Package com.eteks.sweethome3d.model

Examples of com.eteks.sweethome3d.model.Wall


                                  boolean moveWallAtStart) {   
    float oldXStart = wall.getXStart();
    float oldYStart = wall.getYStart();
    wall.setXStart(xStart);
    wall.setYStart(yStart);
    Wall wallAtStart = wall.getWallAtStart();
    // If wall is joined to a wall at its start
    // and this wall doesn't belong to the list of moved walls
    if (wallAtStart != null && moveWallAtStart) {
      // Move the wall start point or end point
      if (wallAtStart.getWallAtStart() == wall
          && (wallAtStart.getWallAtEnd() != wall
              || (wallAtStart.getXStart() == oldXStart
                  && wallAtStart.getYStart() == oldYStart))) {
        wallAtStart.setXStart(xStart);
        wallAtStart.setYStart(yStart);
      } else if (wallAtStart.getWallAtEnd() == wall
                 && (wallAtStart.getWallAtStart() != wall
                     || (wallAtStart.getXEnd() == oldXStart
                         && wallAtStart.getYEnd() == oldYStart))) {
        wallAtStart.setXEnd(xStart);
        wallAtStart.setYEnd(yStart);
      }
    }
  }
View Full Code Here


                                boolean moveWallAtEnd) {
    float oldXEnd = wall.getXEnd();
    float oldYEnd = wall.getYEnd();
    wall.setXEnd(xEnd);
    wall.setYEnd(yEnd);
    Wall wallAtEnd = wall.getWallAtEnd();
    // If wall is joined to a wall at its end 
    // and this wall doesn't belong to the list of moved walls
    if (wallAtEnd != null && moveWallAtEnd) {
      // Move the wall start point or end point
      if (wallAtEnd.getWallAtStart() == wall
          && (wallAtEnd.getWallAtEnd() != wall
              || (wallAtEnd.getXStart() == oldXEnd
                  && wallAtEnd.getYStart() == oldYEnd))) {
        wallAtEnd.setXStart(xEnd);
        wallAtEnd.setYStart(yEnd);
      } else if (wallAtEnd.getWallAtEnd() == wall
                 && (wallAtEnd.getWallAtStart() != wall
                     || (wallAtEnd.getXEnd() == oldXEnd
                         && wallAtEnd.getYEnd() == oldYEnd))) {
        wallAtEnd.setXEnd(xEnd);
        wallAtEnd.setYEnd(yEnd);
      }
    }
  }
View Full Code Here

   * them to other walls if necessary.
   */
  private void doAddWalls(JoinedWall [] joinedWalls, boolean basePlanLocked) {
    // First add all walls to home
    for (JoinedWall joinedNewWall : joinedWalls) {
      Wall wall = joinedNewWall.getWall();
      this.home.addWall(wall);
    }
    this.home.setBasePlanLocked(basePlanLocked);
   
    // Then join them to each other if necessary
    for (JoinedWall joinedNewWall : joinedWalls) {
      Wall wall = joinedNewWall.getWall();
      Wall wallAtStart = joinedNewWall.getWallAtStart();
      if (wallAtStart != null) {
        wall.setWallAtStart(wallAtStart);
        if (joinedNewWall.isJoinedAtEndOfWallAtStart()) {
          wallAtStart.setWallAtEnd(wall);
        } else if (joinedNewWall.isJoinedAtStartOfWallAtStart()) {
          wallAtStart.setWallAtStart(wall);
        }
      }
      Wall wallAtEnd = joinedNewWall.getWallAtEnd();
      if (wallAtEnd != null) {
        wall.setWallAtEnd(wallAtEnd);
        if (joinedNewWall.isJoinedAtStartOfWallAtEnd()) {
          wallAtEnd.setWallAtStart(wall);
        } else if (joinedNewWall.isJoinedAtEndOfWallAtEnd()) {
          wallAtEnd.setWallAtEnd(wall);
        }
      }
    }     
  }
