def update_menu(self):
"""Populate self.menu_show_cat and self.menu_hide_cat with the categories."""
self.menu_hide_cat.delete(0, "end")
self.menu_show_cat.delete(0, "end")
categories = CONFIG.options("Categories")
categories.sort()
for cat in categories:
self.menu_show_cat.add_command(
label=cat.capitalize(), command=lambda c=cat: self.show_cat(c))
self.menu_hide_cat.add_command(
label=cat.capitalize(), command=lambda c=cat: self.hide_cat(c))
def __init__(self, master):
Toplevel.__init__(self, master)
self.title(_("Export"))
self.resizable(False, False)
self.grab_set()
# self.columnconfigure(0, weight=1)
self.categories = CONFIG.options("Categories")
self.categories.sort()
self.categories_to_export = []
self.only_visible = False
self.ch_all = Checkbutton(self,
text=_("Select all"),
command=self.select_all)
self.ch_only_visible = Checkbutton(self, text=_("Only visible notes"))
self.ch_all.grid(sticky="w", padx=4, pady=4)
self.ch_only_visible.grid(sticky="w", padx=4, pady=4)
Separator(self).grid(sticky="ew", padx=4, pady=4)
self.checkbuttons = []
for cat in self.categories:
self.checkbuttons.append(
Checkbutton(self,
text=cat.capitalize(),
command=self.toggle_select_all))
self.checkbuttons[-1].grid(sticky="w", padx=4, pady=4)
frame = Frame(self)
frame.grid()
Button(frame, text="Ok", command=self.ok).grid(row=0,
column=0,
sticky="w",
padx=4,
pady=4)
Button(frame, text=_("Cancel"), command=self.destroy).grid(row=0,
column=1,
sticky="e",
padx=4,
pady=4)
self.ch_all.state(("selected", ))
self.select_all()
def update_notes(self, col_changes={}, name_changes={}):
"""Update the notes after changes in the categories."""
categories = CONFIG.options("Categories")
categories.sort()
self.menu_notes.delete(0, "end")
self.hidden_notes = {cat: {} for cat in categories}
for key in self.note_data:
cat = self.note_data[key]["category"]
if cat in name_changes:
cat = name_changes[cat]
self.note_data[key]["category"] = cat
if self.note_data[key]["visible"]:
self.notes[key].change_category(cat)
elif cat not in categories:
default = CONFIG.get("General", "default_category")
default_color = CONFIG.get("Categories", default)
if self.note_data[key]["visible"]:
self.notes[key].change_category(default)
self.note_data[key]["category"] = default
self.note_data[key]["color"] = default_color
cat = default
if cat in col_changes:
old_color, new_color = col_changes[cat]
if self.note_data[key]["color"] == old_color:
self.note_data[key]["color"] = new_color
if self.note_data[key]["visible"]:
self.notes[key].change_color(cst.INV_COLORS[new_color])
if not self.note_data[key]['visible']:
self.add_note_to_menu(key, self.note_data[key]["title"],
self.note_data[key]['category'])
else:
self.notes[key].update_menu_cat(categories)
self.save()
if self.menu_notes.index("end") is not None:
self.icon.menu.entryconfigure(4, state="normal")
else:
self.icon.menu.entryconfigure(4, state="disabled")
def __init__(self, master, key, **kwargs):
""" Create a new sticky note.
master: main app
key: key identifying this note in master.note_data
kwargs: dictionnary of the other arguments
(title, txt, category, color, tags, geometry, locked, checkboxes,
images, rolled)
"""
Toplevel.__init__(self, master)
# --- window properties
self.id = key
self.is_locked = not (kwargs.get("locked", False))
self.images = []
self.links = {}
self.latex = {}
self.nb_links = 0
self.title('mynotes%s' % key)
self.attributes("-type", "splash")
self.attributes("-alpha", CONFIG.getint("General", "opacity") / 100)
self.focus_force()
# window geometry
self.update_idletasks()
self.geometry(kwargs.get("geometry", '220x235'))
self.save_geometry = kwargs.get("geometry", '220x235')
self.update()
self.rowconfigure(1, weight=1)
self.minsize(10, 10)
self.protocol("WM_DELETE_WINDOW", self.hide)
# --- style
self.style = Style(self)
self.style.configure(self.id + ".TCheckbutton", selectbackground="red")
self.style.map('TEntry', selectbackground=[('!focus', '#c3c3c3')])
selectbg = self.style.lookup('TEntry', 'selectbackground', ('focus', ))
self.style.configure("sel.TCheckbutton", background=selectbg)
self.style.map("sel.TCheckbutton", background=[("active", selectbg)])
# --- note elements
# title
font_title = "%s %s" % (CONFIG.get("Font", "title_family").replace(
" ", "\ "), CONFIG.get("Font", "title_size"))
style = CONFIG.get("Font", "title_style").split(",")
if style:
font_title += " "
font_title += " ".join(style)
self.title_var = StringVar(master=self,
value=kwargs.get("title", _("Title")))
self.title_label = Label(self,
textvariable=self.title_var,
anchor="center",
style=self.id + ".TLabel",
font=font_title)
self.title_entry = Entry(self,
textvariable=self.title_var,
exportselection=False,
justify="center",
font=font_title)
# buttons/icons
self.roll = Label(self, image="img_roll", style=self.id + ".TLabel")
self.close = Label(self, image="img_close", style=self.id + ".TLabel")
self.im_lock = PhotoImage(master=self, file=IM_LOCK)
self.cadenas = Label(self, style=self.id + ".TLabel")
# corner grip
self.corner = Sizegrip(self, style=self.id + ".TSizegrip")
# texte
font_text = "%s %s" % (CONFIG.get("Font", "text_family").replace(
" ", "\ "), CONFIG.get("Font", "text_size"))
self.txt = Text(self,
wrap='word',
undo=True,
selectforeground='white',
inactiveselectbackground=selectbg,
selectbackground=selectbg,
tabs=(10, 'right', 21, 'left'),
relief="flat",
borderwidth=0,
highlightthickness=0,
font=font_text)
# tags
self.txt.tag_configure("bold", font="%s bold" % font_text)
self.txt.tag_configure("italic", font="%s italic" % font_text)
self.txt.tag_configure("bold-italic",
font="%s bold italic" % font_text)
self.txt.tag_configure("underline",
underline=True,
selectforeground="white")
self.txt.tag_configure("overstrike",
overstrike=True,
selectforeground="white")
self.txt.tag_configure("center", justify="center")
self.txt.tag_configure("left", justify="left")
self.txt.tag_configure("right", justify="right")
self.txt.tag_configure("link",
foreground="blue",
underline=True,
selectforeground="white")
self.txt.tag_configure("list",
lmargin1=0,
lmargin2=21,
tabs=(10, 'right', 21, 'left'))
self.txt.tag_configure("todolist",
lmargin1=0,
lmargin2=21,
tabs=(10, 'right', 21, 'left'))
margin = 2 * Font(self, font=font_text).measure("m")
self.txt.tag_configure("enum",
lmargin1=0,
lmargin2=margin + 5,
tabs=(margin, 'right', margin + 5, 'left'))
for coul in TEXT_COLORS.values():
self.txt.tag_configure(coul,
foreground=coul,
selectforeground="white")
self.txt.tag_configure(coul + "-underline",
foreground=coul,
selectforeground="white",
underline=True)
self.txt.tag_configure(coul + "-overstrike",
foreground=coul,
overstrike=True,
selectforeground="white")
# --- menus
# --- * menu on title
self.menu = Menu(self, tearoff=False)
# note color
menu_note_color = Menu(self.menu, tearoff=False)
colors = list(COLORS.keys())
colors.sort()
for coul in colors:
menu_note_color.add_command(
label=coul, command=lambda key=coul: self.change_color(key))
# category
self.category = StringVar(
self,
kwargs.get("category", CONFIG.get("General", "default_category")))
self.menu_categories = Menu(self.menu, tearoff=False)
categories = CONFIG.options("Categories")
categories.sort()
for cat in categories:
self.menu_categories.add_radiobutton(label=cat.capitalize(),
value=cat,
variable=self.category,
command=self.change_category)
# position: normal, always above, always below
self.position = StringVar(
self, kwargs.get("position", CONFIG.get("General", "position")))
menu_position = Menu(self.menu, tearoff=False)
menu_position.add_radiobutton(label=_("Always above"),
value="above",
variable=self.position,
command=self.set_position_above)
menu_position.add_radiobutton(label=_("Always below"),
value="below",
variable=self.position,
command=self.set_position_below)
menu_position.add_radiobutton(label=_("Normal"),
value="normal",
variable=self.position,
command=self.set_position_normal)
# mode: note, list, todo list
menu_mode = Menu(self.menu, tearoff=False)
self.mode = StringVar(self, kwargs.get("mode", "note"))
menu_mode.add_radiobutton(label=_("Note"),
value="note",
variable=self.mode,
command=self.set_mode_note)
menu_mode.add_radiobutton(label=_("List"),
value="list",
variable=self.mode,
command=self.set_mode_list)
menu_mode.add_radiobutton(label=_("ToDo List"),
value="todolist",
variable=self.mode,
command=self.set_mode_todolist)
menu_mode.add_radiobutton(label=_("Enumeration"),
value="enum",
variable=self.mode,
command=self.set_mode_enum)
self.menu.add_command(label=_("Delete"), command=self.delete)
self.menu.add_cascade(label=_("Category"), menu=self.menu_categories)
self.menu.add_cascade(label=_("Color"), menu=menu_note_color)
self.menu.add_command(label=_("Lock"), command=self.lock)
self.menu.add_cascade(label=_("Position"), menu=menu_position)
self.menu.add_cascade(label=_("Mode"), menu=menu_mode)
# --- * menu on main text
self.menu_txt = Menu(self.txt, tearoff=False)
# style
menu_style = Menu(self.menu_txt, tearoff=False)
menu_style.add_command(label=_("Bold"),
command=lambda: self.toggle_text_style("bold"))
menu_style.add_command(
label=_("Italic"),
command=lambda: self.toggle_text_style("italic"))
menu_style.add_command(label=_("Underline"),
command=self.toggle_underline)
menu_style.add_command(label=_("Overstrike"),
command=self.toggle_overstrike)
# text alignment
menu_align = Menu(self.menu_txt, tearoff=False)
menu_align.add_command(label=_("Left"),
command=lambda: self.set_align("left"))
menu_align.add_command(label=_("Right"),
command=lambda: self.set_align("right"))
menu_align.add_command(label=_("Center"),
command=lambda: self.set_align("center"))
# text color
menu_colors = Menu(self.menu_txt, tearoff=False)
colors = list(TEXT_COLORS.keys())
colors.sort()
for coul in colors:
menu_colors.add_command(label=coul,
command=lambda key=coul: self.
change_sel_color(TEXT_COLORS[key]))
# insert
menu_insert = Menu(self.menu_txt, tearoff=False)
menu_insert.add_command(label=_("Symbols"), command=self.add_symbols)
menu_insert.add_command(label=_("Checkbox"), command=self.add_checkbox)
menu_insert.add_command(label=_("Image"), command=self.add_image)
menu_insert.add_command(label=_("Date"), command=self.add_date)
menu_insert.add_command(label=_("Link"), command=self.add_link)
if LATEX:
menu_insert.add_command(label="LaTex", command=self.add_latex)
self.menu_txt.add_cascade(label=_("Style"), menu=menu_style)
self.menu_txt.add_cascade(label=_("Alignment"), menu=menu_align)
self.menu_txt.add_cascade(label=_("Color"), menu=menu_colors)
self.menu_txt.add_cascade(label=_("Insert"), menu=menu_insert)
# --- restore note content/appearence
self.color = kwargs.get("color",
CONFIG.get("Categories", self.category.get()))
self.txt.insert('1.0', kwargs.get("txt", ""))
self.txt.edit_reset() # clear undo stack
# restore inserted objects (images and checkboxes)
# we need to restore objects with increasing index to avoid placment errors
indexes = list(kwargs.get("inserted_objects", {}).keys())
indexes.sort(key=sorting)
for index in indexes:
kind, val = kwargs["inserted_objects"][index]
if kind == "checkbox":
ch = Checkbutton(self.txt,
takefocus=False,
style=self.id + ".TCheckbutton")
if val:
ch.state(("selected", ))
self.txt.window_create(index, window=ch)
elif kind == "image":
if os.path.exists(val):
self.images.append(PhotoImage(master=self.txt, file=val))
self.txt.image_create(index,
image=self.images[-1],
name=val)
# restore tags
for tag, indices in kwargs.get("tags", {}).items():
if indices:
self.txt.tag_add(tag, *indices)
for link in kwargs.get("links", {}).values():
self.nb_links += 1
self.links[self.nb_links] = link
self.txt.tag_bind("link#%i" % self.nb_links,
"<Button-1>",
lambda e, l=link: open_url(l))
for img, latex in kwargs.get("latex", {}).items():
self.latex[img] = latex
if LATEX:
self.txt.tag_bind(img,
'<Double-Button-1>',
lambda e, im=img: self.add_latex(im))
mode = self.mode.get()
if mode != "note":
self.txt.tag_add(mode, "1.0", "end")
self.txt.focus_set()
self.lock()
if kwargs.get("rolled", False):
self.rollnote()
if self.position.get() == "above":
self.set_position_above()
elif self.position.get() == "below":
self.set_position_below()
# --- placement
# titlebar
if CONFIG.get("General", "buttons_position") == "right":
# right = lock icon - title - roll - close
self.columnconfigure(1, weight=1)
self.roll.grid(row=0, column=2, sticky="e")
self.close.grid(row=0, column=3, sticky="e", padx=(0, 2))
self.cadenas.grid(row=0, column=0, sticky="w")
self.title_label.grid(row=0, column=1, sticky="ew", pady=(1, 0))
else:
# left = close - roll - title - lock icon
self.columnconfigure(2, weight=1)
self.roll.grid(row=0, column=1, sticky="w")
self.close.grid(row=0, column=0, sticky="w", padx=(2, 0))
self.cadenas.grid(row=0, column=3, sticky="e")
self.title_label.grid(row=0, column=2, sticky="ew", pady=(1, 0))
# body
self.txt.grid(row=1,
columnspan=4,
column=0,
sticky="ewsn",
pady=(1, 4),
padx=4)
self.corner.lift(self.txt)
self.corner.place(relx=1.0, rely=1.0, anchor="se")
# --- bindings
self.bind("<FocusOut>", self.save_note)
self.bind('<Configure>', self.bouge)
self.bind('<Button-1>', self.change_focus, True)
self.close.bind("<Button-1>", self.hide)
self.close.bind("<Enter>", self.enter_close)
self.close.bind("<Leave>", self.leave_close)
self.roll.bind("<Button-1>", self.rollnote)
self.roll.bind("<Enter>", self.enter_roll)
self.roll.bind("<Leave >", self.leave_roll)
self.title_label.bind("<Double-Button-1>", self.edit_title)
self.title_label.bind("<ButtonPress-1>", self.start_move)
self.title_label.bind("<ButtonRelease-1>", self.stop_move)
self.title_label.bind("<B1-Motion>", self.move)
self.title_label.bind('<Button-3>', self.show_menu)
self.title_entry.bind("<Return>",
lambda e: self.title_entry.place_forget())
self.title_entry.bind("<FocusOut>",
lambda e: self.title_entry.place_forget())
self.title_entry.bind("<Escape>",
lambda e: self.title_entry.place_forget())
self.txt.tag_bind("link", "<Enter>",
lambda event: self.txt.configure(cursor="hand1"))
self.txt.tag_bind("link", "<Leave>",
lambda event: self.txt.configure(cursor=""))
self.txt.bind("<FocusOut>", self.save_note)
self.txt.bind('<Button-3>', self.show_menu_txt)
# add binding to the existing class binding so that the selected text
# is erased on pasting
self.txt.bind("<Control-v>", self.paste)
self.corner.bind('<ButtonRelease-1>', self.resize)
# --- keyboard shortcuts
self.txt.bind('<Control-b>', lambda e: self.toggle_text_style('bold'))
self.txt.bind('<Control-i>',
lambda e: self.toggle_text_style('italic'))
self.txt.bind('<Control-u>', lambda e: self.toggle_underline())
self.txt.bind('<Control-r>', lambda e: self.set_align('right'))
self.txt.bind('<Control-l>', lambda e: self.set_align('left'))
def __init__(self, master, app, **kwargs):
Frame.__init__(self, master, **kwargs)
self.columnconfigure(0, weight=1)
self.app = app
self.style = Style(self)
self.style.theme_use("clam")
self.im_plus = PhotoImage(file=IM_PLUS)
self.im_moins = PhotoImage(file=IM_MOINS)
# --- Default category
self.frame_def_cat = Frame(self)
self.default_category = StringVar(self.frame_def_cat,
CONFIG.get("General",
"default_category").capitalize())
Label(self.frame_def_cat, text=_("Default category ")).grid(row=0, column=0,
sticky="e",
padx=(4, 0))
self.categories = CONFIG.options("Categories")
self.categories.sort()
categories = [cat.capitalize() for cat in self.categories]
self.def_cat_menu = OptionMenu(self.frame_def_cat, self.default_category,
CONFIG.get("General",
"default_category").capitalize(),
*categories)
optionmenu_patch(self.def_cat_menu, self.default_category)
self.def_cat_menu.grid(row=0, column=1, sticky="w", padx=4, pady=4)
# --- Category colors, names ...
self.frame_cat = Frame(self)
self.colors = list(COLORS.keys())
self.colors.sort()
self.images = []
for key in self.colors:
self.images.append(PhotoImage(key, master=self, width=16, height=16))
fill(self.images[-1], COLORS[key])
self.cat_colors = {}
self.cat_labels = {}
self.cat_menus = {}
self.cat_buttons = {}
for i, cat in enumerate(self.categories):
self.cat_labels[cat] = Label(self.frame_cat,
text="%s" % cat.capitalize(),
anchor='e')
self.cat_labels[cat].grid(row=i + 2, column=0, sticky="ew", padx=2)
self.cat_labels[cat].bind('<Double-Button-1>', self.change_name)
self.cat_colors[cat] = StringVar(self)
color = CONFIG.get("Categories", cat)
self.cat_menus[cat] = OptionMenu(self.frame_cat, self.cat_colors[cat],
INV_COLORS[color], *self.colors,
command=lambda color, c=cat: self.change_menubutton_color(color, c),
style="%s.TMenubutton" % cat)
optionmenu_patch(self.cat_menus[cat], self.cat_colors[cat])
self.style.configure("%s.TMenubutton" % cat, background=color)
self.cat_menus[cat].grid(row=i + 2, column=1, sticky="w", padx=4, pady=4)
self.cat_buttons[cat] = Button(self.frame_cat, image=self.im_moins,
command=lambda c=cat: self.del_cat(c))
self.cat_buttons[cat].grid(row=i + 2, column=2, padx=4, pady=4)
self.add_cat_button = Button(self.frame_cat, image=self.im_plus,
command=self.add_cat)
self.add_cat_button.grid(row=i + 3, column=0, pady=(0, 4))
if len(self.categories) == 1:
self.cat_buttons[self.categories[0]].configure(state="disabled")
# --- placement
self.frame_def_cat.grid(row=0, column=0, sticky="eswn")
Separator(self, orient="horizontal").grid(row=1, columnspan=3,
pady=10, sticky="ew")
self.frame_cat.grid(row=2, column=0, sticky="eswn")
def __init__(self, master):
Toplevel.__init__(self, master)
self.title(_("Delete"))
self.grab_set()
categories = CONFIG.options("Categories")
categories.sort()
self.im_moins = PhotoImage(file=IM_MOINS, master=self)
self.notebook = Notebook(self)
self.notebook.pack(fill='both', expand=True)
self.texts = {}
frames = {}
self.notes = {}
for cat in categories:
frame = Frame(self.notebook)
self.texts[cat] = Text(frame,
width=1,
height=1,
bg=self.cget('bg'),
relief='flat',
highlightthickness=0,
padx=4,
pady=4,
cursor='arrow')
frame.columnconfigure(0, weight=1)
frame.rowconfigure(0, weight=1)
self.texts[cat].grid(row=0, column=0, sticky='ewsn', padx=(0, 2))
scrolly = Scrollbar(frame,
orient='vertical',
command=self.texts[cat].yview)
scrolly.grid(row=0, column=1, sticky='ns')
scrollx = Scrollbar(frame,
orient='horizontal',
command=self.texts[cat].xview)
scrollx.grid(row=1, column=0, sticky='ew')
self.texts[cat].configure(xscrollcommand=scrollx.set,
yscrollcommand=scrolly.set)
frames[cat] = Frame(self.texts[cat])
frames[cat].columnconfigure(0, weight=1, minsize=170)
frames[cat].columnconfigure(1, weight=1, minsize=170)
frames[cat].columnconfigure(2, minsize=20)
self.texts[cat].window_create('1.0', window=frames[cat])
self.notebook.add(frame,
text=cat.capitalize(),
sticky="ewsn",
padding=0)
for key, note_data in self.master.note_data.items():
cat = note_data["category"]
c, r = frames[cat].grid_size()
self.notes[key] = []
title = note_data['title'][:20]
title = title.replace('\t', ' ') + ' ' * (20 - len(title))
self.notes[key].append(
Label(frames[cat], text=title, font='TkDefaultFont 10 bold'))
txt = note_data['txt'].splitlines()
if txt:
txt = txt[0][:17] + '...'
else:
txt = ''
txt = txt.replace('\t', ' ') + ' ' * (20 - len(txt))
self.notes[key].append(Label(frames[cat], text=txt))
self.notes[key].append(
Button(frames[cat],
image=self.im_moins,
command=lambda iid=key: self.delete_note(iid)))
for i, widget in enumerate(self.notes[key]):
widget.grid(row=r, column=i, sticky='w', padx=4, pady=4)
for txt in self.texts.values():
txt.configure(state='disabled')
self.geometry('410x450')
self.bind_all("<Button-4>", lambda e: self.scroll(-1))
self.bind_all("<Button-5>", lambda e: self.scroll(1))
def __init__(self):
Tk.__init__(self)
self.withdraw()
self.notes = {}
self.img = PhotoImage(file=cst.IM_ICON)
self.icon = PhotoImage(master=self, file=cst.IM_ICON_48)
self.iconphoto(True, self.icon)
self.ewmh = ewmh.EWMH()
style = Style(self)
style.theme_use("clam")
self.close1 = PhotoImage("img_close", file=cst.IM_CLOSE)
self.close2 = PhotoImage("img_closeactive", file=cst.IM_CLOSE_ACTIVE)
self.roll1 = PhotoImage("img_roll", file=cst.IM_ROLL)
self.roll2 = PhotoImage("img_rollactive", file=cst.IM_ROLL_ACTIVE)
self.protocol("WM_DELETE_WINDOW", self.quit)
self.icon = tktray.Icon(self, docked=True)
# --- Menu
self.menu_notes = Menu(self.icon.menu, tearoff=False)
self.hidden_notes = {cat: {} for cat in CONFIG.options("Categories")}
self.menu_show_cat = Menu(self.icon.menu, tearoff=False)
self.menu_hide_cat = Menu(self.icon.menu, tearoff=False)
self.icon.configure(image=self.img)
self.icon.menu.add_command(label=_("New Note"), command=self.new)
self.icon.menu.add_separator()
self.icon.menu.add_command(label=_('Show All'), command=self.show_all)
self.icon.menu.add_cascade(label=_('Show Category'),
menu=self.menu_show_cat)
self.icon.menu.add_cascade(label=_('Show Note'),
menu=self.menu_notes,
state="disabled")
self.icon.menu.add_separator()
self.icon.menu.add_command(label=_('Hide All'), command=self.hide_all)
self.icon.menu.add_cascade(label=_('Hide Category'),
menu=self.menu_hide_cat)
self.icon.menu.add_separator()
self.icon.menu.add_command(label=_("Preferences"), command=self.config)
self.icon.menu.add_command(label=_("Note Manager"),
command=self.manage)
self.icon.menu.add_separator()
self.icon.menu.add_command(label=_("Backup Notes"),
command=self.backup)
self.icon.menu.add_command(label=_("Restore Backup"),
command=self.restore)
self.icon.menu.add_separator()
self.icon.menu.add_command(label=_("Export"),
command=self.export_notes)
self.icon.menu.add_command(label=_("Import"),
command=self.import_notes)
self.icon.menu.add_separator()
self.icon.menu.add_command(label=_('Check for Updates'),
command=lambda: UpdateChecker(self))
self.icon.menu.add_command(label=_('About'),
command=lambda: About(self))
self.icon.menu.add_command(label=_('Quit'), command=self.quit)
# --- Restore notes
self.note_data = {}
if os.path.exists(PATH_DATA):
with open(PATH_DATA, "rb") as fich:
dp = pickle.Unpickler(fich)
note_data = dp.load()
for i, key in enumerate(note_data):
self.note_data["%i" % i] = note_data[key]
backup()
for key in self.note_data:
data = self.note_data[key]
cat = data["category"]
if not CONFIG.has_option("Categories", cat):
CONFIG.set("Categories", cat, data["color"])
if data["visible"]:
self.notes[key] = Sticky(self, key, **data)
else:
self.add_note_to_menu(key, data["title"], cat)
self.nb = len(self.note_data)
self.update_menu()
self.update_notes()
self.make_notes_sticky()
# --- class bindings
# newline depending on mode
self.bind_class("Text", "<Return>", self.insert_newline)
# char deletion taking into account list type
self.bind_class("Text", "<BackSpace>", self.delete_char)
# change Ctrl+A to select all instead of go to the beginning of the line
self.bind_class('Text', '<Control-a>', self.select_all_text)
self.bind_class('TEntry', '<Control-a>', self.select_all_entry)
# bind Ctrl+Y to redo
self.bind_class('Text', '<Control-y>', self.redo_event)
# unbind Ctrl+I and Ctrl+B
self.bind_class('Text', '<Control-i>', lambda e: None)
self.bind_class('Text', '<Control-b>', lambda e: None)
# highlight checkboxes when inside text selection
self.bind_class("Text", "<ButtonPress-1>", self.highlight_checkboxes,
True)
self.bind_class("Text", "<ButtonRelease-1>", self.highlight_checkboxes,
True)
self.bind_class("Text", "<B1-Motion>", self.highlight_checkboxes, True)
evs = [
'<<SelectAll>>', '<<SelectLineEnd>>', '<<SelectLineStart>>',
'<<SelectNextChar>>', '<<SelectNextLine>>', '<<SelectNextPara>>',
'<<SelectNextWord>>', '<<SelectNone>>', '<<SelectPrevChar>>',
'<<SelectPrevLine>>', '<<SelectPrevPara>>', '<<SelectPrevWord>>'
]
for ev in evs:
self.bind_class("Text", ev, self.highlight_checkboxes, True)
# check for updates
if CONFIG.getboolean("General", "check_update"):
UpdateChecker(self)
def ok(self):
family = self.font_family.get()
if family not in self.fonts:
l = [i for i in self.fonts if i[:len(family)] == family]
if l:
family = l[0]
else:
family = 'TkDefaultFont'
size = self.font_size.get()
familytitle = self.fonttitle_family.get()
if familytitle not in self.fonts:
l = [i for i in self.fonts if i[:len(familytitle)] == familytitle]
if l:
familytitle = l[0]
else:
familytitle = 'TkDefaultFont'
sizetitle = self.fonttitle_size.get()
opacity = "%i" % float(self.opacity_scale.get())
language = self.lang.get().lower()[:2]
style = ""
if self.is_bold.instate(("selected", )):
style += "bold,"
if self.is_italic.instate(("selected", )):
style += "italic,"
if self.is_underlined.instate(("selected", )):
style += "underline,"
if style:
style = style[:-1]
symbols = [
l.strip() for l in self.symbols.get("1.0", "end").splitlines()
]
CONFIG.set("General", "default_category",
self.category_settings.default_category.get().lower())
CONFIG.set("General", "language", language)
CONFIG.set("General", "opacity", opacity)
CONFIG.set("General", "position", self.position.get())
CONFIG.set("General", "buttons_position",
self.titlebar_disposition.get())
CONFIG.set("General", "symbols", "".join(symbols))
CONFIG.set("Font", "text_size", size)
CONFIG.set("Font", "text_family", family)
CONFIG.set("Font", "title_family", familytitle)
CONFIG.set("Font", "title_size", sizetitle)
CONFIG.set("Font", "title_style", style)
col_changes = {}
name_changes = {}
for cat in self.category_settings.categories:
new_name = self.category_settings.get_name(cat)
if cat in CONFIG.options("Categories"):
old_color = CONFIG.get("Categories", cat)
new_color = COLORS[self.category_settings.get_color(cat)]
if new_name != cat:
name_changes[cat] = new_name
CONFIG.remove_option("Categories", cat)
CONFIG.set("Categories", new_name, new_color)
if old_color != new_color:
col_changes[new_name] = (old_color, new_color)
CONFIG.set("Categories", new_name, new_color)
else:
CONFIG.set("Categories", new_name,
COLORS[self.category_settings.get_color(cat)])
save_config()
self.changes = col_changes, name_changes
self.destroy()