1. /*
    2.     This program is free software: you can redistribute it and/or modify
    3.     it under the terms of the GNU General Public License as published by
    4.     the Free Software Foundation, either version 3 of the License, or
    5.     (at your option) any later version.
    7.     This program is distributed in the hope that it will be useful,
    8.     but WITHOUT ANY WARRANTY; without even the implied warranty of
    9.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    10.     GNU General Public License for more details.
    12.     You should have received a copy of the GNU General Public License
    13.     along with this program.  If not, see <http://www.gnu.org/licenses/>.
    14. */
    15. ////////////////////////////////////////////////////////////////
    16. //  ACLLib - Advanced C Lab Library
    17. //    Ver. 2014-07
    18. //    For Students' Lab at Zhejiang University
    19. //    Created     2008 by Gao Yuan
    20. //    Modified     2009 by Cui Liwei
    21. //                    2010 by Lan Huidong
    22. //    Revised        2012 by Li Rui
    23. //  Modified  2014 by Weng Kai for MOOC
    24. ////////////////////////////////////////////////////////////////
    26. #define _CRT_SECURE_NO_WARNINGS
    27. #define _CRT_NON_CONFORMING_SWPRINTFS
    29. #define CINTERFACE
    31. #ifdef _UNICODE
    32. #undef _UNICODE
    33. #endif
    34. #ifdef UNICODE
    35. #undef UNICODE
    36. #endif
    38. #include "acllib.h"
    40. #include <windows.h>
    41. #include <olectl.h>
    42. #include <stdio.h>
    44. #ifdef _MSC_VER
    45. #pragma comment(lib,"winmm.lib")
    46. #pragma comment(lib,"msimg32.lib")
    47. #endif
    49. #ifdef _DEBUG
    50. #define ACL_ASSERT(_Expression,errStr) (void)( (!!(_Expression)) || (acl_error(errStr),0) )
    51. #else
    52. #define ACL_ASSERT(flag,errStr) ((void)0)
    53. #endif
    55. #define ACL_ASSERT_HWND ACL_ASSERT(g_hWnd!=0, \
    56.     "You should call function \"initWindow(...)\" befor use function \"" __FUNCTION__ "\"" )
    57. #define ACL_ASSERT_BEGIN_PAINT ACL_ASSERT(g_hmemdc!=0, \
    58.     "You should call function \"beginPaint()\" befor use function \"" __FUNCTION__ "\"" )
    60. // f
    61. int Setup(void);
    63. const char g_wndClassName[] = "ACL_WND_CLASS";
    64. const char g_libName[] = "ACLLIB";
    66. HINSTANCE g_hInstance;
    68. HWND g_hWnd = NULL;
    69. HDC g_hmemdc = NULL;
    70. HBITMAP g_hbitmap = NULL;
    72. int g_wndHeight;
    73. int g_wndWidth;
    75. HPEN g_pen = NULL;
    76. ACL_Color g_penColor = BLACK;
    77. int g_penWidth = 1;
    78. int g_penStyle = PEN_STYLE_SOLID;
    80. HBRUSH g_brush = NULL;
    81. ACL_Color g_brushColor = BLACK;
    82. int g_brushStyle = BRUSH_STYLE_SOLID;
    84. HFONT g_font = NULL;
    85. char g_fontName[256] = "宋体";
    86. int g_textSize = 12;
    87. ACL_Color g_textColor = BLACK;
    88. ACL_Color g_textBkColor = WHITE;
    90. int g_caretHeight = 12;
    91. int g_caretWidth = 6;
    92. int g_caretX = 0;
    93. int g_caretY = 0;
    95. int g_soundID = 0;
    97. KeyboardEventCallback g_keyboard = NULL;
    98. MouseEventCallback g_mouse = NULL;
    99. TimerEventCallback g_timer = NULL;
    100. CharEventCallback g_char = NULL;
    102. LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
    104. //
    105. void acl_error(char *errStr)
    106. {
    107.     MessageBoxA(g_hWnd,errStr,g_libName,MB_ICONERROR);
    108.     exit(0);
    109. }
    111. //
    112. int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine, int iCmdShow)
    113. {
    114.     MSG          msg;
    115.     WNDCLASSA     wndclass;
    117.     g_hInstance = hInstance;
    118.     g_hWnd = NULL;
    119.     g_keyboard = NULL;
    120.     g_mouse = NULL;
    121.     g_timer = NULL;
    123.     wndclass.style         = CS_HREDRAW | CS_VREDRAW | CS_OWNDC | CS_DBLCLKS;
    124.     wndclass.lpfnWndProc   = WndProc;
    125.     wndclass.cbClsExtra    = 0;
    126.     wndclass.cbWndExtra    = 0;
    127.     wndclass.hInstance     = hInstance;
    128.     wndclass.hInstance     = hInstance;
    129.     wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION);
    130.     wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW);
    131.     wndclass.hbrBackground = (HBRUSH) GetStockObject (BLACK_BRUSH);
    132.     wndclass.lpszMenuName  = NULL;
    133.     wndclass.lpszClassName = g_wndClassName;
    135.     if (!RegisterClassA(&wndclass))
    136.     {
    137.         MessageBoxA(NULL, "This program requires Windows NT!", g_libName, MB_ICONERROR);
    138.         return 0;
    139.     }
    141.     Setup();
    143.     ACL_ASSERT(g_hWnd,"You must call \"initWindow(...)\" in Main()");
    145.     while (GetMessage(&msg, NULL, 0, 0))
    146.     {
    147.         TranslateMessage (&msg);
    148.         DispatchMessage (&msg);
    149.     }
    150.     return msg.wParam;
    151. }
    153. //
    154. LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
    155. { 
    156.     switch (message) 
    157.     {
    158.     case WM_CREATE:
    159.         {
    160.             HDC hdc;
    161.             hdc = GetDC(hwnd);
    162.             g_hbitmap = CreateCompatibleBitmap(
    163.                 hdc, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN));
    164.             g_hmemdc = CreateCompatibleDC(hdc);
    165.             SelectObject(g_hmemdc, g_hbitmap);
    166.             BitBlt(g_hmemdc, 
    167.                 0, 0, 
    168.                 GetSystemMetrics(SM_CXSCREEN),
    169.                 GetSystemMetrics(SM_CYSCREEN), 
    170.                 g_hmemdc, 
    171.                 0, 0, 
    172.                 WHITENESS);
    173.             DeleteDC(g_hmemdc);
    174.             ReleaseDC(hwnd, hdc);
    176.             CreateCaret(hwnd,0,g_caretWidth,g_caretHeight);
    177.             g_caretX = g_wndWidth;
    178.             g_caretY = g_wndHeight;
    179.             SetCaretPos(g_caretX,g_caretY);
    181.             break;
    182.         }
    183.     case WM_ERASEBKGND:
    184.         break;
    185.     case WM_PAINT:
    186.         {
    187.             HDC hdc;
    188.             PAINTSTRUCT ps;
    189.             RECT rect;
    191.             hdc = BeginPaint(hwnd, &ps);
    192.             g_hmemdc = CreateCompatibleDC(hdc);
    193.             SelectObject(g_hmemdc, g_hbitmap);
    194.             GetClientRect(hwnd,&rect);
    195.             BitBlt(hdc, 0, 0, rect.right - rect.left,
    196.                 rect.bottom - rect.top, g_hmemdc, 0, 0, SRCCOPY);
    197.             DeleteDC(g_hmemdc);
    198.             g_hmemdc = 0;
    199.             EndPaint(hwnd,&ps);
    200.             break;
    201.         }
    202.     case WM_CHAR:
    203.         if (g_char != NULL)
    204.             g_char((char) wParam);
    205.         break;
    207.     case WM_KEYDOWN:
    208.         if (g_keyboard != NULL)
    209.             g_keyboard((int) wParam,KEY_DOWN);
    210.         break;
    212.     case WM_KEYUP:
    213.         if(g_keyboard != NULL)
    214.             g_keyboard((int) wParam,KEY_UP);
    215.         break;
    217.     case WM_LBUTTONDOWN:
    218.         if (g_mouse != NULL)
    219.             g_mouse((int) LOWORD(lParam), (int) HIWORD(lParam), LEFT_BUTTON, BUTTON_DOWN);
    220.         break;
    222.     case WM_LBUTTONUP:
    223.         if (g_mouse != NULL)
    224.             g_mouse((int) LOWORD(lParam), (int) HIWORD(lParam), LEFT_BUTTON, BUTTON_UP);
    225.         break;
    227.     case WM_LBUTTONDBLCLK:
    228.         if (g_mouse != NULL)
    229.             g_mouse((int) LOWORD(lParam), (int) HIWORD(lParam), LEFT_BUTTON, BUTTON_DOUBLECLICK);
    230.         break;
    232.     case WM_MBUTTONDOWN:
    233.         if (g_mouse != NULL)
    234.             g_mouse((int) LOWORD(lParam), (int) HIWORD(lParam), MIDDLE_BUTTON, BUTTON_DOWN);
    235.         break;
    237.     case WM_MBUTTONUP:
    238.         if (g_mouse != NULL)
    239.             g_mouse((int) LOWORD(lParam), (int) HIWORD(lParam), MIDDLE_BUTTON, BUTTON_UP);
    240.         break;
    242.     case WM_MBUTTONDBLCLK:
    243.         if (g_mouse != NULL)
    244.             g_mouse((int) LOWORD(lParam), (int) HIWORD(lParam), MIDDLE_BUTTON, BUTTON_DOUBLECLICK);
    245.         break;
    247.     case WM_RBUTTONDOWN:
    248.         if (g_mouse != NULL)
    249.             g_mouse((int) LOWORD(lParam), (int) HIWORD(lParam), RIGHT_BUTTON, BUTTON_DOWN);
    250.         break;
    252.     case WM_RBUTTONUP:
    253.         if (g_mouse != NULL)
    254.             g_mouse((int) LOWORD(lParam), (int) HIWORD(lParam), RIGHT_BUTTON, BUTTON_UP);
    255.         break;
    257.     case WM_RBUTTONDBLCLK:
    258.         if (g_mouse != NULL)
    259.             g_mouse((int) LOWORD(lParam), (int) HIWORD(lParam), RIGHT_BUTTON, BUTTON_DOUBLECLICK);
    260.         break;
    262.     case WM_MOUSEMOVE:
    263.         if(g_mouse != NULL)
    264.             g_mouse((int) LOWORD(lParam), (int) HIWORD(lParam), MOUSEMOVE, MOUSEMOVE);
    265.         break;
    267.     case WM_MOUSEWHEEL:
    268.         if(g_mouse == NULL)
    269.             break;
    270.         if(HIWORD(wParam) == 120)
    271.             g_mouse((int) LOWORD(lParam), (int) HIWORD(lParam),MIDDLE_BUTTON,ROLL_UP);
    272.         else if(HIWORD(wParam)==65416)
    273.             g_mouse((int) LOWORD(lParam), (int) HIWORD(lParam),MIDDLE_BUTTON,ROLL_DOWN);
    274.         break;
    276.     case WM_TIMER:
    277.         if (g_timer != NULL)
    278.             g_timer(wParam);
    279.         break;
    281.     case WM_DESTROY:
    282.         DeleteObject(g_hbitmap);
    283.         PostQuitMessage(0);
    284.         break;
    285.     default:
    286.         return DefWindowProc(hwnd, message, wParam, lParam);
    287.     }
    288.     return 0;
    289. }
    291. //
    292. void initWindow(const char *wndName, int x, int y, int width, int height)
    293. {
    294.     RECT rect;
    296.     ACL_ASSERT(!g_hWnd,"Don't call initWindow twice");
    298.     g_wndHeight = height;
    299.     g_wndWidth = width;
    301.     if(x==DEFAULT || y==DEFAULT)
    302.         x=y=CW_USEDEFAULT;
    304.     g_hWnd = CreateWindowA (
    305.         g_wndClassName, wndName,
    306.         WS_OVERLAPPEDWINDOW & ~WS_MAXIMIZEBOX & ~WS_SIZEBOX,
    307.         x, y, 
    308.         width, height,
    309.         NULL, NULL, 0, NULL) ;
    311.     if(!g_hWnd)
    312.     {
    313.         MessageBoxA(NULL,"Fail to create window",g_libName,MB_ICONERROR);
    314.         exit(0);
    315.     }
    316.     GetClientRect(g_hWnd,&rect);
    317.     width += width - (rect.right-rect.left);
    318.     height += height - (rect.bottom-rect.top);
    319.     SetWindowPos(g_hWnd,HWND_TOP,0,0,width,height,SWP_NOMOVE);
    321.     ShowWindow (g_hWnd,1);
    322.     UpdateWindow (g_hWnd);
    323. }
    325. void initConsole(void)
    326. {
    327.     AllocConsole();
    328.     freopen("CONIN$", "r+t", stdin);
    329.     freopen("CONOUT$", "w+t", stdout);
    330. }
    332. void msgBox(const char title[],const char text[],int flag)
    333. {
    334.     ACL_ASSERT_HWND;
    335.     MessageBoxA(g_hWnd,text,title,flag);
    336. }
    339. //
    340. void updatePen();
    341. void updateBrush();
    342. void updateFont();
    344. //
    345. void beginPaint()
    346. {
    347.     HDC hdc;
    349.     ACL_ASSERT_HWND;
    351.     hdc = GetDC(g_hWnd);
    352.     g_hmemdc = CreateCompatibleDC(hdc);
    353.     SelectObject(g_hmemdc,g_hbitmap);
    355.     updatePen();
    356.     updateBrush();
    357.     updateFont();
    358.     setTextColor(g_textColor);
    359.     setTextBkColor(g_textBkColor);
    360. }
    362. void endPaint()
    363. {
    364.     DeleteDC(g_hmemdc);    
    365.     g_hmemdc = 0;
    366.     InvalidateRect(g_hWnd,0,0);
    368.     DeleteObject(g_pen);
    369.     DeleteObject(g_brush);
    370.     DeleteObject(g_font);
    371.     g_pen = NULL;
    372.     g_brush = NULL;
    373.     g_font = NULL;
    374. }
    376. void clearDevice(void)
    377. {
    378.     ACL_ASSERT_BEGIN_PAINT;
    379.     BitBlt(
    380.         g_hmemdc, 
    381.         0, 0, 
    382.         GetSystemMetrics(SM_CXSCREEN), 
    383.         GetSystemMetrics(SM_CYSCREEN) , 
    384.         g_hmemdc, 
    385.         0, 0,
    386.         WHITENESS);    
    387. }
    389. void updatePen()
    390. {
    391.     if(g_pen)DeleteObject(g_pen);
    392.     if(g_penColor==EMPTY)
    393.         g_pen = (HPEN)GetStockObject(NULL_PEN);
    394.     else
    395.         g_pen = CreatePen(g_penStyle,g_penWidth,g_penColor);
    396.     SelectObject(g_hmemdc,g_pen);
    397. }
    399. void updateBrush()
    400. {
    401.     if(g_brush)DeleteObject(g_brush);
    402.     if(g_brushColor==EMPTY)
    403.     {
    404.         g_brush = (HBRUSH)GetStockObject(NULL_BRUSH);
    405.     }
    406.     else
    407.     {
    408.         if(g_brushStyle==BRUSH_STYLE_SOLID)
    409.             g_brush = CreateSolidBrush(g_brushColor);    
    410.         else
    411.             g_brush = CreateHatchBrush(g_brushStyle,g_brushColor);
    412.     }
    413.     SelectObject(g_hmemdc,g_brush);
    414. }
    416. void updateFont()
    417. {
    418.     if(g_font)DeleteObject(g_font);
    419.     g_font = CreateFontA(
    420.         g_textSize,
    421.         0,
    422.         0,0,700,0,0,0,0,0,0,0,0,g_fontName);
    423.     SelectObject(g_hmemdc,g_font);
    424. }
    426. void setPenColor(ACL_Color newColor)
    427. {
    428.     ACL_ASSERT_BEGIN_PAINT;
    429.     g_penColor = newColor;    
    430.     updatePen();
    431. }
    433. void setPenWidth(int width)
    434. {
    435.     ACL_ASSERT_BEGIN_PAINT;
    436.     g_penWidth = width;
    437.     updatePen();
    438. }
    440. void setPenStyle(ACL_Pen_Style newStyle)
    441. {
    442.     ACL_ASSERT_BEGIN_PAINT;
    444.     switch(newStyle)
    445.     {
    446.     case PEN_STYLE_SOLID:
    447.         g_penStyle = PS_SOLID; break;
    448.     case PEN_STYLE_DASH:
    449.         g_penStyle = PS_DASH; break;
    450.     case PEN_STYLE_DOT:    
    451.         g_penStyle = PS_DOT; break;
    452.     case PEN_STYLE_DASHDOT:
    453.         g_penStyle = PS_DASHDOT; break;
    454.     case PEN_STYLE_DASHDOTDOT:    
    455.         g_penStyle = PS_DASHDOTDOT; break;
    456.     case PEN_STYLE_NULL:
    457.         g_penStyle = -1;
    458.         setPenColor(EMPTY);
    459.         return;
    460.     default:
    461.         break;
    462.     }
    463.     updatePen();
    464. }
    466. void setBrushColor(ACL_Color newColor)
    467. {
    468.     ACL_ASSERT_BEGIN_PAINT;
    469.     g_brushColor = newColor;
    470.     updateBrush();
    471. }
    473. void setBrushStyle(ACL_Brush_Style newStyle)
    474. {
    475.     ACL_ASSERT_BEGIN_PAINT;
    477.     switch(newStyle)
    478.     {
    479.     case BRUSH_STYLE_SOLID:
    480.         g_brushStyle = BRUSH_STYLE_SOLID; break;
    481.     case BRUSH_STYLE_HORIZONTAL:    
    482.         g_brushStyle = HS_HORIZONTAL; break;
    483.     case BRUSH_STYLE_VERTICAL:        
    484.         g_brushStyle = HS_VERTICAL; break;
    485.     case BRUSH_STYLE_FDIAGONAL:        
    486.         g_brushStyle = HS_FDIAGONAL; break;
    487.     case BRUSH_STYLE_BDIAGONAL:        
    488.         g_brushStyle = HS_BDIAGONAL; break;
    489.     case BRUSH_STYLE_CROSS:            
    490.         g_brushStyle = HS_CROSS; break;
    491.     case BRUSH_STYLE_DIAGCROSS:        
    492.         g_brushStyle = HS_DIAGCROSS; break;
    493.     case BRUSH_STYLE_NULL:
    494.         g_brushStyle = BRUSH_STYLE_SOLID;
    495.         setBrushColor(EMPTY);
    496.         return;
    497.     default:
    498.         break;
    499.     }
    500.     updateBrush();
    501. }
    503. void setTextColor(ACL_Color color)
    504. {
    505.     ACL_ASSERT_BEGIN_PAINT;
    506.     ACL_ASSERT(color!=EMPTY,"text color can not be EMPTY");
    507.     g_textColor = color;
    508.     SetTextColor(g_hmemdc,color);
    509. }
    511. void setTextBkColor(ACL_Color color)
    512. {
    513.     ACL_ASSERT_BEGIN_PAINT;
    514.     g_textBkColor = color;
    515.     if(color == EMPTY)
    516.         SetBkMode(g_hmemdc,TRANSPARENT);
    517.     else
    518.     {
    519.         SetBkMode(g_hmemdc,OPAQUE);
    520.         SetBkColor(g_hmemdc,color);
    521.     }    
    522. }
    524. void setTextSize(int size)
    525. {
    526.     ACL_ASSERT_BEGIN_PAINT;
    527.     g_textSize = size;
    528.     updateFont();
    529. }
    531. void setTextFont(const char *pfn)
    532. {
    533.     size_t len;
    534.     ACL_ASSERT_BEGIN_PAINT;
    535.     len = strlen(pfn);
    536.     strcpy(g_fontName,pfn);
    537.     updateFont();
    538. }
    540. void paintText(int x, int y, const char *textstring)
    541. {    
    542.     ACL_ASSERT_BEGIN_PAINT;
    543.     TextOutA(g_hmemdc, x, y, textstring, strlen(textstring));
    544. }
    546. void putPixel(int x, int y, ACL_Color color)
    547. {
    548.     ACL_ASSERT_BEGIN_PAINT;
    549.     SetPixel(g_hmemdc, x, y, color);    
    550. }
    552. ACL_Color getPixel(int x, int y)
    553. {
    554.     ACL_ASSERT_BEGIN_PAINT;
    555.     return GetPixel(g_hmemdc, x, y);
    556. }
    558. int getWidth(void)
    559. {
    560.     RECT rect;
    561.     GetClientRect(g_hWnd, &rect);
    562.     return rect.right;
    563. }
    565. int getHeight(void)
    566. {
    567.     RECT rect;
    568.     GetClientRect(g_hWnd, &rect);
    569.     return rect.bottom;
    570. }
    572. int getX(void)
    573. {
    574.     POINT point;
    575.     ACL_ASSERT_BEGIN_PAINT;
    576.     GetCurrentPositionEx(g_hmemdc, &point);
    577.     return (int) point.x;
    578. }
    580. int getY(void)
    581. {
    582.     POINT point;
    583.     ACL_ASSERT_BEGIN_PAINT;
    584.     GetCurrentPositionEx(g_hmemdc, &point);
    585.     return (int) point.y;
    586. }
    588. void moveTo(int x, int y)
    589. {
    590.     ACL_ASSERT_BEGIN_PAINT;
    591.     MoveToEx(g_hmemdc, x, y,NULL);
    592. }
    594. void moveRel(int dx, int dy)
    595. {
    596.     POINT point;    
    597.     ACL_ASSERT_BEGIN_PAINT;
    598.     GetCurrentPositionEx(g_hmemdc, &point);
    599.     MoveToEx(g_hmemdc, (int) point.x + dx, (int) point.y + dy,NULL);
    600. }
    602. // Lines and Curves
    603. void arc(int x1,int y1,int x2,int y2,int x3,int y3,int x4,int y4)
    604. {
    605.     ACL_ASSERT_BEGIN_PAINT;
    606.     Arc(g_hmemdc,x1,y1,x2,y2,x3,y3,x4,y4);
    607. }
    609. void line(int x0, int y0, int x1, int y1)
    610. {
    611.     POINT point;    
    612.     ACL_ASSERT_BEGIN_PAINT;
    613.     GetCurrentPositionEx(g_hmemdc, &point);
    614.     MoveToEx(g_hmemdc, x0, y0, NULL);
    615.     LineTo(g_hmemdc, x1, y1);
    616.     MoveToEx(g_hmemdc,point.x,point.y,NULL);
    617. }
    619. void lineTo(int x, int y)
    620. {
    621.     ACL_ASSERT_BEGIN_PAINT;
    622.     LineTo(g_hmemdc, x, y);
    623. }
    625. void lineRel(int dx, int dy)
    626. {
    627.     POINT point;
    628.     ACL_ASSERT_BEGIN_PAINT;
    629.     GetCurrentPositionEx(g_hmemdc, &point);
    630.     LineTo(g_hmemdc, (int) point.x + dx, (int) point.y + dy);
    631. }
    633. void polyBezier(const POINT *lppt,int cPoints)
    634. {
    635.     PolyBezier(g_hmemdc,lppt,cPoints);
    636. }
    638. void polyLine(const POINT *lppt, int cPoints)
    639. {
    640.     Polyline(g_hmemdc,lppt,cPoints);
    641. }
    643. // Filled Shapes
    644. void chrod(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4)
    645. {
    646.     ACL_ASSERT_BEGIN_PAINT;
    647.     Chord(g_hmemdc,x1, y1, x2, y2, x3, y3, x4, y4);
    648. }
    650. void ellipse(int left,int top,int right, int bottom)
    651. {
    652.     ACL_ASSERT_BEGIN_PAINT;
    653.     Ellipse(g_hmemdc,left,top,right,bottom);
    654. }
    656. void pie(int left, int top, int right, int bottom, int xr1, int yr1, int xr2, int yr2)
    657. {
    658.     ACL_ASSERT_BEGIN_PAINT;
    659.     Pie(g_hmemdc,left,top,right,bottom,xr1,yr1,xr2,yr2);
    660. }
    662. void polygon(const POINT *apt,int cpt)
    663. {
    664.     ACL_ASSERT_BEGIN_PAINT;
    665.     Polygon(g_hmemdc,apt,cpt);
    666. }
    668. void rectangle(int left,int top,int right,int bottom)
    669. {
    670.     ACL_ASSERT_BEGIN_PAINT;
    671.     Rectangle(g_hmemdc,left,top,right,bottom);
    672. }
    674. void roundrect(int left,int top,int right,int bottom,int width,int height)
    675. {
    676.     ACL_ASSERT_BEGIN_PAINT;
    677.     RoundRect(g_hmemdc,left,top,right,bottom,width,height);
    678. }
    680. void polyline(POINT *apt,int cpt)
    681. {
    682.     ACL_ASSERT_BEGIN_PAINT;
    683.     Polyline(g_hmemdc,apt,cpt);
    684. }
    687. void putImage(ACL_Image *pImage, int x, int y)
    688. {
    689.     HDC hbitmapdc;
    690.     ACL_ASSERT_BEGIN_PAINT;
    691.     hbitmapdc = CreateCompatibleDC(g_hmemdc);
    692.     SelectObject(hbitmapdc, pImage->hbitmap);
    693.     BitBlt(g_hmemdc, x, y, pImage->width, pImage->height, hbitmapdc,0,0,SRCCOPY);
    694.     DeleteDC(hbitmapdc);
    695. }
    697. void putImageScale(ACL_Image *pImage,int x,int y,int width,int height)
    698. {
    699.     HDC hbitmapdc;
    700.     ACL_ASSERT_BEGIN_PAINT;
    701.     hbitmapdc = CreateCompatibleDC(g_hmemdc);
    702.     SelectObject(hbitmapdc, pImage->hbitmap);
    703.     if(width == -1)width = pImage->width;
    704.     if(height == -1)height = pImage->height;
    705.     SetStretchBltMode(g_hmemdc,COLORONCOLOR);
    706.     StretchBlt( g_hmemdc,x,y,width,height,hbitmapdc,0,0,pImage->width,pImage->height,SRCCOPY);
    707.     DeleteDC(hbitmapdc);
    708. }
    710. void putImageTransparent(ACL_Image *pImage,int x,int y,int width,int height, ACL_Color bkColor)
    711. {
    712.     HDC hbitmapdc;
    713.     ACL_ASSERT_BEGIN_PAINT;
    714.     hbitmapdc = CreateCompatibleDC(g_hmemdc);
    715.     SelectObject(hbitmapdc, pImage->hbitmap);
    716.     if(width == -1)width = pImage->width;
    717.     if(height == -1)height = pImage->height;
    718.     //SetStretchBltMode(g_hmemdc,COLORONCOLOR);
    719.     TransparentBlt(g_hmemdc,x,y,width,height,hbitmapdc,0,0,pImage->width,pImage->height,bkColor);
    720.     DeleteDC(hbitmapdc);
    721. }
    723. void loadImage(const char *image, ACL_Image *mapbuf)
    724. {
    725.     HDC hmapdc;
    726.     IPicture *ipicture;
    727.     IStream *istream;
    728.     DWORD filesize = 0, bytes;
    729.     OLE_XSIZE_HIMETRIC width;
    730.     OLE_YSIZE_HIMETRIC height;
    731.     HANDLE file = NULL;
    732.     HGLOBAL global = NULL;
    733.     LPVOID data = NULL;
    735.     ACL_ASSERT_HWND;
    737.     file = CreateFileA(image, GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL, NULL);
    738.     if(file == INVALID_HANDLE_VALUE)
    739.         acl_error("Fail to load image, File not exist");
    740.     filesize = GetFileSize(file, NULL);
    742.     global = GlobalAlloc(GMEM_MOVEABLE, filesize);
    743.     data = GlobalLock(global);
    744.     ReadFile(file, data, filesize, &bytes, NULL);
    745.     GlobalUnlock(global);
    746.     CreateStreamOnHGlobal(global, TRUE, &istream);
    748.     OleLoadPicture(istream, filesize, TRUE, &IID_IPicture, (LPVOID*)&ipicture);
    749.     ipicture->lpVtbl->get_Width(ipicture, &width);
    750.     ipicture->lpVtbl->get_Height(ipicture, &height);
    752.     mapbuf->width = (int)(width / 26.45833333333);
    753.     mapbuf->height = (int)(height / 26.45833333333);
    755.     hmapdc = CreateCompatibleDC(GetDC(g_hWnd));
    756.     if (mapbuf->hbitmap != NULL)
    757.         DeleteObject(mapbuf->hbitmap);
    758.     mapbuf->hbitmap = CreateCompatibleBitmap(GetDC(g_hWnd), mapbuf->width, mapbuf->height);
    759.     SelectObject(hmapdc, mapbuf->hbitmap);
    761.     ipicture->lpVtbl->Render(ipicture, hmapdc, 0, 0, mapbuf->width, mapbuf->height, 0, height, width, -height, NULL);
    762.     ipicture->lpVtbl->Release(ipicture);
    763.     istream->lpVtbl->Release(istream);
    765.     DeleteDC(hmapdc);
    766.     GlobalFree(global);
    767.     CloseHandle(file);
    768. } 
    770. void freeImage(ACL_Image *mapbuf)
    771. {
    772.     if(mapbuf->hbitmap) return;
    773.     DeleteObject(mapbuf->hbitmap);
    774.     mapbuf->hbitmap = NULL;
    775. }
    777. void registerKeyboardEvent(KeyboardEventCallback callback)
    778. {
    779.     g_keyboard = callback;
    780. }
    782. void registerCharEvent(CharEventCallback callback)
    783. {
    784.     g_char = callback;
    785. }
    787. void registerMouseEvent(MouseEventCallback callback)
    788. {
    789.     g_mouse = callback;
    790. }
    792. void registerTimerEvent(TimerEventCallback callback)
    793. {
    794.     g_timer = callback;
    795. }
    797. void startTimer(int id,int timeinterval)
    798. {
    799.     SetTimer(g_hWnd, id, timeinterval, NULL);
    800. }
    802. void cancelTimer(int id)
    803. {
    804.     KillTimer(g_hWnd, id);
    805. }
    807. void loadSound(const char *fileName,ACL_Sound *pSound)
    808. {
    809.     char *cmdStr;
    810.     int len = strlen(fileName)*sizeof(char);
    811.     len +=64;
    812.     cmdStr = (char*)malloc(len);
    813.     sprintf(cmdStr,"open \"%s\" type mpegvideo alias S%d",fileName,g_soundID);
    814.     *pSound = g_soundID;
    815.     ++g_soundID;
    816.     mciSendStringA(cmdStr,NULL,0,NULL);
    817.     free(cmdStr);
    818. }
    820. void playSound(int sid,int repeat)
    821. {
    822.     char cmdStr[32];
    823.     stopSound(sid);
    824.     if(repeat)
    825.         sprintf(cmdStr,"play S%d from 0 repeat",sid);
    826.     else
    827.         sprintf(cmdStr,"play S%d from 0",sid);
    828.     mciSendStringA(cmdStr,NULL,0,NULL);
    829. }
    831. void stopSound(int sid)
    832. {
    833.     char cmdStr[32];
    834.     sprintf(cmdStr,"stop S%d",sid);
    835.     mciSendStringA(cmdStr,NULL,0,NULL);
    836. }
    838. void setCaretSize(int w,int h)
    839. {
    840.     DestroyCaret();
    841.     CreateCaret(g_hWnd,0,w,h);
    842.     SetCaretPos(g_caretX,g_caretY);
    843. }
    845. void setCaretPos(int x,int y)
    846. {
    847.     g_caretX = x;
    848.     g_caretY = y;
    849.     SetCaretPos(g_caretX,g_caretY);
    850. }
    852. void showCaret()
    853. {
    854.     ShowCaret(g_hWnd);
    855. }
    857. void hideCaret()
    858. {
    859.     HideCaret(g_hWnd);
    860. }