/*  Grafx2 - The Ultimate 256-color bitmap paint program

    Copyright 2008      Franck Charlet
    Copyright 2007-2008 Adrien Destugues
    Copyright 1996-2001 Sunset Design (Guillaume Dorme & Karl Maritaud)

    Grafx2 is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License
    as published by the Free Software Foundation; version 2
    of the License.

    Grafx2 is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Grafx2; if not, see <http://www.gnu.org/licenses/> or
    write to the Free Software Foundation, Inc.,
    59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

********************************************************************************

    Brush manipulation functions
*/

#include <math.h>
#include <stdlib.h>
#include <string.h> // memset()

#include "global.h"
#include "graph.h"
#include "misc.h"
#include "errors.h"
#include "windows.h"
#include "sdlscreen.h"
#include "brush.h"

// Calcul de redimensionnement du pinceau pour éviter les débordements de
// l'écran et de l'image
void Compute_clipped_dimensions(short * x,short * y,short * width,short * height)
{
  if ((*x)<Limit_left)
  {
    (*width)-=(Limit_left-(*x));
    (*x)=Limit_left;
  }

  if (((*x)+(*width))>(Limit_right+1))
  {
    (*width)=(Limit_right-(*x))+1;
  }

  if ((*y)<Limit_top)
  {
    (*height)-=(Limit_top-(*y));
    (*y)=Limit_top;
  }

  if (((*y)+(*height))>(Limit_bottom+1))
  {
    (*height)=(Limit_bottom-(*y))+1;
  }
}

  // -- Calcul de redimensionnement du pinceau pour éviter les débordements
  //    de l'écran zoomé et de l'image --

void Compute_clipped_dimensions_zoom(short * x,short * y,short * width,short * height)
{
  if ((*x)<Limit_left_zoom)
  {
    (*width)-=(Limit_left_zoom-(*x));
    (*x)=Limit_left_zoom;
  }

  if (((*x)+(*width))>(Limit_right_zoom+1))
  {
    (*width)=(Limit_right_zoom-(*x))+1;
  }

  if ((*y)<Limit_top_zoom)
  {
    (*height)-=(Limit_top_zoom-(*y));
    (*y)=Limit_top_zoom;
  }

  if (((*y)+(*height))>(Limit_bottom_zoom+1))
  {
    (*height)=(Limit_bottom_zoom-(*y))+1;
  }
}


  // -- Afficher le pinceau (de façon définitive ou non) --

