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 the License "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 

    19 

    20 #include <../bidi.h>

    21 #include <AknUtils.h>

    22 #include <e32cmn.h>

    23 #include "WebScrollbarDrawer.h"

    24 #include "WebView.h"

    25 #include "WebFrame.h"

    26 #include "WebFrameView.h"

    27 #include "BrCtl.h"

    28 #include "StaticObjectsContainer.h"

    29 #include "WebSurface.h"

    30 

    31 #include "WebKitLogger.h"

    32 

    33 const int     KScrollbarWidth = 15;

    34 const TUint32 KMinScrollBarTransparency = 150;

    35 const int     KScrollBarFadeInterval = 30000;

    36 const TInt32  KScrollBarTransparencyStep = 10;

    37 const int     KMinThumbSize = 30;

    38 

    39 int handleFadeScrollBar(TAny* ptr);

    40 

    41 using namespace WebCore;

    42 

    43 WebScrollbarDrawer* WebScrollbarDrawer::NewL()

    44 {

    45   WebScrollbarDrawer* self = new(ELeave) WebScrollbarDrawer();

    46   CleanupStack::PushL(self);

    47   self->ConstructL();

    48   CleanupStack::Pop(); //self

    49   return self;

    50 }

    51 

    52 

    53 void WebScrollbarDrawer::ConstructL()

    54 {

    55   m_scrollBarFader = CPeriodic::NewL(CActive::EPriorityStandard);

    56 }

    57 

    58 

    59 

    60 WebScrollbarDrawer::WebScrollbarDrawer(): 

    61                                         m_webView(NULL),

    62                                         m_scrollBarTransparency(KMinScrollBarTransparency),

    63                                         m_scrollBarWidth(KScrollbarWidth),

    64                                         m_dX(0), m_dY(0)

    65 {

    66 }

    67 

    68 

    69 

    70 WebScrollbarDrawer::~WebScrollbarDrawer()

    71 {

    72   if (m_scrollBarFader) {

    73       m_scrollBarFader->Cancel();

    74   }

    75   delete m_scrollBarFader;

    76   

    77   removeBitmaps();  

    78 }

    79 

    80 

    81 void WebScrollbarDrawer::removeBitmaps()

    82 {

    83   deleteBitmap(m_scrollBarV, m_gcV, m_devV);

    84   deleteBitmap(m_scrollBarVMask, m_gcVMask, m_devVMask);

    85 

    86   deleteBitmap(m_scrollBarH, m_gcH, m_devH);

    87   deleteBitmap(m_scrollBarHMask, m_gcHMask, m_devHMask);

    88 	

    89 }

    90 

    91 TInt WebScrollbarDrawer::InitScrollbar(WebView* view)

    92 {

    93   TInt err = KErrNone;

    94   m_hasVScroll = EFalse;

    95   m_hasHScroll = EFalse;

    96   m_webView = view;  

    97   m_scrollBarTransparency = KMinScrollBarTransparency;

    98   m_dY = 0.0;

    99   m_dX = 0.0;

   100   calculateBitmapRects();

   101   

   102   err = SetupBitmaps();

   103   

   104   if (err == KErrNone) {

   105       constructSprite(m_spriteV, m_rectVThum.iTl, m_scrollBarV, m_scrollBarVMask);

   106       constructSprite(m_spriteH, m_rectHThum.iTl, m_scrollBarH, m_scrollBarHMask);

   107   }

   108   

   109   return err;

   110 }

   111 

   112 

   113 int WebScrollbarDrawer::fadeTime()

   114 {

   115     return KScrollBarFadeInterval;

   116 }

   117 

   118 void WebScrollbarDrawer::fadeScrollbar()

   119 {

   120   if (m_hasVScroll || m_hasHScroll) {

   121     if (!m_scrollBarFader->IsActive()) {

   122       m_scrollBarFader->Start(0, KScrollBarFadeInterval, 

   123                               TCallBack(&handleFadeScrollBar, this));

   124     }

   125   }

   126   else {

   127     m_scrollBarTransparency = 255;

   128     fade();

   129   }

   130 }

   131 

   132 

   133 int handleFadeScrollBar(TAny* ptr)

   134 {

   135   (static_cast<WebScrollbarDrawer*>(ptr))->fade();	

   136   return EFalse;

   137 }

   138 

   139 

   140 void WebScrollbarDrawer::clearSprites()

   141 {

   142    m_spriteV.Close();

   143    m_spriteH.Close();

   144 }

   145 

   146 void WebScrollbarDrawer::fade()

   147 {

   148   m_scrollBarTransparency += KScrollBarTransparencyStep;

   149   if (m_scrollBarTransparency >= 255) {

   150     m_scrollBarFader->Cancel();

   151     clearSprites();

   152     removeBitmaps();

   153     if (m_webView) {

   154       m_webView->syncRepaint(m_webView->mainFrame()->frameView()->visibleRect());

   155       m_webView = NULL;

   156     }

   157     m_hasVScroll = EFalse;

   158     m_hasHScroll = EFalse;

   159   }

   160   else {

   161     

   162     if (m_hasVScroll) {

   163       drawThumbMask(m_gcVMask, m_rectVThum);

   164       updateSprite(m_spriteV, m_scrollBarV, m_scrollBarVMask);

   165     }

   166     

   167     if (m_hasHScroll) {

   168       drawThumbMask(m_gcHMask, m_rectHThum);

   169       updateSprite(m_spriteH, m_scrollBarH, m_scrollBarHMask);

   170     }

   171   }

   172 }

   173 

   174 void WebScrollbarDrawer::redrawScrollbar()

   175 {

   176     TInt err = KErrNone;

   177     calculateBitmapRects();

   178     removeBitmaps();

   179     err = SetupBitmaps();

   180     if (err == KErrNone) {

   181         m_spriteV.SetPosition(m_rectVThum.iTl);

   182         updateSprite(m_spriteV, m_scrollBarV, m_scrollBarVMask);

   183         m_spriteH.SetPosition(m_rectHThum.iTl);

   184         updateSprite(m_spriteH, m_scrollBarH, m_scrollBarHMask);

   185     }

   186     else {

   187         clearSprites();

   188     }

   189 }

   190 

   191 void WebScrollbarDrawer::drawScrollbar(WebView* view, TPoint& scrollPos) 

   192 {

   193   if (!(view->brCtl()->capabilities() & TBrCtlDefs::ECapabilityDisplayScrollBar)) {

   194     return;  

   195   }

   196 

   197   if (m_scrollBarFader->IsActive()) {

   198     m_scrollBarFader->Cancel();

   199     clearSprites();

   200     removeBitmaps();

   201     m_hasVScroll = EFalse;

   202     m_hasHScroll = EFalse;

   203     m_webView = NULL;

   204   }

   205 

   206   if (!m_webView) {

   207     InitScrollbar(view);

   208   }

   209   

   210   if (!m_hasHScroll) { //set it only once

   211     m_hasHScroll = (scrollPos.iX != 0) && (m_displayWidth < m_docWidth);

   212   }

   213   

   214   if (!m_hasVScroll) {  //set it only once

   215     m_hasVScroll = (scrollPos.iY != 0) && (m_displayHeight < m_docHeight);

   216   }

   217 

   218   if ((scrollPos.iY != 0) && (m_displayHeight < m_docHeight)) {

   219     m_dY += m_zoomFactor * ((float)scrollPos.iY * (float)m_displayHeight ) / (float)m_docHeight / 100;

   220 

   221     if (m_rectVThum.iTl.iY + m_dY < m_rectV.iTl.iY) {

   222         m_dY = m_rectV.iTl.iY - m_rectVThum.iTl.iY; 

   223     }

   224     else if (m_rectVThum.iBr.iY + m_dY > m_rectV.iBr.iY) {

   225         m_dY = m_rectV.iBr.iY - m_rectVThum.iBr.iY;

   226     }

   227     else if ((m_rectVThum.iTl.iY + m_dY == m_rectV.iTl.iY) ||

   228             (m_rectVThum.iBr.iY + m_dY == m_rectV.iBr.iY)) {

   229         m_dY = 0.0;        

   230     }

   231     

   232     

   233     if (Abs(m_dY) > 1) { 

   234       m_rectVThum.Move(0, m_dY);

   235       m_dY = 0.0;

   236     }

   237     

   238     m_spriteV.SetPosition(m_rectVThum.iTl);

   239     updateSprite(m_spriteV, m_scrollBarV, m_scrollBarVMask);

   240   }

   241   

   242   

   243   if ((scrollPos.iX != 0) && (m_displayWidth < m_docWidth)) {

   244     m_dX = m_zoomFactor * ((float)scrollPos.iX * (float)m_displayWidth ) / (float)m_docWidth / 100;

   245     

   246     if (m_rectHThum.iTl.iX + m_dX < m_rectH.iTl.iX) {

   247         m_dX = m_rectH.iTl.iX - m_rectHThum.iTl.iX; 

   248     }

   249     else if (m_rectHThum.iBr.iX + m_dX > m_rectH.iBr.iX) {

   250         m_dX = m_rectH.iBr.iX - m_rectHThum.iBr.iX;

   251     }

   252     else if ((m_rectHThum.iTl.iX + m_dX == m_rectH.iTl.iX) ||

   253              (m_rectHThum.iBr.iX + m_dX == m_rectH.iBr.iX)) {

   254         m_dX = 0.0;         

   255     }

   256     

   257     

   258     if (Abs(m_dX) > 1) {

   259       m_rectHThum.Move(m_dX, 0);

   260     }

   261 

   262     m_spriteH.SetPosition(m_rectHThum.iTl);

   263     updateSprite(m_spriteH, m_scrollBarH, m_scrollBarHMask);

   264   }

   265   

   266   

   267   

   268 }

   269 

   270 void WebScrollbarDrawer::constructSprite(RWsSprite& sprite, TPoint& pos,

   271 		                                 CFbsBitmap* bitmap, CFbsBitmap* bitmapMask)

   272 {

   273   sprite = RWsSprite(m_webView->brCtl()->CCoeControlParent()->ControlEnv()->WsSession());

   274   RDrawableWindow *window =  (RDrawableWindow* )m_webView->brCtl()->CCoeControlParent()->DrawableWindow();

   275   sprite.Construct(*window, pos, ESpriteNoChildClip);

   276   

   277   TSpriteMember spriteMem;

   278   spriteMem.iBitmap = 0;//bitmap;

   279   spriteMem.iMaskBitmap = 0;//bitmapMask;

   280   spriteMem.iInvertMask = EFalse;

   281 

   282   sprite.AppendMember(spriteMem);

   283   sprite.Activate();

   284 }

   285 

   286 void WebScrollbarDrawer::updateSprite(RWsSprite& sprite, CFbsBitmap* bitmap, 

   287                                       CFbsBitmap* bitmapMask)

   288 {

   289   TSpriteMember spriteMem;

   290   spriteMem.iBitmap = bitmap;

   291   spriteMem.iMaskBitmap = bitmapMask;

   292   spriteMem.iInvertMask = ETrue;  

   293   sprite.UpdateMember(0, spriteMem);

   294 }

   295 

   296 TInt WebScrollbarDrawer::createBitmap(CFbsBitmap*& bm, CFbsBitGc*& gc, 

   297 		                               CFbsBitmapDevice*& dev, TRect& rect)

   298 {

   299   TInt err = KErrNone;

   300   bm = new CFbsBitmap();

   301   if (!bm) {

   302       err = KErrNoMemory;

   303   }

   304   if (err == KErrNone) {

   305       bm->Create(rect.Size(), EColor256);

   306   }

   307   TRAP(err, dev = CFbsBitmapDevice::NewL(bm));

   308   if (err == KErrNone && dev != NULL) {

   309     err = dev->CreateContext(gc);

   310   }

   311   if (err != KErrNone) {

   312       delete dev;

   313   }

   314   return err;

   315 }

   316 

   317 

   318 void WebScrollbarDrawer::deleteBitmap(CFbsBitmap*& bm, CFbsBitGc*& gc, 

   319 		                               CFbsBitmapDevice*& dev)

   320 {

   321   if (bm) {

   322     delete bm;

   323     bm = NULL;

   324   }

   325   

   326   if (gc) {

   327     delete gc;

   328     gc = NULL;

   329   }

   330 	

   331   if (dev) {

   332     delete dev;

   333     dev = NULL;

   334   }

   335 }

   336 

   337 TInt WebScrollbarDrawer::SetupBitmaps()

   338 {

   339   TInt err = KErrNone;

   340   if (!m_scrollBarV) {

   341     err = createBitmap(m_scrollBarV, m_gcV, m_devV, m_rectVThum);

   342   }

   343   

   344   if (!m_scrollBarVMask && err == KErrNone) {

   345     err = createBitmap(m_scrollBarVMask, m_gcVMask, m_devVMask, m_rectVThum);

   346   }

   347   

   348   if (err == KErrNone) {

   349       drawThumb(m_gcV, m_rectVThum);

   350       drawThumbMask(m_gcVMask, m_rectVThum);

   351   }

   352 

   353   if (!m_scrollBarH && err == KErrNone) {

   354     err = createBitmap(m_scrollBarH, m_gcH, m_devH, m_rectHThum);

   355   }

   356     

   357   if (!m_scrollBarHMask && err == KErrNone) {

   358     err = createBitmap(m_scrollBarHMask, m_gcHMask, m_devHMask, m_rectHThum);

   359   }

   360   

   361   if (err == KErrNone) {

   362       drawThumb(m_gcH, m_rectHThum);

   363       drawThumbMask(m_gcHMask, m_rectHThum);

   364   }

   365   

   366   return err;

   367 }

   368 

   369 

   370 void WebScrollbarDrawer::calculateBitmapRects()

   371 {

   372   m_zoomFactor =  ((float)m_webView->scalingFactor() / 100);

   373   m_rect.SetRect(m_webView->brCtl()->Rect().iTl,

   374 		         m_webView->brCtl()->Rect().Size());

   375   int delta = 0;

   376   int posX = m_zoomFactor * m_webView->mainFrame()->frameView()->contentPos().iX;

   377   int posY = m_zoomFactor * m_webView->mainFrame()->frameView()->contentPos().iY;

   378   m_docWidth = m_zoomFactor * m_webView->mainFrame()->frameView()->contentSize().iWidth;

   379   m_displayWidth = m_rect.Width();

   380   m_docHeight = m_zoomFactor * m_webView->mainFrame()->frameView()->contentSize().iHeight;

   381   m_displayHeight = m_rect.Height();

   382     

   383   m_docHeight = (m_displayHeight > m_docHeight) ? m_displayHeight : m_docHeight;

   384   m_docWidth = (m_displayWidth > m_docWidth) ? m_displayWidth : m_docWidth;

   385   

   386   bool shouldHaveHScroll = (m_displayWidth < m_docWidth); 

   387   bool shouldHaveVScroll = (m_displayHeight < m_docHeight);

   388   TPoint vThumbTl;

   389   TPoint hThumbTl;

   390   

   391   if (AknLayoutUtils::LayoutMirrored()) {

   392     if (shouldHaveHScroll) { //horizontal scroll bar

   393       delta = shouldHaveVScroll ? m_scrollBarWidth : 0; //to ajust thumb and scrollbar rect

   394       m_rectH.SetRect(0 + delta, m_rect.Height() - m_scrollBarWidth, m_rect.Width(), m_rect.Height());

   395       hThumbTl.SetXY(m_scrollBarWidth + (posX * m_rectH.Width()) / m_docWidth, 

   396 	                 m_rect.Height() - m_scrollBarWidth);

   397     }

   398     

   399     if (shouldHaveVScroll) {

   400       delta = shouldHaveHScroll ? m_scrollBarWidth : 0; //to ajust thumb and scrollbar rect

   401       m_rectV.SetRect(0, 0, m_scrollBarWidth, m_rect.Height() - delta);

   402       vThumbTl.SetXY(0, (posY * m_rectV.Height()) / m_docHeight);

   403     }

   404   }

   405   else {

   406     if (shouldHaveHScroll) {

   407       delta = shouldHaveVScroll ? m_scrollBarWidth : 0; //to ajust thumb and scrollbar rect

   408       m_rectH.SetRect(0, m_rect.Height() - m_scrollBarWidth, 

   409                     m_rect.Width() - delta, m_rect.Height());

   410       hThumbTl.SetXY((posX * m_rectH.Width()) / m_docWidth, 

   411                      m_rect.Height() - m_scrollBarWidth);

   412     }   

   413     

   414     if (shouldHaveVScroll) {

   415       delta = shouldHaveHScroll ? m_scrollBarWidth : 0; //to ajust thumb and scrollbar rect

   416       m_rectV.SetRect(m_rect.Width() - m_scrollBarWidth, 0, 

   417    		              m_rect.Width(), m_rect.Height() - delta);

   418       vThumbTl.SetXY(m_rect.Width() - m_scrollBarWidth, 

   419                      ((posY * m_rectV.Height()) / m_docHeight));

   420     }

   421   }

   422   

   423   if (shouldHaveHScroll) {

   424     int thW = ((float)m_rectH.Width() * m_displayWidth) / m_docWidth;

   425     thW = (thW < KMinThumbSize) ? KMinThumbSize : thW;

   426     m_rectHThum.SetRect(hThumbTl, TSize(thW, m_scrollBarWidth));       

   427     if (m_rectHThum.iBr.iX > m_rectH.iBr.iX) {

   428       m_rectHThum.Move(m_rectH.iBr.iX - m_rectHThum.iBr.iX, 0);

   429     }

   430   }

   431   

   432   if (shouldHaveVScroll) {

   433     int thH = ((float)m_rectV.Height() * m_displayHeight) / m_docHeight;

   434     thH = (thH < KMinThumbSize) ? KMinThumbSize : thH;

   435     m_rectVThum.SetRect(vThumbTl, TSize(m_scrollBarWidth, thH));

   436     if (m_rectVThum.iBr.iY > m_rectV.iBr.iY) {

   437       m_rectVThum.Move(0, m_rectV.iBr.iY - m_rectVThum.iBr.iY);

   438     }

   439   }

   440 }

   441 

   442 

   443 void WebScrollbarDrawer::drawThumb(CBitmapContext* gc, TRect& rect)

   444 {

   445   TRect r(TPoint(0, 0), rect.Size());

   446   gc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   447   gc->SetPenStyle(CGraphicsContext::ESolidPen);

   448   gc->SetPenSize(TSize(2,2));

   449   gc->SetPenColor(TRgb(242, 242, 242));

   450   gc->SetBrushColor(TRgb(10, 10, 10));

   451   gc->DrawRoundRect(r, TSize(7, 7));

   452  

   453 }

   454 

   455 

   456 

   457 void WebScrollbarDrawer::drawThumbMask(CBitmapContext* gc, TRect& rect)

   458 {

   459   TRect r(TPoint(0, 0), rect.Size());

   460   TRgb  penMaskColor = TRgb(m_scrollBarTransparency, m_scrollBarTransparency, m_scrollBarTransparency);

   461   TRgb  brushMaskColor = TRgb(m_scrollBarTransparency, m_scrollBarTransparency, m_scrollBarTransparency);;

   462 

   463   gc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   464   gc->SetPenStyle(CGraphicsContext::ESolidPen);

   465   gc->SetBrushColor(brushMaskColor);

   466   gc->SetPenSize(TSize(2,2));

   467   gc->SetPenColor(TRgb(5, 5, 5));

   468   gc->DrawRoundRect(r, TSize(7, 7));

   469 }

   470