← Back to branch summary

~zeitgeist/zeitgeist-explorer/debian-sid-packaging

« back to all changes in this revision

Viewing changes to zgexplorer/eventwidgets.py

  • Committer: Manish Sinha
  • Date: 2013-03-30 07:40:58 UTC
  • Revision ID: manishsinha@ubuntu.com-20130330074058-xm91m36dwh075t9h
Added all basic files for packaging

Show diffs side-by-side

added added

removed removed

Lines of Context:
zgexplorer/eventwidgets.py
 
1
#! /usr/bin/env python
 
2
# -.- coding: utf-8 -.-
 
3
#
 
4
# Zeitgeist Explorer
 
5
#
 
6
# Copyright © 2012 Manish Sinha <manishsinha@ubuntu.com>
 
7
# Copyright © 2012 Dhananjay Sathe <dhananjaysathe@gmail.com>
 
8
#
 
9
# This program is free software: you can redistribute it and/or modify it
 
10
# under the terms of the GNU Lesser General Public License as published
 
11
# by the Free Software Foundation, either version 2 of the License, or
 
12
# (at your option) any later version.
 
13
#
 
14
# This program is distributed in the hope that it will be useful, but
 
15
# WITHOUT ANY WARRANTY; without even the implied warranty of
 
16
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
17
# See the GNU Lesser General Public License for more details.
 
18
#
 
19
# You should have received a copy of the GNU Lesser General Public License
 
20
# along with this program.  If not, see <http://www.gnu.org/licenses/>.";
 
21
 
 
22
import codecs
 
23
from datetime import datetime
 
24
from gi.repository import Gtk, Gdk, Gio
 
25
from zeitgeist.datamodel import Event, Subject, Manifestation, \
 
26
    Interpretation, StorageState, Symbol, ResultType
 
27
 
 
28
from lookupdata import *
 
29
 
 
30
# workaround for Gtk ComboBoxText Widgets
 
31
def get_active_text(combobox):
 
32
      model = combobox.get_model()
 
33
      active = combobox.get_active()
 
34
      if active < 0:
 
35
          return ''
 
36
      return model[active][0]
 
37
 
 
38
class EventsViewer(Gtk.VBox):
 
39
 
 
40
    events = {}
 
41
    
 
42
    def __init__(self):
 
43
        super(EventsViewer, self).__init__()
 
44
 
 
45
        self.scroll = Gtk.ScrolledWindow(None, None,border_width=1,shadow_type=Gtk.ShadowType.IN)
 
46
        self.scroll.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
 
47
        self.pack_start(self.scroll, True, True, 6)
 
48
 
 
49
        self.treeview = EventsTreeView()
 
50
        self.treeview.set_selection_changed_cb(self.on_event_selected)
 
51
        self.scroll.add(self.treeview)
 
52
 
 
53
        self.viewer = EventDetailsViewer()
 
54
        self.pack_start(self.viewer, False, False, 6)
 
55
 
 
56
    def on_event_selected(self, event_id):
 
57
        event = self.events[event_id]
 
58
        self.viewer.map(event)
 
59
 
 
60
    def insert(self, events):
 
61
        for event in events:
 
62
            if event.id not in self.events.keys():
 
63
                self.events[event.id] = event
 
64
        self.treeview.add_events(events)
 
65
 
 
66
    def clear(self):
 
67
        self.events.clear()
 
68
        self.viewer.map(Event.new_for_values(subjects=[Subject()]))
 
69
        self.treeview.set_events([])
 
70
 
 
71
class EventsTreeView(Gtk.TreeView):
 
72
 
 
73
    # TODO: It may make sense to use GenericTreeModel here.
 
74
    _store = None
 
75
    _selection_changed_cb = None
 
76
 
 
77
    def __init__(self):
 
78
        super(EventsTreeView, self).__init__()
 
79
        
 
80
        # event id, timestamp, interpretation, manifestation, actor
 
81
        # FIXME: TreeStore
 
82
        self._store = Gtk.ListStore(int, str, str, str, str) # GObject.TYPE_PYOBJECT)
 
