Exemple #1
0
class Controller(object):
    def __init__(self, plugin, application):
        self._plugin = plugin
        self._application = application

        self._actions_gui_controller = ActionsGUIController(
            self._application,
            WikiWikiPage.getTypeString(),
        )

    def initialize(self):
        imagesPath = os.path.join(self._plugin.pluginPath, 'images')

        action_gui_info = [
            ActionGUIInfo(ThumbAction(self._application),
                          MENU_WIKI_COMMANDS,
                          ButtonInfo(TOOLBAR_PLUGINS,
                                     os.path.join(imagesPath, 'gallery.png'))
                          ),
        ]

        self._application.onWikiParserPrepare += self._onWikiParserPrepare
        if self._application.mainWindow is not None:
            self._actions_gui_controller.initialize(action_gui_info)

    def destroy(self):
        self._application.onWikiParserPrepare -= self._onWikiParserPrepare
        if self._application.mainWindow is not None:
            self._actions_gui_controller.destroy()

    def _onWikiParserPrepare(self, parser):
        parser.addCommand(ThumbListCommand(parser))
        parser.addCommand(ThumbGalleryCommand(parser))
Exemple #2
0
class Controller(object):
    def __init__(self, application):
        self._application = application

        self._GUIController = ActionsGUIController(
            self._application,
            WikiWikiPage.getTypeString(),
        )

    def initialize(self):
        self._application.onWikiParserPrepare += self._onWikiParserPrepare
        self._initialize_guicontroller()

    def _initialize_guicontroller(self):
        action_gui_info = [
            ActionGUIInfo(LightboxAction(self._application),
                          MENU_WIKI_COMMANDS),
        ]

        if self._application.mainWindow is not None:
            self._GUIController.initialize(action_gui_info)

    def destroy(self):
        self._application.onWikiParserPrepare -= self._onWikiParserPrepare
        self._destroy_guicontroller()

    def _destroy_guicontroller(self):
        if self._application.mainWindow is not None:
            self._GUIController.destroy()

    def _onWikiParserPrepare(self, parser):
        parser.addCommand(LightboxCommand(parser))
Exemple #3
0
class Controller(object):
    def __init__(self, plugin, application):
        self._plugin = plugin
        self._application = application

        self._actions_gui_controller = ActionsGUIController(
            self._application,
            WikiWikiPage.getTypeString(),
        )

    def initialize(self):
        imagesPath = os.path.join(self._plugin.pluginPath, 'images')

        action_gui_info = [
            ActionGUIInfo(
                ThumbAction(self._application), MENU_WIKI_COMMANDS,
                ButtonInfo(TOOLBAR_PLUGINS,
                           os.path.join(imagesPath, 'gallery.png'))),
        ]

        self._application.onWikiParserPrepare += self._onWikiParserPrepare
        if self._application.mainWindow is not None:
            self._actions_gui_controller.initialize(action_gui_info)

    def destroy(self):
        self._application.onWikiParserPrepare -= self._onWikiParserPrepare
        if self._application.mainWindow is not None:
            self._actions_gui_controller.destroy()

    def _onWikiParserPrepare(self, parser):
        parser.addCommand(ThumbListCommand(parser))
        parser.addCommand(ThumbGalleryCommand(parser))
Exemple #4
0
class Controller(object):
    """
    Класс отвечает за основную работу интерфейса плагина
    """

    def __init__(self, plugin, application):
        self._plugin = plugin
        self._application = application

        # В этот список добавить новые викикоманды, если они нужны
        self._commands = [CommandOrg]

        self._GUIController = ActionsGUIController(
            self._application,
            WikiWikiPage.getTypeString(),
        )

    def initialize(self):
        """
        Инициализация контроллера при активации плагина.
        Подписка на нужные события
        """
        global _
        _ = get_()

        self._application.onWikiParserPrepare += self.__onWikiParserPrepare
        self._initialize_guicontroller()

    def _initialize_guicontroller(self):
        imagesPath = os.path.join(self._plugin.pluginPath, 'images')

        action_gui_info = [
            ActionGUIInfo(OrgAction(self._application),
                          MENU_WIKI_COMMANDS,
                          ButtonInfo(TOOLBAR_PLUGINS,
                                     os.path.join(imagesPath, 'org.png'))
                          ),
        ]

        if self._application.mainWindow is not None:
            self._GUIController.initialize(action_gui_info)

    def destroy(self):
        """
        Вызывается при отключении плагина
        """
        self._application.onWikiParserPrepare -= self.__onWikiParserPrepare
        self._destroy_guicontroller()

    def _destroy_guicontroller(self):
        if self._application.mainWindow is not None:
            self._GUIController.destroy()

    def __onWikiParserPrepare(self, parser):
        """
        Вызывается до разбора викитекста. Добавление команды (:org:)
        """
        list(map(lambda command: parser.addCommand(command(parser)),
                 self._commands))
