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 */

    17 

    18 // INCLUDE FILES

    19 

    20 #include "HgVgScrollBar.h"

    21 #include "HgVgDrawBuffer.h"

    22 #include "HgVgHelper.h"

    23 #include "HgScrollbar.h"

    24 #include <VG/vgu.h>

    25 #include <gulicon.h>

    26 

    27 

    28 

    29 // ============================ MEMBER FUNCTIONS ===============================

    30 // -----------------------------------------------------------------------------

    31 // CHgVgScrollBar::NewL()

    32 // Two-phased constructor.

    33 // -----------------------------------------------------------------------------

    34 //

    35 CHgVgScrollBar* CHgVgScrollBar::NewL( MHgScrollbarObserver& aObserver, 

    36         TRect aScrollbarRect,

    37                     TSize aTotalSize,

    38                     TSize aViewSize,

    39                     TBool aLandscapeScrolling,

    40                     CHgScroller::THgScrollBarType aScrollBarType )

    41     {

    42     CHgVgScrollBar* self = new ( ELeave ) CHgVgScrollBar( ); 

    43     CleanupStack::PushL (self );

    44     self->ConstructL( aObserver, aScrollbarRect, aTotalSize, aViewSize, aLandscapeScrolling, aScrollBarType );

    45     CleanupStack::Pop ( self );

    46     return self;

    47     }

    48 

    49 // -----------------------------------------------------------------------------

    50 // CHgVgScrollBar::ConstructL()

    51 // Symbian 2nd phase constructor can leave.

    52 // -----------------------------------------------------------------------------

    53 //

    54 void CHgVgScrollBar::ConstructL ( MHgScrollbarObserver& aObserver, TRect aScrollbarRect,

    55         TSize aTotalSize,

    56         TSize aViewSize,

    57         TBool aLandscapeScrolling,

    58         CHgScroller::THgScrollBarType aScrollBarType )

    59     {

    60     ResizeL(aObserver, aScrollbarRect, aTotalSize, aViewSize, aLandscapeScrolling, 

    61             aScrollBarType);

    62     

    63     CreateImagesL();

    64     }

    65 

    66 

    67 // -----------------------------------------------------------------------------

    68 // CHgVgScrollBar::CreateImagesL()

    69 // -----------------------------------------------------------------------------

    70 //

    71 void CHgVgScrollBar::CreateImagesL()

    72     {

    73     iScrollbarBg = HgVgHelper::CreateVgImageFromIconL(*iScrollbar->ScrollbarBg());

    74     iScrollbarBgSelected = HgVgHelper::CreateVgImageFromIconL(*iScrollbar->ScrollbarBgSelected());

    75     iScrollbarHandle = HgVgHelper::CreateVgImageFromIconL(*iScrollbar->ScrollbarHandle());

    76     iScrollbarHandleSelected = HgVgHelper::CreateVgImageFromIconL(*iScrollbar->ScrollbarHandleSelected());

    77     //iScrollbarHandleBg = HgVgHelper::CreateVgImageFromIconL(iScrollbar->ScrollbarHandleBg());

    78     }

    79 

    80 

    81 // -----------------------------------------------------------------------------

    82 // CHgVgScrollBar::CHgVgMediaWall()

    83 // C++ default constructor can NOT contain any code, that might leave.

    84 // -----------------------------------------------------------------------------

    85 //

    86 CHgVgScrollBar::CHgVgScrollBar(  ) : 

    87 iEnabled(ETrue)

    88     {

    89     }

    90         

    91 // -----------------------------------------------------------------------------

    92 // CHgVgScrollBar::~CHgVgScrollBar()

    93 // Destructor.

    94 // -----------------------------------------------------------------------------

    95 //

    96 CHgVgScrollBar::~CHgVgScrollBar ( )

    97     {

    98 

    99     vgDestroyImage(iScrollbarBg);

   100     vgDestroyImage(iScrollbarBgSelected);

   101     vgDestroyImage(iScrollbarHandle);

   102     vgDestroyImage(iScrollbarHandleSelected);

   103     //vgDestroyImage(iScrollbarHandleBg);

   104     

   105     delete iScrollbar;

   106     

   107     }

   108 

   109 

   110 void CHgVgScrollBar::SetViewPosition( TPoint aPosition )

   111     {

   112     iScrollbar->SetViewPosition(aPosition);

   113     }

   114 

   115 TBool CHgVgScrollBar::HandlePointerEventL( const TPointerEvent& aEvent )

   116     {

   117     if (!iEnabled)

   118         return EFalse;

   119     

   120     return iScrollbar->HandlePointerEventL(aEvent);

   121     }

   122 

   123 void CHgVgScrollBar::Draw(const TRect& aWindowRect, TReal aAlpha) const

   124     {

   125     if (!iEnabled)

   126         return;

   127     

   128     TRect scrollbarRect = iScrollbar->ScrollbarRect();

   129     TPoint handlePosition = iScrollbar->HandlePosition();

   130     const CGulIcon* scrollbarBg = iScrollbar->ScrollbarBg();

   131     const CGulIcon* scrollbarBgSelected = iScrollbar->ScrollbarBgSelected();

   132     const CGulIcon* scrollbarHandle = iScrollbar->ScrollbarHandle();

   133     const CGulIcon* scrollbarHandleSelected = iScrollbar->ScrollbarHandleSelected();

   134     const CGulIcon* scrollbarHandleBg = iScrollbar->ScrollbarHandleBg();

   135     

   136     if(scrollbarBg && scrollbarHandle && scrollbarHandleBg)

   137         {

   138         if(iScrollbar->Handler() && !iScrollbar->IsStatic())

   139             {

   140             DrawImage(scrollbarRect.iTl,

   141                     iScrollbarBgSelected, 

   142                     scrollbarBgSelected->Bitmap()->SizeInPixels(), aWindowRect, aAlpha);

   143             

   144             DrawImage(scrollbarRect.iTl + handlePosition, 

   145                     iScrollbarHandleSelected,

   146                     scrollbarHandleSelected->Bitmap()->SizeInPixels(), aWindowRect, aAlpha);

   147             }

   148         else

   149             {

   150             DrawImage(scrollbarRect.iTl, 

   151                     iScrollbarBg,

   152                     scrollbarBg->Bitmap()->SizeInPixels(), aWindowRect, aAlpha);

   153             

   154             DrawImage(scrollbarRect.iTl + handlePosition,

   155                     iScrollbarHandleBg,

   156                     scrollbarHandleBg->Bitmap()->SizeInPixels(), aWindowRect, aAlpha);

   157 

   158             DrawImage(scrollbarRect.iTl + handlePosition, 

   159                     iScrollbarHandle,

   160                     scrollbarHandle->Bitmap()->SizeInPixels(), aWindowRect, aAlpha);

   161             }

   162         }    

   163     }

   164 

   165 void CHgVgScrollBar::DrawImage(const TPoint& aPosition, VGImage aImage, 

   166         const TSize& /*aSize*/, const TRect& aWindowRect, TReal aAlpha) const

   167     {

   168     TRgb color(255, 255, 255, aAlpha * 255.0f);

   169     HgVgHelper::DrawImageColorized(aImage, color, aPosition, aWindowRect, EFalse);

   170     }

   171 

   172 TBool CHgVgScrollBar::IsEnabled() const

   173     {

   174     return iEnabled;

   175     }

   176 

   177 void CHgVgScrollBar::SetEnabled(TBool aEnabled)

   178     {

   179     iEnabled = aEnabled;

   180     }

   181 

   182 void CHgVgScrollBar::ResizeL(

   183         MHgScrollbarObserver& aObserver, 

   184         TRect aScrollbarRect,

   185         TSize aTotalSize,

   186         TSize aViewSize,

   187         TBool aLandscapeScrolling,

   188         CHgScroller::THgScrollBarType /*aScrollBarType */)

   189     {

   190     iScrollbar = CHgScrollbar::NewL(aObserver);

   191 

   192     iScrollbar->InitScrollBarL(aScrollbarRect, aTotalSize, aViewSize, aLandscapeScrolling);    

   193     }

   194 

   195 

   196 

   197 // End of File