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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 查看源码
RTDraw.cpp
资源名称：20060417006-9709.rar　[点击查看]
上传用户：qhonly
上传日期：2013-06-10
资源大小：487k
文件大小：28k
源码类别：

界面编程

开发平台：

Visual C++

RTDraw.cpp：源码内容
  1. ///////////////////////////////////////////////////////////////////////////////
  2. //
  3. // Draw.cpp : implementation file
  4. //
  5. ///////////////////////////////////////////////////////////////////////////////
  7. #include "stdafx.h"
  8. #include "RTDraw.h"
  9. ///////////////////////////////////////////////////////////////////////////////
  10. HLSCOLOR RGB2HLS (COLORREF rgb)
  11. {
  12.     unsigned char minval = min(GetRValue(rgb), min(GetGValue(rgb), GetBValue(rgb)));
  13.     unsigned char maxval = max(GetRValue(rgb), max(GetGValue(rgb), GetBValue(rgb)));
  14.     float mdiff  = float(maxval) - float(minval);
  15.     float msum   = float(maxval) + float(minval);
  16.    
  17.     float luminance = msum / 510.0f;
  18.     float saturation = 0.0f;
  19.     float hue = 0.0f; 
  21.     if ( maxval != minval )
  22.     { 
  23.         float rnorm = (maxval - GetRValue(rgb)  ) / mdiff;      
  24.         float gnorm = (maxval - GetGValue(rgb)) / mdiff;
  25.         float bnorm = (maxval - GetBValue(rgb) ) / mdiff;   
  27.         saturation = (luminance <= 0.5f) ? (mdiff / msum) : (mdiff / (510.0f - msum));
  29.         if (GetRValue(rgb) == maxval) hue = 60.0f * (6.0f + bnorm - gnorm);
  30.         if (GetGValue(rgb) == maxval) hue = 60.0f * (2.0f + rnorm - bnorm);
  31.         if (GetBValue(rgb) == maxval) hue = 60.0f * (4.0f + gnorm - rnorm);
  32.         if (hue > 360.0f) hue = hue - 360.0f;
  33.     }
  34.     return HLS ((hue*255)/360, luminance*255, saturation*255);
  35. }
  37. ///////////////////////////////////////////////////////////////////////////////
  38. static BYTE _ToRGB (float rm1, float rm2, float rh)
  39. {
  40.   if      (rh > 360.0f) rh -= 360.0f;
  41.   else if (rh <   0.0f) rh += 360.0f;
  42.  
  43.   if      (rh <  60.0f) rm1 = rm1 + (rm2 - rm1) * rh / 60.0f;   
  44.   else if (rh < 180.0f) rm1 = rm2;
  45.   else if (rh < 240.0f) rm1 = rm1 + (rm2 - rm1) * (240.0f - rh) / 60.0f;      
  46.                    
  47.   return (BYTE)(rm1 * 255);
  48. }
  50. ///////////////////////////////////////////////////////////////////////////////
  51. COLORREF HLS2RGB (HLSCOLOR hls)
  52. {
  53.     float hue        = ((int)HLS_H(hls)*360)/255.0f;
  54.     float luminance  = HLS_L(hls)/255.0f;
  55.     float saturation = HLS_S(hls)/255.0f;
  57.     if ( saturation == 0.0f )
  58.     {
  59.         return RGB (HLS_L(hls), HLS_L(hls), HLS_L(hls));
  60.     }
  61.     float rm1, rm2;
  62.      
  63.     if ( luminance <= 0.5f ) rm2 = luminance + luminance * saturation;  
  64.     else                     rm2 = luminance + saturation - luminance * saturation;
  65.     rm1 = 2.0f * luminance - rm2;   
  66.     BYTE red   = _ToRGB (rm1, rm2, hue + 120.0f);   
  67.     BYTE green = _ToRGB (rm1, rm2, hue);
  68.     BYTE blue  = _ToRGB (rm1, rm2, hue - 120.0f);
  70.     return RGB (red, green, blue);
  71. }
  73. ///////////////////////////////////////////////////////////////////////////////
  74. COLORREF HLS_TRANSFORM (COLORREF rgb, int percent_L, int percent_S)
  75. {
  76.     HLSCOLOR hls = RGB2HLS (rgb);
  77.     BYTE h = HLS_H(hls);
  78.     BYTE l = HLS_L(hls);
  79.     BYTE s = HLS_S(hls);
  81.     if ( percent_L > 0 )
  82.     {
  83.         l = BYTE(l + ((255 - l) * percent_L) / 100);
  84.     }
  85.     else if ( percent_L < 0 )
  86.     {
  87.         l = BYTE((l * (100+percent_L)) / 100);
  88.     }
  89.     if ( percent_S > 0 )
  90.     {
  91.         s = BYTE(s + ((255 - s) * percent_S) / 100);
  92.     }
  93.     else if ( percent_S < 0 )
  94.     {
  95.         s = BYTE((s * (100+percent_S)) / 100);
  96.     }
  97.     return HLS2RGB (HLS(h, l, s));
  98. }
  100. /////////////////////////////////////////////////////////////////////////////
  101. HBITMAP WINAPI GetScreenBitmap (LPCRECT pRect)
  102. {
  103.     HDC     hDC;
  104.     HDC     hMemDC;
  105.     HBITMAP hNewBitmap = NULL;
  107.     if ( (hDC = ::GetDC (NULL)) != NULL )
  108.     {
  109.         if ( (hMemDC = ::CreateCompatibleDC (hDC)) != NULL )
  110.         {
  111.             if ( (hNewBitmap = ::CreateCompatibleBitmap (hDC, pRect->right - pRect->left, pRect->bottom - pRect->top)) != NULL )
  112.             {
  113.                 HBITMAP hOldBitmap = (HBITMAP)::SelectObject(hMemDC, hNewBitmap);
  114.                 ::BitBlt (hMemDC, 0, 0, pRect->right - pRect->left, pRect->bottom - pRect->top,
  115.                           hDC, pRect->left, pRect->top, SRCCOPY);
  116.                 ::SelectObject (hMemDC, (HGDIOBJ) hOldBitmap);
  117.             }
  118.             ::DeleteDC (hMemDC);
  119.         }
  120.         ::ReleaseDC (NULL, hDC);
  121.     }
  122.     return hNewBitmap;
  123. }
  126. ///////////////////////////////////////////////////////////////////////////////
  127. ///////////////////////////////////////////////////////////////////////////////
  128. CBufferDC::CBufferDC (HDC hDestDC, const CRect& rcPaint) : m_hDestDC (hDestDC)
  129. {
  130.     if ( rcPaint.IsRectEmpty() )
  131.     {
  132.         ::GetClipBox (m_hDestDC, m_rect);
  133.     }
  134.     else
  135.     {
  136.         m_rect = rcPaint;
  137.     }
  138.     VERIFY(Attach (::CreateCompatibleDC (m_hDestDC)));
  139.     m_bitmap.Attach (::CreateCompatibleBitmap (m_hDestDC, m_rect.right, m_rect.bottom));
  140.     m_hOldBitmap = ::SelectObject (m_hDC, m_bitmap);
  142.     if ( m_rect.top > 0 )
  143.     {
  144.         ExcludeClipRect (0, 0, m_rect.right, m_rect.top);
  145.     }
  146.     if ( m_rect.left > 0 )
  147.     {
  148.         ExcludeClipRect (0, m_rect.top, m_rect.left, m_rect.bottom);
  149.     }
  150. }
  152. ///////////////////////////////////////////////////////////////////////////////
  153. CBufferDC::~CBufferDC ()
  154. {
  155.     VERIFY(::BitBlt (m_hDestDC, m_rect.left, m_rect.top, m_rect.Width(), m_rect.Height(), m_hDC, m_rect.left, m_rect.top, SRCCOPY));
  156.     ::SelectObject (m_hDC, m_hOldBitmap);
  157. }
  160. ///////////////////////////////////////////////////////////////////////////////
  161. ///////////////////////////////////////////////////////////////////////////////
  162. CPenDC::CPenDC (HDC hDC, COLORREF crColor) : m_hDC (hDC)
  163. {
  164.     VERIFY(m_pen.CreatePen (PS_SOLID, 1, crColor));
  165.     m_hOldPen = (HPEN)::SelectObject (m_hDC, m_pen);
  166. }
  168. ///////////////////////////////////////////////////////////////////////////////
  169. CPenDC::~CPenDC ()
  170. {
  171.     ::SelectObject (m_hDC, m_hOldPen);
  172. }
  174. ///////////////////////////////////////////////////////////////////////////////
  175. void CPenDC::Color (COLORREF crColor)
  176. {
  177.     ::SelectObject (m_hDC, m_hOldPen);
  178.     VERIFY(m_pen.DeleteObject());
  179.     VERIFY(m_pen.CreatePen (PS_SOLID, 1, crColor));
  180.     m_hOldPen = (HPEN)::SelectObject (m_hDC, m_pen);
  181. }
  183. ///////////////////////////////////////////////////////////////////////////////
  184. COLORREF CPenDC::Color () const
  185. {
  186.     LOGPEN logPen;
  188.     ((CPenDC*)this)->m_pen.GetLogPen (&logPen);
  190.     return logPen.lopnColor;
  191. }
  194. ///////////////////////////////////////////////////////////////////////////////
  195. ///////////////////////////////////////////////////////////////////////////////
  196. CBrushDC::CBrushDC (HDC hDC, COLORREF crColor) : m_hDC (hDC)
  197. {
  198.     if ( crColor == CLR_NONE ) VERIFY(m_brush.CreateStockObject (NULL_BRUSH));
  199.     else                       VERIFY(m_brush.CreateSolidBrush (crColor));
  200.     m_hOldBrush = (HBRUSH)::SelectObject (m_hDC, m_brush);
  201. }
  203. ///////////////////////////////////////////////////////////////////////////////
  204. CBrushDC::~CBrushDC ()
  205. {
  206.     ::SelectObject (m_hDC, m_hOldBrush);
  207. }
  209. ///////////////////////////////////////////////////////////////////////////////
  210. void CBrushDC::Color (COLORREF crColor)
  211. {
  212.     ::SelectObject (m_hDC, m_hOldBrush);
  213.     VERIFY(m_brush.DeleteObject());
  214.     if ( crColor == CLR_NONE ) VERIFY(m_brush.CreateStockObject (NULL_BRUSH));
  215.     else                       VERIFY(m_brush.CreateSolidBrush (crColor));
  216.     m_hOldBrush = (HBRUSH)::SelectObject (m_hDC, m_brush);
  217. }
  219. ///////////////////////////////////////////////////////////////////////////////
  220. COLORREF CBrushDC::Color () const
  221. {
  222.     LOGBRUSH logBrush;
  224.     ((CBrushDC*)this)->m_brush.GetLogBrush (&logBrush);
  226.     return logBrush.lbColor;
  227. }
  230. /////////////////////////////////////////////////////////////////////////////
  231. /////////////////////////////////////////////////////////////////////////////
  232. CFontDC::CFontDC (HDC hDC, LPCTSTR sFaceName, COLORREF crText)
  233.         : m_hDC (hDC), m_hFont (NULL), m_hDefFont (NULL), m_crTextOld (CLR_NONE)
  234. {
  235.     *this = sFaceName;
  237.     if ( crText != CLR_DEFAULT )
  238.     {
  239.         *this = crText;
  240.     }
  241. }
  243. /////////////////////////////////////////////////////////////////////////////
  244. CFontDC::CFontDC (HDC hDC, BYTE nStockFont, COLORREF crText)
  245.         : m_hDC (hDC), m_hFont (NULL), m_hDefFont (NULL), m_crTextOld (CLR_NONE)
  246. {
  247.     *this = nStockFont;
  249.     if ( crText != CLR_DEFAULT )
  250.     {
  251.         *this = crText;
  252.     }
  253. }
  255. /////////////////////////////////////////////////////////////////////////////
  256. CFontDC::CFontDC (HDC hDC, HFONT hFont, COLORREF crText)
  257.         : m_hDC (hDC), m_hFont (NULL), m_hDefFont (NULL), m_crTextOld (CLR_NONE)
  258. {
  259.     *this = hFont;
  261.     if ( crText != CLR_DEFAULT )
  262.     {
  263.         *this = crText;
  264.     }
  265. }
  267. /////////////////////////////////////////////////////////////////////////////
  268. CFontDC::~CFontDC ()
  269. {
  270.     if ( m_hDefFont != NULL )
  271.     {
  272.         ::SelectObject (m_hDC, m_hDefFont);
  273.         DeleteObject (m_hFont);
  274.     }
  275.     if ( m_crTextOld != CLR_NONE )
  276.     {
  277.         ::SetTextColor (m_hDC, m_crTextOld);
  278.     }
  279. }
  281. /////////////////////////////////////////////////////////////////////////////
  282. const CFontDC& CFontDC::operator = (LPCTSTR sFaceName)
  283. {
  284.     LOGFONT lf;
  286. ::GetObject (::GetCurrentObject (m_hDC, OBJ_FONT), sizeof(LOGFONT), &lf);
  288.     if ( _tcsicmp (sFaceName, lf.lfFaceName) )
  289.     {
  290.         if ( m_hDefFont != NULL )
  291.         {
  292.             ::SelectObject (m_hDC, m_hDefFont);
  293.             DeleteObject (m_hFont);
  294.         }
  295.         _tcscpy (lf.lfFaceName, sFaceName);
  296.         m_hFont = ::CreateFontIndirect (&lf);
  297.         m_hDefFont = (HFONT)::SelectObject (m_hDC, m_hFont);
  298.     }
  299. return *this;
  300. }
  302. /////////////////////////////////////////////////////////////////////////////
  303. const CFontDC& CFontDC::operator = (BYTE nStockFont)
  304. {
  305.     if ( m_hDefFont != NULL )
  306.     {
  307.         ::SelectObject (m_hDC, m_hDefFont);
  308.         DeleteObject (m_hFont);
  309.     }
  310.     m_hFont = (HFONT)::GetStockObject (nStockFont);
  311.     m_hDefFont = (HFONT)::SelectObject (m_hDC, m_hFont);
  313. return *this;
  314. }
  316. /////////////////////////////////////////////////////////////////////////////
  317. const CFontDC& CFontDC::operator = (HFONT hFont)
  318. {
  319.     if ( m_hDefFont != NULL )
  320.     {
  321.         ::SelectObject (m_hDC, m_hDefFont);
  322.         DeleteObject (m_hFont);
  323.     }
  324.     m_hFont = hFont;
  325.     m_hDefFont = (HFONT)::SelectObject (m_hDC, m_hFont);
  327. return *this;
  328. }
  330. /////////////////////////////////////////////////////////////////////////////
  331. const CFontDC& CFontDC::operator = (COLORREF crText)
  332. {
  333.     if ( m_crTextOld == CLR_NONE )
  334.     {
  335.         m_crTextOld = ::GetTextColor (m_hDC);
  336.     }
  337.     ::SetTextColor (m_hDC, crText);
  339. return *this;
  340. }
  342. /////////////////////////////////////////////////////////////////////////////
  343. CFontDC::operator LPCTSTR ()
  344. {
  345.     LOGFONT lf;
  347. ::GetObject (::GetCurrentObject (m_hDC, OBJ_FONT), sizeof(LOGFONT), &lf);
  349.     return lf.lfFaceName;
  350. }
  352. /////////////////////////////////////////////////////////////////////////////
  353. CFontDC::operator COLORREF ()
  354. {
  355.     return ::GetTextColor (m_hDC);
  356. }
  359. /////////////////////////////////////////////////////////////////////////////
  360. /////////////////////////////////////////////////////////////////////////////
  361. CBoldDC::CBoldDC (HDC hDC, bool bBold) : m_hDC (hDC), m_hDefFont (NULL)
  362. {
  363.     LOGFONT lf;
  365.     CFont::FromHandle((HFONT)::GetCurrentObject(m_hDC, OBJ_FONT))->GetLogFont (&lf);
  367.     if ( ( bBold && lf.lfWeight != FW_BOLD) ||
  368.          (!bBold && lf.lfWeight == FW_BOLD) )
  369.     {
  370.         lf.lfWeight = bBold ? FW_BOLD : FW_NORMAL;
  372.         m_fontBold.CreateFontIndirect (&lf);
  373.         m_hDefFont = (HFONT)::SelectObject (m_hDC, m_fontBold);
  374.     }
  375. }
  377. /////////////////////////////////////////////////////////////////////////////
  378. CBoldDC::~CBoldDC ()
  379. {
  380.     if ( m_hDefFont != NULL )
  381.     {
  382.         ::SelectObject (m_hDC, m_hDefFont);
  383.     }
  384. }
  387. /////////////////////////////////////////////////////////////////////////////
  388. /////////////////////////////////////////////////////////////////////////////
  389. #define DB_GETTYPE(Style)       ((Style)&0x00FF)
  390. #define DB_ISENABLED(Style)     (!((Style)&DB_DISABLED))
  391. #define DB_ISBORDER(Style)      (((Style)&DB_BORDER)==DB_BORDER)
  392. #define DB_ISWINDOWDC(Style)    (((Style)&DB_WINDOWDC)==DB_WINDOWDC)
  393. #define DB_ISFLAT(Style)        (((Style)&DB_FLAT)==DB_FLAT)
  394. #define DB_ISPRESSED(Style)     (((Style)&(DB_PRESSED|DB_PRESSED2))!=0)
  395. #define DB_ISPRESSED1(Style)    (((Style)&DB_PRESSED)==DB_PRESSED)
  396. #define DB_ISPRESSED2(Style)    (((Style)&DB_PRESSED2)==DB_PRESSED2)
  397. #define DB_ISOVER(Style)        (((Style)&DB_OVER)==DB_OVER)
  398. #define DB_ISTRANSPARENT(Style) (((Style)&DB_TRANSPARENT)==DB_TRANSPARENT)
  400. /////////////////////////////////////////////////////////////////////////////
  401. static void _DrawTriangle (CDC* pDC, int x, int y, int nSize, bool bDown)
  402. {
  403.     for ( int i = 0; i < nSize; i++ )
  404.     {
  405.         pDC->MoveTo (x-i, bDown ? y-i : y+i);
  406.         pDC->LineTo (x+i+1, bDown ? y-i : y+i);
  407.     }
  408. }
  409. BOOL CRTDraw::RTDrawVerticalText(CDC* pDC,LPCRECT lpRect,LPCTSTR lpText,int length,UINT format,LOGFONT *lf)
  410. {
  411. char *ptr = (char *)lpText;
  412. char *start = (char *)lpText;
  413. char *end = (char *)(lpText + length - 1);
  414. char temp = NULL;
  416. BOOL IsUnicode = FALSE;
  417. while(ptr <= end)
  418. {
  419. if(*ptr & 0x80)
  420. {
  421. IsUnicode = TRUE;
  422. break;
  423. }
  424. }
  425. ptr = (char *)lpText;
  426. CRect rtText;
  427. CSize sz;
  428. int top = lpRect->top;
  429. if(!IsUnicode)
  430. {
  431. lf->lfEscapement = 900;
  432. lf->lfOrientation = 900;
  433. CFont font;
  434. font.CreateFontIndirect(lf);
  435. pDC->SelectObject(&font);
  436. sz = pDC->GetTextExtent(start,(int)(end - start));
  437. rtText.left = lpRect->left + (lpRect->right - lpRect->left - sz.cy)/2;
  438. rtText.top = top;
  439. rtText.bottom = rtText.top + sz.cx;
  440. rtText.right = lpRect->right;
  441. pDC->TextOut(rtText.left,rtText.bottom,start,(int)(end - start));
  442. return TRUE;
  443. }
  445. lf->lfEscapement = 0;
  446. lf->lfOrientation = 0;
  447. CFont font;
  448. font.CreateFontIndirect(lf);
  449. pDC->SelectObject(&font);
  450. while(ptr <= end)
  451. {
  453. //UNICODE 
  454. if(*ptr & 0x80)
  455. {
  456. if(ptr + 1 > end)break;
  457. start = ptr;
  458. ptr += 2;
  459. sz = pDC->GetTextExtent(start,(int)(ptr - start));
  460. CRect rtText;
  461. rtText.SetRect(lpRect->left + (lpRect->right - lpRect->left - sz.cx)/2,
  462. top,lpRect->right,lpRect->bottom);
  463. pDC->TextOut(rtText.left,rtText.top, start,(int)(ptr - start));
  464. top += sz.cy;
  465. }
  466. else
  467. {
  468. start = ptr;
  469. ptr += 1;
  470. sz = pDC->GetTextExtent(start,(int)(ptr - start));
  471. CRect rtText;
  472. rtText.SetRect(lpRect->left + (lpRect->right - lpRect->left - sz.cx)/2,
  473. top,lpRect->right,lpRect->bottom);
  474. pDC->TextOut(rtText.left,rtText.top, start,(int)(ptr - start));
  475. top += sz.cy;
  476. }
  477. }
  478. return TRUE;
  479. }
  481. //BITMAP Width and height > 9
  482. BOOL CRTDraw::RTDrawBitmap(CDC* pDC, LPCRECT lpRect, CBitmap* pBitmap,UINT Mode)
  483. {
  484. if(pDC == NULL)return FALSE;
  485. if(pBitmap == NULL)return FALSE;
  487. BITMAP bitmap;
  488. pBitmap->GetBitmap(&bitmap);
  489. if(bitmap.bmWidth < 9)return FALSE;
  490. if(bitmap.bmHeight < 9)return FALSE;
  492. CDC srcDC;
  493. srcDC.CreateCompatibleDC(pDC);
  494. CBitmap *pOldBitmap = srcDC.SelectObject(pBitmap);
  496. if(Mode == DrawModeState)
  497. {
  498. pDC->StretchBlt(lpRect->left,lpRect->top,bitmap.bmWidth,bitmap.bmHeight,
  499. &srcDC,0,0,bitmap.bmWidth,bitmap.bmHeight,SRCCOPY);
  500. return TRUE;
  501. }
  503. if((DrawMode)Mode == DrawModeAllStretch)
  504. {
  505. pDC->StretchBlt(lpRect->left,lpRect->top,lpRect->right - lpRect->left,
  506. lpRect->bottom - lpRect->top,&srcDC,0,0,bitmap.bmWidth,bitmap.bmHeight,SRCCOPY);
  507. srcDC.SelectObject(pOldBitmap);
  508. srcDC.DeleteDC();
  509. return TRUE;
  510. }
  512. int height;
  513. int width;
  515. if((DrawMode)Mode == DrawModeFill)
  516. {
  517. int left = lpRect->left;
  518. int top = lpRect->top;
  519. while(left < lpRect->right)
  520. {
  521. if(lpRect->right - left <= bitmap.bmWidth)
  522. {
  523. width = lpRect->right - left;
  524. if(lpRect->bottom - top <= bitmap.bmHeight)
  525. {
  526. height = lpRect->bottom - top;
  527. pDC->BitBlt(left,top,width,height,&srcDC,0,0,SRCCOPY);
  528. break;
  529. }
  530. else
  531. {
  532. height = bitmap.bmHeight;
  533. pDC->BitBlt(left,top,width,height,&srcDC,0,0,SRCCOPY);
  534. top += height;
  535. left = lpRect->left;
  536. }
  537. }
  538. else
  539. {
  540. width = bitmap.bmWidth;
  541. if(lpRect->bottom - top <= bitmap.bmHeight)
  542. {
  543. height = lpRect->bottom - top;
  544. pDC->BitBlt(left,top,width,height,&srcDC,0,0,SRCCOPY);
  545. }
  546. else
  547. {
  548. height = bitmap.bmHeight;
  549. pDC->BitBlt(left,top,width,height,&srcDC,0,0,SRCCOPY);
  550. }
  551. left += width;
  552. }
  553. }
  554. srcDC.SelectObject(pOldBitmap);
  555. srcDC.DeleteDC();
  556. return TRUE;
  557. }
  559. if(Mode == DrawModeHeightStretch)
  560. {
  561. height = lpRect->bottom - lpRect->top;
  562. int top = lpRect->top;
  563. int left = lpRect->left;
  564. int right = lpRect->right;
  566. while((right - left) >= bitmap.bmWidth)
  567. {
  568. pDC->StretchBlt(left,top,bitmap.bmWidth,height,
  569. &srcDC,0,0,bitmap.bmWidth,bitmap.bmHeight,SRCCOPY);
  570. left += bitmap.bmWidth;
  571. }
  572. width = right - left;
  573. pDC->StretchBlt(left,top,width,height,
  574. &srcDC,0,0,width,bitmap.bmHeight,SRCCOPY);
  576. srcDC.SelectObject(&pOldBitmap);
  577. srcDC.DeleteDC();
  578. return TRUE;
  579. }
  581. if(Mode == DrawModeWidthStretch)
  582. {
  583. height = lpRect->bottom - lpRect->top;
  584. int top = lpRect->top;
  585. width = lpRect->right - lpRect->left;
  586. int left = lpRect->left;
  587. int bottom = lpRect->bottom;
  589. while((bottom - top) >= bitmap.bmHeight)
  590. {
  591. pDC->StretchBlt(left,top,width,bitmap.bmHeight,
  592. &srcDC,0,0,bitmap.bmWidth,bitmap.bmHeight,SRCCOPY);
  593. top += bitmap.bmHeight;
  594. }
  595. height = bottom - top;
  596. pDC->StretchBlt(left,top,width,height,
  597. &srcDC,4,0,bitmap.bmWidth,height,SRCCOPY);
  599. srcDC.SelectObject(&pOldBitmap);
  600. srcDC.DeleteDC();
  601. }
  603. if(Mode == DrawMode3D)
  604. {
  605. int width = bitmap.bmWidth/3;
  606. int height = bitmap.bmHeight/3;
  608. int x = lpRect->left + width;
  609. int y = lpRect->top + height;
  611. //fill center
  612. while( x + width < lpRect->right)
  613. {
  614. while(y + height < lpRect->bottom)
  615. {
  616. pDC->BitBlt(x,y,width,height,&srcDC,width,height,SRCCOPY);
  617. y += height;
  618. }
  619. y = lpRect->top + height;
  620. x += width;
  621. }
  622. //draw top border
  623. x = lpRect->left + width;
  624. y = lpRect->top;
  625. pDC->BitBlt(lpRect->left,y,width,height,&srcDC,0,0,SRCCOPY);
  626. while( x + width < lpRect->right)
  627. {
  628. pDC->BitBlt(x,y,width,height,&srcDC,width,0,SRCCOPY);
  629. x += width;
  630. }
  631. pDC->BitBlt(lpRect->right - width,y,width,height,&srcDC,width + width,0,SRCCOPY);
  633. //draw left border
  634. x = lpRect->left;
  635. y = lpRect->top + height;
  636. while( y + height < lpRect->bottom)
  637. {
  638. pDC->BitBlt(x,y,width,height,&srcDC,0,height,SRCCOPY);
  639. y += height;
  640. }
  642. //draw right border
  643. x = lpRect->right - width;
  644. y = lpRect->top + height;
  645. while( y + height < lpRect->bottom)
  646. {
  647. pDC->BitBlt(x,y,width,height,&srcDC,width + width,height,SRCCOPY);
  648. y += height;
  649. }
  651. //draw bottom border
  652. x = lpRect->left + width;
  653. y = lpRect->bottom - height;
  654. pDC->BitBlt(lpRect->left,y,width,height,&srcDC,0,height + height,SRCCOPY);
  655. while( x + width < lpRect->right)
  656. {
  657. pDC->BitBlt(x,y,width,height,&srcDC,width,height + height,SRCCOPY);
  658. x += width;
  659. }
  660. pDC->BitBlt(lpRect->right - width,y,width,height,&srcDC,width + width,height + height,SRCCOPY);
  662. srcDC.SelectObject(&pOldBitmap);
  663. srcDC.DeleteDC();
  664. return TRUE;
  665. }
  666. if(Mode == DrawModeHeightStretch3D)
  667. {
  668. int width = bitmap.bmWidth / 3;
  669. int height = lpRect->bottom - lpRect->top;
  670. int x = lpRect->left;
  671. int y = lpRect->top;
  672. int right = lpRect->right;
  674. pDC->StretchBlt(x,y,width,height,&srcDC,0,0,width,bitmap.bmHeight,SRCCOPY);
  675. while((x + width) < right)
  676. {
  677. pDC->StretchBlt(x,y,width,height,&srcDC,width,0,width,bitmap.bmHeight,SRCCOPY);
  678. x += width;
  679. }
  680. pDC->StretchBlt(right - width,y,width,height,&srcDC,width + width,0,width,bitmap.bmHeight,SRCCOPY);
  682. srcDC.SelectObject(&pOldBitmap);
  683. srcDC.DeleteDC();
  684. return TRUE;
  685. }
  687. if(Mode == DrawModeHeightCenter3D)
  688. {
  689. int width = bitmap.bmWidth / 3;
  690. int height = lpRect->bottom - lpRect->top;
  691. int x = lpRect->left;
  692. int y = lpRect->top;
  693. int right = lpRect->right;
  694. while((x + width) < right)
  695. {
  696. pDC->StretchBlt(x,y,width,height,&srcDC,width,0,width,bitmap.bmHeight,SRCCOPY);
  697. x += width;
  698. }
  699. pDC->StretchBlt(right - width,y,width,height,&srcDC,width,0,width,bitmap.bmHeight,SRCCOPY);
  701. srcDC.SelectObject(&pOldBitmap);
  702. srcDC.DeleteDC();
  703. return TRUE;
  704. }
  706. srcDC.SelectObject(&pOldBitmap);
  707. srcDC.DeleteDC();
  708. return TRUE;
  709. }
  711. HRGN CRTDraw::BitmapToRegion (HBITMAP hBmp, COLORREF cTransparentColor, COLORREF cTolerance)
  712. {
  713.     HRGN hRgn = NULL;
  715.     if (hBmp)
  716.     {
  717.         // Create a memory DC inside which we will scan the bitmap content
  718.         HDC hMemDC = CreateCompatibleDC(NULL);
  719.         if (hMemDC)
  720.         {
  721.             // Get bitmap size
  722.             BITMAP bm;
  723.             GetObject(hBmp, sizeof(bm), &bm);
  725.             // Create a 32 bits depth bitmap and select it into the memory DC 
  726.             BITMAPINFOHEADER RGB32BITSBITMAPINFO = {    
  727.                     sizeof(BITMAPINFOHEADER),    // biSize 
  728.                     bm.bmWidth,                    // biWidth; 
  729.                     bm.bmHeight,                // biHeight; 
  730.                     1,                            // biPlanes; 
  731.                     32,                            // biBitCount 
  732.                     BI_RGB,                        // biCompression; 
  733.                     0,                            // biSizeImage; 
  734.                     0,                            // biXPelsPerMeter; 
  735.                     0,                            // biYPelsPerMeter; 
  736.                     0,                            // biClrUsed; 
  737.                     0                            // biClrImportant; 
  738.             };
  739.             VOID * pbits32; 
  740.             HBITMAP hbm32 = CreateDIBSection(hMemDC, (BITMAPINFO *)&RGB32BITSBITMAPINFO, DIB_RGB_COLORS, &pbits32, NULL, 0);
  741.             if (hbm32)
  742.             {
  743.                 HBITMAP holdBmp = (HBITMAP)SelectObject(hMemDC, hbm32);
  745.                 // Create a DC just to copy the bitmap into the memory DC
  746.                 HDC hDC = CreateCompatibleDC(hMemDC);
  747.                 if (hDC)
  748.                 {
  749.                     // Get how many bytes per row we have for the bitmap bits (rounded up to 32 bits)
  750.                     BITMAP bm32;
  751.                     GetObject(hbm32, sizeof(bm32), &bm32);
  752.                     while (bm32.bmWidthBytes % 4)
  753.                         bm32.bmWidthBytes++;
  755.                     // Copy the bitmap into the memory DC
  756.                     HBITMAP holdBmp = (HBITMAP)SelectObject(hDC, hBmp);
  757.                     BitBlt(hMemDC, 0, 0, bm.bmWidth, bm.bmHeight, hDC, 0, 0, SRCCOPY);
  759.                     // For better performances, we will use the ExtCreateRegion() function to create the
  760.                     // region. This function take a RGNDATA structure on entry. We will add rectangles by
  761.                     // amount of ALLOC_UNIT number in this structure.
  762.                     #define ALLOC_UNIT    100
  763.                     DWORD maxRects = ALLOC_UNIT;
  764.                     HANDLE hData = GlobalAlloc(GMEM_MOVEABLE, sizeof(RGNDATAHEADER) + (sizeof(RECT) * maxRects));
  765.                     RGNDATA *pData = (RGNDATA *)GlobalLock(hData);
  766.                     pData->rdh.dwSize = sizeof(RGNDATAHEADER);
  767.                     pData->rdh.iType = RDH_RECTANGLES;
  768.                     pData->rdh.nCount = pData->rdh.nRgnSize = 0;
  769.                     SetRect(&pData->rdh.rcBound, MAXLONG, MAXLONG, 0, 0);
  771.                     // Keep on hand highest and lowest values for the "transparent" pixels
  772.                     BYTE lr = GetRValue(cTransparentColor);
  773.                     BYTE lg = GetGValue(cTransparentColor);
  774.                     BYTE lb = GetBValue(cTransparentColor);
  775.                     BYTE hr = min(0xff, lr + GetRValue(cTolerance));
  776.                     BYTE hg = min(0xff, lg + GetGValue(cTolerance));
  777.                     BYTE hb = min(0xff, lb + GetBValue(cTolerance));
  779.                     // Scan each bitmap row from bottom to top (the bitmap is inverted vertically)
  780.                     BYTE *p32 = (BYTE *)bm32.bmBits + (bm32.bmHeight - 1) * bm32.bmWidthBytes;
  781.                     for (int y = 0; y < bm.bmHeight; y++)
  782.                     {
  783. TRACE("n");
  784.                         // Scan each bitmap pixel from left to right
  785.                         for (int x = 0; x < bm.bmWidth; x++)
  786.                         {
  787.                             // Search for a continuous range of "non transparent pixels"
  788.                             int x0 = x;
  789.                             LONG *p = (LONG *)p32 + x;
  790.                             while (x < bm.bmWidth)
  791.                             {
  792. TRACE("1");
  793.                                 BYTE b = GetRValue(*p);
  794.                                 if (b >= lr && b <= hr)
  795.                                 {
  796.                                     b = GetGValue(*p);
  797.                                     if (b >= lg && b <= hg)
  798.                                     {
  799.                                         b = GetBValue(*p);
  800.                                         if (b >= lb && b <= hb)
  801. {
  802. TRACE("0");
  803.                                             // This pixel is "transparent"
  804. break;
  805. }
  806.                                     }
  807.                                 }
  808.                                 p++;
  809.                                 x++;
  810.                             }
  812.                             if (x > x0)
  813.                             {
  814.                                 // Add the pixels (x0, y) to (x, y+1) as a new rectangle in the region
  815.                                 if (pData->rdh.nCount >= maxRects)
  816.                                 {
  817.                                     GlobalUnlock(hData);
  818.                                     maxRects += ALLOC_UNIT;
  819.                                     hData = GlobalReAlloc(hData, sizeof(RGNDATAHEADER) + (sizeof(RECT) * maxRects), GMEM_MOVEABLE);
  820.                                     pData = (RGNDATA *)GlobalLock(hData);
  821.                                 }
  822.                                 RECT *pr = (RECT *)&pData->Buffer;
  823.                                 SetRect(&pr[pData->rdh.nCount], x0, y, x, y+1);
  824.                                 if (x0 < pData->rdh.rcBound.left)
  825.                                     pData->rdh.rcBound.left = x0;
  826.                                 if (y < pData->rdh.rcBound.top)
  827.                                     pData->rdh.rcBound.top = y;
  828.                                 if (x > pData->rdh.rcBound.right)
  829.                                     pData->rdh.rcBound.right = x;
  830.                                 if (y+1 > pData->rdh.rcBound.bottom)
  831.                                     pData->rdh.rcBound.bottom = y+1;
  832.                                 pData->rdh.nCount++;
  834.                                 // On Windows98, ExtCreateRegion() may fail if the number of rectangles is too
  835.                                 // large (ie: > 4000). Therefore, we have to create the region by multiple steps.
  836.                                 if (pData->rdh.nCount == 2000)
  837.                                 {
  838.                                     HRGN h = ExtCreateRegion(NULL, sizeof(RGNDATAHEADER) + (sizeof(RECT) * maxRects), pData);
  839.                                     if (hRgn)
  840.                                     {
  841.                                         CombineRgn(hRgn, hRgn, h, RGN_OR);
  842.                                         DeleteObject(h);
  843.                                     }
  844.                                     else
  845.                                         hRgn = h;
  846.                                     pData->rdh.nCount = 0;
  847.                                     SetRect(&pData->rdh.rcBound, MAXLONG, MAXLONG, 0, 0);
  848.                                 }
  849.                             }
  850.                         }
  852.                         // Go to next row (remember, the bitmap is inverted vertically)
  853.                         p32 -= bm32.bmWidthBytes;
  854.                     }
  856.                     // Create or extend the region with the remaining rectangles
  857.                     HRGN h = ExtCreateRegion(NULL, sizeof(RGNDATAHEADER) + (sizeof(RECT) * maxRects), pData);
  858.                     if (hRgn)
  859.                     {
  860.                         CombineRgn(hRgn, hRgn, h, RGN_OR);
  861.                         DeleteObject(h);
  862.                     }
  863.                     else
  864.                         hRgn = h;
  866.                     // Clean up
  867.                     GlobalFree(hData);
  868.                     SelectObject(hDC, holdBmp);
  869.                     DeleteDC(hDC);
  870.                 }
  872.                 DeleteObject(SelectObject(hMemDC, holdBmp));
  873.             }
  875.             DeleteDC(hMemDC);
  876.         }    
  877.     }
  879.     return hRgn;
  880. }