← Back to branch summary

~mabac/linaro-image-tools/bug-829220

« back to all changes in this revision

Viewing changes to linaro-fetch-image-ui

  • Committer: James Tunnicliffe
  • Date: 2011-08-19 12:15:02 UTC
  • mfrom: (405.3.2 linaro-image-tools)
  • Revision ID: james.tunnicliffe@linaro.org-20110819121502-1rggwopls8gqcjyl
Pages 1 and 2 of the new IU are now complete.

* Saying you want to run a simulation will generate a Beagle image to run on QEMU (tool does not run QEMU for you)
* Advanced options on page 2 allow for selecting an OS that isn't Ubuntu Desktop
* Unless you are selecting a snapshot build, page 3 is now linaro-media-create settings

Part 3 of the updates will concentrate on the linaro-media-create settings page.

Show diffs side-by-side

added added

removed removed

Lines of Context:
linaro-fetch-image-ui
57
57
    return radio_button
58
58
 
59
59
 
60
 
class ReleaseOrSnapshotPage(wiz.WizardPageSimple):
 
60
class ReleaseOrSnapshotPage(wiz.PyWizardPage):
61
61
    """Ask the user if they want to use a release or a snapshot"""
62
62
 
63
 
    def __init__(self, parent, config, width):
64
 
        wiz.WizardPageSimple.__init__(self, parent)
 
63
    def __init__(self, parent, config, db, pages, width):
 
64
        wiz.PyWizardPage.__init__(self, parent)
65
65
        self.config = config
66
66
        self.settings = self.config.settings
67
67
        self.sizer = wx.BoxSizer(wx.VERTICAL)
68
68
        self.next = None
69
69
        self.prev = None
 
70
        self.db = db
 
71
        self.wizard = parent
 
72
        self.pages = pages
 
73
        self.width = width
 
74
        self.settings['image'] = None
 
75
        self.os_selected = True
70
76
 
71
77
        message = ("Would you like to use a Linaro release, or a more up to "
72
78
                   "date, but possibly unstable build?")
89
95
        add_button(self, self.box1, self.button_text['snapshot'], None,
90
96
                   self.event_radio_button_select, None, None)
91
97
 
 
98
        self.cp = wx.CollapsiblePane(self, label="Advanced Options",
 
99
                                     style=wx.CP_DEFAULT_STYLE |
 
100
                                           wx.CP_NO_TLW_RESIZE)
 
101
        self.Bind(wx.EVT_COLLAPSIBLEPANE_CHANGED, self.event_on_pane_changed,
 
102
                  self.cp)
 
103
        self.make_pane_content(self.cp.GetPane())
 
104
        self.box2 = wx.BoxSizer(wx.VERTICAL)
 
105
        self.box2.Add(self.cp)
 
106
        
92
107
        self.sizer.Add(header)
93
108
        self.sizer.Add(self.box1, 0, wx.ALIGN_LEFT | wx.ALL, 5)
 
109
        self.sizer.Add(self.box2, 0, wx.ALIGN_LEFT | wx.ALL, 5)
94
110
        self.SetSizerAndFit(self.sizer)
95
111
        self.sizer.Fit(self)
96
112
        self.Move((50, 50))
97
113
 
 
114
    def make_pane_content(self, pane):
 
115
        self.adv_box = wx.BoxSizer(wx.VERTICAL)
 
116
 
 
117
        message = ("You have the option of selecting from several OS images "
 
118
                   "and builds.")
 
119
        header = wx.StaticText(pane, -1, message)
 
120
        header.Wrap(self.width - 10)  # -10 because boarder below is 5 px wide
 
121
        self.adv_box.Add(header)
 
122
        self.grid1 = wx.FlexGridSizer(0, 2, 0, 0)
 
123
        self.grid2 = wx.FlexGridSizer(0, 2, 0, 0)
 
124
 
 
125
        # TODO: Put in table with explainations!
 
126
        # TODO: Needs to be different (OS name only) if selecting snapshot!
 
127
 
 
128
        platforms = []
 
129
        for key, value in self.settings['choice']['platform'].items():
 
130
            platforms.append(key)
 
131
 
 
132
        style = wx.CB_DROPDOWN | wx.CB_READONLY
 
133
        self.settings['platform'] = None
 
134
 
 
135
        self.cb_release = wx.ComboBox(pane, style=style)
 
136
        self.Bind(wx.EVT_COMBOBOX, self.event_cb_release, self.cb_release)
 
137
 
 
138
        self.cb_build = wx.ComboBox(pane, style=style)
 
139
        self.Bind(wx.EVT_COMBOBOX, self.event_combo_box_build, self.cb_build)
 
140
 
 
141
        self.cb_image = wx.ComboBox(pane, style=style)
 
142
        self.Bind(wx.EVT_COMBOBOX, self.event_combo_box_os, self.cb_image)
 
143
 
 
144
        self.help_text = wx.StaticText(pane, -1, "")
 
145
 
 
146
        alignment = wx.ALIGN_LEFT | wx.LEFT | wx.RIGHT | wx.TOP
 
