atlcontrols.h

outlook 插件 在outlook 中添加弹出试菜单

  {
    ATLASSERT(::IsWindow(m_hWnd));
    return (BOOL)::SendMessage(m_hWnd, EM_GETMODIFY, 0, 0L);
  }
  void SetModify(BOOL bModified = TRUE)
  {
    ATLASSERT(::IsWindow(m_hWnd));
    ::SendMessage(m_hWnd, EM_SETMODIFY, bModified, 0L);
  }
  void GetRect(LPRECT lpRect) const
  {
    ATLASSERT(::IsWindow(m_hWnd));
    ::SendMessage(m_hWnd, EM_GETRECT, 0, (LPARAM)lpRect);
  }
  DWORD GetSel() const
  {
    ATLASSERT(::IsWindow(m_hWnd));
    return ::SendMessage(m_hWnd, EM_GETSEL, 0, 0L);
  }
  void GetSel(int& nStartChar, int& nEndChar) const
  {
    ATLASSERT(::IsWindow(m_hWnd));
    ::SendMessage(m_hWnd, EM_GETSEL, (WPARAM)&nStartChar, (LPARAM)&nEndChar);
  }
  HLOCAL GetHandle() const
  {
    ATLASSERT(::IsWindow(m_hWnd));
    return (HLOCAL)::SendMessage(m_hWnd, EM_GETHANDLE, 0, 0L);
  }
  void SetHandle(HLOCAL hBuffer)
  {
    ATLASSERT(::IsWindow(m_hWnd));
    ::SendMessage(m_hWnd, EM_SETHANDLE, (WPARAM)hBuffer, 0L);
  }
  void SetMargins(UINT nLeft, UINT nRight)
  {
    ATLASSERT(::IsWindow(m_hWnd));
    ::SendMessage(m_hWnd, EM_SETMARGINS, EC_LEFTMARGIN|EC_RIGHTMARGIN, MAKELONG(nLeft, nRight));
  }
  DWORD GetMargins() const
  {
    ATLASSERT(::IsWindow(m_hWnd));
    return (DWORD)::SendMessage(m_hWnd, EM_GETMARGINS, 0, 0L);
  }
  void SetLimitText(UINT nMax)
  {
    ATLASSERT(::IsWindow(m_hWnd));
    ::SendMessage(m_hWnd, EM_SETLIMITTEXT, nMax, 0L);
  }
  UINT GetLimitText() const
  {
    ATLASSERT(::IsWindow(m_hWnd));
    return (UINT)::SendMessage(m_hWnd, EM_GETLIMITTEXT, 0, 0L);
  }
  POINT PosFromChar(UINT nChar) const
  {
    ATLASSERT(::IsWindow(m_hWnd));
    POINT point;
    ::SendMessage(m_hWnd, EM_POSFROMCHAR, (WPARAM)&point, (LPARAM)nChar);
    return point;
  }
  int CharFromPos(POINT pt) const
  {
    ATLASSERT(::IsWindow(m_hWnd));
    return (int)::SendMessage(m_hWnd, EM_CHARFROMPOS, 0, MAKELPARAM(pt.x, pt.y));
  }

  // NOTE: first word in lpszBuffer must contain the size of the buffer!
  int GetLine(int nIndex, LPTSTR lpszBuffer) const
  {
    ATLASSERT(::IsWindow(m_hWnd));
    return (int)::SendMessage(m_hWnd, EM_GETLINE, nIndex, (LPARAM)lpszBuffer);
  }
  int GetLine(int nIndex, LPTSTR lpszBuffer, int nMaxLength) const
  {
    ATLASSERT(::IsWindow(m_hWnd));
    *(LPWORD)lpszBuffer = (WORD)nMaxLength;
    return (int)::SendMessage(m_hWnd, EM_GETLINE, nIndex, (LPARAM)lpszBuffer);
  }

