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
