treejuxtaposer.java

生物物种进化历程的演示

	    mainFrame.validate();
	} else {
	    int numTrees = (treeArgs > treeCount) ? treeArgs : treeCount;

	    if (matrix) { 

		Toolkit toolkit = Toolkit.getDefaultToolkit();
		Dimension screendim = toolkit.getScreenSize();
		mainFrame.setSize(screendim.width-10, screendim.height-30);
		        
		mainFrame.setLocation(10,30);
		//int cph  = controlPanel.getHeight();
		int cph = 100;
		width = (screendim.width - 20 - hgap*(numTrees-1))/numTrees;
		height = (screendim.height - 30 - cph - vgap*(numTrees-1))/numTrees;
		drawPanel.setSize(screendim.width, screendim.height-cph);
		drawLayout = new GridLayout(0,numTrees,hgap,vgap);
		drawPanel.setLayout( drawLayout );
		drawPanel.validate();
		//System.out.println("scr w " + screendim.width + " scr h " + screendim.height + " w " + width + " h " + height + " cph " + cph);
		//mainFrame.pack();
		mainFrame.validate();
	    } else {
			System.out.println("mainFrame validate :");	
			
		// please set this to 0 here in order to avoid the 'invalid-drawable'
		// problem on macosx
		// I think the problem is, that the canvas set its own w and h 
		// so don't mess with that guy. he is awkward and don't likes
		// sizes other then 0 at startup - Yes I know that this is strange...
		height = 0;// drawPanel.getHeight();
		width = 0;//drawPanel.getWidth()/numTrees;
       
//		drawPanel.setSize(width, height);
//		drawPanel.validate();
		mainFrame.validate();

		System.out.println("mainFrame validate :");
	    }
	}	

	/**
	 * Construct the data structures for structural comparison and
	 * highlight
	 **/

	trees.add(newTree);
