Ejemplo n.º 1
0
class LongPythonThread(QObject):

    thread_finished = Signal(str)

    def __init__(self):
        super(LongPythonThread, self).__init__()

    def train_network(self, filter, file_name):
        filter.tf_learn(file_name)
        self.thread_finished.emit("Done")
Ejemplo n.º 2
0
class CometManagerProxy(QObject):
  def __init__(self, parent=None):
    super(CometManagerProxy, self).__init__(parent)
    dm = manager()
    dm.termTopicConnectionCountChanged.connect(self.termTopicConnectionCountChanged)

  termTopicConnectionCountChanged = Signal(int)
  termTopicConnectionCount = Property(int,
      lambda self: manager().termTopicConnectionCount(),
      notify=termTopicConnectionCountChanged)
class _LoggedPage(QWebPage):
    obj = []  # synchronous
    commandRecieved = Signal(str)
    helpNeeded = Signal(str)
    tabPressed = Signal(str)

    def javaScriptConsoleMessage(self, msg, line, source):
        l = msg.split(",")

        self.obj = l
        if msg[:3] == "TAB":
            self.tabPressed.emit(msg[3:])

        elif msg[:3] == "CMD":
            if msg[3:7] == "help":
                self.helpNeeded.emit(msg[3:])
            else:
                self.commandRecieved.emit(msg[3:])
        print('JS: %s line %d: %s' % (source, line, msg))
Ejemplo n.º 4
0
class SpellAction(QAction):
    """
    An Action which will change the selected word.
    """

    correct = Signal(unicode)

    def __init__(self, *args):
        QAction.__init__(self, *args)
        self.triggered.connect(lambda: self.correct.emit(unicode(self.text())))
Ejemplo n.º 5
0
class _ExecThread(QThread):
    update = Signal(tuple)

    def __init__(self, func):
        QThread.__init__(self)
        self.func = func

    def run(self):
        output = self.func()
        self.update.emit(output)
Ejemplo n.º 6
0
class FadeToBlack(QObject):

    activeChanged = Signal(bool)
    rateChanged = Signal(int)

    def __init__(self):
        super(FadeToBlack, self).__init__()
        self.active = False
        self.rate = 25

    def set_active(self, active):
        if self.active != active:
            self.active = active
            self.activeChanged.emit(active)

    def set_rate(self, rate):
        if self.rate != rate:
            self.rate = rate
            self.rateChanged.emit(rate)
Ejemplo n.º 7
0
class FiltersCombo(QComboBox):
    filter_query_selected = Signal(object)

    def __init__(self, parent, family):
        super(FiltersCombo, self).__init__(parent)

        self._family = family
        self._filters = []
        self.activated.connect(self.emit_filter_query_selected)

    def current_filter(self):
        if 0 <= self.currentIndex() < len(self._filters):
            return self._filters[self.currentIndex()]
        else:
            return None

    def preselect(self, fq_id: int, emit_selection_signal: bool = True):
        if not self._filters:
            self.reload()

        for i in range(len(self._filters)):
            if self._filters[i].filter_query_id == fq_id:
                self.setCurrentIndex(i)
                if emit_selection_signal:
                    self.filter_query_selected.emit(self._filters[i])
                return

        # If the filter has been removed, then the configuration file
        # is not correct anymore. I could warn the user, but the problem
        # is that if I do it from here, then the warning might be
        # out of context (gui wise). So I prefer to fail silently.

        mainlog.warning("Unable to preselect filter id {}".format(fq_id))
        if self._filters:
            self.setCurrentIndex(0)
            if emit_selection_signal:
                self.filter_query_selected.emit(self._filters[0])

    @Slot()
    def reload(self):
        global dao
        global user_session

        mainlog.debug("Reloading filters for family {}".format(self._family))
        self._filters = dao.filters_dao.usable_filters(user_session.user_id,
                                                       self._family)

        self.clear()
        for fq in self._filters:
            mainlog.debug("Filter : {} {}".format(fq.name, fq.filter_query_id))
            self.addItem(fq.name, fq.filter_query_id)

    @Slot(int)
    def emit_filter_query_selected(self, ndx):
        self.filter_query_selected.emit(self._filters[ndx])
