Subversion Repositories or1k

# SrcBar

# Copyright 2001 Red Hat, Inc.

#

# This program is free software; you can redistribute it and/or modify it

# under the terms of the GNU General Public License (GPL) as published by

# the Free Software Foundation; either version 2 of the License, or (at

# your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# ----------------------------------------------------------------------

# Implements a menu and a toolbar that are attached to a source window.

#

#   PUBLIC ATTRIBUTES:

#

#

#   METHODS:

#

#     configure ....... used to change public attributes

#

#   PRIVATE METHODS

#

#   X11 OPTION DATABASE ATTRIBUTES

#

#

# ----------------------------------------------------------------------

class SrcBar {

  inherit itk::Widget GDBEventHandler

  # ------------------------------------------------------------------

  #  CONSTRUCTOR - create widget

  # ------------------------------------------------------------------

  constructor {src args} {

    set source $src

    # Load the images to be used in toolbar buttons

    _load_images

    _load_src_images

    # Create a menu widget for the Source Window

    set Menu [GDBMenuBar $itk_interior.menubar]

    # Fill it with the initial set of entries

    if {! [create_menu_items]} {

      destroy $this

    } else {

      # We do not pack the menu, but make it the menu of the toplevel window

      $Menu show

    }

    # Create a toolbar widget for the Source Window

    set Tool [GDBToolBar $itk_interior.toolbar]

    # Now create the Source Window initial set of toolbar buttons

    # First give the necessary info about each button and their position

    create_buttons

    # Then effectively create the tollbar widget

    $Tool show

    # Pack the toolbar

    pack $Tool -expand 1 -fill both

    # Set the srcbar's initial state

    enable_ui 2

    eval itk_initialize $args

    add_hook gdb_no_inferior_hook "$this enable_ui 2"

    add_hook gdb_trace_find_hook "$this handle_trace_find_hook"

  }

  # ------------------------------------------------------------------

  #  DESTRUCTOR - destroy window containing widget

  # ------------------------------------------------------------------

  destructor {

    global GDBSrcBar_state

    unset GDBSrcBar_state($this)

    remove_hook gdb_no_inferior_hook "$this enable_ui 2"

    remove_hook gdb_trace_find_hook "$this handle_trace_find_hook"

    #destroy $this

  }

  ####################################################################

  # The next set of functions create the common menu groupings that

  # are used in gdb menus.

  # Private.  Used at contruction time.

  # These were previously at the GDBToolBar...

  ####################################################################

  # ------------------------------------------------------------------

  #  METHOD:  create_menu_items - Add some menu items to the menubar.

  #                               Returns 1 if any items added.

  # ------------------------------------------------------------------

  private method create_menu_items {} {

    create_file_menu

    create_run_menu

    create_view_menu

    if {[pref get gdb/control_target]} {

      create_control_menu

    }

    if {[pref get gdb/mode]} {

      create_trace_menu

    }

    create_plugin_menu

    create_pref_menu

    create_help_menu

    return 1

  }

  # ------------------------------------------------------------------

  #  METHOD:  create_file_menu - Creates the standard file menu.

  # ------------------------------------------------------------------

  private method create_file_menu {} {

    global enable_external_editor tcl_platform

    $Menu add menubutton file "File" 0

    if {[info exists enable_external_editor] && $enable_external_editor} {

      $Menu add command None "Edit Source" \

        [code $source edit]

    }

    $Menu add command Other "Open..."  \

      "_open_file" -underline 0 -accelerator "Ctrl+O"

    $Menu add command Other "Close" \

      "_close_file" -underline 0 -accelerator "Ctrl+W"

    $Menu add command Other "Source..." \

      "source_file" -underline 0

    set sessions [session_list]

    if {[llength $sessions]} {

      $Menu add separator

      set i 1

      foreach item $sessions {

        $Menu add command Other "$i $item" \

          [list session_load $item] \

          -underline 0

        incr i

      }

    }

    $Menu add separator

    if {$tcl_platform(platform) == "windows"} {

      $Menu add command None "Page Setup..." \

        [format {

          set top %s

          ide_winprint page_setup -parent $top

        } [winfo toplevel [namespace tail $this]]] \

        -underline 8

    }

    $Menu add command None "Print Source..." \

      [code $source print] \

      -underline 0 -accelerator "Ctrl+P"

    $Menu add separator

    $Menu add command Other "Target Settings..." \

      "set_target_name" -underline 0

    $Menu add separator

    $Menu add command None "Exit" gdbtk_quit -underline 1

  }

