Merge lp:~gnome-zeitgeist/gnome-activity-journal/new-core into lp:gnome-activity-journal

[Randal Barlow]

=== added file 'data/multiview_icon.png'
 Binary files data/multiview_icon.png	1970-01-01 00:00:00 +0000 and data/multiview_icon.png	2010-05-04 05:28:16 +0000 differ
=== added file 'data/thumbview_icon.png'
 Binary files data/thumbview_icon.png	1970-01-01 00:00:00 +0000 and data/thumbview_icon.png	2010-05-04 05:28:16 +0000 differ
=== added file 'data/timelineview_icon.png'
 Binary files data/timelineview_icon.png	1970-01-01 00:00:00 +0000 and data/timelineview_icon.png	2010-05-04 05:28:16 +0000 differ
=== added file 'src/activityviews.py'
--- src/activityviews.py	1970-01-01 00:00:00 +0000
+++ src/activityviews.py	2010-05-04 05:28:16 +0000
@@ -0,0 +1,1159 @@
+# -.- coding: utf-8 -.-
+#
+# GNOME Activity Journal
+#
+# Copyright © 2009-2010 Seif Lotfy <[e-mail]>
+# Copyright © 2010 Randal Barlow <[e-mail]>
+# Copyright © 2010 Siegfried Gevatter <[e-mail]>
+# Copyright © 2010 Markus Korn <[e-mail]>
+#
+# 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, or
+# (at your option) any later version.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+
+import datetime
+import gobject
+import gst
+import gtk
+import math
+import pango
+import threading
+
+from bookmarker import bookmarker
+from common import *
+import content_objects
+from config import settings
+from sources import SUPPORTED_SOURCES
+from store import ContentStruct, CLIENT
+from supporting_widgets import DayLabel, ContextMenu, StaticPreviewTooltip, VideoPreviewTooltip, Pane
+
+from zeitgeist.datamodel import ResultType, StorageState, TimeRange
+
+
+class _GenericViewWidget(gtk.VBox):
+    day = None
+
+    def __init__(self):
+        gtk.VBox.__init__(self)
+        self.daylabel = DayLabel()
+        self.pack_start(self.daylabel, False, False)
+        self.connect("style-set", self.change_style)
+
+    def set_day(self, day, store):
+        self.store = store
+        if self.day:
+            self.day.disconnect(self.day_signal_id)
+        self.day = day
+        self.day_signal_id = self.day.connect("update", self.update_day)
+        self.update_day(day)
+
+    def update_day(self, day):
+        self.daylabel.set_date(day.date)
+        self.view.set_day(self.day)
+
+    def click(self, widget, event):
+        if event.button in (1, 3):
+            self.emit("unfocus-day")
+
+    def change_style(self, widget, style):
+        rc_style = self.style
+        color = rc_style.bg[gtk.STATE_NORMAL]
+        color = shade_gdk_color(color, 102/100.0)
+        self.view.modify_bg(gtk.STATE_NORMAL, color)
+        self.view.modify_base(gtk.STATE_NORMAL, color)
+
+
+#####################
+## MultiView code
+## This doesnt work, No idea why
+#####################
+
+class MultiViewContainer(gtk.HBox):
+
+    days = []
+    num_pages = 3
+    day_signal_id = [None] * num_pages
+
+    def __init__(self):
+        super(MultiViewContainer, self).__init__()
+        self.pages = []
+        for i in range(self.num_pages):
+            group = DayViewContainer()
+            evbox = gtk.EventBox()
+            evbox.add(group)
+            self.pages.append(group)
+            padding = 6 if i != self.num_pages-1 and i != 0 else 0
+            self.pack_start(evbox, True, True, padding)
+        self.connect("style-set", self.change_style)
+
+    def set_day(self, day, store):
+        if self.days:
+            for i, _day in enumerate(self.__days(self.days[0], store)):
+                signal = self.day_signal_id[i]
+                if signal:
+                    _day.disconnect(signal)
+        self.days = self.__days(day, store)
+        for i, day in enumerate(self.days):
+            self.day_signal_id[i] = day.connect("update", self.update_day)
+        self.update_day()
+
+    def __days(self, day, store):
+        days = []
+        for i in range(self.num_pages):
+            days += [day]
+            day = day.previous(store)
+        return days
+
+    def update_day(self, *args):
+        #print "UPDATED", i, dayobj
+        #if i != None and dayobj:
+        #    print "DO IT"
+        #    return self.pages[i].set_day(dayobj)
+        for page, day in map(None, reversed(self.pages), self.days):
+            page.set_day(day)
+
+    def change_style(self, this, old_style):
+        style = this.style
+        for widget in self:
+            color = style.bg[gtk.STATE_NORMAL]
+            bgcolor = shade_gdk_color(color, 102/100.0)
+            widget.modify_bg(gtk.STATE_NORMAL, bgcolor)
+
+
+
+class DayViewContainer(gtk.VBox):
+    event_templates = (
+        Event.new_for_values(interpretation=Interpretation.VISIT_EVENT.uri),
+        Event.new_for_values(interpretation=Interpretation.MODIFY_EVENT.uri),
+        Event.new_for_values(interpretation=Interpretation.CREATE_EVENT.uri),
+        Event.new_for_values(interpretation=Interpretation.OPEN_EVENT.uri),
+    )
+    # Do day label stuff here please
+    def __init__(self):
+        super(DayViewContainer, self).__init__()
+        self.daylabel = DayLabel()
+        self.pack_start(self.daylabel, False, False)
+        self.dayviews = (DayView(_("Morning")), DayView(_("Afternoon")), DayView(_("Evening")))
+        self.scrolled_window = gtk.ScrolledWindow()
+        self.scrolled_window.set_shadow_type(gtk.SHADOW_NONE)
+        viewport = gtk.Viewport()
+        viewport.set_shadow_type(gtk.SHADOW_NONE)
+        box = gtk.VBox()
+        for dayview in self.dayviews:
+            box.pack_start(dayview, False, False)
+        viewport.add(box)
+        self.scrolled_window.add(viewport)
+
+        self.pack_end(self.scrolled_window, True, True)
+        self.scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
+        self.show_all()
+
+    def set_day(self, day):
+        self.daylabel.set_date(day.date)
+        morning = []
+        afternoon = []
+        evening = []
+        for item in day.filter(self.event_templates, result_type=ResultType.MostRecentSubjects):
+            if not item.content_object:continue
+            t = time.localtime(int(item.event.timestamp)/1000)
+            if t.tm_hour < 11:
+                morning.append(item)
+            elif t.tm_hour < 17:
+                afternoon.append(item)
+            else:
+                evening.append(item)
+        self.dayviews[0].set_items(morning)
+        self.dayviews[1].set_items(afternoon)
+        self.dayviews[2].set_items(evening)
+
+
+class DayView(gtk.VBox):
+
+    def __init__(self, title=""):
+        super(DayView, self).__init__()
+        #self.add(gtk.Button("LOL"))
+        # Create the title label
+        self.label = gtk.Label(title)
+        self.label.set_alignment(0.03, 0.5)
+        self.pack_start(self.label, False, False, 6)
+        # Create the main container
+        self.view = None
+
+        # Connect to relevant signals
+        self.connect("style-set", self.on_style_change)
+        self.show_all()
+        # Populate the widget with content
+
+    def on_style_change(self, widget, style):
+        """ Update used colors according to the system theme. """
+        color = self.style.bg[gtk.STATE_NORMAL]
+        fcolor = self.style.fg[gtk.STATE_NORMAL]
+        color = combine_gdk_color(color, fcolor)
+        self.label.modify_fg(gtk.STATE_NORMAL, color)
+
+    def clear(self):
+        if self.view:
+            self.remove(self.view)
+            self.view.destroy()
+            del self.view
+        self.view = gtk.VBox()
+        self.pack_start(self.view)
+
+    def set_items(self, items):
+        self.clear()
+        categories = {}
+        for struct in items:
+            if not struct.content_object: continue
+            subject = struct.event.subjects[0]
+            if not categories.has_key(subject.interpretation):
+                categories[subject.interpretation] = []
+            categories[subject.interpretation].append(struct)
+        if not categories:
+            self.hide_all()
+        else:
+            ungrouped_events = []
+            for key in sorted(categories.iterkeys()):
+                events = categories[key]
+                if len(events) > 3:
+                    box = CategoryBox(key, list(reversed(events)))
+                    self.view.pack_start(box)
+                else:
+                    ungrouped_events += events
+                box = CategoryBox(None, ungrouped_events)
+                self.view.pack_start(box)
+            self.show_all()
+
+
+class CategoryBox(gtk.HBox):
+
+    def __init__(self, category, event_structs, pinnable = False):
+        super(CategoryBox, self).__init__()
+        self.view = gtk.VBox(True)
+        self.vbox = gtk.VBox()
+        for struct in event_structs:
+            if not struct.content_object:continue
+            item = Item(struct, pinnable)
+            hbox = gtk.HBox ()
+            #label = gtk.Label("")
+            #hbox.pack_start(label, False, False, 7)
+            hbox.pack_start(item, True, True, 0)
+            self.view.pack_start(hbox, False, False, 0)
+            hbox.show_all()
+            #label.show()
+            self.pack_end(hbox)
+
+        # If this isn't a set of ungrouped events, give it a label
+        if category:
+            # Place the items into a box and simulate left padding
+            self.box = gtk.HBox()
+            #label = gtk.Label("")
+            self.box.pack_start(self.view)
+
+            hbox = gtk.HBox()
+            # Add the title button
+            if category in SUPPORTED_SOURCES:
+                text = SUPPORTED_SOURCES[category].group_label(len(event_structs))
+            else:
+                text = "Unknown"
+
+            label = gtk.Label()
+            label.set_markup("<span>%s</span>" % text)
+            #label.set_ellipsize(pango.ELLIPSIZE_END)
+
+            hbox.pack_start(label, True, True, 0)
+
+            label = gtk.Label()
+            label.set_markup("<span>(%d)</span>" % len(event_structs))
+            label.set_alignment(1.0,0.5)
+            label.set_alignment(1.0,0.5)
+            hbox.pack_end(label, False, False, 2)
+
+            hbox.set_border_width(3)
+
+            self.expander = gtk.Expander()
+            self.expander.set_label_widget(hbox)
+
+            self.vbox.pack_start(self.expander, False, False)
+            self.expander.add(self.box)#
+
+            self.pack_start(self.vbox, True, True, 24)
+
+            self.expander.show_all()
+            self.show()
+            hbox.show_all()
+            label.show_all()
+            self.view.show()
+
+        else:
+            self.box = self.view
+            self.vbox.pack_end(self.box)
+            self.box.show()
+            self.show()
+
+            self.pack_start(self.vbox, True, True, 16)
+
+        self.show_all()
+
+    def on_toggle(self, view, bool):
+        if bool:
+            self.box.show()
+        else:
+            self.box.hide()
+        pinbox.show_all()
+
+
+class Item(gtk.HBox):
+
+    def __init__(self, content_struct, allow_pin = False):
+        event = content_struct.event
+        gtk.HBox.__init__(self)
+        self.set_border_width(2)
+        self.allow_pin = allow_pin
+        self.btn = gtk.Button()
+        self.search_results = []
+        self.in_search = False
+        self.subject = event.subjects[0]
+        self.content_obj = content_struct.content_object
+        # self.content_obj = GioFile.create(self.subject.uri)
+        self.time = float(event.timestamp) / 1000
+        self.time =  time.strftime("%H:%M", time.localtime(self.time))
+
+        if self.content_obj is not None:
+            self.icon = self.content_obj.get_icon(
+                can_thumb=settings.get('small_thumbnails', False), border=0)
+        else:
+            self.icon = None
+        self.btn.set_relief(gtk.RELIEF_NONE)
+        self.btn.set_focus_on_click(False)
+        self.__init_widget()
+        self.show_all()
+        self.markup = None
+
+    def __init_widget(self):
+        self.label = gtk.Label()
+        text = self.content_obj.text.replace("&", "&amp;")
+        self.label.set_markup(text)
+        self.label.set_ellipsize(pango.ELLIPSIZE_MIDDLE)
+        self.label.set_alignment(0.0, 0.5)
+
+        if self.icon: img = gtk.image_new_from_pixbuf(self.icon)
+        else: img = None
+        hbox = gtk.HBox()
+        if img: hbox.pack_start(img, False, False, 1)
+        hbox.pack_start(self.label, True, True, 4)
+
+        if self.allow_pin:
+            # TODO: get the name "pin" from theme when icons are properly installed
+            img = gtk.image_new_from_file(get_icon_path("hicolor/24x24/status/pin.png"))
+            self.pin = gtk.Button()
+            self.pin.add(img)
+            self.pin.set_tooltip_text(_("Remove Pin"))
+            self.pin.set_focus_on_click(False)
+            self.pin.set_relief(gtk.RELIEF_NONE)
+            self.pack_end(self.pin, False, False)
+            self.pin.connect("clicked", lambda x: self.set_bookmarked(False))
+        #hbox.pack_end(img, False, False)
+        evbox = gtk.EventBox()
+        self.btn.add(hbox)
+        evbox.add(self.btn)
+        self.pack_start(evbox)
+
+        self.btn.connect("clicked", self.launch)
+        self.btn.connect("button_press_event", self._show_item_popup)
+
+        def realize_cb(widget):
+            evbox.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.HAND2))
+
+        self.btn.connect("realize", realize_cb)
+
+        self.init_multimedia_tooltip()
+
+    def init_multimedia_tooltip(self):
+        """add multimedia tooltip to multimedia files
+        multimedia tooltip is shown for all images, all videos and pdfs
+
+        TODO: make loading of multimedia thumbs async
+        """
+        if isinstance(self.content_obj, GioFile) and self.content_obj.has_preview():
+            icon_names = self.content_obj.icon_names
+            self.set_property("has-tooltip", True)
+            self.connect("query-tooltip", self._handle_tooltip)
+            if "video-x-generic" in icon_names and gst is not None:
+                self.set_tooltip_window(VideoPreviewTooltip)
+            else:
+                self.set_tooltip_window(StaticPreviewTooltip)
+
+    def _handle_tooltip(self, widget, x, y, keyboard_mode, tooltip):
+        # nothing to do here, we always show the multimedia tooltip
+        # if we like video/sound preview later on we can start them here
+        tooltip_window = self.get_tooltip_window()
+        return tooltip_window.preview(self.content_obj)
+
+    def _show_item_popup(self, widget, ev):
+        if ev.button == 3:
+            items = [self.content_obj]
+            ContextMenu.do_popup(ev.time, items)
+
+    def set_bookmarked(self, bool_):
+        uri = unicode(self.subject.uri)
+        if bool_:
+            bookmarker.bookmark(uri)
+        else:
+            bookmarker.unbookmark(uri)
+
+
+    def launch(self, *discard):
+        if self.content_obj is not None:
+            self.content_obj.launch()
+
+
+#####################
+## ThumbView code
+#####################
+class ThumbViewContainer(_GenericViewWidget):
+    day_signal_id = None
+
+    def __init__(self):
+        _GenericViewWidget.__init__(self)
+        self.scrolledwindow = gtk.ScrolledWindow()
+        self.scrolledwindow.set_shadow_type(gtk.SHADOW_NONE)
+        self.scrolledwindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
+        self.view = ThumbView()
+        self.scrolledwindow.add_with_viewport(self.view)
+        self.scrolledwindow.get_children()[0].set_shadow_type(gtk.SHADOW_NONE)
+        self.pack_end(self.scrolledwindow)
+        self.show_all()
+
+
+class _ThumbViewRenderer(gtk.GenericCellRenderer):
+    """
+    A IconView renderer to be added to a cellayout. It displays a pixbuf and
+    data based on the event property
+    """
+
+    __gtype_name__ = "_ThumbViewRenderer"
+    __gproperties__ = {
+        "content_obj" :
+        (gobject.TYPE_PYOBJECT,
+         "event to be displayed",
+         "event to be displayed",
+         gobject.PARAM_READWRITE,
+         ),
+    }
+
+    width = 96
+    height = 72
+    properties = {}
+
+    @property
+    def content_obj(self):
+        return self.get_property("content_obj")
+
+    @property
+    def emblems(self):
+        return self.content_obj.emblems
+
+    @property
+    def pixbuf(self):
+        return self.content_obj.thumbview_pixbuf
+
+    @property
+    def event(self):
+        return self.content_obj.event
+
+    def __init__(self):
+        super(_ThumbViewRenderer, self).__init__()
+        self.properties = {}
+        self.set_fixed_size(self.width, self.height)
+        self.set_property("mode", gtk.CELL_RENDERER_MODE_ACTIVATABLE)
+
+    def do_set_property(self, pspec, value):
+        self.properties[pspec.name] = value
+
+    def do_get_property(self, pspec):
+        return self.properties[pspec.name]
+
+    def on_get_size(self, widget, area):
+        if area:
+            #return (area.x, area.y, area.width, area.height)
+            return (0, 0, area.width, area.height)
+        return (0,0,0,0)
+
+    def on_render(self, window, widget, background_area, cell_area, expose_area, flags):
+        """
+        The primary rendering function. It calls either the classes rendering functions
+        or special one defined in the rendering_functions dict
+        """
+        x = cell_area.x
+        y = cell_area.y
+        w = cell_area.width
+        h = cell_area.height
+        pixbuf_w = self.pixbuf.get_width() if self.pixbuf else 0
+        pixbuf_h = self.pixbuf.get_height() if self.pixbuf else 0
+        if (pixbuf_w, pixbuf_h) == content_objects.SIZE_THUMBVIEW:
+            render_pixbuf(window, x, y, self.pixbuf)
+        else:
+            self.file_render_pixbuf(window, widget, x, y, w, h)
+        render_emblems(window, x, y, w, h, self.emblems)
+        path = widget.get_path_at_pos(cell_area.x, cell_area.y)
+        if path != None:
+            try:
+                if widget.active_list[path[0]]:
+                    gobject.timeout_add(2, self.render_info_box, window, widget, cell_area, expose_area, self.event)
+            except:pass
+        return True
+
+    @staticmethod
+    def insert_file_markup(text):
+        text = text.replace("&", "&amp;")
+        text = "<span size='6400'>" + text + "</span>"
+        return text
+
+    def file_render_pixbuf(self, window, widget, x, y, w, h):
+        """
+        Renders a icon and file name for non-thumb objects
+        """
+        context = window.cairo_create()
+        pixbuf = self.pixbuf
+        if pixbuf:
+            imgw, imgh = pixbuf.get_width(), pixbuf.get_height()
+            ix = x + (self.width - imgw)
+            iy = y + self.height - imgh
+        context.rectangle(x, y, w, h)
+        context.set_source_rgb(1, 1, 1)
+        context.fill_preserve()
+        if pixbuf:
+            context.set_source_pixbuf(pixbuf, ix, iy)
+            context.fill()
+        draw_frame(context, x, y, w, h)
+        context = window.cairo_create()
+        text = self.insert_file_markup(self.content_obj.thumbview_text)
+
+        layout = widget.create_pango_layout(text)
+        draw_text(context, layout, text, x+5, y+5, self.width-10)
+
+    @staticmethod
+    def render_info_box(window, widget, cell_area, expose_area, event):
+        """
+        Renders a info box when the item is active
+        """
+        x = cell_area.x
+        y = cell_area.y - 10
+        w = cell_area.width
+        h = cell_area.height
+        context = window.cairo_create()
+        t0 = get_event_typename(event)
+        t1 = event.subjects[0].text
+        text = ("<span size='10240'>%s</span>\n<span size='8192'>%s</span>" % (t0, t1)).replace("&", "&amp;")
+        layout = widget.create_pango_layout(text)
+        layout.set_markup(text)
+        textw, texth = layout.get_pixel_size()
+        popuph = max(h/3 + 5, texth)
+        nw = w + 26
+        x = x - (nw - w)/2
+        width, height = window.get_geometry()[2:4]
+        popupy = min(y+h+10, height-popuph-5-1) - 5
+        draw_speech_bubble(context, layout, x, popupy, nw, popuph)
+        context.fill()
+        return False
+
+    def on_start_editing(self, event, widget, path, background_area, cell_area, flags):
+        pass
+
+    def on_activate(self, event, widget, path, background_area, cell_area, flags):
+        self.content_obj.launch()
+        return True
+
+
+class ThumbIconView(gtk.IconView):
+    """
+    A iconview which uses a custom cellrenderer to render square pixbufs
+    based on zeitgeist events
+    """
+    last_active = -1
+    child_width = _ThumbViewRenderer.width
+    child_height = _ThumbViewRenderer.height
+    def __init__(self):
+        super(ThumbIconView, self).__init__()
+        self.active_list = []
+        self.popupmenu = ContextMenu
+        self.add_events(gtk.gdk.LEAVE_NOTIFY_MASK)
+        self.connect("button-press-event", self.on_button_press)
+        self.connect("motion-notify-event", self.on_motion_notify)
+        self.connect("leave-notify-event", self.on_leave_notify)
+        self.set_selection_mode(gtk.SELECTION_NONE)
+        self.set_column_spacing(6)
+        self.set_row_spacing(6)
+        pcolumn = gtk.TreeViewColumn("Preview")
+        render = _ThumbViewRenderer()
+        self.pack_end(render)
+        self.add_attribute(render, "content_obj", 0)
+        self.set_margin(10)
+
+    def _set_model_in_thread(self, items):
+        """
+        A threaded which generates pixbufs and emblems for a list of events.
+        It takes those properties and appends them to the view's model
+        """
+        lock = threading.Lock()
+        self.active_list = []
+        liststore = gtk.ListStore(gobject.TYPE_PYOBJECT)
+        gtk.gdk.threads_enter()
+        self.set_model(liststore)
+        gtk.gdk.threads_leave()
+
+        for item in items:
+            obj = item.content_object
+            if not obj: continue
+            gtk.gdk.threads_enter()
+            lock.acquire()
+            self.active_list.append(False)
+            liststore.append((obj,))
+            lock.release()
+            gtk.gdk.threads_leave()
+
+    def set_model_from_list(self, items):
+        """
+        Sets creates/sets a model from a list of zeitgeist events
+        :param events: a list of :class:`Events <zeitgeist.datamodel.Event>`
+        """
+        self.last_active = -1
+        if not items:
+            self.set_model(None)
+            return
+        thread = threading.Thread(target=self._set_model_in_thread, args=(items,))
+        thread.start()
+
+    def on_button_press(self, widget, event):
+        if event.button == 3:
+            val = self.get_item_at_pos(int(event.x), int(event.y))
+            if val:
+                path, cell = val
+                model = self.get_model()
+                obj = model[path[0]][0]
+                self.popupmenu.do_popup(event.time, [obj])
+        return False
+
+    def on_leave_notify(self, widget, event):
+        try:
+            self.active_list[self.last_active] = False
+        except IndexError:pass
+        self.last_active = -1
+        self.queue_draw()
+
+    def on_motion_notify(self, widget, event):
+        val = self.get_item_at_pos(int(event.x), int(event.y))
+        if val:
+            path, cell = val
+            if path[0] != self.last_active:
+                self.active_list[self.last_active] = False
+                self.active_list[path[0]] = True
+                self.last_active = path[0]
+                self.queue_draw()
+        return True
+
+    def query_tooltip(self, widget, x, y, keyboard_mode, tooltip):
+        """
+        Displays a tooltip based on x, y
+        """
+        path = self.get_path_at_pos(int(x), int(y))
+        if path:
+            model = self.get_model()
+            uri = model[path[0]][3].uri
+            interpretation = model[path[0]][3].subjects[0].interpretation
+            tooltip_window = widget.get_tooltip_window()
+            if interpretation == Interpretation.VIDEO.uri:
+                self.set_tooltip_window(VideoPreviewTooltip)
+            else:
+                self.set_tooltip_window(StaticPreviewTooltip)
+            gio_file = GioFile.create(uri)
+            return tooltip_window.preview(gio_file)
+        return False
+
+
+class ThumbView(gtk.VBox):
+    """
+    A container for three image views representing periods in time
+    """
+    event_templates = (
+            Event.new_for_values(interpretation=Interpretation.VISIT_EVENT.uri),
+            Event.new_for_values(interpretation=Interpretation.MODIFY_EVENT.uri),
+            Event.new_for_values(interpretation=Interpretation.CREATE_EVENT.uri),
+            Event.new_for_values(interpretation=Interpretation.OPEN_EVENT.uri),
+        )
+    def __init__(self):
+        """Woo"""
+        gtk.VBox.__init__(self)
+        self.views = [ThumbIconView() for x in xrange(3)]
+        self.labels = [gtk.Label() for x in xrange(3)]
+        for i in xrange(3):
+            text = TIMELABELS[i]
+            line = 50 - len(text)
+            self.labels[i].set_markup(
+                "\n  <span size='10336'>%s <s>%s</s></span>" % (text, " "*line))
+            self.labels[i].set_justify(gtk.JUSTIFY_RIGHT)
+            self.labels[i].set_alignment(0, 0)
+            self.pack_start(self.labels[i], False, False)
+            self.pack_start(self.views[i], False, False)
+        self.connect("style-set", self.change_style)
+
+    def set_phase_items(self, i, items):
+        """
+        Set a time phases events
+
+        :param i: a index for the three items in self.views. 0:Morning,1:AfterNoon,2:Evening
+        :param events: a list of :class:`Events <zeitgeist.datamodel.Event>`
+        """
+        view = self.views[i]
+        label = self.labels[i]
+        if not items or len(items) == 0:
+            view.set_model_from_list(None)
+            return False
+        view.show_all()
+        label.show_all()
+        view.set_model_from_list(items)
+
+        if len(items) == 0:
+            view.hide_all()
+            label.hide_all()
+
+    def set_day(self, day):
+        morning = []
+        afternoon = []
+        evening = []
+        for item in day.filter(self.event_templates, result_type=ResultType.MostRecentSubjects):
+            #if not item.content_object:continue
+            t = time.localtime(int(item.event.timestamp)/1000)
+            if t.tm_hour < 11:
+                morning.append(item)
+            elif t.tm_hour < 17:
+                afternoon.append(item)
+            else:
+                evening.append(item)
+        self.set_phase_items(0, morning)
+        self.set_phase_items(1, afternoon)
+        self.set_phase_items(2, evening)
+
+    def change_style(self, widget, style):
+        rc_style = self.style
+        parent = self.get_parent()
+        if parent:
+            parent = self.get_parent()
+        color = rc_style.bg[gtk.STATE_NORMAL]
+        parent.modify_bg(gtk.STATE_NORMAL, color)
+        for view in self.views: view.modify_base(gtk.STATE_NORMAL, color)
+        color = rc_style.text[4]
+        color = shade_gdk_color(color, 0.95)
+        for label in self.labels:
+            label.modify_fg(0, color)
+
+################
+## TimelineView
+################
+class TimelineViewContainer(_GenericViewWidget):
+
+    def __init__(self):
+        _GenericViewWidget.__init__(self)
+        self.ruler = _TimelineHeader()
+        self.scrolledwindow = gtk.ScrolledWindow()
+        self.scrolledwindow.set_shadow_type(gtk.SHADOW_NONE)
+        self.scrolledwindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
+        self.view = TimelineView()
+        self.scrolledwindow.add(self.view)
+        self.pack_end(self.scrolledwindow)
+        self.pack_end(self.ruler, False, False)
+        self.view.set_events(gtk.gdk.POINTER_MOTION_MASK | gtk.gdk.POINTER_MOTION_HINT_MASK)
+
+    def change_style(self, widget, style):
+        _GenericViewWidget.change_style(self, widget, style)
+        rc_style = self.style
+        color = rc_style.bg[gtk.STATE_NORMAL]
+        color = shade_gdk_color(color, 102/100.0)
+        self.ruler.modify_bg(gtk.STATE_NORMAL, color)
+
+
+
+
+class _TimelineRenderer(gtk.GenericCellRenderer):
+    """
+    Renders timeline columns, and text for a for properties
+    """
+
+    __gtype_name__ = "TimelineRenderer"
+    __gproperties__ = {
+        "content_obj" :
+        (gobject.TYPE_PYOBJECT,
+         "event to be displayed",
+         "event to be displayed",
+         gobject.PARAM_READWRITE,
+         ),
+    }
+
+    width = 32
+    height = 48
+    barsize = 5
+    properties = {}
+
+    textcolor = {gtk.STATE_NORMAL : ("#ff", "#ff"),
+                 gtk.STATE_SELECTED : ("#ff", "#ff")}
+
+    @property
+    def content_obj(self):
+        return self.get_property("content_obj")
+
+    @property
+    def phases(self):
+        return self.content_obj.phases
+
+    @property
+    def event(self):
+        return self.content_obj.event
+
+    @property
+    def colors(self):
+        """ A tuple of two colors, the first being the base the outer being the outline"""
+        return self.content_obj.type_color_representation
+
+    @property
+    def text(self):
+        return self.content_obj.timelineview_text
+
+    @property
+    def pixbuf(self):
+        return self.content_obj.timelineview_pixbuf
+
+    def __init__(self):
+        super(_TimelineRenderer, self).__init__()
+        self.properties = {}
+        self.set_fixed_size(self.width, self.height)
+        self.set_property("mode", gtk.CELL_RENDERER_MODE_ACTIVATABLE)
+
+    def do_set_property(self, pspec, value):
+        self.properties[pspec.name] = value
+
+    def do_get_property(self, pspec):
+        return self.properties[pspec.name]
+
+    def on_get_size(self, widget, area):
+        if area:
+            return (0, 0, area.width, area.height)
+        return (0,0,0,0)
+
+    def on_render(self, window, widget, background_area, cell_area, expose_area, flags):
+        """
+        The primary rendering function. It calls either the classes rendering functions
+        or special one defined in the rendering_functions dict
+        """
+        x = int(cell_area.x)
+        y = int(cell_area.y)
+        w = int(cell_area.width)
+        h = int(cell_area.height)
+        self.render_phases(window, widget, x, y, w, h, flags)
+        return True
+
+    def render_phases(self, window, widget, x, y, w, h, flags):
+        context = window.cairo_create()
+        phases = self.phases
+        for start, end in phases:
+            context.set_source_rgb(*self.colors[0])
+            start = int(start * w)
+            end = max(int(end * w), 8)
+            if start + 8 > w:
+                start = w - 8
+            context.rectangle(x+ start, y, end, self.barsize)
+            context.fill()
+            context.set_source_rgb(*self.colors[1])
+            context.set_line_width(1)
+            context.rectangle(x + start+0.5, y+0.5, end, self.barsize)
+            context.stroke()
+        x = int(phases[0][0]*w)
+        # Pixbuf related junk which is really dirty
+        self.render_text_with_pixbuf(window, widget, x, y, w, h, flags)
+        return True
+
+    def render_text_with_pixbuf(self, window, widget, x, y, w, h, flags):
+        uri = self.content_obj.uri
+        imgw, imgh = self.pixbuf.get_width(), self.pixbuf.get_height()
+        x = max(x + imgw/2 + 4, 0 + imgw + 4)
+        x, y = self.render_text(window, widget, x, y, w, h, flags)
+        x -= imgw + 4
+        y += self.barsize + 3
+        pixbuf_w = self.pixbuf.get_width() if self.pixbuf else 0
+        pixbuf_h = self.pixbuf.get_height() if self.pixbuf else 0
+        if (pixbuf_w, pixbuf_h) == content_objects.SIZE_TIMELINEVIEW:
+            drawframe = True
+        else: drawframe = False
+        render_pixbuf(window, x, y, self.pixbuf, drawframe=drawframe)
+
+    def render_text(self, window, widget, x, y, w, h, flags):
+        w = window.get_geometry()[2]
+        y+= 2
+        x += 5
+        state = gtk.STATE_SELECTED if gtk.CELL_RENDERER_SELECTED & flags else gtk.STATE_NORMAL
+        color1, color2 = self.textcolor[state]
+        text = self._make_timelineview_text(self.text)
+        text = text % (color1.to_string(), color2.to_string())
+        layout = widget.create_pango_layout("")
+        layout.set_markup(text)
+        textw, texth = layout.get_pixel_size()
+        if textw + x > w:
+            layout.set_ellipsize(pango.ELLIPSIZE_MIDDLE)
+            layout.set_width(200*1024)
+            textw, texth = layout.get_pixel_size()
+            if x + textw > w:
+                x = w - textw
+        context = window.cairo_create()
+        pcontext = pangocairo.CairoContext(context)
+        pcontext.set_source_rgb(0, 0, 0)
+        pcontext.move_to(x, y + self.barsize)
+        pcontext.show_layout(layout)
+        return x, y
+
+    @staticmethod
+    def _make_timelineview_text(text):
+        """
+        :returns: a string of text markup used in timeline widget and elsewhere
+        """
+        text = text.split("\n")
+        if len(text) > 1:
+            p1 = text[0]
+            p2 = text[1]
+        else:
+            p1 = text[0]
+            p2 = " "
+        t1 = "<span color='%s'><b>" + p1 + "</b></span>"
+        t2 = "<span color='%s'>" + p2 + "</span> "
+        return (str(t1) + "\n" + str(t2) + "").replace("&", "&amp;")
+
+    def on_start_editing(self, event, widget, path, background_area, cell_area, flags):
+        pass
+
+    def on_activate(self, event, widget, path, background_area, cell_area, flags):
+        pass
+
+
+class TimelineView(gtk.TreeView):
+    @staticmethod
+    def make_area_from_event(timestamp, duration):
+        """
+        Generates a time box based on a objects timestamp and duration over 1.
+        Multiply the results by the width to get usable positions
+
+        :param timestamp: a timestamp int or string from which to calulate the start position
+        :param duration: the length to calulate the width
+        """
+        w = max(duration/3600.0/1000.0/24.0, 0)
+        x = ((int(timestamp)/1000.0 - time.timezone)%86400)/3600/24.0
+        return [x, w]
+
+    child_width = _TimelineRenderer.width
+    child_height = _TimelineRenderer.height
+
+    def __init__(self):
+        super(TimelineView, self).__init__()
+        self.popupmenu = ContextMenu
+        self.add_events(gtk.gdk.LEAVE_NOTIFY_MASK)
+        self.connect("button-press-event", self.on_button_press)
+        # self.connect("motion-notify-event", self.on_motion_notify)
+        # self.connect("leave-notify-event", self.on_leave_notify)
+        self.connect("row-activated" , self.on_activate)
+        self.connect("style-set", self.change_style)
+        pcolumn = gtk.TreeViewColumn("Timeline")
+        self.render = render = _TimelineRenderer()
+        pcolumn.pack_start(render)
+        self.append_column(pcolumn)
+        pcolumn.add_attribute(render, "content_obj", 0)
+        self.set_headers_visible(False)
+        self.set_property("has-tooltip", True)
+        self.set_tooltip_window(StaticPreviewTooltip)
+
+
+    def set_model_from_list(self, items):
+        """
+        Sets creates/sets a model from a list of zeitgeist events
+
+        :param events: a list of :class:`Events <zeitgeist.datamodel.Event>`
+        """
+        if not items:
+            self.set_model(None)
+            return
+        liststore = gtk.ListStore(gobject.TYPE_PYOBJECT)
+        for row in items:
+            item = row[0][0]
+            obj = item.content_object
+            if not obj: continue
+            obj.phases = [self.make_area_from_event(item.event.timestamp, stop) for (item, stop) in row]
+            obj.phases.sort(key=lambda x: x[0])
+            liststore.append((obj,))
+        self.set_model(liststore)
+
+    def set_day(self, day):
+        items = day.get_time_map()
+        self.set_model_from_list(items)
+
+    def on_button_press(self, widget, event):
+        if event.button == 3:
+            path = self.get_dest_row_at_pos(int(event.x), int(event.y))
+            if path:
+                model = self.get_model()
+                obj = model[path[0]][0]
+                self.popupmenu.do_popup(event.time, [obj])
+                return True
+        return False
+
+    def on_leave_notify(self, widget, event):
+        return True
+
+    def on_motion_notify(self, widget, event):
+        return True
+
+    def on_activate(self, widget, path, column):
+        model = self.get_model()
+        model[path][0].launch()
+
+    def change_style(self, widget, old_style):
+        """
+        Sets the widgets style and coloring
+        """
+        layout = self.create_pango_layout("")
+        layout.set_markup("<b>qPqPqP|</b>\nqPqPqP|")
+        tw, th = layout.get_pixel_size()
+        self.render.height = max(_TimelineRenderer.height, th + 3 + _TimelineRenderer.barsize)
+        if self.window:
+            width = self.window.get_geometry()[2] - 4
+            self.render.width = max(_TimelineRenderer.width, width)
+        self.render.set_fixed_size(self.render.width, self.render.height)
+        def change_color(color, inc):
+            color = shade_gdk_color(color, inc/100.0)
+            return color
+        normal = (self.style.text[gtk.STATE_NORMAL], change_color(self.style.text[gtk.STATE_INSENSITIVE], 70))
+        selected = (self.style.text[gtk.STATE_SELECTED], self.style.text[gtk.STATE_SELECTED])
+        self.render.textcolor[gtk.STATE_NORMAL] = normal
+        self.render.textcolor[gtk.STATE_SELECTED] = selected
+
+
+class _TimelineHeader(gtk.DrawingArea):
+    time_text = {4:"4:00", 8:"8:00", 12:"12:00", 16:"16:00", 20:"20:00"}
+    odd_line_height = 6
+    even_line_height = 12
+
+    line_color = (0, 0, 0, 1)
+    def __init__(self):
+        super(_TimelineHeader, self).__init__()
+        self.connect("expose-event", self.expose)
+        self.connect("style-set", self.change_style)
+        self.set_size_request(100, 12)
+
+    def expose(self, widget, event):
+        window = widget.window
+        context = widget.window.cairo_create()
+        layout = self.create_pango_layout("   ")
+        width = event.area.width
+        widget.style.set_background(window, gtk.STATE_NORMAL)
+        context.set_source_rgba(*self.line_color)
+        context.set_line_width(2)
+        self.draw_lines(window, context, layout, width)
+
+    def draw_text(self, window, context, layout, x, text):
+        x = int(x)
+        color = self.style.text[gtk.STATE_NORMAL]
+        markup = "<span color='%s'>%s</span>" % (color.to_string(), text)
+        pcontext = pangocairo.CairoContext(context)
+        layout.set_markup(markup)
+        xs, ys = layout.get_pixel_size()
+        pcontext.move_to(x - xs/2, 0)
+        pcontext.show_layout(layout)
+
+    def draw_line(self, window, context, x, even):
+        x = int(x)+0.5
+        height = self.even_line_height if even else self.odd_line_height
+        context.move_to(x, 0)
+        context.line_to(x, height)
+        context.stroke()
+
+    def draw_lines(self, window, context, layout, width):
+        xinc = width/24
+        for hour in xrange(1, 24):
+            if self.time_text.has_key(hour):
+                self.draw_text(window, context, layout, xinc*hour, self.time_text[hour])
+            else:
+                self.draw_line(window, context, xinc*hour, bool(hour % 2))
+
+    def change_style(self, widget, old_style):
+        layout = self.create_pango_layout("")
+        layout.set_markup("<b>qPqPqP|</b>")
+        tw, th = layout.get_pixel_size()
+        self.set_size_request(tw*5, th+4)
+        self.line_color = get_gtk_rgba(widget.style, "bg", 0, 0.94)
+
+##
+# Pinned Pane
+
+class PinBox(DayView):
+
+    def __init__(self):
+        # Setup event criteria for querying
+        self.event_timerange = TimeRange.until_now()
+        # Initialize the widget
+        super(PinBox, self).__init__(_("Pinned items"))
+        # Connect to relevant signals
+        bookmarker.connect("reload", self.set_from_templates)
+        self.set_from_templates()
+
+    @property
+    def event_templates(self):
+        if not bookmarker.bookmarks:
+            # Abort, or we will query with no templates and get lots of
+            # irrelevant events.
+            return None
+
+        templates = []
+        for bookmark in bookmarker.bookmarks:
+            templates.append(Event.new_for_values(subject_uri=bookmark))
+        return templates
+
+    def set_from_templates(self, *args, **kwargs):
+        if bookmarker.bookmarks:
+            CLIENT.find_event_ids_for_templates(self.event_templates, self.do_set,
+                                            self.event_timerange,
+                                            StorageState.Any, 10000, ResultType.MostRecentSubjects)
+
+    def do_set(self, event_ids):
+        objs = []
+        for id_ in event_ids:
+            objs += [ContentStruct(id_)]
+        self.set_items(objs)
+        # Make the pin icons visible
+        self.view.show_all()
+        self.show_all()
+
+    def set_items(self, items):
+        self.clear()
+        box = CategoryBox(None, items, True)
+        self.view.pack_start(box)
+
+
+class PinnedPane(Pane):
+    def __init__(self):
+        super(PinnedPane, self).__init__()
+        vbox = gtk.VBox()
+        self.pinbox = PinBox()
+        vbox.pack_start(self.pinbox, False, False)
+        self.add(vbox)
+        self.set_size_request(200, -1)
+        self.set_label_align(1,0)
+
+
+## gobject registration
+gobject.type_register(_TimelineRenderer)
+gobject.type_register(_ThumbViewRenderer)
+
 
