Application: gvSIG desktop

public class JComboBoxFonts extends JComboBox {

    private static final long serialVersionUID = -1096327332248927959L;

    public JComboBoxFonts() {

        super();

        initialize();

    }

    private void initialize() {

        //	Font info is obtained from the current graphics environment.

        GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();

        // --- Get an array of font names (smaller than the number of fonts)

        String[] fontNames = ge.getAvailableFontFamilyNames();

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

            addItem(fontNames[i]);

        };

        try {

            this.setSelectedItem("Arial");

            this.setSelectedItem("DejaVu Sans");

            this.setSelectedItem("Liberation Sans");

            this.setSelectedItem("Serif");

        } catch (Exception ex) {

        }

    }

            int arraySize = featureStore.getDefaultFeatureType().size();

            requiredAttributes = new String[arraySize];

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.util.PropertiesSupportHelper;

public class ExtendedPropertiesHelper extends PropertiesSupportHelper implements ExtendedPropertiesSupport, Persistent {

     */

    @Override

        return this.getProperty((String) key);

    @Override

        this.setProperty((String) key, val);

    @Override

        return this.getProperties();

        this.setProperties(properties);

        @Override

 *

    private static Logger logger = LoggerFactory.getLogger(DefaultViewDocument.class);

    /**

     *

     */

    private static final long serialVersionUID = 676711512482334764L;

    public static final String PERSISTENCE_DEFINITION_NAME = "DefaultViewDocument";

