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

elif action == Actions.ABOUT_WINDOW_DISPLAY:

platform = flow_graph.get_parent()

elif action == Actions.HELP_WINDOW_DISPLAY:

elif action == Actions.TYPES_WINDOW_DISPLAY:

elif action == Actions.ERRORS_WINDOW_DISPLAY:

elif action == Actions.TOGGLE_CONSOLE_WINDOW:

main.update_panel_visibility(main.CONSOLE, action.get_active())

action.save_to_preferences()

elif action == Actions.CLEAR_CONSOLE:

main.text_display.clear()

elif action == Actions.SAVE_CONSOLE:

if file_path is not None:

main.text_display.save(file_path)

elif action == Actions.TOGGLE_HIDE_DISABLED_BLOCKS:

else:

selected_block = flow_graph.get_selected_block()

if selected_block:

response = gtk.RESPONSE_APPLY

while response == gtk.RESPONSE_APPLY: # rerun the dialog if Apply was hit

response = self.dialog.run()

flow_graph._options_block.get_param('generate_options').set_value(args[0])

flow_graph_update(flow_graph)

elif action == Actions.FLOW_GRAPH_OPEN:

if file_paths: #open a new page for each file, show only the first

for i,file_path in enumerate(file_paths):

main.new_page(file_path, show=(i==0))

main.vars.update_gui()

elif action == Actions.FLOW_GRAPH_OPEN_QSS_THEME:

'/share/gnuradio/themes/').run()

if file_paths:

try:

Messages.send_fail_save(page.get_file_path())

page.set_saved(False)

elif action == Actions.FLOW_GRAPH_SAVE_AS:

if file_path is not None:

page.set_file_path(file_path)

Actions.FLOW_GRAPH_SAVE()

while os.path.exists(dup_file_path_temp):

dup_file_path_temp = dup_file_name+'('+str(count)+').grc'

count += 1

if dup_file_path_user is not None:

ParseXML.to_file(flow_graph.export_data(), dup_file_path_user)

Messages.send('Saved Copy to: "' + dup_file_path_user + '"\n')

flow_graph_update(new_flow_graph)

curr_page.set_saved(False)

elif action == Actions.FLOW_GRAPH_SCREEN_CAPTURE:

if file_path is not None:

pixbuf = flow_graph.get_drawing_area().get_screenshot(background_transparent)

pixbuf.save(file_path, Constants.IMAGE_FILE_EXTENSION[1:])

xterm = self.platform.config.xterm_executable

if Preferences.xterm_missing() != xterm:

if not os.path.exists(xterm):

Preferences.xterm_missing(xterm)

if page.get_saved() and page.get_file_path():

