[gnome-clocks: 4/5] Implement deleting functionality for World Clocks

[Seif Lotfy <seiflotfy src gnome org>]

commit 4d23553c9be98368bb3f20e0caec6f84383e889e
Author: Seif Lotfy <seif lotfy com>
Date:   Fri Aug 24 12:46:08 2012 +0200

    Implement deleting functionality for World Clocks
    
    Added Delete button widget for "Selection Mode" and finished
    deleteing functionality for world clocks.

 gnomeclocks/app.py     |   42 ++++++++++++---
 gnomeclocks/clocks.py  |   14 +++--
 gnomeclocks/widgets.py |  132 +++++++++++++++++++++++++++++++++++++++++++++++-
 3 files changed, 172 insertions(+), 16 deletions(-)
---
diff --git a/gnomeclocks/app.py b/gnomeclocks/app.py
index 34deca1..24c45c8 100644
--- a/gnomeclocks/app.py
+++ b/gnomeclocks/app.py
@@ -17,12 +17,15 @@
 # Author: Seif Lotfy <seif lotfy collabora co uk>
 
 import os
+import sys
 from gettext import ngettext
-from gi.repository import Gtk, Gdk, GObject, GLib, Gio
+from gi.repository import Gtk, Gdk, GObject, GLib, Gio, GtkClutter
 from clocks import Clock, World, Alarm, Timer, Stopwatch
+from widgets import Embed
 from utils import Dirs
 from gnomeclocks import __version__, AUTHORS, COPYRIGHTS
 
+GtkClutter.init(sys.argv)
 
 class Window(Gtk.ApplicationWindow):
     def __init__(self, app):
@@ -49,12 +52,13 @@ class Window(Gtk.ApplicationWindow):
 
         self.set_size_request(640, 480)
         self.vbox = vbox = Gtk.VBox()
-        self.add(vbox)
+        embed = Embed(vbox)
+        self.add(embed)
         self.notebook = Gtk.Notebook()
         self.notebook.set_show_tabs(False)
         self.notebook.set_show_border(False)
 
-        self.toolbar = ClocksToolbar()
+        self.toolbar = ClocksToolbar(embed._selectionToolbar)
 
         vbox.pack_start(self.toolbar, False, False, 0)
         vbox.pack_start(self.toolbar.selection_toolbar, False, False, 0)
@@ -75,6 +79,7 @@ class Window(Gtk.ApplicationWindow):
 
         self.world.connect("show-clock", self._on_show_clock)
         self.toolbar.connect("view-clock", self._on_view_clock)
+        vbox.show_all()
         self.show_all()
         self.toolbar.selection_toolbar.hide()
 
@@ -136,8 +141,9 @@ class Window(Gtk.ApplicationWindow):
 
 
 class SelectionToolbar(Gtk.Toolbar):
-    def __init__(self):
+    def __init__(self, _selectionToolbar):
         Gtk.Toolbar.__init__(self)
+        self._selectionToolbar = _selectionToolbar
         self.get_style_context().add_class("clocks-toolbar")
         self.set_icon_size(Gtk.IconSize.MENU)
         self.get_style_context().add_class(Gtk.STYLE_CLASS_MENUBAR)
@@ -177,6 +183,8 @@ class SelectionToolbar(Gtk.Toolbar):
         self.doneButton.get_style_context().add_class('suggested-action')
         self.doneButton.set_label(_("Done"))
         self.doneButton.set_size_request(64, 34)
+        self.doneButton.connect("clicked", self._on_done_clicked)
+        self._selectionToolbar._toolbarDelete.connect("clicked", self._on_delete_clicked)
 
         self.leftBox = box = Gtk.Box()
         box.pack_start(self.doneButton, False, False, 0)
@@ -202,11 +210,29 @@ class SelectionToolbar(Gtk.Toolbar):
     def _on_selection_changed(self, view):
         selection = view.get_selection()
         self.set_selection_label(len(selection))
-
+        if len(selection) > 0:
+            self._selectionToolbar._fade_in()
+        else:
+            self._selectionToolbar._fade_out()
+
+    def _on_done_clicked(self, widget):
+        #TODO: do something
+        self._selectionToolbar._fade_out()
+
+    def _on_delete_clicked(self, widget):
+        selection = self.current_view.get_selection()
+        if type(self.current_view) == World:
+            model = self.current_view.liststore
+            items = []
+            for treepath in selection:
+                items.append(model[treepath][3])
+            self.current_view.delete_clocks(items)
+        selection = self.current_view.get_selection()
+        self.set_selection_label(len(selection))
+        self._selectionToolbar._fade_out()
 
 class ClockButton(Gtk.RadioButton):
     _group = None
