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 ClickFrame(QFrame): """Frame that sends a signal on click.""" clicked = Signal() def __init__(self, parent=None, flags=0): """Create ClickFrame widget.""" super(ClickFrame, self).__init__(parent, flags) def mousePressEvent(self, event): """Emits the clicked signal.""" self.clicked.emit()
class PostInputManagerBean(QObject): def __init__(self, parent=None, manager=None): super(PostInputManagerBean, self).__init__(parent) self.manager = manager or PostInputManager(self) self.manager.postReceived.connect(self.postReceived) postReceived = Signal(unicode, unicode) # json post, json image @Slot(long, str) def newPost(self, topicId, postType): self.manager.newPost(topicId=topicId, type=postType) @Slot(long, long) def replyPost(self, topicId, postId): self.manager.newPost(topicId=topicId, replyId=postId, type='reply') imageEnabledChanged = Signal(bool) imageEnabled = Property(bool, lambda self: self.manager.isImageEnabled(), lambda self, t: self.manager.setImageEnabled(t), notify=imageEnabledChanged)
class TopicEditorManagerBean(QObject): def __init__(self, parent=None, manager=None): super(TopicEditorManagerBean, self).__init__(parent) self.manager = manager or TopicEditorManager(self) self.manager.topicChanged.connect(self.topicChanged) topicChanged = Signal(unicode, unicode, unicode) # json topic, json image, json tickets imageEnabledChanged = Signal(bool) imageEnabled = Property(bool, lambda self: self.manager.isImageEnabled(), lambda self, t: self.manager.setImageEnabled(t), notify=imageEnabledChanged) @Slot(unicode) def editTopic(self, data): # json -> try: topic = json.loads(data) topic['id'] = long(topic['id']) self.manager.editTopic(**topic) except Exception, e: dwarn(e)
class WbAddressEdit(QtWidgets.QComboBox): def __init__(self, parent=None): super(WbAddressEdit, self).__init__(parent) self.__d = _WbAddressEdit(self) self.setInsertPolicy(QtWidgets.QComboBox.InsertAtTop) self.setEditable(True) #self.currentIndexChanged.connect(self.enter) # recursion #self.lineEdit().returnPressed.connect(self.enter) self.maxCount = config.ADDRESS_HISTORY_SIZE self.setToolTip("Ctrl+L, Alt+D") completer = self.completer() completer.setCaseSensitivity(Qt.CaseInsensitive) completer.setCompletionMode( QtWidgets.QCompleter.UnfilteredPopupCompletion) completer.setModelSorting( QtWidgets.QCompleter.CaseInsensitivelySortedModel) textEntered = Signal(unicode) #def enter(self): # t = self.currentText().strip() # if t: # self.setText(t) # self.textEntered.emit(t) def focus(self): self.setFocus() self.lineEdit().selectAll() def setText(self, text): # unicode -> self.addText(text) #self.setEditText(text) self.setCurrentIndex(0) def addText(self, text): # unicode -> index = self.findText(text) if index >= 0: self.removeItem(index) icon = rc.url_icon(text) self.insertItem(0, icon, text) # Note: This will change current item! if self.count() > self.maxCount: self.removeItem(self.maxCount) def setProgress(self, v): # int [0,100] d = self.__d if d.progress != v: d.progress = v d.refreshPallete()
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)
class PunchingBag(QObject): ''' Represents a punching bag; when you punch it, it emits a signal that indicates that it was punched. ''' punched = Signal() def __init__(self): # Initialize the PunchingBag as a QObject QObject.__init__(self) def punch(self): ''' Punch the bag ''' self.punched.emit()
class SkTaskBarObject(SkWindowObject): def __init__(self, parent=None): super(SkTaskBarObject, self).__init__(parent) def setAutoHide(self, t): pass autoHideChanged = Signal(bool) autoHide = Property(bool, lambda self: False, setAutoHide, notify=autoHideChanged)
class QtReduceFontSizeComboBoxFs(QtReduceComboBox): currentFontSizeChangedFs = Signal(StringType) def __init__(self,parent=None): super(QtReduceFontSizeComboBoxFs,self).__init__() self.currentIndexChanged.connect(self.currentIndexChangedHandler) def currentFontSize(self): return self.findText(currentSize) def currentIndexChangedHandler(self,index): return self.currentFontSizeChangedFs.emit(self.currentText())
class StarEditor(QWidget): """ The custome editor for editing StarRatings. """ # A signal to tell the delegate when we've finished editing. editingFinished = Signal() def __init__(self, parent=None): """ Initialize the editor object, making sure we can watch mouse events. """ super(StarEditor, self).__init__(parent) self.setMouseTracking(True) self.setAutoFillBackground(True) def sizeHint(self): """ Tell the caller how big we are. """ return self.starRating.sizeHint() def paintEvent(self, event): """ Paint the editor, offloading the work to the StarRating class. """ painter = QPainter(self) self.starRating.paint(painter, self.rect(), self.palette(), isEditable=True) def mouseMoveEvent(self, event): """ As the mouse moves inside the editor, track the position and update the editor to display as many stars as necessary. """ star = self.starAtPosition(event.x()) if (star != self.starRating.starCount) and (star != -1): self.starRating.starCount = star self.update() def mouseReleaseEvent(self, event): """ Once the user has clicked his/her chosen star rating, tell the delegate we're done editing. """ self.editingFinished.emit() def starAtPosition(self, x): """ Calculate which star the user's mouse cursor is currently hovering over. """ star = (x / (self.starRating.sizeHint().width() / self.starRating.maxStarCount)) + 1 if (star <= 0) or (star > self.starRating.maxStarCount): return -1 return star
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)
class ClickLabel(QLabel): """Label that sends a signal on click.""" clicked = Signal() def __init__(self, parent=None, flags=0): """Create a ClickLabel widget.""" super(ClickLabel, self).__init__(parent, flags) def mousePressEvent(self, event): """Emits the clicked signal.""" self.clicked.emit()
class SignalHandler(QObject): clearSignal = Signal() newUser = Signal(str) stopSignal = Signal() refreshSignal = Signal() stopCon = Signal(int) newmsg = Signal(str) def __init__(self): QObject.__init__(self) def clear(self): self.clearSignal.emit() def new_User(self, name): self.newUser.emit(name) def stop(self): self.stopSignal.emit() def refresh(self): self.refreshSignal.emit() def stopConnection(self, i): self.stopCon.emit(i) def msg(self, text): self.newmsg.emit(text)
class ViewModelSignals(QObject): updateProduction = Signal(str) updateDepartment = Signal(str) updateBody = Signal(str) updateCheckedOutBodies = Signal(dict) updateOverviewBodies = Signal(tuple, dict) changePage = Signal(int, list)
class RpcServer(QObject): def __init__(self, parent=None): super(RpcServer, self).__init__(parent) self.__d = _RpcServer(self) activated = Signal() def stop(self): self.__d.server.stop() def start(self): """@return bool""" return self.__d.server.start() def isActive(self): """@return bool""" return self.__d.server.isActive() activated = Signal() # Agent agentConnected = Signal(long) # pid agentDisconnected = Signal(long) # pid windowTextsReceived = Signal(dict) # {long hash:unicode text} engineReceived = Signal(str) # name engineTextReceived = Signal(unicode, str, long, int, bool) # text, hash, role, needsTranslation def isAgentConnected(self): return bool(self.__d.agentSocket) def closeAgent(self): self.__d.closeAgentSocket() #def enableAgent(self): self.__d.callAgent('enable') def disableAgent(self): self.__d.callAgent('disable') #def detachAgent(self): self.__d.callAgent('detach') def agentProcessId(self): return self.__d.agentPid def setAgentSettings(self, data): """ @param data {k:v} """ try: data = json.dumps( data ) #, ensure_ascii=False) # the json parser in vnragent don't enforce ascii self.__d.callAgent('settings', data) except TypeError, e: dwarn("failed to encode json: %s" % e)
class EthClient(QObject): def __init__(self, privkey): super(EthClient, self).__init__() self.privkey = privkey self.api = APIClient(DEFAULT_HOST, DEFAULT_PORT) @Slot(str) def getbalance(self, data): print "balance", data address = privtoaddr(self.privkey) balance = self.api.getbalance(address) res = dict(address=address, balance=str(balance)) print 'response:', res self.on_getbalance_cb.emit(json.dumps(res)) @Slot(str) def transact(self, data): data = json.loads(data) print "transact", data res = self.api.quicktx(DEFAULT_GASPRICE, DEFAULT_STARTGAS, data['txto'], int(data['txvalue']), '', self.privkey) print 'response:', res self.on_transact_cb.emit(json.dumps(res)) on_getbalance = Signal(str) on_getbalance_cb = Signal(str) on_transact = Signal(str) on_transact_cb = Signal(str) on_client_event = Signal(str) on_actor_event = Signal(str)
class ToggleObject(QObject): toggled = Signal() activated = Signal() deactivated = Signal() toggleRequested = Signal() activationRequested = Signal() deactivationRequested = Signal() def __init__(self, initialState=False): QObject.__init__(self) self._toggled = initialState self.isToggled = partial(getattr, self, '_toggled') def toggle(self): state = not self._toggled self._toggled = state self.toggled.emit() getattr(self, 'activated' if state else 'deactivated').emit() def requestToggle(self): self.toggleRequested.emit() getattr( self, 'deactivationRequested' if self.isToggled() else 'activationRequested').emit()
class AddEffectMenuView(QMenu): Initialize = Signal(object, object) def __init__(self, presenter, parent=None, item_color="rgb(51, 51, 51)", background_color="rgb(245, 245, 245)"): super(AddEffectMenuView, self).__init__(parent) self.item_color = item_color self.background_color = background_color style_string = "QMenu {{ \ font: 'Roboto Light'; \ font-size: 14px; \ padding: 0px, 0px, 0px, 0px; \ background-color: {}; \ }} \ \ QMenu::icon {{ \ position: absolute; \ right: 1px; \ left: 9px; \ }} \ QMenu::item {{ \ color: {}; \ padding-top: 3px; \ padding-bottom: 3px; \ padding-right: 27px; \ padding-left: 27px; \ }} \ \ QMenu::separator {{ \ height: 1px; \ background: rgb(230, 230, 230); \ margin-left: 2px; \ margin-right: 2px; \ }} \ QMenu::item:selected {{ \ background-color: rgb(37, 191, 161); \ color: rgb(246, 246, 246); \ }}".format(self.background_color, self.item_color) self.setAttribute(Qt.WA_StyledBackground) self.setStyleSheet(style_string) self.presenter = presenter self.setAttribute(Qt.WA_StyledBackground) self.Initialize.connect(self._initialize) def _initialize(self, effects_names_and_callback, pos): for effect_name_and_callback in effects_names_and_callback: self.addAction(*effect_name_and_callback) self.move(pos) self.show()
class ScriptDummyWithQtSignal(Script, QThread): # NOTE THAT THE ORDER OF Script and QThread IS IMPORTANT!! _DEFAULT_SETTINGS = Parameter([ Parameter('count', 10, int), Parameter('name', 'this is a counter'), Parameter('wait_time', 0.1, float) ]) _INSTRUMENTS = {} _SCRIPTS = {} #This is the signal that will be emitted during the processing. #By including int as an argument, it lets the signal know to expect #an integer argument when emitting. updateProgress = Signal(int) def __init__(self, name=None, settings=None, log_output=None): """ Example of a script that emits a QT signal for the gui Args: name (optional): name of script, if empty same as class name settings (optional): settings for this script, if empty same as default settings """ Script.__init__(self, name, settings, log_output=log_output) # QtCore.QThread.__init__(self) QThread.__init__(self) def _function(self): """ This is the actual function that will be executed. It uses only information that is provided in the settings property will be overwritten in the __init__ """ # some generic function import time import random count = self.settings['count'] name = self.settings['name'] wait_time = self.settings['wait_time'] self.log('I am a test function counting to {:d}...'.format(count)) data = [] for i in range(count): time.sleep(wait_time) progress = int(100 * (i + 1) / count) self.updateProgress.emit(progress) data.append(random.random()) self.data = {'random data': data}
class TopicInputManager(QObject): def __init__(self, parent=None): super(TopicInputManager, self).__init__(parent) self.__d = _TopicInputManager() from PySide.QtCore import QCoreApplication qApp = QCoreApplication.instance() qApp.aboutToQuit.connect(self.hide) import dataman dataman.manager().loginChanged.connect( lambda name: name or name == 'guest' or self.hide()) #import netman #netman.manager().onlineChanged.connect(lambda t: t or self.hide()) topicReceived = Signal(unicode, unicode, unicode) # json topic, json image, json tickets #def clear(self): self.hide() def isVisible(self): if self.__d.dialogs: for w in self.__d.dialogs: if w.isVisible(): return True return False def hide(self): if self.__d.dialogs: for w in self.__d.dialogs: if w.isVisible(): w.hide() def newTopic(self, type='chat', subjectId=0, subjectType='', imagePath=''): """ @param* type str topic type @param* subjectId long @param* subjectType str @param* imagePath unicode """ w = self.__d.getDialog(self) w.setSubject(subjectId, subjectType) w.setType(type) w.setImagePath(imagePath) w.show() def isImageEnabled(self): return self.__d.imageEnabled def setImageEnabled(self, t): self.__d.imageEnabled = t
class QmlReferenceInput(QObject): def __init__(self, parent=None): super(QmlReferenceInput, self).__init__(parent) self.__d = _QmlRefrenceInput(self) referenceSelected = Signal(QObject) #@Slot() #def show(self): # d = self.__d # d.showWindow(d.dialog) @staticmethod def _getGameIcon(gameId): import dataman return dataman.manager().queryGameIcon(id=gameId) @staticmethod def _getGameName(gameId): import dataman dm = dataman.manager() for it in dm.queryReferenceData(gameId=gameId, online=False): if it.title: return it.title return dm.queryGameName(id=gameId) @Slot(int) def showGame(self, gameId): if not gameId: growl.notify( my.tr("Unknown game. Please try updating the database.")) return d = self.__d d.gameId = gameId import dataman dm = dataman.manager() name = self._getGameName(gameId) title = my.tr("Please select the game title") if name: title += " - " + name w = d.dialog w.setWindowTitle(title) icon = self._getGameIcon(gameId) w.setWindowIcon(icon or rc.icon('window-refinput')) if name: w.setDefaultText(name) d.showWindow(w)
class HyperdeckState(QObject): transportChange = Signal(dict) clipsListChange = Signal(dict) def __init__(self, hyperdeck): super(HyperdeckState, self).__init__() self.deck = hyperdeck self.clip_listing = {} self.transport = {"status": TransportState.STOPPED} if self.deck: self.transport = self.deck.getTransportState() def handleMessage(self, msgType, data): if msgType == HyperDeckMessageTypes.TRANSPORT_STATE_CHANGED: self.transport = data self.transportChange.emit(data) if msgType == HyperDeckMessageTypes.CLIP_LISTING: self.clip_listing = data self.clipsListChange.emit(data)
class DeclarativeView(QDeclarativeView): def __init__(self): QDeclarativeView.__init__(self) self.setAttribute(Qt.WA_OpaquePaintEvent) self.setAttribute(Qt.WA_NoSystemBackground) self.viewport().setAttribute(Qt.WA_OpaquePaintEvent) self.viewport().setAttribute(Qt.WA_NoSystemBackground) closing = Signal() def closeEvent(self, event): self.closing.emit() event.ignore()
class SkClipboardProxy(QObject): def __init__(self, parent=None): super(SkClipboardProxy, self).__init__(parent) self.__d = _SkClipboardProxy(self) QApplication.clipboard().dataChanged.connect(lambda: self.textChanged.emit(self.text)) textChanged = Signal(unicode) text = Property(unicode, lambda _: QApplication.clipboard().text(), lambda _, v: QApplication.clipboard().setText(v), notify=textChanged)
class ResizeDialog(QDialog, fr.Ui_Dialog): resized = Signal(float) def __init__(self, accept=None, reject=None, low=True, parent=None): QDialog.__init__(self, parent) self.setupUi(self) self.buttonBox.rejected.connect(self.close) self.buttonBox.accepted.connect(self._resize) def _resize(self): self.resized.emit(self.doubleSpinBox.value()) self.close()
class PerFrameSeekerFilter(QObject): """ Event filter for filtering mouse btn release events """ LMouseRelease = Signal() LMousePress = Signal() def eventFilter(self, obj, event): """ :type obj: PySide.QtGui.QSlider :type event: PySide.QtCore.QEvent """ if event.type() is QEvent.MouseButtonPress and event.button( ) is Qt.LeftButton: self.LMousePress.emit() if event.type() is QEvent.MouseButtonRelease and event.button( ) is Qt.LeftButton: self.LMouseRelease.emit() return super(PerFrameSeekerFilter, self).eventFilter(obj, event)
class PostEditorManagerBean(QObject): def __init__(self, parent=None, manager=None): super(PostEditorManagerBean, self).__init__(parent) self.manager = manager or PostEditorManager(self) self.manager.postChanged.connect(self.postChanged) postChanged = Signal(unicode, unicode) # json post, json image imageEnabledChanged = Signal(bool) imageEnabled = Property(bool, lambda self: self.manager.isImageEnabled(), lambda self, t: self.manager.setImageEnabled(t), notify=imageEnabledChanged) @Slot(unicode) def editPost(self, data): # json -> try: post = json.loads(data) post['id'] = long(post['id']) self.manager.editPost(**post) except Exception, e: dwarn(e)
class DataSource(QObject): def __init__(self, parent=None): super(DataSource, self).__init__(parent) self.spectrum = Spectrum([]) updated = Signal(object) def getSpectrum(self): return self.spectrum @Slot() def refresh(self): self.updated.emit(self.getSpectrum())
class FilterLineEdit(QLineEdit): key_down = Signal() def __init__(self): super(FilterLineEdit,self).__init__() def keyPressEvent(self,event): if event.key() == Qt.Key_Down: event.ignore() self.key_down.emit() return super(FilterLineEdit,self).keyPressEvent(event)
class Handbrake(QObject): return_signal = Signal(str) def __init__(self, emoji=None): """ This class allows you to add() video files and convert them to gifs. Output files are going to be in the same folder as the input files. """ super(Handbrake, self).__init__() self.tp = TasksPool() self.tp.return_signal.connect(lambda x: self.return_signal.emit(x)) # If we supply Emoji object, then if isinstance(emoji, Emoji): video_file = abspath(join(emoji.folder, emoji.name + Config()()['name_delimiter'] + emoji.version + '.mov')) if not exists(video_file): video_file = abspath(join(emoji.folder, emoji.name + '-' + emoji.version + '.mov')) if exists(video_file): self.add(video_file) self.run() else: error_msg = 'Failed to locate {}, based on {}.'.format(video_file, emoji.name_no_ext) self.return_signal.emit(__name__ + error_msg) logger.warning(error_msg) error_box = QMessageBox() error_box.setStyleSheet(stylesheet.houdini) error_box.setWindowTitle('Handbrake mov to mp4 conversion: File error') error_box.setText(error_msg) error_box.exec_() elif isinstance(emoji, str): video_file = emoji if exists(video_file): self.add(video_file) self.run() def add(self, input_file): """ :param input_file: Source video file :return: String with resulting gif's path """ output_file = splitext(input_file)[0]+'.mp4' cmd = 'bin\\HandBrakeCLI.exe -i "{}" -o "{}"'.format(input_file, output_file) self.tp.add_task(cmd) logger.debug(cmd + ' added') def run(self): """ Launches FFmpeg conversion process queue filled with add() method """ self.tp.launch_list() self.tp = None