We Keep Coding

Python CLR Winforms - Passing data between .NET Winforms

I have a fairly simple task that has eluded me when using Python to generate and automate .NET WinForms. How do I pass data between forms?
I've tried everything: using global variables, using immutable strings, etc. and nothing seems to stick. Can someone show me an example, send me a link, or let me know what I am doing wrong? I have been at this for over a week and frustration is starting to mount.
Below is a (sloppy) example of taking data from one form - a string - and sending it to another form in a Textbox.
MYSTRING = ''
import clr
clr.AddReference("System.Windows.Forms")
clr.AddReference("System.Drawing")
from System.Windows.Forms import *
from System.Drawing import *
class MyForm(Form):
def __init__(self):
self.Text1 = TextBox()
self.Button1 = Button()
self.Button1.Location = Point(0, self.Text1.Bottom + 10)
self.Button1.Text = 'Send'
self.Controls.Add(self.Text1)
self.Controls.Add(self.Button1)
self.Button1.Click += self.Button1_Click
def Button1_Click(self, sender, args):
MYSTRING = self.Text1.Text
self.TopLevel = False
f2 = MyForm2()
f2.Show()
self.TopLevel = True
class MyForm2(Form):
def __init__(self):
self.Text2 = TextBox()
self.Controls.Add(self.Text2)
self.Load += self.MyForm2_Load
def MyForm2_Load(self, sender, args):
self.Text2.Text = MYSTRING
Application.EnableVisualStyles()
Application.SetCompatibleTextRenderingDefault(False)
Application.Run(MyForm())

So, I figured it out...again.
I had to set a python global variable within one of my events that triggers an event, like so...
def dgvExpanderInfo_CellDoubleClick_Event(self, sender, args):
global SelectedExpanderData_List
...
...then I could access whatever is in that globabl variable - in this case it was a list.
def MyForm2_Form_Load_Event(self, sender, args):
self.textbox1.Text = SelectedExpanderData_List[0]
self.textbox2.Text = SelectedExpanderData_List[1]
self.textbox3.Text = SelectedExpanderData_List[2]
...
I hope this helps others as I have found no real documentation on this anywhere.

Classes interacting each other

i wants to make one class interact in another through a function.
a button that when clicked, add 1. But when I make the interaction, there is an error saying that Resources has not been defined
this is what i'm tring, but nothing seens to happens
from tkinter import *
class Caracteristicas:
def __init__(self,master):
self.caracteristicas = Frame(master)
self.caracteristicas.grid(row=1,column=0)
self.forca = Label(self.caracteristicas, text='FORÇA FÍSICA')
self.forca.grid(row=0,column=0)
self.show_forca = Label(self.caracteristicas,text='1')
self.show_forca.grid(row=0,column=1)
self.b_forca = Button(self.caracteristicas,text='+',command=self.ad_for)
self.b_forca.grid(row=0,column=2)
self.Forca = 1
def ad_for(self):
global Forca
self.Forca += 1
Vida = self.Forca + 10
self.show_forca['text'] = self.Forca
Recursos.show_ferimentos['text'] = Vida
class Recursos:
def __init__(self, master):
self.recursos = Frame(master)
self.recursos.grid(row=1,column=1)
self.ferimentos = Label(self.recursos, text='FERIMENTOS')
self.show_ferimentos = Label(self.recursos, text='10')
self.ferimentos.grid(row=0,column=0)
self.show_ferimentos.grid(row=1,column=0)
ficha = Tk()
a = Caracteristicas(ficha)
b = Recursos(ficha)
ficha.mainloop()
I would like to know how to make the interaction between the Characteristicsclass and theResources class
I managed to solve the previous problem however, another appeared. This is my main program, and the solution proposed does not work in this case.
from tkinter import *
from Caracteristicas import Caracteristicas
from Recursos import Recursos
ficha = Tk()
a = Caracteristicas(ficha)
b = Recursos(ficha)
ficha.mainloop()
in the case they are different documents to be used in the main

