1 files changed, 145 insertions, 150 deletions

diff --git a/src/Image.hh b/src/Image.hh
index 3811e69..677acbb 100644
--- a/src/Image.hh
+++ b/src/Image.hh
@@ -1,3 +1,6 @@
+// Image.hh for Fluxbox Window Manager
+// Copyright (c) 2001 - 2002 Henrik Kinnunen (fluxbox@linuxmail.org)
+//
 // Image.hh for Blackbox - an X11 Window manager
 // Copyright (c) 1997 - 2000 Brad Hughes (bhughes@tcac.net)
 //
@@ -13,19 +16,24 @@
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 // DEALINGS IN THE SOFTWARE.
 
-#ifndef   _IMAGE_HH_
-#define   _IMAGE_HH_
+// $Id: Image.hh,v 1.7 2002/05/17 10:59:30 fluxgen Exp $
+
+#ifndef  IMAGE_HH
+#define  IMAGE_HH
 
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 
 #include "Timer.hh"
+#include "BaseDisplay.hh"
+
+#include <list>
 
 class BImage;
 class BImageControl;
@@ -33,208 +41,195 @@ class BImageControl;
 
 class BColor {
 private:
-  int allocated;
-  unsigned char red, green, blue;
-  unsigned long pixel;
+        int allocated;
+        unsigned char red, green, blue;
+        unsigned long pixel;
 
 public:
-  BColor(char r = 0, char g = 0, char b = 0)
-    { red = r; green = g; blue = b; pixel = 0; allocated = 0; }
+        BColor(char r = 0, char g = 0, char b = 0)
+                { red = r; green = g; blue = b; pixel = 0; allocated = 0; }
 
-  inline const int &isAllocated(void) const { return allocated; }
+        inline int isAllocated(void) const { return allocated; }
 
-  inline const unsigned char &getRed(void) const { return red; }
-  inline const unsigned char &getGreen(void) const { return green; }
-  inline const unsigned char &getBlue(void) const { return blue; }
+        inline unsigned char getRed(void) const { return red; }
+        inline unsigned char getGreen(void) const { return green; }
+        inline unsigned char getBlue(void) const { return blue; }
 
-  inline const unsigned long &getPixel(void) const { return pixel; }
+        inline unsigned long getPixel(void) const { return pixel; }
 
-  inline void setAllocated(int a) { allocated = a; }
-  inline void setRGB(char r, char g, char b) { red = r; green = g; blue = b; }
-  inline void setPixel(unsigned long p) { pixel = p; }
+        inline void setAllocated(int a) { allocated = a; }
+        inline void setRGB(char r, char g, char b) { red = r; green = g; blue = b; }
+        inline void setPixel(unsigned long p) { pixel = p; }
 };
 
 
 class BTexture {
 private:
-  BColor color, colorTo, hiColor, loColor;
-  unsigned long texture;
+        BColor color, colorTo, hiColor, loColor;
+        unsigned long texture;
 
 public:
-  BTexture(void) { texture = 0; }
+        BTexture(void):texture(0) { }
 
-  inline BColor *getColor(void) { return &color; }
-  inline BColor *getColorTo(void) { return &colorTo; }
-  inline BColor *getHiColor(void) { return &hiColor; }
-  inline BColor *getLoColor(void) { return &loColor; }
-
-  inline const unsigned long &getTexture(void) const { return texture; }
-
-  inline void setTexture(unsigned long t) { texture = t; }
-  inline void addTexture(unsigned long t) { texture |= t; }
-};
+        inline const BColor *getColor(void) const { return &color; }
+        inline const BColor *getColorTo(void) const { return &colorTo; }
+        inline const BColor *getHiColor(void) const { return &hiColor; }
+        inline const BColor *getLoColor(void) const { return &loColor; }
 
+        inline BColor *getColor(void) { return &color; }
+        inline BColor *getColorTo(void) { return &colorTo; }
+        inline BColor *getHiColor(void) { return &hiColor; }
+        inline BColor *getLoColor(void) { return &loColor; }
 
-// bevel options
-#define BImage_Flat             (1l<<1)
-#define BImage_Sunken           (1l<<2)
-#define BImage_Raised           (1l<<3)
+        inline unsigned long getTexture(void) const { return texture; }
 