=== added file 'src/common.py'
--- src/common.py	1970-01-01 00:00:00 +0000
+++ src/common.py	2010-05-04 05:28:16 +0000
@@ -0,0 +1,582 @@
+# -.- coding: utf-8 -.-
+#
+# Filename
+#
+# Copyright © 2010 Randal Barlow <[e-mail]>
+# Copyright © 2010 Siegfried Gevatter <[e-mail]>
+#
+# 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, or
+# (at your option) any later version.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+
+"""
+Common Functions and classes which are used to create the alternative views,
+and handle colors, pixbufs, and text
+"""
+
+import cairo
+import gobject
+import gtk
+import os
+import pango
+import pangocairo
+import time
+import math
+import operator
+import subprocess
+
+from gio_file import GioFile, SIZE_LARGE, SIZE_NORMAL, SIZE_THUMBVIEW, SIZE_TIMELINEVIEW, ICONS
+from config import get_data_path, get_icon_path
+
+from zeitgeist.datamodel import Interpretation, Event
+
+
+# Caches desktop files
+DESKTOP_FILES = {}
+DESKTOP_FILE_PATHS = []
+try:
+    desktop_file_paths = os.environ["XDG_DATA_DIRS"].split(":")
+    for path in desktop_file_paths:
+        if path.endswith("/"):
+            DESKTOP_FILE_PATHS.append(path + "applications/")
+        else:
+            DESKTOP_FILE_PATHS.append(path + "/applications/")
+except KeyError:pass
+
+# Placeholder pixbufs for common sizes
+PLACEHOLDER_PIXBUFFS = {
+    24 : gtk.gdk.pixbuf_new_from_file_at_size(get_icon_path("hicolor/scalable/apps/gnome-activity-journal.svg"), 24, 24),
+    16 : gtk.gdk.pixbuf_new_from_file_at_size(get_icon_path("hicolor/scalable/apps/gnome-activity-journal.svg"), 16, 16)
+    }
+
+# Color magic
+TANGOCOLORS = [
+    (252/255.0, 234/255.0,  79/255.0),#0
+    (237/255.0, 212/255.0,   0/255.0),
+    (196/255.0, 160/255.0,   0/255.0),
+
+    (252/255.0, 175/255.0,  62/255.0),#3
+    (245/255.0, 121/255.0,   0/255.0),
+    (206/255.0,  92/255.0,   0/255.0),
+
+    (233/255.0, 185/255.0, 110/255.0),#6
+    (193/255.0, 125/255.0,  17/255.0),
+    (143/255.0,  89/255.0,  02/255.0),
+
+    (138/255.0, 226/255.0,  52/255.0),#9
+    (115/255.0, 210/255.0,  22/255.0),
+    ( 78/255.0, 154/255.0,  06/255.0),
+
+    (114/255.0, 159/255.0, 207/255.0),#12
+    ( 52/255.0, 101/255.0, 164/255.0),
+    ( 32/255.0,  74/255.0, 135/255.0),
+
+    (173/255.0, 127/255.0, 168/255.0),#15
+    (117/255.0,  80/255.0, 123/255.0),
+    ( 92/255.0,  53/255.0, 102/255.0),
+
+    (239/255.0,  41/255.0,  41/255.0),#18
+    (204/255.0,   0/255.0,   0/255.0),
+    (164/255.0,   0/255.0,   0/255.0),
+
+    (136/255.0, 138/255.0, 133/255.0),#21
+    ( 85/255.0,  87/255.0,  83/255.0),
+    ( 46/255.0,  52/255.0,  54/255.0),
+]
+
+FILETYPES = {
+    Interpretation.VIDEO.uri : 0,
+    Interpretation.MUSIC.uri : 3,
+    Interpretation.DOCUMENT.uri : 12,
+    Interpretation.IMAGE.uri : 15,
+    Interpretation.SOURCECODE.uri : 12,
+    Interpretation.UNKNOWN.uri : 21,
+    Interpretation.IM_MESSAGE.uri : 21,
+    Interpretation.EMAIL.uri : 21
+}
+
+FILETYPESNAMES = {
+    Interpretation.VIDEO.uri : _("Video"),
+    Interpretation.MUSIC.uri : _("Music"),
+    Interpretation.DOCUMENT.uri : _("Document"),
+    Interpretation.IMAGE.uri : _("Image"),
+    Interpretation.SOURCECODE.uri : _("Source Code"),
+    Interpretation.UNKNOWN.uri : _("Unknown"),
+    Interpretation.IM_MESSAGE.uri : _("IM Message"),
+    Interpretation.EMAIL.uri :_("Email"),
+
+}
+
+MEDIAINTERPRETATIONS = [
+    Interpretation.VIDEO.uri,
+    Interpretation.IMAGE.uri,
+]
+
+TIMELABELS = [_("Morning"), _("Afternoon"), _("Evening")]
+ICON_THEME = gtk.icon_theme_get_default()
+
+def get_file_color(ftype, fmime):
+    """Uses hashing to choose a shade from a hue in the color tuple above
+
+    :param ftype: a :class:`Event <zeitgeist.datamodel.Interpretation>`
+    :param fmime: a mime type string
+    """
+    if ftype in FILETYPES.keys():
+        i = FILETYPES[ftype]
+        l = int(math.fabs(hash(fmime))) % 3
+        return TANGOCOLORS[min(i+l, len(TANGOCOLORS)-1)]
+    return (136/255.0, 138/255.0, 133/255.0)
+
+##
+## Zeitgeist event helper functions
+
+def get_event_typename(event):
+    """
+    :param event: a :class:`Event <zeitgeist.datamodel.Event>`
+
+    :returns: a plain text version of a interpretation
+    """
+    try:
+        return Interpretation[event.subjects[0].interpretation].display_name
+    except KeyError:
+        pass
+    return FILETYPESNAMES[event.subjects[0].interpretation]
+
+##
+# Cairo drawing functions
+
+def draw_frame(context, x, y, w, h):
+    """
+    Draws a 2 pixel frame around a area defined by x, y, w, h using a cairo context
+
+    :param context: a cairo context
+    :param x: x position of the frame
+    :param y: y position of the frame
+    :param w: width of the frame
+    :param h: height of the frame
+    """
+    x, y = int(x)+0.5, int(y)+0.5
+    w, h = int(w), int(h)
+    context.set_line_width(1)
+    context.rectangle(x-1, y-1, w+2, h+2)
+    context.set_source_rgba(0.5, 0.5, 0.5)#0.3, 0.3, 0.3)
+    context.stroke()
+    context.set_source_rgba(0.7, 0.7, 0.7)
+    context.rectangle(x, y, w, h)
+    context.stroke()
+    context.set_source_rgba(0.4, 0.4, 0.4)
+    context.rectangle(x+1, y+1, w-2, h-2)
+    context.stroke()
+
+def draw_rounded_rectangle(context, x, y, w, h, r=5):
+    """Draws a rounded rectangle
+
+    :param context: a cairo context
+    :param x: x position of the rectangle
+    :param y: y position of the rectangle
+    :param w: width of the rectangle
+    :param h: height of the rectangle
+    :param r: radius of the rectangle
+    """
+    context.new_sub_path()
+    context.arc(r+x, r+y, r, math.pi, 3 * math.pi /2)
+    context.arc(w-r+x, r+y, r, 3 * math.pi / 2, 0)
+    context.arc(w-r+x, h-r+y, r, 0, math.pi/2)
+    context.arc(r+x, h-r+y, r, math.pi/2, math.pi)
+    context.close_path()
+    return context
+
+def draw_speech_bubble(context, layout, x, y, w, h):
+    """
+    Draw a speech bubble at a position
+
+    Arguments:
+    :param context: a cairo context
+    :param layout: a pango layout
+    :param x: x position of the bubble
+    :param y: y position of the bubble
+    :param w: width of the bubble
+    :param h: height of the bubble
+    """
+    layout.set_width((w-10)*1024)
+    layout.set_ellipsize(pango.ELLIPSIZE_MIDDLE)
+    textw, texth = layout.get_pixel_size()
+    context.new_path()
+    context.move_to(x + 0.45*w, y+h*0.1 + 2)
+    context.line_to(x + 0.5*w, y)
+    context.line_to(x + 0.55*w, y+h*0.1 + 2)
+    h = max(texth + 5, h)
+    draw_rounded_rectangle(context, x, y+h*0.1, w, h, r = 5)
+    context.close_path()
+    context.set_line_width(2)
+    context.set_source_rgb(168/255.0, 165/255.0, 134/255.0)
+    context.stroke_preserve()
+    context.set_source_rgb(253/255.0, 248/255.0, 202/255.0)
+    context.fill()
+    pcontext = pangocairo.CairoContext(context)
+    pcontext.set_source_rgb(0, 0, 0)
+    pcontext.move_to(x+5, y+5)
+    pcontext.show_layout(layout)
+
+def draw_text(context, layout, markup, x, y, maxw = 0, color = (0.3, 0.3, 0.3)):
+    """
+    Draw text using a cairo context and a pango layout
+
+    Arguments:
+    :param context: a cairo context
+    :param layout: a pango layout
+    :param x: x position of the bubble
+    :param y: y position of the bubble
+    :param maxw: the max text width in pixels
+    :param color: a rgb tuple
+    """
+    pcontext = pangocairo.CairoContext(context)
+    layout.set_markup(markup)
+    layout.set_ellipsize(pango.ELLIPSIZE_MIDDLE)
+    pcontext.set_source_rgba(*color)
+    if maxw:
+        layout.set_width(maxw*1024)
+    pcontext.move_to(x, y)
+    pcontext.show_layout(layout)
+
+def render_pixbuf(window, x, y, pixbuf, drawframe = True):
+    """
+    Renders a pixbuf to be displayed on the cell
+
+    Arguments:
+    :param window: a gdk window
+    :param x: x position
+    :param y: y position
+    :param drawframe: if true we draw a frame around the pixbuf
+    """
+    imgw, imgh = pixbuf.get_width(), pixbuf.get_height()
+    context = window.cairo_create()
+    context.rectangle(x, y, imgw, imgh)
+    if drawframe:
+        context.set_source_rgb(1, 1, 1)
+        context.fill_preserve()
+    context.set_source_pixbuf(pixbuf, x, y)
+    context.fill()
+    if drawframe: # Draw a pretty frame
+        draw_frame(context, x, y, imgw, imgh)
+
+def render_emblems(window, x, y, w, h, emblems):
+    """
+    Renders emblems on the four corners of the rectangle
+
+    Arguments:
+    :param window: a gdk window
+    :param x: x position
+    :param y: y position
+    :param w: the width of the rectangle
+    :param y: the height of the rectangle
+    :param emblems: a list of pixbufs
+    """
+    # w = max(self.width, w)
+    corners = [[x, y],
+               [x+w, y],
+               [x, y+h],
+               [x+w-4, y+h-4]]
+    context = window.cairo_create()
+    for i in xrange(len(emblems)):
+        i = i % len(emblems)
+        pixbuf = emblems[i]
+        if pixbuf:
+            pbw, pbh = pixbuf.get_width()/2, pixbuf.get_height()/2
+            context.set_source_pixbuf(pixbuf, corners[i][0]-pbw, corners[i][1]-pbh)
+            context.rectangle(corners[i][0]-pbw, corners[i][1]-pbh, pbw*2, pbh*2)
+            context.fill()
+
+##
+## Color functions
+
+def shade_gdk_color(color, shade):
+    """
+    Shades a color by a fraction
+
+    Arguments:
+    :param color: a gdk color
+    :param shade: fraction by which to shade the color
+
+    :returns: a :class:`Color <gtk.gdk.Color>`
+    """
+    f = lambda num: min((num * shade, 65535.0))
+    if gtk.pygtk_version >= (2, 16, 0):
+        color.red = f(color.red)
+        color.green = f(color.green)
+        color.blue = f(color.blue)
+    else:
+        red = int(f(color.red))
+        green = int(f(color.green))
+        blue = int(f(color.blue))
+        color = gtk.gdk.Color(red=red, green=green, blue=blue)
+    return color
+
+def combine_gdk_color(color, fcolor):
+    """
+    Combines a color with another color
+
+    Arguments:
+    :param color: a gdk color
+    :param fcolor: a gdk color to combine with color
+
+    :returns: a :class:`Color <gtk.gdk.Color>`
+    """
+    if gtk.pygtk_version >= (2, 16, 0):
+        color.red = (2*color.red + fcolor.red)/3
+        color.green = (2*color.green + fcolor.green)/3
+        color.blue = (2*color.blue + fcolor.blue)/3
+    else:
+        red = int(((2*color.red + fcolor.red)/3))
+        green = int(((2*color.green + fcolor.green)/3))
+        blue = int(((2*color.blue + fcolor.blue)/3))
+        color = gtk.gdk.Color(red=red, green=green, blue=blue)
+    return color
+
+def get_gtk_rgba(style, palette, i, shade = 1, alpha = 1):
+    """Takes a gtk style and returns a RGB tuple
+
+    Arguments:
+    :param style: a gtk_style object
+    :param palette: a string representing the palette you want to pull a color from
+        Example: "bg", "fg"
+    :param shade: how much you want to shade the color
+
+    :returns: a rgba tuple
+    """
+    f = lambda num: (num/65535.0) * shade
+    color = getattr(style, palette)[i]
+    if isinstance(color, gtk.gdk.Color):
+        red = f(color.red)
+        green = f(color.green)
+        blue = f(color.blue)
+        return (min(red, 1), min(green, 1), min(blue, 1), alpha)
+    else: raise TypeError("Not a valid gtk.gdk.Color")
+
+
+##
+## Pixbuff work
+##
+
+def new_grayscale_pixbuf(pixbuf):
+    """
+    Makes a pixbuf grayscale
+
+    :param pixbuf: a :class:`Pixbuf <gtk.gdk.Pixbuf>`
+
+    :returns: a :class:`Pixbuf <gtk.gdk.Pixbuf>`
+
+    """
+    pixbuf2 = pixbuf.copy()
+    pixbuf.saturate_and_pixelate(pixbuf2, 0.0, False)
+    return pixbuf2
+
+def crop_pixbuf(pixbuf, x, y, width, height):
+    """
+    Crop a pixbuf
+
+    Arguments:
+    :param pixbuf: a :class:`Pixbuf <gtk.gdk.Pixbuf>`
+    :param x: the x position to crop from in the source
+    :param y: the y position to crop from in the source
+    :param width: crop width
+    :param height: crop height
+
+    :returns: a :class:`Pixbuf <gtk.gdk.Pixbuf>`
+    """
+    dest_pixbuf = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, True, 8, width, height)
+    pixbuf.copy_area(x, y, width, height, dest_pixbuf, 0, 0)
+    return dest_pixbuf
+
+def scale_to_fill(pixbuf, neww, newh):
+    """
+    Scales/crops a new pixbuf to a width and height at best fit and returns it
+
+    Arguments:
+    :param pixbuf: a :class:`Pixbuf <gtk.gdk.Pixbuf>`
+    :param neww: new width of the new pixbuf
+    :param newh: a new height of the new pixbuf
+
+    :returns: a :class:`Pixbuf <gtk.gdk.Pixbuf>`
+    """
+    imagew, imageh = pixbuf.get_width(), pixbuf.get_height()
+    if (imagew, imageh) != (neww, newh):
+        imageratio = float(imagew) / float(imageh)
+        newratio = float(neww) / float(newh)
+        if imageratio > newratio:
+            transformw = int(round(newh * imageratio))
+            pixbuf = pixbuf.scale_simple(transformw, newh, gtk.gdk.INTERP_BILINEAR)
+            pixbuf = crop_pixbuf(pixbuf, 0, 0, neww, newh)
+        elif imageratio < newratio:
+            transformh = int(round(neww / imageratio))
+            pixbuf = pixbuf.scale_simple(neww, transformh, gtk.gdk.INTERP_BILINEAR)
+            pixbuf = crop_pixbuf(pixbuf, 0, 0, neww, newh)
+        else:
+            pixbuf = pixbuf.scale_simple(neww, newh, gtk.gdk.INTERP_BILINEAR)
+    return pixbuf
+
+
+class PixbufCache(dict):
+    """
+    A pixbuf cache dict which stores, loads, and saves pixbufs to a cache and to
+    the users filesystem. The naming scheme for thumb files are use hash
+
+    There are huge flaws with this object. It does not have a ceiling, and it
+    does not remove thumbnails from the file system. Essentially meaning the
+    cache directory can grow forever.
+    """
+    def __init__(self, *args, **kwargs):
+        super(PixbufCache, self).__init__()
+
+    def check_cache(self, uri):
+        return self[uri]
+
+    def get_buff(self, key):
+        thumbpath = os.path.expanduser("~/.cache/GAJ/1_" + str(hash(key)))
+        if os.path.exists(thumbpath):
+            self[key] = (gtk.gdk.pixbuf_new_from_file(thumbpath), True)
+            return self[key]
+        return None
+
+    def __getitem__(self, key):
+        if self.has_key(key):
+            return super(PixbufCache, self).__getitem__(key)
+        return self.get_buff(key)
+
+    def __setitem__(self, key, (pb, isthumb)):
+        dir_ = os.path.expanduser("~/.cache/GAJ/")
+        if not os.path.exists(os.path.expanduser("~/.cache/GAJ/")):
+            os.makedirs(dir_)
+        path = dir_ + str(hash(isthumb)) + "_" + str(hash(key))
+        if not os.path.exists(path):
+            open(path, 'w').close()
+            pb.save(path, "png")
+        return super(PixbufCache, self).__setitem__(key, (pb, isthumb))
+
+    def get_pixbuf_from_uri(self, uri, size=SIZE_LARGE, iconscale=1, w=0, h=0):
+        """
+        Returns a pixbuf and True if a thumbnail was found, else False. Uses the
+        Pixbuf Cache for thumbnail compatible files. If the pixbuf is a thumb
+        it is cached.
+
+        Arguments:
+        :param uri: a uri on the disk
+        :param size: a size tuple from thumbfactory
+        :param iconscale: a factor to reduce icons by (not thumbs)
+        :param w: resulting width
+        :param h: resulting height
+
+        Warning! This function is in need of a serious clean up.
+
+        :returns: a tuple containing a :class:`Pixbuf <gtk.gdk.Pixbuf>` and bool
+        which is True if a thumbnail was found
+        """
+        try:
+            cached = self.check_cache(uri)
+        except gobject.GError:
+            cached = None
+        if cached:
+            return cached
+        gfile = GioFile.create(uri)
+        thumb = True
+        if gfile:
+            if gfile.has_preview():
+                pb = gfile.get_thumbnail(size=size)
+            else:
+                iconsize = int(size[0]*iconscale)
+                pb = gfile.get_icon(size=iconsize)
+                thumb = False
+        else: pb = None
+        if not pb:
+            pb = ICON_THEME.lookup_icon(gtk.STOCK_MISSING_IMAGE, int(size[0]*iconscale), gtk.ICON_LOOKUP_FORCE_SVG).load_icon()
+            thumb = False
+        if thumb:
+            pb = scale_to_fill(pb, w, h)
+            self[uri] = (pb, thumb)
+        return pb, thumb
+
+PIXBUFCACHE = PixbufCache()
+
+def get_icon_for_name(name, size):
+    """
+    return a icon for a name
+    """
+    size = int(size)
+    ICONS[(size, size)]
+    if ICONS[(size, size)].has_key(name):
+        return ICONS[(size, size)][name]
+    info = ICON_THEME.lookup_icon(name, size, gtk.ICON_LOOKUP_USE_BUILTIN)
+    if not info:
+        return None
+    location = info.get_filename()
+    return get_icon_for_uri(location, size)
+
+def get_icon_for_uri(uri, size):
+    pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(uri, size, size)
+    ICONS[(size, size)][uri] = pixbuf
+    return pixbuf
+
+def get_icon_from_object_at_uri(uri, size):
+    """
+    Returns a icon from a event at size
+
+    :param uri: a uri string
+    :param size: a int representing the size in pixels of the icon
+
+    :returns: a :class:`Pixbuf <gtk.gdk.Pixbuf>`
+    """
+    gfile = GioFile.create(uri)
+    if gfile:
+        pb = gfile.get_icon(size=size)
+        if pb:
+            return pb
+    return False
+
+
+
+##
+## Other useful methods
+##
+
+def is_command_available(command):
+    """
+    Checks whether the given command is available, by looking for it in
+    the PATH.
+
+    This is useful for ensuring that optional dependencies on external
+    applications are fulfilled.
+    """
+    assert len(" a".split()) == 1, "No arguments are accepted in command"
+    for directory in os.environ["PATH"].split(os.pathsep):
+        if os.path.exists(os.path.join(directory, command)):
+            return True
+    return False
+
+def launch_command(command, arguments=None):
+    """
+    Launches a program as an independent process.
+    """
+    if not arguments:
+        arguments = []
+    null = os.open(os.devnull, os.O_RDWR)
+    subprocess.Popen([command] + arguments, stdout=null, stderr=null,
+                     close_fds=True)
+
+def launch_string_command(command):
+    """
+    Launches a program as an independent from a string
+    """
+    command = command.split(" ")
+    null = os.open(os.devnull, os.O_RDWR)
+    subprocess.Popen(command, stdout=null, stderr=null,
+                     close_fds=True)
+
 
