示例#1
0
  /**
   * Called as some kind of destructor when the last layer has been removed. Delegates the call to
   * all Destroyables within this component (e.g. MapModes)
   */
  public void destroy() {
    MapView.removeLayerChangeListener(this);
    dialogsPanel.destroy();
    for (int i = 0; i < toolBarActions.getComponentCount(); ++i) {
      if (toolBarActions.getComponent(i) instanceof Destroyable) {
        ((Destroyable) toolBarActions.getComponent(i)).destroy();
      }
    }
    for (int i = 0; i < toolBarToggle.getComponentCount(); ++i) {
      if (toolBarToggle.getComponent(i) instanceof Destroyable) {
        ((Destroyable) toolBarToggle.getComponent(i)).destroy();
      }
    }

    // MapFrame gets destroyed when the last layer is removed, but the status line background
    // thread that collects the information doesn't get destroyed automatically.
    if (statusLine.thread != null) {
      try {
        statusLine.thread.interrupt();
      } catch (Exception e) {
        e.printStackTrace();
      }
    }
    mapView.destroy();
  }
    public Dimension preferredLayoutSize(Container parent) {
      JToolBar tb = (JToolBar) parent;
      Insets insets = tb.getInsets();
      Dimension dim = new Dimension();
      SeaGlassContext context = getContext(tb);

      if (tb.getOrientation() == JToolBar.HORIZONTAL) {
        dim.width = tb.isFloatable() ? SeaGlassIcon.getIconWidth(handleIcon, context) : 0;
        Dimension compDim;
        for (int i = 0; i < tb.getComponentCount(); i++) {
          Component component = tb.getComponent(i);
          if (component.isVisible()) {
            compDim = component.getPreferredSize();
            dim.width += compDim.width;
            dim.height = Math.max(dim.height, compDim.height);
          }
        }
      } else {
        dim.height = tb.isFloatable() ? SeaGlassIcon.getIconHeight(handleIcon, context) : 0;
        Dimension compDim;
        for (int i = 0; i < tb.getComponentCount(); i++) {
          Component component = tb.getComponent(i);
          if (component.isVisible()) {
            compDim = component.getPreferredSize();
            dim.width = Math.max(dim.width, compDim.width);
            dim.height += compDim.height;
          }
        }
      }
      dim.width += insets.left + insets.right;
      dim.height += insets.top + insets.bottom;

      context.dispose();
      return dim;
    }
  private JToolBar removeUnnecessarySeparators(JToolBar toolBar) {
    Component component;
    int previousDeleted = -1;
    int nbComponents = toolBar.getComponentCount();
    for (int i = 0; i < nbComponents; ) {
      component = toolBar.getComponent(i);
      if (toolBar.getComponent(i).getClass() == JSeparator.class) {
        if (i > previousDeleted) {
          toolBar.remove(component);
          nbComponents--;
        } else {
          i++;
        }
      } else {
        previousDeleted = ++i;
      }
    }

    if (nbComponents > 0) {
      component = toolBar.getComponent(toolBar.getComponentCount() - 1);
      if (component != null && component.getClass() == JSeparator.class) {
        toolBar.remove(component);
      }
    }
    return toolBar;
  }
 /**
  * Habilita un componente de la barra de herramientas.
  *
  * @param posicion posición del elemento de la barra de herramientas que se quiere
  *     habilitar.Entero del 0 al número de elementos.
  */
 public static void habilitarComponenteBarraHerramientas(int posicion) {
   if (posicion < toolBar.getComponentCount()) {
     toolBar.getComponentAtIndex(posicion).setEnabled(true);
     toolBar.repaint();
   } else {
     System.out.println("Te has salido del rango de componentes de la barra de herramientas");
   }
 } // habilitarComponeneteBarraHerramientas
示例#5
0
 /** Process all loaded images. */
 @Override
 protected void process(List<ThumbnailAction> chunks) {
   for (ThumbnailAction thumbAction : chunks) {
     JButton thumbButton = new JButton(thumbAction);
     // add the new button BEFORE the last glue
     // this centers the buttons in the toolbar
     buttonBar.add(thumbButton, buttonBar.getComponentCount() - 1);
   }
 }