-
     def __init__(self, text):
         Gtk.RadioButton.__init__(self, group=ClockButton._group, draw_indicator=False)
         self.text = text
@@ -234,7 +260,7 @@ class ClocksToolbar(Gtk.Toolbar):
     __gsignals__ = {'view-clock': (GObject.SignalFlags.RUN_LAST,
                     None, (Clock,))}
 
-    def __init__(self):
+    def __init__(self, selectionToolbar):
         Gtk.Toolbar.__init__(self)
 
         self.get_style_context().add_class("clocks-toolbar")
@@ -298,7 +324,7 @@ class ClocksToolbar(Gtk.Toolbar):
         box.pack_end(self.applyButton, False, False, 0)
         toolbox.pack_start(box, True, True, 0)
 
-        self.selection_toolbar = SelectionToolbar()
+        self.selection_toolbar = SelectionToolbar(selectionToolbar)
         self.selection_toolbar.doneButton.connect("clicked",
             self._on_selection_mode, False)
 
diff --git a/gnomeclocks/clocks.py b/gnomeclocks/clocks.py
index 48c4c92..8b7c4a3 100644
--- a/gnomeclocks/clocks.py
+++ b/gnomeclocks/clocks.py
@@ -131,9 +131,13 @@ class World(Clock):
                                            "<b>" + name + "</b>",
                                            d])
 
-    def delete_clock(self, d):
-        self.clocks.remove(d.location)
+    def delete_clocks(self, clocks):
+        for d in clocks:
+            self.clocks.remove(d._location)
+        worldclockstorage.save_clocks(self.clocks)
         self.iconview.unselect_all()
+        self.liststore.clear()
+        self.load_clocks()
 
     def update_empty_view(self):
         if len(self.liststore) == 0:
@@ -148,8 +152,7 @@ class World(Clock):
                 self.show_all()
 
     def open_new_dialog(self):
-        parent = self.get_parent().get_parent().get_parent()
-        window = NewWorldClockDialog(parent)
+        window = NewWorldClockDialog(self.get_toplevel())
         window.connect("response", self.on_dialog_response)
         window.show_all()
 
@@ -268,8 +271,7 @@ class Alarm(Clock):
         print "To Do!"
 
     def open_new_dialog(self):
-        parent = self.get_parent().get_parent().get_parent()
-        window = AlarmDialog(self, parent)
+        window = AlarmDialog(self, self.get_toplevel())
         window.connect("response", self.on_dialog_response, True)
         window.show_all()
 
diff --git a/gnomeclocks/widgets.py b/gnomeclocks/widgets.py
index 4a9a85f..2328557 100644
--- a/gnomeclocks/widgets.py
+++ b/gnomeclocks/widgets.py
@@ -17,7 +17,7 @@
 # Author: Seif Lotfy <seif lotfy collabora co uk>
 
 from gi.repository import Gtk, Gdk, GdkPixbuf, GObject, Gio, Pango, PangoCairo
-from gi.repository import GWeather
+from gi.repository import GWeather, Clutter, GtkClutter
 
 from storage import Location
 from alarm import AlarmItem
@@ -27,6 +27,7 @@ import os
 import cairo
 import time
 
+SELECTION_TOOLBAR_DEFAULT_WIDTH = 300;
 
 # FIXME: Use real sunrise/sunset time in the future
 def get_is_day(hour):
@@ -103,6 +104,7 @@ class NewWorldClockDialog(Gtk.Dialog):
 
 class DigitalClock():
     def __init__(self, location):
+        self._location = location
         self.location = location.location
         self.id = location.id
         self.timezone = self.location.get_timezone()
@@ -672,5 +674,131 @@ class SelectableIconView(Gtk.IconView):
                     self.emit("selection-changed")
             else:
                 self.emit("item-activated", path)
-
         return False
