Ordinal: ordinal position, drag and drop

Found in: examples\Graphics\WS\Ordinal\

These are the main files contained in the examples. Some extra files may be needed to run the examples, and these will be found in the appropriate examples directory.

Note: This example is designed to work properly only with techview, there is no guarantee that it will work properly with other interfaces

// AppHolder.cpp
//
// Copyright (c) 2005 Symbian Softwares Ltd.  All rights reserved.
//


#include "AppHolder.h"
#include "Ordinal.h"
#include <EikStart.h>

//
// EXPORTed functions
//

EXPORT_C CApaApplication* NewApplication()
    {
    return new CAppholderApplication;
    }

//  The below section is added to make the code compatible with v9.1
//  This is because only exe files are compatible with v9.1
#if (defined __WINS__ && !defined EKA2)        //  E32Dll used only when WINS defined and EKA2 not defined
GLDEF_C TInt E32Dll(enum TDllReason)     
    {
    return KErrNone;
    }
#else                                       //   else E32Main is used
GLDEF_C TInt E32Main()        
    {
    return EikStart::RunApplication(NewApplication);
    }
#endif


////////////////////////////////////////////////////////////////
//
// Application class, CAppholderApplication
//
////////////////////////////////////////////////////////////////

TUid CAppholderApplication::AppDllUid() const
    {
    return KUidAppholder;
    }

CApaDocument* CAppholderApplication::CreateDocumentL()
    {
    // Construct the document using its NewL() function, rather 
    // than using new(ELeave), because it requires two-phase
    // construction.
    return new (ELeave) CAppholderDocument(*this);
    }


////////////////////////////////////////////////////////////////
//
// Document class, CAppholderDocument
//
////////////////////////////////////////////////////////////////

// C++ constructor
CAppholderDocument::CAppholderDocument(CEikApplication& aApp)
        : CEikDocument(aApp)
    {
    }

CEikAppUi* CAppholderDocument::CreateAppUiL()
    {
    return new(ELeave) CAppholderAppUi;
    }

CAppholderDocument::~CAppholderDocument()
    {
    }

////////////////////////////////////////////////////////////////
//
// App UI class, CAppholderAppUi
//
////////////////////////////////////////////////////////////////

void CAppholderAppUi::ConstructL()
    {
    BaseConstructL();
    iClient=CExampleWsClient::NewL(ClientRect());
    }

CAppholderAppUi::~CAppholderAppUi()
    {
    delete iClient;
    }

void CAppholderAppUi::HandleCommandL(TInt aCommand)
    {
    switch (aCommand)
        {
    case EEikCmdExit: 
        Exit();
        break;
        }
    }

// Base.CPP
//
// Copyright (c) 2005 Symbian Softwares Ltd.  All rights reserved.
//

#include <w32std.h>
#include "Base.h"

///////////////////////////////////////////////////////////////////////////////
//                          CWindow implementation
///////////////////////////////////////////////////////////////////////////////

CWindow::CWindow(CWsClient* aClient)
    : iClient(aClient)
    {
    }

void CWindow::ConstructL (const TRect& aRect, const TRgb& aColor, CWindow* aParent)
    {
    _LIT(KFontName,"Swiss");
    // If a parent window was specified, use it; if not, use the window group
    // (aParent defaults to 0).
    RWindowTreeNode* parent= aParent ? (RWindowTreeNode*) &(aParent->Window()) : &(iClient->iGroup);
    // Allocate and construct the window
    iWindow=RWindow(iClient->iWs);
    User::LeaveIfError(iWindow.Construct(*parent,(TUint32)this));
    // Store the window's extent
    iRect = aRect;
    // Set up the new window's extent
    iWindow.SetExtent(iRect.iTl, iRect.Size());
    // Set its background color
    iWindow.SetBackgroundColor (aColor);
    // Set pointer grab to enable drag and drop
    iWindow.SetPointerGrab (ETrue);
    // Set up font for displaying text
    TFontSpec fontSpec(KFontName,200);
    User::LeaveIfError(iClient->iScreen->GetNearestFontInTwips(iFont,fontSpec));
    // Activate the window
    iWindow.Activate();
    }

