Merge lp:~gustav-hartvigsson/vprocessing/vprocessing_shapes into lp:vprocessing

[Gustav Hartvigsson]

Merging...
It has been so meany revisions, it just had to happen...

[Gustav Hartvigsson (gustav-hartvigsson)]

review: Approve

=== modified file 'Makefile'
--- Makefile	2012-04-01 19:58:29 +0000
+++ Makefile	2012-09-17 18:45:28 +0000
@@ -24,9 +24,11 @@
       -X -shared
 
 
-VALAFILES=src/*.vala
+VALAFILES=src/*.vala\
+          src/shapes/*.vala\
+          src/events/*.vala
 
-EXEC=vProcessing.so
+EXEC=libvProcessing.so
 
 
 default:

=== modified file 'README'
--- README	2012-03-17 11:13:08 +0000
+++ README	2012-09-17 18:45:28 +0000
@@ -4,7 +4,7 @@
 
 FOR LICENSING INFORMATION SEE THE FILE "COPYING".
 
-THIS SOFTWARE IS USED AT YOUR OWN RISK, ALL AND ANNY MONETARY OR PROPERTY DAMAGE
+THIS SOFTWARE IS USED AT YOUR OWN RISK, ALL AND ANY MONETARY OR PROPERTY DAMAGE
 CLAIMS ARE VOID. YOU HAVE BEEN WARNED.
 
 ==== Compile ====
@@ -27,8 +27,11 @@
  make clean
 
 And to create the documentation run:
- valadoc src/processing.vala --pkg sdl --pkg sdl-image\
- --pkg sdl-ttf --pkg sdl-mixer --pkg sdl-gfx -o docs/vProcessing
+$ mkdir docs
+$ valadoc src/*.vala --vapidir=/usr/share/vala-0.16/vapi/\
+  --pkg gee-1.0 --pkg sdl --pkg sdl-image --pkg sdl-ttf\
+  --pkg sdl-mixer --pkg sdl-gfx -o docs/vProcessing
+
 
 This will output the documentation to the folder "docs/vPocessing"
 

=== added directory 'src/events'
=== added file 'src/events/clickEvent.vala'
--- src/events/clickEvent.vala	1970-01-01 00:00:00 +0000
+++ src/events/clickEvent.vala	2012-09-17 18:45:28 +0000
@@ -0,0 +1,18 @@
+using GLib;
+
+namespace vProcessing {
+  public interface ClickEvent {
+    public signal void on_click ();
+    
+    public abstract void click_event (MouseEvents m);
+  }
+  
+  public interface MouseOverEvent {
+    public signal void on_mouse_over ();
+    public abstract void mouse_over_event (MouseEvents m);
+  }
+  
+  public interface CheckEvent {
+    public abstract void check_event();
+  }
+}

=== modified file 'src/mouseEvent.vala'
--- src/mouseEvent.vala	2012-04-01 19:58:29 +0000
+++ src/mouseEvent.vala	2012-09-17 18:45:28 +0000
@@ -1,14 +1,23 @@
 namespace vProcessing{
+  
   /**
    * This struct just holds some ints to represent where the mouse is, and
    * if it is clicked.
    *
    */
-  public struct mouseEvents {
+  public struct MouseEvents {
     int x;
     int y;
     int dx;
     int dy;
     bool down;
+    
+    /**
+     * Returns a Point of where the mouse is.
+     */
+    public Point to_point() {
+      Point p = new Point ((int16) x, (int16) y);
+      return p;
+    }
   }
 }