Ejemplo n.º 8
0
class PublisherDialog(QDialog):

    if USE_MAEMO_5:
        switchRequested = Signal()

    def __init__(self, parent=None):
        QDialog.__init__(self, parent)
        self.ui = Ui_PublisherDialog()
        self.ui.setupUi(self)
        self.publisher = None

        if USE_MAEMO_5:
            switchButton = self.ui.buttonBox.addButton(
                self.tr('Switch'), QDialogButtonBox.ActionRole)
            switchButton.clicked.connect(self.switchRequested)

        self.ui.connectButton.clicked.connect(self.createNewObject)
        self.ui.intValue.valueChanged.connect(self.intValueChanged)
        self.ui.unsetIntButton.clicked.connect(self.unsetIntValue)
        self.ui.setStringButton.clicked.connect(self.setStringValue)
        self.ui.setByteArrayButton.clicked.connect(self.setByteArrayValue)

        self.createNewObject()

    def changeEvent(self, e):
        QDialog.changeEvent(self, e)
        if e.type() == QEvent.LanguageChange:
            self.ui.retranslateUi(self)

    def intValueChanged(self, value):
        self.publisher.setValue('intValue', value)

    def unsetIntValue(self):
        self.publisher.resetValue('intValue')

    def setStringValue(self):
        self.publisher.setValue('stringValue', self.ui.stringValue.text())

    def setByteArrayValue(self):
        self.publisher.setValue('byteArrayValue',
                                self.ui.byteArrayValue.text())

    def createNewObject(self):
        if self.publisher:
            del self.publisher

        self.publisher = QValueSpacePublisher(QValueSpace.WritableLayer,
                                              self.ui.basePath.text())
        if self.publisher.isConnected():
            self.ui.setters.setEnabled(True)
            self.intValueChanged(self.ui.intValue.value())
            self.setStringValue()
            self.setByteArrayValue()
        else:
            self.ui.setters.setEnabled(False)
Ejemplo n.º 9
0
class TouchSpinner(QWidget):
    valueChanged = Signal(int)

    def __init__(self, parent=None):
        super(TouchSpinner, self).__init__(parent)
        self._value = 50
        self._max = 100
        self._min = 0

        layout = QHBoxLayout()

        self.btnMinus = ExpandingButton()
        self.btnMinus.setIcon(QIcon(":icons/list-remove"))
        self.btnMinus.setText("-")
        self.btnMinus.clicked.connect(lambda: self.setValue(self._value - 1))
        layout.addWidget(self.btnMinus, 1)

        self.lblValue = QLabel(self.formattedValue(self._value))
        self.lblValue.setAlignment(Qt.AlignHCenter)
        layout.addWidget(self.lblValue, 1)

        self.btnPlus = ExpandingButton()
        self.btnPlus.setIcon(QIcon(":icons/list-add"))
        self.btnPlus.setText("+")
        self.btnPlus.clicked.connect(lambda: self.setValue(self._value + 1))
        layout.addWidget(self.btnPlus, 1)

        self.setLayout(layout)

    def setValue(self, value):
        if value > self._max:
            newValue = self._max
        elif value < self._min:
            newValue = self._min
        else:
            newValue = value
        if value != self._value:
            self._value = newValue
            self.valueChanged.emit(newValue)
            self.lblValue.setText(self.formattedValue(newValue))

            self.btnPlus.setEnabled(self._value < self._max)
            self.btnMinus.setEnabled(self._value > self._min)

    def setMaximum(self, maxi):
        self._max = maxi

    def setMinimum(self, mini):
        self._min = mini

    def value(self):
        return self._value

    def formattedValue(self, value):
        return "{}".format(value)
