![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hatari.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 hatari.py CVS log | Up to [HATARI the Atari ST Emulator] / hatari / python-ui |
1.1 root 1: #!/usr/bin/env python
2: #
3: # Classes for Hatari emulator instance and mapping its congfiguration
4: # variables with its command line option.
5: #
6: # Copyright (C) 2008 by Eero Tamminen <[email protected]>
7: #
8: # This program is free software; you can redistribute it and/or modify
9: # it under the terms of the GNU General Public License as published by
10: # the Free Software Foundation; either version 2 of the License, or
11: # (at your option) any later version.
12: #
13: # This program is distributed in the hope that it will be useful,
14: # but WITHOUT ANY WARRANTY; without even the implied warranty of
15: # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16: # GNU General Public License for more details.
17:
18: import os
19: import sys
20: import time
21: import signal
22: import socket
23: import select
24: from config import ConfigStore
25:
26:
27: # Running Hatari instance
28: class Hatari:
29: "running hatari instance and methods for communicating with it"
30: basepath = "/tmp/hatari-ui-" + str(os.getpid())
31: logpath = basepath + ".log"
32: tracepath = basepath + ".trace"
33: debugpath = basepath + ".debug"
34: controlpath = basepath + ".socket"
35: server = None # singleton due to path being currently one per user
36:
37: def __init__(self, hataribin = None):
38: # collect hatari process zombies without waitpid()
39: signal.signal(signal.SIGCHLD, signal.SIG_IGN)
40: if hataribin:
41: self.hataribin = hataribin
42: else:
43: self.hataribin = "hatari"
44: self._assert_hatari_compatibility()
45: self._create_server()
46: self.control = None
47: self.paused = False
48: self.pid = 0
49:
50: def _assert_hatari_compatibility(self):
51: for line in os.popen(self.hataribin + " -h").readlines():
52: if line.find("--control-socket") >= 0:
53: return
54: print "ERROR: Hatari not found or it doesn't support the required --control-socket option!"
55: sys.exit(-1)
56:
57: def _create_server(self):
58: if self.server:
59: return
60: self.server = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
61: if os.path.exists(self.controlpath):
62: os.unlink(self.controlpath)
63: self.server.bind(self.controlpath)
64: self.server.listen(1)
65:
66: def _send_message(self, msg):
67: if self.control:
68: self.control.send(msg)
69: return True
70: else:
71: print "ERROR: no Hatari (control socket)"
72: return False
73:
74: def change_option(self, option):
75: "change_option(option), changes given Hatari cli option"
76: return self._send_message("hatari-option %s\n" % option)
77:
78: def set_path(self, key, path):
79: "set_path(key, path), sets path with given key"
80: return self._send_message("hatari-path %s %s\n" % (key, path))
81:
82: def set_device(self, device, enabled):
83: # needed because CLI options cannot disable devices, only enable
84: "set_path(device, enabled), sets whether given device is enabled or not"
85: if enabled:
86: return self._send_message("hatari-enable %s\n" % device)
87: else:
88: return self._send_message("hatari-disable %s\n" % device)
89:
90: def trigger_shortcut(self, shortcut):
91: "trigger_shortcut(shortcut), triggers given Hatari (keyboard) shortcut"
92: return self._send_message("hatari-shortcut %s\n" % shortcut)
93:
94: def insert_event(self, event):
95: "insert_event(event), synthetizes given key/mouse Atari event"
96: return self._send_message("hatari-event %s\n" % event)
97:
98: def debug_command(self, cmd):
99: "debug_command(command), runs given Hatari debugger command"
100: return self._send_message("hatari-debug %s\n" % cmd)
101:
102: def pause(self):
103: "pause(), pauses Hatari emulation"
104: return self._send_message("hatari-stop\n")
105:
106: def unpause(self):
107: "unpause(), continues Hatari emulation"
108: return self._send_message("hatari-cont\n")
109:
110: def _open_output_file(self, hataricommand, option, path):
111: if os.path.exists(path):
112: os.unlink(path)
113: # TODO: why fifo doesn't work properly (blocks forever on read or
114: # reads only byte at the time and stops after first newline)?
115: #os.mkfifo(path)
116: #raw_input("attach strace now, then press Enter\n")
117:
118: # ask Hatari to open/create the requested output file...
119: hataricommand("%s %s" % (option, path))
120: wait = 0.025
121: # ...and wait for it to appear before returning it
122: for i in range(0, 8):
123: time.sleep(wait)
124: if os.path.exists(path):
125: return open(path, "r")
126: wait += wait
127: return None
128:
129: def open_debug_output(self):
130: "open_debug_output() -> file, opens Hatari debugger output file"
131: return self._open_output_file(self.debug_command, "f", self.debugpath)
132:
133: def open_trace_output(self):
134: "open_trace_output() -> file, opens Hatari tracing output file"
135: return self._open_output_file(self.change_option, "--trace-file", self.tracepath)
136:
137: def open_log_output(self):
138: "open_trace_output() -> file, opens Hatari debug log file"
139: return self._open_output_file(self.change_option, "--log-file", self.logpath)
140:
141: def get_lines(self, fileobj):
142: "get_lines(file) -> list of lines readable from given Hatari output file"
143: # wait until data is available, then wait for some more
144: # and only then the data can be read, otherwise its old
145: print "Request&wait data from Hatari..."
146: select.select([fileobj], [], [])
147: time.sleep(0.1)
148: print "...read the data lines"
149: lines = fileobj.readlines()
150: print "".join(lines)
151: return lines
152:
153: def enable_embed_info(self):
154: "enable_embed_info(), request embedded Hatari window ID change information"
155: self._send_message("hatari-embed-info\n")
156:
157: def get_embed_info(self):
158: "get_embed_info() -> (width, height), get embedded Hatari window size"
159: width, height = self.control.recv(12).split("x")
160: return (int(width), int(height))
161:
162: def get_control_socket(self):
163: "get_control_socket() -> socket which can be checked for embed ID changes"
164: return self.control
165:
166: def is_running(self):
167: "is_running() -> bool, True if Hatari is running, False otherwise"
168: if not self.pid:
169: return False
170: try:
171: os.waitpid(self.pid, os.WNOHANG)
172: except OSError, value:
173: print "Hatari PID %d had exited in the meanwhile:\n\t%s" % (self.pid, value)
174: self.pid = 0
175: return False
176: return True
177:
178: def run(self, extra_args = None, parent_win = None):
179: "run([parent window][,embedding args]), runs Hatari"
180: # if parent_win given, embed Hatari to it
181: pid = os.fork()
182: if pid < 0:
183: print "ERROR: fork()ing Hatari failed!"
184: return
185: if pid:
186: # in parent
187: self.pid = pid
188: if self.server:
189: print "WAIT hatari to connect to control socket...",
190: (self.control, addr) = self.server.accept()
191: print "connected!"
192: else:
193: # child runs Hatari
194: env = os.environ
195: if parent_win:
196: self._set_embed_env(env, parent_win)
197: # callers need to take care of confirming quitting
198: args = [self.hataribin, "--confirm-quit", "off"]
199: if self.server:
200: args += ["--control-socket", self.controlpath]
201: if extra_args:
202: args += extra_args
203: print "RUN:", args
204: os.execvpe(self.hataribin, args, env)
205:
206: def _set_embed_env(self, env, parent_win):
207: if sys.platform == 'win32':
208: win_id = parent_win.handle
209: else:
210: win_id = parent_win.xid
211: # tell SDL to use given widget's window
212: #env["SDL_WINDOWID"] = str(win_id)
213:
214: # above is broken: when SDL uses a window it hasn't created itself,
215: # it for some reason doesn't listen to any events delivered to that
216: # window nor implements XEMBED protocol to get them in a way most
217: # friendly to embedder:
218: # http://standards.freedesktop.org/xembed-spec/latest/
219: #
220: # Instead we tell hatari to reparent itself after creating
221: # its own window into this program widget window
222: env["PARENT_WIN_ID"] = str(win_id)
223:
224: def kill(self):
225: "kill(), kill Hatari if it's running"
226: if self.pid:
227: os.kill(self.pid, signal.SIGKILL)
228: print "killed hatari with PID %d" % self.pid
229: self.pid = 0
230: if self.control:
231: self.control.close()
232: self.control = None
233:
234:
235: # Mapping of requested values both to Hatari configuration
236: # and command line options.
237: #
238: # By default this doesn't allow setting any other configuration
239: # variables than the ones that were read from the configuration
240: # file i.e. you get an exception if configuration variables
241: # don't match to current Hatari. So before using this you should
242: # have saved Hatari configuration at least once.
243: #
244: # Because of some inconsistencies in the values (see e.g. sound),
245: # this cannot just do these according to some mapping table, but
246: # it needs actual method for (each) setting.
247: class HatariConfigMapping(ConfigStore):
248: _paths = {
249: "memauto": ("[Memory]", "szAutoSaveFileName", "Automatic memory snapshot"),
250: "memsave": ("[Memory]", "szMemoryCaptureFileName", "Manual memory snapshot"),
251: "midiin": ("[Midi]", "sMidiInFileName", "Midi input"),
252: "midiout": ("[Midi]", "sMidiOutFileName", "Midi output"),
253: "rs232in": ("[RS232]", "szInFileName", "RS232 I/O input"),
254: "rs232out": ("[RS232]", "szOutFileName", "RS232 I/O output"),
255: "printout": ("[Printer]", "szPrintToFileName", "Printer output"),
256: "soundout": ("[Sound]", "szYMCaptureFileName", "Sound output")
257: }
258: "access methods to Hatari configuration file variables and command line options"
259: def __init__(self, hatari):
260: ConfigStore.__init__(self, "hatari.cfg")
261: self._hatari = hatari
262: self._lock_updates = False
263: self._options = []
264:
265: def _change_option(self, option):
266: if self._lock_updates:
267: self._options.append(option)
268: else:
269: self._hatari.change_option(option)
270:
271: def lock_updates(self):
272: "lock_updates(), collect Hatari configuration changes"
273: self._lock_updates = True
274:
275: def flush_updates(self):
276: "flush_updates(), apply collected Hatari configuration changes"
277: self._lock_updates = False
278: if not self._options:
279: return
280: self._hatari.change_option(" ".join(self._options))
281: self._options = []
282:
283: # ------------ paths ---------------
284: def get_paths(self):
285: paths = []
286: for key, item in self._paths.items():
287: paths.append((key, self.get(item[0], item[1]), item[2]))
288: return paths
289:
290: def set_paths(self, paths):
291: for key, path in paths:
292: self.set(self._paths[key][0], self._paths[key][1], path)
293: self._hatari.set_path(key, path)
294:
295: # ------------ midi ---------------
296: def get_midi(self):
297: return self.get("[Midi]", "bEnableMidi")
298:
299: def set_midi(self, value):
300: self.set("[Midi]", "bEnableMidi", value)
301: self._hatari.set_device("midi", value)
302:
303: # ------------ printer ---------------
304: def get_printer(self):
305: return self.get("[Printer]", "bEnablePrinting")
306:
307: def set_printer(self, value):
308: self.set("[Printer]", "bEnablePrinting", value)
309: self._hatari.set_device("printer", value)
310:
311: # ------------ RS232 ---------------
312: def get_rs232(self):
313: return self.get("[RS232]", "bEnableRS232")
314:
315: def set_rs232(self, value):
316: self.set("[RS232]", "bEnableRS232", value)
317: self._hatari.set_device("rs232", value)
318:
319: # ------------ machine ---------------
320: def get_machine_types(self):
321: return ("ST", "STE", "TT", "Falcon")
322:
323: def get_machine(self):
324: return self.get("[System]", "nMachineType")
325:
326: def set_machine(self, value):
327: self.set("[System]", "nMachineType", value)
328: self._change_option("--machine %s" % ("st", "ste", "tt", "falcon")[value])
329:
330: # ------------ compatible ---------------
331: def get_compatible(self):
332: return self.get("[System]", "bCompatibleCpu")
333:
334: def set_compatible(self, value):
335: self.set("[System]", "bCompatibleCpu", value)
336: self._change_option("--compatible %s" % str(value))
337:
338: # ------------ Timer-D ---------------
339: def get_timerd(self):
340: return self.get("[System]", "bPatchTimerD")
341:
342: def set_timerd(self, value):
343: self.set("[System]", "bPatchTimerD", value)
344: self._change_option("--timer-d %s" % str(value))
345:
346: # ------------ fastforward ---------------
347: def get_fastforward(self):
348: return self.get("[System]", "bFastForward")
349:
350: def set_fastforward(self, value):
351: self.set("[System]", "bFastForward", value)
352: self._change_option("--fast-forward %s" % str(value))
353:
354: # ------------ sound ---------------
355: def get_sound_values(self):
356: # 48kHz, 44.1kHz and STE/TT/Falcon DMA 50066Hz divisable values
357: return ("6000", "6258", "8000", "11025", "12000", "12517",
358: "16000", "22050", "24000", "25033", "32000",
359: "48000", "44100", "50066")
360:
361: def get_sound(self):
362: enabled = self.get("[Sound]", "bEnableSound")
363: hz = str(self.get("[Sound]", "nPlaybackFreq"))
364: return (enabled, hz)
365:
366: def set_sound(self, enabled, hz):
367: # map get_sound_values() index to Hatari config
368: try:
369: hz = int(hz)
370: except ValueError:
371: hz = 0
372: if hz < 6000 or hz > 50066:
373: hz = 44100
374: self.set("[Sound]", "nPlaybackFreq", hz)
375: self.set("[Sound]", "bEnableSound", enabled)
376: value = str(hz)
377: # and to cli option
378: if enabled:
379: self._change_option("--sound %s" % value)
380: else:
381: self._change_option("--sound off")
382: return value
383:
384:
385: # ----------- joystick --------------
386: def get_joystick_types(self):
387: return ("Disabled", "Real joystick", "Keyboard")
388:
389: def get_joystick_names(self):
390: return (
391: "ST Joystick 0",
392: "ST Joystick 1",
393: "STE Joypad A",
394: "STE Joypad B",
395: "Parport stick 1",
396: "Parport stick 2"
397: )
398:
399: def get_joystick(self, port):
400: # return index to get_joystick_values() array
401: return self.get("[Joystick%d]" % port, "nJoystickMode")
402:
403: def set_joystick(self, port, value):
404: # map get_sound_values() index to Hatari config
405: self.set("[Joystick%d]" % port, "nJoystickMode", value)
406: joytype = ("none", "real", "keys")[value]
407: self._change_option("--joy%d %s" % (port, joytype))
408:
409: # ------------ floppy image dir ---------------
410: def get_floppydir(self):
411: return self.get("[Floppy]", "szDiskImageDirectory")
412:
413: def set_floppydir(self, path):
414: return self.set("[Floppy]", "szDiskImageDirectory", path)
415:
416: # ------------ floppy disk images ---------------
417: def get_floppy(self, drive):
418: return self.get("[Floppy]", "szDisk%cFileName" % ("A", "B")[drive])
419:
420: def set_floppy(self, drive, filename):
421: self.set("[Floppy]", "szDisk%cFileName" % ("A", "B")[drive], filename)
422: self._change_option("--disk-%c %s" % (("a", "b")[drive], filename))
423:
424: # ------------ use harddisk ---------------
425: def get_use_harddisk(self):
426: return self.get("[HardDisk]", "bUseHardDiskDirectory")
427:
428: def set_use_harddisk(self, value):
429: self.set("[HardDisk]", "bUseHardDiskDirectory", value)
430: # TODO: add to hatari option for this
431:
432: # ------------ harddisk (dir) ---------------
433: def get_harddisk(self):
434: return self.get("[HardDisk]", "szHardDiskDirectory")
435:
436: def set_harddisk(self, dirname):
437: self.set("[HardDisk]", "szHardDiskDirectory", dirname)
438: if self.get_use_harddisk():
439: self._change_option("--harddrive %s" % dirname)
440:
441: # ------------ TOS ROM ---------------
442: def get_tos(self):
443: return self.get("[ROM]", "szTosImageFileName")
444:
445: def set_tos(self, filename):
446: self.set("[ROM]", "szTosImageFileName", filename)
447: self._change_option("--tos %s" % filename)
448:
449: # ------------ memory ---------------
450: def get_memory_names(self):
451: # empty item in list shouldn't be shown, filter them out
452: return ("512kB", "1MB", "2MB", "4MB", "8MB", "14MB")
453:
454: def get_memory(self):
455: "return index to what get_memory_names() returns"
456: sizemap = (0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 5)
457: memsize = self.get("[Memory]", "nMemorySize")
458: if memsize >= 0 and memsize < len(sizemap):
459: return sizemap[memsize]
460: return 1 # default = 1BM
461:
462: def set_memory(self, idx):
463: # map memory item index to memory size
464: sizemap = (0, 1, 2, 4, 8, 14)
465: if idx >= 0 and idx < len(sizemap):
466: memsize = sizemap[idx]
467: else:
468: memsize = 1
469: self.set("[Memory]", "nMemorySize", memsize)
470: self._change_option("--memsize %d" % memsize)
471:
472: # ------------ monitor ---------------
473: def get_monitor_types(self):
474: return ("Mono", "RGB", "VGA", "TV")
475:
476: def get_monitor(self):
477: return self.get("[Screen]", "nMonitorType")
478:
479: def set_monitor(self, value):
480: self.set("[Screen]", "nMonitorType", value)
481: self._change_option("--monitor %s" % ("mono", "rgb", "vga", "tv")[value])
482:
483: # ------------ frameskip ---------------
484: def get_frameskip_names(self):
485: return (
486: "Disabled",
487: "1 frame",
488: "2 frames",
489: "3 frames",
490: "4 frames",
491: "Automatic"
492: )
493:
494: def get_frameskip(self):
495: fs = self.get("[Screen]", "nFrameSkips")
496: print "Frameskip", fs
497: if fs < 0 or fs > 5:
498: return 5
499: return fs
500:
501: def set_frameskip(self, value):
502: value = int(value) # guarantee correct type
503: self.set("[Screen]", "nFrameSkips", value)
504: self._change_option("--frameskips %d" % value)
505:
506: # ------------ spec512 ---------------
507: def get_spec512threshold(self):
508: return self.get("[Screen]", "nSpec512Threshold")
509:
510: def set_spec512threshold(self, value):
511: value = int(value) # guarantee correct type
512: self.set("[Screen]", "nSpec512Threshold", value)
513: self._change_option("--spec512 %d" % value)
514:
515: # ------------ show borders ---------------
516: def get_borders(self):
517: return self.get("[Screen]", "bAllowOverscan")
518:
519: def set_borders(self, value):
520: self.set("[Screen]", "bAllowOverscan", value)
521: self._change_option("--borders %s" % str(value))
522:
523: # ------------ show statusbar ---------------
524: def get_statusbar(self):
525: return self.get("[Screen]", "bShowStatusbar")
526:
527: def set_statusbar(self, value):
528: self.set("[Screen]", "bShowStatusbar", value)
529: self._change_option("--statusbar %s" % str(value))
530:
531: # ------------ show led ---------------
532: def get_led(self):
533: return self.get("[Screen]", "bShowDriveLed")
534:
535: def set_led(self, value):
536: self.set("[Screen]", "bShowDriveLed", value)
537: self._change_option("--drive-led %s" % str(value))
538:
539: # ------------ use zoom ---------------
540: def get_zoom(self):
541: return self.get("[Screen]", "bZoomLowRes")
542:
543: def set_zoom(self, value):
544: self.set("[Screen]", "bZoomLowRes", value)
545: if value:
546: zoom = 2
547: else:
548: zoom = 1
549: self._change_option("--zoom %d" % zoom)
550:
551: # ------------ configured Hatari window size ---------------
552: def get_window_size(self):
553: if self.get("[Screen]", "bFullScreen"):
554: print "WARNING: don't start Hatari UI with fullscreened Hatari!"
555:
556: # VDI resolution?
557: if self.get("[Screen]", "bUseExtVdiResolutions"):
558: width = self.get("[Screen]", "nVdiWidth")
559: height = self.get("[Screen]", "nVdiHeight")
560: return (width, height)
561:
562: # window sizes for other than ST & STE can differ
563: if self.get("[System]", "nMachineType") not in (0, 1):
564: print "WARNING: neither ST nor STE machine, window size inaccurate!"
565:
566: # mono monitor?
567: if self.get("[Screen]", "nMonitorType") == 0:
568: return (640, 400)
569:
570: # no, color
571: width = 320
572: height = 200
573: # add overscan borders?
574: if self.get("[Screen]", "bAllowOverscan"):
575: # max size with overscan borders
576: width += self.get("[Screen]", "nWindowBorderPixelsLeft")
577: width += self.get("[Screen]", "nWindowBorderPixelsRight")
578: height = 29 + 200 + self.get("[Screen]", "nWindowBorderPixelsBottom")
579: # statusbar?
580: if self.get("[Screen]", "bShowStatusbar"):
581: height += 10
582: # zoomed?
583: if self.get("[Screen]", "bZoomLowRes"):
584: width *= 2
585: height *= 2
586:
587: return (width, height)
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.