def __init__(self, block):
"""
Properties dialog constructor.
Args:
block: a block instance
"""
self._hash = 0
gtk.Dialog.__init__(
self,
title='Properties: %s' % block.get_name(),
buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT, gtk.STOCK_OK,
gtk.RESPONSE_ACCEPT),
)
self._block = block
self.set_size_request(MIN_DIALOG_WIDTH, MIN_DIALOG_HEIGHT)
vpaned = gtk.VPaned()
self.vbox.pack_start(vpaned)
# Notebook to hold param boxes
notebook = gtk.Notebook()
notebook.set_show_border(False)
notebook.set_scrollable(True) # scroll arrows for page tabs
notebook.set_tab_pos(gtk.POS_TOP)
vpaned.pack1(notebook, True)
# Params boxes for block parameters
self._params_boxes = list()
for tab in block.get_param_tab_labels():
label = gtk.Label()
vbox = gtk.VBox()
scroll_box = gtk.ScrolledWindow()
scroll_box.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scroll_box.add_with_viewport(vbox)
notebook.append_page(scroll_box, label)
self._params_boxes.append((tab, label, vbox))
# Docs for the block
self._docs_text_display = TextDisplay()
self._docs_box = gtk.ScrolledWindow()
self._docs_box.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self._docs_box.add_with_viewport(self._docs_text_display)
notebook.append_page(self._docs_box, gtk.Label("Documentation"))
# Error Messages for the block
self._error_messages_text_display = TextDisplay()
self._error_box = gtk.ScrolledWindow()
self._error_box.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self._error_box.add_with_viewport(self._error_messages_text_display)
vpaned.pack2(self._error_box)
vpaned.set_position(int(0.65 * MIN_DIALOG_HEIGHT))
# Connect events
self.connect('key-press-event', self._handle_key_press)
self.connect('show', self._update_gui)
self.show_all() # show all (performs initial gui update)
def __init__(self, platform, action_handler_callback):
"""
MainWindow contructor
Setup the menu, toolbar, flowgraph editor notebook, block selection window...
"""
self._platform = platform
gen_opts = platform.get_block('options').get_param('generate_options')
generate_mode_default = gen_opts.get_value()
generate_modes = [(o.get_key(), o.get_name(),
o.get_key() == generate_mode_default)
for o in gen_opts.get_options()]
# load preferences
Preferences.load(platform)
#setup window
gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
vbox = gtk.VBox()
self.hpaned = gtk.HPaned()
self.add(vbox)
#create the menu bar and toolbar
self.add_accel_group(Actions.get_accel_group())
self.menu_bar = Bars.MenuBar(generate_modes, action_handler_callback)
vbox.pack_start(self.menu_bar, False)
self.tool_bar = Bars.Toolbar(generate_modes, action_handler_callback)
vbox.pack_start(self.tool_bar, False)
vbox.pack_start(self.hpaned)
#create the notebook
self.notebook = gtk.Notebook()
self.page_to_be_closed = None
self.current_page = None
self.notebook.set_show_border(False)
self.notebook.set_scrollable(True) #scroll arrows for page tabs
self.notebook.connect('switch-page', self._handle_page_change)
#setup containers
self.flow_graph_vpaned = gtk.VPaned()
#flow_graph_box.pack_start(self.scrolled_window)
self.flow_graph_vpaned.pack1(self.notebook)
self.hpaned.pack1(self.flow_graph_vpaned)
self.btwin = BlockTreeWindow(platform, self.get_flow_graph)
self.hpaned.pack2(self.btwin, False) #dont allow resize
#create the reports window
self.text_display = TextDisplay()
#house the reports in a scrolled window
self.reports_scrolled_window = gtk.ScrolledWindow()
self.reports_scrolled_window.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
self.reports_scrolled_window.add(self.text_display)
self.reports_scrolled_window.set_size_request(
-1, DEFAULT_REPORTS_WINDOW_WIDTH)
self.flow_graph_vpaned.pack2(self.reports_scrolled_window,
False) #dont allow resize
#load preferences and show the main window
self.resize(*Preferences.main_window_size())
self.flow_graph_vpaned.set_position(
Preferences.reports_window_position())
self.hpaned.set_position(Preferences.blocks_window_position())
self.show_all()
self.reports_scrolled_window.hide()
self.btwin.hide()
def __init__(self, block):
"""
Properties dialog constructor.
Args:
block: a block instance
"""
self._hash = 0
gtk.Dialog.__init__(
self,
title='Properties: %s' % block.get_name(),
buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT, gtk.STOCK_OK, gtk.RESPONSE_ACCEPT),
)
self._block = block
self.set_size_request(MIN_DIALOG_WIDTH, MIN_DIALOG_HEIGHT)
vpaned = gtk.VPaned()
self.vbox.pack_start(vpaned)
# Notebook to hold param boxes
notebook = gtk.Notebook()
notebook.set_show_border(False)
notebook.set_scrollable(True) # scroll arrows for page tabs
notebook.set_tab_pos(gtk.POS_TOP)
vpaned.pack1(notebook, True)
# Params boxes for block parameters
self._params_boxes = list()
for tab in block.get_param_tab_labels():
label = gtk.Label()
vbox = gtk.VBox()
scroll_box = gtk.ScrolledWindow()
scroll_box.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scroll_box.add_with_viewport(vbox)
notebook.append_page(scroll_box, label)
self._params_boxes.append((tab, label, vbox))
# Docs for the block
self._docs_text_display = TextDisplay()
self._docs_box = gtk.ScrolledWindow()
self._docs_box.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self._docs_box.add_with_viewport(self._docs_text_display)
notebook.append_page(self._docs_box, gtk.Label("Documentation"))
# Error Messages for the block
self._error_messages_text_display = TextDisplay()
self._error_box = gtk.ScrolledWindow()
self._error_box.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self._error_box.add_with_viewport(self._error_messages_text_display)
vpaned.pack2(self._error_box)
vpaned.set_position(int(0.65 * MIN_DIALOG_HEIGHT))
# Connect events
self.connect('key-press-event', self._handle_key_press)
self.connect('show', self._update_gui)
self.show_all() # show all (performs initial gui update)
def __init__(self, platform):
"""
MainWindow contructor
Setup the menu, toolbar, flowgraph editor notebook, block selection window...
"""
self._platform = platform
#setup window
gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
vbox = gtk.VBox()
self.hpaned = gtk.HPaned()
self.add(vbox)
#create the menu bar and toolbar
self.add_accel_group(Actions.get_accel_group())
vbox.pack_start(Bars.MenuBar(), False)
vbox.pack_start(Bars.Toolbar(), False)
vbox.pack_start(self.hpaned)
#create the notebook
self.notebook = gtk.Notebook()
self.page_to_be_closed = None
self.current_page = None
self.notebook.set_show_border(False)
self.notebook.set_scrollable(True) #scroll arrows for page tabs
self.notebook.connect('switch-page', self._handle_page_change)
#setup containers
self.flow_graph_vpaned = gtk.VPaned()
#flow_graph_box.pack_start(self.scrolled_window)
self.flow_graph_vpaned.pack1(self.notebook)
self.hpaned.pack1(self.flow_graph_vpaned)
self.hpaned.pack2(BlockTreeWindow(platform, self.get_flow_graph),
False) #dont allow resize
#create the reports window
self.text_display = TextDisplay()
#house the reports in a scrolled window
self.reports_scrolled_window = gtk.ScrolledWindow()
self.reports_scrolled_window.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
self.reports_scrolled_window.add_with_viewport(self.text_display)
self.reports_scrolled_window.set_size_request(
-1, DEFAULT_REPORTS_WINDOW_WIDTH)
self.flow_graph_vpaned.pack2(self.reports_scrolled_window,
False) #dont allow resize
#load preferences and show the main window
Preferences.load(platform)
self.resize(*Preferences.main_window_size())
self.flow_graph_vpaned.set_position(
Preferences.reports_window_position())
self.hpaned.set_position(Preferences.blocks_window_position())
self.show_all()
def __init__(self, block):
"""
Properties dialog contructor.
Args:
block: a block instance
"""
self._hash = 0
LABEL_SPACING = 7
gtk.Dialog.__init__(self,
title='Properties: %s'%block.get_name(),
buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT, gtk.STOCK_OK, gtk.RESPONSE_ACCEPT),
)
self._block = block
self.set_size_request(MIN_DIALOG_WIDTH, MIN_DIALOG_HEIGHT)
vbox = gtk.VBox()
#Create the scrolled window to hold all the parameters
scrolled_window = gtk.ScrolledWindow()
scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolled_window.add_with_viewport(vbox)
self.vbox.pack_start(scrolled_window, True)
#Params box for block parameters
self._params_box = gtk.VBox()
self._params_box.pack_start(get_title_label('Parameters'), False)
self._input_object_params = list()
#Error Messages for the block
self._error_box = gtk.VBox()
self._error_messages_text_display = TextDisplay()
self._error_box.pack_start(gtk.Label(), False, False, LABEL_SPACING)
self._error_box.pack_start(get_title_label('Error Messages'), False)
self._error_box.pack_start(self._error_messages_text_display, False)
#Docs for the block
self._docs_box = err_box = gtk.VBox()
self._docs_text_display = TextDisplay()
self._docs_box.pack_start(gtk.Label(), False, False, LABEL_SPACING)
self._docs_box.pack_start(get_title_label('Documentation'), False)
self._docs_box.pack_start(self._docs_text_display, False)
#Add the boxes
vbox.pack_start(self._params_box, False)
vbox.pack_start(self._error_box, False)
vbox.pack_start(self._docs_box, False)
#connect events
self.connect('key-press-event', self._handle_key_press)
self.connect('show', self._update_gui)
#show all (performs initial gui update)
self.show_all()
def __init__(self, block):
"""
SignalBlockParamsDialog contructor.
@param block the signal block
"""
gtk.Dialog.__init__(
self,
title='Properties: %s' % block.get_name(),
buttons=(gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE),
)
self.block = block
self.set_size_request(MIN_DIALOG_WIDTH, MIN_DIALOG_HEIGHT)
vbox = gtk.VBox()
#Add the title label
vbox.pack_start(get_title_label('Parameters'), False)
#Create the scrolled window to hold all the parameters
scrolled_window = gtk.ScrolledWindow()
scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolled_window.add_with_viewport(vbox)
self.vbox.pack_start(scrolled_window, True)
#Error Messages for the block
self._error_box = gtk.VBox()
self._error_messages_text_display = TextDisplay()
self._error_box.pack_start(gtk.Label(), False, False, 7) #spacing
self._error_box.pack_start(get_title_label('Error Messages'), False)
self._error_box.pack_start(self._error_messages_text_display, False)
#Docs for the block
self._docs_box = err_box = gtk.VBox()
self._docs_text_display = TextDisplay()
self._docs_box.pack_start(gtk.Label(), False, False, 7) #spacing
self._docs_box.pack_start(get_title_label('Documentation'), False)
self._docs_box.pack_start(self._docs_text_display, False)
#Add all the parameters
for param in self.block.get_params():
vbox.pack_start(param.get_input_object(self._handle_changed),
False)
#Add the error and docs box
vbox.pack_start(self._error_box, False)
vbox.pack_start(self._docs_box, False)
#connect and show
self.connect('key_press_event', self._handle_key_press)
self.show_all()
#initial update
for param in self.block.get_params():
param.update()
self._update()
def __init__(self, block):
"""
SignalBlockParamsDialog contructor.
@param block the signal block
"""
gtk.Dialog.__init__(self,
title='Properties: %s'%block.get_name(),
buttons=(gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE),
)
self.block = block
self.set_size_request(MIN_DIALOG_WIDTH, MIN_DIALOG_HEIGHT)
vbox = gtk.VBox()
#Add the title label
vbox.pack_start(get_title_label('Parameters'), False)
#Create the scrolled window to hold all the parameters
scrolled_window = gtk.ScrolledWindow()
scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolled_window.add_with_viewport(vbox)
self.vbox.pack_start(scrolled_window, True)
#Error Messages for the block
self._error_box = gtk.VBox()
self._error_messages_text_display = TextDisplay()
self._error_box.pack_start(gtk.Label(), False, False, 7) #spacing
self._error_box.pack_start(get_title_label('Error Messages'), False)
self._error_box.pack_start(self._error_messages_text_display, False)
#Docs for the block
self._docs_box = err_box = gtk.VBox()
self._docs_text_display = TextDisplay()
self._docs_box.pack_start(gtk.Label(), False, False, 7) #spacing
self._docs_box.pack_start(get_title_label('Documentation'), False)
self._docs_box.pack_start(self._docs_text_display, False)
#Add all the parameters
for param in self.block.get_params():
vbox.pack_start(param.get_input_object(self._handle_changed), False)
#Add the error and docs box
vbox.pack_start(self._error_box, False)
vbox.pack_start(self._docs_box, False)
#connect and show
self.connect('key_press_event', self._handle_key_press)
self.show_all()
#initial update
for param in self.block.get_params(): param.update()
self._update()
def __init__(self, platform, action_handler_callback):
"""
MainWindow contructor
Setup the menu, toolbar, flowgraph editor notebook, block selection window...
"""
self._platform = platform
gen_opts = platform.get_block('options').get_param('generate_options')
generate_mode_default = gen_opts.get_value()
generate_modes = [
(o.get_key(), o.get_name(), o.get_key() == generate_mode_default)
for o in gen_opts.get_options()]
# load preferences
Preferences.load(platform)
#setup window
gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
vbox = gtk.VBox()
self.hpaned = gtk.HPaned()
self.add(vbox)
#create the menu bar and toolbar
self.add_accel_group(Actions.get_accel_group())
self.menu_bar = Bars.MenuBar(generate_modes, action_handler_callback)
vbox.pack_start(self.menu_bar, False)
self.tool_bar = Bars.Toolbar(generate_modes, action_handler_callback )
vbox.pack_start(self.tool_bar, False)
vbox.pack_start(self.hpaned)
#create the notebook
self.notebook = gtk.Notebook()
self.page_to_be_closed = None
self.current_page = None
self.notebook.set_show_border(False)
self.notebook.set_scrollable(True) #scroll arrows for page tabs
self.notebook.connect('switch-page', self._handle_page_change)
#setup containers
self.flow_graph_vpaned = gtk.VPaned()
#flow_graph_box.pack_start(self.scrolled_window)
self.flow_graph_vpaned.pack1(self.notebook)
self.hpaned.pack1(self.flow_graph_vpaned)
self.btwin = BlockTreeWindow(platform, self.get_flow_graph);
self.hpaned.pack2(self.btwin, False) #dont allow resize
#create the reports window
self.text_display = TextDisplay()
#house the reports in a scrolled window
self.reports_scrolled_window = gtk.ScrolledWindow()
self.reports_scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.reports_scrolled_window.add(self.text_display)
self.reports_scrolled_window.set_size_request(-1, DEFAULT_REPORTS_WINDOW_WIDTH)
self.flow_graph_vpaned.pack2(self.reports_scrolled_window, False) #dont allow resize
#load preferences and show the main window
self.resize(*Preferences.main_window_size())
self.flow_graph_vpaned.set_position(Preferences.reports_window_position())
self.hpaned.set_position(Preferences.blocks_window_position())
self.show_all()
self.reports_scrolled_window.hide()
self.btwin.hide()
def __init__(self, handle_states, platform):
"""
MainWindow contructor.
@param handle_states the callback function
"""
self._platform = platform
#setup window
self.handle_states = handle_states
gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
vbox = gtk.VBox()
self.hpaned = gtk.HPaned()
self.add(vbox)
#create the menu bar and toolbar
self.add_accel_group(get_accel_group())
vbox.pack_start(Bars.MenuBar(), False)
vbox.pack_start(Bars.Toolbar(), False)
vbox.pack_start(self.hpaned)
#create the notebook
self.notebook = gtk.Notebook()
self.page_to_be_closed = None
self.current_page = None
self.notebook.set_show_border(False)
self.notebook.set_scrollable(True) #scroll arrows for page tabs
self.notebook.connect('switch-page', self._handle_page_change)
#setup containers
self.flow_graph_vpaned = gtk.VPaned()
#flow_graph_box.pack_start(self.scrolled_window)
self.flow_graph_vpaned.pack1(self.notebook)
self.hpaned.pack1(self.flow_graph_vpaned)
self.hpaned.pack2(BlockTreeWindow(platform, self.get_flow_graph), False) #dont allow resize
#create the reports window
self.text_display = TextDisplay()
#house the reports in a scrolled window
self.reports_scrolled_window = gtk.ScrolledWindow()
self.reports_scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.reports_scrolled_window.add_with_viewport(self.text_display)
self.reports_scrolled_window.set_size_request(-1, DEFAULT_REPORTS_WINDOW_WIDTH)
self.flow_graph_vpaned.pack2(self.reports_scrolled_window, False) #dont allow resize
#load preferences and show the main window
Preferences.load(platform)
self.resize(*Preferences.main_window_size())
self.flow_graph_vpaned.set_position(Preferences.reports_window_position())
self.hpaned.set_position(Preferences.blocks_window_position())
self.show_all()
class ParamsDialog(gtk.Dialog):
"""A dialog box to set block parameters."""
def __init__(self, block):
"""
SignalBlockParamsDialog contructor.
@param block the signal block
"""
gtk.Dialog.__init__(self,
title='Properties: %s'%block.get_name(),
buttons=(gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE),
)
self.block = block
self.set_size_request(MIN_DIALOG_WIDTH, MIN_DIALOG_HEIGHT)
vbox = gtk.VBox()
#Add the title label
vbox.pack_start(get_title_label('Parameters'), False)
#Create the scrolled window to hold all the parameters
scrolled_window = gtk.ScrolledWindow()
scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolled_window.add_with_viewport(vbox)
self.vbox.pack_start(scrolled_window, True)
#Error Messages for the block
self._error_box = gtk.VBox()
self._error_messages_text_display = TextDisplay()
self._error_box.pack_start(gtk.Label(), False, False, 7) #spacing
self._error_box.pack_start(get_title_label('Error Messages'), False)
self._error_box.pack_start(self._error_messages_text_display, False)
#Docs for the block
self._docs_box = err_box = gtk.VBox()
self._docs_text_display = TextDisplay()
self._docs_box.pack_start(gtk.Label(), False, False, 7) #spacing
self._docs_box.pack_start(get_title_label('Documentation'), False)
self._docs_box.pack_start(self._docs_text_display, False)
#Add all the parameters
for param in self.block.get_params():
vbox.pack_start(param.get_input_object(self._handle_changed), False)
#Add the error and docs box
vbox.pack_start(self._error_box, False)
vbox.pack_start(self._docs_box, False)
#connect and show
self.connect('key_press_event', self._handle_key_press)
self.show_all()
#initial update
for param in self.block.get_params(): param.update()
self._update()
def _update(self):
"""
Update the error messages box.
Hide the box if there are no errors.
Update the documentation block.
Hide the box if there are no docs.
"""
self.block.validate()
#update the errors box
if self.block.is_valid(): self._error_box.hide()
else: self._error_box.show()
messages = '\n\n'.join(self.block.get_error_messages())
self._error_messages_text_display.set_text(messages)
#update the docs box
if self.block.get_doc(): self._docs_box.show()
else: self._docs_box.hide()
self._docs_text_display.set_text(self.block.get_doc())
def _handle_key_press(self, widget, event):
"""
Handle key presses from the keyboard.
Call the ok response when enter is pressed.
@return false to forward the keypress
"""
keyname = gtk.gdk.keyval_name(event.keyval)
if keyname == 'Return': self.response(gtk.RESPONSE_OK)
return False #forward the keypress
def _handle_changed(self, param):
"""
A change occured, update any dependent parameters:
The enum inside the variable type may have changed and,
the variable param will need an external update.
@param param the graphical parameter that initiated the callback
"""
#update dependent params
if param.is_enum():
for other_param in param.get_parent().get_params():
if param.get_key() is not other_param.get_key() and (
param.get_key() in other_param._type or \
param.get_key() in other_param._hide): other_param.update()
#update
self._update()
return True
def run(self):
"""
Call run().
@return true if a change occured.
"""
original_data = list()
for param in self.block.get_params():
original_data.append(param.get_value())
gtk.Dialog.run(self)
self.destroy()
new_data = list()
for param in self.block.get_params():
new_data.append(param.get_value())
return original_data != new_data
class PropsDialog(gtk.Dialog):
"""
A dialog to set block parameters, view errors, and view documentation.
"""
def __init__(self, block):
"""
Properties dialog contructor.
Args:
block: a block instance
"""
self._hash = 0
LABEL_SPACING = 7
gtk.Dialog.__init__(self,
title='Properties: %s'%block.get_name(),
buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT, gtk.STOCK_OK, gtk.RESPONSE_ACCEPT),
)
self._block = block
self.set_size_request(MIN_DIALOG_WIDTH, MIN_DIALOG_HEIGHT)
vbox = gtk.VBox()
#Create the scrolled window to hold all the parameters
scrolled_window = gtk.ScrolledWindow()
scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolled_window.add_with_viewport(vbox)
self.vbox.pack_start(scrolled_window, True)
#Params box for block parameters
self._params_box = gtk.VBox()
self._params_box.pack_start(get_title_label('Parameters'), False)
self._input_object_params = list()
#Error Messages for the block
self._error_box = gtk.VBox()
self._error_messages_text_display = TextDisplay()
self._error_box.pack_start(gtk.Label(), False, False, LABEL_SPACING)
self._error_box.pack_start(get_title_label('Error Messages'), False)
self._error_box.pack_start(self._error_messages_text_display, False)
#Docs for the block
self._docs_box = err_box = gtk.VBox()
self._docs_text_display = TextDisplay()
self._docs_box.pack_start(gtk.Label(), False, False, LABEL_SPACING)
self._docs_box.pack_start(get_title_label('Documentation'), False)
self._docs_box.pack_start(self._docs_text_display, False)
#Add the boxes
vbox.pack_start(self._params_box, False)
vbox.pack_start(self._error_box, False)
vbox.pack_start(self._docs_box, False)
#connect events
self.connect('key-press-event', self._handle_key_press)
self.connect('show', self._update_gui)
#show all (performs initial gui update)
self.show_all()
def _params_changed(self):
"""
Have the params in this dialog changed?
Ex: Added, removed, type change, hide change...
To the props dialog, the hide setting of 'none' and 'part' are identical.
Therfore, the props dialog only cares if the hide setting is/not 'all'.
Make a hash that uniquely represents the params' state.
Returns:
true if changed
"""
old_hash = self._hash
#create a tuple of things from each param that affects the params box
self._hash = hash(tuple([(
hash(param), param.get_type(), param.get_hide() == 'all',
) for param in self._block.get_params()]))
return self._hash != old_hash
def _handle_changed(self, *args):
"""
A change occured within a param:
Rewrite/validate the block and update the gui.
"""
#update for the block
self._block.rewrite()
self._block.validate()
self._update_gui()
def _update_gui(self, *args):
"""
Repopulate the parameters box (if changed).
Update all the input parameters.
Update the error messages box.
Hide the box if there are no errors.
Update the documentation block.
Hide the box if there are no docs.
"""
#update the params box
if self._params_changed():
#hide params box before changing
self._params_box.hide_all()
#empty the params box
for io_param in list(self._input_object_params):
self._params_box.remove(io_param)
self._input_object_params.remove(io_param)
io_param.destroy()
#repopulate the params box
for param in self._block.get_params():
if param.get_hide() == 'all': continue
io_param = param.get_input(self._handle_changed)
self._input_object_params.append(io_param)
self._params_box.pack_start(io_param, False)
#show params box with new params
self._params_box.show_all()
#update the errors box
if self._block.is_valid(): self._error_box.hide()
else: self._error_box.show()
messages = '\n\n'.join(self._block.get_error_messages())
self._error_messages_text_display.set_text(messages)
#update the docs box
if self._block.get_doc(): self._docs_box.show()
else: self._docs_box.hide()
self._docs_text_display.set_text(self._block.get_doc())
def _handle_key_press(self, widget, event):
"""
Handle key presses from the keyboard.
Call the ok response when enter is pressed.
Returns:
false to forward the keypress
"""
if event.keyval == gtk.keysyms.Return:
self.response(gtk.RESPONSE_ACCEPT)
return True #handled here
return False #forward the keypress
def run(self):
"""
Run the dialog and get its response.
Returns:
true if the response was accept
"""
response = gtk.Dialog.run(self)
self.destroy()
return response == gtk.RESPONSE_ACCEPT
class MainWindow(gtk.Window):
"""The topmost window with menus, the tool bar, and other major windows."""
def __init__(self, platform):
"""
MainWindow contructor
Setup the menu, toolbar, flowgraph editor notebook, block selection window...
"""
self._platform = platform
# setup window
gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
vbox = gtk.VBox()
self.hpaned = gtk.HPaned()
self.add(vbox)
# create the menu bar and toolbar
self.add_accel_group(Actions.get_accel_group())
vbox.pack_start(Bars.MenuBar(), False)
vbox.pack_start(Bars.Toolbar(), False)
vbox.pack_start(self.hpaned)
# create the notebook
self.notebook = gtk.Notebook()
self.page_to_be_closed = None
self.current_page = None
self.notebook.set_show_border(False)
self.notebook.set_scrollable(True) # scroll arrows for page tabs
self.notebook.connect("switch-page", self._handle_page_change)
# setup containers
self.flow_graph_vpaned = gtk.VPaned()
# flow_graph_box.pack_start(self.scrolled_window)
self.flow_graph_vpaned.pack1(self.notebook)
self.hpaned.pack1(self.flow_graph_vpaned)
self.btwin = BlockTreeWindow(platform, self.get_flow_graph)
self.hpaned.pack2(self.btwin, False) # dont allow resize
# create the reports window
self.text_display = TextDisplay()
# house the reports in a scrolled window
self.reports_scrolled_window = gtk.ScrolledWindow()
self.reports_scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.reports_scrolled_window.add(self.text_display)
self.reports_scrolled_window.set_size_request(-1, DEFAULT_REPORTS_WINDOW_WIDTH)
self.flow_graph_vpaned.pack2(self.reports_scrolled_window, False) # dont allow resize
# load preferences and show the main window
Preferences.load(platform)
self.resize(*Preferences.main_window_size())
self.flow_graph_vpaned.set_position(Preferences.reports_window_position())
self.hpaned.set_position(Preferences.blocks_window_position())
self.show_all()
self.reports_scrolled_window.hide()
self.btwin.hide()
############################################################
# Event Handlers
############################################################
def _quit(self, window, event):
"""
Handle the delete event from the main window.
Generated by pressing X to close, alt+f4, or right click+close.
This method in turns calls the state handler to quit.
Returns:
true
"""
Actions.APPLICATION_QUIT()
return True
def _handle_page_change(self, notebook, page, page_num):
"""
Handle a page change. When the user clicks on a new tab,
reload the flow graph to update the vars window and
call handle states (select nothing) to update the buttons.
Args:
notebook: the notebook
page: new page
page_num: new page number
"""
self.current_page = self.notebook.get_nth_page(page_num)
Messages.send_page_switch(self.current_page.get_file_path())
Actions.PAGE_CHANGE()
############################################################
# Report Window
############################################################
def add_report_line(self, line):
"""
Place line at the end of the text buffer, then scroll its window all the way down.
Args:
line: the new text
"""
self.text_display.insert(line)
############################################################
# Pages: create and close
############################################################
def new_page(self, file_path="", show=False):
"""
Create a new notebook page.
Set the tab to be selected.
Args:
file_path: optional file to load into the flow graph
show: true if the page should be shown after loading
"""
# if the file is already open, show the open page and return
if file_path and file_path in self._get_files(): # already open
page = self.notebook.get_nth_page(self._get_files().index(file_path))
self._set_page(page)
return
try: # try to load from file
if file_path:
Messages.send_start_load(file_path)
flow_graph = self._platform.get_new_flow_graph()
flow_graph.grc_file_path = file_path
# print flow_graph
page = NotebookPage(self, flow_graph=flow_graph, file_path=file_path)
if file_path:
Messages.send_end_load()
except Exception, e: # return on failure
Messages.send_fail_load(e)
if isinstance(e, KeyError) and str(e) == "'options'":
# This error is unrecoverable, so crash gracefully
exit(-1)
return
# add this page to the notebook
self.notebook.append_page(page, page.get_tab())
try:
self.notebook.set_tab_reorderable(page, True)
except:
pass # gtk too old
self.notebook.set_tab_label_packing(page, False, False, gtk.PACK_START)
# only show if blank or manual
if not file_path or show:
self._set_page(page)
class MainWindow(gtk.Window):
"""The topmost window with menus, the tool bar, and other major windows."""
def __init__(self, handle_states, platform):
"""
MainWindow contructor.
@param handle_states the callback function
"""
self._platform = platform
#setup window
self.handle_states = handle_states
gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
vbox = gtk.VBox()
self.hpaned = gtk.HPaned()
self.add(vbox)
#create the menu bar and toolbar
self.add_accel_group(get_accel_group())
vbox.pack_start(Bars.MenuBar(), False)
vbox.pack_start(Bars.Toolbar(), False)
vbox.pack_start(self.hpaned)
#create the notebook
self.notebook = gtk.Notebook()
self.page_to_be_closed = None
self.current_page = None
self.notebook.set_show_border(False)
self.notebook.set_scrollable(True) #scroll arrows for page tabs
self.notebook.connect('switch-page', self._handle_page_change)
#setup containers
self.flow_graph_vpaned = gtk.VPaned()
#flow_graph_box.pack_start(self.scrolled_window)
self.flow_graph_vpaned.pack1(self.notebook)
self.hpaned.pack1(self.flow_graph_vpaned)
self.hpaned.pack2(BlockTreeWindow(platform, self.get_flow_graph), False) #dont allow resize
#create the reports window
self.text_display = TextDisplay()
#house the reports in a scrolled window
self.reports_scrolled_window = gtk.ScrolledWindow()
self.reports_scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.reports_scrolled_window.add_with_viewport(self.text_display)
self.reports_scrolled_window.set_size_request(-1, DEFAULT_REPORTS_WINDOW_WIDTH)
self.flow_graph_vpaned.pack2(self.reports_scrolled_window, False) #dont allow resize
#load preferences and show the main window
Preferences.load(platform)
self.resize(*Preferences.main_window_size())
self.flow_graph_vpaned.set_position(Preferences.reports_window_position())
self.hpaned.set_position(Preferences.blocks_window_position())
self.show_all()
############################################################
# Event Handlers
############################################################
def _quit(self, window, event):
"""
Handle the delete event from the main window.
Generated by pressing X to close, alt+f4, or right click+close.
This method in turns calls the state handler to quit.
@return true
"""
self.handle_states(APPLICATION_QUIT)
return True
def _handle_page_change(self, notebook, page, page_num):
"""
Handle a page change. When the user clicks on a new tab,
reload the flow graph to update the vars window and
call handle states (select nothing) to update the buttons.
@param notebook the notebook
@param page new page
@param page_num new page number
"""
self.current_page = self.notebook.get_nth_page(page_num)
Messages.send_page_switch(self.current_page.get_file_path())
self.handle_states()
############################################################
# Report Window
############################################################
def add_report_line(self, line):
"""
Place line at the end of the text buffer, then scroll its window all the way down.
@param line the new text
"""
self.text_display.insert(line)
vadj = self.reports_scrolled_window.get_vadjustment()
vadj.set_value(vadj.upper)
vadj.emit('changed')
############################################################
# Pages: create and close
############################################################
def new_page(self, file_path='', show=False):
"""
Create a new notebook page.
Set the tab to be selected.
@param file_path optional file to load into the flow graph
@param show true if the page should be shown after loading
"""
#if the file is already open, show the open page and return
if file_path and file_path in self._get_files(): #already open
page = self.notebook.get_nth_page(self._get_files().index(file_path))
self._set_page(page)
return
try: #try to load from file
if file_path: Messages.send_start_load(file_path)
flow_graph = self._platform.get_new_flow_graph()
page = NotebookPage(
self,
flow_graph=flow_graph,
file_path=file_path,
)
if file_path: Messages.send_end_load()
except Exception, e: #return on failure
Messages.send_fail_load(e)
return
#add this page to the notebook
self.notebook.append_page(page, page.get_tab())
try: self.notebook.set_tab_reorderable(page, True)
except: pass #gtk too old
self.notebook.set_tab_label_packing(page, False, False, gtk.PACK_START)
#only show if blank or manual
if not file_path or show: self._set_page(page)
class MainWindow(gtk.Window):
"""The topmost window with menus, the tool bar, and other major windows."""
def __init__(self, platform):
"""
MainWindow contructor
Setup the menu, toolbar, flowgraph editor notebook, block selection window...
"""
self._platform = platform
#setup window
gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
vbox = gtk.VBox()
self.hpaned = gtk.HPaned()
self.add(vbox)
#create the menu bar and toolbar
self.add_accel_group(Actions.get_accel_group())
vbox.pack_start(Bars.MenuBar(), False)
vbox.pack_start(Bars.Toolbar(), False)
vbox.pack_start(self.hpaned)
#create the notebook
self.notebook = gtk.Notebook()
self.page_to_be_closed = None
self.current_page = None
self.notebook.set_show_border(False)
self.notebook.set_scrollable(True) #scroll arrows for page tabs
self.notebook.connect('switch-page', self._handle_page_change)
#setup containers
self.flow_graph_vpaned = gtk.VPaned()
#flow_graph_box.pack_start(self.scrolled_window)
self.flow_graph_vpaned.pack1(self.notebook)
self.hpaned.pack1(self.flow_graph_vpaned)
self.btwin = BlockTreeWindow(platform, self.get_flow_graph)
self.hpaned.pack2(self.btwin, False) #dont allow resize
#create the reports window
self.text_display = TextDisplay()
#house the reports in a scrolled window
self.reports_scrolled_window = gtk.ScrolledWindow()
self.reports_scrolled_window.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
self.reports_scrolled_window.add_with_viewport(self.text_display)
self.reports_scrolled_window.set_size_request(
-1, DEFAULT_REPORTS_WINDOW_WIDTH)
self.flow_graph_vpaned.pack2(self.reports_scrolled_window,
False) #dont allow resize
#load preferences and show the main window
Preferences.load(platform)
self.resize(*Preferences.main_window_size())
self.flow_graph_vpaned.set_position(
Preferences.reports_window_position())
self.hpaned.set_position(Preferences.blocks_window_position())
self.show_all()
############################################################
# Event Handlers
############################################################
def _quit(self, window, event):
"""
Handle the delete event from the main window.
Generated by pressing X to close, alt+f4, or right click+close.
This method in turns calls the state handler to quit.
@return true
"""
Actions.APPLICATION_QUIT()
return True
def _handle_page_change(self, notebook, page, page_num):
"""
Handle a page change. When the user clicks on a new tab,
reload the flow graph to update the vars window and
call handle states (select nothing) to update the buttons.
@param notebook the notebook
@param page new page
@param page_num new page number
"""
self.current_page = self.notebook.get_nth_page(page_num)
Messages.send_page_switch(self.current_page.get_file_path())
Actions.PAGE_CHANGE()
############################################################
# Report Window
############################################################
def add_report_line(self, line):
"""
Place line at the end of the text buffer, then scroll its window all the way down.
@param line the new text
"""
self.text_display.insert(line)
vadj = self.reports_scrolled_window.get_vadjustment()
vadj.set_value(vadj.upper)
vadj.emit('changed')
############################################################
# Pages: create and close
############################################################
def new_page(self, file_path='', show=False):
"""
Create a new notebook page.
Set the tab to be selected.
@param file_path optional file to load into the flow graph
@param show true if the page should be shown after loading
"""
#if the file is already open, show the open page and return
if file_path and file_path in self._get_files(): #already open
page = self.notebook.get_nth_page(
self._get_files().index(file_path))
self._set_page(page)
return
try: #try to load from file
if file_path: Messages.send_start_load(file_path)
flow_graph = self._platform.get_new_flow_graph()
flow_graph.grc_file_path = file_path
#print flow_graph
page = NotebookPage(
self,
flow_graph=flow_graph,
file_path=file_path,
)
if file_path: Messages.send_end_load()
except Exception, e: #return on failure
Messages.send_fail_load(e)
if isinstance(e, KeyError) and str(e) == "'options'":
# This error is unrecoverable, so crash gracefully
exit(-1)
return
#add this page to the notebook
self.notebook.append_page(page, page.get_tab())
try:
self.notebook.set_tab_reorderable(page, True)
except:
pass #gtk too old
self.notebook.set_tab_label_packing(page, False, False, gtk.PACK_START)
#only show if blank or manual
if not file_path or show: self._set_page(page)
class ParamsDialog(gtk.Dialog):
"""A dialog box to set block parameters."""
def __init__(self, block):
"""
SignalBlockParamsDialog contructor.
@param block the signal block
"""
gtk.Dialog.__init__(
self,
title='Properties: %s' % block.get_name(),
buttons=(gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE),
)
self.block = block
self.set_size_request(MIN_DIALOG_WIDTH, MIN_DIALOG_HEIGHT)
vbox = gtk.VBox()
#Add the title label
vbox.pack_start(get_title_label('Parameters'), False)
#Create the scrolled window to hold all the parameters
scrolled_window = gtk.ScrolledWindow()
scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolled_window.add_with_viewport(vbox)
self.vbox.pack_start(scrolled_window, True)
#Error Messages for the block
self._error_box = gtk.VBox()
self._error_messages_text_display = TextDisplay()
self._error_box.pack_start(gtk.Label(), False, False, 7) #spacing
self._error_box.pack_start(get_title_label('Error Messages'), False)
self._error_box.pack_start(self._error_messages_text_display, False)
#Docs for the block
self._docs_box = err_box = gtk.VBox()
self._docs_text_display = TextDisplay()
self._docs_box.pack_start(gtk.Label(), False, False, 7) #spacing
self._docs_box.pack_start(get_title_label('Documentation'), False)
self._docs_box.pack_start(self._docs_text_display, False)
#Add all the parameters
for param in self.block.get_params():
vbox.pack_start(param.get_input_object(self._handle_changed),
False)
#Add the error and docs box
vbox.pack_start(self._error_box, False)
vbox.pack_start(self._docs_box, False)
#connect and show
self.connect('key_press_event', self._handle_key_press)
self.show_all()
#initial update
for param in self.block.get_params():
param.update()
self._update()
def _update(self):
"""
Update the error messages box.
Hide the box if there are no errors.
Update the documentation block.
Hide the box if there are no docs.
"""
self.block.validate()
#update the errors box
if self.block.is_valid(): self._error_box.hide()
else: self._error_box.show()
messages = '\n\n'.join(self.block.get_error_messages())
self._error_messages_text_display.set_text(messages)
#update the docs box
if self.block.get_doc(): self._docs_box.show()
else: self._docs_box.hide()
self._docs_text_display.set_text(self.block.get_doc())
def _handle_key_press(self, widget, event):
"""
Handle key presses from the keyboard.
Call the ok response when enter is pressed.
@return false to forward the keypress
"""
keyname = gtk.gdk.keyval_name(event.keyval)
if keyname == 'Return': self.response(gtk.RESPONSE_OK)
return False #forward the keypress
def _handle_changed(self, param):
"""
A change occured, update any dependent parameters:
The enum inside the variable type may have changed and,
the variable param will need an external update.
@param param the graphical parameter that initiated the callback
"""
#update dependent params
if param.is_enum():
for other_param in param.get_parent().get_params():
if param.get_key() is not other_param.get_key() and (
param.get_key() in other_param._type or \
param.get_key() in other_param._hide):
other_param.update()
#update
self._update()
return True
def run(self):
"""
Call run().
@return true if a change occured.
"""
original_data = list()
for param in self.block.get_params():
original_data.append(param.get_value())
gtk.Dialog.run(self)
self.destroy()
new_data = list()
for param in self.block.get_params():
new_data.append(param.get_value())
return original_data != new_data
class PropsDialog(gtk.Dialog):
"""
A dialog to set block parameters, view errors, and view documentation.
"""
def __init__(self, block):
"""
Properties dialog constructor.
Args:
block: a block instance
"""
self._hash = 0
gtk.Dialog.__init__(
self,
title='Properties: %s' % block.get_name(),
buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT, gtk.STOCK_OK,
gtk.RESPONSE_ACCEPT),
)
self._block = block
self.set_size_request(MIN_DIALOG_WIDTH, MIN_DIALOG_HEIGHT)
vpaned = gtk.VPaned()
self.vbox.pack_start(vpaned)
# Notebook to hold param boxes
notebook = gtk.Notebook()
notebook.set_show_border(False)
notebook.set_scrollable(True) # scroll arrows for page tabs
notebook.set_tab_pos(gtk.POS_TOP)
vpaned.pack1(notebook, True)
# Params boxes for block parameters
self._params_boxes = list()
for tab in block.get_param_tab_labels():
label = gtk.Label()
vbox = gtk.VBox()
scroll_box = gtk.ScrolledWindow()
scroll_box.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scroll_box.add_with_viewport(vbox)
notebook.append_page(scroll_box, label)
self._params_boxes.append((tab, label, vbox))
# Docs for the block
self._docs_text_display = TextDisplay()
self._docs_box = gtk.ScrolledWindow()
self._docs_box.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self._docs_box.add_with_viewport(self._docs_text_display)
notebook.append_page(self._docs_box, gtk.Label("Documentation"))
# Error Messages for the block
self._error_messages_text_display = TextDisplay()
self._error_box = gtk.ScrolledWindow()
self._error_box.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self._error_box.add_with_viewport(self._error_messages_text_display)
vpaned.pack2(self._error_box)
vpaned.set_position(int(0.65 * MIN_DIALOG_HEIGHT))
# Connect events
self.connect('key-press-event', self._handle_key_press)
self.connect('show', self._update_gui)
self.show_all() # show all (performs initial gui update)
def _params_changed(self):
"""
Have the params in this dialog changed?
Ex: Added, removed, type change, hide change...
To the props dialog, the hide setting of 'none' and 'part' are identical.
Therefore, the props dialog only cares if the hide setting is/not 'all'.
Make a hash that uniquely represents the params' state.
Returns:
true if changed
"""
old_hash = self._hash
#create a tuple of things from each param that affects the params box
self._hash = hash(
tuple([(
hash(param),
param.get_type(),
param.get_hide() == 'all',
) for param in self._block.get_params()]))
return self._hash != old_hash
def _handle_changed(self, *args):
"""
A change occurred within a param:
Rewrite/validate the block and update the gui.
"""
#update for the block
self._block.rewrite()
self._block.validate()
self._update_gui()
def _update_gui(self, *args):
"""
Repopulate the parameters boxes (if changed).
Update all the input parameters.
Update the error messages box.
Hide the box if there are no errors.
Update the documentation block.
Hide the box if there are no docs.
"""
#update the params box
if self._params_changed():
#hide params box before changing
for tab, label, vbox in self._params_boxes:
vbox.hide_all()
# empty the params box
vbox.forall(lambda c: vbox.remove(c) or c.destroy())
# repopulate the params box
box_all_valid = True
for param in filter(lambda p: p.get_tab_label() == tab,
self._block.get_params()):
if param.get_hide() == 'all':
continue
box_all_valid = box_all_valid and param.is_valid()
vbox.pack_start(param.get_input(self._handle_changed),
False)
label.set_markup(
Utils.parse_template(TAB_LABEL_MARKUP_TMPL,
valid=box_all_valid,
tab=tab))
#show params box with new params
vbox.show_all()
#update the errors box
if self._block.is_valid():
self._error_box.hide()
else:
self._error_box.show()
messages = '\n\n'.join(self._block.get_error_messages())
self._error_messages_text_display.set_text(messages)
#update the docs box
self._docs_text_display.set_text(self._block.get_doc())
def _handle_key_press(self, widget, event):
"""
Handle key presses from the keyboard.
Call the ok response when enter is pressed.
Returns:
false to forward the keypress
"""
if event.keyval == gtk.keysyms.Return:
self.response(gtk.RESPONSE_ACCEPT)
return True # handled here
return False # forward the keypress
def run(self):
"""
Run the dialog and get its response.
Returns:
true if the response was accept
"""
response = gtk.Dialog.run(self)
self.destroy()
return response == gtk.RESPONSE_ACCEPT
class PropsDialog(gtk.Dialog):
"""
A dialog to set block parameters, view errors, and view documentation.
"""
def __init__(self, block):
"""
Properties dialog constructor.
Args:
block: a block instance
"""
self._hash = 0
gtk.Dialog.__init__(
self,
title='Properties: %s' % block.get_name(),
buttons=(gtk.STOCK_OK, gtk.RESPONSE_ACCEPT,
gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT,
gtk.STOCK_APPLY, gtk.RESPONSE_APPLY)
)
self.set_response_sensitive(gtk.RESPONSE_APPLY, False)
self.set_size_request(MIN_DIALOG_WIDTH, MIN_DIALOG_HEIGHT)
self._block = block
vpaned = gtk.VPaned()
self.vbox.pack_start(vpaned)
# Notebook to hold param boxes
notebook = gtk.Notebook()
notebook.set_show_border(False)
notebook.set_scrollable(True) # scroll arrows for page tabs
notebook.set_tab_pos(gtk.POS_TOP)
vpaned.pack1(notebook, True)
# Params boxes for block parameters
self._params_boxes = list()
for tab in block.get_param_tab_labels():
label = gtk.Label()
vbox = gtk.VBox()
scroll_box = gtk.ScrolledWindow()
scroll_box.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scroll_box.add_with_viewport(vbox)
notebook.append_page(scroll_box, label)
self._params_boxes.append((tab, label, vbox))
# Docs for the block
self._docs_text_display = TextDisplay()
self._docs_box = gtk.ScrolledWindow()
self._docs_box.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self._docs_box.add_with_viewport(self._docs_text_display)
notebook.append_page(self._docs_box, gtk.Label("Documentation"))
# Error Messages for the block
self._error_messages_text_display = TextDisplay()
self._error_box = gtk.ScrolledWindow()
self._error_box.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self._error_box.add_with_viewport(self._error_messages_text_display)
vpaned.pack2(self._error_box)
vpaned.set_position(int(0.65 * MIN_DIALOG_HEIGHT))
# Connect events
self.connect('key-press-event', self._handle_key_press)
self.connect('show', self._update_gui)
self.connect('response', self._handle_response)
self.show_all() # show all (performs initial gui update)
def _params_changed(self):
"""
Have the params in this dialog changed?
Ex: Added, removed, type change, hide change...
To the props dialog, the hide setting of 'none' and 'part' are identical.
Therefore, the props dialog only cares if the hide setting is/not 'all'.
Make a hash that uniquely represents the params' state.
Returns:
true if changed
"""
old_hash = self._hash
#create a tuple of things from each param that affects the params box
self._hash = hash(tuple([(
hash(param), param.get_type(), param.get_hide() == 'all',
) for param in self._block.get_params()]))
return self._hash != old_hash
def _handle_changed(self, *args):
"""
A change occurred within a param:
Rewrite/validate the block and update the gui.
"""
#update for the block
self._block.rewrite()
self._block.validate()
self._update_gui()
self._activate_apply()
def _activate_apply(self):
self.set_response_sensitive(gtk.RESPONSE_APPLY, True)
def _update_gui(self, *args):
"""
Repopulate the parameters boxes (if changed).
Update all the input parameters.
Update the error messages box.
Hide the box if there are no errors.
Update the documentation block.
Hide the box if there are no docs.
"""
#update the params box
if self._params_changed():
#hide params box before changing
for tab, label, vbox in self._params_boxes:
vbox.hide_all()
# empty the params box
vbox.forall(lambda c: vbox.remove(c) or c.destroy())
# repopulate the params box
box_all_valid = True
for param in filter(lambda p: p.get_tab_label() == tab, self._block.get_params()):
if param.get_hide() == 'all':
continue
box_all_valid = box_all_valid and param.is_valid()
input_widget = param.get_input(self._handle_changed, self._activate_apply)
vbox.pack_start(input_widget, input_widget.expand)
label.set_markup(Utils.parse_template(TAB_LABEL_MARKUP_TMPL, valid=box_all_valid, tab=tab))
#show params box with new params
vbox.show_all()
#update the errors box
if self._block.is_valid():
self._error_box.hide()
else:
self._error_box.show()
messages = '\n\n'.join(self._block.get_error_messages())
self._error_messages_text_display.set_text(messages)
#update the docs box
self._docs_text_display.set_text(self._block.get_doc())
def _handle_key_press(self, widget, event):
"""
Handle key presses from the keyboard.
Call the ok response when enter is pressed.
Returns:
false to forward the keypress
"""
if (event.keyval == gtk.keysyms.Return and
event.state & gtk.gdk.CONTROL_MASK == 0 and
not isinstance(widget.get_focus(), gtk.TextView)
):
self.response(gtk.RESPONSE_ACCEPT)
return True # handled here
return False # forward the keypress
def _handle_response(self, widget, response):
if response == gtk.RESPONSE_APPLY:
for tab, label, vbox in self._params_boxes:
vbox.forall(lambda c: c.apply_pending_changes())
self.set_response_sensitive(gtk.RESPONSE_APPLY, False)
return True
return False