=== removed file 'src/common.py'
--- src/common.py	2010-04-19 04:51:23 +0000
+++ src/common.py	1970-01-01 00:00:00 +0000
@@ -1,582 +0,0 @@
-# -.- coding: utf-8 -.-
-#
-# Filename
-#
-# Copyright © 2010 Randal Barlow <[e-mail]>
-# Copyright © 2010 Siegfried Gevatter <[e-mail]>
-#
-# 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, or
-# (at your option) any later version.
-#
-# 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, see <http://www.gnu.org/licenses/>.
-
-"""
-Common Functions and classes which are used to create the alternative views,
-and handle colors, pixbufs, and text
-"""
-
-import cairo
-import gobject
-import gtk
-import os
-import pango
-import pangocairo
-import time
-import math
-import operator
-import subprocess
-
-from gio_file import GioFile, SIZE_LARGE, SIZE_NORMAL, SIZE_THUMBVIEW, SIZE_TIMELINEVIEW, ICONS
-from config import get_data_path, get_icon_path
-
-from zeitgeist.datamodel import Interpretation, Event
-
-
-# Caches desktop files
-DESKTOP_FILES = {}
-DESKTOP_FILE_PATHS = []
-try:
-    desktop_file_paths = os.environ["XDG_DATA_DIRS"].split(":")
-    for path in desktop_file_paths:
-        if path.endswith("/"):
-            DESKTOP_FILE_PATHS.append(path + "applications/")
-        else:
-            DESKTOP_FILE_PATHS.append(path + "/applications/")
-except KeyError:pass
-
-# Placeholder pixbufs for common sizes
-PLACEHOLDER_PIXBUFFS = {
-    24 : gtk.gdk.pixbuf_new_from_file_at_size(get_icon_path("hicolor/scalable/apps/gnome-activity-journal.svg"), 24, 24),
-    16 : gtk.gdk.pixbuf_new_from_file_at_size(get_icon_path("hicolor/scalable/apps/gnome-activity-journal.svg"), 16, 16)
-    }
-
-# Color magic
-TANGOCOLORS = [
-    (252/255.0, 234/255.0,  79/255.0),#0
-    (237/255.0, 212/255.0,   0/255.0),
-    (196/255.0, 160/255.0,   0/255.0),
-
-    (252/255.0, 175/255.0,  62/255.0),#3
-    (245/255.0, 121/255.0,   0/255.0),
-    (206/255.0,  92/255.0,   0/255.0),
-
-    (233/255.0, 185/255.0, 110/255.0),#6
-    (193/255.0, 125/255.0,  17/255.0),
-    (143/255.0,  89/255.0,  02/255.0),
-
-    (138/255.0, 226/255.0,  52/255.0),#9
-    (115/255.0, 210/255.0,  22/255.0),
-    ( 78/255.0, 154/255.0,  06/255.0),
-
-    (114/255.0, 159/255.0, 207/255.0),#12
-    ( 52/255.0, 101/255.0, 164/255.0),
-    ( 32/255.0,  74/255.0, 135/255.0),
-
-    (173/255.0, 127/255.0, 168/255.0),#15
-    (117/255.0,  80/255.0, 123/255.0),
-    ( 92/255.0,  53/255.0, 102/255.0),
-
-    (239/255.0,  41/255.0,  41/255.0),#18
-    (204/255.0,   0/255.0,   0/255.0),
-    (164/255.0,   0/255.0,   0/255.0),
-
-    (136/255.0, 138/255.0, 133/255.0),#21
-    ( 85/255.0,  87/255.0,  83/255.0),
-    ( 46/255.0,  52/255.0,  54/255.0),
-]
-
-FILETYPES = {
-    Interpretation.VIDEO.uri : 0,
-    Interpretation.MUSIC.uri : 3,
-    Interpretation.DOCUMENT.uri : 12,
-    Interpretation.IMAGE.uri : 15,
-    Interpretation.SOURCECODE.uri : 12,
-    Interpretation.UNKNOWN.uri : 21,
-    Interpretation.IM_MESSAGE.uri : 21,
-    Interpretation.EMAIL.uri : 21
-}
-
-FILETYPESNAMES = {
-    Interpretation.VIDEO.uri : _("Video"),
-    Interpretation.MUSIC.uri : _("Music"),
-    Interpretation.DOCUMENT.uri : _("Document"),
-    Interpretation.IMAGE.uri : _("Image"),
-    Interpretation.SOURCECODE.uri : _("Source Code"),
-    Interpretation.UNKNOWN.uri : _("Unknown"),
-    Interpretation.IM_MESSAGE.uri : _("IM Message"),
-    Interpretation.EMAIL.uri :_("Email"),
-
-}
-
-MEDIAINTERPRETATIONS = [
-    Interpretation.VIDEO.uri,
-    Interpretation.IMAGE.uri,
-]
-
-TIMELABELS = [_("Morning"), _("Afternoon"), _("Evening")]
-ICON_THEME = gtk.icon_theme_get_default()
-
-def get_file_color(ftype, fmime):
-    """Uses hashing to choose a shade from a hue in the color tuple above
-
-    :param ftype: a :class:`Event <zeitgeist.datamodel.Interpretation>`
-    :param fmime: a mime type string
-    """
-    if ftype in FILETYPES.keys():
-        i = FILETYPES[ftype]
-        l = int(math.fabs(hash(fmime))) % 3
-        return TANGOCOLORS[min(i+l, len(TANGOCOLORS)-1)]
-    return (136/255.0, 138/255.0, 133/255.0)
-
-##
-## Zeitgeist event helper functions
-
-def get_event_typename(event):
-    """
-    :param event: a :class:`Event <zeitgeist.datamodel.Event>`
-
-    :returns: a plain text version of a interpretation
-    """
-    try:
-        return Interpretation[event.subjects[0].interpretation].display_name
-    except KeyError:
-        pass
-    return FILETYPESNAMES[event.subjects[0].interpretation]
-
-##
-# Cairo drawing functions
-
-def draw_frame(context, x, y, w, h):
-    """
-    Draws a 2 pixel frame around a area defined by x, y, w, h using a cairo context
-
-    :param context: a cairo context
-    :param x: x position of the frame
-    :param y: y position of the frame
-    :param w: width of the frame
-    :param h: height of the frame
-    """
-    x, y = int(x)+0.5, int(y)+0.5
-    w, h = int(w), int(h)
-    context.set_line_width(1)
-    context.rectangle(x-1, y-1, w+2, h+2)
-    context.set_source_rgba(0.5, 0.5, 0.5)#0.3, 0.3, 0.3)
-    context.stroke()
-    context.set_source_rgba(0.7, 0.7, 0.7)
-    context.rectangle(x, y, w, h)
-    context.stroke()
-    context.set_source_rgba(0.4, 0.4, 0.4)
-    context.rectangle(x+1, y+1, w-2, h-2)
-    context.stroke()
-
-def draw_rounded_rectangle(context, x, y, w, h, r=5):
-    """Draws a rounded rectangle
-
-    :param context: a cairo context
-    :param x: x position of the rectangle
-    :param y: y position of the rectangle
-    :param w: width of the rectangle
-    :param h: height of the rectangle
-    :param r: radius of the rectangle
-    """
-    context.new_sub_path()
-    context.arc(r+x, r+y, r, math.pi, 3 * math.pi /2)
-    context.arc(w-r+x, r+y, r, 3 * math.pi / 2, 0)
-    context.arc(w-r+x, h-r+y, r, 0, math.pi/2)
-    context.arc(r+x, h-r+y, r, math.pi/2, math.pi)
-    context.close_path()
-    return context
-
-def draw_speech_bubble(context, layout, x, y, w, h):
-    """
-    Draw a speech bubble at a position
-
-    Arguments:
-    :param context: a cairo context
-    :param layout: a pango layout
-    :param x: x position of the bubble
-    :param y: y position of the bubble
-    :param w: width of the bubble
-    :param h: height of the bubble
-    """
-    layout.set_width((w-10)*1024)
-    layout.set_ellipsize(pango.ELLIPSIZE_MIDDLE)
-    textw, texth = layout.get_pixel_size()
-    context.new_path()
-    context.move_to(x + 0.45*w, y+h*0.1 + 2)
-    context.line_to(x + 0.5*w, y)
-    context.line_to(x + 0.55*w, y+h*0.1 + 2)
-    h = max(texth + 5, h)
-    draw_rounded_rectangle(context, x, y+h*0.1, w, h, r = 5)
-    context.close_path()
-    context.set_line_width(2)
-    context.set_source_rgb(168/255.0, 165/255.0, 134/255.0)
-    context.stroke_preserve()
-    context.set_source_rgb(253/255.0, 248/255.0, 202/255.0)
-    context.fill()
-    pcontext = pangocairo.CairoContext(context)
-    pcontext.set_source_rgb(0, 0, 0)
-    pcontext.move_to(x+5, y+5)
-    pcontext.show_layout(layout)
-
-def draw_text(context, layout, markup, x, y, maxw = 0, color = (0.3, 0.3, 0.3)):
-    """
-    Draw text using a cairo context and a pango layout
-
-    Arguments:
-    :param context: a cairo context
-    :param layout: a pango layout
-    :param x: x position of the bubble
-    :param y: y position of the bubble
-    :param maxw: the max text width in pixels
-    :param color: a rgb tuple
-    """
-    pcontext = pangocairo.CairoContext(context)
-    layout.set_markup(markup)
-    layout.set_ellipsize(pango.ELLIPSIZE_MIDDLE)
-    pcontext.set_source_rgba(*color)
-    if maxw:
-        layout.set_width(maxw*1024)
-    pcontext.move_to(x, y)
-    pcontext.show_layout(layout)
-
-def render_pixbuf(window, x, y, pixbuf, drawframe = True):
-    """
-    Renders a pixbuf to be displayed on the cell
-
-    Arguments:
-    :param window: a gdk window
-    :param x: x position
-    :param y: y position
-    :param drawframe: if true we draw a frame around the pixbuf
-    """
-    imgw, imgh = pixbuf.get_width(), pixbuf.get_height()
-    context = window.cairo_create()
-    context.rectangle(x, y, imgw, imgh)
-    if drawframe:
-        context.set_source_rgb(1, 1, 1)
-        context.fill_preserve()
-    context.set_source_pixbuf(pixbuf, x, y)
-    context.fill()
-    if drawframe: # Draw a pretty frame
-        draw_frame(context, x, y, imgw, imgh)
-
-def render_emblems(window, x, y, w, h, emblems):
-    """
-    Renders emblems on the four corners of the rectangle
-
-    Arguments:
-    :param window: a gdk window
-    :param x: x position
-    :param y: y position
-    :param w: the width of the rectangle
-    :param y: the height of the rectangle
-    :param emblems: a list of pixbufs
-    """
-    # w = max(self.width, w)
-    corners = [[x, y],
-               [x+w, y],
-               [x, y+h],
-               [x+w-4, y+h-4]]
-    context = window.cairo_create()
-    for i in xrange(len(emblems)):
-        i = i % len(emblems)
-        pixbuf = emblems[i]
-        if pixbuf:
-            pbw, pbh = pixbuf.get_width()/2, pixbuf.get_height()/2
-            context.set_source_pixbuf(pixbuf, corners[i][0]-pbw, corners[i][1]-pbh)
-            context.rectangle(corners[i][0]-pbw, corners[i][1]-pbh, pbw*2, pbh*2)
-            context.fill()
-
-##
-## Color functions
-
-def shade_gdk_color(color, shade):
-    """
-    Shades a color by a fraction
-
-    Arguments:
-    :param color: a gdk color
-    :param shade: fraction by which to shade the color
-
-    :returns: a :class:`Color <gtk.gdk.Color>`
-    """
-    f = lambda num: min((num * shade, 65535.0))
-    if gtk.pygtk_version >= (2, 16, 0):
-        color.red = f(color.red)
-        color.green = f(color.green)
-        color.blue = f(color.blue)
-    else:
-        red = int(f(color.red))
-        green = int(f(color.green))
-        blue = int(f(color.blue))
-        color = gtk.gdk.Color(red=red, green=green, blue=blue)
-    return color
-
-def combine_gdk_color(color, fcolor):
-    """
-    Combines a color with another color
-
-    Arguments:
-    :param color: a gdk color
-    :param fcolor: a gdk color to combine with color
-
-    :returns: a :class:`Color <gtk.gdk.Color>`
-    """
-    if gtk.pygtk_version >= (2, 16, 0):
-        color.red = (2*color.red + fcolor.red)/3
-        color.green = (2*color.green + fcolor.green)/3
-        color.blue = (2*color.blue + fcolor.blue)/3
-    else:
-        red = int(((2*color.red + fcolor.red)/3))
-        green = int(((2*color.green + fcolor.green)/3))
-        blue = int(((2*color.blue + fcolor.blue)/3))
-        color = gtk.gdk.Color(red=red, green=green, blue=blue)
-    return color
-
-def get_gtk_rgba(style, palette, i, shade = 1, alpha = 1):
-    """Takes a gtk style and returns a RGB tuple
-
-    Arguments:
-    :param style: a gtk_style object
-    :param palette: a string representing the palette you want to pull a color from
-        Example: "bg", "fg"
-    :param shade: how much you want to shade the color
-
-    :returns: a rgba tuple
-    """
-    f = lambda num: (num/65535.0) * shade
-    color = getattr(style, palette)[i]
-    if isinstance(color, gtk.gdk.Color):
-        red = f(color.red)
-        green = f(color.green)
-        blue = f(color.blue)
-        return (min(red, 1), min(green, 1), min(blue, 1), alpha)
-    else: raise TypeError("Not a valid gtk.gdk.Color")
-
-
-##
-## Pixbuff work
-##
-
-def new_grayscale_pixbuf(pixbuf):
-    """
-    Makes a pixbuf grayscale
-
-    :param pixbuf: a :class:`Pixbuf <gtk.gdk.Pixbuf>`
-
-    :returns: a :class:`Pixbuf <gtk.gdk.Pixbuf>`
-
-    """
-    pixbuf2 = pixbuf.copy()
-    pixbuf.saturate_and_pixelate(pixbuf2, 0.0, False)
-    return pixbuf2
-
-def crop_pixbuf(pixbuf, x, y, width, height):
-    """
-    Crop a pixbuf
-
-    Arguments:
-    :param pixbuf: a :class:`Pixbuf <gtk.gdk.Pixbuf>`
-    :param x: the x position to crop from in the source
-    :param y: the y position to crop from in the source
-    :param width: crop width
-    :param height: crop height
-
-    :returns: a :class:`Pixbuf <gtk.gdk.Pixbuf>`
-    """
-    dest_pixbuf = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, True, 8, width, height)
-    pixbuf.copy_area(x, y, width, height, dest_pixbuf, 0, 0)
-    return dest_pixbuf
-
-def scale_to_fill(pixbuf, neww, newh):
-    """
-    Scales/crops a new pixbuf to a width and height at best fit and returns it
-
-    Arguments:
-    :param pixbuf: a :class:`Pixbuf <gtk.gdk.Pixbuf>`
-    :param neww: new width of the new pixbuf
-    :param newh: a new height of the new pixbuf
-
-    :returns: a :class:`Pixbuf <gtk.gdk.Pixbuf>`
-    """
-    imagew, imageh = pixbuf.get_width(), pixbuf.get_height()
-    if (imagew, imageh) != (neww, newh):
-        imageratio = float(imagew) / float(imageh)
-        newratio = float(neww) / float(newh)
-        if imageratio > newratio:
-            transformw = int(round(newh * imageratio))
-            pixbuf = pixbuf.scale_simple(transformw, newh, gtk.gdk.INTERP_BILINEAR)
-            pixbuf = crop_pixbuf(pixbuf, 0, 0, neww, newh)
-        elif imageratio < newratio:
-            transformh = int(round(neww / imageratio))
-            pixbuf = pixbuf.scale_simple(neww, transformh, gtk.gdk.INTERP_BILINEAR)
-            pixbuf = crop_pixbuf(pixbuf, 0, 0, neww, newh)
-        else:
-            pixbuf = pixbuf.scale_simple(neww, newh, gtk.gdk.INTERP_BILINEAR)
-    return pixbuf
-
-
-class PixbufCache(dict):
-    """
-    A pixbuf cache dict which stores, loads, and saves pixbufs to a cache and to
-    the users filesystem. The naming scheme for thumb files are use hash
-
-    There are huge flaws with this object. It does not have a ceiling, and it
-    does not remove thumbnails from the file system. Essentially meaning the
-    cache directory can grow forever.
-    """
-    def __init__(self, *args, **kwargs):
-        super(PixbufCache, self).__init__()
-
-    def check_cache(self, uri):
-        return self[uri]
-
-    def get_buff(self, key):
-        thumbpath = os.path.expanduser("~/.cache/GAJ/1_" + str(hash(key)))
-        if os.path.exists(thumbpath):
-            self[key] = (gtk.gdk.pixbuf_new_from_file(thumbpath), True)
-            return self[key]
-        return None
-
-    def __getitem__(self, key):
-        if self.has_key(key):
-            return super(PixbufCache, self).__getitem__(key)
-        return self.get_buff(key)
-
-    def __setitem__(self, key, (pb, isthumb)):
-        dir_ = os.path.expanduser("~/.cache/GAJ/")
-        if not os.path.exists(os.path.expanduser("~/.cache/GAJ/")):
-            os.makedirs(dir_)
-        path = dir_ + str(hash(isthumb)) + "_" + str(hash(key))
-        if not os.path.exists(path):
-            open(path, 'w').close()
-            pb.save(path, "png")
-        return super(PixbufCache, self).__setitem__(key, (pb, isthumb))
-
-    def get_pixbuf_from_uri(self, uri, size=SIZE_LARGE, iconscale=1, w=0, h=0):
-        """
-        Returns a pixbuf and True if a thumbnail was found, else False. Uses the
-        Pixbuf Cache for thumbnail compatible files. If the pixbuf is a thumb
-        it is cached.
-
-        Arguments:
-        :param uri: a uri on the disk
-        :param size: a size tuple from thumbfactory
-        :param iconscale: a factor to reduce icons by (not thumbs)
-        :param w: resulting width
-        :param h: resulting height
-
-        Warning! This function is in need of a serious clean up.
-
-        :returns: a tuple containing a :class:`Pixbuf <gtk.gdk.Pixbuf>` and bool
-        which is True if a thumbnail was found
-        """
-        try:
-            cached = self.check_cache(uri)
-        except gobject.GError:
-            cached = None
-        if cached:
-            return cached
-        gfile = GioFile.create(uri)
-        thumb = True
-        if gfile:
-            if gfile.has_preview():
-                pb = gfile.get_thumbnail(size=size)
-            else:
-                iconsize = int(size[0]*iconscale)
-                pb = gfile.get_icon(size=iconsize)
-                thumb = False
-        else: pb = None
-        if not pb:
-            pb = ICON_THEME.lookup_icon(gtk.STOCK_MISSING_IMAGE, int(size[0]*iconscale), gtk.ICON_LOOKUP_FORCE_SVG).load_icon()
-            thumb = False
-        if thumb:
-            pb = scale_to_fill(pb, w, h)
-            self[uri] = (pb, thumb)
-        return pb, thumb
-
-PIXBUFCACHE = PixbufCache()
-
-def get_icon_for_name(name, size):
-    """
-    return a icon for a name
-    """
-    size = int(size)
-    ICONS[(size, size)]
-    if ICONS[(size, size)].has_key(name):
-        return ICONS[(size, size)][name]
-    info = ICON_THEME.lookup_icon(name, size, gtk.ICON_LOOKUP_USE_BUILTIN)
-    if not info:
-        return None
-    location = info.get_filename()
-    return get_icon_for_uri(location, size)
-
-def get_icon_for_uri(uri, size):
-    pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(uri, size, size)
-    ICONS[(size, size)][uri] = pixbuf
-    return pixbuf
-
-def get_icon_from_object_at_uri(uri, size):
-    """
-    Returns a icon from a event at size
-
-    :param uri: a uri string
-    :param size: a int representing the size in pixels of the icon
-
-    :returns: a :class:`Pixbuf <gtk.gdk.Pixbuf>`
-    """
-    gfile = GioFile.create(uri)
-    if gfile:
-        pb = gfile.get_icon(size=size)
-        if pb:
-            return pb
-    return False
-
-
-
-##
-## Other useful methods
-##
-
-def is_command_available(command):
-    """
-    Checks whether the given command is available, by looking for it in
-    the PATH.
-
-    This is useful for ensuring that optional dependencies on external
-    applications are fulfilled.
-    """
-    assert len(" a".split()) == 1, "No arguments are accepted in command"
-    for directory in os.environ["PATH"].split(os.pathsep):
-        if os.path.exists(os.path.join(directory, command)):
-            return True
-    return False
-
-def launch_command(command, arguments=None):
-    """
-    Launches a program as an independent process.
-    """
-    if not arguments:
-        arguments = []
-    null = os.open(os.devnull, os.O_RDWR)
-    subprocess.Popen([command] + arguments, stdout=null, stderr=null,
-                     close_fds=True)
-
-def launch_string_command(command):
-    """
-    Launches a program as an independent from a string
-    """
-    command = command.split(" ")
-    null = os.open(os.devnull, os.O_RDWR)
-    subprocess.Popen(command, stdout=null, stderr=null,
-                     close_fds=True)
-
 
