- #self.app.add_action(action)

- #self.win.add_action(action)

- #prefs_name

- #stock_id=Gtk.STOCK_COPY,

- label='Zoom In',

- tooltip='Increase the canvas zoom level',

- keypresses=["<Ctrl>plus","<Ctrl>equal","<Ctrl>KP_Add"],

-)

- label='Zoom Out',

- tooltip='Decrease the canvas zoom level',

- keypresses=["<Ctrl>minus","<Ctrl>KP_Subtract"],

-)

- label='Reset Zoom',

- tooltip='Reset the canvas zoom level',

- keypresses=["<Ctrl>0","<Ctrl>KP_0"],

-)

- label='_Snap to grid',

- tooltip='Snap blocks to a grid for an easier connection alignment',

- preference_name='snap_to_grid',

- default=True,

-)

- tooltip=

- 'Show the variable editor. Modify variables and imports in this flow graph',

-

- self.init_file_paths = [os.path.abspath(file_path) for file_path in file_paths]

- #setup the messages

- main.new_page(file_path, show=file_path_to_show == file_path)

- main.update_panel_visibility(main.BLOCKS, Actions.TOGGLE_BLOCKS_WINDOW.get_active())

- main.update_panel_visibility(main.CONSOLE, Actions.TOGGLE_CONSOLE_WINDOW.get_active())

- main.update_panel_visibility(main.VARIABLES, Actions.TOGGLE_FLOW_GRAPH_VAR_EDITOR.get_active())

- pass #do nothing, update routines below

-

- 'block_index': selected_blocks.index(sink) + 1, # Ignore the options block

- 'block_index': selected_blocks.index(source) + 1, # Ignore the options block

- source_block = flow_graph.get_block(flow_graph.blocks[pad['block_index']].name)

- pad_id = flow_graph.add_new_block('pad_source', pad['coord'])

- sink_block = flow_graph.get_block(flow_graph.blocks[pad['block_index']].name)

- log.debug("Variables are hidden. Forcing the variable panel to be visible.")

- page.state_cache.save_new_state(flow_graph.export_data())

- ### Following line forces a complete update of io ports

- flow_graph.options_block.params['generate_options'].set_value(str(args[0])[1:-1])

- flow_graph.options_block.params['generate_options'].set_value(str(args[0])[1:-1])

- file_paths = args[0] if args[0] else FileDialogs.OpenFlowGraph(main, page.file_path).run()

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

- #read-only or undefined file path, do save-as

- #otherwise try to save

- dup_file_name = '.'.join(dup_file_path.split('.')[:-1]) + "_copy" # Assuming .grc extension at the end of file_path

- dup_file_path_temp = '{}({}){}'.format(dup_file_name, count, Constants.FILE_EXTENSION)

- dup_file_path_user = FileDialogs.SaveFlowGraph(main, dup_file_path_temp).run()

- self.platform.save_flow_graph(dup_file_path_user, flow_graph)

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

- Messages.send_fail_save("Can not create a copy of the flowgraph\n")

- file_path, background_transparent = FileDialogs.SaveScreenShot(main, page.file_path).run()

- Utils.make_screenshot(flow_graph, file_path, background_transparent)

-

- )

- #todo: implement parser error dialog for YAML

- #update general buttons

- #update alignment options

- #update cut/copy/paste

- #update enable/disable/bypass

- [Actions.BLOCK_CUT, Actions.BLOCK_COPY, Actions.BLOCK_PASTE, Actions.ELEMENT_DELETE],

- [Actions.ERRORS_WINDOW_DISPLAY, Actions.FLOW_GRAPH_GEN, Actions.FLOW_GRAPH_EXEC, Actions.FLOW_GRAPH_KILL],

- [Actions.BLOCK_ENABLE, Actions.BLOCK_DISABLE, Actions.BLOCK_BYPASS, Actions.TOGGLE_HIDE_DISABLED_BLOCKS],

- [Actions.FLOW_GRAPH_SAVE, Actions.FLOW_GRAPH_SAVE_AS, Actions.FLOW_GRAPH_SAVE_COPY],

- [Actions.BLOCK_CUT, Actions.BLOCK_COPY, Actions.BLOCK_PASTE, Actions.ELEMENT_DELETE, Actions.SELECT_ALL],

- [Actions.BLOCK_ROTATE_CCW, Actions.BLOCK_ROTATE_CW, ('_Align', Actions.BLOCK_ALIGNMENTS)],

