Rename Fl_Image::pixel_w() and pixel_h() to Fl_Image::data_w() and data_h().

The docs of class Fl_Image and of Fl_Image::scale() are beefed up.

git-svn-id: file:///fltk/svn/fltk/branches/branch-1.4@12784 ea41ed52-d2ee-0310-a9c1-e6b18d33e121

8 files changed, 98 insertions, 92 deletions

diff --git a/src/Fl_Bitmap.cxx b/src/Fl_Bitmap.cxx
index 4324b5367..c3cbaea2a 100644
--- a/src/Fl_Bitmap.cxx
+++ b/src/Fl_Bitmap.cxx
@@ -158,7 +158,7 @@ Fl_Image *Fl_Bitmap::copy(int W, int H) {
   uchar		*new_array;	// New array for image data
 
   // Optimize the simple copy where the width and height are the same...
-  if (W == pixel_w() && H == pixel_h()) {
+  if (W == data_w() && H == data_h()) {
     new_array = new uchar [H * ((W + 7) / 8)];
     memcpy(new_array, array, H * ((W + 7) / 8));
 
@@ -182,10 +182,10 @@ Fl_Image *Fl_Bitmap::copy(int W, int H) {
 
 
   // Figure out Bresenham step/modulus values...
-  xmod   = pixel_w() % W;
-  xstep  = pixel_w() / W;
-  ymod   = pixel_h() % H;
-  ystep  = pixel_h() / H;
+  xmod   = data_w() % W;
+  xstep  = data_w() / W;
+  ymod   = data_h() % H;
+  ystep  = data_h() / H;
 
   // Allocate memory for the new image...
   new_array = new uchar [H * ((W + 7) / 8)];
@@ -196,7 +196,7 @@ Fl_Image *Fl_Bitmap::copy(int W, int H) {
 
   // Scale the image using a nearest-neighbor algorithm...
   for (dy = H, sy = 0, yerr = H, new_ptr = new_array; dy > 0; dy --) {
-    for (dx = W, xerr = W, old_ptr = array + sy * ((pixel_w() + 7) / 8), sx = 0, new_bit = 1;
+    for (dx = W, xerr = W, old_ptr = array + sy * ((data_w() + 7) / 8), sx = 0, new_bit = 1;
 	 dx > 0;
 	 dx --) {
       old_bit = (uchar)(1 << (sx & 7));
diff --git a/src/Fl_Graphics_Driver.cxx b/src/Fl_Graphics_Driver.cxx
index 7655e1c27..e1045b460 100644
--- a/src/Fl_Graphics_Driver.cxx
+++ b/src/Fl_Graphics_Driver.cxx
@@ -332,7 +332,7 @@ void Fl_Scalable_Graphics_Driver::draw(Fl_Pixmap *pxm, int XP, int YP, int WP, i
   if (!*id(pxm)) {
     int w2=pxm->w(), h2=pxm->h();
     cache_size(pxm, w2, h2); // after this, w2 x h2 is size of desired cached image
-    if (pxm->pixel_w() != w2 || pxm->pixel_h() != h2) { // build a scaled id_ & pixmap_ for pxm
+    if (pxm->data_w() != w2 || pxm->data_h() != h2) { // build a scaled id_ & pixmap_ for pxm
       Fl_Pixmap *pxm2 = (Fl_Pixmap*)pxm->copy(w2, h2);
       *id(pxm) = cache(pxm2);
       *cache_scale(pxm) = scale_;
@@ -357,7 +357,7 @@ void Fl_Scalable_Graphics_Driver::draw(Fl_Bitmap *bm, int XP, int YP, int WP, in
   if (!*id(bm)) {
     int w2 = bm->w(), h2 = bm->h();
     cache_size(bm, w2, h2); // after this, w2 x h2 is size of desired cached image
-    if (bm->pixel_w() != w2 || bm->pixel_h() != h2) { // build a scaled id_ for bm
+    if (bm->data_w() != w2 || bm->data_h() != h2) { // build a scaled id_ for bm
       Fl_Bitmap *bm2 = (Fl_Bitmap*)bm->copy(w2, h2);
       *id(bm) = cache(bm2);
       *cache_scale(bm) =  scale_;
@@ -378,8 +378,8 @@ void Fl_Scalable_Graphics_Driver::draw(Fl_RGB_Image *img, int XP, int YP, int WP
   if (start_image(img, XP, YP, WP, HP, cx, cy, XP, YP, WP, HP)) {
     return;
   }
-  int need_scaled_drawing = fabs(img->w() - img->pixel_w()/scale_)/img->w() > 0.05 ||
-  fabs(img->h() - img->pixel_h()/scale_)/img->h() > 0.05;
+  int need_scaled_drawing = fabs(img->w() - img->data_w()/scale_)/img->w() > 0.05 ||
+  fabs(img->h() - img->data_h()/scale_)/img->h() > 0.05;
   if (need_scaled_drawing && can_do_alpha_blending()) { // try and use the system's scaled image drawing
     push_clip(XP, YP, WP, HP);
     int done = draw_scaled(img, XP-cx, YP-cy, img->w(), img->h());
diff --git a/src/Fl_Image.cxx b/src/Fl_Image.cxx
index 67dab574c..c2ad08ca0 100644
--- a/src/Fl_Image.cxx
+++ b/src/Fl_Image.cxx
@@ -42,7 +42,7 @@ Fl_RGB_Scaling Fl_Image::scaling_algorithm_ = FL_RGB_SCALING_BILINEAR;
  1 to 4 for color images.
  */
 Fl_Image::Fl_Image(int W, int H, int D) :
-  w_(W), h_(H), d_(D), ld_(0), count_(0), pixel_w_(W), pixel_h_(H), data_(0L)
+  w_(W), h_(H), d_(D), ld_(0), count_(0), data_w_(W), data_h_(H), data_(0L)
 {}
 
 /**
@@ -234,39 +234,45 @@ Fl_RGB_Scaling Fl_Image::RGB_scaling() {
 }
 
 /** Sets the drawing size of the image.
- This function gives the image its own drawing size, independently from its pixel size.
- This can be useful to draw an image on a drawing surface with more than 1 pixel per
- FLTK unit: all pixels of the original image become available to fill an area of the drawing surface
- sized at <tt>width,height</tt> FLTK units.
+ This function controls the values returned by member functions w() and h()
+ which in turn control how the image is drawn: the full image data (whose size
+ is given by data_w() and data_h()) are drawn scaled
+ to an area of the drawing surface sized at w() x h() FLTK units.
+ This can make a difference if the drawing surface has more than 1 pixel per
+ FLTK unit because the image can be drawn at the full resolution of the drawing surface.
  Examples of such drawing surfaces: HiDPI displays, laser printers, PostScript files, PDF printers.
  
- \param width,height   maximum width and height (in FLTK units) to use when drawing the image
- \param proportional   if not null, keep the width and height of the image proportional to those of the original size
- \param can_expand  if null, the width and height of the image will not exceed those of the original size
- \note This function may change the values returned by the w() and h() member functions. In contrast,
- the values returned by pixel_w() and pixel_h() remain unchanged after scale() was called.
+ \param width,height   maximum values, in FLTK units, that w() and h() should return
+ \param proportional   if not null, keep the values returned by w() and h() proportional to
+ data_w() and data_h()
+ \param can_expand  if null, the values returned by w() and h() will not be larger than
+ data_w() and data_h(), respectively
+ \note This function generally changes the values returned by the w() and h() member functions.
+ In contrast, the values returned by data_w() and data_h() remain unchanged.
  \version 1.4 (1.3.4 and FL_ABI_VERSION for Fl_Shared_Image only)
  
  Example code: scale an image to fit in a box
  \code
  Fl_Box *b = ...  // a box
- Fl_Image *img = Fl_Shared_Image::get("/path/to/picture.jpeg"); // read a picture file
- img->scale(b->w(), b->h()); // set the drawing size of the image to the size of the box
+ Fl_Image *img = new Fl_PNG_Image("/path/to/picture.png"); // read a picture file
+ // set the drawing size of the image to the size of the box keeping its aspect ratio
+ img->scale(b->w(), b->h());
  b->image(img); // use the image as the box image
- b->align(FL_ALIGN_INSIDE | FL_ALIGN_CENTER | FL_ALIGN_CLIP); // the image is to be drawn centered in the box
+ // the image is to be drawn centered in the box
+ b->align(FL_ALIGN_INSIDE | FL_ALIGN_CENTER | FL_ALIGN_CLIP);
  \endcode
  */
 void Fl_Image::scale(int width, int height, int proportional, int can_expand)
 {
-  if ((width <= pixel_w() && height <= pixel_h()) || can_expand) {
+  if ((width <= data_w() && height <= data_h()) || can_expand) {
     w_ = width;
     h_ = height;
   }
   if (fail()) return;
   if (!proportional && can_expand) return;
-  if (!proportional && width <= pixel_w() && height <= pixel_h()) return;
-  float fw = pixel_w() / float(width);
-  float fh = pixel_h() / float(height);
+  if (!proportional && width <= data_w() && height <= data_h()) return;
+  float fw = data_w() / float(width);
+  float fh = data_h() / float(height);
   if (proportional) {
     if (fh > fw) fw = fh;
     else fh = fw;
@@ -275,8 +281,8 @@ void Fl_Image::scale(int width, int height, int proportional, int can_expand)
     if (fw < 1) fw = 1;
     if (fh < 1) fh = 1;
   }
-  w_ = int(pixel_w() / fw);
-  h_ = int(pixel_h() / fh);
+  w_ = int(data_w() / fw);
+  h_ = int(data_h() / fh);
 }
 
 /** Draw the image to the current drawing surface rescaled to a given width and height.
@@ -397,29 +403,29 @@ Fl_Image *Fl_RGB_Image::copy(int W, int H) {
 
   // Optimize the simple copy where the width and height are the same,
   // or when we are copying an empty image...
-  if ((W == pixel_w() && H == pixel_h()) ||
+  if ((W == data_w() && H == data_h()) ||
       !w() || !h() || !d() || !array) {
     if (array) {
       // Make a copy of the image data and return a new Fl_RGB_Image...
-      new_array = new uchar[pixel_w() * pixel_h() * d()];
-      if (ld() && ld()!=pixel_w()*d()) {
+      new_array = new uchar[data_w() * data_h() * d()];
+      if (ld() && ld()!=data_w()*d()) {
         const uchar *src = array;
         uchar *dst = new_array;
-        int dy, dh = h(), wd = pixel_w()*d(), wld = ld();
+        int dy, dh = h(), wd = data_w()*d(), wld = ld();
         for (dy=0; dy<dh; dy++) {
           memcpy(dst, src, wd);
           src += wld;
           dst += wd;
         }
       } else {
-        memcpy(new_array, array, pixel_w() * pixel_h() * d());
+        memcpy(new_array, array, data_w() * data_h() * d());
       }
-      new_image = new Fl_RGB_Image(new_array, pixel_w(), pixel_h(), d());
+      new_image = new Fl_RGB_Image(new_array, data_w(), data_h(), d());
       new_image->alloc_array = 1;
 
       return new_image;
     } else {
-      return new Fl_RGB_Image(array, pixel_w(), pixel_h(), d(), ld());
+      return new Fl_RGB_Image(array, data_w(), data_h(), d(), ld());
     }
   }
   if (W <= 0 || H <= 0) return 0;
@@ -435,7 +441,7 @@ Fl_Image *Fl_RGB_Image::copy(int W, int H) {
   new_image = new Fl_RGB_Image(new_array, W, H, d());
   new_image->alloc_array = 1;
 
-  line_d = ld() ? ld() : pixel_w() * d();
+  line_d = ld() ? ld() : data_w() * d();
 
   if (Fl_Image::RGB_scaling() == FL_RGB_SCALING_NEAREST) {
 
@@ -446,10 +452,10 @@ Fl_Image *Fl_RGB_Image::copy(int W, int H) {
 		xstep, ystep;	// X & Y step increments
 
     // Figure out Bresenham step/modulus values...
-    xmod   = pixel_w() % W;
-    xstep  = (pixel_w() / W) * d();
-    ymod   = pixel_h() % H;
-    ystep  = pixel_h() / H;
+    xmod   = data_w() % W;
+    xstep  = (data_w() / W) * d();
+    ymod   = data_h() % H;
+    ystep  = data_h() / H;
 
     // Scale the image using a nearest-neighbor algorithm...
     for (dy = H, sy = 0, yerr = H, new_ptr = new_array; dy > 0; dy --) {
@@ -474,28 +480,28 @@ Fl_Image *Fl_RGB_Image::copy(int W, int H) {
     }
   } else {
     // Bilinear scaling (FL_RGB_SCALING_BILINEAR)
-    const float xscale = (pixel_w() - 1) / (float) W;
-    const float yscale = (pixel_h() - 1) / (float) H;
+    const float xscale = (data_w() - 1) / (float) W;
+    const float yscale = (data_h() - 1) / (float) H;
     for (dy = 0; dy < H; dy++) {
       float oldy = dy * yscale;
-      if (oldy >= pixel_h())
-        oldy = float(pixel_h() - 1);
+      if (oldy >= data_h())
+        oldy = float(data_h() - 1);
       const float yfract = oldy - (unsigned) oldy;
 
       for (dx = 0; dx < W; dx++) {
         new_ptr = new_array + dy * W * d() + dx * d();
 
         float oldx = dx * xscale;
-        if (oldx >= pixel_w())
-          oldx = float(pixel_w() - 1);
+        if (oldx >= data_w())
+          oldx = float(data_w() - 1);
         const float xfract = oldx - (unsigned) oldx;
 
         const unsigned leftx = (unsigned)oldx;
         const unsigned lefty = (unsigned)oldy;
-        const unsigned rightx = (unsigned)(oldx + 1 >= pixel_w() ? oldx : oldx + 1);
+        const unsigned rightx = (unsigned)(oldx + 1 >= data_w() ? oldx : oldx + 1);
         const unsigned righty = (unsigned)oldy;
         const unsigned dleftx = (unsigned)oldx;
-        const unsigned dlefty = (unsigned)(oldy + 1 >= pixel_h() ? oldy : oldy + 1);
+        const unsigned dlefty = (unsigned)(oldy + 1 >= data_h() ? oldy : oldy + 1);
         const unsigned drightx = (unsigned)rightx;
         const unsigned drighty = (unsigned)dlefty;
 
diff --git a/src/Fl_Pixmap.cxx b/src/Fl_Pixmap.cxx
index 21d9e87a3..ca76362de 100644
--- a/src/Fl_Pixmap.cxx
+++ b/src/Fl_Pixmap.cxx
@@ -153,7 +153,7 @@ Fl_Image *Fl_Pixmap::copy(int W, int H) {
     return new Fl_Pixmap((char *const*)0);
   }
   // Optimize the simple copy where the width and height are the same...
-  if (W == pixel_w() && H == pixel_h()) {
+  if (W == data_w() && H == data_h()) {
     // Make an exact copy of the image and return it...
     new_image = new Fl_Pixmap(data());
     new_image->copy_data();
@@ -185,10 +185,10 @@ Fl_Image *Fl_Pixmap::copy(int W, int H) {
   sprintf(new_info, "%d %d %d %d", W, H, ncolors, chars_per_pixel);
 
   // Figure out Bresenham step/modulus values...
-  xmod   = pixel_w() % W;
-  xstep  = (pixel_w() / W) * chars_per_pixel;
-  ymod   = pixel_h() % H;
-  ystep  = pixel_h() / H;
+  xmod   = data_w() % W;
+  xstep  = (data_w() / W) * chars_per_pixel;
+  ymod   = data_h() % H;
+  ystep  = data_h() / H;
 
   // Allocate memory for the new array...
   if (ncolors < 0) new_data = new char *[H + 2];
diff --git a/src/drivers/GDI/Fl_GDI_Graphics_Driver_image.cxx b/src/drivers/GDI/Fl_GDI_Graphics_Driver_image.cxx
index 349775aad..5c00198f0 100644
--- a/src/drivers/GDI/Fl_GDI_Graphics_Driver_image.cxx
+++ b/src/drivers/GDI/Fl_GDI_Graphics_Driver_image.cxx
@@ -463,7 +463,7 @@ void Fl_GDI_Printer_Graphics_Driver::draw_unscaled(Fl_Bitmap *bm, float s, int X
   fl_end_offscreen(); // offscreen data is in tmp_id
   SelectObject(tempdc, (HGDIOBJ)tmp_id); // use offscreen data
                                          // draw it to printer context with background color as transparent
-  fl_TransparentBlt(gc_, X,Y,W,H, tempdc, cx, cy, bm->pixel_w(), bm->pixel_h(), RGB(r, g, b) );
+  fl_TransparentBlt(gc_, X,Y,W,H, tempdc, cx, cy, bm->data_w(), bm->data_h(), RGB(r, g, b) );
   fl_delete_offscreen(tmp_id);
   RestoreDC(tempdc, save);
   DeleteDC(tempdc);
@@ -472,14 +472,14 @@ void Fl_GDI_Printer_Graphics_Driver::draw_unscaled(Fl_Bitmap *bm, float s, int X
 
 static Fl_Offscreen build_id(Fl_RGB_Image *img, void **pmask)
 {
-  Fl_Image_Surface *surface = new Fl_Image_Surface(img->pixel_w(), img->pixel_h());
+  Fl_Image_Surface *surface = new Fl_Image_Surface(img->data_w(), img->data_h());
   Fl_Surface_Device::push_current(surface);
   if ((img->d() == 2 || img->d() == 4) && fl_can_do_alpha_blending()) {
-    fl_draw_image(img->array, 0, 0, img->pixel_w(), img->pixel_h(), img->d()|FL_IMAGE_WITH_ALPHA, img->ld());
+    fl_draw_image(img->array, 0, 0, img->data_w(), img->data_h(), img->d()|FL_IMAGE_WITH_ALPHA, img->ld());
   } else {
-    fl_draw_image(img->array, 0, 0, img->pixel_w(), img->pixel_h(), img->d(), img->ld());
+    fl_draw_image(img->array, 0, 0, img->data_w(), img->data_h(), img->d(), img->ld());
     if (img->d() == 2 || img->d() == 4) {
-      *pmask = fl_create_alphamask(img->pixel_w(), img->pixel_h(), img->d(), img->ld(), img->array);
+      *pmask = fl_create_alphamask(img->data_w(), img->data_h(), img->d(), img->ld(), img->array);
     }
   }
   Fl_Surface_Device::pop_current();
@@ -494,8 +494,8 @@ void Fl_GDI_Graphics_Driver::draw_unscaled(Fl_RGB_Image *img, float s, int X, in
   Y = Y*s;
   cache_size(img, W, H);
   cx *= s; cy *= s;
-  if (W + cx > img->pixel_w()) W = img->pixel_w() - cx;
-  if (H + cy > img->pixel_h()) H = img->pixel_h() - cy;
+  if (W + cx > img->data_w()) W = img->data_w() - cx;
+  if (H + cy > img->data_h()) H = img->data_h() - cy;
   if (!*Fl_Graphics_Driver::id(img)) {
     *Fl_Graphics_Driver::id(img) = (fl_uintptr_t)build_id(img, (void**)(Fl_Graphics_Driver::mask(img)));
     *cache_scale(img) = 1;
@@ -521,13 +521,13 @@ void Fl_GDI_Graphics_Driver::draw_unscaled(Fl_RGB_Image *img, float s, int X, in
 int Fl_GDI_Printer_Graphics_Driver::draw_scaled(Fl_Image *img, int XP, int YP, int WP, int HP) {
   XFORM old_tr, tr;
   GetWorldTransform(gc_, &old_tr); // storing old transform
-  tr.eM11 = float(WP)/float(img->pixel_w());
-  tr.eM22 = float(HP)/float(img->pixel_h());
+  tr.eM11 = float(WP)/float(img->data_w());
+  tr.eM22 = float(HP)/float(img->data_h());
   tr.eM12 = tr.eM21 = 0;
   tr.eDx =  float(XP);
   tr.eDy =  float(YP);
   ModifyWorldTransform(gc_, &tr, MWT_LEFTMULTIPLY);
-  img->draw(0, 0, img->pixel_w(), img->pixel_h(), 0, 0);
+  img->draw(0, 0, img->data_w(), img->data_h(), 0, 0);
   SetWorldTransform(gc_, &old_tr);
   return 1;
 }
@@ -548,10 +548,10 @@ int Fl_GDI_Graphics_Driver::draw_scaled(Fl_Image *img, int XP, int YP, int WP, i
   int save = SaveDC(new_gc);
   SelectObject(new_gc, (HBITMAP)*Fl_Graphics_Driver::id(rgb));
   if ( (rgb->d() % 2) == 0 ) {
-    alpha_blend_(XP*scale_, YP*scale_, WP, HP, new_gc, 0, 0, rgb->pixel_w(), rgb->pixel_h());
+    alpha_blend_(XP*scale_, YP*scale_, WP, HP, new_gc, 0, 0, rgb->data_w(), rgb->data_h());
   } else {
     SetStretchBltMode(gc_, HALFTONE);
-    StretchBlt(gc_, XP*scale_, YP*scale_, WP, HP, new_gc, 0, 0, rgb->pixel_w(), rgb->pixel_h(), SRCCOPY);
+    StretchBlt(gc_, XP*scale_, YP*scale_, WP, HP, new_gc, 0, 0, rgb->data_w(), rgb->data_h(), SRCCOPY);
   }
   RestoreDC(new_gc, save);
   DeleteDC(new_gc);
@@ -601,7 +601,7 @@ static Fl_Bitmask fl_create_bitmap(int w, int h, const uchar *data) {
 
 fl_uintptr_t Fl_GDI_Graphics_Driver::cache(Fl_Bitmap *bm) {
   *cache_scale(bm) =  Fl_Scalable_Graphics_Driver::scale();
-  return (fl_uintptr_t)fl_create_bitmap(bm->pixel_w(), bm->pixel_h(), bm->array);
+  return (fl_uintptr_t)fl_create_bitmap(bm->data_w(), bm->data_h(), bm->array);
 }
 
 void Fl_GDI_Graphics_Driver::draw_unscaled(Fl_Pixmap *pxm, float s, int X, int Y, int W, int H, int cx, int cy) {
@@ -646,7 +646,7 @@ void Fl_GDI_Printer_Graphics_Driver::draw_unscaled(Fl_Pixmap *pxm, float s, int
 
 
 fl_uintptr_t Fl_GDI_Graphics_Driver::cache(Fl_Pixmap *img) {
-  Fl_Image_Surface *surf = new Fl_Image_Surface(img->pixel_w(), img->pixel_h());
+  Fl_Image_Surface *surf = new Fl_Image_Surface(img->data_w(), img->data_h());
   Fl_Surface_Device::push_current(surf);
   uchar *bitmap = 0;
   Fl_Surface_Device::surface()->driver()->mask_bitmap(&bitmap);
@@ -654,7 +654,7 @@ fl_uintptr_t Fl_GDI_Graphics_Driver::cache(Fl_Pixmap *img) {
   *Fl_Graphics_Driver::pixmap_bg_color(img) = Fl_WinAPI_System_Driver::win_pixmap_bg_color;  // computed by fl_draw_pixmap()
   Fl_Surface_Device::surface()->driver()->mask_bitmap(0);
   if (bitmap) {
-    *Fl_Graphics_Driver::mask(img) = (fl_uintptr_t)fl_create_bitmask(img->pixel_w(), img->pixel_h(), bitmap);
+    *Fl_Graphics_Driver::mask(img) = (fl_uintptr_t)fl_create_bitmask(img->data_w(), img->data_h(), bitmap);
     delete[] bitmap;
   }
   Fl_Surface_Device::pop_current();
diff --git a/src/drivers/PostScript/Fl_PostScript_image.cxx b/src/drivers/PostScript/Fl_PostScript_image.cxx
index 49cb9cebe..cc91f24da 100644
--- a/src/drivers/PostScript/Fl_PostScript_image.cxx
+++ b/src/drivers/PostScript/Fl_PostScript_image.cxx
@@ -574,7 +574,7 @@ void Fl_PostScript_Graphics_Driver::draw_image_mono(Fl_Draw_Image_Cb call, void
 void Fl_PostScript_Graphics_Driver::draw(Fl_Pixmap * pxm,int XP, int YP, int WP, int HP, int cx, int cy){
   int need_clip = cx || cy || WP != pxm->w() || HP != pxm->h();
   if (need_clip) push_clip(XP, YP, WP, HP);
-  if (pxm->w() != pxm->pixel_w() || pxm->h() != pxm->pixel_h()) {
+  if (pxm->w() != pxm->data_w() || pxm->h() != pxm->data_h()) {
     draw_scaled(pxm, XP-cx, YP-cy, pxm->w(), pxm->h());
   } else {
     const char * const * di =pxm->data();
@@ -596,7 +596,7 @@ void Fl_PostScript_Graphics_Driver::draw(Fl_RGB_Image * rgb,int XP, int YP, int
 {
   int need_clip = cx || cy || WP != rgb->w() || HP != rgb->h();
   if (need_clip) push_clip(XP, YP, WP, HP);
-  if (rgb->w() != rgb->pixel_w() || rgb->h() != rgb->pixel_h()) {
+  if (rgb->w() != rgb->data_w() || rgb->h() != rgb->data_h()) {
     draw_scaled(rgb, XP-cx, YP-cy, rgb->w(), rgb->h());
   } else {
     const uchar  * di = rgb->array;
@@ -618,10 +618,10 @@ int Fl_PostScript_Graphics_Driver::draw_scaled(Fl_Image *img, int XP, int YP, in
   if (W == 0 || H == 0) return 1;
   push_no_clip(); // remove the FLTK clip that can't be rescaled
   clocale_printf("%d %d %i %i CL\n", X, Y, W, H);
-  clocale_printf("GS %d %d TR  %f %f SC GS\n", XP, YP, float(WP)/img->pixel_w(), float(HP)/img->pixel_h());
+  clocale_printf("GS %d %d TR  %f %f SC GS\n", XP, YP, float(WP)/img->data_w(), float(HP)/img->data_h());
   int keep_w = img->w(), keep_h = img->h();
-  img->scale(img->pixel_w(), img->pixel_h(), 0, 1);
-  img->draw(0, 0, img->pixel_w(), img->pixel_h(), 0, 0);
+  img->scale(img->data_w(), img->data_h(), 0, 1);
+  img->draw(0, 0, img->data_w(), img->data_h(), 0, 0);
   clocale_printf("GR GR\n");
   img->scale(keep_w, keep_h, 0, 1);
   pop_clip(); // restore FLTK's clip
@@ -631,7 +631,7 @@ int Fl_PostScript_Graphics_Driver::draw_scaled(Fl_Image *img, int XP, int YP, in
 void Fl_PostScript_Graphics_Driver::draw(Fl_Bitmap * bitmap,int XP, int YP, int WP, int HP, int cx, int cy) {
   int need_clip = cx || cy || WP != bitmap->w() || HP != bitmap->h();
   if (need_clip) push_clip(XP, YP, WP, HP);
-  if (bitmap->w() != bitmap->pixel_w() || bitmap->h() != bitmap->pixel_h()) {
+  if (bitmap->w() != bitmap->data_w() || bitmap->h() != bitmap->data_h()) {
     draw_scaled(bitmap, XP-cx, YP-cy, bitmap->w(), bitmap->h());
   } else {
     const uchar  * di = bitmap->array;
diff --git a/src/drivers/Quartz/Fl_Quartz_Graphics_Driver_image.cxx b/src/drivers/Quartz/Fl_Quartz_Graphics_Driver_image.cxx
index 1bd4d8fbc..db00f7935 100644
--- a/src/drivers/Quartz/Fl_Quartz_Graphics_Driver_image.cxx
+++ b/src/drivers/Quartz/Fl_Quartz_Graphics_Driver_image.cxx
@@ -162,7 +162,7 @@ void Fl_Quartz_Graphics_Driver::draw(Fl_RGB_Image *img, int XP, int YP, int WP,
   if (!cgimg) {
     CGColorSpaceRef lut = img->d()<=2 ? CGColorSpaceCreateDeviceGray() : CGColorSpaceCreateDeviceRGB();
     int ld = img->ld();
-    if (!ld) ld = img->pixel_w() * img->d();
+    if (!ld) ld = img->data_w() * img->d();
     CGDataProviderRef src;
     if ( has_feature(PRINTER) ) {
       // When printing, the data at img->array are used when the printed page is completed,
@@ -172,16 +172,16 @@ void Fl_Quartz_Graphics_Driver::draw(Fl_RGB_Image *img, int XP, int YP, int WP,
       // is used to avoid repeating the copy operation if img is printed again.
       // The CGImage data provider deletes the copy at the latest of these two events:
       // deletion of img, and completion of the page where img was printed.
-      size_t total = ld * img->pixel_h();
+      size_t total = ld * img->data_h();
       uchar *copy = new uchar[total];
       memcpy(copy, img->array, total);
       src = CGDataProviderCreateWithData(NULL, copy, total, dataReleaseCB);
       *Fl_Graphics_Driver::mask(img) = 1;
     } else {
     // the CGImage data provider must not release the image data.
-      src = CGDataProviderCreateWithData(NULL, img->array, ld * img->pixel_h(), NULL);
+      src = CGDataProviderCreateWithData(NULL, img->array, ld * img->data_h(), NULL);
     }
-    cgimg = CGImageCreate(img->pixel_w(), img->pixel_h(), 8, img->d()*8, ld,
+    cgimg = CGImageCreate(img->data_w(), img->data_h(), 8, img->d()*8, ld,
                                            lut, (img->d()&1)?kCGImageAlphaNone:kCGImageAlphaLast,
                                            src, 0L, false, kCGRenderingIntentDefault);
     *Fl_Graphics_Driver::id(img) = (fl_uintptr_t)cgimg;
@@ -230,7 +230,7 @@ void Fl_Quartz_Graphics_Driver::uncache(Fl_RGB_Image*, fl_uintptr_t &id_, fl_uin
 }
 
 fl_uintptr_t Fl_Quartz_Graphics_Driver::cache(Fl_Bitmap *bm) {
-  return (fl_uintptr_t)create_bitmask(bm->pixel_w(), bm->pixel_h(), bm->array);
+  return (fl_uintptr_t)create_bitmask(bm->data_w(), bm->data_h(), bm->array);
 }
 
 
@@ -239,7 +239,7 @@ static void pmProviderRelease (void *ctxt, const void *data, size_t size) {
 }
 
 fl_uintptr_t Fl_Quartz_Graphics_Driver::cache(Fl_Pixmap *img) {
-  Fl_Image_Surface *surf = new Fl_Image_Surface(img->pixel_w(), img->pixel_h());
+  Fl_Image_Surface *surf = new Fl_Image_Surface(img->data_w(), img->data_h());
   Fl_Surface_Device::push_current(surf);
   fl_draw_pixmap(img->data(), 0, 0, FL_BLACK);
   CGContextRef src = surf->get_offscreen_before_delete();
diff --git a/src/drivers/Xlib/Fl_Xlib_Graphics_Driver_image.cxx b/src/drivers/Xlib/Fl_Xlib_Graphics_Driver_image.cxx
index 0511dbfa0..902cb5e45 100644
--- a/src/drivers/Xlib/Fl_Xlib_Graphics_Driver_image.cxx
+++ b/src/drivers/Xlib/Fl_Xlib_Graphics_Driver_image.cxx
@@ -643,7 +643,7 @@ void Fl_Xlib_Graphics_Driver::draw_unscaled(Fl_Bitmap *bm, float s, int X, int Y
 // alpha compositing...
 static void alpha_blend(Fl_RGB_Image *img, int X, int Y, int W, int H, int cx, int cy) {
   int ld = img->ld();
-  if (ld == 0) ld = img->pixel_w() * img->d();
+  if (ld == 0) ld = img->data_w() * img->d();
   uchar *srcptr = (uchar*)img->array + cy * ld + cx * img->d();
   int srcskip = ld - img->d() * W;
 
@@ -700,16 +700,16 @@ static Fl_Offscreen cache_rgb(Fl_RGB_Image *img) {
   Fl_Image_Surface *surface;
   int depth = img->d();
   if (depth == 1 || depth == 3) {
-    surface = new Fl_Image_Surface(img->pixel_w(), img->pixel_h());
+    surface = new Fl_Image_Surface(img->data_w(), img->data_h());
   } else if (fl_can_do_alpha_blending()) {
-    Fl_Offscreen pixmap = XCreatePixmap(fl_display, RootWindow(fl_display, fl_screen), img->pixel_w(), img->pixel_h(), 32);
-    surface = new Fl_Image_Surface(img->pixel_w(), img->pixel_h(), 0, pixmap);
+    Fl_Offscreen pixmap = XCreatePixmap(fl_display, RootWindow(fl_display, fl_screen), img->data_w(), img->data_h(), 32);
+    surface = new Fl_Image_Surface(img->data_w(), img->data_h(), 0, pixmap);
     depth |= FL_IMAGE_WITH_ALPHA;
   } else {
     return 0;
   }
   Fl_Surface_Device::push_current(surface);
-  fl_draw_image(img->array, 0, 0, img->pixel_w(), img->pixel_h(), depth, img->ld());
+  fl_draw_image(img->array, 0, 0, img->data_w(), img->data_h(), depth, img->ld());
   Fl_Surface_Device::pop_current();
   Fl_Offscreen off = surface->get_offscreen_before_delete();
   delete surface;
@@ -724,8 +724,8 @@ void Fl_Xlib_Graphics_Driver::draw_unscaled(Fl_RGB_Image *img, float s, int X, i
   Y = (Y+offset_y_)*s;
   cache_size(img, W, H);
   cx *= s; cy *= s;
-  if (W + cx > img->pixel_w()) W = img->pixel_w() - cx;
-  if (H + cy > img->pixel_h()) H = img->pixel_h() - cy;
+  if (W + cx > img->data_w()) W = img->data_w() - cx;
+  if (H + cy > img->data_h()) H = img->data_h() - cy;
   if (!*Fl_Graphics_Driver::id(img)) {
     *Fl_Graphics_Driver::id(img) = cache_rgb(img);
     *cache_scale(img) = 1;
@@ -768,7 +768,7 @@ void Fl_Xlib_Graphics_Driver::uncache(Fl_RGB_Image*, fl_uintptr_t &id_, fl_uintp
 
 fl_uintptr_t Fl_Xlib_Graphics_Driver::cache(Fl_Bitmap *bm) {
   *cache_scale(bm) =  Fl_Scalable_Graphics_Driver::scale();
-  return (fl_uintptr_t)create_bitmask(bm->pixel_w(), bm->pixel_h(), bm->array);
+  return (fl_uintptr_t)create_bitmask(bm->data_w(), bm->data_h(), bm->array);
 }
 
 void Fl_Xlib_Graphics_Driver::draw_unscaled(Fl_Pixmap *pxm, float s, int X, int Y, int W, int H, int cx, int cy) {
@@ -817,14 +817,14 @@ void Fl_Xlib_Graphics_Driver::draw_unscaled(Fl_Pixmap *pxm, float s, int X, int
 
 
 fl_uintptr_t Fl_Xlib_Graphics_Driver::cache(Fl_Pixmap *pxm) {
-  Fl_Image_Surface *surf = new Fl_Image_Surface(pxm->pixel_w(), pxm->pixel_h());
+  Fl_Image_Surface *surf = new Fl_Image_Surface(pxm->data_w(), pxm->data_h());
   Fl_Surface_Device::push_current(surf);
   uchar *bitmap = 0;
   Fl_Surface_Device::surface()->driver()->mask_bitmap(&bitmap);
   fl_draw_pixmap(pxm->data(), 0, 0, FL_BLACK);
   Fl_Surface_Device::surface()->driver()->mask_bitmap(0);
   if (bitmap) {
-    *Fl_Graphics_Driver::mask(pxm) = (fl_uintptr_t)create_bitmask(pxm->pixel_w(), pxm->pixel_h(), bitmap);
+    *Fl_Graphics_Driver::mask(pxm) = (fl_uintptr_t)create_bitmask(pxm->data_w(), pxm->data_h(), bitmap);
     delete[] bitmap;
   }
   Fl_Surface_Device::pop_current();
@@ -885,7 +885,7 @@ int Fl_Xlib_Graphics_Driver::draw_scaled(Fl_Image *img, int XP, int YP, int WP,
   }
   cache_size(img, WP, HP);
   return scale_and_render_pixmap( *Fl_Graphics_Driver::id(rgb), rgb->d(),
-                                 rgb->pixel_w() / double(WP), rgb->pixel_h() / double(HP), 0, 0, (XP + offset_x_)*scale_, (YP + offset_y_)*scale_, WP, HP);
+                                 rgb->data_w() / double(WP), rgb->data_h() / double(HP), 0, 0, (XP + offset_x_)*scale_, (YP + offset_y_)*scale_, WP, HP);
 }
 #endif // HAVE_XRENDER