Ejemplo n.º 10
0
class Wallpaper(QObject):
    def __init__(self, ):
        QObject.__init__(self)
        self._running = False

    @Slot(unicode, int, int)
    def setWallpaper(self, url, offset, width):
        self._set_running(True)
        self.thread = threading.Thread(target=self._setWallpaper, \
                                        args=(url, offset, width))
        self.thread.start()

    def _setWallpaper(self, url, offset, width):
        inStream = urllib2.urlopen(url)
        img = QImage.fromData(inStream.read())
        img = img.scaledToHeight(854,Qt.SmoothTransformation)
        #offset = int(img.width() / 2) - 240
        print 'offset:', offset, 'img.width', img.width(), 'width', width
        img = img.copy(offset, 0, 480, 854)
        img.save(WALLPATH)

        #Set in gconf
        import gconf
        gclient = gconf.client_get_default()
        gclient.set_string(GCONFKEY, '')
        gclient.set_string(GCONFKEY, \
                           WALLPATH)
        #Emit done signal
        self._set_running(False)
        self.done.emit()

    def _get_running(self):
        return self._running

    def _set_running(self, b):
        self._running = b
        self.on_running.emit()


    done = Signal()
    on_running = Signal()
    running = Property(bool, _get_running, _set_running, notify=on_running)
Ejemplo n.º 11
0
class WebBrowser(SkDraggableMainWindow):

    quitRequested = Signal()
    messageReceived = Signal(unicode)

    def __init__(self, parent=None):
        #WINDOW_FLAGS = (
        #  Qt.Window
        #  | Qt.CustomizeWindowHint
        #  | Qt.WindowTitleHint
        #  | Qt.WindowSystemMenuHint
        #  | Qt.WindowMinMaxButtonsHint
        #  | Qt.WindowCloseButtonHint
        #)
        super(WebBrowser, self).__init__(parent)
        self.__d = _WebBrowser(self)
        skqss.class_(self, 'webkit')

    def showStatusMessage(self, t, type='message'):
        """
    @param  t  unicode
    @param  type  'message', 'warning', or 'error'
    """
        self.statusBar().showMessage(text)

    def openDefaultPage(self):
        self.__d.newTabAfterCurrentWithBlankPage()

    def openUrls(self, urls):  # [unicode url]
        for url in urls:
            self.__d.openUnknownAfterCurrent(url)
            #self.__d.openUrl(url)

    def loadTabs(self):  # -> bool
        return self.__d.loadTabs()

    def closeEvent(self, e):
        ss = settings.global_()
        ss.setWindowWidth(self.width())
        ss.setWindowHeight(self.height())

        super(WebBrowser, self).closeEvent(e)
Ejemplo n.º 12
0
class TasksPool(QObject):
    startNextTaskSignal = Signal()
    allTasksCompleteSignal = Signal()

    def __init__(self):
        super(TasksPool, self).__init__()
        self.tasks_pool = []
        self.process = QProcess()

        self.startNextTaskSignal.connect(self.execute_task)
        self.allTasksCompleteSignal.connect(self.tasks_complete)

        self.source = ''

    def add_task(self, command):
        self.tasks_pool.append(command)
        self.startNextTaskSignal.emit()

    def execute_task(self):
        print('Start next?')
        if self.process.isOpen():
            self.process.waitForFinished()
        if not self.tasks_pool:
            self.allTasksCompleteSignal.emit()
            return
        self.process = QProcess()
        self.process.finished.connect(
            lambda *x: QTimer.singleShot(1000, self.startNextTaskSignal.emit))
        self.process.setProcessChannelMode(QProcess.MergedChannels)
        self.process.readyRead.connect(self.process_output)
        next_task = self.tasks_pool.pop(0)
        print('NEXT TASK', next_task)
        self.process.start(next_task)

    def process_output(self):
        output = self.process.readAll()
        output = str(output).strip()
        if output:
            print(output)

    def tasks_complete(self):
        print('ALL TASKS COMPLETE')