=== removed file 'src/daywidgets.py'
--- src/daywidgets.py	2010-04-22 14:05:34 +0000
+++ src/daywidgets.py	1970-01-01 00:00:00 +0000
@@ -1,791 +0,0 @@
-# -.- coding: utf-8 -.-
-#
-# GNOME Activity Journal
-#
-# Copyright © 2009-2010 Seif Lotfy <[e-mail]>
-# Copyright © 2010 Randal Barlow <[e-mail]>
-# Copyright © 2010 Siegfried Gevatter <[e-mail]>
-#
-# 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, or
-# (at your option) any later version.
-#
-# 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, see <http://www.gnu.org/licenses/>.
-
-import gtk
-import time
-import gobject
-import gettext
-import cairo
-import pango
-import math
-import os
-import urllib
-from datetime import date
-
-from zeitgeist.client import ZeitgeistClient
-from zeitgeist.datamodel import Event, Subject, Interpretation, Manifestation, \
-    ResultType, TimeRange
-
-from common import shade_gdk_color, combine_gdk_color, get_gtk_rgba
-from widgets import *
-from thumb import ThumbBox
-from timeline import TimelineView, TimelineHeader
-from eventgatherer import get_dayevents, get_file_events
-
-CLIENT = ZeitgeistClient()
-
-
-class GenericViewWidget(gtk.VBox):
-    __gsignals__ = {
-        "unfocus-day" : (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ()),
-        # Sends a list zeitgeist events
-        }
-
-    def __init__(self):
-        gtk.VBox.__init__(self)
-        self.daylabel = None
-        self.connect("style-set", self.change_style)
-
-    def _set_date_strings(self):
-        self.date_string = date.fromtimestamp(self.day_start).strftime("%d %B")
-        self.year_string = date.fromtimestamp(self.day_start).strftime("%Y")
-        if time.time() < self.day_end and time.time() > self.day_start:
-            self.week_day_string = _("Today")
-        elif time.time() - 86400 < self.day_end and time.time() - 86400> self.day_start:
-            self.week_day_string = _("Yesterday")
-        else:
-            self.week_day_string = date.fromtimestamp(self.day_start).strftime("%A")
-        self.emit("style-set", None)
-
-    def click(self, widget, event):
-        if event.button in (1, 3):
-            self.emit("unfocus-day")
-
-    def change_style(self, widget, style):
-        rc_style = self.style
-        color = rc_style.bg[gtk.STATE_NORMAL]
-        color = shade_gdk_color(color, 102/100.0)
-        self.view.modify_bg(gtk.STATE_NORMAL, color)
-        self.view.modify_base(gtk.STATE_NORMAL, color)
-
-
-class ThumbnailDayWidget(GenericViewWidget):
-
-    def __init__(self):
-        GenericViewWidget.__init__(self)
-        self.monitors = []
-        self.scrolledwindow = gtk.ScrolledWindow()
-        self.scrolledwindow.set_shadow_type(gtk.SHADOW_NONE)
-        self.scrolledwindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
-        self.view = ThumbBox()
-        self.scrolledwindow.add_with_viewport(self.view)
-        self.scrolledwindow.get_children()[0].set_shadow_type(gtk.SHADOW_NONE)
-        self.pack_end(self.scrolledwindow)
-
-    def set_day(self, start, end):
-
-        self.day_start = start
-        self.day_end = end
-        for widget in self:
-            if self.scrolledwindow != widget:
-                self.remove(widget)
-        self._set_date_strings()
-        today = int(time.time() ) - 7*86400
-        if self.daylabel:
-            #Disconnect here
-            pass
-        if self.day_start < today:
-            self.daylabel = DayLabel(self.date_string, self.week_day_string+", "+ self.year_string)
-        else:
-            self.daylabel = DayLabel(self.week_day_string, self.date_string+", "+ self.year_string)
-        self.daylabel.set_size_request(100, 60)
-        self.daylabel.connect("button-press-event", self.click)
-        self.daylabel.set_tooltip_text(_("Click to return to multiday view"))
-        self.pack_start(self.daylabel, False, False)
-        self.show_all()
-        self.view.hide_all()
-        self.daylabel.show_all()
-        self.view.show()
-
-        hour = 60*60
-        get_file_events(start*1000, (start + 12*hour -1) * 1000, self.set_morning_events)
-        get_file_events((start + 12*hour)*1000, (start + 18*hour - 1)*1000, self.set_afternoon_events)
-        get_file_events((start + 18*hour)*1000, end*1000, self.set_evening_events)
-
-    def set_morning_events(self, events):
-        if len(events) > 0:
-            timestamp = int(events[0].timestamp)
-            if self.day_start*1000 <= timestamp and timestamp < (self.day_start + 12*60*60)*1000:
-                self.view.set_morning_events(events)
-            self.view.views[0].show_all()
-            self.view.labels[0].show_all()
-        else:
-            self.view.set_morning_events(events)
-            self.view.views[0].hide_all()
-            self.view.labels[0].hide_all()
-
-    def set_afternoon_events(self, events):
-        if len(events) > 0:
-            timestamp = int(events[0].timestamp)
-            if (self.day_start + 12*60*60)*1000 <= timestamp and timestamp < (self.day_start + 18*60*60)*1000:
-                self.view.set_afternoon_events(events)
-            self.view.views[1].show_all()
-            self.view.labels[1].show_all()
-        else:
-            self.view.set_afternoon_events(events)
-            self.view.views[1].hide_all()
-            self.view.labels[1].hide_all()
-
-    def set_evening_events(self, events):
-        if len(events) > 0:
-            timestamp = int(events[0].timestamp)
-            if (self.day_start + 18*60*60)*1000 <= timestamp and timestamp < self.day_end*1000:
-                self.view.set_evening_events(events)
-            self.view.views[2].show_all()
-            self.view.labels[2].show_all()
-        else:
-            self.view.set_evening_events(events)
-            self.view.views[2].hide_all()
-            self.view.labels[2].hide_all()
-
-
-class SingleDayWidget(GenericViewWidget):
-
-    def __init__(self):
-        GenericViewWidget.__init__(self)
-        self.ruler = TimelineHeader()
-        self.scrolledwindow = gtk.ScrolledWindow()
-        self.scrolledwindow.set_shadow_type(gtk.SHADOW_NONE)
-        self.scrolledwindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
-        self.view = TimelineView()
-        self.scrolledwindow.add(self.view)
-        self.pack_end(self.scrolledwindow)
-        self.pack_end(self.ruler, False, False)
-        self.view.set_events(gtk.gdk.POINTER_MOTION_MASK | gtk.gdk.POINTER_MOTION_HINT_MASK)
-
-    def set_day(self, start, end):
-        self.day_start = start
-        self.day_end = end
-        for widget in self:
-            if widget not in (self.ruler, self.scrolledwindow):
-                self.remove(widget)
-        self._set_date_strings()
-        today = int(time.time() ) - 7*86400
-        if self.daylabel:
-            #Disconnect here
-            pass
-        if self.day_start < today:
-            self.daylabel = DayLabel(self.date_string, self.week_day_string+", "+ self.year_string)
-        else:
-            self.daylabel = DayLabel(self.week_day_string, self.date_string+", "+ self.year_string)
-        self.daylabel.set_size_request(100, 60)
-        self.daylabel.connect("button-press-event", self.click)
-        self.daylabel.set_tooltip_text(_("Click to return to multiday view"))
-
-        self.pack_start(self.daylabel, False, False)
-        get_dayevents(start*1000, end*1000, 1, self.view.set_model_from_list)
-        self.show_all()
-
-    def change_style(self, widget, style):
-        GenericViewWidget.change_style(self, widget, style)
-        rc_style = self.style
-        color = rc_style.bg[gtk.STATE_NORMAL]
-        color = shade_gdk_color(color, 102/100.0)
-        self.ruler.modify_bg(gtk.STATE_NORMAL, color)
-
-
-class DayWidget(gtk.VBox):
-
-    __gsignals__ = {
-        "focus-day" : (gobject.SIGNAL_RUN_FIRST,
-                    gobject.TYPE_NONE,
-                    (gobject.TYPE_INT,))
-        }
-
-    def __init__(self, start, end):
-        super(DayWidget, self).__init__()
-        hour = 60*60
-        self.day_start = start
-        self.day_end = end
-
-        self._set_date_strings()
-        self._periods = [
-            (_("Morning"), start, start + 12*hour - 1),
-            (_("Afternoon"), start + 12*hour, start + 18*hour - 1),
-            (_("Evening"), start + 18*hour, end),
-        ]
-
-        self._init_widgets()
-        self._init_pinbox()
-        gobject.timeout_add_seconds(
-            86400 - (int(time.time() - time.timezone) % 86400), self._refresh)
-
-
-        self.show_all()
-        self._init_events()
-
-    def refresh(self):
-        pass
-
-    def _set_date_strings(self):
-        self.date_string = date.fromtimestamp(self.day_start).strftime("%d %B")
-        self.year_string = date.fromtimestamp(self.day_start).strftime("%Y")
-        if time.time() < self.day_end and time.time() > self.day_start:
-            self.week_day_string = _("Today")
-        elif time.time() - 86400 < self.day_end and time.time() - 86400> self.day_start:
-            self.week_day_string = _("Yesterday")
-        else:
-                self.week_day_string = date.fromtimestamp(self.day_start).strftime("%A")
-        self.emit("style-set", None)
-
-    def _refresh(self):
-        self._init_date_label()
-        self._init_pinbox()
-        pinbox.show_all()
-
-    def _init_pinbox(self):
-        if self.day_start <= time.time() < self.day_end:
-            self.view.pack_start(pinbox, False, False)
-
-    def _init_widgets(self):
-        self.vbox = gtk.VBox()
-        self.pack_start(self.vbox)
-
-        self.daylabel = None
-
-        self._init_date_label()
-
-        #label.modify_bg(gtk.STATE_SELECTED, style.bg[gtk.STATE_SELECTED])
-
-        self.view = gtk.VBox()
-        scroll = gtk.ScrolledWindow()
-        scroll.set_shadow_type(gtk.SHADOW_NONE)
-
-        evbox2 = gtk.EventBox()
-        evbox2.add(self.view)
-        self.view.set_border_width(6)
-
-        scroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
-        scroll.add_with_viewport(evbox2)
-        for w in scroll.get_children():
-            w.set_shadow_type(gtk.SHADOW_NONE)
-        self.vbox.pack_start(scroll)
-        self.show_all()
-
-        def change_style(widget, style):
-            rc_style = self.style
-            color = rc_style.bg[gtk.STATE_NORMAL]
-            color = shade_gdk_color(color, 102/100.0)
-            evbox2.modify_bg(gtk.STATE_NORMAL, color)
-
-        self.connect("style-set", change_style)
-
-    def _init_date_label(self):
-        self._set_date_strings()
-
-        today = int(time.time() ) - 7*86400
-        if self.daylabel:
-            # Disconnect HERE
-            pass
-        if self.day_start < today:
-            self.daylabel = DayLabel(self.date_string, self.week_day_string+", "+ self.year_string)
-        else:
-            self.daylabel = DayLabel(self.week_day_string, self.date_string+", "+ self.year_string)
-        self.daylabel.connect("button-press-event", self.click)
-        self.daylabel.set_tooltip_text(
-            _("Left click for a detailed timeline view")
-            + u"\n" +
-            _("Right click for a thumbnail view"))
-        self.daylabel.set_size_request(100, 60)
-        evbox = gtk.EventBox()
-        evbox.add(self.daylabel)
-        evbox.set_size_request(100, 60)
-        self.vbox.pack_start(evbox, False, False)
-        def cursor_func(x, y):
-            if evbox.window:
-                evbox.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.HAND2))
-        self.connect("motion-notify-event", cursor_func)
-
-        def change_style(widget, style):
-            rc_style = self.style
-            color = rc_style.bg[gtk.STATE_NORMAL]
-            evbox.modify_bg(gtk.STATE_NORMAL, color)
-            self.daylabel.modify_bg(gtk.STATE_NORMAL, color)
-
-        self.connect("style-set", change_style)
-        #self.connect("leave-notify-event", lambda x, y: evbox.window.set_cursor(None))
-
-        self.vbox.reorder_child(self.daylabel, 0)
-
-    def click(self, widget, event):
-        if event.button == 1:
-            self.emit("focus-day", 1)
-        elif event.button == 3:
-            self.emit("focus-day", 2)
-
-    def _init_events(self):
-        for w in self.view:
-            if not w == pinbox:
-                self.view.remove(w)
-        for period in self._periods:
-            part = DayPartWidget(period[0], period[1], period[2])
-            self.view.pack_start(part, False, False)
-
-
-class CategoryBox(gtk.HBox):
-
-    def __init__(self, category, events, pinnable = False):
-        super(CategoryBox, self).__init__()
-        self.view = gtk.VBox(True)
-        self.vbox = gtk.VBox()
-        for event in events:
-            item = Item(event, pinnable)
-            hbox = gtk.HBox ()
-            #label = gtk.Label("")
-            #hbox.pack_start(label, False, False, 7)
-            hbox.pack_start(item, True, True, 0)
-            self.view.pack_start(hbox, False, False, 0)
-            hbox.show()
-            #label.show()
-
-        # If this isn't a set of ungrouped events, give it a label
-        if category:
-            # Place the items into a box and simulate left padding
-            self.box = gtk.HBox()
-            #label = gtk.Label("")
-            self.box.pack_start(self.view)
-
-            hbox = gtk.HBox()
-            # Add the title button
-            if category in SUPPORTED_SOURCES:
-                text = SUPPORTED_SOURCES[category].group_label(len(events))
-            else:
-                text = "Unknown"
-
-            label = gtk.Label()
-            label.set_markup("<span>%s</span>" % text)
-            #label.set_ellipsize(pango.ELLIPSIZE_END)
-
-            hbox.pack_start(label, True, True, 0)
-
-            label = gtk.Label()
-            label.set_markup("<span>(%d)</span>" % len(events))
-            label.set_alignment(1.0,0.5)
-            label.set_alignment(1.0,0.5)
-            hbox.pack_end(label, False, False, 2)
-
-            hbox.set_border_width(3)
-
-            self.expander = gtk.Expander()
-            self.expander.set_label_widget(hbox)
-
-            self.vbox.pack_start(self.expander, False, False)
-            self.expander.add(self.box)#
-
-            self.pack_start(self.vbox, True, True, 24)
-
-            self.expander.show_all()
-            self.show()
-            hbox.show_all()
-            label.show_all()
-            self.view.show()
-
-        else:
-            self.box = self.view
-            self.vbox.pack_end(self.box)
-            self.box.show()
-            self.show()
-
-            self.pack_start(self.vbox, True, True, 16)
-
-        self.show_all()
-
-    def on_toggle(self, view, bool):
-        if bool:
-            self.box.show()
-        else:
-            self.box.hide()
-        pinbox.show_all()
-
-
-class DayLabel(gtk.DrawingArea):
-
-    _events = (
-        gtk.gdk.ENTER_NOTIFY_MASK | gtk.gdk.LEAVE_NOTIFY_MASK |
-        gtk.gdk.KEY_PRESS_MASK | gtk.gdk.BUTTON_MOTION_MASK |
-        gtk.gdk.POINTER_MOTION_HINT_MASK | gtk.gdk.BUTTON_RELEASE_MASK |
-        gtk.gdk.BUTTON_PRESS_MASK
-    )
-
-    def __init__(self, day, date):
-        if day == _("Today"):
-            self.leading = True
-        else:
-            self.leading = False
-        super(DayLabel, self).__init__()
-        self.date = date
-        self.day = day
-        self.set_events(self._events)
-        self.connect("expose_event", self.expose)
-        self.connect("enter-notify-event", self._on_enter)
-        self.connect("leave-notify-event", self._on_leave)
-
-    def _on_enter(self, widget, event):
-        widget.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.HAND2))
-
-    def _on_leave(self, widget, event):
-        widget.window.set_cursor(None)
-
-    def expose(self, widget, event):
-        context = widget.window.cairo_create()
-        self.context = context
-
-        bg = self.style.bg[0]
-        red, green, blue = bg.red/65535.0, bg.green/65535.0, bg.blue/65535.0
-        self.font_name = self.style.font_desc.get_family()
-
-        widget.style.set_background(widget.window, gtk.STATE_NORMAL)
-
-        # set a clip region for the expose event
-        context.rectangle(event.area.x, event.area.y, event.area.width, event.area.height)
-        context.clip()
-        self.draw(widget, event, context)
-        self.day_text(widget, event, context)
-        return False
-
-    def day_text(self, widget, event, context):
-        actual_y = self.get_size_request()[1]
-        if actual_y > event.area.height:
-            y = actual_y
-        else:
-            y = event.area.height
-        x = event.area.width
-        gc = self.style.fg_gc[gtk.STATE_SELECTED if self.leading else gtk.STATE_NORMAL]
-        layout = widget.create_pango_layout(self.day)
-        layout.set_font_description(pango.FontDescription(self.font_name + " Bold 15"))
-        w, h = layout.get_pixel_size()
-        widget.window.draw_layout(gc, (x-w)/2, (y)/2 - h + 5, layout)
-        self.date_text(widget, event, context, (y)/2 + 5)
-
-    def date_text(self, widget, event, context, lastfontheight):
-        gc = self.style.fg_gc[gtk.STATE_SELECTED if self.leading else gtk.STATE_INSENSITIVE]
-        layout = widget.create_pango_layout(self.date)
-        layout.set_font_description(pango.FontDescription(self.font_name + " 10"))
-        w, h = layout.get_pixel_size()
-        widget.window.draw_layout(gc, (event.area.width-w)/2, lastfontheight, layout)
-
-    def draw(self, widget, event, context):
-        if self.leading:
-            bg = self.style.bg[gtk.STATE_SELECTED]
-            red, green, blue = bg.red/65535.0, bg.green/65535.0, bg.blue/65535.0
-        else:
-            bg = self.style.bg[gtk.STATE_NORMAL]
-            red = (bg.red * 125 / 100)/65535.0
-            green = (bg.green * 125 / 100)/65535.0
-            blue = (bg.blue * 125 / 100)/65535.0
-        x = 0; y = 0
-        r = 5
-        w, h = event.area.width, event.area.height
-        context.set_source_rgba(red, green, blue, 1)
-        context.new_sub_path()
-        context.arc(r+x, r+y, r, math.pi, 3 * math.pi /2)
-        context.arc(w-r, r+y, r, 3 * math.pi / 2, 0)
-        context.close_path()
-        context.rectangle(0, r, w, h)
-        context.fill_preserve()
-
-
-class DayButton(gtk.DrawingArea):
-    leading = False
-    pressed = False
-    sensitive = True
-    hover = False
-    header_size = 60
-    bg_color = (0, 0, 0, 0)
-    header_color = (1, 1, 1, 1)
-    leading_header_color = (1, 1, 1, 1)
-    internal_color = (0, 1, 0, 1)
-    arrow_color = (1,1,1,1)
-    arrow_color_selected = (1, 1, 1, 1)
-
-    __gsignals__ = {
-        "clicked":  (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,()),
-        }
-    _events = (
-        gtk.gdk.ENTER_NOTIFY_MASK | gtk.gdk.LEAVE_NOTIFY_MASK |
-        gtk.gdk.KEY_PRESS_MASK | gtk.gdk.BUTTON_RELEASE_MASK | gtk.gdk.BUTTON_PRESS_MASK |
-        gtk.gdk.MOTION_NOTIFY |   gtk.gdk.POINTER_MOTION_MASK
-    )
-    def __init__(self, side = 0, leading = False):
-        super(DayButton, self).__init__()
-        self.set_events(self._events)
-        self.set_flags(gtk.CAN_FOCUS)
-        self.leading = leading
-        self.side = side
-        self.connect("button_press_event", self.on_press)
-        self.connect("button_release_event", self.clicked_sender)
-        self.connect("key_press_event", self.keyboard_clicked_sender)
-        self.connect("motion_notify_event", self.on_hover)
-        self.connect("leave_notify_event", self._enter_leave_notify, False)
-        self.connect("expose_event", self.expose)
-        self.connect("style-set", self.change_style)
-        self.set_size_request(20, -1)
-
-    def set_sensitive(self, case):
-        self.sensitive = case
-        self.queue_draw()
-
-    def _enter_leave_notify(self, widget, event, bol):
-        self.hover = bol
-        self.queue_draw()
-
-    def on_hover(self, widget, event):
-        if event.y > self.header_size:
-            if not self.hover:
-                self.hover = True
-                self.queue_draw()
-        else:
-            if self.hover:
-                self.hover = False
-                self.queue_draw()
-        return False
-
-    def on_press(self, widget, event):
-        if event.y > self.header_size:
-            self.pressed = True
-            self.queue_draw()
-
-    def keyboard_clicked_sender(self, widget, event):
-        if event.keyval in (gtk.keysyms.Return, gtk.keysyms.space):
-            if self.sensitive:
-                self.emit("clicked")
-            self.pressed = False
-            self.queue_draw()
-            return True
-        return False
-
-    def clicked_sender(self, widget, event):
-        if event.y > self.header_size:
-            if self.sensitive:
-                self.emit("clicked")
-        self.pressed = False
-        self.queue_draw()
-        return True
-
-    def change_style(self, *args, **kwargs):
-        self.bg_color = get_gtk_rgba(self.style, "bg", 0)
-        self.header_color = get_gtk_rgba(self.style, "bg", 0, 1.25)
-        self.leading_header_color = get_gtk_rgba(self.style, "bg", 3)
-        self.internal_color = get_gtk_rgba(self.style, "bg", 0, 1.02)
-        self.arrow_color = get_gtk_rgba(self.style, "text", 0, 0.6)
-        self.arrow_color_selected = get_gtk_rgba(self.style, "bg", 3)
-        self.arrow_color_insensitive = get_gtk_rgba(self.style, "text", 4)
-
-    def expose(self, widget, event):
-        context = widget.window.cairo_create()
-
-        context.set_source_rgba(*self.bg_color)
-        context.set_operator(cairo.OPERATOR_SOURCE)
-        context.paint()
-        context.rectangle(event.area.x, event.area.y, event.area.width, event.area.height)
-        context.clip()
-
-        x = 0; y = 0
-        r = 5
-        w, h = event.area.width, event.area.height
-        size = 20
-        if self.sensitive:
-            context.set_source_rgba(*(self.leading_header_color if self.leading else self.header_color))
-            context.new_sub_path()
-            context.move_to(x+r,y)
-            context.line_to(x+w-r,y)
-            context.curve_to(x+w,y,x+w,y,x+w,y+r)
-            context.line_to(x+w,y+h-r)
-            context.curve_to(x+w,y+h,x+w,y+h,x+w-r,y+h)
-            context.line_to(x+r,y+h)
-            context.curve_to(x,y+h,x,y+h,x,y+h-r)
-            context.line_to(x,y+r)
-            context.curve_to(x,y,x,y,x+r,y)
-            context.set_source_rgba(*(self.leading_header_color if self.leading else self.header_color))
-            context.close_path()
-            context.rectangle(0, r, w,  self.header_size)
-            context.fill()
-            context.set_source_rgba(*self.internal_color)
-            context.rectangle(0, self.header_size, w,  h)
-            context.fill()
-            if self.hover:
-                widget.style.paint_box(widget.window, gtk.STATE_PRELIGHT, gtk.SHADOW_OUT,
-                                         event.area, widget, "button",
-                                         event.area.x, self.header_size,
-                                         w, h-self.header_size)
-        size = 10
-        if not self.sensitive:
-            state = gtk.STATE_INSENSITIVE
-        elif self.is_focus() or self.pressed:
-            widget.style.paint_focus(widget.window, gtk.STATE_ACTIVE, event.area,
-                                     widget, None, event.area.x, self.header_size,
-                                     w, h-self.header_size)
-            state = gtk.STATE_SELECTED
-        else:
-            state = gtk.STATE_NORMAL
-        arrow = gtk.ARROW_RIGHT if self.side else gtk.ARROW_LEFT
-        self.style.paint_arrow(widget.window, state, gtk.SHADOW_NONE, None,
-                               self, "arrow", arrow, True,
-                               w/2-size/2, h/2 + size/2, size, size)
-
-
-class EventGroup(gtk.VBox):
-
-    def __init__(self, title):
-        super(EventGroup, self).__init__()
-
-        # Create the title label
-        self.label = gtk.Label(title)
-        self.label.set_alignment(0.03, 0.5)
-        self.pack_start(self.label, False, False, 6)
-        self.events = []
-        # Create the main container
-        self.view = gtk.VBox()
-        self.pack_start(self.view)
-
-        # Connect to relevant signals
-        self.connect("style-set", self.on_style_change)
-
-        # Populate the widget with content
-        self.get_events()
-
-    def on_style_change(self, widget, style):
-        """ Update used colors according to the system theme. """
-        color = self.style.bg[gtk.STATE_NORMAL]
-        fcolor = self.style.fg[gtk.STATE_NORMAL]
-        color = combine_gdk_color(color, fcolor)
-        self.label.modify_fg(gtk.STATE_NORMAL, color)
-
-    @staticmethod
-    def event_exists(uri):
-        # TODO: Move this into Zeitgeist's datamodel.py
-        return not uri.startswith("file://") or os.path.exists(
-            urllib.unquote(str(uri[7:])))
-
-    def set_events(self, events):
-        self.events = []
-        for widget in self.view:
-            self.view.remove(widget)
-
-        if self == pinbox:
-            box = CategoryBox(None, events, True)
-            self.view.pack_start(box)
-        else:
-            categories = {}
-            for event in events:
-                subject = event.subjects[0]
-                if self.event_exists(subject.uri):
-                    if not categories.has_key(subject.interpretation):
-                        categories[subject.interpretation] = []
-                    categories[subject.interpretation].append(event)
-                    self.events.append(event)
-
-            if not categories:
-                self.hide_all()
-            else:
-                # Make the group title, etc. visible
-                self.show_all()
-
-                ungrouped_events = []
-                for key in sorted(categories.iterkeys()):
-                    events = categories[key]
-                    if len(events) > 3:
-                        box = CategoryBox(key, list(reversed(events)))
-                        self.view.pack_start(box)
-                    else:
-                        ungrouped_events += events
-
-                ungrouped_events.sort(key=lambda x: x.timestamp)
-                box = CategoryBox(None, ungrouped_events)
-                self.view.pack_start(box)
-
-                # Make the group's contents visible
-                self.view.show()
-                pinbox.show_all()
-
-        if len(self.events) == 0:
-            self.hide()
-        else:
-            self.show()
-
-    def get_events(self, *discard):
-        if self.event_templates and len(self.event_templates) > 0:
-            CLIENT.find_events_for_templates(self.event_templates,
-                self.set_events, self.event_timerange, num_events=50000,
-                result_type=ResultType.MostRecentSubjects)
-        else:
-            self.view.hide()
-
-
-class DayPartWidget(EventGroup):
-
-    def __init__(self, title, start, end):
-        # Setup event criteria for querying
-        self.event_timerange = [start * 1000, end * 1000]
-        self.event_templates = (
-            Event.new_for_values(interpretation=Interpretation.VISIT_EVENT.uri),
-            Event.new_for_values(interpretation=Interpretation.MODIFY_EVENT.uri),
-            Event.new_for_values(interpretation=Interpretation.CREATE_EVENT.uri),
-            Event.new_for_values(interpretation=Interpretation.OPEN_EVENT.uri),
-        )
-
-        # Initialize the widget
-        super(DayPartWidget, self).__init__(title)
-
-        # FIXME: Move this into EventGroup
-        CLIENT.install_monitor(self.event_timerange, self.event_templates,
-            self.notify_insert_handler, self.notify_delete_handler)
-
-    def notify_insert_handler(self, time_range, events):
-        # FIXME: Don't regenerate everything, we already get the
-        # information we need
-        self.get_events()
-
-    def notify_delete_handler(self, time_range, event_ids):
-        # FIXME: Same as above
-        self.get_events()
-
-class PinBox(EventGroup):
-
-    def __init__(self):
-        # Setup event criteria for querying
-        self.event_timerange = TimeRange.until_now()
-
-        # Initialize the widget
-        super(PinBox, self).__init__(_("Pinned items"))
-
-        # Connect to relevant signals
-        bookmarker.connect("reload", self.get_events)
-
-    @property
-    def event_templates(self):
-        if not bookmarker.bookmarks:
-            # Abort, or we will query with no templates and get lots of
-            # irrelevant events.
-            return None
-
-        templates = []
-        for bookmark in bookmarker.bookmarks:
-            templates.append(Event.new_for_values(subject_uri=bookmark))
-        return templates
-
-    def set_events(self, *args, **kwargs):
-        super(PinBox, self).set_events(*args, **kwargs)
-        # Make the pin icons visible
-        self.view.show_all()
-        self.show_all()
-
-pinbox = PinBox()
 