CWindow::~CWindow()
    {
    iWindow.Close();
    iClient->iScreen->ReleaseFont(iFont);
    }

RWindow& CWindow::Window()
    {
    return iWindow;
    }

CWindowGc* CWindow::SystemGc()
    {
    return iClient->iGc;
    }

CWsScreenDevice* CWindow::Screen()
    {
    return iClient->iScreen;
    }

CFont* CWindow::Font()
    {
    return iFont;
    }


///////////////////////////////////////////////////////////////////////////////
//                          CWsRedrawer implementation
///////////////////////////////////////////////////////////////////////////////

CWsRedrawer::CWsRedrawer()
    : CActive(CActive::EPriorityLow)
    {
    }

void CWsRedrawer::ConstructL(CWsClient* aClient)
    {
    iClient=aClient; // remember WsClient that owns us
    CActiveScheduler::Add(this); // add ourselves to the scheduler
    IssueRequest(); // issue request to draw
    }

CWsRedrawer::~CWsRedrawer()
    {
    Cancel();
    }

void CWsRedrawer::IssueRequest()
    {
    iClient->iWs.RedrawReady(&iStatus);
    SetActive();
    }

void CWsRedrawer::DoCancel()
    {
    iClient->iWs.RedrawReadyCancel();
    }

void CWsRedrawer::RunL()
    {   
    // find out what needs to be done in response to the event
    TWsRedrawEvent redrawEvent;
    iClient->iWs.GetRedraw(redrawEvent); // get event
    CWindow* window=(CWindow*)(redrawEvent.Handle()); // get window
    if (window)
        {
        TRect rect=redrawEvent.Rect(); // and rectangle that needs redrawing
        // now do drawing
        iClient->iGc->Activate(window->Window());
        window->Window().BeginRedraw(rect);
        window->Draw(rect);
        window->Window().EndRedraw();
        iClient->iGc->Deactivate();
        }
    // maintain outstanding request
    IssueRequest();
    }


/////////////////////////////////////////////////////////////////////////////////////
//                              CWsClient implementation
/////////////////////////////////////////////////////////////////////////////////////
CWsClient::CWsClient()
    : CActive(CActive::EPriorityStandard)
    {
    }

void CWsClient::ConstructL()
    {
    // add ourselves to active scheduler 
    CActiveScheduler::Add(this);
    // get a session going
    User::LeaveIfError(iWs.Connect());
    // construct our one and only window group
    iGroup=RWindowGroup(iWs);
    User::LeaveIfError(iGroup.Construct(2,ETrue)); // '2' is a meaningless handle
    // construct screen device and graphics context
    iScreen=new (ELeave) CWsScreenDevice(iWs); // make device for this session
    User::LeaveIfError(iScreen->Construct()); // and complete its construction
    User::LeaveIfError(iScreen->CreateContext(iGc)); // create graphics context
    // construct redrawer
    iRedrawer=new (ELeave) CWsRedrawer;
    iRedrawer->ConstructL(this);
    // construct main window
    ConstructMainWindowL();
    // request first event and start scheduler
    IssueRequest();
    }

CWsClient::~CWsClient()
    {
    // neutralize us as an active object
    Deque(); // cancels and removes from scheduler
    // get rid of everything we allocated
    delete iGc;
    delete iScreen;
    delete iRedrawer;
    // destroy window group
    iGroup.Close();
    // finish with window server
    iWs.Close();
    }

void CWsClient::IssueRequest()
    {
    iWs.EventReady(&iStatus); // request an event
    SetActive(); // so we're now active
    }

void CWsClient::DoCancel()
    {
    iWs.EventReadyCancel(); // cancel event request
    }

void CWsClient::ConstructMainWindowL()
    {
    }

// Ordinal.CPP
//
// Copyright (c) 2005 Symbian Softwares Ltd.  All rights reserved.
//

#include <w32std.h>
#include "Base.h"
#include "Ordinal.h"

_LIT(KString1,"1");
_LIT(KString2,"2");
_LIT(KString3,"3");
_LIT(KString4,"4");
_LIT(KString5,"5");

//////////////////////////////////////////////////////////////////////////////
//                   CNumberedWindow implementation
//////////////////////////////////////////////////////////////////////////////

