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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 对话框与窗口 > 查看源码
GuiControlBar.cpp
资源名称：sourcecode.zip　[点击查看]
上传用户：wlkj888
上传日期：2022-08-01
资源大小：806k
文件大小：67k
源码类别：

对话框与窗口

开发平台：

Visual C++

GuiControlBar.cpp：源码内容
  1. /****************************************************************************
  2.  * *
  3.  * GuiToolKit   *
  4.  *  (MFC extension) *
  5.  * Created by Francisco Campos G. www.beyondata.com fcampos@beyondata.com *
  6.  *--------------------------------------------------------------------------*
  7.  * *
  8.  * This program is free software;so you are free to use it any of your *
  9.  * applications (Freeware, Shareware, Commercial),but leave this header *
  10.  * intact. *
  11.  * *
  12.  * These files are provided "as is" without warranty of any kind. *
  13.  * *
  14.  *        GuiToolKit is forever FREE CODE !!!!! *
  15.  * *
  16.  *--------------------------------------------------------------------------*
  17.  * Created by: Francisco Campos G. *
  18.  * Bug Fixes and improvements : (Add your name) *
  19.  * -Francisco Campos *
  20.  * *
  21.  ****************************************************************************/
  23. // GuiControlBar.cpp : implementation file
  25. #include "stdafx.h"
  26. #include "GuiControlBar.h"
  27. #include "GuiDockContext.h"
  28. #include "GuiDrawLayer.h"
  29. #include "GuiToolBarWnd.h"
  30. #include "menuBar.h"
  31. #include "GuiMDIFrame.h"
  32. #include "GuiFrameWnd.h"
  33. #include "GuiMiniFrameWnd.h"
  36. #define  GUI_SCROLLON   10
  37. #define  GUI_SCROLLOFF  11
  38. #define  GUI_NUMITER 5
  39. #define  HTPIN 323
  40. // CGuiControlBar
  41. #pragma warning( disable : 4244 )
  43. IMPLEMENT_DYNAMIC(CGuiControlBar, CControlBar)
  45. CGuiControlBar::CGuiControlBar()
  46. {
  47. nGapGripper=20;
  48. m_bActive=FALSE;
  49. m_bOldActive=FALSE;
  50. m_sizeMinFloating=m_sizeVert=m_sizeHorz=CSize(200,100);
  51. m_sizeMinFloating1=m_sizeMinFloating;
  52. m_sizeHorzt=CSize(200,100);
  53. m_sizeVertt=CSize(600,100);
  54. m_pos=0;
  55. m_Last=0;
  56. m_bTracking=FALSE;
  57. m_rcBorder=CRect(0,0,0,0);
  58. m_rcOldBorder=CRect(0,0,0,0);
  59. m_ptOld=CPoint(0,0);
  60. m_sizeMinV=CSize(28,28);
  61. m_sizeMinH=CSize(28,28);
  62. m_Initialize=FALSE;
  63. m_First=-1;
  64. m_bForcepaint=FALSE;
  65. m_stateBtn=NORMAL;
  66. m_stateAHBtn=NORMAL;
  67. m_bSupportMultiView=FALSE;
  68. m_MenuContext=NULL;
  69. m_StyleDisplay=GUISTYLE_XP;
  70. m_clrFondo=GuiDrawLayer::GetRGBColorFace(GuiDrawLayer::m_Style);
  71. m_bAutoHide=FALSE;
  72. Porc=0.0;
  73. m_bComplete=TRUE;
  74. m_IsLoadDocking=TRUE;
  75. m_hIcon=NULL;
  78. }
  80. CGuiControlBar::~CGuiControlBar()
  81. {
  83. }
  86. BEGIN_MESSAGE_MAP(CGuiControlBar, CControlBar)
  87. ON_WM_CREATE()
  88. ON_WM_LBUTTONDOWN()
  89. ON_WM_RBUTTONDOWN()
  90. ON_WM_LBUTTONUP()
  91. ON_WM_NCLBUTTONDOWN()
  92. ON_WM_NCRBUTTONDOWN()
  93. ON_WM_NCLBUTTONUP()
  94. ON_WM_MOUSEMOVE()
  95. ON_WM_NCPAINT()
  96. ON_WM_NCCALCSIZE()
  97. ON_WM_WINDOWPOSCHANGED()
  98. ON_WM_PAINT()
  99. ON_WM_LBUTTONDBLCLK()
  100. ON_WM_NCLBUTTONDBLCLK()
  101. ON_WM_NCHITTEST()
  102. ON_WM_SETCURSOR()
  103. ON_WM_SIZE()
  104. ON_WM_NCMOUSEMOVE()
  105. ON_WM_TIMER()
  106. ON_COMMAND(ID_GUI_SHOWTITLE, OnShowTitle)
  107. ON_WM_SYSCOLORCHANGE()
  109. END_MESSAGE_MAP()
  113. // CGuiControlBar message handlers
  115. void CGuiControlBar::OnUpdateCmdUI(CFrameWnd* /*pTarget*/, BOOL /*bDisableIfNoHndler*/)
  116. {
  118. CWnd* pFocus = GetFocus();
  119. m_bOldActive=(pFocus->GetSafeHwnd() && IsChild(pFocus));
  120. m_bForcepaint=TRUE;
  121. if (!m_bActive && m_bOldActive)
  122. OnActiveWindow();
  123. m_bForcepaint=FALSE;
  126. }
  128. void CGuiControlBar::OnSysColorChange( )
  129. {
  130. m_clrFondo=GuiDrawLayer::GetRGBColorFace(GuiDrawLayer::m_Style);
  131. CControlBar::OnSysColorChange( );
  133. }
  135. BOOL CGuiControlBar::Create(LPCTSTR lpszWindowName, DWORD dwStyle,CWnd* pParentWnd, UINT nID)
  136. {
  137. // TODO: Add your specialized code here and/or call the base class
  138. //gran parte del codigo se tomo como guia de clases MFC
  139. ASSERT_VALID(pParentWnd);   // must have a parent
  140. //en esta linea se verifica que la ventana debe disponer de un estilo fijo o dinamico
  141. //pero no los dos.el estilo Dynamic permite cambiar el tama駉 dela ventana mientras flota
  142. //pero no cuando esta docking, el estilo fijo determina las columnas en que se disponen los
  143. //componentes y permance asi.
  144. ASSERT(!((dwStyle & CBRS_SIZE_FIXED) && (dwStyle & CBRS_SIZE_DYNAMIC)));
  145. // save the style
  146. //en dwStyle debe asignarse un tipo de alineaci髇 por ejemplo CBRS_TOP,etc de lo contrario
  147. //se generase un ASSERT al acambiar el Style
  148. dwStyle|=CBRS_TOP;
  149. m_dwStyle = (dwStyle & CBRS_ALL);//save the original style
  150. dwStyle &= ~CBRS_ALL;
  151. //en la siguiente instruccion el proposito que se busca es evitar el parpadeo
  152. //cuando se refresca la ventana.
  153. //WS_CLIPCHILDREN : recorta el area de las ventanas hijas cuando se dibuja sobre
  154. //  la ventana que la contiene.
  155. //WS_CLIPSIBLING : cuando se recibe el mensaje paint se recorta el area de las otras ventanas
  156. //    hijas superpuestas, que estan fuera de la region.
  157. dwStyle |= WS_CLIPSIBLINGS|WS_CLIPCHILDREN;
  158. pMf=pParentWnd;
  159. //con el estilo CS_DBLCLKS, lo que se busca es que al recibir un doble clic
  160. //la ventana reaccione,ojo el problema es que esto lo hace solo con el area cliente.
  161. LPCTSTR lpszClassName=::AfxRegisterWndClass(CS_DBLCLKS,
  162. ::LoadCursor(NULL,IDC_ARROW),
  163. ::GetSysColorBrush(COLOR_BTNFACE),
  164. NULL);
  165. //poque no se llama a CControlBar::Create, bueno, da igual llamar a cualquiera, CWnd o CControlBar
  166. //esto debido a que CControlbar se deriva de CWnd y porque ademas CControlBar no sobrecarga el
  167. //metodo Create, nosotros si porque tenemos que particularizar, cosas.
  168. BOOL bResp= CWnd::Create(lpszClassName, lpszWindowName, dwStyle, CRect(0,0,0,0), pParentWnd, nID);
  169. if (!bResp) return FALSE;
  171. return TRUE;
  172. }
  174. int CGuiControlBar::OnCreate(LPCREATESTRUCT lpCreateStruct)
  175. {
  176. if (CControlBar::OnCreate(lpCreateStruct) == -1)
  177. return -1;
  179. // TODO:  Add your specialized creation code here
  180. //aqui es cuando llamamos a nuestra clase CGuiDockContext, de esta manera
  181. //sobrecargamos el clase original que para nuestros propositos no nos sirve.
  182. //porque ?, bueno porque me interesa que no se pegen las toolbar en el interior
  183. //de las ventanas.
  184. if (m_pDockContext==NULL)
  185. m_pDockContext=new CGuiDockContext(this);
  186. ASSERT(m_pDockContext);
  187. m_CloseBtn.SetData(6,_T("Close"));
  188. m_CloseBtn.SetImageList(IDB_GUI_DOCKBAR,9,10,RGB(255,0,255));
  189. m_AutoHideBtn.SetData(12,_T("Auto Hide"));
  190. m_AutoHideBtn.SetImageList(IDB_GUI_DOCKBAR,9,15,RGB(255,0,255));
  191. return 0;
  192. }
  195. void CGuiControlBar::OnShowTitle()
  196. {
  197. ActiveCaption();
  198. SendMessage(WM_NCPAINT);
  199. }
  202. CSize CGuiControlBar::CalcWinPos()
  203. {
  205. POSITION pos = m_pDockSite->m_listControlBars.GetHeadPosition();
  206. DWORD dwDockStyle = m_dwDockStyle;
  207. dwDockStyle &= CBRS_ALIGN_ANY|CBRS_FLOAT_MULTI;
  208. CRect rect;
  209. GetWindowRect(&rect);
  210. while (pos != NULL)
  211. {
  212. CDockBar* pDockBar = (CDockBar*)m_pDockSite->m_listControlBars.GetNext(pos);
  213. if (pDockBar->IsDockBar() && pDockBar->IsWindowVisible() &&
  214. (pDockBar->m_dwStyle & dwDockStyle & CBRS_ALIGN_ANY) &&
  215. (!pDockBar->m_bFloating ||
  216. (dwDockStyle & pDockBar->m_dwStyle & CBRS_FLOAT_MULTI)))
  217. {
  218. CRect rectBar;
  220. pDockBar->GetWindowRect(&rectBar);
  221. if (rectBar.Width() == 0)
  222. rectBar.right++;
  223. if (rectBar.Height() == 0)
  224. rectBar.bottom++;
  225. if (rectBar.IntersectRect(rectBar, rect))
  226. {
  228. int nSize=pDockBar->m_arrBars.GetSize();
  229. int iCont=0;
  230. UINT m_nDockBarID; 
  231. for (int i=0;i <nSize;  i++)
  232. {
  233. m_nDockBarID = pDockBar->GetDlgCtrlID();
  234. CControlBar* pBar;
  235. pBar = (CControlBar*) pDockBar->m_arrBars[i];
  236. if (HIWORD(pBar) == 0) continue; // placeholder
  237. if (!pBar->IsVisible()) continue;
  238. iCont++;
  239. }
  240. m_pDockSite->GetControlBar(m_nDockBarID)->GetWindowRect(rectBar);
  241. if((pDockBar->m_dwStyle & dwDockStyle) ==CBRS_ALIGN_LEFT)
  242. {
  243. if (iCont==0)
  244. return CSize(m_sizeMinFloating.cx,(rectBar.Height()-4));
  245. else if(iCont>0)
  246. return CSize(m_sizeMinFloating.cx,(rectBar.Height()/iCont));
  247. }
  248. else
  249. {
  250. if (iCont==0)
  251. return CSize((rectBar.Width()-4),m_sizeMinFloating.cy);
  252. else if(iCont>0)
  253. return CSize((rectBar.Width()/iCont),m_sizeMinFloating.cy);
  254. }
  255. }
  256. }
  257. }
  259. /* if (i==1)
  260. return CSize(m_sizeMinFloating.cx,(rcWin.Height()-4));
  261. else if(i>1)
  262. return CSize(m_sizeMinFloating.cx,(rcWin.Height()/i));
  263. else*/
  264. return m_sizeMinFloating;
  266. }
  268. //esta funcion calcula el tama駉 horizontal de la ventana,no importa si esta
  269. //docking a izquierda o derecha o arriba o abajo.Debemos disponer de un espacio equitativo entre todas
  270. //ventanas que se encuentren docking ya sea en una fila o columna.
  271. CSize CGuiControlBar::CalcFixedLayout(BOOL bStretch, BOOL bHorz)
  272. {
  273. //la funcion original toma el ancho o alto dependiendo del sentido que nos
  274. //indica bHorz.
  275. ASSERT_VALID(this);
  277. //se modifica esta rutina para que se ajuste correctamente las ventanas docking
  278. if (IsFloating())
  279. return m_sizeMinFloating;//CalcWinPos();
  280. else
  281. {
  282. //si bStrerch es TRUE significa que esta ventana no se puede hacer
  283. //Docking
  285. if (bStretch)
  286. {
  287. if (bHorz)
  288. return CSize(32767, m_sizeHorz.cy);
  289. else
  290. return CSize(m_sizeVert.cx, 32767);
  291. }
  292. }
  296. int Len=GetHiWid();
  298. //call from GuiDockContext
  299. if (Len==0)
  300. {
  301. if (IsHorz())
  302. return  m_sizeHorz;
  303. else
  304. return  m_sizeVert;
  305. }
  308. int nWidth = GetWidthMax();
  309. int nMinSpace=0;//minimo espacio requerido con lo tama駉s normales
  310. int nMinimo=0;  //minimo espacio de los tama駉s minimos
  311. int nRealBars=0;
  312. int m_First=GetFirstPos();
  315. for (int nPos = m_First; nPos <= m_Last; nPos++)
  316. {
  317. CGuiControlBar* pBar = GetGuiControlBar(nPos,TRUE);
  318. if (pBar== NULL) continue;
  319. if (!pBar->IsVisible()) continue;
  320. if (!pBar->IsKindOf(RUNTIME_CLASS(CGuiControlBar)))
  321. {
  322. CPoint pt(GetMessagePos());
  324. CGuiFrameWnd* mFrame=(CGuiFrameWnd*)m_pDockSite;
  326. if (IsLeft())
  327. mFrame->DockControlBar(pBar,mFrame->m_dockLeft);
  328. if(IsTop())
  329. mFrame->DockControlBar(pBar,mFrame->m_dockTop);
  330. if(IsBottom())
  331. mFrame->DockControlBar(pBar,mFrame->m_dockBottom);
  332. if(IsRight())
  333. mFrame->DockControlBar(pBar,mFrame->m_dockRight);
  336. continue;
  337. }
  339. if (IsVert())
  340.  pBar->m_sizeVert.cx=nWidth;
  341. else
  342. pBar->m_sizeHorz.cy=nWidth; //todas se hacen con el mismo ancho
  343. nMinSpace+=IsVert() ? pBar->m_sizeVert.cy:pBar->m_sizeHorz.cx; //minimo espacio para alinear las barras
  344. nRealBars++; //cuantas barras realmente existen
  348. }
  350. //si el tama駉 de las barras en la fila es mayor que
  351. //el espacio disponible, luego la solucion salomonica es
  352. //repartir el espacio entre todas.
  353. if (nRealBars == 1 )
  354. {
  355. if (bHorz)
  356. return m_sizeHorz= CSize(Len,m_sizeHorz.cy);
  357. else
  358. return m_sizeVert=CSize(m_sizeVert.cx,Len);
  360. }
  364. int niDif=(Len-nMinSpace);//sVert()?8:2);
  366. if (abs(niDif) !=0)
  367. {
  368. BOOL bGrow=FALSE;
  369. if (niDif > 0)
  370. bGrow=TRUE;
  371. niDif=abs(niDif);
  372. while(niDif > 0)
  373. {
  374. for (int nPos = m_First; nPos <= m_Last; nPos++)
  375. {
  376. CGuiControlBar* pBar = GetGuiControlBar(nPos);
  377. if (pBar== NULL) continue;
  378. if(IsVert())
  379. {
  380. if(bGrow)
  381. pBar->m_sizeVert.cy+=1;
  382. else
  383. {
  385. if (pBar->m_sizeVert.cy-1 < 26)
  386. {
  387. niDif--; //bug fixed
  388. continue;
  389. }
  390. pBar->m_sizeVert.cy-=1;
  392. }
  393. }
  394. else
  395. {
  396. if(bGrow)
  397. pBar->m_sizeHorz.cx+=1;
  398. else
  399. {
  401. if (pBar->m_sizeHorz.cx-1 < 26)
  402. {
  403. niDif--; //bug fixed
  404. continue;
  405. }
  406. pBar->m_sizeHorz.cx-=1;
  408. }
  410. }
  412. niDif--;
  413. if(niDif==0) break;
  414. }
  416. }
  418. }
  420.    //--reubicar las ventanas, sin esta rutina nada funciona
  421.   RecalWindowPos();
  423. if (IsHorz())
  424. return  m_sizeHorz;
  425. else
  426. return  m_sizeVert;
  427. }
  430. //esta rutina dispone de la posici髇 en el Dockbar de la pila de  ventanas
  431. void CGuiControlBar::RecalWindowPos()
  432. {
  433. int m_First=GetFirstPos();
  434. int m_Last=GetLastPos();
  435. int m_This=m_pDockBar->FindBar(this);
  437. AFX_SIZEPARENTPARAMS layout;
  438. layout.hDWP =::BeginDeferWindowPos( m_Last);
  440. CRect rcWin=GetDockRect();
  441. int m_VertPos=0;
  442. for(int i=m_First; i<= m_Last; i++)
  443. {
  444. CGuiControlBar* pBar = GetGuiControlBar(i);
  445. if (pBar == NULL) continue;
  446. CRect rcBar;
  447. pBar->GetWindowRect(rcBar);
  448. rcBar.OffsetRect(-rcWin.TopLeft());
  449. if (IsVert())
  450. {
  451.    if (i==m_First)
  452.  {
  453. rcBar.top=0;
  454.  }
  455.  else
  456.   rcBar.top=m_VertPos;
  457. }
  458. else
  459. {
  460. if (i==m_First)
  461. rcBar.left=0;
  462. else
  463.   rcBar.left=m_VertPos;
  464. }
  466. //AfxRepositionWindow(&layout,pBar->m_hWnd,&rcBar);
  467. if (IsVert())
  468. rcBar.bottom=m_VertPos+pBar->m_sizeVert.cy;
  469. else
  470. rcBar.right=m_VertPos+pBar->m_sizeHorz.cx;
  471. pBar->MoveWindow(rcBar,TRUE);
  473. if (IsVert())
  474. m_VertPos+=rcBar.Height();
  475. else
  476. m_VertPos+=rcBar.Width();
  478. }
  479. ASSERT( layout.hDWP != NULL );
  480. if( layout.hDWP != NULL )
  481. {
  482. VERIFY( ::EndDeferWindowPos(layout.hDWP) );
  483. }
  485. //m_pDockSite->DelayRecalcLayout();
  487. }
  489. CRect CGuiControlBar::GetDockRect()
  490. {
  491. CRect rcWin;
  492. if(!m_bAutoHide)
  493. {
  494. if (IsVert())
  495. if (IsLeft())
  496. {
  497. m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_LEFT)->GetWindowRect(rcWin);
  498. CRect rc11;
  499. m_pDockSite->GetControlBar(CBRS_ALIGN_LEFT)->GetWindowRect(rc11);
  500. }
  501. else
  502. m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_RIGHT)->GetWindowRect(rcWin);
  503. else
  504. if(IsBottom())
  505. m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_BOTTOM)->GetWindowRect(rcWin);
  506. else
  507. m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_TOP)->GetWindowRect(rcWin);
  508. }
  509. else
  510. {
  511. if (IsHideVert())
  512. if (IsHideLeft())
  513. {
  514. m_pDockSite->GetControlBar(CBRS_ALIGN_LEFT)->GetWindowRect(rcWin);
  515. CRect rc11;
  516. m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_LEFT)->GetWindowRect(rc11);
  518. }
  519. else
  520. m_pDockSite->GetControlBar(CBRS_ALIGN_RIGHT)->GetWindowRect(rcWin);
  521. else
  522. if(IsHideBottom())
  523. m_pDockSite->GetControlBar(CBRS_ALIGN_BOTTOM)->GetWindowRect(rcWin);
  524. else
  525. m_pDockSite->GetControlBar(CBRS_ALIGN_TOP)->GetWindowRect(rcWin);
  527. }
  528. return rcWin;
  529. }
  531. CRect CGuiControlBar::GetDockRectBck()
  532. {
  533. CRect rcWin=CRect(0,0,0,0);
  534. if (m_nLastAlingDockingBck==AFX_IDW_DOCKBAR_LEFT)
  535. m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_LEFT)->GetWindowRect(rcWin);
  536. else if(m_nLastAlingDockingBck==AFX_IDW_DOCKBAR_RIGHT)
  537. m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_RIGHT)->GetWindowRect(rcWin);
  538. else if(m_nLastAlingDockingBck==AFX_IDW_DOCKBAR_BOTTOM)
  539. m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_BOTTOM)->GetWindowRect(rcWin);
  540. else if(m_nLastAlingDockingBck==AFX_IDW_DOCKBAR_TOP)
  541. m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_TOP)->GetWindowRect(rcWin);
  542. return rcWin;
  543. }
  547. int CGuiControlBar::GetWidthMax()
  548. {
  549. m_pos=m_pDockBar->FindBar(this);
  550. m_Last=GetLastPos();
  551. int nWidth=0;
  552. for (int nPos = GetFirstPos(); nPos <= m_Last; nPos++)
  553. {
  554. CGuiControlBar* pBar = GetGuiControlBar(nPos);
  555. if (pBar== NULL) continue;
  556. nWidth=max(nWidth,IsVert() ? pBar->m_sizeVert.cx:pBar->m_sizeHorz.cy);
  557. }
  558. return nWidth;
  559. }
  563. CGuiControlBar* CGuiControlBar::GetGuiControlBar(int nPos,BOOL bAll) const
  564. {
  565. CGuiControlBar* pResult = (CGuiControlBar*)m_pDockBar->m_arrBars[nPos];
  566. if (bAll==FALSE)
  567. {
  568. if (HIWORD(pResult) == NULL) return NULL;
  569. else if (!pResult->IsVisible()) return NULL;
  570. else if (!pResult->IsKindOf(RUNTIME_CLASS(CGuiControlBar))) return NULL;
  571. }
  572. else
  573. {
  574. if (HIWORD(pResult) == NULL)
  575. return NULL;
  576. }
  577. return pResult;
  578. }
  580. //En esta funci髇 se calcula el tama駉 de la ventana cuando esta flotando
  581. //y gestionar cuando el mouse es presionado en las esquinas.
  582. //#define HTTOPLEFT           13
  583. //#define HTTOPRIGHT          14
  584. //#define HTBOTTOMLEFT        16
  585. //#define HTBOTTOMRIGHT       17
  588. CSize CGuiControlBar::CalcDynamicLayout(int nLength, DWORD nMode)
  589. {
  591. // m_pDockSite->DelayRecalcLayout();
  593. if (IsFloating() && !m_bAutoHide)
  594. {
  595. // Enable diagonal arrow cursor for resizing
  596. //m_sizeVert=m_sizeHorz=CSize(200,200);
  597. GetParent()->GetParent()->ModifyStyle(MFS_4THICKFRAME/*|WS_CAPTION*/,0);
  598. }
  600. if (nMode & (LM_HORZDOCK | LM_VERTDOCK) )
  601. {
  602. m_pDockSite->DelayRecalcLayout();
  603. //obligar a reposicionar  la ventana, de lo contrario cuando vuelva de un doble click
  604. //desde la ventana CMiniFrameWnd queda sin area cliente
  605. if (!m_bAutoHide)
  606. {
  607. SetWindowPos(NULL, 0, 0, 0, 0,
  608. SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER |
  609. SWP_NOACTIVATE | SWP_FRAMECHANGED|SWP_NOREDRAW);
  610. }
  611.   return CControlBar::CalcDynamicLayout(nLength, nMode);
  612. }
  613. if (nMode & LM_MRUWIDTH && !m_bAutoHide)
  614. return  m_sizeMinFloating;
  618. if (nMode & LM_COMMIT && !m_bAutoHide)
  619. return  m_sizeMinFloating ;
  622. if (m_bAutoHide)
  623. {
  624. CRect rcW;
  625. CRect rcC;
  626. CRect rcFrameClient;
  627. GetClientRect(rcC);
  628. if (m_nLastAlingDocking ==CBRS_ALIGN_LEFT)
  629. {
  631. m_pDockSite->GetControlBar(CBRS_ALIGN_LEFT)->GetWindowRect(rcW);
  632. m_sizeMinFloating.cy=rcW.Height();
  633. }
  635. if (m_nLastAlingDocking == CBRS_ALIGN_RIGHT)
  636. {
  637. m_pDockSite->GetControlBar(CBRS_ALIGN_RIGHT)->GetWindowRect(rcW);
  638. m_sizeMinFloating.cy=rcW.Height();
  639. }
  641. if (m_nLastAlingDocking == CBRS_ALIGN_TOP)
  642. {
  643. m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_TOP)->GetWindowRect(rcW);
  644. m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_TOP)->GetWindowRect(rcFrameClient);
  645. m_sizeMinFloating.cx=rcFrameClient.Width();
  646. }
  647. if (m_nLastAlingDocking == CBRS_ALIGN_BOTTOM)
  648. {
  649. m_pDockSite->GetControlBar(CBRS_ALIGN_BOTTOM)->GetWindowRect(rcW);
  650. m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_BOTTOM)->GetWindowRect(rcFrameClient);
  651. m_sizeMinFloating.cx=rcFrameClient.Width();
  652. }
  655. return m_sizeMinFloating;
  657. }
  658. if (IsFloating() && !m_bAutoHide)
  659. {
  661. CRect rcWin;
  662. POINT cpt;
  663. GetCursorPos(&cpt);
  664. GetParent()->GetParent()->GetWindowRect(&rcWin);
  665. int nXOffset=0;int nYOffset=0;
  666. switch (m_pDockContext->m_nHitTest)
  667. {
  669. //------------------------------------------------------------------
  670. case HTLEFT:
  671. m_pDockContext->m_rectFrameDragHorz= rcWin;
  672. m_pDockContext->m_rectFrameDragHorz.left = cpt.x;
  673. m_sizeMinFloating.cx = max(rcWin.right - cpt.x,32)-4 ;
  674. m_sizeMinFloating.cy = max((rcWin.bottom -rcWin.top)-nGapGripper-5,32)+2 ;
  675. return m_sizeMinFloating;
  676. break;
  677. case HTTOP:
  678. m_pDockContext->m_rectFrameDragHorz=rcWin;
  679. m_pDockContext->m_rectFrameDragHorz.top = cpt.y;
  680. m_sizeMinFloating.cx = max(rcWin.right-rcWin.left-2,32)-4 ;
  681. m_sizeMinFloating.cy = max((rcWin.bottom -nGapGripper-cpt.y-3),32) ;
  682. return m_sizeMinFloating;
  683. break;
  684. case HTRIGHT:
  685. m_pDockContext->m_rectFrameDragHorz=rcWin;
  686. m_pDockContext->m_rectFrameDragHorz.right = cpt.x;
  687. m_sizeMinFloating.cy = max(rcWin.bottom -rcWin.top-nGapGripper-3,32) ;
  688. m_sizeMinFloating.cx = max(cpt.x-rcWin.left-4,32);
  689. return m_sizeMinFloating;
  690. break;
  691. case HTBOTTOM:
  692. m_pDockContext->m_rectFrameDragHorz=rcWin;
  693. m_sizeMinFloating.cy = max(cpt.y-rcWin.top -nGapGripper-3,32) ;
  694. m_sizeMinFloating.cx = max(rcWin.right-rcWin.left-2,32)-4 ;
  695. m_pDockContext->m_rectFrameDragHorz.bottom = cpt.y-4;
  696. return m_sizeMinFloating;
  697. break;
  698. case HTTOPLEFT:
  699. //---------------------------------------------------------
  700. //En este caso crece la ventana a izquierda y hacia arriba
  701. //izquierda incrementa cx y top incrementa cy
  702. m_sizeMinFloating.cx = max(rcWin.right - cpt.x,32)-3 ;
  703. m_sizeMinFloating.cy = max(rcWin.bottom -nGapGripper-cpt.y,32)-2 ;
  704. m_pDockContext->m_rectFrameDragHorz.top = cpt.y-1;
  705. m_pDockContext->m_rectFrameDragHorz.left = cpt.x-2;
  707. return m_sizeMinFloating;
  708. break;
  709. case HTTOPRIGHT:
  710. m_sizeMinFloating.cx = max(cpt.x-rcWin.left,32)-4 ;
  711. m_sizeMinFloating.cy = max(rcWin.bottom -nGapGripper-cpt.y,32)-2 ;
  712. m_pDockContext->m_rectFrameDragHorz.top = cpt.y-1;
  713. m_pDockContext->m_rectFrameDragHorz.right = cpt.x-2;
  714. return m_sizeMinFloating;
  715. break;
  716. case HTBOTTOMLEFT:
  717. m_sizeMinFloating.cx = max(rcWin.right - cpt.x,32)-4;
  718. m_sizeMinFloating.cy = max(cpt.y-rcWin.top -nGapGripper,32)-2 ;
  719. m_pDockContext->m_rectFrameDragHorz.top = rcWin.top;
  720. m_pDockContext->m_rectFrameDragHorz.bottom = cpt.y-1;
  721. m_pDockContext->m_rectFrameDragHorz.left = cpt.x-2;
  722. return m_sizeMinFloating;
  723. break;
  724. case HTBOTTOMRIGHT:
  725. m_sizeMinFloating.cx = max(cpt.x-rcWin.left,32);
  726. m_sizeMinFloating.cy = max(cpt.y-rcWin.top -nGapGripper,32) ;
  727. m_pDockContext->m_rectFrameDragHorz.top = rcWin.top;
  728. m_pDockContext->m_rectFrameDragHorz.bottom = cpt.y+1;
  729. m_pDockContext->m_rectFrameDragHorz.right = cpt.x+2;
  730. return m_sizeMinFloating;
  731. break;
  735. }
  737. }
  739. if(nMode & LM_LENGTHY)
  740.  m_sizeMinFloating.cy = max(nLength,32);
  741. else
  742.      m_sizeMinFloating.cx = max(nLength,32);
  743. return m_sizeMinFloating;
  744. }
  746. void CGuiControlBar::ScrollOff()
  747. {
  749. ScrollOnEfect(FALSE);
  750. GetDockingFrame()->ShowControlBar(this, FALSE, FALSE);
  754. }
  756. void CGuiControlBar::ScrollOn()
  757. {
  758. m_sizeMinFloating1=m_sizeMinFloating;
  759. GetDockingFrame()->ShowControlBar(this, TRUE, TRUE);
  760. if (m_nLastAlingDocking ==CBRS_ALIGN_LEFT || m_nLastAlingDocking == CBRS_ALIGN_RIGHT)
  761. {
  762. m_nSizeMed= m_sizeMinFloating.cx/GUI_NUMITER;
  763. m_sizeMinFloating.cx=0;
  764. }
  765. else
  766. {
  767. m_nSizeMed= m_sizeMinFloating.cy/GUI_NUMITER;
  768. m_sizeMinFloating.cy=0;
  769. }
  770. ScrollOnEfect(TRUE);
  773. }
  775. void CGuiControlBar::ScrollOnEfect(BOOL on)
  776. {
  778. CRect rcW;
  779. CRect rcC;
  780. CRect rcFrameClient;
  781. CRect rcWinScroll;
  782. GetClientRect(rcC);
  783. GetWindowRect(rcWinScroll);
  784. CDockBar* pDockBar = m_pDockBar;
  785. CMiniDockFrameWnd* pDockFrame = (CMiniDockFrameWnd*)pDockBar->GetParent();
  786. CFrameWnd* pFrame = reinterpret_cast<CFrameWnd*>(AfxGetMainWnd());
  788. CRect rc1;
  789. m_bComplete=FALSE;
  794. long iWidth80;
  795. long iWidth20;
  797. long iGUI_NUMITER=GUI_NUMITER;
  800. if (IsHideVert())
  801. {
  802. iWidth80=m_sizeMinFloating1.cx/iGUI_NUMITER;
  803. iWidth20=m_sizeMinFloating1.cx/iGUI_NUMITER;
  804. }
  805. else
  806. {
  807. iWidth80=m_sizeMinFloating1.cy/iGUI_NUMITER;
  808. iWidth20=m_sizeMinFloating1.cy/iGUI_NUMITER;
  809. }
  812. for(int i=0; i< iGUI_NUMITER; i++)
  813. {
  815. if (IsHideVert())
  816. {
  817. if (IsHideLeft())
  818. m_pDockSite->GetControlBar(CBRS_ALIGN_LEFT)->GetWindowRect(rcW);
  819. else
  820. m_pDockSite->GetControlBar(CBRS_ALIGN_RIGHT)->GetWindowRect(rcW);
  821. }
  822. else
  823. {
  824. if(IsHideBottom())
  825. {
  826. m_pDockSite->GetControlBar(CBRS_ALIGN_BOTTOM)->GetWindowRect(rcW);
  827. m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_BOTTOM)->GetWindowRect(rcFrameClient);
  828. m_sizeMinFloating.cx=rcFrameClient.Width();
  829. }
  830. else
  831. {
  833. m_pDockSite->GetControlBar(CBRS_ALIGN_TOP)->GetWindowRect(rcW);
  834. m_pDockSite->GetControlBar(AFX_IDW_DOCKBAR_TOP)->GetWindowRect(rcFrameClient);
  835. m_sizeMinFloating.cx=rcFrameClient.Width();
  836. }
  838. }
  840. if (on)
  841. {
  842. if (IsHideVert())
  843. m_sizeMinFloating.cx+=(long)iWidth80;
  844. else
  845. m_sizeMinFloating.cy+=(long)iWidth80;
  846. }
  847. else
  848. {
  849. if (IsHideVert())
  850. m_sizeMinFloating.cx-=(long)iWidth80;
  851. else
  852. m_sizeMinFloating.cy-=(long)iWidth80;
  854. }
  856. if (IsHideVert())
  857. m_sizeMinFloating.cy=rcW.Height()-(rcW.Height()+m_pDockSite->GetControlBar(CBRS_ALIGN_TOP)->IsVisible()?24:0);
  861. if (IsHideVert())
  862. {
  863. if (IsHideLeft())
  864. rc1.left=rcW.right+24;
  865. else
  866. rc1.left=rcW.left-(m_sizeMinFloating.cx+26);
  867. rc1.top=rcW.top;
  868. rc1.right=rc1.left+m_sizeMinFloating.cx;
  869. rc1.bottom=rc1.top+m_sizeMinFloating.cy;
  871. }
  872. else
  873. {
  874. if (IsHideBottom())
  875. rc1.top=rcW.top-(m_sizeMinFloating.cy+26);
  876. else
  877. rc1.top=rcW.bottom+26;
  878. rc1.left=rcFrameClient.left;
  879. rc1.right=rc1.left+m_sizeMinFloating.cx;
  880. rc1.bottom=rc1.top+m_sizeMinFloating.cy;
  882. }
  884. pDockFrame->SetWindowPos(reinterpret_cast<CWnd*>(HWND_TOP),rc1.left,rc1.top, rc1.Width(),rc1.Height(),SWP_HIDEWINDOW);
  886. CRect rcInvalidateClient(rc1);
  887. MapWindowPoints(NULL,&rcInvalidateClient);
  889. pDockFrame->RecalcLayout(TRUE);
  891. pDockFrame->UpdateWindow();
  892. pDockFrame->SetWindowPos(reinterpret_cast<CWnd*>(HWND_TOP), rc1.left,rc1.top, rc1.Width(),rc1.Height(),
  893. SWP_SHOWWINDOW|SWP_NOACTIVATE);
  895. RedrawWindow(&rcInvalidateClient,NULL, RDW_UPDATENOW);
  896. if(!on)
  897. {
  898. pFrame->RecalcLayout(TRUE);
  899. pFrame->UpdateWindow();
  900. pFrame->RedrawWindow(&rcInvalidateClient,NULL,RDW_UPDATENOW);
  901. }
  904. //Sleep(10);
  906. }
  907. m_bComplete=TRUE;
  908. m_sizeMinFloating=m_sizeMinFloating1;
  909. if (!on)
  910. {
  911. pDockFrame->SetWindowPos(reinterpret_cast<CWnd*>(HWND_TOP),rc1.left,rc1.top, rc1.Width(),rc1.Height(),SWP_HIDEWINDOW);
  912. }
  913. else
  914. {
  915. pDockFrame->RecalcLayout(TRUE);
  916. pDockFrame->UpdateWindow();
  917. }
  922. }
  925. void CGuiControlBar::OnTimer(UINT nIDEvent)
  926. {
  927. // TODO: Add your message handler code here and/or call default
  930. if (nIDEvent == 1)
  931. {
  932. if (m_stateBtn==NORMAL) return;
  933. CRect rc;
  934. CPoint pt(GetMessagePos());
  936. CRect rcT=m_rcCloseBtn;
  937. ClientToScreen(rcT);
  938. pt.y+=23;
  939. pt.x+=5;
  940. if (!rcT.PtInRect(pt))
  941. {
  942. m_stateBtn=NORMAL;
  943. KillTimer(1);
  944. SendMessage(WM_NCPAINT);
  945. }
  946. }
  948. if (nIDEvent == 2)
  949. {
  950. if (m_stateAHBtn==NORMAL) return;
  951. CRect rc;
  952. CPoint pt(GetMessagePos());
  954. CRect rcT=m_rcAutoHideBtn;
  955. ClientToScreen(rcT);
  956. pt.y+=23;
  957. pt.x+=5;
  958. if (!rcT.PtInRect(pt))
  959. {
  960. m_stateAHBtn=NORMAL;
  961. KillTimer(2);
  962. SendMessage(WM_NCPAINT);
  963. }
  964. }
  967. CControlBar::OnTimer(nIDEvent);
  968. }
  970. void CGuiControlBar::OnLButtonDblClk(UINT nFlags, CPoint point)
  971. {
  972. // TODO: Add your message handler code here and/or call default
  973. if(m_pDockBar != NULL)
  974. {
  975. ActiveCaption();
  976. // m_pDockContext->ToggleDocking();
  977. }
  978. else
  979. CWnd::OnLButtonDblClk(nFlags, point);
  980. }
  981. void CGuiControlBar::OnLButtonDown(UINT nFlags, CPoint point)
  982. {
  983. // TODO: Add your message handler code here and/or call default
  985. if (m_pDockBar != NULL)
  986.     {
  987.         // start the drag
  988.         ClientToScreen(&point);
  989.        // m_pDockContext->StartDrag(point);
  990.     }
  991.     else
  992. CControlBar::OnLButtonDown(nFlags, point);
  993. }
  995. void CGuiControlBar::OnRButtonDown(UINT nFlags, CPoint point)
  996. {
  997. // TODO: Add your message handler code here and/or call default
  999. if (m_pDockBar != NULL)
  1000.     {
  1001.         // start the drag
  1002.         ReleaseCapture();
  1003.         m_pDockSite->UnlockWindowUpdate();
  1005.     }
  1006.     else
  1007. CControlBar::OnLButtonDown(nFlags, point);
  1011. }
  1013. void CGuiControlBar::OnMouseMove( UINT nHitTest, CPoint point)
  1014. {
  1016. if(m_bTracking)
  1017. {
  1018. if (GetCapture() != this)
  1019. {
  1020. //StopTracking(FALSE);
  1021. m_bTracking=FALSE;
  1022. }
  1024. OnInvertTracker(m_rcBorder);
  1025. //nuevos tama駉s de la ventana
  1026. if (IsVert() || IsHideVert())
  1027. {
  1028. if (m_SideMove==HTLEFT || m_SideMove==HTRIGHT)
  1029. {
  1030. m_rcBorder.left=point.x;
  1031. m_rcBorder.right=m_rcBorder.left+4;
  1033. }
  1034. else
  1035. {
  1036. m_rcBorder.top=point.y+26;
  1037. m_rcBorder.bottom=m_rcBorder.top+4;
  1039. }
  1040. }
  1041. else
  1042. {
  1043. if (m_SideMove==HTBOTTOM || m_SideMove==HTTOP)
  1044. {
  1045. m_rcBorder.top=point.y+26;
  1046. m_rcBorder.bottom=m_rcBorder.top+4;
  1048. }
  1049. else
  1050. {
  1051. m_rcBorder.left=point.x;
  1052. m_rcBorder.right=m_rcBorder.left+4;
  1054. }
  1055. }
  1057. //--------------------------------------------------
  1058. //se hacen iguales todos los tama駉s
  1059. //if(!m_bAutoHide)
  1060. {
  1061. ClientToScreen(&point);
  1062. m_pDockSite->ScreenToClient(&point);
  1063. }
  1064. m_ptActualPos=point;
  1066. OnInvertTracker(m_rcBorder);
  1067. //SetEqualWidth();
  1068. //-----------------------------------------------
  1072. }
  1074. }
  1077. //depende de la posicion se hace igual el tamanio del ancho o alto
  1078. void CGuiControlBar::SetEqualWidth()
  1079. {
  1081. int nFirstPos=GetFirstPos();
  1082. for (int nPos = nFirstPos; nPos <= m_Last; nPos++)
  1083. {
  1084. CGuiControlBar* pBar = GetGuiControlBar(nPos);
  1085. if (pBar== NULL) continue;
  1086. if (IsHorz())
  1087. pBar->m_sizeHorz.cy=m_sizeHorz.cy;//rcDockBar.Height();
  1088. else
  1089. pBar->m_sizeVert.cx=m_sizeVert.cx;
  1090. }
  1091. }
  1093. int CGuiControlBar::GetHiWid()
  1094. {
  1095. CRect rcWin;
  1096. CMenuDockBar* pDock=(CMenuDockBar*)m_pDockBar;
  1097. rcWin=pDock->m_rectLayout; //the real size
  1098. if(IsVert())
  1099. return rcWin.Height();
  1100. else
  1101. return rcWin.Width();
  1103. }
  1106. //espero que funcione el truco
  1107. //la idea es trabajar con coordenadas screen las dimensiones de los bordes del
  1108. //dockBar, mas no con los movimientos internos.
  1109. void CGuiControlBar::OnLButtonUp(UINT nFlags, CPoint point)
  1110. {
  1111. // TODO: Add your message handler code here and/or call default
  1113. CPoint ptTemp=point;
  1114. ClientToScreen(&ptTemp);
  1115. CRect rcFrame;
  1116. CDockBar* pDockBar = m_pDockBar;
  1117. BOOL isMDI=FALSE;
  1118. if (GetParentFrame()->IsKindOf(RUNTIME_CLASS(CGuiMDIFrame)))
  1119. isMDI=TRUE;
  1120.     
  1121. if (m_bAutoHide)
  1122. {
  1123. if (isMDI)
  1124.  ((CGuiMDIFrame*)GetParentFrame())->GetParent()->GetClientRect(rcFrame);
  1125. else 
  1126.  ((CGuiFrameWnd*)GetParentFrame())->GetParent()->GetClientRect(rcFrame);
  1127. }
  1128. else
  1129. {
  1130. if (isMDI)
  1131.  ((CGuiMDIFrame*)GetParentFrame())->GetClientRect(rcFrame);
  1132. else 
  1133.  ((CGuiFrameWnd*)GetParentFrame())->GetClientRect(rcFrame);
  1134. }
  1137. if (m_bTracking)
  1138. {
  1139. ReleaseCapture();
  1140. m_bTracking=FALSE;
  1141. OnInvertTracker(m_rcBorder);
  1142. m_pDockSite->UnlockWindowUpdate();
  1144. if (ptTemp ==m_ptStartPos) return;
  1146. if (IsVert())
  1147. {
  1148. if (m_SideMove==HTLEFT)
  1149. m_sizeVert.cx-=point.x;
  1150. else if(m_SideMove==HTRIGHT)
  1151. m_sizeVert.cx=point.x;
  1152. else if(m_SideMove==HTTOP)
  1153. AjustReDinSize(point);
  1154. }
  1155. else if (IsHorz())
  1156. {
  1157.    if (m_SideMove==HTBOTTOM)
  1158.    {
  1159. if (point.y < 0)
  1160. m_sizeHorz.cy+=abs(point.y);
  1161. else
  1162. m_sizeHorz.cy=point.y;
  1163. }
  1165.    else if (m_SideMove==HTTOP)
  1166.    {
  1167.   if (point.y < 0)
  1168.   m_sizeHorz.cy+=abs(point.y)-12;
  1169.   else
  1170.   m_sizeHorz.cy-=abs(point.y)+12;
  1171.    }
  1172. else if (m_SideMove==HTRIGHT)
  1173.        AjustReDinSize(point);
  1175. }
  1177. if (IsHideVert()== TRUE)
  1178. {
  1181. if (IsHideRight())
  1182. {
  1184. if(point.x<0)
  1185.    m_sizeMinFloating.cx+=abs(point.x);
  1186. else
  1187.    m_sizeMinFloating.cx-=point.x;
  1189. if (m_sizeMinFloating.cx < (rcFrame.Width()-50) && m_sizeMinFloating.cx > 20)
  1190. m_sizeMinFloating1=m_sizeMinFloating;
  1191. else
  1192. {
  1193. m_sizeMinFloating=m_sizeMinFloating1;
  1194. return;
  1195. }
  1196. CRect rc1;
  1197. CMiniDockFrameWnd* pDockFrame = (CMiniDockFrameWnd*)pDockBar->GetParent();
  1198. pDockFrame->GetWindowRect(rc1);
  1200. if(point.x<0)
  1201. rc1.right+=point.x;
  1202. else
  1203. rc1.right-=point.x;
  1204. ClientToScreen(&point);
  1205. pDockFrame->SetWindowPos(reinterpret_cast<CWnd*>(HWND_TOP),point.x-5,rc1.top, rc1.Width(),rc1.Height(),NULL);
  1206. }
  1207. else
  1208. {
  1209. m_sizeMinFloating.cx=point.x+8;
  1210. if (m_sizeMinFloating.cx < (rcFrame.Width()-50) && m_sizeMinFloating.cx > 20)
  1211. m_sizeMinFloating1=m_sizeMinFloating;
  1212. else
  1213. m_sizeMinFloating=m_sizeMinFloating1;
  1214. m_sizeMinFloating1=m_sizeMinFloating;
  1215. GetParentFrame()->RecalcLayout(TRUE);
  1216. }
  1217. return ;
  1218. }
  1219. if (IsHideTop() || IsHideBottom())
  1220. {
  1221. if(IsHideTop())
  1222. {
  1223. m_sizeMinFloating.cy=point.y+25;
  1224. if (m_sizeMinFloating.cy < (rcFrame.Height()-100) && m_sizeMinFloating.cy > 20)
  1225. m_sizeMinFloating1=m_sizeMinFloating;
  1226. else
  1227. {
  1228. m_sizeMinFloating=m_sizeMinFloating1;
  1229. return;
  1230. }
  1232. m_pDockSite->RecalcLayout();
  1233. GetParentFrame()->RecalcLayout(TRUE);
  1234. }
  1235. else
  1236. {
  1237. if(point.y<0)
  1238.    m_sizeMinFloating.cy+=abs(point.y);
  1239. else
  1240.    m_sizeMinFloating.cy-=point.y;
  1241. if (m_sizeMinFloating.cy < (rcFrame.Height()-100) && m_sizeMinFloating.cy > 20)
  1242. m_sizeMinFloating1=m_sizeMinFloating;
  1243. else
  1244. {
  1245. m_sizeMinFloating=m_sizeMinFloating1;
  1246. return ;
  1247. }
  1248. CRect rc1;
  1249. CDockBar* pDockBar = m_pDockBar;
  1250. CMiniDockFrameWnd* pDockFrame = (CMiniDockFrameWnd*)pDockBar->GetParent();
  1251. pDockFrame->GetWindowRect(rc1);
  1253. if(point.y<0)
  1254. rc1.top+=abs(point.y);
  1255. else
  1256. rc1.top-=point.y;
  1257. ClientToScreen(&point);
  1258. //m_sizeMinFloating.cx=rc1.Width();
  1259. //GetDockingFrame()->FloatControlBar(this,rc1.TopLeft());
  1260. pDockFrame->SetWindowPos(reinterpret_cast<CWnd*>(HWND_TOP),rc1.left,point.y, rc1.Width(),rc1.Height(),NULL);
  1262. }
  1264. return;
  1266. }
  1269. if (!m_bAutoHide)
  1270. SetEqualWidth();
  1273. }
  1275. if(!m_bAutoHide)
  1276. m_pDockSite->RecalcLayout();
  1279. }
  1281. //ajusta las ventanas a redimencionarlas verticalmente
  1282. //se decrementa las anteriores ventanas a la actual y se
  1283. //incrementan las posteriores.
  1284. void CGuiControlBar::AjustReDinSize(CPoint point)
  1285. {
  1287. int nFirstPos=GetFirstPos();
  1288. int nLastPos=GetLastPos();
  1289. int m_ThisPos=m_pDockBar->FindBar(this);
  1292. ClientToScreen(&point);
  1294. //si la diferencia es negativa esta barra crece la anterior a esta disminuye
  1295. int nDif=0;
  1296. BOOL bGrow=FALSE;
  1298. if (IsVert())
  1299. {
  1300.  nDif=m_ptStartPos.y- point.y;
  1301.  if (nDif > 0)
  1302. bGrow=TRUE;
  1304.  if (bGrow)
  1305.                 m_sizeVert.cy+=abs(nDif)+4;
  1306.  else
  1307. m_sizeVert.cy-=abs(nDif);
  1309.    if (nFirstPos == m_ThisPos)
  1310. return;
  1312. }
  1313. else
  1314. {
  1315.  nDif=m_ptStartPos.x- point.x;
  1316.  if (nDif < 0)
  1317. bGrow=TRUE;
  1319.  if (bGrow)
  1320. m_sizeHorz.cx+=abs(nDif);
  1321. else
  1322. m_sizeHorz.cx-=abs(nDif);
  1324.          if (nLastPos == m_ThisPos)
  1325. return;
  1326. }
  1329. if (IsVert())
  1330. AjustVert(bGrow,nDif);
  1331. else
  1332. AjustHorz(bGrow,nDif);
  1334. RecalWindowPos();
  1338. }
  1341. void CGuiControlBar::AjustVert(BOOL bGrow,int nDif)
  1342. {
  1343. int nFirstPos=GetFirstPos();
  1344. int nLastPos=GetLastPos();
  1345. int m_ThisPos=m_pDockBar->FindBar(this);
  1347. if(m_SideMove==HTTOP)
  1348. {
  1350. //Esta ventana crece las anteriores reducen su tama駉
  1352. if (bGrow)
  1353. {
  1354. for (int i=m_ThisPos-1; i > 0; i--)
  1355. {
  1356. CGuiControlBar* pBar = GetGuiControlBar(i);
  1357. if (pBar== NULL) return;
  1358. if(IsVert())
  1359. {
  1360. if (pBar->m_sizeVert.cy-abs(nDif) < pBar->m_sizeMinV.cy)
  1361. {
  1362. pBar->m_sizeVert.cy=pBar->m_sizeMinV.cy;
  1363. continue;
  1364. }
  1365. else
  1366. {
  1367. pBar->m_sizeVert.cy-=abs(nDif);
  1368. break;
  1369. }
  1370. }
  1371. }//for
  1373. }//bGrow
  1374. else //este disminuye la anterior crece
  1375. {
  1376. if (m_ThisPos-1 > 0)
  1377. {
  1378. CGuiControlBar* pBar = GetGuiControlBar(m_ThisPos-1);
  1379. if (pBar== NULL) return;
  1380. pBar->m_sizeVert.cy+=abs(nDif);
  1381. if(m_sizeVert.cy > m_sizeMinV.cy)
  1382. return;
  1383. else
  1384.   pBar->m_sizeVert.cy-=m_sizeMinV.cy;
  1385. }
  1386. for (int i=m_ThisPos+1; i >= m_Last; i++)
  1387. {
  1388. CGuiControlBar* pBar = GetGuiControlBar(i);
  1389. if (pBar== NULL) return;
  1390. if(IsVert())
  1391. {
  1392. if (pBar->m_sizeVert.cy-abs(nDif) < pBar->m_sizeMinV.cy)
  1393. continue;
  1394. else
  1395. {
  1396. pBar->m_sizeVert.cy-=abs(nDif);
  1397. return;
  1398. }
  1399. }
  1400. }//for
  1401. }
  1402. }
  1403. }
  1406. void CGuiControlBar::AjustHorz(BOOL bGrow,int nDif)
  1407. {
  1408. int nFirstPos=GetFirstPos();
  1409. int nLastPos=GetLastPos();
  1410. int m_ThisPos=m_pDockBar->FindBar(this);
  1412. if(m_SideMove==HTRIGHT)
  1413. {
  1415. //Esta ventana crece las anteriores reducen su tama駉
  1417. if (bGrow)
  1418. {
  1419. for (int i=m_ThisPos+1; i <= nLastPos; i++)
  1420. {
  1421. CGuiControlBar* pBar = GetGuiControlBar(i);
  1422. if (pBar== NULL) return;
  1423. if(IsHorz())
  1424. {
  1425. if (pBar->m_sizeHorz.cx-abs(nDif) < pBar->m_sizeMinH.cx)
  1426. {
  1427. pBar->m_sizeHorz.cx=pBar->m_sizeMinH.cx;
  1428. continue;
  1429. }
  1430. else
  1431. {
  1432. pBar->m_sizeHorz.cx-=abs(nDif);
  1433. break;
  1434. }
  1435. }
  1436. }//for
  1438. }//bGrow
  1439. else //este disminuye la anterior crece
  1440. {
  1441.    if (m_ThisPos+1 <= m_Last)
  1442. {
  1443. CGuiControlBar* pBar = GetGuiControlBar(m_ThisPos+1);
  1444. if (pBar== NULL) return;
  1445. pBar->m_sizeHorz.cx+=abs(nDif);
  1446. if(m_sizeHorz.cx > m_sizeMinH.cx)
  1447. return;
  1448. else
  1449.   pBar->m_sizeHorz.cx+=abs(nDif);
  1450. }
  1453. for (int i=m_ThisPos-1; i >0; i--)
  1454. {
  1455. CGuiControlBar* pBar = GetGuiControlBar(i);
  1456. if (pBar== NULL) return;
  1457. if(IsHorz())
  1458. {
  1459. if (pBar->m_sizeHorz.cx-abs(nDif) < pBar->m_sizeMinH.cx)
  1460. continue;
  1461. else
  1462. {
  1463. pBar->m_sizeHorz.cx-=abs(nDif);
  1464. return;
  1465. }
  1466. }
  1467. }//for
  1468. }
  1469. }
  1472. }
  1475. //----------------------------------------------------
  1476. //OnActiveWindow retira o asigna el foco a la ventana
  1478. void CGuiControlBar::OnActiveWindow()
  1479. {
  1480. POSITION pos = m_pDockSite->m_listControlBars.GetHeadPosition();
  1481. while (pos != NULL)
  1482. {
  1483. CDockBar* pDockBar = (CDockBar*)m_pDockSite->m_listControlBars.GetNext(pos);
  1484. if (pDockBar->IsDockBar() && pDockBar->IsWindowVisible() &&
  1485. (!pDockBar->m_bFloating || m_bAutoHide))
  1486. {
  1487. int nNumBars=(int)pDockBar->m_arrBars.GetSize();
  1488. for(int i=0; i< nNumBars;i++)
  1489. {
  1490. CGuiControlBar* pBar = (CGuiControlBar*) pDockBar->m_arrBars[i];
  1491. if (HIWORD(pBar) == NULL) continue;
  1492. if (!pBar->IsVisible()) continue;
  1493. if (!pBar->IsKindOf(RUNTIME_CLASS(CGuiControlBar))) continue;
  1494. if (pBar != this)
  1495. {
  1496. pBar->m_bOldActive=FALSE;
  1497. pBar->m_bActive=FALSE;
  1498. pBar->m_bForcepaint=TRUE;
  1499. pBar->SendMessage(WM_NCPAINT);
  1500. pBar->m_bForcepaint=FALSE;
  1501. }
  1502. else
  1503. {
  1504. m_bOldActive=m_bActive;
  1505. m_bActive=TRUE;
  1506. m_bForcepaint=TRUE;
  1507. SendMessage(WM_NCPAINT);
  1508. m_bForcepaint=FALSE;
  1511. }
  1512. }
  1513. }
  1514. }
  1515. }
  1518. void CGuiControlBar::ActiveCaption()
  1519. {
  1520. CWnd* pFocus=SetFocus();
  1521. if(pFocus->GetSafeHwnd())
  1522. IsChild(pFocus);
  1523. m_bForcepaint=TRUE;
  1524. OnActiveWindow();
  1525. m_bForcepaint=FALSE;
  1528. }
  1531. void CGuiControlBar::OnNcRButtonDown(UINT nHitTest, CPoint point)
  1532. {
  1533. // TODO: Add your message handler code here and/or call default
  1534. if (m_bTracking /*|| IsFloating()*/)
  1535.         return;
  1536. // ScreenToScreen (&point);
  1537. CMenu m_menu;
  1538. if (m_MenuContext!=NULL)
  1539. {
  1540. m_menu.LoadMenu(m_MenuContext);
  1541. CMenu* m_SubMenu = m_menu.GetSubMenu(0);
  1542. m_SubMenu->TrackPopupMenu(TPM_LEFTALIGN|TPM_LEFTBUTTON|TPM_VERTICAL,
  1543. point.x, point.y-2, AfxGetMainWnd());
  1544. Invalidate();
  1545. UpdateWindow();
  1546. }
  1548. CWnd::OnNcLButtonDown(nHitTest, point);
  1549. }
  1551. void CGuiControlBar::OnNcLButtonDown(UINT nHitTest, CPoint point)
  1552. {
  1553. // TODO: Add your message handler code here and/or call default
  1554. if (m_bTracking /*|| IsFloating()*/)
  1555.         return;
  1559. m_ptStartPos=point;
  1560. if( nHitTest == HTCAPTION || nHitTest == HTCLOSE || nHitTest == HTPIN)
  1561. ActiveCaption();
  1562. //---------para el boton----
  1563. if( nHitTest == HTCLOSE)
  1564. {
  1565. m_stateBtn=PRESS;
  1566. SendMessage(WM_NCPAINT);
  1567. /*SetTimer(1,100,0);
  1568. CRect rc;
  1570. CGuiMiniFrameWnd* p = new CGuiMiniFrameWnd;
  1571. if (!p->Create(this,this,CRect(100,100,300,400),
  1572. _T("Title"),300))
  1573. {
  1575. }*/
  1576. return;
  1577. }
  1578. if( nHitTest == HTPIN)
  1579. {
  1580. m_stateAHBtn=PRESS;
  1581. SendMessage(WM_NCPAINT);
  1582. /*SetTimer(1,100,0);
  1583. CRect rc;
  1585. CGuiMiniFrameWnd* p = new CGuiMiniFrameWnd;
  1586. if (!p->Create(this,this,CRect(100,100,300,400),
  1587. _T("Title"),300))
  1588. {
  1590. }*/
  1591. return;
  1592. }
  1593. //--------------------------
  1595. if (m_pDockBar != NULL )
  1596. {
  1598. if (HTCAPTION == nHitTest && !m_bAutoHide)
  1599. {
  1600. m_pDockContext->StartDrag(point);
  1601. m_sizeHorzt=m_sizeHorz;
  1602. m_sizeVertt=m_sizeVert;
  1603. }
  1604. if(!m_bTracking)
  1605. {
  1606. if(m_rcBorder.PtInRect(point))
  1607. {
  1609. m_pDockSite->LockWindowUpdate();
  1610. OnInvertTracker(m_rcBorder);
  1612. m_ptStartPos=point;
  1613. SetCapture();
  1614. SetFocus();
  1616. m_bTracking=TRUE;
  1617. m_sizeHorzt=m_sizeHorz;
  1618. m_sizeVertt=m_sizeVert;
  1620. }
  1621. }
  1622. }
  1623. //other bug fixed
  1624. // CWnd::OnNcLButtonDown(nHitTest, point);
  1626. }
  1628. void CGuiControlBar::InitAutoHide()
  1629. {
  1631. if (m_bAutoHide==TRUE)
  1632. {
  1633. m_stateBtn=NORMAL;
  1634. m_sizeMinFloatingBck=m_sizeMinFloating;
  1635. Porc=0.0;
  1636. KillTimer(1);
  1637. CGuiMDIFrame* pB=(CGuiMDIFrame*)pMf;
  1638. pB->FloatControlBar(this,CPoint(400,400));
  1639. if(IsHideRight())
  1640. {
  1641. m_nLastAlingDocking=CBRS_ALIGN_RIGHT;
  1642.   pB->m_dockHideRight.AddToolBars(this);
  1644. }
  1645. if(IsHideLeft())
  1646. {
  1647. m_nLastAlingDocking=CBRS_ALIGN_LEFT;
  1648. pB->m_dockHideLeft.AddToolBars(this);
  1650. }
  1651. if(IsHideTop())
  1652. {
  1653. m_nLastAlingDocking=CBRS_ALIGN_TOP;
  1654. pB->m_dockHideTop.AddToolBars(this);
  1656. }
  1657. if(IsHideBottom())
  1658. {
  1659. m_nLastAlingDocking=CBRS_ALIGN_BOTTOM;
  1660. pB->m_dockHideBottom.AddToolBars(this);
  1662. }
  1665. GetDockingFrame()->ShowControlBar(this, FALSE, FALSE);
  1666. GetDockingFrame()->FloatControlBar(this,CPoint(400,400));
  1667. GetParent()->GetParent()->ModifyStyle(WS_CAPTION,0);
  1668. }
  1669. else
  1670. m_IsLoadDocking=FALSE;
  1671. }
  1673. void CGuiControlBar::OnNcLButtonUp(UINT nHitTest, CPoint point)
  1674. {
  1675. // TODO: Add your message handler code here and/or call default
  1676. CRect rc;
  1677. //------------------ para el boton
  1678. CRect rcT=m_rcCloseBtn;
  1679. ClientToScreen(rcT);
  1680. point.y+=23;
  1681. point.x+=5;
  1682. if (rcT.PtInRect(point))
  1683. {
  1685. if (m_stateBtn ==PRESS)
  1686. {
  1687. m_stateBtn=NORMAL;
  1688. KillTimer(1);
  1689. if (m_bAutoHide)
  1690. {
  1691. m_bAutoHide=FALSE;
  1692. GetParent()->GetParent()->ModifyStyle(WS_CAPTION,1);
  1693. CGuiMDIFrame* pB;
  1694. CGuiFrameWnd* pB1;
  1695. BOOL isMDI=FALSE;
  1697. if (pMf->IsKindOf(RUNTIME_CLASS(CGuiMDIFrame)))
  1698. isMDI=TRUE;
  1700. if (isMDI)
  1701.  pB=(CGuiMDIFrame*)pMf;
  1702. else 
  1703.  pB1= (CGuiFrameWnd*)pMf;
  1707. if(m_nLastAlingDocking==CBRS_ALIGN_RIGHT)
  1708. {
  1709. if (isMDI)
  1710. {
  1711. pB->m_dockHideRight.DeleteToolBars(this);
  1712. pB->DockControlBar(this, AFX_IDW_DOCKBAR_RIGHT);
  1713. }
  1714. else
  1715. {
  1716. pB1->m_dockHideRight.DeleteToolBars(this);
  1717. pB1->DockControlBar(this, AFX_IDW_DOCKBAR_RIGHT);
  1718. }
  1720. }
  1721. if(m_nLastAlingDocking==CBRS_ALIGN_LEFT)
  1722. {
  1723. if (isMDI)
  1724. {
  1725. pB->m_dockHideLeft.DeleteToolBars(this);
  1726. pB->DockControlBar(this, AFX_IDW_DOCKBAR_LEFT);
  1727. }
  1728. else
  1729. {
  1730. pB1->m_dockHideLeft.DeleteToolBars(this);
  1731. pB1->DockControlBar(this, AFX_IDW_DOCKBAR_LEFT);
  1732. }
  1734. }
  1735. if(m_nLastAlingDocking==CBRS_ALIGN_TOP)
  1736. {
  1737. if (isMDI)
  1738. {
  1739. pB->m_dockHideTop.DeleteToolBars(this);
  1740. pB->DockControlBar(this, AFX_IDW_DOCKBAR_TOP);
  1741. }
  1742. else
  1743. {
  1744. pB1->m_dockHideTop.DeleteToolBars(this);
  1745. pB1->DockControlBar(this, AFX_IDW_DOCKBAR_TOP);
  1746. }
  1748. }
  1749. if(m_nLastAlingDocking==CBRS_ALIGN_BOTTOM)
  1750. {
  1751. if (isMDI)
  1752. {
  1753. pB->m_dockHideBottom.DeleteToolBars(this);
  1754. pB->DockControlBar(this, AFX_IDW_DOCKBAR_BOTTOM);
  1755. }
  1756. else
  1757. {
  1758. pB1->m_dockHideBottom.DeleteToolBars(this);
  1759. pB1->DockControlBar(this, AFX_IDW_DOCKBAR_BOTTOM);
  1760. }
  1762. }
  1763. m_nLastAlingDocking=0;
  1764. // SendMessage(WM_NCLBUTTONDBLCLK);
  1766. }
  1767. //--------------------------------------------------------------
  1768. GetDockingFrame()->ShowControlBar(this, FALSE, FALSE);
  1769. }
  1770. SendMessage(WM_NCPAINT);
  1771. m_pDockSite->RecalcLayout();
  1773. return;
  1775. }
  1777. //ojo guardar el aling de la ventana
  1779. rcT=m_rcAutoHideBtn;
  1780. ClientToScreen(rcT);
  1781. if (rcT.PtInRect(point))
  1782. {
  1784. if (m_stateAHBtn ==PRESS)
  1785. {
  1787. if (m_bAutoHide)
  1788. {
  1789. CGuiMDIFrame* pB;
  1790. CGuiFrameWnd* pB1;
  1792. BOOL isMDI=FALSE;
  1794. m_bAutoHide=FALSE;
  1795. m_sizeMinFloating=m_sizeMinFloatingBck;
  1796. GetParent()->GetParent()->ModifyStyle(WS_CAPTION,1);
  1798. pB=(CGuiMDIFrame*)pMf;
  1800. if (pMf->IsKindOf(RUNTIME_CLASS(CGuiMDIFrame)))
  1801. isMDI=TRUE;
  1803. if (isMDI)
  1804.  pB=(CGuiMDIFrame*)pMf;
  1805. else 
  1806.  pB1= (CGuiFrameWnd*)pMf;
  1808. if(m_nLastAlingDocking==CBRS_ALIGN_RIGHT)
  1809. {
  1810. if (isMDI)
  1811. {
  1812. pB->m_dockHideRight.DeleteToolBars(this);
  1813. pB->DockControlBar(this, AFX_IDW_DOCKBAR_RIGHT);
  1814. }
  1815. else
  1816. {
  1817. pB1->m_dockHideRight.DeleteToolBars(this);
  1818. pB1->DockControlBar(this, AFX_IDW_DOCKBAR_RIGHT);
  1819. }
  1821. }
  1822. if(m_nLastAlingDocking==CBRS_ALIGN_LEFT)
  1823. {
  1824. if (isMDI)
  1825. {
  1826. pB->m_dockHideLeft.DeleteToolBars(this);
  1827. pB->DockControlBar(this, AFX_IDW_DOCKBAR_LEFT);
  1828. }
  1829. else
  1830. {
  1831. pB1->m_dockHideLeft.DeleteToolBars(this);
  1832. pB1->DockControlBar(this, AFX_IDW_DOCKBAR_LEFT);
  1833. }
  1835. }
  1836. if(m_nLastAlingDocking==CBRS_ALIGN_TOP)
  1837. {
  1838. if (isMDI)
  1839. {
  1840. pB->m_dockHideTop.DeleteToolBars(this);
  1841. pB->DockControlBar(this, AFX_IDW_DOCKBAR_TOP);
  1842. }
  1843. else
  1844. {
  1845. pB1->m_dockHideTop.DeleteToolBars(this);
  1846. pB1->DockControlBar(this, AFX_IDW_DOCKBAR_TOP);
  1847. }
  1849. }
  1850. if(m_nLastAlingDocking==CBRS_ALIGN_BOTTOM)
  1851. {
  1852. if (isMDI)
  1853. {
  1854. pB->m_dockHideBottom.DeleteToolBars(this);
  1855. pB->DockControlBar(this, AFX_IDW_DOCKBAR_BOTTOM);
  1856. }
  1857. else
  1858. {
  1859. pB1->m_dockHideBottom.DeleteToolBars(this);
  1860. pB1->DockControlBar(this, AFX_IDW_DOCKBAR_BOTTOM);
  1862. }
  1864. }
  1866. GetDockingFrame()->ShowControlBar(this, TRUE, TRUE);
  1867. m_nLastAlingDocking=0;
  1868. // SendMessage(WM_NCLBUTTONDBLCLK);
  1870. }
  1871. else
  1872. {
  1873. m_sizeMinFloatingBck=m_sizeMinFloating;
  1874. m_stateBtn=NORMAL;
  1875. m_bAutoHide=TRUE;
  1876. Porc=0.0;
  1877. KillTimer(1);
  1878. CGuiMDIFrame* pB;
  1879. CGuiFrameWnd* pB1;
  1880. pMf=GetParentFrame();
  1881. BOOL isMDI=FALSE;
  1883. if (pMf->IsKindOf(RUNTIME_CLASS(CGuiMDIFrame)))
  1884. isMDI=TRUE;
  1886. if (isMDI)
  1887.  pB=(CGuiMDIFrame*)pMf;
  1888. else 
  1889.  pB1= (CGuiFrameWnd*)pMf;
  1891. if(IsRight())
  1892. {
  1893. m_nLastAlingDocking=CBRS_ALIGN_RIGHT;
  1894. if (isMDI)
  1895. pB->m_dockHideRight.AddToolBars(this);
  1896. else
  1897. pB1->m_dockHideRight.AddToolBars(this);
  1898. }
  1899. if(IsLeft())
  1900. {
  1901. m_nLastAlingDocking=CBRS_ALIGN_LEFT;
  1902. if (isMDI)
  1903. pB->m_dockHideLeft.AddToolBars(this);
  1904. else
  1905. pB1->m_dockHideLeft.AddToolBars(this);
  1907. }
  1908. if(IsTop())
  1909. {
  1910. m_nLastAlingDocking=CBRS_ALIGN_TOP;
  1911. if (isMDI)
  1912. pB->m_dockHideTop.AddToolBars(this);
  1913. else
  1914. pB1->m_dockHideTop.AddToolBars(this);
  1916. }
  1917. if(IsBottom())
  1918. {
  1919. m_nLastAlingDocking=CBRS_ALIGN_BOTTOM;
  1920. if (isMDI)
  1921. pB->m_dockHideBottom.AddToolBars(this);
  1922. else
  1923. pB1->m_dockHideBottom.AddToolBars(this);
  1925. }
  1927. // if (isMDI)
  1928. {
  1929. GetDockingFrame()->ShowControlBar(this, FALSE, FALSE);
  1930. GetDockingFrame()->FloatControlBar(this,CPoint(400,400));
  1931. }
  1932. /* else
  1933. {
  1934. pB1->ShowControlBar(this, FALSE, FALSE);
  1935. pB1->FloatControlBar(this,CPoint(400,400));
  1936. }*/
  1938. GetParent()->GetParent()->ModifyStyle(WS_CAPTION,0);
  1940. }
  1943. }
  1944. SendMessage(WM_NCPAINT);
  1945. m_pDockSite->RecalcLayout();
  1947. return;
  1949. }
  1951. //-------------------para el boton
  1952. m_pDockSite->RecalcLayout();
  1954. }
  1956. void CGuiControlBar::OnNcPaint()
  1957. {
  1958. // TODO: Add your message handler code here
  1959. // Do not call CControlBar::OnNcPaint() for painting messages
  1960. // Tomo la misma rutina que se desarrolla para la clase
  1961. // CGuiToolBarWnd.
  1962. CRect rcWindow;
  1963. CRect rcClient;
  1964. CWindowDC dc(this);
  1965. CDC m_dc; //contexto de dispositivo en memoria
  1966. CBitmap m_bitmap;
  1967. //la idea es tomar el area de la ventana y area  cliente , luego debemos
  1968. //igualar el area de coordenadas de ventana al cliente
  1969. GetWindowRect(&rcWindow);
  1970. GetClientRect(&rcClient);
  1971. ScreenToClient(rcWindow);
  1972.     rcClient.OffsetRect(-rcWindow.TopLeft());
  1973.     rcWindow.OffsetRect(-rcWindow.TopLeft());
  1975. m_dc.CreateCompatibleDC(&dc);
  1976. m_bitmap.CreateCompatibleBitmap(&dc,rcWindow.Width(),rcWindow.Height());
  1977. CBitmap *m_OldBitmap=m_dc.SelectObject(&m_bitmap);
  1978. //aqui debe utilizarse la brocha que define GuiDrawLayer, si no hacemos la siguiente
  1979. //linea usted vera un horrible color negro, a cambio del dibujo.
  1980. CBrush cb;
  1981. cb.CreateSolidBrush(m_clrFondo);
  1982. m_dc.FillRect(rcWindow, &cb);
  1984. DrawGripper(&m_dc,&rcWindow);
  1985. dc.IntersectClipRect(rcWindow);
  1986.     dc.ExcludeClipRect(rcClient);//asi evitamos el parpadeo
  1987. dc.BitBlt(rcWindow.left,rcWindow.top,rcWindow.Width(),rcWindow.Height(),&m_dc,0,0,SRCCOPY);
  1988. //ReleaseDC(&dc);  //TODO--PAUL
  1989. //::ReleaseDC(m_hWnd, dc.Detach());
  1990. m_dc.SelectObject(m_OldBitmap);
  1991. m_bitmap.DeleteObject();
  1992. m_dc.DeleteDC();
  1993. }
  1995. void CGuiControlBar::DrawGripper(CDC* pDC,CRect* rc)
  1996. {
  1998. CRect gripper = rc;
  1999. gripper.top =3;
  2000. gripper.left+=4;
  2001. if (IsVert())
  2002. gripper.right-=!IsFloating()?!IsRight()?6:3:2;
  2003. else
  2004. gripper.right-=3;
  2005. if(m_StyleDisplay == GUISTYLE_XP)
  2006. gripper.bottom =gripper.top +nGapGripper-3;
  2007. if(m_StyleDisplay == GUISTYLE_2003)
  2008. gripper.bottom =gripper.top +nGapGripper+1;
  2009. //si la ventana esta activa pintamos el caption o el area del titulo de color azul
  2010. if (m_bAutoHide)
  2011. m_bActive=FALSE;
  2012. else if (IsFloating() )
  2013. m_bActive=TRUE;
  2014. if(!m_bActive)
  2015. {
  2016. if (m_StyleDisplay == GUISTYLE_2003)
  2017. {
  2018. CGradient M(CSize(gripper.Width(),gripper.Height()));
  2019. M.PrepareVertical(pDC,m_StyleDisplay);
  2020. M.Draw(pDC,4,0,0,0,gripper.Width(),gripper.Height(),SRCCOPY);
  2021. }
  2023. if (m_StyleDisplay == GUISTYLE_XP)
  2024. {
  2025. CPen cp(PS_SOLID,1,::GetSysColor(COLOR_BTNSHADOW));
  2026. CPen* cpold=pDC->SelectObject(&cp);
  2027. //linea superior
  2028. pDC->MoveTo(gripper.left+1,gripper.top);
  2029. pDC->LineTo(gripper.right,gripper.top);
  2030. //linea izquierda
  2031. pDC->MoveTo(gripper.left,gripper.top+1);
  2032. pDC->LineTo(gripper.left,gripper.bottom);
  2033. //linea inferior
  2034. pDC->MoveTo(gripper.left+1,gripper.bottom);
  2035. pDC->LineTo(gripper.right,gripper.bottom);
  2036. //linea derecha
  2037. pDC->MoveTo(gripper.right,gripper.top+1);
  2038. pDC->LineTo(gripper.right,gripper.bottom);
  2039. pDC->SelectObject(cpold);
  2040. }
  2041. }
  2042. else
  2043. {
  2044. if (m_StyleDisplay == GUISTYLE_XP)
  2045. {
  2046. CBrush cb;
  2047. cb.CreateSolidBrush(::GetSysColor(COLOR_ACTIVECAPTION));//GuiDrawLayer::GetRGBCaptionXP());
  2048. pDC->FillRect(gripper,&cb);
  2049. cb.DeleteObject();
  2050. }
  2052. if (m_StyleDisplay == GUISTYLE_2003)
  2053. {
  2054. CGradient M(CSize(gripper.Width(),gripper.Height()));
  2055. M.PrepareCaption(pDC,m_StyleDisplay);
  2056. M.Draw(pDC,4,0,0,0,gripper.Width(),gripper.Height(),SRCCOPY);
  2057. }
  2058. }
  2060. if(m_StyleDisplay == GUISTYLE_2003) //no es XP
  2061. {
  2063. CRect rcWin=gripper;
  2064. //rcWin.left= gripper.left;
  2065. rcWin.top+=5;
  2066. rcWin.left+=5;
  2067. rcWin.right=rcWin.left+2;
  2068. rcWin.bottom-=4;
  2069. CRect rcBlack;
  2071. for (int i=0; i < rcWin.Height(); i+=4)
  2072. {
  2073. CRect rcWindow;
  2074. CBrush cb;
  2075. cb.CreateSolidBrush(::GetSysColor(COLOR_BTNHIGHLIGHT));
  2076. rcWindow=rcWin;
  2077. rcWindow.top=rcWin.top+i;
  2078. rcWindow.bottom=rcWindow.top+2;
  2079. pDC->FillRect(rcWindow,&cb);
  2080. rcBlack=rcWindow;
  2081. rcBlack.left-=1;
  2082. rcBlack.top=(rcWin.top+i)-1;
  2083. rcBlack.bottom=rcBlack.top+2;
  2084. rcBlack.right=rcBlack.left+2;
  2085. cb.DeleteObject();
  2086. cb.CreateSolidBrush(GuiDrawLayer::GetRGBColorShadow(m_StyleDisplay));
  2087. pDC->FillRect(rcBlack,&cb);
  2089. }
  2093. }
  2096. gripper.DeflateRect(1, 1);
  2097. CString m_caption;
  2098. GetWindowText(m_caption);
  2099. CFont m_cfont;
  2101. m_cfont.CreateFont(-11,0,0,0,400,0,0,0,0,1,2,1,34,_T("Verdana"));
  2103. CFont* m_fontOld=pDC->SelectObject(&m_cfont);
  2104. int nMode = pDC->SetBkMode(TRANSPARENT);
  2105. CString m_cadBreak=m_caption;
  2106. CSize SizeCad=pDC->GetTextExtent(m_cadBreak,m_cadBreak.GetLength());
  2107. CRect rCText=gripper;
  2108. rCText.top=6;
  2109. rCText.bottom =rCText.top+14;
  2111. int cont=m_cadBreak.GetLength();
  2112. if (SizeCad.cx > (gripper.Width()-30))
  2113. {
  2114. while(cont > 1 )
  2115. {
  2116. CString m_scadtemp=m_cadBreak+"...";
  2117. CSize coor=pDC->GetTextExtent(m_scadtemp,m_scadtemp.GetLength());
  2118. if(coor.cx > (gripper.Width()-30))
  2119. {
  2120. m_cadBreak=m_cadBreak.Left(m_cadBreak.GetLength()-1);
  2121. }
  2122. else
  2123. break;
  2124. cont--;
  2126. }
  2127. m_cadBreak+=_T("...");
  2129. }
  2131. if (gripper.Width() > 0 )
  2132. if (!m_bActive)
  2133. pDC->TextOut(rCText.left+8,rCText.top,m_cadBreak);
  2134. else
  2135. {
  2136. if (GuiDrawLayer::m_Style == GUISTYLE_XP)
  2137. pDC->SetTextColor(RGB(255,255,255));
  2138. pDC->TextOut(rCText.left+8,rCText.top,m_cadBreak);
  2139. }
  2140. //CRect gripper;
  2141. //------------------------------------------------
  2142. GetWindowRect( gripper );
  2143. ScreenToClient( gripper );
  2144. gripper.OffsetRect( -gripper.left, -gripper.top );
  2145. gripper.left=gripper.right-20;
  2146. gripper.right-=7;
  2147. gripper.top+=6;
  2148. gripper.bottom=gripper.top+13;
  2149. m_rcAutoHideBtn=gripper;
  2150. m_rcAutoHideBtn.right-=14;
  2151. m_rcAutoHideBtn.left-=14;
  2152. m_rcCloseBtn=gripper;
  2153. //m_rcCloseBtn.left-=4;
  2154. //ClientToScreen(m_rcCloseBtn);
  2155. if(!m_bAutoHide)
  2156. m_AutoHideBtn.SetData(12,_T("Auto Hide"));
  2157. else
  2158. m_AutoHideBtn.SetData(14,_T("Auto Hide"));
  2159. m_CloseBtn.Paint(pDC,m_stateBtn,gripper,NULL_BRUSH,m_bActive && GuiDrawLayer::m_Style != GUISTYLE_2003);
  2160. m_AutoHideBtn.Paint(pDC,m_stateAHBtn,m_rcAutoHideBtn,NULL_BRUSH,m_bActive && GuiDrawLayer::m_Style != GUISTYLE_2003);
  2162. //------------------------------------------------
  2163.   pDC->SetBkMode(nMode);
  2164. pDC->SelectObject(m_fontOld);
  2166. }
  2168. //en esta funci髇 se calcula el area cliente que podra ser utilizado
  2169. //por ventanas que deriven esta clase.
  2170. void CGuiControlBar::OnNcCalcSize(BOOL /*bCalcValidRects*/, NCCALCSIZE_PARAMS* lpncsp)
  2171. {
  2172. // adjust non-client area for border space
  2174. lpncsp->rgrc[0].left +=!IsFloating() || m_bAutoHide ?5:2;
  2175. lpncsp->rgrc[0].top +=!IsFloating() || m_bAutoHide ?nGapGripper+3:3;
  2176. if (IsVert())
  2177. lpncsp->rgrc[0].right -=!IsFloating() || m_bAutoHide?!IsRight()?5:2:2;
  2178. else
  2179. lpncsp->rgrc[0].right -=3;
  2180. lpncsp->rgrc[0].bottom -=!IsFloating()||m_bAutoHide?3:2;
  2182. }
  2185. //Aqui la idea es verificar que si se da clic sobre otra ventana de este tipo
  2186. //automaticamente emita un mensaje eliminando el caption que la identifica como
  2187. //ventana default.
  2189. void CGuiControlBar::OnWindowPosChanged(WINDOWPOS* lpwndpos)
  2190. {
  2192. CRect rc;
  2193. GetClientRect(rc);
  2195. nDockBarAling = GetParent()->GetDlgCtrlID();
  2196. if(!IsFloating())
  2197. m_nLastAlingDockingBck=nDockBarAling;
  2200. //envie un recalculo del area cliente solo si el tama駉 ha sido
  2201. //cambiado, de lo contrario permanezca igual
  2202. lpwndpos->flags |= SWP_FRAMECHANGED;
  2203. CControlBar::OnWindowPosChanged(lpwndpos);
  2205. CWnd* pWnd = GetWindow(GW_CHILD);
  2206. if (!m_bSupportMultiView)
  2207. {
  2208.         if (pWnd != NULL)
  2209.         {
  2210.             pWnd->MoveWindow(rc);
  2211. ASSERT(pWnd->GetWindow(GW_HWNDNEXT) == NULL);
  2212. }
  2213. }
  2214. else
  2215. {
  2216. while (pWnd != NULL)
  2217.         {
  2218.             if (pWnd->IsWindowVisible())
  2219. {
  2220. pWnd->MoveWindow(rc);
  2221. break;
  2222. }
  2223.             pWnd=pWnd->GetWindow(GW_HWNDNEXT);
  2224. }
  2226. }
  2229. }
  2232. //este conjunto de clases nos indican el estado de la ventana
  2233. //en un momento determinado
  2235. BOOL CGuiControlBar::IsHideVert()
  2236. {
  2237. if (m_nLastAlingDocking ==CBRS_ALIGN_LEFT || m_nLastAlingDocking == CBRS_ALIGN_RIGHT)
  2238. return TRUE;
  2239. return FALSE;
  2240. }
  2242. BOOL CGuiControlBar::IsHideLeft()
  2243. {
  2244. if (m_nLastAlingDocking ==CBRS_ALIGN_LEFT) return TRUE;
  2245. return FALSE;
  2246. }
  2248. BOOL CGuiControlBar::IsHideRight()
  2249. {
  2250. if (m_nLastAlingDocking == CBRS_ALIGN_RIGHT) return TRUE;
  2251. return FALSE;
  2252. }
  2254. BOOL CGuiControlBar::IsHideTop()
  2255. {
  2256. if (m_nLastAlingDocking == CBRS_ALIGN_TOP) return TRUE;
  2257. return FALSE;
  2258. }
  2260. BOOL CGuiControlBar::IsHideBottom()
  2261. {
  2262. if (m_nLastAlingDocking == CBRS_ALIGN_BOTTOM) return TRUE;
  2263. return FALSE;
  2264. }
  2268. BOOL CGuiControlBar::IsLeft()
  2269. {
  2270. if (nDockBarAling == AFX_IDW_DOCKBAR_LEFT) return TRUE;
  2271. return FALSE;
  2272. }
  2274. BOOL CGuiControlBar::IsRight()
  2275. {
  2276. if (nDockBarAling == AFX_IDW_DOCKBAR_RIGHT) return TRUE;
  2277. return FALSE;
  2278. }
  2280. BOOL CGuiControlBar::IsTop()
  2281. {
  2282. if (nDockBarAling == AFX_IDW_DOCKBAR_TOP) return TRUE;
  2283. return FALSE;
  2284. }
  2286. BOOL CGuiControlBar::IsBottom()
  2287. {
  2288. if (nDockBarAling == AFX_IDW_DOCKBAR_BOTTOM) return TRUE;
  2289. return FALSE;
  2290. }
  2292. BOOL CGuiControlBar::IsVert()
  2293. {
  2294. if (IsLeft() || IsRight()) return TRUE;
  2295. return FALSE;
  2296. }
  2298. BOOL CGuiControlBar::IsHorz()
  2299. {
  2300. if (IsTop() || IsBottom()) return TRUE;
  2301. return FALSE;
  2302. }
  2304. BOOL CGuiControlBar::IsFloating()
  2305. {
  2306. if (nDockBarAling == AFX_IDW_DOCKBAR_FLOAT) return TRUE;
  2307. return FALSE;
  2309. }
  2310. void CGuiControlBar::OnPaint()
  2311. {
  2312. CPaintDC dc(this); // device context for painting
  2313. m_pDockSite->RecalcLayout();//si quita esto se tiene problemas
  2315. // TODO: Add your message handler code here
  2316. // Do not call CControlBar::OnPaint() for painting messages
  2317. }
  2320. UINT CGuiControlBar::OnNcHitTest(CPoint point)
  2321. {
  2322. // TODO: Add your message handler code here and/or call default
  2323. CRect rcWindow;
  2324. //no se convierte las coordenadas de pantalla porque el punto
  2325. //entregado por esta funci髇 esta dado en el mismo sentido.
  2326. GetWindowRect(rcWindow);
  2327. int it=0;
  2328. // if (IsFloating())
  2329. //        return CControlBar::OnNcHitTest(point);
  2330. CRect rcT=m_rcCloseBtn;
  2331. ClientToScreen(rcT);
  2332. CPoint pt=point;
  2333. pt.y+=23;
  2334. pt.x+=5;
  2335. //pt.Offset(-rcT.left,-rcT.top);
  2336. if (rcT.PtInRect(pt))
  2337. return HTCLOSE;
  2338. rcT=m_rcAutoHideBtn;
  2339. ClientToScreen(rcT);
  2340. pt=point;
  2341. pt.y+=23;
  2342. pt.x+=5;
  2343. if (rcT.PtInRect(pt))
  2344. return HTPIN;
  2346. CRect rcTemp;
  2347. for (int i=0; i< 4; i++)
  2348. {
  2349. rcTemp=rcWindow;
  2350. if (i== 0) //left
  2351. {
  2352. it= rcTemp.left;
  2353. it+=4;
  2354. rcTemp.right=it;
  2355. m_rcBorder=rcTemp;
  2356. if (rcTemp.PtInRect(point))
  2357. if(IsLegal(HTLEFT)) return m_SideMove=HTLEFT;
  2358. }
  2359. if (i==1)  //top
  2360. {
  2361. it= rcTemp.top;
  2362. it+=4;
  2363. rcTemp.bottom=it;
  2364. m_rcBorder=rcTemp;
  2365. if (rcTemp.PtInRect(point))
  2366.  if(IsLegal(HTTOP)) return m_SideMove=HTTOP ;
  2367. }
  2368. if (i==2)  //right
  2369. {
  2370. it= rcTemp.right;
  2371. it-=4;
  2372. rcTemp.left=it;
  2373. m_rcBorder=rcTemp;
  2374. if (rcTemp.PtInRect(point))
  2375. if (IsLegal(HTRIGHT)) return m_SideMove=HTRIGHT;
  2376. }
  2377. if (i==3)  //bottom
  2378. {
  2379. it= rcTemp.bottom;
  2380. it-=4;
  2381. rcTemp.top=it;
  2382. m_rcBorder=rcTemp;
  2383. if (rcTemp.PtInRect(point))
  2384. if (IsLegal(HTBOTTOM))return m_SideMove=HTBOTTOM;
  2385. }
  2387. }
  2388. it=0;
  2389. rcTemp=rcWindow;
  2390. it= rcTemp.top+nGapGripper;
  2391. rcTemp.bottom=it;
  2392. if (rcTemp.PtInRect(point))
  2393. {
  2394. SetCursor(::LoadCursor(NULL,IDC_ARROW));
  2395. return m_SideMove=HTCAPTION;
  2396. }
  2397. return CControlBar::OnNcHitTest(point);
  2398. }
  2400. //-----------------------------------------------------------
  2401. //aqui se verifica que las coordenadas de cambio de tama駉
  2402. //sean las correctas
  2404. BOOL CGuiControlBar::IsLegal(UINT uAlin)
  2405. {
  2406. m_First=GetFirstPos();
  2407. // if (IsFloating()) return FALSE;
  2408. switch(uAlin)
  2409. {
  2410. case HTLEFT:
  2411. if(!m_bAutoHide)
  2412. {
  2413. if (IsHorz() && m_pos >0 && (m_pos != m_Last && m_pos != m_First)) return TRUE;
  2414. if (IsVert() && m_pos <= m_Last && IsRight() ) return TRUE;
  2415. }
  2416. else
  2417. {
  2418. if (!IsHideVert() && m_pos >0 && (m_pos != m_Last && m_pos != m_First)) return TRUE;
  2419. if (IsHideVert() && m_pos <= m_Last && IsHideRight() ) return TRUE;
  2420. }
  2421. return FALSE;
  2422. break;
  2423. case HTTOP:
  2424. if(!m_bAutoHide)
  2425. {
  2426. if (m_pos != m_First && IsVert()) return TRUE;
  2427. if (IsHorz() && m_pos <= m_Last && IsBottom() ) return TRUE;
  2428. }
  2429. else
  2430. {
  2431. if (m_pos != m_First && IsHideVert()) return TRUE;
  2432. if (!IsHideVert() && m_pos <= m_Last && IsHideBottom() ) return TRUE;
  2433. }
  2434. return FALSE;
  2435. break;
  2436. case HTRIGHT:
  2437. if(!m_bAutoHide)
  2438. {
  2439. if (m_pos <= m_Last && IsVert() && IsLeft() ) return TRUE;
  2440. if (IsHorz() && m_pos >0 &&  m_pos != m_Last) return TRUE;
  2441. }
  2442. else
  2443. {
  2444. if (m_pos <= m_Last && IsHideVert() && IsHideLeft() ) return TRUE;
  2445. if (!IsHideVert() && m_pos >0 &&  m_pos != m_Last) return TRUE;
  2446. }
  2448. return FALSE;
  2449. case HTBOTTOM:
  2450. if(!m_bAutoHide)
  2451. {
  2452. if ((m_pos != m_Last && m_pos != m_First) && IsHorz() && IsBottom()) return TRUE;
  2453. if (m_pos <= m_Last && IsHorz() && IsTop()) return TRUE;
  2454. }
  2455. else
  2456. {
  2457. if ((m_pos != m_Last && m_pos != m_First) && !IsHideVert() && IsHideBottom()) return TRUE;
  2458. if (m_pos <= m_Last && !IsHideVert() && IsHideTop()) return TRUE;
  2459. }
  2460. //if (IsVert() && m_pos >0 ) return TRUE;
  2461. return FALSE;
  2462. break;
  2463. }
  2464. return FALSE;
  2465. }
  2469. //----------------------------------------------
  2470. //debemos obtener cuantas barras existen en esta columnas
  2471. //porque si intentamos obtener el conteo con la funciones de dockbar
  2472. //siempre obtendremos nuestra actual barra mas otra de otra fila, por lo que
  2473. //el conteo es incorrecto, luego despues de nuestra barra la siguiente nula
  2474. //es el final de esta fila.
  2476. int CGuiControlBar::GetLastPos()
  2477. {
  2479. int nNumBars=(int)m_pDockBar->m_arrBars.GetSize();
  2480. int m_pos=m_pDockBar->FindBar(this);
  2481. for(int i=m_pos+1; i< nNumBars;i++)
  2482. {
  2483. if (m_pDockBar->m_arrBars[i]== NULL)
  2484.     return i-1;
  2485. }
  2486. return -1;
  2487. }
  2489. //--------------------------------------------
  2490. //esta rutina funciona algo parecido a la anterior
  2491. //con la diferencia que ahora se parte desde la posicion
  2492. //que indetifica m_pos hacia atraz hasta encontrar el nulo
  2493. int CGuiControlBar::GetFirstPos()
  2494. {
  2495. int m_pos=m_pDockBar->FindBar(this);
  2496. for(int i=m_pos; i>=0;i--)
  2497. {
  2498. if (m_pDockBar->m_arrBars[i]== NULL)
  2499.     return i+1;
  2500. }
  2501. return -1;
  2503. }
  2507. //------------------------------------------------------------------------
  2509. BOOL CGuiControlBar::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
  2510. {
  2511. // TODO: Add your message handler code here and/or call default
  2512. if (IsFloating() && !m_bAutoHide) return 0;
  2513. CPoint ptCursor;
  2514. ::GetCursorPos (&ptCursor);
  2515. if(nHitTest == HTLEFT ||nHitTest == HTRIGHT)
  2516. SetCursor(AfxGetApp ()->LoadCursor (AFX_IDC_HSPLITBAR));
  2517. else if(nHitTest == HTTOP ||nHitTest == HTBOTTOM)
  2518. SetCursor(AfxGetApp ()->LoadCursor (AFX_IDC_VSPLITBAR));
  2519. else
  2520. return CControlBar::OnSetCursor(pWnd, nHitTest, message);
  2521. return 1;
  2522. }
  2526. void CGuiControlBar::OnInvertTracker(const CRect& rect)
  2527. {
  2528. ASSERT_VALID(this);
  2529. ASSERT(!rect.IsRectEmpty());
  2531. CRect rcWin=GetDockRect();
  2533. CDC *pDC = m_pDockSite->GetDCEx(NULL,
  2534.         DCX_WINDOW|DCX_CACHE|DCX_LOCKWINDOWUPDATE);
  2535. CRect rcBar;
  2536. GetWindowRect(rcBar);
  2537. if (m_bAutoHide)
  2538. rcWin=rcBar;
  2539. if (IsVert()|| IsHideVert())  //el sentido de las barras es vertical
  2540. {
  2544. if (m_SideMove==HTLEFT || m_SideMove==HTRIGHT) //el mouse esta en el borde izquierdo o derecho
  2545. {
  2547. rcWin.OffsetRect(-rect.left,-rect.top);
  2548. rcWin.top+=10;
  2549. rcWin.left=rect.left+2;
  2550. rcWin.right=rect.right+2;
  2551. }
  2552. else  //el mouse esta el borde de arriba pero de una barra vertical
  2553. {
  2554. rcBar.OffsetRect(-rect.TopLeft());
  2555. rcBar.OffsetRect(CPoint(0,9));
  2556. rcWin=rcBar;
  2557. if (IsLeft() || IsRight())   //a la izquierda
  2558. {
  2560. rcWin.top=rect.top;
  2561. rcWin.bottom=rect.bottom;
  2562. }
  2563. //
  2565. }
  2566. }
  2567. else  //el sentido de las barras es horizontal
  2568. {
  2570. if (m_SideMove==HTTOP || m_SideMove==HTBOTTOM) //el mouse esta en el borde de arriba o abajo
  2571. {
  2572. rcWin.OffsetRect(-rect.left,-rect.top);
  2573. rcWin.top=rect.top-2;
  2574. rcWin.bottom=rect.bottom;
  2575. }
  2576. else //el mouse esta en el borde derecho
  2577. {
  2578. rcBar.OffsetRect(-rect.TopLeft());
  2579. rcBar.OffsetRect(CPoint(0,8));
  2580. rcWin=rcBar;
  2581. if ((IsBottom()|| IsHideBottom()) || (IsTop()|| IsHideTop())) //abajo
  2582. {
  2583. rcWin.left=rect.left+2;
  2584. rcWin.right=rect.right+2;
  2585. }
  2586. }
  2587. }
  2588. ClientToScreen(&rcWin);
  2589. m_pDockSite->ScreenToClient(&rcWin);
  2591. // invert the brush pattern (looks just like frame window sizing)
  2592. CBrush* pBrush = CDC::GetHalftoneBrush();
  2593. HBRUSH hOldBrush = NULL;
  2594. if (pBrush != NULL)
  2595. hOldBrush = (HBRUSH)SelectObject(pDC->m_hDC, pBrush->m_hObject);
  2596. pDC->PatBlt(rcWin.left, rcWin.top, rcWin.Width(), rcWin.Height(), PATINVERT);
  2597. if (hOldBrush != NULL)
  2598. SelectObject(pDC->m_hDC, hOldBrush);
  2599. m_pDockSite->ReleaseDC(pDC);
  2600. }
  2602. /*void CGuiControlBar::OnInvertTracker(const CRect& rect)
  2603. {
  2604. ASSERT_VALID(this);
  2605. ASSERT(!rect.IsRectEmpty());
  2607. CRect rcWin=GetDockRect();
  2609. CDC *pDC = m_pDockSite->GetDCEx(NULL,
  2610.         DCX_WINDOW|DCX_CACHE|DCX_LOCKWINDOWUPDATE);
  2611. CRect rcBar;
  2612. GetParent()->GetWindowRect(rcBar);
  2613. if (m_bAutoHide)
  2614. rcWin=rcBar;
  2615. if (IsVert()|| IsHideVert())  //el sentido de las barras es vertical
  2616. {
  2620. if (m_SideMove==HTLEFT || m_SideMove==HTRIGHT) //el mouse esta en el borde izquierdo o derecho
  2621. {
  2623. rcWin.OffsetRect(-rect.left,-rect.top);
  2624. rcWin.top+=10;
  2625. rcWin.left=rect.left+2;
  2626. rcWin.right=rect.right+2;
  2627. }
  2628. else  //el mouse esta el borde de arriba pero de una barra vertical
  2629. {
  2630. rcBar.OffsetRect(-rect.TopLeft());
  2631. rcBar.OffsetRect(CPoint(0,9));
  2632. rcWin=rcBar;
  2633. if (IsLeft() || IsRight())   //a la izquierda
  2634. {
  2636. rcWin.top=rect.top;
  2637. rcWin.bottom=rect.bottom;
  2638. }
  2639. //
  2641. }
  2642. }
  2643. else  //el sentido de las barras es horizontal
  2644. {
  2646. if (m_SideMove==HTTOP || m_SideMove==HTBOTTOM) //el mouse esta en el borde de arriba o abajo
  2647. {
  2648. rcWin.OffsetRect(-rect.left,-rect.top);
  2649. rcWin.top=rect.top-2;
  2650. rcWin.bottom=rect.bottom-2;
  2651. }
  2652. else //el mouse esta en el borde derecho
  2653. {
  2654. rcBar.OffsetRect(-rect.TopLeft());
  2655. rcBar.OffsetRect(CPoint(0,8));
  2656. rcWin=rcBar;
  2657. if ((IsBottom()|| IsHideBottom()) || (IsTop()|| IsHideTop())) //abajo
  2658. {
  2659. rcWin.left=rect.left+2;
  2660. rcWin.right=rect.right+2;
  2661. }
  2662. }
  2663. }
  2664. ClientToScreen(&rcWin);
  2665. GetParentFrame()->ScreenToClient(&rcWin);
  2667. // invert the brush pattern (looks just like frame window sizing)
  2668. CBrush* pBrush = CDC::GetHalftoneBrush();
  2669. HBRUSH hOldBrush = NULL;
  2670. if (pBrush != NULL)
  2671. hOldBrush = (HBRUSH)SelectObject(pDC->m_hDC, pBrush->m_hObject);
  2672. pDC->PatBlt(rcWin.left, rcWin.top, rcWin.Width(), rcWin.Height(), PATINVERT);
  2673. if (hOldBrush != NULL)
  2674. SelectObject(pDC->m_hDC, hOldBrush);
  2675. m_pDockSite->ReleaseDC(pDC);
  2676. }
  2678. */
  2680. void CGuiControlBar::OnSize(UINT nType, int cx, int cy)
  2681. {
  2682. // CControlBar::OnSize(nType, cx, cy);
  2684. CWnd* pWnd = GetWindow(GW_CHILD);
  2685. if (!m_bSupportMultiView)
  2686. {
  2687.         if (pWnd != NULL)
  2688.         {
  2689.             pWnd->MoveWindow(0, 0, cx, cy);
  2690.             ASSERT(pWnd->GetWindow(GW_HWNDNEXT) == NULL);
  2691. }
  2692. }
  2693. else
  2694. {
  2695. while (pWnd != NULL)
  2696.         {
  2697.             if (pWnd->IsWindowVisible())
  2698. {
  2699. pWnd->MoveWindow(0, 0, cx, cy);
  2700. break;
  2701. }
  2702.             pWnd=pWnd->GetWindow(GW_HWNDNEXT);
  2703. }
  2704. }
  2706. // TODO: Add your message handler code here
  2707. }
  2708. void CGuiControlBar::SetColorFondo(COLORREF clrFondo)
  2709. {
  2710. m_clrFondo=clrFondo;
  2712. }
  2714. //enum State{NORMAL=0,OVER=1,PRESS=2};
  2718. void CGuiControlBar::LoadStateBar(CString sProfile)
  2719. {
  2720. CWinApp* pApp = AfxGetApp();
  2721. TCHAR szSection[256] = {0};
  2722. wsprintf(szSection, _T("%s-Bar%d"),sProfile,GetDlgCtrlID());
  2723. m_sizeHorz.cx=pApp->GetProfileInt(szSection, _T("sizeHorz.cx"),200 );
  2724. m_sizeHorz.cy=pApp->GetProfileInt(szSection, _T("sizeHorz.cy"),100 );
  2725. m_sizeVert.cx=pApp->GetProfileInt(szSection, _T("sizeVert.cx"),200 );
  2726. m_sizeVert.cy=pApp->GetProfileInt(szSection, _T("sizeVert.cy"),100 );
  2727. m_bAutoHide=pApp->GetProfileInt(szSection, _T("AutoHide"),0 );
  2728. m_nLastAlingDocking=pApp->GetProfileInt(szSection, _T("Aling"),0 );
  2729. if (m_bAutoHide)
  2730. InitAutoHide();
  2731. else
  2732. m_nLastAlingDocking=0;
  2735. }
  2737. void CGuiControlBar::SaveBar(CString sProfile)
  2738. {
  2739. CWinApp* pApp = AfxGetApp();
  2740. TCHAR szSection[256] = {0};
  2741. wsprintf(szSection, _T("%s-Bar%d"), sProfile,GetDlgCtrlID());
  2742. pApp->WriteProfileString(szSection, NULL, NULL);
  2743. pApp->WriteProfileInt(szSection, _T("sizeHorz.cx"), m_sizeHorz.cx);
  2744. pApp->WriteProfileInt(szSection, _T("sizeHorz.cy"), m_sizeHorz.cy);
  2745. pApp->WriteProfileInt(szSection, _T("sizeVert.cx"), m_sizeVert.cx);
  2746. pApp->WriteProfileInt(szSection, _T("sizeVert.cy"), m_sizeVert.cy);
  2747. pApp->WriteProfileInt(szSection, _T("AutoHide"), m_bAutoHide);
  2748. pApp->WriteProfileInt(szSection, _T("Aling"), m_nLastAlingDocking);
  2749. }
  2750. void CGuiControlBar::OnNcMouseMove(UINT nHitTest, CPoint point)
  2751. {
  2752. // TODO: Add your message handler code here and/or call default
  2753. if (nHitTest == HTCLOSE)
  2754. if (m_stateBtn != NORMAL) return;
  2756. if (nHitTest == HTPIN)
  2757. if (m_stateAHBtn != NORMAL) return;
  2759. if (nHitTest == HTCLOSE)
  2760. {
  2761. m_stateBtn=OVER;
  2762. SetTimer(1,100,0);
  2763. }
  2765. if (nHitTest == HTPIN)
  2766. {
  2767. m_stateAHBtn=OVER;
  2768. SetTimer(2,100,0);
  2769. }
  2771. SendMessage(WM_NCPAINT);
  2772. CControlBar::OnNcMouseMove(nHitTest, point);
  2773. }
  2780. void CGuiControlBar::OnNcLButtonDblClk(UINT nFlags, CPoint point)
  2781. {
  2782. if(m_pDockBar != NULL && !m_bAutoHide)
  2783. {
  2785. m_pDockContext->ToggleDocking();
  2786. m_rcOldBorder=CRect(0,0,0,0);
  2788. }
  2789. }