canvas.cxx

windows mobile phone source code

    case 5 :
      return PPoint(sine[90-angle], 1000);

    case 6 :
      return PPoint(sine[90-angle], 1000);

    case 7 :
      return PPoint(1000, sine[angle]);
  }
}


void PCanvas::DrawArc(const PRect & rect, int startAngle, int endAngle)
{
  DrawArc(rect, PointFromAngle(startAngle), PointFromAngle(endAngle));
}


void PCanvas::DrawPie(const PRect & rect,
                                  const PPoint & startPt, const PPoint & endPt)
{
  if (penMode == fillMode) {
    SetUpDrawModes(fillMode, fillFgColour, fillBkColour, NULL, -1);
    Pie(GetHDC(), rect.Left(), rect.Top(), rect.Right(), rect.Bottom(),
                               startPt.X(), startPt.Y(), endPt.X(), endPt.Y());
  }
  else {
    HGDIOBJ oldBrush =
           SetUpDrawModes(penMode, penFgColour, penBkColour, NULL, NULL_BRUSH);
    Pie(GetHDC(), rect.Left(), rect.Top(), rect.Right(), rect.Bottom(),
                               startPt.X(), startPt.Y(), endPt.X(), endPt.Y());
    HGDIOBJ oldPen =
      SetUpDrawModes(fillMode, fillFgColour, fillBkColour, oldBrush, NULL_PEN);
    Pie(GetHDC(), rect.Left(), rect.Top(), rect.Right(), rect.Bottom(),
                               startPt.X(), startPt.Y(), endPt.X(), endPt.Y());
    SelectObject(_hDC, oldPen);
  }
}


void PCanvas::DrawPie(const PRect & rect, int startAngle, int endAngle)
{
  DrawPie(rect, PointFromAngle(startAngle), PointFromAngle(endAngle));
}


void PCanvas::DrawChord(const PRect & rect,
                                  const PPoint & startPt, const PPoint & endPt)
{
  if (penMode == fillMode) {
    SetUpDrawModes(fillMode, fillFgColour, fillBkColour, NULL, -1);
    Chord(GetHDC(), rect.Left(), rect.Top(), rect.Right(), rect.Bottom(),
                               startPt.X(), startPt.Y(), endPt.X(), endPt.Y());
  }
  else {
    HGDIOBJ oldBrush =
           SetUpDrawModes(penMode, penFgColour, penBkColour, NULL, NULL_BRUSH);
    Chord(GetHDC(), rect.Left(), rect.Top(), rect.Right(), rect.Bottom(),
                               startPt.X(), startPt.Y(), endPt.X(), endPt.Y());
    HGDIOBJ oldPen =
      SetUpDrawModes(fillMode, fillFgColour, fillBkColour, oldBrush, NULL_PEN);
    Chord(GetHDC(), rect.Left(), rect.Top(), rect.Right(), rect.Bottom(),
                               startPt.X(), startPt.Y(), endPt.X(), endPt.Y());
    SelectObject(_hDC, oldPen);
  }
}


void PCanvas::DrawChord(const PRect & rect, int startAngle, int endAngle)
{
  DrawChord(rect, PointFromAngle(startAngle), PointFromAngle(endAngle));
}


void PCanvas::DrawPolyLine(const PPointArray & ptArray)
{
  DrawPolyLine(MakePOINTArray(ptArray), ptArray.GetSize());
}


void PCanvas::DrawPolyLine(const PPoint * ptArray, PINDEX numPts)
{
  DrawPolyLine(MakePOINTArray(ptArray, numPts), numPts);
}


void PCanvas::DrawPolyLine(LPPOINT ptArray, PINDEX numPts)
{
  SetUpDrawModes(penMode, penFgColour, penBkColour, NULL, -1);
  Polyline(GetHDC(), ptArray, numPts);
  delete [] ptArray;
}


void PCanvas::DrawPolygon(const PPointArray & ptArray)
{
  DrawPolygon(MakePOINTArray(ptArray), ptArray.GetSize());
}


void PCanvas::DrawPolygon(const PPoint * ptArray, PINDEX numPts)
{
  DrawPolygon(MakePOINTArray(ptArray, numPts), numPts);
}


void PCanvas::DrawPolygon(LPPOINT ptArray, PINDEX numPts)
{
  if (penMode == fillMode) {
    SetUpDrawModes(fillMode, fillFgColour, fillBkColour, NULL, -1);
    Polygon(GetHDC(), ptArray, numPts);
  }
  else {
    HGDIOBJ oldBrush =
           SetUpDrawModes(penMode, penFgColour, penBkColour, NULL, NULL_BRUSH);
    Polygon(GetHDC(), ptArray, numPts);
    HGDIOBJ oldPen =
      SetUpDrawModes(fillMode, fillFgColour, fillBkColour, oldBrush, NULL_PEN);
    Polygon(GetHDC(), ptArray, numPts);
    SelectObject(_hDC, oldPen);
  }
  delete [] ptArray;
}


