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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Delphi控件源码 > 查看源码
APPMAIN.C
资源名称：cbuilder.zip　[点击查看]
上传用户：needlamp
上传日期：2007-01-07
资源大小：78k
文件大小：45k
源码类别：

Delphi控件源码

开发平台：

Visual C++

APPMAIN.C：源码内容
  1. //8,3,2,20,7,6,4,5,22
  2. #include <windows.h> 
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include "lg3d.h"
  6. #include "appmain.h"
  8. HINSTANCE hInst;
  10. HWND hWndMain,hWndPrj,hWndStyle,hWndCtl,hWndInsp,hWndCode;
  11. HWND hWndPrev =NULL;
  13. HBRUSH  hBrushPat =NULL;
  15. int slipPos =180;
  17. typedef struct tag_PrjBtnInfo
  18. {
  19.   int BmpNO;
  20.   UINT ID;
  21.   int left,top;
  22. }PrjBtnInfo;
  24. PrjBtnInfo PrjBtn[PRJ_BTN_COUNT]=
  25. {
  26.   {0,IDM_OPENPRJ,5,5},
  27.   {1,IDM_SAVEPRJ,5+PRJ_BTN_WIDTH+1,5},
  28.   {2,IDM_ADDFILE,5+(PRJ_BTN_WIDTH+1)*2,5},
  29.   {3,IDM_VIEW_CODE,10+(PRJ_BTN_WIDTH+1)*3,5},
  30.   {4,IDM_VIEW_FORM,10+(PRJ_BTN_WIDTH+1)*4,5},
  31.   {5,IDM_NEWFILE,5,5+PRJ_BTN_HEIGHT+1},
  32.   {6,IDM_SAVEFILE,5+PRJ_BTN_WIDTH+1,5+PRJ_BTN_HEIGHT+1},
  33.   {7,IDM_RMVFILE,5+(PRJ_BTN_WIDTH+1)*2,5+PRJ_BTN_HEIGHT+1},
  34.   {8,IDM_VIEW_TOG,10+(PRJ_BTN_WIDTH+1)*3,5+PRJ_BTN_HEIGHT+1},
  35.   {9,IDM_NEWFRM,10+(PRJ_BTN_WIDTH+1)*4,5+PRJ_BTN_HEIGHT+1}
  36. };
  38. typedef struct tag_StyleBtnInfo
  39. {
  40.   UINT ID;
  41.   char Caption[20];
  42.   int left,right;
  43. }StyleBtnInfo;
  45. typedef StyleBtnInfo FAR *LPSTYLEBTN;
  46. void DrawStyleBtn(HDC,HWND,int, int, BOOL,LPSTYLEBTN);
  48. int PASCAL WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
  49. {
  50.     MSG msg;
  52.     if (!hPrevInstance)
  53.     if (!InitApplication(hInstance))
  54.         return (FALSE);
  56.     if (!InitInstance(hInstance, nCmdShow))
  57.         return (FALSE);
  58.     
  59.     LgDlg3D(TRUE,NULL);  //must using in c, not in cpp
  60.     
  61.     while (GetMessage(&msg,
  62.         NULL,
  63.         NULL,
  64.         NULL))
  65.     {                           
  66.       {
  67.         TranslateMessage(&msg);
  68.         DispatchMessage(&msg);
  69.       }  
  70.     }
  72.     ExitProg();
  73.     return (msg.wParam);
  74. }
  76. void ExitProg(void)
  77. {
  78.   if(hBrushPat) DeleteObject(hBrushPat);
  79.   hBrushPat = NULL;
  80.   LgDlg3D(FALSE,NULL);  //must use in c , not in cpp
  81. }
  83. BOOL InitApplication(HINSTANCE hInstance)
  84. {
  85.     WNDCLASS  wc;
  87.     wc.style = CS_DBLCLKS;
  88.     wc.lpfnWndProc = MainWndProc;
  89.     wc.cbClsExtra = 0;
  90.     wc.cbWndExtra = 0;
  91.     wc.hInstance = hInstance;
  92.     wc.hIcon = LoadIcon(hInstance, "ICON_YW");
  93.     wc.hCursor = LoadCursor(NULL, IDC_ARROW);
  94.     wc.hbrBackground = GetStockObject(LTGRAY_BRUSH);
  95.     wc.lpszMenuName =  "CBuilder";
  96.     wc.lpszClassName = "CBuilder";
  99.     return (RegisterClass(&wc));
  101. }
  103. BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
  104. {
  105.     HWND            hWnd;
  107.     hInst = hInstance;
  109.     hWnd = CreateWindow(
  110.         "CBuilder",
  111.         "CBuilder",
  112.         WS_OVERLAPPEDWINDOW,
  113.         0,0,638,MAIN_WINDOW_HEIGHT,
  114.         NULL,
  115.         NULL,
  116.         hInstance,
  117.         NULL
  118.     );
  120.     if (!hWnd)
  121.         return (FALSE);
  123.     hWndMain = hWnd;
  125.     if(!CreateMainChild(hWnd))
  126.     {
  127.       DestroyWindow(hWnd);
  128.       return FALSE;
  129.     }  
  130.                           
  131.     if(!RegLGFORM())
  132.     {
  133.       DestroyWindow(hWnd);
  134.       return FALSE;
  135.     }
  136.                           
  137.     if((hWndInsp =CreateInspWnd()) ==NULL)
  138.     {
  139.       DestroyWindow(hWnd);
  140.       return FALSE;
  141.     }
  142.     
  143.     if(!CreateRecSizeWnd())
  144.     {
  145.       ErrorMessage("CreateRecSizeWnd failed!");    
  146.       DestroyWindow(hWnd);
  147.       return FALSE;
  148.     }
  149.    
  150.     ShowWindow(hWnd, nCmdShow);
  151.     UpdateWindow(hWnd);
  152.     return (TRUE);
  154. }
  156. HWND CreateChild(HWND hWndParent,LPSTR ClassName,WNDPROC WndProc,int left,int top,int width,int height,UINT ID,int WndExtra)
  157. {
  158.     WNDCLASS  wc;
  159.     HWND hWnd;
  160.     
  161.     wc.style = CS_HREDRAW | CS_DBLCLKS;
  162.     wc.lpfnWndProc = WndProc;
  163.     wc.cbClsExtra = 0;
  164.     wc.cbWndExtra = WndExtra;
  165.     wc.hInstance = hInst;
  166.     wc.hIcon = LoadIcon(hInst, "ICON_YW");
  167.     wc.hCursor = LoadCursor(NULL, IDC_ARROW);
  168.     wc.hbrBackground = GetStockObject(LTGRAY_BRUSH);
  169.     wc.lpszMenuName =  NULL;
  170.     wc.lpszClassName = ClassName;
  173.     if(!RegisterClass(&wc)) return NULL;
  174.     
  175.     hWnd = CreateWindow( ClassName,ClassName,WS_CHILD,
  176.                          left,top,width,height,
  177.                          hWndParent,ID, hInst,  NULL
  178.                        );
  180.     if (!hWnd)
  181.       return NULL;
  182.     
  183.     ShowWindow(hWnd, SW_SHOW);
  184.     UpdateWindow(hWnd);
  185.     return hWnd;
  186. }
  188. BOOL CreateMainChild(HWND hWnd)
  189. {     
  190.   RECT rc;                                
  191.   HBITMAP hBmpPat; 
  192.   static char tmp[30];                                
  193.   int i;
  194.   
  195.    hBmpPat = LoadBitmap(hInst,"BMP_PAT");
  196.    if(hBmpPat)
  197.      hBrushPat = CreatePatternBrush(hBmpPat);
  199.    DeleteObject(hBmpPat);
  201.    GetClientRect(hWnd,&rc);
  202.    
  203.    if((hWndPrj = CreateChild(hWnd,(LPSTR)"WNDPRJ",(WNDPROC)PrjWndProc,
  204.              0,0,slipPos,rc.bottom,NULL,0)) == NULL)
  205.    {
  206.      ErrorMessage("CreateMainChild WNDPRJ failed!");
  207.      return FALSE;                                                 
  208.    }  
  209.    
  210.    if((hWndCtl = CreateChild(hWnd,(LPSTR)"WNDCTL",(WNDPROC)CtlWndProc,
  211.                 slipPos+3,0,rc.right-slipPos-3,rc.bottom-19,NULL,0)) == NULL)
  212.    {
  213.      ErrorMessage("CreateMainChild WNDCTL failed!");
  214.      return FALSE;
  215.    }
  216.    
  217.    if((hWndStyle = CreateChild(hWnd,(LPSTR)"WNDSTYLE",(WNDPROC)StyleWndProc,
  218.                      slipPos+3,rc.bottom-19,rc.right-slipPos-3,19,IDW_STYLE,
  219.                      5*sizeof(WORD))) == NULL)
  220.    {
  221.      ErrorMessage("CreateMainChild WNDSTYLE failed!");
  222.      return FALSE;                                                   
  223.    }  
  224.    
  225.    i=0;                                           
  226.    while(LoadString(hInst,IDW_STYLE+i,(LPSTR)tmp,sizeof(tmp)))
  227.    {
  228.      SendMessage(hWndStyle,WM_ADDITEM,IDW_STYLE+i,(LPARAM)(LPSTR)tmp);
  229.      i++;
  230.    }  
  231.    return TRUE;
  232. }   
  234. BOOL RegLGFORM(void)
  235. {
  236.     WNDCLASS  wc;
  237.     
  238.     wc.style = CS_HREDRAW | CS_DBLCLKS;
  239.     wc.lpfnWndProc = FormWndProc;
  240.     wc.cbClsExtra = 0;
  241.     wc.cbWndExtra = 2*sizeof(WORD);
  242.     wc.hInstance = hInst;
  243.     wc.hIcon = LoadIcon(hInst, "ICON_YW");
  244.     wc.hCursor = LoadCursor(NULL, IDC_ARROW);
  245.     wc.hbrBackground = GetStockObject(LTGRAY_BRUSH);
  246.     wc.lpszMenuName =  NULL;
  247.     wc.lpszClassName = "LGFORM";
  250.     if(!RegisterClass(&wc)) return FALSE;
  252.     wc.style =0;
  253.     wc.lpfnWndProc = RecSizeWndProc;
  254.     wc.cbClsExtra = 0;
  255.     wc.cbWndExtra = sizeof(WORD);
  256.     wc.hInstance = hInst;
  257.     wc.hIcon = NULL;
  258.     wc.hCursor = LoadCursor(NULL, IDC_ARROW);
  259.     wc.hbrBackground = GetStockObject(BLACK_BRUSH);
  260.     wc.lpszMenuName =  NULL;
  261.     wc.lpszClassName = "RECSIZE";
  262.     
  263.     return (RegisterClass(&wc));
  264. }
  266. HWND hWndRecSize[8];
  267. BOOL CreateRecSizeWnd(void)
  268. {                   
  269.   int i;
  270.   for(i=0;i<8;i++)
  271.   {
  272.     hWndRecSize[i]=CreateWindow("RECSIZE","",WS_CHILD,0,0,5,5,
  273.                       hWndMain,0,hInst,NULL);
  274.     if(hWndRecSize[i]==NULL) return FALSE;
  275.     SetWindowWord(hWndRecSize[i],0,i);                  
  276.   }                
  277.   return TRUE;
  278. }
  280. HWND CreateInspWnd(void)
  281. {
  282.     HWND hWnd;
  283.     WNDCLASS  wc;
  284.     
  285.     wc.style = CS_HREDRAW | CS_DBLCLKS;
  286.     wc.lpfnWndProc = InspWndProc;
  287.     wc.cbClsExtra = 0;
  288.     wc.cbWndExtra = sizeof(WORD);
  289.     wc.hInstance = hInst;
  290.     wc.hIcon = LoadIcon(hInst, "ICON_YW");
  291.     wc.hCursor = LoadCursor(NULL, IDC_ARROW);
  292.     wc.hbrBackground = GetStockObject(LTGRAY_BRUSH);
  293.     wc.lpszMenuName =  NULL;
  294.     wc.lpszClassName = "LGINSP";
  296.     if(!RegisterClass(&wc)) return NULL;
  297.     
  298.     hWnd =CreateWindow("LGINSP","对象流览器",
  299.                    WS_OVERLAPPED|WS_SYSMENU|WS_MINIMIZEBOX
  300.                    |WS_CLIPSIBLINGS|WS_CLIPCHILDREN|WS_THICKFRAME,
  301.                    0,120,200,280,
  302.                    NULL, NULL, hInst, NULL);
  304.     if (!hWnd)
  305.       return NULL;
  306.     
  307.     ShowWindow(hWnd, SW_SHOW);
  308.     UpdateWindow(hWnd);
  309.     SetWindowPos(hWnd,hWndMain,0,0,0,0,SWP_NOSIZE|SWP_NOMOVE);
  310.     return hWnd;
  311. }
  314. HCURSOR hCurSplit = NULL;
  315. BOOL isInSlip = FALSE;
  316. BOOL isMouseDown=FALSE; 
  317. BOOL gSlipped =FALSE;  
  318. int FormNum =0;             
  319. HFONT hStyleFont=NULL;
  320. HBITMAP hBmpStyleUp,hBmpStyleDn,hBmpStyleDs;
  321. long CALLBACK __export MainWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
  322. {     
  323.   RECT rc;
  324.   MINMAXINFO FAR *lpmmi;
  325.   POINT pt;
  326.   PAINTSTRUCT ps;
  327.   HPEN hPen;
  328.   DLGPROC lpProcAbout;
  329.   HDC hDC;
  330.   BOOL fInSlip = FALSE;      
  331.   HWND hwnd;
  332.   LOGFONT lf;
  333.   
  334.   switch (message)
  335.   {                      
  336.     case WM_CREATE:
  337.       hCurSplit = LoadCursor(hInst,"CUR_SPLIT");
  338.   
  339.       hBmpStyleUp =LoadBitmap(hInst,"BMP_STYLEUP");
  340.       hBmpStyleDn =LoadBitmap(hInst,"BMP_STYLEDN");
  341.       hBmpStyleDs =LoadBitmap(hInst,"BMP_STYLEDS"); 
  342.       
  343.       memset(&lf,0,sizeof(lf));
  344.       lf.lfHeight =         13;
  345.       lf.lfWeight =         FW_NORMAL;
  346.       lf.lfCharSet =        DEFAULT_CHARSET ;
  347.       lf.lfOutPrecision =   OUT_DEFAULT_PRECIS ;
  348.       lf.lfClipPrecision =  CLIP_DEFAULT_PRECIS ;
  349.       lf.lfQuality =        DEFAULT_QUALITY ;
  350.       lf.lfPitchAndFamily = DEFAULT_PITCH;
  351.       strcpy(lf.lfFaceName , "宋体");
  352.       hStyleFont = CreateFontIndirect( &lf ) ;   
  353.       if(hStyleFont == NULL)
  354.       {                
  355.         ErrorMessage("Create StyleFont Failed");
  356.         return -1;
  357.       }
  358.     break;
  359.     
  360.     case WM_GETMINMAXINFO:
  361.       lpmmi=(MINMAXINFO FAR *)lParam;
  362.       lpmmi->ptMaxSize.y=100;
  363.       lpmmi->ptMinTrackSize.x=500;
  364.       lpmmi->ptMinTrackSize.y=100;
  365.       lpmmi->ptMaxTrackSize.y=100;
  366.     break;
  367.                                                        
  368.     case WM_SIZE:                                      
  369.       if(wParam == SIZE_MINIMIZED) break;
  370.       GetClientRect(hWndPrj,&rc);                  
  371.       MoveWindow(hWndStyle, rc.right+3, rc.bottom-19,
  372.                       LOWORD(lParam)-rc.right-3,19,TRUE);     
  373.       MoveWindow(hWndCtl, rc.right+3,0,
  374.                    LOWORD(lParam)-rc.right-3,rc.bottom-19,TRUE);                
  375.     return 0L;
  377.     case WM_SETCURSOR:
  378.       if(isInSlip ==TRUE)
  379.         return TRUE;
  380.     break;
  381.                 
  382.     case WM_CANCELMODE:
  383.     break;  
  384.     
  385.     case WM_LBUTTONDOWN:
  386.       if(isInSlip)
  387.       {
  388.         GetClientRect(hWnd,&rc);
  389.         hDC = GetDC(hWnd);  
  390.         SetROP2(hDC,R2_NOT);
  391.         MoveTo(hDC,slipPos+1,0);
  392.         LineTo(hDC,slipPos+1,rc.bottom);
  393.         ReleaseDC(hWnd,hDC);  
  394.         SetCapture(hWnd);  
  395.         isMouseDown = TRUE;
  396.       }
  397.     return 0L;                     
  398.     
  399.     case WM_ACTIVATEAPP:                               
  400.       if(wParam) SetActiveWindow(hWnd);
  401.     break;
  402.     
  403.     case WM_MOUSEMOVE: 
  404.       if(!isMouseDown)
  405.       {
  406.         fInSlip = isInSlip;
  407.         pt = MAKEPOINT(lParam);
  408.         if(pt.x>slipPos-1 && pt.x<slipPos+3 && pt.y>0)
  409.           isInSlip = TRUE;
  410.         else
  411.           isInSlip=FALSE; 
  412.         if(fInSlip !=isInSlip)
  413.         {                                         
  414.           if(isInSlip)
  415.             SetCursor(hCurSplit);
  416.           else SetCursor(LoadCursor(NULL,IDC_ARROW));
  417.         }
  418.         return 0L;
  419.       }
  421.       if(!isInSlip) return 0L;
  423.       GetClientRect(hWnd,&rc);     
  424.       hDC=GetDC(hWnd);
  425.       SetROP2(hDC,R2_NOT);
  426.       MoveTo(hDC,slipPos+1,0);
  427.       LineTo(hDC,slipPos+1,rc.bottom);
  428.       pt=MAKEPOINT(lParam);
  429.       slipPos=pt.x;
  430.       MoveTo(hDC,slipPos+1,0);      
  431.       LineTo(hDC,slipPos+1,rc.bottom);
  432.       ReleaseDC(hWnd,hDC);
  433.     return 0L;
  434.              
  435.     case WM_LBUTTONUP: 
  436.       if(!isInSlip || !isMouseDown) break;     
  437.       isMouseDown = FALSE;              
  438.       isInSlip = FALSE;
  439.       ReleaseCapture();
  440.       GetClientRect(hWnd,&rc);     
  441.       hDC=GetDC(hWnd);
  442.       pt=MAKEPOINT(lParam);
  443.       slipPos=pt.x;
  444.       SetROP2(hDC,R2_NOT);
  445.       MoveTo(hDC,slipPos+1,0);
  446.       LineTo(hDC,slipPos+1,rc.bottom);
  447.       ReleaseDC(hWnd,hDC);               
  448.       SetCursor(LoadCursor(NULL,IDC_ARROW));  
  449.       
  450.       gSlipped =TRUE;
  451.       MoveWindow(hWndPrj, 0,0,slipPos,rc.bottom,TRUE);
  452.       MoveWindow(hWndCtl, slipPos+3,0,
  453.                    rc.right-slipPos-3,rc.bottom-19,TRUE);  
  454.       MoveWindow(hWndStyle, slipPos+3, rc.bottom-19,
  455.                       rc.right-slipPos-3,19,TRUE);     
  456.       gSlipped =FALSE;                
  457.     return 0L;
  458.              
  459.     case WM_MENUSELECT:
  460.       if(wParam ==0 && hWndPrev !=NULL) 
  461.       {
  462.         SetFocus(hWndPrev);
  463.         hWndPrev =NULL;
  464.         return 0L;
  465.       }  
  466.     break;
  467.     
  468.     case WM_COMMAND:
  469.       switch(wParam)
  470.       {                       
  471.         case IDW_STYLE:
  472.           SendMessage(hWndCtl, WM_STYLECHANGED, (WPARAM)lParam,0L);
  473.         return 0L;
  474.         
  475.         case IDM_VIEW_OBJINSP:
  476.           ShowWindow(hWndInsp,SW_SHOW); 
  477.           SetFocus(hWndInsp);
  478.         return 0L;
  479.         
  480.         case IDM_NEWFRM:
  481.           hwnd =CreateNewForm();
  482.         break;
  483.         
  484.         case IDM_EXIT:
  485.           PostMessage(hWnd,WM_CLOSE,0,0L);
  486.         break;
  487.         
  488.         case IDM_ABOUT:               
  489.           lpProcAbout = (DLGPROC)MakeProcInstance((FARPROC)About,hInst);
  490.           DialogBox(hInst, "AboutBox", hWnd, lpProcAbout);
  491.           FreeProcInstance((FARPROC)lpProcAbout);
  492.         break;
  493.         
  494.         default:
  495.         break;  
  496.       }
  497.     return 0L;      
  498.     
  499.     case WM_PAINT:
  500.       GetClientRect(hWndPrj,&rc);
  501.       
  502.       BeginPaint(hWnd,&ps);
  503.       hPen = CreatePen(PS_SOLID,1,RGB(80,80,80));  
  504.       SelectObject(ps.hdc,hPen);
  505.       MoveTo(ps.hdc,rc.right+2,0);
  506.       LineTo(ps.hdc,rc.right+2,rc.bottom);
  507.       SelectObject(ps.hdc,GetStockObject(WHITE_PEN));
  508.       DeleteObject(hPen);
  509.       MoveTo(ps.hdc,rc.right,0);
  510.       LineTo(ps.hdc,rc.right,rc.bottom);                   
  511.       EndPaint(hWnd,&ps);
  512.     break;
  513.                 
  514.     case WM_CLOSE:
  515.       if(MessageBox(NULL,"您 是 否 确 定 退 出nn"
  516.                          "    CBuilder 系 统?",
  517.                     "CBuilder",MB_ICONQUESTION|MB_TASKMODAL|MB_YESNO)
  518.          ==IDYES)                              
  519.       {
  520.         for(hwnd =FindWindow("LGFORM",NULL); 
  521.             GetWindowWord(hwnd,GWW_HINSTANCE)==hInst; 
  522.             hwnd =FindWindow("LGFORM",NULL))
  523.           DestroyWindow(hwnd);
  524.         UnregisterClass("LGFORM",hInst);    
  526.         if(hWndInsp) DestroyWindow(hWndInsp);
  527.         UnregisterClass("LGINSP",hInst);    
  529.         DestroyWindow(hWnd);
  530.       } 
  531.     return 0L;
  532.                 
  533.     case WM_DESTROY:
  534.       if(hCurSplit) DeleteObject(hCurSplit);
  535.       if(hStyleFont) DeleteObject(hStyleFont);         
  536.       if(hBmpStyleUp) DeleteObject(hBmpStyleUp);
  537.       if(hBmpStyleDn) DeleteObject(hBmpStyleDn);
  538.       if(hBmpStyleDs) DeleteObject(hBmpStyleDs);
  539.       PostQuitMessage(0);
  540.     break;
  542.     default:
  543.     break;
  544.   }
  545.   return (DefWindowProc(hWnd, message, wParam, lParam));
  546. }
  549. long CALLBACK __export PrjWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
  550. {             
  551.   HPEN hPen;
  552.   RECT rc;
  553.   POINT pt;                   
  554.   HDC hDC;
  555.   int i;
  556.   static HBITMAP hBmpPrjUp=NULL,hBmpPrjDn=NULL,hBmpPrjDs=NULL;
  557.   static int CurSelBtn=-1;
  558.   static WORD gState=0;
  559.   HBITMAP hBmp;
  560.   HDC hMemDC; 
  561.   LONG ltmp;               
  562.   WORD wState;
  563.   PAINTSTRUCT ps;
  564.   
  565.   switch(message)
  566.   {
  567.     case WM_CREATE:   
  568.       hBmpPrjUp = LoadBitmap(hInst,"BMP_PRJUP");
  569.       if(hBmpPrjUp == NULL){
  570.         ErrorMessage("error load resource BMP_PRJUP");
  571.         DestroyWindow(hWnd);        
  572.         return -1;
  573.       }                                                          
  574.       
  575.       hBmpPrjDn = LoadBitmap(hInst,"BMP_PRJDN");
  576.       if(hBmpPrjDn == NULL){
  577.         ErrorMessage("error load resource BMP_PRJDN");
  578.         DestroyWindow(hWnd);        
  579.         return -1;
  580.       }  
  582.       hBmpPrjDs = LoadBitmap(hInst,"BMP_PRJDS");
  583.       if(hBmpPrjDs == NULL){
  584.         ErrorMessage("error load resource BMP_PRJDS");
  585.         DestroyWindow(hWnd);        
  586.         return -1;
  587.       }  
  589.     break;
  590.     
  591.     case WM_DRAWBUTTON:
  592.       hBmp = NULL;
  593.       if(CurSelBtn<0)
  594.       {             
  595.         if( hBmpPrjUp == NULL) return 0L;
  596.         hMemDC = CreateCompatibleDC ((HDC)wParam) ;
  597.         SelectObject (hMemDC, hBmpPrjUp) ;
  598.         for(i=0;i<PRJ_BTN_COUNT;i++)
  599.         {
  600.           BitBlt ((HDC)wParam, PrjBtn[i].left, PrjBtn[i].top, 
  601.                     PRJ_BTN_WIDTH, PRJ_BTN_HEIGHT,
  602.                     hMemDC,1+i*(PRJ_BTN_WIDTH+1) , 1, SRCCOPY) ;
  603.         }
  604.         DeleteDC (hMemDC) ;           
  605.         return 0L;
  606.       }
  607.       else
  608.       {
  609.         if(CurSelBtn>=PRJ_BTN_COUNT) return 0L;
  610.         switch(lParam)
  611.         {                                      
  612.           case 0L:
  613.             hBmp=hBmpPrjUp;
  614.           break;
  615.           case 1L:         
  616.             hBmp=hBmpPrjDn;
  617.           break;
  618.           case 2L:         
  619.             hBmp=hBmpPrjDs;
  620.           break;
  621.         }
  622.         if(hBmp==NULL) return 0L;
  623.         hDC=GetDC(hWnd);
  624.         hMemDC = CreateCompatibleDC (hDC) ;
  625.         SelectObject (hMemDC, hBmp) ;
  626.         BitBlt (hDC, PrjBtn[CurSelBtn].left, PrjBtn[CurSelBtn].top, 
  627.                     PRJ_BTN_WIDTH, PRJ_BTN_HEIGHT,
  628.                     hMemDC,1+CurSelBtn*(PRJ_BTN_WIDTH+1) , 1, SRCCOPY) ;
  629.         DeleteDC (hMemDC) ;           
  630.         ReleaseDC(hWnd,hDC);
  631.       }
  632.     return 0;              
  633.     
  634.     case WM_SETCURSOR:
  635.       SetCursor(LoadCursor(NULL,IDC_ARROW));
  636.       isInSlip = FALSE;
  637.     return TRUE;
  638.     
  639.     case WM_LBUTTONDBLCLK:
  640.     case WM_LBUTTONDOWN:
  641.       pt=MAKEPOINT(lParam);
  642.       for(i=0;i<PRJ_BTN_COUNT;i++)
  643.       {
  644.         SetRect(&rc,PrjBtn[i].left,PrjBtn[i].top,
  645.               PrjBtn[i].left+PRJ_BTN_WIDTH,PrjBtn[i].top+PRJ_BTN_HEIGHT);
  646.         if (PtInRect(&rc, pt))
  647.           break;
  648.       }         
  649.       if(i==PRJ_BTN_COUNT) CurSelBtn=-1;
  650.       else
  651.       {          
  652.         CurSelBtn=i;
  653.         SetCapture(hWnd);
  654.         StateSet(gState,STATE_MOUSEDOWN);  
  655.         SendMessage(hWnd,WM_DRAWBUTTON,0,1L);              
  656.       }
  657.     return 0L;
  658.                                                 
  659.     case WM_MOUSEMOVE: 
  660.       if(CurSelBtn==-1) break;        
  661.       if(!StateTest(gState,STATE_MOUSEDOWN)) break;
  662.       pt=MAKEPOINT(lParam); 
  663.       SetRect(&rc,PrjBtn[CurSelBtn].left,PrjBtn[CurSelBtn].top,
  664.         PrjBtn[CurSelBtn].left+PRJ_BTN_WIDTH,PrjBtn[CurSelBtn].top+PRJ_BTN_HEIGHT);
  665.       wState=gState;
  666.       if(PtInRect(&rc,pt))
  667.         StateClear(gState, STATE_MOUSEOUT);
  668.   else
  669.     StateSet(gState, STATE_MOUSEOUT);
  670.   if (wState!=gState)
  671.   {
  672.     if(StateTest(gState,STATE_MOUSEOUT)) ltmp=0L;
  673.     else ltmp=1L;
  674.     SendMessage(hWnd,WM_DRAWBUTTON,0,ltmp);
  675.   }  
  676.     return 0L;
  677.     
  678.     case WM_LBUTTONUP:                 
  679.       if(CurSelBtn==-1) return 0L;
  680.       if(!StateTest(gState,STATE_MOUSEDOWN)) return 0L;
  681.       ReleaseCapture();
  682.       if (StateTest(gState, STATE_MOUSEDOWN))
  683.       {
  684.         StateClear(gState, STATE_MOUSEDOWN);
  685.         if(!StateTest(gState,STATE_MOUSEOUT))
  686.         {
  687.           SendMessage(hWnd,WM_DRAWBUTTON,0,0L);
  688.           SendMessage(hWndMain,WM_COMMAND,PrjBtn[CurSelBtn].ID,0L);
  689.         }   
  690.         else StateClear(gState,STATE_MOUSEOUT);
  691.       }                          
  692.       CurSelBtn=-1;                
  693.     return 0L;
  694.     
  695.     case WM_PAINT:       
  696.       BeginPaint(hWnd,&ps); 
  697.       SelectObject(ps.hdc,GetStockObject(NULL_BRUSH));     
  698.       hPen=CreatePen(PS_SOLID,1,RGB(80,80,80));
  699.       SelectObject(ps.hdc,hPen);
  700.       GetClientRect(hWnd,&rc);
  701.       Rectangle(ps.hdc,0,0,rc.right,rc.bottom);
  702.       SelectObject(ps.hdc,GetStockObject(WHITE_PEN));
  703.       DeleteObject(hPen);
  704.       MoveTo(ps.hdc,0,rc.bottom-1);
  705.       LineTo(ps.hdc,0,0);
  706.       LineTo(ps.hdc,rc.right-1,0);                          
  707.       SelectObject(ps.hdc,GetStockObject(BLACK_PEN));
  708.       for(i=0;i<PRJ_BTN_COUNT;i++)
  709.         Rectangle(ps.hdc,PrjBtn[i].left-1,PrjBtn[i].top-1,
  710.                 PrjBtn[i].left+PRJ_BTN_WIDTH+1,PrjBtn[i].top+PRJ_BTN_HEIGHT+1);
  711.       SendMessage(hWnd,WM_DRAWBUTTON,(WPARAM)(HDC)ps.hdc,0L);          
  712.       EndPaint(hWnd,&ps);
  713.     break; 
  714.     
  715.     case WM_DESTROY:
  716.       if(hBmpPrjUp) DeleteObject(hBmpPrjUp);
  717.       if(hBmpPrjDn) DeleteObject(hBmpPrjDn);
  718.       if(hBmpPrjDs) DeleteObject(hBmpPrjDs);
  719.     break;
  720.     
  721.     default:
  722.     break;
  723.   }
  724.   return (DefWindowProc(hWnd, message, wParam, lParam));
  725. }
  727. long CALLBACK __export StyleWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
  728. {                             
  729.   RECT rc;
  730.   HDC hDC,hMemDC;                                                   
  731.   int i;                        
  732.   HPEN hPen;
  733.   DWORD dwExtent;
  734.   POINT pt;
  735.   PAINTSTRUCT ps;           
  736.   int gMouseStart=0L;
  737.   BOOL isStyleMouseDown=FALSE,isStyleMouseOut=FALSE,isLeft =FALSE;
  738.   BOOL fStyleMouseOut =FALSE;                           
  739.   BITMAP bmp;
  740.   int StyleBtnCount =0;
  741.   int CurSelStyle =1000;
  742.   static int OldSelStyle =0;
  743.   int CurBtnStart =0,CurBtnEnd =0;
  744.   HLOCAL hStyleBtns;
  745.   LPSTYLEBTN lpStyleBtns;
  746.   
  747.   switch(message)
  748.   {               
  749.     case WM_CREATE:    
  750.       if(hBrushPat)              
  751.         SetClassWord(hWnd,GCW_HBRBACKGROUND,(WORD)(HBRUSH)hBrushPat);
  752.       SetWindowWord(hWnd,STYLE_COUNT, 0);
  753.       SetWindowWord(hWnd,STYLE_START, 0);
  754.       SetWindowWord(hWnd,STYLE_END,   0);
  755.       SetWindowWord(hWnd,STYLE_SELECT,0);
  756.       SetWindowWord(hWnd,MOUSE_STATE, 0);
  757.       hStyleBtns =LocalAlloc(sizeof(StyleBtnInfo),LMEM_MOVEABLE);
  758.       SetProp(hWnd,"StyleBtns",hStyleBtns);
  759.     break;
  760.     
  761.     case WM_ADDITEM:        
  762.       i=(int)GetWindowWord(hWnd,STYLE_COUNT);  
  763.       hStyleBtns =GetProp(hWnd,"StyleBtns");
  764.       hStyleBtns =LocalReAlloc(hStyleBtns,(i+1)*sizeof(StyleBtnInfo),LMEM_MOVEABLE);
  765.       SetProp(hWnd,"StyleBtns",hStyleBtns);
  766.       lpStyleBtns =(LPSTYLEBTN)LocalLock(hStyleBtns);
  767.       lpStyleBtns[i].ID =wParam;
  768.       lstrcpy(lpStyleBtns[i].Caption,(LPSTR)lParam);
  769.       hDC =GetDC(hWnd);
  770.       SelectObject(hDC, hStyleFont);
  771.       dwExtent =GetTextExtent(hDC,lpStyleBtns[i].Caption,strlen(lpStyleBtns[i].Caption));    
  772.       ReleaseDC(hWnd,hDC);
  773.       if(i==0)
  774.         lpStyleBtns[i].left = 10;
  775.       else
  776.         lpStyleBtns[i].left = lpStyleBtns[i-1].right+5;
  777.       lpStyleBtns[i].right = lpStyleBtns[i].left+LOWORD(dwExtent)+2;
  778.       SetProp(hWnd,"StyleBtns",hStyleBtns);
  779.       SetWindowWord(hWnd,STYLE_COUNT,i+1);
  780.       
  781.       GetClientRect(hWnd,&rc);
  782.       CurBtnEnd =GetWindowWord(hWnd, STYLE_END);
  783.       if(lpStyleBtns[i].right+20 < rc.right) 
  784.       {
  785.         SetWindowWord(hWnd, STYLE_END, i); //CurBtnEnd
  786.         InvalidateRect(hWnd,NULL,TRUE);
  787.       }
  788.       LocalUnlock(hStyleBtns);
  789.     return 0L;
  790.              
  791.     case WM_SIZE:                             
  792.       StyleBtnCount =GetWindowWord(hWnd,STYLE_COUNT);
  793.       CurBtnStart =GetWindowWord(hWnd,STYLE_START);
  794.       CurBtnEnd =GetWindowWord(hWnd,STYLE_END);
  795.       hStyleBtns =GetProp(hWnd,"StyleBtns");
  796.       lpStyleBtns =(LPSTYLEBTN)LocalLock(hStyleBtns);
  797.       for(i=CurBtnStart;i<StyleBtnCount;i++)
  798.       {
  799.         if(lpStyleBtns[i].right+20 >=(int)LOWORD(lParam))
  800.         {
  801.           //CurBtnEnd = i-1; 
  802.           SetWindowWord(hWnd, STYLE_END, i-1);
  803.           break;
  804.         }
  805.       }                        
  806.       if(i == StyleBtnCount) SetWindowWord(hWnd, STYLE_END, i-1);
  807.       InvalidateRect(hWnd,NULL,TRUE);               
  808.       LocalUnlock(hStyleBtns);
  809.     return 0L;
  810.     
  811.     case WM_DRAWBUTTON:
  812.       StyleBtnCount =GetWindowWord(hWnd,STYLE_COUNT);
  813.       CurBtnStart =GetWindowWord(hWnd,STYLE_START);
  814.       CurBtnEnd =GetWindowWord(hWnd,STYLE_END);
  815.       CurSelStyle =GetWindowWord(hWnd,STYLE_SELECT);  
  816.       hStyleBtns =GetProp(hWnd,"StyleBtns");
  817.       lpStyleBtns =(LPSTYLEBTN)LocalLock(hStyleBtns);
  818.       if(wParam!=0 && lParam!=0L)
  819.       {             
  820.         SetTextColor((HDC)wParam,RGB(0,0,0));
  821.         SetBkMode((HDC)wParam,TRANSPARENT);      
  822.         SelectObject((HDC)wParam,hStyleFont);      
  823.         SelectObject((HDC)wParam,GetStockObject(WHITE_BRUSH));
  824.         SelectObject((HDC)wParam,GetStockObject(BLACK_PEN));
  825.         for(i=CurBtnEnd;i>=CurBtnStart;i--)
  826.         {                        
  827.           if(i == CurSelStyle) DrawStyleBtn((HDC)wParam,hWnd,i,1,FALSE,lpStyleBtns);
  828.           else DrawStyleBtn((HDC)wParam,hWnd,i,0,FALSE,lpStyleBtns);
  829.         }
  830.         if(CurBtnStart>0 || CurBtnEnd <StyleBtnCount-1)
  831.         {
  832.           hMemDC=CreateCompatibleDC((HDC)wParam);              
  833.           GetObject(hBmpStyleUp,sizeof(bmp),(LPSTR)&bmp);
  834.           if(CurBtnStart>0)
  835.             SelectObject(hMemDC, hBmpStyleUp);
  836.           else SelectObject(hMemDC,hBmpStyleDs);
  837.           BitBlt((HDC)wParam,(int)lParam-bmp.bmWidth-1,4,bmp.bmWidth/2+1,
  838.                      bmp.bmHeight,hMemDC,0,0,SRCCOPY);
  839.           if(CurBtnEnd <StyleBtnCount-1)
  840.             SelectObject(hMemDC, hBmpStyleUp);
  841.           else SelectObject(hMemDC,hBmpStyleDs);
  842.           BitBlt((HDC)wParam,(int)lParam-bmp.bmWidth/2-1,4,bmp.bmWidth/2,
  843.                      bmp.bmHeight,hMemDC,bmp.bmWidth/2+1,0,SRCCOPY);   
  844.           DeleteDC(hMemDC);           
  845.         }
  846.       }
  847.       else if(wParam ==0)
  848.       {
  849.         if(lParam >0L)
  850.         {            
  851.           switch(lParam)                  
  852.           {
  853.             case 1L: //left up
  854.             break;
  855.             case 2L: //left dn
  856.             break;
  857.             case 3L: //left ds
  858.             break;
  859.             case 4L: //right up
  860.             break;
  861.             case 5L: //right dn
  862.             break;
  863.             case 6L: //right ds
  864.             break;
  865.             default:                                 
  866.               LocalUnlock(hStyleBtns);
  867.             return 0L;
  868.           }
  869.         }
  870.         else if(CurSelStyle >=CurBtnStart && CurSelStyle <=CurBtnEnd)
  871.         {
  872.           if(CurSelStyle == OldSelStyle) return 0L;
  873.           hDC = GetDC(hWnd);
  874.           SelectObject(hDC,GetStockObject(WHITE_BRUSH));
  875.           SelectObject(hDC,GetStockObject(BLACK_PEN));
  876.           SetBkMode(hDC,TRANSPARENT);
  877.           SelectObject(hDC,hStyleFont);
  878.           DrawStyleBtn(hDC, hWnd, OldSelStyle,0,TRUE,lpStyleBtns);
  879.           if(CurSelStyle != OldSelStyle-1)
  880.             DrawStyleBtn(hDC, hWnd,OldSelStyle-1,2,FALSE,lpStyleBtns);
  881.           DrawStyleBtn(hDC, hWnd, CurSelStyle,1,FALSE,lpStyleBtns); 
  882.           ReleaseDC(hWnd,hDC);
  883.         }                             
  884.         LocalUnlock(hStyleBtns);
  885.       } 
  886.     return 0;              
  887.     
  888.     case WM_LBUTTONDBLCLK:
  889.     case WM_LBUTTONDOWN:        
  890.       CurBtnStart =GetWindowWord(hWnd, STYLE_START);
  891.       CurBtnEnd =GetWindowWord(hWnd, STYLE_END);
  892.       OldSelStyle =GetWindowWord(hWnd, STYLE_SELECT);
  893.       hStyleBtns =GetProp(hWnd, "StyleBtns");
  894.       lpStyleBtns =(LPSTYLEBTN)LocalLock(hStyleBtns);
  895.       pt=MAKEPOINT(lParam);
  896.       for(i=CurBtnStart;i<=CurBtnEnd;i++)
  897.       {
  898.         SetRect(&rc,lpStyleBtns[i].left,0,
  899.               lpStyleBtns[i].right+5,STYLE_BTN_HEIGHT);
  900.         if (PtInRect(&rc, pt))
  901.           break;
  902.       }         
  903.       LocalUnlock(hStyleBtns);
  904.       if(i == CurBtnEnd+1) SetWindowWord(hWnd,STYLE_SELECT,1000);
  905.       else
  906.       {          
  907.         SetWindowWord(hWnd,STYLE_SELECT ,i);
  908.         SendMessage(hWnd,WM_DRAWBUTTON,0,0L);              
  909.         SendMessage(GetParent(hWnd),WM_COMMAND,IDW_STYLE,(LONG)i);
  910.       }
  911.     return 0L;       
  912.     
  913.     case WM_SETCURSOR:
  914.       SetCursor(LoadCursor(NULL,IDC_ARROW));
  915.       isInSlip = FALSE;
  916.     return TRUE;
  917.                                                 
  918.     case WM_PAINT:       
  919.       GetClientRect(hWnd,&rc);
  920.       BeginPaint(hWnd,&ps);   
  921.       SelectObject(ps.hdc,hStyleFont);
  922.       hPen = CreatePen(PS_SOLID,1,RGB(80,80,80));
  923.       SelectObject(ps.hdc,hPen);
  924.       MoveTo(ps.hdc,0,0);         
  925.       LineTo(ps.hdc,rc.right,0);
  926.       SelectObject(ps.hdc,GetStockObject(BLACK_PEN));
  927.       DeleteObject(hPen);
  928.       MoveTo(ps.hdc,0,1);
  929.       LineTo(ps.hdc,rc.right,1);      
  930.       SendMessage(hWnd,WM_DRAWBUTTON,(WPARAM)(HDC)ps.hdc,(LONG)rc.right);
  931.       EndPaint(hWnd,&ps);
  932.     return 0L;
  933.                        
  934.     case WM_DESTROY:                       
  935.       hStyleBtns =GetProp(hWnd,"StyleBtns");
  936.       LocalFree(hStyleBtns);
  937.       RemoveProp(hWnd,"StyleBtns");
  938.     break;
  939.                        
  940.     default:
  941.     break;
  942.   }
  943.   return (DefWindowProc(hWnd, message, wParam, lParam));
  944. }
  946. /*
  947. long CALLBACK __export CtlWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
  948. {             
  949.   RECT rc;        
  950.   static int CurSelCtl =-1;
  951.   static int CurStyle =0;
  952.   PAINTSTRUCT ps;           
  953.   HPEN hPen;  
  954.   HBITMAP hBmp;
  955.   static HBITMAP hBmpUpCtl[STYLE_MAX_COUNT],hBmpDnCtl[STYLE_MAX_COUNT],hBmpDsCtl[STYLE_MAX_COUNT];
  956.   static HBITMAP hBmpUpLeft,hBmpDnLeft,hBmpDsLeft,
  957.                  hBmpUpRight,hBmpDnRight,hBmpDsRight,
  958.                  hBmpArrow;  
  959.   static int CurCtlStart[STYLE_MAX_COUNT],CurCtlEnd[STYLE_MAX_COUNT],CurCtlCount[STYLE_MAX_COUNT];
  960.   static int ctlWidth =0;
  961.   static int ctlXStart =0;
  962.   static BOOL isCtlMouseDown =0,isCtlMouseOut =FALSE,isLeft =0; 
  963.   static BOOL fCtlMouseOut =0;
  964.   int xStart =0;
  965.   HDC hMemDC,hDC;                       
  966.   POINT pt;                                            
  967.   BITMAP bmp;                
  968.   int i,j;
  969.   char stmp[100];
  970.   
  971.   switch(message)            
  972.   {                          
  973.     case WM_CREATE:
  974.       hBmpUpLeft = LoadBitmap(hInst,"BMP_UPLEFT");
  975.       hBmpDnLeft = LoadBitmap(hInst,"BMP_DNLEFT");
  976.       hBmpDsLeft = LoadBitmap(hInst,"BMP_DSLEFT");
  977.       hBmpUpRight = LoadBitmap(hInst,"BMP_UPRIGHT");
  978.       hBmpDnRight = LoadBitmap(hInst,"BMP_DNRIGHT");
  979.       hBmpDsRight = LoadBitmap(hInst,"BMP_DSRIGHT");
  980.       hBmpArrow = LoadBitmap(hInst,"BMP_ARROW");                   
  981.       if(!hBmpUpLeft || !hBmpUpRight || !hBmpArrow
  982.          || !hBmpDnLeft || !hBmpDsLeft || !hBmpDnRight || !hBmpDsRight)
  983.       {
  984.         ErrorMessage("Error Load Ctl Bitmap");
  985.         return -1;    
  986.       }  
  987.       
  988.       //// /////
  989.       for(i=0;i<2;i++)
  990.       {        
  991.         wsprintf(stmp,"BMP_UPSTYLE%d",i);
  992.         hBmpUpCtl[i] = LoadBitmap(hInst, stmp); 
  993.         wsprintf(stmp,"BMP_DNSTYLE%d",i);
  994.         hBmpDnCtl[i] = LoadBitmap(hInst, stmp); 
  995.         if(!hBmpUpCtl[i] || !hBmpDnCtl[i])
  996.         {
  997.           ErrorMessage("Error Load Ctl Bitmap");
  998.           return -1;    
  999.         }  
  1000.       }
  1001.       xStart =0;
  1002.       GetObject(hBmpArrow,sizeof(bmp),(LPSTR)&bmp);
  1003.       ctlWidth = bmp.bmHeight-1;
  1004.       xStart = bmp.bmWidth+5;                       
  1005.       GetObject(hBmpUpLeft,sizeof(bmp),(LPSTR)&bmp);
  1006.       xStart += bmp.bmWidth*2+10;
  1007.       ctlXStart =xStart-bmp.bmWidth;
  1008.       GetClientRect(hWnd,&rc);
  1009.       for(i=0;i<2;i++)
  1010.       {
  1011.         GetObject(hBmpUpCtl[i],sizeof(bmp),(LPSTR)&bmp);
  1012.         CurCtlStart[i] =0;
  1013.         CurCtlCount[i] =bmp.bmWidth/(bmp.bmHeight-1);
  1014.         CurCtlEnd[i] =(rc.right-xStart-3)/(bmp.bmHeight-1);  
  1015.         if(CurCtlEnd[i]>CurCtlCount[i]) CurCtlEnd[i] =CurCtlCount[i];
  1016.       }
  1017.     break;
  1018.     
  1019.     case WM_SIZE: 
  1020.       xStart =0;
  1021.       GetObject(hBmpArrow,sizeof(bmp),(LPSTR)&bmp);
  1022.       xStart = bmp.bmWidth+5;
  1023.       GetObject(hBmpUpLeft,sizeof(bmp),(LPSTR)&bmp);
  1024.       xStart += bmp.bmWidth*2+10;
  1025.       for(i=0;i<2;i++)
  1026.       {
  1027.         GetObject(hBmpUpCtl[i],sizeof(bmp),(LPSTR)&bmp);
  1028.         if(gSlipped)
  1029.         {
  1030.           if(i==CurStyle)
  1031.             j =CurCtlStart[i]; 
  1032.           CurCtlStart[i] =CurCtlEnd[i]-(LOWORD(lParam)-xStart-3)/(bmp.bmHeight-1);
  1033.           if(CurCtlStart[i]<0) CurCtlStart[i] =0;
  1034.           if(xStart+3+(CurCtlEnd[i]-CurCtlStart[i])*ctlWidth<(int)LOWORD(lParam))
  1035.           {
  1036.             CurCtlEnd[i] +=(LOWORD(lParam)
  1037.                   -(xStart+3+(CurCtlEnd[i]-CurCtlStart[i])*ctlWidth))/ctlWidth;
  1039.             if(CurCtlEnd[i]>CurCtlCount[i]) CurCtlEnd[i] =CurCtlCount[i];
  1040.           }
  1041.           if(i==CurStyle)
  1042.           {
  1043.             j =CurCtlStart[i]-j;
  1044.             if(CurSelCtl >=0)
  1045.               CurSelCtl -=j;
  1046.           }    
  1047.         }
  1048.         else
  1049.         {
  1050.           if(xStart+3+(CurCtlEnd[i]-CurCtlStart[i])*ctlWidth<(int)LOWORD(lParam))
  1051.           {
  1052.             if(i==CurStyle)
  1053.               j =CurCtlStart[i]; 
  1054.             CurCtlStart[i] -=(LOWORD(lParam)
  1055.                   -(xStart+3+(CurCtlEnd[i]-CurCtlStart[i])*ctlWidth))/ctlWidth;
  1057.             if(CurCtlStart[i]<0) CurCtlStart[i] =0;
  1058.             if(i==CurStyle)
  1059.             {
  1060.               j =CurCtlStart[i]-j;
  1061.               if(CurSelCtl >=0)
  1062.                 CurSelCtl -=j;
  1063.             }    
  1064.           }
  1065.           CurCtlEnd[i] =(LOWORD(lParam)-xStart-3)/(bmp.bmHeight-1)+CurCtlStart[i];
  1066.           if(CurCtlEnd[i]>CurCtlCount[i]) CurCtlEnd[i]=CurCtlCount[i];
  1067.         }  
  1068.       }
  1069.       InvalidateRect(hWnd,NULL,TRUE);
  1070.     return 0L;
  1071.     
  1072.     case WM_STYLECHANGED:
  1073.       if(CurStyle ==(int)wParam) break;
  1074.       CurSelCtl =-1;
  1075.       CurStyle =(int)wParam;
  1076.       //if(CurStyle>1) return 0L;                          
  1077.       InvalidateRect(hWnd,NULL,TRUE);
  1078.     return 0L;
  1079.     
  1080.     case WM_DRAWBUTTON:
  1081.       if(wParam!=0)
  1082.       {
  1083.         //draw all the button: CurStyle -- BtnStart to BtnEnd
  1084.         hDC = (HDC)wParam;
  1085.         hMemDC = CreateCompatibleDC (hDC) ;   
  1086.         xStart =0;
  1087.         //if(hBmpArrow)
  1088.         {
  1089.           SelectObject(hMemDC,hBmpArrow);
  1090.           GetObject(hBmpArrow,sizeof(bmp),(LPSTR)&bmp);
  1091.           xStart =5;
  1092.           BitBlt (hDC, xStart,5,
  1093.                   bmp.bmWidth,bmp.bmHeight,hMemDC,0,0,SRCCOPY) ;
  1094.           xStart =xStart+bmp.bmWidth+10;        
  1095.         } 
  1096.         //if(hBmpCtlLeft)
  1097.         {
  1098.           if(CurCtlStart[CurStyle]>0)
  1099.             SelectObject(hMemDC,hBmpUpLeft);
  1100.           else SelectObject(hMemDC,hBmpDsLeft);  
  1101.           GetObject(hBmpUpLeft,sizeof(bmp),(LPSTR)&bmp);
  1102.           BitBlt (hDC, xStart,5,
  1103.                   bmp.bmWidth,bmp.bmHeight,hMemDC,0,0,SRCCOPY) ;
  1104.           xStart +=bmp.bmWidth;
  1105.         }
  1106.         //if(hBmpCtl[CurStyle])
  1107.         {         
  1108.           SelectObject (hMemDC, hBmpUpCtl[CurStyle]) ;    
  1109.           GetObject(hBmpUpCtl[CurStyle],sizeof(bmp),(LPSTR)&bmp);
  1110.           BitBlt (hDC, xStart,5,
  1111.                   (CurCtlEnd[CurStyle]-CurCtlStart[CurStyle])*(bmp.bmHeight-1),
  1112.                   bmp.bmHeight,hMemDC,
  1113.                   CurCtlStart[CurStyle]*(bmp.bmHeight-1),0,SRCCOPY) ;
  1114.           if(CurSelCtl>=0
  1115.              && CurSelCtl<CurCtlEnd[CurStyle]-CurCtlStart[CurStyle])
  1116.           {
  1117.             SelectObject(hMemDC,hBmpDnCtl[CurStyle]);
  1118.             BitBlt (hDC, ctlXStart+CurSelCtl*ctlWidth,5,
  1119.                   ctlWidth,ctlWidth+1,hMemDC,
  1120.                   (CurSelCtl+CurCtlStart[CurStyle])*ctlWidth,0,SRCCOPY) ;
  1121.           }            
  1122.           else CurSelCtl =-1;
  1123.           xStart += (CurCtlEnd[CurStyle]-CurCtlStart[CurStyle])*(bmp.bmHeight-1);
  1124.         }
  1125.         //if(hBmpCtlRight)
  1126.         {                                      
  1127.           if(CurCtlEnd[CurStyle]<CurCtlCount[CurStyle])
  1128.             SelectObject(hMemDC,hBmpUpRight);
  1129.           else SelectObject(hMemDC,hBmpDsRight);  
  1130.           GetObject(hBmpUpRight,sizeof(bmp),(LPSTR)&bmp);
  1131.           BitBlt (hDC, xStart,5,
  1132.                   bmp.bmWidth,bmp.bmHeight,hMemDC,0,0,SRCCOPY) ;
  1133.         }                       
  1134.         DeleteDC (hMemDC) ;           
  1135.       }                      
  1136.       else if(wParam ==0)
  1137.       {          
  1138.         if(CurSelCtl <0
  1139.            || CurSelCtl >=(CurCtlEnd[CurStyle]-CurCtlStart[CurStyle]))
  1140.         {
  1141.           CurSelCtl =-1;
  1142.           return 0L;    
  1143.         }  
  1144.         switch(lParam)
  1145.         {
  1146.           case 0L://hbmp=up
  1147.             hBmp =hBmpUpCtl[CurStyle];
  1148.           break;
  1149.           case 1L://hbmp=down  
  1150.             hBmp =hBmpDnCtl[CurStyle];
  1151.           break;
  1152.           case 2L: //hbmp=disable
  1153.           break;
  1154.           case 3L: //left up
  1155.           break;
  1156.           case 4L: //left down
  1157.           break;
  1158.           case 5L: //left disable
  1159.           break;
  1160.           case 6L: //right up
  1161.           break;
  1162.           case 7L: //right down
  1163.           break;
  1164.           case 8L: //right disable
  1165.           break;
  1166.           default:
  1167.           return 0L;
  1168.         }                               
  1169.         //draw the button           
  1170.         hDC=GetDC(hWnd);
  1171.         hMemDC =CreateCompatibleDC(hDC);
  1172.         SelectObject(hMemDC,hBmp);
  1173.         if(lParam <3L)
  1174.           BitBlt (hDC, ctlXStart+CurSelCtl*ctlWidth,5,
  1175.                   ctlWidth,ctlWidth+1,hMemDC,
  1176.                   (CurSelCtl+CurCtlStart[CurStyle])*ctlWidth,0,SRCCOPY) ;
  1177.         DeleteDC(hMemDC);
  1178.         ReleaseDC(hWnd,hDC);
  1179.       }
  1180.     return 0L;           
  1181.     
  1182.     case WM_SETCURSOR:
  1183.       //Set Cursor or Show Hint if in a button or Hide Hint if out a button;
  1184.       SetCursor(LoadCursor(NULL,IDC_ARROW)); 
  1185.       isInSlip = FALSE;
  1186.     return TRUE;                                    
  1187.     
  1188.     case WM_LBUTTONDOWN:
  1189.       pt=MAKEPOINT(lParam);                     
  1190.       if(CurCtlStart[CurStyle]>0)
  1191.       {
  1192.         SetRect(&rc,ctlXStart-ctlWidth/2,5,ctlXStart,5+ctlWidth+1);
  1193.         if(PtInRect(&rc,pt))
  1194.         {                                      
  1195.           isLeft =TRUE;
  1196.           SendMessage(hWnd,WM_DRAWBUTTON,0,4L);
  1197.           SetCapture(hWnd);
  1198.           isCtlMouseDown =TRUE;
  1199.           return 0L;
  1200.         }
  1201.       }  
  1202.       if(CurCtlEnd[CurStyle]<CurCtlCount[CurStyle])
  1203.       {
  1204.         SetRect(&rc,ctlXStart+(CurCtlEnd[CurStyle]-CurCtlStart[CurStyle])*ctlWidth,5,
  1205.                     ctlXStart+(CurCtlEnd[CurStyle]-CurCtlStart[CurStyle])*ctlWidth+ctlWidth/2,
  1206.                     5+ctlWidth+1);
  1207.         if(PtInRect(&rc,pt))
  1208.         {                                      
  1209.           isLeft =FALSE;
  1210.           SendMessage(hWnd,WM_DRAWBUTTON,0,7L);
  1211.           SetCapture(hWnd);
  1212.           isCtlMouseDown =TRUE;
  1213.           return 0L;
  1214.         }
  1215.       }  
  1216.       for(i=0;i<CurCtlEnd[CurStyle]-CurCtlStart[CurStyle];i++)
  1217.       {
  1218.         SetRect(&rc,ctlXStart+i*ctlWidth,5,
  1219.               ctlXStart+(i+1)*ctlWidth,5+ctlWidth+1);
  1220.         if (PtInRect(&rc, pt))
  1221.           break;
  1222.       }         
  1223.       if(i+CurCtlStart[CurStyle] ==CurCtlEnd[CurStyle]) return 0L;
  1224.       else
  1225.       {          
  1226.         SendMessage(hWnd,WM_DRAWBUTTON,0,0L);
  1227.         CurSelCtl=i;//+CurCtlStart[CurStyle];
  1228.         SendMessage(hWnd,WM_DRAWBUTTON,0,1L);              
  1229.         //LoadString(hInst, 11000+CurStyle*100+i,(LPSTR)Cur_Ctl_Style, sizeof(Cur_Ctl_Style));
  1230.       }
  1231.     return 0L;
  1232.     
  1233.     case WM_MOUSEMOVE:   
  1234.       if(!isCtlMouseDown) break;
  1235.       pt=MAKEPOINT(lParam);                     
  1236.       if(isLeft)
  1237.         SetRect(&rc,ctlXStart-ctlWidth/2,5,ctlXStart,5+ctlWidth/2+1);
  1238.       else
  1239.         SetRect(&rc,ctlXStart+(CurCtlEnd[CurStyle]-CurCtlStart[CurStyle])*ctlWidth,5,
  1240.                     ctlXStart+(CurCtlEnd[CurStyle]-CurCtlStart[CurStyle])*ctlWidth+ctlWidth/2,
  1241.                     5+ctlWidth+1);
  1242.       fCtlMouseOut = isCtlMouseOut;
  1243.       if(PtInRect(&rc,pt))
  1244.         isCtlMouseOut =FALSE;
  1245.       else isCtlMouseOut =TRUE;
  1246.       if(fCtlMouseOut !=isCtlMouseOut)
  1247.       {
  1248.         if(isCtlMouseOut)
  1249.         {
  1250.           if(isLeft)
  1251.             SendMessage(hWnd,WM_DRAWBUTTON, 0,3L);
  1252.           else SendMessage(hWnd,WM_DRAWBUTTON,0,6L);
  1253.         }
  1254.         else
  1255.         {
  1256.           if(isLeft)
  1257.             SendMessage(hWnd,WM_DRAWBUTTON,0,4L);
  1258.           else SendMessage(hWnd,WM_DRAWBUTTON,0,7L);
  1259.         }  
  1260.       }  
  1261.     return 0L;
  1262.     
  1263.     case WM_LBUTTONUP:
  1264.       if(!isCtlMouseDown) break;
  1265.       ReleaseCapture();
  1266.       isCtlMouseDown =FALSE;
  1267.       if(!isCtlMouseOut)        
  1268.       {                      
  1269.         if(isLeft)
  1270.         {
  1271.           CurCtlStart[CurStyle]--;
  1272.           CurCtlEnd[CurStyle]--;
  1273.           if(CurSelCtl >=0)
  1274.             CurSelCtl++;          /////
  1275.         }
  1276.         else
  1277.         {
  1278.           CurCtlStart[CurStyle]++;
  1279.           CurCtlEnd[CurStyle]++;
  1280.           if(CurSelCtl >=0)
  1281.             CurSelCtl--;    /////
  1282.         }
  1283.         InvalidateRect(hWnd,NULL,TRUE);
  1284.       }
  1285.       else isCtlMouseOut =FALSE;
  1286.     return 0L;
  1287.     
  1288.     case WM_PAINT:
  1289.       GetClientRect(hWnd,&rc);
  1290.       BeginPaint(hWnd,&ps); 
  1291.       hPen = CreatePen(PS_SOLID,1,RGB(80,80,80));
  1292.       SelectObject(ps.hdc,hPen);
  1293.       //MoveTo(ps.hdc,0,rc.bottom-1);         
  1294.       MoveTo(ps.hdc,rc.right-1,rc.bottom-1); 
  1295.       LineTo(ps.hdc,rc.right-1,0);
  1296.       SelectObject(ps.hdc,GetStockObject(WHITE_PEN));
  1297.       DeleteObject(hPen);
  1298.       //MoveTo(ps.hdc,0,1);
  1299.       LineTo(ps.hdc,0,0); 
  1300.       LineTo(ps.hdc,0,rc.bottom-1);    
  1301.       SendMessage(hWnd,WM_DRAWBUTTON,(WPARAM)(HDC)ps.hdc,(LONG)MAKELONG(20,rc.bottom));
  1302.       EndPaint(hWnd,&ps);
  1303.     break;
  1304.              
  1305.     case WM_DESTROY:                               
  1306.       for(i=0;i<2;i++)
  1307.       {
  1308.         if(hBmpUpCtl[i]) DeleteObject(hBmpUpCtl[i]);
  1309.         if(hBmpDnCtl[i]) DeleteObject(hBmpDnCtl[i]);
  1310.         if(hBmpDsCtl[i]) DeleteObject(hBmpDsCtl[i]);
  1311.       }
  1312.       if(hBmpUpLeft) DeleteObject(hBmpUpLeft);
  1313.       if(hBmpUpRight) DeleteObject(hBmpUpRight);
  1314.       if(hBmpDnLeft) DeleteObject(hBmpDnLeft);
  1315.       if(hBmpDnRight) DeleteObject(hBmpDnRight);
  1316.       if(hBmpDsLeft) DeleteObject(hBmpDsLeft);
  1317.       if(hBmpDsRight) DeleteObject(hBmpDsRight);
  1318.       if(hBmpArrow) DeleteObject(hBmpArrow);  
  1319.     break;
  1320.              
  1321.     default:
  1322.     break;
  1323.   }
  1324.   
  1325.   return (DefWindowProc(hWnd, message, wParam, lParam));
  1326. }
  1327. */
  1329. BOOL __export CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
  1330. {
  1331.     switch (message)
  1332.     {
  1333.         case WM_INITDIALOG:
  1334.             return (TRUE);
  1336.         case WM_COMMAND:
  1337.             if (wParam == IDOK
  1338.                 || wParam == IDCANCEL)
  1339.             {
  1340.                 EndDialog(hDlg, TRUE);
  1341.                 return (TRUE);
  1342.             }
  1343.             break;
  1344.     }
  1345.     return (FALSE);
  1346. }                  
  1348. void DrawStyleBtn(HDC hDC,HWND hWnd,int BtnNo, int Style,BOOL fDrawGray,LPSTYLEBTN StyleBtn)
  1349. {
  1350.   POINT aPoints[5];
  1351.   HPEN hPen; 
  1352.   int CurBtnStart,CurBtnEnd;
  1353.   //HLOCAL hStyleBtns;
  1354.   //LPSTYLEBTN lpStyleBtns;
  1356.   CurBtnStart =GetWindowWord(hWnd, STYLE_START);
  1357.   CurBtnEnd =GetWindowWord(hWnd, STYLE_END);
  1358.   if(BtnNo <CurBtnStart || BtnNo >CurBtnEnd) return;
  1359.   
  1360.   //hStyleBtns =GetProp(hWnd,"STYLEBTNS");
  1361.   //lpStyleBtns =(LPSTYLEBTN)LocalLock(hStyleBtns);
  1362.   if(BtnNo == CurBtnStart)
  1363.     aPoints[0].x = 5;
  1364.   else
  1365.   {
  1366.     if(Style !=2)
  1367.       aPoints[0].x = StyleBtn[BtnNo].left-5; 
  1368.     else if(Style ==2)
  1369.       aPoints[0].x = StyleBtn[BtnNo-1].right+5;
  1370.   }  
  1371.             
  1372.   aPoints[0].y = 1;        
  1373.   
  1374.   switch(Style)
  1375.   {
  1376.     case 0:
  1377.     case 1:
  1378.       aPoints[1].x = StyleBtn[BtnNo].left;
  1379.       aPoints[1].y = STYLE_BTN_HEIGHT;
  1380.       aPoints[2].x = StyleBtn[BtnNo].right;
  1381.       aPoints[2].y = STYLE_BTN_HEIGHT;
  1382.       aPoints[3].x = StyleBtn[BtnNo].right+5;
  1383.       aPoints[3].y = 1;
  1384.           
  1385.       if(Style == 1)
  1386.         SelectObject(hDC,GetStockObject(LTGRAY_BRUSH));
  1387.           
  1388.       Polygon(hDC,aPoints,4);
  1389.       if(Style == 1)
  1390.       {                                              
  1391.         hPen = CreatePen(PS_SOLID,2,RGB(180,180,180));
  1392.         SelectObject(hDC,hPen);
  1393.         MoveTo(hDC,aPoints[0].x+2,aPoints[0].y);
  1394.         LineTo(hDC,aPoints[3].x-2,aPoints[3].y);
  1395.         SelectObject(hDC,GetStockObject(WHITE_PEN));
  1396.         DeleteObject(hPen);
  1397.         MoveTo(hDC,aPoints[0].x+1,aPoints[0].y);
  1398.         LineTo(hDC,aPoints[1].x+1,aPoints[1].y-1);
  1399.         hPen = CreatePen(PS_SOLID,1,RGB(80,80,80));
  1400.         SelectObject(hDC,hPen);
  1401.         LineTo(hDC,aPoints[2].x-1,aPoints[2].y-1);
  1402.         LineTo(hDC,aPoints[3].x-1,aPoints[3].y);
  1403.         SelectObject(hDC,GetStockObject(BLACK_PEN));
  1404.         DeleteObject(hPen);
  1405.         SelectObject(hDC,GetStockObject(WHITE_BRUSH));
  1406.         SetTextColor(hDC,RGB(0,0,255));
  1407.       }                                              
  1408.       else if(fDrawGray)
  1409.       {
  1410.         hPen = CreatePen(PS_SOLID,1,RGB(80,80,80));
  1411.         SelectObject(hDC,hPen);
  1412.         MoveTo(hDC,aPoints[0].x,0);
  1413.         LineTo(hDC,aPoints[3].x,0);
  1414.         SelectObject(hDC,GetStockObject(BLACK_PEN));
  1415.         DeleteObject(hPen);
  1416.       }
  1417.     break;
  1418.     
  1419.     case 2:                        
  1420.       aPoints[1].x = StyleBtn[BtnNo].left-3;
  1421.       aPoints[1].y = STYLE_BTN_HEIGHT/2;
  1422.       aPoints[2].x = StyleBtn[BtnNo].left;
  1423.       aPoints[2].y = STYLE_BTN_HEIGHT;
  1424.       aPoints[3].x = StyleBtn[BtnNo].right;
  1425.       aPoints[3].y = STYLE_BTN_HEIGHT;
  1426.       aPoints[4].x = StyleBtn[BtnNo].right+5;
  1427.       aPoints[4].y = 1;
  1428.       Polygon(hDC,aPoints,5);
  1429.     break;  
  1430.     
  1431.     default:               
  1432.       //LocalUnlock(hStyleBtns);
  1433.     return;      
  1434.   }
  1435.   TextOut(hDC,StyleBtn[BtnNo].left+1,3,(LPSTR)StyleBtn[BtnNo].Caption,
  1436.                  strlen(StyleBtn[BtnNo].Caption));    
  1437.   if(Style ==1) SetTextColor(hDC,RGB(0,0,0));               
  1438.   //LocalUnlock(hStyleBtns);
  1439. }
  1441. HWND CreateNewForm(void)
  1442. {
  1443.     static int FormNum =0;
  1444.     char tmp[40];
  1445.     HWND hWnd;
  1447.     FormNum++;
  1448.     wsprintf((LPSTR)tmp,"Form%d",FormNum);
  1449.     hWnd = CreateWindow( "LGFORM",tmp,
  1450.                    WS_OVERLAPPED|WS_SYSMENU|WS_MINIMIZEBOX|WS_MAXIMIZEBOX
  1451.                    |WS_CLIPSIBLINGS|WS_CLIPCHILDREN|WS_THICKFRAME,
  1452.                    130,100,500,300,
  1453.                    NULL, NULL, hInst, NULL
  1454.             );
  1456.     if (!hWnd)
  1457.       return NULL;
  1458.     
  1459.     ShowWindow(hWnd, SW_SHOW);
  1460.     UpdateWindow(hWnd);
  1461.     return hWnd;
  1462. }
  1464. void ErrorMessage(LPSTR lpszMsg)
  1465. {
  1466.   MessageBox(NULL,lpszMsg,"CBuilder",MB_TASKMODAL |MB_ICONSTOP |MB_OK);
  1467. }
  1469. BOOL isWndClass(HWND hWnd,LPSTR ClassName)
  1470. {                                            
  1471.   static char tmp[40];
  1472.   if(!GetClassName(hWnd, (LPSTR)tmp, sizeof(tmp))) return FALSE;
  1473.   return (lstrcmpi((LPSTR)tmp, (LPSTR)ClassName)==0); 
  1474. }