stateframe.java

生物物种进化历程的演示

	gbc.gridwidth = 1;
	gbc.ipadx = 0;
	clearButton = new JButton[clearLabel.length];
	gbc.gridy = 2;
	gbc.fill = GridBagConstraints.NONE;
	for (int i = 0; i < clearLabel.length; i++)
	{
		clearButton[i] = new JButton(clearLabel[i]);
		gbc.gridx = i;
		markPanel.add(clearButton[i], gbc);
	}
	gbc.gridx = clearLabel.length;
	markPanel.add(new JPanel(), gbc);

	resolutionPanel = new JPanel();
	//resolutionPanel.setBorder(javax.swing.BorderFactory.createLineBorder(Color.black));
	markResolution = new ButtonGroup();
	resolutionMode = new JRadioButton[resolutionLabel.length];
	gbc.gridy = 0;
	gbc.gridx = 0;
	resolutionPanel.add(resolutionTitle, gbc);
	for (int i = 0; i < resolutionLabel.length; i++)
	{
		resolutionMode[i] = new JRadioButton(resolutionLabel[i]);
		markResolution.add(resolutionMode[i]);
		gbc.gridx = i + 1;
		resolutionPanel.add(resolutionMode[i], gbc);
	}
	
	LCAMark = new JCheckBox(LCA, false);
	gbc.gridx = gbc.gridx + 1;
	gbc.anchor = GridBagConstraints.EAST;
	resolutionPanel.add(LCAMark, gbc);
	gbc.anchor = GridBagConstraints.CENTER;
		
	gbc.gridx = clearLabel.length + 1;
	gbc.gridy = 2;
	markPanel.add(resolutionPanel, gbc);

	/* Mark panel events */
	markCanvas[GA_ACT].addMouseListener(this);
	markCanvas[GB_ACT].addMouseListener(this);
	markCanvas[GC_ACT].addMouseListener(this);
	markCanvas[GD_ACT].addMouseListener(this);
	
	clearButton[G_CLEAR].addActionListener(this);
	clearButton[A_CLEAR].addActionListener(this);
	
	markMode[GA_ACT].addActionListener(this);
	markMode[GB_ACT].addActionListener(this);
	markMode[GC_ACT].addActionListener(this);
	markMode[GD_ACT].addActionListener(this);

	resolutionMode[N_RES].addActionListener(this);
	resolutionMode[S_RES].addActionListener(this);
	
	LCAMark.addActionListener(this);
	
	gbc.ipadx = 0;
	gbc.ipady = 0;
	gbc.gridx = 0;
	gbc.gridwidth = 1;
	gbc.gridheight = 1;
	gbc.gridy = 0;
	gbc.fill = GridBagConstraints.BOTH;
	getContentPane().add(activePanel, gbc);
	gbc.gridy = 1;
	getContentPane().add(markPanel, gbc);
	pack();
	
	}

	public void prepareToShow()
	{
		System.out.println("prepare to show (state frame)");
		if (tj == null || tj.treeDrawers == null)
			return;
		observe();
	}

	public void growModeAction(int mode)
	{
		growMode[mode].setSelected(true);
		Iterator tdIter = tj.treeDrawers.iterator();
		while (tdIter.hasNext())
		{
			AccordionTreeDrawerFinal atd = (AccordionTreeDrawerFinal)tdIter.next();
			if (mode == B_MODE)
				atd.setGrowDirection(AccordionTreeDrawerFinal.ALL);
			else if (mode == H_MODE)
				atd.setGrowDirection(AccordionTreeDrawerFinal.HORIZ);
			else if (mode == V_MODE)
				atd.setGrowDirection(AccordionTreeDrawerFinal.VERT);
		}
	}

	public void activeModeAction(int mode)
	{
		int tjmode = TreeJuxtaposer.flashGroup;
		switch (mode) {
			case GA_ACT: tjmode = TreeJuxtaposer.markGroup[GA_ACT]; break;
			case GB_ACT: tjmode = TreeJuxtaposer.markGroup[GB_ACT]; break;
			case GC_ACT: tjmode = TreeJuxtaposer.markGroup[GC_ACT]; break;
			case GD_ACT: tjmode = TreeJuxtaposer.markGroup[GD_ACT]; break;
			case M_ACT: tjmode = TreeJuxtaposer.flashGroup; break;
			case F_ACT: tjmode = TreeJuxtaposer.foundGroup; break;
			case D_ACT: tjmode = TreeJuxtaposer.diffGroup; break;
			case LCA_ACT: tjmode = TreeJuxtaposer.lcaGroup; break;
		};
		Iterator tdIter = tj.treeDrawers.iterator();
		while (tdIter.hasNext())
		{
			AccordionTreeDrawerFinal atd = (AccordionTreeDrawerFinal)tdIter.next();
			atd.setActionGroup(tjmode);
		}
	}

	public void activeMarkAction(int mode)
	{
		markMode[mode].setSelected(true);
		Iterator tdIter = tj.treeDrawers.iterator();
		while (tdIter.hasNext())
		{
			AccordionTreeDrawerFinal atd = (AccordionTreeDrawerFinal)tdIter.next();
			atd.setMarkGroup(TreeJuxtaposer.markGroup[mode]);
		}
		tj.setGroupPriority(TreeJuxtaposer.markGroup[mode]);
	}

	public void activeResolutionAction(int mode)
	{
		resolutionMode[mode].setSelected(true);
		int atdmode = AccordionTreeDrawerFinal.SUBTREE;
		if (mode == N_RES) atdmode = AccordionTreeDrawerFinal.NODE;
		Iterator tdIter = tj.treeDrawers.iterator();
		while (tdIter.hasNext())
		{
			AccordionTreeDrawerFinal atd = (AccordionTreeDrawerFinal)tdIter.next();
			atd.setSelectionResolution(atdmode);
		}
	}
	
	public void unmarkAllGroups()
	{
		tj.unmarkGroup(TreeJuxtaposer.markGroup[GA_ACT]);
		tj.unmarkGroup(TreeJuxtaposer.markGroup[GB_ACT]);
		tj.unmarkGroup(TreeJuxtaposer.markGroup[GC_ACT]);
		tj.unmarkGroup(TreeJuxtaposer.markGroup[GD_ACT]);
		tj.unmarkGroup(TreeJuxtaposer.lcaGroup);
		LCAMark.setSelected(false);
	}

	// reflect choices made by keyboard or by selecting this panel
	public void observe()
	{
		if (tj.treeDrawers == null || tj.treeDrawers.size() == 0)
			return;
		AccordionTreeDrawerFinal atd = (AccordionTreeDrawerFinal)tj.treeDrawers.get(0);
		
		if (atd.getActionGroup() == TreeJuxtaposer.markGroup[0])
			activeMode[GA_ACT].setSelected(true);
		else if (atd.getActionGroup() == TreeJuxtaposer.markGroup[1])
			activeMode[GB_ACT].setSelected(true);
		else if (atd.getActionGroup() == TreeJuxtaposer.markGroup[2])
			activeMode[GC_ACT].setSelected(true);
		else if (atd.getActionGroup() == TreeJuxtaposer.markGroup[3])
			activeMode[GD_ACT].setSelected(true);
		else if (atd.getActionGroup() == TreeJuxtaposer.foundGroup)
			activeMode[F_ACT].setSelected(true);
		else if (atd.getActionGroup() == TreeJuxtaposer.diffGroup)
			activeMode[D_ACT].setSelected(true);
		else if (atd.getActionGroup() == TreeJuxtaposer.flashGroup)
			activeMode[M_ACT].setSelected(true);
		else if (atd.getActionGroup() == TreeJuxtaposer.lcaGroup)
					activeMode[LCA_ACT].setSelected(true);	
		else
		{
			System.out.println("bug: active mode (growing target) not set");
			for (int i = GA_ACT; i <= LCA_ACT; i++)
				activeMode[i].setSelected(false);
		}

		if (atd.getGrowDirection() == AccordionTreeDrawerFinal.HORIZ)
			growMode[H_MODE].setSelected(true);
		else if (atd.getGrowDirection() == AccordionTreeDrawerFinal.VERT)
			growMode[V_MODE].setSelected(true);
		else if (atd.getGrowDirection() == AccordionTreeDrawerFinal.ALL)
			growMode[B_MODE].setSelected(true);
		else
		{
			System.out.println("bug: action target (grow dir) not set");
			for (int i = H_MODE; i <= B_MODE; i++)
			growMode[i].setSelected(false);
		}
		
		if (atd.getSelectionResolution() == AccordionTreeDrawerFinal.SUBTREE)
			resolutionMode[S_RES].setSelected(true);
		else if (atd.getSelectionResolution() == AccordionTreeDrawerFinal.NODE)
			resolutionMode[N_RES].setSelected(true);
		else
		{
			System.out.println("bug: action target (resolution mode) not set");
			for (int i = N_RES; i <= S_RES; i++)
			resolutionMode[i].setSelected(false);
		}
		
		if (atd.getMarkGroup() == TreeJuxtaposer.markGroup[0])
			markMode[GA_ACT].setSelected(true);
		else if (atd.getMarkGroup() == TreeJuxtaposer.markGroup[1])
			markMode[GB_ACT].setSelected(true);
		else if (atd.getMarkGroup() == TreeJuxtaposer.markGroup[2])
			markMode[GC_ACT].setSelected(true);
		else if (atd.getMarkGroup() == TreeJuxtaposer.markGroup[3])
			markMode[GD_ACT].setSelected(true);
		else
		{
			System.out.println("bug: mark mode not set");
			for (int i = GA_ACT; i <= GD_ACT; i++)
				markMode[i].setSelected(false);
		}
	}
	
	public void actionPerformed(ActionEvent evt)
	{
		Object obj = evt.getSource();
		if (obj == resetButton)
		{
			tj.reset();
		}
		else if (obj == growMode[H_MODE] ||
			obj == growMode[V_MODE] ||
			obj == growMode[B_MODE])
		{
			int modeNum = H_MODE;
			if (obj == growMode[V_MODE]) modeNum = V_MODE;
			else if (obj == growMode[B_MODE]) modeNum = B_MODE;
			growModeAction(modeNum);
		}
		else if (obj == growButton[B_GROW] ||
			obj == growButton[S_GROW])
		{
			if (tj.treeDrawers.size() == 0)
				return;
			AccordionTreeDrawerFinal atd = (AccordionTreeDrawerFinal)tj.treeDrawers.get(0);
			int numSteps = (atd.jump) ? 1 : atd.getNumAnimSteps();
			boolean horiz = (atd.getGrowDirection() != AccordionTreeDrawerFinal.VERT);
			boolean vert = (atd.getGrowDirection() != AccordionTreeDrawerFinal.HORIZ);
//			if (atd.linkednav) // it makes no sense to only update one drawer, which one is picked?
			{
				tj.resizeGroup(tj.getGroup(atd.getActionGroup()), numSteps, obj == growButton[B_GROW], horiz, vert);
				tj.requestRedrawAll();
			}
//			else 
//			{
//				tj.resizeGroup(tj.getGroup(atd.getActionGroup()), numSteps, growBigger, horiz, vert, atd);
//				atd.
//			}
		}
		else if (obj == activeMode[GA_ACT] ||
			obj == activeMode[GB_ACT] ||
			obj == activeMode[GC_ACT] ||
			obj == activeMode[GD_ACT] ||
			obj == activeMode[M_ACT] ||
			obj == activeMode[F_ACT] ||
			obj == activeMode[D_ACT] ||
			obj == activeMode[LCA_ACT])
		{
			int mode = GA_ACT;
			((JRadioButton)obj).setSelected(true);
			if (obj == activeMode[GB_ACT]) mode = GB_ACT;
			else if (obj == activeMode[GC_ACT]) mode = GC_ACT;
			else if (obj == activeMode[GD_ACT]) mode = GD_ACT;
			else if (obj == activeMode[M_ACT]) mode = M_ACT;
			else if (obj == activeMode[F_ACT]) mode = F_ACT;
			else if (obj == activeMode[D_ACT]) mode = D_ACT;
			else if (obj == activeMode[LCA_ACT]) mode = LCA_ACT;
			activeModeAction(mode);
			tj.requestRedrawAll();
		}	
		else if (obj == clearButton[G_CLEAR])
		{
			if (markMode[GA_ACT].isSelected()) tj.unmarkGroup(TreeJuxtaposer.markGroup[GA_ACT]);
			else if (markMode[GB_ACT].isSelected()) tj.unmarkGroup(TreeJuxtaposer.markGroup[GB_ACT]);
			else if (markMode[GC_ACT].isSelected()) tj.unmarkGroup(TreeJuxtaposer.markGroup[GC_ACT]);
			else if (markMode[GD_ACT].isSelected()) tj.unmarkGroup(TreeJuxtaposer.markGroup[GD_ACT]);
			else unmarkAllGroups();
			tj.requestRedrawAll();
			tj.changedMarks();
		}
		else if (obj == clearButton[A_CLEAR])
		{
			unmarkAllGroups();
			tj.lcaNode.clear();
			tj.requestRedrawAll();
			tj.changedMarks();
		}
		else if (obj == markMode[GA_ACT] ||
			obj == markMode[GB_ACT] ||
			obj == markMode[GC_ACT] ||
			obj == markMode[GD_ACT])
		{
			int mode = GA_ACT;
			if (obj == markMode[GB_ACT]) mode = GB_ACT;
			else if (obj == markMode[GC_ACT]) mode = GC_ACT;
			else if (obj == markMode[GD_ACT]) mode = GD_ACT;
			activeMarkAction(mode);
			tj.requestRedrawAll();
		}	
		else if (obj == resolutionMode[N_RES] ||
			obj == resolutionMode[S_RES])
		{
			if (obj == resolutionMode[N_RES])
				activeResolutionAction(N_RES);
			else
				activeResolutionAction(S_RES);
		}
		else if (obj == LCAMark)
		{
			if(LCAMark.isSelected())			
			    for(int i=0; i<tj.treeDrawers.size(); i++)
			    tj.doLCAGeom(LCA_ACT, (AccordionTreeDrawerFinal)tj.treeDrawers.get(i));			
			else
			     tj.unmarkGroup(LCA_ACT);

			tj.requestRedrawAll();
			
		}
		else if (obj == LCAGroup)
		{
			System.out.println("LCAGroup: " + LCAGroup.isSelected());
		}
	}

	public void setLCAMark(boolean on) { LCAMark.setSelected(on); }
	public boolean getLCAMark() { return LCAMark.isSelected(); }
	public void setLCAGroup(boolean on) { LCAGroup.setSelected(on); }
	public boolean getLCAGroup() { return LCAGroup.isSelected(); }

	public void mouseClicked(MouseEvent evt)
	{
		Object obj = evt.getSource();
		if (obj == activeCanvas[GA_ACT] || obj == markCanvas[GA_ACT] ||
			obj == activeCanvas[GB_ACT] || obj == markCanvas[GB_ACT] ||
			obj == activeCanvas[GC_ACT] || obj == markCanvas[GC_ACT] ||
			obj == activeCanvas[GD_ACT] || obj == markCanvas[GD_ACT] ||
			obj == activeCanvas[M_ACT] ||
			obj == activeCanvas[D_ACT] ||
			obj == activeCanvas[F_ACT] ||
		    obj == activeCanvas[LCA_ACT]) 
		{
			int group = GA_ACT;
			int tjgroup = TreeJuxtaposer.markGroup[GA_ACT];
			if (obj == activeCanvas[GB_ACT] || obj == markCanvas[GB_ACT])
				{ group = GB_ACT; tjgroup = TreeJuxtaposer.markGroup[GB_ACT]; }
			else if (obj == activeCanvas[GC_ACT] || obj == markCanvas[GC_ACT])
				{ group = GC_ACT; tjgroup = TreeJuxtaposer.markGroup[GC_ACT]; }
			else if (obj == activeCanvas[GD_ACT] || obj == markCanvas[GD_ACT])
				{ group = GD_ACT; tjgroup = TreeJuxtaposer.markGroup[GD_ACT]; }
			else if (obj == activeCanvas[M_ACT])
				{ group = M_ACT; tjgroup = TreeJuxtaposer.flashGroup; }
			else if (obj == activeCanvas[D_ACT])
				{ group = D_ACT; tjgroup = TreeJuxtaposer.diffGroup; }
			else if (obj == activeCanvas[F_ACT])
				{ group = F_ACT; tjgroup = TreeJuxtaposer.foundGroup; } 
			else if (obj == activeCanvas[LCA_ACT])
				{ group = LCA_ACT; tjgroup = TreeJuxtaposer.lcaGroup; } 	
			Color newColor = JColorChooser.showDialog(activePanel, colorTitle[group], color[group]);
			if (newColor != null)
			{
				color[group] = newColor;
				activeCanvas[group].setBackground(color[group]);
				if (group == GA_ACT || group == GB_ACT || group == GC_ACT || group == GD_ACT)
					markCanvas[group].setBackground(color[group]);
				tj.setGroupColor(tjgroup, color[group]);
				tj.requestRedrawAll();
				tj.changedMarks();
			}
		}
	}

	public void mouseEntered(MouseEvent evt) {}
	public void mouseExited(MouseEvent evt) {}
	public void mousePressed(MouseEvent evt) {}
	public void mouseReleased(MouseEvent evt) {}
	
}