=== modified file 'src/processing.vala'
--- src/processing.vala	2012-04-01 19:58:29 +0000
+++ src/processing.vala	2012-09-17 18:45:28 +0000
@@ -13,7 +13,7 @@
 
 namespace vProcessing{
   
-  
+  private const int SCREEN_FPS = 200;
   
   /**
    * This class is the class that you have to enherrent from to get the
@@ -25,12 +25,13 @@
     private bool isRun;
     private int height = 200;
     private int width = 200;
-    private unowned SDL.Screen screen;
+    public unowned SDL.Screen screen;
     private uint32 myColor;
     private bool eventBool[322];
     private SDL.Rect myFillRect;
+    private uint32 fpsTimer;
     
-    private mouseEvents myMouseEvents;
+    private MouseEvents myMouseEvents;
     
     /**
      * This is where you set all the attributes and add all the valiables that
@@ -49,7 +50,7 @@
     
     
     /**
-     * This is where you put the stuff that is goung to be drawn..
+     * This is where you put the stuff that is going to be drawn..
      *
      * use:
      * {{{
@@ -61,18 +62,18 @@
     public abstract void draw();
     
     /**
-     * lead an image from file.
+     * load an image from file.
      * 
      * Unlike in processing (java) loadImage is static, so it can be used
-     * in classes that do not inherret from PApplet.
+     * in classes that do not inherrent from PApplet.
      */
-    public static SDL.Surface loadImage(string s) {
+    public static SDL.Surface load_image(string s) {
       SDL.Surface tmpImg = SDLImage.load(s);
       return tmpImg;
     }
     
     
-    private void initScreen(){
+    private void init_screen(){
       uint32 VideoFlags = SurfaceFlag.DOUBLEBUF
                             | SurfaceFlag.HWACCEL
                             | SurfaceFlag.HWSURFACE;
@@ -86,7 +87,7 @@
         stderr.printf("Could not initize video \n");
       }
       SDL.WindowManager.set_caption("vProcessing","");
-    } //initScreen
+    } //init_screen
     
     /**
      * This sets the size of the screen.
@@ -100,31 +101,35 @@
       
     }
     
-    public void DrawRect (int16 x, int16 y, int16 x2, int16 y2) {
+    public void draw_rect (int16 x, int16 y, int16 x2, int16 y2) {
       SDLGraphics.Rectangle.fill_color(screen, x, y, x2, y2, myColor);
     }
     
-    public void DrawCircle (int16 x, int16 y, int16 radius) {
+    public void draw_circle (int16 x, int16 y, int16 radius) {
       SDLGraphics.Circle.fill_color(screen, x, y, radius, myColor);
     }
     
-    public void DrawLine (int16 x, int16 y, int16 x2, int16 y2) {
+    public void draw_line (int16 x, int16 y, int16 x2, int16 y2) {
       SDLGraphics.Line.color(screen, x, y, x2, y2, myColor);
     }
     
     /**
-     * This is the runner for the pragrame, it will run all the things in setup()
+     * This is the runner for the programe, it will run all the things in setup()
      * and continuasly run draw().
      */
     public void run() {
-      this.setup();
       this.isRun = true;
       this.myColor = this.color_from_rgba(255, 255, 255, 255);
-      this.initScreen();
+      this.init_screen();
+      this.setup();
       while(isRun) {
+        this.fpsTimer = SDL.Timer.get_ticks();
         this.process_events();
         this.draw();
         this.screen.flip();
+        if(SDL.Timer.get_ticks() - fpsTimer < 1000/SCREEN_FPS){
+            SDL.Timer.delay(1000/SCREEN_FPS - (SDL.Timer.get_ticks() - fpsTimer));
+        }
       }
       SDL.quit();
     }
@@ -134,11 +139,11 @@
       screen.fill(myFillRect, 0x0000000);
     }
     