            if (th != null) {

                if (layer.isAvailable()) {

                                        i18n.getTranslation("_Calculating_envelope"),

                                        JOptionPane.INFORMATION_MESSAGE

                                        "",

                                        JOptionPane.INFORMATION_MESSAGE

    public DefaultViewDocument() {

        this(null);

    }

    public DefaultViewDocument(DocumentManager factory) {

        super(factory);

        ViewPort vp;

        ProjectPreferences preferences = (ProjectPreferences) ApplicationLocator.getManager().getPreferences("project");

        MapContext viewMapContext = new MapContext(

                new ViewPort(preferences.getDefaultProjection())

        );

        vp = viewMapContext.getViewPort();

        vp.setBackColor(preferences.getDefaultViewBackColor());

        vp.setDistanceUnits(preferences.getDefaultDistanceUnits());

        vp.setDistanceArea(preferences.getDefaultDistanceArea());

        /*

         */

        LayerOrderManager lom = getCurrentOrderManager();

        viewMapContext.setOrderManager(lom);

        /*

         */

        if (viewMapContext.getProjection().isProjected()) {

            vp.setMapUnits(1);

        } else {

        }

        this.setMapContext(viewMapContext);

        MapContext overviewMapContext = new MapContext(

                new ViewPort(viewMapContext.getProjection())

        );

        vp = viewMapContext.getViewPort();

        vp.setBackColor(preferences.getDefaultViewBackColor());

        this.setMapOverViewContext(overviewMapContext);

                new SetViewPortExtentWhenAddLayerListener(this.getMapContext().getViewPort())

                new SetViewPortExtentWhenAddLayerListener(this.getMapOverViewContext().getViewPort())

    }

    /**

     * Get current order manager from persistence

     *

     * @return

     */

    private LayerOrderManager getCurrentOrderManager() {

        DynObject props = this.getPluginProperties();

        // current_layer_order_manager

        Object val_obj = null;

        if (props.hasDynValue(LayerOrderPage.PREFERENCES_ID)) {

            val_obj = props.getDynValue(LayerOrderPage.PREFERENCES_ID);

        }

        if (val_obj != null && val_obj instanceof LayerOrderManager) {

            LayerOrderManager lom = (LayerOrderManager) val_obj;

            return lom;

        } else {

            logger.info("No order manager found in persistence.");

            return MapContextLocator.getDefaultOrderManager();

        }

    }

    private DynObject getPluginProperties() {

    }

    public void saveToState(PersistentState state) throws PersistenceException {

        super.saveToState(state);

    }

    public void loadFromState(PersistentState state) throws PersistenceException {

        super.loadFromState(state);

    }

    public String exportDocumentAsText() {

        // FIXME: jjdc PersistentManager getStateAsText o similar

        return null;

    }

    public void setStateFromText(String text) {

        // FIXME: jjdc PersistentManager getStateFromText o similar

    }

import java.lang.reflect.Method;

import java.util.logging.Level;

import org.gvsig.tools.persistence.PersistentState;

    private static Logger logger = LoggerFactory.getLogger(PersistenceDevelTool.class);

    public void showPersistenceFactories() {

        String html = this.getPersistenceFactories();

        InfoPanel.save2file("persistenceinfo", html);

        InfoPanel.showPanel("Persistence factories", WindowManager.MODE.WINDOW, html);

    }

    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;

        }

        boolean hasSaveToState() {

            try {

                Method method = theClass.getMethod("saveToState", PersistentState.class);

                if (method == null) {

                    return false;

                }

            } catch (NoSuchMethodException | SecurityException ex) {

                return false;

            }

            return true;

        }

        boolean hasLoadFromState() {

            try {

                Method method = theClass.getMethod("loadFromState", PersistentState.class);

                if (method == null) {

                    return false;

                }

            } catch (NoSuchMethodException | SecurityException ex) {

                return false;

            }

            return true;

        }

        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) {

            if (o1 == null || o2 == null || ((Class) o1).getName() == null) {

                logger.warn("Esto no deberia estar pasando.");

                return 0; // FIXME

            }

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

        }

    }

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

    public 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) {

                DynStruct definition = manager.getDefinition(theClass);

                List defs = factory.getDefinitions();

                if (definition == null && defs != null && !defs.isEmpty()) {

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

                        definition = (DynStruct) defs.get(i);

                        classes.add(new PersistenceInfo(factory, theClass,

                                definition));

                    }

                } else {

                    classes.add(new PersistenceInfo(factory, theClass,

                            definition));

                }

            }

        }

        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.");

                if (!classInfo.hasSaveToState()) {

                    classBuffer.append("<br>\n    <b>This class doesn't implement saveToState</b>");

                    warningsCounter++;

                    warning = true;

                }

                if (!classInfo.hasLoadFromState()) {

                    classBuffer.append("<br>\n    <b>This class doesn't implement loadFromState</b>");

                    warningsCounter++;

                    warning = true;

                }

            } 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;

            if (definition == null) {

                classBuffer.append("Definition for ")

                        .append(classInfo.getClassName())

                        .append(" is null.<br>\n    ");

                warningsCounter++;

                warning = true;

            } else {

                DynField[] fields = definition.getDynFields();

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

                    DynField field = fields[i];

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

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

                            classBuffer

                                    .append("Field <b>")

                                    .append(field.getName())

                                    .append("</b> as container (")

                                    .append(field.getDataType().getName())

                                    .append("),  can't has class for value of items.<br>\n    ");

                            warningsCounter++;

                            warning = true;

                        } else {

                            classBuffer.append("Field ")

                                    .append(field.getName())

                                    .append(" as container (")

                                    .append(field.getDataType().getName())

                                    .append(") of '")

                                    .append(field.getClassOfItems().getName())

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

                            referencedClasses.add(field.getClassOfItems());

                        }

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

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

                            classBuffer

                                    .append("Field <b>")

                                    .append(field.getName())

                                    .append(" as object </b> can't has class of value.<br>\n    ");

                            warningsCounter++;

                            warning = true;

                        } else {

                            classBuffer.append("Field ")

                                    .append(field.getName()).append(" as object '")

                                    .append(field.getClassOfValue())

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

                            referencedClasses.add(field.getClassOfValue());

                        }

                    } else {

                        classBuffer.append("Field ")

                                .append(field.getName()).append(" as '")

                                .append(field.getDataType().getName())

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

                    }

                }

            }

            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();

    }