0001: /*
0002: * Created on 25.07.2005
0003: *
0004: */
0005: package org.jdesktop.swingx;
0006:
0007: import java.awt.Color;
0008: import java.awt.Component;
0009: import java.awt.ComponentOrientation;
0010: import java.awt.Dimension;
0011: import java.awt.event.ActionEvent;
0012: import java.util.logging.Logger;
0013: import java.util.regex.Pattern;
0014:
0015: import javax.swing.AbstractAction;
0016: import javax.swing.Action;
0017: import javax.swing.DefaultCellEditor;
0018: import javax.swing.Icon;
0019: import javax.swing.ImageIcon;
0020: import javax.swing.JComboBox;
0021: import javax.swing.JComponent;
0022: import javax.swing.JFrame;
0023: import javax.swing.JTable;
0024: import javax.swing.JTextField;
0025: import javax.swing.JTree;
0026: import javax.swing.SwingUtilities;
0027: import javax.swing.ToolTipManager;
0028: import javax.swing.event.TreeExpansionEvent;
0029: import javax.swing.event.TreeExpansionListener;
0030: import javax.swing.table.TableCellRenderer;
0031: import javax.swing.tree.DefaultMutableTreeNode;
0032: import javax.swing.tree.DefaultTreeCellRenderer;
0033: import javax.swing.tree.TreeCellRenderer;
0034: import javax.swing.tree.TreePath;
0035:
0036: import org.jdesktop.swingx.action.AbstractActionExt;
0037: import org.jdesktop.swingx.decorator.AlternateRowHighlighter;
0038: import org.jdesktop.swingx.decorator.ComponentAdapter;
0039: import org.jdesktop.swingx.decorator.ConditionalHighlighter;
0040: import org.jdesktop.swingx.decorator.Filter;
0041: import org.jdesktop.swingx.decorator.FilterPipeline;
0042: import org.jdesktop.swingx.decorator.HierarchicalColumnHighlighter;
0043: import org.jdesktop.swingx.decorator.Highlighter;
0044: import org.jdesktop.swingx.decorator.HighlighterPipeline;
0045: import org.jdesktop.swingx.decorator.PatternFilter;
0046: import org.jdesktop.swingx.decorator.PatternHighlighter;
0047: import org.jdesktop.swingx.decorator.ShuttleSorter;
0048: import org.jdesktop.swingx.test.ComponentTreeTableModel;
0049: import org.jdesktop.swingx.treetable.AbstractTreeTableModel;
0050: import org.jdesktop.swingx.treetable.DefaultTreeTableModel;
0051: import org.jdesktop.swingx.treetable.TreeTableModel;
0052: import org.jdesktop.test.AncientSwingTeam;
0053:
0054: /**
0055: * @author Jeanette Winzenburg
0056: */
0057: public class JXTreeTableVisualCheck extends JXTreeTableUnitTest {
0058: private static final Logger LOG = Logger
0059: .getLogger(JXTreeTableVisualCheck.class.getName());
0060:
0061: public static void main(String[] args) {
0062: // NOTE JW: this property has be set "very early" in the application life-cycle
0063: // it's immutable once read from the UIManager (into a final static field!!)
0064: // System.setProperty("sun.swing.enableImprovedDragGesture", "true" );
0065: setSystemLF(true);
0066: JXTreeTableVisualCheck test = new JXTreeTableVisualCheck();
0067: try {
0068: // test.runInteractiveTests();
0069: // test.runInteractiveTests("interactive.*Hierarchical.*");
0070: // test.runInteractiveTests("interactive.*ToolTip.*");
0071: // test.runInteractiveTests("interactive.*DnD.*");
0072: // test.runInteractiveTests("interactive.*Compare.*");
0073: // test.runInteractiveTests("interactive.*RowHeightCompare.*");
0074: test.runInteractiveTests("interactive.*Grid.*");
0075: // test.runInteractiveTests("interactive.*Line.*");
0076: // test.runInteractiveTests("interactive.*Render.*");
0077: } catch (Exception ex) {
0078:
0079: }
0080: }
0081:
0082: /**
0083: * visual check what happens on toggling the largeModel property.
0084: * It's okay for ComponentTreeModel, blows up for FileSystemModel.
0085: *
0086: */
0087: public void interactiveLargeModel() {
0088: // final JXTreeTable treeTable = new JXTreeTable(treeTableModel);
0089:
0090: final JXTreeTable treeTable = new JXTreeTable(
0091: createMutableVisualizeModel());
0092: treeTable.setRootVisible(true);
0093: ToolTipManager.sharedInstance().unregisterComponent(treeTable);
0094: Action action = new AbstractAction("toggle largeModel") {
0095:
0096: public void actionPerformed(ActionEvent e) {
0097: treeTable.setLargeModel(!treeTable.isLargeModel());
0098:
0099: }
0100:
0101: };
0102: JXFrame frame = wrapWithScrollingInFrame(treeTable,
0103: "large model");
0104: addAction(frame, action);
0105: frame.setVisible(true);
0106: }
0107:
0108: private ComponentTreeTableModel createMutableVisualizeModel() {
0109: JXPanel frame = new JXPanel();
0110: frame.add(new JTextField());
0111: frame.add(new JTextField());
0112: frame.add(new JComboBox());
0113: frame.add(new JXDatePicker());
0114: return new ComponentTreeTableModel(frame);
0115: }
0116:
0117: /**
0118: * issue #296-swingx: expose scrollPathToVisible in JXTreeTable.
0119: *
0120: * Treetable should behave exactly like Tree - so
0121: * simply passing through to the hierarchical renderer is not quite
0122: * enough - need to force a scrollTo after expanding.
0123: *
0124: */
0125: public void interactiveScrollPathToVisible() {
0126:
0127: final JXFrame container = new JXFrame();
0128: final ComponentTreeTableModel model = new ComponentTreeTableModel(
0129: container);
0130: final JXTreeTable table = new JXTreeTable(model);
0131: table.setColumnControlVisible(true);
0132: final JXTree tree = new JXTree(model);
0133: Action action = new AbstractAction("path visible") {
0134:
0135: public void actionPerformed(ActionEvent e) {
0136: TreePath path = model.getPathToRoot(container
0137: .getContentPane());
0138: table.scrollPathToVisible(path);
0139: tree.scrollPathToVisible(path);
0140:
0141: }
0142:
0143: };
0144: JXFrame frame = wrapWithScrollingInFrame(table, tree,
0145: "compare scrollPathtovisible");
0146: addAction(frame, action);
0147: frame.setVisible(true);
0148:
0149: }
0150:
0151: /**
0152: * http://forums.java.net/jive/thread.jspa?threadID=13966&tstart=0
0153: * adjust hierarchical column width on expansion. The expansion
0154: * listener looks like doing the job. Important: auto-resize off,
0155: * otherwise the table will run out of width to distribute!
0156: *
0157: */
0158: public void interactiveUpdateWidthOnExpand() {
0159:
0160: final JXTreeTable tree = new JXTreeTable(treeTableModel);
0161: tree.setColumnControlVisible(true);
0162: JTree renderer = ((JTree) tree
0163: .getDefaultRenderer(AbstractTreeTableModel.hierarchicalColumnClass));
0164:
0165: renderer.addTreeExpansionListener(new TreeExpansionListener() {
0166:
0167: public void treeCollapsed(TreeExpansionEvent event) {
0168: }
0169:
0170: public void treeExpanded(TreeExpansionEvent event) {
0171:
0172: final JTree renderer = (JTree) event.getSource();
0173:
0174: SwingUtilities.invokeLater(new Runnable() {
0175:
0176: public void run() {
0177: tree
0178: .getColumnModel()
0179: .getColumn(0)
0180: .setPreferredWidth(
0181: renderer.getPreferredSize().width);
0182:
0183: }
0184: });
0185: }
0186:
0187: });
0188: JXFrame frame = wrapWithScrollingInFrame(tree,
0189: "adjust column on expand");
0190: frame.setVisible(true);
0191:
0192: }
0193:
0194: /**
0195: * visualize editing of the hierarchical column, both
0196: * in a tree and a treeTable
0197: *
0198: */
0199: public void interactiveTreeTableModelEditing() {
0200: final TreeTableModel model = createMutableVisualizeModel();
0201: final JXTreeTable table = new JXTreeTable(model);
0202: JTree tree = new JTree(model) {
0203:
0204: @Override
0205: public String convertValueToText(Object value,
0206: boolean selected, boolean expanded, boolean leaf,
0207: int row, boolean hasFocus) {
0208: if (value instanceof Component) {
0209: return ((Component) value).getName();
0210: }
0211: return super .convertValueToText(value, selected,
0212: expanded, leaf, row, hasFocus);
0213: }
0214:
0215: };
0216: tree.setEditable(true);
0217: final JXFrame frame = wrapWithScrollingInFrame(table, tree,
0218: "Editing: compare treetable and tree");
0219: Action toggleComponentOrientation = new AbstractAction(
0220: "toggle orientation") {
0221:
0222: public void actionPerformed(ActionEvent e) {
0223: ComponentOrientation current = frame
0224: .getComponentOrientation();
0225: if (current == ComponentOrientation.LEFT_TO_RIGHT) {
0226: frame
0227: .applyComponentOrientation(ComponentOrientation.RIGHT_TO_LEFT);
0228: } else {
0229: frame
0230: .applyComponentOrientation(ComponentOrientation.LEFT_TO_RIGHT);
0231:
0232: }
0233:
0234: }
0235:
0236: };
0237: addAction(frame, toggleComponentOrientation);
0238: frame.setVisible(true);
0239:
0240: }
0241:
0242: /**
0243: * visualize editing of the hierarchical column, both
0244: * in a treeTable with a local version of TreeTableCellEditor
0245: * and a treeTable with the head version. <p>
0246: *
0247: * Both are loosing the icon... ehem.
0248: *
0249: */
0250: // public void interactiveTreeTableEditingLocalVsHeadEditor() {
0251: // final TreeTableModel model = new ComponentTreeTableModel(new JXFrame());
0252: // final JXTreeTable table = new JXTreeTable(model);
0253: // final JXTreeTable tableHead = new JXTreeTable(model);
0254: // tableHead.setDefaultEditor(AbstractTreeTableModel.hierarchicalColumnClass,
0255: // new TreeTableCellEditorHead(((JXTree) tableHead.getDefaultRenderer(AbstractTreeTableModel.hierarchicalColumnClass))));
0256: // final JXFrame frame = wrapWithScrollingInFrame(table, tableHead, "Editing: compare treetable local and treetable head");
0257: // Action toggleComponentOrientation = new AbstractAction("toggle orientation") {
0258: //
0259: // public void actionPerformed(ActionEvent e) {
0260: // ComponentOrientation current = frame.getComponentOrientation();
0261: // if (current == ComponentOrientation.LEFT_TO_RIGHT) {
0262: // frame.applyComponentOrientation(ComponentOrientation.RIGHT_TO_LEFT);
0263: // } else {
0264: // frame.applyComponentOrientation(ComponentOrientation.LEFT_TO_RIGHT);
0265: //
0266: // }
0267: //
0268: // }
0269: //
0270: // };
0271: // addAction(frame, toggleComponentOrientation);
0272: // frame.setVisible(true);
0273: //
0274: // }
0275: /**
0276: * Issue #248-swingx: update probs with insert into empty model when root
0277: * not visible.
0278: *
0279: * Looks like a core JTree problem: a collapsed root is not automatically expanded
0280: * on hiding. Should it? Yes, IMO (JW).
0281: *
0282: * this exposed a slight glitch in JXTreeTable: toggling the initially invisible
0283: * root to visible did not result in showing the root in the the table. Needed
0284: * to modify setRootVisible to force a revalidate.
0285: *
0286: */
0287: public void interactiveTestInsertNodeEmptyModel() {
0288: final DefaultMutableTreeNode root = new DefaultMutableTreeNode();
0289: final InsertTreeTableModel model = new InsertTreeTableModel(
0290: root, true);
0291: final JTree tree = new JTree(model);
0292: tree.setRootVisible(false);
0293: final JXTreeTable treeTable = new JXTreeTable(model);
0294: treeTable.addHighlighter(AlternateRowHighlighter.linePrinter);
0295: treeTable.setColumnControlVisible(true);
0296: // treetable root invisible by default
0297: JXFrame frame = wrapWithScrollingInFrame(tree, treeTable,
0298: "insert into empty model");
0299: Action insertAction = new AbstractAction("insert node") {
0300:
0301: public void actionPerformed(ActionEvent e) {
0302: model.addChild(root);
0303:
0304: }
0305:
0306: };
0307: addAction(frame, insertAction);
0308: Action toggleRoot = new AbstractAction("toggle root visible") {
0309: public void actionPerformed(ActionEvent e) {
0310: boolean rootVisible = !tree.isRootVisible();
0311: treeTable.setRootVisible(rootVisible);
0312: tree.setRootVisible(rootVisible);
0313: }
0314:
0315: };
0316: addAction(frame, toggleRoot);
0317: frame.setVisible(true);
0318: }
0319:
0320: /**
0321: * Issue #254-swingx: collapseAll/expandAll behaviour depends on
0322: * root visibility (same for treeTable/tree)
0323: *
0324: * initial: root not visible, all root children visible
0325: * do: collapse all - has no effect, unexpected?
0326: * do: toggle root - root and all children visible, expected
0327: * do: collapse all - only root visible, expected
0328: * do: toggle root - all nodes invisible, expected
0329: * do: expand all - still all nodes invisible, unexpected?
0330: *
0331: *
0332: */
0333: public void interactiveTestInsertNodeEmptyModelExpand() {
0334: final DefaultMutableTreeNode root = new DefaultMutableTreeNode();
0335: final InsertTreeTableModel model = new InsertTreeTableModel(
0336: root, true);
0337: for (int i = 0; i < 5; i++) {
0338: model.addChild(root);
0339: }
0340: final JXTree tree = new JXTree(model);
0341: tree.setRootVisible(false);
0342: final JXTreeTable treeTable = new JXTreeTable(model);
0343: treeTable.addHighlighter(AlternateRowHighlighter.linePrinter);
0344: treeTable.setColumnControlVisible(true);
0345: // treetable root invisible by default
0346: JXFrame frame = wrapWithScrollingInFrame(tree, treeTable,
0347: "insert into empty model");
0348: Action toggleRoot = new AbstractAction("toggle root") {
0349: public void actionPerformed(ActionEvent e) {
0350: boolean rootVisible = !tree.isRootVisible();
0351: treeTable.setRootVisible(rootVisible);
0352: tree.setRootVisible(rootVisible);
0353: }
0354:
0355: };
0356: addAction(frame, toggleRoot);
0357: Action expandAll = new AbstractAction("expandAll") {
0358: public void actionPerformed(ActionEvent e) {
0359: treeTable.expandAll();
0360: tree.expandAll();
0361: }
0362:
0363: };
0364: addAction(frame, expandAll);
0365: Action collapseAll = new AbstractAction("collapseAll") {
0366: public void actionPerformed(ActionEvent e) {
0367: treeTable.collapseAll();
0368: tree.collapseAll();
0369: }
0370:
0371: };
0372: addAction(frame, collapseAll);
0373: frame.setVisible(true);
0374: }
0375:
0376: /**
0377: * Issue #247-swingx: update probs with insert node.
0378: * The insert under a collapsed node fires a dataChanged on the table
0379: * which results in the usual total "memory" loss (f.i. selection)
0380: * to reproduce: run example, select root's child in both the tree and the
0381: * treetable (left and right view), press the insert button, treetable looses
0382: * selection, tree doesn't (the latter is the correct behaviour)
0383: *
0384: * couldn't reproduce the reported loss of expansion state. Hmmm..
0385: *
0386: */
0387: public void interactiveTestInsertUnderCollapsedNode() {
0388: final DefaultMutableTreeNode root = new DefaultMutableTreeNode();
0389: final InsertTreeTableModel model = new InsertTreeTableModel(
0390: root);
0391: DefaultMutableTreeNode childA = model.addChild(root);
0392: final DefaultMutableTreeNode childB = model.addChild(childA);
0393: model.addChild(childB);
0394: DefaultMutableTreeNode secondRootChild = model.addChild(root);
0395: model.addChild(secondRootChild);
0396: JXTree tree = new JXTree(model);
0397: final JXTreeTable treeTable = new JXTreeTable(model);
0398: treeTable.addHighlighter(AlternateRowHighlighter.linePrinter);
0399: treeTable.setColumnControlVisible(true);
0400: treeTable.setRootVisible(true);
0401: JXFrame frame = wrapWithScrollingInFrame(tree, treeTable,
0402: "insert problem - root collapsed");
0403: Action insertAction = new AbstractAction("insert node to root") {
0404:
0405: public void actionPerformed(ActionEvent e) {
0406: model.addChild(childB);
0407:
0408: }
0409:
0410: };
0411: addAction(frame, insertAction);
0412: frame.setVisible(true);
0413: }
0414:
0415: /**
0416: * Issue #246-swingx: update probs with insert node.
0417: *
0418: * The reported issue is an asymmetry in updating the parent: it's done only
0419: * if not expanded. With the arguments of #82-swingx, parent's appearance
0420: * might be effected by child changes if expanded as well.
0421: * <p>
0422: * Here's a test for insert: the crazy renderer removes the icon if
0423: * childCount exceeds a limit (here > 3). Select a node, insert a child,
0424: * expand the node and keep inserting children. Interestingly the parent is
0425: * always updated in the treeTable, but not in the tree
0426: * <p>
0427: * Quick test if custom icons provided by the renderer are respected. They
0428: * should appear and seem to do.
0429: *
0430: */
0431: public void interactiveTestInsertNodeAndChangedParentRendering() {
0432: final Icon topIcon = new ImageIcon(getClass().getResource(
0433: "resources/images/wellTop.gif"));
0434: final DefaultMutableTreeNode root = new DefaultMutableTreeNode();
0435: final InsertTreeTableModel model = new InsertTreeTableModel(
0436: root);
0437: final DefaultMutableTreeNode leaf = model.addChild(root);
0438: JXTree tree = new JXTree(model);
0439: final JXTreeTable treeTable = new JXTreeTable(model);
0440: treeTable.addHighlighter(AlternateRowHighlighter.linePrinter);
0441: treeTable.setColumnControlVisible(true);
0442: TreeCellRenderer renderer = new DefaultTreeCellRenderer() {
0443:
0444: @Override
0445: public Component getTreeCellRendererComponent(JTree tree,
0446: Object value, boolean sel, boolean expanded,
0447: boolean leaf, int row, boolean hasFocus) {
0448: Component comp = super
0449: .getTreeCellRendererComponent(tree, value, sel,
0450: expanded, leaf, row, hasFocus);
0451: TreePath path = tree.getPathForRow(row);
0452: if (path != null) {
0453: Object node = path.getLastPathComponent();
0454: if ((node != null)
0455: && (tree.getModel().getChildCount(node) > 3)) {
0456: setIcon(topIcon);
0457: }
0458: }
0459: return comp;
0460: }
0461:
0462: };
0463: tree.setCellRenderer(renderer);
0464: treeTable.setTreeCellRenderer(renderer);
0465: treeTable.setRootVisible(true);
0466: JXFrame frame = wrapWithScrollingInFrame(tree, treeTable,
0467: "update expanded parent on insert - rendering changed for > 3 children");
0468: Action insertAction = new AbstractAction(
0469: "insert node selected treetable") {
0470:
0471: public void actionPerformed(ActionEvent e) {
0472: int selected = treeTable.getSelectedRow();
0473: if (selected < 0)
0474: return;
0475: TreePath path = treeTable.getPathForRow(selected);
0476: DefaultMutableTreeNode parent = (DefaultMutableTreeNode) path
0477: .getLastPathComponent();
0478: model.addChild(parent);
0479:
0480: }
0481:
0482: };
0483: addAction(frame, insertAction);
0484: frame.setVisible(true);
0485: }
0486:
0487: /**
0488: * Issue #82-swingx: update probs with insert node.
0489: *
0490: * Adapted from example code in report.
0491: *
0492: */
0493: public void interactiveTestInsertNode() {
0494: final DefaultMutableTreeNode root = new DefaultMutableTreeNode();
0495: final InsertTreeTableModel model = new InsertTreeTableModel(
0496: root);
0497: final DefaultMutableTreeNode leaf = model.addChild(root);
0498: JTree tree = new JTree(model);
0499: final JXTreeTable treeTable = new JXTreeTable(model);
0500: treeTable.addHighlighter(AlternateRowHighlighter.linePrinter);
0501: treeTable.addHighlighter(new HierarchicalColumnHighlighter());
0502: JXFrame frame = wrapWithScrollingInFrame(tree, treeTable,
0503: "update on insert");
0504: Action insertAction = new AbstractAction("insert node") {
0505:
0506: public void actionPerformed(ActionEvent e) {
0507: int selected = treeTable.getSelectedRow();
0508: if (selected < 0)
0509: return;
0510: TreePath path = treeTable.getPathForRow(selected);
0511: DefaultMutableTreeNode parent = (DefaultMutableTreeNode) path
0512: .getLastPathComponent();
0513: model.addChild(parent);
0514:
0515: }
0516:
0517: };
0518: addAction(frame, insertAction);
0519: frame.setVisible(true);
0520: }
0521:
0522: /**
0523: * Issue #224-swingx: TreeTableEditor not bidi compliant.
0524: *
0525: * the textfield for editing is at the wrong position in RToL.
0526: */
0527: public void interactiveRToLTreeTableEditor() {
0528: final TreeTableModel model = createMutableVisualizeModel();
0529: final JXTreeTable table = new JXTreeTable(model);
0530: final JXFrame frame = wrapWithScrollingInFrame(table,
0531: "Editor: position follows Component orientation");
0532: Action toggleComponentOrientation = new AbstractAction(
0533: "toggle orientation") {
0534:
0535: public void actionPerformed(ActionEvent e) {
0536: ComponentOrientation current = frame
0537: .getComponentOrientation();
0538: if (current == ComponentOrientation.LEFT_TO_RIGHT) {
0539: frame
0540: .applyComponentOrientation(ComponentOrientation.RIGHT_TO_LEFT);
0541: } else {
0542: frame
0543: .applyComponentOrientation(ComponentOrientation.LEFT_TO_RIGHT);
0544:
0545: }
0546:
0547: }
0548:
0549: };
0550: addAction(frame, toggleComponentOrientation);
0551: frame.setVisible(true);
0552: }
0553:
0554: /**
0555: * Issue #223-swingx: Icons lost when editing.
0556: * Regression after starting to fix #224-swingx?
0557: *
0558: *
0559: */
0560: public void interactiveTreeTableEditorIcons() {
0561: final TreeTableModel model = createMutableVisualizeModel();
0562: final JXTreeTable table = new JXTreeTable(model);
0563: JXFrame frame = wrapWithScrollingInFrame(table,
0564: "Editor: icons showing");
0565: frame.setVisible(true);
0566: }
0567:
0568: /**
0569: * see effect of switching treeTableModel.
0570: * Problem when toggling back to FileSystemModel: hierarchical
0571: * column does not show filenames, need to click into table first.
0572: * JW: fixed. The issue was updating of the conversionMethod
0573: * field - needed to be done before calling super.setModel().
0574: *
0575: */
0576: public void interactiveTestSetModel() {
0577: final JXTreeTable treeTable = new JXTreeTable(treeTableModel);
0578: treeTable.setColumnControlVisible(true);
0579: JXFrame frame = wrapWithScrollingInFrame(treeTable,
0580: "toggle model");
0581: frame.setVisible(true);
0582: final TreeTableModel model = new ComponentTreeTableModel(frame);
0583: Action action = new AbstractAction("Toggle model") {
0584:
0585: public void actionPerformed(ActionEvent e) {
0586: TreeTableModel myModel = treeTable.getTreeTableModel();
0587: treeTable
0588: .setTreeTableModel(myModel == model ? treeTableModel
0589: : model);
0590:
0591: }
0592:
0593: };
0594: addAction(frame, action);
0595: }
0596:
0597: /**
0598: * compare treeTable/table height: default gridlines
0599: *
0600: */
0601: public void interactiveTestAlternateHighlightAndRowGridLines() {
0602: JXTreeTable treeTable = new JXTreeTable(treeTableModel);
0603: treeTable.setRowHeight(22);
0604: // treeTable.setRootVisible(true);
0605: // this leads to lines not properly drawn, as always,
0606: // the margins need to be set as well.
0607: // treeTable.setShowGrid(true);
0608: treeTable.setShowGrid(true, true);
0609: treeTable.addHighlighter(AlternateRowHighlighter.linePrinter);
0610: JXTable table = new JXTable(new AncientSwingTeam());
0611: table.addHighlighter(AlternateRowHighlighter.linePrinter);
0612: table.setRowHeight(22);
0613: JFrame frame = wrapWithScrollingInFrame(treeTable, table,
0614: "AlternateRow LinePrinter-with Gridlines");
0615: frame.setVisible(true);
0616: }
0617:
0618: /**
0619: * compare table/table height:
0620: * with and without default gridlines and margins
0621: *
0622: */
0623: public void interactiveTestAlternateHighlightAndNoGridLines() {
0624: JXTable treeTable = new JXTable(new AncientSwingTeam());
0625: treeTable.setRowHeight(22);
0626: treeTable.addHighlighter(AlternateRowHighlighter.linePrinter);
0627: JXTable table = new JXTable(new AncientSwingTeam());
0628: table.addHighlighter(AlternateRowHighlighter.linePrinter);
0629: table.setRowHeight(22);
0630: table.setShowGrid(false, false);
0631: JFrame frame = wrapWithScrollingInFrame(treeTable, table,
0632: "AlternateRow LinePrinter- left== with, right == out Gridlines");
0633: frame.setVisible(true);
0634: }
0635:
0636: /**
0637: * compare treeTable/tree height
0638: *
0639: */
0640: public void interactiveTestHighlightAndRowHeightCompareTree() {
0641: JXTreeTable treeTable = new JXTreeTable(treeTableModel);
0642: treeTable.setRowHeight(22);
0643: treeTable.setShowGrid(true, false);
0644: treeTable.setHighlighters(new HighlighterPipeline(
0645: new Highlighter[] {
0646: AlternateRowHighlighter.linePrinter,
0647: new HierarchicalColumnHighlighter(), }));
0648: final JXTree tree = new JXTree(treeTableModel);
0649: JXTree renderer = (JXTree) treeTable.getCellRenderer(0, 0);
0650: tree.setRowHeight(renderer.getRowHeight());
0651:
0652: JFrame frame = wrapWithScrollingInFrame(treeTable, tree,
0653: "LinePrinter-, ColumnHighlighter and RowHeight");
0654: frame.setVisible(true);
0655: }
0656:
0657: /**
0658: * compare treeTable/tree height
0659: *
0660: */
0661: public void interactiveTestHighlighterRowHeightCompareTree() {
0662: JXTreeTable treeTable = new JXTreeTable(treeTableModel);
0663: treeTable.addHighlighter(new Highlighter(Color.orange, null));
0664: treeTable.setIntercellSpacing(new Dimension(15, 15));
0665: treeTable.setRowHeight(48);
0666: treeTable.setShowHorizontalLines(true);
0667: final JXTree tree = new JXTree(treeTableModel);
0668: JXTree renderer = (JXTree) treeTable.getCellRenderer(0, 0);
0669: tree.setRowHeight(renderer.getRowHeight());
0670: JFrame frame = wrapWithScrollingInFrame(treeTable, tree,
0671: "rowheight 48, margin 15");
0672: frame.setVisible(true);
0673: }
0674:
0675: /**
0676: * Issue #168-jdnc: dnd enabled breaks node collapse/expand.
0677: *
0678: *
0679: */
0680: public void interactiveToggleDnDEnabled() {
0681: final JXTreeTable treeTable = new JXTreeTable(treeTableModel);
0682: treeTable.setColumnControlVisible(true);
0683: final JXTree tree = new JXTree(treeTableModel);
0684: JXTree renderer = (JXTree) treeTable.getCellRenderer(0, 0);
0685: tree.setRowHeight(renderer.getRowHeight());
0686: JXFrame frame = wrapWithScrollingInFrame(treeTable, tree,
0687: "toggle dragEnabled (starting with false)");
0688: frame.setVisible(true);
0689: Action action = new AbstractActionExt("Toggle dnd: false") {
0690:
0691: public void actionPerformed(ActionEvent e) {
0692:
0693: boolean dragEnabled = !treeTable.getDragEnabled();
0694: treeTable.setDragEnabled(dragEnabled);
0695: tree.setDragEnabled(dragEnabled);
0696: setName("Toggle dnd: " + dragEnabled);
0697: }
0698:
0699: };
0700: addAction(frame, action);
0701: }
0702:
0703: public void interactiveTestFocusedCellBackground() {
0704: JXTreeTable xtable = new JXTreeTable(treeTableModel);
0705: xtable.setBackground(new Color(0xF5, 0xFF, 0xF5)); // ledger
0706: JFrame frame = wrapWithScrollingInFrame(xtable,
0707: "Unselected focused background");
0708: frame.setVisible(true);
0709: }
0710:
0711: /**
0712: * Issue #226: no per-cell tooltips in TreeColumn.
0713: */
0714: public void interactiveTestToolTips() {
0715: JXTreeTable treeTable = new JXTreeTable(treeTableModel);
0716: // JW: don't use this idiom - Stackoverflow...
0717: // multiple delegation - need to solve or discourage
0718: treeTable.setTreeCellRenderer(createRenderer());
0719: treeTable.setDefaultRenderer(Object.class,
0720: createTableRenderer(treeTable
0721: .getDefaultRenderer(Object.class)));
0722:
0723: JXTree tree = new JXTree(treeTableModel);
0724: tree.setCellRenderer(createRenderer());
0725: // I'm registered to do tool tips so we can draw tips for the renderers
0726: ToolTipManager toolTipManager = ToolTipManager.sharedInstance();
0727: toolTipManager.registerComponent(tree);
0728: JXFrame frame = wrapWithScrollingInFrame(treeTable, tree,
0729: "tooltips");
0730: frame.setVisible(true);
0731: }
0732:
0733: private TableCellRenderer createTableRenderer(
0734: final TableCellRenderer delegate) {
0735: TableCellRenderer l = new TableCellRenderer() {
0736:
0737: public Component getTableCellRendererComponent(
0738: JTable table, Object value, boolean isSelected,
0739: boolean hasFocus, int row, int column) {
0740: Component result = delegate
0741: .getTableCellRendererComponent(table, value,
0742: isSelected, hasFocus, row, column);
0743: ((JComponent) result).setToolTipText(String
0744: .valueOf(value));
0745: return result;
0746: }
0747:
0748: };
0749: return l;
0750: }
0751:
0752: private TreeCellRenderer createRenderer() {
0753: final TreeCellRenderer delegate = new DefaultTreeCellRenderer();
0754: TreeCellRenderer renderer = new TreeCellRenderer() {
0755:
0756: public Component getTreeCellRendererComponent(JTree tree,
0757: Object value, boolean selected, boolean expanded,
0758: boolean leaf, int row, boolean hasFocus) {
0759: Component result = delegate
0760: .getTreeCellRendererComponent(tree, value,
0761: selected, expanded, leaf, row, hasFocus);
0762: ((JComponent) result).setToolTipText(String
0763: .valueOf(tree.getPathForRow(row)));
0764: return result;
0765: }
0766:
0767: };
0768: return renderer;
0769: }
0770:
0771: /**
0772: * reported: boolean not showing - not reproducible
0773: *
0774: */
0775: public void interactiveTestBooleanRenderer() {
0776: final JXTreeTable treeTable = new JXTreeTable(
0777: new MyTreeTableModel());
0778: treeTable.setRootVisible(true);
0779: JFrame frame = wrapWithScrollingInFrame(treeTable,
0780: "boolean renderers");
0781: frame.setVisible(true);
0782:
0783: }
0784:
0785: private class MyTreeTableModel extends DefaultTreeTableModel {
0786:
0787: public MyTreeTableModel() {
0788: final DefaultMutableTreeNode root = new DefaultMutableTreeNode(
0789: "Root");
0790:
0791: root.add(new DefaultMutableTreeNode("A"));
0792: root.add(new DefaultMutableTreeNode("B"));
0793: this .setRoot(root);
0794: }
0795:
0796: public int getColumnCount() {
0797: return 2;
0798: }
0799:
0800: public Class getColumnClass(int column) {
0801: if (column == 1) {
0802: return Boolean.class;
0803: }
0804: return super .getColumnClass(column);
0805: }
0806:
0807: public boolean isCellEditable(int row, int column) {
0808: return true;
0809: }
0810:
0811: public boolean isCellEditable(Object value, int column) {
0812: return true;
0813: }
0814:
0815: public Object getValueAt(Object o, int column) {
0816: if (column == 0) {
0817: return o.toString();
0818: }
0819:
0820: return new Boolean(true);
0821: }
0822: }
0823:
0824: public void interactiveTestCompareTreeProperties() {
0825: JXTreeTable treeTable = new JXTreeTable(treeTableModel);
0826: treeTable.setShowsRootHandles(false);
0827: treeTable.setRootVisible(false);
0828: JXTreeTable other = new JXTreeTable(treeTableModel);
0829: other.setRootVisible(true);
0830: other.setShowsRootHandles(false);
0831: JFrame frame = wrapWithScrollingInFrame(treeTable, other,
0832: "compare rootVisible");
0833: frame.setVisible(true);
0834: }
0835:
0836: /**
0837: * setting tree properties: tree not updated correctly.
0838: */
0839: public void interactiveTestTreeProperties() {
0840: final JXTreeTable treeTable = new JXTreeTable(treeTableModel);
0841: Action toggleHandles = new AbstractAction("Toggle Handles") {
0842:
0843: public void actionPerformed(ActionEvent e) {
0844: treeTable.setShowsRootHandles(!treeTable
0845: .getShowsRootHandles());
0846:
0847: }
0848:
0849: };
0850: Action toggleRoot = new AbstractAction("Toggle Root") {
0851:
0852: public void actionPerformed(ActionEvent e) {
0853: treeTable.setRootVisible(!treeTable.isRootVisible());
0854:
0855: }
0856:
0857: };
0858: treeTable.setRowHeight(22);
0859: JXFrame frame = wrapWithScrollingInFrame(treeTable,
0860: "Toggle Tree properties ");
0861: addAction(frame, toggleRoot);
0862: addAction(frame, toggleHandles);
0863: frame.setVisible(true);
0864: }
0865:
0866: /**
0867: * Issue #242: CCE when setting icons.
0868: */
0869: public void interactiveTestTreeIcons() {
0870: final JXTreeTable treeTable = new JXTreeTable(treeTableModel);
0871: Icon downIcon = new ImageIcon(getClass().getResource(
0872: "resources/images/" + "wellbottom.gif"));
0873: // DefaultTreeCellRenderer renderer = new DefaultTreeCellRenderer();
0874: // renderer.setClosedIcon(downIcon);
0875: // treeTable.setTreeCellRenderer(renderer);
0876: treeTable.setClosedIcon(downIcon);
0877: // Action toggleHandles = new AbstractAction("Toggle Handles") {
0878: //
0879: // public void actionPerformed(ActionEvent e) {
0880: // treeTable.setShowsRootHandles(!treeTable.getShowsRootHandles());
0881: //
0882: // }
0883: //
0884: // };
0885: // Action toggleRoot = new AbstractAction("Toggle Root") {
0886: //
0887: // public void actionPerformed(ActionEvent e) {
0888: // treeTable.setRootVisible(!treeTable.isRootVisible());
0889: //
0890: // }
0891: //
0892: // };
0893: treeTable.setRowHeight(22);
0894: JFrame frame = wrapWithScrollingInFrame(treeTable,
0895: "Toggle Tree icons ");
0896: // addAction(frame, toggleRoot);
0897: // addAction(frame, toggleHandles);
0898: frame.setVisible(true);
0899: }
0900:
0901: /** issue #148
0902: * did not work on LFs which normally respect lineStyle
0903: * winLF does not respect it anyway...
0904: */
0905: public void interactiveTestFilterHighlightAndLineStyle() {
0906: JXTreeTable treeTable = new JXTreeTable(treeTableModel);
0907: // issue #148
0908: // did not work on LFs which normally respect lineStyle
0909: // winLF does not respect it anyway...
0910: treeTable.putClientProperty("JTree.lineStyle", "Angled");
0911: treeTable.setRowHeight(22);
0912: // add a bunch of highlighters directly
0913: treeTable.addHighlighter(AlternateRowHighlighter.quickSilver);
0914: treeTable.addHighlighter(new HierarchicalColumnHighlighter());
0915: treeTable.addHighlighter(new PatternHighlighter(null,
0916: Color.red, "^s", Pattern.CASE_INSENSITIVE, 0, -1));
0917: // alternative: set a pipeline containing the bunch of highlighters
0918: // treeTable.setHighlighters(new HighlighterPipeline(new Highlighter[] {
0919: // AlternateRowHighlighter.quickSilver,
0920: // new HierarchicalColumnHighlighter(),
0921: // new PatternHighlighter(null, Color.red, "^s",
0922: // Pattern.CASE_INSENSITIVE, 0, -1), }));
0923: JFrame frame = wrapWithScrollingInFrame(treeTable,
0924: "QuickSilver-, Column-, PatternHighligher and LineStyle");
0925: frame.setVisible(true);
0926: }
0927:
0928: /**
0929: * Issue #204: weird filtering.
0930: *
0931: */
0932: public void interactiveTestFilters() {
0933: JXTreeTable treeTable = new JXTreeTable(treeTableModel);
0934: treeTable.putClientProperty("JTree.lineStyle", "Angled");
0935: treeTable.setRowHeight(22);
0936: treeTable.setFilters(new FilterPipeline(
0937: new Filter[] { new PatternFilter("^d",
0938: Pattern.CASE_INSENSITIVE, 0), }));
0939: JFrame frame = wrapWithScrollingInFrame(treeTable,
0940: "PatternFilter");
0941: frame.setVisible(true);
0942: }
0943:
0944: /**
0945: * Issue #??: weird sorting.
0946: *
0947: */
0948: public void interactiveTestSortingFilters() {
0949: JXTreeTable treeTable = new JXTreeTable(treeTableModel);
0950: treeTable.setRowHeight(22);
0951: treeTable.setFilters(new FilterPipeline(
0952: new Filter[] { new ShuttleSorter(1, false), }));
0953: JFrame frame = wrapWithScrollingInFrame(treeTable,
0954: "SortingFilter");
0955: frame.setVisible(true);
0956: }
0957:
0958: public void interactiveTestHighlightAndRowHeight() {
0959: JXTreeTable treeTable = new JXTreeTable(treeTableModel);
0960: treeTable.setRowHeight(22);
0961: treeTable.setHighlighters(new HighlighterPipeline(
0962: new Highlighter[] {
0963: AlternateRowHighlighter.linePrinter,
0964: new HierarchicalColumnHighlighter(), }));
0965: JFrame frame = wrapWithScrollingInFrame(treeTable,
0966: "LinePrinter-, ColumnHighlighter and RowHeight");
0967: frame.setVisible(true);
0968: }
0969:
0970: public void interactiveTestAlternateRowHighlighter() {
0971: JXTreeTable treeTable = new JXTreeTable(treeTableModel);
0972: treeTable
0973: .addHighlighter(AlternateRowHighlighter.classicLinePrinter);
0974: treeTable.setRowHeight(22);
0975: JFrame frame = wrapWithScrollingInFrame(treeTable,
0976: "ClassicLinePrinter and RowHeight");
0977: frame.setVisible(true);
0978: }
0979:
0980: public void interactiveTestBackgroundHighlighter() {
0981: JXTreeTable treeTable = new JXTreeTable(treeTableModel);
0982: treeTable.setHighlighters(new HighlighterPipeline(
0983: new Highlighter[] {
0984: AlternateRowHighlighter.notePadBackground,
0985: new HierarchicalColumnHighlighter(), }));
0986: treeTable.setBackground(new Color(0xFF, 0xFF, 0xCC)); // notepad
0987: treeTable.setGridColor(Color.cyan.darker());
0988: treeTable.setRowHeight(22);
0989: treeTable.setShowGrid(true, false);
0990: JFrame frame = wrapWithScrollingInFrame(treeTable,
0991: "NotePadBackground- HierarchicalColumnHighlighter and horiz lines");
0992: frame.setVisible(true);
0993: }
0994:
0995: public void interactiveTestLedgerBackground() {
0996: JXTreeTable treeTable = new JXTreeTable(treeTableModel);
0997: treeTable.setBackground(new Color(0xF5, 0xFF, 0xF5)); // ledger
0998: treeTable.setGridColor(Color.cyan.darker());
0999: treeTable.setRowHeight(22);
1000: treeTable.setDefaultMargins(true, false);
1001: JFrame frame = wrapWithScrollingInFrame(treeTable,
1002: "LedgerBackground");
1003: frame.setVisible(true);
1004: }
1005:
1006: /**
1007: * Requirement: color the leafs of the hierarchical columns differently.
1008: *
1009: * http://forums.java.net/jive/thread.jspa?messageID=165876
1010: *
1011: *
1012: */
1013: public void interactiveTestHierarchicalColumnHighlightConditional() {
1014: JXTreeTable treeTable = new JXTreeTable(treeTableModel);
1015: treeTable.addHighlighter(new HierarchicalColumnHighlighter(
1016: new Color(235, 234, 219), null));
1017: ConditionalHighlighter conditional = new ConditionalHighlighter() {
1018:
1019: @Override
1020: protected boolean test(ComponentAdapter adapter) {
1021: return adapter.isLeaf();
1022: }
1023:
1024: };
1025: conditional.setBackground(new Color(247, 246, 239));
1026: conditional.setHighlightColumnIndex(0);
1027: treeTable.addHighlighter(conditional);
1028: showWithScrollingInFrame(treeTable,
1029: "HierarchicalColumn And Conditional ");
1030: }
1031:
1032: public void interactiveTestHierarchicalColumnHighlight() {
1033: JXTreeTable treeTable = new JXTreeTable(treeTableModel);
1034: treeTable.addHighlighter(new HierarchicalColumnHighlighter());
1035: JFrame frame = wrapWithScrollingInFrame(treeTable,
1036: "HierarchicalColumnHigh");
1037: frame.setVisible(true);
1038: }
1039:
1040: public void interactiveTestIntercellSpacing1() {
1041: JXTreeTable treeTable = new JXTreeTable(treeTableModel);
1042: treeTable.setIntercellSpacing(new Dimension(1, 1));
1043: treeTable.setShowGrid(true);
1044: JFrame frame = wrapWithScrollingInFrame(treeTable,
1045: "Intercellspacing 1");
1046: frame.setVisible(true);
1047: }
1048:
1049: public void interactiveTestIntercellSpacing2() {
1050: JXTreeTable treeTable = new JXTreeTable(treeTableModel);
1051: treeTable.setIntercellSpacing(new Dimension(2, 2));
1052: treeTable.setShowGrid(true);
1053: JFrame frame = wrapWithScrollingInFrame(treeTable,
1054: "Intercellspacing 2");
1055: frame.setVisible(true);
1056: }
1057:
1058: public void interactiveTestIntercellSpacing3() {
1059: JXTreeTable treeTable = new JXTreeTable(treeTableModel);
1060: treeTable.setIntercellSpacing(new Dimension(3, 3));
1061: treeTable.setShowGrid(true);
1062: JFrame frame = wrapWithScrollingInFrame(treeTable,
1063: "Intercellspacing 3");
1064: frame.setVisible(true);
1065: }
1066:
1067: public void interactiveTestHighlighterRowHeight() {
1068: JXTreeTable treeTable = new JXTreeTable(treeTableModel);
1069: treeTable.addHighlighter(new Highlighter(Color.orange, null));
1070: treeTable.setIntercellSpacing(new Dimension(15, 15));
1071: treeTable.setRowHeight(48);
1072: JFrame frame = wrapWithScrollingInFrame(treeTable,
1073: "Orange, big rowheight");
1074: frame.setVisible(true);
1075: }
1076:
1077: public void interactiveTestHighlighters() {
1078: JXTreeTable treeTable = new JXTreeTable(treeTableModel);
1079: treeTable.setIntercellSpacing(new Dimension(15, 15));
1080: treeTable.setRowHeight(48);
1081: // not supported in JXTreeTable
1082: // treeTable.setRowHeight(0, 96);
1083: treeTable.setShowGrid(true);
1084: // set a bunch of highlighters as a pipeline
1085: treeTable.setHighlighters(new HighlighterPipeline(
1086: new Highlighter[] {
1087: new Highlighter(Color.orange, null),
1088: new HierarchicalColumnHighlighter(),
1089: new PatternHighlighter(null, Color.red, "D", 0,
1090: 0, 0),
1091:
1092: }));
1093: Highlighter conditional = new ConditionalHighlighter(
1094: Color.BLUE, Color.WHITE, 0, 0) {
1095:
1096: protected boolean test(ComponentAdapter adapter) {
1097: return adapter.hasFocus();
1098: }
1099:
1100: };
1101: // add the conditional highlighter later
1102: treeTable.addHighlighter(conditional);
1103: JFrame frame = wrapWithScrollingInFrame(treeTable,
1104: "Highlighters: conditional, orange, hierarchy, pattern D");
1105: frame.setVisible(true);
1106: }
1107:
1108: }
|