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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 对话框与窗口 > 查看源码
XTPImageEditor.cpp
资源名称：Xtreme.ToolkitPro.v12.0.0.rar　[点击查看]
上传用户：szled88
上传日期：2015-04-09
资源大小：43957k
文件大小：35k
源码类别：

对话框与窗口

开发平台：

Visual C++

XTPImageEditor.cpp：源码内容
  1. // XTPImageEditor.cpp : implementation of the CXTPImageEditorDlg class.
  2. //
  3. // This file is a part of the XTREME COMMANDBARS MFC class library.
  4. // (c)1998-2008 Codejock Software, All Rights Reserved.
  5. //
  6. // THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
  7. // RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
  8. // CONSENT OF CODEJOCK SOFTWARE.
  9. //
  10. // THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
  11. // IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
  12. // YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
  13. // SINGLE COMPUTER.
  14. //
  15. // CONTACT INFORMATION:
  16. // support@codejock.com
  17. // http://www.codejock.com
  18. //
  19. /////////////////////////////////////////////////////////////////////////////
  21. #include "stdafx.h"
  22. #include "Resource.h"
  23. #include "Common/Resource.h"
  25. #include "Common/XTPVC80Helpers.h"
  26. #include "Common/XTPResourceManager.h"
  27. #include "Common/XTPImageManager.h"
  28. #include "Common/XTPDrawHelpers.h"
  29. #include "Common/XTPColorManager.h"
  31. #include "XTPImageEditor.h"
  32. #include "XTPCommandBar.h"
  33. #include "XTPMouseManager.h"
  35. #ifdef _DEBUG
  36. #define new DEBUG_NEW
  37. #undef THIS_FILE
  38. static char THIS_FILE[] = __FILE__;
  39. #endif
  42. #define UNDO_COUNT 15
  43. #define CLR_TO_RGBQUAD(clr) (RGB(GetBValue(clr), GetGValue(clr), GetRValue(clr)))
  45. void CXTPImageEditorPicture::CAlphaBitmap::CreateEditorBitmap(int nWidth, int nHeight)
  46. {
  47. BITMAPINFOHEADER BMI;
  48. // Fill in the header info.
  49. ZeroMemory (&BMI, sizeof(BMI));
  50. BMI.biSize = sizeof(BITMAPINFOHEADER);
  51. BMI.biWidth = nWidth;
  52. BMI.biHeight = nHeight;
  53. BMI.biPlanes = 1;
  54. BMI.biBitCount = 32;
  55. BMI.biCompression = BI_RGB;   // No compression
  57. UINT* pSrcBits = NULL;
  58. Attach(CreateDIBSection (NULL, (BITMAPINFO *)&BMI, DIB_RGB_COLORS, (void **)&pSrcBits, 0, 0l));
  59. }
  61. /////////////////////////////////////////////////////////////////////////////
  62. // CXTPImageEditorPicture
  65. CXTPImageEditorPicture::CXTPImageEditorPicture()
  66. {
  67. m_pCurrentBitmap = NULL;
  68. m_pPictureBitmap = NULL;
  70. m_pParentWnd = NULL;
  72. m_bTracked = FALSE;
  74. m_clrDraw = 0;
  76. m_hCursorLine = XTPResourceManager()->LoadCursor(XTP_IDC_COMMANDBARS_LINE);
  77. m_hCursorFillColor = XTPResourceManager()->LoadCursor(XTP_IDC_COMMANDBARS_FILLCOLOR);
  78. m_hCursorPencil = XTPResourceManager()->LoadCursor(XTP_IDC_COMMANDBARS_PENCIL);
  79. m_hCursorPickColor = XTPResourceManager()->LoadCursor(XTP_IDC_COMMANDBARS_PICKCOLOR);
  81. }
  83. CXTPImageEditorPicture::~CXTPImageEditorPicture()
  84. {
  85. if (m_pPictureBitmap)
  86. {
  87. delete m_pPictureBitmap;
  88. }
  89. if (m_pCurrentBitmap)
  90. {
  91. delete m_pCurrentBitmap;
  92. }
  94. while (!m_lstUndo.IsEmpty())
  95. {
  96. CBitmap* pBitmap = m_lstUndo.RemoveTail();
  97. if (pBitmap) delete pBitmap;
  98. }
  100. while (!m_lstRedo.IsEmpty())
  101. {
  102. CBitmap* pBitmap = m_lstRedo.RemoveTail();
  103. if (pBitmap) delete pBitmap;
  104. }
  106. }
  108. void CXTPImageEditorPicture::Init(UINT nID, CXTPImageEditorDlg* pParentWnd)
  109. {
  110. m_pParentWnd = pParentWnd;
  112. SubclassDlgItem(nID, pParentWnd);
  113. m_szPicture = pParentWnd->m_szPicture;
  115. CRect rc;
  116. GetWindowRect(rc);
  118. m_szItem = CSize (rc.Width() / m_szPicture.cx, rc.Height() / m_szPicture.cy);
  120. CSize sz(m_szItem.cx * m_szPicture.cx, m_szItem.cy * m_szPicture.cy);
  122. SetWindowPos(&CWnd::wndTop, rc.left, rc.top, sz.cx + 1, sz.cy + 1, SWP_NOMOVE);
  125. m_dcPicture.CreateCompatibleDC(NULL);
  126. }
  128. XTPImageEditorTools CXTPImageEditorPicture::GetSelectedTool()
  129. {
  130. ASSERT(m_pParentWnd);
  131. if (!m_pParentWnd)
  132. return xtpToolPencil;
  134. return m_pParentWnd->m_toolSelected;
  135. }
  136. COLORREF CXTPImageEditorPicture::GetSelectedColor()
  137. {
  138. ASSERT(m_pParentWnd);
  139. if (m_pParentWnd && m_pParentWnd->m_pSelected)
  140. {
  141. return m_pParentWnd->m_pSelected->GetColor();
  142. }
  143. return 0;
  144. }
  146. BEGIN_MESSAGE_MAP(CXTPImageEditorPicture, CStatic)
  147. //{{AFX_MSG_MAP(CXTPImageEditorPicture)
  148. ON_WM_PAINT()
  149. ON_WM_LBUTTONDOWN()
  150. ON_WM_MOUSEMOVE()
  151. ON_WM_CAPTURECHANGED()
  152. ON_WM_LBUTTONUP()
  153. ON_WM_SETCURSOR()
  154. //}}AFX_MSG_MAP
  155. END_MESSAGE_MAP()
  157. /////////////////////////////////////////////////////////////////////////////
  158. // CXTPImageEditorPicture message handlers
  160. BOOL CXTPImageEditorPicture::OnSetCursor(CWnd* /*pWnd*/, UINT /*nHitTest*/, UINT /*message*/)
  161. {
  162. ::SetCursor(
  163. GetSelectedTool() == xtpToolFill ? m_hCursorFillColor :
  164. GetSelectedTool() == xtpToolPencil ? m_hCursorPencil :
  165. GetSelectedTool() == xtpToolGetColor ? m_hCursorPickColor : m_hCursorLine
  166. );
  168. return TRUE;
  169. }
  171. void CXTPImageEditorPicture::OnPaint()
  172. {
  173. CPaintDC dcPaint(this); // device context for painting
  174. CXTPClientRect rc(this);
  175. CXTPBufferDC dc(dcPaint, rc);
  177. dc.FillSolidRect(rc, RGB(255, 255, 255));
  179. BOOL bAlpha = m_pPictureBitmap != 0 && m_pPictureBitmap->m_bAlpha;
  181. PINT pBits = 0;
  182. PBITMAPINFO pbmi = 0;
  183. UINT nSize;
  185. if (m_pPictureBitmap)
  186. {
  187. if (!CXTPImageManagerIcon::GetBitmapBits(dc, (HBITMAP)m_pPictureBitmap->GetSafeHandle(), pbmi, (LPVOID&)pBits, nSize))
  188. return;
  189. }
  190. if (pbmi == NULL || pBits == NULL)
  191. {
  192. return;
  193. }
  195. for (int x = 0; x < rc.Width(); x++)
  196. for (int y = 0; y < rc.Height(); y++)
  197. {
  198. CPoint pt = CPoint(m_szPicture.cx * x / rc.Width(), m_szPicture.cy * y / rc.Height());
  200. COLORREF clr;
  201. if (bAlpha)
  202. {
  203. clr = pBits[(pt.y * pbmi->bmiHeader.biWidth + pt.x)];
  205. int nAlpha = (clr & 0xFF000000) >> 24;
  207. int nColor = (((x +3) / 4)+ ((y +3)/ 4)) % 2 == 0 ? 255 : 235;
  209. clr = RGB(nColor - (nColor -  GetBValue(clr)) * nAlpha / 255,
  210. nColor -  (nColor - GetGValue(clr)) * nAlpha / 255,
  211. nColor -  (nColor - GetRValue(clr)) * nAlpha / 255);
  214. }
  215. else
  216. {
  218. clr = m_pPictureBitmap == NULL ? XTPCOLOR_ERASE : pBits[(pt.y * pbmi->bmiHeader.biWidth + pt.x)];
  219. clr = CLR_TO_RGBQUAD(clr);
  221. if (clr == XTPCOLOR_ERASE)
  222. clr = (((x +3) / 4)+ ((y +3)/ 4)) % 2 == 0 ? RGB(255, 255, 255) : RGB(235, 235, 235);
  225. }
  226. dc.SetPixel(x, rc.Height() - y - 1, clr);
  227. }
  229. free(pBits);
  230. free(pbmi);
  232. dc.Draw3dRect(rc, 0, 0);
  233. }
  235. COLORREF CXTPImageEditorPicture::GetPicturePixel(CPoint point)
  236. {
  237. CAlphaBitmap bmp;
  238. bmp.CreateEditorBitmap(m_szPicture.cx, m_szPicture.cy);
  240. CBitmap* pOldBitmap = m_dcPicture.SelectObject(&bmp);
  241. m_dcPicture.FillSolidRect(0, 0, m_szPicture.cx, m_szPicture.cy, XTPCOLOR_ERASE);
  242. if (m_pPictureBitmap)
  243. m_dcPicture.DrawState(0, m_szPicture, m_pPictureBitmap, DSS_NORMAL, (CBrush*)NULL);
  244. COLORREF clr = m_dcPicture.GetPixel(point);
  247. m_dcPicture.SelectObject(pOldBitmap);
  248. return clr;
  249. }
  253. CPoint CXTPImageEditorPicture::ClientToPicture(CPoint pt)
  254. {
  255. ASSERT(m_szItem.cx > 0 && m_szItem.cy > 0);
  256. return CPoint(pt.x / m_szItem.cx, pt.y / m_szItem.cy);
  257. }
  259. void CXTPImageEditorPicture::CopyBitmap(CAlphaBitmap* pBitmapCopyTo, CAlphaBitmap* pBitmapCopyFrom, CSize sz, CPoint ptOffset, COLORREF clrTransparentFrom, COLORREF clrTransparentTo, CDC* pDC)
  260. {
  261. CDC dc;
  262. dc.CreateCompatibleDC(pDC);
  264. pBitmapCopyTo->CreateEditorBitmap(sz.cx, sz.cy);
  266. CBitmap* pOldBitmap = dc.SelectObject(pBitmapCopyTo);
  267. dc.FillSolidRect(0, 0, sz.cx, sz.cy, XTPCOLOR_ERASE);
  269. if (pBitmapCopyFrom)
  270. {
  271. dc.DrawState(ptOffset, sz, pBitmapCopyFrom, DSS_NORMAL, (CBrush*)NULL);
  273. if (clrTransparentFrom != clrTransparentTo && !pBitmapCopyFrom->m_bAlpha)
  274. {
  275. for (int x = 0; x < sz.cx; x++)
  276. {
  277. for (int y = 0; y < sz.cy; y++)
  278. {
  279. if (dc.GetPixel(x, y) == clrTransparentFrom)
  280. dc.SetPixel(x, y, clrTransparentTo);
  281. }
  282. }
  283. }
  284. }
  286. dc.SelectObject(pOldBitmap);
  288. pBitmapCopyTo->m_bAlpha = pBitmapCopyFrom ? pBitmapCopyFrom->m_bAlpha : FALSE;
  291. }
  293. void CXTPImageEditorPicture::OnPictureChanged()
  294. {
  295. Invalidate(FALSE);
  296. m_pParentWnd->OnPictureChanged();
  297. }
  299. void CXTPImageEditorPicture::Apply()
  300. {
  301. while (!m_lstRedo.IsEmpty())
  302. {
  303. CBitmap* pBitmap = m_lstRedo.RemoveTail();
  304. if (pBitmap) delete pBitmap;
  305. }
  307. if (m_lstUndo.GetCount() > UNDO_COUNT)
  308. {
  309. CBitmap* pBitmap = m_lstUndo.RemoveHead();
  310. if (pBitmap) delete pBitmap;
  311. }
  313. m_lstUndo.AddTail(m_pCurrentBitmap);
  314. m_pCurrentBitmap = NULL;
  316. OnPictureChanged();
  317. }
  320. void CXTPImageEditorPicture::OnLButtonDown(UINT nFlags, CPoint point)
  321. {
  322. ASSERT(m_pCurrentBitmap == NULL);
  324. switch (GetSelectedTool())
  325. {
  326. case xtpToolFill:
  327. {
  328. m_pCurrentBitmap = m_pPictureBitmap;
  330. m_pPictureBitmap = new CAlphaBitmap();
  331. CopyBitmap(m_pPictureBitmap, m_pCurrentBitmap, m_szPicture);
  333. CBitmap* pOldBitmap = m_dcPicture.SelectObject(m_pPictureBitmap);
  334. CXTPBrushDC brush(m_dcPicture, GetSelectedColor());
  336. CPoint ptFill(ClientToPicture(point));
  338. m_dcPicture.ExtFloodFill(ptFill.x, ptFill.y, GetPicturePixel(ptFill), FLOODFILLSURFACE);
  339. m_dcPicture.SelectObject(pOldBitmap);
  341. if (m_pCurrentBitmap && m_pCurrentBitmap->m_bAlpha)
  342. FixAlphaLayer(m_pPictureBitmap, m_pCurrentBitmap);
  344. Apply();
  345. }
  346. break;
  348. case xtpToolGetColor:
  349. {
  350. COLORREF clr = GetPicturePixel(ClientToPicture(point));
  351. m_pParentWnd->m_wndPicker.SetColor(clr);
  352. m_pParentWnd->SetSelected(&m_pParentWnd->m_wndPicker);
  353. m_pParentWnd->m_toolSelected = m_pParentWnd->m_toolPrevious;
  354. }
  355. break;
  356. case xtpToolPencil:
  357. case xtpToolRectangle:
  358. case xtpToolCircle:
  359. case xtpToolLine:
  360. {
  362. m_pCurrentBitmap = m_pPictureBitmap;
  364. m_pPictureBitmap = new CAlphaBitmap();
  365. CopyBitmap(m_pPictureBitmap, m_pCurrentBitmap, m_szPicture);
  367. m_clrDraw = GetSelectedColor() != GetPicturePixel(ClientToPicture(point)) ? GetSelectedColor() : XTPCOLOR_ERASE;
  369. m_bTracked = TRUE;
  370. m_ptTracked = point;
  371. SetCapture();
  373. OnMouseMove(nFlags, point);
  374. }
  375. break;
  376. default :
  377. ASSERT(FALSE);
  379. }
  381. CStatic::OnLButtonDown(nFlags, point);
  382. }
  385. void CXTPImageEditorDlg::FixAlphaLayer(LPBYTE pBits, UINT nCount)
  386. {
  387. if (pBits == 0)
  388. return;
  390. LPBYTE pBitsI = pBits;
  392. for (UINT i = 0; i < nCount; i++)
  393. {
  394. if (*(LPDWORD)pBitsI == 0) *(LPDWORD)pBitsI = XTPCOLOR_ERASE;
  396. int nAlpha = pBitsI[3];
  397. if (nAlpha != 0)
  398. {
  399. pBitsI[0] = BYTE(pBitsI[0] * 255 / nAlpha);
  400. pBitsI[1] = BYTE(pBitsI[1] * 255 / nAlpha);
  401. pBitsI[2] = BYTE(pBitsI[2] * 255 / nAlpha);
  402. }
  404. pBitsI += 4;
  405. }
  406. }
  408. void CXTPImageEditorPicture::FixAlphaLayer(CAlphaBitmap* pDest, CAlphaBitmap* pSrc)
  409. {
  410. if (pSrc == 0 || pDest == 0)
  411. return;
  413. CDC dcSrc;
  414. dcSrc.CreateCompatibleDC(NULL);
  416. PINT pDestBits = 0, pSrcBits = 0;
  417. PBITMAPINFO pDestBmi = 0, pSrcBmi = 0;
  419. UINT nSize;
  421. if (!CXTPImageManagerIcon::GetBitmapBits(dcSrc, (HBITMAP)pDest->GetSafeHandle(), pDestBmi, (LPVOID&)pDestBits, nSize))
  422. return;
  424. if (!CXTPImageManagerIcon::GetBitmapBits(dcSrc, (HBITMAP)pSrc->GetSafeHandle(), pSrcBmi, (LPVOID&)pSrcBits, nSize))
  425. {
  426. free(pDestBits);
  427. free(pDestBmi);
  428. return;
  429. }
  431. PINT pFixedBits = NULL;
  433. HBITMAP hBitmapAlpha = CreateDIBSection(dcSrc, pDestBmi, DIB_RGB_COLORS, (void**)&pFixedBits, NULL, 0);
  435. if (hBitmapAlpha && pFixedBits)
  436. {
  437. MEMCPY_S(pFixedBits, pDestBits, nSize);
  439. for (UINT i = 0; i < nSize / 4; i++)
  440. {
  441. if (pDestBits[i] != pSrcBits[i])
  442. {
  443. if (pDestBits[i] != XTPCOLOR_ERASE)
  444. pFixedBits[i] |= 0xFF000000;
  445. }
  446. }
  448. pDest->DeleteObject();
  449. pDest->Attach(hBitmapAlpha);
  450. }
  452. free(pDestBits);
  453. free(pDestBmi);
  454. free(pSrcBits);
  455. free(pSrcBmi);
  457. }
  459. void CXTPImageEditorPicture::OnMouseMove(UINT nFlags, CPoint point)
  460. {
  461. if (m_bTracked)
  462. {
  463. if (GetSelectedTool() == xtpToolPencil)
  464. {
  465. CAlphaBitmap* pBitmap = new CAlphaBitmap();
  466. CopyBitmap(pBitmap, m_pPictureBitmap, m_szPicture);
  468. CBitmap* pOldBitmap = m_dcPicture.SelectObject(pBitmap);
  470. m_dcPicture.SetPixel(ClientToPicture(point), m_clrDraw);
  471. m_dcPicture.SelectObject(pOldBitmap);
  473. if (m_pPictureBitmap->m_bAlpha)
  474. FixAlphaLayer(pBitmap, m_pPictureBitmap);
  476. if (m_pPictureBitmap) delete m_pPictureBitmap;
  478. m_pPictureBitmap = pBitmap;
  480. Invalidate(FALSE);
  481. OnPictureChanged();
  482. }
  483. else
  484. {
  485. CAlphaBitmap* pBitmap = new CAlphaBitmap();
  486. CopyBitmap(pBitmap, m_pCurrentBitmap, m_szPicture);
  488. CBitmap* pOldBitmap = m_dcPicture.SelectObject(pBitmap);
  490. CRect rcReftangle(ClientToPicture(m_ptTracked), ClientToPicture(point));
  491. rcReftangle.NormalizeRect();
  493. if (GetSelectedTool() == xtpToolRectangle)
  494. {
  495. m_dcPicture.Draw3dRect(rcReftangle, GetSelectedColor(), GetSelectedColor());
  496. }
  497. if (GetSelectedTool() == xtpToolCircle)
  498. {
  499. CXTPPenDC pen(m_dcPicture, GetSelectedColor());
  500. CXTPBrushDC brush(m_dcPicture, XTPCOLOR_ERASE);
  501. m_dcPicture.Ellipse(rcReftangle);
  502. }
  503. if (GetSelectedTool() == xtpToolLine)
  504. {
  505. CXTPPenDC pen(m_dcPicture, GetSelectedColor());
  506. m_dcPicture.MoveTo(ClientToPicture(m_ptTracked));
  507. m_dcPicture.LineTo(ClientToPicture(point));
  508. }
  510. m_dcPicture.SelectObject(pOldBitmap);
  512. if (m_pPictureBitmap->m_bAlpha)
  513. FixAlphaLayer(pBitmap, m_pCurrentBitmap);
  515. if (m_pPictureBitmap) delete m_pPictureBitmap;
  516. m_pPictureBitmap = pBitmap;
  518. Invalidate(FALSE);
  519. OnPictureChanged();
  521. }
  523. }
  525. CStatic::OnMouseMove(nFlags, point);
  526. }
  528. void CXTPImageEditorPicture::OnLButtonUp(UINT nFlags, CPoint point)
  529. {
  530. m_bTracked = FALSE;
  531. ReleaseCapture();
  533. CStatic::OnLButtonUp(nFlags, point);
  534. }
  536. void CXTPImageEditorPicture::OnCaptureChanged(CWnd* pWnd)
  537. {
  538. m_bTracked = FALSE;
  539. Apply();
  541. CStatic::OnCaptureChanged(pWnd);
  542. }
  544. void CXTPImageEditorPicture::Undo()
  545. {
  546. if (!m_lstUndo.IsEmpty())
  547. {
  548. CAlphaBitmap* pBitmap = m_lstUndo.RemoveTail();
  550. m_lstRedo.AddTail(m_pPictureBitmap);
  552. m_pPictureBitmap = pBitmap;
  554. OnPictureChanged();
  555. }
  556. }
  558. void CXTPImageEditorPicture::Redo()
  559. {
  560. if (!m_lstRedo.IsEmpty())
  561. {
  562. CAlphaBitmap* pBitmap = m_lstRedo.RemoveTail();
  564. m_lstUndo.AddTail(m_pPictureBitmap);
  566. m_pPictureBitmap = pBitmap;
  568. OnPictureChanged();
  569. }
  570. }
  573. void CXTPImageEditorPicture::Clear()
  574. {
  575. m_pCurrentBitmap = m_pPictureBitmap;
  576. m_pPictureBitmap = NULL;
  577. Apply();
  578. }
  580. void CXTPImageEditorPicture::MovePicture(CPoint ptOffset)
  581. {
  582. m_pCurrentBitmap = m_pPictureBitmap;
  584. m_pPictureBitmap = new CAlphaBitmap();
  585. CopyBitmap(m_pPictureBitmap, m_pCurrentBitmap, m_szPicture, ptOffset);
  587. Apply();
  588. }
  591. void CXTPImageEditorPicture::Copy()
  592. {
  593. if (!OpenClipboard ())
  594. {
  595. return;
  596. }
  598. if (!::EmptyClipboard ())
  599. {
  600. ::CloseClipboard ();
  601. return;
  602. }
  604. CAlphaBitmap bitmapCopy;
  605. CopyBitmap(&bitmapCopy, m_pPictureBitmap, m_szPicture, 0, XTPCOLOR_ERASE, GetXtremeColor(COLOR_3DFACE));
  607. HANDLE hclipData = ::SetClipboardData (CF_BITMAP, bitmapCopy.Detach ());
  608. if (hclipData == NULL)
  609. {
  610. TRACE (_T ("CXTPImageEditorPicture::Copy() error. Error code = %xn"), GetLastError ());
  611. }
  613. if (bitmapCopy.m_bAlpha)
  614. {
  615. SetClipboardData(XTPImageManager()->m_nAlphaClipFormat, GlobalAlloc(GMEM_MOVEABLE, 1));
  616. }
  618. ::CloseClipboard ();
  619. }
  621. void CXTPImageEditorPicture::Paste()
  622. {
  623. COleDataObject data;
  624. if (!data.AttachClipboard ())
  625. {
  626. return;
  627. }
  628. if (!data.IsDataAvailable (CF_BITMAP))
  629. {
  630. return;
  631. }
  633. tagSTGMEDIUM dataMedium;
  634. if (!data.GetData (CF_BITMAP, &dataMedium))
  635. {
  636. return;
  637. }
  639. if (!dataMedium.hBitmap)
  640. return;
  642. CAlphaBitmap bmpClip;
  644. BOOL bAlpha = FALSE;
  645. FORMATETC fetc;
  646. static TCHAR sz[256] ;
  648. data.BeginEnumFormats();
  649. while (data.GetNextFormat(&fetc))
  650. {
  651. if (GetClipboardFormatName((UINT)fetc.cfFormat, sz, 254))
  652. {
  653. CString str(sz);
  654. if (str.Find(_T("DIB32")) > 0)
  655. {
  656. bAlpha = TRUE;
  657. break;
  658. }
  659. }
  660. }
  662. bmpClip.m_bAlpha = bAlpha ? bAlpha : data.IsDataAvailable(XTPImageManager()->m_nAlphaClipFormat);
  663. bmpClip.Attach(dataMedium.hBitmap);
  666. m_pCurrentBitmap = m_pPictureBitmap;
  668. m_pPictureBitmap = new CAlphaBitmap();
  669. CopyBitmap(m_pPictureBitmap, &bmpClip, m_szPicture, 0, GetXtremeColor(COLOR_3DFACE), XTPCOLOR_ERASE);
  671. bmpClip.Detach();
  673. Apply();
  675. }
  678. void CXTPImageEditorPicture::Load()
  679. {
  680. CString strFilter;
  681. VERIFY(XTPResourceManager()->LoadString(&strFilter, XTP_IDS_IMAGEEDITOR_FILTER));
  682. CFileDialog fd(TRUE, NULL, NULL, OFN_HIDEREADONLY, strFilter);
  684. if (fd.DoModal() == IDOK)
  685. {
  687. CString strExtension = fd.GetFileExt();
  688. strExtension.MakeLower();
  690. if (strExtension == _T("ico"))
  691. {
  693. HBITMAP hBitmap = CXTPImageManagerIcon::LoadAlphaIcon(fd.GetPathName(), m_szPicture.cx);
  695. if (!hBitmap)
  696. {
  697. HICON hIcon = (HICON)LoadImage(0, fd.GetPathName(),
  698. IMAGE_ICON, m_szPicture.cx, m_szPicture.cy, LR_CREATEDIBSECTION | LR_LOADFROMFILE);
  700. if (!hIcon)
  701. return;
  703. m_pCurrentBitmap = m_pPictureBitmap;
  704. m_pPictureBitmap = new CAlphaBitmap();
  706. CDC dc;
  707. dc.CreateCompatibleDC(NULL);
  709. m_pPictureBitmap->CreateEditorBitmap(m_szPicture.cx, m_szPicture.cy);
  711. CBitmap* pOldBitmap = dc.SelectObject(m_pPictureBitmap);
  712. dc.FillSolidRect(0, 0, m_szPicture.cx, m_szPicture.cy, XTPCOLOR_ERASE);
  714. dc.DrawState(0, CSize(0, 0), hIcon, DSS_NORMAL, (CBrush*)NULL);
  716. dc.SelectObject(pOldBitmap);
  718. DestroyIcon(hIcon);
  719. }
  720. else
  721. {
  723. m_pCurrentBitmap = m_pPictureBitmap;
  724. m_pPictureBitmap = new CAlphaBitmap();
  727. CAlphaBitmap bmpFile(TRUE);
  728. bmpFile.Attach(hBitmap);
  730. CopyBitmap(m_pPictureBitmap, &bmpFile, m_szPicture);
  731. }
  733. Apply();
  736. }
  737. else if (strExtension == _T("bmp") || strExtension == _T("png"))
  738. {
  740. BOOL bAlphaBitmap = FALSE;
  742. HBITMAP hBmp = CXTPImageManagerIcon::LoadBitmapFromFile(fd.GetPathName(), &bAlphaBitmap);
  744. if (!hBmp)
  745. return;
  747. CAlphaBitmap bmpFile(bAlphaBitmap);
  748. bmpFile.Attach(hBmp);
  750. m_pCurrentBitmap = m_pPictureBitmap;
  751. m_pPictureBitmap = new CAlphaBitmap();
  753. CopyBitmap(m_pPictureBitmap, &bmpFile, m_szPicture);
  755. Apply();
  756. }
  757. else
  758. {
  759. LPPICTURE pPict = NULL;
  761. if (OleLoadPicturePath((LPOLESTR)XTP_CT2CW(fd.GetPathName()), NULL, 0, 0, IID_IPicture, (LPVOID*)&pPict) == S_OK)
  762. {
  764. m_pCurrentBitmap = m_pPictureBitmap;
  765. m_pPictureBitmap = new CAlphaBitmap();
  767. CDC dc;
  768. dc.CreateCompatibleDC(NULL);
  770. m_pPictureBitmap->CreateEditorBitmap(m_szPicture.cx, m_szPicture.cy);
  772. CBitmap* pOldBitmap = dc.SelectObject(m_pPictureBitmap);
  773. dc.FillSolidRect(0, 0, m_szPicture.cx, m_szPicture.cy, XTPCOLOR_ERASE);
  775. long hmWidth;
  776. long hmHeight;
  778. pPict->get_Width(&hmWidth);
  779. pPict->get_Height(&hmHeight);
  781. pPict->Render(dc, 0, 0,
  782. m_szPicture.cx, m_szPicture.cy, 0, hmHeight-1,
  783. hmWidth, -hmHeight, 0);
  785. dc.SelectObject(pOldBitmap);
  787. Apply();
  789. pPict->Release();
  791. }
  794. }
  795. }
  797. }
  800. /////////////////////////////////////////////////////////////////////////////
  801. // CXTPImageEditorPicker
  803. IMPLEMENT_DYNAMIC(CXTPImageEditorPicker, CStatic)
  805. CXTPImageEditorPicker::CXTPImageEditorPicker()
  806. {
  807. m_clr = 0;
  808. m_bSelected = FALSE;
  809. }
  812. void CXTPImageEditorPicker::SetColor(COLORREF clr)
  813. {
  814. m_clr = clr;
  815. if (m_hWnd) Invalidate(FALSE);
  816. }
  817. COLORREF CXTPImageEditorPicker::GetColor()
  818. {
  819. return m_clr;
  820. }
  822. void CXTPImageEditorPicker::SetSelected(BOOL bSelected)
  823. {
  824. m_bSelected = bSelected;
  825. if (m_hWnd) Invalidate(FALSE);
  826. }
  829. BEGIN_MESSAGE_MAP(CXTPImageEditorPicker, CStatic)
  830. //{{AFX_MSG_MAP(CXTPImageEditorPicker)
  831. ON_WM_PAINT()
  832. ON_WM_LBUTTONDOWN()
  833. //}}AFX_MSG_MAP
  834. END_MESSAGE_MAP()
  836. /////////////////////////////////////////////////////////////////////////////
  837. // CXTPImageEditorPicker message handlers
  840. void CXTPImageEditorPicker::OnPaint()
  841. {
  842. CPaintDC dcPaint(this); // device context for painting
  843. CXTPClientRect rc(this);
  844. CXTPBufferDC dc(dcPaint, rc);
  846. if (m_clr != XTPCOLOR_ERASE)
  847. {
  848. dc.FillSolidRect(rc, m_clr);
  849. }
  850. else
  851. {
  853. CRect rcItem(rc);
  854. dc.FillSolidRect(rc, RGB(0xFF, 0xFF, 0xFF));
  855. dc.FillSolidRect(rcItem.left, rcItem.top, rcItem.Width() / 2, rcItem.Height() / 2, RGB(235, 235, 235));
  856. dc.FillSolidRect(rcItem.left + rcItem.Width() / 2, rcItem.top + rcItem.Height() / 2,
  857. rcItem.Width() - (rcItem.Width() / 2), rcItem.Height() - (rcItem.Height() / 2), RGB(235, 235, 235));
  859. }
  860. if (!m_bSelected)
  861. {
  862. dc.Draw3dRect(rc, GetXtremeColor(COLOR_3DDKSHADOW), GetXtremeColor(COLOR_3DDKSHADOW));
  863. }
  864. else
  865. {
  866. dc.Draw3dRect(rc, 0, 0);
  867. rc.DeflateRect(1, 1);
  868. dc.Draw3dRect(rc, RGB(0xFF, 0xFF, 0xFF), RGB(0xFF, 0xFF, 0xFF));
  869. rc.DeflateRect(1, 1);
  870. dc.Draw3dRect(rc, 0, 0);
  871. }
  873. }
  875. void CXTPImageEditorPicker::OnLButtonDown(UINT /*nFlags*/, CPoint /*point*/)
  876. {
  877. NMHDR mHDR;
  878. mHDR.hwndFrom = m_hWnd;
  879. mHDR.code = NM_CLICK;
  880. mHDR.idFrom = GetDlgCtrlID();
  882. GetParent()->SendMessage(WM_NOTIFY,
  883. (WPARAM)mHDR.idFrom, (LPARAM)&mHDR);
  884. }
  886. /////////////////////////////////////////////////////////////////////////////
  887. // CXTPImageEditorPreview
  889. CXTPImageEditorPreview::CXTPImageEditorPreview()
  890. {
  891. m_pParentWnd = 0;
  892. }
  894. void CXTPImageEditorPreview::Init(UINT nID, CXTPImageEditorDlg* pParentWnd)
  895. {
  896. m_pParentWnd = pParentWnd;
  898. SubclassDlgItem(nID, pParentWnd);
  899. m_szPicture = pParentWnd->m_szPicture;
  901. ModifyStyleEx(WS_EX_STATICEDGE, 0);
  903. }
  906. BEGIN_MESSAGE_MAP(CXTPImageEditorPreview, CStatic)
  907. //{{AFX_MSG_MAP(CXTPImageEditorPreview)
  908. ON_WM_PAINT()
  909. //}}AFX_MSG_MAP
  910. END_MESSAGE_MAP()
  912. /////////////////////////////////////////////////////////////////////////////
  913. // CXTPImageEditorPreview message handlers
  915. void CXTPImageEditorPreview::OnPaint()
  916. {
  917. CPaintDC dcPaint(this); // device context for painting
  918. CXTPClientRect rc(this);
  919. CXTPBufferDC dc(dcPaint, rc);
  920. dc.FillSolidRect(rc, GetXtremeColor(COLOR_3DFACE));
  923. CRect rcButton (10, (rc.Height() - m_szPicture.cy) / 2, 10 + m_szPicture.cx, (rc.Height() - m_szPicture.cy) / 2 + m_szPicture.cy);
  924. CRect rcFrame(rcButton);
  925. rcFrame.InflateRect(3, 3);
  927. dc.Draw3dRect(rcFrame, RGB(0xFF, 0xFF, 0xFF), GetXtremeColor(COLOR_3DSHADOW));
  928. rcFrame.InflateRect(1, 1);
  929. dc.Draw3dRect(rcFrame, GetXtremeColor(COLOR_3DFACE), GetXtremeColor(COLOR_3DDKSHADOW));
  931. ASSERT(m_pParentWnd);
  932. if (!m_pParentWnd)
  933. return;
  934. CXTPImageEditorPicture::CAlphaBitmap* pBitmap = m_pParentWnd->m_wndPicture.m_pPictureBitmap;
  936. if (pBitmap)
  937. {
  938. if (pBitmap->m_bAlpha)
  939. {
  940. HBITMAP hBitmap = CXTPImageManagerIcon::PreMultiplyAlphaBitmap((HBITMAP)pBitmap->GetSafeHandle());
  941. if (hBitmap)
  942. {
  943. CXTPImageManagerIcon::DrawAlphaBitmap(&dc, hBitmap, rcButton.TopLeft(), m_szPicture);
  945. DeleteObject(hBitmap);
  946. }
  947. }
  948. else
  949. {
  950. CXTPImageEditorPicture::CAlphaBitmap bmpClient;
  951. CXTPImageEditorPicture::CopyBitmap(&bmpClient, pBitmap, m_szPicture, 0, XTPCOLOR_ERASE, GetXtremeColor(COLOR_3DFACE), &dc);
  953. dc.DrawState(rcButton.TopLeft(), m_szPicture, &bmpClient, DSS_NORMAL, (CBrush*)NULL);
  954. }
  955. }
  956. }
  958. /////////////////////////////////////////////////////////////////////////////
  959. // CDlgToolBar dialog
  961. BEGIN_MESSAGE_MAP(CXTPImageEditorDlg::CDlgToolBar, CToolBar)
  962. { WM_IDLEUPDATECMDUI, 0, 0, 0, AfxSig_lwl, (AFX_PMSG)(AFX_PMSGW)(LRESULT (AFX_MSG_CALL CWnd::*)(WPARAM, LPARAM))&CXTPImageEditorDlg::CDlgToolBar::OnIdleUpdateCmdUI },
  963. END_MESSAGE_MAP()
  966. /////////////////////////////////////////////////////////////////////////////
  967. // CXTPImageEditorDlg dialog
  969. CXTPImageEditorDlg::CXTPImageEditorDlg(CWnd* pParent /*= NULL*/, BOOL bCommandBarsEditor)
  970. : m_bCommandBarsEditor(bCommandBarsEditor)
  971. {
  972. InitModalIndirect(XTPResourceManager()->LoadDialogTemplate(XTP_IDD_IMAGEEDITOR_DIALOG), pParent);
  974. m_toolSelected = xtpToolPencil;
  976. m_pSelected = NULL;
  977. m_szPicture = CSize(16, 16);
  978. m_toolPrevious = XTPImageEditorTools(-1);
  979. }
  981. void CXTPImageEditorDlg::GetIcon(CXTPImageManagerIconHandle* pHandle)
  982. {
  983. ASSERT(pHandle);
  984. if (!pHandle)
  985. return;
  987. if (m_wndPicture.m_pPictureBitmap)
  988. {
  989. if (m_wndPicture.m_pPictureBitmap->m_bAlpha)
  990. {
  991. pHandle->CopyHandle((HBITMAP)m_wndPicture.m_pPictureBitmap->GetSafeHandle());
  992. }
  993. else
  994. {
  996. CImageList imgList;
  997. imgList.Create(m_szPicture.cx, m_szPicture.cy, ILC_COLOR24 | ILC_MASK, 0, 1);
  998. imgList.Add(m_wndPicture.m_pPictureBitmap, XTPCOLOR_ERASE);
  1000. if (imgList.GetImageCount() != 1)
  1001. return;
  1003. *pHandle = imgList.ExtractIcon(0);
  1004. }
  1005. }
  1006. }
  1008. void CXTPImageEditorDlg::SetIconSize(CSize szIcon)
  1009. {
  1010. m_szPicture = szIcon;
  1011. }
  1012. void CXTPImageEditorDlg::SetIcon(CXTPImageManagerIconHandle& icon)
  1013. {
  1014. if (icon.IsEmpty())
  1015. return;
  1017. ASSERT(m_wndPicture.m_pPictureBitmap == NULL);
  1018. m_szPicture = icon.GetExtent();
  1020. CXTPImageManagerIconHandle iconHandle;
  1021. iconHandle.CopyHandle(icon);
  1023. if (iconHandle.IsAlpha())
  1024. {
  1025. iconHandle.PreMultiply();
  1027. CXTPImageEditorPicture::CAlphaBitmap* pBitmap = new CXTPImageEditorPicture::CAlphaBitmap(TRUE);
  1029. LPBYTE lpBits;
  1030. pBitmap->Attach(CXTPImageManagerIcon::CopyAlphaBitmap(iconHandle.GetBitmap(), &lpBits));
  1032. FixAlphaLayer(lpBits, m_szPicture.cx * m_szPicture.cy);
  1033. m_wndPicture.m_pPictureBitmap = pBitmap;
  1035. }
  1036. else
  1037. {
  1038. CXTPImageEditorPicture::CAlphaBitmap* pBitmap = new CXTPImageEditorPicture::CAlphaBitmap();
  1040. CDC dc;
  1041. dc.CreateCompatibleDC(NULL);
  1043. pBitmap->CreateEditorBitmap(m_szPicture.cx, m_szPicture.cy);
  1045. CBitmap* pOldBitmap = dc.SelectObject(pBitmap);
  1046. dc.FillSolidRect(0, 0, m_szPicture.cx, m_szPicture.cy, XTPCOLOR_ERASE);
  1048. dc.DrawState(0, CSize(0, 0), iconHandle.GetIcon(), DSS_NORMAL, (CBrush*)NULL);
  1050. dc.SelectObject(pOldBitmap);
  1052. m_wndPicture.m_pPictureBitmap = pBitmap;
  1053. }
  1055. }
  1057. void CXTPImageEditorDlg::DoDataExchange(CDataExchange* pDX)
  1058. {
  1059. CDialog::DoDataExchange(pDX);
  1060. //{{AFX_DATA_MAP(CXTPImageEditorDlg)
  1061. DDX_Control(pDX, XTP_IDC_STATIC_TOOLS, m_gboxTools);
  1062. DDX_Control(pDX, XTP_IDC_STATIC_MOVE, m_gboxMove);
  1063. //}}AFX_DATA_MAP
  1065. }
  1067. BEGIN_MESSAGE_MAP(CXTPImageEditorDlg, CDialog)
  1068. //{{AFX_MSG_MAP(CXTPImageEditorDlg)
  1069. ON_MESSAGE(WM_KICKIDLE, OnKickIdle)
  1070. ON_WM_DESTROY()
  1072. ON_NOTIFY(NM_CLICK, XTP_IDC_CLR_PICKER, OnPickerClick)
  1073. ON_NOTIFY_RANGE(NM_CLICK, XTP_IDS_CLR_BLACK, XTP_IDS_CLR_FUCHSIA, OnSelectorClick)
  1074. ON_NOTIFY(NM_CLICK, XTP_IDC_CLR_ERASE, OnEraseClick)
  1076. ON_UPDATE_COMMAND_UI_RANGE(XTP_ID_BUTTON_PENCIL, XTP_ID_BUTTON_CIRCLE, OnUpdateButtonTool)
  1077. ON_COMMAND_RANGE(XTP_ID_BUTTON_PENCIL, XTP_ID_BUTTON_CIRCLE, OnButtonTool)
  1079. ON_UPDATE_COMMAND_UI(XTP_ID_BUTTON_UNDO, OnUpdateButtonUndo)
  1080. ON_COMMAND(XTP_ID_BUTTON_UNDO, OnButtonUndo)
  1082. ON_UPDATE_COMMAND_UI(XTP_ID_BUTTON_REDO, OnUpdateButtonRedo)
  1083. ON_COMMAND(XTP_ID_BUTTON_REDO, OnButtonRedo)
  1085. ON_COMMAND(XTP_ID_BUTTON_CLEAR, OnButtonClear)
  1086. ON_COMMAND(XTP_ID_BUTTON_COPY, OnButtonCopy)
  1087. ON_COMMAND(XTP_ID_BUTTON_PASTE, OnButtonPaste)
  1088. ON_COMMAND(XTP_ID_BUTTON_OPEN, OnButtonOpen)
  1089. ON_COMMAND_RANGE(XTP_IDC_BUTTON_LEFT, XTP_IDC_BUTTON_RIGHT, OnMoveButton)
  1090. ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTW, 0, 0xFFFF, OnToolTipText)
  1091. ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTA, 0, 0xFFFF, OnToolTipText)
  1092. //}}AFX_MSG_MAP
  1093. END_MESSAGE_MAP()
  1096. /////////////////////////////////////////////////////////////////////////////
  1097. // CXTPImageEditorDlg message handlers
  1099. BOOL CXTPImageEditorDlg::OnInitDialog()
  1100. {
  1101. UINT nButtonsTools[] =
  1102. {
  1103. XTP_ID_BUTTON_PENCIL,
  1104. XTP_ID_BUTTON_FILL,
  1105. XTP_ID_BUTTON_UNDO,
  1106. XTP_ID_BUTTON_REDO,
  1107. XTP_ID_BUTTON_GETCOLOR,
  1108. XTP_ID_BUTTON_LINE,
  1109. XTP_ID_BUTTON_COPY,
  1110. XTP_ID_BUTTON_PASTE,
  1111. XTP_ID_BUTTON_RECTANGLE,
  1112. XTP_ID_BUTTON_CIRCLE,
  1113. XTP_ID_BUTTON_CLEAR,
  1114. XTP_ID_BUTTON_OPEN
  1115. };
  1118. UINT nButtonsMove[] =
  1119. {
  1120. XTP_IDC_BUTTON_LEFT,
  1121. XTP_IDC_BUTTON_DOWN,
  1122. XTP_IDC_BUTTON_UP,
  1123. XTP_IDC_BUTTON_RIGHT
  1124. };
  1126. const struct
  1127. {
  1128. COLORREF clr;
  1129. UINT nID;
  1130. POINT ptOffset;
  1131. }
  1132. colors[] =
  1133. {
  1134. RGB(0x00, 0x00, 0x00), XTP_IDS_CLR_BLACK           , {0, 0},
  1135. RGB(0x80, 0x00, 0x00), XTP_IDS_CLR_DARK_RED        , {2, 0},
  1136. RGB(0x80, 0x80, 0x00), XTP_IDS_CLR_DARK_YELLOW     , {3, 0},
  1137. RGB(0x00, 0x00, 0x80), XTP_IDS_CLR_DARK_BLUE       , {6, 0},
  1138. RGB(0x00, 0x80, 0x00), XTP_IDS_CLR_GREEN           , {4, 0},
  1139. RGB(0x00, 0x80, 0x80), XTP_IDS_CLR_TEAL            , {5, 0},
  1140. RGB(0x00, 0x00, 0xFF), XTP_IDS_CLR_BLUE            , {6, 1},
  1141. RGB(0x80, 0x80, 0x80), XTP_IDS_CLR_GRAY50          , {1, 0},
  1142. RGB(0xFF, 0x00, 0x00), XTP_IDS_CLR_RED             , {2, 1},
  1143. RGB(0x80, 0x00, 0x80), XTP_IDS_CLR_VIOLET          , {7, 0},
  1144. RGB(0xFF, 0x00, 0xFF), XTP_IDS_CLR_PINK            , {7, 1},
  1145. RGB(0xFF, 0xFF, 0x00), XTP_IDS_CLR_YELLOW          , {3, 1},
  1146. RGB(0x00, 0xFF, 0x00), XTP_IDS_CLR_BRIGHT_GREEN    , {4, 1},
  1147. RGB(0x00, 0xFF, 0xFF), XTP_IDS_CLR_TURQUOISE       , {5, 1},
  1148. RGB(0xC0, 0xC0, 0xC0), XTP_IDS_CLR_GRAY25          , {1, 1},
  1149. RGB(0xFF, 0xFF, 0xFF), XTP_IDS_CLR_WHITE           , {0, 1}
  1150. };
  1152. CDialog::OnInitDialog();
  1154. CRect rcTools;
  1155. m_gboxTools.GetWindowRect(&rcTools);
  1156. ScreenToClient(rcTools);
  1158. m_wndToolbarTools.Create(this, WS_CHILD | WS_VISIBLE | CBRS_SIZE_FIXED | CBRS_TOOLTIPS | CBRS_ALIGN_TOP);
  1159. m_wndToolbarTools.ModifyStyle(0, TBSTYLE_FLAT);
  1160. m_wndToolbarTools.SetButtons(nButtonsTools, 12);
  1163. int i;
  1165. int nCount = m_wndToolbarTools.GetToolBarCtrl().GetButtonCount();
  1166. for (i = 0; i < nCount; i++)
  1167. {
  1168. UINT nStyle = m_wndToolbarTools.GetButtonStyle(i);
  1169. if (((i + 1) % 4) == 0) nStyle |= TBBS_WRAPPED;
  1170. m_wndToolbarTools.SetButtonStyle(i, nStyle);
  1171. }
  1173. CSize sz = m_wndToolbarTools.CalcDynamicLayout(0, LM_HORZ);
  1174. m_wndToolbarTools.SetWindowPos(&CWnd::wndTop, rcTools.left - 7, rcTools.top - 4, sz.cx, sz.cy, 0);
  1177. CRect rcMove;
  1178. m_gboxMove.GetWindowRect(&rcMove);
  1179. ScreenToClient(rcMove);
  1181. m_wndToolbarMove.Create(this, WS_CHILD | WS_VISIBLE | CBRS_SIZE_FIXED | CBRS_TOOLTIPS | CBRS_ALIGN_TOP);
  1182. m_wndToolbarMove.ModifyStyle(0, TBSTYLE_FLAT);
  1183. m_wndToolbarMove.SetButtons(nButtonsMove, 4);
  1186. if (CXTPImageManager::IsAlphaIconsImageListSupported())
  1187. {
  1188. m_ilToolbarTools.Create(16, 16, ILC_COLOR32 | ILC_MASK, 0, 1);
  1189. HBITMAP hBitmap = CXTPImageManagerIcon::LoadAlphaBitmap(XTP_IDB_TOOLBAR_TOOLS32);
  1190. m_ilToolbarTools.Add(CBitmap::FromHandle(hBitmap), (CBitmap*)0);
  1192. m_ilToolbarMove.Create(16, 16, ILC_COLOR32 | ILC_MASK, 0, 1);
  1194. m_ilToolbarMove.Add(CBitmap::FromHandle(hBitmap), (CBitmap*)0);
  1195. for (i = 0; i < 12; i++) m_ilToolbarMove.Remove(0);
  1196. DeleteObject(hBitmap);
  1197. }
  1198. else
  1199. {
  1200. m_ilToolbarTools.Create(XTP_IDB_TOOLBAR_TOOLS, 16, 1, RGB(192, 192, 192));
  1201. m_ilToolbarMove.Create(XTP_IDB_TOOLBAR_TOOLS, 16, 1, RGB(192, 192, 192));
  1203. for (i = 0; i < 12; i++) m_ilToolbarMove.Remove(0);
  1204. }
  1206. m_wndToolbarTools.GetToolBarCtrl().SendMessage(TB_SETIMAGELIST, 0, (LPARAM)m_ilToolbarTools.GetSafeHandle());
  1207. m_wndToolbarMove.GetToolBarCtrl().SendMessage(TB_SETIMAGELIST, 0, (LPARAM)m_ilToolbarMove.GetSafeHandle());
  1210. sz = m_wndToolbarMove.CalcDynamicLayout(0, LM_HORZ);
  1211. m_wndToolbarMove.SetWindowPos(&CWnd::wndTop, rcMove.left - 7, rcMove.top - 4, sz.cx, sz.cy, 0);
  1215. CRect rcColors;
  1216. GetDlgItem(XTP_IDC_STATIC_COLORS)->GetWindowRect(&rcColors);
  1217. ScreenToClient(rcColors);
  1219. for (i = 0; i < _countof(colors); i++)
  1220. {
  1221. CRect rcItem(CPoint(rcColors.left, rcColors.top - 4), CSize(11, 11));
  1222. rcItem.OffsetRect(colors[i].ptOffset.x * 13 , colors[i].ptOffset.y * 13);
  1224. m_wndSelector[i].Create(NULL, WS_CHILD | WS_VISIBLE | SS_NOTIFY, rcItem, this, colors[i].nID);
  1225. m_wndSelector[i].SetColor(colors[i].clr);
  1227. }
  1228. SetSelected(&m_wndSelector[0]);
  1230. m_wndSelectorErase.SubclassDlgItem(XTP_IDC_CLR_ERASE, this);
  1231. m_wndSelectorErase.SetColor(XTPCOLOR_ERASE);
  1233. m_wndPicker.SubclassDlgItem(XTP_IDC_CLR_PICKER, this);
  1236. m_wndPicture.Init(XTP_IDC_STATIC_PICTURE, this);
  1237. m_wndPreview.Init(XTP_IDC_STATIC_PREVIEW, this);
  1239. if (m_bCommandBarsEditor)
  1240. {
  1241. XTPMouseManager()->AddTrustedWindow(m_hWnd);
  1242. }
  1244. return TRUE;  // return TRUE  unless you set the focus to a control
  1245. }
  1247. void CXTPImageEditorDlg::OnDestroy()
  1248. {
  1249. if (m_bCommandBarsEditor)
  1250. {
  1251. XTPMouseManager()->RemoveTrustedWindow(m_hWnd);
  1252. }
  1254. CDialog::OnDestroy();
  1255. }
  1257. LRESULT CXTPImageEditorDlg::OnKickIdle(WPARAM, LPARAM)
  1258. {
  1259. SendMessageToDescendants(WM_IDLEUPDATECMDUI);
  1260. return 0;
  1261. }
  1263. void CXTPImageEditorDlg::SetSelected(CXTPImageEditorPicker* pPicker)
  1264. {
  1265. if (m_pSelected != NULL)
  1266. m_pSelected->SetSelected(FALSE);
  1268. if (pPicker)
  1269. pPicker->SetSelected(TRUE);
  1271. m_pSelected = pPicker;
  1272. }
  1274. void CXTPImageEditorDlg::OnPickerClick(NMHDR* /*pNMHDR*/, LRESULT* /*pResult*/)
  1275. {
  1276. CColorDialog cd(m_wndPicker.GetColor(), 0, this);
  1277. if (cd.DoModal())
  1278. {
  1279. m_wndPicker.SetColor(cd.GetColor());
  1280. SetSelected(&m_wndPicker);
  1281. }
  1283. }
  1284. void CXTPImageEditorDlg::OnEraseClick(NMHDR* pNMHDR, LRESULT* /*pResult*/)
  1285. {
  1286. CXTPImageEditorPicker* pWnd = DYNAMIC_DOWNCAST(CXTPImageEditorPicker, CWnd::FromHandlePermanent(pNMHDR->hwndFrom));
  1287. ASSERT(pWnd);
  1288. SetSelected(pWnd);
  1290. }
  1292. void CXTPImageEditorDlg::OnSelectorClick(UINT /*id*/, NMHDR* pNMHDR, LRESULT* /*pResult*/)
  1293. {
  1294. CXTPImageEditorPicker* pWnd = DYNAMIC_DOWNCAST(CXTPImageEditorPicker, CWnd::FromHandlePermanent(pNMHDR->hwndFrom));
  1295. ASSERT(pWnd);
  1296. SetSelected(pWnd);
  1297. }
  1300. void CXTPImageEditorDlg::OnUpdateButtonTool(CCmdUI* pCmdUI)
  1301. {
  1302. pCmdUI->SetCheck(m_toolSelected == (int)pCmdUI->m_nID - XTP_ID_BUTTON_PENCIL);
  1303. }
  1305. void CXTPImageEditorDlg::OnButtonTool(UINT nID)
  1306. {
  1307. m_toolPrevious = m_toolSelected == xtpToolGetColor ? m_toolPrevious : m_toolSelected;
  1308. m_toolSelected = (XTPImageEditorTools)(nID - XTP_ID_BUTTON_PENCIL);
  1309. }
  1312. void CXTPImageEditorDlg::OnPictureChanged()
  1313. {
  1314. m_wndPreview.Invalidate(FALSE);
  1315. }
  1317. void CXTPImageEditorDlg::OnUpdateButtonUndo(CCmdUI* pCmdUI)
  1318. {
  1319. pCmdUI->Enable(!m_wndPicture.m_lstUndo.IsEmpty());
  1320. }
  1322. void CXTPImageEditorDlg::OnButtonUndo()
  1323. {
  1324. m_wndPicture.Undo();
  1325. }
  1327. void CXTPImageEditorDlg::OnUpdateButtonRedo(CCmdUI* pCmdUI)
  1328. {
  1329. pCmdUI->Enable(!m_wndPicture.m_lstRedo.IsEmpty());
  1330. }
  1332. void CXTPImageEditorDlg::OnButtonRedo()
  1333. {
  1334. m_wndPicture.Redo();
  1335. }
  1337. void CXTPImageEditorDlg::OnButtonClear()
  1338. {
  1339. m_wndPicture.Clear();
  1340. }
  1341. void CXTPImageEditorDlg::OnButtonCopy()
  1342. {
  1343. m_wndPicture.Copy();
  1344. }
  1345. void CXTPImageEditorDlg::OnButtonPaste()
  1346. {
  1347. m_wndPicture.Paste();
  1348. }
  1349. void CXTPImageEditorDlg::OnButtonOpen()
  1350. {
  1351. m_wndPicture.Load();
  1352. }
  1354. void CXTPImageEditorDlg::OnMoveButton(UINT nID)
  1355. {
  1356. m_wndPicture.MovePicture(
  1357. nID == XTP_IDC_BUTTON_LEFT ? CPoint(-1, 0) :
  1358. nID == XTP_IDC_BUTTON_RIGHT ? CPoint(+1, 0) :
  1359. nID == XTP_IDC_BUTTON_UP ? CPoint(0, -1) : CPoint(0, +1));
  1360. }
  1363. BOOL CXTPImageEditorDlg::OnToolTipText(UINT, NMHDR* pNMHDR, LRESULT* pResult)
  1364. {
  1365. ASSERT(pNMHDR->code == TTN_NEEDTEXTA || pNMHDR->code == TTN_NEEDTEXTW);
  1367. // need to handle both ANSI and UNICODE versions of the message
  1368. TOOLTIPTEXTA* pTTTA = (TOOLTIPTEXTA*)pNMHDR;
  1369. TOOLTIPTEXTW* pTTTW = (TOOLTIPTEXTW*)pNMHDR;
  1370. TCHAR szFullText[256];
  1371. CString strTipText;
  1372. UINT nID = (UINT)pNMHDR->idFrom;
  1374. if (nID != 0) // will be zero on a separator
  1375. {
  1376. // don't handle the message if no string resource found
  1377. if (AfxLoadString(nID, szFullText) == 0)
  1378. return FALSE;
  1380. // this is the command id, not the button index
  1381. AfxExtractSubString(strTipText, szFullText, 1, 'n');
  1382. }
  1383. #ifndef _UNICODE
  1384. if (pNMHDR->code == TTN_NEEDTEXTA)
  1385. lstrcpyn(pTTTA->szText, strTipText, _countof(pTTTA->szText));
  1386. else
  1387. _mbstowcsz(pTTTW->szText, strTipText, _countof(pTTTW->szText));
  1388. #else
  1389. if (pNMHDR->code == TTN_NEEDTEXTA)
  1390. _wcstombsz(pTTTA->szText, strTipText, _countof(pTTTA->szText));
  1391. else
  1392. lstrcpyn(pTTTW->szText, strTipText, _countof(pTTTW->szText));
  1393. #endif
  1394. *pResult = 0;
  1396. // bring the tooltip window above other popup windows
  1397. ::SetWindowPos(pNMHDR->hwndFrom, HWND_TOP, 0, 0, 0, 0,
  1398. SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE | SWP_NOOWNERZORDER);
  1400. return TRUE;    // message was handled
  1401. }