~ubuntu-branches/ubuntu/utopic/sweethome3d/utopic

import java.awt.FontMetrics;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.GridBagConstraints;

import java.awt.GridBagLayout;

import java.awt.Insets;

  private enum ActionType {DELETE_SELECTION, ESCAPE, 

      MOVE_SELECTION_LEFT, MOVE_SELECTION_UP, MOVE_SELECTION_DOWN, MOVE_SELECTION_RIGHT,

      MOVE_SELECTION_FAST_LEFT, MOVE_SELECTION_FAST_UP, MOVE_SELECTION_FAST_DOWN, MOVE_SELECTION_FAST_RIGHT,

      ACTIVATE_EDITIION, DEACTIVATE_EDITIION}

  

  private static final float    MARGIN = 40;

        "resources/cursors/panning32x32.png", "Panning cursor", Cursor.HAND_CURSOR);

    this.duplicationCursor = DragSource.DefaultCopyDrop;

    this.patternImagesCache = new HashMap<TextureImage, BufferedImage>();

  }

 

  /**

          if (furnitureTopViewIconsCache != null

              && (HomePieceOfFurniture.Property.COLOR.name().equals(ev.getPropertyName())

                  || HomePieceOfFurniture.Property.TEXTURE.name().equals(ev.getPropertyName())

                  || HomePieceOfFurniture.Property.SHININESS.name().equals(ev.getPropertyName())

                  || (HomePieceOfFurniture.Property.WIDTH.name().equals(ev.getPropertyName())

                      || HomePieceOfFurniture.Property.DEPTH.name().equals(ev.getPropertyName())

        if (isEnabled() && !ev.isPopupTrigger()) {

          requestFocusInWindow();          

          if (ev.getButton() == MouseEvent.BUTTON1) {

            controller.pressMouse(convertXPixelToModel(ev.getX()), convertYPixelToModel(ev.getY()), 

          }

        }

      }

    inputMap.put(KeyStroke.getKeyStroke("DELETE"), ActionType.DELETE_SELECTION);

    inputMap.put(KeyStroke.getKeyStroke("BACK_SPACE"), ActionType.DELETE_SELECTION);

    inputMap.put(KeyStroke.getKeyStroke("ESCAPE"), ActionType.ESCAPE);

    inputMap.put(KeyStroke.getKeyStroke("LEFT"), ActionType.MOVE_SELECTION_LEFT);

    inputMap.put(KeyStroke.getKeyStroke("shift LEFT"), ActionType.MOVE_SELECTION_FAST_LEFT);

    inputMap.put(KeyStroke.getKeyStroke("UP"), ActionType.MOVE_SELECTION_UP);

    inputMap.put(KeyStroke.getKeyStroke("shift DOWN"), ActionType.MOVE_SELECTION_FAST_DOWN);

    inputMap.put(KeyStroke.getKeyStroke("RIGHT"), ActionType.MOVE_SELECTION_RIGHT);

    inputMap.put(KeyStroke.getKeyStroke("shift RIGHT"), ActionType.MOVE_SELECTION_FAST_RIGHT);

    inputMap.put(KeyStroke.getKeyStroke("ENTER"), ActionType.ACTIVATE_EDITIION);

    inputMap.put(KeyStroke.getKeyStroke("shift ENTER"), ActionType.ACTIVATE_EDITIION);

    if (OperatingSystem.isMacOSX()) {

      // Under Mac OS X, duplication with Alt key 

      inputMap.put(KeyStroke.getKeyStroke("alt pressed ALT"), ActionType.ACTIVATE_DUPLICATION);

      inputMap.put(KeyStroke.getKeyStroke("released ALT"), ActionType.DEACTIVATE_DUPLICATION);

      inputMap.put(KeyStroke.getKeyStroke("shift alt pressed ALT"), ActionType.ACTIVATE_DUPLICATION);

      inputMap.put(KeyStroke.getKeyStroke("shift released ALT"), ActionType.DEACTIVATE_DUPLICATION);

      inputMap.put(KeyStroke.getKeyStroke("alt shift pressed SHIFT"), ActionType.TOGGLE_MAGNETISM_ON);

      inputMap.put(KeyStroke.getKeyStroke("alt released SHIFT"), ActionType.TOGGLE_MAGNETISM_OFF);

    } else {

    }

  }

  

        controller.toggleMagnetism(this.toggle);

      }

    }

    // Duplication action

    class SetDuplicationActivatedAction extends AbstractAction {

      private final boolean duplicationActivated;

    actionMap.put(ActionType.MOVE_SELECTION_FAST_RIGHT, new MoveSelectionAction(10, 0));

    actionMap.put(ActionType.TOGGLE_MAGNETISM_ON, new ToggleMagnetismAction(true));

    actionMap.put(ActionType.TOGGLE_MAGNETISM_OFF, new ToggleMagnetismAction(false));

    actionMap.put(ActionType.ACTIVATE_DUPLICATION, new SetDuplicationActivatedAction(true));

    actionMap.put(ActionType.DEACTIVATE_DUPLICATION, new SetDuplicationActivatedAction(false));

    actionMap.put(ActionType.ACTIVATE_EDITIION, new SetEditionActivatedAction(true));

   */ 

  protected Cursor createCustomCursor(URL smallCursorImageUrl, 

                                      URL largeCursorImageUrl,

                                      float yCursorHotSpot,

                                      String cursorName,

                                      Cursor defaultCursor) {

  }

 

  /**

      if (this.backgroundImageCache != null) {

        BackgroundImage backgroundImage = this.home.getBackgroundImage();

        if (backgroundImage != null) {

          this.planBoundsCache.add(this.backgroundImageCache.getWidth() * backgroundImage.getScale() - backgroundImage.getXOrigin(),

              this.backgroundImageCache.getHeight() * backgroundImage.getScale() - backgroundImage.getYOrigin());

        }

        for (Level level : this.home.getLevels()) {

          BackgroundImage levelBackgroundImage = level.getBackgroundImage();

          if (levelBackgroundImage != null) {

            this.planBoundsCache.add(this.backgroundImageCache.getWidth() * levelBackgroundImage.getScale() - levelBackgroundImage.getXOrigin(),

                this.backgroundImageCache.getHeight() * levelBackgroundImage.getScale() - levelBackgroundImage.getYOrigin());

          }

    if (printedItemBounds != null) {

      float imageableWidthCm = LengthUnit.inchToCentimeter((float)pageFormat.getImageableWidth() / 72);

      float imageableHeightCm = LengthUnit.inchToCentimeter((float)pageFormat.getImageableHeight() / 72);

      // Compute the largest integer scale possible

      int scaleInverse = (int)Math.ceil(Math.max(

          (printedItemBounds.getWidth() + 2 * extraMargin) / imageableWidthCm,

   * Returns the margin that should be added around home items bounds to ensure their

   * line stroke width is always fully visible.

   */

  }

  

  /**

      // Change coordinates system to paper imageable origin

      g2D.translate(imageableX - columnIndex * imageableWidth, imageableY - rowIndex * imageableHeight);

      g2D.scale(printScale, printScale);

      g2D.translate(-printedItemBounds.getMinX() + extraMargin,

          -printedItemBounds.getMinY() + extraMargin);

      // Center plan in component if possible

    } else {

      // Use a scale of 1

      float clipboardScale = 1f;

      BufferedImage image = new BufferedImage((int)Math.ceil(selectionBounds.getWidth() * clipboardScale + 2 * extraMargin), 

              (int)Math.ceil(selectionBounds.getHeight() * clipboardScale + 2 * extraMargin), BufferedImage.TYPE_INT_RGB);      

      Graphics2D g2D = (Graphics2D)image.getGraphics();

      }

      

      float svgScale = 1f;

      Dimension imageSize = new Dimension((int)Math.ceil(svgItemBounds.getWidth() * svgScale + 2 * extraMargin), 

          (int)Math.ceil(svgItemBounds.getHeight() * svgScale + 2 * extraMargin));

      

      if (this.otherLevelWallAreaCache != null) {

        Composite oldComposite = setTransparency(g2D, 

            this.preferences.isGridVisible() ? 0.2f : 0.1f);

        g2D.setComposite(oldComposite);

      }

    }

      xMax = convertXPixelToModel(getWidth());

      yMax = convertYPixelToModel(getHeight());

    }

      // is too slow and can't be replaced by Quartz engine in applet environment 

      int imageWidth = Math.round(mainGridSize * gridScale);

      BufferedImage gridImage = new BufferedImage(imageWidth, imageWidth, BufferedImage.TYPE_INT_ARGB);

   */

  private float getMainGridSize(float gridScale) {

    float [] mainGridSizes;

      // Use a grid in inch and foot with a minimum grid increment of 1 inch

      float oneFoot = 2.54f * 12;

      mainGridSizes = new float [] {oneFoot, 3 * oneFoot, 6 * oneFoot, 

   */

  private float getGridSize(float gridScale) {

    float [] gridSizes;

      // Use a grid in inch and foot with a minimum grid increment of 1 inch

      float oneFoot = 2.54f * 12;

      gridSizes = new float [] {2.54f, 5.08f, 7.62f, 15.24f, oneFoot, 3 * oneFoot, 6 * oneFoot, 

        ? Color.WHITE

        : Color.GRAY;

    // Draw rooms area

    for (Room room : this.sortedLevelRooms) { 

      boolean selectedRoom = selectedItems.contains(room);

      // In clipboard paint mode, paint room only if it is selected

    

    // Draw rooms area

    g2D.setPaint(foregroundColor);

    for (Room room : rooms) { 

      if (isViewableAtSelectedLevel(room)) {

        g2D.draw(getShape(room.getPoints()));

        : planScale;

    for (Map.Entry<Collection<Wall>, Area> areaEntry : wallAreas.entrySet()) {

      TextureImage wallPattern = areaEntry.getKey().iterator().next().getPattern();

          getWallPaint(wallPaintScale, backgroundColor, foregroundColor, 

    }

  }

 

  /**

   * Fills and paints the given area.

   */

    // Fill walls area

    g2D.setPaint(fillPaint);

    g2D.fill(area);

    // Draw walls area

    g2D.setPaint(drawPaint);

    g2D.draw(area);

  }

  

    }

    // Draw walls area

    g2D.setPaint(foregroundColor);

    for (Area area : getWallAreas(walls).values()) {

      g2D.draw(area);

    }

                              Color furnitureOutlineColor,

                              PaintMode paintMode, boolean paintIcon) {    

    if (!furniture.isEmpty()) {

      Boolean allFurnitureViewedFromTop = null;

      // Draw furniture

      for (HomePieceOfFurniture piece : furniture) {

            if (piece instanceof HomeDoorOrWindow) {

              HomeDoorOrWindow doorOrWindow = (HomeDoorOrWindow)piece;

              pieceShape2D = getDoorOrWindowShapeAtWallIntersection(doorOrWindow);

            } else {

              pieceShape2D = pieceShape;

            }

   * Paints the sashes of a door or a window.

   */

  private void paintDoorOrWindowSashes(Graphics2D g2D, HomeDoorOrWindow doorOrWindow, float planScale, 

    g2D.setPaint(foregroundColor);

    g2D.setStroke(sashBorderStroke);

    for (Sash sash : doorOrWindow.getSashes()) {

                                     Paint selectionOutlinePaint, Stroke selectionOutlineStroke, 

                                     Paint indicatorPaint, float planScale, 

                                     Color foregroundColor) {

        BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER);

    for (HomePieceOfFurniture piece : Home.getFurnitureSubList(items)) {

      if (piece.isVisible() 

 

    // Draw dimension lines

    g2D.setPaint(foregroundColor);

    // Change font size

    Font previousFont = g2D.getFont();

    for (DimensionLine dimensionLine : dimensionLines) {

      g2D.setPaint(backgroundColor);

      g2D.fill(scaledCameraBody);

      g2D.setPaint(foregroundColor);

      g2D.setStroke(stroke);

      g2D.draw(scaledCameraBody);

  

      if (toolTipEditedProperties [i] == PlanController.EditableProperty.ANGLE

          || toolTipEditedProperties [i] == PlanController.EditableProperty.ARC_EXTENT) {

        unitLabel = new JLabel(this.preferences.getLocalizedString(PlanComponent.class, "degreeLabel.text"));

        unitLabel = new JLabel(" " + this.preferences.getLengthUnit().getName());

      }

      

      if (Math.abs(value) < 1E-5) {

        value = 0; // Avoid "-0" text

      }

        text = format.format(LengthUnit.centimeterToFoot((float)value)) + "'"; 

      } else {

        text = format.format(value / 100);