void Display_paintbrush(short x,short y,byte color,byte is_preview)
  // x,y: position du centre du pinceau
  // color: couleur à appliquer au pinceau
  // is_preview: "Il ne faut l'afficher qu'à l'écran"
{
  short start_x; // Position X (dans l'image) à partir de laquelle on
        // affiche la brosse/pinceau
  short start_y; // Position Y (dans l'image) à partir de laquelle on
        // affiche la brosse/pinceau
  short width; // width dans l'écran selon laquelle on affiche la
        // brosse/pinceau
  short height; // height dans l'écran selon laquelle on affiche la
        // brosse/pinceau
  short start_x_counter; // Position X (dans la brosse/pinceau) à partir
        // de laquelle on affiche la brosse/pinceau
  short start_y_counter; // Position Y (dans la brosse/pinceau) à partir
        // de laquelle on affiche la brosse/pinceau
  short x_pos; // Position X (dans l'image) en cours d'affichage
  short y_pos; // Position Y (dans l'image) en cours d'affichage
  short counter_x; // Position X (dans la brosse/pinceau) en cours
        // d'affichage
  short counter_y; // Position Y (dans la brosse/pinceau) en cours
        // d'affichage
  short end_counter_x; // Position X ou s'arrête l'affichade de la
        // brosse/pinceau
  short end_counter_y; // Position Y ou s'arrête l'affichade de la
        // brosse/pinceau
  byte  temp_color; // color de la brosse en cours d'affichage
  int position;
  byte * temp;

  if (!(is_preview && Mouse_K)) // Si bouton enfoncé & preview > pas de dessin
  switch (Paintbrush_shape)
  {
    case PAINTBRUSH_SHAPE_POINT : // !!! TOUJOURS EN PREVIEW !!!
      if ( (Paintbrush_X>=Limit_left)
        && (Paintbrush_X<=Limit_right)
        && (Paintbrush_Y>=Limit_top)
        && (Paintbrush_Y<=Limit_bottom) )
        {
                Pixel_preview(Paintbrush_X,Paintbrush_Y,color);
                Update_part_of_screen(x,y,1,1);
        }
      break;

    case PAINTBRUSH_SHAPE_COLOR_BRUSH : // Brush en couleur

      start_x=x-Brush_offset_X;
      start_y=y-Brush_offset_Y;
      width=Brush_width;
      height=Brush_height;
      Compute_clipped_dimensions(&start_x,&start_y,&width,&height);
      if (width<=0 || height<=0)
        break;
      start_x_counter=start_x-(x-Brush_offset_X);
      start_y_counter=start_y-(y-Brush_offset_Y);
      end_counter_x=start_x_counter+width;
      end_counter_y=start_y_counter+height;

      if (is_preview)
      {
        if ( (width>0) && (height>0) )
          Display_brush_color(
                start_x-Main_offset_X,
                start_y-Main_offset_Y,
                start_x_counter,
                start_y_counter,
                width,
                height,
                Back_color,
                Brush_width
          );

        if (Main_magnifier_mode)
        {
          Compute_clipped_dimensions_zoom(&start_x,&start_y,&width,
                &height
          );

          start_x_counter=start_x-(x-Brush_offset_X);
          start_y_counter=start_y-(y-Brush_offset_Y);

          if ( (width>0) && (height>0) )
          {
            // Corrections dues au Zoom:
            start_x=(start_x-Main_magnifier_offset_X)*Main_magnifier_factor;
            start_y=(start_y-Main_magnifier_offset_Y)*Main_magnifier_factor;
            height=start_y+(height*Main_magnifier_factor);
            if (height>Menu_Y)
              height=Menu_Y;

            Display_brush_color_zoom(Main_X_zoom+start_x,start_y,
                                     start_x_counter,start_y_counter,
                                     width,height,Back_color,
                                     Brush_width,
                                     Horizontal_line_buffer);
          }
        }

        Update_part_of_screen(x-Brush_offset_X,y-Brush_offset_Y,Brush_width,Brush_height);

      }
      else
      {
        if ((Smear_mode) && (Shade_table==Shade_table_left))
        {
          if (Smear_start)
          {
            if ((width>0) && (height>0))
            {
              Copy_part_of_image_to_another(
                Main_screen, start_x, start_y, width, height,
                Main_image_width, Smear_brush,
                start_x_counter, start_y_counter,
                Smear_brush_width
              );

              Update_part_of_screen(start_x,start_y,width,height);
            }
            Smear_start=0;
          }
          else
          {
            for (y_pos = start_y, counter_y = start_y_counter;
                counter_y < end_counter_y;
                y_pos++, counter_y++
            )
              for (x_pos = start_x, counter_x = start_x_counter;
                counter_x < end_counter_x;
                x_pos++, counter_x++
              )
              {
                temp_color = Read_pixel_from_current_screen(
                        x_pos,y_pos
                );
                position = (counter_y * Smear_brush_width)+ counter_x;
                if ( (Read_pixel_from_brush(counter_x,counter_y) != Back_color)
                  && (counter_y<Smear_max_Y) && (counter_x<Smear_max_X)
                  && (counter_y>=Smear_min_Y) && (counter_x>=Smear_min_X) )
                        Display_pixel(x_pos,y_pos,Smear_brush[position]);
                Smear_brush[position]=temp_color;
              }

              Update_part_of_screen(start_x,start_y,width,height);
          }

          Smear_min_X=start_x_counter;
          Smear_min_Y=start_y_counter;
          Smear_max_X=end_counter_x;
          Smear_max_Y=end_counter_y;
        }
        else
        {
          if (Shade_table==Shade_table_left)
            for (y_pos=start_y,counter_y=start_y_counter;counter_y<end_counter_y;y_pos++,counter_y++)
              for (x_pos=start_x,counter_x=start_x_counter;counter_x<end_counter_x;x_pos++,counter_x++)
              {
                temp_color=Read_pixel_from_brush(counter_x,counter_y);
                if (temp_color!=Back_color)
                  Display_pixel(x_pos,y_pos,temp_color);
              }
          else
            for (y_pos=start_y,counter_y=start_y_counter;counter_y<end_counter_y;y_pos++,counter_y++)
              for (x_pos=start_x,counter_x=start_x_counter;counter_x<end_counter_x;x_pos++,counter_x++)
              {
                if (Read_pixel_from_brush(counter_x,counter_y)!=Back_color)
                  Display_pixel(x_pos,y_pos,color);
              }
        }
        Update_part_of_screen(start_x,start_y,width,height);

      }
      break;
    case PAINTBRUSH_SHAPE_MONO_BRUSH : // Brush monochrome
      start_x=x-Brush_offset_X;
      start_y=y-Brush_offset_Y;
      width=Brush_width;
      height=Brush_height;
      Compute_clipped_dimensions(&start_x,&start_y,&width,&height);
      start_x_counter=start_x-(x-Brush_offset_X);
      start_y_counter=start_y-(y-Brush_offset_Y);
      end_counter_x=start_x_counter+width;
      end_counter_y=start_y_counter+height;
      if (is_preview)
      {
        if ( (width>0) && (height>0) )
          Display_brush_mono(start_x-Main_offset_X,
                             start_y-Main_offset_Y,
                             start_x_counter,start_y_counter,
                             width,height,
                             Back_color,Fore_color,
                             Brush_width);

        if (Main_magnifier_mode)
        {
          Compute_clipped_dimensions_zoom(&start_x,&start_y,&width,&height);
          start_x_counter=start_x-(x-Brush_offset_X);
          start_y_counter=start_y-(y-Brush_offset_Y);

          if ( (width>0) && (height>0) )
          {
            // Corrections dues au Zoom:
            start_x=(start_x-Main_magnifier_offset_X)*Main_magnifier_factor;
            start_y=(start_y-Main_magnifier_offset_Y)*Main_magnifier_factor;
            height=start_y+(height*Main_magnifier_factor);
            if (height>Menu_Y)
              height=Menu_Y;

            Display_brush_mono_zoom(Main_X_zoom+start_x,start_y,
                                    start_x_counter,start_y_counter,
                                    width,height,
                                    Back_color,Fore_color,
                                    Brush_width,
                                    Horizontal_line_buffer);

          }
        }

        Update_part_of_screen(x-Brush_offset_X,y-Brush_offset_Y,Brush_width,Brush_height);
      }
      else
      {
        if ((Smear_mode) && (Shade_table==Shade_table_left))
        {
          if (Smear_start)
          {
            if ((width>0) && (height>0))
            {
              Copy_part_of_image_to_another(Main_screen,
                                                       start_x,start_y,
                                                       width,height,
                                                       Main_image_width,
                                                       Smear_brush,
                                                       start_x_counter,
                                                       start_y_counter,
                                                       Smear_brush_width);
              Update_part_of_screen(start_x,start_y,width,height);
            }
            Smear_start=0;
          }
          else
          {
            for (y_pos=start_y,counter_y=start_y_counter;counter_y<end_counter_y;y_pos++,counter_y++)
              for (x_pos=start_x,counter_x=start_x_counter;counter_x<end_counter_x;x_pos++,counter_x++)
              {
                temp_color=Read_pixel_from_current_screen(x_pos,y_pos);
                position=(counter_y*Smear_brush_width)+counter_x;
                if ( (Read_pixel_from_brush(counter_x,counter_y)!=Back_color)
                  && (counter_y<Smear_max_Y) && (counter_x<Smear_max_X)
                  && (counter_y>=Smear_min_Y) && (counter_x>=Smear_min_X) )
                  Display_pixel(x_pos,y_pos,Smear_brush[position]);
                Smear_brush[position]=temp_color;
              }

            Update_part_of_screen(start_x,start_y,width,height);

          }

          Smear_min_X=start_x_counter;
          Smear_min_Y=start_y_counter;
          Smear_max_X=end_counter_x;
          Smear_max_Y=end_counter_y;
        }
        else
        {
          for (y_pos=start_y,counter_y=start_y_counter;counter_y<end_counter_y;y_pos++,counter_y++)
            for (x_pos=start_x,counter_x=start_x_counter;counter_x<end_counter_x;x_pos++,counter_x++)
            {
              if (Read_pixel_from_brush(counter_x,counter_y)!=Back_color)
                Display_pixel(x_pos,y_pos,color);
            }
          Update_part_of_screen(start_x,start_y,width,height);
        }
      }
      break;
    default : // Pinceau
      start_x=x-Paintbrush_offset_X;
      start_y=y-Paintbrush_offset_Y;
      width=Paintbrush_width;
      height=Paintbrush_height;
      Compute_clipped_dimensions(&start_x,&start_y,&width,&height);
      start_x_counter=start_x-(x-Paintbrush_offset_X);
      start_y_counter=start_y-(y-Paintbrush_offset_Y);
      end_counter_x=start_x_counter+width;
      end_counter_y=start_y_counter+height;
      if (is_preview)
      {
        temp=Brush;
        Brush=Paintbrush_sprite;

        if ( (width>0) && (height>0) )
          Display_brush_mono(start_x-Main_offset_X,
                             start_y-Main_offset_Y,
                             start_x_counter,start_y_counter,
                             width,height,
                             0,Fore_color,
                             MAX_PAINTBRUSH_SIZE);

        if (Main_magnifier_mode)
        {
          Compute_clipped_dimensions_zoom(&start_x,&start_y,&width,&height);
          start_x_counter=start_x-(x-Paintbrush_offset_X);
          start_y_counter=start_y-(y-Paintbrush_offset_Y);

          if ( (width>0) && (height>0) )
          {
            // Corrections dues au Zoom:
            start_x=(start_x-Main_magnifier_offset_X)*Main_magnifier_factor;
            start_y=(start_y-Main_magnifier_offset_Y)*Main_magnifier_factor;
            height=start_y+(height*Main_magnifier_factor);
            if (height>Menu_Y)
              height=Menu_Y;

            Display_brush_mono_zoom(Main_X_zoom+start_x,start_y,
                                    start_x_counter,start_y_counter,
                                    width,height,
                                    0,Fore_color,
                                    MAX_PAINTBRUSH_SIZE,
                                    Horizontal_line_buffer);

          }
        }

        Brush=temp;
      }
      else
      {
        if ((Smear_mode) && (Shade_table==Shade_table_left))
        {
          if (Smear_start)
          {
            if ((width>0) && (height>0))
            {
              Copy_part_of_image_to_another(Main_screen,
                                                       start_x,start_y,
                                                       width,height,
                                                       Main_image_width,
                                                       Smear_brush,
                                                       start_x_counter,
                                                       start_y_counter,
                                                       Smear_brush_width);
              Update_part_of_screen(start_x,start_y,width,height);
            }
            Smear_start=0;
          }
          else
          {
            for (y_pos=start_y,counter_y=start_y_counter;counter_y<end_counter_y;y_pos++,counter_y++)
              for (x_pos=start_x,counter_x=start_x_counter;counter_x<end_counter_x;x_pos++,counter_x++)
              {
                temp_color=Read_pixel_from_current_screen(x_pos,y_pos);
                position=(counter_y*Smear_brush_width)+counter_x;
                if ( (Paintbrush_sprite[(MAX_PAINTBRUSH_SIZE*counter_y)+counter_x]) // Le pinceau sert de masque pour dire quels pixels on doit traiter dans le rectangle
                  && (counter_y<Smear_max_Y) && (counter_x<Smear_max_X)          // On clippe l'effet smear entre Smear_Min et Smear_Max
                  && (counter_y>=Smear_min_Y) && (counter_x>=Smear_min_X) )
                  Display_pixel(x_pos,y_pos,Smear_brush[position]);
                Smear_brush[position]=temp_color;
              }
              Update_part_of_screen(start_x, start_y, width, height);
          }


          Smear_min_X=start_x_counter;
          Smear_min_Y=start_y_counter;
          Smear_max_X=end_counter_x;
          Smear_max_Y=end_counter_y;
        }
        else
        {
          for (y_pos=start_y,counter_y=start_y_counter;counter_y<end_counter_y;y_pos++,counter_y++)
            for (x_pos=start_x,counter_x=start_x_counter;counter_x<end_counter_x;x_pos++,counter_x++)
            {
              if (Paintbrush_sprite[(MAX_PAINTBRUSH_SIZE*counter_y)+counter_x])
                Display_pixel(x_pos,y_pos,color);
            }
          Update_part_of_screen(start_x,start_y,width,height);
        }
      }
  }
}

