Sort out Presentation plugin Handler

* Allow 2 presentations to work at same time
* Sort out live / preview issues to stop cross messaging

openlp/core/lib/mediamanageritem.py

@@ -357,7 +357,7 @@ class MediaManagerItem(QtGui.QWidget):
                 self.trUtf8('No items selected...'),
                 self.trUtf8('You must select one or more items'))
         else:
-            log.debug(self.PluginNameShort + u' Preview Requested')
+            log.debug(self.PluginNameShort + u' Preview requested')
             service_item = self.buildServiceItem()
             if service_item:
                 service_item.fromPlugin = True
@@ -369,7 +369,7 @@ class MediaManagerItem(QtGui.QWidget):
                 self.trUtf8('No items selected...'),
                 self.trUtf8('You must select one or more items'))
         else:
-            log.debug(self.PluginNameShort + u' Live Requested')
+            log.debug(self.PluginNameShort + u' Live requested')
             service_item = self.buildServiceItem()
             if service_item:
                 service_item.fromPlugin = True
@@ -381,7 +381,7 @@ class MediaManagerItem(QtGui.QWidget):
                 self.trUtf8('No items selected...'),
                 self.trUtf8('You must select one or more items'))
         else:
-            log.debug(self.PluginNameShort + u' Add Requested')
+            log.debug(self.PluginNameShort + u' Add requested')
             service_item = self.buildServiceItem()
             if service_item:
                 service_item.fromPlugin = False

openlp/core/lib/serviceitem.py

@@ -112,6 +112,8 @@ class ServiceItem(object):
             for slide in self._raw_frames:
                 slide[u'image'] = \
                     self.RenderManager.resize_image(slide[u'image'])
+        elif self.service_item_type == ServiceItemType.Command:
+            pass
         else:
             log.error(u'Invalid value renderer :%s' % self.service_item_type)
 

openlp/core/ui/maindisplay.py

@@ -214,7 +214,6 @@ class MainDisplay(DisplayWidget):
                 self.setVisible(True)
                 self.showFullScreen()
         self.frame = frame
-        print type(self.frame)
 
     def blankDisplay(self, blanked=True):
         if blanked:

openlp/core/ui/slidecontroller.py

@@ -390,14 +390,12 @@ class SlideController(QtGui.QWidget):
         #If old item was a command tell it to stop
         if self.serviceItem and self.serviceItem.is_command():
             self.onMediaStop()
-        if item.is_command():
+        if item.is_media():
-            if self.isLive:
+            self.onMediaStart(item)
-                Receiver.send_message(u'%s_start' % item.name.lower(), \
+        elif item.is_command():
-                    [item.title, item.service_item_path,
+            Receiver.send_message(u'%s_start' % item.name.lower(), \
-                    item.get_frame_title(), slideno, self.isLive])
+                [item.title, item.service_item_path,
-            else:
+                item.get_frame_title(), slideno, self.isLive])
-                if item.is_media():
-                    self.onMediaStart(item)
         self.displayServiceManagerItems(item, slideno)
 
     def displayServiceManagerItems(self, serviceItem, slideno):
@@ -475,7 +473,8 @@ class SlideController(QtGui.QWidget):
         if not self.serviceItem:
             return
         if self.serviceItem.is_command():
-            Receiver.send_message(u'%s_first'% self.serviceItem.name.lower())
+            Receiver.send_message(u'%s_first'% \
+                self.serviceItem.name.lower(), self.isLive)
             self.updatePreview()
         else:
             self.PreviewListWidget.selectRow(0)
@@ -504,17 +503,20 @@ class SlideController(QtGui.QWidget):
         row = self.PreviewListWidget.currentRow()
         self.selectedRow = 0
         if row > -1 and row < self.PreviewListWidget.rowCount():