示例#6
0
文件: MapFrame.java 项目: rheinz/josm
  /**
   * Called as some kind of destructor when the last layer has been removed. Delegates the call to
   * all Destroyables within this component (e.g. MapModes)
   */
  @Override
  public void destroy() {
    MapView.removeLayerChangeListener(this);
    dialogsPanel.destroy();
    Main.pref.removePreferenceChangeListener(sidetoolbarPreferencesChangedListener);
    for (int i = 0; i < toolBarActions.getComponentCount(); ++i) {
      if (toolBarActions.getComponent(i) instanceof Destroyable) {
        ((Destroyable) toolBarActions.getComponent(i)).destroy();
      }
    }
    for (int i = 0; i < toolBarToggle.getComponentCount(); ++i) {
      if (toolBarToggle.getComponent(i) instanceof Destroyable) {
        ((Destroyable) toolBarToggle.getComponent(i)).destroy();
      }
    }

    statusLine.destroy();
    mapView.destroy();
  }
  /** This method uninstalls listeners installed by the UI. */
  protected void uninstallListeners() {
    if (toolBarFocusListener != null) {
      int count = toolBar.getComponentCount();
      for (int i = 0; i < count; i++)
        toolBar.getComponent(i).removeFocusListener(toolBarFocusListener);
      toolBarFocusListener = null;
    }

    floatFrame.removeWindowListener(windowListener);
    windowListener = null;

    toolBar.removeContainerListener(toolBarContListener);
    toolBarContListener = null;

    toolBar.removeMouseMotionListener(dockingListener);
    toolBar.removeMouseListener(dockingListener);
    dockingListener = null;
  }
  /** This method installs listeners for the JToolBar. */
  protected void installListeners() {
    dockingListener = createDockingListener();
    toolBar.addMouseListener(dockingListener);
    toolBar.addMouseMotionListener(dockingListener);

    propertyListener = createPropertyListener();
    toolBar.addPropertyChangeListener(propertyListener);

    toolBarContListener = createToolBarContListener();
    toolBar.addContainerListener(toolBarContListener);

    windowListener = createFrameListener();
    floatFrame.addWindowListener(windowListener);

    toolBarFocusListener = createToolBarFocusListener();
    if (toolBarFocusListener != null) {
      int count = toolBar.getComponentCount();
      for (int i = 0; i < count; i++)
        toolBar.getComponent(i).addFocusListener(toolBarFocusListener);
    }
  }
 /**
  * This method navigates in the given direction giving focus to the next component in the given
  * direction.
  *
  * @param direction The direction to give focus to.
  */
 protected void navigateFocusedComp(int direction) {
   int count = toolBar.getComponentCount();
   switch (direction) {
     case EAST:
     case SOUTH:
       if (focusedCompIndex >= 0 && focusedCompIndex < count) {
         int i = focusedCompIndex + 1;
         boolean focusRequested = false;
         // Find component to focus and request focus on it.
         while (i != focusedCompIndex && !focusRequested) {
           if (i >= count) i = 0;
           Component comp = toolBar.getComponentAtIndex(i++);
           if (comp != null && comp.isFocusable() && comp.isEnabled()) {
             comp.requestFocus();
             focusRequested = true;
           }
         }
       }
       break;
     case WEST:
     case NORTH:
       if (focusedCompIndex >= 0 && focusedCompIndex < count) {
         int i = focusedCompIndex - 1;
         boolean focusRequested = false;
         // Find component to focus and request focus on it.
         while (i != focusedCompIndex && !focusRequested) {
           if (i < 0) i = count - 1;
           Component comp = toolBar.getComponentAtIndex(i--);
           if (comp != null && comp.isFocusable() && comp.isEnabled()) {
             comp.requestFocus();
             focusRequested = true;
           }
         }
       }
       break;
     default:
       break;
   }
 }
