git.gag.com Git - debian/gnuradio/blob - grc/gui/PropsDialog.py

   1 """
   2 Copyright 2007, 2008, 2009 Free Software Foundation, Inc.
   3 This file is part of GNU Radio
   4
   5 GNU Radio Companion is free software; you can redistribute it and/or
   6 modify it under the terms of the GNU General Public License
   7 as published by the Free Software Foundation; either version 2
   8 of the License, or (at your option) any later version.
   9
  10 GNU Radio Companion is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
  18 """
  19
  20 import pygtk
  21 pygtk.require('2.0')
  22 import gtk
  23
  24 from Dialogs import TextDisplay
  25 from Constants import MIN_DIALOG_WIDTH, MIN_DIALOG_HEIGHT
  26
  27 def get_title_label(title):
  28         """
  29         Get a title label for the params window.
  30         The title will be bold, underlined, and left justified.
  31         @param title the text of the title
  32         @return a gtk object
  33         """
  34         label = gtk.Label()
  35         label.set_markup('\n<b><span underline="low">%s</span>:</b>\n'%title)
  36         hbox = gtk.HBox()
  37         hbox.pack_start(label, False, False, padding=11)
  38         return hbox
  39
  40 class PropsDialog(gtk.Dialog):
  41         """
  42         A dialog to set block parameters, view errors, and view documentation.
  43         """
  44
  45         def __init__(self, block):
  46                 """
  47                 Properties dialog contructor.
  48                 @param block a block instance
  49                 """
  50                 self._hash = 0
  51                 LABEL_SPACING = 7
  52                 gtk.Dialog.__init__(self,
  53                         title='Properties: %s'%block.get_name(),
  54                         buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT, gtk.STOCK_OK, gtk.RESPONSE_ACCEPT),
  55                 )
  56                 self._block = block
  57                 self.set_size_request(MIN_DIALOG_WIDTH, MIN_DIALOG_HEIGHT)
  58                 vbox = gtk.VBox()
  59                 #Create the scrolled window to hold all the parameters
  60                 scrolled_window = gtk.ScrolledWindow()
  61                 scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
  62                 scrolled_window.add_with_viewport(vbox)
  63                 self.vbox.pack_start(scrolled_window, True)
  64                 #Params box for block parameters
  65                 self._params_box = gtk.VBox()
  66                 self._params_box.pack_start(get_title_label('Parameters'), False)
  67                 self._input_object_params = list()
  68                 #Error Messages for the block
  69                 self._error_box = gtk.VBox()
  70                 self._error_messages_text_display = TextDisplay()
  71                 self._error_box.pack_start(gtk.Label(), False, False, LABEL_SPACING)
  72                 self._error_box.pack_start(get_title_label('Error Messages'), False)
  73                 self._error_box.pack_start(self._error_messages_text_display, False)
  74                 #Docs for the block
  75                 self._docs_box = err_box = gtk.VBox()
  76                 self._docs_text_display = TextDisplay()
  77                 self._docs_box.pack_start(gtk.Label(), False, False, LABEL_SPACING)
  78                 self._docs_box.pack_start(get_title_label('Documentation'), False)
  79                 self._docs_box.pack_start(self._docs_text_display, False)
  80                 #Add the boxes
  81                 vbox.pack_start(self._params_box, False)
  82                 vbox.pack_start(self._error_box, False)
  83                 vbox.pack_start(self._docs_box, False)
  84                 #connect events
  85                 self.connect('key-press-event', self._handle_key_press)
  86                 self.connect('show', self._update_gui)
  87                 #show all (performs initial gui update)
  88                 self.show_all()
  89
  90         def _params_changed(self):
  91                 """
  92                 Have the params in this dialog changed?
  93                 Ex: Added, removed, type change, hide change...
  94                 To the props dialog, the hide setting of 'none' and 'part' are identical.
  95                 Therfore, the props dialog only cares if the hide setting is/not 'all'.
  96                 Make a hash that uniquely represents the params' state.
  97                 @return true if changed
  98                 """
  99                 old_hash = self._hash
 100                 #create a tuple of things from each param that affects the params box
 101                 self._hash = hash(tuple([(
 102                         hash(param), param.get_type(), param.get_hide() == 'all',
 103                 ) for param in self._block.get_params()]))
 104                 return self._hash != old_hash
 105
 106         def _handle_changed(self, *args):
 107                 """
 108                 A change occured within a param:
 109                 Rewrite/validate the block and update the gui.
 110                 """
 111                 #update for the block
 112                 self._block.rewrite()
 113                 self._block.validate()
 114                 self._update_gui()
 115
 116         def _update_gui(self, *args):
 117                 """
 118                 Repopulate the parameters box (if changed).
 119                 Update all the input parameters.
 120                 Update the error messages box.
 121                 Hide the box if there are no errors.
 122                 Update the documentation block.
 123                 Hide the box if there are no docs.
 124                 """
 125                 #update the params box
 126                 if self._params_changed():
 127                         #hide params box before changing
 128                         self._params_box.hide_all()
 129                         #empty the params box
 130                         for io_param in list(self._input_object_params):
 131                                 self._params_box.remove(io_param)
 132                                 self._input_object_params.remove(io_param)
 133                                 io_param.destroy()
 134                         #repopulate the params box
 135                         for param in self._block.get_params():
 136                                 if param.get_hide() == 'all': continue
 137                                 io_param = param.get_input(self._handle_changed)
 138                                 self._input_object_params.append(io_param)
 139                                 self._params_box.pack_start(io_param, False)
 140                         #show params box with new params
 141                         self._params_box.show_all()
 142                 #update the errors box
 143                 if self._block.is_valid(): self._error_box.hide()
 144                 else: self._error_box.show()
 145                 messages = '\n\n'.join(self._block.get_error_messages())
 146                 self._error_messages_text_display.set_text(messages)
 147                 #update the docs box
 148                 if self._block.get_doc(): self._docs_box.show()
 149                 else: self._docs_box.hide()
 150                 self._docs_text_display.set_text(self._block.get_doc())
 151
 152         def _handle_key_press(self, widget, event):
 153                 """
 154                 Handle key presses from the keyboard.
 155                 Call the ok response when enter is pressed.
 156                 @return false to forward the keypress
 157                 """
 158                 if event.keyval == gtk.keysyms.Return:
 159                         self.response(gtk.RESPONSE_ACCEPT)
 160                         return True #handled here
 161                 return False #forward the keypress
 162
 163         def run(self):
 164                 """
 165                 Run the dialog and get its response.
 166                 @return true if the response was accept
 167                 """
 168                 response = gtk.Dialog.run(self)
 169                 self.destroy()
 170                 return response == gtk.RESPONSE_ACCEPT