-            if self.serviceItem.is_command():
+            if self.serviceItem.is_command() and self.isLive:
-                Receiver.send_message(u'%s_slide'% self.serviceItem.name.lower(), [row])
+                Receiver.send_message(u'%s_slide'% \
-                if self.isLive:
+                    self.serviceItem.name.lower(), u'%s:%s' % (row, self.isLive))
-                    self.updatePreview()
+                self.updatePreview()
             else:
                 before = time.time()
                 frame = self.serviceItem.get_rendered_frame(row)
                 if isinstance(frame, QtGui.QImage):
                     self.SlidePreview.setPixmap(QtGui.QPixmap.fromImage(frame))
                 else:
-                    self.SlidePreview.setPixmap(QtGui.QPixmap.fromImage(frame[u'main']))
+                    if isinstance(frame[u'main'], basestring):
+                        self.SlidePreview.setPixmap(QtGui.QPixmap(frame[u'main']))
+                    else:
+                        self.SlidePreview.setPixmap(QtGui.QPixmap.fromImage(frame[u'main']))
                 log.log(15, u'Slide Rendering took %4s' % (time.time() - before))
                 if self.isLive:
                     self.parent.mainDisplay.frameView(frame, True)
@@ -553,7 +555,8 @@ class SlideController(QtGui.QWidget):
         if not self.serviceItem:
             return
         if self.serviceItem.is_command():
-            Receiver.send_message(u'%s_next'% self.serviceItem.name.lower())
+            Receiver.send_message(u'%s_next' % \
+                self.serviceItem.name.lower(), self.isLive)
             self.updatePreview()
         else:
             row = self.PreviewListWidget.currentRow() + 1
@@ -570,7 +573,7 @@ class SlideController(QtGui.QWidget):
             return
         if self.serviceItem.is_command():
             Receiver.send_message(
-                u'%s_previous'% self.serviceItem.name.lower())
+                u'%s_previous'% self.serviceItem.name.lower(),  self.isLive)
             self.updatePreview()
         else:
             row = self.PreviewListWidget.currentRow() - 1
@@ -586,7 +589,8 @@ class SlideController(QtGui.QWidget):
         if not self.serviceItem:
             return
         if self.serviceItem.is_command():
-            Receiver.send_message(u'%s_last'% self.serviceItem.name.lower())
+            Receiver.send_message(u'%s_last' % \
+                self.serviceItem.name.lower(), self.isLive)
             self.updatePreview()
         else:
             self.PreviewListWidget.selectRow(self.PreviewListWidget.rowCount() - 1)
@@ -628,11 +632,16 @@ class SlideController(QtGui.QWidget):
                 self.serviceItem, row)
 
     def onMediaStart(self, item):
-        self.mediaObject.stop()
+        if self.isLive:
-        self.mediaObject.clearQueue()
+            Receiver.send_message(u'%s_start' % item.name.lower(), \
-        file = os.path.join(item.service_item_path, item.get_frame_title())
+                [item.title, item.service_item_path,
-        self.mediaObject.setCurrentSource(Phonon.MediaSource(file))
+                item.get_frame_title(), slideno, self.isLive])
-        self.onMediaPlay()
+        else:
+            self.mediaObject.stop()
+            self.mediaObject.clearQueue()
+            file = os.path.join(item.service_item_path, item.get_frame_title())
+            self.mediaObject.setCurrentSource(Phonon.MediaSource(file))
+            self.onMediaPlay()
 
     def onMediaPause(self):
         if self.isLive:

openlp/plugins/presentations/lib/messagelistener.py

@@ -30,6 +30,124 @@ from PyQt4 import QtCore
 
 from openlp.core.lib import Receiver
 
