class Photo(QObject): def __init__(self, gPhoto, parent=None): super(Photo, self).__init__(parent) self._data = gPhoto self._thumbnail = gPhoto.media.thumbnail[0] def getWidth(self): return int(self._thumbnail.width) def getHeight(self): return int(self._thumbnail.height) def getUrl(self): return self._thumbnail.url def getImageUrl(self): return self._data.GetMediaURL() onWidthChanged = Signal() onHeightChanged = Signal() onUrlChanged = Signal() width = Property(int, getWidth, notify=onWidthChanged) height = Property(int, getHeight, notify=onHeightChanged) url = Property(QUrl, getUrl, notify=onUrlChanged) imageUrl = Property(QUrl, getImageUrl, notify=onUrlChanged)
class OcrRegionBean(QObject): instance = None def __init__(self, parent=None): super(OcrRegionBean, self).__init__(parent) self.__d = _OcrRegionBean() OcrRegionBean.instance = self dprint("pass") regionRequested = Signal(int, int, int, int) # x, y, width, height def setEnabled(self, t): if self.__d.enabled != t: self.__d.enabled = t self.enabledChanged.emit(t) ocrman.manager().setRegionOcrEnabled(t) enabledChanged = Signal(bool) enabled = Property(bool, lambda self: self.__d.enabled, setEnabled, notify=enabledChanged) def setVisible(self, t): if self.__d.visible != t: self.__d.visible = t self.visibleChanged.emit(t) ocrman.manager().setRegionSelectionEnabled(t) visibleChanged = Signal(bool) visible = Property(bool, lambda self: self.__d.visible, setVisible, notify=visibleChanged) def setDesktopSelected(self, t): if self.__d.desktopSelected != t: self.__d.desktopSelected = t self.desktopSelectedChanged.emit(t) ocrman.manager().setDesktopSelected(t) desktopSelectedChanged = Signal(bool) desktopSelected = Property(bool, lambda self: self.__d.desktopSelected, setDesktopSelected, notify=desktopSelectedChanged) @Slot(QObject) # QDeclarativeItem def addRegionItem(self, item): ocrman.manager().addRegionItem(item) @Slot(result=QObject) def createImageObject(self): return ocrman.manager().createImageObject()
class ConfigProxy(QObject): def __init__(self, config): QObject.__init__(self) self._config = config config.add_observer(self._on_config_changed) def _on_config_changed(self, name, old_value, new_value): if name == 'ui.qml.autorotate': self.autorotateChanged.emit() elif name == 'flattr.token': self.flattrTokenChanged.emit() elif name == 'flattr.flattr_on_play': self.flattrOnPlayChanged.emit() def get_autorotate(self): return self._config.ui.qml.autorotate def set_autorotate(self, autorotate): self._config.ui.qml.autorotate = autorotate autorotateChanged = Signal() autorotate = Property(bool, get_autorotate, set_autorotate, notify=autorotateChanged) def get_flattr_token(self): return self._config.flattr.token def set_flattr_token(self, flattr_token): self._config.flattr.token = flattr_token flattrTokenChanged = Signal() flattrToken = Property(unicode, get_flattr_token, set_flattr_token, notify=flattrTokenChanged) def get_flattr_on_play(self): return self._config.flattr.flattr_on_play def set_flattr_on_play(self, flattr_on_play): self._config.flattr.flattr_on_play = flattr_on_play flattrOnPlayChanged = Signal() flattrOnPlay = Property(bool, get_flattr_on_play, set_flattr_on_play, notify=flattrOnPlayChanged)
def testQVariantListProperty(self): class Obj(object): list = ['foo', 'bar', 'baz'] obj = Obj() wrapper_dict = {} for name in ['list']: getter = lambda arg=None, name=name: getattr(obj, name) wrapper_dict[name] = Property('QVariantList', getter) wrapper = type('PyObj', (QObject,), wrapper_dict) view = QWebView() frame = view.page().mainFrame() frame.addToJavaScriptWindowObject('py_obj', wrapper()) html = ''' <html><body> <script type="text/javascript"> document.write(py_obj.list) </script> </body></html> ''' view.setHtml(html) view.show() self.app.exec_()
class StatItem(QObject): """ Item de statistique sur le déroulement du programme qui sera affiché dans l'interface sur le paneau de droite. """ def __init__(self, name, content, color=None): QObject.__init__(self) self._content = content self._name = name self._color = color def _content(self): return self._content def name(self): return self._name def color(self): return self._color def _set(self, content): self._content = content self.changed.emit() changed = Signal() content = Property(unicode, _content, _set, notify=changed)
def testBug899(self): html = ''' <html><body> <script type="text/javascript"> document.write("<p>"+py_obj.list1+"</p>") document.write("<p>"+py_obj.list2+"</p>") </script> </body></html> ''' class Obj(object): list1 = ['foo', 'bar', 'baz'] list2 = ['fi', 'fo', 'fum'] obj = Obj() wrapper_dict = {} for name in ('list1', 'list2'): getter = lambda arg=None, name=name: getattr(obj, name) wrapper_dict[name] = Property('QVariantList', getter) wrapper = type('PyObj', (QObject, ), wrapper_dict) view = QWebView() view.page().mainFrame().addToJavaScriptWindowObject( 'py_obj', wrapper()) view.setHtml(html)
class gPodderEpisodeListModel(gPodderListModel): def __init__(self, config): gPodderListModel.__init__(self) self._filter = config.ui.qml.state.episode_list_filter self._filtered = [] self._is_subset_view = False self._config = config config.add_observer(self._on_config_changed) is_subset_view_changed = Signal() def get_is_subset_view(self): return self._is_subset_view def set_is_subset_view(self, is_subset_view): if is_subset_view != self.is_subset_view: self._is_subset_view = is_subset_view self.is_subset_view_changed.emit() is_subset_view = Property(bool, get_is_subset_view, set_is_subset_view, notify=is_subset_view_changed) def _on_config_changed(self, name, old_value, new_value): if name == 'ui.qml.state.episode_list_filter': self._filter = new_value self.sort() def sort(self): caption, eql = EPISODE_LIST_FILTERS[self._filter] if eql is None: self._filtered = self._objects else: eql = query.EQL(eql) match = lambda episode: eql.match(episode._episode) self._filtered = filter(match, self._objects) self.reset() def get_objects(self): return self._filtered def get_object(self, index): return self._filtered[index.row()] @Slot(int, result=QObject) def get_object_by_index(self, index): return self._filtered[int(index)] @Slot(result=int) def getFilter(self): return self._filter @Slot(int) def setFilter(self, filter_index): self._config.ui.qml.state.episode_list_filter = filter_index
def __property(type, method): """ @param type type @param method method """ sig = Signal(type) prop = Property(type, method, notify=sig) return prop, sig
class SpellChecker(QObject): def __init__(self, parent=None): super(SpellChecker, self).__init__(parent) self.__d = _SpellChecker(self) def setDocument(self, doc): d = self.__d if d.document is not doc: if doc: doc.destroyed.connect(d.clearDocument) d.document = doc if d.hasHighlighter(): d.highlighter.setDocument(doc if d.enabled else None) self.documentChanged.emit(doc) documentChanged = Signal(QObject) # QtWidgets.QTextDocument document = Property(QObject, lambda self: self.__d.document, setDocument, notify=documentChanged) def setLanguage(self, lang): d = self.__d if d.language != lang: d.language = lang if d.hasHighlighter(): d.highlighter.setLanguage(lang) self.languageChanged.emit(lang) languageChanged = Signal(unicode) language = Property(unicode, lambda self: self.__d.language, setLanguage, notify=languageChanged) def setEnabled(self, value): d = self.__d if value != d.enabled: d.enabled = value d.highlighter.setDocument(d.document if value else None) self.enabledChanged.emit(value) enabledChanged = Signal(bool) enabled = Property(bool, lambda self: self.__d.enabled, setEnabled, notify=enabledChanged)
class ThreadPoolStatus(QObject): def __init__(self, parent=None): super(ThreadPoolStatus, self).__init__(parent) self.__d = _ThreadPoolStatus(self) threadCountChanged = Signal(int) threadCount = Property(int, lambda self: self.__d.activeThreadCount, notify=threadCountChanged)
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 HotkeyManagerProxy(QObject): def __init__(self, parent=None): super(HotkeyManagerProxy, self).__init__(parent) manager().enabledChanged.connect(self.enabledChanged) enabledChanged = Signal(bool) enabled = Property(bool, lambda self: manager().isEnabled(), lambda self, v: manager().setEnabled(v), notify=enabledChanged)
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 ImageView(QWidget): def __init__(self, image=None, parent=None): QWidget.__init__(self, parent) self._image = None self._scale = False def _get_scale(self): return self._scale def _set_scale(self, value): if self._scale != value: self._scale = value self.update() def _get_image(self): return self._image def _set_image(self, image): self._image = image self.update() scale = Property(bool, _get_scale, _set_scale) image = Property(QImage, _get_image, _set_image) def paintEvent(self, event): if self._image is None: return QWidget.paintEvent(self, event) with paint(self) as painter: painter.setRenderHint(QPainter.Antialiasing) painter.setRenderHint(QPainter.HighQualityAntialiasing) pixmap = QPixmap.fromImage(self.image, Qt.AutoColor) scale_factor = 1.0 if self._scale: scale_factor = min(self.width() / pixmap.width(), self.height() / pixmap.height()) translated = (self.size() - (pixmap.size() * scale_factor)) / 2 painter.translate(translated.width(), translated.height()) painter.scale(scale_factor, scale_factor) painter.drawPixmap(0, 0, pixmap)
class JavaScriptObjectToSend(QtCore.QObject): """Simple class with one slot and one read-only property.""" @QtCore.Slot(str) def showMessage(self, msg): """Open a message box and display the specified message.""" QtGui.QMessageBox.information(None, "Info", msg) def _pyVersion(self): """Return the Python version.""" return sys.version """Python interpreter version property.""" pyVersion = Property(str, fget=_pyVersion)
class MyObject(QObject): def __init__(self, text, parent=None): QObject.__init__(self, parent) self._text = text def getText(self): return self._text @Slot(str) def qmlText(self, text): self._qmlText = text title = Property(str, getText)
class Album(QObject): def __init__(self, gService, gAlbum, parent=None): super(Album, self).__init__(parent) self._data = gAlbum self._service = gService self._photos = None def getName(self): return self._data.name.text def getStatus(self): return 0 def getPhotos(self): if not self._photos: self._photos = PhotoListModel(self) return self._photos tag = Property(str, getName) status = Property(int, getStatus) images = Property(QAbstractListModel, getPhotos)
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 Person(QObject): """ use unicode instead of QString """ # * person.h * # private: # QString m_name; # int m_shoeSize; # * person.cpp * # Person::Person(QObject *parent) : QObject(parent), m_shoeSize(0) def __init__(self, parent=None): # these are automatic constructors in C++ # : QObject(parent), m_shoeSize(0) super(Person, self).__init__(parent) # python convention is to use underscore to indicate private member variables self._shoeSize = 0 self._name = "No Name Defined" def getShoeSize(self): return self._shoeSize def setShoeSize(self, value): self._shoeSize = value self.shoeSizeChanged.emit() # since this would clash with the property declaration, we change name --> getName # QString name() const; def getName(self): return self._name # void setName(const QString &); def setName(self, value): self._name = value name = Property(unicode, getName, setName) shoeSize = Property(int, getShoeSize, setShoeSize)
class MyObjectWithNotifyProperty(QObject): def __init__(self, parent=None): QObject.__init__(self, parent) self.p = 0 def readP(self): return self.p def writeP(self, v): self.p = v self.notifyP.emit() notifyP = Signal() myProperty = Property(int, readP, fset=writeP, notify=notifyP)
class SpeechRecognitionBean(QObject): def __init__(self, parent=None): super(SpeechRecognitionBean, self).__init__(parent) m = manager() m.activeChanged.connect(self.activeChanged) m.singleShotChanged.connect(self.singleShotChanged) @Slot() def stop(self): manager().stop() activeChanged = Signal(bool) active = Property(bool, lambda _: manager().isActive(), lambda _, t: manager().setActive(t), notify=activeChanged) singleShotChanged = Signal(bool) singleShot = Property(bool, lambda _: manager().isSingleShot(), lambda _, t: manager().setSingleShot(t), notify=singleShotChanged)
class SkTaskBarObject(SkWindowObject): def __init__(self, parent=None): pyobj = SkTaskBarPyObject() super(SkTaskBarObject, self).__init__(parent, pyObject=pyobj) def setAutoHide(self, t): obj = self.__d.obj if t != obj.autoHide: obj.autoHide = t self.autoHideChanged.emit(t) autoHideChanged = Signal(bool) autoHide = Property(bool, lambda self: self.__d.obj.autoHide, setAutoHide, notify=autoHideChanged)
class ShioriBean(QObject): instance = None def __init__(self, parent=None): super(ShioriBean, self).__init__(parent) self.__d = _ShioriBean() ShioriBean.instance = self ss = settings.global_() self.__d.enabled = ss.isJapaneseDictionaryEnabled() ss.japaneseDictionaryEnabledChanged.connect(self.setEnabled) dprint("pass") def isEnabled(self): return self.__d.enabled def setEnabled(self, v): if self.__d.enabled != v: self.__d.enabled = v self.enabledChanged.emit(v) enabledChanged = Signal(bool) enabled = Property(bool, isEnabled, setEnabled, notify=enabledChanged) @Slot(unicode, unicode, result=unicode) def renderLookup(self, text, language): """ @param text Japanese phrase @param language @return unicode not None html """ if language == 'ja': return self.__d.renderJapanese(text) if language == 'ko': return self.__d.renderKorean(text) return '' @Slot(unicode, result=unicode) def renderJson(self, json): """ @param json term @return unicode not None html """ return self.__d.renderJson(json) popupLookup = Signal(unicode, unicode, int, int) # text, language, x, y popupJson = Signal(unicode, int, int) # json, x, y
class MyObject(QObject): def __init__(self, parent = None): QObject.__init__(self, parent) self._p = 100 def setX(self, value): self._p = value def getX(self): return self._p def resetX(self): self._p = 100 def delX(self): self._p = 0 x = Property(int, getX, setX, resetX, delX)
class StupidClass(QtCore.QObject): """Simple class with one slot and one read-only property.""" @QtCore.Slot(str) def showMessage(self, msg): """Open a message box and display the specified message.""" QtGui.QMessageBox.information(None, "Info", msg) print "asdas" def makeInertison(self,Yo): print Yo def _pyVersion(self): """Return the Python version.""" return sys.version """Python interpreter version property.""" pyVersion = Property(str, fget=_pyVersion)
class TopicInputManagerBean(QObject): def __init__(self, parent=None, manager=None): super(TopicInputManagerBean, self).__init__(parent) self.manager = manager or TopicInputManager(self) self.manager.topicReceived.connect(self.topicReceived) topicReceived = Signal(unicode, unicode) # json topic, json image @Slot(str, long, str) def newTopic(self, topicType, subjectId, subjectType): self.manager.newTopic(topicType, subjectId=subjectId, subjectType=subjectType) imageEnabledChanged = Signal(bool) imageEnabled = Property(bool, lambda self: self.manager.isImageEnabled(), lambda self, t: self.manager.setImageEnabled(t), notify=imageEnabledChanged)
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)
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 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 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)