pwlib.inl

windows mobile phone source code

                       component[GreenComponent], component[BlueComponent]); }

PINLINE PColour & PColour::FromSYSCOLOR(int syscol)
  { return FromCOLORREF(GetSysColor(syscol)); }


//////////////////////////////////////////////////////////////////////////////
// PRealColour

PINLINE PObject * PRealColour::Clone() const
  { return new PRealColour(ToCOLORREF()); }

PINLINE PRealColour::PRealColour(COLORREF col)
  { FromCOLORREF(col); }


//////////////////////////////////////////////////////////////////////////////
// PPalette

PINLINE void PPalette::CopyContents(const PPalette & pal)
  { hPalette = pal.hPalette; }

PINLINE HPALETTE PPalette::GetHPALETTE() const
  { return hPalette; }


//////////////////////////////////////////////////////////////////////////////
// PCanvas

PINLINE void PCanvas::DrawFocusRect(const PRect & rect)
  { ::DrawFocusRect(GetHDC(), rect); }


PINLINE void PCanvas::SetCurrentPosition(PORDINATE x, PORDINATE y)
  { MoveToEx(GetHDC(), x, y, NULL); }

PINLINE BOOL PCanvas::IsInClipRegion(const PPoint & pt) const
  { return PtVisible(GetHDC(), pt.X(), pt.Y()); }

PINLINE BOOL PCanvas::IsInClipRegion(const PRect & rect) const
  { return RectVisible(GetHDC(), rect); }


PINLINE HDC PCanvas::GetHDC() const
  { return PAssertNULL(_hDC); }

PINLINE BOOL PCanvas::NullHDC() const
  { return _hDC == NULL; }


//////////////////////////////////////////////////////////////////////////////
// PInteractorCanvas

PINLINE PInteractorCanvas::PInteractorCanvas(PInteractor * theInteractor,BOOL)
  : interactor(theInteractor) { }

PINLINE PInteractorCanvas::~PInteractorCanvas()
  { }


PINLINE void PInteractorCanvas::Scroll(PORDINATE dx,
                                                PORDINATE dy, const PRect & rect)
  { PAssertOS(ScrollDC(GetHDC(), dx, dy, rect, rect, NULL, NULL)); }

PINLINE void PInteractorCanvas::Copy(const PRect & srcRect,
                                                PCanvas & dst, const PPoint & pt)
  { PAssertOS(BitBlt(dst.GetHDC(),
              pt.X(), pt.Y(), srcRect.Width(), srcRect.Height(), GetHDC(),
              srcRect.Left(), srcRect.Top(), SRCCOPY)); }

PINLINE void PInteractorCanvas::Copy(const PRect & srcRect,
                                           PCanvas & dst, const PRect & dstRect)
  { PAssertOS(StretchBlt(dst.GetHDC(),
      dstRect.X(), dstRect.Y(), dstRect.Width(), dstRect.Height(), GetHDC(),
      srcRect.X(), srcRect.Y(), srcRect.Width(), srcRect.Height(), SRCCOPY)); }


//////////////////////////////////////////////////////////////////////////////
// PPixels

PINLINE BYTE PPixelBase::GetDepth() const
  { return (BYTE)info.biBitCount; }



//////////////////////////////////////////////////////////////////////////////
// PPict

PINLINE PMETAFILE PPictBase::GetMETAFILE() const
  { return hMetafile; }


//////////////////////////////////////////////////////////////////////////////
// PPattern

PINLINE PDim PPattern::GetDimensions() const
  { return PDim((PDIMENSION)bitmap.bmWidth, (PDIMENSION)bitmap.bmHeight); }


PINLINE HBITMAP PPattern::GetHBITMAP() const
  { return hBitmap; }


//////////////////////////////////////////////////////////////////////////////
// PCursor

PINLINE PCursor::PCursor()
  { hCursor = LoadCursor(NULL, IDC_ARROW); deleteCursor = FALSE; }

PINLINE HCURSOR PCursor::GetHCURSOR() const
  { return hCursor; }


//////////////////////////////////////////////////////////////////////////////
// PCaret

PINLINE PCaret::PCaret()
  { activeWindow = NULL; }

