TB10.1 Example Applications: examples/AppFramework/UIControls/CustomControls/CustomControls.cpp Source File

00001 // Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies).
+00002 // All rights reserved.
+00003 // This component and the accompanying materials are made available
+00004 // under the terms of "Eclipse Public License v1.0"
+00005 // which accompanies this distribution, and is available
+00006 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
+00007 //
+00008 // Initial Contributors:
+00009 // Nokia Corporation - initial contribution.
+00010 //
+00011 // Contributors:
+00012 //
+00013 // Description:
+00014 // UI Control Framework example program
+00015 // This example demonstrates how to write new control classes.
+00016 // The example creates three new control classes:
+00017 // 1. CSmiley              - a simple control which displays a 
+00018 // smiley face that can have two moods,
+00019 // happy and sad. The user can change
+00020 // the smiley's mood by pressing the
+00021 // space bar.
+00022 // 2. CSmileyContainer     - a compound control which contains
+00023 // two CSmiley controls, side by side.
+00024 // The user can move the keyboard focus
+00025 // from one CSmiley to the other using
+00026 // the arrow keys, or the pointer.
+00027 // 3. CMainWinControl      - a compound control which does nothing
+00028 // except act as a background window and a 
+00029 // container for other controls in the 
+00030 // application.
+00031 // When the application starts up, it creates a CMainWinControl to cover
+00032 // the entire screen, and a CSmileyContainer inside this main window.
+00033 // The application's menu contains just two options. One of them closes 
+00034 // the application; the other creates a dialog which contains a 
+00035 // CSmileyContainer. CSmileyContainer therefore illustrates how to write 
+00036 // a control that can be created both in a dialog and within the
+00037 // application's main view.
+00038 //
+00039 
+00040 #include "CustomControls.h"
+00041 #include <eikstart.h>
+00042 
+00043 
+00045 //
+00046 // -----> CMainWinControl(implementation)
+00047 //
+00049 CMainWinControl::CMainWinControl()
+00050         {
+00051         }
+00052 
+00053 CMainWinControl::~CMainWinControl()
+00054         {
+00055         delete iContainer;
+00056         }
+00057 
+00058 // CMainWinControl needs a ConstructL(), because it is a compound control
+00059 // (and a window-owning control).
+00060 void CMainWinControl::ConstructL(const TRect& rect)
+00061         {
+00062         // Make this a window-owning control.
+00063         CreateWindowL();
+00064         SetRect(rect);
+00065 
+00066         // Create its only component, a CSmileyContainer
+00067         iContainer = new(ELeave) CSmileyContainer;
+00068         iContainer->SetContainerWindowL(*this);
+00069         TRect containerRect=Rect();
+00070         iContainer->ConstructL(containerRect);
+00071         // Activate the main window control - this will also activate the 
+00072         // CSmileyContainer and its components.
+00073         ActivateL();
+00074         DrawNow();
+00075         }
+00076 
+00077 // The following two functions have to be implemented for all compound controls.
+00078 TInt CMainWinControl::CountComponentControls() const
+00079         {
+00080         return 1;
+00081         }
+00082 
+00083 CCoeControl* CMainWinControl::ComponentControl(TInt /*aIndex*/) const
+00084         {
+00085         return iContainer;
+00086         }
+00087 
+00088 // Draw the main window.
+00089 void CMainWinControl::Draw(const TRect& /*aRect*/) const
+00090         {
+00091         CWindowGc& gc=SystemGc();
+00092         gc.SetBrushColor(KRgbWhite);
+00093         gc.Clear(Rect());
+00094         }
+00095 
+00096 // CSmileyContainer can't be put on the control stack, because it's a component of this 
+00097 // control. The main window control goes on the stack and passes on any key events it gets
+00098 // to the CSmileyContainer.
+00099 TKeyResponse CMainWinControl::OfferKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType)
+00100         {
+00101         return (iContainer->OfferKeyEventL(aKeyEvent, aType));
+00102         }
+00103 
+00105 //
+00106 // -----> CSmileyContainer (implementation)
+00107 //
+00109 CSmileyContainer::CSmileyContainer()
+00110         {}
+00111 
+00112         
+00113 CSmileyContainer::~CSmileyContainer()
+00114         {
+00115           // Delete all the contained controls 
+00116         delete iSmiley1;
+00117         delete iSmiley2;
+00118         }
+00119 
+00120 
+00121 // Because CSmileyContainer is a compound control, it needs a
+00122 // ConstructL() for when it's created outside a dialog, and a
+00123 // ConstructFromResourceL() for when it's created inside a dialog.
+00124 void CSmileyContainer::ConstructL(const TRect& aRect)
+00125         {
+00126         TBool isSmiling=ETrue;
+00127 
+00128         // Create the two CSmileys. Their size and position is 
+00129         // set in CSmileyContainer::SizeChangedL().
+00130         iSmiley1 = new(ELeave) CSmiley(isSmiling);
+00131         iSmiley1->SetContainerWindowL(*this);
+00132 
+00133         isSmiling=EFalse;
+00134 
+00135         iSmiley2 = new(ELeave) CSmiley(isSmiling);
+00136         iSmiley2->SetContainerWindowL(*this);
+00137 
+00138         iSmiley1->SetFocus(ETrue);
+00139 
+00140         // Set the container as the observer of the two CSmileys. This 
+00141         // is for handling keyboard focus. When an arrow key is pressed 
+00142         // or the pointer is clicked on one of the CSmileys, an 
+00143         // EEventRequestFocus event is sent to the container, and the
+00144         // container changes the focus if applicable.
+00145         iSmiley1->SetObserver(this);
+00146         iSmiley2->SetObserver(this);
+00147 
+00148         // Set the bounding rectangle of this control (this will result in 
+00149         // a call to SizeChangedL(). The component controls must be 
+00150         // created before calling this, because SizeChangedL() sets their
+00151         // sizes.
+00152         SetRect(aRect);
+00153         }
+00154 
+00155 
+00156 // This function is used when the CSmileyContainer is created inside a dialog.
+00157 void CSmileyContainer::ConstructFromResourceL(TResourceReader& aReader)
+00158         {
+00159         // Read the smiley mood from the resource file
+00160         TBool isSmiling=(TBool)aReader.ReadInt8();
+00161         // Read the width of the smiley container from the resource file.
+00162         TInt width=aReader.ReadInt16();
+00163         // Set the height of the container to be half its width
+00164         TSize containerSize (width, width/2);
+00165 
+00166         iSmiley1 = new(ELeave) CSmiley(isSmiling);
+00167         iSmiley1->SetContainerWindowL(*this);
+00168 
+00169         iSmiley2 = new(ELeave) CSmiley(isSmiling);
+00170         iSmiley2->SetContainerWindowL(*this);
+00171 
+00172         iSmiley1->SetFocus(ETrue);
+00173 
+00174         iSmiley1->SetObserver(this);
+00175         iSmiley2->SetObserver(this);
+00176 
+00177         SetSize(containerSize);
+00178 
+00179         ActivateL();    
+00180         }
+00181 
+00182 // The following two functions have to be implemented for all compound controls.
+00183 TInt CSmileyContainer::CountComponentControls() const
+00184         {
+00185         return 2;
+00186         }
+00187 
+00188 CCoeControl* CSmileyContainer::ComponentControl(TInt aIndex) const
+00189         {
+00190         if (aIndex==0)
+00191                 return iSmiley1;
+00192         else
+00193                 return iSmiley2;
+00194         }
+00195 
+00196 // This function gets called whenever one of the size-setting functions is called.
+00197 // As this is a compound control, this function calculates and sets the size and  
+00198 // position for its components, based on its own size.
+00199 void CSmileyContainer::SizeChanged()
+00200     {
+00201         TInt containerWidth=Size().iWidth;
+00202         TInt containerHeight=Size().iHeight;
+00203         // Find half of the greater - width or height
+00204         TInt length=containerHeight>containerWidth ? containerWidth/4 : containerHeight/4; 
+00205         TSize smileySize(length,length);
+00206 
+00207         // Do some preliminary calculations so that Draw() is as short
+00208         // as possible.
+00209         TInt xOffset=smileySize.iWidth/4; // x offset from the center
+00210         TInt yOffset=(containerHeight - smileySize.iHeight) / 2;
+00211         iSmiley1->SetPosition(Position() +
+00212                 TPoint(containerWidth/2 - smileySize.iWidth - xOffset, yOffset));
+00213         iSmiley2->SetPosition(Position() + 
+00214                 TPoint(containerWidth/2 + xOffset, yOffset));
+00215         // Calling SetSizeL() causes the components' SizeChanged() to be called.
+00216         iSmiley1->SetSize(smileySize);
+00217         iSmiley2->SetSize(smileySize);
+00218         }
+00219         
+00220 void CSmileyContainer::Draw(const TRect& aRect) const
+00221         {
+00222         // Just draw a rectangle round the edge of the control.
+00223         CWindowGc& gc=SystemGc();
+00224         gc.Clear(aRect);
+00225         gc.SetClippingRect(aRect);
+00226         gc.DrawRect(Rect());
+00227         }
+00228 
+00229 // This function is defined by MCoeControlObserver. It gets called whenever
+00230 // a control that this control is observing calls ReportEventL().
+00231 // In this example, the CSmileyContainer is the observer for both of the 
+00232 // CSmileys.  CCoeControl::ProcessPointerEventL() calls ReportEvent(), 
+00233 // sending an event of type EEventRequestFocus, whenever an EButton1Down event
+00234 // occurs in the CSmiley that doesn't currently have focus.
+00235 void CSmileyContainer::HandleControlEventL(CCoeControl* aControl,
+00236                                                                                 TCoeEvent aEventType)
+00237         {
+00238         switch (aEventType)
+00239                 {
+00240                 case EEventRequestFocus:
+00241                         {
+00242                         if (aControl->IsFocused())
+00243                                 return;
+00244                         SwapFocus(aControl);
+00245                         }
+00246                         break;
+00247                 default:
+00248                         break;
+00249                 }
+00250         }
+00251 
+00252 // This function is called by the framework whenever a component in a dialog is 
+00253 // about to lose focus. It checks that the data in ithe component is valid. In
+00254 // this example, there's a "rule" that both the CSmileys in the container can't
+00255 // be miserable! If they are, the function leaves. The framework issues the message 
+00256 // we give it, and doesn't move focus away from the CSmileyContainer.
+00257 void CSmileyContainer::PrepareForFocusLossL()   
+00258         {
+00259         if (!iSmiley1->IsSmiling() && !iSmiley2->IsSmiling())
+00260                 {
+00261                 CEikonEnv::Static()->LeaveWithInfoMsg(R_EXAMPLE_TEXT_VALIDATE);
+00262                 }
+00263         }
+00264 
+00265 // This function gets called whenever the application calls SetFocus().
+00266 // It redraws the CSmileyContainer, so that they are updated to show 
+00267 // which one now has focus.
+00268 void CSmileyContainer::FocusChanged(TDrawNow aDrawNow)
+00269         {
+00270         if (IsFocused())
+00271                 {
+00272                 iSmiley1->SetFocus(ETrue, EDrawNow);
+00273                 }
+00274         else
+00275                 {
+00276                         if (iSmiley1->IsFocused())
+00277                         iSmiley1->SetFocus(EFalse, EDrawNow);
+00278                         else
+00279                         iSmiley2->SetFocus(EFalse, EDrawNow);
+00280                 }
+00281         if (aDrawNow)
+00282                 DrawNow();
+00283         }
+00284 
+00285 
+00286 void CSmileyContainer::SwapFocus(CCoeControl* aControl)
+00287         {
+00288         if (aControl==iSmiley1)
+00289                 {
+00290                 iSmiley2->SetFocus(EFalse, EDrawNow);
+00291                 iSmiley1->SetFocus(ETrue, EDrawNow);
+00292                 }
+00293         else
+00294                 {
+00295                 iSmiley1->SetFocus(EFalse, EDrawNow);
+00296                 iSmiley2->SetFocus(ETrue, EDrawNow);
+00297                 }
+00298         }
+00299 
+00300 TKeyResponse CSmileyContainer::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)
+00301         {
+00302         // Use the arrow keys to move focus between the two CSmileys.
+00303         switch (aKeyEvent.iScanCode)
+00304                 {
+00305                 case EStdKeySpace:
+00306                         if (iSmiley1->IsFocused())
+00307                                 return iSmiley1->OfferKeyEventL(aKeyEvent, aType);
+00308                         else if (iSmiley2->IsFocused())
+00309                                 return iSmiley2->OfferKeyEventL(aKeyEvent, aType);
+00310                         break;
+00311                 case EStdKeyRightArrow:
+00312                         if (iSmiley1->IsFocused())
+00313                                 SwapFocus(iSmiley2);
+00314                         else
+00315                         return EKeyWasConsumed;
+00316                         break;
+00317                 case EStdKeyLeftArrow:
+00318                         if (iSmiley2->IsFocused())
+00319                                 SwapFocus(iSmiley1);
+00320                         else
+00321                         return EKeyWasConsumed;
+00322                         break;
+00323                 default:
+00324                         break;
+00325                 }
+00326         // If the CSmileyContainer didn't use the key event, it must return EKeyWasNotConsumed,
+00327         // so that the key event is passed to other controls on the stack.
+00328         return EKeyWasNotConsumed;
+00329         }
+00330 
+00331 
+00332 
+00333 
+00335 //
+00336 // -----> CSmiley (implementation)
+00337 //
+00339 
+00340 // CSmiley doesn't need a ConstructL() because it's a simple control.
+00341 
+00342 CSmiley::CSmiley(TBool aSmiling) : iSmiling(aSmiling)
+00343         {
+00344         }
+00345 
+00346 CSmiley::~CSmiley()
+00347         {
+00348         }
+00349 
+00350 TBool CSmiley::IsSmiling()
+00351         {
+00352         return iSmiling;
+00353         }
+00354 
+00355 void CSmiley::Draw(const TRect& aRect) const
+00356         {
+00357         CWindowGc& gc=SystemGc();
+00358         if (IsFocused())
+00359                 {
+00360                 gc.SetPenColor(KRgbBlack);
+00361                 }
+00362         else
+00363                 {
+00364                 gc.SetPenColor(KRgbWhite);
+00365                 }
+00366         gc.SetBrushColor(KRgbWhite);
+00367         gc.Clear(Rect());
+00368         gc.DrawRect(Rect());
+00369 
+00370         gc.SetClippingRect(aRect);
+00371 
+00372         // Draw the smiley face, smiling or looking sad
+00373         gc.SetPenColor(KRgbBlack);
+00374         // Draw a circle for the face
+00375         gc.DrawEllipse(iSmileyRect);
+00376         // Draw the eyes
+00377         TPoint leftEye(iSmileyWidth/3, iSmileyHeight/3);
+00378         TPoint rightEye(iSmileyWidth*2/3, iSmileyHeight/3);
+00379         gc.SetPenSize(TSize(5,5));
+00380         gc.Plot(iSmileyRect.iTl+leftEye);
+00381         gc.Plot(iSmileyRect.iTl+rightEye);
+00382         //Draw the mouth, smiling or looking sad.
+00383         gc.SetPenSize(TSize(1,1));
+00384         gc.SetPenColor(KRgbWhite);
+00385         if (iSmiling)
+00386                 gc.DrawArc(iFrownRect, iFrownRect.iTl+TPoint(iSmileyWidth/2,iFrownRect.Height()/2), 
+00387                                                           iFrownRect.iTl+TPoint(0,iFrownRect.Height()/2));
+00388         else
+00389                 gc.DrawArc(iSmileRect, iSmileRect.iTl+TPoint(0,iSmileRect.Height()/2), 
+00390                                                           iSmileRect.iTl+TPoint(iSmileyWidth/2,iSmileRect.Height()/2));
+00391         gc.SetPenColor(KRgbBlack);
+00392         if (iSmiling)
+00393                 gc.DrawArc(iSmileRect, iSmileRect.iTl+TPoint(0,iSmileRect.Height()/2), 
+00394                                                           iSmileRect.iTl+TPoint(iSmileyWidth/2,iSmileRect.Height()/2));
+00395         else
+00396                 gc.DrawArc(iFrownRect, iFrownRect.iTl+TPoint(iSmileyWidth/2,iFrownRect.Height()/2), 
+00397                                                           iFrownRect.iTl+TPoint(0,iFrownRect.Height()/2));
+00398         }
+00399 
+00400 void CSmiley::SizeChanged()
+00401         {
+00402         // Calculate sizes of rectangles for drawing face and mouth
+00403         iSmileyRect=Rect();
+00404         // Allow room for the focus rectangle round the outside
+00405         iSmileyRect.Shrink(3,3);
+00406         iSmileyWidth=iSmileyRect.Width();
+00407         iSmileyHeight=iSmileyRect.Height();
+00408         iSmileRect.SetRect(iSmileyRect.iTl+TPoint(iSmileyWidth/4, iSmileyHeight/2),
+00409                                         TSize(iSmileyWidth/2, iSmileyHeight/3));
+00410         iFrownRect.SetRect(iSmileyRect.iTl+TPoint(iSmileyWidth/4, iSmileyHeight*2/3),
+00411                                         TSize(iSmileyWidth/2, iSmileyHeight/3));
+00412         }
+00413 
+00414 void CSmiley::FocusChanged(TDrawNow aDrawNow)
+00415         {
+00416         if (aDrawNow)
+00417                 DrawNow();
+00418         }
+00419 
+00420 void CSmiley::HandlePointerEventL(const TPointerEvent& aPointerEvent)
+00421         {
+00422         if (aPointerEvent.iType==TPointerEvent::EButton1Down)
+00423                 {
+00424                 iSmiling = !iSmiling;
+00425                 DrawNow();
+00426                 }
+00427         }
+00428 
+00429 TKeyResponse CSmiley::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)
+00430         {
+00431         // The space bar changes the "mood" of the CSmiley.
+00432         if (aType==EEventKey && aKeyEvent.iScanCode==EStdKeySpace)
+00433                 {
+00434                 iSmiling = !iSmiling;
+00435                 DrawNow();
+00436                 return EKeyWasConsumed;
+00437                 }
+00438         else
+00439                 {
+00440                 return EKeyWasNotConsumed;
+00441                 }
+00442         }
+00443 
+00445 //
+00446 // -----> CSmileyDialog(implementation)
+00447 //
+00449 TBool CSmileyDialog::RunDlgLD()
+00450         {
+00451         CEikDialog* dialog = new (ELeave) CSmileyDialog();
+00452         return (dialog->ExecuteLD(R_SMILEY_DIALOG));
+00453         }
+00454 
+00455 // This function is used by CEikForm::ConstructByTypeL() to create the custom 
+00456 // control within the dialog.
+00457 SEikControlInfo CSmileyDialog::CreateCustomControlL(TInt aControlType)
+00458         {
+00459         SEikControlInfo controlInfo;
+00460         controlInfo.iControl = NULL;
+00461         controlInfo.iTrailerTextId = 0;
+00462         controlInfo.iFlags = 0;
+00463 
+00464     switch (aControlType)
+00465         {
+00466     case ESmileyControl:
+00467                 controlInfo.iControl = new(ELeave) CSmileyContainer;
+00468                 break;
+00469         default:
+00470                 break;
+00471                 }
+00472     return controlInfo;
+00473         }
+00474 
+00476 //
+00477 // -----> CExampleAppUi (implementation)
+00478 //
+00480 void CExampleAppUi::ConstructL()
+00481         {
+00482           // Allow base class (CEikAppUi) to perform necessary construction
+00483         BaseConstructL();
+00484         // Construct the CMainWinControl which forms the main view
+00485         // for this application.
+00486         iMainWinControl=new(ELeave) CMainWinControl;
+00487         iMainWinControl->ConstructL(ClientRect());
+00488         // The main window is added to the control stack (for key event
+00489         // handling).   
+00490         AddToStackL(iMainWinControl);
+00491         }
+00492         
+00493 
+00494 CExampleAppUi::~CExampleAppUi()
+00495         {
+00496         RemoveFromStack(iMainWinControl);
+00497           // Delete the main window
+00498         delete iMainWinControl;
+00499         }
+00500 
+00501 void CExampleAppUi::HandleCommandL(TInt aCommand)
+00502         {
+00503           // Handle the command generated by:
+00504           //   1. menu item selection
+00505           //   2. short-cut key press
+00506         switch (aCommand)
+00507                 {
+00508         // EXIT comand
+00509         case EEikCmdExit:
+00510                 OnCmdExit();
+00511                 break;
+00512         case ECreateSmileyDialog:
+00513                 CSmileyDialog::RunDlgLD();
+00514                 break;
+00515         default :
+00516                 break;
+00517                 }
+00518         }
+00519 
+00520 void CExampleAppUi::OnCmdExit()
+00521         {
+00522         CBaActiveScheduler::Exit();
+00523         }
+00524 
+00525 void CExampleAppUi::HandleModelChangeL()
+00526         {
+00527         }
+00528 
+00530 //
+00531 // -----> CExampleDocument (implementation)
+00532 //
+00534 
+00535 CExampleDocument::CExampleDocument(CEikApplication& aApp)
+00536          : CEikDocument(aApp)
+00537         {}
+00538 
+00539 CExampleDocument::~CExampleDocument()
+00540         {
+00541         }
+00542 
+00543 CExampleDocument* CExampleDocument::NewL(CEikApplication& aApp)
+00544         {
+00545         CExampleDocument* self=new(ELeave) CExampleDocument(aApp);
+00546         CleanupStack::PushL(self);
+00547         self->CreateModelL();
+00548         CleanupStack::Pop();
+00549         return self;
+00550         }
+00551 
+00552 void CExampleDocument::ResetModelL()
+00553         {
+00554         CreateModelL();
+00555         }
+00556 
+00557 void CExampleDocument::CreateModelL()
+00558         {
+00559         }
+00560 
+00561 CEikAppUi* CExampleDocument::CreateAppUiL()
+00562         {
+00563     return(new(ELeave) CExampleAppUi);
+00564         }
+00565 
+00566 void CExampleDocument::NewDocumentL()
+00567         {
+00568         ResetModelL();
+00569         }
+00570 
+00571 void CExampleDocument::StoreL(CStreamStore& /*aStore*/,CStreamDictionary& /*aStreamDic*/) const
+00572         {
+00573         }
+00574 
+00575 void CExampleDocument::RestoreL(const CStreamStore& /*aStore*/,const CStreamDictionary& /*aStreamDic*/)
+00576         {
+00577         }
+00578 
+00579 
+00581 //
+00582 // -----> CExampleApplication (implementation)
+00583 //
+00585 TUid CExampleApplication::AppDllUid() const
+00586         {
+00587         return(KUidExampleApp);
+00588         }
+00589 
+00590 
+00591 CApaDocument* CExampleApplication::CreateDocumentL()
+00592         {
+00593         return CExampleDocument::NewL(*this);
+00594         }
+00595 
+00596 
+00597 //
+00598 // EXPORTed functions
+00599 //
+00600 
+00601 
+00602 LOCAL_C CApaApplication* NewApplication()
+00603         {
+00604         return new CExampleApplication;
+00605         }
+00606         
+00607 GLDEF_C TInt E32Main()
+00608         {
+00609         return EikStart::RunApplication(NewApplication);
+00610         }
+00611 
+00612 
+00613 
+00614 
+00615 
+