#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
#       cover.py
#
#       Copyright 2012 S. Daniel Francis <francis@sugarlabs.org>
#
#       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; either version 3 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., 51 Franklin Street, Fifth Floor, Boston,
#       MA 02110-1301, USA.
#


import os
from gettext import gettext as _
import gobject
import gtk
from widgets import ImageEditor


class CoverSlide(gtk.VPaned):
    __gsignals__ = {'get-image-from-galery': (gobject.SIGNAL_RUN_LAST,
                                              gobject.TYPE_PYOBJECT,
                                              (gobject.TYPE_STRING,))}

    def set_copyright(self, title):
        self._copyright.set_text(title)

    def get_copyright(self):
        return self._copyright.get_text()

    def get_title_label(self):
        return self.slide_title

    def activate_time(self, widget):
        self._time.set_sensitive(widget.get_active())

    def get_count_time(self):
        return self.count_time.get_active()

    def set_count_time(self, value):
        self.count_time.set_active(value)

    def set_lenght(self, lenght):
        self._time.set_value(lenght)

    def get_lenght(self):
        return self._time.get_value() if self.get_count_time() else 0

    def set_slide_title(self, title):
        self.get_title_label().set_text(title)

    def get_slide_title(self):
        return self.get_title_label().get_text()

    def clear(self):
        self.presentation_title.clear()
        self._copyright.set_text("Copyright ©")
        self.count_time.set_active(False)
        self._time.set_value(0)
        self._time.set_sensitive(False)
        self.slide_title.clear()
        self.style_selection.select_path(self.style_model.get_path
                                            (self.default_color_iter))
        self.bullet_selection.select_path(self.bullet_model.get_path
                                          (self.default_bullet_iter))
        self.lang_selection.select_path(self.lang_model.get_path
                                        (self.default_lang_iter))
        self.set_show_big_bullet(True)
        self.head_image_editor.clear()
        self.background_image_editor.clear()
        self.cover_image_editor.clear()

    def get_bullet_type(self):
        model, _iter = self.bullet_selection.get_selected()
        return model.get_value(_iter, 0).split("-")[1]

    def set_bullet_type(self, bullet_type):
        _iter = self.bullet_model.get_iter_first()
        while _iter:
            if self.bullet_model.get_value(_iter,
                        0) == "icon-" + bullet_type + "-" + self.get_color():
                self.bullet_selection.select_path(self.bullet_model.get_path
                                                  (_iter))
            _iter = self.bullet_model.iter_next(_iter)

    def get_color(self):
        model, _iter = self.style_selection.get_selected()
        return model.get_value(_iter, 0)

    def set_color(self, color):
        _iter = self.style_model.get_iter_first()
        while _iter:
            if self.style_model.get_value(_iter, 0) == color:
                self.style_selection.select_path(self.style_model.get_path
                                                 (_iter))
            _iter = self.style_model.iter_next(_iter)

    def get_language(self):
        model, _iter = self.lang_selection.get_selected()
        return model.get_value(_iter, 0)

    def set_language(self, lang):
        _iter = self.lang_model.get_iter_first()
        while _iter:
            if self.lang_model.get_value(_iter, 0) == lang:
                self.lang_selection.select_path(self.lang_model.get_path(_iter))
            _iter = self.lang_model.iter_next(_iter)

    def get_show_big_bullet(self):
        return self.head_bullet_check.get_active()

    def set_show_big_bullet(self, show):
        self.head_bullet_check.set_active(show)

    def get_cover_image(self):
        if self.cover_image_check.get_active():
            return self.cover_image_editor.get_image_path()
        return None

    def get_background_image(self):
        if self.background_image_check.get_active():
            return self.background_image_editor.get_image_path()
        return None

    def get_head_image(self):
        if self.head_image_check.get_active():
            return self.head_image_editor.get_image_path()
        return None

    def set_head_image(self, head_image):
        if head_image == None:
            self.head_image_check.set_active(False)
        else:
            self.head_image_check.set_active(True)
            self.head_image_editor.set_image(head_image)

    def set_background_image(self, background_image):
        if background_image == None:
            self.background_image_check.set_active(False)
        else:
            self.background_image_check.set_active(True)
            self.background_image_editor.set_image(background_image)

    def set_cover_image(self, cover_image):
        if cover_image == None:
            self.cover_image_check.set_active(False)
        else:
            self.cover_image_check.set_active(True)
            self.cover_image_editor.set_image(cover_image)

    def __init__(self):
        gtk.VPaned.__init__(self)
        self.main_vbox = gtk.VBox()
        self.pack1(self.main_vbox)
        hbox = gtk.HBox()
        self._copyright = gtk.Entry()
        self._copyright.set_text("Copyright ©")
        self._copyright.set_tooltip_text("Copyright")
        self._copyright.show()
        hbox.pack_start(self._copyright, True, True)
        self.count_time = gtk.CheckButton(_("Presentation duration: "))
        self.count_time.connect("toggled", self.activate_time)
        self.count_time.show()
        hbox.pack_start(self.count_time, False, False, 0)
        self._time = gtk.SpinButton(gtk.Adjustment(value=0,
                                                   lower=0,
                                                   upper=120,
                                                   step_incr=1,
                                                   page_incr=5))
        self._time.show()
        self._time.set_sensitive(False)
        hbox.pack_start(self._time, True, True)
        self.label = gtk.Label(_("min"))
        self.label.show()
        hbox.pack_start(self.label, False, False)
        hbox.show()
        self.main_vbox.pack_start(hbox, False, True, 0)
        style_box = gtk.HBox()
        self.style_model = gtk.ListStore(str)
        self.styles_list = gtk.TreeView(self.style_model)
        column = gtk.TreeViewColumn(_("Presentation Color"))
        cell = gtk.CellRendererPixbuf()
        cell.set_property("stock-size", gtk.ICON_SIZE_DIALOG)
        column.pack_start(cell, True)
        column.add_attribute(cell, 'icon-name', 0)
        self.styles_list.append_column(column)
        self.styles_list.show()
        for i in os.listdir('./themes/colors'):
            _iter = self.style_model.append([i])
            if i == "blue":
                self.default_color_iter = _iter
                self.style_selection = self.styles_list.get_selection()
                self.style_selection.select_path(self.style_model.get_path
                                                 (_iter))
                self.style_selection.set_select_function(self.bullet_color_set)
        styles_scrollbar = gtk.VScrollbar(self.styles_list.get_vadjustment())
        style_box.pack_start(self.styles_list, True, True, 0)
        style_box.pack_start(styles_scrollbar, False, True, 0)

        self.bullet_model = gtk.ListStore(str)
        self.bullet_list = gtk.TreeView(self.bullet_model)
        hadjustment = self.bullet_list.get_hadjustment()
        hadjustment.set_page_size(hadjustment.get_upper())
        column = gtk.TreeViewColumn(_("Bullets Type"))
        cell = gtk.CellRendererPixbuf()
        cell.set_property("stock-size", gtk.ICON_SIZE_DIALOG)
        column.pack_start(cell, True)
        column.add_attribute(cell, 'icon-name', 0)
        self.bullet_list.append_column(column)
        self.bullet_list.show()
        for i in os.listdir('./themes/bullets'):
            _iter = self.bullet_model.append(["icon-" + i + "-blue"])
            if i == "square":
                self.default_bullet_iter = _iter
                self.bullet_selection = self.bullet_list.get_selection()
                self.bullet_selection.select_path(self.bullet_model.get_path
                                                  (_iter))
        bullet_scrollbar = gtk.VScrollbar(self.bullet_list.get_vadjustment())
        bullet_scrollbar.show()
        style_box.pack_start(self.bullet_list, True, True, 0)
        style_box.pack_start(bullet_scrollbar, False, True, 0)

        self.head_bullet_check = gtk.CheckButton(
                            _("Display a big bullet at the top of the slides"))
        self.head_bullet_check.set_active(True)
        self.head_bullet_check.show()
        self.images_check_view = gtk.TreeView()
        images_check_selection = self.images_check_view.get_selection()
        images_check_selection.set_select_function(self._current_image_set)
        self.images_check_model = gtk.ListStore(bool, str, int)
        self.images_check_view.set_model(self.images_check_model)
        null_column = gtk.TreeViewColumn()
        self.images_check_view.append_column(null_column)
        column = gtk.TreeViewColumn(_("Select an image item to edit it"))
        self.images_check_view.append_column(column)
        check_cell = gtk.CellRendererToggle()
        check_cell.connect("toggled", self.activate_image)
        null_column.pack_start(check_cell)
        desc_cell = gtk.CellRendererText()
        column.pack_start(desc_cell)
        null_column.add_attribute(check_cell, 'active', 0)
        column.add_attribute(desc_cell, 'text', 1)

        self.images_notebook = gtk.Notebook()
        self.images_notebook.set_show_tabs(False)
        label1 = gtk.Label("No selected image")
        label1.show()
        self.images_notebook.append_page(label1)

        self.top_image_editor = ImageEditor()
        self.top_image_editor.connect('get-image-from-galery',
                                      lambda w,
                                        arg: self.emit('get-image-from-galery',
                                                      arg))
        self.images_notebook.append_page(self.top_image_editor)
        self.images_check_model.append([False,
                                   "Display an image on the top of the slides",
                                   1])
        self.background_image_editor = ImageEditor()
        self.background_image_editor.connect('get-image-from-galery',
                                      lambda w,
                                        arg: self.emit('get-image-from-galery',
                                                      arg))
        self.images_check_model.append([False,
                         "Display a background image in the slides you choose",
                         2])
        self.images_notebook.append_page(self.background_image_editor)
        self.cover_image_editor = ImageEditor()
        self.cover_image_editor.connect('get-image-from-galery',
                                         lambda w,
                                        arg: self.emit('get-image-from-galery',
                                                       arg))
        self.images_check_model.append([False,
                                        "Display an image at the cover slide",
                                        3])
        self.images_notebook.append_page(self.cover_image_editor)
        self.images_check_view.show()
        style_box.show()
        self.main_vbox.pack_start(style_box, True, True, 0)
        self.main_vbox.pack_start(self.head_bullet_check, False, True, 0)
        self.main_vbox.pack_start(self.images_check_view, False, True, 0)
        self.images_notebook.show()
        self.pack2(self.images_notebook)
        self._ready = False
        self.connect('expose-event', self._expose_event_cb)
        """
        images_editing_box = gtk.VBox()
        self.images_model = gtk.ListStore(str, bool, int)
        self.head_iter = self.images_model.append(["Head Image", False, 1])
        self.head_image_check.connect("toggled",
                                      self.check_display_image,
                                      self.head_iter)
        self.background_iter = self.images_model.append(["Background Image",
                                                         False,
                                                         2])
        self.background_image_check.connect("toggled",
                                            self.check_display_image,
                                            self.background_iter)
        self.cover_iter = self.images_model.append(["Cover Image", False, 3])
        self.cover_image_check.connect("toggled",
                                       self.check_display_image,
                                       self.cover_iter)
        self.image_iters = [self.head_iter,
                            self.background_iter,
                            self.cover_iter]
        self.image_combo = gtk.ComboBox(self.images_model)
        cell = gtk.CellRendererText()
        self.image_combo.pack_start(cell)
        self.image_combo.add_attribute(cell, 'text', 0)
        self.image_combo.add_attribute(cell, 'sensitive', 1)
        self.image_combo.show()
        images_editing_box.pack_start(self.image_combo, False, True, 0)
        self.images_editing_notebook = gtk.Notebook()
        self.images_editing_notebook.set_show_tabs(False)
        self.images_editing_notebook.append_page(gtk.Label(), None)
        self.head_image_editor = ImageEditor()
        self.head_image_editor.show()
        self.images_editing_notebook.append_page(self.head_image_editor, None)
        self.background_image_editor = ImageEditor()
        self.background_image_editor.show()
        self.images_editing_notebook.append_page(self.background_image_editor,
                                                 None)
        self.cover_image_editor = ImageEditor()
        self.cover_image_editor.show()
        self.images_editing_notebook.append_page(self.cover_image_editor, None)
        self.images_editing_notebook.show_all()
        self.images_editing_notebook.set_current_page(0)
        self.image_combo.connect("changed", self.change_image)
        images_editing_box.pack_start(self.images_editing_notebook,
                                      True,
                                      True,
                                      0)
        images_editing_box.show()
        hbox.pack_start(images_editing_box, True, True, 0)
        """
        self.slide_title = gtk.Entry()
        self.slide_title.set_text("Cover Slide")
        self.slide_title.show()

    def _current_image_set(self, selection):
        _iter = self.images_check_model.get_iter(selection)
        if not self.images_check_model.get_value(_iter, 0):
            return False
        self.images_notebook.set_current_page(
                                       self.images_check_model.get_value(_iter,
                                                                         2))
        return True

    def _expose_event_cb(self, widget, event):
        if not self._ready:
            self._ready = True
            min_position = self.get_property('min-position')
            max_position = self.get_property('max-position')
            self.set_position((max_position - min_position) / 2 +\
                              min_position)

    def activate_image(self, widget, path):
        self.images_check_model[path][0] = not self.images_check_model[path][0]
        #FIXME, Need to select an active row or unselect all.
        if not self.images_check_model[path][0]:
            selection = self.images_check_view.get_selection()
            selection.unselect_iter(self.images_check_model.get_iter(path))
            self.images_notebook.set_current_page(0)
            _iter = self.images_check_model.get_iter_first()
            while _iter != None:
                if self.images_check_model[_iter][2]:
                    selection.select_iter(_iter)
                    break
                else:
                    _iter = self.images_check_model.iter_next(_iter)

    def change_image(self, widget):
        active_iter = self.image_combo.get_active_iter()
        self.images_editing_notebook.set_current_page(self.images_model.\
                                                      get_value
                                                      (active_iter,
                                                       2)
                                                       if active_iter else 0)

    def check_display_image(self, widget, _iter):
        self.images_model.set_value(_iter, 1, widget.get_active())
        if self.image_combo.get_active_iter() == None:
            self.image_combo.set_active_iter(_iter)
        if not self.images_model.get_value(self.image_combo.get_active_iter(),
                                           1):
            self.image_combo.set_property("active", -1)
            for i in self.image_iters:
                if self.images_model.get_value(i, 1):
                    self.image_combo.set_active_iter(i)
                    break

    def bullet_color_set(self, selection):
        _iter = self.style_model.get_iter(selection)
        for i in self.bullet_model:
            text = i[0].split("-")
            text[-1] = self.style_model.get_value(_iter, 0)
            i[0] = "-".join(text)
        return True