PINLINE PCaret::PCaret(const PDim & dim)
  : caretSize(dim) { activeWindow = NULL; }

PINLINE PCaret::PCaret(PDIMENSION dx, PDIMENSION dy)
  : caretSize(dx, dy) { activeWindow = NULL; }


//////////////////////////////////////////////////////////////////////////////
// PImgIcon

PINLINE PImgIcon::PImgIcon()
  { hBitmap = NULL; }

PINLINE PImgIcon::PImgIcon(HBITMAP hBits)
  { hBitmap = hBits; }

PINLINE HBITMAP PImgIcon::GetHBITMAP() const
  { return hBitmap; }

PINLINE void PImgIcon::CopyContents(const PImgIcon & icon)
  { hBitmap = icon.hBitmap; }


//////////////////////////////////////////////////////////////////////////////
// PIcon

PINLINE PIcon::PIcon(HICON hIcn)
  : PImgIcon((HBITMAP)NULL), deleteIcon(FALSE) { hIcon = hIcn; }

PINLINE HICON PIcon::GetHICON() const
  { return hIcon; }


//////////////////////////////////////////////////////////////////////////////
// PInteractor

PINLINE PInteractor::PInteractor()
  { Construct(NULL, NULL, TRUE); }

PINLINE PInteractor::PInteractor(PInteractor * par, BOOL hiddenChild)
  { Construct(PAssertNULL(par), NULL, hiddenChild); }

PINLINE PInteractor::PInteractor(PInteractor * par, HWND hWnd)
  { Construct(PAssertNULL(par), hWnd, FALSE); }


PINLINE void PInteractor::Enable(BOOL enabled)
  { EnableWindow(GetHWND(), enabled); }

PINLINE BOOL PInteractor::IsEnabled() const
  { return IsWindowEnabled(GetHWND()); }

PINLINE void PInteractor::Show(BOOL visible)
  { ShowWindow(GetHWND(), visible ? SW_SHOW : SW_HIDE); }

PINLINE BOOL PInteractor::IsVisible() const
  { return IsWindowVisible(GetHWND()); }


PINLINE void PInteractor::BringToTop()
  { BringWindowToTop(GetHWND()); }

PINLINE BOOL PInteractor::IsOnTop() const
  { return GetHWND() == GetActiveWindow(); }

PINLINE void PInteractor::Update()
  { UpdateWindow(GetHWND()); }


PINLINE void PInteractor::GrabMouse()
  { SetCapture(GetHWND()); }

PINLINE BOOL PInteractor::HasMouse() const
  { return GetCapture() == GetHWND(); }


PINLINE void PInteractor::GrabFocus()
  { SetFocus(GetHWND()); }

PINLINE BOOL PInteractor::HasFocus() const
  { return GetFocus() == GetHWND(); }


PINLINE void PInteractor::ShowCursor(BOOL show)
  { ::ShowCursor(show); }


PINLINE PPoint PInteractor::ToScreen(PORDINATE x, PORDINATE y, CoordinateSystem coords) const
  { return ToScreen(PPoint(x, y), coords); }

PINLINE PPoint PInteractor::FromScreen(PORDINATE x, PORDINATE y, CoordinateSystem coords) const
  { return FromScreen(PPoint(x, y), coords); }


PINLINE void PInteractor::SetWndText(const PString & str,
                                                   UINT setMsg, WPARAM wParam)
  { SendMessage(GetHWND(),
                    setMsg, wParam, (DWORD)(const char *)PMakeOEMText(str)); }




//////////////////////////////////////////////////////////////////////////////
// PNamedControl

PINLINE PNamedControl::PNamedControl(PInteractorLayout * parent,
                PRESOURCE_ID ctlID, const PNotifier & notify, void * valuePtr)
  : PControl(parent, ctlID, notify, valuePtr) { }


PINLINE PString PNamedControl::GetName() const
  { return GetWndText(); }


//////////////////////////////////////////////////////////////////////////////
// PEditBox

PINLINE PEditBox::PEditBox(PInteractorLayout * parent,
             PRESOURCE_ID ctlID, const PNotifier & notify, PString * valuePtr)
  : PControl(parent, ctlID, notify, valuePtr) { }