View Full Code Here

    tester.actionClick(planComponent, 30, 30);
    tester.actionClick(planComponent, 270, 31);
    tester.actionClick(planComponent, 269, 170);
    tester.actionClick(planComponent, 30, 171, InputEvent.BUTTON1_MASK, 2);
    // Check 3 walls were created at (20, 20), (500, 20), (500, 300) and (20, 300) coordinates
    Wall wall1 = orderedWalls.get(0);
    assertCoordinatesEqualWallPoints(20, 20, 500, 20, wall1);
    Wall wall2 = orderedWalls.get(1);
    assertCoordinatesEqualWallPoints(500, 20, 500, 300, wall2);
    Wall wall3 = orderedWalls.get(2);
    assertCoordinatesEqualWallPoints(500, 300, 20, 300, wall3);
    // Check the thickness and the height of first wall
    assertEquals("Wrong wall tickness", frame.preferences.getNewWallThickness(), wall1.getThickness());
    assertEquals("Wrong wall height", frame.preferences.getNewWallHeight(), wall1.getHeight());
    assertEquals("Wrong wall height at end", null, wall1.getHeightAtEnd());
    // Check they are joined to each other end point
    assertWallsAreJoined(null, wall1, wall2);
    assertWallsAreJoined(wall1, wall2, wall3);
    assertWallsAreJoined(wall2, wall3, null);
    // Check they are selected
    assertSelectionContains(frame.home, wall1, wall2, wall3);

    // 3. Click at (30, 170), then double click at (50, 50) with Shift key depressed
    tester.actionClick(planComponent, 30, 170);
    tester.actionKeyPress(KeyEvent.VK_SHIFT);
    tester.actionClick(planComponent, 50, 50, InputEvent.BUTTON1_MASK, 2);
    tester.actionKeyRelease(KeyEvent.VK_SHIFT);
    // Check a forth wall was created at (20, 300), (60, 60) coordinates
    Wall wall4 = orderedWalls.get(orderedWalls.size() - 1);
    assertCoordinatesEqualWallPoints(20, 300, 60, 60, wall4);
    assertSelectionContains(frame.home, wall4);
    assertWallsAreJoined(wall3, wall4, null);
   
    // 4. Use SELECTION mode
    tester.click(frame.modeButton);
    // Check current mode is SELECTION
    assertEquals("Current mode isn't " + PlanController.Mode.SELECTION,
        PlanController.Mode.SELECTION, frame.planController.getMode());
    // Give focus to plan component
    tester.actionFocus(planComponent);
    // Press the delete key
    tester.actionKeyStroke(KeyEvent.VK_DELETE);
    // Check plan contains only the first three walls
    assertHomeContains(frame.home, wall1, wall2, wall3);
   
    // 5. Use WALL_CREATION mode
    tester.click(frame.modeButton);  
    //  Click at (31, 29), then double click at (30, 170)
    tester.actionClick(planComponent, 31, 29);
    tester.actionClick(planComponent, 30, 170, InputEvent.BUTTON1_MASK, 2);
    // Check a new forth wall was created at (20, 20), (20, 300) coordinates
    wall4 = orderedWalls.get(orderedWalls.size() - 1);
    assertCoordinatesEqualWallPoints(20, 20, 20, 300, wall4);
    // Check its end points are joined to the first and third wall
    assertWallsAreJoined(wall1, wall4, wall3);
   
    // 6. Use SELECTION mode
    tester.click(frame.modeButton);
    // Drag and drop cursor from (200, 100) to (300, 180)
    tester.actionMousePress(planComponent,
        new ComponentLocation(new Point(200, 100)));
    tester.actionMouseMove(planComponent,
        new ComponentLocation(new Point(300, 180)));
    tester.actionMouseRelease();
    // Check the selected walls are the second and third ones
    assertSelectionContains(frame.home, wall2, wall3);

    // 7. Press twice right arrow key    
    tester.actionKeyStroke(KeyEvent.VK_RIGHT);
    tester.actionKeyStroke(KeyEvent.VK_RIGHT);
    // Check the 4 walls coordinates are (20, 20), (504, 20), (504, 300), (24, 300)
    assertCoordinatesEqualWallPoints(20, 20, 504, 20, wall1);
    assertCoordinatesEqualWallPoints(504, 20, 504, 300, wall2);
    assertCoordinatesEqualWallPoints(504, 300, 24, 300, wall3);
    assertCoordinatesEqualWallPoints(20, 20, 24, 300, wall4);

    // 8. Click at (272, 40) with Shift key depressed
    tester.actionKeyPress(KeyEvent.VK_SHIFT);
    tester.actionClick(planComponent, 272, 40);
    tester.actionKeyRelease(KeyEvent.VK_SHIFT);
    // Check the second wall was removed from selection
    assertSelectionContains(frame.home, wall3);

     // 9. Drag cursor from (50, 30) to (50, 50)
    tester.actionMousePress(planComponent,
        new ComponentLocation(new Point(50, 30)));
    tester.actionMouseMove(planComponent,
        new ComponentLocation(new Point(50, 50)));
    // Check first wall is selected and that it moved
    assertSelectionContains(frame.home, wall1);
    assertCoordinatesEqualWallPoints(20, 60, 504, 60, wall1);
    // Lose focus
    tester.actionKeyStroke(KeyEvent.VK_TAB);
    // Check the wall didn't move at end
    assertCoordinatesEqualWallPoints(20, 20, 504, 20, wall1);

    // 10. Click 6 times on undo button
    for (int i = 0; i < 6; i++) {
      tester.invokeAndWait(new Runnable() {
          public void run() {
            frame.undoButton.doClick();
          }
        });
    }
    // Check home doesn't contain any wall
    assertHomeContains(frame.home);
   
    // 11. Click 6 times on redo button
    for (int i = 0; i < 6; i++) {
      tester.invokeAndWait(new Runnable() {
          public void run() {
            frame.redoButton.doClick();
          }
        });
    }
    // Check plan contains the four wall
    assertHomeContains(frame.home, wall1, wall2, wall3, wall4);
    //  Check they are joined to each other end point
    assertWallsAreJoined(wall4, wall1, wall2);
    assertWallsAreJoined(wall1, wall2, wall3);
    assertWallsAreJoined(wall2, wall3, wall4);
    assertWallsAreJoined(wall1, wall4, wall3);
    // Check the second and the third wall are selected
    assertSelectionContains(frame.home, wall2, wall3);
   
    // 12. Reverse directions of selected walls
    float xStartWall2 = wall2.getXStart();
    float yStartWall2 = wall2.getYStart();
    float xStartWall3 = wall3.getXStart();
    float yStartWall3 = wall3.getYStart();
    float xEndWall3 = wall3.getXEnd();
    float yEndWall3 = wall3.getYEnd();
    tester.invokeAndWait(new Runnable() {
        public void run() {
          frame.reverseDirectionButton.doClick();
        }
      });
    // Check the second and the third wall are still selected
    assertSelectionContains(frame.home, wall2, wall3);
    // Check wall2 and wall3 were reserved
    assertCoordinatesEqualWallPoints(xStartWall3, yStartWall3, xStartWall2, yStartWall2, wall2);
    assertCoordinatesEqualWallPoints(xEndWall3, yEndWall3, xStartWall3, yStartWall3, wall3);
    assertWallsAreJoined(wall3, wall2, wall1);
    assertWallsAreJoined(wall4, wall3, wall2);
   
    // 13. Select first wall
    tester.actionClick(planComponent, 100, 100); // Give focus first
    tester.actionClick(planComponent, 40, 30);
    // Drag cursor from (30, 30) to (50, 50) with shift key pressed
    tester.actionMousePress(planComponent,
        new ComponentLocation(new Point(30, 30)));
    tester.actionMouseMove(planComponent,
        new ComponentLocation(new Point(50, 50)));
    tester.actionKeyPress(KeyEvent.VK_SHIFT);
    tester.waitForIdle();
    tester.actionMouseRelease();
    tester.actionKeyRelease(KeyEvent.VK_SHIFT);
    // Check wall start point moved to (60, 60)
    assertCoordinatesEqualWallPoints(60, 60, 504, 20, wall1);
    assertCoordinatesEqualWallPoints(60, 60, 24, 300, wall4);
   
    // 14. Select first wall
    tester.actionClick(planComponent, 60, 50);
    assertSelectionContains(frame.home, wall1);
    // Split first wall in two walls
    tester.click(frame.splitButton);
    Wall wall5 = orderedWalls.get(orderedWalls.size() - 2);
    Wall wall6 = orderedWalls.get(orderedWalls.size() - 1);
    assertSelectionContains(frame.home, wall5);
    assertCoordinatesEqualWallPoints(60, 60, 282, 40, wall5);
    assertCoordinatesEqualWallPoints(282, 40, 504, 20, wall6);
    assertWallsAreJoined(wall4, wall5, wall6);
    assertWallsAreJoined(wall5, wall6, wall2);
