← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/electric/jaunty

« back to all changes in this revision

Viewing changes to com/sun/electric/tool/user/ui/OutlineListener.java

  • Committer: Bazaar Package Importer
  • Author(s): Onkar Shinde
  • Date: 2009-01-08 02:05:08 UTC
  • mfrom: (1.1.2 upstream) (3.1.4 sid)
  • Revision ID: james.westby@ubuntu.com-20090108020508-0h3li7zt9mu5gf0i
Tags: 8.08-1
New upstream version.

Show diffs side-by-side

added added

removed removed

Lines of Context:
com/sun/electric/tool/user/ui/OutlineListener.java
23
23
 */
24
24
package com.sun.electric.tool.user.ui;
25
25
 
 
26
import com.sun.electric.database.geometry.Dimension2D;
26
27
import com.sun.electric.database.geometry.EPoint;
27
28
import com.sun.electric.database.hierarchy.Cell;
28
29
import com.sun.electric.database.topology.NodeInst;
29
30
import com.sun.electric.technology.PrimitiveNode;
30
31
import com.sun.electric.tool.Job;
31
32
import com.sun.electric.tool.JobException;
 
33
import com.sun.electric.tool.user.CircuitChangeJobs;
 
34
import com.sun.electric.tool.user.Highlight2;
 
35
import com.sun.electric.tool.user.Highlighter;
 
36
import com.sun.electric.tool.user.User;
32
37
import com.sun.electric.tool.user.menus.EditMenu;
33
 
import com.sun.electric.tool.user.*;
34
38
 
35
39
import java.awt.Point;
 
40
import java.awt.event.KeyEvent;
 
41
import java.awt.event.KeyListener;
 
42
import java.awt.event.MouseEvent;
 
43
import java.awt.event.MouseListener;
36
44
import java.awt.event.MouseMotionListener;
37
 
import java.awt.event.MouseListener;
 
45
import java.awt.event.MouseWheelEvent;
38
46
import java.awt.event.MouseWheelListener;
39
 
import java.awt.event.MouseEvent;
40
 
import java.awt.event.MouseWheelEvent;
41
 
import java.awt.event.KeyListener;
42
 
import java.awt.event.KeyEvent;
 
47
import java.awt.geom.AffineTransform;
43
48
import java.awt.geom.Point2D;
44
 
import java.awt.geom.AffineTransform;
45
49
 