  # ------------------------------------------------------------------

  #  METHOD:  create_run_menu - Creates the standard run menu,

  #  or reconfigures it if it already exists.

  # ------------------------------------------------------------------

  private method create_run_menu {} {

    if {![$Menu exists Run]} {

      set run_menu [$Menu add menubutton run "Run" 0]

    } else {

      set run_menu [$Menu clear Run]

    }

    set is_native [TargetSelection::native_debugging]

    # If we are on a Unix target, put in the attach options.  "ps" doesn't

    # give me the Windows PID yet, and the attach also seems flakey, so

    # I will hold off on the Windows implementation for now.

    if {$is_native} {

      if {[string compare $::tcl_platform(platform) windows] != 0} {

        $Menu add command Attach "Attach to process" \

          [code $this do_attach $run_menu] \

          -underline 0 -accelerator "Ctrl+A"

      }

    } else {

      $Menu add command Other "Connect to target" \

        "$this do_connect $run_menu" -underline 0

    }

    if {[pref get gdb/control_target]} {

      if {!$is_native} {

        $Menu add command Other "Download" Download::download_it \

          -underline 0 -accelerator "Ctrl+D"

      }

      $Menu add command Other "Run" [code $source inferior run] \

        -underline 0 -accelerator R

    }

    if {$is_native} {

      if {[string compare $::tcl_platform(platform) windows] != 0} {

        $Menu add command Detach "Detach" \

          [code $this do_detach $run_menu] \

          -underline 0 -state disabled

      }

    } else {

      $Menu add command Other "Disconnect"  \

        [code $this do_disconnect $run_menu] -underline 0 -state disabled

    }

    if {$is_native} {

      $Menu add separator

      $Menu add command Control "Kill" \

        [code $this do_kill $run_menu] \

        -underline 0 -state disabled

    }

    if { [pref get gdb/mode] } {

      $Menu add separator

      $Menu add command Other "Start collection" "$this do_tstop" \

        -underline 0 -accelerator "Ctrl+B"

      $Menu add command Other "Stop collection" "$this do_tstop" \

        -underline 0  -accelerator "Ctrl+E" -state disabled

    }

  }

  # ------------------------------------------------------------------

  #  METHOD:  create_view_menu - Creates the standard view menu

  # ------------------------------------------------------------------

  private method create_view_menu {} {

    $Menu add menubutton view "View" 0

    $Menu add command Other "Stack" {ManagedWin::open StackWin} \

      -underline 0 -accelerator "Ctrl+S"

    $Menu add command Other "Registers" {ManagedWin::open RegWin} \

      -underline 0 -accelerator "Ctrl+R"

    $Menu add command Other "Memory" {ManagedWin::open MemWin} \

      -underline 0 -accelerator "Ctrl+M"

    $Menu add command Other "Watch Expressions" \

      {ManagedWin::open WatchWin} \

      -underline 0 -accelerator "Ctrl+T"

    $Menu add command Other "Local Variables" \

      {ManagedWin::open LocalsWin} \

      -underline 0 -accelerator "Ctrl+L"

    if {[pref get gdb/control_target]} {

      $Menu add command Other "Breakpoints" \

        {ManagedWin::open BpWin -tracepoints 0} \

        -underline 0 -accelerator "Ctrl+B"

    }

    if {[pref get gdb/mode]} {

      $Menu add command Other "Tracepoints" \

        {ManagedWin::open BpWin -tracepoints 1} \

        -underline 0 -accelerator "Ctrl+T"

      $Menu add command Other "Tdump" {ManagedWin::open TdumpWin} \

        -underline 2 -accelerator "Ctrl+U"

    }

    $Menu add command Other "Console" {ManagedWin::open Console} \

      -underline 2 -accelerator "Ctrl+N"

    $Menu add command Other "Function Browser" \

      {ManagedWin::open BrowserWin} \

      -underline 1 -accelerator "Ctrl+F"

    $Menu add command Other "Thread List" \

      {ManagedWin::open ProcessWin} \

      -underline 0 -accelerator "Ctrl+H"

    if {[info exists ::env(GDBTK_DEBUG)] && $::env(GDBTK_DEBUG)} {

      $Menu add separator

      $Menu add command Other "Debug Window" \

        {ManagedWin::open DebugWin} \

        -underline 3 -accelerator "Ctrl+U"

    }

  }

