airspacebuilder.java

来自「world wind java sdk 源码」· Java 代码 · 共 1,830 行 · 第 1/5 页

        {
            SphereAirspace sphere = new SphereAirspace();
            sphere.setAttributes(getDefaultAttributes());
            sphere.setValue(AVKey.DISPLAY_NAME, getNextName(toString()));
            sphere.setAltitude(0.0);
            sphere.setTerrainConforming(true);
            this.initializeSphere(wwd, sphere, fitShapeToViewport);

            return sphere;
        }

        public AirspaceEditor createEditor(Airspace airspace)
        {
            SphereAirspaceEditor editor = new SphereAirspaceEditor();
            editor.setSphere((SphereAirspace) airspace);
            setEditorAttributes(editor);
            return editor;
        }

        protected void initializeSphere(WorldWindow wwd, SphereAirspace sphere, boolean fitShapeToViewport)
        {
            // Creates a sphere in the center of the viewport. Attempts to guess at a reasonable size and height.
            Position position = ShapeUtils.getNewShapePosition(wwd);
            double sizeInMeters = fitShapeToViewport ?
                ShapeUtils.getViewportScaleFactor(wwd) : DEFAULT_SHAPE_SIZE_METERS;

            sphere.setLocation(new LatLon(position));
            sphere.setRadius(sizeInMeters / 2.0);
        }

        public String toString()
        {
            return "Sphere";
        }
    }

    public static AirspaceAttributes getDefaultAttributes()
    {
        AirspaceAttributes attributes = new BasicAirspaceAttributes();
        attributes.setMaterial(new Material(Color.BLACK, Color.LIGHT_GRAY, Color.DARK_GRAY, Color.BLACK, 0.0f));
        attributes.setOutlineMaterial(Material.DARK_GRAY);
        attributes.setDrawOutline(true);
        attributes.setOpacity(0.95);
        attributes.setOutlineOpacity(.95);
        attributes.setOutlineWidth(2);
        return attributes;
    }

    public static AirspaceAttributes getSelectionAttributes()
    {
        AirspaceAttributes attributes = new BasicAirspaceAttributes();
        attributes.setMaterial(Material.WHITE);
        attributes.setOutlineMaterial(Material.BLACK);
        attributes.setDrawOutline(true);
        attributes.setOpacity(0.8);
        attributes.setOutlineOpacity(0.8);
        attributes.setOutlineWidth(2);
        return attributes;
    }

    public static AirspaceAttributes getIntersectionAttributes()
    {
        AirspaceAttributes attributes = new BasicAirspaceAttributes();
        attributes.setMaterial(Material.RED);
        attributes.setOpacity(0.95);
        return attributes;
    }

    public static AirspaceAttributes getSelectionAndIntersectionAttributes()
    {
        AirspaceAttributes attributes = new BasicAirspaceAttributes();
        attributes.setMaterial(Material.ORANGE);
        attributes.setOpacity(0.8);
        return attributes;
    }

    public static void setEditorAttributes(AirspaceEditor editor)
    {
        editor.setUseRubberBand(true);
        editor.setKeepControlPointsAboveTerrain(true);
    }

    public static String getNextName(String base)
    {
        StringBuilder sb = new StringBuilder();
        sb.append(base);
        sb.append(nextEntryNumber++);
        return sb.toString();
    }

    private static AirspaceEditor getEditorFor(Airspace airspace)
    {
        if (airspace instanceof Polygon)
        {
            PolygonEditor editor = new PolygonEditor();
            editor.setPolygon((Polygon) airspace);
            setEditorAttributes(editor);
            return editor;
        }
        else if (airspace instanceof SphereAirspace)
        {
            SphereAirspaceEditor editor = new SphereAirspaceEditor();
            editor.setSphere((SphereAirspace) airspace);
            setEditorAttributes(editor);
            return editor;
        }

        return null;
    }

    private static long nextEntryNumber = 1;

    //**************************************************************//
    //********************  Airspace Builder Panel  ****************//
    //**************************************************************//

    protected static class AirspaceBuilderPanel extends JPanel
    {
        private JComboBox factoryComboBox;
        private JTable entryTable;
        private boolean ignoreSelectEvents = false;

        public AirspaceBuilderPanel(AirspaceBuilderModel model, AirspaceBuilderController controller)
        {
            this.initComponents(model, controller);
        }

        public int[] getSelectedIndices()
        {
            return this.entryTable.getSelectedRows();
        }

        public void setSelectedIndices(int[] indices)
        {
            this.ignoreSelectEvents = true;

            if (indices != null && indices.length != 0)
            {
                for (int index : indices)
                {
                    this.entryTable.setRowSelectionInterval(index, index);
                }
            }
            else
            {
                this.entryTable.clearSelection();
            }

            this.ignoreSelectEvents = false;
        }

        public AirspaceFactory getSelectedFactory()
        {
            return (AirspaceFactory) this.factoryComboBox.getSelectedItem();
        }

        public void setSelectedFactory(AirspaceFactory factory)
        {
            this.factoryComboBox.setSelectedItem(factory);
        }

        private void initComponents(AirspaceBuilderModel model, final AirspaceBuilderController controller)
        {
            final JCheckBox resizeNewShapesCheckBox;
            final JCheckBox enableEditCheckBox;

            JPanel newShapePanel = new JPanel();
            {
                JButton newShapeButton = new JButton("New shape");
                newShapeButton.setActionCommand(NEW_AIRSPACE);
                newShapeButton.addActionListener(controller);
                newShapeButton.setToolTipText("Create a new shape centered in the viewport");

                this.factoryComboBox = new JComboBox(defaultAirspaceFactories);
                this.factoryComboBox.setEditable(false);
                this.factoryComboBox.setToolTipText("Choose shape type to create");

                resizeNewShapesCheckBox = new JCheckBox("Fit new shapes to viewport");
                resizeNewShapesCheckBox.setActionCommand(SIZE_NEW_SHAPES_TO_VIEWPORT);
                resizeNewShapesCheckBox.addActionListener(controller);
                resizeNewShapesCheckBox.setSelected(controller.isResizeNewShapesToViewport());
                resizeNewShapesCheckBox.setAlignmentX(Component.LEFT_ALIGNMENT);
                resizeNewShapesCheckBox.setToolTipText("New shapes are sized to fit the geographic viewport");

                enableEditCheckBox = new JCheckBox("Enable shape editing");
                enableEditCheckBox.setActionCommand(ENABLE_EDIT);
                enableEditCheckBox.addActionListener(controller);
                enableEditCheckBox.setSelected(controller.isEnableEdit());
                enableEditCheckBox.setAlignmentX(Component.LEFT_ALIGNMENT);
                enableEditCheckBox.setToolTipText("Allow modifications to shapes");

                Box newShapeBox = Box.createHorizontalBox();
                newShapeBox.add(newShapeButton);
                newShapeBox.add(Box.createHorizontalStrut(5));
                newShapeBox.add(this.factoryComboBox);
                newShapeBox.setAlignmentX(Component.LEFT_ALIGNMENT);

                JPanel gridPanel = new JPanel(new GridLayout(0, 1, 0, 5)); // rows, cols, hgap, vgap
                gridPanel.add(newShapeBox);
                gridPanel.add(resizeNewShapesCheckBox);
                gridPanel.add(enableEditCheckBox);

                newShapePanel.setLayout(new BorderLayout());
                newShapePanel.add(gridPanel, BorderLayout.NORTH);
            }

            JPanel entryPanel = new JPanel();
            {
                this.entryTable = new JTable(model);
                this.entryTable.setColumnSelectionAllowed(false);
                this.entryTable.setRowSelectionAllowed(true);
                this.entryTable.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
                this.entryTable.getSelectionModel().addListSelectionListener(new ListSelectionListener()
                {
                    public void valueChanged(ListSelectionEvent e)
                    {
                        if (!ignoreSelectEvents)
                        {
                            controller.actionPerformed(new ActionEvent(e.getSource(), -1, SELECTION_CHANGED));
                        }
                    }
                });
                this.entryTable.setToolTipText("<html>Click to select<br>Double-Click to rename</html>");

                JScrollPane tablePane = new JScrollPane(this.entryTable);
                tablePane.setPreferredSize(new Dimension(200, 100));

                entryPanel.setLayout(new BorderLayout(0, 0)); // hgap, vgap
                entryPanel.add(tablePane, BorderLayout.CENTER);
            }

            JPanel selectionPanel = new JPanel();
            {
                JButton delselectButton = new JButton("Deselect");
                delselectButton.setActionCommand(CLEAR_SELECTION);
                delselectButton.addActionListener(controller);
                delselectButton.setToolTipText("Clear the selection");

                JButton deleteButton = new JButton("Delete Selected");
                deleteButton.setActionCommand(REMOVE_SELECTED);
                deleteButton.addActionListener(controller);
                deleteButton.setToolTipText("Delete selected shapes");

                JPanel gridPanel = new JPanel(new GridLayout(0, 1, 0, 5)); // rows, cols, hgap, vgap
                gridPanel.add(delselectButton);
                gridPanel.add(deleteButton);

                selectionPanel.setLayout(new BorderLayout());
                selectionPanel.add(gridPanel, BorderLayout.NORTH);
            }

            this.setLayout(new BorderLayout(30, 0)); // hgap, vgap
            this.setBorder(BorderFactory.createEmptyBorder(20, 20, 20, 20)); // top, left, bottom, right
            this.add(newShapePanel, BorderLayout.WEST);
            this.add(entryPanel, BorderLayout.CENTER);
            this.add(selectionPanel, BorderLayout.EAST);

            controller.addPropertyChangeListener(new PropertyChangeListener()
            {
                public void propertyChange(PropertyChangeEvent e)
                {
                    //noinspection StringEquality
                    if (e.getPropertyName() == SIZE_NEW_SHAPES_TO_VIEWPORT)
                    {
                        resizeNewShapesCheckBox.setSelected(controller.isResizeNewShapesToViewport());
                    }
                    else //noinspection StringEquality
                        if (e.getPropertyName() == ENABLE_EDIT)
                    {
                        enableEditCheckBox.setSelected(controller.isEnableEdit());
                    }
                }
            });
        }
    }

    //**************************************************************//
    //********************  Airspace Builder Controller  ***********//
    //**************************************************************//

    protected static class AirspaceBuilderController extends WWObjectImpl implements ActionListener, MouseListener,
        AirspaceEditListener
    {
        private AppFrame app;
        private AirspaceBuilderModel model;
        private AirspaceBuilderPanel view;
        private AirspaceEntry selectedEntry;
        private AirspaceEditorController editorController;
        private boolean enabled = true;
        private boolean enableEdit = true;
        private boolean resizeNewShapes;
        // UI components.
        private JFileChooser fileChooser;

        public AirspaceBuilderController(AppFrame app)
        {
            this.app = app;
            this.editorController = new AirspaceEditorController();

            // The ordering is important here; we want first pass at mouse events.
            this.editorController.setWorldWindow(this.app.getWwd());
            this.app.getWwd().getInputHandler().addMouseListener(this);
        }

        public AppFrame getApp()
        {
            return this.app;
        }

        public AirspaceBuilderModel getModel()
        {
            return this.model;
        }

        public void setModel(AirspaceBuilderModel model)
        {
            this.model = model;
        }

        public AirspaceBuilderPanel getView()
        {
            return this.view;
        }

        public void setView(AirspaceBuilderPanel view)
        {
            this.view = view;
        }

        public boolean isEnabled()
        {
            return this.enabled;
        }

        public void setEnabled(boolean enabled)
        {
            this.enabled = enabled;
            getView().setEnabled(enabled);
            getApp().setEnabled(enabled);
        }

        public boolean isEnableEdit()
        {
            return this.enableEdit;
        }

        public void setEnableEdit(boolean enable)
        {
            this.enableEdit = enable;
            this.handleEnableEdit(enable);
            this.firePropertyChange(ENABLE_EDIT, null, enable);
        }

        public boolean isResizeNewShapesToViewport()
        {
            return this.resizeNewShapes;
        }

        public void setResizeNewShapesToViewport(boolean resize)
        {
            this.resizeNewShapes = resize;
            this.firePropertyChange(SIZE_NEW_SHAPES_TO_VIEWPORT, null, resize);
        }

        public void actionPerformed(ActionEvent e)
        {