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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 行业应用 > 金融证券系统 > 查看源码
GuiControlBar.cpp
资源名称：clking_src.rar　[点击查看]
上传用户：zhanglf88
上传日期：2013-11-19
资源大小：6036k
文件大小：41k
源码类别：

金融证券系统

开发平台：

Visual C++

GuiControlBar.cpp：源码内容
  1. //-----------------------------------------------------------------------//
  2. // This is a part of the GuiLib MFC Extention.  //
  3. // Autor  :  Francisco Campos  //
  4. // (C) 2002 Francisco Campos <www.beyondata.com> All rights reserved     //
  5. // This code is provided "as is", with absolutely no warranty expressed  //
  6. // or implied. Any use is at your own risk.  //
  7. // You must obtain the author's consent before you can include this code //
  8. // in a software library.  //
  9. // If the source code in  this file is used in any application  //
  10. // then acknowledgement must be made to the author of this program  //
  11. // fcampos@tutopia.com  //
  12. //-----------------------------------------------------------------------//
  15. // GuiControlBar.cpp : implementation file
  18. #include "stdafx.h"
  19. #include "GuiControlBar.h"
  20. #include "GuiDockContext.h"
  21. #include "guicontrolbar.h"
  22. #include "GuiDrawLayer.h"
  23. #include "resource.h"
  24. #include "..headerguicontrolbar.h"
  25. // CGuiControlBar
  27. IMPLEMENT_DYNAMIC(CGuiControlBar, CControlBar)
  28. CGuiControlBar::CGuiControlBar()
  29. {
  30. nGapGripper=20;
  31. m_bActive=FALSE;
  32. m_bOldActive=FALSE;
  33. /*Modified By SunZhenyu 2003/6/21
  34. m_sizeMinFloating=m_sizeVert=m_sizeHorz=CSize(200,100);
  35. m_sizeHorzt=CSize(200,100);
  36. m_sizeVertt=CSize(200,100);
  37. */
  38. m_sizeMinFloating=m_sizeVert=m_sizeHorz=CSize(210,400);
  39. m_sizeHorzt=CSize(210,400);
  40. m_sizeVertt=CSize(210,400);
  41. m_pos=0;
  42. m_Last=0;
  43. m_bTracking=FALSE;
  44. m_rcBorder=CRect(0,0,0,0);
  45. m_rcOldBorder=CRect(0,0,0,0);
  46. m_ptOld=CPoint(0,0);
  47. m_sizeMinV=CSize(28,28);
  48. m_sizeMinH=CSize(28,28);
  49. m_Initialize=FALSE;
  50. m_First=-1;
  51. m_bForcepaint=FALSE;
  52. m_stateBtn=NORMAL;
  53. m_clrFondo=GuiDrawLayer::GetRGBColorFace();
  54. m_bSupportMultiView=FALSE;
  55. }
  57. CGuiControlBar::~CGuiControlBar()
  58. {
  59. }
  62. BEGIN_MESSAGE_MAP(CGuiControlBar, CControlBar)
  63. ON_WM_CREATE()
  64. ON_WM_LBUTTONDOWN()
  65. ON_WM_LBUTTONUP()
  66. ON_WM_NCLBUTTONDOWN()
  67. ON_WM_NCLBUTTONUP()
  68. ON_WM_MOUSEMOVE()
  69. ON_WM_NCPAINT()
  70. ON_WM_NCCALCSIZE()
  71. ON_WM_WINDOWPOSCHANGED()
  72. ON_WM_PAINT()
  73. ON_WM_LBUTTONDBLCLK()
  74. ON_WM_NCLBUTTONDBLCLK()
  75. ON_WM_NCHITTEST()
  76. ON_WM_SETCURSOR()
  77. ON_WM_SIZE()
  78. ON_WM_NCMOUSEMOVE()
  79. ON_WM_TIMER()
  80. ON_COMMAND(WM_SHOWTITLE, OnShowTitle)
  81. ON_WM_SYSCOLORCHANGE()
  83. END_MESSAGE_MAP()
  87. // CGuiControlBar message handlers
  89. void CGuiControlBar::OnUpdateCmdUI(CFrameWnd* /*pTarget*/, BOOL /*bDisableIfNoHndler*/)
  90. {
  92. CWnd* pFocus = GetFocus();
  93. m_bOldActive=(pFocus->GetSafeHwnd() && IsChild(pFocus));
  94. m_bForcepaint=TRUE;
  95. if (!m_bActive && m_bOldActive)
  96. OnActiveWindow();
  97. m_bForcepaint=FALSE;
  100. }
  102. void CGuiControlBar::OnSysColorChange( )
  103. {
  104. m_clrFondo=GuiDrawLayer::GetRGBColorFace();
  105. CControlBar::OnSysColorChange( );
  107. }
  109. BOOL CGuiControlBar::Create(LPCTSTR lpszWindowName, DWORD dwStyle,CWnd* pParentWnd, UINT nID)
  110. {
  111. // TODO: Add your specialized code here and/or call the base class
  112. //gran parte del codigo se tomo como guia de clases MFC
  113. ASSERT_VALID(pParentWnd);   // must have a parent
  114. //en esta linea se verifica que la ventana debe disponer de un estilo fijo o dinamico
  115. //pero no los dos.el estilo Dynamic permite cambiar el tama駉 dela ventana mientras flota
  116. //pero no cuando esta docking, el estilo fijo determina las columnas en que se disponen los
  117. //componentes y permance asi.
  118. ASSERT(!((dwStyle & CBRS_SIZE_FIXED) && (dwStyle & CBRS_SIZE_DYNAMIC)));
  119. // save the style
  120. //en dwStyle debe asignarse un tipo de alineaci髇 por ejemplo CBRS_TOP,etc de lo contrario
  121. //se generase un ASSERT al acambiar el Style
  122. dwStyle|=CBRS_TOP;
  123. m_dwStyle = (dwStyle & CBRS_ALL);//save the original style
  124. dwStyle &= ~CBRS_ALL;
  125. //en la siguiente instruccion el proposito que se busca es evitar el parpadeo 
  126. //cuando se refresca la ventana.
  127. //WS_CLIPCHILDREN : recorta el area de las ventanas hijas cuando se dibuja sobre 
  128. //  la ventana que la contiene.
  129. //WS_CLIPSIBLING : cuando se recibe el mensaje paint se recorta el area de las otras ventanas
  130. //    hijas superpuestas, que estan fuera de la region.
  131. dwStyle |= WS_CLIPSIBLINGS|WS_CLIPCHILDREN;
  132. //con el estilo CS_DBLCLKS, lo que se busca es que al recibir un doble clic
  133. //la ventana reaccione,ojo el problema es que esto lo hace solo con el area cliente. 
  134. LPCTSTR lpszClassName=::AfxRegisterWndClass(CS_DBLCLKS,
  135. ::LoadCursor(NULL,IDC_ARROW),
  136. ::GetSysColorBrush(COLOR_BTNFACE),
  137. NULL);
  138. //poque no se llama a CControlBar::Create, bueno, da igual llamar a cualquiera, CWnd o CControlBar
  139. //esto debido a que CControlbar se deriva de CWnd y porque ademas CControlBar no sobrecarga el 
  140. //metodo Create, nosotros si porque tenemos que particularizar, cosas.
  141. BOOL bResp= CWnd::Create(lpszClassName, lpszWindowName, dwStyle, CRect(0,0,0,0), pParentWnd, nID);
  142. if (!bResp) return FALSE;
  144. return TRUE;
  145. }
  147. int CGuiControlBar::OnCreate(LPCREATESTRUCT lpCreateStruct)
  148. {
  149. if (CControlBar::OnCreate(lpCreateStruct) == -1)
  150. return -1;
  152. // TODO:  Add your specialized creation code here
  153. //aqui es cuando llamamos a nuestra clase CGuiDockContext, de esta manera
  154. //sobrecargamos el clase original que para nuestros propositos no nos sirve.
  155. //porque ?, bueno porque me interesa que no se pegen las toolbar en el interior
  156. //de las ventanas.
  157. if (m_pDockContext==NULL)
  158. m_pDockContext=new CGuiDockContext(this);
  159. ASSERT(m_pDockContext);
  160. m_CloseBtn.SetData(6,"Close");
  161. m_CloseBtn.SetImageList(IDB_DOCKBAR,9,10,RGB(255,0,255));
  162. return 0;
  163. }
  166. void CGuiControlBar::OnShowTitle()
  167. {
  168. ActiveCaption();
  169. SendMessage(WM_NCPAINT);
  170. }
  173. //esta funcion calcula el tama駉 horizontal de la ventana,no importa si esta 
  174. //docking a izquierda o derecha o arriba o abajo.Debemos disponer de un espacio equitativo entre todas
  175. //ventanas que se encuentren docking ya sea en una fila o columna.
  176. CSize CGuiControlBar::CalcFixedLayout(BOOL bStretch, BOOL bHorz)
  177. {
  178. //la funcion original toma el ancho o alto dependiendo del sentido que nos 
  179. //indica bHorz.
  180. ASSERT_VALID(this);
  182. if (IsFloating())
  183. return m_sizeMinFloating;
  184. else
  185. {
  186. //si bStrerch es TRUE significa que esta ventana no se puede hacer
  187. //Docking
  188. if (bStretch) 
  189. {
  190. if (bHorz)
  191. return CSize(32767, m_sizeHorz.cy);
  192. else
  193. return CSize(m_sizeVert.cx, 32767);
  194. }
  195. }
  197. int Len=GetHiWid();
  199. int nWidth = GetWidthMax();
  200. int nMinSpace=0;//minimo espacio requerido con lo tama駉s normales
  201. int nMinimo=0;  //minimo espacio de los tama駉s minimos
  202. int nRealBars=0;
  203. int m_First=GetFirstPos();
  207. for (int nPos = m_First; nPos <= m_Last; nPos++)
  208. {
  209. CGuiControlBar* pBar = GetGuiControlBar(nPos,TRUE);
  210. if (pBar== NULL) continue;
  211. if (!pBar->IsVisible()) continue;
  212. if (!pBar->IsKindOf(RUNTIME_CLASS(CGuiControlBar)))
  213. {
  214. CPoint pt(GetMessagePos());
  215. m_pDockSite->FloatControlBar(pBar,pt);
  216. continue;
  217. }
  218. if(IsVert())
  219. pBar->m_sizeVert.cx=nWidth;
  220. else
  221. pBar->m_sizeHorz.cy=nWidth; //todas se hacen con el mismo ancho
  222. nMinSpace+=IsVert() ? pBar->m_sizeVert.cy:pBar->m_sizeHorz.cx; //minimo espacio para alinear las barras
  223. nRealBars++; //cuantas barras realmente existen
  224. }
  226. //si el tama駉 de las barras en la fila es mayor que 
  227. //el espacio disponible, luego la solucion salomonica es 
  228. //repartir el espacio entre todas.
  229. if (nRealBars == 1 )
  230. {
  231. if (bHorz)
  232. return m_sizeHorz= CSize(Len,m_sizeHorz.cy);
  233. else
  234. return m_sizeVert=CSize(m_sizeVert.cx,Len);
  236. }
  240. int nDif=Len-nMinSpace;
  241. if (abs(nDif) !=0)
  242. {
  243. BOOL bGrow=FALSE;
  244. if (nDif > 0)
  245. bGrow=TRUE;
  246. nDif=abs(nDif);
  247. while(nDif > 0)
  248. {
  249. for (int nPos = m_First; nPos <= m_Last; nPos++)
  250. {
  251. CGuiControlBar* pBar = GetGuiControlBar(nPos);
  252. if (pBar== NULL) continue;
  253. if(IsVert())
  254. {
  255. if(bGrow)
  256. pBar->m_sizeVert.cy+=1;
  257. else
  258. {
  260. if (pBar->m_sizeVert.cy-1 < pBar->m_sizeMinV.cy)
  261. continue;
  262. pBar->m_sizeVert.cy-=1;
  264. }
  265. }
  266. else
  267. {
  268. if(bGrow)
  269. pBar->m_sizeHorz.cx+=1;
  270. else
  271. {
  273. if (pBar->m_sizeHorz.cx-1 < pBar->m_sizeMinH.cx)
  274. continue;
  275. pBar->m_sizeHorz.cx-=1;
  277. }
  279. }
  281. nDif--;
  282. if(nDif==0) break;
  283. }
  285. }
  287. }
  289.    //--reubicar las ventanas, sin esta rutina nada funciona
  290.   RecalWindowPos();
  291.  
  292. if (IsHorz())
  293. return  m_sizeHorz;
  294. else
  295. return  m_sizeVert;
  296. }
  299. //esta rutina dispone de la posici髇 en el Dockbar de la pila de  ventanas 
  300. void CGuiControlBar::RecalWindowPos()
  301. {
  302. int m_First=GetFirstPos();
  303. int m_Last=GetLastPos();
  304. int m_This=m_pDockBar->FindBar(this);
  306. CRect rcWin=GetDockRect();
  307. int m_VertPos=0;
  308. for(int i=m_First; i<= m_Last; i++)
  309. {
  310. CGuiControlBar* pBar = GetGuiControlBar(i);
  311. if (pBar == NULL) continue;
  312. CRect rcBar;
  313. pBar->GetWindowRect(rcBar);
  314. rcBar.OffsetRect(-rcWin.TopLeft());
  315. if (IsVert())
  316. {
  317.    if (i==m_First) 
  318. rcBar.top=-2;
  319.  else
  320.   rcBar.top=m_VertPos;
  321. }
  322. else
  323. {
  324. if (i==m_First) 
  325. rcBar.left=-2;
  326. else
  327.   rcBar.left=m_VertPos;
  328. }
  329. pBar->MoveWindow(rcBar);
  330. m_VertPos+=IsVert()? rcBar.Height():rcBar.Width();
  332. }
  333. m_pDockSite->RecalcLayout();
  335. }
  337. CRect CGuiControlBar::GetDockRect()
  338. {
  339. CRect rcWin;
  340. if (IsVert())
  341. if (IsLeft())
  342. m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_LEFT)->GetWindowRect(rcWin);
  343. else
  344. m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_RIGHT)->GetWindowRect(rcWin);
  345. else
  346. if(IsBottom())
  347. m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_BOTTOM)->GetWindowRect(rcWin);
  348. else
  349. m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_TOP)->GetWindowRect(rcWin);
  350. return rcWin;
  351. }
  355. int CGuiControlBar::GetWidthMax()
  356. {
  357. m_pos=m_pDockBar->FindBar(this);
  358. m_Last=GetLastPos();
  359. int nWidth=0;
  360. for (int nPos = GetFirstPos(); nPos <= m_Last; nPos++)
  361. {
  362. CGuiControlBar* pBar = GetGuiControlBar(nPos);
  363. if (pBar== NULL) continue;
  364. nWidth=max(nWidth,IsVert() ? pBar->m_sizeVert.cx:pBar->m_sizeHorz.cy);
  365. }
  366. return nWidth;
  367. }
  371. CGuiControlBar* CGuiControlBar::GetGuiControlBar(int nPos,BOOL bAll) const
  372. {
  373. CGuiControlBar* pResult = (CGuiControlBar*)m_pDockBar->m_arrBars[nPos];
  374. if (bAll==FALSE)
  375. {
  376. if (HIWORD(pResult) == NULL) return NULL;
  377. else if (!pResult->IsVisible()) return NULL;
  378. else if (!pResult->IsKindOf(RUNTIME_CLASS(CGuiControlBar))) return NULL;
  379. }
  380. else
  381. {
  382. if (HIWORD(pResult) == NULL)
  383. return NULL;
  384. }
  385. return pResult;
  386. }
  388. //En esta funci髇 se calcula el tama駉 de la ventana cuando esta flotando
  389. //y gestionar cuando el mouse es presionado en las esquinas.
  390. //#define HTTOPLEFT           13
  391. //#define HTTOPRIGHT          14
  392. //#define HTBOTTOMLEFT        16
  393. //#define HTBOTTOMRIGHT       17
  396. CSize CGuiControlBar::CalcDynamicLayout(int nLength, DWORD nMode)
  397. {
  399. m_pDockSite->RecalcLayout();
  401. if (IsFloating())
  402. {
  403. // Enable diagonal arrow cursor for resizing
  404. //m_sizeVert=m_sizeHorz=CSize(200,200);
  405. GetParent()->GetParent()->ModifyStyle(MFS_4THICKFRAME|WS_CAPTION,0);
  406. } 
  407. if (nMode & (LM_HORZDOCK | LM_VERTDOCK)) 
  408. {
  409. m_pDockSite->DelayRecalcLayout();
  410. //obligar a reposicionar  la ventana, de lo contrario cuando vuelva de un doble click
  411. //desde la ventana CMiniFrameWnd queda sin area cliente
  412. SetWindowPos(NULL, 0, 0, 0, 0,
  413. SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER |
  414. SWP_NOACTIVATE | SWP_FRAMECHANGED|SWP_NOREDRAW);
  415.   return CControlBar::CalcDynamicLayout(nLength, nMode);
  416. }
  417. if (nMode & LM_MRUWIDTH)
  418.         return  m_sizeMinFloating;
  420.     if (nMode & LM_COMMIT)
  421.         return  m_sizeMinFloating ;
  422.     
  423. if (IsFloating())
  424. {
  426. CRect rcWin;
  427. POINT cpt;
  428. GetCursorPos(&cpt);
  429. GetParent()->GetParent()->GetWindowRect(&rcWin);
  430. int nXOffset=0;int nYOffset=0;
  431. switch (m_pDockContext->m_nHitTest)
  432. {
  434. //------------------------------------------------------------------
  435. case HTLEFT:
  436. m_pDockContext->m_rectFrameDragHorz= rcWin;
  437. m_pDockContext->m_rectFrameDragHorz.left = cpt.x;
  438. m_sizeMinFloating.cx = max(rcWin.right - cpt.x,32)-4 ;
  439. m_sizeMinFloating.cy = max((rcWin.bottom -rcWin.top)-nGapGripper-5,32)+2 ;
  440. return m_sizeMinFloating;
  441. break;
  442. case HTTOP:
  443. m_pDockContext->m_rectFrameDragHorz=rcWin;
  444. m_pDockContext->m_rectFrameDragHorz.top = cpt.y;
  445. m_sizeMinFloating.cx = max(rcWin.right-rcWin.left-2,32)-4 ;
  446. m_sizeMinFloating.cy = max((rcWin.bottom -nGapGripper-cpt.y-3),32) ;
  447. return m_sizeMinFloating;
  448. break;
  449. case HTRIGHT:
  450. m_pDockContext->m_rectFrameDragHorz=rcWin;
  451. m_pDockContext->m_rectFrameDragHorz.right = cpt.x;
  452. m_sizeMinFloating.cy = max(rcWin.bottom -rcWin.top-nGapGripper-3,32) ;
  453. m_sizeMinFloating.cx = max(cpt.x-rcWin.left-4,32);
  454. return m_sizeMinFloating;
  455. break;
  456. case HTBOTTOM:
  457. m_pDockContext->m_rectFrameDragHorz=rcWin;
  458. m_sizeMinFloating.cy = max(cpt.y-rcWin.top -nGapGripper-3,32) ;
  459. m_sizeMinFloating.cx = max(rcWin.right-rcWin.left-2,32)-4 ;
  460. m_pDockContext->m_rectFrameDragHorz.bottom = cpt.y-4;
  461. return m_sizeMinFloating;
  462. break;
  463. case HTTOPLEFT:
  464. //---------------------------------------------------------
  465. //En este caso crece la ventana a izquierda y hacia arriba
  466. //izquierda incrementa cx y top incrementa cy
  467. m_sizeMinFloating.cx = max(rcWin.right - cpt.x,32)-3 ;
  468. m_sizeMinFloating.cy = max(rcWin.bottom -nGapGripper-cpt.y,32)-2 ;
  469. m_pDockContext->m_rectFrameDragHorz.top = cpt.y-1;
  470. m_pDockContext->m_rectFrameDragHorz.left = cpt.x-2;
  472. return m_sizeMinFloating;
  473. break;
  474. case HTTOPRIGHT:
  475. m_sizeMinFloating.cx = max(cpt.x-rcWin.left,32)-4 ;
  476. m_sizeMinFloating.cy = max(rcWin.bottom -nGapGripper-cpt.y,32)-2 ;
  477. m_pDockContext->m_rectFrameDragHorz.top = cpt.y-1;
  478. m_pDockContext->m_rectFrameDragHorz.right = cpt.x-2;
  479. return m_sizeMinFloating;
  480. break;
  481. case HTBOTTOMLEFT:
  482. m_sizeMinFloating.cx = max(rcWin.right - cpt.x,32)-4;
  483. m_sizeMinFloating.cy = max(cpt.y-rcWin.top -nGapGripper,32)-2 ;
  484. m_pDockContext->m_rectFrameDragHorz.top = rcWin.top;
  485. m_pDockContext->m_rectFrameDragHorz.bottom = cpt.y-1;
  486. m_pDockContext->m_rectFrameDragHorz.left = cpt.x-2;
  487. return m_sizeMinFloating;
  488. break;
  489. case HTBOTTOMRIGHT:
  490. m_sizeMinFloating.cx = max(cpt.x-rcWin.left,32);
  491. m_sizeMinFloating.cy = max(cpt.y-rcWin.top -nGapGripper,32) ;
  492. m_pDockContext->m_rectFrameDragHorz.top = rcWin.top;
  493. m_pDockContext->m_rectFrameDragHorz.bottom = cpt.y+1;
  494. m_pDockContext->m_rectFrameDragHorz.right = cpt.x+2;
  495. return m_sizeMinFloating;
  496. break;
  498. }
  500. }
  502. if(nMode & LM_LENGTHY)
  503.  m_sizeMinFloating.cy = max(nLength,32);
  504. else
  505.      m_sizeMinFloating.cx = max(nLength,32);
  506. return m_sizeMinFloating;
  507. }
  509. void CGuiControlBar::OnLButtonDblClk(UINT nFlags, CPoint point)
  510. {
  511. // TODO: Add your message handler code here and/or call default
  512. if(m_pDockBar != NULL)
  513. m_pDockContext->ToggleDocking();
  514. else
  515. CWnd::OnLButtonDblClk(nFlags, point);
  516. }
  517. void CGuiControlBar::OnLButtonDown(UINT nFlags, CPoint point)
  518. {
  519. // TODO: Add your message handler code here and/or call default
  521. CControlBar::OnLButtonDown(nFlags, point);
  522. }
  526. void CGuiControlBar::OnMouseMove( UINT nHitTest, CPoint point)
  527. {
  529. if(m_bTracking)
  530. {
  531. if (GetCapture() != this)
  532. {
  533. //StopTracking(FALSE);
  534. m_bTracking=FALSE;
  535. }
  537. OnInvertTracker(m_rcBorder);
  538. //nuevos tama駉s de la ventana
  539. if (IsVert())
  540. {
  541. if (m_SideMove==HTLEFT || m_SideMove==HTRIGHT)
  542. {
  543. m_rcBorder.left=point.x;
  544. m_rcBorder.right=m_rcBorder.left+4;
  546. }
  547. else
  548. {
  549. m_rcBorder.top=point.y+26;
  550. m_rcBorder.bottom=m_rcBorder.top+4;
  552. }
  553. }
  554. else
  555. {
  556. if (m_SideMove==HTBOTTOM || m_SideMove==HTTOP)
  557. {
  558. m_rcBorder.top=point.y+26;
  559. m_rcBorder.bottom=m_rcBorder.top+4;
  561. }
  562. else
  563. {
  564. m_rcBorder.left=point.x;
  565. m_rcBorder.right=m_rcBorder.left+4;
  567. }
  568. }
  570. //--------------------------------------------------
  571. //se hacen iguales todos los tama駉s
  572. ClientToScreen(&point);
  573. GetParentFrame()->ScreenToClient(&point);
  574. m_ptActualPos=point;
  576. OnInvertTracker(m_rcBorder);
  577. //SetEqualWidth();
  578. //-----------------------------------------------
  582. }
  584. }
  587. //depende de la posicion se hace igual el tamanio del ancho o alto
  588. void CGuiControlBar::SetEqualWidth()
  589. {
  591. int nFirstPos=GetFirstPos();
  592. for (int nPos = nFirstPos; nPos <= m_Last; nPos++)
  593. {
  594. CGuiControlBar* pBar = GetGuiControlBar(nPos);
  595. if (pBar== NULL) continue;
  596. if (IsHorz())
  597. pBar->m_sizeHorz.cy=m_sizeHorz.cy;//rcDockBar.Height();
  598. else
  599. pBar->m_sizeVert.cx=m_sizeVert.cx;
  600. }
  601. }
  603. int CGuiControlBar::GetHiWid()
  604. {
  605. CRect rcWin;
  606. rcWin=GetDockRect();
  607. if (IsVert())
  608. return rcWin.Height() ;
  609. else
  610. return rcWin.Width() ;
  611. }
  614. //espero que funcione el truco
  615. //la idea es trabajar con coordenadas screen las dimensiones de los bordes del
  616. //dockBar, mas no con los movimientos internos.
  617. void CGuiControlBar::OnLButtonUp(UINT nFlags, CPoint point)
  618. {
  619. // TODO: Add your message handler code here and/or call default
  620. CPoint ptTemp=point;
  621. ClientToScreen(&ptTemp);
  622. if (m_bTracking)
  623. {
  624. ReleaseCapture();
  625. m_bTracking=FALSE;
  626. OnInvertTracker(m_rcBorder);
  627. m_pDockSite->UnlockWindowUpdate();
  629. if (ptTemp ==m_ptStartPos) return;
  631. if (IsVert())
  632. {
  633. if (m_SideMove==HTLEFT)
  634. m_sizeVert.cx-=point.x;
  635. else if(m_SideMove==HTRIGHT)
  636. m_sizeVert.cx=point.x;
  637. else if(m_SideMove==HTTOP)
  638. AjustReDinSize(point);
  639. }
  640. else
  641. {
  642.    if (m_SideMove==HTBOTTOM)
  643.    {
  644. if (point.y < 0)
  645. m_sizeHorz.cy+=abs(point.y);
  646. else
  647. m_sizeHorz.cy=point.y;
  648. }
  649.  
  650.    else if (m_SideMove==HTTOP)
  651.    {
  652.   if (point.y < 0)
  653.   m_sizeHorz.cy+=abs(point.y)-12;
  654.   else
  655.   m_sizeHorz.cy-=abs(point.y)+12;
  656.    }
  657. else if (m_SideMove==HTRIGHT)
  658.        AjustReDinSize(point);
  659.     
  660. }
  662. SetEqualWidth();
  664. }
  665. m_pDockSite->RecalcLayout();
  668. }
  670. //ajusta las ventanas a redimencionarlas verticalmente
  671. //se decrementa las anteriores ventanas a la actual y se 
  672. //incrementan las posteriores.
  673. void CGuiControlBar::AjustReDinSize(CPoint point)
  674. {
  676. int nFirstPos=GetFirstPos();
  677. int nLastPos=GetLastPos();
  678. int m_ThisPos=m_pDockBar->FindBar(this);
  681. ClientToScreen(&point);
  683. //si la diferencia es negativa esta barra crece la anterior a esta disminuye
  684. int nDif=0;
  685. BOOL bGrow=FALSE;
  687. if (IsVert())
  688. {
  689.  nDif=m_ptStartPos.y- point.y;
  690.  if (nDif > 0)
  691. bGrow=TRUE;
  692.  
  693.  if (bGrow)
  694.                 m_sizeVert.cy+=abs(nDif)+4;
  695.  else
  696. m_sizeVert.cy-=abs(nDif);
  698.    if (nFirstPos == m_ThisPos) 
  699. return;
  701. }
  702. else
  703. {
  704.  nDif=m_ptStartPos.x- point.x;
  705.  if (nDif < 0)
  706. bGrow=TRUE;
  708.  if (bGrow)
  709. m_sizeHorz.cx+=abs(nDif);
  710. else
  711. m_sizeHorz.cx-=abs(nDif);
  713.          if (nLastPos == m_ThisPos) 
  714. return;
  715. }
  718. if (IsVert())
  719. AjustVert(bGrow,nDif);
  720. else
  721. AjustHorz(bGrow,nDif);
  723. RecalWindowPos();
  727. }
  730. void CGuiControlBar::AjustVert(BOOL bGrow,int nDif)
  731. {
  732. int nFirstPos=GetFirstPos();
  733. int nLastPos=GetLastPos();
  734. int m_ThisPos=m_pDockBar->FindBar(this);
  736. if(m_SideMove==HTTOP)
  737. {
  739. //Esta ventana crece las anteriores reducen su tama駉
  741. if (bGrow)
  742. {
  743. for (int i=m_ThisPos-1; i > 0; i--)
  744. {
  745. CGuiControlBar* pBar = GetGuiControlBar(i);
  746. if (pBar== NULL) return;
  747. if(IsVert())
  748. {
  749. if (pBar->m_sizeVert.cy-abs(nDif) < pBar->m_sizeMinV.cy)
  750. {
  751. pBar->m_sizeVert.cy=pBar->m_sizeMinV.cy;
  752. continue;
  753. }
  754. else
  755. {
  756. pBar->m_sizeVert.cy-=abs(nDif);
  757. break;
  758. }
  759. }
  760. }//for
  762. }//bGrow
  763. else //este disminuye la anterior crece
  764. {
  765. if (m_ThisPos-1 > 0)
  766. {
  767. CGuiControlBar* pBar = GetGuiControlBar(m_ThisPos-1);
  768. if (pBar== NULL) return;
  769. pBar->m_sizeVert.cy+=abs(nDif); 
  770. if(m_sizeVert.cy > m_sizeMinV.cy)
  771. return;
  772. else
  773.   pBar->m_sizeVert.cy-=m_sizeMinV.cy; 
  774. }
  775. for (int i=m_ThisPos+1; i >= m_Last; i++)
  776. {
  777. CGuiControlBar* pBar = GetGuiControlBar(i);
  778. if (pBar== NULL) return;
  779. if(IsVert())
  780. {
  781. if (pBar->m_sizeVert.cy-abs(nDif) < pBar->m_sizeMinV.cy)
  782. continue;
  783. else
  784. {
  785. pBar->m_sizeVert.cy-=abs(nDif);
  786. return;
  787. }
  788. }
  789. }//for
  790. }
  791. }
  792. }
  795. void CGuiControlBar::AjustHorz(BOOL bGrow,int nDif)
  796. {
  797. int nFirstPos=GetFirstPos();
  798. int nLastPos=GetLastPos();
  799. int m_ThisPos=m_pDockBar->FindBar(this);
  801. if(m_SideMove==HTRIGHT)
  802. {
  804. //Esta ventana crece las anteriores reducen su tama駉
  806. if (bGrow)
  807. {
  808. for (int i=m_ThisPos+1; i <= nLastPos; i++)
  809. {
  810. CGuiControlBar* pBar = GetGuiControlBar(i);
  811. if (pBar== NULL) return;
  812. if(IsHorz())
  813. {
  814. if (pBar->m_sizeHorz.cx-abs(nDif) < pBar->m_sizeMinH.cx)
  815. {
  816. pBar->m_sizeHorz.cx=pBar->m_sizeMinH.cx;
  817. continue;
  818. }
  819. else
  820. {
  821. pBar->m_sizeHorz.cx-=abs(nDif);
  822. break;
  823. }
  824. }
  825. }//for
  827. }//bGrow
  828. else //este disminuye la anterior crece
  829. {
  830.    if (m_ThisPos+1 <= m_Last)
  831. {
  832. CGuiControlBar* pBar = GetGuiControlBar(m_ThisPos+1);
  833. if (pBar== NULL) return;
  834. pBar->m_sizeHorz.cx+=abs(nDif); 
  835. if(m_sizeHorz.cx > m_sizeMinH.cx)
  836. return;
  837. else
  838.   pBar->m_sizeHorz.cx+=abs(nDif); 
  839. }
  842. for (int i=m_ThisPos-1; i >0; i--)
  843. {
  844. CGuiControlBar* pBar = GetGuiControlBar(i);
  845. if (pBar== NULL) return;
  846. if(IsHorz())
  847. {
  848. if (pBar->m_sizeHorz.cx-abs(nDif) < pBar->m_sizeMinH.cx)
  849. continue;
  850. else
  851. {
  852. pBar->m_sizeHorz.cx-=abs(nDif);
  853. return;
  854. }
  855. }
  856. }//for
  857. }
  858. }
  861. }
  864. //----------------------------------------------------
  865. //OnActiveWindow retira o asigna el foco a la ventana 
  867. void CGuiControlBar::OnActiveWindow()
  868. {
  869. POSITION pos = m_pDockSite->m_listControlBars.GetHeadPosition();
  870. while (pos != NULL)
  871. {
  872. CDockBar* pDockBar = (CDockBar*)m_pDockSite->m_listControlBars.GetNext(pos);
  873. if (pDockBar->IsDockBar() && pDockBar->IsWindowVisible() &&
  874. (!pDockBar->m_bFloating ))
  875. {
  876. int nNumBars=(int)pDockBar->m_arrBars.GetSize();
  877. for(int i=0; i< nNumBars;i++)
  878. {
  879. CGuiControlBar* pBar = (CGuiControlBar*) pDockBar->m_arrBars[i];
  880. if (HIWORD(pBar) == NULL) continue;
  881. if (!pBar->IsVisible()) continue;
  882. if (!pBar->IsKindOf(RUNTIME_CLASS(CGuiControlBar))) continue;
  883. if (pBar != this)
  884. {
  885. pBar->m_bOldActive=FALSE;
  886. pBar->m_bActive=FALSE;
  887. pBar->m_bForcepaint=TRUE;
  888. pBar->SendMessage(WM_NCPAINT);
  889. pBar->m_bForcepaint=FALSE;
  890. }
  891. else
  892. {
  893. m_bOldActive=m_bActive;
  894. m_bActive=TRUE;
  895. m_bForcepaint=TRUE;
  896. SendMessage(WM_NCPAINT);
  897. m_bForcepaint=FALSE;
  900. }
  901. }
  902. }
  903. }
  904. }
  907. void CGuiControlBar::ActiveCaption()
  908. {
  909. CWnd* pFocus=SetFocus();
  910. if(pFocus->GetSafeHwnd())
  911. IsChild(pFocus);
  912. m_bForcepaint=TRUE;
  913. OnActiveWindow();
  914. m_bForcepaint=FALSE;
  916. }
  920. void CGuiControlBar::OnNcLButtonDown(UINT nHitTest, CPoint point)
  921. {
  922. // TODO: Add your message handler code here and/or call default
  923. if (m_bTracking /*|| IsFloating()*/)
  924.         return;
  927.  
  928. m_ptStartPos=point;
  929. if( nHitTest == HTCAPTION || nHitTest == HTCLOSE)
  930. ActiveCaption();
  931. //---------para el boton----
  932. if( nHitTest == HTCLOSE)
  933. {
  934. m_stateBtn=PRESS;
  935. SendMessage(WM_NCPAINT);
  936. SetTimer(1,100,0);
  938. return;
  939. }
  940. //--------------------------
  942. if (m_pDockBar != NULL)
  943. {
  945. if (HTCAPTION == nHitTest)
  946. {
  947. m_pDockContext->StartDrag(point);
  948. m_sizeHorzt=m_sizeHorz;
  949. m_sizeVertt=m_sizeVert;
  950. }
  951. if(!m_bTracking)
  952. {
  953. if(m_rcBorder.PtInRect(point))
  954. {
  956. m_pDockSite->LockWindowUpdate();
  957. OnInvertTracker(m_rcBorder);
  959. m_ptStartPos=point;
  960. SetCapture();
  961. SetFocus();
  963. m_bTracking=TRUE;
  964. m_sizeHorzt=m_sizeHorz;
  965. m_sizeVertt=m_sizeVert;
  967. }
  968. }
  969. }
  970. CWnd::OnNcLButtonDown(nHitTest, point);
  972. }
  974. void CGuiControlBar::OnNcLButtonUp(UINT nHitTest, CPoint point)
  975. {
  976. // TODO: Add your message handler code here and/or call default
  977. CRect rc;
  978. //------------------ para el boton
  979. CRect rcT=m_rcCloseBtn;
  980. ClientToScreen(rcT);
  981. point.y+=23;
  982. point.x+=5;
  983. if (rcT.PtInRect(point))
  984. {
  986. if (m_stateBtn ==PRESS)
  987. {
  988. m_stateBtn=NORMAL;
  989. KillTimer(1);
  990. GetDockingFrame()->ShowControlBar(this, FALSE, FALSE);
  991. }
  992. //SendMessage(WM_NCPAINT);
  993. return;
  995. }
  996. //-------------------para el boton
  999. }
  1001. void CGuiControlBar::OnNcPaint()
  1002. {
  1003. // TODO: Add your message handler code here
  1004. // Do not call CControlBar::OnNcPaint() for painting messages
  1005. // Tomo la misma rutina que se desarrolla para la clase 
  1006. // CGuiToolBarWnd.
  1007. CRect rcWindow;
  1008. CRect rcClient;
  1009. CWindowDC dc(this);
  1010. CDC m_dc; //contexto de dispositivo en memoria
  1011. CBitmap m_bitmap;
  1012. //la idea es tomar el area de la ventana y area  cliente , luego debemos
  1013. //igualar el area de coordenadas de ventana al cliente
  1014. GetWindowRect(&rcWindow);
  1015. GetClientRect(&rcClient);
  1016. ScreenToClient(rcWindow);
  1017.     rcClient.OffsetRect(-rcWindow.TopLeft());
  1018.     rcWindow.OffsetRect(-rcWindow.TopLeft());
  1019.   
  1020. m_dc.CreateCompatibleDC(&dc);
  1021. m_bitmap.CreateCompatibleBitmap(&dc,rcWindow.Width(),rcWindow.Height());
  1022. CBitmap *m_OldBitmap=m_dc.SelectObject(&m_bitmap);
  1023. //aqui debe utilizarse la brocha que define GuiDrawLayer, si no hacemos la siguiente
  1024. //linea usted vera un horrible color negro, a cambio del dibujo.
  1025. CBrush cb;
  1026. cb.CreateSolidBrush(m_clrFondo);
  1027. m_dc.FillRect(rcWindow, &cb);
  1029. DrawGripper(&m_dc,&rcWindow);
  1030. dc.IntersectClipRect(rcWindow);
  1031.     dc.ExcludeClipRect(rcClient);//asi evitamos el parpadeo
  1032. dc.BitBlt(rcWindow.left,rcWindow.top,rcWindow.Width(),rcWindow.Height(),&m_dc,0,0,SRCCOPY);
  1033. ReleaseDC(&dc);
  1034. m_dc.SelectObject(m_OldBitmap);
  1035. m_bitmap.DeleteObject();
  1036. m_dc.DeleteDC();
  1040. }
  1042. void CGuiControlBar::DrawGripper(CDC* pDC,CRect* rc)
  1043. {
  1044. CRect gripper = rc;
  1045. gripper.top =3;
  1046. gripper.left+=4;
  1047. gripper.right-=IsVert()?6:4;
  1048. gripper.bottom =gripper.top +nGapGripper-3;
  1049. //si la ventana esta activa pintamos el caption o el area del titulo de color azul 
  1050. if (IsFloating())
  1051. m_bActive=TRUE;
  1053. /* Modified By SunZhenyu 2003/6/21, Add the following line*/
  1054. m_bActive = FALSE;
  1056. if(!m_bActive)
  1057. {
  1059. CPen cp(PS_SOLID,1,::GetSysColor(COLOR_BTNSHADOW));
  1060. CPen* cpold=pDC->SelectObject(&cp);
  1061. //linea superior
  1062. pDC->MoveTo(gripper.left+1,gripper.top);
  1063. pDC->LineTo(gripper.right,gripper.top);
  1064. //linea izquierda
  1065. pDC->MoveTo(gripper.left,gripper.top+1);
  1066. pDC->LineTo(gripper.left,gripper.bottom);
  1067. //linea inferior
  1068. pDC->MoveTo(gripper.left+1,gripper.bottom);
  1069. pDC->LineTo(gripper.right,gripper.bottom);
  1070. //linea derecha
  1071. pDC->MoveTo(gripper.right,gripper.top+1);
  1072. pDC->LineTo(gripper.right,gripper.bottom);
  1073. pDC->SelectObject(cpold);
  1074. }
  1075. else
  1076. {
  1077. CBrush cb;
  1078. cb.CreateSolidBrush(::GetSysColor(COLOR_ACTIVECAPTION));//GuiDrawLayer::GetRGBCaptionXP());
  1079. pDC->FillRect(gripper,&cb);
  1080. }
  1081. gripper.DeflateRect(1, 1);
  1082. CString m_caption;
  1083. GetWindowText(m_caption);
  1084. CFont m_cfont;
  1086. // Modified Bu SunZhenyu
  1087. if( !m_cfont.CreateStockObject( DEFAULT_GUI_FONT ) )
  1088. m_cfont.CreateStockObject( ANSI_VAR_FONT );
  1089. // m_cfont.CreateFont(-11,0,0,0,400,0,0,0,0,1,2,1,34,"Verdana");
  1091. CFont* m_fontOld=pDC->SelectObject(&m_cfont);
  1092. int nMode = pDC->SetBkMode(TRANSPARENT);
  1093. CSize SizeCad=pDC->GetTextExtent(m_caption);
  1094. CRect rCText=gripper;
  1095. rCText.top=6;
  1096. rCText.bottom =rCText.top+14;
  1098. int cont=SizeCad.cx;
  1099. while(cont > 1 && gripper.Width() > 0)
  1100. {
  1101. CSize coor=pDC->GetTextExtent(m_caption,m_caption.GetLength());
  1102. if(coor.cx > gripper.Width()-10)
  1103. {
  1104. m_caption=m_caption.Left(m_caption.GetLength()-1);
  1105. }
  1106. else
  1107. break;
  1108. cont--;
  1110. }
  1111. if (gripper.Width() > 0 )
  1112. if (!m_bActive)
  1113. pDC->TextOut(rCText.left+3,rCText.top,m_caption);
  1114. else
  1115. {
  1116. pDC->SetTextColor(RGB(255,255,255));
  1117. pDC->TextOut(rCText.left+3,rCText.top,m_caption);
  1118. }
  1119. //CRect gripper;
  1120. //------------------------------------------------
  1121. GetWindowRect( gripper );
  1122. ScreenToClient( gripper );
  1123. gripper.OffsetRect( -gripper.left, -gripper.top );
  1124. gripper.left=gripper.right-20;
  1125. gripper.right-=7;
  1126. gripper.top+=6;
  1127. gripper.bottom=gripper.top+13;
  1128. m_rcCloseBtn=gripper;
  1129. //m_rcCloseBtn.left-=4;
  1130. //ClientToScreen(m_rcCloseBtn);
  1131. if(!m_bActive)
  1132.   m_CloseBtn.Paint(pDC,m_stateBtn,gripper,::GetSysColor(COLOR_BTNFACE));
  1133. else
  1134.   m_CloseBtn.Paint(pDC,m_stateBtn,gripper,::GetSysColor(COLOR_ACTIVECAPTION));
  1135. //------------------------------------------------
  1136.   pDC->SetBkMode(nMode);
  1137. pDC->SelectObject(m_fontOld);
  1139. }
  1141. //en esta funci髇 se calcula el area cliente que podra ser utilizado
  1142. //por ventanas que deriven esta clase.
  1143. void CGuiControlBar::OnNcCalcSize(BOOL /*bCalcValidRects*/, NCCALCSIZE_PARAMS* lpncsp)
  1144. {
  1145. // adjust non-client area for border space
  1146. lpncsp->rgrc[0].left +=!IsFloating()?5:2;
  1147. lpncsp->rgrc[0].top +=nGapGripper+3;
  1148. lpncsp->rgrc[0].right -=!IsFloating()?IsVert()?7:4:2;
  1149. lpncsp->rgrc[0].bottom -=!IsFloating()?3:2;
  1151. }
  1154. //Aqui la idea es verificar que si se da clic sobre otra ventana de este tipo
  1155. //automaticamente emita un mensaje eliminando el caption que la identifica como
  1156. //ventana default.
  1158. void CGuiControlBar::OnWindowPosChanged(WINDOWPOS* lpwndpos)
  1159. {
  1160. CRect rc;
  1161. GetClientRect(rc);
  1162. nDockBarAling = GetParent()->GetDlgCtrlID();
  1163. //envie un recalculo del area cliente solo si el tama駉 ha sido 
  1164. //cambiado, de lo contrario permanezca igual
  1165. lpwndpos->flags |= SWP_FRAMECHANGED;
  1166. CControlBar::OnWindowPosChanged(lpwndpos);
  1168. CWnd* pWnd = GetWindow(GW_CHILD);
  1169. if (!m_bSupportMultiView)
  1170. {
  1171.         if (pWnd != NULL)
  1172.         {
  1173.             pWnd->MoveWindow(rc);
  1174.             ASSERT(pWnd->GetWindow(GW_HWNDNEXT) == NULL);
  1175. }
  1176. }
  1177. else
  1178. {
  1179. while (pWnd != NULL)
  1180.         {
  1181.             if (pWnd->IsWindowVisible())
  1182. {
  1183. pWnd->MoveWindow(rc);
  1184. break;
  1185. }
  1186.             pWnd=pWnd->GetWindow(GW_HWNDNEXT);
  1187. }
  1188. }
  1189. }
  1192. //este conjunto de clases nos indican el estado de la ventana
  1193. //en un momento determinado
  1195. BOOL CGuiControlBar::IsLeft()
  1196. {
  1197. if (nDockBarAling == AFX_IDW_DOCKBAR_LEFT) return TRUE;
  1198. return FALSE;
  1199. }
  1201. BOOL CGuiControlBar::IsRight()
  1202. {
  1203. if (nDockBarAling == AFX_IDW_DOCKBAR_RIGHT) return TRUE;
  1204. return FALSE;
  1205. }
  1207. BOOL CGuiControlBar::IsTop()
  1208. {
  1209. if (nDockBarAling == AFX_IDW_DOCKBAR_TOP) return TRUE;
  1210. return FALSE;
  1211. }
  1213. BOOL CGuiControlBar::IsBottom()
  1214. {
  1215. if (nDockBarAling == AFX_IDW_DOCKBAR_BOTTOM) return TRUE;
  1216. return FALSE;
  1217. }
  1219. BOOL CGuiControlBar::IsVert()
  1220. {
  1221. if (IsLeft() || IsRight()) return TRUE;
  1222. return FALSE;
  1223. }
  1225. BOOL CGuiControlBar::IsHorz()
  1226. {
  1227. if (IsTop() || IsBottom()) return TRUE;
  1228. return FALSE;
  1229. }
  1231. BOOL CGuiControlBar::IsFloating()
  1232. {
  1233. if (nDockBarAling == AFX_IDW_DOCKBAR_FLOAT) return TRUE;
  1234. return FALSE;
  1236. }
  1237. void CGuiControlBar::OnPaint()
  1238. {
  1239. CPaintDC dc(this); // device context for painting
  1240. m_pDockSite->RecalcLayout();//si quita esto se tiene problemas    
  1242. // TODO: Add your message handler code here
  1243. // Do not call CControlBar::OnPaint() for painting messages
  1244. }
  1247. UINT CGuiControlBar::OnNcHitTest(CPoint point)
  1248. {
  1249. // TODO: Add your message handler code here and/or call default
  1250. CRect rcWindow;
  1251. //no se convierte las coordenadas de pantalla porque el punto
  1252. //entregado por esta funci髇 esta dado en el mismo sentido.
  1253. GetWindowRect(rcWindow);
  1254. int it=0;
  1255. // if (IsFloating())
  1256. //        return CControlBar::OnNcHitTest(point);
  1257. CRect rcT=m_rcCloseBtn;
  1258. ClientToScreen(rcT);
  1259. CPoint pt=point;
  1260. pt.y+=23;
  1261. pt.x+=5;
  1262. //pt.Offset(-rcT.left,-rcT.top);
  1263. if (rcT.PtInRect(pt))
  1264. return HTCLOSE;
  1265. CRect rcTemp;
  1266. for (int i=0; i< 4; i++)
  1267. {
  1268. rcTemp=rcWindow;
  1269. if (i== 0) //left
  1270. {
  1271. it= rcTemp.left;
  1272. it+=4;
  1273. rcTemp.right=it;
  1274. m_rcBorder=rcTemp;
  1275. if (rcTemp.PtInRect(point))
  1276. if(IsLegal(HTLEFT)) return m_SideMove=HTLEFT;
  1277. }
  1278. if (i==1)  //top
  1279. {
  1280. it= rcTemp.top;
  1281. it+=4;
  1282. rcTemp.bottom=it;
  1283. m_rcBorder=rcTemp;
  1284. if (rcTemp.PtInRect(point))
  1285.  if(IsLegal(HTTOP)) return m_SideMove=HTTOP ;
  1286. }
  1287. if (i==2)  //right
  1288. {
  1289. it= rcTemp.right;
  1290. it-=4;
  1291. rcTemp.left=it;
  1292. m_rcBorder=rcTemp;
  1293. if (rcTemp.PtInRect(point))
  1294. if (IsLegal(HTRIGHT)) return m_SideMove=HTRIGHT;
  1295. }
  1296. if (i==3)  //bottom
  1297. {
  1298. it= rcTemp.bottom;
  1299. it-=4;
  1300. rcTemp.top=it;
  1301. m_rcBorder=rcTemp;
  1302. if (rcTemp.PtInRect(point))
  1303. if (IsLegal(HTBOTTOM))return m_SideMove=HTBOTTOM;
  1304. }
  1306. }
  1307. it=0;
  1308. rcTemp=rcWindow;
  1309. it= rcTemp.top+nGapGripper;
  1310. rcTemp.bottom=it;
  1311. if (rcTemp.PtInRect(point))
  1312. return m_SideMove=HTCAPTION;
  1314. return CControlBar::OnNcHitTest(point);
  1315. }
  1317. //-----------------------------------------------------------
  1318. //aqui se verifica que las coordenadas de cambio de tama駉
  1319. //sean las correctas
  1321. BOOL CGuiControlBar::IsLegal(UINT uAlin)
  1322. {
  1323. m_First=GetFirstPos();
  1324. // if (IsFloating()) return FALSE;
  1325. switch(uAlin)
  1326. {
  1327. case HTLEFT:
  1328. if (IsHorz() && m_pos >0 && (m_pos != m_Last && m_pos != m_First)) return TRUE;
  1329. if (IsVert() && m_pos <= m_Last && IsRight() ) return TRUE;
  1330. return FALSE;
  1331. break;
  1332. case HTTOP:
  1333. if (m_pos != m_First && IsVert()) return TRUE;
  1334. if (IsHorz() && m_pos <= m_Last && IsBottom() ) return TRUE;
  1335. return FALSE;
  1336. break;
  1337. case HTRIGHT:
  1338. if (m_pos <= m_Last && IsVert() && IsLeft() ) return TRUE;
  1339. if (IsHorz() && m_pos >0 &&  m_pos != m_Last) return TRUE;
  1340. return FALSE;
  1341. case HTBOTTOM:
  1342. if ((m_pos != m_Last && m_pos != m_First) && IsHorz() && IsBottom()) return TRUE;
  1343. if (m_pos <= m_Last && IsHorz() && IsTop()) return TRUE;
  1344. //if (IsVert() && m_pos >0 ) return TRUE;
  1345. return FALSE;
  1346. break;
  1347. }
  1348. return FALSE;
  1349. }
  1353. //----------------------------------------------
  1354. //debemos obtener cuantas barras existen en esta columnas
  1355. //porque si intentamos obtener el conteo con la funciones de dockbar
  1356. //siempre obtendremos nuestra actual barra mas otra de otra fila, por lo que
  1357. //el conteo es incorrecto, luego despues de nuestra barra la siguiente nula
  1358. //es el final de esta fila.
  1360. int CGuiControlBar::GetLastPos()
  1361. {
  1363. int nNumBars=(int)m_pDockBar->m_arrBars.GetSize();
  1364. int m_pos=m_pDockBar->FindBar(this);
  1365. for(int i=m_pos+1; i< nNumBars;i++)
  1366. {
  1367. if (m_pDockBar->m_arrBars[i]== NULL)
  1368.     return i-1;
  1369. }
  1370. return -1;
  1371. }
  1373. //--------------------------------------------
  1374. //esta rutina funciona algo parecido a la anterior
  1375. //con la diferencia que ahora se parte desde la posicion
  1376. //que indetifica m_pos hacia atraz hasta encontrar el nulo
  1377. int CGuiControlBar::GetFirstPos()
  1378. {
  1379. int m_pos=m_pDockBar->FindBar(this);
  1380. for(int i=m_pos; i>=0;i--)
  1381. {
  1382. if (m_pDockBar->m_arrBars[i]== NULL)
  1383.     return i+1;
  1384. }
  1385. return -1;
  1387. }
  1391. //------------------------------------------------------------------------
  1393. BOOL CGuiControlBar::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
  1394. {
  1395. // TODO: Add your message handler code here and/or call default
  1396. if (IsFloating()) return 0;
  1397. CPoint ptCursor;
  1398. ::GetCursorPos (&ptCursor);
  1399. if(nHitTest == HTLEFT ||nHitTest == HTRIGHT)
  1400. SetCursor(AfxGetApp ()->LoadCursor (AFX_IDC_HSPLITBAR));
  1401. else if(nHitTest == HTTOP ||nHitTest == HTBOTTOM)
  1402. SetCursor(AfxGetApp ()->LoadCursor (AFX_IDC_VSPLITBAR));
  1403. else
  1404. return CControlBar::OnSetCursor(pWnd, nHitTest, message);
  1405. return 1;
  1406. }
  1410. void CGuiControlBar::OnInvertTracker(const CRect& rect)
  1411. {
  1412. ASSERT_VALID(this);
  1413. ASSERT(!rect.IsRectEmpty());
  1415. CRect rcWin=GetDockRect();
  1417. CDC *pDC = m_pDockSite->GetDCEx(NULL,
  1418.         DCX_WINDOW|DCX_CACHE|DCX_LOCKWINDOWUPDATE);
  1419. CRect rcBar;
  1420. GetWindowRect(rcBar);
  1421. if (IsVert())  //el sentido de las barras es vertical
  1422. {
  1426. if (m_SideMove==HTLEFT || m_SideMove==HTRIGHT) //el mouse esta en el borde izquierdo o derecho
  1427. {
  1428. rcWin.OffsetRect(-rect.left,-rect.top);
  1429. rcWin.top+=10;
  1430. rcWin.left=rect.left+2;
  1431. rcWin.right=rect.right+2;
  1432. }
  1433. else  //el mouse esta el borde de arriba pero de una barra vertical
  1434. {
  1435. rcBar.OffsetRect(-rect.TopLeft());
  1436. rcWin=rcBar;
  1437. if (IsLeft() || IsRight())   //a la izquierda
  1438. {
  1440. rcWin.top=rect.top-2;
  1441. rcWin.bottom=rect.bottom-2;
  1442. }
  1443. //
  1445. }
  1446. }
  1447. else  //el sentido de las barras es horizontal
  1448. {
  1450. if (m_SideMove==HTTOP || m_SideMove==HTBOTTOM) //el mouse esta en el borde de arriba o abajo
  1451. {
  1452. rcWin.OffsetRect(-rect.left,-rect.top);
  1453. rcWin.top=rect.top-2;
  1454. rcWin.bottom=rect.bottom-2;
  1455. }
  1456. else //el mouse esta en el borde derecho
  1457. {
  1458. rcBar.OffsetRect(-rect.TopLeft());
  1459. rcWin=rcBar;
  1460. if (IsBottom() || IsTop()) //abajo
  1461. {
  1462. rcWin.left=rect.left+2;
  1463. rcWin.right=rect.right+2;
  1464. }
  1465. }
  1466. }
  1467. ClientToScreen(&rcWin);
  1468. GetParentFrame()->ScreenToClient(&rcWin);
  1469. // invert the brush pattern (looks just like frame window sizing)
  1470. CBrush* pBrush = CDC::GetHalftoneBrush();
  1471. HBRUSH hOldBrush = NULL;
  1472. if (pBrush != NULL)
  1473. hOldBrush = (HBRUSH)SelectObject(pDC->m_hDC, pBrush->m_hObject);
  1474. pDC->PatBlt(rcWin.left, rcWin.top, rcWin.Width(), rcWin.Height(), PATINVERT);
  1475. if (hOldBrush != NULL)
  1476. SelectObject(pDC->m_hDC, hOldBrush);
  1477. m_pDockSite->ReleaseDC(pDC);
  1478. }
  1481. void CGuiControlBar::OnSize(UINT nType, int cx, int cy)
  1482. {
  1483. // CControlBar::OnSize(nType, cx, cy);
  1484. CWnd* pWnd = GetWindow(GW_CHILD);
  1485. if (!m_bSupportMultiView)
  1486. {
  1487.         if (pWnd != NULL)
  1488.         {
  1489.             pWnd->MoveWindow(0, 0, cx, cy);
  1490.             ASSERT(pWnd->GetWindow(GW_HWNDNEXT) == NULL);
  1491. }
  1492. }
  1493. else
  1494. {
  1495. while (pWnd != NULL)
  1496.         {
  1497.             if (pWnd->IsWindowVisible())
  1498. {
  1499. pWnd->MoveWindow(0, 0, cx, cy);
  1500. break;
  1501. }
  1502.             pWnd=pWnd->GetWindow(GW_HWNDNEXT);
  1503. }
  1504. }
  1505. //m_pDockSite->RecalcLayout();
  1506. // TODO: Add your message handler code here
  1507. }
  1508. void CGuiControlBar::SetColorFondo(COLORREF clrFondo)
  1509. {
  1510. m_clrFondo=clrFondo;
  1512. }
  1514. //enum State{NORMAL=0,OVER=1,PRESS=2};
  1517. CGuiControlBarButton::CGuiControlBarButton()
  1518. {
  1519. bTypeButton=GUINORMAL;
  1520. m_bEnabled=TRUE;
  1521. }
  1524. CGuiControlBarButton::~CGuiControlBarButton()
  1525. {
  1527. }
  1529. void CGuiControlBarButton::SetTypeButton(GuiType bTypeb)
  1530. {
  1531. bTypeButton=bTypeb;
  1532. }
  1535. void CGuiControlBarButton::SetEnabled(BOOL bEnabled)
  1536. {
  1537. m_bEnabled=bEnabled;
  1538. }
  1540. void CGuiControlBarButton::Paint(CDC* pDC,int st,CRect rc,COLORREF clrFondo)
  1541. {
  1542. CBrush cb;
  1543. if(bTypeButton==GUINORMAL) 
  1544. cb.CreateSolidBrush(clrFondo);
  1545. else
  1546. {
  1547. if (m_bEnabled)
  1548. if (st == OVER)
  1549. cb.CreateSolidBrush(GuiDrawLayer::GetRGBFondoXP());
  1550. else if(st == PRESS)
  1551. cb.CreateSolidBrush(GuiDrawLayer::GetRGBPressBXP());
  1552. else
  1553. cb.CreateSolidBrush(GuiDrawLayer::GetRGBColorFace());
  1554. }
  1556. if (m_bEnabled)
  1557. {
  1558. pDC->FillRect(rc,&cb);
  1559. if (st == OVER)
  1560. pDC->Draw3dRect(rc,bTypeButton==GUINORMAL?::GetSysColor(COLOR_BTNHIGHLIGHT):GuiDrawLayer::GetRGBCaptionXP(),
  1561.    bTypeButton==GUINORMAL?::GetSysColor(COLOR_BTNSHADOW):GuiDrawLayer::GetRGBCaptionXP());
  1562. if (st == PRESS)
  1563. pDC->Draw3dRect(rc,bTypeButton==GUINORMAL?::GetSysColor(COLOR_BTNSHADOW):GuiDrawLayer::GetRGBCaptionXP(),
  1564. bTypeButton==GUINORMAL?::GetSysColor(COLOR_BTNHIGHLIGHT):GuiDrawLayer::GetRGBCaptionXP());
  1565. }
  1566. if(bTypeButton==GUINORMAL) 
  1567. m_imgList.Draw(pDC,clrFondo == ::GetSysColor(COLOR_ACTIVECAPTION)? m_nIcon+1:m_nIcon, 
  1568. CPoint(rc.left+1,rc.top+2), ILD_TRANSPARENT);
  1569. else
  1570. {
  1571. if (m_bEnabled)
  1572. m_imgList.Draw(pDC,m_nIcon, CPoint(rc.left+1,rc.top+1), ILD_TRANSPARENT);
  1573. else
  1574. {
  1575. HICON m_Icon=m_imgList.ExtractIcon(m_nIcon);
  1576. ICONINFO bm;
  1577. ZeroMemory(&bm, sizeof(ICONINFO));
  1578. ::GetIconInfo(m_Icon,&bm);
  1579. CSize m_SizeImage =CSize((BYTE)(bm.xHotspot*2),(BYTE)(bm.yHotspot*2));
  1580. pDC->DrawState(CPoint(rc.left+1,rc.top+1),m_SizeImage,m_Icon,DSS_MONO,CBrush (GuiDrawLayer::GetRGBColorShadow()));
  1581. }
  1582. }
  1583. }
  1585. void CGuiControlBarButton::SetData(int nIcon,LPCTSTR lpMsg)
  1586. {
  1587. m_nIcon=nIcon;
  1588. m_lpMsg=lpMsg;
  1589. }
  1591. void  CGuiControlBarButton::SetImageList(UINT nBitmapID, int cx, int nGrow, COLORREF crMask)
  1592. {
  1593. CBitmap cbmp;
  1594. BITMAP bmp;
  1595. m_imgList.Create(nBitmapID,cx,nGrow,crMask);
  1596. cbmp.LoadBitmap(nBitmapID);
  1597. cbmp.GetBitmap(&bmp);
  1598. m_imgList.Add(&cbmp,crMask);
  1600. }
  1603. void CGuiControlBar::OnNcMouseMove(UINT nHitTest, CPoint point)
  1604. {
  1605. // TODO: Add your message handler code here and/or call default
  1606. if (m_stateBtn != NORMAL) return;
  1607. if (nHitTest == HTCLOSE)
  1608. {
  1609. m_stateBtn=OVER;
  1610. SetTimer(1,100,0);
  1611. }
  1612. SendMessage(WM_NCPAINT);
  1613. CControlBar::OnNcMouseMove(nHitTest, point);
  1614. }
  1616. void CGuiControlBar::OnTimer(UINT nIDEvent)
  1617. {
  1618. // TODO: Add your message handler code here and/or call default
  1619. if (m_stateBtn==NORMAL) return;
  1620. CRect rc;
  1621. CPoint pt(GetMessagePos());
  1623. CRect rcT=m_rcCloseBtn;
  1624. ClientToScreen(rcT);
  1625. pt.y+=23;
  1626. pt.x+=5;
  1627. if (!rcT.PtInRect(pt))
  1628. {
  1629. m_stateBtn=NORMAL;
  1630. KillTimer(1);
  1631. SendMessage(WM_NCPAINT); 
  1632. }
  1633. CControlBar::OnTimer(nIDEvent);
  1634. }
  1636. void CGuiControlBar::OnNcLButtonDblClk(UINT nFlags, CPoint point)
  1637. {
  1638. if(m_pDockBar != NULL)
  1639. {
  1641. m_pDockContext->ToggleDocking();
  1642. m_rcOldBorder=CRect(0,0,0,0);
  1644. }
  1645. }