147
        align_text = alignment | wx.ALIGN_CENTER_VERTICAL
 
148
        self.grid1.Add(self.cb_image, 0, alignment, 5)
 
149
        self.grid1.Add(wx.StaticText(pane, -1, "The OS to run"),
 
150
                          0, align_text, 5)
 
151
 
 
152
        self.grid2.Add(self.cb_release, 0, alignment, 5)
 
153
        self.grid2.Add(wx.StaticText(pane, -1, "Available Linaro releases"),
 
154
                          0, align_text, 5)
 
155
 
 
156
        self.grid2.Add(self.cb_build, 0, alignment, 5)
 
157
        self.grid2.Add(wx.StaticText(pane, -1, "Available milestones"),
 
158
                          0, align_text, 5)
 
159
 
 
160
        self.adv_box.Add(self.grid1, 0, alignment, 0)
 
161
        self.adv_box.Add(self.grid2, 0, alignment, 0)
 
162
        self.update_visibility()
 
163
        self.adv_box.Add(self.help_text, 0, alignment, 5)
 
164
 
 
165
        pane.SetSizer(self.adv_box)
 
166
        self.adv_box.Fit(pane)
 
167
 
 
168
    def update_visibility(self):
 
169
        if self.settings['release_or_snapshot'] == "snapshot":
 
170
            self.adv_box.Hide(self.grid2, True)
 
171
        else:
 
172
            self.adv_box.Show(self.grid2, True)
 
173
 
 
174
        self.Fit()
 
175
        self.Layout()
 
176
 
 
177
    def update_next_active(self):
 
178
        if self.build_available and self.os_selected:
 
179
            self.wizard.FindWindowById(wx.ID_FORWARD).Enable()
 
180
        else:
 
181
            self.wizard.FindWindowById(wx.ID_FORWARD).Disable()
 
182
 
 
183
    def update_build_box(self):
 
184
        """Depending on what hardware has been chosen, the OS list may be
 
185
        restricted. Filter out anything that is unavailable."""
 
186
        self.cb_build.Clear()
 
187
 
 
188
        if self.settings['release_or_snapshot'] == "snapshot":
 
189
            # This combo box is not used by snapshot builds
 
190
            self.cb_build.SetValue("Not applicable")
 
191
            self.build_available = True
 
192
            return
 
193
 
 
194
        builds = self.db.get_builds(self.settings['platform'])
 
195
        self.cb_build.SetValue("No build available")
 
196
 
 
197
        for build in builds:
 
198
            if(self.db.hardware_is_available_for_platform_build(
 
199
                                          self.settings['compatable_hwpacks'],
 
200
                                          self.settings['platform'],
 
201
                                          build)
 
202
                and self.db.build_is_available_for_platform_image(
 
203
                                "release_binaries",
 
204
                                self.settings['platform'],
 
205
                                self.settings['image'],
 
206
                                build)):
 
207
 
 
208
                self.cb_build.Append(build)
 
209
                self.cb_build.SetValue(build)
 
210
                self.settings['release_build'] = build
 
211
 
 
212
        available_hwpacks = (
 
213
            self.db.get_available_hwpacks_for_hardware_build_plaform(
 
214
                                          self.settings['compatable_hwpacks'],
 
215
                                          self.settings['platform'],
 
216
                                          self.settings['release_build']))
 
217
 
 
218
        if len(available_hwpacks):
 
219
            self.settings['hwpack'] = available_hwpacks[0]
 
220
            self.build_available = True
 
221
        else:
 
222
            self.build_available = False
 
223
 
 
224
        self.update_next_active()
 
225
 
 
226
    def update_release_and_build_boxes(self):
 
227
        """Depending on what hardware has been chosen, some builds may be
 
228
           unavailable..."""
 
229
        self.cb_release.Clear()
 
230
 
 
231
        if self.settings['release_or_snapshot'] == "snapshot":
 
232
            # This combo box is not used by snapshot builds
 
233
            self.cb_release.SetValue("Not applicable")
 
234
            return
 
235
 
 
236
        if not self.os_selected:
 
237
            self.cb_release.SetValue("-")
 
238
            self.update_build_box()
 
239
            self.update_next_active()
 
240
            return
 
241
 
 
242
        default_release = None
 
243
        for platform, value in self.settings['choice']['platform'].items():
 
244
            if(self.db.hardware_is_available_for_platform(
 
245
                                          self.settings['compatable_hwpacks'],
 
246
                                          platform)
 
247
               and len(self.db.execute_return_list(
 
248
                               'select * from release_binaries '
 
249
                               'where platform == ? and image == ?',
 
250
                                (platform, self.settings['image'])))):
 
251
 
 
252
                if platform in self.settings['UI']['translate']:
 
253
                    platform = self.settings['UI']['translate'][platform]
 
254
 
 
255
                self.cb_release.Append(platform, platform.upper())
 
256
                if not default_release or default_release < platform:
 
257
                    default_release = platform
 
258
 
 
259
        if default_release in self.settings['UI']['reverse-translate']:
 
260
            default = self.settings['UI']['reverse-translate'][default_release]
 
261
        else:
 