46
50
/**
47
51
 * Class to make changes to the outline information on a node.
172
176
                                for(int i=0; i<origPoints.length; i++)
173
177
                                {
174
178
                                        // copy the original point
175
 
                                        newPoints[j++] = new Point2D.Double(outlineNode.getAnchorCenterX() + origPoints[i].getX(),
176
 
                                                outlineNode.getAnchorCenterY() + origPoints[i].getY());
 
179
                                        if (origPoints[i] != null)
 
180
                                        {
 
181
                                                newPoints[j] = new Point2D.Double(outlineNode.getAnchorCenterX() + origPoints[i].getX(),
 
182
                                                        outlineNode.getAnchorCenterY() + origPoints[i].getY());
 
183
                                        }
 
184
                                        j++;
177
185
                                        if (i == point)
178
186
                                        {
179
187
                                                // found the selected point, make the insertion
295
303
                        for(int i=0; i<origPoints.length; i++)
296
304
                        {
297
305
                                if (i == pt) continue;
298
 
                                newPoints[j] = new Point2D.Double(outlineNode.getAnchorCenterX() + origPoints[i].getX(),
299
 
                                        outlineNode.getAnchorCenterY() + origPoints[i].getY());
300
 
                                trans.transform(newPoints[j], newPoints[j]);
 
306
                                if (origPoints[j] != null)
 
307
                                {
 
308
                                        newPoints[j] = new Point2D.Double(outlineNode.getAnchorCenterX() + origPoints[i].getX(),
 
309
                                                outlineNode.getAnchorCenterY() + origPoints[i].getY());
 
310
                                        trans.transform(newPoints[j], newPoints[j]);
 
311
                                }
301
312
                                j++;
302
313
                        }
303
314
                        if (pt > 0) pt--;
304
315
                        setNewPoints(newPoints, pt);
305
316
                } else if (chr == KeyEvent.VK_LEFT)
306
317
                {
307
 
                        double arrowDistance = User.getAlignmentToGrid();
308
 
                        moveSelectedPoint(-arrowDistance, 0);
 
318
                        Dimension2D arrowDistance = User.getAlignmentToGrid();
 
319
                        moveSelectedPoint(-arrowDistance.getWidth(), 0);
309
320
                } else if (chr == KeyEvent.VK_RIGHT)
310
321
                {
311
 
                        double arrowDistance = User.getAlignmentToGrid();
312
 
                        moveSelectedPoint(arrowDistance, 0);
 
322
                        Dimension2D arrowDistance = User.getAlignmentToGrid();
 
323
                        moveSelectedPoint(arrowDistance.getWidth(), 0);
313
324
                } else if (chr == KeyEvent.VK_UP)
314
325
                {
315
 
                        double arrowDistance = User.getAlignmentToGrid();
316
 
                        moveSelectedPoint(0, arrowDistance);
 
326
                        Dimension2D arrowDistance = User.getAlignmentToGrid();
 
327
                        moveSelectedPoint(0, arrowDistance.getHeight());
317
328
                } else if (chr == KeyEvent.VK_DOWN)
318
329
                {
319
 
                        double arrowDistance = User.getAlignmentToGrid();
320
 
                        moveSelectedPoint(0, -arrowDistance);
 
330
                        Dimension2D arrowDistance = User.getAlignmentToGrid();
 
331
                        moveSelectedPoint(0, -arrowDistance.getHeight());
321
332
                } else if (chr == KeyEvent.VK_PERIOD)
322
333
                {
323
334
                        // advance to next point
348
359
                Point2D [] newPoints = new Point2D[origPoints.length];
349
360
                for(int i=0; i<origPoints.length; i++)
350
361
                {
351
 
                        newPoints[i] = new Point2D.Double(outlineNode.getAnchorCenterX() + origPoints[i].getX(),
352
 
                                outlineNode.getAnchorCenterY() + origPoints[i].getY());
 
362
                        if (origPoints[i] != null)
 
363
                                newPoints[i] = new Point2D.Double(outlineNode.getAnchorCenterX() + origPoints[i].getX(),
 
364
                                        outlineNode.getAnchorCenterY() + origPoints[i].getY());
353
365
                }
354
366
                AffineTransform trans = outlineNode.rotateOutAboutTrueCenter();
355
 
                trans.transform(newPoints, 0, newPoints, 0, newPoints.length);
356
 
                newPoints[point].setLocation(newPoints[point].getX()+dx, newPoints[point].getY()+dy);
 
367
                for(int i=0; i<newPoints.length; i++)
 
368
                {
 
369
                        if (newPoints[i] != null)
 
370
                                trans.transform(newPoints[i], newPoints[i]);
 
371
                }
 
372
                if (newPoints[point] != null)
 
373
                        newPoints[point].setLocation(newPoints[point].getX()+dx, newPoints[point].getY()+dy);
357
374
                setNewPoints(newPoints, point);
358
375
        }
359
376
 
360
377
        private void setNewPoints(Point2D [] newPoints, int newPoint)
361
378
        {
362
 
                double [] x = new double[newPoints.length];
363
 
                double [] y = new double[newPoints.length];
 
379
                EPoint [] pts = new EPoint[newPoints.length];
364
380
                for(int i=0; i<newPoints.length; i++)
365
381
                {
366
 
                        x[i] = newPoints[i].getX();
367
 
                        y[i] = newPoints[i].getY();
 
382
                        if (newPoints[i] != null)
 
383
                                pts[i] = new EPoint(newPoints[i].getX(), newPoints[i].getY());
368
384
                }
369
 
                new SetPoints(this, outlineNode, x, y, newPoint);
 
385
                new SetPoints(this, outlineNode, pts, newPoint);
370
386
        }
371
387
 
372
388
        /**
376
392
        {
377
393
                private transient OutlineListener listener;
378
394
                private NodeInst ni;
379
 
                private double [] x, y;
 
395
                private EPoint [] pts;
380
396
                private int newPoint;
381
397
 
382
 
                protected SetPoints(OutlineListener listener, NodeInst ni, double [] x, double [] y, int newPoint)
 
398
                protected SetPoints(OutlineListener listener, NodeInst ni, EPoint [] pts, int newPoint)
383
399
                {
384
400
                        super("Change Outline Points", User.getUserTool(), Job.Type.CHANGE, null, null, Job.Priority.USER);
385
401
                        this.listener = listener;
386
402
                        this.ni = ni;
387
 
                        this.x = x;
388
 
                        this.y = y;
 
403
                        this.pts = pts;
389
404
                        this.newPoint = newPoint;
390
405
                        startJob();
391
406
                }
396
411
                        if (CircuitChangeJobs.cantEdit(ni.getParent(), ni, true, false, true) != 0) return false;
397
412
 
398
413
                        // get the extent of the data
399
 
                        Point2D [] points = new Point2D[x.length];
400
 
                        for(int i=0; i<x.length; i++)
401
 
                        {
402
 
                                points[i] = new Point2D.Double(x[i], y[i]);
403
 
                        }
404
 
                        ni.setTrace(points);
 
414
                        ni.setTrace(pts);
405
415
                        return true;
406
416
                }
407
417