=== removed file 'src/eventgatherer.py'
--- src/eventgatherer.py	2010-04-07 03:17:49 +0000
+++ src/eventgatherer.py	1970-01-01 00:00:00 +0000
@@ -1,224 +0,0 @@
-# -.- coding: utf-8 -.-
-#
-# GNOME Activity Journal
-#
-# Copyright © 2010 Seif Lotfy <[e-mail]>
-# Copyright © 2010 Siegfried Gevatter <[e-mail]>
-#
-# 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, or
-# (at your option) any later version.
-#
-# 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, see <http://www.gnu.org/licenses/>.
-
-import time
-from datetime import timedelta, datetime
-import gtk
-import random
-import os
-import urllib
-from zeitgeist.client import ZeitgeistClient
-from zeitgeist.datamodel import Event, Subject, Interpretation, Manifestation, \
-     ResultType, TimeRange, StorageState
-
-CLIENT = ZeitgeistClient()
-
-event_templates = (
-    Event.new_for_values(interpretation=Interpretation.VISIT_EVENT.uri),
-    Event.new_for_values(interpretation=Interpretation.MODIFY_EVENT.uri),
-    Event.new_for_values(interpretation=Interpretation.CREATE_EVENT.uri),
-    Event.new_for_values(interpretation=Interpretation.OPEN_EVENT.uri),
-    Event.new_for_values(interpretation=Interpretation.CLOSE_EVENT.uri),
-)
-
-EVENTS = {}
-
-def event_exists(uri):
-    # TODO: Move this into Zeitgeist's datamodel.py
-    if uri.startswith("trash://"):
-        return False
-    return not uri.startswith("file://") or os.path.exists(
-        urllib.unquote(str(uri[7:])))
-
-def get_dayevents(start, end, result_type, callback, force = False):
-    """
-    :param start: a int time from which to start gathering events in milliseconds
-    :param end: a int time from which to stop gathering events in milliseconds
-    :callback: a callable to be called when the query is done
-    """
-    def handle_find_events(events):
-        results = {}
-        for event in events:
-            uri = event.subjects[0].uri
-            if not event.subjects[0].uri in results:
-                results[uri] = []
-            if not event.interpretation == Interpretation.CLOSE_EVENT.uri:
-                results[uri].append([event, 0])
-            else:
-                if not len(results[uri]) == 0:
-                    #print "***", results[uri]
-                    results[uri][len(results[uri])-1][1] = (int(event.timestamp)) -  int(results[uri][-1][0].timestamp)
-                else:
-                    tend = int(event.timestamp)
-                    event.timestamp = str(start)
-                    results[uri].append([event, tend - start])
-        events = list(sorted(results.itervalues(), key=lambda r: \
-                             r[0][0].timestamp))
-        EVENTS[start+end] = events
-        callback(events)
-
-    def notify_insert_handler_morning(timerange, events):
-        find_events()
-
-    def find_events():
-        event_templates = []
-        CLIENT.find_events_for_templates(event_templates, handle_find_events,
-                                         [start, end], num_events=50000,
-                                         result_type=result_type)
-
-    if not EVENTS.has_key(start+end) or force:
-        find_events()
-        event_timerange = [start, end]
-        event_templates = (
-            Event.new_for_values(interpretation=Interpretation.VISIT_EVENT.uri),
-            Event.new_for_values(interpretation=Interpretation.MODIFY_EVENT.uri),
-            Event.new_for_values(interpretation=Interpretation.CREATE_EVENT.uri),
-            Event.new_for_values(interpretation=Interpretation.OPEN_EVENT.uri),
-        )
-        # FIXME: Move this into EventGroup
-
-        CLIENT.install_monitor([start, end], event_templates,
-                               notify_insert_handler_morning, notify_insert_handler_morning)
-
-
-
-    else:
-        callback(EVENTS[start+end])
-
-
-
-def get_file_events(start, end, callback, force = False):
-    """
-    :param start: a int time from which to start gathering events in milliseconds
-    :param end: a int time from which to stop gathering events in milliseconds
-    :callback: a callable to be called when the query is done
-    """
-
-    def handle_find_events(events):
-        results = {}
-        for event in events:
-            uri = event.subjects[0].uri
-            if not event.subjects[0].uri in results:
-                results[uri] = []
-            results[uri].append(event)
-        events = [result[0] for result in results.values()]
-        EVENTS[start+end] = events
-        callback(events)
-
-    def notify_insert_handler_morning(timerange, events):
-        find_events()
-
-    event_templates = (
-            #Event.new_for_values(interpretation=Interpretation.VISIT_EVENT.uri),
-            #Event.new_for_values(interpretation=Interpretation.MODIFY_EVENT.uri),
-            #Event.new_for_values(interpretation=Interpretation.CREATE_EVENT.uri),
-            #Event.new_for_values(interpretation=Interpretation.OPEN_EVENT.uri),
-        )
-
-    def find_events():
-        CLIENT.find_events_for_templates(event_templates, handle_find_events,
-                                         [start, end], num_events=50000,
-                                         result_type=ResultType.LeastRecentEvents)
-
-    if not EVENTS.has_key(start+end) or force:
-        find_events()
-        event_timerange = [start, end]
-
-        # FIXME: Move this into EventGroup
-
-        CLIENT.install_monitor([start, end], event_templates,
-                               notify_insert_handler_morning, notify_insert_handler_morning)
-
-
-
-    else:
-        callback(EVENTS[start+end])
-
-
-def datelist(n, callback):
-    """
-    :param n: number of days to query
-    :callback: a callable to be called when the query is done
-    """
-    event_templates = (
-        Event.new_for_values(interpretation=Interpretation.VISIT_EVENT.uri,
-                             storage_state=StorageState.Available),
-        Event.new_for_values(interpretation=Interpretation.MODIFY_EVENT.uri,
-                             storage_state=StorageState.Available),
-        Event.new_for_values(interpretation=Interpretation.CREATE_EVENT.uri,
-                             storage_state=StorageState.Available),
-        Event.new_for_values(interpretation=Interpretation.OPEN_EVENT.uri,
-                             storage_state=StorageState.Available),
-        Event.new_for_values(interpretation=Interpretation.CLOSE_EVENT.uri,
-                             storage_state=StorageState.Available),
-    )
-    if n == -1:
-        n = int(time.time()/86400)
-    today = int(time.mktime(time.strptime(time.strftime("%d %B %Y"),
-                                          "%d %B %Y")))
-    today = today - n*86400
-
-    x = []
-
-    def _handle_find_events(ids):
-        x.append((today+len(x)*86400, len(ids)))
-        if len(x) == n+1:
-            callback(x)
-
-    def get_ids(start, end):
-        CLIENT.find_event_ids_for_templates(event_templates,
-                                            _handle_find_events, [start * 1000, end * 1000],
-                                            num_events=50000,
-                                            result_type=0,)
-
-    for i in xrange(n+1):
-        get_ids(today+i*86400, today+i*86400+86399)
-
-
-def get_related_events_for_uri(uri, callback):
-    """
-    :param uri: A uri for which to request related uris using zetigeist
-    :param callback: this callback is called once the events are retrieved for
-    the uris. It is called with a list of events.
-    """
-    def _event_request_handler(uris):
-        """
-        :param uris: a list of uris which are related to the windows current uri
-        Seif look here
-        """
-        templates = []
-        if len(uris) > 0:
-            for i, uri in enumerate(uris):
-                templates += [
-                        Event.new_for_values(interpretation=Interpretation.VISIT_EVENT.uri, subject_uri=uri),
-                        Event.new_for_values(interpretation=Interpretation.MODIFY_EVENT.uri, subject_uri=uri),
-                        Event.new_for_values(interpretation=Interpretation.CREATE_EVENT.uri, subject_uri=uri),
-                        Event.new_for_values(interpretation=Interpretation.OPEN_EVENT.uri, subject_uri=uri)
-                    ]
-            CLIENT.find_events_for_templates(templates, callback,
-                                             [0, time.time()*1000], num_events=50000,
-                                             result_type=ResultType.MostRecentSubjects)
-
-    end = time.time() * 1000
-    start = end - (86400*30*1000)
-    CLIENT.find_related_uris_for_uris([uri], _event_request_handler)
-
-
-
 
