1   package fi.jyu.mit.graphics;
2   
3   import java.awt.*;
4   
5   /**
6    * Kaikkien kuvioiden yliluokka
7    * @author Markus Kivioja
8    * @author Vesa Lappalainen
9    */
10  public abstract class BasicShape implements Drawable, Transformable { // NOPMD
11      
12      private Color color;
13      private Matrix matrix;
14      private Matrix rotator;
15      private BasicDrawableCollection parent;
16      
17      public BasicShape() {
18          this.matrix = null; // NOPMD
19          this.rotator = null;// NOPMD
20          this.color = null;  // NOPMD
21      }
22      
23      public Drawable setColor(int r, int g, int b) { // NOPMD
24          return setColor(new Color(r, g, b));
25      }
26      
27      /**
28       * Asetetaan piirtoobjecktin väri
29       * @see fi.jyu.mit.graphics.Drawable#setColor(java.awt.Color)
30       */
31      public Drawable setColor(Color c) {  // NOPMD
32          this.color = c;
33          redraw();
34          return this;
35      }
36      
37  
38      /**
39       * Palautetaan väri jota käyteään piirtämiseen
40       * @return kuvion väri
41       */
42      public Color getColor() {
43          if ( color != null ) return this.color;
44          if ( parent == null ) {  return Color.BLACK; }
45          return parent.getColor();
46      }
47      
48      
49      /**
50       * Alustetaan graphics nykyisten tietojen pohjalta.
51       * Vari haetaan omistajalta jos itsella ei ole.
52       * Jos kenellakaan ei ole varia, kaytetaan mustaa.
53       * @param g Graphics joka alustetaan
54       */
55      protected void initGraphics(Graphics g) {
56          if ( color == null ) {
57              if ( parent == null ) { g.setColor(Color.BLACK); return; }
58              parent.initGraphics(g);
59              return;
60          }
61          g.setColor(this.color);
62      }
63      
64      /**
65       * Palauttaa annetun matriisin muunnettuna kuvion omalla muunnosmatriisilla,
66       * jos muunnosmatriisia ei ole asetettu se on yksikkömatriisi
67       * @param a muunnettava matriisi
68       * @return a muunnettuna kuvion omalla matriisilla
69       */
70      public Matrix getTransform(Matrix a) {  // NOPMD
71          if ( matrix == null ) return a;
72          if ( a == null ) return getTransform();
73          return a.multiply(matrix);
74      }   
75      
76      /**
77       * Palauttaa annetun matriisin kierrettynä kuvion omalla kiertomatriisilla,
78       * jos kiertomatriisia ei ole asetettu se on yksikkömatriisi
79       * @param a muunnettava matriisi
80       * @return a muunnettuna kuvion omalla matriisilla
81       */
82      public Matrix getRotator(Matrix a) {  // NOPMD
83          if ( rotator == null ) return a;
84          if( a == null) return rotator;
85          return a.multiply(rotator);
86      }
87      
88      
89      public Matrix getTransform() {  // NOPMD
90          if ( matrix == null ) matrix = new Matrix();
91          return matrix;
92      }   
93      
94      /**
95       * Muuntaa annetun pisteen annetulla matriisilla ja kuvion omalla muunnosmatriisilla,
96       * palauttaa muunnetun pisteen SPoint-oliona
97       * @param a muunnosmatriisi
98       * @param x muunnettavan pisteen x-koordinaatti
99       * @param y muunnettavan pisteen y-koordinaatti
100      * @param z muunnettavan pisteen z-koortinaatti
101      * @return muunnettu piste SPoint-oliona
102      */
103     public SPoint getPoint(Matrix a,double x,double y, double z) {  // NOPMD
104         Matrix tr = getTransform(a); 
105         if ( tr != null ) return tr.transform(x, y, z);
106         return new SPoint((int)x,(int)y);
107     }
108     
109     /**
110      * Pirtää kuvion annetulla Graphics-oliolla ja muunnosmatriisilla
111      * @param g Graphics-olio
112      * @param a muunnosmatriisi
113      */
114     abstract protected void drawShape(Graphics g, Matrix a);
115 
116     public void draw(Graphics g, Matrix a) {
117         Matrix t = getRotator(getTransform(a));
118         initGraphics(g);
119         drawShape(g,t);
120     }
121     
122     public void setParent(BasicDrawableCollection parent) {
123         if ( this.parent == parent ) return;
124         if ( this == parent ) return; // itseaan ei saa lisata itseensa
125         if ( this.parent != null ) this.parent.justRemove(this);
126         this.parent = parent;
127         parent.justAdd(this);
128         redraw();
129     }
130     
131     public void redraw() {
132         if ( this.parent == null ) return;
133         this.parent.redraw();
134     }
135     
136     public Drawable transform(Matrix m) {  // NOPMD
137         if ( this.matrix == null ) this.matrix = m; 
138         else matrix.multiplyThis(m);
139         redraw();
140         return this;
141     }
142 
143     public Drawable setTransform(Matrix m) {  // NOPMD
144         if ( this.matrix == m ) return this;
145         this.matrix = m; 
146         redraw();
147         return this;
148     }
149 
150     public void changeTransform(Matrix m) {  // NOPMD
151         setTransform(m);
152     }
153 
154     public void setRotator(Matrix m) {  // NOPMD
155         this.rotator = m;
156         redraw();
157     }
158     
159     public Matrix getRotator() {  // NOPMD
160         if ( this.rotator == null ) this.rotator = new Matrix();
161         return this.rotator;
162     }
163     
164     public Drawable scale(double dx, double dy, double dz) {  // NOPMD
165         return transform(new ScaleMatrix(dx,dy,dz));        
166     }
167 
168     public Drawable move(double sx, double sy, double sz) {  // NOPMD
169         return transform(new TranslateMatrix(sx,sy,sz));        
170     }
171 
172     public Drawable rotate(int axis, double deg) {  // NOPMD
173         return transform(new RotMatrix(axis,deg));      
174     }
175 
176 
177 }
178