editors.py

Go to the documentation of this file.

#  Copyright 2008-2015 Nokia Networks
#  Copyright 2016-     Robot Framework Foundation
#
#  Licensed under the Apache License, Version 2.0 (the "License");
#  you may not use this file except in compliance with the License.
#  You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing, software
#  distributed under the License is distributed on an "AS IS" BASIS,
#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#  See the License for the specific language governing permissions and
#  limitations under the License.
 
import wx
from wx import Colour
 
from .settingeditors import (
    DocumentationEditor, SettingEditor, TagsEditor,
    ImportSettingListEditor, VariablesListEditor, MetadataListEditor)
from .. import robotapi, context
from ..controller.settingcontrollers import (
    DocumentationController, VariableController, TagsController)
from ..publish import (
    RideItemSettingsChanged, RideInitFileRemoved, RideFileNameChanged)
from ..usages.UsageRunner import ResourceFileUsages
from ..widgets import (
    ButtonWithHandler, Label, HeaderLabel, HorizontalSizer, HtmlWindow)
 
 
class WelcomePage(HtmlWindow):
    undo = cut = copy = paste = delete = comment = uncomment = save \
        = show_content_assist = tree_item_selected = lambda *args: None
 
    def __init__(self, parent):
        HtmlWindow.__init__(self, parent, text=context.ABOUT_RIDE)
 
    def close(self):
        self.Show(False)
 
    def destroy(self):
        self.closeclose()
        self.Destroy()
 
 
 
class EditorPanel(wx.Panel):
    # TODO: Move outside default editor package, document
    name = doc = ''
    title = None
    undo = cut = copy = paste = delete = comment = uncomment = save \
        = show_content_assist = lambda self: None
 
    def __init__(self, plugin, parent, controller, tree):
        wx.Panel.__init__(self, parent)
        from ..preferences import RideSettings
        
        _settings = RideSettings()
        self.general_settingsgeneral_settings = _settings['General']
        self.color_backgroundcolor_background = self.general_settingsgeneral_settings.get('background', 'light grey')
        self.color_foregroundcolor_foreground = self.general_settingsgeneral_settings.get('foreground', 'black')
        self.color_secondary_backgroundcolor_secondary_background = self.general_settingsgeneral_settings.get('secondary background', 'light grey')
        self.color_secondary_foregroundcolor_secondary_foreground = self.general_settingsgeneral_settings.get('secondary foreground', 'black')
        self.color_background_helpcolor_background_help = self.general_settingsgeneral_settings.get('background help', (240, 242, 80))
        self.color_foreground_textcolor_foreground_text = self.general_settingsgeneral_settings.get('foreground text', (7, 0, 70))
        self.font_facefont_face = self.general_settingsgeneral_settings.get('font face', '')
        self.font_sizefont_size = self.general_settingsgeneral_settings.get('font size', 11)
        self.SetBackgroundColour(Colour(self.color_backgroundcolor_background))
        self.SetForegroundColour(Colour(self.color_foregroundcolor_foreground))
        self.pluginplugin = plugin
        self.controllercontroller = controller
        self._tree_tree = tree
 
    def tree_item_selected(self, item):
        pass
 
 