=== added file 'src/histogram.py'
--- src/histogram.py	1970-01-01 00:00:00 +0000
+++ src/histogram.py	2010-05-04 05:28:16 +0000
@@ -0,0 +1,532 @@
+# -.- coding: utf-8 -.-
+#
+# GNOME Activity Journal
+#
+# Copyright © 2010 Randal Barlow <[e-mail]>
+# Copyright © 2010 Markus Korn
+# Copyright © 2010 Siegfried Gevatter <[e-mail]>
+#
+# 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, or
+# (at your option) any later version.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+
+import datetime
+import cairo
+import calendar
+import gettext
+import gobject
+import gtk
+from math import pi as PI
+import pango
+from common import *
+
+
+def get_gc_from_colormap(widget, shade):
+    """
+    Gets a gtk.gdk.GC and modifies the color by shade
+    """
+    gc = widget.style.text_gc[gtk.STATE_INSENSITIVE]
+    if gc:
+        color = widget.style.text[4]
+        color = shade_gdk_color(color, shade)
+        gc.set_rgb_fg_color(color)
+    return gc
+
+
+class CairoHistogram(gtk.DrawingArea):
+    """
+    A histogram which is represented by a list of dates, and nitems.
+
+    There are a few maintenance issues due to the movement abilities. The widget
+    currently is able to capture motion events when the mouse is outside
+    the widget and the button is pressed if it was initially pressed inside
+    the widget. This event mask magic leaves a few flaws open.
+    """
+    _selected = (0,)
+    padding = 2
+    bottom_padding = 23
+    top_padding = 2
+    wcolumn = 12
+    xincrement = wcolumn + padding
+    start_x_padding = 2
+    max_width = xincrement
+    column_radius = 0
+    stroke_width = 1
+    stroke_offset = 0
+    min_column_height = 4
+    max_column_height = 101
+    gc = None
+    pangofont = None
+    _disable_mouse_motion = False
+    selected_range = 0
+    _highlighted = tuple()
+    _last_location = -1
+    _single_day_only = False
+    colors = {
+        "bg" : (1, 1, 1, 1),
+        "base" : (1, 1, 1, 1),
+        "column_normal" :  (1, 1, 1, 1),
+        "column_selected" : (1, 1, 1, 1),
+        "column_alternative" : (1, 1, 1, 1),
+        "column_selected_alternative" : (1, 1, 1, 1),
+        "font_color" : "#ffffff",
+        "stroke" : (1, 1, 1, 0),
+        "shadow" : (1, 1, 1, 0),
+        }
+
+    _store = None
+
+    __gsignals__ = {
+        "selection-set" : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                           (gobject.TYPE_PYOBJECT,)),
+        "data-updated" : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,()),
+        "column_clicked" : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                            (gobject.TYPE_PYOBJECT,))
+        }
+    _connections = {"style-set": "change_style",
+                       "expose_event": "_expose",
+                       "button_press_event": "mouse_press_interaction",
+                       "motion_notify_event": "mouse_motion_interaction",
+                       "key_press_event": "keyboard_interaction",
+                       "scroll-event" : "mouse_scroll_interaction",
+                       }
+    _events = (gtk.gdk.KEY_PRESS_MASK | gtk.gdk.BUTTON_MOTION_MASK |
+                  gtk.gdk.POINTER_MOTION_HINT_MASK | gtk.gdk.BUTTON_RELEASE_MASK |
+                  gtk.gdk.BUTTON_PRESS_MASK)
+
+    def __init__(self):
+        """
+        :param datastore: The.CairoHistograms two dimensional list of dates and nitems
+        :param selected_range: the number of days displayed at once
+        """
+        super(CairoHistogram, self).__init__()
+        self._selected = []
+        self.set_events(self._events)
+        self.set_flags(gtk.CAN_FOCUS)
+        for key, val in self._connections.iteritems():
+            self.connect(key, getattr(self, val))
+        self.font_name = self.style.font_desc.get_family()
+
+    def change_style(self, widget, old_style):
+        """
+        Sets the widgets style and coloring
+        """
+        self.colors = self.colors.copy()
+        self.colors["bg"] = get_gtk_rgba(self.style, "bg", 0)
+        self.colors["base"] = get_gtk_rgba(self.style, "base", 0)
+        self.colors["column_normal"] =  get_gtk_rgba(self.style, "text", 4, 1.17)
+        self.colors["column_selected"] = get_gtk_rgba(self.style, "bg", 3)
+        color = self.style.bg[gtk.STATE_NORMAL]
+        fcolor = self.style.fg[gtk.STATE_NORMAL]
+        self.colors["font_color"] = combine_gdk_color(color, fcolor).to_string()
+
+        pal = get_gtk_rgba(self.style, "bg", 3, 1.2)
+        self.colors["column_alternative"] = (pal[2], pal[1], pal[0], 1)
+        self.colors["column_selected_alternative"] = get_gtk_rgba(self.style, "bg", 3, 0.6)
+        self.colors["stroke"] = get_gtk_rgba(self.style, "text", 4)
+        self.colors["shadow"] = get_gtk_rgba(self.style, "text", 4)
+        self.font_size = self.style.font_desc.get_size()/1024
+        self.pangofont = pango.FontDescription(self.font_name + " %d" % self.font_size)
+        self.pangofont.set_weight(pango.WEIGHT_BOLD)
+        self.bottom_padding = self.font_size + 9 + widget.style.ythickness
+        self.gc = get_gc_from_colormap(widget, 0.6)
+
+    def set_store(self, store):
+        if self._store:
+            self._store.disconnect(self._store_connection)
+        self._store = store
+        self.largest = min(max(max(map(lambda x: len(x), store.days)), 1), 100)
+        if not self.get_selected():
+            self.set_selected([datetime.date.today()])
+        self._store_connection = store.connect("update", self.set_store)
+
+    def get_store(self):
+        return self._store
+
+    def _expose(self, widget, event):
+        """
+        The major drawing method that the expose event calls directly
+        """
+        widget.style.set_background(widget.window, gtk.STATE_NORMAL)
+        context = widget.window.cairo_create()
+        self.expose(widget, event, context)
+
+    def expose(self, widget, event, context):
+        """
+        The minor drawing method
+
+        :param event: a gtk event with x and y values
+        :param context: This drawingarea's cairo context from the expose event
+        """
+        if not self.pangofont:
+            self.pangofont = pango.FontDescription(self.font_name + " %d" % self.font_size)
+            self.pangofont.set_weight(pango.WEIGHT_BOLD)
+        if not self.gc:
+            self.gc = get_gc_from_colormap(widget, 0.6)
+        context.set_source_rgba(*self.colors["base"])
+        context.set_operator(cairo.OPERATOR_SOURCE)
+        #context.paint()
+        context.rectangle(event.area.x, event.area.y, event.area.width, event.area.height)
+        context.clip()
+        #context.set_source_rgba(*self.colors["bg"])
+        context.rectangle(event.area.x, event.area.y, event.area.width, event.area.height - self.bottom_padding)
+        context.fill()
+        self.draw_columns_from_store(context, event, self.get_selected())
+        context.set_line_width(1)
+        if type(self) == CairoHistogram:
+            widget.style.paint_shadow(widget.window, gtk.STATE_NORMAL, gtk.SHADOW_IN,
+                                      event.area, widget, "treeview", event.area.x, event.area.y,
+                                      event.area.width, event.area.height - self.bottom_padding)
+        if self.is_focus():
+            widget.style.paint_focus(widget.window, gtk.STATE_NORMAL, event.area, widget, None, event.area.x, event.area.y,
+                                     event.area.width, event.area.height - self.bottom_padding)
+
+    def draw_columns_from_store(self, context, event, selected):
+        """
+        Draws columns from a datastore
+
+        :param context: This drawingarea's cairo context from the expose event
+        :param event: a gtk event with x and y values
+        :param selected: a list of the selected dates
+        """
+        x = self.start_x_padding
+        months_positions = []
+        for day in self.get_store().days:
+            if day.date.day == 1:
+                months_positions += [(day.date, x)]
+            if day.date in self._highlighted:
+                color = self.colors["column_selected_alternative"] if day.date in selected else self.colors["column_alternative"]
+            elif not selected:
+                color = self.colors["column_normal"]
+            if day.date in selected:
+                color = self.colors["column_selected"]
+            else:
+                color = self.colors["column_normal"]
+            self.draw_column(context, x, event.area.height, len(day), color)
+            x += self.xincrement
+        if x > event.area.width: # Check for resize
+            self.set_size_request(x+self.xincrement, event.area.height)
+        for date, xpos in months_positions:
+            edge = 0
+            if (date, xpos) == months_positions[-1]:
+                edge = len(self._store)*self.xincrement
+            self.draw_month(context, xpos - self.padding, event.area.height, date, edge)
+        self.max_width = x # remove me
+
+    def draw_column(self, context, x, maxheight, nitems, color):
+        """
+        Draws a columns at x with height based on nitems, and maxheight
+
+        :param context: The drawingarea's cairo context from the expose event
+        :param x: The current position in the image
+        :param maxheight: The event areas height
+        :param nitems: The number of items in the column to be drawn
+        :param color: A RGBA tuple Example: (0.3, 0.4, 0.8, 1)
+        """
+        if nitems < 2:
+            nitems = 2
+        elif nitems > self.max_column_height:
+            nitems = self.max_column_height
+        maxheight = maxheight - self.bottom_padding - 2
+        #height = int((maxheight-self.top_padding-2) * (self.largest*math.log(nitems)/math.log(self.largest))/100)
+        height = int(((float(nitems)/self.largest)*(maxheight-2))) - self.top_padding
+        #height = min(int((maxheight*self.largest/100) * (1 - math.e**(-0.025*nitems))), maxheight)
+        if height < self.min_column_height:
+            height = self.min_column_height
+        y = maxheight - height
+        context.set_source_rgba(*color)
+        context.move_to(x + self.column_radius, y)
+        context.new_sub_path()
+        if nitems > 4:
+            context.arc(self.column_radius + x, self.column_radius + y, self.column_radius, PI, 3 * PI /2)
+            context.arc(x + self.wcolumn - self.column_radius, self.column_radius + y, self.column_radius, 3 * PI / 2, 0)
+            context.rectangle(x, y + self.column_radius, self.wcolumn, height - self.column_radius)
+        else:
+            context.rectangle(x, y, self.wcolumn, height)
+        context.close_path()
+        context.fill()
+
+    def draw_month(self, context, x, height, date, edge=0):
+        """
+        Draws a line signifying the start of a month
+        """
+        context.set_source_rgba(*self.colors["stroke"])
+        context.set_line_width(self.stroke_width)
+        context.move_to(x+self.stroke_offset, 0)
+        context.line_to(x+self.stroke_offset, height - self.bottom_padding)
+        context.stroke()
+        month = calendar.month_name[date.month]
+        date = "<span color='%s'>%s %d</span>" % (self.colors["font_color"], month, date.year)
+        layout = self.create_pango_layout(date)
+        layout.set_markup(date)
+        layout.set_font_description(self.pangofont)
+        w, h = layout.get_pixel_size()
+        if edge:
+            if x + w > edge: x = edge - w - 5
+        self.window.draw_layout(self.gc, int(x + 3), int(height - self.bottom_padding/2 - h/2), layout)
+
+    def set_selected(self, dates):
+        if dates == self._selected:
+            return False
+        self._selected = dates
+        if dates:
+            date = dates[-1]
+        self.emit("selection-set", dates)
+        self.queue_draw()
+        return True
+
+    def get_selected(self):
+        """
+        returns a list of selected indices
+        """
+        return self._selected
+
+    def clear_selection(self):
+        """
+        clears the selected items
+        """
+        self._selected = []
+        self.queue_draw()
+
+    def set_highlighted(self, highlighted):
+        """
+        Sets the widgets which should be highlighted with an alternative color
+
+        :param highlighted: a list of indexes to be highlighted
+        """
+        if isinstance(highlighted, list):
+            self._highlighted = highlighted
+        else: raise TypeError("highlighted is not a list")
+        self.queue_draw()
+
+    def clear_highlighted(self):
+        """Clears the highlighted color"""
+        self._highlighted = []
+        self.queue_draw()
+
+    def set_single_day(self, choice):
+        """
+        Allows the cal to enter a mode where the trailing days are not selected but still kept
+        """
+        self._single_day_only = choice
+        self.queue_draw()
+
+    def get_store_index_from_cartesian(self, x, y):
+        """
+        Gets the datastore index from a x, y value
+        """
+        return int((x - self.start_x_padding) / self.xincrement)
+
+    def keyboard_interaction(self, widget, event):
+        if event.keyval in (gtk.keysyms.space, gtk.keysyms.Right, gtk.keysyms.Left, gtk.keysyms.BackSpace):
+            i = self.get_selected()
+            if isinstance(i, list) and len(i) > 0: i = i[-1]
+            if event.keyval in (gtk.keysyms.space, gtk.keysyms.Right):
+                i = i + datetime.timedelta(days=1)
+            elif event.keyval in (gtk.keysyms.Left, gtk.keysyms.BackSpace):
+                i = i + datetime.timedelta(days=-1)
+            if i < datetime.date.today() + datetime.timedelta(days=1):
+                self.change_location(i)
+
+    def mouse_motion_interaction(self, widget, event, *args, **kwargs):
+        """
+        Reacts to mouse moving (while pressed), and clicks
+        """
+        #if (event.state == gtk.gdk.BUTTON1_MASK and not self._disable_mouse_motion):
+        location = min((self.get_store_index_from_cartesian(event.x, event.y), len(self._store.days) - 1))
+        if location != self._last_location:
+            self.change_location(location)
+            self._last_location = location
+            #return True
+        return False
+
+    def mouse_press_interaction(self, widget, event, *args, **kwargs):
+        if (event.y > self.get_size_request()[1] - self.bottom_padding and
+            event.y < self.get_size_request()[1]):
+            return False
+        location = min((self.get_store_index_from_cartesian(event.x, event.y), len(self._store.days) - 1))
+        if location != self._last_location:
+            self.change_location(location)
+            self._last_location = location
+        return True
+
+    def mouse_scroll_interaction(self, widget, event):
+        date = self.get_selected()[-1]
+        i = self.get_store().dates.index(date)
+        if (event.direction in (gtk.gdk.SCROLL_UP, gtk.gdk.SCROLL_RIGHT)):
+            if i+1< len(self.get_store().days):
+                self.change_location(i+1)
+        elif (event.direction in (gtk.gdk.SCROLL_DOWN, gtk.gdk.SCROLL_LEFT)):
+            if 0 <= i-1:
+                self.change_location(i-1)
+
+    def change_location(self, location):
+        """
+        Handles click events
+        """
+        if isinstance(location, int):
+            if location < 0:
+                return False
+            store = self.get_store()
+            date = store.days[location].date
+        else: date = location
+        self.emit("column_clicked", date)
+        return True
+
+
+def _in_area(coord_x, coord_y, area):
+    """check if some given X,Y coordinates are within an area.
+    area is either None or a (top_left_x, top_left_y, width, height)-tuple"""
+    if area is None:
+        return False
+    area_x, area_y, area_width, area_height = area
+    return (area_x <= coord_x <= area_x + area_width) and \
+        (area_y <= coord_y <= area_y + area_height)
+
+
+def _in_area(coord_x, coord_y, area):
+    """check if some given X,Y coordinates are within an area.
+    area is either None or a (top_left_x, top_left_y, width, height)-tuple"""
+    if area is None:
+        return False
+    area_x, area_y, area_width, area_height = area
+    return (area_x <= coord_x <= area_x + area_width) and \
+        (area_y <= coord_y <= area_y + area_height)
+
+
+class TooltipEventBox(gtk.EventBox):
+    """
+    A event box housing the tool tip logic that can be used for a CairoHistogram.
+    Otherwise it interferes with the scrubbing mask code
+    """
+    _saved_tooltip_location = None
+    def __init__(self, histogram, container):
+        super(TooltipEventBox, self).__init__()
+        self.add(histogram)
+        self.histogram = histogram
+        self.container = container
+        self.set_property("has-tooltip", True)
+        #self.connect("query-tooltip", self.query_tooltip)
+
+    def query_tooltip(self, widget, x, y, keyboard_mode, tooltip):
+        if y < self.histogram.get_size_request()[1] - self.histogram.bottom_padding:
+            location = self.histogram.get_store_index_from_cartesian(x, y)
+            if location != self._saved_tooltip_location:
+                # don't show the previous tooltip if we moved to another
+                # location
+                self._saved_tooltip_location = location
+                return False
+            try:
+                timestamp, count = self.histogram.get_store()[location]
+            except IndexError:
+                # there is no bar for at this location
+                # don't show a tooltip
+                return False
+            date = datetime.date.fromtimestamp(timestamp).strftime("%A, %d %B, %Y")
+            tooltip.set_text("%s\n%i %s" % (date, count,
+                                            gettext.ngettext("item", "items", count)))
+        else:
+            return False
+        return True
+
+
+class JournalHistogram(CairoHistogram):
+    """
+    A subclass of CairoHistogram with theming to fit into Journal
+    """
+    padding = 2
+    column_radius = 1.3
+    top_padding = 6
+    bottom_padding = 29
+    wcolumn = 10
+    xincrement = wcolumn + padding
+    column_radius = 2
+    stroke_width = 2
+    stroke_offset = 1
+    font_size = 12
+    min_column_height = 2
+
+    def change_style(self, widget, *args, **kwargs):
+        self.colors = self.colors.copy()
+        self.colors["bg"] = get_gtk_rgba(self.style, "bg", 0)
+        self.colors["color"] = get_gtk_rgba(self.style, "base", 0)
+        self.colors["column_normal"] =  get_gtk_rgba(self.style, "bg", 1)
+        self.colors["column_selected"] = get_gtk_rgba(self.style, "bg", 3)
+        self.colors["column_selected_alternative"] = get_gtk_rgba(self.style, "bg", 3, 0.7)
+        self.colors["column_alternative"] = get_gtk_rgba(self.style, "text", 2)
+        self.colors["stroke"] = get_gtk_rgba(self.style, "bg", 0)
+        self.colors["shadow"] = get_gtk_rgba(self.style, "bg", 0, 0.98)
+        self.font_size = self.style.font_desc.get_size()/1024
+        self.bottom_padding = self.font_size + 9 + widget.style.ythickness
+        self.gc = self.style.text_gc[gtk.STATE_NORMAL]
+        self.pangofont = pango.FontDescription(self.font_name + " %d" % self.font_size)
+        self.pangofont.set_weight(pango.WEIGHT_BOLD)
+
+
+class HistogramWidget(gtk.Viewport):
+    """
+    A container for a CairoHistogram which allows you to scroll
+    """
+    __gsignals__ = {
+        # the index of the first selected item in the datastore.
+        "date-changed" : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                           (gobject.TYPE_PYOBJECT,)),
+        }
+
+    def __init__(self, histo_type=CairoHistogram, size = (600, 75)):
+        """
+        :param histo_type: a :class:`CairoHistogram <CairoHistogram>` or a derivative
+        """
+        super(HistogramWidget, self).__init__()
+        self.set_shadow_type(gtk.SHADOW_NONE)
+        self.histogram = histo_type()
+        self.eventbox = TooltipEventBox(self.histogram, self)
+        self.set_size_request(*size)
+        self.add(self.eventbox)
+        self.histogram.connect("column_clicked", self.date_changed)
+        self.histogram.connect("selection-set", self.scrubbing_fix)
+        self.histogram.queue_draw()
+        self.queue_draw()
+
+    def date_changed(self, widget, date):
+        self.emit("date-changed", date)
+
+    def set_store(self, store):
+        self.histogram.set_store(store)
+        self.scroll_to_end()
+
+    def set_dates(self, dates):
+        self.histogram.set_selected(dates)
+
+    def scroll_to_end(self, *args, **kwargs):
+        """
+        Scroll to the end of the drawing area's viewport
+        """
+        hadjustment = self.get_hadjustment()
+        hadjustment.set_value(1)
+        hadjustment.set_value(self.histogram.max_width - hadjustment.page_size)
+
+    def scrubbing_fix(self, widget, dates):
+        """
+        Allows scrubbing to scroll the scroll window
+        """
+        if not len(dates):
+            return
+        store = widget.get_store()
+        i = store.dates.index(dates[0])
+        hadjustment = self.get_hadjustment()
+        proposed_xa = ((i) * self.histogram.xincrement) + self.histogram.start_x_padding
+        proposed_xb = ((i + len(dates)) * self.histogram.xincrement) + self.histogram.start_x_padding
+        if proposed_xa < hadjustment.value:
+            hadjustment.set_value(proposed_xa)
+        elif proposed_xb > hadjustment.value + hadjustment.page_size:
+            hadjustment.set_value(proposed_xb - hadjustment.page_size)
 
