--- /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;
+ }
+
+