+class Controller(object):
+    """
+    This is the Presentation listener who acts on events from the slide
+    controller and passes the messages on the the correct presentation handlers
+    """
+    global log
+    log = logging.getLogger(u'Controller')
+    log.info(u'Controller loaded')
+
+    def __init__(self, live):
+        self.isLive = live
+        log.info(u'%s controller loaded' % live)
+
+    def addHandler(self, controller, file):
+        log.debug(u'Live = %s, addHandler %s' % (self.isLive, file))
+        self.controller = controller
+        if self.controller.is_loaded():
+            self.shutdown(None)
+        self.controller.load_presentation(file)
+        if self.isLive:
+            self.controller.start_presentation()
+            Receiver.send_message(u'live_slide_hide')
+        self.controller.slidenumber = 0
+
+    def activate(self):
+        log.debug(u'Live = %s, activate' % self.isLive)
+        if self.controller.is_active():
+            return
+        if not self.controller.is_loaded():
+            self.controller.load_presentation(self.controller.filepath)
+        if self.isLive:
+            self.controller.start_presentation()
+            if self.controller.slidenumber > 1:
+                self.controller.goto_slide(self.controller.slidenumber)
+
+    def slide(self, message):
+        log.debug(u'Live = %s, slide' % self.isLive)
+        print "slide ", message
+        if not self.isLive:
+            return
+        self.activate()
+        if message:
+            self.controller.goto_slide(message[0] + 1)
+            self.controller.poll_slidenumber(self.isLive)
+
+    def first(self, message):
+        """
+        Based on the handler passed at startup triggers the first slide
+        """
+        log.debug(u'Live = %s, first' % self.isLive)
+        print "first ", message
+        if not self.isLive:
+            return
+        self.activate()
+        self.controller.start_presentation()
+        self.controller.poll_slidenumber(self.isLive)
+
+    def last(self, message):
+        """
+        Based on the handler passed at startup triggers the first slide
+        """
+        log.debug(u'Live = %s, last' % self.isLive)
+        print "last ", message
+        if not self.isLive:
+            return
+        self.activate()
+        self.controller.goto_slide(self.controller.get_slide_count())
+        self.controller.poll_slidenumber(self.isLive)
+
+    def next(self, message):
+        """
+        Based on the handler passed at startup triggers the next slide event
+        """
+        log.debug(u'Live = %s, next' % self.isLive)
+        print "next ", message
+        if not self.isLive:
+            return
+        self.activate()
+        self.controller.next_step()
+        self.controller.poll_slidenumber(self.isLive)
+
+    def previous(self, message):
+        """
+        Based on the handler passed at startup triggers the previous slide event
+        """
+        log.debug(u'Live = %s, previous' % self.isLive)
+        if not self.isLive:
+            return
+        print "previous ", message
+        self.activate()
+        self.controller.previous_step()
+        self.controller.poll_slidenumber(self.isLive)
+
+    def shutdown(self, message):
+        """
+        Based on the handler passed at startup triggers slide show to shut down
+        """
+        log.debug(u'Live = %s, shutdown' % self.isLive)
+        self.controller.close_presentation()
+        self.controller.slidenumber = 0
+        #self.timer.stop()
+
+    def blank(self):
+        if not self.isLive:
+            return
+        if not self.controller.is_loaded():
+            return
+        if not self.controller.is_active():
+            return
+        self.controller.blank_screen()
+
+    def unblank(self):
+        if not self.is_live:
+            return
+        self.activate()
+        self.controller.unblank_screen()
+
+
 class MessageListener(object):
     """
     This is the Presentation listener who acts on events from the slide
@@ -41,8 +159,9 @@ class MessageListener(object):
 
     def __init__(self, controllers):
         self.controllers = controllers
-        self.handler = None
+        self.previewHandler = Controller(False)
-        self.is_live = None
+        self.liveHandler = Controller(True)
+        self.isLive = None
         # messages are sent from core.ui.slidecontroller
         QtCore.QObject.connect(Receiver.get_receiver(),
             QtCore.SIGNAL(u'presentations_start'), self.startup)
@@ -71,108 +190,84 @@ class MessageListener(object):
         Start of new presentation
         Save the handler as any new presentations start here
         """
