def setUp(self): """ Set up the objects we need for all of the tests """ Registry.create() self.registry = Registry() self.setup_application() # Mock cursor busy/normal methods. self.app.set_busy_cursor = MagicMock() self.app.set_normal_cursor = MagicMock() self.app.process_events = MagicMock() self.app.args = [] Registry().register('application', self.app) Registry().set_flag('no_web_server', True) self.add_toolbar_action_patcher = patch( 'openlp.core.ui.mainwindow.create_action') self.mocked_add_toolbar_action = self.add_toolbar_action_patcher.start( ) self.mocked_add_toolbar_action.side_effect = self._create_mock_action self.renderer_patcher = patch('openlp.core.display.render.Renderer') self.mocked_renderer = self.renderer_patcher.start() mocked_desktop = MagicMock() mocked_desktop.screenCount.return_value = 1 mocked_desktop.screenGeometry.return_value = QtCore.QRect( 0, 0, 1024, 768) mocked_desktop.primaryScreen.return_value = 1 ScreenList.create(mocked_desktop) State().load_settings() self.main_window = MainWindow()
def __init__(self, parent): """ Initialise the general settings tab """ self.logo_file = ':/graphics/openlp-splash-screen.png' self.logo_background_color = '#ffffff' self.screens = ScreenList() self.icon_path = ':/icon/openlp-logo.svg' general_translated = translate('OpenLP.GeneralTab', 'General') super(GeneralTab, self).__init__(parent, 'Core', general_translated)
def setUp(self): """ Create the UI """ Registry.create() self.setup_application() ScreenList.create(self.app.desktop()) self.image_manager = ImageManager() self.lock = Lock() self.sleep_time = 0.1
def setUp(self): """ Setup for tests """ Registry.create() self.registry = Registry() self.mocked_live_controller = MagicMock() self.desktop = MagicMock() self.desktop.primaryScreen.return_value = SCREEN['primary'] self.desktop.screenCount.return_value = SCREEN['number'] self.desktop.screenGeometry.return_value = SCREEN['size'] with patch('openlp.core.display.screens.QtWidgets.QApplication.screens') as mocked_screens: mocked_screens.return_value = [ MagicMock(**{'geometry.return_value': SCREEN['size']}) ] self.screens = ScreenList.create(self.desktop) # Mock the renderer and its format_slide method self.mocked_renderer = MagicMock() def side_effect_return_arg(arg1, arg2): return [arg1] self.mocked_slide_formater = MagicMock(side_effect=side_effect_return_arg) self.mocked_renderer.format_slide = self.mocked_slide_formater Registry().register('live_controller', self.mocked_live_controller) Registry().register('renderer', self.mocked_renderer) Registry().register('settings', MagicMock(**{'value.return_value': 'english'}))
def start_presentation(self): """ Start the presentation from the beginning. """ log.debug('start presentation OpenOffice') if self.control is None or not self.control.isRunning(): window = self.document.getCurrentController().getFrame( ).getContainerWindow() window.setVisible(True) self.presentation.start() self.control = self.presentation.getController() # start() returns before the Component is ready. Try for 15 seconds. sleep_count = 1 while not self.control and sleep_count < 150: time.sleep(0.1) sleep_count += 1 self.control = self.presentation.getController() window.setVisible(False) if not is_win(): listener = SlideShowListener(self) self.control.getSlideShow().addSlideShowListener(listener) else: self.control.activate() self.goto_slide(1) # Make sure impress doesn't steal focus, unless we're on a single screen setup if len(ScreenList()) > 1: Registry().get('main_window').activateWindow()
def next_step(self): """ Triggers the next effect of slide on the running presentation. """ log.debug('next_step') # if we are at the presentations end don't go further, just return True if self.presentation.SlideShowWindow.View.GetClickCount() == \ self.presentation.SlideShowWindow.View.GetClickIndex() \ and self.get_slide_number() == self.get_slide_count(): return True past_end = False try: self.presentation.SlideShowWindow.Activate() self.presentation.SlideShowWindow.View.Next() except (AttributeError, pywintypes.com_error): log.exception('Caught exception while in next_step') trace_error_handler(log) self.show_error_msg() return past_end # If for some reason the presentation end was not detected above, this will catch it. if self.get_slide_number() > self.get_slide_count(): log.debug('past end, stepping back to previous') self.previous_step() past_end = True # Stop powerpoint from flashing in the taskbar if self.presentation_hwnd: win32gui.FlashWindowEx(self.presentation_hwnd, win32con.FLASHW_STOP, 0, 0) # Make sure powerpoint doesn't steal focus, unless we're on a single screen setup if len(ScreenList()) > 1: Registry().get('main_window').activateWindow() return past_end
def generate_alert(self): """ Format and request the Alert and start the timer. """ if not self.alert_list or (len(ScreenList()) == 1 and not self.settings.value('core/display on monitor')): return text = self.alert_list.pop(0) # Get the rgb color format of the font & background hex colors from settings rgb_font_color = self.hex_to_rgb(QtGui.QColor(self.settings.value('alerts/font color'))) rgb_background_color = self.hex_to_rgb(QtGui.QColor(self.settings.value('alerts/background color'))) # Put alert settings together in dict that will be passed to Display in Javascript alert_settings = { 'backgroundColor': rgb_background_color, 'location': self.settings.value('alerts/location'), 'fontFace': self.settings.value('alerts/font face'), 'fontSize': self.settings.value('alerts/font size'), 'fontColor': rgb_font_color, 'timeout': self.settings.value('alerts/timeout'), 'repeat': self.settings.value('alerts/repeat'), 'scroll': self.settings.value('alerts/scroll') } self.live_controller.displays[0].alert(text, json.dumps(alert_settings))
def load_presentation(self): """ Called when a presentation is added to the SlideController. It builds the environment, starts communcations with the background OpenOffice task started earlier. If OpenOffice is not present is is started. Once the environment is available the presentation is loaded and started. """ log.debug('Load Presentation OpenOffice') if is_win(): desktop = self.controller.get_com_desktop() if desktop is None: self.controller.start_process() desktop = self.controller.get_com_desktop() else: desktop = self.controller.get_uno_desktop() url = self.file_path.as_uri() if desktop is None: return False self.desktop = desktop properties = [] properties.append(self.create_property('Hidden', True)) properties = tuple(properties) try: self.document = desktop.loadComponentFromURL(url, '_blank', 0, properties) except: log.warning('Failed to load presentation {url}'.format(url=url)) return False self.presentation = self.document.getPresentation() self.presentation.Display = ScreenList().current['number'] + 1 self.control = None self.create_thumbnails() self.create_titles_and_notes() return True
def unblank_screen(self): """ Unblanks (restores) the presentation. """ log.debug('unblank_screen') try: self.presentation.SlideShowWindow.Activate() self.presentation.SlideShowWindow.View.State = 1 # Unblanking is broken in PowerPoint 2010 (14.0), need to redisplay if 15.0 > float(self.presentation.Application.Version) >= 14.0: self.presentation.SlideShowWindow.View.GotoSlide( self.index_map[self.blank_slide], False) if self.blank_click: self.presentation.SlideShowWindow.View.GotoClick( self.blank_click) except (AttributeError, pywintypes.com_error): log.exception('Caught exception while in unblank_screen') trace_error_handler(log) self.show_error_msg() # Stop powerpoint from flashing in the taskbar if self.presentation_hwnd: win32gui.FlashWindowEx(self.presentation_hwnd, win32con.FLASHW_STOP, 0, 0) # Make sure powerpoint doesn't steal focus, unless we're on a single screen setup if len(ScreenList()) > 1: Registry().get('main_window').activateWindow()
def run(self, args): """ Run the OpenLP application. :param args: Some Args """ self.is_event_loop_active = False # On Windows, the args passed into the constructor are ignored. Not very handy, so set the ones we want to use. # On Linux and FreeBSD, in order to set the WM_CLASS property for X11, we pass "OpenLP" in as a command line # argument. This interferes with files being passed in as command line arguments, so we remove it from the list. if 'OpenLP' in args: args.remove('OpenLP') self.args.extend(args) # Decide how many screens we have and their size screens = ScreenList.create(self.desktop()) # First time checks in settings has_run_wizard = Settings().value('core/has run wizard') if not has_run_wizard: ftw = FirstTimeForm() ftw.initialize(screens) if ftw.exec() == QtWidgets.QDialog.Accepted: Settings().setValue('core/has run wizard', True) elif ftw.was_cancelled: QtCore.QCoreApplication.exit() sys.exit() # Correct stylesheet bugs application_stylesheet = get_application_stylesheet() if application_stylesheet: self.setStyleSheet(application_stylesheet) can_show_splash = Settings().value('core/show splash') if can_show_splash: self.splash = SplashScreen() self.splash.show() # make sure Qt really display the splash screen self.processEvents() # Check if OpenLP has been upgrade and if a backup of data should be created self.backup_on_upgrade(has_run_wizard, can_show_splash) # start the main app window self.main_window = MainWindow() Registry().execute('bootstrap_initialise') Registry().execute('bootstrap_post_set_up') Registry().initialise = False self.main_window.show() if can_show_splash: # now kill the splashscreen log.debug('Splashscreen closing') self.splash.close() log.debug('Splashscreen closed') # make sure Qt really display the splash screen self.processEvents() self.main_window.repaint() self.processEvents() if not has_run_wizard: self.main_window.first_time() if Settings().value('core/update check'): check_for_update(self.main_window) self.main_window.is_display_blank() self.main_window.app_startup() return self.exec()
def start_presentation(self): """ Start the presentation from the beginning. """ log.debug('start presentation LibreOffice') self.client.start_presentation() # Make sure impress doesn't steal focus, unless we're on a single screen setup if len(ScreenList()) > 1: Registry().get('main_window').activateWindow()
def show(self): self.progress_bar.setValue(0) try: screens = ScreenList() self.ratio = screens.current.display_geometry.width( ) / screens.current.display_geometry.height() except ZeroDivisionError: self.ratio = 16 / 9 self.theme_preview_layout.aspect_ratio = self.ratio return super().show()
def update_display(self): """ Screen has changed size so rebuild the cache to new size. """ log.debug('update_display') current_screen = ScreenList().current self.width = current_screen.display_geometry.width() self.height = current_screen.display_geometry.height() # Mark the images as dirty for a rebuild by setting the image and byte stream to None. for image in list(self._cache.values()): self._reset_image(image)
def setUp(self): """ Set up the components need for all tests """ # Mocked out desktop object self.desktop = MagicMock() self.desktop.primaryScreen.return_value = SCREEN['primary'] self.desktop.screenCount.return_value = SCREEN['number'] self.desktop.screenGeometry.return_value = SCREEN['size'] self.screens = ScreenList.create(self.desktop) Registry.create()
def load_presentation(self): """ Tell the LibreOfficeServer to start the presentation. """ log.debug('Load Presentation LibreOffice') if not self.client.load_presentation(str(self.file_path), ScreenList().current.number + 1): return False self.create_thumbnails() self.create_titles_and_notes() return True
def set_default_header_footer(self): """ Set the header and footer size into the current primary screen. 10 px on each side is removed to allow for a border. """ current_screen = ScreenList().current self.font_main_y = 0 self.font_main_width = current_screen['size'].width() - 20 self.font_main_height = current_screen['size'].height() * 9 / 10 self.font_footer_width = current_screen['size'].width() - 20 self.font_footer_y = current_screen['size'].height() * 9 / 10 self.font_footer_height = current_screen['size'].height() / 10
def resize(self, controller): """ Resize the player :param controller: The display where the media is stored within the controller. :return: """ if controller.is_live: controller.vlc_widget.setGeometry( ScreenList().current.display_geometry) else: controller.vlc_widget.resize(controller.preview_display.size())
def __init__(self): """ Constructor for the image manager. """ super(ImageManager, self).__init__() Registry().register('image_manager', self) current_screen = ScreenList().current self.width = current_screen.display_geometry.width() self.height = current_screen.display_geometry.height() self._cache = {} self._conversion_queue = PriorityQueue() self.stop_manager = False Registry().register_function('images_regenerate', self.process_updates)
def __init__(self, parent=None, screen=None, can_show_startup_screen=True): """ Create the display window """ super(DisplayWindow, self).__init__(parent) # Gather all flags for the display window flags = QtCore.Qt.FramelessWindowHint | QtCore.Qt.Tool | QtCore.Qt.WindowStaysOnTopHint if self.settings.value('advanced/x11 bypass wm'): flags |= QtCore.Qt.X11BypassWindowManagerHint # Need to import this inline to get around a QtWebEngine issue from openlp.core.display.webengine import WebEngineView self._is_initialised = False self._can_show_startup_screen = can_show_startup_screen self._fbo = None self.setWindowTitle(translate('OpenLP.DisplayWindow', 'Display Window')) self.setWindowFlags(flags) self.setAttribute(QtCore.Qt.WA_TranslucentBackground) self.setAutoFillBackground(True) self.setAttribute(QtCore.Qt.WA_DeleteOnClose) self.layout = QtWidgets.QVBoxLayout(self) self.layout.setContentsMargins(0, 0, 0, 0) self.webview = WebEngineView(self) self.webview.setAttribute(QtCore.Qt.WA_TranslucentBackground) self.webview.page().setBackgroundColor(QtCore.Qt.transparent) self.layout.addWidget(self.webview) self.webview.loadFinished.connect(self.after_loaded) display_base_path = AppLocation.get_directory(AppLocation.AppDir) / 'core' / 'display' / 'html' self.display_path = display_base_path / 'display.html' self.checkerboard_path = display_base_path / 'checkerboard.png' self.openlp_splash_screen_path = display_base_path / 'openlp-splash-screen.png' self.set_url(QtCore.QUrl.fromLocalFile(path_to_str(self.display_path))) self.channel = QtWebChannel.QWebChannel(self) self.media_watcher = MediaWatcher(self) self.channel.registerObject('mediaWatcher', self.media_watcher) self.display_watcher = DisplayWatcher(self) self.channel.registerObject('displayWatcher', self.display_watcher) self.webview.page().setWebChannel(self.channel) self.display_watcher.initialised.connect(self.on_initialised) self.is_display = False self.scale = 1 self.hide_mode = None self.__script_done = True self.__script_result = None if screen and screen.is_display: Registry().register_function('live_display_hide', self.hide_display) Registry().register_function('live_display_show', self.show_display) self.update_from_screen(screen) self.is_display = True # Only make visible on single monitor setup if setting enabled. if len(ScreenList()) > 1 or self.settings.value('core/display on monitor'): self.show()
def setUp(self): """ Some pre-test setup required. """ self.dummy1 = MagicMock() self.dummy2 = MagicMock() self.dummy3 = MagicMock() self.desktop = MagicMock() self.setup_application() self.desktop.primaryScreen.return_value = SCREEN['primary'] self.desktop.screenCount.return_value = SCREEN['number'] self.desktop.screenGeometry.return_value = SCREEN['size'] self.screens = ScreenList.create(self.desktop) Registry.create() self.form = settingsform.SettingsForm()
def setUp(self): """ Setup for tests """ Registry.create() self.registry = Registry() self.mocked_live_controller = MagicMock() self.desktop = MagicMock() self.desktop.primaryScreen.return_value = SCREEN['primary'] self.desktop.screenCount.return_value = SCREEN['number'] self.desktop.screenGeometry.return_value = SCREEN['size'] self.screens = ScreenList.create(self.desktop) renderer = Renderer() renderer.empty_height = 1000 Registry().register('live_controller', self.mocked_live_controller)
def __init__(self, *args, **kwargs): """ Constructor """ super().__init__(*args, **kwargs) self.force_page = False for screen in ScreenList(): if screen.is_display: self.setGeometry(screen.display_geometry.x(), screen.display_geometry.y(), screen.display_geometry.width(), screen.display_geometry.height()) break # If the display is not show'ed and hidden like this webegine will not render self.show() self.hide() self.theme_level = ThemeLevel.Global
def setUp(self): """ Set up the components need for all tests. """ # Mocked out desktop object self.desktop = MagicMock() self.desktop.primaryScreen.return_value = SCREEN['primary'] self.desktop.screenCount.return_value = SCREEN['number'] self.desktop.screenGeometry.return_value = SCREEN['size'] self.application = QtWidgets.QApplication.instance() Registry.create() self.application.setOrganizationName('OpenLP-tests') self.application.setOrganizationDomain('openlp.org') self.screens = ScreenList.create(self.desktop)
def setUp(self): """ Set up the components need for all tests. """ self.setup_application() self.build_settings() # Mocked out desktop object self.desktop = MagicMock() self.desktop.primaryScreen.return_value = SCREEN['primary'] self.desktop.screenCount.return_value = SCREEN['number'] self.desktop.screenGeometry.return_value = SCREEN['size'] self.screens = ScreenList.create(self.desktop) Settings().extend_default_settings(__default_settings__) self.temp_folder_path = Path(mkdtemp()) self.thumbnail_folder_path = Path(mkdtemp()) self.mock_plugin = MagicMock() self.mock_plugin.settings_section = self.temp_folder_path
def __init__(self, parent=None, name=None, icon=None): """ Initialise the DockWidget """ log.debug('Initialise the %s widget' % name) super(OpenLPDockWidget, self).__init__(parent) if name: self.setObjectName(name) if icon: self.setWindowIcon(build_icon(icon)) # Sort out the minimum width. screens = ScreenList() main_window_docbars = screens.current.display_geometry.width() // 5 if main_window_docbars > 300: self.setMinimumWidth(300) else: self.setMinimumWidth(main_window_docbars)
def show_display(self): """ Show the display """ if self.is_display: # Only make visible on single monitor setup if setting enabled. if len(ScreenList()) == 1 and not self.settings.value('core/display on monitor'): return self.run_javascript('Display.show();') # Check if setting for hiding logo on startup is enabled. # If it is, display should remain hidden, otherwise logo is shown. (from def setup) if self.isHidden() and not self.settings.value('core/logo hide on startup'): self.setVisible(True) self.hide_mode = None # Trigger actions when display is active again. if self.is_display: Registry().execute('live_display_active')
def close_presentation(self): """ Close presentation and clean up objects. This is triggered by a new object being added to SlideController or OpenLP being shut down. """ log.debug('close_presentation') if self.presentation: try: self.presentation.Close() except (AttributeError, pywintypes.com_error): log.exception( 'Caught exception while closing powerpoint presentation') trace_error_handler(log) self.presentation = None self.controller.remove_doc(self) # Make sure powerpoint doesn't steal focus, unless we're on a single screen setup if len(ScreenList()) > 1: Registry().get('main_window').activateWindow()
def __init__(self): """ Initialise the renderer. """ super(Renderer, self).__init__(None) # Need live behaviour if this is also working as a pseudo MainDisplay. self.screens = ScreenList() self.theme_level = ThemeLevel.Global self.global_theme_name = '' self.service_theme_name = '' self.item_theme_name = '' self.force_page = False self._theme_dimensions = {} self._calculate_default() self.web = QtWebKitWidgets.QWebView() self.web.setVisible(False) self.web_frame = self.web.page().mainFrame() Registry().register_function('theme_update_global', self.set_global_theme)
def setUp(self): """ Set up the components need for all tests. """ # Mocked out desktop object self.desktop = MagicMock() self.desktop.primaryScreen.return_value = 0 self.desktop.screenCount.return_value = 2 self.desktop.screenGeometry.side_effect = lambda x: { 0: QtCore.QRect(0, 0, 1024, 768), 1: QtCore.QRect(0, 0, 1024, 768) }[x] self.screens = ScreenList.create(self.desktop) Registry.create() self.registry = Registry() self.setup_application() Registry().register('application', self.app) self.mocked_audio_player = patch( 'openlp.core.ui.maindisplay.AudioPlayer') self.mocked_audio_player.start()
def hide_display(self, mode=HideMode.Screen): """ Hide the display by making all layers transparent Store the images so they can be replaced when required :param mode: How the screen is to be hidden """ log.debug('hide_display mode = {mode:d}'.format(mode=mode)) if self.is_display: # Only make visible on single monitor setup if setting enabled. if len(ScreenList()) == 1 and not self.settings.value('core/display on monitor'): return if mode == HideMode.Screen: self.setVisible(False) elif mode == HideMode.Blank: self.run_javascript('Display.blankToBlack();') else: self.run_javascript('Display.blankToTheme();') if mode != HideMode.Screen: if self.isHidden(): self.setVisible(True) self.webview.setVisible(True) self.hide_mode = mode