- [Actions.TOGGLE_CONSOLE_WINDOW, Actions.TOGGLE_SCROLL_LOCK, Actions.SAVE_CONSOLE, Actions.CLEAR_CONSOLE],

- [Actions.TOGGLE_HIDE_DISABLED_BLOCKS, Actions.TOGGLE_AUTO_HIDE_PORT_LABELS, Actions.TOGGLE_SNAP_TO_GRID, Actions.TOGGLE_SHOW_BLOCK_COMMENTS, Actions.TOGGLE_SHOW_BLOCK_IDS,],

- [Actions.HELP_WINDOW_DISPLAY, Actions.TYPES_WINDOW_DISPLAY, Actions.KEYBOARD_SHORTCUTS_WINDOW_DISPLAY, Actions.XML_PARSER_ERRORS_DISPLAY],

- [Actions.BLOCK_CUT, Actions.BLOCK_COPY, Actions.BLOCK_PASTE, Actions.ELEMENT_DELETE],

- [Actions.BLOCK_ROTATE_CCW, Actions.BLOCK_ROTATE_CW, Actions.BLOCK_ENABLE, Actions.BLOCK_DISABLE, Actions.BLOCK_BYPASS],

- menuitem.set_icon(Gio.Icon.new_for_string(parent.icon_name))

- #self.get_style_context().add_class(Gtk.STYLE_CLASS_PRIMARY_TOOLBAR)

- #SubMenuCreator.__init__(self)

- tooltip = '{}: {}'.format('Category' if len(category) > 1 else 'Module', category[-1])

- self.search_entry.set_icon_from_icon_name(Gtk.EntryIconPosition.PRIMARY, 'edit-find')

- self.search_entry.set_icon_activatable(Gtk.EntryIconPosition.PRIMARY, False)

- self.search_entry.set_icon_from_icon_name(Gtk.EntryIconPosition.SECONDARY, 'window-close')

- self.search_entry.connect('key-press-event', self._handle_search_key_press)

- self.treestore = Gtk.TreeStore(GObject.TYPE_STRING, GObject.TYPE_STRING, GObject.TYPE_STRING)

- self.treestore_search = Gtk.TreeStore(GObject.TYPE_STRING, GObject.TYPE_STRING, GObject.TYPE_STRING)

- self.treeview.connect('button-press-event', self._handle_mouse_button_press)

- self.treeview.enable_model_drag_source(Gdk.ModifierType.BUTTON1_MASK, Constants.DND_TARGETS, Gdk.DragAction.COPY)

- scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)

- scrolled_window.set_size_request(Constants.DEFAULT_BLOCKS_WINDOW_WIDTH, -1)

- self.treeview.expand_row(self.treestore.get_path(core_module_iter), False)

- ## Block Tree Methods

- category = tuple(filter(str, block.category)) # tuple is hashable, remove empty cats

- iter_ = treestore.insert_before(categories[parent_category[:-1]], None)

- treestore.set_value(iter_, DOC_INDEX, _format_cat_tooltip(parent_category))

- ## Helper Methods

- ## Event Handlers

- self.add_block(block, self.treestore_search, self._categories_search)

- if key: self.emit('create_new_block', key)

- or event.keyval == Gdk.KEY_slash:

- return False # propagate event

- files = list(filter(os.path.exists, self.get_file_list('files_recent')))

- return self.entry('variable_editor_sidebar_position', pos, default=int(h*0.7))

- return self.entry('variable_editor_position', pos, default=int(self.blocks_window_position()*0.5))

-from gi.repository import Gtk, Gdk, GObject

-

-from .Constants import DEFAULT_CONSOLE_WINDOW_WIDTH

-from .Dialogs import TextDisplay, MessageDialogWrapper

-

-from ..core import Messages

-DPI_SCALING = 1.0 # todo: figure out the GTK3 way (maybe cairo does this for us

- PORT_SEPARATION = PORT_SPACING + 2 * PORT_LABEL_PADDING + int(1.5 * font_size)

- PORT_SEPARATION += -PORT_SEPARATION % (2 * CANVAS_GRID_SIZE) # even multiple

- aspect = "{} '{}'".format('Sink' if element.is_sink else 'Source', element.name)

- #ad.set_comments("")

- colors = [(name, color) for name, key, sizeof, color in Constants.CORE_TYPES]