LPPOINT PCanvas::MakePOINTArray(const PPointArray & ptArray)
{
  PINDEX size = ptArray.GetSize();
  LPPOINT pa = new POINT[size];
  for (PINDEX i = 0; i < size; i++)
    pa[i] = *(LPPOINT)ptArray[i];
  return pa;
}


LPPOINT PCanvas::MakePOINTArray(const PPoint * ptArray, PINDEX numPts)
{
  LPPOINT pa = new POINT[numPts];
  for (PINDEX i = 0; i < numPts; i++)
    pa[i] = *(const POINT *)ptArray[i];
  return pa;
}


void PCanvas::DrawImgIcon(PORDINATE x, PORDINATE y, const PImgIcon & icn)
{
  SetUpDrawModes(fillMode, fillFgColour, fillBkColour, NULL, -1);
  SetMapMode(_hDC, MM_TEXT);
  SetViewportOrgEx(_hDC, 0, 0, NULL);
  SetWindowOrgEx(_hDC, 0, 0, NULL);
  HDC hSrcDC = CreateCompatibleDC(_hDC);
  HGDIOBJ oldBitmap = SelectObject(PAssertNULL(hSrcDC), icn.GetHBITMAP());
  BITMAP bm;
  GetObject(icn.GetHBITMAP(), sizeof(bm), (LPSTR)&bm);
  PAssertOS(BitBlt(_hDC,
                   ToPixelsX(x), ToPixelsY(y),
                   (int)bm.bmWidth, (int)bm.bmHeight,
                   hSrcDC, 0, 0, SRCCOPY));
  SelectObject(hSrcDC, oldBitmap);
  DeleteDC(hSrcDC);
  SetMapMode(_hDC, MM_ANISOTROPIC);
  SetTransform();
}


void PCanvas::DrawIcon(PORDINATE x, PORDINATE y, const PIcon & icn)
{
  ::DrawIcon(GetHDC(), x, y, icn.GetHICON());
}


void PCanvas::DrawPixels(PORDINATE x, PORDINATE y, const PPixelImage & pix)
{
  if (pix->GetPixelDataPtr() != NULL) {
    SetUpDrawModes(fillMode, fillFgColour, fillBkColour, NULL, -1);
    RealizePalette(_hDC);
    PPixelBase::DIBInfo dib(*pix, palette.GetHPALETTE());
    SetDIBitsToDevice(_hDC,
                      x, y, dib.Width(), dib.Height(),
                      0, 0, 0, dib.Height(),
                      pix->GetPixelDataPtr(), dib, dib.Usage());
  }
}


void PCanvas::DrawPixels(const PRect & rect, const PPixelImage & pix)
{
  if (pix->GetPixelDataPtr() != NULL) {
    SetUpDrawModes(fillMode, fillFgColour, fillBkColour, NULL, -1);
    RealizePalette(_hDC);
    PPixelBase::DIBInfo dib(*pix, palette.GetHPALETTE());
    StretchDIBits(_hDC,
                  rect.X(), rect.Y(), rect.Width(), rect.Height(),
                  0, 0, dib.Width(), dib.Height(),
                  pix->GetPixelDataPtr(), dib, dib.Usage(), SRCCOPY);
  }
}


void PCanvas::DrawPict(PORDINATE x, PORDINATE y, const PPictImage & pic)
{
  POINT org;
  SetWindowOrgEx(_hDC, x, y, &org);
#if defined(_WIN32)
  PlayEnhMetaFile(GetHDC(), pic->GetMETAFILE(), NULL);
#else
  PlayMetaFile(GetHDC(), pic->GetMETAFILE());
#endif
  SetWindowOrgEx(_hDC, (int)org.x, (int)org.y, NULL);
}


void PCanvas::DrawPict(const PRect & rect, const PPictImage & pic)
{
#if defined(_WIN32)
  PlayEnhMetaFile(GetHDC(), pic->GetMETAFILE(), rect);
#else
  POINT org;
  SIZE ext;
  SetWindowOrgEx(_hDC, rect.X(), rect.Y(), &org);
  SetWindowExtEx(_hDC, rect.Width(), rect.Height(), &ext);
  PlayMetaFile(GetHDC(), pic->GetMETAFILE());
  SetWindowOrgEx(_hDC, (int)org.x, (int)org.y, NULL);
  SetWindowExtEx(_hDC, (int)ext.cx, (int)ext.cy, NULL);
#endif
}


