def __init__(self, *args, **kwargs):
self.__i_range = i_range = kwargs.pop('i_range')
self.__q_range = q_range = kwargs.pop('q_range')
Frame.__init__(self, *args, **kwargs)
Observable.__init__(self)
self.__canvas = canvas = ComplexCanvas(self)
canvas.grid(row=0, column=0, sticky='wens')
canvas['bg'] = 'black'
self.__q_slider = q_slider = Scale(self, from_=q_range, to=-q_range, orient='vertical')
q_slider.grid(row=0, column=1, sticky='e')
self.__i_slider = i_slider = Scale(self, from_=-i_range, to=i_range, orient='horizontal')
i_slider.grid(row=1, column=0, sticky='s')
self.grid_rowconfigure(0, weight=1)
self.grid_columnconfigure(0, weight=1)
self.__pad = 10
self.__width = 0
self.__height = 0
self.__center = None
self.__radius = 0
self.__bbox = None
self.__complex_magnitude = 0 + 0j
canvas.bind('<Configure>', self._on_resize)
self.__borderBox = canvas.create_rectangle(0, 0, 10, 10, outline='green')
self.__borderCircle = canvas.create_oval(0, 0, 10, 10, outline='green', dash=[1, 2])
self.__middleCircle = canvas.create_oval(0, 0, 10, 10, outline='green', dash=[1, 2])
self.__vLine = canvas.create_line(0, 0, 10, 10, fill='green', dash=[1, 2])
self.__hLine = canvas.create_line(0, 0, 10, 10, fill='green', dash=[1, 2])
self.__dLine = canvas.create_line(0, 0, 10, 10, fill='green', dash=[1, 2])
self.__cdLine = canvas.create_line(0, 0, 10, 10, fill='green', dash=[1, 2])
self.__scale_circles = []
for k in range(60):
if k % 5 == 0:
color = 'gold'
else:
color = 'green'
self.__scale_circles.append(canvas.create_oval(0, 0, 10, 10, fill=color))
self.__indicator1 = self.Indicator(self, solid=False)
self.__indicator2 = self.Indicator(self)
canvas.bind('<Motion>', self._on_mouse_move)
canvas.bind('<Button-1>', self._on_click)
i_slider['command'] = self._on_iq_scale
q_slider['command'] = self._on_iq_scale
def __init__(self, master, **kw):
super().__init__(master)
# self.grid_propagate(0)
# self.columnconfigure(0, weight=1)
# self.rowconfigure(0, weight=1)
self.var = kw.get('variable', IntVar())
kw['variable'] = self.var
kw['from_'] = ConfidenceLevel.Low.value
kw['to'] = ConfidenceLevel.VeryHigh.value
# kw['command'] = self.scale_change
kw['orient'] = HORIZONTAL
self.lbl_scale = Label(self)
self.scale = Scale(self, **kw)
self.scale_font = tkfont.nametofont(Style().lookup('TLabel',
'font')).copy()
self.scale_font.config(weight=tkfont.BOLD, size=9)
self.lbl_scale.config(font=self.scale_font, width=3, anchor=CENTER)
self.var.trace_variable('w', lambda a, b, c: self.scale_change())
self.scale.grid(row=0, column=0, sticky='ns')
self.lbl_scale.grid(row=0, column=1, sticky='ns', padx=(3, 0))
def make_slider(self, name, valmin, valmax, valinit, valfmt, label, forceint):
from tkinter import IntVar, DoubleVar, StringVar
from tkinter.ttk import Label, Scale, Frame
if self.slider_frame is None:
frame = self.slider_frame = Frame(self.widget_frame, )
else:
frame = self.slider_frame
if forceint:
v = IntVar(self.widget_frame)
else:
v = DoubleVar(self.widget_frame)
s = self._scales[name] = Scale(frame, variable=v, from_=valmin, to=valmax, length=250)
num_sv = StringVar(self.widget_frame)
def label_callback(*args):
num_sv.set(valfmt % v.get())
v.trace_variable('w', label_callback)
nl = self._labels[name + 'num'] = Label(frame, textvariable=num_sv, width=6, anchor='e')
tl = self._labels[name + 'text'] = Label(frame, text=label if label is not None else name, anchor='w')
v.set(valinit)
nl.grid(column=0, row=self.slider_row, sticky='e')
s.grid(column=1, row=self.slider_row)
tl.grid(column=2, row=self.slider_row, sticky='w')
self.slider_row += 1
frame.pack()
return TkWidgetWrapper(s, forceint)
def __init__(self, w, *args, **kwargs):
super().__init__(w, *args, **kwargs)
#___
self.state_txt_time1 = StringVar()
self.state_txt_time1.set(INIT_TIME)
self.txt_time1 = Label(self,
textvariable=self.state_txt_time1,
background=config.colors["BG"],
font=font.nametofont("font_small_size"))
self.txt_time1.grid(row=0, column=0, sticky="sw")
#___
self.state_txt_song = StringVar()
self.state_txt_song.set(INIT_SONG)
self.txt_song = Label(self,
textvariable=self.state_txt_song,
background=config.colors["BG"])
self.txt_song.grid(row=0, column=1, pady=(0,2))
#___
self.state_txt_time2 = StringVar()
self.state_txt_time2.set(INIT_TIME)
self.txt_time1 = Label(self,
textvariable=self.state_txt_time2,
background=config.colors["BG"],
font=font.nametofont("font_small_size"))
self.txt_time1.grid(row=0, column=2, sticky="se")
#___
self.state_scale_time = DoubleVar()
self.scale_time = Scale(self,
orient="horizontal",
length=300,
from_=0, to_=100,
value=0, variable=self.state_scale_time)
self.scale_time.grid(row=1, column=0, columnspan=3)
#___
#Set time when direct click on the timeline
self.scale_time.bind("<Button-1>", self._setTimeDirect)
#___
self.song_playing = None
def __init__(self, root):
#Properties of the objects
self.root = root
self.root.title("Paint")
self.root.geometry("800x520")
self.root.configure(background="white")
self.root.resizable(0, 0)
# Important things
self.pen_color = "black"
self.eraser_color = "white"
#Adding widgets to tkinter window
self.color_frame = LabelFrame(self.root, text="color", font = ("arial", 15), bd=5, relief=RIDGE, bg="white")
self.color_frame.place(x=0, y=0, width=70, height=185)
colors = ["#000000","#FFFFFF" , "#FF0000", "#00FF00", "#0000FF", "#FFFF00", "#00FFFF", "#FF00FF", "#C0C0C0", "#808080", "#800000", "#808000", "#008000", "#800080", "#008080", "#000080"]
i=j=0
for color in colors:
Button(self.color_frame, bg=color, bd=2, relief=RIDGE, width=3, command=lambda col =color:self.select_color(col)).grid(row=i, column=j)
i+=1
if i==6:
i=0
j=1
self.eraser_button = Button(self.root, text="ERASER", bg="white", bd=4, command=self.eraser, width=8, relief=RIDGE)
self.eraser_button.place(x=0, y=187)
self.clear_button = Button(self.root, text="CLEAR", bg="white", bd=4, command=lambda : self.canvas.delete("all"), width=8, relief=RIDGE)
self.clear_button.place(x=0, y=217)
self.save_button = Button(self.root, text="SAVE", bg="white", bd=4, command=self.save_paint, width=8, relief=RIDGE)
self.save_button.place(x=0, y=247)
self.canvas_color_button = Button(self.root, text="CANVAS", bg="white", bd=4, command=self.canvas, width=8, relief=RIDGE)
self.canvas_color_button.place(x=0, y=277)
#Creating a scale for pen and eraser size
self.pen_size_scale_frame = LabelFrame(self.root, text="size", bd=5, bg="white", font=("arial", 15, 'bold'), relief=RIDGE)
self.pen_size_scale_frame.place(x=0, y=310, height=200, width=70)
self.pen_size = Scale(self.pen_size_scale_frame, orient=VERTICAL, from_=50, to_=0, length=170)
self.pen_size.set(1)
self.pen_size.grid(row=0, column=1, padx=15)
#Creating Canvas
self.canvas = Canvas(self.root, bg="white", bd=5, relief=GROOVE, height=500, width=700)
self.canvas.place(x=80, y=0)
#Bind the canvas with mouse drag
self.canvas.bind("<B1-Motion>", self.paint)
def _criar_scale(self):
'''
Criar widget Scale.
'''
self._scale = Scale(self, from_=self.MINIMO,
to=self.MAXIMO,
orient='horizontal')
self._scale['command'] = lambda e: \
self.set_atual(self._scale.get(), widget=self._scale)
self._scale.pack(side='left', fill='x', anchor='center', expand=True, )
def __init__(self, master, **kw):
self.__multiplyValue = kw.pop("multiplyValue", False)
twoRows = kw.pop("twoRows", False)
kw["columns"] = 1 if twoRows else 3
kw["rows"] = 1
valueIsNone = "value" not in kw
SmartWidget._setVariable(kw, "IntVar")
self.__frame = Frame(master) if twoRows else None
super().__init__(master, **kw)
if self.__frame:
master = self.__frame
# = Step = #
self.__step = kw.get("step", 1)
# = Caption = #
self.__caption = Label(master, text=kw["text"])
self.__valueLabel = Label(master, anchor=E)
# = Scale = #
self.getRawValue().trace_add("write", self.onChanged)
storage = self._getValueStorage()
for index, key in enumerate(("from_", "to")):
if key in storage:
kw["range"][index] = storage[key]
self.getRawValue().set(
StaticUtils.setIfAbsentAndGet(
storage, "value",
(kw["range"][0] if valueIsNone else self.getValue()) //
self.__step))
from_, to = tuple(v // self.__step for v in kw["range"])
self.__scale = Scale(master,
from_=from_,
length=400,
to=to,
variable=self.getRawValue())
if "state" in kw:
self.__scale["state"] = kw["state"]
self.__setValueWidth()
def __init__(self):
self.root= Tk()
self.root.title("My Paint")
self.root.geometry("800x500")
self.size=Canvas(self.root, width=800, height=500)
self.root.configure(bg="white")
self.pen_color="black"
self.eraser_color="white"
self.color_frame=LabelFrame(self.root, text="Color", font=('arial', 15, 'bold'), bd=5, relief=RIDGE, bg="#6FA5F5")
self.color_frame.place(x=10, y=400, width=240, height=90)
colors=['white', 'black', 'brown','red', 'orange','yellow','green', 'blue', '#3E1C91', '#F20A85']
i=j=0
for color in colors: #col is value of color
Button(self.color_frame, bg=color, bd=2, relief=RIDGE, width=5, command=lambda col= color: self.select_color(col)).grid(row=i, column=j)
j+=1
if j==5:
j=0
i=1
self.edit_color_button=Button(self.root, text="Edit Color",font=('arial', 11, 'bold'), bd=3, bg="#6FA5F5", command=self.edit_color, width=12,height=2, relief=RIDGE)
self.edit_color_button.place(x=255, y=400)
self.eraser_button=Button(self.root, text="Eraser",font=('arial', 11, 'bold'), bd=3, bg="#6FA5F5", command=self.eraser, width=12,height=2, relief=RIDGE)
self.eraser_button.place(x=255, y=445)
self.clear_button=Button(self.root, text="Clear",font=('arial', 11, 'bold'), bd=3, bg="#6FA5F5", command=lambda : self.canvas.delete("all"), width=12,height=2, relief=RIDGE)
self.clear_button.place(x=355, y=400)
self.save_button=Button(self.root, text="Save",font=('arial', 11, 'bold'), bd=3, bg="#6FA5F5", command=self.save_paint, width=12,height=2, relief=RIDGE)
self.save_button.place(x=355, y=445)
self.pen_size_scale_frame=LabelFrame(self.root, text="size", bd=5, bg="#6FA5F5", font=('areal',15,'bold'), relief=RIDGE)
self.pen_size_scale_frame.place(x=480, y=400, height=70, width=250)
self.pen_size=Scale(self.pen_size_scale_frame, orient=HORIZONTAL, from_=0, to=50, length=220)
self.pen_size.set(1)
self.pen_size.grid(row=0, column=1, padx=15)
self.canvas=Canvas(self.root, bg='white', bd=5, relief=GROOVE, height=380, width=787)
self.canvas.place(x=0, y=0)
#self.setup()
self.canvas.bind('<B1-Motion>', self.paint)
self.root.mainloop()
def initUI(self):
self.master.title("Scale")
self.style = Style()
self.style.theme_use("default")
self.pack(fill=BOTH, expand=1)
scale = Scale(self, from_=0, to=100, command=self.on_scale)
scale.pack(side=LEFT, padx=15)
self.var = IntVar()
self.label = Label(self, text=0, textvariable=self.var)
self.label.pack(side=LEFT)
def __init__(self, root):
self.root = root
self.root.title("paint")
self.root.geometry("800x520")
self.root.configure(background="white")
self.root.resizable(0,0)
self.pen_color = "black"
self.eraser_color = "white"
#adding widges to paint
self.color_frame = LabelFrame(self.root,text='Color',font = ('Times New Roman',15),bd=5,relief=RIDGE,bg="white")
self.color_frame.place(x=0,y=0,width=70,height=195)
colors = ['red','black','pink','blue','grey','cyan','brown','yellow','purple','hotpink','green','olive','plum','indigo']
i=j=0
for color in colors:
Button(self.color_frame,bg=color,bd=1,relief=RIDGE,width=3,command=lambda col =color:self.select_color(col)).grid(row=i,column=j)
i+=1
if i==7:
i=0
j+=1
self.eraser_button = Button(self.root,text="ERASER",bd=4,bg="white",command=self.eraser,width=8,relief=RIDGE)
self.eraser_button.place(x=0,y=192)
self.clear_button = Button(self.root, text="CLEAR", bd=4, bg="white", command=lambda : self.canvas.delete("all"), width=8, relief=RIDGE)
self.clear_button.place(x=0, y=222)
self.save_button = Button(self.root, text="SAVE", bd=4, bg="white", command=None, width=8, relief=RIDGE)
self.save_button.place(x=0, y=252)
self.canvas_color_button = Button(self.root, text="FILL", bd=4, bg="white", command=self.canvas_color, width=8, relief=RIDGE)
self.canvas_color_button.place(x=0, y=282)
#creating a Scale for pen and Eraser Size
self.pen_size_scale_frame = LabelFrame(self.root,text="size",bd=5,bg="white",font=('Times New Roman',15,'bold'),relief=RIDGE)
self.pen_size_scale_frame.place(x=0,y=313,height=200,width=70)
self.pen_size = Scale(self.pen_size_scale_frame,orient=VERTICAL,from_=50,to=0,length=170)
self.pen_size.set(1)
self.pen_size.grid(row=0,column=1,padx=15)
#creating canvas
self.canvas = Canvas(self.root,bg="white",bd=5,relief=GROOVE,height=500,width=700)
self.canvas.place(x=80,y=0)
#bind canvas with mouse drag
self.canvas.bind("<B1-Motion>",self.paint)
def initUI(self):
self.master.title("Scale")
self.style = Style()
self.style.theme_use("default")
self.pack(fill=BOTH, expand=True)
self.scale = Scale(self, from_=0, to=100, command=self.onScale)
self.scale.grid(row=0, column=0, padx=10, pady=10, sticky=E + W)
self.var = IntVar()
self.label = Label(self, text=0, textvariable=self.var)
self.label.grid(row=0, column=1, sticky=W, padx=10)
self.grid_columnconfigure(0, weight=1)
def __init__(self, *args, **kwargs):
default_range = kwargs.pop("default_range", (60, 90))
super().__init__(*args, **kwargs)
color_list = ["green", "yellow"]
label_list = []
scale_list = []
range_list = [*default_range]
def on_scale0(value):
value = int(float(value))
if value > range_list[1]:
scale_list[1].set(value)
label_list[1]["text"] = f"{value: 3d}%"
range_list[0] = value
label_list[0]["text"] = f"{value: 3d}%"
def on_scale1(value):
value = int(float(value))
if value < range_list[0]:
scale_list[0].set(value)
label_list[0]["text"] = f"{value: 3d}%"
range_list[1] = value
label_list[1]["text"] = f"{value: 3d}%"
callback_list = [on_scale0, on_scale1]
for index in range(2):
frame = Frame(self)
frame.pack(expand="yes", fill="x")
label = Label(frame,
bg=color_list[index],
text=f"{default_range[index]: 3d}%",
width=5)
label.pack(side="left")
label_list.append(label)
scale = Scale(frame,
from_=0,
to=100,
value=default_range[index],
orient="horizontal",
command=callback_list[index])
scale.pack(side="left", fill="x", expand="yes")
scale_list.append(scale)
self.__scale_list = scale_list
def _create_bottomframe(self) -> None:
self.bottomframe = Frame(self.rightframe)
self.bottomframe.pack()
self.mutePhoto = PhotoImage(file=self.assets_path + '/icons/mute.png')
self.volumePhoto = PhotoImage(file=self.assets_path + '/icons/volume.png')
self.volumeBtn = Button(self.bottomframe, image=self.volumePhoto, command=self.mute_music)
self.volumeBtn.grid(row=0, column=1)
self.rewindPhoto = PhotoImage(file=self.assets_path + '/icons/rewind.png')
rewindBtn = Button(self.bottomframe, image=self.rewindPhoto, command=self.rewind_music)
rewindBtn.grid(row=0, column=0)
self.scale = Scale(self.bottomframe, from_=0, to=100, orient=HORIZONTAL, command=self.set_vol)
self.scale.set(self.init_vol)
mixer.music.set_volume(self.init_vol / 100)
self.scale.grid(row=0, column=2, pady=15, padx=30)
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
self.imageName = ""
self.w = Scale(parent, from_=1, to=100, orient=HORIZONTAL)
self.w.place(x=600, y=140)
self.w.set(100)
GPIO.setup(self.Motor1A, GPIO.OUT)
GPIO.setup(self.Motor1B, GPIO.OUT)
GPIO.setup(self.Motor1E, GPIO.OUT)
GPIO.setup(self.Motor2A, GPIO.OUT)
GPIO.setup(self.Motor2B, GPIO.OUT)
GPIO.setup(self.Motor2E, GPIO.OUT)
self.initUI()
def _create_master(self):
output_device = self.player.get_output_device()
master_frame = LabelFrame(self,
text="Master",
relief=tkinter.GROOVE,
borderwidth=5)
Label(master_frame, text="Volume").pack()
vol_tracker = tkinter.DoubleVar()
vol_tracker.set(self.player.volume)
Scale(
master_frame,
variable=vol_tracker,
from_=1.0,
to=0.0,
orient=tkinter.VERTICAL,
command=self.player.set_volume,
).pack()
Label(master_frame, text=f"Device: {output_device['name']}").pack()
Label(master_frame, text=f"Channels: {self.player.channels}").pack()
Label(master_frame,
text=f"Sample Rate: {output_device['default_samplerate']}Hz"
).pack()
Label(master_frame,
text=f"Block Size: {self.player.stream.blocksize}").pack()
Label(master_frame,
text=f"Latency: {self.player.stream.latency * 1000}ms").pack()
graph_frame = self._create_graph_frame(
master_frame, lambda: self.player.master_sample)
graph_frame.pack()
self.plot_frames.append(graph_frame)
return master_frame
def __init__(self,root):
self.root = root
self.root.title("Paint")
self.root.geometry("800x520")
self.root.configure(background = 'white')
self.root.resizable(0,0)
self.pen_color="black"
self.eraser_color = "white"
#adding widgets to tkinter window
self.color_frame = LabelFrame(self.root,text="Color",font=('arial',15),bd=4,relief=RIDGE,bg="white")
self.color_frame.place(x = 0,y = 0, width =98, height = 195)
colors = ['#ff0000', '#00ff00', '#0000ff' , '#ffff00', '#00ffff', '#ff00ff','#ffffff', '#000000', '#99ffcc', '#ff99cc']
i = j = 0
for color in colors:
Button(self.color_frame,bg = color,bd =2, relief=RIDGE,width=2,command = lambda col=color:self.select_color(col)).grid(row = i, column = j)
i += 1
if i==5:
i = 0
j+=1
self.eraser_button = Button(self.root, text = "Eraser",bd = 4,bg="white",command = self.eraser,width = 8,relief=RIDGE)
self.eraser_button.place(x = 0,y = 207)
self.clear_button = Button(self.root, text = "Clear",bd = 4,bg="white",command = lambda:self.canvas.delete("all"),width = 8,relief=RIDGE)
self.clear_button.place(x = 0,y = 247)
self.canvas_color = Button(self.root, text = "Canvas",bd = 4,bg="white",command = self.canvas,width = 8,relief=RIDGE)
self.canvas_color.place(x = 0,y = 287)
#creating a scale for pen and eraser size..
self.pen_size_scale_frame = LabelFrame(self.root, text="Size", bd=5,bg='white',font=('arial', 15,'bold'),relief=RIDGE)
self.pen_size = Scale(self.pen_size_scale_frame,orient=VERTICAL,from_=50,to=0,length=170)
self.pen_size.set(1)
self.pen_size.grid(row=0,column=1,padx=15)
#creating canvas
self.canvas = Canvas(self.root,bg='white',bd=5,relief=GROOVE, height=488,width=680)
self.canvas.place(x=105,y=7)
self.pen_size_scale_frame.place(x=0,y=325,height=190,width=98)
#bind canvas with mouse drag
self.canvas.bind("<B1-Motion>",self.paint)
def onClick(self):
if self.columns.get() == 0:
self.scale = Scale(self,
from_=1,
to=self.clades.get() - 1,
command=self.onScale,
orient=HORIZONTAL)
self.scale.grid(sticky=W, row=3, column=2)
self.labScale = Label(
self, text="Number of clades in the first column: ")
self.labScale.grid(sticky=W, row=2, column=2)
self.ScaleVal = Label(self, textvariable=self.var)
self.ScaleVal.grid(sticky=E, row=2, column=2)
else:
self.scale.grid_remove()
self.labScale.grid_remove()
self.ScaleVal.grid_remove()
def Sliders(self, txt, value, x, y, bind_func, **kw):
kw = var_check(kw)
self.Labels(txt, x, y, relwidth=0.2)
self.widget_frame.value = DoubleVar()
self.widget_frame.value.set(value)
self.widget_frame.scale = Scale(self.widget_frame,
variable=self.widget_frame.value,
from_=0,
to=value * 10,
orient=kw["slider_orient"])
self.widget_frame.scale.bind("<B1-Motion>", bind_func)
self.widget_frame.scale.place(relx=x + 0.2,
rely=y,
anchor=kw['anchor'],
relwidth=kw['relwidth'],
relheight=kw['relheight'])
return self.widget_frame.value
def initUI(self):
self.master.title("Scale")
self.style = Style()
self.style.theme_use("default")
self.frame = Frame(height=10, width=100, relief=SUNKEN)
self.frame.pack(fill=X, expand=1)
self.frame.grid_columnconfigure(0, weight=1)
self.scale = Scale(self.frame, from_=0, to=100, command=self.onScale)
self.scale.grid(row=0,
column=0,
columnspan=2,
padx=10,
pady=10,
sticky=E + W)
#scale.pack(fill=X, padx=15, expand=1)
#scale.pack(fill=X, padx=15)
self.var = IntVar()
self.label = Label(self.frame, text=0, textvariable=self.var)
self.label.grid(row=0, column=2, sticky=W, padx=10)
def add_widgets(self):
#self.controls.grid(row = 0, column = 0, sticky=NE)
self.color_frame = Frame(self.root, bd=1, relief=RIDGE, bg="white")
#self.color_frame.place(x = 0, y = 0, width = 185, height = 70)
self.color_frame.grid(sticky=NW, row=0, column=0, padx=15, pady=10)
self.color_frame.config(cursor="hand2")
#self.color_frame.pack()
self.palette_image = PhotoImage(file='paint.png')
self.palette_button = Button(self.root,
image=self.palette_image,
command=self.select_palette_color)
#self.canvas_button.place(x = 247, y = 0)
self.palette_button.grid(sticky="W", row=0, column=1, padx=10, pady=10)
self.palette_button.config(cursor="hand2")
self.palette_tooltip = CreateToolTip(
self.palette_button, 'Select a color from the color palette')
colors = [
'black', 'white', '#4d4d4d', 'grey', '#990033', '#993300', 'red',
'pink', 'orange', '#ffcc99', 'yellow', '#ffff99', 'lime',
'#d9ffb3', 'green', '#88cc00', '#0099ff', 'turquoise', '#3333ff',
'#6699cc', 'purple', '#bfbff2'
]
i = j = 0
for color in colors:
Button(self.color_frame,
bg=color,
bd=2,
relief=RIDGE,
height=1,
width=3,
command=lambda col=color: self.select_color(col)).grid(
row=i, column=j)
i += 1
if i == 2:
i = 0
j += 1
self.pencil_image = PhotoImage(file='pencil.png')
self.pencil_button = Button(self.root,
image=self.pencil_image,
command=self.pencil)
#self.pencil.place(x = 0, y = 187)
self.pencil_button.grid(sticky="W", row=1, column=0, padx=16)
self.pencil_button.config(cursor="hand2")
self.pencil_tooltip = CreateToolTip(self.pencil_button, 'Pencil')
self.bg_image = PhotoImage(file='bg.png')
self.bg_button = Button(self.root,
image=self.bg_image,
command=self.bg_color)
self.bg_button.grid(sticky="W", row=2, column=0, padx=16)
self.bg_button.config(cursor="hand2")
self.bg_tooltip = CreateToolTip(self.bg_button,
'Change background color')
self.eraser_image = PhotoImage(file='eraser.png')
self.eraser_button = Button(self.root,
image=self.eraser_image,
command=self.eraser)
#self.eraser.place(x = 0, y = 187)
self.eraser_button.grid(sticky="W", row=3, column=0, padx=16)
self.eraser_button.config(cursor="hand2")
self.eraser_tooltip = CreateToolTip(self.eraser_button, 'Eraser')
self.clear_image = PhotoImage(file='clear.png')
self.clear_button = Button(self.root,
image=self.clear_image,
command=self.clear)
#self.clear.place(x = 0, y = 217)
self.clear_button.grid(sticky="W", row=4, column=0, padx=16)
self.clear_button.config(cursor="hand2")
self.clear_tooltip = CreateToolTip(self.clear_button,
'Clear the canvas area')
self.line_image = PhotoImage(file='line.png')
self.line_button = Button(self.root,
image=self.line_image,
command=self.line)
#self.line.place(x = 0, y = 367)
self.line_button.grid(sticky="W", row=5, column=0, padx=16)
self.line_button.config(cursor="hand2")
self.line_tooltip = CreateToolTip(self.line_button, 'Draw a line')
self.arrow_image = PhotoImage(file='arrow.png')
self.arrow_button = Button(self.root,
image=self.arrow_image,
command=self.arrow)
#self.line.place(x = 0, y = 367)
self.arrow_button.grid(sticky="W", row=6, column=0, padx=16)
self.arrow_button.config(cursor="hand2")
self.arrow_tooltip = CreateToolTip(self.arrow_button, 'Draw an arrow')
self.rectangle_image = PhotoImage(file='rectangle.png')
self.rectangle_button = Button(self.root,
image=self.rectangle_image,
command=self.rectangle)
#self.rectangle.place(x = 0, y = 307)
self.rectangle_button.grid(sticky="W", row=7, column=0, padx=16)
self.rectangle_button.config(cursor="hand2")
self.rectangle_tooltip = CreateToolTip(self.rectangle_button,
'Draw a rectangle')
self.oval_image = PhotoImage(file='oval.png')
self.oval_button = Button(self.root,
image=self.oval_image,
command=self.oval)
#self.oval.place(x = 0, y = 397)
self.oval_button.grid(sticky="W", row=8, column=0, padx=16)
self.oval_button.config(cursor="hand2")
self.oval_tooltip = CreateToolTip(self.oval_button,
'Draw an oval/a circle')
self.undo_image = PhotoImage(file='undo.png')
self.undo_button = Button(self.root,
image=self.undo_image,
command=self.undo)
#self.oval.place(x = 0, y = 397)
self.undo_button.grid(sticky="W", row=9, column=0, padx=16)
self.undo_button.config(cursor="hand2")
self.undo_tooltip = CreateToolTip(self.undo_button, 'Undo')
# creating a scale for pen and eraser size
self.slider = Frame(self.root, bd=3, bg="white", relief=RIDGE)
#self.slider.place(x = 0, y = 400)
self.slider.grid(sticky="W", row=10, column=0, padx=16, pady=20)
self.pen_size = Scale(self.slider,
orient=VERTICAL,
from_=50,
to=0,
length=170)
self.pen_size.set(1)
self.pen_size.grid(sticky="W",
row=10,
column=0,
ipadx=2,
padx=7,
pady=7)
self.slider.config(cursor="hand2")
self.slider_tooltip = CreateToolTip(self.slider, 'Size')
# creating canvas
self.canvas = Canvas(self.root,
relief=GROOVE,
height=self.height_value,
width=self.width_value,
bg="white")
self.canvas.place(x=70, y=75)
# self.canvas.grid(row = 0, column = 1)
# bind the canvas with mouse drag
self.canvas.bind('<B1-Motion>', self.paint)
self.canvas.bind('<ButtonRelease-1>', self.reset)
self.msg = Message(self.root, text=self.choice, width=70, bg="white")
self.msg.grid(sticky="W", row=11, column=0)
menu = Menu(self.root)
self.root.config(menu=menu)
filemenu = Menu(menu)
colormenu = Menu(menu)
menu.add_cascade(label='File', menu=filemenu)
filemenu.add_command(label='Save File', command=self.save_file)
optionmenu = Menu(menu)
menu.add_cascade(label='Options', menu=optionmenu)
optionmenu.add_command(label='Exit', command=self.root.destroy)
def __init__(self, root):
self.root = root
self.root.title("Paint")
self.root.geometry("800x520")
self.root.configure(background="white")
self.root.resizable(0, 0)
self.pen_color = "#000000"
self.color_frame = LabelFrame(self.root,
text="Color",
font=('arial', 15, 'bold'),
bd=5,
relief=RIDGE,
bg='white')
self.color_frame.place(x=0, y=0, width=70, height=185)
Colors = [
'#ff0000',
'#ff4dd2',
'#ffff33',
'#000000',
'#0066ff',
'#660033',
'#4dff4d',
'#b300b3',
'#00ffff',
'#808080',
'#99ffcc',
'#336600',
'#ff9966',
'#ff99ff',
'#00cc99',
]
i = j = 0
for color in Colors:
Button(self.color_frame,
bg=color,
command=lambda col=color: self.select_color(col),
width=3,
bd=2,
relief=RIDGE).grid(row=i, column=j)
i += 1
if i == 6:
i = 0
j = 1
self.erase_button = Button(self.root,
text="Eraser",
bd=4,
relief=RIDGE,
width=8,
command=self.eraser,
bg="white")
self.erase_button.place(x=0, y=187)
self.clear_sreen_button = Button(
self.root,
text="Clear",
bd=4,
relief=RIDGE,
width=8,
command=lambda: self.canvas.delete("all"),
bg="white")
self.clear_sreen_button.place(x=0, y=217)
self.save_button = Button(self.root,
text="Save",
bd=4,
relief=RIDGE,
width=8,
command=self.save_paint,
bg="white")
self.save_button.place(x=0, y=247)
self.canvas_color_button = Button(self.root,
text="Canvas",
bd=4,
relief=RIDGE,
width=8,
command=self.canvas_color,
bg="white")
self.canvas_color_button.place(x=0, y=277)
self.pen_size_scale_frame = LabelFrame(self.root,
text="Size",
bd=5,
relief=RIDGE,
bg="white",
font=('arial', 15, 'bold'))
self.pen_size_scale_frame.place(x=0, y=310, height=200, width=70)
self.pen_size = Scale(self.pen_size_scale_frame,
orient='vertical',
from_=50,
to=0,
command=None,
length=170)
self.pen_size.set(1)
self.pen_size.grid(row=0, column=1, padx=15)
self.canvas = Canvas(self.root,
bg='white',
bd=5,
relief='groove',
height=500,
width=700)
self.canvas.place(x=80, y=0)
# Blind mouse dragging event to canvas
self.canvas.bind("<B1-Motion>", self.paint)
def __init__(self, root_frame_instance):
super().__init__(volume_callback=self.update_volume,
mute_callback=self.update_mute,
state_callback=self.update_state)
self.root_frame_instance = root_frame_instance
# ______________ DISPLAY NAME ______________
self.app_name = self.magic_root_session.app_exec
print(f":: new session: {self.app_name}")
# ______________ CREATE FRAME ______________
# super(MagicSession, self).__init__(root_frame_instance)
Frame.__init__(self, root_frame_instance)
# _______________ NAME LABEL _______________
self.name_label = Label(self,
text=self.app_name,
font=("Consolas", 12, "italic"))
# _____________ VOLUME SLIDER _____________
self.volume_slider_state = DoubleVar()
self.volume_slider = Scale(self,
variable=self.volume_slider_state,
command=self._slide_volume,
from_=0,
to=100,
takefocus=False,
orient=HORIZONTAL)
# set initial:
self.volume_slider_state.set(self.volume * 100)
# ______________ MUTE BUTTON ______________
self.mute_button_state = StringVar()
self.mute_button = Button(self,
style="",
textvariable=self.mute_button_state,
command=self._toogle_mute,
takefocus=False)
# set initial:
self.update_mute(self.mute)
# _____________ SESSION STATUS _____________
self.status_line = Frame(self, style="", width=6)
# set initial:
self.update_state(self.state)
# ________________ SEPARATE ________________
self.separate = Separator(self, orient=HORIZONTAL)
# ____________ ARRANGE ELEMENTS ____________
# set column[1] to take the most space
# and make all others as small as possible:
self.columnconfigure(1, weight=1)
# grid
self.name_label.grid(row=0, column=0, columnspan=2, sticky="EW")
self.mute_button.grid(row=1, column=0)
self.volume_slider.grid(row=1, column=1, sticky="EW", pady=10, padx=20)
self.separate.grid(row=2, column=0, columnspan=3, sticky="EW", pady=10)
self.status_line.grid(row=0, rowspan=2, column=2, sticky="NS")
# _____________ DISPLAY FRAME _____________
self.pack(pady=0, padx=15, fill='x')
def start(self):
"""Called when initialised to create test widgets."""
self.img = ScalingImage(file=self.imgpath)
self.my_label = Label(Toplevel(self), image=self.img)
self.my_label.__image = self.img
# The window snaps to the right size faster with these pack options
self.my_label.pack(fill="both",
expand="true",
side="left",
anchor="nw")
self.numer_var = IntVar()
self.denom_var = IntVar()
self.numer_display_var = IntVar()
self.denom_display_var = IntVar()
self.numer_var.set(10)
self.denom_var.set(20)
self.numer_display_var.set(10)
self.denom_display_var.set(20)
frac_frame = LabelFrame(self, text="Full Fraction")
frac_frame.pack(side="left",
fill="both",
expand="true",
padx=5,
pady=5)
frac_numer_scale = Scale(frac_frame,
variable=self.numer_var,
from_=1,
to=100,
orient="vertical",
command=lambda i: self.on_frac_changed())
frac_numer_scale.bind("<ButtonRelease>", lambda e: self.on_end_zoom())
frac_numer_scale.pack(side="left")
frac_denom_scale = Scale(frac_frame,
variable=self.denom_var,
from_=1,
to=100,
orient="vertical",
command=lambda i: self.on_frac_changed())
frac_denom_scale.bind("<ButtonRelease>", lambda e: self.on_end_zoom())
frac_denom_scale.pack(side="left")
Label(frac_frame, textvariable=self.numer_display_var).pack()
Label(frac_frame, text="__\n").pack()
Label(frac_frame, textvariable=self.denom_display_var).pack()
numer_scale_frame = LabelFrame(self, text="Numeric Scale")
numer_scale_frame.pack(side="left",
fill="both",
expand="true",
padx=5,
pady=5)
self.numer_scale_var = IntVar()
self.numer_scale_display_var = IntVar()
self.numer_scale_var.set(20)
self.numer_scale_display_var.set(20)
zoom_scale = Scale(numer_scale_frame,
from_=1,
to=60,
variable=self.numer_scale_var,
orient="horizontal",
command=lambda i: self.on_numer_scale_changed())
zoom_scale.bind("<ButtonRelease>", lambda e: self.on_end_zoom())
zoom_scale.pack(fill="x")
Label(numer_scale_frame,
textvariable=self.numer_scale_display_var).pack()
Label(numer_scale_frame, text="__\n\n20").pack()
decimal_frame = LabelFrame(self, text="Decimal")
decimal_frame.pack(side="left",
fill="both",
expand="true",
padx=5,
pady=5)
self.decimal_scale_var = DoubleVar()
self.decimal_display_var = DoubleVar()
self.decimal_scale_var.set(1)
self.decimal_display_var.set(1)
decimal_scale = Scale(decimal_frame,
variable=self.decimal_scale_var,
from_=0.01,
to=3,
command=lambda i: self.on_decimal_changed())
decimal_scale.bind("<ButtonRelease>", lambda e: self.on_end_zoom())
decimal_scale.pack()
Label(decimal_frame, textvariable=self.decimal_display_var).pack()
Button(self, text="Reset", command=self.on_reset).pack(side="left")
def __init__(self, root):
self.root = root
self.root.title("Paint Application")
self.root.geometry("900x750")
self.root.configure(background='white')
self.stack = []
self.item = None
self.old_x = None
self.old_y = None
self.old_x_arrow = None
self.old_y_arrow = None
self.width_val = self.root.winfo_screenwidth()
self.height_val = self.root.winfo_screenheight()
self.pen_color = 'black'
self.eraser_color = 'white'
self.save_color = self.pen_color
self.choice = 'Pencil'
# Adding widgets to tkinter window
self.color_frame = LabelFrame(self.root,
bd=4,
relief=RIDGE,
bg="white")
self.color_frame.grid(row=0, column=0, pady=(5, 0))
self.color_frame_tooltip = CreateToolTip(self.color_frame,
'Select Brush Color')
self.color_frame.config(cursor="hand2")
colors = [
'#800000', '#FF0000', '#FFA500', '#FFFF00', '#808000', '#800080',
'#FF00FF', '#808080', '#00FF00', '#008000', '#000080', '#0000FF',
'#00FFFF', '#008080', '#000000', '#C0C0C0'
]
i = j = 0
for color in colors:
Button(self.color_frame,
bg=color,
bd=2,
relief=RIDGE,
width=3,
command=lambda col=color: self.select_color(col)).grid(
row=i, column=j)
i += 1
if i == 8:
i = 0
j += 1
self.clear_image = PhotoImage(file='signs.png')
self.clear_button = Button(self.root,
image=self.clear_image,
command=self.clear,
width=64)
self.clear_button.grid(row=1, column=0, pady=(5, 0))
self.clear_button.config(cursor="hand2")
self.clear_button_tooltip = CreateToolTip(self.clear_button,
'Clear the Canvas')
self.eraser_image = PhotoImage(file='eraser.png')
self.eraser_button = Button(self.root,
image=self.eraser_image,
command=self.eraser,
width=64)
self.eraser_button.grid(row=2, column=0)
self.eraser_button.config(cursor="hand2")
self.eraser_button_tooltip = CreateToolTip(self.eraser_button,
'Eraser')
self.line_image = PhotoImage(file='line.png')
self.line_button = Button(self.root,
image=self.line_image,
command=self._createLine,
width=64)
self.line_button.grid(row=3, column=0)
self.line_button.config(cursor="hand2")
self.line_button_tooltip = CreateToolTip(self.line_button,
'Straight Line')
self.line_arrow_image = PhotoImage(file='arrows.png')
self.line_arrow_button = Button(self.root,
image=self.line_arrow_image,
command=self._createArrowLine,
width=64)
self.line_arrow_button.grid(row=4, column=0)
self.line_arrow_button.config(cursor="hand2")
self.line_arrow_button_tooltip = CreateToolTip(
self.line_arrow_button, 'Straight Line with Arrow')
self.rectangle_image = PhotoImage(file='rectangle.png')
self.rectangle_button = Button(self.root,
image=self.rectangle_image,
command=self._createRectangle,
width=64)
self.rectangle_button.grid(row=5, column=0)
self.rectangle_button.config(cursor="hand2")
self.rectangle_button_tooltip = CreateToolTip(self.rectangle_button,
'Rectangle and Square')
self.oval_image = PhotoImage(file='oval.png')
self.oval_button = Button(self.root,
image=self.oval_image,
command=self._createOval,
width=64)
self.oval_button.grid(row=6, column=0)
self.oval_button.config(cursor="hand2")
self.oval_button_tooltip = CreateToolTip(self.oval_button,
'Oval and Circle')
self.pencil_image = PhotoImage(file='pencil.png')
self.pencil_button = Button(self.root,
image=self.pencil_image,
command=self._pencil,
width=64)
self.pencil_button.grid(row=7, column=0)
self.pencil_button.config(cursor="hand2")
self.pencil_button_tooltip = CreateToolTip(self.pencil_button,
'Pencil')
self.undo_image = PhotoImage(file='undo.png')
self.undo_button = Button(self.root,
image=self.undo_image,
command=self.undo,
width=64)
self.undo_button.grid(row=9, column=0)
self.undo_button.config(cursor="hand2")
self.undo_button_tooltip = CreateToolTip(self.undo_button, 'Undo')
# self.redo_image = PhotoImage(file='redo.png')
# self.redo_button = Button(self.root, image=self.redo_image, command=self.redo, width=64)
# self.redo_button.grid(row=8, column=0)
# self.redo_button.config(cursor="hand2")
# Creating a Scale for pen and eraser size...
self.pen_size_scale_frame = Frame(self.root,
bd=5,
bg='lightblue',
relief=RIDGE)
self.pen_size_scale_frame.grid(row=10, column=0, pady=5)
self.pen_size = Scale(self.pen_size_scale_frame,
orient=VERTICAL,
from_=30,
to=2,
length=170)
self.pen_size_tooltip = CreateToolTip(
self.pen_size,
'Adjust the size of pen and eraser using this slider.')
self.pen_size.set(1)
self.pen_size.grid(row=0, column=1, padx=15, pady=5)
self.pen_size.config(cursor="hand2")
# Creating Canvas
self.canvas = Canvas(self.root,
bg='white',
relief=GROOVE,
height=self.height_val,
width=self.width_val,
cursor="crosshair")
self.canvas.place(x=70, y=0)
# Binding the canvas with the mouse drag
self.canvas.bind("<B1-Motion>", self.paint)
self.canvas.bind("<ButtonRelease-1>", self.reset)
self.msg = tk.Message(self.root, text=self.choice)
self.msg.grid(row=11, column=0, pady=(20, 0))
menu = Menu(self.root)
self.root.config(menu=menu)
filemenu = Menu(menu)
colormenu = Menu(menu)
menu.add_cascade(label='Colors', menu=colormenu)
colormenu.add_command(label='Brush Color', command=self.brush_color)
colormenu.add_command(label='Background Color',
command=self.canvas_color)
optionmenu = Menu(menu)
menu.add_cascade(label='Options', menu=optionmenu)
optionmenu.add_command(label='Clear Canvas', command=self.clear)
optionmenu.add_command(label='Exit', command=self.root.destroy)
menu.add_cascade(label='File', menu=filemenu)
filemenu.add_command(label='Save', command=self.save_it)
filemenu.add_command(label='Save and Exit',
command=self.save_it_destroy)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
timer = TkTimer(widget=self, interval=0.2*pq.second, active=False)
self.__battery_images = battery_images = {}
image_dir = Path(Scripting.root_node.get_gui_image_path('battery'))
for image_name in ['10per', '25per', '50per', '75per', '100per',
'10per_charge', '25per_charge',
'50per_charge', '75per_charge', '100per_charge']:
battery_images[image_name] = ImageTk.PhotoImage(
file=str(image_dir/(image_name+'.png')))
balloon = Scripting.root_node.gui.balloon
self.__busy_lamp = busy_lamp = BusyLight(self)
busy_lamp.pack(side='right', fill='y')
balloon.bind_widget(busy_lamp, balloonmsg='''Main-thread status.
Green: main-thread is available;
Red: main-thread is busy.''')
battery_meter = Label(self)
battery_meter.pack(side='right', fill='y')
battery_meter_tip = balloon.bind_widget(battery_meter, balloonmsg='Battery: ')
def battery_meter_tip_show_callback():
battery_status = Scripting.root_node.interfaces.os.get_battery_status()
if battery_status is None:
return 'No battery detected.'
else:
return f'{battery_status.percent}%'
battery_meter_tip.show_callback = battery_meter_tip_show_callback
self.__membar = IntVar(0)
self.__cpubar = IntVar(0)
self._make_cpu_mem_status()
# Transparent Scale {
def on_scale(val):
Scripting.root_node.gui.console.set_opacity(val)
trans_scale = Scale(self, from_=0.2, to=1.0, orient='horizontal', value=1, command=on_scale)
trans_scale.pack(side='right')
balloon.bind_widget(trans_scale, balloonmsg='Set the opacity of the console.')
# } End Transparent Scale
# Topmost Button {
import tkinter
topmost_button = tkinter.Button(self, text='TOP', relief='groove')
topmost_button.pack(side='right')
def on_click():
console =Scripting.root_node.gui.console
b = console.is_topmost
fg = 'black' if b else 'lime green'
topmost_button['fg'] = fg
with code_printer(True):
console.set_topmost(not b)
topmost_button['command'] = on_click
balloon.bind_widget(topmost_button, balloonmsg='Set the console as a topmost window.')
# } End Topmost Button
# Doc Button {
docbtn = tkinter.Button(self, text='DOC', relief='groove')
docbtn.pack(side='right')
def on_click():
docwin = Scripting.root_node.gui.console.doc_window
with code_printer(True):
docwin.show_window()
docbtn['command'] = on_click
balloon.bind_widget(docbtn, balloonmsg='Show document window.')
#} End Doc Window
# Debug Button {
debbtn = tkinter.Button(self, text='DEB', relief='groove')
debbtn.pack(side='right')
def on_click():
debwin = Scripting.root_node.gui.console.debug_window
with code_printer(True):
debwin.show_window()
debbtn['command'] = on_click
balloon.bind_widget(debbtn, balloonmsg='Show debug window.')
#} End Debug Button
#{ Window Combo
window_combo = Combobox(self, value=[], takefocus=1, stat='readonly')
def on_selected(event):
text = event.widget.get()
wid = int(text.split(':')[1].strip())
Scripting.root_node.gui.windows[wid].tk_object.deiconify()
window_combo.bind('<<ComboboxSelected>>', on_selected)
window_combo.pack(side='right', fill='y') # deiconify a window
@Scripting.root_node.gui.windows.add_observer
def on_windows_change(node, command):
values = window_combo['values']
if values == '':
values = []
if isinstance(values, tuple):
values = list(values)
node_id = id(node)
if command == 'new':
type_name = node.__class__.__name__
values.append(f'{type_name}: {node_id}')
elif command == 'del':
for index, value in enumerate(values):
wid = int(value.split(':')[1].strip())
if node_id == wid:
del values[index]
window_combo['values'] = values
if len(values) > 0:
window_combo.current(len(values)-1)
else:
window_combo.set('')
#} End Window Combo
self.__lock = thread.allocate_lock()
self.__busy = False
os_node = Scripting.root_node.interfaces.os
get_memory_usage = os_node.get_memory_usage
get_cpu_usage = os_node.get_cpu_usage
get_battery_status = os_node.get_battery_status
def check_cpu_mem_battery(event):
with code_printer(print_=False):
self.__membar.set(get_memory_usage())
self.__cpubar.set(get_cpu_usage())
battery_status = get_battery_status()
if battery_status:
percent = battery_status.percent
if percent > 75:
percent = 100
elif percent > 50:
percent = 75
elif percent > 25:
percent = 50
elif percent > 10:
percent = 25
else:
percent = 10
charge = '_charge' if battery_status.power_plugged else ''
image_name = f'{percent}per{charge}'
image = battery_images[image_name]
if battery_meter['image'] != image:
battery_meter['image'] = image
timer.divider(divide_by=10).add_observer(check_cpu_mem_battery)
timer.active = True
def __init__(self, root):
self.root = root
self.root.title("Paint")
self.root.geometry("800x520")
self.root.config(background='purple')
self.root.resizable(0, 0)
self.pen_color = "black"
#adding frame
self.color_frame = LabelFrame(self.root,
text="Color",
font=('arial', 15),
bd=5,
relief=RIDGE,
bg='white')
self.color_frame.place(x=0, y=0, width=70, height=205)
colors = [
'#000000', '#FFFFFF', '#FF0000', '#00FF00', '#0000FF', '#FFFF00',
'#00FFFF', '#FF00FF', '#F1510B', '#CD9C10', '#513D53', '#4A7570'
]
i = j = 0
for color in colors:
Button(self.color_frame,
bg=color,
bd=2,
relief=RIDGE,
width=3,
command=None).grid(row=i, column=j)
i += 1
if i == 6:
i = 0
j += 1
self.eraser_button = Button(self.root,
text="ERASER",
bd=4,
bg='white',
command=None,
width=8,
relief=RIDGE)
self.eraser_button.place(x=0, y=205)
self.eraser_button = Button(self.root,
text="Clear",
bd=4,
bg='white',
command=None,
width=8,
relief=RIDGE)
self.eraser_button.place(x=0, y=235)
self.eraser_button = Button(self.root,
text="Save",
bd=4,
bg='white',
command=None,
width=8,
relief=RIDGE)
self.eraser_button.place(x=0, y=265)
self.eraser_button = Button(self.root,
text="Canvas",
bd=4,
bg='white',
command=None,
width=8,
relief=RIDGE)
self.eraser_button.place(x=0, y=295)
self.pen_size_scale_frame = LabelFrame(self.root,
text="Size",
bd=5,
bg='white',
font=('arial', 15, 'bold'),
relief=RIDGE)
self.pen_size_scale_frame.place(x=0, y=325, width=70, height=195)
self.pen_size = Scale(self.pen_size_scale_frame,
orient=VERTICAL,
from_=50,
to=0,
length=150)
self.pen_size.set(1)
self.pen_size.grid(row=0, column=1, padx=15)
self.canvas = Canvas(self.root,
bg='white',
bd=5,
relief=GROOVE,
height=505,
width=715)
self.canvas.place(x=70, y=0)
self.canvas.bind("<B1-Motion>", self.paint)
def __init__(self, master):
self.master = master
self.master.title("Points indicator")
# Mode de draw
self.draw_mode = "point"
# Image
self.origin_image = None
self.scale = 1.0
self.img = None
self.img_id = None
# Menu
self.menu_bar = Menu(self.master)
self.create_menus()
# main frame
self.frame = Frame(self.master,
relief=SUNKEN,
bg="red",
width=self.master.winfo_width())
self.frame.grid_rowconfigure(0, weight=1)
self.frame.grid_columnconfigure(0, weight=1)
self.frame.pack(fill=None, expand=False)
# scroll bars
self.xscrollbar = Scrollbar(self.frame, orient=HORIZONTAL)
self.xscrollbar.grid(row=2, column=0, columnspan=2, sticky=EW)
self.yscrollbar = Scrollbar(self.frame)
self.yscrollbar.grid(row=1, column=1, sticky=NS)
# canvas to put image
self.canvas = Canvas(self.frame,
bg="black",
bd=0,
height=(self.master.winfo_height() - 250),
width=(self.master.winfo_width() - 100),
xscrollcommand=self.xscrollbar.set,
yscrollcommand=self.yscrollbar.set)
self.canvas.grid(row=1, column=0, sticky=NSEW)
self.canvas.config(state=DISABLED)
self.xscrollbar.config(command=self.canvas.xview)
self.yscrollbar.config(command=self.canvas.yview)
# zoom utility buttons
self.zoom_in_button = Button(self.frame,
text="+",
command=lambda: self.zoom(self.scale * 2),
width=3)
self.zoom_out_button = Button(
self.frame,
text="-",
command=lambda: self.zoom(self.scale * 0.5),
width=3)
self.zoom_scale = Scale(self.frame,
from_=1,
to=3,
length=80,
command=self.on_scale,
orient=VERTICAL)
self.zoom_in_button.place(relx=0.93, rely=0.03)
self.zoom_scale.place(relx=0.93, rely=0.07)
self.zoom_out_button.place(relx=0.93, rely=0.18)
self.change_zoom_state(0)
# Frame to put text
self.textFrame = Frame(self.frame,
relief=SUNKEN,
bg=self.master.cget('bg'),
width=(self.master.winfo_width()),
height=(self.master.winfo_height() -
int(self.canvas['height']) - 50))
self.textFrame.grid_rowconfigure(0, weight=1)
self.textFrame.grid_columnconfigure(0, weight=1)
self.textFrame.grid(row=3, column=0, columnspan=2, sticky=NSEW)
self.textFrame.grid_propagate(False)
# text area widget
self.textContent = Text(self.textFrame, font='Arial')
self.textContent.grid(row=4, column=0, padx=25, pady=25, sticky=NSEW)
self.set_text_color_tags()
# popup entry value
self.roomLabel = StringVar()
self.open_file()
# bind mouse-click event
self.go_to_point_mode() # point mode by default
self.canvas.bind("<MouseWheel>", self.on_mouse_wheel)
def __init__(self, *args, **kwargs):
pil_image = kwargs.pop('pil_image')
balloon = None
if 'balloon' in kwargs:
balloon = kwargs.pop('balloon')
photo = ImageTk.PhotoImage(pil_image)
self.__photo = photo
self.__origin_image = pil_image
self.__zoomed_image = pil_image
super().__init__(*args, **kwargs)
self.__icons = icons = {}
image_dir = Path(__file__).parent / 'images'
for name in ('save', 'savezoom', 'copy'):
icon_path = image_dir / (name+'.png')
icon = ImageTk.PhotoImage(file=str(icon_path))
icons[name] = icon
frame = Frame(self)
frame.pack(fill='x')
save_dlg = lambda: asksaveasfilename(filetypes=[
('JPEG', '.jpg'), ('PNG', '.png')],
defaultextension='.jpg')
def on_save(image):
filename = save_dlg()
if filename:
image.save(filename)
Label(frame, text=f'id={id(self)}').pack(side='left')
save_btn = Button(frame,
image=icons['save'],
command=lambda:on_save(self.__origin_image))
save_btn.pack(side='left')
if balloon:
balloon.bind_widget(save_btn, balloonmsg='Save image.')
savezoom_btn = Button(frame,
image=icons['savezoom'],
command=lambda:on_save(self.__zoomed_image))
savezoom_btn.pack(side='left')
if balloon:
balloon.bind_widget(savezoom_btn, balloonmsg='Save zoomed image.')
if platform.system().lower() == 'windows':
from wavesynlib.interfaces.os.windows.clipboard import clipb
def on_copy():
clipb.image_to_clipboard(self.__origin_image)
copy_btn = Button(frame, image=icons['copy'], command=on_copy)
copy_btn.pack(side='left')
if balloon:
balloon.bind_widget(copy_btn, balloonmsg='Copy image.')
scale = Scale(frame, from_=0, to=100, orient='horizontal', value=100)
scale.pack(side='left')
zoomed_label = Label(frame, text='100%')
zoomed_label.pack(side='left')
self.__label = label = Label(self, image=photo)
label.pack(expand='yes', fill='both')
def on_scale(val):
val = float(val)
width, height = self.__origin_image.size
width = int(width * val / 100)
height = int(height * val / 100)
if width<=0 or height<=0:
return
zoomed_image = self.__origin_image.resize((width, height),
Image.ANTIALIAS)
self.__zoomed_image = zoomed_image
self.__photo = ImageTk.PhotoImage(zoomed_image)
self.__label['image'] = self.__photo
zoomed_label['text'] = f'{int(val)}%'
scale['command'] = on_scale
def initUI(self):
self.parent.title("PRIMEP")
self.pack(fill=BOTH, expand=True)
global value
value = 0
global var
var = IntVar()
global num
num = StringVar()
global res
res = StringVar()
frame1 = Frame(self, style='My.TFrame')
frame1.pack(fill=X)
lbl1 = Label(frame1,
text="Enter a number :",
width=16,
background='orange')
lbl1.pack(side=LEFT, padx=5, pady=5)
entry1 = Entry(frame1, textvariable=num, style='My.TEntry')
entry1.pack(fill=X, padx=5, expand=True)
frame2 = Frame(self, style='My.TFrame')
frame2.pack(fill=X)
lbl2 = Label(frame2,
text="Set certainty :",
width=16,
background='orange')
lbl2.pack(side=LEFT, padx=5, pady=5)
#entry2 = Entry(frame2,textvariable=cer,style='My.TEntry')
#entry2.pack(fill=X, padx=5, expand=True)
scale = Scale(frame2,
from_=1,
to=25,
orient=HORIZONTAL,
command=self.onScale)
scale.pack(side=LEFT, padx=5)
#var = IntVar()
label = Label(frame2, text=1, textvariable=var)
label.pack(side=LEFT, padx=5)
frame3 = Frame(self, style='My.TFrame')
frame3.pack(fill=X)
result = Label(frame3, textvariable=res, width=28, background='orange')
result.pack(side=LEFT, padx=60, pady=5)
frame4 = Frame(self, style='My.TFrame')
frame4.pack(fill=X)
btntest = Button(frame4,
text="Test",
width=10,
command=self.test,
style='My.TButton')
btntest.pack(side=LEFT, anchor=N, padx=5, pady=5)
btnclear = Button(frame4,
text="Clear",
width=10,
command=self.clear,
style='My.TButton')
btnclear.pack(side=LEFT, anchor=N, padx=5, pady=5)
btnclose = Button(frame4,
text="Close",
width=10,
command=self.quit,
style='My.TButton')
btnclose.pack(side=LEFT, anchor=N, padx=5, pady=5)
def __init__(self, root):
self.root = root
self.root.title("MyPaint")
self.root.geometry("800x520")
self.root.configure(background="white")
self.root.resizable(0, 0)
self.pen_color = "black"
self.eraser_color = "white"
self.color_frame = LabelFrame(self.root, text="Color", font=(
"arial,15"), bd=5, relief=RIDGE, bg="white")
self.color_frame.place(x=0, y=0, width=76, height=185)
# self.canvas_shapes_frame = LabelFrame(self.root, text="Shapes", font=(
# "arial", 15), bd=5, relief=RIDGE, bg="white")
# self.canvas_shapes_frame.place(x=0, y=105, width=76, height=80)
colors = ["#000000", "#FFFFFF", "#FF0000", "#00FF00",
"#0000FF", "#FFFF00", "#00FFFF", "#FF00FF", "#FFFACD", "#F5DEB3", "#C0C0C0", "#DEB887"]
i = j = 0
for color in colors:
Button(self.color_frame, bg=color, bd=2, relief=RIDGE,
width=1, height=2, command=lambda col=color: self.select_color(col)).grid(row=i, column=j)
i += 1
if i == 3 or i == 6:
i = 0
j += 1
self.color_other_button = Button(
self.color_frame, text="Others", bd=4, bg="white", command=self.color_other, width=8, relief=RIDGE)
self.color_other_button.place(x=0, y=130, width=68)
self.eraser_button = Button(
self.root, text="Eraser", bd=4, bg="white", command=self.eraser, width=8, relief=RIDGE)
self.eraser_button.place(x=0, y=187, width=76)
self.clear_button = Button(
self.root, text="Clear", bd=4, bg="white", command=lambda: self.canvas.delete("all"), width=8, relief=RIDGE)
self.clear_button.place(x=0, y=217, width=76)
self.save_button = Button(
self.root, text="Save", bd=4, bg="white", command=self.save_image, width=8, relief=RIDGE)
self.save_button.place(x=0, y=247, width=76)
self.canvas_color_button = Button(
self.root, text="Canvas", bd=4, bg="white", command=self.canvas_color, width=8, relief=RIDGE)
self.canvas_color_button.place(x=0, y=277, width=76)
# creating a scale for pen and eraser
self.pen_size_scale_frame = LabelFrame(
self.root, text="Size", bd=5, bg="white", font=("arial", 15, "bold"), relief=RIDGE)
self.pen_size_scale_frame.place(x=0, y=310, height=200, width=76)
self.pen_size = Scale(self.pen_size_scale_frame,
orient=VERTICAL, from_=50, to=0, length=170)
self.pen_size.set(1)
self.pen_size.grid(row=0, column=1, padx=15)
# creating the canvas
self.canvas = Canvas(self.root, bg="white", bd=5,
relief=GROOVE, height=500, width=680)
self.canvas.place(x=100, y=0)
# binding the canvas
self.canvas.bind("<B1-Motion>", self.paint)