//	TPs.addTree(newTree, edgeweightLevels);

	//newTree.printLeaves();
	addLeaves();

	/**
	 * Create and add the drawer(s) for the tree
	 **/
	if (matrix) {
		TPs.addTree(newTree, edgeweightLevels);
	    // matrix mode is n by n grid, where n is total number of
	    // trees (like scatterplot matrix). there are n rows where
	    // each tree is drawn n times: once with no highlights in
	    // column that corresponds to own row (i.e. the diagonal),
	    // and highlighted by the tree corresponding to that
	    // column. example diagram for three trees: capital letter
	    // is tree drawn, lower case is which tree it's
	    // highlighted against.

            // A   A/b  A/c
            // B/a B    B/c
	    // C/a C/b  C

	    // because of the way the gridlayout works, we can't just
	    // add new components because there's no way to rearrange
	    // or insert at specific locations. so just clear the
	    // panel and then insert everything in the correct order.

	    // reshape before removing, otherwise command is ignored.
	    // nope, this doesn't work either.
	    Iterator tdIter = treeDrawers.iterator();
	    while (tdIter.hasNext()) {
		AccordionTreeDrawer atd = (AccordionTreeDrawer)tdIter.next();
		atd.reshape(width,height);
		atd.requestRedraw();
	    }
	    drawPanel.removeAll();
	    ArrayList newRow = new ArrayList();
	    ATDMatrix.add(newRow);
	    for (int row = 0; row < treeCount; row++ ) {
		ArrayList ATDRow = (ArrayList) ATDMatrix.get(row);
		for (int col = 0; col < treeCount; col++) {
		    int index = row*treeCount+col;
		    //System.out.println("row " + row + " col " + col + " ind " + index + " tc " + treeCount + " TDsize " + treeDrawers.size());
		    if (row >= treeCount-1 || col >= treeCount-1) {
			// add new one
			Tree treeToUse;
			if (row == treeCount-1 && 0 == col) {
			    // use new tree for the first new ATD on bottom row
			    treeToUse = newTree;
			    //System.out.println("use tree row " + row + " col " + col);
			} else {
			    // clone the tree, this isn't the first new ATD
			    treeToUse = new Tree(((AccordionTreeDrawer)ATDRow.get(0)).tree);
			    treeToUse.setKey(treeCount);
			    TPs.addTree(treeToUse, edgeweightLevels);
			    //System.out.println("add tree row " + row + " col " + col);
			}
			AccordionTreeDrawer newATD = (AccordionTreeDrawer) addATD(treeToUse, width, height);
			ATDRow.add(newATD);
		    } else {
			// tell old one it got smaller
			//((AccordionTreeDrawer)ATDRow.get(col)).reshape(width,height);
			//((AccordionTreeDrawer)ATDRow.get(col)).requestRedraw();
			//System.out.println("shrink tree row " + row + " col " + col);
		    }
		}
	    }
	    // can't set structural differences until all the new ATDs have been made
	    for (int row = 0; row < treeCount; row++ ) {
		ArrayList ATDRow = (ArrayList) ATDMatrix.get(row);
		for (int col = 0; col < treeCount; col++) {
		    ArrayList ATDCol = (ArrayList) ATDMatrix.get(col);
		    int index = row*treeCount+col;
		    if (showStructDiffs == true) {
			if (row != col && (row >= treeCount-1 || col >= treeCount-1 )) {
				AccordionTreeDrawer atdA = (AccordionTreeDrawer)ATDRow.get(col);
				AccordionTreeDrawer atdB = (AccordionTreeDrawer)ATDCol.get(row);
			    doStructuralDiff(atdA, atdB, diffGroup);

				Tree2Tree t2t = TPs.getPair(atdA.tree, atdB.tree);  // new subtree => forest preprocessing:
				t2t.subtree2Forest(atdA, atdB, edgeweightLevels); //    matrix mode untested
			    //System.out.println("SD row " + row + " col " + col + " ind " + index + " tc " + treeCount);
			}
		    }
		    AccordionTreeDrawer ATD = (AccordionTreeDrawer)ATDRow.get(col);
		    drawPanel.add(ATD);
		    //System.out.println("adding panel for " + row + " " + col + " atdkey " + ATD.getKey() + " treekey " + ATD.tree.getKey());
		    //ATD.requestRedraw();
		}
	    }
	    // create color trees for faster color lookup
		RangeList diffGroupRangeList = getGroup(diffGroup);
	} else {
	    addATD(newTree, width, height);
		TPs.addTree(newTree, edgeweightLevels);
	    if (showStructDiffs == true) {
		for (int i = 0; i < treeDrawers.size()-1; i++) {
			AccordionTreeDrawer atdA = (AccordionTreeDrawer)treeDrawers.get(i);
			AccordionTreeDrawer atdB = (AccordionTreeDrawer)treeDrawers.get(treeCount-1);
		    doStructuralDiff((AccordionTreeDrawer)treeDrawers.get(i), 
				     (AccordionTreeDrawer)treeDrawers.get(treeCount-1), 
				     diffGroup);
		    doStructuralDiff((AccordionTreeDrawer)treeDrawers.get(treeCount-1), 
				     (AccordionTreeDrawer)treeDrawers.get(i), 
				     diffGroup);
			Tree2Tree t2t = TPs.getPair(atdA.tree, atdB.tree); // new subtree => forest preprocessing:
			t2t.subtree2Forest(atdA, atdB, edgeweightLevels);
		}
//		System.out.println("Number of differences: " + ((RangeList)groups.get(diffGroup)).getRanges().size());
//		System.out.println("Difference groups: " + groups.get(diffGroup));
		// create color trees for faster color lookup
//		RangeList diffGroupRangeList = getGroup(diffGroup);
//		diffGroupRangeList.setColorTree(new ColorTree(diffGroupRangeList));
	    }
	    Component c = ((AccordionTreeDrawer)treeDrawers.get(treeCount-1)).getCanvas();
	    drawPanel.add(c);
	}
	
	drawPanel.validate();
	mainFrame.validate();
	mainFrame.repaint();
	drawPanel.repaint();
	requestRedrawAll();
 //  drawWithViewDirection();	
    }