/****************************************************************************\
|   Function:    Constructor/Destructor for CNumberedWindow
|   Input:       aClient      Client application that owns the window
\****************************************************************************/
CNumberedWindow::CNumberedWindow (CWsClient* aClient, TInt aNum)
: CWindow (aClient), iNumber(aNum), iOldPos(0,0)
    {
    }


CNumberedWindow::~CNumberedWindow ()
    {
    }


/****************************************************************************\
|   Function:    CNumberedWindow::Draw
|   Purpose: Redraws the contents of CNumberedWindow within a given
|               rectangle.  CNumberedWindow displays a number in the window.
|   Input:       aRect    Rectangle that needs redrawing
|   Output:      None
\****************************************************************************/
void CNumberedWindow::Draw(const TRect& aRect)
    {
    const TBufC<1> strings[5] = { *&KString1,
                              *&KString2,
                              *&KString3,
                              *&KString4,
                              *&KString5
                            };

    CWindowGc* gc=SystemGc(); // get a graphics context
    gc->SetClippingRect(aRect); // clip outside the redraw area
    gc->Clear(aRect); // clear the redraw area
    TSize size=iWindow.Size();
    TInt height=size.iHeight; // Need window height to calculate vertical text offset
    TInt ascent = Font()->AscentInPixels();
    TInt descent = Font()->DescentInPixels();
    TInt offset = (height + (ascent + descent)) / 2; // Calculate vertical text offset
   gc->SetPenColor(TRgb(0,0,0)); // Set pen to black
    gc->UseFont(Font());
    gc->DrawText(strings[iNumber], TRect(TPoint(0,0), size), offset, CGraphicsContext::ECenter);
    gc->DiscardFont();
    }

/****************************************************************************\
|   Function:    CNumberedWindow::HandlePointerEvent
|   Purpose: Handles pointer events for CNumberedWindow.
|   Input:       aPointerEvent    The pointer event
|   Output:      None
\****************************************************************************/
void CNumberedWindow::HandlePointerEvent (TPointerEvent& aPointerEvent)
    {   
    switch (aPointerEvent.iType)
        {
        case TPointerEvent::EDrag:
            {
            // Move the window position as the pointer is dragged.
            TPoint point = aPointerEvent.iParentPosition;
            TPoint distToMove = point - iOldPos;
            TPoint position = Window().Position();
            Window().SetPosition (position + distToMove);
            iOldPos = point;
            break;
            }
        case TPointerEvent::EButton1Down:
            {
            // Move window to front
            Window().SetOrdinalPosition (0);
            // Request drag events 
            Window().PointerFilter (EPointerFilterDrag,    0);
            // Initialize starting point for dragging
            iOldPos = aPointerEvent.iParentPosition;
            break;
            }
        case TPointerEvent::EButton1Up:
            {
            // Cancel the request for drag events.
            Window().PointerFilter (EPointerFilterDrag,    EPointerFilterDrag);
            break;
            }
        case TPointerEvent::EButton3Down:
            {
            // Cascade windows in top left corner.
            // Window at the front should be cascaded last.
            // The window at the front (ordinal position 0) is given by Child(), and 
            // each window behind it is given by NextSibling(). We need to go down
            // the sibling list till we get to the last sibling, and move this to 
            // the top left corner. Then go back up the list and move each previous 
            // sibling on top of the last, displaced by an offset (of TPoint(10,10)).
            TPoint point (0,0);
            TUint32 nextSib, prevSib;
            CWindow* childWindow;
            TInt    numChildren = 0;
            TUint32 child = Window().Child();
            if (child)
                {
                childWindow = (CWindow*)child;
                numChildren++;
                nextSib = childWindow->Window().NextSibling();
                while (nextSib)
                    {
                    numChildren++;
                    childWindow = (CWindow*)nextSib;
                    nextSib = childWindow->Window().NextSibling();
                    }
                for (TInt i=numChildren; i>0; i--)
                    {
                    childWindow->Window().SetPosition (point);
                    prevSib = childWindow->Window().PrevSibling();
                    if (prevSib)
                        {
                        childWindow = (CWindow*)prevSib;
                        point += TPoint(10,10);
                        }
                    }
                }
            break;
            }
        default:
            break;
        }
    }


