Changeset 48

Show
Ignore:
Timestamp:
02/21/10 15:53:06 (7 months ago)
Author:
ke
Message:

Removed setters and getters for nodeCaptions, edgeLabels and status in tree classes. Swapping dimensions in KahinaTreeView? is now handled in a less sacrilegious way.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • kahina/trunk/src/org/kahina/data/tree/KahinaDbTree.java

    r46 r48  
    22 
    33import java.util.List; 
    4 import java.util.Map; 
    54 
    65import org.kahina.io.database.DatabaseHandler; 
     
    5655        public void addChild(int parent, int child) 
    5756        { 
    58                 // TODO Auto-generated method stub 
    59  
     57                // add 
     58                // nach oben gehen und jedem 
    6059        } 
    6160 
     
    110109 
    111110        @Override 
    112         public Map<Integer, String> getEdgeLabels() 
    113         { 
    114                 // TODO Auto-generated method stub 
    115                 return null; 
    116         } 
    117  
    118         @Override 
    119111        public List<Integer> getLeaves() 
    120112        { 
     
    125117        @Override 
    126118        public String getNodeCaption(int nodeID) 
    127         { 
    128                 // TODO Auto-generated method stub 
    129                 return null; 
    130         } 
    131  
    132         @Override 
    133         public Map<Integer, String> getNodeCaptions() 
    134119        { 
    135120                // TODO Auto-generated method stub 
     
    166151 
    167152        @Override 
    168         public Map<Integer, Integer> getStatus() 
    169         { 
    170                 // TODO Auto-generated method stub 
    171                 return null; 
    172         } 
    173  
    174         @Override 
    175153        public boolean hasCollapsedAncestor(int nodeID) 
    176154        { 
     
    184162                // TODO Auto-generated method stub 
    185163                return false; 
    186         } 
    187  
    188         @Override 
    189         public void setEdgeLabels(Map<Integer, String> edgeLabels) 
    190         { 
    191                 // TODO Auto-generated method stub 
    192  
    193         } 
    194  
    195         @Override 
    196         public void setNodeCaptions(Map<Integer, String> nodeCaptions) 
    197         { 
    198                 // TODO Auto-generated method stub 
    199  
    200164        } 
    201165 
     
    215179 
    216180        @Override 
    217         public void setStatus(Map<Integer, Integer> status
     181        public void toggleCollapse(int nodeID
    218182        { 
    219183                // TODO Auto-generated method stub 
     
    222186 
    223187        @Override 
    224         public void toggleCollapse(int nodeID
     188        public int getSize(
    225189        { 
    226190                // TODO Auto-generated method stub 
    227  
     191                return 0; 
    228192        } 
    229193 
  • kahina/trunk/src/org/kahina/data/tree/KahinaTree.java

    r46 r48  
    4545        public abstract boolean isCollapsed(int nodeID); 
    4646 
    47         public abstract void setStatus(Map<Integer, Integer> status); 
    48  
    49         public abstract Map<Integer, Integer> getStatus(); 
    50  
    51         public abstract void setEdgeLabels(Map<Integer, String> edgeLabels); 
    52  
    53         public abstract Map<Integer, String> getEdgeLabels(); 
    54  
    55         public abstract void setNodeCaptions(Map<Integer, String> nodeCaptions); 
    56  
    57         public abstract Map<Integer, String> getNodeCaptions(); 
    58  
    5947        public abstract List<Integer> getLeaves(); 
    6048 
     
    7664 
    7765        public abstract int getRootID(int layerID); 
     66         
     67        public abstract int getSize(); 
    7868     
    7969    public String exportXML() 
  • kahina/trunk/src/org/kahina/data/tree/KahinaUnlayeredMemTree.java

    r46 r48  
    106106        else 
    107107        { 
     108                System.err.println("Caption: " + caption); // TODO 
    108109            return caption; 
    109110        } 
     
    180181            } 
    181182        } 
    182     } 
    183      
    184     @Override 
    185         public Map<Integer, String> getNodeCaptions() 
    186     { 
    187         return nodeCaptions; 
    188     } 
    189  
    190     @Override 
    191         public void setNodeCaptions(Map<Integer, String> nodeCaptions) 
    192     { 
    193         this.nodeCaptions = nodeCaptions; 
    194     } 
    195  
    196     @Override 
    197         public Map<Integer, String> getEdgeLabels() 
    198     { 
    199         return edgeLabels; 
    200     } 
    201  
    202     @Override 
    203         public void setEdgeLabels(Map<Integer, String> edgeLabels) 
    204     { 
    205         this.edgeLabels = edgeLabels; 
    206     } 
    207  
    208     @Override 
    209         public Map<Integer, Integer> getStatus() 
    210     { 
    211         return status; 
    212     } 
    213  
    214     @Override 
    215         public void setStatus(Map<Integer, Integer> status) 
    216     { 
    217         this.status = status; 
    218183    } 
    219184     
     
    311276        nextID = 0; 
    312277    } 
     278 
     279        @Override 
     280        public int getSize() 
     281        { 
     282                return nodeCaptions.size(); 
     283        } 
    313284     
    314285    // TODO find a good way to make this implementation-independent 
  • kahina/trunk/src/org/kahina/gui/breakpoint/BreakpointTestWindow.java

    r46 r48  
    1212import javax.swing.JScrollPane; 
    1313 
    14 import org.kahina.breakpoint.KahinaBreakpoint; 
    1514import org.kahina.breakpoint.TreeAutomaton; 
    1615import org.kahina.control.KahinaController; 
     
    122121        else if (s.equals("addRandomNode")) 
    123122        { 
    124             int parentNode = (int) (Math.random() * model.getNodeCaptions().size()); 
     123            int parentNode = (int) (Math.random() * model.getSize()); 
    125124            String caption = generateRandomNodeCaption(); 
    126125            view.setMarkedNode(addNode(parentNode, caption)); 
     
    286285                     
    287286                } 
    288                 int parentNode = (int) (Math.random() * model.getNodeCaptions().size()); 
     287                int parentNode = (int) (Math.random() * model.getSize()); 
    289288                String caption = generateRandomNodeCaption(); 
    290289                addNode(parentNode, caption); 
  • kahina/trunk/src/org/kahina/test/KahinaTreeTest.java

    r46 r48  
    4545            v0.display(m1,0,17); 
    4646            v0.displaySecondaryTree(m2); 
    47             v0.swapSecondDimensionDisplay(); 
     47            v0.toggleSecondDimensionDisplay(); 
    4848             
    4949            v0.setStatusColorEncoding(0,new Color(0,255,0)); 
     
    6060            v1.display(m1,1,17); 
    6161            v1.displaySecondaryTree(m2); 
    62             v1.swapSecondDimensionDisplay(); 
     62            v1.toggleSecondDimensionDisplay(); 
    6363             
    6464            v1.setStatusColorEncoding(0,new Color(0,255,0)); 
  • kahina/trunk/src/org/kahina/visual/tree/KahinaTreeView.java

    r46 r48  
    9292    KahinaTree secondaryTreeModel; 
    9393     
     94    private boolean dimensionsSwapped = false; 
     95     
    9496    //display coordinates for nodes 
    9597    private HashMap<Integer, Integer> nodeX; 
     
    229231    } 
    230232     
    231     public void swapSecondDimensionDisplay() 
     233    public void toggleSecondDimensionDisplay() 
    232234    { 
    233235        displaySecondDimension = !displaySecondDimension; 
     
    464466    public Font getNodeFont(int nodeID) 
    465467    { 
    466         int status = treeModel.getNodeStatus(nodeID); 
     468        int status = getContentfulTreeModel().getNodeStatus(nodeID); 
    467469        Font fnt = statusFontEncoding.get(status); 
    468470        if (fnt == null) 
     
    486488    public Color getNodeColor(int nodeID) 
    487489    { 
    488         int status = treeModel.getNodeStatus(nodeID); 
     490        int status = getContentfulTreeModel().getNodeStatus(nodeID); 
    489491        Color col = statusNodeColorEncoding.get(status); 
    490492        if (col == null) 
     
    588590        } 
    589591        treeLayer = 0; 
    590         this.treeModel = (KahinaMemTree) treeModel; 
     592        this.treeModel = (KahinaTree) treeModel; 
    591593        nodeBorderColor = new HashMap<Integer, Color>(); 
    592594        resetAllStructures(); 
     
    648650                for (int node : nodeLevels.get(i)) 
    649651                { 
    650                     int nodeLabelWidth = fm.stringWidth(treeModel.getNodeCaption(node)); 
     652                    int nodeLabelWidth = fm.stringWidth(getContentfulTreeModel().getNodeCaption(node)); 
    651653                    if (maxNodeWidth < nodeLabelWidth) maxNodeWidth = nodeLabelWidth; 
    652654                    ArrayList<Integer> children = getVisibleVirtualChildren(treeModel, node);            
     
    801803        if (nodeDisplayPolicy == KahinaTreeView.NEVER) return false; 
    802804        if (secondaryTreeModel != null && collapsePolicy == COLLAPSE_SECONDARY && secondaryTreeModel.hasCollapsedAncestor(nodeID)) return false; 
    803         int status = treeModel.getNodeStatus(nodeID); 
     805        int status = getContentfulTreeModel().getNodeStatus(nodeID); 
    804806        Boolean decision = statusVisibilityEncoding.get(status); 
    805807        if (decision == null) 
     
    894896        if (secondaryTreeModel != null) 
    895897        { 
     898                dimensionsSwapped = !dimensionsSwapped; 
    896899            KahinaTree firstModel = treeModel; 
    897900            treeModel = secondaryTreeModel; 
    898             treeModel.setNodeCaptions(firstModel.getNodeCaptions()); 
    899             treeModel.setEdgeLabels(firstModel.getEdgeLabels()); 
    900             treeModel.setStatus(firstModel.getStatus()); 
    901901            secondaryTreeModel = firstModel; 
    902902            resetAllStructures(); 
     
    956956            middleIndex = (lowerIndex + upperIndex)/2; 
    957957            FontMetrics fm = getFontMetrics(new Font(Font.SANS_SERIF,Font.PLAIN, fontSize), new BasicStroke(1), fontSize); 
    958             int width = fm.stringWidth(treeModel.getNodeCaption(selectedLevel.get(middleIndex))); 
     958            int width = fm.stringWidth(getContentfulTreeModel().getNodeCaption(selectedLevel.get(middleIndex))); 
    959959            middleBound = nodeX.get(selectedLevel.get(middleIndex)) + width / 2 + 2; 
    960960            if (nodePositionPolicy == KahinaTreeView.LEFT_ALIGNED_NODES) 
     
    978978                } 
    979979                middleIndex = (lowerIndex + upperIndex)/2; 
    980                 width = fm.stringWidth(treeModel.getNodeCaption(selectedLevel.get(middleIndex))); 
     980                width = fm.stringWidth(getContentfulTreeModel().getNodeCaption(selectedLevel.get(middleIndex))); 
    981981                middleBound = nodeX.get(selectedLevel.get(middleIndex)) + width / 2 - 2; 
    982982                if (nodePositionPolicy == KahinaTreeView.LEFT_ALIGNED_NODES) 
     
    997997        //test coordinates against exact boundaries of candidate node 
    998998        FontMetrics fm = getFontMetrics(new Font(Font.SANS_SERIF,Font.PLAIN, fontSize), new BasicStroke(1), fontSize); 
    999         int width = fm.stringWidth(treeModel.getNodeCaption(candidateNode)); 
     999        int width = fm.stringWidth(getContentfulTreeModel().getNodeCaption(candidateNode)); 
    10001000        int xLeft = getNodeX(candidateNode) - width / 2 - 2; 
    10011001        if (nodePositionPolicy == KahinaTreeView.LEFT_ALIGNED_NODES) 
     
    10371037        return treeModel; 
    10381038    } 
     1039     
     1040    public KahinaTree getContentfulTreeModel() 
     1041    { 
     1042        if (dimensionsSwapped) 
     1043        { 
     1044                return secondaryTreeModel; 
     1045        } else 
     1046        { 
     1047                return treeModel; 
     1048        } 
     1049    } 
    10391050} 
  • kahina/trunk/src/org/kahina/visual/tree/KahinaTreeViewListener.java

    r46 r48  
    252252        else if (command.equals("Display second dimension")) 
    253253        { 
    254             view.v.swapSecondDimensionDisplay(); 
     254            view.v.toggleSecondDimensionDisplay(); 
    255255        } 
    256256        else if (command.equals("Swap dimensions")) 
  • kahina/trunk/src/org/kahina/visual/tree/KahinaTreeViewPanel.java

    r34 r48  
    11package org.kahina.visual.tree; 
    22 
    3 import java.awt.*; 
     3import java.awt.BasicStroke; 
     4import java.awt.Color; 
     5import java.awt.Dimension; 
     6import java.awt.Font; 
     7import java.awt.FontMetrics; 
     8import java.awt.Graphics; 
     9import java.awt.Graphics2D; 
     10import java.awt.RenderingHints; 
    411import java.awt.image.BufferedImage; 
    512import java.util.List; 
    6  
    7 import javax.swing.*; 
    813 
    914import org.kahina.visual.KahinaViewPanel; 
     
    137142        canvas.setFont(v.getNodeFont(nodeID)); 
    138143        FontMetrics fm = canvas.getFontMetrics(); 
    139         int width = fm.stringWidth(v.treeModel.getNodeCaption(nodeID)); 
     144        int width = fm.stringWidth(v.getContentfulTreeModel().getNodeCaption(nodeID)); 
    140145        int x = v.getNodeX(nodeID) - width / 2; 
    141146        int y = v.getNodeY(nodeID) - v.getNodeHeight(nodeID) + 2; 
     
    174179        canvas.setFont(v.getNodeFont(nodeID)); 
    175180        FontMetrics fm = canvas.getFontMetrics(); 
    176         int width = fm.stringWidth(v.treeModel.getNodeCaption(nodeID)); 
     181        int width = fm.stringWidth(v.getContentfulTreeModel().getNodeCaption(nodeID)); 
    177182        int x = v.getNodeX(nodeID) - width / 2; 
    178183        int y = v.getNodeY(nodeID) - v.getNodeHeight(nodeID) + 2; 
     
    206211        canvas.setFont(v.getNodeFont(nodeID)); 
    207212        FontMetrics fm = canvas.getFontMetrics(); 
    208         String tag = v.treeModel.getNodeCaption(nodeID); 
     213        String tag = v.getContentfulTreeModel().getNodeCaption(nodeID); 
    209214        int width = fm.stringWidth(tag); 
    210215        canvas.setColor(Color.BLACK); 
     
    318323                                else if (v.getNodePositionPolicy() == KahinaTreeView.CENTERED_NODES) 
    319324                                { 
    320                                     int parentWidth = canvas.getFontMetrics().stringWidth(v.treeModel.getNodeCaption(parent)); 
    321                                     int nodeWidth = canvas.getFontMetrics().stringWidth(v.treeModel.getNodeCaption(node)); 
     325                                    int parentWidth = canvas.getFontMetrics().stringWidth(v.getContentfulTreeModel().getNodeCaption(parent)); 
     326                                    int nodeWidth = canvas.getFontMetrics().stringWidth(v.getContentfulTreeModel().getNodeCaption(node)); 
    322327                                    x1 -= parentWidth / 2; 
    323328                                    x2 -= nodeWidth / 2;