// Operations
  void EmptyUndoBuffer()
  {
    ATLASSERT(::IsWindow(m_hWnd));
    ::SendMessage(m_hWnd, EM_EMPTYUNDOBUFFER, 0, 0L);
  }
  BOOL FmtLines(BOOL bAddEOL)
  {
    ATLASSERT(::IsWindow(m_hWnd));
    return (BOOL)::SendMessage(m_hWnd, EM_FMTLINES, bAddEOL, 0L);
  }
  void LimitText(int nChars = 0)
  {
    ATLASSERT(::IsWindow(m_hWnd));
    ::SendMessage(m_hWnd, EM_LIMITTEXT, nChars, 0L);
  }
  int LineFromChar(int nIndex = -1) const
  {
    ATLASSERT(::IsWindow(m_hWnd));
    return (int)::SendMessage(m_hWnd, EM_LINEFROMCHAR, nIndex, 0L);
  }
  int LineIndex(int nLine = -1) const
  {
    ATLASSERT(::IsWindow(m_hWnd));
    return (int)::SendMessage(m_hWnd, EM_LINEINDEX, nLine, 0L);
  }
  int LineLength(int nLine = -1) const
  {
    ATLASSERT(::IsWindow(m_hWnd));
    return (int)::SendMessage(m_hWnd, EM_LINELENGTH, nLine, 0L);
  }
  void LineScroll(int nLines, int nChars = 0)
  {
    ATLASSERT(::IsWindow(m_hWnd));
    ::SendMessage(m_hWnd, EM_LINESCROLL, nChars, nLines);
  }
  void ReplaceSel(LPCTSTR lpszNewText, BOOL bCanUndo = FALSE)
  {
    ATLASSERT(::IsWindow(m_hWnd));
    ::SendMessage(m_hWnd, EM_REPLACESEL, (WPARAM) bCanUndo, (LPARAM)lpszNewText);
  }
  void SetPasswordChar(TCHAR ch)
  {
    ATLASSERT(::IsWindow(m_hWnd));
    ::SendMessage(m_hWnd, EM_SETPASSWORDCHAR, ch, 0L);
  }
  void SetRect(LPCRECT lpRect)
  {
    ATLASSERT(::IsWindow(m_hWnd));
    ::SendMessage(m_hWnd, EM_SETRECT, 0, (LPARAM)lpRect);
  }
  void SetRectNP(LPCRECT lpRect)
  {
    ATLASSERT(::IsWindow(m_hWnd));
    ::SendMessage(m_hWnd, EM_SETRECTNP, 0, (LPARAM)lpRect);
  }
  void SetSel(DWORD dwSelection, BOOL bNoScroll = FALSE)
  {
    ATLASSERT(::IsWindow(m_hWnd));
    ::SendMessage(m_hWnd, EM_SETSEL, LOWORD(dwSelection), HIWORD(dwSelection));
    if(!bNoScroll)
      ::SendMessage(m_hWnd, EM_SCROLLCARET, 0, 0L);
  }
  void SetSel(int nStartChar, int nEndChar, BOOL bNoScroll = FALSE)
  {
    ATLASSERT(::IsWindow(m_hWnd));
    ::SendMessage(m_hWnd, EM_SETSEL, nStartChar, nEndChar);
    if(!bNoScroll)
      ::SendMessage(m_hWnd, EM_SCROLLCARET, 0, 0L);
  }
  BOOL SetTabStops(int nTabStops, LPINT rgTabStops)
  {
    ATLASSERT(::IsWindow(m_hWnd));
    return (BOOL)::SendMessage(m_hWnd, EM_SETTABSTOPS, nTabStops, (LPARAM)rgTabStops);
  }
  BOOL SetTabStops()
  {
    ATLASSERT(::IsWindow(m_hWnd));
    return ::SendMessage(m_hWnd, EM_SETTABSTOPS, 0, 0L);
  }
  BOOL SetTabStops(const int& cxEachStop)    // takes an 'int'
  {
    ATLASSERT(::IsWindow(m_hWnd));
    return (BOOL)::SendMessage(m_hWnd, EM_SETTABSTOPS, 1, (LPARAM)(LPINT)&cxEachStop);
  }

  // Additional operations
  void ScrollCaret()
  {
    ATLASSERT(::IsWindow(m_hWnd));
    ::SendMessage(m_hWnd, EM_SCROLLCARET, 0, 0L);
  }
  void InsertText(int nInsertAfterChar, LPCTSTR lpstrText, BOOL bNoScroll = FALSE, BOOL bCanUndo = FALSE)
  {
    SetSel(nInsertAfterChar, nInsertAfterChar, bNoScroll);
    ReplaceSel(lpstrText, bCanUndo);
  }
  void AppendText(LPCTSTR lpstrText, BOOL bNoScroll = FALSE, BOOL bCanUndo = FALSE)
  {
    InsertText(GetWindowTextLength(), lpstrText, bNoScroll, bCanUndo);
  }

  // Clipboard operations
  BOOL Undo()
  {
    ATLASSERT(::IsWindow(m_hWnd));
    return (BOOL)::SendMessage(m_hWnd, EM_UNDO, 0, 0L);
  }
  void Clear()
  {
    ATLASSERT(::IsWindow(m_hWnd));
    ::SendMessage(m_hWnd, WM_CLEAR, 0, 0L);
  }
  void Copy()
  {
    ATLASSERT(::IsWindow(m_hWnd));
    ::SendMessage(m_hWnd, WM_COPY, 0, 0L);
  }
  void Cut()
  {
    ATLASSERT(::IsWindow(m_hWnd));
    ::SendMessage(m_hWnd, WM_CUT, 0, 0L);
  }
  void Paste()
  {
    ATLASSERT(::IsWindow(m_hWnd));
    ::SendMessage(m_hWnd, WM_PASTE, 0, 0L);
  }

  BOOL SetReadOnly(BOOL bReadOnly = TRUE)
  {
    ATLASSERT(::IsWindow(m_hWnd));
    return (BOOL)::SendMessage(m_hWnd, EM_SETREADONLY, bReadOnly, 0L);
  }
  int GetFirstVisibleLine() const
  {
    ATLASSERT(::IsWindow(m_hWnd));
    return (int)::SendMessage(m_hWnd, EM_GETFIRSTVISIBLELINE, 0, 0L);
  }
  TCHAR GetPasswordChar() const
  {
    ATLASSERT(::IsWindow(m_hWnd));
    return (TCHAR)::SendMessage(m_hWnd, EM_GETPASSWORDCHAR, 0, 0L);
  }
};