=== removed file 'src/histogram.py'
--- src/histogram.py	2010-04-15 14:34:37 +0000
+++ src/histogram.py	1970-01-01 00:00:00 +0000
@@ -1,625 +0,0 @@
-# -.- coding: utf-8 -.-
-#
-# GNOME Activity Journal
-#
-# Copyright © 2010 Randal Barlow <[e-mail]>
-# Copyright © 2010 Markus Korn
-# Copyright © 2010 Siegfried Gevatter <[e-mail]>
-#
-# 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, or
-# (at your option) any later version.
-#
-# 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, see <http://www.gnu.org/licenses/>.
-
-"""
-Takes a two dementional list of ints and turns it into a graph based on
-the first value a int date, and the second value the number of items on that date
-where items are
-datastore = []
-datastore.append(time, nitems)
-CairoHistogram.set_datastore(datastore)
-"""
-import datetime
-import cairo
-import calendar
-import gettext
-import gobject
-import gtk
-from math import pi as PI
-import pango
-from common import *
-
-
-def get_gc_from_colormap(widget, shade):
-    """
-    Gets a gtk.gdk.GC and modifies the color by shade
-    """
-    gc = widget.style.text_gc[gtk.STATE_INSENSITIVE]
-    if gc:
-        color = widget.style.text[4]
-        color = shade_gdk_color(color, shade)
-        gc.set_rgb_fg_color(color)
-    return gc
-
-
-class CairoHistogram(gtk.DrawingArea):
-    """
-    A histogram which is represented by a list of dates, and nitems.
-
-    There are a few maintenance issues due to the movement abilities. The widget
-    currently is able to capture motion events when the mouse is outside
-    the widget and the button is pressed if it was initially pressed inside
-    the widget. This event mask magic leaves a few flaws open.
-    """
-    _selected = (0,)
-    padding = 2
-    bottom_padding = 23
-    top_padding = 2
-    wcolumn = 12
-    xincrement = wcolumn + padding
-    start_x_padding = 2
-    max_width = xincrement
-    column_radius = 0
-    stroke_width = 1
-    stroke_offset = 0
-    min_column_height = 4
-    max_column_height = 101
-    gc = None
-    pangofont = None
-    _disable_mouse_motion = False
-    selected_range = 0
-    _highlighted = tuple()
-    _last_location = -1
-    _single_day_only = False
-    colors = {
-        "bg" : (1, 1, 1, 1),
-        "base" : (1, 1, 1, 1),
-        "column_normal" :  (1, 1, 1, 1),
-        "column_selected" : (1, 1, 1, 1),
-        "column_alternative" : (1, 1, 1, 1),
-        "column_selected_alternative" : (1, 1, 1, 1),
-        "font_color" : "#ffffff",
-        "stroke" : (1, 1, 1, 0),
-        "shadow" : (1, 1, 1, 0),
-        }
-
-    # Today button stuff
-    _today_width = 0
-    _today_text = ""
-    _today_area = None
-    _today_hover = False
-
-    _datastore = None
-    __gsignals__ = {
-        # the index of the first selected item in the datastore.
-        "selection-set" : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
-                           (gobject.TYPE_INT,gobject.TYPE_INT)),
-        "data-updated" : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,()),
-        "column_clicked" : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
-                            (gobject.TYPE_INT,))
-        }
-    _connections = {"style-set": "change_style",
-                       "expose_event": "_expose",
-                       "button_press_event": "mouse_press_interaction",
-                       "motion_notify_event": "mouse_motion_interaction",
-                       "key_press_event": "keyboard_interaction",
-                       "scroll-event" : "mouse_scroll_interaction",
-                       "selection-set": "check_for_today",
-                       }
-    _events = (gtk.gdk.KEY_PRESS_MASK | gtk.gdk.BUTTON_MOTION_MASK |
-                  gtk.gdk.POINTER_MOTION_HINT_MASK | gtk.gdk.BUTTON_RELEASE_MASK |
-                  gtk.gdk.BUTTON_PRESS_MASK)
-
-    def __init__(self, datastore = None, selected_range = 0):
-        """
-        :param datastore: The.CairoHistograms two dimensional list of dates and nitems
-        :param selected_range: the number of days displayed at once
-        """
-        super(CairoHistogram, self).__init__()
-        self.set_events(self._events)
-        self.set_flags(gtk.CAN_FOCUS)
-        for key, val in self._connections.iteritems():
-            self.connect(key, getattr(self, val))
-        self.font_name = self.style.font_desc.get_family()
-        self.set_datastore(datastore if datastore else [], draw = False)
-        self.selected_range = selected_range
-
-    def change_style(self, widget, old_style):
-        """
-        Sets the widgets style and coloring
-        """
-        self.colors = self.colors.copy()
-        self.colors["bg"] = get_gtk_rgba(self.style, "bg", 0)
-        self.colors["base"] = get_gtk_rgba(self.style, "base", 0)
-        self.colors["column_normal"] =  get_gtk_rgba(self.style, "text", 4, 1.17)
-        self.colors["column_selected"] = get_gtk_rgba(self.style, "bg", 3)
-        color = self.style.bg[gtk.STATE_NORMAL]
-        fcolor = self.style.fg[gtk.STATE_NORMAL]
-        self.colors["font_color"] = combine_gdk_color(color, fcolor).to_string()
-
-        pal = get_gtk_rgba(self.style, "bg", 3, 1.2)
-        self.colors["column_alternative"] = (pal[2], pal[1], pal[0], 1)
-        self.colors["column_selected_alternative"] = get_gtk_rgba(self.style, "bg", 3, 0.6)
-        self.colors["stroke"] = get_gtk_rgba(self.style, "text", 4)
-        self.colors["shadow"] = get_gtk_rgba(self.style, "text", 4)
-        self.font_size = self.style.font_desc.get_size()/1024
-        self.pangofont = pango.FontDescription(self.font_name + " %d" % self.font_size)
-        self.pangofont.set_weight(pango.WEIGHT_BOLD)
-        self.bottom_padding = self.font_size + 9 + widget.style.ythickness
-        self.gc = get_gc_from_colormap(widget, 0.6)
-
-    def set_selected_range(self, selected_range):
-        """
-        Set the number of days to be colored as selected
-
-        :param selected_range: the range to be used when setting selected coloring
-        """
-        self.selected_range = selected_range
-        return True
-
-    def set_datastore(self, datastore, draw = True):
-        """
-        Sets the objects datastore attribute using a list
-
-        :param datastore: A list that is comprised of rows containing
-        a int time and a int nitems
-        """
-        if isinstance(datastore, list):
-            self._datastore = datastore
-            self.largest = 1
-            for date, nitems in self._datastore:
-                if nitems > self.largest: self.largest = nitems
-            if self.largest > self.max_column_height: self.largest = self.max_column_height
-            self.max_width = self.xincrement + (self.xincrement *len(datastore))
-        else:
-            raise TypeError("Datastore is not a <list>")
-        self.emit("data-updated")
-        self.set_selected(len(datastore) - self.selected_range)
-
-    def get_datastore(self):
-        return self._datastore
-
-    def prepend_data(self, newdatastore):
-        """
-        Adds the items of a new list before the items of the current datastore
-
-        :param newdatastore: the new list to be prepended
-
-        ## WARNING SELECTION WILL CHANGE WHEN DOING THIS TO BE FIXED ##
-        """
-        selected = self.get_selected()[-1]
-        self._datastore = newdatastore + self._datastore
-        self.queue_draw()
-        self.set_selected(len(newdatastore) + selected)
-
-    def _expose(self, widget, event):
-        """
-        The major drawing method that the expose event calls directly
-        """
-        widget.style.set_background(widget.window, gtk.STATE_NORMAL)
-        context = widget.window.cairo_create()
-        self.expose(widget, event, context)
-        if len(self._today_text):
-            self.draw_today(widget, event, context)
-
-    def expose(self, widget, event, context):
-        """
-        The minor drawing method
-
-        :param event: a gtk event with x and y values
-        :param context: This drawingarea's cairo context from the expose event
-        """
-        if not self.pangofont:
-            self.pangofont = pango.FontDescription(self.font_name + " %d" % self.font_size)
-            self.pangofont.set_weight(pango.WEIGHT_BOLD)
-        if not self.gc:
-            self.gc = get_gc_from_colormap(widget, 0.6)
-        context.set_source_rgba(*self.colors["base"])
-        context.set_operator(cairo.OPERATOR_SOURCE)
-        #context.paint()
-        context.rectangle(event.area.x, event.area.y, event.area.width, event.area.height)
-        context.clip()
-        #context.set_source_rgba(*self.colors["bg"])
-        context.rectangle(event.area.x, event.area.y, event.area.width, event.area.height - self.bottom_padding)
-        context.fill()
-        self.draw_columns_from_datastore(context, event, self.get_selected())
-        context.set_line_width(1)
-        if type(self) == CairoHistogram:
-            widget.style.paint_shadow(widget.window, gtk.STATE_NORMAL, gtk.SHADOW_IN,
-                                      event.area, widget, "treeview", event.area.x, event.area.y,
-                                      event.area.width, event.area.height - self.bottom_padding)
-        if self.is_focus():
-            widget.style.paint_focus(widget.window, gtk.STATE_NORMAL, event.area, widget, None, event.area.x, event.area.y,
-                                     event.area.width, event.area.height - self.bottom_padding)
-
-    def draw_today(self, widget, event, context):
-        """
-        """
-        layout = widget.create_pango_layout(self._today_text)
-        pangofont = pango.FontDescription(widget.font_name + " %d" % (widget.font_size - 1))
-        if not widget.gc:
-            widget.gc = get_gc_from_colormap(widget, 0.6)
-        layout.set_font_description(pangofont)
-        w, h = layout.get_pixel_size()
-        self._today_width = w + 10
-        self._today_area = (
-            int(event.area.x + event.area.width - self._today_width),
-            int(event.area.height - widget.bottom_padding + 2),
-            self._today_width,
-            widget.bottom_padding - 2)
-        state = gtk.STATE_PRELIGHT
-        shadow = gtk.SHADOW_OUT
-        widget.style.paint_box(
-            widget.window, state, shadow, event.area, widget, "button", *self._today_area)
-        widget.window.draw_layout(
-            widget.gc, int(event.area.x + event.area.width - w -5),
-            int(event.area.height - widget.bottom_padding/2 - h/2), layout)
-
-    def draw_columns_from_datastore(self, context, event, selected):
-        """
-        Draws columns from a datastore
-
-        :param context: This drawingarea's cairo context from the expose event
-        :param event: a gtk event with x and y values
-        :param selected: a list of the selected columns
-        """
-        x = self.start_x_padding
-        months_positions = []
-        for i, (date, nitems) in enumerate(self.get_datastore()):
-            if datetime.date.fromtimestamp(date).day == 1:
-                months_positions += [(date, x)]
-            if len(self._highlighted) > 0 and i >= self._highlighted[0] and i <= self._highlighted[-1] and i in self._highlighted:
-                color = self.colors["column_selected_alternative"] if i in selected else self.colors["column_alternative"]
-            elif not selected:
-                color = self.colors["column_normal"]
-            elif self._single_day_only  and i != selected[-1]:
-                color = self.colors["column_normal"]
-            elif i >= selected[0] and i <= selected[-1] and i in selected:
-                color = self.colors["column_selected"]
-            else:
-                color = self.colors["column_normal"]
-            self.draw_column(context, x, event.area.height, nitems, color)
-            x += self.xincrement
-        if x > event.area.width: # Check for resize
-            self.set_size_request(x+self.xincrement, event.area.height)
-        for date, xpos in months_positions:
-            edge = 0
-            if (date, xpos) == months_positions[-1]:
-                edge = len(self._datastore)*self.xincrement
-            self.draw_month(context, xpos - self.padding, event.area.height, date, edge)
-        self.max_width = x # remove me
-
-    def draw_column(self, context, x, maxheight, nitems, color):
-        """
-        Draws a columns at x with height based on nitems, and maxheight
-
-        :param context: The drawingarea's cairo context from the expose event
-        :param x: The current position in the image
-        :param maxheight: The event areas height
-        :param nitems: The number of items in the column to be drawn
-        :param color: A RGBA tuple Example: (0.3, 0.4, 0.8, 1)
-        """
-        if nitems < 2:
-            nitems = 2
-        elif nitems > self.max_column_height:
-            nitems = self.max_column_height
-        maxheight = maxheight - self.bottom_padding - 2
-        #height = int((maxheight-self.top_padding-2) * (self.largest*math.log(nitems)/math.log(self.largest))/100)
-        height = int(((float(nitems)/self.largest)*(maxheight-2))) - self.top_padding
-        #height = min(int((maxheight*self.largest/100) * (1 - math.e**(-0.025*nitems))), maxheight)
-        if height < self.min_column_height:
-            height = self.min_column_height
-        y = maxheight - height
-        context.set_source_rgba(*color)
-        context.move_to(x + self.column_radius, y)
-        context.new_sub_path()
-        if nitems > 4:
-            context.arc(self.column_radius + x, self.column_radius + y, self.column_radius, PI, 3 * PI /2)
-            context.arc(x + self.wcolumn - self.column_radius, self.column_radius + y, self.column_radius, 3 * PI / 2, 0)
-            context.rectangle(x, y + self.column_radius, self.wcolumn, height - self.column_radius)
-        else:
-            context.rectangle(x, y, self.wcolumn, height)
-        context.close_path()
-        context.fill()
-
-    def draw_month(self, context, x, height, date, edge=0):
-        """
-        Draws a line signifying the start of a month
-        """
-        context.set_source_rgba(*self.colors["stroke"])
-        context.set_line_width(self.stroke_width)
-        context.move_to(x+self.stroke_offset, 0)
-        context.line_to(x+self.stroke_offset, height - self.bottom_padding)
-        context.stroke()
-        date = datetime.date.fromtimestamp(date)
-        month = calendar.month_name[date.month]
-        date = "<span color='%s'>%s %d</span>" % (self.colors["font_color"], month, date.year)
-        layout = self.create_pango_layout(date)
-        layout.set_markup(date)
-        layout.set_font_description(self.pangofont)
-        w, h = layout.get_pixel_size()
-        if edge:
-            if x + w > edge: x = edge - w - 5
-        self.window.draw_layout(self.gc, int(x + 3), int(height - self.bottom_padding/2 - h/2), layout)
-
-    def set_selected(self, i):
-        """
-        Set the selected items using a int or a list of the selections
-        If you pass this method a int it will select the index + selected_range
-
-        Emits:
-         self._selected[0] and self._selected[-1]
-
-        :param i: a list or a int where the int will select i + selected_range
-        """
-        if len(self._selected):
-            if i == self._selected[0]:
-                return False
-        if isinstance(i, int):
-            self._selected = range(i, i + self.selected_range)
-            self.emit("selection-set", max(i, 0), max(i + self.selected_range - 1, 0))
-        else: self._selected = (-1,)
-        self.queue_draw()
-        return True
-
-    def get_selected(self):
-        """
-        returns a list of selected indices
-        """
-        return self._selected
-
-    def clear_selection(self):
-        """
-        clears the selected items
-        """
-        self._selected = range(len(self._datastore))[-self.selected_range:]
-        self.queue_draw()
-
-    def set_highlighted(self, highlighted):
-        """
-        Sets the widgets which should be highlighted with an alternative color
-
-        :param highlighted: a list of indexes to be highlighted
-        """
-        if isinstance(highlighted, list):
-            self._highlighted = highlighted
-        else: raise TypeError("highlighted is not a list")
-        self.queue_draw()
-
-    def clear_highlighted(self):
-        """Clears the highlighted color"""
-        self._highlighted = []
-        self.queue_draw()
-
-    def set_single_day(self, choice):
-        """
-        Allows the cal to enter a mode where the trailing days are not selected but still kept
-        """
-        self._single_day_only = choice
-        self.queue_draw()
-
-    def get_datastore_index_from_cartesian(self, x, y):
-        """
-        Gets the datastore index from a x, y value
-        """
-        return int((x - self.start_x_padding) / self.xincrement)
-
-    def keyboard_interaction(self, widget, event):
-        if event.keyval in (gtk.keysyms.space, gtk.keysyms.Right, gtk.keysyms.Left, gtk.keysyms.BackSpace):
-            i = self.get_selected()
-            if isinstance(i, list) and len(i) > 0: i = i[-1]
-            if event.keyval in (gtk.keysyms.space, gtk.keysyms.Right):
-                i += 1
-            elif event.keyval in (gtk.keysyms.Left, gtk.keysyms.BackSpace):
-                i -= 1
-            if i < len(self.get_datastore()):
-                self.change_location(i)
-
-    def mouse_motion_interaction(self, widget, event, *args, **kwargs):
-        """
-        Reacts to mouse moving (while pressed), and clicks
-        """
-        #if (event.state == gtk.gdk.BUTTON1_MASK and not self._disable_mouse_motion):
-        location = min((self.get_datastore_index_from_cartesian(event.x, event.y), len(self._datastore) - 1))
-        if location != self._last_location:
-            self.change_location(location)
-            self._last_location = location
-            #return True
-        return False
-
-    def mouse_press_interaction(self, widget, event, *args, **kwargs):
-        if (event.y > self.get_size_request()[1] - self.bottom_padding and
-            event.y < self.get_size_request()[1]):
-            return False
-        location = min((self.get_datastore_index_from_cartesian(event.x, event.y), len(self._datastore) - 1))
-        if location != self._last_location:
-            self.change_location(location)
-            self._last_location = location
-        return True
-
-    def mouse_scroll_interaction(self, widget, event):
-        i = self.get_selected()[-1]
-        if (event.direction in (gtk.gdk.SCROLL_UP, gtk.gdk.SCROLL_RIGHT)):
-            if i+1< len(self.get_datastore()):
-                self.change_location(i+1)
-        elif (event.direction in (gtk.gdk.SCROLL_DOWN, gtk.gdk.SCROLL_LEFT)):
-            if 0 <= i-1:
-                self.change_location(i-1)
-
-    def change_location(self, location):
-        """
-        Handles click events
-        """
-        if location < 0:
-            return False
-        self.set_selected(max(location - self.selected_range + 1, 0))
-        self.emit("column_clicked", location)
-        return True
-
-    # Today stuff
-    def check_for_today(self, widget, i, ii):
-        """
-        Changes today to a empty string if the selected item is not today
-        """
-        if ii == len(self.get_datastore())-1:
-            self._today_text = ""
-            self._today_area = None
-        elif len(self._today_text) == 0:
-            self._today_text = _("Today") + " »"
-        self.queue_draw()
-        return True
-
-
-def _in_area(coord_x, coord_y, area):
-    """check if some given X,Y coordinates are within an area.
-    area is either None or a (top_left_x, top_left_y, width, height)-tuple"""
-    if area is None:
-        return False
-    area_x, area_y, area_width, area_height = area
-    return (area_x <= coord_x <= area_x + area_width) and \
-        (area_y <= coord_y <= area_y + area_height)
-
-
-def _in_area(coord_x, coord_y, area):
-    """check if some given X,Y coordinates are within an area.
-    area is either None or a (top_left_x, top_left_y, width, height)-tuple"""
-    if area is None:
-        return False
-    area_x, area_y, area_width, area_height = area
-    return (area_x <= coord_x <= area_x + area_width) and \
-        (area_y <= coord_y <= area_y + area_height)
-
-
-class TooltipEventBox(gtk.EventBox):
-    """
-    A event box housing the tool tip logic that can be used for a CairoHistogram.
-    Otherwise it interferes with the scrubbing mask code
-    """
-    _saved_tooltip_location = None
-    def __init__(self, histogram, container):
-        super(TooltipEventBox, self).__init__()
-        self.add(histogram)
-        self.histogram = histogram
-        self.container = container
-        self.set_property("has-tooltip", True)
-        self.connect("query-tooltip", self.query_tooltip)
-
-    def query_tooltip(self, widget, x, y, keyboard_mode, tooltip):
-        if y < self.histogram.get_size_request()[1] - self.histogram.bottom_padding:
-            location = self.histogram.get_datastore_index_from_cartesian(x, y)
-            if location != self._saved_tooltip_location:
-                # don't show the previous tooltip if we moved to another
-                # location
-                self._saved_tooltip_location = location
-                return False
-            try:
-                timestamp, count = self.histogram.get_datastore()[location]
-            except IndexError:
-                # there is no bar for at this location
-                # don't show a tooltip
-                return False
-            date = datetime.date.fromtimestamp(timestamp).strftime("%A, %d %B, %Y")
-            tooltip.set_text("%s\n%i %s" % (date, count,
-                                            gettext.ngettext("item", "items", count)))
-        elif self.container.histogram._today_text and _in_area(x, y, self.container.histogram._today_area):
-            tooltip.set_text(_("Click today to return to today"))
-        else:
-            return False
-        return True
-
-
-class JournalHistogram(CairoHistogram):
-    """
-    A subclass of CairoHistogram with theming to fit into Journal
-    """
-    padding = 2
-    column_radius = 1.3
-    top_padding = 6
-    bottom_padding = 29
-    wcolumn = 10
-    xincrement = wcolumn + padding
-    column_radius = 2
-    stroke_width = 2
-    stroke_offset = 1
-    font_size = 12
-    min_column_height = 2
-
-    def change_style(self, widget, *args, **kwargs):
-        self.colors = self.colors.copy()
-        self.colors["bg"] = get_gtk_rgba(self.style, "bg", 0)
-        self.colors["color"] = get_gtk_rgba(self.style, "base", 0)
-        self.colors["column_normal"] =  get_gtk_rgba(self.style, "bg", 1)
-        self.colors["column_selected"] = get_gtk_rgba(self.style, "bg", 3)
-        self.colors["column_selected_alternative"] = get_gtk_rgba(self.style, "bg", 3, 0.7)
-        self.colors["column_alternative"] = get_gtk_rgba(self.style, "text", 2)
-        self.colors["stroke"] = get_gtk_rgba(self.style, "bg", 0)
-        self.colors["shadow"] = get_gtk_rgba(self.style, "bg", 0, 0.98)
-        self.font_size = self.style.font_desc.get_size()/1024
-        self.bottom_padding = self.font_size + 9 + widget.style.ythickness
-        self.gc = self.style.text_gc[gtk.STATE_NORMAL]
-        self.pangofont = pango.FontDescription(self.font_name + " %d" % self.font_size)
-        self.pangofont.set_weight(pango.WEIGHT_BOLD)
-
-
-class HistogramWidget(gtk.Viewport):
-    """
-    A container for a CairoHistogram which allows you to scroll
-    """
-
-
-    def __init__(self, histo_type, size = (600, 75)):
-        """
-        :param histo_type: a :class:`CairoHistogram <CairoHistogram>` or a derivative
-        """
-        super(HistogramWidget, self).__init__()
-        self.set_shadow_type(gtk.SHADOW_NONE)
-        self.histogram = histo_type()
-        self.eventbox = TooltipEventBox(self.histogram, self)
-        self.set_size_request(*size)
-        self.add(self.eventbox)
-        self.histogram.connect("button_press_event", self.footer_clicked)
-        self.histogram.connect("selection-set", self.scrubbing_fix)
-        self.histogram.queue_draw()
-        self.queue_draw()
-
-    def footer_clicked(self, widget, event):
-        """
-        Handles all rejected clicks from bellow the histogram internal view and
-        checks to see if they were inside of the today text
-        """
-        hadjustment = self.get_hadjustment()
-        # Check for today button click
-        if (widget._today_text and event.x > hadjustment.value + hadjustment.page_size - widget._today_width):
-            self.histogram.change_location(len(self.histogram.get_datastore()) - 1)
-            return True
-        else:
-            pass # Drag here
-        return False
-
-    def scroll_to_end(self, *args, **kwargs):
-        """
-        Scroll to the end of the drawing area's viewport
-        """
-        hadjustment = self.get_hadjustment()
-        hadjustment.set_value(1)
-        hadjustment.set_value(self.histogram.max_width - hadjustment.page_size)
-
-    def scrubbing_fix(self, widget, i, ii):
-        """
-        Allows scrubbing to scroll the scroll window
-        """
-        hadjustment = self.get_hadjustment()
-        proposed_xa = ((i) * self.histogram.xincrement) + self.histogram.start_x_padding
-        proposed_xb = ((i + self.histogram.selected_range) * self.histogram.xincrement) + self.histogram.start_x_padding
-        if proposed_xa < hadjustment.value:
-            hadjustment.set_value(proposed_xa)
-        elif proposed_xb > hadjustment.value + hadjustment.page_size:
-            hadjustment.set_value(proposed_xb - hadjustment.page_size)
 
