diff options
Diffstat (limited to 'bitbake/lib/bb/ui/crumbs/imagedetailspage.py')
-rwxr-xr-x | bitbake/lib/bb/ui/crumbs/imagedetailspage.py | 669 |
1 files changed, 669 insertions, 0 deletions
diff --git a/bitbake/lib/bb/ui/crumbs/imagedetailspage.py b/bitbake/lib/bb/ui/crumbs/imagedetailspage.py new file mode 100755 index 0000000000..b5d9660218 --- /dev/null +++ b/bitbake/lib/bb/ui/crumbs/imagedetailspage.py | |||
@@ -0,0 +1,669 @@ | |||
1 | #!/usr/bin/env python | ||
2 | # | ||
3 | # BitBake Graphical GTK User Interface | ||
4 | # | ||
5 | # Copyright (C) 2012 Intel Corporation | ||
6 | # | ||
7 | # Authored by Dongxiao Xu <dongxiao.xu@intel.com> | ||
8 | # Authored by Shane Wang <shane.wang@intel.com> | ||
9 | # | ||
10 | # This program is free software; you can redistribute it and/or modify | ||
11 | # it under the terms of the GNU General Public License version 2 as | ||
12 | # published by the Free Software Foundation. | ||
13 | # | ||
14 | # This program is distributed in the hope that it will be useful, | ||
15 | # but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
16 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
17 | # GNU General Public License for more details. | ||
18 | # | ||
19 | # You should have received a copy of the GNU General Public License along | ||
20 | # with this program; if not, write to the Free Software Foundation, Inc., | ||
21 | # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. | ||
22 | |||
23 | import gobject | ||
24 | import gtk | ||
25 | from bb.ui.crumbs.hobcolor import HobColors | ||
26 | from bb.ui.crumbs.hobwidget import hic, HobViewTable, HobAltButton, HobButton | ||
27 | from bb.ui.crumbs.hobpages import HobPage | ||
28 | import subprocess | ||
29 | from bb.ui.crumbs.hig.crumbsdialog import CrumbsDialog | ||
30 | from bb.ui.crumbs.hig.saveimagedialog import SaveImageDialog | ||
31 | |||
32 | # | ||
33 | # ImageDetailsPage | ||
34 | # | ||
35 | class ImageDetailsPage (HobPage): | ||
36 | |||
37 | class DetailBox (gtk.EventBox): | ||
38 | def __init__(self, widget = None, varlist = None, vallist = None, icon = None, button = None, button2=None, color = HobColors.LIGHT_GRAY): | ||
39 | gtk.EventBox.__init__(self) | ||
40 | |||
41 | # set color | ||
42 | style = self.get_style().copy() | ||
43 | style.bg[gtk.STATE_NORMAL] = self.get_colormap().alloc_color(color, False, False) | ||
44 | self.set_style(style) | ||
45 | |||
46 | self.row = gtk.Table(1, 2, False) | ||
47 | self.row.set_border_width(10) | ||
48 | self.add(self.row) | ||
49 | |||
50 | total_rows = 0 | ||
51 | if widget: | ||
52 | total_rows = 10 | ||
53 | if varlist and vallist: | ||
54 | # pack the icon and the text on the left | ||
55 | total_rows += len(varlist) | ||
56 | self.table = gtk.Table(total_rows, 20, True) | ||
57 | self.table.set_row_spacings(6) | ||
58 | self.table.set_size_request(100, -1) | ||
59 | self.row.attach(self.table, 0, 1, 0, 1, xoptions=gtk.FILL|gtk.EXPAND, yoptions=gtk.FILL) | ||
60 | |||
61 | colid = 0 | ||
62 | rowid = 0 | ||
63 | self.line_widgets = {} | ||
64 | if icon: | ||
65 | self.table.attach(icon, colid, colid + 2, 0, 1) | ||
66 | colid = colid + 2 | ||
67 | if widget: | ||
68 | self.table.attach(widget, colid, 20, 0, 10) | ||
69 | rowid = 10 | ||
70 | if varlist and vallist: | ||
71 | for row in range(rowid, total_rows): | ||
72 | index = row - rowid | ||
73 | self.line_widgets[varlist[index]] = self.text2label(varlist[index], vallist[index]) | ||
74 | self.table.attach(self.line_widgets[varlist[index]], colid, 20, row, row + 1) | ||
75 | # pack the button on the right | ||
76 | if button: | ||
77 | self.bbox = gtk.VBox() | ||
78 | self.bbox.pack_start(button, expand=True, fill=False) | ||
79 | if button2: | ||
80 | self.bbox.pack_start(button2, expand=True, fill=False) | ||
81 | self.bbox.set_size_request(150,-1) | ||
82 | self.row.attach(self.bbox, 1, 2, 0, 1, xoptions=gtk.FILL, yoptions=gtk.EXPAND) | ||
83 | |||
84 | def update_line_widgets(self, variable, value): | ||
85 | if len(self.line_widgets) == 0: | ||
86 | return | ||
87 | if not isinstance(self.line_widgets[variable], gtk.Label): | ||
88 | return | ||
89 | self.line_widgets[variable].set_markup(self.format_line(variable, value)) | ||
90 | |||
91 | def wrap_line(self, inputs): | ||
92 | # wrap the long text of inputs | ||
93 | wrap_width_chars = 75 | ||
94 | outputs = "" | ||
95 | tmps = inputs | ||
96 | less_chars = len(inputs) | ||
97 | while (less_chars - wrap_width_chars) > 0: | ||
98 | less_chars -= wrap_width_chars | ||
99 | outputs += tmps[:wrap_width_chars] + "\n " | ||
100 | tmps = inputs[less_chars:] | ||
101 | outputs += tmps | ||
102 | return outputs | ||
103 | |||
104 | def format_line(self, variable, value): | ||
105 | wraped_value = self.wrap_line(value) | ||
106 | markup = "<span weight=\'bold\'>%s</span>" % variable | ||
107 | markup += "<span weight=\'normal\' foreground=\'#1c1c1c\' font_desc=\'14px\'>%s</span>" % wraped_value | ||
108 | return markup | ||
109 | |||
110 | def text2label(self, variable, value): | ||
111 | # append the name:value to the left box | ||
112 | # such as "Name: hob-core-minimal-variant-2011-12-15-beagleboard" | ||
113 | label = gtk.Label() | ||
114 | label.set_alignment(0.0, 0.5) | ||
115 | label.set_markup(self.format_line(variable, value)) | ||
116 | return label | ||
117 | |||
118 | class BuildDetailBox (gtk.EventBox): | ||
119 | def __init__(self, varlist = None, vallist = None, icon = None, color = HobColors.LIGHT_GRAY): | ||
120 | gtk.EventBox.__init__(self) | ||
121 | |||
122 | # set color | ||
123 | style = self.get_style().copy() | ||
124 | style.bg[gtk.STATE_NORMAL] = self.get_colormap().alloc_color(color, False, False) | ||
125 | self.set_style(style) | ||
126 | |||
127 | self.hbox = gtk.HBox() | ||
128 | self.hbox.set_border_width(10) | ||
129 | self.add(self.hbox) | ||
130 | |||
131 | total_rows = 0 | ||
132 | if varlist and vallist: | ||
133 | # pack the icon and the text on the left | ||
134 | total_rows += len(varlist) | ||
135 | self.table = gtk.Table(total_rows, 20, True) | ||
136 | self.table.set_row_spacings(6) | ||
137 | self.table.set_size_request(100, -1) | ||
138 | self.hbox.pack_start(self.table, expand=True, fill=True, padding=15) | ||
139 | |||
140 | colid = 0 | ||
141 | rowid = 0 | ||
142 | self.line_widgets = {} | ||
143 | if icon: | ||
144 | self.table.attach(icon, colid, colid + 2, 0, 1) | ||
145 | colid = colid + 2 | ||
146 | if varlist and vallist: | ||
147 | for row in range(rowid, total_rows): | ||
148 | index = row - rowid | ||
149 | self.line_widgets[varlist[index]] = self.text2label(varlist[index], vallist[index]) | ||
150 | self.table.attach(self.line_widgets[varlist[index]], colid, 20, row, row + 1) | ||
151 | |||
152 | def update_line_widgets(self, variable, value): | ||
153 | if len(self.line_widgets) == 0: | ||
154 | return | ||
155 | if not isinstance(self.line_widgets[variable], gtk.Label): | ||
156 | return | ||
157 | self.line_widgets[variable].set_markup(self.format_line(variable, value)) | ||
158 | |||
159 | def wrap_line(self, inputs): | ||
160 | # wrap the long text of inputs | ||
161 | wrap_width_chars = 75 | ||
162 | outputs = "" | ||
163 | tmps = inputs | ||
164 | less_chars = len(inputs) | ||
165 | while (less_chars - wrap_width_chars) > 0: | ||
166 | less_chars -= wrap_width_chars | ||
167 | outputs += tmps[:wrap_width_chars] + "\n " | ||
168 | tmps = inputs[less_chars:] | ||
169 | outputs += tmps | ||
170 | return outputs | ||
171 | |||
172 | def format_line(self, variable, value): | ||
173 | wraped_value = self.wrap_line(value) | ||
174 | markup = "<span weight=\'bold\'>%s</span>" % variable | ||
175 | markup += "<span weight=\'normal\' foreground=\'#1c1c1c\' font_desc=\'14px\'>%s</span>" % wraped_value | ||
176 | return markup | ||
177 | |||
178 | def text2label(self, variable, value): | ||
179 | # append the name:value to the left box | ||
180 | # such as "Name: hob-core-minimal-variant-2011-12-15-beagleboard" | ||
181 | label = gtk.Label() | ||
182 | label.set_alignment(0.0, 0.5) | ||
183 | label.set_markup(self.format_line(variable, value)) | ||
184 | return label | ||
185 | |||
186 | def __init__(self, builder): | ||
187 | super(ImageDetailsPage, self).__init__(builder, "Image details") | ||
188 | |||
189 | self.image_store = [] | ||
190 | self.button_ids = {} | ||
191 | self.details_bottom_buttons = gtk.HBox(False, 6) | ||
192 | self.image_saved = False | ||
193 | self.create_visual_elements() | ||
194 | self.name_field_template = "" | ||
195 | self.description_field_template = "" | ||
196 | |||
197 | def create_visual_elements(self): | ||
198 | # create visual elements | ||
199 | # create the toolbar | ||
200 | self.toolbar = gtk.Toolbar() | ||
201 | self.toolbar.set_orientation(gtk.ORIENTATION_HORIZONTAL) | ||
202 | self.toolbar.set_style(gtk.TOOLBAR_BOTH) | ||
203 | |||
204 | my_images_button = self.append_toolbar_button(self.toolbar, | ||
205 | "Images", | ||
206 | hic.ICON_IMAGES_DISPLAY_FILE, | ||
207 | hic.ICON_IMAGES_HOVER_FILE, | ||
208 | "Open previously built images", | ||
209 | self.my_images_button_clicked_cb) | ||
210 | settings_button = self.append_toolbar_button(self.toolbar, | ||
211 | "Settings", | ||
212 | hic.ICON_SETTINGS_DISPLAY_FILE, | ||
213 | hic.ICON_SETTINGS_HOVER_FILE, | ||
214 | "View additional build settings", | ||
215 | self.settings_button_clicked_cb) | ||
216 | |||
217 | self.details_top_buttons = self.add_onto_top_bar(self.toolbar) | ||
218 | |||
219 | def _remove_all_widget(self): | ||
220 | children = self.get_children() or [] | ||
221 | for child in children: | ||
222 | self.remove(child) | ||
223 | children = self.box_group_area.get_children() or [] | ||
224 | for child in children: | ||
225 | self.box_group_area.remove(child) | ||
226 | children = self.details_bottom_buttons.get_children() or [] | ||
227 | for child in children: | ||
228 | self.details_bottom_buttons.remove(child) | ||
229 | |||
230 | def show_page(self, step): | ||
231 | self.build_succeeded = (step == self.builder.IMAGE_GENERATED) | ||
232 | image_addr = self.builder.parameters.image_addr | ||
233 | image_names = self.builder.parameters.image_names | ||
234 | if self.build_succeeded: | ||
235 | machine = self.builder.configuration.curr_mach | ||
236 | base_image = self.builder.recipe_model.get_selected_image() | ||
237 | layers = self.builder.configuration.layers | ||
238 | pkg_num = "%s" % len(self.builder.package_model.get_selected_packages()) | ||
239 | log_file = self.builder.current_logfile | ||
240 | else: | ||
241 | pkg_num = "N/A" | ||
242 | log_file = None | ||
243 | |||
244 | # remove | ||
245 | for button_id, button in self.button_ids.items(): | ||
246 | button.disconnect(button_id) | ||
247 | self._remove_all_widget() | ||
248 | |||
249 | # repack | ||
250 | self.pack_start(self.details_top_buttons, expand=False, fill=False) | ||
251 | self.pack_start(self.group_align, expand=True, fill=True) | ||
252 | |||
253 | self.build_result = None | ||
254 | if self.image_saved or (self.build_succeeded and self.builder.current_step == self.builder.IMAGE_GENERATING): | ||
255 | # building is the previous step | ||
256 | icon = gtk.Image() | ||
257 | pixmap_path = hic.ICON_INDI_CONFIRM_FILE | ||
258 | color = HobColors.RUNNING | ||
259 | pix_buffer = gtk.gdk.pixbuf_new_from_file(pixmap_path) | ||
260 | icon.set_from_pixbuf(pix_buffer) | ||
261 | varlist = [""] | ||
262 | if self.image_saved: | ||
263 | vallist = ["Your image recipe has been saved"] | ||
264 | else: | ||
265 | vallist = ["Your image is ready"] | ||
266 | self.build_result = self.BuildDetailBox(varlist=varlist, vallist=vallist, icon=icon, color=color) | ||
267 | self.box_group_area.pack_start(self.build_result, expand=False, fill=False) | ||
268 | |||
269 | self.buttonlist = ["Build new image", "Save image recipe", "Run image", "Deploy image"] | ||
270 | |||
271 | # Name | ||
272 | self.image_store = [] | ||
273 | self.toggled_image = "" | ||
274 | default_image_size = 0 | ||
275 | self.num_toggled = 0 | ||
276 | i = 0 | ||
277 | for image_name in image_names: | ||
278 | image_size = HobPage._size_to_string(os.stat(os.path.join(image_addr, image_name)).st_size) | ||
279 | |||
280 | image_attr = ("run" if (self.test_type_runnable(image_name) and self.test_mach_runnable(image_name)) else \ | ||
281 | ("deploy" if self.test_deployable(image_name) else "")) | ||
282 | is_toggled = (image_attr != "") | ||
283 | |||
284 | if not self.toggled_image: | ||
285 | if i == (len(image_names) - 1): | ||
286 | is_toggled = True | ||
287 | if is_toggled: | ||
288 | default_image_size = image_size | ||
289 | self.toggled_image = image_name | ||
290 | |||
291 | split_stuff = image_name.split('.') | ||
292 | if "rootfs" in split_stuff: | ||
293 | image_type = image_name[(len(split_stuff[0]) + len(".rootfs") + 1):] | ||
294 | else: | ||
295 | image_type = image_name[(len(split_stuff[0]) + 1):] | ||
296 | |||
297 | self.image_store.append({'name': image_name, | ||
298 | 'type': image_type, | ||
299 | 'size': image_size, | ||
300 | 'is_toggled': is_toggled, | ||
301 | 'action_attr': image_attr,}) | ||
302 | |||
303 | i = i + 1 | ||
304 | self.num_toggled += is_toggled | ||
305 | |||
306 | is_runnable = self.create_bottom_buttons(self.buttonlist, self.toggled_image) | ||
307 | |||
308 | # Generated image files info | ||
309 | varlist = ["Name: ", "Files created: ", "Directory: "] | ||
310 | vallist = [] | ||
311 | |||
312 | vallist.append(image_name.split('.')[0]) | ||
313 | vallist.append(', '.join(fileitem['type'] for fileitem in self.image_store)) | ||
314 | vallist.append(image_addr) | ||
315 | |||
316 | view_files_button = HobAltButton("View files") | ||
317 | view_files_button.connect("clicked", self.view_files_clicked_cb, image_addr) | ||
318 | view_files_button.set_tooltip_text("Open the directory containing the image files") | ||
319 | open_log_button = None | ||
320 | if log_file: | ||
321 | open_log_button = HobAltButton("Open log") | ||
322 | open_log_button.connect("clicked", self.open_log_clicked_cb, log_file) | ||
323 | open_log_button.set_tooltip_text("Open the build's log file") | ||
324 | self.image_detail = self.DetailBox(varlist=varlist, vallist=vallist, button=view_files_button, button2=open_log_button) | ||
325 | self.box_group_area.pack_start(self.image_detail, expand=False, fill=True) | ||
326 | |||
327 | # The default kernel box for the qemu images | ||
328 | self.sel_kernel = "" | ||
329 | self.kernel_detail = None | ||
330 | if 'qemu' in image_name: | ||
331 | self.sel_kernel = self.get_kernel_file_name() | ||
332 | |||
333 | # varlist = ["Kernel: "] | ||
334 | # vallist = [] | ||
335 | # vallist.append(self.sel_kernel) | ||
336 | |||
337 | # change_kernel_button = HobAltButton("Change") | ||
338 | # change_kernel_button.connect("clicked", self.change_kernel_cb) | ||
339 | # change_kernel_button.set_tooltip_text("Change qemu kernel file") | ||
340 | # self.kernel_detail = self.DetailBox(varlist=varlist, vallist=vallist, button=change_kernel_button) | ||
341 | # self.box_group_area.pack_start(self.kernel_detail, expand=True, fill=True) | ||
342 | |||
343 | # Machine, Image recipe and Layers | ||
344 | layer_num_limit = 15 | ||
345 | varlist = ["Machine: ", "Image recipe: ", "Layers: "] | ||
346 | vallist = [] | ||
347 | self.setting_detail = None | ||
348 | if self.build_succeeded: | ||
349 | vallist.append(machine) | ||
350 | if self.builder.recipe_model.is_custom_image(): | ||
351 | if self.builder.configuration.initial_selected_image == self.builder.recipe_model.__custom_image__: | ||
352 | base_image ="New image recipe" | ||
353 | else: | ||
354 | base_image = self.builder.configuration.initial_selected_image + " (edited)" | ||
355 | vallist.append(base_image) | ||
356 | i = 0 | ||
357 | for layer in layers: | ||
358 | varlist.append(" - ") | ||
359 | if i > layer_num_limit: | ||
360 | break | ||
361 | i += 1 | ||
362 | vallist.append("") | ||
363 | i = 0 | ||
364 | for layer in layers: | ||
365 | if i > layer_num_limit: | ||
366 | break | ||
367 | elif i == layer_num_limit: | ||
368 | vallist.append("and more...") | ||
369 | else: | ||
370 | vallist.append(layer) | ||
371 | i += 1 | ||
372 | |||
373 | edit_config_button = HobAltButton("Edit configuration") | ||
374 | edit_config_button.set_tooltip_text("Edit machine and image recipe") | ||
375 | edit_config_button.connect("clicked", self.edit_config_button_clicked_cb) | ||
376 | self.setting_detail = self.DetailBox(varlist=varlist, vallist=vallist, button=edit_config_button) | ||
377 | self.box_group_area.pack_start(self.setting_detail, expand=True, fill=True) | ||
378 | |||
379 | # Packages included, and Total image size | ||
380 | varlist = ["Packages included: ", "Total image size: "] | ||
381 | vallist = [] | ||
382 | vallist.append(pkg_num) | ||
383 | vallist.append(default_image_size) | ||
384 | self.builder.configuration.image_size = default_image_size | ||
385 | self.builder.configuration.image_packages = self.builder.configuration.selected_packages | ||
386 | if self.build_succeeded: | ||
387 | edit_packages_button = HobAltButton("Edit packages") | ||
388 | edit_packages_button.set_tooltip_text("Edit the packages included in your image") | ||
389 | edit_packages_button.connect("clicked", self.edit_packages_button_clicked_cb) | ||
390 | else: # get to this page from "My images" | ||
391 | edit_packages_button = None | ||
392 | self.package_detail = self.DetailBox(varlist=varlist, vallist=vallist, button=edit_packages_button) | ||
393 | self.box_group_area.pack_start(self.package_detail, expand=True, fill=True) | ||
394 | |||
395 | # pack the buttons at the bottom, at this time they are already created. | ||
396 | if self.build_succeeded: | ||
397 | self.box_group_area.pack_end(self.details_bottom_buttons, expand=False, fill=False) | ||
398 | else: # for "My images" page | ||
399 | self.details_separator = gtk.HSeparator() | ||
400 | self.box_group_area.pack_start(self.details_separator, expand=False, fill=False) | ||
401 | self.box_group_area.pack_start(self.details_bottom_buttons, expand=False, fill=False) | ||
402 | |||
403 | self.show_all() | ||
404 | if self.kernel_detail and (not is_runnable): | ||
405 | self.kernel_detail.hide() | ||
406 | self.image_saved = False | ||
407 | |||
408 | def view_files_clicked_cb(self, button, image_addr): | ||
409 | subprocess.call("xdg-open /%s" % image_addr, shell=True) | ||
410 | |||
411 | def open_log_clicked_cb(self, button, log_file): | ||
412 | if log_file: | ||
413 | log_file = "file:///" + log_file | ||
414 | gtk.show_uri(screen=button.get_screen(), uri=log_file, timestamp=0) | ||
415 | |||
416 | def refresh_package_detail_box(self, image_size): | ||
417 | self.package_detail.update_line_widgets("Total image size: ", image_size) | ||
418 | |||
419 | def test_type_runnable(self, image_name): | ||
420 | type_runnable = False | ||
421 | for t in self.builder.parameters.runnable_image_types: | ||
422 | if image_name.endswith(t): | ||
423 | type_runnable = True | ||
424 | break | ||
425 | return type_runnable | ||
426 | |||
427 | def test_mach_runnable(self, image_name): | ||
428 | mach_runnable = False | ||
429 | for t in self.builder.parameters.runnable_machine_patterns: | ||
430 | if t in image_name: | ||
431 | mach_runnable = True | ||
432 | break | ||
433 | return mach_runnable | ||
434 | |||
435 | def test_deployable(self, image_name): | ||
436 | if self.builder.configuration.curr_mach.startswith("qemu"): | ||
437 | return False | ||
438 | deployable = False | ||
439 | for t in self.builder.parameters.deployable_image_types: | ||
440 | if image_name.endswith(t): | ||
441 | deployable = True | ||
442 | break | ||
443 | return deployable | ||
444 | |||
445 | def get_kernel_file_name(self, kernel_addr=""): | ||
446 | kernel_name = "" | ||
447 | |||
448 | if not kernel_addr: | ||
449 | kernel_addr = self.builder.parameters.image_addr | ||
450 | |||
451 | files = [f for f in os.listdir(kernel_addr) if f[0] <> '.'] | ||
452 | for check_file in files: | ||
453 | if check_file.endswith(".bin"): | ||
454 | name_splits = check_file.split(".")[0] | ||
455 | if self.builder.parameters.kernel_image_type in name_splits.split("-"): | ||
456 | kernel_name = check_file | ||
457 | break | ||
458 | |||
459 | return kernel_name | ||
460 | |||
461 | def show_builded_images_dialog(self, widget, primary_action=""): | ||
462 | title = primary_action if primary_action else "Your builded images" | ||
463 | dialog = CrumbsDialog(title, self.builder, | ||
464 | gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT) | ||
465 | dialog.set_border_width(12) | ||
466 | |||
467 | label = gtk.Label() | ||
468 | label.set_use_markup(True) | ||
469 | label.set_alignment(0.0, 0.5) | ||
470 | label.set_padding(12,0) | ||
471 | if primary_action == "Run image": | ||
472 | label.set_markup("<span font_desc='12'>Select the image file you want to run:</span>") | ||
473 | elif primary_action == "Deploy image": | ||
474 | label.set_markup("<span font_desc='12'>Select the image file you want to deploy:</span>") | ||
475 | else: | ||
476 | label.set_markup("<span font_desc='12'>Select the image file you want to %s</span>" % primary_action) | ||
477 | dialog.vbox.pack_start(label, expand=False, fill=False) | ||
478 | |||
479 | # filter created images as action attribution (deploy or run) | ||
480 | action_attr = "" | ||
481 | action_images = [] | ||
482 | for fileitem in self.image_store: | ||
483 | action_attr = fileitem['action_attr'] | ||
484 | if (action_attr == 'run' and primary_action == "Run image") \ | ||
485 | or (action_attr == 'deploy' and primary_action == "Deploy image"): | ||
486 | action_images.append(fileitem) | ||
487 | |||
488 | # pack the corresponding 'runnable' or 'deploy' radio_buttons, if there has no more than one file. | ||
489 | # assume that there does not both have 'deploy' and 'runnable' files in the same building result | ||
490 | # in possible as design. | ||
491 | curr_row = 0 | ||
492 | rows = (len(action_images)) if len(action_images) < 10 else 10 | ||
493 | table = gtk.Table(rows, 10, True) | ||
494 | table.set_row_spacings(6) | ||
495 | table.set_col_spacing(0, 12) | ||
496 | table.set_col_spacing(5, 12) | ||
497 | |||
498 | sel_parent_btn = None | ||
499 | for fileitem in action_images: | ||
500 | sel_btn = gtk.RadioButton(sel_parent_btn, fileitem['type']) | ||
501 | sel_parent_btn = sel_btn if not sel_parent_btn else sel_parent_btn | ||
502 | sel_btn.set_active(fileitem['is_toggled']) | ||
503 | sel_btn.connect('toggled', self.table_selected_cb, fileitem) | ||
504 | if curr_row < 10: | ||
505 | table.attach(sel_btn, 0, 4, curr_row, curr_row + 1, xpadding=24) | ||
506 | else: | ||
507 | table.attach(sel_btn, 5, 9, curr_row - 10, curr_row - 9, xpadding=24) | ||
508 | curr_row += 1 | ||
509 | |||
510 | dialog.vbox.pack_start(table, expand=False, fill=False, padding=6) | ||
511 | |||
512 | button = dialog.add_button("Cancel", gtk.RESPONSE_CANCEL) | ||
513 | HobAltButton.style_button(button) | ||
514 | |||
515 | if primary_action: | ||
516 | button = dialog.add_button(primary_action, gtk.RESPONSE_YES) | ||
517 | HobButton.style_button(button) | ||
518 | |||
519 | dialog.show_all() | ||
520 | |||
521 | response = dialog.run() | ||
522 | dialog.destroy() | ||
523 | |||
524 | if response != gtk.RESPONSE_YES: | ||
525 | return | ||
526 | |||
527 | for fileitem in self.image_store: | ||
528 | if fileitem['is_toggled']: | ||
529 | if fileitem['action_attr'] == 'run': | ||
530 | self.builder.runqemu_image(fileitem['name'], self.sel_kernel) | ||
531 | elif fileitem['action_attr'] == 'deploy': | ||
532 | self.builder.deploy_image(fileitem['name']) | ||
533 | |||
534 | def table_selected_cb(self, tbutton, image): | ||
535 | image['is_toggled'] = tbutton.get_active() | ||
536 | if image['is_toggled']: | ||
537 | self.toggled_image = image['name'] | ||
538 | |||
539 | def change_kernel_cb(self, widget): | ||
540 | kernel_path = self.builder.show_load_kernel_dialog() | ||
541 | if kernel_path and self.kernel_detail: | ||
542 | import os.path | ||
543 | self.sel_kernel = os.path.basename(kernel_path) | ||
544 | markup = self.kernel_detail.format_line("Kernel: ", self.sel_kernel) | ||
545 | label = ((self.kernel_detail.get_children()[0]).get_children()[0]).get_children()[0] | ||
546 | label.set_markup(markup) | ||
547 | |||
548 | def create_bottom_buttons(self, buttonlist, image_name): | ||
549 | # Create the buttons at the bottom | ||
550 | created = False | ||
551 | packed = False | ||
552 | self.button_ids = {} | ||
553 | is_runnable = False | ||
554 | |||
555 | # create button "Deploy image" | ||
556 | name = "Deploy image" | ||
557 | if name in buttonlist and self.test_deployable(image_name): | ||
558 | deploy_button = HobButton('Deploy image') | ||
559 | #deploy_button.set_size_request(205, 49) | ||
560 | deploy_button.set_tooltip_text("Burn a live image to a USB drive or flash memory") | ||
561 | deploy_button.set_flags(gtk.CAN_DEFAULT) | ||
562 | button_id = deploy_button.connect("clicked", self.deploy_button_clicked_cb) | ||
563 | self.button_ids[button_id] = deploy_button | ||
564 | self.details_bottom_buttons.pack_end(deploy_button, expand=False, fill=False) | ||
565 | created = True | ||
566 | packed = True | ||
567 | |||
568 | name = "Run image" | ||
569 | if name in buttonlist and self.test_type_runnable(image_name) and self.test_mach_runnable(image_name): | ||
570 | if created == True: | ||
571 | # separator | ||
572 | #label = gtk.Label(" or ") | ||
573 | #self.details_bottom_buttons.pack_end(label, expand=False, fill=False) | ||
574 | |||
575 | # create button "Run image" | ||
576 | run_button = HobAltButton("Run image") | ||
577 | else: | ||
578 | # create button "Run image" as the primary button | ||
579 | run_button = HobButton("Run image") | ||
580 | #run_button.set_size_request(205, 49) | ||
581 | run_button.set_flags(gtk.CAN_DEFAULT) | ||
582 | packed = True | ||
583 | run_button.set_tooltip_text("Start up an image with qemu emulator") | ||
584 | button_id = run_button.connect("clicked", self.run_button_clicked_cb) | ||
585 | self.button_ids[button_id] = run_button | ||
586 | self.details_bottom_buttons.pack_end(run_button, expand=False, fill=False) | ||
587 | created = True | ||
588 | is_runnable = True | ||
589 | |||
590 | name = "Save image recipe" | ||
591 | if name in buttonlist and self.builder.recipe_model.is_custom_image(): | ||
592 | save_button = HobAltButton("Save image recipe") | ||
593 | save_button.set_tooltip_text("Keep your changes saving them as an image recipe") | ||
594 | save_button.set_sensitive(not self.image_saved) | ||
595 | button_id = save_button.connect("clicked", self.save_button_clicked_cb) | ||
596 | self.button_ids[button_id] = save_button | ||
597 | self.details_bottom_buttons.pack_end(save_button, expand=False, fill=False) | ||
598 | |||
599 | name = "Build new image" | ||
600 | if name in buttonlist: | ||
601 | # create button "Build new image" | ||
602 | if packed: | ||
603 | build_new_button = HobAltButton("Build new image") | ||
604 | else: | ||
605 | build_new_button = HobButton("Build new image") | ||
606 | build_new_button.set_flags(gtk.CAN_DEFAULT) | ||
607 | #build_new_button.set_size_request(205, 49) | ||
608 | self.details_bottom_buttons.pack_end(build_new_button, expand=False, fill=False) | ||
609 | build_new_button.set_tooltip_text("Create a new image from scratch") | ||
610 | button_id = build_new_button.connect("clicked", self.build_new_button_clicked_cb) | ||
611 | self.button_ids[button_id] = build_new_button | ||
612 | |||
613 | return is_runnable | ||
614 | |||
615 | def deploy_button_clicked_cb(self, button): | ||
616 | if self.toggled_image: | ||
617 | if self.num_toggled > 1: | ||
618 | self.set_sensitive(False) | ||
619 | self.show_builded_images_dialog(None, "Deploy image") | ||
620 | self.set_sensitive(True) | ||
621 | else: | ||
622 | self.builder.deploy_image(self.toggled_image) | ||
623 | |||
624 | def run_button_clicked_cb(self, button): | ||
625 | if self.toggled_image: | ||
626 | if self.num_toggled > 1: | ||
627 | self.set_sensitive(False) | ||
628 | self.show_builded_images_dialog(None, "Run image") | ||
629 | self.set_sensitive(True) | ||
630 | else: | ||
631 | self.builder.runqemu_image(self.toggled_image, self.sel_kernel) | ||
632 | |||
633 | def save_button_clicked_cb(self, button): | ||
634 | topdir = self.builder.get_topdir() | ||
635 | images_dir = topdir + "/recipes/images/" | ||
636 | self.builder.ensure_dir(images_dir) | ||
637 | |||
638 | self.name_field_template = self.builder.image_configuration_page.custom_image_selected | ||
639 | if self.name_field_template: | ||
640 | image_path = self.builder.recipe_model.pn_path[self.name_field_template] | ||
641 | image_iter = self.builder.recipe_model.get_iter(image_path) | ||
642 | self.description_field_template = self.builder.recipe_model.get_value(image_iter, self.builder.recipe_model.COL_DESC) | ||
643 | else: | ||
644 | self.name_field_template = "" | ||
645 | |||
646 | dialog = SaveImageDialog(images_dir, self.name_field_template, self.description_field_template, | ||
647 | "Save image recipe", self.builder, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT) | ||
648 | response = dialog.run() | ||
649 | dialog.destroy() | ||
650 | |||
651 | def build_new_button_clicked_cb(self, button): | ||
652 | self.builder.initiate_new_build_async() | ||
653 | |||
654 | def edit_config_button_clicked_cb(self, button): | ||
655 | self.builder.show_configuration() | ||
656 | |||
657 | def edit_packages_button_clicked_cb(self, button): | ||
658 | self.builder.show_packages(ask=False) | ||
659 | |||
660 | def my_images_button_clicked_cb(self, button): | ||
661 | self.builder.show_load_my_images_dialog() | ||
662 | |||
663 | def settings_button_clicked_cb(self, button): | ||
664 | # Create an advanced settings dialog | ||
665 | response, settings_changed = self.builder.show_simple_settings_dialog() | ||
666 | if not response: | ||
667 | return | ||
668 | if settings_changed: | ||
669 | self.builder.reparse_post_adv_settings() | ||