/b-gtk/fix-viz

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/b-gtk/fix-viz

« back to all changes in this revision

Viewing changes to annotate/spanselector.py

  • Committer: Curtis Hovey
  • Date: 2011-08-12 20:25:28 UTC
  • mto: This revision was merged to the branch mainline in revision 741.
  • Revision ID: sinzui.is@verizon.net-20110812202528-4xf4a2t23urx50d2
Updated gst to gtk3.

Show diffs side-by-side

added added

removed removed

Lines of Context:
annotate/spanselector.py
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
18
 
import pygtk
19
 
pygtk.require("2.0")
20
 
import gobject
21
 
import gtk
 
18
from gi.repository import GObject
 
19
from gi.repository import Gtk
22
20
 
23
21
 
24
22
(
29
27
) = range(4)
30
28
 
31
29
 
32
 
class SpanSelector(gtk.HBox):
 
30
class SpanSelector(Gtk.HBox):
33
31
    """Encapsulates creation and functionality of widgets used for changing
34
32
    highlight spans.
35
 
    
 
33
 
36
34
    Note that calling any activate_* methods will emit "span-changed".
37
35
    """
38
 
    
 
36
 
39
37
    max_custom_spans = 4
40
38
    custom_spans = []
41
39
    last_selected = None
42
40
 
43
41
    def __init__(self, homogeneous=False, spacing=6):
44
 
        gtk.HBox.__init__(self, homogeneous, spacing)
 
42
        GObject.GObject.__init__(self, homogeneous, spacing)
45
43
 
46
44
        self.model = self._create_model()
47
45
        self.combo = self._create_combobox(self.model)
48
46
        self.entry = self._create_custom_entry()
49
47
 
50
 
        label = gtk.Label("Highlighting spans:")
 
48
        label = Gtk.Label(label="Highlighting spans:")
51
49
        label.show()
52
50
 
53
 
        self.pack_start(label, expand=False, fill=True)
54
 
        self.pack_start(self.combo, expand=False, fill=False)
55
 
        self.pack_start(self.entry, expand=False, fill=False)
 
51
        self.pack_start(label, False, True, True, 0)
 
52
        self.pack_start(self.combo, False, False, True, 0)
 
53
        self.pack_start(self.entry, False, False, True, 0)
56
54
 
57
55
    def set_to_oldest_span(self, span):
58
56
        """Set the span associated with the "to Oldest Revision" entry."""
67
65
        self.max_custom_spans = n
68
66
 
69
67
    def activate(self, iter):
70
 
        """Activate the row pointed to by gtk.TreeIter iter."""
 
68
        """Activate the row pointed to by Gtk.TreeIter iter."""
71
69
        index = self._get_index_from_iter(iter)
72
70
        self.combo.set_active(index)
73
71
 
104
102
        self.combo.show()
105
103
 
106
104
        span = float(w.get_text())
107
 
        
 
105
 
108
106
        if span == 0:
109
107
            # FIXME this works as "cancel", returning to the previous span,
110
108
            # but it emits "span-changed", which isn't necessary.
121
119
            self.custom_iter = self.model.insert_after(self.custom_iter,
122
120
                                                       self.separator)
123
121
            self.custom_iter_top = self.custom_iter.copy()
124
 
        
 
122
 
125
123
        if len(self.custom_spans) == self.max_custom_spans:
126
124
            self.custom_spans.pop(0)
127
125
            self.model.remove(self.model.iter_next(self.custom_iter_top))
128
 
        
 
126
 
129
127
        self.custom_spans.append(span)
130
128
        self.custom_iter = self.model.insert_after(
131
129
            self.custom_iter, [span, "%.2f Days" % span, False, False])
137
135
    def _create_model(self):
138
136
        # [span in days, span as string, row is seperator?, row is select
139
137
        # default?]
140
 
        m = gtk.ListStore(gobject.TYPE_FLOAT,
141
 
                          gobject.TYPE_STRING,
142
 
                          gobject.TYPE_BOOLEAN,
143
 
                          gobject.TYPE_BOOLEAN)
 
138
        m = Gtk.ListStore(GObject.TYPE_FLOAT,
 
139
                          GObject.TYPE_STRING,
 
140
                          GObject.TYPE_BOOLEAN,
 
141
                          GObject.TYPE_BOOLEAN)
144
142
 
145
143
        self.separator = [0., "", True, False]
146
 
        
 
144
 
147
145
        self.oldest_iter = m.append([0., "to Oldest Revision", False, False])
148
146
        self.newest_iter = m.append([0., "Newest to Oldest", False, False])
149
147
        m.append(self.separator)
157
155
        return m
158
156
 
159
157
    def _create_combobox(self, model):
160
 
        cb = gtk.ComboBox(model)
 
158
        cb = Gtk.ComboBox(model)
161
159
        cb.set_row_separator_func(
162
160
            lambda m, i: m.get_value(i, SPAN_IS_SEPARATOR_COL))
163
 
        cell = gtk.CellRendererText()
 
161
        cell = Gtk.CellRendererText()
164
162
        cb.pack_start(cell, False)
165
163
        cb.add_attribute(cell, "text", SPAN_STR_COL)
166
164
        cb.connect("changed", self._combo_changed_cb)
169
167
        return cb
170
168
 
171
169
    def _create_custom_entry(self):
172
 
        entry = gtk.HBox(False, 6)
173
 
        
174
 
        spin = gtk.SpinButton(digits=2)
 
170
        entry = Gtk.HBox(False, 6)
 
171
 
 
172
        spin = Gtk.SpinButton(digits=2)
175
173
        spin.set_numeric(True)
176
174
        spin.set_increments(1., 10.)
177
175
        spin.set_range(0., 100 * 365) # I presume 100 years is sufficient
178
176
        spin.connect("activate", self._activate_custom_span_cb)
179
177
        spin.connect("show", lambda w: w.grab_focus())
180
178
 
181
 
        label = gtk.Label("Days")
 
179
        label = Gtk.Label(label="Days")
182
180
 
183
 
        entry.pack_start(spin, expand=False, fill=False)
184
 
        entry.pack_start(label, expand=False, fill=False)
 
181
        entry.pack_start(spin, False, False, True, 0)
 
182
        entry.pack_start(label, False, False, True, 0)
185
183
 
186
184
        return entry
187
185
 
191
189
 
192
190
Callback signature: def callback(SpanSelector, span, [user_param, ...])
193
191
"""
194
 
gobject.signal_new("span-changed", SpanSelector,
195
 
                   gobject.SIGNAL_RUN_LAST,
196
 
                   gobject.TYPE_NONE,
197
 
                   (gobject.TYPE_FLOAT,))
 
192
GObject.signal_new("span-changed", SpanSelector,
 
193
                   GObject.SignalFlags.RUN_LAST,
 
194
                   None,
 
195
                   (GObject.TYPE_FLOAT,))
198
196
 
199
197
"""The "custom-span-added" signal is emitted after a custom span has been
200
198
added, but before it has been selected.
201
199
 
202
200
Callback signature: def callback(SpanSelector, span, [user_param, ...])
203
201
"""
204
 
gobject.signal_new("custom-span-added", SpanSelector,
205
 
                   gobject.SIGNAL_RUN_LAST,
206
 
                   gobject.TYPE_NONE,
207
 
                   (gobject.TYPE_FLOAT,))
 
202
GObject.signal_new("custom-span-added", SpanSelector,
 
203
                   GObject.SignalFlags.RUN_LAST,
 
204
                   None,
 
205
                   (GObject.TYPE_FLOAT,))
208
206