Ejemplo n.º 13
0
class QUDevMonitorObserver(QObject, QUDevMonitorObserverMixin):
    """
    An observer for device events integrating into the :mod:`PySide` mainloop.

    This class inherits :class:`~PySide.QtCore.QObject` to turn device events
    into Qt signals:

    >>> from pyudev import Context, Monitor
    >>> from pyudev.pyqt4 import QUDevMonitorObserver
    >>> context = Context()
    >>> monitor = Monitor.from_netlink(context)
    >>> monitor.filter_by(subsystem='input')
    >>> observer = QUDevMonitorObserver(monitor)
    >>> def device_connected(device):
    ...     print('{0!r} added'.format(device))
    >>> observer.deviceAdded.connect(device_connected)
    >>> monitor.start()

    This class is a child of :class:`~PySide.QtCore.QObject`.
    """

    #: emitted upon arbitrary device events
    deviceEvent = Signal(text_type, Device)
    #: emitted, if a device was added
    deviceAdded = Signal(Device)
    #: emitted, if a device was removed
    deviceRemoved = Signal(Device)
    #: emitted, if a device was changed
    deviceChanged = Signal(Device)
    #: emitted, if a device was moved
    deviceMoved = Signal(Device)

    def __init__(self, monitor, parent=None):
        """
        Observe the given ``monitor`` (a :class:`~pyudev.Monitor`):

        ``parent`` is the parent :class:`~PySide.QtCore.QObject` of this
        object.  It is passed unchanged to the inherited constructor of
        :class:`~PySide.QtCore.QObject`.
        """
        QObject.__init__(self, parent)
        self._setup_notifier(monitor, QSocketNotifier)
Ejemplo n.º 14
0
class outputStream(QObject):
    #set up a signal 'message' for transmitting stdout/stderr
    message = Signal(str)

    def __init__(self, parent=None):
        #standard __init__
        super(outputStream, self).__init__(parent)

    def write(self, message):
        #send message to be printed in terminal window
        self.message.emit(str(message))
Ejemplo n.º 15
0
class Transition(QObject):
    changedProps = Signal()

    def __init__(self):
        super(Transition, self).__init__()
        self.rate = 1

    def set_rate(self, rate):
        if self.rate != rate:
            self.rate = rate
            self.changedProps.emit()
Ejemplo n.º 16
0
class Scene(QObject):
    """Parent class for all Scene classes."""

    causeChangeSignal = Signal(QObject)  # For changes originating w/this scene
    changeSignal = Signal(QObject)  # For changes applied to this scene

    def __init__(self):
        """Construct a Scene object."""
        super(Scene, self).__init__()

    def announceChange(self):
        """This should be called whenever a Scene object is changed due
           to a user action.

           Example: When a user selects highlights.
        """
        self.causeChangeSignal.emit(self)

    def acceptChanges(self):
        self.changeSignal.emit(self)
Ejemplo n.º 17
0
class HistogramWidget(QWidget, Ui_HistogramWindow):
    fourier_updated = Signal(np.ndarray)

    def __init__(self, parent_title, parent=None):
        QWidget.__init__(self, parent)
        self.setupUi(self)

        self.setWindowTitle("{}'s Histogram".format(parent_title))

    def update_histogram(self, image_array, cause):
        self.histogram.update(image_array)
Ejemplo n.º 18
0
class TradeLog(QObject):

    trade_added = Signal(QObject)
    trade_completed = Signal(QObject)

    def __init__(self):
        super().__init__()
        self.start_time = time.time()
        self.log = []

    def add_trade(self, trade):
        self.trade_added.emit(trade)

    def complete_trade(self, trade):
        trade.complete_time = datetime.datetime.now()
        logging.info("Completed trade!")
        logging.debug("Start amount1: {} \t Remaining amount1: {}".format(
            str(trade.amount1), str(trade.remaining1)))
        self.log.append(trade)
        self.trade_completed.emit(trade)
Ejemplo n.º 19
0
class PassFilterDialog(Dialog, QDialog, ff.Ui_Dialog):
    mask_accepted = Signal(np.ndarray)
    updated = Signal(np.ndarray)
    mask = None

    def __init__(self, low=True, parent=None):
        QDialog.__init__(self, parent)
        self.setupUi(self)
        self.low = low
        self.horizontalSlider.valueChanged.connect(self.update_mask)
        self.buttonBox.rejected.connect(self._clear)
        self.buttonBox.accepted.connect(self._apply_mask)

    def update_mask(self, diam):
        diam = diam if not self.low else 99 - diam
        print(diam)
        max_dim = max(self.height, self.width)
        diam = max_dim * (diam / 100)
        self.mask = round_mask(diam, self.width, self.height, low=self.low)
        self.updated.emit(self.mask.copy())