  # ------------------------------------------------------------------

  #  METHOD:  create_control_menu - Creates the standard control menu

  # ------------------------------------------------------------------

  private method create_control_menu {} {

    $Menu add menubutton cntrl "Control" 0

    $Menu add command Control "Step" [code $source inferior step] \

      -underline 0 -accelerator S

    $Menu add command Control "Next" [code $source inferior next] \

      -underline 0 -accelerator N

    $Menu add command Control "Finish" \

      [code $source inferior finish] \

      -underline 0 -accelerator F

    $Menu add command Control "Continue" \

      [code $source inferior continue] \

      -underline 0 -accelerator C

    $Menu add separator

    $Menu add command Control "Step Asm Inst" \

      [code $source inferior stepi] \

      -underline 1 -accelerator S

    $Menu add command Control "Next Asm Inst" \

      [code $source inferior nexti] \

      -underline 1 -accelerator N

    # $Menu add separator

    # $Menu add command Other "Automatic Step" auto_step

  }

  # ------------------------------------------------------------------

  #  METHOD:  create_trace_menu - Creates the standard trace menu

  # ------------------------------------------------------------------

  private method create_trace_menu {} {

    $Menu add menubutton trace "Trace" 0

    $Menu add command Other "Save Trace Commands..." \

      "save_trace_commands" \

      -underline 0

    $Menu add separator

    $Menu add command Trace "Next Hit" {tfind_cmd tfind} \

      -underline 0 -accelerator N

    $Menu add command Trace "Previous Hit" {tfind_cmd "tfind -"} \

      -underline 0 -accelerator P

    $Menu add command Trace "First Hit" {tfind_cmd "tfind start"} \

      -underline 0 -accelerator F

    $Menu add command Trace "Next Line Hit" \

      {tfind_cmd "tfind line"} \

      -underline 5 -accelerator L

    $Menu add command Trace "Next Hit Here" \

      {tfind_cmd "tfind tracepoint"} \

      -underline 9 -accelerator H

    $Menu add separator

    $Menu add command Trace "Tfind Line..." \

      "ManagedWin::open TfindArgs -Type LN" \

      -underline 9 -accelerator E

    $Menu add command Trace "Tfind PC..." \

      "ManagedWin::open TfindArgs -Type PC" \

      -underline 7 -accelerator C

    $Menu add command Trace "Tfind Tracepoint..." \

      "ManagedWin::open TfindArgs -Type TP" \

      -underline 6 -accelerator T

    $Menu add command Trace "Tfind Frame..." \

      "ManagedWin::open TfindArgs -Type FR" \

      -underline 6 -accelerator F

  }

  # ------------------------------------------------------------------

  #  METHOD:  create_plugin_menu - Creates the optional plugin menu

  # ------------------------------------------------------------------

  private method create_plugin_menu {} {

    global gdb_plugins

    if {$gdb_plugins != ""} {

      $Menu add menubutton plugin "PlugIn" 4

      set plugins_available 0

      source [file join $gdb_plugins plugins.tcl]

      if {! $plugins_available} {

        # No plugins are available for this configuration,

        # so remove the menu

        debug "No plugins configured, go remove the PlugIn menu..."

        $Menu delete plugin

      }

    }

  }