262
            default = default_release
 
263
 
 
264
        if not self.settings['platform']:
 
265
            # No platform has been chose, go with the default
 
266
            self.settings['platform'] = default
 
267
            self.cb_release.SetValue(default_release)
 
268
        else:
 
269
            # Don't change the value of platform if it is set.
 
270
            pf = self.settings['UI']['translate'][self.settings['platform']]
 
271
            self.cb_release.SetValue(pf)
 
272
 
 
273
        self.update_build_box()
 
274
        self.update_next_active()
 
275
 
 
276
    def get_human_os_name(self, item):
 
277
        """Given an OS name from the database, return a human name (either
 
278
        translated from the YAML settings, or just prettified) and if it is a
 
279
        LEB OS or not"""
 
280
 
 
281
        item = re.sub("linaro-", "", item)  # Remove any linaro- decoration
 
282
 
 
283
        if item in self.settings['UI']['descriptions']:
 
284
            human_name = self.settings['UI']['descriptions'][item]
 
285
        else:
 
286
            # Make human_name look nicer...
 
287
            human_name = string.capwords(item)
 
288
 
 
289
        leb_search = re.search("^LEB:\s*(.*)$", human_name)
 
290
 
 
291
        if leb_search:
 
292
            return leb_search.group(1), True
 
293
 
 
294
        return human_name, False
 
295
 
 
296
    def fill_os_list(self):
 
297
        """Filter the list of OS's from the config file based on the users
 
298
        preferences so all choices in the list are valid (i.e. their hardware
 
299
        is supported for the build they have chosen)."""
 
300
 
 
301
        # select unique image from snapshot_binaries/release_binaries to
 
302
        # generate list
 
303
        os_list = None
 
304
        if self.settings['release_or_snapshot'] == "release":
 
305
            os_list = self.db.get_os_list_from('release_binaries')
 
306
        else:
 
307
            os_list = self.db.get_os_list_from('snapshot_binaries')
 
308
 
 
309
        self.cb_image.Clear()
 
310
 
 
311
        printed_tag = None
 
312
        last_name = None
 
313
        current_image_setting_valid = False
 
314
 
 
315
        for state in ["LEB", "other"]:
 
316
            for item in os_list:
 
317
                if item == "old":
 
318
                    # Old is a directory that sometimes hangs around,
 
319
                    # but isn't one we want to display
 
320
                    continue
 
321
 
 
322
                # Save the original, untouched image name for use later.
 
323
                # We give it a more human name for display
 
324
                original = item
 
325
                item = re.sub("linaro-", "", item)
 
326
 
 
327
                os_hardware_combo_available = (
 
328
                            self.db.image_hardware_combo_available(
 
329
                                    self.settings['release_or_snapshot'],
 
330
                                    original,
 
331
                                    self.settings['compatable_hwpacks']))
 
332
 
 
333
                if os_hardware_combo_available:
 
334
                    human_name, is_LEB = self.get_human_os_name(item)
 
335
 
 
336
                    if item == self.settings['image']:
 
337
                        current_image_setting_valid = True
 
338
 
 
339
                    if state == "LEB" and is_LEB:
 
340
 
 
341
                        if printed_tag != state:
 
342
                            self.cb_image.Append(
 
343
                                            "- Linaro Supported Releases -")
 
344
                            printed_tag = state
 
345
 
 
346
                        self.cb_image.Append(human_name, original)
 
347
 
 
348
                        if self.settings['image'] == None:
 
349
                            self.settings['image'] = original
 
350
                            self.os_selected = True
 
351
 
 
352
                    elif state != "LEB" and not is_LEB:
 
353
                        if printed_tag != state:
 
354
                            self.cb_image.Append(
 
355
                                            "- Community Supported Releases -")
 
356
                            printed_tag = state
 
357
 
 
358
                        self.cb_image.Append(human_name, original)
 
359
 
 
360
                    last_name = original
 
361
 
 
362
        if(    self.settings['image'] != None
 
363
           and current_image_setting_valid == False):
 
364
            # If we have an image setting, but it doesn't match the OS list, we
 
365
            # have switched OS list. It may be that adding/removing "linaro-"
 
366
            # from the name will get a match.
 
367
 
 
368
            if re.search("linaro-", self.settings['image']):
 
369
                test_name = re.sub("linaro-", "", self.settings['image'])
 
370
            else:
 
371
                test_name = "linaro-" + self.settings['image']
 
372
 
 
373
            if test_name in os_list:
 
374
                # Success! We have translated the name and can retain the
 
375
                # "old setting"
 
376
                self.settings['image'] = test_name
 
377
                current_image_setting_valid = True
 
378
                self.os_selected = True
 
379
 
 
380
        if(   self.settings['image'] == None
 
381
           or current_image_setting_valid == False):
 
382
            # This should only get hit if there are no LEBs available
 
383
            self.settings['image'] = last_name
 
384
            self.os_selected = True
 
385
 
 
386
        assert self.settings['image']
 
387
 
 
388
        # Make sure the visible selected value matches the saved setting
 
389
        self.cb_image.SetValue(
 
390
                            self.get_human_os_name(self.settings['image'])[0])
 