void PCanvas::DrawString(PORDINATE x, PORDINATE y,
                                              const PString & str, int options)
{
  SetUpDrawModes(SrcCopy, textFgColour, textBkColour, NULL, -1);

  PDim dim;
  switch (options&VerticalAlignmentMask) {
    case BottomAlign :
      if (dim.Height() == 0)
        dim = MeasureString(str);
      y -= dim.Height();
      break;

    case CentreVertical :
      if (dim.Height() == 0)
        dim = MeasureString(str);
      y -= dim.Height()/2;
      break;

    case BaseLine :
      y -= FromPointsY(realFont.GetAscent());
  }

  switch (options&HorizontalAlignmentMask) {
    case RightAlign :
      if (dim.Width() == 0)
        dim = MeasureString(str);
      x -= dim.Width();
      break;

    case Centred :
      if (dim.Width() == 0)
        dim = MeasureString(str);
      x -= dim.Width()/2;
  }

  if (str.FindOneOf("\r\n") == P_MAX_INDEX)
    TabbedTextOut(GetHDC(), x, y, str, str.GetLength(), 0, NULL, 0);
  else {
    PRect r(x, y, 10000, 10000);
    DrawText(GetHDC(), str, -1, r,
                 DT_LEFT|DT_TOP|DT_NOPREFIX|DT_EXPANDTABS|DT_EXTERNALLEADING);
  }
}


PDim PCanvas::MeasureString(const PString & str)
{
  PDim dim;
  if (str.FindOneOf("\r\n") == P_MAX_INDEX)
    dim = PDim::FromDWORD(GetTabbedTextExtent(GetHDC(),
                                              str, str.GetLength(), 0, NULL));
  else {
    PStringArray lines = str.Lines();
    for (PINDEX line = 0; line < lines.GetSize(); line++) {
      DWORD lineDim = GetTabbedTextExtent(GetHDC(),
                                    lines[line], lines[line].GetLength(), 0, NULL);
      if (dim.Width() < (PDIMENSION)LOWORD(lineDim))
        dim.SetWidth(LOWORD(lineDim));
      dim.SetHeight(dim.Height() + HIWORD(lineDim));
    }
  }
  return dim;
}


void PCanvas::DrawTextLine(PORDINATE x, PORDINATE y,
                           const char * textChars,
                           const PDIMENSION * charWidths,
                           PINDEX len)
{
  SetUpDrawModes(SrcCopy, textFgColour, textBkColour, NULL, -1);
  PRect rect(x, y, 1, 1);
  ExtTextOut(_hDC, x, y, 0, rect, textChars, len, (LPINT)charWidths);
}


HGDIOBJ PCanvas::SetUpDrawModes(DrawingModes mode,
                                const PColour & fg, const PColour & bg,
                                HGDIOBJ restoreObj, int saveObj)
{
  if (restoreObj)
    SelectObject(GetHDC(), restoreObj);

  static int modeTable[] = {
    R2_COPYPEN, R2_NOTCOPYPEN,
    R2_MASKPEN, R2_MASKNOTPEN, R2_MASKPENNOT, R2_NOTMASKPEN,
    R2_MERGEPEN, R2_MERGENOTPEN, R2_MERGEPENNOT, R2_NOTMERGEPEN,
    R2_XORPEN, R2_NOTXORPEN,
    R2_NOT, R2_NOP
  };
  PAssert(mode < PARRAYSIZE(modeTable), PInvalidParameter);
  SetROP2(GetHDC(), modeTable[mode]);

  SetTextColor(_hDC, fg.ToCOLORREF());
  SetBkColor(_hDC, bg.ToCOLORREF());
  SetBkMode(_hDC, bg.GetAlpha() == 0 ? TRANSPARENT : OPAQUE);

  return saveObj < 0 ? NULL : SelectObject(_hDC, GetStockObject(saveObj));
}


void PCanvas::SetClipRect(const PRect & rect)
{
  PRegion rgn = ToPixels(rect);
  SelectClipRgn(GetHDC(), rgn.GetHRGN());
}


PRect PCanvas::GetClipRect() const
{
  PRect r;
  GetClipBox(GetHDC(), r);
  return r;
}


void PCanvas::SetClipRegion(const PRegion & rgn)
{
  SelectClipRgn(GetHDC(), rgn.GetHRGN());
}


PRegion PCanvas::GetClipRegion() const
{
#if defined(_WIN32)
  PRegion rgn;
  GetClipRgn(GetHDC(), rgn.GetHRGN());
  return rgn;
#else
  PRect r;
  GetClipBox(GetHDC(), r);
  return r;
#endif
}


PRect PCanvas::GetDrawingBounds() const
{
  return FromPixels(PRect(0, 0, (PDIMENSION)GetDeviceCaps(_hDC,HORZRES),
                                       (PDIMENSION)GetDeviceCaps(_hDC,VERTRES)));
}


