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

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

IP电话/视频会议

开发平台：

Visual C++

canvas.cxx：源码内容
  1. /*
  2.  * canvas.cxx
  3.  *
  4.  * Canvas 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: canvas.cxx,v $
  30.  * Revision 1.49  1999/02/16 08:08:07  robertj
  31.  * MSVC 6.0 compatibility changes.
  32.  *
  33.  * Revision 1.48  1998/10/15 11:32:53  robertj
  34.  * New memory leak detection system.
  35.  *
  36.  * Revision 1.47  1998/09/24 03:42:31  robertj
  37.  * Added open software license.
  38.  *
  39.  * Revision 1.46  1998/09/22 15:09:58  robertj
  40.  * Added delayed HDC creation in PDrawCanvas.
  41.  *
  42.  * Revision 1.45  1998/09/18 13:59:31  robertj
  43.  * Fixed FillRect leaving small gaps in pattern filled rectangles next to each other.
  44.  *
  45.  * Revision 1.44  1998/09/07 14:03:41  robertj
  46.  * Fixed printing transforms being reset after each page.
  47.  *
  48.  * Revision 1.43  1998/09/04 07:00:10  robertj
  49.  * Fixed double print dialog.
  50.  * Can now print more than one page.
  51.  * Fixed uninitialised variable for win95 StartDoc()
  52.  *
  53.  * Revision 1.42  1998/03/20 03:13:25  robertj
  54.  * Added function to get physical bounds of canvas. Allows to scale drawing.
  55.  *
  56.  * Revision 1.41  1996/10/31 12:39:55  robertj
  57.  * Added RCS keywords.
  58.  *
  59.  */
  61. #include <pwlib.h>
  63. #define new PNEW
  66. PCanvas::PCanvas()
  67.   : _hDC(NULL),
  68.     _hPen((HPEN)GetStockObject(BLACK_PEN)),
  69.     _hBrush((HBRUSH)GetStockObject(HOLLOW_BRUSH)),
  70.     _hFont(NULL)
  71. {
  72.   deviceResX = deviceResY = 1;
  73.   font = realFont;
  74. }
  77. PCanvas::~PCanvas()
  78. {
  79.   if (_hDC != NULL)
  80.     PAssertOS(DeleteDC(_hDC));
  81.   if (_hPen != NULL)
  82.     PAssertOS(DeleteObject(_hPen));
  83.   if (_hBrush != NULL)
  84.     PAssertOS(DeleteObject(_hBrush));
  85.   if (_hFont != NULL)
  86.     PAssertOS(DeleteObject(_hFont));
  87. }
  90. PCanvasState & PCanvas::operator=(const PCanvasState & state)
  91. {
  92.   PCanvasState::operator=(state);
  93.   if (_hDC != NULL)
  94.     SetHDC(_hDC);
  95.   return *this;
  96. }
  99. PObject::Comparison PCanvas::Compare(const PObject & obj) const
  100. {
  101.   PAssert(obj.IsDescendant(PCanvas::Class()), PInvalidCast);
  102.   return _hDC == ((const PCanvas &)obj)._hDC ? EqualTo : GreaterThan;
  103. }
  106. int PEXPORTED PEnumFontFamilyProc(const ENUMLOGFONT FAR * lpelf,
  107.                                  const NEWTEXTMETRIC FAR *,
  108.                                  int fontType,
  109.                                  LPARAM lParam)
  110. {
  111.   PFontFamily * family = new PFontFamily(lpelf->elfLogFont.lfFaceName);
  112.   family->scalable = (fontType & RASTER_FONTTYPE) == 0;
  113.   ((PFontFamilyList *)lParam)->Append(family);
  114.   return TRUE;
  115. }
  118. int PEXPORTED PEnumFontFaceProc(const ENUMLOGFONT FAR * lpelf,
  119.                                const NEWTEXTMETRIC FAR * lpntm,
  120.                                int fontType,
  121.                                LPARAM lParam)
  122. {
  123.   PFontFamily * family = (PFontFamily *)lParam;
  124.   if ((fontType & TRUETYPE_FONTTYPE) != 0) {
  125.     if (family->sizes.GetSize() == 0) {
  126.       WORD sizes[] = {
  127.         8, 9, 10, 11, 12, 14, 16, 18, 20, 24, 28, 32, 36, 40, 48, 56, 64, 72
  128.       };
  129.       family->sizes = PWORDArray(sizes, PARRAYSIZE(sizes));
  130.     }
  131.     WORD style = PFont::Regular;
  132.     if ((lpntm->ntmFlags&0x20) != 0)
  133.       style |= PFont::Bold;
  134.     if ((lpntm->ntmFlags&1) != 0)
  135.       style |= PFont::Italic;
  136.     if ((lpntm->ntmFlags&2) != 0)
  137.       style |= PFont::Underline;
  138.     family->styles[family->styles.GetSize()] = style;
  139.     family->styleNames[family->styleNames.GetSize()] =
  140.                                         PString((const char *)lpelf->elfStyle);
  141.   }
  142.   else {
  143.     family->sizes[family->sizes.GetSize()] = (WORD)lpelf->elfLogFont.lfHeight;
  144.     if (family->styles.GetSize() == 0) {
  145.       family->sizes[0] = 0;
  146.       if (lpelf->elfStyle[0] != '')
  147.         family->styleNames[0] = PString((const char *)lpelf->elfStyle);
  148.       else
  149.         family->styleNames[0] = "Regular";
  150.     }
  151.   }
  152.   return TRUE;
  153. }
  156. PFontFamilyList PCanvas::GetAvailableFonts() const
  157. {
  158.   PFontFamilyList list;
  159.   EnumFontFamilies(GetHDC(),
  160.                        NULL, (FONTENUMPROC)PEnumFontFamilyProc, (LPARAM)&list);
  161.   for (PINDEX i = 0; i < list.GetSize(); i++)
  162.     EnumFontFamilies(GetHDC(), list[i].GetFacename(),
  163.                             (FONTENUMPROC)PEnumFontFaceProc, (LPARAM)&list[i]);
  164.   return list;
  165. }
  168. void PCanvas::SetHDC(HDC newDC)
  169. {
  170.   _hDC = PAssertNULL(newDC);
  171.   deviceResX = GetDeviceCaps(_hDC, LOGPIXELSX);
  172.   deviceResY = GetDeviceCaps(_hDC, LOGPIXELSY);
  174.   realFont = PRealFont(*this, font);
  176.   SetMapMode(_hDC, MM_ANISOTROPIC);
  177.   SetTransform();
  178.   MakePen();
  179.   MakeBrush();
  181. #if defined(_WIN32)
  182.   SetBrushOrgEx(GetHDC(), patternOrigin.X(), patternOrigin.Y(), NULL);
  183. #else
  184.   SetBrushOrg(GetHDC(), patternOrigin.X(), patternOrigin.Y());
  185. #endif
  186.   PAssertOS(SelectPalette(_hDC, palette.GetHPALETTE(), TRUE) != NULL);
  187.   ::SetPolyFillMode(_hDC, polyFillMode == Winding ? WINDING : ALTERNATE);
  188.   SetTextAlign(_hDC, TA_LEFT|TA_TOP|TA_NOUPDATECP);
  189. }
  192. BOOL PCanvas::SetPenStyle(PenStyles style)
  193. {
  194.   if (PCanvasState::SetPenStyle(style)) {
  195.     MakePen();
  196.     return TRUE;
  197.   }
  198.   return FALSE;
  199. }
  202. BOOL PCanvas::SetPenWidth(int width)
  203. {
  204.   if (PCanvasState::SetPenWidth(width)) {
  205.     MakePen();
  206.     return TRUE;
  207.   }
  208.   return FALSE;
  209. }
  212. BOOL PCanvas::SetPenFgColour(const PColour & colour)
  213. {
  214.   if (PCanvasState::SetPenFgColour(colour)) {
  215.     MakePen();
  216.     return TRUE;
  217.   }
  218.   return FALSE;
  219. }
  222. void PCanvas::MakePen()
  223. {
  224.   HPEN oldPen = _hPen;
  226.   if (penFgColour.GetAlpha() == 0)
  227.     _hPen = (HPEN)GetStockObject(NULL_PEN);
  228.   else {
  229.     static int msStyle[] = { PS_SOLID, PS_DOT, PS_DASH, PS_DASHDOT };
  230.     PAssert(penStyle < sizeof(msStyle)/sizeof(msStyle[0]), PInvalidParameter);
  231.     _hPen = CreatePen(msStyle[penStyle],
  232.                           penWidth, penFgColour.ToCOLORREF());
  233.   }
  234.   PAssertNULL(_hPen);
  236.   if (_hDC != NULL)
  237.     PAssertOS(SelectObject(_hDC, _hPen) != NULL);
  239.   if (oldPen != NULL)
  240.     PAssertOS(DeleteObject(oldPen));
  241. }
  244. BOOL PCanvas::SetFillPattern(const PPattern & pattern)
  245. {
  246.   if (PCanvasState::SetFillPattern(pattern)) {
  247.     MakeBrush();
  248.     return TRUE;
  249.   }
  250.   return FALSE;
  251. }
  254. BOOL PCanvas::SetPatternOrigin(const PPoint & pt)
  255. {
  256.   if (PCanvasState::SetPatternOrigin(pt)) {
  257. #ifdef WIN32
  258.     SetBrushOrgEx(GetHDC(), pt.X(), pt.Y(), NULL);
  259. #else
  260.     SetBrushOrg(GetHDC(), pt.X(), pt.Y());
  261. #endif
  262.     return TRUE;
  263.   }
  264.   return FALSE;
  265. }
  268. BOOL PCanvas::SetFillFgColour(const PColour & colour)
  269. {
  270.   if (PCanvasState::SetFillFgColour(colour)) {
  271.     MakeBrush();
  272.     return TRUE;
  273.   }
  274.   return FALSE;
  275. }
  278. void PCanvas::MakeBrush()
  279. {
  280.   HBRUSH oldBrush = _hBrush;
  282.   if (fillFgColour.GetAlpha() == 0)
  283.     _hBrush = (HBRUSH)GetStockObject(HOLLOW_BRUSH);
  284.   else if (fillPattern.GetHBITMAP() == NULL)
  285.     _hBrush = CreateSolidBrush(fillFgColour.ToCOLORREF());
  286.   else
  287.     _hBrush = CreatePatternBrush(fillPattern.GetHBITMAP());
  288.   PAssertNULL(_hBrush);
  290.   if (_hDC != NULL)
  291.     PAssertOS(SelectObject(_hDC, _hBrush) != NULL);
  293.   if (oldBrush != NULL)
  294.     PAssertOS(DeleteObject(oldBrush));
  295. }
  298. BOOL PCanvas::SetFont(const PFont & newFont)
  299. {
  300.   if (!PCanvasState::SetFont(newFont))
  301.     return FALSE;
  303.   GetHDC();
  304.   realFont = PRealFont(*this, newFont);
  305.   MakeFont();
  306.   return TRUE;
  307. }
  310. void PCanvas::MakeFont()
  311. {
  312.   HFONT oldFont = _hFont;
  314.   _hFont = CreateFont(FromPointsY(realFont.GetHeight()),
  315.                      0, 0, 0,
  316.                      realFont.IsBold() ? FW_BOLD : FW_NORMAL,
  317.                      (BYTE)realFont.IsItalic(),
  318.                      (BYTE)realFont.IsUnderlined(),
  319.                      0, 0, 0, 0, 0, 0,
  320.                      realFont.GetFacename());
  321.   PAssertNULL(_hFont);
  323.   if (_hDC != NULL)
  324.     PAssertOS(SelectObject(_hDC, _hFont) != NULL);
  326.   if (oldFont != NULL)
  327.     PAssertOS(DeleteObject(oldFont));
  328. }
  331. BOOL PCanvas::SetPalette(const PPalette & newPal)
  332. {
  333.   if (PCanvasState::SetPalette(newPal)) {
  334.     if (_hDC != NULL)
  335.       PAssertOS(SelectPalette(_hDC, palette.GetHPALETTE(), TRUE) != NULL);
  336.     return TRUE;
  337.   }
  338.   return FALSE;
  339. }
  342. BOOL PCanvas::SetPolyFillMode(PolyFillMode newMode)
  343. {
  344.   if (PCanvasState::SetPolyFillMode(newMode)) {
  345.     if (_hDC != NULL)
  346.       ::SetPolyFillMode(_hDC, polyFillMode == Winding ? WINDING : ALTERNATE);
  347.     return TRUE;
  348.   }
  349.   return FALSE;
  350. }
  353. BOOL PCanvas::SetViewportRect(const PRect & rect)
  354. {
  355.   if (PCanvasState::SetViewportRect(rect)) {
  356.     SetTransform();
  357.     return TRUE;
  358.   }
  359.   return FALSE;
  360. }
  363. BOOL PCanvas::SetMappingRect(const PRect & rect)
  364. {
  365.   if (PCanvasState::SetMappingRect(rect)) {
  366.     SetTransform();
  367.     return TRUE;
  368.   }
  369.   return FALSE;
  370. }
  373. void PCanvas::SetTransform()
  374. {
  375.   if (_hDC == NULL)
  376.     return;
  378.   SetViewportOrgEx(_hDC, viewport.Left(), viewport.Top(), NULL);
  379.   SetViewportExtEx(_hDC, viewport.Width(), viewport.Height(), NULL);
  380.   SetWindowOrgEx(_hDC, map.Left(), map.Top(), NULL);
  381.   SetWindowExtEx(_hDC, map.Width(), map.Height(), NULL);
  382.   if (GetPenWidth() != 0)
  383.     MakePen();
  384.   MakeFont();
  385. }
  388. void PCanvas::MoveCurrentPosition(PORDINATE x, PORDINATE y)
  389. {
  390.   POINT p;
  391.   PAssertOS(GetCurrentPositionEx(GetHDC(), &p));
  392.   MoveToEx(_hDC, p.x+x, p.y+y, NULL);
  393. }
  396. PPoint PCanvas::GetCurrentPosition() const
  397. {
  398.   PPoint p;
  399.   PAssertOS(::GetCurrentPositionEx(GetHDC(), p));
  400.   return p;
  401. }
  404. void PCanvas::DrawLine(PORDINATE x, PORDINATE y)
  405. {
  406.   SetUpDrawModes(penMode, penFgColour, penBkColour, NULL, -1);
  407.   LineTo(GetHDC(), x, y);
  408. }
  411. void PCanvas::DrawLine(PORDINATE x1, PORDINATE y1, PORDINATE x2, PORDINATE y2)
  412. {
  413.   SetUpDrawModes(penMode, penFgColour, penBkColour, NULL, -1);
  414.   POINT p;
  415.   MoveToEx(GetHDC(), x1, y1, &p);
  416.   LineTo(_hDC, x2, y2);
  417.   MoveToEx(_hDC, (int)p.x, (int)p.y, NULL);
  418. }
  421. void PCanvas::DrawLineRelative(PORDINATE x, PORDINATE y)
  422. {
  423.   SetUpDrawModes(penMode, penFgColour, penBkColour, NULL, -1);
  424.   POINT p;
  425.   PAssertOS(GetCurrentPositionEx(GetHDC(), &p));
  426.   LineTo(_hDC, p.x+x, p.y+y);
  427. }
  430. void PCanvas::_DrawRect(PORDINATE x, PORDINATE y, PDIMENSION dx, PDIMENSION dy)
  431. {
  432.   if (penMode == fillMode) {
  433.     SetUpDrawModes(fillMode, fillFgColour, fillBkColour, NULL, -1);
  434.     Rectangle(_hDC, x, y, x+dx, y+dy);
  435.   }
  436.   else {
  437.     HGDIOBJ oldBrush =
  438.            SetUpDrawModes(penMode, penFgColour, penBkColour, NULL, NULL_BRUSH);
  439.     Rectangle(_hDC, x, y, x+dx, y+dy);
  440.     HGDIOBJ oldPen =
  441.       SetUpDrawModes(fillMode, fillFgColour, fillBkColour, oldBrush, NULL_PEN);
  442.     Rectangle(_hDC, x, y, x+dx, y+dy);
  443.     SelectObject(_hDC, oldPen);
  444.   }
  445. }
  448. void PCanvas::_FillRect(PORDINATE x, PORDINATE y, PDIMENSION dx, PDIMENSION dy)
  449. {
  450.   SetUpDrawModes(fillMode, fillFgColour, fillBkColour, NULL, -1);
  451.   PRect r(x, y, dx, dy);
  452.   ::FillRect(GetHDC(), r, _hBrush);
  453. }
  456. void PCanvas::DrawRoundRect(const PRect & rect,
  457.                                PDIMENSION cornerWidth, PDIMENSION cornerHeight)
  458. {
  459.   if (penMode == fillMode) {
  460.     SetUpDrawModes(fillMode, fillFgColour, fillBkColour, NULL, -1);
  461.     RoundRect(_hDC, rect.Left(), rect.Top(), rect.Right(), rect.Bottom(),
  462.                                                     cornerWidth, cornerHeight);
  463.   }
  464.   else {
  465.     HGDIOBJ oldBrush =
  466.            SetUpDrawModes(penMode, penFgColour, penBkColour, NULL, NULL_BRUSH);
  467.     RoundRect(_hDC, rect.Left(), rect.Top(), rect.Right(), rect.Bottom(),
  468.                                                     cornerWidth, cornerHeight);
  469.     HGDIOBJ oldPen =
  470.       SetUpDrawModes(fillMode, fillFgColour, fillBkColour, oldBrush, NULL_PEN);
  471.     RoundRect(_hDC, rect.Left(), rect.Top(), rect.Right(), rect.Bottom(),
  472.                                                     cornerWidth, cornerHeight);
  473.     SelectObject(_hDC, oldPen);
  474.   }
  475. }
  478. void PCanvas::DrawEllipse(const PRect & rect)
  479. {
  480.   if (penMode == fillMode) {
  481.     SetUpDrawModes(fillMode, fillFgColour, fillBkColour, NULL, -1);
  482.     Ellipse(_hDC, rect.Left(), rect.Top(), rect.Right(), rect.Bottom());
  483.   }
  484.   else {
  485.     HGDIOBJ oldBrush =
  486.            SetUpDrawModes(penMode, penFgColour, penBkColour, NULL, NULL_BRUSH);
  487.     Ellipse(_hDC, rect.Left(), rect.Top(), rect.Right(), rect.Bottom());
  488.     HGDIOBJ oldPen =
  489.       SetUpDrawModes(fillMode, fillFgColour, fillBkColour, oldBrush, NULL_PEN);
  490.     Ellipse(_hDC, rect.Left(), rect.Top(), rect.Right(), rect.Bottom());
  491.     SelectObject(_hDC, oldPen);
  492.   }
  493. }
  496. void PCanvas::DrawArc(const PRect & rect,
  497.                                   const PPoint & startPt, const PPoint & endPt)
  498. {
  499.   SetUpDrawModes(penMode, penFgColour, penBkColour, NULL, -1);
  500.   Arc(GetHDC(), rect.Left(), rect.Top(), rect.Right(), rect.Bottom(),
  501.                                startPt.X(), startPt.Y(), endPt.X(), endPt.Y());
  502. }
  505. static PPoint PointFromAngle(int angle)
  506. {
  507.   static int sine[] = {
  508.       0,  17,  35,  52,  70,  87, 105, 122, 139, 156, 174,  191,  208,
  509.     225, 242, 259, 276, 292, 309, 326, 342, 358, 375, 391,  407,  423,
  510.     438, 454, 469, 485, 500, 515, 530, 545, 559, 574, 588,  602,  616,
  511.     629, 643, 656, 669, 682, 695, 707, 719, 731, 743, 755,  766,  777,
  512.     788, 799, 809, 819, 829, 839, 848, 857, 866, 875, 883,  891,  899,
  513.     906, 914, 921, 927, 934, 940, 946, 951, 956, 961, 966,  970,  974,
  514.     978, 982, 985, 988, 990, 993, 995, 996, 998, 999, 999, 1000, 1000
  515.   };
  517.   while (angle < 0)
  518.     angle += 360;
  519.   angle %= 360;
  521.   switch (angle/45) {
  522.     default:
  523.     case 0 :
  524.       return PPoint(1000, sine[angle]);
  526.     case 1 :
  527.       return PPoint(sine[90-angle], 1000);
  529.     case 2 :
  530.       return PPoint(sine[angle], -1000);
  532.     case 3 :
  533.       return PPoint(1000, sine[angle]);
  535.     case 4 :
  536.       return PPoint(1000, sine[angle]);
  538.     case 5 :
  539.       return PPoint(sine[90-angle], 1000);
  541.     case 6 :
  542.       return PPoint(sine[90-angle], 1000);
  544.     case 7 :
  545.       return PPoint(1000, sine[angle]);
  546.   }
  547. }
  550. void PCanvas::DrawArc(const PRect & rect, int startAngle, int endAngle)
  551. {
  552.   DrawArc(rect, PointFromAngle(startAngle), PointFromAngle(endAngle));
  553. }
  556. void PCanvas::DrawPie(const PRect & rect,
  557.                                   const PPoint & startPt, const PPoint & endPt)
  558. {
  559.   if (penMode == fillMode) {
  560.     SetUpDrawModes(fillMode, fillFgColour, fillBkColour, NULL, -1);
  561.     Pie(GetHDC(), rect.Left(), rect.Top(), rect.Right(), rect.Bottom(),
  562.                                startPt.X(), startPt.Y(), endPt.X(), endPt.Y());
  563.   }
  564.   else {
  565.     HGDIOBJ oldBrush =
  566.            SetUpDrawModes(penMode, penFgColour, penBkColour, NULL, NULL_BRUSH);
  567.     Pie(GetHDC(), rect.Left(), rect.Top(), rect.Right(), rect.Bottom(),
  568.                                startPt.X(), startPt.Y(), endPt.X(), endPt.Y());
  569.     HGDIOBJ oldPen =
  570.       SetUpDrawModes(fillMode, fillFgColour, fillBkColour, oldBrush, NULL_PEN);
  571.     Pie(GetHDC(), rect.Left(), rect.Top(), rect.Right(), rect.Bottom(),
  572.                                startPt.X(), startPt.Y(), endPt.X(), endPt.Y());
  573.     SelectObject(_hDC, oldPen);
  574.   }
  575. }
  578. void PCanvas::DrawPie(const PRect & rect, int startAngle, int endAngle)
  579. {
  580.   DrawPie(rect, PointFromAngle(startAngle), PointFromAngle(endAngle));
  581. }
  584. void PCanvas::DrawChord(const PRect & rect,
  585.                                   const PPoint & startPt, const PPoint & endPt)
  586. {
  587.   if (penMode == fillMode) {
  588.     SetUpDrawModes(fillMode, fillFgColour, fillBkColour, NULL, -1);
  589.     Chord(GetHDC(), rect.Left(), rect.Top(), rect.Right(), rect.Bottom(),
  590.                                startPt.X(), startPt.Y(), endPt.X(), endPt.Y());
  591.   }
  592.   else {
  593.     HGDIOBJ oldBrush =
  594.            SetUpDrawModes(penMode, penFgColour, penBkColour, NULL, NULL_BRUSH);
  595.     Chord(GetHDC(), rect.Left(), rect.Top(), rect.Right(), rect.Bottom(),
  596.                                startPt.X(), startPt.Y(), endPt.X(), endPt.Y());
  597.     HGDIOBJ oldPen =
  598.       SetUpDrawModes(fillMode, fillFgColour, fillBkColour, oldBrush, NULL_PEN);
  599.     Chord(GetHDC(), rect.Left(), rect.Top(), rect.Right(), rect.Bottom(),
  600.                                startPt.X(), startPt.Y(), endPt.X(), endPt.Y());
  601.     SelectObject(_hDC, oldPen);
  602.   }
  603. }
  606. void PCanvas::DrawChord(const PRect & rect, int startAngle, int endAngle)
  607. {
  608.   DrawChord(rect, PointFromAngle(startAngle), PointFromAngle(endAngle));
  609. }
  612. void PCanvas::DrawPolyLine(const PPointArray & ptArray)
  613. {
  614.   DrawPolyLine(MakePOINTArray(ptArray), ptArray.GetSize());
  615. }
  618. void PCanvas::DrawPolyLine(const PPoint * ptArray, PINDEX numPts)
  619. {
  620.   DrawPolyLine(MakePOINTArray(ptArray, numPts), numPts);
  621. }
  624. void PCanvas::DrawPolyLine(LPPOINT ptArray, PINDEX numPts)
  625. {
  626.   SetUpDrawModes(penMode, penFgColour, penBkColour, NULL, -1);
  627.   Polyline(GetHDC(), ptArray, numPts);
  628.   delete [] ptArray;
  629. }
  632. void PCanvas::DrawPolygon(const PPointArray & ptArray)
  633. {
  634.   DrawPolygon(MakePOINTArray(ptArray), ptArray.GetSize());
  635. }
  638. void PCanvas::DrawPolygon(const PPoint * ptArray, PINDEX numPts)
  639. {
  640.   DrawPolygon(MakePOINTArray(ptArray, numPts), numPts);
  641. }
  644. void PCanvas::DrawPolygon(LPPOINT ptArray, PINDEX numPts)
  645. {
  646.   if (penMode == fillMode) {
  647.     SetUpDrawModes(fillMode, fillFgColour, fillBkColour, NULL, -1);
  648.     Polygon(GetHDC(), ptArray, numPts);
  649.   }
  650.   else {
  651.     HGDIOBJ oldBrush =
  652.            SetUpDrawModes(penMode, penFgColour, penBkColour, NULL, NULL_BRUSH);
  653.     Polygon(GetHDC(), ptArray, numPts);
  654.     HGDIOBJ oldPen =
  655.       SetUpDrawModes(fillMode, fillFgColour, fillBkColour, oldBrush, NULL_PEN);
  656.     Polygon(GetHDC(), ptArray, numPts);
  657.     SelectObject(_hDC, oldPen);
  658.   }
  659.   delete [] ptArray;
  660. }
  663. LPPOINT PCanvas::MakePOINTArray(const PPointArray & ptArray)
  664. {
  665.   PINDEX size = ptArray.GetSize();
  666.   LPPOINT pa = new POINT[size];
  667.   for (PINDEX i = 0; i < size; i++)
  668.     pa[i] = *(LPPOINT)ptArray[i];
  669.   return pa;
  670. }
  673. LPPOINT PCanvas::MakePOINTArray(const PPoint * ptArray, PINDEX numPts)
  674. {
  675.   LPPOINT pa = new POINT[numPts];
  676.   for (PINDEX i = 0; i < numPts; i++)
  677.     pa[i] = *(const POINT *)ptArray[i];
  678.   return pa;
  679. }
  682. void PCanvas::DrawImgIcon(PORDINATE x, PORDINATE y, const PImgIcon & icn)
  683. {
  684.   SetUpDrawModes(fillMode, fillFgColour, fillBkColour, NULL, -1);
  685.   SetMapMode(_hDC, MM_TEXT);
  686.   SetViewportOrgEx(_hDC, 0, 0, NULL);
  687.   SetWindowOrgEx(_hDC, 0, 0, NULL);
  688.   HDC hSrcDC = CreateCompatibleDC(_hDC);
  689.   HGDIOBJ oldBitmap = SelectObject(PAssertNULL(hSrcDC), icn.GetHBITMAP());
  690.   BITMAP bm;
  691.   GetObject(icn.GetHBITMAP(), sizeof(bm), (LPSTR)&bm);
  692.   PAssertOS(BitBlt(_hDC,
  693.                    ToPixelsX(x), ToPixelsY(y),
  694.                    (int)bm.bmWidth, (int)bm.bmHeight,
  695.                    hSrcDC, 0, 0, SRCCOPY));
  696.   SelectObject(hSrcDC, oldBitmap);
  697.   DeleteDC(hSrcDC);
  698.   SetMapMode(_hDC, MM_ANISOTROPIC);
  699.   SetTransform();
  700. }
  703. void PCanvas::DrawIcon(PORDINATE x, PORDINATE y, const PIcon & icn)
  704. {
  705.   ::DrawIcon(GetHDC(), x, y, icn.GetHICON());
  706. }
  709. void PCanvas::DrawPixels(PORDINATE x, PORDINATE y, const PPixelImage & pix)
  710. {
  711.   if (pix->GetPixelDataPtr() != NULL) {
  712.     SetUpDrawModes(fillMode, fillFgColour, fillBkColour, NULL, -1);
  713.     RealizePalette(_hDC);
  714.     PPixelBase::DIBInfo dib(*pix, palette.GetHPALETTE());
  715.     SetDIBitsToDevice(_hDC,
  716.                       x, y, dib.Width(), dib.Height(),
  717.                       0, 0, 0, dib.Height(),
  718.                       pix->GetPixelDataPtr(), dib, dib.Usage());
  719.   }
  720. }
  723. void PCanvas::DrawPixels(const PRect & rect, const PPixelImage & pix)
  724. {
  725.   if (pix->GetPixelDataPtr() != NULL) {
  726.     SetUpDrawModes(fillMode, fillFgColour, fillBkColour, NULL, -1);
  727.     RealizePalette(_hDC);
  728.     PPixelBase::DIBInfo dib(*pix, palette.GetHPALETTE());
  729.     StretchDIBits(_hDC,
  730.                   rect.X(), rect.Y(), rect.Width(), rect.Height(),
  731.                   0, 0, dib.Width(), dib.Height(),
  732.                   pix->GetPixelDataPtr(), dib, dib.Usage(), SRCCOPY);
  733.   }
  734. }
  737. void PCanvas::DrawPict(PORDINATE x, PORDINATE y, const PPictImage & pic)
  738. {
  739.   POINT org;
  740.   SetWindowOrgEx(_hDC, x, y, &org);
  741. #if defined(_WIN32)
  742.   PlayEnhMetaFile(GetHDC(), pic->GetMETAFILE(), NULL);
  743. #else
  744.   PlayMetaFile(GetHDC(), pic->GetMETAFILE());
  745. #endif
  746.   SetWindowOrgEx(_hDC, (int)org.x, (int)org.y, NULL);
  747. }
  750. void PCanvas::DrawPict(const PRect & rect, const PPictImage & pic)
  751. {
  752. #if defined(_WIN32)
  753.   PlayEnhMetaFile(GetHDC(), pic->GetMETAFILE(), rect);
  754. #else
  755.   POINT org;
  756.   SIZE ext;
  757.   SetWindowOrgEx(_hDC, rect.X(), rect.Y(), &org);
  758.   SetWindowExtEx(_hDC, rect.Width(), rect.Height(), &ext);
  759.   PlayMetaFile(GetHDC(), pic->GetMETAFILE());
  760.   SetWindowOrgEx(_hDC, (int)org.x, (int)org.y, NULL);
  761.   SetWindowExtEx(_hDC, (int)ext.cx, (int)ext.cy, NULL);
  762. #endif
  763. }
  766. void PCanvas::DrawString(PORDINATE x, PORDINATE y,
  767.                                               const PString & str, int options)
  768. {
  769.   SetUpDrawModes(SrcCopy, textFgColour, textBkColour, NULL, -1);
  771.   PDim dim;
  772.   switch (options&VerticalAlignmentMask) {
  773.     case BottomAlign :
  774.       if (dim.Height() == 0)
  775.         dim = MeasureString(str);
  776.       y -= dim.Height();
  777.       break;
  779.     case CentreVertical :
  780.       if (dim.Height() == 0)
  781.         dim = MeasureString(str);
  782.       y -= dim.Height()/2;
  783.       break;
  785.     case BaseLine :
  786.       y -= FromPointsY(realFont.GetAscent());
  787.   }
  789.   switch (options&HorizontalAlignmentMask) {
  790.     case RightAlign :
  791.       if (dim.Width() == 0)
  792.         dim = MeasureString(str);
  793.       x -= dim.Width();
  794.       break;
  796.     case Centred :
  797.       if (dim.Width() == 0)
  798.         dim = MeasureString(str);
  799.       x -= dim.Width()/2;
  800.   }
  802.   if (str.FindOneOf("rn") == P_MAX_INDEX)
  803.     TabbedTextOut(GetHDC(), x, y, str, str.GetLength(), 0, NULL, 0);
  804.   else {
  805.     PRect r(x, y, 10000, 10000);
  806.     DrawText(GetHDC(), str, -1, r,
  807.                  DT_LEFT|DT_TOP|DT_NOPREFIX|DT_EXPANDTABS|DT_EXTERNALLEADING);
  808.   }
  809. }
  812. PDim PCanvas::MeasureString(const PString & str)
  813. {
  814.   PDim dim;
  815.   if (str.FindOneOf("rn") == P_MAX_INDEX)
  816.     dim = PDim::FromDWORD(GetTabbedTextExtent(GetHDC(),
  817.                                               str, str.GetLength(), 0, NULL));
  818.   else {
  819.     PStringArray lines = str.Lines();
  820.     for (PINDEX line = 0; line < lines.GetSize(); line++) {
  821.       DWORD lineDim = GetTabbedTextExtent(GetHDC(),
  822.                                     lines[line], lines[line].GetLength(), 0, NULL);
  823.       if (dim.Width() < (PDIMENSION)LOWORD(lineDim))
  824.         dim.SetWidth(LOWORD(lineDim));
  825.       dim.SetHeight(dim.Height() + HIWORD(lineDim));
  826.     }
  827.   }
  828.   return dim;
  829. }
  832. void PCanvas::DrawTextLine(PORDINATE x, PORDINATE y,
  833.                            const char * textChars,
  834.                            const PDIMENSION * charWidths,
  835.                            PINDEX len)
  836. {
  837.   SetUpDrawModes(SrcCopy, textFgColour, textBkColour, NULL, -1);
  838.   PRect rect(x, y, 1, 1);
  839.   ExtTextOut(_hDC, x, y, 0, rect, textChars, len, (LPINT)charWidths);
  840. }
  843. HGDIOBJ PCanvas::SetUpDrawModes(DrawingModes mode,
  844.                                 const PColour & fg, const PColour & bg,
  845.                                 HGDIOBJ restoreObj, int saveObj)
  846. {
  847.   if (restoreObj)
  848.     SelectObject(GetHDC(), restoreObj);
  850.   static int modeTable[] = {
  851.     R2_COPYPEN, R2_NOTCOPYPEN,
  852.     R2_MASKPEN, R2_MASKNOTPEN, R2_MASKPENNOT, R2_NOTMASKPEN,
  853.     R2_MERGEPEN, R2_MERGENOTPEN, R2_MERGEPENNOT, R2_NOTMERGEPEN,
  854.     R2_XORPEN, R2_NOTXORPEN,
  855.     R2_NOT, R2_NOP
  856.   };
  857.   PAssert(mode < PARRAYSIZE(modeTable), PInvalidParameter);
  858.   SetROP2(GetHDC(), modeTable[mode]);
  860.   SetTextColor(_hDC, fg.ToCOLORREF());
  861.   SetBkColor(_hDC, bg.ToCOLORREF());
  862.   SetBkMode(_hDC, bg.GetAlpha() == 0 ? TRANSPARENT : OPAQUE);
  864.   return saveObj < 0 ? NULL : SelectObject(_hDC, GetStockObject(saveObj));
  865. }
  868. void PCanvas::SetClipRect(const PRect & rect)
  869. {
  870.   PRegion rgn = ToPixels(rect);
  871.   SelectClipRgn(GetHDC(), rgn.GetHRGN());
  872. }
  875. PRect PCanvas::GetClipRect() const
  876. {
  877.   PRect r;
  878.   GetClipBox(GetHDC(), r);
  879.   return r;
  880. }
  883. void PCanvas::SetClipRegion(const PRegion & rgn)
  884. {
  885.   SelectClipRgn(GetHDC(), rgn.GetHRGN());
  886. }
  889. PRegion PCanvas::GetClipRegion() const
  890. {
  891. #if defined(_WIN32)
  892.   PRegion rgn;
  893.   GetClipRgn(GetHDC(), rgn.GetHRGN());
  894.   return rgn;
  895. #else
  896.   PRect r;
  897.   GetClipBox(GetHDC(), r);
  898.   return r;
  899. #endif
  900. }
  903. PRect PCanvas::GetDrawingBounds() const
  904. {
  905.   return FromPixels(PRect(0, 0, (PDIMENSION)GetDeviceCaps(_hDC,HORZRES),
  906.                                        (PDIMENSION)GetDeviceCaps(_hDC,VERTRES)));
  907. }
  910. PRect PCanvas::GetPhysicalBounds(BOOL inPixels) const
  911. {
  912.   if (inPixels)
  913.     return PRect(0, 0, (PDIMENSION)GetDeviceCaps(_hDC,HORZRES),
  914.                                         (PDIMENSION)GetDeviceCaps(_hDC,VERTRES));
  915.   else
  916.     return PRect(0, 0, (PDIMENSION)GetDeviceCaps(_hDC,HORZSIZE),
  917.                                         (PDIMENSION)GetDeviceCaps(_hDC,VERTSIZE));
  918. }
  921. //////////////////////////////////////////////////////////////////////////////
  924. PRect PInteractorCanvas::GetDrawingBounds() const
  925. {
  926.   return FromPixels(interactor->GetDrawingBounds(PInteractor::PixelCoords));
  927. }
  930. //////////////////////////////////////////////////////////////////////////////
  933. PDrawCanvas::PDrawCanvas(PInteractor * theInteractor,
  934.                                      BOOL inPixels, BOOL overDrawChildWindows)
  935.   : PInteractorCanvas(theInteractor, inPixels)
  936. {
  937.   if (overDrawChildWindows)
  938.     SetWindowLong(interactor->GetHWND(), GWL_STYLE,
  939.             GetWindowLong(interactor->GetHWND(), GWL_STYLE)&~WS_CLIPCHILDREN);
  941.   Construct(inPixels);
  942.   SetHDC(GetDC(interactor->GetHWND()));
  943.   deleteDC = TRUE;
  944. }
  947. PDrawCanvas::PDrawCanvas(PInteractor * theInteractor,
  948.                                      HDC newDC, BOOL autoDelete, BOOL inPixels)
  949.   : PInteractorCanvas(theInteractor, inPixels)
  950. {
  951.   Construct(inPixels);
  952.   preAllocatedDC = newDC;
  953.   deleteDC = autoDelete;
  954. }
  957. PDrawCanvas::~PDrawCanvas()
  958. {
  959.   if (_hDC == NULL)
  960.     return;
  962.   if (deleteDC) {
  963.     PAssertOS(ReleaseDC(interactor->GetHWND(), _hDC));
  964.     SetWindowLong(interactor->GetHWND(), GWL_STYLE,
  965.              GetWindowLong(interactor->GetHWND(), GWL_STYLE)|WS_CLIPCHILDREN);
  966.   }
  967.   else {
  968.     SelectObject(_hDC, GetStockObject(BLACK_PEN));
  969.     SelectObject(_hDC, GetStockObject(WHITE_BRUSH));
  970.     SelectObject(_hDC, GetStockObject(SYSTEM_FONT));
  971.     SelectPalette(_hDC, (HPALETTE)GetStockObject(DEFAULT_PALETTE), FALSE);
  972.   }
  973.   _hDC = NULL;
  974. }
  977. HDC PDrawCanvas::GetHDC() const
  978. {
  979.   if (_hDC == NULL)
  980.     ((PDrawCanvas*)this)->SetHDC(preAllocatedDC);
  981.   return _hDC;
  982. }
  985. //////////////////////////////////////////////////////////////////////////////
  988. PRedrawCanvas::PRedrawCanvas(PInteractor * theInteractor, BOOL inPixels)
  989.   : PInteractorCanvas(theInteractor, inPixels)
  990. {
  991.   Construct(inPixels);
  992.   SetHDC(GetDC(interactor->GetHWND()));
  993.   PAssertOS(ReleaseDC(interactor->GetHWND(), _hDC));
  994.   paint.hdc = _hDC = NULL;
  995. }
  998. PRedrawCanvas::~PRedrawCanvas()
  999. {
  1000.   if (paint.hdc != NULL)
  1001.     EndPaint(interactor->GetHWND(), &paint);
  1002.   else if (_hDC != NULL)
  1003.     PAssertOS(ReleaseDC(interactor->GetHWND(), _hDC));
  1004.   _hDC = NULL;
  1005. }
  1008. HDC PRedrawCanvas::GetHDC() const
  1009. {
  1010.   if (_hDC == NULL)
  1011.     ((PRedrawCanvas*)this)->SetHDC(
  1012.            BeginPaint(interactor->GetHWND(), &((PRedrawCanvas*)this)->paint));
  1013.   return _hDC;
  1014. }
  1017. //////////////////////////////////////////////////////////////////////////////
  1020. PPrintCanvas::~PPrintCanvas()
  1021. {
  1022.   if (_hDC != NULL) {
  1023.     PAssertOS(EndPage(_hDC) > 0);
  1024.     EndDoc(_hDC);
  1025.   }
  1026. }
  1029. void PPrintCanvas::Construct()
  1030. {
  1031.   HDC newDC = CreateDC(printInfo.GetDriver(),
  1032.                        printInfo.GetPrinter(),
  1033.                        printInfo.GetDevice(),
  1034.                        printInfo.GetDEVMODE());
  1036.   DOCINFO docInfo;
  1037.   memset(&docInfo, 0, sizeof(docInfo));
  1038.   docInfo.cbSize = sizeof(docInfo);
  1039.   docInfo.lpszDocName = jobName;
  1040.   StartDoc(newDC, &docInfo);
  1042.   if (StartPage(newDC) < 0)
  1043.     DeleteDC(newDC);
  1044.   else
  1045.     SetHDC(newDC);
  1046. }
  1049. BOOL PPrintCanvas::NewPage()
  1050. {
  1051.   if (EndPage(GetHDC()) > 0) {
  1052.     if (StartPage(_hDC) > 0) {
  1053.       SetHDC(_hDC);
  1054.       return TRUE;
  1055.     }
  1056.   }
  1058.   return FALSE;
  1059. }
  1062. //////////////////////////////////////////////////////////////////////////////
  1065. void PMemoryCanvas::Construct()
  1066. {
  1067.   SetHDC(image->CreateImageDC());
  1068. }
  1071. // End Of File ///////////////////////////////////////////////////////////////