8e3f66073f
and whether we are printing: virtual int Fl_Graphics_Driver::has_feature(driver_feature feature) This is also because it is not convenient to derive a printer-specific driver with its own implementation of virtual functions when this implementation differs only in one line of code. 2) Solved the problem of inclusion of non public header by the public header FL/Fl_Device.H: bracket this with #if FL_LIBRARY / #endif so this non public header is included only when building FLTK itself. 3) Removed several (but not all) of the FLTK_ABI_VERSION guards that are no longer useful for code targeting FLTK 1.4. git-svn-id: file:///fltk/svn/fltk/branches/branch-1.3-porting@11063 ea41ed52-d2ee-0310-a9c1-e6b18d33e121
120 lines
4.1 KiB
C++
120 lines
4.1 KiB
C++
//
|
|
// "$Id$"
|
|
//
|
|
// Shared image header file for the Fast Light Tool Kit (FLTK).
|
|
//
|
|
// Copyright 1998-2015 by Bill Spitzak and others.
|
|
//
|
|
// This library is free software. Distribution and use rights are outlined in
|
|
// the file "COPYING" which should have been included with this file. If this
|
|
// file is missing or damaged, see the license at:
|
|
//
|
|
// http://www.fltk.org/COPYING.php
|
|
//
|
|
// Please report all bugs and problems on the following page:
|
|
//
|
|
// http://www.fltk.org/str.php
|
|
//
|
|
|
|
/** \file
|
|
Fl_Shared_Image class. */
|
|
|
|
#ifndef Fl_Shared_Image_H
|
|
# define Fl_Shared_Image_H
|
|
|
|
# include "Fl_Image.H"
|
|
|
|
|
|
// Test function for adding new formats
|
|
typedef Fl_Image *(*Fl_Shared_Handler)(const char *name, uchar *header,
|
|
int headerlen);
|
|
|
|
// Shared images class.
|
|
/**
|
|
This class supports caching, loading, scaling,
|
|
and drawing of image files. Most applications will also want to
|
|
link against the fltk_images library and call the
|
|
fl_register_images()
|
|
function to support standard image formats such as BMP, GIF, JPEG, and PNG.
|
|
*/
|
|
class FL_EXPORT Fl_Shared_Image : public Fl_Image {
|
|
|
|
friend class Fl_JPEG_Image;
|
|
friend class Fl_PNG_Image;
|
|
|
|
private:
|
|
static Fl_RGB_Scaling scaling_algorithm_; // method used to rescale RGB source images
|
|
Fl_Image *scaled_image_;
|
|
protected:
|
|
|
|
static Fl_Shared_Image **images_; // Shared images
|
|
static int num_images_; // Number of shared images
|
|
static int alloc_images_; // Allocated shared images
|
|
static Fl_Shared_Handler *handlers_; // Additional format handlers
|
|
static int num_handlers_; // Number of format handlers
|
|
static int alloc_handlers_; // Allocated format handlers
|
|
|
|
const char *name_; // Name of image file
|
|
int original_; // Original image?
|
|
int refcount_; // Number of times this image has been used
|
|
Fl_Image *image_; // The image that is shared
|
|
int alloc_image_; // Was the image allocated?
|
|
|
|
static int compare(Fl_Shared_Image **i0, Fl_Shared_Image **i1);
|
|
|
|
// Use get() and release() to load/delete images in memory...
|
|
Fl_Shared_Image();
|
|
Fl_Shared_Image(const char *n, Fl_Image *img = 0);
|
|
virtual ~Fl_Shared_Image();
|
|
void add();
|
|
void update();
|
|
|
|
public:
|
|
/** Returns the filename of the shared image */
|
|
const char *name() { return name_; }
|
|
/** Returns the number of references of this shared image. When reference is below 1, the image is deleted. */
|
|
int refcount() { return refcount_; }
|
|
void release();
|
|
void reload();
|
|
|
|
virtual Fl_Image *copy(int W, int H);
|
|
Fl_Image *copy() { return copy(w(), h()); }
|
|
virtual void color_average(Fl_Color c, float i);
|
|
virtual void desaturate();
|
|
virtual void draw(int X, int Y, int W, int H, int cx, int cy);
|
|
void draw(int X, int Y) { draw(X, Y, w(), h(), 0, 0); }
|
|
void scale(int width, int height, int proportional = 1, int can_expand = 0);
|
|
virtual void uncache();
|
|
|
|
static Fl_Shared_Image *find(const char *n, int W = 0, int H = 0);
|
|
static Fl_Shared_Image *get(const char *n, int W = 0, int H = 0);
|
|
static Fl_Shared_Image *get(Fl_RGB_Image *rgb, int own_it = 1);
|
|
static Fl_Shared_Image **images();
|
|
static int num_images();
|
|
static void add_handler(Fl_Shared_Handler f);
|
|
static void remove_handler(Fl_Shared_Handler f);
|
|
/** Sets what algorithm is used when resizing a source image.
|
|
The default algorithm is FL_RGB_SCALING_BILINEAR.
|
|
Drawing an Fl_Shared_Image is sometimes performed by first resizing the source image
|
|
and then drawing the resized copy. This occurs, e.g., when drawing to screen under Linux or MSWindows
|
|
after having called Fl_Shared_Image::scale().
|
|
This function controls what method is used when the image to be resized is an Fl_RGB_Image.
|
|
\version 1.3.4 and requires compiling with FL_ABI_VERSION = 10304
|
|
*/
|
|
static void scaling_algorithm(Fl_RGB_Scaling algorithm) {scaling_algorithm_ = algorithm; }
|
|
};
|
|
|
|
//
|
|
// The following function is provided in the fltk_images library and
|
|
// registers all of the "extra" image file formats that are not part
|
|
// of the core FLTK library...
|
|
//
|
|
|
|
FL_EXPORT extern void fl_register_images();
|
|
|
|
#endif // !Fl_Shared_Image_H
|
|
|
|
//
|
|
// End of "$Id$"
|
|
//
|