def recursive_generate_models(self, load_meta_data):
# regulate depth of library model generation to reduce resource consumption
current_hierarchy_depth = self.state.library_hierarchy_depth
min_temp_depth = 2
max_hierarchy_depth = global_gui_config.get_config_value(
"MAX_VISIBLE_LIBRARY_HIERARCHY", min_temp_depth)
if max_hierarchy_depth < min_temp_depth:
logger.verbose(
"Increase MAX_VISIBLE_LIBRARY_HIERARCHY to {0} for state {1}.".
format(min_temp_depth, self))
max_hierarchy_depth = min_temp_depth
no_fully_rec_lib_model = global_gui_config.get_config_value(
"NO_FULLY_RECURSIVE_LIBRARY_MODEL", False)
recursive_model_generation = not (
current_hierarchy_depth >
max_hierarchy_depth) or not no_fully_rec_lib_model
if recursive_model_generation:
self.initiate_library_root_state_model()
self._load_port_models()
if load_meta_data:
if not self.load_meta_data():
# TODO decide to scale here or still in the editor -> at the moment meta data is missing here
import rafcon.gui.helpers.meta_data as gui_helper_meta_data
else:
self.meta_data_was_scaled = True
def recursive_generate_models(self, load_meta_data):
# TODO maybe find a different way to load the meta data of ports correctly
# at the moment the models of state_copy get initialized and the meta data taken from there if not found in
# state itself
# regulate depth of library model generation to reduce resource consumption
current_hierarchy_depth = self.state.library_hierarchy_depth
min_temp_depth = 2
max_hierarchy_depth = global_gui_config.get_config_value(
"MAX_VISIBLE_LIBRARY_HIERARCHY", min_temp_depth)
if max_hierarchy_depth < min_temp_depth:
logger.verbose(
"Increase MAX_VISIBLE_LIBRARY_HIERARCHY to {0} for state {1}.".
format(min_temp_depth, self))
max_hierarchy_depth = min_temp_depth
no_fully_rec_lib_model = global_gui_config.get_config_value(
"NO_FULLY_RECURSIVE_LIBRARY_MODEL", False)
recursive_model_generation = not (
current_hierarchy_depth >
max_hierarchy_depth) or not no_fully_rec_lib_model
if recursive_model_generation:
# logger.debug("initialize state copy {0}".format(self))
self.initiate_library_root_state_model()
else:
logger.verbose("Do not initialize state copy {0}".format(self))
self._load_port_models()
if load_meta_data:
if not self.load_meta_data():
# TODO decide to scale here or still in the editor -> at the moment meta data is missing here
import rafcon.gui.helpers.meta_data as gui_helper_meta_data
# gui_helper_meta_data.scale_library_ports_meta_data(self)
else:
self.meta_data_was_scaled = True
def __init__(self, top_window):
View.__init__(self)
self.win = top_window['main_window']
self.insert_accelerators = {'new': gtk.accelerator_parse('<control>N'),
'open': gtk.accelerator_parse('<control>O'),
'save': gtk.accelerator_parse('<control>S'),
# 'save_as': gtk.accelerator_parse('<shift><control>S'), # no default accelerator insert
'quit': gtk.accelerator_parse('<control>Q'),
'cut': gtk.accelerator_parse('<control>X'),
'copy': gtk.accelerator_parse('<control>C'),
'paste': gtk.accelerator_parse('<control>V'),
# 'delete': gtk.accelerator_parse('Delete'), # no default accelerator insert
# 'undo': gtk.accelerator_parse('<control>Z'), # no default accelerator insert
# 'redo': gtk.accelerator_parse('<control>Y'), # no default accelerator insert
}
self.sub_menu_open_recently = gtk.Menu()
self['open_recent'].set_submenu(self.sub_menu_open_recently)
for menu_item_name in self.buttons.iterkeys():
# set icon
self.set_menu_item_icon(menu_item_name, self.buttons[menu_item_name])
# set accelerator if in shortcuts dictionary with menu_item_name == key
if menu_item_name in global_gui_config.get_config_value('SHORTCUTS'):
shortcuts = global_gui_config.get_config_value('SHORTCUTS')[menu_item_name]
if shortcuts:
self.set_menu_item_accelerator(menu_item_name, shortcuts[0])
def __init__(self, state_machine, meta=None, load_meta_data=True):
"""Constructor
"""
MetaModel.__init__(self) # pass columns as separate parameters
assert isinstance(state_machine, StateMachine)
self.state_machine = state_machine
self.state_machine_id = state_machine.state_machine_id
root_state = self.state_machine.root_state
if isinstance(root_state, ContainerState):
self.root_state = ContainerStateModel(
root_state, parent=self, load_meta_data=load_meta_data)
else:
self.root_state = StateModel(root_state,
parent=self,
load_meta_data=load_meta_data)
if isinstance(meta, Vividict):
self.meta = meta
else:
self.meta = Vividict()
# ongoing_complex_actions is updated by ComplexActionObserver -> secure encapsulated observation
# and made observable by state machine model here
self.ongoing_complex_actions = {}
self.complex_action_observer = ComplexActionObserver(self)
self.meta_signal = Signal()
self.state_meta_signal = Signal()
self.action_signal = Signal()
self.state_action_signal = Signal()
self.sm_selection_changed_signal = Signal()
self.destruction_signal = Signal()
self.temp = Vividict()
if load_meta_data:
self.load_meta_data(recursively=False)
self.selection = Selection(self.sm_selection_changed_signal)
self.storage_lock = threading.Lock(
) # lock can not be substituted by the state machine lock -> maybe because it is a RLock
self.history = None
if global_gui_config.get_config_value('HISTORY_ENABLED'):
from rafcon.gui.models.modification_history import ModificationsHistoryModel
self.history = ModificationsHistoryModel(self)
else:
logger.info("The modification history is disabled")
self.auto_backup = None
if global_gui_config.get_config_value('AUTO_BACKUP_ENABLED'):
from rafcon.gui.models.auto_backup import AutoBackupModel
self.auto_backup = AutoBackupModel(self)
self.root_state.register_observer(self)
self.register_observer(self)
def register_view(self, view):
super(SourceEditorController, self).register_view(view)
view['open_external_button'].connect('clicked',
self.open_externally_clicked)
view['apply_button'].connect('clicked', self.apply_clicked)
view['cancel_button'].connect('clicked', self.cancel_clicked)
view['pylint_check_button'].set_active(
global_gui_config.get_config_value(
'CHECK_PYTHON_FILES_WITH_PYLINT', False))
view['pylint_check_button'].set_tooltip_text(
"Change global default value in GUI config.")
view['apply_button'].set_tooltip_text(
global_gui_config.get_config_value('SHORTCUTS')['apply'][0])
view['open_external_button'].set_tooltip_text(
"Open source in external editor. " +
global_gui_config.get_config_value(
'SHORTCUTS')['open_external_editor'][0])
if isinstance(
self.model.state,
LibraryState) or self.model.state.get_library_root_state():
view['pylint_check_button'].set_sensitive(False)
view.textview.set_editable(False)
view['apply_button'].set_sensitive(False)
view['cancel_button'].set_sensitive(False)
view['open_external_button'].set_sensitive(False)
def new_buffer(self):
style_scheme_manager = GtkSource.StyleSchemeManager()
b = GtkSource.Buffer()
b.set_language(self.language_manager.get_language(self.language))
b.set_highlight_syntax(True)
user_editor_style = global_gui_config.get_config_value(
self.editor_style, "classic")
if user_editor_style.startswith("rafcon"):
user_editor_style = "rafcon"
dark_theme = global_gui_config.get_config_value(
'THEME_DARK_VARIANT', True)
if dark_theme:
user_editor_style = "rafcon-dark"
if is_custom_design_enabled():
user_editor_style = global_design_config.get_config_value(
"SOURCE_VIEW_THEME")
scheme = style_scheme_manager.get_scheme(user_editor_style)
if scheme:
self.style_scheme = scheme
else:
logger.debug(
"The editor style '{}' is not supported. Using the default 'classic'"
.format(user_editor_style))
self.style_scheme = style_scheme_manager.get_scheme('classic')
b.set_style_scheme(self.style_scheme)
return b
def __init__(self):
super().__init__(
builder_filename=glade.get_glade_path('menu_bar.glade'),
parent='menubar')
self.insert_accelerators = {
'new': Gtk.accelerator_parse('<control>N'),
'open': Gtk.accelerator_parse('<control>O'),
'save': Gtk.accelerator_parse('<control>S'),
'quit': Gtk.accelerator_parse('<control>Q'),
'cut': Gtk.accelerator_parse('<control>X'),
'copy': Gtk.accelerator_parse('<control>C'),
'paste': Gtk.accelerator_parse('<control>V'),
}
self.sub_menu_open_recently = Gtk.Menu()
self['open_recent'].set_submenu(self.sub_menu_open_recently)
for menu_item_name in self.buttons:
# set icon
self.set_menu_item_icon(menu_item_name,
self.buttons[menu_item_name])
# set accelerator if in shortcuts dictionary with menu_item_name == key
if menu_item_name in global_gui_config.get_config_value(
'SHORTCUTS'):
shortcuts = global_gui_config.get_config_value(
'SHORTCUTS')[menu_item_name]
if shortcuts:
main_shortcut = shortcuts[0] if isinstance(
shortcuts, list) else shortcuts
self.set_menu_item_accelerator(menu_item_name,
main_shortcut)
for sub_menu_name in self.sub_menus:
sub_menu = self[sub_menu_name]
sub_menu.set_reserve_toggle_size(False)
def __init__(self, state_machine_model):
ModelMT.__init__(self)
assert isinstance(state_machine_model, StateMachineModel)
self.state_machine_model = state_machine_model
# variables used for lock files
# TODO reduce those variables
self.__destroyed = False
self.AUTO_RECOVERY_LOCK_ENABLED = False
if os.path.exists(os.path.join(RAFCON_TEMP_PATH_BASE, 'lock')) and \
global_gui_config.get_config_value('AUTO_RECOVERY_LOCK_ENABLED'):
self.AUTO_RECOVERY_LOCK_ENABLED = True
self.lock_file_lock = threading.Lock()
self.lock_file = None
self.last_lock_file_name = None
# general auto-backup variable
self.timed_temp_storage_enabled = global_gui_config.get_config_value(
'AUTO_BACKUP_ENABLED')
self.only_fix_interval = global_gui_config.get_config_value(
'AUTO_BACKUP_ONLY_FIX_FORCED_INTERVAL')
self.force_temp_storage_interval = global_gui_config.get_config_value(
'AUTO_BACKUP_FORCED_STORAGE_INTERVAL')
self.timed_temp_storage_interval = global_gui_config.get_config_value(
'AUTO_BACKUP_DYNAMIC_STORAGE_INTERVAL')
self.last_backup_time = time.time(
) # used as 'last-backup' and 'last-modification-not-backup-ed' time
self.marked_dirty = False
self.__perform_storage = False
self._timer_request_time = None
self.timer_request_lock = threading.Lock()
self.tmp_timed_storage_thread = None
self.meta = Vividict()
if state_machine_model.state_machine.file_system_path is not None:
# logger.info("store meta data of {0} to {1}".format(self, meta_data_path))
# data used for restore tabs -> (having the information to load state machines without loading them)
self.meta['last_saved'][
'time'] = state_machine_model.state_machine.last_update
self.meta['last_saved'][
'file_system_path'] = state_machine_model.state_machine.file_system_path
logger.debug(
"The auto-backup for state-machine {2} is {0} and set to '{1}'"
"".format(
'ENABLED' if self.timed_temp_storage_enabled else 'DISABLED',
'fix interval mode'
if self.only_fix_interval else 'dynamic interval mode',
self.state_machine_model.state_machine.state_machine_id))
# register observer before initializing check loop
self.observe_model(self.state_machine_model)
# initializing check loop to fully initialize the model
if not self.only_fix_interval:
self.perform_temp_storage()
else:
self.check_for_auto_backup(force=True)
def add_graphical_state_machine_editor(self, state_machine_m):
"""Add to for new state machine
If a new state machine was added, a new tab is created with a graphical editor for this state machine.
:param StateMachineModel state_machine_m: The new state machine model
"""
assert isinstance(state_machine_m, StateMachineModel)
sm_id = state_machine_m.state_machine.state_machine_id
logger.debug(
"Create new graphical editor for state machine with id %s" %
str(sm_id))
if global_gui_config.get_config_value(
'GAPHAS_EDITOR', False) and GAPHAS_AVAILABLE or not GL_ENABLED:
if not GL_ENABLED and not global_gui_config.get_config_value(
'GAPHAS_EDITOR', False):
logger.info(
"Gaphas editor is used. "
"The gui-config is set to use OpenGL editor but not all libraries needed are provided."
)
graphical_editor_view = GraphicalEditorGaphasView(state_machine_m)
graphical_editor_ctrl = GraphicalEditorGaphasController(
state_machine_m, graphical_editor_view)
else:
graphical_editor_view = GraphicalEditorView()
graphical_editor_ctrl = GraphicalEditorController(
state_machine_m, graphical_editor_view)
self.add_controller(sm_id, graphical_editor_ctrl)
tab, tab_label = create_tab_header('', self.on_close_clicked,
self.on_mouse_right_click,
state_machine_m, 'refused')
set_tab_label_texts(tab_label, state_machine_m,
state_machine_m.state_machine.marked_dirty)
page = graphical_editor_view['main_frame']
self.view.notebook.append_page(page, tab)
self.view.notebook.set_tab_reorderable(page, True)
page.show_all()
self.tabs[sm_id] = {
'page': page,
'state_machine_m': state_machine_m,
'file_system_path': state_machine_m.state_machine.file_system_path,
'marked_dirty': state_machine_m.state_machine.marked_dirty,
'root_state_name': state_machine_m.state_machine.root_state.name
}
self.observe_model(state_machine_m)
graphical_editor_view.show()
self.view.notebook.show()
self.last_focused_state_machine_ids.append(sm_id)
def refresh_shortcuts(self):
self.shortcut_manager.remove_shortcuts()
self.shortcut_manager.update_shortcuts()
for item_name, shortcuts in global_gui_config.get_config_value('SHORTCUTS', {}).iteritems():
if shortcuts and item_name in self.view.buttons:
self.view.set_menu_item_accelerator(item_name, shortcuts[0])
self.create_logger_warning_if_shortcuts_are_overwritten_by_menu_bar()
def create_tab_header(title, close_callback, sticky_callback,
*additional_parameters):
def handle_middle_click(widget, event, callback, *additional_parameters):
"""Calls `callback` in case the middle mouse button was pressed"""
if event.get_button()[1] == 2 and callback:
callback(event, *additional_parameters)
sticky_button = None
label = Gtk.Label(label=title)
label.set_max_width_chars(STATE_NAME_MAX_CHARS)
close_button = create_tab_close_button(close_callback,
*additional_parameters)
hbox = Gtk.Box.new(Gtk.Orientation.HORIZONTAL, 0)
if global_gui_config.get_config_value('KEEP_ONLY_STICKY_STATES_OPEN',
True):
sticky_button = create_sticky_button(sticky_callback,
*additional_parameters)
sticky_button.set_name('sticky_button')
hbox.pack_start(sticky_button, expand=False, fill=False, padding=0)
hbox.pack_start(label, expand=True, fill=True, padding=0)
hbox.pack_start(close_button, expand=False, fill=False, padding=0)
event_box = Gtk.EventBox()
event_box.set_name("tab_label") # required for gtkrc
event_box.connect('button-press-event', handle_middle_click,
close_callback, *additional_parameters)
event_box.tab_label = label
event_box.add(hbox)
event_box.show_all()
return event_box, label, sticky_button
def insert_history_item(self,
parent,
history_item,
description,
dummy=False):
"""Enters a single history item into the tree store
:param gtk.TreeItem parent: Parent tree item
:param HistoryItem history_item: History item to be inserted
:param str description: A description to be added to the entry
:param None dummy: Whether this is just a dummy entry (wrapper for concurrency items)
:return: Inserted tree item
:rtype: gtk.TreeItem
"""
if not history_item.state_reference:
logger.error(
"This must never happen! Current history_item is {}".format(
history_item))
return None
content = None
if global_gui_config.get_config_value(
"SHOW_PATH_NAMES_IN_EXECUTION_HISTORY", False):
content = (history_item.state_reference.name + " - " +
history_item.state_reference.get_path() + " - " +
description, None if dummy else history_item,
None if dummy else self.TOOL_TIP_TEXT)
else:
content = (history_item.state_reference.name + " - " + description,
None if dummy else history_item,
None if dummy else self.TOOL_TIP_TEXT)
tree_item = self.history_tree_store.insert_before(
parent, None, content)
return tree_item
def generate_right_click_menu_library(self):
menu = gtk.Menu()
accel_group = self.accel_group
shortcuts_dict = global_gui_config.get_config_value('SHORTCUTS')
self.insert_show_library_content_in_menu(menu, shortcuts_dict, accel_group)
self.insert_is_start_state_in_menu(menu, shortcuts_dict, accel_group)
self.insert_execution_sub_menu_in_menu(menu, shortcuts_dict, accel_group)
self.insert_copy_cut_paste_in_menu(menu, shortcuts_dict, accel_group, no_paste=True)
menu.append(create_image_menu_item("Group states", constants.BUTTON_GROUP, self.on_group_states_activate,
accel_code=shortcuts_dict['group'][0], accel_group=accel_group))
menu.append(create_image_menu_item("Open separately", constants.BUTTON_OPEN,
self.on_open_library_state_separately_activate,
accel_code=shortcuts_dict['open_library_state_separately'][0],
accel_group=accel_group))
menu.append(create_image_menu_item("Substitute state with library", constants.BUTTON_REFR,
self.on_substitute_state_activate,
accel_code=shortcuts_dict['substitute_state'][0], accel_group=accel_group))
sub_menu_item, sub_menu = append_sub_menu_to_parent_menu("Substitute library with template", menu,
constants.BUTTON_REFR)
sub_menu.append(create_image_menu_item("Keep state name", constants.BUTTON_LEFTA,
partial(self.on_substitute_library_with_template_activate, keep_name=True)))
sub_menu.append(create_image_menu_item("Take name from library", constants.BUTTON_EXCHANGE,
partial(self.on_substitute_library_with_template_activate, keep_name=False)))
return menu
def scale_meta_data_according_states(models_dict):
""" Offset meta data of state elements according the area used indicated by the states and
maybe scoped variables (in case of OpenGL editor) meta data.
Method is used by group states to set the offset for the elements in the new container state.
The method needs some generalisation to create methods to easily scale meta data according new parents or views
(e.g. to show inner elements of s library state).
:param models_dict: dictionary that hold lists of meta data with state attribute consistent keys
:return:
"""
gaphas_editor = True if global_gui_config.get_config_value('GAPHAS_EDITOR') else False
left, right, top, bottom = get_boundaries_of_elements_in_dict(models_dict=models_dict)
parent_size = models_dict['state'].parent.get_meta_data_editor(for_gaphas=gaphas_editor)['size']
_, rel_pos, size = cal_frame_according_boundaries(left, right, top, bottom, parent_size, gaphas_editor)
# Set size and position of new container state
models_dict['state'].set_meta_data_editor('rel_pos', rel_pos, from_gaphas=gaphas_editor)
models_dict['state'].set_meta_data_editor('size', size, from_gaphas=gaphas_editor)
offset = mult_two_vectors((-1., -1.), rel_pos)
offset_rel_pos_of_all_models_in_dict(models_dict, offset, gaphas_editor)
return True
def refresh_shortcuts(self):
self.shortcut_manager.remove_shortcuts()
self.shortcut_manager.update_shortcuts()
for item_name, shortcuts in global_gui_config.get_config_value(
'SHORTCUTS', {}).iteritems():
if shortcuts and item_name in self.view.buttons:
self.view.set_menu_item_accelerator(item_name, shortcuts[0])
def set_default_paned_positions(self):
if global_gui_config.get_config_value("SEMANTIC_DATA_MODE", False):
self['vpaned'].set_position(200)
else:
self['vpaned'].set_position(575)
self['logic_vpaned'].set_position(300)
self['data_vpaned'].set_position(300)
def on_full_screen_activate(self, *args):
"""
function to display the currently selected state machine in full screen mode
:param args:
:return:
"""
self.sm_notebook.set_show_tabs(False)
# Hide obsolete widgets of VBox
self.main_window_view['graphical_editor_label_event_box'].hide()
if not global_gui_config.get_config_value("FULLSCREEN_SHOW_TOOLBAR",
True):
self.main_window_view['graphical_editor_toolbar'].hide()
self.main_window_view['console_return_button'].hide()
# Move whole VBox into fullscreen window
self.main_window_view['central_v_pane'].remove(
self.main_window_view['central_vbox'])
self.full_screen_window.add(self.main_window_view['central_vbox'])
# Show fullscreen window undecorated in same screen as main window
position = self.main_window_view.get_top_widget().get_position()
self.full_screen_window.show()
self.full_screen_window.move(position[0], position[1])
self.full_screen_window.set_decorated(False)
self.full_screen_window.fullscreen()
self.main_window_view.get_top_widget().iconify()
def keep_only_sticked_and_selected_tabs(self):
"""Close all tabs, except the currently active one and all sticked ones"""
# Only if the user didn't deactivate this behaviour
if not global_gui_config.get_config_value(
'KEEP_ONLY_STICKY_STATES_OPEN', True):
return
page_id = self.view.notebook.get_current_page()
# No tabs are open
if page_id == -1:
return
page = self.view.notebook.get_nth_page(page_id)
current_state_identifier = self.get_state_identifier_for_page(page)
states_to_be_closed = []
# Iterate over all tabs
for state_identifier, tab_info in list(self.tabs.items()):
# If the tab is currently open, keep it open
if current_state_identifier == state_identifier:
continue
# If the tab is sticky, keep it open
if tab_info['is_sticky']:
continue
# Otherwise close it
states_to_be_closed.append(state_identifier)
for state_identifier in states_to_be_closed:
self.close_page(state_identifier, delete=False)
def __init__(self):
View.__init__(self)
self._lock = threading.Lock()
self.text_view = gtk.TextView()
self.text_view.set_property('editable', False)
self.filtered_buffer = self.create_text_buffer()
self.text_view.set_buffer(self.filtered_buffer)
self.text_view.set_border_width(10)
self._enables = {}
self._auto_scroll_handler_id = None
scrollable = gtk.ScrolledWindow()
scrollable.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrollable.set_name('console_scroller')
scrollable.add(self.text_view)
self.text_view.show()
self['scrollable'] = scrollable
self.top = 'scrollable'
self.quit_flag = False
from rafcon.gui.config import global_gui_config
self.logging_priority = global_gui_config.get_config_value("LOGGING_CONSOLE_GTK_PRIORITY", glib.PRIORITY_LOW)
self._stored_line_number = None
self._stored_line_offset = None
self._stored_text_of_line = None
self._stored_relative_lines = None
def create_logger_warning_if_shortcuts_are_overwritten_by_menu_bar():
shortcut_dict = global_gui_config.get_config_value('SHORTCUTS')
shortcut_key_patterns = [elem for l in shortcut_dict.values() for elem in l]
for key in ['E', 'F', 'V', 'X', 'H', 'e', 'f', 'v', 'x', 'h']:
if '<Alt>' + key in shortcut_key_patterns:
dict_pair = {k: v for k, v_list in shortcut_dict.iteritems() for v in v_list if '<Alt>' + key == v}
logger.warning("Your current shortcut {0} is not working because a menu-bar access key "
"is overwriting it.".format(dict_pair))
def add_description_to_tooltip(tool_tip_with_only_sm_file_system_path_in):
from rafcon.gui.helpers.state_machine import get_root_state_description_of_sm_file_system_path
description = get_root_state_description_of_sm_file_system_path(tool_tip_with_only_sm_file_system_path_in)
enabled = global_gui_config.get_config_value('LIBRARY_TREE_TOOLTIP_INCLUDES_ROOT_STATE_DESCRIPTION', True)
if description and enabled:
return "[source]:\n{0}\n\n[description]:\n\n{1}" \
"".format(tool_tip_with_only_sm_file_system_path_in, description)
else:
return "[source]:\n{0}".format(tool_tip_with_only_sm_file_system_path_in)
def __init__(self, window):
# Setup window to listen for accelerators
self.main_window = window
self.accel_group = Gtk.AccelGroup()
self.main_window.add_accel_group(self.accel_group)
self.__action_to_callbacks = {}
self.__action_to_shortcuts = global_gui_config.get_config_value('SHORTCUTS', {})
self.register_shortcuts()
self.__controller_action_callbacks = {}
def on_quit_activate(self, widget, data=None, force=False):
global_runtime_config.prepare_recently_opened_state_machines_list_for_storage()
if force:
backup_session.reset_session()
if not force and global_gui_config.get_config_value("SESSION_RESTORE_ENABLED"):
backup_session.store_session()
self.on_delete_check_sm_running()
force = True
avoid_shutdown = self.on_delete_event(widget, None, force=force)
if not avoid_shutdown:
self.on_destroy(None)
def __init__(self, top_window):
View.__init__(self)
self.win = top_window['main_window']
self.insert_accelerators = {
'new': Gtk.accelerator_parse('<control>N'),
'open': Gtk.accelerator_parse('<control>O'),
'save': Gtk.accelerator_parse('<control>S'),
# 'save_as': Gtk.accelerator_parse('<shift><control>S'), # no default accelerator insert
'quit': Gtk.accelerator_parse('<control>Q'),
'cut': Gtk.accelerator_parse('<control>X'),
'copy': Gtk.accelerator_parse('<control>C'),
'paste': Gtk.accelerator_parse('<control>V'),
# 'delete': Gtk.accelerator_parse('Delete'), # no default accelerator insert
# 'undo': Gtk.accelerator_parse('<control>Z'), # no default accelerator insert
# 'redo': Gtk.accelerator_parse('<control>Y'), # no default accelerator insert
}
self.sub_menu_open_recently = Gtk.Menu()
self['open_recent'].set_submenu(self.sub_menu_open_recently)
# Gtk TODO: Unfortunately does not help against not showing Accel Keys
# self.win.add_accel_group(self['accelgroup1'])
for menu_item_name in self.buttons:
# set icon
self.set_menu_item_icon(menu_item_name,
self.buttons[menu_item_name])
# set accelerator if in shortcuts dictionary with menu_item_name == key
if menu_item_name in global_gui_config.get_config_value(
'SHORTCUTS'):
shortcuts = global_gui_config.get_config_value(
'SHORTCUTS')[menu_item_name]
if shortcuts:
main_shortcut = shortcuts[0] if isinstance(
shortcuts, list) else shortcuts
self.set_menu_item_accelerator(menu_item_name,
main_shortcut)
for sub_menu_name in self.sub_menus:
sub_menu = self[sub_menu_name]
sub_menu.set_reserve_toggle_size(False)
def __init__(self):
View.__init__(self)
self._lock = threading.Lock()
######################################################
# Logging text view
######################################################
self.logging_console_view = LoggingConsoleView()
self['console'].pack_start(self.logging_console_view.get_top_widget(), True, True, 0)
self.logging_console_view.get_top_widget().show()
######################################################
# initial configuration of the console
######################################################
self['button_follow_logging'].set_active(global_gui_config.get_config_value('CONSOLE_FOLLOW_LOGGING', True))
self['button_show_verbose'].set_active(global_gui_config.get_config_value('LOGGING_SHOW_VERBOSE', True))
self['button_show_debug'].set_active(global_gui_config.get_config_value('LOGGING_SHOW_DEBUG', True))
self['button_show_info'].set_active(global_gui_config.get_config_value('LOGGING_SHOW_INFO', True))
self['button_show_warning'].set_active(global_gui_config.get_config_value('LOGGING_SHOW_WARNING', True))
self['button_show_error'].set_active(global_gui_config.get_config_value('LOGGING_SHOW_ERROR', True))
self['undock_console_button'].set_image(gui_helper_label.create_button_label(constants.BUTTON_UNDOCK))
self['undock_console_button'].set_tooltip_text("Undock debug console widget")
self['console_hide_button'].set_image(gui_helper_label.create_button_label(constants.BUTTON_DOWNA))
gui_helper_label.ellipsize_labels_recursively(self['debug_console_button_hbox'])
def __compare_parameters(self, width, height, zoom, parameters):
"""Compare parameters for equality
Checks if a cached image is existing, the the dimensions agree and finally if the properties are equal. If
so, True is returned, else False,
:param width: The width of the image
:param height: The height of the image
:param zoom: The current scale/zoom factor
:param parameters: The parameters used for the image
:return: True if all parameters are equal, False else
"""
# Deactivated caching
if not global_gui_config.get_config_value('ENABLE_CACHING', True):
return False
# Empty cache
if not self.__image:
return False
# Changed image size
if self.__width != width or self.__height != height:
return False
# Current zoom greater then prepared zoom
if zoom > self.__zoom * self.__zoom_multiplicator:
return False
# Current zoom much smaller than prepared zoom, causes high memory usage and imperfect anti-aliasing
if zoom < self.__zoom / self.__zoom_multiplicator:
return False
# Changed drawing parameter
for key in parameters:
try:
if key not in self.__last_parameters or self.__last_parameters[
key] != parameters[key]:
return False
except (AttributeError, ValueError):
# Some values cannot be compared and raise an exception on comparison (e.g. numpy.ndarray). In this
# case, just return False and do not cache.
try:
# Catch at least the ndarray-case, as this could occure relatively often
import numpy
if isinstance(self.__last_parameters[key], numpy.ndarray):
return numpy.array_equal(self.__last_parameters[key],
parameters[key])
except ImportError:
return False
return False
return True
def prepare_the_labels(self):
for notebook_name in self.notebook_names:
notebook = self[notebook_name]
for i in xrange(notebook.get_n_pages()):
child = notebook.get_nth_page(i)
tab_label = notebook.get_tab_label(child)
if global_gui_config.get_config_value("USE_ICONS_AS_TAB_LABELS", True):
tab_label_text = tab_label.get_text()
notebook.set_tab_label(child, gui_helper_label.create_tab_header_label(tab_label_text, self.icons))
else:
tab_label.set_angle(270)
notebook.set_tab_reorderable(child, True)
notebook.set_tab_detachable(child, True)
def __init__(self):
super().__init__(parent='scrollable')
self._lock = threading.Lock()
self.text_view = Gtk.TextView()
self.text_view.set_property('editable', False)
self._filtered_buffer = self.create_text_buffer()
self._filtered_buffer_lock = ReaderWriterLock(self._filtered_buffer)
self.text_view.set_buffer(self.filtered_buffer)
self.text_view.set_border_window_size(Gtk.TextWindowType.LEFT, 10)
self.text_view.set_border_window_size(Gtk.TextWindowType.RIGHT, 10)
self.text_view.set_border_window_size(Gtk.TextWindowType.TOP, 10)
self.text_view.set_border_window_size(Gtk.TextWindowType.BOTTOM, 10)
self._enables = {}
self._auto_scroll_handler_id = None
scrollable = Gtk.ScrolledWindow()
scrollable.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
scrollable.set_name('console_scroller')
scrollable.add(self.text_view)
self.text_view.show()
self['scrollable'] = scrollable
self.top = 'scrollable'
self.quit_flag = False
self.logging_priority = global_gui_config.get_config_value("LOGGING_CONSOLE_GTK_PRIORITY", GLib.PRIORITY_LOW)
self.max_logging_buffer_lines = global_gui_config.get_config_value('MAX_LOGGING_BUFFER_LINES', 5000)
self._stored_line_number = None
self._stored_line_offset = None
self._stored_text_of_line = None
self._stored_relative_lines = None
def offset_rel_pos_of_models_meta_data_according_parent_state(models_dict):
""" Offset meta data of state elements according the area used indicated by the state meta data.
The offset_rel_pos_of_models_meta_data_according_parent_state offset the position of all handed old elements
in the dictionary.
:param models_dict: dict that hold lists of meta data with state attribute consistent keys
:return:
"""
gaphas_editor = True if global_gui_config.get_config_value('GAPHAS_EDITOR') else False
old_parent_rel_pos = models_dict['state'].get_meta_data_editor(for_gaphas=gaphas_editor)['rel_pos']
offset_rel_pos_of_all_models_in_dict(models_dict, pos_offset=old_parent_rel_pos, gaphas_editor=gaphas_editor)
return True
def __init__(self, state, parent=None, meta=None, load_meta_data=True):
assert isinstance(state, LibraryState)
# TODO maybe find a different way to load the meta data of ports correctly
# at the moment the models of state_copy get initialized and the meta data taken from there if not found in
# state itself
self.state_copy_initialized = False
self.meta_data_was_scaled = False
super(LibraryStateModel, self).__init__(state, parent, meta)
# regulate depth of library model generation to reduce resource consumption
current_hierarchy_depth = self.state.library_hierarchy_depth
max_hierarchy_depth = global_gui_config.get_config_value(
"MAX_VISIBLE_LIBRARY_HIERARCHY", 2)
no_fully_rec_lib_model = global_gui_config.get_config_value(
"NO_FULLY_RECURSIVE_LIBRARY_MODEL", False)
recursive_model_generation = not (
current_hierarchy_depth >
max_hierarchy_depth) or not no_fully_rec_lib_model
if recursive_model_generation:
# logger.debug("initialize state copy {0}".format(self))
self.initiate_library_root_state_model()
else:
logger.debug("Do not initialize state copy {0}".format(self))
self._load_input_data_port_models()
self._load_output_data_port_models()
self._load_outcome_models()
if load_meta_data:
if not self.load_meta_data():
# TODO decide to scale here or still in the editor -> at the moment meta data is missing here
import rafcon.gui.helpers.meta_data as gui_helper_meta_data
# gui_helper_meta_data.scale_library_ports_meta_data(self)
else:
self.meta_data_was_scaled = True
if not global_gui_config.get_config_value('GAPHAS_EDITOR'):
self.meta_data_was_scaled = False
