开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > IP电话/视频会议 > 查看源码
graphics.cxx
资源名称：pwlib_1.1pl17.zip　[点击查看]
上传用户：hzhsqp
上传日期：2007-01-06
资源大小：1600k
文件大小：51k
源码类别：

IP电话/视频会议

开发平台：

Visual C++

graphics.cxx：源码内容
  1. /*
  2.  * graphics.cxx
  3.  *
  4.  * Graphics, Canvas and drawing classes.
  5.  *
  6.  * Portable Windows Library
  7.  *
  8.  * Copyright (c) 1993-1998 Equivalence Pty. Ltd.
  9.  *
  10.  * The contents of this file are subject to the Mozilla Public License
  11.  * Version 1.0 (the "License"); you may not use this file except in
  12.  * compliance with the License. You may obtain a copy of the License at
  13.  * http://www.mozilla.org/MPL/
  14.  *
  15.  * Software distributed under the License is distributed on an "AS IS"
  16.  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  17.  * the License for the specific language governing rights and limitations
  18.  * under the License.
  19.  *
  20.  * The Original Code is Portable Windows Library.
  21.  *
  22.  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
  23.  *
  24.  * Portions are Copyright (C) 1993 Free Software Foundation, Inc.
  25.  * All Rights Reserved.
  26.  *
  27.  * Contributor(s): ______________________________________.
  28.  *
  29.  * $Log: graphics.cxx,v $
  30.  * Revision 1.38  1999/09/05 14:39:22  robertj
  31.  * GNU 2.95 compatibility
  32.  *
  33.  * Revision 1.37  1998/10/16 11:08:15  robertj
  34.  * GNU compatibility.
  35.  *
  36.  * Revision 1.36  1998/09/23 06:29:38  robertj
  37.  * Added open source copyright license.
  38.  *
  39.  * Revision 1.35  1998/09/22 15:06:38  robertj
  40.  * Added delayed HDC creation in PDrawCanvas.
  41.  *
  42.  * Revision 1.34  1998/03/20 03:14:11  robertj
  43.  * Added function to get physical bounds of canvas. Allows to scale drawing.
  44.  *
  45.  * Revision 1.33  1997/04/27 05:50:21  robertj
  46.  * DLL support.
  47.  *
  48.  * Revision 1.32  1996/11/04 03:39:34  robertj
  49.  * Fixed warning about uninitialised variable.
  50.  *
  51.  * Revision 1.31  1996/07/15 10:34:21  robertj
  52.  * Fixed uninitialised variable.
  53.  * Changed endian classes to be memory mapped.
  54.  *
  55.  * Revision 1.30  1996/06/28 13:17:37  robertj
  56.  * Removed integer size mismatch warnings
  57.  *
  58.  * Revision 1.29  1996/06/17 11:42:16  robertj
  59.  * Creation of a default palette for 24 bit images.
  60.  *
  61.  * Revision 1.28  1996/01/28 02:52:02  robertj
  62.  * Added assert into all Compare functions to assure comparison between compatible objects.
  63.  *
  64.  * Revision 1.27  1995/12/10 11:38:21  robertj
  65.  * Removed eatwhite() as not in GNU library.
  66.  * Fixed automatic operator translation incompatibility amongst compilers.
  67.  *
  68.  * Revision 1.26  1995/11/21 11:52:35  robertj
  69.  * Improved streams compatibility.
  70.  * Added 16 bit windows support for bitmap reading.
  71.  *
  72.  * Revision 1.24  1995/10/14 15:09:57  robertj
  73.  * Changed return values to references for efficency.
  74.  *
  75.  * Revision 1.23  1995/08/12 22:33:42  robertj
  76.  * Changed DrawBevelledRect() so does not change background colour.
  77.  *
  78.  * Revision 1.22  1995/04/25 11:29:20  robertj
  79.  * Fixed Borland compiler warnings.
  80.  *
  81.  * Revision 1.21  1995/02/22 10:50:36  robertj
  82.  * Changes required for compiling release (optimised) version.
  83.  *
  84.  * Revision 1.20  1995/01/27  11:13:43  robertj
  85.  * Added pattern origin.
  86.  *
  87.  * Revision 1.19  1995/01/21  05:14:31  robertj
  88.  * Added origin changing function, simpler than setting rectangles.
  89.  * Fixed rounding error for negative numbers in coordinate system conversions.
  90.  *
  91.  * Revision 1.18  1995/01/06  10:43:59  robertj
  92.  * Changed PRealFont usage from pointer to reference.
  93.  *
  94.  * Revision 1.17  1994/12/14  11:17:17  robertj
  95.  * Changed PDIMENSION to be unsigned causing untold number of changes.
  96.  *
  97.  * Revision 1.16  1994/12/12  10:07:15  robertj
  98.  * Made depth member of PPixels and removed virtual function.
  99.  *
  100.  * Revision 1.15  1994/12/05  11:34:25  robertj
  101.  * Major rewrite of images, pictures and pixmaps.
  102.  * Renamed PPict, PPixels and PImage to make sure all uses are found.
  103.  *
  104.  * Revision 1.14  1994/11/01  11:57:47  robertj
  105.  * Removed lots of signed/unsigned mismatch warnings.
  106.  *
  107.  * Revision 1.13  1994/10/30  11:51:29  robertj
  108.  * Added ability to change interactor foreground colour on a per interactor basis.
  109.  *
  110.  * Revision 1.12  1994/10/23  03:45:22  robertj
  111.  * Added multiply and divide operators for points and dims.
  112.  * Changed PPixels to have subclasses for each pixel size and be fully polymorhic.
  113.  *
  114.  * Revision 1.11  1994/08/21  23:43:02  robertj
  115.  * Optimisation of DrawString() for transparent background.
  116.  *
  117.  * Revision 1.10  1994/08/01  03:41:24  robertj
  118.  * Use of PNEW instead of new for heap debugging. Need undef for Unix end.
  119.  *
  120.  * Revision 1.9  1994/07/27  05:58:07  robertj
  121.  * Synchronisation.
  122.  *
  123.  * Revision 1.8  1994/06/25  11:55:15  robertj
  124.  * Unix version synchronisation.
  125.  *
  126.  * Revision 1.7  1994/04/20  12:17:44  robertj
  127.  * assert changes
  128.  *
  129.  * Revision 1.6  1994/03/07  07:47:00  robertj
  130.  * Major upgrade
  131.  *
  132.  * Revision 1.5  1994/01/03  04:42:23  robertj
  133.  * Mass changes to common container classes and interactors etc etc etc.
  134.  *
  135.  * Revision 1.4  1993/12/31  06:53:02  robertj
  136.  * Made inlines optional for debugging purposes.
  137.  *
  138.  * Revision 1.3  1993/12/15  23:41:27  robertj
  139.  * Removed triadic conditional expressions as GCC can't do it.
  140.  *
  141.  * Revision 1.2  1993/12/04  05:23:25  robertj
  142.  * More implementation
  143.  *
  144.  * Revision 1.1  1993/11/20  17:26:28  robertj
  145.  * Initial revision
  146.  */
  148. #include <pwlib.h>
  149. #include <ctype.h>
  151. #define new PNEW
  154. ///////////////////////////////////////////////////////////////////////////////
  155. // PDim
  157. #if defined(_PDIM)
  159. PObject * PDim::Clone() const
  160. {
  161.   return new PDim(width, height);
  162. }
  165. PObject::Comparison PDim::Compare(const PObject & obj) const
  166. {
  167.   PAssert(obj.IsDescendant(PDim::Class()), PInvalidCast);
  168.   const PDim & other = (const PDim &)obj;
  169.   if (height == other.height && width == other.width)
  170.     return EqualTo;
  171.   else
  172.     return width*height < other.width*other.height ? LessThan : GreaterThan;
  173. }
  176. PDim PDim::operator+(const PDim & dim) const
  177. {
  178.   return PDim(width+dim.width, height+dim.height);
  179. }
  182. PDim PDim::operator+(const PPoint & pt) const
  183. {
  184.   return PDim(width+pt.X(), height+pt.Y());
  185. }
  188. PDim & PDim::operator+=(const PDim & dim)
  189. {
  190.   width += dim.width;
  191.   height += dim.height;
  192.   return *this;
  193. }
  196. PDim & PDim::operator+=(const PPoint & pt)
  197. {
  198.   width += (PDIMENSION)pt.X();
  199.   height += (PDIMENSION)pt.Y();
  200.   return *this;
  201. }
  204. PDim PDim::operator-(const PDim & dim) const
  205. {
  206.   return PDim(width-dim.width, height-dim.height);
  207. }
  210. PDim & PDim::operator-=(const PDim & dim)
  211. {
  212.   width -= dim.width;
  213.   height -= dim.height;
  214.   return *this;
  215. }
  218. PDim & PDim::operator-=(const PPoint & pt)
  219. {
  220.   width -= (PDIMENSION)pt.X();
  221.   height -= (PDIMENSION)pt.Y();
  222.   return *this;
  223. }
  226. PDim PDim::operator*(PDIMENSION scale) const
  227. {
  228.   return PDim(width*scale, height*scale);
  229. }
  232. PDim & PDim::operator*=(PDIMENSION scale)
  233. {
  234.   width *= scale;
  235.   height *= scale;
  236.   return *this;
  237. }
  239. PDim PDim::operator/(PDIMENSION scale) const
  240. {
  241.   return PDim(width/scale, height/scale);
  242. }
  245. PDim & PDim::operator/=(PDIMENSION scale)
  246. {
  247.   width /= scale;
  248.   height /= scale;
  249.   return *this;
  250. }
  253. #endif
  256. ///////////////////////////////////////////////////////////////////////////////
  257. // PPoint
  259. #if defined(_PPOINT)
  261. PObject * PPoint::Clone() const
  262. {
  263.   return new PPoint(*this);
  264. }
  267. PObject::Comparison PPoint::Compare(const PObject & obj) const
  268. {
  269.   PAssert(obj.IsDescendant(PPoint::Class()), PInvalidCast);
  270.   const PPoint & other = (const PPoint &)obj;
  271.   if (X() == other.X() && Y() == other.Y())
  272.     return EqualTo;
  274.   return X()+Y() < other.X()+other.Y() ? LessThan : GreaterThan;
  275. }
  278. PPoint PPoint::operator+(const PPoint & pt) const
  279. {
  280.   return PPoint(X()+pt.X(), Y()+pt.Y());
  281. }
  284. PPoint PPoint::operator+(const PDim & dim) const
  285. {
  286.   return PPoint(X()+dim.Width(), Y()+dim.Height());
  287. }
  290. PPoint PPoint::operator-(const PPoint & pt) const
  291. {
  292.   return PPoint(X()-pt.X(), Y()-pt.Y());
  293. }
  296. PPoint PPoint::operator-(const PDim & dim) const
  297. {
  298.   return PPoint(X()-dim.Width(), Y()-dim.Height());
  299. }
  302. PPoint PPoint::operator*(const PPoint & pt) const
  303. {
  304.   return PPoint(X()*pt.X(), Y()*pt.Y());
  305. }
  308. PPoint PPoint::operator*(const PDim & dim) const
  309. {
  310.   return PPoint(X()*dim.Width(), Y()*dim.Height());
  311. }
  314. PPoint PPoint::operator*(PORDINATE scale) const
  315. {
  316.   return PPoint(X()*scale, Y()*scale);
  317. }
  320. PPoint PPoint::operator/(const PPoint & pt) const
  321. {
  322.   return PPoint(X()/pt.X(), Y()/pt.Y());
  323. }
  326. PPoint PPoint::operator/(const PDim & dim) const
  327. {
  328.   return PPoint(X()/dim.Width(), Y()/dim.Height());
  329. }
  332. PPoint PPoint::operator/(PORDINATE scale) const
  333. {
  334.   return PPoint(X()/scale, Y()/scale);
  335. }
  338. #endif
  341. ///////////////////////////////////////////////////////////////////////////////
  342. // PRect
  344. #if defined(_PRECT)
  346. PObject * PRect::Clone() const
  347. {
  348.   return new PRect(*this);
  349. }
  353. PPoint PRect::Centre() const
  354. {
  355.   return PPoint(X()+Width()/2, Y()+Height()/2);
  356. }
  359. void PRect::SetOrigin(PORDINATE nx, PORDINATE ny)
  360. {
  361.   SetX(nx);
  362.   SetY(ny);
  363. }
  366. void PRect::SetOrigin(const PPoint & org)
  367. {
  368.   SetX(org.X());
  369.   SetY(org.Y());
  370. }
  373. void PRect::SetCorner(PORDINATE nx, PORDINATE ny)
  374. {
  375.   SetRight(nx);
  376.   SetBottom(ny);
  377. }
  380. void PRect::SetCorner(const PPoint & cnr)
  381. {
  382.   SetRight(cnr.X());
  383.   SetBottom(cnr.Y());
  384. }
  387. void PRect::SetDimensions(PDIMENSION dx, PDIMENSION dy)
  388. {
  389.   SetWidth(dx);
  390.   SetHeight(dy);
  391. }
  394. void PRect::SetDimensions(const PDim & dim)
  395. {
  396.   SetWidth(dim.Width());
  397.   SetHeight(dim.Height());
  398. }
  401. #endif
  404. ///////////////////////////////////////////////////////////////////////////////
  405. // PPixels
  407. PPixelImage::PPixelImage(PDIMENSION dx, PDIMENSION dy, BYTE depth)
  408. {
  409.   switch (depth) {
  410.     case 32 :
  411.       operator=(PPixelImage(new PPixels32(dx, dy)));
  412.       break;
  414.     case 24 :
  415.       operator=(PPixelImage(new PPixels24(dx, dy)));
  416.       break;
  418.     case 8 :
  419.       operator=(PPixelImage(new PPixels8(dx, dy)));
  420.       break;
  422.     case 4 :
  423.       operator=(PPixelImage(new PPixels4(dx, dy)));
  424.       break;
  426.     case 2 :
  427.       operator=(PPixelImage(new PPixels2(dx, dy)));
  428.       break;
  430.     case 1 :
  431.       operator=(PPixelImage(new PPixels1(dx, dy)));
  432.       break;
  434.     default:
  435.       PAssertAlways(PUnsupportedFeature);
  436.   }
  437. }
  440. struct P_BITMAPINFOHEADER {
  441.   P_BITMAPINFOHEADER(istream & s)
  442.     { s >> biWidth >> biHeight >> biPlanes >> biBitCount
  443.         >> biCompression >> biSizeImage >> biXPelsPerMeter
  444.         >> biYPelsPerMeter >> biClrUsed >> biClrImportant;
  445.     }
  447.   PUInt32l biWidth;
  448.   PUInt32l biHeight;
  449.   PUInt16l biPlanes;
  450.   PUInt16l biBitCount;
  451.   PUInt32l biCompression;
  452.   PUInt32l biSizeImage;
  453.   PUInt32l biXPelsPerMeter;
  454.   PUInt32l biYPelsPerMeter;
  455.   PUInt32l biClrUsed;
  456.   PUInt32l biClrImportant;
  457. };
  459. struct P_RGBQUAD {
  460.   P_RGBQUAD(istream & s)
  461.     { s >> rgbBlue >> rgbGreen >> rgbRed >> rgbReserved; }
  463.   operator PColour() const { return PColour(rgbRed, rgbGreen, rgbBlue); }
  465.   PUInt8 rgbBlue;
  466.   PUInt8 rgbGreen;
  467.   PUInt8 rgbRed;
  468.   PUInt8 rgbReserved;
  469. };
  471. struct P_BITMAPCOREHEADER {
  472.   P_BITMAPCOREHEADER(istream & s)
  473.     { s >> bcWidth >> bcHeight >> bcPlanes >> bcBitCount; }
  475.   PUInt16l bcWidth;
  476.   PUInt16l bcHeight;
  477.   PUInt16l bcPlanes;
  478.   PUInt16l bcBitCount;
  479. };
  482. struct P_RGBTRIPLE {
  483.   P_RGBTRIPLE(istream & s)
  484.     { s >> rgbtBlue >> rgbtGreen >> rgbtRed; }
  486.   operator PColour() const { return PColour(rgbtRed, rgbtGreen, rgbtBlue); }
  488.   PUInt8 rgbtBlue;
  489.   PUInt8 rgbtGreen;
  490.   PUInt8 rgbtRed;
  491. };
  494. static void ReadBMP(istream & stream, PPixelImage & image)
  495. {
  496.   stream.ignore(12); // Skip rest of BITMAPFILEHEADER structure
  498.   PUInt32l hdrsize;  // Read size of header for bitmap
  499.   stream >> hdrsize;
  501.   PPalette palette;
  502.   DWORD width, height, imageSize;
  503.   WORD bitCount;
  504.   PINDEX colourCount;
  506.   switch ((DWORD)hdrsize) {
  507.     case 40 : {
  508.       P_BITMAPINFOHEADER bmih(stream);
  509.       if (!stream.good())
  510.         return;
  512.       width = bmih.biWidth;
  513.       height = bmih.biHeight;
  514.       bitCount = bmih.biBitCount;
  515.       imageSize = bmih.biSizeImage;
  517.       if (bitCount < 24 && (DWORD)bmih.biClrUsed == 0)
  518.         colourCount = 1 << bitCount;
  519.       else
  520.         colourCount = (PINDEX)(DWORD)bmih.biClrUsed;
  521.       for (PINDEX i = 0; i < colourCount; i++) {
  522.         P_RGBQUAD rgb(stream);
  523.         palette.SetColour(i, rgb);
  524.       }
  525.       break;
  526.     }
  528.     case 12 : {
  529.       P_BITMAPCOREHEADER bmch(stream);
  530.       if (!stream.good())
  531.         return;
  533.       width = (WORD)bmch.bcWidth;
  534.       height = (WORD)bmch.bcHeight;
  535.       bitCount = (WORD)bmch.bcBitCount;
  536.       imageSize = (width*bitCount+31)/32*height*4;
  538.       colourCount = 1 << bitCount;
  539.       for (PINDEX i = 0; i < colourCount; i++) {
  540.         P_RGBTRIPLE rgb(stream);
  541.         palette.SetColour(i, rgb);
  542.       }
  543.       break;
  544.     }
  546.     default :
  547.       return;
  548.   }
  550.   if (!stream.good())
  551.     return;
  553.   if (colourCount == 0) {
  554.     for (PINDEX i = 0; i < 256; i++) {
  555.       PColour col((BYTE)(i&0xe0), (BYTE)((i<<3)&0xe0), (BYTE)(i<<6));
  556.       palette.SetColour(i, col);
  557.     }
  558.   }
  560.   image = PPixelImage((PDIMENSION)width, (PDIMENSION)height, (BYTE)bitCount);
  561.   image->SetPalette(palette);
  563. #if defined(_WINDOWS) && !defined(_WIN32)
  564.   PPixelDataPtr pixPtr = image->GetPixelDataPtr();
  565.   while (imageSize > 0x4000) {
  566.     stream.read(pixPtr, 0x4000);
  567.     imageSize -= 0x4000;
  568.     pixPtr += 0x4000;
  569.   }
  570.   stream.read(pixPtr, (int)imageSize);
  571. #else
  572.   stream.read(image->GetPixelDataPtr(), imageSize);
  573. #endif
  575. }
  578. static int PPM_read_number(istream & stream)
  579. {
  580.   while (isspace(stream.peek()))
  581.     stream.get();
  582.   while (stream.peek() == '#') { // if the line is a comment, then ignore it
  583.     stream.ignore(P_MAX_INDEX, 'n');
  584.     while (isspace(stream.peek()))
  585.       stream.get();
  586.   }
  588.   // Read number 
  589.   int num;
  590.   stream >> num;
  591.   return num;
  592. }
  595. #if 0
  596. void PPixelImage::ReadPPM(istream & stream, BYTE format)
  597. {
  598.   // get the width and height
  599.   PDIMENSION width  = PPM_read_number(stream);
  600.   PDIMENSION height = PPM_read_number(stream);
  602.   PPalette palette;
  603.   BYTE bitCount;
  605.   // for each image type, we have to set depth and pixelData
  606.   int black, white, max_value;
  607.   switch (format) {
  608.     case '1':
  609.     case '4':
  610.       bitCount = 1;
  611.       max_value = -1;
  612.       black = palette.AddColour(PColour::Black);
  613.       white = palette.AddColour(PColour::White);
  614.       break;
  616.     case '2':
  617.     case '5':
  618.       bitCount = 8;
  619.       max_value = PPM_read_number(stream);
  620.       for (int i = 0; i < 128; i++)
  621.         palette.AddColour(PColour(i*2, i*2, i*2));
  622.       break;
  624.     case '3':
  625.     case '6':
  626.       bitCount = 24;
  627.       max_value = PPM_read_number(stream);
  628.       break;
  629.   }
  631.   PPixelImage pix(width, height, bitCount);
  633.   // calculate the shift for max_value
  634.   int shift;
  635.   if (max_value > 0) {
  636.     shift = 0;
  637.     while ((max_value << (shift+1)) < 255)
  638.       shift++;
  639.   }
  641.   // remove single whitespace after header if in raw format
  642.   if (format == '2' || format == '4' || format == '6')
  643.     stream.ignore();
  645.   int x, y;
  647.   // declare a line buffer when needed
  648.   PBYTEArray line(width * 3);
  649.   BYTE * linePtr = line.GetPointer();
  651.   switch (format) {
  652.     // PBM ASCII 
  653.     case '1':
  654.       for (y = 0; y < height; y++) {
  655.         for (x = 0; x < width; x++)
  656.           line[x] = PPM_read_number(stream);
  657.         operator->()->SetRaster(y, line, width);
  658.       }
  659.       break;
  661.     // PGM ASCII
  662.     case '2':
  663.       for (y = 0; y < height; y++) {
  664.         for (x = 0; x < width; x++)
  665.           line[x] = PPM_read_number(stream);
  666.         operator->()->SetRaster(y, line, width);
  667.       }
  668.       break;
  670.     // PPM ASCII
  671.     case '3':
  672.       for (y = 0; y < height; y++) {
  673.         for (x = 0; x < width*3; x++)
  674.           line[x] = PPM_read_number(stream);
  675.         operator->()->SetRaster(y, line, width);
  676.       }
  677.       break;
  679.     // PBM binary
  680.     case '4':
  681.       break;
  683.     // PGM binary
  684.     case '5':
  685.       break;
  687.     // PPM binary
  688.     case '6':
  689.       for (y = 0; y < height; y++) {
  690.         if (shift == 0)
  691.           file.Read (operator->()->GetRasterDataPtr(y), width*3);
  692.         else {
  693.           file.Read (linePtr, width*3);
  694.           BYTE * ptr = linePtr;
  695.           BYTE * optr = operator->()->GetRasterDataPtr(y);
  696.           for (PINDEX x = width; x > 0; x--)
  697.             *optr++ = *ptr++ << shift;
  698.         }
  699.       }
  700.       break;
  701.   }
  702. }
  703. #endif
  706. static void ReadPBMa(istream & stream, PPixelImage & image)
  707. {
  708.   PDIMENSION width  = PPM_read_number(stream);
  709.   PDIMENSION height = PPM_read_number(stream);
  711.   image = PPixelImage(width, height, 1);
  713.   PPalette pal;
  714.   pal.AddColour(PColour::Black);
  715.   pal.AddColour(PColour::White);
  716.   image->SetPalette(pal);
  718.   for (PDIMENSION y = 0; y < height; y++)
  719.     for (PDIMENSION x = 0; x < width; x++)
  720.       image->SetPixel(x, y, (BYTE)PPM_read_number(stream));
  721. }
  724. static void ReadPBMb(istream & stream, PPixelImage & image)
  725. {
  726.   PDIMENSION width  = PPM_read_number(stream);
  727.   PDIMENSION height = PPM_read_number(stream);
  729.   image = PPixelImage(width, height, 1);
  731.   PPalette pal;
  732.   pal.AddColour(PColour::Black);
  733.   pal.AddColour(PColour::White);
  734.   image->SetPalette(pal);
  736.   stream.ignore();  // Skip blank before binary data
  738.   for (PDIMENSION y = 0; y < height; y++) 
  739.     stream.read(image->GetRasterDataPtr(y), width);
  740. }
  743. static void ReadPGMa(istream & stream, PPixelImage & image)
  744. {
  745.   PDIMENSION width  = PPM_read_number(stream);
  746.   PDIMENSION height = PPM_read_number(stream);
  747.   /*int max_value =*/ PPM_read_number(stream);
  749.   image = PPixelImage(width, height, 8);
  751.   PPalette pal;
  752.   for (BYTE i = 0; i < 256; i += 2)
  753.     pal.AddColour(PColour(i, i, i));
  754.   image->SetPalette(pal);
  756.   for (PDIMENSION y = 0; y < height; y++)
  757.     for (PDIMENSION x = 0; x < width; x++)
  758.       image->SetPixel(x, y, (BYTE)PPM_read_number(stream));
  759. }
  762. static void ReadPGMb(istream & stream, PPixelImage & image)
  763. {
  764.   PDIMENSION width  = PPM_read_number(stream);
  765.   PDIMENSION height = PPM_read_number(stream);
  766.   int max_value = PPM_read_number(stream);
  768.   // calculate the shift for max_value
  769.   int shift = 0;
  770.   if (max_value > 0) {
  771.     while ((max_value << (shift+1)) < 255)
  772.       shift++;
  773.   }
  775.   image = PPixelImage(width, height, 8);
  777.   PPalette pal;
  778.   for (BYTE i = 0; i < 256; i += 2)
  779.     pal.AddColour(PColour(i, i, i));
  780.   image->SetPalette(pal);
  782.   stream.ignore();  // Skip blank before binary data
  784.   for (PDIMENSION y = 0; y < height; y++) {
  785.     BYTE * line = image->GetRasterDataPtr(y);
  786.     stream.read(line, width*3);
  787.     if (shift != 0) {
  788.       for (PINDEX x = width; x > 0; x--)
  789.         *line++ <<= shift;
  790.     }
  791.   }
  792. }
  795. static void ReadPPMa(istream & stream, PPixelImage & image)
  796. {
  797.   PDIMENSION width  = PPM_read_number(stream);
  798.   PDIMENSION height = PPM_read_number(stream);
  799.   /*int max_value =*/ PPM_read_number(stream);
  801.   image = PPixelImage(width, height, 24);
  803.   for (PDIMENSION y = 0; y < height; y++) {
  804.     BYTE * line = image->GetRasterDataPtr(y);
  805.     for (PDIMENSION x = 0; x < width*3; x++)
  806.       *line++ = (BYTE)PPM_read_number(stream);
  807.   }
  808. }
  811. static void ReadPPMb(istream & stream, PPixelImage & image)
  812. {
  813.   PDIMENSION width  = PPM_read_number(stream);
  814.   PDIMENSION height = PPM_read_number(stream);
  815.   int max_value = PPM_read_number(stream);
  817.   // calculate the shift for max_value
  818.   int shift = 0;
  819.   if (max_value > 0) {
  820.     while ((max_value << (shift+1)) < 255)
  821.       shift++;
  822.   }
  824.   image = PPixelImage(width, height, 24);
  826.   stream.ignore();  // Skip blank before binary data
  828.   for (PDIMENSION y = 0; y < height; y++) {
  829.     BYTE * line = image->GetRasterDataPtr(y);
  830.     stream.read(line, width*3);
  831.     if (shift != 0) {
  832.       for (PDIMENSION x = width; x > 0; x--)
  833.         *line++ <<= shift;
  834.     }
  835.   }
  836. }
  839. PPixelImage::PPixelImage(istream & stream)
  840. {
  841.   // read the magic number 
  842.   char magic[2];
  843.   stream.read(magic, 2);
  844.   if (!stream.good())
  845.     return;
  847.   // determine the format 
  848.   if (magic[0] == 'B' && magic[1] == 'M')
  849.     ReadBMP(stream, *this);
  850.   else if (magic[0] == 'P')
  851.     switch (magic[1]) {
  852.       case '1': // PBM ASCII 
  853.         ReadPBMa(stream, *this);
  854.         break;
  855.       case '2': // PGM ASCII
  856.         ReadPGMa(stream, *this);
  857.         break;
  858.       case '3': // PPM ASCII
  859.         ReadPPMa(stream, *this);
  860.         break;
  861.       case '4': // PBM binary
  862.         ReadPBMb(stream, *this);
  863.         break;
  864.       case '5': // PGM binary
  865.         ReadPGMb(stream, *this);
  866.         break;
  867.       case '6': // PPM binary
  868.         ReadPPMb(stream, *this);
  869.     }
  870. }
  873. void PPixelBase::SetDirtyArea(PORDINATE x, PORDINATE y, PDIMENSION width)
  874. {
  875.   PAssert(x >= 0 && (PDIMENSION)x < Width(), "Pixel out of bounds");
  877.   if (x < dirtyArea.Left())
  878.     dirtyArea.SetLeft(x);
  880.   if (x+(PORDINATE)width > dirtyArea.Right())
  881.     dirtyArea.SetRight(x+width);
  883.   if (y < dirtyArea.Top())
  884.     dirtyArea.SetTop(y);
  886.   if (y > dirtyArea.Bottom())
  887.     dirtyArea.SetBottom(y);
  888. }
  891. void PPixelBase::SetPixelColour(PORDINATE x,PORDINATE y,const PColour & colour)
  892. {
  893.   SetPixel(x, y, (BYTE)palette.GetIndex(colour));
  894. }
  897. void PPixels24::SetPixelColour(PORDINATE x,PORDINATE y,const PColour & colour)
  898. {
  899.   SetDirtyArea(x, y);
  900.   PPixelDataPtr pixel = GetRasterDataPtr(y) + x*3;
  901.   *pixel++ = colour.GetRed();
  902.   *pixel++ = colour.GetGreen();
  903.   *pixel   = colour.GetBlue();
  904. }
  907. void PPixels32::SetPixelColour(PORDINATE x,PORDINATE y,const PColour & colour)
  908. {
  909.   SetDirtyArea(x, y);
  910.   PPixelDataPtr pixel = GetRasterDataPtr(y) + x*4;
  911.   *pixel++ = colour.GetRed();
  912.   *pixel++ = colour.GetGreen();
  913.   *pixel++ = colour.GetBlue();
  914.   *pixel   = colour.GetAlpha();
  915. }
  918. void PPixels1::SetPixel(PORDINATE x, PORDINATE y, BYTE val)
  919. {
  920.   SetDirtyArea(x, y);
  921.   PPixelDataPtr pixel = GetRasterDataPtr(y) + (x >> 3);
  922.   x &= 7;
  923.   *pixel = (BYTE)((*pixel & ~(1 << x)) | (val << x));
  924. }
  927. void PPixels2::SetPixel(PORDINATE x, PORDINATE y, BYTE val)
  928. {
  929.   SetDirtyArea(x, y);
  930.   PPixelDataPtr pixel = GetRasterDataPtr(y) + (x >> 2);
  931.   x &= 3;
  932.   *pixel = (BYTE)((*pixel & ~(3 << x)) | (val << (x << 1)));
  933. }
  936. void PPixels4::SetPixel(PORDINATE x, PORDINATE y, BYTE val)
  937. {
  938.   SetDirtyArea(x, y);
  939.   PPixelDataPtr pixel = GetRasterDataPtr(y) + (x >> 1);
  940.   x &= 1;
  941.   *pixel = (BYTE)((*pixel & ~(0xf << x)) | (val << (x << 2)));
  942. }
  945. void PPixels8::SetPixel(PORDINATE x, PORDINATE y, BYTE val)
  946. {
  947.   SetDirtyArea(x, y);
  948.   PPixelDataPtr pixel = GetRasterDataPtr(y) + x;
  949.   *pixel = val;
  950. }
  953. void PPixels24::SetPixel(PORDINATE x, PORDINATE y, BYTE val)
  954. {
  955.   SetDirtyArea(x, y);
  956.   PPixelDataPtr pixel = GetRasterDataPtr(y) + x*3;
  957.   *pixel++ = val;
  958.   *pixel++ = val;
  959.   *pixel   = val;
  960. }
  963. void PPixels32::SetPixel(PORDINATE x, PORDINATE y, BYTE val)
  964. {
  965.   SetDirtyArea(x, y);
  966.   PPixelDataPtr pixel = GetRasterDataPtr(y) + x*4;
  967.   *pixel++ = val;
  968.   *pixel++ = val;
  969.   *pixel++ = val;
  970.   *pixel   = 0;
  971. }
  974. PColour PPixelBase::GetPixelColour(PORDINATE x, PORDINATE y) const
  975. {
  976.   return palette.GetColour(GetPixel(x, y));
  977. }
  980. PColour PPixels24::GetPixelColour(PORDINATE x, PORDINATE y) const
  981. {
  982.   PAssert(x >= 0 && (PDIMENSION)x < Width(), "Pixel out of bounds");
  983.   PPixelDataPtr pixel = GetRasterDataPtr(y) + x*3;
  984.   return PColour(pixel[0], pixel[1], pixel[2]);
  985. }
  988. PColour PPixels32::GetPixelColour(PORDINATE x, PORDINATE y) const
  989. {
  990.   PAssert(x >= 0 && (PDIMENSION)x < Width(), "Pixel out of bounds");
  991.   PPixelDataPtr pixel = GetRasterDataPtr(y) + x*4;
  992.   return PColour(pixel[0], pixel[1], pixel[2], pixel[3]);
  993. }
  996. BYTE PPixels1::GetPixel(PORDINATE x, PORDINATE y) const
  997. {
  998.   PAssert(x >= 0 && (PDIMENSION)x < Width(), "Pixel out of bounds");
  999.   PPixelDataPtr pixel = GetRasterDataPtr(y) + (x >> 3);
  1000.   return (BYTE)((*pixel >> (x&7))&1);
  1001. }
  1004. BYTE PPixels2::GetPixel(PORDINATE x, PORDINATE y) const
  1005. {
  1006.   PAssert(x >= 0 && (PDIMENSION)x < Width(), "Pixel out of bounds");
  1007.   PPixelDataPtr pixel = GetRasterDataPtr(y) + (x >> 2);
  1008.   return (BYTE)((*pixel >> ((x&3) << 1))&3);
  1009. }
  1012. BYTE PPixels4::GetPixel(PORDINATE x, PORDINATE y) const
  1013. {
  1014.   PAssert(x >= 0 && (PDIMENSION)x < Width(), "Pixel out of bounds");
  1015.   PPixelDataPtr pixel = GetRasterDataPtr(y) + (x >> 1);
  1016.   return (BYTE)((*pixel >> ((x&1) << 2))&0xf);
  1017. }
  1020. BYTE PPixels8::GetPixel(PORDINATE x, PORDINATE y) const
  1021. {
  1022.   PAssert(x >= 0 && (PDIMENSION)x < Width(), "Pixel out of bounds");
  1023.   PPixelDataPtr pixel = GetRasterDataPtr(y) + x;
  1024.   return *pixel;
  1025. }
  1028. BYTE PPixels24::GetPixel(PORDINATE x, PORDINATE y) const
  1029. {
  1030.   PAssert(x >= 0 && (PDIMENSION)x < Width(), "Pixel out of bounds");
  1031.   PPixelDataPtr pixel = GetRasterDataPtr(y) + x*3;
  1032.   return (BYTE)((pixel[0]*30 + pixel[1]*59 + pixel[2]*11)/100);
  1033. }
  1036. BYTE PPixels32::GetPixel(PORDINATE x, PORDINATE y) const
  1037. {
  1038.   PAssert(x >= 0 && (PDIMENSION)x < Width(), "Pixel out of bounds");
  1039.   PPixelDataPtr pixel = GetRasterDataPtr(y) + x*4;
  1040.   return (BYTE)((pixel[0]*30 + pixel[1]*59 + pixel[2]*11)/100);
  1041. }
  1044. PPixelDataPtr PPixelBase::CalculateRaster(PORDINATE x, PORDINATE y,
  1045.                                                      PDIMENSION & lastX) const
  1046. {
  1047.   PAssert(x >= 0 && (PDIMENSION)x < Width(), "Pixel out of bounds");
  1048.   lastX += (PDIMENSION)x;
  1049.   if (lastX > Width())
  1050.     lastX = Width();
  1051.   return GetRasterDataPtr(y) + x*GetDepth()/8;
  1052. }
  1055. void PPixelBase::SetRaster(PORDINATE x, PORDINATE y,
  1056.                                   const PBYTEArray & raster, PDIMENSION width)
  1057. {
  1058.   if (width > (PDIMENSION)raster.GetSize())
  1059.     width = (PDIMENSION)raster.GetSize();
  1060.   SetRasterValues(x, y, raster, width);
  1061. }
  1062.   
  1064. void PPixelBase::GetRaster(PORDINATE x, PORDINATE y,
  1065.                                   PBYTEArray & raster, PDIMENSION width) const
  1066. {
  1067.   if (width > Width())
  1068.     width = Width();
  1069.   GetRasterValues(x, y, raster.GetPointer(width), width);
  1070. }
  1071.   
  1073. void PPixelBase::SetRasterColours(PORDINATE x, PORDINATE y,
  1074.                                 const PColourArray & raster, PDIMENSION width)
  1075. {
  1076.   if (width > (PDIMENSION)raster.GetSize())
  1077.     width = (PDIMENSION)raster.GetSize();
  1078.   while ((PDIMENSION)x < width) {
  1079.     SetPixel(x, y, (BYTE)palette.GetIndex(raster[x]));
  1080.     x++;
  1081.   }
  1082. }
  1085. void PPixels24::SetRasterColours(PORDINATE x, PORDINATE y,
  1086.                                 const PColourArray & raster, PDIMENSION width)
  1087. {
  1088.   if (width > (PDIMENSION)raster.GetSize())
  1089.     width = (PDIMENSION)raster.GetSize();
  1090.   PPixelDataPtr pixel = CalculateRaster(x, y, width);
  1091.   SetDirtyArea(x, y, width);
  1092.   while ((PDIMENSION)x < width) {
  1093.     *pixel++ = raster[x].GetRed();
  1094.     *pixel++ = raster[x].GetGreen();
  1095.     *pixel++ = raster[x++].GetBlue();
  1096.   }
  1097. }
  1100. void PPixels32::SetRasterColours(PORDINATE x, PORDINATE y,
  1101.                                 const PColourArray & raster, PDIMENSION width)
  1102. {
  1103.   if (width > (PDIMENSION)raster.GetSize())
  1104.     width = (PDIMENSION)raster.GetSize();
  1105.   PPixelDataPtr pixel = CalculateRaster(x, y, width);
  1106.   SetDirtyArea(x, y, width);
  1107.   while ((PDIMENSION)x < width) {
  1108.     *pixel++ = raster[x].GetRed();
  1109.     *pixel++ = raster[x].GetGreen();
  1110.     *pixel++ = raster[x].GetBlue();
  1111.     *pixel++ = raster[x++].GetAlpha();
  1112.   }
  1113. }
  1116. void PPixels1::SetRasterValues(PORDINATE x, PORDINATE y,
  1117.                                         const BYTE * raster, PDIMENSION width)
  1118. {
  1119.   PPixelDataPtr pixel = CalculateRaster(x, y, width);
  1120.   BYTE mask = (BYTE)(0x80 >> (x&7));
  1121.   *pixel = 0;
  1122.   while ((PDIMENSION)x < width) {
  1123.     if (*raster++ != 0)
  1124.       *pixel |= mask;
  1125.     mask >>= 1;
  1126.     if (mask == 0) {
  1127.       *++pixel = 0;
  1128.       mask = 0x80;
  1129.     }
  1130.     x++;
  1131.   }
  1132. }
  1135. void PPixels2::SetRasterValues(PORDINATE x, PORDINATE y,
  1136.                                         const BYTE * raster, PDIMENSION width)
  1137. {
  1138.   PPixelDataPtr pixel = CalculateRaster(x, y, width);
  1139.   SetDirtyArea(x, y, width);
  1140.   while ((PDIMENSION)(x += 4) <= width) {
  1141.     *pixel++ = (BYTE)((raster[0] << 6)|(raster[1] << 4)|
  1142.                       (raster[2] << 2)| raster[3]);
  1143.     raster += 4;
  1144.   }
  1145.   switch (x&3) {
  1146.     case 1 :
  1147.       *pixel = (BYTE)((raster[0] << 6)|(raster[1] << 4)|
  1148.                         (raster[2] << 2));
  1149.       break;
  1150.     case 2 :
  1151.       *pixel = (BYTE)((raster[0] << 6)|(raster[1] << 4));
  1152.       break;
  1153.     case 3 :
  1154.       *pixel = (BYTE)(raster[0] << 6);
  1155.       break;
  1156.   }
  1157. }
  1160. void PPixels4::SetRasterValues(PORDINATE x, PORDINATE y,
  1161.                                         const BYTE * raster, PDIMENSION width)
  1162. {
  1163.   PPixelDataPtr pixel = CalculateRaster(x, y, width);
  1164.   SetDirtyArea(x, y, width);
  1165.   while ((PDIMENSION)(x += 2) <= width) {
  1166.     *pixel++ = (BYTE)((raster[0] << 4)|raster[1]);
  1167.     raster += 2;
  1168.   }
  1169.   if ((x&1) != 0)
  1170.     *pixel = (BYTE)(*raster << 4);
  1171. }
  1174. void PPixels8::SetRasterValues(PORDINATE x, PORDINATE y,
  1175.                                         const BYTE * raster, PDIMENSION width)
  1176. {
  1177.   PPixelDataPtr pixel = CalculateRaster(x, y, width);
  1178.   SetDirtyArea(x, y, width);
  1179.   memcpy(pixel, raster, width);
  1180. }
  1183. void PPixels24::SetRasterValues(PORDINATE x, PORDINATE y,
  1184.                                         const BYTE * raster, PDIMENSION width)
  1185. {
  1186.   PPixelDataPtr pixel = CalculateRaster(x, y, width);
  1187.   SetDirtyArea(x, y, width);
  1188.   while ((PDIMENSION)x < width) {
  1189.     *pixel++ = *raster;
  1190.     *pixel++ = *raster;
  1191.     *pixel++ = *raster;
  1192.     raster++;
  1193.     x++;
  1194.   }
  1195. }
  1198. void PPixels32::SetRasterValues(PORDINATE x, PORDINATE y,
  1199.                                         const BYTE * raster, PDIMENSION width)
  1200. {
  1201.   PPixelDataPtr pixel = CalculateRaster(x, y, width);
  1202.   SetDirtyArea(x, y, width);
  1203.   while ((PDIMENSION)x < width) {
  1204.     *pixel++ = *raster;
  1205.     *pixel++ = *raster;
  1206.     *pixel++ = *raster;
  1207.     *pixel++ = 0;
  1208.     raster++;
  1209.     x++;
  1210.   }
  1211. }
  1214. void PPixelBase::GetRasterColours(PORDINATE x, PORDINATE y,
  1215.                                 PColourArray & raster, PDIMENSION width) const
  1216. {
  1217.   CalculateRaster(x, y, width);
  1218.   raster.SetMinSize(width);
  1219.   while ((PDIMENSION)x < width) {
  1220.     raster[x] = palette.GetColour(GetPixel(x, y));
  1221.     x++;
  1222.   }
  1223. }
  1226. void PPixels24::GetRasterColours(PORDINATE x, PORDINATE y,
  1227.                                 PColourArray & raster, PDIMENSION width) const
  1228. {
  1229.   PPixelDataPtr pixel = CalculateRaster(x, y, width);
  1230.   raster.SetMinSize(width);
  1231.   while ((PDIMENSION)x < width) {
  1232.     raster[x++] = PColour(pixel[0], pixel[1], pixel[2]);
  1233.     pixel += 3;
  1234.   }
  1235. }
  1238. void PPixels32::GetRasterColours(PORDINATE x, PORDINATE y,
  1239.                                 PColourArray & raster, PDIMENSION width) const
  1240. {
  1241.   PPixelDataPtr pixel = CalculateRaster(x, y, width);
  1242.   raster.SetMinSize(width);
  1243.   while ((PDIMENSION)x < width) {
  1244.     raster[x++] = PColour(pixel[0], pixel[1], pixel[2], pixel[3]);
  1245.     pixel += 4;
  1246.   }
  1247. }
  1250. void PPixels1::GetRasterValues(PORDINATE x, PORDINATE y,
  1251.                                         BYTE * raster, PDIMENSION width) const
  1252. {
  1253.   PPixelDataPtr pixel = CalculateRaster(x, y, width);
  1254.   int mask = 0x80 >> (x&7);
  1255.   *pixel = 0;
  1256.   while ((PDIMENSION)x < width) {
  1257.     *raster++ = (BYTE)((*pixel & mask) != 0);
  1258.     mask >>= 1;
  1259.     if (mask == 0) {
  1260.       *++pixel = 0;
  1261.       mask = 0x80;
  1262.     }
  1263.     x++;
  1264.   }
  1265. }
  1268. void PPixels2::GetRasterValues(PORDINATE x, PORDINATE y,
  1269.                                         BYTE * raster, PDIMENSION width) const
  1270. {
  1271.   PPixelDataPtr pixel = CalculateRaster(x, y, width);
  1272.   while ((PDIMENSION)x < width) {
  1273.     *raster++ = (BYTE)(*pixel >> 6);
  1274.     if ((PDIMENSION)++x < width) {
  1275.       *raster++ = (BYTE)((*pixel >> 4)&3);
  1276.       if ((PDIMENSION)++x < width) {
  1277.         *raster++ = (BYTE)((*pixel >> 2)&3);
  1278.         if ((PDIMENSION)++x < width)
  1279.           *raster++ = (BYTE)(*pixel&3);
  1280.       }
  1281.     }
  1282.     pixel++;
  1283.   }
  1284. }
  1287. void PPixels4::GetRasterValues(PORDINATE x, PORDINATE y,
  1288.                                         BYTE * raster, PDIMENSION width) const
  1289. {
  1290.   PPixelDataPtr pixel = CalculateRaster(x, y, width);
  1291.   while ((PDIMENSION)x < width) {
  1292.     *raster++ = (BYTE)(*pixel >> 4);
  1293.     if ((PDIMENSION)++x < width)
  1294.       *raster++ = (BYTE)(*pixel&0xf);
  1295.     pixel++;
  1296.   }
  1297. }
  1300. void PPixels8::GetRasterValues(PORDINATE x, PORDINATE y,
  1301.                                         BYTE * raster, PDIMENSION width) const
  1302. {
  1303.   PPixelDataPtr pixel = CalculateRaster(x, y, width);
  1304.   memcpy(raster, pixel, width);
  1305. }
  1308. void PPixels24::GetRasterValues(PORDINATE x, PORDINATE y,
  1309.                                         BYTE * raster, PDIMENSION width) const
  1310. {
  1311.   PPixelDataPtr pixel = CalculateRaster(x, y, width);
  1312.   while ((PDIMENSION)x < width) {
  1313.     *raster++ = (BYTE)((pixel[0]*30 + pixel[1]*59 + pixel[2]*11)/100);
  1314.     pixel += 3;
  1315.     x++;
  1316.   }
  1317. }
  1320. void PPixels32::GetRasterValues(PORDINATE x, PORDINATE y,
  1321.                                         BYTE * raster, PDIMENSION width) const
  1322. {
  1323.   PPixelDataPtr pixel = CalculateRaster(x, y, width);
  1324.   while ((PDIMENSION)x < width) {
  1325.     *raster++ = (BYTE)((pixel[0]*30 + pixel[1]*59 + pixel[2]*11)/100);
  1326.     pixel += 4;
  1327.     x++;
  1328.   }
  1329. }
  1332. PPixelImage PPixelBase::ExtractPixels(PORDINATE x, PORDINATE y,
  1333.                                    PDIMENSION width, PDIMENSION height) const
  1334. {
  1335.   PAssert(x >= 0 && (PDIMENSION)x < Width() &&
  1336.           y >= 0 && (PDIMENSION)y < Height(), "Pixel out of bounds");
  1337.   if (width > Width() - x)
  1338.     width = Width() - x;
  1339.   if (height > Height() - y)
  1340.     height = Height() - y;
  1342.   PPixelImage pix(width, height, GetDepth());
  1344.   if (GetDepth() >= 8 || x%(8/GetDepth()) == 0) {
  1345.     for (PDIMENSION py = 0; py < height; py++)
  1346.       memcpy(pix->GetRasterDataPtr(py),
  1347.                  GetRasterDataPtr(y++) + x*GetDepth()/8, pix->pixelLineBytes);
  1348.   }
  1349.   else {
  1350.     PBYTEArray raster(width);
  1351.     for (PDIMENSION py = 0; py < height; py++) {
  1352.       GetRaster(x, y++, raster, width);
  1353.       pix->SetRaster(py, raster, width);
  1354.     }
  1355.   }
  1356.   return pix;
  1357. }
  1360. //////////////////////////////////////////////////////////////////////////////
  1361. // PCanvasState
  1363. #if defined(_PCANVASSTATE)
  1365. PCanvasState::PCanvasState()
  1366.   : penStyle(PCanvas::Solid),
  1367.     penWidth(0),
  1368.     penMode(PCanvas::SrcCopy),
  1369.     penFgColour(PColour::Black),
  1370.     penBkColour(PColour::White),
  1371.     fillFgColour(PColour::Clear),
  1372.     fillBkColour(PColour::Clear),
  1373.     fillMode(PCanvas::SrcCopy),
  1374.     font("System", 10),
  1375.     textFgColour(PColour::Black),
  1376.     textBkColour(PColour::White),
  1377.     palette(),
  1378.     polyFillMode(PCanvas::Winding),
  1379.     viewport(0, 0, 100, 100), 
  1380.     map(0, 0, 100, 100)
  1381. {
  1382. }
  1385. PCanvasState::PCanvasState(const PCanvasState & s)
  1386.   : penStyle(s.penStyle),
  1387.     penWidth(s.penWidth),
  1388.     penMode(s.penMode),
  1389.     penFgColour(s.penFgColour),
  1390.     penBkColour(s.penBkColour),
  1391.     fillFgColour(s.fillFgColour),
  1392.     fillBkColour(s.fillBkColour),
  1393.     fillPattern(s.fillPattern),
  1394.     fillMode(s.fillMode),
  1395.     font(s.font),
  1396.     textFgColour(s.textFgColour),
  1397.     textBkColour(s.textBkColour),
  1398.     palette(s.palette),
  1399.     polyFillMode(s.polyFillMode),
  1400.     viewport(s.viewport), 
  1401.     map(s.map)
  1402. {
  1403. }
  1406. BOOL PCanvasState::SetPenStyle(PenStyles style)
  1407. {
  1408.   if (penStyle == style)
  1409.     return FALSE;
  1410.   penStyle = style;
  1411.   return TRUE;
  1412. }
  1415. BOOL PCanvasState::SetPenWidth(int width)
  1416. {
  1417.   if (penWidth == width)
  1418.     return FALSE;
  1419.   penWidth = width;
  1420.   return TRUE;
  1421. }
  1424. BOOL PCanvasState::SetPenMode(DrawingModes mode)
  1425. {
  1426.   if (penMode == mode)
  1427.     return FALSE;
  1428.   penMode = mode;
  1429.   return TRUE;
  1430. }
  1433. BOOL PCanvasState::SetPenFgColour(const PColour & colour)
  1434. {
  1435.   if (colour == penFgColour)
  1436.     return FALSE;
  1437.   penFgColour = colour;
  1438.   return TRUE;
  1439. }
  1442. BOOL PCanvasState::SetPenBkColour(const PColour & colour)
  1443. {
  1444.   if (colour == penBkColour)
  1445.     return FALSE;
  1446.   penBkColour = colour;
  1447.   return TRUE;
  1448. }
  1451. BOOL PCanvasState::SetFillPattern(const PPattern & pattern)
  1452. {
  1453.   if (fillPattern == pattern)
  1454.     return FALSE;
  1455.   fillPattern = pattern;
  1456.   return TRUE;
  1457. }
  1460. BOOL PCanvasState::SetPatternOrigin(const PPoint & pt)
  1461. {
  1462.   if (patternOrigin == pt)
  1463.     return FALSE;
  1464.   patternOrigin = pt;
  1465.   return TRUE;
  1466. }
  1469. BOOL PCanvasState::SetFillMode(DrawingModes mode)
  1470. {
  1471.   if (fillMode == mode)
  1472.     return FALSE;
  1473.   fillMode = mode;
  1474.   return TRUE;
  1475. }
  1478. BOOL PCanvasState::SetFillFgColour(const PColour & colour)
  1479. {
  1480.   if (colour == fillFgColour)
  1481.     return FALSE;
  1482.   fillFgColour = colour;
  1483.   return TRUE;
  1484. }
  1487. BOOL PCanvasState::SetFillBkColour(const PColour & colour)
  1488. {
  1489.   if (colour == fillBkColour)
  1490.     return FALSE;
  1491.   fillBkColour = colour;
  1492.   return TRUE;
  1493. }
  1496. BOOL PCanvasState::SetFont(const PFont & newFont)
  1497. {
  1498.   if (font == newFont)
  1499.     return FALSE;
  1500.   font = newFont;
  1501.   return TRUE;
  1502. }
  1505. BOOL PCanvasState::SetTextFgColour(const PColour & colour)
  1506. {
  1507.   if (colour == textFgColour)
  1508.     return FALSE;
  1509.   textFgColour = colour;
  1510.   return TRUE;
  1511. }
  1514. BOOL PCanvasState::SetTextBkColour(const PColour & colour)
  1515. {
  1516.   if (colour == textBkColour)
  1517.     return FALSE;
  1518.   textBkColour = colour;
  1519.   return TRUE;
  1520. }
  1523. BOOL PCanvasState::SetPalette(const PPalette & newPal)
  1524. {
  1525.   if (palette == newPal)
  1526.     return FALSE;
  1527.   palette = newPal;
  1528.   return TRUE;
  1529. }
  1532. BOOL PCanvasState::SetPolyFillMode(PolyFillMode newMode)
  1533. {
  1534.   if (polyFillMode == newMode)
  1535.     return FALSE;
  1536.   polyFillMode = newMode;
  1537.   return TRUE;
  1538. }
  1541. BOOL PCanvasState::SetViewportRect(const PRect & rect)
  1542. {
  1543.   if (viewport == rect)
  1544.     return FALSE;
  1545.   viewport = rect;
  1546.   return TRUE;
  1547. }
  1550. BOOL PCanvasState::SetMappingRect(const PRect & rect)
  1551. {
  1552.   if (map == rect)
  1553.     return FALSE;
  1554.   map = rect;
  1555.   return TRUE;
  1556. }
  1559. void PCanvasState::SetOrigin(const PPoint & pt)
  1560. {
  1561.   PRect newMap = map;
  1562.   newMap.SetOrigin(pt);
  1563.   SetMappingRect(newMap);
  1564. }
  1567. #endif
  1570. //////////////////////////////////////////////////////////////////////////////
  1571. // PCanvas
  1573. #if defined(_PCANVAS)
  1575. inline static long CalculateScaledValue(long value,
  1576.                                         int innerOffset, int innerWidth,
  1577.                                         int outerOffset, int outerWidth)
  1578. {
  1579.   long tmp = (1000L*(value-innerOffset)*outerWidth)/innerWidth;
  1580.   if (tmp < 0)
  1581.     tmp -= 500;
  1582.   else
  1583.     tmp += 500;
  1584.   return tmp/1000L + outerOffset;
  1585. }
  1587. PDIMENSION PCanvas::FromPixelsDX(PDIMENSION dx) const
  1588. {
  1589.   return (PDIMENSION)CalculateScaledValue(dx,
  1590.                                           0, viewport.Width(), 0, map.Width());
  1591. }
  1593. PDIMENSION PCanvas::FromPixelsDY(PDIMENSION dy) const
  1594. {
  1595.   return (PDIMENSION)CalculateScaledValue(dy,
  1596.                                         0, viewport.Height(), 0, map.Height());
  1597. }
  1599. PORDINATE PCanvas::FromPixelsX(PORDINATE x) const
  1600. {
  1601.   return (PORDINATE)CalculateScaledValue(x,
  1602.                          viewport.X(), viewport.Width(), map.X(), map.Width());
  1603. }
  1605. PORDINATE PCanvas::FromPixelsY(PORDINATE y) const
  1606. {
  1607.   return (PORDINATE)CalculateScaledValue(y,
  1608.                        viewport.Y(), viewport.Height(), map.Y(), map.Height());
  1609. }
  1611. PDIMENSION PCanvas::ToPixelsDX(PDIMENSION dx) const
  1612. {
  1613.   return (PDIMENSION)CalculateScaledValue(dx,
  1614.                                           0, map.Width(), 0, viewport.Width());
  1615. }
  1617. PDIMENSION PCanvas::ToPixelsDY(PDIMENSION dy) const
  1618. {
  1619.   return (PDIMENSION)CalculateScaledValue(dy,
  1620.                                         0, map.Height(), 0, viewport.Height());
  1621. }
  1623. PORDINATE PCanvas::ToPixelsX(PORDINATE x) const
  1624. {
  1625.   return (PORDINATE)CalculateScaledValue(x,
  1626.                          map.X(), map.Width(), viewport.X(), viewport.Width());
  1627. }
  1629. PORDINATE PCanvas::ToPixelsY(PORDINATE y) const
  1630. {
  1631.   return (PORDINATE)CalculateScaledValue(y,
  1632.                        map.Y(), map.Height(), viewport.Y(), viewport.Height());
  1633. }
  1635. PDIMENSION PCanvas::ToPointsX(PDIMENSION x)
  1636. {
  1637.   long tmp1 = 7200L*x*viewport.Width();
  1638.   long tmp2 = map.Width()*deviceResX*100L;
  1639.   if (tmp1 < 0)
  1640.     tmp1 -= tmp2/2;
  1641.   else
  1642.     tmp1 += tmp2/2;
  1643.   return (PDIMENSION)(tmp1/tmp2);
  1644. }
  1646.   
  1647. PDIMENSION PCanvas::ToPointsY(PDIMENSION y)
  1648. {
  1649.   long tmp1 = 7200L*y*viewport.Height();
  1650.   long tmp2 = map.Height()*deviceResY*100L;
  1651.   if (tmp1 < 0)
  1652.     tmp1 -= tmp2/2;
  1653.   else
  1654.     tmp1 += tmp2/2;
  1655.   return (PDIMENSION)(tmp1/tmp2);
  1656. }
  1659. PDIMENSION PCanvas::FromPointsX(PDIMENSION x)
  1660. {
  1661.   long tmp = (100L*x*deviceResX*map.Width())/viewport.Width();
  1662.   if (tmp < 0)
  1663.     tmp -= 3600;
  1664.   else
  1665.     tmp += 3600;
  1666.   return (PDIMENSION)(tmp/7200L);
  1667. }
  1668.   
  1670. PDIMENSION PCanvas::FromPointsY(PDIMENSION y)
  1671. {
  1672.   long tmp = (100L*y*deviceResY*map.Height())/viewport.Height();
  1673.   if (tmp < 0)
  1674.     tmp -= 3600;
  1675.   else
  1676.     tmp += 3600;
  1677.   return (PDIMENSION)(tmp/7200L);
  1678. }
  1679.   
  1681. void PCanvas::DrawBevelledRect(const PRect & rect, BOOL raised, BOOL deep)
  1682. {
  1683.   Save();
  1684.   PRect bounds = ToPixels(rect);
  1685.   PDim border = PApplication::Current().GetBorderSize();
  1686.   SetMappingRect(GetViewportRect());
  1688.   const PColour & shadowColour = PApplication::Current().GetButtonShadowColour();
  1689.   const PColour & lightColour = PApplication::Current().GetButtonLightingColour();
  1690.   const PColour & bkColour = GetFillFgColour();
  1691.   SetPenFgColour(bkColour);
  1692.   SetFillFgColour(bkColour);
  1693.   SetFillBkColour(bkColour);
  1694.   DrawRect(bounds);
  1696.   PORDINATE left = bounds.Left();
  1697.   PORDINATE top = bounds.Top();
  1698.   PORDINATE right = bounds.Right()-border.Width();
  1699.   PORDINATE bottom = bounds.Bottom()-border.Height();
  1701.   if (raised)
  1702.     SetPenFgColour(shadowColour);
  1703.   else
  1704.     SetPenFgColour(lightColour);
  1705.   SetPenWidth(border.Height());
  1706.   DrawLine(left,  bottom, right+border.Width(), bottom);
  1707.   bottom -= border.Height();
  1708.   if (deep)
  1709.     DrawLine(left+border.Width(), bottom, right+border.Width(), bottom);
  1711.   SetPenWidth(border.Width());
  1712.   DrawLine(right, top, right, bottom+border.Height());
  1713.   right -= border.Width();
  1714.   if (deep)
  1715.     DrawLine(right, top+border.Height(), right, bottom+border.Height());
  1717.   if (raised)
  1718.     SetPenFgColour(lightColour);
  1719.   else
  1720.     SetPenFgColour(shadowColour);
  1721.   SetPenWidth(border.Width());
  1722.   DrawLine(left,  top, left, bottom+border.Height());
  1723.   left += border.Width();
  1724.   if (deep)
  1725.     DrawLine(left,  top, left, bottom);
  1727.   SetPenWidth(border.Height());
  1728.   DrawLine(left, top, right+border.Width(), top);
  1729.   if (deep) {
  1730.     top += border.Height();
  1731.     DrawLine(left, top, right, top);
  1732.   }
  1734.   Restore();
  1735. }
  1738. static PString AddEllipses(PCanvas & canvas,
  1739.                         PDIMENSION width, const PString & line, int alignment)
  1740. {
  1741.   int amtTooBig = canvas.MeasureString(line).Width() - width;
  1742.   if (amtTooBig <= 0)
  1743.     return line;
  1745.   PDIMENSION fontWidth = canvas.FromPointsY(canvas.GetFont().GetAvgWidth());
  1746.   PINDEX numChars = line.GetLength() - (amtTooBig+fontWidth-1)/fontWidth - 5;
  1748.   PString ellipses, str;
  1749.   switch (alignment) {
  1750.     default :
  1751.     case PCanvas::LeftAlign :
  1752.       ellipses = " ...";
  1753.       str = line.Left(numChars) + ellipses;
  1754.       break;
  1756.     case PCanvas::RightAlign :
  1757.       ellipses = "... ";
  1758.       str = ellipses + line.Right(numChars);
  1759.       break;
  1761.     case PCanvas::Centred :
  1762.       ellipses = " ... ";
  1763.       str = line.Left((numChars+1)/2) + ellipses + line.Right(numChars/2);
  1764.       break;
  1765.   }
  1767.   while (canvas.MeasureString(str).Width() - width <= 0) {
  1768.     numChars++;
  1769.     switch (alignment) {
  1770.       default :
  1771.       case PCanvas::LeftAlign :
  1772.         str = line.Left(numChars) + ellipses;
  1773.         break;
  1775.       case PCanvas::RightAlign :
  1776.         str = ellipses + line.Right(numChars);
  1777.         break;
  1779.       case PCanvas::Centred :
  1780.         str = line.Left((numChars+1)/2) + ellipses + line.Right(numChars/2);
  1781.         break;
  1782.     }
  1783.   }
  1785.   numChars--;
  1786.   switch (alignment) {
  1787.     default :
  1788.     case PCanvas::LeftAlign :
  1789.       return line.Left(numChars) + ellipses;
  1791.     case PCanvas::RightAlign :
  1792.       return ellipses + line.Right(numChars);
  1794.     case PCanvas::Centred :
  1795.       return line.Left((numChars+1)/2) + ellipses + line.Right(numChars/2);
  1796.   }
  1797. }
  1800. PDIMENSION PCanvas::DrawString(const PRect & rect, const PString & str, int options) 
  1801. {
  1802.   if (GetTextBkColour().GetAlpha() != 0) {
  1803.     Save();
  1804.     SetPenStyle(Solid);
  1805.     SetPenWidth(0);
  1806.     SetPenMode(SrcCopy);
  1807.     SetPenFgColour(GetTextBkColour());
  1808.     SetFillPattern(PPattern());
  1809.     SetFillMode(SrcCopy);
  1810.     SetFillFgColour(GetTextBkColour());
  1811.     DrawRect(rect);
  1812.     Restore();
  1813.   }
  1815.   PDIMENSION spaceWidth = MeasureString(" ").Width();
  1816.   PStringArray unbrokenLines = str.Lines();
  1817.   PStringArray lines(unbrokenLines.GetSize());
  1818.   PINDEX line = 0;
  1819.   for (PINDEX i = 0; i < unbrokenLines.GetSize(); i++) {
  1820.     if (MeasureString(unbrokenLines[i]).Width() <= rect.Width())
  1821.       lines[line++] = unbrokenLines[i];
  1822.     else {
  1823.       switch (options&HorizontalWrapMask) {
  1824.         case NoWrapping :
  1825.           lines[line++] = unbrokenLines[i];
  1826.           break;
  1828.         // break the lines into new lines that are no wider than the rectangle
  1829.         case WordWrap : {
  1830.           PString str;
  1831.           PDIMENSION w = 0;
  1832.           PStringArray words = unbrokenLines[i].Tokenise(" t", FALSE);
  1833.           for (PINDEX k = 0; k < words.GetSize(); k++) {
  1834.             PDIMENSION x = MeasureString(words[k]).Width();
  1835.             if (w + x > rect.Width()) {
  1836.               if (w != 0)
  1837.                 lines[line++] = str;
  1838.               str = "";
  1839.               w = 0;
  1840.             }
  1841.             else if (w != 0) {
  1842.               str += " ";
  1843.               x += spaceWidth;
  1844.             }
  1845.             str += words[k];
  1846.             w += x;
  1847.           }
  1848.           lines[line++] = str;
  1849.           break;
  1850.         }
  1852.         // Chop text out of the line so that is no wider than the rectangle
  1853.         case CentreEllipses :
  1854.           lines[line++] = AddEllipses(*this,
  1855.                                       rect.Width(), unbrokenLines[i], Centred);
  1856.           break;
  1858.         case EndEllipses :
  1859.           lines[line++] = AddEllipses(*this,
  1860.               rect.Width(), unbrokenLines[i], options&HorizontalAlignmentMask);
  1861.           break;
  1862.       }
  1863.     }
  1864.   }
  1866.   PDIMENSION fontHeight = FromPointsY(realFont.GetHeight());
  1867.   PDIMENSION totalHeight = fontHeight*lines.GetSize();
  1869.   if (totalHeight > rect.Height()) {
  1870.     int numLinesToKill = (totalHeight-rect.Height()+fontHeight-1)/fontHeight+1;
  1871.     int firstLineToKill;
  1872.     switch (options&VerticalTruncationMask) {
  1873.       case CentreTruncation :
  1874.         firstLineToKill = lines.GetSize()/2 - numLinesToKill/2;
  1875.         break;
  1877.       case EndTruncation :
  1878.         switch (options&VerticalAlignmentMask) {
  1879.           case PCanvas::TopAlign :
  1880.             firstLineToKill = lines.GetSize() - numLinesToKill;
  1881.             break;
  1883.           case PCanvas::CentreVertical :
  1884.             firstLineToKill = lines.GetSize()/2 - numLinesToKill/2;
  1885.             break;
  1887.           default : // BottomAlign and BaseLine
  1888.             firstLineToKill = 0;
  1889.         }
  1890.         break;
  1892.       default :
  1893.         firstLineToKill = numLinesToKill = 0;
  1894.     }
  1895.     if (numLinesToKill > 0) {
  1896.       PDIMENSION eWidth = MeasureString(" ... ").Width();
  1897.       PString s = AddEllipses(*this, rect.Width()/2-eWidth/2,
  1898.                                           lines[firstLineToKill], LeftAlign) +
  1899.                   " ... " +
  1900.                   AddEllipses(*this, rect.Width()/2-eWidth/2,
  1901.                          lines[firstLineToKill+numLinesToKill-1], RightAlign);
  1902.       while (numLinesToKill-- > 0)
  1903.         lines.RemoveAt(firstLineToKill);
  1904.       lines.InsertAt(firstLineToKill, new PString(s));
  1905.       totalHeight = fontHeight*lines.GetSize();
  1906.     }
  1907.   }
  1909.   PORDINATE y;
  1910.   switch (options&VerticalAlignmentMask) {
  1911.     case TopAlign :
  1912.       y = rect.Top();
  1913.       break;
  1915.     case CentreVertical :
  1916.       y = rect.Top() + (rect.Height()-totalHeight)/2;
  1917.       break;
  1919.     default : // BottomAlign and BaseLine
  1920.       y = rect.Bottom() - totalHeight;
  1921.   }
  1923.   for (line = 0; line < lines.GetSize(); line++, y += fontHeight) {
  1924.     switch (options&HorizontalAlignmentMask) {
  1925.       case LeftAlign :
  1926.         DrawString(rect.Left(), y, lines[line], LeftAlign);
  1927.         break;
  1928.       
  1929.       case RightAlign :
  1930.         DrawString(rect.Right(), y, lines[line], RightAlign);
  1931.         break;
  1932.       
  1933.       case Centred :
  1934.         DrawString((rect.Left()+rect.Right())/2, y, lines[line], Centred);
  1935.         break;
  1936.       
  1937.       case Justified :
  1938.         // Split the line into space separated words
  1939.         PStringArray words = lines[line].Tokenise(" ", FALSE);
  1940.         if (words.GetSize() <= 1)
  1941.           DrawString(rect.Left(), y, lines[line], LeftAlign);
  1942.         else {
  1943.           // Now get the width inpixesl of each word
  1944.           PWORDArray wordWidths(words.GetSize());
  1945.           PDIMENSION totalWidth = 0;
  1946.           PINDEX word;
  1947.           for (word = 0; word < words.GetSize(); word++) {
  1948.             wordWidths[word] = (WORD)MeasureString(words[word]).Width();
  1949.             totalWidth += wordWidths[word];
  1950.           }
  1952.           if (rect.Width() <= totalWidth)
  1953.             DrawString(rect.Left(), y, lines[line], LeftAlign);
  1954.           else {
  1955.             // Now calculate the size of each space
  1956.             PORDINATE spaceWidth = (rect.Width()-totalWidth)/(words.GetSize()-1);
  1958.             // Finally, output each word at x location determined by space width
  1959.             PORDINATE x = rect.Left();
  1960.             for (word = 0; word < words.GetSize(); word++) {
  1961.               DrawString(x, y, words[word], LeftAlign);
  1962.               x += wordWidths[word] + spaceWidth;
  1963.             }
  1964.           }
  1965.         }
  1966.     }
  1967.   }
  1968.   return lines.GetSize()*fontHeight;
  1969. }
  1972. PDIMENSION PCanvas::MeasureString(const PString & str, PDIMENSION width)
  1973. {
  1974.   PStringArray lines = str.Lines();
  1975.   PDIMENSION height = 0;
  1976.   for (PINDEX line = 0; line < lines.GetSize(); line++) {
  1977.     PDim lineDim(MeasureString(lines[line]));
  1978.     if (lineDim.Width() > width) {
  1979.       
  1980.     }
  1981.     height += lineDim.Height();
  1982.   }
  1983.   return height;
  1984. }
  1987. void PCanvas::Restore()
  1988. {
  1989.   State * old = stack.Pop();
  1990.   SetPenStyle(old->GetPenStyle());
  1991.   SetPenWidth(old->GetPenWidth());
  1992.   SetPenMode(old->GetPenMode());
  1993.   SetPenFgColour(old->GetPenFgColour());
  1994.   SetPenBkColour(old->GetPenBkColour());
  1995.   SetFillFgColour(old->GetFillFgColour());
  1996.   SetFillBkColour(old->GetFillBkColour());
  1997.   SetFillPattern(old->GetFillPattern());
  1998.   SetFillMode(old->GetFillMode());
  1999.   SetFont(old->font);
  2000.   SetTextFgColour(old->GetTextFgColour());
  2001.   SetTextBkColour(old->GetTextBkColour());
  2002.   SetPalette(old->GetPalette());
  2003.   SetPolyFillMode(old->GetPolyFillMode());
  2004.   SetViewportRect(old->GetViewportRect());
  2005.   SetMappingRect(old->GetMappingRect());
  2006.   delete old;
  2007. }
  2010. #endif
  2013. //////////////////////////////////////////////////////////////////////////////
  2014. // PInteractorCanvas
  2016. #if defined(_PINTERACTORCANVAS)
  2018. void PInteractorCanvas::Construct(BOOL inPixels)
  2019. {
  2020.   PCanvasState::SetMappingRect(PRect(0, 0, 100, 100));
  2022.   if (inPixels)
  2023.     PCanvasState::SetViewportRect(map);
  2024.   else
  2025.     PCanvasState::SetViewportRect(PRect(0, 0,
  2026.                           (PDIMENSION)interactor->ToPixelsX(100),
  2027.                           (PDIMENSION)interactor->ToPixelsY(100)));
  2029.   const PColour & fgColour = interactor->GetForegroundColour();
  2030.   const PColour & bkColour = interactor->GetBackgroundColour();
  2031.   PCanvasState::SetPenFgColour(fgColour);
  2032.   PCanvasState::SetPenBkColour(bkColour);
  2033.   PCanvasState::SetFillFgColour(bkColour);
  2034.   PCanvasState::SetFillBkColour(fgColour);
  2035.   PCanvasState::SetTextFgColour(fgColour);
  2036.   PCanvasState::SetTextBkColour(bkColour);
  2038.   PCanvasState::SetFont(interactor->GetFont());
  2039. }
  2042. void PInteractorCanvas::Scroll(PORDINATE dx, PORDINATE dy)
  2043. {
  2044.   Scroll(dx, dy, GetDrawingBounds());
  2045. }
  2048. void PInteractorCanvas::Scroll(const PPoint & amt)
  2049. {
  2050.   Scroll(amt.X(), amt.Y(), GetDrawingBounds());
  2051. }
  2054. void PInteractorCanvas::Scroll(const PPoint & amt, const PRect & rect)
  2055. {
  2056.   Scroll(amt.X(), amt.Y(), rect);
  2057. }
  2060. #endif
  2063. //////////////////////////////////////////////////////////////////////////////
  2064. // PMemoryCanvas
  2066. PRect PMemoryCanvas::GetDrawingBounds() const
  2067. {
  2068.   return FromPixels(PRect(0, 0, image->Width(), image->Height()));
  2069. }
  2072. #undef new
  2075. // End Of File ///////////////////////////////////////////////////////////////