391
 
 
392
    def GetNext(self):
 
393
        if self.settings['release_or_snapshot'] == "release":
 
394
            return self.pages['lmc_settings']
 
395
        else:
 
396
            return self.pages['select_snapshot']
 
397
 
 
398
    def GetPrev(self):
 
399
        return self.pages['hardware_details']
 
400
 
 
401
    #--- Event(s) ---
98
402
    def event_radio_button_select(self, event):
 
403
        # The radio button can be release or snapshot
99
404
        self.radio_selected = event.GetEventObject().GetLabel()
100
 
        # The radio button can be release, snapshot or "latest snapshot"
101
 
        if(self.radio_selected == self.button_text['release']):
 
405
 
 
406
        if self.radio_selected == self.button_text['release']:
102
407
            self.settings['release_or_snapshot'] = "release"
103
408
        else:
104
409
            self.settings['release_or_snapshot'] = "snapshot"
105
410
 
 
411
        self.update_release_and_build_boxes()
 
412
        self.update_visibility()
 
413
        self.update_next_active()
 
414
 
 
415
    def event_on_pane_changed(self, event):
 
416
        self.fill_os_list()
 
417
        self.update_release_and_build_boxes()
 
418
        self.update_visibility()
 
419
        self.Layout()
 
420
        self.update_next_active()
 
421
 
 
422
    def event_cb_release(self, evt):
 
423
        str = evt.GetString().encode('ascii').lower()
 
424
        if str in self.settings['UI']['reverse-translate']:
 
425
            str = self.settings['UI']['reverse-translate'][str]
 
426
        self.settings['platform'] = str
 
427
 
 
428
        self.update_build_box()
 
429
 
 
430
    def event_combo_box_build(self, evt):
 
431
        self.settings['release_build'] = evt.GetString().encode('ascii')
 
432
 
 
433
    def event_combo_box_os(self, evt):
 
434
        self.settings['image'] = self.cb_image.GetClientData(
 
435
                                                            evt.GetSelection())
 
436
 
 
437
        if self.settings['image']:  # Is None for items that aren't an OS
 
438
            self.os_selected = True
 
439
            image = re.sub("linaro-", "", self.settings['image'])
 
440
 
 
441
            if image + "::long" in self.settings['UI']['descriptions']:
 
442
                self.help_text.SetLabel(self.settings['UI']
 
443
                                                     ['descriptions']
 
444
                                                     [image + "::long"])
 
445
            else:
 
446
                self.help_text.SetLabel("")
 
447
 
 
448
        else:  # Have selected help text
 
449
            self.os_selected = False
 
450
            self.help_text.SetLabel("Please select an operating system to run "
 
451
                                    "on your chosen hardware.")
 
452
 
 
453
        self.help_text.Wrap(self.width - 10)
 
454
        self.update_release_and_build_boxes()
 
455
        self.update_next_active()
 
456
    #--- END event(s) ---
 
457
 
106
458
 
107
459
class AboutMyHardwarePage(wiz.PyWizardPage):
108
460
    """Ask the user about their hardware. This only asks about the board, not
127
479
image or to an MMC card. First we need to know what hardware you have."""
128
480
        header = wx.StaticText(self, label=message)
129
481
 
130
 
 
131
 
 
132
482
        #--- Hardware Combo Box ---
133
483
        # Make sure that the displayed release is the one set in settings if
134
484
        # no selection is made
156
506
        file_dev_grid = wx.FlexGridSizer(0, 1, 0, 0)
157
507
        line_1_grid = wx.FlexGridSizer(0, 2, 0, 0)
158
508
        self.box2.Add(file_dev_grid, 0, wx.EXPAND)
159
 
        grid1 = wx.FlexGridSizer(0, 2, 0, 0)
160
509
 
161
510
        # self.settings['write_to_file_or_device'] should match the first
162
511
        # button below...
219
568
        val = event.GetEventObject().GetLabel()
220
569
        if val == self.button_text['sim']:
221
570
            self.settings['hw_or_qemu'] = QEMU
 
571
            assert "beagle" in self.settings['choice']['hardware'].keys()
 
572
            self.settings['hardware'] = "beagle"
 
573
 
222
574
        elif val == self.button_text['hardware']:
223
575
            self.settings['hw_or_qemu'] = HARDWARE
224
576
    #--- END event(s) ---
229
581
    def GetNext(self):
230
582
        return self.next
231
583
 
232
 
class SelectStableRelease(wiz.WizardPageSimple):
233
 
    """Ask the user which Linaro release they would like to run."""
234
 
    def __init__(self, parent, config, db, width):
235
 
        wiz.WizardPageSimple.__init__(self, parent)
236
 
        self.settings = config.settings
237
 
        self.db = db
238
 
        self.sizer = wx.BoxSizer(wx.VERTICAL)
239
 
        self.wizard = parent
240
 
 
241
 
        header = wx.StaticText(self, label="Please select the stable Linaro "
242
 
                                           "release you would like to use")
243
 
 
244
 
        header.Wrap(width - 10)  # -10 because boarder below is 5 pixels wide
