| gvSIG desktop 1

package org.gvsig.app.extension;

import java.awt.BorderLayout;

import java.awt.Dimension;

import java.awt.Toolkit;

import java.awt.datatransfer.StringSelection;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.ComponentEvent;

import java.awt.event.ComponentListener;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.List;

import java.util.Set;

import java.util.TreeSet;

import javax.help.Map;

import javax.swing.BorderFactory;

import javax.swing.Box;

import javax.swing.BoxLayout;

import javax.swing.JButton;

import javax.swing.JPanel;

import javax.swing.JScrollPane;

import javax.swing.JTextPane;

import org.gvsig.andami.plugins.Extension;

import org.gvsig.andami.ui.mdiManager.IWindow;

import org.gvsig.andami.ui.mdiManager.WindowInfo;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataTypesManager;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceFactory;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.Persistent;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class ShowDevelInfoExtension extends Extension {

        public static final int MODE_DIALOG = 1;

    public static final int MODE_WINDOW = 2;

    public static final int MODE_TOOL = 3;

    private Logger LOG = LoggerFactory.getLogger(ShowDevelInfoExtension.class);

        public void initialize() {

                // Do nothing

        }

        public void postInitialize() {

                super.postInitialize();

                PersistenceManager manager = ToolsLocator.getPersistenceManager();

                try {

                        manager.setAutoValidation(PersistenceManager.MANDATORY_IF_DECLARED);

                } catch (PersistenceException e) {

                        LOG.warn("Error modificando el modo de autovalidacion de persistencia.", e);

                }

        }

        public void execute(String actionCommand) {

                if( "ShowPersistenceFactories".equalsIgnoreCase(actionCommand) ) {

                        showInfoPanel("Persistence factories", MODE_WINDOW, this.getPersistenceFactories());

                }

        }

        public boolean isEnabled() {

                return true;

        }

        public boolean isVisible() {

                return true;

        }

        private void showInfoPanel(String title, int mode, String html) {

                IWindow win = new JInfoPanel(title, mode, html);

                ApplicationLocator.getManager().getUIManager().addCentredWindow(win);

        }

        private class JInfoPanel extends JPanel implements IWindow, ComponentListener  {

            /**

                 * 

                 */

                private static final long serialVersionUID = 7164653790859770568L;

                private JButton accept = null;

                private JButton copy = null;

                private JTextPane text = null;

            private WindowInfo info;

            private Object profile = WindowInfo.TOOL_PROFILE;

                public JInfoPanel(String title, int mode, final String html) {

                    this.setLayout(new BorderLayout());

                    this.setPreferredSize(new Dimension(500, 300));

                    text = new JTextPane();

                    text.setContentType("text/html");

                    text.setEditable(false);

                    text.setText(html);

                    text.setCaretPosition(0);

                    JScrollPane scrollPane = new JScrollPane(text);

                    scrollPane.setPreferredSize(new Dimension(500, 220));

                    accept = new JButton("Accept");

                    accept.addActionListener(new ActionListener() {

                            public void actionPerformed(ActionEvent arg0) {

                                    setVisible(false);

                            }

                    });

                    copy = new JButton("Copy to clipboard");

                    copy.addActionListener(new ActionListener() {

                            public void actionPerformed(ActionEvent arg0) {

                                    StringSelection ss = new StringSelection(text.getText());

                                    Toolkit.getDefaultToolkit().getSystemClipboard().setContents(ss,ss);

                            }

                    });

                    JPanel optionsPane = new JPanel();

                    optionsPane.setLayout(new BoxLayout(optionsPane, BoxLayout.LINE_AXIS));

                    optionsPane.setBorder(BorderFactory.createEmptyBorder(4,4,4,4));

                    optionsPane.add(copy);

                    optionsPane.add(accept);

                    this.add(scrollPane, BorderLayout.CENTER);

                    this.add(optionsPane, BorderLayout.SOUTH);

                    this.setVisible(true);

                    profile = WindowInfo.DIALOG_PROFILE;

                int code = WindowInfo.ICONIFIABLE | WindowInfo.MAXIMIZABLE

                        | WindowInfo.RESIZABLE;

                switch (mode) {

                case MODE_DIALOG:

                    code |= WindowInfo.MODALDIALOG;

                    profile = WindowInfo.DIALOG_PROFILE;

                    break;

                case MODE_TOOL:

                    code |= WindowInfo.PALETTE;

                    profile = WindowInfo.TOOL_PROFILE;

                    break;

                case MODE_WINDOW:

                default:

                    code |= WindowInfo.MODELESSDIALOG;

                    profile = WindowInfo.DIALOG_PROFILE;

                }

                info = new WindowInfo(code);

                info.setTitle(title);

                info.setMinimumSize(getPreferredSize());

                info.setHeight(400);

                info.setWidth(600);

                addComponentListener(this);

                }

            public WindowInfo getWindowInfo() {

                return info;

            }

            public Object getWindowProfile() {

                return profile;

            }

            public void componentHidden(ComponentEvent componentEvent) {

                    ApplicationLocator.getManager().getUIManager().closeWindow(this);

            }

            public void componentMoved(ComponentEvent arg0) {

                // Do nothing

            }

            public void componentResized(ComponentEvent arg0) {

                // Do nothing

            }

            public void componentShown(ComponentEvent arg0) {

                // Do nothing

            }

        }

        public class PersistenceInfo implements Comparable<PersistenceInfo> {

                PersistenceFactory factory;

                @SuppressWarnings("rawtypes")

                Class theClass;

                DynStruct definition;

                PersistenceInfo(PersistenceFactory factory,        @SuppressWarnings("rawtypes") Class theClass,        DynStruct definition) {

                        this.factory = factory;

                        this.theClass = theClass;

                        this.definition = definition;

                }

                String getDefinitionName() {

                        if( definition == null ) {

                                return "";

                        }

                        return definition.getFullName();

                } 

                String getDefinitionDescription() {

                        if( definition == null ) {

                                return "";

                        }

                        return definition.getDescription();

                } 

                String getClassName() {

                        if( theClass == null ) {

                                return "";

                        }

                        return theClass.getName();

                } 

                String getFactoryName() {

                        if( factory == null ) {

                                return "";

                        }

                        return factory.getClass().getName();

                } 

                public int compareTo(PersistenceInfo other) {

                        int r = this.factory.getClass().getName().compareTo(other.factory.getClass().getName());

                        if( r == 0 ) {

                                return this.theClass.getName().compareTo(other.theClass.getName());

                        }

                        return r;

                }

        }

        @SuppressWarnings("rawtypes")

        public class ClassComparator implements Comparator {

                public int compare(Object o1, Object o2) {

                        return ((Class)o1).getName().compareTo(((Class)o2).getName());

                }

        }

        @SuppressWarnings({ "unchecked", "rawtypes" })

        private String getPersistenceFactories() {

                int warningsCounter =0;

                List<PersistenceInfo> classes = new ArrayList<PersistenceInfo>();

                Set<Class> referencedClasses = new TreeSet<Class>(new ClassComparator());

                PersistenceManager manager = ToolsLocator.getPersistenceManager();

                List<PersistenceFactory> factories = manager.getFactories();

                for (PersistenceFactory factory : factories) {

                        List<Class> theClasses = factory.getManagedClasses();

                        for (Class theClass : theClasses) {

                                classes.add( new PersistenceInfo(factory, theClass, manager.getDefinition(theClass)));

                        }

                }

                Collections.sort(classes);

                StringBuffer buffer= new StringBuffer();

                StringBuffer warnings = new StringBuffer();

                buffer.append("<html>\n");

                buffer.append("<body>\n");

                buffer.append("<h2>Supported persistent classes</h2>\n");

                buffer.append("<br>\n");

                buffer.append("<ol>\n");

                for (PersistenceInfo classInfo : classes) {

                        StringBuffer classBuffer = new StringBuffer();

                        boolean warning = false;

                        classBuffer.append("  <li>\n    ");

                        classBuffer.append("Class: <i>");

                        classBuffer.append(classInfo.getClassName());

                        classBuffer.append("</i><br>\n    Persistent: <i>");

                        if( Persistent.class.isAssignableFrom(classInfo.theClass) ) {

                                classBuffer.append(" yes.");

                        } else {

                                classBuffer.append(" through a factory.");

                        }

                        classBuffer.append("<br>\n    Factory: <i>");

                        classBuffer.append(classInfo.getFactoryName()).append("</i><br>\n    Definition name: <i>");

                        classBuffer.append(classInfo.getDefinitionName()).append("</i><br>\n    Description: \n");

                        classBuffer.append(classInfo.getDefinitionDescription()).append("<br>\n    ");

                        DataTypesManager dataTypesManager = ToolsLocator.getDataTypesManager();

                        DynStruct definition = classInfo.definition;

                        DynField[] fields = definition.getDynFields();

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

                                DynField field = fields[i];

                                if( dataTypesManager.isContainer(field.getType())) {

                                        if( field.getClassOfValue()==null ) {

                                                classBuffer.append("Field <b>").append(field.getName()).append("</b>, container,  can't has class for value of items.<br>\n    ");

                                                warningsCounter++;

                                                warning = true;

                                        } else if( field.getClassOfValue().getName().equals(Map.class.getName()) ||

                                                           field.getClassOfValue().getName().equals(List.class.getName()) ||

                                                           field.getClassOfValue().getName().equals(Set.class.getName()) ) {

                                                classBuffer.append("Field <b>").append(field.getName()).append("</b>, container,  probably can't has class for value of items.<br>\n    ");

                                                warningsCounter++;

                                                warning = true;

                                        } else {

                                                referencedClasses.add(field.getClassOfValue());

                                        }

                                } else if( dataTypesManager.isObject(field.getType())) {

                                        if( field.getClassOfValue()==null ) {

                                                classBuffer.append("Field <b>").append(field.getName()).append("</b> can't has class of value.<br>\n    ");

                                                warning = true;

                                                warningsCounter++;

                                        } else {

                                                referencedClasses.add(field.getClassOfValue());

                                        }

                                }

                        }

                        classBuffer.append("<br>\n  </li>\n");

                        buffer.append(classBuffer);

                        if( warning ) {

                                warnings.append(classBuffer);

                        }

                }

                buffer.append("</ol>\n");

                buffer.append("<br>\n");

                buffer.append("<br>\n");

                buffer.append("<h2>Persistent classes with problems</h2>\n");

                buffer.append("<ol>\n");

                buffer.append(warnings);

                buffer.append("</ol>\n");

                buffer.append("<br>\n<p>Total warnigs: ").append(warningsCounter).append("</p>");

                buffer.append("<h2>Not persistents used classes</h2>\n");

                buffer.append("<ol>\n");

                for (Class  theClass : referencedClasses) {

//                        if( manager.canPersist(theClass) ) {

//                                continue;

//                        }

                        if( Persistent.class.isAssignableFrom(theClass) ) {

                                continue;

                        }

                        if( manager.getFactories().get(theClass)!=null ) {

                                continue;

                        }

                        buffer.append("  <li>\n");

                        buffer.append("    <i>").append(theClass.getName()).append("</i><br>\n");

                        buffer.append("  </li>\n");

                        warningsCounter++;

                }

                buffer.append("</ol>\n");

                buffer.append("</body>\n");

                buffer.append("</html>\n");

                return buffer.toString();

        }

}