示例#10
0
  /**
   * Parse the toolbar preference setting and construct the toolbar GUI control.
   *
   * <p>Call this, if anything has changed in the toolbar settings and you want to refresh the
   * toolbar content (e.g. after registering actions in a plugin)
   */
  public void refreshToolbarControl() {
    control.removeAll();
    buttonActions.clear();
    boolean unregisterTab = Shortcut.findShortcut(KeyEvent.VK_TAB, 0) != null;

    for (ActionDefinition action : getDefinedActions()) {
      if (action.isSeparator()) {
        control.addSeparator();
      } else {
        final JButton b = addButtonAndShortcut(action);
        buttonActions.put(b, action);

        Icon i = action.getDisplayIcon();
        if (i != null) {
          b.setIcon(i);
        } else {
          // hide action text if an icon is set later (necessary for delayed/background image
          // loading)
          action
              .getParametrizedAction()
              .addPropertyChangeListener(
                  new PropertyChangeListener() {

                    @Override
                    public void propertyChange(PropertyChangeEvent evt) {
                      if (Action.SMALL_ICON.equals(evt.getPropertyName())) {
                        b.setHideActionText(evt.getNewValue() != null);
                      }
                    }
                  });
        }
        b.setInheritsPopupMenu(true);
        b.setFocusTraversalKeysEnabled(!unregisterTab);
      }
    }
    control.setFocusTraversalKeysEnabled(!unregisterTab);
    control.setVisible(control.getComponentCount() != 0);
  }
    public void layoutContainer(Container parent) {
      JToolBar tb = (JToolBar) parent;
      Insets insets = tb.getInsets();
      boolean ltr = tb.getComponentOrientation().isLeftToRight();
      SeaGlassContext context = getContext(tb);

      Component c;
      Dimension d;

      // JToolBar by default uses a somewhat modified BoxLayout as
      // its layout manager. For compatibility reasons, we want to
      // support Box "glue" as a way to move things around on the
      // toolbar. "glue" is represented in BoxLayout as a Box.Filler
      // with a minimum and preferred size of (0,0).
      // So what we do here is find the number of such glue fillers
      // and figure out how much space should be allocated to them.
      int glueCount = 0;
      for (int i = 0; i < tb.getComponentCount(); i++) {
        if (isGlue(tb.getComponent(i))) glueCount++;
      }

      if (tb.getOrientation() == JToolBar.HORIZONTAL) {
        int handleWidth = tb.isFloatable() ? SeaGlassIcon.getIconWidth(handleIcon, context) : 0;

        // Note: contentRect does not take insets into account
        // since it is used for determining the bounds that are
        // passed to paintToolBarContentBackground().
        contentRect.x = ltr ? handleWidth : 0;
        contentRect.y = 0;
        contentRect.width = tb.getWidth() - handleWidth;
        contentRect.height = tb.getHeight();

        // However, we do take the insets into account here for
        // the purposes of laying out the toolbar child components.
        int x = ltr ? handleWidth + insets.left : tb.getWidth() - handleWidth - insets.right;
        int baseY = insets.top;
        int baseH = tb.getHeight() - insets.top - insets.bottom;

        // we need to get the minimum width for laying things out
        // so that we can calculate how much empty space needs to
        // be distributed among the "glue", if any
        int extraSpacePerGlue = 0;
        if (glueCount > 0) {
          int minWidth = minimumLayoutSize(parent).width;
          extraSpacePerGlue = (tb.getWidth() - minWidth) / glueCount;
          if (extraSpacePerGlue < 0) extraSpacePerGlue = 0;
        }

        for (int i = 0; i < tb.getComponentCount(); i++) {
          c = tb.getComponent(i);
          if (c.isVisible()) {
            d = c.getPreferredSize();
            int y, h;
            if (d.height >= baseH || c instanceof JSeparator) {
              // Fill available height
              y = baseY;
              h = baseH;
            } else {
              // Center component vertically in the available
              // space
              y = baseY + (baseH / 2) - (d.height / 2);
              h = d.height;
            }
            // if the component is a "glue" component then add to
            // its
            // width the extraSpacePerGlue it is due
            if (isGlue(c)) d.width += extraSpacePerGlue;
            c.setBounds(ltr ? x : x - d.width, y, d.width, h);
            x = ltr ? x + d.width : x - d.width;
          }
        }
      } else {
        int handleHeight = tb.isFloatable() ? SeaGlassIcon.getIconHeight(handleIcon, context) : 0;

        // See notes above regarding the use of insets
        contentRect.x = 0;
        contentRect.y = handleHeight;
        contentRect.width = tb.getWidth();
        contentRect.height = tb.getHeight() - handleHeight;

        int baseX = insets.left;
        int baseW = tb.getWidth() - insets.left - insets.right;
        int y = handleHeight + insets.top;

        // we need to get the minimum height for laying things out
        // so that we can calculate how much empty space needs to
        // be distributed among the "glue", if any
        int extraSpacePerGlue = 0;
        if (glueCount > 0) {
          int minHeight = minimumLayoutSize(parent).height;
          extraSpacePerGlue = (tb.getHeight() - minHeight) / glueCount;
          if (extraSpacePerGlue < 0) extraSpacePerGlue = 0;
        }

        for (int i = 0; i < tb.getComponentCount(); i++) {
          c = tb.getComponent(i);
          if (c.isVisible()) {
            d = c.getPreferredSize();
            int x, w;
            if (d.width >= baseW || c instanceof JSeparator) {
              // Fill available width
              x = baseX;
              w = baseW;
            } else {
              // Center component horizontally in the available
              // space
              x = baseX + (baseW / 2) - (d.width / 2);
              w = d.width;
            }
            // if the component is a "glue" component then add to
            // its
            // height the extraSpacePerGlue it is due
            if (isGlue(c)) d.height += extraSpacePerGlue;
            c.setBounds(x, y, w, d.height);
            y += d.height;
          }
        }
      }
      context.dispose();
    }
