org/jpc/plugins/PCControl.java

   1 /*
   2     JPC-RR: A x86 PC Hardware Emulator
   3     Release 1
   4
   5     Copyright (C) 2007-2009 Isis Innovation Limited
   6     Copyright (C) 2009-2010 H. Ilari Liusvaara
   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 version 2 as published by
  10     the Free Software Foundation.
  11
  12     This program is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15     GNU General Public License for more details.
  16
  17     You should have received a copy of the GNU General Public License along
  18     with this program; if not, write to the Free Software Foundation, Inc.,
  19     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20
  21     Based on JPC x86 PC Hardware emulator,
  22     A project from the Physics Dept, The University of Oxford
  23
  24     Details about original JPC can be found at:
  25
  26     www-jpc.physics.ox.ac.uk
  27
  28 */
  29
  30 package org.jpc.plugins;
  31
  32 import java.awt.Dimension;
  33 import java.io.*;
  34 import java.util.*;
  35 import java.lang.reflect.*;
  36 import java.security.AccessControlException;
  37 import javax.swing.*;
  38 import java.awt.dnd.*;
  39 import java.awt.datatransfer.*;
  40 import javax.swing.border.EtchedBorder;
  41
  42 import org.jpc.emulator.HardwareComponent;
  43 import org.jpc.emulator.PC;
  44 import org.jpc.emulator.EventRecorder;
  45 import org.jpc.emulator.TraceTrap;
  46 import org.jpc.emulator.DriveSet;
  47 import org.jpc.emulator.DisplayController;
  48 import org.jpc.emulator.memory.PhysicalAddressSpace;
  49 import org.jpc.emulator.StatusDumper;
  50 import org.jpc.emulator.Clock;
  51 import org.jpc.emulator.VGADigitalOut;
  52 import org.jpc.diskimages.BlockDevice;
  53 import org.jpc.diskimages.DiskImageSet;
  54 import org.jpc.diskimages.DiskImage;
  55 import org.jpc.plugins.RAWDumper;
  56 import org.jpc.pluginsaux.PleaseWait;
  57 import org.jpc.pluginsaux.AsyncGUITask;
  58 import org.jpc.pluginsaux.NewDiskDialog;
  59 import org.jpc.pluginsaux.AuthorsDialog;
  60 import org.jpc.pluginsaux.PCConfigDialog;
  61 import org.jpc.pluginsaux.MenuManager;
  62 import org.jpc.pluginsaux.PCMonitorPanel;
  63 import org.jpc.pluginsaux.PCMonitorPanelEmbedder;
  64 import org.jpc.pluginsaux.ImportDiskImage;
  65 import org.jpc.Misc;
  66 import org.jpc.pluginsbase.*;
  67 import org.jpc.jrsr.*;
  68
  69 import static org.jpc.Misc.randomHexes;
  70 import static org.jpc.Misc.errorDialog;
  71 import static org.jpc.Misc.callShowOptionDialog;
  72 import static org.jpc.Misc.moveWindow;
  73 import static org.jpc.Misc.parseStringToComponents;
  74 import static org.jpc.Misc.nextParseLine;
  75 import static org.jpc.Misc.renameFile;
  76
  77 public class PCControl implements Plugin, PCMonitorPanelEmbedder
  78 {
  79     private static long PROFILE_ALWAYS = 0;
  80     private static long PROFILE_NO_PC = 1;
  81     private static long PROFILE_HAVE_PC = 2;
  82     private static long PROFILE_STOPPED = 4;
  83     private static long PROFILE_RUNNING = 8;
  84     private static long PROFILE_EVENTS = 16;
  85     private static long PROFILE_CDROM = 32;
  86     private static long PROFILE_DUMPING = 64;
  87     private static long PROFILE_NOT_DUMPING = 128;
  88     private static long PROFILE_HAVE_HDA = 256;
  89     private static long PROFILE_HAVE_HDB = 512;
  90     private static long PROFILE_HAVE_HDC = 1024;
  91     private static long PROFILE_HAVE_HDD = 2048;
  92     private static String SAVESTATE_LABEL = "Savestating...";
  93     private static String LOADSTATE_LABEL = "Loadstating...";
  94     private static String RAMDUMP_LABEL = "Dumping RAM...";
  95     private static String IMAGEDUMP_LABEL = "Dumping Image...";
  96     private static String STATUSDUMP_LABEL = "Dumping status...";
  97     private static String ASSEMBLE_LABEL = "Assembling system...";
  98     private static String ADDDISK_LABEL = "Adding new disk...";
  99     private static String CHANGEAUTHORS_LABEL = "Changing run authors...";
 100
 101     private static final long serialVersionUID = 8;
 102     private Plugins vPluginManager;
 103
 104     private JFrame window;
 105     private JFileChooser snapshotFileChooser;
 106     private DropTarget dropTarget;
 107     private LoadstateDropTarget loadstateDropTarget;
 108     private RAWDumper dumper;
 109
 110     private Set<String> disks;
 111
 112     protected PC pc;
 113
 114     private int trapFlags;
 115
 116     private volatile long profile;
 117     private volatile boolean running;
 118     private volatile boolean waiting;
 119     private boolean uncompressedSave;
 120     private static final long[] stopTime;
 121     private static final String[] stopLabel;
 122     private volatile long imminentTrapTime;
 123     private boolean shuttingDown;
 124     private int nativeWidth;
 125     private int nativeHeight;
 126     private PCConfigDialog configDialog;
 127     private MenuManager menuManager;
 128     private Map<String, List<String[]> > extraActions;
 129     private PCMonitorPanel panel;
 130     private JLabel statusBar;
 131     private volatile int currentResolutionWidth;
 132     private volatile int currentResolutionHeight;
 133     private volatile Runnable taskToDo;
 134     private volatile String taskLabel;
 135     private boolean cycleDone;
 136     private Map<String, Class<?>> debugInClass;
 137     private Map<String, Boolean> debugState;
 138
 139     private PC.PCFullStatus currentProject;
 140
 141     class LoadstateDropTarget implements DropTargetListener
 142     {
 143         public void dragEnter(DropTargetDragEvent e)         {}
 144         public void dragOver(DropTargetDragEvent e)          {}
 145         public void dragExit(DropTargetEvent e)              {}
 146         public void dropActionChanged(DropTargetDragEvent e) {}
 147
 148         public void drop(DropTargetDropEvent e)
 149         {
 150             if(running) {
 151                 e.rejectDrop();
 152                 return;
 153             }
 154             e.acceptDrop(DnDConstants.ACTION_COPY);
 155             int i = 0;
 156             for(DataFlavor f : e.getCurrentDataFlavors()) {
 157                 try {
 158                     Transferable t = e.getTransferable();
 159                     Object d = t.getTransferData(f);
 160                     if(f.isMimeTypeEqual("text/uri-list") && d.getClass() == String.class) {
 161                         String url = (String)d;
 162                         if(url.indexOf(10) >= 0) {
 163                             callShowOptionDialog(window, "Hey, only single file at time!",
 164                                 "DnD error", JOptionPane.YES_NO_OPTION, JOptionPane.WARNING_MESSAGE, null,
 165                                 new String[]{"Dismiss"}, "Dismiss");
 166                             e.dropComplete(false);
 167                             return;
 168                         }
 169                         e.dropComplete(handleURLDropped(url));
 170                         return;
 171                     }
 172                 } catch(Exception ex) {
 173                     errorDialog(ex, "Failed to get DnD data", null, "Dismiss");
 174                     e.dropComplete(false);
 175                     return;
 176                 }
 177             }
 178             for(DataFlavor f : e.getCurrentDataFlavors()) {
 179                 i = 0;
 180                 try {
 181                     i++;
 182                     Transferable t = e.getTransferable();
 183                     Object d = t.getTransferData(f);
 184                     System.err.println("Notice: Format #" + i + ":" + d.getClass().getName() + "(" + f + ")");
 185                 } catch(Exception ex) {
 186                     System.err.println("Notice: Format #" + i + ": <ERROR>(" + f + ")");
 187                 }
 188             }
 189             callShowOptionDialog(window, "Can't recognize file to load from drop (debugging information dumped to console).",
 190                 "DnD error", JOptionPane.YES_NO_OPTION, JOptionPane.WARNING_MESSAGE, null,
 191                 new String[]{"Dismiss"}, "Dismiss");
 192             e.dropComplete(false);
 193         }
 194     }
 195
 196     private boolean handleURLDropped(String url)
 197     {
 198         if(!url.startsWith("file:///")) {
 199             callShowOptionDialog(window, "Can't load remote resource.",
 200                 "DnD error", JOptionPane.YES_NO_OPTION, JOptionPane.WARNING_MESSAGE, null,
 201                 new String[]{"Dismiss"}, "Dismiss");
 202             return false;
 203         }
 204         url = url.substring(7);
 205         setTask(new LoadStateTask(url, LoadStateTask.MODE_NORMAL), LOADSTATE_LABEL);
 206         return true;
 207     }
 208
 209     static
 210     {
 211         stopTime = new long[] {-1, 0, 1000, 2000, 5000, 10000, 20000, 50000, 100000, 200000, 500000, 1000000, 2000000,
 212             5000000, 10000000, 20000000, 50000000, 100000000, 200000000, 500000000, 1000000000, 2000000000,
 213             5000000000L, 10000000000L, 20000000000L, 50000000000L};
 214         stopLabel = new String[] {"(unbounded)", "(singlestep)", "1µs", "2µs", "5µs", "10µs", "20µs", "50µs", "100µs",
 215             "200µs", "500µs","1ms", "2ms", "5ms", "10ms", "20ms", "50ms", "100ms", "200ms", "500ms", "1s", "2s", "5s",
 216             "10s", "20s", "50s"};
 217     }
 218
 219     public boolean systemShutdown()
 220     {
 221         if(!running || pc == null)
 222             return true;
 223         //We are running. Do the absolute minimum since we are running in very delicate context.
 224         shuttingDown = true;
 225         stop();
 226         while(running);
 227         return true;
 228     }
 229
 230     public void reconnect(PC pc)
 231     {
 232         pcStopping();  //Do the equivalent effects.
 233         updateStatusBar();
 234         updateDebug();
 235     }
 236
 237     public void notifySizeChange(int w, int h)
 238     {
 239         final int w2 = w;
 240         final int h2 = h;
 241
 242         SwingUtilities.invokeLater(new Runnable() { public void run() {
 243             window.pack();
 244             Dimension d = window.getSize();
 245             nativeWidth = d.width;
 246             nativeHeight = d.height;
 247             currentResolutionWidth = w2;
 248             currentResolutionHeight = h2;
 249             updateStatusBarEventThread();
 250         }});
 251     }
 252
 253     public void notifyFrameReceived(int w, int h)
 254     {
 255         currentResolutionWidth = w;
 256         currentResolutionHeight = h;
 257         updateStatusBar();
 258     }
 259
 260     private void setTrapFlags()
 261     {
 262         pc.getTraceTrap().setTrapFlags(trapFlags);
 263     }
 264
 265     public void pcStarting()
 266     {
 267         profile = PROFILE_HAVE_PC | PROFILE_RUNNING | (profile & (PROFILE_DUMPING | PROFILE_NOT_DUMPING));
 268         if(currentProject != null && currentProject.events != null);
 269             profile |= PROFILE_EVENTS;
 270         if(pc.getCDROMIndex() >= 0)
 271             profile |= PROFILE_CDROM;
 272
 273         menuManager.setProfile(profile);
 274
 275         if (running)
 276             return;
 277
 278         setTrapFlags();
 279
 280         Clock sysClock = (Clock)pc.getComponent(Clock.class);
 281         long current = sysClock.getTime();
 282         if(imminentTrapTime > 0) {
 283             pc.getTraceTrap().setTrapTime(current + imminentTrapTime);
 284         } else if(imminentTrapTime == 0) {
 285             //Hack: We set trace trap to trap immediately. It comes too late to abort next instruction, but
 286             //early enough to abort one after that.
 287             pc.getTraceTrap().setTrapTime(current);
 288         }
 289         if(currentProject.events != null)
 290             currentProject.events.setPCRunStatus(true);
 291     }
 292
 293     public void pcStopping()
 294     {
 295         if(currentProject.events != null)
 296             currentProject.events.setPCRunStatus(false);
 297         if(shuttingDown)
 298             return;   //Don't mess with UI when shutting down.
 299
 300
 301         profile = PROFILE_STOPPED | (profile & (PROFILE_DUMPING | PROFILE_NOT_DUMPING));
 302         if(pc != null)
 303             profile |= PROFILE_HAVE_PC;
 304         else
 305             profile |= PROFILE_NO_PC;
 306         if(currentProject != null && currentProject.events != null);
 307             profile |= PROFILE_EVENTS;
 308         if(pc.getCDROMIndex() >= 0)
 309             profile |= PROFILE_CDROM;
 310
 311         menuManager.setProfile(profile);
 312         updateStatusBar();
 313
 314         try {
 315             updateDisks();
 316         } catch(Exception e) {
 317             errorDialog(e, "Failed to update disk menus", null, "Dismiss");
 318         }
 319
 320         if(pc != null) {
 321             pc.getTraceTrap().clearTrapTime();
 322             pc.getTraceTrap().getAndClearTrapActive();
 323         }
 324     }
 325
 326     private String diskNameByIdx(int idx)
 327     {
 328         return pc.getDisks().lookupDisk(idx).getName();
 329     }
 330
 331     private void updateDisks() throws Exception
 332     {
 333         for(String x : disks)
 334             menuManager.removeMenuItem(x);
 335
 336         disks.clear();
 337
 338         if(pc == null)
 339             return;
 340
 341         DiskImageSet imageSet = pc.getDisks();
 342         DriveSet driveset = pc.getDrives();
 343         int[] floppies = imageSet.diskIndicesByType(BlockDevice.Type.FLOPPY);
 344         int[] cdroms = imageSet.diskIndicesByType(BlockDevice.Type.CDROM);
 345
 346         for(int i = 0; i < floppies.length; i++) {
 347             String name = diskNameByIdx(floppies[i]);
 348             menuManager.addMenuItem("Drives→fda→" + name, this, "menuChangeDisk", new Object[]{new Integer(0),
 349                 new Integer(floppies[i])}, PROFILE_HAVE_PC);
 350             menuManager.addMenuItem("Drives→fdb→" + name, this, "menuChangeDisk", new Object[]{new Integer(1),
 351                  new Integer(floppies[i])}, PROFILE_HAVE_PC);
 352             menuManager.addMenuItem("Drives→dump→" + name, this, "menuDumpDisk", new Object[]{
 353                  new Integer(floppies[i])}, PROFILE_HAVE_PC);
 354             menuManager.addSelectableMenuItem("Drives→Write Protect→" + name, this, "menuWriteProtect",
 355                  new Object[]{new Integer(floppies[i])}, imageSet.lookupDisk(floppies[i]).isReadOnly(),
 356                  PROFILE_HAVE_PC);
 357             disks.add("Drives→fda→" + name);
 358             disks.add("Drives→fdb→" + name);
 359             disks.add("Drives→Write Protect→" + name);
 360             disks.add("Drives→dump→" + name);
 361
 362             BlockDevice dev;
 363             DriveSet drives = pc.getDrives();
 364             profile = profile & ~(PROFILE_HAVE_HDA | PROFILE_HAVE_HDB | PROFILE_HAVE_HDC | PROFILE_HAVE_HDD);
 365             dev = drives.getHardDrive(0);
 366             profile = profile | ((dev != null && dev.getType() == BlockDevice.Type.HARDDRIVE) ? PROFILE_HAVE_HDA : 0);
 367             dev = drives.getHardDrive(1);
 368             profile = profile | ((dev != null && dev.getType() == BlockDevice.Type.HARDDRIVE) ? PROFILE_HAVE_HDB : 0);
 369             dev = drives.getHardDrive(2);
 370             profile = profile | ((dev != null && dev.getType() == BlockDevice.Type.HARDDRIVE) ? PROFILE_HAVE_HDC : 0);
 371             dev = drives.getHardDrive(3);
 372             profile = profile | ((dev != null && dev.getType() == BlockDevice.Type.HARDDRIVE) ? PROFILE_HAVE_HDD : 0);
 373             menuManager.setProfile(profile);
 374         }
 375
 376         for(int i = 0; i < cdroms.length; i++) {
 377             String name = diskNameByIdx(cdroms[i]);
 378             menuManager.addMenuItem("Drives→CD-ROM→" + name, this, "menuChangeDisk", new Object[]{new Integer(1),
 379                  new Integer(cdroms[i])}, PROFILE_HAVE_PC | PROFILE_CDROM);
 380             disks.add("Drives→CD-ROM→" + name);
 381         }
 382     }
 383
 384     private synchronized boolean setTask(Runnable task, String label)
 385     {
 386         boolean run = running;
 387         if(run || taskToDo != null)
 388             return false;   //Can't do tasks with PC running or existing task.
 389         taskToDo = task;
 390         taskLabel = label;
 391         notifyAll();
 392         updateStatusBar();
 393         return true;
 394     }
 395
 396     public void main()
 397     {
 398         boolean wasRunning = false;
 399         while(true) {   //We will be killed by JVM.
 400             //Wait for us to become runnable again.
 401             while((!running || pc == null) && taskToDo == null) {
 402                 if(!running && wasRunning && pc != null)
 403                     pc.stop();
 404                 wasRunning = running;
 405                 try {
 406                     synchronized(this) {
 407                         if((running && pc != null) || taskToDo != null)
 408                             continue;
 409                         waiting = true;
 410                         notifyAll();
 411                         wait();
 412                         waiting = false;
 413                     }
 414                 } catch(Exception e) {
 415                 }
 416             }
 417             //
 418             if(running && !wasRunning)
 419                 pc.start();
 420             wasRunning = running;
 421
 422             if(taskToDo != null) {
 423                 taskToDo.run();
 424                 taskToDo = null;
 425                 updateStatusBar();
 426                 continue;
 427             }
 428
 429             try {
 430                 pc.execute();
 431                 if(pc.getHitTraceTrap()) {
 432                     if(pc.getAndClearTripleFaulted())
 433                         callShowOptionDialog(window, "CPU shut itself down due to triple fault. Rebooting the system.",
 434                             "Triple fault!", JOptionPane.YES_NO_OPTION, JOptionPane.WARNING_MESSAGE, null,
 435                             new String[]{"Dismiss"}, "Dismiss");
 436                     if(shuttingDown)
 437                         stopNoWait();
 438                     else
 439                         SwingUtilities.invokeAndWait(new Thread() { public void run() { stopNoWait(); }});
 440                     running = false;
 441                     doCycle(pc);
 442                 }
 443             } catch (Exception e) {
 444                 running = false;
 445                 doCycle(pc);
 446                 errorDialog(e, "Hardware emulator internal error", window, "Dismiss");
 447                 try {
 448                     if(shuttingDown)
 449                         stopNoWait();
 450                     else
 451                         SwingUtilities.invokeAndWait(new Thread() { public void run() { stopNoWait(); }});
 452                     SwingUtilities.invokeAndWait(new Thread() { public void run() { stopNoWait(); }});
 453                 } catch (Exception f) {
 454                 }
 455             }
 456         }
 457     }
 458
 459
 460     public void connectPC(PC pc)
 461     {
 462         currentProject.pc = pc;
 463         vPluginManager.reconnect(pc);
 464         this.pc = pc;
 465     }
 466
 467     private void startExternal()
 468     {
 469         if(pc != null && !running)
 470             if(!SwingUtilities.isEventDispatchThread())
 471                 try {
 472                     SwingUtilities.invokeAndWait(new Thread() { public void run() { PCControl.this.start(); }});
 473                 } catch(Exception e) {
 474                 }
 475             else
 476                 start();
 477     }
 478
 479     private void stopExternal()
 480     {
 481         if(pc != null && running)
 482             if(!SwingUtilities.isEventDispatchThread())
 483                 try {
 484                     SwingUtilities.invokeAndWait(new Thread() { public void run() { PCControl.this.stop(); }});
 485                 } catch(Exception e) {
 486                 }
 487             else
 488                 stop();
 489     }
 490
 491     public boolean eci_state_save(String filename)
 492     {
 493         return setTask(new SaveStateTask(filename, false), SAVESTATE_LABEL);
 494     }
 495
 496     public boolean eci_state_dump(String filename)
 497     {
 498         return setTask(new StatusDumpTask(filename), STATUSDUMP_LABEL);
 499     }
 500
 501     public boolean eci_movie_save(String filename)
 502     {
 503         return setTask(new SaveStateTask(filename, true), SAVESTATE_LABEL);
 504     }
 505
 506     public boolean eci_state_load(String filename)
 507     {
 508         return setTask(new LoadStateTask(filename, LoadStateTask.MODE_NORMAL), LOADSTATE_LABEL);
 509     }
 510
 511     public boolean eci_state_load_noevents(String filename)
 512     {
 513         return setTask(new LoadStateTask(filename, LoadStateTask.MODE_PRESERVE), LOADSTATE_LABEL);
 514     }
 515
 516     public boolean eci_movie_load(String filename)
 517     {
 518         return setTask(new LoadStateTask(filename, LoadStateTask.MODE_MOVIEONLY), LOADSTATE_LABEL);
 519     }
 520
 521     public boolean eci_pc_assemble()
 522     {
 523         return setTask(new AssembleTask(), ASSEMBLE_LABEL);
 524     }
 525
 526     public boolean eci_ram_dump_text(String filename)
 527     {
 528         return setTask(new RAMDumpTask(filename, false), RAMDUMP_LABEL);
 529     }
 530
 531     public boolean eci_image_dump(String filename, int index)
 532     {
 533         return setTask(new ImageDumpTask(filename, index), IMAGEDUMP_LABEL);
 534     }
 535
 536     public boolean eci_ram_dump_binary(String filename)
 537     {
 538         return setTask(new RAMDumpTask(filename, true), RAMDUMP_LABEL);
 539     }
 540
 541     public void eci_trap_vretrace_start_on()
 542     {
 543         trapFlags |= TraceTrap.TRACE_STOP_VRETRACE_START;
 544     }
 545
 546     public void eci_trap_vretrace_start_off()
 547     {
 548         trapFlags &= ~TraceTrap.TRACE_STOP_VRETRACE_START;
 549     }
 550
 551     public void eci_trap_vretrace_end_on()
 552     {
 553         trapFlags |= TraceTrap.TRACE_STOP_VRETRACE_END;
 554     }
 555
 556     public void eci_trap_vretrace_end_off()
 557     {
 558         trapFlags &= ~TraceTrap.TRACE_STOP_VRETRACE_END;
 559     }
 560
 561     public void eci_trap_timed_disable()
 562     {
 563         this.imminentTrapTime = -1;
 564     }
 565
 566     public void eci_trap_timed(Long time)
 567     {
 568         this.imminentTrapTime = time.longValue();
 569     }
 570
 571     public void eci_pc_start()
 572     {
 573         startExternal();
 574     }
 575
 576     public void eci_pc_stop()
 577     {
 578         stopExternal();
 579     }
 580
 581     public void eci_pccontrol_setwinpos(Integer x, Integer y)
 582     {
 583         moveWindow(window, x.intValue(), y.intValue(), nativeWidth, nativeHeight);
 584     }
 585
 586     public void eci_sendevent(String clazz, String[] rargs)
 587     {
 588         System.err.println("Event to: '" + clazz + "':");
 589         for(int i = 0; i < rargs.length; i++) {
 590             System.err.println("rargs[" + i + "]: '"  + rargs[i] + "'.");
 591         }
 592         if(currentProject.events != null) {
 593             try {
 594                 Class <? extends HardwareComponent> x = Class.forName(clazz).asSubclass(HardwareComponent.class);
 595                 currentProject.events.addEvent(0L, x, rargs);
 596             } catch(Exception e) {
 597                 System.err.println("Error adding event: " + e.getMessage());
 598             }
 599         }
 600     }
 601
 602     public void eci_sendevent_lowbound(Long timeMin, String clazz, String[] rargs)
 603     {
 604         System.err.println("Event to: '" + clazz + "' (with low bound of " + timeMin + "):");
 605         for(int i = 0; i < rargs.length; i++) {
 606             System.err.println("rargs[" + i + "]: '"  + rargs[i] + "'.");
 607         }
 608         if(currentProject.events != null) {
 609             try {
 610                 Class <? extends HardwareComponent> x = Class.forName(clazz).asSubclass(HardwareComponent.class);
 611                 currentProject.events.addEvent(timeMin, x, rargs);
 612             } catch(Exception e) {
 613                 System.err.println("Error adding event: " + e.getMessage());
 614             }
 615         }
 616     }
 617
 618     public void eci_memory_read(Long address, Integer size)
 619     {
 620         if(currentProject.pc != null) {
 621             long addr = address.longValue();
 622             long _size = size.intValue();
 623             long ret = 0;
 624             PhysicalAddressSpace addrSpace;
 625             if(addr < 0 || addr > 0xFFFFFFFFL || (_size != 1 && _size != 2 && _size != 4))
 626                 return;
 627
 628             addrSpace = (PhysicalAddressSpace)currentProject.pc.getComponent(PhysicalAddressSpace.class);
 629             if(_size == 1)
 630                 ret = (long)addrSpace.getByte((int)addr) & 0xFF;
 631             else if(_size == 2)
 632                 ret = (long)addrSpace.getWord((int)addr) & 0xFFFF;
 633             else if(_size == 4)
 634                 ret = (long)addrSpace.getDoubleWord((int)addr) & 0xFFFFFFFFL;
 635
 636             vPluginManager.returnValue(ret);
 637         }
 638     }
 639
 640     public void eci_memory_write(Long address, Long value, Integer size)
 641     {
 642         if(currentProject.pc != null) {
 643             long addr = address.longValue();
 644             long _size = size.intValue();
 645             long _value = value.longValue();
 646             PhysicalAddressSpace addrSpace;
 647             if(addr < 0 || addr > 0xFFFFFFFFL || (_size != 1 && _size != 2 && _size != 4))
 648                 return;
 649
 650             addrSpace = (PhysicalAddressSpace)currentProject.pc.getComponent(PhysicalAddressSpace.class);
 651             if(_size == 1)
 652                 addrSpace.setByte((int)addr, (byte)_value);
 653             else if(_size == 2)
 654                 addrSpace.setWord((int)addr, (short)_value);
 655             else if(_size == 4)
 656                 addrSpace.setDoubleWord((int)addr, (int)_value);
 657         }
 658     }
 659
 660     public PCControl(Plugins manager, String args) throws Exception
 661     {
 662         this(manager);
 663
 664         UTFInputLineStream file = null;
 665         Map<String, String> params = parseStringToComponents(args);
 666         Set<String> used = new HashSet<String>();
 667         String extramenu = params.get("extramenu");
 668         String uncompress = params.get("uncompressedsave");
 669         if(uncompress != null)
 670             uncompressedSave = true;
 671         if(extramenu == null)
 672             return;
 673         try {
 674             file = new UTFInputLineStream(new FileInputStream(extramenu));
 675
 676             while(true) {
 677                 boolean exists = false;
 678                 String[] line = nextParseLine(file);
 679                 if(line == null)
 680                     break;
 681                 if(line.length < 3 || line[0].charAt(0) == '→') {
 682                     System.err.println("Warning: Bad extra menu item '" + line[0] + "'.");
 683                     continue;
 684                 }
 685                 if(line[0].length() == 0 || line[0].charAt(line[0].length() - 1) == '→') {
 686                     System.err.println("Warning: Bad extra menu item '" + line[0] + "'.");
 687                     continue;
 688                 }
 689                 if(line[0].indexOf("→→") >= 0) {
 690                     System.err.println("Warning: Bad extra menu item '" + line[0] + "'.");
 691                     continue;
 692                 }
 693                 if(used.contains(line[0]))
 694                     exists = true;
 695
 696                 KeyStroke stroke = null;
 697                 if(!line[1].equals("<>")) {
 698                     stroke = KeyStroke.getKeyStroke(line[1]);
 699                     if(stroke == null) {
 700                         System.err.println("Warning: Bad keystroke '" + line[1] + "'.");
 701
 702                     }
 703                 }
 704
 705                 String[] lineCommand = Arrays.copyOfRange(line, 2, line.length);
 706                 used.add(line[0]);
 707                 List<String[]> commandList = extraActions.get(line[0]);
 708                 if(commandList == null)
 709                     extraActions.put(line[0], commandList = new ArrayList<String[]>());
 710                 commandList.add(lineCommand);
 711
 712                 if(!exists)
 713                     menuManager.addMenuItem("Extra→" + line[0], this, "menuExtra", new String[]{line[0]}, PROFILE_ALWAYS,
 714                         stroke);
 715             }
 716             file.close();
 717         } catch(IOException e) {
 718             errorDialog(e, "Failed to load extra menu defintions", null, "dismiss");
 719             if(file != null)
 720                 file.close();
 721         }
 722         window.setJMenuBar(menuManager.getMainBar());
 723     }
 724
 725     public PCControl(Plugins manager) throws Exception
 726     {
 727         window = new JFrame("JPC-RR" + Misc.emuname);
 728
 729         if(DiskImage.getLibrary() == null)
 730             throw new Exception("PCControl plugin requires disk library");
 731
 732         running = false;
 733         shuttingDown = false;
 734
 735         debugInClass = new HashMap<String, Class<?>>();
 736         debugState = new HashMap<String, Boolean>();
 737
 738         configDialog = new PCConfigDialog();
 739         extraActions = new HashMap<String, List<String[]> >();
 740         menuManager = new MenuManager();
 741
 742         menuManager.setProfile(profile = (PROFILE_NO_PC | PROFILE_STOPPED | PROFILE_NOT_DUMPING));
 743
 744         menuManager.addMenuItem("System→Assemble", this, "menuAssemble", null, PROFILE_STOPPED);
 745         menuManager.addMenuItem("System→Start", this, "menuStart", null, PROFILE_STOPPED | PROFILE_HAVE_PC);
 746         menuManager.addMenuItem("System→Stop", this, "menuStop", null, PROFILE_RUNNING);
 747         menuManager.addMenuItem("System→Reset", this, "menuReset", null, PROFILE_HAVE_PC);
 748         menuManager.addMenuItem("System→Start dumping", this, "menuStartDump", null, PROFILE_STOPPED | PROFILE_NOT_DUMPING);
 749         menuManager.addMenuItem("System→Stop dumping", this, "menuStopDump", null, PROFILE_STOPPED | PROFILE_DUMPING);
 750         menuManager.addMenuItem("System→Quit", this, "menuQuit", null, PROFILE_ALWAYS);
 751         menuManager.addSelectableMenuItem("Breakpoints→Trap VRetrace Start", this, "menuVRetraceStart", null, false,
 752             PROFILE_ALWAYS);
 753         menuManager.addSelectableMenuItem("Breakpoints→Trap VRetrace End", this, "menuVRetraceEnd", null, false,
 754             PROFILE_ALWAYS);
 755         menuManager.addMenuItem("Snapshot→Change Run Authors", this, "menuChangeAuthors", null, PROFILE_HAVE_PC);
 756         menuManager.addMenuItem("Snapshot→Save→Snapshot", this, "menuSave", new Object[]{new Boolean(false)},
 757             PROFILE_HAVE_PC | PROFILE_STOPPED);
 758         menuManager.addMenuItem("Snapshot→Save→Movie", this, "menuSave", new Object[]{new Boolean(true)},
 759             PROFILE_HAVE_PC | PROFILE_STOPPED);
 760         menuManager.addMenuItem("Snapshot→Save→Status Dump", this, "menuStatusDump", null,
 761             PROFILE_HAVE_PC | PROFILE_STOPPED);
 762         menuManager.addMenuItem("Snapshot→Load→Snapshot", this, "menuLoad",
 763             new Object[]{new Integer(LoadStateTask.MODE_NORMAL)}, PROFILE_STOPPED);
 764         menuManager.addMenuItem("Snapshot→Load→Snapshot (preserve events)", this, "menuLoad",
 765             new Object[]{new Integer(LoadStateTask.MODE_PRESERVE)}, PROFILE_STOPPED | PROFILE_EVENTS);
 766         menuManager.addMenuItem("Snapshot→Load→Movie", this, "menuLoad",
 767             new Object[]{new Integer(LoadStateTask.MODE_MOVIEONLY)}, PROFILE_STOPPED);
 768         menuManager.addMenuItem("Snapshot→RAM Dump→Hexadecimal", this, "menuRAMDump", new Object[]{new Boolean(false)},
 769             PROFILE_HAVE_PC | PROFILE_STOPPED);
 770         menuManager.addMenuItem("Snapshot→RAM Dump→Binary", this, "menuRAMDump", new Object[]{new Boolean(true)},
 771             PROFILE_HAVE_PC | PROFILE_STOPPED);
 772         menuManager.addMenuItem("Snapshot→Truncate Event Stream", this, "menuTruncate", null,
 773             PROFILE_STOPPED | PROFILE_EVENTS);
 774
 775         for(int i = 0; i < stopLabel.length; i++) {
 776             menuManager.addSelectableMenuItem("Breakpoints→Timed Stops→" + stopLabel[i], this, "menuTimedStop",
 777                 null, (i == 0), PROFILE_ALWAYS);
 778         }
 779         imminentTrapTime = -1;
 780
 781         menuManager.addMenuItem("Drives→fda→<Empty>", this, "menuChangeDisk", new Object[]{new Integer(0),
 782             new Integer(-1)}, PROFILE_HAVE_PC);
 783         menuManager.addMenuItem("Drives→fdb→<Empty>", this, "menuChangeDisk", new Object[]{new Integer(1),
 784             new Integer(-1)}, PROFILE_HAVE_PC);
 785         menuManager.addMenuItem("Drives→CD-ROM→<Empty>", this, "menuChangeDisk", new Object[]{new Integer(2),
 786             new Integer(-1)}, PROFILE_HAVE_PC | PROFILE_CDROM);
 787         menuManager.addMenuItem("Drives→Add image", this, "menuAddDisk", null, PROFILE_HAVE_PC);
 788         menuManager.addMenuItem("Drives→Import Image", this, "menuImport", null, PROFILE_ALWAYS);
 789         menuManager.addMenuItem("Drives→dump→HDA", this, "menuDumpDisk", new Object[]{
 790               new Integer(-1)}, PROFILE_HAVE_PC | PROFILE_HAVE_HDA);
 791         menuManager.addMenuItem("Drives→dump→HDB", this, "menuDumpDisk", new Object[]{
 792               new Integer(-2)}, PROFILE_HAVE_PC | PROFILE_HAVE_HDB);
 793         menuManager.addMenuItem("Drives→dump→HDC", this, "menuDumpDisk", new Object[]{
 794               new Integer(-3)}, PROFILE_HAVE_PC | PROFILE_HAVE_HDC);
 795         menuManager.addMenuItem("Drives→dump→HDD", this, "menuDumpDisk", new Object[]{
 796               new Integer(-4)}, PROFILE_HAVE_PC | PROFILE_HAVE_HDD);
 797         menuManager.addMenuItem("Debug→Hacks→NO_FPU", this, "menuNOFPU", null, PROFILE_HAVE_PC);
 798         menuManager.addMenuItem("Debug→Hacks→VGA_DRAW", this, "menuVGADRAW", null, PROFILE_HAVE_PC);
 799         menuManager.addMenuItem("Debug→Hacks→VGA_SCROLL_2", this, "menuVGASCROLL2", null, PROFILE_HAVE_PC);
 800
 801         disks = new HashSet<String>();
 802         currentProject = new PC.PCFullStatus();
 803         this.pc = null;
 804         this.vPluginManager = manager;
 805
 806         panel = new PCMonitorPanel(this, manager.getOutputConnector());
 807         loadstateDropTarget  = new LoadstateDropTarget();
 808         dropTarget = new DropTarget(panel.getMonitorPanel(), loadstateDropTarget);
 809
 810         statusBar = new JLabel("");
 811         statusBar.setBorder(new EtchedBorder(EtchedBorder.LOWERED));
 812         manager.addSlaveObject(this, panel);
 813         panel.startThread();
 814
 815         window.getContentPane().add("Center", panel.getMonitorPanel());
 816         window.getContentPane().add("South", statusBar);
 817         JMenuBar bar = menuManager.getMainBar();
 818         for(JMenu menu : panel.getMenusNeeded())
 819             bar.add(menu);
 820         window.setJMenuBar(bar);
 821
 822         try {
 823             window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 824         } catch (AccessControlException e) {
 825             System.err.println("Error: Not able to add some components to frame: " + e.getMessage());
 826         }
 827
 828         snapshotFileChooser = new JFileChooser(System.getProperty("user.dir"));
 829
 830         window.getContentPane().validate();
 831         window.validate();
 832         window.pack();
 833         Dimension d = window.getSize();
 834         nativeWidth = d.width;
 835         nativeHeight = d.height;
 836         updateStatusBarEventThread();
 837
 838         window.setVisible(true);
 839     }
 840
 841     private String debugShowName(String name)
 842     {
 843         name = name.substring(12);
 844         StringBuffer buf = new StringBuffer();
 845         for(int i = 0; i < name.length(); i++)
 846             if(name.charAt(i) == '_')
 847                 buf.append(' ');
 848             else
 849                 buf.append(name.charAt(i));
 850         return buf.toString();
 851     }
 852
 853     private void addDebug(String name, Class<?> clazz)
 854     {
 855         if(debugInClass.get(name) != null)
 856             return;
 857         debugInClass.put(name, clazz);
 858         debugState.put(name, false);
 859         try {
 860              menuManager.addSelectableMenuItem("Debug→" + debugShowName(name), this, "menuDEBUGOPTION",
 861                  new Object[]{name}, false, PROFILE_HAVE_PC);
 862         } catch(Exception e) {
 863         }
 864     }
 865
 866     public void menuDEBUGOPTION(String i, Object[] args)
 867     {
 868         String name = (String)args[0];
 869         String mName = "Debug→" + debugShowName(name);
 870         debugState.put(name, !debugState.get(name));
 871         setDebugOption(name);
 872         menuManager.setSelected(mName, debugState.get(name));
 873     }
 874
 875     private void setDebugOption(String name)
 876     {
 877         try {
 878             debugInClass.get(name).getDeclaredMethod(name, boolean.class).invoke(pc.getComponent(
 879                  debugInClass.get(name)), debugState.get(name));
 880         } catch(Exception e) {
 881 e.printStackTrace();
 882         }
 883     }
 884
 885     private void setDebugOptions()
 886     {
 887          for(Map.Entry<String, Class<?>> opt : debugInClass.entrySet())
 888              setDebugOption(opt.getKey());
 889     }
 890
 891     private void updateDebug()
 892     {
 893          setDebugOptions();
 894          for(HardwareComponent c : pc.allComponents()) {
 895              Class<?> cl = c.getClass();
 896              for(Method m : cl.getDeclaredMethods()) {
 897                  Class<?>[] p = m.getParameterTypes();
 898                  if(!m.getName().startsWith("DEBUGOPTION_"))
 899                      continue;
 900                  if(p.length != 1 || p[0] != boolean.class)
 901                      continue;
 902                  addDebug(m.getName(), cl);
 903              }
 904          }
 905     }
 906
 907     private void updateStatusBar()
 908     {
 909         if(vPluginManager.isShuttingDown())
 910             return;  //Too much of deadlock risk.
 911         SwingUtilities.invokeLater(new Runnable() { public void run() { updateStatusBarEventThread(); }});
 912     }
 913
 914     private void updateStatusBarEventThread()
 915     {
 916         String text1;
 917         if(currentProject.pc != null && taskToDo == null) {
 918             long timeNow = ((Clock)currentProject.pc.getComponent(Clock.class)).getTime();
 919             long timeEnd = currentProject.events.getLastEventTime();
 920             text1 = " Time: " + (timeNow / 1000000) + "ms, movie length: " + (timeEnd / 1000000) + "ms";
 921             if(currentResolutionWidth > 0 && currentResolutionHeight > 0)
 922                 text1 = text1 + ", resolution: " + currentResolutionWidth + "*" + currentResolutionHeight;
 923             else
 924                 text1 = text1 + ", resolution: <No valid signal>";
 925             if(currentProject.events.isAtMovieEnd())
 926                 text1 = text1 + " (At movie end)";
 927         } else if(taskToDo != null)
 928             text1 = taskLabel;
 929         else
 930             text1 = " NO PC CONNECTED";
 931
 932         statusBar.setText(text1);
 933     }
 934
 935     public void menuExtra(String i, Object[] args)
 936     {
 937         final List<String[]> commandList = extraActions.get(args[0]);
 938         if(commandList == null) {
 939             System.err.println("Warning: Called extra menu with unknown entry '" + args[0] + "'.");
 940             return;
 941         }
 942
 943         //Run the functions on seperate thread to avoid deadlocking.
 944         (new Thread(new Runnable() { public void run() { menuExtraThreadFunc(commandList); }}, "Extra action thread")).start();
 945     }
 946
 947     private void menuExtraThreadFunc(List<String[]> actions)
 948     {
 949         for(String[] i : actions) {
 950             if(i.length == 1) {
 951                 vPluginManager.invokeExternalCommandSynchronous(i[0], null);
 952             } else {
 953                 String[] rest = Arrays.copyOfRange(i, 1, i.length, String[].class);
 954                 vPluginManager.invokeExternalCommandSynchronous(i[0], rest);
 955             }
 956         }
 957     }
 958
 959     public void menuAssemble(String i, Object[] args)
 960     {
 961         setTask(new AssembleTask(), ASSEMBLE_LABEL);
 962     }
 963
 964     public void menuStart(String i, Object[] args)
 965     {
 966         start();
 967     }
 968
 969     public void menuStartDump(String i, Object[] args)
 970     {
 971         int returnVal = snapshotFileChooser.showDialog(window, "Dump to file");
 972         if(returnVal != 0)
 973             return;
 974         File choosen = snapshotFileChooser.getSelectedFile();
 975         try {
 976             dumper = new RAWDumper(vPluginManager, "rawoutput=" + choosen.getAbsolutePath());
 977             vPluginManager.registerPlugin(dumper);
 978         } catch(Exception e) {
 979             errorDialog(e, "Failed to start dumping", null, "Dismiss");
 980             return;
 981         }
 982         profile &= ~PROFILE_NOT_DUMPING;
 983         profile |= PROFILE_DUMPING;
 984         menuManager.setProfile(profile);
 985     }
 986
 987     public void menuStopDump(String i, Object[] args)
 988     {
 989         vPluginManager.unregisterPlugin(dumper);
 990         profile &= ~PROFILE_DUMPING;
 991         profile |= PROFILE_NOT_DUMPING;
 992         menuManager.setProfile(profile);
 993     }
 994
 995     public void menuStop(String i, Object[] args)
 996     {
 997         stop();
 998     }
 999
1000     public void menuReset(String i, Object[] args)
1001     {
1002         reset();
1003     }
1004
1005     public void menuImport(String i, Object[] args)
1006     {
1007         try {
1008             new ImportDiskImage();
1009         } catch(Exception e) {
1010             e.printStackTrace();
1011         }
1012     }
1013
1014     public void menuNOFPU(String i, Object[] args)
1015     {
1016         pc.setFPUHack();
1017     }
1018
1019     public void menuVGADRAW(String i, Object[] args)
1020     {
1021         pc.setVGADrawHack();
1022     }
1023
1024     public void menuVGASCROLL2(String i, Object[] args)
1025     {
1026         pc.setVGAScroll2Hack();
1027     }
1028
1029     public void menuQuit(String i, Object[] args)
1030     {
1031         vPluginManager.shutdownEmulator();
1032     }
1033
1034     public void menuVRetraceStart(String i, Object[] args)
1035     {
1036         trapFlags ^= TraceTrap.TRACE_STOP_VRETRACE_START;
1037         menuManager.setSelected("Breakpoints→Trap VRetrace Start",
1038             (trapFlags & TraceTrap.TRACE_STOP_VRETRACE_START) == TraceTrap.TRACE_STOP_VRETRACE_START);
1039     }
1040
1041     public void menuVRetraceEnd(String i, Object[] args)
1042     {
1043         trapFlags ^= TraceTrap.TRACE_STOP_VRETRACE_END;
1044         menuManager.setSelected("Breakpoints→Trap VRetrace End",
1045             (trapFlags & TraceTrap.TRACE_STOP_VRETRACE_END) == TraceTrap.TRACE_STOP_VRETRACE_END);
1046     }
1047
1048     public void menuTimedStop(String i, Object[] args)
1049     {
1050         for(int j = 0; j < stopLabel.length; j++) {
1051             String label = "Breakpoints→Timed Stops→" + stopLabel[j];
1052             if(i.equals(label)) {
1053                 this.imminentTrapTime = stopTime[j];
1054                 menuManager.select(label);
1055             } else
1056                 menuManager.unselect(label);
1057         }
1058     }
1059
1060     public void menuSave(String i, Object[] args)
1061     {
1062         setTask(new SaveStateTask(((Boolean)args[0]).booleanValue()), SAVESTATE_LABEL);
1063     }
1064
1065     public void menuStatusDump(String i, Object[] args)
1066     {
1067         setTask(new StatusDumpTask(), STATUSDUMP_LABEL);
1068     }
1069
1070     public void menuLoad(String i, Object[] args)
1071     {
1072         setTask(new LoadStateTask(((Integer)args[0]).intValue()), LOADSTATE_LABEL);
1073     }
1074
1075     public void menuRAMDump(String i, Object[] args)
1076     {
1077         setTask(new RAMDumpTask(((Boolean)args[0]).booleanValue()), RAMDUMP_LABEL);
1078     }
1079
1080     public void menuDumpDisk(String i, Object[] args)
1081     {
1082         setTask(new ImageDumpTask(((Integer)args[0]).intValue()), IMAGEDUMP_LABEL);
1083     }
1084
1085     public void menuTruncate(String i, Object[] args)
1086     {
1087         currentProject.events.truncateEventStream();
1088     }
1089
1090     public void menuChangeDisk(String i, Object[] args)
1091     {
1092         changeFloppy(((Integer)args[0]).intValue(), ((Integer)args[1]).intValue());
1093     }
1094
1095     public void menuWriteProtect(String i, Object[] args)
1096     {
1097         int disk = ((Integer)args[0]).intValue();
1098         writeProtect(disk, menuManager.isSelected(i));
1099         DiskImageSet imageSet = pc.getDisks();
1100         menuManager.setSelected(i, imageSet.lookupDisk(disk).isReadOnly());
1101     }
1102
1103     public void menuAddDisk(String i, Object[] args)
1104     {
1105         setTask(new AddDiskTask(), ADDDISK_LABEL);
1106     }
1107
1108     public void menuChangeAuthors(String i, Object[] args)
1109     {
1110         setTask(new ChangeAuthorsTask(), CHANGEAUTHORS_LABEL);
1111     }
1112
1113     public synchronized void start()
1114     {
1115         if(taskToDo != null)
1116             return;
1117         vPluginManager.pcStarted();
1118         running = true;
1119         notifyAll();
1120     }
1121
1122     private String prettyPrintTime(long ts)
1123     {
1124         String s = "";
1125
1126         if(ts >= 1000000000)
1127             s = s + "" + (ts / 1000000000) + " ";
1128         if(ts >= 100000000)
1129             s = s + "" + (ts % 1000000000 / 100000000);
1130         if(ts >= 10000000)
1131             s = s + "" + (ts % 100000000 / 10000000);
1132         if(ts >= 1000000)
1133             s = s + "" + (ts % 10000000 / 1000000) + " ";
1134         if(ts >= 100000)
1135             s = s + "" + (ts % 1000000 / 100000);
1136         if(ts >= 10000)
1137            s = s + ""  + (ts % 100000 / 10000);
1138         if(ts >= 1000)
1139             s = s + "" + (ts % 10000 / 1000) + " ";
1140         if(ts >= 100)
1141             s = s + "" + (ts % 1000 / 100);
1142         if(ts >= 10)
1143             s = s + "" + (ts % 100 / 10);
1144         s = s + ""     + (ts % 10);
1145         return s;
1146     }
1147
1148     protected synchronized void stopNoWait()
1149     {
1150         running = false;
1151         vPluginManager.pcStopped();
1152         Clock sysClock = (Clock)pc.getComponent(Clock.class);
1153         System.err.println("Notice: PC emulation stopped (at time sequence value " +
1154             prettyPrintTime(sysClock.getTime()) + ")");
1155     }
1156
1157     public synchronized void stop()
1158     {
1159         pc.getTraceTrap().doPotentialTrap(TraceTrap.TRACE_STOP_IMMEDIATE);
1160         System.err.println("Informational: Waiting for PC to halt...");
1161     }
1162
1163     public JScrollPane getMonitorPane()
1164     {
1165         return null;
1166     }
1167
1168     protected void reset()
1169     {
1170         pc.reboot();
1171     }
1172
1173     public synchronized boolean isRunning()
1174     {
1175         return running;
1176     }
1177
1178     private void changeFloppy(int drive, int image)
1179     {
1180         try
1181         {
1182             PC.DiskChanger changer = (PC.DiskChanger)pc.getComponent(PC.DiskChanger.class);
1183             changer.changeFloppyDisk(drive, image);
1184         } catch (Exception e) {
1185             System.err.println("Error: Failed to change disk");
1186             errorDialog(e, "Failed to change disk", null, "Dismiss");
1187         }
1188     }
1189
1190     private void writeProtect(int image, boolean state)
1191     {
1192         try
1193         {
1194             PC.DiskChanger changer = (PC.DiskChanger)pc.getComponent(PC.DiskChanger.class);
1195             changer.wpFloppyDisk(image, state);
1196         } catch (Exception e) {
1197             System.err.println("Error: Failed to change floppy write protect");
1198             errorDialog(e, "Failed to write (un)protect floppy", null, "Dismiss");
1199         }
1200     }
1201
1202     private class LoadStateTask extends AsyncGUITask
1203     {
1204         File chosen;
1205         Exception caught;
1206         int _mode;
1207         long oTime;
1208         private static final int MODE_NORMAL = 1;
1209         private static final int MODE_PRESERVE = 2;
1210         private static final int MODE_MOVIEONLY = 3;
1211
1212         public LoadStateTask(int mode)
1213         {
1214             oTime = System.currentTimeMillis();
1215             chosen = null;
1216             _mode = mode;
1217         }
1218
1219         public LoadStateTask(String name, int mode)
1220         {
1221             this(mode);
1222             chosen = new File(name);
1223         }
1224
1225         protected void runPrepare()
1226         {
1227             if(chosen == null) {
1228                 int returnVal = 0;
1229                 if(_mode == MODE_PRESERVE)
1230                     returnVal = snapshotFileChooser.showDialog(window, "LOAD JPC-RR Snapshot (PE)");
1231                 else if(_mode == MODE_MOVIEONLY)
1232                     returnVal = snapshotFileChooser.showDialog(window, "LOAD JPC-RR Snapshot (MO)");
1233                 else
1234                     returnVal = snapshotFileChooser.showDialog(window, "LOAD JPC-RR Snapshot");
1235                 chosen = snapshotFileChooser.getSelectedFile();
1236
1237                 if (returnVal != 0)
1238                     chosen = null;
1239             }
1240         }
1241
1242         protected void runFinish()
1243         {
1244             if(chosen == null)
1245                 return;
1246
1247             if(caught == null) {
1248                 try {
1249                     connectPC(pc = currentProject.pc);
1250                     doCycle(pc);
1251                     System.err.println("Informational: Loadstate done on "+chosen.getAbsolutePath());
1252                 } catch(Exception e) {
1253                     caught = e;
1254                 }
1255             }
1256             if(caught != null) {
1257                 errorDialog(caught, "Load savestate failed", window, "Dismiss");
1258             }
1259             System.err.println("Total save time: " + (System.currentTimeMillis() - oTime) + "ms.");
1260             PCControl.this.vPluginManager.signalCommandCompletion();
1261         }
1262
1263         protected void runTask()
1264         {
1265             if(chosen == null)
1266                 return;
1267
1268             try {
1269                 System.err.println("Informational: Loading a snapshot of JPC-RR");
1270                 long times1 = System.currentTimeMillis();
1271                 JRSRArchiveReader reader = new JRSRArchiveReader(chosen.getAbsolutePath());
1272
1273                 PC.PCFullStatus fullStatus = PC.loadSavestate(reader, _mode == MODE_PRESERVE, _mode == MODE_MOVIEONLY,
1274                     currentProject);
1275
1276                 currentProject = fullStatus;
1277
1278                 reader.close();
1279                 long times2 = System.currentTimeMillis();
1280                 System.err.println("Informational: Loadstate complete (" + (times2 - times1) + "ms).");
1281             } catch(Exception e) {
1282                  caught = e;
1283             }
1284         }
1285     }
1286
1287     private synchronized void doCycleDedicatedThread(PC _pc)
1288     {
1289         if(_pc == null) {
1290             cycleDone = true;
1291             return;
1292         }
1293         DisplayController dc = (DisplayController)_pc.getComponent(DisplayController.class);
1294         dc.getOutputDevice().holdOutput(_pc.getTime());
1295         cycleDone = true;
1296         notifyAll();
1297     }
1298
1299     private void doCycle(PC _pc)
1300     {
1301         final PC _xpc = _pc;
1302         cycleDone = false;
1303         (new Thread(new Runnable() { public void run() { doCycleDedicatedThread(_xpc); }}, "VGA output cycle thread")).start();
1304         while(cycleDone)
1305             try {
1306                 synchronized(this) {
1307                     if(cycleDone)
1308                         break;
1309                     wait();
1310                 }
1311             } catch(Exception e) {
1312             }
1313     }
1314
1315     private class SaveStateTask extends AsyncGUITask
1316     {
1317         File chosen;
1318         Exception caught;
1319         boolean movieOnly;
1320         long oTime;
1321
1322         public SaveStateTask(boolean movie)
1323         {
1324             oTime = System.currentTimeMillis();
1325             chosen = null;
1326             movieOnly = movie;
1327         }
1328
1329         public SaveStateTask(String name, boolean movie)
1330         {
1331             this(movie);
1332             chosen = new File(name);
1333         }
1334
1335         protected void runPrepare()
1336         {
1337             if(chosen == null) {
1338                 int returnVal = snapshotFileChooser.showDialog(window, movieOnly ? "Save JPC-RR Movie" :
1339                     "Save JPC-RR Snapshot");
1340                 chosen = snapshotFileChooser.getSelectedFile();
1341
1342                 if (returnVal != 0)
1343                     chosen = null;
1344             }
1345         }
1346
1347         protected void runFinish()
1348         {
1349             if(caught != null) {
1350                 errorDialog(caught, "Saving savestate failed", window, "Dismiss");
1351             }
1352             System.err.println("Total save time: " + (System.currentTimeMillis() - oTime) + "ms.");
1353             PCControl.this.vPluginManager.signalCommandCompletion();
1354         }
1355
1356         protected void runTask()
1357         {
1358             if(chosen == null)
1359                 return;
1360
1361             JRSRArchiveWriter writer = null;
1362
1363             try {
1364                 System.err.println("Informational: Savestating...");
1365                 long times1 = System.currentTimeMillis();
1366                 writer = new JRSRArchiveWriter(chosen.getAbsolutePath());
1367                 PC.saveSavestate(writer, currentProject, movieOnly, uncompressedSave);
1368                 renameFile(chosen, new File(chosen.getAbsolutePath() + ".backup"));
1369                 writer.close();
1370                 long times2 = System.currentTimeMillis();
1371                 System.err.println("Informational: Savestate complete (" + (times2 - times1) + "ms). on"+chosen.getAbsolutePath());
1372             } catch(Exception e) {
1373                  if(writer != null)
1374                      try { writer.rollback(); } catch(Exception f) {}
1375                  caught = e;
1376             }
1377         }
1378     }
1379
1380     private class StatusDumpTask extends AsyncGUITask
1381     {
1382         File chosen;
1383         Exception caught;
1384
1385         public StatusDumpTask()
1386         {
1387             chosen = null;
1388         }
1389
1390         public StatusDumpTask(String name)
1391         {
1392             this();
1393             chosen = new File(name);
1394         }
1395
1396         protected void runPrepare()
1397         {
1398             if(chosen == null) {
1399                 int returnVal = snapshotFileChooser.showDialog(window, "Save Status dump");
1400                 chosen = snapshotFileChooser.getSelectedFile();
1401
1402                 if (returnVal != 0)
1403                     chosen = null;
1404             }
1405         }
1406
1407         protected void runFinish()
1408         {
1409             if(caught != null) {
1410                 errorDialog(caught, "Status dump failed", window, "Dismiss");
1411             }
1412             PCControl.this.vPluginManager.signalCommandCompletion();
1413         }
1414
1415         protected void runTask()
1416         {
1417             if(chosen == null)
1418                 return;
1419
1420             try {
1421                 OutputStream outb = new BufferedOutputStream(new FileOutputStream(chosen));
1422                 PrintStream out = new PrintStream(outb, false, "UTF-8");
1423                 StatusDumper sd = new StatusDumper(out);
1424                 pc.dumpStatus(sd);
1425                 out.flush();
1426                 outb.flush();
1427                 System.err.println("Informational: Dumped " + sd.dumpedObjects() + " objects");
1428             } catch(Exception e) {
1429                  caught = e;
1430             }
1431         }
1432     }
1433
1434     private class RAMDumpTask extends AsyncGUITask
1435     {
1436         File chosen;
1437         Exception caught;
1438         boolean binary;
1439
1440         public RAMDumpTask(boolean binFlag)
1441         {
1442             chosen = null;
1443             binary = binFlag;
1444         }
1445
1446         public RAMDumpTask(String name, boolean binFlag)
1447         {
1448             this(binFlag);
1449             chosen = new File(name);
1450         }
1451
1452         protected void runPrepare()
1453         {
1454             if(chosen == null) {
1455                 int returnVal;
1456                 if(binary)
1457                     returnVal = snapshotFileChooser.showDialog(window, "Save RAM dump");
1458                 else
1459                     returnVal = snapshotFileChooser.showDialog(window, "Save RAM hexdump");
1460                 chosen = snapshotFileChooser.getSelectedFile();
1461
1462                 if (returnVal != 0)
1463                     chosen = null;
1464             }
1465         }
1466
1467         protected void runFinish()
1468         {
1469             if(caught != null) {
1470                 errorDialog(caught, "RAM dump failed", window, "Dismiss");
1471             }
1472             PCControl.this.vPluginManager.signalCommandCompletion();
1473         }
1474
1475         protected void runTask()
1476         {
1477             if(chosen == null)
1478                 return;
1479
1480             try {
1481                 OutputStream outb = new BufferedOutputStream(new FileOutputStream(chosen));
1482                 byte[] pagebuf = new byte[4096];
1483                 PhysicalAddressSpace addr = (PhysicalAddressSpace)pc.getComponent(PhysicalAddressSpace.class);
1484                 int lowBound = addr.findFirstRAMPage(0);
1485                 int firstUndumped = 0;
1486                 int highBound = 0;
1487                 int present = 0;
1488                 while(lowBound >= 0) {
1489                     for(; firstUndumped < lowBound; firstUndumped++)
1490                         dumpPage(outb, firstUndumped, null);
1491                     addr.readRAMPage(firstUndumped++, pagebuf);
1492                     dumpPage(outb, lowBound, pagebuf);
1493                     present++;
1494                     highBound = lowBound + 1;
1495                     lowBound = addr.findFirstRAMPage(++lowBound);
1496                 }
1497                 outb.flush();
1498                 System.err.println("Informational: Dumped machine RAM (" + highBound + " pages examined, " +
1499                     present + " pages present).");
1500             } catch(Exception e) {
1501                  caught = e;
1502             }
1503         }
1504
1505         private byte charForHex(int hvalue)
1506         {
1507             if(hvalue < 10)
1508                 return (byte)(hvalue + 48);
1509             else if(hvalue > 9 && hvalue < 16)
1510                 return (byte)(hvalue + 55);
1511             else
1512                 System.err.println("Unknown hex value: " + hvalue + ".");
1513             return 90;
1514         }
1515
1516         private void dumpPage(OutputStream stream, int pageNo, byte[] buffer) throws IOException
1517         {
1518             int pageBufSize;
1519             pageNo = pageNo & 0xFFFFF;   //Cut page numbers out of range.
1520             if(!binary && buffer == null)
1521                 return;  //Don't dump null pages in non-binary mode.
1522             if(binary)
1523                 pageBufSize = 4096;      //Binary page buffer is 4096 bytes.
1524             else
1525                 pageBufSize = 14592;     //Hexdump page buffer is 14592 bytes.
1526             byte[] outputPage = new byte[pageBufSize];
1527             if(buffer != null && binary) {
1528                 System.arraycopy(buffer, 0, outputPage, 0, 4096);
1529             } else if(buffer != null) {   //Hex mode
1530                 for(int i = 0; i < 256; i++) {
1531                     for(int j = 0; j < 57; j++) {
1532                         if(j < 5)
1533                             outputPage[57 * i + j] = charForHex((pageNo >>> (4 * (4 - j))) & 0xF);
1534                         else if(j == 5)
1535                             outputPage[57 * i + j] = charForHex(i / 16);
1536                         else if(j == 6)
1537                             outputPage[57 * i + j] = charForHex(i % 16);
1538                         else if(j == 7)
1539                             outputPage[57 * i + j] = 48;
1540                         else if(j == 56)
1541                             outputPage[57 * i + j] = 10;
1542                         else if(j % 3 == 2)
1543                             outputPage[57 * i + j] = 32;
1544                         else if(j % 3 == 0)
1545                             outputPage[57 * i + j] = charForHex(((int)buffer[16 * i + j / 3 - 3] & 0xFF) / 16);
1546                         else if(j % 3 == 1)
1547                             outputPage[57 * i + j] = charForHex(buffer[16 * i + j / 3 - 3] & 0xF);
1548                         else
1549                             System.err.println("Error: dumpPage: unhandled j = " + j + ".");
1550                     }
1551                 }
1552             }
1553             stream.write(outputPage);
1554         }
1555     }
1556
1557     private class ImageDumpTask extends AsyncGUITask
1558     {
1559         File chosen;
1560         Exception caught;
1561         int index;
1562
1563         public ImageDumpTask(int _index)
1564         {
1565             chosen = null;
1566             index = _index;
1567         }
1568
1569         public ImageDumpTask(String name, int index)
1570         {
1571             this(index);
1572             chosen = new File(name);
1573         }
1574
1575         protected void runPrepare()
1576         {
1577             if(chosen == null) {
1578                 int returnVal;
1579                 returnVal = snapshotFileChooser.showDialog(window, "Save Image dump");
1580                 chosen = snapshotFileChooser.getSelectedFile();
1581
1582                 if (returnVal != 0)
1583                     chosen = null;
1584             }
1585         }
1586
1587         protected void runFinish()
1588         {
1589             if(caught != null) {
1590                 errorDialog(caught, "Image dump failed", window, "Dismiss");
1591             }
1592             PCControl.this.vPluginManager.signalCommandCompletion();
1593         }
1594
1595         protected void runTask()
1596         {
1597             if(chosen == null)
1598                 return;
1599
1600             try {
1601                 DiskImage dev;
1602                 if(index < 0)
1603                     dev = pc.getDrives().getHardDrive(-index).getImage();
1604                 else
1605                     dev = pc.getDisks().lookupDisk(index);
1606                 if(dev == null)
1607                     throw new IOException("Trying to dump nonexistent disk");
1608                 OutputStream outb = new BufferedOutputStream(new FileOutputStream(chosen));
1609                 byte[] buf = new byte[512];
1610                 long sectors = dev.getTotalSectors();
1611                 for(long i = 0; i < sectors; i++) {
1612                     dev.read(i, buf, 1);
1613                     outb.write(buf);
1614                 }
1615                 outb.close();
1616                 System.err.println("Informational: Dumped disk image (" + sectors + " sectors).");
1617             } catch(Exception e) {
1618                  caught = e;
1619             }
1620         }
1621     }
1622
1623     private class AssembleTask extends AsyncGUITask
1624     {
1625         Exception caught;
1626         boolean canceled;
1627
1628         public AssembleTask()
1629         {
1630             canceled = false;
1631         }
1632
1633         protected void runPrepare()
1634         {
1635             try {
1636                 configDialog.popUp();
1637             } catch(Exception e) {
1638                 caught = e;
1639             }
1640         }
1641
1642         protected void runFinish()
1643         {
1644             if(caught == null && !canceled) {
1645                 try {
1646                     currentProject.projectID = randomHexes(24);
1647                     currentProject.rerecords = 0;
1648                     currentProject.events = new EventRecorder();
1649                     currentProject.events.attach(pc, null);
1650                     currentProject.savestateID = null;
1651                     currentProject.extraHeaders = null;
1652                     currentProject.events.setRerecordCount(0);
1653                     currentProject.events.setHeaders(currentProject.extraHeaders);
1654                     connectPC(pc);
1655                 } catch(Exception e) {
1656                     caught = e;
1657                 }
1658             }
1659             if(caught != null) {
1660                 errorDialog(caught, "PC Assembly failed", window, "Dismiss");
1661             }
1662             PCControl.this.vPluginManager.signalCommandCompletion();
1663         }
1664
1665         protected void runTask()
1666         {
1667             if(caught != null)
1668                 return;
1669             PC.PCHardwareInfo hw = configDialog.waitClose();
1670             if(hw == null) {
1671                 canceled = true;
1672                 return;
1673             }
1674
1675             try {
1676                 pc = PC.createPC(hw);
1677             } catch(Exception e) {
1678                  caught = e;
1679             }
1680         }
1681     }
1682
1683     private class AddDiskTask extends AsyncGUITask
1684     {
1685         Exception caught;
1686         NewDiskDialog dd;
1687
1688         public AddDiskTask()
1689         {
1690             dd = new NewDiskDialog();
1691         }
1692
1693         protected void runPrepare()
1694         {
1695         }
1696
1697         protected void runFinish()
1698         {
1699             if(caught != null) {
1700                 errorDialog(caught, "Adding disk failed", window, "Dismiss");
1701             }
1702             try {
1703                 updateDisks();
1704             } catch(Exception e) {
1705                 errorDialog(e, "Failed to update disk menus", null, "Dismiss");
1706             }
1707             PCControl.this.vPluginManager.signalCommandCompletion();
1708         }
1709
1710         protected void runTask()
1711         {
1712             NewDiskDialog.Response res = dd.waitClose();
1713             if(res == null) {
1714                 return;
1715             }
1716             try {
1717                 DiskImage img;
1718                 pc.getDisks().addDisk(img = new DiskImage(res.diskFile, false));
1719                 img.setName(res.diskName);
1720             } catch(Exception e) {
1721                 caught = e;
1722             }
1723         }
1724     }
1725
1726     private class ChangeAuthorsTask extends AsyncGUITask
1727     {
1728         Exception caught;
1729         AuthorsDialog ad;
1730
1731         public ChangeAuthorsTask()
1732         {
1733             int authors = 0;
1734             int headers = 0;
1735             AuthorsDialog.AuthorElement[] authorNames = null;
1736             if(currentProject != null)
1737                 authorNames = AuthorsDialog.readAuthorsFromHeaders(currentProject.extraHeaders);
1738
1739             ad = new AuthorsDialog(authorNames);
1740         }
1741
1742         protected void runPrepare()
1743         {
1744         }
1745
1746         protected void runFinish()
1747         {
1748             if(caught != null) {
1749                 errorDialog(caught, "Changing authors failed", window, "Dismiss");
1750             }
1751             PCControl.this.vPluginManager.signalCommandCompletion();
1752         }
1753
1754         protected void runTask()
1755         {
1756             AuthorsDialog.Response res = ad.waitClose();
1757             if(res == null) {
1758                 return;
1759             }
1760             try {
1761                  currentProject.extraHeaders = AuthorsDialog.rewriteHeaderAuthors(currentProject.extraHeaders,
1762                      res.authors);
1763                  currentProject.events.setHeaders(currentProject.extraHeaders);
1764             } catch(Exception e) {
1765                 caught = e;
1766             }
1767         }
1768     }
1769 }