class _RobotTableEditor(EditorPanel):
    name = 'table'
    doc = 'table editor'
    
    _settings_open_id = 'robot table settings open'
 
    def __init__(self, plugin, parent, controller, tree):
        EditorPanel.__init__(self, plugin, parent, controller, tree)
        self.sizersizer = wx.BoxSizer(wx.VERTICAL)
        self.Bind(wx.EVT_IDLE, self.OnIdleOnIdle)
        self.SetSizer(self.sizersizer)
        if self.titletitle:
            self.sizersizer.Add(self._create_header_create_header(self.titletitle),
                           0, wx.EXPAND | wx.ALL, 5)
            # self.sizer.Add((0, 10))  # DEBUG why this?
        self._editors_editors = []
        self._reset_last_show_tooltip_reset_last_show_tooltip()
        self._populate()
        self.pluginplugin.subscribe(self._settings_changed_settings_changed, RideItemSettingsChanged)
 
    def _should_settings_be_open(self):
        if self._settings_open_id_settings_open_id not in self.pluginplugin.global_settings:
            return False
        return self.pluginplugin.global_settings[self._settings_open_id_settings_open_id]
 
    def _store_settings_open_status(self):
        self.pluginplugin.global_settings[self._settings_open_id_settings_open_id] = \
            self._settings_settings.IsExpanded()
 
    def _settings_changed(self, message):
        if message.item == self.controllercontroller:
            for editor in self._editors_editors:
                editor.update_value()
 
    def OnIdle(self, event):
        if self._last_shown_tooltip_last_shown_tooltip and self._mouse_outside_tooltip_mouse_outside_tooltip():
            self._last_shown_tooltip_last_shown_tooltip.hide()
            self._reset_last_show_tooltip_reset_last_show_tooltip()
 
    def _mouse_outside_tooltip(self):
        mx, my = wx.GetMousePosition()
        tx, ty = self._last_shown_tooltip_last_shown_tooltip.screen_position
        dx, dy = self._last_shown_tooltip_last_shown_tooltip.size
        return (mx < tx or mx > tx+dx) or (my < ty or my > ty+dy)
 
    def tooltip_allowed(self, tooltip):
        if wx.GetMouseState().ControlDown() or \
                self._last_shown_tooltip_last_shown_tooltip is tooltip:
            return False
        self._last_shown_tooltip_last_shown_tooltip = tooltip
        return True
 
    def _reset_last_show_tooltip(self):
        self._last_shown_tooltip_last_shown_tooltip = None
 
    def close(self):
        self.pluginplugin.unsubscribe(
            self._settings_changed_settings_changed, RideItemSettingsChanged)
        self.Unbind(wx.EVT_MOTION)
        self.Show(False)
 
    def destroy(self):
        self.closeclose()
        self.DestroyLater()
 
    def _create_header(self, text, readonly=False):
        if readonly:
            text += ' (READ ONLY)'
        self._title_display_title_display = HeaderLabel(self, text)
        return self._title_display_title_display
 
    def _add_settings(self):
        self._settings_settings = self._create_settings_create_settings()
        self._restore_settings_open_status_restore_settings_open_status()
        self._editors_editors.append(self._settings_settings)
        self.sizersizer.Add(self._settings_settings, 0, wx.ALL | wx.EXPAND, 2)
 
    def _create_settings(self):
        settings = Settings(self)
        settings.Bind(wx.EVT_COLLAPSIBLEPANE_CHANGED, self._collabsible_changed_collabsible_changed)
        settings.build(self.controllercontroller.settings, self.pluginplugin, self._tree_tree)
        return settings
 
    def _restore_settings_open_status(self):
        if self._should_settings_be_open_should_settings_be_open():
            self._settings_settings.Expand()
            wx.CallAfter(self._collabsible_changed_collabsible_changed)
        else:
            self._settings_settings.Collapse()
            self.GetSizer().Layout()
            self.Refresh()
        self.Parent.GetSizer().Layout()
        self.Parent.Refresh()
 
    def _collabsible_changed(self, event=None):
        self._store_settings_open_status_store_settings_open_status()
        self.GetSizer().Layout()
        self.Refresh()
        if event:
            event.Skip()
 
    
    def highlight_cell(self, obj, row, column):
        if isinstance(obj, robotapi.Setting):
            setting_editor = self._get_settings_editor_get_settings_editor(obj)
            if setting_editor and hasattr(setting_editor, "highlight"):
                setting_editor.highlight(column)
        elif row >= 0 and column >= 0:
            self.kweditor.select(row, column)
 
    
    def _get_settings_editor(self, setting):
        for child in self.GetChildren():
            if isinstance(child, SettingEditor):
                if child._item == setting:
                    return child
        return None
 
    def highlight(self, text, expand=True):
        for editor in self._editors_editors:
            editor.highlight(text, expand=expand)
 
 
