/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: 2006-09-30 10:21:43 UTC
  • Revision ID: jelmer@samba.org-20060930102143-c0ef64d6ca860c21
Merge some files from Olive and bzr-gtk.

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