static int alloc_handlers_ = 0;

static int alloc_images_ = 0;

static Fl_Shared_Handler * handlers_ = 0;

static Fl_Shared_Image ** images_ = 0;

static int num_handlers_ = 0;

static int num_images_ = 0;

int alloc_image_;

Fl_Image * image_;

const char * name_;

int original_;

int refcount_;

Fl_Shared_Image();

Fl_Shared_Image(const char *n, Fl_Image *img=0);

static Fl_Shared_Image * get(const char *name, int W=0, int H=0);

function Create
       (Filename : in String;
        W, H     : in Integer)
    return Shared_Image;

static Fl_Shared_Image * get(Fl_RGB_Image *rgb, int own_it=1);

function Create
       (From : in FLTK.Images.RGB.RGB_Image'Class)
    return Shared_Image;

static Fl_Shared_Image ** images();

static void add_handler(Fl_Shared_Handler f);

static Fl_Shared_Image * find(const char *name, int W=0, int H=0);

function Find
       (Name : in String;
        W, H : in Integer := 0)
    return Shared_Image;

static int num_images();

function Number_Of_Images
    return Natural;

static void remove_handler(Fl_Shared_Handler f);

static void scaling_algorithm(Fl_RGB_Scaling algorithm);

procedure Set_Scaling_Algorithm
       (To : in Scaling_Kind);

virtual void color_average(Fl_Color c, float i);

procedure Color_Average
       (This   : in out Shared_Image;
        Col    : in     Color;
        Amount : in     Blend);

virtual Fl_Image * copy(int W, int H);

function Copy
       (This          : in Shared_Image;
        Width, Height : in Natural)
    return Shared_Image'Class;

Fl_Image * copy();

function Copy
       (This : in Shared_Image)
    return Shared_Image'Class;

virtual void desaturate();

procedure Desaturate
       (This : in out Shared_Image);

virtual void draw(int X, int Y, int W, int H,
    int cx, int cy);

procedure Draw
       (This       : in Shared_Image;
        X, Y, W, H : in Integer;
        CX, CY     : in Integer := 0);

void draw(int X, int Y);

procedure Draw
       (This : in Shared_Image;
        X, Y : in Integer);

const char * name();

function Name
       (This : in Shared_Image)
    return String;

int original();

function Original
       (This : in Shared_Image)
    return Boolean;

int refcount();

function Reference_Count
       (This : in Shared_Image)
    return Natural;

void release();

void reload();

procedure Reload
       (This : in out Shared_Image);

void scale(int width, int height,
    int proportional=1, int can_expand=0);

procedure Scale
       (This         : in out Shared_Image;
        W, H         : in     Integer;
        Proportional : in     Boolean := True;
        Can_Expand   : in     Boolean := False);

virtual void uncache();

procedure Uncache
       (This : in out Shared_Image);

static int compare(Fl_Shared_Image **i0, Fl_Shared_Image **i1);

void add();

void update();