| """IDLE Configuration Dialog: support user customization of IDLE by GUI |
| |
| Customize font faces, sizes, and colorization attributes. Set indentation |
| defaults. Customize keybindings. Colorization and keybindings can be |
| saved as user defined sets. Select startup options including shell/editor |
| and default window size. Define additional help sources. |
| |
| Note that tab width in IDLE is currently fixed at eight due to Tk issues. |
| Refer to comments in EditorWindow autoindent code for details. |
| |
| """ |
| from tkinter import (Toplevel, Frame, LabelFrame, Listbox, Label, Button, |
| Entry, Text, Scale, Radiobutton, Checkbutton, Canvas, |
| StringVar, BooleanVar, IntVar, TRUE, FALSE, |
| TOP, BOTTOM, RIGHT, LEFT, SOLID, GROOVE, NORMAL, DISABLED, |
| NONE, BOTH, X, Y, W, E, EW, NS, NSEW, NW, |
| HORIZONTAL, VERTICAL, ANCHOR, END) |
| from tkinter.ttk import Scrollbar |
| import tkinter.colorchooser as tkColorChooser |
| import tkinter.font as tkFont |
| import tkinter.messagebox as tkMessageBox |
| |
| from idlelib.config import idleConf |
| from idlelib.config_key import GetKeysDialog |
| from idlelib.dynoption import DynOptionMenu |
| from idlelib import macosx |
| from idlelib.query import SectionName, HelpSource |
| from idlelib.tabbedpages import TabbedPageSet |
| from idlelib.textview import view_text |
| |
| class ConfigDialog(Toplevel): |
| |
| def __init__(self, parent, title='', _htest=False, _utest=False): |
| """ |
| _htest - bool, change box location when running htest |
| _utest - bool, don't wait_window when running unittest |
| """ |
| Toplevel.__init__(self, parent) |
| self.parent = parent |
| if _htest: |
| parent.instance_dict = {} |
| self.withdraw() |
| |
| self.configure(borderwidth=5) |
| self.title(title or 'IDLE Preferences') |
| x = parent.winfo_rootx() + 20 |
| y = parent.winfo_rooty() + (30 if not _htest else 150) |
| self.geometry(f'+{x}+{y}') |
| #Theme Elements. Each theme element key is its display name. |
| #The first value of the tuple is the sample area tag name. |
| #The second value is the display name list sort index. |
| self.theme_elements={ |
| 'Normal Text': ('normal', '00'), |
| 'Python Keywords': ('keyword', '01'), |
| 'Python Definitions': ('definition', '02'), |
| 'Python Builtins': ('builtin', '03'), |
| 'Python Comments': ('comment', '04'), |
| 'Python Strings': ('string', '05'), |
| 'Selected Text': ('hilite', '06'), |
| 'Found Text': ('hit', '07'), |
| 'Cursor': ('cursor', '08'), |
| 'Editor Breakpoint': ('break', '09'), |
| 'Shell Normal Text': ('console', '10'), |
| 'Shell Error Text': ('error', '11'), |
| 'Shell Stdout Text': ('stdout', '12'), |
| 'Shell Stderr Text': ('stderr', '13'), |
| } |
| self.reset_changed_items() #load initial values in changed items dict |
| self.create_widgets() |
| self.resizable(height=FALSE, width=FALSE) |
| self.transient(parent) |
| self.grab_set() |
| self.protocol("WM_DELETE_WINDOW", self.cancel) |
| self.tab_pages.focus_set() |
| #key bindings for this dialog |
| #self.bind('<Escape>', self.Cancel) #dismiss dialog, no save |
| #self.bind('<Alt-a>', self.Apply) #apply changes, save |
| #self.bind('<F1>', self.Help) #context help |
| self.load_configs() |
| self.attach_var_callbacks() #avoid callbacks during load_configs |
| |
| if not _utest: |
| self.wm_deiconify() |
| self.wait_window() |
| |
| def create_widgets(self): |
| self.tab_pages = TabbedPageSet(self, |
| page_names=['Fonts/Tabs', 'Highlighting', 'Keys', 'General', |
| 'Extensions']) |
| self.tab_pages.pack(side=TOP, expand=TRUE, fill=BOTH) |
| self.create_page_font_tab() |
| self.create_page_highlight() |
| self.create_page_keys() |
| self.create_page_general() |
| self.create_page_extensions() |
| self.create_action_buttons().pack(side=BOTTOM) |
| |
| def create_action_buttons(self): |
| if macosx.isAquaTk(): |
| # Changing the default padding on OSX results in unreadable |
| # text in the buttons |
| padding_args = {} |
| else: |
| padding_args = {'padx':6, 'pady':3} |
| outer = Frame(self, pady=2) |
| buttons = Frame(outer, pady=2) |
| for txt, cmd in ( |
| ('Ok', self.ok), |
| ('Apply', self.apply), |
| ('Cancel', self.cancel), |
| ('Help', self.help)): |
| Button(buttons, text=txt, command=cmd, takefocus=FALSE, |
| **padding_args).pack(side=LEFT, padx=5) |
| # add space above buttons |
| Frame(outer, height=2, borderwidth=0).pack(side=TOP) |
| buttons.pack(side=BOTTOM) |
| return outer |
| |
| def create_page_font_tab(self): |
| parent = self.parent |
| self.font_size = StringVar(parent) |
| self.font_bold = BooleanVar(parent) |
| self.font_name = StringVar(parent) |
| self.space_num = IntVar(parent) |
| self.edit_font = tkFont.Font(parent, ('courier', 10, 'normal')) |
| |
| ##widget creation |
| #body frame |
| frame = self.tab_pages.pages['Fonts/Tabs'].frame |
| #body section frames |
| frame_font = LabelFrame( |
| frame, borderwidth=2, relief=GROOVE, text=' Base Editor Font ') |
| frame_indent = LabelFrame( |
| frame, borderwidth=2, relief=GROOVE, text=' Indentation Width ') |
| #frame_font |
| frame_font_name = Frame(frame_font) |
| frame_font_param = Frame(frame_font) |
| font_name_title = Label( |
| frame_font_name, justify=LEFT, text='Font Face :') |
| self.list_fonts = Listbox( |
| frame_font_name, height=5, takefocus=FALSE, exportselection=FALSE) |
| self.list_fonts.bind( |
| '<ButtonRelease-1>', self.on_list_fonts_button_release) |
| scroll_font = Scrollbar(frame_font_name) |
| scroll_font.config(command=self.list_fonts.yview) |
| self.list_fonts.config(yscrollcommand=scroll_font.set) |
| font_size_title = Label(frame_font_param, text='Size :') |
| self.opt_menu_font_size = DynOptionMenu( |
| frame_font_param, self.font_size, None, command=self.set_font_sample) |
| check_font_bold = Checkbutton( |
| frame_font_param, variable=self.font_bold, onvalue=1, |
| offvalue=0, text='Bold', command=self.set_font_sample) |
| frame_font_sample = Frame(frame_font, relief=SOLID, borderwidth=1) |
| self.font_sample = Label( |
| frame_font_sample, justify=LEFT, font=self.edit_font, |
| text='AaBbCcDdEe\nFfGgHhIiJjK\n1234567890\n#:+=(){}[]') |
| #frame_indent |
| frame_indent_size = Frame(frame_indent) |
| indent_size_title = Label( |
| frame_indent_size, justify=LEFT, |
| text='Python Standard: 4 Spaces!') |
| self.scale_indent_size = Scale( |
| frame_indent_size, variable=self.space_num, |
| orient='horizontal', tickinterval=2, from_=2, to=16) |
| |
| #widget packing |
| #body |
| frame_font.pack(side=LEFT, padx=5, pady=5, expand=TRUE, fill=BOTH) |
| frame_indent.pack(side=LEFT, padx=5, pady=5, fill=Y) |
| #frame_font |
| frame_font_name.pack(side=TOP, padx=5, pady=5, fill=X) |
| frame_font_param.pack(side=TOP, padx=5, pady=5, fill=X) |
| font_name_title.pack(side=TOP, anchor=W) |
| self.list_fonts.pack(side=LEFT, expand=TRUE, fill=X) |
| scroll_font.pack(side=LEFT, fill=Y) |
| font_size_title.pack(side=LEFT, anchor=W) |
| self.opt_menu_font_size.pack(side=LEFT, anchor=W) |
| check_font_bold.pack(side=LEFT, anchor=W, padx=20) |
| frame_font_sample.pack(side=TOP, padx=5, pady=5, expand=TRUE, fill=BOTH) |
| self.font_sample.pack(expand=TRUE, fill=BOTH) |
| #frame_indent |
| frame_indent_size.pack(side=TOP, fill=X) |
| indent_size_title.pack(side=TOP, anchor=W, padx=5) |
| self.scale_indent_size.pack(side=TOP, padx=5, fill=X) |
| return frame |
| |
| def create_page_highlight(self): |
| parent = self.parent |
| self.builtin_theme = StringVar(parent) |
| self.custom_theme = StringVar(parent) |
| self.fg_bg_toggle = BooleanVar(parent) |
| self.colour = StringVar(parent) |
| self.font_name = StringVar(parent) |
| self.is_builtin_theme = BooleanVar(parent) |
| self.highlight_target = StringVar(parent) |
| |
| ##widget creation |
| #body frame |
| frame = self.tab_pages.pages['Highlighting'].frame |
| #body section frames |
| frame_custom = LabelFrame(frame, borderwidth=2, relief=GROOVE, |
| text=' Custom Highlighting ') |
| frame_theme = LabelFrame(frame, borderwidth=2, relief=GROOVE, |
| text=' Highlighting Theme ') |
| #frame_custom |
| self.text_highlight_sample=Text( |
| frame_custom, relief=SOLID, borderwidth=1, |
| font=('courier', 12, ''), cursor='hand2', width=21, height=11, |
| takefocus=FALSE, highlightthickness=0, wrap=NONE) |
| text=self.text_highlight_sample |
| text.bind('<Double-Button-1>', lambda e: 'break') |
| text.bind('<B1-Motion>', lambda e: 'break') |
| text_and_tags=( |
| ('#you can click here', 'comment'), ('\n', 'normal'), |
| ('#to choose items', 'comment'), ('\n', 'normal'), |
| ('def', 'keyword'), (' ', 'normal'), |
| ('func', 'definition'), ('(param):\n ', 'normal'), |
| ('"""string"""', 'string'), ('\n var0 = ', 'normal'), |
| ("'string'", 'string'), ('\n var1 = ', 'normal'), |
| ("'selected'", 'hilite'), ('\n var2 = ', 'normal'), |
| ("'found'", 'hit'), ('\n var3 = ', 'normal'), |
| ('list', 'builtin'), ('(', 'normal'), |
| ('None', 'keyword'), (')\n', 'normal'), |
| (' breakpoint("line")', 'break'), ('\n\n', 'normal'), |
| (' error ', 'error'), (' ', 'normal'), |
| ('cursor |', 'cursor'), ('\n ', 'normal'), |
| ('shell', 'console'), (' ', 'normal'), |
| ('stdout', 'stdout'), (' ', 'normal'), |
| ('stderr', 'stderr'), ('\n', 'normal')) |
| for texttag in text_and_tags: |
| text.insert(END, texttag[0], texttag[1]) |
| for element in self.theme_elements: |
| def tem(event, elem=element): |
| event.widget.winfo_toplevel().highlight_target.set(elem) |
| text.tag_bind( |
| self.theme_elements[element][0], '<ButtonPress-1>', tem) |
| text.config(state=DISABLED) |
| self.frame_colour_set = Frame(frame_custom, relief=SOLID, borderwidth=1) |
| frame_fg_bg_toggle = Frame(frame_custom) |
| button_set_colour = Button( |
| self.frame_colour_set, text='Choose Colour for :', |
| command=self.get_colour, highlightthickness=0) |
| self.opt_menu_highlight_target = DynOptionMenu( |
| self.frame_colour_set, self.highlight_target, None, |
| highlightthickness=0) #, command=self.set_highlight_targetBinding |
| self.radio_fg = Radiobutton( |
| frame_fg_bg_toggle, variable=self.fg_bg_toggle, value=1, |
| text='Foreground', command=self.set_colour_sample_binding) |
| self.radio_bg=Radiobutton( |
| frame_fg_bg_toggle, variable=self.fg_bg_toggle, value=0, |
| text='Background', command=self.set_colour_sample_binding) |
| self.fg_bg_toggle.set(1) |
| button_save_custom_theme = Button( |
| frame_custom, text='Save as New Custom Theme', |
| command=self.save_as_new_theme) |
| #frame_theme |
| theme_type_title = Label(frame_theme, text='Select : ') |
| self.radio_theme_builtin = Radiobutton( |
| frame_theme, variable=self.is_builtin_theme, value=1, |
| command=self.set_theme_type, text='a Built-in Theme') |
| self.radio_theme_custom = Radiobutton( |
| frame_theme, variable=self.is_builtin_theme, value=0, |
| command=self.set_theme_type, text='a Custom Theme') |
| self.opt_menu_theme_builtin = DynOptionMenu( |
| frame_theme, self.builtin_theme, None, command=None) |
| self.opt_menu_theme_custom=DynOptionMenu( |
| frame_theme, self.custom_theme, None, command=None) |
| self.button_delete_custom_theme=Button( |
| frame_theme, text='Delete Custom Theme', |
| command=self.delete_custom_theme) |
| self.new_custom_theme = Label(frame_theme, bd=2) |
| |
| ##widget packing |
| #body |
| frame_custom.pack(side=LEFT, padx=5, pady=5, expand=TRUE, fill=BOTH) |
| frame_theme.pack(side=LEFT, padx=5, pady=5, fill=Y) |
| #frame_custom |
| self.frame_colour_set.pack(side=TOP, padx=5, pady=5, expand=TRUE, fill=X) |
| frame_fg_bg_toggle.pack(side=TOP, padx=5, pady=0) |
| self.text_highlight_sample.pack( |
| side=TOP, padx=5, pady=5, expand=TRUE, fill=BOTH) |
| button_set_colour.pack(side=TOP, expand=TRUE, fill=X, padx=8, pady=4) |
| self.opt_menu_highlight_target.pack( |
| side=TOP, expand=TRUE, fill=X, padx=8, pady=3) |
| self.radio_fg.pack(side=LEFT, anchor=E) |
| self.radio_bg.pack(side=RIGHT, anchor=W) |
| button_save_custom_theme.pack(side=BOTTOM, fill=X, padx=5, pady=5) |
| #frame_theme |
| theme_type_title.pack(side=TOP, anchor=W, padx=5, pady=5) |
| self.radio_theme_builtin.pack(side=TOP, anchor=W, padx=5) |
| self.radio_theme_custom.pack(side=TOP, anchor=W, padx=5, pady=2) |
| self.opt_menu_theme_builtin.pack(side=TOP, fill=X, padx=5, pady=5) |
| self.opt_menu_theme_custom.pack(side=TOP, fill=X, anchor=W, padx=5, pady=5) |
| self.button_delete_custom_theme.pack(side=TOP, fill=X, padx=5, pady=5) |
| self.new_custom_theme.pack(side=TOP, fill=X, pady=5) |
| return frame |
| |
| def create_page_keys(self): |
| parent = self.parent |
| self.binding_target = StringVar(parent) |
| self.builtin_keys = StringVar(parent) |
| self.custom_keys = StringVar(parent) |
| self.are_keys_builtin = BooleanVar(parent) |
| self.keybinding = StringVar(parent) |
| |
| ##widget creation |
| #body frame |
| frame = self.tab_pages.pages['Keys'].frame |
| #body section frames |
| frame_custom = LabelFrame( |
| frame, borderwidth=2, relief=GROOVE, |
| text=' Custom Key Bindings ') |
| frame_key_sets = LabelFrame( |
| frame, borderwidth=2, relief=GROOVE, text=' Key Set ') |
| #frame_custom |
| frame_target = Frame(frame_custom) |
| target_title = Label(frame_target, text='Action - Key(s)') |
| scroll_target_y = Scrollbar(frame_target) |
| scroll_target_x = Scrollbar(frame_target, orient=HORIZONTAL) |
| self.list_bindings = Listbox( |
| frame_target, takefocus=FALSE, exportselection=FALSE) |
| self.list_bindings.bind('<ButtonRelease-1>', self.keybinding_selected) |
| scroll_target_y.config(command=self.list_bindings.yview) |
| scroll_target_x.config(command=self.list_bindings.xview) |
| self.list_bindings.config(yscrollcommand=scroll_target_y.set) |
| self.list_bindings.config(xscrollcommand=scroll_target_x.set) |
| self.button_new_keys = Button( |
| frame_custom, text='Get New Keys for Selection', |
| command=self.get_new_keys, state=DISABLED) |
| #frame_key_sets |
| frames = [Frame(frame_key_sets, padx=2, pady=2, borderwidth=0) |
| for i in range(2)] |
| self.radio_keys_builtin = Radiobutton( |
| frames[0], variable=self.are_keys_builtin, value=1, |
| command=self.set_keys_type, text='Use a Built-in Key Set') |
| self.radio_keys_custom = Radiobutton( |
| frames[0], variable=self.are_keys_builtin, value=0, |
| command=self.set_keys_type, text='Use a Custom Key Set') |
| self.opt_menu_keys_builtin = DynOptionMenu( |
| frames[0], self.builtin_keys, None, command=None) |
| self.opt_menu_keys_custom = DynOptionMenu( |
| frames[0], self.custom_keys, None, command=None) |
| self.button_delete_custom_keys = Button( |
| frames[1], text='Delete Custom Key Set', |
| command=self.delete_custom_keys) |
| button_save_custom_keys = Button( |
| frames[1], text='Save as New Custom Key Set', |
| command=self.save_as_new_key_set) |
| self.new_custom_keys = Label(frames[0], bd=2) |
| |
| ##widget packing |
| #body |
| frame_custom.pack(side=BOTTOM, padx=5, pady=5, expand=TRUE, fill=BOTH) |
| frame_key_sets.pack(side=BOTTOM, padx=5, pady=5, fill=BOTH) |
| #frame_custom |
| self.button_new_keys.pack(side=BOTTOM, fill=X, padx=5, pady=5) |
| frame_target.pack(side=LEFT, padx=5, pady=5, expand=TRUE, fill=BOTH) |
| #frame target |
| frame_target.columnconfigure(0, weight=1) |
| frame_target.rowconfigure(1, weight=1) |
| target_title.grid(row=0, column=0, columnspan=2, sticky=W) |
| self.list_bindings.grid(row=1, column=0, sticky=NSEW) |
| scroll_target_y.grid(row=1, column=1, sticky=NS) |
| scroll_target_x.grid(row=2, column=0, sticky=EW) |
| #frame_key_sets |
| self.radio_keys_builtin.grid(row=0, column=0, sticky=W+NS) |
| self.radio_keys_custom.grid(row=1, column=0, sticky=W+NS) |
| self.opt_menu_keys_builtin.grid(row=0, column=1, sticky=NSEW) |
| self.opt_menu_keys_custom.grid(row=1, column=1, sticky=NSEW) |
| self.new_custom_keys.grid(row=0, column=2, sticky=NSEW, padx=5, pady=5) |
| self.button_delete_custom_keys.pack(side=LEFT, fill=X, expand=True, padx=2) |
| button_save_custom_keys.pack(side=LEFT, fill=X, expand=True, padx=2) |
| frames[0].pack(side=TOP, fill=BOTH, expand=True) |
| frames[1].pack(side=TOP, fill=X, expand=True, pady=2) |
| return frame |
| |
| def create_page_general(self): |
| parent = self.parent |
| self.win_width = StringVar(parent) |
| self.win_height = StringVar(parent) |
| self.startup_edit = IntVar(parent) |
| self.autosave = IntVar(parent) |
| self.encoding = StringVar(parent) |
| self.user_help_browser = BooleanVar(parent) |
| self.help_browser = StringVar(parent) |
| |
| #widget creation |
| #body |
| frame = self.tab_pages.pages['General'].frame |
| #body section frames |
| frame_run = LabelFrame(frame, borderwidth=2, relief=GROOVE, |
| text=' Startup Preferences ') |
| frame_save = LabelFrame(frame, borderwidth=2, relief=GROOVE, |
| text=' autosave Preferences ') |
| frame_win_size = Frame(frame, borderwidth=2, relief=GROOVE) |
| frame_help = LabelFrame(frame, borderwidth=2, relief=GROOVE, |
| text=' Additional Help Sources ') |
| #frame_run |
| startup_title = Label(frame_run, text='At Startup') |
| self.radio_startup_edit = Radiobutton( |
| frame_run, variable=self.startup_edit, value=1, |
| text="Open Edit Window") |
| self.radio_startup_shell = Radiobutton( |
| frame_run, variable=self.startup_edit, value=0, |
| text='Open Shell Window') |
| #frame_save |
| run_save_title = Label(frame_save, text='At Start of Run (F5) ') |
| self.radio_save_ask = Radiobutton( |
| frame_save, variable=self.autosave, value=0, |
| text="Prompt to Save") |
| self.radio_save_auto = Radiobutton( |
| frame_save, variable=self.autosave, value=1, |
| text='No Prompt') |
| #frame_win_size |
| win_size_title = Label( |
| frame_win_size, text='Initial Window Size (in characters)') |
| win_width_title = Label(frame_win_size, text='Width') |
| self.entry_win_width = Entry( |
| frame_win_size, textvariable=self.win_width, width=3) |
| win_height_title = Label(frame_win_size, text='Height') |
| self.entry_win_height = Entry( |
| frame_win_size, textvariable=self.win_height, width=3) |
| #frame_help |
| frame_helplist = Frame(frame_help) |
| frame_helplist_buttons = Frame(frame_helplist) |
| scroll_helplist = Scrollbar(frame_helplist) |
| self.list_help = Listbox( |
| frame_helplist, height=5, takefocus=FALSE, |
| exportselection=FALSE) |
| scroll_helplist.config(command=self.list_help.yview) |
| self.list_help.config(yscrollcommand=scroll_helplist.set) |
| self.list_help.bind('<ButtonRelease-1>', self.help_source_selected) |
| self.button_helplist_edit = Button( |
| frame_helplist_buttons, text='Edit', state=DISABLED, |
| width=8, command=self.helplist_item_edit) |
| self.button_helplist_add = Button( |
| frame_helplist_buttons, text='Add', |
| width=8, command=self.helplist_item_add) |
| self.button_helplist_remove = Button( |
| frame_helplist_buttons, text='Remove', state=DISABLED, |
| width=8, command=self.helplist_item_remove) |
| |
| #widget packing |
| #body |
| frame_run.pack(side=TOP, padx=5, pady=5, fill=X) |
| frame_save.pack(side=TOP, padx=5, pady=5, fill=X) |
| frame_win_size.pack(side=TOP, padx=5, pady=5, fill=X) |
| frame_help.pack(side=TOP, padx=5, pady=5, expand=TRUE, fill=BOTH) |
| #frame_run |
| startup_title.pack(side=LEFT, anchor=W, padx=5, pady=5) |
| self.radio_startup_shell.pack(side=RIGHT, anchor=W, padx=5, pady=5) |
| self.radio_startup_edit.pack(side=RIGHT, anchor=W, padx=5, pady=5) |
| #frame_save |
| run_save_title.pack(side=LEFT, anchor=W, padx=5, pady=5) |
| self.radio_save_auto.pack(side=RIGHT, anchor=W, padx=5, pady=5) |
| self.radio_save_ask.pack(side=RIGHT, anchor=W, padx=5, pady=5) |
| #frame_win_size |
| win_size_title.pack(side=LEFT, anchor=W, padx=5, pady=5) |
| self.entry_win_height.pack(side=RIGHT, anchor=E, padx=10, pady=5) |
| win_height_title.pack(side=RIGHT, anchor=E, pady=5) |
| self.entry_win_width.pack(side=RIGHT, anchor=E, padx=10, pady=5) |
| win_width_title.pack(side=RIGHT, anchor=E, pady=5) |
| #frame_help |
| frame_helplist_buttons.pack(side=RIGHT, padx=5, pady=5, fill=Y) |
| frame_helplist.pack(side=TOP, padx=5, pady=5, expand=TRUE, fill=BOTH) |
| scroll_helplist.pack(side=RIGHT, anchor=W, fill=Y) |
| self.list_help.pack(side=LEFT, anchor=E, expand=TRUE, fill=BOTH) |
| self.button_helplist_edit.pack(side=TOP, anchor=W, pady=5) |
| self.button_helplist_add.pack(side=TOP, anchor=W) |
| self.button_helplist_remove.pack(side=TOP, anchor=W, pady=5) |
| return frame |
| |
| def attach_var_callbacks(self): |
| self.font_size.trace_add('write', self.var_changed_font) |
| self.font_name.trace_add('write', self.var_changed_font) |
| self.font_bold.trace_add('write', self.var_changed_font) |
| self.space_num.trace_add('write', self.var_changed_space_num) |
| self.colour.trace_add('write', self.var_changed_colour) |
| self.builtin_theme.trace_add('write', self.var_changed_builtin_theme) |
| self.custom_theme.trace_add('write', self.var_changed_custom_theme) |
| self.is_builtin_theme.trace_add('write', self.var_changed_is_builtin_theme) |
| self.highlight_target.trace_add('write', self.var_changed_highlight_target) |
| self.keybinding.trace_add('write', self.var_changed_keybinding) |
| self.builtin_keys.trace_add('write', self.var_changed_builtin_keys) |
| self.custom_keys.trace_add('write', self.var_changed_custom_keys) |
| self.are_keys_builtin.trace_add('write', self.var_changed_are_keys_builtin) |
| self.win_width.trace_add('write', self.var_changed_win_width) |
| self.win_height.trace_add('write', self.var_changed_win_height) |
| self.startup_edit.trace_add('write', self.var_changed_startup_edit) |
| self.autosave.trace_add('write', self.var_changed_autosave) |
| self.encoding.trace_add('write', self.var_changed_encoding) |
| |
| def remove_var_callbacks(self): |
| "Remove callbacks to prevent memory leaks." |
| for var in ( |
| self.font_size, self.font_name, self.font_bold, |
| self.space_num, self.colour, self.builtin_theme, |
| self.custom_theme, self.is_builtin_theme, self.highlight_target, |
| self.keybinding, self.builtin_keys, self.custom_keys, |
| self.are_keys_builtin, self.win_width, self.win_height, |
| self.startup_edit, self.autosave, self.encoding,): |
| var.trace_remove('write', var.trace_info()[0][1]) |
| |
| def var_changed_font(self, *params): |
| '''When one font attribute changes, save them all, as they are |
| not independent from each other. In particular, when we are |
| overriding the default font, we need to write out everything. |
| ''' |
| value = self.font_name.get() |
| self.add_changed_item('main', 'EditorWindow', 'font', value) |
| value = self.font_size.get() |
| self.add_changed_item('main', 'EditorWindow', 'font-size', value) |
| value = self.font_bold.get() |
| self.add_changed_item('main', 'EditorWindow', 'font-bold', value) |
| |
| def var_changed_space_num(self, *params): |
| value = self.space_num.get() |
| self.add_changed_item('main', 'Indent', 'num-spaces', value) |
| |
| def var_changed_colour(self, *params): |
| self.on_new_colour_set() |
| |
| def var_changed_builtin_theme(self, *params): |
| old_themes = ('IDLE Classic', 'IDLE New') |
| value = self.builtin_theme.get() |
| if value not in old_themes: |
| if idleConf.GetOption('main', 'Theme', 'name') not in old_themes: |
| self.add_changed_item('main', 'Theme', 'name', old_themes[0]) |
| self.add_changed_item('main', 'Theme', 'name2', value) |
| self.new_custom_theme.config(text='New theme, see Help', |
| fg='#500000') |
| else: |
| self.add_changed_item('main', 'Theme', 'name', value) |
| self.add_changed_item('main', 'Theme', 'name2', '') |
| self.new_custom_theme.config(text='', fg='black') |
| self.paint_theme_sample() |
| |
| def var_changed_custom_theme(self, *params): |
| value = self.custom_theme.get() |
| if value != '- no custom themes -': |
| self.add_changed_item('main', 'Theme', 'name', value) |
| self.paint_theme_sample() |
| |
| def var_changed_is_builtin_theme(self, *params): |
| value = self.is_builtin_theme.get() |
| self.add_changed_item('main', 'Theme', 'default', value) |
| if value: |
| self.var_changed_builtin_theme() |
| else: |
| self.var_changed_custom_theme() |
| |
| def var_changed_highlight_target(self, *params): |
| self.set_highlight_target() |
| |
| def var_changed_keybinding(self, *params): |
| value = self.keybinding.get() |
| key_set = self.custom_keys.get() |
| event = self.list_bindings.get(ANCHOR).split()[0] |
| if idleConf.IsCoreBinding(event): |
| #this is a core keybinding |
| self.add_changed_item('keys', key_set, event, value) |
| else: #this is an extension key binding |
| ext_name = idleConf.GetExtnNameForEvent(event) |
| ext_keybind_section = ext_name + '_cfgBindings' |
| self.add_changed_item('extensions', ext_keybind_section, event, value) |
| |
| def var_changed_builtin_keys(self, *params): |
| old_keys = ( |
| 'IDLE Classic Windows', |
| 'IDLE Classic Unix', |
| 'IDLE Classic Mac', |
| 'IDLE Classic OSX', |
| ) |
| value = self.builtin_keys.get() |
| if value not in old_keys: |
| if idleConf.GetOption('main', 'Keys', 'name') not in old_keys: |
| self.add_changed_item('main', 'Keys', 'name', old_keys[0]) |
| self.add_changed_item('main', 'Keys', 'name2', value) |
| self.new_custom_keys.config(text='New key set, see Help', |
| fg='#500000') |
| else: |
| self.add_changed_item('main', 'Keys', 'name', value) |
| self.add_changed_item('main', 'Keys', 'name2', '') |
| self.new_custom_keys.config(text='', fg='black') |
| self.load_keys_list(value) |
| |
| def var_changed_custom_keys(self, *params): |
| value = self.custom_keys.get() |
| if value != '- no custom keys -': |
| self.add_changed_item('main', 'Keys', 'name', value) |
| self.load_keys_list(value) |
| |
| def var_changed_are_keys_builtin(self, *params): |
| value = self.are_keys_builtin.get() |
| self.add_changed_item('main', 'Keys', 'default', value) |
| if value: |
| self.var_changed_builtin_keys() |
| else: |
| self.var_changed_custom_keys() |
| |
| def var_changed_win_width(self, *params): |
| value = self.win_width.get() |
| self.add_changed_item('main', 'EditorWindow', 'width', value) |
| |
| def var_changed_win_height(self, *params): |
| value = self.win_height.get() |
| self.add_changed_item('main', 'EditorWindow', 'height', value) |
| |
| def var_changed_startup_edit(self, *params): |
| value = self.startup_edit.get() |
| self.add_changed_item('main', 'General', 'editor-on-startup', value) |
| |
| def var_changed_autosave(self, *params): |
| value = self.autosave.get() |
| self.add_changed_item('main', 'General', 'autosave', value) |
| |
| def var_changed_encoding(self, *params): |
| value = self.encoding.get() |
| self.add_changed_item('main', 'EditorWindow', 'encoding', value) |
| |
| def reset_changed_items(self): |
| #When any config item is changed in this dialog, an entry |
| #should be made in the relevant section (config type) of this |
| #dictionary. The key should be the config file section name and the |
| #value a dictionary, whose key:value pairs are item=value pairs for |
| #that config file section. |
| self.changed_items = {'main':{}, 'highlight':{}, 'keys':{}, |
| 'extensions':{}} |
| |
| def add_changed_item(self, typ, section, item, value): |
| value = str(value) #make sure we use a string |
| if section not in self.changed_items[typ]: |
| self.changed_items[typ][section] = {} |
| self.changed_items[typ][section][item] = value |
| |
| def GetDefaultItems(self): |
| d_items={'main':{}, 'highlight':{}, 'keys':{}, 'extensions':{}} |
| for config_type in d_items: |
| sections = idleConf.GetSectionList('default', config_type) |
| for section in sections: |
| d_items[config_type][section] = {} |
| options = idleConf.defaultCfg[config_type].GetOptionList(section) |
| for option in options: |
| d_items[config_type][section][option] = ( |
| idleConf.defaultCfg[config_type].Get(section, option)) |
| return d_items |
| |
| def set_theme_type(self): |
| if self.is_builtin_theme.get(): |
| self.opt_menu_theme_builtin.config(state=NORMAL) |
| self.opt_menu_theme_custom.config(state=DISABLED) |
| self.button_delete_custom_theme.config(state=DISABLED) |
| else: |
| self.opt_menu_theme_builtin.config(state=DISABLED) |
| self.radio_theme_custom.config(state=NORMAL) |
| self.opt_menu_theme_custom.config(state=NORMAL) |
| self.button_delete_custom_theme.config(state=NORMAL) |
| |
| def set_keys_type(self): |
| if self.are_keys_builtin.get(): |
| self.opt_menu_keys_builtin.config(state=NORMAL) |
| self.opt_menu_keys_custom.config(state=DISABLED) |
| self.button_delete_custom_keys.config(state=DISABLED) |
| else: |
| self.opt_menu_keys_builtin.config(state=DISABLED) |
| self.radio_keys_custom.config(state=NORMAL) |
| self.opt_menu_keys_custom.config(state=NORMAL) |
| self.button_delete_custom_keys.config(state=NORMAL) |
| |
| def get_new_keys(self): |
| list_index = self.list_bindings.index(ANCHOR) |
| binding = self.list_bindings.get(list_index) |
| bind_name = binding.split()[0] #first part, up to first space |
| if self.are_keys_builtin.get(): |
| current_key_set_name = self.builtin_keys.get() |
| else: |
| current_key_set_name = self.custom_keys.get() |
| current_bindings = idleConf.GetCurrentKeySet() |
| if current_key_set_name in self.changed_items['keys']: #unsaved changes |
| key_set_changes = self.changed_items['keys'][current_key_set_name] |
| for event in key_set_changes: |
| current_bindings[event] = key_set_changes[event].split() |
| current_key_sequences = list(current_bindings.values()) |
| new_keys = GetKeysDialog(self, 'Get New Keys', bind_name, |
| current_key_sequences).result |
| if new_keys: #new keys were specified |
| if self.are_keys_builtin.get(): #current key set is a built-in |
| message = ('Your changes will be saved as a new Custom Key Set.' |
| ' Enter a name for your new Custom Key Set below.') |
| new_keyset = self.get_new_keys_name(message) |
| if not new_keyset: #user cancelled custom key set creation |
| self.list_bindings.select_set(list_index) |
| self.list_bindings.select_anchor(list_index) |
| return |
| else: #create new custom key set based on previously active key set |
| self.create_new_key_set(new_keyset) |
| self.list_bindings.delete(list_index) |
| self.list_bindings.insert(list_index, bind_name+' - '+new_keys) |
| self.list_bindings.select_set(list_index) |
| self.list_bindings.select_anchor(list_index) |
| self.keybinding.set(new_keys) |
| else: |
| self.list_bindings.select_set(list_index) |
| self.list_bindings.select_anchor(list_index) |
| |
| def get_new_keys_name(self, message): |
| used_names = (idleConf.GetSectionList('user', 'keys') + |
| idleConf.GetSectionList('default', 'keys')) |
| new_keyset = SectionName( |
| self, 'New Custom Key Set', message, used_names).result |
| return new_keyset |
| |
| def save_as_new_key_set(self): |
| new_keys_name = self.get_new_keys_name('New Key Set Name:') |
| if new_keys_name: |
| self.create_new_key_set(new_keys_name) |
| |
| def keybinding_selected(self, event): |
| self.button_new_keys.config(state=NORMAL) |
| |
| def create_new_key_set(self, new_key_set_name): |
| #creates new custom key set based on the previously active key set, |
| #and makes the new key set active |
| if self.are_keys_builtin.get(): |
| prev_key_set_name = self.builtin_keys.get() |
| else: |
| prev_key_set_name = self.custom_keys.get() |
| prev_keys = idleConf.GetCoreKeys(prev_key_set_name) |
| new_keys = {} |
| for event in prev_keys: #add key set to changed items |
| event_name = event[2:-2] #trim off the angle brackets |
| binding = ' '.join(prev_keys[event]) |
| new_keys[event_name] = binding |
| #handle any unsaved changes to prev key set |
| if prev_key_set_name in self.changed_items['keys']: |
| key_set_changes = self.changed_items['keys'][prev_key_set_name] |
| for event in key_set_changes: |
| new_keys[event] = key_set_changes[event] |
| #save the new theme |
| self.save_new_key_set(new_key_set_name, new_keys) |
| #change gui over to the new key set |
| custom_key_list = idleConf.GetSectionList('user', 'keys') |
| custom_key_list.sort() |
| self.opt_menu_keys_custom.SetMenu(custom_key_list, new_key_set_name) |
| self.are_keys_builtin.set(0) |
| self.set_keys_type() |
| |
| def load_keys_list(self, keyset_name): |
| reselect = 0 |
| new_keyset = 0 |
| if self.list_bindings.curselection(): |
| reselect = 1 |
| list_index = self.list_bindings.index(ANCHOR) |
| keyset = idleConf.GetKeySet(keyset_name) |
| bind_names = list(keyset.keys()) |
| bind_names.sort() |
| self.list_bindings.delete(0, END) |
| for bind_name in bind_names: |
| key = ' '.join(keyset[bind_name]) #make key(s) into a string |
| bind_name = bind_name[2:-2] #trim off the angle brackets |
| if keyset_name in self.changed_items['keys']: |
| #handle any unsaved changes to this key set |
| if bind_name in self.changed_items['keys'][keyset_name]: |
| key = self.changed_items['keys'][keyset_name][bind_name] |
| self.list_bindings.insert(END, bind_name+' - '+key) |
| if reselect: |
| self.list_bindings.see(list_index) |
| self.list_bindings.select_set(list_index) |
| self.list_bindings.select_anchor(list_index) |
| |
| def delete_custom_keys(self): |
| keyset_name=self.custom_keys.get() |
| delmsg = 'Are you sure you wish to delete the key set %r ?' |
| if not tkMessageBox.askyesno( |
| 'Delete Key Set', delmsg % keyset_name, parent=self): |
| return |
| self.deactivate_current_config() |
| #remove key set from config |
| idleConf.userCfg['keys'].remove_section(keyset_name) |
| if keyset_name in self.changed_items['keys']: |
| del(self.changed_items['keys'][keyset_name]) |
| #write changes |
| idleConf.userCfg['keys'].Save() |
| #reload user key set list |
| item_list = idleConf.GetSectionList('user', 'keys') |
| item_list.sort() |
| if not item_list: |
| self.radio_keys_custom.config(state=DISABLED) |
| self.opt_menu_keys_custom.SetMenu(item_list, '- no custom keys -') |
| else: |
| self.opt_menu_keys_custom.SetMenu(item_list, item_list[0]) |
| #revert to default key set |
| self.are_keys_builtin.set(idleConf.defaultCfg['main'] |
| .Get('Keys', 'default')) |
| self.builtin_keys.set(idleConf.defaultCfg['main'].Get('Keys', 'name') |
| or idleConf.default_keys()) |
| #user can't back out of these changes, they must be applied now |
| self.save_all_changed_configs() |
| self.activate_config_changes() |
| self.set_keys_type() |
| |
| def delete_custom_theme(self): |
| theme_name = self.custom_theme.get() |
| delmsg = 'Are you sure you wish to delete the theme %r ?' |
| if not tkMessageBox.askyesno( |
| 'Delete Theme', delmsg % theme_name, parent=self): |
| return |
| self.deactivate_current_config() |
| #remove theme from config |
| idleConf.userCfg['highlight'].remove_section(theme_name) |
| if theme_name in self.changed_items['highlight']: |
| del(self.changed_items['highlight'][theme_name]) |
| #write changes |
| idleConf.userCfg['highlight'].Save() |
| #reload user theme list |
| item_list = idleConf.GetSectionList('user', 'highlight') |
| item_list.sort() |
| if not item_list: |
| self.radio_theme_custom.config(state=DISABLED) |
| self.opt_menu_theme_custom.SetMenu(item_list, '- no custom themes -') |
| else: |
| self.opt_menu_theme_custom.SetMenu(item_list, item_list[0]) |
| #revert to default theme |
| self.is_builtin_theme.set(idleConf.defaultCfg['main'].Get('Theme', 'default')) |
| self.builtin_theme.set(idleConf.defaultCfg['main'].Get('Theme', 'name')) |
| #user can't back out of these changes, they must be applied now |
| self.save_all_changed_configs() |
| self.activate_config_changes() |
| self.set_theme_type() |
| |
| def get_colour(self): |
| target = self.highlight_target.get() |
| prev_colour = self.frame_colour_set.cget('bg') |
| rgbTuplet, colour_string = tkColorChooser.askcolor( |
| parent=self, title='Pick new colour for : '+target, |
| initialcolor=prev_colour) |
| if colour_string and (colour_string != prev_colour): |
| #user didn't cancel, and they chose a new colour |
| if self.is_builtin_theme.get(): #current theme is a built-in |
| message = ('Your changes will be saved as a new Custom Theme. ' |
| 'Enter a name for your new Custom Theme below.') |
| new_theme = self.get_new_theme_name(message) |
| if not new_theme: #user cancelled custom theme creation |
| return |
| else: #create new custom theme based on previously active theme |
| self.create_new_theme(new_theme) |
| self.colour.set(colour_string) |
| else: #current theme is user defined |
| self.colour.set(colour_string) |
| |
| def on_new_colour_set(self): |
| new_colour=self.colour.get() |
| self.frame_colour_set.config(bg=new_colour) #set sample |
| plane ='foreground' if self.fg_bg_toggle.get() else 'background' |
| sample_element = self.theme_elements[self.highlight_target.get()][0] |
| self.text_highlight_sample.tag_config(sample_element, **{plane:new_colour}) |
| theme = self.custom_theme.get() |
| theme_element = sample_element + '-' + plane |
| self.add_changed_item('highlight', theme, theme_element, new_colour) |
| |
| def get_new_theme_name(self, message): |
| used_names = (idleConf.GetSectionList('user', 'highlight') + |
| idleConf.GetSectionList('default', 'highlight')) |
| new_theme = SectionName( |
| self, 'New Custom Theme', message, used_names).result |
| return new_theme |
| |
| def save_as_new_theme(self): |
| new_theme_name = self.get_new_theme_name('New Theme Name:') |
| if new_theme_name: |
| self.create_new_theme(new_theme_name) |
| |
| def create_new_theme(self, new_theme_name): |
| #creates new custom theme based on the previously active theme, |
| #and makes the new theme active |
| if self.is_builtin_theme.get(): |
| theme_type = 'default' |
| theme_name = self.builtin_theme.get() |
| else: |
| theme_type = 'user' |
| theme_name = self.custom_theme.get() |
| new_theme = idleConf.GetThemeDict(theme_type, theme_name) |
| #apply any of the old theme's unsaved changes to the new theme |
| if theme_name in self.changed_items['highlight']: |
| theme_changes = self.changed_items['highlight'][theme_name] |
| for element in theme_changes: |
| new_theme[element] = theme_changes[element] |
| #save the new theme |
| self.save_new_theme(new_theme_name, new_theme) |
| #change gui over to the new theme |
| custom_theme_list = idleConf.GetSectionList('user', 'highlight') |
| custom_theme_list.sort() |
| self.opt_menu_theme_custom.SetMenu(custom_theme_list, new_theme_name) |
| self.is_builtin_theme.set(0) |
| self.set_theme_type() |
| |
| def on_list_fonts_button_release(self, event): |
| font = self.list_fonts.get(ANCHOR) |
| self.font_name.set(font.lower()) |
| self.set_font_sample() |
| |
| def set_font_sample(self, event=None): |
| font_name = self.font_name.get() |
| font_weight = tkFont.BOLD if self.font_bold.get() else tkFont.NORMAL |
| new_font = (font_name, self.font_size.get(), font_weight) |
| self.font_sample.config(font=new_font) |
| self.text_highlight_sample.configure(font=new_font) |
| |
| def set_highlight_target(self): |
| if self.highlight_target.get() == 'Cursor': #bg not possible |
| self.radio_fg.config(state=DISABLED) |
| self.radio_bg.config(state=DISABLED) |
| self.fg_bg_toggle.set(1) |
| else: #both fg and bg can be set |
| self.radio_fg.config(state=NORMAL) |
| self.radio_bg.config(state=NORMAL) |
| self.fg_bg_toggle.set(1) |
| self.set_colour_sample() |
| |
| def set_colour_sample_binding(self, *args): |
| self.set_colour_sample() |
| |
| def set_colour_sample(self): |
| #set the colour smaple area |
| tag = self.theme_elements[self.highlight_target.get()][0] |
| plane = 'foreground' if self.fg_bg_toggle.get() else 'background' |
| colour = self.text_highlight_sample.tag_cget(tag, plane) |
| self.frame_colour_set.config(bg=colour) |
| |
| def paint_theme_sample(self): |
| if self.is_builtin_theme.get(): #a default theme |
| theme = self.builtin_theme.get() |
| else: #a user theme |
| theme = self.custom_theme.get() |
| for element_title in self.theme_elements: |
| element = self.theme_elements[element_title][0] |
| colours = idleConf.GetHighlight(theme, element) |
| if element == 'cursor': #cursor sample needs special painting |
| colours['background'] = idleConf.GetHighlight( |
| theme, 'normal', fgBg='bg') |
| #handle any unsaved changes to this theme |
| if theme in self.changed_items['highlight']: |
| theme_dict = self.changed_items['highlight'][theme] |
| if element + '-foreground' in theme_dict: |
| colours['foreground'] = theme_dict[element + '-foreground'] |
| if element + '-background' in theme_dict: |
| colours['background'] = theme_dict[element + '-background'] |
| self.text_highlight_sample.tag_config(element, **colours) |
| self.set_colour_sample() |
| |
| def help_source_selected(self, event): |
| self.set_helplist_button_states() |
| |
| def set_helplist_button_states(self): |
| if self.list_help.size() < 1: #no entries in list |
| self.button_helplist_edit.config(state=DISABLED) |
| self.button_helplist_remove.config(state=DISABLED) |
| else: #there are some entries |
| if self.list_help.curselection(): #there currently is a selection |
| self.button_helplist_edit.config(state=NORMAL) |
| self.button_helplist_remove.config(state=NORMAL) |
| else: #there currently is not a selection |
| self.button_helplist_edit.config(state=DISABLED) |
| self.button_helplist_remove.config(state=DISABLED) |
| |
| def helplist_item_add(self): |
| help_source = HelpSource(self, 'New Help Source', |
| ).result |
| if help_source: |
| self.user_helplist.append((help_source[0], help_source[1])) |
| self.list_help.insert(END, help_source[0]) |
| self.update_user_help_changed_items() |
| self.set_helplist_button_states() |
| |
| def helplist_item_edit(self): |
| item_index = self.list_help.index(ANCHOR) |
| help_source = self.user_helplist[item_index] |
| new_help_source = HelpSource( |
| self, 'Edit Help Source', |
| menuitem=help_source[0], |
| filepath=help_source[1], |
| ).result |
| if new_help_source and new_help_source != help_source: |
| self.user_helplist[item_index] = new_help_source |
| self.list_help.delete(item_index) |
| self.list_help.insert(item_index, new_help_source[0]) |
| self.update_user_help_changed_items() |
| self.set_helplist_button_states() |
| |
| def helplist_item_remove(self): |
| item_index = self.list_help.index(ANCHOR) |
| del(self.user_helplist[item_index]) |
| self.list_help.delete(item_index) |
| self.update_user_help_changed_items() |
| self.set_helplist_button_states() |
| |
| def update_user_help_changed_items(self): |
| "Clear and rebuild the HelpFiles section in self.changed_items" |
| self.changed_items['main']['HelpFiles'] = {} |
| for num in range(1, len(self.user_helplist) + 1): |
| self.add_changed_item( |
| 'main', 'HelpFiles', str(num), |
| ';'.join(self.user_helplist[num-1][:2])) |
| |
| def load_font_cfg(self): |
| ##base editor font selection list |
| fonts = list(tkFont.families(self)) |
| fonts.sort() |
| for font in fonts: |
| self.list_fonts.insert(END, font) |
| configured_font = idleConf.GetFont(self, 'main', 'EditorWindow') |
| font_name = configured_font[0].lower() |
| font_size = configured_font[1] |
| font_bold = configured_font[2]=='bold' |
| self.font_name.set(font_name) |
| lc_fonts = [s.lower() for s in fonts] |
| try: |
| current_font_index = lc_fonts.index(font_name) |
| self.list_fonts.see(current_font_index) |
| self.list_fonts.select_set(current_font_index) |
| self.list_fonts.select_anchor(current_font_index) |
| except ValueError: |
| pass |
| ##font size dropdown |
| self.opt_menu_font_size.SetMenu(('7', '8', '9', '10', '11', '12', '13', |
| '14', '16', '18', '20', '22', |
| '25', '29', '34', '40'), font_size ) |
| ##font_weight |
| self.font_bold.set(font_bold) |
| ##font sample |
| self.set_font_sample() |
| |
| def load_tab_cfg(self): |
| ##indent sizes |
| space_num = idleConf.GetOption( |
| 'main', 'Indent', 'num-spaces', default=4, type='int') |
| self.space_num.set(space_num) |
| |
| def load_theme_cfg(self): |
| ##current theme type radiobutton |
| self.is_builtin_theme.set(idleConf.GetOption( |
| 'main', 'Theme', 'default', type='bool', default=1)) |
| ##currently set theme |
| current_option = idleConf.CurrentTheme() |
| ##load available theme option menus |
| if self.is_builtin_theme.get(): #default theme selected |
| item_list = idleConf.GetSectionList('default', 'highlight') |
| item_list.sort() |
| self.opt_menu_theme_builtin.SetMenu(item_list, current_option) |
| item_list = idleConf.GetSectionList('user', 'highlight') |
| item_list.sort() |
| if not item_list: |
| self.radio_theme_custom.config(state=DISABLED) |
| self.custom_theme.set('- no custom themes -') |
| else: |
| self.opt_menu_theme_custom.SetMenu(item_list, item_list[0]) |
| else: #user theme selected |
| item_list = idleConf.GetSectionList('user', 'highlight') |
| item_list.sort() |
| self.opt_menu_theme_custom.SetMenu(item_list, current_option) |
| item_list = idleConf.GetSectionList('default', 'highlight') |
| item_list.sort() |
| self.opt_menu_theme_builtin.SetMenu(item_list, item_list[0]) |
| self.set_theme_type() |
| ##load theme element option menu |
| theme_names = list(self.theme_elements.keys()) |
| theme_names.sort(key=lambda x: self.theme_elements[x][1]) |
| self.opt_menu_highlight_target.SetMenu(theme_names, theme_names[0]) |
| self.paint_theme_sample() |
| self.set_highlight_target() |
| |
| def load_key_cfg(self): |
| ##current keys type radiobutton |
| self.are_keys_builtin.set(idleConf.GetOption( |
| 'main', 'Keys', 'default', type='bool', default=1)) |
| ##currently set keys |
| current_option = idleConf.CurrentKeys() |
| ##load available keyset option menus |
| if self.are_keys_builtin.get(): #default theme selected |
| item_list = idleConf.GetSectionList('default', 'keys') |
| item_list.sort() |
| self.opt_menu_keys_builtin.SetMenu(item_list, current_option) |
| item_list = idleConf.GetSectionList('user', 'keys') |
| item_list.sort() |
| if not item_list: |
| self.radio_keys_custom.config(state=DISABLED) |
| self.custom_keys.set('- no custom keys -') |
| else: |
| self.opt_menu_keys_custom.SetMenu(item_list, item_list[0]) |
| else: #user key set selected |
| item_list = idleConf.GetSectionList('user', 'keys') |
| item_list.sort() |
| self.opt_menu_keys_custom.SetMenu(item_list, current_option) |
| item_list = idleConf.GetSectionList('default', 'keys') |
| item_list.sort() |
| self.opt_menu_keys_builtin.SetMenu(item_list, idleConf.default_keys()) |
| self.set_keys_type() |
| ##load keyset element list |
| keyset_name = idleConf.CurrentKeys() |
| self.load_keys_list(keyset_name) |
| |
| def load_general_cfg(self): |
| #startup state |
| self.startup_edit.set(idleConf.GetOption( |
| 'main', 'General', 'editor-on-startup', default=1, type='bool')) |
| #autosave state |
| self.autosave.set(idleConf.GetOption( |
| 'main', 'General', 'autosave', default=0, type='bool')) |
| #initial window size |
| self.win_width.set(idleConf.GetOption( |
| 'main', 'EditorWindow', 'width', type='int')) |
| self.win_height.set(idleConf.GetOption( |
| 'main', 'EditorWindow', 'height', type='int')) |
| # default source encoding |
| self.encoding.set(idleConf.GetOption( |
| 'main', 'EditorWindow', 'encoding', default='none')) |
| # additional help sources |
| self.user_helplist = idleConf.GetAllExtraHelpSourcesList() |
| for help_item in self.user_helplist: |
| self.list_help.insert(END, help_item[0]) |
| self.set_helplist_button_states() |
| |
| def load_configs(self): |
| """ |
| load configuration from default and user config files and populate |
| the widgets on the config dialog pages. |
| """ |
| ### fonts / tabs page |
| self.load_font_cfg() |
| self.load_tab_cfg() |
| ### highlighting page |
| self.load_theme_cfg() |
| ### keys page |
| self.load_key_cfg() |
| ### general page |
| self.load_general_cfg() |
| # note: extension page handled separately |
| |
| def save_new_key_set(self, keyset_name, keyset): |
| """ |
| save a newly created core key set. |
| keyset_name - string, the name of the new key set |
| keyset - dictionary containing the new key set |
| """ |
| if not idleConf.userCfg['keys'].has_section(keyset_name): |
| idleConf.userCfg['keys'].add_section(keyset_name) |
| for event in keyset: |
| value = keyset[event] |
| idleConf.userCfg['keys'].SetOption(keyset_name, event, value) |
| |
| def save_new_theme(self, theme_name, theme): |
| """ |
| save a newly created theme. |
| theme_name - string, the name of the new theme |
| theme - dictionary containing the new theme |
| """ |
| if not idleConf.userCfg['highlight'].has_section(theme_name): |
| idleConf.userCfg['highlight'].add_section(theme_name) |
| for element in theme: |
| value = theme[element] |
| idleConf.userCfg['highlight'].SetOption(theme_name, element, value) |
| |
| def set_user_value(self, config_type, section, item, value): |
| if idleConf.defaultCfg[config_type].has_option(section, item): |
| if idleConf.defaultCfg[config_type].Get(section, item) == value: |
| #the setting equals a default setting, remove it from user cfg |
| return idleConf.userCfg[config_type].RemoveOption(section, item) |
| #if we got here set the option |
| return idleConf.userCfg[config_type].SetOption(section, item, value) |
| |
| def save_all_changed_configs(self): |
| "Save configuration changes to the user config file." |
| idleConf.userCfg['main'].Save() |
| for config_type in self.changed_items: |
| cfg_type_changed = False |
| for section in self.changed_items[config_type]: |
| if section == 'HelpFiles': |
| #this section gets completely replaced |
| idleConf.userCfg['main'].remove_section('HelpFiles') |
| cfg_type_changed = True |
| for item in self.changed_items[config_type][section]: |
| value = self.changed_items[config_type][section][item] |
| if self.set_user_value(config_type, section, item, value): |
| cfg_type_changed = True |
| if cfg_type_changed: |
| idleConf.userCfg[config_type].Save() |
| for config_type in ['keys', 'highlight']: |
| # save these even if unchanged! |
| idleConf.userCfg[config_type].Save() |
| self.reset_changed_items() #clear the changed items dict |
| self.save_all_changed_extensions() # uses a different mechanism |
| |
| def deactivate_current_config(self): |
| #Before a config is saved, some cleanup of current |
| #config must be done - remove the previous keybindings |
| win_instances = self.parent.instance_dict.keys() |
| for instance in win_instances: |
| instance.RemoveKeybindings() |
| |
| def activate_config_changes(self): |
| "Dynamically apply configuration changes" |
| win_instances = self.parent.instance_dict.keys() |
| for instance in win_instances: |
| instance.ResetColorizer() |
| instance.ResetFont() |
| instance.set_notabs_indentwidth() |
| instance.ApplyKeybindings() |
| instance.reset_help_menu_entries() |
| |
| def cancel(self): |
| self.destroy() |
| |
| def ok(self): |
| self.apply() |
| self.destroy() |
| |
| def apply(self): |
| self.deactivate_current_config() |
| self.save_all_changed_configs() |
| self.activate_config_changes() |
| |
| def help(self): |
| page = self.tab_pages._current_page |
| view_text(self, title='Help for IDLE preferences', |
| text=help_common+help_pages.get(page, '')) |
| |
| def create_page_extensions(self): |
| """Part of the config dialog used for configuring IDLE extensions. |
| |
| This code is generic - it works for any and all IDLE extensions. |
| |
| IDLE extensions save their configuration options using idleConf. |
| This code reads the current configuration using idleConf, supplies a |
| GUI interface to change the configuration values, and saves the |
| changes using idleConf. |
| |
| Not all changes take effect immediately - some may require restarting IDLE. |
| This depends on each extension's implementation. |
| |
| All values are treated as text, and it is up to the user to supply |
| reasonable values. The only exception to this are the 'enable*' options, |
| which are boolean, and can be toggled with a True/False button. |
| """ |
| parent = self.parent |
| frame = self.tab_pages.pages['Extensions'].frame |
| self.ext_defaultCfg = idleConf.defaultCfg['extensions'] |
| self.ext_userCfg = idleConf.userCfg['extensions'] |
| self.is_int = self.register(is_int) |
| self.load_extensions() |
| # create widgets - a listbox shows all available extensions, with the |
| # controls for the extension selected in the listbox to the right |
| self.extension_names = StringVar(self) |
| frame.rowconfigure(0, weight=1) |
| frame.columnconfigure(2, weight=1) |
| self.extension_list = Listbox(frame, listvariable=self.extension_names, |
| selectmode='browse') |
| self.extension_list.bind('<<ListboxSelect>>', self.extension_selected) |
| scroll = Scrollbar(frame, command=self.extension_list.yview) |
| self.extension_list.yscrollcommand=scroll.set |
| self.details_frame = LabelFrame(frame, width=250, height=250) |
| self.extension_list.grid(column=0, row=0, sticky='nws') |
| scroll.grid(column=1, row=0, sticky='ns') |
| self.details_frame.grid(column=2, row=0, sticky='nsew', padx=[10, 0]) |
| frame.configure(padx=10, pady=10) |
| self.config_frame = {} |
| self.current_extension = None |
| |
| self.outerframe = self # TEMPORARY |
| self.tabbed_page_set = self.extension_list # TEMPORARY |
| |
| # create the frame holding controls for each extension |
| ext_names = '' |
| for ext_name in sorted(self.extensions): |
| self.create_extension_frame(ext_name) |
| ext_names = ext_names + '{' + ext_name + '} ' |
| self.extension_names.set(ext_names) |
| self.extension_list.selection_set(0) |
| self.extension_selected(None) |
| |
| def load_extensions(self): |
| "Fill self.extensions with data from the default and user configs." |
| self.extensions = {} |
| for ext_name in idleConf.GetExtensions(active_only=False): |
| self.extensions[ext_name] = [] |
| |
| for ext_name in self.extensions: |
| opt_list = sorted(self.ext_defaultCfg.GetOptionList(ext_name)) |
| |
| # bring 'enable' options to the beginning of the list |
| enables = [opt_name for opt_name in opt_list |
| if opt_name.startswith('enable')] |
| for opt_name in enables: |
| opt_list.remove(opt_name) |
| opt_list = enables + opt_list |
| |
| for opt_name in opt_list: |
| def_str = self.ext_defaultCfg.Get( |
| ext_name, opt_name, raw=True) |
| try: |
| def_obj = {'True':True, 'False':False}[def_str] |
| opt_type = 'bool' |
| except KeyError: |
| try: |
| def_obj = int(def_str) |
| opt_type = 'int' |
| except ValueError: |
| def_obj = def_str |
| opt_type = None |
| try: |
| value = self.ext_userCfg.Get( |
| ext_name, opt_name, type=opt_type, raw=True, |
| default=def_obj) |
| except ValueError: # Need this until .Get fixed |
| value = def_obj # bad values overwritten by entry |
| var = StringVar(self) |
| var.set(str(value)) |
| |
| self.extensions[ext_name].append({'name': opt_name, |
| 'type': opt_type, |
| 'default': def_str, |
| 'value': value, |
| 'var': var, |
| }) |
| |
| def extension_selected(self, event): |
| newsel = self.extension_list.curselection() |
| if newsel: |
| newsel = self.extension_list.get(newsel) |
| if newsel is None or newsel != self.current_extension: |
| if self.current_extension: |
| self.details_frame.config(text='') |
| self.config_frame[self.current_extension].grid_forget() |
| self.current_extension = None |
| if newsel: |
| self.details_frame.config(text=newsel) |
| self.config_frame[newsel].grid(column=0, row=0, sticky='nsew') |
| self.current_extension = newsel |
| |
| def create_extension_frame(self, ext_name): |
| """Create a frame holding the widgets to configure one extension""" |
| f = VerticalScrolledFrame(self.details_frame, height=250, width=250) |
| self.config_frame[ext_name] = f |
| entry_area = f.interior |
| # create an entry for each configuration option |
| for row, opt in enumerate(self.extensions[ext_name]): |
| # create a row with a label and entry/checkbutton |
| label = Label(entry_area, text=opt['name']) |
| label.grid(row=row, column=0, sticky=NW) |
| var = opt['var'] |
| if opt['type'] == 'bool': |
| Checkbutton(entry_area, textvariable=var, variable=var, |
| onvalue='True', offvalue='False', |
| indicatoron=FALSE, selectcolor='', width=8 |
| ).grid(row=row, column=1, sticky=W, padx=7) |
| elif opt['type'] == 'int': |
| Entry(entry_area, textvariable=var, validate='key', |
| validatecommand=(self.is_int, '%P') |
| ).grid(row=row, column=1, sticky=NSEW, padx=7) |
| |
| else: |
| Entry(entry_area, textvariable=var |
| ).grid(row=row, column=1, sticky=NSEW, padx=7) |
| return |
| |
| def set_extension_value(self, section, opt): |
| name = opt['name'] |
| default = opt['default'] |
| value = opt['var'].get().strip() or default |
| opt['var'].set(value) |
| # if self.defaultCfg.has_section(section): |
| # Currently, always true; if not, indent to return |
| if (value == default): |
| return self.ext_userCfg.RemoveOption(section, name) |
| # set the option |
| return self.ext_userCfg.SetOption(section, name, value) |
| |
| def save_all_changed_extensions(self): |
| """Save configuration changes to the user config file.""" |
| has_changes = False |
| for ext_name in self.extensions: |
| options = self.extensions[ext_name] |
| for opt in options: |
| if self.set_extension_value(ext_name, opt): |
| has_changes = True |
| if has_changes: |
| self.ext_userCfg.Save() |
| |
| |
| help_common = '''\ |
| When you click either the Apply or Ok buttons, settings in this |
| dialog that are different from IDLE's default are saved in |
| a .idlerc directory in your home directory. Except as noted, |
| these changes apply to all versions of IDLE installed on this |
| machine. Some do not take affect until IDLE is restarted. |
| [Cancel] only cancels changes made since the last save. |
| ''' |
| help_pages = { |
| 'Highlighting': ''' |
| Highlighting: |
| The IDLE Dark color theme is new in October 2015. It can only |
| be used with older IDLE releases if it is saved as a custom |
| theme, with a different name. |
| ''', |
| 'Keys': ''' |
| Keys: |
| The IDLE Modern Unix key set is new in June 2016. It can only |
| be used with older IDLE releases if it is saved as a custom |
| key set, with a different name. |
| ''', |
| } |
| |
| |
| def is_int(s): |
| "Return 's is blank or represents an int'" |
| if not s: |
| return True |
| try: |
| int(s) |
| return True |
| except ValueError: |
| return False |
| |
| |
| class VerticalScrolledFrame(Frame): |
| """A pure Tkinter vertically scrollable frame. |
| |
| * Use the 'interior' attribute to place widgets inside the scrollable frame |
| * Construct and pack/place/grid normally |
| * This frame only allows vertical scrolling |
| """ |
| def __init__(self, parent, *args, **kw): |
| Frame.__init__(self, parent, *args, **kw) |
| |
| # create a canvas object and a vertical scrollbar for scrolling it |
| vscrollbar = Scrollbar(self, orient=VERTICAL) |
| vscrollbar.pack(fill=Y, side=RIGHT, expand=FALSE) |
| canvas = Canvas(self, bd=0, highlightthickness=0, |
| yscrollcommand=vscrollbar.set, width=240) |
| canvas.pack(side=LEFT, fill=BOTH, expand=TRUE) |
| vscrollbar.config(command=canvas.yview) |
| |
| # reset the view |
| canvas.xview_moveto(0) |
| canvas.yview_moveto(0) |
| |
| # create a frame inside the canvas which will be scrolled with it |
| self.interior = interior = Frame(canvas) |
| interior_id = canvas.create_window(0, 0, window=interior, anchor=NW) |
| |
| # track changes to the canvas and frame width and sync them, |
| # also updating the scrollbar |
| def _configure_interior(event): |
| # update the scrollbars to match the size of the inner frame |
| size = (interior.winfo_reqwidth(), interior.winfo_reqheight()) |
| canvas.config(scrollregion="0 0 %s %s" % size) |
| interior.bind('<Configure>', _configure_interior) |
| |
| def _configure_canvas(event): |
| if interior.winfo_reqwidth() != canvas.winfo_width(): |
| # update the inner frame's width to fill the canvas |
| canvas.itemconfigure(interior_id, width=canvas.winfo_width()) |
| canvas.bind('<Configure>', _configure_canvas) |
| |
| return |
| |
| |
| if __name__ == '__main__': |
| import unittest |
| unittest.main('idlelib.idle_test.test_configdialog', |
| verbosity=2, exit=False) |
| from idlelib.idle_test.htest import run |
| run(ConfigDialog) |