If you have instances of two classes and you need function in one of them to modify data or call methods on the other, you usually will want to pass a reference to the other object into the one that is going to interact with it.
In your code, that probably means you should pass your reference to the Recursos instance into the constructor of you Caracteristicas object, where it can be used later.
Here's a very abbreviated version of what that could look like:
class Caracteristicas:
def __init__(self, master, resource):
self.resource = resource # save value for later
... # the rest of the constructor can be the same
def ad_for(self):
self.Forca += 1
Vida = self.Forca + 10
self.show_forca['text'] = self.Forca
self.resource.show_ferimentos['text'] = Vida # main change is here!
You also need to change the code where you create your objects, to something like:
b = Recursos(ficha)
a = Caracteristicas(ficha, b) # pass the reference to the resource object in

Get selected object from ListBox (binded to ListStore) in Python GTK

I have made a simple GTK music player with ListBox (as playlist).
This is GObject class, which i use to bind to ListBox (using bind_model() method) and ListStore.
import eyed3
from gi.repository import Gio, GObject
class Song(GObject.GObject):
path = GObject.Property(type=str)
name = GObject.Property(type=str)
def __init__(self, path):
GObject.GObject.__init__(self)
self.path = path
self.file = eyed3.load(path)
self.name = self
def __str__(self):
return str(self.file.tag.artist) + ' - ' + str(self.file.tag.title)
playlist = Gio.ListStore().new(Song)
And this is how I bind ListStore to ListBox:
play_listbox.connect('row-selected', self.on_row_selected)
playlist.append(Song('/home/user/Downloads/Some album/01 - Song1.mp3'))
playlist.append(Song('/home/user/Downloads/Some album/02 - Song2.mp3'))
play_listbox.bind_model(playlist, self.create_song_label)
def create_song_label(self, song):
return Gtk.Label(label=song.name)
And so far, everything works like it should.
The question is: Is it possible to retrieve Song object (stored in playlist) based on selection? To retrieve path property stored in that object?
If not, is it possible to at least retrieve selection text? Trying this with
def on_row_selected(self, container, row):
print(row.widget.label)
Gives a traceback:
Traceback (most recent call last):
File "/home/user/Documents/App/player.py", line 45, in on_row_selected
print(row.widget.label) # or data, value, text - nothing works
RuntimeError: unable to get the value
row variable is of type
<Gtk.ListBoxRow object at 0x7f9fe7604a68 (GtkListBoxRow at 0x5581a51ef7d0)>
So above code, I think, should work like a charm... but it doesn't.
Thank you very much for any help provided!

So you need to assign the selection with:
treeview_selection = treeview.get_selection()
And connect it with the 'changed' signal:
treeview_selection.connect('changed', on_tree_selection_changed)
Then you can fetch the required data with:
def on_tree_selection_changed(self, treeview):
model, treeiter = treeview.get_selected()
if treeiter is not None:
print(model[treeiter][0]) # you should a list index to get the data you require for each row - first column = [0], second column = [1] etc.
I would suggest you read the pgi docs and also the python Gtk docs

Is it possible to retrieve Song object (stored in playlist) based on selection? To retrieve path property stored in that object?
def on_row_selected(self, container, row):
song = playlist.get_item(row.get_index())
If not, is it possible to at least retrieve selection text?
def on_row_selected(self, container, row):
name = row.get_child().get_text()
Here is an example. You could also use the selected-rows-changed signal if you have to deal with multiple selections:
import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk, Gio, GObject
import sys
class Song(GObject.GObject):
path = GObject.Property(type=str)
name = GObject.Property(type=str)
def __init__(self, path, name):
GObject.GObject.__init__(self)
self.path = path
self.name = name
class GUI:
def __init__(self):
self.playlist = Gio.ListStore()
self.playlist.append(Song("path1", "name1"))
self.playlist.append(Song("path2", "name2"))
self.playlist.append(Song("path3", "name3"))
play_listbox = Gtk.ListBox()
play_listbox.set_selection_mode(Gtk.SelectionMode.SINGLE)
play_listbox.bind_model(self.playlist, self.create_widget_func)
play_listbox.connect('row-selected', self.on_row_selected_1)
play_listbox.connect('row-selected', self.on_row_selected_2)
play_listbox.connect('selected-rows-changed', self.on_selected_rows_changed)
window = Gtk.Window()
window.add(play_listbox)
window.connect("destroy", self.on_window_destroy)
window.show_all()
def create_widget_func(self, song):
return Gtk.Label(label = song.name)
def on_row_selected_1(self ,container, row):
print("on_row_selected_1")
song = self.playlist.get_item(row.get_index())
print(song.path)
def on_row_selected_2(self ,container, row):
print("on_row_selected_2")
print(row.get_child().get_text())
def on_selected_rows_changed(self, container):
print("on_selected_rows_changed", len(container.get_selected_rows()), "item(s) selected")
for row in container.get_selected_rows():
song = self.playlist.get_item(row.get_index())
print(song.name, song.path)
print("---")
def on_window_destroy(self, window):
Gtk.main_quit()
def main():
app = GUI()
Gtk.main()
if __name__ == "__main__":
sys.exit(main())

