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

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

Delphi控件源码

开发平台：

Visual C++

CTLS.C：源码内容
  1. #include <windows.h>
  2. #include "appmain.h"
  3. #include "ctls.h"
  5. #define MAX_BUTTON_NUMBER 50
  7. typedef struct tag_CtlsInfo
  8. {          
  9.   //int StyleNo; 
  10.   int CurCtlCount;
  11.   int CurCtlStart,CurCtlEnd;
  12.   HBITMAP hBmpUpCtl,hBmpDnCtl,hBmpDsCtl;
  13.   CtlInfo Btns[MAX_BUTTON_NUMBER];
  14. }CtlsInfo;
  16. CtlsInfo CtlBtns[STYLE_MAX_COUNT];
  18. CtlInfo far *lpCurCtlInfo=NULL;  
  20. long CALLBACK __export CtlWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
  21. {             
  22.   RECT rc;        
  23.   static int CurSelCtl =-1;
  24.   static int CurStyle =0;
  25.   PAINTSTRUCT ps;           
  26.   HPEN hPen;  
  27.   HBITMAP hBmp;
  28.   //static HBITMAP hBmpUpCtl[STYLE_MAX_COUNT],hBmpDnCtl[STYLE_MAX_COUNT],hBmpDsCtl[STYLE_MAX_COUNT];
  29.   static HBITMAP hBmpUpLeft,hBmpDnLeft,hBmpDsLeft,
  30.                  hBmpUpRight,hBmpDnRight,hBmpDsRight,
  31.                  hBmpArrow;  
  32.   //static int CurCtlStart[STYLE_MAX_COUNT],CurCtlEnd[STYLE_MAX_COUNT],CurCtlCount[STYLE_MAX_COUNT];
  33.   static int ctlWidth =0;
  34.   static int ctlXStart =0;
  35.   static BOOL isCtlMouseDown =0,isCtlMouseOut =FALSE,isLeft =0; 
  36.   static BOOL fCtlMouseOut =0;
  37.   int xStart =0;
  38.   HDC hMemDC,hDC;                       
  39.   POINT pt;                                            
  40.   BITMAP bmp;                
  41.   int i,j;
  42.   char stmp[100];
  43.   
  44.   switch(message)            
  45.   {                          
  46.     case WM_CREATE:
  47.       hBmpUpLeft = LoadBitmap(hInst,"BMP_UPLEFT");
  48.       hBmpDnLeft = LoadBitmap(hInst,"BMP_DNLEFT");
  49.       hBmpDsLeft = LoadBitmap(hInst,"BMP_DSLEFT");
  50.       hBmpUpRight = LoadBitmap(hInst,"BMP_UPRIGHT");
  51.       hBmpDnRight = LoadBitmap(hInst,"BMP_DNRIGHT");
  52.       hBmpDsRight = LoadBitmap(hInst,"BMP_DSRIGHT");
  53.       hBmpArrow = LoadBitmap(hInst,"BMP_ARROW");                   
  54.       if(!hBmpUpLeft || !hBmpUpRight || !hBmpArrow
  55.          || !hBmpDnLeft || !hBmpDsLeft || !hBmpDnRight || !hBmpDsRight)
  56.       {
  57.         ErrorMessage("Error Load Ctl Bitmap");
  58.         return -1;    
  59.       }  
  60.       
  61.       //// /////
  62.       for(i=0;i<2;i++)
  63.       {        
  64.         wsprintf(stmp,"BMP_UPSTYLE%d",i);
  65.         CtlBtns[i].hBmpUpCtl = LoadBitmap(hInst, stmp); 
  66.         wsprintf(stmp,"BMP_DNSTYLE%d",i);
  67.         CtlBtns[i].hBmpDnCtl = LoadBitmap(hInst, stmp); 
  68.         if(!CtlBtns[i].hBmpUpCtl || !CtlBtns[i].hBmpDnCtl)
  69.         {
  70.           ErrorMessage("Error Load Ctl Bitmap");
  71.           return -1;    
  72.         }  
  73.       }
  74.       xStart =0;
  75.       GetObject(hBmpArrow,sizeof(bmp),(LPSTR)&bmp);
  76.       ctlWidth = bmp.bmHeight-1;
  77.       xStart = bmp.bmWidth+5;                       
  78.       GetObject(hBmpUpLeft,sizeof(bmp),(LPSTR)&bmp);
  79.       xStart += bmp.bmWidth*2+10;
  80.       ctlXStart =xStart-bmp.bmWidth;
  81.       GetClientRect(hWnd,&rc);       
  82.       
  83.       for(i=0;i<2;i++)
  84.       {
  85.         GetObject(CtlBtns[i].hBmpUpCtl,sizeof(bmp),(LPSTR)&bmp);
  86.         CtlBtns[i].CurCtlStart =0;
  87.         CtlBtns[i].CurCtlCount =bmp.bmWidth/(bmp.bmHeight-1);
  88.         CtlBtns[i].CurCtlEnd =(rc.right-xStart-3)/(bmp.bmHeight-1);  
  89.         if(CtlBtns[i].CurCtlEnd>CtlBtns[i].CurCtlCount) CtlBtns[i].CurCtlEnd =CtlBtns[i].CurCtlCount;
  90.       }
  91.       for(j=0;j<10;j++)
  92.       {
  93.         CtlBtns[0].Btns[j].WndStyle =WndStyles[j];
  94.         CtlBtns[0].Btns[j].WndCount =0;
  95.         lstrcpy((LPSTR)CtlBtns[0].Btns[j].ClassName,ClassNames[j]);
  96.       }
  97.     break;
  98.     
  99.     case WM_SIZE: 
  100.       xStart =0;
  101.       GetObject(hBmpArrow,sizeof(bmp),(LPSTR)&bmp);
  102.       xStart = bmp.bmWidth+5;
  103.       GetObject(hBmpUpLeft,sizeof(bmp),(LPSTR)&bmp);
  104.       xStart += bmp.bmWidth*2+10;
  105.       for(i=0;i<2;i++)
  106.       {
  107.         GetObject(CtlBtns[i].hBmpUpCtl,sizeof(bmp),(LPSTR)&bmp);
  108.         if(gSlipped)
  109.         {
  110.           if(i==CurStyle)
  111.             j =CtlBtns[i].CurCtlStart; 
  112.           CtlBtns[i].CurCtlStart =CtlBtns[i].CurCtlEnd-(LOWORD(lParam)-xStart-3)/(bmp.bmHeight-1);
  113.           if(CtlBtns[i].CurCtlStart<0) CtlBtns[i].CurCtlStart =0;
  114.           if(xStart+3+(CtlBtns[i].CurCtlEnd-CtlBtns[i].CurCtlStart)*ctlWidth<(int)LOWORD(lParam))
  115.           {
  116.             CtlBtns[i].CurCtlEnd +=(LOWORD(lParam)
  117.                   -(xStart+3+(CtlBtns[i].CurCtlEnd-CtlBtns[i].CurCtlStart)*ctlWidth))/ctlWidth;
  119.             if(CtlBtns[i].CurCtlEnd>CtlBtns[i].CurCtlCount) CtlBtns[i].CurCtlEnd =CtlBtns[i].CurCtlCount;
  120.           }
  121.           if(i==CurStyle)
  122.           {
  123.             j =CtlBtns[i].CurCtlStart-j;
  124.             if(CurSelCtl >=0)
  125.               CurSelCtl -=j;
  126.           }    
  127.         }
  128.         else
  129.         {
  130.           if(xStart+3+(CtlBtns[i].CurCtlEnd-CtlBtns[i].CurCtlStart)*ctlWidth<(int)LOWORD(lParam))
  131.           {
  132.             if(i==CurStyle)
  133.               j =CtlBtns[i].CurCtlStart; 
  134.             CtlBtns[i].CurCtlStart -=(LOWORD(lParam)
  135.                   -(xStart+3+(CtlBtns[i].CurCtlEnd-CtlBtns[i].CurCtlStart)*ctlWidth))/ctlWidth;
  137.             if(CtlBtns[i].CurCtlStart<0) CtlBtns[i].CurCtlStart =0;
  138.             if(i==CurStyle)
  139.             {
  140.               j =CtlBtns[i].CurCtlStart-j;
  141.               if(CurSelCtl >=0)
  142.                 CurSelCtl -=j;
  143.             }    
  144.           }
  145.           CtlBtns[i].CurCtlEnd =(LOWORD(lParam)-xStart-3)/(bmp.bmHeight-1)+CtlBtns[i].CurCtlStart;
  146.           if(CtlBtns[i].CurCtlEnd>CtlBtns[i].CurCtlCount) CtlBtns[i].CurCtlEnd=CtlBtns[i].CurCtlCount;
  147.         }  
  148.       }
  149.       InvalidateRect(hWnd,NULL,TRUE);
  150.     return 0L;
  151.     
  152.     case WM_STYLECHANGED:
  153.       if(CurStyle ==(int)wParam) break;
  154.       CurSelCtl =-1;
  155.       CurStyle =(int)wParam;
  156.       //if(CurStyle>1) return 0L;                          
  157.       InvalidateRect(hWnd,NULL,TRUE);
  158.     return 0L;
  159.     
  160.     case WM_DRAWBUTTON:
  161.       if(wParam!=0)
  162.       {
  163.         //draw all the button: CurStyle -- BtnStart to BtnEnd
  164.         hDC = (HDC)wParam;
  165.         hMemDC = CreateCompatibleDC (hDC) ;   
  166.         xStart =0;
  167.         //if(hBmpArrow)
  168.         {
  169.           SelectObject(hMemDC,hBmpArrow);
  170.           GetObject(hBmpArrow,sizeof(bmp),(LPSTR)&bmp);
  171.           xStart =5;
  172.           BitBlt (hDC, xStart,5,
  173.                   bmp.bmWidth,bmp.bmHeight,hMemDC,0,0,SRCCOPY) ;
  174.           xStart =xStart+bmp.bmWidth+10;        
  175.         } 
  176.         //if(hBmpCtlLeft)
  177.         {
  178.           if(CtlBtns[CurStyle].CurCtlStart>0)
  179.             SelectObject(hMemDC,hBmpUpLeft);
  180.           else SelectObject(hMemDC,hBmpDsLeft);  
  181.           GetObject(hBmpUpLeft,sizeof(bmp),(LPSTR)&bmp);
  182.           BitBlt (hDC, xStart,5,
  183.                   bmp.bmWidth,bmp.bmHeight,hMemDC,0,0,SRCCOPY) ;
  184.           xStart +=bmp.bmWidth;
  185.         }
  186.         //if(hBmpCtl[CurStyle])
  187.         {         
  188.           SelectObject (hMemDC, CtlBtns[CurStyle].hBmpUpCtl) ;    
  189.           GetObject(CtlBtns[CurStyle].hBmpUpCtl,sizeof(bmp),(LPSTR)&bmp);
  190.           BitBlt (hDC, xStart,5,
  191.                   (CtlBtns[CurStyle].CurCtlEnd-CtlBtns[CurStyle].CurCtlStart)*(bmp.bmHeight-1),
  192.                   bmp.bmHeight,hMemDC,
  193.                   CtlBtns[CurStyle].CurCtlStart*(bmp.bmHeight-1),0,SRCCOPY) ;
  194.           if(CurSelCtl>=0
  195.              && CurSelCtl<CtlBtns[CurStyle].CurCtlEnd-CtlBtns[CurStyle].CurCtlStart)
  196.           {
  197.             SelectObject(hMemDC,CtlBtns[CurStyle].hBmpDnCtl);
  198.             BitBlt (hDC, ctlXStart+CurSelCtl*ctlWidth,5,
  199.                   ctlWidth,ctlWidth+1,hMemDC,
  200.                   (CurSelCtl+CtlBtns[CurStyle].CurCtlStart)*ctlWidth,0,SRCCOPY) ;
  201.           }            
  202.           else CurSelCtl =-1;
  203.           xStart += (CtlBtns[CurStyle].CurCtlEnd-CtlBtns[CurStyle].CurCtlStart)*(bmp.bmHeight-1);
  204.         }
  205.         //if(hBmpCtlRight)
  206.         {                                      
  207.           if(CtlBtns[CurStyle].CurCtlEnd<CtlBtns[CurStyle].CurCtlCount)
  208.             SelectObject(hMemDC,hBmpUpRight);
  209.           else SelectObject(hMemDC,hBmpDsRight);  
  210.           GetObject(hBmpUpRight,sizeof(bmp),(LPSTR)&bmp);
  211.           BitBlt (hDC, xStart,5,
  212.                   bmp.bmWidth,bmp.bmHeight,hMemDC,0,0,SRCCOPY) ;
  213.         }                       
  214.         DeleteDC (hMemDC) ;           
  215.       }                      
  216.       else if(wParam ==0)
  217.       {          
  218.         if(CurSelCtl <0
  219.            || CurSelCtl >=(CtlBtns[CurStyle].CurCtlEnd-CtlBtns[CurStyle].CurCtlStart))
  220.         {
  221.           CurSelCtl =-1;
  222.           return 0L;    
  223.         }  
  224.         switch(lParam)
  225.         {
  226.           case 0L://hbmp=up
  227.             hBmp =CtlBtns[CurStyle].hBmpUpCtl;
  228.           break;
  229.           case 1L://hbmp=down  
  230.             hBmp =CtlBtns[CurStyle].hBmpDnCtl;
  231.           break;
  232.           case 2L: //hbmp=disable
  233.           break;
  234.           case 3L: //left up
  235.           break;
  236.           case 4L: //left down
  237.           break;
  238.           case 5L: //left disable
  239.           break;
  240.           case 6L: //right up
  241.           break;
  242.           case 7L: //right down
  243.           break;
  244.           case 8L: //right disable
  245.           break;
  246.           default:
  247.           return 0L;
  248.         }                               
  249.         //draw the button           
  250.         hDC=GetDC(hWnd);
  251.         hMemDC =CreateCompatibleDC(hDC);
  252.         SelectObject(hMemDC,hBmp);
  253.         if(lParam <3L)
  254.           BitBlt (hDC, ctlXStart+CurSelCtl*ctlWidth,5,
  255.                   ctlWidth,ctlWidth+1,hMemDC,
  256.                   (CurSelCtl+CtlBtns[CurStyle].CurCtlStart)*ctlWidth,0,SRCCOPY) ;
  257.         DeleteDC(hMemDC);
  258.         ReleaseDC(hWnd,hDC);
  259.       }
  260.     return 0L;           
  261.     
  262.     case WM_SETCURSOR:
  263.       //Set Cursor or Show Hint if in a button or Hide Hint if out a button;
  264.       SetCursor(LoadCursor(NULL,IDC_ARROW)); 
  265.       isInSlip = FALSE;
  266.     return TRUE;                                    
  267.     
  268.     case WM_LBUTTONDOWN:
  269.       pt=MAKEPOINT(lParam);                     
  270.       if(CtlBtns[CurStyle].CurCtlStart>0)
  271.       {
  272.         SetRect(&rc,ctlXStart-ctlWidth/2,5,ctlXStart,5+ctlWidth+1);
  273.         if(PtInRect(&rc,pt))
  274.         {                                      
  275.           isLeft =TRUE;
  276.           SendMessage(hWnd,WM_DRAWBUTTON,0,4L);
  277.           SetCapture(hWnd);
  278.           isCtlMouseDown =TRUE;
  279.           return 0L;
  280.         }
  281.       }  
  282.       if(CtlBtns[CurStyle].CurCtlEnd<CtlBtns[CurStyle].CurCtlCount)
  283.       {
  284.         SetRect(&rc,ctlXStart+(CtlBtns[CurStyle].CurCtlEnd-CtlBtns[CurStyle].CurCtlStart)*ctlWidth,5,
  285.                     ctlXStart+(CtlBtns[CurStyle].CurCtlEnd-CtlBtns[CurStyle].CurCtlStart)*ctlWidth+ctlWidth/2,
  286.                     5+ctlWidth+1);
  287.         if(PtInRect(&rc,pt))
  288.         {                                      
  289.           isLeft =FALSE;
  290.           SendMessage(hWnd,WM_DRAWBUTTON,0,7L);
  291.           SetCapture(hWnd);
  292.           isCtlMouseDown =TRUE;
  293.           return 0L;
  294.         }
  295.       }  
  296.       for(i=0;i<CtlBtns[CurStyle].CurCtlEnd-CtlBtns[CurStyle].CurCtlStart;i++)
  297.       {
  298.         SetRect(&rc,ctlXStart+i*ctlWidth,5,
  299.               ctlXStart+(i+1)*ctlWidth,5+ctlWidth+1);
  300.         if (PtInRect(&rc, pt))
  301.           break;
  302.       }         
  303.       if(i+CtlBtns[CurStyle].CurCtlStart ==CtlBtns[CurStyle].CurCtlEnd) return 0L;
  304.       else
  305.       {          
  306.         SendMessage(hWnd,WM_DRAWBUTTON,0,0L);
  307.         CurSelCtl=i;//+CtlBtns[CurStyle].CurCtlStart;
  308.         SendMessage(hWnd,WM_DRAWBUTTON,0,1L);              
  309.         lpCurCtlInfo = (CtlInfo far *)&CtlBtns[CurStyle].Btns[CurSelCtl+CtlBtns[CurStyle].CurCtlStart];
  310.         //LoadString(hInst, 11000+CurStyle*100+i,(LPSTR)Cur_Ctl_Style, sizeof(Cur_Ctl_Style));
  311.       }
  312.     return 0L;
  313.     
  314.     case WM_MOUSEMOVE:   
  315.       if(!isCtlMouseDown) break;
  316.       pt=MAKEPOINT(lParam);                     
  317.       if(isLeft)
  318.         SetRect(&rc,ctlXStart-ctlWidth/2,5,ctlXStart,5+ctlWidth/2+1);
  319.       else
  320.         SetRect(&rc,ctlXStart+(CtlBtns[CurStyle].CurCtlEnd-CtlBtns[CurStyle].CurCtlStart)*ctlWidth,5,
  321.                     ctlXStart+(CtlBtns[CurStyle].CurCtlEnd-CtlBtns[CurStyle].CurCtlStart)*ctlWidth+ctlWidth/2,
  322.                     5+ctlWidth+1);
  323.       fCtlMouseOut = isCtlMouseOut;
  324.       if(PtInRect(&rc,pt))
  325.         isCtlMouseOut =FALSE;
  326.       else isCtlMouseOut =TRUE;
  327.       if(fCtlMouseOut !=isCtlMouseOut)
  328.       {
  329.         if(isCtlMouseOut)
  330.         {
  331.           if(isLeft)
  332.             SendMessage(hWnd,WM_DRAWBUTTON, 0,3L);
  333.           else SendMessage(hWnd,WM_DRAWBUTTON,0,6L);
  334.         }
  335.         else
  336.         {
  337.           if(isLeft)
  338.             SendMessage(hWnd,WM_DRAWBUTTON,0,4L);
  339.           else SendMessage(hWnd,WM_DRAWBUTTON,0,7L);
  340.         }  
  341.       }  
  342.     return 0L;
  343.     
  344.     case WM_LBUTTONUP:
  345.       if(!isCtlMouseDown) break;
  346.       ReleaseCapture();
  347.       isCtlMouseDown =FALSE;
  348.       if(!isCtlMouseOut)        
  349.       {                      
  350.         if(isLeft)
  351.         {
  352.           CtlBtns[CurStyle].CurCtlStart--;
  353.           CtlBtns[CurStyle].CurCtlEnd--;
  354.           if(CurSelCtl >=0)
  355.             CurSelCtl++;          /////
  356.         }
  357.         else
  358.         {
  359.           CtlBtns[CurStyle].CurCtlStart++;
  360.           CtlBtns[CurStyle].CurCtlEnd++;
  361.           if(CurSelCtl >=0)
  362.             CurSelCtl--;    /////
  363.         }
  364.         InvalidateRect(hWnd,NULL,TRUE);
  365.       }
  366.       else isCtlMouseOut =FALSE;
  367.     return 0L;
  368.     
  369.     case WM_PAINT:
  370.       GetClientRect(hWnd,&rc);
  371.       BeginPaint(hWnd,&ps); 
  372.       hPen = CreatePen(PS_SOLID,1,RGB(80,80,80));
  373.       SelectObject(ps.hdc,hPen);
  374.       //MoveTo(ps.hdc,0,rc.bottom-1);         
  375.       MoveTo(ps.hdc,rc.right-1,rc.bottom-1); 
  376.       LineTo(ps.hdc,rc.right-1,0);
  377.       SelectObject(ps.hdc,GetStockObject(WHITE_PEN));
  378.       DeleteObject(hPen);
  379.       //MoveTo(ps.hdc,0,1);
  380.       LineTo(ps.hdc,0,0); 
  381.       LineTo(ps.hdc,0,rc.bottom-1);    
  382.       SendMessage(hWnd,WM_DRAWBUTTON,(WPARAM)(HDC)ps.hdc,(LONG)MAKELONG(20,rc.bottom));
  383.       EndPaint(hWnd,&ps);
  384.     break;
  385.              
  386.     case WM_DESTROY:                               
  387.       for(i=0;i<2;i++)
  388.       {
  389.         if(CtlBtns[i].hBmpUpCtl) DeleteObject(CtlBtns[i].hBmpUpCtl);
  390.         if(CtlBtns[i].hBmpDnCtl) DeleteObject(CtlBtns[i].hBmpDnCtl);
  391.         if(CtlBtns[i].hBmpDsCtl) DeleteObject(CtlBtns[i].hBmpDsCtl);
  392.       }
  393.       if(hBmpUpLeft) DeleteObject(hBmpUpLeft);
  394.       if(hBmpUpRight) DeleteObject(hBmpUpRight);
  395.       if(hBmpDnLeft) DeleteObject(hBmpDnLeft);
  396.       if(hBmpDnRight) DeleteObject(hBmpDnRight);
  397.       if(hBmpDsLeft) DeleteObject(hBmpDsLeft);
  398.       if(hBmpDsRight) DeleteObject(hBmpDsRight);
  399.       if(hBmpArrow) DeleteObject(hBmpArrow);  
  400.     break;
  401.              
  402.     default:
  403.     break;
  404.   }
  405.   
  406.   return (DefWindowProc(hWnd, message, wParam, lParam));
  407. }