// -- Effacer le pinceau -- //
//
void Hide_paintbrush(short x,short y)
  // x,y: position du centre du pinceau
{
  short start_x; // Position X (dans l'image) à partir de laquelle on
        // affiche la brosse/pinceau
  short start_y; // Position Y (dans l'image) à partir de laquelle on
        // affiche la brosse/pinceau
  short width; // width dans l'écran selon laquelle on affiche la
        // brosse/pinceau
  short height; // height dans l'écran selon laquelle on affiche la
        // brosse/pinceau
  short start_x_counter; // Position X (dans la brosse/pinceau) à partir
        // de laquelle on affiche la brosse/pinceau
  short start_y_counter; // Position Y (dans la brosse/pinceau) à partir
        // de laquelle on affiche la brosse/pinceau
  //short x_pos; // Position X (dans l'image) en cours d'affichage
  //short y_pos; // Position Y (dans l'image) en cours d'affichage
  //short counter_x; // Position X (dans la brosse/pinceau) en cours
        //d'affichage
  //short counter_y; // Position Y (dans la brosse/pinceau) en cours d'affichage
  short end_counter_x; // Position X ou s'arrête l'affichade de la brosse/pinceau
  short end_counter_y; // Position Y ou s'arrête l'affichade de la brosse/pinceau
  byte * temp;

  if (!Mouse_K)
  switch (Paintbrush_shape)
  {
    case PAINTBRUSH_SHAPE_POINT :
      if ( (Paintbrush_X>=Limit_left)
        && (Paintbrush_X<=Limit_right)
        && (Paintbrush_Y>=Limit_top)
        && (Paintbrush_Y<=Limit_bottom) )
      {
        Pixel_preview(Paintbrush_X,Paintbrush_Y,Read_pixel_from_current_screen(Paintbrush_X,Paintbrush_Y));
        Update_part_of_screen(Paintbrush_X,Paintbrush_Y,1,1);
      }
      break;
    case PAINTBRUSH_SHAPE_COLOR_BRUSH :    // Brush en couleur
    case PAINTBRUSH_SHAPE_MONO_BRUSH : // Brush monochrome
      start_x=x-Brush_offset_X;
      start_y=y-Brush_offset_Y;
      width=Brush_width;
      height=Brush_height;
      Compute_clipped_dimensions(&start_x,&start_y,&width,&height);
      start_x_counter=start_x-(x-Brush_offset_X);
      start_y_counter=start_y-(y-Brush_offset_Y);
      end_counter_x=start_x_counter+width;
      end_counter_y=start_y_counter+height;

      if ( (width>0) && (height>0) )
        Clear_brush(start_x-Main_offset_X,
                    start_y-Main_offset_Y,
                    start_x_counter,start_y_counter,
                    width,height,Back_color,
                    Main_image_width);

      if (Main_magnifier_mode)
      {
        Compute_clipped_dimensions_zoom(&start_x,&start_y,&width,&height);
        start_x_counter=start_x;
        start_y_counter=start_y;

        if ( (width>0) && (height>0) )
        {
          // Corrections dues au Zoom:
          start_x=(start_x-Main_magnifier_offset_X)*Main_magnifier_factor;
          start_y=(start_y-Main_magnifier_offset_Y)*Main_magnifier_factor;
          height=start_y+(height*Main_magnifier_factor);
          if (height>Menu_Y)
            height=Menu_Y;

          Clear_brush_scaled(Main_X_zoom+start_x,start_y,
                           start_x_counter,start_y_counter,
                           width,height,Back_color,
                           Main_image_width,
                           Horizontal_line_buffer);
        }
      }
      break;
    default: // Pinceau
      start_x=x-Paintbrush_offset_X;
      start_y=y-Paintbrush_offset_Y;
      width=Paintbrush_width;
      height=Paintbrush_height;
      Compute_clipped_dimensions(&start_x,&start_y,&width,&height);
      start_x_counter=start_x-(x-Paintbrush_offset_X);
      start_y_counter=start_y-(y-Paintbrush_offset_Y);
      end_counter_x=start_x_counter+width;
      end_counter_y=start_y_counter+height;

      temp=Brush;
      Brush=Paintbrush_sprite;

      if ( (width>0) && (height>0) )
      {
        Clear_brush(start_x-Main_offset_X,
                    start_y-Main_offset_Y,
                    start_x_counter,start_y_counter,
                    width,height,0,
                    Main_image_width);
      }

      if (Main_magnifier_mode)
      {
        Compute_clipped_dimensions_zoom(&start_x,&start_y,&width,&height);
        start_x_counter=start_x;
        start_y_counter=start_y;

        if ( (width>0) && (height>0) )
        {
          // Corrections dues au Zoom:
          start_x=(start_x-Main_magnifier_offset_X)*Main_magnifier_factor;
          start_y=(start_y-Main_magnifier_offset_Y)*Main_magnifier_factor;
          height=start_y+(height*Main_magnifier_factor);
          if (height>Menu_Y)
            height=Menu_Y;

          Clear_brush_scaled(Main_X_zoom+start_x,start_y,
                           start_x_counter,start_y_counter,
                           width,height,0,
                           Main_image_width,
                           Horizontal_line_buffer);
        }
      }

      Brush=temp;
      break;
  }
}



void Capture_brush(short start_x,short start_y,short end_x,short end_y,short clear)
{
  short temp;
  short x_pos;
  short y_pos;
  word  new_brush_width;
  word  new_brush_height;


  // On commence par "redresser" les bornes:
  if (start_x>end_x)
  {
    temp=start_x;
    start_x   =end_x;
    end_x     =temp;
  }
  if (start_y>end_y)
  {
    temp=start_y;
    start_y   =end_y;
    end_y     =temp;
  }

  // On ne capture la nouvelle brosse que si elle est au moins partiellement
  // dans l'image:

  if ((start_x<Main_image_width) && (start_y<Main_image_height))
  {
    // On met les décalages du tiling à 0 pour eviter toute incohérence.
    // Si par hasard on voulait les mettre à
    //    min(Tiling_Decalage_?,Brosse_?a??eur-1)
    // il faudrait penser à les initialiser à 0 dans "MAIN.C".
    Tiling_offset_X=0;
    Tiling_offset_Y=0;

    // Ensuite, on calcule les dimensions de la brosse:
    new_brush_width=(end_x-start_x)+1;
    new_brush_height=(end_y-start_y)+1;

    if (start_x+new_brush_width>Main_image_width)
      new_brush_width=Main_image_width-start_x;
    if (start_y+new_brush_height>Main_image_height)
      new_brush_height=Main_image_height-start_y;

    if ( (((long)Brush_height)*Brush_width) !=
         (((long)new_brush_height)*new_brush_width) )
    {
      free(Brush);
      Brush=(byte *)malloc(((long)new_brush_height)*new_brush_width);
      if (!Brush)
      {
        Error(0);

        Brush=(byte *)malloc(1*1);
        new_brush_height=new_brush_width=1;
        *Brush=Fore_color;
      }
    }
    Brush_width=new_brush_width;
    Brush_height=new_brush_height;

    free(Smear_brush);
    Smear_brush_width=(Brush_width>MAX_PAINTBRUSH_SIZE)?Brush_width:MAX_PAINTBRUSH_SIZE;
    Smear_brush_height=(Brush_height>MAX_PAINTBRUSH_SIZE)?Brush_height:MAX_PAINTBRUSH_SIZE;
    Smear_brush=(byte *)malloc(((long)Smear_brush_height)*Smear_brush_width);

    if (!Smear_brush) // On ne peut même pas allouer la brosse du smear!
    {
      Error(0);

      free(Brush);
      Brush=(byte *)malloc(1*1);
      Brush_height=1;
      Brush_width=1;

      Smear_brush=(byte *)malloc(MAX_PAINTBRUSH_SIZE*MAX_PAINTBRUSH_SIZE);
      Smear_brush_height=MAX_PAINTBRUSH_SIZE;
      Smear_brush_width=MAX_PAINTBRUSH_SIZE;
    }

    Copy_image_to_brush(start_x,start_y,Brush_width,Brush_height,Main_image_width);

    // On regarde s'il faut effacer quelque chose:
    if (clear)
    {
      for (y_pos=start_y;y_pos<start_y+Brush_height;y_pos++)
        for (x_pos=start_x;x_pos<start_x+Brush_width;x_pos++)
        {
          Pixel_in_current_screen(x_pos,y_pos,Back_color);
          Pixel_preview           (x_pos,y_pos,Back_color);
        }
      Update_part_of_screen(start_x,start_y,Brush_width,Brush_height);
    }

    // On centre la prise sur la brosse
    Brush_offset_X=(Brush_width>>1);
    Brush_offset_Y=(Brush_height>>1);
  }
}


void Rotate_90_deg()
{
  short temp;
  byte * new_brush;

  new_brush=(byte *)malloc(((long)Brush_height)*Brush_width);
  if (new_brush)
  {
    Rotate_90_deg_lowlevel(Brush,new_brush,Brush_width,Brush_height);
    free(Brush);
    Brush=new_brush;

    temp=Brush_width;
    Brush_width=Brush_height;
    Brush_height=temp;

    temp=Smear_brush_width;
    Smear_brush_width=Smear_brush_height;
    Smear_brush_height=temp;

    // On centre la prise sur la brosse
    Brush_offset_X=(Brush_width>>1);
    Brush_offset_Y=(Brush_height>>1);
  }
  else
    Error(0);
}


