gui/menus.py

   1 import gtk
   2 import dialogs
   3
   4 class FigureMenu(object):
   5
   6     def __init__(self):
   7         self._store = None
   8
   9     def create_menu(self, store, figure, graph, app_exec):
  10         self._layout_to_str = {'horiz': 'Horizontal', 'vert':'Vertical',\
  11                                    'quad':'Quad'}
  12         self._store = store
  13         menu = gtk.Menu()
  14         if graph is None:
  15             item_nograph = gtk.MenuItem('No graph selected')
  16             menu.append(item_nograph)
  17             return menu
  18         item_figure = gtk.MenuItem('Figure')
  19         item_figure.set_submenu(self._create_figure_menu(figure, graph, app_exec))
  20         menu.append(item_figure)
  21         item_graph = gtk.MenuItem('Graph')
  22         item_graph.set_submenu(self._create_graph_menu(figure, graph, app_exec))
  23         menu.append(item_graph)
  24         return menu
  25
  26     def _create_figure_menu(self, fig, graph, app_exec):
  27         menu = gtk.Menu()
  28         item_add = gtk.MenuItem('Add graph')
  29         item_add.connect('activate', self._graph_menu_item_activated,
  30                          (fig, app_exec))
  31         menu.append(item_add)
  32         item_delete = gtk.MenuItem('Delete graph')
  33         item_delete.connect('activate', self._delete_graph_menu_item_activated,
  34                             (fig, graph, app_exec))
  35         menu.append(item_delete)
  36         item_layout = gtk.MenuItem('Layout')
  37         item_layout.set_submenu(self._create_layout_menu(fig, app_exec))
  38         menu.append(item_layout)
  39         return menu
  40
  41     def _graph_menu_item_activated(self, menuitem, user_data):
  42         fig, app_exec = user_data
  43         app_exec('add')
  44         fig.canvas.draw()
  45
  46     def _delete_graph_menu_item_activated(self, menuitem, user_data):
  47         figure, graph, app_exec = user_data
  48         if graph is not None:
  49             idx = figure.graphs.index(graph) + 1
  50             app_exec('delete %d' % idx)
  51             if figure.canvas is not None:
  52                 figure.canvas.draw()
  53
  54     def _create_layout_menu(self, fig, app_exec):
  55         menu = gtk.Menu()
  56         for layout in self._layout_to_str.keys():
  57             item = gtk.CheckMenuItem(self._layout_to_str[layout])
  58             item.set_active(fig.layout == layout)
  59             item.connect('activate', self._layout_menu_item_activated,
  60                          (fig, layout, app_exec))
  61             menu.append(item)
  62         return menu
  63
  64     def _layout_menu_item_activated(self, menuitem, user_data):
  65         fig, layout, app_exec = user_data
  66         app_exec('layout ' + layout)
  67         if fig.canvas is not None:
  68             fig.canvas.draw()
  69
  70     def _create_graph_menu(self, figure, graph, app_exec):
  71         graphmenu = GraphMenu()
  72         return graphmenu.create_graph_menu(self._store, figure, graph, app_exec)
  73
  74 class GraphMenu(object):
  75
  76     def __init__(self):
  77         self._store = None
  78         pass
  79
  80     def create_graph_menu(self, store, figure, graph, app_exec):
  81         self._scale_to_str = {'lin': 'Linear', 'logx': 'LogX', 'logy': 'LogY',\
  82                                   'loglog': 'Loglog'}
  83         self._store = store
  84         menu = gtk.Menu()
  85         item_range = gtk.MenuItem('Range...')
  86         item_range.connect('activate', self._range_menu_item_activated,
  87                            (figure, graph, app_exec))
  88         menu.append(item_range)
  89         item_units = gtk.MenuItem('Units...')
  90         item_units.connect('activate', self._units_menu_item_activated,
  91                            (figure, graph, app_exec))
  92         menu.append(item_units)
  93         item_scale = gtk.MenuItem('Scale')
  94         item_scale.set_submenu(self._create_scale_menu((figure, graph,
  95                                                         app_exec)))
  96         menu.append(item_scale)
  97         item_add = gtk.MenuItem('Insert signal')
  98         item_add.set_submenu(self._create_filename_menu((figure, graph,
  99                                                          app_exec)))
 100         menu.append(item_add)
 101         item_remove = gtk.MenuItem('Remove signal')
 102         item_remove.set_submenu(self._create_remove_signal_menu((figure, graph,
 103                                                                  app_exec)))
 104         menu.append(item_remove)
 105         return menu
 106
 107     def _create_units_window(self, figure, graph, app_exec):
 108         if graph is None:
 109             return
 110         unitdlg = dialogs.Enter_Units_Dialog()
 111         unitdlg.display(graph.unit, graph.axis_names, graph.scale_factors)
 112         units, scale_factors = unitdlg.run()
 113         if units:
 114             app_exec('unit %s' % ','.join(units))
 115             app_exec('factors %s,%s' % (scale_factors[0],scale_factors[1]))
 116             if figure.canvas is not None:
 117                 figure.canvas.draw()
 118
 119     def _units_menu_item_activated(self, menuitem, user_data):
 120         figure, graph, app_exec = user_data
 121         self._create_units_window(figure, graph, app_exec)
 122
 123     def _create_range_window(self, figure, graph, app_exec):
 124         if graph is None:
 125             return
 126         rangedlg = dialogs.Enter_Range_Dialog()
 127         rangedlg.display(graph.get_range(), graph.axis_names,
 128                          graph.scale_factors, graph.unit)
 129         r = rangedlg.run()
 130         if r:
 131             app_exec('range %s' % ' '.join(r))
 132             if figure.canvas is not None:
 133                 figure.canvas.draw()
 134
 135     def _range_menu_item_activated(self, menuitem, user_data):
 136         figure, graph, app_exec = user_data
 137         self._create_range_window(figure, graph, app_exec)
 138
 139     def _signals_menu_item_activated(self, menuitem, user_data):
 140         fig, graph, parent_it, it, app_exec = user_data
 141         name, sig = self._store.get(it, 0, 1)
 142         if not fig.graphs:
 143             app_exec('add %s' % name)
 144         else:
 145             if graph is not None:
 146                 app_exec('insert %s' % name)
 147         if fig.canvas is not None:
 148             fig.canvas.draw()
 149
 150     def _scale_menu_item_activated(self, menuitem, user_data):
 151         figure, graph, scale, app_exec = user_data
 152         app_exec('scale %s' % scale)
 153         if figure.canvas is not None:
 154             figure.canvas.draw()
 155
 156     def _remove_signal_menu_item_activated(self, menuitem, user_data):
 157         figure, graph, signals, app_exec = user_data
 158         if graph is None:
 159             return
 160         app_exec('remove %s' % ' '.join(signals.keys()))
 161         if figure.canvas is not None:
 162             figure.canvas.draw()
 163
 164     def _create_scale_menu(self, data):
 165         figure, graph, app_exec = data
 166         menu = gtk.Menu()
 167         for scale in self._scale_to_str.keys():
 168             item = gtk.CheckMenuItem(self._scale_to_str[scale])
 169             item.set_active(graph.scale == scale)
 170             item.connect('activate', self._scale_menu_item_activated,
 171                          (figure, graph, scale, app_exec))
 172             menu.append(item)
 173         return menu
 174
 175     def _create_remove_signal_menu(self, data):
 176         figure, graph, app_exec = data
 177         menu = gtk.Menu()
 178         if graph is None:
 179             item_nograph = gtk.MenuItem('No graph selected')
 180             menu.append(item_nograph)
 181             return menu
 182         for name, signal in graph.signals.iteritems():
 183             item = gtk.MenuItem(name)
 184             item.connect('activate', self._remove_signal_menu_item_activated,
 185                          (figure, graph, {name: signal}, app_exec))
 186             menu.append(item)
 187         return menu
 188
 189     def _create_signals_menu(self, fig, graph, parent_it, app_exec):
 190         menu = gtk.Menu()
 191         it = self._store.iter_children(parent_it)
 192         while it is not None:
 193             name = self._store.get_value(it, 0)
 194             item = gtk.MenuItem(name)
 195             item.connect('activate', self._signals_menu_item_activated,
 196                          (fig, graph, parent_it, it, app_exec))
 197             menu.append(item)
 198             it = self._store.iter_next(it)
 199         return menu
 200
 201     def _create_filename_menu(self, data):
 202         figure, graph, app_exec = data
 203         it = self._store.get_iter_root()
 204         if it is None:
 205             return gtk.Menu()
 206
 207         menu = gtk.Menu()
 208         while it is not None:
 209             filename = self._store.get_value(it, 0)
 210             item = gtk.MenuItem(filename)
 211             item.set_submenu(self._create_signals_menu(figure, graph, it,
 212                                                        app_exec))
 213             menu.append(item)
 214             it = self._store.iter_next(it)
 215         return menu
 216