Exemple #5
0
class Controller(object):
    """
    Класс отвечает за основную работу интерфейса плагина
    """
    def __init__(self, plugin, application):
        """
        plugin - Владелец контроллера (экземпляр класса PluginSource)
        application - экземпляр класса ApplicationParams
        """
        self._plugin = plugin
        self._application = application

        self._commands = commands
        self._actions = actions

        self._GUIController = ActionsGUIController(
            self._application,
            WikiWikiPage.getTypeString(),
        )

    def initialize(self):
        """
        Инициализация контроллера при активации плагина.
        Подписка на нужные события
        """
        global _
        _ = get_()

        self._application.onWikiParserPrepare += self.__onWikiParserPrepare
        self._initialize_guicontroller()

    def _initialize_guicontroller(self):
        action_gui_info = [ActionGUIInfo(action(self._application),
                                         defines.MENU_PLUGIN)
                           for action in self._actions]

        new_menus = [(defines.MENU_PLUGIN, _(defines.MENU_PLUGIN_TITLE), MENU_WIKI)]

        if self._application.mainWindow is not None:
            self._GUIController.initialize(action_gui_info,
                                           new_menus=new_menus)

    def destroy(self):
        """
        Вызывается при отключении плагина
        """
        self._application.onWikiParserPrepare -= self.__onWikiParserPrepare
        self._destroy_guicontroller()

    def _destroy_guicontroller(self):
        if self._application.mainWindow is not None:
            self._GUIController.destroy()

    def __onWikiParserPrepare(self, parser):
        """
        Вызывается до разбора викитекста. Добавление команд
        """
        [parser.addCommand(command(parser)) for command in self._commands]
Exemple #6
0
class Controller(object):
    """
    Класс отвечает за основную работу интерфейса плагина
    """
    def __init__(self, plugin, application):
        self._plugin = plugin
        self._application = application

        # В этот список добавить новые викикоманды, если они нужны
        self._commands = [CommandOrg]

        self._GUIController = ActionsGUIController(
            self._application,
            WikiWikiPage.getTypeString(),
        )

    def initialize(self):
        """
        Инициализация контроллера при активации плагина.
        Подписка на нужные события
        """
        global _
        _ = get_()

        self._application.onWikiParserPrepare += self.__onWikiParserPrepare
        self._initialize_guicontroller()

    def _initialize_guicontroller(self):
        imagesPath = os.path.join(self._plugin.pluginPath, 'images')

        action_gui_info = [
            ActionGUIInfo(
                OrgAction(self._application), MENU_WIKI_COMMANDS,
                ButtonInfo(TOOLBAR_PLUGINS,
                           os.path.join(imagesPath, 'org.png'))),
        ]

        if self._application.mainWindow is not None:
            self._GUIController.initialize(action_gui_info)

    def destroy(self):
        """
        Вызывается при отключении плагина
        """
        self._application.onWikiParserPrepare -= self.__onWikiParserPrepare
        self._destroy_guicontroller()

    def _destroy_guicontroller(self):
        if self._application.mainWindow is not None:
            self._GUIController.destroy()

    def __onWikiParserPrepare(self, parser):
        """
        Вызывается до разбора викитекста. Добавление команды (:org:)
        """
        list(
            map(lambda command: parser.addCommand(command(parser)),
                self._commands))
Exemple #7
0
class Controller(object):
    def __init__(self, plugin, application):
        self._plugin = plugin
        self._application = application
        self.__maxCommandIndex = 9

        self._GUIController = ActionsGUIController(
            self._application,
            WikiWikiPage.getTypeString(),
        )

    def initialize(self):
        self._application.onWikiParserPrepare += self._onWikiParserPrepare
        self._initialize_guicontroller()

    def _initialize_guicontroller(self):
        imagesPath = os.path.join(self._plugin.pluginPath, 'images')

        action_gui_info = [
            ActionGUIInfo(SpoilerAction(self._application),
                          MENU_WIKI_COMMANDS,
                          ButtonInfo(TOOLBAR_PLUGINS,
                                     os.path.join(imagesPath, 'spoiler.png'))
                          ),
        ]

        if self._application.mainWindow is not None:
            self._GUIController.initialize(action_gui_info)

    def destroy(self):
        self._application.onWikiParserPrepare -= self._onWikiParserPrepare
        self._destroy_guicontroller()

    def _destroy_guicontroller(self):
        if self._application.mainWindow is not None:
            self._GUIController.destroy()

    def _onWikiParserPrepare(self, parser):
        parser.addCommand(SpoilerCommand(parser, "spoiler", _))

        for index in range(self.__maxCommandIndex + 1):
            commandname = "spoiler{index}".format(index=index)
            parser.addCommand(SpoilerCommand(parser, commandname, _))
Exemple #8
0
class Controller(object):
    def __init__(self, plugin, application):
        self._plugin = plugin
        self._application = application
        self.__maxCommandIndex = 9

        self._GUIController = ActionsGUIController(
            self._application,
            WikiWikiPage.getTypeString(),
        )

    def initialize(self):
        self._application.onWikiParserPrepare += self._onWikiParserPrepare
        self._initialize_guicontroller()

    def _initialize_guicontroller(self):
        imagesPath = os.path.join(self._plugin.pluginPath, 'images')

        action_gui_info = [
            ActionGUIInfo(
                SpoilerAction(self._application), MENU_WIKI_COMMANDS,
                ButtonInfo(TOOLBAR_PLUGINS,
                           os.path.join(imagesPath, 'spoiler.png'))),
        ]

        if self._application.mainWindow is not None:
            self._GUIController.initialize(action_gui_info)

    def destroy(self):
        self._application.onWikiParserPrepare -= self._onWikiParserPrepare
        self._destroy_guicontroller()

    def _destroy_guicontroller(self):
        if self._application.mainWindow is not None:
            self._GUIController.destroy()

    def _onWikiParserPrepare(self, parser):
        parser.addCommand(SpoilerCommand(parser, "spoiler", _))

        for index in range(self.__maxCommandIndex + 1):
            commandname = "spoiler{index}".format(index=index)
            parser.addCommand(SpoilerCommand(parser, commandname, _))