class Settings(wx.CollapsiblePane):
    BORDER = 2
 
    def __init__(self, parent):
        wx.CollapsiblePane.__init__(
            self, parent, wx.ID_ANY, 'Settings',
            style=wx.CP_DEFAULT_STYLE | wx.CP_NO_TLW_RESIZE)
        from ..preferences import RideSettings
        
        _settings = RideSettings()
        self.general_settingsgeneral_settings = _settings['General']
        self.color_backgroundcolor_background = self.general_settingsgeneral_settings.get('background', 'light grey')
        self.color_foregroundcolor_foreground = self.general_settingsgeneral_settings.get('foreground', 'black')
        self.color_secondary_backgroundcolor_secondary_background = self.general_settingsgeneral_settings.get('secondary background', 'light grey')
        self.color_secondary_foregroundcolor_secondary_foreground = self.general_settingsgeneral_settings.get('secondary foreground', 'black')
        self.color_background_helpcolor_background_help = self.general_settingsgeneral_settings.get('background help', (240, 242, 80))
        self.color_foreground_textcolor_foreground_text = self.general_settingsgeneral_settings.get('foreground text', (7, 0, 70))
        self.font_facefont_face = self.general_settingsgeneral_settings.get('font face', '')
        self.font_sizefont_size = self.general_settingsgeneral_settings.get('font size', 11)
        self.SetBackgroundColour(Colour(self.color_backgroundcolor_background))
        self.SetForegroundColour(Colour(self.color_foregroundcolor_foreground))
        self._sizer_sizer = wx.BoxSizer(wx.VERTICAL)
        self._editors_editors = []
        self.Bind(wx.EVT_SIZE, self._recalc_size_recalc_size)
 
    def Expand(self):
        wx.CollapsiblePane.Expand(self)
 
    def GetPane(self):
        pane = wx.CollapsiblePane.GetPane(self)
        """
        pane.SetBackgroundColour(Colour(200, 222, 40))
        pane.SetOwnBackgroundColour(Colour(200, 222, 40))
        pane.SetForegroundColour(Colour(7, 0, 70))
        pane.SetOwnForegroundColour(Colour(7, 0, 70))
        """
        pane.tooltip_allowed = self.GetParent().tooltip_allowed
        return pane
 
    def close(self):
        for editor in self._editors_editors:
            editor.close()
 
    def update_value(self):
        for editor in self._editors_editors:
            editor.update_value()
 
    def create_editor_for(self, controller, plugin, tree):
        editor_cls = self._get_editor_class_get_editor_class(controller)
        return editor_cls(self.GetPaneGetPane(), controller, plugin, tree)
 
    def _get_editor_class(self, controller):
        if isinstance(controller, DocumentationController):
            return DocumentationEditor
        if isinstance(controller, TagsController):
            return TagsEditor
        return SettingEditor
 
    def build(self, settings, plugin, tree):
        for setting in settings:
            editor = self.create_editor_forcreate_editor_for(setting, plugin, tree)
            """
            editor.SetBackgroundColour(Colour(200, 222, 40))
            editor.SetOwnBackgroundColour(Colour(200, 222, 40))
            editor.SetForegroundColour(Colour(7, 0, 70))
            editor.SetOwnForegroundColour(Colour(7, 0, 70))
            """
            self._sizer_sizer.Add(editor, 0, wx.ALL | wx.EXPAND, self.BORDERBORDER)
            self._editors_editors.append(editor)
            editor.Refresh()
        self.GetPaneGetPane().SetSizer(self._sizer_sizer)
 
    def _recalc_size(self, event=None):
        expand_button_height = 34
        total_height = 0
        if self.IsExpanded():
            for editor in self._editors_editors:
                total_height += editor.BestSize[1]
                total_height += 2 * self.BORDERBORDER + 1
        self.SetSizeHints(-1, total_height + expand_button_height)
        if event:
            event.Skip()
 
    def highlight(self, text, expand=True):
        match = False
        for editor in self._editors_editors:
            if editor.contains(text):
                editor.highlight(text)
                match = True
            else:
                editor.clear_highlight()
        if match and expand:
            self.ExpandExpand()
            self.Parent.GetSizer().Layout()
 
 