How to kill the sleeping thread and the main process instantly?

I've wrote an little app to scroll an stock market ticker into a Tkinter window and update the stock values every minute using a threading class.
If I closed the window the main process didn't stops, then I've implemented a method to close the window and stop the thread. But when I close the window the main process delay the stopping to the next call to the theading.run() method.
How can I get that an instant closing process?
The code:
# -*- coding: UTF-8 -*-
import tkinter as tk
import tkinter.messagebox
import time
import threading
from random import randint as randint, uniform as randlimit
# Here starts the program working process, until here was the GUI
# CONSTANTS
CHAR_UP = "\u25B2"
CHAR_DOWN = "\u25BC"
CHAR_EVEN = "="
UPDATE_TIME = 60
# INITIAL DATA, this must be changed to implement the load of a external source
stock_market = [["GOOG", "587.25", CHAR_UP, "(+12.14)"],
["AAPL", "237.14", CHAR_UP, "(+7.25)"],
["GTAT", "87.47", CHAR_DOWN, "(-1.18)"],
["KNDI", "167.32", CHAR_UP, "(+6.85)"],
["ORCL", "482.91", CHAR_DOWN, "(-24.65)"],
["FBOK", "327.67", CHAR_DOWN, "(-11.78)"],
["TWTR", "842.41", CHAR_UP, "(+15.45)"]]
class AplicationTkinter(tk.Frame):
"""
Class of tkinter.Frame subclass, Initializes the GUI
constants:
SPEED, the delay in millisecs of the scroll
attributes:
parent, the root Tk object
"""
SPEED = 250
def __init__(self, parent):
tk.Frame.__init__(self, parent)
self.parent = parent
self._initGUI()
self._scroll_ticker()
self.parent.protocol("WM_DELETE_WINDOW",self.stop)
# or toplevel.protocol(...
def _initGUI(self):
"""
initGUI, draws the layout.
"""
# changes the window icon
self.parent.iconbitmap("tabla.ico")
self.parent.title("Stock Exchange Ticker")
# fix a status bar at the bottom of the window, for future improvements
self.status_bar = tk.Label(self.parent, text="", bd=1, relief=tk.SUNKEN,
anchor=tk.W)
self.status_bar.pack(side=tk.BOTTOM, fill=tk.X)
# content Frame for entry, for future improvements
self.frame = tk.Frame(self.parent)
self.frame.pack()
self.var_entry = tk.StringVar()
self.entry = tk.Entry(self.frame, textvariable=self.var_entry)
self.entry.pack()
self.var_entry.set("a default value")
str_ent_1 = self.entry.get()
# content LabelFrame to show the ticker scrolling line of text
self.label_frame = tk.LabelFrame(self.parent,
text="Ventana de Resultados")
self.label_frame.pack()
# creates an instance of the StockMarket class for contents the data
self.market_one = StockMarket(stock_market)
# the scrolling line of Text for show the data
self.txt_ticker_widget = tk.Text(self.label_frame, background='black',
height=1, width=56, wrap="none")
self.txt_ticker_widget.pack(side=tk.TOP, fill=tk.X)
self.txt_ticker_widget.tag_configure("up", foreground="green")
self.txt_ticker_widget.tag_configure("down", foreground="red")
self.txt_ticker_widget.tag_configure("even", foreground="white")
self.tag = {CHAR_DOWN: "down", CHAR_EVEN: "even", CHAR_UP: "up"}
def _scroll_ticker(self):
"""
scroll_ticker, inserts character by character in the Text widget
"""
self.txt_ticker_widget.configure(state=tk.NORMAL)
self.txt_ticker_widget.insert(tk.END,
self.market_one.get_next_character(),
self.tag[self.market_one.get_tag()])
# TODO simplify
self.txt_ticker_widget.see(tk.END)
self.txt_ticker_widget.configure(state=tk.DISABLED)
self.txt_ticker_widget.after(self.SPEED, self._scroll_ticker)
# recursive each interval of millisecs, constant SPEED
def stop(self):
if tk.messagebox.askokcancel("Quit?", "Are you sure you want to quit?"):
# self.destroy()
print("STOPPING !!")
self.market_one.thread_updating.stop()
self.destroy()
self.parent.quit()
class StockTicker():
"""
Class StockTicker, handle each stock symbol and their data
attributes:
symbol, string, the abbreviature of the securitie
price, string, the current price of the securitie
direction, string(1), is a character that indicates its las fix price
went up, down or even
change, string, is the value of the last change surrounded by '()',
the first character is '+' or '-'
"""
def __init__(self, list_data):
self.symbol, self.price, self.direction, self.change = list_data
def update_ticker(self):
"""
update_ticker, update the securitie price, direction and
change with random values
"""
flt_price = float(self.price)
if randint(0, 9) == 0:
self.direction = CHAR_EVEN
else:
increase_percent = randlimit(-5, 5)
# TODO implementar normalvariate(0, 0.02) o gauss(0, 0.02)
flt_change = flt_price * increase_percent / 100
flt_new_price = flt_price + flt_change
self.price = "{:.2f}".format(flt_new_price)
if flt_change < 0:
self.direction = CHAR_DOWN
elif flt_change == 0:
self.direction = CHAR_EVEN
else:
self.direction = CHAR_UP
self.change = "({:+.2f})".format(flt_change)
def ticker_to_text(self):
"""
ticker_to_text, returns a formatted string with all the data of
the securitie.
"""
return " | {} {} {} {} ".format(self.symbol, self.price,
self.direction, self.change)
class StockMarket():
"""
Class StockMarket, creates and handle a list of StockTicker objects,
and provide to the GUI of stuff for the scroll ticker
attributes:
smarket, list of StockTicker objects
thread_actualizar, Thread object to update the stock market
each time interval
"""
def __init__(self, l_inicial):
self.tickers = []
self.index = 0
self._load(l_inicial)
self.current_ticker = self._get_one_ticker()
self.thread_updating = UpdateThread(self)
self.thread_updating.start()
def _load(self, l_inicial):
"""
load_market, load the list with StockTicker object taking the data from
the initial source data.
"""
for data_ticker in l_inicial:
simple_ticker = StockTicker(data_ticker)
self.tickers.append(simple_ticker)
def update_market(self):
"""
update_market, update the objects of the list
"""
for ticker in self.tickers:
ticker.update_ticker()
def _get_one_ticker(self):
"""
get_one_ticker, getter function to return one securitie data in text
format and rotates to the next one
"""
self.one_ticker = self.tickers.pop(0)
self.tickers.append(self.one_ticker)
self.index = 0
return self.one_ticker.ticker_to_text()
def get_next_character(self):
"""
get_next_character, returns a character of one securitie
(if the securitie data is exhausted retrieve another securitie)
data to the GUI.
"""
if self.index == len(self.current_ticker):
self.current_ticker = self._get_one_ticker()
self.index = 0
character_symbol = self.current_ticker[self.index:self.index+1]
self.index += 1
return character_symbol
def get_tag(self):
return self.one_ticker.direction
class UpdateThread(threading.Thread):
"""
Class UpdateThread(), subclass of Thread, handle the time to the next
update of the stock market values
args:
market_1, a StockMarket class object to update
attributes:
my_check, string for debugging purpouses, it'll be implemented the
source data management the_market, StockMarket object that will
be updated
"""
def __init__(self, market_1):
self.my_check = " CHECK " # TODO replace with initial source data.
self.the_market = market_1
self.is_quit = False
threading.Thread.__init__(self)
def run(self):
"""
run, overrides the Thread run method, and calls the update_market
method of StockMarket class each interval
"""
time.sleep(UPDATE_TIME)
self.the_market.update_market()
print(" UPDATED!!!") # for debugging
if not self.is_quit:
self.run()
def stop(self):
"""
stop, for stopping the thread when event occurs
"""
self.is_quit = True
# STARTS THE PROGRAM
def main():
the_window = tk.Tk()
aplication = AplicationTkinter(the_window)
# init the GUI process
the_window.mainloop()
if __name__ == '__main__':
main()

