openlp/openlp/plugins/presentations/lib/mediaitem.py

# -*- coding: utf-8 -*-
# vim: autoindent shiftwidth=4 expandtab textwidth=80 tabstop=4 softtabstop=4

###############################################################################
# OpenLP - Open Source Lyrics Projection                                      #
# --------------------------------------------------------------------------- #
# Copyright (c) 2008-2010 Raoul Snyman                                        #
# Portions copyright (c) 2008-2010 Tim Bentley, Jonathan Corwin, Michael      #
# Gorven, Scott Guerrieri, Christian Richter, Maikel Stuivenberg, Martin      #
# Thompson, Jon Tibble, Carsten Tinggaard                                     #
# --------------------------------------------------------------------------- #
# This program is free software; you can redistribute it and/or modify it     #
# under the terms of the GNU General Public License as published by the Free  #
# Software Foundation; version 2 of the License.                              #
#                                                                             #
# This program is distributed in the hope that it will be useful, but WITHOUT #
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or       #
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for    #
# more details.                                                               #
#                                                                             #
# You should have received a copy of the GNU General Public License along     #
# with this program; if not, write to the Free Software Foundation, Inc., 59  #
# Temple Place, Suite 330, Boston, MA 02111-1307 USA                          #
###############################################################################

import logging
import os

from PyQt4 import QtCore, QtGui

from openlp.core.lib import MediaManagerItem, BaseListWithDnD, build_icon, \
    SettingsManager, translate, check_item_selected
from openlp.plugins.presentations.lib import MessageListener

log = logging.getLogger(__name__)

class PresentationListView(BaseListWithDnD):
    """
    Class for the list of Presentations
    
    We have to explicitly create separate classes for each plugin
    in order for DnD to the Service manager to work correctly.
    """
    def __init__(self, parent=None):
        self.PluginName = u'Presentations'
        BaseListWithDnD.__init__(self, parent)