  # ------------------------------------------------------------------

  #  METHOD:  create_pref_menu - Creates the standard preferences menu

  # ------------------------------------------------------------------

  private method create_pref_menu {} {

    $Menu add menubutton pref "Preferences" 0

    $Menu add command Other "Global..." \

      "ManagedWin::open GlobalPref -transient" -underline 0

    $Menu add command Other "Source..." \

      "ManagedWin::open SrcPref -transient" -underline 0

  }

  # ------------------------------------------------------------------

  #  METHOD:  create_help_menu - Creates the standard help menu

  # ------------------------------------------------------------------

  private method create_help_menu {} {

    $Menu add menubutton help "Help" 0

    $Menu add command Other "Help Topics" \

      {HtmlViewer::open_help index.html} \

      -underline 0

    $Menu add separator

    $Menu add command Other "About GDB..." \

      {ManagedWin::open About -transient} \

      -underline 0

  }

  ####################################################################

  # The next set of functions are the generic button groups that gdb uses.

  # Private.  Used at contruction time.

  # These were previously at the GDBToolBar...

  ####################################################################

  # ------------------------------------------------------------------

  #  METHOD:  create_buttons - Add some buttons to the toolbar.

  #                         Returns list of buttons in form acceptable

  #                         to standard_toolbar.

  # ------------------------------------------------------------------

  private  method create_buttons {} {

    global enable_external_editor

    $Tool add button stop None {} {}

    _set_runstop

    if {[pref get gdb/mode]} {

      $Tool add button tstop Control \

                         [list $this do_tstop] "Start Collection" \

                         -image Movie_on_img

      $Tool add button view Other [list $this set_control_mode 1] \

                         "Switch to Browse Mode" -image watch_movie_img

      $Tool add separator

    }

    if {[pref get gdb/control_target]} {

      create_control_buttons

      if {[pref get gdb/mode]} {

        create_trace_buttons 0

      }

    } elseif {[get pref gdb/mode]} {

      #

      # If we don't control the target, then we might as well

      # put a copy of the trace controls on the source window.

      #

      create_trace_buttons 1

   }

    $Tool add separator

    create_window_buttons

    # Random bits of obscurity...

    $Tool itembind reg    "ManagedWin::open RegWin -force"

    $Tool itembind mem    "ManagedWin::open MemWin -force"

    $Tool itembind watch  \

      "ManagedWin::open WatchWin -force"

    $Tool itembind vars   \

      "ManagedWin::open LocalsWin -force"

    $Tool add separator

    if {[info exists enable_external_editor] && $enable_external_editor} {

      $Tool add button edit Other [code $source edit] "Edit Source" \

                              -image edit_img

      $Tool add separator

    }

    $Tool add label addr $address "Address" -width 10 -relief sunken \

                           -bd 1 -anchor e -font  src-font

    $Tool add label line $line "Line Number" -width 6 -relief sunken \

                           -bd 1 -anchor e -font  src-font

    $Tool toolbar_button_right_justify

    create_stack_buttons

    # This feature has been disabled for now.

    # checkbutton $ButtonFrame.upd -command "$this _toggle_updates" \

    #   -variable GDBSrcBar_state($this)

    # lappend button_list $ButtonFrame.upd

    # global GDBSrcBar_state

    # ::set GDBSrcBar_state($this) $updatevalue

    # balloon register $ButtonFrame.upd "Toggle Window Updates"

  }

  # ------------------------------------------------------------------

  #  METHOD:  create_control_buttons - Creates the step, continue, etc buttons.

  # ------------------------------------------------------------------

  private method create_control_buttons {} {

    $Tool add button step Control [code $source inferior step] \

      "Step (S)" -image step_img

    $Tool add button next Control [code $source inferior next] \

      "Next (N)" -image next_img

    $Tool add button finish Control [code $source inferior finish] \

      "Finish (F)" -image finish_img

    $Tool add button continue Control [code $source inferior continue] \

      "Continue (C)" -image continue_img

    # A spacer before the assembly-level items looks good.  It helps

    # to indicate that these are somehow different.

    $Tool add separator

    $Tool add button stepi Control [code $source inferior stepi] \

      "Step Asm Inst (S)" -image stepi_img

    $Tool add button nexti Control [code $source inferior nexti] \

      "Next Asm Inst (N)" -image nexti_img

    _set_stepi

    set Run_control_buttons {step next finish continue -stepi nexti}

  }