//////////////////////////////////////////////////////////////////////////////
//                   CMainWindow implementation
//////////////////////////////////////////////////////////////////////////////


/****************************************************************************\
|   Function:    Constructor/Destructor for CMainWindow
|   Input:       aClient      Client application that owns the window
\****************************************************************************/
CMainWindow::CMainWindow (CWsClient* aClient)
: CWindow (aClient)
    {
    }


CMainWindow::~CMainWindow ()
    {
    iWindow.Close();
    }

/****************************************************************************\
|   Function:    CMainWindow::Draw
|   Purpose: Redraws the contents of CMainWindow within a given
|               rectangle.
|   Input:       aRect    Rectangle that needs redrawing
|   Output:      None
\****************************************************************************/

void CMainWindow::Draw(const TRect& aRect)
    {
    CWindowGc* gc=SystemGc(); // get a gc
    gc->SetClippingRect(aRect); // clip outside this rect
    gc->Clear(aRect); // clear
    }


/****************************************************************************\
|   Function:    CMainWindow::HandlePointerEvent
|   Purpose: Handles pointer events for CMainWindow.
|   Input:       aPointerEvent    The pointer event!
|   Output:      None
\****************************************************************************/

void CMainWindow::HandlePointerEvent (TPointerEvent& aPointerEvent)
    {   
    switch (aPointerEvent.iType)
        {
        case TPointerEvent::EButton3Down:
            {
            // Cascade windows in top left corner
            // Window at the front should be cascaded last.
            // The window at the front (ordinal position 0) is given by Child(), and 
            // each window behind it is given by NextSibling(). We need to go down
            // the sibling list till we get to the last sibling, and move this to 
            // the top left corner. Then go back up the list and move each previous 
            // sibling on top of the last, displaced by an offset (of TPoint(10,10)).
            TPoint point (0,0);
            TUint32 nextSib, prevSib;
            CWindow* childWindow;
            TInt    numChildren = 0;
            TUint32 child = Window().Child();
            if (child)
                {
                childWindow = (CWindow*)child;
                numChildren++;
                nextSib = childWindow->Window().NextSibling();
                while (nextSib)
                    {
                    numChildren++;
                    childWindow = (CWindow*)nextSib;
                    nextSib = childWindow->Window().NextSibling();
                    }
                for (TInt i=numChildren; i>0; i--)
                    {
                    childWindow->Window().SetPosition (point);
                    prevSib = childWindow->Window().PrevSibling();
                    if (prevSib)
                        {
                        childWindow = (CWindow*)prevSib;
                        point += TPoint(10,10);
                        }
                    }
                }
            break;
            }
        default:
            break;
        }
    }


//////////////////////////////////////////////////////////////////////////////
//                   CExampleWsClient implementation
//////////////////////////////////////////////////////////////////////////////

CExampleWsClient* CExampleWsClient::NewL(const TRect& aRect)
    {
    // make new client
    CExampleWsClient* client=new (ELeave) CExampleWsClient(aRect); 
    CleanupStack::PushL(client); // push, just in case
    client->ConstructL(); // construct and run
    CleanupStack::Pop();
    return client;
    }

/****************************************************************************\
|   Function:    Constructor/Destructor for CExampleWsClient
|               Destructor deletes everything that was allocated by
|               ConstructMainWindowL()
\****************************************************************************/

CExampleWsClient::CExampleWsClient(const TRect& aRect)
:iRect(aRect)
    {
    }

CExampleWsClient::~CExampleWsClient ()
    {
    delete iWindow1;
    delete iWindow2;
    delete iWindow3;
    delete iWindow4;
    delete iWindow5;
    delete iMainWindow;
    }


/****************************************************************************\
|   Function:    CExampleWsClient::ConstructMainWindowL()
|               Called by base class's ConstructL
|   Purpose: Allocates and creates all the windows owned by this client
|               (See list of windows in CExampleWsCLient declaration).
\****************************************************************************/