// TODO: this all belongs in ATD, in a MUCH better way
//	public void setHorizontalDirection(){
//		viewDirection=1;
//		drawWithViewDirection();
//	}
//
//	public void setVerticalDirection(){
//		viewDirection=0;	
//		drawWithViewDirection();
//	}
//
//   public void drawWithViewDirection()
//   {
//	int k = treeDrawers.size();
//	   String[] file = new String[k];
//	   int[] number = new int[k];
//	   for(int i=0; i<k; i++)
//	   {
//		  file[i] = ((AccordionTreeDrawer)treeDrawers.get(i)).getTree().getName();
//		  number[i] = ((AccordionTreeDrawer)treeDrawers.get(i)).getTree().getNumber();
//	   }
//	   for(int i=0; i<k; i++)
//		 deleteTree(file[i]);
//	   GridLayout newLayout = null;
//	  if(viewDirection==1)
//	  	newLayout = new GridLayout(1,0,8,0);
//	  else
//		newLayout = new GridLayout(0,1,0,8);
//	  drawPanel.setLayout(newLayout);
//	  	for(int i=0; i<k; i++)
//	  	    if (number[i] == 0)
//	  	        loadNewickTree(file[i]);
//	  	    else
//	  	    {
//	  	        Vector v = new Vector();
//	  	        v.add(new Integer(number[i]));
//	  	        loadNexusTree(file[i], v);
//	  	    }
//
//   }			 		  
//   
//// draw Rite Left butterfly layout
//   public void drawRL()
//   {
//   	winSize[0] = this.mainFrame.getSize().width;
//   	winSize[1] = this.mainFrame.getSize().height;
//   	drawButterFly = true;
//	int k = treeDrawers.size();
//		String[] file = new String[k];
//		for(int i=0; i<k; i++)
//		   file[i] = ((AccordionTreeDrawer)treeDrawers.get(i)).getTree().getName();
//	    for(int i=0; i<k; i++)
//		  deleteTree(file[i]);  
//
//		 for(int i=0; i<k; i++)
//         {
//         	if(i%2==0)
//         	{
//         		setLeftRight(0);			 
//				loadNewickTree(file[i]);
//         	}
//         	else 
//         	{
//         		setLeftRight(1);				
//				loadNewickTree(file[i]);
//         	}
//         }
////         drawButterFly = false;
//   }
//
//// draw Rite Rite butterfly layout
//   public void drawRR()
//   {
//	winSize[0] = this.mainFrame.getSize().width;
//	winSize[1] = this.mainFrame.getSize().height;
//	drawButterFly = true;
//  	
//	int k = treeDrawers.size();
//	String[] file = new String[k];
//	for(int i=0; i<k; i++)
//	   file[i] = ((AccordionTreeDrawer)treeDrawers.get(i)).getTree().getName();
//	for(int i=0; i<k; i++)
//		deleteTree(file[i]);
//	setLeftRight(0);
//	 for(int i=0; i<k; i++)
//		loadNewickTree(file[i]);
////	drawButterFly = false;
//   }
//   
//  // draw Up Up  
//   public void drawUU()
//	 {
//		winSize[0] = this.mainFrame.getSize().width;
//		winSize[1] = this.mainFrame.getSize().height;
//		drawButterFly = true;
//	 	
//	 	int k = treeDrawers.size();
//	 	String[] file = new String[k];
//	 	for(int i=0; i<k; i++)
//	       file[i] = ((AccordionTreeDrawer)treeDrawers.get(i)).getTree().getName();
//		for(int i=0; i<k; i++)
//			deleteTree(file[i]);
//	    setLeftRight(2);
//	     for(int i=0; i<k; i++)
//	        loadNewickTree(file[i]);
////	        drawButterFly = false;
//	 }
//   
//	// draw Down Down  
//	  public void drawDD()
//		{
//			winSize[0] = this.mainFrame.getSize().width;
//			winSize[1] = this.mainFrame.getSize().height;
//			drawButterFly = true;
//			
//			int k = treeDrawers.size();
//		   String[] file = new String[k];
//		   for(int i=0; i<k; i++)
//		    file[i] = ((AccordionTreeDrawer)treeDrawers.get(i)).getTree().getName();
//		  for(int i=0; i<k; i++)
//		   deleteTree(file[i]);	
//		 setLeftRight(3);
//		 for(int i=0; i<k; i++)
//			loadNewickTree(file[i]);
////			drawButterFly = false;
//		}
//   
//   
//// draw Rite Left butterfly layout
//   public void drawLL()
//   {
//	winSize[0] = this.mainFrame.getSize().width;
//	winSize[1] = this.mainFrame.getSize().height;
//	drawButterFly = true;
//   	
//	int k = treeDrawers.size();
//	String[] file = new String[k];
//	for(int i=0; i<k; i++)
//	   file[i] = ((AccordionTreeDrawer)treeDrawers.get(i)).getTree().getName();
//	for(int i=0; i<k; i++)
//	deleteTree(file[i]);
//	
//	setLeftRight(1);
//	 for(int i=0; i<k; i++)
//		loadNewickTree(file[i]);
//     drawButterFly = false;
//   }
/**
 * draw independent resize window
 *
 */