  # ------------------------------------------------------------------

  #  METHOD:  create_trace_buttons - Creates the next hit, etc.

  # ------------------------------------------------------------------

  private method create_trace_buttons {{show 0}} {

    if {$show} {

      set command $Tool add button

    } else {

      set command $Tool create

    }

    $command tfindstart Trace {tfind_cmd "tfind start"} "First Hit " \

      -image rewind_img

    $command tfind Trace {tfind_cmd tfind} "Next Hit " -image next_hit_img

    $command tfindprev Trace {tfind_cmd "tfind -"} "Previous Hit 
" \

      -image prev_hit_img

    $command tfindline Trace {tfind_cmd "tfind line"} "Next Line Hit " \

      -image next_line_img

    $command tfindtp Trace { tfind_cmd "tfind tracepoint"} \

      "Next Hit Here " -image next_check_img

    set Trace_control_buttons {tfindstart tfind tfindprev tfindline tfindtp}

  }

  # ------------------------------------------------------------------

  #  METHOD:  create_window_buttons - Creates the registers, etc, buttons

  # ------------------------------------------------------------------

  private method create_window_buttons {} {

    $Tool add button reg Other {ManagedWin::open RegWin} \

                           "Registers (Ctrl+R)" -image reg_img

    $Tool add button mem Other {ManagedWin::open MemWin} \

                           "Memory (Ctrl+M)" -image memory_img

    $Tool add button stack Other {ManagedWin::open StackWin} \

                             "Stack (Ctrl+S)" -image stack_img

    $Tool add button watch Other {ManagedWin::open WatchWin} \

                             "Watch Expressions (Ctrl+W)" -image watch_img

    $Tool add button vars Other {ManagedWin::open LocalsWin} \

                            "Local Variables (Ctrl+L)" -image vars_img

    if {[pref get gdb/control_target]} {

      $Tool add button bp Other {ManagedWin::open BpWin} \

                            "Breakpoints (Ctrl+B)" -image bp_img

    }

    if {[pref get gdb/mode]} {

      $Tool add button tp Other \

        {ManagedWin::open BpWin -tracepoints 1} \

        "Tracepoints (Ctrl+T)" -image tp_img

      $Tool add button tdump Trace {ManagedWin::open TdumpWin} \

                               "Tdump (Ctrl+D)" -image tdump_img

    }

    $Tool add button con Other {ManagedWin::open Console} \

                           "Console (Ctrl+N)" -image console_img

  }

  # ------------------------------------------------------------------

  #  METHOD:  create_stack_buttons - Creates the up down bottom stack buttons

  # ------------------------------------------------------------------

  private method create_stack_buttons {} {

    $Tool add button down {Trace Control} \

      [code $source stack down] \

      "Down Stack Frame" -image down_img

    $Tool add button up {Trace Control} \

      [code $source stack up] \

      "Up Stack Frame" -image up_img

    $Tool add button bottom {Trace Control} \

      [code $source stack bottom] \

      "Go to Bottom of Stack" -image bottom_img

  }

  ####################################################################

  #

  # Auxiliary methods used by the toolbar

  #

  ####################################################################

  # ------------------------------------------------------------------

  #  METHOD:  _load_images - Load standard images.  Private method.

  # ------------------------------------------------------------------

  public method _load_images { {reconfig 0} } {

    global gdb_ImageDir

    if {!$reconfig && $_loaded_images} {

      return

    }

    set _loaded_images 1

    lappend imgs console reg stack vmake vars watch memory bp

    foreach name $imgs {

      image create photo ${name}_img -file [file join $gdb_ImageDir ${name}.gif]

    }

  }

  # ------------------------------------------------------------------

