diff options
Diffstat (limited to 'scripts/pybootchartgui/pybootchartgui/gui.py')
-rw-r--r-- | scripts/pybootchartgui/pybootchartgui/gui.py | 594 |
1 files changed, 334 insertions, 260 deletions
diff --git a/scripts/pybootchartgui/pybootchartgui/gui.py b/scripts/pybootchartgui/pybootchartgui/gui.py index 310c3d1bcc..ddeb88cd9b 100644 --- a/scripts/pybootchartgui/pybootchartgui/gui.py +++ b/scripts/pybootchartgui/pybootchartgui/gui.py | |||
@@ -1,273 +1,347 @@ | |||
1 | # This file is part of pybootchartgui. | ||
2 | |||
3 | # pybootchartgui is free software: you can redistribute it and/or modify | ||
4 | # it under the terms of the GNU General Public License as published by | ||
5 | # the Free Software Foundation, either version 3 of the License, or | ||
6 | # (at your option) any later version. | ||
7 | |||
8 | # pybootchartgui is distributed in the hope that it will be useful, | ||
9 | # but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
10 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
11 | # GNU General Public License for more details. | ||
12 | |||
13 | # You should have received a copy of the GNU General Public License | ||
14 | # along with pybootchartgui. If not, see <http://www.gnu.org/licenses/>. | ||
15 | |||
1 | import gobject | 16 | import gobject |
2 | import gtk | 17 | import gtk |
3 | import gtk.gdk | 18 | import gtk.gdk |
4 | import gtk.keysyms | 19 | import gtk.keysyms |
5 | 20 | from . import draw | |
6 | import draw | 21 | from .draw import RenderOptions |
7 | 22 | ||
8 | class PyBootchartWidget(gtk.DrawingArea): | 23 | class PyBootchartWidget(gtk.DrawingArea): |
9 | __gsignals__ = { | 24 | __gsignals__ = { |
10 | 'expose-event': 'override', | 25 | 'expose-event': 'override', |
11 | 'clicked' : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (gobject.TYPE_STRING, gtk.gdk.Event)), | 26 | 'clicked' : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (gobject.TYPE_STRING, gtk.gdk.Event)), |
12 | 'position-changed' : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (gobject.TYPE_INT, gobject.TYPE_INT)), | 27 | 'position-changed' : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (gobject.TYPE_INT, gobject.TYPE_INT)), |
13 | 'set-scroll-adjustments' : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (gtk.Adjustment, gtk.Adjustment)) | 28 | 'set-scroll-adjustments' : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (gtk.Adjustment, gtk.Adjustment)) |
14 | } | 29 | } |
15 | 30 | ||
16 | def __init__(self, res): | 31 | def __init__(self, trace, options, xscale): |
17 | gtk.DrawingArea.__init__(self) | 32 | gtk.DrawingArea.__init__(self) |
18 | 33 | ||
19 | self.res = res | 34 | self.trace = trace |
20 | 35 | self.options = options | |
21 | self.set_flags(gtk.CAN_FOCUS) | 36 | |
22 | 37 | self.set_flags(gtk.CAN_FOCUS) | |
23 | self.add_events(gtk.gdk.BUTTON_PRESS_MASK | gtk.gdk.BUTTON_RELEASE_MASK) | 38 | |
24 | self.connect("button-press-event", self.on_area_button_press) | 39 | self.add_events(gtk.gdk.BUTTON_PRESS_MASK | gtk.gdk.BUTTON_RELEASE_MASK) |
25 | self.connect("button-release-event", self.on_area_button_release) | 40 | self.connect("button-press-event", self.on_area_button_press) |
26 | self.add_events(gtk.gdk.POINTER_MOTION_MASK | gtk.gdk.POINTER_MOTION_HINT_MASK | gtk.gdk.BUTTON_RELEASE_MASK) | 41 | self.connect("button-release-event", self.on_area_button_release) |
27 | self.connect("motion-notify-event", self.on_area_motion_notify) | 42 | self.add_events(gtk.gdk.POINTER_MOTION_MASK | gtk.gdk.POINTER_MOTION_HINT_MASK | gtk.gdk.BUTTON_RELEASE_MASK) |
28 | self.connect("scroll-event", self.on_area_scroll_event) | 43 | self.connect("motion-notify-event", self.on_area_motion_notify) |
29 | self.connect('key-press-event', self.on_key_press_event) | 44 | self.connect("scroll-event", self.on_area_scroll_event) |
30 | 45 | self.connect('key-press-event', self.on_key_press_event) | |
31 | self.connect('set-scroll-adjustments', self.on_set_scroll_adjustments) | 46 | |
32 | self.connect("size-allocate", self.on_allocation_size_changed) | 47 | self.connect('set-scroll-adjustments', self.on_set_scroll_adjustments) |
33 | self.connect("position-changed", self.on_position_changed) | 48 | self.connect("size-allocate", self.on_allocation_size_changed) |
34 | 49 | self.connect("position-changed", self.on_position_changed) | |
35 | self.zoom_ratio = 1.0 | 50 | |
36 | self.x, self.y = 0.0, 0.0 | 51 | self.zoom_ratio = 1.0 |
37 | 52 | self.xscale = xscale | |
38 | self.chart_width, self.chart_height = draw.extents(res) | 53 | self.x, self.y = 0.0, 0.0 |
39 | self.hadj = None | 54 | |
40 | self.vadj = None | 55 | self.chart_width, self.chart_height = draw.extents(self.options, self.xscale, self.trace) |
41 | 56 | self.hadj = None | |
42 | def do_expose_event(self, event): | 57 | self.vadj = None |
43 | cr = self.window.cairo_create() | 58 | self.hadj_changed_signal_id = None |
44 | 59 | self.vadj_changed_signal_id = None | |
45 | # set a clip region for the expose event | 60 | |
46 | cr.rectangle( | 61 | def do_expose_event(self, event): |
47 | event.area.x, event.area.y, | 62 | cr = self.window.cairo_create() |
48 | event.area.width, event.area.height | 63 | |
49 | ) | 64 | # set a clip region for the expose event |
50 | cr.clip() | 65 | cr.rectangle( |
51 | self.draw(cr, self.get_allocation()) | 66 | event.area.x, event.area.y, |
52 | return False | 67 | event.area.width, event.area.height |
53 | 68 | ) | |
54 | def draw(self, cr, rect): | 69 | cr.clip() |
55 | cr.set_source_rgba(1.0, 1.0, 1.0, 1.0) | 70 | self.draw(cr, self.get_allocation()) |
56 | cr.paint() | 71 | return False |
57 | cr.scale(self.zoom_ratio, self.zoom_ratio) | 72 | |
58 | cr.translate(-self.x, -self.y) | 73 | def draw(self, cr, rect): |
59 | draw.render(cr, self.res) | 74 | cr.set_source_rgba(1.0, 1.0, 1.0, 1.0) |
60 | 75 | cr.paint() | |
61 | def position_changed(self): | 76 | cr.scale(self.zoom_ratio, self.zoom_ratio) |
62 | self.emit("position-changed", self.x, self.y) | 77 | cr.translate(-self.x, -self.y) |
63 | 78 | draw.render(cr, self.options, self.xscale, self.trace) | |
64 | ZOOM_INCREMENT = 1.25 | 79 | |
65 | 80 | def position_changed(self): | |
66 | def zoom_image(self, zoom_ratio): | 81 | self.emit("position-changed", self.x, self.y) |
67 | self.zoom_ratio = zoom_ratio | 82 | |
68 | self._set_scroll_adjustments(self.hadj, self.vadj) | 83 | ZOOM_INCREMENT = 1.25 |
69 | self.queue_draw() | 84 | |
70 | 85 | def zoom_image (self, zoom_ratio): | |
71 | def zoom_to_rect(self, rect): | 86 | self.zoom_ratio = zoom_ratio |
72 | zoom_ratio = float(rect.width)/float(self.chart_width) | 87 | self._set_scroll_adjustments (self.hadj, self.vadj) |
73 | self.zoom_image(zoom_ratio) | 88 | self.queue_draw() |
74 | self.x = 0 | 89 | |
75 | self.position_changed() | 90 | def zoom_to_rect (self, rect): |
76 | 91 | zoom_ratio = float(rect.width)/float(self.chart_width) | |
77 | def on_zoom_in(self, action): | 92 | self.zoom_image(zoom_ratio) |
78 | self.zoom_image(self.zoom_ratio * self.ZOOM_INCREMENT) | 93 | self.x = 0 |
79 | 94 | self.position_changed() | |
80 | def on_zoom_out(self, action): | 95 | |
81 | self.zoom_image(self.zoom_ratio / self.ZOOM_INCREMENT) | 96 | def set_xscale(self, xscale): |
82 | 97 | old_mid_x = self.x + self.hadj.page_size / 2 | |
83 | def on_zoom_fit(self, action): | 98 | self.xscale = xscale |
84 | self.zoom_to_rect(self.get_allocation()) | 99 | self.chart_width, self.chart_height = draw.extents(self.options, self.xscale, self.trace) |
85 | 100 | new_x = old_mid_x | |
86 | def on_zoom_100(self, action): | 101 | self.zoom_image (self.zoom_ratio) |
87 | self.zoom_image(1.0) | 102 | |
88 | 103 | def on_expand(self, action): | |
89 | POS_INCREMENT = 100 | 104 | self.set_xscale (self.xscale * 1.5) |
90 | 105 | ||
91 | def on_key_press_event(self, widget, event): | 106 | def on_contract(self, action): |
92 | if event.keyval == gtk.keysyms.Left: | 107 | self.set_xscale (self.xscale / 1.5) |
93 | self.x -= self.POS_INCREMENT/self.zoom_ratio | 108 | |
94 | elif event.keyval == gtk.keysyms.Right: | 109 | def on_zoom_in(self, action): |
95 | self.x += self.POS_INCREMENT/self.zoom_ratio | 110 | self.zoom_image(self.zoom_ratio * self.ZOOM_INCREMENT) |
96 | elif event.keyval == gtk.keysyms.Up: | 111 | |
97 | self.y -= self.POS_INCREMENT/self.zoom_ratio | 112 | def on_zoom_out(self, action): |
98 | elif event.keyval == gtk.keysyms.Down: | 113 | self.zoom_image(self.zoom_ratio / self.ZOOM_INCREMENT) |
99 | self.y += self.POS_INCREMENT/self.zoom_ratio | 114 | |
100 | elif event.keyval == gtk.keysyms.Page_Up: | 115 | def on_zoom_fit(self, action): |
101 | self.zoom_image(self.zoom_ratio * self.ZOOM_INCREMENT) | 116 | self.zoom_to_rect(self.get_allocation()) |
102 | elif event.keyval == gtk.keysyms.Page_Down: | 117 | |
103 | self.zoom_image(self.zoom_ratio / self.ZOOM_INCREMENT) | 118 | def on_zoom_100(self, action): |
104 | else: | 119 | self.zoom_image(1.0) |
105 | return False | 120 | self.set_xscale(1.0) |
106 | self.queue_draw() | 121 | |
107 | self.position_changed() | 122 | def show_toggled(self, button): |
123 | self.options.app_options.show_all = button.get_property ('active') | ||
124 | self.queue_draw() | ||
125 | |||
126 | POS_INCREMENT = 100 | ||
127 | |||
128 | def on_key_press_event(self, widget, event): | ||
129 | if event.keyval == gtk.keysyms.Left: | ||
130 | self.x -= self.POS_INCREMENT/self.zoom_ratio | ||
131 | elif event.keyval == gtk.keysyms.Right: | ||
132 | self.x += self.POS_INCREMENT/self.zoom_ratio | ||
133 | elif event.keyval == gtk.keysyms.Up: | ||
134 | self.y -= self.POS_INCREMENT/self.zoom_ratio | ||
135 | elif event.keyval == gtk.keysyms.Down: | ||
136 | self.y += self.POS_INCREMENT/self.zoom_ratio | ||
137 | else: | ||
138 | return False | ||
139 | self.queue_draw() | ||
140 | self.position_changed() | ||
141 | return True | ||
142 | |||
143 | def on_area_button_press(self, area, event): | ||
144 | if event.button == 2 or event.button == 1: | ||
145 | area.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.FLEUR)) | ||
146 | self.prevmousex = event.x | ||
147 | self.prevmousey = event.y | ||
148 | if event.type not in (gtk.gdk.BUTTON_PRESS, gtk.gdk.BUTTON_RELEASE): | ||
149 | return False | ||
150 | return False | ||
151 | |||
152 | def on_area_button_release(self, area, event): | ||
153 | if event.button == 2 or event.button == 1: | ||
154 | area.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.ARROW)) | ||
155 | self.prevmousex = None | ||
156 | self.prevmousey = None | ||
157 | return True | ||
158 | return False | ||
159 | |||
160 | def on_area_scroll_event(self, area, event): | ||
161 | if event.state & gtk.gdk.CONTROL_MASK: | ||
162 | if event.direction == gtk.gdk.SCROLL_UP: | ||
163 | self.zoom_image(self.zoom_ratio * self.ZOOM_INCREMENT) | ||
108 | return True | 164 | return True |
109 | 165 | if event.direction == gtk.gdk.SCROLL_DOWN: | |
110 | def on_area_button_press(self, area, event): | 166 | self.zoom_image(self.zoom_ratio / self.ZOOM_INCREMENT) |
111 | if event.button == 2 or event.button == 1: | ||
112 | area.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.FLEUR)) | ||
113 | self.prevmousex = event.x | ||
114 | self.prevmousey = event.y | ||
115 | if event.type not in (gtk.gdk.BUTTON_PRESS, gtk.gdk.BUTTON_RELEASE): | ||
116 | return False | ||
117 | return False | ||
118 | |||
119 | def on_area_button_release(self, area, event): | ||
120 | if event.button == 2 or event.button == 1: | ||
121 | area.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.ARROW)) | ||
122 | self.prevmousex = None | ||
123 | self.prevmousey = None | ||
124 | return True | ||
125 | return False | ||
126 | |||
127 | def on_area_scroll_event(self, area, event): | ||
128 | if event.direction == gtk.gdk.SCROLL_UP: | ||
129 | self.zoom_image(self.zoom_ratio * self.ZOOM_INCREMENT) | ||
130 | return True | ||
131 | if event.direction == gtk.gdk.SCROLL_DOWN: | ||
132 | self.zoom_image(self.zoom_ratio / self.ZOOM_INCREMENT) | ||
133 | return True | ||
134 | return False | ||
135 | |||
136 | def on_area_motion_notify(self, area, event): | ||
137 | state = event.state | ||
138 | if state & gtk.gdk.BUTTON2_MASK or state & gtk.gdk.BUTTON1_MASK: | ||
139 | x, y = int(event.x), int(event.y) | ||
140 | # pan the image | ||
141 | self.x += (self.prevmousex - x)/self.zoom_ratio | ||
142 | self.y += (self.prevmousey - y)/self.zoom_ratio | ||
143 | self.queue_draw() | ||
144 | self.prevmousex = x | ||
145 | self.prevmousey = y | ||
146 | self.position_changed() | ||
147 | return True | 167 | return True |
148 | 168 | return False | |
149 | def on_set_scroll_adjustments(self, area, hadj, vadj): | 169 | |
150 | self._set_scroll_adjustments(hadj, vadj) | 170 | def on_area_motion_notify(self, area, event): |
151 | 171 | state = event.state | |
152 | def on_allocation_size_changed(self, widget, allocation): | 172 | if state & gtk.gdk.BUTTON2_MASK or state & gtk.gdk.BUTTON1_MASK: |
153 | self.hadj.page_size = allocation.width | 173 | x, y = int(event.x), int(event.y) |
154 | self.hadj.page_increment = allocation.width * 0.9 | 174 | # pan the image |
155 | self.vadj.page_size = allocation.height | 175 | self.x += (self.prevmousex - x)/self.zoom_ratio |
156 | self.vadj.page_increment = allocation.height * 0.9 | 176 | self.y += (self.prevmousey - y)/self.zoom_ratio |
157 | 177 | self.queue_draw() | |
158 | def _set_scroll_adjustments(self, hadj, vadj): | 178 | self.prevmousex = x |
159 | if hadj == None: | 179 | self.prevmousey = y |
160 | hadj = gtk.Adjustment(0.0, 0.0, 0.0, 0.0, 0.0, 0.0) | 180 | self.position_changed() |
161 | if vadj == None: | 181 | return True |
162 | vadj = gtk.Adjustment(0.0, 0.0, 0.0, 0.0, 0.0, 0.0) | 182 | |
163 | 183 | def on_set_scroll_adjustments(self, area, hadj, vadj): | |
164 | if self.hadj != None and hadj != self.hadj: | 184 | self._set_scroll_adjustments (hadj, vadj) |
165 | self.hadj.disconnect(self.hadj_changed_signal_id) | 185 | |
166 | if self.vadj != None and vadj != self.vadj: | 186 | def on_allocation_size_changed(self, widget, allocation): |
167 | self.vadj.disconnect(self.vadj_changed_signal_id) | 187 | self.hadj.page_size = allocation.width |
168 | 188 | self.hadj.page_increment = allocation.width * 0.9 | |
169 | if hadj != None: | 189 | self.vadj.page_size = allocation.height |
170 | self.hadj = hadj | 190 | self.vadj.page_increment = allocation.height * 0.9 |
171 | self._set_adj_upper(self.hadj, self.zoom_ratio * self.chart_width) | 191 | |
172 | self.hadj_changed_signal_id = self.hadj.connect('value-changed', self.on_adjustments_changed) | 192 | def _set_adj_upper(self, adj, upper): |
173 | 193 | changed = False | |
174 | if vadj != None: | 194 | value_changed = False |
175 | self.vadj = vadj | 195 | |
176 | self._set_adj_upper(self.vadj, self.zoom_ratio * self.chart_height) | 196 | if adj.upper != upper: |
177 | self.vadj_changed_signal_id = self.vadj.connect('value-changed', self.on_adjustments_changed) | 197 | adj.upper = upper |
178 | 198 | changed = True | |
179 | def _set_adj_upper(self, adj, upper): | 199 | |
180 | changed = False | 200 | max_value = max(0.0, upper - adj.page_size) |
181 | value_changed = False | 201 | if adj.value > max_value: |
182 | 202 | adj.value = max_value | |
183 | if adj.upper != upper: | 203 | value_changed = True |
184 | adj.upper = upper | 204 | |
185 | changed = True | 205 | if changed: |
186 | 206 | adj.changed() | |
187 | max_value = max(0.0, upper - adj.page_size) | 207 | if value_changed: |
188 | if adj.value > max_value: | 208 | adj.value_changed() |
189 | adj.value = max_value | 209 | |
190 | value_changed = True | 210 | def _set_scroll_adjustments(self, hadj, vadj): |
191 | 211 | if hadj == None: | |
192 | if changed: | 212 | hadj = gtk.Adjustment(0.0, 0.0, 0.0, 0.0, 0.0, 0.0) |
193 | adj.changed() | 213 | if vadj == None: |
194 | if value_changed: | 214 | vadj = gtk.Adjustment(0.0, 0.0, 0.0, 0.0, 0.0, 0.0) |
195 | adj.value_changed() | 215 | |
196 | 216 | if self.hadj_changed_signal_id != None and \ | |
197 | def on_adjustments_changed(self, adj): | 217 | self.hadj != None and hadj != self.hadj: |
198 | self.x = self.hadj.value / self.zoom_ratio | 218 | self.hadj.disconnect (self.hadj_changed_signal_id) |
199 | self.y = self.vadj.value / self.zoom_ratio | 219 | if self.vadj_changed_signal_id != None and \ |
200 | self.queue_draw() | 220 | self.vadj != None and vadj != self.vadj: |
201 | 221 | self.vadj.disconnect (self.vadj_changed_signal_id) | |
202 | def on_position_changed(self, widget, x, y): | 222 | |
203 | self.hadj.value = x * self.zoom_ratio | 223 | if hadj != None: |
204 | self.vadj.value = y * self.zoom_ratio | 224 | self.hadj = hadj |
225 | self._set_adj_upper (self.hadj, self.zoom_ratio * self.chart_width) | ||
226 | self.hadj_changed_signal_id = self.hadj.connect('value-changed', self.on_adjustments_changed) | ||
227 | |||
228 | if vadj != None: | ||
229 | self.vadj = vadj | ||
230 | self._set_adj_upper (self.vadj, self.zoom_ratio * self.chart_height) | ||
231 | self.vadj_changed_signal_id = self.vadj.connect('value-changed', self.on_adjustments_changed) | ||
232 | |||
233 | def on_adjustments_changed(self, adj): | ||
234 | self.x = self.hadj.value / self.zoom_ratio | ||
235 | self.y = self.vadj.value / self.zoom_ratio | ||
236 | self.queue_draw() | ||
237 | |||
238 | def on_position_changed(self, widget, x, y): | ||
239 | self.hadj.value = x * self.zoom_ratio | ||
240 | self.vadj.value = y * self.zoom_ratio | ||
205 | 241 | ||
206 | PyBootchartWidget.set_set_scroll_adjustments_signal('set-scroll-adjustments') | 242 | PyBootchartWidget.set_set_scroll_adjustments_signal('set-scroll-adjustments') |
207 | 243 | ||
244 | class PyBootchartShell(gtk.VBox): | ||
245 | ui = ''' | ||
246 | <ui> | ||
247 | <toolbar name="ToolBar"> | ||
248 | <toolitem action="Expand"/> | ||
249 | <toolitem action="Contract"/> | ||
250 | <separator/> | ||
251 | <toolitem action="ZoomIn"/> | ||
252 | <toolitem action="ZoomOut"/> | ||
253 | <toolitem action="ZoomFit"/> | ||
254 | <toolitem action="Zoom100"/> | ||
255 | </toolbar> | ||
256 | </ui> | ||
257 | ''' | ||
258 | def __init__(self, window, trace, options, xscale): | ||
259 | gtk.VBox.__init__(self) | ||
260 | |||
261 | self.widget = PyBootchartWidget(trace, options, xscale) | ||
262 | |||
263 | # Create a UIManager instance | ||
264 | uimanager = self.uimanager = gtk.UIManager() | ||
265 | |||
266 | # Add the accelerator group to the toplevel window | ||
267 | accelgroup = uimanager.get_accel_group() | ||
268 | window.add_accel_group(accelgroup) | ||
269 | |||
270 | # Create an ActionGroup | ||
271 | actiongroup = gtk.ActionGroup('Actions') | ||
272 | self.actiongroup = actiongroup | ||
273 | |||
274 | # Create actions | ||
275 | actiongroup.add_actions(( | ||
276 | ('Expand', gtk.STOCK_ADD, None, None, None, self.widget.on_expand), | ||
277 | ('Contract', gtk.STOCK_REMOVE, None, None, None, self.widget.on_contract), | ||
278 | ('ZoomIn', gtk.STOCK_ZOOM_IN, None, None, None, self.widget.on_zoom_in), | ||
279 | ('ZoomOut', gtk.STOCK_ZOOM_OUT, None, None, None, self.widget.on_zoom_out), | ||
280 | ('ZoomFit', gtk.STOCK_ZOOM_FIT, 'Fit Width', None, None, self.widget.on_zoom_fit), | ||
281 | ('Zoom100', gtk.STOCK_ZOOM_100, None, None, None, self.widget.on_zoom_100), | ||
282 | )) | ||
283 | |||
284 | # Add the actiongroup to the uimanager | ||
285 | uimanager.insert_action_group(actiongroup, 0) | ||
286 | |||
287 | # Add a UI description | ||
288 | uimanager.add_ui_from_string(self.ui) | ||
289 | |||
290 | # Scrolled window | ||
291 | scrolled = gtk.ScrolledWindow() | ||
292 | scrolled.add(self.widget) | ||
293 | |||
294 | # toolbar / h-box | ||
295 | hbox = gtk.HBox(False, 8) | ||
296 | |||
297 | # Create a Toolbar | ||
298 | toolbar = uimanager.get_widget('/ToolBar') | ||
299 | hbox.pack_start(toolbar, True, True) | ||
300 | |||
301 | if not options.kernel_only: | ||
302 | # Misc. options | ||
303 | button = gtk.CheckButton("Show more") | ||
304 | button.connect ('toggled', self.widget.show_toggled) | ||
305 | hbox.pack_start (button, False, True) | ||
306 | |||
307 | self.pack_start(hbox, False) | ||
308 | self.pack_start(scrolled) | ||
309 | self.show_all() | ||
310 | |||
311 | def grab_focus(self, window): | ||
312 | window.set_focus(self.widget) | ||
313 | |||
314 | |||
208 | class PyBootchartWindow(gtk.Window): | 315 | class PyBootchartWindow(gtk.Window): |
209 | 316 | ||
210 | ui = ''' | 317 | def __init__(self, trace, app_options): |
211 | <ui> | 318 | gtk.Window.__init__(self) |
212 | <toolbar name="ToolBar"> | 319 | |
213 | <toolitem action="ZoomIn"/> | 320 | window = self |
214 | <toolitem action="ZoomOut"/> | 321 | window.set_title("Bootchart %s" % trace.filename) |
215 | <toolitem action="ZoomFit"/> | 322 | window.set_default_size(750, 550) |
216 | <toolitem action="Zoom100"/> | 323 | |
217 | </toolbar> | 324 | tab_page = gtk.Notebook() |
218 | </ui> | 325 | tab_page.show() |
219 | ''' | 326 | window.add(tab_page) |
220 | 327 | ||
221 | def __init__(self, res): | 328 | full_opts = RenderOptions(app_options) |
222 | gtk.Window.__init__(self) | 329 | full_tree = PyBootchartShell(window, trace, full_opts, 1.0) |
223 | 330 | tab_page.append_page (full_tree, gtk.Label("Full tree")) | |
224 | window = self | 331 | |
225 | window.set_title('Bootchart') | 332 | if trace.kernel is not None and len (trace.kernel) > 2: |
226 | window.set_default_size(512, 512) | 333 | kernel_opts = RenderOptions(app_options) |
227 | vbox = gtk.VBox() | 334 | kernel_opts.cumulative = False |
228 | window.add(vbox) | 335 | kernel_opts.charts = False |
229 | 336 | kernel_opts.kernel_only = True | |
230 | self.widget = PyBootchartWidget(res) | 337 | kernel_tree = PyBootchartShell(window, trace, kernel_opts, 5.0) |
231 | 338 | tab_page.append_page (kernel_tree, gtk.Label("Kernel boot")) | |
232 | # Create a UIManager instance | 339 | |
233 | uimanager = self.uimanager = gtk.UIManager() | 340 | full_tree.grab_focus(self) |
234 | 341 | self.show() | |
235 | # Add the accelerator group to the toplevel window | 342 | |
236 | accelgroup = uimanager.get_accel_group() | 343 | |
237 | window.add_accel_group(accelgroup) | 344 | def show(trace, options): |
238 | 345 | win = PyBootchartWindow(trace, options) | |
239 | # Create an ActionGroup | 346 | win.connect('destroy', gtk.main_quit) |
240 | actiongroup = gtk.ActionGroup('Actions') | 347 | gtk.main() |
241 | self.actiongroup = actiongroup | ||
242 | |||
243 | # Create actions | ||
244 | actiongroup.add_actions(( | ||
245 | ('ZoomIn', gtk.STOCK_ZOOM_IN, None, None, None, self.widget.on_zoom_in), | ||
246 | ('ZoomOut', gtk.STOCK_ZOOM_OUT, None, None, None, self.widget.on_zoom_out), | ||
247 | ('ZoomFit', gtk.STOCK_ZOOM_FIT, 'Fit Width', None, None, self.widget.on_zoom_fit), | ||
248 | ('Zoom100', gtk.STOCK_ZOOM_100, None, None, None, self.widget.on_zoom_100), | ||
249 | )) | ||
250 | |||
251 | # Add the actiongroup to the uimanager | ||
252 | uimanager.insert_action_group(actiongroup, 0) | ||
253 | |||
254 | # Add a UI description | ||
255 | uimanager.add_ui_from_string(self.ui) | ||
256 | |||
257 | # Scrolled window | ||
258 | scrolled = gtk.ScrolledWindow() | ||
259 | scrolled.add(self.widget) | ||
260 | |||
261 | # Create a Toolbar | ||
262 | toolbar = uimanager.get_widget('/ToolBar') | ||
263 | vbox.pack_start(toolbar, False) | ||
264 | vbox.pack_start(scrolled) | ||
265 | |||
266 | self.set_focus(self.widget) | ||
267 | |||
268 | self.show_all() | ||
269 | |||
270 | def show(res): | ||
271 | win = PyBootchartWindow(res) | ||
272 | win.connect('destroy', gtk.main_quit) | ||
273 | gtk.main() | ||