| gvSIG desktop 1

	private static final long serialVersionUID = 7989057553773181019L;

	private static ArrayList<Class<? extends ILegendPanel>> legendPool = new ArrayList<Class<? extends ILegendPanel>>();

	private static ArrayList<Class<? extends IFMapLegendDriver>> legendDriverPool = new ArrayList<Class<? extends IFMapLegendDriver>>();

	private Hashtable<Class<? extends ILegendPanel>, ILegendPanel> pages = new Hashtable<Class<? extends ILegendPanel>, ILegendPanel>();

	private JLabel iconLabel;

								PluginServices.getText(this, "error_file_exists")+"\n"+

								PluginServices.getText(this, "do_you_want_to_overwrite_it")+"?",

						String message=PluginServices.getText(this, "could_not_save_legend")+":\n";

							message += PluginServices.getText(this, "error_writing_file")+".\n";

							message += "-"+ PluginServices.getText(this, "legend_format_not_yet_supported")+"\n";

							message = "-"+PluginServices.getText(this, "unknown_error")+"\n";

						boolean hasReason = false;

							message +="-"+ PluginServices.getText(this, "classification_field_does_not_exists")+"\n";

							hasReason = true;

							message += "-"+ PluginServices.getText(this, "legend_type_not_yet_supported")+"\n";

							hasReason = true;

							message += "-"+ PluginServices.getText(this, "unsupported_symbol_type")+"\n";

							hasReason = true;

							message += "-"+ PluginServices.getText(this, "layer_geometry_and_legend_types_are_incompatible")+"\n";

							hasReason = true;

							message += "-"+ PluginServices.getText(this, "failed_reading_file")+"\n";

							hasReason = true;

							message += "-"+ PluginServices.getText(this, "unsupported_legend_file_version")+"\n";

							hasReason = true;

							message +="-"+ PluginServices.getText(this, "unsupported_legend_file_format")+"\n"; 

							hasReason = true;

						if ((type & LegendDriverException.LAYER_NAME_NOT_FOUND) != 0){

							type = type & ~LegendDriverException.UNSUPPORTED_LEGEND_READING;

							message +="-"+ PluginServices.getText(this, "could_not_find_layer")+"\n"; 

							hasReason = true;

						if (!hasReason) {

							message = "-"+ PluginServices.getText(this, "unknown_error")+"\n";

						}

			Class<?>[] legendDriverClasses = legendDriverPool.toArray(new Class[0]);

				String message = PluginServices.getText(this, "adding_legend_file_format_support")+": ";

					Class<?> c = legendDriverClasses[i];

					drivers.add((IFMapLegendDriver) c.newInstance());

				} catch (Exception e) {

					NotificationManager.addError(message+PluginServices.getText(this, "failed"), e);

				NotificationManager.addInfo(message+PluginServices.getText(this, "OK"));

	private JPanel getTopPanel() {

	}

	private JButton getBtnSaveLegend() {

		if (btnSaveLegend == null) {

			btnSaveLegend = new JButton(PluginServices.getText(this,"Guardar_leyenda")+"...");

			btnSaveLegend.addActionListener(loadSaveLegendAction);

		}

		return btnSaveLegend;

	}

	private JButton getBtnLoadLegend() {

		if (btnLoadLegend == null) {

			btnLoadLegend = new JButton(PluginServices.getText(this,"Recuperar_leyenda")+"...");

			btnLoadLegend.addActionListener(loadSaveLegendAction);

		}

		return btnLoadLegend;

	}

	/**

	 * This method initializes jTextArea

	 *

	 * @return javax.swing.JTextArea

	 */

	private JTextArea getTitleArea() {

		if (titleArea == null) {

			titleArea = new JTextArea();

			titleArea.setBackground(java.awt.SystemColor.control);

			titleArea.setLineWrap(true);

			titleArea.setRows(0);

			titleArea.setWrapStyleWord(false);

			titleArea.setEditable(false);

			titleArea.setPreferredSize(new java.awt.Dimension(495,40));

		}

		return titleArea;

	}

	/**

	 * This method initializes jPanel1

	 *

	 * @return javax.swing.JPanel

	 */

	private JPanel getPreviewPanel() {

		if (preview == null) {

			preview = new JPanel();

			preview.setBorder(javax.swing.BorderFactory.createBevelBorder(javax.swing.border.BevelBorder.LOWERED));

			preview.setBackground(java.awt.SystemColor.text);

			preview.setLayout(new BorderLayout(5,5));

			preview.add(getIconLabel());

			preview.setPreferredSize(new Dimension(

					getSplitPane().getDividerLocation(),

					130));

			preview.setBackground(Color.white);

		}

		return preview;

	}

	private JLabel getIconLabel() {

		if (iconLabel == null) {

	 * This method initializes jScrollPane

	 *

	 * @return javax.swing.JScrollPane

	 */

	private JScrollPane getLegendTreeScrollPane() {

		if (legendTreeScrollPane == null) {

			legendTreeScrollPane = new JScrollPane();

			legendTreeScrollPane.setViewportView(getJTreeLegends());

		}

		return legendTreeScrollPane;

	}

	/**

	 * <p>Adds a new fully-featured legend panel to the LegendManager.<br></p>

	 *

	 * <p><b>CAUTION:</b> Trying to add a child page whose parent hasn't been added yet

	 * causes the application to fall in an infinite loop. This is a known

	 * bug, sorry. Just avoid this case or try to fix it (lol).<br></p>

	 *

	 * <p><b>Notice</b> that there is no type check so if you add a non-ILegendPanel class,

	 * you'll have a runtime error later.</p>

	 * @param page, Class of type ILegendPanel

	 */

	public static void addLegendPage(Class<? extends ILegendPanel> iLegendPanelClass) {

		if (!legendPool.contains(iLegendPanelClass)) {

			legendPool.add(iLegendPanelClass);

		}

	}

	/**

	 * Causes the component to be autofilled with the legend pages that

	 * were added through the static method addLegendPage(ILegendPanel page)

	 */

	private void fillDialog() {

		if (empty) {

			for (int i = 0; i < legendPool.size(); i++) {

				Class<?> pageClass = (Class<?>) legendPool.get(i);

				ILegendPanel page;

				try {

					page = (ILegendPanel) pageClass.newInstance();

					if (page.isSuitableFor(layer)) {

						// this legend can be applied to this layer

						pages.put(page.getClass(), page);

						if (dirtyTree) {

							// rebuild page tree

							dirtyTree = false;

							ArrayList<ILegendPanel> legList = new ArrayList<ILegendPanel>(pages.values());

							ArrayList<ILegendPanel> alreadyAdded = new ArrayList<ILegendPanel>();

							DefaultTreeModel model = new DefaultTreeModel(root);

							while (legList.size()>0) {

								ILegendPanel legend = (ILegendPanel) legList.get(0);

								Class<? extends ILegendPanel> parent = legend.getParentClass();

								while (parent != null &&

										!alreadyAdded.contains(pages.get(parent))) {

									legend = (ILegendPanel) pages.get(parent);

								}

								doInsertNode(model, legend);

								legList.remove(legend);

								alreadyAdded.add(legend);

							}

							treeModel = model;

							jTreeLegends.setModel(model);

						}

						doInsertNode(treeModel, page);

					}

					getJTreeLegends().setModel(treeModel);

				} catch (InstantiationException e) {

					NotificationManager.addError("Trying to instantiate an interface" +

							" or abstract class + "+pageClass.getName(), e);

				} catch (IllegalAccessException e) {

					NotificationManager.addError("IllegalAccessException: does " +

							pageClass.getName()	+ " class have an anonymous" +

							" constructor?", e);

				}

			}

			getJTreeLegends().repaint();

			empty = false;

		}

	}

	@SuppressWarnings("unchecked")

	private DefaultMutableTreeNode findNode(Class searchID) {

		String title;

		try {

			title = ((ILegendPanel) Class.forName(searchID.getName()).newInstance()).getTitle();

		} catch (Exception e) {

			// this should be impossible, but anyway this case will be treat as the node does not

			// exist.

			return null;

		}

		Enumeration e = root.breadthFirstEnumeration();

		while (e.hasMoreElements()) {

			DefaultMutableTreeNode nodeAux = (DefaultMutableTreeNode) e.nextElement();

			if (nodeAux != null) {

				ILegendPanel legend = (ILegendPanel) nodeAux.getUserObject();

				if (legend == null) continue; // Root node

				if (legend.getTitle().equals(title)) {

					return nodeAux;

				}

			}

		}

		return null;

	}

	private void doInsertNode(DefaultTreeModel treeModel, ILegendPanel page) {

		dirtyTree = ((page.getParentClass() != null) && (findNode(page.getParentClass())==null));

		if (findNode(page.getClass()) != null) // It is already added

			return;

		if (page.getParentClass() != null) {

			if (pages.containsKey(page.getParentClass())) {

				ILegendPanel parent = (ILegendPanel) pages.get(page.getParentClass());

				DefaultMutableTreeNode nodeParent = findNode(parent.getClass());

				if (nodeParent == null) {

					// the parent is empty

					// Recursively add it

					doInsertNode(treeModel, parent);

				} else {

					DefaultMutableTreeNode nodeValue = new DefaultMutableTreeNode(page);

					int children = nodeParent.getChildCount();

					int pos=0;

					for (int i = 0; i < children; i++) {

						DefaultMutableTreeNode node = (DefaultMutableTreeNode) treeModel.getChild(nodeParent, i);

						if (node.getUserObject() instanceof ILegendPanel) {

							String pageTitle = ((ILegendPanel) node.getUserObject()).getTitle();

							if (pageTitle.compareTo(page.getTitle()) < 0) ++pos;

						}

					}

					treeModel.insertNodeInto(nodeValue, nodeParent, pos);

				}

			}

		} else {

			// First level node

			DefaultMutableTreeNode nodeValue = new DefaultMutableTreeNode(page);

			int children = root.getChildCount();

			int pos=0;

			for (int i = 0; i < children; i++) {

				DefaultMutableTreeNode node = (DefaultMutableTreeNode) treeModel.getChild(root, i);

				if (node.getUserObject() instanceof ILegendPanel) {

					String pageTitle = ((ILegendPanel) node.getUserObject()).getTitle();

					if (pageTitle.compareTo(page.getTitle()) < 0) ++pos;

				}

			}

			treeModel.insertNodeInto(nodeValue, root, pos);

		}

	}

	private JScrollPane getTitleScroll() {

		if (jTitleScrollPane == null) {

			jTitleScrollPane = new JScrollPane();

			jTitleScrollPane.setBounds(2, 2, 498, 42);

			jTitleScrollPane.setViewportView(getTitleArea());

		}

		return jTitleScrollPane;

	}

	private JTree getJTreeLegends() {

		if (jTreeLegends == null) {

			jTreeLegends = new JTree();

			jTreeLegends.setRootVisible(false);

			MyTreeCellRenderer treeCellRenderer = new MyTreeCellRenderer();

			treeCellRenderer.setOpenIcon(null);

			treeCellRenderer.setClosedIcon(null);

			treeCellRenderer.setLeafIcon(null);

			jTreeLegends.setCellRenderer(treeCellRenderer);

			jTreeLegends.setShowsRootHandles(true);

			jTreeLegends.addTreeSelectionListener(new javax.swing.event.TreeSelectionListener() {

				public void valueChanged(javax.swing.event.TreeSelectionEvent e) {

					if (isTreeListenerDisabled) return;

					DefaultMutableTreeNode node = (DefaultMutableTreeNode)

					jTreeLegends.getLastSelectedPathComponent();

					if (node == null) return;

					setActivePage((ILegendPanel) node.getUserObject());

				}

			});

			jTreeLegends.putClientProperty("JTree.linestyle", "Angled");

			jTreeLegends.getSelectionModel().

			setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);

		}

		return jTreeLegends;

	}

	private void setActivePage(ILegendPanel page) {

		if (page.getPanel() == null) {

			// this is what happens when the user clicked in a parent node

			// which only acts as a folder, and does not manage any legend

			// then it expands and selects the first child

			DefaultMutableTreeNode node = findNode(page.getClass());

			if (treeModel.getChildCount(node)>0) {

				DefaultMutableTreeNode dmn = (DefaultMutableTreeNode) treeModel.getChild(node, 0);

				page = (ILegendPanel) dmn.getUserObject();

				setActivePage(page);

				expandAndSelect(page);

			}

		} else {

			// show the page

			activePanel = page;

			setIcon(activePanel.getIcon());

			activePanel.setData(layer, legend);

			getTitleArea().setText(activePanel.getDescription());

			jPanelContainer.setViewportView(activePanel.getPanel());

		}

	}

	private void setIcon(ImageIcon icon) {

		getIconLabel().setIcon(icon);

		private static final long serialVersionUID = -6013698992263578041L;

		public MyTreeCellRenderer() {}

		public Component getTreeCellRendererComponent(

				JTree tree,

				Object value,

				boolean sel,

				boolean expanded,

				boolean leaf,

				int row,

				boolean hasFocus) {

			super.getTreeCellRendererComponent(

					tree, value, sel,

					expanded, leaf, row,

					hasFocus);

			if (value instanceof DefaultMutableTreeNode)

			{

				DefaultMutableTreeNode node = (DefaultMutableTreeNode) value;

				if (node.getUserObject() instanceof ILegendPanel)

				{

					ILegendPanel legend = (ILegendPanel) node.getUserObject();

					this.setText(

							legend.getPanel() == null ? "<html><b>"+legend.getTitle()+"</b></html>":legend.getTitle());

				}

			}

			return this;

		}

	}

	private void expandAndSelect(Object node) {

		isTreeListenerDisabled = true;

		// will expand the tree and select the node

		int i = 0;

		boolean exit = false;

		TreePath tp = null;

		// find the page in the tree

		while (i<jTreeLegends.getRowCount() && !exit) {

			//see if this row is the node that we are looking for

			tp = jTreeLegends.getPathForRow(i);

			Object[] obj = tp.getPath();

			for (int j = 0; j < obj.length && !exit ; j++) {

				Object o = ((DefaultMutableTreeNode) obj[j]).getUserObject();

				if (o!=null	&& o.getClass().equals(node.getClass())	&& o.equals(node)) {

					// found it! collapse the tree

					while (i>=0) {

						jTreeLegends.collapseRow(i);

						i--;

					}

					exit = true;

				}

			}

			jTreeLegends.expandRow(i);

			i++;

		}

		// expand the tree and set the selection

		if (tp != null) {

			jTreeLegends.expandPath(tp);

			jTreeLegends.setSelectionPath(tp);

		}

		isTreeListenerDisabled = false;

	}

	public String getName() {

		return PluginServices.getText(this,"Simbologia");

	}

	public void acceptAction() {

		// automatically handled by the ThemeManagerWindow

	}

	public void cancelAction() {

		// does nothing

	}

	public void applyAction() {

		legend = activePanel.getLegend();

		if (table != null && table.size() > 1) 

			applyRestOfLegends(table,layer.getMapContext().getLayers());

		/* try to apply the legend to all the active layers that

		FLayer[] activeLyrs = layer.getMapContext().getLayers().getActives();

		for (int i=0; i < activeLyrs.length; i++) {

			FLayer laux=activeLyrs[i];

			if (activeLyrs[i] instanceof FLayers){

				laux=getFirstActiveLayerVect((FLayers)activeLyrs[i]);

			}

			if (laux instanceof ClassifiableVectorial) {

				ClassifiableVectorial aux2 = (ClassifiableVectorial) laux;

				try {

					if (legend instanceof IClassifiedVectorLegend) {

						// Es una leyenda que necesita un recordset con un

						// nombre de campo. Comprobamos que ese recordset

						// tiene ese nombre de campo y es del tipo esperado

						IClassifiedVectorLegend cl = (IClassifiedVectorLegend) legend;

						if (aux2 instanceof AlphanumericData) {

							if (cl.getValues().length==0) {

								JOptionPane.showMessageDialog((Component)PluginServices.getMainFrame(),PluginServices.getText(this,"no_es_posible_aplicar_leyenda_vacia"));

								return;

							}

							aux2.setLegend((IVectorLegend) legend);

						}

					}

					else if (legend instanceof SingleSymbolLegend)

						aux2.setLegend((IVectorLegend) legend);

				} catch (LegendLayerException e) {

					NotificationManager.addError(PluginServices.getText(this, "legend_exception"), e);

				}

			}

		}

	}

	private void applyRestOfLegends(Hashtable<FLayer, ILegend> table2,FLayers layers) {

		for(int i = 0; i < layers.getLayersCount(); i++) {

			FLayer my_layer= layers.getLayer(i);

			if(!(my_layer instanceof FLayers)){

				if(my_layer instanceof ClassifiableVectorial){

					try {

						if(table.containsKey(my_layer)){

							ClassifiableVectorial lyr = (ClassifiableVectorial)my_layer;

							lyr.setLegend((IVectorLegend) table.get(my_layer));

						}

					} catch (LegendLayerException e) {

						// TODO Auto-generated catch block

						e.printStackTrace();

					}

				}

			}

			else 

				applyRestOfLegends(table,(FLayers) my_layer);	

		}

	}

	@Override

	public void setModel(FLayer layer) {

		this.layer = layer;

		applyLegend(((Classifiable) layer).getLegend());

	}

	/**

	 * Applies the legend to the layer.

	 * 

	 * @param aLegend , legend that the user wants to apply

	 */

	private void applyLegend(ILegend aLegend) {

		this.legend = aLegend;

		fillDialog();

		Enumeration<Class<? extends ILegendPanel>> en = pages.keys();

		while (en.hasMoreElements()) {

			ILegendPanel page = (ILegendPanel) pages.get(en.nextElement());

			if (legend.getClass().equals(page.getLegendClass())) {

				setActivePage(page);

				expandAndSelect(page);

				return;

			}

		}

		NotificationManager.addWarning(

				PluginServices.getText(this, 

						"caution_no_registered_panel_associated_to_" +

						"loaded_legend_the_legend_wont_be_applied"));

	}

	public static void addLegendDriver(Class<? extends IFMapLegendDriver> legendDriverClass) {

		if (!legendDriverPool.contains(legendDriverClass)) {

			legendDriverPool.add(legendDriverClass);

		}

	}