API tools faq
paste
Advertisement
nex036ara

Resize(undo/redo)

nex036ara
Dec 29th, 2013
55
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 12.39 KB | None | 0 0
raw download clone embed print report
  1. /***********************************************************************
  2.  * Module:  ResizeState.java
  3.  * Author:  e13592
  4.  * Purpose: Defines the Class ResizeState
  5.  ***********************************************************************/
  6.  
  7. package view.graph.state;
  8.  
  9. import java.awt.event.KeyEvent;
  10. import java.awt.event.MouseEvent;
  11. import java.awt.event.MouseWheelEvent;
  12. import java.awt.geom.Point2D;
  13. import java.util.Iterator;
  14.  
  15. import model.genericFunctions.Element;
  16. import model.graph.Node;
  17. import model.graph.commands.ResizeElementCommand;
  18. import view.MainFrame;
  19. import view.graph.GraphDocumentView;
  20. import view.graph.GraphEditorPanel;
  21. import view.graph.GraphWorkArea;
  22. import view.graph.GraphWorkArea.Handle;
  23.  
  24. public class ResizeState extends State {
  25.  
  26.     private Handle handleInMotion = null;
  27.     private double oldXscale, oldYscale;
  28.     private Point2D oldPosition;
  29.     private Node currentNode;
  30.      
  31.     @Override
  32.     public void mouseReleased(MouseEvent e) {
  33.         handleInMotion = null;
  34.  
  35.         ResizeElementCommand command = new ResizeElementCommand(oldXscale,oldYscale,oldPosition,currentNode);
  36.        
  37.         MainFrame.getInstance().getGraphEditorPanel().getGraphDocument()
  38.                 .getCommandManager().executeCommand(command);
  39.        
  40.         ((GraphWorkArea) ((GraphEditorPanel) MainFrame.getInstance()
  41.                 .getGraphEditorPanel()).getGraphDocumentView().getWorkArea())
  42.                 .setState(new SelectionState());
  43.     }
  44.  
  45.     @Override
  46.     public void mouseDragged(MouseEvent e) {
  47.         GraphDocumentView graphDocumentView = MainFrame.getInstance()
  48.                 .getGraphEditorPanel().getGraphDocumentView();
  49.         GraphWorkArea graphWorkArea = (GraphWorkArea) graphDocumentView
  50.                 .getWorkArea();
  51.  
  52.         Point2D position = e.getPoint();
  53.         graphWorkArea.pointToUserSpace(position);
  54.  
  55.         if (handleInMotion == null) {
  56.             handleInMotion = graphWorkArea.getDeviceAndHandleForPoint(position);
  57.         } else {
  58.  
  59.             Iterator<Element> it = graphWorkArea.getCurrentElements()
  60.                     .iterator();
  61.  
  62.             while (it.hasNext()) {
  63.  
  64.                 Element element = it.next();
  65.                 if (element instanceof Node) {
  66.                     Node device = (Node) element;
  67.  
  68.                     oldXscale = device.getScaleX();
  69.                     oldYscale = device.getScaleY();
  70.                     oldPosition = device.getPosition();
  71.                    
  72.                     switch (handleInMotion.ordinal()) {
  73.  
  74.                     case 0: {
  75.  
  76.                         // North
  77.                         device.setHandleInMotion(Handle.North);
  78.                         double razlikaY = device.getPosition().getY()
  79.                                 - position.getY();
  80.                         double newHeight = device.getSize().getHeight()
  81.                                 + razlikaY;
  82.                         double scaleY = newHeight
  83.                                 / device.getInitSize().getHeight();
  84.                         Point2D newPostition = new java.awt.geom.Point2D.Double(
  85.                                 device.getPosition().getX(), device
  86.                                         .getPosition().getY() - razlikaY);
  87.                         device.setScaleY(scaleY);
  88.                         device.setPosition(newPostition);
  89.                        
  90.                         break;
  91.  
  92.                     }
  93.  
  94.                     case 1: {
  95.                         // South
  96.                         device.setHandleInMotion(Handle.South);
  97.                         double razlikaY = position.getY()
  98.                                 - (device.getPosition().getY() + device
  99.                                         .getSize().getHeight());
  100.                         double newHeight = device.getSize().getHeight()
  101.                                 + razlikaY;
  102.                         double scaleY = newHeight
  103.                                 / device.getInitSize().getHeight();
  104.                         device.setScaleY(scaleY);
  105.                         break;
  106.                     }
  107.                     case 2: {
  108.                         // East
  109.                         device.setHandleInMotion(Handle.East);
  110.                         double razlikaX = position.getX()
  111.                                 - (device.getPosition().getX() + device
  112.                                         .getSize().getWidth());
  113.                         double newWidth = device.getSize().getWidth()
  114.                                 + razlikaX;
  115.                         double scaleX = newWidth
  116.                                 / device.getInitSize().getWidth();
  117.                         device.setScaleX(scaleX);
  118.                         break;
  119.                     }
  120.  
  121.                     case 3: {
  122.                         // West
  123.                         device.setHandleInMotion(Handle.West);
  124.                         double razlikaX = device.getPosition().getX()
  125.                                 - position.getX();
  126.                         double newWidth = device.getSize().getWidth()
  127.                                 + razlikaX;
  128.                         double scaleX = newWidth
  129.                                 / device.getInitSize().getWidth();
  130.                         Point2D newPostition = new java.awt.geom.Point2D.Double(
  131.                                 device.getPosition().getX() - razlikaX, device
  132.                                         .getPosition().getY());
  133.                         device.setScaleX(scaleX);
  134.                         device.setPosition(newPostition);
  135.                         break;
  136.                     }
  137.                     case 4: {
  138.                         // SouthEast
  139.                         device.setHandleInMotion(Handle.SouthEast);
  140.                         double razlikaX = position.getX()
  141.                                 - (device.getPosition().getX() + device
  142.                                         .getSize().getWidth());
  143.                         double razlikaY = position.getY()
  144.                                 - (device.getPosition().getY() + device
  145.                                         .getSize().getHeight());
  146.                         double newWidth = device.getSize().getWidth()
  147.                                 + razlikaX;
  148.                         double newHeight = device.getSize().getHeight()
  149.                                 + razlikaY;
  150.  
  151.                         double scaleX = newWidth
  152.                                 / device.getInitSize().getWidth();
  153.                         double scaleY = newHeight
  154.                                 / device.getInitSize().getHeight();
  155.                        
  156.  
  157.                         // uniformni resize po x i y
  158.                         if (e.isShiftDown()) {
  159.                             double newScale = 1;
  160.                             if (scaleX < scaleY)
  161.                                 newScale = scaleX;
  162.                             else
  163.                                 newScale = scaleY;
  164.  
  165.                             device.setScaleX(newScale);
  166.                             device.setScaleY(newScale);
  167.  
  168.                         } else {
  169.                             device.setScaleX(scaleX);
  170.                             device.setScaleY(scaleY);
  171.                         }
  172.  
  173.                         break;
  174.                     }
  175.  
  176.                     case 5: {
  177.                         // SouthWest
  178.                         device.setHandleInMotion(Handle.SouthWest);
  179.                         double razlikaX = device.getPosition().getX()
  180.                                 - position.getX();
  181.                         double razlikaY = position.getY()
  182.                                 - (device.getPosition().getY() + device
  183.                                         .getSize().getHeight());
  184.  
  185.                         double newWidth = device.getSize().getWidth()
  186.                                 + razlikaX;
  187.                         double newHeight = device.getSize().getHeight()
  188.                                 + razlikaY;
  189.  
  190.                         double scaleX = newWidth
  191.                                 / device.getInitSize().getWidth();
  192.                         double scaleY = newHeight
  193.                                 / device.getInitSize().getHeight();
  194.  
  195.                         double newScale = 1;
  196.                        
  197.                         if (e.isShiftDown()) {
  198.                            
  199.                             if (scaleX < scaleY) {
  200.                                 newScale = scaleX;
  201.  
  202.                                 Point2D newPostition = new java.awt.geom.Point2D.Double(
  203.                                         device.getPosition().getX() - razlikaX, device
  204.                                                 .getPosition().getY());
  205.                                 device.setPosition(newPostition);
  206.                             }
  207.                            
  208.                             else {
  209.                                 newScale = scaleY;
  210.  
  211.                                 Point2D newPostition = new java.awt.geom.Point2D.Double(
  212.                                         device.getPosition().getX()-razlikaY, device
  213.                                                 .getPosition().getY());
  214.                                 device.setPosition(newPostition);
  215.                             }
  216.                            
  217.                             device.setScaleX(newScale);
  218.                             device.setScaleY(newScale);
  219.  
  220.                         } else {
  221.                             device.setScaleX(scaleX);
  222.                             device.setScaleY(scaleY);
  223.                             Point2D newPostition = new java.awt.geom.Point2D.Double(
  224.                                     device.getPosition().getX() - razlikaX, device
  225.                                             .getPosition().getY());
  226.                             device.setPosition(newPostition);
  227.                         }
  228.  
  229.                        
  230.                         break;
  231.                     }
  232.                     case 6: {
  233.                         // NorthEast
  234.                         device.setHandleInMotion(Handle.NorthEast);
  235.                         double razlikaX = position.getX()
  236.                                 - (device.getPosition().getX() + device
  237.                                         .getSize().getWidth());
  238.                         double razlikaY = device.getPosition().getY()
  239.                                 - position.getY();
  240.  
  241.                         double newWidth = device.getSize().getWidth()
  242.                                 + razlikaX;
  243.                         double newHeight = device.getSize().getHeight()
  244.                                 + razlikaY;
  245.  
  246.                         double scaleX = newWidth
  247.                                 / device.getInitSize().getWidth();
  248.                         double scaleY = newHeight
  249.                                 / device.getInitSize().getHeight();
  250.  
  251.                         double newScale = 1;
  252.                         if (e.isShiftDown()) {
  253.                            
  254.                             if (scaleX < scaleY) {
  255.                                 newScale = scaleX;
  256.  
  257.                                 Point2D newPostition = new java.awt.geom.Point2D.Double(
  258.                                         device.getPosition().getX(), device
  259.                                                 .getPosition().getY() - razlikaX);
  260.                                 device.setPosition(newPostition);
  261.                             }
  262.                            
  263.                             else {
  264.                                 newScale = scaleY;
  265.  
  266.                                 Point2D newPostition = new java.awt.geom.Point2D.Double(
  267.                                         device.getPosition().getX(), device
  268.                                                 .getPosition().getY()-razlikaY);
  269.                                 device.setPosition(newPostition);
  270.                             }
  271.                            
  272.                             device.setScaleX(newScale);
  273.                             device.setScaleY(newScale);
  274.  
  275.                         } else {
  276.                             device.setScaleX(scaleX);
  277.                             device.setScaleY(scaleY);
  278.                             Point2D newPostition = new java.awt.geom.Point2D.Double(
  279.                                     device.getPosition().getX(), device
  280.                                             .getPosition().getY()-razlikaY);
  281.                             device.setPosition(newPostition);
  282.                         }
  283.  
  284.                        
  285.                         break;
  286.                     }
  287.                     case 7: {
  288.                         // NorthWest
  289.                         device.setHandleInMotion(Handle.NorthWest);
  290.                         double razlikaX = device.getPosition().getX()
  291.                                 - position.getX();
  292.                         double razlikaY = device.getPosition().getY()
  293.                                 - position.getY();
  294.  
  295.                         double newWidth = device.getSize().getWidth()
  296.                                 + razlikaX;
  297.                         double newHeight = device.getSize().getHeight()
  298.                                 + razlikaY;
  299.  
  300.                         double scaleX = newWidth
  301.                                 / device.getInitSize().getWidth();
  302.                         double scaleY = newHeight
  303.                                 / device.getInitSize().getHeight();
  304.  
  305.                         double newScale = 1;
  306.                         if (e.isShiftDown()) {
  307.                            
  308.                             if (scaleX < scaleY) {
  309.                                 newScale = scaleX;
  310.  
  311.                                 Point2D newPostition = new java.awt.geom.Point2D.Double(
  312.                                         device.getPosition().getX() - razlikaX, device
  313.                                                 .getPosition().getY() - razlikaX);
  314.                                 device.setPosition(newPostition);
  315.                             }
  316.                            
  317.                             else {
  318.                                 newScale = scaleY;
  319.  
  320.                                 Point2D newPostition = new java.awt.geom.Point2D.Double(
  321.                                         device.getPosition().getX() -razlikaY, device
  322.                                                 .getPosition().getY()-razlikaY);
  323.                                 device.setPosition(newPostition);
  324.                             }
  325.                            
  326.                             device.setScaleX(newScale);
  327.                             device.setScaleY(newScale);
  328.  
  329.                         } else {
  330.                             device.setScaleX(scaleX);
  331.                             device.setScaleY(scaleY);
  332.                             Point2D newPostition = new java.awt.geom.Point2D.Double(
  333.                                     device.getPosition().getX() - razlikaX, device
  334.                                             .getPosition().getY()-razlikaY);
  335.                             device.setPosition(newPostition);
  336.                         }
  337.  
  338.                        
  339.                         break;
  340.                     }
  341.  
  342.                     }
  343.                     currentNode = device;
  344.                     //graphWorkArea.repaint();
  345.                     //graphDocumentView.update(null, null);
  346.                     MainFrame.getInstance().getGraphEditorPanel().repaint();
  347.                    
  348.                 }else{
  349.                     //ako element nije instanca Node
  350.                     System.out.println("kara");
  351.                 }
  352.             }
  353.  
  354.         }
  355.     }
  356.  
  357.     @Override
  358.     public void keyTyped(KeyEvent e) {
  359.         // TODO Auto-generated method stub
  360.         super.keyTyped(e);
  361.     }
  362.  
  363.     @Override
  364.     public void mouseWheelMoved(MouseWheelEvent e) {
  365.         // TODO Auto-generated method stub
  366.         super.mouseWheelMoved(e);
  367.     }
  368.  
  369.    
  370. }
  371.  
  372.  
  373. /**********************************************/
  374.  
  375.  
  376.  
  377. /***********************************************************************
  378.  * Module:  ResizeElementCommand.java
  379.  * Author:  Spremo
  380.  * Purpose: Defines the Class ResizeElementCommand
  381.  ***********************************************************************/
  382.  
  383. package model.graph.commands;
  384.  
  385. import java.awt.geom.Point2D;
  386.  
  387. import view.MainFrame;
  388.  
  389. import model.graph.Node;
  390.  
  391. public class ResizeElementCommand extends model.genericFunctions.Command {
  392.     private double oldXscale, oldYscale;
  393.     private Point2D oldPosition;
  394.    
  395.     private Node currentNode;
  396.  
  397.     private Point2D newPosition;
  398.     private double newXscale, newYscale;
  399.    
  400.    
  401.    
  402.     public ResizeElementCommand(double oldXscale, double oldYscale,
  403.             Point2D oldPosition, Node currentNode) {
  404.         super();
  405.         this.oldXscale = oldXscale;
  406.         this.oldYscale = oldYscale;
  407.         this.oldPosition = oldPosition;
  408.  
  409.         this.currentNode = currentNode;
  410.         this.newPosition = currentNode.getPosition();
  411.         this.newXscale = currentNode.getScaleX();
  412.         this.newYscale = currentNode.getScaleY();
  413.     }
  414.  
  415.     public void execute() {
  416.  
  417.        
  418.         MainFrame.getInstance().getGraphEditorPanel().getGraphDocumentView()
  419.                 .getSelection().removeElement(currentNode);
  420.  
  421.         currentNode.setPosition(newPosition);
  422.         currentNode.setScaleX(newXscale);
  423.         currentNode.setScaleY(newYscale);
  424.  
  425.         MainFrame.getInstance().getGraphEditorPanel().getGraphDocumentView()
  426.                 .getSelection().addElement(currentNode);
  427.         MainFrame.getInstance().getGraphEditorPanel().repaint();
  428.        
  429.     }
  430.  
  431.     public void undo() {
  432.  
  433.         MainFrame.getInstance().getGraphEditorPanel().getGraphDocumentView()
  434.                 .getSelection().removeElement(currentNode);
  435.  
  436.         currentNode.setPosition(oldPosition);
  437.         currentNode.setScaleX(oldXscale);
  438.         currentNode.setScaleY(oldYscale);
  439.        
  440.         MainFrame.getInstance().getGraphEditorPanel().getGraphDocumentView()
  441.                 .getSelection().addElement(currentNode);
  442.         MainFrame.getInstance().getGraphEditorPanel().repaint();
  443.  
  444.     }
  445.  
  446. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!