void Remap_brush(void)
{
  short x_pos; // Variable de balayage de la brosse
  short y_pos; // Variable de balayage de la brosse
  byte  used[256]; // Tableau de booléens "La couleur est utilisée"
  int   color;


  // On commence par initialiser le tableau de booléens à faux
  for (color=0;color<=255;color++)
    used[color]=0;

  // On calcule la table d'utilisation des couleurs
  for (y_pos=0;y_pos<Brush_height;y_pos++)
    for (x_pos=0;x_pos<Brush_width;x_pos++)
      used[Read_pixel_from_brush(x_pos,y_pos)]=1;

  //  On n'est pas censé remapper la couleur de transparence, sinon la brosse
  // changera de forme, donc on dit pour l'instant qu'elle n'est pas utilisée
  // ainsi on ne s'embêtera pas à la recalculer
  used[Back_color]=0;

  //   On va maintenant se servir de la table "used" comme table de
  // conversion: pour chaque indice, la table donne une couleur de
  // remplacement.
  // Note : Seules les couleurs utilisées on besoin d'êtres recalculées: les
  //       autres ne seront jamais consultées dans la nouvelle table de
  //       conversion puisque elles n'existent pas dans la brosse, donc elles
  //       ne seront pas utilisées par Remap_brush_LOWLEVEL.
  for (color=0;color<=255;color++)
    if (used[color])
      used[color]=Best_color(Spare_palette[color].R,Spare_palette[color].G,Spare_palette[color].B);

  //   Il reste une couleur non calculée dans la table qu'il faut mettre à
  // jour: c'est la couleur de fond. On l'avait inhibée pour éviter son
  // calcul inutile, mais comme il est possible qu'elle soit quand même dans
  // la brosse, on va mettre dans la table une relation d'équivalence entre
  // les deux palettes: comme on ne veut pas que la couleur soit remplacée,
  // on va dire qu'on veut qu'elle soit remplacée par la couleur en question.
  used[Back_color]=Back_color;

  //   Maintenant qu'on a une super table de conversion qui n'a que le nom
  // qui craint un peu, on peut faire l'échange dans la brosse de toutes les
  // teintes.
  Remap_general_lowlevel(used,Brush,Brush_width,Brush_height,Brush_width);
  //Remap_brush_LOWLEVEL(used);
}



void Outline_brush(void)
{
  long /*Pos,*/x_pos,y_pos;
  byte state;
  byte * new_brush;
  byte * temp;
  word width;
  word height;


  width=Brush_width+2;
  height=Brush_height+2;
  new_brush=(byte *)malloc(((long)width)*height);

  if (new_brush)
  {
    // On remplit la bordure ajoutée par la Backcolor
    memset(new_brush,Back_color,((long)width)*height);

    // On copie la brosse courante dans la nouvelle
    Copy_part_of_image_to_another(Brush, // source
                                             0, 0,
                                             Brush_width,
                                             Brush_height,
                                             Brush_width,
                                             new_brush, // Destination
                                             1, 1,
                                             width);

    // On intervertit la nouvelle et l'ancienne brosse:
    temp=Brush;
    Brush=new_brush;
    Brush_width+=2;
    Brush_height+=2;
    width-=2;
    height-=2;

    // Si on "outline" avec une couleur différente de la Back_color on y va!
    if (Fore_color!=Back_color)
    {
      // 1er balayage (horizontal)
      for (y_pos=1; y_pos<Brush_height-1; y_pos++)
      {
        state=0;
        for (x_pos=1; x_pos<Brush_width-1; x_pos++)
        {
          if (temp[((y_pos-1)*width)+x_pos-1]==Back_color)
          {
            if (state)
            {
              Pixel_in_brush(x_pos,y_pos,Fore_color);
              state=0;
            }
          }
          else
          {
            if (!state)
            {
              Pixel_in_brush(x_pos-1,y_pos,Fore_color);
              state=1;
            }
          }
        }
        // Cas du dernier pixel à droite de la ligne
        if (state)
          Pixel_in_brush(x_pos,y_pos,Fore_color);
      }

      // 2ème balayage (vertical)
      for (x_pos=1; x_pos<Brush_width-1; x_pos++)
      {
        state=0;
        for (y_pos=1; y_pos<Brush_height-1; y_pos++)
        {
          if (temp[((y_pos-1)*width)+x_pos-1]==Back_color)
          {
            if (state)
            {
              Pixel_in_brush(x_pos,y_pos,Fore_color);
              state=0;
            }
          }
          else
          {
            if (!state)
            {
              Pixel_in_brush(x_pos,y_pos-1,Fore_color);
              state=1;
            }
          }
        }
        // Cas du dernier pixel en bas de la colonne
        if (state)
          Pixel_in_brush(x_pos,y_pos,Fore_color);
      }
    }

    // On recentre la prise sur la brosse
    Brush_offset_X=(Brush_width>>1);
    Brush_offset_Y=(Brush_height>>1);

    free(temp); // Libération de l'ancienne brosse

    // Réallocation d'un buffer de Smear
    free(Smear_brush);
    Smear_brush_width=(Brush_width>MAX_PAINTBRUSH_SIZE)?Brush_width:MAX_PAINTBRUSH_SIZE;
    Smear_brush_height=(Brush_height>MAX_PAINTBRUSH_SIZE)?Brush_height:MAX_PAINTBRUSH_SIZE;
    Smear_brush=(byte *)malloc(((long)Smear_brush_width)*Smear_brush_height);
  }
  else
    Error(0); // Pas assez de mémoire!
}


void Nibble_brush(void)
{
  long /*Pos,*/x_pos,y_pos;
  byte state;
  byte * new_brush;
  byte * temp;
  word width;
  word height;

  if ( (Brush_width>2) && (Brush_height>2) )
  {
    width=Brush_width-2;
    height=Brush_height-2;
    new_brush=(byte *)malloc(((long)width)*height);

    if (new_brush)
    {
      // On copie la brosse courante dans la nouvelle
      Copy_part_of_image_to_another(Brush, // source
                                               1,
                                               1,
                                               width,
                                               height,
                                               Brush_width,
                                               new_brush, // Destination
                                               0,
                                               0,
                                               width);

      // On intervertit la nouvelle et l'ancienne brosse:
      temp=Brush;
      Brush=new_brush;
      Brush_width-=2;
      Brush_height-=2;
      width+=2;
      height+=2;

      // 1er balayage (horizontal)
      for (y_pos=0; y_pos<Brush_height; y_pos++)
      {
        state=(temp[(y_pos+1)*width]!=Back_color);
        for (x_pos=0; x_pos<Brush_width; x_pos++)
        {
          if (temp[((y_pos+1)*width)+x_pos+1]==Back_color)
          {
            if (state)
            {
              if (x_pos>0)
                Pixel_in_brush(x_pos-1,y_pos,Back_color);
              state=0;
            }
          }
          else
          {
            if (!state)
            {
              Pixel_in_brush(x_pos,y_pos,Back_color);
              state=1;
            }
          }
        }
        // Cas du dernier pixel à droite de la ligne
        if (temp[((y_pos+1)*width)+x_pos+1]==Back_color)
          Pixel_in_brush(x_pos-1,y_pos,Back_color);
      }

      // 2ème balayage (vertical)
      for (x_pos=0; x_pos<Brush_width; x_pos++)
      {
        state=(temp[width+x_pos+1]!=Back_color);;
        for (y_pos=0; y_pos<Brush_height; y_pos++)
        {
          if (temp[((y_pos+1)*width)+x_pos+1]==Back_color)
          {
            if (state)
            {
              if (y_pos>0)
                Pixel_in_brush(x_pos,y_pos-1,Back_color);
              state=0;
            }
          }
          else
          {
            if (!state)
            {
              Pixel_in_brush(x_pos,y_pos,Back_color);
              state=1;
            }
          }
        }
        // Cas du dernier pixel en bas de la colonne
        if (temp[((y_pos+1)*width)+x_pos+1]==Back_color)
          Pixel_in_brush(x_pos,y_pos-1,Back_color);
      }

      // On recentre la prise sur la brosse
      Brush_offset_X=(Brush_width>>1);
      Brush_offset_Y=(Brush_height>>1);

      free(temp); // Libération de l'ancienne brosse

      // Réallocation d'un buffer de Smear
      free(Smear_brush);
      Smear_brush_width=(Brush_width>MAX_PAINTBRUSH_SIZE)?Brush_width:MAX_PAINTBRUSH_SIZE;
      Smear_brush_height=(Brush_height>MAX_PAINTBRUSH_SIZE)?Brush_height:MAX_PAINTBRUSH_SIZE;
      Smear_brush=(byte *)malloc(((long)Smear_brush_width)*Smear_brush_height);
    }
    else
      Error(0);  // Pas assez de mémoire!
  }
}



