hgcacheproxymodel/src/hgbuffermanager.cpp
changeset 1 e48454f237ca
child 3 c863538fcbb6
equal deleted inserted replaced
0:89c329efa980 1:e48454f237ca
       
     1 /*
       
     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description:
       
    15 *
       
    16 *  Version     : %version: 1 %
       
    17 */
       
    18 #include "hgbuffermanager.h"
       
    19 #include <hgwidgets/hgcacheproxymodel.h>
       
    20 
       
    21 
       
    22 HgBufferManager::HgBufferManager(
       
    23     HgBufferManagerObserver* aObserver,
       
    24 	int aBufferSize,
       
    25 	int aBufferTreshold,
       
    26 	int aInitialPosition,
       
    27 	int aTotalCount )
       
    28 :
       
    29 mObserver(aObserver),
       
    30 mBufferSize( aBufferSize ),
       
    31 mBufferTreshold( aBufferTreshold ),
       
    32 mBufferPosition( aInitialPosition ),
       
    33 mTotalCount( aTotalCount )
       
    34 {
       
    35     ASSERT( mObserver != 0 );
       
    36     mBufferPosition -= (mBufferSize / 2);
       
    37     
       
    38     if( mBufferPosition + mBufferSize > mTotalCount - 1 ){
       
    39         mBufferPosition = (mTotalCount - 1) - mBufferSize;
       
    40     }
       
    41     
       
    42     if(mBufferPosition < 0 ){
       
    43         mBufferPosition = 0;
       
    44     }
       
    45     
       
    46     mDiff = 0;
       
    47 	//request Initial Buffer
       
    48 	mRequestStart = mBufferPosition;
       
    49 	mRequestCount = mBufferSize;
       
    50 
       
    51 	calculate();
       
    52 }
       
    53 
       
    54 
       
    55 HgBufferManager::~HgBufferManager()
       
    56 {
       
    57 }
       
    58 
       
    59 void HgBufferManager::resizeCache(int newSize, int newTreshold)
       
    60 {
       
    61     if (newTreshold != mBufferTreshold){
       
    62         mBufferTreshold = newTreshold;
       
    63     }
       
    64     
       
    65     if (newSize!=mBufferSize){
       
    66 //        int pos = mBufferPosition + (mBufferSize / 2);
       
    67         
       
    68         int a = Max(0, mBufferPosition + mBufferSize/2 - newSize/2);
       
    69         int b = Min(a + newSize, mTotalCount);
       
    70         if ( b == mTotalCount){
       
    71             a = mTotalCount - newSize;
       
    72         }
       
    73         
       
    74         int c = Max(0, mBufferPosition);
       
    75         int d = Min(c + mBufferSize, mTotalCount);
       
    76         if ( d == mTotalCount){
       
    77             c = mTotalCount - mBufferSize;
       
    78         }
       
    79         
       
    80         if ( newSize>mBufferSize){
       
    81             mObserver->request(a, c-1, HgCacheProxyModel::HgRequestOrderAscending);
       
    82             mObserver->request(d, b-1, HgCacheProxyModel::HgRequestOrderAscending);
       
    83         }else if ( newSize<mBufferSize){
       
    84             mObserver->release(c, a-1);
       
    85             mObserver->release(b, d);
       
    86         }
       
    87         mBufferPosition = a;
       
    88         mBufferSize = newSize;
       
    89     }
       
    90 }
       
    91 
       
    92 void HgBufferManager::calculate()
       
    93 {  
       
    94     HgCacheProxyModel::HgRequestOrder direction = HgCacheProxyModel::HgRequestOrderAscending;
       
    95     
       
    96     if(mResetOrdered){
       
    97         mResetOrdered = false;
       
    98     } else {
       
    99         if(mDiff < 0){
       
   100             mReleaseStart = mBufferPosition;
       
   101             mRequestStart = mBufferPosition + mBufferSize;
       
   102             direction = HgCacheProxyModel::HgRequestOrderAscending; 
       
   103         } else if( mDiff > 0) {
       
   104             mReleaseStart = mBufferPosition + mBufferSize - mDiff;
       
   105             mRequestStart = mBufferPosition - mDiff;
       
   106             direction = HgCacheProxyModel::HgRequestOrderDescending;
       
   107         }
       
   108     }
       
   109     
       
   110     // Release 
       
   111     int end = mReleaseStart + mReleaseCount < mTotalCount ?
       
   112         mReleaseStart + mReleaseCount: mTotalCount; 
       
   113     end--;
       
   114     if(end >= mReleaseStart ){
       
   115         mObserver->release(mReleaseStart, end);
       
   116     }
       
   117     
       
   118     mReleaseCount = 0;
       
   119     
       
   120     // Request
       
   121     end = mRequestStart + mRequestCount < mTotalCount ? 
       
   122         mRequestStart + mRequestCount : mTotalCount;
       
   123     
       
   124     end--;
       
   125     if(end >= mRequestStart ){
       
   126         mObserver->request(mRequestStart, end, direction);
       
   127 	}
       
   128       
       
   129     mRequestCount = 0;
       
   130     
       
   131     // Move Buffer
       
   132     mBufferPosition -= mDiff;
       
   133     // Reset Diff
       
   134     mDiff = 0;
       
   135 }
       
   136 
       
   137 // -----------------------------------------------------------------------------
       
   138 // BufferManager::SetPosition()
       
   139 // -----------------------------------------------------------------------------
       
   140 //
       
   141 void HgBufferManager::setPosition( int aIndex )
       
   142 {
       
   143     // If all the items fit in the buffer no need to move the buffer
       
   144     if(mTotalCount <= mBufferSize)
       
   145         return;
       
   146 	
       
   147 	bool forceUpdate = false;
       
   148     aIndex -= mBufferSize / 2; // normalize index to Buffer start
       
   149     
       
   150     if(aIndex < 0){
       
   151         aIndex = 0;
       
   152         forceUpdate = true;
       
   153     }else if( aIndex > mTotalCount - mBufferSize ){
       
   154         aIndex = mTotalCount - mBufferSize;
       
   155         forceUpdate = true;
       
   156     }
       
   157 
       
   158     mDiff = mBufferPosition - aIndex; 
       
   159 
       
   160     // Too large change reset whole buffer
       
   161     if( mDiff >= mBufferSize || -mDiff >= mBufferSize || mResetOrdered ) {
       
   162         resetBuffer(aIndex + (mBufferSize/2), mTotalCount);
       
   163     } else if( mDiff >= mBufferTreshold ) { // Move Up
       
   164         mRequestCount = mDiff;
       
   165         mReleaseCount = mDiff;
       
   166         calculate();
       
   167     } else if ( -mDiff >= mBufferTreshold ) {// Move Down
       
   168         mRequestCount = -mDiff;
       
   169         mReleaseCount = -mDiff;
       
   170         calculate();
       
   171     } else if( forceUpdate && mDiff ) { // Top or bottom has been reached
       
   172         int diff = mDiff < 0 ? -mDiff : mDiff;
       
   173         mRequestCount = diff;
       
   174         mReleaseCount = diff;
       
   175         calculate();
       
   176     }
       
   177 }
       
   178 
       
   179 // -----------------------------------------------------------------------------
       
   180 // BufferManager::ResetBuffer()
       
   181 // -----------------------------------------------------------------------------
       
   182 //
       
   183 void HgBufferManager::resetBuffer( int aPosition, int aTotalCount)
       
   184 {
       
   185     if( !mResetOrdered ){
       
   186         // release Old buffer
       
   187         mReleaseStart = mBufferPosition;
       
   188         mReleaseCount = mBufferSize;
       
   189     }
       
   190     
       
   191     // set position and count
       
   192     mBufferPosition = aPosition - (mBufferSize / 2);
       
   193     mTotalCount = aTotalCount;
       
   194     mDiff = 0;
       
   195     
       
   196     if( mBufferPosition + mBufferSize > mTotalCount - 1 ){
       
   197         mBufferPosition = mTotalCount - mBufferSize;
       
   198     }
       
   199     
       
   200     if(mBufferPosition < 0 ){
       
   201         mBufferPosition = 0;
       
   202     }
       
   203     
       
   204     //request new Buffer
       
   205     mRequestStart = mBufferPosition;
       
   206     mRequestCount = mBufferSize;
       
   207     mResetOrdered = true;
       
   208     calculate();
       
   209 }
       
   210 
       
   211 void HgBufferManager::itemCountChanged( int aIndex, 
       
   212                                       bool aRemoved,
       
   213                                       int aNewTotalCount )
       
   214 {    
       
   215     Q_UNUSED(aIndex);    
       
   216     Q_UNUSED(aRemoved);
       
   217     //release all, to make sure that no old items are skipped
       
   218     mObserver->release(0, aNewTotalCount);
       
   219     resetBuffer(mBufferPosition + (mBufferSize / 2), aNewTotalCount);
       
   220 }
       
   221 //eof