Exemple #9
0
class Controller(object):
    """
    Класс отвечает за основную работу интерфейса плагина
    """

    def __init__(self, plugin, application):
        """
        plugin - Владелец контроллера(экземпляр класса PluginSource)
        application - экземпляр класса ApplicationParams
        """
        self._plugin = plugin
        self._application = application

        self._GUIController = ActionsGUIController(
            self._application,
            WikiWikiPage.getTypeString(),
        )

    def initialize(self):
        """
        Инициализация контроллера при активации плагина.
        Подписка на нужные события
        """
        global _
        _ = get_()

        self._application.onWikiParserPrepare += self.__onWikiParserPrepare
        self._application.onPreferencesDialogCreate += self.__onPreferencesDialogCreate
        self._initialize_guicontroller()

    def _initialize_guicontroller(self):
        imagesPath = os.path.join(self._plugin.pluginPath, 'images')

        action_gui_info = [
            ActionGUIInfo(InsertSourceAction(self._application),
                          MENU_WIKI_COMMANDS,
                          ButtonInfo(TOOLBAR_PLUGINS,
                                     os.path.join(imagesPath, 'source.png'))
                          ),
        ]

        if self._application.mainWindow is not None:
            self._GUIController.initialize(action_gui_info)

    def destroy(self):
        """
        Вызывается при отключении плагина
        """
        self._application.onWikiParserPrepare -= self.__onWikiParserPrepare
        self._application.onPreferencesDialogCreate -= self.__onPreferencesDialogCreate
        self._destroy_guicontroller()

    def _destroy_guicontroller(self):
        if self._application.mainWindow is not None:
            self._GUIController.destroy()

    def __onWikiParserPrepare(self, parser):
        """
        Вызывается до разбора викитекста. Добавление команды(:source:)
        """
        from .commandsource import CommandSource
        parser.addCommand(CommandSource(parser, self._application.config))

    def __onPreferencesDialogCreate(self, dialog):
        """
        Добавление страницы с настройками
        """
        prefPanel = PreferencePanel(dialog.treeBook, self._application.config)

        panelName = _(u"Source [Plugin]")
        panelsList = [PreferencePanelInfo(prefPanel, panelName)]
        dialog.appendPreferenceGroup(panelName, panelsList)
Exemple #10
0
class Controller(object):
    """
    Класс отвечает за основную работу интерфейса плагина
    """
    def __init__(self, plugin, application):
        """
        plugin - Владелец контроллера(экземпляр класса PluginSource)
        application - экземпляр класса ApplicationParams
        """
        self._plugin = plugin
        self._application = application

        self._commands = [TitleCommand,
                          DescriptionCommand,
                          KeywordsCommand,
                          StyleCommand,
                          CustomHeadsCommand]

        self._GUIController = ActionsGUIController(
            self._application,
            WikiWikiPage.getTypeString(),
        )

    def initialize(self):
        """
        Инициализация контроллера при активации плагина.
        Подписка на нужные события
        """
        global _
        _ = get_()

        self._application.onWikiParserPrepare += self.__onWikiParserPrepare
        self._initialize_guicontroller()

    def _initialize_guicontroller(self):
        action_gui_info = [
            ActionGUIInfo(StyleAction(self._application),
                          defines.MENU_HTMLHEADS,
                          ),
            ActionGUIInfo(TitleAction(self._application),
                          defines.MENU_HTMLHEADS,
                          ),
            ActionGUIInfo(DescriptionAction(self._application),
                          defines.MENU_HTMLHEADS,
                          ),
            ActionGUIInfo(KeywordsAction(self._application),
                          defines.MENU_HTMLHEADS,
                          ),
            ActionGUIInfo(CustomHeadsAction(self._application),
                          defines.MENU_HTMLHEADS,
                          ),
        ]

        new_menus = [(defines.MENU_HTMLHEADS, _('HTML Headers'), MENU_WIKI)]

        if self._application.mainWindow is not None:
            self._GUIController.initialize(action_gui_info,
                                           new_menus=new_menus)

    def destroy(self):
        """
        Вызывается при отключении плагина
        """
        self._application.onWikiParserPrepare -= self.__onWikiParserPrepare
        self._destroy_guicontroller()

    def _destroy_guicontroller(self):
        if self._application.mainWindow is not None:
            self._GUIController.destroy()

    def __onWikiParserPrepare(self, parser):
        """
        Вызывается до разбора викитекста. Добавление команды(:counter:)
        """
        list(map(lambda command: parser.addCommand(command(parser)),
                 self._commands))
Exemple #11
0
class Controller(object):
    """
    Класс отвечает за основную работу интерфейса плагина
    """
    def __init__(self, plugin, application):
        """
        """
        self._plugin = plugin
        self._application = application

        self._GUIController = ActionsGUIController(
            self._application,
            WikiWikiPage.getTypeString(),
        )

        # В этот список добавить новые викикоманды, если они нужны
        self._commands = [PlotCommand]

    def initialize(self):
        """
        Инициализация контроллера при активации плагина.
        Подписка на нужные события
        """
        global _
        _ = get_()

        self._application.onWikiParserPrepare += self.__onWikiParserPrepare
        self._initialize_guicontroller()

    def _initialize_guicontroller(self):
        imagesPath = os.path.join(self._plugin.pluginPath, 'images')

        action_gui_info = [
            ActionGUIInfo(PlotAction(self._application),
                          defines.MENU_DATAGRAPH,
                          ButtonInfo(defines.TOOLBAR_DATAGRAPH,
                                     os.path.join(imagesPath, 'plot.png'))
                          ),
            ActionGUIInfo(OpenHelpAction(self._application),
                          defines.MENU_DATAGRAPH,
                          ButtonInfo(defines.TOOLBAR_DATAGRAPH,
                                     os.path.join(imagesPath, 'help.png'))
                          ),
        ]

        new_toolbars = [(defines.TOOLBAR_DATAGRAPH, _('DataGraph'))]
        new_menus = [(defines.MENU_DATAGRAPH, _('DataGraph'), MENU_WIKI)]

        if self._application.mainWindow is not None:
            self._GUIController.initialize(action_gui_info,
                                           new_toolbars,
                                           new_menus)

    def destroy(self):
        """
        Вызывается при отключении плагина
        """
        self._application.onWikiParserPrepare -= self.__onWikiParserPrepare
        self._destroy_guicontroller()

    def _destroy_guicontroller(self):
        if self._application.mainWindow is not None:
            self._GUIController.destroy()

    def __onWikiParserPrepare(self, parser):
        """
        Вызывается до разбора викитекста. Добавление команды (:plot:)
        """
        [*map(lambda command: parser.addCommand(command(parser)),
              self._commands)]