- ('gtk-cancel', Gtk.ResponseType.CANCEL, 'gtk-open', Gtk.ResponseType.OK),

- Messages.send('>>> Unable to load the default editor. Please choose an editor.\n')

-

- change = 1/1.2

- run_command = generator.file_path + '/build/' + self.flow_graph.get_option('id')

- self.add_buttons('gtk-cancel', Gtk.ResponseType.CANCEL, ok_stock, Gtk.ResponseType.OK)

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

- filters = filters or ([(self.filter_label, self.filter_ext)] if self.filter_label else [])

- self.set_current_name(path.splitext(path.basename(self.current_file_path))[0] + self.filter_ext)

- 'File <b>{filename}</b> Does not Exist!'.format(filename=Utils.encode(filename)),

- filters = [('PDF Files', '.pdf'), ('PNG Files', '.png'), ('SVG Files', '.svg')]

- self._button.set_active(self.config.screen_shot_background_transparent())

- 'File Extension of <b>{filename}</b> not supported!'.format(filename=Utils.encode(filename)),

- Gtk.ApplicationWindow.__init__(self, title="GNU Radio Companion", application=app)

- self.set_icon_from_file(os.path.dirname(os.path.abspath(__file__)) + "/icon.png")

- self.main = Gtk.HPaned() #(orientation=Gtk.Orientation.HORIZONTAL)

- self.btwin.connect('create_new_block', self._add_block_to_current_flow_graph)

- self.vars.connect('create_new_block', self._add_block_to_current_flow_graph)

- self.vars.connect('remove_block', self._remove_block_from_current_flow_graph)

- self.left = Gtk.VPaned() #orientation=Gtk.Orientation.VERTICAL)

- self.right = Gtk.VPaned() #orientation=Gtk.Orientation.VERTICAL)

- self.left_subpanel = Gtk.HPaned() #orientation=Gtk.Orientation.HORIZONTAL)

- self.right.set_position(self.config.variable_editor_position(sidebar=True))

- self.left_subpanel.set_position(self.config.variable_editor_position())

- #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))

- try: #try to load from file

- if file_path: Messages.send_start_load(file_path)

- #print flow_graph

- if file_path: Messages.send_end_load()

- except Exception as e: #return on failure

- #add this page to the notebook

- #only show if blank or manual

- if not file_path or show: self._set_page(page)

- open_files = [file for file in self._get_files() if file] #filter blank files

- #close each page

- if self.notebook.get_n_pages(): return False

- #save state before closing

- self.config.variable_editor_position(self.right.get_position(), sidebar=True)

- self.config.variable_editor_position(self.left_subpanel.get_position())

- if not self.page_to_be_closed: self.page_to_be_closed = self.current_page

- #show the page if it has an executing flow graph or is unsaved

- #unsaved? ask the user

- response = self._save_changes() # return value is either OK, CLOSE, or CANCEL

- Actions.FLOW_GRAPH_SAVE() #try to save

- if not self.page_to_be_closed.saved: #still unsaved?

- self.page_to_be_closed = None #set the page to be closed back to None

- #stop the flow graph if executing

- #remove the page

- self.notebook.remove_page(self.notebook.page_num(self.page_to_be_closed))

- self.new_page() #no pages, make a new one

- self.page_to_be_closed = None #set the page to be closed back to None

- self.notebook.set_current_page(self.notebook.page_num(self.current_page))

- self.scrolled_window.set_size_request(MIN_WINDOW_WIDTH, MIN_WINDOW_HEIGHT)

- self.scrolled_window.set_policy(Gtk.PolicyType.ALWAYS, Gtk.PolicyType.ALWAYS)

- self.scrolled_window.connect('key-press-event', self._handle_scroll_window_key_press)

- self.label.set_markup(self.param.format_label_markup(self._have_pending_changes))

- #set the new value

- #call the callback

- #gui update

- self.param.parent_flowgraph.install_external_editor(self.param, parent=self._transient_for)

- (dirname, basename) = os.path.isfile(file_path) and os.path.split(file_path) or (file_path, '')

- config = self.param.parent_platform.config

- dirname = os.path.join(config.install_prefix, '/share/gnuradio/themes')

- file_dialog.add_buttons('gtk-cancel', Gtk.ResponseType.CANCEL, 'gtk-open', Gtk.ResponseType.OK)

- file_dialog.add_buttons('gtk-cancel', Gtk.ResponseType.CANCEL, 'gtk-save', Gtk.ResponseType.OK)