-    public void setColor(uchar r, uchar g, uchar b, uchar a){
+    public void set_color(uchar r, uchar g, uchar b, uchar a){
       this.myColor = this.color_from_rgba(r, g, b, a);
     }
     
-    public uint32 getColor() {
+    public uint32 get_color() {
       return myColor;
     }
     
@@ -154,12 +159,12 @@
     /**
      * This function return true if the mouse in down.
      */
-    public bool MouseDown () {
+    public bool mouse_down () {
       return myMouseEvents.down;
     }
     
     /**
-     * This function returns a mouseEvent structure.
+     * This function returns a MouseEvent structure.
      * 
      * Example:
      * {{{
@@ -171,7 +176,7 @@
      * mouseEvents mEvents = this.getMouseEvent()
      * }}}
      */
-    public mouseEvents getMouseEvent () {
+    public MouseEvents get_MouseEvent () {
       return myMouseEvents;
     }
     
@@ -192,10 +197,11 @@
           myMouseEvents.x = event.motion.x;
           break;
         case EventType.MOUSEBUTTONDOWN:
-          /*stdout.printf("clicked\n");*/
+          stdout.printf("mousedown\n");
           myMouseEvents.down = true;
           break;
         case EventType.MOUSEBUTTONUP:
+          stdout.printf("mouseup \n");
           myMouseEvents.down = false;
           break;
         case EventType.KEYDOWN:
@@ -220,9 +226,9 @@
     }
     
     /**
-     * This returns an array of bools that con be used to prosses stuff...
+     * This returns an array of bools that can be used to prosses stuff...
      */
-    public bool[] getKeyEvent() {
+    public bool[] get_KeyEvent() {
       return this.eventBool;
     }
     

=== added directory 'src/shapes'
=== added file 'src/shapes/vButton.vala'
--- src/shapes/vButton.vala	1970-01-01 00:00:00 +0000
+++ src/shapes/vButton.vala	2012-09-17 18:45:28 +0000
@@ -0,0 +1,25 @@
+using GLib;
+
+namespace vProcessing {
+  /**
+   * vButton derives from vRect and impliments ClickEvent and MouseOverEvent
+   */
+  public class vButton : vRect, ClickEvent, MouseOverEvent {
+    public vButton (int16 x, int16 y, int16 h,int16 w, string s) {
+      base(x,y,h,w,false);
+      
+    }
+    
+    public void click_event (MouseEvents m) {
+      if ( base.is_inside ( m.to_point () ) && m.down ) {
+        on_click ();
+      }
+    }
+    
+    public void mouse_over_event (MouseEvents m) {
+      if ( base.is_inside (m.to_point () ) ) {
+      on_mouse_over();
+      }
+    }
+  }
+}

=== added file 'src/shapes/vCircle.vala'
--- src/shapes/vCircle.vala	1970-01-01 00:00:00 +0000
+++ src/shapes/vCircle.vala	2012-09-17 18:45:28 +0000
@@ -0,0 +1,80 @@
+
+
+namespace vProcessing {
+  
+  /**
+   * vCircle is a vShape. It represents an ellipse.
+   * vCircle has one constructor:
+   * vCircle()
+   */
+  public class vCircle : vShape {
+    /*
+     * x and y values are inhereted from vShape
+     */
+    public int16 rx;
+    public int16 ry;
+    
+    private bool filled;
+    
+    /**
+     * This is the cosstructor of the class.
+     * @param x is the x center coordinate of the ellipse.
+     * @param y is the y center coordinate of the ellipse.
+     * @param rx is the x axis radius.
+     * @param ry is the y axis radius.
+     * @param filled if the ellipse is going to be filled or not.
+     */
+    public vCircle (int16 x, int16 y, int16 rx, int16 ry, bool filled) {
+      this.rx = rx;
+      this.ry = ry;
+      this.x = x;
+      this.y = y;
+      this.filled = filled;
+    }
+    
+    public bool is_inside(Point p) {
+      if(pointWithinEllipse(this.x, this.y, this.rx, this.ry, p.x, p.y)){
+        return true;
+      }
+      return false;
+    }
+    
+    /*
+     * source: http://board.flashkit.com/board/showthread.php?t=541469
+     */
+    private bool pointWithinEllipse (int16 ex ,int16 ey ,int16 ea ,int16 eb ,int16 px ,int16 py ) {
+      
+      double dx = px - ex;
+      double dy = py - ey;
+      
+      double nea = ea;
+      double neb = eb;
+      
+      if((dx*dx)/(nea*nea) + (dy*dy)/(neb*neb) <= 1){
+        return true;
+      } else {
+        return false;
+      }
+      
+    }
+    
+    
+    public void draw (SDL.Surface? screen, uint32 color, bool? filled) {
+      if (filled == null){
+        if (this.filled) {
+          SDLGraphics.Ellipse.fill_color(screen, this.x, this.y, this.rx, this.ry, color);
+        } else {
+          SDLGraphics.Ellipse.outline_color(screen, this.x, this.y, this.rx, this.ry, color);
+        }
+      } else {
+        if (filled) {
+          SDLGraphics.Ellipse.fill_color(screen, this.x, this.y, this.rx, this.ry, color);
+        } else {
+          SDLGraphics.Ellipse.outline_color(screen, this.x, this.y, this.rx, this.ry, color);
+        }
+      }
+    }
+  
+  }
+  
+}

=== added file 'src/shapes/vPolly.vala'
--- src/shapes/vPolly.vala	1970-01-01 00:00:00 +0000
+++ src/shapes/vPolly.vala	2012-09-17 18:45:28 +0000
@@ -0,0 +1,145 @@
+using SDL;
+using SDLGraphics;
+using SDLImage;
+using SDLMixer;
+using SDLTTF;
+using Gee;
+
+namespace vProcessing {
+  
+  
+  /**
+   * vPolly is a polygon class. it is a vShape.
+   * vPolly has three connstructors:
+   * vPolly()
+   * vPolly.fromArrayOfPoints()
+   * vPolly.fromArrayListOfPoints()
+   * 
+   */
+  public class vPolly : vProcessing.vShape{
+    
+    /**
+     * an array to store the points in...
+     * Probobly needs to be reimplimented to be faster.
+     */
+    private ArrayList<Point> myPointArray;
+    
+    private bool goBack;
+    
+    /**
+     * The last poist to be renderd
+     */
+    private Point lastPoint;
+    
+    private Point firstPoint;
+   
+    /**
+     * All points that are added are relative to this point.
+     * This is so that a vPolly can be moved w/o much hassle
+     */
+    public vPolly(int16 x, int16 y, bool goBack) {
+      this.goBack = goBack;
+      this.x = x;
+      this.y = y;
+      myPointArray = new ArrayList<Point>();
+    }
+    
+    /**
+     * This takes an ArrayList of Points to create a shape, it can be used to
+     * create a vPolly from a predefined shape.
+     * 
+     */
+    public vPolly.fromArrayListOfPoints (int16 x, int16 y, bool goBack,
+                                        ArrayList<Point> points){
+      this.goBack = goBack;
+      this.x = x;
+      this.y = y;
+      myPointArray = new ArrayList<Point>();
+      myPointArray.add_all(points);
+    }
+
+
+    /**
+     * This is like vPolly.fromArrayListOfPoints but uses an array of points
+     * instead.
+     */
+    public vPolly.fromArrayOfPoints (int16 x, int16 y, bool goBack,
+                                    Point[] points) {
+      this.x = x;
+      this.y = y;
+      this.goBack = goBack;
+      myPointArray = new ArrayList<Point>();       
+      foreach (Point p in points) {
+        this.addPointFromPoint (p);
+      }
+    }
+    
+    
+    /**
+     * Add a point (x and y) to the array.
+     * note that the order is important. 
+     */
+    public void addPoint(int16 x, int16 y){
+      Point tempPoint = new Point(x, y);
+      myPointArray.add(tempPoint);
+    }
+    /**
+     * This one takes a Point and adds it to the object.
+     */
+    public void addPointFromPoint (Point p) {
+      this.myPointArray.add (p);
+    }
+    
+    /**
+     * Clear the points...
+     */
+    public void clearPoints() {
+      myPointArray.clear();
+    }
+    
+    /**
+     * Draw the array to a surface..
+     * @param surface The surface that is poing te be draw to.
+     * @param color The colour of the lines.
+     * @param goBack if a line is to be put between the last and the first
+     * point. it can be negeted (null), and will then use the value in the vPolly
+     * object.
+     */
+    public void draw(SDL.Surface? surface, uint32 color, bool? goBack) {
+      lastPoint = myPointArray.get(0);
+      firstPoint = lastPoint;
+      foreach(Point p in myPointArray){
+        SDLGraphics.Line.color(surface,
+                               lastPoint.x + this.x ,
+                               lastPoint.y + this.y,
+                               p.x + this.x, p.y + this.y,
+                               color
+                              );
+        lastPoint = p;
+      }
+      
+      if(goBack == null) {
+        if(this.goBack) {
+          SDLGraphics.Line.color(surface,
+                                 lastPoint.x + this.x,
+                                 lastPoint.y + this.y,
+                                 myPointArray.get(0).x + this.x,
+                                 myPointArray.get(0).y + this.y,
+                                 color
+                                );
+        }
+      } else {
+        if(goBack) {
+          SDLGraphics.Line.color(surface,
+                                 lastPoint.x + this.x,
+                                 lastPoint.y + this.y,
+                                 myPointArray.get(0).x + this.x,
+                                 myPointArray.get(0).y + this.y,
+                                 color
+                                );
+        }
+      }
+    }
+  }
+}
+

=== added file 'src/shapes/vRect.vala'
--- src/shapes/vRect.vala	1970-01-01 00:00:00 +0000
+++ src/shapes/vRect.vala	2012-09-17 18:45:28 +0000
@@ -0,0 +1,93 @@
+
+
+namespace vProcessing {
+  /**
+   * this is basicly just has a re implimentation of SDLs rect.
+   */
+  public class vRect : vShape{
+    /*
+     * x and y values are inhereted from vShape
+     */
+    public uint16 h;
+    public uint16 w;
+    
+    private bool filled;
+    
+    public vRect(int16 x, int16 y, uint16 h, uint16 w, bool filled){
+      this.x = x;
+      this.y = y;
+      this.h = h;
+      this.w = w;
+      this.filled = filled;
+    }
+    
+    public bool is_inside(Point p) {
+      if(p.x > this.x &&
+          p.y > this.y &&
+          p.x < this.x + this.w &&
+          p.y < this.y + this.h ){
+        return true;
+      } else {
+        return false;
+      }
+    }
+    
+     public bool is_collide(vRect other){
+      
+      if(this.y >= other.y + other.h || this.y + this.h <= other.y ||
+         this.x >= other.x + other.w || this.x + this.w <= other.x) {
+        return false;
+      }
+      
+      return true;
+    }
+    
+    
+    public void draw (SDL.Surface? screen, uint32 color, bool? filled) {
+      if (filled == null){
+        if (this.filled) {
+          SDLGraphics.Rectangle.fill_color(screen, this.x, this.y,
+                       this.x + (int16)this.w, this.y + (int16)this.h, color);
+        } else {
+          SDLGraphics.Rectangle.outline_color(screen, this.x, this.y,
+                       this.x + (int16)this.w, this.y + (int16)this.h, color);
+        }
+      } else {
+        if (filled) {
+          SDLGraphics.Rectangle.fill_color(screen, this.x, this.y,
+                       this.x + (int16)this.w, this.y + (int16)this.h, color);
+        } else {
+          SDLGraphics.Rectangle.outline_color(screen, this.x, this.y,
+                       this.x + (int16)this.w, this.y + (int16)this.h, color);
+        }
+      }
+      
+    }
+    
+    /*
+    public static int main(string[] args){
+      vRect rect1 = new vRect(15, 15, 15, 15);
+      vRect rect2 = new vRect(25, 25, 15, 15);
+      vRect rect3 = new vRect(30, 15, 15, 15);
+      
+      if(rect1.isCollide(rect2)){
+        stdout.printf("is collide 1 and 2 \n");
+      } else {
+        stdout.printf("is not collide 1 and 2 \n");
+      }
+      
+      if(rect1.isCollide(rect3)){
+        stdout.printf("is collide 1 and 3 \n");
+      } else {
+        stdout.printf("is not collide 1 and 3 \n");
+      }
+      
+      return 0;
+    }
+    */
+    
+  }
+  
+}
+
+

=== added file 'src/shapes/vShape.vala'
--- src/shapes/vShape.vala	1970-01-01 00:00:00 +0000
+++ src/shapes/vShape.vala	2012-09-17 18:45:28 +0000
@@ -0,0 +1,45 @@
+
+
+
+namespace vProcessing {
+  
+  /**
+   * Base class for all shapes in vProcessing
+   * All use int16!
+   */
+  public abstract class vShape {
+    /*
+     * All datatypes in shapes MUST be int16!
+     */
+    protected int16 x;
+    protected int16 y;
+    
+    public void set_x(int16 i) {
+      this.x = i;
+    }
+    
+    public void set_y(int16 i) {
+      this.y = i;
+    }
+    
+    public void set_posision (int16 x, int16 y) {
+      this.x = x;
+      this.y = y;
+    }
+    
+    public int16 get_x(){
+      return x;
+    }
+
+    public int16 get_y(){
+      return y;
+    }
+    /*
+    public abstract void draw(SDL.Screen s);
+    */
+  }
+  
+  
+  
+  
+}

=== added file 'src/shapes/vText.vala'
=== added directory 'tests'
=== added directory 'tests/basic'
=== added directory 'tests/basic_animation'
=== added file 'tests/basic_animation/Makefile'
--- tests/basic_animation/Makefile	1970-01-01 00:00:00 +0000
+++ tests/basic_animation/Makefile	2012-09-17 18:45:28 +0000
@@ -0,0 +1,35 @@
+VALAC=valac-0.16
+VALAFILES=main.vala\
+          animation.vala
+VALAPKGS=--pkg glib-2.0\
+         --pkg vProcessing\
+         --pkg sdl\
+         --pkg sdl-gfx\
+         --pkg sdl-mixer\
+         --pkg sdl-ttf\
+         --pkg gee-1.0
+
+INCLUDEDIR=./../../
+CCEXTRA=--vapidir=$(INCLUDEDIR)\
+        -X -I$(INCLUDEDIR)\
+        -X -L$(INCLUDEDIR)\
+        -X -lvProcessing
+
+EXEC=main
+
+default:
+	$(VALAC) -o $(EXEC) $(VALAFILES) $(VALAPKGS) $(CCEXTRA)
+
+.PHONY: run clean test
+
+.IGNORE: run clean test
+
+run:
+	LD_LIBRARY_PATH=LD_LIBRARY_PATH:./../../ ./$(EXEC)
+
+clean:
+	rm $(EXEC)
+	rm *~
+
+test:clean default run
+

=== added file 'tests/basic_animation/animation.vala'
--- tests/basic_animation/animation.vala	1970-01-01 00:00:00 +0000
+++ tests/basic_animation/animation.vala	2012-09-17 18:45:28 +0000
@@ -0,0 +1,68 @@
+using GLib;
+using vProcessing;
+using SDL;
+
+namespace foo {
+  
+  public class animation : PMain {
+    
+    private vCircle ball;
+    private bool down;
+    private bool left;
+    
+    private int16 ball_x;
+    private int16 ball_y;
+    private int16 ball_offset = 16;
+    
+    //Constructior
+    public animation () {
+      this.size(400, 600);
+      
+    }
+    
+    public override void setup () {
+      ball_x = 50;
+      ball_y = 25;
+      left = true;
+      down = false;
+      ball = new vCircle (ball_x, ball_y,ball_offset, ball_offset, true);
+    }
+    
+    public override void draw () {
+      
+      this.clear();
+      
+      if (left) {
+        ball_x++;
+        if(ball_x > 600 - ball_offset){
+          left = false;
+        }
+      } else {
+        ball_x--;
+        if(ball_x < 0 + ball_offset){
+          left = true;
+        }
+
+      }
+      
+      if (down) {
+        ball_y--;
+        if(ball_y < 0 + ball_offset){
+          down = false;
+        }
+      } else {
+        ball_y++;
+        if(ball_y > 400 - ball_offset){
+          down = true;
+        }
+      }
+      
+      ball.set_posision(ball_x, ball_y);
+      this.setColor(255,0,0,255);
+      ball.draw(this.screen, this.getColor(), null);
+      
+    }
+    
+  }
+  
+}

=== added file 'tests/basic_animation/main.vala'
--- tests/basic_animation/main.vala	1970-01-01 00:00:00 +0000
+++ tests/basic_animation/main.vala	2012-09-17 18:45:28 +0000
@@ -0,0 +1,11 @@
+using GLib;
+using vProcessing;
+using SDL;
+using foo;
+
+int main (string args[]) {
+  
+  foo.animation a = new foo.animation ();
+  a.run();
+  return 0;
+}

=== added file 'tests/basic_animation/run.sh'
--- tests/basic_animation/run.sh	1970-01-01 00:00:00 +0000
+++ tests/basic_animation/run.sh	2012-09-17 18:45:28 +0000
@@ -0,0 +1,1 @@
+LD_LIBRARY_PATH=./../../ ./main

=== added directory 'tests/shapes'
=== added file 'tests/shapes/Makefile'
--- tests/shapes/Makefile	1970-01-01 00:00:00 +0000
+++ tests/shapes/Makefile	2012-09-17 18:45:28 +0000
@@ -0,0 +1,35 @@
+VALAC=valac-0.16
+VALAFILES=main.vala\
+          shapes.vala
+VALAPKGS=--pkg glib-2.0\
+         --pkg vProcessing\
+         --pkg sdl\
+         --pkg sdl-gfx\
+         --pkg sdl-mixer\
+         --pkg sdl-ttf\
+         --pkg gee-1.0
+
+INCLUDEDIR=./../../
+CCEXTRA=--vapidir=$(INCLUDEDIR)\
+        -X -I$(INCLUDEDIR)\
+        -X -L$(INCLUDEDIR)\
+        -X -lvProcessing
+
+EXEC=main
+
+default:
+	$(VALAC) -o $(EXEC) $(VALAFILES) $(VALAPKGS) $(CCEXTRA)
+
+.PHONY: run clean test
+
+.IGNORE: run clean test
+
+run:
+	LD_LIBRARY_PATH=LD_LIBRARY_PATH:./../../ ./$(EXEC)
+
+clean:
+	rm $(EXEC)
+	rm *~
+
+test:clean default run
+

=== added file 'tests/shapes/main.vala'
--- tests/shapes/main.vala	1970-01-01 00:00:00 +0000
+++ tests/shapes/main.vala	2012-09-17 18:45:28 +0000
@@ -0,0 +1,7 @@
+using GLib;
+
+int main (string[] args){
+  test.shapes s = new test.shapes();
+  s.run();
+  return 0;
+}

=== added file 'tests/shapes/shapes.vala'
--- tests/shapes/shapes.vala	1970-01-01 00:00:00 +0000
+++ tests/shapes/shapes.vala	2012-09-17 18:45:28 +0000
@@ -0,0 +1,168 @@
+using GLib;
+using SDL;
+using Gee;
+using vProcessing;
+
+namespace test {
+  public class shapes : PMain {
+    
+    private Point[] points;
+    private vPolly a_polly;
+    private vPolly b_polly;
+    private vPolly c_polly;
+    
+    private int16 xi;
+    private int16 yi;
+    private bool goLeft;
+    private bool goDown;
+    
+    private bool expand_x;
+    private bool expand_y;
+    private int16 expx;
+    private int16 expy;
+    
+    private vRect a_rect;
+    private vRect b_rect;
+    
+    private vCircle a_circle;
+    private vCircle b_circle;
+    
+    public shapes () {
+      this.size (400, 600);
+      
+    }
+    
+    public override void setup () {
+      
+      this.a_rect = new vRect(560,20,30,20,false);
+      this.b_rect = new vRect(555,15,30,20,true);
+      this.xi = 0;
+      this.yi = 0;
+      this.goLeft = true;
+      this.goDown = true;
+      
+      
+      this.a_circle = new vCircle(150,150,25,10,false);
+      this.b_circle = new vCircle(300, 300, 150, 100, true);
+      this.expand_x = false;
+      this.expand_y = true;
+      this.expx = 50;
+      this.expy = 10;
+      
+      stdout.printf("hello from shapes!\n");
+      
+      //-----------
+      points = new Point[7];
+      stdout.printf("adding points...\n");
+      //------------
+      points[0] = new Point(0,0);
+      points[1] = new Point(50,50);
+      points[2] = new Point(50,0);
+      points[3] = new Point(100,0);
+      points[4] = new Point(100,50);
+      points[5] = new Point(70,50);
+      points[6] = new Point(50,70);
+      //-----------
+      stdout.printf("done adding points.\n");
+      stdout.printf("Creating vPolly...\n");
+      a_polly = new vPolly.fromArrayOfPoints(10,10,false,points);
+      b_polly = new vPolly.fromArrayOfPoints(100,100,true,points);
+      c_polly = new vPolly.fromArrayOfPoints(490,10,true,points);
+      
+      stdout.printf("done creating vPolly\n");
+    }
+    
+    public override void draw () {
+      
+      this.clear();
+      
+      // ----------
+      
+      if(goLeft) {
+        xi++;
+      } else {
+        xi--;
+      }
+      
+      if (xi >= 600 - 100) {
+        goLeft = false;
+      } else if (xi <= 0) {
+        goLeft = true;
+      }
+      
+      if(goDown) {
+        yi++;
+      } else {
+        yi--;
+      }
+      
+      if (yi >= 400 - 70) {
+        goDown = false;
+      } else if (yi <= 0) {
+        goDown = true;
+      }
+      
+      // ----------
+      
+      if(this.expand_x) {
+        this.expx++;
+        a_circle.rx = expx;
+      } else {
+        this.expx--;
+        a_circle.rx = expx;
+      }
+      
+      if(this.expx >= 150) {
+        this.expand_x = false;
+      } else if (this.expx <= 10) {
+        this.expand_x = true;
+      }
+      
+      if(this.expand_y) {
+        this.expy++;
+        a_circle.ry = expy;
+      } else {
+        this.expy--;
+        a_circle.ry = expy;
+      }
+      
+      if(this.expy >= 150) {
+        this.expand_y = false;
+      } else if (this.expy <= 10) {
+        this.expand_y = true;
+      }
+      
+      //-----------
+      
+      this.set_color(255, 255,255,255);
+      
+      b_polly.set_posision(xi, yi);
+      
+      a_polly.draw(this.screen, this.get_color(), null);
+      b_polly.draw(this.screen, this.get_color(), null);
+      c_polly.draw(this.screen, this.get_color(), null);
+      
+      a_rect.draw(this.screen, this.get_color(), null);
+      if(b_rect.is_inside(this.get_MouseEvent().to_point()) && this.mouse_down()) {
+        this.set_color(11, 11,255,255);
+      } else {
+        this.set_color(255, 255,255,255);
+      }
+      
+      b_rect.draw(this.screen, this.get_color(), null);
+      
+      this.set_color( (uchar)expy, (uchar)expx, (uchar)expx - (uchar)expy, 255);
+      
+      a_circle.draw(this.screen, this.get_color(), null);
+      
+      this.set_color(150, 150,255,100);
+      
+      if (b_circle.is_inside(this.get_MouseEvent().to_point())){
+        b_circle.draw(this.screen, this.get_color(), true);
+      } else {
+        b_circle.draw(this.screen, this.get_color(), false);
+      }
+    }
+  }
+  
+}

=== added directory 'tests/template'
=== added file 'tests/template/Makefile'
--- tests/template/Makefile	1970-01-01 00:00:00 +0000
+++ tests/template/Makefile	2012-09-17 18:45:28 +0000
@@ -0,0 +1,41 @@
+########################
+## THIS FILE IS PUBLIC DOMAIN, AND IS ALLOWD TO USE AS YOU AND/OR OTHER PARTIES
+## SEE FIT.
+## THIS FILE COMES WETH ABSOLUTLY NO WARRENTY, ALL AND ANNY MONYTARY AND/OR
+## PROPERTY CLAIMS ARE VOID.
+########################
+VALAC=valac-0.16
+VALAFILES=main.vala\
+          foo.vala
+VALAPKGS=--pkg glib-2.0\
+         --pkg vProcessing\
+         --pkg sdl\
+         --pkg sdl-gfx\
+         --pkg sdl-mixer\
+         --pkg sdl-ttf\
+         --pkg gee-1.0
+
+INCLUDEDIR=./../../
+CCEXTRA=--vapidir=$(INCLUDEDIR)\
+        -X -I$(INCLUDEDIR)\
+        -X -L$(INCLUDEDIR)\
+        -X -lvProcessing
+
+EXEC=main
+
+default:
+	$(VALAC) -o $(EXEC) $(VALAFILES) $(VALAPKGS) $(CCEXTRA)
+
+.PHONY: run clean test
+
+.IGNORE: run clean test
+
+run:
+	LD_LIBRARY_PATH=LD_LIBRARY_PATH:./../../ ./$(EXEC)
+
+clean:
+	rm $(EXEC)
+	rm *~
+
+test:clean default run
+

=== added file 'tests/template/foo.vala'
--- tests/template/foo.vala	1970-01-01 00:00:00 +0000
+++ tests/template/foo.vala	2012-09-17 18:45:28 +0000
@@ -0,0 +1,32 @@
+/*
+ * THIS FILE IS PUBLIC DOMAIN, AND IS ALLOWD TO USE AS YOU AND/OR OTHER PARTIES
+ * SEE FIT.
+ * THIS FILE COMES WETH ABSOLUTLY NO WARRENTY, ALL AND ANNY MONYTARY AND/OR
+ * PROPERTY CLAIMS ARE VOID.
+ */
+
+using GLib;
+using vProcessing;
+using SDL;
+
+namespace foo {
+  
+  public class foo : PMain {
+    
+    //Constructior
+    public foo () {
+      this.size(400, 600);
+      this.run();
+    }
+    
+    public override void setup () {
+      
+    }
+    
+    public override void draw () {
+      
+    }
+    
+  }
+  
+}

=== added file 'tests/template/main.vala'
--- tests/template/main.vala	1970-01-01 00:00:00 +0000
+++ tests/template/main.vala	2012-09-17 18:45:28 +0000
@@ -0,0 +1,17 @@
+/*
+ * THIS FILE IS PUBLIC DOMAIN, AND IS ALLOWD TO USE AS YOU AND/OR OTHER PARTIES
+ * SEE FIT.
+ * THIS FILE COMES WETH ABSOLUTLY NO WARRENTY, ALL AND ANNY MONYTARY AND/OR
+ * PROPERTY CLAIMS ARE VOID.
+ */
+using GLib;
+using vProcessing;
+using SDL;
+using foo;
+
+int main (string args[]) {
+  
+  foo.foo a = new foo.foo ();
+  
+  return 0;
+}

=== added file 'tests/template/run.sh'
--- tests/template/run.sh	1970-01-01 00:00:00 +0000
+++ tests/template/run.sh	2012-09-17 18:45:28 +0000
@@ -0,0 +1,1 @@
+LD_LIBRARY_PATH=./../../ ./main