http://git-wip-us.apache.org/repos/asf/cayenne/blob/51289d1c/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/editor/dbimport/DraggableTreePanel.java ---------------------------------------------------------------------- diff --git a/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/editor/dbimport/DraggableTreePanel.java b/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/editor/dbimport/DraggableTreePanel.java new file mode 100644 index 0000000..9605e54 --- /dev/null +++ b/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/editor/dbimport/DraggableTreePanel.java @@ -0,0 +1,449 @@ +/***************************************************************** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + ****************************************************************/ + +package org.apache.cayenne.modeler.editor.dbimport; + +import org.apache.cayenne.dbsync.reverse.dbimport.Catalog; +import org.apache.cayenne.dbsync.reverse.dbimport.ExcludeColumn; +import org.apache.cayenne.dbsync.reverse.dbimport.ExcludeProcedure; +import org.apache.cayenne.dbsync.reverse.dbimport.ExcludeTable; +import org.apache.cayenne.dbsync.reverse.dbimport.IncludeColumn; +import org.apache.cayenne.dbsync.reverse.dbimport.IncludeProcedure; +import org.apache.cayenne.dbsync.reverse.dbimport.IncludeTable; +import org.apache.cayenne.dbsync.reverse.dbimport.ReverseEngineering; +import org.apache.cayenne.dbsync.reverse.dbimport.Schema; +import org.apache.cayenne.map.DataMap; +import org.apache.cayenne.modeler.ProjectController; +import org.apache.cayenne.modeler.action.dbimport.AddCatalogAction; +import org.apache.cayenne.modeler.action.dbimport.AddExcludeColumnAction; +import org.apache.cayenne.modeler.action.dbimport.AddExcludeProcedureAction; +import org.apache.cayenne.modeler.action.dbimport.AddExcludeTableAction; +import org.apache.cayenne.modeler.action.dbimport.AddIncludeColumnAction; +import org.apache.cayenne.modeler.action.dbimport.AddIncludeProcedureAction; +import org.apache.cayenne.modeler.action.dbimport.AddIncludeTableAction; +import org.apache.cayenne.modeler.action.dbimport.AddSchemaAction; +import org.apache.cayenne.modeler.action.dbimport.MoveImportNodeAction; +import org.apache.cayenne.modeler.action.dbimport.MoveInvertNodeAction; +import org.apache.cayenne.modeler.action.dbimport.TreeManipulationAction; +import org.apache.cayenne.modeler.dialog.db.load.DbImportTreeNode; +import org.apache.cayenne.modeler.dialog.db.load.TransferableNode; +import org.apache.cayenne.modeler.util.CayenneAction; + +import javax.swing.DropMode; +import javax.swing.JButton; +import javax.swing.JComponent; +import javax.swing.JScrollPane; +import javax.swing.JTree; +import javax.swing.TransferHandler; +import javax.swing.event.TreeSelectionEvent; +import javax.swing.event.TreeSelectionListener; +import javax.swing.tree.DefaultTreeCellRenderer; +import javax.swing.tree.TreePath; +import java.awt.datatransfer.DataFlavor; +import java.awt.datatransfer.Transferable; +import java.awt.datatransfer.UnsupportedFlavorException; +import java.awt.event.KeyEvent; +import java.awt.event.KeyListener; +import java.awt.event.MouseAdapter; +import java.awt.event.MouseEvent; +import java.io.IOException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** + * @since 4.1 + */ +public class DraggableTreePanel extends JScrollPane { + + private static final int ROOT_LEVEL = 14; + private static final int FIRST_LEVEL = 11; + private static final int SECOND_LEVEL = 8; + private static final int THIRD_LEVEL = 5; + private static final int FOURTH_LEVEL = 2; + private static final int FIFTH_LEVEL = 3; + private static final String MOVE_BUTTON_LABEL = "Include"; + private static final String MOVE_INV_BUTTON_LABEL = "Exclude"; + + private DbImportTree sourceTree; + private DbImportTree targetTree; + private CayenneAction.CayenneToolbarButton moveButton; + private CayenneAction.CayenneToolbarButton moveInvertButton; + private Map<DataMap, ReverseEngineering> databaseStructures; + + private ProjectController projectController; + private Map<Class, Integer> levels; + private Map<Class, List<Class>> insertableLevels; + private Map<Class, Class> actions; + + public DraggableTreePanel(ProjectController projectController, DbImportTree sourceTree, DbImportTree targetTree) { + super(sourceTree); + this.targetTree = targetTree; + this.sourceTree = sourceTree; + this.projectController = projectController; + this.databaseStructures = new HashMap<>(); + initLevels(); + initElement(); + initActions(); + initListeners(); + } + + private void initActions() { + actions = new HashMap<>(); + actions.put(Catalog.class, AddCatalogAction.class); + actions.put(Schema.class, AddSchemaAction.class); + actions.put(IncludeTable.class, AddIncludeTableAction.class); + actions.put(ExcludeTable.class, AddExcludeTableAction.class); + actions.put(IncludeColumn.class, AddIncludeColumnAction.class); + actions.put(ExcludeColumn.class, AddExcludeColumnAction.class); + actions.put(IncludeProcedure.class, AddIncludeProcedureAction.class); + actions.put(ExcludeProcedure.class, AddExcludeProcedureAction.class); + } + + public void updateTree(DataMap dataMap) { + DbImportModel model = (DbImportModel) sourceTree.getModel(); + model.reload(); + if (databaseStructures.get(dataMap) != null) { + sourceTree.setReverseEngineering(databaseStructures.get(dataMap)); + sourceTree.translateReverseEngineeringToTree(databaseStructures.get(dataMap), true); + sourceTree.setEnabled(true); + } else { + sourceTree.setEnabled(false); + } + } + + private void initListeners() { + sourceTree.addKeyListener(new SourceTreeKeyListener()); + targetTree.addKeyListener(new TargetTreeKeyListener()); + targetTree.addTreeSelectionListener(new TargetTreeSelectionListener()); + targetTree.setTransferHandler(new TargetTreeTransferHandler()); + sourceTree.setTransferHandler(new SourceTreeTransferHandler()); + sourceTree.addTreeSelectionListener(new SourceTreeSelectionListener()); + sourceTree.addMouseListener(new ResetFocusMouseAdapter()); + targetTree.setDragEnabled(true); + } + + private boolean canBeInverted() { + if (sourceTree.getSelectionPath() != null) { + DbImportTreeNode selectedElement = sourceTree.getSelectedNode(); + if (selectedElement == null) { + return false; + } + if (levels.get(selectedElement.getUserObject().getClass()) < SECOND_LEVEL) { + return true; + } + } + return false; + } + + private void initElement() { + sourceTree.setDragEnabled(true); + sourceTree.setCellRenderer(new ColorTreeRenderer()); + sourceTree.setDropMode(DropMode.INSERT); + + MoveImportNodeAction action = projectController.getApplication(). + getActionManager().getAction(MoveImportNodeAction.class); + action.setPanel(this); + action.setSourceTree(sourceTree); + action.setTargetTree(targetTree); + moveButton = (CayenneAction.CayenneToolbarButton) action.buildButton(); + moveButton.setShowingText(true); + moveButton.setText(MOVE_BUTTON_LABEL); + MoveInvertNodeAction actionInv = projectController.getApplication(). + getActionManager().getAction(MoveInvertNodeAction.class); + actionInv.setPanel(this); + actionInv.setSourceTree(sourceTree); + actionInv.setTargetTree(targetTree); + moveInvertButton = (CayenneAction.CayenneToolbarButton) actionInv.buildButton(); + moveInvertButton.setShowingText(true); + moveInvertButton.setText(MOVE_INV_BUTTON_LABEL); + + + DefaultTreeCellRenderer renderer = (DefaultTreeCellRenderer) sourceTree.getCellRenderer(); + renderer.setLeafIcon(null); + renderer.setClosedIcon(null); + renderer.setOpenIcon(null); + } + + private void initLevels() { + levels = new HashMap<>(); + levels.put(ReverseEngineering.class, ROOT_LEVEL); + levels.put(Catalog.class, FIRST_LEVEL); + levels.put(Schema.class, SECOND_LEVEL); + levels.put(IncludeTable.class, THIRD_LEVEL); + levels.put(IncludeColumn.class, FOURTH_LEVEL); + levels.put(ExcludeColumn.class, FOURTH_LEVEL); + levels.put(ExcludeTable.class, FIFTH_LEVEL); + levels.put(IncludeProcedure.class, FIFTH_LEVEL); + levels.put(ExcludeProcedure.class, FIFTH_LEVEL); + + insertableLevels = new HashMap<>(); + List<Class> rootLevelClasses = new ArrayList<>(); + rootLevelClasses.add(Catalog.class); + rootLevelClasses.add(Schema.class); + rootLevelClasses.add(IncludeTable.class); + rootLevelClasses.add(ExcludeTable.class); + rootLevelClasses.add(IncludeColumn.class); + rootLevelClasses.add(ExcludeColumn.class); + rootLevelClasses.add(IncludeProcedure.class); + rootLevelClasses.add(ExcludeProcedure.class); + + List<Class> catalogLevelClasses = new ArrayList<>(); + catalogLevelClasses.add(Schema.class); + catalogLevelClasses.add(IncludeTable.class); + catalogLevelClasses.add(ExcludeTable.class); + catalogLevelClasses.add(IncludeColumn.class); + catalogLevelClasses.add(ExcludeColumn.class); + catalogLevelClasses.add(IncludeProcedure.class); + catalogLevelClasses.add(ExcludeProcedure.class); + + List<Class> schemaLevelClasses = new ArrayList<>(); + schemaLevelClasses.add(IncludeTable.class); + schemaLevelClasses.add(ExcludeTable.class); + schemaLevelClasses.add(IncludeColumn.class); + schemaLevelClasses.add(ExcludeColumn.class); + schemaLevelClasses.add(IncludeProcedure.class); + schemaLevelClasses.add(ExcludeProcedure.class); + + List<Class> includeTableLevelClasses = new ArrayList<>(); + includeTableLevelClasses.add(IncludeColumn.class); + includeTableLevelClasses.add(ExcludeColumn.class); + + insertableLevels.put(ReverseEngineering.class, rootLevelClasses); + insertableLevels.put(Catalog.class, catalogLevelClasses); + insertableLevels.put(Schema.class, schemaLevelClasses); + insertableLevels.put(IncludeTable.class, includeTableLevelClasses); + } + + private boolean canBeMoved() { + if (sourceTree.getSelectionPath() != null) { + DbImportTreeNode selectedElement = sourceTree.getSelectedNode(); + if (selectedElement == null) { + return false; + } + Class draggableElementClass = selectedElement.getUserObject().getClass(); + Class reverseEngineeringElementClass; + if (targetTree.getSelectionPath() != null) { + selectedElement = targetTree.getSelectedNode(); + DbImportTreeNode parent = (DbImportTreeNode) selectedElement.getParent(); + if (parent != null) { + reverseEngineeringElementClass = parent.getUserObject().getClass(); + } else { + reverseEngineeringElementClass = selectedElement.getUserObject().getClass(); + } + } else { + reverseEngineeringElementClass = ReverseEngineering.class; + } + List<Class> containsList = insertableLevels.get(reverseEngineeringElementClass); + return containsList.contains(draggableElementClass); + } + return false; + } + + public JButton getMoveButton() { + return moveButton; + } + + public JButton getMoveInvertButton() { + return moveInvertButton; + } + + public TreeManipulationAction getActionByNodeType(Class nodeType) { + Class actionClass = actions.get(nodeType); + if (actionClass != null) { + TreeManipulationAction action = (TreeManipulationAction) projectController.getApplication(). + getActionManager().getAction(actionClass); + return action; + } + return null; + } + + public void bindReverseEngineeringToDatamap(DataMap dataMap, ReverseEngineering reverseEngineering) { + databaseStructures.put(dataMap, reverseEngineering); + } + + public DbImportTree getSourceTree() { + return sourceTree; + } + + private static class SourceTreeTransferHandler extends TransferHandler { + + @Override + public int getSourceActions(JComponent c) { + return COPY; + } + + @Override + public Transferable createTransferable(JComponent c) { + JTree tree = (JTree) c; + TreePath[] paths = tree.getSelectionPaths(); + DbImportTreeNode[] nodes = new DbImportTreeNode[paths.length]; + for (int i = 0; i < paths.length; i++) { + nodes[i] = (DbImportTreeNode) paths[i].getLastPathComponent(); + } + return new Transferable() { + @Override + public DataFlavor[] getTransferDataFlavors() { + return TransferableNode.flavors; + } + + @Override + public boolean isDataFlavorSupported(DataFlavor flavor) { + return true; + } + + @Override + public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException { + return nodes; + } + }; + } + } + + private class SourceTreeKeyListener implements KeyListener { + @Override + public void keyTyped(KeyEvent e) {} + + @Override + public void keyPressed(KeyEvent e) { + if (e.getKeyCode() == KeyEvent.VK_ESCAPE) { + sourceTree.setSelectionRow(-1); + moveButton.setEnabled(false); + moveInvertButton.setEnabled(false); + } + } + + @Override + public void keyReleased(KeyEvent e) {} + } + + private class TargetTreeKeyListener implements KeyListener { + @Override + public void keyTyped(KeyEvent e) {} + + @Override + public void keyPressed(KeyEvent e) { + if (e.getKeyCode() == KeyEvent.VK_ESCAPE) { + targetTree.setSelectionRow(-1); + } + } + + @Override + public void keyReleased(KeyEvent e) {} + } + + private class TargetTreeSelectionListener implements TreeSelectionListener { + @Override + public void valueChanged(TreeSelectionEvent e) { + DbImportModel model = (DbImportModel) sourceTree.getModel(); + DbImportTreeNode root = (DbImportTreeNode) model.getRoot(); + sourceTree.repaint(); + if (root.getChildCount() > 0) { + model.nodesChanged(root, new int[]{root.getChildCount() - 1}); + } + if (canBeMoved()) { + moveButton.setEnabled(true); + if (canBeInverted()) { + moveInvertButton.setEnabled(true); + } else { + moveInvertButton.setEnabled(false); + } + } else { + moveButton.setEnabled(false); + moveInvertButton.setEnabled(false); + } + } + } + + private class TargetTreeTransferHandler extends TransferHandler { + + @Override + public int getSourceActions(JComponent c) { + return COPY_OR_MOVE; + } + + @Override + public boolean canImport(TransferSupport support) { + if (!support.isDrop()) { + return false; + } + return true; + } + + @Override + public boolean importData(TransferSupport support) { + if (!canImport(support)) { + return false; + } + if (!canBeMoved()) { + return false; + } + Transferable transferable = support.getTransferable(); + DbImportTreeNode[] transferData = null; + try { + for (DataFlavor dataFlavor : transferable.getTransferDataFlavors()) { + transferData = (DbImportTreeNode[]) transferable.getTransferData(dataFlavor); + } + } catch (IOException | UnsupportedFlavorException e) { + return false; + } + if (transferData != null) { + MoveImportNodeAction action = projectController.getApplication(). + getActionManager().getAction(MoveImportNodeAction.class); + action.setSourceTree(sourceTree); + action.setTargetTree(targetTree); + action.setPanel(DraggableTreePanel.this); + action.performAction(null); + return true; + } + return false; + } + } + + private class SourceTreeSelectionListener implements TreeSelectionListener { + @Override + public void valueChanged(TreeSelectionEvent e) { + if (sourceTree.getLastSelectedPathComponent() != null) { + if (canBeMoved()) { + moveButton.setEnabled(true); + if (canBeInverted()) { + moveInvertButton.setEnabled(true); + } else { + moveInvertButton.setEnabled(false); + } + } else { + moveInvertButton.setEnabled(false); + moveButton.setEnabled(false); + } + } + } + } + + private class ResetFocusMouseAdapter extends MouseAdapter { + @Override + public void mouseClicked(MouseEvent e) { + if (sourceTree.getRowForLocation(e.getX(),e.getY()) == -1) { + sourceTree.setSelectionRow(-1); + moveInvertButton.setEnabled(false); + moveButton.setEnabled(false); + } + } + } +}
http://git-wip-us.apache.org/repos/asf/cayenne/blob/51289d1c/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/editor/dbimport/ReverseEngineeringConfigPanel.java ---------------------------------------------------------------------- diff --git a/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/editor/dbimport/ReverseEngineeringConfigPanel.java b/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/editor/dbimport/ReverseEngineeringConfigPanel.java new file mode 100644 index 0000000..8f3993a --- /dev/null +++ b/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/editor/dbimport/ReverseEngineeringConfigPanel.java @@ -0,0 +1,221 @@ +/***************************************************************** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + ****************************************************************/ + +package org.apache.cayenne.modeler.editor.dbimport; + +import com.jgoodies.forms.builder.DefaultFormBuilder; +import com.jgoodies.forms.layout.FormLayout; +import org.apache.cayenne.dbsync.reverse.dbimport.ReverseEngineering; +import org.apache.cayenne.map.DataMap; +import org.apache.cayenne.modeler.ProjectController; +import org.apache.cayenne.modeler.util.NameGeneratorPreferences; +import org.apache.cayenne.modeler.util.TextAdapter; + +import javax.swing.DefaultComboBoxModel; +import javax.swing.JCheckBox; +import javax.swing.JComboBox; +import javax.swing.JPanel; +import javax.swing.JTextField; +import java.util.Vector; + +/** + * @since 4.1 + */ +public class ReverseEngineeringConfigPanel extends JPanel { + + private static final String DATA_FIELDS_LAYOUT = "right:pref, 3dlu, fill:235dlu"; + + private JComboBox<String> strategyCombo; + private TextAdapter meaningfulPk; + private TextAdapter stripFromTableNames; + private JCheckBox skipRelationshipsLoading; + private JCheckBox skipPrimaryKeyLoading; + private JCheckBox forceDataMapCatalog; + private JCheckBox forceDataMapSchema; + private JCheckBox usePrimitives; + private JCheckBox useJava7Types; + + private ProjectController projectController; + + ReverseEngineeringConfigPanel(ProjectController projectController) { + this.projectController = projectController; + initFormElements(); + initListeners(); + buildView(); + } + + private void buildView() { + FormLayout panelLayout = new FormLayout(DATA_FIELDS_LAYOUT); + DefaultFormBuilder panelBuilder = new DefaultFormBuilder(panelLayout); + panelBuilder.setDefaultDialogBorder(); + + panelBuilder.append("Tables with Meaningful PK Pattern:", meaningfulPk.getComponent()); + panelBuilder.append("Strip from table names:", stripFromTableNames.getComponent()); + panelBuilder.append("Skip relationships loading:", skipRelationshipsLoading); + panelBuilder.append("Skip primary key loading:", skipPrimaryKeyLoading); + panelBuilder.append("Force datamap catalog:", forceDataMapCatalog); + panelBuilder.append("Force datamap schema:", forceDataMapSchema); + panelBuilder.append("Use Java primitive types:", usePrimitives); + panelBuilder.append("Use java.util.Date type:", useJava7Types); + panelBuilder.append(strategyCombo); + + add(panelBuilder.getPanel()); + } + + void fillCheckboxes(ReverseEngineering reverseEngineering) { + skipRelationshipsLoading.setSelected(reverseEngineering.getSkipRelationshipsLoading()); + skipPrimaryKeyLoading.setSelected(reverseEngineering.getSkipPrimaryKeyLoading()); + forceDataMapCatalog.setSelected(reverseEngineering.isForceDataMapCatalog()); + forceDataMapSchema.setSelected(reverseEngineering.isForceDataMapSchema()); + usePrimitives.setSelected(reverseEngineering.isUsePrimitives()); + useJava7Types.setSelected(reverseEngineering.isUseJava7Types()); + } + + void initializeTextFields(ReverseEngineering reverseEngineering) { + meaningfulPk.setText(reverseEngineering.getMeaningfulPkTables()); + stripFromTableNames.setText(reverseEngineering.getStripFromTableNames()); + } + + private ReverseEngineering getReverseEngineeringBySelectedMap() { + DataMap dataMap = projectController.getCurrentDataMap(); + return projectController.getApplication().getMetaData().get(dataMap, ReverseEngineering.class); + } + + private void initStrategy() { + Vector<String> arr = NameGeneratorPreferences + .getInstance() + .getLastUsedStrategies(); + strategyCombo.setModel(new DefaultComboBoxModel<>(arr)); + } + + private void initFormElements() { + strategyCombo = new JComboBox<>(); + strategyCombo.addActionListener(e -> { + getReverseEngineeringBySelectedMap().setNamingStrategy( + (String) ReverseEngineeringConfigPanel.this.getStrategyCombo().getSelectedItem() + ); + projectController.setDirty(true); + }); + strategyCombo.setVisible(false); + + JTextField meaningfulPkField = new JTextField(); + meaningfulPkField.setToolTipText("<html>Regular expression to filter tables with meaningful primary keys.<br>" + + "Multiple expressions divided by comma can be used.<br>" + + "Example: <b>^table1|^table2|^prefix.*|table_name</b></html>"); + meaningfulPk = new TextAdapter(meaningfulPkField) { + protected void updateModel(String text) { + getReverseEngineeringBySelectedMap().setMeaningfulPkTables(text); + projectController.setDirty(true); + } + }; + + JTextField stripFromTableNamesField = new JTextField(); + stripFromTableNamesField.setToolTipText("<html>Regex that matches the part of the table name that needs to be stripped off " + + "when generating ObjEntity name</html>"); + stripFromTableNames = new TextAdapter(stripFromTableNamesField) { + protected void updateModel(String text) { + getReverseEngineeringBySelectedMap().setStripFromTableNames(text); + projectController.setDirty(true); + } + }; + + skipRelationshipsLoading = new JCheckBox(); + skipRelationshipsLoading.setToolTipText("<html>Whether to load relationships.</html>"); + skipPrimaryKeyLoading = new JCheckBox(); + skipPrimaryKeyLoading.setToolTipText("<html>Whether to load primary keys.</html>"); + forceDataMapCatalog = new JCheckBox(); + forceDataMapCatalog.setToolTipText("<html>Automatically tagging each DbEntity with the actual DB catalog/schema" + + "(default behavior) may sometimes be undesirable.<br> If this is the case then setting <b>forceDataMapCatalog</b> " + + "to <b>true</b> will set DbEntity catalog to one in the DataMap.</html>"); + forceDataMapSchema = new JCheckBox(); + forceDataMapSchema.setToolTipText("<html>Automatically tagging each DbEntity with the actual DB catalog/schema " + + "(default behavior) may sometimes be undesirable.<br> If this is the case then setting <b>forceDataMapSchema</b> " + + "to <b>true</b> will set DbEntity schema to one in the DataMap.</html>"); + useJava7Types = new JCheckBox(); + useJava7Types.setToolTipText("<html>Use <b>java.util.Date</b> for all columns with <i>DATE/TIME/TIMESTAMP</i> types.<br>" + + "By default <b>java.time.*</b> types will be used.</html>"); + usePrimitives = new JCheckBox(); + usePrimitives.setToolTipText("<html>Use primitive types (e.g. int) or Object types (e.g. java.lang.Integer)</html>"); + initStrategy(); + } + + private void initListeners() { + skipRelationshipsLoading.addActionListener(e -> { + getReverseEngineeringBySelectedMap().setSkipRelationshipsLoading(skipRelationshipsLoading.isSelected()); + projectController.setDirty(true); + }); + skipPrimaryKeyLoading.addActionListener(e -> { + getReverseEngineeringBySelectedMap().setSkipPrimaryKeyLoading(skipPrimaryKeyLoading.isSelected()); + projectController.setDirty(true); + }); + forceDataMapCatalog.addActionListener(e -> { + getReverseEngineeringBySelectedMap().setForceDataMapCatalog(forceDataMapCatalog.isSelected()); + projectController.setDirty(true); + }); + forceDataMapSchema.addActionListener(e -> { + getReverseEngineeringBySelectedMap().setForceDataMapSchema(forceDataMapSchema.isSelected()); + projectController.setDirty(true); + }); + usePrimitives.addActionListener(e -> { + getReverseEngineeringBySelectedMap().setUsePrimitives(usePrimitives.isSelected()); + projectController.setDirty(true); + }); + useJava7Types.addActionListener(e -> { + getReverseEngineeringBySelectedMap().setUseJava7Types(useJava7Types.isSelected()); + projectController.setDirty(true); + }); + } + + JComboBox<String> getStrategyCombo() { + return strategyCombo; + } + + TextAdapter getMeaningfulPk() { + return meaningfulPk; + } + + TextAdapter getStripFromTableNames() { + return stripFromTableNames; + } + + JCheckBox getSkipRelationshipsLoading() { + return skipRelationshipsLoading; + } + + JCheckBox getSkipPrimaryKeyLoading() { + return skipPrimaryKeyLoading; + } + + JCheckBox getForceDataMapCatalog() { + return forceDataMapCatalog; + } + + JCheckBox getForceDataMapSchema() { + return forceDataMapSchema; + } + + JCheckBox getUsePrimitives() { + return usePrimitives; + } + + JCheckBox getUseJava7Types() { + return useJava7Types; + } + +} http://git-wip-us.apache.org/repos/asf/cayenne/blob/51289d1c/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/editor/dbimport/ReverseEngineeringTreePanel.java ---------------------------------------------------------------------- diff --git a/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/editor/dbimport/ReverseEngineeringTreePanel.java b/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/editor/dbimport/ReverseEngineeringTreePanel.java new file mode 100644 index 0000000..5fefdd2 --- /dev/null +++ b/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/editor/dbimport/ReverseEngineeringTreePanel.java @@ -0,0 +1,173 @@ +/***************************************************************** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + ****************************************************************/ + +package org.apache.cayenne.modeler.editor.dbimport; + +import org.apache.cayenne.dbsync.reverse.dbimport.Catalog; +import org.apache.cayenne.dbsync.reverse.dbimport.ExcludeColumn; +import org.apache.cayenne.dbsync.reverse.dbimport.ExcludeProcedure; +import org.apache.cayenne.dbsync.reverse.dbimport.ExcludeTable; +import org.apache.cayenne.dbsync.reverse.dbimport.IncludeColumn; +import org.apache.cayenne.dbsync.reverse.dbimport.IncludeProcedure; +import org.apache.cayenne.dbsync.reverse.dbimport.IncludeTable; +import org.apache.cayenne.dbsync.reverse.dbimport.ReverseEngineering; +import org.apache.cayenne.dbsync.reverse.dbimport.Schema; +import org.apache.cayenne.map.DataMap; +import org.apache.cayenne.modeler.ProjectController; +import org.apache.cayenne.modeler.dialog.db.load.CatalogPopUpMenu; +import org.apache.cayenne.modeler.dialog.db.load.DbImportTreeNode; +import org.apache.cayenne.modeler.dialog.db.load.DefaultPopUpMenu; +import org.apache.cayenne.modeler.dialog.db.load.IncludeTablePopUpMenu; +import org.apache.cayenne.modeler.dialog.db.load.RootPopUpMenu; +import org.apache.cayenne.modeler.dialog.db.load.SchemaPopUpMenu; +import org.apache.cayenne.modeler.editor.dbimport.DbImportTree; +import org.apache.cayenne.modeler.editor.dbimport.DbImportTreeCellEditor; +import org.apache.cayenne.modeler.editor.dbimport.DbImportTreeCellRenderer; +import org.apache.cayenne.modeler.editor.dbimport.DraggableTreePanel; +import org.apache.cayenne.modeler.editor.dbimport.TreeToolbarPanel; + +import javax.swing.JScrollPane; +import javax.swing.JTree; +import javax.swing.SwingUtilities; +import javax.swing.tree.DefaultTreeCellRenderer; +import javax.swing.tree.TreePath; +import java.awt.event.MouseAdapter; +import java.awt.event.MouseEvent; +import java.util.HashMap; +import java.util.Map; + +/** + * @since 4.1 + */ +class ReverseEngineeringTreePanel extends JScrollPane { + + private DbImportTree reverseEngineeringTree; + private DbImportTree dbSchemaTree; + + private ProjectController projectController; + private TreeToolbarPanel treeToolbar; + private Map<Class, DefaultPopUpMenu> popups; + + ReverseEngineeringTreePanel(ProjectController projectController, DbImportTree reverseEngineeringTree, + DbImportTree dbSchemaTree) { + super(reverseEngineeringTree); + this.projectController = projectController; + this.reverseEngineeringTree = reverseEngineeringTree; + this.dbSchemaTree = dbSchemaTree; + reverseEngineeringTree.setEditable(true); + reverseEngineeringTree.setCellRenderer(new DbImportTreeCellRenderer()); + DbImportTreeCellEditor editor = new DbImportTreeCellEditor(reverseEngineeringTree, + (DefaultTreeCellRenderer) reverseEngineeringTree.getCellRenderer()); + editor.setProjectController(projectController); + reverseEngineeringTree.setCellEditor(editor); + initListeners(); + initPopupMenus(); + changeIcons(); + } + + void updateTree() { + reverseEngineeringTree.translateReverseEngineeringToTree(getReverseEngineeringBySelectedMap(), false); + } + + private void initPopupMenus() { + popups = new HashMap<>(); + popups.put(Catalog.class, new CatalogPopUpMenu()); + popups.put(Schema.class, new SchemaPopUpMenu()); + popups.put(ReverseEngineering.class, new RootPopUpMenu()); + popups.put(String.class, new RootPopUpMenu()); + popups.put(IncludeTable.class, new IncludeTablePopUpMenu()); + popups.put(ExcludeTable.class, new DefaultPopUpMenu()); + popups.put(IncludeColumn.class, new DefaultPopUpMenu()); + popups.put(ExcludeColumn.class, new DefaultPopUpMenu()); + popups.put(IncludeProcedure.class, new DefaultPopUpMenu()); + popups.put(ExcludeProcedure.class, new DefaultPopUpMenu()); + } + + private void initListeners() { + reverseEngineeringTree.addTreeSelectionListener(e -> treeToolbar.lockButtons()); + reverseEngineeringTree.addMouseListener(new MouseAdapter() { + @Override + public void mouseClicked(MouseEvent e) { + if (reverseEngineeringTree.getRowForLocation(e.getX(), e.getY()) == -1) { + reverseEngineeringTree.setSelectionRow(-1); + } + + if (SwingUtilities.isRightMouseButton(e)) { + if (reverseEngineeringTree.isEditing()) { + return; + } + int row = reverseEngineeringTree.getClosestRowForLocation(e.getX(), e.getY()); + reverseEngineeringTree.setSelectionRow(row); + DefaultPopUpMenu popupMenu; + DbImportTreeNode selectedElement; + if (reverseEngineeringTree.getSelectionPath() != null) { + selectedElement = reverseEngineeringTree.getSelectedNode(); + popupMenu = popups.get(selectedElement.getUserObject().getClass()); + } else { + selectedElement = reverseEngineeringTree.getRootNode(); + popupMenu = popups.get(ReverseEngineering.class); + } + if (popupMenu != null) { + popupMenu.setProjectController(projectController); + popupMenu.setSelectedElement(selectedElement); + popupMenu.setParentElement((DbImportTreeNode) selectedElement.getParent()); + popupMenu.setTree(reverseEngineeringTree); + popupMenu.show(e.getComponent(), e.getX(), e.getY()); + } + } else if (reverseEngineeringTree.getSelectionPath() != null) { + DbImportTreeNode findedNode = dbSchemaTree.findNode( + dbSchemaTree.getRootNode(), reverseEngineeringTree.getSelectedNode(), 0 + ); + if (findedNode != null) { + dbSchemaTree.expandPath(new TreePath(((DbImportTreeNode) findedNode.getParent()).getPath())); + scrollToNode(dbSchemaTree, findedNode); + } + } + } + }); + } + + private void scrollToNode(JTree tree, DbImportTreeNode node) { + TreePath path = new TreePath(node.getPath()); + tree.scrollPathToVisible(path); + DraggableTreePanel parentPanel = ((DraggableTreePanel) dbSchemaTree.getParent().getParent()); + parentPanel.getHorizontalScrollBar().setValue(0); + } + + private ReverseEngineering getReverseEngineeringBySelectedMap() { + DataMap dataMap = projectController.getCurrentDataMap(); + return projectController.getApplication().getMetaData().get(dataMap, ReverseEngineering.class); + } + + private void changeIcons() { + // Deleting standard tree icons + DefaultTreeCellRenderer renderer = (DefaultTreeCellRenderer) reverseEngineeringTree.getCellRenderer(); + renderer.setLeafIcon(null); + renderer.setClosedIcon(null); + renderer.setOpenIcon(null); + } + + public DbImportTree getReverseEngineeringTree() { + return reverseEngineeringTree; + } + + void setTreeToolbar(TreeToolbarPanel treeToolbar) { + this.treeToolbar = treeToolbar; + } +} http://git-wip-us.apache.org/repos/asf/cayenne/blob/51289d1c/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/editor/dbimport/TreeToolbarPanel.java ---------------------------------------------------------------------- diff --git a/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/editor/dbimport/TreeToolbarPanel.java b/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/editor/dbimport/TreeToolbarPanel.java new file mode 100644 index 0000000..cb1ee9b --- /dev/null +++ b/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/editor/dbimport/TreeToolbarPanel.java @@ -0,0 +1,231 @@ +/***************************************************************** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + ****************************************************************/ + +package org.apache.cayenne.modeler.editor.dbimport; + +import org.apache.cayenne.dbsync.reverse.dbimport.Catalog; +import org.apache.cayenne.dbsync.reverse.dbimport.ExcludeColumn; +import org.apache.cayenne.dbsync.reverse.dbimport.ExcludeProcedure; +import org.apache.cayenne.dbsync.reverse.dbimport.ExcludeTable; +import org.apache.cayenne.dbsync.reverse.dbimport.IncludeColumn; +import org.apache.cayenne.dbsync.reverse.dbimport.IncludeProcedure; +import org.apache.cayenne.dbsync.reverse.dbimport.IncludeTable; +import org.apache.cayenne.dbsync.reverse.dbimport.ReverseEngineering; +import org.apache.cayenne.dbsync.reverse.dbimport.Schema; +import org.apache.cayenne.modeler.ProjectController; +import org.apache.cayenne.modeler.action.dbimport.AddCatalogAction; +import org.apache.cayenne.modeler.action.dbimport.AddExcludeColumnAction; +import org.apache.cayenne.modeler.action.dbimport.AddExcludeProcedureAction; +import org.apache.cayenne.modeler.action.dbimport.AddExcludeTableAction; +import org.apache.cayenne.modeler.action.dbimport.AddIncludeColumnAction; +import org.apache.cayenne.modeler.action.dbimport.AddIncludeProcedureAction; +import org.apache.cayenne.modeler.action.dbimport.AddIncludeTableAction; +import org.apache.cayenne.modeler.action.dbimport.AddPatternParamAction; +import org.apache.cayenne.modeler.action.dbimport.AddSchemaAction; +import org.apache.cayenne.modeler.action.dbimport.DeleteNodeAction; +import org.apache.cayenne.modeler.action.dbimport.EditNodeAction; +import org.apache.cayenne.modeler.action.GetDbConnectionAction; +import org.apache.cayenne.modeler.action.dbimport.TreeManipulationAction; +import org.apache.cayenne.modeler.dialog.db.load.DbImportTreeNode; +import org.apache.cayenne.modeler.editor.dbimport.DbImportTree; +import org.apache.cayenne.modeler.editor.dbimport.DraggableTreePanel; + +import javax.swing.JButton; +import javax.swing.JToolBar; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** + * @since 4.1 + */ +class TreeToolbarPanel extends JToolBar { + + private JButton schemaButton; + private JButton catalogButton; + private JButton includeTableButton; + private JButton excludeTableButton; + private JButton includeColumnButton; + private JButton excludeColumnButton; + private JButton includeProcedureButton; + private JButton excludeProcedureButton; + private JButton editButton; + private JButton deleteButton; + private JButton configureButton; + private DbImportTree reverseEngineeringTree; + + private Map<Class, List<JButton>> levels; + private ProjectController projectController; + + TreeToolbarPanel(ProjectController projectController, DbImportTree reverseEngineeringTree, DraggableTreePanel treePanel) { + this.projectController = projectController; + this.reverseEngineeringTree = reverseEngineeringTree; + createButtons(treePanel); + initLevels(); + addButtons(); + } + + void unlockButtons() { + changeToolbarButtonsState(true); + editButton.setEnabled(false); + deleteButton.setEnabled(false); + } + + private boolean isLabelSelected() { + DbImportTreeNode selectedNode = reverseEngineeringTree.getSelectedNode(); + if (selectedNode.getUserObject().getClass() == String.class) { + return true; + } + return false; + } + + void lockButtons() { + if ((reverseEngineeringTree.getLastSelectedPathComponent() != null) && (!isLabelSelected())) { + DbImportTreeNode selectedNode = ((DbImportTreeNode) reverseEngineeringTree.getLastSelectedPathComponent()); + DbImportTreeNode parentNode = (DbImportTreeNode) selectedNode.getParent(); + if (parentNode != null) { + lockButtons(parentNode.getUserObject()); + } else { + unlockButtons(); + } + } else { + changeToolbarButtonsState(true); + editButton.setEnabled(false); + deleteButton.setEnabled(false); + } + if (reverseEngineeringTree.getSelectionPaths() != null) { + if (reverseEngineeringTree.getSelectionPaths().length > 1) { + changeToolbarButtonsState(false); + deleteButton.setEnabled(true); + } + } + } + + private void initLevels() { + levels = new HashMap<>(); + + List<JButton> rootLevelButtons = new ArrayList<>(); + rootLevelButtons.add(catalogButton); + rootLevelButtons.add(schemaButton); + rootLevelButtons.add(includeTableButton); + rootLevelButtons.add(excludeTableButton); + rootLevelButtons.add(includeColumnButton); + rootLevelButtons.add(excludeColumnButton); + rootLevelButtons.add(includeProcedureButton); + rootLevelButtons.add(excludeProcedureButton); + + List<JButton> catalogLevelButtons = new ArrayList<>(); + catalogLevelButtons.add(schemaButton); + catalogLevelButtons.add(includeTableButton); + catalogLevelButtons.add(excludeTableButton); + catalogLevelButtons.add(includeColumnButton); + catalogLevelButtons.add(excludeColumnButton); + catalogLevelButtons.add(includeProcedureButton); + catalogLevelButtons.add(excludeProcedureButton); + + List<JButton> schemaLevelButtons = new ArrayList<>(); + schemaLevelButtons.add(includeTableButton); + schemaLevelButtons.add(excludeTableButton); + schemaLevelButtons.add(includeColumnButton); + schemaLevelButtons.add(excludeColumnButton); + schemaLevelButtons.add(includeProcedureButton); + schemaLevelButtons.add(excludeProcedureButton); + + List<JButton> includeTableLevelButtons = new ArrayList<>(); + includeTableLevelButtons.add(includeColumnButton); + includeTableLevelButtons.add(excludeColumnButton); + + levels.put(ReverseEngineering.class, rootLevelButtons); + levels.put(Catalog.class, catalogLevelButtons); + levels.put(Schema.class, schemaLevelButtons); + levels.put(IncludeTable.class, includeTableLevelButtons); + } + + private void addButtons() { + this.setFloatable(false); + this.add(catalogButton); + this.add(schemaButton); + this.addSeparator(); + this.add(includeTableButton); + this.add(excludeTableButton); + this.add(includeColumnButton); + this.add(excludeColumnButton); + this.add(includeProcedureButton); + this.add(excludeProcedureButton); + this.add(editButton); + this.addSeparator(); + this.add(deleteButton); + this.add(configureButton); + } + + void changeToolbarButtonsState(boolean state) { + schemaButton.setEnabled(state); + catalogButton.setEnabled(state); + includeTableButton.setEnabled(state); + excludeTableButton.setEnabled(state); + includeColumnButton.setEnabled(state); + excludeColumnButton.setEnabled(state); + includeProcedureButton.setEnabled(state); + excludeProcedureButton.setEnabled(state); + editButton.setEnabled(state); + deleteButton.setEnabled(state); + } + + private void lockButtons(Object userObject) { + changeToolbarButtonsState(false); + List<JButton> buttons = levels.get(userObject.getClass()); + for (JButton button : buttons) { + button.setEnabled(true); + } + editButton.setEnabled(true); + deleteButton.setEnabled(true); + } + + private <T extends TreeManipulationAction> JButton createButton(Class<T> actionClass, int position) { + TreeManipulationAction action = projectController.getApplication().getActionManager().getAction(actionClass); + action.setTree(reverseEngineeringTree); + return action.buildButton(position); + } + + private <T extends AddPatternParamAction> JButton createButton(Class<T> actionClass, int position, Class paramClass) { + AddPatternParamAction action = projectController.getApplication().getActionManager().getAction(actionClass); + action.setTree(reverseEngineeringTree); + action.setParamClass(paramClass); + return action.buildButton(position); + } + + private void createButtons(DraggableTreePanel panel) { + schemaButton = createButton(AddSchemaAction.class, 0); + catalogButton = createButton(AddCatalogAction.class, 0); + includeTableButton = createButton(AddIncludeTableAction.class, 1); + excludeTableButton = createButton(AddExcludeTableAction.class, 2, ExcludeTable.class); + includeColumnButton = createButton(AddIncludeColumnAction.class, 2, IncludeColumn.class); + excludeColumnButton = createButton(AddExcludeColumnAction.class, 2, ExcludeColumn.class); + includeProcedureButton = createButton(AddIncludeProcedureAction.class, 2, IncludeProcedure.class); + excludeProcedureButton = createButton(AddExcludeProcedureAction.class, 3, ExcludeProcedure.class); + editButton = createButton(EditNodeAction.class, 0); + DeleteNodeAction deleteNodeAction = projectController.getApplication().getActionManager().getAction(DeleteNodeAction.class); + deleteNodeAction.setTree(reverseEngineeringTree); + deleteNodeAction.setPanel(panel); + deleteButton = deleteNodeAction.buildButton(0); + GetDbConnectionAction action = projectController.getApplication().getActionManager().getAction(GetDbConnectionAction.class); + configureButton = action.buildButton(0); + } +} http://git-wip-us.apache.org/repos/asf/cayenne/blob/51289d1c/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/graph/extension/GraphHandler.java ---------------------------------------------------------------------- diff --git a/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/graph/extension/GraphHandler.java b/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/graph/extension/GraphHandler.java index 1efdd60..0870ef7 100644 --- a/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/graph/extension/GraphHandler.java +++ b/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/graph/extension/GraphHandler.java @@ -23,8 +23,6 @@ import java.util.Map; import javax.swing.undo.UndoableEdit; -import org.apache.cayenne.configuration.DataChannelDescriptor; -import org.apache.cayenne.configuration.xml.DataChannelLoaderListener; import org.apache.cayenne.configuration.xml.NamespaceAwareNestedTagHandler; import org.apache.cayenne.modeler.Application; import org.apache.cayenne.modeler.graph.GraphBuilder; @@ -37,10 +35,6 @@ import org.xml.sax.Attributes; import org.xml.sax.ContentHandler; import org.xml.sax.SAXException; -import javax.swing.undo.UndoableEdit; -import java.util.HashMap; -import java.util.Map; - /** * Class to load graph from XML */ http://git-wip-us.apache.org/repos/asf/cayenne/blob/51289d1c/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/undo/DbImportTreeUndoableEdit.java ---------------------------------------------------------------------- diff --git a/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/undo/DbImportTreeUndoableEdit.java b/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/undo/DbImportTreeUndoableEdit.java index 9e7c81e..cd99859 100644 --- a/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/undo/DbImportTreeUndoableEdit.java +++ b/modeler/cayenne-modeler/src/main/java/org/apache/cayenne/modeler/undo/DbImportTreeUndoableEdit.java @@ -22,7 +22,7 @@ package org.apache.cayenne.modeler.undo; import org.apache.cayenne.dbsync.reverse.dbimport.ReverseEngineering; import org.apache.cayenne.modeler.ProjectController; import org.apache.cayenne.modeler.dialog.db.load.DbImportTreeNode; -import org.apache.cayenne.modeler.editor.DbImportTree; +import org.apache.cayenne.modeler.editor.dbimport.DbImportTree; import javax.swing.undo.AbstractUndoableEdit; import javax.swing.undo.CannotRedoException;
