764 lines
29 KiB
Python
Executable File
764 lines
29 KiB
Python
Executable File
#!/usr/bin/env python
|
|
#
|
|
# A PyGtk UI for Hatari that can embed the Hatari emulator window.
|
|
#
|
|
# Requires PyGtk (python-gtk2) package and its dependencies to be present.
|
|
#
|
|
# Copyright (C) 2008-2011 by Eero Tamminen
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 2 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# 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.
|
|
|
|
import os
|
|
import sys
|
|
import getopt
|
|
|
|
# use correct version of pygtk/gtk
|
|
import pygtk
|
|
pygtk.require('2.0')
|
|
import gtk
|
|
import gobject
|
|
|
|
from debugui import HatariDebugUI
|
|
from hatari import Hatari, HatariConfigMapping
|
|
from uihelpers import UInfo, UIHelp, create_button, create_toolbutton, \
|
|
create_toggle, HatariTextInsert, get_open_filename, get_save_filename
|
|
from dialogs import AboutDialog, TodoDialog, NoteDialog, ErrorDialog, \
|
|
InputDialog, KillDialog, QuitSaveDialog, ResetDialog, TraceDialog, \
|
|
FloppyDialog, HardDiskDialog, DisplayDialog, JoystickDialog, \
|
|
MachineDialog, PeripheralDialog, PathDialog, SoundDialog
|
|
|
|
|
|
# helper functions to match callback args
|
|
def window_hide_cb(window, arg):
|
|
window.hide()
|
|
return True
|
|
|
|
|
|
# ---------------------------------------------------------------
|
|
# Class with Hatari and configuration instances which methods are
|
|
# called to change those (with additional dialogs or directly).
|
|
# Owns the application window and socket widget embedding Hatari.
|
|
class UICallbacks:
|
|
tmpconfpath = os.path.expanduser("~/.hatari/.tmp.cfg")
|
|
def __init__(self):
|
|
# Hatari and configuration
|
|
self.hatari = Hatari()
|
|
error = self.hatari.is_compatible()
|
|
if error:
|
|
ErrorDialog(None).run(error)
|
|
sys.exit(-1)
|
|
|
|
self.config = HatariConfigMapping(self.hatari)
|
|
try:
|
|
self.config.validate()
|
|
except (KeyError, AttributeError):
|
|
NoteDialog(None).run("Loading Hatari configuration failed!\nRetrying after saving Hatari configuration.")
|
|
self.hatari.save_config()
|
|
self.config = HatariConfigMapping(self.hatari)
|
|
self.config.validate()
|
|
|
|
# windows are created when needed
|
|
self.mainwin = None
|
|
self.hatariwin = None
|
|
self.debugui = None
|
|
self.panels = {}
|
|
|
|
# dialogs are created when needed
|
|
self.aboutdialog = None
|
|
self.inputdialog = None
|
|
self.tracedialog = None
|
|
self.resetdialog = None
|
|
self.quitdialog = None
|
|
self.killdialog = None
|
|
|
|
self.floppydialog = None
|
|
self.harddiskdialog = None
|
|
self.displaydialog = None
|
|
self.joystickdialog = None
|
|
self.machinedialog = None
|
|
self.peripheraldialog = None
|
|
self.sounddialog = None
|
|
self.pathdialog = None
|
|
|
|
# used by run()
|
|
self.memstate = None
|
|
self.floppy = None
|
|
self.io_id = None
|
|
|
|
# TODO: Hatari UI own configuration settings save/load
|
|
self.tracepoints = None
|
|
|
|
def _reset_config_dialogs(self):
|
|
self.floppydialog = None
|
|
self.harddiskdialog = None
|
|
self.displaydialog = None
|
|
self.joystickdialog = None
|
|
self.machinedialog = None
|
|
self.peripheraldialog = None
|
|
self.sounddialog = None
|
|
self.pathdialog = None
|
|
|
|
# ---------- create UI ----------------
|
|
def create_ui(self, accelgroup, menu, toolbars, fullscreen, embed):
|
|
"create_ui(menu, toolbars, fullscreen, embed)"
|
|
# add horizontal elements
|
|
hbox = gtk.HBox()
|
|
if toolbars["left"]:
|
|
hbox.pack_start(toolbars["left"], False, True)
|
|
if embed:
|
|
self._add_uisocket(hbox)
|
|
if toolbars["right"]:
|
|
hbox.pack_start(toolbars["right"], False, True)
|
|
# add vertical elements
|
|
vbox = gtk.VBox()
|
|
if menu:
|
|
vbox.add(menu)
|
|
if toolbars["top"]:
|
|
vbox.pack_start(toolbars["top"], False, True)
|
|
vbox.add(hbox)
|
|
if toolbars["bottom"]:
|
|
vbox.pack_start(toolbars["bottom"], False, True)
|
|
# put them to main window
|
|
mainwin = gtk.Window(gtk.WINDOW_TOPLEVEL)
|
|
mainwin.set_title("%s %s" % (UInfo.name, UInfo.version))
|
|
mainwin.set_icon_from_file(UInfo.icon)
|
|
if accelgroup:
|
|
mainwin.add_accel_group(accelgroup)
|
|
if fullscreen:
|
|
mainwin.fullscreen()
|
|
mainwin.add(vbox)
|
|
mainwin.show_all()
|
|
# for run and quit callbacks
|
|
self.killdialog = KillDialog(mainwin)
|
|
mainwin.connect("delete_event", self.quit)
|
|
self.mainwin = mainwin
|
|
|
|
def _add_uisocket(self, box):
|
|
# add Hatari parent container to given box
|
|
socket = gtk.Socket()
|
|
# without this, closing Hatari would remove the socket widget
|
|
socket.connect("plug-removed", lambda obj: True)
|
|
socket.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("black"))
|
|
socket.set_events(gtk.gdk.ALL_EVENTS_MASK)
|
|
socket.set_flags(gtk.CAN_FOCUS)
|
|
# set max Hatari window size = desktop size
|
|
self.config.set_desktop_size(gtk.gdk.screen_width(), gtk.gdk.screen_height())
|
|
# set initial embedded hatari size
|
|
width, height = self.config.get_window_size()
|
|
socket.set_size_request(width, height)
|
|
# no resizing for the Hatari window
|
|
box.pack_start(socket, False, False)
|
|
self.hatariwin = socket
|
|
|
|
# ------- run callback -----------
|
|
def _socket_cb(self, fd, event):
|
|
if event != gobject.IO_IN:
|
|
# hatari process died, make sure Hatari instance notices
|
|
self.hatari.kill()
|
|
return False
|
|
width, height = self.hatari.get_embed_info()
|
|
print("New size = %d x %d" % (width, height))
|
|
oldwidth, oldheight = self.hatariwin.get_size_request()
|
|
self.hatariwin.set_size_request(width, height)
|
|
if width < oldwidth or height < oldheight:
|
|
# force also mainwin smaller (it automatically grows)
|
|
self.mainwin.resize(width, height)
|
|
return True
|
|
|
|
def run(self, widget = None):
|
|
if not self.killdialog.run(self.hatari):
|
|
return
|
|
if self.io_id:
|
|
gobject.source_remove(self.io_id)
|
|
args = ["--configfile"]
|
|
# whether to use Hatari config or unsaved Hatari UI config?
|
|
if self.config.is_changed():
|
|
args += [self.config.save_tmp(self.tmpconfpath)]
|
|
else:
|
|
args += [self.config.get_path()]
|
|
if self.memstate:
|
|
args += self.memstate
|
|
# only way to change boot order is to specify disk on command line
|
|
if self.floppy:
|
|
args += self.floppy
|
|
if self.hatariwin:
|
|
size = self.hatariwin.window.get_size()
|
|
self.hatari.run(args, self.hatariwin.window)
|
|
# get notifications of Hatari window size changes
|
|
self.hatari.enable_embed_info()
|
|
socket = self.hatari.get_control_socket().fileno()
|
|
events = gobject.IO_IN | gobject.IO_HUP | gobject.IO_ERR
|
|
self.io_id = gobject.io_add_watch(socket, events, self._socket_cb)
|
|
# all keyboard events should go to Hatari window
|
|
self.hatariwin.grab_focus()
|
|
else:
|
|
self.hatari.run(args)
|
|
|
|
def set_floppy(self, floppy):
|
|
self.floppy = floppy
|
|
|
|
# ------- quit callback -----------
|
|
def quit(self, widget, arg = None):
|
|
# due to Gtk API, needs to return True when *not* quitting
|
|
if not self.killdialog.run(self.hatari):
|
|
return True
|
|
if self.io_id:
|
|
gobject.source_remove(self.io_id)
|
|
if self.config.is_changed():
|
|
if not self.quitdialog:
|
|
self.quitdialog = QuitSaveDialog(self.mainwin)
|
|
if not self.quitdialog.run(self.config):
|
|
return True
|
|
gtk.main_quit()
|
|
if os.path.exists(self.tmpconfpath):
|
|
os.unlink(self.tmpconfpath)
|
|
# continue to mainwin destroy if called by delete_event
|
|
return False
|
|
|
|
# ------- pause callback -----------
|
|
def pause(self, widget):
|
|
if widget.get_active():
|
|
self.hatari.pause()
|
|
else:
|
|
self.hatari.unpause()
|
|
|
|
# dialogs
|
|
# ------- reset callback -----------
|
|
def reset(self, widget):
|
|
if not self.resetdialog:
|
|
self.resetdialog = ResetDialog(self.mainwin)
|
|
self.resetdialog.run(self.hatari)
|
|
|
|
# ------- about callback -----------
|
|
def about(self, widget):
|
|
if not self.aboutdialog:
|
|
self.aboutdialog = AboutDialog(self.mainwin)
|
|
self.aboutdialog.run()
|
|
|
|
# ------- input callback -----------
|
|
def inputs(self, widget):
|
|
if not self.inputdialog:
|
|
self.inputdialog = InputDialog(self.mainwin)
|
|
self.inputdialog.run(self.hatari)
|
|
|
|
# ------- floppydisk callback -----------
|
|
def floppydisk(self, widget):
|
|
if not self.floppydialog:
|
|
self.floppydialog = FloppyDialog(self.mainwin)
|
|
self.floppydialog.run(self.config)
|
|
|
|
# ------- harddisk callback -----------
|
|
def harddisk(self, widget):
|
|
if not self.harddiskdialog:
|
|
self.harddiskdialog = HardDiskDialog(self.mainwin)
|
|
self.harddiskdialog.run(self.config)
|
|
|
|
# ------- display callback -----------
|
|
def display(self, widget):
|
|
if not self.displaydialog:
|
|
self.displaydialog = DisplayDialog(self.mainwin)
|
|
self.displaydialog.run(self.config)
|
|
|
|
# ------- joystick callback -----------
|
|
def joystick(self, widget):
|
|
if not self.joystickdialog:
|
|
self.joystickdialog = JoystickDialog(self.mainwin)
|
|
self.joystickdialog.run(self.config)
|
|
|
|
# ------- machine callback -----------
|
|
def machine(self, widget):
|
|
if not self.machinedialog:
|
|
self.machinedialog = MachineDialog(self.mainwin)
|
|
if self.machinedialog.run(self.config):
|
|
self.hatari.trigger_shortcut("coldreset")
|
|
|
|
# ------- peripheral callback -----------
|
|
def peripheral(self, widget):
|
|
if not self.peripheraldialog:
|
|
self.peripheraldialog = PeripheralDialog(self.mainwin)
|
|
self.peripheraldialog.run(self.config)
|
|
|
|
# ------- sound callback -----------
|
|
def sound(self, widget):
|
|
if not self.sounddialog:
|
|
self.sounddialog = SoundDialog(self.mainwin)
|
|
self.sounddialog.run(self.config)
|
|
|
|
# ------- path callback -----------
|
|
def path(self, widget):
|
|
if not self.pathdialog:
|
|
self.pathdialog = PathDialog(self.mainwin)
|
|
self.pathdialog.run(self.config)
|
|
|
|
# ------- debug callback -----------
|
|
def debugger(self, widget):
|
|
if not self.debugui:
|
|
self.debugui = HatariDebugUI(self.hatari)
|
|
self.debugui.show()
|
|
|
|
# ------- trace callback -----------
|
|
def trace(self, widget):
|
|
if not self.tracedialog:
|
|
self.tracedialog = TraceDialog(self.mainwin)
|
|
self.tracepoints = self.tracedialog.run(self.hatari, self.tracepoints)
|
|
|
|
# ------ snapshot load/save callbacks ---------
|
|
def load(self, widget):
|
|
path = os.path.expanduser("~/.hatari/hatari.sav")
|
|
filename = get_open_filename("Select snapshot", self.mainwin, path)
|
|
if filename:
|
|
self.memstate = ["--memstate", filename]
|
|
self.run()
|
|
return True
|
|
return False
|
|
|
|
def save(self, widget):
|
|
self.hatari.trigger_shortcut("savemem")
|
|
|
|
# ------ config load/save callbacks ---------
|
|
def config_load(self, widget):
|
|
path = self.config.get_path()
|
|
filename = get_open_filename("Select configuration file", self.mainwin, path)
|
|
if filename:
|
|
self.hatari.change_option("--configfile %s" % filename)
|
|
self.config.load(filename)
|
|
self._reset_config_dialogs()
|
|
return True
|
|
return False
|
|
|
|
def config_save(self, widget):
|
|
path = self.config.get_path()
|
|
filename = get_save_filename("Save configuration as...", self.mainwin, path)
|
|
if filename:
|
|
self.config.save_as(filename)
|
|
return True
|
|
return False
|
|
|
|
# ------- fast forward callback -----------
|
|
def set_fastforward(self, widget):
|
|
self.config.set_fastforward(widget.get_active())
|
|
|
|
def get_fastforward(self):
|
|
return self.config.get_fastforward()
|
|
|
|
# ------- fullscreen callback -----------
|
|
def set_fullscreen(self, widget):
|
|
# if user can select this, Hatari isn't in fullscreen
|
|
self.hatari.change_option("--fullscreen")
|
|
|
|
# ------- screenshot callback -----------
|
|
def screenshot(self, widget):
|
|
self.hatari.trigger_shortcut("screenshot")
|
|
|
|
# ------- record callbacks -----------
|
|
def recanim(self, widget):
|
|
self.hatari.trigger_shortcut("recanim")
|
|
|
|
def recsound(self, widget):
|
|
self.hatari.trigger_shortcut("recsound")
|
|
|
|
# ------- insert key special callback -----------
|
|
def keypress(self, widget, code):
|
|
self.hatari.insert_event("keypress %s" % code)
|
|
|
|
def textinsert(self, widget, text):
|
|
HatariTextInsert(self.hatari, text)
|
|
|
|
# ------- panel callback -----------
|
|
def panel(self, action, box):
|
|
title = action.get_name()
|
|
if title not in self.panels:
|
|
window = gtk.Window(gtk.WINDOW_TOPLEVEL)
|
|
window.set_transient_for(self.mainwin)
|
|
window.set_icon_from_file(UInfo.icon)
|
|
window.set_title(title)
|
|
window.add(box)
|
|
window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DIALOG)
|
|
window.connect("delete_event", window_hide_cb)
|
|
self.panels[title] = window
|
|
else:
|
|
window = self.panels[title]
|
|
window.show_all()
|
|
window.deiconify()
|
|
|
|
|
|
# ---------------------------------------------------------------
|
|
# class for creating menus, toolbars and panels
|
|
# and managing actions bound to them
|
|
class UIActions:
|
|
def __init__(self):
|
|
cb = self.callbacks = UICallbacks()
|
|
|
|
self.help = UIHelp()
|
|
|
|
self.actions = gtk.ActionGroup("All")
|
|
|
|
# name, icon ID, label, accel, tooltip, callback
|
|
self.actions.add_toggle_actions((
|
|
# TODO: how to know when these are changed from inside Hatari?
|
|
("recanim", gtk.STOCK_MEDIA_RECORD, "Record animation", "<Ctrl>A", "Record animation", cb.recanim),
|
|
("recsound", gtk.STOCK_MEDIA_RECORD, "Record sound", "<Ctrl>W", "Record YM/Wav", cb.recsound),
|
|
("pause", gtk.STOCK_MEDIA_PAUSE, "Pause", "<Ctrl>P", "Pause Hatari to save battery", cb.pause),
|
|
("forward", gtk.STOCK_MEDIA_FORWARD, "Forward", "<Ctrl>F", "Whether to fast forward Hatari (needs fast machine)", cb.set_fastforward, cb.get_fastforward())
|
|
))
|
|
|
|
# name, icon ID, label, accel, tooltip, callback
|
|
self.actions.add_actions((
|
|
("load", gtk.STOCK_OPEN, "Load snapshot...", "<Ctrl>L", "Load emulation snapshot", cb.load),
|
|
("save", gtk.STOCK_SAVE, "Save snapshot", "<Ctrl>S", "Save emulation snapshot", cb.save),
|
|
("shot", gtk.STOCK_MEDIA_RECORD, "Grab screenshot", "<Ctrl>G", "Grab a screenshot", cb.screenshot),
|
|
("quit", gtk.STOCK_QUIT, "Quit", "<Ctrl>Q", "Quit Hatari UI", cb.quit),
|
|
|
|
("run", gtk.STOCK_MEDIA_PLAY, "Run", "<Ctrl>R", "(Re-)run Hatari", cb.run),
|
|
("full", gtk.STOCK_FULLSCREEN, "Fullscreen", "<Ctrl>U", "Toggle whether Hatari is fullscreen", cb.set_fullscreen),
|
|
("input", gtk.STOCK_SPELL_CHECK, "Inputs...", "<Ctrl>N", "Simulate text input and mouse clicks", cb.inputs),
|
|
("reset", gtk.STOCK_REFRESH, "Reset...", "<Ctrl>E", "Warm or cold reset Hatari", cb.reset),
|
|
|
|
("display", gtk.STOCK_PREFERENCES, "Display...", "<Ctrl>Y", "Display settings", cb.display),
|
|
("floppy", gtk.STOCK_FLOPPY, "Floppies...", "<Ctrl>D", "Floppy images", cb.floppydisk),
|
|
("harddisk", gtk.STOCK_HARDDISK, "Hard disks...", "<Ctrl>H", "Hard disk images and directories", cb.harddisk),
|
|
("joystick", gtk.STOCK_CONNECT, "Joysticks...", "<Ctrl>J", "Joystick settings", cb.joystick),
|
|
("machine", gtk.STOCK_HARDDISK, "Machine...", "<Ctrl>M", "Hatari st/e/tt/falcon configuration", cb.machine),
|
|
("device", gtk.STOCK_PRINT, "Peripherals...", "<Ctrl>V", "Toggle Midi, Printer, RS232 peripherals", cb.peripheral),
|
|
("sound", gtk.STOCK_PROPERTIES, "Sound...", "<Ctrl>O", "Sound settings", cb.sound),
|
|
|
|
("path", gtk.STOCK_DIRECTORY, "Paths...", None, "Device & save file paths", cb.path),
|
|
("lconfig", gtk.STOCK_OPEN, "Load config...", "<Ctrl>C", "Load configuration", self.config_load),
|
|
("sconfig", gtk.STOCK_SAVE_AS, "Save config as...", None, "Save configuration", cb.config_save),
|
|
|
|
("debug", gtk.STOCK_FIND, "Debugger...", "<Ctrl>B", "Activate Hatari debugger", cb.debugger),
|
|
("trace", gtk.STOCK_EXECUTE, "Trace settings...", "<Ctrl>T", "Hatari tracing setup", cb.trace),
|
|
|
|
("manual", None, "Hatari manual", None, None, self.help.view_hatari_manual),
|
|
("compatibility", None, "Hatari compatibility list", None, None, self.help.view_hatari_compatibility),
|
|
("release", None, "Hatari release notes", None, None, self.help.view_hatari_releasenotes),
|
|
("todo", None, "Hatari TODO", None, None, self.help.view_hatari_todo),
|
|
("mails", None, "Hatari mailing lists", None, None, self.help.view_hatari_mails),
|
|
("changes", None, "Latest Hatari changes", None, None, self.help.view_hatari_repository),
|
|
("authors", None, "Hatari authors", None, None, self.help.view_hatari_authors),
|
|
("hatari", None, "Hatari home page", None, None, self.help.view_hatari_page),
|
|
("hatariui", None, "Hatari UI home page", None, None, self.help.view_hatariui_page),
|
|
("about", gtk.STOCK_INFO, "Hatari UI info", "<Ctrl>I", "Hatari UI information", cb.about)
|
|
))
|
|
self.action_names = [x.get_name() for x in self.actions.list_actions()]
|
|
|
|
# no actions set yet to panels or toolbars
|
|
self.toolbars = {}
|
|
self.panels = []
|
|
|
|
def config_load(self, widget):
|
|
# user loads a new configuration?
|
|
if self.callbacks.config_load(widget):
|
|
print("TODO: reset toggle actions")
|
|
|
|
# ----- toolbar / panel additions ---------
|
|
def set_actions(self, action_str, place):
|
|
"set_actions(actions,place) -> error string, None if all OK"
|
|
actions = action_str.split(",")
|
|
for action in actions:
|
|
if action in self.action_names:
|
|
# regular action
|
|
continue
|
|
if action in self.panels:
|
|
# user specified panel
|
|
continue
|
|
if action in ("close", ">"):
|
|
if place != "panel":
|
|
return "'close' and '>' can be only in a panel"
|
|
continue
|
|
if action == "|":
|
|
# divider
|
|
continue
|
|
if action.find("=") >= 0:
|
|
# special keycode/string action
|
|
continue
|
|
return "unrecognized action '%s'" % action
|
|
|
|
if place in ("left", "right", "top", "bottom"):
|
|
self.toolbars[place] = actions
|
|
return None
|
|
if place == "panel":
|
|
if len(actions) < 3:
|
|
return "panel has too few items to be useful"
|
|
return None
|
|
return "unknown actions position '%s'" % place
|
|
|
|
def add_panel(self, spec):
|
|
"add_panel(panel_specification) -> error string, None if all is OK"
|
|
offset = spec.find(",")
|
|
if offset <= 0:
|
|
return "invalid panel specification '%s'" % spec
|
|
|
|
name, panelcontrols = spec[:offset], spec[offset+1:]
|
|
error = self.set_actions(panelcontrols, "panel")
|
|
if error:
|
|
return error
|
|
|
|
if ",>," in panelcontrols:
|
|
box = gtk.VBox()
|
|
splitcontrols = panelcontrols.split(",>,")
|
|
for controls in splitcontrols:
|
|
box.add(self._get_container(controls.split(",")))
|
|
else:
|
|
box = self._get_container(panelcontrols.split(","))
|
|
|
|
self.panels.append(name)
|
|
self.actions.add_actions(
|
|
((name, gtk.STOCK_ADD, name, None, name, self.callbacks.panel),),
|
|
box
|
|
)
|
|
return None
|
|
|
|
def list_actions(self):
|
|
yield ("|", "Separator between controls")
|
|
yield (">", "Start next toolbar row in panel windows")
|
|
# generate the list from action information
|
|
for act in self.actions.list_actions():
|
|
note = act.get_property("tooltip")
|
|
if not note:
|
|
note = act.get_property("label")
|
|
yield(act.get_name(), note)
|
|
yield ("<panel name>", "Button for the specified panel window")
|
|
yield ("<name>=<string/code>", "Synthetize string or single key <code>")
|
|
|
|
# ------- panel special actions -----------
|
|
def _close_cb(self, widget):
|
|
widget.get_toplevel().hide()
|
|
|
|
# ------- key special action -----------
|
|
def _create_key_control(self, name, textcode):
|
|
"Simulate Atari key press/release and string inserting"
|
|
if not textcode:
|
|
return None
|
|
widget = gtk.ToolButton(gtk.STOCK_PASTE)
|
|
widget.set_label(name)
|
|
try:
|
|
# part after "=" converts to an int?
|
|
code = int(textcode, 0)
|
|
widget.connect("clicked", self.callbacks.keypress, code)
|
|
tip = "keycode: %d" % code
|
|
except ValueError:
|
|
# no, assume a string macro is wanted instead
|
|
widget.connect("clicked", self.callbacks.textinsert, textcode)
|
|
tip = "string '%s'" % textcode
|
|
widget.set_tooltip_text("Insert " + tip)
|
|
return widget
|
|
|
|
def _get_container(self, actions, horiz = True):
|
|
"return Gtk container with the specified actions or None for no actions"
|
|
if not actions:
|
|
return None
|
|
|
|
#print("ACTIONS:", actions)
|
|
if len(actions) > 1:
|
|
bar = gtk.Toolbar()
|
|
if horiz:
|
|
bar.set_orientation(gtk.ORIENTATION_HORIZONTAL)
|
|
else:
|
|
bar.set_orientation(gtk.ORIENTATION_VERTICAL)
|
|
bar.set_style(gtk.TOOLBAR_BOTH)
|
|
# disable overflow menu to get toolbar sized correctly for panels
|
|
bar.set_show_arrow(False)
|
|
else:
|
|
bar = None
|
|
|
|
for action in actions:
|
|
#print(action)
|
|
offset = action.find("=")
|
|
if offset >= 0:
|
|
# handle "<name>=<keycode>" action specification
|
|
name = action[:offset]
|
|
text = action[offset+1:]
|
|
widget = self._create_key_control(name, text)
|
|
elif action == "|":
|
|
widget = gtk.SeparatorToolItem()
|
|
elif action == "close":
|
|
if bar:
|
|
widget = create_toolbutton(gtk.STOCK_CLOSE, self._close_cb)
|
|
else:
|
|
widget = create_button("Close", self._close_cb)
|
|
else:
|
|
widget = self.actions.get_action(action).create_tool_item()
|
|
if not widget:
|
|
continue
|
|
if bar:
|
|
if action != "|":
|
|
widget.set_expand(True)
|
|
bar.insert(widget, -1)
|
|
if bar:
|
|
return bar
|
|
return widget
|
|
|
|
# ------------- handling menu -------------
|
|
def _add_submenu(self, bar, title, items):
|
|
submenu = gtk.Menu()
|
|
for name in items:
|
|
if name:
|
|
action = self.actions.get_action(name)
|
|
item = action.create_menu_item()
|
|
else:
|
|
item = gtk.SeparatorMenuItem()
|
|
submenu.add(item)
|
|
baritem = gtk.MenuItem(title, False)
|
|
baritem.set_submenu(submenu)
|
|
bar.add(baritem)
|
|
|
|
def _get_menu(self):
|
|
allmenus = (
|
|
("File", ("load", "save", None, "shot", "recanim", "recsound", None, "quit")),
|
|
("Emulation", ("run", "pause", "forward", None, "full", None, "input", None, "reset")),
|
|
("Devices", ("display", "floppy", "harddisk", "joystick", "machine", "device", "sound")),
|
|
("Configuration", ("path", None, "lconfig", "sconfig")),
|
|
("Debug", ("debug", "trace")),
|
|
("Help", ("manual", "compatibility", "release", "todo", None, "mails", "changes", None, "authors", "hatari", "hatariui", "about",))
|
|
)
|
|
bar = gtk.MenuBar()
|
|
|
|
for title, items in allmenus:
|
|
self._add_submenu(bar, title, items)
|
|
|
|
if self.panels:
|
|
self._add_submenu(bar, "Panels", self.panels)
|
|
|
|
return bar
|
|
|
|
# ------------- run the whole UI -------------
|
|
def run(self, floppy, havemenu, fullscreen, embed):
|
|
accelgroup = None
|
|
# create menu?
|
|
if havemenu:
|
|
# this would steal keys from embedded Hatari
|
|
if not embed:
|
|
accelgroup = gtk.AccelGroup()
|
|
for action in self.actions.list_actions():
|
|
action.set_accel_group(accelgroup)
|
|
menu = self._get_menu()
|
|
else:
|
|
menu = None
|
|
|
|
# create toolbars
|
|
toolbars = { "left":None, "right":None, "top":None, "bottom":None}
|
|
for side in ("left", "right"):
|
|
if side in self.toolbars:
|
|
toolbars[side] = self._get_container(self.toolbars[side], False)
|
|
for side in ("top", "bottom"):
|
|
if side in self.toolbars:
|
|
toolbars[side] = self._get_container(self.toolbars[side], True)
|
|
|
|
self.callbacks.create_ui(accelgroup, menu, toolbars, fullscreen, embed)
|
|
self.help.set_mainwin(self.callbacks.mainwin)
|
|
self.callbacks.set_floppy(floppy)
|
|
|
|
# ugly, Hatari socket window ID can be gotten only
|
|
# after Socket window is realized by gtk_main()
|
|
gobject.idle_add(self.callbacks.run)
|
|
gtk.main()
|
|
|
|
|
|
# ------------- usage / argument handling --------------
|
|
def usage(actions, msg=None):
|
|
name = os.path.basename(sys.argv[0])
|
|
uiname = "%s %s" % (UInfo.name, UInfo.version)
|
|
print("\n%s" % uiname)
|
|
print("=" * len(uiname))
|
|
print("\nUsage: %s [options] [directory|disk image|Atari program]" % name)
|
|
print("\nOptions:")
|
|
print("\t-h, --help\t\tthis help")
|
|
print("\t-n, --nomenu\t\tomit menus")
|
|
print("\t-e, --embed\t\tembed Hatari window in middle of controls")
|
|
print("\t-f, --fullscreen\tstart in fullscreen")
|
|
print("\t-l, --left <controls>\ttoolbar at left")
|
|
print("\t-r, --right <controls>\ttoolbar at right")
|
|
print("\t-t, --top <controls>\ttoolbar at top")
|
|
print("\t-b, --bottom <controls>\ttoolbar at bottom")
|
|
print("\t-p, --panel <name>,<controls>")
|
|
print("\t\t\t\tseparate window with given name and controls")
|
|
print("\nAvailable (panel/toolbar) controls:")
|
|
for action, description in actions.list_actions():
|
|
size = len(action)
|
|
if size < 8:
|
|
tabs = "\t\t"
|
|
elif size < 16:
|
|
tabs = "\t"
|
|
else:
|
|
tabs = "\n\t\t\t"
|
|
print("\t%s%s%s" % (action, tabs, description))
|
|
print("""
|
|
You can have as many panels as you wish. For each panel you need to add
|
|
a control with the name of the panel (see "MyPanel" below).
|
|
|
|
For example:
|
|
\t%s --embed \\
|
|
\t-t "about,run,pause,quit" \\
|
|
\t-p "MyPanel,Macro=Test,Undo=97,Help=98,>,F1=59,F2=60,F3=61,F4=62,>,close" \\
|
|
\t-r "paste,debug,trace,machine,MyPanel" \\
|
|
\t-b "sound,|,fastforward,|,fullscreen"
|
|
|
|
if no options are given, the UI uses basic controls.
|
|
""" % name)
|
|
if msg:
|
|
print("ERROR: %s\n" % msg)
|
|
sys.exit(1)
|
|
|
|
|
|
def main():
|
|
info = UInfo()
|
|
actions = UIActions()
|
|
try:
|
|
longopts = ["embed", "fullscreen", "nomenu", "help",
|
|
"left=", "right=", "top=", "bottom=", "panel="]
|
|
opts, floppies = getopt.getopt(sys.argv[1:], "efnhl:r:t:b:p:", longopts)
|
|
del longopts
|
|
except getopt.GetoptError as err:
|
|
usage(actions, err)
|
|
|
|
menu = True
|
|
embed = False
|
|
fullscreen = False
|
|
|
|
error = None
|
|
for opt, arg in opts:
|
|
print(opt, arg)
|
|
if opt in ("-e", "--embed"):
|
|
embed = True
|
|
elif opt in ("-f", "--fullscreen"):
|
|
fullscreen = True
|
|
elif opt in ("-n", "--nomenu"):
|
|
menu = False
|
|
elif opt in ("-h", "--help"):
|
|
usage(actions)
|
|
elif opt in ("-l", "--left"):
|
|
error = actions.set_actions(arg, "left")
|
|
elif opt in ("-r", "--right"):
|
|
error = actions.set_actions(arg, "right")
|
|
elif opt in ("-t", "--top"):
|
|
error = actions.set_actions(arg, "top")
|
|
elif opt in ("-b", "--bottom"):
|
|
error = actions.set_actions(arg, "bottom")
|
|
elif opt in ("-p", "--panel"):
|
|
error = actions.add_panel(arg)
|
|
else:
|
|
assert False, "getopt returned unhandled option"
|
|
if error:
|
|
usage(actions, error)
|
|
|
|
if len(floppies) > 1:
|
|
usage(actions, "multiple floppy images given: %s" % str(floppies))
|
|
if floppies:
|
|
if not os.path.exists(floppies[0]):
|
|
usage(actions, "floppy image '%s' doesn't exist" % floppies[0])
|
|
|
|
actions.run(floppies, menu, fullscreen, embed)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|