83
        self.set_model(self._store)
 
84
        self.set_search_column(0)
 
85
        
 
86
        col = self._create_column(_('ID'), 0)
 
87
        col = self._create_column(_('Timestamp'), 1)
 
88
        col = self._create_column(_('Interpretation'), 2)
 
89
        col = self._create_column(_('Manifestation'), 3)
 
90
        col = self._create_column(_('Actor'), 4)
 
91
        
 
92
        self.connect('button-press-event', self._on_click)
 
93
        self.connect('cursor-changed', self._on_selection_changed)
 
94
 
 
95
    def _create_column(self, name, data_col, cell_renderer=Gtk.CellRendererText()):
 
96
        column = Gtk.TreeViewColumn(name, cell_renderer)
 
97
        column.set_expand(True)
 
98
        column.set_resizable(True)
 
99
        column.set_sort_column_id(data_col)
 
100
        column.add_attribute(cell_renderer, 'text', data_col)
 
101
        self.append_column(column)
 
102
        return (column, cell_renderer)
 
103
 
 
104
    # FIXME
 
105
    def _get_data_from_event(self, event):
 
106
        x, y = (int(round(event.x)), int(round(event.y)))
 
107
        treepath = self.get_path_at_pos(x, y)[0]
 
108
        treeiter = self._store.get_iter(treepath)
 
109
        return self._store.get_value(treeiter, 3)
 
110
 
 
111
    # FIXME
 
112
    def _on_click(self, widget, event):
 
113
        if event.type == Gdk.EventType._2BUTTON_PRESS:
 
114
            data = self._get_data_from_event(event)
 
115
            if isinstance(data, Event):
 
116
                details.EventDetails(data)
 
117
            elif isinstance(data, Subject):
 
118
                details.SubjectDetails(data)
 
119
            else:
 
120
                print 'Unknown row selected.'
 
121
 
 
122
    def _on_selection_changed(self, widget):
 
123
        selection = self.get_selection()
 
124
        if selection:
 
125
            model, _iter = selection.get_selected()
 
126
            if _iter:
 
127
                event_id = model.get(_iter, 0)[0]
 
128
                if self._selection_changed_cb:
 
129
                    self._selection_changed_cb(event_id)
 
130
        return None
 
131
 
 
132
    def add_event(self, event):
 
133
        self._store.append([event.id, event.date_string,
 
134
            event.interp_string, event.manif_string, unicode(event.actor)])
 
135
        #event_iter = self._store.append(None, [event.id, event.date_string,
 
136
        #    event.interp_string, event.manif_string, unicode(event.actor)])
 
137
        #for subject in event.subjects:
 
138
        #    self._store.append(event_iter, [None, subject.text,
 
139
        #        subject.interp_string, subject.manif_string, subject.mimetype])
 
140
        #self.expand_row(event_iter)
 
141
 
 
142
    def add_events(self, events):
 
143
        map(self.add_event, events)
 
144
 
 
145
    def set_events(self, events):
 
146
        self._store.clear()
 
147
        self.add_events(events)
 
148
        self.expand_all()
 
149
 
 
150
    def set_selection_changed_cb(self, cb):
 
151
        self._selection_changed_cb = cb
 
152
 
 
153
class EventDetailsViewer(Gtk.VBox):
 
154
 
 
155
    def __init__(self):
 
156
 
 
157
        super(EventDetailsViewer, self).__init__()
 
158
 
 
159
        self.table = Gtk.Table(18, 4, False,border_width=1)
 
160
        self.pack_start(self.table, False, False, 6)
 
161
 
 
162
        id_label = Gtk.Label(xalign=0,yalign=0.5)
 
163
        id_label.set_markup("<b>%s</b>" %("Event ID"))
 
164
 
 
165
        self.id_entry = Gtk.Label(xalign=0,yalign=0.5)
 
166
 
 
167
        time_label = Gtk.Label(xalign=0,yalign=0.5)
 
168
        time_label.set_markup("<b>%s</b>" %("Timestamp"))
 
169
 
 
170
        self.time_entry = Gtk.Label(xalign=0,yalign=0.5)
 