245
 
 
246
 
        self.sizer.Add(header)
247
 
        self.box1 = wx.BoxSizer(wx.VERTICAL)
248
 
 
249
 
        platforms = []
250
 
        for key, value in self.settings['choice']['platform'].items():
251
 
            platforms.append(key)
252
 
 
253
 
        default_release = self.settings['UI']['translate'][platforms[-1]]
254
 
        self.cb_release = wx.ComboBox(self,
255
 
                                      value=default_release,
256
 
                                      style=wx.CB_DROPDOWN | wx.CB_READONLY)
257
 
        self.Bind(wx.EVT_COMBOBOX,
258
 
                  self.event_combo_box_release,
259
 
                  self.cb_release)
260
 
 
261
 
        if(default_release in self.settings['UI']['translate']):
262
 
            default_release = self.settings['UI']['translate'][default_release]
263
 
        self.settings['platform'] = (
264
 
                    self.settings['UI']['reverse-translate'][default_release])
265
 
 
266
 
        for item in platforms:
267
 
            if(item in self.settings['UI']['translate']):
268
 
                new_item = self.settings['UI']['translate'][item]
269
 
                item = new_item
270
 
 
271
 
            self.cb_release.Append(item, item.upper())
272
 
 
273
 
        self.cb_build = wx.ComboBox(self,
274
 
                                    style=wx.CB_DROPDOWN | wx.CB_READONLY)
275
 
        self.Bind(wx.EVT_COMBOBOX, self.event_combo_box_build, self.cb_build)
276
 
 
277
 
        self.box1.Add(self.cb_release, 0,
278
 
                      wx.ALIGN_LEFT | wx.LEFT | wx.RIGHT | wx.TOP, 5)
279
 
        self.box1.Add(self.cb_build, 0,
280
 
                      wx.ALIGN_LEFT | wx.LEFT | wx.RIGHT | wx.TOP, 5)
281
 
        self.sizer.Add(self.box1, 0, wx.ALIGN_LEFT | wx.ALL, 5)
282
 
        self.SetSizerAndFit(self.sizer)
283
 
        self.sizer.Fit(self)
284
 
        self.Move((50, 50))
285
 
 
286
 
    def update_build_box(self):
287
 
        """Depending on what hardware has been chosen, the OS list may be
288
 
        restricted. Filter out anything that is unavailable."""
289
 
        self.cb_build.Clear()
290
 
 
291
 
        builds = self.db.get_builds(self.settings['platform'])
292
 
        self.cb_build.SetValue("No build available")
293
 
 
294
 
        for build in builds:
295
 
            if(self.db.hardware_is_available_for_platform_build(
296
 
                                          self.settings['compatable_hwpacks'],
297
 
                                          self.settings['platform'],
298
 
                                          build)
299
 
                and self.db.build_is_available_for_platform_image(
300
 
                                "release_binaries",
301
 
                                self.settings['platform'],
302
 
                                self.settings['image'],
303
 
                                build)):
304
 
 
305
 
                self.cb_build.Append(build)
306
 
                self.cb_build.SetValue(build)
307
 
                self.settings['release_build'] = build
308
 
 
309
 
        available_hwpacks = (
310
 
            self.db.get_available_hwpacks_for_hardware_build_plaform(
311
 
                                          self.settings['compatable_hwpacks'],
312
 
                                          self.settings['platform'],
313
 
                                          self.settings['release_build']))
314
 
 
315
 
        if len(available_hwpacks):
316
 
            self.settings['hwpack'] = available_hwpacks[0]
317
 
            self.wizard.FindWindowById(wx.ID_FORWARD).Enable()
318
 
        else:
319
 
            self.wizard.FindWindowById(wx.ID_FORWARD).Disable()
320
 
 
321
 
    def update_release_and_build_boxes(self):
322
 
        """Depending on what hardware has been chosen, some builds may be
323
 
           unavailable..."""
324
 
        self.cb_release.Clear()
325
 
 
326
 
        default_release = None
327
 
        for platform, value in self.settings['choice']['platform'].items():
328
 
            if(self.db.hardware_is_available_for_platform(
329
 
                                          self.settings['compatable_hwpacks'],
330
 
                                          platform)
331
 
               and len(self.db.execute_return_list(
332
 
                               'select * from release_binaries '
333
 
                               'where platform == ? and image == ?',
334
 
                                (platform, self.settings['image'])))):
335
 
 
336
 
                if(platform in self.settings['UI']['translate']):
337
 
                    platform = self.settings['UI']['translate'][platform]
338
 
 
339
 
                self.cb_release.Append(platform, platform.upper())
340
 
                if not default_release or default_release < platform:
341
 
                    default_release = platform
342
 
 
343
 
        self.settings['platform'] = (
344
 
                    self.settings['UI']['reverse-translate'][default_release])
345
 
        self.cb_release.SetValue(default_release)
346
 
        self.update_build_box()
347
 
 
348
 
    #--- Event(s) ---
349
 
    def event_combo_box_release(self, evt):
350
 
        str = evt.GetString().encode('ascii').lower()