/*	public void drawIndependentResizeWindow(){
		        int k = treeDrawers.size();
			   JSplitPane[] jsp = new JSplitPane[10];
			   Canvas[]  temp = new Canvas[10];	     
			  JPanel[] jp = new JPanel[10];
				for(int i =0 ; i< jp.length; i++)
				{
				 jp[i] = new JPanel();
				 jp[i].setMinimumSize(new Dimension(10,10));
				 jp[i].setLayout(new BorderLayout());
				} 
			  for(int i=0; i<treeDrawers.size();i++){						
				  temp[i] = (AccordionTreeDrawer)treeDrawers.get(i);
//				  temp[i].setSize(0,0);		
				  jp[i].add(temp[i]);
			  }		  			
		   int wh;
		   if(viewDirection == 1)
			 wh = mainFrame.getSize().width;
			 else
			 wh = mainFrame.getHeight()-30; 
                   
            jsp[0] = new JSplitPane(viewDirection, jp[0], jp[1]);
			 if(k==1)
				 jsp[0].setDividerLocation(wh);  
		    else if(k == 2){
			 	jsp[0] = new JSplitPane(viewDirection, jp[0], jp[1]);
				jsp[0].setDividerLocation(wh/2);
				jsp[0].setContinuousLayout(true);
			 }				                    
             for(int i=2; i<k; i++){
                    jsp[i-2].setDividerLocation(wh*(i-1)/k);
                    jsp[i-2].setContinuousLayout(true);
                 	jsp[i-1] = new JSplitPane(viewDirection, jsp[i-2], jp[i]);
                 	jsp[i-1].setDividerLocation(wh*i/k);
                 	jsp[i-1].setContinuousLayout(true);          
		   }	
		   mainFrame.removeAll();
		   if(k == 0){}
		   else if(k<=2)
			mainFrame.add(jsp[0], BorderLayout.CENTER);		
			else
		    mainFrame.add(jsp[k-2], BorderLayout.CENTER);
//			drawPanel.add(c); 
//			drawPanel.validate();
    		mainFrame.validate();	
//		    mainFrame.repaint();
		  }	
*/


    /**
     * Utility function to make new AccordionTreeDrawer, set initial
     * parameters and do treeDrawer list bookkeeping.
     * @author Tamara Munzner
     */
    private AccordionTreeDrawerFinal addATD(Tree newTree,int width,int height) {
	AccordionTreeDrawerFinal ATD = new AccordionTreeDrawerFinal(newTree, width, height, this);
	ATD.setBackgroundColor(backgroundColor);
	ATD.setObjectColor(objectColor);
	ATD.setLabelColor(labelColor);
	ATD.setLabelBackColor(labelBackColor);
	ATD.setLabelHiColor(labelHiColor);
	ATD.setLabelBackHiColor(labelBackHiColor);
	ATD.setRubberbandColor(Color.getHSBColor(0.0f/360f,.0f,0.3f));