//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 1998.
//
// File: winsplit.cxx
//
// Contents: Contains the code to do a window split.
//
// Classes: CTableWindowSplit
//
// Functions:
//
// History: 1-08-95 srikants Created
//
//----------------------------------------------------------------------------
#include "pch.cxx"
#pragma hdrstop
#include "winsplit.hxx"
#include "tabledbg.hxx"
//+---------------------------------------------------------------------------
//
// Function: CTableWindowSplit ~ctor
//
// Synopsis: Constructor for the CTableWindowSplit class.
//
// Arguments: [srcWindow] - The source window that needs to be
// split
// [iSplitVisibleRowIndex] - Index in the source window's visible
// row index which is the split index. All rows <=
// iSplitVisibleRowIndex will be in the left hand window and the rest
// in the right hand window after the split.
//
// History: 1-09-95 srikants Created
//
// Notes:
//
//----------------------------------------------------------------------------
CTableWindowSplit::CTableWindowSplit( CTableWindow & srcWindow,
ULONG iSplitQueryRowIndex,
ULONG segIdLeft, ULONG segIdRight,
BOOL fIsLastSegment )
: _srcWindow(srcWindow),
_pLeftWindow(0),
_pRightWindow(0),
_srcQueryRowIndex(srcWindow._GetInvisibleRowIndex()),
_srcClientRowIndex(srcWindow._GetVisibleRowIndex()),
_iSplitQueryRowIndex(iSplitQueryRowIndex),
_iSplitClientRowIndex(-1),
_segIdLeft(segIdLeft), _segIdRight(segIdRight),
_fIsLastSegment(fIsLastSegment)
{
Win4Assert( _srcQueryRowIndex.RowCount() >= 2 );
Win4Assert( iSplitQueryRowIndex < _srcQueryRowIndex.RowCount()-1 );
if ( _srcWindow.IsWatched() )
{
//
// The source window has watch regions. The dynamic rowindex must
// also be split.
//
TBL_OFF oQuerySplitRow = _srcQueryRowIndex.GetRow( iSplitQueryRowIndex );
_iSplitClientRowIndex = _srcClientRowIndex.FindSplitPoint( oQuerySplitRow )-1;
}
}
//+---------------------------------------------------------------------------
//
// Function: ~CTableWindowSplit ~dtor for the CTableWindowSplit class
//
// Synopsis: Frees up the resources
//
// History: 1-09-95 srikants Created
//
// Notes:
//
//----------------------------------------------------------------------------
CTableWindowSplit::~CTableWindowSplit()
{
delete _pLeftWindow;
delete _pRightWindow;
}
//+---------------------------------------------------------------------------
//
// Function: CreateTargetWindows
//
// Synopsis: Creates the target windows and initializes their
// notification region based on the source window notification
// region.
//
// History: 1-09-95 srikants Created
//
// Notes:
//
//----------------------------------------------------------------------------
void CTableWindowSplit::CreateTargetWindows()
{
//
// First create the left and right windows
//
Win4Assert( 0 == _pLeftWindow );
Win4Assert( 0 == _pRightWindow );
_pLeftWindow = new CTableWindow( _srcWindow, _segIdLeft );
_pRightWindow = new CTableWindow( _srcWindow, _segIdRight );
}
//+---------------------------------------------------------------------------
//
// Function: TransferTargetWindows
//
// Synopsis: Transfers the control of the target windows to the caller.
//
// Arguments: [ppLeftWindow] - (output) The pointer to the left window.
// [ppRightWindow] - (output) The pointer to the right window.
//
// History: 1-09-95 srikants Created
//
// Notes:
//
//----------------------------------------------------------------------------
void CTableWindowSplit::TransferTargetWindows( CTableWindow ** ppLeftWindow,
CTableWindow ** ppRightWindow )
{
Win4Assert( 0 != ppLeftWindow && 0 != ppRightWindow );
*ppLeftWindow = _pLeftWindow;
_pLeftWindow = 0;
*ppRightWindow = _pRightWindow;
_pRightWindow = 0;
}
//+---------------------------------------------------------------------------
//
// Function: _CopyWithoutNotifications
//
// Synopsis: Copies rows from the source window to the destination window. Only
// the rows in the "srcRowIndex" will be copied to the
// destination.
//
// Arguments: [destWindow] - Target window to copy to.
// [srcRowIndex] - The source row index.
// [iStartRowIndex] - Starting offset in the row index to start
// copying rows from.
// [iEndRowIndex] - Ending offset in the row index to stop
// copying.
//
// History: 1-09-95 srikants Created
//
// Notes:
//
//----------------------------------------------------------------------------
void CTableWindowSplit::_CopyWithoutNotifications( CTableWindow & destWindow,
CRowIndex & srcRowIndex,
ULONG iStartRowIndex, ULONG iEndRowIndex )
{
Win4Assert( iEndRowIndex < srcRowIndex.RowCount() );
for ( ULONG i = iStartRowIndex; i <= iEndRowIndex; i++ )
{
destWindow._PutRowToVisibleRowIndex( _srcWindow, srcRowIndex.GetRow(i) );
}
}
//+---------------------------------------------------------------------------
//
// Function: _SimpleSplit
//
// Synopsis: Does a simple split in which the first half of the rows from
// the source row index will be copied to the left window and the
// second half to the right window.
//
// History: 1-31-95 srikants Created
//
// Notes: This must be called only when there is no notification region
// in the source window.
//
//----------------------------------------------------------------------------
void CTableWindowSplit::_SimpleSplit()
{
Win4Assert( !_srcWindow.IsWatched() );
//
// The source notifcation region is completely empty. We have to copy from
// the visible row index only.
//
tbDebugOut(( DEB_WINSPLIT, "CTableWindowSplit::Simple Split\n" ));
_CopyWithoutNotifications( *_pLeftWindow, _srcQueryRowIndex,
0, _iSplitQueryRowIndex );
_CopyWithoutNotifications( *_pRightWindow, _srcQueryRowIndex,
_iSplitQueryRowIndex+1,
_srcQueryRowIndex.RowCount()-1 );
}
//+---------------------------------------------------------------------------
//
// Function: DoSplit
//
// Synopsis: Splits the source window into left and right windows.
//
// History: 1-09-95 srikants Created
//
// Notes:
//
//----------------------------------------------------------------------------
void CTableWindowSplit::DoSplit()
{
Win4Assert( 0 != _pLeftWindow && 0 != _pRightWindow );
_pLeftWindow->_SetSplitInProgress();
_pRightWindow->_SetSplitInProgress();
if ( !_srcWindow.IsWatched() )
{
//
// The source notifcation region is completely empty. We have to copy from
// the visible row index only.
//
Win4Assert( -1 == _iSplitClientRowIndex );
_SimpleSplit();
_pLeftWindow->_SetSplitDone();
_pRightWindow->_SetSplitDone();
}
else
{
//
// If notifications are enabled in the target window, then we must copy
// both the client row index and the query row index. O/W, just copy
// the contents of the query row index.
//
//
// Copy the contents to the target left window.
//
tbDebugOut(( DEB_WINSPLIT, "Left Window with Notifications\n" ));
_CopyWithNotifications( *_pLeftWindow, 0, _iSplitQueryRowIndex,
0, _iSplitClientRowIndex );
//
// Copy the contents to the target right window.
//
tbDebugOut(( DEB_WINSPLIT, "Right Window with Notifications\n" ));
_CopyWithNotifications( *_pRightWindow,
_iSplitQueryRowIndex+1, _srcQueryRowIndex.RowCount()-1,
_iSplitClientRowIndex+1, _srcClientRowIndex.RowCount()-1 );
//
// Now apply the watch regions on the new windows.
//
_CopyWatchRegions();
//
// Indicate that the split is done.
//
_pLeftWindow->_SetSplitDone();
_pRightWindow->_SetSplitDone();
//
// If any of the windows doesn't have any watch regions, we have to
// do a state change to delete the dynamic/static split.
//
Win4Assert( _pLeftWindow->IsWatched() || _pRightWindow->IsWatched() );
if ( !_pLeftWindow->IsWatched() )
{
_pLeftWindow->_EndStaticDynamicSplit();
}
if ( !_pRightWindow->IsWatched() )
{
_pRightWindow->_EndStaticDynamicSplit();
}
}
//
// Setup the lowest & highest keys for the left and right windows.
//
_srcWindow.GetSortKey( 0, _pLeftWindow->GetLowestKey() );
_srcWindow.GetSortKey( _iSplitQueryRowIndex+1, _pRightWindow->GetLowestKey() );
_srcWindow.GetSortKey( _iSplitQueryRowIndex, _pLeftWindow->GetHighestKey() );
_srcWindow.GetSortKey( (ULONG) _srcWindow.RowCount()-1, _pRightWindow->GetHighestKey() );
}
//+---------------------------------------------------------------------------
//
// Function: _CopyWithNotifications
//
// Synopsis: Copies contents of both the "visible" and "dynamic" row index
// from the source window to the destination window.
//
// Arguments: [destWindow] - Destination window to copy to.
// [iStartVisRowIndex] - Starting offset in the visible rowindex.
// [iEndVisRowIndex] - Ending offset in the visible rowindex.
// [iStartDynRowIndex] - Starting offset in the dynamic rowindex.
// [iEndDynRowIndex] - Ending offset in the dynamic rowindex.
//
// History: 1-09-95 srikants Created
//
// Notes:
//
//----------------------------------------------------------------------------
void CTableWindowSplit::_CopyWithNotifications( CTableWindow & destWindow,
ULONG iStartQueryRowIndex, ULONG iEndQueryRowIndex,
LONG iStartClientRowIndex, LONG iEndClientRowIndex )
{
Win4Assert( _srcWindow.IsWatched() );
Win4Assert( iStartQueryRowIndex < _srcQueryRowIndex.RowCount() );
Win4Assert( iEndQueryRowIndex >= iStartQueryRowIndex &&
iEndQueryRowIndex < _srcQueryRowIndex.RowCount() );
//
// Copy the rows from the client row index.
//
for ( LONG j = iStartClientRowIndex; j <= iEndClientRowIndex; j++ )
{
destWindow._PutRowToVisibleRowIndex( _srcWindow, _srcClientRowIndex.GetRow(j) );
}
//
// Copy the rows from the query row index.
//
for ( ULONG i = iStartQueryRowIndex; i <= iEndQueryRowIndex; i++ )
{
destWindow._PutRowToDynRowIndex( _srcWindow, _srcQueryRowIndex.GetRow(i) );
}
}
//+---------------------------------------------------------------------------
//
// Member: CTableWindowSplit::_IsOffsetInLeftWindow
//
// Synopsis:
//
// Arguments: [iOffset] -
//
// Returns:
//
// Modifies:
//
// History: 7-27-95 srikants Created
//
// Notes:
//
//----------------------------------------------------------------------------
inline
BOOL CTableWindowSplit::_IsOffsetInLeftWindow( long iOffset )
{
return iOffset <= _iSplitClientRowIndex;
}
//+---------------------------------------------------------------------------
//
// Member: CTableWindowSplit::_CopyWatchRegions
//
// Synopsis:
//
// Modifies:
//
// History: 7-27-95 srikants Created
//
// Notes:
//
//----------------------------------------------------------------------------
void CTableWindowSplit::_CopyWatchRegions()
{
Win4Assert( _srcWindow.IsWatched() );
for ( unsigned i = 0; i < _srcWindow._aWindowWatch.Count(); i++ )
{
CWindowWatch & watch = _srcWindow._aWindowWatch.Get(i);
long cResidual = watch._cRowsLeft;
if ( _IsOffsetInLeftWindow( watch._iRowStart ) )
{
cResidual -= _pLeftWindow->AddWatch( watch._hRegion,
watch._iRowStart,
cResidual,
FALSE );
if ( cResidual > 0 )
{
_pRightWindow->AddWatch( watch._hRegion,
0,
cResidual,
_fIsLastSegment );
}
}
else
{
//
// The offset must be in the right hand side window.
//
Win4Assert( watch._iRowStart > _iSplitClientRowIndex &&
watch._iRowStart < (long) _srcWindow.RowCount() );
Win4Assert( (long) _pLeftWindow->RowCount() == _iSplitClientRowIndex+1 );
_pRightWindow->AddWatch( watch._hRegion,
(LONG) (watch._iRowStart - _pLeftWindow->RowCount()),
cResidual,
_fIsLastSegment );
}
}
}