private int compare(DefaultMutableTreeNode node1, DefaultMutableTreeNode node2) {
SearchTOCItem item1, item2;
double confidence1, confidence2;
int hits1, hits2;
item1 = (SearchTOCItem) node1.getUserObject();
confidence1 = item1.getConfidence();
hits1 = item1.hitCount();
item2 = (SearchTOCItem) node2.getUserObject();
confidence2 = item2.getConfidence();
hits2 = item2.hitCount();
// confidence is a penality. The lower the better
if (confidence1 > confidence2) {
// node1 is less than node2
return -1;
} else if (confidence1 < confidence2) {
// node1 is greater than node2
return 1;
} else {
// confidences are the same check the hits
if (hits1 < hits2) {
// node1 is less than node2
return -1;
} else if (hits1 > hits2) {
// node2 is greater than node2
return 1;
}
}
// nodes1 and nodes2 are equivalent
return 0;
}
@Override
public void treeNodesChanged(TreeModelEvent e) {
if (adjusting) {
return;
}
adjusting = true;
TreePath parent = e.getTreePath();
Object[] children = e.getChildren();
DefaultTreeModel model = (DefaultTreeModel) e.getSource();
DefaultMutableTreeNode node;
CheckBoxNode c; // = (CheckBoxNode)node.getUserObject();
if (children != null && children.length == 1) {
node = (DefaultMutableTreeNode) children[0];
c = (CheckBoxNode) node.getUserObject();
onCheckboxStatusChanged(node);
DefaultMutableTreeNode n = (DefaultMutableTreeNode) parent.getLastPathComponent();
while (n != null) {
updateParentUserObject(n);
DefaultMutableTreeNode tmp = (DefaultMutableTreeNode) n.getParent();
if (tmp == null) {
break;
} else {
n = tmp;
}
}
model.nodeChanged(n);
} else {
node = (DefaultMutableTreeNode) model.getRoot();
c = (CheckBoxNode) node.getUserObject();
}
updateAllChildrenUserObject(node, c.status);
model.nodeChanged(node);
adjusting = false;
}
private void updateParentUserObject(DefaultMutableTreeNode parent) {
String label = ((CheckBoxNode) parent.getUserObject()).label;
int selectedCount = 0;
int indeterminateCount = 0;
Enumeration children = parent.children();
while (children.hasMoreElements()) {
DefaultMutableTreeNode node = (DefaultMutableTreeNode) children.nextElement();
CheckBoxNode check = (CheckBoxNode) node.getUserObject();
if (check.status == Status.INDETERMINATE) {
indeterminateCount++;
break;
}
if (check.status == Status.SELECTED) {
selectedCount++;
}
}
onCheckboxStatusChanged(parent);
if (indeterminateCount > 0) {
parent.setUserObject(new CheckBoxNode(label));
} else if (selectedCount == 0) {
parent.setUserObject(new CheckBoxNode(label, Status.DESELECTED));
} else if (selectedCount == parent.getChildCount()) {
parent.setUserObject(new CheckBoxNode(label, Status.SELECTED));
} else {
parent.setUserObject(new CheckBoxNode(label));
}
}
/**
* get the children of this group in the tree (recursive call)
*
* @param root of the tree
* @return a list of the children of the group or null if no children (to be initialized by
* caller)
*/
public ArrayList<PDLGroup> getChildren(DefaultMutableTreeNode root, ArrayList<PDLGroup> list) {
PDLGroup rootGroup = (PDLGroup) root.getUserObject();
String rootGroupName = rootGroup.getName();
if (this.name.equals(rootGroupName)) {
@SuppressWarnings("rawtypes")
Enumeration children = root.children();
while (children.hasMoreElements()) {
DefaultMutableTreeNode child = (DefaultMutableTreeNode) children.nextElement();
list.add((PDLGroup) child.getUserObject());
}
return list;
} else {
@SuppressWarnings("rawtypes")
Enumeration children = root.children();
if (children != null) {
while (children.hasMoreElements()) {
ArrayList<PDLGroup> l =
getChildren((DefaultMutableTreeNode) children.nextElement(), list);
if (l != null) return l;
}
}
}
return null;
}
private static DefaultMutableTreeNode findMatchedChild(
DefaultMutableTreeNode parent, PathElement pathElement) {
for (int j = 0; j < parent.getChildCount(); j++) {
final TreeNode child = parent.getChildAt(j);
if (!(child instanceof DefaultMutableTreeNode)) continue;
final DefaultMutableTreeNode childNode = (DefaultMutableTreeNode) child;
final Object userObject = childNode.getUserObject();
if (pathElement.matchedWithByObject(userObject)) return childNode;
}
for (int j = 0; j < parent.getChildCount(); j++) {
final TreeNode child = parent.getChildAt(j);
if (!(child instanceof DefaultMutableTreeNode)) continue;
final DefaultMutableTreeNode childNode = (DefaultMutableTreeNode) child;
final Object userObject = childNode.getUserObject();
if (!(userObject instanceof NodeDescriptor)) continue;
final NodeDescriptor nodeDescriptor = (NodeDescriptor) userObject;
if (pathElement.matchedWith(nodeDescriptor)) return childNode;
}
if (parent.getChildCount() > 0) {
int index = pathElement.myItemIndex;
if (index >= parent.getChildCount()) {
index = parent.getChildCount() - 1;
}
final TreeNode child = parent.getChildAt(index);
if (child instanceof DefaultMutableTreeNode) {
return (DefaultMutableTreeNode) child;
}
}
return null;
}
@Override
public String convertValueToText(
Object value, boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus) {
String s = super.convertValueToText(value, selected, expanded, leaf, row, hasFocus);
String newProp = jEdit.getProperty(HIGHLIGHT_PROP);
if (newProp == null || newProp.isEmpty()) return s;
DefaultMutableTreeNode node = (DefaultMutableTreeNode) value;
while (node != null && !(node.getUserObject() instanceof HyperSearchOperationNode)) {
node = (DefaultMutableTreeNode) node.getParent();
}
if (node == null) return s;
if (!newProp.equals(prop)) {
prop = newProp;
Font f = (resultTree != null) ? resultTree.getFont() : UIManager.getFont("Tree.font");
styleTag = HtmlUtilities.style2html(prop, f);
}
SearchMatcher matcher = ((HyperSearchOperationNode) node.getUserObject()).getSearchMatcher();
int i = s.indexOf(": ");
if (i > 0) i += 2;
else i = 0;
Match m;
List<Integer> matches = new ArrayList<Integer>();
while ((m = matcher.nextMatch(s.substring(i), true, true, true, false)) != null) {
matches.add(i + m.start);
matches.add(i + m.end);
i += m.end;
}
return HtmlUtilities.highlightString(s, styleTag, matches);
}
/**
* Remove this node from the model.
*
* @param node
* @param model
*/
private void removeFromModel(DefaultMutableTreeNode node, DefaultTreeModel model) {
model.removeNodeFromParent(node);
nodeTable.remove(node.getUserObject());
// remove the type branch if there are no more children
switch (treeMode) {
case TYPE:
String typeString = ((GeoElement) node.getUserObject()).getObjectType();
DefaultMutableTreeNode parent = (DefaultMutableTreeNode) typeNodesMap.get(typeString);
// this has been the last node
if (parent.getChildCount() == 0) {
typeNodesMap.remove(typeString);
model.removeNodeFromParent(parent);
}
break;
case LAYER:
int layer = ((GeoElement) node.getUserObject()).getLayer();
parent = (DefaultMutableTreeNode) layerNodesMap.get(layer);
// this has been the last node
if (parent.getChildCount() == 0) {
layerNodesMap.remove(layer);
model.removeNodeFromParent(parent);
}
break;
}
}
/**
* Gets the insert position for newGeo to insert it in alphabetical order in parent node. Note:
* all children of parent must have instances of GeoElement as user objects.
*
* @param mode
*/
public static final int getInsertPosition(
DefaultMutableTreeNode parent, GeoElement newGeo, SortMode mode) {
// label of inserted geo
// String newLabel = newGeo.getLabel();
// standard case: binary search
int left = 0;
int right = parent.getChildCount();
if (right == 0) return right;
// bigger then last?
DefaultMutableTreeNode node = (DefaultMutableTreeNode) parent.getLastChild();
// String nodeLabel = ((GeoElement) node.getUserObject()).getLabel();
GeoElement geo2 = ((GeoElement) node.getUserObject());
if (compare(newGeo, geo2, mode)) return right;
// binary search
while (right > left) {
int middle = (left + right) / 2;
node = (DefaultMutableTreeNode) parent.getChildAt(middle);
// nodeLabel = ((GeoElement) node.getUserObject()).getLabel();
geo2 = ((GeoElement) node.getUserObject());
if (!compare(newGeo, geo2, mode)) {
right = middle;
} else {
left = middle + 1;
}
}
// insert at correct position
return right;
}
private void jTree1MouseClicked1(
java.awt.event.MouseEvent evt) { // GEN-FIRST:event_jTree1MouseClicked1
if (evt.getClickCount() == 2 && evt.getButton() == evt.BUTTON1) {
DefaultMutableTreeNode tn =
(DefaultMutableTreeNode) jTree1.getSelectionPath().getLastPathComponent();
if (tn.getChildCount() > 0) return;
/*if (!jTree1.isCollapsed( jTree1.getSelectionPath() ))
{
jTree1.collapsePath( jTree1.getSelectionPath() );
return;
}
*
*/
if (tn.getUserObject() instanceof TreeJRField) {
TreeJRField jrf = (TreeJRField) tn.getUserObject();
if (!jrf.getObj().isPrimitive() && !jrf.getObj().getName().startsWith("java.lang.")) {
exploreBean(
tn,
jrf.getObj().getName(),
isPathOnDescription()
? Misc.nvl(jrf.getField().getDescription(), "")
: Misc.nvl(jrf.getField().getName(), ""));
}
}
}
} // GEN-LAST:event_jTree1MouseClicked1
private ArrayList<?> updateSelectedGeos(TreePath[] selPath) {
selectionList.clear();
if (selPath != null) {
// add all selected paths
for (int i = 0; i < selPath.length; i++) {
DefaultMutableTreeNode node = (DefaultMutableTreeNode) selPath[i].getLastPathComponent();
if (node == node.getRoot()) {
// root: add all objects
selectionList.clear();
selectionList.addAll(app.getKernel().getConstruction().getGeoSetLabelOrder());
i = selPath.length;
} else if (node.getParent() == node.getRoot()) {
// type node: select all children
for (int k = 0; k < node.getChildCount(); k++) {
DefaultMutableTreeNode child = (DefaultMutableTreeNode) node.getChildAt(k);
selectionList.add(child.getUserObject());
}
} else {
// GeoElement
selectionList.add(node.getUserObject());
}
}
}
return selectionList;
}
/**
* Copies all the mod files from the profileModDir to the factorioModDir.
*
* @param profileModDir The profileDir to copy mods from.
* @param factorioModDir The factorioDir to copy mods to.
* @param selectedNode The TreeNode that is currently selected.
*/
private void copyAllEnabledMods(
File profileModDir, File factorioModDir, DefaultMutableTreeNode selectedNode) {
// Let's copy all enabled mods!
// Get the selected node.
Enumeration<DefaultMutableTreeNode> children = selectedNode.children(); // Get it's children.
while (children.hasMoreElements()) {
DefaultMutableTreeNode node = children.nextElement(); // Get the next element.
ModManagerWindow.CheckBoxNode checkBox =
(ModManagerWindow.CheckBoxNode) node.getUserObject(); // Get the checkbox.
String name = checkBox.getText(); // Get the text from the checkbox.
if (name.equals("base") || !checkBox.isSelected())
continue; // If it is the "base" mod, ignore it (it's always on)
// Get the file with the name of the mod and then copy it from the profile dir to the mods
// dir.
File file =
FileUtils.findFileWithPartName(
profileModDir, ((ModManagerWindow.CheckBoxNode) node.getUserObject()).getText());
try {
Files.copy(
file.toPath(),
Paths.get(
factorioModDir.getPath()
+ "/"
+ file.getPath().substring(file.getPath().lastIndexOf('\\'))));
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* Scroll to the error specified by the given tree path, or do nothing if no error is specified.
*
* @param treePath the tree path to scroll to.
*/
private void scrollToError(final TreePath treePath) {
final DefaultMutableTreeNode treeNode =
(DefaultMutableTreeNode) treePath.getLastPathComponent();
if (treeNode == null || !(treeNode.getUserObject() instanceof ResultTreeNode)) {
return;
}
final ResultTreeNode nodeInfo = (ResultTreeNode) treeNode.getUserObject();
if (nodeInfo.getFile() == null || nodeInfo.getProblem() == null) {
return; // no problem here :-)
}
final VirtualFile virtualFile = nodeInfo.getFile().getVirtualFile();
if (virtualFile == null || !virtualFile.exists()) {
return;
}
final FileEditorManager fileEditorManager = FileEditorManager.getInstance(project);
final FileEditor[] editor = fileEditorManager.openFile(virtualFile, true);
if (editor.length > 0 && editor[0] instanceof TextEditor) {
final LogicalPosition problemPos =
new LogicalPosition(Math.max(lineFor(nodeInfo) - 1, 0), Math.max(columnFor(nodeInfo), 0));
final Editor textEditor = ((TextEditor) editor[0]).getEditor();
textEditor.getCaretModel().moveToLogicalPosition(problemPos);
textEditor.getScrollingModel().scrollToCaret(ScrollType.CENTER);
}
}
/*
* Adds a field to the format being composed
*/
public void addField() {
DefaultMutableTreeNode node =
(DefaultMutableTreeNode) availableFieldsComp.getTree().getLastSelectedPathComponent();
if (node == null
|| !node.isLeaf()
|| !(node.getUserObject() instanceof DataObjDataFieldWrapper)) {
return; // not really a field that can be added, just empty or a string
}
Object obj = node.getUserObject();
if (obj instanceof DataObjDataFieldWrapper) {
DataObjDataFieldWrapper wrapper = (DataObjDataFieldWrapper) obj;
String sep = sepText.getText();
if (StringUtils.isNotEmpty(sep)) {
try {
DefaultStyledDocument doc = (DefaultStyledDocument) formatEditor.getStyledDocument();
if (doc.getLength() > 0) {
doc.insertString(doc.getLength(), sep, null);
}
} catch (BadLocationException ble) {
}
}
insertFieldIntoTextEditor(wrapper);
setHasChanged(true);
}
}
/**
* Restore opened settings node if still there.
*
* @param oldProps properties inserted in the old model
* @param selPath path to the node selected in the old model
*/
private void restoreInsertedProperties(HashMap<String, Property[]> oldProps, TreePath selPath) {
DefaultTreeModel newModel = levelTrees.get(permissionLvl);
// Create properties panel for every properties panel existing in the old model
updateUsedPanels(oldProps, newModel);
final JPanel holderPropertiesPanel = (JPanel) splitPane.getRightComponent();
holderPropertiesPanel.removeAll();
if (selPath != null) {
// returns node from previous model
DefaultMutableTreeNode selectedNode = (DefaultMutableTreeNode) selPath.getLastPathComponent();
if (selectedNode.getUserObject() instanceof ClassPropertiesInfo) {
// find selected class by name
ClassPropertiesInfo selectedClassInfo = (ClassPropertiesInfo) selectedNode.getUserObject();
String selectedClassInfoName = selectedClassInfo.getName();
// see if it's still visible
DefaultMutableTreeNode classNode;
ClassPropertiesInfo classInfo;
DefaultMutableTreeNode root = (DefaultMutableTreeNode) newModel.getRoot();
int classCount = newModel.getChildCount(root);
for (int c = 0; c < classCount; c++) {
classNode = (DefaultMutableTreeNode) newModel.getChild(root, c);
classInfo = (ClassPropertiesInfo) classNode.getUserObject();
if (classInfo.getName().equalsIgnoreCase(selectedClassInfoName)) {
tree.setSelectionPath(new TreePath(classNode.getPath()));
c = classCount;
}
}
}
}
holderPropertiesPanel.repaint();
}
@Override
public Component getTreeCellRendererComponent(
final JTree tree,
final Object value,
final boolean selected,
final boolean expanded,
final boolean leaf,
final int row,
final boolean hasFocus) {
final LigandTreeCellRenderer component =
(LigandTreeCellRenderer)
super.getTreeCellRendererComponent(
tree, value, selected, expanded, leaf, row, hasFocus);
ImageIcon imageIcon = null;
DefaultMutableTreeNode node = (DefaultMutableTreeNode) value;
if (node.getUserObject() instanceof String) imageIcon = chainIcon; // top level are strings
else if (node.getUserObject() instanceof Chain)
imageIcon = residueIcon; // for BIRD chains, use residue icon.
else if (node.getUserObject() instanceof Residue) imageIcon = residueIcon;
setIcon(imageIcon);
return component;
}
@Override
public Component getTreeCellRendererComponent(
JTree tree,
Object value,
boolean sel,
boolean expanded,
boolean leaf,
int row,
boolean hasFocus) {
super.getTreeCellRendererComponent(tree, value, sel, expanded, leaf, row, hasFocus);
DefaultMutableTreeNode node = (DefaultMutableTreeNode) value;
if (node.getUserObject() != null) {
ComponentWrapper userObject = (ComponentWrapper) node.getUserObject();
if (userObject != null) {
Component c = userObject.component;
for (int i = 0; i < cmpClasses.length; i++) {
Class clazz = cmpClasses[i];
if (clazz.isAssignableFrom(c.getClass())) {
setIcon(cmpIcons[i]);
return this;
}
}
}
setIcon(noneIcon);
}
return this;
}
@Override
protected String validateAction() {
String validate = null;
DefaultMutableTreeNode node =
(DefaultMutableTreeNode) tree.getSelectionPath().getLastPathComponent();
BOMLineWrapper line = null;
if (!(node.getUserObject() instanceof BOMLineWrapper)) {
validate =
"'"
+ node.getUserObject().getClass().getName()
+ "' isn't a type of 'BOMLineWrapper'(ClassCastException)";
} else {
line = (BOMLineWrapper) node.getUserObject();
MProduct p = new MProduct(Env.getCtx(), line.getM_Product_ID(), null);
if (p.getM_AttributeSet_ID() == 0) {
validate = Services.get(IMsgBL.class).getMsg(Env.getCtx(), "PAttributeNoAttributeSet");
}
}
return validate;
}
/** Gets the value for the given node at the given column. */
public Object getValueAt(Object node, int col) {
DefaultMutableTreeNode tree_node = (DefaultMutableTreeNode) node;
Object value = tree_node.getUserObject();
switch (col) {
// Name
case 0:
return value;
// Value
case 1:
if (value instanceof ConfigElement) {
return null;
} else if (value instanceof PropertyDefinition) {
// Only provide comma delimited editing for simple types
if (((PropertyDefinition) value).getType() != ConfigElement.class) {
StringBuffer buffer = new StringBuffer();
for (Enumeration e = tree_node.children(); e.hasMoreElements(); ) {
DefaultMutableTreeNode child_node = (DefaultMutableTreeNode) e.nextElement();
buffer.append(child_node.getUserObject());
if (e.hasMoreElements()) {
buffer.append(", ");
}
}
return buffer.toString();
}
return null;
}
return value;
}
return null;
}
/**
* This gets called whenever one of the ConfigElements we are editing removes a property value.
*/
public void propertyValueRemoved(ConfigElementEvent evt) {
ConfigElement src = (ConfigElement) evt.getSource();
int idx = evt.getIndex();
PropertyDefinition prop_def = src.getDefinition().getPropertyDefinition(evt.getProperty());
DefaultMutableTreeNode elt_node = getNodeFor(src);
// Get the node containing the property description under the source
// ConfigElement node
for (Enumeration e = elt_node.children(); e.hasMoreElements(); ) {
DefaultMutableTreeNode node = (DefaultMutableTreeNode) e.nextElement();
if (node.getUserObject().equals(prop_def)) {
// The newly removed property value must be a child to this node
System.out.println("Removing child " + idx + " from node: " + node.getUserObject());
DefaultMutableTreeNode child = (DefaultMutableTreeNode) node.getChildAt(idx);
// If the child is an embedded element, stop listening to it
if (child.getUserObject() instanceof ConfigElement) {
ConfigElement removed_elt = (ConfigElement) child.getUserObject();
removed_elt.removeConfigElementListener(this);
}
// Physically remove the child from the tree
removeNodeFromParent(child);
}
}
}
void onOK() {
TreePath path = m_tree.getSelectionPath();
if (path == null) {
JOptionPane.showMessageDialog(this, "Departement not yet been selected");
return;
}
DefaultMutableTreeNode node = (DefaultMutableTreeNode) path.getLastPathComponent();
if (!m_isroot) {
if (node.getChildCount() > 0) return;
if (node.getUserObject() instanceof Organization) {
m_org = (Organization) node.getUserObject();
m_iResponse = JOptionPane.OK_OPTION;
dispose();
}
} else {
if (node.getUserObject() instanceof Organization) {
m_org = (Organization) node.getUserObject();
m_iResponse = JOptionPane.OK_OPTION;
dispose();
} else {
m_org = new Organization("", "", "Department");
m_iResponse = JOptionPane.OK_OPTION;
dispose();
}
}
}
private void createPainToTree3true(
final DefaultTreeModel treeModel, DefaultMutableTreeNode root, Collection paintCollection) {
ArrayList a = (ArrayList) paintCollection;
Iterator i = a.iterator();
Person p = null;
Person parent = null;
DefaultMutableTreeNode parentNode = root;
DefaultMutableTreeNode newNode;
while (i.hasNext()) {
p = (Person) i.next();
int ves, ves2;
if (parent != null) {
parent = (Person) parentNode.getUserObject();
ves = comparePerson(p, (Person) parentNode.getUserObject());
ves2 = comparePersonAsString(p, (Person) parentNode.getUserObject()) + 1;
System.out.println("ves = " + ves + " ves2= " + ves2);
switch (ves) {
case 0:
{
parentNode = root;
parent = null;
break;
}
case 1:
{
}
}
}
newNode = new DefaultMutableTreeNode(p);
parentNode.add(newNode);
parent = p;
parentNode = newNode;
}
}
@Override
public void dragGestureRecognized(DragGestureEvent event) {
TreePath path = tree.getSelectionPath();
if (path != null) {
// Dragged node is a DefaultMutableTreeNode
if (path.getLastPathComponent() instanceof DefaultMutableTreeNode) {
DefaultMutableTreeNode treeNode = (DefaultMutableTreeNode) path.getLastPathComponent();
// This is an ObjectType node
if (treeNode.getUserObject() instanceof ObjectType) {
ObjectType type = (ObjectType) treeNode.getUserObject();
Cursor cursor = null;
if (event.getDragAction() == DnDConstants.ACTION_COPY) {
cursor = DragSource.DefaultCopyDrop;
}
if (RenderManager.isGood()) {
// The new renderer is initialized
RenderManager.inst().startDragAndDrop(type);
event.startDrag(cursor, new TransferableObjectType(type), RenderManager.inst());
} else {
event.startDrag(cursor, new TransferableObjectType(type));
}
}
}
}
}
@Nullable
private static String getActionId(DefaultMutableTreeNode node) {
return (String)
(node.getUserObject() instanceof String
? node.getUserObject()
: node.getUserObject() instanceof Pair ? ((Pair) node.getUserObject()).first : null);
}
public int createTreeFromMenuBar(
javax.swing.MenuElement subElements[],
javax.swing.tree.DefaultMutableTreeNode treeNodes,
javax.swing.tree.DefaultMutableTreeNode topReports,
java.lang.String reportNodeTitle,
java.lang.String utilitiesNodeTitle) {
for (int i = 0; i < subElements.length; i++) {
if (subElements[i].getClass().getName() != "javax.swing.JPopupMenu") {
javax.swing.JMenuItem abstractButton = (javax.swing.JMenuItem) subElements[i];
if (abstractButton.isEnabled()) {
siblingNode = new javax.swing.tree.DefaultMutableTreeNode(abstractButton.getText());
treeNodes.add(siblingNode);
if (treeNodes.getUserObject() == "Reports") {
treeNodes.setUserObject(reportNodeTitle);
topReports.add(treeNodes);
}
if (treeNodes.getUserObject() == "Utility") {
treeNodes.setUserObject(utilitiesNodeTitle);
topReports.add(treeNodes);
}
}
}
if (subElements[i].getSubElements().length > 0) {
createTreeFromMenuBar(
subElements[i].getSubElements(),
siblingNode,
topReports,
reportNodeTitle,
utilitiesNodeTitle);
if (treeNodes.isLeaf()) {
javax.swing.tree.DefaultMutableTreeNode parentNode =
(javax.swing.tree.DefaultMutableTreeNode) siblingNode.getParent();
siblingNode.removeFromParent();
}
}
treeCount++;
}
return treeCount;
}
public void drop(DropTargetDropEvent dtde) {
Point pt = dtde.getLocation();
DropTargetContext dtc = dtde.getDropTargetContext();
JTree tree = (JTree) dtc.getComponent();
TreePath parentpath = tree.getClosestPathForLocation(pt.x, pt.y);
DefaultMutableTreeNode parent = (DefaultMutableTreeNode) parentpath.getLastPathComponent();
try {
// Transferable tr = dtde.getTransferable(); // !!! this should work, but doesn't. after one
// click on the draggable node, this call here will not return the TransferableTreeNode that
// is created in dragGestureRecognized()
Transferable tr =
ObjectInspector
.transferNode; // therefore, we use this hack, which just stores the current
// transferable in a static variable
DataFlavor[] flavors = tr.getTransferDataFlavors();
for (int i = 0; i < flavors.length; i++) {
if (tr.isDataFlavorSupported(flavors[i])) {
dtde.acceptDrop(dtde.getDropAction());
TreePath p = (TreePath) tr.getTransferData(flavors[i]);
DefaultMutableTreeNode node = (DefaultMutableTreeNode) p.getLastPathComponent();
DefaultTreeModel model = (DefaultTreeModel) tree.getModel();
Object sourceObject = node.getUserObject();
FieldWrapperObjectTree targetField = ((FieldWrapperObjectTree) parent.getUserObject());
if (sourceObject != null) {
if (sourceObject instanceof FieldWrapperObjectTree) {
FieldWrapperObjectTree sourceField = (FieldWrapperObjectTree) sourceObject;
if (sourceField.getTheField().getType().equals(targetField.getTheField().getType())) {
targetField
.getTheField()
.set(
targetField.getOnObject(),
sourceField.getTheField().get(sourceField.getOnObject()));
}
} else if (sourceObject.getClass().equals(targetField.getTheField().getType())) {
targetField.getTheField().set(targetField.getOnObject(), sourceObject);
}
tree.invalidate();
tree.repaint();
}
dtde.dropComplete(true);
return;
}
}
dtde.rejectDrop();
} catch (Exception e) {
e.printStackTrace();
// dtde.rejectDrop();
}
}
@Override
protected Transferable createTransferable(JComponent arg0) {
DefaultMutableTreeNode node =
(DefaultMutableTreeNode) ((JTree) arg0).getLastSelectedPathComponent();
if (node.getUserObject() instanceof VegetableBean) {
return new VegetableTransfer((VegetableBean) node.getUserObject());
}
return super.createTransferable(arg0);
}
private static List<String> getMenuPathElements(DefaultMutableTreeNode node) {
ArrayList<String> pathElements = new ArrayList<String>();
while (node != null) {
if (node.getUserObject() instanceof JMenuItem)
pathElements.add(((JMenuItem) node.getUserObject()).getText());
node = (DefaultMutableTreeNode) node.getParent();
}
return pathElements;
}
public void valueChanged(TreeSelectionEvent arg0) {
DefaultMutableTreeNode curTreeNode =
(DefaultMutableTreeNode) ((MyTree) arg0.getSource()).getLastSelectedPathComponent();
if (curTreeNode == null) return;
if (!(curTreeNode.getUserObject() instanceof Caliber)) {
return;
}
Caliber cal = (Caliber) curTreeNode.getUserObject();
// 数据源组合框
dataSourceCbx.setValue(cal.getACal().getSourceID());
// 根据字段列名得到字段类型
// cbxFieldName.setSelectedIndex(-1);
JComboBox cbxFieldNameTmp = (JComboBox) cbxFieldName.getEditor();
int count = cbxFieldNameTmp.getItemCount();
String value;
for (int i = 0; i < count; i++) {
value = ((FComboBoxItem) cbxFieldNameTmp.getItemAt(i)).getValue().toString();
if (value.substring(0, value.indexOf(":")).equals(cal.getACal().getSourceColID())) {
cbxFieldName.setSelectedIndex(i);
break;
}
}
// 字段名称组合框
// cbxFieldName.setValue(cal.getACal().getSourceColID());
// 比较类型
cbxCompare.setValue(cal.getACal().getCompareType());
// 根据sFieldEname返回字段类型
String sFieldTyp = getFieldType();
// 根据字段类型判断参数加不加引号(')
// 条件值
if (DefinePub.checkCharVal(sFieldTyp)) {
String paraValue = cal.getACal().getValue();
// 判断是不是in或not in比较符
if (CompareType.IN_TYPE.equalsIgnoreCase(cal.getACal().getCompareType())
|| CompareType.NOTIN_TYPE.equalsIgnoreCase(cal.getACal().getCompareType())) {
// 去掉左右括号
paraValue = paraValue.substring(1, paraValue.length() - 1);
// 去掉逗号旁的引号
paraValue = paraValue.replaceAll("','", ",");
}
// 去掉最外层引号
cbxWhereValue.setValue(paraValue.substring(1, paraValue.length() - 1));
} else {
cbxWhereValue.setValue(cal.getACal().getValue());
}
// 定义条件类型
if (!Common.isNullStr(cal.getACal().getJoinBefore()))
frdoType.setValue(cal.getACal().getJoinBefore());
}
public static Icon getMenuItemIcon(String menuItemKey) {
final DefaultMutableTreeNode treeNode = getMenuBuilder().get(menuItemKey);
if (treeNode == null
|| !treeNode.isLeaf()
|| !(treeNode.getUserObject() instanceof JMenuItem)) {
return null;
}
final JMenuItem menuItem = (JMenuItem) treeNode.getUserObject();
return menuItem.getIcon();
}
@Override
public void valueChanged(TreeSelectionEvent e) {
TreePath treePath = e.getPath();
DefaultMutableTreeNode node = (DefaultMutableTreeNode) (treePath.getLastPathComponent());
if (node.getUserObject() instanceof Trigger) {
Trigger trigger = (Trigger) (node.getUserObject());
tcd.setVisibleTrigger(trigger);
} else {
tcd.setVisibleTrigger(null);
}
}
