/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: Jelmer Vernooij
  • Date: 2007-12-21 20:20:37 UTC
  • mto: This revision was merged to the branch mainline in revision 422.
  • Revision ID: jelmer@samba.org-20071221202037-6zvbwefvrte3e2zy
Fix URL.

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