typedef CEditT<CWindow>     CEdit;

/////////////////////////////////////////////////////////////////////////////
// CScrollBar - client side for a Windows SCROLLBAR control

template <class Base>
class CScrollBarT : public Base
{
public:
// Constructors
  CScrollBarT(HWND hWnd = NULL) : Base(hWnd) { }

  CScrollBarT< Base >& operator=(HWND hWnd)
  {
    m_hWnd = hWnd;
    return *this;
  }

  HWND Create(HWND hWndParent, RECT& rcPos, LPCTSTR szWindowName = NULL,
      DWORD dwStyle = 0, DWORD dwExStyle = 0,
      UINT nID = 0, LPVOID lpCreateParam = NULL)
  {
    return CWindow::Create(GetWndClassName(), hWndParent, rcPos, szWindowName, dwStyle, dwExStyle, nID, lpCreateParam);
  }
  HWND Create(HWND hWndParent, LPRECT lpRect = NULL, LPCTSTR szWindowName = NULL,
      DWORD dwStyle = 0, DWORD dwExStyle = 0,
      HMENU hMenu = NULL, LPVOID lpCreateParam = NULL)
  {
    return CWindow::Create(GetWndClassName(), hWndParent, lpRect, szWindowName, dwStyle, dwExStyle, hMenu, lpCreateParam);
  }

// Attributes
  static LPCTSTR GetWndClassName()
  {
    return _T("SCROLLBAR");
  }

  int GetScrollPos() const
  {
    ATLASSERT(::IsWindow(m_hWnd));
    return ::GetScrollPos(m_hWnd, SB_CTL);
  }
  int SetScrollPos(int nPos, BOOL bRedraw = TRUE)
  {
    ATLASSERT(::IsWindow(m_hWnd));
    return ::SetScrollPos(m_hWnd, SB_CTL, nPos, bRedraw);
  }
  void GetScrollRange(LPINT lpMinPos, LPINT lpMaxPos) const
  {
    ATLASSERT(::IsWindow(m_hWnd));
    ::GetScrollRange(m_hWnd, SB_CTL, lpMinPos, lpMaxPos);
  }
  void SetScrollRange(int nMinPos, int nMaxPos, BOOL bRedraw = TRUE)
  {
    ATLASSERT(::IsWindow(m_hWnd));
    ::SetScrollRange(m_hWnd, SB_CTL, nMinPos, nMaxPos, bRedraw);
  }
  void ShowScrollBar(BOOL bShow = TRUE)
  {
    ATLASSERT(::IsWindow(m_hWnd));
    ::ShowScrollBar(m_hWnd, SB_CTL, bShow);
  }

  BOOL EnableScrollBar(UINT nArrowFlags = ESB_ENABLE_BOTH)
  {
    ATLASSERT(::IsWindow(m_hWnd));
    return ::EnableScrollBar(m_hWnd, SB_CTL, nArrowFlags);
  }