Exemple #12
0
class Controller(object):
    """
    Класс отвечает за основную работу интерфейса плагина
    """
    def __init__(self, plugin, application):
        """
        plugin - Владелец контроллера(экземпляр класса PluginSource)
        application - экземпляр класса ApplicationParams
        """
        self._plugin = plugin
        self._application = application

        self._commands = [
            TitleCommand, DescriptionCommand, KeywordsCommand, StyleCommand,
            CustomHeadsCommand
        ]

        self._GUIController = ActionsGUIController(
            self._application,
            WikiWikiPage.getTypeString(),
        )

    def initialize(self):
        """
        Инициализация контроллера при активации плагина.
        Подписка на нужные события
        """
        global _
        _ = get_()

        self._application.onWikiParserPrepare += self.__onWikiParserPrepare
        self._initialize_guicontroller()

    def _initialize_guicontroller(self):
        action_gui_info = [
            ActionGUIInfo(
                StyleAction(self._application),
                defines.MENU_HTMLHEADS,
            ),
            ActionGUIInfo(
                TitleAction(self._application),
                defines.MENU_HTMLHEADS,
            ),
            ActionGUIInfo(
                DescriptionAction(self._application),
                defines.MENU_HTMLHEADS,
            ),
            ActionGUIInfo(
                KeywordsAction(self._application),
                defines.MENU_HTMLHEADS,
            ),
            ActionGUIInfo(
                CustomHeadsAction(self._application),
                defines.MENU_HTMLHEADS,
            ),
        ]

        new_menus = [(defines.MENU_HTMLHEADS, _('HTML Headers'), MENU_WIKI)]

        if self._application.mainWindow is not None:
            self._GUIController.initialize(action_gui_info,
                                           new_menus=new_menus)

    def destroy(self):
        """
        Вызывается при отключении плагина
        """
        self._application.onWikiParserPrepare -= self.__onWikiParserPrepare
        self._destroy_guicontroller()

    def _destroy_guicontroller(self):
        if self._application.mainWindow is not None:
            self._GUIController.destroy()

    def __onWikiParserPrepare(self, parser):
        """
        Вызывается до разбора викитекста. Добавление команды(:counter:)
        """
        list(
            map(lambda command: parser.addCommand(command(parser)),
                self._commands))
Exemple #13
0
class Controller(object):
    """
    Этот класс отвечает за основную работу плагина
    """
    def __init__(self, plugin, application):
        self._plugin = plugin
        self._application = application

        self._page = None
        self._menuToolsController = MenuToolsController(self._application)
        self._commandController = CommandController(self._application)

        self._GUIController = ActionsGUIController(
            self._application,
            WikiWikiPage.getTypeString(),
        )

    def initialize(self):
        global _
        _ = get_()

        self._menuToolsController.initialize()
        self._commandController.initialize()
        self._initialize_guicontroller()
        self._application.onPreferencesDialogCreate += self.__onPreferencesDialogCreate

    def _initialize_guicontroller(self):
        action_gui_info = [
            ActionGUIInfo(CommandExecAction(self._application),
                          defines.MENU_EXTERNALTOOLS),
            ActionGUIInfo(MacrosPageAction(self._application),
                          defines.MENU_EXTERNALTOOLS),
            ActionGUIInfo(MacrosHtmlAction(self._application),
                          defines.MENU_EXTERNALTOOLS),
            ActionGUIInfo(MacrosAttachAction(self._application),
                          defines.MENU_EXTERNALTOOLS),
            ActionGUIInfo(MacrosFolderAction(self._application),
                          defines.MENU_EXTERNALTOOLS),
        ]
        new_menus = [(defines.MENU_EXTERNALTOOLS, _('ExternalTools'),
                      MENU_WIKI)]

        if self._application.mainWindow is not None:
            self._GUIController.initialize(action_gui_info,
                                           new_menus=new_menus)

    def destroy(self):
        self._menuToolsController.destroy()
        self._commandController.destroy()
        self._destroy_guicontroller()
        self._application.onPreferencesDialogCreate -= self.__onPreferencesDialogCreate

    def _destroy_guicontroller(self):
        if self._application.mainWindow is not None:
            self._GUIController.destroy()

    def __onPreferencesDialogCreate(self, dialog):
        from .preferencespanel import PreferencesPanel
        prefPanel = PreferencesPanel(dialog.treeBook, self._application.config)

        panelName = _(u"External Tools [Plugin]")
        panelsList = [PreferencePanelInfo(prefPanel, panelName)]
        dialog.appendPreferenceGroup(panelName, panelsList)