void Capture_brush_with_lasso(int vertices, short * points,short clear)
{
  short start_x=Limit_right+1;
  short start_y=Limit_bottom+1;
  short end_x=Limit_left-1;
  short end_y=Limit_top-1;
  short temp;
  short x_pos;
  short y_pos;
  word  new_brush_width;
  word  new_brush_height;


  // On recherche les bornes de la brosse:
  for (temp=0; temp<vertices; temp++)
  {
    x_pos=points[temp<<1];
    y_pos=points[(temp<<1)+1];
    if (x_pos<start_x)
      start_x=x_pos;
    if (x_pos>end_x)
      end_x=x_pos;
    if (y_pos<start_y)
      start_y=y_pos;
    if (y_pos>end_y)
      end_y=y_pos;
  }

  // On clippe ces bornes à l'écran:
  if (start_x<Limit_left)
    start_x=Limit_left;
  if (end_x>Limit_right)
    end_x=Limit_right;
  if (start_y<Limit_top)
    start_y=Limit_top;
  if (end_y>Limit_bottom)
    end_y=Limit_bottom;

  // On ne capture la nouvelle brosse que si elle est au moins partiellement
  // dans l'image:

  if ((start_x<Main_image_width) && (start_y<Main_image_height))
  {
    // On met les décalages du tiling à 0 pour eviter toute incohérence.
    // Si par hasard on voulait les mettre à
    //    min(Tiling_Decalage_?,Brosse_?a??eur-1)
    // il faudrait penser à les initialiser à 0 dans "MAIN.C".
    Tiling_offset_X=0;
    Tiling_offset_Y=0;

    // Ensuite, on calcule les dimensions de la brosse:
    new_brush_width=(end_x-start_x)+1;
    new_brush_height=(end_y-start_y)+1;

    if ( (((long)Brush_height)*Brush_width) !=
         (((long)new_brush_height)*new_brush_width) )
    {
      free(Brush);
      Brush=(byte *)malloc(((long)new_brush_height)*new_brush_width);
      if (!Brush)
      {
        Error(0);

        Brush=(byte *)malloc(1*1);
        new_brush_height=new_brush_width=1;
        *Brush=Fore_color;
      }
    }
    Brush_width=new_brush_width;
    Brush_height=new_brush_height;

    free(Smear_brush);
    Smear_brush_width=(Brush_width>MAX_PAINTBRUSH_SIZE)?Brush_width:MAX_PAINTBRUSH_SIZE;
    Smear_brush_height=(Brush_height>MAX_PAINTBRUSH_SIZE)?Brush_height:MAX_PAINTBRUSH_SIZE;
    Smear_brush=(byte *)malloc(((long)Smear_brush_height)*Smear_brush_width);

    if (!Smear_brush) // On ne peut même pas allouer la brosse du smear!
    {
      Error(0);

      free(Brush);
      Brush=(byte *)malloc(1*1);
      Brush_height=1;
      Brush_width=1;

      Smear_brush=(byte *)malloc(MAX_PAINTBRUSH_SIZE*MAX_PAINTBRUSH_SIZE);
      Smear_brush_height=MAX_PAINTBRUSH_SIZE;
      Smear_brush_width=MAX_PAINTBRUSH_SIZE;
    }

    Brush_offset_X=start_x;
    Brush_offset_Y=start_y;
    Pixel_figure=Pixel_figure_in_brush;

    memset(Brush,Back_color,(long)Brush_width*Brush_height);
    Polyfill_general(vertices,points,~Back_color);

    // On retrace les bordures du lasso:
    for (temp=1; temp<vertices; temp++)
    {
      Draw_line_general(points[(temp-1)<<1],points[((temp-1)<<1)+1],
                           points[temp<<1],points[(temp<<1)+1],
                           ~Back_color);
    }
    Draw_line_general(points[(vertices-1)<<1],points[((vertices-1)<<1)+1],
                         points[0],points[1],
                         ~Back_color);

    // On scanne la brosse pour remplacer tous les pixels affectés par le
    // polyfill par ceux de l'image:
    for (y_pos=start_y;y_pos<=end_y;y_pos++)
      for (x_pos=start_x;x_pos<=end_x;x_pos++)
        if (Read_pixel_from_brush(x_pos-start_x,y_pos-start_y)!=Back_color)
        {
          Pixel_in_brush(x_pos-start_x,y_pos-start_y,Read_pixel_from_current_screen(x_pos,y_pos));
          // On regarde s'il faut effacer quelque chose:
          if (clear)
            Pixel_in_current_screen(x_pos,y_pos,Back_color);
        }

    // On centre la prise sur la brosse
    Brush_offset_X=(Brush_width>>1);
    Brush_offset_Y=(Brush_height>>1);
  }
}



//------------------------- Etirement de la brosse ---------------------------

void Stretch_brush(short x1, short y1, short x2, short y2)
{
  byte * new_brush;
  int    new_brush_width;  // Width de la nouvelle brosse
  int    new_brush_height;  // Height de la nouvelle brosse
  int    x_flipped, y_flipped;
  
  // Compute new brush dimensions
  if ((new_brush_width=x1-x2)<0)
  {
    x_flipped=1;
    new_brush_width=-new_brush_width;
  }
  new_brush_width++;

  if ((new_brush_height=y1-y2)<0)
  {
    y_flipped=1;
    new_brush_height=-new_brush_height;
  }
  new_brush_height++;

  // Free some memory
  free(Smear_brush);

  if ((new_brush=((byte *)malloc(new_brush_width*new_brush_height))))
  {
    Rescale(Brush, Brush_width, Brush_height, new_brush, new_brush_width, new_brush_height, x2<x1, y2<y1);

    free(Brush);
    Brush=new_brush;

    Brush_width=new_brush_width;
    Brush_height=new_brush_height;

    Smear_brush_width=(Brush_width>MAX_PAINTBRUSH_SIZE)?Brush_width:MAX_PAINTBRUSH_SIZE;
    Smear_brush_height=(Brush_height>MAX_PAINTBRUSH_SIZE)?Brush_height:MAX_PAINTBRUSH_SIZE;
    Smear_brush=(byte *)malloc(((long)Smear_brush_height)*Smear_brush_width);

    if (!Smear_brush) // On ne peut même pas allouer la brosse du smear!
    {
      Error(0);

      free(Brush);
      Brush=(byte *)malloc(1*1);
      Brush_height=1;
      Brush_width=1;

      Smear_brush=(byte *)malloc(MAX_PAINTBRUSH_SIZE*MAX_PAINTBRUSH_SIZE);
      Smear_brush_height=MAX_PAINTBRUSH_SIZE;
      Smear_brush_width=MAX_PAINTBRUSH_SIZE;
    }

    Brush_offset_X=(Brush_width>>1);
    Brush_offset_Y=(Brush_height>>1);
  }
  else
  {
    // Ici la libération de mémoire n'a pas suffi donc on remet dans l'état
    // où c'etait avant. On a juste à réallouer la Smear_brush car il y a
    // normalement la place pour elle puisque rien d'autre n'a pu être alloué
    // entre temps.
    Smear_brush=(byte *)malloc(((long)Smear_brush_height)*Smear_brush_width);
    Error(0);
  }
}