  BOOL SetScrollInfo(LPSCROLLINFO lpScrollInfo, BOOL bRedraw = TRUE)
  {
    ATLASSERT(::IsWindow(m_hWnd));
    return ::SetScrollInfo(m_hWnd, SB_CTL, lpScrollInfo, bRedraw);
  }
  BOOL GetScrollInfo(LPSCROLLINFO lpScrollInfo)
  {
    ATLASSERT(::IsWindow(m_hWnd));
    return ::GetScrollInfo(m_hWnd, SB_CTL, lpScrollInfo);
  }
  int GetScrollLimit()
  {
    int nMin, nMax;
    ::GetScrollRange(m_hWnd, SB_CTL, &nMin, &nMax);
    SCROLLINFO info;
    info.cbSize = sizeof(SCROLLINFO);
    info.fMask = SIF_PAGE;
    if(::GetScrollInfo(m_hWnd, SB_CTL, &info))
      nMax -= ((info.nPage-1) > 0) ? (info.nPage-1) : 0;

    return nMax;
  }
};

typedef CScrollBarT<CWindow>    CScrollBar;


// --- Windows Common Controls ---

/////////////////////////////////////////////////////////////////////////////
// CImageList

class CImageList
{
public:
  HIMAGELIST m_hImageList;

// Constructors
  CImageList(HIMAGELIST hImageList = NULL) : m_hImageList(hImageList) { }

  CImageList& operator=(HIMAGELIST hImageList)
  {
    m_hImageList = hImageList;
    return *this;
  }

  operator HIMAGELIST() const { return m_hImageList; }

  BOOL Create(int cx, int cy, UINT nFlags, int nInitial, int nGrow)
  {
    ATLASSERT(m_hImageList == NULL);
    m_hImageList = ImageList_Create(cx, cy, nFlags, nInitial, nGrow);
    return (m_hImageList != NULL) ? TRUE : FALSE;
  }
  BOOL Create(UINT nBitmapID, int cx, int nGrow, COLORREF crMask)
  {
    ATLASSERT(m_hImageList == NULL);
    ATLASSERT(HIWORD(nBitmapID) == 0);
    m_hImageList = ImageList_LoadBitmap(_Module.GetModuleInstance(), MAKEINTRESOURCE(nBitmapID), cx, nGrow, crMask);
    return (m_hImageList != NULL) ? TRUE : FALSE;
  }
  BOOL Create(LPCTSTR lpszBitmapID, int cx, int nGrow, COLORREF crMask)
  {
    ATLASSERT(m_hImageList == NULL);
    m_hImageList = ImageList_LoadBitmap(_Module.GetModuleInstance(), lpszBitmapID, cx, nGrow, crMask);
    return (m_hImageList != NULL) ? TRUE : FALSE;
  }
  BOOL Merge(HIMAGELIST hImageList1, int nImage1, HIMAGELIST hImageList2, int nImage2, int dx, int dy)
  {
    ATLASSERT(m_hImageList == NULL);
    m_hImageList = ImageList_Merge(hImageList1, nImage1, hImageList2, nImage2, dx, dy);
    return (m_hImageList != NULL) ? TRUE : FALSE;
  }

// Attributes

  void Attach(HIMAGELIST hImageList)
  {
    ATLASSERT(m_hImageList == NULL);
    ATLASSERT(hImageList != NULL);
    m_hImageList = hImageList;
  }
  HIMAGELIST Detach()
  {
    HIMAGELIST hImageList = m_hImageList;
    m_hImageList = NULL;
    return hImageList;
  }

  int GetImageCount() const
  {
    ATLASSERT(m_hImageList != NULL);
    return ImageList_GetImageCount(m_hImageList);
  }
  COLORREF SetBkColor(COLORREF cr)
  {
    ATLASSERT(m_hImageList != NULL);
    return ImageList_SetBkColor(m_hImageList, cr);
  }
  COLORREF GetBkColor() const
  {
    ATLASSERT(m_hImageList != NULL);
    return ImageList_GetBkColor(m_hImageList);
  }
  BOOL GetImageInfo(int nImage, IMAGEINFO* pImageInfo) const
  {
    ATLASSERT(m_hImageList != NULL);
    return ImageList_GetImageInfo(m_hImageList, nImage, pImageInfo);
  }

// Operations
  BOOL Destroy()
  {
    if (m_hImageList == NULL)
      return FALSE;
    BOOL bRet = ImageList_Destroy(Detach());
    if(bRet)
      m_hImageList = NULL;
    return bRet;
  }

  int Add(HBITMAP hBitmap, HBITMAP hBitmapMask)
  {
    ATLASSERT(m_hImageList != NULL);
    return ImageList_Add(m_hImageList, hBitmap, hBitmapMask);
  }
  int Add(HBITMAP hBitmap, COLORREF crMask)
  {
    ATLASSERT(m_hImageList != NULL);
    return ImageList_AddMasked(m_hImageList, hBitmap, crMask);
  }
  BOOL Remove(int nImage)
  {
    ATLASSERT(m_hImageList != NULL);
    return ImageList_Remove(m_hImageList, nImage);