Exemple #14
0
class Controller(object):
    """
    Класс отвечает за основную работу интерфейса плагина
    """
    def __init__(self, plugin, application):
        """
        """
        self._plugin = plugin
        self._application = application

        # В этот список добавить новые викикоманды, если они нужны
        self._commands = [TOCCommand]

        self._GUIController = ActionsGUIController(
            self._application,
            WikiWikiPage.getTypeString(),
        )

    def initialize(self):
        """
        Инициализация контроллера при активации плагина.
        Подписка на нужные события
        """
        global _
        _ = get_()

        self._application.onWikiParserPrepare += self.__onWikiParserPrepare
        self._initialize_guicontroller()

    def _initialize_guicontroller(self):
        action_gui_info = [
            ActionGUIInfo(GenerateTOC(self._application), defines.MENU_TOC),
            ActionGUIInfo(InsertTOCCommand(self._application),
                          defines.MENU_TOC),
        ]

        new_menus = [(defines.MENU_TOC, _('Table of contents'), MENU_WIKI)]

        if self._application.mainWindow is not None:
            self._GUIController.initialize(action_gui_info,
                                           new_menus=new_menus)

    def destroy(self):
        """
        Вызывается при отключении плагина
        """
        self._application.onWikiParserPrepare -= self.__onWikiParserPrepare
        self._destroy_guicontroller()

    def _destroy_guicontroller(self):
        if self._application.mainWindow is not None:
            self._GUIController.destroy()

    def __onWikiParserPrepare(self, parser):
        """
        Вызывается до разбора викитекста. Добавление команды(:counter:)
        """
        list(
            map(
                lambda command: parser.addCommand(
                    command(parser, self._application)), self._commands))
Exemple #15
0
class Controller(object):
    """
    Класс отвечает за основную работу интерфейса плагина
    """
    def __init__(self, plugin, application):
        """
        """
        self._plugin = plugin
        self._application = application

        self._GUIController = ActionsGUIController(
            self._application,
            WikiWikiPage.getTypeString(),
        )

        # В этот список добавить новые викикоманды, если они нужны
        self._commands = [PlotCommand]

    def initialize(self):
        """
        Инициализация контроллера при активации плагина.
        Подписка на нужные события
        """
        global _
        _ = get_()

        self._application.onWikiParserPrepare += self.__onWikiParserPrepare
        self._initialize_guicontroller()

    def _initialize_guicontroller(self):
        imagesPath = os.path.join(self._plugin.pluginPath, 'images')

        action_gui_info = [
            ActionGUIInfo(
                PlotAction(self._application), defines.MENU_DATAGRAPH,
                ButtonInfo(defines.TOOLBAR_DATAGRAPH,
                           os.path.join(imagesPath, 'plot.png'))),
            ActionGUIInfo(
                OpenHelpAction(self._application), defines.MENU_DATAGRAPH,
                ButtonInfo(defines.TOOLBAR_DATAGRAPH,
                           os.path.join(imagesPath, 'help.png'))),
        ]

        new_toolbars = [(defines.TOOLBAR_DATAGRAPH, _('DataGraph'))]
        new_menus = [(defines.MENU_DATAGRAPH, _('DataGraph'), MENU_WIKI)]

        if self._application.mainWindow is not None:
            self._GUIController.initialize(action_gui_info, new_toolbars,
                                           new_menus)

    def destroy(self):
        """
        Вызывается при отключении плагина
        """
        self._application.onWikiParserPrepare -= self.__onWikiParserPrepare
        self._destroy_guicontroller()

    def _destroy_guicontroller(self):
        if self._application.mainWindow is not None:
            self._GUIController.destroy()

    def __onWikiParserPrepare(self, parser):
        """
        Вызывается до разбора викитекста. Добавление команды (:plot:)
        """
        [
            *map(lambda command: parser.addCommand(command(parser)),
                 self._commands)
        ]
Exemple #16
0
class Controller(object):
    """
    Класс отвечает за основную работу интерфейса плагина
    """
    def __init__(self, plugin, application):
        """
        """
        self._plugin = plugin
        self._application = application

        self._GUIController = ActionsGUIController(
            self._application,
            WikiWikiPage.getTypeString(),
        )

    def initialize(self):
        """
        Инициализация контроллера при активации плагина.
        Подписка на нужные события
        """
        global _
        _ = get_()

        self._application.onWikiParserPrepare += self.__onWikiParserPrepare
        self._initialize_guicontroller()

    def _initialize_guicontroller(self):
        imagesPath = os.path.join(self._plugin.pluginPath, 'images')

        action_gui_info = [
            ActionGUIInfo(
                TexEquationAction(self._application), MENU_WIKI_COMMANDS,
                ButtonInfo(TOOLBAR_PLUGINS,
                           os.path.join(imagesPath, 'equation.png'))),
        ]

        if self._application.mainWindow is not None:
            self._GUIController.initialize(action_gui_info)

    def destroy(self):
        """
        Вызывается при отключении плагина
        """
        self._application.onWikiParserPrepare -= self.__onWikiParserPrepare
        self._destroy_guicontroller()

    def _destroy_guicontroller(self):
        if self._application.mainWindow is not None:
            self._GUIController.destroy()

    def __onWikiParserPrepare(self, parser):
        from .tokentex import TexFactory
        tex_inline = TexFactory().makeInlineTexToken(parser)
        tex_big = TexFactory().makeBigTexToken(parser)

        parser.wikiTokens.append(tex_big)
        parser.wikiTokens.append(tex_inline)

        parser.linkTokens.append(tex_big)
        parser.linkTokens.append(tex_inline)

        parser.headingTokens.append(tex_big)
        parser.headingTokens.append(tex_inline)

        parser.textLevelTokens.append(tex_big)
        parser.textLevelTokens.append(tex_inline)

        parser.listItemsTokens.append(tex_big)
        parser.listItemsTokens.append(tex_inline)
