[sgt/puzzles] / PuzzleApplet.java

/*
 * PuzzleApplet.java: NestedVM applet for the puzzle collection
 */
import java.awt.*;
import java.awt.event.*;
import java.awt.image.BufferedImage;
import java.util.*;
import javax.swing.*;
import javax.swing.border.BevelBorder;
import javax.swing.Timer;
import java.util.List;

import org.ibex.nestedvm.Runtime;

public class PuzzleApplet extends JApplet implements Runtime.CallJavaCB {

    private static final long serialVersionUID = 1L;

    private static final int CFG_SETTINGS = 0, CFG_SEED = 1, CFG_DESC = 2,
            LEFT_BUTTON = 0x0200, MIDDLE_BUTTON = 0x201, RIGHT_BUTTON = 0x202,
            LEFT_DRAG = 0x203, MIDDLE_DRAG = 0x204, RIGHT_DRAG = 0x205,
            LEFT_RELEASE = 0x206, CURSOR_UP = 0x209, CURSOR_DOWN = 0x20a,
            CURSOR_LEFT = 0x20b, CURSOR_RIGHT = 0x20c, MOD_CTRL = 0x1000,
            MOD_SHFT = 0x2000, MOD_NUM_KEYPAD = 0x4000, ALIGN_VCENTRE = 0x100,
            ALIGN_HCENTRE = 0x001, ALIGN_HRIGHT = 0x002, C_STRING = 0,
            C_CHOICES = 1, C_BOOLEAN = 2;

    private JFrame mainWindow;

    private JMenu typeMenu;
    private JMenuItem solveCommand;
    private Color[] colors;
    private JLabel statusBar;
    private PuzzlePanel pp;
    private Runtime runtime;
    private String[] puzzle_args;
    private Graphics2D  gg;
    private Timer timer;
    private int xarg1, xarg2, xarg3;
    private int[] xPoints, yPoints;
    private BufferedImage[] blitters = new BufferedImage[512];
    private ConfigDialog dlg;

