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)