View Full Code Here

    tester.actionKeyString("5 ");
    tester.actionKeyStroke(KeyEvent.VK_ENTER);
    tester.actionKeyStroke(KeyEvent.VK_ESCAPE);
    // Check created walls
    assertEquals("Wrong walls count", 3, frame.home.getWalls().size());
    Wall wall1 = orderedWalls.get(0);
    assertCoordinatesEqualWallPoints(10, 21, 210, 21, wall1);
    Wall wall2 = orderedWalls.get(1);
    assertCoordinatesEqualWallPoints(210, 21, 210, 221, wall2);
    assertEquals("Wrong wall thickness", wall1.getThickness(), wall2.getThickness());
    Wall wall3 = orderedWalls.get(2);
    assertCoordinatesEqualWallPoints(210, 221, 410, 221, wall3);
    assertEquals("Wrong wall thickness",
        Float.parseFloat(String.valueOf(wall1.getThickness()) + "5"), wall3.getThickness());
    assertWallsAreJoined(wall1, wall2, wall3);
    assertSelectionContains(frame.home, wall1, wall2, wall3);
   
    // 3. Mix mouse and keyboard to create other walls
    tester.actionClick(planComponent, 300, 200);
    tester.actionMouseMove(planComponent,
        new ComponentLocation(new Point(310, 200)));
    tester.actionKeyStroke(KeyEvent.VK_ENTER);
    // Enter the length and the angle of the wall
    tester.actionKeyString("100");
    tester.actionKeyStroke(KeyEvent.VK_TAB);
    tester.actionKeyString("315");
    tester.actionKeyStroke(KeyEvent.VK_ENTER);
    // Create 3 walls with same length
    Thread.sleep(500);
    tester.actionKeyStroke(KeyEvent.VK_ENTER);
    Thread.sleep(500);
    tester.actionKeyStroke(KeyEvent.VK_ENTER);
    // Take control with mouse
    tester.actionMouseMove(planComponent,
        new ComponentLocation(new Point(200, 200)));
    tester.actionKeyPress(KeyEvent.VK_SHIFT);
    Wall wall7 = orderedWalls.get(7);
    assertCoordinatesEqualWallPoints(wall7.getXStart(), wall7.getYStart(),
        planComponent.convertXPixelToModel(200),
        planComponent.convertYPixelToModel(200), wall7);
    tester.waitForIdle();
    tester.actionKeyRelease(KeyEvent.VK_SHIFT);
    // Take control again with keyboard and close the walls square
    tester.actionKeyStroke(KeyEvent.VK_ENTER);
    tester.actionKeyString("100");
    tester.actionKeyStroke(KeyEvent.VK_TAB);
    tester.actionKeyString("90");
    tester.actionKeyStroke(KeyEvent.VK_ENTER);
    // Check created walls
    assertEquals("Wrong walls count", 7, frame.home.getWalls().size());
    Wall wall4 = orderedWalls.get(4);
    Wall wall5 = orderedWalls.get(5);
    Wall wall6 = orderedWalls.get(6);
    assertSelectionContains(frame.home, wall4, wall5, wall6, wall7);
    assertWallsAreJoined(wall6, wall7, wall4);
   
    // 4. Create a dimension line with keyboard
    frame.planController.setMode(PlanController.Mode.DIMENSION_LINE_CREATION);