class _FileEditor(_RobotTableEditor):
 
    def __init__(self, *args):
        _RobotTableEditor.__init__(self, *args)
        self.pluginplugin.subscribe(
            self._update_source_and_name_update_source_and_name, RideFileNameChanged)
 
    def _update_source(self, message=None):
        self._source_source.SetValue(self.controllercontroller.data.source)
 
    def _update_source_and_name(self, message):
        self._title_display_title_display.SetLabel(self.controllercontroller.name)
        self._update_source_update_source()
 
    def tree_item_selected(self, item):
        if isinstance(item, VariableController):
            self._var_editor_var_editor.select(item.name)
 
    def _populate(self):
        datafile = self.controllercontroller.data
        header = self._create_header_create_header(
            datafile.name, not self.controllercontroller.is_modifiable())
        self.sizersizer.Add(header, 0, wx.EXPAND | wx.ALL, 5)
        self.sizersizer.Add(self._create_source_label_create_source_label(datafile.source), 0, wx.EXPAND | wx.ALL, 1)
        self.sizersizer.Add((0, 10))
        self._add_settings_add_settings()
        self._add_import_settings_add_import_settings()
        self._add_variable_table_add_variable_table()
 
    def _create_source_label(self, source):
        sizer = wx.BoxSizer(wx.HORIZONTAL)
        sizer.Add((5, 0))
        sizer.Add(Label(self, label='Source', size=(context.SETTING_LABEL_WIDTH,
                                                    context.SETTING_ROW_HEIGHT)))
        self._source_source = wx.TextCtrl(self, style=wx.TE_READONLY | wx.NO_BORDER)
        self._source_source.SetBackgroundColour(Colour(self.color_backgroundcolor_background))
        self._source_source.SetForegroundColour(Colour(self.color_foregroundcolor_foreground))
 
        self._source_source.SetValue(source)
        self._source_source.SetMaxSize(wx.Size(-1, context.SETTING_ROW_HEIGHT))
        sizer.Add(self._source_source, 1, wx.EXPAND)
        return sizer
 
    def _add_import_settings(self):
        import_editor = ImportSettingListEditor(self, self._tree_tree, self.controllercontroller.imports)
        self.sizersizer.Add(import_editor, 1, wx.EXPAND)
        self._editors_editors_editors.append(import_editor)
 
    def _add_variable_table(self):
        self._var_editor_var_editor = VariablesListEditor(self, self._tree_tree, self.controllercontroller.variables)
        self.sizersizer.Add(self._var_editor_var_editor, 1, wx.EXPAND)
        self._editors_editors_editors.append(self._var_editor_var_editor)
 
    def close(self):
        self.pluginplugin.unsubscribe(self._update_source_and_name_update_source_and_name, RideFileNameChanged)
        for editor in self._editors_editors_editors:
            editor.close()
        self._editors_editors_editors = []
        _RobotTableEditor.close(self)
 
    # Stubs so that ctrl+d ctrl+i don't throw exceptions
    delete_rows = insert_rows = lambda s: None
 
 
class FindUsagesHeader(HorizontalSizer):
 
    def __init__(self, parent, header, usages_callback, color_foreground, color_background):
        HorizontalSizer.__init__(self)
        self._header_header = HeaderLabel(parent, header)
        self.add_expanding(self._header_header)
        self.add(ButtonWithHandler(parent, 'Find Usages', usages_callback, color_secondary_foreground=color_foreground,
                                   color_secondary_background=color_background))
 
    def SetLabel(self, label):
        self._header_header.SetLabel(label)
 
 
class ResourceFileEditor(_FileEditor):
    
    _settings_open_id = 'resource file settings open'
 
    def _create_header(self, text, readonly=False):
        if readonly:
            text += ' (READ ONLY)'
 
        def cb(event):
            ResourceFileUsages(self.controllercontroller, self._tree_tree.highlight).show()
        self._title_display_title_display_title_display = FindUsagesHeader(self, text, cb, color_foreground=self.color_secondary_foregroundcolor_secondary_foreground,
                                               color_background=self.color_secondary_backgroundcolor_secondary_background)
        return self._title_display_title_display_title_display
 
 
class TestCaseFileEditor(_FileEditor):
    
    _settings_open_id = 'test case file settings open'
 
    def _populate(self):
        _FileEditor._populate(self)
        self.sizersizer.Add((0, 10))
        self._add_metadata_add_metadata()
 
    def _add_metadata(self):
        metadata_editor = MetadataListEditor(self, self._tree_tree, self.controllercontroller.metadata)
        self.sizersizer.Add(metadata_editor, 1, wx.EXPAND)
        self._editors_editors_editors.append(metadata_editor)
 
 
class InitFileEditor(TestCaseFileEditor):
    
    _settings_open_id = 'init file settings open'
 
    def _populate(self):
        TestCaseFileEditor._populate(self)
        self.pluginplugin.subscribe(self._init_file_removed_init_file_removed, RideInitFileRemoved)
 
    def _init_file_removed(self, message):
        for setting, editor in zip(self.controllercontroller.settings, self._editors_editors_editors):
            editor.refresh(setting)
 
    def close(self):
        self.pluginplugin.unsubscribe(self._init_file_removed_init_file_removed, RideInitFileRemoved)
        super().close()