351
 
        if(str in self.settings['UI']['reverse-translate']):
352
 
            str = self.settings['UI']['reverse-translate'][str]
353
 
        self.settings['platform'] = str
354
 
 
355
 
        self.update_build_box()
356
 
 
357
 
    def event_combo_box_build(self, evt):
358
 
        self.settings['release_build'] = evt.GetString().encode('ascii')
359
 
    #--- END event(s) ---
360
 
 
361
 
 
362
584
class SelectSnapshot(wiz.WizardPageSimple):
363
585
    """Present the user with a calendar widget and a list of builds available
364
586
    on the selected date so they can chose a snapshot. Filter out days when
518
740
    #--- END event(s) ---
519
741
 
520
742
 
521
 
class SelectOS(wiz.WizardPageSimple):
522
 
    """Ask the user which OS they would like to run. Filter out any choices
523
 
    that are unavailable due to previous choices."""
524
 
    def __init__(self, parent, config, db, width):
525
 
        wiz.WizardPageSimple.__init__(self, parent)
526
 
        self.settings = config.settings
527
 
        self.wizard = parent
528
 
        self.db = db
529
 
        self.width = width
530
 
        self.sizer = wx.BoxSizer(wx.VERTICAL)
531
 
        self.settings['image'] = None
532
 
 
533
 
        header = wx.StaticText(self, label="Please select the operating "
534
 
                                           "system you would like to run on "
535
 
                                           "your hardware.")
536
 
        header.Wrap(width - 10)  # -10 because boarder below is 5 pixels wide
537
 
 
538
 
        self.box1 = wx.BoxSizer(wx.VERTICAL)
539
 
        self.sizer.Add(header)
540
 
 
541
 
        self.cb_image = wx.ComboBox(self,
542
 
                                    style=wx.CB_DROPDOWN | wx.CB_READONLY)
543
 
        self.Bind(wx.EVT_COMBOBOX, self.event_combo_box_os, self.cb_image)
544
 
 
545
 
        #--- Layout ---
546
 
        # -- Combo boxes for hardware and image selection --
547
 
        self.box1.Add(self.cb_image, 0, wx.ALIGN_LEFT | wx.ALL, 5)
548
 
 
549
 
        self.sizer.Add(self.box1, 0, wx.ALIGN_LEFT | wx.ALL, 5)
550
 
 
551
 
        self.help_text = wx.StaticText(self)
552
 
        self.sizer.Add(self.help_text, 1, wx.EXPAND, 5)
553
 
 
554
 
        self.SetSizer(self.sizer)
555
 
        self.sizer.Fit(self)
556
 
        self.Move((50, 50))
557
 
 
558
 
    def get_human_os_name(self, item):
559
 
        """Given an OS name from the database, return a human name (either
560
 
        translated from the YAML settings, or just prettified) and if it is a
561
 
        LEB OS or not"""
562
 
 
563
 
        item = re.sub("linaro-", "", item)  # Remove any linaro- decoration
564
 
 
565
 
        human_name = item
566
 
 
567
 
        if item in self.settings['UI']['descriptions']:
568
 
            human_name = self.settings['UI']['descriptions'][item]
569
 
        else:
570
 
            # Make human_name look nicer...
571
 
            human_name = string.capwords(item)
572
 
 
573
 
        leb_search = re.search("^LEB:\s*(.*)$", human_name)
574
 
 
575
 
        if leb_search:
576
 
            return leb_search.group(1), True
577
 
 
578
 
        return human_name, False
579
 
 
580
 
    def fill_os_list(self):
581
 
        """Filter the list of OS's from the config file based on the users
