![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hatariui.py CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [HATARI the Atari ST Emulator] / hatari / python-ui|
Return to hatariui.py CVS log | Up to [HATARI the Atari ST Emulator] / hatari / python-ui |
1.1 root 1: #!/usr/bin/env python
2: #
3: # A PyGtk UI for Hatari that can embed the Hatari emulator window.
4: #
5: # Requires PyGtk (python-gtk2) package and its dependencies to be present.
6: #
1.1.1.5 root 7: # Copyright (C) 2008-2011 by Eero Tamminen
1.1 root 8: #
9: # This program is free software; you can redistribute it and/or modify
10: # it under the terms of the GNU General Public License as published by
11: # the Free Software Foundation; either version 2 of the License, or
12: # (at your option) any later version.
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: import os
20: import sys
21: import getopt
22:
23: # use correct version of pygtk/gtk
24: import pygtk
25: pygtk.require('2.0')
26: import gtk
27: import gobject
28:
29: from debugui import HatariDebugUI
30: from hatari import Hatari, HatariConfigMapping
31: from uihelpers import UInfo, UIHelp, create_button, create_toolbutton, \
32: create_toggle, HatariTextInsert, get_open_filename, get_save_filename
1.1.1.2 root 33: from dialogs import AboutDialog, TodoDialog, NoteDialog, ErrorDialog, \
34: InputDialog, KillDialog, QuitSaveDialog, ResetDialog, TraceDialog, \
35: FloppyDialog, HardDiskDialog, DisplayDialog, JoystickDialog, \
36: MachineDialog, PeripheralDialog, PathDialog, SoundDialog
1.1 root 37:
38:
39: # helper functions to match callback args
40: def window_hide_cb(window, arg):
41: window.hide()
42: return True
43:
44:
45: # ---------------------------------------------------------------
46: # Class with Hatari and configuration instances which methods are
47: # called to change those (with additional dialogs or directly).
48: # Owns the application window and socket widget embedding Hatari.
49: class UICallbacks:
50: tmpconfpath = os.path.expanduser("~/.hatari/.tmp.cfg")
51: def __init__(self):
52: # Hatari and configuration
53: self.hatari = Hatari()
1.1.1.2 root 54: error = self.hatari.is_compatible()
55: if error:
56: ErrorDialog(None).run(error)
57: sys.exit(-1)
58:
1.1 root 59: self.config = HatariConfigMapping(self.hatari)
1.1.1.2 root 60: try:
61: self.config.validate()
62: except (KeyError, AttributeError):
63: NoteDialog(None).run("Loading Hatari configuration failed!\nRetrying after saving Hatari configuration.")
64: self.hatari.save_config()
65: self.config = HatariConfigMapping(self.hatari)
66: self.config.validate()
1.1 root 67:
68: # windows are created when needed
69: self.mainwin = None
70: self.hatariwin = None
71: self.debugui = None
72: self.panels = {}
73:
74: # dialogs are created when needed
75: self.aboutdialog = None
76: self.inputdialog = None
77: self.tracedialog = None
78: self.resetdialog = None
79: self.quitdialog = None
80: self.killdialog = None
81:
1.1.1.2 root 82: self.floppydialog = None
83: self.harddiskdialog = None
1.1 root 84: self.displaydialog = None
85: self.joystickdialog = None
86: self.machinedialog = None
87: self.peripheraldialog = None
88: self.sounddialog = None
89: self.pathdialog = None
90:
91: # used by run()
92: self.memstate = None
93: self.floppy = None
94: self.io_id = None
95:
96: # TODO: Hatari UI own configuration settings save/load
97: self.tracepoints = None
98:
99: def _reset_config_dialogs(self):
1.1.1.2 root 100: self.floppydialog = None
101: self.harddiskdialog = None
1.1 root 102: self.displaydialog = None
103: self.joystickdialog = None
104: self.machinedialog = None
105: self.peripheraldialog = None
106: self.sounddialog = None
107: self.pathdialog = None
108:
109: # ---------- create UI ----------------
110: def create_ui(self, accelgroup, menu, toolbars, fullscreen, embed):
111: "create_ui(menu, toolbars, fullscreen, embed)"
112: # add horizontal elements
113: hbox = gtk.HBox()
114: if toolbars["left"]:
115: hbox.pack_start(toolbars["left"], False, True)
116: if embed:
117: self._add_uisocket(hbox)
118: if toolbars["right"]:
119: hbox.pack_start(toolbars["right"], False, True)
120: # add vertical elements
121: vbox = gtk.VBox()
122: if menu:
123: vbox.add(menu)
124: if toolbars["top"]:
125: vbox.pack_start(toolbars["top"], False, True)
126: vbox.add(hbox)
127: if toolbars["bottom"]:
128: vbox.pack_start(toolbars["bottom"], False, True)
129: # put them to main window
130: mainwin = gtk.Window(gtk.WINDOW_TOPLEVEL)
131: mainwin.set_title("%s %s" % (UInfo.name, UInfo.version))
132: mainwin.set_icon_from_file(UInfo.icon)
133: if accelgroup:
134: mainwin.add_accel_group(accelgroup)
135: if fullscreen:
136: mainwin.fullscreen()
137: mainwin.add(vbox)
138: mainwin.show_all()
139: # for run and quit callbacks
140: self.killdialog = KillDialog(mainwin)
141: mainwin.connect("delete_event", self.quit)
142: self.mainwin = mainwin
143:
144: def _add_uisocket(self, box):
145: # add Hatari parent container to given box
146: socket = gtk.Socket()
147: # without this, closing Hatari would remove the socket widget
148: socket.connect("plug-removed", lambda obj: True)
149: socket.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("black"))
150: socket.set_events(gtk.gdk.ALL_EVENTS_MASK)
151: socket.set_flags(gtk.CAN_FOCUS)
1.1.1.4 root 152: # set max Hatari window size = desktop size
153: self.config.set_desktop_size(gtk.gdk.screen_width(), gtk.gdk.screen_height())
1.1 root 154: # set initial embedded hatari size
155: width, height = self.config.get_window_size()
156: socket.set_size_request(width, height)
157: # no resizing for the Hatari window
158: box.pack_start(socket, False, False)
159: self.hatariwin = socket
160:
161: # ------- run callback -----------
162: def _socket_cb(self, fd, event):
163: if event != gobject.IO_IN:
164: # hatari process died, make sure Hatari instance notices
165: self.hatari.kill()
166: return False
167: width, height = self.hatari.get_embed_info()
1.1.1.3 root 168: print("New size = %d x %d" % (width, height))
1.1 root 169: oldwidth, oldheight = self.hatariwin.get_size_request()
170: self.hatariwin.set_size_request(width, height)
171: if width < oldwidth or height < oldheight:
172: # force also mainwin smaller (it automatically grows)
173: self.mainwin.resize(width, height)
174: return True
175:
176: def run(self, widget = None):
177: if not self.killdialog.run(self.hatari):
178: return
179: if self.io_id:
180: gobject.source_remove(self.io_id)
181: args = ["--configfile"]
182: # whether to use Hatari config or unsaved Hatari UI config?
183: if self.config.is_changed():
184: args += [self.config.save_tmp(self.tmpconfpath)]
185: else:
186: args += [self.config.get_path()]
187: if self.memstate:
188: args += self.memstate
1.1.1.2 root 189: # only way to change boot order is to specify disk on command line
1.1 root 190: if self.floppy:
191: args += self.floppy
192: if self.hatariwin:
193: size = self.hatariwin.window.get_size()
194: self.hatari.run(args, self.hatariwin.window)
195: # get notifications of Hatari window size changes
196: self.hatari.enable_embed_info()
197: socket = self.hatari.get_control_socket().fileno()
198: events = gobject.IO_IN | gobject.IO_HUP | gobject.IO_ERR
199: self.io_id = gobject.io_add_watch(socket, events, self._socket_cb)
200: # all keyboard events should go to Hatari window
201: self.hatariwin.grab_focus()
202: else:
203: self.hatari.run(args)
204:
205: def set_floppy(self, floppy):
206: self.floppy = floppy
207:
208: # ------- quit callback -----------
209: def quit(self, widget, arg = None):
210: # due to Gtk API, needs to return True when *not* quitting
211: if not self.killdialog.run(self.hatari):
212: return True
213: if self.io_id:
214: gobject.source_remove(self.io_id)
215: if self.config.is_changed():
216: if not self.quitdialog:
217: self.quitdialog = QuitSaveDialog(self.mainwin)
218: if not self.quitdialog.run(self.config):
219: return True
220: gtk.main_quit()
221: if os.path.exists(self.tmpconfpath):
222: os.unlink(self.tmpconfpath)
223: # continue to mainwin destroy if called by delete_event
224: return False
225:
226: # ------- pause callback -----------
227: def pause(self, widget):
228: if widget.get_active():
229: self.hatari.pause()
230: else:
231: self.hatari.unpause()
232:
233: # dialogs
234: # ------- reset callback -----------
235: def reset(self, widget):
236: if not self.resetdialog:
237: self.resetdialog = ResetDialog(self.mainwin)
238: self.resetdialog.run(self.hatari)
239:
240: # ------- about callback -----------
241: def about(self, widget):
242: if not self.aboutdialog:
243: self.aboutdialog = AboutDialog(self.mainwin)
244: self.aboutdialog.run()
245:
246: # ------- input callback -----------
247: def inputs(self, widget):
248: if not self.inputdialog:
249: self.inputdialog = InputDialog(self.mainwin)
250: self.inputdialog.run(self.hatari)
251:
1.1.1.2 root 252: # ------- floppydisk callback -----------
253: def floppydisk(self, widget):
254: if not self.floppydialog:
255: self.floppydialog = FloppyDialog(self.mainwin)
256: self.floppydialog.run(self.config)
257:
258: # ------- harddisk callback -----------
259: def harddisk(self, widget):
260: if not self.harddiskdialog:
261: self.harddiskdialog = HardDiskDialog(self.mainwin)
262: self.harddiskdialog.run(self.config)
1.1 root 263:
264: # ------- display callback -----------
265: def display(self, widget):
266: if not self.displaydialog:
267: self.displaydialog = DisplayDialog(self.mainwin)
268: self.displaydialog.run(self.config)
269:
270: # ------- joystick callback -----------
271: def joystick(self, widget):
272: if not self.joystickdialog:
273: self.joystickdialog = JoystickDialog(self.mainwin)
274: self.joystickdialog.run(self.config)
275:
276: # ------- machine callback -----------
277: def machine(self, widget):
278: if not self.machinedialog:
279: self.machinedialog = MachineDialog(self.mainwin)
280: if self.machinedialog.run(self.config):
281: self.hatari.trigger_shortcut("coldreset")
282:
283: # ------- peripheral callback -----------
284: def peripheral(self, widget):
285: if not self.peripheraldialog:
286: self.peripheraldialog = PeripheralDialog(self.mainwin)
287: self.peripheraldialog.run(self.config)
288:
289: # ------- sound callback -----------
290: def sound(self, widget):
291: if not self.sounddialog:
292: self.sounddialog = SoundDialog(self.mainwin)
293: self.sounddialog.run(self.config)
294:
295: # ------- path callback -----------
296: def path(self, widget):
297: if not self.pathdialog:
298: self.pathdialog = PathDialog(self.mainwin)
299: self.pathdialog.run(self.config)
300:
301: # ------- debug callback -----------
302: def debugger(self, widget):
303: if not self.debugui:
304: self.debugui = HatariDebugUI(self.hatari)
305: self.debugui.show()
306:
307: # ------- trace callback -----------
308: def trace(self, widget):
309: if not self.tracedialog:
310: self.tracedialog = TraceDialog(self.mainwin)
311: self.tracepoints = self.tracedialog.run(self.hatari, self.tracepoints)
312:
313: # ------ snapshot load/save callbacks ---------
314: def load(self, widget):
315: path = os.path.expanduser("~/.hatari/hatari.sav")
316: filename = get_open_filename("Select snapshot", self.mainwin, path)
317: if filename:
318: self.memstate = ["--memstate", filename]
319: self.run()
320: return True
321: return False
322:
323: def save(self, widget):
324: self.hatari.trigger_shortcut("savemem")
325:
326: # ------ config load/save callbacks ---------
327: def config_load(self, widget):
328: path = self.config.get_path()
329: filename = get_open_filename("Select configuration file", self.mainwin, path)
330: if filename:
331: self.hatari.change_option("--configfile %s" % filename)
332: self.config.load(filename)
333: self._reset_config_dialogs()
334: return True
335: return False
336:
337: def config_save(self, widget):
338: path = self.config.get_path()
339: filename = get_save_filename("Save configuration as...", self.mainwin, path)
340: if filename:
341: self.config.save_as(filename)
342: return True
343: return False
344:
345: # ------- fast forward callback -----------
346: def set_fastforward(self, widget):
347: self.config.set_fastforward(widget.get_active())
348:
349: def get_fastforward(self):
350: return self.config.get_fastforward()
351:
352: # ------- fullscreen callback -----------
353: def set_fullscreen(self, widget):
354: # if user can select this, Hatari isn't in fullscreen
355: self.hatari.change_option("--fullscreen")
356:
357: # ------- screenshot callback -----------
358: def screenshot(self, widget):
359: self.hatari.trigger_shortcut("screenshot")
360:
361: # ------- record callbacks -----------
362: def recanim(self, widget):
363: self.hatari.trigger_shortcut("recanim")
364:
365: def recsound(self, widget):
366: self.hatari.trigger_shortcut("recsound")
367:
368: # ------- insert key special callback -----------
369: def keypress(self, widget, code):
370: self.hatari.insert_event("keypress %s" % code)
371:
372: def textinsert(self, widget, text):
373: HatariTextInsert(self.hatari, text)
374:
375: # ------- panel callback -----------
376: def panel(self, action, box):
377: title = action.get_name()
378: if title not in self.panels:
379: window = gtk.Window(gtk.WINDOW_TOPLEVEL)
380: window.set_transient_for(self.mainwin)
381: window.set_icon_from_file(UInfo.icon)
382: window.set_title(title)
383: window.add(box)
384: window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DIALOG)
385: window.connect("delete_event", window_hide_cb)
386: self.panels[title] = window
387: else:
388: window = self.panels[title]
389: window.show_all()
390: window.deiconify()
391:
392:
393: # ---------------------------------------------------------------
394: # class for creating menus, toolbars and panels
395: # and managing actions bound to them
396: class UIActions:
397: def __init__(self):
398: cb = self.callbacks = UICallbacks()
399:
400: self.help = UIHelp()
401:
402: self.actions = gtk.ActionGroup("All")
403:
404: # name, icon ID, label, accel, tooltip, callback
405: self.actions.add_toggle_actions((
406: # TODO: how to know when these are changed from inside Hatari?
407: ("recanim", gtk.STOCK_MEDIA_RECORD, "Record animation", "<Ctrl>A", "Record animation", cb.recanim),
408: ("recsound", gtk.STOCK_MEDIA_RECORD, "Record sound", "<Ctrl>W", "Record YM/Wav", cb.recsound),
409: ("pause", gtk.STOCK_MEDIA_PAUSE, "Pause", "<Ctrl>P", "Pause Hatari to save battery", cb.pause),
410: ("forward", gtk.STOCK_MEDIA_FORWARD, "Forward", "<Ctrl>F", "Whether to fast forward Hatari (needs fast machine)", cb.set_fastforward, cb.get_fastforward())
411: ))
412:
413: # name, icon ID, label, accel, tooltip, callback
414: self.actions.add_actions((
415: ("load", gtk.STOCK_OPEN, "Load snapshot...", "<Ctrl>L", "Load emulation snapshot", cb.load),
416: ("save", gtk.STOCK_SAVE, "Save snapshot", "<Ctrl>S", "Save emulation snapshot", cb.save),
417: ("shot", gtk.STOCK_MEDIA_RECORD, "Grab screenshot", "<Ctrl>G", "Grab a screenshot", cb.screenshot),
418: ("quit", gtk.STOCK_QUIT, "Quit", "<Ctrl>Q", "Quit Hatari UI", cb.quit),
419:
420: ("run", gtk.STOCK_MEDIA_PLAY, "Run", "<Ctrl>R", "(Re-)run Hatari", cb.run),
421: ("full", gtk.STOCK_FULLSCREEN, "Fullscreen", "<Ctrl>U", "Toggle whether Hatari is fullscreen", cb.set_fullscreen),
422: ("input", gtk.STOCK_SPELL_CHECK, "Inputs...", "<Ctrl>N", "Simulate text input and mouse clicks", cb.inputs),
423: ("reset", gtk.STOCK_REFRESH, "Reset...", "<Ctrl>E", "Warm or cold reset Hatari", cb.reset),
424:
425: ("display", gtk.STOCK_PREFERENCES, "Display...", "<Ctrl>Y", "Display settings", cb.display),
1.1.1.2 root 426: ("floppy", gtk.STOCK_FLOPPY, "Floppies...", "<Ctrl>D", "Floppy images", cb.floppydisk),
427: ("harddisk", gtk.STOCK_HARDDISK, "Hard disks...", "<Ctrl>H", "Hard disk images and directories", cb.harddisk),
1.1 root 428: ("joystick", gtk.STOCK_CONNECT, "Joysticks...", "<Ctrl>J", "Joystick settings", cb.joystick),
429: ("machine", gtk.STOCK_HARDDISK, "Machine...", "<Ctrl>M", "Hatari st/e/tt/falcon configuration", cb.machine),
430: ("device", gtk.STOCK_PRINT, "Peripherals...", "<Ctrl>V", "Toggle Midi, Printer, RS232 peripherals", cb.peripheral),
431: ("sound", gtk.STOCK_PROPERTIES, "Sound...", "<Ctrl>O", "Sound settings", cb.sound),
432:
433: ("path", gtk.STOCK_DIRECTORY, "Paths...", None, "Device & save file paths", cb.path),
434: ("lconfig", gtk.STOCK_OPEN, "Load config...", "<Ctrl>C", "Load configuration", self.config_load),
435: ("sconfig", gtk.STOCK_SAVE_AS, "Save config as...", None, "Save configuration", cb.config_save),
436:
437: ("debug", gtk.STOCK_FIND, "Debugger...", "<Ctrl>B", "Activate Hatari debugger", cb.debugger),
438: ("trace", gtk.STOCK_EXECUTE, "Trace settings...", "<Ctrl>T", "Hatari tracing setup", cb.trace),
439:
440: ("manual", None, "Hatari manual", None, None, self.help.view_hatari_manual),
441: ("compatibility", None, "Hatari compatibility list", None, None, self.help.view_hatari_compatibility),
442: ("release", None, "Hatari release notes", None, None, self.help.view_hatari_releasenotes),
443: ("todo", None, "Hatari TODO", None, None, self.help.view_hatari_todo),
444: ("mails", None, "Hatari mailing lists", None, None, self.help.view_hatari_mails),
445: ("changes", None, "Latest Hatari changes", None, None, self.help.view_hatari_repository),
446: ("authors", None, "Hatari authors", None, None, self.help.view_hatari_authors),
447: ("hatari", None, "Hatari home page", None, None, self.help.view_hatari_page),
448: ("hatariui", None, "Hatari UI home page", None, None, self.help.view_hatariui_page),
449: ("about", gtk.STOCK_INFO, "Hatari UI info", "<Ctrl>I", "Hatari UI information", cb.about)
450: ))
451: self.action_names = [x.get_name() for x in self.actions.list_actions()]
452:
453: # no actions set yet to panels or toolbars
454: self.toolbars = {}
455: self.panels = []
456:
457: def config_load(self, widget):
458: # user loads a new configuration?
459: if self.callbacks.config_load(widget):
1.1.1.3 root 460: print("TODO: reset toggle actions")
1.1 root 461:
462: # ----- toolbar / panel additions ---------
463: def set_actions(self, action_str, place):
464: "set_actions(actions,place) -> error string, None if all OK"
465: actions = action_str.split(",")
466: for action in actions:
467: if action in self.action_names:
468: # regular action
469: continue
470: if action in self.panels:
471: # user specified panel
472: continue
473: if action in ("close", ">"):
474: if place != "panel":
475: return "'close' and '>' can be only in a panel"
476: continue
477: if action == "|":
478: # divider
479: continue
480: if action.find("=") >= 0:
481: # special keycode/string action
482: continue
483: return "unrecognized action '%s'" % action
484:
485: if place in ("left", "right", "top", "bottom"):
486: self.toolbars[place] = actions
487: return None
488: if place == "panel":
489: if len(actions) < 3:
490: return "panel has too few items to be useful"
491: return None
492: return "unknown actions position '%s'" % place
493:
494: def add_panel(self, spec):
495: "add_panel(panel_specification) -> error string, None if all is OK"
496: offset = spec.find(",")
497: if offset <= 0:
498: return "invalid panel specification '%s'" % spec
499:
500: name, panelcontrols = spec[:offset], spec[offset+1:]
501: error = self.set_actions(panelcontrols, "panel")
502: if error:
503: return error
504:
505: if ",>," in panelcontrols:
506: box = gtk.VBox()
507: splitcontrols = panelcontrols.split(",>,")
508: for controls in splitcontrols:
509: box.add(self._get_container(controls.split(",")))
510: else:
511: box = self._get_container(panelcontrols.split(","))
512:
513: self.panels.append(name)
514: self.actions.add_actions(
515: ((name, gtk.STOCK_ADD, name, None, name, self.callbacks.panel),),
516: box
517: )
518: return None
519:
520: def list_actions(self):
521: yield ("|", "Separator between controls")
1.1.1.6 ! root 522: yield (">", "Start next toolbar row in panel windows")
1.1 root 523: # generate the list from action information
524: for act in self.actions.list_actions():
1.1.1.2 root 525: note = act.get_property("tooltip")
526: if not note:
527: note = act.get_property("label")
528: yield(act.get_name(), note)
1.1 root 529: yield ("<panel name>", "Button for the specified panel window")
530: yield ("<name>=<string/code>", "Synthetize string or single key <code>")
531:
532: # ------- panel special actions -----------
533: def _close_cb(self, widget):
534: widget.get_toplevel().hide()
535:
536: # ------- key special action -----------
537: def _create_key_control(self, name, textcode):
538: "Simulate Atari key press/release and string inserting"
539: if not textcode:
1.1.1.3 root 540: return None
1.1 root 541: widget = gtk.ToolButton(gtk.STOCK_PASTE)
542: widget.set_label(name)
543: try:
544: # part after "=" converts to an int?
545: code = int(textcode, 0)
546: widget.connect("clicked", self.callbacks.keypress, code)
547: tip = "keycode: %d" % code
548: except ValueError:
549: # no, assume a string macro is wanted instead
550: widget.connect("clicked", self.callbacks.textinsert, textcode)
551: tip = "string '%s'" % textcode
1.1.1.3 root 552: widget.set_tooltip_text("Insert " + tip)
553: return widget
1.1 root 554:
555: def _get_container(self, actions, horiz = True):
556: "return Gtk container with the specified actions or None for no actions"
557: if not actions:
558: return None
559:
1.1.1.3 root 560: #print("ACTIONS:", actions)
1.1 root 561: if len(actions) > 1:
562: bar = gtk.Toolbar()
563: if horiz:
564: bar.set_orientation(gtk.ORIENTATION_HORIZONTAL)
565: else:
566: bar.set_orientation(gtk.ORIENTATION_VERTICAL)
567: bar.set_style(gtk.TOOLBAR_BOTH)
568: # disable overflow menu to get toolbar sized correctly for panels
569: bar.set_show_arrow(False)
570: else:
571: bar = None
572:
573: for action in actions:
1.1.1.3 root 574: #print(action)
1.1 root 575: offset = action.find("=")
576: if offset >= 0:
577: # handle "<name>=<keycode>" action specification
578: name = action[:offset]
579: text = action[offset+1:]
1.1.1.3 root 580: widget = self._create_key_control(name, text)
1.1 root 581: elif action == "|":
582: widget = gtk.SeparatorToolItem()
583: elif action == "close":
584: if bar:
585: widget = create_toolbutton(gtk.STOCK_CLOSE, self._close_cb)
586: else:
587: widget = create_button("Close", self._close_cb)
588: else:
589: widget = self.actions.get_action(action).create_tool_item()
590: if not widget:
591: continue
592: if bar:
593: if action != "|":
594: widget.set_expand(True)
595: bar.insert(widget, -1)
596: if bar:
597: return bar
598: return widget
599:
600: # ------------- handling menu -------------
601: def _add_submenu(self, bar, title, items):
602: submenu = gtk.Menu()
603: for name in items:
604: if name:
605: action = self.actions.get_action(name)
606: item = action.create_menu_item()
607: else:
608: item = gtk.SeparatorMenuItem()
609: submenu.add(item)
610: baritem = gtk.MenuItem(title, False)
611: baritem.set_submenu(submenu)
612: bar.add(baritem)
613:
614: def _get_menu(self):
615: allmenus = (
616: ("File", ("load", "save", None, "shot", "recanim", "recsound", None, "quit")),
617: ("Emulation", ("run", "pause", "forward", None, "full", None, "input", None, "reset")),
1.1.1.2 root 618: ("Devices", ("display", "floppy", "harddisk", "joystick", "machine", "device", "sound")),
1.1 root 619: ("Configuration", ("path", None, "lconfig", "sconfig")),
620: ("Debug", ("debug", "trace")),
1.1.1.4 root 621: ("Help", ("manual", "compatibility", "release", "todo", None, "mails", "changes", None, "authors", "hatari", "hatariui", "about",))
1.1 root 622: )
623: bar = gtk.MenuBar()
624:
625: for title, items in allmenus:
626: self._add_submenu(bar, title, items)
627:
628: if self.panels:
629: self._add_submenu(bar, "Panels", self.panels)
630:
631: return bar
632:
633: # ------------- run the whole UI -------------
634: def run(self, floppy, havemenu, fullscreen, embed):
635: accelgroup = None
636: # create menu?
637: if havemenu:
638: # this would steal keys from embedded Hatari
639: if not embed:
640: accelgroup = gtk.AccelGroup()
641: for action in self.actions.list_actions():
642: action.set_accel_group(accelgroup)
643: menu = self._get_menu()
644: else:
645: menu = None
646:
647: # create toolbars
648: toolbars = { "left":None, "right":None, "top":None, "bottom":None}
649: for side in ("left", "right"):
650: if side in self.toolbars:
651: toolbars[side] = self._get_container(self.toolbars[side], False)
652: for side in ("top", "bottom"):
653: if side in self.toolbars:
654: toolbars[side] = self._get_container(self.toolbars[side], True)
655:
656: self.callbacks.create_ui(accelgroup, menu, toolbars, fullscreen, embed)
657: self.help.set_mainwin(self.callbacks.mainwin)
658: self.callbacks.set_floppy(floppy)
659:
660: # ugly, Hatari socket window ID can be gotten only
661: # after Socket window is realized by gtk_main()
662: gobject.idle_add(self.callbacks.run)
663: gtk.main()
664:
665:
666: # ------------- usage / argument handling --------------
667: def usage(actions, msg=None):
668: name = os.path.basename(sys.argv[0])
669: uiname = "%s %s" % (UInfo.name, UInfo.version)
1.1.1.3 root 670: print("\n%s" % uiname)
671: print("=" * len(uiname))
672: print("\nUsage: %s [options] [directory|disk image|Atari program]" % name)
673: print("\nOptions:")
674: print("\t-h, --help\t\tthis help")
675: print("\t-n, --nomenu\t\tomit menus")
676: print("\t-e, --embed\t\tembed Hatari window in middle of controls")
677: print("\t-f, --fullscreen\tstart in fullscreen")
678: print("\t-l, --left <controls>\ttoolbar at left")
679: print("\t-r, --right <controls>\ttoolbar at right")
680: print("\t-t, --top <controls>\ttoolbar at top")
681: print("\t-b, --bottom <controls>\ttoolbar at bottom")
682: print("\t-p, --panel <name>,<controls>")
683: print("\t\t\t\tseparate window with given name and controls")
684: print("\nAvailable (panel/toolbar) controls:")
1.1 root 685: for action, description in actions.list_actions():
686: size = len(action)
687: if size < 8:
688: tabs = "\t\t"
689: elif size < 16:
690: tabs = "\t"
691: else:
692: tabs = "\n\t\t\t"
1.1.1.3 root 693: print("\t%s%s%s" % (action, tabs, description))
694: print("""
1.1 root 695: You can have as many panels as you wish. For each panel you need to add
696: a control with the name of the panel (see "MyPanel" below).
697:
698: For example:
699: \t%s --embed \\
700: \t-t "about,run,pause,quit" \\
701: \t-p "MyPanel,Macro=Test,Undo=97,Help=98,>,F1=59,F2=60,F3=61,F4=62,>,close" \\
702: \t-r "paste,debug,trace,machine,MyPanel" \\
703: \t-b "sound,|,fastforward,|,fullscreen"
704:
705: if no options are given, the UI uses basic controls.
1.1.1.3 root 706: """ % name)
1.1 root 707: if msg:
1.1.1.3 root 708: print("ERROR: %s\n" % msg)
1.1 root 709: sys.exit(1)
710:
711:
712: def main():
713: info = UInfo()
714: actions = UIActions()
715: try:
716: longopts = ["embed", "fullscreen", "nomenu", "help",
717: "left=", "right=", "top=", "bottom=", "panel="]
718: opts, floppies = getopt.getopt(sys.argv[1:], "efnhl:r:t:b:p:", longopts)
719: del longopts
1.1.1.3 root 720: except getopt.GetoptError as err:
1.1 root 721: usage(actions, err)
722:
723: menu = True
724: embed = False
725: fullscreen = False
726:
727: error = None
728: for opt, arg in opts:
1.1.1.3 root 729: print(opt, arg)
1.1 root 730: if opt in ("-e", "--embed"):
731: embed = True
732: elif opt in ("-f", "--fullscreen"):
733: fullscreen = True
734: elif opt in ("-n", "--nomenu"):
735: menu = False
736: elif opt in ("-h", "--help"):
737: usage(actions)
738: elif opt in ("-l", "--left"):
739: error = actions.set_actions(arg, "left")
740: elif opt in ("-r", "--right"):
741: error = actions.set_actions(arg, "right")
742: elif opt in ("-t", "--top"):
743: error = actions.set_actions(arg, "top")
744: elif opt in ("-b", "--bottom"):
745: error = actions.set_actions(arg, "bottom")
746: elif opt in ("-p", "--panel"):
747: error = actions.add_panel(arg)
748: else:
749: assert False, "getopt returned unhandled option"
750: if error:
751: usage(actions, error)
752:
753: if len(floppies) > 1:
754: usage(actions, "multiple floppy images given: %s" % str(floppies))
755: if floppies:
756: if not os.path.exists(floppies[0]):
757: usage(actions, "floppy image '%s' doesn't exist" % floppies[0])
758:
759: actions.run(floppies, menu, fullscreen, embed)
760:
761:
762: if __name__ == "__main__":
763: main()
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.