Exemple #17
0
class Controller(object):
    def __init__(self, plugin, application):
        self._plugin = plugin
        self._application = application

        self._GUIController = ActionsGUIController(
            self._application,
            WikiWikiPage.getTypeString(),
        )

    def initialize(self):
        """
        Инициализация плагина
        """
        global _
        _ = get_()

        self._application.onWikiParserPrepare += self.__onWikiParserPrepare
        self._initialize_guicontroller()

    def _initialize_guicontroller(self):
        imagesPath = os.path.join(self._plugin.pluginPath, 'images')

        action_gui_info = [
            ActionGUIInfo(LJUserAction(self._application),
                          defines.MENU_LIVEJOURNAL,
                          ButtonInfo(defines.TOOLBAR_LIVEJOURNAL,
                                     os.path.join(imagesPath, 'ljuser.gif'))
                          ),
            ActionGUIInfo(LJCommAction(self._application),
                          defines.MENU_LIVEJOURNAL,
                          ButtonInfo(defines.TOOLBAR_LIVEJOURNAL,
                                     os.path.join(imagesPath, 'ljcommunity.gif'))
                          ),
        ]

        new_toolbars = [(defines.TOOLBAR_LIVEJOURNAL, _('LiveJournal'))]
        new_menus = [(defines.MENU_LIVEJOURNAL, _('LiveJournal'), MENU_WIKI)]

        if self._application.mainWindow is not None:
            self._GUIController.initialize(action_gui_info,
                                           new_toolbars,
                                           new_menus)

    def destroy(self):
        """
        Уничтожение(выгрузка) плагина.
        Здесь плагин должен отписаться от всех событий
        """
        self._application.onWikiParserPrepare -= self.__onWikiParserPrepare
        self._destroy_guicontroller()

    def _destroy_guicontroller(self):
        if self._application.mainWindow is not None:
            self._GUIController.destroy()

    def __onWikiParserPrepare(self, parser):
        """
        Добавление команд в википарсер
        """
        parser.addCommand(LjUserCommand(parser))
        parser.addCommand(LjCommunityCommand(parser))
Exemple #18
0
class Controller(object):
    """
    Класс отвечает за основную работу интерфейса плагина
    """
    def __init__(self, plugin, application):
        """
        """
        self._plugin = plugin
        self._application = application

        # В этот список добавить новые викикоманды, если они нужны
        self._commands = [CommandDiagram]

        self._GUIController = ActionsGUIController(
            self._application,
            WikiWikiPage.getTypeString(),
        )

    def initialize(self):
        """
        Инициализация контроллера при активации плагина.
        Подписка на нужные события
        """
        global _
        _ = get_()

        DiagramRender.initialize()
        self._initialize_guicontroller()

        self._application.onWikiParserPrepare += self.__onWikiParserPrepare

    def _initialize_guicontroller(self):
        imagesPath = os.path.join(self._plugin.pluginPath, 'images')

        action_gui_info = [
            ActionGUIInfo(InsertDiagramAction(self._application),
                          defines.MENU_DIAGRAMMER,
                          ButtonInfo(defines.TOOLBAR_DIAGRAMMER,
                                     os.path.join(imagesPath, 'diagram.png'))
                          ),
            ActionGUIInfo(InsertNodeAction(self._application),
                          defines.MENU_DIAGRAMMER,
                          ButtonInfo(defines.TOOLBAR_DIAGRAMMER,
                                     os.path.join(imagesPath, 'node.png'))
                          ),
            ActionGUIInfo(InsertGroupAction(self._application),
                          defines.MENU_DIAGRAMMER,
                          ButtonInfo(defines.TOOLBAR_DIAGRAMMER,
                                     os.path.join(imagesPath, 'group.png'))
                          ),
            ActionGUIInfo(InsertEdgeNoneAction(self._application),
                          defines.MENU_DIAGRAMMER,
                          ButtonInfo(defines.TOOLBAR_DIAGRAMMER,
                                     os.path.join(imagesPath, 'edge-none.png'))
                          ),
            ActionGUIInfo(InsertEdgeLeftAction(self._application),
                          defines.MENU_DIAGRAMMER,
                          ButtonInfo(defines.TOOLBAR_DIAGRAMMER,
                                     os.path.join(imagesPath, 'edge-left.png'))
                          ),
            ActionGUIInfo(InsertEdgeRightAction(self._application),
                          defines.MENU_DIAGRAMMER,
                          ButtonInfo(defines.TOOLBAR_DIAGRAMMER,
                                     os.path.join(imagesPath, 'edge-right.png'))
                          ),
            ActionGUIInfo(InsertEdgeBothAction(self._application),
                          defines.MENU_DIAGRAMMER,
                          ButtonInfo(defines.TOOLBAR_DIAGRAMMER,
                                     os.path.join(imagesPath, 'edge-both.png'))
                          ),
            ActionGUIInfo(HelpAction(self._application),
                          defines.MENU_DIAGRAMMER,
                          ButtonInfo(defines.TOOLBAR_DIAGRAMMER,
                                     os.path.join(imagesPath, 'help.png'))
                          ),
        ]

        new_toolbars = [(defines.TOOLBAR_DIAGRAMMER, _('Diagrammer'))]
        new_menus = [(defines.MENU_DIAGRAMMER, _('Diagrammer'), MENU_WIKI)]

        if self._application.mainWindow is not None:
            self._GUIController.initialize(action_gui_info,
                                           new_toolbars,
                                           new_menus)

    def destroy(self):
        """
        Вызывается при отключении плагина
        """
        self._application.onWikiParserPrepare -= self.__onWikiParserPrepare
        self._destroy_guicontroller()

    def _destroy_guicontroller(self):
        if self._application.mainWindow is not None:
            self._GUIController.destroy()

    def __onWikiParserPrepare(self, parser):
        """
        Вызывается до разбора викитекста. Добавление команды(:counter:)
        """
        [*map(lambda command: parser.addCommand(command(parser)),
              self._commands)]