-        self.handler, file, self.is_live = self.decodeMessage(message)
+        log.debug(u'Startup called with message %s' % message)
-        self.controller = self.controllers[self.handler]
+        self.handler, file, isLive = self.decodeMessage(message)
-        if self.controller.is_loaded():
+        if isLive:
-            self.shutdown(None)
+            self.liveHandler.addHandler(self.controllers[self.handler], file)
-        self.controller.load_presentation(file)
+        else:
-        if self.is_live:
+            self.previewHandler.addHandler(self.controllers[self.handler], file)
-            self.controller.start_presentation()
-            Receiver.send_message(u'live_slide_hide')
-        self.controller.slidenumber = 0
-        self.timer.start()
-
-    def activate(self):
-        if self.controller.is_active():
-            return
-        if not self.controller.is_loaded():
-            self.controller.load_presentation(self.controller.filepath)
-        self.controller.start_presentation()
-        if self.controller.slidenumber > 1:
-            self.controller.goto_slide(self.controller.slidenumber)
 
     def slide(self, message):
-        if not self.is_live:
+        slide, live = self.splitMessage(message)
-            return
+        if live:
-        self.activate()
+            self.liveHandler.activate()
-        if message:
+        else:
-            self.controller.goto_slide(message[0]+1)
+            self.previewHandler.activate()
-            self.controller.poll_slidenumber(self.is_live)
 
     def first(self, message):
-        """
+        if self.isLive:
-        Based on the handler passed at startup triggers the first slide
+            self.liveHandler.first(message)
-        """
+        else:
-        if not self.is_live:
+            self.previewHandler.first(message)
-            return
-        self.activate()
-        self.controller.start_presentation()
-        self.controller.poll_slidenumber(self.is_live)
 
     def last(self, message):
-        """
+        if self.isLive:
-        Based on the handler passed at startup triggers the first slide
+            self.liveHandler.last(message)
-        """
+        else:
-        if not self.is_live:
+            self.previewHandler.last(message)
-            return
-        self.activate()
-        self.controller.goto_slide(self.controller.get_slide_count())
-        self.controller.poll_slidenumber(self.is_live)
 
     def next(self, message):
-        """
+        if self.isLive:
-        Based on the handler passed at startup triggers the next slide event
+            self.liveHandler.next(message)
-        """
+        else:
-        if not self.is_live:
+            self.previewHandler.next(message)
-            return
-        self.activate()
-        self.controller.next_step()
-        self.controller.poll_slidenumber(self.is_live)
 
     def previous(self, message):
-        """
+        if self.isLive:
-        Based on the handler passed at startup triggers the previous slide event
+            self.liveHandler.previous(message)
-        """
+        else:
-        if not self.is_live:
+            self.previewHandler.previous(message)
-            return
-        self.activate()
-        self.controller.previous_step()
-        self.controller.poll_slidenumber(self.is_live)
 
     def shutdown(self, message):
-        """
+        if self.isLive:
-        Based on the handler passed at startup triggers slide show to shut down
+            self.liveHandler.shutdown(message)
-        """
-        if self.is_live:
             Receiver.send_message(u'live_slide_show')
-        self.controller.close_presentation()
+        else:
-        self.controller.slidenumber = 0
+            self.previewHandler.shutdown(message)
-        self.timer.stop()
 
     def blank(self):
-        if not self.is_live:
+        if self.isLive:
-            return
+            self.liveHandler.blank()
-        if not self.controller.is_loaded():
+        else:
-            return
+            self.previewHandler.blank()
-        if not self.controller.is_active():
-            return
-        self.controller.blank_screen()
 
     def unblank(self):
-        if not self.is_live:
+        if self.isLive:
-            return
+            self.liveHandler.unblank()
-        self.activate()
+        else:
-        self.controller.unblank_screen()
+            self.previewHandler.unblank()
+
+    def splitMessage(self, message):
+        """
+        Splits the selection messages
+        into it's component parts
+
+        ``message``
+        Message containing Presentaion handler name and file to be presented.
+        """
+        bits = message.split(u':')
+        return bits[0], bits[1]
 
     def decodeMessage(self, message):
         """
-        Splits the message from the SlideController into it's component parts
+        Splits the initial message from the SlideController
+        into it's component parts
 
         ``message``
         Message containing Presentaion handler name and file to be presented.
         """
         file = os.path.join(message[1], message[2])
-        return message[0], file, message[3]
+        return message[0], file, message[4]
 
     def timeout(self):
         self.controller.poll_slidenumber(self.is_live)