Example #1
0
        def __init__(self, parent=None, **kw):
            """
            Initialize the main widget.
            :param parent:
            :param kw:
            :return:
            """
            QtGui.QWidget.__init__(self, parent)
            LoggingConfigurable.__init__(self, **kw)

            self.main_content = tab_content_template(edit_class)(self.is_complete, editor=self.editor)
            self.main_content.please_export.connect(self.export)
            # MainContent -> export

            # Import and handle kernel messages
            # message_arrived -> Importer -> MainContent
            self._importer = Importer(self)
            self.message_arrived.connect(self._importer.convert)
            self._importer.please_process.connect(self.main_content.post)
            self._importer.please_export.connect(self.export)

            layout = QtGui.QHBoxLayout(self)
            layout.setContentsMargins(0, 0, 0, 0)
            layout.addWidget(self.main_content)

            # Set flag for whether we are connected via localhost.
            self.local_kernel = kw.get('local_kernel', TabMain.local_kernel)
Example #2
0
        def __init__(self, is_complete, editor=default_editor, **kwargs):
            """
            Initialize
            :param is_complete: function str->(bool, str) that checks whether the input is complete code
            :param kwargs: arguments for LoggingConfigurable
            :return:
            """
            QtGui.QSplitter.__init__(self, QtCore.Qt.Horizontal)
            LoggingConfigurable.__init__(self, **kwargs)
            # Layout overview:
            # pager_top
            # receiver  |      pager_right
            #           | pager_inside
            # entry     |

            self.editor = editor

            self._console_stack = QtGui.QWidget()
            self._console_stack_layout = QtGui.QStackedLayout()
            self._console_stack.setLayout(self._console_stack_layout)
            self.addWidget(self._console_stack)

            self._console_area = QtGui.QSplitter(QtCore.Qt.Vertical)
            self._console_stack_layout.addWidget(self._console_area)

            self.entry = entry_template(edit_class)(is_complete=is_complete, use_ansi=self.ansi_codes)
            self.entry.please_export.connect(self.please_export)
            self.history = self.entry.history

            self.receiver = receiver_template(edit_class)(use_ansi=self.ansi_codes, show_users=self.show_users)
            self.receiver.please_export.connect(self.please_export)

            self._console_area.addWidget(self.receiver)
            self._console_area.addWidget(self.entry)

            self.print_action = self.receiver.print_action
            self.export_action = self.receiver.export_action
            self.select_all_action = self.receiver.select_all_action
            self.increase_font_size = self.receiver.increase_font_size
            self.decrease_font_size = self.receiver.decrease_font_size
            self.reset_font_size = self.receiver.reset_font_size

            self._pager_targets = [
                ('right', {'target': self, 'index': 1}),
                ('top', {'target': self._console_area, 'index': 0}),
                ('inside', {'target': self._console_stack_layout, 'index': 1})
            ]

            self.pager = pager_template(edit_class)(self._pager_targets, self.default_pager_location,
                                                    'This is the pager!', use_ansi=self.ansi_codes)
            self.pager.hide()

            self.pager.release_focus.connect(self.entry.set_focus)
            self.receiver.release_focus.connect(self.entry.set_focus)
            self.entry.release_focus.connect(self.receiver.set_focus)

            self.line_prompt = LinePrompt()
            self.line_prompt.text_input.connect(self.on_text_input)

            self.show_users = self.receiver.text_register.get_visible()
Example #3
0
        def __init__(self, is_complete, use_ansi, parent=None, **kwargs):
            QtGui.QWidget.__init__(self, parent)
            LoggingConfigurable.__init__(self, **kwargs)
            self._layout = NamedStackedLayout(self)
            self._layout.currentChanged.connect(self._on_current_changed)

            self._frame_color = dict()

            name = 'Code'
            self._frame_color[name] = code_active_color
            self.code_area = code_area_template(edit_class)(is_complete=is_complete, use_ansi=use_ansi,
                                                            comment_prefix=self.comment_prefix)
            self.code_area.to_next.connect(self.move)
            self.code_area.please_export.connect(self.please_export)
            self.code_area.release_focus.connect(self.release_focus)
            self._layout.insert_widget(0, self.code_area, name)
            self.switch(name)

            name = 'Chat'
            self._frame_color[name] = chat_active_color
            self.chat_area = chat_area_template(edit_class)(comment_prefix=self.comment_prefix)
            self.chat_area.to_next.connect(self.move)
            self.chat_area.please_export.connect(self.please_export)
            self.chat_area.release_focus.connect(self.release_focus)
            self._layout.insert_widget(0, self.chat_area, 'Chat')

            self.setFrameStyle(QtGui.QFrame.Box | QtGui.QFrame.Plain)
            self.setLineWidth(2)
Example #4
0
    def __init__(self, kernel, client, stream, session, channel, **kwargs):
        Thread.__init__(self, **kwargs)
        LoggingConfigurable.__init__(self, **kwargs)

        self.daemon = True
        self.channel_name = channel
        self.channel = getattr(client, channel + "_channel")
        self.kernel = kernel
        self.client = client
        self.stream = stream
        self.session = session

        self.log.debug("init ChannelReaderThread: channel_name=%s",
                       self.channel_name)
Example #5
0
    def __init__(self, parent=None, **kwargs):
        """
        Initialize.
        :param parent: parent object, requires data member show_other.
        :param kwargs:
        :return:
        """
        QtCore.QObject.__init__(self, parent)
        LoggingConfigurable.__init__(self, **kwargs)
        self.target = parent
        self._retry_history = QtCore.QSemaphore(1)

        self._payload_handlers = {
            self._payload_source_edit: self._handle_payload_edit,
            self._payload_source_exit: self._handle_payload_exit,
            self._payload_source_page: self._handle_payload_page,
            self._payload_source_next_input: self._handle_payload_next_input}