misc.cxx

windows mobile phone source code

{
  Deactivate(activeWindow);
}


void PCaret::CopyContents(const PCaret & c)
{
  caretSize = c.caretSize;
  activeWindow = c.activeWindow;
}


#if defined(_WIN32)
#define PCaretAssertOS PAssertOS
#else
#define PCaretAssertOS
#endif

void PCaret::Activate(PInteractor * activator, BOOL display)
{
  Deactivate(activeWindow);

  if (caretSize.Width() > 0 && caretSize.Height() > 0) {
    activeWindow = activator;

    PCaretAssertOS(CreateCaret(activator->GetHWND(),
                                 NULL, caretSize.Width(), caretSize.Height()));
    SetPosition(activator);
    if (display)
      Show(activator);
  }
}


void PCaret::Deactivate(PInteractor * activator)
{
  if (activeWindow != NULL && activeWindow == activator) {
    PCaretAssertOS(DestroyCaret());
    activeWindow = NULL;
  }
}


void PCaret::Show(PInteractor * activator)
{
  if (activeWindow != NULL && activeWindow == activator)
    PCaretAssertOS(ShowCaret(activator->GetHWND()));
}


void PCaret::Hide(PInteractor * activator)
{
  if (activeWindow != NULL && activeWindow == activator)
    PCaretAssertOS(HideCaret(activator->GetHWND()));
}


void PCaret::SetPosition(PInteractor * activator)
{
  if (activeWindow != NULL && activeWindow == activator) {
    PPoint pos = activator->GetCaretPos(PInteractor::PixelCoords);
    PCaretAssertOS(SetCaretPos(pos.X(), pos.Y()));
  }
}


void PCaret::SetDimensions(PDIMENSION dx, PDIMENSION dy)
{
  caretSize.SetWidth(dx);
  caretSize.SetHeight(dy);
  if (activeWindow != NULL)
    Activate(activeWindow, FALSE);
}


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

PImgIcon::PImgIcon(PRESOURCE_ID resID)
{
  hBitmap = LoadBitmap(PApplication::Current().GetInstance(), MAKEINTRESOURCE(resID));
  PAssert(hBitmap != NULL, "Could not load resource.");
}


PImgIcon::PImgIcon(PCanvas & canvas, const PPixelImage & pix)
{
  hBitmap = pix->GetHBITMAP(canvas.GetHDC());
  PAssertOS(hBitmap != NULL);
}


PObject::Comparison PImgIcon::Compare(const PObject & obj) const
{
  PAssert(obj.IsDescendant(PImgIcon::Class()), PInvalidCast);
  return hBitmap == ((const PImgIcon &)obj).hBitmap ? EqualTo : GreaterThan;
}


void PImgIcon::DestroyContents()
{
  if (hBitmap != NULL) {
    PAssertOS(DeleteObject(hBitmap));
    hBitmap = NULL;
  }
}


PDim PImgIcon::GetDimensions() const
{
  BITMAP bm;
  GetObject(hBitmap, sizeof(bm), (LPSTR)&bm);
  return PDim((PDIMENSION)bm.bmWidth, (PDIMENSION)bm.bmHeight);
}


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

PIcon::PIcon(PRESOURCE_ID resID)
  : PImgIcon((HBITMAP)NULL)
{
  deleteIcon = FALSE;
  switch ((unsigned)resID) {
    case PSTD_ID_ICON_INFORMATION :
      hIcon = LoadIcon(NULL, IDI_ASTERISK);
      break;

    case PSTD_ID_ICON_QUESTION :
      hIcon = LoadIcon(NULL, IDI_QUESTION);
      break;

    case PSTD_ID_ICON_EXCLAMATION :
      hIcon = LoadIcon(NULL, IDI_EXCLAMATION);
      break;

    case PSTD_ID_ICON_STOPSIGN :
      hIcon = LoadIcon(NULL, IDI_HAND);
      break;

    case PSTD_ID_ICON_WINDOW :
      hIcon = LoadIcon(NULL, IDI_APPLICATION);
      break;

    default :
      hIcon = LoadIcon(PApplication::Current().GetInstance(), MAKEINTRESOURCE(resID));
      deleteIcon = TRUE;
  }
  PAssertNULL(hIcon);
}


PObject::Comparison PIcon::Compare(const PObject & obj) const
{
  PAssert(obj.IsDescendant(PIcon::Class()), PInvalidCast);
  return hIcon == ((const PIcon &)obj).hIcon ? EqualTo : GreaterThan;
}


void PIcon::DestroyContents()
{
  if (deleteIcon && hIcon != NULL) {
    DestroyIcon(hIcon);
    hIcon = NULL;
  }
}


void PIcon::CopyContents(const PIcon & icon)
{
  deleteIcon = icon.deleteIcon;
  hIcon = icon.hIcon;
}


PDim PIcon::GetDimensions() const
{
  return PDim((PDIMENSION)GetSystemMetrics(SM_CXICON),
              (PDIMENSION)GetSystemMetrics(SM_CYICON));
}


///////////////////////////////////////////////////////////////////////////////
// PClipboard

PClipboard::PClipboard(const PInteractor * wnd)
  : owner(PAssertNULL(wnd))
{
  opened = OpenClipboard(wnd->GetHWND());
  emptied = FALSE;
}


