def center(self):
frameGm = self.frameGeometry()
screen = QApplication.desktop().screenNumber(
QApplication.desktop().cursor().pos())
centerPoint = QApplication.desktop().screenGeometry(screen).center()
frameGm.moveCenter(centerPoint)
self.move(frameGm.topLeft())
def mousePressEvent(self, QMouseEvent):
self.hide()
xd = QApplication.desktop().screenGeometry().x() - QApplication.desktop().availableGeometry().x()
yd = QApplication.desktop().screenGeometry().y() - QApplication.desktop().availableGeometry().y()
self.pos = numpy.array([QMouseEvent.pos().x()-xd,
QMouseEvent.pos().y()-yd])
self.emit(SIGNAL("mouse_press()"))
def loadUIInfo( self ):
Commands.makeFile( Window.uiInfoPath )
f = open( Window.uiInfoPath, 'r' )
try:data = json.load( f )
except:data = {}
f.close()
if not data.items():
self.resize( self.defaultWidth, self.defaultHeight )
return
try:
posX, posY = data['mainWindow']['position']
width, height = data['mainWindow']['size']
except:
return
desktop = QApplication.desktop()
desktopWidth = desktop.width()
desktopHeight = desktop.height()
if posX + width > desktopWidth: posX = desktopWidth - width
if posY + height > desktopWidth: posY = desktopHeight - height
if posX < 0 : posX = 0
self.move( posX, posY )
self.resize( width, height )
def loadInfo(filePath=None):
if not filePath:
filePath = Window_global.infoPath
f = open(filePath, 'r')
try:
data = json.load(f)
except:
f.close()
return None
f.close()
if not data: return None
try:
posX = data[0]
posY = data[1]
width = data[2]
height = data[3]
Window_global.mainGui.resize(width, height)
desktop = QApplication.desktop()
desktopWidth = desktop.width()
desktopHeight = desktop.height()
if posX + width > desktopWidth: posX = desktopWidth - width
if posY + height > desktopWidth: posY = desktopHeight - height
if posX < 0: posX = 0
if posY < 0: posY = 0
Window_global.mainGui.move(posX, posY)
except:
pass
def __init__(self):
# GL units are ground units
self.rotation = Rotation() # about focus point
self.focus_in_ground = Vec3([0,0,0])
# Human/real-space/user measures:
self.window_size_in_pixels = [640.0, 480.0] # will be overwritten on first resize event
# initialize sceen size to correct value
# ratio of screen distance to screen height:
# measured 2.7 for my home monitor
# 2.5 for Cami's monitor
# 5.0 for our TV
# should not change dynamically, unless we do head tracking
self.distance_to_screen_in_screen_heights = 2.5
# self.distance_to_screen_in_screen_heights = 0.5 # exaggerated perspective for testing
dt = QApplication.desktop()
self.set_screen_size_in_pixels(dt.width(), dt.height())
# Object/ground/gl-units measures:
self.distance_to_focus = 25.0 # changes with zoom level
# viewport parameters for side by side stereo
self.viewport_xrelstart = 0.0
self.viewport_yrelstart = 0.0
self.viewport_relwidth = 1.0
self.viewport_relheight = 1.0
# big value for testing
self.interocular_distance_in_meters = 0.062 # Probably close enough for anyone
self.pixels_per_meter = 3724; # TODO - expose this
self.interocular_distance_in_pixels = self.pixels_per_meter * self.interocular_distance_in_meters;
self.eye_pos = 0.0 # -1.0 for left eye, +1.0 for right eye
self.swap_eyes = False
def loadInfo( filePath = None ):
if not filePath:
filePath = Window_global.infoPath
f = open( filePath, 'r')
try:data = json.load( f )
except: f.close(); return None
f.close()
if not data: return None
try:
posX = data[0]
posY = data[1]
width = data[2]
height = data[3]
Window_global.mainGui.resize( width, height )
desktop = QApplication.desktop()
desktopWidth = desktop.width()
desktopHeight = desktop.height()
if posX + width > desktopWidth: posX = desktopWidth - width
if posY + height > desktopWidth: posY = desktopHeight - height
if posX < 0 : posX = 0
if posY < 0 : posY = 0
Window_global.mainGui.move( posX, posY )
except:
pass
def loadUIInfo(self):
Commands.makeFile(Window.uiInfoPath)
f = open(Window.uiInfoPath, 'r')
try:
data = json.load(f)
except:
data = {}
f.close()
if not data.items():
self.resize(self.defaultWidth, self.defaultHeight)
return
try:
posX, posY = data['mainWindow']['position']
width, height = data['mainWindow']['size']
except:
return
desktop = QApplication.desktop()
desktopWidth = desktop.width()
desktopHeight = desktop.height()
if posX + width > desktopWidth: posX = desktopWidth - width
if posY + height > desktopWidth: posY = desktopHeight - height
if posX < 0: posX = 0
self.move(posX, posY)
self.resize(width, height)
def showEvent(self, event):
# Center the dialog on the screen
super(LoginDialog, self).showEvent(event)
scr = QApplication.desktop().screenGeometry()
self.move(scr.center() - self.rect().center())
def __init__(self):
super(DirectoryDialog, self).__init__()
self.setWindowTitle("Query")
rect = QApplication.desktop().screenGeometry()
height = rect.height()
width = rect.width()
self.setGeometry(width / 3, height / 3, width / 3, height / 8)
formLayout = QFormLayout()
self.dir = QLineEdit()
self.dir.setReadOnly(True)
formLayout.addRow(QLabel("Select a folder"), self.dir)
browseBtn = QPushButton("Browse")
browseBtn.clicked.connect(self.browseAction)
formLayout.addWidget(browseBtn)
btnOk = QPushButton("Ok")
btnOk.clicked.connect(self.okAction)
btnCancel = QPushButton("Cancel")
btnCancel.clicked.connect(self.reject)
group = QDialogButtonBox()
group.addButton(btnOk, QDialogButtonBox.AcceptRole)
group.addButton(btnCancel, QDialogButtonBox.RejectRole)
formLayout.addRow(group)
self.setLayout(formLayout)
self.setWindowIcon(QIcon("res/SplashScreen.png"))
self.__result = None
def screen_size(self):
""" Returns a tuple of the form (width,height) containing the size of
the user's display.
"""
_geom = QApplication.desktop().availableGeometry()
return (_geom.width(), _geom.height())
def loadInfo( self ):
filePath = Window.shapeInfoPath
f = open( filePath, 'r')
try:data = json.load( f )
except: f.close(); return None
f.close()
if not data: return None
try:
posX = data[0]
posY = data[1]
width = data[2]
height = data[3]
desktop = QApplication.desktop()
desktopWidth = desktop.width()
desktopHeight = desktop.height()
if posX + width > desktopWidth: posX = desktopWidth - width
if posY + height > desktopWidth: posY = desktopHeight - height
if posX < 0 : posX = 0
if posY < 0 : posY = 0
self.move( posX, posY )
self.resize( width, height )
except:
self.resize( Window.defaultWidth, Window.defaultHeight )
def loadInfo(filePath=None):
if not filePath:
filePath = Window_global.infoPath
f = open(filePath, 'r')
try:
data = json.load(f)
except:
f.close()
return None
f.close()
if not data: return None
try:
posX = data[0]
posY = data[1]
width = data[2]
height = data[3]
Window_global.mainGui.resize(width, height)
desktop = QApplication.desktop()
desktopWidth = desktop.width()
desktopHeight = desktop.height()
if posX + width > desktopWidth: posX = desktopWidth - width
if posY + height > desktopWidth: posY = desktopHeight - height
if posX < 0: posX = 0
if posY < 0: posY = 0
Window_global.mainGui.move(posX, posY)
children = data[4]
for child in children:
tabText = child["tabText"]
imagePath = child['imagePath']
x, y, scale, rotValue, scaleMultX = child['imagePosition']
Window_global.mainGui.tabWidget.addTab(tabText)
widgets = Window_global.mainGui.tabWidget.widget(
children.index(child)).children()
for widget in widgets:
if widget.__class__ == FilePathLine:
widget.setText(imagePath)
elif widget.__class__ == ImageBase:
widget.loadImage(imagePath)
widget.transInfo.x = x
widget.transInfo.y = y
widget.transInfo.scale = scale
widget.transInfo.rotValue = rotValue
widget.transInfo.scaleMultX = scaleMultX
widget.resize()
cuIndex = data[5]
Window_global.mainGui.tabWidget.setCurrentIndex(cuIndex)
except:
pass
def _showMainWindw(self):
"""Show main window near-by to the system tray icon"""
logging.debug('Main window is shown')
self.setVisible(True)
trayIconGeometry = self.__trayIcon.geometry()
screenGeometry = QApplication.desktop().screenGeometry(trayIconGeometry.topLeft())
self.move(_calculateWindowPosition(screenGeometry, trayIconGeometry, self.width(),
self.height()))
def shoot():
if( not isTokenCollected()):
redirect_to_permission_page()
#taking the screenshot
filename = date.strftime('%Y-%m-%d_%H-%M-%S.jpg')
p = QPixmap.grabWindow(QApplication.desktop().winId())
p.save(filename, 'jpg')
upload_file_to_drive(filename)
def shoot():
if (not isTokenCollected()):
redirect_to_permission_page()
#taking the screenshot
filename = date.strftime('%Y-%m-%d_%H-%M-%S.jpg')
p = QPixmap.grabWindow(QApplication.desktop().winId())
p.save(filename, 'jpg')
upload_file_to_drive(filename)
def sendLocation(self, jid, latitude, longitude, rotate):
latitude = latitude[:10]
longitude = longitude[:10]
self._d("Capturing preview...")
QPixmap.grabWindow(QApplication.desktop().winId()).save(WAConstants.CACHE_PATH+"/tempimg.png", "PNG")
img = QImage(WAConstants.CACHE_PATH+"/tempimg.png")
if rotate == "true":
rot = QTransform()
rot = rot.rotate(90)
img = img.transformed(rot)
if img.height() > img.width():
result = img.scaledToWidth(320,Qt.SmoothTransformation);
result = result.copy(result.width()/2-50,result.height()/2-50,100,100);
elif img.height() < img.width():
result = img.scaledToHeight(320,Qt.SmoothTransformation);
result = result.copy(result.width()/2-50,result.height()/2-50,100,100);
#result = img.scaled(96, 96, Qt.KeepAspectRatioByExpanding, Qt.SmoothTransformation);
result.save( WAConstants.CACHE_PATH+"/tempimg2.jpg", "JPG" );
f = open(WAConstants.CACHE_PATH+"/tempimg2.jpg", 'r')
stream = base64.b64encode(f.read())
f.close()
os.remove(WAConstants.CACHE_PATH+"/tempimg.png")
os.remove(WAConstants.CACHE_PATH+"/tempimg2.jpg")
fmsg = WAXMPP.message_store.createMessage(jid);
mediaItem = WAXMPP.message_store.store.Media.create()
mediaItem.mediatype_id = WAConstants.MEDIA_TYPE_LOCATION
mediaItem.remote_url = None
mediaItem.preview = stream
mediaItem.local_path ="%s,%s"%(latitude,longitude)
mediaItem.transfer_status = 2
fmsg.content = QtCore.QCoreApplication.translate("WAEventHandler", "Location")
fmsg.Media = mediaItem
if fmsg.Conversation.type == "group":
contact = WAXMPP.message_store.store.Contact.getOrCreateContactByJid(self.conn.jid)
fmsg.setContact(contact);
fmsg.setData({"status":0,"content":fmsg.content,"type":1})
WAXMPP.message_store.pushMessage(jid,fmsg)
resultId = self.interfaceHandler.call("message_locationSend", (jid, latitude, longitude, stream))
k = Key(jid, True, resultId)
fmsg.key = k.toString()
fmsg.save()
def mouseReleaseEvent(self, event):
self.rubberBand.hide()
if self.havePressed == True:
self.end = event.pos()
self.hide()
QPixmap.grabWindow(QApplication.desktop().winId(), self.origin.x(),
self.origin.y(),
self.end.x() - self.origin.x(),
self.end.y() - self.origin.y()).save(
'C:/Users/Ta/screenshot_windowed.png',
'png')
def grabImg(self): self.idFrame += 1 wid = QApplication.desktop().winId() QPixmap.grabWindow(wid, self.screenArea.x, self.screenArea.y, self.screenArea.w, self.screenArea.h).save(self.buffer, 'png') strio = StringIO.StringIO() strio.write(self.buffer.data()) self.buffer.seek(0) strio.seek(0) pix = np.array(Image.open(strio)) pix = cv2.resize(pix, (0,0), fx=self.scale, fy=self.scale) real_color = cv2.cvtColor(pix, cv2.COLOR_BGR2RGB) return real_color
def getAppLabel(self):
'''
Gets label to be displayed in widget
'''
appTitle = QLabel(CUSTOMER_NAME)
appTitle.setAlignment(Qt.AlignCenter)
appTitle.setFixedHeight(
QApplication.desktop().screenGeometry().height() / 20)
appTitle.setStyleSheet(
"border-style:ridge;border: 2px solid red; border-radius: 3px;"
"background-color: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #7EC0EE, stop: 1 #7EC0EE);"
"min-width: 40px;color: red;font-size: 54px; font-style=bold italic large 'New Century Schoolbook'"
)
return appTitle
def __init__(self):
QWidget.__init__(self,None,Qt.Window)
self.layout = QGridLayout()
self.setLayout(self.layout)
self.showMaximized()
self.activateWindow()
self.raise_()
self.setWindowFlags(Qt.Window | Qt.WindowStaysOnTopHint | Qt.X11BypassWindowManagerHint \
| Qt.FramelessWindowHint )
screenGeometry = QApplication.desktop().availableGeometry();
self.setGeometry(screenGeometry)
self.setStyleSheet("QWidget { background-color: rgba(255,255,255, 5%); }")
def get_display_size():
size = namedtuple('Size', 'width height')
# if IsQt():
# from PySide.QtGui import QDesktopWidget
from PySide.QtGui import QApplication
desktop = QApplication.desktop()
rect = desktop.screenGeometry()
w, h = rect.width(), rect.height()
# else:
# import wx
# rect = wx.GetDisplaySize()
# w, h = rect.width, rect.height
#
return size(w, h)
def get_display_size():
size = namedtuple('Size', 'width height')
# if IsQt():
# from PySide.QtGui import QDesktopWidget
from PySide.QtGui import QApplication
desktop = QApplication.desktop()
rect = desktop.screenGeometry()
w, h = rect.width(), rect.height()
# else:
# import wx
# rect = wx.GetDisplaySize()
# w, h = rect.width, rect.height
#
return size(w, h)
def grabImg(self):
self.idFrame += 1
wid = QApplication.desktop().winId()
QPixmap.grabWindow(wid, self.screenArea.x, self.screenArea.y,
self.screenArea.w,
self.screenArea.h).save(self.buffer, 'png')
strio = StringIO.StringIO()
strio.write(self.buffer.data())
self.buffer.seek(0)
strio.seek(0)
pix = np.array(Image.open(strio))
pix = cv2.resize(pix, (0, 0), fx=self.scale, fy=self.scale)
real_color = cv2.cvtColor(pix, cv2.COLOR_BGR2RGB)
return real_color
def init():
logging.debug('PySide ver: %s (lib path: %s)', PySide.__version__,
QLibraryInfo.location(QLibraryInfo.LibrariesPath))
app = QApplication(sys.argv)
app.setWindowIcon(makeQIcon(':/appicon-24.png', ':/appicon-48.png'))
global scaleRatio
scaleRatio = app.desktop().logicalDpiX() / 96 # when will x != y happen?
logging.debug('DPI scale ratio %s' % scaleRatio)
setTranslationLocale()
global font
font = Fonts()
font.load()
setStyleSheet()
return app
def read_settings(self):
settings = get_settings()
screen = QApplication.desktop().screenGeometry()
h = min(screen.height() * 5 / 6., 900)
size = QSize(min(screen.width() * 5 / 6., 1200), h)
pos = settings.value("pos", None)
savesize = settings.value("size", size)
if savesize.width() > screen.width():
savesize.setWidth(size.width())
if savesize.height() > screen.height():
savesize.setHeight(size.height())
self.resize(savesize)
if ((pos is None or pos.x() + savesize.width() > screen.width() or
pos.y() + savesize.height() > screen.height())):
self.move(screen.center() - self.rect().center())
else:
self.move(pos)
def drag(self, x, y ):
if self.dragMode == 0: return None
if self.dragMode == 1:
import math
addRotValue = (x - self.pressX )/3.0
self.rotValue = self.bRotValue + addRotValue
if self.shiftPressed:
elseValue = self.rotValue % 90
if math.fabs( elseValue ) < 5:
self.rotValue -= elseValue
addRotValue -= elseValue
elif math.fabs( elseValue ) > 85:
self.rotValue = self.rotValue + 90 - elseValue
addRotValue = addRotValue + 90 - elseValue
radValue = math.radians( addRotValue )
sinValue = math.sin( radValue )
cosValue = math.cos( radValue )
movedX = self.bx * cosValue - self.by * sinValue
movedY = self.bx * sinValue + self.by * cosValue
self.x = movedX
self.y = movedY
elif self.dragMode == 4:
moveX = x - self.pressX
moveY = y - self.pressY
self.x = moveX + self.bx
self.y = moveY + self.by
elif self.dragMode == 2:
moveX = x - self.pressX
rect = QApplication.desktop().screenGeometry();
height = rect.height()/4
self.scale = self.bScale * (2**(float(moveX)/height))
scaledValue = self.scale/ self.bScale
self.x = (self.bx - self.pressX) * scaledValue + self.pressX
self.y = (self.by - self.pressY) * scaledValue + self.pressY
def drag(self, x, y ):
if self.dragMode == 0: return None
if self.dragMode == 1:
import math
addRotValue = (x - self.pressX )/3.0
self.rotValue = self.bRotValue + addRotValue
if self.shiftPressed:
elseValue = self.rotValue % 90
if math.fabs( elseValue ) < 5:
self.rotValue -= elseValue
addRotValue -= elseValue
elif math.fabs( elseValue ) > 85:
self.rotValue = self.rotValue + 90 - elseValue
addRotValue = addRotValue + 90 - elseValue
radValue = math.radians( addRotValue )
sinValue = math.sin( radValue )
cosValue = math.cos( radValue )
movedX = self.bx * cosValue - self.by * sinValue
movedY = self.bx * sinValue + self.by * cosValue
self.x = movedX
self.y = movedY
elif self.dragMode == 4:
moveX = x - self.pressX
moveY = y - self.pressY
self.x = moveX + self.bx
self.y = moveY + self.by
elif self.dragMode == 2:
moveX = x - self.pressX
rect = QApplication.desktop().screenGeometry();
height = rect.height()/4
self.scale = self.bScale * (2**(float(moveX)/height))
scaledValue = self.scale/ self.bScale
self.x = (self.bx - self.pressX) * scaledValue + self.pressX
self.y = (self.by - self.pressY) * scaledValue + self.pressY
def capture(self):
app.processEvents()
print "caught capture",('tmp_{}_{:'+self.fmt+'}.jpg').format(self.UID,self.capture_count)
print "current fps",float(self.capture_count)/(time.time()-self.start_capture_time)
if not self.snap_shots.queue.empty():
self.snap_shots.queue.get(0)
arrow = QPixmap(self.arrow_icon);
self.px = QPixmap.grabWindow(QApplication.desktop().winId())
painter = QPainter(self.px)
painter.drawPixmap(QCursor.pos(), arrow)
if(self.options.capture_area_sa.isChecked()):
self.px2 = self.px.copy(self.options.sa_x.value(),
self.options.sa_y.value(),
self.options.sa_w.value(),
self.options.sa_h.value())
else:
self.px2 = self.px
self.px2.save(('tmp_{}_{:'+self.fmt+'}.jpg').format(self.UID,self.capture_count), 'jpg')
self.capture_count+=1
def __init__(self, kind, module, parent=None):
super(DefaultsDialog, self).__init__()
self.clipboard = parent.clipboard
self.setWindowTitle("%s : %s" % (kind, module))
self.setGeometry(0, 0, 500, 500)
self.move(
QApplication.desktop().screenGeometry().center() - self.rect().center())
self.show()
# Main layout
self.layout = QVBoxLayout()
self.setLayout(self.layout)
self.display_tabs = QTabWidget()
self.display = {}
for k in ["yaml", "python", "bibliography"]:
self.display[k] = QTextEdit()
self.display[k].setLineWrapMode(QTextEdit.NoWrap)
self.display[k].setFontFamily("mono")
self.display[k].setCursorWidth(0)
self.display[k].setReadOnly(True)
self.display_tabs.addTab(self.display[k], k)
self.layout.addWidget(self.display_tabs)
# Fill text
defaults_txt = get_default_info(
module, kind, return_yaml=True, fail_if_not_found=True)
from cobaya.yaml import yaml_load
self.display["python"].setText(
"from collections import OrderedDict\n\ninfo = " +
pformat(yaml_load(defaults_txt)))
self.display["yaml"].setText(defaults_txt)
self.display["bibliography"].setText(get_bib_module(module, kind))
# Buttons
self.buttons = QHBoxLayout()
self.close_button = QPushButton('Close', self)
self.copy_button = QPushButton('Copy to clipboard', self)
self.buttons.addWidget(self.close_button)
self.buttons.addWidget(self.copy_button)
self.close_button.released.connect(self.close)
self.copy_button.released.connect(self.copy_clipb)
self.layout.addLayout(self.buttons)
def loadUIInfo( self ):
try:
BaseCommands.makeFile( Window.uiInfoPath )
f = open( Window.uiInfoPath, 'r' )
data = json.load( f )
f.close()
posX, posY = data['position']
width, height = data['size']
desktop = QApplication.desktop()
desktopWidth = desktop.width()
desktopHeight = desktop.height()
if posX + width > desktopWidth: posX = desktopWidth - width
if posY + height > desktopWidth: posY = desktopHeight - height
if posX < 0 : posX = 0
self.move( posX, posY )
self.resize( width, height )
except:
self.resize( self.defaultWidth, self.defaultHeight )
def _centerWindow(self):
displayWidth = QApplication.desktop().width()
displayHeight = QApplication.desktop().height()
self.move(displayWidth/2.0 - self._initWidth/2.0,
displayHeight/2.0 - self._initHeight/2.0 - 50)
def screenshot_callback():
screenshot = QPixmap.grabWidget(window)
screenshot = QPixmap.grabWindow(QApplication.desktop().winId())
screenshot.save("screenshot-main.png")
def screenshot_callback3():
window.show_presence_overview()
screenshot = QPixmap.grabWidget(window)
screenshot = QPixmap.grabWindow(QApplication.desktop().winId())
screenshot.save("screenshot-presence.png")
class qtPodder(QObject):
def __init__(self, args, gpodder_core, dbus_bus_name):
QObject.__init__(self)
self.dbus_bus_name = dbus_bus_name
# TODO: Expose the same D-Bus API as the Gtk UI D-Bus object (/gui)
# TODO: Create a gpodder.dbusproxy.DBusPodcastsProxy object (/podcasts)
self.app = QApplication(args)
signal.signal(signal.SIGINT, signal.SIG_DFL)
self.quit.connect(self.on_quit)
self.episodeUpdated.connect(self.on_episode_updated)
self.setEpisodeListModel.connect(self.on_set_episode_list_model)
self.core = gpodder_core
self.config = self.core.config
self.db = self.core.db
self.model = self.core.model
self.config_proxy = ConfigProxy(self.config)
# Initialize the gpodder.net client
self.mygpo_client = my.MygPoClient(self.config)
gpodder.user_extensions.on_ui_initialized(self.model,
self.extensions_podcast_update_cb,
self.extensions_episode_download_cb)
self.view = DeclarativeView()
self.view.closing.connect(self.on_quit)
self.view.setResizeMode(QDeclarativeView.SizeRootObjectToView)
self.controller = Controller(self)
self.media_buttons_handler = helper.MediaButtonsHandler()
self.tracker_miner_config = helper.TrackerMinerConfig()
self.podcast_model = gPodderPodcastListModel()
self.episode_model = gPodderEpisodeListModel(self.config, self)
self.last_episode = None
# A dictionary of episodes that are currently active
# in some way (i.e. playing back or downloading)
self.active_episode_wrappers = {}
engine = self.view.engine()
# Add the cover art image provider
self.cover_provider = images.LocalCachedImageProvider()
engine.addImageProvider('cover', self.cover_provider)
root_context = self.view.rootContext()
root_context.setContextProperty('controller', self.controller)
root_context.setContextProperty('configProxy', self.config_proxy)
root_context.setContextProperty('mediaButtonsHandler',
self.media_buttons_handler)
root_context.setContextProperty('trackerMinerConfig',
self.tracker_miner_config)
# Load the QML UI (this could take a while...)
self.view.setSource(QUrl.fromLocalFile(QML('main_default.qml')))
# Proxy to the "main" QML object for direct access to Qt Properties
self.main = helper.QObjectProxy(self.view.rootObject().property('main'))
self.main.podcastModel = self.podcast_model
self.main.episodeModel = self.episode_model
self.view.setWindowTitle('gPodder')
if gpodder.ui.harmattan:
self.view.showFullScreen()
else:
# On the Desktop, scale to fit my small laptop screen..
desktop = self.app.desktop()
if desktop.height() < 1000:
FACTOR = .8
self.view.scale(FACTOR, FACTOR)
size = self.view.size()
size *= FACTOR
self.view.resize(size)
self.view.show()
self.do_start_progress.connect(self.on_start_progress)
self.do_end_progress.connect(self.on_end_progress)
self.do_show_message.connect(self.on_show_message)
podcasts = self.load_podcasts()
self.resumable_episodes = None
self.do_offer_download_resume.connect(self.on_offer_download_resume)
util.run_in_background(self.find_partial_downloads(podcasts))
def find_partial_downloads(self, podcasts):
def start_progress_callback(count):
self.start_progress(_('Loading incomplete downloads'))
def progress_callback(title, progress):
self.start_progress('%s (%d%%)' % (
_('Loading incomplete downloads'),
progress*100))
def finish_progress_callback(resumable_episodes):
self.end_progress()
self.resumable_episodes = resumable_episodes
self.do_offer_download_resume.emit()
common.find_partial_downloads(podcasts,
start_progress_callback,
progress_callback,
finish_progress_callback)
do_offer_download_resume = Signal()
def on_offer_download_resume(self):
if self.resumable_episodes:
def download_episodes():
for episode in self.resumable_episodes:
qepisode = self.wrap_simple_episode(episode)
self.controller.downloadEpisode(qepisode)
def delete_episodes():
logger.debug('Deleting incomplete downloads.')
common.clean_up_downloads(delete_partial=True)
message = _('Incomplete downloads from a previous session were found.')
title = _('Resume')
self.controller.confirm_action(message, title, download_episodes, delete_episodes)
def add_active_episode(self, episode):
self.active_episode_wrappers[episode.id] = episode
episode.episode_wrapper_refcount += 1
def remove_active_episode(self, episode):
episode.episode_wrapper_refcount -= 1
if episode.episode_wrapper_refcount == 0:
del self.active_episode_wrappers[episode.id]
def load_last_episode(self):
last_episode = None
last_podcast = None
for podcast in self.podcast_model.get_podcasts():
for episode in podcast.get_all_episodes():
if not episode.last_playback:
continue
if last_episode is None or \
episode.last_playback > last_episode.last_playback:
last_episode = episode
last_podcast = podcast
if last_episode is not None:
self.last_episode = self.wrap_episode(last_podcast, last_episode)
# FIXME: Send last episode to player
#self.select_episode(self.last_episode)
def on_episode_deleted(self, episode):
# Remove episode from play queue (if it's in there)
self.main.removeQueuedEpisode(episode)
# If the episode that has been deleted is currently
# being played back (or paused), stop playback now.
if self.main.currentEpisode == episode:
self.main.togglePlayback(None)
def enqueue_episode(self, episode):
self.main.enqueueEpisode(episode)
def run(self):
return self.app.exec_()
quit = Signal()
def on_quit(self):
# Make sure the audio playback is stopped immediately
self.main.togglePlayback(None)
self.save_pending_data()
self.view.hide()
self.core.shutdown()
self.app.quit()
episodeUpdated = Signal(int)
def on_episode_updated(self, episode_id):
self.main.episodeUpdated(episode_id)
setEpisodeListModel = Signal(object)
def on_set_episode_list_model(self, prepared):
self.main.setEpisodeListModel(prepared)
do_show_message = Signal(unicode)
@Slot(unicode)
def on_show_message(self, message):
self.main.showMessage(message)
def show_message(self, message):
self.do_show_message.emit(message)
def show_input_dialog(self, message, value='', accept=_('OK'),
reject=_('Cancel'), is_text=True):
self.main.showInputDialog(message, value, accept, reject, is_text)
def open_context_menu(self, items):
self.main.openContextMenu(items)
do_start_progress = Signal(str)
@Slot(str)
def on_start_progress(self, text):
self.main.startProgress(text)
def start_progress(self, text=_('Please wait...')):
self.do_start_progress.emit(text)
do_end_progress = Signal()
@Slot()
def on_end_progress(self):
self.main.endProgress()
def end_progress(self):
self.do_end_progress.emit()
def resort_podcast_list(self):
self.podcast_model.sort()
def insert_podcast(self, podcast):
self.podcast_model.insert_object(podcast)
self.mygpo_client.on_subscribe([podcast.url])
self.mygpo_client.flush()
def remove_podcast(self, podcast):
# Remove queued episodes for this specific podcast
self.main.removeQueuedEpisodesForPodcast(podcast)
if self.main.currentEpisode is not None:
# If the currently-playing episode is in the podcast
# that is to be deleted, stop playback immediately.
if self.main.currentEpisode.qpodcast == podcast:
self.main.togglePlayback(None)
self.podcast_model.remove_object(podcast)
self.mygpo_client.on_unsubscribe([podcast.url])
self.mygpo_client.flush()
def load_podcasts(self):
podcasts = map(model.QPodcast, self.model.get_podcasts())
self.podcast_model.set_podcasts(self.db, podcasts)
return podcasts
def wrap_episode(self, podcast, episode):
try:
return self.active_episode_wrappers[episode.id]
except KeyError:
return model.QEpisode(self, podcast, episode)
def wrap_simple_episode(self, episode):
for podcast in self.podcast_model.get_podcasts():
if podcast.id == episode.podcast_id:
return self.wrap_episode(podcast, episode)
return None
def select_podcast(self, podcast):
if isinstance(podcast, model.QPodcast):
# Normal QPodcast instance
wrap = functools.partial(self.wrap_episode, podcast)
objects = podcast.get_all_episodes()
self.episode_model.set_is_subset_view(False)
else:
# EpisodeSubsetView
wrap = lambda args: self.wrap_episode(*args)
objects = podcast.get_all_episodes_with_podcast()
self.episode_model.set_is_subset_view(True)
self.episode_model.set_objects(map(wrap, objects))
self.main.state = 'episodes'
def save_pending_data(self):
current_ep = self.main.currentEpisode
if isinstance(current_ep, model.QEpisode):
current_ep.save()
def podcast_to_qpodcast(self, podcast):
podcasts = filter(lambda p: p._podcast == podcast,
self.podcast_model.get_podcasts())
assert len(podcasts) <= 1
if podcasts:
return podcasts[0]
return None
def extensions_podcast_update_cb(self, podcast):
logger.debug('extensions_podcast_update_cb(%s)', podcast)
try:
qpodcast = self.podcast_to_qpodcast(podcast)
if qpodcast is not None and not qpodcast.pause_subscription:
qpodcast.qupdate(
finished_callback=self.controller.update_subset_stats)
except Exception, e:
logger.exception('extensions_podcast_update_cb(%s): %s', podcast, e)
#refactor
def _quit():
app.quit()
qDebug('bye!')
def show_window(thereason):
if thereason == QSystemTrayIcon.ActivationReason.Trigger:
if main_window.isVisible() == True:
main_window.hide()
main_window.show()
#create the QApplication instance before any other widget
app = QApplication(sys.argv)
app.setQuitOnLastWindowClosed(False)
ico = QIcon(os.path.join(os.getcwd(),'yhn.png'))
systrayico = QSystemTrayIcon(ico)
systrayico.activated.connect(show_window)
systrayico.show()
x_pos = systrayico.geometry().left()
y_pos = app.desktop().availableGeometry(app.desktop().primaryScreen()).topLeft().y()
main_window = MainWindow(x_pos, y_pos, 420, 500)
sys.exit(app.exec_())
class qtPodder(QObject):
def __init__(self, args, gpodder_core, dbus_bus_name):
QObject.__init__(self)
self.dbus_bus_name = dbus_bus_name
# TODO: Expose the same D-Bus API as the Gtk UI D-Bus object (/gui)
# TODO: Create a gpodder.dbusproxy.DBusPodcastsProxy object (/podcasts)
self.app = QApplication(args)
signal.signal(signal.SIGINT, signal.SIG_DFL)
self.quit.connect(self.on_quit)
self.episodeUpdated.connect(self.on_episode_updated)
self.setEpisodeListModel.connect(self.on_set_episode_list_model)
self.core = gpodder_core
self.config = self.core.config
self.db = self.core.db
self.model = self.core.model
self.config_proxy = ConfigProxy(self.config)
# Initialize the gpodder.net client
self.mygpo_client = my.MygPoClient(self.config)
gpodder.user_extensions.on_ui_initialized(
self.model, self.extensions_podcast_update_cb,
self.extensions_episode_download_cb)
self.view = DeclarativeView()
self.view.closing.connect(self.on_quit)
self.view.setResizeMode(QDeclarativeView.SizeRootObjectToView)
self.controller = Controller(self)
self.media_buttons_handler = helper.MediaButtonsHandler()
self.tracker_miner_config = helper.TrackerMinerConfig()
self.podcast_model = gPodderPodcastListModel()
self.episode_model = gPodderEpisodeListModel(self.config, self)
self.last_episode = None
# A dictionary of episodes that are currently active
# in some way (i.e. playing back or downloading)
self.active_episode_wrappers = {}
engine = self.view.engine()
# Add the cover art image provider
self.cover_provider = images.LocalCachedImageProvider()
engine.addImageProvider('cover', self.cover_provider)
root_context = self.view.rootContext()
root_context.setContextProperty('controller', self.controller)
root_context.setContextProperty('configProxy', self.config_proxy)
root_context.setContextProperty('mediaButtonsHandler',
self.media_buttons_handler)
root_context.setContextProperty('trackerMinerConfig',
self.tracker_miner_config)
# Load the QML UI (this could take a while...)
self.view.setSource(QUrl.fromLocalFile(QML('main_default.qml')))
# Proxy to the "main" QML object for direct access to Qt Properties
self.main = helper.QObjectProxy(
self.view.rootObject().property('main'))
self.main.podcastModel = self.podcast_model
self.main.episodeModel = self.episode_model
self.view.setWindowTitle('gPodder')
if gpodder.ui.harmattan:
self.view.showFullScreen()
else:
# On the Desktop, scale to fit my small laptop screen..
desktop = self.app.desktop()
if desktop.height() < 1000:
FACTOR = .8
self.view.scale(FACTOR, FACTOR)
size = self.view.size()
size *= FACTOR
self.view.resize(size)
self.view.show()
self.do_start_progress.connect(self.on_start_progress)
self.do_end_progress.connect(self.on_end_progress)
self.do_show_message.connect(self.on_show_message)
podcasts = self.load_podcasts()
self.resumable_episodes = None
self.do_offer_download_resume.connect(self.on_offer_download_resume)
util.run_in_background(self.find_partial_downloads(podcasts))
def find_partial_downloads(self, podcasts):
def start_progress_callback(count):
self.start_progress(_('Loading incomplete downloads'))
def progress_callback(title, progress):
self.start_progress(
'%s (%d%%)' %
(_('Loading incomplete downloads'), progress * 100))
def finish_progress_callback(resumable_episodes):
self.end_progress()
self.resumable_episodes = resumable_episodes
self.do_offer_download_resume.emit()
common.find_partial_downloads(podcasts, start_progress_callback,
progress_callback,
finish_progress_callback)
do_offer_download_resume = Signal()
def on_offer_download_resume(self):
if self.resumable_episodes:
def download_episodes():
for episode in self.resumable_episodes:
qepisode = self.wrap_simple_episode(episode)
self.controller.downloadEpisode(qepisode)
def delete_episodes():
logger.debug('Deleting incomplete downloads.')
common.clean_up_downloads(delete_partial=True)
message = _(
'Incomplete downloads from a previous session were found.')
title = _('Resume')
self.controller.confirm_action(message, title, download_episodes,
delete_episodes)
def add_active_episode(self, episode):
self.active_episode_wrappers[episode.id] = episode
episode.episode_wrapper_refcount += 1
def remove_active_episode(self, episode):
episode.episode_wrapper_refcount -= 1
if episode.episode_wrapper_refcount == 0:
del self.active_episode_wrappers[episode.id]
def load_last_episode(self):
last_episode = None
last_podcast = None
for podcast in self.podcast_model.get_podcasts():
for episode in podcast.get_all_episodes():
if not episode.last_playback:
continue
if last_episode is None or \
episode.last_playback > last_episode.last_playback:
last_episode = episode
last_podcast = podcast
if last_episode is not None:
self.last_episode = self.wrap_episode(last_podcast, last_episode)
# FIXME: Send last episode to player
#self.select_episode(self.last_episode)
def on_episode_deleted(self, episode):
# Remove episode from play queue (if it's in there)
self.main.removeQueuedEpisode(episode)
# If the episode that has been deleted is currently
# being played back (or paused), stop playback now.
if self.main.currentEpisode == episode:
self.main.togglePlayback(None)
def enqueue_episode(self, episode):
self.main.enqueueEpisode(episode)
def run(self):
return self.app.exec_()
quit = Signal()
def on_quit(self):
# Make sure the audio playback is stopped immediately
self.main.togglePlayback(None)
self.save_pending_data()
self.view.hide()
self.core.shutdown()
self.app.quit()
episodeUpdated = Signal(int)
def on_episode_updated(self, episode_id):
self.main.episodeUpdated(episode_id)
setEpisodeListModel = Signal(object)
def on_set_episode_list_model(self, prepared):
self.main.setEpisodeListModel(prepared)
do_show_message = Signal(unicode)
@Slot(unicode)
def on_show_message(self, message):
self.main.showMessage(message)
def show_message(self, message):
self.do_show_message.emit(message)
def show_input_dialog(self,
message,
value='',
accept=_('OK'),
reject=_('Cancel'),
is_text=True):
self.main.showInputDialog(message, value, accept, reject, is_text)
def open_context_menu(self, items):
self.main.openContextMenu(items)
do_start_progress = Signal(str)
@Slot(str)
def on_start_progress(self, text):
self.main.startProgress(text)
def start_progress(self, text=_('Please wait...')):
self.do_start_progress.emit(text)
do_end_progress = Signal()
@Slot()
def on_end_progress(self):
self.main.endProgress()
def end_progress(self):
self.do_end_progress.emit()
def resort_podcast_list(self):
self.podcast_model.sort()
def insert_podcast(self, podcast):
self.podcast_model.insert_object(podcast)
self.mygpo_client.on_subscribe([podcast.url])
self.mygpo_client.flush()
def remove_podcast(self, podcast):
# Remove queued episodes for this specific podcast
self.main.removeQueuedEpisodesForPodcast(podcast)
if self.main.currentEpisode is not None:
# If the currently-playing episode is in the podcast
# that is to be deleted, stop playback immediately.
if self.main.currentEpisode.qpodcast == podcast:
self.main.togglePlayback(None)
self.podcast_model.remove_object(podcast)
self.mygpo_client.on_unsubscribe([podcast.url])
self.mygpo_client.flush()
def load_podcasts(self):
podcasts = map(model.QPodcast, self.model.get_podcasts())
self.podcast_model.set_podcasts(self.db, podcasts)
return podcasts
def wrap_episode(self, podcast, episode):
try:
return self.active_episode_wrappers[episode.id]
except KeyError:
return model.QEpisode(self, podcast, episode)
def wrap_simple_episode(self, episode):
for podcast in self.podcast_model.get_podcasts():
if podcast.id == episode.podcast_id:
return self.wrap_episode(podcast, episode)
return None
def select_podcast(self, podcast):
if isinstance(podcast, model.QPodcast):
# Normal QPodcast instance
wrap = functools.partial(self.wrap_episode, podcast)
objects = podcast.get_all_episodes()
self.episode_model.set_is_subset_view(False)
else:
# EpisodeSubsetView
wrap = lambda args: self.wrap_episode(*args)
objects = podcast.get_all_episodes_with_podcast()
self.episode_model.set_is_subset_view(True)
self.episode_model.set_objects(map(wrap, objects))
self.main.state = 'episodes'
def save_pending_data(self):
current_ep = self.main.currentEpisode
if isinstance(current_ep, model.QEpisode):
current_ep.save()
def podcast_to_qpodcast(self, podcast):
podcasts = filter(lambda p: p._podcast == podcast,
self.podcast_model.get_podcasts())
assert len(podcasts) <= 1
if podcasts:
return podcasts[0]
return None
def extensions_podcast_update_cb(self, podcast):
logger.debug('extensions_podcast_update_cb(%s)', podcast)
try:
qpodcast = self.podcast_to_qpodcast(podcast)
if qpodcast is not None and not qpodcast.pause_subscription:
qpodcast.qupdate(
finished_callback=self.controller.update_subset_stats)
except Exception, e:
logger.exception('extensions_podcast_update_cb(%s): %s', podcast,
e)
def __init__(self):
super(MainWindow, self).__init__()
self.setWindowTitle("Cobaya input generator for Cosmology")
self.setGeometry(0, 0, 1500, 1000)
self.move(
QApplication.desktop().screenGeometry().center() - self.rect().center())
self.show()
# Main layout
self.layout = QHBoxLayout()
self.setLayout(self.layout)
self.layout_left = QVBoxLayout()
self.layout.addLayout(self.layout_left)
self.layout_output = QVBoxLayout()
self.layout.addLayout(self.layout_output)
# LEFT: Options
self.options = QWidget()
self.layout_options = QVBoxLayout()
self.options.setLayout(self.layout_options)
self.options_scroll = QScrollArea()
self.options_scroll.setWidget(self.options)
self.options_scroll.setWidgetResizable(True)
self.layout_left.addWidget(self.options_scroll)
titles = odict([
["Presets", odict([["preset", "Presets"]])],
["Cosmological Model", odict([
["theory", "Theory code"],
["primordial", "Primordial perturbations"],
["geometry", "Geometry"],
["hubble", "Hubble parameter constraint"],
["matter", "Matter sector"],
["neutrinos", "Neutrinos and other extra matter"],
["dark_energy", "Lambda / Dark energy"],
["bbn", "BBN"],
["reionization", "Reionization history"]])],
["Data sets", odict([
["like_cmb", "CMB experiments"],
["like_bao", "BAO experiments"],
["like_sn", "SN experiments"],
["like_H0", "Local H0 measurements"]])],
["Sampler", odict([["sampler", "Samplers"]])]])
self.combos = odict()
for group, fields in titles.items():
group_box = QGroupBox(group)
self.layout_options.addWidget(group_box)
group_layout = QVBoxLayout(group_box)
for a, desc in fields.items():
self.combos[a] = QComboBox()
if len(fields) > 1:
label = QLabel(desc)
group_layout.addWidget(label)
group_layout.addWidget(self.combos[a])
self.combos[a].addItems(
[text(k, v) for k, v in getattr(input_database, a).items()])
# PLANCK NAMES CHECKBOX TEMPORARILY DISABLED
# if a == "theory":
# # Add Planck-naming checkbox
# self.planck_names = QCheckBox(
# "Keep common parameter names "
# "(useful for fast CLASS/CAMB switching)")
# group_layout.addWidget(self.planck_names)
# Connect to refreshers -- needs to be after adding all elements
for field, combo in self.combos.items():
if field == "preset":
combo.currentIndexChanged.connect(self.refresh_preset)
else:
combo.currentIndexChanged.connect(self.refresh)
# self.planck_names.stateChanged.connect(self.refresh_keep_preset)
# RIGHT: Output + buttons
self.display_tabs = QTabWidget()
self.display = {}
for k in ["yaml", "python", "citations"]:
self.display[k] = QTextEdit()
self.display[k].setLineWrapMode(QTextEdit.NoWrap)
self.display[k].setFontFamily("mono")
self.display[k].setCursorWidth(0)
self.display[k].setReadOnly(True)
self.display_tabs.addTab(self.display[k], k)
self.layout_output.addWidget(self.display_tabs)
# Buttons
self.buttons = QHBoxLayout()
self.save_button = QPushButton('Save', self)
self.copy_button = QPushButton('Copy to clipboard', self)
self.buttons.addWidget(self.save_button)
self.buttons.addWidget(self.copy_button)
self.save_button.released.connect(self.save_file)
self.copy_button.released.connect(self.copy_clipb)
self.layout_output.addLayout(self.buttons)
self.save_dialog = QFileDialog()
self.save_dialog.setFileMode(QFileDialog.AnyFile)
self.save_dialog.setAcceptMode(QFileDialog.AcceptSave)
class qtPodder(QObject):
def __init__(self, args, gpodder_core, dbus_bus_name):
QObject.__init__(self)
self.dbus_bus_name = dbus_bus_name
# TODO: Expose the same D-Bus API as the Gtk UI D-Bus object (/gui)
# TODO: Create a gpodder.dbusproxy.DBusPodcastsProxy object (/podcasts)
# Enable OpenGL rendering without requiring QtOpenGL
# On Harmattan we let the system choose the best graphicssystem
if '-graphicssystem' not in args and not gpodder.ui.harmattan:
if gpodder.ui.fremantle:
args += ['-graphicssystem', 'opengl']
elif not gpodder.win32:
args += ['-graphicssystem', 'raster']
self.app = QApplication(args)
signal.signal(signal.SIGINT, signal.SIG_DFL)
self.quit.connect(self.on_quit)
self.core = gpodder_core
self.config = self.core.config
self.db = self.core.db
self.model = self.core.model
self.config_proxy = ConfigProxy(self.config)
# Initialize the gpodder.net client
self.mygpo_client = my.MygPoClient(self.config)
gpodder.user_extensions.on_ui_initialized(self.model,
self.extensions_podcast_update_cb,
self.extensions_episode_download_cb)
self.view = DeclarativeView()
self.view.closing.connect(self.on_quit)
self.view.setResizeMode(QDeclarativeView.SizeRootObjectToView)
self.controller = Controller(self)
self.media_buttons_handler = helper.MediaButtonsHandler()
self.tracker_miner_config = helper.TrackerMinerConfig()
self.podcast_model = gPodderPodcastListModel()
self.episode_model = gPodderEpisodeListModel(self.config)
self.last_episode = None
# A dictionary of episodes that are currently active
# in some way (i.e. playing back or downloading)
self.active_episode_wrappers = {}
engine = self.view.engine()
# Maemo 5: Experimental Qt Mobility packages are installed in /opt
if gpodder.ui.fremantle:
for path in ('/opt/qtm11/imports', '/opt/qtm12/imports'):
engine.addImportPath(path)
elif gpodder.win32:
for path in (r'C:\QtSDK\Desktop\Qt\4.7.4\msvc2008\imports',):
engine.addImportPath(path)
# Add the cover art image provider
self.cover_provider = images.LocalCachedImageProvider()
engine.addImageProvider('cover', self.cover_provider)
root_context = self.view.rootContext()
root_context.setContextProperty('controller', self.controller)
root_context.setContextProperty('configProxy', self.config_proxy)
root_context.setContextProperty('mediaButtonsHandler',
self.media_buttons_handler)
root_context.setContextProperty('trackerMinerConfig',
self.tracker_miner_config)
# Load the QML UI (this could take a while...)
self.view.setSource(QUrl.fromLocalFile(QML('main_default.qml')))
# Proxy to the "main" QML object for direct access to Qt Properties
self.main = helper.QObjectProxy(self.view.rootObject().property('main'))
self.main.podcastModel = self.podcast_model
self.main.episodeModel = self.episode_model
self.view.setWindowTitle('gPodder')
if gpodder.ui.harmattan:
self.view.showFullScreen()
elif gpodder.ui.fremantle:
self.view.setAttribute(Qt.WA_Maemo5AutoOrientation, True)
self.view.showFullScreen()
else:
# On the Desktop, scale to fit my small laptop screen..
desktop = self.app.desktop()
if desktop.height() < 1000:
FACTOR = .8
self.view.scale(FACTOR, FACTOR)
size = self.view.size()
size *= FACTOR
self.view.resize(size)
self.view.show()
self.do_start_progress.connect(self.on_start_progress)
self.do_end_progress.connect(self.on_end_progress)
self.do_show_message.connect(self.on_show_message)
self.load_podcasts()
def add_active_episode(self, episode):
self.active_episode_wrappers[episode.id] = episode
episode.episode_wrapper_refcount += 1
def remove_active_episode(self, episode):
episode.episode_wrapper_refcount -= 1
if episode.episode_wrapper_refcount == 0:
del self.active_episode_wrappers[episode.id]
def load_last_episode(self):
last_episode = None
last_podcast = None
for podcast in self.podcast_model.get_podcasts():
for episode in podcast.get_all_episodes():
if not episode.last_playback:
continue
if last_episode is None or \
episode.last_playback > last_episode.last_playback:
last_episode = episode
last_podcast = podcast
if last_episode is not None:
self.last_episode = self.wrap_episode(last_podcast, last_episode)
# FIXME: Send last episode to player
#self.select_episode(self.last_episode)
def on_episode_deleted(self, episode):
# Remove episode from play queue (if it's in there)
self.main.removeQueuedEpisode(episode)
# If the episode that has been deleted is currently
# being played back (or paused), stop playback now.
if self.main.currentEpisode == episode:
self.main.togglePlayback(None)
def enqueue_episode(self, episode):
self.main.enqueueEpisode(episode)
def run(self):
return self.app.exec_()
quit = Signal()
def on_quit(self):
# Make sure the audio playback is stopped immediately
self.main.togglePlayback(None)
self.save_pending_data()
self.view.hide()
self.core.shutdown()
self.app.quit()
do_show_message = Signal(unicode)
@Slot(unicode)
def on_show_message(self, message):
self.main.showMessage(message)
def show_message(self, message):
self.do_show_message.emit(message)
def show_input_dialog(self, message, value='', accept=_('OK'),
reject=_('Cancel'), is_text=True):
self.main.showInputDialog(message, value, accept, reject, is_text)
def open_context_menu(self, items):
self.main.openContextMenu(items)
do_start_progress = Signal(str)
@Slot(str)
def on_start_progress(self, text):
self.main.startProgress(text)
def start_progress(self, text=_('Please wait...')):
self.do_start_progress.emit(text)
do_end_progress = Signal()
@Slot()
def on_end_progress(self):
self.main.endProgress()
def end_progress(self):
self.do_end_progress.emit()
def resort_podcast_list(self):
self.podcast_model.sort()
def insert_podcast(self, podcast):
self.podcast_model.insert_object(podcast)
self.mygpo_client.on_subscribe([podcast.url])
self.mygpo_client.flush()
def remove_podcast(self, podcast):
# Remove queued episodes for this specific podcast
self.main.removeQueuedEpisodesForPodcast(podcast)
if self.main.currentEpisode is not None:
# If the currently-playing episode is in the podcast
# that is to be deleted, stop playback immediately.
if self.main.currentEpisode.qpodcast == podcast:
self.main.togglePlayback(None)
self.podcast_model.remove_object(podcast)
self.mygpo_client.on_unsubscribe([podcast.url])
self.mygpo_client.flush()
def load_podcasts(self):
podcasts = map(model.QPodcast, self.model.get_podcasts())
self.podcast_model.set_podcasts(self.db, podcasts)
def wrap_episode(self, podcast, episode):
try:
return self.active_episode_wrappers[episode.id]
except KeyError:
return model.QEpisode(self, podcast, episode)
def select_podcast(self, podcast):
if isinstance(podcast, model.QPodcast):
# Normal QPodcast instance
wrap = functools.partial(self.wrap_episode, podcast)
objects = podcast.get_all_episodes()
self.episode_model.set_is_subset_view(False)
else:
# EpisodeSubsetView
wrap = lambda args: self.wrap_episode(*args)
objects = podcast.get_all_episodes_with_podcast()
self.episode_model.set_is_subset_view(True)
self.episode_model.set_objects(map(wrap, objects))
self.main.state = 'episodes'
def save_pending_data(self):
current_ep = self.main.currentEpisode
if isinstance(current_ep, model.QEpisode):
current_ep.save()
def podcast_to_qpodcast(self, podcast):
podcasts = filter(lambda p: p._podcast == podcast,
self.podcast_model.get_podcasts())
assert len(podcasts) <= 1
if podcasts:
return podcasts[0]
return None
def extensions_podcast_update_cb(self, podcast):
logger.debug('extensions_podcast_update_cb(%s)', podcast)
try:
qpodcast = self.podcast_to_qpodcast(podcast)
if qpodcast is not None:
qpodcast.qupdate(
finished_callback=self.controller.update_subset_stats)
except Exception, e:
logger.exception('extensions_podcast_update_cb(%s): %s', podcast, e)
def initSearch(self): self.s.show() # self.seaProc = Popen(["python", # self.instdir + "/searchui.py"]) def initManager(self): self.m.show() # self.manProc = Popen(["python", # self.instdir + "/managerui.py"]) if __name__ == '__main__': import sys app = QApplication(sys.argv) display = app.desktop() if not QSystemTrayIcon.isSystemTrayAvailable(): QMessageBox.critical(None, "System Tray", "No system tray detected, use alternate means to \ interface with Tag Manager.") sys.exit(1) QApplication.setQuitOnLastWindowClosed(False) ignition = SysTray(display) sys.exit(app.exec_())
class qtPodder(QObject):
def __init__(self, args, gpodder_core, dbus_bus_name):
QObject.__init__(self)
self.dbus_bus_name = dbus_bus_name
# TODO: Expose the same D-Bus API as the Gtk UI D-Bus object (/gui)
# TODO: Create a gpodder.dbusproxy.DBusPodcastsProxy object (/podcasts)
self.app = QApplication(args)
signal.signal(signal.SIGINT, signal.SIG_DFL)
self.quit.connect(self.on_quit)
self.core = gpodder_core
self.config = self.core.config
self.db = self.core.db
self.model = self.core.model
self.config_proxy = ConfigProxy(self.config)
# Initialize the gpodder.net client
self.mygpo_client = my.MygPoClient(self.config)
gpodder.user_extensions.on_ui_initialized(self.model,
self.extensions_podcast_update_cb,
self.extensions_episode_download_cb)
self.view = DeclarativeView()
self.view.closing.connect(self.on_quit)
self.view.setResizeMode(QDeclarativeView.SizeRootObjectToView)
self.controller = Controller(self)
self.media_buttons_handler = helper.MediaButtonsHandler()
self.tracker_miner_config = helper.TrackerMinerConfig()
self.podcast_model = gPodderPodcastListModel()
self.episode_model = gPodderEpisodeListModel(self.config, self)
self.last_episode = None
# A dictionary of episodes that are currently active
# in some way (i.e. playing back or downloading)
self.active_episode_wrappers = {}
engine = self.view.engine()
# Add the cover art image provider
self.cover_provider = images.LocalCachedImageProvider()
engine.addImageProvider('cover', self.cover_provider)
root_context = self.view.rootContext()
root_context.setContextProperty('controller', self.controller)
root_context.setContextProperty('configProxy', self.config_proxy)
root_context.setContextProperty('mediaButtonsHandler',
self.media_buttons_handler)
root_context.setContextProperty('trackerMinerConfig',
self.tracker_miner_config)
root_context.setContextProperty('podcastModel', self.podcast_model)
root_context.setContextProperty('episodeModel', self.episode_model)
for folder in gpodder.ui_folders:
path = os.path.join(folder, 'harmattan')
if os.path.exists(path):
logger.info('Adding QML Import Path: %s', path)
engine.addImportPath(path)
# Load the QML UI (this could take a while...)
self.view.setSource(QUrl.fromLocalFile(QML('main_default.qml')))
self.view.setWindowTitle('gPodder')
if gpodder.ui.harmattan:
self.view.showFullScreen()
else:
# On the Desktop, scale to fit my small laptop screen..
desktop = self.app.desktop()
if desktop.height() < 1000:
FACTOR = .8
self.view.scale(FACTOR, FACTOR)
size = self.view.size()
size *= FACTOR
self.view.resize(size)
self.view.show()
podcasts = self.load_podcasts()
self.resumable_episodes = None
self.do_offer_download_resume.connect(self.on_offer_download_resume)
util.run_in_background(self.find_partial_downloads(podcasts))
def find_partial_downloads(self, podcasts):
def start_progress_callback(count):
self.controller.startProgress.emit(_('Loading incomplete downloads'))
def progress_callback(title, progress):
self.controller.startProgress.emit('%s (%d%%)' % (
_('Loading incomplete downloads'),
progress*100))
def finish_progress_callback(resumable_episodes):
self.controller.endProgress.emit()
self.resumable_episodes = resumable_episodes
self.do_offer_download_resume.emit()
common.find_partial_downloads(podcasts,
start_progress_callback,
progress_callback,
finish_progress_callback)
do_offer_download_resume = Signal()
def on_offer_download_resume(self):
if self.resumable_episodes:
def download_episodes():
for episode in self.resumable_episodes:
qepisode = self.wrap_simple_episode(episode)
self.controller.downloadEpisode(qepisode)
def delete_episodes():
logger.debug('Deleting incomplete downloads.')
common.clean_up_downloads(delete_partial=True)
message = _('Incomplete downloads from a previous session were found.')
title = _('Resume')
self.controller.confirm_action(message, title, download_episodes, delete_episodes)
def add_active_episode(self, episode):
self.active_episode_wrappers[episode.id] = episode
episode.episode_wrapper_refcount += 1
def remove_active_episode(self, episode):
episode.episode_wrapper_refcount -= 1
if episode.episode_wrapper_refcount == 0:
del self.active_episode_wrappers[episode.id]
def load_last_episode(self):
last_episode = None
last_podcast = None
for podcast in self.podcast_model.get_podcasts():
for episode in podcast.get_all_episodes():
if not episode.last_playback:
continue
if last_episode is None or \
episode.last_playback > last_episode.last_playback:
last_episode = episode
last_podcast = podcast
if last_episode is not None:
self.last_episode = self.wrap_episode(last_podcast, last_episode)
# FIXME: Send last episode to player
#self.select_episode(self.last_episode)
def run(self):
return self.app.exec_()
quit = Signal()
def on_quit(self):
self.controller.on_quit()
self.view.hide()
self.core.shutdown()
self.app.quit()
def resort_podcast_list(self):
self.podcast_model.sort()
def insert_podcast(self, podcast):
self.podcast_model.insert_object(podcast)
self.mygpo_client.on_subscribe([podcast.url])
self.mygpo_client.flush()
def load_podcasts(self):
podcasts = map(model.QPodcast, self.model.get_podcasts())
self.podcast_model.set_podcasts(self.db, podcasts)
return podcasts
def wrap_episode(self, podcast, episode):
try:
return self.active_episode_wrappers[episode.id]
except KeyError:
return model.QEpisode(self, podcast, episode)
def wrap_simple_episode(self, episode):
for podcast in self.podcast_model.get_podcasts():
if podcast.id == episode.podcast_id:
return self.wrap_episode(podcast, episode)
return None
def select_podcast(self, podcast):
if isinstance(podcast, model.QPodcast):
# Normal QPodcast instance
wrap = functools.partial(self.wrap_episode, podcast)
objects = podcast.get_all_episodes()
self.episode_model.set_is_subset_view(False)
else:
# EpisodeSubsetView
wrap = lambda args: self.wrap_episode(*args)
objects = podcast.get_all_episodes_with_podcast()
self.episode_model.set_is_subset_view(True)
self.episode_model.set_objects(map(wrap, objects))
def podcast_to_qpodcast(self, podcast):
podcasts = filter(lambda p: p._podcast == podcast,
self.podcast_model.get_podcasts())
assert len(podcasts) <= 1
if podcasts:
return podcasts[0]
return None
def extensions_podcast_update_cb(self, podcast):
logger.debug('extensions_podcast_update_cb(%s)', podcast)
try:
qpodcast = self.podcast_to_qpodcast(podcast)
if qpodcast is not None and not qpodcast.pause_subscription:
qpodcast.qupdate(
finished_callback=self.controller.update_subset_stats)
except Exception, e:
logger.exception('extensions_podcast_update_cb(%s): %s', podcast, e)
#
if __name__ == '__main__':
config_file = 'config.json'
parser = argparse.ArgumentParser(
description = ""
)
parser.add_argument(
'-c',
'--config',
default = config_file,
help = 'Configuration file, default is %s' % config_file
)
arg = parser.parse_args()
app = QApplication(sys.argv)
win = app.desktop().screenGeometry()
cfg = config.XiboConfig(arg.config)
signal.signal(signal.SIGINT, lambda s, f: app.quit())
if not os.path.isfile(arg.config):
print
print 'The configuration file %s is not exists.' % arg.config
print 'Creating default configuration ...'
cfg.save()
print "Please edit the '%s' file and then rerun xibopy again." % arg.config
print
sys.exit(0)
r = -1
with ui.XiboWindow(cfg) as w:
''' screen_x = self.screen.screenGeometry().width() screen_y = self.screen.screenGeometry().height() x_pos = .83 * screen_x y_pos = .07 * screen_y self.setGeometry(x_pos, y_pos, dimension_x, dimension_y) # def mkresdir(self): # if not path.exists(tfm.tmpFile): # makedirs(tfm.tmpFile) if __name__ == '__main__': from PySide.QtGui import QApplication import sys app = QApplication(sys.argv) screen = app.desktop() search = uiSearch(screen) if not path.exists(tfmlib.tmpF): makedirs(tfmlib.tmpF) search.show() app.exec_()
def __init__(self):
super(MainWindow, self).__init__()
self.setWindowTitle("Cobaya input generator for Cosmology")
self.setGeometry(0, 0, 1500, 1000)
self.move(
QApplication.desktop().screen().rect().center() - self.rect().center())
self.show()
# Main layout
self.layout = QHBoxLayout()
self.setLayout(self.layout)
self.layout_left = QVBoxLayout()
self.layout.addLayout(self.layout_left)
self.layout_output = QVBoxLayout()
self.layout.addLayout(self.layout_output)
# LEFT: Options
self.options = QWidget()
self.layout_options = QVBoxLayout()
self.options.setLayout(self.layout_options)
self.options_scroll = QScrollArea()
self.options_scroll.setWidget(self.options)
self.options_scroll.setWidgetResizable(True)
self.layout_left.addWidget(self.options_scroll)
self.atoms = odict()
titles = odict([
["preset", "Presets"],
["theory", "Theory code"],
["primordial", "Primordial perturbations"],
["geometry", "Geometry"],
["hubble", "Constaint on hubble parameter"],
["baryons", "Baryon sector"],
["dark_matter", "Dark matter"],
["dark_energy", "Lambda / Dark energy"],
["neutrinos", "Neutrinos and other extra matter"],
["bbn", "BBN"],
["reionization", "Reionization history"],
["cmb_lensing", "CMB lensing"],
["cmb", "CMB experiments"],
["sampler", "Samplers"]])
for a in titles:
self.atoms[a] = {
"group": QGroupBox(titles[a]),
"combo": QComboBox()}
self.layout_options.addWidget(self.atoms[a]["group"])
self.atoms[a]["layout"] = QVBoxLayout(self.atoms[a]["group"])
self.atoms[a]["layout"].addWidget(self.atoms[a]["combo"])
self.atoms[a]["combo"].addItems(
[text(k,v) for k,v in getattr(input_database, a).items()])
# Connect to refreshers -- needs to be after adding all elements
for a in self.atoms:
if a == "preset":
self.atoms["preset"]["combo"].currentIndexChanged.connect(
self.refresh_preset)
continue
self.atoms[a]["combo"].currentIndexChanged.connect(self.refresh)
# Add Planck-naming checkbox and connect to refresher too
self.planck_names = QCheckBox("Keep common names")
self.atoms["theory"]["layout"].addWidget(self.planck_names)
self.planck_names.stateChanged.connect(self.refresh)
# RIGHT: Output + buttons
self.display_tabs = QTabWidget()
self.display = {}
for k in ["yaml", "python"]:
self.display[k] = QTextEdit()
self.display[k].setLineWrapMode(QTextEdit.NoWrap)
self.display[k].setFontFamily("mono")
self.display[k].setCursorWidth(0)
self.display[k].setReadOnly(True)
self.display_tabs.addTab(self.display[k], k)
self.layout_output.addWidget(self.display_tabs)
# Buttons
self.buttons = QHBoxLayout()
self.save_button = QPushButton('Save', self)
self.copy_button = QPushButton('Copy to clipboard', self)
self.buttons.addWidget(self.save_button)
self.buttons.addWidget(self.copy_button)
self.save_button.released.connect(self.save_file)
self.copy_button.released.connect(self.copy_clipb)
self.layout_output.addLayout(self.buttons)
self.save_dialog = QFileDialog()
self.save_dialog.setFileMode(QFileDialog.AnyFile)
self.save_dialog.setAcceptMode(QFileDialog.AcceptSave)
