indent mosaic.c

magic/src/mosaic.c

@@ -57,17 +57,10 @@ int mosaic_get_tool_count(magic_api *);
 SDL_Surface *mosaic_get_icon(magic_api *, int);
 char *mosaic_get_name(magic_api *, int);
 char *mosaic_get_description(magic_api *, int, int);
-void mosaic_paint(void *, int, SDL_Surface *, 
+void mosaic_paint(void *, int, SDL_Surface *, SDL_Surface *, int, int);
-	SDL_Surface *, int, int);
+void mosaic_drag(magic_api *, int, SDL_Surface *, SDL_Surface *, int, int, int, int, SDL_Rect *);
-void mosaic_drag(magic_api *, int, SDL_Surface *,
+void mosaic_click(magic_api *, int, int, SDL_Surface *, SDL_Surface *, int, int, SDL_Rect *);
-	SDL_Surface *, int, int, int, int,
+void mosaic_release(magic_api *, int, SDL_Surface *, SDL_Surface *, int, int, SDL_Rect *);
-	SDL_Rect *);
-void mosaic_click(magic_api *, int, int,
-	SDL_Surface *, SDL_Surface *,
-	int, int, SDL_Rect *);
-void mosaic_release(magic_api *, int,
-	SDL_Surface *, SDL_Surface *,
-	int, int, SDL_Rect *);
 void mosaic_shutdown(magic_api *);
 void mosaic_set_color(magic_api *, Uint8, Uint8, Uint8);
 int mosaic_requires_colors(magic_api *, int);
@@ -80,7 +73,8 @@ static const int mosaic_RADIUS = 16;
 static const double mosaic_SHARPEN = 1.0;
 static int randnoise ATTRIBUTE_UNUSED;
 Uint8 *mosaic_blured;
