def SyntexHighlight(self, event=None):
from tkinter.font import Font
for tag in self.tag_names():
self.tag_delete(tag)
self.mark_set("range_start", "1.0")
data = self._get_value()
self.tag_configure("Token.Comment", foreground="#F00")
bolder = Font(family=self.app.cnf['font'][0])
bolder.config(size=self.app.cnf['font'][1]-2)
bolder.config(weight="bold")
for token, content in lex(data, PythonLexer()):
self.mark_set("range_end", "range_start + %dc" % len(content))
self.tag_add(str(token), "range_start", "range_end")
self.mark_set("range_start", "range_end")
self.tag_config("Token.Comment.Single", foreground="#F00")
self.tag_config("Token.Literal.String.Doc", foreground="#F00")
for tag in self.tag_names():
if 'Token.Keyword' == tag:
self.tag_config(tag, foreground="#008", font=bolder)
elif 'Token.Keyword.Namespace' == tag:
self.tag_config(tag, foreground="#00F", font=bolder)
elif 'Token.Name.Class' in tag:
self.tag_config(tag, foreground="#F30", background='#AFA')
elif 'Token.Name.Function' in tag:
self.tag_config(tag, foreground="#A3A", background='#FFA')
elif 'Token.Literal' in tag:
self.tag_config(tag, foreground="#6A0")
elif 'Token.Operator' in tag:
self.tag_config(tag, foreground="#A3A")
print(self.tag_names())
def initialize(self):
#Create the menubar
self.menubar=Menu(self)
menu=Menu(self.menubar,tearoff=0)
self.menubar.add_cascade(label="File",menu=menu)
menu.add_command(label="Open",command=self.openfile)
#menu.add_command(label="Exit")
menu=Menu(self.menubar,tearoff=0)
self.menubar.add_cascade(label="Tools",menu=menu)
menu.add_command(label="Class",command=self.classwindow)
menu.add_command(label="Hilbert",command=self.hilbertwindow)
menu.add_command(label="Entropy",command=self.entropywindow)
menu.add_command(label="Gradient",command=self.gradientwindow)
self.master.config(menu=self.menubar)
#Configure grid layout
self.columnconfigure(0,pad=5)
self.columnconfigure(1,pad=5)
self.columnconfigure(2,pad=5)
self.rowconfigure(0,pad=5)
self.rowconfigure(0,pad=5)
#Add canvas to plot points from converted hex values
self.plotcanvas=Canvas(self,width=256,height=256)
self.plotcanvas.configure(background='black')
self.plotcanvas.grid(row=0,column=0)
#Add listbox to hold the current group of hexvalues
listframe=Frame(self)
hexscroll=Scrollbar(listframe,orient=VERTICAL)
hexbox_font = Font(size=8)
hexbox_font.config(family={"posix": "Monospace","nt": "Courier New"})
self.hexbox=Listbox(listframe,width=75,height=20,font=hexbox_font,yscrollcommand=hexscroll.set,selectmode=EXTENDED)
hexscroll.config(command=self.hexbox.yview)
hexscroll.pack(side=RIGHT,fill=Y)
self.hexbox.pack(side=LEFT)
listframe.grid(row=0,column=1)
#Add slider for location in hex lines and size of window of hex values
commandframe=Frame(self)
playframe=Frame(commandframe)
windowframe=Frame(commandframe)
self.playslider=Scale(playframe,command=self.playslider_moved)
self.playslider.configure(from_=0,to=100)
self.playslider.configure(orient=HORIZONTAL)
self.playslider.pack(side=BOTTOM)
hexaddress=gethexaddress(int(self.playslider.get()))
self.currhexaddress=Label(playframe,width=20,text=hexaddress)
self.currhexaddress.pack(side=TOP)
self.curroffset=Label(windowframe,text=self.hexaddressoffset)
self.curroffset.pack(side=TOP)
self.windowslider=Scale(windowframe,command=self.windowslider_moved)
self.windowslider.configure(from_=100,to=600,orient=HORIZONTAL)
self.windowslider.pack(side=TOP)
self.windowslider.set(self.hexaddressoffset)
playframe.pack(side=LEFT)
windowframe.pack(side=RIGHT)
commandframe.grid(row=1,columnspan=2)
self.pack()
def __getHammerFont(self):
from tkinter.font import Font, families
hammerFont = Font(font='Hammerfat_Hun')
if int(self.__Config.get_Element("BoxFontSize")) == 0:
hammerFont.config(size=self.__fontSize + 4)
else:
hammerFont.config(
size=int(self.__Config.get_Element("BoxFontSize")))
return (hammerFont)
def __createViewer(self, __w, __h, __s, fontSize, hammerFont, code):
"""Creates the menu where you can watch the result."""
from tkinter.font import Font, families
self.__HTMLviewer.pack_propagate(False)
hammerFont = Font(font='Hammerfat_Hun')
hammerFont.config(size=fontSize + 2)
self.__fixheight = __h
self.__createButtonsFrame(__w, hammerFont)
self.__createHTMLFrame(__w, __h, code)
def __init__(self, master=None, **cnf):
ScrolledText.__init__(self, master, **cnf)
bold = Font(font=self['font']).copy()
bold.config(weight='bold')
italic = Font(font=self['font']).copy()
italic.config(slant='italic')
# Define tags for formatting styles
self.tag_config('X', underline=1)
self.tag_config('!', font=bold)
self.tag_config('_', font=italic)
# Set state to idle
self.fp = None
self.lineno = 0
def __init__(self, master=None, **cnf):
ScrolledText.__init__(self, master, **cnf)
bold = Font(font=self['font']).copy()
bold.config(weight='bold')
italic = Font(font=self['font']).copy()
italic.config(slant='italic')
# Define tags for formatting styles
self.tag_config('X', underline=1)
self.tag_config('!', font=bold)
self.tag_config('_', font=italic)
# Set state to idle
self.fp = None
self.lineno = 0
def getFont(self, size, bold, italic, underline):
from tkinter.font import Font, families
if size == "normal":
size = self.__normalSize
elif size == "small":
size = self.__normalSize * 0.75
elif size == "xs":
size = self.__normalSize * 0.5
elif size == "large":
size = self.__normalSize * 1.5
elif size == "xl":
size = self.__normalSize * 2
if bold == True:
bold = "bold"
elif bold == False:
bold = "normal"
if italic == True:
italic = "italic"
elif italic == False:
italic = "roman"
if underline == True:
underline = 1
elif italic == False:
underline = 0
__font = Font(font='HammerFat_Hun')
__font.config(size=round(size))
__font.config(weight=bold)
__font.config(slant=italic)
__font.config(underline=underline)
return (__font)
class TextEditor:
def __init__(self, master):
self.master = master
self.font_dict = {'family': 'Arial', 'size': 10, 'weight': 'normal', 'slant': 'roman', 'underline': 0, 'overstrike': 0}
self.font = Font(family = self.font_dict.get('family'),
size = self.font_dict.get('size'),
weight = self.font_dict.get('weight'),
slant = self.font_dict.get('slant'),
underline = self.font_dict.get('underline'),
overstrike = self.font_dict.get('overstrike'))
self.master.title('SB Text Editor')
self.file_name = None
self.bg = 'white'
self.fg = 'black'
# text box
self.text = tk.Text(relief = tk.FLAT, undo = True, font = self.font)
self.text.pack(fill=tk.BOTH, expand=True)
self.text.focus()
# main menu
self.main_menu = tk.Menu()
self.master.config(menu = self.main_menu)
# file menu
self.file_menu = tk.Menu(self.main_menu, tearoff = False)
self.main_menu.add_cascade(label = 'File', menu = self.file_menu)
self.file_menu.add_command(label = 'New', accelerator = 'Ctrl+N', command = self.new_file)
self.file_menu.add_command(label = 'Open', accelerator = 'Ctrl+O', command = self.open_file)
self.file_menu.add_separator()
self.file_menu.add_command(label = 'Save', accelerator = 'Ctrl+S', command = self.save_file)
self.file_menu.add_command(label = 'Save as', accelerator = 'Ctrl+Shift+S', command = self.save_as)
self.file_menu.add_separator()
self.file_menu.add_command(label = 'Quit', command = self.close_programe)
# edit menu
self.edit_menu = tk.Menu(self.main_menu, tearoff = False)
self.main_menu.add_cascade(label = 'Edit', menu = self.edit_menu)
self.edit_menu.add_command(label = 'Undo', accelerator = 'Ctrl+Z', command = self.text.edit_undo)
self.edit_menu.add_command(label = 'Redo', accelerator = 'Ctrl+Y',command = self.text.edit_redo)
self.edit_menu.add_separator()
self.edit_menu.add_command(label = 'Copy', accelerator = 'Ctrl+C', command = self.copy)
self.edit_menu.add_command(label = 'Cut', accelerator = 'Ctrl+X', command = self.cut)
self.edit_menu.add_command(label = 'Paste', accelerator = 'Ctrl+V', command = self.paste)
self.edit_menu.add_command(label = 'Delete', command = self.delete)
# view menu
self.view_menu = tk.Menu(self.main_menu, tearoff = False)
self.main_menu.add_cascade(label = 'View', menu = self.view_menu)
self.view_menu.add_command(label = 'Zoon in', command = self.zoom_in)
self.view_menu.add_command(label = 'Zoom out', command = self.zoom_out)
self.view_menu.add_separator()
self.view_menu.add_command(label = 'Change font', command = self.change_font)
# color menu
self.color_menu = tk.Menu(self.view_menu, tearoff = False)
self.view_menu.add_cascade(label = 'Change Colors', menu = self.color_menu)
self.color_menu.add_command(label = 'Change background color', command = self.change_bg)
self.color_menu.add_command(label = 'Change foreground color', command = self.change_fg)
# shortcuts
self.master.bind('<Control-n>', self.new_file)
self.master.bind('<Control-N>', self.new_file)
self.master.bind('<Control-o>', self.open_file)
self.master.bind('<Control-O>', self.open_file)
self.master.bind('<Control-s>', self.save_file)
self.master.bind('<Control-S>', self.save_file)
self.master.bind('<Shift-Control-s>', self.save_as)
self.master.bind('<Shift-Control-S>', self.save_as)
self.master.bind('<Control-plus>', self.zoom_in)
self.master.bind('<Control-minus>', self.zoom_out)
self.master.protocol('WM_DELETE_WINDOW', self.close_programe)
def load(self):
self.home = os.getenv('HOME')
self.home = self.home
if not os.path.isdir(os.path.join(self.home, '.SB_Text_Editor')):
os.mkdir(os.path.join(self.home, '.SB_Text_Editor'))
if os.path.isfile(os.path.join(self.home, '.SB_Text_Editor/settings.txt')):
with open(os.path.join(self.home, '.SB_Text_Editor/settings.txt'), 'r') as settings:
tmp = settings.readline().strip().split(';')
if len(tmp) == 6:
self.font_dict['family'] = tmp[0]
self.font_dict['size'] = int(tmp[1])
self.font_dict['weight'] = tmp[2]
self.font_dict['slant'] = tmp[3]
self.font_dict['underline'] = int(tmp[4])
self.font_dict['overstrike'] = int(tmp[5])
self.font = Font(family = self.font_dict['family'],
size = self.font_dict['size'],
weight = self.font_dict['weight'],
slant = self.font_dict['slant'],
underline = self.font_dict['underline'],
overstrike = self.font_dict['overstrike'])
self.text.config(font = self.font)
tmp = settings.readline().strip().split(';')
if len(tmp) == 2:
self.bg = tmp[0]
self.fg = tmp[1]
self.text.config(bg = self.bg, fg = self.fg)
def new_file(self, event = None):
if len(self.text.get(1.0, tk.END)) > 1:
inp = messagebox.askyesnocancel('SB Text Editor', 'Do you want to save this file?')
if inp == True:
self.save_file()
elif inp == None:
return None
self.file_name = None
self.text.delete(1.0, tk.END)
self.text.edit_reset()
def open_file(self, event = None):
file = filedialog.askopenfile(filetypes = [('Text file', '.txt'), ('All file', '*.*')])
if file != None:
self.text.delete(1.0, tk.END)
for line in file:
self.text.insert(tk.INSERT, line)
self.file_name = file.name
def save_file(self, event = None):
if self.file_name == None:
self.save_as()
else:
with open(self.file_name, 'w') as file:
file.write(self.text.get(1.0, tk.END))
def save_as(self, event = None):
file = filedialog.asksaveasfile(mode='w',
filetypes = [('Text file', '.txt'), ('All file', '*.*')],
defaultextension = '.txt')
if file != None:
file.write(self.text.get(1.0, tk.END))
self.file_name = file.name
file.close()
def close_programe(self, event = None):
if len(self.text.get(1.0, tk.END)) > 1:
inp = messagebox.askyesnocancel('SB Text Editor', 'Do you want to save this file?')
if inp == True:
self.save_file()
elif inp == None:
return None
self.master.quit()
def copy(self, event = None):
self.text.event_generate('<<Copy>>')
def cut(self, event = None):
self.text.event_generate('<<Cut>>')
def paste(self, event = None):
self.text.event_generate('<<Paste>>')
def delete(self, event = None):
try:
i1 = self.text.index('sel.first')
i2 = self.text.index('sel.last')
self.text.delete(i1, i2)
except:
return None
def zoom_in(self, event = None):
size = self.font.cget('size')
size += 1
if size > 30:
size = 30
self.font_dict['size'] = size
self.font.config(size = size)
self.text.config(font = self.font)
def zoom_out(self, event = None):
size = self.font.cget('size')
size -= 1
if size < 3:
size = 3
self.font_dict['size'] = size
self.font.config(size = size)
self.text.config(font = self.font)
def change_font(self, event = None):
font_dict = tkfontchooser.askfont(**self.font_dict)
if font_dict != '':
self.font_dict = font_dict
font_dict = list(font_dict.values())
font = Font(family = font_dict[0],
size = font_dict[1],
weight = font_dict[2],
slant = font_dict[3],
underline = font_dict[4],
overstrike = font_dict[5])
self.font = font
self.text.config(font = self.font)
with open(os.path.join(self.home, '.SB_Text_Editor/settings.txt'), 'w') as settings:
tmp = ';'.join(map(lambda item: str(item), list(self.font_dict.values())))
tmp += '\n'+self.bg+';'+self.fg
settings.write(tmp)
def change_bg(self, event = None):
color = colorchooser.askcolor()
if color[1] != None:
self.bg = color[1]
self.text.config(bg = self.bg)
with open(os.path.join(self.home, '.SB_Text_Editor/settings.txt'), 'w') as settings:
tmp = ';'.join(map(lambda item: str(item), list(self.font_dict.values())))
tmp += '\n' + self.bg + ';' + self.fg
settings.write(tmp)
def change_fg(self, event = None):
color = colorchooser.askcolor()
if color[1] != None:
self.fg = color[1]
self.text.config(fg = self.fg)
with open(os.path.join(self.home, '.SB_Text_Editor/settings.txt'), 'w') as settings:
tmp = ';'.join(map(lambda item: str(item), list(self.font_dict.values())))
tmp += '\n'+self.bg+';'+self.fg
settings.write(tmp)
def validateTags(self):
tags = self.text.tagsInSelection()
for tag in tags:
#Tag template
#{"prefix" : None, "tags" : list(), "size" = 18, "hex" : '#cccccc'}
formatFont = Font(self.text, self.text.cget("font"))
tagDict = eval(tag)
for _tag in tagDict["tags"]:
if _tag == "bold":
if "title" not in tagDict["tags"]:
formatFont.config(weight="bold")
else:
formatFont.config(weight="normal")
if _tag == "title":
if "bold" not in tagDict["tags"]:
formatFont.config(weight="bold")
else:
formatFont.config(weight="normal")
if _tag == "italic":
if "subtitle" not in tagDict["tags"]:
formatFont.config(slant="italic")
else:
formatFont.config(slant="roman")
if _tag == "subtitle":
if "italic" not in tagDict["tags"]:
formatFont.config(slant="italic")
else:
formatFont.config(slant="roman")
if _tag == "underline":
formatFont.config(underline=1)
if _tag == "overstrike":
formatFont.config(overstrike=1)
size = tagDict["size"]
formatFont.config(size=size)
if tagDict["prefix"] == "color" or tagDict["prefix"] == None:
self.text.tag_config(tag,
font=formatFont,
foreground=tagDict["hex"])
elif tagDict["prefix"] in globals.colorConfig.keys(
) and globals.vsc:
print("Tchau")
self.text.tag_config(
tag,
font=formatFont,
foreground=globals.colorConfig[tagDict["prefix"]])
class TextEditor:
# initialize all the component.
def __init__(self, master):
self.master = master
self.font_dict = {
'family': 'Arial',
'size': 10,
'weight': 'normal',
'slant': 'roman',
'underline': 0,
'overstrike': 0
}
self.font = Font(family=self.font_dict.get('family'),
size=self.font_dict.get('size'),
weight=self.font_dict.get('weight'),
slant=self.font_dict.get('slant'),
underline=self.font_dict.get('underline'),
overstrike=self.font_dict.get('overstrike'))
self.master.title('SB Text Editor')
self.file_name = None
self.bg = 'white'
self.fg = 'black'
self.insert = 'red'
self.insert_width = 2
# text box
self.text = tk.Text(relief=tk.FLAT, undo=True, font=self.font)
self.text.config(insertbackground=self.insert)
self.text.config(insertwidth=self.insert_width)
self.text.pack(fill=tk.BOTH, expand=True)
self.text.focus()
# main menu
self.main_menu = tk.Menu()
self.master.config(menu=self.main_menu)
# file menu
self.file_menu = tk.Menu(self.main_menu, tearoff=False)
self.main_menu.add_cascade(label='File', menu=self.file_menu)
self.file_menu.add_command(label='New',
accelerator='Ctrl+N',
command=self.new_file)
self.file_menu.add_command(label='Open',
accelerator='Ctrl+O',
command=self.open_file)
self.file_menu.add_separator()
self.file_menu.add_command(label='Save',
accelerator='Ctrl+S',
command=self.save_file)
self.file_menu.add_command(label='Save as',
accelerator='Ctrl+Shift+S',
command=self.save_as)
self.file_menu.add_separator()
self.file_menu.add_command(label='Quit', command=self.close_programe)
# edit menu
self.edit_menu = tk.Menu(self.main_menu, tearoff=False)
self.main_menu.add_cascade(label='Edit', menu=self.edit_menu)
self.edit_menu.add_command(label='Undo',
accelerator='Ctrl+Z',
command=self.text.edit_undo)
self.edit_menu.add_command(label='Redo',
accelerator='Ctrl+Y',
command=self.text.edit_redo)
self.edit_menu.add_separator()
self.edit_menu.add_command(label='Copy',
accelerator='Ctrl+C',
command=self.copy)
self.edit_menu.add_command(label='Cut',
accelerator='Ctrl+X',
command=self.cut)
self.edit_menu.add_command(label='Paste',
accelerator='Ctrl+V',
command=self.paste)
self.edit_menu.add_command(label='Delete', command=self.delete)
# view menu
self.view_menu = tk.Menu(self.main_menu, tearoff=False)
self.main_menu.add_cascade(label='View', menu=self.view_menu)
self.view_menu.add_command(label='Zoon in', command=self.zoom_in)
self.view_menu.add_command(label='Zoom out', command=self.zoom_out)
self.view_menu.add_separator()
self.view_menu.add_command(label='Change font',
command=self.change_font)
# color menu
self.color_menu = tk.Menu(self.view_menu, tearoff=False)
self.view_menu.add_cascade(label='Change Colors', menu=self.color_menu)
self.color_menu.add_command(label='Change background color',
command=self.change_bg)
self.color_menu.add_command(label='Change foreground color',
command=self.change_fg)
# cursor menu
self.cursor_menu = tk.Menu(self.view_menu, tearoff=False)
self.view_menu.add_cascade(label='Change cursor',
menu=self.cursor_menu)
self.cursor_menu.add_command(label='Change color',
command=self.change_cursor_color)
self.cursor_menu.add_command(label='Change width',
command=self.change_cursor_width)
# shortcuts
self.master.bind('<Control-n>', self.new_file)
self.master.bind('<Control-N>', self.new_file)
self.master.bind('<Control-o>', self.open_file)
self.master.bind('<Control-O>', self.open_file)
self.master.bind('<Control-s>', self.save_file)
self.master.bind('<Control-S>', self.save_file)
self.master.bind('<Shift-Control-s>', self.save_as)
self.master.bind('<Shift-Control-S>', self.save_as)
self.master.bind('<Control-plus>', self.zoom_in)
self.master.bind('<Control-minus>', self.zoom_out)
self.master.protocol('WM_DELETE_WINDOW', self.close_programe)
# load all the important data.
def load(self):
# get the home path
self.home = os.getenv('HOMEPATH')
self.home = 'C://' + self.home
# create folder to store the config data
if not os.path.isdir(os.path.join(self.home, '.SB_Text_Editor')):
os.mkdir(os.path.join(self.home, '.SB_Text_Editor'))
# create the setting file to store the setting data.
if os.path.isfile(
os.path.join(self.home, '.SB_Text_Editor/settings.txt')):
with open(os.path.join(self.home, '.SB_Text_Editor/settings.txt'),
'r') as settings:
# in the setting file first line contain the data about the font.
tmp = settings.readline().strip().split(';')
if len(tmp) == 6:
# load the font
self.font_dict['family'] = tmp[0]
self.font_dict['size'] = int(tmp[1])
self.font_dict['weight'] = tmp[2]
self.font_dict['slant'] = tmp[3]
self.font_dict['underline'] = int(tmp[4])
self.font_dict['overstrike'] = int(tmp[5])
self.font = Font(family=self.font_dict['family'],
size=self.font_dict['size'],
weight=self.font_dict['weight'],
slant=self.font_dict['slant'],
underline=self.font_dict['underline'],
overstrike=self.font_dict['overstrike'])
self.text.config(font=self.font)
# second line contain the information about background and foreground color.
tmp = settings.readline().strip().split(';')
# load the colors
if len(tmp) == 2:
self.bg = tmp[0]
self.fg = tmp[1]
self.text.config(bg=self.bg, fg=self.fg)
# third line contain data about cursor color and width.
tmp = settings.readline().strip().split(';')
if len(tmp) == 2:
self.insert = tmp[0]
self.insert_width = tmp[1]
self.text.config(insertbackground=self.insert,
insertwidth=self.insert_width)
# create new file
def new_file(self, event=None):
if len(self.text.get(1.0, tk.END)) > 1:
inp = messagebox.askyesnocancel('SB Text Editor',
'Do you want to save this file?')
if inp == True:
self.save_file()
elif inp == None:
return None
self.file_name = None
self.text.delete(1.0, tk.END)
self.text.edit_reset()
# open any text file
def open_file(self, event=None):
file = filedialog.askopenfile(filetype=[('Text file',
'.txt'), ('All file', '*.*')])
if file != None:
self.text.delete(1.0, tk.END)
for line in file:
self.text.insert(tk.INSERT, line)
self.file_name = file.name
# save the file
def save_file(self, event=None):
if self.file_name == None:
self.save_as()
else:
with open(self.file_name, 'w') as file:
file.write(self.text.get(1.0, tk.END))
def save_as(self, event=None):
file = filedialog.asksaveasfile(mode='w',
filetypes=[('Text file', '.txt'),
('All file', '*.*')],
defaultextension='.txt')
if file != None:
file.write(self.text.get(1.0, tk.END))
self.file_name = file.name
file.close()
# exit function
def close_programe(self, event=None):
if len(self.text.get(1.0, tk.END)) > 1:
inp = messagebox.askyesnocancel('SB Text Editor',
'Do you want to save this file?')
if inp == True:
self.save_file()
elif inp == None:
return None
self.master.quit()
# copy function
def copy(self, event=None):
self.text.event_generate('<<Copy>>')
# cut function
def cut(self, event=None):
self.text.event_generate('<<Cut>>')
# paste function
def paste(self, event=None):
self.text.event_generate('<<Paste>>')
# delete selected line
def delete(self, event=None):
try:
i1 = self.text.index('sel.first')
i2 = self.text.index('sel.last')
self.text.delete(i1, i2)
except:
return None
# zoom in function
def zoom_in(self, event=None):
size = self.font.cget('size')
size += 1
if size > 30:
size = 30
self.font_dict['size'] = size
self.font.config(size=size)
self.text.config(font=self.font)
# zoom out function
def zoom_out(self, event=None):
size = self.font.cget('size')
size -= 1
if size < 3:
size = 3
self.font_dict['size'] = size
self.font.config(size=size)
self.text.config(font=self.font)
# change font function
def change_font(self, event=None):
font_dict = tkfontchooser.askfont(**self.font_dict)
if font_dict != '':
self.font_dict = font_dict
font_dict = list(font_dict.values())
font = Font(family=font_dict[0],
size=font_dict[1],
weight=font_dict[2],
slant=font_dict[3],
underline=font_dict[4],
overstrike=font_dict[5])
self.font = font
self.text.config(font=self.font)
with open(os.path.join(self.home, '.SB_Text_Editor/settings.txt'),
'w') as settings:
tmp = ';'.join(
map(lambda item: str(item), list(self.font_dict.values())))
tmp += '\n' + self.bg + ';' + self.fg
tmp += '\n' + self.insert + ';' + str(self.insert_width)
settings.write(tmp)
# change background color
def change_bg(self, event=None):
color = colorchooser.askcolor()
if color[1] != None:
self.bg = color[1]
self.text.config(bg=self.bg)
with open(os.path.join(self.home, '.SB_Text_Editor/settings.txt'),
'w') as settings:
tmp = ';'.join(
map(lambda item: str(item), list(self.font_dict.values())))
tmp += '\n' + self.bg + ';' + self.fg
tmp += '\n' + self.insert + ';' + str(self.insert_width)
settings.write(tmp)
# change foreground color
def change_fg(self, event=None):
color = colorchooser.askcolor()
if color[1] != None:
self.fg = color[1]
self.text.config(fg=self.fg)
with open(os.path.join(self.home, '.SB_Text_Editor/settings.txt'),
'w') as settings:
tmp = ';'.join(
map(lambda item: str(item), list(self.font_dict.values())))
tmp += '\n' + self.bg + ';' + self.fg
tmp += '\n' + self.insert + ';' + str(self.insert_width)
settings.write(tmp)
# change cursor color
def change_cursor_color(self):
color = colorchooser.askcolor()
if color[1] != None:
self.insert = color[1]
self.text.config(insertbackground=self.insert)
with open(os.path.join(self.home, '.SB_Text_Editor/settings.txt'),
'w') as settings:
tmp = ';'.join(
map(lambda item: str(item), list(self.font_dict.values())))
tmp += '\n' + self.bg + ';' + self.fg
tmp += '\n' + self.insert + ';' + str(self.insert_width)
settings.write(tmp)
def make_small(self):
self.insert_width = 1
self.text.config(insertwidth=self.insert_width)
with open(os.path.join(self.home, '.SB_Text_Editor/settings.txt'),
'w') as settings:
tmp = ';'.join(
map(lambda item: str(item), list(self.font_dict.values())))
tmp += '\n' + self.bg + ';' + self.fg
tmp += '\n' + self.insert + ';' + str(self.insert_width)
settings.write(tmp)
self.tmp_window.destroy()
def make_medium(self):
self.insert_width = 3
self.text.config(insertwidth=self.insert_width)
with open(os.path.join(self.home, '.SB_Text_Editor/settings.txt'),
'w') as settings:
tmp = ';'.join(
map(lambda item: str(item), list(self.font_dict.values())))
tmp += '\n' + self.bg + ';' + self.fg
tmp += '\n' + self.insert + ';' + str(self.insert_width)
settings.write(tmp)
self.tmp_window.destroy()
def make_large(self):
self.insert_width = 5
self.text.config(insertwidth=self.insert_width)
with open(os.path.join(self.home, '.SB_Text_Editor/settings.txt'),
'w') as settings:
tmp = ';'.join(
map(lambda item: str(item), list(self.font_dict.values())))
tmp += '\n' + self.bg + ';' + self.fg
tmp += '\n' + self.insert + ';' + str(self.insert_width)
settings.write(tmp)
self.tmp_window.destroy()
def change_cursor_width(self):
self.tmp_window = tk.Toplevel()
self.tmp_window.title('Select size')
self.tmp_window.resizable(False, False)
button_1 = tk.Button(self.tmp_window,
text='Small',
command=self.make_small)
button_1.pack(side=tk.LEFT)
button_2 = tk.Button(self.tmp_window,
text='Medium',
command=self.make_medium)
button_2.pack(side=tk.LEFT)
button_3 = tk.Button(self.tmp_window,
text='Large',
command=self.make_large)
button_3.pack(side=tk.LEFT)
class text_editor:
current_open_file = "no_file"
def open_file(self, event=""):
#print("Openning File")
open_return = filedialog.askopenfile(initialdir="/",
title="select file to open",
filetypes=(("text files",
"*.txt"),
("all files", "*.*")))
if (open_return != None):
self.text_area.delete(1.0, END)
for line in open_return:
self.text_area.insert(END, line)
self.current_open_file = open_return.name
open_return.close()
def save_as_file(self, event=""):
f = filedialog.asksaveasfile(mode="w", defaultextension=".txt")
if f is None:
return
text2save = self.text_area.get(1.0, END)
self.current_open_file = f.name
f.write(text2save)
f.close()
def save_file(self, event=""):
if self.current_open_file == "no_file":
self.save_as_file()
else:
f = open(self.current_open_file, "w+")
f.write(self.text_area.get(1.0, END))
f.close()
def custom_quit(self):
answer = messagebox.askokcancel(
"Are you Sure ?",
"Are you sure want to exit this page Your data will be lost and you will come on road"
)
if (answer):
print("Exit")
quit()
def res(self):
print("Resize")
root.geometry("500x500")
def nor(self):
print("Normal")
root.geometry("")
def new_file(self, event=""):
self.text_area.delete(1.0, END)
self.current_open_file == "no_file"
def copy_text(self, event=""):
self.text_area.clipboard_clear()
self.text_area.clipboard_append(self.text_area.selection_get())
def cut_text(self, event=""):
self.copy_text()
self.text_area.delete("sel.first", "sel.last")
def paste_text(self, event=""):
self.text_area.insert(INSERT, self.text_area.clipboard_get())
def __init__(self, master):
self.scroll = Scrollbar()
self.scroll.pack(side=RIGHT, fill=Y)
self.master = Font(family="Times New Roman",
size=20,
weight="bold",
slant="italic")
self.master = master #5
master.title("textpad") #1
self.text_area = Text(self.master,
undo=True,
height=30,
wrap=WORD,
padx=10,
pady=10,
selectbackground="gray",
yscrollcommand=self.scroll.set) #2
self.text_area.configure(font=master)
self.text_area.pack(fill=BOTH, expand=1) #3
self.scroll.config(command=self.text_area.yview)
self.main_menu = Menu() #4
self.master.config(menu=self.main_menu)
# creating file menu
self.file_menu = Menu(self.main_menu, tearoff=False)
self.main_menu.add_cascade(label="File", menu=self.file_menu)
self.file_menu.add_command(label="New Page Ctrl+N",
command=self.new_file)
self.file_menu.add_command(label="Open Ctrl+O",
command=self.open_file)
self.file_menu.add_command(label="Save Ctrl+S",
command=self.save_file)
self.file_menu.add_command(label="Save as....",
command=self.save_as_file)
self.file_menu.add_separator()
self.file_menu.add_command(label="Page Setup")
self.file_menu.add_command(label="Print........ Ctrl+P")
self.file_menu.add_separator()
self.file_menu.add_command(label="Exit", command=self.custom_quit)
# Binding Working
root.bind('<Control-n>', self.new_file)
root.bind('<Control-o>', self.open_file)
root.bind('<Control-s>', self.save_file)
root.bind('<Control-Shift-s>', self.save_as_file)
root.bind('<Control-p>')
root.bind('<Control-c>')
root.bind('<Control-x>')
root.bind('<Control-v>')
root.bind('<Control-z>')
# creating Edit menu
self.edit_menu = Menu(self.main_menu, tearoff=False)
self.main_menu.add_cascade(label="Edit", menu=self.edit_menu)
self.edit_menu.add_command(label="Undo Ctrl+Z",
command=self.text_area.edit_undo)
self.edit_menu.add_command(label="Redo",
command=self.text_area.edit_redo)
self.edit_menu.add_separator()
self.edit_menu.add_command(label="Cut Ctrl+X",
command=self.cut_text)
self.edit_menu.add_command(label="Copy Ctrl+C",
command=self.copy_text)
self.edit_menu.add_command(label="Past Ctrl+V",
command=self.paste_text)
self.edit_menu.add_command(label="Delete Del")
self.edit_menu.add_separator()
self.edit_menu.add_command(label="Search with Bing Ctrl+E ")
self.edit_menu.add_command(label="Resize Window", command=self.res)
self.edit_menu.add_command(label="NormalSize Window", command=self.nor)
# creating Formate menu
self.formate_menu = Menu(self.main_menu, tearoff=False)
self.main_menu.add_cascade(label="Formate", menu=self.formate_menu)
self.formate_menu.add_command(label="Word Wrap")
self.formate_menu.add_command(label="Font.......")
# creating Code menu
self.code_menu = Menu(self.main_menu, tearoff=False)
self.main_menu.add_cascade(label="Code", menu=self.code_menu)
# creating Run menu
self.run_menu = Menu(self.main_menu, tearoff=False)
self.main_menu.add_cascade(label="Run", menu=self.run_menu)
# creating View menu
self.view_menu = Menu(self.main_menu, tearoff=False)
self.main_menu.add_cascade(label="View", menu=self.view_menu)
self.view_menu.add_command(label="Zoom")
self.view_menu.add_command(label="Status Bar")
# creating Help menu
self.help_menu = Menu(self.main_menu, tearoff=False)
self.main_menu.add_cascade(label="Help", menu=self.help_menu)
self.help_menu.add_command(label="View Help")
self.help_menu.add_command(label="About Notepad")
# Starus Bar
status = Label(root,
text="Running.......\t\t\t Window(Ctrl)\t\t\t\t\t 100%",
relief=SUNKEN,
anchor=W,
bd=1)
status.pack(side=BOTTOM, fill=X)
class TopFastMenu:
def __init__(self, master):
frame = Frame(master=master)
frame.pack(expand=YES, fill=X)
fontsList = ['Times New Roman', 'Segoe UI', 'Arial']
sizesList = [i + 2 for i in range(30)]
self.fontsVar = StringVar()
self.fontsVar.set(fontsList[0])
self.sizeVar = IntVar()
self.sizeVar.set(sizesList[10])
self.font = Font(family=self.fontsVar.get(), size=self.sizeVar.get())
self.tagsNames = {}
self.tag = 'styleFont'
self.tagIndex = 0
self.keyForDel = None
OptionMenu(
frame,
self.fontsVar,
*fontsList,
command=lambda arg: self.__setFontToAllText()).pack(side=LEFT)
OptionMenu(
frame,
self.sizeVar,
*sizesList,
command=lambda arg: self.__setFontToAllText()).pack(side=LEFT)
Button(frame,
text='B',
font=Font(size='12', weight='bold'),
command=lambda: self.__setFont(weight='bold')).pack(side=LEFT)
Button(frame,
text='I',
font=Font(size='12', slant='italic'),
command=lambda: self.__setFont(slant='italic')).pack(side=LEFT)
Button(frame,
text='U',
font=Font(size='12', underline='1'),
command=lambda: self.__setFont(underline=1)).pack(side=LEFT)
def __setFontToAllText(self):
self.text.tag_add('text', '1.0', END)
self.font.config(family=self.fontsVar.get(), size=self.sizeVar.get())
self.text.tag_config('text', font=self.font)
for key in self.tagsNames:
self.text.tag_delete(key)
for key in self.tagsNames:
print(key)
self.text.tag_add(key, self.tagsNames[key][0],
self.tagsNames[key][1])
self.tagsNames[key][2] = Font(family=self.fontsVar.get(),
size=self.sizeVar.get())
if self.tagsNames[key][3]:
self.tagsNames[key][2].config(weight='bold')
print('if bold')
if self.tagsNames[key][4]:
self.tagsNames[key][2].config(slant='italic')
print('if slant')
if self.tagsNames[key][5]:
self.tagsNames[key][2].config(underline=1)
print('if underline')
self.text.tag_config(key, font=self.tagsNames[key][2])
def setTextArea(self, textArea):
self.text = textArea
self.text.config(font=Font(family='Times New Roman', size=12))
self.text.pack(expand=YES, fill=BOTH)
def __setFont(self, weight=None, slant=None, underline=0):
ind1 = self.text.index(SEL_FIRST)
ind2 = self.text.index(SEL_LAST)
isWeight = False
isSlant = False
isUndeline = False
isBreak = False
for index in range(len(self.tagsNames)):
print(self.text.tag_names())
for val in self.text.tag_names():
if val != 'sel' and val != 'text':
print(val)
ranges = self.text.tag_ranges(val)
for tagRange in range(0, len(ranges), 2):
indList1 = list(map(int, ind1.split('.')))
indList2 = list(map(int, ind2.split('.')))
rangeList1 = list(
map(int,
str(ranges[tagRange]).split('.')))
rangeList2 = list(
map(int,
str(ranges[tagRange + 1]).split('.')))
print(indList1, indList2, rangeList1, rangeList2)
if indList1 == rangeList1 and indList2 == rangeList2:
self.__checkFormats(val, weight, slant, underline)
self.text.tag_config(val,
font=self.tagsNames[val][2])
self.tagsNames[val] = [
ind1, ind2, self.tagsNames[val][2],
self.tagsNames[val][3], self.tagsNames[val][4],
self.tagsNames[val][5]
]
isBreak = True
break
if indList2 >= rangeList1 and indList2 <= rangeList2 and indList1 < rangeList1:
print(
'indList2 >= rangeList1 and indList2 <= rangeList2 and indList1 < rangeList1'
)
self.text.tag_add(val, ind1, ranges[tagRange + 1])
self.__setFormats(val, weight, slant, underline)
self.text.tag_config(val,
font=self.tagsNames[val][2])
isBreak = True
break
if indList1 >= rangeList1 and indList1 <= rangeList2 and indList2 > rangeList2:
print(
'indList1 >= rangeList1 and indList1 <= rangeList2 and indList2 > rangeList2'
)
self.text.tag_add(val, ranges[tagRange], ind2)
self.__setFormats(val, weight, slant, underline)
self.text.tag_config(val,
font=self.tagsNames[val][2])
isBreak = True
break
if indList1 > rangeList1 and indList2 < rangeList2:
print(
'indList1 > rangeList1 and indList2 < rangeList2'
)
self.text.tag_delete(val)
self.text.tag_add(val, ranges[tagRange], ind1)
self.__setFormats(val, weight, slant, underline)
self.text.tag_config(val,
font=self.tagsNames[val][2])
ind1 = ind2
ind2 = ranges[tagRange + 1]
break
if indList1 >= rangeList1 and indList1 <= rangeList2 and indList2 == rangeList2:
print(
'indList1 >= rangeList1 and indList1 <= rangeList2 and indList2 == rangeList2; val =>',
val)
self.text.tag_delete(val)
self.text.tag_add(val, ranges[tagRange], ind1)
self.__forDeletedTags(val)
self.text.tag_config(val,
font=self.tagsNames[val][2])
isBreak = True
break
if indList1 == rangeList1 and indList2 >= rangeList1 and indList2 <= rangeList2:
print(
'indList1 == rangeList1 and indList2 >= rangeList1 and indList2 <= rangeList2'
)
self.text.tag_add(val, ind2, ranges[tagRange + 1])
self.__forDeletedTags(val)
self.text.tag_config(val,
font=self.tagsNames[val][2])
isBreak = True
break
if isBreak:
break
else:
tag = self.tag + str(self.tagIndex)
if weight is not None:
font = Font(family=self.fontsVar.get(),
size=self.sizeVar.get(),
weight=weight)
isWeight = True
if slant is not None:
font = Font(family=self.fontsVar.get(),
size=self.sizeVar.get(),
slant=slant)
isSlant = True
if underline:
font = Font(family=self.fontsVar.get(),
size=self.sizeVar.get(),
underline=underline)
isUndeline = True
self.text.tag_add(tag, ind1, ind2)
self.text.tag_config(tag, font=font)
self.tagsNames[tag] = [
ind1, ind2, font, isWeight, isSlant, isUndeline
]
self.tagIndex += 1
print('new teg added; tag =>', tag)
if self.keyForDel is not None:
del self.tagsNames[self.keyForDel]
self.keyForDel = None
def __checkFormats(self, val, weight, slant, underline):
if weight is not None and self.tagsNames[val][3]:
self.tagsNames[val][2].config(weight='normal')
self.tagsNames[val][3] = False
print('weight if')
elif weight is not None and not self.tagsNames[val][3]:
self.tagsNames[val][2].config(weight=weight)
self.tagsNames[val][3] = True
print('weight elif')
if slant is not None and self.tagsNames[val][4]:
self.tagsNames[val][2].config(slant='roman')
self.tagsNames[val][4] = False
print('slant if')
elif slant is not None and not self.tagsNames[val][4]:
self.tagsNames[val][2].config(slant=slant)
self.tagsNames[val][4] = True
print('slant elif')
if underline and self.tagsNames[val][5]:
self.tagsNames[val][2].config(underline=0)
self.tagsNames[val][5] = False
print('underline if')
elif underline and not self.tagsNames[val][5]:
self.tagsNames[val][2].config(underline=underline)
self.tagsNames[val][5] = True
print('underline elif')
def __setFormats(self, val, weight, slant, underline):
if weight:
self.tagsNames[val][2].config(weight=weight)
self.tagsNames[val][3] = True
print('__setFormats weight')
if slant:
self.tagsNames[val][2].config(slant=slant)
self.tagsNames[val][4] = True
print('__setFormats slant')
if underline:
self.tagsNames[val][2].config(underline=underline)
self.tagsNames[val][5] = True
print('__setFormats underline')
def __forDeletedTags(self, val):
if self.tagsNames[val][3]:
self.tagsNames[val][2].config(weight='bold')
if self.tagsNames[val][4]:
self.tagsNames[val][2].config(slant='italic')
if self.tagsNames[val][5]:
self.tagsNames[val][2].config(underline=1)
def openFile(root, text, dirToOpen=None):
if dirToOpen == None:
dirToOpen = askopenfilename(parent=root,
title='Choose file to open',
filetypes=(("Notecalc documents (*.nxc)",
"*.nxc"),
("Text documents (*.txt)",
"*.txt"), ("All files",
"*.*")))
dirToOpen = toPath(dirToOpen)
with open(dirToOpen, 'r', encoding='utf-8') as file:
text.delete('1.0', 'end')
fileText = file.read()
if str(dirToOpen).endswith(".nxc") == True:
fileText = literal_eval(fileText)
final = ""
for (key, value, index) in fileText:
if key == "text":
final += value
text.insert('1.0', final)
tagsInitIndexes = list()
for (key, value, index) in fileText:
if key == "tagon":
tagsInitIndexes.append(index)
elif key == "tagoff":
tagInitIndex = tagsInitIndexes.pop(0)
if len(value) < 14:
size = globals.font.cget("size")
size = str(size)
if len(size) < 2:
size = "0" + size
sampleTag = "......." + size[0] + size[
1] + globals.colorConfig["def"]
size = int(size)
if "bt" in value:
sampleTag = replaceSubstring(
sampleTag, ".", "n", globals.formsIndex["n"])
elif "stit" in value:
sampleTag = replaceSubstring(
sampleTag, ".", "i", globals.formsIndex["i"])
sizeSubTitulo = size + 2
sizeSubTitulo = str(sizeSubTitulo)
if len(sizeSubTitulo) < 2:
sizeSubTitulo = "0" + sizeSubTitulo
sampleTag = replaceSubstring(
sampleTag,
sampleTag[globals.formsIndex["size"]],
sizeSubTitulo[0], globals.formsIndex["size"])
sampleTag = replaceSubstring(
sampleTag,
sampleTag[globals.formsIndex["size"] + 1],
sizeSubTitulo[1],
globals.formsIndex["size"] + 1)
elif "tit" in value:
if (sampleTag[globals.formsIndex["n"]] != "n"):
sampleTag = replaceSubstring(
sampleTag, ".", "n",
globals.formsIndex["n"])
sizeTitulo = size + 4
sizeTitulo = str(sizeTitulo)
if len(sizeTitulo) < 2:
sizeTitulo = "0" + sizeTitulo
sampleTag = replaceSubstring(
sampleTag,
sampleTag[globals.formsIndex["size"]],
sizeTitulo[0], globals.formsIndex["size"])
sampleTag = replaceSubstring(
sampleTag,
sampleTag[globals.formsIndex["size"] + 1],
sizeTitulo[1], globals.formsIndex["size"] + 1)
elif "it" in value:
if (sampleTag[globals.formsIndex["i"]] != "i"):
sampleTag = replaceSubstring(
sampleTag, ".", "i",
globals.formsIndex["i"])
elif "un" in value:
sampleTag = replaceSubstring(
sampleTag, ".", "s", globals.formsIndex["s"])
elif "tc" in value:
sampleTag = replaceSubstring(
sampleTag, ".", "t", globals.formsIndex["t"])
elif "cor" in value:
cor = value[3::]
sampleTag = "cor" + sampleTag[
globals.formsIndex["n"]:globals.
formsIndex["hex"]] + cor
# Pra manter a compatibilidade com os arquivos da antiga formatação
elif value.startswith("#"):
cor = value
sampleTag = "cor" + sampleTag[
globals.formsIndex["n"]:globals.
formsIndex["hex"]] + cor
fontDaFormatacao = Font(text, text.cget("font"))
fontSize = fontDaFormatacao.cget("size")
if "n" in sampleTag[globals.formsIndex["n"]:]:
fontDaFormatacao.config(weight="bold")
if "i" in sampleTag[globals.formsIndex["n"]:]:
fontDaFormatacao.config(slant="italic")
if "t" in sampleTag[globals.formsIndex["n"]:]:
fontDaFormatacao.config(overstrike=1)
if "s" in sampleTag[globals.formsIndex["n"]:]:
fontDaFormatacao.config(underline=1)
if (len(sampleTag) == 14):
size = sampleTag[5:7]
elif (len(sampleTag) == 16):
size = sampleTag[globals.formsIndex["size"]:globals
.formsIndex["size"] + 2]
fontDaFormatacao.config(size=int(size))
cor = globals.configCores["padrao"]
prefixo = "..."
if sampleTag[0] == "c":
cor = sampleTag[globals.formsIndex["hex"]::]
prefixo = "cor"
elif globals.vsc == True:
if "n" in sampleTag[globals.
formsIndex["n"]:] and int(
size) != fontSize + 4:
cor = globals.configCores["negrito"]
prefixo = "vbt"
if "n" in sampleTag[globals.
formsIndex["n"]:] and int(
size) == fontSize + 4:
cor = globals.configCores["titulo"]
prefixo = "vtt"
if "i" in sampleTag[globals.
formsIndex["n"]:] and int(
size) != fontSize + 2:
cor = globals.configCores["italico"]
prefixo = "vit"
if "i" in sampleTag[globals.
formsIndex["n"]:] and int(
size) == fontSize + 2:
cor = globals.configCores["subtitulo"]
prefixo = "vst"
if "s" in sampleTag[globals.formsIndex["n"]:]:
cor = globals.configCores["sublinhado"]
prefixo = "vtc"
if "t" in sampleTag[globals.formsIndex["n"]:]:
cor = globals.configCores["tachado"]
prefixo = "vun"
sampleTag = prefixo + sampleTag[
globals.formsIndex["n"]:globals.
formsIndex["hex"]] + cor
text.tag_config(sampleTag,
font=fontDaFormatacao,
foreground=cor)
text.tag_add(sampleTag, f"{tagInitIndex}", f"{index}")
elif len(value) >= 14:
fontDaFormatacao = Font(text, text.cget("font"))
fontSize = fontDaFormatacao.cget("size")
if "n" in value[globals.formsIndex["n"]:]:
fontDaFormatacao.config(weight="bold")
if "i" in value[globals.formsIndex["n"]:]:
fontDaFormatacao.config(slant="italic")
if "t" in value[globals.formsIndex["n"]:]:
fontDaFormatacao.config(overstrike=1)
if "s" in value[globals.formsIndex["n"]:]:
fontDaFormatacao.config(underline=1)
if (len(value) == 14):
size = value[5:7]
elif (len(value) == 16):
size = value[globals.formsIndex["size"]:globals.
formsIndex["size"] + 2]
fontDaFormatacao.config(size=int(size))
cor = globals.configCores["padrao"]
if value[0] == "v" and globals.vsc == True:
if value[:globals.formsIndex["n"]] == "vbt":
cor = globals.configCores["negrito"]
if value[:globals.formsIndex["n"]] == "vtt":
cor = globals.configCores["titulo"]
if value[:globals.formsIndex["n"]] == "vit":
cor = globals.configCores["italico"]
if value[:globals.formsIndex["n"]] == "vst":
cor = globals.configCores["subtitulo"]
if value[:globals.formsIndex["n"]] == "vun":
cor = globals.configCores["sublinhado"]
if value[:globals.formsIndex["n"]] == "vtc":
cor = globals.configCores["tachado"]
elif value[0] == "c":
cor = value[globals.formsIndex["hex"]::]
value = value[:globals.formsIndex["hex"]] + cor
text.tag_config(value,
font=fontDaFormatacao,
foreground=cor)
text.tag_add(value, f"{tagInitIndex}", f"{index}")
text.edit_modified(False)
globals.dirDeTrabalhoAtual = dirToOpen
chdir(dirname(dirToOpen))
root.title("Lolicalc " + str(globals.dirDeTrabalhoAtual))
return True
else:
text.edit_modified(False)
globals.dirDeTrabalhoAtual = dirToOpen
chdir(dirname(dirToOpen))
root.title("Lolicalc " + str(globals.dirDeTrabalhoAtual))
text.insert('1.0', fileText)
return True
class KeyEventsEdit(tk.Canvas):
# Inherits from Canvas so it can have scroll bar
rows = []
def __init__(self, parent):
self.root = parent
tk.Canvas.__init__(self, parent)
# tableFrame = tk.Frame(self)
self.bind('<Configure>', self.on_resize)
self.height = self.winfo_reqheight()
self.width = self.winfo_reqwidth()
self.configure(highlightthickness=0)
self.items_font = Font(family='Times New Roman', size=16)
self.coordinates_font = Font(family='Times New Roman',
size=30,
weight="bold")
self.headers_font = Font()
self.icon_header = tk.Label(self, text='Image', font=self.headers_font)
self.type_header = tk.Label(self,
text='Method',
font=self.headers_font)
self.coord_header = tk.Label(self,
text='Region',
font=self.headers_font)
self.is_split_header = tk.Label(self,
text='Split',
font=self.headers_font)
self.icon_header.grid(column=0, row=0, padx=1, pady=5, sticky='nsew')
self.type_header.grid(column=1, row=0, padx=1, pady=5, sticky='nsew')
self.coord_header.grid(column=2, row=0, padx=1, pady=5, sticky='nsew')
self.is_split_header.grid(column=3,
row=0,
padx=1,
pady=5,
sticky='nsew')
# Makes all columns of equal size
self.columnconfigure(0, weight=1)
self.columnconfigure(1, weight=1)
self.columnconfigure(2, weight=1)
self.columnconfigure(3, weight=1)
self.addtag_all('all')
if self.rows is None or len(self.rows) is 0:
self.add_row()
# https://stackoverflow.com/a/22837522/10062180
def on_resize(self, event):
# determine the ratio of old width/height to new width/height
width_scale = float(event.width) / self.width
height_scale = float(event.height) / self.height
self.width = event.width
self.height = event.height
# resize the canvas
self.config(width=self.width, height=self.height)
# rescale all the objects tagged with the "all" tag
self.scale('all', 0, 0, width_scale, height_scale)
# Adds a new row at the bottom of the table
def add_row(self):
# photo_img = ImageTk.PhotoImage(pil_img)
icon = tk.Label(self)
event_type = DropdownFrame(self,
default_value='',
set_width=3,
dropdown_strs=[''])
coordinates = tk.Button(self,
text='!',
font=self.coordinates_font,
width=4,
height=1,
borderwidth=5)
coordinates.config(fg='red')
img = tk.PhotoImage(width=1, height=1)
is_split = tk.Checkbutton(self, width=10, height=4)
items = [icon, event_type, coordinates, is_split]
for i, item in enumerate(items):
item.grid(column=i, row=len(self.rows) + 1, padx=5, pady=5)
self.rows.append(items)
self.addtag_all('all')
def set_bg_color(self, color):
self.configure(background=color)
for row in self.rows:
[icon, event_type, coordinates, is_split] = row
coordinates.config(bg=color)
is_split.config(bg=color)
def change_text_size(self, size):
self.headers_font.config(size=size)
self.items_font.config(size=size - 2)
self.coordinates_font.config(size=size + 5)
def change_text_color(self, color):
self.icon_header.configure(fg=color)
self.type_header.configure(fg=color)
self.coord_header.configure(fg=color)
self.is_split_header.configure(fg=color)
def change_text_font(self, font_family):
self.headers_font.configure(family=font_family)
self.items_font.configure(family=font_family)
class CreateRoute(tk.Frame):
FONT_STYLE = 'Times New Roman'
FONT_SIZE = 16
def __init__(self, parent):
self.root = parent
tk.Frame.__init__(self, parent)
self.title_string_var = tk.StringVar()
self.description_string_var = tk.StringVar()
self.title_label_font = Font(family=self.FONT_STYLE,
size=self.FONT_SIZE)
self.title_label = tk.Label(self,
text='Name',
anchor='w',
font=self.title_label_font)
self.title_entry = tk.Entry(self, textvariable=self.title_string_var)
# description_label = tk.Label(self, text='Description', anchor='w')
# description_entry = tk.Entry(self, textvariable=self.title_string_var)
self.key_event_canvas = KeyEventsEdit(self)
add_row_button = tk.Button(self,
text='+',
bg='green',
command=self.add_row_clicked,
width=10)
self.title_label.grid(column=0, row=0, padx=5, pady=8, sticky='nsew')
self.title_entry.grid(column=1, row=0, padx=5, pady=8, sticky='nsew')
self.columnconfigure(0, weight=1)
self.columnconfigure(1, weight=5)
self.rowconfigure(0, weight=1)
self.rowconfigure(1, weight=1)
self.rowconfigure(2, weight=50)
# description_label.grid(column=0, row=1, padx=5, pady=8, sticky='nsew')
# description_entry.grid(column=1, row=1, padx=5, pady=8, sticky='nsew')
self.key_event_canvas.grid(column=0,
row=2,
columnspan=2,
padx=5,
pady=5,
sticky='nsew')
add_row_button.grid(column=1, row=3, padx=5, pady=5, sticky='e')
def add_row_clicked(self):
self.key_event_canvas.add_row()
def set_bg_color(self, color):
self.configure(background=color)
self.key_event_canvas.set_bg_color(color)
def change_text_size(self, size):
self.title_label_font.config(size=size)
self.key_event_canvas.change_text_size(size=size)
def change_text_color(self, color):
self.title_label.configure(fg=color)
self.key_event_canvas.change_text_color(color=color)
def change_text_font(self, font_family):
self.title_label_font.configure(family=font_family)
self.key_event_canvas.change_text_font(font_family=font_family)