Exemple #19
0
class Controller(object):
    """
    Класс отвечает за основную работу интерфейса плагина
    """

    def __init__(self, plugin, application):
        """
        """
        self._plugin = plugin
        self._application = application

        # В этот список добавить новые викикоманды, если они нужны
        self._commands = [TOCCommand]

        self._GUIController = ActionsGUIController(
            self._application,
            WikiWikiPage.getTypeString(),
        )

    def initialize(self):
        """
        Инициализация контроллера при активации плагина.
        Подписка на нужные события
        """
        global _
        _ = get_()

        self._application.onWikiParserPrepare += self.__onWikiParserPrepare
        self._initialize_guicontroller()

    def _initialize_guicontroller(self):
        action_gui_info = [
            ActionGUIInfo(GenerateTOC(self._application),
                          defines.MENU_TOC),
            ActionGUIInfo(InsertTOCCommand(self._application),
                          defines.MENU_TOC),
        ]

        new_menus = [(defines.MENU_TOC, _('Table of contents'), MENU_WIKI)]

        if self._application.mainWindow is not None:
            self._GUIController.initialize(action_gui_info,
                                           new_menus=new_menus)

    def destroy(self):
        """
        Вызывается при отключении плагина
        """
        self._application.onWikiParserPrepare -= self.__onWikiParserPrepare
        self._destroy_guicontroller()

    def _destroy_guicontroller(self):
        if self._application.mainWindow is not None:
            self._GUIController.destroy()

    def __onWikiParserPrepare(self, parser):
        """
        Вызывается до разбора викитекста. Добавление команды(:counter:)
        """
        list(map(lambda command: parser.addCommand(command(parser, self._application)),
                 self._commands))
Exemple #20
0
class Controller(object):
    """
    Класс отвечает за основную работу интерфейса плагина
    """
    def __init__(self, plugin, application):
        """
        plugin - Владелец контроллера(экземпляр класса PluginSource)
        application - экземпляр класса ApplicationParams
        """
        self._plugin = plugin
        self._application = application

        self._GUIController = ActionsGUIController(
            self._application,
            WikiWikiPage.getTypeString(),
        )

    def initialize(self):
        """
        Инициализация контроллера при активации плагина.
        Подписка на нужные события
        """
        global _
        _ = get_()

        self._application.onWikiParserPrepare += self.__onWikiParserPrepare
        self._initialize_guicontroller()

    def _initialize_guicontroller(self):
        imagesPath = os.path.join(self._plugin.pluginPath, 'images')

        action_gui_info = [
            ActionGUIInfo(InsertCounterAction(self._application, self),
                          MENU_WIKI_COMMANDS,
                          ButtonInfo(TOOLBAR_PLUGINS,
                                     os.path.join(imagesPath, 'counter.png'))
                          ),
        ]

        if self._application.mainWindow is not None:
            self._GUIController.initialize(action_gui_info)

    def destroy(self):
        """
        Вызывается при отключении плагина
        """
        self._application.onWikiParserPrepare -= self.__onWikiParserPrepare
        self._destroy_guicontroller()

    def _destroy_guicontroller(self):
        if self._application.mainWindow is not None:
            self._GUIController.destroy()

    def __onWikiParserPrepare(self, parser):
        """
        Вызывается до разбора викитекста. Добавление команды(:counter:)
        """
        parser.addCommand(CommandCounter(parser))

    @testreadonly
    def insertCommand(self):
        """
        Вставка команды(:counter:) в редактор
        """
        if self._application.selectedPage.readonly:
            raise outwiker.core.exceptions.ReadonlyException

        dlg = InsertDialog(self._application.mainWindow)

        dlgController = InsertDialogController(dlg,
                                               self._application.config,
                                               self._application.selectedPage)

        resultDlg = dlgController.showDialog()

        if resultDlg == wx.ID_OK:
            command = dlgController.getCommandString()
            self._getPageView().codeEditor.replaceText(command)

        dlg.Destroy()

    def _getPageView(self):
        """
        Получить указатель на панель представления страницы
        """
        return self._application.mainWindow.pageView