582
 
        preferences so all choices in the list are valid (i.e. their hardware
583
 
        is supported for the build they have chosen)."""
584
 
 
585
 
        # select unique image from snapshot_binaries/release_binaries to
586
 
        # generate list
587
 
        os_list = None
588
 
        if self.settings['release_or_snapshot'] == "release":
589
 
            os_list = self.db.get_os_list_from('release_binaries')
590
 
        else:
591
 
            os_list = self.db.get_os_list_from('snapshot_binaries')
592
 
 
593
 
        self.cb_image.Clear()
594
 
 
595
 
        printed_tag = None
596
 
        last_name = None
597
 
        current_image_setting_valid = False
598
 
 
599
 
        for state in ["LEB", "other"]:
600
 
            for item in os_list:
601
 
                if item == "old":
602
 
                    # Old is a directory that sometimes hangs around,
603
 
                    # but isn't one we want to display
604
 
                    continue
605
 
 
606
 
                # Save the original, untouched image name for use later.
607
 
                # We give it a more human name for display
608
 
                original = item
609
 
                item = re.sub("linaro-", "", item)
610
 
 
611
 
                os_hardware_combo_available = (
612
 
                            self.db.image_hardware_combo_available(
613
 
                                    self.settings['release_or_snapshot'],
614
 
                                    original,
615
 
                                    self.settings['compatable_hwpacks']))
616
 
 
617
 
                if os_hardware_combo_available:
618
 
                    human_name, is_LEB = self.get_human_os_name(item)
619
 
 
620
 
                    if item == self.settings['image']:
621
 
                        current_image_setting_valid = True
622
 
 
623
 
                    if state == "LEB" and is_LEB:
624
 
 
625
 
                        if printed_tag != state:
626
 
                            self.cb_image.Append(
627
 
                                            "- Linaro Supported Releases -")
628
 
                            printed_tag = state
629
 
 
630
 
                        self.cb_image.Append(human_name, original)
631
 
 
632
 
                        if self.settings['image'] == None:
633
 
                            self.settings['image'] = original
634
 
 
635
 
                    elif state != "LEB" and not is_LEB:
636
 
                        if printed_tag != state:
637
 
                            self.cb_image.Append(
638
 
                                            "- Community Supported Releases -")
639
 
                            printed_tag = state
640
 
 
641
 
                        self.cb_image.Append(human_name, original)
642
 
 
643
 
                    last_name = original
644
 
 
645
 
        if(    self.settings['image'] != None
646
 
           and current_image_setting_valid == False):
647
 
            # If we have an image setting, but it doesn't match the OS list, we
648
 
            # have switched OS list. It may be that adding/removing "linaro-"
649
 
            # from the name will get a match.
650
 
 
651
 
            if re.search("linaro-", self.settings['image']):
652
 
                test_name = re.sub("linaro-", "", self.settings['image'])
653
 
            else:
654
 
                test_name = "linaro-" + self.settings['image']
655
 
 
656
 
            if test_name in os_list:
657
 
                # Success! We have translated the name and can retain the
658
 
                # "old setting"
659
 
                self.settings['image'] = test_name
660
 
                current_image_setting_valid = True
661
 
 
662
 
        if(   self.settings['image'] == None
663
 
           or current_image_setting_valid == False):
664
 
            # This should only get hit if there are no LEBs available
665
 
            self.settings['image'] = last_name
666
 
 
667
 
        assert self.settings['image']
668
 
 
669
 
        # Make sure the visible selected value matches the saved setting
670
 
        self.cb_image.SetValue(
671
 
                            self.get_human_os_name(self.settings['image'])[0])
672
 
 
673
 
    #--- Event(s) ---
674
 
    def event_combo_box_os(self, evt):
675
 
        self.settings['image'] = self.cb_image.GetClientData(
676
 
                                                            evt.GetSelection())
677
 
 
678
 
        if self.settings['image']:  # Is None for items that aren't an OS
679
 
            self.wizard.FindWindowById(wx.ID_FORWARD).Enable()
680
 
            image = re.sub("linaro-", "", self.settings['image'])
681
 
 
682
 
            if image + "::long" in self.settings['UI']['descriptions']:
683
 
                self.help_text.SetLabel(self.settings['UI']
684
 
                                                     ['descriptions']
685
 
                                                     [image + "::long"])
686
 
            else:
687
 
                self.help_text.SetLabel("")
688
 
 
689
 
        else:  # Have selected help text
690
 
            self.wizard.FindWindowById(wx.ID_FORWARD).Disable()
691
 
            self.help_text.SetLabel("Please select an operating system to run "
692
 
                                    "on your chosen hardware.")
693
 
 
694
 
        self.help_text.Wrap(self.width - 10)
695
 
    #--- END event(s) ---
696
 
 
697
 
 
698
743
class LMC_settings(wiz.WizardPageSimple):
699
744
    """Present the user with, intially, the choice of writing the file system
700
745
    they are going to have created to a file, or directly to a device. Ask
1450
1495
        self.done_startup = False
1451
1496
 
1452
1497
    def on_page_changing(self, evt):
1453
 
        'Executed before the page changes.'
1454
 
 
1455
 
        if self.done_startup == False:
1456
 
            self.pages['lmc_settings'].box2.Hide(
1457
 
                            self.pages['lmc_settings'].optional_settings_box,
1458
 
                            True)
1459
 
 
1460
 
            self.pages['lmc_settings'].box3.Hide(
1461
 
                            self.pages['lmc_settings'].confirm_mmc_usage_box,
1462
 
                            True)
 
1498
        """Executed before the page changes."""
 
1499
 
 
1500
        hw_details_pg = self.pages['hardware_details']
 
1501
        rel_or_snap_pg = self.pages['release_or_snapshot']
 
1502
        select_snap_pg = self.pages['select_snapshot']
 
1503
        lmc_settings_pg = self.pages['lmc_settings']
 
1504
 
 
1505
        if not self.done_startup:
 
1506
            lmc_settings_pg.box2.Hide(lmc_settings_pg.optional_settings_box,
 
1507
                                      True)
 
1508
 
 
1509
            lmc_settings_pg.box3.Hide(lmc_settings_pg.confirm_mmc_usage_box,
 
1510
                                      True)
1463
1511
 
1464
1512
            self.done_startup = True
1465
1513
 
1471
1519
 
1472
1520
            # If going from a select snapshot or select release page, record
1473
1521
            # which we were on so the back button of the next page works
1474
 
            if(self.config.settings['release_or_snapshot'] == "release"):
1475
 
                self.pages['select_os'].SetNext(self.pages['select_release'])
