text: """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, Listbox, Text, Scale, Canvas,
                       StringVar, BooleanVar, IntVar, TRUE, FALSE,
                       TOP, BOTTOM, RIGHT, LEFT, SOLID, GROOVE,
                       NONE, BOTH, X, Y, W, E, EW, NS, NSEW, NW,
                       HORIZONTAL, VERTICAL, ANCHOR, ACTIVE, END)
  from tkinter.ttk import (Frame, LabelFrame, Button, Checkbutton, Entry, Label,
                           OptionMenu, Notebook, Radiobutton, Scrollbar, Style)
  import tkinter.colorchooser as tkColorChooser
  import tkinter.font as tkFont
  from tkinter import messagebox
  
  from idlelib.config import idleConf, ConfigChanges
  from idlelib.config_key import GetKeysDialog
  from idlelib.dynoption import DynOptionMenu
  from idlelib import macosx
  from idlelib.query import SectionName, HelpSource
  from idlelib.textview import view_text
  from idlelib.autocomplete import AutoComplete
  from idlelib.codecontext import CodeContext
  from idlelib.parenmatch import ParenMatch
  from idlelib.paragraph import FormatParagraph
  from idlelib.squeezer import Squeezer
  
  changes = ConfigChanges()
  # Reload changed options in the following classes.
  reloadables = (AutoComplete, CodeContext, ParenMatch, FormatParagraph,
                 Squeezer)
  
  
  class ConfigDialog(Toplevel):
      """Config dialog for IDLE.
      """
  
      def __init__(self, parent, title='', *, _htest=False, _utest=False):
          """Show the tabbed dialog for user configuration.
  
          Args:
              parent - parent of this dialog
              title - string which is the title of this popup dialog
              _htest - bool, change box location when running htest
              _utest - bool, don't wait_window when running unittest
  
          Note: Focus set on font page fontlist.
  
          Methods:
              create_widgets
              cancel: Bound to DELETE_WINDOW protocol.
          """
          Toplevel.__init__(self, parent)
          self.parent = parent
          if _htest:
              parent.instance_dict = {}
          if not _utest:
              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}')
          # 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.create_widgets()
          self.resizable(height=FALSE, width=FALSE)
          self.transient(parent)
          self.protocol("WM_DELETE_WINDOW", self.cancel)
          self.fontpage.fontlist.focus_set()
          # XXX Decide whether to keep or delete these key bindings.
          # 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
          # Attach callbacks after loading config to avoid calling them.
          tracers.attach()
  
          if not _utest:
              self.grab_set()
              self.wm_deiconify()
              self.wait_window()
  
      def create_widgets(self):
          """Create and place widgets for tabbed dialog.
  
          Widgets Bound to self:
              note: Notebook
              highpage: HighPage
              fontpage: FontPage
              keyspage: KeysPage
              genpage: GenPage
              extpage: self.create_page_extensions
  
          Methods:
              create_action_buttons
              load_configs: Load pages except for extensions.
              activate_config_changes: Tell editors to reload.
          """
          self.note = note = Notebook(self)
          self.highpage = HighPage(note)
          self.fontpage = FontPage(note, self.highpage)
          self.keyspage = KeysPage(note)
          self.genpage = GenPage(note)
          self.extpage = self.create_page_extensions()
          note.add(self.fontpage, text='Fonts/Tabs')
          note.add(self.highpage, text='Highlights')
          note.add(self.keyspage, text=' Keys ')
          note.add(self.genpage, text=' General ')
          note.add(self.extpage, text='Extensions')
          note.enable_traversal()
          note.pack(side=TOP, expand=TRUE, fill=BOTH)
          self.create_action_buttons().pack(side=BOTTOM)
  
      def create_action_buttons(self):
          """Return frame of action buttons for dialog.
  
          Methods:
              ok
              apply
              cancel
              help
  
          Widget Structure:
              outer: Frame
                  buttons: Frame
                      (no assignment): Button (ok)
                      (no assignment): Button (apply)
                      (no assignment): Button (cancel)
                      (no assignment): Button (help)
                  (no assignment): Frame
          """
          if macosx.isAquaTk():
              # Changing the default padding on OSX results in unreadable
              # text in the buttons.
              padding_args = {}
          else:
              padding_args = {'padding': (6, 3)}
          outer = Frame(self, padding=2)
          buttons = Frame(outer, padding=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 ok(self):
          """Apply config changes, then dismiss dialog.
  
          Methods:
              apply
              destroy: inherited
          """
          self.apply()
          self.destroy()
  
      def apply(self):
          """Apply config changes and leave dialog open.
  
          Methods:
              deactivate_current_config
              save_all_changed_extensions
              activate_config_changes
          """
          self.deactivate_current_config()
          changes.save_all()
          self.save_all_changed_extensions()
          self.activate_config_changes()
  
      def cancel(self):
          """Dismiss config dialog.
  
          Methods:
              destroy: inherited
          """
          self.destroy()
  
      def destroy(self):
          global font_sample_text
          font_sample_text = self.fontpage.font_sample.get('1.0', 'end')
          self.grab_release()
          super().destroy()
  
      def help(self):
          """Create textview for config dialog help.
  
          Attributes accessed:
              note
  
          Methods:
              view_text: Method from textview module.
          """
          page = self.note.tab(self.note.select(), option='text').strip()
          view_text(self, title='Help for IDLE preferences',
                   text=help_common+help_pages.get(page, ''))
  
      def deactivate_current_config(self):
          """Remove current key bindings.
          Iterate over window instances defined in parent and remove
          the keybindings.
          """
          # 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):
          """Apply configuration changes to current windows.
  
          Dynamically update the current parent window instances
          with some of the 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()
          for klass in reloadables:
              klass.reload()
  
      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.
  
          Methods:
              load_extensions:
              extension_selected: Handle selection from list.
              create_extension_frame: Hold widgets for one extension.
              set_extension_value: Set in userCfg['extensions'].
              save_all_changed_extensions: Call extension page Save().
          """
          parent = self.parent
          frame = Frame(self.note)
          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(padding=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)
  
          return frame
  
      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):
              # Former built-in extensions are already filtered out.
              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):
          "Handle selection of an extension from the list."
          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, variable=var,
                              onvalue='True', offvalue='False', 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'), width=10
                        ).grid(row=row, column=1, sticky=NSEW, padx=7)
  
              else:  # type == 'str'
                  # Limit size to fit non-expanding space with larger font.
                  Entry(entry_area, textvariable=var, width=15
                        ).grid(row=row, column=1, sticky=NSEW, padx=7)
          return
  
      def set_extension_value(self, section, opt):
          """Return True if the configuration was added or changed.
  
          If the value is the same as the default, then remove it
          from user config file.
          """
          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.
  
          Attributes accessed:
              extensions
  
          Methods:
              set_extension_value
          """
          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()
  
  
  # class TabPage(Frame):  # A template for Page classes.
  #     def __init__(self, master):
  #         super().__init__(master)
  #         self.create_page_tab()
  #         self.load_tab_cfg()
  #     def create_page_tab(self):
  #         # Define tk vars and register var and callback with tracers.
  #         # Create subframes and widgets.
  #         # Pack widgets.
  #     def load_tab_cfg(self):
  #         # Initialize widgets with data from idleConf.
  #     def var_changed_var_name():
  #         # For each tk var that needs other than default callback.
  #     def other_methods():
  #         # Define tab-specific behavior.
  
  font_sample_text = (
      '<ASCII/Latin1>\n'
      'AaBbCcDdEeFfGgHhIiJj\n1234567890#:+=(){}[]\n'
      '\u00a2\u00a3\u00a5\u00a7\u00a9\u00ab\u00ae\u00b6\u00bd\u011e'
      '\u00c0\u00c1\u00c2\u00c3\u00c4\u00c5\u00c7\u00d0\u00d8\u00df\n'
      '\n<IPA,Greek,Cyrillic>\n'
      '\u0250\u0255\u0258\u025e\u025f\u0264\u026b\u026e\u0270\u0277'
      '\u027b\u0281\u0283\u0286\u028e\u029e\u02a2\u02ab\u02ad\u02af\n'
      '\u0391\u03b1\u0392\u03b2\u0393\u03b3\u0394\u03b4\u0395\u03b5'
      '\u0396\u03b6\u0397\u03b7\u0398\u03b8\u0399\u03b9\u039a\u03ba\n'
      '\u0411\u0431\u0414\u0434\u0416\u0436\u041f\u043f\u0424\u0444'
      '\u0427\u0447\u042a\u044a\u042d\u044d\u0460\u0464\u046c\u04dc\n'
      '\n<Hebrew, Arabic>\n'
      '\u05d0\u05d1\u05d2\u05d3\u05d4\u05d5\u05d6\u05d7\u05d8\u05d9'
      '\u05da\u05db\u05dc\u05dd\u05de\u05df\u05e0\u05e1\u05e2\u05e3\n'
      '\u0627\u0628\u062c\u062f\u0647\u0648\u0632\u062d\u0637\u064a'
      '\u0660\u0661\u0662\u0663\u0664\u0665\u0666\u0667\u0668\u0669\n'
      '\n<Devanagari, Tamil>\n'
      '\u0966\u0967\u0968\u0969\u096a\u096b\u096c\u096d\u096e\u096f'
      '\u0905\u0906\u0907\u0908\u0909\u090a\u090f\u0910\u0913\u0914\n'
      '\u0be6\u0be7\u0be8\u0be9\u0bea\u0beb\u0bec\u0bed\u0bee\u0bef'
      '\u0b85\u0b87\u0b89\u0b8e\n'
      '\n<East Asian>\n'
      '\u3007\u4e00\u4e8c\u4e09\u56db\u4e94\u516d\u4e03\u516b\u4e5d\n'
      '\u6c49\u5b57\u6f22\u5b57\u4eba\u6728\u706b\u571f\u91d1\u6c34\n'
      '\uac00\ub0d0\ub354\ub824\ubaa8\ubd64\uc218\uc720\uc988\uce58\n'
      '\u3042\u3044\u3046\u3048\u304a\u30a2\u30a4\u30a6\u30a8\u30aa\n'
      )
  
  
  class FontPage(Frame):
  
      def __init__(self, master, highpage):
          super().__init__(master)
          self.highlight_sample = highpage.highlight_sample
          self.create_page_font_tab()
          self.load_font_cfg()
          self.load_tab_cfg()
  
      def create_page_font_tab(self):
          """Return frame of widgets for Font/Tabs tab.
  
          Fonts: Enable users to provisionally change font face, size, or
          boldness and to see the consequence of proposed choices.  Each
          action set 3 options in changes structuree and changes the
          corresponding aspect of the font sample on this page and
          highlight sample on highlight page.
  
          Function load_font_cfg initializes font vars and widgets from
          idleConf entries and tk.
  
          Fontlist: mouse button 1 click or up or down key invoke
          on_fontlist_select(), which sets var font_name.
  
          Sizelist: clicking the menubutton opens the dropdown menu. A
          mouse button 1 click or return key sets var font_size.
  
          Bold_toggle: clicking the box toggles var font_bold.
  
          Changing any of the font vars invokes var_changed_font, which
          adds all 3 font options to changes and calls set_samples.
          Set_samples applies a new font constructed from the font vars to
          font_sample and to highlight_sample on the highlight page.
  
          Tabs: Enable users to change spaces entered for indent tabs.
          Changing indent_scale value with the mouse sets Var space_num,
          which invokes the default callback to add an entry to
          changes.  Load_tab_cfg initializes space_num to default.
  
          Widgets for FontPage(Frame):  (*) widgets bound to self
              frame_font: LabelFrame
                  frame_font_name: Frame
                      font_name_title: Label
                      (*)fontlist: ListBox - font_name
                      scroll_font: Scrollbar
                  frame_font_param: Frame
                      font_size_title: Label
                      (*)sizelist: DynOptionMenu - font_size
                      (*)bold_toggle: Checkbutton - font_bold
              frame_sample: LabelFrame
                  (*)font_sample: Label
              frame_indent: LabelFrame
                      indent_title: Label
                      (*)indent_scale: Scale - space_num
          """
          self.font_name = tracers.add(StringVar(self), self.var_changed_font)
          self.font_size = tracers.add(StringVar(self), self.var_changed_font)
          self.font_bold = tracers.add(BooleanVar(self), self.var_changed_font)
          self.space_num = tracers.add(IntVar(self), ('main', 'Indent', 'num-spaces'))
  
          # Define frames and widgets.
          frame_font = LabelFrame(
                  self, borderwidth=2, relief=GROOVE, text=' Shell/Editor Font ')
          frame_sample = LabelFrame(
                  self, borderwidth=2, relief=GROOVE,
                  text=' Font Sample (Editable) ')
          frame_indent = LabelFrame(
                  self, 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.fontlist = Listbox(frame_font_name, height=15,
                                  takefocus=True, exportselection=FALSE)
          self.fontlist.bind('<ButtonRelease-1>', self.on_fontlist_select)
          self.fontlist.bind('<KeyRelease-Up>', self.on_fontlist_select)
          self.fontlist.bind('<KeyRelease-Down>', self.on_fontlist_select)
          scroll_font = Scrollbar(frame_font_name)
          scroll_font.config(command=self.fontlist.yview)
          self.fontlist.config(yscrollcommand=scroll_font.set)
          font_size_title = Label(frame_font_param, text='Size :')
          self.sizelist = DynOptionMenu(frame_font_param, self.font_size, None)
          self.bold_toggle = Checkbutton(
                  frame_font_param, variable=self.font_bold,
                  onvalue=1, offvalue=0, text='Bold')
          # frame_sample.
          self.font_sample = Text(frame_sample, width=20, height=20)
          self.font_sample.insert(END, font_sample_text)
          # frame_indent.
          indent_title = Label(
                  frame_indent, justify=LEFT,
                  text='Python Standard: 4 Spaces!')
          self.indent_scale = Scale(
                  frame_indent, variable=self.space_num,
                  orient='horizontal', tickinterval=2, from_=2, to=16)
  
          # Grid and pack widgets:
          self.columnconfigure(1, weight=1)
          frame_font.grid(row=0, column=0, padx=5, pady=5)
          frame_sample.grid(row=0, column=1, rowspan=2, padx=5, pady=5,
                            sticky='nsew')
          frame_indent.grid(row=1, column=0, padx=5, pady=5, sticky='ew')
          # 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.fontlist.pack(side=LEFT, expand=TRUE, fill=X)
          scroll_font.pack(side=LEFT, fill=Y)
          font_size_title.pack(side=LEFT, anchor=W)
          self.sizelist.pack(side=LEFT, anchor=W)
          self.bold_toggle.pack(side=LEFT, anchor=W, padx=20)
          # frame_sample.
          self.font_sample.pack(expand=TRUE, fill=BOTH)
          # frame_indent.
          indent_title.pack(side=TOP, anchor=W, padx=5)
          self.indent_scale.pack(side=TOP, padx=5, fill=X)
  
      def load_font_cfg(self):
          """Load current configuration settings for the font options.
  
          Retrieve current font with idleConf.GetFont and font families
          from tk. Setup fontlist and set font_name.  Setup sizelist,
          which sets font_size.  Set font_bold.  Call set_samples.
          """
          configured_font = idleConf.GetFont(self, 'main', 'EditorWindow')
          font_name = configured_font[0].lower()
          font_size = configured_font[1]
          font_bold  = configured_font[2]=='bold'
  
          # Set editor font selection list and font_name.
          fonts = list(tkFont.families(self))
          fonts.sort()
          for font in fonts:
              self.fontlist.insert(END, font)
          self.font_name.set(font_name)
          lc_fonts = [s.lower() for s in fonts]
          try:
              current_font_index = lc_fonts.index(font_name)
              self.fontlist.see(current_font_index)
              self.fontlist.select_set(current_font_index)
              self.fontlist.select_anchor(current_font_index)
              self.fontlist.activate(current_font_index)
          except ValueError:
              pass
          # Set font size dropdown.
          self.sizelist.SetMenu(('7', '8', '9', '10', '11', '12', '13', '14',
                                 '16', '18', '20', '22', '25', '29', '34', '40'),
                                font_size)
          # Set font weight.
          self.font_bold.set(font_bold)
          self.set_samples()
  
      def var_changed_font(self, *params):
          """Store changes to font attributes.
  
          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()
          changes.add_option('main', 'EditorWindow', 'font', value)
          value = self.font_size.get()
          changes.add_option('main', 'EditorWindow', 'font-size', value)
          value = self.font_bold.get()
          changes.add_option('main', 'EditorWindow', 'font-bold', value)
          self.set_samples()
  
      def on_fontlist_select(self, event):
          """Handle selecting a font from the list.
  
          Event can result from either mouse click or Up or Down key.
          Set font_name and example displays to selection.
          """
          font = self.fontlist.get(
                  ACTIVE if event.type.name == 'KeyRelease' else ANCHOR)
          self.font_name.set(font.lower())
  
      def set_samples(self, event=None):
          """Update update both screen samples with the font settings.
  
          Called on font initialization and change events.
          Accesses font_name, font_size, and font_bold Variables.
          Updates font_sample and highlight page highlight_sample.
          """
          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['font'] = new_font
          self.highlight_sample['font'] = new_font
  
      def load_tab_cfg(self):
          """Load current configuration settings for the tab options.
  
          Attributes updated:
              space_num: Set to value from idleConf.
          """
          # Set indent sizes.
          space_num = idleConf.GetOption(
              'main', 'Indent', 'num-spaces', default=4, type='int')
          self.space_num.set(space_num)
  
      def var_changed_space_num(self, *params):
          "Store change to indentation size."
          value = self.space_num.get()
          changes.add_option('main', 'Indent', 'num-spaces', value)
  
  
  class HighPage(Frame):
  
      def __init__(self, master):
          super().__init__(master)
          self.cd = master.master
          self.style = Style(master)
          self.create_page_highlight()
          self.load_theme_cfg()
  
      def create_page_highlight(self):
          """Return frame of widgets for Highlighting tab.
  
          Enable users to provisionally change foreground and background
          colors applied to textual tags.  Color mappings are stored in
          complete listings called themes.  Built-in themes in
          idlelib/config-highlight.def are fixed as far as the dialog is
          concerned. Any theme can be used as the base for a new custom
          theme, stored in .idlerc/config-highlight.cfg.
  
          Function load_theme_cfg() initializes tk variables and theme
          lists and calls paint_theme_sample() and set_highlight_target()
          for the current theme.  Radiobuttons builtin_theme_on and
          custom_theme_on toggle var theme_source, which controls if the
          current set of colors are from a builtin or custom theme.
          DynOptionMenus builtinlist and customlist contain lists of the
          builtin and custom themes, respectively, and the current item
          from each list is stored in vars builtin_name and custom_name.
  
          Function paint_theme_sample() applies the colors from the theme
          to the tags in text widget highlight_sample and then invokes
          set_color_sample().  Function set_highlight_target() sets the state
          of the radiobuttons fg_on and bg_on based on the tag and it also
          invokes set_color_sample().
  
          Function set_color_sample() sets the background color for the frame
          holding the color selector.  This provides a larger visual of the
          color for the current tag and plane (foreground/background).
  
          Note: set_color_sample() is called from many places and is often
          called more than once when a change is made.  It is invoked when
          foreground or background is selected (radiobuttons), from
          paint_theme_sample() (theme is changed or load_cfg is called), and
          from set_highlight_target() (target tag is changed or load_cfg called).
  
          Button delete_custom invokes delete_custom() to delete
          a custom theme from idleConf.userCfg['highlight'] and changes.
          Button save_custom invokes save_as_new_theme() which calls
          get_new_theme_name() and create_new() to save a custom theme
          and its colors to idleConf.userCfg['highlight'].
  
          Radiobuttons fg_on and bg_on toggle var fg_bg_toggle to control
          if the current selected color for a tag is for the foreground or
          background.
  
          DynOptionMenu targetlist contains a readable description of the
          tags applied to Python source within IDLE.  Selecting one of the
          tags from this list populates highlight_target, which has a callback
          function set_highlight_target().
  
          Text widget highlight_sample displays a block of text (which is
          mock Python code) in which is embedded the defined tags and reflects
          the color attributes of the current theme and changes for those tags.
          Mouse button 1 allows for selection of a tag and updates
          highlight_target with that tag value.
  
          Note: The font in highlight_sample is set through the config in
          the fonts tab.
  
          In other words, a tag can be selected either from targetlist or
          by clicking on the sample text within highlight_sample.  The
          plane (foreground/background) is selected via the radiobutton.
          Together, these two (tag and plane) control what color is
          shown in set_color_sample() for the current theme.  Button set_color
          invokes get_color() which displays a ColorChooser to change the
          color for the selected tag/plane.  If a new color is picked,
          it will be saved to changes and the highlight_sample and
          frame background will be updated.
  
          Tk Variables:
              color: Color of selected target.
              builtin_name: Menu variable for built-in theme.
              custom_name: Menu variable for custom theme.
              fg_bg_toggle: Toggle for foreground/background color.
                  Note: this has no callback.
              theme_source: Selector for built-in or custom theme.
              highlight_target: Menu variable for the highlight tag target.
  
          Instance Data Attributes:
              theme_elements: Dictionary of tags for text highlighting.
                  The key is the display name and the value is a tuple of
                  (tag name, display sort order).
  
          Methods [attachment]:
              load_theme_cfg: Load current highlight colors.
              get_color: Invoke colorchooser [button_set_color].
              set_color_sample_binding: Call set_color_sample [fg_bg_toggle].
              set_highlight_target: set fg_bg_toggle, set_color_sample().
              set_color_sample: Set frame background to target.
              on_new_color_set: Set new color and add option.
              paint_theme_sample: Recolor sample.
              get_new_theme_name: Get from popup.
              create_new: Combine theme with changes and save.
              save_as_new_theme: Save [button_save_custom].
              set_theme_type: Command for [theme_source].
              delete_custom: Activate default [button_delete_custom].
              save_new: Save to userCfg['theme'] (is function).
  
          Widgets of highlights page frame:  (*) widgets bound to self
              frame_custom: LabelFrame
                  (*)highlight_sample: Text
                  (*)frame_color_set: Frame
                      (*)button_set_color: Button
                      (*)targetlist: DynOptionMenu - highlight_target
                  frame_fg_bg_toggle: Frame
                      (*)fg_on: Radiobutton - fg_bg_toggle
                      (*)bg_on: Radiobutton - fg_bg_toggle
                  (*)button_save_custom: Button
              frame_theme: LabelFrame
                  theme_type_title: Label
                  (*)builtin_theme_on: Radiobutton - theme_source
                  (*)custom_theme_on: Radiobutton - theme_source
                  (*)builtinlist: DynOptionMenu - builtin_name
                  (*)customlist: DynOptionMenu - custom_name
                  (*)button_delete_custom: Button
                  (*)theme_message: Label
          """
          self.theme_elements = {
              'Normal Text': ('normal', '00'),
              'Code Context': ('context', '01'),
              'Python Keywords': ('keyword', '02'),
              'Python Definitions': ('definition', '03'),
              'Python Builtins': ('builtin', '04'),
              'Python Comments': ('comment', '05'),
              'Python Strings': ('string', '06'),
              'Selected Text': ('hilite', '07'),
              'Found Text': ('hit', '08'),
              'Cursor': ('cursor', '09'),
              'Editor Breakpoint': ('break', '10'),
              'Shell Normal Text': ('console', '11'),
              'Shell Error Text': ('error', '12'),
              'Shell Stdout Text': ('stdout', '13'),
              'Shell Stderr Text': ('stderr', '14'),
              }
          self.builtin_name = tracers.add(
                  StringVar(self), self.var_changed_builtin_name)
          self.custom_name = tracers.add(
                  StringVar(self), self.var_changed_custom_name)
          self.fg_bg_toggle = BooleanVar(self)
          self.color = tracers.add(
                  StringVar(self), self.var_changed_color)
          self.theme_source = tracers.add(
                  BooleanVar(self), self.var_changed_theme_source)
          self.highlight_target = tracers.add(
                  StringVar(self), self.var_changed_highlight_target)
  
          # Create widgets:
          # body frame and section frames.
          frame_custom = LabelFrame(self, borderwidth=2, relief=GROOVE,
                                    text=' Custom Highlighting ')
          frame_theme = LabelFrame(self, borderwidth=2, relief=GROOVE,
                                   text=' Highlighting Theme ')
          # frame_custom.
          text = self.highlight_sample = Text(
                  frame_custom, relief=SOLID, borderwidth=1,
                  font=('courier', 12, ''), cursor='hand2', width=21, height=13,
                  takefocus=FALSE, highlightthickness=0, wrap=NONE)
          text.bind('<Double-Button-1>', lambda e: 'break')
          text.bind('<B1-Motion>', lambda e: 'break')
          text_and_tags=(
              ('\n', 'normal'),
              ('#you can click here', 'comment'), ('\n', 'normal'),
              ('#to choose items', 'comment'), ('\n', 'normal'),
              ('code context section', 'context'), ('\n\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\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_top_level().highlight_target.set(elem)
                  self.highlight_target.set(elem)
              text.tag_bind(
                      self.theme_elements[element][0], '<ButtonPress-1>', tem)
          text['state'] = 'disabled'
          self.style.configure('frame_color_set.TFrame', borderwidth=1,
                               relief='solid')
          self.frame_color_set = Frame(frame_custom, style='frame_color_set.TFrame')
          frame_fg_bg_toggle = Frame(frame_custom)
          self.button_set_color = Button(
                  self.frame_color_set, text='Choose Color for :',
                  command=self.get_color)
          self.targetlist = DynOptionMenu(
                  self.frame_color_set, self.highlight_target, None,
                  highlightthickness=0) #, command=self.set_highlight_targetBinding
          self.fg_on = Radiobutton(
                  frame_fg_bg_toggle, variable=self.fg_bg_toggle, value=1,
                  text='Foreground', command=self.set_color_sample_binding)
          self.bg_on = Radiobutton(
                  frame_fg_bg_toggle, variable=self.fg_bg_toggle, value=0,
                  text='Background', command=self.set_color_sample_binding)
          self.fg_bg_toggle.set(1)
          self.button_save_custom = 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.builtin_theme_on = Radiobutton(
                  frame_theme, variable=self.theme_source, value=1,
                  command=self.set_theme_type, text='a Built-in Theme')
          self.custom_theme_on = Radiobutton(
                  frame_theme, variable=self.theme_source, value=0,
                  command=self.set_theme_type, text='a Custom Theme')
          self.builtinlist = DynOptionMenu(
                  frame_theme, self.builtin_name, None, command=None)
          self.customlist = DynOptionMenu(
                  frame_theme, self.custom_name, None, command=None)
          self.button_delete_custom = Button(
                  frame_theme, text='Delete Custom Theme',
                  command=self.delete_custom)
          self.theme_message = Label(frame_theme, borderwidth=2)
          # Pack widgets:
          # body.
          frame_custom.pack(side=LEFT, padx=5, pady=5, expand=TRUE, fill=BOTH)
          frame_theme.pack(side=TOP, padx=5, pady=5, fill=X)
          # frame_custom.
          self.frame_color_set.pack(side=TOP, padx=5, pady=5, expand=TRUE, fill=X)
          frame_fg_bg_toggle.pack(side=TOP, padx=5, pady=0)
          self.highlight_sample.pack(
                  side=TOP, padx=5, pady=5, expand=TRUE, fill=BOTH)
          self.button_set_color.pack(side=TOP, expand=TRUE, fill=X, padx=8, pady=4)
          self.targetlist.pack(side=TOP, expand=TRUE, fill=X, padx=8, pady=3)
          self.fg_on.pack(side=LEFT, anchor=E)
          self.bg_on.pack(side=RIGHT, anchor=W)
          self.button_save_custom.pack(side=BOTTOM, fill=X, padx=5, pady=5)
          # frame_theme.
          theme_type_title.pack(side=TOP, anchor=W, padx=5, pady=5)
          self.builtin_theme_on.pack(side=TOP, anchor=W, padx=5)
          self.custom_theme_on.pack(side=TOP, anchor=W, padx=5, pady=2)
          self.builtinlist.pack(side=TOP, fill=X, padx=5, pady=5)
          self.customlist.pack(side=TOP, fill=X, anchor=W, padx=5, pady=5)
          self.button_delete_custom.pack(side=TOP, fill=X, padx=5, pady=5)
          self.theme_message.pack(side=TOP, fill=X, pady=5)
  
      def load_theme_cfg(self):
          """Load current configuration settings for the theme options.
  
          Based on the theme_source toggle, the theme is set as
          either builtin or custom and the initial widget values
          reflect the current settings from idleConf.
  
          Attributes updated:
              theme_source: Set from idleConf.
              builtinlist: List of default themes from idleConf.
              customlist: List of custom themes from idleConf.
              custom_theme_on: Disabled if there are no custom themes.
              custom_theme: Message with additional information.
              targetlist: Create menu from self.theme_elements.
  
          Methods:
              set_theme_type
              paint_theme_sample
              set_highlight_target
          """
          # Set current theme type radiobutton.
          self.theme_source.set(idleConf.GetOption(
                  'main', 'Theme', 'default', type='bool', default=1))
          # Set current theme.
          current_option = idleConf.CurrentTheme()
          # Load available theme option menus.
          if self.theme_source.get():  # Default theme selected.
              item_list = idleConf.GetSectionList('default', 'highlight')
              item_list.sort()
              self.builtinlist.SetMenu(item_list, current_option)
              item_list = idleConf.GetSectionList('user', 'highlight')
              item_list.sort()
              if not item_list:
                  self.custom_theme_on.state(('disabled',))
                  self.custom_name.set('- no custom themes -')
              else:
                  self.customlist.SetMenu(item_list, item_list[0])
          else:  # User theme selected.
              item_list = idleConf.GetSectionList('user', 'highlight')
              item_list.sort()
              self.customlist.SetMenu(item_list, current_option)
              item_list = idleConf.GetSectionList('default', 'highlight')
              item_list.sort()
              self.builtinlist.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.targetlist.SetMenu(theme_names, theme_names[0])
          self.paint_theme_sample()
          self.set_highlight_target()
  
      def var_changed_builtin_name(self, *params):
          """Process new builtin theme selection.
  
          Add the changed theme's name to the changed_items and recreate
          the sample with the values from the selected theme.
          """
          old_themes = ('IDLE Classic', 'IDLE New')
          value = self.builtin_name.get()
          if value not in old_themes:
              if idleConf.GetOption('main', 'Theme', 'name') not in old_themes:
                  changes.add_option('main', 'Theme', 'name', old_themes[0])
              changes.add_option('main', 'Theme', 'name2', value)
              self.theme_message['text'] = 'New theme, see Help'
          else:
              changes.add_option('main', 'Theme', 'name', value)
              changes.add_option('main', 'Theme', 'name2', '')
              self.theme_message['text'] = ''
          self.paint_theme_sample()
  
      def var_changed_custom_name(self, *params):
          """Process new custom theme selection.
  
          If a new custom theme is selected, add the name to the
          changed_items and apply the theme to the sample.
          """
          value = self.custom_name.get()
          if value != '- no custom themes -':
              changes.add_option('main', 'Theme', 'name', value)
              self.paint_theme_sample()
  
      def var_changed_theme_source(self, *params):
          """Process toggle between builtin and custom theme.
  
          Update the default toggle value and apply the newly
          selected theme type.
          """
          value = self.theme_source.get()
          changes.add_option('main', 'Theme', 'default', value)
          if value:
              self.var_changed_builtin_name()
          else:
              self.var_changed_custom_name()
  
      def var_changed_color(self, *params):
          "Process change to color choice."
          self.on_new_color_set()
  
      def var_changed_highlight_target(self, *params):
          "Process selection of new target tag for highlighting."
          self.set_highlight_target()
  
      def set_theme_type(self):
          """Set available screen options based on builtin or custom theme.
  
          Attributes accessed:
              theme_source
  
          Attributes updated:
              builtinlist
              customlist
              button_delete_custom
              custom_theme_on
  
          Called from:
              handler for builtin_theme_on and custom_theme_on
              delete_custom
              create_new
              load_theme_cfg
          """
          if self.theme_source.get():
              self.builtinlist['state'] = 'normal'
              self.customlist['state'] = 'disabled'
              self.button_delete_custom.state(('disabled',))
          else:
              self.builtinlist['state'] = 'disabled'
              self.custom_theme_on.state(('!disabled',))
              self.customlist['state'] = 'normal'
              self.button_delete_custom.state(('!disabled',))
  
      def get_color(self):
          """Handle button to select a new color for the target tag.
  
          If a new color is selected while using a builtin theme, a
          name must be supplied to create a custom theme.
  
          Attributes accessed:
              highlight_target
              frame_color_set
              theme_source
  
          Attributes updated:
              color
  
          Methods:
              get_new_theme_name
              create_new
          """
          target = self.highlight_target.get()
          prev_color = self.style.lookup(self.frame_color_set['style'],
                                         'background')
          rgbTuplet, color_string = tkColorChooser.askcolor(
                  parent=self, title='Pick new color for : '+target,
                  initialcolor=prev_color)
          if color_string and (color_string != prev_color):
              # User didn't cancel and they chose a new color.
              if self.theme_source.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(new_theme)
                      self.color.set(color_string)
              else:  # Current theme is user defined.
                  self.color.set(color_string)
  
      def on_new_color_set(self):
          "Display sample of new color selection on the dialog."
          new_color = self.color.get()
          self.style.configure('frame_color_set.TFrame', background=new_color)
          plane = 'foreground' if self.fg_bg_toggle.get() else 'background'
          sample_element = self.theme_elements[self.highlight_target.get()][0]
          self.highlight_sample.tag_config(sample_element, **{plane: new_color})
          theme = self.custom_name.get()
          theme_element = sample_element + '-' + plane
          changes.add_option('highlight', theme, theme_element, new_color)
  
      def get_new_theme_name(self, message):
          "Return name of new theme from query popup."
          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):
          """Prompt for new theme name and create the theme.
  
          Methods:
              get_new_theme_name
              create_new
          """
          new_theme_name = self.get_new_theme_name('New Theme Name:')
          if new_theme_name:
              self.create_new(new_theme_name)
  
      def create_new(self, new_theme_name):
          """Create a new custom theme with the given name.
  
          Create the new theme based on the previously active theme
          with the current changes applied.  Once it is saved, then
          activate the new theme.
  
          Attributes accessed:
              builtin_name
              custom_name
  
          Attributes updated:
              customlist
              theme_source
  
          Method:
              save_new
              set_theme_type
          """
          if self.theme_source.get():
              theme_type = 'default'
              theme_name = self.builtin_name.get()
          else:
              theme_type = 'user'
              theme_name = self.custom_name.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 changes['highlight']:
              theme_changes = changes['highlight'][theme_name]
              for element in theme_changes:
                  new_theme[element] = theme_changes[element]
          # Save the new theme.
          self.save_new(new_theme_name, new_theme)
          # Change GUI over to the new theme.
          custom_theme_list = idleConf.GetSectionList('user', 'highlight')
          custom_theme_list.sort()
          self.customlist.SetMenu(custom_theme_list, new_theme_name)
          self.theme_source.set(0)
          self.set_theme_type()
  
      def set_highlight_target(self):
          """Set fg/bg toggle and color based on highlight tag target.
  
          Instance variables accessed:
              highlight_target
  
          Attributes updated:
              fg_on
              bg_on
              fg_bg_toggle
  
          Methods:
              set_color_sample
  
          Called from:
              var_changed_highlight_target
              load_theme_cfg
          """
          if self.highlight_target.get() == 'Cursor':  # bg not possible
              self.fg_on.state(('disabled',))
              self.bg_on.state(('disabled',))
              self.fg_bg_toggle.set(1)
          else:  # Both fg and bg can be set.
              self.fg_on.state(('!disabled',))
              self.bg_on.state(('!disabled',))
              self.fg_bg_toggle.set(1)
          self.set_color_sample()
  
      def set_color_sample_binding(self, *args):
          """Change color sample based on foreground/background toggle.
  
          Methods:
              set_color_sample
          """
          self.set_color_sample()
  
      def set_color_sample(self):
          """Set the color of the frame background to reflect the selected target.
  
          Instance variables accessed:
              theme_elements
              highlight_target
              fg_bg_toggle
              highlight_sample
  
          Attributes updated:
              frame_color_set
          """
          # Set the color sample area.
          tag = self.theme_elements[self.highlight_target.get()][0]
          plane = 'foreground' if self.fg_bg_toggle.get() else 'background'
          color = self.highlight_sample.tag_cget(tag, plane)
          self.style.configure('frame_color_set.TFrame', background=color)
  
      def paint_theme_sample(self):
          """Apply the theme colors to each element tag in the sample text.
  
          Instance attributes accessed:
              theme_elements
              theme_source
              builtin_name
              custom_name
  
          Attributes updated:
              highlight_sample: Set the tag elements to the theme.
  
          Methods:
              set_color_sample
  
          Called from:
              var_changed_builtin_name
              var_changed_custom_name
              load_theme_cfg
          """
          if self.theme_source.get():  # Default theme
              theme = self.builtin_name.get()
          else:  # User theme
              theme = self.custom_name.get()
          for element_title in self.theme_elements:
              element = self.theme_elements[element_title][0]
              colors = idleConf.GetHighlight(theme, element)
              if element == 'cursor':  # Cursor sample needs special painting.
                  colors['background'] = idleConf.GetHighlight(
                          theme, 'normal')['background']
              # Handle any unsaved changes to this theme.
              if theme in changes['highlight']:
                  theme_dict = changes['highlight'][theme]
                  if element + '-foreground' in theme_dict:
                      colors['foreground'] = theme_dict[element + '-foreground']
                  if element + '-background' in theme_dict:
                      colors['background'] = theme_dict[element + '-background']
              self.highlight_sample.tag_config(element, **colors)
          self.set_color_sample()
  
      def save_new(self, theme_name, theme):
          """Save a newly created theme to idleConf.
  
          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 askyesno(self, *args, **kwargs):
          # Make testing easier.  Could change implementation.
          return messagebox.askyesno(*args, **kwargs)
  
      def delete_custom(self):
          """Handle event to delete custom theme.
  
          The current theme is deactivated and the default theme is
          activated.  The custom theme is permanently removed from
          the config file.
  
          Attributes accessed:
              custom_name
  
          Attributes updated:
              custom_theme_on
              customlist
              theme_source
              builtin_name
  
          Methods:
              deactivate_current_config
              save_all_changed_extensions
              activate_config_changes
              set_theme_type
          """
          theme_name = self.custom_name.get()
          delmsg = 'Are you sure you wish to delete the theme %r ?'
          if not self.askyesno(
                  'Delete Theme',  delmsg % theme_name, parent=self):
              return
          self.cd.deactivate_current_config()
          # Remove theme from changes, config, and file.
          changes.delete_section('highlight', theme_name)
          # Reload user theme list.
          item_list = idleConf.GetSectionList('user', 'highlight')
          item_list.sort()
          if not item_list:
              self.custom_theme_on.state(('disabled',))
              self.customlist.SetMenu(item_list, '- no custom themes -')
          else:
              self.customlist.SetMenu(item_list, item_list[0])
          # Revert to default theme.
          self.theme_source.set(idleConf.defaultCfg['main'].Get('Theme', 'default'))
          self.builtin_name.set(idleConf.defaultCfg['main'].Get('Theme', 'name'))
          # User can't back out of these changes, they must be applied now.
          changes.save_all()
          self.cd.save_all_changed_extensions()
          self.cd.activate_config_changes()
          self.set_theme_type()
  
  
  class KeysPage(Frame):
  
      def __init__(self, master):
          super().__init__(master)
          self.cd = master.master
          self.create_page_keys()
          self.load_key_cfg()
  
      def create_page_keys(self):
          """Return frame of widgets for Keys tab.
  
          Enable users to provisionally change both individual and sets of
          keybindings (shortcut keys). Except for features implemented as
          extensions, keybindings are stored in complete sets called
          keysets. Built-in keysets in idlelib/config-keys.def are fixed
          as far as the dialog is concerned. Any keyset can be used as the
          base for a new custom keyset, stored in .idlerc/config-keys.cfg.
  
          Function load_key_cfg() initializes tk variables and keyset
          lists and calls load_keys_list for the current keyset.
          Radiobuttons builtin_keyset_on and custom_keyset_on toggle var
          keyset_source, which controls if the current set of keybindings
          are from a builtin or custom keyset. DynOptionMenus builtinlist
          and customlist contain lists of the builtin and custom keysets,
          respectively, and the current item from each list is stored in
          vars builtin_name and custom_name.
  
          Button delete_custom_keys invokes delete_custom_keys() to delete
          a custom keyset from idleConf.userCfg['keys'] and changes.  Button
          save_custom_keys invokes save_as_new_key_set() which calls
          get_new_keys_name() and create_new_key_set() to save a custom keyset
          and its keybindings to idleConf.userCfg['keys'].
  
          Listbox bindingslist contains all of the keybindings for the
          selected keyset.  The keybindings are loaded in load_keys_list()
          and are pairs of (event, [keys]) where keys can be a list
          of one or more key combinations to bind to the same event.
          Mouse button 1 click invokes on_bindingslist_select(), which
          allows button_new_keys to be clicked.
  
          So, an item is selected in listbindings, which activates
          button_new_keys, and clicking button_new_keys calls function
          get_new_keys().  Function get_new_keys() gets the key mappings from the
          current keyset for the binding event item that was selected.  The
          function then displays another dialog, GetKeysDialog, with the
          selected binding event and current keys and allows new key sequences
          to be entered for that binding event.  If the keys aren't
          changed, nothing happens.  If the keys are changed and the keyset
          is a builtin, function get_new_keys_name() will be called
          for input of a custom keyset name.  If no name is given, then the
          change to the keybinding will abort and no updates will be made.  If
          a custom name is entered in the prompt or if the current keyset was
          already custom (and thus didn't require a prompt), then
          idleConf.userCfg['keys'] is updated in function create_new_key_set()
          with the change to the event binding.  The item listing in bindingslist
          is updated with the new keys.  Var keybinding is also set which invokes
          the callback function, var_changed_keybinding, to add the change to
          the 'keys' or 'extensions' changes tracker based on the binding type.
  
          Tk Variables:
              keybinding: Action/key bindings.
  
          Methods:
              load_keys_list: Reload active set.
              create_new_key_set: Combine active keyset and changes.
              set_keys_type: Command for keyset_source.
              save_new_key_set: Save to idleConf.userCfg['keys'] (is function).
              deactivate_current_config: Remove keys bindings in editors.
  
          Widgets for KeysPage(frame):  (*) widgets bound to self
              frame_key_sets: LabelFrame
                  frames[0]: Frame
                      (*)builtin_keyset_on: Radiobutton - var keyset_source
                      (*)custom_keyset_on: Radiobutton - var keyset_source
                      (*)builtinlist: DynOptionMenu - var builtin_name,
                              func keybinding_selected
                      (*)customlist: DynOptionMenu - var custom_name,
                              func keybinding_selected
                      (*)keys_message: Label
                  frames[1]: Frame
                      (*)button_delete_custom_keys: Button - delete_custom_keys
                      (*)button_save_custom_keys: Button -  save_as_new_key_set
              frame_custom: LabelFrame
                  frame_target: Frame
                      target_title: Label
                      scroll_target_y: Scrollbar
                      scroll_target_x: Scrollbar
                      (*)bindingslist: ListBox - on_bindingslist_select
                      (*)button_new_keys: Button - get_new_keys & ..._name
          """
          self.builtin_name = tracers.add(
                  StringVar(self), self.var_changed_builtin_name)
          self.custom_name = tracers.add(
                  StringVar(self), self.var_changed_custom_name)
          self.keyset_source = tracers.add(
                  BooleanVar(self), self.var_changed_keyset_source)
          self.keybinding = tracers.add(
                  StringVar(self), self.var_changed_keybinding)
  
          # Create widgets:
          # body and section frames.
          frame_custom = LabelFrame(
                  self, borderwidth=2, relief=GROOVE,
                  text=' Custom Key Bindings ')
          frame_key_sets = LabelFrame(
                  self, 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.bindingslist = Listbox(
                  frame_target, takefocus=FALSE, exportselection=FALSE)
          self.bindingslist.bind('<ButtonRelease-1>',
                                 self.on_bindingslist_select)
          scroll_target_y['command'] = self.bindingslist.yview
          scroll_target_x['command'] = self.bindingslist.xview
          self.bindingslist['yscrollcommand'] = scroll_target_y.set
          self.bindingslist['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, padding=2, borderwidth=0)
                    for i in range(2)]
          self.builtin_keyset_on = Radiobutton(
                  frames[0], variable=self.keyset_source, value=1,
                  command=self.set_keys_type, text='Use a Built-in Key Set')
          self.custom_keyset_on = Radiobutton(
                  frames[0], variable=self.keyset_source, value=0,
                  command=self.set_keys_type, text='Use a Custom Key Set')
          self.builtinlist = DynOptionMenu(
                  frames[0], self.builtin_name, None, command=None)
          self.customlist = DynOptionMenu(
                  frames[0], self.custom_name, None, command=None)
          self.button_delete_custom_keys = Button(
                  frames[1], text='Delete Custom Key Set',
                  command=self.delete_custom_keys)
          self.button_save_custom_keys = Button(
                  frames[1], text='Save as New Custom Key Set',
                  command=self.save_as_new_key_set)
          self.keys_message = Label(frames[0], borderwidth=2)
  
          # Pack widgets:
          # 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.bindingslist.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.builtin_keyset_on.grid(row=0, column=0, sticky=W+NS)
          self.custom_keyset_on.grid(row=1, column=0, sticky=W+NS)
          self.builtinlist.grid(row=0, column=1, sticky=NSEW)
          self.customlist.grid(row=1, column=1, sticky=NSEW)
          self.keys_message.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)
          self.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)
  
      def load_key_cfg(self):
          "Load current configuration settings for the keybinding options."
          # Set current keys type radiobutton.
          self.keyset_source.set(idleConf.GetOption(
                  'main', 'Keys', 'default', type='bool', default=1))
          # Set current keys.
          current_option = idleConf.CurrentKeys()
          # Load available keyset option menus.
          if self.keyset_source.get():  # Default theme selected.
              item_list = idleConf.GetSectionList('default', 'keys')
              item_list.sort()
              self.builtinlist.SetMenu(item_list, current_option)
              item_list = idleConf.GetSectionList('user', 'keys')
              item_list.sort()
              if not item_list:
                  self.custom_keyset_on.state(('disabled',))
                  self.custom_name.set('- no custom keys -')
              else:
                  self.customlist.SetMenu(item_list, item_list[0])
          else:  # User key set selected.
              item_list = idleConf.GetSectionList('user', 'keys')
              item_list.sort()
              self.customlist.SetMenu(item_list, current_option)
              item_list = idleConf.GetSectionList('default', 'keys')
              item_list.sort()
              self.builtinlist.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 var_changed_builtin_name(self, *params):
          "Process selection of builtin key set."
          old_keys = (
              'IDLE Classic Windows',
              'IDLE Classic Unix',
              'IDLE Classic Mac',
              'IDLE Classic OSX',
          )
          value = self.builtin_name.get()
          if value not in old_keys:
              if idleConf.GetOption('main', 'Keys', 'name') not in old_keys:
                  changes.add_option('main', 'Keys', 'name', old_keys[0])
              changes.add_option('main', 'Keys', 'name2', value)
              self.keys_message['text'] = 'New key set, see Help'
          else:
              changes.add_option('main', 'Keys', 'name', value)
              changes.add_option('main', 'Keys', 'name2', '')
              self.keys_message['text'] = ''
          self.load_keys_list(value)
  
      def var_changed_custom_name(self, *params):
          "Process selection of custom key set."
          value = self.custom_name.get()
          if value != '- no custom keys -':
              changes.add_option('main', 'Keys', 'name', value)
              self.load_keys_list(value)
  
      def var_changed_keyset_source(self, *params):
          "Process toggle between builtin key set and custom key set."
          value = self.keyset_source.get()
          changes.add_option('main', 'Keys', 'default', value)
          if value:
              self.var_changed_builtin_name()
          else:
              self.var_changed_custom_name()
  
      def var_changed_keybinding(self, *params):
          "Store change to a keybinding."
          value = self.keybinding.get()
          key_set = self.custom_name.get()
          event = self.bindingslist.get(ANCHOR).split()[0]
          if idleConf.IsCoreBinding(event):
              changes.add_option('keys', key_set, event, value)
          else:  # Event is an extension binding.
              ext_name = idleConf.GetExtnNameForEvent(event)
              ext_keybind_section = ext_name + '_cfgBindings'
              changes.add_option('extensions', ext_keybind_section, event, value)
  
      def set_keys_type(self):
          "Set available screen options based on builtin or custom key set."
          if self.keyset_source.get():
              self.builtinlist['state'] = 'normal'
              self.customlist['state'] = 'disabled'
              self.button_delete_custom_keys.state(('disabled',))
          else:
              self.builtinlist['state'] = 'disabled'
              self.custom_keyset_on.state(('!disabled',))
              self.customlist['state'] = 'normal'
              self.button_delete_custom_keys.state(('!disabled',))
  
      def get_new_keys(self):
          """Handle event to change key binding for selected line.
  
          A selection of a key/binding in the list of current
          bindings pops up a dialog to enter a new binding.  If
          the current key set is builtin and a binding has
          changed, then a name for a custom key set needs to be
          entered for the change to be applied.
          """
          list_index = self.bindingslist.index(ANCHOR)
          binding = self.bindingslist.get(list_index)
          bind_name = binding.split()[0]
          if self.keyset_source.get():
              current_key_set_name = self.builtin_name.get()
          else:
              current_key_set_name = self.custom_name.get()
          current_bindings = idleConf.GetCurrentKeySet()
          if current_key_set_name in changes['keys']:  # unsaved changes
              key_set_changes = changes['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:
              if self.keyset_source.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.bindingslist.select_set(list_index)
                      self.bindingslist.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.bindingslist.delete(list_index)
              self.bindingslist.insert(list_index, bind_name+' - '+new_keys)
              self.bindingslist.select_set(list_index)
              self.bindingslist.select_anchor(list_index)
              self.keybinding.set(new_keys)
          else:
              self.bindingslist.select_set(list_index)
              self.bindingslist.select_anchor(list_index)
  
      def get_new_keys_name(self, message):
          "Return new key set name from query popup."
          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):
          "Prompt for name of new key set and save changes using that name."
          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 on_bindingslist_select(self, event):
          "Activate button to assign new keys to selected action."
          self.button_new_keys.state(('!disabled',))
  
      def create_new_key_set(self, new_key_set_name):
          """Create a new custom key set with the given name.
  
          Copy the bindings/keys from the previously active keyset
          to the new keyset and activate the new custom keyset.
          """
          if self.keyset_source.get():
              prev_key_set_name = self.builtin_name.get()
          else:
              prev_key_set_name = self.custom_name.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 changes['keys']:
              key_set_changes = changes['keys'][prev_key_set_name]
              for event in key_set_changes:
                  new_keys[event] = key_set_changes[event]
          # Save the new key set.
          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.customlist.SetMenu(custom_key_list, new_key_set_name)
          self.keyset_source.set(0)
          self.set_keys_type()
  
      def load_keys_list(self, keyset_name):
          """Reload the list of action/key binding pairs for the active key set.
  
          An action/key binding can be selected to change the key binding.
          """
          reselect = False
          if self.bindingslist.curselection():
              reselect = True
              list_index = self.bindingslist.index(ANCHOR)
          keyset = idleConf.GetKeySet(keyset_name)
          bind_names = list(keyset.keys())
          bind_names.sort()
          self.bindingslist.delete(0, END)
          for bind_name in bind_names:
              key = ' '.join(keyset[bind_name])
              bind_name = bind_name[2:-2]  # Trim off the angle brackets.
              if keyset_name in changes['keys']:
                  # Handle any unsaved changes to this key set.
                  if bind_name in changes['keys'][keyset_name]:
                      key = changes['keys'][keyset_name][bind_name]
              self.bindingslist.insert(END, bind_name+' - '+key)
          if reselect:
              self.bindingslist.see(list_index)
              self.bindingslist.select_set(list_index)
              self.bindingslist.select_anchor(list_index)
  
      @staticmethod
      def save_new_key_set(keyset_name, keyset):
          """Save a newly created core key set.
  
          Add keyset to idleConf.userCfg['keys'], not to disk.
          If the keyset doesn't exist, it is created.  The
          binding/keys are taken from the keyset argument.
  
          keyset_name - string, the name of the new key set
          keyset - dictionary containing the new keybindings
          """
          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 askyesno(self, *args, **kwargs):
          # Make testing easier.  Could change implementation.
          return messagebox.askyesno(*args, **kwargs)
  
      def delete_custom_keys(self):
          """Handle event to delete a custom key set.
  
          Applying the delete deactivates the current configuration and
          reverts to the default.  The custom key set is permanently
          deleted from the config file.
          """
          keyset_name = self.custom_name.get()
          delmsg = 'Are you sure you wish to delete the key set %r ?'
          if not self.askyesno(
                  'Delete Key Set',  delmsg % keyset_name, parent=self):
              return
          self.cd.deactivate_current_config()
          # Remove key set from changes, config, and file.
          changes.delete_section('keys', keyset_name)
          # Reload user key set list.
          item_list = idleConf.GetSectionList('user', 'keys')
          item_list.sort()
          if not item_list:
              self.custom_keyset_on.state(('disabled',))
              self.customlist.SetMenu(item_list, '- no custom keys -')
          else:
              self.customlist.SetMenu(item_list, item_list[0])
          # Revert to default key set.
          self.keyset_source.set(idleConf.defaultCfg['main']
                                 .Get('Keys', 'default'))
          self.builtin_name.set(idleConf.defaultCfg['main'].Get('Keys', 'name')
                                or idleConf.default_keys())
          # User can't back out of these changes, they must be applied now.
          changes.save_all()
          self.cd.save_all_changed_extensions()
          self.cd.activate_config_changes()
          self.set_keys_type()
  
  
  class GenPage(Frame):
  
      def __init__(self, master):
          super().__init__(master)
          self.create_page_general()
          self.load_general_cfg()
  
      def create_page_general(self):
          """Return frame of widgets for General tab.
  
          Enable users to provisionally change general options. Function
          load_general_cfg intializes tk variables and helplist using
          idleConf.  Radiobuttons startup_shell_on and startup_editor_on
          set var startup_edit. Radiobuttons save_ask_on and save_auto_on
          set var autosave. Entry boxes win_width_int and win_height_int
          set var win_width and win_height.  Setting var_name invokes the
          default callback that adds option to changes.
  
          Helplist: load_general_cfg loads list user_helplist with
          name, position pairs and copies names to listbox helplist.
          Clicking a name invokes help_source selected. Clicking
          button_helplist_name invokes helplist_item_name, which also
          changes user_helplist.  These functions all call
          set_add_delete_state. All but load call update_help_changes to
          rewrite changes['main']['HelpFiles'].
  
          Widgets for GenPage(Frame):  (*) widgets bound to self
              frame_window: LabelFrame
                  frame_run: Frame
                      startup_title: Label
                      (*)startup_editor_on: Radiobutton - startup_edit
                      (*)startup_shell_on: Radiobutton - startup_edit
                  frame_win_size: Frame
                      win_size_title: Label
                      win_width_title: Label
                      (*)win_width_int: Entry - win_width
                      win_height_title: Label
                      (*)win_height_int: Entry - win_height
                  frame_autocomplete: Frame
                      auto_wait_title: Label
                      (*)auto_wait_int: Entry - autocomplete_wait
                  frame_paren1: Frame
                      paren_style_title: Label
                      (*)paren_style_type: OptionMenu - paren_style
                  frame_paren2: Frame
                      paren_time_title: Label
                      (*)paren_flash_time: Entry - flash_delay
                      (*)bell_on: Checkbutton - paren_bell
              frame_editor: LabelFrame
                  frame_save: Frame
                      run_save_title: Label
                      (*)save_ask_on: Radiobutton - autosave
                      (*)save_auto_on: Radiobutton - autosave
                  frame_format: Frame
                      format_width_title: Label
                      (*)format_width_int: Entry - format_width
                  frame_context: Frame
                      context_title: Label
                      (*)context_int: Entry - context_lines
              frame_shell: LabelFrame
                  frame_auto_squeeze_min_lines: Frame
                      auto_squeeze_min_lines_title: Label
                      (*)auto_squeeze_min_lines_int: Entry - auto_squeeze_min_lines
              frame_help: LabelFrame
                  frame_helplist: Frame
                      frame_helplist_buttons: Frame
                          (*)button_helplist_edit
                          (*)button_helplist_add
                          (*)button_helplist_remove
                      (*)helplist: ListBox
                      scroll_helplist: Scrollbar
          """
          # Integer values need StringVar because int('') raises.
          self.startup_edit = tracers.add(
                  IntVar(self), ('main', 'General', 'editor-on-startup'))
          self.win_width = tracers.add(
                  StringVar(self), ('main', 'EditorWindow', 'width'))
          self.win_height = tracers.add(
                  StringVar(self), ('main', 'EditorWindow', 'height'))
          self.autocomplete_wait = tracers.add(
                  StringVar(self), ('extensions', 'AutoComplete', 'popupwait'))
          self.paren_style = tracers.add(
                  StringVar(self), ('extensions', 'ParenMatch', 'style'))
          self.flash_delay = tracers.add(
                  StringVar(self), ('extensions', 'ParenMatch', 'flash-delay'))
          self.paren_bell = tracers.add(
                  BooleanVar(self), ('extensions', 'ParenMatch', 'bell'))
  
          self.auto_squeeze_min_lines = tracers.add(
                  StringVar(self), ('main', 'PyShell', 'auto-squeeze-min-lines'))
  
          self.autosave = tracers.add(
                  IntVar(self), ('main', 'General', 'autosave'))
          self.format_width = tracers.add(
                  StringVar(self), ('extensions', 'FormatParagraph', 'max-width'))
          self.context_lines = tracers.add(
                  StringVar(self), ('extensions', 'CodeContext', 'maxlines'))
  
          # Create widgets:
          # Section frames.
          frame_window = LabelFrame(self, borderwidth=2, relief=GROOVE,
                                    text=' Window Preferences')
          frame_editor = LabelFrame(self, borderwidth=2, relief=GROOVE,
                                    text=' Editor Preferences')
          frame_shell = LabelFrame(self, borderwidth=2, relief=GROOVE,
                                   text=' Shell Preferences')
          frame_help = LabelFrame(self, borderwidth=2, relief=GROOVE,
                                  text=' Additional Help Sources ')
          # Frame_window.
          frame_run = Frame(frame_window, borderwidth=0)
          startup_title = Label(frame_run, text='At Startup')
          self.startup_editor_on = Radiobutton(
                  frame_run, variable=self.startup_edit, value=1,
                  text="Open Edit Window")
          self.startup_shell_on = Radiobutton(
                  frame_run, variable=self.startup_edit, value=0,
                  text='Open Shell Window')
  
          frame_win_size = Frame(frame_window, borderwidth=0)
          win_size_title = Label(
                  frame_win_size, text='Initial Window Size  (in characters)')
          win_width_title = Label(frame_win_size, text='Width')
          self.win_width_int = Entry(
                  frame_win_size, textvariable=self.win_width, width=3)
          win_height_title = Label(frame_win_size, text='Height')
          self.win_height_int = Entry(
                  frame_win_size, textvariable=self.win_height, width=3)
  
          frame_autocomplete = Frame(frame_window, borderwidth=0,)
          auto_wait_title = Label(frame_autocomplete,
                                 text='Completions Popup Wait (milliseconds)')
          self.auto_wait_int = Entry(frame_autocomplete, width=6,
                                     textvariable=self.autocomplete_wait)
  
          frame_paren1 = Frame(frame_window, borderwidth=0)
          paren_style_title = Label(frame_paren1, text='Paren Match Style')
          self.paren_style_type = OptionMenu(
                  frame_paren1, self.paren_style, 'expression',
                  "opener","parens","expression")
          frame_paren2 = Frame(frame_window, borderwidth=0)
          paren_time_title = Label(
                  frame_paren2, text='Time Match Displayed (milliseconds)\n'
                                    '(0 is until next input)')
          self.paren_flash_time = Entry(
                  frame_paren2, textvariable=self.flash_delay, width=6)
          self.bell_on = Checkbutton(
                  frame_paren2, text="Bell on Mismatch", variable=self.paren_bell)
  
          # Frame_editor.
          frame_save = Frame(frame_editor, borderwidth=0)
          run_save_title = Label(frame_save, text='At Start of Run (F5)  ')
          self.save_ask_on = Radiobutton(
                  frame_save, variable=self.autosave, value=0,
                  text="Prompt to Save")
          self.save_auto_on = Radiobutton(
                  frame_save, variable=self.autosave, value=1,
                  text='No Prompt')
  
          frame_format = Frame(frame_editor, borderwidth=0)
          format_width_title = Label(frame_format,
                                     text='Format Paragraph Max Width')
          self.format_width_int = Entry(
                  frame_format, textvariable=self.format_width, width=4)
  
          frame_context = Frame(frame_editor, borderwidth=0)
          context_title = Label(frame_context, text='Max Context Lines :')
          self.context_int = Entry(
                  frame_context, textvariable=self.context_lines, width=3)
  
          # Frame_shell.
          frame_auto_squeeze_min_lines = Frame(frame_shell, borderwidth=0)
          auto_squeeze_min_lines_title = Label(frame_auto_squeeze_min_lines,
                                               text='Auto-Squeeze Min. Lines:')
          self.auto_squeeze_min_lines_int = Entry(
              frame_auto_squeeze_min_lines, width=4,
              textvariable=self.auto_squeeze_min_lines)
  
          # frame_help.
          frame_helplist = Frame(frame_help)
          frame_helplist_buttons = Frame(frame_helplist)
          self.helplist = Listbox(
                  frame_helplist, height=5, takefocus=True,
                  exportselection=FALSE)
          scroll_helplist = Scrollbar(frame_helplist)
          scroll_helplist['command'] = self.helplist.yview
          self.helplist['yscrollcommand'] = scroll_helplist.set
          self.helplist.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)
  
          # Pack widgets:
          # Body.
          frame_window.pack(side=TOP, padx=5, pady=5, expand=TRUE, fill=BOTH)
          frame_editor.pack(side=TOP, padx=5, pady=5, expand=TRUE, fill=BOTH)
          frame_shell.pack(side=TOP, padx=5, pady=5, expand=TRUE, fill=BOTH)
          frame_help.pack(side=TOP, padx=5, pady=5, expand=TRUE, fill=BOTH)
          # frame_run.
          frame_run.pack(side=TOP, padx=5, pady=0, fill=X)
          startup_title.pack(side=LEFT, anchor=W, padx=5, pady=5)
          self.startup_shell_on.pack(side=RIGHT, anchor=W, padx=5, pady=5)
          self.startup_editor_on.pack(side=RIGHT, anchor=W, padx=5, pady=5)
          # frame_win_size.
          frame_win_size.pack(side=TOP, padx=5, pady=0, fill=X)
          win_size_title.pack(side=LEFT, anchor=W, padx=5, pady=5)
          self.win_height_int.pack(side=RIGHT, anchor=E, padx=10, pady=5)
          win_height_title.pack(side=RIGHT, anchor=E, pady=5)
          self.win_width_int.pack(side=RIGHT, anchor=E, padx=10, pady=5)
          win_width_title.pack(side=RIGHT, anchor=E, pady=5)
          # frame_autocomplete.
          frame_autocomplete.pack(side=TOP, padx=5, pady=0, fill=X)
          auto_wait_title.pack(side=LEFT, anchor=W, padx=5, pady=5)
          self.auto_wait_int.pack(side=TOP, padx=10, pady=5)
          # frame_paren.
          frame_paren1.pack(side=TOP, padx=5, pady=0, fill=X)
          paren_style_title.pack(side=LEFT, anchor=W, padx=5, pady=5)
          self.paren_style_type.pack(side=TOP, padx=10, pady=5)
          frame_paren2.pack(side=TOP, padx=5, pady=0, fill=X)
          paren_time_title.pack(side=LEFT, anchor=W, padx=5)
          self.bell_on.pack(side=RIGHT, anchor=E, padx=15, pady=5)
          self.paren_flash_time.pack(side=TOP, anchor=W, padx=15, pady=5)
  
          # frame_save.
          frame_save.pack(side=TOP, padx=5, pady=0, fill=X)
          run_save_title.pack(side=LEFT, anchor=W, padx=5, pady=5)
          self.save_auto_on.pack(side=RIGHT, anchor=W, padx=5, pady=5)
          self.save_ask_on.pack(side=RIGHT, anchor=W, padx=5, pady=5)
          # frame_format.
          frame_format.pack(side=TOP, padx=5, pady=0, fill=X)
          format_width_title.pack(side=LEFT, anchor=W, padx=5, pady=5)
          self.format_width_int.pack(side=TOP, padx=10, pady=5)
          # frame_context.
          frame_context.pack(side=TOP, padx=5, pady=0, fill=X)
          context_title.pack(side=LEFT, anchor=W, padx=5, pady=5)
          self.context_int.pack(side=TOP, padx=5, pady=5)
  
          # frame_auto_squeeze_min_lines
          frame_auto_squeeze_min_lines.pack(side=TOP, padx=5, pady=0, fill=X)
          auto_squeeze_min_lines_title.pack(side=LEFT, anchor=W, padx=5, pady=5)
          self.auto_squeeze_min_lines_int.pack(side=TOP, padx=5, 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.helplist.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)
  
      def load_general_cfg(self):
          "Load current configuration settings for the general options."
          # Set variables for all windows.
          self.startup_edit.set(idleConf.GetOption(
                  'main', 'General', 'editor-on-startup', type='bool'))
          self.win_width.set(idleConf.GetOption(
                  'main', 'EditorWindow', 'width', type='int'))
          self.win_height.set(idleConf.GetOption(
                  'main', 'EditorWindow', 'height', type='int'))
          self.autocomplete_wait.set(idleConf.GetOption(
                  'extensions', 'AutoComplete', 'popupwait', type='int'))
          self.paren_style.set(idleConf.GetOption(
                  'extensions', 'ParenMatch', 'style'))
          self.flash_delay.set(idleConf.GetOption(
                  'extensions', 'ParenMatch', 'flash-delay', type='int'))
          self.paren_bell.set(idleConf.GetOption(
                  'extensions', 'ParenMatch', 'bell'))
  
          # Set variables for editor windows.
          self.autosave.set(idleConf.GetOption(
                  'main', 'General', 'autosave', default=0, type='bool'))
          self.format_width.set(idleConf.GetOption(
                  'extensions', 'FormatParagraph', 'max-width', type='int'))
          self.context_lines.set(idleConf.GetOption(
                  'extensions', 'CodeContext', 'maxlines', type='int'))
  
          # Set variables for shell windows.
          self.auto_squeeze_min_lines.set(idleConf.GetOption(
                  'main', 'PyShell', 'auto-squeeze-min-lines', type='int'))
  
          # Set additional help sources.
          self.user_helplist = idleConf.GetAllExtraHelpSourcesList()
          self.helplist.delete(0, 'end')
          for help_item in self.user_helplist:
              self.helplist.insert(END, help_item[0])
          self.set_add_delete_state()
  
      def help_source_selected(self, event):
          "Handle event for selecting additional help."
          self.set_add_delete_state()
  
      def set_add_delete_state(self):
          "Toggle the state for the help list buttons based on list entries."
          if self.helplist.size() < 1:  # No entries in list.
              self.button_helplist_edit.state(('disabled',))
              self.button_helplist_remove.state(('disabled',))
          else:  # Some entries.
              if self.helplist.curselection():  # There currently is a selection.
                  self.button_helplist_edit.state(('!disabled',))
                  self.button_helplist_remove.state(('!disabled',))
              else:  # There currently is not a selection.
                  self.button_helplist_edit.state(('disabled',))
                  self.button_helplist_remove.state(('disabled',))
  
      def helplist_item_add(self):
          """Handle add button for the help list.
  
          Query for name and location of new help sources and add
          them to the list.
          """
          help_source = HelpSource(self, 'New Help Source').result
          if help_source:
              self.user_helplist.append(help_source)
              self.helplist.insert(END, help_source[0])
              self.update_help_changes()
  
      def helplist_item_edit(self):
          """Handle edit button for the help list.
  
          Query with existing help source information and update
          config if the values are changed.
          """
          item_index = self.helplist.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.helplist.delete(item_index)
              self.helplist.insert(item_index, new_help_source[0])
              self.update_help_changes()
              self.set_add_delete_state()  # Selected will be un-selected
  
      def helplist_item_remove(self):
          """Handle remove button for the help list.
  
          Delete the help list item from config.
          """
          item_index = self.helplist.index(ANCHOR)
          del(self.user_helplist[item_index])
          self.helplist.delete(item_index)
          self.update_help_changes()
          self.set_add_delete_state()
  
      def update_help_changes(self):
          "Clear and rebuild the HelpFiles section in changes"
          changes['main']['HelpFiles'] = {}
          for num in range(1, len(self.user_helplist) + 1):
              changes.add_option(
                      'main', 'HelpFiles', str(num),
                      ';'.join(self.user_helplist[num-1][:2]))
  
  
  class VarTrace:
      """Maintain Tk variables trace state."""
  
      def __init__(self):
          """Store Tk variables and callbacks.
  
          untraced: List of tuples (var, callback)
              that do not have the callback attached
              to the Tk var.
          traced: List of tuples (var, callback) where
              that callback has been attached to the var.
          """
          self.untraced = []
          self.traced = []
  
      def clear(self):
          "Clear lists (for tests)."
          # Call after all tests in a module to avoid memory leaks.
          self.untraced.clear()
          self.traced.clear()
  
      def add(self, var, callback):
          """Add (var, callback) tuple to untraced list.
  
          Args:
              var: Tk variable instance.
              callback: Either function name to be used as a callback
                  or a tuple with IdleConf config-type, section, and
                  option names used in the default callback.
  
          Return:
              Tk variable instance.
          """
          if isinstance(callback, tuple):
              callback = self.make_callback(var, callback)
          self.untraced.append((var, callback))
          return var
  
      @staticmethod
      def make_callback(var, config):
          "Return default callback function to add values to changes instance."
          def default_callback(*params):
              "Add config values to changes instance."
              changes.add_option(*config, var.get())
          return default_callback
  
      def attach(self):
          "Attach callback to all vars that are not traced."
          while self.untraced:
              var, callback = self.untraced.pop()
              var.trace_add('write', callback)
              self.traced.append((var, callback))
  
      def detach(self):
          "Remove callback from traced vars."
          while self.traced:
              var, callback = self.traced.pop()
              var.trace_remove('write', var.trace_info()[0][1])
              self.untraced.append((var, callback))
  
  
  tracers = VarTrace()
  
  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. [Cancel] only cancels changes made since the last save.
  '''
  help_pages = {
      'Fonts/Tabs':'''
  Font sample: This shows what a selection of Basic Multilingual Plane
  unicode characters look like for the current font selection.  If the
  selected font does not define a character, Tk attempts to find another
  font that does.  Substitute glyphs depend on what is available on a
  particular system and will not necessarily have the same size as the
  font selected.  Line contains 20 characters up to Devanagari, 14 for
  Tamil, and 10 for East Asia.
  
  Hebrew and Arabic letters should display right to left, starting with
  alef, \u05d0 and \u0627.  Arabic digits display left to right.  The
  Devanagari and Tamil lines start with digits.  The East Asian lines
  are Chinese digits, Chinese Hanzi, Korean Hangul, and Japanese
  Hiragana and Katakana.
  
  You can edit the font sample. Changes remain until IDLE is closed.
  ''',
      'Highlights': '''
  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.
  ''',
       'General': '''
  General:
  
  AutoComplete: Popupwait is milliseconds to wait after key char, without
  cursor movement, before popping up completion box.  Key char is '.' after
  identifier or a '/' (or '\\' on Windows) within a string.
  
  FormatParagraph: Max-width is max chars in lines after re-formatting.
  Use with paragraphs in both strings and comment blocks.
  
  ParenMatch: Style indicates what is highlighted when closer is entered:
  'opener' - opener '({[' corresponding to closer; 'parens' - both chars;
  'expression' (default) - also everything in between.  Flash-delay is how
  long to highlight if cursor is not moved (0 means forever).
  
  CodeContext: Maxlines is the maximum number of code context lines to
  display when Code Context is turned on for an editor window.
  
  Shell Preferences: Auto-Squeeze Min. Lines is the minimum number of lines
  of output to automatically "squeeze".
  '''
  }
  
  
  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, borderwidth=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__':
      from unittest import main
      main('idlelib.idle_test.test_configdialog', verbosity=2, exit=False)
  
      from idlelib.idle_test.htest import run
      run(ConfigDialog)
  