171
 
 
172
        event_int_label = Gtk.Label(xalign=0,yalign=0.5)
 
173
        event_int_label.set_markup("<b>%s</b>" %("Interpretation"))
 
174
 
 
175
        self.event_int_entry = Gtk.Label(xalign=0,yalign=0.5)
 
176
 
 
177
        event_manifes_label = Gtk.Label(xalign=0,yalign=0.5)
 
178
        event_manifes_label.set_markup("<b>%s</b>" %("Manifestation"))
 
179
 
 
180
        self.event_manifes_entry = Gtk.Label(xalign=0,yalign=0.5)
 
181
 
 
182
        actor_label = Gtk.Label(xalign=0,yalign=0.5)
 
183
        actor_label.set_markup("<b>%s</b>" %("Actor"))
 
184
 
 
185
        self.actor_entry = Gtk.Label(xalign=0,yalign=0.5)
 
186
 
 
187
        actor_box = Gtk.HBox()
 
188
        self.image_entry = Gtk.Image(xalign=0,yalign=0.5)
 
189
        actor_box.pack_start(self.image_entry, False, False, 6)
 
190
        self.actor_name_entry = Gtk.Label(xalign=0,yalign=0.5)
 
191
        actor_box.pack_start(self.actor_name_entry, False, False, 6)
 
192
 
 
193
        uri_label = Gtk.Label(xalign=0,yalign=0.5)
 
194
        uri_label.set_markup("<b>%s</b>" %("URI"))
 
195
 
 
196
        self.uri_entry = Gtk.Label(xalign=0,yalign=0.5)
 
197
 
 
198
        current_uri_label = Gtk.Label(xalign=0,yalign=0.5)
 
199
        current_uri_label.set_markup("<b>%s</b>" %("Current URI"))
 
200
 
 
201
        self.current_uri_entry = Gtk.Label(xalign=0,yalign=0.5)
 
202
 
 
203
        subj_int_label = Gtk.Label(xalign=0,yalign=0.5)
 
204
        subj_int_label.set_markup("<b>%s</b>" %("Interpretation"))
 
205
 
 
206
        self.subj_int_entry = Gtk.Label(xalign=0,yalign=0.5)
 
207
 
 
208
        subj_manifes_label = Gtk.Label(xalign=0,yalign=0.5)
 
209
        subj_manifes_label.set_markup("<b>%s</b>" %("Manifestation"))
 
210
 
 
211
        self.subj_manifes_entry = Gtk.Label(xalign=0,yalign=0.5)
 
212
 
 
213
 
 
214
        origin_label = Gtk.Label(xalign=0,yalign=0.5)
 
215
        origin_label.set_markup("<b>%s</b>" %("Origin"))
 
216
 
 
217
        self.origin_entry = Gtk.Label(xalign=0,yalign=0.5)
 
218
 
 
219
        mimetype_label = Gtk.Label(xalign=0,yalign=0.5)
 
220
        mimetype_label.set_markup("<b>%s</b>" %("Mimetype"))
 
221
 
 
222
        self.mime_entry = Gtk.Label(xalign=0,yalign=0.5)
 
223
 
 
224
        text_label = Gtk.Label(xalign=0,yalign=0.5)
 
225
        text_label.set_markup("<b>%s</b>" %("Text"))
 
226
 
 
227
        self.text_entry = Gtk.Label(xalign=0,yalign=0.5)
 
228
 
 
229
        storage_label = Gtk.Label(xalign=0,yalign=0.5)
 
230
        storage_label.set_markup("<b>%s</b>" %("Storage"))
 
231
 
 
232
        self.storage_entry = Gtk.Label(xalign=0,yalign=0.5)
 