-enum {
+enum
+{
   TOOL_MOSAIC,
   mosaic_NUM_TOOLS
 };
@@ -93,26 +87,34 @@ static SDL_Surface * canvas_sharp;
 const char *mosaic_snd_filenames[mosaic_NUM_TOOLS] = {
   "mosaic.ogg",                 /* FIXME */
 };
+
 const char *mosaic_icon_filenames[mosaic_NUM_TOOLS] = {
   "mosaic.png",
 };
+
 const char *mosaic_names[mosaic_NUM_TOOLS] = {
   gettext_noop("Mosaic"),
 };
+
 const char *mosaic_descs[mosaic_NUM_TOOLS][2] = {
   {gettext_noop("Click and drag the mouse to add a mosaic effect to parts of your picture."),
    gettext_noop("Click to add a mosaic effect to your entire picture."),},
 };
 
-Uint32 mosaic_api_version(void) { return(TP_MAGIC_API_VERSION); }
+Uint32 mosaic_api_version(void)
+{
+  return (TP_MAGIC_API_VERSION);
+}
 
 //Load sounds
-int mosaic_init(magic_api * api){
+int mosaic_init(magic_api * api)
+{
 
   int i;
   char fname[1024];
 
-  for (i = 0; i < mosaic_NUM_TOOLS; i++){
+  for (i = 0; i < mosaic_NUM_TOOLS; i++)
+    {
       snprintf(fname, sizeof(fname), "%s/sounds/magic/%s", api->data_directory, mosaic_snd_filenames[i]);
       mosaic_snd_effect[i] = Mix_LoadWAV(fname);
     }
@@ -120,46 +122,49 @@ int mosaic_init(magic_api * api){
   return (1);
 }
 
-int mosaic_get_tool_count(magic_api * api ATTRIBUTE_UNUSED){
+int mosaic_get_tool_count(magic_api * api ATTRIBUTE_UNUSED)
+{
   return (mosaic_NUM_TOOLS);
 }
 
 // Load our icons:
-SDL_Surface * mosaic_get_icon(magic_api * api, int which){
+SDL_Surface *mosaic_get_icon(magic_api * api, int which)
+{
   char fname[1024];
+
   snprintf(fname, sizeof(fname), "%simages/magic/%s", api->data_directory, mosaic_icon_filenames[which]);
   return (IMG_Load(fname));
 }
 
 // Return our names, localized:
-char * mosaic_get_name(magic_api * api ATTRIBUTE_UNUSED, int which){
+char *mosaic_get_name(magic_api * api ATTRIBUTE_UNUSED, int which)
+{
   return (strdup(gettext_noop(mosaic_names[which])));
 }
 
 // Return our descriptions, localized:
-char * mosaic_get_description(magic_api * api ATTRIBUTE_UNUSED, 
+char *mosaic_get_description(magic_api * api ATTRIBUTE_UNUSED, int which, int mode)
-	  int which, int mode){
+{
   return (strdup(gettext_noop(mosaic_descs[which][mode - 1])));
 }
 
 //Calculates the grey scale value for a rgb pixel
-static int mosaic_grey(Uint8 r1,Uint8 g1,Uint8 b1){
+static int mosaic_grey(Uint8 r1, Uint8 g1, Uint8 b1)
+{
   return 0.3 * r1 + .59 * g1 + 0.11 * b1;
 }
 
 // Do the effect for the full image
 static void do_mosaic_full(void *ptr, SDL_Surface * canvas,
-	  SDL_Surface * last ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED){
+                           SDL_Surface * last ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED)
+{
 
   magic_api *api = (magic_api *) ptr;
 
   int x, y;
 
-Uint32 amask = ~(canvas->format->Rmask |
+  Uint32 amask = ~(canvas->format->Rmask | canvas->format->Gmask | canvas->format->Bmask);
-            canvas->format->Gmask |
+  SDL_Surface *mosaic_temp = SDL_CreateRGBSurface(SDL_SWSURFACE,
-            canvas->format->Bmask);
-  SDL_Surface * mosaic_temp = 
-    SDL_CreateRGBSurface(SDL_SWSURFACE,
                                                   canvas->w,
                                                   canvas->h,
                                                   canvas->format->BitsPerPixel,
@@ -171,17 +176,21 @@ Uint32 amask = ~(canvas->format->Rmask |
 
   api->update_progress_bar();
 
-  for (y = 0; y < canvas->h; y++){ 
+  for (y = 0; y < canvas->h; y++)
+    {
 
-		for (x=0; x < canvas->w; x++){
+      for (x = 0; x < canvas->w; x++)
+        {
           mosaic_blur_pixel(api, mosaic_temp, canvas_noise, x, y);
         }
     }
 
   api->update_progress_bar();
 
-  for (y = 0; y < canvas->h; y++){ 
+  for (y = 0; y < canvas->h; y++)
-		for (x=0; x < canvas->w; x++){
+    {
+      for (x = 0; x < canvas->w; x++)
+        {
           mosaic_sharpen_pixel(api, canvas, mosaic_temp, x, y);
         }
     }
@@ -191,8 +200,7 @@ Uint32 amask = ~(canvas->format->Rmask |
 /* Paint the brush, noise is yet done at switchin, 
    blurs 2 pixels around the brush in order to get sharpen well done.*/
 void mosaic_paint(void *ptr_to_api, int which ATTRIBUTE_UNUSED,
-		  SDL_Surface * canvas, SDL_Surface * last ATTRIBUTE_UNUSED, 
+                  SDL_Surface * canvas, SDL_Surface * last ATTRIBUTE_UNUSED, int x, int y)
-		  int x, int y)
 {
   int i, j, pix_row_pos;
 
@@ -202,8 +210,7 @@ void mosaic_paint(void * ptr_to_api, int which ATTRIBUTE_UNUSED,
     {
       pix_row_pos = j * canvas->w;
       for (i = max(0, x - mosaic_RADIUS - 2); i < min(canvas->w, x + mosaic_RADIUS + 2); i++)
-	if( !mosaic_blured[pix_row_pos + i] &&
+        if (!mosaic_blured[pix_row_pos + i] && api->in_circle(i - x, j - y, mosaic_RADIUS + 2))
-	    api->in_circle(i - x,j - y, mosaic_RADIUS + 2))
           {
             mosaic_blur_pixel(api, canvas_blur, canvas_noise, i, j);
             mosaic_blured[pix_row_pos + i] = 1; /* Track what are yet blured */
@@ -222,8 +229,8 @@ for (i = x - mosaic_RADIUS; i < x + mosaic_RADIUS; i++)
 
 // Affect the canvas on drag:
 void mosaic_drag(magic_api * api, int which, SDL_Surface * canvas,
-	          SDL_Surface * last, int ox, int oy, int x, int y,
+                 SDL_Surface * last, int ox, int oy, int x, int y, SDL_Rect * update_rect)
-		  SDL_Rect * update_rect){
+{
   api->line(api, which, canvas, last, ox, oy, x, y, 1, mosaic_paint);
 
   update_rect->x = min(ox, x) - mosaic_RADIUS;
@@ -236,8 +243,8 @@ void mosaic_drag(magic_api * api, int which, SDL_Surface * canvas,
 
 // Affect the canvas on click:
 void mosaic_click(magic_api * api, int which, int mode,
-	            SDL_Surface * canvas, SDL_Surface * last,
+                  SDL_Surface * canvas, SDL_Surface * last, int x, int y, SDL_Rect * update_rect)
-	            int x, int y, SDL_Rect * update_rect){
+{
 
   if (mode == MODE_FULLSCREEN)
     {
@@ -260,8 +267,7 @@ void mosaic_release(magic_api * api ATTRIBUTE_UNUSED,
                     int which ATTRIBUTE_UNUSED,
                     SDL_Surface * canvas ATTRIBUTE_UNUSED,
                     SDL_Surface * last ATTRIBUTE_UNUSED,
-	           int x ATTRIBUTE_UNUSED, int y ATTRIBUTE_UNUSED, 
+                    int x ATTRIBUTE_UNUSED, int y ATTRIBUTE_UNUSED, SDL_Rect * update_rect ATTRIBUTE_UNUSED)
-		   SDL_Rect * update_rect ATTRIBUTE_UNUSED)
 {
 }
 
@@ -270,8 +276,11 @@ void mosaic_shutdown(magic_api * api ATTRIBUTE_UNUSED)
 {
   //Clean up sounds
   int i;
-	for(i=0; i<mosaic_NUM_TOOLS; i++){
+
-		if(mosaic_snd_effect[i] != NULL){
+  for (i = 0; i < mosaic_NUM_TOOLS; i++)
+    {
+      if (mosaic_snd_effect[i] != NULL)
+        {
           Mix_FreeChunk(mosaic_snd_effect[i]);
         }
     }
@@ -279,20 +288,19 @@ void mosaic_shutdown(magic_api * api ATTRIBUTE_UNUSED)
 
 // Record the color from Tux Paint:
 void mosaic_set_color(magic_api * api ATTRIBUTE_UNUSED,
-	          Uint8 r ATTRIBUTE_UNUSED, Uint8 g ATTRIBUTE_UNUSED,
+                      Uint8 r ATTRIBUTE_UNUSED, Uint8 g ATTRIBUTE_UNUSED, Uint8 b ATTRIBUTE_UNUSED)
-		  Uint8 b ATTRIBUTE_UNUSED)
 {
 }
 
 // Use colors:
-int mosaic_requires_colors(magic_api * api ATTRIBUTE_UNUSED,
+int mosaic_requires_colors(magic_api * api ATTRIBUTE_UNUSED, int which ATTRIBUTE_UNUSED)
-	          int which ATTRIBUTE_UNUSED)
 {
   return 0;
 }
 
 //Add noise to a pixel
-static void mosaic_noise_pixel(void * ptr, SDL_Surface * canvas, int noise_AMOUNT, int x, int y){
+static void mosaic_noise_pixel(void *ptr, SDL_Surface * canvas, int noise_AMOUNT, int x, int y)
+{
   magic_api *api = (magic_api *) ptr;
 
   Uint8 temp[3];
@@ -300,48 +308,56 @@ static void mosaic_noise_pixel(void * ptr, SDL_Surface * canvas, int noise_AMOUN
   int k;
 
   SDL_GetRGB(api->getpixel(canvas, x, y), canvas->format, &temp[0], &temp[1], &temp[2]);
-  for (k =0;k<3;k++){
+  for (k = 0; k < 3; k++)
+    {
       temp2[k] = clamp(0.0, (int)temp[k] - (rand() % noise_AMOUNT) + noise_AMOUNT / 2.0, 255.0);
     }
   api->putpixel(canvas, x, y, SDL_MapRGB(canvas->format, temp2[0], temp2[1], temp2[2]));
 }
 
 //Blur a pixel
-static void mosaic_blur_pixel(void * ptr, SDL_Surface * canvas, SDL_Surface * last, int x, int y){
+static void mosaic_blur_pixel(void *ptr, SDL_Surface * canvas, SDL_Surface * last, int x, int y)
+{
   magic_api *api = (magic_api *) ptr;
   int i, j, k;
   Uint8 temp[3];
   double blurValue[3];
+
   //5x5 gaussiann weighting window
   const int weight[5][5] = { {1, 4, 7, 4, 1},
   {4, 16, 26, 16, 4},
   {7, 26, 41, 26, 7},
   {4, 16, 26, 16, 4},
-                              {1,4,7,4,1}};
+  {1, 4, 7, 4, 1}
+  };
 
-  for (k =0;k<3;k++){
+  for (k = 0; k < 3; k++)
+    {
       blurValue[k] = 0;
     }
 
-  for (i=-2;i<3;i++){
+  for (i = -2; i < 3; i++)
-    for (j=-2;j<3;j++){
+    {
+      for (j = -2; j < 3; j++)
+        {
           //Add the pixels around the current one wieghted 
           SDL_GetRGB(api->getpixel(last, x + i, y + j), last->format, &temp[0], &temp[1], &temp[2]);
-      for (k =0;k<3;k++){
+          for (k = 0; k < 3; k++)
+            {
               blurValue[k] += temp[k] * weight[i + 2][j + 2];
             }
         }
     }
-  for (k =0;k<3;k++){
+  for (k = 0; k < 3; k++)
+    {
       blurValue[k] /= 273;
     }
   api->putpixel(canvas, x, y, SDL_MapRGB(canvas->format, blurValue[0], blurValue[1], blurValue[2]));
 }
 
 //Sharpen a pixel
-static void mosaic_sharpen_pixel(void * ptr,
+static void mosaic_sharpen_pixel(void *ptr, SDL_Surface * canvas, SDL_Surface * last, int x, int y)
-	         SDL_Surface * canvas, SDL_Surface * last,
+{
-	         int x, int y){
 
   magic_api *api = (magic_api *) ptr;
 
@@ -354,15 +370,19 @@ static void mosaic_sharpen_pixel(void * ptr,
   //Sobel weighting masks
   const int sobel_weights_1[3][3] = { {1, 2, 1},
   {0, 0, 0},
-                                      {-1,-2,-1}};
+  {-1, -2, -1}
+  };
   const int sobel_weights_2[3][3] = { {-1, 0, 1},
   {-2, 0, 2},
-                                      {-1,0,1}};
+  {-1, 0, 1}
+  };
 
   sobel_1 = 0;
   sobel_2 = 0;
-			for (i=-1;i<2;i++){
+  for (i = -1; i < 2; i++)
-				for(j=-1; j<2; j++){
+    {
+      for (j = -1; j < 2; j++)
+        {
           //No need to check if inside canvas, getpixel does it for us.
           SDL_GetRGB(api->getpixel(last, x + i, y + j), last->format, &r1, &g1, &b1);
           grey = mosaic_grey(r1, g1, b1);
@@ -381,8 +401,7 @@ static void mosaic_sharpen_pixel(void * ptr,
 
 }
 
-void mosaic_switchin(magic_api * api, int which ATTRIBUTE_UNUSED, 
+void mosaic_switchin(magic_api * api, int which ATTRIBUTE_UNUSED, int mode ATTRIBUTE_UNUSED, SDL_Surface * canvas)
-		int mode ATTRIBUTE_UNUSED, SDL_Surface * canvas)
 {
   int y, x;
   Uint32 amask;
@@ -394,22 +413,20 @@ void mosaic_switchin(magic_api * api, int which ATTRIBUTE_UNUSED,
       exit(1);
     }
 
-  amask = ~(canvas->format->Rmask |
+  amask = ~(canvas->format->Rmask | canvas->format->Gmask | canvas->format->Bmask);
-		   canvas->format->Gmask |
-		   canvas->format->Bmask);
 
   canvas_noise = SDL_CreateRGBSurface(SDL_SWSURFACE,
                                       canvas->w,
                                       canvas->h,
                                       canvas->format->BitsPerPixel,
-                         canvas->format->Rmask,
+                                      canvas->format->Rmask, canvas->format->Gmask, canvas->format->Bmask, amask);
-                         canvas->format->Gmask,
-                         canvas->format->Bmask, amask);
 
   SDL_BlitSurface(canvas, NULL, canvas_noise, NULL);
 
-  for (y = 0; y < canvas->h; y++){ 
+  for (y = 0; y < canvas->h; y++)
-		for (x=0; x < canvas->w; x++){
+    {
+      for (x = 0; x < canvas->w; x++)
+        {
           mosaic_noise_pixel(api, canvas_noise, mosaic_AMOUNT, x, y);
         }
     }
@@ -418,23 +435,18 @@ void mosaic_switchin(magic_api * api, int which ATTRIBUTE_UNUSED,
                                      canvas->w,
                                      canvas->h,
                                      canvas->format->BitsPerPixel,
-                         canvas->format->Rmask,
+                                     canvas->format->Rmask, canvas->format->Gmask, canvas->format->Bmask, amask);
-                         canvas->format->Gmask,
-                         canvas->format->Bmask, amask);
 
   canvas_sharp = SDL_CreateRGBSurface(SDL_SWSURFACE,
                                       canvas->w,
                                       canvas->h,
                                       canvas->format->BitsPerPixel,
-                         canvas->format->Rmask,
+                                      canvas->format->Rmask, canvas->format->Gmask, canvas->format->Bmask, amask);
-                         canvas->format->Gmask,
-                         canvas->format->Bmask, amask);
   reset_mosaic_blured(canvas);
 }
 
 void mosaic_switchout(magic_api * api ATTRIBUTE_UNUSED,
-		int which ATTRIBUTE_UNUSED, int mode ATTRIBUTE_UNUSED, 
+                      int which ATTRIBUTE_UNUSED, int mode ATTRIBUTE_UNUSED, SDL_Surface * canvas ATTRIBUTE_UNUSED)
-		SDL_Surface * canvas ATTRIBUTE_UNUSED)
 {
   SDL_FreeSurface(canvas_noise);
   SDL_FreeSurface(canvas_blur);