void CExampleWsClient::ConstructMainWindowL()
    {
    // Resources allocated in this function are freed in the CExampleWsClient destructor
            
    iMainWindow=new (ELeave) CMainWindow(this);
    iMainWindow->ConstructL(iRect, TRgb (255,255,255));
    TInt count=0;
    TRect rect(0,0,40,40);
    iWindow1  = new (ELeave) CNumberedWindow (this, count++);
    iWindow1->ConstructL (rect, TRgb (50, 50, 50),iMainWindow);
    iWindow2  = new (ELeave) CNumberedWindow (this, count++);
    iWindow2->ConstructL (rect, TRgb (100, 100, 100),iMainWindow);
    iWindow3  = new (ELeave) CNumberedWindow (this, count++);
    iWindow3->ConstructL (rect, TRgb (150, 150, 150),iMainWindow);
    iWindow4  = new (ELeave) CNumberedWindow (this, count++);
    rect.Shrink(10,10);
    iWindow4->ConstructL (rect, TRgb (200, 200, 200),iWindow1);
    iWindow5  = new (ELeave) CNumberedWindow (this, count++);
    iWindow5->ConstructL (rect, TRgb (150, 150, 150),iWindow1);
    }


/****************************************************************************\
|   Function:    CExampleWsClient::RunL()
|               Called by active scheduler when an even occurs
|   Purpose: Processes events according to their type
|               For key events: calls HandleKeyEventL() (global to client)
|               For pointer event: calls HandlePointerEvent() for window
|                                  event occurred in.
\****************************************************************************/
void CExampleWsClient::RunL()
    {
    // get the event
    iWs.GetEvent(iWsEvent);
    TInt eventType=iWsEvent.Type();
    // take action on it
    switch (eventType)
        {
    // events global within window group
    case EEventNull:
        break;
    case EEventKey:
        {
        TKeyEvent& keyEvent=*iWsEvent.Key(); // get key event
        HandleKeyEventL (keyEvent);
        break;
        }
    case EEventKeyUp:
    case EEventModifiersChanged:
    case EEventKeyDown:
    case EEventFocusLost:
    case EEventFocusGained:
    case EEventSwitchOn:
    case EEventPassword:
    case EEventWindowGroupsChanged:
    case EEventErrorMessage:
        break;
    // events local to specific windows
    case EEventPointer:
        {
        CWindow* window=(CWindow*)(iWsEvent.Handle()); // get window
        TPointerEvent& pointerEvent=*iWsEvent.Pointer();
        window->HandlePointerEvent (pointerEvent);
        break;
        }
    case EEventPointerExit:
    case EEventPointerEnter:
    case EEventPointerBufferReady:
        break;
    case EEventDragDrop:
        break;
    default:
        break;
        }
    IssueRequest(); // maintain outstanding request
    }

/****************************************************************************\
|   Function:    CExampleWsClient::HandleKeyEventL()
|   Purpose: Processes key events for CExampleWsClient
|               Gets the key code from the key event.  Exits on 'Escape'
\****************************************************************************/
void CExampleWsClient::HandleKeyEventL (TKeyEvent& /*aKeyEvent*/)
    {
    }

// AppHolder.h
//


#ifndef __APPHOLDER_H
#define __APPHOLDER_H

#include <coeccntx.h>

#include <eikenv.h>
#include <eikappui.h>
#include <eikapp.h>
#include <eikdoc.h>
#include <eikmenup.h>

#include <eikon.hrh>

const TUid KUidAppholder = { 0x100098e5 };

class CWsClient;

//
// CAppholderAppUi
//

class CAppholderAppUi : public CEikAppUi
    {
public:
    void ConstructL();
    ~CAppholderAppUi();
private: // from CEikAppUi
    void HandleCommandL(TInt aCommand);
private:
    CWsClient* iClient;
    };


//
// CAppholderDocument
//

class CAppholderDocument : public CEikDocument
    {
public:
    // construct/destruct
    CAppholderDocument(CEikApplication& aApp);
    ~CAppholderDocument();
private: // from CEikDocument
    CEikAppUi* CreateAppUiL();
    };


//
// CAppholderApplication
//

class CAppholderApplication : public CEikApplication
    {
private: // from CApaApplication
    CApaDocument* CreateDocumentL();
    TUid AppDllUid() const;
    };

#endif

