tobi/M7350
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
2d95e8761a
M7350/oe-core/bitbake/lib/bb/ui/hob.py

1112 lines
44 KiB
Python
Raw Normal View History

M7350v1_en_gpl
2024-09-09 08:52:07 +00:00
#
# BitBake Graphical GTK User Interface
#
# Copyright (C) 2011 Intel Corporation
#
# Authored by Joshua Lock <josh@linux.intel.com>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
import glib
import gobject
import gtk
from bb.ui.crumbs.tasklistmodel import TaskListModel, BuildRep
from bb.ui.crumbs.hobeventhandler import HobHandler
from bb.ui.crumbs.configurator import Configurator
from bb.ui.crumbs.hobprefs import HobPrefs
from bb.ui.crumbs.layereditor import LayerEditor
from bb.ui.crumbs.runningbuild import RunningBuildTreeView, RunningBuild
from bb.ui.crumbs.hig import CrumbsDialog
import xmlrpclib
import logging
import Queue
extraCaches = ['bb.cache_extra:HobRecipeInfo']
class MainWindow (gtk.Window):
def __init__(self, taskmodel, handler, configurator, prefs, layers, mach):
gtk.Window.__init__(self)
# global state
self.curr_mach = mach
self.machine_handler_id = None
self.image_combo_id = None
self.generating = False
self.files_to_clean = []
self.selected_image = None
self.selected_packages = None
self.stopping = False
self.model = taskmodel
self.model.connect("tasklist-populated", self.update_model)
self.model.connect("image-changed", self.image_changed_string_cb)
self.handler = handler
self.configurator = configurator
self.prefs = prefs
self.layers = layers
self.save_path = None
self.dirty = False
self.build_succeeded = False
self.connect("delete-event", self.destroy_window)
self.set_title("Image Creator")
self.set_icon_name("applications-development")
self.set_default_size(1000, 650)
self.build = RunningBuild(sequential=True)
self.build.connect("build-failed", self.running_build_failed_cb)
self.build.connect("build-succeeded", self.running_build_succeeded_cb)
self.build.connect("build-started", self.build_started_cb)
self.build.connect("build-complete", self.build_complete_cb)
vbox = gtk.VBox(False, 0)
vbox.set_border_width(0)
vbox.show()
self.add(vbox)
self.menu = self.create_menu()
vbox.pack_start(self.menu, False)
createview = self.create_build_gui()
self.back = None
self.cancel = None
buildview = self.view_build_gui()
self.nb = gtk.Notebook()
self.nb.append_page(createview)
self.nb.append_page(buildview)
self.nb.set_current_page(0)
self.nb.set_show_tabs(False)
vbox.pack_start(self.nb, expand=True, fill=True)
def destroy_window(self, widget, event):
self.quit()
def menu_quit(self, action):
self.quit()
def quit(self):
if self.dirty and len(self.model.contents):
question = "Would you like to save your customisations?"
dialog = CrumbsDialog(self, question, gtk.STOCK_DIALOG_WARNING)
dialog.add_buttons(gtk.STOCK_NO, gtk.RESPONSE_NO,
gtk.STOCK_YES, gtk.RESPONSE_YES)
resp = dialog.run()
dialog.destroy()
if resp == gtk.RESPONSE_YES:
if not self.save_path:
self.get_save_path()
if self.save_path:
self.save_recipe_file()
rep = self.model.get_build_rep()
rep.writeRecipe(self.save_path, self.model)
# Prevent the busy cursor being shown after hob exits if quit is called
# whilst the busy cursor is set
self.set_busy_cursor(False)
self.handler.remove_temp_dir()
gtk.main_quit()
"""
In the case of a fatal error give the user as much information as possible
and then exit.
"""
def fatal_error_cb(self, handler, errormsg, phase):
lbl = "<b>Error!</b>\nThere was an unrecoverable error during the"
lbl = lbl + " <i>%s</i> phase of BitBake. This must be" % phase
lbl = lbl + " rectified before the GUI will function. The error"
lbl = lbl + " message which which caused this is:\n\n\"%s\"" % errormsg
dialog = CrumbsDialog(self, lbl, gtk.STOCK_DIALOG_ERROR)
dialog.add_button("Exit", gtk.RESPONSE_OK)
response = dialog.run()
dialog.destroy()
self.set_busy_cursor(False)
gtk.main_quit()
def scroll_tv_cb(self, model, path, it, view):
view.scroll_to_cell(path)
def running_build_succeeded_cb(self, running_build):
self.build_succeeded = True
def running_build_failed_cb(self, running_build):
self.build_succeeded = False
def image_changed_string_cb(self, model, new_image):
self.selected_image = new_image
# disconnect the image combo's signal handler
if self.image_combo_id:
self.image_combo.disconnect(self.image_combo_id)
self.image_combo_id = None
cnt = 0
it = self.model.images.get_iter_first()
while it:
path = self.model.images.get_path(it)
if self.model.images[path][self.model.COL_NAME] == new_image:
self.image_combo.set_active(cnt)
break
it = self.model.images.iter_next(it)
cnt = cnt + 1
# Reconnect the signal handler
if not self.image_combo_id:
self.image_combo_id = self.image_combo.connect("changed", self.image_changed_cb)
def image_changed_cb(self, combo):
model = self.image_combo.get_model()
it = self.image_combo.get_active_iter()
if it:
path = model.get_path(it)
# Firstly, deselect the previous image
userp, _ = self.model.get_selected_packages()
self.model.reset()
# Now select the new image and save its path in case we
# change the image later
self.toggle_package(path, model, image=True)
if len(userp):
self.model.set_selected_packages(userp)
self.selected_image = model[path][self.model.COL_NAME]
def reload_triggered_cb(self, handler, image, packages):
if image:
self.selected_image = image
if len(packages):
self.selected_packages = packages.split()
def data_generated(self, handler):
self.generating = False
self.enable_widgets()
def machine_combo_changed_cb(self, combo, handler):
mach = combo.get_active_text()
if mach != self.curr_mach:
self.curr_mach = mach
# Flush this straight to the file as MACHINE is changed
# independently of other 'Preferences'
self.configurator.setConfVar('MACHINE', mach)
self.configurator.writeConf()
handler.set_machine(mach)
handler.reload_data()
def update_machines(self, handler, machines):
active = 0
# disconnect the signal handler before updating the combo model
if self.machine_handler_id:
self.machine_combo.disconnect(self.machine_handler_id)
self.machine_handler_id = None
model = self.machine_combo.get_model()
if model:
model.clear()
for machine in machines:
self.machine_combo.append_text(machine)
if machine == self.curr_mach:
self.machine_combo.set_active(active)
active = active + 1
self.machine_handler_id = self.machine_combo.connect("changed", self.machine_combo_changed_cb, handler)
def set_busy_cursor(self, busy=True):
"""
Convenience method to set the cursor to a spinner when executing
a potentially lengthy process.
A busy value of False will set the cursor back to the default
left pointer.
"""
if busy:
cursor = gtk.gdk.Cursor(gtk.gdk.WATCH)
else:
# TODO: presumably the default cursor is different on RTL
# systems. Can we determine the default cursor? Or at least
# the cursor which is set before we change it?
cursor = gtk.gdk.Cursor(gtk.gdk.LEFT_PTR)
window = self.get_root_window()
window.set_cursor(cursor)
def busy_idle_func(self):
if self.generating:
self.progress.pulse()
return True
else:
if not self.image_combo_id:
self.image_combo_id = self.image_combo.connect("changed", self.image_changed_cb)
self.progress.set_text("Loaded")
self.progress.set_fraction(0.0)
self.set_busy_cursor(False)
return False
def busy(self, handler):
self.generating = True
self.progress.set_text("Loading...")
self.set_busy_cursor()
if self.image_combo_id:
self.image_combo.disconnect(self.image_combo_id)
self.image_combo_id = None
self.progress.pulse()
gobject.timeout_add (100, self.busy_idle_func)
self.disable_widgets()
def enable_widgets(self):
self.menu.set_sensitive(True)
self.machine_combo.set_sensitive(True)
self.image_combo.set_sensitive(True)
self.nb.set_sensitive(True)
self.contents_tree.set_sensitive(True)
def disable_widgets(self):
self.menu.set_sensitive(False)
self.machine_combo.set_sensitive(False)
self.image_combo.set_sensitive(False)
self.nb.set_sensitive(False)
self.contents_tree.set_sensitive(False)
def update_model(self, model):
# We want the packages model to be alphabetised and sortable so create
# a TreeModelSort to use in the view
pkgsaz_model = gtk.TreeModelSort(self.model.packages_model())
pkgsaz_model.set_sort_column_id(self.model.COL_NAME, gtk.SORT_ASCENDING)
# Unset default sort func so that we only toggle between A-Z and
# Z-A sorting
pkgsaz_model.set_default_sort_func(None)
self.pkgsaz_tree.set_model(pkgsaz_model)
self.image_combo.set_model(self.model.images_model())
# Without this the image combo is incorrectly sized on first load of the GUI
self.image_combo.set_active(0)
self.image_combo.set_active(-1)
if not self.image_combo_id:
self.image_combo_id = self.image_combo.connect("changed", self.image_changed_cb)
# We want the contents to be alphabetised so create a TreeModelSort to
# use in the view
contents_model = gtk.TreeModelSort(self.model.contents_model())
contents_model.set_sort_column_id(self.model.COL_NAME, gtk.SORT_ASCENDING)
# Unset default sort func so that we only toggle between A-Z and
# Z-A sorting
contents_model.set_default_sort_func(None)
self.contents_tree.set_model(contents_model)
self.tasks_tree.set_model(self.model.tasks_model())
if self.selected_image:
if self.image_combo_id:
self.image_combo.disconnect(self.image_combo_id)
self.image_combo_id = None
self.model.set_selected_image(self.selected_image)
if not self.image_combo_id:
self.image_combo_id = self.image_combo.connect("changed", self.image_changed_cb)
if self.selected_packages:
self.model.set_selected_packages(self.selected_packages)
def reset_clicked_cb(self, button):
lbl = "<b>Reset your selections?</b>\n\nAny new changes you have made will be lost"
dialog = CrumbsDialog(self, lbl, gtk.STOCK_DIALOG_WARNING)
dialog.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)
dialog.add_button("Reset", gtk.RESPONSE_OK)
response = dialog.run()
dialog.destroy()
if response == gtk.RESPONSE_OK:
self.reset_build()
self.search.set_text("")
self.selected_image = None
return
def reset_build(self):
if self.image_combo_id:
self.image_combo.disconnect(self.image_combo_id)
self.image_combo_id = None
self.image_combo.set_active(-1)
self.model.reset()
if not self.image_combo_id:
self.image_combo_id = self.image_combo.connect("changed", self.image_changed_cb)
def layers_cb(self, action):
resp = self.layers.run()
self.layers.save_current_layers()
self.layers.hide()
def add_layer_cb(self, action):
self.layers.find_layer(self)
self.layers.save_current_layers()
def preferences_cb(self, action):
resp = self.prefs.run()
self.prefs.write_changes()
self.prefs.hide()
def about_cb(self, action):
about = gtk.AboutDialog()
about.set_name("Image Creator")
about.set_copyright("Copyright (C) 2011 Intel Corporation")
about.set_authors(["Joshua Lock <josh@linux.intel.com>"])
about.set_logo_icon_name("applications-development")
about.run()
about.destroy()
def save_recipe_file(self):
rep = self.model.get_build_rep()
rep.writeRecipe(self.save_path, self.model)
self.dirty = False
def get_save_path(self):
chooser = gtk.FileChooserDialog(title=None, parent=self,
action=gtk.FILE_CHOOSER_ACTION_SAVE,
buttons=(gtk.STOCK_CANCEL,
gtk.RESPONSE_CANCEL,
gtk.STOCK_SAVE,
gtk.RESPONSE_OK,))
chooser.set_current_name("myimage.bb")
response = chooser.run()
if response == gtk.RESPONSE_OK:
save_path = chooser.get_filename()
else:
save_path = None
chooser.destroy()
self.save_path = save_path
def save_cb(self, action):
if not self.save_path:
self.get_save_path()
if self.save_path:
self.save_recipe_file()
def save_as_cb(self, action):
self.get_save_path()
if self.save_path:
self.save_recipe_file()
def open_cb(self, action):
chooser = gtk.FileChooserDialog(title=None, parent=self,
action=gtk.FILE_CHOOSER_ACTION_OPEN,
buttons=(gtk.STOCK_CANCEL,
gtk.RESPONSE_CANCEL,
gtk.STOCK_OPEN,
gtk.RESPONSE_OK))
response = chooser.run()
rep = BuildRep(None, None, None)
recipe = chooser.get_filename()
if response == gtk.RESPONSE_OK:
rep.loadRecipe(recipe)
self.save_path = recipe
self.model.load_image_rep(rep)
self.dirty = False
chooser.destroy()
def bake_clicked_cb(self, button):
build_image = True
rep = self.model.get_build_rep()
# If no base image and no user selected packages don't build anything
if not self.selected_image and not len(rep.userpkgs):
lbl = "<b>No selections made</b>\nYou have not made any selections"
lbl = lbl + " so there isn't anything to bake at this time."
dialog = CrumbsDialog(self, lbl, gtk.STOCK_DIALOG_INFO)
dialog.add_button(gtk.STOCK_OK, gtk.RESPONSE_OK)
dialog.run()
dialog.destroy()
return
# Else if no base image, ask whether to just build packages or whether
# to build a rootfs with the selected packages in
elif not self.selected_image:
lbl = "<b>Build empty image or only packages?</b>\nA base image"
lbl = lbl + " has not been selected.\n\'Empty image' will build"
lbl = lbl + " an image with only the selected packages as its"
lbl = lbl + " contents.\n'Packages Only' will build only the"
lbl = lbl + " selected packages, no image will be created"
dialog = CrumbsDialog(self, lbl, gtk.STOCK_DIALOG_WARNING)
dialog.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)
dialog.add_button("Empty Image", gtk.RESPONSE_OK)
dialog.add_button("Packages Only", gtk.RESPONSE_YES)
response = dialog.run()
dialog.destroy()
if response == gtk.RESPONSE_CANCEL:
return
elif response == gtk.RESPONSE_YES:
build_image = False
elif response == gtk.RESPONSE_OK:
rep.base_image = "empty"
# Ensure at least one value is set in IMAGE_FSTYPES.
have_selected_fstype = False
if (len(self.prefs.selected_image_types) and
len(self.prefs.selected_image_types[0])):
have_selected_fstype = True
if build_image and not have_selected_fstype:
lbl = "<b>No image output type selected</b>\nThere is no image output"
lbl = lbl + " selected for the build. Please set an output image type"
lbl = lbl + " in the preferences (Edit -> Preferences)."
dialog = CrumbsDialog(self, lbl, gtk.STOCK_DIALOG_INFO)
dialog.add_button(gtk.STOCK_OK, gtk.RESPONSE_OK)
dialog.run()
dialog.destroy()
return
elif build_image:
self.handler.make_temp_dir()
recipepath = self.handler.get_temp_recipe_path(rep.base_image)
image_name = recipepath.rstrip(".bb")
path, sep, image_name = image_name.rpartition("/")
image = []
image.append(image_name)
rep.writeRecipe(recipepath, self.model)
# In the case where we saved the file for the purpose of building
# it we should then delete it so that the users workspace doesn't
# contain files they haven't explicitly saved there.
if not self.save_path:
self.files_to_clean.append(recipepath)
self.handler.build_targets(image, self.configurator)
else:
self.handler.build_targets(self.model.get_selected_pn(), self.configurator, "packages")
# Disable parts of the menu which shouldn't be used whilst building
self.set_menus_sensitive(False)
self.nb.set_current_page(1)
def set_menus_sensitive(self, sensitive):
self.add_layers_action.set_sensitive(sensitive)
self.layers_action.set_sensitive(sensitive)
self.prefs_action.set_sensitive(sensitive)
self.open_action.set_sensitive(sensitive)
def back_button_clicked_cb(self, button):
self.toggle_createview()
def toggle_createview(self):
self.set_menus_sensitive(True)
self.build.reset()
self.nb.set_current_page(0)
def build_complete_cb(self, running_build):
# Have the handler process BB events again
self.handler.building = False
self.stopping = False
self.back.connect("clicked", self.back_button_clicked_cb)
self.back.set_sensitive(True)
self.cancel.set_sensitive(False)
for f in self.files_to_clean:
try:
os.remove(f)
except OSError:
pass
self.files_to_clean.remove(f)
self.files_to_clean = []
lbl = "<b>Build completed</b>\n\nClick 'Edit Image' to start another build or 'View Messages' to view the messages output during the build."
if self.handler.build_type == "image" and self.build_succeeded:
deploy = self.handler.get_image_deploy_dir()
lbl = lbl + "\n<a href=\"file://%s\" title=\"%s\">Browse folder of built images</a>." % (deploy, deploy)
dialog = CrumbsDialog(self, lbl)
dialog.add_button("View Messages", gtk.RESPONSE_CANCEL)
dialog.add_button("Edit Image", gtk.RESPONSE_OK)
response = dialog.run()
dialog.destroy()
if response == gtk.RESPONSE_OK:
self.toggle_createview()
def build_started_cb(self, running_build):
self.back.set_sensitive(False)
self.cancel.set_sensitive(True)
def include_gplv3_cb(self, toggle):
excluded = toggle.get_active()
self.handler.toggle_gplv3(excluded)
def change_bb_threads(self, spinner):
val = spinner.get_value_as_int()
self.handler.set_bbthreads(val)
def change_make_threads(self, spinner):
val = spinner.get_value_as_int()
self.handler.set_pmake(val)
def toggle_toolchain(self, check):
enabled = check.get_active()
self.handler.toggle_toolchain(enabled)
def toggle_headers(self, check):
enabled = check.get_active()
self.handler.toggle_toolchain_headers(enabled)
def toggle_package_idle_cb(self, opath, image):
"""
As the operations which we're calling on the model can take
a significant amount of time (in the order of seconds) during which
the GUI is unresponsive as the main loop is blocked perform them in
an idle function which at least enables us to set the busy cursor
before the UI is blocked giving the appearance of being responsive.
"""
# Whether the item is currently included
inc = self.model[opath][self.model.COL_INC]
# FIXME: due to inpredictability of the removal of packages we are
# temporarily disabling this feature
# If the item is already included, mark it for removal then
# the sweep_up() method finds affected items and marks them
# appropriately
# if inc:
# self.model.mark(opath)
# self.model.sweep_up()
# # If the item isn't included, mark it for inclusion
# else:
if not inc:
self.model.include_item(item_path=opath,
binb="User Selected",
image_contents=image)
self.set_busy_cursor(False)
return False
def toggle_package(self, path, model, image=False):
inc = model[path][self.model.COL_INC]
# Warn user before removing included packages
if inc:
# FIXME: due to inpredictability of the removal of packages we are
# temporarily disabling this feature
return
# pn = model[path][self.model.COL_NAME]
# revdeps = self.model.find_reverse_depends(pn)
# if len(revdeps):
# lbl = "<b>Remove %s?</b>\n\nThis action cannot be undone and all packages which depend on this will be removed\nPackages which depend on %s include %s." % (pn, pn, ", ".join(revdeps).rstrip(","))
# else:
# lbl = "<b>Remove %s?</b>\n\nThis action cannot be undone." % pn
# dialog = CrumbsDialog(self, lbl, gtk.STOCK_DIALOG_WARNING)
# dialog.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)
# dialog.add_button("Remove", gtk.RESPONSE_OK)
# response = dialog.run()
# dialog.destroy()
# if response == gtk.RESPONSE_CANCEL:
# return
self.set_busy_cursor()
# Convert path to path in original model
opath = model.convert_path_to_child_path(path)
# This is a potentially length call which can block the
# main loop, therefore do the work in an idle func to keep
# the UI responsive
glib.idle_add(self.toggle_package_idle_cb, opath, image)
self.dirty = True
def toggle_include_cb(self, cell, path, tv):
model = tv.get_model()
self.toggle_package(path, model)
def toggle_pkg_include_cb(self, cell, path, tv):
# there's an extra layer of models in the packages case.
sort_model = tv.get_model()
cpath = sort_model.convert_path_to_child_path(path)
self.toggle_package(cpath, sort_model.get_model())
def pkgsaz(self):
vbox = gtk.VBox(False, 6)
vbox.show()
self.pkgsaz_tree = gtk.TreeView()
self.pkgsaz_tree.set_headers_visible(True)
self.pkgsaz_tree.set_headers_clickable(True)
self.pkgsaz_tree.set_enable_search(True)
self.pkgsaz_tree.set_search_column(0)
self.pkgsaz_tree.get_selection().set_mode(gtk.SELECTION_SINGLE)
col = gtk.TreeViewColumn('Package')
col.set_clickable(True)
col.set_sort_column_id(self.model.COL_NAME)
col.set_min_width(220)
col1 = gtk.TreeViewColumn('Description')
col1.set_resizable(True)
col1.set_min_width(360)
col2 = gtk.TreeViewColumn('License')
col2.set_resizable(True)
col2.set_clickable(True)
col2.set_sort_column_id(self.model.COL_LIC)
col2.set_min_width(170)
col3 = gtk.TreeViewColumn('Group')
col3.set_clickable(True)
col3.set_sort_column_id(self.model.COL_GROUP)
col4 = gtk.TreeViewColumn('Included')
col4.set_min_width(80)
col4.set_max_width(90)
col4.set_sort_column_id(self.model.COL_INC)
self.pkgsaz_tree.append_column(col)
self.pkgsaz_tree.append_column(col1)
self.pkgsaz_tree.append_column(col2)
self.pkgsaz_tree.append_column(col3)
self.pkgsaz_tree.append_column(col4)
cell = gtk.CellRendererText()
cell1 = gtk.CellRendererText()
cell1.set_property('width-chars', 20)
cell2 = gtk.CellRendererText()
cell2.set_property('width-chars', 20)
cell3 = gtk.CellRendererText()
cell4 = gtk.CellRendererToggle()
cell4.set_property('activatable', True)
cell4.connect("toggled", self.toggle_pkg_include_cb, self.pkgsaz_tree)
col.pack_start(cell, True)
col1.pack_start(cell1, True)
col2.pack_start(cell2, True)
col3.pack_start(cell3, True)
col4.pack_end(cell4, True)
col.set_attributes(cell, text=self.model.COL_NAME)
col1.set_attributes(cell1, text=self.model.COL_DESC)
col2.set_attributes(cell2, text=self.model.COL_LIC)
col3.set_attributes(cell3, text=self.model.COL_GROUP)
col4.set_attributes(cell4, active=self.model.COL_INC)
self.pkgsaz_tree.show()
scroll = gtk.ScrolledWindow()
scroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_ALWAYS)
scroll.set_shadow_type(gtk.SHADOW_IN)
scroll.add(self.pkgsaz_tree)
vbox.pack_start(scroll, True, True, 0)
hb = gtk.HBox(False, 0)
hb.show()
self.search = gtk.Entry()
self.search.set_icon_from_stock(gtk.ENTRY_ICON_SECONDARY, "gtk-clear")
self.search.connect("icon-release", self.search_entry_clear_cb)
self.search.show()
self.pkgsaz_tree.set_search_entry(self.search)
hb.pack_end(self.search, False, False, 0)
label = gtk.Label("Search packages:")
label.show()
hb.pack_end(label, False, False, 6)
vbox.pack_start(hb, False, False, 0)
return vbox
def search_entry_clear_cb(self, entry, icon_pos, event):
entry.set_text("")
def tasks(self):
vbox = gtk.VBox(False, 6)
vbox.show()
self.tasks_tree = gtk.TreeView()
self.tasks_tree.set_headers_visible(True)
self.tasks_tree.set_headers_clickable(False)
self.tasks_tree.set_enable_search(True)
self.tasks_tree.set_search_column(0)
self.tasks_tree.get_selection().set_mode(gtk.SELECTION_SINGLE)
col = gtk.TreeViewColumn('Package Collection')
col.set_min_width(430)
col1 = gtk.TreeViewColumn('Description')
col1.set_min_width(430)
col2 = gtk.TreeViewColumn('Include')
col2.set_min_width(70)
col2.set_max_width(80)
self.tasks_tree.append_column(col)
self.tasks_tree.append_column(col1)
self.tasks_tree.append_column(col2)
cell = gtk.CellRendererText()
cell1 = gtk.CellRendererText()
cell2 = gtk.CellRendererToggle()
cell2.set_property('activatable', True)
cell2.connect("toggled", self.toggle_include_cb, self.tasks_tree)
col.pack_start(cell, True)
col1.pack_start(cell1, True)
col2.pack_end(cell2, True)
col.set_attributes(cell, text=self.model.COL_NAME)
col1.set_attributes(cell1, text=self.model.COL_DESC)
col2.set_attributes(cell2, active=self.model.COL_INC)
self.tasks_tree.show()
scroll = gtk.ScrolledWindow()
scroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_ALWAYS)
scroll.set_shadow_type(gtk.SHADOW_IN)
scroll.add(self.tasks_tree)
vbox.pack_start(scroll, True, True, 0)
hb = gtk.HBox(False, 0)
hb.show()
search = gtk.Entry()
search.show()
self.tasks_tree.set_search_entry(search)
hb.pack_end(search, False, False, 0)
label = gtk.Label("Search collections:")
label.show()
hb.pack_end(label, False, False, 6)
vbox.pack_start(hb, False, False, 0)
return vbox
def cancel_build(self, button):
if self.stopping:
lbl = "<b>Force Stop build?</b>\nYou've already selected Stop once,"
lbl = lbl + " would you like to 'Force Stop' the build?\n\n"
lbl = lbl + "This will stop the build as quickly as possible but may"
lbl = lbl + " well leave your build directory in an unusable state"
lbl = lbl + " that requires manual steps to fix.\n"
dialog = CrumbsDialog(self, lbl, gtk.STOCK_DIALOG_WARNING)
dialog.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)
dialog.add_button("Force Stop", gtk.RESPONSE_YES)
else:
lbl = "<b>Stop build?</b>\n\nAre you sure you want to stop this"
lbl = lbl + " build?\n\n'Force Stop' will stop the build as quickly as"
lbl = lbl + " possible but may well leave your build directory in an"
lbl = lbl + " unusable state that requires manual steps to fix.\n\n"
lbl = lbl + "'Stop' will stop the build as soon as all in"
lbl = lbl + " progress build tasks are finished. However if a"
lbl = lbl + " lengthy compilation phase is in progress this may take"
lbl = lbl + " some time."
dialog = CrumbsDialog(self, lbl, gtk.STOCK_DIALOG_WARNING)
dialog.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)
dialog.add_button("Stop", gtk.RESPONSE_OK)
dialog.add_button("Force Stop", gtk.RESPONSE_YES)
response = dialog.run()
dialog.destroy()
if response != gtk.RESPONSE_CANCEL:
self.stopping = True
if response == gtk.RESPONSE_OK:
self.handler.cancel_build()
elif response == gtk.RESPONSE_YES:
self.handler.cancel_build(True)
def view_build_gui(self):
vbox = gtk.VBox(False, 12)
vbox.set_border_width(6)
vbox.show()
build_tv = RunningBuildTreeView(readonly=True)
build_tv.show()
build_tv.set_model(self.build.model)
self.build.model.connect("row-inserted", self.scroll_tv_cb, build_tv)
scrolled_view = gtk.ScrolledWindow ()
scrolled_view.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolled_view.add(build_tv)
scrolled_view.show()
vbox.pack_start(scrolled_view, expand=True, fill=True)
hbox = gtk.HBox(False, 12)
hbox.show()
vbox.pack_start(hbox, expand=False, fill=False)
self.back = gtk.Button("Back")
self.back.show()
self.back.set_sensitive(False)
hbox.pack_start(self.back, expand=False, fill=False)
self.cancel = gtk.Button("Stop Build")
self.cancel.connect("clicked", self.cancel_build)
self.cancel.show()
hbox.pack_end(self.cancel, expand=False, fill=False)
return vbox
def create_menu(self):
menu_items = '''<ui>
<menubar name="MenuBar">
<menu action="File">
<menuitem action="Save"/>
<menuitem action="Save As"/>
<menuitem action="Open"/>
<separator/>
<menuitem action="AddLayer" label="Add Layer"/>
<separator/>
<menuitem action="Quit"/>
</menu>
<menu action="Edit">
<menuitem action="Layers" label="Layers"/>
<menuitem action="Preferences"/>
</menu>
<menu action="Help">
<menuitem action="About"/>
</menu>
</menubar>
</ui>'''
uimanager = gtk.UIManager()
accel = uimanager.get_accel_group()
self.add_accel_group(accel)
actions = gtk.ActionGroup('ImageCreator')
self.actions = actions
actions.add_actions([('Quit', gtk.STOCK_QUIT, None, None, None, self.menu_quit,),
('File', None, '_File'),
('Save', gtk.STOCK_SAVE, None, None, None, self.save_cb),
('Save As', gtk.STOCK_SAVE_AS, None, None, None, self.save_as_cb),
('Edit', None, '_Edit'),
('Help', None, '_Help'),
('About', gtk.STOCK_ABOUT, None, None, None, self.about_cb)])
self.add_layers_action = gtk.Action('AddLayer', 'Add Layer', None, None)
self.add_layers_action.connect("activate", self.add_layer_cb)
self.actions.add_action(self.add_layers_action)
self.layers_action = gtk.Action('Layers', 'Layers', None, None)
self.layers_action.connect("activate", self.layers_cb)
self.actions.add_action(self.layers_action)
self.prefs_action = gtk.Action('Preferences', 'Preferences', None, None)
self.prefs_action.connect("activate", self.preferences_cb)
self.actions.add_action(self.prefs_action)
self.open_action = gtk.Action('Open', 'Open', None, None)
self.open_action.connect("activate", self.open_cb)
self.actions.add_action(self.open_action)
uimanager.insert_action_group(actions, 0)
uimanager.add_ui_from_string(menu_items)
menubar = uimanager.get_widget('/MenuBar')
menubar.show_all()
return menubar
def info_button_clicked_cb(self, button):
info = "We cannot accurately predict the image contents before they are built so instead a best"
info = info + " attempt at estimating what the image will contain is listed."
dialog = CrumbsDialog(self, info, gtk.STOCK_DIALOG_INFO)
dialog.add_buttons(gtk.STOCK_CLOSE, gtk.RESPONSE_OK)
resp = dialog.run()
dialog.destroy()
def create_build_gui(self):
vbox = gtk.VBox(False, 12)
vbox.set_border_width(6)
vbox.show()
hbox = gtk.HBox(False, 12)
hbox.show()
vbox.pack_start(hbox, expand=False, fill=False)
label = gtk.Label("Machine:")
label.show()
hbox.pack_start(label, expand=False, fill=False, padding=6)
self.machine_combo = gtk.combo_box_new_text()
self.machine_combo.show()
self.machine_combo.set_tooltip_text("Selects the architecture of the target board for which you would like to build an image.")
hbox.pack_start(self.machine_combo, expand=False, fill=False, padding=6)
label = gtk.Label("Base image:")
label.show()
hbox.pack_start(label, expand=False, fill=False, padding=6)
self.image_combo = gtk.ComboBox()
self.image_combo.show()
self.image_combo.set_tooltip_text("Selects the image on which to base the created image")
image_combo_cell = gtk.CellRendererText()
self.image_combo.pack_start(image_combo_cell, True)
self.image_combo.add_attribute(image_combo_cell, 'text', self.model.COL_NAME)
hbox.pack_start(self.image_combo, expand=False, fill=False, padding=6)
self.progress = gtk.ProgressBar()
self.progress.set_size_request(250, -1)
hbox.pack_end(self.progress, expand=False, fill=False, padding=6)
ins = gtk.Notebook()
vbox.pack_start(ins, expand=True, fill=True)
ins.set_show_tabs(True)
label = gtk.Label("Packages")
label.show()
ins.append_page(self.pkgsaz(), tab_label=label)
label = gtk.Label("Package Collections")
label.show()
ins.append_page(self.tasks(), tab_label=label)
ins.set_current_page(0)
ins.show_all()
hbox = gtk.HBox(False, 1)
hbox.show()
label = gtk.Label("Estimated image contents:")
self.model.connect("contents-changed", self.update_package_count_cb, label)
label.set_property("xalign", 0.00)
label.show()
hbox.pack_start(label, expand=False, fill=False, padding=6)
info = gtk.Button("?")
info.set_tooltip_text("What does this mean?")
info.show()
info.connect("clicked", self.info_button_clicked_cb)
hbox.pack_start(info, expand=False, fill=False, padding=6)
vbox.pack_start(hbox, expand=False, fill=False, padding=6)
con = self.contents()
con.show()
vbox.pack_start(con, expand=True, fill=True)
bbox = gtk.HButtonBox()
bbox.set_spacing(12)
bbox.set_layout(gtk.BUTTONBOX_END)
bbox.show()
vbox.pack_start(bbox, expand=False, fill=False)
reset = gtk.Button("Reset")
reset.connect("clicked", self.reset_clicked_cb)
reset.show()
bbox.add(reset)
bake = gtk.Button("Bake")
bake.connect("clicked", self.bake_clicked_cb)
bake.show()
bbox.add(bake)
return vbox
def update_package_count_cb(self, model, count, label):
lbl = "Estimated image contents (%s packages):" % count
label.set_text(lbl)
def contents(self):
self.contents_tree = gtk.TreeView()
self.contents_tree.set_headers_visible(True)
self.contents_tree.get_selection().set_mode(gtk.SELECTION_SINGLE)
# allow searching in the package column
self.contents_tree.set_search_column(0)
self.contents_tree.set_enable_search(True)
col = gtk.TreeViewColumn('Package')
col.set_sort_column_id(0)
col.set_min_width(430)
col1 = gtk.TreeViewColumn('Brought in by')
col1.set_resizable(True)
col1.set_min_width(430)
self.contents_tree.append_column(col)
self.contents_tree.append_column(col1)
cell = gtk.CellRendererText()
cell1 = gtk.CellRendererText()
cell1.set_property('width-chars', 20)
col.pack_start(cell, True)
col1.pack_start(cell1, True)
col.set_attributes(cell, text=self.model.COL_NAME)
col1.set_attributes(cell1, text=self.model.COL_BINB)
self.contents_tree.show()
scroll = gtk.ScrolledWindow()
scroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_ALWAYS)
scroll.set_shadow_type(gtk.SHADOW_IN)
scroll.add(self.contents_tree)
return scroll
def main (server, eventHandler):
gobject.threads_init()
# NOTE: For now we require that the user run with pre and post files to
# read and store configuration set in the GUI.
# We hope to adjust this long term as tracked in Yocto Bugzilla #1441
# http://bugzilla.pokylinux.org/show_bug.cgi?id=1441
reqfiles = 0
dep_files = server.runCommand(["getVariable", "__depends"]) or set()
dep_files.union(server.runCommand(["getVariable", "__base_depends"]) or set())
for f in dep_files:
if f[0].endswith("hob-pre.conf"):
reqfiles = reqfiles + 1
elif f[0].endswith("hob-post.conf"):
reqfiles = reqfiles + 1
if reqfiles == 2:
break
if reqfiles < 2:
print("""The hob UI requires a pre file named hob-pre.conf and a post
file named hob-post.conf to store and read its configuration from. Please run
hob with these files, i.e.\n
\bitbake -u hob -r conf/hob-pre.conf -R conf/hob-post.conf""")
return
taskmodel = TaskListModel()
configurator = Configurator()
handler = HobHandler(taskmodel, server)
mach = server.runCommand(["getVariable", "MACHINE"])
sdk_mach = server.runCommand(["getVariable", "SDKMACHINE"])
# If SDKMACHINE not set the default SDK_ARCH is used so we
# should represent that in the GUI
if not sdk_mach:
sdk_mach = server.runCommand(["getVariable", "SDK_ARCH"])
distro = server.runCommand(["getVariable", "DISTRO"])
if not distro:
distro = "defaultsetup"
bbthread = server.runCommand(["getVariable", "BB_NUMBER_THREADS"])
if not bbthread:
bbthread = 1
else:
bbthread = int(bbthread)
pmake = server.runCommand(["getVariable", "PARALLEL_MAKE"])
if not pmake:
pmake = 1
else:
# The PARALLEL_MAKE variable will be of the format: "-j 3" and we only
# want a number for the spinner, so strip everything from the variable
# up to and including the space
pmake = int(pmake.lstrip("-j "))
selected_image_types = server.runCommand(["getVariable", "IMAGE_FSTYPES"])
all_image_types = server.runCommand(["getVariable", "IMAGE_TYPES"])
pclasses = server.runCommand(["getVariable", "PACKAGE_CLASSES"]).split(" ")
# NOTE: we're only supporting one value for PACKAGE_CLASSES being set
# this seems OK because we're using the first package format set in
# PACKAGE_CLASSES and that's the package manager used for the rootfs
pkg, sep, pclass = pclasses[0].rpartition("_")
incompatible = server.runCommand(["getVariable", "INCOMPATIBLE_LICENSE"])
gplv3disabled = False
if incompatible and incompatible.lower().find("gplv3") != -1:
gplv3disabled = True
build_toolchain = bool(server.runCommand(["getVariable", "HOB_BUILD_TOOLCHAIN"]))
handler.toggle_toolchain(build_toolchain)
build_headers = bool(server.runCommand(["getVariable", "HOB_BUILD_TOOLCHAIN_HEADERS"]))
handler.toggle_toolchain_headers(build_headers)
prefs = HobPrefs(configurator, handler, sdk_mach, distro, pclass,
pmake, bbthread, selected_image_types, all_image_types,
gplv3disabled, build_toolchain, build_headers)
layers = LayerEditor(configurator, None)
window = MainWindow(taskmodel, handler, configurator, prefs, layers, mach)
prefs.set_parent_window(window)
layers.set_parent_window(window)
window.show_all ()
handler.connect("machines-updated", window.update_machines)
handler.connect("sdk-machines-updated", prefs.update_sdk_machines)
handler.connect("distros-updated", prefs.update_distros)
handler.connect("package-formats-found", prefs.update_package_formats)
handler.connect("generating-data", window.busy)
handler.connect("data-generated", window.data_generated)
handler.connect("reload-triggered", window.reload_triggered_cb)
configurator.connect("layers-loaded", layers.load_current_layers)
configurator.connect("layers-changed", handler.reload_data)
handler.connect("config-found", configurator.configFound)
handler.connect("fatal-error", window.fatal_error_cb)
try:
# kick the while thing off
handler.current_command = handler.CFG_PATH_LOCAL
server.runCommand(["findConfigFilePath", "local.conf"])
except xmlrpclib.Fault:
print("XMLRPC Fault getting commandline:\n %s" % x)
return 1
# This timeout function regularly probes the event queue to find out if we
# have any messages waiting for us.
gobject.timeout_add (100,
handler.event_handle_idle_func,
eventHandler,
window.build,
window.progress)
try:
gtk.main()
except EnvironmentError as ioerror:
# ignore interrupted io
if ioerror.args[0] == 4:
pass
finally:
server.runCommand(["stateStop"])
Reference in New Issue Copy Permalink