880 lines
26 KiB
Java
880 lines
26 KiB
Java
/*
|
|
The contents of this file are subject to the THDL Open Community License
|
|
Version 1.0 (the "License"); you may not use this file except in compliance
|
|
with the License. You may obtain a copy of the License on the THDL web site
|
|
(http://www.thdl.org/).
|
|
|
|
Software distributed under the License is distributed on an "AS IS" basis,
|
|
WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
|
|
License for the specific terms governing rights and limitations under the
|
|
License.
|
|
|
|
The Initial Developer of this software is the Tibetan and Himalayan Digital
|
|
Library (THDL). Portions created by the THDL are Copyright 2001-2003 THDL.
|
|
All Rights Reserved.
|
|
|
|
Contributor(s): ______________________________________.
|
|
*/
|
|
|
|
package org.thdl.tib.bibl;
|
|
|
|
import java.awt.Event;
|
|
import java.awt.event.*;
|
|
import java.awt.Color;
|
|
import java.awt.Dimension;
|
|
import java.awt.Toolkit;
|
|
import java.io.File;
|
|
import java.util.Vector;
|
|
import java.util.Iterator;
|
|
import javax.swing.*;
|
|
import javax.swing.text.*;
|
|
import javax.swing.event.*;
|
|
|
|
/**
|
|
* <p>
|
|
* TibFrame is the view for the {@link TiblEdit} program. TiblEdit is the controller.
|
|
* {@link TibDoc}, or {@link TiblEdit#tibbibl} in its instantiation, is the data model.
|
|
* TibFrame mainly utilizes a {@link TextPane} (an extension of JTextPane) as its main
|
|
* view window, but also allows split screens with a {@link DiacriticPanel} on the left and/or
|
|
* a {@link TibTable} at the bottom.
|
|
* </p>
|
|
*
|
|
* @author Than Garson, Tibetan and Himalayan Digital Library
|
|
*/
|
|
|
|
public class TibFrame extends JFrame implements CaretListener, TibConstants
|
|
{
|
|
// Attributes
|
|
private TiblEdit controller;
|
|
|
|
// Frame Attributes
|
|
private JMenu fileMenu, editMenu, insertMenu, provMenu, viewMenu;
|
|
// File Menu items
|
|
private JMenuItem openItem, closeItem, saveItem, saveAsItem, exportItem, exitItem;
|
|
|
|
// Edit Menu items
|
|
protected JMenuItem cutItem, copyItem, pasteItem, editTransItem, editNormItem,
|
|
removeAppItem, removeTitleItem, removeEditionItem;
|
|
|
|
// Insert menu items
|
|
private JMenuItem critTitleItem, edTitleItem, variantItem, insertEdItem, insertDiscItem;
|
|
|
|
// View Menu items
|
|
private JCheckBoxMenuItem diacItem, edConsultItem;
|
|
private JMenuItem masterIDItem, userIDItem, aboutItem;
|
|
private JMenuItem[] recentFileItems;
|
|
//private JMenuItem authorItem, audienceItem, redactorItem, translatorItem, concealerItem, revealerItem;
|
|
|
|
private JPanel contentPanel;
|
|
private JComponent rightSp, leftSp, bottomSp, topSp;
|
|
private JSplitPane horizontalSplit, verticalSplit;
|
|
private TextPane tp;
|
|
private DiacriticPanel dp;
|
|
private TibTable tibTable;
|
|
Vector styleElements;
|
|
|
|
// Initialization
|
|
/**
|
|
* <p>
|
|
* This is the initialization method for the TibFrame. The TibFrame is the view for
|
|
* this program, for which a {@link TiblEdit} object is the controller and
|
|
* a {@link TibDoc} is the data model. This method establishes a file menu,
|
|
* an edit menu, an view menu, and an insert menu. Its content pane is set to a
|
|
* JScrollPane with a {@link TextPane} as its view.
|
|
* </p>
|
|
*/
|
|
protected void init()
|
|
{
|
|
Toolkit xKit = getToolkit();
|
|
Dimension wndSize = xKit.getScreenSize();
|
|
setBounds(wndSize.width/16, wndSize.height/16,
|
|
7*wndSize.width/8, 7*wndSize.height/8);
|
|
addWindowListener(new XWindowHandler());
|
|
addComponentListener(new XComponentHandler());
|
|
|
|
// TextPane content pane
|
|
tp = new TextPane(controller);
|
|
EditorKit ekit = tp.getEditorKit();
|
|
Action[] actions = ekit.getActions();
|
|
|
|
// MenuBar
|
|
JMenuBar menuBar = new JMenuBar();
|
|
setJMenuBar(menuBar);
|
|
|
|
// File Menu
|
|
fileMenu = new JMenu(FILE);
|
|
openItem = fileMenu.add(new FileAction(OPENFILE,this));
|
|
openItem.setAccelerator(KeyStroke.getKeyStroke('O',Event.CTRL_MASK));
|
|
openItem.setFont(MENU_FONT);
|
|
openItem.setEnabled(true);
|
|
|
|
closeItem = fileMenu.add(new FileAction(CLOSEFILE,this));
|
|
closeItem.setAccelerator(KeyStroke.getKeyStroke('W',Event.CTRL_MASK));
|
|
closeItem.setFont(MENU_FONT);
|
|
closeItem.setEnabled(false);
|
|
|
|
saveItem = fileMenu.add(new FileAction(SAVE,this));
|
|
saveItem.setAccelerator(KeyStroke.getKeyStroke('S',Event.CTRL_MASK));
|
|
saveItem.setFont(MENU_FONT);
|
|
saveItem.setEnabled(false);
|
|
|
|
fileMenu.addSeparator();
|
|
|
|
recentFileItems = new JMenuItem[RECENT_FILE_SIZE];
|
|
for(int n=0;n<recentFileItems.length;n++)
|
|
{
|
|
recentFileItems[n] = new JMenuItem();
|
|
fileMenu.add(recentFileItems[n]);
|
|
recentFileItems[n].setVisible(false);
|
|
}
|
|
|
|
recentFileItems[0].setText(" ");
|
|
recentFileItems[0].setVisible(true);
|
|
|
|
fileMenu.addSeparator();
|
|
exitItem = fileMenu.add(new FileAction(EXIT, this));
|
|
exitItem.setAccelerator(KeyStroke.getKeyStroke('Q',Event.CTRL_MASK));
|
|
exitItem.setFont(MENU_FONT);
|
|
exitItem.setEnabled(true);
|
|
|
|
menuBar.add(fileMenu);
|
|
|
|
// Edit Menu
|
|
editMenu = new JMenu(EDIT);
|
|
|
|
// 65 - paste; 26 - copy; 14 -cut
|
|
|
|
copyItem = editMenu.add(actions[26]);
|
|
copyItem.setAccelerator(KeyStroke.getKeyStroke('C',Event.CTRL_MASK));
|
|
copyItem.setText("Copy");
|
|
copyItem.setFont(MENU_FONT);
|
|
copyItem.setEnabled(false);
|
|
|
|
cutItem = editMenu.add(actions[14]);
|
|
cutItem.setAccelerator(KeyStroke.getKeyStroke('X',Event.CTRL_MASK));
|
|
cutItem.setText("Cut");
|
|
cutItem.setFont(MENU_FONT);
|
|
cutItem.setEnabled(false);
|
|
|
|
pasteItem = editMenu.add(actions[65]);
|
|
pasteItem.setAccelerator(KeyStroke.getKeyStroke('V',Event.CTRL_MASK));
|
|
pasteItem.setText("Paste");
|
|
pasteItem.setFont(MENU_FONT);
|
|
pasteItem.setEnabled(false);
|
|
|
|
editMenu.addSeparator();
|
|
editTransItem = editMenu.add(new EditAction(TRANS_EDIT,this));
|
|
editTransItem.setAccelerator(KeyStroke.getKeyStroke('T',Event.CTRL_MASK));
|
|
editTransItem.setFont(MENU_FONT);
|
|
editTransItem.setEnabled(false);
|
|
|
|
editNormItem = editMenu.add(new EditAction(NORM_EDIT,this));
|
|
editNormItem.setFont(MENU_FONT);
|
|
editNormItem.setAccelerator(KeyStroke.getKeyStroke('N',Event.CTRL_MASK));
|
|
editNormItem.setEnabled(false);
|
|
|
|
removeAppItem = editMenu.add(new EditAction(REMOVE_APP,this));
|
|
removeAppItem.setFont(MENU_FONT);
|
|
removeAppItem.setAccelerator(KeyStroke.getKeyStroke('X',Event.CTRL_MASK+Event.SHIFT_MASK));
|
|
removeAppItem.setEnabled(false);
|
|
|
|
removeTitleItem = editMenu.add(new EditAction(REMOVE_TITLE,this));
|
|
removeTitleItem.setFont(MENU_FONT);
|
|
removeTitleItem.setAccelerator(KeyStroke.getKeyStroke('T',Event.CTRL_MASK+Event.SHIFT_MASK));
|
|
removeTitleItem.setEnabled(false);
|
|
|
|
removeEditionItem = editMenu.add(new EditAction(REMOVE_EDITION,this));
|
|
removeEditionItem.setFont(MENU_FONT);
|
|
removeEditionItem.setAccelerator(KeyStroke.getKeyStroke('R',Event.CTRL_MASK+Event.SHIFT_MASK));
|
|
removeEditionItem.setEnabled(false);
|
|
|
|
menuBar.add(editMenu);
|
|
|
|
// Insert menu
|
|
insertMenu = new JMenu(INSERT);
|
|
|
|
insertEdItem = insertMenu.add(new InsertAction(ED_INFO,this));
|
|
insertEdItem.setFont(MENU_FONT);
|
|
insertEdItem.setAccelerator(KeyStroke.getKeyStroke('I',Event.CTRL_MASK));
|
|
insertEdItem.setEnabled(false);
|
|
|
|
critTitleItem = insertMenu.add(new InsertAction(CRIT_TITLE,this));
|
|
critTitleItem.setFont(MENU_FONT);
|
|
critTitleItem.setAccelerator(KeyStroke.getKeyStroke('C',Event.CTRL_MASK+Event.SHIFT_MASK));
|
|
critTitleItem.setEnabled(false);
|
|
|
|
edTitleItem = insertMenu.add(new InsertAction(ED_TITLE,this));
|
|
edTitleItem.setFont(MENU_FONT);
|
|
edTitleItem.setAccelerator(KeyStroke.getKeyStroke('E',Event.CTRL_MASK+Event.SHIFT_MASK));
|
|
edTitleItem.setEnabled(false);
|
|
|
|
insertDiscItem = insertMenu.add(new InsertAction(TITLE_DISC,this));
|
|
insertDiscItem.setFont(MENU_FONT);
|
|
insertDiscItem.setAccelerator(KeyStroke.getKeyStroke('D',Event.CTRL_MASK+Event.SHIFT_MASK));
|
|
insertDiscItem.setEnabled(false);
|
|
|
|
insertMenu.addSeparator();
|
|
variantItem = insertMenu.add(new InsertAction(INSERT_APP,this));
|
|
variantItem.setFont(MENU_FONT);
|
|
variantItem.setAccelerator(KeyStroke.getKeyStroke('V',Event.CTRL_MASK+Event.SHIFT_MASK));
|
|
variantItem.setEnabled(false);
|
|
|
|
menuBar.add(insertMenu);
|
|
|
|
// View menu
|
|
viewMenu = new JMenu(VIEW);
|
|
|
|
masterIDItem = viewMenu.add(new ViewAction(MASTER_ID_VIEW,this));
|
|
masterIDItem.setFont(MENU_FONT);
|
|
masterIDItem.setAccelerator(KeyStroke.getKeyStroke('M',Event.CTRL_MASK));
|
|
masterIDItem.setEnabled(false);
|
|
|
|
viewMenu.addSeparator();
|
|
|
|
edConsultItem = new JCheckBoxMenuItem(EDCON,false);
|
|
edConsultItem.setFont(MENU_FONT);
|
|
edConsultItem.setAccelerator(KeyStroke.getKeyStroke('E',Event.CTRL_MASK));
|
|
edConsultItem.addActionListener(new ActionListener() {
|
|
public void actionPerformed(ActionEvent ae) {
|
|
boolean on = ((JCheckBoxMenuItem)ae.getSource()).isSelected();
|
|
if(on) {
|
|
showEditions();
|
|
} else {
|
|
hideEditions();
|
|
}
|
|
}
|
|
});
|
|
edConsultItem.setEnabled(false);
|
|
viewMenu.add(edConsultItem);
|
|
|
|
diacItem = new JCheckBoxMenuItem(DIAC,false);
|
|
diacItem.setFont(MENU_FONT);
|
|
diacItem.setAccelerator(KeyStroke.getKeyStroke('D',Event.CTRL_MASK));
|
|
diacItem.addActionListener(new ActionListener() {
|
|
public void actionPerformed(ActionEvent ae) {
|
|
boolean on = ((JCheckBoxMenuItem)ae.getSource()).isSelected();
|
|
if(on) {
|
|
showDiacritics();
|
|
} else {
|
|
hideDiacritics();
|
|
}
|
|
}
|
|
});
|
|
viewMenu.add(diacItem);
|
|
|
|
userIDItem = viewMenu.add(new ViewAction(USER_ID_VIEW,this));
|
|
userIDItem.setFont(MENU_FONT);
|
|
userIDItem.setEnabled(true);
|
|
|
|
viewMenu.addSeparator();
|
|
|
|
aboutItem = viewMenu.add(new ViewAction(ABOUT,this));
|
|
aboutItem.setFont(MENU_FONT);
|
|
aboutItem.setEnabled(true);
|
|
|
|
menuBar.add(viewMenu);
|
|
|
|
//Content frame
|
|
|
|
|
|
topSp = new JScrollPane(tp, JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,
|
|
JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
|
|
getContentPane().add(topSp);
|
|
setVisible(true);
|
|
tp.setEditable(false);
|
|
}
|
|
|
|
// Accessors
|
|
/**
|
|
* <p>
|
|
* This sets the {@link #controller} variable to the controller which is the
|
|
* instantiation of the main {@link TiblEdit} program.
|
|
* </p>
|
|
*
|
|
* @param jt TiblEdit - the controller of the program.
|
|
*/
|
|
public void setController (TiblEdit jt)
|
|
{
|
|
controller = jt;
|
|
}
|
|
|
|
/**
|
|
* <p>
|
|
* This method returns the controller for this view.
|
|
* </p>
|
|
*
|
|
* @return TiblEdit - the controller.
|
|
*/
|
|
public TiblEdit getController()
|
|
{
|
|
return controller;
|
|
}
|
|
|
|
/**
|
|
* <p>
|
|
* This method sets the list of recent files in the file menu.
|
|
* </p>
|
|
*
|
|
* @param recent Vector - A Vector of the recent files from the controller.
|
|
*/
|
|
public void setRecentFiles(Vector recent)
|
|
{
|
|
int n = 0;
|
|
for(Iterator it=recent.iterator();it.hasNext();)
|
|
{
|
|
final File file = (File)it.next();
|
|
if(n == RECENT_FILE_SIZE) {break;}
|
|
JMenuItem fileItem = recentFileItems[n++];
|
|
fileItem.setText(file.getName());
|
|
ActionListener al[] = fileItem.getActionListeners();
|
|
if(al != null && al.length >0) {fileItem.removeActionListener(al[0]);}
|
|
fileItem.addActionListener(new ActionListener() {
|
|
public void actionPerformed(ActionEvent ae)
|
|
{
|
|
controller.openFile(file);
|
|
}
|
|
});
|
|
fileItem.setVisible(true);
|
|
fileItem.setEnabled(true);
|
|
}
|
|
|
|
for(;n<RECENT_FILE_SIZE;n++)
|
|
{
|
|
recentFileItems[n].setVisible(false);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* <p>
|
|
* This returns the {@link TextPane} that is the main view for tibbibl text information.
|
|
* The TextPane is set in this objects {@link #init} method and is set within a
|
|
* JScrollPane.
|
|
* </p>
|
|
*
|
|
* @return TextPane the text pane that is the main content view of the program.
|
|
*/
|
|
public TextPane getTextPane()
|
|
{
|
|
return tp;
|
|
}
|
|
|
|
/**
|
|
* <p>
|
|
* This returns the position of the caret within the {@link TextPane} that is
|
|
* the main text view for the program.
|
|
* </p>
|
|
*
|
|
* @return int - the position of the caret.
|
|
*/
|
|
public int getCaretPosition()
|
|
{
|
|
return tp.getCaret().getDot();
|
|
}
|
|
|
|
// Helper methods
|
|
/**
|
|
* <p>
|
|
* This method is called by the controller when a file is opened. It serves to
|
|
* enable or disable the appropriate menu commands. Open is disabled, and
|
|
* close, save, view titles, add crit title, add ed title, and view editions consulted
|
|
* are turned on.
|
|
* </p>
|
|
*/
|
|
public void fileOpened()
|
|
{
|
|
setTitle(PROG_NAME+controller.getCurrentFile().getName());
|
|
openItem.setEnabled(false);
|
|
closeItem.setEnabled(true);
|
|
saveItem.setEnabled(true);
|
|
critTitleItem.setEnabled(true);
|
|
edTitleItem.setEnabled(true);
|
|
edConsultItem.setEnabled(true);
|
|
copyItem.setEnabled(true);
|
|
cutItem.setEnabled(true);
|
|
pasteItem.setEnabled(true);
|
|
editTransItem.setEnabled(true);
|
|
editNormItem.setEnabled(true);
|
|
masterIDItem.setEnabled(true);
|
|
insertEdItem.setEnabled(true);
|
|
removeEditionItem.setEnabled(true);
|
|
insertDiscItem.setEnabled(true);
|
|
for(int n=0;n<RECENT_FILE_SIZE;n++)
|
|
recentFileItems[n].setEnabled(false);
|
|
}
|
|
|
|
/**
|
|
* <p>
|
|
* This method is called by the controller when a file is closed. It serves to
|
|
* enable or disable the appropriate menu commands. Open is enabled and
|
|
* close, save, insert crit title, insert ed title, view titles, and view editions
|
|
* consulted are all disabled. It also calls {@link TextPane#reset}, which resets
|
|
* the styled document for the textpane view, calls {@link #hideEditions} to hide
|
|
* any table that is displaying at the bottom of the screen, and then redisplays itself
|
|
* with {@link #show}.
|
|
* </p>
|
|
*/
|
|
public void fileClosed()
|
|
{
|
|
setTitle(DEFAULT_HEADER);
|
|
openItem.setEnabled(true);
|
|
closeItem.setEnabled(false);
|
|
saveItem.setEnabled(false);
|
|
critTitleItem.setEnabled(false);
|
|
edTitleItem.setEnabled(false);
|
|
edConsultItem.setEnabled(false);
|
|
copyItem.setEnabled(false);
|
|
cutItem.setEnabled(false);
|
|
pasteItem.setEnabled(false);
|
|
editTransItem.setEnabled(false);
|
|
editNormItem.setEnabled(false);
|
|
masterIDItem.setEnabled(false);
|
|
insertEdItem.setEnabled(false);
|
|
removeEditionItem.setEnabled(false);
|
|
insertDiscItem.setEnabled(false);
|
|
|
|
tp.reset();
|
|
hideEditions();
|
|
setRecentFiles(controller.getRecent());
|
|
setTitle(DEFAULT_HEADER);
|
|
show();
|
|
}
|
|
|
|
/**
|
|
* <p>
|
|
* This method is called (maybe) when the cursor is on a title. It enables the add
|
|
* critical title menu option. (May be deprecated?)
|
|
* </p>
|
|
*/
|
|
public void titleSelected()
|
|
{
|
|
critTitleItem.setEnabled(true);
|
|
}
|
|
|
|
/**
|
|
* <p>
|
|
* This method is called (maybe) when cursor is on something other than a title. It disables the add
|
|
* critical title menu option. (May be deprecated?)
|
|
* </p>
|
|
*/
|
|
public void titleNotSelected()
|
|
{
|
|
critTitleItem.setEnabled(false);
|
|
}
|
|
|
|
/**
|
|
* <p>
|
|
* This method displays a {@link TibTable} as the bottom half of a split screen with the {@link TextPane}
|
|
* This particular table displays the editions consulted for the formation of the master record
|
|
* by displaying the information in the text's tibiddecl element. To do so it uses {@link TibTable#TibTable(IDFactory) TibTable constructor}
|
|
* that takes an {@link IDFactory} retrieved from the {@link TibDoc}. It then calls {@link #showTable(TibTable) TibTable}
|
|
* method.
|
|
* </p>
|
|
*/
|
|
public void showEditions()
|
|
{
|
|
if(controller.getTibDoc() == null) {return;}
|
|
tibTable = new TibTable(controller.getTibDoc().getIDFactory());
|
|
showTable(tibTable);
|
|
}
|
|
/**
|
|
* <p>
|
|
* This method hides <b>any</b> table that is displaying at the bottom of the {@link TextPane}. The first
|
|
* table that used this was the edition's consulted table, but it will close any table including an apparatus
|
|
* table that is displaying at the bottom of the screen.
|
|
* </p>
|
|
*/
|
|
|
|
public void hideEditions()
|
|
{
|
|
topSp = new JScrollPane(tp);
|
|
if(horizontalSplit == null) {
|
|
setContentPane(topSp);
|
|
show();
|
|
|
|
} else {
|
|
int horizLoc = horizontalSplit.getDividerLocation();
|
|
horizontalSplit.setRightComponent(topSp);
|
|
show();
|
|
horizontalSplit.setDividerLocation(horizLoc);
|
|
}
|
|
show();
|
|
verticalSplit = null;
|
|
}
|
|
|
|
/**
|
|
* <p>
|
|
* This method creates a split screen with a {@link DiacriticPanel#DiacriticPanel(TibFrame) DiacriticPanel}
|
|
* on the left and the main {@link TextPane} on the right.
|
|
* </p>
|
|
*/
|
|
public void showDiacritics()
|
|
{
|
|
dp = new DiacriticPanel(this);
|
|
rightSp = new JScrollPane(dp);
|
|
JComponent comp;
|
|
if(verticalSplit == null) {
|
|
leftSp = new JScrollPane(tp);
|
|
comp = leftSp;
|
|
} else {
|
|
comp = verticalSplit;
|
|
}
|
|
horizontalSplit = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT,rightSp,comp);
|
|
setContentPane(horizontalSplit);
|
|
show();
|
|
double loc = 0.1D;
|
|
horizontalSplit.setDividerLocation(loc);
|
|
}
|
|
|
|
/**
|
|
* <p>
|
|
* This method hides the {@link DiacriticPanel} that is displayed on the left of
|
|
* the split screen.
|
|
* </p>
|
|
*/
|
|
public void hideDiacritics()
|
|
{
|
|
JComponent comp;
|
|
if(verticalSplit == null) {
|
|
comp = tp;
|
|
} else {
|
|
comp = verticalSplit;
|
|
}
|
|
rightSp = new JScrollPane(comp);
|
|
setContentPane(rightSp);
|
|
show();
|
|
horizontalSplit = null;
|
|
}
|
|
|
|
/**
|
|
* <p>
|
|
* This method displays a {@link TibTable} underneath the {@link TextPane}. It takes a
|
|
* {@link TibTable} as its parameter and depending on the value of its {@link TibTable#getType() type}
|
|
* inserts either an JTable with the editions consulted or it retrieves an {@link TibTable#getAppPanel() specific
|
|
* JPanel} that has a table with an apparatus' info and control buttons.
|
|
* </p>
|
|
*
|
|
* @param tt TibTable - the TibTable object that contains the tabular information to be displayed.
|
|
*/
|
|
public void showTable(TibTable tt)
|
|
{
|
|
JSplitPane tableSplit = new JSplitPane();
|
|
if(tt.getType() == TibTable.APP) {
|
|
edConsultItem.setSelected(false);
|
|
tt.addObserver(controller);
|
|
tableSplit = tt.getAppPanel();
|
|
bottomSp = tableSplit;
|
|
} else {
|
|
bottomSp = new JScrollPane(tt.getTable());
|
|
}
|
|
topSp = new JScrollPane(tp);
|
|
verticalSplit = new JSplitPane(JSplitPane.VERTICAL_SPLIT,topSp,bottomSp);
|
|
if(horizontalSplit == null) {
|
|
setContentPane(verticalSplit);
|
|
show();
|
|
} else {
|
|
int horizLoc = horizontalSplit.getDividerLocation();
|
|
horizontalSplit.setRightComponent(verticalSplit);
|
|
show();
|
|
horizontalSplit.setDividerLocation(horizLoc);
|
|
}
|
|
double loc = 0.80D;
|
|
verticalSplit.setDividerLocation(loc);
|
|
tableSplit.setDividerLocation(loc);
|
|
}
|
|
|
|
/**
|
|
* <p>
|
|
* This method is called if the insert variant option is chosen from the insert menu. Variant readings
|
|
* are displayed in the {@link TextPane} with a yellow background and are determined by being marked up
|
|
* within an app element. When inserting a new variant, the app element was not originally there so the
|
|
* selected area does not have a yellow background. This method sets the background of the selected area
|
|
* to yellow until the insertion is complete and the TextPane can be redisplayed.
|
|
* </p>
|
|
*/
|
|
public void displayNewApp()
|
|
{
|
|
int start = tp.getSelectionStart();
|
|
int len = tp.getSelectedText().length();
|
|
Style variant = tp.getStyle(TextPane.VARIANT);
|
|
tp.getStyledDocument().setCharacterAttributes(start,len,variant,false);
|
|
}
|
|
|
|
/**
|
|
* <p>
|
|
* This method displays all the variations of text titles found in a {@link TibDoc}. It takes the
|
|
* TibDoc's {@link TitleFactory} and uses its {@link TitleFactory#getAllTitles() getAllTitles} method
|
|
* to retrive a vector of {@link ElementStyle ElementStyles}. It also adds a text header at the top
|
|
* and depending on the {@link TiblEdit#mode mode} of the controller (i.e., whether it is inserting a
|
|
* new title or translation, etc.) adds appropriate prompts. It then calls the {@link TextPane#setTextPane(Vector) TextPane's setTextPane(Vector)}
|
|
* method with the vector of StyleElements and this displays the information. That setTextPane method
|
|
* returns an {@link ElementList} which is a list of org.jdom.Elements with their associated positions in
|
|
* the TextPane (start and end) so that when the caret is positioned somewhere in the TextPane the controller
|
|
* can find the associated element and make the appropriate options available.
|
|
* </p>
|
|
*
|
|
* @param tf TitleFactory - The TibDocs TitleFactory object for retrieving title information
|
|
*
|
|
* @return ElementList - The ElementList returned by the TextPane once its document is set.
|
|
*
|
|
*/
|
|
public ElementList showTitles(TitleFactory tf)
|
|
{
|
|
int presCaretPos = tp.getCaretPosition();
|
|
if(presCaretPos < 0) {presCaretPos = 0;}
|
|
|
|
styleElements = new Vector();
|
|
|
|
// Do the Text's Header Element as the documents general header
|
|
String[] headStrings = tf.getHeadStrings();
|
|
|
|
if(headStrings == null) {
|
|
|
|
styleElements.add(new ElementStyle("No Head Element Found\n\n",TextPane.TEXT_HEAD,NO_ELEM));
|
|
|
|
} else {
|
|
styleElements.add(new ElementStyle(headStrings[0]+" ",TextPane.TEXT_HEAD,NO_ELEM));
|
|
|
|
if(headStrings.length>1) {
|
|
for(int n=1;n<headStrings.length;n++) {
|
|
styleElements.add(new ElementStyle(headStrings[n]+"\n",TextPane.TEXT_HEAD_ITALIC,NO_ELEM));
|
|
}
|
|
styleElements.add(new ElementStyle("\n",TextPane.REG,NO_ELEM));
|
|
}
|
|
}
|
|
|
|
styleElements.addAll(tf.getAllTitles());
|
|
|
|
// Check to see if enterting translation
|
|
|
|
org.jdom.Element child, selEl;
|
|
String trans = new String();
|
|
selEl = controller.getSelectedElement();
|
|
|
|
// Get index of selected Element, adding 1 because label for insertion goes after.
|
|
int index = findElementStyleIndex(selEl)+1;
|
|
|
|
|
|
|
|
if(controller.getMode() == ENTER_TRANS) {
|
|
|
|
styleElements.add(index++,new ElementStyle(ENTER_TRANS_PHRASE,TextPane.BOLD,NO_ELEM));
|
|
child = selEl.getChild(FOREIGN);
|
|
if(child == null) {
|
|
child = new org.jdom.Element(FOREIGN);
|
|
child.setAttribute(LANG,ENG);
|
|
selEl.addContent(child);
|
|
}
|
|
trans = " " + TibDoc.cleanString(child.getText())+"\n";
|
|
styleElements.add(index,new ElementStyle(trans,TextPane.RED,child));
|
|
|
|
} else if(controller.getMode() == NEW_TITLE) {
|
|
|
|
styleElements.add(index++,new ElementStyle(ENTER_TITLE_PHRASE,TextPane.BOLD,NO_ELEM));
|
|
styleElements.add(index++,new ElementStyle(ENTER_PLACE,TextPane.RED,selEl));
|
|
|
|
} else if(controller.getMode() == ENTER_NORMALIZED) {
|
|
|
|
index -= 1;
|
|
if(index<0) {index = 0;}
|
|
styleElements.add(index,new ElementStyle(ENTER_NORMALIZED_PHRASE,TextPane.BOLD,NO_ELEM));
|
|
index += 4;
|
|
styleElements.add(index, new ElementStyle(ENTER_NORM_TRANS_PHRASE,TextPane.BOLD,NO_ELEM));
|
|
|
|
} else if(controller.getMode() == DO_TRANS) {
|
|
if(index == 0) {
|
|
index = findElementStyleIndex(selEl.getParent())+2;
|
|
styleElements.add(index++,new ElementStyle(ENTER_TRANS_PHRASE,TextPane.BOLD,NO_ELEM));
|
|
styleElements.add(index, new ElementStyle(" \n",TextPane.RED,selEl));
|
|
|
|
} else {
|
|
index -= 1;
|
|
styleElements.add(index,new ElementStyle(ENTER_TRANS_PHRASE,TextPane.BOLD,NO_ELEM));
|
|
}
|
|
|
|
}
|
|
// Convert Vectors to String arrays and send to TextPane for displaying
|
|
// Return the resulting element list
|
|
tp.removeMouseListener(controller);
|
|
tp.reset();
|
|
ElementList el = tp.setTextPane(styleElements);
|
|
|
|
if(controller.getMode()== NORM) {
|
|
//tp.setCaretPosition(0);
|
|
tp.addMouseListener(controller);
|
|
tp.setEditable(false);
|
|
tp.addCaretListener(this);
|
|
} else {
|
|
tp.removeCaretListener(this);
|
|
tp.addKeyListener(controller);
|
|
tp.setEditable(true);
|
|
}
|
|
|
|
/*try {
|
|
tp.setCaretPosition(presCaretPos);
|
|
} catch (IllegalArgumentException ia) {}
|
|
tp.getCaret().setVisible(true);*/
|
|
|
|
return el;
|
|
}
|
|
|
|
public void chooseEdition()
|
|
{
|
|
hideEditions();
|
|
tibTable = new TibTable(controller.getTibDoc().getIDFactory());
|
|
showTable(tibTable);
|
|
JOptionPane.showMessageDialog(this,DEL_EDS_MESS,DEL_EDS_TITLE,JOptionPane.INFORMATION_MESSAGE);
|
|
tibTable.getTable().addMouseListener(new MouseAdapter() {
|
|
public void mouseClicked(MouseEvent me) {
|
|
if(me.getClickCount() == 2) {
|
|
JTable theTable = tibTable.getTable();
|
|
int selRow = theTable.getSelectedRow();
|
|
String sigla = (String)theTable.getValueAt(selRow,0);
|
|
IDFactory idf = controller.getTibDoc().getIDFactory();
|
|
org.jdom.Element tibid = idf.findEdTibid(sigla);
|
|
controller.deleteEdition(tibid);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* <p>
|
|
* This method is used by {@link #showTitles(TitleFactory)} to insert prompts for information
|
|
* at the correct location. The showTitles method creates a vector of {@link ElementStyle}. Once
|
|
* this is created, if the {@link TiblEdit#mode} is to insert a title or translation. This method
|
|
* is called with the selected element. It searches the vector for that element and returns its
|
|
* index in the vector.
|
|
* </p>
|
|
*
|
|
* @param el org.jdom.Element - the selected element.
|
|
*
|
|
* @return int - that element's index in the ElementStyle Vector.
|
|
*/
|
|
private int findElementStyleIndex(org.jdom.Element el)
|
|
{
|
|
if(styleElements == null) {
|
|
System.out.println("No styleElements list to search in findElementStyleIndex of TibFrame");
|
|
return -1;
|
|
}
|
|
int index = -1;
|
|
Iterator it = styleElements.iterator();
|
|
while(it.hasNext())
|
|
{
|
|
Object item = it.next();
|
|
//System.out.println("It is: " + item.getClass().getName());
|
|
ElementStyle es = (ElementStyle)item;
|
|
if(es.getElement().equals(el)) { index = styleElements.indexOf(es);}
|
|
}
|
|
if(index == -1) {
|
|
//System.out.println("Element was not found: " + TiblEdit.outputString(el));
|
|
}
|
|
return index;
|
|
}
|
|
|
|
public DiscDialog getDiscussionDialog(TibDoc tibl)
|
|
{
|
|
DiscDialog dd = new DiscDialog(this, tibl);
|
|
return dd;
|
|
}
|
|
|
|
// Constructor
|
|
/**
|
|
* <p>
|
|
* This constructor simply takes a title as the corresponding JFrame contructor.
|
|
* </p>
|
|
*
|
|
* @param title String - the frame's title.
|
|
*/
|
|
public TibFrame(String title)
|
|
{
|
|
super(title);
|
|
init();
|
|
}
|
|
|
|
/**
|
|
* <p>
|
|
* This constructor takes both a title and a {@link TiblEdit} object that is its controller.
|
|
* It first calls JFrame's title constructor, then {@link #setController(TiblEdit) the setController} method
|
|
* and then the {@link #init()} method.
|
|
* </p>
|
|
*/
|
|
public TibFrame(String title, TiblEdit app)
|
|
{
|
|
super(title);
|
|
setController(app);
|
|
init();
|
|
}
|
|
|
|
// Main for testing
|
|
|
|
public static void main(String[] args)
|
|
{
|
|
}
|
|
|
|
// Listeners
|
|
/**
|
|
* <p>
|
|
* This implementation of the CaretListener interface calls the controller's
|
|
* {@link TiblEdit#checkCaretPosition(String) checkCaretPosition} method with the type of {@link TibConstants#AP AP}
|
|
* to see if an appartatus element is insertable. If so, then it turns on the insert variant reading
|
|
* menu item. If not, that item is turned off.
|
|
* </p>
|
|
*
|
|
* @param ce CaretEvent - the required parameter of this abstract method. It is not used here.
|
|
*/
|
|
public void caretUpdate(CaretEvent ce)
|
|
{
|
|
boolean canInsertAp = controller.checkCaretPosition(AP_CHECK);
|
|
if(canInsertAp) {
|
|
variantItem.setEnabled(true);
|
|
} else {
|
|
variantItem.setEnabled(false);
|
|
}
|
|
|
|
if(controller.checkCaretPosition(ED_TITLE_REM)) {
|
|
removeTitleItem.setEnabled(true);
|
|
} else {
|
|
removeTitleItem.setEnabled(false);
|
|
}
|
|
}
|
|
|
|
// SubClasses Event Handlers
|
|
/**
|
|
* <p>
|
|
* The inner class, XWindowHandler, extends the WindowAdapter and is used for the closing of the frame.
|
|
* It is added to the TibFrame in its {@link #init} method.
|
|
* </p>
|
|
*/
|
|
|
|
/**
|
|
* <p>
|
|
* When the TibFrame is closed, the program ends. The window is disposed. The controller's
|
|
* {@link TiblEdit#exit() exit()} method is called, and the system is exited.
|
|
* </p>
|
|
*/
|
|
public class XWindowHandler extends WindowAdapter
|
|
implements TibConstants
|
|
{
|
|
|
|
/** See class comment.
|
|
*
|
|
* @param e WindowEvent - the required parameter for this abstract method.
|
|
*/
|
|
public void windowClosing(WindowEvent e)
|
|
{
|
|
e.getWindow().dispose();
|
|
controller.exit();
|
|
}
|
|
}
|
|
public class XComponentHandler extends ComponentAdapter
|
|
{
|
|
|
|
public void ComponentResized(ComponentEvent ce)
|
|
{
|
|
show();
|
|
}
|
|
}
|
|
|
|
|
|
}
|