PClipboard::~PClipboard()
{
  if (opened)
    PAssertOS(CloseClipboard());
}


BOOL PClipboard::HasFormat(Format fmt)
{
  static const UINT PClipboardFormats[NumFormats] = {
    CF_TEXT, CF_BITMAP, CF_METAFILEPICT
  };
  
  return opened && IsClipboardFormatAvailable(PClipboardFormats[fmt]);
}


BOOL PClipboard::HasFormat(const PString & fmt)
{
  return opened && IsClipboardFormatAvailable(RegisterClipboardFormat(fmt));
}


DWORD PClipboard::GetSize(const PString & fmt)
{
  if (!opened)
    return 0;

  HANDLE h = GetClipboardData(RegisterClipboardFormat(fmt));
  return h != NULL ? GlobalSize(h) : 0;
}


BOOL PClipboard::GetData(const PString & fmt, void * data, DWORD max)
{
  if (!opened)
    return FALSE;

  HANDLE h = GetClipboardData(RegisterClipboardFormat(fmt));
  if (h == NULL)
    return FALSE;

  DWORD size = GlobalSize(h);
  memcpy(data, GlobalLock(h), (size_t)min(max, size));
  GlobalUnlock(h);
  return size <= max;
}

    
BOOL PClipboard::SetData(const PString & fmt, const void * data, DWORD len)
{
  if (!opened)
    return FALSE;

  if (!emptied) {
    EmptyClipboard();
    emptied = TRUE;
  }
  
#if !defined(_WIN32)
  PAssert(len < 65536, PInvalidParameter);
#endif
  HANDLE h = GlobalAlloc(GHND, len);
  memcpy(GlobalLock(h), data, (size_t)len);
  GlobalUnlock(h);
  return SetClipboardData(RegisterClipboardFormat(fmt), h) != NULL;
}


PString PClipboard::GetText()
{
  PString str;

  HANDLE h = GetClipboardData(CF_TEXT);
  if (h != NULL) {
    DWORD size = GlobalSize(h);
#if !defined(_WIN32)
    PAssert(size < 65536, PInvalidParameter);
#endif
    lstrcpy(str.GetPointer((PINDEX)size), (LPSTR)GlobalLock(h));
    GlobalUnlock(h);
  }
  return str;
}


BOOL PClipboard::SetText(const PString & str)
{
  if (!opened)
    return FALSE;

  if (!emptied) {
    EmptyClipboard();
    emptied = TRUE;
  }
  
  PString winstr = PMakeOEMText(str);
  HANDLE h = GlobalAlloc(GHND, winstr.GetLength()+1);
  lstrcpy((LPSTR)GlobalLock(h), winstr);
  GlobalUnlock(h);
  SetClipboardData(CF_TEXT, h);
  return TRUE;
}


PPixelImage PClipboard::GetPixels()
{
  HANDLE h = GetClipboardData(CF_BITMAP);
  if (h != NULL)
    return PPixelBase::CreateBitmap((HBITMAP)h);

  return PPixelImage();
}


BOOL PClipboard::SetPixels(const PPixelImage & pix)
{
  if (!opened)
    return FALSE;

  if (!emptied) {
    EmptyClipboard();
    emptied = TRUE;
  }
  
  PAssertOS(SetClipboardData(CF_BITMAP, pix->GetHBITMAP(NULL)) != NULL);
  return TRUE;
}


PPictImage PClipboard::GetPict()
{
  PPictImage dwg;

#if defined(_WIN32)
  HENHMETAFILE h = (HENHMETAFILE)GetClipboardData(CF_ENHMETAFILE);
  if (h != NULL)
    dwg = PPictImage(new PPictBase(h));
#else
  HANDLE h = GetClipboardData(CF_METAFILEPICT);
  if (h != NULL) {
    LPMETAFILEPICT m = (LPMETAFILEPICT)GlobalLock(h);
    dwg = PPictImage(new PPictBase(m->hMF));
    GlobalUnlock(h);
  }
#endif

  return dwg;
}


BOOL PClipboard::SetPict(const PPictImage & pic)
{
  if (!opened)
    return FALSE;

  if (!emptied) {
    EmptyClipboard();
    emptied = TRUE;
  }
  
#if defined(_WIN32)
  return SetClipboardData(CF_ENHMETAFILE, pic->GetMETAFILE()) != NULL;
#else
  HANDLE h = GlobalAlloc(GHND, sizeof(METAFILEPICT));
  if (h == NULL)
    return FALSE;

  LPMETAFILEPICT m = (LPMETAFILEPICT)GlobalLock(h);
  m->hMF = pic->GetMETAFILE();
  GlobalUnlock(h);
  SetClipboardData(CF_METAFILEPICT, h);
  return TRUE;
#endif
}


///////////////////////////////////////////////////////////////////////////////
// PApplication

PApplication::PApplication(const char * manuf, const char * name,
                           WORD major, WORD minor, CodeStatus stat, WORD build)
  : PProcess(manuf, name, major, minor, stat, build),
    systemFont("System", 12),
    balloonFont("MS Sans Serif", 8)
{
}


BOOL PApplication::IsGUIProcess() const
{
  return TRUE;