libavg custom event handler

I'm trying to find a way to use libavg's event handlers from an embedded serial output. My understanding is that I need to create my own Publisher that I will call when I process serial commands. All I need is a way to create 10 different triggers given different serial inputs. An analogy of what I am trying to do would be to use libavg's keyboard handling to process different keyboard inputs.
I want the custom publisher to take the 10 serial outputs and pass a event.serialid parameter to various subscribers similarly to what event.keystring does.
Here is some nonfunctional code that I have that I think has the basics of what needs to be done.
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from libavg import avg, statemachine, player
class Test():
PRESSED = avg.Publisher.genMessageID()
RELEASED = avg.Publisher.genMessageID()
def __init__(self, parent=None, **kwargs):
self.registerInstance(self, parent)
self.publish(self.PRESSED)
self.publish(self.RELEASED)
def isActive(self):
self.notifySubscribers(Test.PRESSED, [])
def isInactive(self):
self.notifySubscribers(Test.RELEASED, [])
def onKeyDown(event):
global node
if event.serialid == '1':
#serialid isn't implemented anywhere but this is what ideally I would like to have happen
node.color = "FF8000"
def onKeyUp(event):
global node
node.color = "FFFFFF"
player = avg.Player.get()
canvas = player.createMainCanvas(size=(640,480))
rootNode = player.getRootNode()
node = avg.WordsNode(pos=(10,10), font="arial", text="Hello World", parent=rootNode)
vbutton=Test()
node.subscribe(vbutton.PRESSED, onKeyDown)
node.subscribe(vbutton.RELEASED, onKeyUp)
player.play()
examples of custom publishers from here:
class _ButtonBase(avg.DivNode):
PRESSED = avg.Publisher.genMessageID()
RELEASED = avg.Publisher.genMessageID()
def __init__(self, parent=None, **kwargs):
super(_ButtonBase, self).__init__(**kwargs)
self.registerInstance(self, parent)
self.publish(self.PRESSED)
self.publish(self.RELEASED)
def _setActiveArea(self, upNode, activeAreaNode, fatFingerEnlarge):
self.__activeAreaNode = activeAreaNode
if fatFingerEnlarge:
if self.__activeAreaNode != None:
raise(RuntimeError(
"Button: Can't specify both fatFingerEnlarge and activeAreaNode"))
size = upNode.size
minSize = 20*player.getPixelsPerMM()
size = avg.Point2D(max(minSize, size.x), max(minSize, size.y))
self.__activeAreaNode = avg.RectNode(size=size, opacity=0, parent=self)
else:
if self.__activeAreaNode == None:
self.__activeAreaNode = self
else:
self.appendChild(self.__activeAreaNode)
self._tapRecognizer = gesture.TapRecognizer(self.__activeAreaNode,
possibleHandler=self._onDown,
detectedHandler=self._onTap,
failHandler=self._onTapFail)

You can pass arbitrary parameters through the publish-subscribe interface. The parameter(s) are passed as a list:
self.notifySubscribers(Test.PRESSED, [serialID])
And in the handler:
def onKeyDown(serialID):
global node
if serialid == '1':
node.color = "FF8000"