示例#12
0
  /**
   * Create a toolbar containing the given tools (if any).
   *
   * @param template Conta
   */
  protected void changeToolBar(JComponent[] template, IControlCenterPlugin selplugin) {
    // Setup the tool bar.
    if (toolbar == null) {
      toolbar = new JToolBar("Main Toolbar");
      getContentPane().add(BorderLayout.NORTH, toolbar);
      // Add standard entries (after gap).
      toolbar.add(Box.createGlue());
      toolcnt++;
      toolbar.addSeparator();
      toolcnt++;

      // ButtonGroup bg = new ButtonGroup();
      IControlCenterPlugin[] plugins = controlcenter.getPlugins();
      for (int i = 0; i < plugins.length; i++) {
        final IControlCenterPlugin plugin = plugins[i];
        // final JToggleButton button = new JToggleButton(new PluginAction(plugins[i]));
        final JButton button = new JButton(new PluginAction(plugins[i]));
        Icon ic = plugin.getToolIcon(selplugin.getName().equals(plugins[i].getName()));
        if (ic != null) button.setIcon(ic);
        else button.setText(plugins[i].getName());
        button.setText("A");
        button.putClientProperty("plugin", plugins[i]);
        button.setBorder(null);
        button.setText(null);
        button.setMinimumSize(BUTTON_DIM);
        button.setHorizontalAlignment(SwingConstants.CENTER);
        button.setVerticalAlignment(SwingConstants.CENTER);
        button.setToolTipText(plugins[i].getName());
        button
            .getModel()
            .addItemListener(
                new ItemListener() {
                  public void itemStateChanged(ItemEvent e) {
                    // System.out.println(plugin.getName()+" :"+button.isSelected());
                    button.setIcon(plugin.getToolIcon(button.isSelected()));
                  }
                });
        //	            if(plugins[i].getHelpID()!=null)
        //	            	SHelp.setupHelp(button, plugins[i].getHelpID());

        // bg.add(button);
        toolbar.add(button);
        toolcnt++;
      }
      toolbar.addSeparator();
      toolcnt++;
      toolbar.add(new JadexLogoButton(toolbar));
      toolcnt++;
    } else {
      while (toolbar.getComponentCount() > toolcnt) {
        //				Component	comp	= toolbar.getComponent(0);
        toolbar.remove(0);
        // if(lasttoolbar!=null)
        //	lasttoolbar.add(comp);
      }
    }

    for (int i = 0; template != null && i < template.length; i++) toolbar.add(template[i], i);
    // lasttoolbar	= template;

    // Select plugins
    for (int i = 0; i < toolbar.getComponentCount(); i++) {
      JComponent comp = (JComponent) toolbar.getComponent(i);
      if (comp.getClientProperty("plugin") != null) {
        IControlCenterPlugin pl = (IControlCenterPlugin) comp.getClientProperty("plugin");
        ((JButton) comp).setIcon(pl.getToolIcon(pl.equals(selplugin)));
        // ((JToggleButton)comp).setSelected(pluginname.equals(comp.getClientProperty("pluginname")));
      }
    }

    toolbar.validate();
    toolbar.repaint();

    // If toolbar has been dropped out -> pack the window (hack???).
    Container root = toolbar;
    while (root.getParent() != null && !(root instanceof Window)) root = root.getParent();
    if (root != null && !(root instanceof JFrame)) {
      ((Window) root).pack();
    }
  }