void Stretch_brush_preview(short x1, short y1, short x2, short y2)
{
  int    src_x_pos,src_y_pos;
  int    initial_src_x_pos,initial_src_y_pos;
  int    delta_x,delta_y;
  int    dest_x_pos,dest_y_pos;
  int    initial_dest_x_pos,initial_dest_y_pos;
  int    final_dest_x_pos,final_dest_y_pos;
  int    dest_width,dest_height;
  byte   color;


  // 1er calcul des positions destination extremes:
  initial_dest_x_pos=Min(x1,x2);
  initial_dest_y_pos=Min(y1,y2);
  final_dest_x_pos  =Max(x1,x2);
  final_dest_y_pos  =Max(y1,y2);

  // Calcul des dimensions de la destination:
  dest_width=final_dest_x_pos-initial_dest_x_pos+1;
  dest_height=final_dest_y_pos-initial_dest_y_pos+1;

  // Calcul des vecteurs d'incrémentation :
  delta_x=(Brush_width<<16)/dest_width;
  delta_y=(Brush_height<<16)/dest_height;

  // 1er calcul de la position X initiale dans la source:
  initial_src_x_pos=(Brush_width<<16)*
                     (Max(initial_dest_x_pos,Limit_left)-
                      initial_dest_x_pos)/dest_width;
  // Calcul du clip de la destination:
  initial_dest_x_pos=Max(initial_dest_x_pos,Limit_left);
  final_dest_x_pos  =Min(final_dest_x_pos  ,Limit_visible_right);
  // On discute selon l'inversion en X
  if (x1>x2)
  {
    // Inversion -> Inversion du signe de delta_x
    delta_x=-delta_x;
    initial_src_x_pos=(Brush_width<<16)-1-initial_src_x_pos;
  }

  // 1er calcul de la position Y initiale dans la source:
  initial_src_y_pos=(Brush_height<<16)*
                     (Max(initial_dest_y_pos,Limit_top)-
                      initial_dest_y_pos)/dest_height;
  // Calcul du clip de la destination:
  initial_dest_y_pos=Max(initial_dest_y_pos,Limit_top);
  final_dest_y_pos  =Min(final_dest_y_pos  ,Limit_visible_bottom);
  // On discute selon l'inversion en Y
  if (y1>y2)
  {
    // Inversion -> Inversion du signe de delta_y
    delta_y=-delta_y;
    initial_src_y_pos=(Brush_height<<16)-1-initial_src_y_pos;
  }

  // Pour chaque ligne :
  src_y_pos=initial_src_y_pos;
  for (dest_y_pos=initial_dest_y_pos;dest_y_pos<=final_dest_y_pos;dest_y_pos++)
  {
    // Pour chaque colonne:
    src_x_pos=initial_src_x_pos;
    for (dest_x_pos=initial_dest_x_pos;dest_x_pos<=final_dest_x_pos;dest_x_pos++)
    {
      color=Read_pixel_from_brush(src_x_pos>>16,src_y_pos>>16);
      if (color!=Back_color)
        Pixel_preview(dest_x_pos,dest_y_pos,color);

      src_x_pos+=delta_x;
    }

    src_y_pos+=delta_y;
  }
  Update_part_of_screen(initial_dest_x_pos,initial_dest_y_pos,dest_width,dest_height);
}

/// Returns the minimum of 4 integers.
int Min4(unsigned long int a,unsigned long int b,unsigned long int c,unsigned long int d)
{
  if (a<b)
    if (c<d)
      return a<c?a:c;
    else
      return a<d?a:d;
  else
    if (c<d)
      return b<c?b:c;
    else
      return b<d?b:d;
}

//-------------------- Brush distort -------------------------------

// That's a lot of globals, but it saves stack space in the recursive calls.
static Func_pixel Pixel_for_distort;
static byte *     Distort_buffer;
static short      Distort_buffer_width;

/// Draw a pixel in the target buffer. No clipping.
void Pixel_in_distort_buffer(word x_pos,word y_pos,byte color)
{
  *(Distort_buffer+y_pos*Distort_buffer_width+x_pos)=color;
}

/// Returns the maximum of 4 integers.
int Max4(unsigned long int a,unsigned long int b,unsigned long int c,unsigned long int d)
{
  if (a>b)
    if (c>d)
      return a>c?a:c;
    else
      return a>d?a:d;
  else
    if (c>d)
      return b>c?b:c;
    else
      return b>d?b:d;
}

// Recursive function for linear distortion.
void Draw_brush_linear_distort(unsigned long int tex_min_x,
                               unsigned long int tex_min_y,
                               unsigned long int tex_max_x,
                               unsigned long int tex_max_y,
                               unsigned long int x1,
                               unsigned long int y1,
                               unsigned long int x2,
                               unsigned long int y2,
                               unsigned long int x3,
                               unsigned long int y3,
                               unsigned long int x4,
                               unsigned long int y4)
{
  static byte color;
  // bounding rectangle
  static unsigned long int min_x, max_x, min_y, max_y;
  
  min_x=Min4(x1,x2,x3,x4);
  max_x=Max4(x1,x2,x3,x4);
  min_y=Min4(y1,y2,y3,y4);
  max_y=Max4(y1,y2,y3,y4);
   
  if ((max_x>>16) - (min_x>>16) <= 1 && (max_y>>16) - (min_y>>16) <= 1)
  //if (max_x - min_x <= 1<<16 && max_y - min_y <= 1<<16)
  {
    if ((min_x<(max_x&0x7FFF0000)) && (min_y<(max_y&0x7FFF0000)))  
    {
      color=Read_pixel_from_brush((tex_min_x)>>16,(tex_min_y)>>16);
      if (color!=Back_color)
        Pixel_for_distort(min_x>>16,min_y>>16,color);
    }
    return;
  }
  // Cut in 4 quarters and repeat
  // "top left"
  Draw_brush_linear_distort(tex_min_x,
                            tex_min_y,
                            (tex_min_x+tex_max_x)>>1,
                            (tex_min_y+tex_max_y)>>1,
                            x1,
                            y1,
                            (x1+x2)>>1,
                            (y1+y2)>>1,
                            (x1+x2+x3+x4)>>2,
                            (y1+y2+y3+y4)>>2,
                            (x1+x4)>>1,
                            (y1+y4)>>1);

  // "top right"
  Draw_brush_linear_distort((tex_min_x+tex_max_x)>>1,
                            tex_min_y,
                            tex_max_x,
                            (tex_min_y+tex_max_y)>>1,
                            (x1+x2)>>1,
                            (y1+y2)>>1,
                            x2,
                            y2,
                            (x2+x3)>>1,
                            (y2+y3)>>1,
                            (x1+x2+x3+x4)>>2,
                            (y1+y2+y3+y4)>>2);

  // "bottom right"
  Draw_brush_linear_distort((tex_min_x+tex_max_x)>>1,
                            (tex_min_y+tex_max_y)>>1,
                            tex_max_x,
                            tex_max_y,
                            (x1+x2+x3+x4)>>2,
                            (y1+y2+y3+y4)>>2,
                            (x2+x3)>>1,
                            (y2+y3)>>1,
                            x3,
                            y3,
                            (x3+x4)>>1,
                            (y3+y4)>>1);
  
  // "bottom left"
  Draw_brush_linear_distort(tex_min_x,
                            (tex_min_y+tex_max_y)>>1,
                            (tex_min_x+tex_max_x)>>1,
                            tex_max_y,
                            (x1+x4)>>1,
                            (y1+y4)>>1,
                            (x1+x2+x3+x4)>>2,
                            (y1+y2+y3+y4)>>2,
                            (x3+x4)>>1,
                            (y3+y4)>>1,
                            x4,
                            y4);

  return;
}

/// Draws a distorted version of the brush, mapped over the given quad (picture coordinates).
void Distort_brush_preview(unsigned short x1, unsigned short y1, unsigned short x2, unsigned short y2, unsigned short x3, unsigned short y3, unsigned short x4, unsigned short y4)
{
  Pixel_for_distort=Pixel_figure_preview;
  Draw_brush_linear_distort(0, 0, (Brush_width<<16), (Brush_height<<16), (x1<<16), (y1<<16), (x2<<16), (y2<<16), (x3<<16), (y3<<16), (x4<<16), (y4<<16));
}

/// Modifies the current brush, mapping it over the given quad.
void Distort_brush(short x1, short y1, short x2, short y2, short x3, short y3, short x4, short y4)
{
  short min_x, max_x, min_y, max_y;
  short width, height;
  byte * new_brush;
  byte * new_smear_brush;
  short new_smear_brush_width;
  short new_smear_brush_height;
  
  // Move all coordinates to start on (0,0)
  min_x=Min4(x1,x2,x3,x4);
  max_x=Max4(x1,x2,x3,x4);
  min_y=Min4(y1,y2,y3,y4);
  max_y=Max4(y1,y2,y3,y4);

  x1-=min_x;
  x2-=min_x;
  x3-=min_x;
  x4-=min_x;

  y1-=min_y;
  y2-=min_y;
  y3-=min_y;
  y4-=min_y;
  
  width=Max(max_x-min_x, 1);
  height=Max(max_y-min_y, 1);
    
  new_smear_brush_width=(width>MAX_PAINTBRUSH_SIZE)?width:MAX_PAINTBRUSH_SIZE;
  new_smear_brush_height=(height>MAX_PAINTBRUSH_SIZE)?height:MAX_PAINTBRUSH_SIZE;

  new_smear_brush=(byte *)malloc(((long)new_smear_brush_height)*new_smear_brush_width);
  if (! new_smear_brush)
  {
    // Out of memory while allocating new smear brush
    Error(0);
    return;
  }
  
  new_brush=((byte *)malloc((long)width*height));
  if (!new_brush)
  {
    // Out of memory while allocating new brush
    Error(0);
    free(new_smear_brush);
    return;
  }

  // Fill the new brush with backcolor, originally.
  memset(new_brush,Back_color,((long)width)*height);
  
  // Call distort routine
  Pixel_for_distort=Pixel_in_distort_buffer;
  Distort_buffer=new_brush;
  Distort_buffer_width=width;
  Draw_brush_linear_distort(0, 0, (Brush_width<<16), (Brush_height<<16), (x1<<16), (y1<<16), (x2<<16), (y2<<16), (x3<<16), (y3<<16), (x4<<16), (y4<<16));

  // Free old brushes
  free(Smear_brush);
  free(Brush);

  // Point to the new ones
  Brush=new_brush;
  Brush_width=width;
  Brush_height=height;

  Smear_brush=new_smear_brush;
  Smear_brush_width=new_smear_brush_width;
  Smear_brush_height=new_smear_brush_height;
}

