gui/dialogs.py

   1 import os
   2 import gtk
   3 import vte
   4 import pty
   5 import sys
   6 import readline
   7
   8 class Enter_Units_Dialog(object):
   9     def __init__(self):
  10         self._dlg = None
  11         self._entry_xunits = None
  12         self._entry_yunits = None
  13         pass
  14
  15     def display(self, units):
  16         self._dlg = gtk.Dialog('Enter graph units',
  17                                buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT,
  18                                         gtk.STOCK_OK, gtk.RESPONSE_ACCEPT))
  19         self._dlg.set_default_response(gtk.RESPONSE_ACCEPT)
  20         table = gtk.Table(2, 2, False)
  21         table.set_col_spacing(0, 12)
  22         table.set_col_spacing(1, 12)
  23         # Label and entry for X axis
  24         label_xunits = gtk.Label('X axis unit:')
  25         table.attach(label_xunits, 0, 1, 0, 1)
  26         self._entry_xunits = gtk.Entry()
  27         self._entry_xunits.set_text(units[0])
  28         table.attach(self._entry_xunits, 1, 2, 0, 1)
  29
  30         # Label and entry for Y axis
  31         label_yunits = gtk.Label('Y axis unit:')
  32         table.attach(label_yunits, 0, 1, 1, 2)
  33         self._entry_yunits = gtk.Entry()
  34         self._entry_yunits.set_text(units[1])
  35         table.attach(self._entry_yunits, 1, 2, 1, 2)
  36         self._dlg.vbox.pack_start(table)
  37         self._dlg.set_border_width(12)
  38
  39         self._dlg.show_all()
  40
  41     def run(self):
  42         units = ()
  43         resp = self._dlg.run()
  44         if resp == gtk.RESPONSE_ACCEPT:
  45             units = (self._entry_xunits.get_text(),
  46                      self._entry_yunits.get_text())
  47         self._dlg.destroy()
  48         return units
  49
  50 class Enter_Range_Dialog(object):
  51     def __init__(self):
  52         self._dlg = None
  53         self._entries = None
  54
  55     def display(self, r, xy, scale_factors, units):
  56         self._dlg = gtk.Dialog('Enter graph range',
  57                                flags=gtk.DIALOG_NO_SEPARATOR,
  58                                buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT,
  59                                         gtk.STOCK_OK, gtk.RESPONSE_ACCEPT))
  60         self._dlg.set_default_response(gtk.RESPONSE_ACCEPT)
  61
  62         self._entries = []
  63         minmax = ['From', 'To']
  64
  65         hbox = gtk.HBox(False)
  66         for col in range(0, 2):
  67             frame = gtk.Frame('')
  68             frame.get_label_widget().set_markup('<b>'+ xy[col] +'</b>')
  69             frame.set_shadow_type(gtk.SHADOW_NONE)
  70             table = gtk.Table(1, 3, False)
  71             entries_row = []
  72             for row in range(0, 2):
  73                 label = gtk.Label(minmax[row])
  74                 align_lbl = gtk.Alignment(0, 0.5)
  75                 align_lbl.add(label)
  76                 entry = gtk.Entry()
  77                 entry.set_text(str(r[col][row]))
  78                 entry.set_width_chars(7)
  79                 entry.set_activates_default(True)
  80                 units_label = gtk.Label(scale_factors[col] + units[col])
  81                 align_units = gtk.Alignment(0, 0.5)
  82                 align_units.add(units_label)
  83                 table.attach(align_lbl, 0, 1, row, row + 1, xpadding=3)
  84                 table.attach(entry, 1, 2, row, row + 1, xpadding=3)
  85                 table.attach(align_units, 2, 3, row, row + 1, xpadding=3)
  86                 table.set_row_spacing(row, 6)
  87                 entries_row.append(entry)
  88             self._entries.append(entries_row)
  89             box = gtk.HBox(False)
  90             box.pack_start(table, False, False, 12)
  91             frame.add(box)
  92             hbox.pack_start(frame, False, False, 0)
  93         self._dlg.vbox.pack_start(hbox, False, False, 6)
  94
  95         self._dlg.show_all()
  96
  97     def run(self):
  98         r = []
  99         resp = self._dlg.run()
 100         if resp == gtk.RESPONSE_ACCEPT:
 101             r = [self._entries[0][0].get_text(),
 102                  self._entries[0][1].get_text(),
 103                  self._entries[1][0].get_text(),
 104                  self._entries[1][1].get_text()]
 105         self._dlg.destroy()
 106         return r
 107
 108 class Run_Netlister_and_Simulate_Dialog:
 109     def __init__(self):
 110         self._dlg = None
 111         pass
 112
 113     def display(self, actions):
 114         # Define functions to enable/disable entries upon toggle buttons
 115         # make window a bit larger
 116         self._dlg = gtk.Dialog("Run netlister and simulate",
 117                                flags=gtk.DIALOG_NO_SEPARATOR,
 118                                buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT,
 119                                         gtk.STOCK_OK, gtk.RESPONSE_ACCEPT))
 120         self._dlg.set_default_response(gtk.RESPONSE_ACCEPT)
 121         frame = gtk.Frame('')
 122         frame.get_label_widget().set_markup('<b>Netlister</b>')
 123         frame.set_shadow_type(gtk.SHADOW_NONE)
 124         box = gtk.HBox()
 125         self._entry_netl = gtk.Entry()
 126         self._entry_netl.set_text(actions['run_netlister'][1])
 127         self._ckbutton_netl = gtk.CheckButton("Run")
 128         self._ckbutton_netl.set_active(actions['run_netlister'][0])
 129         self._ckbutton_netl.connect('toggled', self._check_button_toggled,
 130                                     self._entry_netl)
 131         self._entry_netl.set_editable(self._ckbutton_netl.get_active())
 132         box.pack_start(self._ckbutton_netl, False, False, 12)
 133         box.pack_start(self._entry_netl, True, True)
 134         frame.add(box)
 135         self._dlg.vbox.pack_start(frame, False, False, 6)
 136
 137         frame = gtk.Frame('')
 138         frame.get_label_widget().set_markup('<b>Simulator</b>')
 139         frame.set_shadow_type(gtk.SHADOW_NONE)
 140         box = gtk.HBox()
 141         self._entry_sim = gtk.Entry()
 142         self._entry_sim.set_text(actions['run_simulator'][1])
 143         self._ckbutton_sim = gtk.CheckButton('Run')
 144         self._ckbutton_sim.set_active(actions['run_simulator'][0])
 145         self._ckbutton_sim.connect('toggled', self._check_button_toggled,
 146                                    self._entry_sim)
 147         self._entry_sim.set_editable(self._ckbutton_sim.get_active())
 148         box.pack_start(self._ckbutton_sim, False, False, 12)
 149         box.pack_start(self._entry_sim, True, True)
 150         frame.add(box)
 151         self._dlg.vbox.pack_start(frame, False, False, 6)
 152
 153         frame = gtk.Frame('')
 154         frame.get_label_widget().set_markup('<b>Options</b>')
 155         frame.set_shadow_type(gtk.SHADOW_NONE)
 156         vbox = gtk.VBox()
 157         box = gtk.HBox(False, 12)
 158         label = gtk.Label()
 159         label.set_markup('Run from directory:')
 160         box.pack_start(label, False, False, 12)
 161         dialog = gtk.FileChooserDialog('Run netlister and simulator from directory...',
 162                                        None,
 163                                        gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER,
 164                                        buttons=(gtk.STOCK_CANCEL,
 165                                                 gtk.RESPONSE_REJECT,
 166                                                 gtk.STOCK_OK,
 167                                                 gtk.RESPONSE_ACCEPT))
 168         dialog.set_filename(actions['run_from'])
 169         self._filechoose = gtk.FileChooserButton(dialog)
 170         box.pack_start(self._filechoose)
 171         vbox.pack_start(box, False)
 172         box = gtk.HBox()
 173         self._ckbutton_upd = gtk.CheckButton('Update readers once terminated')
 174         self._ckbutton_upd.set_active(actions['update'])
 175         box.pack_start(self._ckbutton_upd, False, False, 12)
 176         vbox.pack_start(box, False)
 177         frame.add(vbox)
 178         self._dlg.vbox.pack_start(frame, False, False, 6)
 179
 180         self._dlg.resize(400, 100)
 181         self._dlg.show_all()
 182
 183     def run(self):
 184         resp = self._dlg.run()
 185         if resp == gtk.RESPONSE_ACCEPT:
 186             actions = {}
 187             actions['run_netlister'] = (self._ckbutton_netl.get_active(),
 188                                         self._entry_netl.get_text())
 189             actions['run_simulator'] = (self._ckbutton_sim.get_active(),
 190                                         self._entry_sim.get_text())
 191             actions['update'] = self._ckbutton_upd.get_active()
 192             actions['run_from'] = self._filechoose.get_filename()
 193             self._dlg.destroy()
 194             return actions
 195         else:
 196             self._dlg.destroy()
 197             return None
 198
 199     def _check_button_toggled(self, button, entry=None):
 200         if entry is not None:
 201             entry.set_editable(button.get_active())
 202
 203 class TerminalWindow:
 204     def __init__(self, prompt, intro, hist_file, app_exec):
 205         # History file
 206         self.hist_file = hist_file
 207
 208         # Readline configuration
 209         if not os.path.exists(self.hist_file):
 210             f = open(self.hist_file, "w")
 211             f.write("figlist")
 212             f.close()
 213         readline.read_history_file(self.hist_file)
 214
 215         self.prompt = prompt
 216         self.intro = intro
 217         self._term = None
 218         self._app_exec = app_exec
 219         self.is_there = False
 220         self._term_hist_item = readline.get_current_history_length() + 1
 221
 222     def create(self):
 223         cmdw = gtk.Window()
 224         if self._term is None:
 225             self._term = vte.Terminal()
 226             self._term.set_cursor_blinks(True)
 227             self._term.set_emulation('xterm')
 228             self._term.set_font_from_string('monospace 9')
 229             self._term.set_scrollback_lines(1000)
 230             self._term.show()
 231             (master, slave) = pty.openpty()
 232             self._term.set_pty(master)
 233             sys.stdout = os.fdopen(slave, "w")
 234             print self.intro
 235         scrollbar = gtk.VScrollbar()
 236         scrollbar.set_adjustment(self._term.get_adjustment())
 237
 238         termbox = gtk.HBox()
 239         termbox.pack_start(self._term)
 240         termbox.pack_start(scrollbar)
 241
 242         entrybox = gtk.HBox(False)
 243         label = gtk.Label('Command:')
 244         entry = gtk.Entry()
 245         entry.connect('activate', self._entry_activate)
 246         entry.connect('key-press-event', self._entry_key_pressed)
 247         entrybox.pack_start(label, False, False, 12)
 248         entrybox.pack_start(entry, True, True, 12)
 249
 250         box = gtk.VBox()
 251         box.pack_start(termbox)
 252         box.pack_start(entrybox)
 253
 254         cmdw.connect('destroy', self._destroy)
 255         cmdw.add(box)
 256         cmdw.show_all()
 257         self.is_there = True
 258
 259     def _destroy(self, data=None):
 260         self.is_there = False
 261         return False
 262
 263     def _entry_activate(self, entry, data=None):
 264         if isinstance(entry, gtk.Entry):
 265             line = entry.get_text()
 266             if line is not None:
 267                 print self.prompt + line
 268                 self._app_exec(line)
 269                 readline.add_history(line)
 270             self._term_hist_item = readline.get_current_history_length()
 271             entry.set_text('')
 272
 273     def _entry_key_pressed(self, entry, event):
 274         if gtk.gdk.keyval_name(event.keyval) == "Up":
 275             line = readline.get_history_item(self._term_hist_item - 1)
 276             if line is not None:
 277                 self._term_hist_item = self._term_hist_item - 1
 278                 entry.set_text(line)
 279             return True
 280         elif gtk.gdk.keyval_name(event.keyval) == "Down":
 281             line = readline.get_history_item(self._term_hist_item + 1)
 282             if line is not None:
 283                 self._term_hist_item = self._term_hist_item + 1
 284                 entry.set_text(line)
 285             return True
 286