  #  METHOD:  _load_src_images - Load standard images.  Private method.

  # ------------------------------------------------------------------

  method _load_src_images { {reconf 0} } {

    global gdb_ImageDir

    if {!$reconf && $_loaded_src_images} {

      return

    }

    set _loaded_src_images 1

    foreach name {run stop step next finish continue edit \

                    stepi nexti up down bottom Movie_on Movie_off \

                    next_line next_check next_hit rewind prev_hit \

                  watch_movie run_expt tdump tp} {

      image create photo ${name}_img -file [file join $gdb_ImageDir ${name}.gif]

    }

  }

  # ------------------------------------------------------------------

  #  METHOD:  _set_runstop - Set state of run/stop button.

  #

  #  busy        - Run button becomes disabled

  #  running     - Stop button appears, allowing user to stop executing target

  #  downloading - Stop button appears, allowing user to interrupt downloading

  #  normal      - Run button appears, allowing user to run/re-run exe

  # ------------------------------------------------------------------

  public method _set_runstop {} {

    dbug I $runstop

    switch $runstop {

      busy {

        $Tool itemconfigure stop -state disabled

      }

      downloading {

        $Tool itemconfigure stop -state normal -image stop_img \

          -command [code $this cancel_download]

        $Tool itemballoon stop "Stop"

      }

      running {

        $Tool itemconfigure stop -state normal -image stop_img \

          -command [code $source inferior stop]

        $Tool itemballoon stop "Stop"

      }

      normal {

        $Tool itemconfigure stop -state normal -image run_img \

          -command [code $source inferior run]

        $Tool itemballoon stop "Run (R)"

      }

      default {

        dbug W "unknown state $runstop"

      }

    }

  }

  # ------------------------------------------------------------------

  #  METHOD:  _set_stepi - Set state of stepi/nexti buttons.

  # ------------------------------------------------------------------

  public method _set_stepi {} {

    # Only do this in synchronous mode

    if {!$Tracing} {

      # In source-only mode, disable these buttons.  Otherwise, enable

      # them.

      if {$displaymode == "SOURCE"} {

        set state disabled

      } else {

        set state normal

      }

      $Tool itemconfigure stepi -state $state

      $Tool itemconfigure nexti -state $state

    }

  }

  ####################################################################

  #

  # State control methods used by both the menu and the toolbar

  #

  ####################################################################

  # ------------------------------------------------------------------

  #  METHOD:  handle_trace_find_hook - response to the tfind command.

  #             If the command puts us in a new mode, then switch modes...

  # ------------------------------------------------------------------

  method handle_trace_find_hook {mode from_tty} {

    debug "mode: $mode, from_tty: $from_tty, Browsing: $Browsing"

    if {[string compare $mode -1] == 0} {

      if {$Browsing} {

        set_control_mode 0

      }

    } else {

      if {!$Browsing} {

        set_control_mode 1

      }

    }

  }

  # ------------------------------------------------------------------

  #  METHOD:  set_control_mode - sets up the srcbar for browsing

  #  a trace experiment.

  #   mode: 1 => browse mode

  #         0 => control mode

  # ------------------------------------------------------------------

  method set_control_mode  {mode} {

    debug "set_control_mode called with mode $mode"

    if {$mode} {

      set Browsing 1

      $Tool itemconfigure view -image run_expt_img \

                            -command "$this set_control_mode 0"

      $Tool itemballoon view "Switch to Control mode"

      # Now swap out the buttons...

      $Tool toolbar_swap_button_lists $Trace_control_buttons \

                                      $Run_control_buttons

      enable_ui 1

    } else {

      if {$Browsing} {

        tfind_cmd {tfind none}

      }

      set Browsing 0

      $Tool itemconfigure view -image watch_movie_img \

                            -command "$this set_control_mode 1"

      $Tool itemballoon view "Switch to Browse mode"

      # Now swap out the buttons...

      $Tool toolbar_swap_button_lists $Run_control_buttons \

                                      $Trace_control_buttons

      enable_ui 1

    }

  }

