home *** CD-ROM | disk | FTP | other *** search
/ Windows Graphics Programming / Feng_Yuan_Win32_GDI_DirectX.iso / Samples / Chapt_08 / LineCurve / LineCurve.cpp next >
Encoding:
C/C++ Source or Header  |  2000-05-20  |  33.2 KB  |  1,453 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   : linecurve.cpp                                                         //
  10. //  Description: Line/curve demo program, Chapter 8                                  //
  11. //  Version    : 1.00.000, May 31, 2000                                              //
  12. //-----------------------------------------------------------------------------------//
  13.  
  14. #define STRICT
  15. #define _WIN32_WINNT 0x0500
  16. #define WIN32_LEAN_AND_MEAN
  17.  
  18. #include <windows.h>
  19. #include <assert.h>
  20. #include <tchar.h>
  21. #include <math.h>
  22. #include <stdio.h>
  23.  
  24. #include "..\..\include\win.h"
  25. #include "..\..\include\Canvas.h"
  26. #include "..\..\include\Status.h"
  27. #include "..\..\include\FrameWnd.h"
  28. #include "..\..\include\Affine.h"
  29. #include "..\..\include\Pen.h"
  30. #include "..\..\include\curve.h"
  31. #include "..\..\include\BezierCurve.h"
  32.  
  33. #include "Resource.h"
  34.  
  35.  
  36. class KMyCanvas : public KCanvas
  37. {
  38.     virtual void    OnDraw(HDC hDC, const RECT * rcPaint);
  39.     virtual LRESULT WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
  40.     virtual    BOOL    OnCommand(WPARAM wParam, LPARAM lParam);
  41.  
  42.     int        m_test;
  43.     int        m_lastx;
  44.     int        m_lasty;
  45.  
  46.     void SetTest(int test);
  47.  
  48.     void DrawCrossHair(HDC hDC, bool on);
  49.  
  50.     void TestDrawMode(HDC hDC);
  51.     void TestWidthCap(HDC hDC);
  52.     void TestDCPen(HDC hDC);
  53.     void TestPenStyle(HDC hDC);
  54.  
  55.     void TestCosmetic(HDC hDC);
  56.     void TestGeometricWidth(HDC hDC);
  57.     void TestGeometricStyle(HDC hDC);
  58.  
  59.     void TestLine1(HDC hDC);
  60.     void TestLine2(HDC hDC);
  61.     void TestBezier(HDC hDC);
  62.     void BezierDemo(HDC hDC);
  63.  
  64.     void DragBezier(HDC hDC, int x, bool on);
  65.     void TestBezierPen(HDC hDC);
  66.     void TestArc(HDC hDC);
  67.  
  68.     void ArcToBezier(HDC hDC);
  69.     void AngleArcToBezier(HDC hDC);
  70.  
  71.     void TestPath(HDC hDC);
  72.     void TestPathStyleCurve(HDC hDC);
  73.  
  74.     void TestMapPath(HDC hDC);
  75.  
  76.     POINT m_bezier[4];
  77.  
  78. public:
  79.  
  80.     KMyCanvas()
  81.     {
  82.         m_test  = -1;
  83.         m_lastx = -1;
  84.         m_lasty = -1;
  85.  
  86.         m_bezier[0].x =  30; m_bezier[0].y = 330;
  87.         m_bezier[1].x = 130; m_bezier[1].y =  30;
  88.         m_bezier[2].x = 430; m_bezier[2].y = 130;
  89.         m_bezier[3].x = 630; m_bezier[3].y = 430;
  90.     }
  91. };
  92.  
  93.  
  94. void KMyCanvas::SetTest(int test)
  95. {
  96.     m_test = test;
  97.  
  98.     HMENU hMain = GetMenu(GetParent(m_hWnd));
  99.  
  100.     TCHAR Temp[MAX_PATH];
  101.  
  102.     _tcscpy(Temp, _T("LineCurve - "));
  103.  
  104.     GetMenuString(hMain, m_test, Temp + _tcslen(Temp), 
  105.         sizeof(Temp)/sizeof(TCHAR) - _tcslen(Temp), MF_BYCOMMAND);
  106.  
  107.     SetWindowText(GetParent(m_hWnd), Temp);
  108. }
  109.  
  110.  
  111. BOOL KMyCanvas::OnCommand(WPARAM wParam, LPARAM lParam)
  112. {
  113.     switch ( LOWORD(wParam) )
  114.     {
  115.         case IDM_TEST_DRAWMODE:
  116.         case IDM_TEST_WIDTHCAP:
  117.         case IDM_TEST_DCPEN:
  118.         case IDM_TEST_PENSTYLE:
  119.         case IDM_TEST_COSMETIC:
  120.         case IDM_TEST_GEOMETRIC_WIDTH:
  121.         case IDM_TEST_GEOMETRIC_STYLE:
  122.         case IDM_TEST_LINE1:
  123.         case IDM_TEST_LINE2:
  124.         case IDM_TEST_BEZIER:
  125.         case IDM_TEST_BEZIERDEMO:
  126.         case IDM_TEST_BEZIERPEN:
  127.         case IDM_TEST_ARC:
  128.         case IDM_TEST_ARCBEZIER:
  129.         case IDM_TEST_ANGLEARCBEZIER:
  130.         case IDM_TEST_PATH:
  131.         case IDM_TEST_PATHSTYLECURVE:
  132.         case IDM_TEST_MAPPATH:
  133.             SetTest( LOWORD(wParam) );
  134.             InvalidateRect(m_hWnd, NULL, TRUE);
  135.             return TRUE;
  136.  
  137.         case IDM_FILE_EXIT:
  138.             DestroyWindow(GetParent(m_hWnd));
  139.             return TRUE;
  140.     }
  141.  
  142.     return FALSE;    // not processed
  143. }
  144.  
  145.  
  146. void KMyCanvas::DrawCrossHair(HDC hDC, bool on)
  147. {
  148.     if ( (m_lastx<0) || (m_lasty<0) )
  149.         return;
  150.  
  151.     if ( m_test == IDM_TEST_BEZIER )
  152.         DragBezier(hDC, m_lastx, on);
  153.     else
  154.     {
  155.         RECT rect;
  156.  
  157.         GetClientRect(m_hWnd, & rect);
  158.  
  159.         SetROP2(hDC, R2_XORPEN);
  160.         KPen pen(PS_DOT, 0, RGB(0, 0, 0xFF), hDC);
  161.  
  162.         Line(hDC, rect.left, m_lasty, rect.right, m_lasty);
  163.         Line(hDC, m_lastx, rect.top, m_lastx, rect.bottom);
  164.     }
  165. }
  166.  
  167.  
  168. LRESULT KMyCanvas::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
  169. {
  170.     LRESULT lr;
  171.  
  172.     switch( uMsg )
  173.     {
  174.         case WM_CREATE:
  175.             m_hWnd = hWnd;
  176.             SetTest(IDM_TEST_DRAWMODE);
  177.             return 0;
  178.  
  179.         case WM_PAINT:
  180.             {
  181.                 PAINTSTRUCT ps; 
  182.  
  183. //                SetLastError(0);
  184. //                HRGN hrgnClip = CreateRectRgn(0,0,0,0);
  185. //                GetUpdateRgn(m_hWnd,hrgnClip,FALSE);
  186. //                HDC hdc = GetDCEx(m_hWnd,NULL,DCX_VALIDATE|DCX_INTERSECTUPDATE);
  187.  
  188.                 HDC hDC = BeginPaint(m_hWnd, &ps);
  189.  
  190.             //    DrawCrossHair(hDC);
  191.                 OnDraw(hDC, &ps.rcPaint);
  192.                 DrawCrossHair(hDC, true);
  193.  
  194.                 EndPaint(m_hWnd, &ps);
  195.             }
  196.             return 0;
  197.  
  198.         case WM_MOUSEMOVE:
  199.             {
  200.                 HDC hDC = GetDC(hWnd);
  201.  
  202.                 DrawCrossHair(hDC, false);
  203.                 m_lastx = LOWORD(lParam); m_lasty = HIWORD(lParam);
  204.                 DrawCrossHair(hDC, true);
  205.                 ReleaseDC(hWnd, hDC);
  206.                 
  207.                 TCHAR temp[32];
  208.                 wsprintf(temp, _T("(%d, %d)"), m_lastx, m_lasty);
  209.                 m_pStatus->SetText(0, temp);
  210.         
  211.             }
  212.             return 0;
  213.  
  214.         default:
  215.             lr = DefWindowProc(hWnd, uMsg, wParam, lParam);
  216.     }
  217.  
  218.     return lr;
  219. }
  220.  
  221.  
  222. const TCHAR * R2_Names[] = 
  223. {
  224.     "R2_BLACK",
  225.     "R2_NOTMERGEPEN",
  226.     "R2_MASKNOTPEN",
  227.     "R2_NOTCOPYPEN",
  228.     "R2_MASKPENNOT",
  229.     "R2_NOT",
  230.     "R2_XORPEN",
  231.     "R2_NOTMASKPEN",
  232.     "R2_MASKPEN",
  233.     "R2_NOTXORPEN",
  234.     "R2_NOP",
  235.     "R2_MERGENOTPEN",
  236.     "R2_COPYPEN",
  237.     "R2_MERGEPENNOT",
  238.     "R2_MERGEPEN",
  239.     "R2_WHITE"
  240. };
  241.  
  242.  
  243. void KMyCanvas::TestDrawMode(HDC hDC)
  244. {
  245.     for (int c=0; c<20; c++)
  246.     {
  247.         RECT rect = { c*20+40, 30, c*20+58, 400 };
  248.  
  249.         HBRUSH hBrush = CreateSolidBrush(PALETTEINDEX(c));
  250.  
  251.         FillRect(hDC, & rect, hBrush);
  252.  
  253.         DeleteObject(hBrush);
  254.     }
  255.  
  256.     KPen pen(PS_SOLID, 0, RGB(0xFF, 0, 0), hDC);
  257.  
  258.     for (int r=R2_BLACK; r<=R2_WHITE; r++)
  259.     {
  260.         SetROP2(hDC, r);
  261.  
  262.         for (int i=0; i<18; i++)
  263.         {
  264.             Label(hDC, 440, r*22+20, R2_Names[r-R2_BLACK]);
  265.  
  266.             Line(hDC, 30, r*22+20+i, 430, r*22+20+i);
  267.         }
  268.     }
  269. } 
  270.  
  271.  
  272. void ZoomPixel(HDC hDC, int x0, int y0, int x1, int y1)
  273. {
  274.     COLORREF c = GetPixel(hDC, x0, y0);
  275.  
  276.     HBRUSH hBrush = CreateSolidBrush(c);
  277.     SelectObject(hDC, hBrush);
  278.  
  279.     Rectangle(hDC, x1, y1, x1+11, y1+11);
  280.     SelectObject(hDC, GetStockObject(WHITE_BRUSH));
  281.     DeleteObject(hBrush);
  282. }
  283.  
  284.  
  285. void KMyCanvas::TestWidthCap(HDC hDC)
  286. {
  287.     char temp[6];
  288.  
  289.     KPen green(PS_SOLID, 0, RGB(0, 0xFF, 0));
  290.     
  291.     for (int i=0; i<12; i++)
  292.     {
  293.         KPen pen (PS_DOT, i, RGB(0, 0, 0xFF));
  294.  
  295.         int x0 = 40 + (i/2)*110;
  296.         int x1 = x0 + 64;
  297.         int y0 = 30 + (i & 1) * 200;
  298.         
  299.         // thick line
  300.         Line(hDC, x0, y0, x1, y0, pen.m_hPen);
  301.  
  302.         // Center line
  303.         Line(hDC, x0, y0, x1, y0, green.m_hPen);
  304.  
  305.         wsprintf(temp, "w=%d", i);
  306.         Label(hDC, 40+x0-5*12, 90 + y0 -5*12-17, temp);
  307.  
  308.         // copy zoomed line
  309.         for (int y=-5; y<6; y++)
  310.         for (int x=-5; x<3;  x++)
  311.             ZoomPixel(hDC, x0+x, y0+y, 40+x0+x*12, 90 + y0 + y*12);
  312.  
  313.         Line(hDC, x0, y0, x1, y0, pen.m_hPen);
  314.     }
  315. }
  316.  
  317.  
  318. void KMyCanvas::TestDCPen(HDC hDC)
  319. {
  320.     Label(hDC, 10, 0, _T("Use DC_PEN to simulate gradient fill"));
  321.  
  322.     SelectObject(hDC, GetStockObject(DC_PEN));
  323.  
  324.     for (int i=0; i<128; i++)
  325.     {
  326.         SetDCPenColor(hDC, RGB(i, 255-i, 128+i));
  327.  
  328.         Line(hDC, 40, i+40, 150, i+40);
  329.     }
  330.  
  331.     SelectObject(hDC, GetStockObject(BLACK_PEN));
  332.     
  333.     // Test DeleteObject on stock object
  334.     BOOL rslt = DeleteObject(GetStockObject(DC_PEN));
  335. }
  336.  
  337. const LPCTSTR mess_PenStyle [] =
  338. {
  339.     _T("PS_SOLID"),
  340.     _T("PS_DASH"),
  341.     _T("PS_DOT"),
  342.     _T("PS_DASHDOT"),
  343.     _T("PS_DASHDOTDOT"),
  344.     _T("PS_NULL"),
  345.     _T("PS_INSIDEFRAME"),
  346.     _T("PS_USERSTYLE"),
  347.     _T("PS_ALTERNATE")
  348. };
  349.  
  350.  
  351. void KMyCanvas::TestPenStyle(HDC hDC)
  352. {
  353.     // Pen style
  354.     for (int i = PS_SOLID; i<=PS_INSIDEFRAME; i++)
  355.     {
  356.         Label(hDC, 10, i*20+10, mess_PenStyle[i]);
  357.  
  358.         SetBkColor(hDC, RGB(0, 0xFF, 0));
  359.         SetBkMode(hDC, OPAQUE);
  360.  
  361.         {    
  362.             KPen Pen(i, 1, RGB(0x00, 0x00, 0xFF), hDC);
  363.         
  364.             Line(hDC, 150, i*20 + 17, 180, i*20 + 17);
  365.         }
  366.  
  367.         SetBkColor(hDC, RGB(0xFF, 0xFF, 0xFF));
  368.     
  369.         // copy to zoomed display
  370.         for (int x=150; x<180; x++)
  371.             ZoomPixel(hDC, x,                i*20 + 17,
  372.                            200 + (x-150)*12, i*20 + 12);
  373.     }
  374. }
  375.  
  376.  
  377. void KMyCanvas::TestCosmetic(HDC hDC)
  378. {
  379.     const LOGBRUSH logbrush = { BS_SOLID, RGB(0, 0, 0xFF), 0 };
  380.  
  381. //    SetMapMode(hDC, MM_ANISOTROPIC);
  382. //    SetViewportExtEx(hDC, 2, 2, NULL);
  383.  
  384.     for (int i = PS_SOLID; i<=PS_ALTERNATE; i++)
  385.     {
  386.         HPEN hPen;
  387.         const DWORD cycle[4] = { 4, 3, 2, 1 };
  388.         
  389.         if ( i==PS_USERSTYLE )
  390.             hPen = ExtCreatePen(PS_COSMETIC | i, 1, & logbrush, 4, cycle);
  391.         else
  392.             hPen = ExtCreatePen(PS_COSMETIC | i, 1, & logbrush, 0, NULL);
  393.         
  394.         Label(hDC, 10, i*20+10, mess_PenStyle[i]);
  395.  
  396.         if ( hPen )
  397.         {
  398.             SelectObject(hDC, hPen);
  399.             SetBkColor(hDC, RGB(0, 0xFF, 0));
  400.             SetBkMode(hDC, OPAQUE);
  401.         //    SetROP2(hDC, R2_XORPEN);
  402.  
  403.             // draw style line
  404.             Line(hDC, 150, i*20 + 17, 180, i*20 + 17);
  405.  
  406.             SetBkColor(hDC, RGB(0xFF, 0xFF, 0xFF));
  407.     
  408.             SelectObject(hDC, GetStockObject(BLACK_PEN));
  409.             DeleteObject(hPen);
  410.  
  411.             // copy to zoomed display
  412.             for (int x=150; x<180; x++)
  413.                 ZoomPixel(hDC, x,                i*20 + 17,
  414.                                200 + (x-150)*12, i*20 + 12);
  415.         }
  416.     }
  417. }
  418.  
  419. void KMyCanvas::TestGeometricWidth(HDC hDC)
  420. {
  421.     const LOGBRUSH logbrush = { BS_SOLID, RGB(0, 0xFF, 0), 0 };
  422.  
  423.     int save = SaveDC(hDC);
  424.  
  425.     HPEN hGreen = CreatePen(PS_SOLID, 0, RGB(0, 0xFF, 0));
  426.  
  427.     SetBkColor(hDC, RGB(0, 0xFF, 0));
  428.     SetBkMode(hDC, OPAQUE);
  429.  
  430.     // Geometric line width under transformation
  431.     
  432.         HPEN hPen = ExtCreatePen(PS_GEOMETRIC | PS_SOLID | PS_ENDCAP_FLAT, 61, & logbrush, 0, NULL);
  433.         
  434.         KAffine affine;
  435.  
  436.         POINT p[6] = { 0, 0, 200, 0, -00, -30, 200, -30, 200, 30, 0, 30 };
  437.  
  438.         affine.Rotate(30, 0, 0);
  439.         affine.Translate(100, -200);
  440.  
  441.         SelectObject(hDC, hPen);
  442.         SetMapMode(hDC, MM_ANISOTROPIC);
  443.         SetViewportExtEx(hDC, 1, -1, NULL);
  444.  
  445.         SetGraphicsMode(hDC, GM_ADVANCED);
  446.  
  447.         SetWorldTransform(hDC, & affine.m_xm);
  448.  
  449.         LPtoDP(hDC, p, 6);
  450.  
  451.         Line(hDC, 0, 0, 200, 0);
  452.  
  453.         SelectObject(hDC, GetStockObject(BLACK_PEN));
  454.         DeleteObject(hPen);
  455.  
  456.         ModifyWorldTransform(hDC, NULL, MWT_IDENTITY);
  457.         SetGraphicsMode(hDC, GM_COMPATIBLE);
  458.  
  459.         SetBkColor(hDC, RGB(0xFF, 0xFF, 0xFF));
  460.         SetTextAlign(hDC, TA_LEFT);
  461.  
  462.         SetViewportExtEx(hDC, 1, 1, NULL);
  463.  
  464.         Line(hDC, p[0].x, p[0].y, 20, 200);
  465.         Label(hDC, 20, 200, "(x0,y0)");
  466.  
  467.         Line(hDC, p[1].x, p[1].y, 300, 80);
  468.         Label(hDC, 300, 80, "(x1,y1)");
  469.  
  470.         Line(hDC, p[5].x, p[5].y, 20, 120);
  471.         Label(hDC, 20, 120, "(x0-dx,y0+dy)");
  472.  
  473.         Line(hDC, p[4].x, p[4].y, 260, 40);
  474.         Label(hDC, 260, 40, "(x1-dx,y1+dy)");
  475.  
  476.         Line(hDC, p[3].x, p[3].y, 300, 160);
  477.         Label(hDC, 300, 160, "(x1+dx,y1-dy)");
  478.  
  479.         Line(hDC, p[2].x, p[2].y, 130, 250);
  480.         Label(hDC, 130, 250, "(x0+dx,y0-dy)");
  481.  
  482.         Label(hDC, 20, 20, "dx = pen_width * sin(°)/2");
  483.         Label(hDC, 20, 50, "dy = pen_width * cos(°)/2");
  484.     
  485.     DeleteObject(hGreen);
  486.  
  487.     RestoreDC(hDC, save);
  488. }
  489.  
  490.  
  491. class KGPen
  492. {
  493. public:
  494.     DWORD    m_cycle[4];
  495.     LOGBRUSH m_logbrush;
  496.     HPEN     m_hPen;
  497.  
  498.     KGPen()
  499.     {
  500.         m_cycle[0] = 20;
  501.         m_cycle[1] = 15;
  502.         m_cycle[2] = 10;
  503.         m_cycle[3] =  5;
  504.  
  505.         m_logbrush.lbStyle = BS_SOLID;
  506.         m_logbrush.lbColor = RGB(0, 0, 0xFF);
  507.         m_logbrush.lbHatch = 0;
  508.  
  509.         m_hPen = NULL;
  510.     }
  511.  
  512.     ~KGPen(void)
  513.     {
  514.         if ( m_hPen )
  515.             DeleteObject(m_hPen);
  516.     }
  517.  
  518.     void SetPen(int style, int width);
  519.  
  520.     void DrawLine(HDC hDC, const TCHAR * mess, int x0, int y0, int x1, int y1);
  521.     void DrawPolyLine(HDC hDC, int count, POINT * cord);
  522.     void DrawZ(HDC hDC, int endcap, int x, int y, COLORREF color, 
  523.                const TCHAR * desp, bool poly=false);
  524. };
  525.  
  526. void KGPen::SetPen(int style, int width)
  527. {
  528.     if ( m_hPen )
  529.         DeleteObject(m_hPen);
  530.  
  531.     if ( ( style & PS_STYLE_MASK ) == PS_USERSTYLE )
  532.         m_hPen = ExtCreatePen(PS_GEOMETRIC | style, width, & m_logbrush, 4, m_cycle);
  533.     else
  534.         m_hPen = ExtCreatePen(PS_GEOMETRIC | style, width, & m_logbrush, 0, NULL);
  535. }
  536.  
  537. void KGPen::DrawLine(HDC hDC, const TCHAR * mess, int x0, int y0, int x1, int y1)
  538. {
  539.     if ( mess )
  540.         Label(hDC, x0, y0-25, mess);
  541.  
  542.     if ( m_hPen )
  543.     {
  544.         SelectObject(hDC, m_hPen);
  545.         SetBkColor(hDC, RGB(0, 0xFF, 0));
  546.         SetBkMode(hDC, OPAQUE);
  547.  
  548.         // draw style line
  549.         Line(hDC, x0, y0, x1, y1);
  550.  
  551.         SetBkColor(hDC, RGB(0xFF, 0xFF, 0xFF));
  552.     
  553.         SelectObject(hDC, GetStockObject(BLACK_PEN));
  554.     }
  555. }
  556.  
  557. void KGPen::DrawPolyLine(HDC hDC, int count, POINT * cord)
  558. {
  559.     if ( m_hPen )
  560.     {
  561.         SelectObject(hDC, m_hPen);
  562.         SetBkColor(hDC, RGB(0, 0xFF, 0));
  563.         SetBkMode(hDC, OPAQUE);
  564.  
  565.         // draw style line
  566.         Polyline(hDC, cord, count); 
  567.  
  568.         SetBkColor(hDC, RGB(0xFF, 0xFF, 0xFF));
  569.     
  570.         SelectObject(hDC, GetStockObject(BLACK_PEN));
  571.     }
  572. }
  573.  
  574. void KGPen::DrawZ(HDC hDC, int endcap, int x, int y, COLORREF color, const TCHAR * desp, bool poly)
  575. {
  576.     SetPen(PS_SOLID | endcap, 25);
  577.  
  578.     if ( poly )
  579.     {
  580.         POINT p[4] = { x, y, x+100, y, x, y+50, x+100, y+50 };
  581.         
  582.         DrawPolyLine(hDC, 4, p);
  583.     }
  584.     else
  585.     {
  586.         DrawLine(hDC, NULL, x,     y,    x+100, y);
  587.  
  588.         m_logbrush.lbColor = color;
  589.         SetPen(PS_SOLID | endcap, 25);
  590.         DrawLine(hDC, NULL, x+100, y,    x   ,  y+50);
  591.  
  592.         m_logbrush.lbColor = RGB(0, 0, 0xFF);
  593.         SetPen(PS_SOLID | endcap, 25);
  594.         DrawLine(hDC, NULL, x    , y+50, x+100, y+50);
  595.     }
  596.  
  597.     SelectObject(hDC, GetStockObject(WHITE_PEN));
  598.     Line(hDC, x, y, x+100, y); LineTo(hDC, x, y+50); LineTo(hDC, x+100, y+50);
  599.  
  600.     while ( desp )
  601.     {
  602.         const TCHAR * p = _tcschr(desp, '\n');
  603.         int len;
  604.  
  605.         if ( p )
  606.             len = ((int) p - (int) desp)/sizeof(TCHAR);
  607.         else
  608.             len = _tcslen(desp);
  609.  
  610.         TextOut(hDC, x, y+70, desp, len);
  611.         y+= 20;
  612.  
  613.         if ( p )
  614.             desp = p + 1;
  615.         else
  616.             desp = NULL;
  617.     }
  618. }
  619.  
  620.  
  621. void KMyCanvas::TestGeometricStyle(HDC hDC)
  622. {
  623.     KGPen gpen;
  624.  
  625.     for (int i = PS_SOLID; i<=PS_ALTERNATE; i++)
  626.     {
  627.         Label(hDC, 10, i*20+30, mess_PenStyle[i]);
  628.  
  629.         int y = i*20 + 37;
  630.  
  631.         gpen.SetPen(i | PS_ENDCAP_FLAT, 3);
  632.         gpen.DrawLine(hDC, (i==PS_SOLID) ? "w=3, flat" : NULL,          150, y, 250, y);
  633.         
  634.         gpen.SetPen(i | PS_ENDCAP_FLAT, 7);
  635.         gpen.DrawLine(hDC, (i==PS_SOLID) ? "w=7, flat" : NULL,          270, y, 370, y);
  636.  
  637.         gpen.SetPen(i | PS_ENDCAP_SQUARE, 11);
  638.         gpen.DrawLine(hDC, (i==PS_SOLID) ? "w=11, square" : NULL,       390, y, 490, y);
  639.  
  640.         gpen.m_logbrush.lbStyle = BS_HATCHED;
  641.         gpen.m_logbrush.lbHatch = HS_DIAGCROSS;
  642.  
  643.         gpen.SetPen(i | PS_ENDCAP_ROUND, 15);
  644.         gpen.DrawLine(hDC, (i==PS_SOLID) ? "w=15, round, hatch" : NULL, 510, y, 610, y);
  645.  
  646.         gpen.m_logbrush.lbStyle = BS_SOLID;
  647.         gpen.m_logbrush.lbHatch = 0;
  648.     }
  649.  
  650.     gpen.DrawZ(hDC, PS_ENDCAP_FLAT,    50, 260, RGB(0xFF, 0x3F, 0x0F), _T("PS_ENDCAP_FLAT"));
  651.     gpen.DrawZ(hDC, PS_ENDCAP_SQUARE, 220, 260, RGB(0xFF, 0x3F, 0x0F), _T("PS_ENDCAP_SQUARE"));
  652.     gpen.DrawZ(hDC, PS_ENDCAP_ROUND,  390, 260, RGB(0xFF, 0x3F, 0x0F), _T("PS_ENDCAP_ROUND"));
  653.     
  654.     SetROP2(hDC, R2_XORPEN);
  655.     gpen.DrawZ(hDC, PS_ENDCAP_ROUND,  560, 260, RGB(0xFF, 0x3F, 0x0F), _T("PS_ENDCAP_ROUND\nR2_XORPEN"));
  656.  
  657.     SetROP2(hDC, R2_COPYPEN);
  658.  
  659. //    FLOAT f;
  660.  
  661. //    SetMiterLimit(hDC, 4.35, & f);
  662.  
  663.     gpen.DrawZ(hDC, PS_ENDCAP_FLAT   | PS_JOIN_BEVEL,  50, 400, RGB(0xFF, 0x3F, 0x0F), _T("PS_ENDCAP_FLAT\nPS_JOIN_BEVEL"), true);
  664.     gpen.DrawZ(hDC, PS_ENDCAP_SQUARE | PS_JOIN_MITER, 220, 400, RGB(0xFF, 0x3F, 0x0F), _T("PS_ENDCAP_SQUARE\nPS_JOIN_MITER"), true);
  665.     gpen.DrawZ(hDC, PS_ENDCAP_ROUND  | PS_JOIN_ROUND, 390, 400, RGB(0xFF, 0x3F, 0x0F), _T("PS_ENDCAP_ROUND\nPS_JOIN_ROUND"), true);
  666.     
  667.     SetROP2(hDC, R2_XORPEN);
  668.     gpen.DrawZ(hDC, PS_ENDCAP_ROUND  | PS_JOIN_ROUND, 560, 400, RGB(0xFF, 0x3F, 0x0F), _T("PS_ENDCAP_ROUND\nPS_JOIN_ROUND\nR2_XORPEN"), true);
  669. }
  670.  
  671.  
  672. void KMyCanvas::TestLine1(HDC hDC)
  673. {
  674.     const int    N      = 19;
  675.     const int    Radius = 200;
  676.     const double theta  = 3.1415926 * 2 / N;
  677.     
  678.     SelectObject(hDC, GetStockObject(DC_PEN));
  679.  
  680.     // simple line drawing
  681.     const COLORREF color[] = { 
  682.         RGB(0, 0, 0), RGB(255,0,0), RGB(0,255,0), RGB(0,0, 255),
  683.         RGB(255,255,0), RGB(0, 255, 255), RGB(255, 255, 0),
  684.         RGB(127, 255, 0), RGB(0, 127, 255), RGB(255, 0, 127)
  685.     };
  686.     
  687.     for (int p=0; p<N; p++)
  688.     for (int q=0; q<p; q++)
  689.     {
  690.         SetDCPenColor(hDC, color[min(p-q, N-p+q)]);
  691.  
  692.         Line(hDC, (int)(220 + Radius * sin(p * theta)), 
  693.                   (int)(220 + Radius * cos(p * theta)), 
  694.                   (int)(220 + Radius * sin(q * theta)), 
  695.                   (int)(220 + Radius * cos(q * theta)));
  696.     }
  697. }
  698.  
  699.  
  700. void Triangle(HDC hDC, int x0, int y0, int x1, int y1, int x2, int y2, bool extra=false)
  701. {
  702.     POINT corner[5] = { x0, y0, x1, y1, x2, y2, x0, y0, x1, y1 };
  703.  
  704.     if ( extra ) // extra segment to make nicer closing join
  705.         Polyline(hDC, corner, 5);
  706.     else
  707.         Polyline(hDC, corner, 4);
  708. }
  709.  
  710.  
  711. void CALLBACK LineDDAProc(int x, int y, LPARAM lpData)
  712. {
  713.     HDC hDC = (HDC) lpData;
  714.     POINT cur;
  715.  
  716.     GetCurrentPositionEx(hDC, & cur);
  717.  
  718.     if ( (cur.x & 31)== 0 ) // every 32th call
  719.         Triangle(hDC, x, y-16, x+20, y+18, x-20, y+18);
  720.  
  721.     cur.x ++;
  722.     MoveToEx(hDC, cur.x, cur.y, NULL);
  723. }
  724.  
  725.  
  726. void KMyCanvas::TestLine2(HDC hDC)
  727. {
  728.     LOGBRUSH logbrush = { BS_SOLID, RGB(0, 0, 0xFF), 0 };
  729.  
  730.     HPEN hPen = ExtCreatePen(PS_GEOMETRIC | PS_SOLID | 
  731.                     PS_ENDCAP_FLAT | PS_JOIN_MITER, 
  732.                     15, & logbrush, 0, NULL);
  733. //    SetROP2(hDC, R2_XORPEN);
  734.     
  735.     HGDIOBJ hOld = SelectObject(hDC, hPen);
  736.     
  737.     // drawing triangle using mutlple LineTo calls
  738.     SetViewportOrgEx(hDC, 100, 50, NULL);
  739.     Line(hDC, 0, 0, 50, 86); 
  740.     LineTo(hDC, -50, 86); LineTo(hDC, 0, 0);
  741.     
  742.     // using polyline
  743.     SetViewportOrgEx(hDC, 230, 50, NULL);
  744.     Triangle(hDC, 0, 0, 50, 86, -50, 86, false );
  745.  
  746.     // using polyline, extra segment
  747.     SetViewportOrgEx(hDC, 360, 50, NULL);
  748.     Triangle(hDC, 0, 0, 50, 86, -50, 86, true );
  749.  
  750.     // using LineDDA
  751.     SetViewportOrgEx(hDC, 490, 50, NULL);
  752.     SelectObject(hDC, hOld);
  753.     DeleteObject(hPen);
  754.  
  755.     hPen = ExtCreatePen(PS_GEOMETRIC | PS_DOT | PS_ENDCAP_ROUND, 
  756.                     3, & logbrush, 0, NULL);
  757.     SelectObject(hDC, hPen);
  758.  
  759.     LineDDA( 0,  0,   50, 86, LineDDAProc, (LPARAM) hDC); 
  760.     LineDDA( 50, 86, -50, 86, LineDDAProc, (LPARAM) hDC); 
  761.     LineDDA(-50, 86,   0,  0, LineDDAProc, (LPARAM) hDC);
  762.  
  763.     SetViewportOrgEx(hDC, 50, 150, NULL);
  764.     SelectObject(hDC, hOld);
  765.     DeleteObject(hPen);
  766.  
  767.     // PolyPolyline
  768.     hPen = ExtCreatePen(PS_GEOMETRIC | PS_SOLID | PS_ENDCAP_ROUND, 
  769.                     5, & logbrush, 0, NULL);
  770.     SelectObject(hDC, hPen);
  771.     
  772.     POINT P[10] = { 0,  0, 100,  0, 100, 100, 0, 100,  0,  0,
  773.                   50, 50, 150, 50, 150, 150, 50,150, 50, 50 };
  774.     DWORD c[2] = { 5, 5 };
  775.     SetROP2(hDC, R2_XORPEN);
  776.     PolyPolyline(hDC, P, c, 2);
  777.  
  778.     SetViewportOrgEx(hDC, 0, 0, NULL);
  779.     SelectObject(hDC, hOld);
  780.     DeleteObject(hPen);
  781. }
  782.  
  783.  
  784. void KMyCanvas::TestBezier(HDC hDC)
  785. {
  786. }
  787.  
  788.  
  789. void KMyCanvas::DragBezier(HDC hDC, int x, bool on)
  790. {
  791.     SetROP2(hDC, R2_XORPEN);
  792.     SetBkMode(hDC, TRANSPARENT);
  793.  
  794.     LOGBRUSH logbrush = { BS_SOLID, RGB(0xFF, 0xFF, 0), 0 };
  795.  
  796.     m_bezier[0].x =  30; m_bezier[0].y = 330;
  797.     m_bezier[1].x = 130; m_bezier[1].y =  30;
  798.     m_bezier[2].x = 430; m_bezier[2].y = 130;
  799.     m_bezier[3].x = 630; m_bezier[3].y = 330;
  800.  
  801.     HPEN hPen, hOld;
  802.  
  803.     hPen = CreatePen(PS_DOT, 0, RGB(0xFF, 0, 0xFF));
  804.     hOld = (HPEN) SelectObject(hDC, hPen);
  805.     // Dotted line link control points
  806.     Polyline(hDC, m_bezier, 4);
  807.     SelectObject(hDC, hOld);
  808.     DeleteObject(hPen);
  809.  
  810.     hPen = ExtCreatePen(PS_GEOMETRIC | PS_SOLID | PS_ENDCAP_ROUND, 3, & logbrush, 0, NULL);
  811.     hOld = (HPEN) SelectObject(hDC, hPen);
  812.  
  813.     // Solid thick Bezier curve
  814. //    PolyBezier(hDC, m_bezier, 4);
  815.     Bezier(hDC, 30, 330, 130, 30, 430, 130, 630, 330);
  816.     
  817.     SelectObject(hDC, hOld);
  818.     DeleteObject(hPen);
  819.  
  820.     double  t = (x%101) / 100.0;
  821.  
  822.     hPen = CreatePen(PS_DASH, 0, RGB(0, 0xFF, 0xFF));
  823.     hOld = (HPEN) SelectObject(hDC, hPen);
  824.  
  825.     POINT P12; P(P12, m_bezier[0], m_bezier[1], t);
  826.     POINT P23; P(P23, m_bezier[1], m_bezier[2], t);
  827.     POINT P34; P(P34, m_bezier[2], m_bezier[3], t);
  828.  
  829.     POINT P1223; P(P1223, P12, P23, t);
  830.     POINT P2334; P(P2334, P23, P34, t);
  831.     POINT P0;    P(P0   , P1223, P2334, t);
  832.     
  833.     // P(t) lines
  834.     Line(hDC, P12, P23);
  835.     Line(hDC, P23, P34);
  836.     Line(hDC, P1223, P2334);
  837.  
  838.     SelectObject(hDC, hOld);
  839.     DeleteObject(hPen);
  840.  
  841.     SetROP2(hDC, R2_COPYPEN);
  842.  
  843.     // labels
  844.     if ( on )
  845.         SetTextColor(hDC, 0);
  846.     else
  847.         SetTextColor(hDC, RGB(0xFF, 0xFF, 0xFF));
  848.  
  849.     Label(hDC, m_bezier[0].x,    m_bezier[0].y+10, "P1");
  850.     Label(hDC, m_bezier[1].x-20, m_bezier[1].y,    "P2");
  851.     Label(hDC, m_bezier[2].x+15, m_bezier[2].y,    "P3");
  852.     Label(hDC, m_bezier[3].x,    m_bezier[3].y+10, "P4");
  853.  
  854.     Label(hDC, P12.x-30, P12.y,    "P12");
  855.     Label(hDC, P23.x+10, P23.y-20, "P23");
  856.     Label(hDC, P34.x+30, P34.y+10, "P34");
  857.  
  858.     Label(hDC, P1223.x-20, P1223.y-20, "P1223");
  859.     Label(hDC, P2334.x-20, P2334.y-20, "P2334");
  860.  
  861.     Label(hDC, P0.x-20, P0.y-20, "P");
  862.  
  863.     TCHAR num[10];
  864.  
  865.     sprintf(num, "t=%8.5f    ", t);
  866.     Label(hDC, 250, 250, num);
  867. }
  868.  
  869.  
  870.  
  871. void KMyCanvas::BezierDemo(HDC hDC)
  872. {
  873.     KPen Red (PS_DOT, 0, RGB(0xFF, 0, 0));
  874.     KPen Blue(PS_SOLID, 3, RGB(0, 0, 0xFF));
  875.  
  876.     for (int z=0; z<=200; z+=40)
  877.     {
  878.         int x = 50, y = 240;
  879.  
  880.         POINT p[4] = { x, y, x+ 50, y-z, x+100, y-z, x+150, y }; x+= 160;
  881.         POINT q[4] = { x, y, x+ 50, y-z, x+100, y+z, x+150, y }; x+= 180;
  882.         
  883.         POINT r[4] = { x, y, x+170, y-z, x- 20, y-z, x+150, y }; x+= 200;
  884.         POINT s[4] = { x, y, x+170, y-z, x- 20, y+z, x+150, y }; x+= 180;
  885.         
  886.         POINT t[4] = { x+75, y, x,  y-z, x+150, y-z, x+75, y }; 
  887.  
  888.         Red.Select(hDC);
  889.         Polyline(hDC, p, 4);
  890.         Polyline(hDC, q, 4);
  891.         Polyline(hDC, r, 4);
  892.         Polyline(hDC, s, 4);
  893.         Polyline(hDC, t, 4);
  894.         Red.UnSelect();
  895.  
  896.         Blue.Select(hDC);
  897.         PolyBezier(hDC, p, 4);
  898.         PolyBezier(hDC, q, 4);
  899.         PolyBezier(hDC, r, 4);
  900.         PolyBezier(hDC, s, 4);
  901.         PolyBezier(hDC, t, 4);
  902.         Blue.UnSelect();
  903.  
  904.         if ( z==200 )
  905.         {
  906.             Label(hDC, p,   0, 10, -20, -10, +10, -10, -18,  10);
  907.             Label(hDC, q,   0, 10, -20, -10, +15, -10, -18, -25);
  908.             Label(hDC, r,   0, 10,  +5, -10, -20, -10, -18,  10);
  909.             Label(hDC, s,   0, 10, -20, -10, +15, -10, -18, -25);
  910.             Label(hDC, t, -20, 10,  +5, -10, -20, -10, + 5,  10);
  911.         }                
  912.     }
  913. }
  914.  
  915.  
  916. void KMyCanvas::TestBezierPen(HDC hDC)
  917. {
  918.     const POINT P[12] = 
  919.     {   50, 200, 100,  50, 150, 350, 200, 200,
  920.        150,  50, 100, 350,  50, 200,
  921.        125, 275, 175, 200, 125, 125,  75, 200, 125, 275
  922.     };
  923.     
  924.     const BYTE T[12] = 
  925.     {     PT_MOVETO, PT_BEZIERTO, PT_BEZIERTO, PT_BEZIERTO,
  926.         PT_BEZIERTO , PT_BEZIERTO, PT_BEZIERTO | PT_CLOSEFIGURE,
  927.         PT_MOVETO, PT_LINETO, PT_LINETO, PT_LINETO, PT_LINETO | PT_CLOSEFIGURE
  928.     };
  929.  
  930.     SetROP2(hDC, R2_XORPEN);
  931.  
  932.     LOGBRUSH logbrush = { BS_SOLID, RGB(0xFF, 0xFF, 0), 0 };
  933.  
  934.     HPEN hPen = ExtCreatePen(PS_GEOMETRIC | PS_SOLID | PS_ENDCAP_FLAT | PS_JOIN_MITER, 15, & logbrush, 0, NULL);
  935.     SelectObject(hDC, hPen);
  936.  
  937.     PolyBezier(hDC, P, 7); // two Bezier curves
  938.     Polyline(hDC, P+7, 5); // diamond shape
  939.     
  940.     SetViewportOrgEx(hDC, 200, 0, NULL);
  941.     PolyDraw(hDC, P, T, 12);    // Bezier curves and diamon shape together
  942.     
  943.     SetViewportOrgEx(hDC, 0, 0, NULL);
  944.     SelectObject(hDC, GetStockObject(BLACK_PEN));
  945.     DeleteObject(hPen);
  946. }
  947.  
  948.  
  949. void KMyCanvas::TestArc(HDC hDC)
  950. {
  951. //    SetMapMode(hDC, MM_ANISOTROPIC);
  952. //    SetViewportExtEx(hDC, 1, -1, NULL);
  953.  
  954.     // 200 by 250
  955.     const int A =  80;
  956.     const int B = 100;
  957.     
  958.     POINT P[5] = { -A, -B, A, -B, A, B, -A, B, -A, -B };
  959.     POINT S    = {  A * 6/5, -B * 3/5 };
  960.     POINT E    = {  A * 6/5,  B * 3/5 };
  961.  
  962.     POINT PAA[5] = { -A, -A, A, -A, A, A, -A, A, -A, -A };
  963.     POINT SAA    = {  A * 6/5, -A * 3/5 };
  964.     POINT EAA    = {  A * 6/5,  A * 3/5 };
  965.  
  966.     // Arc counterclockwise
  967.     // ArcTo clockwise
  968.  
  969.     for (int i=0; i<3; i++)
  970.     {
  971.         if ( i==0 )
  972.         {
  973.             SetViewportOrgEx(hDC, 200, 300, 0);
  974.             SetArcDirection(hDC, AD_COUNTERCLOCKWISE);
  975.             Label(hDC, -65, P[0].y-40, "Arc, counterclockwise");
  976.         }
  977.         else
  978.         {
  979.             SetViewportOrgEx(hDC, 200 + i* A * 3, 300, 0);
  980.             SetArcDirection(hDC, AD_CLOCKWISE);
  981.  
  982.             if ( i==1)
  983.                 Label(hDC, -55, P[0].y-40, "ArcTo, clockwise");
  984.             else if (i==2)
  985.             {
  986.                 Label(hDC, -30, P[0].y-40, "AngleArc");
  987.                 memcpy(P, PAA, sizeof(P));
  988.                 S = SAA;
  989.                 E = EAA;
  990.             }
  991.         }
  992.     
  993.         HPEN hPen = CreatePen(PS_DOT, 0, RGB(0xFF, 0, 0));
  994.         HPEN hOld = (HPEN) SelectObject(hDC, hPen);
  995.  
  996.         // bounding rectangle, start/end lines
  997.         Polyline(hDC, P, 5);       Dot(hDC, P[0].x ,P[0].y); Dot(hDC, P[2].x ,P[2].y);
  998.         Line(hDC, 0, 0, S.x, S.y); Dot(hDC, S.x, S.y);
  999.         Line(hDC, 0, 0, E.x, E.y); Dot(hDC, E.x, E.y);
  1000.  
  1001.         SelectObject(hDC, hOld);
  1002.         DeleteObject(hPen);
  1003.  
  1004.         hPen = CreatePen(PS_INSIDEFRAME, 3, RGB(0, 0, 0xFF));
  1005.         SelectObject(hDC, hPen);
  1006.  
  1007.     //    SetROP2(hDC, R2_XORPEN);
  1008.  
  1009.         // solid arc
  1010.         switch ( i )
  1011.         {
  1012.             case 0:
  1013.                 Arc(hDC, P[0].x, P[0].y, P[2].x, P[2].y, S.x, S.y, E.x, E.y);
  1014.                 break;
  1015.  
  1016.             case 1:
  1017.                 MoveToEx(hDC, P[0].x, (P[0].y+P[2].y)/2, NULL);
  1018.                 ArcTo(hDC, P[0].x, P[0].y, P[2].x, P[2].y, S.x, S.y, E.x, E.y);
  1019.                 break;
  1020.  
  1021.             case 2:
  1022.                 MoveToEx(hDC, P[0].x, (P[0].y+P[2].y)/2, NULL);
  1023.                 AngleArcTo(hDC, (P[0].x + P[2].y)/2, (P[0].x + P[2].y)/2,A, (float)26.56, (float)(360-26.56*2));
  1024.                 break;
  1025.         }
  1026.         
  1027.         SelectObject(hDC, hOld);
  1028.         DeleteObject(hPen);
  1029.     
  1030.         // labels
  1031.         Label(hDC, P[0].x, P[0].y-20,  "(Left, Top)");
  1032.         Label(hDC, P[2].x-100, P[2].y+5, "(Bottom, Right)");
  1033.  
  1034.         if ( i==2 )
  1035.         {
  1036.             Label(hDC, S.x-20, S.y-20, "eStartAngle");
  1037.             Label(hDC, E.x-20, E.y+5,  "eStartAngle + eSweepAngle");
  1038.         }
  1039.         else
  1040.         {
  1041.             Label(hDC, S.x-20, S.y-20, "(xStart, yStart)");
  1042.             Label(hDC, E.x-20, E.y+5,  "(xEnd, yEnd)");
  1043.         }
  1044.     }
  1045.  
  1046. //    SetViewportExtEx(hDC, 1, 1, NULL);
  1047.     SetViewportOrgEx(hDC, 0, 0, NULL);
  1048. }
  1049.  
  1050.  
  1051.  
  1052. void KMyCanvas::ArcToBezier(HDC hDC)
  1053. {
  1054.     SetMapMode(hDC, MM_ANISOTROPIC);
  1055.     SetViewportExtEx(hDC, 1, -1, NULL);
  1056.  
  1057.     SetViewportOrgEx(hDC, 50, 450, NULL);
  1058.  
  1059.     Line(hDC, 0, 0, 0, 420);
  1060.     Line(hDC, 0, 0, 420, 0);
  1061.  
  1062.     // Draw Bezier curves for m=0.0 to 1.0
  1063.     {
  1064.         KPen pen(PS_COSMETIC | PS_ALTERNATE, 1, RGB(0xFF, 0, 0), 0, NULL, hDC);
  1065.     
  1066.         for (int m=0; m<=400; m+=80)
  1067.         {
  1068.             POINT P[4] = { 0, 400, m, 400, 400, m, 400, 0 };
  1069.  
  1070.         //    Polyline(hDC, P, 4);
  1071.             PolyBezier(hDC, P, 4);
  1072.  
  1073.             double error, t;
  1074.             error = Error(m/400.0, t);
  1075.  
  1076.             TCHAR mess[128];
  1077.             
  1078.             sprintf(mess, _T("m=%3.1f, error(%5.3f) = %+8.5f%%"), m/400.0, t, error*100);
  1079.             Label(hDC, 20, 170- m/3, mess);
  1080.         }
  1081.     }
  1082.  
  1083.     double M = 4*(sqrt(2)-1)/3;
  1084.     
  1085.     int m = (int) (M*400);
  1086.     
  1087.     POINT Q[4] = { 0, 400, m, 400, 400, m, 400, 0 };
  1088.  
  1089.     {
  1090.         KPen blue(PS_COSMETIC | PS_ALTERNATE, 1, RGB(0, 0, 0xFF), 0, NULL, hDC);
  1091.  
  1092.         Polyline(hDC, Q, 4);
  1093.     }
  1094.  
  1095.     {
  1096.         KPen pen(PS_SOLID, 3, RGB(0, 0, 0xFF), hDC);
  1097.         PolyBezier(hDC, Q, 4);
  1098.  
  1099.         Label(hDC, Q[0].x+5,  Q[0].y+20, "(0,1)");
  1100.         Label(hDC, Q[1].x+5,  Q[1].y+20, "(m,1)");
  1101.         Label(hDC, Q[2].x+10, Q[2].y+ 5, "(1,m)");
  1102.         Label(hDC, Q[3].x+10, Q[3].y+20, "(1,0)");
  1103.     }
  1104.  
  1105.     double error, t;
  1106.     error = Error(M, t);
  1107.  
  1108.     TCHAR mess[128];
  1109.             
  1110.     sprintf(mess, _T("m=%8.6f, error(%5.3f) = %+8.6f%%"), M, t, error*100);
  1111.     Label(hDC, 20, -20, mess);
  1112.  
  1113.     // Test FullEllipse
  1114.     for (int i=0; i<100; i+=10)
  1115.         EllipseToBezier(hDC, 530-i, 280-i, 530+i, 320+i);
  1116.     
  1117.     SetViewportExtEx(hDC, 1, 1, NULL);
  1118.     SetViewportOrgEx(hDC, 0, 0, NULL);
  1119. }
  1120.  
  1121.  
  1122. void KMyCanvas::AngleArcToBezier(HDC hDC)
  1123. {
  1124.     SetMapMode(hDC, MM_ANISOTROPIC);
  1125.     SetViewportExtEx(hDC, 1, -1, NULL);
  1126.  
  1127.     SetViewportOrgEx(hDC, 400, 350, NULL);
  1128.  
  1129.     for (int angle=15; angle<=240; angle+=15)
  1130.     {
  1131.         TCHAR mess[32];
  1132.         double err;
  1133.  
  1134.         ::AngleArcToBezier(hDC, 0, 0, 50+angle*2/3, 50+angle*2/3, 0, angle*3.1415926/180, & err);
  1135.  
  1136.         sprintf(mess, "%d degree, error=%8.5f%%", angle, err*100);
  1137.         Label(hDC, -380, 350-angle, mess);
  1138.     }
  1139.  
  1140.     SetViewportExtEx(hDC, 1, 1, NULL);
  1141.     SetViewportOrgEx(hDC, 0, 0, NULL);
  1142. }
  1143.  
  1144.  
  1145. void KMyCanvas::TestPath(HDC hDC)
  1146. {
  1147.     SetViewportOrgEx(hDC, 150, 200, NULL);
  1148.  
  1149.     KPen wide(PS_GEOMETRIC | PS_SOLID | PS_ENDCAP_FLAT | PS_JOIN_MITER, 17, RGB(0, 0, 0xFF), 0, NULL);
  1150. //    KPen wide(PS_SOLID, 0, RGB(0, 0, 0xFF));
  1151.     wide.Select(hDC);
  1152.  
  1153. //    KPen wide(PS_COSMETIC | PS_SOLID, 1, RGB(0, 0, 0xFF), 0, NULL);
  1154. //    wide.Select(hDC);
  1155.     
  1156.     // Path construction
  1157.     {
  1158.         BeginPath(hDC);
  1159.         
  1160.         MoveToEx(hDC, 0, 0, NULL);
  1161.         AngleArc(hDC, 0, 0, 150, 0, 135);
  1162.  
  1163.         POINT P[] = { -75, 20, -20, -75, 40, -40 };
  1164.         PolyBezierTo(hDC, P, 3);
  1165.         
  1166.         CloseFigure(hDC);
  1167.  
  1168.         EndPath(hDC);
  1169.     }
  1170.  
  1171. //    SetViewportOrgEx(hDC, 160, 200, NULL);
  1172.     
  1173. //    int n = SaveDC(hDC);
  1174. //    StrokePath(hDC);
  1175. //    RestoreDC(hDC, n);
  1176. //    SetViewportOrgEx(hDC, 150, 200, NULL);
  1177.  
  1178.     KPathData org;    org.GetPathData(hDC);
  1179.     
  1180.     FlattenPath(hDC);
  1181.     KPathData flt;  flt.GetPathData(hDC);
  1182.  
  1183.     WidenPath(hDC);
  1184.     KPathData wid;  wid.GetPathData(hDC);
  1185.  
  1186.     wide.UnSelect();
  1187.  
  1188.     //////////////////////////////////////////////
  1189.     // Draw original path data
  1190.     PolyDraw(hDC, org.m_pPoint, org.m_pFlag, org.m_nCount);
  1191.  
  1192.     // Display origin control points 
  1193.     SetViewportOrgEx(hDC, 450, 200, NULL);
  1194.     org.MarkPoints(hDC);
  1195.  
  1196.     //////////////////////////////////////////////
  1197.     // Display flatten lines
  1198.     SetViewportOrgEx(hDC, 150, 400, NULL);
  1199.     PolyDraw(hDC, flt.m_pPoint, flt.m_pFlag, flt.m_nCount);
  1200.     
  1201.  
  1202.     // Display flatten control
  1203.     SetViewportOrgEx(hDC, 450, 400, NULL);
  1204.     flt.MarkPoints(hDC);
  1205.  
  1206.     ///////////////////////////////////////////
  1207.     // Display flatten lines
  1208.     SetViewportOrgEx(hDC, 150, 600, NULL);
  1209.     PolyDraw(hDC, wid.m_pPoint, wid.m_pFlag, wid.m_nCount);
  1210.  
  1211.     // Display flatten control
  1212.     SetViewportOrgEx(hDC, 450, 600, NULL);
  1213.     wid.MarkPoints(hDC);
  1214.  
  1215.     SetViewportOrgEx(hDC, 750, 200, NULL);
  1216.  
  1217.     // Use WidenPath and Stroke path to show geometric line construction
  1218.     for (int i=0; i<3; i++)
  1219.     {
  1220.         const WideStyle[] = { PS_ENDCAP_SQUARE | PS_JOIN_MITER,
  1221.                               PS_ENDCAP_ROUND  | PS_JOIN_ROUND,
  1222.                               PS_ENDCAP_FLAT   | PS_JOIN_BEVEL
  1223.                             };
  1224.         const ThinStyle[] = { PS_ALTERNATE, PS_DOT, PS_SOLID };
  1225.         const Color    [] = { RGB(0xFF, 0, 0), RGB(0, 0, 0xFF), RGB(0,0,0) };
  1226.  
  1227.  
  1228.         {
  1229.             KPen wide(PS_GEOMETRIC | PS_SOLID | WideStyle[i], 70, RGB(0, 0, 0xFF), 0, NULL, hDC);
  1230.  
  1231.             BeginPath(hDC);
  1232.                 MoveToEx(hDC, 150, 0, NULL);
  1233.                 LineTo(hDC, 0, 0);
  1234.                 LineTo(hDC, 100, -100);
  1235.             EndPath(hDC);
  1236.             WidenPath(hDC);
  1237.         }
  1238.         
  1239.         if (i==2 )
  1240.         {
  1241.             KPathData pd; 
  1242.             pd.GetPathData(hDC);
  1243.             pd.MarkPoints(hDC, false);
  1244.         }
  1245.  
  1246.         {
  1247.             KPen thin(PS_COSMETIC | ThinStyle[i], 1, Color[i], 0, NULL, hDC);
  1248.             
  1249.             StrokePath(hDC);
  1250.         }
  1251.     }
  1252.  
  1253.     SetViewportOrgEx(hDC, 0, 0, NULL);
  1254.  
  1255. #ifdef TEST_INSIDEFRAME
  1256.  
  1257.     BeginPath(hDC);
  1258.  
  1259.     Ellipse(hDC, 0, 0, 100, 100);
  1260.  
  1261.     HPEN    hPen = CreatePen(PS_INSIDEFRAME, 21, RGB(0xFF, 0, 0));
  1262.     HGDIOBJ hOld = SelectObject(hDC, hPen);
  1263.     
  1264.     Ellipse(hDC, 0, 0, 100, 100);
  1265.  
  1266.     EndPath(hDC);
  1267.  
  1268.     SelectObject(hDC, hOld);
  1269.  
  1270.     StrokePath(hDC);
  1271.  
  1272.     DeleteObject(hPen);
  1273.  
  1274. #endif
  1275. }
  1276.  
  1277.  
  1278. void KMyCanvas::TestPathStyleCurve(HDC hDC)
  1279. {
  1280.     SetViewportOrgEx(hDC, 400, 300, NULL);
  1281.  
  1282.     for (int i=6; i<10; i++)
  1283.     {
  1284.         BeginPath(hDC);
  1285.         Ellipse(hDC, -50-i*25, -50-i*20, 50+i*25, 50+i*20);
  1286.         CloseFigure(hDC);
  1287.         EndPath(hDC);
  1288.  
  1289.         FlattenPath(hDC);
  1290.         KPathData flt;  
  1291.         flt.GetPathData(hDC);
  1292.  
  1293.         KDashes dash(hDC, i);
  1294.         KStyleCurve sc(& dash);
  1295.  
  1296.         sc.PolyDraw(flt.m_pPoint, flt.m_pFlag, flt.m_nCount);
  1297.     }
  1298.  
  1299.     SetViewportOrgEx(hDC, 0, 0, NULL);
  1300. }
  1301.  
  1302.  
  1303. void KMyCanvas::TestMapPath(HDC hDC)
  1304. {
  1305.     {
  1306.         KPen wide(PS_GEOMETRIC | PS_SOLID | PS_ENDCAP_FLAT | PS_JOIN_MITER, 15, 
  1307.                 RGB(0, 0, 0xFF), 0, NULL, hDC);
  1308.  
  1309.         BeginPath(hDC);
  1310.             Rectangle(hDC, 50, 50, 200, 500);
  1311.         EndPath(hDC);
  1312.  
  1313.         WidenPath(hDC);
  1314.     }
  1315.  
  1316.     KPathData pd;
  1317.     pd.GetPathData(hDC);
  1318.  
  1319.     StrokePath(hDC);
  1320.  
  1321.     KBiLinearMap bl;
  1322.     bl.SetWindow(50, 50, 150, 450);
  1323.     
  1324.     POINT Dest[] = { 200+9, 500, 200+9, 50, 500+9, 400, 450+9, 300 };
  1325.     bl.SetDestination(Dest);
  1326.  
  1327.     pd.MapPoints(bl);
  1328.  
  1329.     BeginPath(hDC);
  1330.         PolyDraw(hDC, pd.m_pPoint, pd.m_pFlag, pd.m_nCount);
  1331.     EndPath(hDC);
  1332.  
  1333.     SelectObject(hDC, GetStockObject(BLACK_BRUSH));
  1334.     FillPath(hDC);
  1335. }
  1336.  
  1337.  
  1338. void KMyCanvas::OnDraw(HDC hDC, const RECT * rcPaint)
  1339. {
  1340.     switch ( m_test )
  1341.     {
  1342.         case IDM_TEST_DRAWMODE:
  1343.             TestDrawMode(hDC);
  1344.             break;
  1345.  
  1346.         case IDM_TEST_WIDTHCAP:
  1347.             TestWidthCap(hDC);
  1348.             break;
  1349.  
  1350.         case IDM_TEST_DCPEN:
  1351.             TestDCPen(hDC);
  1352.             break;
  1353.  
  1354.         case IDM_TEST_PENSTYLE:
  1355.             TestPenStyle(hDC);
  1356.             break;
  1357.  
  1358.         case IDM_TEST_COSMETIC:
  1359.             TestCosmetic(hDC);
  1360.             break;
  1361.  
  1362.         case IDM_TEST_GEOMETRIC_WIDTH:
  1363.             TestGeometricWidth(hDC);
  1364.             break;
  1365.  
  1366.         case IDM_TEST_GEOMETRIC_STYLE:
  1367.             TestGeometricStyle(hDC);
  1368.             break;
  1369.  
  1370.         case IDM_TEST_LINE1:
  1371.             TestLine1(hDC);
  1372.             break;
  1373.  
  1374.         case IDM_TEST_LINE2:
  1375.             TestLine2(hDC);
  1376.             break;
  1377.  
  1378.         case IDM_TEST_BEZIER:
  1379.             TestBezier(hDC);
  1380.             break;
  1381.  
  1382.         case IDM_TEST_BEZIERDEMO:
  1383.             BezierDemo(hDC);
  1384.             break;
  1385.  
  1386.         case IDM_TEST_BEZIERPEN:
  1387.             TestBezierPen(hDC);
  1388.             break;
  1389.  
  1390.         case IDM_TEST_ARC:
  1391.             TestArc(hDC);
  1392.             break;
  1393.  
  1394.         case IDM_TEST_ARCBEZIER:
  1395.             ArcToBezier(hDC);
  1396.             break;
  1397.  
  1398.         case IDM_TEST_ANGLEARCBEZIER:
  1399.             AngleArcToBezier(hDC);
  1400.             break;
  1401.  
  1402.         case IDM_TEST_PATH:
  1403.             TestPath(hDC);
  1404.             break;
  1405.  
  1406.         case IDM_TEST_PATHSTYLECURVE:
  1407.             TestPathStyleCurve(hDC);
  1408.             break;
  1409.  
  1410.         case IDM_TEST_MAPPATH:
  1411.             TestMapPath(hDC);
  1412.     }
  1413. }
  1414.  
  1415. class KLogoFrame : public KFrame
  1416. {
  1417.     void GetWndClassEx(WNDCLASSEX & wc)
  1418.     {
  1419.         KFrame::GetWndClassEx(wc);
  1420.  
  1421.         wc.hIcon = LoadIcon(m_hInst, MAKEINTRESOURCE(IDI_LINE));
  1422.     }
  1423.  
  1424. public:
  1425.     KLogoFrame(HINSTANCE hInstance, const TBBUTTON * pButtons, int nCount,
  1426.         KToolbar * pToolbar, KCanvas * pCanvas, KStatusWindow * pStatus) :
  1427.             KFrame(hInstance, pButtons, nCount, pToolbar, pCanvas, pStatus)
  1428.     {
  1429.     }
  1430.  
  1431. };
  1432.  
  1433.  
  1434. int WINAPI WinMain(HINSTANCE hInst, HINSTANCE, LPSTR, int nShow)
  1435. {
  1436.     KMyCanvas     canvas;
  1437.     KStatusWindow status;
  1438.  
  1439.     KLogoFrame frame(hInst, NULL, 0, NULL, & canvas, & status);
  1440.  
  1441.     frame.CreateEx(0, _T("LineCurveDemo"), _T("LineCurve"),
  1442.         WS_OVERLAPPEDWINDOW,
  1443.         CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, 
  1444.         NULL, LoadMenu(hInst, MAKEINTRESOURCE(IDR_MAIN)), hInst);
  1445.  
  1446.     frame.ShowWindow(nShow);
  1447.     frame.UpdateWindow();
  1448.  
  1449.     frame.MessageLoop();
  1450.  
  1451.     return 0;
  1452. }
  1453.