=== added file 'src/infopane.py'
--- src/infopane.py	1970-01-01 00:00:00 +0000
+++ src/infopane.py	2010-05-04 05:28:16 +0000
@@ -0,0 +1,577 @@
+# -.- coding: utf-8 -.-
+#
+# Filename
+#
+# Copyright © 2010 Randal Barlow
+# Copyright © 2010 Markus Korn <[e-mail]>
+#
+# 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, or
+# (at your option) any later version.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+
+# Purpose:
+
+import gobject
+import gtk
+import mimetypes
+import os
+import pango
+try: import gst
+except ImportError:
+    gst = None
+try: import gtksourceview2
+except ImportError: gtksourceview2 = None
+import threading
+
+from zeitgeist.client import ZeitgeistClient
+from zeitgeist.datamodel import Event, Subject, Interpretation, Manifestation, \
+     ResultType, TimeRange
+
+import content_objects
+from common import *
+from gio_file import GioFile
+import supporting_widgets
+
+
+GENERIC_DISPLAY_NAME = "other"
+
+MIMETYPEMAP = {
+    GENERIC_DISPLAY_NAME : ("image", None),
+    #"multimedia" : ("video", "audio"),
+    #"text" : ("text",),
+}
+
+CLIENT = ZeitgeistClient()
+
+def get_related_events_for_uri(uri, callback):
+    """
+    :param uri: A uri for which to request related uris using zetigeist
+    :param callback: this callback is called once the events are retrieved for
+    the uris. It is called with a list of events.
+    """
+    def _event_request_handler(uris):
+        """
+        :param uris: a list of uris which are related to the windows current uri
+        Seif look here
+        """
+        templates = []
+        if len(uris) > 0:
+            for i, uri in enumerate(uris):
+                templates += [
+                        Event.new_for_values(interpretation=Interpretation.VISIT_EVENT.uri, subject_uri=uri),
+                        Event.new_for_values(interpretation=Interpretation.MODIFY_EVENT.uri, subject_uri=uri),
+                        Event.new_for_values(interpretation=Interpretation.CREATE_EVENT.uri, subject_uri=uri),
+                        Event.new_for_values(interpretation=Interpretation.OPEN_EVENT.uri, subject_uri=uri)
+                    ]
+            CLIENT.find_events_for_templates(templates, callback,
+                                             [0, time.time()*1000], num_events=50000,
+                                             result_type=ResultType.MostRecentSubjects)
+
+    end = time.time() * 1000
+    start = end - (86400*30*1000)
+    CLIENT.find_related_uris_for_uris([uri], _event_request_handler)
+
+
+def get_media_type(gfile):
+    uri = gfile.uri
+    if not uri.startswith("file://") or not gfile:
+        return GENERIC_DISPLAY_NAME
+    majortype = gfile.mime_type.split("/")[0]
+    for key, mimes in MIMETYPEMAP.iteritems():
+        if majortype in mimes:
+            return key
+    #if isinstance(gfile, GioFile):
+    #    if "text-x-generic" in gfile.icon_names or "text-x-script" in gfile.icon_names:
+    #        return "text"
+    return GENERIC_DISPLAY_NAME
+
+
+class ContentDisplay(object):
+    """
+    The abstract base class for content displays
+    """
+    def set_content_object(self, obj):
+        """
+        :param obj a content object which the Content Display displays
+        """
+        pass
+
+    def set_inactive(self):
+        """
+        This method performs clean when the displays are swapped
+        """
+        pass
+
+
+class ScrolledDisplay(gtk.ScrolledWindow):
+    """
+    A scrolled window container that acts as a proxy for a child
+    use type to make wrapers for your type
+    """
+    child_type = gtk.Widget
+    def __init__(self):
+        super(ScrolledDisplay, self).__init__()
+        self._child_obj = self.child_type()
+        self.add(self._child_obj)
+        self.set_shadow_type(gtk.SHADOW_IN)
+        self.set_size_request(-1, 200)
+
+    def set_content_object(self, obj): self._child_obj.set_content_object(obj)
+    def set_inactive(self): self._child_obj.set_inactive()
+
+
+class TextDisplay(gtksourceview2.View if gtksourceview2
+                  else gtk.TextView, ContentDisplay):
+    """
+    A text preview display which uses a sourceview or a textview if sourceview
+    modules are not found
+    """
+    def __init__(self):
+        """"""
+        super(TextDisplay, self).__init__()
+        self.textbuffer = (gtksourceview2.Buffer() if gtksourceview2
+                           else gtk.TextBuffer())
+        self.set_buffer(self.textbuffer)
+        self.set_editable(False)
+        font  = pango.FontDescription()
+        font.set_family("Monospace")
+        self.modify_font(font)
+        if gtksourceview2:
+            self.manager = gtksourceview2.LanguageManager()
+            self.textbuffer.set_highlight_syntax(True)
+
+    def get_language_from_mime_type(self, mime):
+        for id_ in self.manager.get_language_ids():
+            temp_language = self.manager.get_language(id_)
+            if mime in temp_language.get_mime_types():
+                return temp_language
+        return None
+
+    def set_content_object(self, obj):
+        if obj:
+            content = obj.get_content()
+            self.textbuffer.set_text(content)
+            if gtksourceview2:
+                lang = self.get_language_from_mime_type(obj.mime_type)
+                self.textbuffer.set_language(lang)
+
+
+class ImageDisplay(gtk.Image, ContentDisplay):
+    """
+    A display based on GtkImage to display a uri's thumb or icon using GioFile
+    """
+    def set_content_object(self, obj):
+        if obj:
+            if isinstance(obj, GioFile) and obj.has_preview():
+                pixbuf = obj.get_thumbnail(size=SIZE_NORMAL, border=3)
+            else:
+                pixbuf = obj.get_icon(size=128)
+            self.set_from_pixbuf(pixbuf)
+
+
+class MultimediaDisplay(gtk.VBox, ContentDisplay):
+    """
+    a display which words for video and audio using gstreamer
+    """
+    def __init__(self):
+        super(MultimediaDisplay, self).__init__()
+        self.playing = False
+        self.mediascreen = gtk.DrawingArea()
+        self.player = gst.element_factory_make("playbin", "player")
+        bus = self.player.get_bus()
+        bus.add_signal_watch()
+        bus.enable_sync_message_emission()
+        bus.connect("message", self.on_message)
+        bus.connect("sync-message::element", self.on_sync_message)
+        buttonbox = gtk.HBox()
+        self.playbutton = gtk.Button()
+        buttonbox.pack_start(self.playbutton, True, False)
+        self.playbutton.gtkimage = gtk.Image()
+        self.playbutton.add(self.playbutton.gtkimage)
+        self.playbutton.gtkimage.set_from_stock(gtk.STOCK_MEDIA_PAUSE, 2)
+        self.pack_start(self.mediascreen, True, True, 10)
+        self.pack_end(buttonbox, False, False)
+        self.playbutton.connect("clicked", self.on_play_click)
+        self.playbutton.set_relief(gtk.RELIEF_NONE)
+        self.connect("hide", self._handle_hide)
+
+    def _handle_hide(self, widget):
+        self.player.set_state(gst.STATE_NULL)
+
+    def set_playing(self):
+        """
+        Set MultimediaDisplay.player's state to playing
+        """
+        self.player.set_state(gst.STATE_PLAYING)
+        self.playbutton.gtkimage.set_from_stock(gtk.STOCK_MEDIA_PAUSE, 2)
+        self.playing = True
+
+    def set_paused(self):
+        """
+        Set MultimediaDisplay.player's state to paused
+        """
+        self.player.set_state(gst.STATE_PAUSED)
+        self.playbutton.gtkimage.set_from_stock(gtk.STOCK_MEDIA_PLAY, 2)
+        self.playing = False
+
+
+    def set_content_object(self, obj):
+        if isinstance(obj, GioFile):
+            self.player.set_state(gst.STATE_NULL)
+            self.player.set_property("uri", obj.uri)
+            self.set_playing()
+
+    def set_inactive(self):
+        self.player.set_state(gst.STATE_NULL)
+        self.playing = False
+
+    def on_play_click(self, widget):
+        if self.playing:
+            return self.set_paused()
+        return self.set_playing()
+
+    def on_sync_message(self, bus, message):
+        if message.structure is None:
+            return
+        message_name = message.structure.get_name()
+        if message_name == "prepare-xwindow-id":
+            imagesink = message.src
+            imagesink.set_property("force-aspect-ratio", True)
+            gtk.gdk.threads_enter()
+            try:
+                self.show_all()
+                imagesink.set_xwindow_id(self.mediascreen.window.xid)
+            finally:
+                gtk.gdk.threads_leave()
+
+    def on_message(self, bus, message):
+        t = message.type
+        if t == gst.MESSAGE_EOS:
+            self.player.set_state(gst.STATE_NULL)
+        elif t == gst.MESSAGE_ERROR:
+            self.player.set_state(gst.STATE_NULL)
+            err, debug = message.parse_error()
+            print "Error: %s" % err, debug
+
+
+class EventDataPane(gtk.Table):
+    x = 2
+    y = 8
+
+    column_names = (
+        _("Actor"), # 0
+        _("Time"), # 1
+        _(""), # 2
+        _("Interpretation"), # 3
+        _("Subject Interpretation"), # 4
+        _("Manifestation"),
+    )
+
+
+    def __init__(self):
+        super(EventDataPane, self).__init__(self.x, self.y)
+        self.set_col_spacings(4)
+        self.set_row_spacings(4)
+        self.labels = []
+        for i, name in enumerate(self.column_names):
+            #for i in xrange(len(self.column_names)):
+            namelabel = gtk.Label()
+            if name:
+                namelabel.set_markup("<b>" + name + ":</b>")
+            namelabel.set_alignment(0, 0)
+            self.attach(namelabel, 0, 1, i, i+1)
+            label = gtk.Label()
+            label.set_alignment(0, 0)
+            self.attach(label, 1, 2, i, i+1)
+            self.labels.append(label)
+
+    def set_content_object(self, obj):
+        event = obj.event
+        # Actor
+        desktop_file = obj.get_actor_desktop_file()
+        if desktop_file:
+            actor = desktop_file.getName()
+        else: actor = event.actor
+        self.labels[0].set_text(actor)
+        # Time
+        local_t = time.localtime(int(event.timestamp)/1000)
+        time_str = time.strftime("%b %d %Y %H:%M:%S", local_t)
+        self.labels[1].set_text(time_str)
+        #self.labels[2].set_text(event.subjects[0].uri)
+        # Interpetation
+        try: interpretation_name = Interpretation[event.interpretation].display_name
+        except KeyError: interpretation_name = ""
+        self.labels[3].set_text(interpretation_name)
+        # Subject Interpetation
+        try: subject_interpretation_name = Interpretation[event.subjects[0].interpretation].display_name
+        except KeyError: subject_interpretation_name = ""
+        self.labels[4].set_text(subject_interpretation_name)
+        # Manifestation
+        try: manifestation_name = Manifestation[event.manifestation].display_name
+        except KeyError: manifestation_name = ""
+        self.labels[5].set_text(manifestation_name)
+
+
+class InformationPane(gtk.VBox):
+    """
+    . . . . . . . .
+    .             .
+    .    Info     .
+    .             .
+    .             .
+    . . . . . . . .
+
+    Holds widgets which display information about a uri
+    """
+    displays = {
+        GENERIC_DISPLAY_NAME : ImageDisplay,
+        "multimedia" : MultimediaDisplay if gst else ImageDisplay,
+        "text" : type("TextScrolledWindow", (ScrolledDisplay,),
+                      {"child_type" : TextDisplay}),
+    }
+
+    obj = None
+
+    def __init__(self):
+        super(InformationPane, self).__init__()
+        vbox = gtk.VBox()
+        buttonhbox = gtk.HBox()
+        self.box = gtk.Frame()
+        self.label = gtk.Label()
+        self.pathlabel = gtk.Label()
+        labelvbox = gtk.VBox()
+        labelvbox.pack_start(self.label)
+        labelvbox.pack_end(self.pathlabel)
+        self.openbutton = gtk.Button(stock=gtk.STOCK_OPEN)
+        self.displays = self.displays.copy()
+        #self.set_shadow_type(gtk.SHADOW_NONE)
+        #self.set_label_widget(labelvbox)
+        self.pack_start(labelvbox)
+        self.box.set_shadow_type(gtk.SHADOW_NONE)
+        buttonhbox.pack_end(self.openbutton, False, False, 5)
+        buttonhbox.set_border_width(5)
+        vbox.pack_start(self.box, True, True)
+        vbox.pack_end(buttonhbox, False, False)
+        #self.set_label_align(0.5, 0.5)
+        #self.label.set_ellipsize(pango.ELLIPSIZE_MIDDLE)
+        #self.pathlabel.set_size_request(100, -1)
+        #self.pathlabel.set_size_request(300, -1)
+        self.pathlabel.set_ellipsize(pango.ELLIPSIZE_MIDDLE)
+        def _launch(w):
+            self.obj.launch()
+        self.openbutton.connect("clicked", _launch)
+
+        #self.datapane = EventDataPane()
+        #vbox.pack_end(self.datapane, False, False)
+        self.add(vbox)
+        self.show_all()
+
+    def set_displaytype(self, obj):
+        """
+        Determines the ContentDisplay to use for a given uri
+        """
+        media_type = get_media_type(obj)
+        display_widget = self.displays[media_type]
+        if isinstance(display_widget, type):
+            display_widget = self.displays[media_type] = display_widget()
+        if display_widget.parent != self.box:
+            child = self.box.get_child()
+            if child:
+                self.box.remove(child)
+                child.set_inactive()
+            self.box.add(display_widget)
+        display_widget.set_content_object(obj)
+        self.show_all()
+
+    def set_content_object(self, obj):
+        self.obj = obj
+        self.set_displaytype(obj)
+        self.label.set_markup("<span size='12336'>" + obj.text.replace("&", "&amp;") + "</span>")
+        self.pathlabel.set_markup("<span color='#979797'>" + obj.uri + "</span>")
+        #self.datapane.set_content_object(obj)
+
+    def set_inactive(self):
+        display = self.box.get_child()
+        if display: display.set_inactive()
+
+
+class RelatedPane(gtk.TreeView):
+    """
+                     . . .
+                     .   .
+                     .   . <--- Related files
+                     .   .
+                     .   .
+                     . . .
+
+    Displays related events using a widget based on gtk.TreeView
+    """
+    def __init__(self):
+        super(RelatedPane, self).__init__()
+        self.popupmenu = supporting_widgets.ContextMenu
+        self.connect("button-press-event", self.on_button_press)
+        self.connect("row-activated", self.row_activated)
+        pcolumn = gtk.TreeViewColumn(_("Related Items"))
+        pixbuf_render = gtk.CellRendererPixbuf()
+        pcolumn.pack_start(pixbuf_render, False)
+        pcolumn.set_cell_data_func(pixbuf_render, self.celldatamethod, "pixbuf")
+        text_render = gtk.CellRendererText()
+        text_render.set_property("ellipsize", pango.ELLIPSIZE_MIDDLE)
+        pcolumn.pack_end(text_render, True)
+        pcolumn.set_cell_data_func(text_render, self.celldatamethod, "text")
+        self.append_column(pcolumn)
+        #self.set_headers_visible(False)
+
+    def celldatamethod(self, column, cell, model, iter_, user_data):
+        if model:
+            obj = model.get_value(iter_, 0)
+            if user_data == "text":
+                cell.set_property("text", obj.text.replace("&", "&amp;"))
+            elif user_data == "pixbuf":
+                cell.set_property("pixbuf", obj.icon)
+
+    def _set_model_in_thread(self, events):
+        """
+        A threaded which generates pixbufs and emblems for a list of events.
+        It takes those properties and appends them to the view's model
+        """
+        lock = threading.Lock()
+        self.active_list = []
+        liststore = gtk.ListStore(gobject.TYPE_PYOBJECT)
+        gtk.gdk.threads_enter()
+        self.set_model(liststore)
+        gtk.gdk.threads_leave()
+        for event in events:
+            obj = content_objects.choose_content_object(event)
+            if not obj: continue
+            gtk.gdk.threads_enter()
+            lock.acquire()
+            self.active_list.append(False)
+            liststore.append((obj,))
+            lock.release()