+
+def alphaGtkWidget(widget):
+    widget.override_background_color(0, Gdk.RGBA(0,0,0,0))
+
+class SelectionToolbar():
+
+    def __init__(self, parent_actor):
+        self._parent_actor = parent_actor
+        
+        self.widget = Gtk.Toolbar()
+        self.widget.set_show_arrow(False)
+        self.widget.set_icon_size(Gtk.IconSize.LARGE_TOOLBAR)
+        self.widget.get_style_context().add_class('osd');
+        self.widget.set_size_request(SELECTION_TOOLBAR_DEFAULT_WIDTH, -1);
+
+        self.actor = GtkClutter.Actor.new_with_contents(self.widget)
+        self.actor.set_opacity(0)
+        alphaGtkWidget(self.actor.get_widget())
+
+        constraint = Clutter.AlignConstraint()
+        constraint.set_source(self._parent_actor)
+        constraint.set_align_axis(Clutter.AlignAxis.X_AXIS)
+        constraint.set_factor(0.50)
+        self.actor.add_constraint(constraint)
+
+        constraint = Clutter.AlignConstraint()
+        constraint.set_source(self._parent_actor)
+        constraint.set_align_axis(Clutter.AlignAxis.Y_AXIS)
+        constraint.set_factor(0.95)
+        self.actor.add_constraint(constraint)
+
+        self._leftBox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
+        self._leftGroup = Gtk.ToolItem()
+        self._leftGroup.set_expand(True)
+        self._leftGroup.add(self._leftBox)
+        self.widget.insert(self._leftGroup, -1);
+        self._toolbarDelete = Gtk.Button("Delete") #FIXME: Make translatable
+        self._leftBox.pack_start(self._toolbarDelete, True, True, 0);
+        self._toolbarDelete.connect('clicked', self._on_toolbar_delete)
+        self.widget.show_all()
+
+    def _on_toolbar_delete(self, widget):
+        pass
+
+    def change_select_mode(self, mode):
+        if mode:
+            self._fade_in() #TODO implement fading in
+        else:
+            self._fade_out()
+
+    def _fade_in(self):
+        if self.actor.get_opacity() != 0:
+            return
+        else:
+            self.actor.set_opacity(0)
+            self.actor.show()
+            # FIXME: add tween
+            #Tweener.addTween(self.actor,
+            #    { opacity: 255,
+            #      time: 0.30,
+            #      transition: 'easeOutQuad' });
+            self.actor.set_opacity(255)
+            self.actor.show()
+
+    def _fade_out(self):
+        # FIXME: add tween
+        #Tweener.addTween(self.actor,
+        #{ opacity: 0,
+        #  time: 0.30,
+        #  transition: 'easeOutQuad',
+        #  onComplete: function() {
+        #      self.actor.hide();
+        #  },
+        #  onCompleteScope: this });
+        self.actor.set_opacity(0)
+        self.actor.hide()
+
+
+class Embed (GtkClutter.Embed):
+    def __init__(self, notebook):
+        GtkClutter.Embed.__init__(self)
+        self.set_use_layout_size(True)
+
+        self.stage = self.get_stage()
+
+        self._overlayLayout = Clutter.BinLayout()
+        self.actor = Clutter.Box()
+        self.actor.set_layout_manager(self._overlayLayout)
+        constraint = Clutter.BindConstraint()
+        constraint.set_source(self.stage)
+        constraint.set_coordinate(Clutter.BindCoordinate.SIZE)
+        self.actor.add_constraint(constraint)
+        self.stage.add_actor(self.actor)
+
+        self._contentsLayout = Clutter.BoxLayout()
+        self._contentsLayout.set_vertical(True)
+        self._contentsActor = Clutter.Box()
+        self._contentsActor.set_layout_manager(self._contentsLayout)
+        self._overlayLayout.add(self._contentsActor,
+            Clutter.BinAlignment.FILL, Clutter.BinAlignment.FILL)
+
+        # pack the main GtkNotebook and a spinnerbox in a BinLayout, so that
+        # we can easily bring them front/back
+        self._viewLayout = Clutter.BinLayout()
+        self._viewActor = Clutter.Box()
+        self._viewActor.set_layout_manager(self._viewLayout)
+        self._contentsLayout.set_expand(self._viewActor, True)
+        self._contentsLayout.set_fill(self._viewActor, True, True)
+        self._contentsActor.add_actor(self._viewActor)
+
+        self._notebook = notebook
+        self._notebookActor = GtkClutter.Actor.new_with_contents(self._notebook)
+        self._viewLayout.add(self._notebookActor,
+                             Clutter.BinAlignment.FILL,
+                             Clutter.BinAlignment.FILL)
+
+        self._selectionToolbar = SelectionToolbar(self._contentsActor)
+        self._overlayLayout.add(self._selectionToolbar.actor,
+                                Clutter.BinAlignment.FIXED,
+                                Clutter.BinAlignment.FIXED)
+        self.show_all()
+
+    def set_show_selectionbar(show):
+        if show:
+            self._selectionToolbar._fade_in()
+        else:
+            self._selectionToolbar._fade_out()