diff -r 000000000000 -r 2f259fa3e83a uifw/EikStd/coctlsrc/Aknscind.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/uifw/EikStd/coctlsrc/Aknscind.cpp	Tue Feb 02 01:00:49 2010 +0200
@@ -0,0 +1,461 @@
+/*
+* Copyright (c) 1997-1999 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+
+
+#include <coecntrl.h>
+#include <aknconsts.h>
+#include "aknscbut.h"
+#include "aknscind.h"
+#include <avkon.mbg>
+#include <eikenv.h>
+#include <AknsDrawUtils.h>
+#include <AknLayout.lag>
+#include <AknIconUtils.h>
+#include <AknUtils.h>
+#include <AknsUtils.h>
+#include <aknlayoutscalable_avkon.cdl.h>
+#include <aknappui.h>
+#include <gulicon.h>
+#include <AknsConstants.h>
+
+static const TInt KNoOfIndicatorColors = 17;
+static const TInt KMaxIndicatorIndex = KNoOfIndicatorColors - 1;
+static const TInt KNoOfGrayMaskColors = 256;
+static const TInt KMaxGrayMaskIndex = KNoOfGrayMaskColors - 1;
+static const TInt KMinGrayMaskIndex = 0;
+static const TInt KFullColor = 16;
+
+const TUint8 KIndicatorColors[KNoOfIndicatorColors] =
+    {
+    0,
+    226,
+    227,
+    228,
+    229,
+    230,
+    231,
+    232,
+    233,
+    234,
+    235,
+    236,
+    237,
+    238,
+    239,
+    240,
+    241
+    };
+
+//
+// Local panics + routine
+//
+enum TEikPanicResourceScrollerIndicator
+    {
+    EEikPanicScrollbarScrollRangeLow,
+    EEikPanicScrollbarIndicatorOutOfRangeLow,
+    EEikPanicScrollbarIndicatorOutOfRangeHigh,
+    EEikPanicScrollbarScrollSpanLow,
+    EEikPanicScrollbarFocusPosOutOfRange
+    };
+
+#if defined(_DEBUG)
+LOCAL_C void Panic(TEikPanicResourceScrollerIndicator aPanic)
+    {
+    _LIT(KPanicCat,"AVKON-Scroll Indicator");
+    User::Panic(KPanicCat, aPanic);
+    }
+#endif
+
+CAknScrollIndicator::CAknScrollIndicator(CAknScrollButton::TType aType)
+    : iFocusPosition(0), iScrollSpan(1), iType(aType), iTypeOfScrollBar(CAknScrollButton::EArrowHead)
+    {
+    }
+
+CAknScrollIndicator* CAknScrollIndicator::NewL(CAknScrollButton::TType aType)
+    {
+    CAknScrollIndicator* self = new(ELeave) CAknScrollIndicator(aType);
+    CleanupStack::PushL(self);
+    self->ConstructL();
+    CleanupStack::Pop();
+    return self;
+    }
+
+    
+CAknScrollIndicator* CAknScrollIndicator::NewL(CAknScrollButton::TType aType, CAknScrollButton::TTypeOfScrollBar aTypeOfScrollBar)
+    {
+    CAknScrollIndicator* self = new(ELeave) CAknScrollIndicator(aType);
+    CleanupStack::PushL(self);
+    self->ConstructL(aTypeOfScrollBar);
+    CleanupStack::Pop();
+    return self;
+    }
+    
+void CAknScrollIndicator::ConstructL(CAknScrollButton::TTypeOfScrollBar aTypeOfScrollBar)
+    {
+    iTypeOfScrollBar = aTypeOfScrollBar;
+    ConstructL();
+    }
+
+void CAknScrollIndicator::ConstructL()
+    {
+    iIsWindowOwningScrollBar = EFalse;
+    if( AknLayoutUtils::PenEnabled() && (iTypeOfScrollBar == CAknScrollButton::ENormal) )
+        {
+        // TODO: Load bitmaps for double span scroll bar buttons when they become available
+        // Get the correct sizes from LAF when the support for the buttons is available
+        // Initalize the bitmap devices and graphics contexts correctly        
+        TInt err;         
+        TAknsItemID indicator; 
+        TAknWindowComponentLayout buttonLayout;
+        TAknWindowComponentLayout scrollpaneLayout;
+        
+        switch( iType )
+            {
+            case CAknScrollButton::ENudgeUp:        	        
+                buttonLayout = AknLayoutScalable_Avkon::scroll_sc2_up_pane( 1 );  
+                indicator = KAknsIIDQgnGrafScrollArrowUp;
+                scrollpaneLayout = AknLayoutScalable_Avkon::scroll_pane();
+                break;
+            case CAknScrollButton::ENudgeDown:
+                buttonLayout = AknLayoutScalable_Avkon::scroll_sc2_down_pane( 1 );  
+                indicator = KAknsIIDQgnGrafScrollArrowDown;
+                scrollpaneLayout = AknLayoutScalable_Avkon::scroll_pane();
+                break;
+            case CAknScrollButton::ENudgeLeft:
+                buttonLayout = AknLayoutScalable_Avkon::scroll_sc2_left_pane();  
+                indicator = KAknsIIDQgnGrafScrollArrowLeft;
+                scrollpaneLayout = AknLayoutScalable_Avkon::scroll_pane(1);
+                break;
+            case CAknScrollButton::ENudgeRight:
+                buttonLayout = AknLayoutScalable_Avkon::scroll_sc2_right_pane();
+                indicator = KAknsIIDQgnGrafScrollArrowRight;
+                scrollpaneLayout = AknLayoutScalable_Avkon::scroll_pane(1);
+                break;
+            default:
+                return;
+            }
+        
+        TAknLayoutRect scrollpaneLayoutRect, buttonLayoutRect;
+        
+        // Using mainpanerect only for counting the size of button bitmap
+        TRect mainpaneRect;
+        AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, mainpaneRect );
+        scrollpaneLayoutRect.LayoutRect( mainpaneRect, scrollpaneLayout.LayoutLine() ); 
+        buttonLayoutRect.LayoutRect( scrollpaneLayoutRect.Rect(), buttonLayout.LayoutLine() ); 
+        
+        // trapping possible leave in this phase when there's no bitmaps in other skins        
+        
+        TRAP( err, iIcon = AknsUtils::CreateGulIconL( AknsUtils::SkinInstance(), 
+                            indicator, EFalse ) );
+        
+        if( err == KErrNone )
+            {
+            AknIconUtils::SetSize( iIcon->Bitmap(),  buttonLayoutRect.Rect().Size() );    
+            AknIconUtils::SetSize( iIcon->Mask(),  buttonLayoutRect.Rect().Size() );    
+            }             
+        }
+    else
+        {
+        TInt indicator;
+        TSize indiSize;
+
+
+        // screen
+        TRect screenRect = iAvkonAppUi->ApplicationRect();
+    
+        //TAknWindowLineLayout screenLayout = AknLayout::screen();
+        //TRect screenRect = screenLayout.Rect();
+
+        // app window
+        TAknWindowLineLayout applicationWindowLayout =
+            AknLayout::application_window(screenRect);
+    
+        TAknLayoutRect applicationWindowLayoutRect;
+        applicationWindowLayoutRect.LayoutRect(screenRect, applicationWindowLayout);
+        TRect applicationWindowRect = applicationWindowLayoutRect.Rect(); 
+
+        // control pane
+        TAknWindowLineLayout controlPaneLayout =
+            AknLayout::control_pane(applicationWindowRect);
+
+        TAknLayoutRect controlPaneLayoutRect;
+        controlPaneLayoutRect.LayoutRect(applicationWindowRect, controlPaneLayout);
+        TRect controlPaneRect = controlPaneLayoutRect.Rect(); 
+
+    
+        if (iType == CAknScrollButton::ENudgeUp)
+            {
+            // scroll up
+            TAknWindowLineLayout scrollLayout =
+                AknLayout::Control_pane_elements_Line_1();
+            TAknLayoutRect scrollLayoutRect;
+            scrollLayoutRect.LayoutRect(controlPaneRect, scrollLayout);
+            TRect scrollRect = scrollLayoutRect.Rect(); 
+
+            indicator=EMbmAvkonQgn_indi_scroll_a;        
+            indiSize = scrollRect.Size();
+            }
+        else
+            {
+            // scroll down
+            TAknWindowLineLayout scrollLayout =
+                AknLayout::Control_pane_elements_Line_2();
+            TAknLayoutRect scrollLayoutRect;
+            scrollLayoutRect.LayoutRect(controlPaneRect, scrollLayout);
+            TRect scrollRect = scrollLayoutRect.Rect(); 
+
+            indicator=EMbmAvkonQgn_indi_scroll_b;
+            indiSize = scrollRect.Size();
+            }
+
+//  iBitmap = new (ELeave) CFbsBitmap();
+//  User::LeaveIfError(iBitmap->Load(KAvkonBitmapFile,
+//      indicator,ETrue));
+
+//    iBitmap = AknIconUtils::CreateIconL(KAvkonBitmapFile, indicator);
+    
+        iBitmap = new (ELeave) CEikImage();    
+        CFbsBitmap* mask = NULL;
+        CFbsBitmap* bitmap = NULL;
+    
+        // Use bitmap id for both mask and bitmap because of 1-bit icons.
+        AknIconUtils::CreateIconL(
+            bitmap, mask, KAvkonBitmapFile, indicator, indicator ); 
+        AknIconUtils::SetSize(bitmap,indiSize);
+        // Also note that in the drawing time mask is used as bitmap. We store the bitmap
+        // only because AknIconUtils requires to do so.
+        iBitmap->SetBitmap(bitmap);
+        iBitmap->SetMask(mask);
+
+        iColorBitmap = new (ELeave) CFbsBitmap();
+        User::LeaveIfError( iColorBitmap->Create( bitmap->SizeInPixels(),
+            iEikonEnv->ScreenDevice()->DisplayMode() ) );
+        iColorBmpDev = CFbsBitmapDevice::NewL( iColorBitmap );
+//      User::LeaveIfError( iColorBmpDev->Resize( bitmap->SizeInPixels()));
+        iColorBmpGc = CFbsBitGc::NewL();
+        iColorBmpGc->Activate( iColorBmpDev );
+
+        iMaskBitmap = new (ELeave) CFbsBitmap();
+        //8-bit bitmap
+        User::LeaveIfError( iMaskBitmap->Create( bitmap->SizeInPixels(),
+            EGray256 ));
+        iMaskBmpDev = CFbsBitmapDevice::NewL( iMaskBitmap );
+//      User::LeaveIfError( iMaskBmpDev->Resize( bitmap->SizeInPixels()));
+        iMaskBmpGc = CFbsBitGc::NewL();
+        iMaskBmpGc->Activate( iMaskBmpDev );
+        }
+    }
+
+CAknScrollIndicator::~CAknScrollIndicator()
+    {
+    delete iBitmap;
+    delete iColorBitmap;
+    delete iColorBmpDev;
+    delete iColorBmpGc;
+    delete iMaskBmpGc;
+    delete iMaskBmpDev;
+    delete iMaskBitmap;    
+    delete iIcon;
+        
+        
+    }
+
+
+/**
+ * Main method. Calculates the index of the appropriate scroller
+ * indicator bitmap color and draws it.
+ *
+ * Alternatively draws a transparent indicator using 8-bit
+ * greyscale mask.
+ */
+void CAknScrollIndicator::DrawScrollIndicator(const TRect& aRect)
+    {
+    if( AknLayoutUtils::PenEnabled() && (iTypeOfScrollBar == CAknScrollButton::ENormal) )
+        {        
+        CWindowGc& gc = SystemGc();
+       
+        MAknsSkinInstance* skin = AknsUtils::SkinInstance();
+        MAknsControlContext* cc = AknsDrawUtils::ControlContext( this );
+    
+        if ( iIsWindowOwningScrollBar )
+            {            
+            TRect rect( Window().Position() + aRect.iTl, aRect.Size() ); 
+            AknsDrawUtils::DrawBackground( skin, cc, NULL, gc, aRect.iTl, rect , KAknsDrawParamNoClearUnderImage );
+            }
+        else
+            {
+            AknsDrawUtils::Background( skin, cc, this, gc, aRect, KAknsDrawParamNoClearUnderImage );
+            }
+        
+        if( iIcon )
+            {
+            gc.BitBltMasked( aRect.iTl, iIcon->Bitmap(), aRect.Size(), iIcon->Mask(), ETrue );            
+            }        
+        }
+    else
+        {
+        
+        if (Size().iWidth)  // only draw bitmaps if the button has some size to it
+            {
+            CWindowGc& gc=SystemGc();   // graphics context we draw to
+            TInt indicator( 0 );            // which indicator color to draw
+            TInt grayIndicator( KMinGrayMaskIndex );
+            
+            // if focus position is at the lower limit the color is the 0th...
+            if (iFocusPosition <= 0) {}// do nothing
+            // at the upper limit it is the MAXth...
+            else if (iFocusPosition >= iScrollSpan-1)
+                {
+                indicator = KMaxIndicatorIndex;
+                grayIndicator = KMaxGrayMaskIndex;
+                }
+                // ...all other indicator colors are spread evenly between
+                // all other focus positions...
+            else
+                {
+                // all indicators minus top & bottom
+                TInt variableIndicatorRange( KNoOfIndicatorColors-2 );
+                TInt maxVariableIndex( iScrollSpan-1 );
+                // Calculate the indicator value...
+                indicator=((iFocusPosition*variableIndicatorRange)+
+                    (maxVariableIndex-1))/maxVariableIndex;
+                
+                grayIndicator = KMaxGrayMaskIndex -
+                    ( maxVariableIndex - iFocusPosition ) *
+                    ( KMaxGrayMaskIndex - KMinGrayMaskIndex ) /
+                    maxVariableIndex;
+                }
+            // Sanity checks...
+            __ASSERT_DEBUG(indicator>=0,
+                Panic( EEikPanicScrollbarIndicatorOutOfRangeLow));
+            __ASSERT_DEBUG(indicator<=KMaxIndicatorIndex,
+                Panic(EEikPanicScrollbarIndicatorOutOfRangeHigh));
+            __ASSERT_DEBUG(grayIndicator>=0,
+                Panic( EEikPanicScrollbarIndicatorOutOfRangeLow));
+            __ASSERT_DEBUG(grayIndicator<=KMaxGrayMaskIndex,
+                Panic(EEikPanicScrollbarIndicatorOutOfRangeHigh));
+            
+            // reverse the colors for down buttons
+            if ( iType == CAknScrollButton::ENudgeDown )
+                {
+                indicator = KMaxIndicatorIndex - indicator;
+                grayIndicator = KMaxGrayMaskIndex - grayIndicator;
+                }
+            MAknsSkinInstance* skin = AknsUtils::SkinInstance();
+            MAknsControlContext* cc = AknsDrawUtils::ControlContext( this );
+            
+            AknsDrawUtils::Background( skin, cc, this, gc, aRect );
+            
+            if( indicator )
+                {
+                CFbsBitmap* mask = NULL;
+                if (iType == CAknScrollButton::ENudgeUp)
+                    {
+                    mask = AknsUtils::GetCachedBitmap( skin, KAknsIIDQgnIndiScrollUpMask );
+                    if ( mask )
+                        {
+                        AknIconUtils::SetSize( mask, aRect.Size() );
+                        }
+                    }
+                else
+                    {
+                    mask = AknsUtils::GetCachedBitmap( skin, KAknsIIDQgnIndiScrollDownMask );
+                    if ( mask )
+                        {
+                        AknIconUtils::SetSize( mask, aRect.Size() );
+                        }
+                    }
+                
+                
+                const CFbsBitmap* blitMask = mask;
+                if( !blitMask )
+                    {
+                    blitMask = iBitmap->Mask();
+                    }
+                
+                
+                TRgb color( AKN_LAF_COLOR( KIndicatorColors[indicator] ) );
+                
+                TInt err( AknsUtils::GetCachedColor( skin, color, KAknsIIDQsnScrollColors, KFullColor ) );
+                
+                const TRect bmpRect( TPoint( 0,0 ), aRect.Size() );
+                
+                iColorBmpGc->SetPenStyle( CGraphicsContext::ENullPen );
+                iColorBmpGc->SetBrushStyle( CGraphicsContext::ESolidBrush );
+                
+                if ( err == KErrNone )
+                    {
+                    TRgb gray( 0,0,0 );
+                    //mask bitmap with right gray color
+                    iMaskBmpGc->SetPenStyle( CGraphicsContext::ENullPen );
+                    iMaskBmpGc->SetBrushStyle( CGraphicsContext::ESolidBrush );
+                    iMaskBmpGc->SetBrushColor( gray.Gray256( grayIndicator ) );
+                    iMaskBmpGc->DrawRect( bmpRect );
+                    
+                    //bitmap temporarily filled with black
+                    iColorBmpGc->SetBrushColor( TRgb( 0, 0, 0 ) );
+                    iColorBmpGc->DrawRect( bmpRect );
+                    
+                    //create the mask with gray colored shape
+                    iMaskBmpGc->SetBrushStyle( CGraphicsContext::ENullBrush );
+                    iMaskBmpGc->BitBltMasked( aRect.iTl, iColorBitmap,
+                        bmpRect, blitMask, EFalse );
+                    
+                    //set the skin color
+                    iColorBmpGc->SetBrushColor( color );
+                    iColorBmpGc->DrawRect( bmpRect );
+                    
+                    //blit to screen with transparent color
+                    gc.SetBrushStyle( CGraphicsContext::ENullBrush );
+                    gc.BitBltMasked( aRect.iTl, iColorBitmap,
+                        bmpRect, iMaskBitmap, ETrue );
+                    }
+                else
+                    {
+                    iColorBmpGc->SetBrushColor( color );
+                    iColorBmpGc->DrawRect( bmpRect );
+                    
+                    //draw default color
+                    gc.BitBltMasked( aRect.iTl, iColorBitmap, bmpRect,
+                        blitMask, ETrue );
+                    }
+                }
+            }
+        } //end of else
+    }
+
+
+
+void CAknScrollIndicator::SetPosition(const TInt aFocusPosition, const TInt aScrollSpan)
+    /**
+    / Sets the new focus position in the list and the list length.
+    */
+    {
+    // check parameters valid
+    // scrollspan can now be zero and focusposition -1 for empty lists.
+    __ASSERT_DEBUG(aScrollSpan>=0,Panic(EEikPanicScrollbarScrollSpanLow));
+    __ASSERT_DEBUG((aFocusPosition>=-1) && (aFocusPosition<=aScrollSpan),Panic(EEikPanicScrollbarFocusPosOutOfRange));
+
+    iFocusPosition = aFocusPosition;
+    iScrollSpan = aScrollSpan;
+    }
+void CAknScrollIndicator::SetWindowOwning( const TBool aBool )
+    {   
+    iIsWindowOwningScrollBar = aBool;
+    }
+
+