PINLINE PEditBox::~PEditBox()
  { }

PINLINE void PEditBox::Construct()
  { }


PINLINE PString PEditBox::GetText() const
  { return GetWndText(); }


PINLINE void PEditBox::SetMaxText(PINDEX max)
  { SendMessage(GetHWND(), EM_LIMITTEXT, max, 0L); }

PINLINE PINDEX PEditBox::GetLength() const
  { return (PINDEX)SendMessage(GetHWND(), WM_GETTEXTLENGTH, 0, 0L); }

PINLINE BOOL PEditBox::IsModified() const
  { return (BOOL)SendMessage(GetHWND(), EM_GETMODIFY, 0, 0L); }

PINLINE void PEditBox::SetSelection(PINDEX start, PINDEX finish)
#ifdef _WIN32
  { SendMessage(GetHWND(), EM_SETSEL, start, finish); }
#else
  { SendMessage(GetHWND(), EM_SETSEL, 0, MAKELPARAM(start, finish)); }
#endif

PINLINE void PEditBox::ReplaceSelection(const PString & text, BOOL canUndo)
  { SendMessage(GetHWND(), EM_REPLACESEL, canUndo, (LPARAM)(const char *)text); }

PINLINE BOOL PEditBox::CanUndo() const
  { return (BOOL)SendMessage(GetHWND(), EM_CANUNDO, 0, 0L); }

PINLINE void PEditBox::Undo()
  { SendMessage(GetHWND(), EM_UNDO, 0, 0L); }

PINLINE void PEditBox::Cut()
  { SendMessage(GetHWND(), WM_CUT, 0, 0L); }

PINLINE void PEditBox::Copy() const
  { SendMessage(GetHWND(), WM_COPY, 0, 0L); }

PINLINE void PEditBox::Paste()
  { SendMessage(GetHWND(), WM_PASTE, 0, 0L); }

PINLINE void PEditBox::Clear()
  { SendMessage(GetHWND(), WM_CLEAR, 0, 0L); }


//////////////////////////////////////////////////////////////////////////////
// PPasswordEditBox

PINLINE void PPasswordEditBox::Construct()
  { }

PINLINE void PPasswordEditBox::SetPasswordCharacter(char c)
  { SendMessage(GetHWND(), EM_SETPASSWORDCHAR, c, 0); }

PINLINE char PPasswordEditBox::GetPasswordCharacter()
  { return (char)SendMessage(GetHWND(), EM_GETPASSWORDCHAR, 0, 0);}


//////////////////////////////////////////////////////////////////////////////
// PMultiLineEditBox

PINLINE void PMultiLineEditBox::Construct()
  { }

PINLINE PINDEX PMultiLineEditBox::GetLineCount()
  { return (PINDEX)SendMessage(GetHWND(), EM_GETLINECOUNT, 0, 0L); }

PINLINE PString PMultiLineEditBox::GetLine(PINDEX linenum)
  { return GetWndText(EM_LINELENGTH, EM_GETLINE,
                                         linenum, GetOffsetFromLine(linenum)); }

PINLINE PINDEX PMultiLineEditBox::GetLineFromOffset(PINDEX offset)
  { return (PINDEX)SendMessage(GetHWND(), EM_LINEFROMCHAR, offset, 0L); }

PINLINE PINDEX PMultiLineEditBox::GetOffsetFromLine(PINDEX linenum)
  { return (PINDEX)SendMessage(GetHWND(), EM_LINEINDEX, linenum, 0L); }


//////////////////////////////////////////////////////////////////////////////
// PNumberEditBox

PINLINE PNumberEditBox::PNumberEditBox(PInteractorLayout * parent,
                PRESOURCE_ID ctlID, const PNotifier & notify, void * valuePtr)
  : PEditBox(parent, ctlID, notify, (PString *)valuePtr) { }


//////////////////////////////////////////////////////////////////////////////
// PPushButton

PINLINE void PPushButton::Construct()
  { }

PINLINE BOOL PPushButton::IsOwnerDraw() const
  { return TRUE; }