1 /*

     2 * Copyright (C) 2005, 2006, 2007 Apple Inc. All rights reserved.

     3 * Copyright (C) 2006 David Smith (catfish.man@gmail.com)

     4 * Copyright (C) 2007 Nokia

     5 *

     6 * Redistribution and use in source and binary forms, with or without

     7 * modification, are permitted provided that the following conditions

     8 * are met:

     9 *

    10 * 1.  Redistributions of source code must retain the above copyright

    11 *     notice, this list of conditions and the following disclaimer.

    12 * 2.  Redistributions in binary form must reproduce the above copyright

    13 *     notice, this list of conditions and the following disclaimer in the

    14 *     documentation and/or other materials provided with the distribution.

    15 * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of

    16 *     its contributors may be used to endorse or promote products derived

    17 *     from this software without specific prior written permission.

    18 *

    19 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY

    20 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

    21 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

    22 * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY

    23 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

    24 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

    25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

    26 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

    27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

    28 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    29 */

    30 

    31 #include <Browser_platform_variant.hrh>

    32 #include "config.h"

    33 #include "../../bidi.h"

    34 #include "brctl.h"

    35 #include "HistoryController.h"

    36 #include "PageView.h"

    37 #include "SettingsContainer.h"

    38 #include "WebFrame.h"

    39 #include "WebFrameBridge.h"

    40 #include "WebFrameView.h"

    41 #include "WebView.h"

    42 #include "WebTabbedNavigation.h"

    43 #include "WebChromeClient.h"

    44 #include "WebCoreGraphicsContext.h"

    45 #include "WebContextMenuClient.h"

    46 #include "WebEditorClient.h"

    47 #include "WebDragClient.h"

    48 #include "WebFrameLoaderClient.h"

    49 #include "WebInspectorClient.h"

    50 #include "WebFepTextEditor.h"

    51 #include "WebSurface.h"

    52 #include "WebCursor.h"

    53 #include "WebFormFill.h"

    54 #include "WebFormFillPopup.h"

    55 #include "WebToolBarInterface.h"

    56 #include "WebPointerEventHandler.h"

    57 #include "WebPageScrollHandler.h"

    58 #include "WebPopupDrawer.h"

    59 #include "PluginSkin.h"

    60 #include "PluginWin.h"

    61 #include "PluginPlayer.h"

    62 

    63 

    64 #include "Page.h"

    65 #include "Settings.h"

    66 #include "Frame.h"

    67 #include "FrameView.h"

    68 #include "FrameTree.h"

    69 #include "FrameLoader.h"

    70 #include "HistoryItem.h"

    71 #include "EventHandler.h"

    72 #include "ResourceRequest.h"

    73 #include "PlatformString.h"

    74 #include "SelectionController.h"

    75 #include "PlatformKeyboardEvent.h"

    76 #include "PlatformScrollbar.h"

    77 #include "DocumentLoader.h"

    78 #include "StaticObjectsContainer.h"

    79 #include "ToolBar.h"

    80 #include "Document.h"

    81 #include "FocusController.h"

    82 #include "WebUtil.h"

    83 #include "WidgetExtension.h"

    84 #include "Cache.h"

    85 #include "RenderWidget.h"

    86 

    87 #include <AknUtils.h>

    88 #include <CUserAgent.h>

    89 #include "WebPageZoomHandler.h"

    90 

    91 #include "PlatformFontCache.h"

    92 #include "WebPageFullScreenHandler.h"

    93 #include "eikon.hrh"

    94 #include "WebScrollbarDrawer.h"

    95 

    96 

    97 using namespace WebCore;

    98 

    99 const int KRepaintDelayLoading = 500*1000; // dont do repaints more often than this during loading (0.5s)

   100 const int KRepaintDelayComplete = 100*1000; // faster updates after load so dynamic scripts etc have better frame rate (0.1s)

   101 const int KNormalScrollRange = 60;

   102 

   103 const int KPanningStartSpeed = 30;

   104 const int KPanningStartTime = 900;

   105 const int KPanningPageScalerStart = 1300;

   106 const int KPanningMaxSpeed = 90;

   107 const int KPanningMaxTime = 3000;

   108 const int KAllowSelection = 1;

   109 

   110 const int KScalerVisibilityTime = 1100*1000; //1.1s

   111 

   112 const int KCursorUpdateFrquency = 20*1000; // 20ms

   113 const int KCursorInitialDelay = 200*1000;  // 200ms

   114 const TKeyEvent KNullKeyEvent = {0,0,0,0};

   115 const int KSmallPageScale = 13*13;    // if the area of page is less than 169% (130%*130%) of the viewport area, it's considered to be a small page

   116 const int KZoomLevelDelta = 10; //set 10% for each increasment

   117 

   118 const int KZoomLevelDefaultValue = 100;

   119 const int KZoomLevelMaxValue = 200;

   120 const int KZoomLevelMinValue = 10;

   121 

   122 const int KZoomBgRectColor = 209;

   123 const int KZoomDefaultLevel = 8; //100%

   124 const int defaultCacheCapacity = 256 * 1024;

   125 

   126 // LOCAL FUNCTION PROTOTYPES

   127 TInt doRepaintCb( TAny* ptr );

   128 TInt doFepCb( TAny* ptr );

   129 

   130 static WebFrame* incrementFrame(WebFrame* curr, bool forward, bool wrapFlag)

   131 {

   132     Frame* coreFrame = core(curr);

   133     return kit(forward

   134         ? coreFrame->tree()->traverseNextWithWrap(wrapFlag)

   135         : coreFrame->tree()->traversePreviousWithWrap(wrapFlag));

   136 }

   137 

   138 

   139 

   140 // -----------------------------------------------------------------------------

   141 // CWebKitView::NewL

   142 // Public Class Method

   143 // Two-phased constructor.

   144 // -----------------------------------------------------------------------------

   145 WebView* WebView::NewL(

   146                        CCoeControl& parent, CBrCtl* brctl )

   147 {

   148     WebView* self = new (ELeave) WebView( brctl );

   149 

   150     CleanupStack::PushL( self );

   151     self->ConstructL( parent );

   152     CleanupStack::Pop(); // self

   153 

   154     return self;

   155 }

   156 

   157 // -----------------------------------------------------------------------------

   158 // CWebKitView::CWebKitView

   159 // Private Class Method

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

   161 // -----------------------------------------------------------------------------

   162 WebView::WebView( CBrCtl* brctl ) :

   163 m_brctl(brctl)

   164 , m_isEditable(false)

   165 , m_currentEventKey(KNullKeyEvent)

   166 , m_scrollingSpeed(KNormalScrollRange*KZoomLevelDefaultValue/100)

   167 , m_focusedElementType(TBrCtlDefs::EElementNone)

   168 , m_pageScaler(NULL)

   169 , m_pageScalerEnabled(false)

   170 , m_inFindState(false)

   171 , m_pageView(NULL)

   172 , m_savedCursorPosition(KInitialOffset, KInitialOffset)

   173 , m_findKeyword(NULL)

   174 , m_webFormFill(NULL)

   175 , m_fepTimer(0)

   176 , m_isClosing(false)

   177 , m_widgetextension(0)

   178 , m_userAgent(NULL)

   179 , m_pageZoomHandler(NULL)

   180 , m_currentZoomLevel(KZoomLevelDefaultValue)

   181 , m_lastZoomLevel(KZoomLevelMinValue)

   182 , m_maxZoomLevel(KZoomLevelMaxValue)

   183 , m_minZoomLevel(KZoomLevelMinValue)

   184 , m_defaultZoomLevel(KZoomLevelDefaultValue)

   185 , m_pageFullScreenHandler(NULL)

   186 , m_viewIsScrolling(false)

   187 , m_ptrbuffer(0)

   188 , m_pluginActivated(false)

   189 , m_showCursor(false)

   190 , m_allowRepaints(true)

   191 {

   192 }

   193 

   194 WebView::~WebView()

   195 {

   196     // the zoom handler is a client of WebView (also owned by

   197     // WebView--a circular dependency) so it must be deleted before

   198     // the WebView object is destroyed because in its destructor it

   199     // operates on the WebView object

   200     delete m_pageZoomHandler;

   201     m_pageZoomHandler = NULL;

   202 

   203     // prevent frameViews to access members when topView is

   204     // closing down.

   205     m_isClosing = true;

   206     m_page->setGroupName(String());

   207 

   208     if (m_fastScrollTimer)

   209         m_fastScrollTimer->Cancel();

   210     delete m_fastScrollTimer;

   211 

   212     delete [] m_ptrbuffer;

   213     delete m_repainttimer;

   214     delete m_webfeptexteditor;

   215     delete m_webcorecontext;

   216     delete m_bitmapdevice;

   217     delete m_page;

   218     delete m_pageScaler;

   219     delete m_pageView;

   220     delete m_webFormFill;

   221     delete m_toolbar;

   222     delete m_toolbarinterface;

   223     delete m_widgetextension;

   224     delete m_webpointerEventHandler;

   225     delete m_pageScrollHandler;

   226     delete m_pluginplayer;

   227     delete m_fepTimer;

   228     delete m_popupDrawer;

   229     delete m_tabbedNavigation;

   230     delete m_userAgent;

   231     delete m_pageFullScreenHandler;

   232 }

   233 

   234 // -----------------------------------------------------------------------------

   235 // CWebKitView::ConstructL

   236 // Private Class Method

   237 // Symbian 2nd phase constructor can leave.

   238 // -----------------------------------------------------------------------------

   239 void WebView::ConstructL(

   240                          CCoeControl& parent)

   241 {

   242     SetContainerWindowL(parent);

   243 

   244     CCoeControl::MakeVisible(ETrue);

   245 

   246     WebFrameView *frameView = new WebFrameView();

   247     m_page = new Page(new WebChromeClient(this), new WebContextMenuClient(), new WebEditorClient(this), new WebDragClient(), new WebInspectorClient());

   248     m_page->backForwardList()->setCapacity(0);

   249     m_page->setGroupName("com.s60.browser");

   250     //

   251     WebCore::Settings* settings = m_page->settings();

   252     settings->setLoadsImagesAutomatically(true);

   253     settings->setJavaScriptEnabled(true);

   254 

   255     settings->setMinimumFontSize(7);

   256     settings->setMinimumLogicalFontSize(9);

   257     settings->setDefaultFontSize(12);

   258     settings->setDefaultFixedFontSize(12);

   259     settings->setPluginsEnabled(true);

   260     settings->setJavaScriptCanOpenWindowsAutomatically(true);

   261     settings->setPluginsEnabled(true);

   262 

   263     m_tabbedNavigation = new WebTabbedNavigation(this);

   264 

   265     WebFrameBridge* bridge = new WebFrameBridge();

   266     bridge->initMainFrameWithPage(m_page, "", frameView);

   267 

   268     // Create and offscreen device and context

   269     m_bitmapdevice = CFbsBitmapDevice::NewL( StaticObjectsContainer::instance()->webSurface()->offscreenBitmap() );

   270     m_webcorecontext = WebCoreGraphicsContext::NewL( m_bitmapdevice, StaticObjectsContainer::instance()->webSurface()->offscreenBitmap(), mainFrame()->frameView());

   271     //

   272     m_repainttimer = CPeriodic::NewL(CActive::EPriorityHigh);

   273 

   274     m_webfeptexteditor = new CWebFepTextEditor(this);

   275 

   276     m_fastScrollTimer = CPeriodic::NewL(CActive::EPriorityHigh);

   277 

   278     m_dirtyZoomMode = false;

   279     m_currentZoomLevel = StaticObjectsContainer::instance()->fontCache()->fontZoomFactor();

   280     m_startZoomLevel = m_currentZoomLevel;

   281 

   282     m_pageZoomHandler = WebPageZoomHandler::NewL( *this );

   283     if ( brCtl()->capabilities()&TBrCtlDefs::ECapabilityFitToScreen ) {

   284         m_minZoomLevel = (KZoomLevelDefaultValue / m_pageZoomHandler->stepSize())*m_pageZoomHandler->stepSize();

   285         //could happen only if m_minZoomLevel < stepSize

   286         if (!m_minZoomLevel) m_minZoomLevel = m_pageZoomHandler->stepSize();

   287     }

   288 

   289     // construct the zoom array from the default level

   290     m_zoomLevelArray.Append(KZoomLevelDefaultValue);

   291     TInt toAddZoomLevel = KZoomLevelDefaultValue + KZoomLevelDefaultValue*KZoomLevelDelta/100;

   292     while (toAddZoomLevel <= m_maxZoomLevel)

   293         {

   294         // add the zoom level after default one

   295         m_zoomLevelArray.Append(toAddZoomLevel);

   296         toAddZoomLevel = toAddZoomLevel + toAddZoomLevel*KZoomLevelDelta/100;

   297         }

   298 

   299     // now go the minimum one

   300     toAddZoomLevel = KZoomLevelDefaultValue - KZoomLevelDefaultValue*KZoomLevelDelta/100;

   301     while (toAddZoomLevel >= m_minZoomLevel)

   302         {

   303         //add the zoom level after default one

   304         m_zoomLevelArray.Insert(toAddZoomLevel, 0);

   305         toAddZoomLevel = toAddZoomLevel - toAddZoomLevel*KZoomLevelDelta/100;

   306         }

   307 

   308     m_pageFullScreenHandler = WebPageFullScreenHandler::NewL( *this );

   309 

   310     if ( m_brctl->capabilities() & TBrCtlDefs::ECapabilityWebKitLite ) {

   311         m_pageScalerEnabled = false;

   312     }

   313     else  {

   314         initializePageScalerL();

   315         m_pageScalerEnabled = true;

   316     }

   317     if (m_brctl->capabilities() & TBrCtlDefs::ECapabilityAutoFormFill) {

   318         m_webFormFill = new WebFormFill(this);

   319     }

   320 

   321     // Create the PointerEventHandler

   322     m_ptrbuffer = new TPoint[256];

   323     m_webpointerEventHandler = WebPointerEventHandler::NewL(this);

   324 

   325     // Create the ScrollHandler

   326     m_pageScrollHandler = WebPageScrollHandler::NewL( *this );

   327     if (AknLayoutUtils::PenEnabled()) {

   328         DrawableWindow()->SetPointerGrab(ETrue);

   329         EnableDragEvents();

   330     }

   331 

   332     CUserAgent* usrAgnt = CUserAgent::NewL();

   333     CleanupStack::PushL( usrAgnt );

   334     HBufC8* userAgent8 = usrAgnt->UserAgentL();

   335     CleanupStack::PushL( userAgent8 );

   336     m_userAgent = HBufC::NewL(userAgent8->Length());

   337     m_userAgent->Des().Copy(userAgent8->Des());

   338     CleanupStack::PopAndDestroy(2); // userAgent8, usrAgnt

   339 

   340     MakeViewVisible(ETrue);

   341     m_isPluginsVisible=ETrue;

   342     CCoeControl::SetFocus(ETrue);

   343 

   344     cache()->setCapacities(0, 0, defaultCacheCapacity);

   345 }

   346 

   347 void WebView::initializePageScalerL()

   348 {

   349     TBool lowQuality = !( m_brctl->capabilities() & TBrCtlDefs::ECapabilityGraphicalHistory );

   350     m_pageScaler = CPageScaler::NewL( *this, EColor64K, lowQuality );

   351     m_pageScaler->SetVisible( EFalse );

   352     //update the minimap support info from page scaler

   353     m_pageScalerEnabled = (m_pageScaler->HasOverlaySupport());

   354 }

   355 

   356 

   357 void WebView::fepTimerFired(Timer<WebView>*)

   358 {

   359     CCoeEnv::Static()->SimulateKeyEventL(m_keyevent, m_eventcode);

   360 }

   361 

   362 //-------------------------------------------------------------------------------

   363 // Draw ( from CCoeControl )

   364 // BitBlts the offscreen bitmap to the GraphicsContext

   365 //-------------------------------------------------------------------------------

   366 void WebView::Draw(

   367                    const TRect& rect ) const

   368 {

   369     if (m_pluginFullscreen) return;

   370 

   371     CWindowGc& gc = SystemGc();

   372     CEikBorderedControl::Draw( rect );

   373 

   374     // put offscreen bitmap onto the screen

   375 

   376     if ( !m_dirtyZoomMode ) {

   377         StaticObjectsContainer::instance()->webSurface()->flip( Rect().iTl, gc );

   378         if (m_widgetextension){

   379             m_widgetextension->DrawTransition(gc,StaticObjectsContainer::instance()->webSurface()->offscreenBitmap());

   380         }

   381     }

   382     else {

   383         gc.DrawBitmap( m_destRectForZooming, StaticObjectsContainer::instance()->webSurface()->offscreenBitmap(), m_srcRectForZooming );

   384 

   385         if ( m_startZoomLevel > m_currentZoomLevel) {

   386 

   387             TRect rectLeft( TPoint( rect.iTl.iX + m_destRectForZooming.Width() - 2, rect.iTl.iY ),

   388                             TPoint( rect.iBr ));

   389 

   390             TRect rectBottom( TPoint( rect.iTl.iX, rect.iTl.iY + m_destRectForZooming.Height() - 2 ),

   391                               TPoint( rect.iBr.iX + m_destRectForZooming.Width(), rect.iBr.iY ));

   392 

   393 

   394             const TRgb colorTest(KZoomBgRectColor,KZoomBgRectColor,KZoomBgRectColor);

   395             gc.SetPenColor(colorTest);

   396             gc.SetBrushStyle( CGraphicsContext::EForwardDiagonalHatchBrush );

   397             gc.SetBrushColor(colorTest);

   398             gc.DrawRect( rectLeft );

   399             gc.DrawRect( rectBottom );

   400 

   401         }

   402 

   403     }

   404 

   405     if (m_pageScalerEnabled && m_pageScaler->Visible()) {

   406         m_pageScaler->Draw( gc, rect );

   407     }

   408 

   409     if (m_toolbar) {

   410         m_toolbar->Draw();

   411     }

   412 

   413     if (m_popupDrawer)

   414     {

   415         m_popupDrawer->drawPopup();

   416     }

   417 

   418     if (m_widgetextension){

   419         m_widgetextension->DrawTransition(gc,StaticObjectsContainer::instance()->webSurface()->offscreenBitmap());

   420     }

   421 

   422 

   423 }

   424 

   425 

   426 WebCore::Page* WebView::page()

   427 {

   428     return m_page;

   429 }

   430 

   431 

   432 WebFrame* WebView::mainFrame()

   433 {

   434     if (!m_page)

   435         return NULL;

   436     return kit(m_page->mainFrame());

   437 }

   438 

   439 //-------------------------------------------------------------------------------

   440 // SyncRepaint

   441 // Repaint the given rectangle synchronously

   442 //-------------------------------------------------------------------------------

   443 void WebView::syncRepaint(

   444                           const TRect& rect)

   445 {

   446     m_repaints.AddRect( rect );

   447     syncRepaint();

   448 }

   449 

   450 void WebView::MakeVisible(TBool visible)

   451 {

   452     if (visible == IsVisible()) return;

   453     CCoeControl::MakeVisible(visible);

   454     MakeViewVisible(visible);

   455 }

   456 

   457 void WebView::MakeViewVisible(TBool visible)

   458 {

   459     if ( visible ) {

   460         // resize the offscreen surface, this is needed

   461         // because the shared surface is changed.

   462         StaticObjectsContainer::instance()->webSurface()->setView( this );

   463         m_bitmapdevice->Resize( m_offscreenrect.Size() );

   464         m_webcorecontext->resized();

   465     }

   466     WebCursor* cursor = StaticObjectsContainer::instance()->webCursor();

   467     if (cursor) {

   468         if (visible) {

   469             cursor->setCurrentView(*this);

   470             //Reset the iFocusedElementType to be the same as before the second window is opened.

   471             cursor->setPosition(m_savedCursorPosition);

   472             cursor->updatePositionAndElemType(m_savedCursorPosition);

   473         } else

   474             m_savedCursorPosition = cursor->position();

   475         cursor->cursorUpdate(visible & !AknLayoutUtils::PenEnabled());

   476     }

   477     Frame* f = m_page->mainFrame();

   478     while ( f ) {

   479         PassRefPtr<HTMLCollection> objects = f->document()->objects();

   480         for (Node* n = objects->firstItem(); n; n = objects->nextItem()) {

   481             MWebCoreObjectWidget* w = widget(n);

   482             if (w)

   483                 w->makeVisible(visible);

   484         }

   485         PassRefPtr<HTMLCollection> embeds = f->document()->embeds();

   486         for (Node* n = embeds->firstItem(); n; n = embeds->nextItem()) {

   487             MWebCoreObjectWidget* w = widget(n);

   488             if (w)

   489                 w->makeVisible(visible);

   490         }

   491         f = f->tree()->traverseNext();

   492     }

   493     if ( m_pageScaler )  {

   494         m_pageScaler->SetContainerRect(TRect(Rect().Size()));

   495     }

   496     if ( m_webFormFillPopup ){

   497         // don't show the popup if view's visibility changes.

   498         m_webFormFillPopup->MakeVisible(EFalse);

   499     }

   500 

   501     if ( visible ) {

   502       clearOffScreenBitmap();

   503       syncRepaint( mainFrame()->frameView()->visibleRect() );

   504     }

   505 

   506 }

   507 

   508 

   509 

   510 void WebView::doLayout()

   511 {

   512 

   513     int zoomLevel = m_currentZoomLevel;

   514     if(!(   m_widgetextension && m_widgetextension->IsWidgetPublising())) {

   515         zoomLevelChanged( KZoomLevelDefaultValue );

   516     }

   517     Frame* f = m_page->mainFrame();

   518 

   519     while ( f ) {

   520         f->sendResizeEvent();

   521         f->view()->layout();

   522         f = f->tree()->traverseNext();

   523     }

   524         // maybe it got bigger in layout?

   525     TRect rect(m_repaints.BoundingRect());

   526 

   527     TPoint p( mainFrame()->frameView()->contentPos());

   528 

   529     rect.Move(-p);

   530 

   531       // draw to back buffer

   532 

   533    

   534     if(!(   m_widgetextension && m_widgetextension->IsWidgetPublising())) {

   535         mainFrame()->frameView()->draw( *m_webcorecontext, rect );

   536         if ( zoomLevel < m_minZoomLevel ) zoomLevel = m_minZoomLevel;

   537         zoomLevelChanged( zoomLevel );

   538     }

   539 }

   540 //-------------------------------------------------------------------------------

   541 // SyncRepaint

   542 // Repaint the current repaint region synchronously and clear it

   543 //-------------------------------------------------------------------------------

   544 void WebView::syncRepaint()

   545 {

   546     if (m_pageScaler && m_pageScaler->FullScreenMode()) {

   547       ScaledPageChanged(m_pageScaler->Rect(), EFalse, EFalse);

   548       return;

   549     }

   550 

   551     if (!IsVisible()) {

   552       return;

   553     }

   554 

   555     if (isPluginFullscreen()) return;

   556     CFbsBitGc& gc = m_webcorecontext->gc();

   557     gc.Reset();

   558 

   559     TRect viewRect( mainFrame()->frameView()->visibleRect() );

   560     TPoint p( mainFrame()->frameView()->contentPos());

   561     Frame* f = m_page->mainFrame();

   562     bool layoutPending = false;

   563     while (f && !layoutPending) {

   564         layoutPending = f->view()->layoutPending();

   565         f = f->tree()->traverseNext();

   566     }

   567     if (!layoutPending) {

   568         bool needsDraw = false;

   569         m_repaints.Tidy();

   570         for (int i=0; i<m_repaints.Count(); ++i) {

   571             TRect r = m_repaints[i];

   572             if (r.Intersects(viewRect)) {

   573                 r.Move(-p);

   574                 mainFrame()->frameView()->draw( *m_webcorecontext, r );

   575                 needsDraw = true;

   576             }

   577         }

   578 

   579         if (needsDraw){

   580             // blit the whole backbuffer to the screen (in Draw())

   581             // This could be optimized further to blit only the affected area.

   582             // Not a big win, scrolling is the most critical case and there you

   583             // need to blit the whole buffer anyway.

   584             m_brctl->DrawNow();

   585         }

   586 

   587         // dont do next async repaint until KRepaintDelay

   588         m_repaints.Clear();

   589     }

   590     m_repainttimer->Cancel();

   591     // tot:fixme TBool complete = iWebkitControl->IsProgressComplete(); && CImageRendererFactory::Instance()->DecodeCount()==0;

   592 

   593     TBool complete = ETrue;

   594     if ( !m_pageZoomHandler->isActive() && m_allowRepaints){

   595         m_repainttimer->Start(complete ? KRepaintDelayComplete : KRepaintDelayLoading,

   596         0, TCallBack( &doRepaintCb, this ) );

   597     }

   598     // need to draw formfill popup here.

   599     if (m_webFormFillPopup && m_webFormFillPopup->IsVisible()) {

   600         m_webFormFillPopup->reDraw();

   601     }

   602 }

   603 

   604 //-------------------------------------------------------------------------------

   605 // DoRepaintCb

   606 // C-style TCallback function

   607 //-------------------------------------------------------------------------------

   608 TInt doRepaintCb(

   609                  TAny* ptr )

   610 {

   611     static_cast<WebView*>(ptr)->doRepaint();

   612     return EFalse;

   613 }

   614 

   615 //-------------------------------------------------------------------------------

   616 // DoRepaint

   617 // Perform a scheduled repaint

   618 //-------------------------------------------------------------------------------

   619 void WebView::doRepaint()

   620 {

   621     // the timer must always be canceled here!

   622       m_repainttimer->Cancel();

   623 

   624     // only repaint when this view owns the surface

   625       if ( StaticObjectsContainer::instance()->webSurface()->topView() != this ) return;

   626 

   627     // anything to do?

   628       if ( !m_repaints.IsEmpty() ) {

   629           syncRepaint( );

   630       }

   631 }

   632 

   633 //-------------------------------------------------------------------------------

   634 // CollectOffscreenbitmap

   635 // Get offscreen bitmap

   636 //-------------------------------------------------------------------------------

   637 void WebView::collectOffscreenbitmapL(CFbsBitmap& snapshot)

   638 {

   639    

   640     (snapshot).Create(m_brctl->Size(), StaticObjectsContainer::instance()->webSurface()->displayMode());

   641 

   642     CFbsBitmapDevice* device = CFbsBitmapDevice::NewL( &snapshot);

   643     CleanupStack::PushL(device);

   644 

   645     WebCoreGraphicsContext* gc = WebCoreGraphicsContext::NewL( device, &snapshot, mainFrame()->frameView());

   646     CleanupStack::PushL(gc);

   647 

   648     mainFrame()->frameView()->draw( *gc, mainFrame()->frameView()->visibleRect() );

   649 

   650     CleanupStack::PopAndDestroy(2);

   651 

   652 }

   653 

   654 //-------------------------------------------------------------------------------

   655 // ScheduleRepaint

   656 // Schedule an asynchronous repaint

   657 //-------------------------------------------------------------------------------

   658 void WebView::scheduleRepaint(

   659                               const TRect& rect )

   660 {

   661     m_repaints.AddRect( rect );

   662     if(   m_widgetextension && m_widgetextension->IsWidgetPublising())

   663         {

   664 #ifdef BRDO_WRT_HS_FF

   665         // Draw the miniview

   666         m_brctl->brCtlLayoutObserver()->NotifyLayoutChange(EOriginTopLeft);

   667 #endif

   668         }

   669     // if we are active, we'll repaint when timer fires

   670     if( !m_repainttimer->IsActive() && !m_pageZoomHandler->isActive() && 

   671          m_allowRepaints) {

   672         // no timer yet, repaint immediatly (but asynchronously)

   673         m_repainttimer->Start( 0, 0, TCallBack( &doRepaintCb, this ) );

   674     }

   675 }

   676 

   677 void WebView::pageLoadFinished()

   678 {

   679 

   680     if (m_brctl->settings() && m_brctl->settings()->getTabbedNavigation()) {

   681         m_tabbedNavigation->initializeForPage();

   682     }

   683     else {

   684 

   685         // Temp solution to fix a problem with scrolling large pages:

   686         // if user starts scrolling while loading a page - at the end of the load we should not restore

   687         // the content position from the history controller

   688         // As of now scroll events are not passed to WebCore and this will be changed in future

   689         // then this code should be replaces with the commented one below

   690 

   691         TPoint ptInit(0,0);

   692         TPoint ptFromHistory = m_brctl->historyHandler()->historyController()->currentEntryPosition();

   693         TPoint ptCurr = mainFrame()->frameView()->contentPos();

   694 

   695         if ( ptCurr != ptFromHistory ) {

   696             if ( ptInit == ptCurr ) {

   697                 mainFrame()->frameView()->scrollTo(ptFromHistory);

   698             }

   699             else {

   700                 m_brctl->historyHandler()->historyController()->updateCurrentEntryPositionIfNeeded();

   701             }

   702         }

   703         /*

   704         if ( !core(mainFrame())->view()->wasScrolledByUser())

   705             mainFrame()->frameView()->scrollTo(m_brctl->historyHandler()->historyController()->currentEntryPosition());*/

   706 

   707     }

   708 

   709     if (FrameLoadTypeStandard == core( mainFrame())->loader()->loadType()){

   710         if (m_brctl->capabilities()&TBrCtlDefs::ECapabilityFitToScreen){

   711             updateMinZoomLevel( mainFrame()->frameView()->contentSize());

   712         }

   713     }

   714 

   715     setHistoryLoad(false);

   716     setRedirectWithLockedHistory(false);

   717 

   718     int zoomLevel = m_brctl->historyHandler()->historyController()->currentEntryZoomLevel();

   719     if ( zoomLevel != m_currentZoomLevel) {

   720         m_brctl->historyHandler()->historyController()->updateCurrentEntryZoomLevelIfNeeded();

   721     }

   722     if ( m_pageScaler ) {

   723         m_pageScaler->DocumentCompleted();

   724         TRAP_IGNORE(m_pageScaler->DocumentChangedL());

   725     }

   726 

   727     Node* focusedNode = NULL;

   728     Frame* focusedFrame = page()->focusController()->focusedFrame();

   729 

   730     if (focusedFrame)

   731         {

   732         focusedNode = focusedFrame->document()->focusedNode();

   733 

   734         if (focusedNode) { // based on focused element

   735             m_focusedElementType = nodeTypeB(focusedNode, focusedFrame);

   736         }

   737         else {

   738             m_focusedElementType = TBrCtlDefs::EElementNone;

   739         }

   740     }

   741     else {

   742         m_focusedElementType = TBrCtlDefs::EElementNone;

   743     }

   744     m_brctl->updateDefaultSoftkeys();

   745 }

   746 

   747 void WebView::updatePageScaler()

   748 {

   749     if (m_brctl->capabilities() & TBrCtlDefs::ECapabilityGraphicalPage) {

   750         TRAP_IGNORE(if (m_pageScaler) m_pageScaler->DocumentChangedL());

   751     }

   752 }

   753 

   754 void WebView::openUrl(const TDesC& url)

   755 {

   756     mainFrame()->loadRequest(WebCore::ResourceRequest(url, true));

   757 }

   758 

   759 WebCore::DOMDocument* WebView::mainFrameDocument()

   760 {

   761     return mainFrame()->DOMDocument();

   762 }

   763 

   764 TBool WebView::shouldClose()

   765 {

   766     Frame* coreFrame = core(mainFrame());

   767     if (!coreFrame)

   768         return ETrue;

   769     return coreFrame->shouldClose();

   770 }

   771 

   772 TBool WebView::isLoading()

   773 {

   774     return m_page->mainFrame()->loader()->activeDocumentLoader()->isLoading();

   775 }

   776 

   777 TInt WebView::CountComponentControls() const

   778 {

   779     int count = (m_webFormFillPopup && m_webFormFillPopup->IsVisible()) ? 1 : 0;

   780     return count;

   781 }

   782 

   783 CCoeControl* WebView::ComponentControl(TInt aIndex) const

   784 {

   785     CCoeControl* rv = NULL;

   786 

   787     if ( aIndex == 0)

   788         if ( m_webFormFillPopup && m_webFormFillPopup->IsVisible()) rv = m_webFormFillPopup;

   789 

   790     return rv;

   791 }

   792 

   793 TKeyResponse WebView::OfferKeyEventL(const TKeyEvent& keyevent, TEventCode eventcode )

   794 {

   795     WebCursor* cursor = StaticObjectsContainer::instance()->webCursor();

   796     //hijack

   797     if (isSynchRequestPending()) {

   798         return EKeyWasNotConsumed;

   799     }

   800     if (m_toolbar)

   801         return m_toolbar->HandleOfferKeyEventL(keyevent, eventcode);

   802 

   803     if (m_popupDrawer)

   804         return m_popupDrawer->handleOfferKeyEventL(keyevent, eventcode );

   805 

   806     if ( m_webFormFillPopup && m_webFormFillPopup->IsVisible() && AknLayoutUtils::PenEnabled() ) {

   807 	    if (EKeyWasConsumed == m_webFormFillPopup->HandleKeyEventL(keyevent, eventcode)) {

   808             return EKeyWasConsumed;

   809 	        }

   810     }

   811 

   812     bool consumed = false;

   813     Frame* coreFrame = core(mainFrame());

   814     if (!coreFrame)

   815         return EKeyWasNotConsumed;

   816 

   817     coreFrame = page()->focusController()->focusedOrMainFrame();

   818 

   819     // edit events

   820     if (m_isEditable) {

   821         consumed = page()->focusController()->focusedOrMainFrame()->eventHandler()->keyEvent(PlatformKeyboardEvent(keyevent,eventcode));

   822         // exit input on up/down key

   823         // EXCEPT on touch-enabled devices. We'll just consume in that case

   824             if ( !consumed

   825                  && (    keyevent.iCode == EKeyUpArrow         // North

   826                       || keyevent.iCode == EKeyRightUpArrow    // Northeast

   827                       || keyevent.iCode == EStdKeyDevice11     //   : Extra KeyEvent supports diagonal event simulator wedge

   828                       || keyevent.iCode == EKeyRightArrow      // East

   829                       || keyevent.iCode == EKeyRightDownArrow  // Southeast

   830                       || keyevent.iCode == EStdKeyDevice12     //   : Extra KeyEvent supports diagonal event simulator wedge

   831                       || keyevent.iCode == EKeyDownArrow       // South

   832                       || keyevent.iCode == EKeyLeftDownArrow   // Southwest

   833                       || keyevent.iCode == EStdKeyDevice13     //   : Extra KeyEvent supports diagonal event simulator wedge

   834                       || keyevent.iCode == EKeyLeftArrow       // West

   835                       || keyevent.iCode == EKeyLeftUpArrow     // Northwest

   836                       || keyevent.iCode == EStdKeyDevice10 ) ) //   : Extra KeyEvent supports diagonal event simulator wedge

   837                 {

   838                 if (m_webfeptexteditor->validateTextFormat() ) {

   839                     setFocusNone();

   840                 } else {

   841                     consumed = true;

   842                 }

   843             }

   844     }

   845 

   846     // scroll events

   847     if (!consumed) {

   848         switch( eventcode ) {

   849         case EEventKeyDown:

   850             m_currentEventKey = keyevent;

   851             //page()->mainFrame()->setFocusedNodeIfNeeded();

   852             //coreFrame->eventHandler()->mousePressNode()->focus();

   853 

   854             break;

   855         case EEventKey:

   856             if (keyevent.iScanCode != m_currentEventKey.iScanCode ) return EKeyWasNotConsumed;

   857             //

   858             m_currentEventKey = keyevent;

   859             if (keyevent.iCode == EKeyDevice3) {

   860                 // pass it to webcore

   861                 TPointerEvent event;

   862                 event.iPosition = StaticObjectsContainer::instance()->webCursor()->position();

   863                 event.iModifiers = 0;

   864                 event.iType = TPointerEvent::EButton1Down ;

   865                 coreFrame->eventHandler()->handleMousePressEvent(PlatformMouseEvent(event));

   866 

   867                 // mimic ccb's behavior of onFocus

   868                 Node* node = page()->focusController()->focusedOrMainFrame()->eventHandler()->mousePressNode();

   869                 for (Node* n = node; n; n = n->parentNode()) {

   870                     if ( n->isFocusable() ) {

   871                         page()->focusController()->setFocusedNode(n, page()->focusController()->focusedOrMainFrame());

   872                     }

   873                 }

   874 

   875                 // Toolbar is activated on long key press only if the element

   876                 // type is EElementNone during EEventKeyDown and EEventKey.

   877                 // This prevents toolbar from popping up in DHTML pages. Also,

   878                 // toolbar is activated when the user is not in fast scroll

   879                 // mode, or in page overview mode, or on wml page.

   880                 if ( ( m_focusedElementType == TBrCtlDefs::EElementNone ||

   881                        m_focusedElementType == TBrCtlDefs::EElementBrokenImage ) &&

   882                        keyevent.iRepeats && !m_brctl->wmlMode() )

   883                     {

   884                     launchToolBarL();

   885                     }

   886                 consumed = true;

   887             } else if (    keyevent.iCode == EKeyUpArrow              // North

   888                         || keyevent.iCode == EKeyRightUpArrow         // Northeast

   889                         || keyevent.iCode == EStdKeyDevice11          //   : Extra KeyEvent supports diagonal event simulator wedge

   890                         || keyevent.iCode == EKeyRightArrow           // East

   891                         || keyevent.iCode == EKeyRightDownArrow       // Southeast

   892                         || keyevent.iCode == EStdKeyDevice12          //   : Extra KeyEvent supports diagonal event simulator wedge

   893                         || keyevent.iCode == EKeyDownArrow            // South

   894                         || keyevent.iCode == EKeyLeftDownArrow        // Southwest

   895                         || keyevent.iCode == EStdKeyDevice13          //   : Extra KeyEvent supports diagonal event simulator wedge

   896                         || keyevent.iCode == EKeyLeftArrow            // West

   897                         || keyevent.iCode == EKeyLeftUpArrow          // Northwest

   898                         || keyevent.iCode == EStdKeyDevice10 )        //   : Extra KeyEvent supports diagonal event simulator wedge

   899             {

   900                 if (m_brctl->settings()->getTabbedNavigation()) {

   901                     int horizontal = 0;

   902                     int vertical = 0;

   903                     switch(keyevent.iCode)

   904                     {

   905                         case EKeyUpArrow:             // North

   906                             vertical = -1;

   907                             break;

   908 

   909                         case EKeyRightUpArrow:        // Northeast

   910                         case EStdKeyDevice11:         //   : Extra KeyEvent supports diagonal event simulator wedge

   911                             vertical   = -1;

   912                             horizontal = +1;

   913                             break;

   914 

   915                         case EKeyRightArrow:          // East

   916                             horizontal = +1;

   917                             break;

   918 

   919                         case EKeyRightDownArrow:      // Southeast

   920                         case EStdKeyDevice12:         //   : Extra KeyEvent supports diagonal event simulator wedge

   921                             vertical   = +1;

   922                             horizontal = +1;

   923                             break;

   924 

   925                         case EKeyDownArrow:           // South

   926                             vertical   = +1;

   927                             break;

   928 

   929                         case EKeyLeftDownArrow:       // Southwest

   930                         case EStdKeyDevice13:         //   : Extra KeyEvent supports diagonal event simulator wedge

   931                             vertical   = +1;

   932                             horizontal = -1;

   933                             break;

   934 

   935                         case EKeyLeftArrow:           // West

   936                             horizontal = -1;

   937                             break;

   938 

   939                         case EKeyLeftUpArrow:         // Northwest

   940                         case EStdKeyDevice10:         //   : Extra KeyEvent supports diagonal event simulator wedge

   941                             vertical   = -1;

   942                             horizontal = -1;

   943                             break;

   944 

   945                         default:                      // (Should never get here)

   946                             break;

   947 

   948                     }

   949                     

   950                    	consumed = m_tabbedNavigation->navigate(horizontal, vertical);

   951                 }

   952                 else {

   953                     // start fast scrolling

   954 					m_showCursor = true;

   955                     if (!cursor->isVisible()) {

   956                         cursor->cursorUpdate(true);

   957                     }

   958                     bool fastscroll(m_fastScrollTimer->IsActive());

   959                     m_savedPosition = mainFrame()->frameView()->contentPos();

   960                     cursor->scrollAndMoveCursor(keyevent.iCode, m_scrollingSpeed, fastscroll);

   961                     if (!fastscroll) {

   962                         m_fastScrollTimer->Start(KCursorInitialDelay,KCursorUpdateFrquency,TCallBack(&scrollTimerCb,this));

   963                         m_scrollingStartTime.HomeTime();

   964                     }

   965                     // and minimap comes on

   966                     int scrollingTime = millisecondsScrolled();

   967                     if (!AknLayoutUtils::PenEnabled() && m_pageScalerEnabled && m_pageScaler && !isSmallPage() &&

   968                         m_brctl->settings()->brctlSetting(TBrCtlDefs::ESettingsPageOverview) &&

   969                         (scrollingTime > KPanningPageScalerStart || m_pageScaler->Visible())) {

   970                         m_pageScaler->SetVisibleUntil(KScalerVisibilityTime);

   971 					}

   972                     //

   973                     if (!fastscroll) {

   974                       TPointerEvent event;

   975                       event.iPosition = cursor->position();

   976                       event.iModifiers = 0;

   977                       event.iType = TPointerEvent::EMove;

   978                       coreFrame->eventHandler()->handleMouseMoveEvent(PlatformMouseEvent(event));

   979                     }

   980                     consumed = true;

   981                 } // if (m_brctl->settings()->getTabbedNavigation()

   982             } else {

   983                 // activate hovered input element by just start typing

   984                 if (m_focusedElementType == TBrCtlDefs::EElementInputBox || m_focusedElementType == TBrCtlDefs::EElementSelectBox

   985                     || m_focusedElementType == TBrCtlDefs::EElementSelectMultiBox || m_focusedElementType == TBrCtlDefs::EElementTextAreaBox) {

   986                     TPointerEvent event;

   987                     event.iModifiers = 0;

   988                     event.iPosition = cursor->position();

   989                     event.iType = TPointerEvent::EButton1Down ;

   990                     coreFrame->eventHandler()->handleMousePressEvent(PlatformMouseEvent(event));

   991                     event.iType = TPointerEvent::EButton1Up;

   992                     coreFrame->eventHandler()->handleMouseReleaseEvent(PlatformMouseEvent(event));

   993 

   994 

   995                     if (m_focusedElementType == TBrCtlDefs::EElementInputBox || m_focusedElementType == TBrCtlDefs::EElementTextAreaBox) {

   996                         if (!m_fepTimer)

   997                             m_fepTimer = new WebCore::Timer<WebView>(this, &WebView::fepTimerFired);

   998 

   999                         m_fepTimer->startOneShot(0.2f);

  1000                         setEditable(true);

  1001                     }

  1002                     m_keyevent = keyevent;

  1003                     m_eventcode = eventcode;

  1004 

  1005                     consumed = true;

  1006             }

  1007             }

  1008             break;

  1009         case EEventKeyUp:

  1010             m_fastScrollTimer->Cancel();

  1011             m_scrollingSpeed = KNormalScrollRange*100/scalingFactor();

  1012 

  1013             if (viewIsFastScrolling()) {

  1014 	      setViewIsFastScrolling(false);

  1015               toggleRepaintTimer(true);

  1016               if (AknLayoutUtils::PenEnabled() && !inPageViewMode()) {

  1017                   m_pageScrollHandler->scrollbarDrawer()->fadeScrollbar();

  1018               }

  1019             }

  1020             m_currentEventKey = KNullKeyEvent;

  1021             if ( (keyevent.iScanCode == EStdKeyDevice3) || (keyevent.iScanCode == EStdKeyEnter) ){

  1022                 // pass it to webcore

  1023                 TPointerEvent event;

  1024                 if (m_focusedElementType == TBrCtlDefs::EElementInputBox || 

  1025                         m_focusedElementType == TBrCtlDefs::EElementTextAreaBox)

  1026                     {

  1027                     setEditable(true);

  1028                     }

  1029                 event.iPosition = cursor->position();

  1030                 event.iType = TPointerEvent::EButton1Up;

  1031                 coreFrame->eventHandler()->handleMouseReleaseEvent(PlatformMouseEvent(event));

  1032                 consumed = true;

  1033             }

  1034             break;

  1035         }

  1036     }

  1037 

  1038     // keyevents

  1039     if (!consumed) {

  1040         consumed = coreFrame->eventHandler()->keyEvent(PlatformKeyboardEvent(keyevent,eventcode));

  1041         if (!consumed && eventcode == EEventKey && (m_brctl->capabilities() & TBrCtlDefs::ECapabilityAccessKeys)) {

  1042             TKeyEvent ke = keyevent;

  1043             TChar c(ke.iCode);

  1044             // Not consumed by WebCore, is alphanumeric and does not have any modifier

  1045             if (c.IsAlphaDigit() && !(ke.iModifiers & (EModifierCtrl | EModifierAlt | EModifierShift))) {

  1046                 ke.iModifiers = EModifierCtrl;

  1047                 coreFrame->eventHandler()->keyEvent(PlatformKeyboardEvent(ke,EEventKeyDown));

  1048                 consumed = true;

  1049             }

  1050         }

  1051     }

  1052 

  1053     //setEditable();

  1054 

  1055     return (consumed)?EKeyWasConsumed:EKeyWasNotConsumed;

  1056 }

  1057 

  1058 

  1059 void WebView::updateScrollbars(int documentHeight, int displayPosY, int documentWidth, int displayPosX)

  1060 {

  1061     m_brctl->updateScrollbars((documentHeight * scalingFactor()) / 100, Rect().Height(),

  1062         (displayPosY * scalingFactor()) / 100, (documentWidth * scalingFactor()) / 100, Rect().Width(),

  1063         (displayPosX * scalingFactor()) / 100);

  1064 }

  1065 

  1066 void WebView::openPageViewL()

  1067 {

  1068     // don't show pageview if we are in lite mode

  1069     if ( m_brctl->capabilities() & TBrCtlDefs::ECapabilityWebKitLite )

  1070         return;

  1071     if (!m_pageView) {

  1072         m_pageView = CPageView::NewL(*this);

  1073         MakeVisible(EFalse);

  1074         m_savedPosition = mainFrame()->frameView()->contentPos();

  1075         m_brctl->reportStateChanged(TBrCtlDefs::EStateThumbnailView, ETrue);

  1076     }

  1077 }

  1078 

  1079 void WebView::closePageView()

  1080 {

  1081     if ( m_brctl->capabilities() & TBrCtlDefs::ECapabilityWebKitLite )

  1082         return;

  1083     if (m_pageView) {

  1084         delete m_pageView;

  1085         m_pageView = 0;

  1086         MakeVisible(ETrue);

  1087         m_brctl->DrawNow();

  1088         m_brctl->reportStateChanged(TBrCtlDefs::EStateThumbnailView, EFalse);

  1089     }

  1090 }

  1091 

  1092 void WebView::cancelPageView()

  1093 {

  1094     if ( m_brctl->capabilities() & TBrCtlDefs::ECapabilityWebKitLite )

  1095         return;

  1096     if (m_pageView) {

  1097         mainFrame()->frameView()->scrollTo(m_savedPosition);

  1098         closePageView();

  1099     }

  1100 }

  1101 

  1102 //-------------------------------------------------------------------------------

  1103 // launchToolBarL

  1104 //-------------------------------------------------------------------------------

  1105 void WebView::launchToolBarL()

  1106 {

  1107     if ( AknLayoutUtils::PenEnabled() || m_brctl->wmlMode() ) {

  1108         return;

  1109     }

  1110 

  1111     if ( !(m_brctl->capabilities() & TBrCtlDefs::ECapabilityToolBar) ) {

  1112         return;

  1113     }

  1114 

  1115     if ( !m_brctl->settings()->brctlSetting(TBrCtlDefs::ESettingsToolbarOnOff) ) {

  1116         return;

  1117     }

  1118 

  1119     delete m_toolbar;

  1120     m_toolbar = 0;

  1121 

  1122     delete m_toolbarinterface;

  1123     m_toolbarinterface = 0;

  1124 

  1125     m_toolbarinterface = new WebToolBarInterface(this);

  1126     TRAPD(leave, m_toolbar = CToolBar::NewL(*m_toolbarinterface));

  1127     if (leave != KErrNone)

  1128         return;

  1129 

  1130     /*EnableDragEvents();*/

  1131 

  1132     m_brctl->DrawNow();

  1133     m_brctl->reportStateChanged(TBrCtlDefs::EStateToolBarMode, ETrue);

  1134