class PresentationMediaItem(MediaManagerItem):
    """
    This is the Presentation media manager item for Presentation Items.
    It can present files using Openoffice and Powerpoint
    """
    log.info(u'Presentations Media Item loaded')

    def __init__(self, parent, icon, title, controllers):
        """
        Constructor. Setup defaults
        """
        self.controllers = controllers
        self.PluginNameShort = u'Presentation'
        self.pluginNameVisible = translate('PresentationPlugin.MediaItem',
            'Presentation')
        self.IconPath = u'presentations/presentation'
        self.Automatic = u''
        # this next is a class, not an instance of a class - it will
        # be instanced by the base MediaManagerItem
        self.ListViewWithDnD_class = PresentationListView
        MediaManagerItem.__init__(self, parent, icon, title)
        self.message_listener = MessageListener(self)

    def retranslateUi(self):
        """
        The name of the plugin media displayed in UI
        """
        self.OnNewPrompt = translate('PresentationPlugin.MediaItem',
            'Select Presentation(s)')
        self.Automatic = translate('PresentationPlugin.MediaItem',
            'Automatic')
        fileType = u''
        for controller in self.controllers:
            if self.controllers[controller].enabled:
                types = self.controllers[controller].supports + \
                    self.controllers[controller].alsosupports
                for type in types:
                    if fileType.find(type) == -1:
                        fileType += u'*%s ' % type
                        self.parent.serviceManager.supportedSuffixes(type)
        self.OnNewFileMasks = translate('PresentationPlugin.MediaItem',
            'Presentations (%s)' % fileType)

    def requiredIcons(self):
        """
        Set which icons the media manager tab should show
        """
        MediaManagerItem.requiredIcons(self)
        self.hasFileIcon = True
        self.hasNewIcon = False
        self.hasEditIcon = False

    def addEndHeaderBar(self):
        """
        Display custom media manager items for presentations
        """
        self.PresentationWidget = QtGui.QWidget(self)
        sizePolicy = QtGui.QSizePolicy(
            QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Minimum)
        sizePolicy.setHorizontalStretch(0)
        sizePolicy.setVerticalStretch(0)
        sizePolicy.setHeightForWidth(
            self.PresentationWidget.sizePolicy().hasHeightForWidth())
        self.PresentationWidget.setSizePolicy(sizePolicy)
        self.PresentationWidget.setObjectName(u'PresentationWidget')
        self.DisplayLayout = QtGui.QGridLayout(self.PresentationWidget)
        self.DisplayLayout.setObjectName(u'DisplayLayout')
        self.DisplayTypeComboBox = QtGui.QComboBox(self.PresentationWidget)
        self.DisplayTypeComboBox.setObjectName(u'DisplayTypeComboBox')
        self.DisplayLayout.addWidget(self.DisplayTypeComboBox, 0, 1, 1, 2)
        self.DisplayTypeLabel = QtGui.QLabel(self.PresentationWidget)
        self.DisplayTypeLabel.setObjectName(u'SearchTypeLabel')
        self.DisplayLayout.addWidget(self.DisplayTypeLabel, 0, 0, 1, 1)
        self.DisplayTypeLabel.setText(
            translate('PresentationPlugin.MediaItem', 'Present using:'))
        # Add the Presentation widget to the page layout
        self.pageLayout.addWidget(self.PresentationWidget)

    def initialise(self):
        """
        Populate the media manager tab
        """
        self.listView.setIconSize(QtCore.QSize(88, 50))
        list = SettingsManager.load_list(
            self.settingsSection, u'presentations')
        self.loadList(list, True)
        for item in self.controllers:
            #load the drop down selection
            if self.controllers[item].enabled:
                self.DisplayTypeComboBox.addItem(item)
        if self.DisplayTypeComboBox.count() > 1:
            self.DisplayTypeComboBox.insertItem(0, self.Automatic)
            self.DisplayTypeComboBox.setCurrentIndex(0)

    def loadList(self, list, initialLoad=False):
        """
        Add presentations into the media manager
        This is called both on initial load of the plugin to populate with
        existing files, and when the user adds new files via the media manager
        """
        currlist = self.getFileList()
        titles = []
        for file in currlist:
            titles.append(os.path.split(file)[1])
        for file in list:
            if currlist.count(file) > 0:
                continue
            filename = os.path.split(unicode(file))[1]
            if titles.count(filename) > 0:
                if not initialLoad:
                    QtGui.QMessageBox.critical(
                        self, translate('PresentationPlugin.MediaItem',
                        'File exists'),
                        translate('PresentationPlugin.MediaItem',
                        'A presentation with that filename already exists.'),
                        QtGui.QMessageBox.Ok)
                continue
            controller_name = self.findControllerByType(filename)
            if controller_name:
                controller = self.controllers[controller_name]
                doc = controller.add_doc(unicode(file))
                thumb = os.path.join(doc.get_thumbnail_folder(), u'icon.png')
                preview = doc.get_thumbnail_path(1, True)
                if not preview and not initialLoad:
                    doc.load_presentation()
                    preview = doc.get_thumbnail_path(1, True)
                doc.close_presentation()
                if preview and self.validate(preview, thumb):
                    icon = build_icon(thumb)
                else:
                    icon = build_icon(u':/general/general_delete.png')
            else:
                if initialLoad:
                    icon = build_icon(u':/general/general_delete.png')
                else:
                    QtGui.QMessageBox.critical(
                        self, translate('PresentationPlugin.MediaItem',
                        'Unsupported file'),
                        translate('PresentationPlugin.MediaItem',
                        'This type of presentation is not supported'),
                        QtGui.QMessageBox.Ok)
                    continue
            item_name = QtGui.QListWidgetItem(filename)
            item_name.setData(QtCore.Qt.UserRole, QtCore.QVariant(file))
            item_name.setIcon(icon)
            self.listView.addItem(item_name)

    def onDeleteClick(self):
        """
        Remove a presentation item from the list
        """
        if check_item_selected(self.listView,
            translate('PresentationPlugin.MediaItem',
            'You must select an item to delete.')):
            items = self.listView.selectedIndexes()
            row_list = [item.row() for item in items]
            row_list.sort(reverse=True)
            for item in items:
                filepath = unicode(item.data(
                    QtCore.Qt.UserRole).toString())
                for cidx in self.controllers:
                    doc = self.controllers[cidx].add_doc(filepath)
                    doc.presentation_deleted()
                    doc.close_presentation()
            for row in row_list:
                self.listView.takeItem(row)
            SettingsManager.set_list(self.settingsSection,
                self.settingsSection, self.getFileList())

    def generateSlideData(self, service_item, item=None):
        """
        Load the relevant information for displaying the presentation
        in the slidecontroller. In the case of powerpoints, an image
        for each slide
        """
        items = self.listView.selectedIndexes()
        if len(items) > 1:
            return False
        service_item.title = unicode(self.DisplayTypeComboBox.currentText())
        service_item.shortname = unicode(self.DisplayTypeComboBox.currentText())
        shortname = service_item.shortname
        if shortname:
            for item in items:
                bitem = self.listView.item(item.row())
                filename = unicode(bitem.data(QtCore.Qt.UserRole).toString())
                if shortname == self.Automatic:
                    service_item.shortname = self.findControllerByType(filename)
                    if not service_item.shortname:
                        return False
                controller = self.controllers[service_item.shortname]
                (path, name) = os.path.split(filename)
                doc = controller.add_doc(filename)
                if doc.get_thumbnail_path(1, True) is None:
                    doc.load_presentation()
                i = 1
                img = doc.get_thumbnail_path(i, True)
                while img:
                    service_item.add_from_command(path, name, img)
                    i = i + 1
                    img = doc.get_thumbnail_path(i, True)
                doc.close_presentation()
            return True
        else:
            return False

    def findControllerByType(self, filename):
        """
        Determine the default application controller to use for the selected
        file type. This is used if "Automatic" is set as the preferred 
        controller. Find the first (alphabetic) enabled controller which
        "supports" the extension. If none found, then look for a controller
        which "alsosupports" it instead.
        """
        filetype = os.path.splitext(filename)[1]
        if not filetype:
            return None
        for controller in self.controllers:
            if self.controllers[controller].enabled:
                if filetype in self.controllers[controller].supports:
                    return controller
        for controller in self.controllers:
            if self.controllers[controller].enabled:
                if filetype in self.controllers[controller].alsosupports:
                    return controller
        return None