View Full Code Here

    tester.actionKeyPress(KeyEvent.VK_SHIFT);
    tester.actionClick(planComponent, 50, 50);
    tester.actionClick(planComponent, 150, 50, InputEvent.BUTTON1_MASK, 2);
    tester.actionKeyRelease(KeyEvent.VK_SHIFT);
    // Check wall length is 100 * plan scale
    Wall wall = home.getWalls().iterator().next();
    assertTrue("Incorrect wall length " + 100 / planComponent.getScale()
               + " " + (wall.getXEnd() - wall.getXStart()),
        Math.abs(wall.getXEnd() - wall.getXStart() - 100 / planComponent.getScale()) < 1E-3);
    float xWallMiddle = (wall.getXEnd() + wall.getXStart()) / 2;
    float yWallMiddle = (wall.getYEnd() + wall.getYStart()) / 2;
    // Check camera location and angles
    assertCoordinatesAndAnglesEqualCameraLocationAndAngles(xWallMiddle, yWallMiddle + 1000, 1000,
        (float)Math.PI, (float)Math.PI / 4, home.getCamera());
   
    // 3. Transfer focus to 3D view with TAB key
View Full Code Here

    float wallHeightAtStart = getWallHeightAtStart();
    float wallHeightAtEnd = getWallHeightAtEnd();
    float maxWallHeight = Math.max(wallHeightAtStart, wallHeightAtEnd);
   
    // Compute wall angles and top line factors
    Wall wall = (Wall)getUserData();
    double wallYawAngle = Math.atan2(wall.getYEnd() - wall.getYStart(), wall.getXEnd() - wall.getXStart());
    double cosWallYawAngle = Math.cos(wallYawAngle);
    double sinWallYawAngle = Math.sin(wallYawAngle);
    double wallXStartWithZeroYaw = cosWallYawAngle * wall.getXStart() + sinWallYawAngle * wall.getYStart();
    double wallXEndWithZeroYaw = cosWallYawAngle * wall.getXEnd() + sinWallYawAngle * wall.getYEnd();
    boolean roundWall = wall.getArcExtent() != null && wall.getArcExtent() != 0;
    double topLineAlpha;
    double topLineBeta;
    if (wallHeightAtStart == wallHeightAtEnd) {
      topLineAlpha = 0;
      topLineBeta = wallHeightAtStart;
View Full Code Here

  /**
   * Returns the points of one of the side of this wall.
   */
  private float [][] getWallSidePoints(int wallSide) {
    Wall wall = (Wall)getUserData();
    float [][] wallPoints = wall.getPoints();
   
    if (wallSide == LEFT_WALL_SIDE) {
      for (int i = wallPoints.length / 2; i < wallPoints.length; i++) {
        wallPoints [i][0] = (wallPoints [i][0] + wallPoints [wallPoints.length - i - 1][0]) / 2;
        wallPoints [i][1] = (wallPoints [i][1] + wallPoints [wallPoints.length - i - 1][1]) / 2;
View Full Code Here

 
  /**
   * Returns the height at the end of the wall managed by this 3D object.
   */
  private float getWallHeightAtEnd() {
    Wall wall = (Wall)getUserData();     
    if (wall.isTrapezoidal()) {
      return wall.getHeightAtEnd();
    } else {
      // If the wall isn't trapezoidal, use same height as at wall start
      return getWallHeightAtStart();
    }
  }
View Full Code Here

 
  /**
   * Sets wall appearance with its color, texture and transparency.
   */
  private void updateWallAppearance(boolean waitTextureLoadingEnd) {
    Wall wall = (Wall)getUserData();
    updateFilledWallSideAppearance(((Shape3D)getChild(LEFT_WALL_SIDE)).getAppearance(),
        wall.getLeftSideTexture(), waitTextureLoadingEnd, wall.getLeftSideColor(), wall.getLeftSideShininess());
    updateFilledWallSideAppearance(((Shape3D)getChild(RIGHT_WALL_SIDE)).getAppearance(),
        wall.getRightSideTexture(), waitTextureLoadingEnd, wall.getRightSideColor(), wall.getRightSideShininess());
    if (numChildren() > 2) {
      updateOutlineWallSideAppearance(((Shape3D)getChild(LEFT_WALL_SIDE + 2)).getAppearance());
      updateOutlineWallSideAppearance(((Shape3D)getChild(RIGHT_WALL_SIDE + 2)).getAppearance());
    }
  }
View Full Code Here

TOP

Related Classes of com.eteks.sweethome3d.model.Wall

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.