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

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

IP电话/视频会议

开发平台：

Visual C++

graph.cxx：源码内容
  1. /*
  2.  * graph.cxx
  3.  *
  4.  * Graphics classes implementation.
  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: graph.cxx,v $
  30.  * Revision 1.27  1999/08/17 03:46:41  robertj
  31.  * Fixed usage of inlines in optimised version.
  32.  *
  33.  * Revision 1.26  1998/12/12 00:44:03  robertj
  34.  * Added functions for user request on printing selection only.
  35.  * Fixed transfer of start and end pages from PPrintDialog.
  36.  *
  37.  * Revision 1.25  1998/10/15 11:32:55  robertj
  38.  * New memory leak detection system.
  39.  *
  40.  * Revision 1.24  1998/09/24 03:42:42  robertj
  41.  * Added open software license.
  42.  *
  43.  * Revision 1.23  1998/09/07 14:34:01  robertj
  44.  * Fixed setting of print info parameters from DEVMODE structure.
  45.  *
  46.  * Revision 1.22  1998/09/04 07:01:38  robertj
  47.  * Added a lot of DEVMODE infor for win95 to propagate from PrintDlg to PPrintCanvas.
  48.  *
  49.  * Revision 1.21  1998/01/26 00:20:42  robertj
  50.  * Fixed creation of pattern bitmaps (word alignment).
  51.  *
  52.  * Revision 1.20  1997/04/27 05:50:29  robertj
  53.  * DLL support.
  54.  *
  55.  * Revision 1.19  1996/10/31 12:39:56  robertj
  56.  * Added RCS keywords.
  57.  *
  58.  */
  60. #include <pwlib.h>
  62. #if !P_USE_INLINES
  63. #include <pwlib/graphics.inl>
  64. #endif
  66. #define new PNEW
  69. ///////////////////////////////////////////////////////////////////////////////
  71. PPoint::PPoint(DWORD dw)
  72. {
  73. #if defined(_WIN32)
  74.   POINTS ps = MAKEPOINTS(dw);
  75.   p.x = ps.x;
  76.   p.y = ps.y;
  77. #else
  78.   p = MAKEPOINT(dw);
  79. #endif
  80. }
  83. ///////////////////////////////////////////////////////////////////////////////
  86. PRect::PRect(PORDINATE x, PORDINATE y, PDIMENSION dx, PDIMENSION dy)
  87. {
  88.   r.left = x;
  89.   r.top = y;
  90.   r.right = x + dx;
  91.   r.bottom = y + dy;
  92. }
  95. PRect::PRect(const PDim & dim)
  96. {
  97.   r.left = r.top = 0;
  98.   r.right = dim.Width();
  99.   r.bottom = dim.Height();
  100. }
  103. PRect::PRect(const PPoint & p1, const PPoint & p2)
  104. {
  105.   if (p1.X() > p2.X()) {
  106.     r.left = p2.X();
  107.     r.right = p1.X();
  108.   }
  109.   else {
  110.     r.left = p1.X();
  111.     r.right = p2.X();
  112.   }
  114.   if (p1.Y() > p2.Y()) {
  115.     r.top = p2.Y();
  116.     r.bottom = p1.Y();
  117.   }
  118.   else {
  119.     r.top = p1.Y();
  120.     r.bottom = p2.Y();
  121.   }
  122. }
  125. PRect::PRect(const PPoint & topLeft, const PDim & dim)
  126. {
  127.   r.left = topLeft.X();
  128.   r.top = topLeft.Y();
  129.   r.right = topLeft.X() + dim.Width();
  130.   r.bottom = topLeft.Y() + dim.Height();
  131. }
  134. PObject::Comparison PRect::Compare(const PObject & obj) const
  135. {
  136.   PAssert(obj.IsDescendant(PRect::Class()), PInvalidCast);
  137.   return EqualRect(&r, &((const PRect &)obj).r) ? EqualTo : GreaterThan;
  138. }
  141. void PRect::SetX(PORDINATE nx)
  142. {
  143.   PORDINATE diff = nx - (PORDINATE)r.left;
  144.   r.left = nx;
  145.   r.right += diff;
  146. }
  149. void PRect::SetY(PORDINATE ny)
  150. {
  151.   PORDINATE diff = ny - (PORDINATE)r.top;
  152.   r.top = ny;
  153.   r.bottom += diff;
  154. }
  157. void PRect::SetTop(PORDINATE t)
  158. {
  159.   r.top = t;
  160.   if (t > r.bottom)
  161.     r.bottom = t;
  162. }
  165. void PRect::SetLeft(PORDINATE l)
  166. {
  167.   r.left = l;
  168.   if (l > r.right)
  169.     r.right = l;
  170. }
  173. void PRect::SetBottom(PORDINATE b)
  174. {
  175.   r.bottom = b;
  176.   if (b < r.top)
  177.     r.top = b;
  178. }
  180. void PRect::SetRight(PORDINATE rt)
  181. {
  182.   r.right = rt;
  183.   if (rt < r.left)
  184.     r.left = rt;
  185. }
  187. PRect PRect::Intersection(const PRect & rect) const
  188. {
  189.   PRect newRect;
  190.   IntersectRect(newRect, &r, rect);
  191.   return newRect;
  192. }
  195. PRect PRect::Union(const PRect & rect) const
  196. {
  197.   PRect newRect;
  198.   UnionRect(newRect, &r, rect);
  199.   return newRect;
  200. }
  203. ///////////////////////////////////////////////////////////////////////////////
  206. PRegion::PRegion(const PRect & rect)
  207. {
  208.   hRegion = CreateRectRgnIndirect(rect);
  209.   PAssertNULL(hRegion);
  210. }
  213. PRegion::PRegion(const PRegion & rgn)
  214. {
  215.   hRegion = CreateRectRgn(0, 0, 0, 0);
  216.   PAssertNULL(hRegion);
  217.   PAssertOS(CombineRgn(hRegion, rgn.hRegion, NULL, RGN_COPY) != ERROR);
  218. }
  221. PRegion & PRegion::operator=(const PRegion & rgn)
  222. {
  223.   PAssertOS(DeleteObject(hRegion));
  224.   hRegion = CreateRectRgn(0, 0, 0, 0);
  225.   PAssertNULL(hRegion);
  226.   PAssertOS(CombineRgn(hRegion, rgn.hRegion, NULL, RGN_COPY) != ERROR);
  227.   return *this;
  228. }
  231. PObject::Comparison PRegion::Compare(const PObject & obj) const
  232. {
  233.   PAssert(obj.IsDescendant(PRegion::Class()), PInvalidCast);
  234.   return EqualRgn(hRegion, ((const PRegion &)obj).hRegion)
  235.                                                        ? EqualTo : GreaterThan;
  236. }
  239. void PRegion::Add(const PRect & rect)
  240. {
  241.   HRGN hRgnNew = CreateRectRgn(0, 0, 0, 0);
  242.   HRGN hRgnRect = CreateRectRgnIndirect(rect);
  243.   PAssertNULL(hRgnNew);
  244.   PAssertNULL(hRgnRect);
  245.   PAssertOS(CombineRgn(hRgnNew, hRegion, hRgnRect, RGN_OR) != ERROR);
  246.   PAssertOS(DeleteObject(hRgnRect));
  247.   PAssertOS(DeleteObject(hRegion));
  248.   hRegion = PAssertNULL(hRgnNew);
  249. }
  252. void PRegion::Add(const PRegion & rgn)
  253. {
  254.   HRGN hRgnNew = CreateRectRgn(0, 0, 0, 0);
  255.   PAssertNULL(hRgnNew);
  256.   PAssertOS(CombineRgn(hRgnNew, hRegion, rgn.hRegion, RGN_OR) != ERROR);
  257.   PAssertOS(DeleteObject(hRegion));
  258.   hRegion = PAssertNULL(hRgnNew);
  259. }
  262. BOOL PRegion::OverlapsRect(const PRect & rect) const
  263. {
  264.   HRGN hRgn = CreateRectRgn(0, 0, 0, 0);
  265.   HRGN hRect = CreateRectRgnIndirect(rect);
  266.   PAssertNULL(hRgn);
  267.   PAssertNULL(hRect);
  268.   PAssertOS(CombineRgn(hRgn, hRect, hRegion, RGN_AND) != ERROR);
  269.   PAssertOS(DeleteObject(hRect));
  270.   RECT dummy;
  271.   BOOL empty = GetRgnBox(PAssertNULL(hRgn), &dummy) == NULLREGION;
  272.   PAssertOS(DeleteObject(hRgn));
  273.   return !empty;
  274. }
  277. BOOL PRegion::IsEmpty() const
  278. {
  279.   RECT dummy;
  280.   return GetRgnBox(hRegion, &dummy) == NULLREGION;
  281. }
  284. PRect PRegion::GetBounds() const
  285. {
  286.   PRect rect;
  287.   GetRgnBox(hRegion, rect);
  288.   return rect;
  289. }
  292. PRegion PRegion::Intersection(const PRegion & rgn) const
  293. {
  294.   HRGN hRgnNew = CreateRectRgn(0, 0, 0, 0);
  295.   PAssertNULL(hRgnNew);
  296.   PAssertOS(CombineRgn(hRgnNew, hRegion, rgn.hRegion, RGN_AND) != ERROR);
  297.   return PRegion(PAssertNULL(hRgnNew));
  298. }
  301. PRegion PRegion::Union(const PRegion & rgn) const
  302. {
  303.   HRGN hRgnNew = CreateRectRgn(0, 0, 0, 0);
  304.   PAssertNULL(hRgnNew);
  305.   PAssertOS(CombineRgn(hRgnNew, hRegion, rgn.hRegion, RGN_OR) != ERROR);
  306.   return PRegion(PAssertNULL(hRgnNew));
  307. }
  310. ///////////////////////////////////////////////////////////////////////////////
  313. PColour::PColour(const PString & description)
  314. {
  315.   memset(component, 0, sizeof(component));
  316.   PStringArray compstr = description.Tokenise(" ,");
  317.   switch (compstr.GetSize()) {
  318.     case 4 :
  319.       component[AlphaComponent] = (BYTE)compstr[3].AsInteger();
  320.       // Then execute next case
  322.     case 3 :
  323.       component[BlueComponent] = (BYTE)compstr[2].AsInteger();
  324.       // Then execute next case
  326.     case 2 :
  327.       component[GreenComponent] = (BYTE)compstr[1].AsInteger();
  328.       // Then execute next case
  330.     case 1 :
  331.       component[RedComponent] = (BYTE)compstr[0].AsInteger();
  332.   }
  333. }
  336. PString PColour::GetDescription() const
  337. {
  338.   return psprintf("%u,%u,%u,%u", GetRed(), GetGreen(), GetBlue(), GetAlpha());
  339. }
  342. PColour & PColour::FromCOLORREF(COLORREF col)
  343. {
  344.   component[RedComponent] = GetRValue(col);
  345.   component[GreenComponent] = GetGValue(col);
  346.   component[BlueComponent] = GetBValue(col);
  347.   component[AlphaComponent] = 0xff;
  348.   return *this;
  349. }
  352. //////////////////////////////////////////////////////////////////////////////
  354. #ifdef NOTYET
  355. PRealColour::PRealColour()
  356. {
  357.   HDC hDC = CreateCompatibleDC(NULL);
  358.   FromCOLORREF(GetNearestColor(hDC, ToCOLORREF()));
  359.   DeleteDC(hDC);
  360. }
  363. PRealColour::PRealColour(const PColour & colour)
  364.   : PColour(colour)
  365. {
  366.   if (colour.GetAlpha() != 0) {
  367.     HDC hDC = CreateCompatibleDC(NULL);
  368.     FromCOLORREF(GetNearestColor(hDC, colour.ToCOLORREF()));
  369.     DeleteDC(hDC);
  370.   }
  371. }
  372. #endif
  375. PRealColour::PRealColour(PCanvas & canvas, const PColour & colour)
  376.   : PColour(colour)
  377. {
  378.   if (colour.GetAlpha() != 0)
  379.     FromCOLORREF(GetNearestColor(canvas.GetHDC(), colour.ToCOLORREF()));
  380. }
  383. //////////////////////////////////////////////////////////////////////////////
  385. PPalette::PPalette()
  386. {
  387.   LOGPALETTE logPal;
  388.   logPal.palVersion = 0x300;
  389.   logPal.palNumEntries = 1;
  390.   logPal.palPalEntry[0].peRed = 0;
  391.   logPal.palPalEntry[0].peGreen = 0;
  392.   logPal.palPalEntry[0].peBlue = 0;
  393.   logPal.palPalEntry[0].peFlags = 0;
  394.   hPalette = CreatePalette(&logPal);
  395.   PAssertNULL(hPalette);
  396. }
  399. void PPalette::DestroyContents()
  400. {
  401.   PAssertOS(DeleteObject(hPalette));
  402. }
  405. PObject::Comparison PPalette::Compare(const PObject & obj) const
  406. {
  407.   PAssert(obj.IsDescendant(PPalette::Class()), PInvalidCast);
  408.   return hPalette == ((const PPalette &)obj).hPalette ? EqualTo : GreaterThan;
  409. }
  412. PINDEX PPalette::AddColour(const PColour & colour)
  413. {
  414.   PINDEX count = GetSize();
  415.   PAssertOS(SetColour(count, colour));
  416.   return count;
  417. }
  420. BOOL PPalette::RemoveColour(const PColour & colour)
  421. {
  422.   PINDEX index = GetNearestPaletteIndex(hPalette, colour.ToCOLORREF());
  423.   if (colour != GetColour(index))
  424.     return FALSE;
  425.   return RemoveColour(index);
  426. }
  429. BOOL PPalette::RemoveColour(PINDEX index)
  430. {
  431.   PINDEX numColours = GetSize()-1;
  432.   if (index > numColours)
  433.     return FALSE;
  435.   PINDEX colourCount = numColours - index;
  436.   if (colourCount > 0) {
  437.     PALETTEENTRY * entries = new PALETTEENTRY[colourCount];
  438.     GetPaletteEntries(hPalette, index+1, colourCount, entries);
  439.     SetPaletteEntries(hPalette, index, colourCount, entries);
  440.     delete [] entries;
  441.   }
  443.   return ResizePalette(hPalette, numColours);
  444. }
  447. BOOL PPalette::HasColour(const PColour & colour) const
  448. {
  449.   return GetColour(GetIndex(colour)) == colour;
  450. }
  453. PINDEX PPalette::GetIndex(const PColour & colour) const
  454. {
  455.   return GetNearestPaletteIndex(hPalette, colour.ToCOLORREF());
  456. }
  459. PColour PPalette::GetColour(PINDEX index) const
  460. {
  461.   PALETTEENTRY entry;
  462.   GetPaletteEntries(hPalette, index, 1, &entry);
  463.   return PColour(entry.peRed, entry.peGreen, entry.peBlue);
  464. }
  467. BOOL PPalette::SetColour(PINDEX index, const PColour & colour)
  468. {
  469.   if (!SetMinSize(index+1))
  470.     return FALSE;
  472.   PALETTEENTRY entry;
  473.   entry.peRed = colour.GetRed();
  474.   entry.peGreen = colour.GetGreen();
  475.   entry.peBlue = colour.GetBlue();
  476.   entry.peFlags = 0;
  477.   SetPaletteEntries(hPalette, index, 1, &entry);
  478.   return TRUE;
  479. }
  482. PINDEX PPalette::GetSize() const
  483. {
  484.   short count;
  485.   PAssertOS(GetObject(hPalette, sizeof(count), (LPSTR)&count)==sizeof(count));
  486.   return count;
  487. }
  490. BOOL PPalette::SetSize(PINDEX size)
  491. {
  492.   return ResizePalette(hPalette, size);
  493. }
  496. ///////////////////////////////////////////////////////////////////////////////
  499. PRealFont::PRealFont()
  500.   : PFont(PApplication::Current().GetSystemFont())
  501. {
  502.   Construct(CreateCompatibleDC(NULL));
  503. }
  506. PRealFont::PRealFont(const PFont & font)
  507.   : PFont(font)
  508. {
  509.   Construct(CreateCompatibleDC(NULL));
  510. }
  513. PRealFont::PRealFont(PCanvas & canvas, const PFont & font)
  514.   : PFont(font)
  515. {
  516.   Construct(CreateCompatibleDC(canvas.GetHDC()));
  517. }
  520. PRealFont::PRealFont(HFONT hFont)
  521.   : PFont("", 0)
  522. {
  523.   if (hFont == NULL)
  524.     hFont = (HFONT)GetStockObject(SYSTEM_FONT);
  526.   HDC dc = CreateCompatibleDC(NULL);
  527.   deviceResY = (PDIMENSION)GetDeviceCaps(dc, LOGPIXELSY);
  528.   PAssert(deviceResY != 0, PInvalidParameter);
  530.   LOGFONT lf;
  531.   GetObject(hFont, sizeof(lf), (LPSTR)&lf);
  532.   facename = PCaselessString(lf.lfFaceName);
  533.   size = PixelsToPointsY((PDIMENSION)PABS(lf.lfHeight));
  534.   styles = Regular;
  535.   if (lf.lfWeight > FW_NORMAL)
  536.     styles |= Bold;
  537.   if (lf.lfItalic)
  538.     styles |= Italic;
  539.   if (lf.lfUnderline)
  540.     styles |= Underline;
  541.   Construct(dc);
  542. }
  545. void PRealFont::Construct(HDC dc)
  546. {
  547.   SetMapMode(PAssertNULL(dc), MM_TEXT);
  548.   deviceResX = (PDIMENSION)GetDeviceCaps(dc, LOGPIXELSX);
  549.   PAssert(deviceResX != 0, PInvalidParameter);
  550.   deviceResY = (PDIMENSION)GetDeviceCaps(dc, LOGPIXELSY);
  551.   PAssert(deviceResY != 0, PInvalidParameter);
  552.   HFONT hFont = GetHFONT();
  553.   HGDIOBJ oldFont = SelectObject(dc, hFont);
  554.   TEXTMETRIC t;
  555.   GetTextMetrics(dc, &t);
  556.   PAssertOS(SelectObject(dc, PAssertNULL(oldFont)) != NULL);
  557.   PAssertOS(DeleteObject(hFont));
  558.   PAssertOS(DeleteDC(dc));
  560.   size = PixelsToPointsY((PDIMENSION)t.tmHeight);
  561.   height = PixelsToPointsY((PDIMENSION)(t.tmHeight + t.tmExternalLeading));
  562.   avgWidth = PixelsToPointsX((PDIMENSION)t.tmAveCharWidth);
  563.   maxWidth = PixelsToPointsX((PDIMENSION)t.tmMaxCharWidth);
  564.   ascent = PixelsToPointsY((PDIMENSION)t.tmAscent);
  565.   descent = PixelsToPointsY((PDIMENSION)t.tmDescent);
  566.   leading = PixelsToPointsY((PDIMENSION)t.tmExternalLeading);
  567.   styles = Regular;
  568.   if (t.tmWeight > FW_NORMAL)
  569.     styles |= Bold;
  570.   if (t.tmItalic)
  571.     styles |= Italic;
  572.   if (t.tmUnderlined)
  573.     styles |= Underline;
  574. }
  577. HFONT PRealFont::GetHFONT() const
  578. {
  579.   HFONT hFont = ::CreateFont(PointsToPixelsY(size), 0, 0, 0,
  580.                              (styles&Bold) != 0 ? FW_BOLD : FW_NORMAL,
  581.                              (BYTE)((styles&Italic) != 0),
  582.                              (BYTE)((styles&Underline) != 0),
  583.                              0, 0, 0, 0, 0, 0, facename);
  584.   return PAssertNULL(hFont);
  585. }
  588. PDIMENSION PRealFont::GetHeight(BOOL inPixels) const
  589. {
  590.   return inPixels ? PointsToPixelsY(height) : height;
  591. }
  594. PDIMENSION PRealFont::GetAvgWidth(BOOL inPixels) const
  595. {
  596.   return inPixels ? PointsToPixelsX(avgWidth) : avgWidth;
  597. }
  600. PDIMENSION PRealFont::GetMaxWidth(BOOL inPixels) const
  601. {
  602.   return inPixels ? PointsToPixelsX(maxWidth) : maxWidth;
  603. }
  606. PDIMENSION PRealFont::GetAscent(BOOL inPixels) const
  607. {
  608.   return inPixels ? PointsToPixelsY(ascent) : ascent;
  609. }
  612. PDIMENSION PRealFont::GetDescent(BOOL inPixels) const
  613. {
  614.   return inPixels ? PointsToPixelsY(descent) : descent;
  615. }
  618. PDIMENSION PRealFont::GetLeading(BOOL inPixels) const
  619. {
  620.   return inPixels ? PointsToPixelsY(leading) : leading;
  621. }
  624. ///////////////////////////////////////////////////////////////////////////////
  626. PPattern::PPattern()
  627. {
  628.   hBitmap = NULL;
  629.   bitmap.bmWidth = bitmap.bmHeight = 1;
  630. }
  633. PPattern::PPattern(PRESOURCE_ID resID)
  634. {
  635.   Construct(LoadBitmap(PApplication::Current().GetInstance(), MAKEINTRESOURCE(resID)));
  636. }
  639. PPattern::PPattern(Bits bits)
  640. {
  641.   BYTE wordAlignedBits[16];
  642.   memset(wordAlignedBits, 0, sizeof(wordAlignedBits));
  643.   PINDEX i;
  644.   for (i = 0; i < 8; i++)
  645.     wordAlignedBits[i*2] = bits[i];
  646.   Construct(CreateBitmap(8, 8, 1, 1, wordAlignedBits));
  647. }
  650. void PPattern::Construct(HBITMAP hBm)
  651. {
  652.   hBitmap = PAssertNULL(hBm);
  653.   GetObject(hBitmap, sizeof(bitmap), (LPSTR)&bitmap);
  654. }
  657. PObject::Comparison PPattern::Compare(const PObject & obj) const
  658. {
  659.   PAssert(obj.IsDescendant(PPattern::Class()), PInvalidCast);
  660.   return hBitmap == ((const PPattern &)obj).hBitmap ? EqualTo : GreaterThan;
  661. }
  664. void PPattern::DestroyContents()
  665. {
  666.   if (hBitmap != NULL)
  667.     PAssertOS(DeleteObject((HGDIOBJ)hBitmap));
  668. }
  671. void PPattern::CopyContents(const PPattern & pat)
  672. {
  673.   hBitmap = pat.hBitmap;
  674.   bitmap = pat.bitmap;
  675. }
  678. ///////////////////////////////////////////////////////////////////////////////
  680. PPixelBase::PPixelBase(PDIMENSION dx, PDIMENSION dy, BYTE depth)
  681.   : PImageBase(dx, dy)
  682. {
  683.   pixelLineBytes = (PINDEX)((((long)Width()*depth+31)/32)*4);
  684. #if defined(_WIN32)
  685.   pixels = (PPixelDataPtr)malloc((size_t)dy*pixelLineBytes);
  686. #else
  687.   pixels = (PPixelDataPtr)_halloc((long)dy*pixelLineBytes, 1);
  688. #endif
  689.   if (pixels == NULL)
  690.     memset(&info, 0, sizeof(info));
  691.   else {
  692.     info.biWidth = dx;
  693.     info.biHeight = dy;
  694.     info.biPlanes = 1;
  695.     info.biBitCount = depth;
  696.     info.biSizeImage = info.biHeight*pixelLineBytes;
  697.     info.biCompression = BI_RGB;
  698.     info.biXPelsPerMeter = 0;
  699.     info.biYPelsPerMeter = 0;
  700.     info.biClrImportant = 0;
  701.     info.biClrUsed = info.biBitCount < 24 ? (1 << info.biBitCount) : 0;
  702.   }
  703.   info.biSize = sizeof(info);
  705.   hBitmap = NULL;
  706. }
  709. PPixelBase::~PPixelBase()
  710. {
  711.   if (hBitmap != NULL)
  712.     PAssertOS(DeleteObject((HGDIOBJ)hBitmap));
  713. #if defined(_WIN32)
  714.     free(pixels);
  715. #else
  716.     _hfree(pixels);
  717. #endif
  718. }
  721. PObject::Comparison PPixelBase::Compare(const PObject & obj) const
  722. {
  723.   PAssert(obj.IsDescendant(PPixelBase::Class()), PInvalidCast);
  724.   return pixels == ((const PPixelBase &)obj).pixels ? EqualTo : GreaterThan;
  725. }
  728. PPixelBase::DIBInfo::DIBInfo(const PPixelBase & pix, HPALETTE hPal)
  729. {
  730.   PINDEX numColours = pix.palette.GetSize();
  731.   info = (BITMAPINFO *)malloc(
  732.                        sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD)*numColours);
  733.   PAssertNULL(info);
  734.   info->bmiHeader = pix.info;
  735.   if (info->bmiHeader.biBitCount >= 24)
  736.     colourUse = DIB_RGB_COLORS;
  737.   else if (pix.palette.GetHPALETTE() != hPal) {
  738.     colourUse = DIB_RGB_COLORS;
  739.     for (PINDEX i = 0; i < numColours; i++) {
  740.       PColour c = pix.palette.GetColour(i);
  741.       info->bmiColors[i].rgbRed   = c.GetRed();
  742.       info->bmiColors[i].rgbGreen = c.GetGreen();
  743.       info->bmiColors[i].rgbBlue  = c.GetBlue();
  744.       info->bmiColors[i].rgbReserved = 0;
  745.     }
  746.   }
  747.   else {
  748.     colourUse = DIB_PAL_COLORS;
  749.     WORD * wp = (WORD *)info->bmiColors;
  750.     for (PINDEX i = 0; i < numColours; i++)
  751.       *wp++ = (WORD)i;
  752.   }
  753. }
  756. HBITMAP PPixelBase::GetHBITMAP(HDC hDC) const
  757. {
  758.   DIBInfo dib(*this, NULL);
  759.   HDC tempDC = NULL;
  760.   if (hDC == NULL)
  761.     hDC = tempDC = CreateCompatibleDC(NULL);
  762.   HBITMAP hBm = CreateDIBitmap(hDC, dib, CBM_INIT, pixels, dib, dib.Usage());
  763.   if (tempDC)
  764.     DeleteDC(tempDC);
  765.   return hBm;
  766. }
  769. HDC PPixelBase::CreateImageDC()
  770. {
  771.   HDC hDC = CreateCompatibleDC(NULL);
  772.   hBitmap = GetHBITMAP(hDC);
  773.   PAssertOS(SelectObject(PAssertNULL(hDC), hBitmap) != NULL);
  774.   return hDC;
  775. }
  778. void PPixelBase::CloseImageDC(HDC hDC)
  779. {
  780.   PAssertOS(SelectObject(hDC, NULL) != NULL);
  781.   if (pixels != NULL)
  782.     GetBitmapBits(hBitmap, info.biSizeImage, pixels);
  783.   hBitmap = NULL;
  784. }
  787. PPixelDataPtr PPixelBase::GetRasterDataPtr(PORDINATE y) const
  788. {
  789.   PAssert(y >= 0 && (PDIMENSION)y < Height(), "Pixel out of bounds");
  790.   PAssert(pixels != NULL, "No pixel data");
  791.   return pixels + (long)(Height()-y-1)*pixelLineBytes;
  792. }
  795. PPixelImage::PPixelImage(PRESOURCE_ID resID)
  796. {
  797.   operator=(PPixelBase::CreateBitmap(LoadBitmap(
  798.               PApplication::Current().GetInstance(), MAKEINTRESOURCE(resID))));
  799. }
  802. PPixelImage PPixelBase::CreateBitmap(HBITMAP hBm)
  803. {
  804.   BITMAP bm;
  805.   PAssertOS(GetObject(PAssertNULL(hBm), sizeof(bm), (LPSTR)&bm) > 0);
  806.   PAssert(bm.bmPlanes == 1, PUnsupportedFeature);
  807.   PPixelImage pix((PDIMENSION)bm.bmWidth,
  808.                                (PDIMENSION)bm.bmHeight, (BYTE)bm.bmBitsPixel);
  809.   if (pix->pixels != NULL)
  810.     GetBitmapBits(hBm, pix->info.biSizeImage, pix->pixels);
  811.   return pix;
  812. }
  815. BOOL PPixelBase::Write(PFile & bmpFile)
  816. {
  817.   if (!bmpFile.IsOpen())
  818.     return FALSE;
  820.   BITMAPFILEHEADER bmfh;
  821.   bmfh.bfType = 0x4d42 /*'BM'*/;
  822.   bmfh.bfOffBits = sizeof(BITMAPFILEHEADER) +
  823.                    sizeof(BITMAPINFOHEADER) + info.biClrUsed*sizeof(RGBQUAD);
  824.   bmfh.bfSize = bmfh.bfOffBits + info.biSizeImage;
  825.   bmfh.bfReserved1 = bmfh.bfReserved2 = 0;
  826.   if (!bmpFile.Write(&bmfh, sizeof(bmfh)))
  827.     return FALSE;
  829.   if (!bmpFile.Write(&info, sizeof(info)))
  830.     return FALSE;
  832.   for (PINDEX i = 0; i < (PINDEX)info.biClrUsed; i++) {
  833.     PColour colour = palette.GetColour(i);
  834.     RGBQUAD rgb;
  835.     rgb.rgbRed = colour.GetRed();
  836.     rgb.rgbGreen = colour.GetGreen();
  837.     rgb.rgbBlue = colour.GetBlue();
  838.     rgb.rgbReserved = 0;
  839.     if (!bmpFile.Write(&rgb, sizeof(rgb)))
  840.       return FALSE;
  841.   }
  843.   if (pixels == NULL)
  844.     return FALSE;
  846. #if defined(_WIN32)
  847.   return bmpFile.Write(pixels, (PINDEX)info.biSizeImage);
  848. #else
  849.   return _hwrite(bmpFile.GetHandle(),
  850.                             pixels, info.biSizeImage) == (long)info.biSizeImage;
  851. #endif
  852. }
  855. ///////////////////////////////////////////////////////////////////////////////
  858. PPictBase::PPictBase()
  859.   : PImageBase(0, 0)
  860. {
  861.   hMetafile = NULL;
  862. }
  865. PPictBase::PPictBase(PFile & dwg)
  866.   : PImageBase(0, 0)
  867. {
  868.   dwg.Close();
  869. #if defined(_WIN32)
  870.   hMetafile = GetEnhMetaFile(dwg.GetFilePath());
  871. #else
  872.   hMetafile = GetMetaFile(dwg.GetFilePath());
  873. #endif
  874. }
  877. PPictBase::PPictBase(PRESOURCE_ID)
  878.   : PImageBase(0, 0)
  879. {
  880.   hMetafile = NULL;
  881. }
  884. PPictBase::PPictBase(PMETAFILE hM)
  885.   : PImageBase(0, 0)
  886. {
  887.   hMetafile = PAssertNULL(hM);
  888. }
  891. PPictBase::~PPictBase()
  892. {
  893. #if defined(_WIN32)
  894.   PAssertOS(DeleteEnhMetaFile(hMetafile));
  895. #else
  896.   PAssertOS(DeleteMetaFile(hMetafile));
  897. #endif
  898. }
  901. PObject::Comparison PPictBase::Compare(const PObject & obj) const
  902. {
  903.   PAssert(obj.IsDescendant(PPictBase::Class()), PInvalidCast);
  904.   return hMetafile==((const PPictBase &)obj).hMetafile ? EqualTo : GreaterThan;
  905. }
  908. HDC PPictBase::CreateImageDC()
  909. {
  910. #if defined(_WIN32)
  911.   HDC hDC = CreateEnhMetaFile(NULL, NULL, NULL, "PWLib");
  912. #else
  913.   HDC hDC = CreateMetaFile(NULL);
  914. #endif
  915.   return PAssertNULL(hDC);
  916. }
  919. void PPictBase::CloseImageDC(HDC hDC)
  920. {
  921. #if defined(_WIN32)
  922.   hMetafile = CloseEnhMetaFile(hDC);
  923. #else
  924.   hMetafile = CloseMetaFile(hDC);
  925. #endif
  926. }
  929. BOOL PPictBase::Write(PFile & dwg)
  930. {
  931.   dwg.Close();
  932. #if defined(_WIN32)
  933.   HENHMETAFILE hCopy = CopyEnhMetaFile(hMetafile, dwg.GetFilePath());
  934.   return DeleteEnhMetaFile(PAssertNULL(hCopy));
  935. #else
  936.   HMETAFILE hCopy = CopyMetaFile(hMetafile, dwg.GetFilePath());
  937.   return DeleteMetaFile(PAssertNULL(hCopy));
  938. #endif
  939. }
  943. ///////////////////////////////////////////////////////////////////////////////
  945. PPrintInfo::PPrintInfo()
  946. {
  947.   form = A4;
  948.   startPage = 1;
  949.   endPage = UINT_MAX;
  950.   selectionOnly = NoSelectionOnly;
  951.   copies = 1;
  952.   orientation = TRUE;
  953.   draftQuality = TRUE;
  955.   PRINTDLG printDlg;
  956.   memset(&printDlg, 0, sizeof(printDlg));
  957.   printDlg.lStructSize = sizeof(printDlg);
  958.   printDlg.Flags = PD_RETURNDEFAULT;
  960.   PAssertOS(PrintDlg(&printDlg));
  962.   SetFromPrintDlg(printDlg);
  964.   if (printDlg.hDevMode != NULL)
  965.     GlobalFree(printDlg.hDevMode);
  966.   if (printDlg.hDevNames != NULL)
  967.     GlobalFree(printDlg.hDevNames);
  968. }
  971. PPrintInfo::PPrintInfo(const PString & printerType,const PString & devicePort)
  972.   : driver("WINSPOOL"),
  973.     device(devicePort),
  974.     printer(printerType)
  975. {
  976.   form = A4;
  977.   startPage = 0;
  978.   endPage = (unsigned)-1;
  979.   copies = 1;
  980.   orientation = TRUE;
  981.   draftQuality = TRUE;
  983. #if defined(_WIN32)
  984.   HANDLE          hPrinter;
  985.   if (OpenPrinter((char *)(const char *)printerType, &hPrinter, NULL)) {
  986.     devModeBuffer.SetSize(DocumentProperties(NULL, hPrinter, NULL, NULL, NULL, 0));
  987.     if (DocumentProperties(NULL, hPrinter, NULL, GetDEVMODE(), NULL, DM_OUT_BUFFER) == IDOK)
  988.       ProcessDEVMODE();
  989.     PAssertOS(ClosePrinter(hPrinter));
  990.   }
  991. #else
  992.   char devLib[_MAX_PATH];
  993.   GetProfileString("devices", printerType, "", devLib, sizeof(devLib));
  994.   char * comma = strchr(devLib, ',');
  995.   if (comma != NULL)
  996.     *comma = '';
  997.   strcat(devLib, ".DRV");
  998.   HMODULE hDriver = LoadLibrary(devLib);
  999.   if (hDriver >= HINSTANCE_ERROR) {
  1000.     LPFNDEVMODE extDevMode = (LPFNDEVMODE)GetProcAddress(hDriver, PROC_EXTDEVICEMODE);
  1001.     if (extDevMode != NULL) {
  1002.       char devType[CCHDEVICENAME];
  1003.       strcpy(devType, printerType);
  1004.       char devPort[_MAX_PATH];
  1005.       strcpy(devPort, devicePort);
  1006.       LONG bufSize = extDevMode(NULL, hDriver, NULL, pDevMode, devPort, NULL, NULL, 0);
  1007.       devMode = (LPDEVMODE)new char[bufSize];
  1008.       if (extDevMode(NULL, hDriver, devMode, devType, devPort,
  1009.                      NULL, NULL, DM_OUT_BUFFER) == IDOK) {
  1010.         ProcessDEVMODE();
  1011.         driver = devicePort;
  1012.         printer = printerType;
  1013.       }
  1014.     }
  1015.     FreeLibrary(hDriver);
  1016.   }
  1017. #endif
  1018. }
  1021. void PPrintInfo::SetFromPrintDlg(const PRINTDLG & printDlg)
  1022. {
  1023.   if (printDlg.hDevMode != NULL) {
  1024.     devModeBuffer = PBYTEArray((BYTE *)GlobalLock(printDlg.hDevMode),
  1025.                                        GlobalSize(printDlg.hDevMode));
  1026.     GlobalUnlock(printDlg.hDevMode);
  1027.     ProcessDEVMODE();
  1028.   }
  1030.   if (printDlg.hDevNames != NULL) {
  1031.     LPSTR devNameBase = (LPSTR)GlobalLock(printDlg.hDevNames);
  1032.     LPDEVNAMES devNames = (LPDEVNAMES)devNameBase;
  1033.     driver = &devNameBase[devNames->wDriverOffset];
  1034.     printer = &devNameBase[devNames->wDeviceOffset];
  1035.     device = &devNameBase[devNames->wOutputOffset];
  1036.     GlobalUnlock(printDlg.hDevNames);
  1037.   }
  1039.   if ((printDlg.Flags&PD_NOPAGENUMS) != 0 || (printDlg.Flags&PD_PAGENUMS) == 0) {
  1040.     startPage = 0;
  1041.     endPage = UINT_MAX;
  1042.   }
  1043.   else {
  1044.     startPage = printDlg.nFromPage;
  1045.     endPage = printDlg.nToPage;
  1046.   }
  1048.   if ((printDlg.Flags&PD_NOSELECTION) != 0)
  1049.     selectionOnly = NoSelectionOnly;
  1050.   else if ((printDlg.Flags&PD_SELECTION) != 0)
  1051.     selectionOnly = SelectionOnlyOn;
  1052.   else
  1053.     selectionOnly = SelectionOnlyOff;
  1055.   copies = printDlg.nCopies;
  1056. }
  1059. void PPrintInfo::ProcessDEVMODE()
  1060. {
  1061.   LPDEVMODE devMode = GetDEVMODE();
  1063.   orientation = devMode->dmOrientation == DMORIENT_PORTRAIT;
  1065.   const static struct {
  1066.     short form;
  1067.     PDIMENSION width;
  1068.     PDIMENSION height;
  1069.   } PaperSizes[PPrintInfo::MaxForm] = {
  1070.     { 0,              0, 0 },
  1071.     { DMPAPER_A3,     2970, 4200 },
  1072.     { DMPAPER_A4,     2100, 2970 },
  1073.     { DMPAPER_A5,     1485, 2100 },
  1074.     { DMPAPER_B4,     2500, 3540 },
  1075.     { DMPAPER_B5,     1820, 2570 },
  1076.     { DMPAPER_LETTER, 2163, 2800 },
  1077.     { DMPAPER_LEGAL,  2163, 3563 }
  1078.   };
  1080.   int f;
  1081.   for (f = A3; f < MaxForm; f++) {
  1082.     if (PaperSizes[f].form == devMode->dmPaperSize)
  1083.       break;
  1084.   }
  1086.   form = (Forms)f;
  1087.   if (form == Custom)
  1088.     paperSize = PDim((PDIMENSION)devMode->dmPaperWidth,
  1089.                      (PDIMENSION)devMode->dmPaperLength);
  1090.   else if (orientation)
  1091.     paperSize = PDim(PaperSizes[f].width, PaperSizes[f].height);
  1092.   else
  1093.     paperSize = PDim(PaperSizes[f].height, PaperSizes[f].width);
  1095.   draftQuality = devMode->dmPrintQuality == DMRES_DRAFT;
  1096.   if (devMode->dmPrintQuality > 0)
  1097.     resolution = PDim((PDIMENSION)devMode->dmPrintQuality,
  1098.                       (PDIMENSION)devMode->dmYResolution);
  1099.   else
  1100.     resolution = PDim();
  1102.   copies = devMode->dmCopies;
  1103. }
  1106. LPDEVMODE PPrintInfo::GetDEVMODE() const
  1107. {
  1108.   PAssertOS(devModeBuffer.GetSize() > 0);
  1109.   return (LPDEVMODE)(const BYTE *)devModeBuffer;
  1110. }
  1113. HANDLE PPrintInfo::GetHDEVMODE() const
  1114. {
  1115.   HANDLE h = GlobalAlloc(GHND, devModeBuffer.GetSize());
  1116.   memcpy(GlobalLock(h), devModeBuffer, devModeBuffer.GetSize());
  1117.   GlobalUnlock(h);
  1118.   return h;
  1119. }
  1122. HANDLE PPrintInfo::GetDevNames() const
  1123. {
  1124.   PINDEX driverLen = driver.GetLength();
  1125.   PINDEX printerLen = printer.GetLength();
  1126.   PINDEX deviceLen = device.GetLength();
  1128.   HANDLE h = GlobalAlloc(GHND, sizeof(DEVNAMES)+driverLen+printerLen+deviceLen+4);
  1130.   LPDEVNAMES devNames = (LPDEVNAMES)GlobalLock(h);
  1131.   devNames->wDriverOffset = sizeof(DEVNAMES);
  1132.   devNames->wDeviceOffset = (WORD)(sizeof(DEVNAMES)+driverLen+1);
  1133.   devNames->wOutputOffset = (WORD)(sizeof(DEVNAMES)+driverLen+printerLen+2);
  1135.   LPSTR p = (LPSTR)devNames+sizeof(DEVNAMES);
  1136.   strcpy(p, driver);
  1138.   p += driverLen+1;
  1139.   strcpy(p, printer);
  1141.   p += printerLen+1;
  1142.   strcpy(p, device);
  1144.   GlobalUnlock(h);
  1145.   return h;
  1146. }
  1149. // End Of File ///////////////////////////////////////////////////////////////