src/TortoiseMerge/XSplitter.cpp

   1 // TortoiseMerge - a Diff/Patch program
   2
   3 // Copyright (C) 2006 - Stefan Kueng
   4
   5 // This program is free software; you can redistribute it and/or
   6 // modify it under the terms of the GNU General Public License
   7 // as published by the Free Software Foundation; either version 2
   8 // of the License, or (at your option) any later version.
   9
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software Foundation,
  17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 //
  19 #include "stdafx.h"
  20 #include "XSplitter.h"
  21
  22 #ifdef _DEBUG
  23 #define new DEBUG_NEW
  24 #undef THIS_FILE
  25 static char THIS_FILE[] = __FILE__;
  26 #endif
  27
  28 CXSplitter::CXSplitter()
  29 {
  30         m_bBarLocked=FALSE;
  31         m_nHiddenCol = -1;
  32         m_nHiddenRow = -1;
  33 }
  34
  35 CXSplitter::~CXSplitter()
  36 {
  37 }
  38
  39 BEGIN_MESSAGE_MAP(CXSplitter, CSplitterWnd)
  40         ON_WM_LBUTTONDOWN()
  41         ON_WM_MOUSEMOVE()
  42         ON_WM_SETCURSOR()
  43 END_MESSAGE_MAP()
  44
  45 void CXSplitter::OnLButtonDown(UINT nFlags, CPoint point)
  46 {
  47         if (!m_bBarLocked)
  48                 CSplitterWnd::OnLButtonDown(nFlags, point);
  49 }
  50
  51 void CXSplitter::OnMouseMove(UINT nFlags, CPoint point)
  52 {
  53         if (!m_bBarLocked)
  54                 CSplitterWnd::OnMouseMove(nFlags, point);
  55         else
  56                 CWnd::OnMouseMove(nFlags, point);
  57 }
  58
  59 BOOL CXSplitter::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
  60 {
  61         if (!m_bBarLocked)
  62                 return CWnd::OnSetCursor(pWnd, nHitTest, message);
  63
  64         return CSplitterWnd::OnSetCursor(pWnd, nHitTest, message);
  65 }
  66
  67 BOOL CXSplitter::ReplaceView(int row, int col,CRuntimeClass * pViewClass,SIZE size)
  68 {
  69         CCreateContext context;
  70         BOOL bSetActive;
  71
  72         if ((GetPane(row,col)->IsKindOf(pViewClass))==TRUE)
  73                 return FALSE;
  74
  75         // Get pointer to CDocument object so that it can be used in the creation
  76         // process of the new view
  77         CDocument * pDoc= ((CView *)GetPane(row,col))->GetDocument();
  78         CView * pActiveView=GetParentFrame()->GetActiveView();
  79         if (pActiveView==NULL || pActiveView==GetPane(row,col))
  80                 bSetActive=TRUE;
  81         else
  82                 bSetActive=FALSE;
  83
  84         // set flag so that document will not be deleted when view is destroyed
  85         pDoc->m_bAutoDelete=FALSE;
  86         // Delete existing view
  87         ((CView *) GetPane(row,col))->DestroyWindow();
  88         // set flag back to default
  89         pDoc->m_bAutoDelete=TRUE;
  90
  91         // Create new view
  92         context.m_pNewViewClass=pViewClass;
  93         context.m_pCurrentDoc=pDoc;
  94         context.m_pNewDocTemplate=NULL;
  95         context.m_pLastView=NULL;
  96         context.m_pCurrentFrame=NULL;
  97
  98         CreateView(row,col,pViewClass,size, &context);
  99
 100         CView * pNewView= (CView *)GetPane(row,col);
 101
 102         if (bSetActive==TRUE)
 103                 GetParentFrame()->SetActiveView(pNewView);
 104
 105         RecalcLayout();
 106         GetPane(row,col)->SendMessage(WM_PAINT);
 107
 108         return TRUE;
 109 }
 110
 111 void CXSplitter::HideRow(int nRowHide)
 112 {
 113         ASSERT_VALID( this );
 114         ASSERT( m_nRows > 1 );
 115         ASSERT( nRowHide < m_nRows );
 116         ASSERT( m_nHiddenRow == -1 );
 117         m_nHiddenRow = nRowHide;
 118
 119         int nActiveRow, nActiveCol;
 120
 121         // if the nRow has an active window -- change it
 122         if( GetActivePane( &nActiveRow, &nActiveCol ) != NULL )
 123         {
 124                 if( nActiveRow == nRowHide )
 125                 {
 126                         if( ++nActiveRow >= m_nRows )
 127                                 nActiveRow = 0;
 128                         SetActivePane( nActiveRow, nActiveCol );
 129                 }
 130         }
 131
 132         // hide all nRow panes.
 133         for( int nCol = 0; nCol < m_nCols; ++nCol )
 134         {
 135                 CWnd* pPaneHide = GetPane( nRowHide, nCol );
 136                 ASSERT( pPaneHide != NULL );
 137
 138                 pPaneHide->ShowWindow( SW_HIDE );
 139                 pPaneHide->SetDlgCtrlID( AFX_IDW_PANE_FIRST+nCol * 16+m_nRows );
 140
 141                 for( int nRow = nRowHide+1; nRow < m_nRows; ++nRow )
 142                 {
 143                         CWnd* pPane = GetPane( nRow, nCol );
 144                         ASSERT( pPane != NULL );
 145
 146                         pPane->SetDlgCtrlID( IdFromRowCol( nRow-1, nCol ));
 147                 }
 148         }
 149
 150         m_nRows--;
 151         m_pRowInfo[m_nRows].nCurSize = m_pRowInfo[nRowHide].nCurSize;
 152         RecalcLayout();
 153 }
 154
 155 void CXSplitter::ShowRow()
 156 {
 157         ASSERT_VALID( this );
 158         ASSERT( m_nRows < m_nMaxRows );
 159         ASSERT( m_nHiddenRow != -1 );
 160
 161         int nShowRow = m_nHiddenRow;
 162         m_nHiddenRow = -1;
 163
 164         int cyNew = m_pRowInfo[m_nRows].nCurSize;
 165         m_nRows++;  // add a nRow
 166
 167         ASSERT( m_nRows == m_nMaxRows );
 168
 169         int nRow;
 170
 171         // Show the hidden nRow
 172         for( int nCol = 0; nCol < m_nCols; ++nCol )
 173         {
 174                 CWnd* pPaneShow = GetDlgItem( AFX_IDW_PANE_FIRST+nCol * 16+m_nRows );
 175                 ASSERT( pPaneShow != NULL );
 176                 pPaneShow->ShowWindow( SW_SHOWNA );
 177
 178                 for( nRow = m_nRows - 2; nRow >= nShowRow; --nRow )
 179                 {
 180                         CWnd* pPane = GetPane( nRow, nCol );
 181                         ASSERT( pPane != NULL );
 182                         pPane->SetDlgCtrlID( IdFromRowCol( nRow + 1, nCol ));
 183                 }
 184
 185                 pPaneShow->SetDlgCtrlID( IdFromRowCol( nShowRow, nCol ));
 186         }
 187
 188         // new panes have been created -- recalculate layout
 189         for( nRow = nShowRow+1; nRow < m_nRows; nRow++ )
 190                 m_pRowInfo[nRow].nIdealSize = m_pRowInfo[nRow - 1].nCurSize;
 191
 192         m_pRowInfo[nShowRow].nIdealSize = cyNew;
 193         RecalcLayout();
 194 }
 195
 196 void CXSplitter::HideColumn(int nColHide)
 197 {
 198         ASSERT_VALID( this );
 199         ASSERT( m_nCols > 1 );
 200         ASSERT( nColHide < m_nCols );
 201         ASSERT( m_nHiddenCol == -1 );
 202         m_nHiddenCol = nColHide;
 203
 204         // if the column has an active window -- change it
 205         int nActiveRow, nActiveCol;
 206         if( GetActivePane( &nActiveRow, &nActiveCol ) != NULL )
 207         {
 208                 if( nActiveCol == nColHide )
 209                 {
 210                         if( ++nActiveCol >= m_nCols )
 211                                 nActiveCol = 0;
 212                         SetActivePane( nActiveRow, nActiveCol );
 213                 }
 214         }
 215
 216         // hide all column panes
 217         for( int nRow = 0; nRow < m_nRows; nRow++)
 218         {
 219                 CWnd* pPaneHide = GetPane(nRow, nColHide);
 220                 ASSERT( pPaneHide != NULL );
 221
 222                 pPaneHide->ShowWindow(SW_HIDE);
 223                 pPaneHide->SetDlgCtrlID( AFX_IDW_PANE_FIRST+nRow * 16+m_nCols );
 224
 225                 for( int nCol = nColHide + 1; nCol < m_nCols; nCol++ )
 226                 {
 227                         CWnd* pPane = GetPane( nRow, nCol );
 228                         ASSERT( pPane != NULL );
 229
 230                         pPane->SetDlgCtrlID( IdFromRowCol( nRow, nCol - 1 ));
 231                 }
 232         }
 233
 234         m_nCols--;
 235         m_pColInfo[m_nCols].nCurSize = m_pColInfo[nColHide].nCurSize;
 236         RecalcLayout();
 237 }
 238
 239 void CXSplitter::ShowColumn()
 240 {
 241         ASSERT_VALID( this );
 242         ASSERT( m_nCols < m_nMaxCols );
 243         ASSERT( m_nHiddenCol != -1 );
 244
 245         int nShowCol = m_nHiddenCol;
 246         m_nHiddenCol = -1;
 247
 248         int cxNew = m_pColInfo[m_nCols].nCurSize;
 249         m_nCols++;  // add a column
 250
 251         ASSERT( m_nCols == m_nMaxCols );
 252
 253         int nCol;
 254
 255         // Show the hidden column
 256         for( int nRow = 0; nRow < m_nRows; ++nRow )
 257         {
 258                 CWnd* pPaneShow = GetDlgItem( AFX_IDW_PANE_FIRST+nRow * 16+m_nCols );
 259                 ASSERT( pPaneShow != NULL );
 260                 pPaneShow->ShowWindow( SW_SHOWNA );
 261
 262                 for( nCol = m_nCols - 2; nCol >= nShowCol; --nCol )
 263                 {
 264                         CWnd* pPane = GetPane( nRow, nCol );
 265                         ASSERT( pPane != NULL );
 266                         pPane->SetDlgCtrlID( IdFromRowCol( nRow, nCol + 1 ));
 267                 }
 268
 269                 pPaneShow->SetDlgCtrlID( IdFromRowCol( nRow, nShowCol ));
 270         }
 271
 272         // new panes have been created -- recalculate layout
 273         for( nCol = nShowCol+1; nCol < m_nCols; nCol++ )
 274                 m_pColInfo[nCol].nIdealSize = m_pColInfo[nCol - 1].nCurSize;
 275
 276         m_pColInfo[nShowCol].nIdealSize = cxNew;
 277         RecalcLayout();
 278 }
 279