plugin.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 inspect
 
import wx
 
from .. import utils
from ..action.actioninfo import ActionInfo
from ..publish import PUBLISHER
 
 
 
class Plugin():
    tree = property(lambda self: self.__frame__frame.tree,
                    doc='Provides access to the suite and resource tree')
    filemgr = property(lambda self: self.__frame__frame.filemgr,
                    doc='Provides access to the files and folders explorer')
    menubar = property(lambda self: self.__frame__frame.GetMenuBar(),
                       doc='Provides access to the application menubar')
    toolbar = property(lambda self: self.__frame__frame.GetToolBar(),
                       doc='Provides access to the application toolbar')
    notebook = property(lambda self: self.__frame__frame.notebook,
                        doc='Provides access to the tabbed notebook')
    model = property(lambda self: self.__app__app.model,
                     doc='Provides access to the data model')
    frame = property(lambda self: self.__frame__frame,
                     doc='Reference to the RIDE main frame')
    datafile = property(lambda self: self.get_selected_datafileget_selected_datafile(),
                        doc='Currently selected datafile')
    global_settings = property(lambda self: self.__app__app.settings,
                               doc='Settings read from settings.cfg')
 
    
    def __init__(self, application, name=None, doc=None, metadata=None,
                 default_settings=None, initially_enabled=True):
        self.namename = name or utils.name_from_class(self, drop='Plugin')
        self.docdoc = self._get_doc_get_doc(doc)
        self.metadatametadata = metadata or {}
        self.initially_enabledinitially_enabled = initially_enabled
        self._save_timer_save_timer = None
        self.__app__app = application
        self.__frame__frame = application.frame
        self.__namespace__namespace = application.namespace
        self.__settings__settings = application.settings['Plugins'].add_section(self.namename)
        self.__settings__settings.set_defaults(default_settings)
        self.__actions__actions = []
 
    def _get_doc(self, given_doc):
        if given_doc:
            return given_doc
        if self.__doc____doc__ == Plugin.__doc__:
            return ''
        return inspect.getdoc(self) or ''
 
    
    def __getattr__(self, name):
        if '__settings' not in name and self.__settings__settings.has_setting(name):
            return self.__settings__settings[name]
        raise AttributeError("No attribute or settings with name '%s' found" % name)
 
    
    def save_setting(self, name, value, override=True, delay=0):
        self.__settings__settings.set(name, value, autosave=delay == 0, override=override)
        self._delay_saving_delay_saving(delay)
 
    def _delay_saving(self, delay):
        if not delay:
            return
        delay = delay * 1000
        if not self._save_timer_save_timer:
            self._save_timer_save_timer = wx.CallLater(delay, self._save_setting_after_delay_save_setting_after_delay)
        else:
            self._save_timer_save_timer.Restart(delay)
 
    def _save_setting_after_delay(self):
        self.__settings__settings.save()
        self._save_timer_save_timer = None
 
    
    def enable(self):
        pass
 
    
    def disable(self):
        pass
 
    
    def config_panel(self, parent):
        return None
 
    
    def register_action(self, action_info):
        action = self.__frame__frame.actions.register_action(action_info)
        self.__actions__actions.append(action)
        return action
 
    def register_shortcut(self, shortcut, callback):
        action_info = ActionInfo(None, None, action=callback, shortcut=shortcut)
        action = self.__frame__frame.actions.register_shortcut(action_info)
        self.__actions__actions.append(action)
        return action
 
    
    def register_actions(self, action_infos):
        return [self.register_actionregister_action(info) for info in action_infos]
 
    def register_search_action(self, description, handler, icon, default=False):
        self.__frame__frame.toolbar.register_search_handler(description, handler, icon, default=default)
 
    
    def unregister_actions(self):
        for action in self.__actions__actions:
            action.unregister()
        self.__actions__actions = []
 
    
    def add_tab(self, tab, title, allow_closing=True):
        self.notebooknotebook.add_tab(tab, title, allow_closing)
 
    
    def show_tab(self, tab):
        self.notebooknotebook.show_tab(tab)
 
    
    def delete_tab(self, tab):
        self.notebooknotebook.delete_tab(tab)
 
    
    def allow_tab_closing(self, tab):
        self.notebooknotebook.allow_closing(tab)
 
    
    def disallow_tab_closing(self, tab):
        self.notebooknotebook.disallow_closing(tab)
 
    
    def tab_is_visible(self, tab):
        return self.notebooknotebook.tab_is_visible(tab)
 
    
    def new_suite_can_be_opened(self):
        return self.__app__app.ok_to_open_new()
 
    
    def open_suite(self, path):
        self.__frame__frame.open_suite(path)
 
    
    def get_selected_datafile(self):
        if not self.treetree:
            return
        return self.treetree.get_selected_datafile()
 
    
    def save_selected_datafile(self):
        self.__frame__frame.save(self.treetree.get_selected_datafile_controller())
 
    
    def is_unsaved_changes(self):
        return self.__frame__frame.has_unsaved_changes()
 
    
    def save_all_unsaved_changes(self):
        self.__frame__frame.save_all()
 
 
    
    def get_selected_item(self):
        if not self.treetree:
            return
        return self.treetree.get_selected_item()
 
    
    def content_assist_values(self, value=''):
        return self.__namespace__namespace.get_suggestions_for(self.get_selected_itemget_selected_item(), value)
 
    
    def get_user_keyword(self, name):
        keyword_info = self.__namespace__namespace.find_user_keyword(self.datafiledatafile, name)
        return keyword_info.item if keyword_info else None
 
    
    def select_user_keyword_node(self, uk):
        if not self.treetree:
            return
        self.treetree.select_user_keyword_node(uk)
 
    
    def get_keyword(self, name):
        return self.__namespace__namespace.find_keyword(self.datafiledatafile, name)
 
    
    def get_keyword_details(self, name):
        return self.__namespace__namespace.keyword_details(self.datafiledatafile, name)
 
    
    def is_user_keyword(self, name):
        return self.__namespace__namespace.is_user_keyword(self.datafiledatafile, name)
 
    
    def is_library_keyword(self, name):
        return self.__namespace__namespace.is_library_keyword(self.datafiledatafile, name)
 
    
    def all_testcases(self):
        return self.modelmodel.all_testcases()
 
    
    def register_content_assist_hook(self, hook):
        self.__namespace__namespace.register_content_assist_hook(hook)
 
    
    def get_plugins(self):
        return self.__app__app.get_plugins()
 
    
    def publish(self, topic, data):
        PUBLISHER.publish(topic, data)
 
    
    def subscribe(self, listener, *topics):
        for topic in topics:
            PUBLISHER.subscribe(listener, topic)
 
    
    def unsubscribe(self, listener, *topics):
        for topic in topics:
            PUBLISHER.unsubscribe(listener, topic)
 
    
    def unsubscribe_all(self):
        PUBLISHER.unsubscribe_all(self)
 
    
    def register_editor(self, item_class, editor_class, activate=True):
        self.__app__app.register_editor(item_class, editor_class, activate)
 
    
    def unregister_editor(self, item_class, editor_class):
        self.__app__app.unregister_editor(item_class, editor_class)
 
    
    def set_active_editor(self, item_class, editor_class):
        self.__app__app.activate_editor(item_class, editor_class)
 
    
    def get_editors(self, item_class):
        return self.__app__app.get_editors(item_class)
 
    
    def get_editor(self, item_class):
        return self.__app__app.get_editor(item_class)
 
    
    def highlight_cell(self, tcuk, obj=None, row=-1, column=-1):
        if not self.treetree:
            return
        self.treetree.select_node_by_data(tcuk)
        self.__app__app.editor.highlight_cell(obj, row, column)
 
    
    def highlight(self, data, text):
        if not self.treetree:
            return
        self.treetree.highlight(data, text)