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

源码开发语言/平台
当前位置：首页 > 电子书籍 > VC书籍 > 查看源码
CPI_Interface.c
资源名称：VC++视频传输.rar　[点击查看]
上传用户：hxb_1234
上传日期：2010-03-30
资源大小：8328k
文件大小：28k
源码类别：

VC书籍

开发平台：

Visual C++

CPI_Interface.c：源码内容
  2. ////////////////////////////////////////////////////////////////////////////////
  6. #include "stdafx.h"
  7. #include "globals.h"
  8. #include "resource.h"
  9. #include "WindowsOS.h"
  10. #include "CPI_InterfacePart.h"
  14. ////////////////////////////////////////////////////////////////////////////////
  15. // Handy macro to tidy up the source (handles the "SetHandler_xxxx" functions)
  16. #define CPC_IMPLEMENT_SETHANDLER(handlertype)
  17. void IF_sethandler_##handlertype(CP_HINTERFACE hInterface, wp_IF_##handlertype pfnHandler) {
  18. CPs_InterfaceWindowState* pState;
  19. pState = (CPs_InterfaceWindowState*)hInterface;
  20. CP_CHECKOBJECT(pState);
  21. pState->m_hndlr_##handlertype = pfnHandler; }
  22. //
  23. ////////////////////////////////////////////////////////////////////////////////
  28. #define CPC_SIZEBORDER 0x4
  29. ////////////////////////////////////////////////////////////////////////////////
  30. //
  31. typedef struct _CPs_InterfaceWindowState
  32. {
  33.     HWND m_hWnd;
  34.     DWORD m_dwStyle;
  35.     SIZE m_szMinSize;
  37.     // Windowpos
  38.     POINT m_ptWindowPos;
  39.     SIZE m_szWindowSize;
  41.     // Window state
  42.     BOOL m_bSkipRegion;
  43.     BOOL m_bMouseLeaveEventSet;
  44.     CPs_InterfacePart* m_pFloatActiveSubpart;
  45.     CPs_InterfacePart* m_pActiveSubpart;
  47.     // Callback handlers
  48.     wp_IF_onCreate m_hndlr_onCreate;
  49.     wp_IF_onDestroy m_hndlr_onDestroy;
  50.     wp_IF_onPosChange m_hndlr_onPosChange;
  51.     wp_IF_onDraw m_hndlr_onDraw;
  52.     wp_IF_onKeyDown m_hndlr_onKeyDown;
  53.     wp_IF_onDropFiles m_hndlr_onDropFiles;
  54.     wp_IF_onFocus m_hndlr_onFocus;
  55.     wp_IF_onAppMessage m_hndlr_onAppMessage;
  56.     wp_IF_onCommandMessage m_hndlr_onCommandMessage;
  57.     wp_IF_onClose m_hndlr_onClose;
  59.     BOOL m_bMouseCaptured;
  60.     wp_IF_onMouseMessage m_hndlr_onMouseMove;
  61.     wp_IF_onMouseMessage m_hndlr_onMouseButton_LUp;
  63.     // Subparts
  64.     CPs_InterfacePart* m_pFirstSubPart;
  66. } CPs_InterfaceWindowState;
  67. //
  68. ////////////////////////////////////////////////////////////////////////////////
  71. LRESULT CALLBACK exp_InterfaceWindowProc(HWND hWnd, UINT uiMessage, WPARAM wParam, LPARAM lParam);
  72. void IF_PaintWindow(CPs_InterfaceWindowState* pState, CPs_DrawContext* pContext);
  73. ////////////////////////////////////////////////////////////////////////////////
  74. //
  75. //
  76. //
  77. CPC_IMPLEMENT_SETHANDLER(onCreate)
  78. CPC_IMPLEMENT_SETHANDLER(onDestroy)
  79. CPC_IMPLEMENT_SETHANDLER(onPosChange)
  80. CPC_IMPLEMENT_SETHANDLER(onDraw)
  81. CPC_IMPLEMENT_SETHANDLER(onKeyDown)
  82. CPC_IMPLEMENT_SETHANDLER(onDropFiles)
  83. CPC_IMPLEMENT_SETHANDLER(onFocus)
  84. CPC_IMPLEMENT_SETHANDLER(onAppMessage)
  85. CPC_IMPLEMENT_SETHANDLER(onCommandMessage)
  86. CPC_IMPLEMENT_SETHANDLER(onClose)
  87. //
  88. //
  89. //
  90. HWND IF_GetHWnd(CP_HINTERFACE hInterface)
  91. {
  92.     CPs_InterfaceWindowState* pState;
  94.     // Init
  95.     pState = (CPs_InterfaceWindowState*)hInterface;
  96.     CP_CHECKOBJECT(pState);
  98.     return pState->m_hWnd;
  99. }
  100. //
  101. //
  102. //
  103. void IF_ProcessInit()
  104. {
  105.     WNDCLASS wcPlaylist;
  106.     wcPlaylist.style = 0L;
  107.     wcPlaylist.lpfnWndProc = exp_InterfaceWindowProc;
  108.     wcPlaylist.cbClsExtra = 0;
  109.     wcPlaylist.cbWndExtra = 0;
  110.     wcPlaylist.hInstance = GetModuleHandle(NULL);
  111.     wcPlaylist.hIcon = NULL; // We will explicity set our icons (so that we have a nice small icon)
  112.     wcPlaylist.hCursor = LoadCursor(NULL, IDC_ARROW);
  113.     wcPlaylist.hbrBackground = (HBRUSH)GetStockObject(HOLLOW_BRUSH); // Prevent the system drawing white over our invaid rgn before we can paint
  114.     wcPlaylist.lpszMenuName = NULL;
  115.     wcPlaylist.lpszClassName = CLC_COOLPLAYER_INTERFACECLASSNAME;
  116.     RegisterClass(&wcPlaylist);
  117. }
  118. //
  119. //
  120. //
  121. void IF_ProcessDeInit()
  122. {
  123.     UnregisterClass(CLC_COOLPLAYER_INTERFACECLASSNAME, GetModuleHandle(NULL));
  124. }
  125. //
  126. //
  127. //
  128. CP_HINTERFACE IF_Create(const char* pcTitle, const RECT* pInitialSize, const DWORD dwStyle)
  129. {
  130.     CPs_InterfaceWindowState* pState;
  132.     pState = (CPs_InterfaceWindowState*)malloc(sizeof(*pState));
  133.     memset(pState, 0, sizeof(*pState));
  135.     return pState;
  136. }
  137. //
  138. //
  139. //
  140. void IF_OpenWindow(CP_HINTERFACE hInterface, const char* pcTitle, const RECT* pInitialSize, const DWORD dwStyle)
  141. {
  142.     CPs_InterfaceWindowState* pState;
  144.     // Init
  145.     pState = (CPs_InterfaceWindowState*)hInterface;
  146.     CP_CHECKOBJECT(pState);
  148.     // Setup base state
  149.     pState->m_dwStyle = dwStyle;
  150.     pState->m_bSkipRegion = FALSE;
  152.     // Create Windows window
  153.     CreateWindowEx(WS_EX_ACCEPTFILES,
  154.                    CLC_COOLPLAYER_INTERFACECLASSNAME,
  155.                    pcTitle,
  156.                    WS_POPUP | WS_CLIPCHILDREN | WS_SYSMENU
  157.                    | ((dwStyle & CPC_INTERFACE_STYLE_RESIZING) ? WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_THICKFRAME : 0),
  158.                    pInitialSize->left, pInitialSize->top,
  159.                    pInitialSize->right - pInitialSize->left,
  160.                    pInitialSize->bottom - pInitialSize->top,
  161.                    NULL,
  162.                    NULL,
  163.                    GetModuleHandle(NULL),
  164.                    pState);
  165. }
  166. //
  167. //
  168. //
  169. void IF_CleanupState(CPs_InterfaceWindowState* pState)
  170. {
  171.     free(pState);
  172. }
  173. //
  174. //
  175. //
  176. void IF_CloseWindow(CP_HINTERFACE hInterface)
  177. {
  178.     CPs_InterfaceWindowState* pState;
  180.     // Init
  181.     pState = (CPs_InterfaceWindowState*)hInterface;
  182.     CP_CHECKOBJECT(pState);
  184.     DestroyWindow(pState->m_hWnd);
  185. }
  186. //
  187. //
  188. //
  189. void IF_SetVisible(CP_HINTERFACE hInterface, const BOOL bVisible)
  190. {
  191.     CPs_InterfaceWindowState* pState;
  193.     // Init
  194.     pState = (CPs_InterfaceWindowState*)hInterface;
  195.     CP_CHECKOBJECT(pState);
  197.     ShowWindow(pState->m_hWnd, bVisible ? SW_SHOW : SW_HIDE);
  198. }
  199. //
  200. //
  201. //
  202. void IF_SetFloatActiveSubPart(CPs_InterfaceWindowState* pState, CPs_InterfacePart* pNewFloatActiveSubPart)
  203. {
  204.     // If this OS cannot give us mouseleave notification - do not do any float active stuff
  205.     if(!pfnTrackMouseEvent)
  206.         return;
  207.     if(pState->m_pFloatActiveSubpart == pNewFloatActiveSubPart)
  208.         return;
  210.     // Set mouseleave event
  211.     if(pState->m_bMouseLeaveEventSet == FALSE)
  212.     {
  213.         TRACKMOUSEEVENT tme;
  215.         tme.cbSize = sizeof(tme);
  216.         tme.dwFlags = TME_LEAVE;
  217.         tme.hwndTrack = pState->m_hWnd;
  218.         pState->m_bMouseLeaveEventSet = pfnTrackMouseEvent(&tme) ? TRUE : FALSE;
  219.     }
  221.     // Reset existing FA target
  222.     if(pState->m_pFloatActiveSubpart)
  223.     {
  224.         if(pState->m_pFloatActiveSubpart->onMouseOut)
  225.             pState->m_pFloatActiveSubpart->onMouseOut(pState->m_pFloatActiveSubpart);
  226.     }
  228.     // Set new FA target - do not set it if another target has buttondown
  229.     if(pState->m_pActiveSubpart == NULL
  230.             || pNewFloatActiveSubPart == NULL
  231.             || pState->m_pActiveSubpart == pNewFloatActiveSubPart)
  232.     {
  233.         pState->m_pFloatActiveSubpart = pNewFloatActiveSubPart;
  234.         if(pState->m_pFloatActiveSubpart)
  235.         {
  236.             if(pState->m_pFloatActiveSubpart->onMouseIn)
  237.                 pState->m_pFloatActiveSubpart->onMouseIn(pState->m_pFloatActiveSubpart);
  238.         }
  239.     }
  240. }
  241. //
  242. //
  243. //
  244. CPs_InterfacePart* IF_HitTestMouse(CPs_InterfaceWindowState* pState, const POINT* pptMouse)
  245. {
  246.     CPs_InterfacePart* pSubPart_Cursor;
  248.     // Walk through list drawing and adding to the valid rects list
  249.     for(pSubPart_Cursor = pState->m_pFirstSubPart; pSubPart_Cursor; pSubPart_Cursor = (CPs_InterfacePart*)pSubPart_Cursor->m_hNext)
  250.     {
  251.         if(PtInRect(&pSubPart_Cursor->m_rLocation, *pptMouse) == TRUE)
  252.         {
  253.             return pSubPart_Cursor;
  254.         }
  255.     }
  257.     return NULL;
  258. }
  259. //
  260. //
  261. //
  262. LRESULT CALLBACK exp_InterfaceWindowProc(HWND hWnd, UINT uiMessage, WPARAM wParam, LPARAM lParam)
  263. {
  264.     CPs_InterfaceWindowState* pState;
  266.     // Get the window's data object
  267.     if(uiMessage == WM_NCCREATE)
  268.     {
  269.         HMODULE hModApplication;
  270.         pState = (CPs_InterfaceWindowState*)((CREATESTRUCT*)lParam)->lpCreateParams;
  271.         pState->m_hWnd = hWnd;
  272.         SetWindowLong(hWnd, GWL_USERDATA, (LONG)pState);
  274.         // Setup icons
  275.         hModApplication = GetModuleHandle(NULL);
  276.         SendMessage(hWnd, WM_SETICON, (WPARAM)ICON_BIG, (LPARAM)LoadIcon(hModApplication, MAKEINTRESOURCE(APP_ICON)));
  277.         SendMessage(hWnd, WM_SETICON, (WPARAM)ICON_SMALL, (LPARAM)LoadIcon(hModApplication, MAKEINTRESOURCE(APP_ICON)));
  278.     }
  279.     else
  280.         pState = (CPs_InterfaceWindowState*)GetWindowLong(hWnd, GWL_USERDATA);
  282.     // We get some messages before the window gets it's WM_NCCREATE!!! (just how bad is Windows eh???)
  283.     if(!pState)
  284.         return DefWindowProc(hWnd, uiMessage, wParam, lParam);
  285.     CP_CHECKOBJECT(pState);
  287.     // Message handlers
  288.     switch(uiMessage)
  289.     {
  290.     case WM_MOUSEMOVE:
  291.         if(pState->m_bMouseCaptured)
  292.         {
  293.             if(pState->m_hndlr_onMouseMove)
  294.                 pState->m_hndlr_onMouseMove(pState, MAKEPOINTS(lParam), (SHORT)wParam);
  295.         }
  296.         else
  297.         {
  298.             CPs_InterfacePart* pHitSubPart;
  299.             POINT ptMouse;
  300.             ptMouse.x = (short)LOWORD(lParam);
  301.             ptMouse.y = (short)HIWORD(lParam);
  303.             pHitSubPart = IF_HitTestMouse(pState, &ptMouse);
  304.             IF_SetFloatActiveSubPart(pState, pHitSubPart);
  305.         }
  306.         return 0;
  308.     case WM_LBUTTONDOWN:
  309.         {
  310.             CPs_InterfacePart* pHitSubPart;
  311.             POINT ptMouse;
  312.             ptMouse.x = (short)LOWORD(lParam);
  313.             ptMouse.y = (short)HIWORD(lParam);
  315.             pHitSubPart = IF_HitTestMouse(pState, &ptMouse);
  316.             if(pHitSubPart && pHitSubPart->onMouseButton_LDown)
  317.             {
  318.                 SetCapture(pState->m_hWnd);
  319.                 pState->m_pActiveSubpart = pHitSubPart;
  320.                 pHitSubPart->onMouseButton_LDown(pHitSubPart, MAKEPOINTS(lParam));
  321.             }
  322.         }
  323.         return 0;
  325.     case WM_LBUTTONUP:
  326.         if(pState->m_bMouseCaptured)
  327.         {
  328.             if(pState->m_hndlr_onMouseButton_LUp)
  329.                 pState->m_hndlr_onMouseButton_LUp(pState, MAKEPOINTS(lParam), (SHORT)wParam);
  330.         }
  331.         else
  332.         {
  333.             if(pState->m_pActiveSubpart)
  334.             {
  335.                 ReleaseCapture();
  336.                 if(pState->m_pActiveSubpart->onMouseButton_LUp)
  337.                     pState->m_pActiveSubpart->onMouseButton_LUp(pState->m_pActiveSubpart, MAKEPOINTS(lParam));
  338.                 pState->m_pActiveSubpart = NULL;
  339.             }
  340.         }
  341.         return 0;
  343.     case WM_NCDESTROY:
  344.         IF_CleanupState(pState);
  345.         break;
  347.     case WM_CREATE:
  348.         {
  349.             const CREATESTRUCT* pCS = (const CREATESTRUCT*)lParam;
  351.             // Update size/pos cache
  352.             pState->m_ptWindowPos.x = pCS->x;
  353.             pState->m_ptWindowPos.y = pCS->y;
  354.             pState->m_szWindowSize.cx = pCS->cx;
  355.             pState->m_szWindowSize.cy = pCS->cy;
  357.             // Reposition any subitems
  358.             IF_UpdateSubPartLayout(pState);
  360.             // Callback
  361.             if(pState->m_hndlr_onCreate)
  362.             {
  363.                 RECT rInitialPos;
  365.                 rInitialPos.left = 0;
  366.                 rInitialPos.top = 0;
  367.                 rInitialPos.right = pCS->cx;
  368.                 rInitialPos.bottom = pCS->cy;
  369.                 pState->m_hndlr_onCreate(pState, &rInitialPos);
  370.             }
  372.             IF_RebuildRegion(pState);
  373.         }
  374.         return 0;
  376.     case WM_DESTROY:
  377.         if(pState->m_hndlr_onDestroy)
  378.             pState->m_hndlr_onDestroy(pState);
  379.         IF_RemoveAllSubparts(pState);
  380.         break;
  382.     case WM_NCHITTEST:
  383.         {
  384.             CPs_InterfacePart* pSubPart_Cursor;
  385.             POINT ptMouse;
  386.             ptMouse.x = (short)LOWORD(lParam) - pState->m_ptWindowPos.x;
  387.             ptMouse.y = (short)HIWORD(lParam) - pState->m_ptWindowPos.y;
  389.             // First perform hit testing on subparts
  390.             for(pSubPart_Cursor = pState->m_pFirstSubPart; pSubPart_Cursor; pSubPart_Cursor = (CPs_InterfacePart*)pSubPart_Cursor->m_hNext)
  391.             {
  392.                 if(PtInRect(&pSubPart_Cursor->m_rLocation, ptMouse) == TRUE)
  393.                     return HTCLIENT;
  394.             }
  396.             // If the window is sizable - perform hit testing on edges
  397.             if(pState->m_dwStyle & CPC_INTERFACE_STYLE_RESIZING)
  398.             {
  399.                 // Is the mouse inside the size bands
  400.                 // - top band
  401.                 if(ptMouse.y < CPC_SIZEBORDER)
  402.                 {
  403.                     // Are we in a corner
  404.                     // - left
  405.                     if(ptMouse.x < CPC_SIZEBORDER)
  406.                         return HTTOPLEFT;
  407.                     // - right
  408.                     else if(ptMouse.x > (pState->m_szWindowSize.cx - CPC_SIZEBORDER) )
  409.                         return HTTOPRIGHT;
  410.                     else
  411.                         return HTTOP;
  412.                 }
  413.                 // - bottom band
  414.                 else if(ptMouse.y > (pState->m_szWindowSize.cy - CPC_SIZEBORDER) )
  415.                 {
  416.                     // Are we in a corner
  417.                     // - left
  418.                     if(ptMouse.x < CPC_SIZEBORDER)
  419.                         return HTBOTTOMLEFT;
  420.                     // - right
  421.                     else if(ptMouse.x > (pState->m_szWindowSize.cx - CPC_SIZEBORDER) )
  422.                         return HTBOTTOMRIGHT;
  423.                     else
  424.                         return HTBOTTOM;
  425.                 }
  426.                 // - left band
  427.                 else if(ptMouse.x < CPC_SIZEBORDER)
  428.                     return HTLEFT;
  429.                 // - right band
  430.                 else if(ptMouse.x > (pState->m_szWindowSize.cx - CPC_SIZEBORDER) )
  431.                     return HTRIGHT;
  432.             }
  434.             // - return the caption so that the window is dragged
  435.             return HTCAPTION;
  436.         }
  438.     case WM_WINDOWPOSCHANGED:
  439.         {
  440.             const WINDOWPOS* pWP = (const WINDOWPOS*)lParam;
  441.             RECT rNewPos;
  442.             BOOL bSizeChanged;
  444.             rNewPos.left = pWP->x;
  445.             rNewPos.right = pWP->x + pWP->cx;
  446.             rNewPos.top = pWP->y;
  447.             rNewPos.bottom = pWP->y + pWP->cy;
  448.             bSizeChanged = (pWP->flags & SWP_NOSIZE) ? FALSE : TRUE;
  450.             pState->m_ptWindowPos.x = pWP->x;
  451.             pState->m_ptWindowPos.y = pWP->y;
  452.             pState->m_szWindowSize.cx = pWP->cx;
  453.             pState->m_szWindowSize.cy = pWP->cy;
  455.             if(bSizeChanged)
  456.             {
  457.                 IF_UpdateSubPartLayout(pState);
  458.                 IF_RebuildRegion(pState);
  459.             }
  461.             // Perform callback
  462.             if(pState->m_hndlr_onPosChange)
  463.                 pState->m_hndlr_onPosChange(pState, &rNewPos, bSizeChanged);
  464.         }
  465.         return 0;
  467.     case WM_NCCALCSIZE:
  468.         // We do not wish to have any window area lost to captions etc (also prevent the system
  469.         // from preserving our window contents during a resize
  470.         return WVR_REDRAW;
  472.     case WM_NCACTIVATE:
  473.         return TRUE;
  475.     case WM_NCPAINT:
  476.         return 0;
  478.     case WM_NCMOUSEMOVE:
  479.         IF_SetFloatActiveSubPart(pState, NULL);
  480.         return 0;
  482.     case WM_MOUSELEAVE:
  483.         IF_SetFloatActiveSubPart(pState, NULL);
  484.         pState->m_bMouseLeaveEventSet = FALSE;
  485.         return 0;
  487.     case WM_CLOSE:
  488.         if(pState->m_hndlr_onClose)
  489.         {
  490.             pState->m_hndlr_onClose(pState);
  491.             return 0;
  492.         }
  493.         break;
  495.     case WM_PAINT:
  496.         {
  497.             PAINTSTRUCT ps;
  498.             CPs_DrawContext drawcontext;
  500.             // Prepare for draw
  501.             drawcontext.m_dcDraw = BeginPaint(hWnd, &ps);
  502.             drawcontext.m_ptOffset.x = 0;
  503.             drawcontext.m_ptOffset.y = 0;
  504.             GetClipBox(drawcontext.m_dcDraw, &drawcontext.m_rClip);
  506.             IF_PaintWindow(pState, &drawcontext);
  508.             // Cleanup
  509.             EndPaint(hWnd, &ps);
  510.         }
  511.         return 0;
  513.     case WM_ACTIVATE:
  514.         if(LOWORD(wParam) == WA_ACTIVE)
  515.             SetFocus(hWnd);
  516.         return 0;
  518.     case WM_SYSKEYDOWN:
  519.     case WM_KEYDOWN:
  520.         if(pState->m_hndlr_onKeyDown)
  521.         {
  522.             const BOOL bAltIsDown = (GetAsyncKeyState(VK_MENU)  & 0x8000) ? TRUE : FALSE;
  523.             const BOOL bCtrlIsDown = (GetAsyncKeyState(VK_CONTROL)  & 0x8000) ? TRUE : FALSE;
  524.             const BOOL bShiftIsDown = (GetAsyncKeyState(VK_SHIFT)  & 0x8000) ? TRUE : FALSE;
  525.             pState->m_hndlr_onKeyDown(pState, (unsigned int)wParam, bAltIsDown, bCtrlIsDown, bShiftIsDown);
  526.         }
  527.         return 0;
  529.     case WM_DROPFILES:
  530.         if(pState->m_hndlr_onDropFiles)
  531.             pState->m_hndlr_onDropFiles(pState, (HDROP)wParam);
  532.         return 0;
  534.     case WM_GETMINMAXINFO:
  535.         {
  536.             MINMAXINFO* pMinMaxInfo = (MINMAXINFO*)lParam;
  537.             RECT rWorkArea;
  539.             if(pfnGetMonitorInfo)
  540.             {
  541.                 // Multimonitors are supported by this OS
  542.                 MONITORINFO mi;
  543.                 HMONITOR hmon = pfnMonitorFromWindow(pState->m_hWnd, MONITOR_DEFAULTTOPRIMARY);
  544.                 mi.cbSize = sizeof(mi);
  545.                 pfnGetMonitorInfo(hmon, &mi);
  547.                 // Get the work area of this monitor - as an offset from this monitors virtual space
  548.                 rWorkArea.left = mi.rcWork.left - mi.rcMonitor.left;
  549.                 rWorkArea.right = mi.rcWork.right - mi.rcMonitor.left;
  550.                 rWorkArea.top = mi.rcWork.top - mi.rcMonitor.top;
  551.                 rWorkArea.bottom = mi.rcWork.bottom - mi.rcMonitor.top;
  552.             }
  553.             else
  554.             {
  555.                 // Single monitor only OS
  556.                 SystemParametersInfo(SPI_GETWORKAREA, 0, &rWorkArea, 0);
  557.             }
  559.             pMinMaxInfo->ptMinTrackSize.x = pState->m_szMinSize.cx;
  560.             pMinMaxInfo->ptMinTrackSize.y = pState->m_szMinSize.cy;
  561.             pMinMaxInfo->ptMaxPosition.x = rWorkArea.left;
  562.             pMinMaxInfo->ptMaxPosition.y = rWorkArea.top;
  563.             pMinMaxInfo->ptMaxSize.x = rWorkArea.right-rWorkArea.left;
  564.             pMinMaxInfo->ptMaxSize.y = rWorkArea.bottom-rWorkArea.top;
  565.             pMinMaxInfo->ptMaxTrackSize.x = pMinMaxInfo->ptMaxSize.x;
  566.             pMinMaxInfo->ptMaxTrackSize.y = pMinMaxInfo->ptMaxSize.y;
  567.         }
  568.         return 0;
  570.     case WM_SETFOCUS:
  571.         if(pState->m_hndlr_onFocus)
  572.             pState->m_hndlr_onFocus(pState, TRUE);
  573.         return 0;
  575.     case WM_KILLFOCUS:
  576.         if(pState->m_hndlr_onFocus)
  577.             pState->m_hndlr_onFocus(pState, FALSE);
  578.         return 0;
  580.     case WM_COMMAND:
  581.         if(pState->m_hndlr_onCommandMessage)
  582.             pState->m_hndlr_onCommandMessage(pState, wParam, lParam);
  583.         return 0;
  584.     }
  586.     // Route message (to windows if it isn't handled)
  587.     if(uiMessage >= WM_APP && pState->m_hndlr_onAppMessage)
  588.         return pState->m_hndlr_onAppMessage(pState, uiMessage, wParam, lParam);
  590.     return DefWindowProc(hWnd, uiMessage, wParam, lParam);
  591. }
  592. //
  593. //
  594. //
  595. void IF_RebuildRegion(CP_HINTERFACE hInterface)
  596. {
  597.     CPs_InterfaceWindowState* pState;
  598.     HBITMAP bmOld;
  599.     HBITMAP bmSurface;
  600.     HDC dcDraw;
  601.     RECT rClient;
  602.     HDC dcScreen;
  603.     HRGN rgnWindow;
  605.     // Init
  606.     pState = (CPs_InterfaceWindowState*)hInterface;
  607.     CP_CHECKOBJECT(pState);
  609.     // There was no region last time - don't bother looking for one now
  610.     if(pState->m_bSkipRegion)
  611.         return;
  613.     // Create an offscreen
  614.     GetClientRect(pState->m_hWnd, &rClient);
  615.     bmSurface = CreateBitmap(rClient.right, rClient.bottom, 1, 1, NULL);
  616.     dcScreen = GetDC(pState->m_hWnd);
  617.     dcDraw = CreateCompatibleDC(dcScreen);
  618.     bmOld = (HBITMAP)SelectObject(dcDraw, bmSurface);
  619.     ReleaseDC(pState->m_hWnd, dcScreen);
  621.     // Draw the window
  622.     {
  623.         CPs_DrawContext drawcontext;
  624.         drawcontext.m_dcDraw = dcDraw;
  625.         drawcontext.m_ptOffset.x = 0;
  626.         drawcontext.m_ptOffset.y = 0;
  627.         drawcontext.m_rClip = rClient;
  628.         IF_PaintWindow(pState, &drawcontext);
  629.     }
  631.     // Cleanup
  632.     SelectObject(dcDraw, bmOld);
  633.     DeleteDC(dcDraw);
  635.     // Setup region
  636.     rgnWindow = main_bitmap_to_region_1bit(bmSurface, glb_pSkin->m_clrTransparent);
  637.     DeleteObject(bmSurface);
  638.     SetWindowRgn( pState->m_hWnd,
  639.                   rgnWindow,
  640.                   TRUE);
  642.     if(!rgnWindow)
  643.         pState->m_bSkipRegion = TRUE;
  644. }
  645. //
  646. //
  647. //
  648. void IF_PaintWindow(CPs_InterfaceWindowState* pState, CPs_DrawContext* pContext)
  649. {
  650.     // Walk through list drawing and adding to the valid rects list
  651.     CPs_InterfacePart* pSubPart_Cursor;
  652.     for(pSubPart_Cursor = pState->m_pFirstSubPart; pSubPart_Cursor; pSubPart_Cursor = (CPs_InterfacePart*)pSubPart_Cursor->m_hNext)
  653.     {
  654.         if(pSubPart_Cursor->Draw)
  655.         {
  656.             pSubPart_Cursor->Draw(pSubPart_Cursor, pContext);
  657.             ExcludeClipRect(pContext->m_dcDraw,
  658.                             pSubPart_Cursor->m_rLocation.left, pSubPart_Cursor->m_rLocation.top,
  659.                             pSubPart_Cursor->m_rLocation.right, pSubPart_Cursor->m_rLocation.bottom);
  660.         }
  661.     }
  663.     // Perform callback
  664.     if(pState->m_hndlr_onDraw)
  665.         pState->m_hndlr_onDraw(pState, pContext);
  666. }
  667. //
  668. //
  669. //
  670. void IF_SetMinSize(CP_HINTERFACE hInterface, const SIZE* pMinSize)
  671. {
  672.     CPs_InterfaceWindowState* pState;
  674.     // Init
  675.     pState = (CPs_InterfaceWindowState*)hInterface;
  676.     CP_CHECKOBJECT(pState);
  678.     pState->m_szMinSize = *pMinSize;
  679. }
  680. //
  681. //
  682. //
  683. void IF_PostAppMessage(CP_HINTERFACE hInterface, const UINT uiMessage, const WPARAM wParam, const LPARAM lParam)
  684. {
  685.     CPs_InterfaceWindowState* pState;
  687.     // Init
  688.     pState = (CPs_InterfaceWindowState*)hInterface;
  689.     CP_CHECKOBJECT(pState);
  690.     CP_ASSERT(uiMessage >= WM_APP);
  692.     PostMessage(pState->m_hWnd, uiMessage, wParam, lParam);
  693. }
  694. //
  695. //
  696. //
  697. void IF_SetMouseCapture(CP_HINTERFACE hInterface, wp_IF_onMouseMessage pfn_onMouseMove, wp_IF_onMouseMessage pfn_onMouseButton_LUp)
  698. {
  699.     CPs_InterfaceWindowState* pState;
  701.     // Init
  702.     pState = (CPs_InterfaceWindowState*)hInterface;
  703.     CP_CHECKOBJECT(pState);
  705.     pState->m_bMouseCaptured = TRUE;
  706.     pState->m_hndlr_onMouseMove = pfn_onMouseMove;
  707.     pState->m_hndlr_onMouseButton_LUp = pfn_onMouseButton_LUp;
  708.     SetCapture(pState->m_hWnd);
  709. }
  710. //
  711. //
  712. //
  713. void IF_ReleaseMouseCapture(CP_HINTERFACE hInterface)
  714. {
  715.     CPs_InterfaceWindowState* pState;
  717.     // Init
  718.     pState = (CPs_InterfaceWindowState*)hInterface;
  719.     CP_CHECKOBJECT(pState);
  721.     pState->m_bMouseCaptured = FALSE;
  722.     ReleaseCapture();
  723. }
  724. //
  725. //
  726. //
  727. void IF_RemoveAllSubparts(CP_HINTERFACE hInterface)
  728. {
  729.     CPs_InterfaceWindowState* pState;
  730.     CPs_InterfacePart* pSubPart_Cursor;
  731.     CPs_InterfacePart* pSubPart_Next;
  733.     // Init
  734.     pState = (CPs_InterfaceWindowState*)hInterface;
  735.     CP_CHECKOBJECT(pState);
  737.     // Walk through list destroying subparts
  738.     for(pSubPart_Cursor = pState->m_pFirstSubPart; pSubPart_Cursor; pSubPart_Cursor = pSubPart_Next)
  739.     {
  740.         pSubPart_Next = (CPs_InterfacePart*)pSubPart_Cursor->m_hNext;
  741.         IP_Destroy(pSubPart_Cursor);
  742.     }
  743.     pState->m_pFirstSubPart = NULL;
  744. }
  745. //
  746. //
  747. //
  748. void IF_AddSubPart_CommandButton( CP_HINTERFACE hInterface,
  749.                                   const DWORD dwAlign,
  750.                                   const POINT* pptOffset,
  751.                                   CPs_Image_WithState* pStateImage,
  752.                                   wp_Verb pfnVerb)
  753. {
  754.     CPs_InterfaceWindowState* pState;
  755.     CPs_InterfacePart* pSubPart_Next;
  757.     // Init
  758.     pState = (CPs_InterfaceWindowState*)hInterface;
  759.     CP_CHECKOBJECT(pState);
  761.     // Add new head to list
  762.     pSubPart_Next = pState->m_pFirstSubPart;
  764.     // Setup new part
  765.     pState->m_pFirstSubPart = IP_Create_CommandButton(pfnVerb, pStateImage);
  766.     pState->m_pFirstSubPart->m_hNext = pSubPart_Next;
  767.     pState->m_pFirstSubPart->m_hOwner = hInterface;
  768.     pState->m_pFirstSubPart->m_dwAlign = dwAlign;
  769.     pState->m_pFirstSubPart->m_bRectAlignMode = FALSE;
  770.     pState->m_pFirstSubPart->m_ptOffset = *pptOffset;
  771.     pState->m_pFirstSubPart->m_szSize.cx = pStateImage->m_pImage->m_szSize.cx;
  772.     pState->m_pFirstSubPart->m_szSize.cy = pStateImage->m_iStateHeight;
  773. }
  774. //
  775. //
  776. //
  777. void IF_AddSubPart_Indicator( CP_HINTERFACE hInterface,
  778.                               const char* pcName,
  779.                               const DWORD dwAlign,
  780.                               const RECT* prPosition)
  781. {
  782.     CPs_InterfaceWindowState* pState;
  783.     CPs_InterfacePart* pSubPart_Next;
  785.     // Init
  786.     pState = (CPs_InterfaceWindowState*)hInterface;
  787.     CP_CHECKOBJECT(pState);
  789.     // Add new head to list
  790.     pSubPart_Next = pState->m_pFirstSubPart;
  792.     // Setup new part
  793.     pState->m_pFirstSubPart = IP_Create_Indicator(pcName);
  794.     pState->m_pFirstSubPart->m_hNext = pSubPart_Next;
  795.     pState->m_pFirstSubPart->m_hOwner = hInterface;
  796.     pState->m_pFirstSubPart->m_dwAlign = dwAlign;
  797.     pState->m_pFirstSubPart->m_bRectAlignMode = TRUE;
  798.     pState->m_pFirstSubPart->m_rPosition = *prPosition;
  799. }
  800. //
  801. //
  802. //
  803. void IF_UpdateSubPartLayout(CP_HINTERFACE hInterface)
  804. {
  805.     CPs_InterfaceWindowState* pState;
  806.     CPs_InterfacePart* pSubPart_Cursor;
  808.     // Init
  809.     pState = (CPs_InterfaceWindowState*)hInterface;
  810.     CP_CHECKOBJECT(pState);
  812.     // Walk through list setting position
  813.     for(pSubPart_Cursor = pState->m_pFirstSubPart; pSubPart_Cursor; pSubPart_Cursor = (CPs_InterfacePart*)pSubPart_Cursor->m_hNext)
  814.     {
  815.         if(pSubPart_Cursor->m_bRectAlignMode == TRUE)
  816.         {
  817.             // Set position
  818.             // - left
  819.             if(pSubPart_Cursor->m_dwAlign & CPC_COMMANDTARGET_ALIGN_LEFT)
  820.                 pSubPart_Cursor->m_rLocation.left = pSubPart_Cursor->m_rPosition.left;
  821.             else
  822.             {
  823.                 CP_ASSERT(pSubPart_Cursor->m_dwAlign & CPC_COMMANDTARGET_ALIGN_RIGHT);
  824.                 pSubPart_Cursor->m_rLocation.left = pState->m_szWindowSize.cx - pSubPart_Cursor->m_rPosition.right - pSubPart_Cursor->m_rPosition.left;
  825.             }
  827.             // - right
  828.             if(pSubPart_Cursor->m_dwAlign & CPC_COMMANDTARGET_ALIGN_RIGHT)
  829.                 pSubPart_Cursor->m_rLocation.right = pState->m_szWindowSize.cx - pSubPart_Cursor->m_rPosition.right;
  830.             else
  831.             {
  832.                 CP_ASSERT(pSubPart_Cursor->m_dwAlign & CPC_COMMANDTARGET_ALIGN_LEFT);
  833.                 pSubPart_Cursor->m_rLocation.right = pSubPart_Cursor->m_rLocation.left + pSubPart_Cursor->m_rPosition.right;
  834.             }
  836.             // - top
  837.             if(pSubPart_Cursor->m_dwAlign & CPC_COMMANDTARGET_ALIGN_TOP)
  838.                 pSubPart_Cursor->m_rLocation.top = pSubPart_Cursor->m_rPosition.top;
  839.             else
  840.             {
  841.                 CP_ASSERT(pSubPart_Cursor->m_dwAlign & CPC_COMMANDTARGET_ALIGN_BOTTOM);
  842.                 pSubPart_Cursor->m_rLocation.top = pState->m_szWindowSize.cy - pSubPart_Cursor->m_rPosition.bottom - pSubPart_Cursor->m_rPosition.top;
  843.             }
  845.             // - bottom
  846.             if(pSubPart_Cursor->m_dwAlign & CPC_COMMANDTARGET_ALIGN_BOTTOM)
  847.                 pSubPart_Cursor->m_rLocation.bottom = pState->m_szWindowSize.cy - pSubPart_Cursor->m_rPosition.bottom;
  848.             else
  849.             {
  850.                 CP_ASSERT(pSubPart_Cursor->m_dwAlign & CPC_COMMANDTARGET_ALIGN_TOP);
  851.                 pSubPart_Cursor->m_rLocation.bottom = pSubPart_Cursor->m_rLocation.top + pSubPart_Cursor->m_rPosition.bottom;
  852.             }
  853.         }
  854.         else
  855.         {
  856.             // Set position
  857.             if(pSubPart_Cursor->m_dwAlign & CPC_COMMANDTARGET_ALIGN_LEFT)
  858.                 pSubPart_Cursor->m_rLocation.left = pSubPart_Cursor->m_ptOffset.x;
  859.             else
  860.             {
  861.                 CP_ASSERT(pSubPart_Cursor->m_dwAlign & CPC_COMMANDTARGET_ALIGN_RIGHT);
  862.                 pSubPart_Cursor->m_rLocation.left = pState->m_szWindowSize.cx - pSubPart_Cursor->m_szSize.cx - pSubPart_Cursor->m_ptOffset.x;
  863.             }
  864.             pSubPart_Cursor->m_rLocation.right = pSubPart_Cursor->m_rLocation.left + pSubPart_Cursor->m_szSize.cx;
  866.             if(pSubPart_Cursor->m_dwAlign & CPC_COMMANDTARGET_ALIGN_TOP)
  867.                 pSubPart_Cursor->m_rLocation.top = pSubPart_Cursor->m_ptOffset.y;
  868.             else
  869.             {
  870.                 CP_ASSERT(pSubPart_Cursor->m_dwAlign & CPC_COMMANDTARGET_ALIGN_BOTTOM);
  871.                 pSubPart_Cursor->m_rLocation.top = pState->m_szWindowSize.cy - pSubPart_Cursor->m_szSize.cy - pSubPart_Cursor->m_ptOffset.y;
  872.             }
  873.             pSubPart_Cursor->m_rLocation.bottom = pSubPart_Cursor->m_rLocation.top + pSubPart_Cursor->m_szSize.cy;
  874.         }
  875.     }
  876. }
  877. //
  878. //
  879. //