PRect PCanvas::GetPhysicalBounds(BOOL inPixels) const
{
  if (inPixels)
    return PRect(0, 0, (PDIMENSION)GetDeviceCaps(_hDC,HORZRES),
                                        (PDIMENSION)GetDeviceCaps(_hDC,VERTRES));
  else
    return PRect(0, 0, (PDIMENSION)GetDeviceCaps(_hDC,HORZSIZE),
                                        (PDIMENSION)GetDeviceCaps(_hDC,VERTSIZE));
}


//////////////////////////////////////////////////////////////////////////////


PRect PInteractorCanvas::GetDrawingBounds() const
{
  return FromPixels(interactor->GetDrawingBounds(PInteractor::PixelCoords));
}


//////////////////////////////////////////////////////////////////////////////


PDrawCanvas::PDrawCanvas(PInteractor * theInteractor,
                                     BOOL inPixels, BOOL overDrawChildWindows)
  : PInteractorCanvas(theInteractor, inPixels)
{
  if (overDrawChildWindows)
    SetWindowLong(interactor->GetHWND(), GWL_STYLE,
            GetWindowLong(interactor->GetHWND(), GWL_STYLE)&~WS_CLIPCHILDREN);

  Construct(inPixels);
  SetHDC(GetDC(interactor->GetHWND()));
  deleteDC = TRUE;
}


PDrawCanvas::PDrawCanvas(PInteractor * theInteractor,
                                     HDC newDC, BOOL autoDelete, BOOL inPixels)
  : PInteractorCanvas(theInteractor, inPixels)
{
  Construct(inPixels);
  preAllocatedDC = newDC;
  deleteDC = autoDelete;
}


PDrawCanvas::~PDrawCanvas()
{
  if (_hDC == NULL)
    return;

  if (deleteDC) {
    PAssertOS(ReleaseDC(interactor->GetHWND(), _hDC));
    SetWindowLong(interactor->GetHWND(), GWL_STYLE,
             GetWindowLong(interactor->GetHWND(), GWL_STYLE)|WS_CLIPCHILDREN);
  }
  else {
    SelectObject(_hDC, GetStockObject(BLACK_PEN));
    SelectObject(_hDC, GetStockObject(WHITE_BRUSH));
    SelectObject(_hDC, GetStockObject(SYSTEM_FONT));
    SelectPalette(_hDC, (HPALETTE)GetStockObject(DEFAULT_PALETTE), FALSE);
  }
  _hDC = NULL;
}


HDC PDrawCanvas::GetHDC() const
{
  if (_hDC == NULL)
    ((PDrawCanvas*)this)->SetHDC(preAllocatedDC);
  return _hDC;
}


//////////////////////////////////////////////////////////////////////////////


PRedrawCanvas::PRedrawCanvas(PInteractor * theInteractor, BOOL inPixels)
  : PInteractorCanvas(theInteractor, inPixels)
{
  Construct(inPixels);
  SetHDC(GetDC(interactor->GetHWND()));
  PAssertOS(ReleaseDC(interactor->GetHWND(), _hDC));
  paint.hdc = _hDC = NULL;
}


PRedrawCanvas::~PRedrawCanvas()
{
  if (paint.hdc != NULL)
    EndPaint(interactor->GetHWND(), &paint);
  else if (_hDC != NULL)
    PAssertOS(ReleaseDC(interactor->GetHWND(), _hDC));
  _hDC = NULL;
}


HDC PRedrawCanvas::GetHDC() const
{
  if (_hDC == NULL)
    ((PRedrawCanvas*)this)->SetHDC(
           BeginPaint(interactor->GetHWND(), &((PRedrawCanvas*)this)->paint));
  return _hDC;
}


//////////////////////////////////////////////////////////////////////////////


PPrintCanvas::~PPrintCanvas()
{
  if (_hDC != NULL) {
    PAssertOS(EndPage(_hDC) > 0);
    EndDoc(_hDC);
  }
}


void PPrintCanvas::Construct()
{
  HDC newDC = CreateDC(printInfo.GetDriver(),
                       printInfo.GetPrinter(),
                       printInfo.GetDevice(),
                       printInfo.GetDEVMODE());

  DOCINFO docInfo;
  memset(&docInfo, 0, sizeof(docInfo));
  docInfo.cbSize = sizeof(docInfo);
  docInfo.lpszDocName = jobName;
  StartDoc(newDC, &docInfo);

  if (StartPage(newDC) < 0)
    DeleteDC(newDC);
  else
    SetHDC(newDC);
}


BOOL PPrintCanvas::NewPage()
{
  if (EndPage(GetHDC()) > 0) {
    if (StartPage(_hDC) > 0) {
      SetHDC(_hDC);
      return TRUE;
    }
  }

  return FALSE;
}


//////////////////////////////////////////////////////////////////////////////


void PMemoryCanvas::Construct()
{
  SetHDC(image->CreateImageDC());
}


// End Of File ///////////////////////////////////////////////////////////////