37e9e9935c
Prefer not to have edgy references to child sexual assault in our tools. Consider that victims of such violence may well grow up to become ROM hackers just as often as the rest of us. Let's not be rude to them!
5034 lines
No EOL
166 KiB
Java
5034 lines
No EOL
166 KiB
Java
/*
|
|
*
|
|
* Copyright (C) 2003 Kent Hansen.
|
|
*
|
|
* This file is part of Tile Mangler.
|
|
*
|
|
* Tile Mangler is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* Tile Mangler is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
*/
|
|
|
|
package tm.ui;
|
|
|
|
import tm.*;
|
|
import tm.colorcodecs.*;
|
|
import tm.tilecodecs.*;
|
|
import tm.fileselection.*;
|
|
import tm.modaldialog.*;
|
|
import tm.treenodes.*;
|
|
import tm.utils.*;
|
|
import tm.threads.*;
|
|
import tm.filelistener.*;
|
|
import tm.canvases.*;
|
|
import javax.swing.*;
|
|
import javax.swing.event.*;
|
|
import java.awt.*;
|
|
import java.awt.event.*;
|
|
import java.io.*;
|
|
import javax.swing.border.*;
|
|
import javax.swing.filechooser.FileFilter;
|
|
import javax.swing.plaf.ButtonUI;
|
|
import javax.swing.plaf.ComponentUI;
|
|
import javax.swing.plaf.ToolBarUI;
|
|
|
|
import java.util.Locale;
|
|
import java.util.Vector;
|
|
import java.util.Hashtable;
|
|
import java.util.StringTokenizer;
|
|
import org.w3c.dom.Document;
|
|
import org.w3c.dom.Element;
|
|
import org.w3c.dom.NodeList;
|
|
import java.io.IOException;
|
|
import javax.xml.parsers.ParserConfigurationException;
|
|
import org.xml.sax.SAXException;
|
|
import org.xml.sax.SAXParseException;
|
|
|
|
/**
|
|
*
|
|
* The main UI window.
|
|
* Has a desktop for child frames, a menu, toolbars, a palette panel, and a statusbar.
|
|
* The code is mainly dominated by
|
|
* 1) setting up the various menus and toolbars; and
|
|
* 2) providing action handlers for menu items and tool buttons.
|
|
*
|
|
**/
|
|
|
|
public class TMUI extends JFrame {
|
|
|
|
private static String OS = System.getProperty("os.name").toLowerCase();
|
|
public static boolean isLinux = OS.indexOf("nix") >= 0 || OS.indexOf("nux") >= 0 || OS.indexOf("aix") > 0;
|
|
public static boolean isWindows = OS.indexOf("win") >= 0;
|
|
|
|
// tool types
|
|
public static final int SELECT_TOOL = 1;
|
|
public static final int ZOOM_TOOL = 2;
|
|
public static final int PICKUP_TOOL = 3;
|
|
public static final int BRUSH_TOOL = 4;
|
|
public static final int LINE_TOOL = 5;
|
|
public static final int FILL_TOOL = 6;
|
|
public static final int REPLACE_TOOL = 7;
|
|
public static final int MOVE_TOOL = 8;
|
|
|
|
private int tool = SELECT_TOOL;
|
|
private int previousTool;
|
|
|
|
private int maxRecentFiles = 10;
|
|
private Vector recentFiles = new Vector();
|
|
private Vector colorcodecs;
|
|
private Vector tilecodecs;
|
|
private Vector filefilters;
|
|
private Vector palettefilters;
|
|
private Vector filelisteners;
|
|
|
|
private TMSelectionCanvas copiedSelection=null;
|
|
|
|
// UI components
|
|
private mxScrollableDesktop desktop = new mxScrollableDesktop();
|
|
private TMStatusBar statusBar = new TMStatusBar();
|
|
private JToolBar toolBar = new JToolBar(JToolBar.HORIZONTAL);
|
|
private JToolBar toolPalette = new JToolBar(JToolBar.VERTICAL);
|
|
private JToolBar selectionToolBar = new JToolBar(JToolBar.VERTICAL);
|
|
private JToolBar navBar = new JToolBar(JToolBar.HORIZONTAL);
|
|
private JMenuBar menuBar = new JMenuBar();
|
|
private JPanel toolPane = new JPanel(); // the drawing tools and such
|
|
private JPanel toolBarPane = new JPanel(); // the program toolbars
|
|
private JPanel bottomPane = new JPanel(); // palette and statusbar
|
|
private TMPalettePane palettePane;
|
|
|
|
// file choosers
|
|
private TMApprovedFileOpenChooser fileOpenChooser = new TMApprovedFileOpenChooser();
|
|
private TMApprovedFileSaveChooser fileSaveChooser = new TMApprovedFileSaveChooser();
|
|
private TMApprovedFileOpenChooser bitmapOpenChooser = new TMApprovedFileOpenChooser();
|
|
private TMApprovedFileSaveChooser bitmapSaveChooser = new TMApprovedFileSaveChooser();
|
|
private TMApprovedFileOpenChooser paletteOpenChooser = new TMApprovedFileOpenChooser();
|
|
|
|
private TMBitmapFilters bmf = new TMBitmapFilters();
|
|
private TMFileFilter allFilter = new AllFilter();
|
|
|
|
// custom dialogs
|
|
private TMGoToDialog goToDialog;
|
|
private TMNewFileDialog newFileDialog;
|
|
private TMCustomCodecDialog customCodecDialog;
|
|
private TMStretchDialog stretchDialog;
|
|
private TMCanvasSizeDialog canvasSizeDialog;
|
|
private TMBlockSizeDialog blockSizeDialog;
|
|
private TMAddToTreeDialog addBookmarkDialog;
|
|
private TMAddToTreeDialog addPaletteDialog;
|
|
private TMOrganizeTreeDialog organizeBookmarksDialog;
|
|
private TMOrganizeTreeDialog organizePalettesDialog;
|
|
private TMNewPaletteDialog newPaletteDialog;
|
|
private TMPaletteSizeDialog paletteSizeDialog;
|
|
private TMImportInternalPaletteDialog importInternalPaletteDialog;
|
|
|
|
// toolbar buttons
|
|
ClassLoader cl = getClass().getClassLoader();
|
|
private ToolButton newButton = new ToolButton(new ImageIcon(cl.getResource("tm/icons/light/New24.png")));
|
|
private ToolButton openButton = new ToolButton(new ImageIcon(cl.getResource("tm/icons/light/Open24.png")));
|
|
private ToolButton saveButton = new ToolButton(new ImageIcon(cl.getResource("tm/icons/light/Save24.png")));
|
|
private ToolButton cutButton = new ToolButton(new ImageIcon(cl.getResource("tm/icons/light/Cut24.png")));
|
|
private ToolButton copyButton = new ToolButton(new ImageIcon(cl.getResource("tm/icons/light/Copy24.png")));
|
|
private ToolButton pasteButton = new ToolButton(new ImageIcon(cl.getResource("tm/icons/light/Paste24.png")));
|
|
private ToolButton undoButton = new ToolButton(new ImageIcon(cl.getResource("tm/icons/light/Undo24.png")));
|
|
private ToolButton redoButton = new ToolButton(new ImageIcon(cl.getResource("tm/icons/light/Redo24.png")));
|
|
private ToolButton gotoButton = new ToolButton(new ImageIcon(cl.getResource("tm/icons/light/Import24.png")));
|
|
private ToolButton addBookmarkButton = new ToolButton(new ImageIcon(cl.getResource("tm/icons/light/Bookmarks24.png")));
|
|
private ToolButton decWidthButton = new ToolButton(new ImageIcon(cl.getResource("tm/icons/light/DecWidth24.png")));
|
|
private ToolButton incWidthButton = new ToolButton(new ImageIcon(cl.getResource("tm/icons/light/IncWidth24.png")));
|
|
private ToolButton decHeightButton = new ToolButton(new ImageIcon(cl.getResource("tm/icons/light/DecHeight24.png")));
|
|
private ToolButton incHeightButton = new ToolButton(new ImageIcon(cl.getResource("tm/icons/light/IncHeight24.png")));
|
|
|
|
// navigation bar buttons
|
|
private ToolButton minusPageButton = new ToolButton(new ImageIcon(cl.getResource("tm/icons/light/Rewind24.png")));
|
|
private ToolButton minusRowButton = new ToolButton(new ImageIcon(cl.getResource("tm/icons/light/StepBack24.png")));
|
|
private ToolButton minusTileButton = new ToolButton(new ImageIcon(cl.getResource("tm/icons/light/Back24.png")));
|
|
private ToolButton minusByteButton = new ToolButton(new ImageIcon(cl.getResource("tm/icons/light/Minus24.png")));
|
|
private ToolButton plusByteButton = new ToolButton(new ImageIcon(cl.getResource("tm/icons/light/Plus24.png")));
|
|
private ToolButton plusTileButton = new ToolButton(new ImageIcon(cl.getResource("tm/icons/light/Forward24.png")));
|
|
private ToolButton plusRowButton = new ToolButton(new ImageIcon(cl.getResource("tm/icons/light/StepForward24.png")));
|
|
private ToolButton plusPageButton = new ToolButton(new ImageIcon(cl.getResource("tm/icons/light/FastForward24.png")));
|
|
|
|
// tool palette buttons
|
|
private ToolToggleButton selectButton = new ToolToggleButton(new ImageIcon(cl.getResource("tm/icons/light/Selection24.png")));
|
|
private ToolToggleButton zoomButton = new ToolToggleButton(new ImageIcon(cl.getResource("tm/icons/light/Zoom24.png")));
|
|
private ToolToggleButton pickupButton = new ToolToggleButton(new ImageIcon(cl.getResource("tm/icons/light/Dropper24.png")));
|
|
private ToolToggleButton brushButton = new ToolToggleButton(new ImageIcon(cl.getResource("tm/icons/light/Brush24.png")));
|
|
private ToolToggleButton lineButton = new ToolToggleButton(new ImageIcon(cl.getResource("tm/icons/light/Line24.png")));
|
|
private ToolToggleButton fillButton = new ToolToggleButton(new ImageIcon(cl.getResource("tm/icons/light/Fill24.png")));
|
|
private ToolToggleButton replaceButton = new ToolToggleButton(new ImageIcon(cl.getResource("tm/icons/light/ColorReplacer24.png")));
|
|
private ToolToggleButton moveButton = new ToolToggleButton(new ImageIcon(cl.getResource("tm/icons/light/Mover24.gif")));
|
|
|
|
// selection palette buttons
|
|
private ToolButton mirrorButton = new ToolButton(new ImageIcon(cl.getResource("tm/icons/light/Mirror24.png")));
|
|
private ToolButton flipButton = new ToolButton(new ImageIcon(cl.getResource("tm/icons/light/Flip24.png")));
|
|
private ToolButton rotateRightButton = new ToolButton(new ImageIcon(cl.getResource("tm/icons/light/RotateRight24.png")));
|
|
private ToolButton rotateLeftButton = new ToolButton(new ImageIcon(cl.getResource("tm/icons/light/RotateLeft24.png")));
|
|
private ToolButton shiftLeftButton = new ToolButton(new ImageIcon(cl.getResource("tm/icons/light/ShiftLeft24.png")));
|
|
private ToolButton shiftRightButton = new ToolButton(new ImageIcon(cl.getResource("tm/icons/light/ShiftRight24.png")));
|
|
private ToolButton shiftUpButton = new ToolButton(new ImageIcon(cl.getResource("tm/icons/light/ShiftUp24.png")));
|
|
private ToolButton shiftDownButton = new ToolButton(new ImageIcon(cl.getResource("tm/icons/light/ShiftDown24.png")));
|
|
|
|
// File menu
|
|
private JMenu fileMenu = new JMenu("File");
|
|
private JMenuItem newMenuItem = new JMenuItem("New...");
|
|
private JMenuItem openMenuItem = new JMenuItem("Open...");
|
|
private JMenu reopenMenu = new JMenu("Reopen");
|
|
private JMenuItem closeMenuItem = new JMenuItem("Close");
|
|
private JMenuItem closeAllMenuItem = new JMenuItem("Close All");
|
|
private JMenuItem saveMenuItem = new JMenuItem("Save");
|
|
private JMenuItem saveAsMenuItem = new JMenuItem("Save As...");
|
|
private JMenuItem saveAllMenuItem = new JMenuItem("Save All");
|
|
private JMenuItem exitMenuItem = new JMenuItem("Exit");
|
|
// Edit menu
|
|
private JMenu editMenu = new JMenu("Edit");
|
|
private JMenuItem undoMenuItem = new JMenuItem("Undo");
|
|
private JMenuItem redoMenuItem = new JMenuItem("Redo");
|
|
private JMenuItem cutMenuItem = new JMenuItem("Cut");
|
|
private JMenuItem copyMenuItem = new JMenuItem("Copy");
|
|
private JMenuItem pasteMenuItem = new JMenuItem("Paste");
|
|
private JMenuItem clearMenuItem = new JMenuItem("Clear");
|
|
private JMenuItem selectAllMenuItem = new JMenuItem("Select All");
|
|
private JMenuItem copyToMenuItem = new JMenuItem("Copy To...");
|
|
private JMenuItem pasteFromMenuItem = new JMenuItem("Paste From...");
|
|
// Image menu
|
|
private JMenu imageMenu = new JMenu("Image");
|
|
private JMenuItem mirrorMenuItem = new JMenuItem("Mirror");
|
|
private JMenuItem flipMenuItem = new JMenuItem("Flip");
|
|
private JMenuItem rotateRightMenuItem = new JMenuItem("Rotate Right");
|
|
private JMenuItem rotateLeftMenuItem = new JMenuItem("Rotate Left");
|
|
private JMenuItem shiftLeftMenuItem = new JMenuItem("Shift Left");
|
|
private JMenuItem shiftRightMenuItem = new JMenuItem("Shift Right");
|
|
private JMenuItem shiftUpMenuItem = new JMenuItem("Shift Up");
|
|
private JMenuItem shiftDownMenuItem = new JMenuItem("Shift Down");
|
|
private JMenuItem canvasSizeMenuItem = new JMenuItem("Canvas Size...");
|
|
private JMenuItem stretchMenuItem = new JMenuItem("Stretch...");
|
|
// View menu
|
|
private JMenu viewMenu = new JMenu("View");
|
|
private JCheckBoxMenuItem statusBarMenuItem = new JCheckBoxMenuItem("Statusbar");
|
|
private JCheckBoxMenuItem toolBarMenuItem = new JCheckBoxMenuItem("Toolbar");
|
|
private JMenu tileCodecMenu = new JMenu("Codec");
|
|
private JMenu zoomMenu = new JMenu("Zoom");
|
|
private JMenuItem zoomInMenuItem = new JMenuItem("In");
|
|
private JMenuItem zoomOutMenuItem = new JMenuItem("Out");
|
|
private JMenuItem _100MenuItem = new JMenuItem("100%");
|
|
private JMenuItem _200MenuItem = new JMenuItem("200%");
|
|
private JMenuItem _400MenuItem = new JMenuItem("400%");
|
|
private JMenuItem _800MenuItem = new JMenuItem("800%");
|
|
private JMenuItem _1600MenuItem = new JMenuItem("1600%");
|
|
private JMenuItem _3200MenuItem = new JMenuItem("3200%");
|
|
private JMenu blockSizeMenu = new JMenu("Block Size");
|
|
private JCheckBoxMenuItem sizeBlockToCanvasMenuItem = new JCheckBoxMenuItem("Full Canvas");
|
|
private JMenuItem customBlockSizeMenuItem = new JMenuItem("Custom...");
|
|
private JRadioButtonMenuItem rowInterleaveBlocksMenuItem = new JRadioButtonMenuItem("Row-interleave Blocks");
|
|
private JMenu modeMenu = new JMenu("Mode");
|
|
private JRadioButtonMenuItem _1DimensionalMenuItem = new JRadioButtonMenuItem("1-Dimensional");
|
|
private JRadioButtonMenuItem _2DimensionalMenuItem = new JRadioButtonMenuItem("2-Dimensional");
|
|
private JCheckBoxMenuItem blockGridMenuItem = new JCheckBoxMenuItem("Block Grid");
|
|
private JCheckBoxMenuItem tileGridMenuItem = new JCheckBoxMenuItem("Tile Grid");
|
|
private JCheckBoxMenuItem pixelGridMenuItem = new JCheckBoxMenuItem("Pixel Grid");
|
|
// Navigate menu
|
|
private JMenu navigateMenu = new JMenu("Navigate");
|
|
private JMenuItem goToMenuItem = new JMenuItem("Go To...");
|
|
private JMenuItem goToAgainMenuItem = new JMenuItem("Go To Again");
|
|
private JMenuItem addToBookmarksMenuItem = new JMenuItem("Add To Bookmarks...");
|
|
private JMenuItem organizeBookmarksMenuItem = new JMenuItem("Organize Bookmarks...");
|
|
// private JMenuItem saveBookmarksMenuItem = new JMenuItem("Save Bookmarks");
|
|
// Palette menu
|
|
private JMenu paletteMenu = new JMenu("Palette");
|
|
private JMenuItem editColorsMenuItem = new JMenuItem("Edit Colors...");
|
|
private JMenu colorCodecMenu = new JMenu("Format");
|
|
private JMenu paletteEndiannessMenu = new JMenu("Endianness");
|
|
private JRadioButtonMenuItem paletteLittleEndianMenuItem = new JRadioButtonMenuItem("Little");
|
|
private JRadioButtonMenuItem paletteBigEndianMenuItem = new JRadioButtonMenuItem("Big");
|
|
private JRadioButtonMenuItem dummyPaletteMenuItem = new JRadioButtonMenuItem();
|
|
private JMenuItem paletteSizeMenuItem = new JMenuItem("Size...");
|
|
private JMenuItem newPaletteMenuItem = new JMenuItem("New...");
|
|
private JMenu importPaletteMenu = new JMenu("Import From");
|
|
private JMenuItem importInternalPaletteMenuItem = new JMenuItem("This File...");
|
|
private JMenuItem importExternalPaletteMenuItem = new JMenuItem("Another File...");
|
|
private JMenuItem addToPalettesMenuItem = new JMenuItem("Add To Palettes...");
|
|
private JMenuItem organizePalettesMenuItem = new JMenuItem("Organize Palettes...");
|
|
// private JMenuItem savePalettesMenuItem = new JMenuItem("Save Palettes");
|
|
// private JMenuItem exportPaletteMenuItem = new JMenuItem("Export..."); // tpl, c, asm, java?
|
|
// Window menu
|
|
private JMenu windowMenu = new JMenu("Window");
|
|
private JMenuItem newWindowMenuItem = new JMenuItem("New Window");
|
|
private JMenuItem tileMenuItem = new JMenuItem("Tile");
|
|
private JMenuItem cascadeMenuItem = new JMenuItem("Cascade");
|
|
private JMenuItem arrangeIconsMenuItem = new JMenuItem("Arrange Icons");
|
|
// Help menu
|
|
private JMenu helpMenu = new JMenu("Help");
|
|
private JMenuItem helpTopicsMenuItem = new JMenuItem("Help Topics");
|
|
//private JMenuItem tipMenuItem = new JMenuItem("Tip of the Millennium..."); // Still say no to drugs, okay?
|
|
private JMenuItem aboutMenuItem = new JMenuItem("About Tile Mangler...");
|
|
|
|
// button groups
|
|
private ButtonGroup toolButtonGroup = new ButtonGroup();
|
|
private ButtonGroup colorCodecButtonGroup = new ButtonGroup();
|
|
private ButtonGroup tileCodecButtonGroup = new ButtonGroup();
|
|
private ButtonGroup paletteButtonGroup = new ButtonGroup();
|
|
private ButtonGroup modeButtonGroup = new ButtonGroup();
|
|
private ButtonGroup paletteEndiannessButtonGroup = new ButtonGroup();
|
|
|
|
private Hashtable tileCodecButtonHashtable = new Hashtable();
|
|
private Hashtable colorCodecButtonHashtable = new Hashtable();
|
|
private Hashtable paletteButtonHashtable = new Hashtable();
|
|
private Hashtable fileListenerHashtable = new Hashtable();
|
|
|
|
private Xlator xl;
|
|
private File settingsFile = new File("settings.xml");
|
|
|
|
private Locale locale = Locale.getDefault();
|
|
private boolean viewStatusBar=true;
|
|
private boolean viewToolBar=true;
|
|
|
|
private String lastPath = "";
|
|
public static Color MenuBG = SystemColor.menu;
|
|
public static Color WindowBG = SystemColor.window;
|
|
public static Color AsideBG = SystemColor.desktop;
|
|
public static Color FrameBG = SystemColor.scrollbar;
|
|
public static boolean DarkIcons = false;
|
|
|
|
|
|
private Border emptyBorder = BorderFactory.createEmptyBorder();
|
|
private JSeparator separator = new JSeparator();
|
|
|
|
|
|
/**
|
|
*
|
|
* Creates a Tile Mangler UI.
|
|
*
|
|
**/
|
|
|
|
public TMUI() {
|
|
|
|
super("Tile Mangler");
|
|
|
|
//I tried to change the UI but it seems innatural
|
|
/*try {
|
|
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
|
|
} catch (ClassNotFoundException e) {
|
|
e.printStackTrace();
|
|
} catch (InstantiationException e) {
|
|
e.printStackTrace();
|
|
} catch (IllegalAccessException e) {
|
|
e.printStackTrace();
|
|
} catch (UnsupportedLookAndFeelException e) {
|
|
e.printStackTrace();
|
|
}*/
|
|
|
|
setIconImage(new ImageIcon(cl.getResource("tm/icons/TMIcon.gif")).getImage());
|
|
|
|
if (settingsFile.exists()) {
|
|
// load settings from file
|
|
loadSettings();
|
|
}
|
|
else {
|
|
// assume this is the first time program is run
|
|
selectLanguage();
|
|
// File bookmarksDir = new File("bookmarks");
|
|
// bookmarksDir.mkdir();
|
|
// copy bookmarks.dtd to bookmarksDir
|
|
// File palettesDir = new File("palettes");
|
|
// palettesDir.mkdir();
|
|
// copy palettes.dtd to palettesDir
|
|
/* File resourcesDir = new File("resources");
|
|
if (!resourcesDir.exists()) {
|
|
resourcesDir.mkdir();
|
|
File resourceDTDFile = new File(resourcesDir, "tmres.dtd");
|
|
try {
|
|
FileWriter fw = new FileWriter(resourceDTDFile);
|
|
fw.write(""+
|
|
"<?xml version=\"1.0\" encoding=\"iso-8859-1\"?>\n"+
|
|
"<!ELEMENT tmres (bookmarks?, palettes?)>\n"+
|
|
"<!ELEMENT bookmarks (folder | bookmark)*>\n"+
|
|
"<!ELEMENT palettes (folder | palette)*>\n"+
|
|
"<!ELEMENT folder (name, (folder | bookmark | palette)*)>\n"+
|
|
"<!ELEMENT bookmark (description)>\n"+
|
|
"<!ATTLIST bookmark\n"+
|
|
" offset CDATA #REQUIRED\n"+
|
|
" width CDATA #REQUIRED\n"+
|
|
" height CDATA #REQUIRED\n"+
|
|
" mode (1D | 2D) #REQUIRED\n"+
|
|
" codec CDATA #REQUIRED\n"+
|
|
" palIndex CDATA #REQUIRED\n"+
|
|
" palette CDATA #IMPLIED\n"+
|
|
">\n"+
|
|
"<!ELEMENT palette (description, data?)>\n"+
|
|
"<!ATTLIST palette\n"+
|
|
" id ID #IMPLIED\n"+
|
|
" direct (yes | no) #REQUIRED\n"+
|
|
" codec CDATA #REQUIRED\n"+
|
|
" size CDATA #REQUIRED\n"+
|
|
" offset CDATA #IMPLIED\n"+
|
|
" endianness (little | big) \"little\"\n"+
|
|
">\n"+
|
|
"<!ELEMENT data (#PCDATA)>\n"+
|
|
"<!ELEMENT name (#PCDATA)>\n"+
|
|
"<!ELEMENT description (#PCDATA)>\n"+
|
|
"");
|
|
fw.close();
|
|
}
|
|
catch (Exception e) { }
|
|
}*/
|
|
}
|
|
setLocale(locale);
|
|
Locale.setDefault(locale);
|
|
JComponent.setDefaultLocale(this.locale);
|
|
|
|
if(DarkIcons){
|
|
newButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/New24.png")));
|
|
openButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/Open24.png")));
|
|
saveButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/Save24.png")));
|
|
cutButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/Cut24.png")));
|
|
copyButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/Copy24.png")));
|
|
pasteButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/Paste24.png")));
|
|
undoButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/Undo24.png")));
|
|
redoButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/Redo24.png")));
|
|
gotoButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/Import24.png")));
|
|
addBookmarkButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/Bookmarks24.png")));
|
|
decWidthButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/DecWidth24.png")));
|
|
incWidthButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/IncWidth24.png")));
|
|
decHeightButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/DecHeight24.png")));
|
|
incHeightButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/IncHeight24.png")));
|
|
minusPageButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/Rewind24.png")));
|
|
minusRowButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/StepBack24.png")));
|
|
minusTileButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/Back24.png")));
|
|
minusByteButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/Minus24.png")));
|
|
plusByteButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/Plus24.png")));
|
|
plusTileButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/Forward24.png")));
|
|
plusRowButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/StepForward24.png")));
|
|
plusPageButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/FastForward24.png")));
|
|
selectButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/Selection24.png")));
|
|
zoomButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/Zoom24.png")));
|
|
pickupButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/Dropper24.png")));
|
|
brushButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/Brush24.png")));
|
|
lineButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/Line24.png")));
|
|
fillButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/Fill24.png")));
|
|
replaceButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/ColorReplacer24.png")));
|
|
moveButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/Mover24.gif")));
|
|
mirrorButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/Mirror24.png")));
|
|
flipButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/Flip24.png")));
|
|
rotateRightButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/RotateRight24.png")));
|
|
rotateLeftButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/RotateLeft24.png")));
|
|
shiftLeftButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/ShiftLeft24.png")));
|
|
shiftRightButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/ShiftRight24.png")));
|
|
shiftUpButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/ShiftUp24.png")));
|
|
shiftDownButton.setIcon(new ImageIcon(cl.getResource("tm/icons/dark/ShiftDown24.png")));
|
|
}
|
|
|
|
separator.setForeground(Color.decode("#292929"));
|
|
|
|
//desktop.repaint();
|
|
|
|
// show splash screen
|
|
//new TMSplashScreen(this); // No need for a splash screen, it runs immediately on modern systems
|
|
|
|
// create a translator
|
|
try {
|
|
xl = new Xlator("languages/language", locale);
|
|
} catch (Exception e) {
|
|
JOptionPane.showMessageDialog(this,
|
|
xlate("Error reading language file:")+"\n"+e.getMessage(),
|
|
"Tile Mangler",
|
|
JOptionPane.ERROR_MESSAGE);
|
|
System.exit(0);
|
|
}
|
|
|
|
///////// Translate items
|
|
|
|
// File menu
|
|
fileMenu.setText(xlate("File"));
|
|
newMenuItem.setText(xlate("New"));
|
|
openMenuItem.setText(xlate("Open"));
|
|
reopenMenu.setText(xlate("Reopen"));
|
|
closeMenuItem.setText(xlate("Close"));
|
|
closeAllMenuItem.setText(xlate("Close_All"));
|
|
saveMenuItem.setText(xlate("Save"));
|
|
saveAsMenuItem.setText(xlate("Save_As"));
|
|
saveAllMenuItem.setText(xlate("Save_All"));
|
|
exitMenuItem.setText(xlate("Exit"));
|
|
// Edit menu
|
|
editMenu.setText(xlate("Edit"));
|
|
undoMenuItem.setText(xlate("Undo"));
|
|
redoMenuItem.setText(xlate("Redo"));
|
|
cutMenuItem.setText(xlate("Cut"));
|
|
copyMenuItem.setText(xlate("Copy"));
|
|
pasteMenuItem.setText(xlate("Paste"));
|
|
clearMenuItem.setText(xlate("Clear"));
|
|
selectAllMenuItem.setText(xlate("Select_All"));
|
|
copyToMenuItem.setText(xlate("Copy_To"));
|
|
pasteFromMenuItem.setText(xlate("Paste_From"));
|
|
pasteFromMenuItem.setText(xlate("New_Selection"));
|
|
pasteFromMenuItem.setText(xlate("Apply_Selection"));
|
|
// Image menu
|
|
imageMenu.setText(xlate("Image"));
|
|
mirrorMenuItem.setText(xlate("Mirror"));
|
|
flipMenuItem.setText(xlate("Flip"));
|
|
rotateRightMenuItem.setText(xlate("Rotate_Right"));
|
|
rotateLeftMenuItem.setText(xlate("Rotate_Left"));
|
|
shiftLeftMenuItem.setText(xlate("Shift_Left"));
|
|
shiftRightMenuItem.setText(xlate("Shift_Right"));
|
|
shiftUpMenuItem.setText(xlate("Shift_Up"));
|
|
shiftDownMenuItem.setText(xlate("Shift_Down"));
|
|
canvasSizeMenuItem.setText(xlate("Canvas_Size"));
|
|
stretchMenuItem.setText(xlate("Stretch"));
|
|
// View menu
|
|
viewMenu.setText(xlate("View"));
|
|
statusBarMenuItem.setText(xlate("Statusbar"));
|
|
toolBarMenuItem.setText(xlate("Toolbar"));
|
|
tileCodecMenu.setText(xlate("Codec"));
|
|
zoomMenu.setText(xlate("Zoom"));
|
|
zoomInMenuItem.setText(xlate("In"));
|
|
zoomOutMenuItem.setText(xlate("Out"));
|
|
_100MenuItem.setText(xlate("100%"));
|
|
_200MenuItem.setText(xlate("200%"));
|
|
_400MenuItem.setText(xlate("400%"));
|
|
_800MenuItem.setText(xlate("800%"));
|
|
_1600MenuItem.setText(xlate("1600%"));
|
|
_3200MenuItem.setText(xlate("3200%"));
|
|
modeMenu.setText(xlate("Mode"));
|
|
_1DimensionalMenuItem.setText(xlate("1_Dimensional"));
|
|
_2DimensionalMenuItem.setText(xlate("2_Dimensional"));
|
|
blockSizeMenu.setText(xlate("Block_Size"));
|
|
sizeBlockToCanvasMenuItem.setText(xlate("Full_Canvas"));
|
|
customBlockSizeMenuItem.setText(xlate("Custom_Block_Size"));
|
|
rowInterleaveBlocksMenuItem.setText(xlate("Row_Interleave_Blocks"));
|
|
blockGridMenuItem.setText(xlate("Block_Grid"));
|
|
tileGridMenuItem.setText(xlate("Tile_Grid"));
|
|
pixelGridMenuItem.setText(xlate("Pixel_Grid"));
|
|
// Navigate menu
|
|
navigateMenu.setText(xlate("Navigate"));
|
|
goToMenuItem.setText(xlate("Go_To"));
|
|
goToAgainMenuItem.setText(xlate("Go_To_Again"));
|
|
addToBookmarksMenuItem.setText(xlate("Add_To_Bookmarks"));
|
|
organizeBookmarksMenuItem.setText(xlate("Organize_Bookmarks"));
|
|
// Palette menu
|
|
paletteMenu.setText(xlate("Palette"));
|
|
editColorsMenuItem.setText(xlate("Edit_Colors"));
|
|
colorCodecMenu.setText(xlate("Format"));
|
|
paletteEndiannessMenu.setText(xlate("Endianness"));
|
|
paletteLittleEndianMenuItem.setText(xlate("Little_Endian"));
|
|
paletteBigEndianMenuItem.setText(xlate("Big_Endian"));
|
|
paletteSizeMenuItem.setText(xlate("Size"));
|
|
newPaletteMenuItem.setText(xlate("New"));
|
|
importPaletteMenu.setText(xlate("Import_From"));
|
|
importInternalPaletteMenuItem.setText(xlate("This_File"));
|
|
importExternalPaletteMenuItem.setText(xlate("Another_File"));
|
|
addToPalettesMenuItem.setText(xlate("Add_To_Palettes"));
|
|
organizePalettesMenuItem.setText(xlate("Organize_Palettes"));
|
|
// Window menu
|
|
windowMenu.setText(xlate("Window"));
|
|
newWindowMenuItem.setText(xlate("New_Window"));
|
|
tileMenuItem.setText(xlate("Tile"));
|
|
cascadeMenuItem.setText(xlate("Cascade"));
|
|
arrangeIconsMenuItem.setText(xlate("Arrange_Icons"));
|
|
// Help menu
|
|
helpMenu.setText(xlate("Help"));
|
|
helpTopicsMenuItem.setText(xlate("Help_Topics"));
|
|
aboutMenuItem.setText(xlate("About_Tile_Mangler"));
|
|
|
|
UIManager.put("OptionPane.yesButtonText", xlate("Yes"));
|
|
UIManager.put("OptionPane.noButtonText", xlate("No"));
|
|
UIManager.put("OptionPane.cancelButtonText", xlate("Cancel"));
|
|
UIManager.put("OptionPane.okButtonText", xlate("OK"));
|
|
|
|
fileOpenChooser.setDialogTitle(xlate("Open_File_Dialog_Title"));
|
|
fileSaveChooser.setDialogTitle(xlate("Save_As_Dialog_Title"));
|
|
bitmapOpenChooser.setDialogTitle(xlate("Paste_From_Dialog_Title"));
|
|
bitmapSaveChooser.setDialogTitle(xlate("Copy_To_Dialog_Title"));
|
|
paletteOpenChooser.setDialogTitle(xlate("Open_Palette_Dialog_Title"));
|
|
|
|
///////// Read specs
|
|
try {
|
|
TMSpecReader.readSpecsFromFile(new File("tmspec.xml"));
|
|
}
|
|
catch (SAXParseException e) {
|
|
JOptionPane.showMessageDialog(this,
|
|
xlate("Parser_Parse_Error")+"\n"+
|
|
e.getMessage()+"\n"+
|
|
"("+e.getSystemId()+",\n"+
|
|
"line "+e.getLineNumber()+")\n",
|
|
"Tile Mangler",
|
|
JOptionPane.ERROR_MESSAGE);
|
|
System.exit(0);
|
|
}
|
|
catch (SAXException e) {
|
|
JOptionPane.showMessageDialog(this,
|
|
xlate("Parser_Parse_Error")+"\n"+e.getMessage(),
|
|
"Tile Mangler",
|
|
JOptionPane.ERROR_MESSAGE);
|
|
System.exit(0);
|
|
}
|
|
catch (ParserConfigurationException e) {
|
|
JOptionPane.showMessageDialog(this,
|
|
xlate("Parser_Config_Error")+"\n"+e.getMessage(),
|
|
"Tile Mangler",
|
|
JOptionPane.ERROR_MESSAGE);
|
|
System.exit(0);
|
|
}
|
|
catch (IOException e) {
|
|
JOptionPane.showMessageDialog(this,
|
|
xlate("Parser_IO_Error")+"\n"+e.getMessage(),
|
|
"Tile Mangler",
|
|
JOptionPane.ERROR_MESSAGE);
|
|
System.exit(0);
|
|
}
|
|
|
|
colorcodecs = TMSpecReader.getColorCodecs();
|
|
tilecodecs = TMSpecReader.getTileCodecs();
|
|
filefilters = TMSpecReader.getFileFilters();
|
|
palettefilters = TMSpecReader.getPaletteFilters();
|
|
filelisteners = TMSpecReader.getFileListeners();
|
|
|
|
tilecodecs.add(new _3BPPLinearTileCodec());
|
|
//////////
|
|
|
|
// create dialogs.
|
|
goToDialog = new TMGoToDialog(this, xl);
|
|
newFileDialog = new TMNewFileDialog(this, xl);
|
|
// customCodecDialog = new TMCustomCodecDialog(this, "Custom Codec", true, xl);
|
|
stretchDialog = new TMStretchDialog(this, xl);
|
|
canvasSizeDialog = new TMCanvasSizeDialog(this, xl);
|
|
blockSizeDialog = new TMBlockSizeDialog(this, xl);
|
|
addBookmarkDialog = new TMAddToTreeDialog(this, "Add_To_Bookmarks_Dialog_Title", xl);
|
|
addPaletteDialog = new TMAddToTreeDialog(this, "Add_To_Palettes_Dialog_Title", xl);
|
|
organizeBookmarksDialog = new TMOrganizeTreeDialog(this, "Organize_Bookmarks_Dialog_Title", xl);
|
|
organizePalettesDialog = new TMOrganizeTreeDialog(this, "Organize_Palettes_Dialog_Title", xl);
|
|
newPaletteDialog = new TMNewPaletteDialog(this, xl);
|
|
paletteSizeDialog = new TMPaletteSizeDialog(this, xl);
|
|
importInternalPaletteDialog = new TMImportInternalPaletteDialog(this, xl);
|
|
|
|
newPaletteDialog.setCodecs(colorcodecs);
|
|
importInternalPaletteDialog.setCodecs(colorcodecs);
|
|
|
|
//Set up the GUI.
|
|
// main contentpane
|
|
JPanel pane = new JPanel();
|
|
setContentPane(pane);
|
|
pane.setDoubleBuffered(true);
|
|
pane.setLayout(new BorderLayout());
|
|
|
|
// main toolbar
|
|
initToolBar();
|
|
initNavBar();
|
|
toolBarPane.setLayout(new FlowLayout(FlowLayout.LEFT));
|
|
toolBarPane.setBackground(MenuBG);
|
|
toolBarPane.add(toolBar);
|
|
toolBarPane.add(navBar);
|
|
pane.add(toolBarPane, BorderLayout.NORTH);
|
|
|
|
// desktop
|
|
pane.add(new JScrollPane(desktop), BorderLayout.CENTER);
|
|
|
|
// palette pane & statusbar
|
|
palettePane = new TMPalettePane(this);
|
|
//statusBar.setBorder(new BevelBorder(BevelBorder.LOWERED));
|
|
bottomPane.setLayout(new BorderLayout());
|
|
bottomPane.add(palettePane, BorderLayout.CENTER);
|
|
bottomPane.add(statusBar, BorderLayout.SOUTH);
|
|
pane.add(bottomPane, BorderLayout.SOUTH);
|
|
|
|
// tool palettes
|
|
initToolPalette();
|
|
initSelectionToolBar();
|
|
JPanel barPane = new JPanel();
|
|
//barPane.setLayout(new GridLayout(1, 2));
|
|
|
|
barPane.setBackground(AsideBG);
|
|
barPane.add(selectionToolBar);
|
|
barPane.add(toolPalette);
|
|
toolPane.setBackground(AsideBG);
|
|
toolPane.setLayout(new BorderLayout());
|
|
toolPane.add(barPane, BorderLayout.NORTH);
|
|
pane.add(toolPane, BorderLayout.WEST);
|
|
|
|
// menus
|
|
initMenuBar();
|
|
setJMenuBar(menuBar);
|
|
buildReopenMenu();
|
|
|
|
initTileCodecUIStuff();
|
|
buildColorCodecsMenu();
|
|
initPaletteOpenChooser();
|
|
|
|
// Set up file save chooser.
|
|
fileSaveChooser.setAcceptAllFileFilterUsed(false);
|
|
fileSaveChooser.addChoosableFileFilter(allFilter);
|
|
fileSaveChooser.setFileFilter(allFilter);
|
|
|
|
// Set up bitmap open chooser.
|
|
bitmapOpenChooser.setAcceptAllFileFilterUsed(false);
|
|
bitmapOpenChooser.addChoosableFileFilter(bmf.supported);
|
|
bitmapOpenChooser.addChoosableFileFilter(bmf.gif);
|
|
bitmapOpenChooser.addChoosableFileFilter(bmf.jpeg);
|
|
bitmapOpenChooser.addChoosableFileFilter(bmf.png);
|
|
bitmapOpenChooser.addChoosableFileFilter(bmf.bmp);
|
|
bitmapOpenChooser.addChoosableFileFilter(bmf.pcx);
|
|
bitmapOpenChooser.setFileFilter(bmf.supported);
|
|
|
|
// Set up bitmap save chooser.
|
|
bitmapSaveChooser.setAcceptAllFileFilterUsed(false);
|
|
bitmapSaveChooser.addChoosableFileFilter(bmf.gif);
|
|
bitmapSaveChooser.addChoosableFileFilter(bmf.jpeg);
|
|
bitmapSaveChooser.addChoosableFileFilter(bmf.png);
|
|
bitmapSaveChooser.addChoosableFileFilter(bmf.bmp);
|
|
bitmapSaveChooser.addChoosableFileFilter(bmf.pcx);
|
|
bitmapSaveChooser.setFileFilter(bmf.png);
|
|
|
|
setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);
|
|
|
|
addWindowListener(new WindowAdapter() {
|
|
public void windowClosing(WindowEvent e) {
|
|
doExitCommand();
|
|
}
|
|
public void windowActivated(WindowEvent e) {
|
|
setExtendedState(JFrame.NORMAL); // Hacky way to make it not run in full screen by default
|
|
// HACK to fix the GUI after running FCEU in fullscreen mode
|
|
// int state = getExtendedState();
|
|
// setExtendedState(JFrame.ICONIFIED);
|
|
// setExtendedState(state);
|
|
}
|
|
});
|
|
|
|
// Center the frame
|
|
int inset = 128;
|
|
Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
|
|
setBounds(inset, inset,
|
|
screenSize.width - inset*2,
|
|
screenSize.height-inset*2);
|
|
|
|
//Make dragging faster:
|
|
desktop.putClientProperty("JDesktopPane.dragMode", "outline");
|
|
|
|
// MDI menus and such shouldn't be shown until file loaded.
|
|
disableMDIStuff();
|
|
|
|
toolBarPane.setVisible(viewToolBar);
|
|
|
|
// Show and maximize.
|
|
setVisible(true);
|
|
setExtendedState(JFrame.MAXIMIZED_BOTH);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Saves program settings to file.
|
|
*
|
|
**/
|
|
|
|
public void saveSettings() {
|
|
StringBuffer sb = new StringBuffer();
|
|
sb.append("<?xml version=\"1.0\" encoding=\"iso-8859-1\"?>\n");
|
|
sb.append("<!DOCTYPE settings SYSTEM \"settings.dtd\">\n");
|
|
sb.append("<settings>\n");
|
|
|
|
sb.append(makePropertyTag("locale", locale.toString()));
|
|
sb.append(makePropertyTag("viewStatusBar", ""+viewStatusBar));
|
|
sb.append(makePropertyTag("viewToolBar", ""+viewToolBar));
|
|
sb.append(makePropertyTag("maxRecentFiles", ""+maxRecentFiles));
|
|
|
|
File recentFile = null;
|
|
//To remember last path
|
|
for (int i=0; i<recentFiles.size(); i++) {
|
|
recentFile = (File)recentFiles.get(i);
|
|
sb.append(makePropertyTag("recentFile", recentFile.getAbsolutePath()));
|
|
}
|
|
sb.append(makePropertyTag("lastPath", lastPath));
|
|
sb.append(makePropertyTag("MenuBG", "#"+Integer.toHexString(MenuBG.getRGB()).substring(2)));
|
|
sb.append(makePropertyTag("WindowBG", "#"+Integer.toHexString(WindowBG.getRGB()).substring(2)));
|
|
sb.append(makePropertyTag("AsideBG", "#"+Integer.toHexString(AsideBG.getRGB()).substring(2)));
|
|
sb.append(makePropertyTag("FrameBG", "#"+Integer.toHexString(FrameBG.getRGB()).substring(2)));
|
|
sb.append(makePropertyTag("DarkIcons", DarkIcons?"true":"false"));
|
|
|
|
sb.append("</settings>\n");
|
|
|
|
// write to file
|
|
try {
|
|
FileWriter fw = new FileWriter(settingsFile);
|
|
fw.write(sb.toString());
|
|
fw.close();
|
|
}
|
|
catch (Exception e) {
|
|
JOptionPane.showMessageDialog(this,
|
|
xlate("Save_Settings_Error")+"\n"+e.getMessage(),
|
|
"Tile Mangler",
|
|
JOptionPane.ERROR_MESSAGE);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Makes a property tag with the given key and value.
|
|
*
|
|
**/
|
|
|
|
public String makePropertyTag(String key, String value) {
|
|
return " <property key=\""+key+"\" value=\""+value+"\"/>\n";
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Loads program settings from file.
|
|
*
|
|
**/
|
|
|
|
public void loadSettings() {
|
|
boolean loadedLocale = false;
|
|
Document doc = null;
|
|
try {
|
|
doc = XMLParser.parse(settingsFile);
|
|
}
|
|
catch (Exception e) {
|
|
JOptionPane.showMessageDialog(this,
|
|
xlate("Load_Settings_Error")+"\n"+e.getMessage(),
|
|
"Tile Mangler",
|
|
JOptionPane.ERROR_MESSAGE);
|
|
}
|
|
if (doc == null) return;
|
|
|
|
Element settings = doc.getDocumentElement();
|
|
NodeList properties = settings.getElementsByTagName("property");
|
|
// process all the properties
|
|
for (int i=0; i<properties.getLength(); i++) {
|
|
// get property (key, value) pair
|
|
Element property = (Element)properties.item(i);
|
|
String key = property.getAttribute("key");
|
|
String value = property.getAttribute("value");
|
|
// handle property
|
|
if (key.equals("locale")) {
|
|
StringTokenizer st = new StringTokenizer(value, "_");
|
|
if (st.countTokens() != 2) continue;
|
|
String language = st.nextToken();
|
|
String country = st.nextToken();
|
|
locale = new Locale(language, country);
|
|
loadedLocale = true;
|
|
}
|
|
if (key.equals("viewStatusBar")) {
|
|
viewStatusBar = value.equals("true");
|
|
}
|
|
else if (key.equals("viewToolBar")) {
|
|
viewToolBar = value.equals("true");
|
|
}
|
|
else if (key.equals("maxRecentFiles")) {
|
|
maxRecentFiles = Integer.parseInt(value);
|
|
}
|
|
else if (key.equals("recentFile")) {
|
|
File file = new File(value);
|
|
if (file.exists()) {
|
|
recentFiles.add(file);
|
|
}
|
|
}
|
|
else if (key.equals("lastPath")) {
|
|
lastPath = value;
|
|
}
|
|
else if (key.equals("MenuBG")) {
|
|
MenuBG = Color.decode(value);
|
|
}
|
|
else if (key.equals("WindowBG")) {
|
|
WindowBG = Color.decode(value);
|
|
}
|
|
else if (key.equals("AsideBG")) {
|
|
AsideBG = Color.decode(value);
|
|
}
|
|
else if (key.equals("FrameBG")) {
|
|
FrameBG = Color.decode(value);
|
|
}
|
|
else if (key.equals("DarkIcons")) {
|
|
DarkIcons = value.equals("true");
|
|
}
|
|
}
|
|
if(!loadedLocale) selectLanguage();
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Begin long bunch of code for setting up menus, panels etc...
|
|
|
|
static class CButtonUI extends ButtonUI {
|
|
|
|
/*
|
|
* private static final CButtonUI buttonUI = new CButtonUI();
|
|
*
|
|
* ModifButtonUI() { }
|
|
*/
|
|
|
|
public static ComponentUI createUI(JComponent c) {
|
|
return new CButtonUI();
|
|
}
|
|
|
|
@Override
|
|
public void paint(Graphics g, JComponent c) {
|
|
final Color color1 = new Color(230, 255, 255, 0);
|
|
final Color color2 = new Color(255, 230, 255, 64);
|
|
final Color alphaColor = new Color(200, 200, 230, 64);
|
|
final Color color3 = new Color(alphaColor.getRed(), alphaColor.getGreen(), alphaColor.getBlue(), 0);
|
|
final Color color4 = new Color(alphaColor.getRed(), alphaColor.getGreen(), alphaColor.getBlue(), 64);
|
|
super.paint(g, c);
|
|
Graphics2D g2D = (Graphics2D) g;
|
|
GradientPaint gradient1 = new GradientPaint(0.0F, (float) c.getHeight() / (float) 2, color1, 0.0F, 0.0F,
|
|
color2);
|
|
Rectangle rec1 = new Rectangle(0, 0, c.getWidth(), c.getHeight() / 2);
|
|
g2D.setPaint(gradient1);
|
|
g2D.fill(rec1);
|
|
GradientPaint gradient2 = new GradientPaint(0.0F, (float) c.getHeight() / (float) 2, color3, 0.0F,
|
|
c.getHeight(), color4);
|
|
Rectangle rec2 = new Rectangle(0, c.getHeight() / 2, c.getWidth(), c.getHeight());
|
|
g2D.setPaint(gradient2);
|
|
g2D.fill(rec2);
|
|
}
|
|
|
|
/*
|
|
@Override
|
|
public void paintButtonPressed(Graphics g, AbstractButton b) {
|
|
paintText(g, b, b.getBounds(), b.getText());
|
|
g.setColor(Color.red.brighter());
|
|
g.fillRect(0, 0, b.getSize().width, b.getSize().height);
|
|
}
|
|
*/
|
|
|
|
public void paintBorder(Graphics g) {
|
|
}
|
|
|
|
/*
|
|
@Override
|
|
protected void paintFocus(Graphics g, AbstractButton b, Rectangle viewRect, Rectangle textRect,
|
|
Rectangle iconRect) {
|
|
}
|
|
*/
|
|
}
|
|
|
|
|
|
/**
|
|
*
|
|
* Sets up the toolbar.
|
|
*
|
|
**/
|
|
|
|
private void initToolBar() {
|
|
// New
|
|
//newButton.setUI(new CButtonUI());
|
|
//newButton.setContentAreaFilled(false);
|
|
toolBar.setBorder(null);
|
|
newButton.setBackground(MenuBG);
|
|
|
|
newButton.setToolTipText(newMenuItem.getText());
|
|
newButton.setFocusable(false);
|
|
newButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doNewCommand();
|
|
}
|
|
}
|
|
);
|
|
toolBar.add(newButton);
|
|
// Open
|
|
openButton.setBackground(MenuBG);
|
|
openButton.setToolTipText(openMenuItem.getText());
|
|
openButton.setFocusable(false);
|
|
openButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doOpenCommand();
|
|
}
|
|
}
|
|
);
|
|
toolBar.add(openButton);
|
|
// Save
|
|
saveButton.setBackground(MenuBG);
|
|
saveButton.setToolTipText(saveMenuItem.getText());
|
|
saveButton.setFocusable(false);
|
|
saveButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doSaveCommand();
|
|
}
|
|
}
|
|
);
|
|
toolBar.add(saveButton);
|
|
//
|
|
toolBar.add(separator);
|
|
// Cut
|
|
cutButton.setBackground(MenuBG);
|
|
cutButton.setToolTipText(cutMenuItem.getText());
|
|
cutButton.setFocusable(false);
|
|
cutButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doCutCommand();
|
|
}
|
|
}
|
|
);
|
|
toolBar.add(cutButton);
|
|
// Copy
|
|
copyButton.setBackground(MenuBG);
|
|
copyButton.setToolTipText(copyMenuItem.getText());
|
|
copyButton.setFocusable(false);
|
|
copyButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doCopyCommand();
|
|
}
|
|
}
|
|
);
|
|
toolBar.add(copyButton);
|
|
// Paste
|
|
pasteButton.setBackground(MenuBG);
|
|
pasteButton.setToolTipText(pasteMenuItem.getText());
|
|
pasteButton.setFocusable(false);
|
|
pasteButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doPasteCommand();
|
|
}
|
|
}
|
|
);
|
|
toolBar.add(pasteButton);
|
|
//
|
|
toolBar.add(separator);
|
|
// Undo
|
|
undoButton.setBackground(MenuBG);
|
|
undoButton.setToolTipText(undoMenuItem.getText());
|
|
undoButton.setFocusable(false);
|
|
undoButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doUndoCommand();
|
|
}
|
|
}
|
|
);
|
|
toolBar.add(undoButton);
|
|
// Redo
|
|
redoButton.setBackground(MenuBG);
|
|
redoButton.setToolTipText(redoMenuItem.getText());
|
|
redoButton.setFocusable(false);
|
|
redoButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doRedoCommand();
|
|
}
|
|
}
|
|
);
|
|
toolBar.add(redoButton);
|
|
//
|
|
toolBar.add(separator);
|
|
// Go To
|
|
gotoButton.setBackground(MenuBG);
|
|
gotoButton.setToolTipText(goToMenuItem.getText());
|
|
gotoButton.setFocusable(false);
|
|
gotoButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doGoToCommand();
|
|
}
|
|
}
|
|
);
|
|
toolBar.add(gotoButton);
|
|
// Add To Bookmarks...
|
|
addBookmarkButton.setBackground(MenuBG);
|
|
addBookmarkButton.setToolTipText(addToBookmarksMenuItem.getText());
|
|
addBookmarkButton.setFocusable(false);
|
|
addBookmarkButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doAddToBookmarksCommand();
|
|
}
|
|
}
|
|
);
|
|
toolBar.add(addBookmarkButton);
|
|
//
|
|
toolBar.add(separator);
|
|
// Decrease Width
|
|
decWidthButton.setBackground(MenuBG);
|
|
decWidthButton.setToolTipText(xlate("Decrease_Width"));
|
|
decWidthButton.setFocusable(false);
|
|
decWidthButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doDecreaseWidthCommand();
|
|
}
|
|
}
|
|
);
|
|
toolBar.add(decWidthButton);
|
|
// Increase Width
|
|
incWidthButton.setBackground(MenuBG);
|
|
incWidthButton.setToolTipText(xlate("Increase_Width"));
|
|
incWidthButton.setFocusable(false);
|
|
incWidthButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doIncreaseWidthCommand();
|
|
}
|
|
}
|
|
);
|
|
toolBar.add(incWidthButton);
|
|
// Decrease Height
|
|
decHeightButton.setBackground(MenuBG);
|
|
decHeightButton.setToolTipText(xlate("Decrease_Height"));
|
|
decHeightButton.setFocusable(false);
|
|
decHeightButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doDecreaseHeightCommand();
|
|
}
|
|
}
|
|
);
|
|
toolBar.add(decHeightButton);
|
|
// Increase Height
|
|
incHeightButton.setBackground(MenuBG);
|
|
incHeightButton.setToolTipText(xlate("Increase_Height"));
|
|
incHeightButton.setFocusable(false);
|
|
incHeightButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doIncreaseHeightCommand();
|
|
}
|
|
}
|
|
);
|
|
toolBar.add(incHeightButton);
|
|
//
|
|
toolBar.setFocusable(false);
|
|
toolBar.setFloatable(false);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Sets up the navigation bar.
|
|
*
|
|
**/
|
|
|
|
public void initNavBar() {
|
|
navBar.setBorder(null);
|
|
|
|
// Page Back
|
|
minusPageButton.setBackground(MenuBG);
|
|
minusPageButton.setToolTipText(xlate("Page_Back"));
|
|
minusPageButton.setFocusable(false);
|
|
minusPageButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doMinusPageCommand();
|
|
}
|
|
}
|
|
);
|
|
navBar.add(minusPageButton);
|
|
// Page Forward
|
|
plusPageButton.setBackground(MenuBG);
|
|
plusPageButton.setToolTipText(xlate("Page_Forward"));
|
|
plusPageButton.setFocusable(false);
|
|
plusPageButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doPlusPageCommand();
|
|
}
|
|
}
|
|
);
|
|
navBar.add(plusPageButton);
|
|
// Row Back
|
|
minusRowButton.setBackground(MenuBG);
|
|
minusRowButton.setToolTipText(xlate("Row_Back"));
|
|
minusRowButton.setFocusable(false);
|
|
minusRowButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doMinusRowCommand();
|
|
}
|
|
}
|
|
);
|
|
navBar.add(minusRowButton);
|
|
// Row Forward
|
|
plusRowButton.setBackground(MenuBG);
|
|
plusRowButton.setToolTipText(xlate("Row_Forward"));
|
|
plusRowButton.setFocusable(false);
|
|
plusRowButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doPlusRowCommand();
|
|
}
|
|
}
|
|
);
|
|
navBar.add(plusRowButton);
|
|
// Tile Back
|
|
minusTileButton.setBackground(MenuBG);
|
|
minusTileButton.setToolTipText(xlate("Tile_Back"));
|
|
minusTileButton.setFocusable(false);
|
|
minusTileButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doMinusTileCommand();
|
|
}
|
|
}
|
|
);
|
|
navBar.add(minusTileButton);
|
|
// Tile Forward
|
|
plusTileButton.setBackground(MenuBG);
|
|
plusTileButton.setToolTipText(xlate("Tile_Forward"));
|
|
plusTileButton.setFocusable(false);
|
|
plusTileButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doPlusTileCommand();
|
|
}
|
|
}
|
|
);
|
|
navBar.add(plusTileButton);
|
|
// Byte Back
|
|
minusByteButton.setBackground(MenuBG);
|
|
minusByteButton.setToolTipText(xlate("Byte_Back"));
|
|
minusByteButton.setFocusable(false);
|
|
minusByteButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doMinusByteCommand();
|
|
}
|
|
}
|
|
);
|
|
navBar.add(minusByteButton);
|
|
// Byte Forward
|
|
plusByteButton.setBackground(MenuBG);
|
|
plusByteButton.setToolTipText(xlate("Byte_Forward"));
|
|
plusByteButton.setFocusable(false);
|
|
plusByteButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doPlusByteCommand();
|
|
}
|
|
}
|
|
);
|
|
navBar.add(plusByteButton);
|
|
//
|
|
navBar.setFloatable(false);
|
|
navBar.setFocusable(false);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Sets up the tool palette.
|
|
*
|
|
**/
|
|
|
|
private void initToolPalette() {
|
|
toolPalette.setBorder(null);
|
|
toolPalette.setBackground(AsideBG);
|
|
// Selection
|
|
selectButton.setBackground(AsideBG);
|
|
selectButton.setToolTipText(xlate("Selection"));
|
|
selectButton.setFocusable(false);
|
|
selectButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
tool = SELECT_TOOL;
|
|
}
|
|
}
|
|
);
|
|
toolPalette.add(selectButton);
|
|
// Zoom
|
|
zoomButton.setBackground(AsideBG);
|
|
zoomButton.setToolTipText(xlate("Zoom"));
|
|
zoomButton.setFocusable(false);
|
|
zoomButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
tool = ZOOM_TOOL;
|
|
}
|
|
}
|
|
);
|
|
toolPalette.add(zoomButton);
|
|
// Dropper
|
|
pickupButton.setBackground(AsideBG);
|
|
pickupButton.setToolTipText(xlate("Dropper"));
|
|
pickupButton.setFocusable(false);
|
|
pickupButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
tool = PICKUP_TOOL;
|
|
}
|
|
}
|
|
);
|
|
toolPalette.add(pickupButton);
|
|
// Brush
|
|
brushButton.setBackground(AsideBG);
|
|
brushButton.setToolTipText(xlate("Brush"));
|
|
brushButton.setFocusable(false);
|
|
brushButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
tool = BRUSH_TOOL;
|
|
}
|
|
}
|
|
);
|
|
toolPalette.add(brushButton);
|
|
// Line
|
|
lineButton.setBackground(AsideBG);
|
|
lineButton.setToolTipText(xlate("Line"));
|
|
lineButton.setFocusable(false);
|
|
lineButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
tool = LINE_TOOL;
|
|
}
|
|
}
|
|
);
|
|
toolPalette.add(lineButton);
|
|
// Flood Fill
|
|
fillButton.setBackground(AsideBG);
|
|
fillButton.setToolTipText(xlate("Flood_Fill"));
|
|
fillButton.setFocusable(false);
|
|
fillButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
tool = FILL_TOOL;
|
|
}
|
|
}
|
|
);
|
|
toolPalette.add(fillButton);
|
|
// Color Replacer
|
|
replaceButton.setBackground(AsideBG);
|
|
replaceButton.setToolTipText(xlate("Color_Replacer"));
|
|
replaceButton.setFocusable(false);
|
|
replaceButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
tool = REPLACE_TOOL;
|
|
}
|
|
}
|
|
);
|
|
toolPalette.add(replaceButton);
|
|
// Mover
|
|
moveButton.setBackground(AsideBG);
|
|
moveButton.setToolTipText(xlate("Mover"));
|
|
moveButton.setFocusable(false);
|
|
moveButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
tool = MOVE_TOOL;
|
|
}
|
|
}
|
|
);
|
|
toolPalette.add(moveButton);
|
|
//
|
|
toolPalette.setFloatable(false);
|
|
toolPalette.setFocusable(false);
|
|
|
|
toolButtonGroup.add(selectButton);
|
|
toolButtonGroup.add(zoomButton);
|
|
toolButtonGroup.add(pickupButton);
|
|
toolButtonGroup.add(brushButton);
|
|
toolButtonGroup.add(lineButton);
|
|
toolButtonGroup.add(fillButton);
|
|
toolButtonGroup.add(replaceButton);
|
|
toolButtonGroup.add(moveButton);
|
|
selectButton.setSelected(true); // starting tool
|
|
//toolPalette.setBorder(new BevelBorder(BevelBorder.LOWERED));
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Sets up the selection palette.
|
|
*
|
|
**/
|
|
|
|
public void initSelectionToolBar() {
|
|
selectionToolBar.setBorder(null);
|
|
// Mirror
|
|
mirrorButton.setBackground(AsideBG);
|
|
mirrorButton.setToolTipText(mirrorMenuItem.getText());
|
|
mirrorButton.setFocusable(false);
|
|
mirrorButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doMirrorCommand();
|
|
}
|
|
}
|
|
);
|
|
selectionToolBar.add(mirrorButton);
|
|
// Flip
|
|
flipButton.setBackground(AsideBG);
|
|
flipButton.setToolTipText(flipMenuItem.getText());
|
|
flipButton.setFocusable(false);
|
|
flipButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doFlipCommand();
|
|
}
|
|
}
|
|
);
|
|
selectionToolBar.add(flipButton);
|
|
// Rotate Right
|
|
rotateRightButton.setBackground(AsideBG);
|
|
rotateRightButton.setToolTipText(rotateRightMenuItem.getText());
|
|
rotateRightButton.setFocusable(false);
|
|
rotateRightButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doRotateRightCommand();
|
|
}
|
|
}
|
|
);
|
|
selectionToolBar.add(rotateRightButton);
|
|
// Rotate Left
|
|
rotateLeftButton.setBackground(AsideBG);
|
|
rotateLeftButton.setToolTipText(rotateLeftMenuItem.getText());
|
|
rotateLeftButton.setFocusable(false);
|
|
rotateLeftButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doRotateLeftCommand();
|
|
}
|
|
}
|
|
);
|
|
selectionToolBar.add(rotateLeftButton);
|
|
// Shift Left
|
|
shiftLeftButton.setBackground(AsideBG);
|
|
shiftLeftButton.setToolTipText(shiftLeftMenuItem.getText());
|
|
shiftLeftButton.setFocusable(false);
|
|
shiftLeftButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doShiftLeftCommand();
|
|
}
|
|
}
|
|
);
|
|
selectionToolBar.add(shiftLeftButton);
|
|
// Shift Right
|
|
shiftRightButton.setBackground(AsideBG);
|
|
shiftRightButton.setToolTipText(shiftRightMenuItem.getText());
|
|
shiftRightButton.setFocusable(false);
|
|
shiftRightButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doShiftRightCommand();
|
|
}
|
|
}
|
|
);
|
|
selectionToolBar.add(shiftRightButton);
|
|
// Shift Up
|
|
shiftUpButton.setBackground(AsideBG);
|
|
shiftUpButton.setToolTipText(shiftUpMenuItem.getText());
|
|
shiftUpButton.setFocusable(false);
|
|
shiftUpButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doShiftUpCommand();
|
|
}
|
|
}
|
|
);
|
|
selectionToolBar.add(shiftUpButton);
|
|
// Shift Down
|
|
shiftDownButton.setBackground(AsideBG);
|
|
shiftDownButton.setToolTipText(shiftDownMenuItem.getText());
|
|
shiftDownButton.setFocusable(false);
|
|
shiftDownButton.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doShiftDownCommand();
|
|
}
|
|
}
|
|
);
|
|
selectionToolBar.add(shiftDownButton);
|
|
//
|
|
selectionToolBar.setFloatable(false);
|
|
selectionToolBar.setFocusable(false);
|
|
//selectionToolBar.setBorder(new BevelBorder(BevelBorder.LOWERED));
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Sets up the menu bar.
|
|
*
|
|
**/
|
|
|
|
private void initMenuBar() {
|
|
// File menu
|
|
fileMenu.setMnemonic(KeyEvent.VK_F);
|
|
// New
|
|
newMenuItem.setMnemonic(KeyEvent.VK_N);
|
|
newMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_N, Event.CTRL_MASK));
|
|
newMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doNewCommand();
|
|
}
|
|
}
|
|
);
|
|
fileMenu.add(newMenuItem);
|
|
// Open
|
|
openMenuItem.setMnemonic(KeyEvent.VK_O);
|
|
openMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_O, Event.CTRL_MASK));
|
|
openMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doOpenCommand();
|
|
}
|
|
}
|
|
);
|
|
fileMenu.add(openMenuItem);
|
|
// Reopen
|
|
reopenMenu.setMnemonic(KeyEvent.VK_R);
|
|
fileMenu.add(reopenMenu);
|
|
// Close
|
|
closeMenuItem.setMnemonic(KeyEvent.VK_C);
|
|
closeMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doCloseCommand();
|
|
}
|
|
}
|
|
);
|
|
fileMenu.add(closeMenuItem);
|
|
// Close All
|
|
closeAllMenuItem.setMnemonic(KeyEvent.VK_E);
|
|
closeAllMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doCloseAllCommand();
|
|
}
|
|
}
|
|
);
|
|
fileMenu.add(closeAllMenuItem);
|
|
//
|
|
//fileMenu.add(separator);
|
|
// Save
|
|
saveMenuItem.setMnemonic(KeyEvent.VK_S);
|
|
saveMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S, Event.CTRL_MASK));
|
|
saveMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doSaveCommand();
|
|
}
|
|
}
|
|
);
|
|
fileMenu.add(saveMenuItem);
|
|
// Save As
|
|
saveAsMenuItem.setMnemonic(KeyEvent.VK_A);
|
|
saveAsMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doSaveAsCommand();
|
|
}
|
|
}
|
|
);
|
|
fileMenu.add(saveAsMenuItem);
|
|
// Save All
|
|
saveAllMenuItem.setMnemonic(KeyEvent.VK_L);
|
|
saveAllMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doSaveAllCommand();
|
|
}
|
|
}
|
|
);
|
|
fileMenu.add(saveAllMenuItem);
|
|
//
|
|
fileMenu.add(separator);
|
|
// Exit
|
|
exitMenuItem.setMnemonic(KeyEvent.VK_X);
|
|
exitMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doExitCommand();
|
|
}
|
|
}
|
|
);
|
|
fileMenu.add(exitMenuItem);
|
|
menuBar.add(fileMenu);
|
|
// Edit menu
|
|
editMenu.setMnemonic(KeyEvent.VK_E);
|
|
// Undo
|
|
undoMenuItem.setMnemonic(KeyEvent.VK_U);
|
|
undoMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_Z, Event.CTRL_MASK));
|
|
undoMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doUndoCommand();
|
|
}
|
|
}
|
|
);
|
|
editMenu.add(undoMenuItem);
|
|
// Redo
|
|
redoMenuItem.setMnemonic(KeyEvent.VK_R);
|
|
redoMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_Y, Event.CTRL_MASK));
|
|
redoMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doRedoCommand();
|
|
}
|
|
}
|
|
);
|
|
editMenu.add(redoMenuItem);
|
|
//
|
|
editMenu.add(separator);
|
|
// Cut
|
|
cutMenuItem.setMnemonic(KeyEvent.VK_T);
|
|
cutMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_X, Event.CTRL_MASK));
|
|
cutMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doCutCommand();
|
|
}
|
|
}
|
|
);
|
|
editMenu.add(cutMenuItem);
|
|
// Copy
|
|
copyMenuItem.setMnemonic(KeyEvent.VK_C);
|
|
copyMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_C, Event.CTRL_MASK));
|
|
copyMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doCopyCommand();
|
|
}
|
|
}
|
|
);
|
|
editMenu.add(copyMenuItem);
|
|
// Paste
|
|
pasteMenuItem.setMnemonic(KeyEvent.VK_P);
|
|
pasteMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_V, Event.CTRL_MASK));
|
|
pasteMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doPasteCommand();
|
|
}
|
|
}
|
|
);
|
|
editMenu.add(pasteMenuItem);
|
|
// Clear
|
|
clearMenuItem.setMnemonic(KeyEvent.VK_L);
|
|
clearMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_DELETE, 0));
|
|
clearMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doClearCommand();
|
|
}
|
|
}
|
|
);
|
|
editMenu.add(clearMenuItem);
|
|
//
|
|
editMenu.add(separator);
|
|
// Select All
|
|
selectAllMenuItem.setMnemonic(KeyEvent.VK_S);
|
|
selectAllMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_A, Event.CTRL_MASK));
|
|
selectAllMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doSelectAllCommand();
|
|
}
|
|
}
|
|
);
|
|
editMenu.add(selectAllMenuItem);
|
|
//
|
|
editMenu.add(separator);
|
|
// Copy To...
|
|
copyToMenuItem.setMnemonic(KeyEvent.VK_O);
|
|
copyToMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doCopyToCommand();
|
|
}
|
|
}
|
|
);
|
|
editMenu.add(copyToMenuItem);
|
|
// Paste From...
|
|
pasteFromMenuItem.setMnemonic(KeyEvent.VK_F);
|
|
pasteFromMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doPasteFromCommand();
|
|
}
|
|
}
|
|
);
|
|
editMenu.add(pasteFromMenuItem);
|
|
menuBar.add(editMenu);
|
|
// View menu
|
|
viewMenu.setMnemonic(KeyEvent.VK_V);
|
|
// Codec submenu
|
|
viewMenu.add(tileCodecMenu);
|
|
// Zoom submenu
|
|
zoomMenu.setMnemonic(KeyEvent.VK_Z);
|
|
// In
|
|
zoomInMenuItem.setMnemonic(KeyEvent.VK_I);
|
|
zoomInMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doZoomInCommand();
|
|
}
|
|
}
|
|
);
|
|
zoomMenu.add(zoomInMenuItem);
|
|
// Out
|
|
zoomOutMenuItem.setMnemonic(KeyEvent.VK_O);
|
|
zoomOutMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doZoomOutCommand();
|
|
}
|
|
}
|
|
);
|
|
zoomMenu.add(zoomOutMenuItem);
|
|
//
|
|
zoomMenu.add(separator);
|
|
// 100%
|
|
_100MenuItem.setMnemonic(KeyEvent.VK_1);
|
|
_100MenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doZoomCommand(1.0);
|
|
}
|
|
}
|
|
);
|
|
zoomMenu.add(_100MenuItem);
|
|
// 200%
|
|
_200MenuItem.setMnemonic(KeyEvent.VK_2);
|
|
_200MenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doZoomCommand(2.0);
|
|
}
|
|
}
|
|
);
|
|
zoomMenu.add(_200MenuItem);
|
|
// 400%
|
|
_400MenuItem.setMnemonic(KeyEvent.VK_4);
|
|
_400MenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doZoomCommand(4.0);
|
|
}
|
|
}
|
|
);
|
|
zoomMenu.add(_400MenuItem);
|
|
// 800%
|
|
_800MenuItem.setMnemonic(KeyEvent.VK_8);
|
|
_800MenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doZoomCommand(8.0);
|
|
}
|
|
}
|
|
);
|
|
zoomMenu.add(_800MenuItem);
|
|
// 1600%
|
|
_1600MenuItem.setMnemonic(KeyEvent.VK_6);
|
|
_1600MenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doZoomCommand(16.0);
|
|
}
|
|
}
|
|
);
|
|
zoomMenu.add(_1600MenuItem);
|
|
// 3200%
|
|
_3200MenuItem.setMnemonic(KeyEvent.VK_3);
|
|
_3200MenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doZoomCommand(32.0);
|
|
}
|
|
}
|
|
);
|
|
zoomMenu.add(_3200MenuItem);
|
|
viewMenu.add(zoomMenu);
|
|
// Mode submenu
|
|
modeMenu.setMnemonic(KeyEvent.VK_M);
|
|
// 1-Dimensional
|
|
_1DimensionalMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doModeCommand(TileCodec.MODE_1D);
|
|
_1DimensionalMenuItem.setSelected(true);
|
|
}
|
|
}
|
|
);
|
|
modeMenu.add(_1DimensionalMenuItem);
|
|
// 2-Dimensional
|
|
_2DimensionalMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doModeCommand(TileCodec.MODE_2D);
|
|
_2DimensionalMenuItem.setSelected(true);
|
|
}
|
|
}
|
|
);
|
|
modeMenu.add(_2DimensionalMenuItem);
|
|
viewMenu.add(modeMenu);
|
|
// create button group for modes
|
|
modeButtonGroup.add(_1DimensionalMenuItem);
|
|
modeButtonGroup.add(_2DimensionalMenuItem);
|
|
//
|
|
viewMenu.add(separator);
|
|
// Block Size
|
|
blockSizeMenu.setMnemonic(KeyEvent.VK_B);
|
|
// Full Canvas
|
|
sizeBlockToCanvasMenuItem.setMnemonic(KeyEvent.VK_F);
|
|
sizeBlockToCanvasMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doSizeBlockToCanvasCommand();
|
|
}
|
|
}
|
|
);
|
|
blockSizeMenu.add(sizeBlockToCanvasMenuItem);
|
|
//
|
|
blockSizeMenu.add(separator);
|
|
// Custom Block Size
|
|
customBlockSizeMenuItem.setMnemonic(KeyEvent.VK_C);
|
|
customBlockSizeMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doCustomBlockSizeCommand();
|
|
}
|
|
}
|
|
);
|
|
blockSizeMenu.add(customBlockSizeMenuItem);
|
|
viewMenu.add(blockSizeMenu);
|
|
// Row-interleave Blocks
|
|
rowInterleaveBlocksMenuItem.setMnemonic(KeyEvent.VK_R);
|
|
rowInterleaveBlocksMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doRowInterleaveBlocksCommand();
|
|
}
|
|
}
|
|
);
|
|
viewMenu.add(rowInterleaveBlocksMenuItem);
|
|
//
|
|
viewMenu.add(separator);
|
|
// Block Grid
|
|
blockGridMenuItem.setMnemonic(KeyEvent.VK_V);
|
|
blockGridMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doBlockGridCommand();
|
|
}
|
|
}
|
|
);
|
|
viewMenu.add(blockGridMenuItem);
|
|
// Tile Grid
|
|
tileGridMenuItem.setMnemonic(KeyEvent.VK_A);
|
|
tileGridMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doTileGridCommand();
|
|
}
|
|
}
|
|
);
|
|
viewMenu.add(tileGridMenuItem);
|
|
// Pixel Grid
|
|
pixelGridMenuItem.setMnemonic(KeyEvent.VK_P);
|
|
pixelGridMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doPixelGridCommand();
|
|
}
|
|
}
|
|
);
|
|
viewMenu.add(pixelGridMenuItem);
|
|
//
|
|
viewMenu.add(separator);
|
|
// Statusbar
|
|
statusBarMenuItem.setMnemonic(KeyEvent.VK_S);
|
|
statusBarMenuItem.setSelected(viewStatusBar);
|
|
statusBarMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doStatusBarCommand();
|
|
}
|
|
}
|
|
);
|
|
viewMenu.add(statusBarMenuItem);
|
|
// Toolbar
|
|
toolBarMenuItem.setMnemonic(KeyEvent.VK_T);
|
|
toolBarMenuItem.setSelected(viewToolBar);
|
|
toolBarMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doToolBarCommand();
|
|
}
|
|
}
|
|
);
|
|
viewMenu.add(toolBarMenuItem);
|
|
menuBar.add(viewMenu);
|
|
// Image menu
|
|
imageMenu.setMnemonic(KeyEvent.VK_I);
|
|
// Mirror
|
|
mirrorMenuItem.setMnemonic(KeyEvent.VK_M);
|
|
mirrorMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_M, Event.CTRL_MASK));
|
|
mirrorMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doMirrorCommand();
|
|
}
|
|
}
|
|
);
|
|
imageMenu.add(mirrorMenuItem);
|
|
// Flip
|
|
flipMenuItem.setMnemonic(KeyEvent.VK_F);
|
|
flipMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_I, Event.CTRL_MASK));
|
|
flipMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doFlipCommand();
|
|
}
|
|
}
|
|
);
|
|
imageMenu.add(flipMenuItem);
|
|
//
|
|
imageMenu.add(separator);
|
|
// Rotate Right
|
|
rotateRightMenuItem.setMnemonic(KeyEvent.VK_O);
|
|
rotateRightMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doRotateRightCommand();
|
|
}
|
|
}
|
|
);
|
|
imageMenu.add(rotateRightMenuItem);
|
|
// Rotate Left
|
|
rotateLeftMenuItem.setMnemonic(KeyEvent.VK_A);
|
|
rotateLeftMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doRotateLeftCommand();
|
|
}
|
|
}
|
|
);
|
|
imageMenu.add(rotateLeftMenuItem);
|
|
//
|
|
imageMenu.add(separator);
|
|
// Shift Left
|
|
shiftLeftMenuItem.setMnemonic(KeyEvent.VK_L);
|
|
// shiftLeftMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_LEFT, Event.SHIFT_MASK));
|
|
shiftLeftMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doShiftLeftCommand();
|
|
}
|
|
}
|
|
);
|
|
imageMenu.add(shiftLeftMenuItem);
|
|
// Shift Right
|
|
shiftRightMenuItem.setMnemonic(KeyEvent.VK_R);
|
|
// shiftRightMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_RIGHT, Event.SHIFT_MASK));
|
|
shiftRightMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doShiftRightCommand();
|
|
}
|
|
}
|
|
);
|
|
imageMenu.add(shiftRightMenuItem);
|
|
// Shift Up
|
|
shiftUpMenuItem.setMnemonic(KeyEvent.VK_U);
|
|
// shiftUpMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_UP, Event.SHIFT_MASK));
|
|
shiftUpMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doShiftUpCommand();
|
|
}
|
|
}
|
|
);
|
|
imageMenu.add(shiftUpMenuItem);
|
|
// Shift Down
|
|
shiftDownMenuItem.setMnemonic(KeyEvent.VK_D);
|
|
// shiftDownMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_DOWN, Event.SHIFT_MASK));
|
|
shiftDownMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doShiftDownCommand();
|
|
}
|
|
}
|
|
);
|
|
imageMenu.add(shiftDownMenuItem);
|
|
//
|
|
imageMenu.add(separator);
|
|
// Canvas Size...
|
|
canvasSizeMenuItem.setMnemonic(KeyEvent.VK_S);
|
|
canvasSizeMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doCanvasSizeCommand();
|
|
}
|
|
}
|
|
);
|
|
imageMenu.add(canvasSizeMenuItem);
|
|
// Stretch...
|
|
stretchMenuItem.setMnemonic(KeyEvent.VK_E);
|
|
stretchMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doStretchCommand();
|
|
}
|
|
}
|
|
);
|
|
imageMenu.add(stretchMenuItem);
|
|
menuBar.add(imageMenu);
|
|
// Navigate menu
|
|
navigateMenu.setMnemonic(KeyEvent.VK_N);
|
|
// Go To
|
|
goToMenuItem.setMnemonic(KeyEvent.VK_G);
|
|
goToMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_G, Event.CTRL_MASK));
|
|
goToMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doGoToCommand();
|
|
}
|
|
}
|
|
);
|
|
navigateMenu.add(goToMenuItem);
|
|
// Go To Again
|
|
goToAgainMenuItem.setMnemonic(KeyEvent.VK_A);
|
|
goToAgainMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F5, 0));
|
|
goToAgainMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doGoToAgainCommand();
|
|
}
|
|
}
|
|
);
|
|
navigateMenu.add(goToAgainMenuItem);
|
|
//
|
|
navigateMenu.add(separator);
|
|
// Add To Bookmarks
|
|
addToBookmarksMenuItem.setMnemonic(KeyEvent.VK_A);
|
|
addToBookmarksMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doAddToBookmarksCommand();
|
|
}
|
|
}
|
|
);
|
|
navigateMenu.add(addToBookmarksMenuItem);
|
|
// Organize Bookmarks
|
|
organizeBookmarksMenuItem.setMnemonic(KeyEvent.VK_O);
|
|
organizeBookmarksMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doOrganizeBookmarksCommand();
|
|
}
|
|
}
|
|
);
|
|
navigateMenu.add(organizeBookmarksMenuItem);
|
|
//
|
|
menuBar.add(navigateMenu);
|
|
// Palette menu
|
|
paletteMenu.setMnemonic(KeyEvent.VK_P);
|
|
// Edit Colors...
|
|
editColorsMenuItem.setMnemonic(KeyEvent.VK_E);
|
|
editColorsMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doEditColorsCommand();
|
|
}
|
|
}
|
|
);
|
|
paletteMenu.add(editColorsMenuItem);
|
|
// Format submenu
|
|
colorCodecMenu.setMnemonic(KeyEvent.VK_F);
|
|
paletteMenu.add(colorCodecMenu);
|
|
// Endianness submenu
|
|
paletteEndiannessMenu.setMnemonic(KeyEvent.VK_N);
|
|
// Little endian
|
|
paletteLittleEndianMenuItem.setMnemonic(KeyEvent.VK_L);
|
|
paletteLittleEndianMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doPaletteEndiannessCommand(ColorCodec.LITTLE_ENDIAN);
|
|
}
|
|
}
|
|
);
|
|
paletteEndiannessMenu.add(paletteLittleEndianMenuItem);
|
|
// Big endian
|
|
paletteBigEndianMenuItem.setMnemonic(KeyEvent.VK_B);
|
|
paletteBigEndianMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doPaletteEndiannessCommand(ColorCodec.BIG_ENDIAN);
|
|
}
|
|
}
|
|
);
|
|
paletteEndiannessMenu.add(paletteBigEndianMenuItem);
|
|
// create button group for palette endianness
|
|
paletteEndiannessButtonGroup.add(paletteLittleEndianMenuItem);
|
|
paletteEndiannessButtonGroup.add(paletteBigEndianMenuItem);
|
|
//
|
|
paletteMenu.add(paletteEndiannessMenu);
|
|
// Size...
|
|
paletteSizeMenuItem.setMnemonic(KeyEvent.VK_S);
|
|
paletteSizeMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doPaletteSizeCommand();
|
|
}
|
|
}
|
|
);
|
|
paletteMenu.add(paletteSizeMenuItem);
|
|
//
|
|
paletteMenu.add(separator);
|
|
// New...
|
|
newPaletteMenuItem.setMnemonic(KeyEvent.VK_N);
|
|
newPaletteMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doNewPaletteCommand();
|
|
}
|
|
}
|
|
);
|
|
paletteMenu.add(newPaletteMenuItem);
|
|
// Import From submenu
|
|
importPaletteMenu.setMnemonic(KeyEvent.VK_I);
|
|
// Import From This File...
|
|
importInternalPaletteMenuItem.setMnemonic(KeyEvent.VK_T);
|
|
importInternalPaletteMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doImportInternalPaletteCommand();
|
|
}
|
|
}
|
|
);
|
|
importPaletteMenu.add(importInternalPaletteMenuItem);
|
|
// Import From Another File...
|
|
importExternalPaletteMenuItem.setMnemonic(KeyEvent.VK_A);
|
|
importExternalPaletteMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doImportExternalPaletteCommand();
|
|
}
|
|
}
|
|
);
|
|
importPaletteMenu.add(importExternalPaletteMenuItem);
|
|
paletteMenu.add(importPaletteMenu);
|
|
//
|
|
paletteMenu.add(separator);
|
|
// Add To Palettes...
|
|
addToPalettesMenuItem.setMnemonic(KeyEvent.VK_A);
|
|
addToPalettesMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doAddToPalettesCommand();
|
|
}
|
|
}
|
|
);
|
|
paletteMenu.add(addToPalettesMenuItem);
|
|
// Organize Palettes...
|
|
organizePalettesMenuItem.setMnemonic(KeyEvent.VK_O);
|
|
organizePalettesMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doOrganizePalettesCommand();
|
|
}
|
|
}
|
|
);
|
|
paletteMenu.add(organizePalettesMenuItem);
|
|
menuBar.add(paletteMenu);
|
|
// Window menu
|
|
windowMenu.setMnemonic(KeyEvent.VK_W);
|
|
// New Window
|
|
newWindowMenuItem.setMnemonic(KeyEvent.VK_N);
|
|
newWindowMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doNewWindowCommand();
|
|
}
|
|
}
|
|
);
|
|
windowMenu.add(newWindowMenuItem);
|
|
//
|
|
windowMenu.add(separator);
|
|
// Tile
|
|
tileMenuItem.setMnemonic(KeyEvent.VK_T);
|
|
tileMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doTileCommand();
|
|
}
|
|
}
|
|
);
|
|
windowMenu.add(tileMenuItem);
|
|
// Cascade
|
|
cascadeMenuItem.setMnemonic(KeyEvent.VK_C);
|
|
cascadeMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doCascadeCommand();
|
|
}
|
|
}
|
|
);
|
|
windowMenu.add(cascadeMenuItem);
|
|
// Arrange Icons
|
|
arrangeIconsMenuItem.setMnemonic(KeyEvent.VK_I);
|
|
arrangeIconsMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doArrangeIconsCommand();
|
|
}
|
|
}
|
|
);
|
|
windowMenu.add(arrangeIconsMenuItem);
|
|
menuBar.add(windowMenu);
|
|
// Help menu
|
|
helpMenu.setMnemonic(KeyEvent.VK_H);
|
|
// Help Topics
|
|
helpTopicsMenuItem.setMnemonic(KeyEvent.VK_H);
|
|
helpTopicsMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F1, 0));
|
|
helpTopicsMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doHelpTopicsCommand();
|
|
}
|
|
}
|
|
);
|
|
helpMenu.add(helpTopicsMenuItem);
|
|
|
|
// About
|
|
aboutMenuItem.setMnemonic(KeyEvent.VK_A);
|
|
aboutMenuItem.addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doAboutCommand();
|
|
}
|
|
}
|
|
);
|
|
helpMenu.add(aboutMenuItem);
|
|
menuBar.add(helpMenu);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// Begin code for handling menu commands
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "New".
|
|
* Prompts the user to enter the desired file size, then creates a new
|
|
* FileImage and a default view + palette.
|
|
*
|
|
**/
|
|
|
|
public void doNewCommand() {
|
|
// Show dialog for creating new file
|
|
//TMNewFileDialog newFileDialog = new TMNewFileDialog(this, xl);
|
|
int retVal = newFileDialog.showDialog();
|
|
if (retVal == JOptionPane.OK_OPTION) {
|
|
// create fileimage
|
|
FileImage img = new FileImage(newFileDialog.getFileSize());
|
|
new TMFileResources(img, this);
|
|
// create view for it
|
|
TileCodec tc = (TileCodec)tilecodecs.get(0); // default
|
|
TMPalette pal = new TMPalette("PAL000", TMPalette.defaultPalette, getColorCodecByID("CF01"), ColorCodec.LITTLE_ENDIAN, true);
|
|
addViewToDesktop(createView(img, tc, pal, TileCodec.MODE_1D));
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Open...".
|
|
* User selects file from standard file dialog, the file is
|
|
* opened and a default view + palette is assigned.
|
|
*
|
|
**/
|
|
|
|
public void doOpenCommand() {
|
|
// set to directory of selected file, if there is one
|
|
System.out.println(lastPath);
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
this.fileOpenChooser.setCurrentDirectory(view.getFileImage().getFile().getParentFile());
|
|
} else if (new File(this.lastPath).exists()) {
|
|
this.fileOpenChooser.setCurrentDirectory(new File(this.lastPath));
|
|
} else {
|
|
this.fileOpenChooser.setCurrentDirectory(new File("."));
|
|
}
|
|
|
|
// have the user select a file
|
|
int retVal = fileOpenChooser.showOpenDialog(this);
|
|
if (retVal == JFileChooser.APPROVE_OPTION) {
|
|
// get the selected file and open it
|
|
File file = fileOpenChooser.getSelectedFile();
|
|
//updates the last path opened
|
|
lastPath = file.getPath().substring(0,file.getPath().lastIndexOf(File.separator));
|
|
openFile(file);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Close".
|
|
* Closes a view. If it is the last (only) view of a FileImage,
|
|
* and the file is modified, the user is prompted to save the file.
|
|
*
|
|
**/
|
|
|
|
public void doCloseCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
FileImage img = view.getFileImage();
|
|
|
|
// check if it's the last view
|
|
if (img.getViews().length == 1) {
|
|
saveResources(img); // TODO
|
|
// check if saving required/desired
|
|
if (img.isModified()) {
|
|
int retVal = JOptionPane.showConfirmDialog(this,
|
|
xlate("Save_Changes_To")+" "+img.getName()+"?", "Tile Mangler",
|
|
JOptionPane.YES_NO_CANCEL_OPTION, JOptionPane.INFORMATION_MESSAGE);
|
|
if (retVal == JOptionPane.YES_OPTION) {
|
|
doSaveCommand();
|
|
}
|
|
else if (retVal == JOptionPane.NO_OPTION) {
|
|
}
|
|
else if (retVal == JOptionPane.CANCEL_OPTION) {
|
|
return; // return to program without saving and/or closing
|
|
}
|
|
}
|
|
// remove potential file listener
|
|
fileListenerHashtable.remove(img.getContents());
|
|
}
|
|
|
|
// update recent files
|
|
File f = new File(img.getFile().getAbsolutePath());
|
|
addToRecentFiles(f);
|
|
buildReopenMenu();
|
|
|
|
// remove view from the FileImage and desktop
|
|
img.removeView(view);
|
|
desktop.remove(view);
|
|
view.dispose();
|
|
desktop.revalidate();
|
|
desktop.repaint();
|
|
|
|
img = null;
|
|
view = null;
|
|
System.gc();
|
|
}
|
|
|
|
desktop.setSelectedFrame(null);
|
|
JInternalFrame[] frames = desktop.getAllFrames();
|
|
if (frames.length == 0) {
|
|
// no more frames left on the desktop, hide MDI menus and toolbars
|
|
disableMDIStuff();
|
|
setTitle("Tile Mangler");
|
|
}
|
|
else {
|
|
// select a random frame (Swing doesn't do it for you...)
|
|
try {
|
|
frames[0].setSelected(true);
|
|
}
|
|
catch (Exception e) { }
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Saves the resources for the given fileimage to a file in XML format.
|
|
*
|
|
**/
|
|
|
|
public void saveResources(FileImage img) {
|
|
// TODO: should only save if # bookmarks | # of palettes > 0?
|
|
File resourceFile = TMFileResources.getResourceFileFor(img.getFile());
|
|
try {
|
|
File res = new File("./resources");
|
|
if (!res.exists()) {
|
|
res.mkdir();
|
|
}
|
|
FileWriter fw = new FileWriter(resourceFile);
|
|
fw.write(img.getResources().toXML());
|
|
fw.close();
|
|
}
|
|
catch (Exception e) {
|
|
JOptionPane.showMessageDialog(this,
|
|
xlate("Save_Resources_Error")+"\n"+e.getMessage(),
|
|
"Tile Mangler",
|
|
JOptionPane.ERROR_MESSAGE);
|
|
}
|
|
}
|
|
|
|
public void saveBookmarks() {
|
|
// TODO
|
|
}
|
|
|
|
public void savePalettes() {
|
|
// TODO
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Close All".
|
|
* Does the same as "Close", only for all the current frames.
|
|
*
|
|
**/
|
|
|
|
public void doCloseAllCommand() {
|
|
JInternalFrame[] frames = desktop.getAllFrames();
|
|
for (int i=0; i<frames.length; i++) {
|
|
TMView view = (TMView)frames[i];
|
|
FileImage img = view.getFileImage();
|
|
if (img.getViews().length == 1) {
|
|
// check if saving required/desired
|
|
if (img.isModified()) {
|
|
int retVal = JOptionPane.showConfirmDialog(this,
|
|
xlate("Save_Changes_To")+" "+img.getName()+"?", "Tile Mangler",
|
|
JOptionPane.YES_NO_CANCEL_OPTION, JOptionPane.INFORMATION_MESSAGE);
|
|
if (retVal == JOptionPane.YES_OPTION) {
|
|
try {
|
|
view.setSelected(true);
|
|
}
|
|
catch (java.beans.PropertyVetoException x) {
|
|
x.printStackTrace();
|
|
}
|
|
doSaveCommand();
|
|
}
|
|
else if (retVal == JOptionPane.NO_OPTION) {
|
|
}
|
|
else if (retVal == JOptionPane.CANCEL_OPTION) {
|
|
return;
|
|
}
|
|
}
|
|
// remove potential file listener
|
|
fileListenerHashtable.remove(img.getContents());
|
|
}
|
|
}
|
|
|
|
// remove them all
|
|
for (int i=0; i<frames.length; i++) {
|
|
TMView view = (TMView)frames[i];
|
|
FileImage img = view.getFileImage();
|
|
|
|
saveResources(img); // TODO
|
|
|
|
addToRecentFiles(new File(img.getFile().getAbsolutePath()));
|
|
|
|
// remove the view
|
|
img.removeView(view);
|
|
desktop.remove(view);
|
|
view.dispose();
|
|
}
|
|
|
|
buildReopenMenu();
|
|
desktop.setSelectedFrame(null);
|
|
desktop.revalidate();
|
|
desktop.repaint();
|
|
disableMDIStuff();
|
|
setTitle("Tile Mangler");
|
|
|
|
System.gc();
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Save".
|
|
*
|
|
**/
|
|
|
|
public void doSaveCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
FileImage img = view.getFileImage();
|
|
File file = img.getFile();
|
|
String ext = TMFileFilter.getExtension(file);
|
|
|
|
saveResources(img); // TODO
|
|
|
|
// if (img.isModified()) {
|
|
if (file.exists()) {
|
|
if (!file.canWrite()) {
|
|
JOptionPane.showMessageDialog(this,
|
|
xlate("File_Write_Error")+"\n"+file.getName(),
|
|
"Tile Mangler",
|
|
JOptionPane.ERROR_MESSAGE);
|
|
}
|
|
else {
|
|
FileSaverThread thread = null;
|
|
byte[] contents = img.getContents();
|
|
try {
|
|
thread = new FileSaverThread(contents, file);
|
|
}
|
|
catch (Exception e) {
|
|
JOptionPane.showMessageDialog(this,
|
|
xlate("File_Save_Error")+"\n"+e.getMessage(),
|
|
"Tile Mangler",
|
|
JOptionPane.ERROR_MESSAGE);
|
|
return;
|
|
}
|
|
|
|
// see if a filelistener should be notified
|
|
TMFileListener fl = (TMFileListener)fileListenerHashtable.get(contents);
|
|
if (fl != null) {
|
|
fl.fileSaving(contents, ext);
|
|
}
|
|
|
|
// save it!
|
|
new ProgressDialog(this, thread);
|
|
img.setModified(false);
|
|
setSaveButtonsEnabled(false);
|
|
|
|
if (fl != null) {
|
|
fl.fileLoaded(contents, ext);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
doSaveAsCommand();
|
|
}
|
|
// }
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Save As...".
|
|
*
|
|
**/
|
|
|
|
public void doSaveAsCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
fileSaveChooser.setCurrentDirectory(view.getFileImage().getFile().getParentFile());
|
|
fileSaveChooser.setSelectedFile(view.getFileImage().getFile());
|
|
int retVal = fileSaveChooser.showSaveDialog(this);
|
|
if (retVal == JFileChooser.APPROVE_OPTION) {
|
|
File file = fileSaveChooser.getSelectedFile();
|
|
view.getFileImage().setFile(file);
|
|
doSaveCommand();
|
|
setTitle("Tile Mangler - "+view.getTitle());
|
|
}
|
|
}
|
|
setSaveButtonsEnabled(false);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Save All".
|
|
*
|
|
**/
|
|
|
|
public void doSaveAllCommand() {
|
|
JInternalFrame[] frames = desktop.getAllFrames();
|
|
for (int i=0; i<frames.length; i++) {
|
|
TMView view = (TMView)frames[i];
|
|
if (view.getFileImage().isModified()) {
|
|
try {
|
|
view.setSelected(true);
|
|
}
|
|
catch (java.beans.PropertyVetoException x) {
|
|
x.printStackTrace();
|
|
}
|
|
doSaveCommand();
|
|
}
|
|
}
|
|
setSaveButtonsEnabled(false);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Exit".
|
|
*
|
|
**/
|
|
|
|
public void doExitCommand() {
|
|
doCloseAllCommand();
|
|
// if all frames were closed, the operation was successful and we can exit.
|
|
if (desktop.getAllFrames().length == 0) {
|
|
saveSettings();
|
|
System.exit(0);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Undo".
|
|
* Extracts the top item in the Undo stack and undoes it.
|
|
* Moves the item to the Redo stack.
|
|
*
|
|
**/
|
|
|
|
public void doUndoCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.undo();
|
|
refreshUndoRedo();
|
|
fileImageModified(view.getFileImage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Redo".
|
|
* Extracts the top item in the Redo stack and redoes it.
|
|
* Moves the item to the Undo stack.
|
|
*
|
|
**/
|
|
|
|
public void doRedoCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.redo();
|
|
refreshUndoRedo();
|
|
fileImageModified(view.getFileImage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Cut".
|
|
* The current selection of the selected frame is cut to the
|
|
* central selection.
|
|
*
|
|
**/
|
|
|
|
public void doCutCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
// get the frame's selection
|
|
copiedSelection = view.getEditorCanvas().cutSelection();
|
|
// enable relevant buttons
|
|
pasteButton.setEnabled(true);
|
|
pasteMenuItem.setEnabled(true);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Copy".
|
|
*
|
|
**/
|
|
|
|
public void doCopyCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
// get the frame's selection
|
|
copiedSelection = view.getEditorCanvas().copySelection();
|
|
// enable relevant buttons
|
|
pasteButton.setEnabled(true);
|
|
pasteMenuItem.setEnabled(true);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Paste".
|
|
*
|
|
**/
|
|
|
|
public void doPasteCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
if (copiedSelection != null) {
|
|
// paste selection
|
|
view.getEditorCanvas().paste(copiedSelection);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Clear".
|
|
*
|
|
**/
|
|
|
|
public void doClearCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.getEditorCanvas().clearSelection();
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Go To...".
|
|
* Shows a dialog where the user can enter an absolute or relative
|
|
* file offset to jump to. Then jumps to that offset.
|
|
*
|
|
**/
|
|
|
|
public void doGoToCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
//TMGoToDialog goToDialog = new TMGoToDialog(this, xl);
|
|
int retVal = goToDialog.showDialog();
|
|
if (retVal == JOptionPane.OK_OPTION) {
|
|
if (goToDialog.getMode() == TMGoToDialog.ABSOLUTE_MODE) {
|
|
view.setAbsoluteOffset(goToDialog.getOffset());
|
|
}
|
|
else { // RELATIVE_MODE
|
|
view.setRelativeOffset(goToDialog.getOffset());
|
|
}
|
|
view.repaint();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Go To Again".
|
|
* Only applicable when the preceding "Go To..." was of relative type.
|
|
*
|
|
**/
|
|
|
|
public void doGoToAgainCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
if (goToDialog.getMode() == TMGoToDialog.ABSOLUTE_MODE) {
|
|
view.setAbsoluteOffset(goToDialog.getOffset());
|
|
}
|
|
else { // RELATIVE_MODE
|
|
view.setRelativeOffset(goToDialog.getOffset());
|
|
}
|
|
view.repaint();
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Select All".
|
|
*
|
|
**/
|
|
|
|
public void doSelectAllCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.getEditorCanvas().selectAll();
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Copy To...".
|
|
*
|
|
**/
|
|
|
|
public void doCopyToCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
int retVal = bitmapSaveChooser.showSaveDialog(this);
|
|
if (retVal == JFileChooser.APPROVE_OPTION) {
|
|
File file = bitmapSaveChooser.getSelectedFile();
|
|
try {
|
|
TMBitmapExporter.saveTileCanvasToFile(view.getEditorCanvas().getSelectionCanvas(), file);
|
|
} catch (Exception e) {
|
|
JOptionPane.showMessageDialog(this,
|
|
xlate("Save_Bitmap_Error")+"\n"+e.getMessage(),
|
|
"Tile Mangler",
|
|
JOptionPane.ERROR_MESSAGE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Paste From...".
|
|
*
|
|
**/
|
|
|
|
public void doPasteFromCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
if (new File(this.lastPath).exists()) {
|
|
this.bitmapOpenChooser.setCurrentDirectory(new File(this.lastPath));
|
|
} else {
|
|
this.bitmapOpenChooser.setCurrentDirectory(new File("."));
|
|
}
|
|
int retVal = bitmapOpenChooser.showOpenDialog(this);
|
|
if (retVal == JFileChooser.APPROVE_OPTION) {
|
|
File file = bitmapOpenChooser.getSelectedFile();
|
|
// paste it
|
|
TMTileCanvas bitmapCanvas = null;
|
|
try {
|
|
bitmapCanvas = TMBitmapImporter.loadTileCanvasFromFile(file);
|
|
}
|
|
catch (Exception e) {
|
|
JOptionPane.showMessageDialog(this,
|
|
xlate("Load_Bitmap_Error")+"\n"+e.getMessage(),
|
|
"Tile Mangler",
|
|
JOptionPane.ERROR_MESSAGE);
|
|
return;
|
|
}
|
|
TMSelectionCanvas selCanvas = new TMSelectionCanvas(
|
|
this, bitmapCanvas, 0, 0,
|
|
bitmapCanvas.getCols(),
|
|
bitmapCanvas.getRows()
|
|
);
|
|
view.getEditorCanvas().paste(selCanvas);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Tile".
|
|
* Code ruthlessly stolen from some guy on the Java forums. Thanks and sorry. :)
|
|
*
|
|
**/
|
|
|
|
public void doTileCommand() {
|
|
JInternalFrame[] frames = desktop.getAllFrames();
|
|
// count frames that aren't iconized
|
|
int frameCount = 0;
|
|
for (int i = 0; i < frames.length; i++) {
|
|
if (!frames[i].isIcon())
|
|
frameCount++;
|
|
}
|
|
int rows = (int)Math.sqrt(frameCount);
|
|
int cols = frameCount / rows;
|
|
int extra = frameCount % rows;
|
|
// number of columns with an extra row
|
|
int width = desktop.getWidth() / cols;
|
|
int height = desktop.getHeight() / rows;
|
|
int r = 0;
|
|
int c = 0;
|
|
for (int i = 0; i < frames.length; i++) {
|
|
if (!frames[i].isIcon()) {
|
|
frames[i].reshape(c * width, r * height, width, height);
|
|
r++;
|
|
if (r == rows) {
|
|
r = 0;
|
|
c++;
|
|
if (c == cols - extra) {
|
|
// start adding an extra row
|
|
rows++;
|
|
height = desktop.getHeight() / rows;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
desktop.revalidate();
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Cascade".
|
|
* Code ruthlessly stolen from some guy on the Java forums. Thanks and sorry. :)
|
|
*
|
|
**/
|
|
|
|
public void doCascadeCommand() {
|
|
int FRAME_OFFSET = 30;
|
|
int xpos = 0, ypos = 0;
|
|
JInternalFrame frames[] = desktop.getAllFrames();
|
|
int cascadeWidth = desktop.getBounds().width - 5;
|
|
int cascadeHeight = desktop.getBounds().height - 5;
|
|
int frameHeight = cascadeHeight - frames.length * FRAME_OFFSET;
|
|
int frameWidth = cascadeWidth - frames.length * FRAME_OFFSET;
|
|
for (int i = frames.length - 1; i >= 0; i--) {
|
|
if (!frames[i].isIcon()) {
|
|
frames[i].setLocation(xpos, ypos);
|
|
xpos += FRAME_OFFSET;
|
|
ypos += FRAME_OFFSET;
|
|
}
|
|
}
|
|
desktop.revalidate();
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Arrange Icons".
|
|
*
|
|
**/
|
|
|
|
public void doArrangeIconsCommand() {
|
|
JInternalFrame[] frames = desktop.getAllFrames();
|
|
int xpos=0;
|
|
int ypos=0;
|
|
for (int i=0; i<frames.length; i++) {
|
|
if (frames[i].isIcon()) {
|
|
JInternalFrame.JDesktopIcon icon = frames[i].getDesktopIcon();
|
|
icon.setLocation(xpos, desktop.getHeight() - icon.getHeight());
|
|
xpos += icon.getWidth();
|
|
}
|
|
}
|
|
desktop.revalidate();
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Help Topics".
|
|
*
|
|
**/
|
|
|
|
public void doHelpTopicsCommand() {
|
|
File localizedHelpFile = new File("docs/help_"+locale.toString()+".htm");
|
|
if (localizedHelpFile.exists()) {
|
|
BrowserControl.displayURL("file://"+localizedHelpFile.getAbsolutePath());
|
|
}
|
|
else {
|
|
BrowserControl.displayURL("file://docs/help.htm");
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Tip".
|
|
* Just a bogus dialog.
|
|
*
|
|
**/
|
|
|
|
public void doTipCommand() {
|
|
// Show Tip dialog
|
|
JOptionPane.showConfirmDialog(this,
|
|
xlate("Drugs_Message"), "Tile Mangler",
|
|
JOptionPane.YES_NO_OPTION, JOptionPane.INFORMATION_MESSAGE);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "About".
|
|
* Displays a small dialog with info about the program.
|
|
*
|
|
**/
|
|
|
|
public void doAboutCommand()
|
|
{
|
|
JOptionPane.showMessageDialog(this,
|
|
"Tile Mangler v0.20\nby SnowBro 2003-2005 (v0.16)\nby Dr. MefistO 2013 (v0.17.2)\nby Mewster 2014-2015 (v0.19)\nby toruzz 2020 (v0.20)", "Tile Mangler",
|
|
1);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Tile Codec".
|
|
* Changes the tile codec for the current view to the specified one.
|
|
*
|
|
**/
|
|
|
|
public void doTileCodecCommand(TileCodec codec) {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.setTileCodec(codec);
|
|
refreshPalettePane();
|
|
refreshStatusBar();
|
|
refreshTileCodecSelection(view);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Zoom".
|
|
* Zooms the current frame to the given scale (1.0 = 100%, 2.0 = 200% and so on)
|
|
*
|
|
**/
|
|
|
|
public void doZoomCommand(double scale) {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.setScale(scale);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Zoom In".
|
|
* Scale += 1.0
|
|
*
|
|
**/
|
|
|
|
public void doZoomInCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.setScale(view.getScale()+1.0);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Zoom Out".
|
|
* Scale -= 1.0
|
|
*
|
|
**/
|
|
|
|
public void doZoomOutCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.setScale(view.getScale()-1.0);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Block Grid".
|
|
*
|
|
**/
|
|
|
|
public void doBlockGridCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.setBlockGridVisible(!view.isBlockGridVisible());
|
|
blockGridMenuItem.setSelected(view.isBlockGridVisible());
|
|
view.repaint();
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Tile Grid".
|
|
*
|
|
**/
|
|
|
|
public void doTileGridCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.setTileGridVisible(!view.isTileGridVisible());
|
|
tileGridMenuItem.setSelected(view.isTileGridVisible());
|
|
view.repaint();
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Pixel Grid".
|
|
*
|
|
**/
|
|
|
|
public void doPixelGridCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.setPixelGridVisible(!view.isPixelGridVisible());
|
|
pixelGridMenuItem.setSelected(view.isPixelGridVisible());
|
|
view.repaint();
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Statusbar".
|
|
* Toggles the statusbar visibility.
|
|
*
|
|
**/
|
|
|
|
public void doStatusBarCommand() {
|
|
viewStatusBar = !viewStatusBar;
|
|
statusBar.setVisible(viewStatusBar);
|
|
statusBarMenuItem.setSelected(viewStatusBar);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Toolbar".
|
|
* Toggles the toolbar visibility.
|
|
*
|
|
**/
|
|
|
|
public void doToolBarCommand() {
|
|
viewToolBar = !viewToolBar;
|
|
toolBarPane.setVisible(viewToolBar);
|
|
toolBarMenuItem.setSelected(viewToolBar);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "New Window".
|
|
* Creates a new view for the current one.
|
|
* Duplicates view settings (offset, codec, width/height etc.)
|
|
*
|
|
**/
|
|
|
|
public void doNewWindowCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
FileImage img = view.getFileImage();
|
|
TMView newView = createView(img, view.getTileCodec(), view.getPalette(), view.getMode());
|
|
// TODO: Copy palette
|
|
newView.setPalIndex(view.getPalIndex());
|
|
newView.setFGColor(view.getFGColor());
|
|
newView.setBGColor(view.getBGColor());
|
|
newView.setAbsoluteOffset(view.getOffset());
|
|
newView.setGridSize(view.getCols(), view.getRows());
|
|
addViewToDesktop(newView);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Mirror".
|
|
*
|
|
**/
|
|
|
|
public void doMirrorCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.getEditorCanvas().flipSelectionHorizontally();
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Flip".
|
|
*
|
|
**/
|
|
|
|
public void doFlipCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.getEditorCanvas().flipSelectionVertically();
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Rotate +90".
|
|
*
|
|
**/
|
|
|
|
public void doRotateRightCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.getEditorCanvas().rotateSelectionClockwise();
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Rotate Left".
|
|
*
|
|
**/
|
|
|
|
public void doRotateLeftCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.getEditorCanvas().rotateSelectionCounterClockwise();
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Shift Left".
|
|
*
|
|
**/
|
|
|
|
public void doShiftLeftCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.getEditorCanvas().shiftSelectionLeft();
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Shift Right".
|
|
*
|
|
**/
|
|
|
|
public void doShiftRightCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.getEditorCanvas().shiftSelectionRight();
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Shift Up".
|
|
*
|
|
**/
|
|
|
|
public void doShiftUpCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.getEditorCanvas().shiftSelectionUp();
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Shift Down".
|
|
*
|
|
**/
|
|
|
|
public void doShiftDownCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.getEditorCanvas().shiftSelectionDown();
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Stretch".
|
|
*
|
|
**/
|
|
|
|
public void doStretchCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
//TMStretchDialog stretchDialog = new TMStretchDialog(this, xl);
|
|
int retVal = stretchDialog.showDialog(view.getEditorCanvas().getSelectionCanvas().getCols(), view.getEditorCanvas().getSelectionCanvas().getRows());
|
|
if (retVal == JOptionPane.OK_OPTION) {
|
|
view.getEditorCanvas().stretchSelection(stretchDialog.getCols(), stretchDialog.getRows());
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Canvas Size".
|
|
*
|
|
**/
|
|
|
|
public void doCanvasSizeCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
//TMCanvasSizeDialog canvasSizeDialog = new TMCanvasSizeDialog(this, xl);
|
|
int retVal = canvasSizeDialog.showDialog(view.getCols(), view.getRows());
|
|
if (retVal == JOptionPane.OK_OPTION) {
|
|
view.setGridSize(canvasSizeDialog.getCols(), canvasSizeDialog.getRows());
|
|
view.setScale(view.getScale());
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Mode".
|
|
* Switches to the specified tile mode for the current frame.
|
|
* The valid modes are MODE_1D and MODE_2D.
|
|
*
|
|
**/
|
|
|
|
public void doModeCommand(int mode) {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.setMode(mode);
|
|
refreshStatusBar();
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
*
|
|
*
|
|
**/
|
|
|
|
public void doSizeBlockToCanvasCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.setSizeBlockToCanvas(!view.getSizeBlockToCanvas());
|
|
sizeBlockToCanvasMenuItem.setSelected(view.getSizeBlockToCanvas());
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
*
|
|
*
|
|
**/
|
|
|
|
public void doCustomBlockSizeCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
//TMBlockSizeDialog blockSizeDialog = new TMBlockSizeDialog(this, xl);
|
|
int retVal = blockSizeDialog.showDialog(view.getBlockWidth(), view.getBlockHeight());
|
|
if (retVal == JOptionPane.OK_OPTION) {
|
|
view.setSizeBlockToCanvas(false);
|
|
sizeBlockToCanvasMenuItem.setSelected(false);
|
|
view.setBlockDimensions(blockSizeDialog.getCols(), blockSizeDialog.getRows());
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
*
|
|
*
|
|
**/
|
|
|
|
public void doRowInterleaveBlocksCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.setRowInterleaveBlocks(!view.getRowInterleaveBlocks());
|
|
rowInterleaveBlocksMenuItem.setSelected(view.getRowInterleaveBlocks());
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
*
|
|
*
|
|
**/
|
|
|
|
public void doReopenCommand(File recentFile) {
|
|
if (recentFile.exists() && recentFile.canRead()) {
|
|
fileOpenChooser.setFileFilter(getTileCodecFilterForFile(recentFile));
|
|
openFile(recentFile);
|
|
recentFiles.remove(recentFile);
|
|
buildReopenMenu();
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles the menu command "Custom Codec".
|
|
*
|
|
**/
|
|
|
|
public void doCustomCodecCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
customCodecDialog.setVisible(true);
|
|
int retVal = 0; // TODO
|
|
if (retVal == JOptionPane.OK_OPTION) {
|
|
// create the codec
|
|
int bpp = customCodecDialog.getBitsPerPixel();
|
|
int rmask = customCodecDialog.getRedMask();
|
|
int gmask = customCodecDialog.getBlueMask();
|
|
int bmask = customCodecDialog.getGreenMask();
|
|
int amask = customCodecDialog.getAlphaMask();
|
|
// int endianness = customCodecDialog.getEndianness();
|
|
String desc = customCodecDialog.getDescription();
|
|
DirectColorTileCodec codec = new DirectColorTileCodec("", bpp, rmask, gmask, bmask, amask, desc);
|
|
addTileCodec(codec);
|
|
view.setTileCodec(codec);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Navigation button press handlers.
|
|
*
|
|
**/
|
|
|
|
public void doHomeCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.setAbsoluteOffset(view.getMinOffset());
|
|
}
|
|
}
|
|
|
|
public void doMinusPageCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.setRelativeOffset(-view.getEditorCanvas().getPageIncrement());
|
|
}
|
|
}
|
|
|
|
public void doMinusRowCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.setRelativeOffset(-view.getEditorCanvas().getRowIncrement());
|
|
}
|
|
}
|
|
|
|
public void doMinusTileCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.setRelativeOffset(-view.getEditorCanvas().getTileIncrement());
|
|
}
|
|
}
|
|
|
|
public void doMinusByteCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.setRelativeOffset(-1);
|
|
}
|
|
}
|
|
|
|
public void doPlusByteCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.setRelativeOffset(1);
|
|
}
|
|
}
|
|
|
|
public void doPlusTileCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.setRelativeOffset(view.getEditorCanvas().getTileIncrement());
|
|
}
|
|
}
|
|
|
|
public void doPlusRowCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.setRelativeOffset(view.getEditorCanvas().getRowIncrement());
|
|
}
|
|
}
|
|
|
|
public void doPlusPageCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.setRelativeOffset(view.getEditorCanvas().getPageIncrement());
|
|
}
|
|
}
|
|
|
|
public void doEndCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.setRelativeOffset(view.getMaxOffset());
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles the menu command "Add To Bookmarks".
|
|
*
|
|
**/
|
|
|
|
public void doAddToBookmarksCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
//TMAddToTreeDialog addBookmarkDialog = new TMAddToTreeDialog(this, "Add_To_Bookmarks_Dialog_Title", xl);
|
|
int retVal = addBookmarkDialog.showDialog(view.getFileImage().getResources().getBookmarksRoot());
|
|
if (retVal == JOptionPane.OK_OPTION) {
|
|
// Create & Add the bookmark
|
|
FolderNode folder = addBookmarkDialog.getFolder();
|
|
String description = addBookmarkDialog.getDescription();
|
|
BookmarkItemNode bookmark = view.createBookmark(addBookmarkDialog.getDescription());
|
|
|
|
/* view.addReversibleAction(
|
|
new ReversibleAddBookmarkAction(
|
|
bookmark
|
|
)
|
|
); */
|
|
|
|
folder.add(bookmark);
|
|
|
|
refreshBookmarksMenu();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles the menu command "Organize Bookmarks".
|
|
*
|
|
**/
|
|
|
|
public void doOrganizeBookmarksCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
//TMOrganizeTreeDialog organizeBookmarksDialog = new TMOrganizeTreeDialog(this, "Organize_Bookmarks_Dialog_Title", xl);
|
|
organizeBookmarksDialog.showDialog(view.getFileImage().getResources().getBookmarksRoot());
|
|
refreshBookmarksMenu();
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles the menu command "Add To Palettes".
|
|
*
|
|
**/
|
|
|
|
public void doAddToPalettesCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
//TMAddToTreeDialog addPaletteDialog = new TMAddToTreeDialog(this, "Add_To_Palettes_Dialog_Title", xl);
|
|
int retVal = addPaletteDialog.showDialog(view.getFileImage().getResources().getPalettesRoot());
|
|
if (retVal == JOptionPane.OK_OPTION) {
|
|
// Add the palette
|
|
FolderNode folder = addPaletteDialog.getFolder();
|
|
String description = addPaletteDialog.getDescription();
|
|
PaletteItemNode palNode = new PaletteItemNode(view.getPalette(), description);
|
|
folder.add(palNode);
|
|
|
|
/* view.addReversibleAction(
|
|
new ReversibleAddPaletteAction(
|
|
palette
|
|
)
|
|
); */
|
|
|
|
refreshPalettesMenu();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles the menu command "Organize Palettes".
|
|
*
|
|
**/
|
|
|
|
public void doOrganizePalettesCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
//TMOrganizeTreeDialog organizePalettesDialog = new TMOrganizeTreeDialog(this, "Organize_Palettes_Dialog_Title", xl);
|
|
organizePalettesDialog.showDialog(view.getFileImage().getResources().getPalettesRoot());
|
|
refreshPalettesMenu();
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles the menu command "Edit Colors".
|
|
*
|
|
**/
|
|
|
|
public void doEditColorsCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
JOptionPane.showMessageDialog(
|
|
this,
|
|
"Todo.\nDouble-click on a color in the palette below to edit it.",
|
|
"Tile Mangler",
|
|
JOptionPane.INFORMATION_MESSAGE
|
|
);
|
|
// let user edit the color
|
|
/* Color newColor = JColorChooser.showDialog(this, "Edit Color", new Color(view.getFGColor()));
|
|
if (newColor != null) {
|
|
int rgb = newColor.getRGB();
|
|
int colorIndex = vizualiser.getIndexOfColorAt(e.getX(), e.getY());
|
|
|
|
/* view.addReversibleAction(
|
|
new ReversiblePaletteEditAction(
|
|
view,
|
|
view.getPalette(),
|
|
colorIndex,
|
|
view.getPalette().getEntryRGB(colorIndex),
|
|
rgb
|
|
)
|
|
;*/
|
|
/*
|
|
view.getPalette().setEntryRGB(colorIndex, rgb);
|
|
ui.setFGColor(rgb);
|
|
view.getEditorCanvas().unpackPixels();
|
|
view.getEditorCanvas().redraw();
|
|
repaint();
|
|
}*/
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles the menu command "Format Palette".
|
|
*
|
|
**/
|
|
|
|
public void doColorCodecCommand(ColorCodec codec) {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.getPalette().setCodec(codec);
|
|
view.getEditorCanvas().unpackPixels();
|
|
view.getEditorCanvas().redraw();
|
|
refreshPalettePane();
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles the menu command "Set Palette Size".
|
|
*
|
|
**/
|
|
|
|
public void doPaletteSizeCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
//TMPaletteSizeDialog paletteSizeDialog = new TMPaletteSizeDialog(this, xl);
|
|
int retVal = paletteSizeDialog.showDialog(view.getPalette().getSize());
|
|
if (retVal == JOptionPane.OK_OPTION) {
|
|
view.getPalette().setSize(paletteSizeDialog.getPaletteSize());
|
|
// TODO: Check some stuff
|
|
refreshPalettePane();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles the menu command "New Palette".
|
|
*
|
|
**/
|
|
|
|
public void doNewPaletteCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
//TMNewPaletteDialog newPaletteDialog = new TMNewPaletteDialog(this, xl);
|
|
//newPaletteDialog.setCodecs(colorcodecs);
|
|
int retVal = newPaletteDialog.showDialog();
|
|
if (retVal == JOptionPane.OK_OPTION) {
|
|
// get input
|
|
int size = newPaletteDialog.getPaletteSize();
|
|
ColorCodec codec = newPaletteDialog.getCodec();
|
|
int endianness = newPaletteDialog.getEndianness();
|
|
|
|
// create the palette
|
|
TMPalette palette = new TMPalette("ID", size, codec, endianness);
|
|
|
|
// set the new palette
|
|
view.setPalette(palette);
|
|
refreshPalettePane();
|
|
refreshPalettesMenu();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles the menu command "Import Palette From This File".
|
|
*
|
|
**/
|
|
|
|
public void doImportInternalPaletteCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
//TMImportInternalPaletteDialog importInternalPaletteDialog = new TMImportInternalPaletteDialog(this, xl);
|
|
//importInternalPaletteDialog.setCodecs(colorcodecs);
|
|
int retVal = importInternalPaletteDialog.showDialog();
|
|
if (retVal == JOptionPane.OK_OPTION) {
|
|
// get input
|
|
int offset = importInternalPaletteDialog.getOffset();
|
|
int size = importInternalPaletteDialog.getPaletteSize();
|
|
ColorCodec codec = importInternalPaletteDialog.getCodec();
|
|
int endianness = importInternalPaletteDialog.getEndianness();
|
|
boolean copy = importInternalPaletteDialog.getCopy();
|
|
|
|
// create the palette
|
|
byte[] data = view.getFileImage().getContents();
|
|
TMPalette palette = new TMPalette("ID", data, offset, size, codec, endianness, copy, false);
|
|
|
|
// set the new palette
|
|
view.setPalette(palette);
|
|
refreshPalettePane();
|
|
refreshPalettesMenu();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles the menu command "Import Palette From Another File".
|
|
*
|
|
**/
|
|
|
|
public void doImportExternalPaletteCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
if (new File(this.lastPath).exists()) {
|
|
this.paletteOpenChooser.setCurrentDirectory(new File(this.lastPath));
|
|
} else {
|
|
this.paletteOpenChooser.setCurrentDirectory(new File("."));
|
|
}
|
|
// have the user select a file
|
|
int retVal = paletteOpenChooser.showOpenDialog(this);
|
|
if (retVal == JFileChooser.APPROVE_OPTION) {
|
|
// get the selected file
|
|
File file = paletteOpenChooser.getSelectedFile();
|
|
|
|
// figure out palette info based on file filter
|
|
FileFilter ff = paletteOpenChooser.getFileFilter();
|
|
if (!(ff instanceof TMPaletteFileFilter)) {
|
|
ff = getPaletteFilterForFile(file);
|
|
}
|
|
TMPaletteFileFilter pf = (TMPaletteFileFilter)ff;
|
|
int size = pf.getSize();
|
|
ColorCodec codec = getColorCodecByID(pf.getCodecID());
|
|
int offset = pf.getOffset();
|
|
int endianness = pf.getEndianness();
|
|
|
|
// create buffer to hold the palette data
|
|
byte[] data = new byte[size * codec.getBytesPerPixel()];
|
|
|
|
// read the palette data
|
|
RandomAccessFile raf=null;
|
|
try {
|
|
raf = new RandomAccessFile(file, "r");
|
|
raf.seek(offset);
|
|
raf.read(data);
|
|
raf.close();
|
|
}
|
|
catch (Exception e) {
|
|
JOptionPane.showMessageDialog(this,
|
|
xlate("Palette_Read_Error")+"\n"+e.getMessage(),
|
|
"Tile Mangler",
|
|
JOptionPane.ERROR_MESSAGE);
|
|
return;
|
|
}
|
|
|
|
// create the palette
|
|
TMPalette palette = new TMPalette("ID", data, 0, size, codec, endianness, true, false);
|
|
|
|
// set the new palette
|
|
view.setPalette(palette);
|
|
refreshPalettePane();
|
|
refreshPalettesMenu();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Handles menu command "Palette Endianness".
|
|
*
|
|
**/
|
|
|
|
public void doPaletteEndiannessCommand(int endianness) {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.getPalette().setEndianness(endianness);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Called when user has selected a bookmark to jump to from the Navigate menu.
|
|
*
|
|
**/
|
|
|
|
public void doGotoBookmarkCommand(BookmarkItemNode bookmark) {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.gotoBookmark(bookmark);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Called when user has selected a palette to use from the Palette menu.
|
|
*
|
|
**/
|
|
|
|
public void doSelectPaletteCommand(TMPalette palette) {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.setPalette(palette);
|
|
refreshPalettePane();
|
|
refreshPaletteEndiannessSelection(view);
|
|
refreshColorCodecSelection(view);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
*
|
|
*
|
|
**/
|
|
|
|
public void doDecreaseWidthCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.setGridSize(view.getCols()-1, view.getRows());
|
|
view.setScale(view.getScale());
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
*
|
|
*
|
|
**/
|
|
|
|
public void doIncreaseWidthCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.setGridSize(view.getCols()+1, view.getRows());
|
|
view.setScale(view.getScale());
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
*
|
|
*
|
|
**/
|
|
|
|
public void doDecreaseHeightCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.setGridSize(view.getCols(), view.getRows()-1);
|
|
view.setScale(view.getScale());
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
*
|
|
*
|
|
**/
|
|
|
|
public void doIncreaseHeightCommand() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.setGridSize(view.getCols(), view.getRows()+1);
|
|
view.setScale(view.getScale());
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
/**
|
|
*
|
|
* Call this when a fileimage has been modified.
|
|
*
|
|
**/
|
|
|
|
public void fileImageModified(FileImage img) {
|
|
img.setModified(true);
|
|
setSaveButtonsEnabled(true);
|
|
saveAllMenuItem.setEnabled(true);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Sets enabled state of save buttons.
|
|
*
|
|
**/
|
|
|
|
public void setSaveButtonsEnabled(boolean b) {
|
|
saveButton.setEnabled(b);
|
|
saveMenuItem.setEnabled(b);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Sets enabled state of undo buttons.
|
|
*
|
|
**/
|
|
|
|
public void setUndoButtonsEnabled(boolean b) {
|
|
undoButton.setEnabled(b);
|
|
undoMenuItem.setEnabled(b);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Sets enabled state of redo buttons.
|
|
*
|
|
**/
|
|
|
|
public void setRedoButtonsEnabled(boolean b) {
|
|
redoButton.setEnabled(b);
|
|
redoMenuItem.setEnabled(b);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Hides/disables MDI-specific menus and buttons.
|
|
*
|
|
**/
|
|
|
|
public void disableMDIStuff() {
|
|
// Hide MDI menus
|
|
menuBar.remove(editMenu);
|
|
menuBar.remove(viewMenu);
|
|
menuBar.remove(imageMenu);
|
|
menuBar.remove(navigateMenu);
|
|
menuBar.remove(paletteMenu);
|
|
menuBar.remove(windowMenu);
|
|
// Hide some File menu items
|
|
closeMenuItem.setVisible(false);
|
|
closeAllMenuItem.setVisible(false);
|
|
saveMenuItem.setVisible(false);
|
|
saveAsMenuItem.setVisible(false);
|
|
saveAllMenuItem.setVisible(false);
|
|
// Hide some Toolbar buttons
|
|
saveButton.setVisible(false);
|
|
cutButton.setVisible(false);
|
|
copyButton.setVisible(false);
|
|
pasteButton.setVisible(false);
|
|
undoButton.setVisible(false);
|
|
redoButton.setVisible(false);
|
|
gotoButton.setVisible(false);
|
|
addBookmarkButton.setVisible(false);
|
|
decWidthButton.setVisible(false);
|
|
incWidthButton.setVisible(false);
|
|
decHeightButton.setVisible(false);
|
|
incHeightButton.setVisible(false);
|
|
// Hide navigation bar
|
|
navBar.setVisible(false);
|
|
// Hide tool pane
|
|
toolPane.setVisible(false);
|
|
// hide bottom pane
|
|
bottomPane.setVisible(false);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Shows/enables MDI-specific menus and buttons.
|
|
*
|
|
**/
|
|
|
|
public void enableMDIStuff() {
|
|
// Show MDI menus
|
|
menuBar.remove(helpMenu);
|
|
menuBar.add(editMenu);
|
|
menuBar.add(viewMenu);
|
|
menuBar.add(imageMenu);
|
|
menuBar.add(navigateMenu);
|
|
menuBar.add(paletteMenu);
|
|
menuBar.add(windowMenu);
|
|
menuBar.add(helpMenu);
|
|
// Show File menu items
|
|
closeMenuItem.setVisible(true);
|
|
closeAllMenuItem.setVisible(true);
|
|
saveMenuItem.setVisible(true);
|
|
saveAsMenuItem.setVisible(true);
|
|
saveAllMenuItem.setVisible(true);
|
|
saveAllMenuItem.setEnabled(false);
|
|
// TODO: Enable previously hidden menu items w/ key accelerators
|
|
// Show Toolbar buttons
|
|
saveButton.setVisible(true);
|
|
cutButton.setVisible(true);
|
|
copyButton.setVisible(true);
|
|
pasteButton.setVisible(true);
|
|
undoButton.setVisible(true);
|
|
redoButton.setVisible(true);
|
|
gotoButton.setVisible(true);
|
|
addBookmarkButton.setVisible(true);
|
|
decWidthButton.setVisible(true);
|
|
incWidthButton.setVisible(true);
|
|
decHeightButton.setVisible(true);
|
|
incHeightButton.setVisible(true);
|
|
// disable some buttons
|
|
saveButton.setEnabled(false);
|
|
pasteButton.setEnabled(false);
|
|
pasteMenuItem.setEnabled(false);
|
|
undoButton.setEnabled(false);
|
|
redoButton.setEnabled(false);
|
|
// Show navigation bar
|
|
navBar.setVisible(true);
|
|
// Show tool pane
|
|
toolPane.setVisible(true);
|
|
// Maybe show statusbar
|
|
statusBar.setVisible(viewStatusBar);
|
|
// show bottom pane
|
|
bottomPane.setVisible(true);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Adds a codec to the list of available codecs and creates a menu item for it.
|
|
*
|
|
**/
|
|
|
|
public void addTileCodec(TileCodec codec) {
|
|
TileCodecMenuItem codecMenuItem = new TileCodecMenuItem(codec);
|
|
tileCodecMenu.add(codecMenuItem);
|
|
tileCodecButtonGroup.add(codecMenuItem);
|
|
tileCodecButtonHashtable.put(codec, codecMenuItem);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Menu item that represents a tile codec.
|
|
*
|
|
**/
|
|
|
|
private class TileCodecMenuItem extends JRadioButtonMenuItem {
|
|
|
|
private TileCodec codec;
|
|
|
|
// Creates a TileCodecMenuItem for the given codec.
|
|
public TileCodecMenuItem(TileCodec codec) {
|
|
super(codec.getDescription()); // use description as button text
|
|
this.codec = codec;
|
|
// TODO: setToolTipText(exampleFormats)
|
|
addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doTileCodecCommand(((TileCodecMenuItem)e.getSource()).getCodec());
|
|
setSelected(true);
|
|
}
|
|
}
|
|
);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Gets the codec that the menu item represents.
|
|
*
|
|
**/
|
|
|
|
public TileCodec getCodec() {
|
|
return codec;
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Gets the "successor" of the given codec, which is the next codec in
|
|
* the global list of codecs (with wraparound).
|
|
*
|
|
**/
|
|
|
|
public TileCodec getTileCodecSuccessor(TileCodec codec) {
|
|
int i = tilecodecs.indexOf(codec);
|
|
if (i == tilecodecs.size()-1) {
|
|
return (TileCodec)tilecodecs.get(0);
|
|
}
|
|
else {
|
|
return (TileCodec)tilecodecs.get(i+1);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Gets the "predecessor" of the given codec, which is the previous codec in
|
|
* the global list of codecs (with wraparound).
|
|
*
|
|
**/
|
|
|
|
public TileCodec getTileCodecPredecessor(TileCodec codec) {
|
|
int i = tilecodecs.indexOf(codec);
|
|
if (i == 0) {
|
|
return (TileCodec)tilecodecs.get(tilecodecs.size()-1);
|
|
}
|
|
else {
|
|
return (TileCodec)tilecodecs.get(i-1);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Just a JButton with very small insets, to avoid lots of whitespace around the
|
|
* ImageIcon.
|
|
*
|
|
**/
|
|
|
|
private class ToolButton extends JButton {
|
|
|
|
Insets insets=null;
|
|
|
|
public ToolButton(String text) {
|
|
super(text);
|
|
if(isWindows){
|
|
insets = new Insets(6,6,8,8);
|
|
}else{
|
|
insets = new Insets(4,4,5,5);
|
|
}
|
|
}
|
|
public ToolButton(ImageIcon icon) {
|
|
super(icon);
|
|
setBackground(MenuBG);
|
|
if(isWindows){
|
|
insets = new Insets(6,6,8,8);
|
|
}else{
|
|
insets = new Insets(4,4,5,5);
|
|
}
|
|
}
|
|
public Insets getInsets() {
|
|
return insets;
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Just a JToggleButton with very small insets, to avoid lots of whitespace
|
|
* around the ImageIcon.
|
|
*
|
|
**/
|
|
|
|
private class ToolToggleButton extends JToggleButton {
|
|
Insets insets=null;
|
|
public ToolToggleButton(String text) {
|
|
super(text);
|
|
if(isWindows){
|
|
insets = new Insets(6,6,8,8);
|
|
}else{
|
|
insets = new Insets(4,4,5,5);
|
|
}
|
|
}
|
|
public ToolToggleButton(ImageIcon icon) {
|
|
super(icon);
|
|
setBackground(MenuBG);
|
|
if(isWindows){
|
|
insets = new Insets(6,6,8,8);
|
|
}else{
|
|
insets = new Insets(4,4,5,5);
|
|
}
|
|
}
|
|
public Insets getInsets() {
|
|
return insets;
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Gets the foreground color for the current view.
|
|
*
|
|
**/
|
|
|
|
public int getFGColor() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
return view.getFGColor();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Gets the background color for the current view.
|
|
*
|
|
**/
|
|
|
|
public int getBGColor() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
return view.getBGColor();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Sets the foreground color for the current view.
|
|
*
|
|
**/
|
|
|
|
public void setFGColor(int fgColor) {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.setFGColor(fgColor);
|
|
palettePane.setFGColor(fgColor);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Sets the background color for the current view.
|
|
*
|
|
**/
|
|
|
|
public void setBGColor(int bgColor) {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.setBGColor(bgColor);
|
|
palettePane.setBGColor(bgColor);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Sets the palette index for the current view.
|
|
*
|
|
**/
|
|
|
|
public void setPalIndex(int palIndex) {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
view.setPalIndex(palIndex);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Gets the current tool.
|
|
*
|
|
**/
|
|
|
|
public int getTool() {
|
|
return tool;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Gets the desktop.
|
|
*
|
|
**/
|
|
|
|
public JDesktopPane getDesktop() {
|
|
return desktop;
|
|
}
|
|
|
|
public static int getColorIndex(int palIndex, int bpp) {
|
|
if (bpp > 8) bpp = 8;
|
|
int cols = 1 << bpp;
|
|
return palIndex * cols;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Creates a view with the given resources/attributes.
|
|
*
|
|
**/
|
|
|
|
public TMView createView(FileImage img, TileCodec tc, TMPalette pal, int mode) {
|
|
TMView view = new TMView(this, img, tc);
|
|
view.setMode(mode);
|
|
view.setPalette(pal);
|
|
return view;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Adds a view to the desktop.
|
|
*
|
|
**/
|
|
|
|
public void addViewToDesktop(TMView view) {
|
|
desktop.add(view);
|
|
try {
|
|
view.setSelected(true);
|
|
}
|
|
catch (java.beans.PropertyVetoException x) {
|
|
x.printStackTrace();
|
|
}
|
|
desktop.revalidate();
|
|
desktop.repaint();
|
|
|
|
if (desktop.getAllFrames().length == 1) {
|
|
// this is the first frame, show the MDI toolbars and menus
|
|
enableMDIStuff();
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Initializes the View->Codec menu based on the tilecodecs present, and sets up
|
|
* the fileOpenChooser accordingly.
|
|
*
|
|
**/
|
|
|
|
private void initTileCodecUIStuff() {
|
|
buildTileCodecsMenu();
|
|
initFileOpenChooser();
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Builds the View->Codec menu.
|
|
*
|
|
**/
|
|
|
|
private void buildTileCodecsMenu() {
|
|
tileCodecMenu.setMnemonic(KeyEvent.VK_C);
|
|
tileCodecMenu.removeAll();
|
|
for (int i=0; i<tilecodecs.size(); i++) {
|
|
addTileCodec((TileCodec)tilecodecs.get(i));
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Builds the Palette->Format menu.
|
|
*
|
|
**/
|
|
|
|
private void buildColorCodecsMenu() {
|
|
colorCodecMenu.setMnemonic(KeyEvent.VK_F);
|
|
colorCodecMenu.removeAll();
|
|
for (int i=0; i<colorcodecs.size(); i++) {
|
|
addColorCodec((ColorCodec)colorcodecs.get(i));
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Adds a codec to the list of available codecs and creates a menu item for it.
|
|
*
|
|
**/
|
|
|
|
public void addColorCodec(ColorCodec codec) {
|
|
ColorCodecMenuItem codecMenuItem = new ColorCodecMenuItem(codec);
|
|
colorCodecMenu.add(codecMenuItem);
|
|
colorCodecButtonGroup.add(codecMenuItem);
|
|
colorCodecButtonHashtable.put(codec, codecMenuItem);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Menu item that represents a color codec.
|
|
*
|
|
**/
|
|
|
|
private class ColorCodecMenuItem extends JRadioButtonMenuItem {
|
|
|
|
private ColorCodec codec;
|
|
|
|
// Creates a ColorCodecMenuItem for the given codec.
|
|
public ColorCodecMenuItem(ColorCodec codec) {
|
|
super(codec.getDescription()); // use description as button text
|
|
this.codec = codec;
|
|
addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doColorCodecCommand(((ColorCodecMenuItem)e.getSource()).getCodec());
|
|
setSelected(true);
|
|
}
|
|
}
|
|
);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Gets the codec that the menu item represents.
|
|
*
|
|
**/
|
|
|
|
public ColorCodec getCodec() {
|
|
return codec;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
*
|
|
* Sets up the file open chooser.
|
|
*
|
|
**/
|
|
|
|
private void initFileOpenChooser() {
|
|
fileOpenChooser.setAcceptAllFileFilterUsed(false);
|
|
fileOpenChooser.resetChoosableFileFilters();
|
|
// TODO: Sort alphabetically by description...
|
|
String extlist = "";
|
|
for (int i=0; i<filefilters.size(); i++) {
|
|
TMTileCodecFileFilter cff = (TMTileCodecFileFilter)filefilters.get(i);
|
|
fileOpenChooser.addChoosableFileFilter(cff);
|
|
if (i > 0) extlist += ",";
|
|
extlist += cff.getExtlist();
|
|
}
|
|
TMFileFilter supportedFilter = new TMFileFilter(extlist, xlate("All_Supported_Formats"));
|
|
fileOpenChooser.addChoosableFileFilter(supportedFilter);
|
|
fileOpenChooser.addChoosableFileFilter(allFilter);
|
|
fileOpenChooser.setFileFilter(supportedFilter);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Sets up the palette open chooser.
|
|
*
|
|
**/
|
|
|
|
private void initPaletteOpenChooser() {
|
|
paletteOpenChooser.setAcceptAllFileFilterUsed(false);
|
|
paletteOpenChooser.resetChoosableFileFilters();
|
|
String extlist = "";
|
|
for (int i=0; i<palettefilters.size(); i++) {
|
|
TMPaletteFileFilter pff = (TMPaletteFileFilter)palettefilters.get(i);
|
|
paletteOpenChooser.addChoosableFileFilter(pff);
|
|
if (i > 0) extlist += ",";
|
|
extlist += pff.getExtlist();
|
|
}
|
|
TMFileFilter supportedFilter = new TMFileFilter(extlist, xlate("All_Supported_Formats"));
|
|
paletteOpenChooser.addChoosableFileFilter(supportedFilter);
|
|
paletteOpenChooser.setFileFilter(supportedFilter);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Gets the color codec that has the specified ID, or null if no such codec exists.
|
|
*
|
|
**/
|
|
|
|
public ColorCodec getColorCodecByID(String codecID) {
|
|
for (int i=0; i<colorcodecs.size(); i++) {
|
|
ColorCodec cc = (ColorCodec)colorcodecs.get(i);
|
|
if (cc.getID().equals(codecID)) {
|
|
return cc;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Gets the tile codec that has the specified ID, or null if no such codec exists.
|
|
*
|
|
**/
|
|
|
|
public TileCodec getTileCodecByID(String codecID) {
|
|
for (int i=0; i<tilecodecs.size(); i++) {
|
|
TileCodec tc = (TileCodec)tilecodecs.get(i);
|
|
if (tc.getID().equals(codecID)) {
|
|
return tc;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Gets the default tile codec file filter for the specified file
|
|
* based on its extension.
|
|
*
|
|
**/
|
|
|
|
private TMTileCodecFileFilter getTileCodecFilterForFile(File file) {
|
|
for (int i=0; i<filefilters.size(); i++) {
|
|
TMTileCodecFileFilter cff = (TMTileCodecFileFilter)filefilters.get(i);
|
|
if (cff.accept(file)) {
|
|
return cff;
|
|
}
|
|
}
|
|
return (TMTileCodecFileFilter)filefilters.get(0);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Gets the default palette file filter for the specified file
|
|
* based on its extension.
|
|
*
|
|
**/
|
|
|
|
private TMPaletteFileFilter getPaletteFilterForFile(File file) {
|
|
for (int i=0; i<palettefilters.size(); i++) {
|
|
TMPaletteFileFilter pff = (TMPaletteFileFilter)palettefilters.get(i);
|
|
if (pff.accept(file)) {
|
|
return pff;
|
|
}
|
|
}
|
|
return (TMPaletteFileFilter)palettefilters.get(0);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Recognizes all files.
|
|
*
|
|
**/
|
|
|
|
private class AllFilter extends TMFileFilter {
|
|
|
|
public boolean accept(File f) {
|
|
return true;
|
|
}
|
|
|
|
public String getDescription() {
|
|
return xlate("All_Files");
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Builds the menu containing all the bookmarks.
|
|
*
|
|
**/
|
|
|
|
private void buildBookmarksMenu(FolderNode root) {
|
|
// remove old bookmark menuitems, if any
|
|
while (navigateMenu.getItemCount() > 5) {
|
|
navigateMenu.remove(5);
|
|
}
|
|
|
|
TMTreeNode[] children = root.getChildren();
|
|
if (children.length == 0) {
|
|
// no bookmarks exist
|
|
}
|
|
else {
|
|
// add all the bookmarks
|
|
navigateMenu.add(separator);
|
|
for (int i=0; i<children.length; i++) {
|
|
addToBookmarksMenu(children[i], navigateMenu);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Recursive routine that adds the given node to the given menu.
|
|
* If the node is internal it is expanded into a menu of its own.
|
|
*
|
|
**/
|
|
|
|
public void addToBookmarksMenu(TMTreeNode node, JMenu menu) {
|
|
if (node instanceof BookmarkItemNode) {
|
|
menu.add(new BookmarkMenuItem((BookmarkItemNode)node));
|
|
}
|
|
else {
|
|
// folder
|
|
JMenu subMenu = new JMenu(node.toString());
|
|
TMTreeNode[] children = node.getChildren();
|
|
if (children.length == 0) {
|
|
// no bookmarks exist in this folder
|
|
JMenuItem emptyItem = new JMenuItem("("+xlate("Empty")+")");
|
|
emptyItem.setEnabled(false);
|
|
subMenu.add(emptyItem);
|
|
}
|
|
else {
|
|
// add all the child bookmarks/folders
|
|
for (int i=0; i<children.length; i++) {
|
|
addToBookmarksMenu(children[i], subMenu);
|
|
}
|
|
}
|
|
menu.add(subMenu);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Menu item that represents a bookmark.
|
|
*
|
|
**/
|
|
|
|
private class BookmarkMenuItem extends JMenuItem {
|
|
|
|
private BookmarkItemNode bookmark;
|
|
|
|
// creates a bookmarkmenu item for the given bookmark.
|
|
public BookmarkMenuItem(BookmarkItemNode bookmark) {
|
|
super(bookmark.getDescription());
|
|
this.bookmark = bookmark;
|
|
addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doGotoBookmarkCommand(((BookmarkMenuItem)e.getSource()).getBookmark());
|
|
}
|
|
}
|
|
);
|
|
setToolTipText(bookmark.getToolTipText());
|
|
}
|
|
|
|
public BookmarkItemNode getBookmark() {
|
|
return bookmark;
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Builds the menu containing all the palettes.
|
|
*
|
|
**/
|
|
|
|
private void buildPalettesMenu(FolderNode root) {
|
|
// remove old palette menuitems, if any
|
|
while (paletteMenu.getItemCount() > 10) {
|
|
paletteMenu.remove(10);
|
|
}
|
|
|
|
paletteButtonHashtable.clear();
|
|
paletteButtonGroup = new ButtonGroup();
|
|
|
|
TMTreeNode[] children = root.getChildren();
|
|
if (children.length == 0) {
|
|
// no palettes exist (shouldn't be possible)
|
|
}
|
|
else {
|
|
// add all the palettes
|
|
paletteMenu.add(separator);
|
|
for (int i=0; i<children.length; i++) {
|
|
addToPalettesMenu(children[i], paletteMenu);
|
|
}
|
|
}
|
|
paletteButtonGroup.add(dummyPaletteMenuItem);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Recursive routine that adds the given node to the given menu.
|
|
* If the node is internal it is expanded into a menu of its own.
|
|
*
|
|
**/
|
|
|
|
public void addToPalettesMenu(TMTreeNode node, JMenu menu) {
|
|
if (node instanceof PaletteItemNode) {
|
|
// palette
|
|
PaletteItemNode paletteNode = (PaletteItemNode)node;
|
|
PaletteMenuItem paletteMenuItem = new PaletteMenuItem(paletteNode);
|
|
menu.add(paletteMenuItem);
|
|
paletteButtonGroup.add(paletteMenuItem);
|
|
paletteButtonHashtable.put(paletteNode.getPalette(), paletteMenuItem);
|
|
}
|
|
else {
|
|
// folder
|
|
JMenu subMenu = new JMenu(node.toString());
|
|
TMTreeNode[] children = node.getChildren();
|
|
if (children.length == 0) {
|
|
// no palettes exist in this folder
|
|
JMenuItem emptyItem = new JMenuItem("("+xlate("Empty")+")");
|
|
emptyItem.setEnabled(false);
|
|
subMenu.add(emptyItem);
|
|
}
|
|
else {
|
|
// add all the child palettes/folders
|
|
for (int i=0; i<children.length; i++) {
|
|
addToPalettesMenu(children[i], subMenu);
|
|
}
|
|
}
|
|
menu.add(subMenu);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Menu item that represents a bookmark.
|
|
*
|
|
**/
|
|
|
|
private class PaletteMenuItem extends JRadioButtonMenuItem {
|
|
|
|
private PaletteItemNode paletteNode;
|
|
|
|
// creates a palettemenu item for the given palette node.
|
|
public PaletteMenuItem(PaletteItemNode paletteNode) {
|
|
super(paletteNode.getDescription());
|
|
this.paletteNode = paletteNode;
|
|
addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doSelectPaletteCommand(((PaletteMenuItem)e.getSource()).getPalette());
|
|
}
|
|
}
|
|
);
|
|
setToolTipText(paletteNode.getToolTipText());
|
|
}
|
|
|
|
public TMPalette getPalette() {
|
|
return paletteNode.getPalette();
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Updates various UI components (menus, statusbar, palette) to reflect the
|
|
* settings of the current frame.
|
|
*
|
|
**/
|
|
|
|
public void viewSelected(TMView view) {
|
|
setSaveButtonsEnabled(view.getFileImage().isModified());
|
|
|
|
// (un)check some menu items
|
|
TMEditorCanvas ec = view.getEditorCanvas();
|
|
blockGridMenuItem.setSelected(ec.isBlockGridVisible());
|
|
tileGridMenuItem.setSelected(ec.isTileGridVisible());
|
|
pixelGridMenuItem.setSelected(ec.isPixelGridVisible());
|
|
rowInterleaveBlocksMenuItem.setSelected(ec.getRowInterleaveBlocks());
|
|
|
|
refreshModeSelection(view);
|
|
refreshTileCodecSelection(view);
|
|
refreshBlockSizeSelection(view);
|
|
refreshPalettePane();
|
|
refreshStatusBar();
|
|
refreshBookmarksMenu();
|
|
refreshPalettesMenu();
|
|
refreshUndoRedo();
|
|
|
|
setTitle("Tile Mangler - "+view.getTitle());
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Selects the correct menu item, according to the view's block size.
|
|
*
|
|
**/
|
|
|
|
public void refreshBlockSizeSelection(TMView view) {
|
|
sizeBlockToCanvasMenuItem.setSelected(view.getSizeBlockToCanvas());
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Selects the correct menu item, according to the view's mode.
|
|
*
|
|
**/
|
|
|
|
public void refreshModeSelection(TMView view) {
|
|
// select the correct mode menu item
|
|
if (view.getMode() == TileCodec.MODE_1D) {
|
|
_1DimensionalMenuItem.setSelected(true);
|
|
}
|
|
else {
|
|
_2DimensionalMenuItem.setSelected(true);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Selects the correct menu item, according to the view's tile codec.
|
|
*
|
|
**/
|
|
|
|
public void refreshTileCodecSelection(TMView view) {
|
|
((TileCodecMenuItem)tileCodecButtonHashtable.get(view.getTileCodec())).setSelected(true);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Reloads the palette.
|
|
*
|
|
**/
|
|
|
|
public void refreshPalettePane() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
palettePane.viewSelected(view);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Updates the Undo/Redo buttons text+status.
|
|
*
|
|
**/
|
|
|
|
public void refreshUndoRedo() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
setUndoButtonsEnabled(view.canUndo());
|
|
if (view.canUndo()) {
|
|
undoMenuItem.setText(xlate("Undo")+" "+xlate(view.getFirstUndoableAction().getPresentationName()));
|
|
}
|
|
else {
|
|
undoMenuItem.setText(xlate("Cant_Undo"));
|
|
}
|
|
undoButton.setToolTipText(undoMenuItem.getText());
|
|
|
|
setRedoButtonsEnabled(view.canRedo());
|
|
if (view.canRedo()) {
|
|
redoMenuItem.setText(xlate("Redo")+" "+xlate(view.getFirstRedoableAction().getPresentationName()));
|
|
}
|
|
else {
|
|
redoMenuItem.setText(xlate("Cant_Redo"));
|
|
}
|
|
redoButton.setToolTipText(redoMenuItem.getText());
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Sets the statusbar fields according to current view settings.
|
|
*
|
|
**/
|
|
|
|
public void refreshStatusBar() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
statusBar.viewSelected(view);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Builds the bookmarks menu according to current file image.
|
|
*
|
|
**/
|
|
|
|
public void refreshBookmarksMenu() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
buildBookmarksMenu(view.getFileImage().getResources().getBookmarksRoot());
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Builds the palettes menu according to current file image.
|
|
*
|
|
**/
|
|
|
|
public void refreshPalettesMenu() {
|
|
TMView view = getSelectedView();
|
|
if (view != null) {
|
|
buildPalettesMenu(view.getFileImage().getResources().getPalettesRoot());
|
|
refreshPaletteSelection(view);
|
|
refreshPaletteEndiannessSelection(view);
|
|
refreshColorCodecSelection(view);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Refreshes the palette selection.
|
|
*
|
|
**/
|
|
|
|
public void refreshPaletteSelection(TMView view) {
|
|
PaletteMenuItem item = (PaletteMenuItem)paletteButtonHashtable.get(view.getPalette());
|
|
if (item != null) {
|
|
item.setSelected(true);
|
|
}
|
|
else {
|
|
dummyPaletteMenuItem.setSelected(true);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Refreshes the palette endianness.
|
|
*
|
|
**/
|
|
|
|
public void refreshPaletteEndiannessSelection(TMView view) {
|
|
if (view.getPalette().getEndianness() == ColorCodec.LITTLE_ENDIAN) {
|
|
paletteLittleEndianMenuItem.setSelected(true);
|
|
}
|
|
else {
|
|
paletteBigEndianMenuItem.setSelected(true);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Selects the correct menu item, according to the view's color codec.
|
|
*
|
|
**/
|
|
|
|
public void refreshColorCodecSelection(TMView view) {
|
|
((ColorCodecMenuItem)colorCodecButtonHashtable.get(view.getPalette().getCodec())).setSelected(true);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Opens the specified file.
|
|
*
|
|
**/
|
|
|
|
public void openFile(File file) {
|
|
System.gc();
|
|
// read file
|
|
FileLoaderThread thread = null;
|
|
try {
|
|
thread = new FileLoaderThread(file);
|
|
}
|
|
catch (OutOfMemoryError e) {
|
|
JOptionPane.showMessageDialog(this,
|
|
xlate("Out_Of_Memory")+"\n"+file.length()+" bytes needed to load file.", // i18n
|
|
"Tile Mangler",
|
|
JOptionPane.ERROR_MESSAGE);
|
|
return;
|
|
}
|
|
catch (Exception e) {
|
|
JOptionPane.showMessageDialog(this,
|
|
xlate("Load_File_Error")+"\n"+e.getMessage(),
|
|
"Tile Mangler",
|
|
JOptionPane.ERROR_MESSAGE);
|
|
return;
|
|
}
|
|
ProgressDialog dialog = new ProgressDialog(this, thread);
|
|
byte[] contents = thread.getContents();
|
|
|
|
// see if a filelistener should receive notification
|
|
String ext = TMFileFilter.getExtension(file);
|
|
for (int i=0; i<filelisteners.size(); i++) {
|
|
TMFileListener fl = (TMFileListener)filelisteners.get(i);
|
|
if (fl.doFormatDetect(contents, ext)) {
|
|
fileListenerHashtable.put(contents, fl);
|
|
fl.fileLoaded(contents, ext);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// create fileimage
|
|
FileImage img = new FileImage(file, contents);
|
|
// create resources for it
|
|
File resourceFile = TMFileResources.getResourceFileFor(file);
|
|
if (resourceFile.exists()) {
|
|
// load the resources from XML document
|
|
try {
|
|
new TMFileResources(resourceFile, img, this);
|
|
}
|
|
catch (SAXException e) {
|
|
JOptionPane.showMessageDialog(this,
|
|
xlate("Parser_Parse_Error")+"\n"+e.getMessage(),
|
|
"Tile Mangler",
|
|
JOptionPane.ERROR_MESSAGE);
|
|
}
|
|
catch (ParserConfigurationException e) {
|
|
JOptionPane.showMessageDialog(this,
|
|
xlate("Parser_Config_Error")+"\n"+e.getMessage(),
|
|
"Tile Mangler",
|
|
JOptionPane.ERROR_MESSAGE);
|
|
}
|
|
catch (IOException e) {
|
|
JOptionPane.showMessageDialog(this,
|
|
xlate("Parser_IO_Error")+"\n"+e.getMessage(),
|
|
"Tile Mangler",
|
|
JOptionPane.ERROR_MESSAGE);
|
|
}
|
|
}
|
|
else {
|
|
// create default resources
|
|
new TMFileResources(img, this);
|
|
}
|
|
// figure out mode and codec based on file filter
|
|
FileFilter ff = fileOpenChooser.getFileFilter();
|
|
if (!(ff instanceof TMTileCodecFileFilter)) {
|
|
ff = getTileCodecFilterForFile(file);
|
|
}
|
|
int mode = ((TMTileCodecFileFilter)ff).getDefaultMode();
|
|
TileCodec tc = getTileCodecByID(((TMTileCodecFileFilter)ff).getCodecID());
|
|
TMPalette pal = new TMPalette("PAL000", TMPalette.defaultPalette, getColorCodecByID("CF01"), ColorCodec.LITTLE_ENDIAN, true);
|
|
|
|
addViewToDesktop(createView(img, tc, pal, mode));
|
|
|
|
// Remove file from recentFiles, if it's there
|
|
for (int i=0; i<recentFiles.size(); i++) {
|
|
File f = (File)recentFiles.get(i);
|
|
if (f.compareTo(file) == 0) {
|
|
recentFiles.remove(f);
|
|
buildReopenMenu();
|
|
break;
|
|
}
|
|
}
|
|
|
|
thread.killContentsRef();
|
|
thread = null;
|
|
System.gc();
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Builds the menu containing most recently opened (closed) files.
|
|
*
|
|
**/
|
|
|
|
public void buildReopenMenu() {
|
|
reopenMenu.removeAll();
|
|
if (recentFiles.size() == 0) {
|
|
JMenuItem emptyItem = new JMenuItem("("+xlate("Empty")+")");
|
|
emptyItem.setEnabled(false);
|
|
reopenMenu.add(emptyItem);
|
|
}
|
|
else {
|
|
for (int i=0; i<recentFiles.size(); i++) {
|
|
File recentFile = (File)recentFiles.get(i);
|
|
reopenMenu.add(new RecentFileMenuItem(recentFile));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Menu item that represents a recently opened (closed) file.
|
|
*
|
|
**/
|
|
|
|
private class RecentFileMenuItem extends JMenuItem {
|
|
|
|
private File recentFile;
|
|
|
|
// creates a recentfilemenuitem for the given file.
|
|
public RecentFileMenuItem(File recentFile) {
|
|
super(recentFile.getName());
|
|
setToolTipText(recentFile.getAbsolutePath());
|
|
this.recentFile = recentFile;
|
|
addActionListener(
|
|
new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
doReopenCommand(((RecentFileMenuItem)e.getSource()).getRecentFile());
|
|
}
|
|
}
|
|
);
|
|
}
|
|
|
|
public File getRecentFile() {
|
|
return recentFile;
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
*
|
|
*
|
|
*
|
|
**/
|
|
|
|
public ColorCodec[] getColorCodecs() {
|
|
ColorCodec[] ccs = new ColorCodec[colorcodecs.size()];
|
|
for (int i=0; i<ccs.length; i++) {
|
|
ccs[i] = (ColorCodec)colorcodecs.get(i);
|
|
}
|
|
return ccs;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Lets the user select a locale from a combobox.
|
|
*
|
|
**/
|
|
|
|
public void selectLanguage() {
|
|
// figure out available translations
|
|
File dir = new File("./languages");
|
|
File[] files = dir.listFiles(new PropertiesFilter());
|
|
if ((files != null) && (files.length > 0)) {
|
|
Locale[] locales = new Locale[files.length];
|
|
String[] displayNames = new String[locales.length];
|
|
int defaultIndex=0;
|
|
for (int i=0; i<files.length; i++) {
|
|
String name = files[i].getName();
|
|
String language = name.substring(name.indexOf('_')+1, name.lastIndexOf('_'));
|
|
String country = name.substring(name.lastIndexOf('_')+1, name.lastIndexOf('.'));
|
|
locales[i] = new Locale(language, country);
|
|
displayNames[i] = locales[i].getDisplayName();
|
|
if (language.equals("en")) defaultIndex=i;
|
|
}
|
|
|
|
// ask user to select language
|
|
String selectedName = (String)JOptionPane.showInputDialog(this,
|
|
"Choose a locale:", "Tile Mangler",
|
|
JOptionPane.INFORMATION_MESSAGE, null,
|
|
displayNames, displayNames[defaultIndex]);
|
|
if (selectedName != null) {
|
|
// find selected one
|
|
for (int i=0; i<locales.length; i++) {
|
|
if (selectedName.equals(locales[i].getDisplayName())) {
|
|
// select this locale
|
|
this.locale = locales[i];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
JOptionPane.showMessageDialog(this,
|
|
xlate("No language files found.\nPlease check your installation."),
|
|
"Tile Mangler",
|
|
JOptionPane.ERROR_MESSAGE);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* File filter that recognizes filenames of the form
|
|
* language_xx_yy.properties
|
|
*
|
|
**/
|
|
|
|
private class PropertiesFilter implements FilenameFilter {
|
|
public boolean accept(File dir, String name) {
|
|
return (name.toLowerCase().startsWith("language")
|
|
&& (name.indexOf('_') != -1)
|
|
&& name.toLowerCase().endsWith(".properties"));
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Attempts to translate the given key string by consulting a ResourceBundle.
|
|
* If no corresponding value is found, the key itself is returned.
|
|
*
|
|
**/
|
|
|
|
public String xlate(String key) {
|
|
try {
|
|
String value = xl.xlate(key);
|
|
return value;
|
|
}
|
|
catch (Exception e) {
|
|
return key;
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Gets the selected view frame.
|
|
*
|
|
**/
|
|
|
|
public TMView getSelectedView() {
|
|
return (TMView)desktop.getSelectedFrame();
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Adds the given file to the list of recently opened (closed) files.
|
|
*
|
|
**/
|
|
public void addToRecentFiles(File f) {
|
|
// make sure it's not already in the list
|
|
for (int i=0; i<recentFiles.size(); i++) {
|
|
File rf = (File)recentFiles.get(i);
|
|
if (rf.compareTo(f) == 0) {
|
|
recentFiles.remove(i);
|
|
break;
|
|
}
|
|
}
|
|
// add it
|
|
recentFiles.insertElementAt(f, 0);
|
|
// check for "overflow"
|
|
if (recentFiles.size() > maxRecentFiles) {
|
|
recentFiles.remove(maxRecentFiles-1);
|
|
}
|
|
}
|
|
|
|
} |