svgtviewer/SvgtViewerPlugin/UIControlSrc/SvgtEventHandlerAO.cpp
branchRCL_3
changeset 13 e52958d06c29
parent 10 1882882c7f9c
child 14 20b99a6d6175
equal deleted inserted replaced
10:1882882c7f9c 13:e52958d06c29
     1 /*
       
     2 * Copyright (c) 2006 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:  This class handles the event list & process the events 
       
    15 *                 while progressive rendering
       
    16 *
       
    17 */
       
    18 
       
    19 
       
    20 #include "SvgtEventHandlerAO.h"
       
    21 #include <SVGTAppObserverUtil.h>
       
    22 #include <imcvcodc.h>
       
    23 #include "SvgtEvent.h"
       
    24 
       
    25 const TInt KTimerIntervalInMiliSeconds = 1000;
       
    26 
       
    27 const TInt KInitialTimeInterval = 100;
       
    28 const TInt KMaxTimeInterval = 2000;
       
    29 // -----------------------------------------------------------------------------
       
    30 // CSvgtEventHandlerAO::NewL
       
    31 // Two phase construction
       
    32 // -----------------------------------------------------------------------------
       
    33 //
       
    34 CSvgtEventHandlerAO* CSvgtEventHandlerAO::NewL(MSvgtAppObserver* aAppObserverUtil, 
       
    35                                 CSVGTCustControl* aCustControl ,
       
    36                                 const TThreadId aMainThreadId )
       
    37     {
       
    38     CSvgtEventHandlerAO* self = new ( ELeave ) CSvgtEventHandlerAO( aAppObserverUtil , 
       
    39                                                                     aCustControl, 
       
    40                                                                     aMainThreadId);
       
    41     CleanupStack::PushL( self );
       
    42     self->ConstructL();
       
    43     CleanupStack::Pop(self);
       
    44     return self;
       
    45     }
       
    46 
       
    47 // -----------------------------------------------------------------------------
       
    48 // CSvgtEventHandlerAO::CSvgtEventHandlerAO
       
    49 // Constructor
       
    50 // -----------------------------------------------------------------------------
       
    51 //
       
    52 CSvgtEventHandlerAO::CSvgtEventHandlerAO(MSvgtAppObserver* aAppObserverUtil, 
       
    53                                         CSVGTCustControl* aCustControl, 
       
    54                                         const TThreadId aMainThreadId):
       
    55                                         CActive( CActive::EPriorityStandard ),
       
    56                                         iCustControl(aCustControl),
       
    57                                         iMainThreadId( aMainThreadId ),
       
    58                                         iIsDocumentComplete( EFalse ),
       
    59                                         iStepCount( 1 ),
       
    60                                         iSvgTimeBetweenRedraw( KInitialTimeInterval )
       
    61     {
       
    62     iAppObserverUtil = static_cast<CSVGTAppObserverUtil*>(aAppObserverUtil);
       
    63     }
       
    64 
       
    65 // -----------------------------------------------------------------------------
       
    66 // CSvgtEventHandlerAO::ConstructL
       
    67 // 2nd phase constructor
       
    68 // -----------------------------------------------------------------------------
       
    69 //
       
    70 void CSvgtEventHandlerAO::ConstructL()
       
    71     {
       
    72     iPreviousRedrawClock.HomeTime();
       
    73     // Add to active scheduler
       
    74     CActiveScheduler::Add( this );
       
    75     // Set the status as pending
       
    76     iStatus = KRequestPending;
       
    77     // Set the active object as Active
       
    78     SetActive();
       
    79     // Create the critical section IPC for sync. the RequestComplete Calls
       
    80     iCritSection.CreateLocal();
       
    81     }
       
    82 
       
    83 // -----------------------------------------------------------------------------
       
    84 // CSvgtEventHandlerAO::~CSvgtEventHandlerAO
       
    85 // Destructor
       
    86 // -----------------------------------------------------------------------------
       
    87 //
       
    88 CSvgtEventHandlerAO::~CSvgtEventHandlerAO()
       
    89     {
       
    90     Cancel();
       
    91     iEventList.ResetAndDestroy();
       
    92     iEventList.Close();
       
    93     iCritSection.Close();
       
    94     }
       
    95 
       
    96 // -----------------------------------------------------------------------------
       
    97 // CSvgtEventHandlerAO::AddEventToList
       
    98 // It adds the event (except redraw event) to the event queue.
       
    99 // -----------------------------------------------------------------------------
       
   100 //
       
   101 TBool CSvgtEventHandlerAO::AddEventToList( CSvgtEvent* aEvent)
       
   102     {
       
   103     iEventList.Append( aEvent );
       
   104     return ETrue;        
       
   105     }
       
   106 
       
   107 // -----------------------------------------------------------------------------
       
   108 // CSvgtEventHandlerAO::AddRedrawEventToList
       
   109 // It adds the redraw event to the event queue.
       
   110 // -----------------------------------------------------------------------------
       
   111 //
       
   112 TBool CSvgtEventHandlerAO::AddRedrawEventToList( const TBool aForceAdd )
       
   113     {
       
   114     TBool isEventAdded = EFalse;
       
   115     if(aForceAdd || IsRedrawTimeElapsed())
       
   116         {
       
   117         CSvgtEvent* redrawEvent = new CSvgtEventRedraw;
       
   118         iEventList.Append( redrawEvent );
       
   119         isEventAdded = ETrue;
       
   120         }
       
   121     
       
   122     return isEventAdded;        
       
   123     }
       
   124 
       
   125 // -----------------------------------------------------------------------------
       
   126 // CSvgtEventHandlerAO::MakeRequestComplete
       
   127 // It make the request complete.
       
   128 // -----------------------------------------------------------------------------
       
   129 //
       
   130 void CSvgtEventHandlerAO::MakeRequestComplete( TInt aError )
       
   131     {
       
   132     // The Asynchronouse service provider must only call the RequestComplete()
       
   133     // once for each request. Multiple completion events on a single active
       
   134     // object result in a stray signal panic.
       
   135     // Hence use a critical section to synchronize access to RequestComplete()
       
   136     iCritSection.Wait();
       
   137     if( ( IsActive() ) && ( iStatus == KRequestPending ) )
       
   138         { 
       
   139         // The asynchronous service provider is the loading thread and since 
       
   140         // this is called from both loading thread as well as main thread
       
   141         // use the RThread object to complete the request for active
       
   142         // object present in the main thread's active scheduler
       
   143         TRequestStatus* status = &iStatus;
       
   144         RThread mainThread;
       
   145 
       
   146         if( mainThread.Open( iMainThreadId) )
       
   147             {
       
   148             // Problem opening thread, ignore error and return : Should not happen.
       
   149             return;
       
   150             }
       
   151             
       
   152         mainThread.RequestComplete( status, aError );
       
   153         mainThread.Close();
       
   154         }
       
   155     iCritSection.Signal();
       
   156     }
       
   157 
       
   158 // -----------------------------------------------------------------------------
       
   159 // CSvgtEventHandlerAO::AddEventToList
       
   160 // It indicates that document is document loading completed.
       
   161 // -----------------------------------------------------------------------------
       
   162 //
       
   163 void CSvgtEventHandlerAO::SetDocumentComplete()
       
   164     {
       
   165     iIsDocumentComplete = ETrue;
       
   166     }
       
   167 
       
   168 // -----------------------------------------------------------------------------
       
   169 // CSvgtEventHandlerAO::RunL
       
   170 // Handles an active object's request completion event.
       
   171 // -----------------------------------------------------------------------------
       
   172 //
       
   173 void CSvgtEventHandlerAO::RunL()
       
   174     {
       
   175     // Set the Active Object Active always
       
   176     if( !IsActive() )
       
   177         {
       
   178         iStatus = KRequestPending;
       
   179         SetActive();
       
   180         }
       
   181 
       
   182     if(iEventList.Count())    
       
   183         {
       
   184         CSvgtEvent* event = iEventList[0];
       
   185         iEventList.Remove( 0 );
       
   186         switch(event->EventType())
       
   187             {
       
   188             case CSvgtEvent::ESvgtEventEmbededImage:
       
   189                 {
       
   190                 CSvgtEventEmbededImage* svgEvent = 
       
   191                                         static_cast<CSvgtEventEmbededImage*>(event);
       
   192                 iAppObserverUtil->AssignEmbededDataL( svgEvent->ImageUri() );
       
   193                 }
       
   194                 break;
       
   195                 
       
   196             case CSvgtEvent::ESvgtEventFetchImage:
       
   197                 {
       
   198                 CSvgtEventFetchImage* fetchEvent = 
       
   199                                         static_cast<CSvgtEventFetchImage*>(event);
       
   200                 iAppObserverUtil->NewFetchImageData(fetchEvent->ImageUri());
       
   201                 }
       
   202                 break;
       
   203             case CSvgtEvent::ESvgtEventLinkActivated:
       
   204                 {
       
   205                 CSvgtEventLinkActivated* linkEvent = 
       
   206                                             static_cast<CSvgtEventLinkActivated*>(event);
       
   207                 iAppObserverUtil->LinkActivated(linkEvent->ImageUri());
       
   208                 }
       
   209                 break;
       
   210             case CSvgtEvent::ESvgtEventLinkActivatedWithShow:
       
   211                 {
       
   212                 CSvgtEventLinkActivatedWithShow* linkShowEvent = 
       
   213                                 static_cast<CSvgtEventLinkActivatedWithShow*>(event);
       
   214                 iAppObserverUtil->LinkActivatedWithShow(linkShowEvent->ImageUri(), 
       
   215                                                         linkShowEvent->Show());
       
   216                 }
       
   217                 break;
       
   218             case CSvgtEvent::ESvgtEventRedraw:
       
   219                 {
       
   220                 //DO REDRAW
       
   221                 iCustControl->PerformEngineRedraw();
       
   222                 iCustControl->DrawNow();
       
   223                 }
       
   224                 break;
       
   225                 
       
   226             default:
       
   227                 break;
       
   228             }
       
   229 
       
   230         delete event;
       
   231         }
       
   232 
       
   233 
       
   234         if( iEventList.Count() )
       
   235             {
       
   236             // Pending events in the list, reschedule active
       
   237             // object
       
   238             MakeRequestComplete( KErrNone );
       
   239             }
       
   240     }
       
   241 
       
   242 // -----------------------------------------------------------------------------
       
   243 // CSvgtEventHandlerAO::DoCancel
       
   244 // Cancels all the pending request
       
   245 // -----------------------------------------------------------------------------
       
   246 //
       
   247 void CSvgtEventHandlerAO::DoCancel()
       
   248     {
       
   249     // The service provided for this active object is the 
       
   250     // loading thread. Since the loading thread is already indicated to stop
       
   251     // generating requests, need to terminate the request
       
   252     // pending in the main thread
       
   253     DoTerminate();
       
   254     }
       
   255 
       
   256 // -----------------------------------------------------------------------------
       
   257 // CSvgtEventHandlerAO::RunError
       
   258 // Handles a leave occurring in the request completion event handler RunL().
       
   259 // -----------------------------------------------------------------------------
       
   260 //
       
   261 TInt CSvgtEventHandlerAO::RunError( TInt aError )
       
   262     {
       
   263     // When an error occurs, call base class error handler
       
   264     // Note that active object should not be Cancel() here
       
   265     // as Loading thread could still be alive and do a
       
   266     // MakeRequestComplete. This would generate a stray
       
   267     // signal.
       
   268     return ( CActive::RunError( aError ) );
       
   269     }
       
   270 
       
   271 // -----------------------------------------------------------------------------
       
   272 // CSvgtEventHandlerAO::IsRedrawTimeElapsed
       
   273 // It determines whether the time elapsed or not.
       
   274 // -----------------------------------------------------------------------------
       
   275 //
       
   276 TBool CSvgtEventHandlerAO::IsRedrawTimeElapsed()
       
   277     {
       
   278     TBool isTimeElapsed = EFalse;
       
   279     TTime currentClock;
       
   280     currentClock.HomeTime();
       
   281 
       
   282     TTimeIntervalMicroSeconds time64;
       
   283     time64 = currentClock.MicroSecondsFrom( iPreviousRedrawClock );
       
   284 
       
   285     TUint32 timeDelta = I64INT( time64.Int64() ) / KTimerIntervalInMiliSeconds; 
       
   286                                                             // milliseconds
       
   287     
       
   288     if ( timeDelta > iSvgTimeBetweenRedraw )//KSvgTimeBetweenRedraw=500  
       
   289         {
       
   290         if( iSvgTimeBetweenRedraw < KMaxTimeInterval )
       
   291             {
       
   292             iSvgTimeBetweenRedraw *= ++iStepCount;
       
   293             }
       
   294         isTimeElapsed = ETrue;
       
   295         // Save the current time to calculate interframe delay
       
   296         iPreviousRedrawClock.HomeTime();        
       
   297         }
       
   298 
       
   299     return isTimeElapsed;
       
   300     }
       
   301 
       
   302 // -----------------------------------------------------------------------------
       
   303 // CSvgtEventHandlerAO::DoTerminate
       
   304 // Cancels the pending async request 
       
   305 // -----------------------------------------------------------------------------
       
   306 //
       
   307 void CSvgtEventHandlerAO::DoTerminate()
       
   308     {
       
   309     // Post a pseudo complete, so that Cancel() is done 
       
   310     // successfully. The Loading thread which is the actual service
       
   311     // provider is by now already stopped.
       
   312     // The Asynchronous service provider should complete the 
       
   313     // request with KErrCancel as quickly as possible, because CActive::Cancel
       
   314     // blocks until completion occurs.
       
   315     MakeRequestComplete( KErrCancel );    
       
   316     }
       
   317 
       
   318 
       
   319 //End of file