@Override
public void valueChanged(TreeSelectionEvent e) {
if (LOG.isLoggable(Level.FINER)) {
LOG.finer("TreeSelectionEvent: " + e.toString());
}
// Stop editing the table, if editing is currently in progress
if (groupTable.getCellEditor() != null) {
groupTable.getCellEditor().stopCellEditing();
}
InitTableModel tableModel = groupTable.getActorTableModel();
if (groupTree.getLastSelectedPathComponent() != null) {
if (LOG.isLoggable(Level.FINER)) {
LOG.finer("Current Selection: " + groupTree.getLastSelectedPathComponent().toString());
}
GroupTreeNode node = (GroupTreeNode) groupTree.getLastSelectedPathComponent();
if (node.isGroup()) { // If current selection is a group, display the actors
tableModel.setActorList(node.getActorList());
groupTable.setVisible(true);
} else { // Otherwise don't show any actors
groupTable.setVisible(false);
tableModel.setActorList(null);
}
} else {
if (LOG.isLoggable(Level.FINER)) {
LOG.finer("Current Selection: null");
}
groupTable.setVisible(false);
tableModel.setActorList(null);
}
}
/**
* @param subtree The root node of the subtree that was modified (this node may not be modified,
* it is just used as a convenience handle).
*/
public UndoableModifySubtree(
GroupSelector groupSelector, GroupTreeNode groupRoot, GroupTreeNode subtree, String name) {
m_subtreeBackup = subtree.deepCopy();
m_groupRoot = groupRoot;
m_subtreeRootPath = subtree.getIndexedPath();
m_groupSelector = groupSelector;
m_name = name;
}
/**
* @param node The node which still contains the old group.
* @param newGroup The new group to replace the one currently stored in <b>node </b>.
*/
public UndoableModifyGroup(
GroupSelector gs, GroupTreeNode groupsRoot, GroupTreeNode node, AbstractGroup newGroup) {
m_groupSelector = gs;
m_oldGroupBackup = node.getGroup().deepCopy();
m_newGroupBackup = newGroup.deepCopy();
m_pathToNode = node.getIndexedPath();
m_groupsRootHandle = groupsRoot;
}
@Override
public void redo() {
super.redo();
final GroupTreeNode subtreeRoot = m_groupRoot.getNode(m_subtreeRootPath);
subtreeRoot.removeAllChildren();
for (int i = 0; i < m_modifiedSubtree.size(); ++i) {
subtreeRoot.add((GroupTreeNode) m_modifiedSubtree.elementAt(i));
}
if (m_revalidate) {
m_groupSelector.revalidateGroups();
}
}
@Override
public void redo() {
super.redo();
GroupTreeNode treeNode = mGroupsRootHandle.getChildAt(mPathToNode);
if (treeNode != null) {
ExplicitGroup group = (ExplicitGroup) treeNode.getGroup();
group.clearAssignments();
for (final BibEntry aM_newAssignmentBackup : m_newAssignmentBackup) {
group.addEntry(aM_newAssignmentBackup);
}
}
}
@Override
public void redo() {
super.redo();
ExplicitGroup group = (ExplicitGroup) m_groupsRootHandle.getChildAt(m_pathToNode).getGroup();
group.clearAssignments();
for (BibtexEntry aM_newAssignmentBackup : m_newAssignmentBackup) {
group.addEntry(aM_newAssignmentBackup);
}
}
/** @param move For add: if true, remove from previous groups */
private void insertNodes(
JMenu menu, GroupTreeNode node, BibtexEntry[] selection, boolean add, boolean move) {
final AbstractAction action = getAction(node, selection, add, move);
if (node.getChildCount() == 0) {
JMenuItem menuItem = new JMenuItem(action);
setGroupFontAndIcon(menuItem, node.getGroup());
menu.add(menuItem);
if (action.isEnabled()) {
menu.setEnabled(true);
}
return;
}
JMenu submenu;
if (node.getGroup() instanceof AllEntriesGroup) {
for (int i = 0; i < node.getChildCount(); ++i) {
insertNodes(menu, (GroupTreeNode) node.getChildAt(i), selection, add, move);
}
} else {
submenu = new JMenu('[' + node.getGroup().getName() + ']');
setGroupFontAndIcon(submenu, node.getGroup());
// setEnabled(true) is done above/below if at least one menu
// entry (item or submenu) is enabled
submenu.setEnabled(action.isEnabled());
JMenuItem menuItem = new JMenuItem(action);
setGroupFontAndIcon(menuItem, node.getGroup());
submenu.add(menuItem);
submenu.add(new Separator());
for (int i = 0; i < node.getChildCount(); ++i) {
insertNodes(submenu, (GroupTreeNode) node.getChildAt(i), selection, add, move);
}
menu.add(submenu);
if (submenu.isEnabled()) {
menu.setEnabled(true);
}
}
}
/**
* Import a GCA4 character file
*
* @param file - the file to load from. Open File dialog used if file is null.
* @return whether the load was completed successfully.
*/
public boolean importGCA4File(File file) {
if (file == null) {
if (LOG.isLoggable(Level.WARNING)) {
LOG.warning("Given null file!");
}
return false;
}
if (LOG.isLoggable(Level.FINE)) {
LOG.fine("Opening file: " + file.getName());
}
Actor importedActor;
try {
importedActor = GCAImporter.importActor(file);
} catch (FileNotFoundException e) {
if (LOG.isLoggable(Level.SEVERE)) {
LOG.log(Level.SEVERE, e.getMessage(), e);
}
return false;
}
// Check if there is no valid selected group currently
if (groupTable.getActorTableModel().getRowCount() == 0) {
if (LOG.isLoggable(Level.FINE)) {
LOG.fine("Creating new group to hold imported actor!");
}
GroupTreeNode newGroup = groupTree.addNode("GCA4 Import", true);
TreePath groupPath = new TreePath(newGroup.getPath());
groupTree.getSelectionModel().setSelectionPath(groupPath);
}
if (LOG.isLoggable(Level.FINE)) {
LOG.fine("Adding imported actor to currently selected group");
}
groupTable
.getActorTableModel()
.addActor(importedActor, groupTable.getActorTableModel().getRowCount() - 1);
return true;
}
/** @param move For add: if true, remove from all previous groups */
private AbstractAction getAction(
GroupTreeNode node, BibtexEntry[] selection, boolean add, boolean move) {
AbstractAction action =
add ? new AddToGroupAction(node, move, panel) : new RemoveFromGroupAction(node, panel);
AbstractGroup group = node.getGroup();
if (!move) {
action.setEnabled(
add
? group.supportsAdd() && !group.containsAll(selection)
: group.supportsRemove() && group.containsAny(selection));
} else {
action.setEnabled(group.supportsAdd());
}
return action;
}
@Override
public void undo() {
super.undo();
// remember modified children for redo
m_modifiedSubtree.clear();
// get node to edit
final GroupTreeNode subtreeRoot = m_groupRoot.getNode(m_subtreeRootPath);
for (int i = 0; i < subtreeRoot.getChildCount(); ++i) {
m_modifiedSubtree.add(subtreeRoot.getChildAt(i));
}
// keep subtree handle, but restore everything else from backup
subtreeRoot.removeAllChildren();
for (int i = 0; i < m_subtreeBackup.getChildCount(); ++i) {
subtreeRoot.add(((GroupTreeNode) m_subtreeBackup.getChildAt(i)).deepCopy());
}
if (m_revalidate) {
m_groupSelector.revalidateGroups();
}
}
public void redo() {
super.redo();
m_groupsRootHandle.getDescendant(m_pathToNode).setGroup(m_newGroupBackup.deepCopy());
m_groupSelector.revalidateGroups();
}
@Override
public void actionPerformed(ActionEvent evt) {
final BibtexEntry[] entries = m_panel.getSelectedEntries();
final Vector<GroupTreeNode> removeGroupsNodes =
new Vector<GroupTreeNode>(); // used only when moving
if (m_move) {
// collect warnings for removal
Enumeration<GroupTreeNode> e = ((GroupTreeNode) m_node.getRoot()).preorderEnumeration();
GroupTreeNode node;
while (e.hasMoreElements()) {
node = e.nextElement();
if (!node.getGroup().supportsRemove()) {
continue;
}
for (BibtexEntry entry : entries) {
if (node.getGroup().contains(entry)) {
removeGroupsNodes.add(node);
}
}
}
// warning for all groups from which the entries are removed, and
// for the one to which they are added! hence the magical +1
AbstractGroup[] groups = new AbstractGroup[removeGroupsNodes.size() + 1];
for (int i = 0; i < removeGroupsNodes.size(); ++i) {
groups[i] = removeGroupsNodes.elementAt(i).getGroup();
}
groups[groups.length - 1] = m_node.getGroup();
if (!Util.warnAssignmentSideEffects(
groups, entries, m_panel.getDatabase(), m_panel.frame())) {
return; // user aborted operation
}
} else {
// warn if assignment has undesired side effects (modifies a field != keywords)
if (!Util.warnAssignmentSideEffects(
new AbstractGroup[] {m_node.getGroup()},
entries,
m_panel.getDatabase(),
m_panel.frame())) {
return; // user aborted operation
}
}
// if an editor is showing, its fields must be updated
// after the assignment, and before that, the current
// edit has to be stored:
m_panel.storeCurrentEdit();
NamedCompound undoAll = new NamedCompound(Globals.lang("change assignment of entries"));
if (m_move) {
// first remove
for (int i = 0; i < removeGroupsNodes.size(); ++i) {
GroupTreeNode node = removeGroupsNodes.elementAt(i);
if (node.getGroup().containsAny(entries)) {
undoAll.addEdit(node.removeFromGroup(entries));
}
}
// then add
AbstractUndoableEdit undoAdd = m_node.addToGroup(entries);
if (undoAdd != null) {
undoAll.addEdit(undoAdd);
}
} else {
AbstractUndoableEdit undoAdd = m_node.addToGroup(entries);
if (undoAdd == null) {
return; // no changed made
}
undoAll.addEdit(undoAdd);
}
undoAll.end();
m_panel.undoManager.addEdit(undoAll);
m_panel.markBaseChanged();
m_panel.updateEntryEditorIfShowing();
m_panel.getGroupSelector().valueChanged(null);
}
/** @param move If true, remove node from all other groups. */
public AddToGroupAction(GroupTreeNode node, boolean move, BasePanel panel) {
super(node.getGroup().getName());
m_node = node;
m_move = move;
m_panel = panel;
}
/**
* Sets the node of the group that was edited. If this node was not specified at construction
* time, this method has to be called before this instance may be used.
*
* @param node The node whose assignments were edited.
*/
public void setEditedNode(GroupTreeNode node) {
m_groupsRootHandle = (GroupTreeNode) node.getRoot();
m_pathToNode = node.getIndexedPath();
}
