def __init__(self, parent=None):
super(PypePlayer, self).__init__(parent)
QCoreApplication.setOrganizationName('Ted')
QCoreApplication.setApplicationName('PypePlayer')
self.setting_dialog = settings_widget()
self.setting_dialog.settings_saved.connect(self.read_settings)
self.player = Player(parent=self)
self.setCentralWidget(self.player)
self.viewer = Viewer(parent=self)
self.menu_controller = MenuController(self, self.menuBar())
self._create_menu()
self.update_actions()
self.player.media_loaded.connect(self.set_window_title)
self.player.stopped.connect(self.set_window_title)
self.read_settings()
self.set_window_title('')
self.show()
self.adjust_header_act.trigger()
def main(self):
fullscreenValue = self.argValues["fullscreen"]
topWindowValue = self.argValues["topWindow"]
startFromDesktopValue = self.argValues["startFromDesktop"]
cursor_pos = QCursor.pos()
desktop = qApp.desktop()
screen_num = desktop.screenNumber(cursor_pos)
screen_geo = desktop.screenGeometry(screen_num)
pixmap = qApp.primaryScreen().grabWindow(0)
pixmap = pixmap.copy(screen_geo.x(), screen_geo.y(),
screen_geo.width(), screen_geo.height())
pixmap.save(self.settings.tmpImageFile)
show_osd = self.settings.getOption("showOSD", "show")
if show_osd == True or show_osd == "true":
self.settings.showOSD = startFromDesktopValue
if self.settings.showOSD:
self.settings.setOption("showOSD", "show", QVariant(False))
else:
self.settings.showOSD = False
self.menu_controller = MenuController()
self.windowInfo = WindowInfo(screen_num)
notificationsInterface.ActionInvoked.connect(self._actionInvoked)
notificationsInterface.NotificationClosed.connect(
self._notificationClosed)
if fullscreenValue:
self.saveScreenshot(pixmap)
elif topWindowValue:
wInfos = self.windowInfo.get_windows_info()
if len(wInfos) > 0:
wInfo = wInfos[0]
pix = pixmap.copy(wInfo[0] - screen_geo.x(),
wInfo[1] - screen_geo.y(), wInfo[2],
wInfo[3])
self.saveScreenshot(pix)
else:
self.window = Window(ref(self)())
self.window.setX(screen_geo.x())
self.window.setY(screen_geo.y())
self.window.setWidth(screen_geo.width())
self.window.setHeight(screen_geo.height())
self.window.windowClosing.connect(self._windowClosing)
self.window.visibleChanged.connect(self._windowVisibleChanged)
# NOTE: make sure that all the objects that are set as context
# property are always referenced by others through the lifetime
# of this application, otherwise it'll cause problems.
qml_context = self.window.rootContext()
qml_context.setContextProperty("windowView", self.window)
qml_context.setContextProperty("qApp", qApp)
qml_context.setContextProperty(
"screenWidth", self.window.window_info.screen_width)
qml_context.setContextProperty(
"screenHeight", self.window.window_info.screen_height)
qml_context.setContextProperty("tmpImageFile",
self.settings.tmpImageFile)
qml_context.setContextProperty("blurImageFile",
self.settings.tmpBlurFile)
qml_context.setContextProperty("mosaicImageFile",
self.settings.tmpMosaiceFile)
qml_context.setContextProperty("_menu_controller",
self.menu_controller)
self.window.setSource(QUrl.fromLocalFile(MAIN_QML))
self.window.showWindow()
self.menu_controller.preMenuShow.connect(self.window.ungrabFocus)
self.menu_controller.postMenuHide.connect(self.window.grabFocus)
def _initMenuBar(self):
menu = self._view.menuBar()
self._menu_controller = MenuController(self, menu)
class MainController(QtCore.QObject):
def __init__(self, view, dialogs_service, task_editor_service):
super(MainController, self).__init__()
self._view = view
self._dialogs_service = dialogs_service
self._task_editor_service = task_editor_service
self._initControllers()
self._file = todolib.File()
self._is_modified = False
self._settings = settings.Settings()
self._setIsModified(False)
self._view.closeEventSignal.connect(self._view_onCloseEvent)
self._args = self._parseArgs()
def _parseArgs(self):
if len(sys.argv) > 1 and sys.argv[1].startswith('-psn'):
del sys.argv[1]
parser = argparse.ArgumentParser(description = 'QTodoTxt')
parser.add_argument('-f', '--file', type=str, nargs=1, metavar='TEXTFILE')
parser.add_argument('-q', '--quickadd', action='store_true', \
help='opens the add task dialog and exit the application when done')
return parser.parse_args()
def _initControllers(self):
self._initFiltersTree()
self._initTasksList()
self._initMenuBar()
def _initMenuBar(self):
menu = self._view.menuBar()
self._menu_controller = MenuController(self, menu)
def exit(self):
self._view.close()
sys.exit()
def getView(self):
return self._view
def show(self):
self._view.show()
self._updateTitle()
self._settings.load()
self._updateCreatePref()
filename = None
if self._args.file:
filename = self._args.file[0]
else:
filename = self._settings.getLastOpenFile()
if filename:
self.openFileByName(filename)
if self._args.quickadd:
self._tasks_list_controller.createTask()
self.save()
self.exit()
def _initFiltersTree(self):
controller = self._filters_tree_controller = \
FiltersTreeController(self._view.filters_tree_view)
controller.filterSelectionChanged.connect(
self._onFilterSelectionChanged)
def _onFilterSelectionChanged(self, filters):
tasks = self._getTasks(filters)
self._tasks_list_controller.showTasks(tasks)
def _initTasksList(self):
controller = self._tasks_list_controller = \
TasksListController(self._view.tasks_list_view, self._task_editor_service)
controller.taskCreated.connect(self._tasks_list_taskCreated)
controller.taskModified.connect(self._tasks_list_taskModified)
controller.taskDeleted.connect(self._tasks_list_taskDeleted)
def _tasks_list_taskDeleted(self, task):
self._file.tasks.remove(task)
self._onFileUpdated()
def _tasks_list_taskCreated(self, task):
self._file.tasks.append(task)
self._onFileUpdated()
def _tasks_list_taskModified(self, task):
self._onFileUpdated()
def _onFileUpdated(self):
self._filters_tree_controller.showFilters(self._file)
self._task_editor_service.updateValues(self._file)
self._setIsModified(True)
def _getTasks(self, filters):
if None in filters:
return self._file.tasks
tasks = []
for task in self._file.tasks:
for filter in filters:
if filter.isMatch(task):
tasks.append(task)
break
return tasks
def _canExit(self):
if not self._is_modified:
return True
button = self._dialogs_service.showSaveDiscardOrCancel('Unsaved changes...')
if button == QtGui.QMessageBox.Save:
self.save()
return True
else:
return button == QtGui.QMessageBox.Discard
def _view_onCloseEvent(self, closeEvent):
if self._canExit():
closeEvent.accept()
else:
closeEvent.ignore()
def _setIsModified(self, is_modified):
self._is_modified = is_modified
self._updateTitle()
self._menu_controller.saveAction.setEnabled(is_modified)
self._menu_controller.revertAction.setEnabled(is_modified)
def save(self):
if self._file.filename:
self._file.save()
self._setIsModified(False)
else:
(filename, ok) = \
QtGui.QFileDialog.getSaveFileName(self._view, filter=FILENAME_FILTERS)
if ok and filename:
self._file.save(filename)
self._settings.setLastOpenFile(filename)
self._setIsModified(False)
def _updateTitle(self):
title = 'QTodoTxt - '
if self._file.filename:
filename = os.path.basename(self._file.filename)
title += filename
else:
title += 'Untitled'
if self._is_modified:
title += ' (*)'
self._view.setWindowTitle(title)
def open(self):
(filename, ok) = \
QtGui.QFileDialog.getOpenFileName(self._view, filter=FILENAME_FILTERS)
if ok and filename:
self.openFileByName(filename)
def new(self):
if self._canExit():
self._openFile(todolib.File())
def revert(self):
if self._dialogs_service.showConfirm('Revert to saved file (and lose unsaved changes)?'):
self.openFileByName(self._file.filename)
def openFileByName(self, filename):
file = todolib.File()
try:
file.load(filename)
except todolib.ErrorLoadingFile as ex:
self._dialogs_service.showError(str(ex))
return
self._openFile(file)
self._settings.setLastOpenFile(filename)
def _openFile(self, file):
self._file = file
self._setIsModified(False)
self._filters_tree_controller.showFilters(file)
self._task_editor_service.updateValues(file)
def _updateCreatePref(self):
self._menu_controller.changeCreatedDateState(bool(self._settings.getCreateDate()))
def createdDate(self):
if self._settings.getCreateDate():
self._settings.setCreateDate(False)
else:
self._settings.setCreateDate(True)
def toggleVisible(self):
if self._view.isMinimized():
self._view.showNormal()
self._view.activateWindow()
else:
self._view.showMinimized()
class PypePlayer(QMainWindow):
def __init__(self, parent=None):
super(PypePlayer, self).__init__(parent)
QCoreApplication.setOrganizationName('Ted')
QCoreApplication.setApplicationName('PypePlayer')
self.setting_dialog = settings_widget()
self.setting_dialog.settings_saved.connect(self.read_settings)
self.player = Player(parent=self)
self.setCentralWidget(self.player)
self.viewer = Viewer(parent=self)
self.menu_controller = MenuController(self, self.menuBar())
self._create_menu()
self.update_actions()
self.player.media_loaded.connect(self.set_window_title)
self.player.stopped.connect(self.set_window_title)
self.read_settings()
self.set_window_title('')
self.show()
self.adjust_header_act.trigger()
def _create_menu(self):
# Player
forward_short = createAction(self.player, 'Short Forward',
self.player.forward_short, 'Right')
forward_medium = createAction(self.player, 'Forward',
self.player.forward_medium,
'Shift+Right')
forward_long = createAction(self.player, 'Long Forward',
self.player.forward_long, 'Ctrl+Right')
backward_short = createAction(self.player, 'Short Backward',
self.player.backward_short, 'Left')
backward_medium = createAction(self.player, 'Backward',
self.player.backward_medium,
'Shift+Left')
backward_long = createAction(self.player, 'Long Backward',
self.player.backward_long, 'Ctrl+Left')
play_and_pause = createAction(self.player, 'Play',
self.player.optimal_play, 'Space')
stop = createAction(self.player, 'Stop', self.player.stop, 'Ctrl+.')
self.menu_controller.add_action_list('Playback',
[play_and_pause, stop])
self.menu_controller.add_action_list(
'Playback/Jump', [forward_short, forward_medium, forward_long])
self.menu_controller.add_separator('Playback/Jump')
self.menu_controller.add_action_list(
'Playback/Jump', [backward_short, backward_medium, backward_long])
load_and_play = createAction(self.player, 'Load and Play',
self.player.load_and_play, 'Return')
self.player.addAction(load_and_play)
self.player.context_menu.addActions([play_and_pause, stop])
# Playlist
playlist = self.player.playlist
add_file = createAction(playlist, 'Add file(s)', playlist.open,
'Ctrl+o')
open_directory = createAction(playlist, 'Open directory',
playlist.open_directory, 'Ctrl+Shift+o')
open_preferences = createAction(self, 'Preferences...',
self.open_preferences)
add_playlist = createAction(playlist, 'New',
playlist.widget.add_playlist, 'Ctrl+N')
load_playlist = createAction(playlist, 'Load',
playlist.widget.load_playlist, 'Ctrl+l')
save_playlist = createAction(playlist, 'Save Current',
playlist.widget.save_current, 'Ctrl+s')
rename_playlist = createAction(playlist, 'Rename',
playlist.widget.rename_playlist)
remove_playlist = createAction(playlist, 'Remove Current',
playlist.widget.remove_playlist)
next_tab_act = createAction(playlist, 'Next Tab',
playlist.widget.next_tab, 'Meta+tab')
previous_tab_act = createAction(playlist, 'Previous Tab',
playlist.widget.previous_tab,
'Meta+Shift+tab')
self.adjust_header_act = createAction(
playlist, 'Auto Adjust Header', playlist.widget.adjust_header_size)
# self.adjust_header_act.setCheckable(True)
self.menu_controller.add_action_list('', [open_preferences])
self.menu_controller.add_action_list('File',
[add_file, open_directory])
self.menu_controller.add_separator('File')
self.menu_controller.add_action_list('Playlist', [
add_playlist, load_playlist, rename_playlist, save_playlist,
remove_playlist
])
self.menu_controller.add_separator('Playlist')
self.menu_controller.add_action_list(
'Playlist',
[next_tab_act, previous_tab_act, self.adjust_header_act])
# Viewer
set_reference_act = createAction(self.viewer, 'Set Reference',
self.viewer.set_reference)
next_act = createAction(self.viewer, 'next', self.viewer.next,
'Alt+Right')
previous_act = createAction(self.viewer, 'previous',
self.viewer.previous, 'Alt+Left')
zoom_in_act = createAction(self.viewer, 'Zoom In', self.viewer.zoom_in,
'Ctrl++')
zoom_out_act = createAction(self.viewer, 'Zoom Out',
self.viewer.zoom_out, 'Ctrl+-')
normal_size_act = createAction(self.viewer, 'Normal size',
self.viewer.normal_size, 'Ctrl+0')
fit_to_window_act = createAction(self.viewer, 'Fit to window',
self.viewer.fit_to_window)
fit_to_window_act.setCheckable(True)
show_act = createAction(self.viewer, 'Show', self.viewer.show)
close_window_act = createAction(self.viewer, 'Close', self.viewer.hide,
'Ctrl+c')
self.viewer_act = [
set_reference_act, next_act, previous_act, zoom_in_act,
zoom_out_act, normal_size_act, fit_to_window_act, show_act,
close_window_act
]
self.viewer.context_menu.addActions(self.viewer_act)
self.menu_controller.add_action_list('Viewer', self.viewer_act)
def set_window_title(self, str=''):
if str:
self.setWindowTitle('{0} - Pype Player'.format(str))
else:
self.setWindowTitle('Pype Player')
def closeEvent(self, event):
self.player.playlist.save_all()
self.write_settings()
super(PypePlayer, self).closeEvent(event)
def update_actions(self):
for a in self.viewer_act[1:]:
a.setEnabled(self.viewer.isReady())
def open_preferences(self):
self.setting_dialog.show()
def write_settings(self):
settings = QSettings()
if settings.value('window/remember'):
settings.setValue('window/size', self.size())
else:
settings.setValue('window/size', QSize(600, 360))
settings.beginGroup('player')
settings.setValue('order_list', self.player.order_list.currentIndex())
settings.setValue('splitter_sizes',
self.player.display_splitter.saveState())
settings.endGroup()
def read_settings(self):
settings = QSettings()
self.resize(settings.value('window/size', QSize(600, 360)))
self.player.read_settings()
if __name__ == "__main__":
from dbus_services import (DeepinMovieServie, check_multiple_instances,
DeepinMovieInterface, session_bus, DBUS_PATH)
result = check_multiple_instances()
if result:
dbus_service = DeepinMovieServie(app)
session_bus.registerObject(DBUS_PATH, dbus_service)
else:
if not config.playerMultipleProgramsAllowed:
dbus_interface = DeepinMovieInterface()
dbus_interface.play(json.dumps(sys.argv[1:]))
os._exit(0)
windowView = Window(result or len(sys.argv) > 1)
menu_controller = MenuController(windowView)
file_monitor = FileMonitor()
findVideoThreadManager = FindVideoThreadManager()
app._extra_window = weakref.ref(windowView)
qml_context = windowView.rootContext()
qml_context.setContextProperty("config", config)
qml_context.setContextProperty("_utils", utils)
qml_context.setContextProperty("_findVideoThreadManager",
findVideoThreadManager)
qml_context.setContextProperty("_file_monitor", file_monitor)
qml_context.setContextProperty("database", database)
qml_context.setContextProperty("windowView", windowView)
qml_context.setContextProperty("movieInfo", movie_info)
qml_context.setContextProperty("_menu_controller", menu_controller)
