void CEGPaneBar::OnMouseMove(UINT nFlags, CPoint point)
{
if ( m_bDragging ) {
CRect rc1( m_dragRect );
if ( IsVertical() ) {
m_dragRect.SetRect( rc1.left, point.y - 5, rc1.right, point.y );
} else {
m_dragRect.SetRect( point.x - 5, rc1.top, point.x, rc1.bottom);
}
if (rc1 != m_dragRect)
{
OnInvertTracker(rc1);
OnInvertTracker(m_dragRect);
}
} else {
CRect rc = GetCloseButtonRect();
if ( rc.PtInRect( point ) ) {
if( !m_bCloseHover ) {
m_bCloseHover = TRUE;
InvalidateCaption();
return;
}
} else {
if ( m_bCloseHover ) {
m_bCloseHover = FALSE;
InvalidateCaption();
return;
}
}
}
CControlBar::OnMouseMove(nFlags, point);
}
void CCoolDialogBar::OnMouseMove(UINT nFlags, CPoint point)
{
if (IsFloating() || !m_bTracking)
{
CControlBar::OnMouseMove(nFlags, point);
return;
}
CPoint cpt = m_rectTracker.CenterPoint();
ClientToWnd(point);
if (IsHorz())
{
if (cpt.y != point.y)
{
OnInvertTracker(m_rectTracker);
m_rectTracker.OffsetRect(0, point.y - cpt.y);
OnInvertTracker(m_rectTracker);
}
}
else
{
if (cpt.x != point.x)
{
OnInvertTracker(m_rectTracker);
m_rectTracker.OffsetRect(point.x - cpt.x, 0);
OnInvertTracker(m_rectTracker);
}
}
}
void CGuiControlBar::OnMouseMove( UINT nHitTest, CPoint point)
{
if(m_bTracking)
{
if (GetCapture() != this)
{
//StopTracking(FALSE);
m_bTracking=FALSE;
}
OnInvertTracker(m_rcBorder);
//nuevos tamaños de la ventana
if (IsVert())
{
if (m_SideMove==HTLEFT || m_SideMove==HTRIGHT)
{
m_rcBorder.left=point.x;
m_rcBorder.right=m_rcBorder.left+4;
}
else
{
m_rcBorder.top=point.y+26;
m_rcBorder.bottom=m_rcBorder.top+4;
}
}
else
{
if (m_SideMove==HTBOTTOM || m_SideMove==HTTOP)
{
m_rcBorder.top=point.y+26;
m_rcBorder.bottom=m_rcBorder.top+4;
}
else
{
m_rcBorder.left=point.x;
m_rcBorder.right=m_rcBorder.left+4;
}
}
//--------------------------------------------------
//se hacen iguales todos los tamaños
ClientToScreen(&point);
GetParentFrame()->ScreenToClient(&point);
m_ptActualPos=point;
OnInvertTracker(m_rcBorder);
//SetEqualWidth();
//-----------------------------------------------
}
}
void CCJSizeDockBar::OnMouseMove(UINT nFlags, CPoint point)
{
if( m_bDragging )
{
CRect rectWin;
GetWindowRect(&rectWin);
CRect rectAvail;
GetAvailableRect(rectAvail);
CFrameWnd *pFrame=GetDockingFrame();
ClientToScreen(&point);
pFrame->ScreenToClient(&point);
UINT nID = ((UINT)(WORD)::GetDlgCtrlID(m_hWnd));
if (nID == AFX_IDW_SIZEBAR_LEFT) {
point.x = point.x>rectAvail.right ? rectAvail.right:point.x;
point.x = point.x<m_iTrackBorderSize ? m_iTrackBorderSize:point.x;
}
else if (nID == AFX_IDW_SIZEBAR_TOP) {
point.y = point.y>rectAvail.bottom ? rectAvail.bottom:point.y;
point.y = point.y<m_iTrackBorderSize ? m_iTrackBorderSize:point.y;
}
else if (nID == AFX_IDW_SIZEBAR_RIGHT) {
point.x = point.x<rectAvail.left ? rectAvail.left:point.x;
point.x = point.x>rectAvail.right+m_iActualSize-m_iTrackBorderSize ? rectAvail.right-m_iTrackBorderSize+m_iActualSize:point.x;
}
else if (nID == AFX_IDW_SIZEBAR_BOTTOM) {
point.y = point.y<rectAvail.top ? rectAvail.top:point.y;
point.y = point.y>rectAvail.bottom+m_iActualSize-m_iTrackBorderSize ? rectAvail.bottom-m_iTrackBorderSize+m_iActualSize:point.y;
}
int deltaX = point.x-m_ptCurDrag.x;
int deltaY = point.y-m_ptCurDrag.y;
m_ptCurDrag = point;
if (nID == AFX_IDW_SIZEBAR_LEFT || nID == AFX_IDW_SIZEBAR_RIGHT && deltaX)
{
OnInvertTracker(m_rcTrack);
m_rcTrack.left+=deltaX;
m_rcTrack.right+=deltaX;
OnInvertTracker(m_rcTrack);
}
else if( nID == AFX_IDW_SIZEBAR_TOP || nID == AFX_IDW_SIZEBAR_BOTTOM && deltaY)
{
OnInvertTracker(m_rcTrack);
m_rcTrack.top+=deltaY;
m_rcTrack.bottom+=deltaY;
OnInvertTracker(m_rcTrack);
}
}
CDockBar::OnMouseMove(nFlags, point);
}
void OnMouseMove(HWND hWnd, UINT nFlags, POINTS p)
{
if (bTracking) // move the tracking image
{
int nWidth;
RECT rect;
POINT pt;
pt.x = (int)p.x;
pt.y = (int)p.y;
ClientToScreen(hWnd, &pt);
GetWindowRect(hWnd, &rect);
if (! PtInRect(&rect, pt))
{
if ((short)pt.x < (short)rect.left)
pt.x = rect.left;
if ((short)pt.x > (short)rect.right)
pt.x = rect.right;
pt.y = rect.top + 1;
}
ScreenToClient(hWnd, &pt);
// Erase the old tracking image
OnInvertTracker(hWnd, &lpCurSpltr->m_dragRect);
// calc the new one based on p.x draw it
nWidth = lpCurSpltr->m_dragRect.right - lpCurSpltr->m_dragRect.left;
lpCurSpltr->m_dragRect.right = pt.x + nWidth / 2;
lpCurSpltr->m_dragRect.left = pt.x - nWidth / 2;
if (pt.x - nWidth / 2 > lpCurSpltr->m_limitRect.right)
{
lpCurSpltr->m_dragRect.right = lpCurSpltr->m_limitRect.right;
lpCurSpltr->m_dragRect.left = lpCurSpltr->m_dragRect.right - nWidth;
}
if (pt.x + nWidth / 2 < lpCurSpltr->m_limitRect.left)
{
lpCurSpltr->m_dragRect.left = lpCurSpltr->m_limitRect.left;
lpCurSpltr->m_dragRect.right = lpCurSpltr->m_dragRect.left + nWidth;
}
OnInvertTracker(hWnd, &lpCurSpltr->m_dragRect);
}
else
{
switch(SplitterHitTest(hWnd, p))
{
case SPLITTER_HITNOTHING:
SetCursor(LoadCursor(0, IDC_ARROW));
break;
case SPLITTER_HITITEM:
SetCursor(hSplitterCursor);
break;
}
}
}
void CEGControlBar::OnLButtonUp(UINT nFlags, CPoint point)
{
if ( m_bDragging )
{
ReleaseCapture();
OnInvertTracker(m_dragRect);
DWORD dwStyle = GetBarStyle();
int nMinHeight = GetSystemMetrics( SM_CYCAPTION ) + SPLITTER_SIZE*2;
int nMinWidth = nMinHeight*4;
if( ( dwStyle & CBRS_TOP ) == CBRS_TOP ) {
m_iSize = point.y > nMinHeight ? point.y : nMinHeight;
} else if( ( dwStyle & CBRS_BOTTOM ) == CBRS_BOTTOM ) {
m_iSize = m_iSize - point.y;
if ( m_iSize < nMinHeight )
m_iSize = nMinHeight;
} else if( ( dwStyle & CBRS_RIGHT ) == CBRS_RIGHT ) {
m_iSize = m_iSize - point.x;
if ( m_iSize < nMinWidth )
m_iSize = nMinWidth;
} else {
m_iSize = point.x > nMinWidth ? point.x : nMinWidth;
}
GetParentFrame()->RecalcLayout();
}
m_bDragging = FALSE;
CControlBar::OnLButtonUp(nFlags, point);
}
void CCJSizeDockBar::OnNcLButtonDown(UINT nHitTest, CPoint point)
{
if( m_bOkToDrag )
{
UINT nID = ((UINT)(WORD)::GetDlgCtrlID(m_hWnd));
CFrameWnd *pFrame=GetDockingFrame();
GetWindowRect(m_rcTrack);
if (nID == AFX_IDW_SIZEBAR_LEFT)
m_rcTrack.left = m_rcTrack.right-m_iTrackBorderSize;
else if (nID == AFX_IDW_SIZEBAR_TOP)
m_rcTrack.top = m_rcTrack.bottom-m_iTrackBorderSize;
else if (nID == AFX_IDW_SIZEBAR_RIGHT)
m_rcTrack.right = m_rcTrack.left+m_iTrackBorderSize;
else if (nID == AFX_IDW_SIZEBAR_BOTTOM)
m_rcTrack.bottom = m_rcTrack.top+m_iTrackBorderSize;
pFrame->ScreenToClient(&m_rcTrack);
pFrame->ScreenToClient(&point);
m_ptStartDrag = point;
m_ptCurDrag = point;
SetCapture();
m_bDragging = TRUE;
OnInvertTracker(m_rcTrack);
}
CDockBar::OnNcLButtonDown(nHitTest, point);
}
void CEGPaneBar::OnLButtonDown(UINT nFlags, CPoint point)
{
if ( m_iSize <= 4 || m_dragRect.PtInRect(point) )
{
m_bDragging = TRUE;
SetDragCursor();
SetCapture();
SetFocus();
CRect rc;
GetClientRect(rc);
OnInvertTracker(m_dragRect);
return;
} else {
if( m_hPane ) {
if( m_hPane != ::SetFocus( m_hPane ) )
InvalidateCaption();
}
CRect rcCloseButton = GetCloseButtonRect();
if ( rcCloseButton.PtInRect( point ) ) {
SetCapture();
m_bClosePressed = TRUE;
InvalidateCaption();
}
}
CControlBar::OnLButtonDown(nFlags, point);
}
void CEGControlBar::OnMouseMove(UINT nFlags, CPoint point)
{
if ( m_bDragging ) {
CRect rc1( m_dragRect );
if ( IsVertical() ) {
m_dragRect.SetRect( rc1.left, point.y - 5, rc1.right, point.y );
} else {
m_dragRect.SetRect( point.x - 5, rc1.top, point.x, rc1.bottom);
}
if (rc1 != m_dragRect)
{
OnInvertTracker(rc1);
OnInvertTracker(m_dragRect);
}
}
CControlBar::OnMouseMove(nFlags, point);
}
void CGuiControlBar::OnNcLButtonDown(UINT nHitTest, CPoint point)
{
// TODO: Add your message handler code here and/or call default
if (m_bTracking /*|| IsFloating()*/)
return;
m_ptStartPos=point;
if( nHitTest == HTCAPTION || nHitTest == HTCLOSE)
ActiveCaption();
//---------para el boton----
if( nHitTest == HTCLOSE)
{
m_stateBtn=PRESS;
SendMessage(WM_NCPAINT);
SetTimer(1,100,0);
return;
}
//--------------------------
if (m_pDockBar != NULL)
{
if (HTCAPTION == nHitTest)
{
m_pDockContext->StartDrag(point);
m_sizeHorzt=m_sizeHorz;
m_sizeVertt=m_sizeVert;
}
if(!m_bTracking)
{
if(m_rcBorder.PtInRect(point))
{
m_pDockSite->LockWindowUpdate();
OnInvertTracker(m_rcBorder);
m_ptStartPos=point;
SetCapture();
SetFocus();
m_bTracking=TRUE;
m_sizeHorzt=m_sizeHorz;
m_sizeVertt=m_sizeVert;
}
}
}
CWnd::OnNcLButtonDown(nHitTest, point);
}
//espero que funcione el truco
//la idea es trabajar con coordenadas screen las dimensiones de los bordes del
//dockBar, mas no con los movimientos internos.
void CGuiControlBar::OnLButtonUp(UINT nFlags, CPoint point)
{
// TODO: Add your message handler code here and/or call default
CPoint ptTemp=point;
ClientToScreen(&ptTemp);
if (m_bTracking)
{
ReleaseCapture();
m_bTracking=FALSE;
OnInvertTracker(m_rcBorder);
m_pDockSite->UnlockWindowUpdate();
if (ptTemp ==m_ptStartPos) return;
if (IsVert())
{
if (m_SideMove==HTLEFT)
m_sizeVert.cx-=point.x;
else if(m_SideMove==HTRIGHT)
m_sizeVert.cx=point.x;
else if(m_SideMove==HTTOP)
AjustReDinSize(point);
}
else
{
if (m_SideMove==HTBOTTOM)
{
if (point.y < 0)
m_sizeHorz.cy+=abs(point.y);
else
m_sizeHorz.cy=point.y;
}
else if (m_SideMove==HTTOP)
{
if (point.y < 0)
m_sizeHorz.cy+=abs(point.y)-12;
else
m_sizeHorz.cy-=abs(point.y)+12;
}
else if (m_SideMove==HTRIGHT)
AjustReDinSize(point);
}
SetEqualWidth();
}
m_pDockSite->RecalcLayout();
}
void CCJControlBar::StopTracking(BOOL bAccept)
{
OnInvertTracker(m_rectTracker);
m_pDockSite->UnlockWindowUpdate();
m_bTracking = FALSE;
ReleaseCapture();
if (!bAccept)
return;
int maxsize, minsize, newsize;
CRect rcc;
m_pDockSite->GetClientRect(rcc);
newsize = IsHorzDocked() ? m_sizeHorz.cy : m_sizeVert.cx;
maxsize = newsize + (IsHorzDocked() ? rcc.Height() : rcc.Width());
minsize = IsHorzDocked() ? m_sizeMin.cy : m_sizeMin.cx;
CPoint point = m_rectTracker.CenterPoint();
switch (m_nDockBarID)
{
case AFX_IDW_DOCKBAR_TOP:
{
newsize += point.y - m_ptOld.y;
break;
}
case AFX_IDW_DOCKBAR_BOTTOM:
{
newsize += -point.y + m_ptOld.y;
break;
}
case AFX_IDW_DOCKBAR_LEFT:
{
newsize += point.x - m_ptOld.x;
break;
}
case AFX_IDW_DOCKBAR_RIGHT:
{
newsize += -point.x + m_ptOld.x;
break;
}
}
newsize = max(minsize, min(maxsize, newsize));
if (IsHorzDocked())
m_sizeHorz.cy = newsize;
else
m_sizeVert.cx = newsize;
m_pDockSite->DelayRecalcLayout();
}
void CCJSizeDockBar::OnLButtonUp(UINT nFlags, CPoint point)
{
if( m_bDragging )
{
CRect rectWin;
CRect rectAvail;
GetWindowRect(&rectWin);
ReleaseCapture();
m_bDragging = FALSE;
OnInvertTracker(m_rcTrack);
GetAvailableRect(rectAvail);
UINT nID = ((UINT)(WORD)::GetDlgCtrlID(m_hWnd));
if (nID == AFX_IDW_SIZEBAR_LEFT ) {
int maxWidth = rectAvail.Width()-m_iSafeSpace;
int newWidth = m_rcTrack.left-m_ptStartDrag.x;
m_iActualSize = newWidth>maxWidth ? maxWidth: newWidth;
m_iActualSize += rectWin.Width();
}
else if (nID == AFX_IDW_SIZEBAR_TOP) {
int maxHeight = rectAvail.Height()-m_iSafeSpace;
int newHeight = m_rcTrack.top-m_ptStartDrag.y;
m_iActualSize = newHeight>maxHeight ? maxHeight : newHeight;
m_iActualSize += rectWin.Height();
}
else if (nID == AFX_IDW_SIZEBAR_RIGHT) {
int maxWidth = rectAvail.Width()-m_iSafeSpace;
int newWidth = m_ptStartDrag.x-m_rcTrack.left;
m_iActualSize = newWidth>maxWidth ? maxWidth: newWidth;
m_iActualSize += rectWin.Width();
}
else if (nID == AFX_IDW_SIZEBAR_BOTTOM) {
int maxHeight = rectAvail.Height()-m_iSafeSpace;
int newHeight = m_ptStartDrag.y-m_rcTrack.top;
m_iActualSize = newHeight>maxHeight ? maxHeight : newHeight;
m_iActualSize += rectWin.Height();
}
if(m_iActualSize<m_iTrackBorderSize )
m_iActualSize = m_iTrackBorderSize;
GetDockingFrame()->RecalcLayout();
RecalcAllExcept(NULL);
}
CDockBar::OnLButtonUp(nFlags, point);
}
static void StartTracking(HWND hWnd, UINT hitArea)
{
if (!bTracking && lpCurSpltr != 0 && hitArea == SPLITTER_HITITEM)
{
// Ensure we have and updated cursor structure
CalcSplitter(hWnd, lpCurSpltr);
// Draw the first splitter shadow
OnInvertTracker(hWnd, &lpCurSpltr->m_dragRect);
// Capture the mouse
SetCapture(hWnd);
// Set tracking to TRUE
bTracking = TRUE;
SetCursor(hSplitterCursor);
}
}
void COutlook2Ctrl::OnLButtonUp(UINT nFlags, CPoint point)
{
if (m_iDragging)
{
ReleaseCapture();
OnInvertTracker(m_dragRect);
m_iSize = point.x + m_iDragoffset;
if (m_iSize < 4) m_iSize = 4;
CFrameWnd* pParentFrame = GetParentFrame ();
pParentFrame->RecalcLayout ();
}
m_iDragging = 0;
OLCTRL2_BASE_CLASS::OnLButtonUp(nFlags, point);
}
void CCoolDialogBar::StartTracking()
{
SetCapture();
// make sure no updates are pending
RedrawWindow(NULL, NULL, RDW_ALLCHILDREN | RDW_UPDATENOW);
m_pDockSite->LockWindowUpdate();
m_ptOld = m_rectBorder.CenterPoint();
m_bTracking = TRUE;
m_rectTracker = m_rectBorder;
if (!IsHorz()) m_rectTracker.bottom -= 4;
OnInvertTracker(m_rectTracker);
}
void CEGControlBar::OnLButtonDown(UINT nFlags, CPoint point)
{
if ( m_iSize <= 4 || m_dragRect.PtInRect(point) )
{
m_bDragging = TRUE;
SetDragCursor();
SetCapture();
SetFocus();
CRect rc;
GetClientRect(rc);
OnInvertTracker(m_dragRect);
return;
}
CControlBar::OnLButtonDown(nFlags, point);
}
static void StopTracking(HWND hWnd)
{
if (bTracking)
{
// erase the tracking image
OnInvertTracker(hWnd, &lpCurSpltr->m_dragRect);
// Release the mouse
ReleaseCapture();
// set tracking to false
bTracking = FALSE;
SetCursor(LoadCursor(0, IDC_ARROW));
// set the new splitter position
nSplitterOffset[currentSplitter] = lpCurSpltr->m_dragRect.left;
// Redraw the screen area
ResizePickerControls(hWnd);
UpdateScreenShot();
InvalidateRect(GetMainWindow(),NULL,TRUE);
}
}
void COutlook2Ctrl::OnLButtonDown(UINT nFlags, CPoint point)
{
if (m_iSize <= 4 || m_dragRect.PtInRect(point))
{
m_iDragoffset = m_iSize - point.x;
m_iDragging = 1;
SetCursor(hDragCur);
SetCapture();
SetFocus();
CRect rc;
GetClientRect(rc);
OnInvertTracker(m_dragRect);
return;
}
int f,i,s;
int r = HitTest(f,i,s,point);
if (r == 1)
{
SetCurFolder(f);
}
if (r == 4)
{
COL2SubItem * ps = GetSubItem(f,i,s);
if (ps->dwStyle == 2 || ps->dwStyle == 3) // item is hotlinked or checkbox
{
AfxGetMainWnd()->SendMessage(WM_COMMAND, MAKELONG(ps->lParam, 0), (LPARAM) GetSafeHwnd());
InvalidateRect(rcInnerRect, FALSE);
}
if (ps->dwStyle == 0 || ps->dwStyle == 1) // item is radio or singlelist .. check before sending
{
COL2CCmdUI pui;
pui.pSI = ps;
pui.m_nID = ps->lParam;
AfxGetMainWnd()->OnCmdMsg(pui.m_nID, CN_UPDATE_COMMAND_UI, &pui, NULL);
if (!(pui.iRes & 2)) // not checked yet .. so let's do it
AfxGetMainWnd()->SendMessage(WM_COMMAND, MAKELONG(ps->lParam, 0), (LPARAM) GetSafeHwnd());
InvalidateRect(rcInnerRect, FALSE);
}
}
OLCTRL2_BASE_CLASS::OnLButtonDown(nFlags, point);
}
void CEGPaneBar::OnLButtonUp(UINT nFlags, CPoint point)
{
if ( m_bDragging )
{
ReleaseCapture();
OnInvertTracker(m_dragRect);
DWORD dwStyle = GetBarStyle();
CRect rcCaption = GetCaptionRect();
int nMinHeight = rcCaption.Height() + SPLITTER_SIZE*2;
int nMinWidth = nMinHeight*4;
if( ( dwStyle & CBRS_TOP ) == CBRS_TOP ) {
m_iSize = point.y > nMinHeight ? point.y : nMinHeight;
} else if( ( dwStyle & CBRS_BOTTOM ) == CBRS_BOTTOM ) {
m_iSize = m_iSize - point.y;
if ( m_iSize < nMinHeight )
m_iSize = nMinHeight;
} else if( ( dwStyle & CBRS_RIGHT ) == CBRS_RIGHT ) {
m_iSize = m_iSize - point.x;
if ( m_iSize < nMinWidth )
m_iSize = nMinWidth;
} else {
m_iSize = point.x > nMinWidth ? point.x : nMinWidth;
}
GetParentFrame()->RecalcLayout();
}
m_bDragging = FALSE;
BOOL bOldClosePressed = m_bClosePressed;
m_bClosePressed = FALSE;
if ( bOldClosePressed ) {
ReleaseCapture();
CRect rcCloseButton = GetCloseButtonRect();
if ( rcCloseButton.PtInRect( point ) ) {
HidePane( );
} else {
InvalidateCaption();
}
}
CControlBar::OnLButtonUp(nFlags, point);
}
void duSplitter::OnMouseMove(POINT pt)
{
duPlugin *pFPlugin = GetPluginByName(m_szFName);
duPlugin *pSPlugin = GetPluginByName(m_szSName);
if (!Plugin_IsValid(pFPlugin) || !Plugin_IsValid(pSPlugin))
return;
if (GetState() == DU_STATE_NORMAL)
{
Plugin_SetState(this, DU_STATE_OVER);
Plugin_Redraw(this, TRUE);
}
if (m_fTracking)
{
duRect rectFirst;
Plugin_GetRect(pFPlugin, &rectFirst);
duRect rectSplitter;
Plugin_GetRect(this, &rectSplitter);
duRect rectSecond;
Plugin_GetRect(pSPlugin, &rectSecond);
duRect rectTracking = rectSplitter;
if (m_fVert)
{
int yOffset = pt.y - m_ptStart.y;
rectTracking.OffsetRect(0, yOffset);
int nFirstMinY = rectFirst.top + m_nFMinPixel + (m_ptStart.y - rectSplitter.top);
int nSecondMinY = rectSecond.bottom - m_nSMinPixel - (rectSplitter.bottom - m_ptStart.y);
if (pt.y >= nFirstMinY && pt.y <= nSecondMinY)
{
OnInvertTracker(m_rectLast);
OnInvertTracker(rectTracking);
m_rectLast = rectTracking;
}
else
{
if (pt.y < nFirstMinY && m_rectLast.top != (rectFirst.top + m_nFMinPixel))
{
int nSplitterHeight = m_rectLast.Height();
rectTracking.top = rectFirst.top + m_nFMinPixel;
rectTracking.bottom = rectTracking.top + nSplitterHeight;
OnInvertTracker(m_rectLast);
OnInvertTracker(rectTracking);
m_rectLast = rectTracking;
}
if (pt.y > nSecondMinY && m_rectLast.bottom != (rectSecond.bottom - m_nSMinPixel))
{
int nSplitterHeight = m_rectLast.Height();
rectTracking.bottom = rectSecond.bottom - m_nSMinPixel;
rectTracking.top = rectTracking.bottom - nSplitterHeight;
OnInvertTracker(m_rectLast);
OnInvertTracker(rectTracking);
m_rectLast = rectTracking;
}
}
}
else
{
int xOffset = pt.x - m_ptStart.x;
rectTracking.OffsetRect(xOffset, 0);
int nFirstMinX = rectFirst.left + m_nFMinPixel + (m_ptStart.x - rectSplitter.left);
int nSecondMinX = rectSecond.right - m_nSMinPixel - (rectSplitter.right - m_ptStart.x);
if (pt.x >= nFirstMinX && pt.x <= nSecondMinX)
{
OnInvertTracker(m_rectLast);
OnInvertTracker(rectTracking);
m_rectLast = rectTracking;
}
else
{
if (pt.x < nFirstMinX && m_rectLast.left != (rectFirst.left + m_nFMinPixel))
{
int nSplitterWidth = m_rectLast.Width();
rectTracking.left = rectFirst.left + m_nFMinPixel;
rectTracking.right = rectTracking.left + nSplitterWidth;
OnInvertTracker(m_rectLast);
OnInvertTracker(rectTracking);
m_rectLast = rectTracking;
}
if (pt.x > nSecondMinX && m_rectLast.right != (rectSecond.right - m_nSMinPixel))
{
int nSplitterWidth = m_rectLast.Width();
rectTracking.right = rectSecond.right - m_nSMinPixel;
rectTracking.left = rectTracking.right - nSplitterWidth;
OnInvertTracker(m_rectLast);
OnInvertTracker(rectTracking);
m_rectLast = rectTracking;
}
}
}
//static int count = 0;
//if (rectTracking.Height() != 10)
//{
// __asm int 3;
//_TRACE("[%d] pointClient (%d, %d)\r\n", count, pointClient.x, pointClient.y);
//_TRACE("[%d] m_ptStart (%d, %d)\r\n", count, m_ptStart.x, m_ptStart.y);
//_TRACE("[%d] rectFirst (%d, %d, %d, %d)\r\n", count, rectFirst.left, rectFirst.top, rectFirst.right, rectFirst.bottom);
//_TRACE("[%d] rectSecond (%d, %d, %d, %d)\r\n", count, rectSecond.left, rectSecond.top, rectSecond.right, rectSecond.bottom);
//_TRACE("[%d] rectTracking(%d, %d, %d, %d,) Width : %d, Height : %d\r\n",
// count, rectTracking.left, rectTracking.top, rectTracking.right, rectTracking.bottom, rectTracking.Width(), rectTracking.Height());
// count++;
//}
}
}
void COutlook2Ctrl::OnMouseMove(UINT nFlags, CPoint point)
{
if (m_iDragging == 1)
{
CRect rc1(m_dragRect);
m_dragRect.SetRect(point.x-5 + m_iDragoffset, rc1.top, point.x + m_iDragoffset, rc1.bottom);
if (rc1 != m_dragRect)
{
OnInvertTracker(rc1);
OnInvertTracker(m_dragRect);
}
}
else
{
int f,i,s;
int r = HitTest(f,i,s,point);
if (r == 1)
{
CClientDC dc(this);
if (iHiFolder >= 0 && iHiFolder != f)
{
DrawButton(&dc, (COL2Folder *) m_Folders.GetAt(iHiFolder), iHiFolder == m_iSelectedFolder, false);
}
if (iHiFolder != f)
{
iHiFolder = f;
DrawButton(&dc, (COL2Folder *) m_Folders.GetAt(iHiFolder), iHiFolder == m_iSelectedFolder, true);
}
}
if (r == 4)
{
COL2SubItem * ps = GetSubItem(f,i,s);
CClientDC dc(this);
if (pLastHilink && pLastHilink != ps)
{
DrawSubItem(&dc, GetFolder(iHilinkFolder), GetItem(iHilinkFolder, iHilinkItem), pLastHilink, false);
}
if (pLastHilink != ps)
{
pLastHilink = ps;
DrawSubItem(&dc, GetFolder(f), GetItem(f,i), ps, true);
iHilinkFolder = f;
iHilinkItem = i;
}
}
if (r == 0)
{
if (iHiFolder >= 0)
{
CClientDC dc(this);
DrawButton(&dc, (COL2Folder *) m_Folders.GetAt(iHiFolder), iHiFolder == m_iSelectedFolder, false);
iHiFolder = -1;
}
if (pLastHilink != NULL)
{
CClientDC dc(this);
DrawSubItem(&dc, GetFolder(iHilinkFolder), GetItem(iHilinkFolder, iHilinkItem), pLastHilink, false);
pLastHilink = NULL;
}
}
}
OLCTRL2_BASE_CLASS::OnMouseMove(nFlags, point);
}
void CDynSplitterWnd::StopTracking(BOOL bAccept)
{
ASSERT_VALID(this);
if (!m_bTracking)
return;
ReleaseCapture();
// erase tracker rectangle
OnInvertTracker(m_rectTracker);
if (m_bTracking2)
OnInvertTracker(m_rectTracker2);
m_bTracking = m_bTracking2 = FALSE;
// save old active view
CWnd* pOldActiveView = GetActivePane();
// m_rectTracker is set to the new splitter position (without border)
// (so, adjust relative to where the border will be)
m_rectTracker.OffsetRect(-CX_BORDER , -CY_BORDER);
m_rectTracker2.OffsetRect(-CX_BORDER, -CY_BORDER);
if (bAccept)
{
if (m_htTrack == vSplitterBox)
{
SplitRow(m_rectTracker.top);
}
else if (m_htTrack >= vSplitterBar1 && m_htTrack <= vSplitterBar15)
{
// set row height
TrackRowSize(m_rectTracker.top, m_htTrack - vSplitterBar1);
RecalcLayout();
}
else if (m_htTrack == hSplitterBox)
{
SplitColumn(m_rectTracker.left);
}
else if (m_htTrack >= hSplitterBar1 && m_htTrack <= hSplitterBar15)
{
// set column width
TrackColumnSize(m_rectTracker.left, m_htTrack - hSplitterBar1);
RecalcLayout();
}
else if (m_htTrack >= splitterIntersection1 &&
m_htTrack <= splitterIntersection225)
{
// set row height and column width
int row = (m_htTrack - splitterIntersection1) / 15;
int col = (m_htTrack - splitterIntersection1) % 15;
TrackRowSize(m_rectTracker.top, row);
TrackColumnSize(m_rectTracker2.left, col);
RecalcLayout();
}
else if (m_htTrack == bothSplitterBox)
{
// rectTracker is vSplitter (splits rows)
// rectTracker2 is hSplitter (splits cols)
SplitRow(m_rectTracker.top);
SplitColumn(m_rectTracker2.left);
}
}
if ( (pOldActiveView == GetActivePane()) &&
(pOldActiveView != NULL)
)
SetActivePane(-1, -1, pOldActiveView); // re-activate
}
void CDynSplitterWnd::OnMouseMove(UINT nFlags, CPoint pt)
{
if(!m_bDynSplit)
{
CSplitterWnd::OnMouseMove(nFlags, pt);
return;
}
if (GetCapture() != this)
StopTracking(FALSE);
if (m_bTracking)
{
// move tracker to current cursor position
pt.Offset(m_ptTrackOffset); // pt is the upper right of hit detect
// limit the point to the valid split range
if (pt.y < m_rectLimit.top)
pt.y = m_rectLimit.top;
else if (pt.y > m_rectLimit.bottom)
pt.y = m_rectLimit.bottom;
if (pt.x < m_rectLimit.left)
pt.x = m_rectLimit.left;
else if (pt.x > m_rectLimit.right)
pt.x = m_rectLimit.right;
if (m_htTrack == vSplitterBox ||
m_htTrack >= vSplitterBar1 && m_htTrack <= vSplitterBar15)
{
if (m_rectTracker.top != pt.y)
{
OnInvertTracker(m_rectTracker);
m_rectTracker.OffsetRect(0, pt.y - m_rectTracker.top);
OnInvertTracker(m_rectTracker);
}
}
else if (m_htTrack == hSplitterBox ||
m_htTrack >= hSplitterBar1 && m_htTrack <= hSplitterBar15)
{
if (m_rectTracker.left != pt.x)
{
OnInvertTracker(m_rectTracker);
m_rectTracker.OffsetRect(pt.x - m_rectTracker.left, 0);
OnInvertTracker(m_rectTracker);
}
}
else if (m_htTrack == bothSplitterBox ||
(m_htTrack >= splitterIntersection1 &&
m_htTrack <= splitterIntersection225))
{
if (m_rectTracker.top != pt.y)
{
OnInvertTracker(m_rectTracker);
m_rectTracker.OffsetRect(0, pt.y - m_rectTracker.top);
OnInvertTracker(m_rectTracker);
}
if (m_rectTracker2.left != pt.x)
{
OnInvertTracker(m_rectTracker2);
m_rectTracker2.OffsetRect(pt.x - m_rectTracker2.left, 0);
OnInvertTracker(m_rectTracker2);
}
}
OnLButtonUp(MK_LBUTTON,pt);
OnLButtonDown(MK_LBUTTON,pt);
if(m_OldPoint != pt)
{
RedrawWindow(NULL, NULL, RDW_ALLCHILDREN | RDW_UPDATENOW);
m_OldPoint = pt;
}
}
else
{
// simply hit-test and set appropriate cursor
int ht = HitTest(pt);
SetSplitCursor(ht);
}
}