1476
 
                self.pages['select_release'].SetPrev(self.pages['select_os'])
1477
 
 
1478
 
                self.pages['select_release'].SetNext(self.pages['lmc_settings'])
1479
 
                self.pages['lmc_settings'].SetPrev(self.pages['select_release'])
 
1522
            if self.config.settings['release_or_snapshot'] == "release":
 
1523
                lmc_settings_pg.SetPrev(rel_or_snap_pg)
1480
1524
            else:
1481
 
                self.pages['select_os'].SetNext(self.pages['select_snapshot'])
1482
 
                self.pages['select_snapshot'].SetPrev(self.pages['select_os'])
1483
 
 
1484
 
                if(page == self.pages['select_os']):
1485
 
                    self.pages['select_snapshot'].fill_build_combo_box_for_date(
 
1525
                select_snap_pg.SetNext(lmc_settings_pg)
 
1526
 
 
1527
                lmc_settings_pg.SetPrev(select_snap_pg)
 
1528
                select_snap_pg.SetPrev(rel_or_snap_pg)
 
1529
 
 
1530
                if page == rel_or_snap_pg:
 
1531
                    select_snap_pg.fill_build_combo_box_for_date(
1486
1532
                                            self.config.settings['build_date'])
1487
1533
 
1488
 
                self.pages['select_snapshot'].SetNext(self.pages['lmc_settings'])
1489
 
                self.pages['lmc_settings'].SetPrev(self.pages['select_snapshot'])
1490
 
 
1491
 
            if page == self.pages['hardware_details']:
1492
 
                self.pages['select_os'].fill_os_list()
1493
 
 
1494
 
            # If about to move into the release selection, make sure the list
1495
 
            # is populated only with releases that are valid with our current
1496
 
            # selection
1497
 
            if(    page == self.pages['select_os']
1498
 
               and self.config.settings['release_or_snapshot'] == "release"):
1499
 
                self.pages['select_release'].update_release_and_build_boxes()
1500
 
 
1501
 
            if page == self.pages['select_snapshot']:
 
1534
            if page == hw_details_pg:
 
1535
                rel_or_snap_pg.fill_os_list()
 
1536
                rel_or_snap_pg.update_release_and_build_boxes()
 
1537
 
 
1538
            if page == select_snap_pg:
1502
1539
                # Execute when exiting page
1503
 
                self.pages['select_snapshot'].update_platform()
1504
 
 
1505
 
            if(   page == self.pages['select_snapshot']
1506
 
               or page == self.pages['select_release']):
1507
 
                self.pages['lmc_settings'].on_activate()
1508
 
 
1509
 
            if page == self.pages['lmc_settings']:
 
1540
                select_snap_pg.update_platform()
 
1541
 
 
1542
            if(   page == select_snap_pg
 
1543
               or (page == rel_or_snap_pg and
 
1544
                   self.config.settings['release_or_snapshot'] == "release")):
 
1545
                lmc_settings_pg.on_activate()
 
1546
 
 
1547
            if page == lmc_settings_pg:
1510
1548
                # Forward stays disabled until LMC has finished running
1511
1549
                self.wizard.FindWindowById(wx.ID_FORWARD).Disable()
1512
1550
                self.pages['run_lmc'].on_activate()
1544
1582
 
1545
1583
        self.pages['release_or_snapshot'] = ReleaseOrSnapshotPage(self.wizard,
1546
1584
                                                                  self.config,
 
1585
                                                                  db,
 
1586
                                                                  self.pages,
1547
1587
                                                                  width)
1548
1588
 
1549
 
        self.pages['select_release']    = SelectStableRelease(self.wizard,
1550
 
                                                              self.config,
1551
 
                                                              db,
1552
 
                                                              width)
1553
 
 
1554
1589
        self.pages['select_snapshot']   = SelectSnapshot(self.wizard,
1555
1590
                                                         self.config,
1556
1591
                                                         db,
1557
1592
                                                         width)
1558
1593
 
1559
 
        self.pages['select_os']         = SelectOS(self.wizard,
1560
 
                                                   self.config,
1561
 
                                                   db,
1562
 
                                                   width)
1563
 
 
1564
1594
        self.pages['lmc_settings']      = LMC_settings(self.wizard,
1565
1595
                                                       self.config,
1566
1596
                                                       db,
1574
1604
        self.pages['hardware_details'].SetNext(
1575
1605
                                            self.pages['release_or_snapshot'])
1576
1606
 
1577
 
        self.pages['release_or_snapshot'].SetPrev(
1578
 
                                            self.pages['hardware_details'])
1579
 
 
1580
 
        self.pages['release_or_snapshot'].SetNext(self.pages['select_os'])
1581
 
        self.pages['select_os'].SetPrev(self.pages['release_or_snapshot'])
1582
 
        # Select OS goes to select build, which is customised for
1583
 
        # releases or snapshots
1584
1607
        self.pages['lmc_settings'].SetNext(self.pages['run_lmc'])
1585
1608
        self.pages['run_lmc'].SetPrev(self.pages['lmc_settings'])
1586
1609