//------------------------- Rotation de la brosse ---------------------------

#define UNDEFINED (-1.0e20F)
float * ScanY_Xt[2];
float * ScanY_Yt[2];
float * ScanY_X[2];


void Interpolate_texture(int start_x,int start_y,int xt1,int yt1,
                        int end_x  ,int end_y  ,int xt2,int yt2,int height)
{
  int x_pos,y_pos;
  int incr_x,incr_y;
  int i,cumul;
  int delta_x,delta_y;
  int delta_xt=xt2-xt1;
  int delta_yt=yt2-yt1;
  int delta_x2=end_x-start_x;
  int delta_y2=end_y-start_y;
  float xt,yt;


  x_pos=start_x;
  y_pos=start_y;

  if (start_x<end_x)
  {
    incr_x=+1;
    delta_x=delta_x2;
  }
  else
  {
    incr_x=-1;
    delta_x=-delta_x2;
  }

  if (start_y<end_y)
  {
    incr_y=+1;
    delta_y=delta_y2;
  }
  else
  {
    incr_y=-1;
    delta_y=-delta_y2;
  }

  if (delta_x>delta_y)
  {
    cumul=delta_x>>1;
    for (i=0; i<=delta_x; i++)
    {
      if (cumul>=delta_x)
      {
        cumul-=delta_x;
        y_pos+=incr_y;
      }

      if ((y_pos>=0) && (y_pos<height))
      {
        xt=(((float)((x_pos-start_x)*delta_xt))/(float)delta_x2) + (float)xt1;
        yt=(((float)((x_pos-start_x)*delta_yt))/(float)delta_x2) + (float)yt1;
        if (ScanY_X[0][y_pos]==UNDEFINED) // Gauche non défini
        {
          ScanY_X[0][y_pos]=x_pos;
          ScanY_Xt[0][y_pos]=xt;
          ScanY_Yt[0][y_pos]=yt;
        }
        else
        {
          if (x_pos>=ScanY_X[0][y_pos])
          {
            if ((ScanY_X[1][y_pos]==UNDEFINED) // Droit non défini
             || (x_pos>ScanY_X[1][y_pos]))
            {
              ScanY_X[1][y_pos]=x_pos;
              ScanY_Xt[1][y_pos]=xt;
              ScanY_Yt[1][y_pos]=yt;
            }
          }
          else
          {
            if (ScanY_X[1][y_pos]==UNDEFINED) // Droit non défini
            {
              ScanY_X[1][y_pos]=ScanY_X[0][y_pos];
              ScanY_Xt[1][y_pos]=ScanY_Xt[0][y_pos];
              ScanY_Yt[1][y_pos]=ScanY_Yt[0][y_pos];
              ScanY_X[0][y_pos]=x_pos;
              ScanY_Xt[0][y_pos]=xt;
              ScanY_Yt[0][y_pos]=yt;
            }
            else
            {
              ScanY_X[0][y_pos]=x_pos;
              ScanY_Xt[0][y_pos]=xt;
              ScanY_Yt[0][y_pos]=yt;
            }
          }
        }
      }
      x_pos+=incr_x;
      cumul+=delta_y;
    }
  }
  else
  {
    cumul=delta_y>>1;
    for (i=0; i<=delta_y; i++)
    {
      if (cumul>=delta_y)
      {
        cumul-=delta_y;
        x_pos+=incr_x;
      }

      if ((y_pos>=0) && (y_pos<height))
      {
        xt=(((float)((y_pos-start_y)*delta_xt))/(float)delta_y2) + (float)xt1;
        yt=(((float)((y_pos-start_y)*delta_yt))/(float)delta_y2) + (float)yt1;
        if (ScanY_X[0][y_pos]==UNDEFINED) // Gauche non défini
        {
          ScanY_X[0][y_pos]=x_pos;
          ScanY_Xt[0][y_pos]=xt;
          ScanY_Yt[0][y_pos]=yt;
        }
        else
        {
          if (x_pos>=ScanY_X[0][y_pos])
          {
            if ((ScanY_X[1][y_pos]==UNDEFINED) // Droit non défini
             || (x_pos>ScanY_X[1][y_pos]))
            {
              ScanY_X[1][y_pos]=x_pos;
              ScanY_Xt[1][y_pos]=xt;
              ScanY_Yt[1][y_pos]=yt;
            }
          }
          else
          {
            if (ScanY_X[1][y_pos]==UNDEFINED) // Droit non défini
            {
              ScanY_X[1][y_pos]=ScanY_X[0][y_pos];
              ScanY_Xt[1][y_pos]=ScanY_Xt[0][y_pos];
              ScanY_Yt[1][y_pos]=ScanY_Yt[0][y_pos];
              ScanY_X[0][y_pos]=x_pos;
              ScanY_Xt[0][y_pos]=xt;
              ScanY_Yt[0][y_pos]=yt;
            }
            else
            {
              ScanY_X[0][y_pos]=x_pos;
              ScanY_Xt[0][y_pos]=xt;
              ScanY_Yt[0][y_pos]=yt;
            }
          }
        }
      }
      y_pos+=incr_y;
      cumul+=delta_x;
    }
  }
}



void Compute_quad_texture(int x1,int y1,int xt1,int yt1,
                           int x2,int y2,int xt2,int yt2,
                           int x3,int y3,int xt3,int yt3,
                           int x4,int y4,int xt4,int yt4,
                           byte * buffer, int width, int height)
{
  int x_min,/*x_max,*/y_min/*,y_max*/;
  int x,y,xt,yt;
  int start_x,end_x,line_width;
  float temp;
  //byte color;

  x_min=Min(Min(x1,x2),Min(x3,x4));
  y_min=Min(Min(y1,y2),Min(y3,y4));

  ScanY_Xt[0]=(float *)malloc(height*sizeof(float));
  ScanY_Xt[1]=(float *)malloc(height*sizeof(float));
  ScanY_Yt[0]=(float *)malloc(height*sizeof(float));
  ScanY_Yt[1]=(float *)malloc(height*sizeof(float));
  ScanY_X[0] =(float *)malloc(height*sizeof(float));
  ScanY_X[1] =(float *)malloc(height*sizeof(float));

  // Fill_general avec des valeurs égales à UNDEFINED.
  for (y=0; y<height; y++)
  {
    ScanY_X[0][y]=UNDEFINED;
    ScanY_X[1][y]=UNDEFINED;
  }

  Interpolate_texture(x1-x_min,y1-y_min,xt1,yt1,x3-x_min,y3-y_min,xt3,yt3,height);
  Interpolate_texture(x3-x_min,y3-y_min,xt3,yt3,x4-x_min,y4-y_min,xt4,yt4,height);
  Interpolate_texture(x4-x_min,y4-y_min,xt4,yt4,x2-x_min,y2-y_min,xt2,yt2,height);
  Interpolate_texture(x2-x_min,y2-y_min,xt2,yt2,x1-x_min,y1-y_min,xt1,yt1,height);

  for (y=0; y<height; y++)
  {
    start_x=Round(ScanY_X[0][y]);
    end_x  =Round(ScanY_X[1][y]);

    line_width=1+end_x-start_x;

    for (x=0; x<start_x; x++)
      buffer[x+(y*width)]=Back_color;
    for (; x<=end_x; x++)
    {
      temp=(float)(0.5+(float)x-ScanY_X[0][y])/(float)line_width;
      xt=Round((float)(ScanY_Xt[0][y])+(temp*(ScanY_Xt[1][y]-ScanY_Xt[0][y])));
      yt=Round((float)(ScanY_Yt[0][y])+(temp*(ScanY_Yt[1][y]-ScanY_Yt[0][y])));
      if (xt>=0 && yt>=0)
        buffer[x+(y*width)]=Read_pixel_from_brush(xt,yt);
    }
    for (; x<width; x++)
      buffer[x+(y*width)]=Back_color;
  }

  free(ScanY_Xt[0]);
  free(ScanY_Xt[1]);
  free(ScanY_Yt[0]);
  free(ScanY_Yt[1]);
  free(ScanY_X[0]);
  free(ScanY_X[1]);
}