Executor.ExecFlowGraphThread(

return False

"""

Create a modal message dialog and run it.

type: the type of message: gtk.MESSAGE_INFO, gtk.MESSAGE_WARNING, gtk.MESSAGE_QUESTION or gtk.MESSAGE_ERROR

buttons: the predefined set of buttons to use:

title: the title of the window (string)

markup: the message text with pango markup

default_response: if set, determines which button is highlighted by default

Returns:

the gtk response from run()

"""

if title: message_dialog.set_title(title)

if markup: message_dialog.set_markup(markup)

if extra_buttons: message_dialog.add_buttons(*extra_buttons)

#end for"""

class AboutDialog(gtk.AboutDialog):

"""A cute little about dialog."""

"""AboutDialog constructor."""

gtk.AboutDialog.__init__(self)

self.set_name(config.name)

self.set_version(config.version)

self.set_license(config.license)

self.destroy()

<b>Usage Tips</b>

<u>Add block</u>: drag and drop or double click a block in the block selection window.

<u>Make connection</u>: click on the source port of one block, then click on the sink port of another block.

<u>Remove connection</u>: select the connection and press delete, or drag the connection.

COLORS_DIALOG_MARKUP_TMPL = """\

<b>Color Mapping</b>

"""

MessageDialogHelper(

type=gtk.MESSAGE_INFO,

buttons=gtk.BUTTONS_CLOSE,

title='Types',

markup=Utils.parse_template(COLORS_DIALOG_MARKUP_TMPL,

colors=platform.get_colors())

)

MessageDialogHelper(

type=gtk.MESSAGE_WARNING,

buttons=gtk.BUTTONS_OK,

title='Warning: missing xterm executable',

markup=("The xterm executable {0!r} is missing.\n\n"

"You can change this setting in your gnuradio.conf, in "

)

# Give the option to either choose an editor or use the default

# Always return true/false so the caller knows it was successful

buttons = (

gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL

)

response = MessageDialogHelper(

)

# Handle the inital default/choose/cancel response

# User wants to choose the editor to use

if response == gtk.RESPONSE_YES:

file_dialog = gtk.FileChooserDialog(

gtk.FILE_CHOOSER_ACTION_OPEN,

('gtk-cancel', gtk.RESPONSE_CANCEL, 'gtk-open', gtk.RESPONSE_OK)

)

Implement a file chooser dialog with only necessary parameters.

"""

"""

FileDialogHelper contructor.

Create a save or open dialog with cancel and ok buttons.

title: the title of the dialog (string)

"""

ok_stock = {gtk.FILE_CHOOSER_ACTION_OPEN : 'gtk-open', gtk.FILE_CHOOSER_ACTION_SAVE : 'gtk-save'}[action]

self.set_select_multiple(False)

self.set_local_only(True)

self.add_filter(get_all_files_filter())

class FileDialog(FileDialogHelper):

"""A dialog box to save or open flow graph files. This is a base class, do not use."""

"""

FileDialog constructor.

"""

if not current_file_path: current_file_path = path.join(DEFAULT_FILE_PATH, NEW_FLOGRAPH_TITLE + Preferences.file_extension())

if self.type == OPEN_FLOW_GRAPH:

self.add_and_set_filter(get_flow_graph_files_filter())

self.set_select_multiple(True)

elif self.type == SAVE_FLOW_GRAPH:

self.add_and_set_filter(get_flow_graph_files_filter())

self.set_current_name(path.basename(current_file_path))

elif self.type == SAVE_CONSOLE:

self.add_and_set_filter(get_text_files_filter())

file_path = path.splitext(path.basename(current_file_path))[0]

self.set_current_name(file_path) #show the current filename

elif self.type == SAVE_IMAGE:

self.add_and_set_filter(get_image_files_filter())

current_file_path = current_file_path + IMAGE_FILE_EXTENSION

self.set_current_name(path.basename(current_file_path)) #show the current filename

elif self.type == OPEN_QSS_THEME:

self.add_and_set_filter(get_qss_themes_filter())

self.set_select_multiple(False)

self.set_current_folder(path.dirname(current_file_path)) #current directory

class SaveScreenShotDialog(SaveImageFileDialog):

self._button = button = gtk.CheckButton('_Background transparent')

self._button.set_active(Preferences.screen_shot_background_transparent())

self.set_extra_widget(button)

break

return block_id

target = (param.get_parent().get_id(), param.get_key())

if target in self._external_updaters:

else:

config = self.get_parent().config

editor = (find_executable(config.editor) or

if not editor:

return

updater = functools.partial(

gtk.STOCK_SAVE, gtk.RESPONSE_OK

)

return MessageDialogHelper(

'Would you like to save changes before closing?', gtk.RESPONSE_OK, buttons

)

"""The base class for an input parameter inside the input parameters dialog."""

expand = False

gtk.HBox.__init__(self)

self.param = param

self._changed_callback = changed_callback

self._editing_callback = editing_callback

self.label = gtk.Label() #no label, markup is added by set_markup

def open_editor(self, widget=None):

flowgraph = self.param.get_parent().get_parent()

def get_text(self):

pass # we never update the value from here

#build the dialog

if self.param.get_type() == 'file_open':

gtk.FILE_CHOOSER_ACTION_OPEN, ('gtk-cancel',gtk.RESPONSE_CANCEL,'gtk-open',gtk.RESPONSE_OK))

elif self.param.get_type() == 'file_save':

gtk.FILE_CHOOSER_ACTION_SAVE, ('gtk-cancel',gtk.RESPONSE_CANCEL, 'gtk-save',gtk.RESPONSE_OK))

file_dialog.set_do_overwrite_confirmation(True)

file_dialog.set_current_name(basename) #show the current filename

A dialog to set block parameters, view errors, and view documentation.

"""

"""

Properties dialog constructor.

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)

(MIN_DIALOG_WIDTH, MIN_DIALOG_HEIGHT)

))

self._block = block

vpaned = gtk.VPaned()

self.vbox.pack_start(vpaned)

if param.get_hide() == 'all':

continue

box_all_valid = box_all_valid and param.is_valid()

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