#include <eikon.rh>
#include <avkon.rsg>
#include <avkon.rh>
 
//...
RESOURCE TBUF r_global_query_progress_text
    {   
    buf = "<progress dialog text here>"; 
    }

#ifndef GLOBALQUERYOBSERVER_H
#define GLOBALQUERYOBSERVER_H
 
class MGlobalQueryObserver
    {
public:     
    //keep these methods short running because they are called
    //from within an active object  
    virtual void ProcessOkOptionL() = 0;
    virtual void ProcessCancelOptionL() = 0;
    virtual void ProcessDoneOptionL() = 0;
    virtual void ProcessSelectedItemL(const TInt aItem) = 0;
    };
 
#endif  // GLOBALQUERYOBSERVER_H

#ifndef GLOBALQUERYHANDLERAO_H
#define GLOBALQUERYHANDLERAO_H
 
#include <e32base.h>  //CActive
#include "GlobalQueryObserver.h"
 
class CGlobalQueryHandlerAO : public CActive
    {
public:
    ~CGlobalQueryHandlerAO();
    static CGlobalQueryHandlerAO* NewL(MGlobalQueryObserver& aObserver);
    static CGlobalQueryHandlerAO* NewLC(MGlobalQueryObserver& aObserver);   
public: 
    void StartHandler();    
private:    
    CGlobalQueryHandlerAO(MGlobalQueryObserver& aObserver) 
            : CActive (EPriorityStandard), iObserver(aObserver){};
    void ConstructL();  
private: // from CActive    
    void RunL();
    void DoCancel();
private: // data
    MGlobalQueryObserver& iObserver;
    };
#endif //GLOBALQUERYHANDLERAO_H

#ifndef GLOBALQUERYCONTAINER_H
#define GLOBALQUERYCONTAINER_H
 
#include <coecntrl.h> // CCoeControl
#include "GlobalQueryObserver.h"
#include <aknglobalprogressdialog.h> //CAknGlobalProgressDialog
 
const TInt KFinalExampleStep = 100;
 
class CGlobalQueryHandlerAO;
 
class CGlobalQueryContainer : public CCoeControl, MGlobalQueryObserver
    {
public:
//...
void MakeExampleQueryL();
private:
//...
    static TInt TimerCallback(TAny* aThis);
    void GlobalExampleProcessTimerEvent();
public: // from MGlobalQueryObserver
    void ProcessOkOptionL(); //not used
    void ProcessCancelOptionL();
    void ProcessDoneOptionL(); 
    void ProcessSelectedItemL(const TInt aItem); //not used
//...
private:
    CGlobalQueryHandlerAO*       iQueryHandlerAO;
    CAknGlobalProgressDialog*    iGlobalProgressDialog; 
    CPeriodic*                   iTimer;
    TInt iCurrentExampleStep;
    };
#endif  // GLOBALQUERYCONTAINER_H

#include "GlobalQueryHandlerAO.h"
#include <avkon.hrh> //EAknSoftkeyOk, EAknSoftkeyCancel, EAknSoftkeyDone
 
CGlobalQueryHandlerAO::~CGlobalQueryHandlerAO() { Cancel(); }
 
void CGlobalQueryHandlerAO::ConstructL()
    {
    CActiveScheduler::Add(this);
    }
 
CGlobalQueryHandlerAO* CGlobalQueryHandlerAO::NewLC(MGlobalQueryObserver& aObserver)
    {
    CGlobalQueryHandlerAO* self = new (ELeave) CGlobalQueryHandlerAO(aObserver);
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
    }
 
CGlobalQueryHandlerAO* CGlobalQueryHandlerAO::NewL(MGlobalQueryObserver& aObserver)
    {
    CGlobalQueryHandlerAO* self = CGlobalQueryHandlerAO::NewLC(aObserver);
    CleanupStack::Pop(self);
    return self;
    }
 
void CGlobalQueryHandlerAO::DoCancel(){}
 
void CGlobalQueryHandlerAO::StartHandler() { SetActive(); }
 
void CGlobalQueryHandlerAO::RunL()
    {
    if (iStatus == EAknSoftkeyOk)
        iObserver.ProcessOkOptionL();
    else if(iStatus == EAknSoftkeyCancel)
        iObserver.ProcessCancelOptionL();
    else if(iStatus == EAknSoftkeyDone)
        iObserver.ProcessDoneOptionL();
    else
        iObserver.ProcessSelectedItemL(iStatus.Int());
 
    Cancel();
    }

#include "GlobalQueryContainer.h" //CGlobalQueryContainer
#include "GlobalQueryHandlerAO.h" //CGlobalQueryHandlerAO
#include <GlobalQuery_0xED0C36BE.rsg> //Resources
#include <StringLoader.h> // StringLoader
 
void CGlobalQueryContainer::ConstructL(const TRect& aRect)
    {
    CreateWindowL();
    SetRect(aRect);
    ActivateL();
 
    MakeExampleQueryL();
    }
 
void CGlobalQueryContainer::MakeExampleQueryL()
    {   
    //start the query handler and show global progress dialog
    iQueryHandlerAO = CGlobalQueryHandlerAO::NewL(*this); 
    iQueryHandlerAO->StartHandler();
 
    iGlobalProgressDialog = CAknGlobalProgressDialog::NewL();
 
    HBufC* progressText = StringLoader::LoadLC(R_GLOBAL_QUERY_PROGRESS_TEXT);
 
    iCurrentExampleStep = 0;
 
    iGlobalProgressDialog->ShowProgressDialogL(
                        iQueryHandlerAO->iStatus,
                        *progressText,
                        R_AVKON_SOFTKEYS_CANCEL);
 
    //start example process and update the progress dialog
    iTimer = CPeriodic::NewL(EPriorityLow);
    iTimer->Start(1000, 1000, TCallBack(TimerCallback, this));
 
    CleanupStack::PopAndDestroy(); //progressText
    }
 
CGlobalQueryContainer::~CGlobalQueryContainer()
    {
    //...
    delete iQueryHandlerAO;
    delete iGlobalProgressDialog;
 
    if(iTimer)
        {
        iTimer->Cancel();
        delete iTimer;
        }
    }
 
TInt CGlobalQueryContainer::TimerCallback(TAny* aThis)
    {
    static_cast< CGlobalQueryContainer* >(aThis)->GlobalExampleProcessTimerEvent();
 
    return 0;
    }
 
void CGlobalQueryContainer::GlobalExampleProcessTimerEvent()
    {
    if (!iGlobalProgressDialog)
        {
        return;
        }
 
    iCurrentExampleStep++;
 
    if (iCurrentExampleStep <= KFinalExampleStep)
        {
        iGlobalProgressDialog->UpdateProgressDialog(iCurrentExampleStep, KFinalExampleStep);
        }
    else
        {
        iGlobalProgressDialog->ProcessFinished();
        iTimer->Cancel();
        }
    }
 
void CGlobalQueryContainer::ProcessOkOptionL()
    {
    //not used
    }
void CGlobalQueryContainer::ProcessCancelOptionL()
    {
    //Cancel pressed, do something...
    iEikonEnv->InfoWinL(_L("Cancel"),_L("Pressed"));
    }
void CGlobalQueryContainer::ProcessDoneOptionL()
    {
    //Progress dialog ready, do something...
    iEikonEnv->InfoWinL(_L("Progress"),_L("Done"));
    }
void CGlobalQueryContainer::ProcessSelectedItemL(const TInt /*aItem*/)
    {   
    //not used
    }