class MTTFileList(QListView):
    """ Extend QListView for navigation """

    selectionValidated = Signal()
    goToParentDirectory = Signal()

    def __init__(self, parent=None):
        super(MTTFileList, self).__init__(parent)

        self.filter_line = None

    def keyPressEvent(self, event):
        if event.key() == Qt.Key_F and event.modifiers() == Qt.ControlModifier:
            self.filter_line.setFocus()
        elif event.key() == Qt.Key_Return or event.key() == Qt.Key_Enter:
            self.selectionValidated.emit()
        elif event.key() == Qt.Key_Backspace:
            self.goToParentDirectory.emit()
        else:
            super(MTTFileList, self).keyPressEvent(event)
Ejemplo n.º 21
0
        class CloseLabel(QLabel):

            closeSignal = Signal()

            def __init__(self):
                super(CloseLabel, self).__init__("Close")

                self.setStyleSheet("QLabel { color : white; }")

            def mousePressEvent(self, e):
                self.closeSignal.emit()
Ejemplo n.º 22
0
class Mixin(QObject):
    changed = Signal()

    def add_observer(self, slot):
        self.changed.connect(slot)

    def remove_observer(self, slot):
        self.changed.disconnect(slot)

    def on_change(self):
        self.changed.emit()
Ejemplo n.º 23
0
class OcrPopupBean(QObject):

    instance = None

    def __init__(self, parent=None):
        super(OcrPopupBean, self).__init__(parent)
        OcrPopupBean.instance = self
        dprint("pass")

    popupRequested = Signal(int, int, QObject, QObject, unicode,
                            unicode)  # x, y, imgobj, winobj, text, language
Ejemplo n.º 24
0
class ThreadRun(QThread):
    trigger = Signal()  # trigger传输的内容是字符串

    def __init__(self, parent=None):
        super(ThreadRun, self).__init__(parent)

    def setup(self):
        pass

    def run(self):
        self.trigger.emit()
Ejemplo n.º 25
0
class TextReader(QObject):

    ## Construction ##

    def __init__(self, parent=None):
        super(TextReader, self).__init__(parent)
        self.__d = _TextReader(self)

    pageBreakReceived = Signal()
    textReceived = Signal(unicode, unicode, long)  # text, lang, timestamp
    translationReceived = Signal(unicode, unicode, unicode,
                                 long)  # text, language, provider, timestamp

    ## Properties ##

    def userLanguage(self):
        return self.__d.language

    def setUserLanguage(self, value):
        self.__d.language = value

    #def encoding(self): return self.__d.encoding
    #def setEncoding(self, encoding): self.__d.encoding = encoding

    def gameLanguage(self):
        return self.__d.gameLanguage

    def setGameLanguage(self, value):
        self.__d.gameLanguage = value

    ## Actions ##

    def addText(self, text):
        d = self.__d
        if text == d.lastText:
            return
        d.lastText = text
        #if len(text) > defs.MIRAGE_MAX_TEXT_LENGTH:
        #  growl.msg(my.tr("Game text is ignored for being too long"))
        #else:
        d.showText(text)
Ejemplo n.º 26
0
class OnlineThread(QThread):
    playRequested = Signal(object, unicode, str, str,
                           float)  # OnlineEngine, text, language, gender, time
    stopRequested = Signal(float)  # time
    abortSignal = Signal()
    abortSignalRequested = Signal()

    def __init__(self, parent=None):
        super(OnlineThread, self).__init__(parent)
        self.__d = _OnlineThread()

    def run(self):
        """@reimp"""
        skwincom.coinit(threading=True)  # critical to use WMP
        self.__d.run(self)
        self.exec_()

    def destroy(self):
        self.abortSignalRequested.emit()
        self.quit()
        #skwincom.couninit() # never invoked

    # Actions

    def requestPlay(self, engine, text, language, gender):  # OnlineTask ->
        now = time()
        d = self.__d
        d.time = now
        if d.downloadCount > 0:
            self.abortSignalRequested.emit()

        self.playRequested.emit(engine, text, language, gender, now)

    def requestStop(self):
        d = self.__d
        now = time()
        d.time = now
        if d.downloadCount > 0:
            self.abortSignalRequested.emit()
        if d.playing:
            self.stopRequested.emit(now)