233
 
 
234
        attach_list = (
 
235
            (id_label,(0, 1, 0, 1)),
 
236
            (self.id_entry,(1, 2, 0, 1)),
 
237
            (time_label,(2, 3, 0, 1)),
 
238
            (self.time_entry,(3, 4, 0, 1)),
 
239
            (event_int_label,(0, 1, 1, 2)),
 
240
            (self.event_int_entry,(1, 4, 1, 2)),
 
241
            (event_manifes_label,(0, 1, 2, 3)),
 
242
            (self.event_manifes_entry,(1, 4, 2, 3)),
 
243
            (actor_label,(0, 1, 3, 4)),
 
244
            (self.actor_entry,(1, 2, 3, 4)),
 
245
            (actor_box,(2, 4, 3, 4)),
 
246
            (uri_label,(0, 1, 4, 5)),
 
247
            (self.uri_entry,(1, 4, 4, 5)),
 
248
            (current_uri_label,(0, 1, 5, 6)),
 
249
            (self.current_uri_entry,(1, 4, 5, 6)),
 
250
            (subj_int_label,(0, 1, 6, 7)),
 
251
            (self.subj_int_entry,(1, 4, 6, 7)),
 
252
            (subj_manifes_label,(0, 1, 7, 8)),
 
253
            (self.subj_manifes_entry,(1, 4, 7, 8)),
 
254
            (origin_label,(0, 1, 8, 9)),
 
255
            (self.origin_entry,(1, 2, 8, 9)),
 
256
            (mimetype_label,(2, 3, 8, 9)),
 
257
            (self.mime_entry,(3, 4, 8, 9)),
 
258
            (text_label,(0, 1, 9, 10)),
 
259
            (self.text_entry,(1, 2, 9, 10)),
 
260
            (storage_label,(2, 3, 9, 10)),
 
261
            (self.storage_entry,(3, 4, 9, 10))
 
262
         )
 
263
        for widget_entry in attach_list:
 
264
           widget,pos = widget_entry
 
265
           self.table.attach(widget,pos[0],pos[1], pos[2], pos[3], xpadding=6, ypadding=6)
 
266
 
 
267
    def map(self, event):
 
268
        try:
 
269
            id_val = int(event.get_id())
 
270
            self.id_entry.set_text(str(id_val) if id_val > 0 else "")
 
271
 
 
272
            timestamp = int(str(event.get_timestamp()))
 
273
            time = datetime.fromtimestamp(timestamp/1000).strftime("%Y-%m-%d %I:%M:%S %p")
 
274
            self.time_entry.set_text(time if id_val > 0 else "")
 
275
        except:
 
276
            self.id_entry.set_text("")
 
277
            self.time_entry.set_text("")
 
278
 
 
279
        self.event_int_entry.set_text(str(event.get_interpretation()))
 
280
        self.event_manifes_entry.set_text(str(event.get_manifestation()))
 
281
 
 
282
        actor = str(event.get_actor())
 
283
        self.actor_entry.set_label(actor)
 
284
 
 
285
        if actor.startswith("application://"):
 
286
            app_info = Gio.DesktopAppInfo.new(actor.replace("application://", ""))
 
287
            self.image_entry.set_from_gicon(app_info.get_icon(), Gtk.IconSize.DIALOG)
 
288
            self.actor_name_entry.set_text(app_info.get_display_name())
 
289
        else:
 
290
            self.image_entry.clear()
 
291
            self.actor_name_entry.set_text("")
 
292
 
 
293
        if len(event.subjects) > 0:
 
294
            subj = event.subjects[0]
 
295
 
 
296
            self.uri_entry.set_text(str(subj.get_uri()))
 
297
            self.current_uri_entry.set_text(str(subj.get_current_uri()))
 
298
 
 
299
            self.subj_int_entry.set_text(str(subj.get_interpretation()))
 
300
            self.subj_manifes_entry.set_text(str(subj.get_manifestation()))
 
301
 
 
302
            self.origin_entry.set_text(str(subj.get_origin()))
 
303
            self.mime_entry.set_text(subj.get_mimetype())
 
304
            try:
 
305
                txt = str(subj.get_text())
 
306
                self.text_entry.set_text(txt)
 
307
            except:
 
308
                #print unicode(subj.get_text().strip(codecs.BOM_UTF8), 'utf-8')
 
309
                self.text_entry.set_text("")
 
310
            self.storage_entry.set_text(str(subj.get_storage()))