Exemple #21
0
class Controller(object):
    """
    Класс отвечает за основную работу интерфейса плагина
    """
    def __init__(self, plugin, application):
        """
        """
        self._plugin = plugin
        self._application = application

        # В этот список добавить новые викикоманды, если они нужны
        self._commands = [CommandDiagram]

        self._GUIController = ActionsGUIController(
            self._application,
            WikiWikiPage.getTypeString(),
        )

    def initialize(self):
        """
        Инициализация контроллера при активации плагина.
        Подписка на нужные события
        """
        global _
        _ = get_()

        DiagramRender.initialize()
        self._initialize_guicontroller()

        self._application.onWikiParserPrepare += self.__onWikiParserPrepare

    def _initialize_guicontroller(self):
        imagesPath = os.path.join(self._plugin.pluginPath, 'images')

        action_gui_info = [
            ActionGUIInfo(
                InsertDiagramAction(self._application),
                defines.MENU_DIAGRAMMER,
                ButtonInfo(defines.TOOLBAR_DIAGRAMMER,
                           os.path.join(imagesPath, 'diagram.png'))),
            ActionGUIInfo(
                InsertNodeAction(self._application), defines.MENU_DIAGRAMMER,
                ButtonInfo(defines.TOOLBAR_DIAGRAMMER,
                           os.path.join(imagesPath, 'node.png'))),
            ActionGUIInfo(
                InsertGroupAction(self._application), defines.MENU_DIAGRAMMER,
                ButtonInfo(defines.TOOLBAR_DIAGRAMMER,
                           os.path.join(imagesPath, 'group.png'))),
            ActionGUIInfo(
                InsertEdgeNoneAction(self._application),
                defines.MENU_DIAGRAMMER,
                ButtonInfo(defines.TOOLBAR_DIAGRAMMER,
                           os.path.join(imagesPath, 'edge-none.png'))),
            ActionGUIInfo(
                InsertEdgeLeftAction(self._application),
                defines.MENU_DIAGRAMMER,
                ButtonInfo(defines.TOOLBAR_DIAGRAMMER,
                           os.path.join(imagesPath, 'edge-left.png'))),
            ActionGUIInfo(
                InsertEdgeRightAction(self._application),
                defines.MENU_DIAGRAMMER,
                ButtonInfo(defines.TOOLBAR_DIAGRAMMER,
                           os.path.join(imagesPath, 'edge-right.png'))),
            ActionGUIInfo(
                InsertEdgeBothAction(self._application),
                defines.MENU_DIAGRAMMER,
                ButtonInfo(defines.TOOLBAR_DIAGRAMMER,
                           os.path.join(imagesPath, 'edge-both.png'))),
            ActionGUIInfo(
                HelpAction(self._application), defines.MENU_DIAGRAMMER,
                ButtonInfo(defines.TOOLBAR_DIAGRAMMER,
                           os.path.join(imagesPath, 'help.png'))),
        ]

        new_toolbars = [(defines.TOOLBAR_DIAGRAMMER, _('Diagrammer'))]
        new_menus = [(defines.MENU_DIAGRAMMER, _('Diagrammer'), MENU_WIKI)]

        if self._application.mainWindow is not None:
            self._GUIController.initialize(action_gui_info, new_toolbars,
                                           new_menus)

    def destroy(self):
        """
        Вызывается при отключении плагина
        """
        self._application.onWikiParserPrepare -= self.__onWikiParserPrepare
        self._destroy_guicontroller()

    def _destroy_guicontroller(self):
        if self._application.mainWindow is not None:
            self._GUIController.destroy()

    def __onWikiParserPrepare(self, parser):
        """
        Вызывается до разбора викитекста. Добавление команды(:counter:)
        """
        [
            *map(lambda command: parser.addCommand(command(parser)),
                 self._commands)
        ]
Exemple #22
0
class Controller(object):
    """
    Класс отвечает за основную работу интерфейса плагина
    """
    def __init__(self, plugin, application):
        """
        """
        self._plugin = plugin
        self._application = application

        self._GUIController = ActionsGUIController(
            self._application,
            WikiWikiPage.getTypeString(),
        )
        self._toolsWindowController = ToolsWindowController(self._application)

    def initialize(self):
        """
        Инициализация контроллера при активации плагина.
        Подписка на нужные события
        """
        global _
        _ = get_()

        self._application.onWikiParserPrepare += self.__onWikiParserPrepare
        self._application.onPreferencesDialogCreate += self.__onPreferencesDialogCreate
        self._initialize_guicontroller()

        if self._application.mainWindow is not None:
            self._toolsWindowController.initialize()

    def _initialize_guicontroller(self):
        imagesPath = os.path.join(self._plugin.pluginPath, 'images')

        action_gui_info = [
            ActionGUIInfo(TexEquationAction(self._application),
                          MENU_WIKI_COMMANDS,
                          ButtonInfo(TOOLBAR_PLUGINS,
                                     os.path.join(imagesPath, 'equation.png'))
                          ),
        ]

        if self._application.mainWindow is not None:
            self._GUIController.initialize(action_gui_info)

    def destroy(self):
        """
        Вызывается при отключении плагина
        """
        self._application.onWikiParserPrepare -= self.__onWikiParserPrepare
        self._application.onPreferencesDialogCreate -= self.__onPreferencesDialogCreate
        self._destroy_guicontroller()

        if self._application.mainWindow is not None:
            self._toolsWindowController.destroy()

    def _destroy_guicontroller(self):
        if self._application.mainWindow is not None:
            self._GUIController.destroy()

    def __onWikiParserPrepare(self, parser):
        from .tokentex import TexFactory
        tex_inline = TexFactory().makeInlineTexToken(parser)
        tex_big = TexFactory().makeBigTexToken(parser)

        parser.wikiTokens.append(tex_big)
        parser.wikiTokens.append(tex_inline)

        parser.linkTokens.append(tex_big)
        parser.linkTokens.append(tex_inline)

        parser.headingTokens.append(tex_big)
        parser.headingTokens.append(tex_inline)

        parser.textLevelTokens.append(tex_big)
        parser.textLevelTokens.append(tex_inline)

        parser.listItemsTokens.append(tex_big)
        parser.listItemsTokens.append(tex_inline)

    def __onPreferencesDialogCreate(self, dialog):
        """
        Add page to preferences dialog
        """
        prefPanel = PreferencePanel(dialog.treeBook, self._application.config)

        panelName = _(u"TeXEquation [Plugin]")
        panelsList = [PreferencePanelInfo(prefPanel, panelName)]
        dialog.appendPreferenceGroup(panelName, panelsList)