def init(server, eventHandler):
# Initialise threading...
gobject.threads_init()
gtk.gdk.threads_init()
main_window = MainWindow()
main_window.show_all()
# Set up the build manager stuff in general
builds_dir = os.path.join(os.getcwd(), "results")
manager = BuildManager(server, builds_dir)
main_window.build_manager_view.set_model(manager.model)
# Do the running build setup
running_build = RunningBuild()
main_window.running_build_view.set_model(running_build.model)
running_build.connect("build-succeeded", running_build_succeeded_cb,
manager)
running_build.connect("build-failed", running_build_failed_cb, manager)
# We need to save the manager into the MainWindow so that the toolbar
# button can use it.
# FIXME: Refactor ?
main_window.manager = manager
# Use a timeout function for probing the event queue to find out if we
# have a message waiting for us.
gobject.timeout_add(200, event_handle_timeout, eventHandler, running_build)
gtk.main()
def main(server, eventHandler, params):
gobject.threads_init()
gtk.gdk.threads_init()
window = MainWindow()
window.show_all()
pbar = ProgressBar(window)
pbar.connect("delete-event", gtk.main_quit)
# Create the object for the current build
running_build = RunningBuild()
window.cur_build_tv.set_model(running_build.model)
running_build.model.connect("row-inserted", scroll_tv_cb,
window.cur_build_tv)
running_build.connect("build-succeeded", running_build_succeeded_cb)
running_build.connect("build-failed", running_build_failed_cb)
try:
params.updateFromServer(server)
cmdline = params.parseActions()
if not cmdline:
print(
"Nothing to do. Use 'bitbake world' to build everything, or run 'bitbake --help' for usage information."
)
return 1
if 'msg' in cmdline and cmdline['msg']:
logger.error(cmdline['msg'])
return 1
cmdline = cmdline['action']
ret, error = server.runCommand(cmdline)
if error:
print("Error running command '%s': %s" % (cmdline, error))
return 1
elif ret != True:
print("Error running command '%s': returned %s" % (cmdline, ret))
return 1
except xmlrpclib.Fault as x:
print("XMLRPC Fault getting commandline:\n %s" % x)
return 1
# Use a timeout function for probing the event queue to find out if we
# have a message waiting for us.
gobject.timeout_add(100, event_handle_idle_func, eventHandler,
running_build, pbar)
try:
gtk.main()
except EnvironmentError as ioerror:
# ignore interrupted io
if ioerror.args[0] == 4:
pass
except KeyboardInterrupt:
pass
finally:
server.runCommand(["stateForceShutdown"])
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 __init__(self, server, recipe_model, package_model):
super(HobHandler, self).__init__()
self.build = RunningBuild(sequential=True)
self.recipe_model = recipe_model
self.package_model = package_model
self.commands_async = []
self.generating = False
self.current_phase = None
self.building = False
self.recipe_queue = []
self.package_queue = []
self.server = server
self.error_msg = ""
self.initcmd = None
def main (server, eventHandler):
gobject.threads_init()
gtk.gdk.threads_init()
window = MainWindow ()
window.show_all ()
pbar = ProgressBar(window)
# Create the object for the current build
running_build = RunningBuild ()
window.cur_build_tv.set_model (running_build.model)
running_build.model.connect("row-inserted", scroll_tv_cb, window.cur_build_tv)
running_build.connect ("build-succeeded", running_build_succeeded_cb)
running_build.connect ("build-failed", running_build_failed_cb)
try:
cmdline = server.runCommand(["getCmdLineAction"])
if not cmdline:
return 1
ret = server.runCommand(cmdline)
if ret != True:
print("Couldn't get default commandline! %s" % ret)
return 1
except xmlrpclib.Fault as x:
print("XMLRPC Fault getting commandline:\n %s" % x)
return 1
# Use a timeout function for probing the event queue to find out if we
# have a message waiting for us.
gobject.timeout_add (100,
event_handle_idle_func,
eventHandler,
running_build,
pbar)
try:
gtk.main()
except EnvironmentError as ioerror:
# ignore interrupted io
if ioerror.args[0] == 4:
pass
finally:
server.runCommand(["stateStop"])