void Rotate_brush(float angle)
{
  byte * new_brush;
  int    new_brush_width;  // Width de la nouvelle brosse
  int    new_brush_height;  // Height de la nouvelle brosse

  short x1,y1,x2,y2,x3,y3,x4,y4;
  int start_x,end_x,start_y,end_y;
  int x_min,x_max,y_min,y_max;
  float cos_a=cos(angle);
  float sin_a=sin(angle);

  // Calcul des coordonnées des 4 coins:
  // 1 2
  // 3 4

  start_x=1-(Brush_width>>1);
  start_y=1-(Brush_height>>1);
  end_x=start_x+Brush_width-1;
  end_y=start_y+Brush_height-1;

  Transform_point(start_x,start_y, cos_a,sin_a, &x1,&y1);
  Transform_point(end_x  ,start_y, cos_a,sin_a, &x2,&y2);
  Transform_point(start_x,end_y  , cos_a,sin_a, &x3,&y3);
  Transform_point(end_x  ,end_y  , cos_a,sin_a, &x4,&y4);

  // Calcul des nouvelles dimensions de la brosse:
  x_min=Min(Min((int)x1,(int)x2),Min((int)x3,(int)x4));
  x_max=Max(Max((int)x1,(int)x2),Max((int)x3,(int)x4));
  y_min=Min(Min((int)y1,(int)y2),Min((int)y3,(int)y4));
  y_max=Max(Max((int)y1,(int)y2),Max((int)y3,(int)y4));

  new_brush_width=x_max+1-x_min;
  new_brush_height=y_max+1-y_min;

  free(Smear_brush); // On libère un peu de mémoire

  if ((new_brush=((byte *)malloc(new_brush_width*new_brush_height))))
  {
    // Et maintenant on calcule la nouvelle brosse tournée.
    Compute_quad_texture(x1,y1,               0,               0,
                          x2,y2,Brush_width-1,               0,
                          x3,y3,               0,Brush_height-1,
                          x4,y4,Brush_width-1,Brush_height-1,
                          new_brush,new_brush_width,new_brush_height);

    free(Brush);
    Brush=new_brush;

    Brush_width=new_brush_width;
    Brush_height=new_brush_height;

    Smear_brush_width=(Brush_width>MAX_PAINTBRUSH_SIZE)?Brush_width:MAX_PAINTBRUSH_SIZE;
    Smear_brush_height=(Brush_height>MAX_PAINTBRUSH_SIZE)?Brush_height:MAX_PAINTBRUSH_SIZE;
    Smear_brush=(byte *)malloc(((long)Smear_brush_height)*Smear_brush_width);

    if (!Smear_brush) // On ne peut même pas allouer la brosse du smear!
    {
      Error(0);

      free(Brush);
      Brush=(byte *)malloc(1*1);
      Brush_height=1;
      Brush_width=1;

      Smear_brush=(byte *)malloc(MAX_PAINTBRUSH_SIZE*MAX_PAINTBRUSH_SIZE);
      Smear_brush_height=MAX_PAINTBRUSH_SIZE;
      Smear_brush_width=MAX_PAINTBRUSH_SIZE;
    }

    Brush_offset_X=(Brush_width>>1);
    Brush_offset_Y=(Brush_height>>1);
  }
  else
  {
    // Ici la libération de mémoire n'a pas suffit donc on remet dans l'état
    // où c'etait avant. On a juste à réallouer la Smear_brush car il y a
    // normalement la place pour elle puisque rien d'autre n'a pu être alloué
    // entre temps.
    Smear_brush=(byte *)malloc(((long)Smear_brush_height)*Smear_brush_width);
    Error(0);
  }
}



void Draw_quad_texture_preview(int x1,int y1,int xt1,int yt1,
                                   int x2,int y2,int xt2,int yt2,
                                   int x3,int y3,int xt3,int yt3,
                                   int x4,int y4,int xt4,int yt4)
{
  int x_min,x_max,y_min,y_max;
  int x,y,xt,yt;
  int y_,y_min_;
  int start_x,end_x,width,height;
  float temp;
  byte color;

  x_min=Min(Min(x1,x2),Min(x3,x4));
  x_max=Max(Max(x1,x2),Max(x3,x4));
  y_min=Min(Min(y1,y2),Min(y3,y4));
  y_max=Max(Max(y1,y2),Max(y3,y4));
  height=1+y_max-y_min;

  ScanY_Xt[0]=(float *)malloc(height*sizeof(float));
  ScanY_Xt[1]=(float *)malloc(height*sizeof(float));
  ScanY_Yt[0]=(float *)malloc(height*sizeof(float));
  ScanY_Yt[1]=(float *)malloc(height*sizeof(float));
  ScanY_X[0] =(float *)malloc(height*sizeof(float));
  ScanY_X[1] =(float *)malloc(height*sizeof(float));

  // Fill_general avec des valeurs égales à UNDEFINED.
  for (y=0; y<height; y++)
  {
    ScanY_X[0][y]=UNDEFINED;
    ScanY_X[1][y]=UNDEFINED;
  }

  Interpolate_texture(x1,y1-y_min,xt1,yt1,x3,y3-y_min,xt3,yt3,height);
  Interpolate_texture(x3,y3-y_min,xt3,yt3,x4,y4-y_min,xt4,yt4,height);
  Interpolate_texture(x4,y4-y_min,xt4,yt4,x2,y2-y_min,xt2,yt2,height);
  Interpolate_texture(x2,y2-y_min,xt2,yt2,x1,y1-y_min,xt1,yt1,height);

  y_min_=y_min;
  if (y_min<Limit_top) y_min=Limit_top;
  if (y_max>Limit_bottom)  y_max=Limit_bottom;

  for (y_=y_min; y_<=y_max; y_++)
  {
    y=y_-y_min_;
    start_x=Round(ScanY_X[0][y]);
    end_x  =Round(ScanY_X[1][y]);

    width=1+end_x-start_x;

    if (start_x<Limit_left) start_x=Limit_left;
    if (  end_x>Limit_right)   end_x=Limit_right;

    for (x=start_x; x<=end_x; x++)
    {
      temp=(float)(0.5+(float)x-ScanY_X[0][y])/(float)width;
      xt=Round((float)(ScanY_Xt[0][y])+(temp*(ScanY_Xt[1][y]-ScanY_Xt[0][y])));
      yt=Round((float)(ScanY_Yt[0][y])+(temp*(ScanY_Yt[1][y]-ScanY_Yt[0][y])));
      if (xt>=0 && yt>=0)
      {
        color=Read_pixel_from_brush(xt,yt);
        if (color!=Back_color)
          Pixel_preview(x,y_,color);
      }
    }
  }

  free(ScanY_Xt[0]);
  free(ScanY_Xt[1]);
  free(ScanY_Yt[0]);
  free(ScanY_Yt[1]);
  free(ScanY_X[0]);
  free(ScanY_X[1]);
}


void Rotate_brush_preview(float angle)
{
  short x1,y1,x2,y2,x3,y3,x4,y4;
  int start_x,end_x,start_y,end_y;
  float cos_a=cos(angle);
  float sin_a=sin(angle);

  // Calcul des coordonnées des 4 coins:
  // 1 2
  // 3 4

  start_x=1-(Brush_width>>1);
  start_y=1-(Brush_height>>1);
  end_x=start_x+Brush_width-1;
  end_y=start_y+Brush_height-1;

  Transform_point(start_x,start_y, cos_a,sin_a, &x1,&y1);
  Transform_point(end_x  ,start_y, cos_a,sin_a, &x2,&y2);
  Transform_point(start_x,end_y  , cos_a,sin_a, &x3,&y3);
  Transform_point(end_x  ,end_y  , cos_a,sin_a, &x4,&y4);

  x1+=Brush_rotation_center_X;
  y1+=Brush_rotation_center_Y;
  x2+=Brush_rotation_center_X;
  y2+=Brush_rotation_center_Y;
  x3+=Brush_rotation_center_X;
  y3+=Brush_rotation_center_Y;
  x4+=Brush_rotation_center_X;
  y4+=Brush_rotation_center_Y;

  // Et maintenant on dessine la brosse tournée.
  Draw_quad_texture_preview(x1,y1,               0,               0,
                                x2,y2,Brush_width-1,               0,
                                x3,y3,               0,Brush_height-1,
                                x4,y4,Brush_width-1,Brush_height-1);
  start_x=Min(Min(x1,x2),Min(x3,x4));
  end_x=Max(Max(x1,x2),Max(x3,x4));
  start_y=Min(Min(y1,y2),Min(y3,y4));
  end_y=Max(Max(y1,y2),Max(y3,y4));
  Update_part_of_screen(start_x,start_y,end_x-start_x+1,end_y-start_y+1);
}