Ejemplo n.º 27
0
class GlobalFilter(QObject):
    """
    Event filter for filtering events (i.e. key events) on main dialog and its children
    """

    escapePressed = Signal()
    playKeyPressed = Signal()
    stopKeyPressed = Signal()
    muteKeyPressed = Signal()
    volumeUpKeyPressed = Signal()
    volumeDownKeyPressed = Signal()
    mouseWheel = Signal(int)

    def eventFilter(self, obj, event):
        """
        Handles every event on filtered object and its children
        :param event: custom event
        :param obj: receiver
        :type event: PySide.QtCore.QEvent
        :type obj: PySide.QtCore.QObject
        :return: if the event needs to be filtered (eaten)
        :rtype : bool
        """
        # --- KEY PRESS events ----
        if event.type() is QEvent.KeyPress:
            modifier = QApplication.queryKeyboardModifiers(
            )  # get pressed modifier keys (ctrl, shift, alt, etc)

            # ESCAPE key
            if event.key() == Qt.Key_Escape:
                self.escapePressed.emit()

            # PLAY or SPACE key
            elif event.key() == Qt.Key_MediaPlay or event.key(
            ) == Qt.Key_Space:
                self.playKeyPressed.emit()

            # STOP key
            elif event.key() == Qt.Key_MediaStop:
                self.stopKeyPressed.emit()

            # CTRL + PLUS key pressed
            if event.key() == Qt.Key_Plus and modifier == Qt.ControlModifier:
                self.volumeUpKeyPressed.emit()
                return True
                # CTRL + MINUS key pressed
            if event.key() == Qt.Key_Minus and modifier == Qt.ControlModifier:
                self.volumeDownKeyPressed.emit()
                return True
                # CTRL + * key pressed
            if event.key(
            ) == Qt.Key_Asterisk and modifier == Qt.ControlModifier:
                self.muteKeyPressed.emit()
                return True

        return super(GlobalFilter, self).eventFilter(obj, event)
Ejemplo n.º 28
0
class SliderWidget(QWidget):
    """
	SliderWidget
	"""
    valueChanged = Signal(int)

    def __init__(self):
        super(SliderWidget, self).__init__()

        self.label = QLabel()
        self.slider = QSlider(Qt.Horizontal)
        self.spinbox = QSpinBox()

        self.slider.valueChanged.connect(self.changedValue)
        self.spinbox.valueChanged.connect(self.changedValue)

        layout = QGridLayout()
        layout.setContentsMargins(0, 0, 0, 0)
        layout.setVerticalSpacing(0)
        layout.addWidget(self.label, 0, 0)
        layout.addWidget(self.slider, 0, 1)
        layout.addWidget(self.spinbox, 0, 2)
        self.setLayout(layout)

    def setName(self, name):
        """
		Set the name for the slider
		"""
        self.label.setText(name)

    def setRange(self, range):
        """
		Set the range for the value
		"""
        self.slider.setMinimum(range[0])
        self.spinbox.setMinimum(range[0])
        self.slider.setMaximum(range[1])
        self.spinbox.setMaximum(range[1])

    def setValue(self, value):
        """
		Set the value for the slider and the spinbox
		"""
        self.slider.setValue(value)
        self.spinbox.setValue(value)

    def value(self):
        return self.slider.value()

    @Slot(int)
    def changedValue(self, value):
        self.setValue(value)
        self.valueChanged.emit(value)
Ejemplo n.º 29
0
class View(QDeclarativeView):
    def __init__(self):
        QDeclarativeView.__init__(self)
        self.setSource(
            QUrl.fromLocalFile(adjust_filename('bug_847.qml', __file__)))
        self.rootObject().setProperty('pythonObject', self)

    @Slot(int, int)
    def blubb(self, x, y):
        self.called.emit(x, y)

    called = Signal(int, int)
Ejemplo n.º 30
0
class HubOpenFile(QObject):
    def __init__(self):
        super(HubOpenFile, self).__init__()

    @Slot(str)
    def connect(self, config):

        txtFileName = QFileDialog.getOpenFileNames(None, "Open")[0]
        txtFileName = str(txtFileName).replace("[u'", '').replace("']", '')
        print(txtFileName)

        text = open(txtFileName).read()
        self.on_file_open_event.emit(text)

    @Slot(str)
    def disconnect(self, config):
        print(config)

    on_file_open_event = Signal(str)
    on_connect = Signal(str)
    on_disconnect = Signal(str)