/** * Copyright (C) IntelliBitz Technologies., Muthu Ramadoss * 168, Medavakkam Main Road, Madipakkam, Chennai 600091, Tamilnadu, India. * http://www.intellibitz.com * training@intellibitz.com * +91 44 2247 5106 * http://groups.google.com/group/etoe * http://sted.sourceforge.net * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * * STED, Copyright (C) 2007 IntelliBitz Technologies * STED comes with ABSOLUTELY NO WARRANTY; * This is free software, and you are welcome * to redistribute it under the GNU GPL conditions; * * Visit http://www.gnu.org/ for GPL License terms. */ /** * $Id: TabDesktop.java 59 2007-05-19 08:11:31Z sushmu $ * $HeadURL: svn+ssh://sushmu@svn.code.sf.net/p/sted/code/FontTransliterator/trunk/src/intellibitz/sted/ui/TabDesktop.java $ */ package intellibitz.sted.ui; import intellibitz.sted.actions.RedoAction; import intellibitz.sted.actions.UndoAction; import intellibitz.sted.event.FontMapChangeEvent; import intellibitz.sted.event.FontMapChangeListener; import intellibitz.sted.event.FontMapReadEvent; import intellibitz.sted.event.IMessageEventSource; import intellibitz.sted.event.IMessageListener; import intellibitz.sted.event.IStatusEventSource; import intellibitz.sted.event.IStatusListener; import intellibitz.sted.event.IThreadListener; import intellibitz.sted.event.MessageEvent; import intellibitz.sted.event.StatusEvent; import intellibitz.sted.event.ThreadEvent; import intellibitz.sted.event.TransliterateEvent; import intellibitz.sted.fontmap.FontMap; import intellibitz.sted.io.FileFilterHelper; import intellibitz.sted.io.FontMapReader; import intellibitz.sted.launch.STEDGUI; import intellibitz.sted.util.FileHelper; import intellibitz.sted.util.MenuHandler; import intellibitz.sted.util.Resources; import intellibitz.sted.widgets.ButtonTabComponent; import javax.swing.JDesktopPane; import javax.swing.JFileChooser; import javax.swing.JMenu; import javax.swing.JOptionPane; import javax.swing.JTabbedPane; import javax.swing.SwingUtilities; import javax.swing.event.ChangeEvent; import javax.swing.event.ChangeListener; import javax.swing.event.InternalFrameEvent; import javax.swing.event.InternalFrameListener; import javax.xml.transform.TransformerException; import java.awt.HeadlessException; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.beans.PropertyVetoException; import java.io.File; import java.io.IOException; import java.util.Collection; import java.util.HashMap; import java.util.Map; import java.util.Set; import java.util.TreeSet; import java.util.logging.Logger; /** * Desktop managing FontMap Internal Frame's */ public class TabDesktop extends JTabbedPane implements InternalFrameListener, IThreadListener, FontMapChangeListener, ChangeListener, ActionListener, IStatusEventSource, IMessageEventSource { /** * FrameNumberIndex <br> Generates Unique Id for New fontmap frames */ private static class FrameNumberIndex { private Set<Integer> indices = new TreeSet<Integer>(); public FrameNumberIndex() { super(); } /** * if the index is new, add it if the index is existing, then find free * index and add it * * @param indx * @return */ public int addNewIndex(int indx) { int sz = indices.size(); if (!containsIndex(indx) && indx >= sz) { indices.add(indx); return indx; } else { for (int i = 1; i <= sz; i++) { if (!containsIndex(i)) { indices.add(i); return i; } } } return indx; } public boolean removeIndex(int indx) { return indices.remove(indx); } public boolean containsIndex(int indx) { for (Integer indice : indices) { if (indice == indx) { return true; } } return false; } } private JDesktopPane desktopPane; private static final Logger logger = Logger.getLogger(TabDesktop.class.getName()); private FrameNumberIndex frameNumberIndex = new FrameNumberIndex(); // cache to hold fonmap internal frames used by this desktop private Map<String, DesktopFrame> frameCache = new HashMap<String, DesktopFrame>(); // cache to hold new/open fontmaps // private Map<String, FontMap> fontMapCache = new HashMap<String, FontMap>(); // Tabbed Desktop // private JTabbedPane desktopFrames; // private DesktopFrame fontMapperDesktopFrame; // clipboard for fontmap edits private Map<String, Collection> clipboard = new HashMap<String, Collection>(); private IStatusListener statusListener; private StatusEvent statusEvent; private IMessageListener messageListener; private MessageEvent messageEvent; public TabDesktop() { super(); } public void init() { desktopPane = new JDesktopPane(); // we need to listen to our own events here // to update the desktop addChangeListener(this); statusEvent = new StatusEvent(this); messageEvent = new MessageEvent(this); setVisible(true); } public void load() { } public void fireStatusPosted(String message) { statusEvent.setStatus(message); statusListener.statusPosted(statusEvent); } public void fireStatusPosted() { statusListener.statusPosted(statusEvent); } public void addStatusListener(IStatusListener statusListener) { this.statusListener = statusListener; } public void addTab(DesktopFrame desktopFrame) { addTab(desktopFrame.getTitle(), desktopFrame); } public void addTab(String title, DesktopFrame desktopFrame) { desktopFrame.setTitle(title); desktopFrame.removeInternalFrameListener(this); desktopFrame.addInternalFrameListener(this); desktopFrame.getModel().removeFontMapChangeListener(this); desktopFrame.getModel().addFontMapChangeListener(this); super.addTab(title, Resources.getSTEDIcon(), desktopFrame, Resources.getResource(Resources.TIP_TAB_FONTMAP)); initTabComponent(getTabCount() - 1, title); setEnabledAt(getTabCount() - 1, true); setSelectedIndex(getTabCount() - 1); // setSelectedComponent(desktopFrame); // desktopPane.setSelectedFrame(desktopFrame); try { desktopFrame.setSelected(true); } catch (PropertyVetoException e) { e.printStackTrace(); } // stedWindow.selectTab(); // stedWindow.setState(JFrame.MAXIMIZED_BOTH); // stedWindow.setExtendedState(JFrame.MAXIMIZED_BOTH); // this.updateUI(); } private void initTabComponent(int i, String title) { ButtonTabComponent buttonTabComponent = new ButtonTabComponent("TabComponent " + i, this); buttonTabComponent.getTabTitle().setIcon(Resources.getCleanIcon()); buttonTabComponent.getTabTitle().setText(title); buttonTabComponent.addActionListener(this); setTabComponentAt(i, buttonTabComponent); } public int closeFontMap() { return closeFontMap(getFontMapperDesktopFrame()); } public int closeFontMap(DesktopFrame desktopFrame) { int i = saveDirty(desktopFrame); if (JOptionPane.CANCEL_OPTION != i) { int index = getSelectedIndex(); // todo: hacking because the first frame not getting selected by default if (index == -1) { index = getTabCount() - 1; } removeTabFrameAt(index); desktopFrame.close(); } // todo: this must be in activated // hacking it for now since the first frame we load by default is not // getting activated enableCloseAction(); return i; } public int closeFontMap(DesktopFrame desktopFrame, int i) { int result = saveDirty(desktopFrame); if (JOptionPane.CANCEL_OPTION != result) { removeTabFrameAt(i); desktopFrame.close(); } // todo: this must be in activated // hacking it for now since the first frame we load by default is not // getting activated enableCloseAction(); return i; } private boolean removeTabFrameAt(int index) { if (index > -1) { DesktopFrame desktopFrame = (DesktopFrame) getComponentAt(index); String title = desktopFrame.getTitle(); if (title.startsWith(Resources.ACTION_FILE_NEW_COMMAND)) { int indx = getNewIndexNumber(title); // removes the tab index as generated by the newframeindex frameNumberIndex.removeIndex(indx); } // remove the tab with the tab index supplied removeTabAt(index); return true; } return false; } private int getNewIndexNumber(String title) { return Integer.valueOf(title.substring( Resources.ACTION_FILE_NEW_COMMAND.length()).trim()); } private String createNewFrameTitle(int num) { return Resources.ACTION_FILE_NEW_COMMAND + " " + frameNumberIndex.addNewIndex(num); } public void stateChanged(FontMapChangeEvent e) { // select a new tab, if the fontmap is new DesktopFrame desktopFrame = getSelectedFrame(); String title = desktopFrame.getTitle(); if (null != title) { int indx = indexOfTab(title); if (-1 == indx) { addTab(desktopFrame); } else { setEnabledAt(indx, true); } } // if title null, new frame else { addTab(desktopFrame); } // existing fontmaps, with existing tabs ButtonTabComponent buttonTabComponent = (ButtonTabComponent) getTabComponentAt(getSelectedIndex()); buttonTabComponent.getTabTitle().setIcon(Resources.getDirtyIcon()); FontMap fontMap = desktopFrame.getModel().getFontMap(); if (fontMap.getFontMapFile() != null) { buttonTabComponent.getTabTitle() .setText(fontMap.getFontMapFile().getName()); } if (fontMap.isDirty()) { buttonTabComponent.getTabTitle().setIcon(Resources.getDirtyIcon()); } else { buttonTabComponent.getTabTitle().setIcon(Resources.getCleanIcon()); } fireStatusPosted( buttonTabComponent.getTabTitle().getText() + " Active"); // buttonTabComponent.updateUI(); this.updateUI(); } /** * We are listening to our own events, so we can update the dependent * desktop. This is required since the tabbed pane acts as the proxy for the * contained desktop pane. * * @param e The change event of this tabbed pane */ public void stateChanged(ChangeEvent e) { TabDesktop me = (TabDesktop) e.getSource(); int i = me.getSelectedIndex(); if (i != -1) { DesktopFrame myframe = (DesktopFrame) getComponentAt(i); desktopPane.setSelectedFrame(myframe); i = me.getSelectedIndex(); ButtonTabComponent buttonTab = (ButtonTabComponent) getTabComponentAt(i); String title = myframe.getTitle(); if (buttonTab != null) { title = buttonTab.getTabTitle().getText(); } fireStatusPosted(title + " Active"); } enableCloseAction(); } private void enableCloseAction(boolean flag) { MenuHandler.getInstance() .getMenuItem(Resources.ACTION_FILE_CLOSE_COMMAND) .setEnabled(flag); } private void enableCloseAction() { if (getTabCount() > 0) { enableCloseAction(true); } else { enableCloseAction(false); } } /** * listens to tab button, so when tab button is used for closing sync it * with desktop * * @param e */ public void actionPerformed(ActionEvent e) { ButtonTabComponent buttonTabComponent = (ButtonTabComponent) e.getSource(); int i = indexOfTabComponent(buttonTabComponent); if (i != -1) { DesktopFrame desktopFrame = (DesktopFrame) getComponentAt(i); // closeFrameTab(desktopFrame, i-1); closeFontMap(desktopFrame, i); } } /* private void closeFrameTab (DesktopFrame fontMapperDesktopFrame, int i) { if (JOptionPane.CANCEL_OPTION != closeFontMap(fontMapperDesktopFrame)) // cancel button has been pressed during save operation // safely return without performing close { removeTabFrameAt(i); } } */ private DesktopFrame getSelectedFrame() { DesktopFrame desktopFrame = (DesktopFrame) desktopPane.getSelectedFrame(); //hack!! //todo: the frame must be selected, so we dont do this // desktopFrame = (DesktopFrame) getComponentAt(getTabCount()-1); return desktopFrame; } /** * sets FontMap and invokes #fireFontMapChangeEvent () * * @param desktopFrame */ public void addListenersToDesktopFrame( DesktopFrame desktopFrame) { MapperPanel mapperPanel = desktopFrame.getMapperPanel(); DesktopModel desktopModel = desktopFrame.getModel(); FontMap fontMap = desktopModel.getFontMap(); fontMap.removeFontMapChangeListener( mapperPanel); fontMap.addFontMapChangeListener( mapperPanel); fontMap.removeFontMapChangeListener( mapperPanel.getMappingEntryPanel()); fontMap.addFontMapChangeListener( mapperPanel.getMappingEntryPanel()); fontMap.removeFontMapChangeListener(desktopFrame); fontMap.addFontMapChangeListener(desktopFrame); final MenuHandler menuHandler = MenuHandler.getInstance(); final Map actions = menuHandler.getActions(); final FontMapChangeListener newAction = (FontMapChangeListener) menuHandler.getAction(Resources.ACTION_FILE_NEW_COMMAND); fontMap.removeFontMapChangeListener(newAction); fontMap.addFontMapChangeListener(newAction); final FontMapChangeListener reload = (FontMapChangeListener) actions .get(Resources.ACTION_FILE_RELOAD); fontMap.removeFontMapChangeListener(reload); fontMap.addFontMapChangeListener(reload); final FontMapChangeListener save = (FontMapChangeListener) actions .get(Resources.ACTION_FILE_SAVE_COMMAND); fontMap.removeFontMapChangeListener(save); fontMap.addFontMapChangeListener(save); final FontMapChangeListener paste = (FontMapChangeListener) actions .get(Resources.ACTION_PASTE_COMMAND); fontMap.removeFontMapChangeListener(paste); fontMap.addFontMapChangeListener(paste); final UndoAction undo = (UndoAction) actions .get(Resources.ACTION_UNDO_COMMAND); fontMap.removeUndoListener(undo); undo.setEnabled(false); fontMap.addUndoListener(undo); this.removeChangeListener(undo); this.addChangeListener(undo); final RedoAction redo = (RedoAction) actions .get(Resources.ACTION_REDO_COMMAND); fontMap.removeRedoListener(redo); redo.setEnabled(false); fontMap.addRedoListener(redo); this.removeChangeListener(redo); this.addChangeListener(redo); final FontKeypad1 keypad1 = mapperPanel.getFontKeypad1(); fontMap.removeFontListChangeListener(keypad1); fontMap.addFontListChangeListener(keypad1); desktopModel.addFontMapChangeListener(keypad1); final FontKeypad2 keypad2 = mapperPanel.getFontKeypad2(); fontMap.removeFontListChangeListener(keypad2); fontMap.addFontListChangeListener(keypad2); desktopModel.addFontMapChangeListener(keypad2); desktopFrame.addInternalFrameListener( (InternalFrameListener) menuHandler.getActions() .get(Resources.ACTION_FILE_NEW_COMMAND)); desktopFrame.addInternalFrameListener( (InternalFrameListener) menuHandler.getActions ().get(Resources.ACTION_FILE_RELOAD_COMMAND)); desktopFrame.addInternalFrameListener( (InternalFrameListener) menuHandler.getActions() .get(Resources.ACTION_FILE_REOPEN_COMMAND)); desktopFrame.addInternalFrameListener( (InternalFrameListener) menuHandler.getActions() .get(Resources.ACTION_FILE_SAVEAS_COMMAND)); desktopFrame.addInternalFrameListener( (InternalFrameListener) menuHandler.getActions().get( Resources.ACTION_FILE_CLOSE_COMMAND)); desktopModel.removeFontMapChangeListener(newAction); desktopModel.addFontMapChangeListener(newAction); final FontMapChangeListener reopen = (FontMapChangeListener) menuHandler.getActions ().get(Resources.ACTION_FILE_REOPEN_COMMAND); desktopModel.removeFontMapChangeListener(reopen); desktopModel.addFontMapChangeListener(reopen); desktopFrame .addInternalFrameListener((InternalFrameListener) reopen); } public DesktopModel createDesktopModel( DesktopFrame desktopFrame, FontMap fontMap) { DesktopModel desktopModel = new DesktopModel(); desktopModel.setFontMap(fontMap); desktopFrame.setModel(desktopModel); addListenersToDesktopFrame(desktopFrame); desktopFrame.load(); return desktopModel; } public void loadFontMap(File file) { loadFontMap(getSelectedFrame(), file); } public void loadFontMap(DesktopFrame desktopFrame, File file) { DesktopModel desktopModel = createDesktopModel( desktopFrame, new FontMap(file)); desktopModel.addFontMapChangeListener(this); readFontMap(desktopModel); fireStatusPosted("FontMap loaded"); } /** * reads the FontMap from an external File * * @param desktopModel */ public void readFontMap(DesktopModel desktopModel) { //TODO: move this somewhere applicable // clear(); // final String path1 = fontMap.getFont1Path(); // final String path2 = fontMap.getFont2Path(); // fontMap.clear(); // fontMap.clearAll(); // fontMap.setFontMapFile(file); // fontMap.setFont1Path(path1); // fontMap.setFont2Path(path2); FontMap fontMap = desktopModel.getFontMap(); try { final FontMapReader fontMapReader = new FontMapReader(fontMap); fontMapReader.addThreadListener(this); SwingUtilities.invokeLater(fontMapReader); } catch (IllegalArgumentException e) { fireMessagePosted( "Cannot Read FontMap.. Failed: " + e.getMessage()); logger.severe("Cannot Read FontMap - Illegal Argument " + fontMap.getFontMapFile().getAbsolutePath()); fireStatusPosted("Cannot Read FontMap - Illegal Argument " + fontMap.getFontMapFile().getAbsolutePath()); } } /** * */ public void openFontMap() { final File selectedFile = FileHelper .openFile("Please select FontMap location:", Resources.XML, "STED FontMap files", this); if (selectedFile != null) { openFontMap(selectedFile); } } public void newFontMap() { DesktopFrame desktopFrame = loadNewFontMap(); int num = getTabCount() + 1; addTab(createNewFrameTitle(num), desktopFrame); fireStatusPosted("New FontMap"); } /** * creates a new FontMap and loads into the Window if the Window already * contains a new FontMap, clears and loads them otherwise, looks up the * cache for a new FontMap and load them if not in cache, creates a new * FontMap, stores in cache and loads new FontMap * * @return DesktopFrame the newly added fontmap component */ public DesktopFrame loadNewFontMap() { DesktopFrame desktopFrame = createFontMapperDesktopFrame(); FontMap fontMap = new FontMap(); DesktopModel desktopModel = createDesktopModel(desktopFrame, fontMap); // fontMapCache.put(Resources.ACTION_FILE_NEW_COMMAND, fontMap); desktopModel.fireFontMapChangedEvent(); return desktopFrame; } public void reopenFontMap(String fileName) { openFontMap(new File(fileName)); /* FontMap fontMap = getFontMap(); // add it to the reopen menu.. one last check // TODO: remove the following.. typically reopen items must be added as part of events // only fontmaps with a valid filename can be re-opened if (!fontMap.isNew()) { addItemToReOpenMenu(fontMap.getFileName()); } MenuHelper.disableMenuItem(MenuHandler.getInstance(), fileName); fireStatusPosted("FontMap Re-Opened"); */ /* if (fontMap == null) { fontMap = new FontMap(); addListenersToDesktopFrame(fontMap); } else { //TODO: must discard the old fontmap here // fontMap.clearAll(); } // add it to the reopen menu.. one last check // TODO: remove the following.. typically reopen items must be added as part of events // only fontmaps with a valid filename can be re-opened if (!fontMap.isNew()) { addItemToReOpenMenu(fontMap.getFileName()); } // clear the old stuff, if any fontMap.clear(); // fontMap.clearAll(); fontMap.setFontMapFile(new File(fileName)); MenuHelper.disableMenuItem(stedWindow.getInstance(), fileName); stedWindow.getDesktop().readFontMap(); */ } public void reloadFontMap() { // readFontMap(getSelectedFrame().getModel()); DesktopFrame selectedFrame = getSelectedFrame(); File selectedFile = selectedFrame.getModel().getFontMap().getFontMapFile(); // closeFontMap(selectedFrame); removeTabFrameAt(getSelectedIndex()); frameCache.remove(selectedFrame.getModel().getFontMap().getFileName()); // fontMapCache // .remove(selectedFrame.getModel().getFontMap().getFileName()); openFontMap(selectedFile); } public void openFontMap(File selectedFile) { try { DesktopFrame desktopFrame = frameCache.get(selectedFile.getAbsolutePath()); if (desktopFrame == null) { desktopFrame = createFontMapperDesktopFrame(); //todo: repeat the logic of the frame creation, init and load loadFontMap(desktopFrame, selectedFile); DesktopModel desktopModel = desktopFrame.getModel(); FontMap fontMap = desktopModel.getFontMap(); // desktopModel.setFontMap(fontMap); // fontMapCache.put(fontMap.getFileName(), fontMap); frameCache.put(fontMap.getFileName(), desktopFrame); } // add it to the tabs add(desktopFrame); desktopPane.setSelectedFrame(desktopFrame); desktopFrame.getModel().fireFontMapChangedEvent(); // showDesktopFrame(); /* // try the cache first fontMap = (FontMap) fontMapCache.get(selectedFile.getAbsolutePath()); // if not found.. create a new one if (fontMap == null) { readFontMap(selectedFile); fontMapCache.put(fontMap.getFileName(), fontMap); } else { fireFontMapChangedEvent(); showDesktopFrame(); } */ } catch (HeadlessException ex) { logger.throwing("intellibitz.sted.util.FontMapHelper", "readFontMap", ex); JOptionPane.showMessageDialog(this, "Invalid FontMap " + selectedFile.getAbsolutePath()); } catch (IllegalArgumentException ex) { logger.throwing("intellibitz.sted.util.FontMapHelper", "readFontMap", ex); JOptionPane.showMessageDialog(this, "Load Failed: " + ex.getMessage()); } } private void saveFontMap() { DesktopFrame desktopFrame = getSelectedFrame(); FontMap fontMap = desktopFrame.getModel().getFontMap(); fontMap.setFont1(desktopFrame.getMapperPanel() .getFontKeypad1().getSelectedFont()); fontMap.setFont2(desktopFrame.getMapperPanel() .getFontKeypad2().getSelectedFont()); try { fontMap = desktopFrame.getModel().saveFontMap(); //add it to cache // fontMapCache.put(fontMap.getFileName(), fontMap); // get } catch (TransformerException exception) { exception .printStackTrace(); //To change body of catch statement use Options | File Templates. JOptionPane.showMessageDialog(this, fontMap.getFileName() + " cannot create for writing " + exception.getMessage()); } // JOptionPane.showMessageDialog(stedWindow, "saved FontMap in " + selectedFile.getAbsolutePath()); } public void saveAction() { FontMap fontMap = getFontMap(); final File selectedFile = fontMap.getFontMapFile(); if (selectedFile == null) { // try the save as functionality saveAsAction(); } else if (!selectedFile.canWrite()) { try { selectedFile.createNewFile(); fontMap.setFontMapFile(selectedFile); } catch (IOException exception) { JOptionPane.showMessageDialog(this, selectedFile + " cannot create for writing " + exception.getMessage()); } } else { saveFontMap(); } } public int saveAsAction() { FontMap fontMap = getFontMap(); final JFileChooser jFileChooser = new JFileChooser(System.getProperty("user.dir")); final FileFilterHelper fileFilterHelper = new FileFilterHelper("xml", "STED FontMap files"); jFileChooser.setFileFilter(fileFilterHelper); final int result = jFileChooser.showSaveDialog(this); if (result == JFileChooser.APPROVE_OPTION) { File selectedFile = jFileChooser.getSelectedFile(); if (selectedFile.canWrite()) { fontMap.setFontMapFile(selectedFile); saveFontMap(); } else { JOptionPane.showMessageDialog(this, selectedFile + " is NOT Writable"); } } return result; } public int saveDirty() { return saveDirty(getSelectedFrame()); } public int saveDirty(DesktopFrame desktopFrame) { int result = JOptionPane.CLOSED_OPTION; if (null != desktopFrame) { FontMap fontMap = desktopFrame.getModel().getFontMap(); if (fontMap != null && fontMap.isDirty()) { result = JOptionPane.showConfirmDialog(this, "FontMap Changed.. Do you want to save changes?", "Save Changes", JOptionPane.YES_NO_CANCEL_OPTION); // if yes, save the fontmap if (JOptionPane.YES_OPTION == result) { if (fontMap.isNew()) { result = saveAsAction(); // can be cancelled.. clear the fontmap if (JFileChooser.CANCEL_OPTION == result) { fontMap.clear(); } } else { saveAction(); } } else if (JOptionPane.NO_OPTION == result) { //TODO: need to do something sensible for NO_OPTION // if no, discard the fontmap // setDirty will fire events..so DONT use! // fontMap.setDirty(false); // try clear (need to investigate if this would affect other actions!) fontMap.clear(); } } } return result; } public void clear() { getSelectedFrame().clear(); } public FontMap getFontMap() { return getSelectedFrame().getModel() .getFontMap(); } public void addItemToReOpenMenu(String item) { final MenuHandler menuHandler = MenuHandler.getInstance(); final JMenu menu = menuHandler.getMenu(Resources.ACTION_FILE_REOPEN_COMMAND); MenuHandler.addReOpenItem(menu, item); menu.setEnabled( menu.getItemCount() != Resources.DEFAULT_MENU_COUNT + 1); } public DesktopFrame createFontMapperDesktopFrame() { DesktopFrame desktopFrame = new DesktopFrame(); desktopFrame.addInternalFrameListener(this); desktopFrame.init(); // add it to the desktop desktopPane.add(desktopFrame); desktopPane.setSelectedFrame(desktopFrame); desktopFrame.setEnabled(true); desktopFrame.setVisible(true); return desktopFrame; } /** * creates a new FontMap and loads into the Window if the Window already * contains a new FontMap, clears and loads them otherwise, looks up the * cache for a new FontMap and load them if not in cache, creates a new * FontMap, stores in cache and loads new FontMap * @return */ /* public void loadNewFontMap() { // FIRST TIME // create a new frame and set the fontmap // OTHER THAN FIRST TIME // get the frame from the cache, set it as current clear(); // check the current FontMap first if (fontMap != null && fontMap.isNew()) { // clear the existing fontmap contents.. no need to clear the listeners fontMap.clear(); // stedWindow.addListenersToDesktopFrame(fontMap); // stedWindow.createDesktopModel(); fireFontMapChangedEvent(); } else { // try the cache FontMap fMap = (FontMap) fontMapCache.get(Resources.ACTION_FILE_NEW_COMMAND); // if not found, create new one if (fMap == null) { fMap = new FontMap(); fontMapCache.put(Resources.ACTION_FILE_NEW_COMMAND, fMap); addListenersToDesktopFrame(fMap); } else if (!fMap.isNew()) { fMap = new FontMap(); fontMapCache.put(Resources.ACTION_FILE_NEW_COMMAND, fMap); addListenersToDesktopFrame(fMap); } else { fontMap.clear(); // stedWindow.addListenersToDesktopFrame(fontMap); // stedWindow.createDesktopModel(); fireFontMapChangedEvent(); } } stedWindow.showDesktop(); } */ /** * @return */ public Map<String, Collection> getClipboard() { return clipboard; } public void addToClipboard(String entry, Collection value) { clipboard.put(entry, value); fireStatusPosted("Copied Fontmap Entries"); } public DesktopFrame getFontMapperDesktopFrame() { return getSelectedFrame(); } public DesktopModel getDesktopModel() { return getFontMapperDesktopFrame().getModel(); } public String getFrameTitle() { DesktopFrame desktopFrame = getSelectedFrame(); if (null == desktopFrame) { return null; } else { return desktopFrame.getTitle(); } } public void fireMessagePosted(String message) { messageEvent.setMessage(message); messageListener.messagePosted(messageEvent); } public void fireMessagePosted() { messageListener.messagePosted(messageEvent); } public void addMessageListener(IMessageListener messageListener) { this.messageListener = messageListener; } public void threadRunStarted(ThreadEvent e) { STEDGUI.busy(); } public void threadRunning(ThreadEvent e) { } public void threadRunFailed(ThreadEvent e) { STEDGUI.busy(); String message = e.getEventSource().getMessage().toString(); JOptionPane.showMessageDialog(this, message, "Error", JOptionPane.ERROR_MESSAGE); // if FontMapReader.. if (FontMapReadEvent.class.isInstance(e)) { closeFontMap(); } // if Transliterator.. if (TransliterateEvent.class.isInstance(e)) { // enable the convert action MenuHandler.getInstance() .getAction(Resources.ACTION_CONVERT_NAME) .setEnabled(true); // disable the stop button MenuHandler.getInstance().getAction(Resources.ACTION_STOP_NAME) .setEnabled(false); } fireStatusPosted(message); STEDGUI.relax(); } public void threadRunFinished(ThreadEvent e) { // if FontMapReader.. if (FontMapReadEvent.class.isInstance(e)) { DesktopModel desktopModel = getSelectedFrame().getModel(); final FontMap fontMap = desktopModel.getFontMap(); fontMap.setDirty(false); desktopModel.fireFontMapChangedEvent(); fireStatusPosted("FontMap Loaded"); } // if Transliterator.. else if (TransliterateEvent.class.isInstance(e)) { // readFontMap the converted file getSelectedFrame().readOutputFile(); // enable the convert action MenuHandler.getInstance() .getAction(Resources.ACTION_CONVERT_NAME) .setEnabled(true); // disable the stop button MenuHandler.getInstance().getAction(Resources.ACTION_STOP_NAME) .setEnabled(false); fireStatusPosted("Transliterate Done"); } STEDGUI.relax(); } public void internalFrameClosing(InternalFrameEvent e) { DesktopFrame desktopFrame = (DesktopFrame) e.getInternalFrame(); if (JOptionPane.CANCEL_OPTION != saveDirty(desktopFrame)) { // when the frame closes, close the tab int index = getSelectedIndex(); removeTabFrameAt(index); desktopFrame.close(); } // todo: this must be in activated // hacking it for now since the first frame we load by default is not // getting activated enableCloseAction(); } public void internalFrameActivated(InternalFrameEvent e) { // enable the view mapping and sample when the internal frame is shown MenuHandler.getInstance() .getMenuItem(Resources.ACTION_VIEW_MAPPING) .setEnabled(true); MenuHandler.getInstance() .getMenuItem(Resources.ACTION_VIEW_SAMPLE) .setEnabled(true); DesktopFrame desktopFrame = (DesktopFrame) e.getInternalFrame(); desktopFrame.setEnabledFontMapTab(true); enableCloseAction(); } public void internalFrameOpened(InternalFrameEvent e) { // todo: this must be in activated // hacking it for now since the first frame we load by default is not // getting activated enableCloseAction(); } public void internalFrameClosed(InternalFrameEvent e) { // todo: this must be in activated // hacking it for now since the first frame we load by default is not // getting activated enableCloseAction(); } public void internalFrameIconified(InternalFrameEvent e) { //To change body of implemented methods use File | Settings | File Templates. } public void internalFrameDeiconified(InternalFrameEvent e) { //To change body of implemented methods use File | Settings | File Templates. } public void internalFrameDeactivated(InternalFrameEvent e) { } }