  # ------------------------------------------------------------------

  #  METHOD:  reconfig - reconfigure the srcbar

  #                      used when preferences change

  # ------------------------------------------------------------------

  public method reconfig {} {

    debug

    _load_src_images 1

    _load_images 1

    # FIXME: Must Check if we are Tracing and set the buttons accordingly.

  }

  # ------------------------------------------------------------------

  #  METHOD:  set_variable - run when user enters a `set' command.

  #

  #  FIXME: Should not be accessing the base class internal data

  #         As the spec says, one must clear the menu and recreate it.

  # ------------------------------------------------------------------

  public method set_variable {event} {

    set varname [$event get variable]

    set value   [$event get value]

    debug "Got $varname = $value"

    if {$varname == "os"} {

      # Make current_menu pointer point to the View Menu.

      # FIXME: Should not be accessing the base class internal data directly

      set view_menu [menu_find View]

      # Restore the current_menu pointer.

      set save_menu [$Menu menubar_set_current_menu $view_menu]

      set title "Kernel Objects"

      # Look for the KOD menu entry...

      if {[catch {$view_menu index $title} index]} {

        set index none

      }

      # FIXME: This assumes that the KOD menu is the last one as it does not

      # adjust the index information kept by the GDBMenuBar class.

      if {$value == ""} {

        # No OS, so remove KOD from View menu.

        if {$index != "none"} {

          # FIXME: Should not be accessing the base class internal data

          $view_menu delete $index

        }

      } else {

        # Add KOD to View menu, but only if it isn't already there.

        if {$index == "none"} {

          $Menu add command Other $title \

            {ManagedWin::open KodWin} \

            -underline 0 -accelerator "Ctrl+K"

        }

      }

      # Restore the current_menu pointer.

      $Menu menubar_set_current_menu $save_menu

      global gdb_kod_cmd

      set gdb_kod_cmd $value

    }

  }

  ####################################################################

  # The following method enables/disables both menus and buttons.

  ####################################################################

  # ------------------------------------------------------------------

  # METHOD:  enable_ui - enable/disable the appropriate buttons and menus

  # Called from the busy, idle, and no_inferior hooks.

  #

  # on must be:

  # value      Control    Other    Trace    State

  #   0          off       off      off     gdb is busy

  #   1          on        on       off     gdb has inferior, and is idle

  #   2          off       on       off     gdb has no inferior, and is idle

  # ------------------------------------------------------------------

  public method enable_ui {on} {

    global tcl_platform

    debug "$on - Browsing=$Browsing"

    # Do the enabling so that all the disabling happens first, this way if a

    # button belongs to two groups, enabling takes precedence, which is

    #  probably right.

    switch $on {

        # Busy

        set enable_list {Control disabled \

                           Other disabled \

                           Trace disabled \

                           Attach disabled \

                           Detach disabled}

      }

      1 {

        # Idle, with inferior

        if {!$Browsing} {

          set enable_list {Trace disabled \

                             Control normal \

                             Other normal \

                             Attach disabled \

                             Detach normal }

          # set the states of stepi and nexti correctly

          _set_stepi

        } else {

          set enable_list {Control disabled Other normal Trace normal}

        }

      }

      2 {

        # Idle, no inferior

        set enable_list {Control disabled \

                           Trace disabled \

                           Other normal \

                           Attach normal \

                           Detach disabled }

      }

      default {

        debug "Unknown type: $on in enable_ui"

        return

      }

    }

    $Menu set_class_state $enable_list

    $Tool set_class_state $enable_list

  }

  ####################################################################

  #

  # Execute actions corresponding to menu events

  #

  ####################################################################

  # ------------------------------------------------------------------

  # METHOD:  do_attach: attach to a running target

  # ------------------------------------------------------------------

  method do_attach {menu} {

      gdbtk_attach_native

  }

  # ------------------------------------------------------------------

  # METHOD:  do_detach: detach from a running target

  # ------------------------------------------------------------------

  method do_detach {menu} {

    gdbtk_disconnect

    gdbtk_idle