- raise ValueError("Can't open file chooser dialog for type " + repr(self.param.dtype))

- if not os.path.isdir(dirname): # Check if directory exists, if not fall back to workdir

- if self.param.dtype == "dir_select": # Setup directory selection dialog, and fail for unexpected dtype

- raise ValueError("Can't open directory chooser dialog for type " + repr(self.param.dtype))

- dir_dialog.add_buttons('gtk-cancel', Gtk.ResponseType.CANCEL, 'gtk-open', Gtk.ResponseType.OK)

-

- GObject.GObject.__init__(self, title='Parser Errors', buttons=(Gtk.STOCK_CLOSE, Gtk.ResponseType.ACCEPT))

- scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)

- self.set_size_request(2*MIN_DIALOG_WIDTH, MIN_DIALOG_HEIGHT)

- em = self.tree_store.append(parent, ["Line {e.line}: {e.message}".format(e=error)])

- self._docs_box.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)

- code_box.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)

- self._error_box.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)

- scroll_box.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)

- block_constructor = self._block.templates.render('make').rsplit('.', 2)[-1]

- self.states = [None] * STATE_CACHE_SIZE #fill states

- self.current_state_index = (self.current_state_index + 1)%STATE_CACHE_SIZE

- if self.num_prev_states == STATE_CACHE_SIZE: self.num_prev_states = STATE_CACHE_SIZE - 1

- self.current_state_index = (self.current_state_index + STATE_CACHE_SIZE -1)%STATE_CACHE_SIZE

- self.current_state_index = (self.current_state_index + 1)%STATE_CACHE_SIZE

- raise ValueError('unusable rotation angle "%s"'%str(rotation))

- for exp, symbol in zip(range(9, -15-1, -3), 'GMk munpf'):

- output += eng_notation(num.imag, '+g' if output else 'g') + 'j' if num.imag else ''

- global _nproc # Cached result

- _nproc = max(_nproc//2 - 1, 1)

- self.imports.connect('activate', var_edit.handle_action, var_edit.ADD_IMPORT)

- self.variables.connect('activate', var_edit.handle_action, var_edit.ADD_VARIABLE)

- self.enable.connect('activate', var_edit.handle_action, var_edit.ENABLE_BLOCK)

- self.disable.connect('activate', var_edit.handle_action, var_edit.DISABLE_BLOCK)

- self.delete.connect('activate', var_edit.handle_action, var_edit.DELETE_BLOCK)

- self.properties.connect('activate', var_edit.handle_action, var_edit.OPEN_PROPERTIES)

- #self.treeview.set_enable_search(True)

- #self.treeview.set_search_column(ID_INDEX)

- self.treeview.connect('button-press-event', self._handle_mouse_button_press)

- self.treeview.connect('button-release-event', self._handle_mouse_button_release)

- self.treeview.connect('motion-notify-event', self._handle_motion_notify)

- scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)

- scrolled_window.set_size_request(Constants.DEFAULT_BLOCKS_WINDOW_WIDTH, -1)

- self.treestore.append(imports, [block, block.params['id'].get_value()])

- self.treestore.append(variables, [block, block.params['id'].get_value()])

- #Actions.BLOCK_PARAM_MODIFY()

- block_id = self._block.params['id'].get_value().replace("_", "__")

- confirm.connect('activate', self.handle_action, self.DELETE_BLOCK)

- confirmation_menu.popup(None, None, None, None, event.button, event.time)

- self.handle_action(None, self.OPEN_PROPERTIES, event=event)

- self.handle_action(None, self.ADD_IMPORT, event=event)

- self.handle_action(None, self.ADD_VARIABLE, event=event)

- self.handle_action(None, self.DELETE_CONFIRM, event=event)

- self._context_menu.update_sensitive(True, enabled=self._block.enabled)

- self._context_menu.popup(None, None, None, None, event.button, event.time)

-

- offset_x, offset_y = (0, self.height / 2) if self.is_horizontal() else (self.height / 2, 0)

- port_separation = Constants.PORT_SEPARATION if not has_busses else ports[0].height + Constants.PORT_SPACING

- offset = (self.height - (len(ports) - 1) * port_separation - ports[0].height) / 2

- offset += Constants.PORT_SEPARATION if not has_busses else port.height + Constants.PORT_SPACING