-// textures
-#define BImage_Solid            (1l<<4)
-#define BImage_Gradient         (1l<<5)
-
-// gradients
-#define BImage_Horizontal       (1l<<6)
-#define BImage_Vertical         (1l<<7)
-#define BImage_Diagonal         (1l<<8)
-#define BImage_CrossDiagonal    (1l<<9)
-#define BImage_Rectangle        (1l<<10)
-#define BImage_Pyramid          (1l<<11)
-#define BImage_PipeCross        (1l<<12)
-#define BImage_Elliptic         (1l<<13)
-
-// bevel types
-#define BImage_Bevel1           (1l<<14)
-#define BImage_Bevel2           (1l<<15)
-
-// inverted image
-#define BImage_Invert           (1l<<16)
-
-// parent relative image
-#define BImage_ParentRelative   (1l<<17)
-
-#ifdef    INTERLACE
-// fake interlaced image
-#  define BImage_Interlaced     (1l<<18)
-#endif // INTERLACE
+        inline void setTexture(unsigned long t) { texture = t; }
+        inline void addTexture(unsigned long t) { texture |= t; }
+};
 
-#include "BaseDisplay.hh"
-#include "LinkedList.hh"
 
 
 class BImage {
 private:
-  BImageControl *control;
+        BImageControl *control;
 
-#ifdef    INTERLACE
-  Bool interlaced;
+#ifdef          INTERLACE
+        Bool interlaced;
 #endif // INTERLACE
 
-  XColor *colors;
+        XColor *colors;
 
-  BColor *from, *to;
-  int red_offset, green_offset, blue_offset, red_bits, green_bits, blue_bits,
-    ncolors, cpc, cpccpc;
-  unsigned char *red, *green, *blue, *red_table, *green_table, *blue_table;
-  unsigned int width, height, *xtable, *ytable;
+        BColor *from, *to;
+        int red_offset, green_offset, blue_offset, red_bits, green_bits, blue_bits,
+                ncolors, cpc, cpccpc;
+        unsigned char *red, *green, *blue, *red_table, *green_table, *blue_table;
+        unsigned int width, height, *xtable, *ytable;
 
 
 protected:
-  Pixmap renderPixmap(void);
+        Pixmap renderPixmap(void);
 
-  XImage *renderXImage(void);
+        XImage *renderXImage(void);
 
-  void invert(void);
-  void bevel1(void);
-  void bevel2(void);
-  void dgradient(void);
-  void egradient(void);
-  void hgradient(void);
-  void pgradient(void);
-  void rgradient(void);
-  void vgradient(void);
-  void cdgradient(void);
-  void pcgradient(void);
+        void invert(void);
+        void bevel1(void);
+        void bevel2(void);
+        void dgradient(void);
+        void egradient(void);
+        void hgradient(void);
+        void pgradient(void);
+        void rgradient(void);
+        void vgradient(void);
+        void cdgradient(void);
+        void pcgradient(void);
 
 
 public:
-  BImage(BImageControl *, unsigned int, unsigned int);
-  ~BImage(void);
-
-  Pixmap render(BTexture *);
-  Pixmap render_solid(BTexture *);
-  Pixmap render_gradient(BTexture *);
+        enum Bevel{FLAT=0x00002, SUNKEN=0x00004, RAISED=0x00008};
+        enum Textures{SOLID=0x00010, GRADIENT=0x00020};
+        enum Gradients{
+                HORIZONTAL=0x00040,
+                VERTICAL=0x00080,
+                DIAGONAL=0x00100,
+                CROSSDIAGONAL=0x00200,
+                RECTANGLE=0x00400,
+                PYRAMID=0x00800,
+                PIPECROSS=0x01000,
+                ELLIPTIC=0x02000                
+        };
+        
+        enum {
+                BEVEL1=0x04000, BEVEL2=0x08000, // bevel types
+                INVERT=0x010000, //inverted image
+                PARENTRELATIVE=0x20000,
+                INTERLACED=0x40000
+        };
+        
+        BImage(BImageControl *, unsigned int, unsigned int);
+        ~BImage(void);
+
+        Pixmap render(BTexture *);
+        Pixmap render_solid(BTexture *);
+        Pixmap render_gradient(BTexture *);
 };
 
 
 class BImageControl : public TimeoutHandler {
-private:
-  Bool dither;
-  BaseDisplay *basedisplay;
-  ScreenInfo *screeninfo;
-#ifdef    TIMEDCACHE
-  BTimer *timer;
-#endif // TIMEDCACHE
-
-  Colormap colormap;
+public:
+        BImageControl(BaseDisplay *, ScreenInfo *, Bool = False, int = 4,
+                                                                unsigned long = 300000l, unsigned long = 200l);
+        virtual ~BImageControl();
 
-  Window window;
-  XColor *colors;
-  int colors_per_channel, ncolors, screen_number, screen_depth,
-    bits_per_pixel, red_offset, green_offset, blue_offset,
-    red_bits, green_bits, blue_bits;
-  unsigned char red_color_table[256], green_color_table[256],
-    blue_color_table[256];
-  unsigned int *grad_xbuffer, *grad_ybuffer, grad_buffer_width,
-    grad_buffer_height;
-  unsigned long *sqrt_table, cache_max;
+        inline BaseDisplay *getBaseDisplay(void) { return basedisplay; }
 
-  typedef struct Cache {
-    Pixmap pixmap;
+        inline bool doDither(void) { return dither; }
+        inline const Colormap &getColormap(void) const { return colormap; }
+        inline ScreenInfo *getScreenInfo(void) { return screeninfo; }
 
-    unsigned int count, width, height;
-    unsigned long pixel1, pixel2, texture;
-  } Cache;
+        inline const Window &getDrawable(void) const { return window; }
 
-  LinkedList<Cache> *cache;
+        inline Visual *getVisual(void) { return screeninfo->getVisual(); }
 
+        inline int getBitsPerPixel(void) const { return bits_per_pixel; }
+        inline int getDepth(void) const { return screen_depth; }
+        inline int getColorsPerChannel(void) const
+                { return colors_per_channel; }
 
-protected:
-  Pixmap searchCache(unsigned int, unsigned int, unsigned long, BColor *,
-                     BColor *);
+        unsigned long getColor(const char *);
+        unsigned long getColor(const char *, unsigned char *, unsigned char *,
+                                                                                                 unsigned char *);
+        unsigned long getSqrt(unsigned int);
 
+        Pixmap renderImage(unsigned int, unsigned int, BTexture *);
 
-public:
-  BImageControl(BaseDisplay *, ScreenInfo *, Bool = False, int = 4,
-                unsigned long = 300000l, unsigned long = 200l);
-  virtual ~BImageControl(void);
+        void installRootColormap(void);
+        void removeImage(Pixmap);
+        void getColorTables(unsigned char **, unsigned char **, unsigned char **,
+                                                                                        int *, int *, int *, int *, int *, int *);
+        void getXColorTable(XColor **, int *);
+        void getGradientBuffers(unsigned int, unsigned int,
+                                                                                                        unsigned int **, unsigned int **);
+        void setDither(Bool d) { dither = d; }
+        void setColorsPerChannel(int);
+        void parseTexture(BTexture *, char *);
+        void parseColor(BColor *, char * = 0);
 
-  inline BaseDisplay *getBaseDisplay(void) { return basedisplay; }
+        virtual void timeout(void);
 
-  inline const Bool &doDither(void) { return dither; }
-  inline const Colormap &getColormap(void) const { return colormap; }
-  inline ScreenInfo *getScreenInfo(void) { return screeninfo; }
+private:
+        Bool dither;
+        BaseDisplay *basedisplay;
+        ScreenInfo *screeninfo;
+#ifdef          TIMEDCACHE
+        BTimer timer;
+#endif // TIMEDCACHE
 
-  inline const Window &getDrawable(void) const { return window; }
+        Colormap colormap;
 
-  inline Visual *getVisual(void) { return screeninfo->getVisual(); }
+        Window window;
+        XColor *colors;
+        int colors_per_channel, ncolors, screen_number, screen_depth,
+                bits_per_pixel, red_offset, green_offset, blue_offset,
+                red_bits, green_bits, blue_bits;
+        unsigned char red_color_table[256], green_color_table[256],
+                blue_color_table[256];
+        unsigned int *grad_xbuffer, *grad_ybuffer, grad_buffer_width,
+                grad_buffer_height;
+        unsigned long *sqrt_table, cache_max;
 
-  inline const int &getBitsPerPixel(void) const { return bits_per_pixel; }
-  inline const int &getDepth(void) const { return screen_depth; }
-  inline const int &getColorsPerChannel(void) const
-    { return colors_per_channel; }
+        typedef struct Cache {
+                Pixmap pixmap;
 
-  unsigned long getColor(const char *);
-  unsigned long getColor(const char *, unsigned char *, unsigned char *,
-                         unsigned char *);
-  unsigned long getSqrt(unsigned int);
+                unsigned int count, width, height;
+                unsigned long pixel1, pixel2, texture;
+        } Cache;
 
-  Pixmap renderImage(unsigned int, unsigned int, BTexture *);
+        typedef std::list<Cache *> CacheList;
 
-  void installRootColormap(void);
-  void removeImage(Pixmap);
-  void getColorTables(unsigned char **, unsigned char **, unsigned char **,
-                      int *, int *, int *, int *, int *, int *);
-  void getXColorTable(XColor **, int *);
-  void getGradientBuffers(unsigned int, unsigned int,
-                          unsigned int **, unsigned int **);
-  void setDither(Bool d) { dither = d; }
-  void setColorsPerChannel(int);
-  void parseTexture(BTexture *, char *);
-  void parseColor(BColor *, char * = 0);
+        CacheList cache;
 
-  virtual void timeout(void);
+protected:
+        Pixmap searchCache(unsigned int, unsigned int, unsigned long, BColor *, BColor *);
 };