home *** CD-ROM | disk | FTP | other *** search
/ Windows Graphics Programming / Feng_Yuan_Win32_GDI_DirectX.iso / Samples / Chapt_10 / Bitmaps / Bitmaps.cpp next >
C/C++ Source or Header  |  2000-05-25  |  31KB  |  1,247 lines
  1. //-----------------------------------------------------------------------------------//
  2. //              Windows Graphics Programming: Win32 GDI and DirectDraw               //
  3. //                             ISBN  0-13-086985-6                                   //
  4. //                                                                                   //
  5. //  Written            by  Yuan, Feng                             www.fengyuan.com   //
  6. //  Copyright (c) 2000 by  Hewlett-Packard Company                www.hp.com         //
  7. //  Published          by  Prentice Hall PTR, Prentice-Hall, Inc. www.phptr.com      //
  8. //                                                                                   //
  9. //  FileName   : bitmaps.cpp                                                         //
  10. //  Description: Basic bitmap demo program, Chapter 10                               //
  11. //  Version    : 1.00.000, May 31, 2000                                              //
  12. //-----------------------------------------------------------------------------------//
  13.  
  14. #define STRICT
  15. #define _WIN32_WINNT 0x0500
  16. #define NOCRYPT
  17. #define OEMRESOURCE
  18.  
  19. #include <windows.h>
  20. #include <assert.h>
  21. #include <tchar.h>
  22. #include <math.h>
  23.  
  24. #include "..\..\include\wingraph.h"
  25. #include "..\..\include\CheckMark.h"
  26. #include "..\..\include\BitmapMenu.h"
  27. #include "..\..\include\EditView.h"
  28. #include "..\..\include\Background.h"
  29.  
  30. #include "Resource.h"
  31.  
  32. BOOL SaveWindow(HWND hWnd, bool bClient, int nFrame, COLORREF crFrame);
  33.  
  34. class KDIBView : public KScrollCanvas
  35. {
  36.     typedef enum { GAP = 16 };
  37.  
  38.     virtual void    OnDraw(HDC hDC, const RECT * rcPaint);
  39.     virtual LRESULT WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
  40.     void            GetWndClassEx(WNDCLASSEX & wc);
  41.     
  42.     HMENU            m_hViewMenu;
  43.     int                m_nViewOpt;
  44.  
  45. public:
  46.  
  47.     HINSTANCE        m_hInst;
  48.     KDIB            m_DIB;
  49.  
  50.     KDIBView(void)
  51.     {
  52.         m_hViewMenu = NULL;
  53.         m_nViewOpt  = IDM_VIEW_STRETCHDIBITS;
  54.     }
  55.  
  56.     bool Initialize(const TCHAR * pFileName, HINSTANCE hInstance, KStatusWindow * pStatus)
  57.     {
  58.         if ( m_DIB.LoadFile(pFileName) )
  59.         {
  60.             SetSize(m_DIB.GetWidth()  + GAP*2,
  61.                     m_DIB.GetHeight() + GAP*2, 5, 5);
  62.  
  63.             m_hInst   = hInstance;
  64.             m_pStatus = pStatus;
  65.  
  66.             RegisterClass(_T("DIBView"), hInstance);
  67.             
  68.             return true;
  69.         }
  70.         else
  71.             return false;
  72.     }
  73.  
  74.     bool GetTitle(const TCHAR * pFileName, TCHAR * pTitle)
  75.     {
  76.         if ( pFileName )
  77.         {
  78.             wsprintf(pTitle, "%s, %d x %d pixel, %d bits", pFileName,
  79.                 m_DIB.GetWidth(), m_DIB.GetHeight(), m_DIB.GetDepth());
  80.  
  81.             return true;
  82.         }
  83.         else
  84.             return false;
  85.     }
  86. };
  87.  
  88.  
  89. void KDIBView::GetWndClassEx(WNDCLASSEX & wc)
  90. {
  91.     memset(& wc, 0, sizeof(wc));
  92.  
  93.     wc.cbSize         = sizeof(WNDCLASSEX);
  94.     wc.style          = CS_HREDRAW | CS_VREDRAW;
  95.     wc.lpfnWndProc    = WindowProc;
  96.     wc.cbClsExtra     = 0;
  97.     wc.cbWndExtra     = 0;       
  98.     wc.hInstance      = NULL;
  99.     wc.hIcon          = LoadIcon(m_hInst, MAKEINTRESOURCE(IDI_IMAGE));
  100.     wc.hCursor        = LoadCursor(NULL, IDC_ARROW);
  101.     wc.hbrBackground  = (HBRUSH) (COLOR_GRAYTEXT + 1);
  102.     wc.lpszMenuName   = NULL;
  103.     wc.lpszClassName  = NULL;
  104.     wc.hIconSm        = NULL;
  105. }
  106.  
  107.  
  108. LRESULT KDIBView::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
  109. {
  110.     switch( uMsg )
  111.     {
  112.         case WM_CREATE:
  113.             m_hWnd        = hWnd;
  114.             m_hViewMenu = LoadMenu(m_hInst, MAKEINTRESOURCE(IDR_DIBVIEW));
  115.             return 0;
  116.  
  117.         case WM_PAINT:
  118.             return KScrollCanvas::WndProc(hWnd, uMsg, wParam, lParam);
  119.  
  120.         case WM_SIZE:
  121.         case WM_HSCROLL:
  122.         case WM_VSCROLL:
  123.         {
  124.             LRESULT lr = KScrollCanvas::WndProc(hWnd, uMsg, wParam, lParam);
  125.  
  126.             int nMin, nMax, nPos;
  127.  
  128.             GetScrollRange(m_hWnd, SB_VERT, &nMin, &nMax);
  129.  
  130.             nPos = GetScrollPos(m_hWnd, SB_VERT);
  131.  
  132.             TCHAR mess[32];
  133.             wsprintf(mess, "%d %d %d", nMin, nPos, nMax);
  134.             m_pStatus->SetText(0, mess);
  135.  
  136.             return lr;
  137.         }
  138.  
  139.         case WM_COMMAND:
  140.             switch ( LOWORD(wParam) )
  141.             {
  142.                 case IDM_VIEW_STRETCHDIBITS:
  143.                 case IDM_VIEW_STRETCHDIBITS4:
  144.                 case IDM_VIEW_SETDIBITSTODEVICE:
  145.                 case IDM_VIEW_FITWINDOW:
  146.                     if ( LOWORD(wParam)!= m_nViewOpt )
  147.                     {
  148.                         m_nViewOpt = LOWORD(wParam);
  149.  
  150.                         switch ( LOWORD(wParam) )
  151.                         {
  152.                             case IDM_VIEW_STRETCHDIBITS:
  153.                             case IDM_VIEW_SETDIBITSTODEVICE:
  154.                                 SetSize(m_DIB.GetWidth() + GAP*2, m_DIB.GetHeight() + GAP*2, 5, 5, true);
  155.                                 break;
  156.  
  157.                             case IDM_VIEW_STRETCHDIBITS4:
  158.                                 SetSize(m_DIB.GetWidth()*2 + GAP*3, m_DIB.GetHeight()*2 + GAP*3, 5, 5, true);
  159.                         }
  160.  
  161.                         InvalidateRect(hWnd, NULL, TRUE);
  162.                     }
  163.                     return 0;
  164.  
  165.                 case IDM_FILE_SAVEDIB1BPP:    SaveWindowToDIB(hWnd,  1, BI_RGB); return 0;
  166.                 case IDM_FILE_SAVEDIB4BPP:    SaveWindowToDIB(hWnd,  4, BI_RGB); return 0;
  167.                 case IDM_FILE_SAVEDIB4RLE:    SaveWindowToDIB(hWnd,  4, BI_RLE4); return 0;
  168.                 case IDM_FILE_SAVEDIB8BPP:    SaveWindowToDIB(hWnd,  8, BI_RGB); return 0;
  169.                 case IDM_FILE_SAVEDIB8RLE:    SaveWindowToDIB(hWnd,  8, BI_RLE8); return 0;
  170.                 case IDM_FILE_SAVEDIB16BPP: SaveWindowToDIB(hWnd, 16, BI_RGB); return 0;
  171.           case IDM_FILE_SAVEDIB16BITFIELDS: SaveWindowToDIB(hWnd, 16, BI_BITFIELDS); return 0;
  172.                 case IDM_FILE_SAVEDIB24BPP: SaveWindowToDIB(hWnd, 24, BI_RGB); return 0;
  173.                 case IDM_FILE_SAVEDIB32BPP: SaveWindowToDIB(hWnd, 32, BI_RGB); return 0;
  174.           case IDM_FILE_SAVEDIB32BITFIELDS: SaveWindowToDIB(hWnd, 32, BI_BITFIELDS); return 0;
  175.  
  176.             case IDM_FILE_SAVEDIBSECTION:  SaveWindow(hWnd, true, 25, RGB(209, 177, 80)); return 0;
  177.  
  178.                 case IDM_VIEW_DIBHEXDUMP:
  179.                     SendMessage(GetParent(GetParent(hWnd)), WM_USER+1, (WPARAM) & m_DIB, 0);    
  180.             }
  181.             return 0;
  182.  
  183.         default:
  184.             return CommonMDIChildProc(hWnd, uMsg, wParam, lParam, m_hViewMenu, 3);
  185.     }
  186. }
  187.  
  188. void KDIBView::OnDraw(HDC hDC, const RECT * rcPaint)
  189. {
  190. //    HDC        hMemDC  = CreateCompatibleDC(hDC);
  191. //    HBITMAP hBitmap = CreateBitmap(m_DIB.GetWidth(), m_DIB.GetHeight(), 1, 1, NULL);
  192. //    HGDIOBJ hOld    = SelectObject(hMemDC, hBitmap);
  193. //
  194. //    SetBkColor(hMemDC, RGB(0xFF, 0xFF, 0xFF));
  195. //    SetTextColor(hMemDC, RGB(0xFF, 0xFF, 0xFF));
  196. //    SetStretchBltMode(hMemDC, STRETCH_DELETESCANS);
  197. //    m_DIB.StretchDIBits(hMemDC, 0, 0, SRCCOPY);
  198.  
  199. //    BitBlt(hDC, GAP, GAP, m_DIB.GetWidth(), m_DIB.GetHeight(), 
  200. //                hMemDC, 0, 0, SRCCOPY);
  201.  
  202. //    SelectObject(hMemDC, hOld);
  203. //    DeleteObject(hBitmap);
  204. //    DeleteObject(hMemDC);
  205.  
  206.     SaveDC(hDC);
  207. //    CAffine affine;
  208. //    affine.Rotate(5);
  209. //    affine.Translate(20, 20);
  210. //    SetGraphicsMode(hDC, GM_ADVANCED);
  211. //    SetWorldTransform(hDC, & affine.m_xm);
  212.  
  213.     int w = m_DIB.GetWidth();
  214.     int h = m_DIB.GetHeight();
  215.  
  216.     switch ( m_nViewOpt )
  217.     {
  218.         case IDM_VIEW_FITWINDOW:
  219.             {
  220.                 RECT rect;
  221.  
  222.                 GetClientRect(m_hWnd, & rect);
  223.                 m_DIB.DrawDIB(hDC, 0, 0, rect.right, rect.bottom, 0, 0, w, h, SRCCOPY);
  224.             }
  225.             break;
  226.  
  227.         case IDM_VIEW_STRETCHDIBITS:
  228.             m_DIB.DrawDIB(hDC, GAP,   GAP,    w, h, 0, 0,  w,  h, SRCCOPY);
  229.             break;
  230.  
  231.         case IDM_VIEW_STRETCHDIBITS4:
  232.             m_DIB.DrawDIB(hDC, GAP,     GAP,     w, h, 0, 0,  w,  h, SRCCOPY);
  233.             m_DIB.DrawDIB(hDC, GAP*2+w, GAP,     w, h, w, 0, -w,  h, SRCCOPY);
  234.             m_DIB.DrawDIB(hDC, GAP,     GAP*2+h, w, h, 0, h,  w, -h, SRCCOPY);
  235.             m_DIB.DrawDIB(hDC, GAP*2+w, GAP*2+h, w, h, w, h, -w, -h, SRCCOPY);
  236.             break;
  237.  
  238.         case IDM_VIEW_SETDIBITSTODEVICE:
  239.             if ( ! m_DIB.IsCompressed() )
  240.             {
  241.                 int  bps      = m_DIB.GetBPS();
  242.                 BYTE * buffer = new BYTE[bps];
  243.  
  244.                 for (int i=0; i<m_DIB.GetHeight(); i++)
  245.                 {
  246.                     memcpy(buffer, m_DIB.GetBits() + bps*i, bps);
  247.  
  248.                     for (int j=0; j<bps; j++)
  249.                         buffer[j] = ~ buffer[j];
  250.  
  251.                     m_DIB.SetDIB(hDC, GAP, GAP, i, 1, buffer);
  252.                 }
  253.                 delete [] buffer;
  254.             }
  255.             break;
  256.     }
  257.  
  258.     RestoreDC(hDC, -1);
  259. }
  260.  
  261.  
  262.  
  263. //////////////////////
  264.  
  265. const int TextureID[] = 
  266. { 
  267.     IDB_BRICK01, 
  268.     IDB_BRICK02, 
  269.     IDB_WOOD01, 
  270.     IDB_WOOD02, 
  271.     IDB_ROCK01, 
  272.     IDB_MARBLE01, 
  273.     IDB_PAPER01 
  274. };
  275.  
  276. class KDDBView : public KScrollCanvas
  277. {
  278.     typedef enum { GAP = 16 };
  279.  
  280.     virtual void    OnDraw(HDC hDC, const RECT * rcPaint);
  281.     virtual LRESULT WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
  282.     void            GetWndClassEx(WNDCLASSEX & wc);
  283.     
  284.     HMENU            m_hViewMenu;
  285.     int                m_nViewOpt;
  286.  
  287.     void            TouchMenu(HMENU hMenu);
  288.     KCheckMark        m_uibmp;
  289.     KBitmapMenu     m_texture;
  290.  
  291. public:
  292.  
  293.     KDDBView(void)
  294.     {
  295.         m_hViewMenu = NULL;
  296.         m_nViewOpt  = IDM_VIEW_CREATEBITMAP;
  297.     }
  298.  
  299.     bool Initialize(HINSTANCE hInstance, KStatusWindow * pStatus)
  300.     {
  301.         // SetSize(m_DIB.GetWidth()  + GAP*2,    m_DIB.GetHeight() + GAP*2, 5, 5);
  302.  
  303.         m_hInst   = hInstance;
  304.         m_pStatus = pStatus;
  305.  
  306.         RegisterClass(_T("DDBView"), hInstance);
  307.             
  308.         return true;
  309.     }
  310.  
  311.     void Test_CreateBitmap(HDC hDC, const RECT * rcPaint);
  312.     void Test_LargestDDB(HDC hDC, const RECT * rcPaint);
  313.     void Test_LoadBitmap(HDC hDC, const RECT * rcPaint);
  314.     void Test_Blt(HDC hDC, const RECT * rcPaint);
  315.     void Test_Blt_Color(HDC hDC, const RECT * rcPaint);
  316.     void Test_Blt_GenMask(HDC hDC, const RECT * rcPaint);
  317. };
  318.  
  319.  
  320. void KDDBView::TouchMenu(HMENU hMainMenu)
  321. {
  322.     HMENU hMenu = GetSubMenu(hMainMenu, 3);
  323.  
  324.     m_uibmp.LoadToolbar(m_hInst, IDB_LICON, true);
  325.  
  326.     for (int i=0; i<20; i++)
  327.         m_uibmp.SetCheckMarks(hMenu, i, MF_BYPOSITION, i, -1);
  328.  
  329.     m_texture.AddToMenu(GetSubMenu(hMainMenu, 4), 7, m_hInst, TextureID, 10);
  330. }
  331.  
  332.  
  333. void KDDBView::GetWndClassEx(WNDCLASSEX & wc)
  334. {
  335.     memset(& wc, 0, sizeof(wc));
  336.  
  337.     wc.cbSize         = sizeof(WNDCLASSEX);
  338.     wc.style          = CS_HREDRAW | CS_VREDRAW;
  339.     wc.lpfnWndProc    = WindowProc;
  340.     wc.cbClsExtra     = 0;
  341.     wc.cbWndExtra     = 0;       
  342.     wc.hInstance      = NULL;
  343.     wc.hIcon          = LoadIcon(m_hInst, MAKEINTRESOURCE(IDI_IMAGE));
  344.     wc.hCursor        = LoadCursor(NULL, IDC_ARROW);
  345.     wc.hbrBackground  = (HBRUSH) GetStockObject(WHITE_BRUSH);
  346.     wc.lpszMenuName   = NULL;
  347.     wc.lpszClassName  = NULL;
  348.     wc.hIconSm        = NULL;
  349. }
  350.  
  351.  
  352. LRESULT KDDBView::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
  353. {
  354.     switch( uMsg )
  355.     {
  356.         case WM_CREATE:
  357.             m_hWnd        = hWnd;
  358.             m_hViewMenu = LoadMenu(m_hInst, MAKEINTRESOURCE(IDR_DDBVIEW));
  359.             TouchMenu(m_hViewMenu);
  360.             return 0;
  361.  
  362.         case WM_PAINT:
  363.             return KScrollCanvas::WndProc(hWnd, uMsg, wParam, lParam);
  364.  
  365.         case WM_SIZE:
  366.         case WM_HSCROLL:
  367.         case WM_VSCROLL:
  368.         {
  369.             LRESULT lr = KScrollCanvas::WndProc(hWnd, uMsg, wParam, lParam);
  370.  
  371.             int nMin, nMax, nPos;
  372.  
  373.             GetScrollRange(m_hWnd, SB_VERT, &nMin, &nMax);
  374.  
  375.             nPos = GetScrollPos(m_hWnd, SB_VERT);
  376.  
  377.             TCHAR mess[32];
  378.             wsprintf(mess, "%d %d %d", nMin, nPos, nMax);
  379.             m_pStatus->SetText(0, mess);
  380.  
  381.             return lr;
  382.         }
  383.  
  384.         case WM_COMMAND:
  385.             switch ( LOWORD(wParam) )
  386.             {
  387.                 case IDM_VIEW_CREATEBITMAP:
  388.                 case IDM_VIEW_LARGESTDDB:
  389.                 case IDM_VIEW_LOADBITMAP:
  390.                 case IDM_VIEW_LOADBITMAPHEX:
  391.                 case IDM_VIEW_CREATEDIBITMAP:
  392.                 case IDM_VIEW_CREATEDIBITMAPHEX:
  393.  
  394.                 case IDM_VIEW_BLT_NORMAL:
  395.                 case IDM_VIEW_BLT_CENTER:
  396.                 case IDM_VIEW_BLT_STRETCH:
  397.                 case IDM_VIEW_BLT_TILE:
  398.                 case IDM_VIEW_BLT_STRETCHPROP:
  399.                 case IDM_VIEW_BITBLT_COLOR:
  400.                 case IDM_VIEW_GENMASK:
  401.                     if ( LOWORD(wParam)!= m_nViewOpt )
  402.                     {
  403.                         m_nViewOpt = LOWORD(wParam);
  404.  
  405.                         InvalidateRect(hWnd, NULL, TRUE);
  406.                     }
  407.                     return 0;
  408.                 
  409.                 default:
  410.                     switch ( m_texture.OnCommand(LOWORD(wParam)) )
  411.                     {
  412.                         case 1: return 0;
  413.                         case 2: InvalidateRect(hWnd, NULL, TRUE); return 0;
  414.                     }
  415.                     break;
  416.             }
  417.     }
  418.  
  419.     return CommonMDIChildProc(hWnd, uMsg, wParam, lParam, m_hViewMenu, 3);
  420. }
  421.  
  422.  
  423.  
  424. // special routine to display a 8x8 DDB as 32x32
  425. void TestDDB88(HDC hDC, int x, int y, HBITMAP hBmp, const TCHAR * desp)
  426. {
  427.     HDC hMemDC = CreateCompatibleDC(hDC);
  428.     SelectObject(hMemDC, hBmp);
  429.  
  430.     StretchBlt(hDC, x, y, 32, 32, hMemDC, 0, 0, 8, 8, SRCCOPY);
  431.     
  432.     TCHAR mess[64];
  433.  
  434.     TextOut(hDC, x+50, y, desp, _tcslen(desp));
  435.         
  436.     DecodeDDB(hBmp, mess);
  437.     TextOut(hDC, x+50, y+20, mess, _tcslen(mess));
  438.  
  439.     DeleteObject(hMemDC);
  440.     DeleteObject(hBmp);
  441. }
  442.  
  443.  
  444. void KDDBView::Test_CreateBitmap(HDC hDC, const RECT * rcPaint)
  445. {
  446.     // Test supported DDB format    
  447.     const SIZE format[] = { 
  448.             { 1, 0 }, { 1, 1 }, { 1, 2 }, { 1, 4 }, { 1, 8 }, 
  449.             { 1, 15 }, { 1, 16}, { 1, 24 }, { 1, 32 }, { 1, 48 },
  450.             { 2, 2 }, { 3, 3 }, { 4, 4 }, { 5, 5 }, { 6, 6 } };
  451.  
  452.     TextOut(hDC, 100, 10, "Supported DDB Formats", 21);
  453.  
  454.     for (int i=0; i<sizeof(format)/sizeof(format[0]); i++)
  455.     {
  456.         TCHAR mess[128];
  457.     
  458.         HBITMAP hBmp = CreateBitmap(16, 16, format[i].cx, format[i].cy, NULL);
  459.  
  460.         wsprintf(mess, "CreateBitmap(16, 16, %d, %d, NULL) ", format[i].cx, format[i].cy);
  461.         TextOut(hDC, 10, 30+i*17, mess, _tcslen(mess));
  462.  
  463.         DecodeDDB(hBmp, mess);
  464.         TextOut(hDC, 250, 30+i*17, mess, _tcslen(mess));
  465.         DeleteObject(hBmp);
  466.     }
  467.  
  468.     
  469.     SetViewportOrgEx(hDC, 150, 0, NULL);
  470.  
  471.     // Initialized 1 bpp
  472.     const WORD Chess44_WORD [] = { 0xCC, 0xCC, 0x33, 0x33, 0xCC, 0xCC, 0x33, 0x33 };
  473.     
  474.     TestDDB88(hDC, 300, 20, CreateBitmap(8, 8, 1, 1, Chess44_WORD), _T("CreateBitmap(8, 8, 1, 1, Chess44_WORD)"));
  475.  
  476.     // Uninitialized 1 bpp
  477.     TestDDB88(hDC, 300, 70, CreateBitmap(8, 8, 1, 1, NULL), _T("CreateBitmap(8, 8, 1, 1, NULL)"));
  478.  
  479.     // CreateBitmapIndirect, 1 bpp, DWORD aligned pixel array
  480.     DWORD Chess44_DWORD [] = { 0xCC, 0xCC, 0x33, 0x33, 0xCC, 0xCC, 0x33, 0x33 };
  481.     
  482.     BITMAP bbp = { 0, 8, 8, sizeof(DWORD), 1, 1, Chess44_DWORD };
  483.  
  484.     TestDDB88(hDC, 300, 120, CreateBitmapIndirect(&bbp), _T("CreateBitmapIndirect({0,8,8,sizeof(DWORD),1,1,Chess44_DWORD})"));
  485.  
  486.     // CreateCompatibleBitmap: Mem DC
  487.     HDC hMemDC = CreateCompatibleDC(hDC);
  488.     TestDDB88(hDC, 300, 170, CreateCompatibleBitmap(hMemDC, 8, 8), _T("CreateCompatibleBitmap(hMemDC, 8, 8)"));
  489.     DeleteObject(hMemDC);
  490.  
  491.     SetViewportOrgEx(hDC, 0, 0, NULL);
  492. }
  493.     
  494.  
  495. void KDDBView::Test_LargestDDB(HDC hDC, const RECT * rcPaint)
  496. {
  497.     HDC hMemDC = CreateCompatibleDC(hDC);
  498.         
  499.     // Calculate largest DDB size
  500.     TCHAR mess[128];
  501.     HDC DC[2] = { hMemDC, hDC };
  502.  
  503.     for (int y=0; y<2; y++)
  504.     {
  505.         const TCHAR * desp[] = { "Largest monochrome",
  506.         "Largest screen compatible bitmap" };
  507.  
  508.         HBITMAP hBmp = LargestDDB(DC[y]);
  509.  
  510.         TextOut(hDC, 20, 10+y*20, desp[y], _tcslen(desp[y]));
  511.  
  512.         DecodeDDB(hBmp, mess);
  513.         TextOut(hDC, 280, 10+y*20, mess, _tcslen(mess));
  514.  
  515.         DeleteObject(hBmp);
  516.     }
  517.  
  518.     // test maximum number of DDB that can be created
  519.     for (y=0; y<2; y++)
  520.     {
  521.         HBITMAP hBmp[1024];
  522.  
  523.         for (int x=0; x<1024; x++)
  524.         {
  525.             hBmp[x] = CreateCompatibleBitmap(DC[y], GetSystemMetrics(SM_CXSCREEN), 
  526.                 GetSystemMetrics(SM_CYSCREEN));
  527.             if ( hBmp[x]==NULL )
  528.                 break;
  529.         }
  530.  
  531.         wsprintf(mess, "Maximum number of DDB: %d, each of them is ", x);
  532.         TextOut(hDC,  20, 60 + y*20, mess, _tcslen(mess));
  533.  
  534.         DecodeDDB(hBmp[0], mess);
  535.         TextOut(hDC, 340, 60 + y*20, mess, _tcslen(mess));
  536.  
  537.         x--;
  538.         while ( x>=0 )
  539.         {
  540.             DeleteObject(hBmp[x]);
  541.             x --;
  542.         }
  543.     }
  544.  
  545.     DeleteObject(hMemDC);
  546. }
  547.  
  548.  
  549. void KDDBView::Test_LoadBitmap(HDC hDC, const RECT * rcPaint)
  550. {
  551.     TCHAR mess[128];
  552.  
  553.     HDC hMemDC = CreateCompatibleDC(hDC);
  554.  
  555.     // load difference BITMAP as resource
  556.     HPALETTE hPal = CreateHalftonePalette(hDC);
  557.     HPALETTE hOld = SelectPalette(hDC, hPal, FALSE);
  558.     RealizePalette(hDC);
  559.  
  560.     for (int i=0; i<6; i++)
  561.     {
  562.         int x = 10 + (i%3) * 320;
  563.         int y = 10 + (i/3) * 320;
  564.  
  565.         KDIB dib;
  566.  
  567.         dib.LoadBitmap(m_hInst, MAKEINTRESOURCE(i+IDB_BITMAP1));
  568.  
  569.         HBITMAP hBmp;
  570.  
  571.         if ( (m_nViewOpt==IDM_VIEW_LOADBITMAP) || (m_nViewOpt==IDM_VIEW_LOADBITMAPHEX) )
  572.             hBmp = LoadBitmap(m_hInst, MAKEINTRESOURCE(i+IDB_BITMAP1));
  573.         else
  574.             hBmp = dib.ConvertToDDB(hDC);
  575.  
  576.         KGDIObject bmp(hMemDC, hBmp);
  577.  
  578.         if ( hBmp==NULL ) break;
  579.  
  580.         BITMAP info;
  581.         GetObject(hBmp, sizeof(BITMAP), & info);
  582.  
  583.         BitBlt(hDC, x, y, info.bmWidth, info.bmHeight, hMemDC, 0, 0, SRCCOPY);
  584.  
  585.         dib.DecodeDIBFormat(mess);
  586.         TextOut(hDC, x, y + info.bmHeight+20, mess, _tcslen(mess));
  587.         
  588.         DecodeDDB(bmp.m_hObj, mess);
  589.         TextOut(hDC, x, y + info.bmHeight+40, mess, _tcslen(mess));
  590.  
  591.         int size = GetBitmapBits(hBmp, 0, NULL);
  592.         wsprintf(mess, "DDB %d bytes", size);
  593.         TextOut(hDC, x, y+ info.bmHeight+60, mess, _tcslen(mess));
  594.  
  595.         if ( (m_nViewOpt==IDM_VIEW_LOADBITMAPHEX) || (m_nViewOpt==IDM_VIEW_CREATEDIBITMAPHEX) )
  596.             SendMessage(GetParent(GetParent(m_hWnd)), WM_USER+1, (WPARAM) hBmp, 1);
  597.     }
  598.     SelectPalette(hDC, hOld, FALSE);
  599.     RealizePalette(hDC);
  600.     DeleteObject(hPal);
  601.  
  602.     DeleteObject(hMemDC);
  603. }
  604.  
  605.  
  606. void KDDBView::Test_Blt(HDC hDC, const RECT * rcPaint)
  607. {
  608.     KDDB ddb;
  609.  
  610.     int nSeq;
  611.  
  612.     m_texture.GetChecked(nSeq);
  613.  
  614.     ddb.LoadBitmap(m_hInst, TextureID[nSeq]);
  615.  
  616.     RECT rect;
  617.  
  618.     GetClientRect(m_hWnd, & rect);
  619.     int cwidth = rect.right;
  620.     int cheight = rect.bottom;
  621.  
  622.     switch ( m_nViewOpt )
  623.     {
  624.         case IDM_VIEW_BLT_NORMAL:
  625.             ddb.Draw(hDC, 0, 0, cwidth, cheight, SRCCOPY, KDDB::draw_normal);
  626.             break;
  627.  
  628.         case IDM_VIEW_BLT_CENTER:
  629.             ddb.Draw(hDC, 0, 0, cwidth, cheight, SRCCOPY, KDDB::draw_center);
  630.             break;
  631.  
  632.         case IDM_VIEW_BLT_STRETCH:
  633.             ddb.Draw(hDC, 0, 0, cwidth, cheight, SRCCOPY, KDDB::draw_stretch);
  634.             break;
  635.  
  636.         case IDM_VIEW_BLT_TILE:
  637.             ddb.Draw(hDC, 0, 0, cwidth, cheight, SRCCOPY, KDDB::draw_tile);
  638.             break;
  639.  
  640.         case IDM_VIEW_BLT_STRETCHPROP:
  641.             ddb.Draw(hDC, 0, 0, cwidth, cheight, SRCCOPY, KDDB::draw_stretchprop);
  642.     }
  643. }
  644.  
  645.  
  646. void KDDBView::Test_Blt_Color(HDC hDC, const RECT * rcPaint)
  647. {
  648.     KDDB ddb;
  649.  
  650.     ddb.LoadBitmap(m_hInst, IDB_LION);
  651.     RECT rect;
  652.  
  653.     GetClientRect(m_hWnd, & rect);
  654.     int cwidth = rect.right;
  655.     int cheight = rect.bottom;
  656.  
  657.     BITMAP bmp;
  658.     GetObject(ddb.GetBitmap(), sizeof(bmp), & bmp);
  659.     
  660.     HDC hMemDC = CreateCompatibleDC(hDC);
  661.     SelectObject(hMemDC, ddb.GetBitmap());
  662.  
  663.     COLORREF ColorTable[] = { 
  664.         RGB(0xFF, 0, 0),    RGB(0, 0xFF, 0),    RGB(0, 0, 0xFF),
  665.         RGB(0xFF, 0xFF, 0), RGB(0, 0xFF, 0xFF), RGB(0xFF, 0, 0xFF) 
  666.     };
  667.  
  668.     for (int j=0; j<cheight; j+= bmp.bmHeight )
  669.     for (int i=0; i<cwidth;  i+= bmp.bmWidth  )
  670.     {
  671.         SetTextColor(hDC, ColorTable[j/bmp.bmHeight]);
  672.         SetBkColor(hDC,   ColorTable[i/bmp.bmWidth] | RGB(0xC0, 0xC0, 0xC0));
  673.  
  674.         BitBlt(hDC, i, j, bmp.bmWidth, bmp.bmHeight, hMemDC, 0, 0, SRCCOPY);
  675.     }
  676.  
  677.     DeleteObject(hMemDC);
  678. }
  679.  
  680.  
  681. void KDDBView::Test_Blt_GenMask(HDC hDC, const RECT * rcPaint)
  682. {
  683.     KDDB ddb;
  684.  
  685.     KGDIObject brush(hDC, CreateSolidBrush(RGB(0xFF, 0xFF, 0)));
  686.  
  687.     
  688.     ddb.LoadBitmap(m_hInst, IDB_CUBE);
  689.     BITMAP bmp;
  690.     GetObject(ddb.GetBitmap(), sizeof(bmp), & bmp); 
  691.  
  692.     PatBlt(hDC, 0, 0, bmp.bmWidth * 5 + 70, bmp.bmHeight * 2 + 30, PATCOPY);
  693.  
  694.     ddb.Draw(hDC, 10, 10, 0, 0, SRCCOPY, KDDB::draw_normal);
  695.  
  696.     COLORREF ct[] = {
  697.         RGB(128, 128, 128), RGB(192, 192, 192), RGB(255, 255, 255),
  698.         RGB(255, 0, 0), RGB(0, 255, 0), RGB(0, 0, 255),
  699.         RGB(255, 255, 0), RGB(0, 255, 255), RGB(255, 0, 255)
  700.     };
  701.  
  702.     HDC hMemDC = CreateCompatibleDC(hDC);
  703.  
  704.     for (int i=0; i<sizeof(ct)/sizeof(COLORREF); i++)
  705.     {
  706.         HBITMAP hOld = ddb.CreateMask(ct[i], hMemDC);
  707.  
  708.         SetBkColor(hDC, RGB(0xFF, 0xFF, 0xFF));
  709.         SetTextColor(hDC, RGB(0, 0, 0));
  710.  
  711.         BitBlt(hDC, ((i+1)%5)* (bmp.bmWidth+10)+10, ((i+1)/5)* (bmp.bmHeight+10)+10, bmp.bmWidth, bmp.bmHeight,
  712.             hMemDC, 0, 0, SRCCOPY);
  713.  
  714.         DeleteObject(SelectObject(hMemDC, hOld));
  715.     }
  716.  
  717.     DeleteObject(hMemDC);
  718. }
  719.  
  720.  
  721. void KDDBView::OnDraw(HDC hDC, const RECT * rcPaint)
  722. {
  723.     switch ( m_nViewOpt )
  724.     {
  725.         case IDM_VIEW_CREATEBITMAP:
  726.             Test_CreateBitmap(hDC, rcPaint);
  727.             break;
  728.  
  729.         case IDM_VIEW_LARGESTDDB:
  730.             Test_LargestDDB(hDC, rcPaint);
  731.             break;
  732.  
  733.         case IDM_VIEW_LOADBITMAP:
  734.         case IDM_VIEW_CREATEDIBITMAP:
  735.             Test_LoadBitmap(hDC, rcPaint);
  736.             break;
  737.  
  738.         case IDM_VIEW_LOADBITMAPHEX:
  739.             Test_LoadBitmap(hDC, rcPaint);
  740.             m_nViewOpt = IDM_VIEW_LOADBITMAP;
  741.             break;
  742.  
  743.         case IDM_VIEW_CREATEDIBITMAPHEX:
  744.             Test_LoadBitmap(hDC, rcPaint);
  745.             m_nViewOpt = IDM_VIEW_CREATEDIBITMAP;
  746.             break;
  747.  
  748.         case IDM_VIEW_BLT_NORMAL:
  749.         case IDM_VIEW_BLT_CENTER:
  750.         case IDM_VIEW_BLT_STRETCH:
  751.         case IDM_VIEW_BLT_TILE:
  752.         case IDM_VIEW_BLT_STRETCHPROP:
  753.             Test_Blt(hDC, rcPaint);
  754.             break;
  755.  
  756.         case IDM_VIEW_BITBLT_COLOR:
  757.             Test_Blt_Color(hDC, rcPaint);
  758.             break;
  759.  
  760.         case IDM_VIEW_GENMASK:
  761.             Test_Blt_GenMask(hDC, rcPaint);
  762.             break;
  763.     }
  764. }
  765.  
  766. //////////////////////
  767. //    DIB Section   //
  768. //////////////////////
  769.  
  770. class KDIBSectionView : public KScrollCanvas
  771. {
  772.     typedef enum { GAP = 16 };
  773.  
  774.     virtual void    OnDraw(HDC hDC, const RECT * rcPaint);
  775.     virtual LRESULT WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
  776.     void            GetWndClassEx(WNDCLASSEX & wc);
  777.     
  778.     HMENU            m_hViewMenu;
  779.     int                m_nViewOpt;
  780.  
  781. public:
  782.  
  783.     KDIBSectionView(void)
  784.     {
  785.         m_hViewMenu = NULL;
  786.         m_nViewOpt  = IDM_VIEW_CREATEBITMAP;
  787.     }
  788.  
  789.     bool Initialize(HINSTANCE hInstance, KStatusWindow * pStatus)
  790.     {
  791.         m_hInst   = hInstance;
  792.         m_pStatus = pStatus;
  793.  
  794.         RegisterClass(_T("DIBSectionView"), hInstance);
  795.             
  796.         return true;
  797.     }
  798.  
  799.     void Test_CreateDIBSection(HDC hDC, const RECT * rcPaint);
  800. };
  801.  
  802.  
  803. void KDIBSectionView::Test_CreateDIBSection(HDC hDC, const RECT * rcPaint)
  804. {
  805.     TextOut(hDC, 10, 10, "CreateDIBSection", 10);
  806.  
  807.     TCHAR temp[128];
  808.     KDIBSection dibsection[11];
  809.  
  810.     for (int i=0; i<11; i++)
  811.     {
  812.         const int static bitcount   [] = { 0,      1,      4,       4,      8,       8,      16,     16,           24,     32    , 32};
  813.         const int static compression[] = { BI_PNG, BI_RGB, BI_RLE4, BI_RGB, BI_RLE8, BI_RGB, BI_RGB, BI_BITFIELDS, BI_RGB, BI_RGB, BI_BITFIELDS };
  814.  
  815.         KBitmapInfo bmi;
  816.  
  817.         bmi.SetFormat(125, 125, bitcount[i], compression[i]);
  818.  
  819.         dibsection[i].CreateDIBSection(hDC, bmi.GetBMI(), DIB_RGB_COLORS, NULL, NULL);
  820.         
  821.         dibsection[i].DecodeDIBSectionFormat(temp);
  822.         TextOut(hDC, 20, 40 + i*20, temp, _tcslen(temp));
  823.  
  824.         if ( dibsection[i].GetBitmap() )
  825.         {
  826.             HBITMAP hBig = LargestDIBSection(bmi.GetBMI());
  827.  
  828.             DecodeDDB(hBig, temp);
  829.             TextOut(hDC, 720, 40 + i*20, temp, _tcslen(temp));
  830.  
  831.             DeleteObject(hBig);
  832.         }
  833.     }
  834. }
  835.  
  836.  
  837. class KRipDialog : public KDialog
  838. {
  839.     int m_width;
  840.     int m_height;
  841.  
  842.     virtual BOOL DlgProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
  843.     {
  844.         switch (uMsg)
  845.         {
  846.             case WM_INITDIALOG:
  847.                 {
  848.                     for (int i=1; i<10; i++)
  849.                     {
  850.                         TCHAR mess[64];
  851.  
  852.                         wsprintf(mess, "%d%c % %d x %d pixels, %d Kb", i*100, '%', i*m_width, i*m_height,
  853.                             (m_width*i*3+3)/4*4*m_height*i/1024);
  854.                         SendDlgItemMessage(hWnd, IDC_LIST, LB_ADDSTRING, 0, (LPARAM) mess);
  855.                         SendDlgItemMessage(hWnd, IDC_LIST, LB_SETCURSEL, 0, 0);
  856.                     }
  857.                 }
  858.                 return TRUE;
  859.     
  860.             case WM_COMMAND:
  861.                 if ( LOWORD(wParam)==IDOK )
  862.                 {
  863.                     EndDialog(hWnd, 1 + SendDlgItemMessage(hWnd, IDC_LIST, LB_GETCURSEL, 0, 0));
  864.                     return TRUE;
  865.                 }
  866.                 else if ( LOWORD(wParam)==IDCANCEL )
  867.                 {
  868.                     EndDialog(hWnd, 0);
  869.                     return TRUE;
  870.                 }
  871.         }
  872.  
  873.         return FALSE;
  874.     }
  875.  
  876. public:
  877.     KRipDialog(int width, int height)
  878.     {
  879.         m_width  = width;
  880.         m_height = height;
  881.     }
  882. };
  883.  
  884.  
  885. BOOL RenderEMF(HINSTANCE hInstance)
  886. {
  887.     KFileDialog fd;
  888.  
  889.     if ( ! fd.GetOpenFileName(NULL, "emf", "Enhanced Metafiles") )
  890.         return FALSE;
  891.  
  892.     HENHMETAFILE hemf = GetEnhMetaFile(fd.m_TitleName);
  893.  
  894.     if ( hemf==NULL )
  895.         return FALSE;
  896.  
  897.     if ( ! fd.GetSaveFileName(NULL, "tga", "Targa 24 bit Image") )
  898.     {
  899.         DeleteEnhMetaFile(hemf);
  900.         return FALSE;
  901.     }
  902.  
  903.     ENHMETAHEADER emfheader;
  904.  
  905.     GetEnhMetaFileHeader(hemf, sizeof(ENHMETAHEADER), & emfheader);
  906.  
  907.     int width  = emfheader.rclBounds.right  - emfheader.rclBounds.left;
  908.     int height = emfheader.rclBounds.bottom - emfheader.rclBounds.top;
  909.  
  910.     KRipDialog sizedialog(width, height);
  911.  
  912.     int scale = sizedialog.Dialogbox(hInstance, MAKEINTRESOURCE(IDD_RIP), NULL);
  913.     BOOL rslt;
  914.  
  915.     if ( scale )
  916.         rslt = RenderEMF(hemf, width * scale, height * scale, fd.m_TitleName);
  917.     else
  918.         rslt = FALSE;
  919.  
  920.     DeleteEnhMetaFile(hemf);
  921.  
  922.     return rslt;
  923. }
  924.  
  925.  
  926. void KDIBSectionView::GetWndClassEx(WNDCLASSEX & wc)
  927. {
  928.     memset(& wc, 0, sizeof(wc));
  929.  
  930.     wc.cbSize         = sizeof(WNDCLASSEX);
  931.     wc.style          = CS_HREDRAW | CS_VREDRAW;
  932.     wc.lpfnWndProc    = WindowProc;
  933.     wc.cbClsExtra     = 0;
  934.     wc.cbWndExtra     = 0;       
  935.     wc.hInstance      = NULL;
  936.     wc.hIcon          = LoadIcon(m_hInst, MAKEINTRESOURCE(IDI_IMAGE));
  937.     wc.hCursor        = LoadCursor(NULL, IDC_ARROW);
  938.     wc.hbrBackground  = (HBRUSH) GetStockObject(WHITE_BRUSH);
  939.     wc.lpszMenuName   = NULL;
  940.     wc.lpszClassName  = NULL;
  941.     wc.hIconSm        = NULL;
  942. }
  943.  
  944.  
  945. LRESULT KDIBSectionView::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
  946. {
  947.     switch( uMsg )
  948.     {
  949.         case WM_CREATE:
  950.             m_hWnd        = hWnd;
  951.             m_hViewMenu = LoadMenu(m_hInst, MAKEINTRESOURCE(IDR_DIBSECTIONVIEW));
  952.             return 0;
  953.  
  954.         case WM_PAINT:
  955.             return KScrollCanvas::WndProc(hWnd, uMsg, wParam, lParam);
  956.  
  957.         case WM_SIZE:
  958.         case WM_HSCROLL:
  959.         case WM_VSCROLL:
  960.         {
  961.             LRESULT lr = KScrollCanvas::WndProc(hWnd, uMsg, wParam, lParam);
  962.  
  963.             int nMin, nMax, nPos;
  964.  
  965.             GetScrollRange(m_hWnd, SB_VERT, &nMin, &nMax);
  966.  
  967.             nPos = GetScrollPos(m_hWnd, SB_VERT);
  968.  
  969.             TCHAR mess[32];
  970.             wsprintf(mess, "%d %d %d", nMin, nPos, nMax);
  971.             m_pStatus->SetText(0, mess);
  972.  
  973.             return lr;
  974.         }
  975.  
  976.         case WM_COMMAND:
  977.             switch ( LOWORD(wParam) )
  978.             {
  979.                 case IDM_VIEW_CREATEDIBSECTION:
  980.                     if ( LOWORD(wParam)!= m_nViewOpt )
  981.                     {
  982.                         m_nViewOpt = LOWORD(wParam);
  983.  
  984.                         InvalidateRect(hWnd, NULL, TRUE);
  985.                     }
  986.                     return 0;
  987.  
  988.                 case IDM_VIEW_RIP:
  989.                     RenderEMF(m_hInst);
  990.                     return 0;
  991.             }
  992.     }
  993.  
  994.     return CommonMDIChildProc(hWnd, uMsg, wParam, lParam, m_hViewMenu, 3);
  995. }
  996.  
  997.  
  998. void KDIBSectionView::OnDraw(HDC hDC, const RECT * rcPaint)
  999. {
  1000.     switch ( m_nViewOpt )
  1001.     {
  1002.         case IDM_VIEW_CREATEBITMAP:
  1003.             Test_CreateDIBSection(hDC, rcPaint);
  1004.             break;
  1005.     }
  1006. }
  1007.  
  1008.  
  1009. const int Translate[] =
  1010. {
  1011.     IDM_FILE_CLOSE,
  1012.     IDM_FILE_EXIT,
  1013.     IDM_WINDOW_TILE,
  1014.     IDM_WINDOW_CASCADE,
  1015.     IDM_WINDOW_ARRANGE,
  1016.     IDM_WINDOW_CLOSEALL
  1017. };
  1018.  
  1019.  
  1020. class KMyMDIFRame : public KMDIFrame
  1021. {
  1022.     int                m_nCount;
  1023.     KDDBBackground  m_background;
  1024.  
  1025.     void CreateMDIChild(KScrollCanvas * canvas, const TCHAR * klass, const TCHAR * filename, const TCHAR * title)
  1026.     {
  1027.         MDICREATESTRUCT mdic;
  1028.  
  1029.         TCHAR Temp[MAX_PATH];
  1030.  
  1031.         if ( ! canvas->GetTitle(filename, Temp) )
  1032.         {
  1033.             m_nCount ++;
  1034.             wsprintf(Temp, title, m_nCount);
  1035.         }
  1036.  
  1037.         mdic.szClass = klass;
  1038.         mdic.szTitle = Temp;
  1039.         mdic.hOwner  = m_hInst;
  1040.         mdic.x       = CW_USEDEFAULT;
  1041.         mdic.y       = CW_USEDEFAULT;
  1042.         mdic.cx      = CW_USEDEFAULT;
  1043.         mdic.cy      = CW_USEDEFAULT;
  1044.         mdic.style   = WS_VISIBLE | WS_BORDER;
  1045.         mdic.lParam  = (LPARAM) canvas;
  1046.  
  1047.         SendMessage(m_hMDIClient, WM_MDICREATE, 0, (LPARAM) & mdic);
  1048.     }
  1049.  
  1050.     void CreateDIBView(const TCHAR * pFileName)
  1051.     {
  1052.         KDIBView * pDIBView = new KDIBView();
  1053.  
  1054.         if ( pDIBView )
  1055.             if ( pDIBView->Initialize(pFileName, m_hInst, m_pStatus) )
  1056.                 CreateMDIChild(pDIBView, _T("DIBView"), pFileName, _T("DIB %d"));
  1057.             else
  1058.                 delete pDIBView;
  1059.     }
  1060.     
  1061.     void CreateDDBView(void)
  1062.     {
  1063.         KDDBView * pDDBView = new KDDBView();
  1064.  
  1065.         if ( pDDBView )
  1066.             if ( pDDBView->Initialize(m_hInst, m_pStatus) )
  1067.                 CreateMDIChild(pDDBView, _T("DDBView"), NULL, _T("DDB %d"));
  1068.             else
  1069.                 delete pDDBView;
  1070.     }
  1071.  
  1072.     void CreateDIBSectionView(void)
  1073.     {
  1074.         KDIBSectionView * pDIBSectionView = new KDIBSectionView();
  1075.  
  1076.         if ( pDIBSectionView )
  1077.             if ( pDIBSectionView->Initialize(m_hInst, m_pStatus) )
  1078.                 CreateMDIChild(pDIBSectionView, _T("DIBSectionView"), NULL, _T("DIBSection %d"));
  1079.             else
  1080.                 delete pDIBSectionView;
  1081.     }
  1082.  
  1083.     void CreateHexView(WPARAM wParam, LPARAM lParam)
  1084.     {
  1085.         KEditView * pEditView = new KEditView();
  1086.  
  1087.         if ( pEditView )
  1088.             if ( pEditView->Initialize(m_hInst) )
  1089.             {
  1090.                 CreateMDIChild(pEditView, _T("EditView"), NULL, _T("Hex Dump %d"));
  1091.                 pEditView->Decode(wParam, lParam);
  1092.             }
  1093.             else
  1094.                 delete pEditView;
  1095.     }
  1096.  
  1097.     virtual BOOL OnCommand(WPARAM wParam, LPARAM lParam)
  1098.     {
  1099.         switch ( LOWORD(wParam) )
  1100.         {
  1101.             case IDM_FILE_NEW:
  1102.                 CreateDIBView(NULL);
  1103.                 return TRUE;
  1104.  
  1105.             case IDM_FILE_NEWDDB:
  1106.                 CreateDDBView();
  1107.                 return TRUE;
  1108.  
  1109.             case IDM_FILE_NEW_DIBSECTION:
  1110.                 CreateDIBSectionView();
  1111.                 return TRUE;
  1112.  
  1113.             case IDM_FILE_OPEN:
  1114.             {
  1115.                 KFileDialog fo;
  1116.  
  1117.                 if ( fo.GetOpenFileName(m_hWnd, "bmp", "Bitmap Files") )
  1118.                     CreateDIBView(fo.m_TitleName);
  1119.                 
  1120.                 return TRUE;
  1121.             }
  1122.         }
  1123.  
  1124.         return FALSE; // not processed
  1125.     }
  1126.  
  1127.     virtual LRESULT WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
  1128.     {
  1129.         if ( uMsg==WM_USER + 1)
  1130.         {
  1131.             CreateHexView(wParam, lParam);
  1132.             return 0;
  1133.         }
  1134.         
  1135.         LRESULT lr = KMDIFrame::WndProc(hWnd, uMsg, wParam, lParam);
  1136.  
  1137.         if ( uMsg == WM_CREATE )
  1138.         {
  1139.             m_background.SetBitmap(m_hInst, IDB_PUZZLE);
  1140.             m_background.Attach(m_hMDIClient);
  1141.         }
  1142.  
  1143.         return lr;
  1144.     }
  1145.  
  1146.     void GetWndClassEx(WNDCLASSEX & wc)
  1147.     {
  1148.         KFrame::GetWndClassEx(wc);
  1149.  
  1150.         wc.hIcon = LoadIcon(m_hInst, MAKEINTRESOURCE(IDI_IMAGE));
  1151.     }
  1152.  
  1153. public:
  1154.     KMyMDIFRame(HINSTANCE hInstance, const TBBUTTON * pButtons, int nCount,
  1155.         KToolbar * pToolbar, KStatusWindow * pStatus) :
  1156.         KMDIFrame(hInstance, pButtons, nCount, pToolbar, pStatus, Translate)
  1157.     {
  1158.         m_nCount = 0;
  1159.     }
  1160. };
  1161.  
  1162.  
  1163. const TBBUTTON tbButtons[] =
  1164. {
  1165.     { STD_FILENEW,     IDM_FILE_NEW,   TBSTATE_ENABLED, TBSTYLE_BUTTON, { 0, 0 }, IDS_FILENEW,  0 },
  1166.     { STD_FILEOPEN,  IDM_FILE_OPEN,  TBSTATE_ENABLED, TBSTYLE_BUTTON, { 0, 0 }, IDS_FILEOPEN, 0 }
  1167. };
  1168.  
  1169.  
  1170. class KMyDialog : public KDialog
  1171. {
  1172.     KDDBBackground whole;
  1173.     KDDBBackground groupbox;
  1174.     KDDBBackground frame;
  1175.     KDDBBackground button;
  1176.  
  1177.     HINSTANCE      m_hInstance;
  1178.  
  1179.     virtual BOOL DlgProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
  1180.     {
  1181.         switch (uMsg)
  1182.         {
  1183.             case WM_INITDIALOG:
  1184.                 m_hWnd = hWnd;
  1185.                 
  1186.                 whole.SetBitmap(m_hInstance, IDB_PAPER01);
  1187.                 whole.SetStyle(KDDB::draw_tile);
  1188.                 whole.Attach(hWnd);
  1189.                 
  1190.                 groupbox.SetBitmap(m_hInstance, IDB_BRICK02);
  1191.                 groupbox.SetStyle(KDDB::draw_center);
  1192.                 groupbox.Attach(GetDlgItem(hWnd, IDC_GROUPBOX));
  1193.  
  1194.                 frame.SetBitmap(m_hInstance, IDB_BRICK02);
  1195.                 frame.SetStyle(KDDB::draw_stretchprop);
  1196.                 frame.Attach(GetDlgItem(hWnd, IDC_FRAME)); 
  1197.                 return TRUE;
  1198.     
  1199.             case WM_COMMAND:
  1200.                 if ( LOWORD(wParam)==IDOK )
  1201.                 {
  1202.                     EndDialog(hWnd, 1);
  1203.                     return TRUE;
  1204.                 }
  1205.         }
  1206.  
  1207.         return FALSE;
  1208.     }
  1209.  
  1210. public:
  1211.     KMyDialog(HINSTANCE hInst)
  1212.     {
  1213.         m_hInstance = hInst;
  1214.     }
  1215. };
  1216.  
  1217.  
  1218. int WINAPI WinMain(HINSTANCE hInst, HINSTANCE, LPSTR, int nShow)
  1219. {
  1220.     KToolbar      toolbar;
  1221.     KStatusWindow status;
  1222.     KMyDialog      testdialog(hInst);
  1223.  
  1224.     testdialog.Dialogbox(hInst, MAKEINTRESOURCE(IDD_BACKGROUND), NULL);
  1225.  
  1226.     KMyMDIFRame frame(hInst, tbButtons, 2, & toolbar, & status);
  1227.  
  1228.     TCHAR title[MAX_PATH];
  1229.  
  1230.     HDC hDC = GetDC(NULL);
  1231.     wsprintf(title, "DIBShop (%s)", PixelFormatName(PixelFormat(hDC)));
  1232.     ReleaseDC(NULL, hDC);
  1233.  
  1234.     frame.CreateEx(0, _T("ClassName"), title,
  1235.         WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN,
  1236.         CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, 
  1237.         NULL, LoadMenu(hInst, MAKEINTRESOURCE(IDR_MAIN)), hInst);
  1238.     
  1239.  
  1240.     frame.ShowWindow(nShow);
  1241.     frame.UpdateWindow();
  1242.  
  1243.     frame.MessageLoop();
  1244.  
  1245.     return 0;
  1246. }
  1247.