Fl_Image.H

Go to the documentation of this file.

//
// Image header file for the Fast Light Tool Kit (FLTK).
//
// Copyright 1998-2022 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:
//
//     https://www.fltk.org/COPYING.php
//
// Please see the following page on how to report bugs and issues:
//
//     https://www.fltk.org/bugs.php
//
 
#ifndef Fl_Image_H
#define Fl_Image_H
 
#include "Enumerations.H"
#include "Fl_Widget.H" // for fl_uintptr_t
 
class Fl_Widget;
class Fl_Pixmap;
struct Fl_Menu_Item;
struct Fl_Label;
class Fl_RGB_Image;
 
 
enum Fl_RGB_Scaling {
  FL_RGB_SCALING_NEAREST = 0, 
  FL_RGB_SCALING_BILINEAR     
};
 
 
class FL_EXPORT Fl_Image {
  friend class Fl_Graphics_Driver;
public:
  static const int ERR_NO_IMAGE       = -1;
  static const int ERR_FILE_ACCESS    = -2;
  static const int ERR_FORMAT         = -3;
  static const int ERR_MEMORY_ACCESS  = -4;
 
private:
  int w_, h_, d_, ld_, count_;
  int data_w_, data_h_;
  const char * const *data_;
  static Fl_RGB_Scaling RGB_scaling_; // method used when copying RGB images
  static Fl_RGB_Scaling scaling_algorithm_; // method used to rescale RGB source images before drawing
  // Forbid use of copy constructor and assign operator
  Fl_Image & operator=(const Fl_Image &);
  Fl_Image(const Fl_Image &);
  // Presently redefined in Fl_SVG_Image
  virtual void cache_size_(int &/*width*/, int &/*height*/) {}
 
protected:
 
  void w(int W) {w_ = W; data_w_ = W;}
  void h(int H) {h_ = H; data_h_ = H;}
  void d(int D) {d_ = D;}
  void ld(int LD) {ld_ = LD;}
  void data(const char * const *p, int c) {data_ = p; count_ = c;}
  void draw_empty(int X, int Y);
 
  static void labeltype(const Fl_Label *lo, int lx, int ly, int lw, int lh, Fl_Align la);
  static void measure(const Fl_Label *lo, int &lw, int &lh);
  int draw_scaled(int X, int Y, int W, int H);
 
public:
 
  int w() const {return w_;}
  int h() const {return h_;}
  int data_w() const {return data_w_;}
  int data_h() const {return data_h_;}
  int d() const {return d_;}
  int ld() const {return ld_;}
  int count() const {return count_;}
  const char * const *data() const {return data_;}
  int fail() const;
  virtual void release() {
    delete this;
  }
 
  virtual class Fl_Shared_Image *as_shared_image() {
    return 0;
  }
 
  Fl_Image(int W, int H, int D);
  virtual ~Fl_Image();
  virtual Fl_Image *copy(int W, int H) const;
  Fl_Image *copy() const { return copy(w(), h()); }
  virtual void color_average(Fl_Color c, float i);
  void inactive() { color_average(FL_GRAY, .33f); }
  virtual void desaturate();
  virtual void label(Fl_Widget*w);
  virtual void label(Fl_Menu_Item*m);
  virtual void draw(int X, int Y, int W, int H, int cx=0, int cy=0); // platform dependent
  void draw(int X, int Y) {draw(X, Y, w(), h(), 0, 0);} // platform dependent
  virtual void uncache();
 
  // used by fl_define_FL_IMAGE_LABEL() to avoid 'friend' declaration
  static Fl_Labeltype define_FL_IMAGE_LABEL();
 
  // set RGB image scaling method
  static void RGB_scaling(Fl_RGB_Scaling);
  // get RGB image scaling method
  static Fl_RGB_Scaling RGB_scaling();
 
  // set the image drawing size
  virtual void scale(int width, int height, int proportional = 1, int can_expand = 0);
  static void scaling_algorithm(Fl_RGB_Scaling algorithm) {scaling_algorithm_ = algorithm; }
  static Fl_RGB_Scaling scaling_algorithm() {return scaling_algorithm_;}
  static bool register_images_done;
};
 
class Fl_SVG_Image;
 
class FL_EXPORT Fl_RGB_Image : public Fl_Image {
  friend class Fl_Graphics_Driver;
  static size_t max_size_;
public:
 
  const uchar *array;
  int alloc_array;
 
private:
  // These two variables are used to cache the image and mask for the main display graphics driver
  fl_uintptr_t id_;
  fl_uintptr_t mask_;
  int cache_w_, cache_h_; // size of image when cached
public:
 
  Fl_RGB_Image(const uchar *bits, int W, int H, int D=3, int LD=0);
  Fl_RGB_Image(const uchar *bits, int bits_length, int W, int H, int D, int LD);
  Fl_RGB_Image(const Fl_Pixmap *pxm, Fl_Color bg=FL_GRAY);
  ~Fl_RGB_Image() FL_OVERRIDE;
  Fl_Image *copy(int W, int H) const FL_OVERRIDE;
  Fl_Image *copy() const { return Fl_Image::copy(); }
  void color_average(Fl_Color c, float i) FL_OVERRIDE;
  void desaturate() FL_OVERRIDE;
  void draw(int X, int Y, int W, int H, int cx=0, int cy=0) FL_OVERRIDE;
  void draw(int X, int Y) {draw(X, Y, w(), h(), 0, 0);}
  void label(Fl_Widget*w) FL_OVERRIDE;
  void label(Fl_Menu_Item*m) FL_OVERRIDE;
  void uncache() FL_OVERRIDE;
  int cache_w() {return cache_w_;}
  int cache_h() {return cache_h_;}
  static void max_size(size_t size) { max_size_ = size;}
  static size_t max_size() {return max_size_;}
  virtual Fl_SVG_Image *as_svg_image() { return NULL; }
  virtual void normalize() {}
};
 
#endif // !Fl_Image_H