// Base.H
//
// Copyright (c) 2005 Symbian Softwares Ltd.  All rights reserved.
//



#if !defined(__WSWINORD_H__)
#define __WSWINORD_H__

// Forward declarations
class CWsRedrawer;
class CWindow;


/////////////////////////////////////////////////////////////////////////
//                      Declaration of CWsClient
/////////////////////////////////////////////////////////////////////////

class CWsClient : public CActive
    {
public:
    void ConstructL();
    // destruct
    ~CWsClient();
    // main window
    virtual void ConstructMainWindowL();
    // terminate cleanly
    void Exit();
    // active object protocol
    void IssueRequest(); // request an event
    void DoCancel(); // cancel the request
    virtual void RunL() = 0; // handle completed request
    virtual void HandleKeyEventL (TKeyEvent& aKeyEvent) = 0;
protected:
    //construct
    CWsClient();
    CWsScreenDevice* iScreen;
    CWsRedrawer* iRedrawer;
    RWsSession iWs;
    TWsEvent iWsEvent;
private:
    RWindowGroup iGroup;
    CWindowGc* iGc;
    friend class CWsRedrawer; // needs to get at session
    friend class CWindow; // needs to get at session
    };



////////////////////////////////////////////////////////////////////////////
//                      CWsRedrawer declaration
////////////////////////////////////////////////////////////////////////////

class CWsRedrawer : public CActive
    {
public:
    // construct/destruct
    CWsRedrawer();
    void ConstructL(CWsClient* aClient);
    ~CWsRedrawer();
    // drawing
    void IssueRequest();
    void DoCancel();
    void RunL();
protected:
    CWsClient* iClient;
    };


//////////////////////////////////////////////////////////////////////////////
//                          CWindow declaration
//////////////////////////////////////////////////////////////////////////////

class CWindow : public CBase
    {
public:
    CWindow(CWsClient* aClient);
    void ConstructL (const TRect& aRect, const TRgb& aColor, CWindow* aParent=0);
    ~CWindow();
    // access
    RWindow& Window(); // our own window
    CWindowGc* SystemGc(); // system graphics context
    CWsScreenDevice* Screen();
    CFont* Font();
    // drawing
    virtual void Draw(const TRect& aRect) = 0;
    virtual void HandlePointerEvent (TPointerEvent& aPointerEvent) = 0;
protected:
    RWindow iWindow; // window server window
    TRect iRect; // window's extent
private:
    CWsClient* iClient; // client including session and group
    CFont*  iFont;
    };


#endif

// Ordinal.H
//
// Copyright (c) 2005 Symbian Softwares Ltd.  All rights reserved.
//


#if !defined(__WSWNORD1_H__)
#define __WSWNORD1_H__

#include "Base.h"

//////////////////////////////////////////////////////////////////////////
//                      Derived window classes
//////////////////////////////////////////////////////////////////////////
// CNumberedWindow displays a number in its center and supports drag and drop
class CNumberedWindow : public CWindow
    {
public:
    CNumberedWindow (CWsClient* aClient, TInt aNum);
    ~CNumberedWindow ();
    void Draw (const TRect& aRect);
    void HandlePointerEvent (TPointerEvent& aPointerEvent);
private:
    TInt    iNumber;    // Number displayed in window
    TPoint  iOldPos;  // Position is required for drag and drop
    };

// CMainWindow is a plain window that just acts as a container for the
// other windows
class CMainWindow : public CWindow
    {
public:
    CMainWindow (CWsClient* aClient);
    ~CMainWindow ();
    void Draw (const TRect& aRect);
    void HandlePointerEvent (TPointerEvent& aPointerEvent);
    };

//////////////////////////////////////////////////////////////////////////
//                      Derived client class
//////////////////////////////////////////////////////////////////////////

class CExampleWsClient : public CWsClient
    {
public:
    static CExampleWsClient* NewL(const TRect& aRect);
private:
    CExampleWsClient (const TRect& aRect);
    void ConstructMainWindowL();
    ~CExampleWsClient ();
    void RunL ();
    void HandleKeyEventL (TKeyEvent& aKeyEvent);
private:
    CMainWindow*    iMainWindow;
    CNumberedWindow* iWindow1;
    CNumberedWindow* iWindow2;
    CNumberedWindow* iWindow3;
    CNumberedWindow* iWindow4;
    CNumberedWindow* iWindow5;
    const TRect& iRect;
    };