    static {
        try {
            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    public void init() {
        try {
            Container cp = getContentPane();
            cp.setLayout(new BorderLayout());
            runtime = (Runtime) Class.forName("PuzzleEngine").newInstance();
            runtime.setCallJavaCB(this);
            JMenuBar menubar = new JMenuBar();
            JMenu jm;
            menubar.add(jm = new JMenu("Game"));
            addMenuItemWithKey(jm, "New", 'n');
            addMenuItemCallback(jm, "Restart", "jcallback_restart_event");
            addMenuItemCallback(jm, "Specific...", "jcallback_config_event", CFG_DESC);
            addMenuItemCallback(jm, "Random Seed...", "jcallback_config_event", CFG_SEED);
            jm.addSeparator();
            addMenuItemWithKey(jm, "Undo", 'u');
            addMenuItemWithKey(jm, "Redo", 'r');
            jm.addSeparator();
            solveCommand = addMenuItemCallback(jm, "Solve", "jcallback_solve_event");
            solveCommand.setEnabled(false);
            if (mainWindow != null) {
                jm.addSeparator();
                addMenuItemWithKey(jm, "Exit", 'q');
            }
            menubar.add(typeMenu = new JMenu("Type"));
            typeMenu.setVisible(false);
            menubar.add(jm = new JMenu("Help"));
            addMenuItemCallback(jm, "About", "jcallback_about_event");
            setJMenuBar(menubar);
            cp.add(pp = new PuzzlePanel(), BorderLayout.CENTER);
            pp.addKeyListener(new KeyAdapter() {
                public void keyPressed(KeyEvent e) {
                    int key = -1;
                    int shift = e.isShiftDown() ? MOD_SHFT : 0;
                    int ctrl = e.isControlDown() ? MOD_CTRL : 0;
                    switch (e.getKeyCode()) {
                    case KeyEvent.VK_LEFT:
                    case KeyEvent.VK_KP_LEFT:
                        key = shift | ctrl | CURSOR_LEFT;
                        break;
                    case KeyEvent.VK_RIGHT:
                    case KeyEvent.VK_KP_RIGHT:
                        key = shift | ctrl | CURSOR_RIGHT;
                        break;
                    case KeyEvent.VK_UP:
                    case KeyEvent.VK_KP_UP:
                        key = shift | ctrl | CURSOR_UP;
                        break;
                    case KeyEvent.VK_DOWN:
                    case KeyEvent.VK_KP_DOWN:
                        key = shift | ctrl | CURSOR_DOWN;
                        break;
                    case KeyEvent.VK_PAGE_UP:
                        key = shift | ctrl | MOD_NUM_KEYPAD | '9';
                        break;
                    case KeyEvent.VK_PAGE_DOWN:
                        key = shift | ctrl | MOD_NUM_KEYPAD | '3';
                        break;
                    case KeyEvent.VK_HOME:
                        key = shift | ctrl | MOD_NUM_KEYPAD | '7';
                        break;
                    case KeyEvent.VK_END:
                        key = shift | ctrl | MOD_NUM_KEYPAD | '1';
                        break;
                    default:
                        if (e.getKeyCode() >= KeyEvent.VK_NUMPAD0 && e.getKeyCode() <=KeyEvent.VK_NUMPAD9) {
                            key = MOD_NUM_KEYPAD | (e.getKeyCode() - KeyEvent.VK_NUMPAD0+'0');
                        }
                    break;
                    }
                    if (key != -1) {
                        runtimeCall("jcallback_key_event", new int[] {0, 0, key});
                    }
                }
                public void keyTyped(KeyEvent e) {
                    runtimeCall("jcallback_key_event", new int[] {0, 0, e.getKeyChar()});
                }
            });
            pp.addMouseListener(new MouseAdapter() {
                public void mouseReleased(MouseEvent e) {
                    mousePressedReleased(e, true);
                }
                public void mousePressed(MouseEvent e) {
                    pp.requestFocus();
                    mousePressedReleased(e, false);
                }
                private void mousePressedReleased(MouseEvent e, boolean released) {
                    int button;
                    if ((e.getModifiers() & (InputEvent.BUTTON2_MASK | InputEvent.SHIFT_MASK)) != 0)
                        button = MIDDLE_BUTTON;
                    else if ((e.getModifiers() & (InputEvent.BUTTON3_MASK | InputEvent.ALT_MASK)) != 0)
                        button = RIGHT_BUTTON;
                    else if ((e.getModifiers() & (InputEvent.BUTTON1_MASK)) != 0)
                        button = LEFT_BUTTON;
                    else
                        return;
                    if (released)
                        button += LEFT_RELEASE - LEFT_BUTTON;
                    runtimeCall("jcallback_key_event", new int[] {e.getX(), e.getY(), button});
                }
            });
            pp.addMouseMotionListener(new MouseMotionAdapter() {
                public void mouseDragged(MouseEvent e) {
                    int button;
                    if ((e.getModifiers() & (InputEvent.BUTTON2_MASK | InputEvent.SHIFT_MASK)) != 0)
                        button = MIDDLE_DRAG;
                    else if ((e.getModifiers() & (InputEvent.BUTTON3_MASK | InputEvent.ALT_MASK)) != 0)
                        button = RIGHT_DRAG;
                    else
                        button = LEFT_DRAG;
                    runtimeCall("jcallback_key_event", new int[] {e.getX(), e.getY(), button});
                }
            });
            pp.addComponentListener(new ComponentAdapter() {
                public void componentResized(ComponentEvent e) {
                    handleResized();
                }
            });
            pp.setFocusable(true);
            pp.requestFocus();
            timer = new Timer(20, new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    runtimeCall("jcallback_timer_func", new int[0]);
                }
            });
	    String gameid;
	    try {
		gameid = getParameter("game_id");
	    } catch (java.lang.NullPointerException ex) {
		gameid = null;
	    }
	    if (gameid == null) {
		puzzle_args = null;
	    } else {
		puzzle_args = new String[2];
		puzzle_args[0] = "puzzle";
		puzzle_args[1] = gameid;
	    }
            SwingUtilities.invokeLater(new Runnable() {
                public void run() {
                    runtime.start(puzzle_args);
                    runtime.execute();
                }
            });
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    public void destroy() {
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                runtime.execute();
                if (mainWindow != null) {
                    mainWindow.dispose();
                    System.exit(0);
                }
            }
        });
    }

    protected void handleResized() {
        pp.createBackBuffer(pp.getWidth(), pp.getHeight(), colors[0]);
        runtimeCall("jcallback_resize", new int[] {pp.getWidth(), pp.getHeight()});
    }

    private void addMenuItemWithKey(JMenu jm, String name, int key) {
        addMenuItemCallback(jm, name, "jcallback_menu_key_event", key);
    }

    private JMenuItem addMenuItemCallback(JMenu jm, String name, final String callback, final int arg) {
        return addMenuItemCallback(jm, name, callback, new int[] {arg});
    }

    private JMenuItem addMenuItemCallback(JMenu jm, String name, final String callback) {
        return addMenuItemCallback(jm, name, callback, new int[0]);
    }

    private JMenuItem addMenuItemCallback(JMenu jm, String name, final String callback, final int[] args) {
        JMenuItem jmi;
        if (jm == typeMenu)
            typeMenu.add(jmi = new JCheckBoxMenuItem(name));
        else
        jm.add(jmi = new JMenuItem(name));
        jmi.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                runtimeCall(callback, args);
            }
        });
        return jmi;
    }

    protected void runtimeCall(String func, int[] args) {
        if (runtimeCallWithResult(func, args) == 42 && mainWindow != null) {
            destroy();
        }
    }

    protected int runtimeCallWithResult(String func, int[] args) {
        try {
            return runtime.call(func, args);
        } catch (Runtime.CallException ex) {
            ex.printStackTrace();
            return 42;
        }
    }

    private void buildConfigureMenuItem() {
        if (typeMenu.isVisible()) {
            typeMenu.addSeparator();
        } else {
            typeMenu.setVisible(true);
        }
        addMenuItemCallback(typeMenu, "Custom...", "jcallback_config_event", CFG_SETTINGS);
    }

    private void addTypeItem(String name, final int ptrGameParams) {
        typeMenu.setVisible(true);
        addMenuItemCallback(typeMenu, name, "jcallback_preset_event", ptrGameParams);
    }

    public int call(int cmd, int arg1, int arg2, int arg3) {
        try {
            switch(cmd) {
            case 0: // initialize
                if (mainWindow != null) mainWindow.setTitle(runtime.cstring(arg1));
                if ((arg2 & 1) != 0) buildConfigureMenuItem();
                if ((arg2 & 2) != 0) addStatusBar();
                if ((arg2 & 4) != 0) solveCommand.setEnabled(true);
                colors = new Color[arg3];
                return 0;
            case 1: // Type menu item
                addTypeItem(runtime.cstring(arg1), arg2);
                return 0;
            case 2: // MessageBox
                JOptionPane.showMessageDialog(this, runtime.cstring(arg2), runtime.cstring(arg1), arg3 == 0 ? JOptionPane.INFORMATION_MESSAGE : JOptionPane.ERROR_MESSAGE);
                return 0;
            case 3: // Resize
                pp.setPreferredSize(new Dimension(arg1, arg2));
                if (mainWindow != null) mainWindow.pack();
                handleResized();
                if (mainWindow != null) mainWindow.setVisible(true);
                return 0;
            case 4: // drawing tasks
                switch(arg1) {
                case 0:
		    String text = runtime.cstring(arg2);
		    if (text.equals("")) text = " ";
		    statusBar.setText(text);
		    break;
                case 1:
                    gg = pp.backBuffer.createGraphics();
                    if (arg2 != 0 || arg3 != 0 ||
			arg2 + xarg2 != getWidth() ||
			arg3 + xarg3 != getHeight()) {
			int left = arg2, right = arg2 + xarg2;
			int top = arg3, bottom = arg3 + xarg3;
			int width = getWidth(), height = getHeight();
                        gg.setColor(colors != null ? colors[0] : Color.black);
                        gg.fillRect(0, 0, left, height);
                        gg.fillRect(right, 0, width-right, height);
                        gg.fillRect(0, 0, width, top);
                        gg.fillRect(0, bottom, width, height-bottom);
                        gg.setClip(left, top, right-left, bottom-top);
                    }
                    break;
                case 2: gg.dispose(); pp.repaint(); break;
                case 3: gg.setClip(arg2, arg3, xarg1, xarg2); break;
                case 4:
                    if (arg2 == 0 && arg3 == 0) {
                        gg.setClip(0, 0, getWidth(), getHeight());
                    } else {
                        gg.setClip(arg2, arg3, getWidth()-2*arg2, getHeight()-2*arg3);
                    }
                    break;
                case 5:
                    gg.setColor(colors[xarg3]);
                    gg.fillRect(arg2, arg3, xarg1, xarg2);
                    break;
                case 6:
                    gg.setColor(colors[xarg3]);
                    gg.drawLine(arg2, arg3, xarg1, xarg2);
                    break;
                case 7:
                    xPoints = new int[arg2];
                    yPoints = new int[arg2];
                    break;
                case 8:
                    if (arg3 != -1) {
                        gg.setColor(colors[arg3]);
                        gg.fillPolygon(xPoints, yPoints, xPoints.length);
                    }
                    gg.setColor(colors[arg2]);
                    gg.drawPolygon(xPoints, yPoints, xPoints.length);
                    break;
                case 9:
                    if (arg3 != -1) {
                        gg.setColor(colors[arg3]);
                        gg.fillOval(xarg1-xarg3, xarg2-xarg3, xarg3*2, xarg3*2);
                    }
                    gg.setColor(colors[arg2]);
                    gg.drawOval(xarg1-xarg3, xarg2-xarg3, xarg3*2, xarg3*2);
                    break;
                case 10:
                    for(int i=0; i<blitters.length; i++) {
                        if (blitters[i] == null) {
                            blitters[i] = new BufferedImage(arg2, arg3, BufferedImage.TYPE_3BYTE_BGR);
                            return i;
                        }
                    }
                    throw new RuntimeException("No free blitter found!");
                case 11: blitters[arg2] = null; break;
                case 12:
                    timer.start(); break;
                case 13:
                    timer.stop(); break;
                }
                return 0;
            case 5: // more arguments
                xarg1 = arg1;
                xarg2 = arg2;
                xarg3 = arg3;
                return 0;
            case 6: // polygon vertex
                xPoints[arg1]=arg2;
                yPoints[arg1]=arg3;
                return 0;
            case 7: // string
                gg.setColor(colors[arg2]);
                {
                    String text = runtime.utfstring(arg3);
                    Font ft = new Font((xarg3 & 0x10) != 0 ? "Monospaced" : "Dialog",
                            Font.PLAIN, 100);
                    int height100 = this.getFontMetrics(ft).getHeight();
                    ft = ft.deriveFont(arg1 * 100 / (float)height100);
                    FontMetrics fm = this.getFontMetrics(ft);
                    int asc = fm.getAscent(), desc = fm.getDescent();
                    if ((xarg3 & ALIGN_VCENTRE) != 0)
                        xarg2 += asc - (asc+desc)/2;
                    int wid = fm.stringWidth(text);
                    if ((xarg3 & ALIGN_HCENTRE) != 0)
                        xarg1 -= wid / 2;
                    else if ((xarg3 & ALIGN_HRIGHT) != 0)
                        xarg1 -= wid;
                    gg.setFont(ft);
                    gg.drawString(text, xarg1, xarg2);
                }
                return 0;
            case 8: // blitter_save
                Graphics g2 = blitters[arg1].createGraphics();
                g2.drawImage(pp.backBuffer, 0, 0, blitters[arg1].getWidth(), blitters[arg1].getHeight(),
                        arg2, arg3, arg2 + blitters[arg1].getWidth(), arg3 + blitters[arg1].getHeight(), this);
                g2.dispose();
                return 0;
            case 9: // blitter_load
                gg.drawImage(blitters[arg1], arg2, arg3, this);
                return 0;
            case 10: // dialog_init
                dlg= new ConfigDialog(this, runtime.cstring(arg1));
                return 0;
            case 11: // dialog_add_control
                {
                    int sval_ptr = arg1;
                    int ival = arg2;
                    int ptr = xarg1;
                    int type=xarg2;
                    String name = runtime.cstring(xarg3);
                    switch(type) {
                    case C_STRING:
                        dlg.addTextBox(ptr, name, runtime.cstring(sval_ptr));
                        break;
                    case C_BOOLEAN:
                        dlg.addCheckBox(ptr, name, ival != 0);
                        break;
                    case C_CHOICES:
                        dlg.addComboBox(ptr, name, runtime.cstring(sval_ptr), ival);
                    }
                }
                return 0;
            case 12:
                dlg.finish();
                dlg = null;
                return 0;
            case 13: // tick a menu item
                if (arg1 < 0) arg1 = typeMenu.getItemCount() - 1;
                for (int i = 0; i < typeMenu.getItemCount(); i++) {
                    if (typeMenu.getMenuComponent(i) instanceof JCheckBoxMenuItem) {
                        ((JCheckBoxMenuItem)typeMenu.getMenuComponent(i)).setSelected(arg1 == i);
                    }
                }
                return 0;
            default:
                if (cmd >= 1024 && cmd < 2048) { // palette
                    colors[cmd-1024] = new Color(arg1, arg2, arg3);
                }
            if (cmd == 1024) {
                pp.setBackground(colors[0]);
                if (statusBar != null) statusBar.setBackground(colors[0]);
                this.setBackground(colors[0]);
            }
            return 0;
            }
        } catch (Throwable ex) {
            ex.printStackTrace();
            System.exit(-1);
            return 0;
        }
    }

    private void addStatusBar() {
        statusBar = new JLabel("test");
        statusBar.setBorder(new BevelBorder(BevelBorder.LOWERED));
        getContentPane().add(BorderLayout.SOUTH,statusBar);
    }

    // Standalone runner
    public static void main(String[] args) {
        final PuzzleApplet a = new PuzzleApplet();
        JFrame jf = new JFrame("Loading...");
        jf.getContentPane().setLayout(new BorderLayout());
        jf.getContentPane().add(a, BorderLayout.CENTER);
        a.mainWindow=jf;
        a.init();
        a.start();
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        jf.addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent e) {
                a.stop();
                a.destroy();
            }
        });
        jf.setVisible(true);
    }

    public static class PuzzlePanel extends JPanel {

        private static final long serialVersionUID = 1L;
        protected BufferedImage backBuffer;

        public PuzzlePanel() {
            setPreferredSize(new Dimension(100,100));
            createBackBuffer(100,100, Color.black);
        }

        public void createBackBuffer(int w, int h, Color bg) {
	    if (w > 0 && h > 0) {
		backBuffer = new BufferedImage(w,h, BufferedImage.TYPE_3BYTE_BGR);
		Graphics g = backBuffer.createGraphics();
		g.setColor(bg);
		g.fillRect(0, 0, w, h);
		g.dispose();
	    }
        }

        protected void paintComponent(Graphics g) {
            g.drawImage(backBuffer, 0, 0, this);
        }
    }

    public static class ConfigComponent {
        public int type;
        public int configItemPointer;
        public JComponent component;

        public ConfigComponent(int type, int configItemPointer, JComponent component) {
            this.type = type;
            this.configItemPointer = configItemPointer;
            this.component = component;
        }
    }

    public class ConfigDialog extends JDialog {

        private GridBagConstraints gbcLeft = new GridBagConstraints(
                GridBagConstraints.RELATIVE, GridBagConstraints.RELATIVE, 1, 1,
                0, 0, GridBagConstraints.WEST, GridBagConstraints.NONE,
                new Insets(0, 0, 0, 0), 0, 0);
        private GridBagConstraints gbcRight = new GridBagConstraints(
                GridBagConstraints.RELATIVE, GridBagConstraints.RELATIVE,
                GridBagConstraints.REMAINDER, 1, 1.0, 0,
                GridBagConstraints.CENTER, GridBagConstraints.HORIZONTAL,
                new Insets(5, 5, 5, 5), 0, 0);
        private GridBagConstraints gbcBottom = new GridBagConstraints(
                GridBagConstraints.RELATIVE, GridBagConstraints.RELATIVE,
                GridBagConstraints.REMAINDER, GridBagConstraints.REMAINDER,
                1.0, 1.0, GridBagConstraints.CENTER,
                GridBagConstraints.HORIZONTAL, new Insets(5, 5, 5, 5), 0, 0);

        private static final long serialVersionUID = 1L;
        private List components = new ArrayList();

        public ConfigDialog(JApplet parent, String title) {
            super(JOptionPane.getFrameForComponent(parent), title, true);
            getContentPane().setLayout(new GridBagLayout());
        }

        public void addTextBox(int ptr, String name, String value) {
            getContentPane().add(new JLabel(name), gbcLeft);
            JComponent c = new JTextField(value, 25);
            getContentPane().add(c, gbcRight);
            components.add(new ConfigComponent(C_STRING, ptr, c));
        }


        public void addCheckBox(int ptr, String name, boolean selected) {
            JComponent c = new JCheckBox(name, selected);
            getContentPane().add(c, gbcRight);
            components.add(new ConfigComponent(C_BOOLEAN, ptr, c));
        }

        public void addComboBox(int ptr, String name, String values, int selected) {
            getContentPane().add(new JLabel(name), gbcLeft);
            StringTokenizer st = new StringTokenizer(values.substring(1), values.substring(0,1));
            JComboBox c = new JComboBox();
            c.setEditable(false);
            while(st.hasMoreTokens())
                c.addItem(st.nextToken());
            c.setSelectedIndex(selected);
            getContentPane().add(c, gbcRight);
            components.add(new ConfigComponent(C_CHOICES, ptr, c));
        }

        public void finish() {
            JPanel buttons = new JPanel(new GridLayout(1, 2, 5, 5));
            getContentPane().add(buttons, gbcBottom);
            JButton b;
            buttons.add(b=new JButton("OK"));
            b.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    save();
                    dispose();
                }
            });
            getRootPane().setDefaultButton(b);
            buttons.add(b=new JButton("Cancel"));
            b.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    dispose();
                }
            });
            setDefaultCloseOperation(DISPOSE_ON_CLOSE);
            pack();
            setLocationRelativeTo(null);
            setVisible(true);
        }
        private void save() {
            for (int i = 0; i < components.size(); i++) {
                ConfigComponent cc = (ConfigComponent) components.get(i);
                switch(cc.type) {
                case C_STRING:
                    JTextField jtf = (JTextField)cc.component;
                    runtimeCall("jcallback_config_set_string", new int[] {cc.configItemPointer, runtime.strdup(jtf.getText())});
                    break;
                case C_BOOLEAN:
                    JCheckBox jcb = (JCheckBox)cc.component;
                    runtimeCall("jcallback_config_set_boolean", new int[] {cc.configItemPointer, jcb.isSelected()?1:0});
                    break;
                case C_CHOICES:
                    JComboBox jcm = (JComboBox)cc.component;
                    runtimeCall("jcallback_config_set_choice", new int[] {cc.configItemPointer, jcm.getSelectedIndex()});
                    break;
                }
            }
            runtimeCall("jcallback_config_ok", new int[0]);
        }
    }
}
Commit	Line	Data
2c930807	1	/*
	2	* PuzzleApplet.java: NestedVM applet for the puzzle collection
	3	*/
	4	import java.awt.*;
	5	import java.awt.event.*;
	6	import java.awt.image.BufferedImage;
	7	import java.util.*;
	8	import javax.swing.*;
	9	import javax.swing.border.BevelBorder;
	10	import javax.swing.Timer;
	11	import java.util.List;
	12
	13	import org.ibex.nestedvm.Runtime;
	14
	15	public class PuzzleApplet extends JApplet implements Runtime.CallJavaCB {
	16
	17	private static final long serialVersionUID = 1L;
	18
	19	private static final int CFG_SETTINGS = 0, CFG_SEED = 1, CFG_DESC = 2,
	20	LEFT_BUTTON = 0x0200, MIDDLE_BUTTON = 0x201, RIGHT_BUTTON = 0x202,
	21	LEFT_DRAG = 0x203, MIDDLE_DRAG = 0x204, RIGHT_DRAG = 0x205,
	22	LEFT_RELEASE = 0x206, CURSOR_UP = 0x209, CURSOR_DOWN = 0x20a,
	23	CURSOR_LEFT = 0x20b, CURSOR_RIGHT = 0x20c, MOD_CTRL = 0x1000,
	24	MOD_SHFT = 0x2000, MOD_NUM_KEYPAD = 0x4000, ALIGN_VCENTRE = 0x100,
	25	ALIGN_HCENTRE = 0x001, ALIGN_HRIGHT = 0x002, C_STRING = 0,
	26	C_CHOICES = 1, C_BOOLEAN = 2;
	27
	28	private JFrame mainWindow;
	29
	30	private JMenu typeMenu;
	31	private JMenuItem solveCommand;
	32	private Color[] colors;
	33	private JLabel statusBar;
	34	private PuzzlePanel pp;
	35	private Runtime runtime;
cbbe322f	36	private String[] puzzle_args;
2c930807	37	private Graphics2D gg;
	38	private Timer timer;
	39	private int xarg1, xarg2, xarg3;
	40	private int[] xPoints, yPoints;
	41	private BufferedImage[] blitters = new BufferedImage[512];
	42	private ConfigDialog dlg;
	43
	44	static {
	45	try {
	46	UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
	47	} catch (Exception ex) {
	48	ex.printStackTrace();
	49	}
	50	}
	51
	52	public void init() {
	53	try {
	54	Container cp = getContentPane();
	55	cp.setLayout(new BorderLayout());
	56	runtime = (Runtime) Class.forName("PuzzleEngine").newInstance();
	57	runtime.setCallJavaCB(this);
	58	JMenuBar menubar = new JMenuBar();
	59	JMenu jm;
	60	menubar.add(jm = new JMenu("Game"));
	61	addMenuItemWithKey(jm, "New", 'n');
	62	addMenuItemCallback(jm, "Restart", "jcallback_restart_event");
	63	addMenuItemCallback(jm, "Specific...", "jcallback_config_event", CFG_DESC);
	64	addMenuItemCallback(jm, "Random Seed...", "jcallback_config_event", CFG_SEED);
	65	jm.addSeparator();
	66	addMenuItemWithKey(jm, "Undo", 'u');
	67	addMenuItemWithKey(jm, "Redo", 'r');
	68	jm.addSeparator();
	69	solveCommand = addMenuItemCallback(jm, "Solve", "jcallback_solve_event");
	70	solveCommand.setEnabled(false);
	71	if (mainWindow != null) {
	72	jm.addSeparator();
	73	addMenuItemWithKey(jm, "Exit", 'q');
	74	}
	75	menubar.add(typeMenu = new JMenu("Type"));
	76	typeMenu.setVisible(false);
	77	menubar.add(jm = new JMenu("Help"));
	78	addMenuItemCallback(jm, "About", "jcallback_about_event");
	79	setJMenuBar(menubar);
	80	cp.add(pp = new PuzzlePanel(), BorderLayout.CENTER);
	81	pp.addKeyListener(new KeyAdapter() {
	82	public void keyPressed(KeyEvent e) {
	83	int key = -1;
	84	int shift = e.isShiftDown() ? MOD_SHFT : 0;
	85	int ctrl = e.isControlDown() ? MOD_CTRL : 0;
	86	switch (e.getKeyCode()) {
	87	case KeyEvent.VK_LEFT:
	88	case KeyEvent.VK_KP_LEFT:
	89	key = shift \| ctrl \| CURSOR_LEFT;
	90	break;
	91	case KeyEvent.VK_RIGHT:
	92	case KeyEvent.VK_KP_RIGHT:
	93	key = shift \| ctrl \| CURSOR_RIGHT;
	94	break;
	95	case KeyEvent.VK_UP:
	96	case KeyEvent.VK_KP_UP:
	97	key = shift \| ctrl \| CURSOR_UP;
	98	break;
	99	case KeyEvent.VK_DOWN:
	100	case KeyEvent.VK_KP_DOWN:
101	key = shift \| ctrl \| CURSOR_DOWN;
102	break;
103	case KeyEvent.VK_PAGE_UP:
104	key = shift \| ctrl \| MOD_NUM_KEYPAD \| '9';
105	break;
106	case KeyEvent.VK_PAGE_DOWN:
107	key = shift \| ctrl \| MOD_NUM_KEYPAD \| '3';
108	break;
109	case KeyEvent.VK_HOME:
110	key = shift \| ctrl \| MOD_NUM_KEYPAD \| '7';
111	break;
112	case KeyEvent.VK_END:
113	key = shift \| ctrl \| MOD_NUM_KEYPAD \| '1';
114	break;
115	default:
116	if (e.getKeyCode() >= KeyEvent.VK_NUMPAD0 && e.getKeyCode() <=KeyEvent.VK_NUMPAD9) {
117	key = MOD_NUM_KEYPAD \| (e.getKeyCode() - KeyEvent.VK_NUMPAD0+'0');
118	}
119	break;
120	}
121	if (key != -1) {
122	runtimeCall("jcallback_key_event", new int[] {0, 0, key});
123	}
124	}
125	public void keyTyped(KeyEvent e) {
126	runtimeCall("jcallback_key_event", new int[] {0, 0, e.getKeyChar()});
127	}
128	});
129	pp.addMouseListener(new MouseAdapter() {
130	public void mouseReleased(MouseEvent e) {
131	mousePressedReleased(e, true);
132	}
133	public void mousePressed(MouseEvent e) {
134	pp.requestFocus();
135	mousePressedReleased(e, false);
136	}
137	private void mousePressedReleased(MouseEvent e, boolean released) {
138	int button;
139	if ((e.getModifiers() & (InputEvent.BUTTON2_MASK \| InputEvent.SHIFT_MASK)) != 0)
140	button = MIDDLE_BUTTON;
141	else if ((e.getModifiers() & (InputEvent.BUTTON3_MASK \| InputEvent.ALT_MASK)) != 0)
142	button = RIGHT_BUTTON;
143	else if ((e.getModifiers() & (InputEvent.BUTTON1_MASK)) != 0)
144	button = LEFT_BUTTON;
145	else
146	return;
147	if (released)
148	button += LEFT_RELEASE - LEFT_BUTTON;
149	runtimeCall("jcallback_key_event", new int[] {e.getX(), e.getY(), button});
150	}
151	});
152	pp.addMouseMotionListener(new MouseMotionAdapter() {
153	public void mouseDragged(MouseEvent e) {
154	int button;
155	if ((e.getModifiers() & (InputEvent.BUTTON2_MASK \| InputEvent.SHIFT_MASK)) != 0)
156	button = MIDDLE_DRAG;
157	else if ((e.getModifiers() & (InputEvent.BUTTON3_MASK \| InputEvent.ALT_MASK)) != 0)
158	button = RIGHT_DRAG;
159	else
160	button = LEFT_DRAG;
161	runtimeCall("jcallback_key_event", new int[] {e.getX(), e.getY(), button});
162	}
163	});
164	pp.addComponentListener(new ComponentAdapter() {
165	public void componentResized(ComponentEvent e) {
166	handleResized();
167	}
168	});
169	pp.setFocusable(true);
170	pp.requestFocus();
171	timer = new Timer(20, new ActionListener() {
172	public void actionPerformed(ActionEvent e) {
173	runtimeCall("jcallback_timer_func", new int[0]);
174	}
175	});
cbbe322f	176	String gameid;
	177	try {
	178	gameid = getParameter("game_id");
	179	} catch (java.lang.NullPointerException ex) {
	180	gameid = null;
	181	}
cbbe322f	182	if (gameid == null) {
	183	puzzle_args = null;
	184	} else {
	185	puzzle_args = new String[2];
	186	puzzle_args[0] = "puzzle";
	187	puzzle_args[1] = gameid;
	188	}
2c930807	189	SwingUtilities.invokeLater(new Runnable() {
2c930807	190	public void run() {
cbbe322f	191	runtime.start(puzzle_args);
2c930807	192	runtime.execute();
	193	}
	194	});
	195	} catch (Exception ex) {
	196	ex.printStackTrace();
	197	}
	198	}
	199
	200	public void destroy() {
	201	SwingUtilities.invokeLater(new Runnable() {
	202	public void run() {
	203	runtime.execute();
	204	if (mainWindow != null) {
	205	mainWindow.dispose();
	206	System.exit(0);
	207	}
	208	}
	209	});
	210	}
	211
	212	protected void handleResized() {
	213	pp.createBackBuffer(pp.getWidth(), pp.getHeight(), colors[0]);
	214	runtimeCall("jcallback_resize", new int[] {pp.getWidth(), pp.getHeight()});
	215	}
	216
	217	private void addMenuItemWithKey(JMenu jm, String name, int key) {
	218	addMenuItemCallback(jm, name, "jcallback_menu_key_event", key);
	219	}
	220
	221	private JMenuItem addMenuItemCallback(JMenu jm, String name, final String callback, final int arg) {
	222	return addMenuItemCallback(jm, name, callback, new int[] {arg});
	223	}
	224
	225	private JMenuItem addMenuItemCallback(JMenu jm, String name, final String callback) {
	226	return addMenuItemCallback(jm, name, callback, new int[0]);
	227	}
	228
	229	private JMenuItem addMenuItemCallback(JMenu jm, String name, final String callback, final int[] args) {
	230	JMenuItem jmi;
	231	if (jm == typeMenu)
	232	typeMenu.add(jmi = new JCheckBoxMenuItem(name));
	233	else
	234	jm.add(jmi = new JMenuItem(name));
	235	jmi.addActionListener(new ActionListener() {
	236	public void actionPerformed(ActionEvent e) {
	237	runtimeCall(callback, args);
	238	}
	239	});
	240	return jmi;
	241	}
	242
	243	protected void runtimeCall(String func, int[] args) {
	244	if (runtimeCallWithResult(func, args) == 42 && mainWindow != null) {
	245	destroy();
	246	}
	247	}
	248
	249	protected int runtimeCallWithResult(String func, int[] args) {
	250	try {
	251	return runtime.call(func, args);
	252	} catch (Runtime.CallException ex) {
	253	ex.printStackTrace();
	254	return 42;
	255	}
256	}
257
258	private void buildConfigureMenuItem() {
259	if (typeMenu.isVisible()) {
260	typeMenu.addSeparator();
261	} else {
262	typeMenu.setVisible(true);
263	}
264	addMenuItemCallback(typeMenu, "Custom...", "jcallback_config_event", CFG_SETTINGS);
265	}
266
267	private void addTypeItem(String name, final int ptrGameParams) {
268	typeMenu.setVisible(true);
269	addMenuItemCallback(typeMenu, name, "jcallback_preset_event", ptrGameParams);
270	}
271
272	public int call(int cmd, int arg1, int arg2, int arg3) {
273	try {
274	switch(cmd) {
275	case 0: // initialize
276	if (mainWindow != null) mainWindow.setTitle(runtime.cstring(arg1));
277	if ((arg2 & 1) != 0) buildConfigureMenuItem();
278	if ((arg2 & 2) != 0) addStatusBar();
279	if ((arg2 & 4) != 0) solveCommand.setEnabled(true);
280	colors = new Color[arg3];
281	return 0;
282	case 1: // Type menu item
283	addTypeItem(runtime.cstring(arg1), arg2);
284	return 0;
285	case 2: // MessageBox
286	JOptionPane.showMessageDialog(this, runtime.cstring(arg2), runtime.cstring(arg1), arg3 == 0 ? JOptionPane.INFORMATION_MESSAGE : JOptionPane.ERROR_MESSAGE);
287	return 0;
288	case 3: // Resize
289	pp.setPreferredSize(new Dimension(arg1, arg2));
290	if (mainWindow != null) mainWindow.pack();
291	handleResized();
292	if (mainWindow != null) mainWindow.setVisible(true);
293	return 0;
294	case 4: // drawing tasks
295	switch(arg1) {
296	case 0:
297	String text = runtime.cstring(arg2);
298	if (text.equals("")) text = " ";
047f95bc	299	statusBar.setText(text);
047f95bc	300	break;
2c930807	301	case 1:
2c930807	302	gg = pp.backBuffer.createGraphics();
047f95bc	303	if (arg2 != 0 \|\| arg3 != 0 \|\|
	304	arg2 + xarg2 != getWidth() \|\|
	305	arg3 + xarg3 != getHeight()) {
	306	int left = arg2, right = arg2 + xarg2;
	307	int top = arg3, bottom = arg3 + xarg3;
	308	int width = getWidth(), height = getHeight();
8e5a23b9	309	gg.setColor(colors != null ? colors[0] : Color.black);
047f95bc	310	gg.fillRect(0, 0, left, height);
	311	gg.fillRect(right, 0, width-right, height);
	312	gg.fillRect(0, 0, width, top);
	313	gg.fillRect(0, bottom, width, height-bottom);
	314	gg.setClip(left, top, right-left, bottom-top);
2c930807	315	}
	316	break;
	317	case 2: gg.dispose(); pp.repaint(); break;
	318	case 3: gg.setClip(arg2, arg3, xarg1, xarg2); break;
	319	case 4:
	320	if (arg2 == 0 && arg3 == 0) {
99efed51	321	gg.setClip(0, 0, getWidth(), getHeight());
2c930807	322	} else {
	323	gg.setClip(arg2, arg3, getWidth()-2arg2, getHeight()-2arg3);
	324	}
	325	break;
	326	case 5:
	327	gg.setColor(colors[xarg3]);
	328	gg.fillRect(arg2, arg3, xarg1, xarg2);
	329	break;
	330	case 6:
	331	gg.setColor(colors[xarg3]);
	332	gg.drawLine(arg2, arg3, xarg1, xarg2);
	333	break;
	334	case 7:
	335	xPoints = new int[arg2];
	336	yPoints = new int[arg2];
	337	break;
	338	case 8:
	339	if (arg3 != -1) {
	340	gg.setColor(colors[arg3]);
	341	gg.fillPolygon(xPoints, yPoints, xPoints.length);
	342	}
	343	gg.setColor(colors[arg2]);
	344	gg.drawPolygon(xPoints, yPoints, xPoints.length);
	345	break;
	346	case 9:
	347	if (arg3 != -1) {
	348	gg.setColor(colors[arg3]);
	349	gg.fillOval(xarg1-xarg3, xarg2-xarg3, xarg32, xarg32);
	350	}
	351	gg.setColor(colors[arg2]);
	352	gg.drawOval(xarg1-xarg3, xarg2-xarg3, xarg32, xarg32);
	353	break;
	354	case 10:
	355	for(int i=0; i<blitters.length; i++) {
	356	if (blitters[i] == null) {
	357	blitters[i] = new BufferedImage(arg2, arg3, BufferedImage.TYPE_3BYTE_BGR);
	358	return i;
	359	}
	360	}
	361	throw new RuntimeException("No free blitter found!");
	362	case 11: blitters[arg2] = null; break;
	363	case 12:
	364	timer.start(); break;
	365	case 13:
	366	timer.stop(); break;
	367	}
	368	return 0;
	369	case 5: // more arguments
	370	xarg1 = arg1;
	371	xarg2 = arg2;
	372	xarg3 = arg3;
	373	return 0;
	374	case 6: // polygon vertex
	375	xPoints[arg1]=arg2;
	376	yPoints[arg1]=arg3;
	377	return 0;
	378	case 7: // string
	379	gg.setColor(colors[arg2]);
	380	{
4011952c	381	String text = runtime.utfstring(arg3);
2c930807	382	Font ft = new Font((xarg3 & 0x10) != 0 ? "Monospaced" : "Dialog",
	383	Font.PLAIN, 100);
	384	int height100 = this.getFontMetrics(ft).getHeight();
	385	ft = ft.deriveFont(arg1 * 100 / (float)height100);
	386	FontMetrics fm = this.getFontMetrics(ft);
	387	int asc = fm.getAscent(), desc = fm.getDescent();
	388	if ((xarg3 & ALIGN_VCENTRE) != 0)
	389	xarg2 += asc - (asc+desc)/2;
2c930807	390	int wid = fm.stringWidth(text);
	391	if ((xarg3 & ALIGN_HCENTRE) != 0)
	392	xarg1 -= wid / 2;
	393	else if ((xarg3 & ALIGN_HRIGHT) != 0)
	394	xarg1 -= wid;
	395	gg.setFont(ft);
	396	gg.drawString(text, xarg1, xarg2);
	397	}
	398	return 0;
	399	case 8: // blitter_save
	400	Graphics g2 = blitters[arg1].createGraphics();
	401	g2.drawImage(pp.backBuffer, 0, 0, blitters[arg1].getWidth(), blitters[arg1].getHeight(),
	402	arg2, arg3, arg2 + blitters[arg1].getWidth(), arg3 + blitters[arg1].getHeight(), this);
	403	g2.dispose();
	404	return 0;
	405	case 9: // blitter_load
	406	gg.drawImage(blitters[arg1], arg2, arg3, this);
	407	return 0;
	408	case 10: // dialog_init
	409	dlg= new ConfigDialog(this, runtime.cstring(arg1));
	410	return 0;
	411	case 11: // dialog_add_control
	412	{
	413	int sval_ptr = arg1;
	414	int ival = arg2;
	415	int ptr = xarg1;
	416	int type=xarg2;
	417	String name = runtime.cstring(xarg3);
	418	switch(type) {
	419	case C_STRING:
	420	dlg.addTextBox(ptr, name, runtime.cstring(sval_ptr));
	421	break;
	422	case C_BOOLEAN:
	423	dlg.addCheckBox(ptr, name, ival != 0);
	424	break;
	425	case C_CHOICES:
	426	dlg.addComboBox(ptr, name, runtime.cstring(sval_ptr), ival);
	427	}
	428	}
	429	return 0;
	430	case 12:
	431	dlg.finish();
	432	dlg = null;
	433	return 0;
	434	case 13: // tick a menu item
	435	if (arg1 < 0) arg1 = typeMenu.getItemCount() - 1;
	436	for (int i = 0; i < typeMenu.getItemCount(); i++) {
	437	if (typeMenu.getMenuComponent(i) instanceof JCheckBoxMenuItem) {
	438	((JCheckBoxMenuItem)typeMenu.getMenuComponent(i)).setSelected(arg1 == i);
	439	}
	440	}
	441	return 0;
	442	default:
	443	if (cmd >= 1024 && cmd < 2048) { // palette
	444	colors[cmd-1024] = new Color(arg1, arg2, arg3);
	445	}
	446	if (cmd == 1024) {
	447	pp.setBackground(colors[0]);
	448	if (statusBar != null) statusBar.setBackground(colors[0]);
	449	this.setBackground(colors[0]);
	450	}
	451	return 0;
	452	}
	453	} catch (Throwable ex) {
454	ex.printStackTrace();
455	System.exit(-1);
456	return 0;
457	}
458	}
459
460	private void addStatusBar() {
461	statusBar = new JLabel("test");
462	statusBar.setBorder(new BevelBorder(BevelBorder.LOWERED));
463	getContentPane().add(BorderLayout.SOUTH,statusBar);
464	}
465
466	// Standalone runner
467	public static void main(String[] args) {
468	final PuzzleApplet a = new PuzzleApplet();
469	JFrame jf = new JFrame("Loading...");
470	jf.getContentPane().setLayout(new BorderLayout());
471	jf.getContentPane().add(a, BorderLayout.CENTER);
472	a.mainWindow=jf;
473	a.init();
474	a.start();
475	jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
476	jf.addWindowListener(new WindowAdapter() {
477	public void windowClosing(WindowEvent e) {
478	a.stop();
479	a.destroy();
480	}
481	});
482	jf.setVisible(true);
483	}
484
485	public static class PuzzlePanel extends JPanel {
486
487	private static final long serialVersionUID = 1L;
488	protected BufferedImage backBuffer;
489
490	public PuzzlePanel() {
491	setPreferredSize(new Dimension(100,100));
492	createBackBuffer(100,100, Color.black);
493	}
494
495	public void createBackBuffer(int w, int h, Color bg) {
cb22d3a6	496	if (w > 0 && h > 0) {
	497	backBuffer = new BufferedImage(w,h, BufferedImage.TYPE_3BYTE_BGR);
	498	Graphics g = backBuffer.createGraphics();
	499	g.setColor(bg);
	500	g.fillRect(0, 0, w, h);
	501	g.dispose();
	502	}
2c930807	503	}
	504
	505	protected void paintComponent(Graphics g) {
	506	g.drawImage(backBuffer, 0, 0, this);
	507	}
	508	}
	509
	510	public static class ConfigComponent {
	511	public int type;
	512	public int configItemPointer;
	513	public JComponent component;
	514
	515	public ConfigComponent(int type, int configItemPointer, JComponent component) {
	516	this.type = type;
	517	this.configItemPointer = configItemPointer;
	518	this.component = component;
	519	}
	520	}
	521
	522	public class ConfigDialog extends JDialog {
	523
	524	private GridBagConstraints gbcLeft = new GridBagConstraints(
	525	GridBagConstraints.RELATIVE, GridBagConstraints.RELATIVE, 1, 1,
	526	0, 0, GridBagConstraints.WEST, GridBagConstraints.NONE,
	527	new Insets(0, 0, 0, 0), 0, 0);
	528	private GridBagConstraints gbcRight = new GridBagConstraints(
	529	GridBagConstraints.RELATIVE, GridBagConstraints.RELATIVE,
	530	GridBagConstraints.REMAINDER, 1, 1.0, 0,
	531	GridBagConstraints.CENTER, GridBagConstraints.HORIZONTAL,
	532	new Insets(5, 5, 5, 5), 0, 0);
	533	private GridBagConstraints gbcBottom = new GridBagConstraints(
	534	GridBagConstraints.RELATIVE, GridBagConstraints.RELATIVE,
	535	GridBagConstraints.REMAINDER, GridBagConstraints.REMAINDER,
	536	1.0, 1.0, GridBagConstraints.CENTER,
	537	GridBagConstraints.HORIZONTAL, new Insets(5, 5, 5, 5), 0, 0);
	538
	539	private static final long serialVersionUID = 1L;
	540	private List components = new ArrayList();
	541
	542	public ConfigDialog(JApplet parent, String title) {
	543	super(JOptionPane.getFrameForComponent(parent), title, true);
	544	getContentPane().setLayout(new GridBagLayout());
	545	}
	546
	547	public void addTextBox(int ptr, String name, String value) {
	548	getContentPane().add(new JLabel(name), gbcLeft);
	549	JComponent c = new JTextField(value, 25);
	550	getContentPane().add(c, gbcRight);
	551	components.add(new ConfigComponent(C_STRING, ptr, c));
	552	}
	553
	554
	555	public void addCheckBox(int ptr, String name, boolean selected) {
	556	JComponent c = new JCheckBox(name, selected);
	557	getContentPane().add(c, gbcRight);
	558	components.add(new ConfigComponent(C_BOOLEAN, ptr, c));
	559	}
	560
	561	public void addComboBox(int ptr, String name, String values, int selected) {
	562	getContentPane().add(new JLabel(name), gbcLeft);
	563	StringTokenizer st = new StringTokenizer(values.substring(1), values.substring(0,1));
	564	JComboBox c = new JComboBox();
	565	c.setEditable(false);
	566	while(st.hasMoreTokens())
567	c.addItem(st.nextToken());
568	c.setSelectedIndex(selected);
569	getContentPane().add(c, gbcRight);
570	components.add(new ConfigComponent(C_CHOICES, ptr, c));
571	}
572
573	public void finish() {
574	JPanel buttons = new JPanel(new GridLayout(1, 2, 5, 5));
575	getContentPane().add(buttons, gbcBottom);
576	JButton b;
577	buttons.add(b=new JButton("OK"));
578	b.addActionListener(new ActionListener() {
579	public void actionPerformed(ActionEvent e) {
580	save();
581	dispose();
582	}
583	});
584	getRootPane().setDefaultButton(b);
585	buttons.add(b=new JButton("Cancel"));
586	b.addActionListener(new ActionListener() {
587	public void actionPerformed(ActionEvent e) {
588	dispose();
589	}
590	});
591	setDefaultCloseOperation(DISPOSE_ON_CLOSE);
592	pack();
593	setLocationRelativeTo(null);
594	setVisible(true);
595	}
596	private void save() {
597	for (int i = 0; i < components.size(); i++) {
598	ConfigComponent cc = (ConfigComponent) components.get(i);
599	switch(cc.type) {
600	case C_STRING:
601	JTextField jtf = (JTextField)cc.component;
602	runtimeCall("jcallback_config_set_string", new int[] {cc.configItemPointer, runtime.strdup(jtf.getText())});
603	break;
604	case C_BOOLEAN:
605	JCheckBox jcb = (JCheckBox)cc.component;
606	runtimeCall("jcallback_config_set_boolean", new int[] {cc.configItemPointer, jcb.isSelected()?1:0});
607	break;
608	case C_CHOICES:
609	JComboBox jcm = (JComboBox)cc.component;
f87c357f	610	runtimeCall("jcallback_config_set_choice", new int[] {cc.configItemPointer, jcm.getSelectedIndex()});
2c930807	611	break;
	612	}
	613	}
	614	runtimeCall("jcallback_config_ok", new int[0]);
	615	}
	616	}
	617	}