- markups = ['<span font_desc="{font}"><b>key: </b>{key}</span>'.format(font=Constants.PARAM_FONT, key=self.key)]

- min_height = 2 * Constants.PORT_BORDER_SEPARATION + len(ports) * Constants.PORT_SEPARATION

- ) - Constants.PORT_SPACING

- self.width, self.height = width, height = Utils.align_to_grid((width, height))

- (0, (height - label_height) / 2.0 + Constants.LABEL_SEPARATION + title_height / Pango.SCALE)

- '<b>Complexity: {num}bal</b></span>'.format(num=Utils.num_to_str(complexity), font=Constants.BLOCK_FONT)

- coor_m=[a - b for a, b in zip(coor, self.coordinate)] if coor_m is not None else None

- type_templates += ' '.join(p.get_raw('dtype') for p in (self.sinks + self.sources))

- nports_str = ' '.join(str(port.get_raw('multiplicity')) for port in self.ports())

-PORT_TYPE_TO_COLOR = {key: get_color(color) for name, key, sizeof, color in Constants.CORE_TYPES}

-PORT_TYPE_TO_COLOR.update((key, get_color(color)) for key, (_, color) in Constants.ALIAS_TYPES.items())

-

- rotate((15, 0), source.rotation), # line from 0,0 to here, bezier curve start

- rotate((-CONNECTOR_ARROW_HEIGHT, 0), sink.rotation), # line to arrow head

- p1, p2, (dx_e1, dy_e1), (dx_e2, dy_e2), (dx_e3, dy_e3) = self._rel_points

- new_coordinates = (source.parent_block.coordinate, sink.parent_block.coordinate)

- cr.rel_line_to(-CONNECTOR_ARROW_HEIGHT, -CONNECTOR_ARROW_BASE/2)

- Messages.send('>>> Error opening an external editor. Please select a different editor.\n')

- if coor is None: coor = (

- int(random.uniform(.25, .75)*h_adj.get_page_size() + h_adj.get_value()),

- int(random.uniform(.25, .75)*v_adj.get_page_size() + v_adj.get_value()),

- )

- #get selected blocks

- #calc x and y min

- #get connections between selected blocks

- block.move((Constants.CANVAS_GRID_SIZE, Constants.CANVAS_GRID_SIZE))

- min_x, min_y = self.selected_block.coordinate

- delta_coordinate = max(delta_coordinate[0],-min_x), max(delta_coordinate[1], -min_y)

- # Move selected blocks

- ctr_x, ctr_y = (max_x + min_x)/2, (max_y + min_y)/2

- Actions.BLOCK_VALIGN_MIDDLE: lambda x, y, w, h: (x, ctr_y - h/2),

- Actions.BLOCK_HALIGN_CENTER: lambda x, y, w, h: (ctr_x-w/2, y),

- #initialize min and max coordinates

- #update the min/max coordinate

- #calculate center point of selected blocks

- ctr_x, ctr_y = (max_x + min_x)/2, (max_y + min_y)/2

- #rotate the blocks around the center point

- x, y = Utils.get_rotated_coordinate((x - ctr_x, y - ctr_y), rotation)

- #TODO - this is a workaround for bus ports not having a proper coordinate

- selected_elements = self.what_is_selected(self.coordinate, self.press_coor)

- self._new_connection = DummyConnection(selected_port, coordinate=coor)

- dX, dY = int(round(dX / Constants.CANVAS_GRID_SIZE)), int(round(dY / Constants.CANVAS_GRID_SIZE))

- self.coordinate = (X+dX, Y+dY)

- extent = [cmp(xy, e_xy) for cmp, xy, e_xy in zip(cmps, extent, sub_extent)]

-

-

- string = '...' + string[3-max_len:]

- string = string[:max_len//2 - 3] + '...' + string[-max_len//2:]

- string = string[:max_len-3] + '...'

- foreground='foreground="red"' if not self.is_valid() else '', font=Constants.PARAM_FONT,

- color = colors.PORT_TYPE_TO_COLOR.get(self.dtype) or colors.PORT_TYPE_TO_COLOR.get('')

- dark = (0, 0, 30 / 255.0, 50 / 255.0, 70 / 255.0)[min(4, self.vlen)]

- 0: (self.width, self.height / 2),

- 90: (self.height / 2, 0),

- self.height = (2 * Constants.PORT_LABEL_PADDING + label_height*(3 if self.dtype == 'bus' else 1)) / Pango.SCALE