#endif

// Ordinal.mmp
//
// Copyright (c) 2005 Symbian Softwares Ltd.  All rights reserved.
//

// From 9.1 builds supporting EKA2 with Winscw, os will treat all
// applications with the extension exe.
TARGET          Ordinal.exe       
TARGETTYPE      exe
UID         0x100098e3
VENDORID       0x70000001

SOURCEPATH      .
SOURCE          AppHolder.cpp Base.cpp Ordinal.cpp
USERINCLUDE     .
SYSTEMINCLUDE   \epoc32\include
SYSTEMINCLUDE   \epoc32\include\techview

// To support the new resource compilation practice from 9.1
// provide the following details to generate .rss files
START RESOURCE Ordinal.rss            
TARGET          Ordinal.rsc
TARGETPATH      \Resource\Apps
HEADER
LANG 01       // Build English language versions
END


// In v8.1, both aif files and registration files are supported,
// but from v9.0 onwards, only registration files are supported.
start resource    Ordinal_reg.rss
targetpath         \private\10003a3f\apps
//lang          01
end

// To support localisation for the UI applicatons
start resource Ordinal_loc.rss            
//targetpath    \resource\apps
lang           01
end

LIBRARY         euser.lib
LIBRARY         apparc.lib
LIBRARY         cone.lib
LIBRARY         eikcore.lib 
LIBRARY         ws32.lib    
LIBRARY         gdi.lib

// Ordinal.rss
//


NAME MEAD

#include <eikon.rh>
#include <eikcore.rsg>

RESOURCE RSS_SIGNATURE { }

RESOURCE TBUF
    {
    buf = "";
    }

RESOURCE EIK_APP_INFO
    {
    menubar = r_appholder_menubar;
    hotkeys = r_appholder_hotkeys;
    }

RESOURCE HOTKEYS r_appholder_hotkeys
    {
    control =
        {
        HOTKEY
            {
            command = EEikCmdExit;
            key = 'e';
            }
        };
    }

RESOURCE MENU_BAR r_appholder_menubar
    {
    titles =
        {
        MENU_TITLE
            {
            menu_pane = r_appholder_file_menu;
            txt = "File";
            }
    };
    }

RESOURCE MENU_PANE r_appholder_file_menu
    {
    items =
        {
        MENU_ITEM
            {
            command = EEikCmdExit;
            txt = "Close";
            }
        };
    }

#include <appinfo.rh>
   
RESOURCE LOCALISABLE_APP_INFO
{
short_caption = "Ordinal";
caption_and_icon =
    {
    CAPTION_AND_ICON_INFO
        {
        caption = "Ordinal";
        number_of_icons = 0; // each icon must be a bitmap/mask pair
        }
    };
}     

// Ordinal.RSS
//
// Copyright (c) 2005 Symbian Software Ltd.  All rights reserved.
//

#include <appinfo.rh>

UID2 KUidAppRegistrationResourceFile
UID3 0x100098e3
RESOURCE APP_REGISTRATION_INFO
 { 
 app_file = Ordinal;
 localisable_resource_file="\\resource\\apps\\Ordinal_loc.rss";
 hidden=KAppNotHidden;
 embeddability=KAppNotEmbeddable;
 newfile=KAppDoesNotSupportNewFile;
 launch=KAppLaunchInForeground;
 }

Ordinal uses five numbered, draggable windows, similar to the draggable window used in the previous example to demonstrate the ordinal positioning of windows.

Clicking in a window with the left mouse button brings that window to the front by giving it an ordinal position of 0. Dragging with the left mouse button moves the windows around on the screen.

Clicking in a window with the right mouse button cascades the children of that window in the top left corner (using RWindowTreeNode::Child(), NextSibling() and PrevSibling()). The windows are cascaded according to their ordinal position in the top window's list of siblings.

The behaviour invoked by the right mouse button click is unavailable on the target phone. Windows can be dragged using the pointer, and tapping on a window brings it to the front.

• RWindowTreeNode: General window behaviour