Added 3 'string art' tools.

docs/CHANGES.txt

@@ -8,7 +8,7 @@ http://www.tuxpaint.org/
 
 $Id$
 
-2009.February.14 (0.9.21)
+2009.February.21 (0.9.21)
   * New Starters:
     -------------
     * Silver Frame
@@ -49,6 +49,11 @@ $Id$
       with modifications by Bill Kendrick
       and Pere Pujal i Carabantes <pere@fornol.no-ip.org>
 
+    * String Edges - Draw string-like patters around the screen.
+      String Corner - Draw aligned string-like patterns.
+      String 'V' - Draw free-form string-like patterns.
+      By Pere Pujal i Carabantes <pere@fornol.no-ip.org>
+
   * Magic Tool Improvememnts:
     --------------------------
     * Added "_switchin()" and "_switchout()" functions to Magic tool API,

magic/src/string.c

@@ -0,0 +1,462 @@
+#include "tp_magic_api.h"
+#include "SDL_image.h"
+#include "SDL_mixer.h"
+
+
+Mix_Chunk * string_snd;
+unsigned int img_w, img_h;
+static Uint8 string_r, string_g, string_b;   
+static int string_ox, string_oy;
+static int string_vertex_x, string_vertex_y, string_vertex_done, string_vertex_distance;
+static SDL_Surface * canvas_backup;
+enum string_tools{
+  STRING_TOOL_FULL_BY_OFFSET,
+  STRING_TOOL_TRIANGLE,
+  STRING_TOOL_ANGLE,
+  STRING_NUMTOOLS};
+
+// Custom function declarations
+
+void string_callback(void * ptr, int which_tool,
+		     SDL_Surface * canvas, SDL_Surface * snapshot, int x, int y);
+void string_draw_triangle(magic_api * api, int which,
+			  SDL_Surface * canvas, SDL_Surface * snapshot, int ox, int oy, int x, int y,
+			  SDL_Rect * update_rect);
+void string_draw_angle(magic_api * api, int which,
+		       SDL_Surface * canvas, SDL_Surface * snapshot, int ox, int oy, int x, int y,
+		       SDL_Rect * update_rect);
+void string_draw_triangle_preview(magic_api * api, int which,
+				  SDL_Surface * canvas, SDL_Surface * snapshot, int ox, int oy, int x, int y,
+				  SDL_Rect * update_rect);
+void string_draw_angle_preview(magic_api * api, int which,
+			       SDL_Surface * canvas, SDL_Surface * snapshot, int ox, int oy, int x, int y,
+			       SDL_Rect * update_rect);
+void scale_xcoord(int * xcoord);
+void scale_ycoord(int * ycoord);
+void scale_coords(int * ox, int * oy, int * x, int * y);
+void string_draw_wrapper(magic_api * api, int which,
+			 SDL_Surface * canvas, SDL_Surface * snapshot, int ox, int oy, int x, int y,
+			 SDL_Rect * update_rect);
+void string_set_vertex(int x, int y);
+void compute_middle( int start_point, int end_point, int vertex, int * middle);
+
+
+// Prototypes for required functions
+
+void string_drag(magic_api * api, int which, SDL_Surface * canvas,
+		 SDL_Surface * snapshot, int ox, int oy, int x, int y,
+		 SDL_Rect * update_rect);
+
+
+Uint32 string_api_version(void);
+int string_modes(magic_api * api, int which);
+void string_set_color(magic_api * api, Uint8 r, Uint8 g, Uint8 b);
+int string_get_tool_count(magic_api * api);
+SDL_Surface * string_get_icon(magic_api * api, int which);
+char * string_get_name(magic_api * api, int which);
+char * string_get_description(magic_api * api, int which, int mode);
+int string_requires_colors(magic_api * api, int which);
+void string_release(magic_api * api, int which,
+		    SDL_Surface * canvas, SDL_Surface * snapshot,
+		    int x, int y, SDL_Rect * update_rect);
+int string_init(magic_api * api);
+void string_shutdown(magic_api * api);
+void string_switchin(magic_api * api, int which, int mode, SDL_Surface * canvas, SDL_Surface * snapshot);
+void string_switchout(magic_api * api, int which, int mode, SDL_Surface * canvas, SDL_Surface * snapshot);
+void string_click(magic_api * api, int which, int mode,
+		  SDL_Surface * canvas, SDL_Surface * snapshot,
+		  int x, int y, SDL_Rect * update_rect);
+
+// Required functions
+
+Uint32 string_api_version(void)
+{
+  return(TP_MAGIC_API_VERSION);
+}
+
+int string_modes(__attribute__((unused)) magic_api * api, __attribute__((unused)) int which)
+{
+  return(MODE_PAINT);
+}
+
+void string_set_color(__attribute__((unused)) magic_api * api, Uint8 r, Uint8 g, Uint8 b)
+{
+  string_r=r;
+  string_g=g;
+  string_b=b;
+}
+ 
+
+
+int string_get_tool_count(__attribute__((unused)) magic_api * api)
+{
+  return STRING_NUMTOOLS;
+}
+
+SDL_Surface * string_get_icon(magic_api * api, int which)
+{
+  char fname[1024];
+  switch (which)
+    {
+    case STRING_TOOL_FULL_BY_OFFSET:
+      snprintf(fname, sizeof(fname), "%s/images/magic/string_art_full_by_offset.png", api->data_directory);
+      break;
+    case   STRING_TOOL_TRIANGLE:
+      snprintf(fname, sizeof(fname), "%s/images/magic/string_art_triangles.png", api->data_directory);
+      break;
+    case STRING_TOOL_ANGLE:
+      snprintf(fname, sizeof(fname), "%s/images/magic/string_art_angles.png", api->data_directory);
+      break;
+    }
+
+  return(IMG_Load(fname));
+}
+
+
+char * string_get_name(__attribute__((unused)) magic_api * api, __attribute__((unused)) int which) 
+{
+  switch (which)
+    {
+    case STRING_TOOL_FULL_BY_OFFSET:
+      return strdup(gettext_noop("String edges"));
+      break;
+    case   STRING_TOOL_TRIANGLE:
+      return strdup(gettext_noop("String corner"));
+      break;
+    default:
+      return strdup(gettext_noop("String 'V'"));
+    }
+}
+
+char * string_get_description(__attribute__((unused)) magic_api * api, int which, __attribute__((unused)) int mode) {
+  switch (which)
+    {
+    case STRING_TOOL_FULL_BY_OFFSET:
+      return strdup(gettext_noop("Click and drag to draw string art. Drag top-bottom to draw less or more lines, to the center to approach the lines to center."));
+      break;
+    case   STRING_TOOL_TRIANGLE:
+      return strdup(gettext_noop("Click and drag to draw string art aligned to the edges."));
+      break;
+    default:
+      return strdup(gettext_noop("Draw string art with free angles. Click and drag a V: drag to the vertex, drag backwards a little to the start, then drag to the end."));
+    }
+}
+
+int string_requires_colors(__attribute__((unused)) magic_api * api, __attribute__((unused)) int which) { return 1;}
+
+void string_release(magic_api * api, int which,
+		    SDL_Surface * canvas, SDL_Surface * snapshot,
+		    int x, int y, SDL_Rect * update_rect)
+{
+  int dx, dy;
+  if (which==STRING_TOOL_TRIANGLE)
+    string_draw_triangle((void *) api, which, canvas, snapshot, string_ox, string_oy, x, y, update_rect);
+  if (which==STRING_TOOL_ANGLE)
+    {
+    if(!string_vertex_done) // maybe we face small children, draw square angles aligned to the drag
+      {
+	dx=string_ox - x;
+	dy=string_oy - y;
+	y=y + dx;
+	x=x - dy;
+      }
+    string_draw_angle((void *) api, which, canvas, snapshot, string_ox, string_oy, x, y, update_rect);
+    }
+  //  no sound at the moment
+  //  api->playsound(string_snd, (x * 255) / canvas->w, 255);
+}
+
+int string_init(__attribute__((unused)) magic_api * api)
+{  
+  return(1);
+}
+
+void string_shutdown(__attribute__((unused)) magic_api * api)
+{
+  if (canvas_backup) 
+    SDL_FreeSurface(canvas_backup);
+}
+
+void string_switchin(__attribute__((unused)) magic_api * api, __attribute__((unused)) int which, __attribute__((unused)) int mode,  SDL_Surface * canvas, __attribute__((unused)) SDL_Surface * snapshot)
+{
+  canvas_backup=SDL_CreateRGBSurface(SDL_ANYFORMAT, canvas->w, canvas->h, canvas->format->BitsPerPixel,
+				     canvas->format->Rmask, canvas->format->Gmask, canvas->format->Bmask, canvas->format->Amask);
+}
+
+void string_switchout(__attribute__((unused)) magic_api * api, __attribute__((unused)) int which, __attribute__((unused)) int mode, __attribute__((unused)) SDL_Surface * canvas, __attribute__((unused)) SDL_Surface * snapshot)
+{
+  SDL_FreeSurface(canvas_backup);
+  canvas_backup=0;
+}
+
+// Interactivity functions
+
+
+void string_callback(void * ptr,__attribute__((unused)) int which,
+		     SDL_Surface * canvas,__attribute__((unused)) SDL_Surface * snapshot, int x, int y)
+{
+  magic_api * api = (magic_api *) ptr;
+  api->putpixel(canvas, x, y, SDL_MapRGBA(canvas->format, string_r, string_g, string_b,255));
+}
+
+
+void string_click(magic_api * api, int which,__attribute__((unused)) int mode,
+		  SDL_Surface * canvas, SDL_Surface * snapshot,
+		  int x, int y, SDL_Rect * update_rect)
+{
+  SDL_BlitSurface(canvas, NULL, canvas_backup, NULL);
+
+  string_ox=x;
+  string_oy=y;
+  string_vertex_distance=0;
+  string_vertex_done=0;
+  string_drag(api, which, canvas, snapshot, x, y, x, y, update_rect);
+}
+
+static void string_draw_full_by_offset(void * ptr, __attribute__((unused)) int which, SDL_Surface * canvas, __attribute__((unused)) SDL_Surface * snapshot,
+				       int x,  int y, SDL_Rect * update_rect)
+{
+  magic_api * api = (magic_api *) ptr;
+  int u;
+  int i;
+  int o; //offset
+  // int n=y/5;
+  int ** a;  
+  float step_w, step_h, aux;
+  int side=(int)(y/3);
+
+  SDL_BlitSurface(snapshot,0,canvas,0);
+
+  if (side<3) side=3;
+
+  o=(int)(side*4*x/canvas->w);  
+  step_w=canvas->w/(float)side;
+  step_h=canvas->h/(float)side;
+
+  a=malloc(sizeof(int*)*side*4*2);
+
+  for (i=0;i<side*4;i++)
+    {
+      a[i]=malloc(sizeof(int*)*2);
+      if (i<side) 
+	{
+	  a[i][0]= 0;
+	  aux=step_h*(float)i;
+	  a[i][1]= (int)aux;
+	}
+      else
+	if(i<(side*2))
+	  {
+	    a[i][0]= (int)((float)(i%side)*step_w);
+	    a[i][1]= canvas->h;
+	  }
+	else
+	  if (i<(int)(side*3))
+	    {
+	      a[i][0]= canvas->w;
+	      a[i][1]= (int)(canvas->h - (float)((i%side)*step_h));
+	    }
+	  else
+	    if (i<(int)(side*4))
+	      {
+		a[i][0]=(int)( canvas->w-((float)((i%side)*step_w)));
+		a[i][1]= 0;
+	      }
+    }
+	    
+
+  for (i=0;i<side*4;i++)
+    {
+      u=(i+o)%(side*4);
+      api->line((void *) api, which, canvas, snapshot,a[i][0],a[i][1],a[u][0],a[u][1],1, string_callback);
+    }
+
+  for (i=0;i<side*4;i++)
+    {
+      free(  a[i]);
+    }
+  free(a);
+
+  update_rect->x=0;
+  update_rect->y=0;
+  update_rect->w=canvas->w;
+  update_rect->h=canvas->h;
+}
+
+void scale_xcoord(int * xcoord)
+{
+  if (*xcoord < string_ox) *xcoord=string_ox-(string_ox - *xcoord)*4;
+  else *xcoord=string_ox+(*xcoord-string_ox)*4;
+}
+
+void scale_ycoord(int * ycoord)
+{
+  if (*ycoord < string_oy) *ycoord=string_oy-(string_oy - *ycoord)*4;
+  else *ycoord=string_oy+(*ycoord-string_oy)*4;
+}
+
+void scale_coords(int * ox, int * oy, int * x, int * y)
+{
+  scale_xcoord(ox);
+  scale_xcoord(x);
+  scale_ycoord(oy);
+  scale_ycoord(y);
+}
+
+void compute_middle( int start_point, int end_point, int vertex, int * middle)
+{
+  *middle=min(start_point,end_point)+(max(start_point,end_point)-min(start_point,end_point))/2;
+  *middle=min(*middle,vertex)+(max(*middle,vertex)-min(*middle,vertex))/2;
+}
+
+void string_draw_triangle_preview(magic_api * api, int which,
+				  SDL_Surface * canvas, SDL_Surface * snapshot, int ox, int oy, int x, int y,
+				  SDL_Rect * update_rect)
+{ 
+  scale_coords(&ox, &oy,&x, &y);
+  int middle_x, middle_y;
+  int w, h;
+  w=max(string_ox,x)-min(string_ox,x);
+  h=max(string_oy,y)-min(string_oy,y);
+
+  /*
+    This is enouth if you move the mouse slowly, but if you move the mouse fast,
+    there are rests of old previews left around.
+    update_rect->w=max(max(string_ox,x),max(ox,x))-min(min(string_ox,x),min(ox,x)) +80;
+    update_rect->h=max(max(string_oy,y),max(oy,y))-min(min(string_oy,y),min(oy,y)) +80;
+    update_rect->x=min(string_ox,x) -40;
+    update_rect->y=min(string_oy,y) -40;
+  */
+  update_rect->x=0;
+  update_rect->y=0;
+  update_rect->w=canvas->w;
+  update_rect->h=canvas->h;
+  SDL_BlitSurface(canvas_backup,update_rect,canvas,update_rect);
+
+  compute_middle(x, string_ox, string_ox, &middle_x);
+  compute_middle(y, string_oy, string_oy, &middle_y);
+
+  api->line((void *) api, which, canvas, snapshot, string_ox,string_oy, string_ox , y,1, string_callback);
+  api->line((void *) api, which, canvas, snapshot, string_ox,string_oy, x , string_oy,1, string_callback);
+  api->line((void *) api, which, canvas, snapshot, middle_x,middle_y, x , string_oy,1, string_callback);
+  api->line((void *) api, which, canvas, snapshot, string_ox,y, middle_x , middle_y,1, string_callback);
+}
+
+void string_draw_angle_preview(magic_api * api, int which,
+			       SDL_Surface * canvas, SDL_Surface * snapshot, __attribute__((unused)) int ox, __attribute__ ((unused)) int oy, int x, int y,
+			       SDL_Rect * update_rect)
+{ 
+  int w, h;
+  int middle_x, middle_y;
+  int dx, dy;
+  w=max(string_ox,x)-min(string_ox,x);
+  h=max(string_oy,y)-min(string_oy,y);
+
+  update_rect->x=0;
+  update_rect->y=0;
+  update_rect->w=canvas->w;
+  update_rect->h=canvas->h;
+  SDL_BlitSurface(canvas_backup,update_rect,canvas,update_rect);
+
+  api->line((void *) api, which, canvas, snapshot, string_ox,string_oy, string_vertex_x , string_vertex_y,1, string_callback);
+  if(!string_vertex_done)
+    {
+      //    if(!string_vertex_done) // maybe we face small children, draw square angles aligned to the drag
+      //{
+	dx=string_ox - x;
+	dy=string_oy - y;
+	y=y + dx;
+	x=x - dy;
+      }
+
+      compute_middle(string_ox, x, string_vertex_x, &middle_x);
+      compute_middle(string_oy, y, string_vertex_y, &middle_y);
+
+      api->line((void *) api, which, canvas, snapshot, string_vertex_x,string_vertex_y, x , y,1, string_callback);
+      api->line((void *) api, which, canvas, snapshot, string_ox,string_oy, middle_x , middle_y,1, string_callback);
+      api->line((void *) api, which, canvas, snapshot, x, y, middle_x , middle_y,1, string_callback);
+    
+}
+
+void string_draw_angle(magic_api * api, __attribute__((unused)) int which,
+		       SDL_Surface * canvas, __attribute__((unused))SDL_Surface * snapshot, __attribute__ ((unused)) int ox, __attribute__ ((unused)) int oy, int x, int y,
+		       SDL_Rect * update_rect)
+{
+  float first_arm_step_x, first_arm_step_y, second_arm_step_x, second_arm_step_y;
+  int i;
+  int max_wh , steps;
+  int max_separation=10;
+
+  update_rect->x=min(min(string_ox,string_vertex_x),x);
+  update_rect->y=min(min(string_oy,string_vertex_y),y);
+  update_rect->w=max(max(string_ox,string_vertex_x),x)-update_rect->x;
+  update_rect->h=max(max(string_oy,string_vertex_y),y)-update_rect->y;
+  SDL_BlitSurface(canvas_backup,update_rect,canvas,update_rect);
+
+  max_wh= max(  max(max(string_ox,string_vertex_x),x)- min(min(string_vertex_x , x),string_ox) , max(max(string_oy , string_vertex_y),y)- min(min(string_vertex_y ,y),string_oy));
+
+  steps=max_wh/max_separation;
+  first_arm_step_x=(float)(string_ox-string_vertex_x)/(float)steps;
+  first_arm_step_y=(float)(string_oy-string_vertex_y)/(float)steps;
+  second_arm_step_x=(float)(string_vertex_x-x)/(float)steps;
+  second_arm_step_y=(float)(string_vertex_y-y)/(float)steps;
+
+  for (i=0;i<=steps;i++)
+    {
+      api->line((void *) api, 0, canvas, snapshot, string_ox-first_arm_step_x*i,string_oy-first_arm_step_y*i, string_vertex_x-second_arm_step_x*i,string_vertex_y-second_arm_step_y*i,1, string_callback);
+    }
+}
+
+void string_draw_triangle(magic_api * api, __attribute__((unused)) int which,
+			  SDL_Surface * canvas, SDL_Surface * snapshot, int ox, int oy, int x, int y,
+			  SDL_Rect * update_rect)
+{
+  SDL_BlitSurface(canvas_backup,0,canvas,0);
+  scale_coords(&ox, &oy,&x, &y);
+
+  string_vertex_x=string_ox;
+  string_vertex_y=string_oy;
+  string_ox=string_vertex_x;
+  string_oy=y;
+  y=string_vertex_y;
+
+  string_draw_angle((void *) api, which, canvas, snapshot, string_ox, string_oy, x, y, update_rect);
+}
+
+void string_draw_wrapper(magic_api * api, int which,
+			 SDL_Surface * canvas, SDL_Surface * snapshot, int ox, int oy, int x, int y,
+			 SDL_Rect * update_rect)
+{
+  if (which==STRING_TOOL_FULL_BY_OFFSET)
+    string_draw_full_by_offset((void *) api, which, canvas, snapshot, x, y, update_rect);
+  else if (which==STRING_TOOL_TRIANGLE)
+    string_draw_triangle_preview  ((void *) api, which, canvas, snapshot, ox, oy, x, y, update_rect);
+  else if (which==STRING_TOOL_ANGLE)
+    string_draw_angle_preview  ((void *) api, which, canvas, snapshot, ox, oy, x, y, update_rect);
+}
+
+void string_set_vertex(int x, int y)
+{
+  int dx, dy;
+  if (string_vertex_done) return;
+  dx=max(string_ox,x)-min(string_ox,x);
+  dy=max(string_oy,y)-min(string_oy,y);
+  if(dx+dy>string_vertex_distance) 
+    {
+      string_vertex_distance=dx+dy;
+      string_vertex_x=x;
+      string_vertex_y=y;
+    }
+  if(dx+dy+30<string_vertex_distance) string_vertex_done=1;
+}
+
+void string_drag(magic_api * api, int which,
+		 SDL_Surface * canvas, SDL_Surface * snapshot, int ox, int oy, int x, int y,
+		 SDL_Rect * update_rect)
+{
+  if ((x<canvas->w)&&(y<canvas->h)&&(ox<canvas->w)&&(oy<canvas->h)&&((signed)x>0)&&((signed)y>0)&&((signed)ox>0)&&((signed)oy>0))
+    {
+      string_set_vertex(x,y);
+      string_draw_wrapper((void *) api, which, canvas, snapshot,ox,oy, x, y,  update_rect);
+    }
+}