examples/Graphics/GraphicsShell/Draw.cpp

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 //
00015 
00016 #include "GraphicsControl.h"
00017 
00018 #include <coemain.h>
00019 
00020 // Text printed to the console in UpdateModeL()
00021 _LIT(KTxtUpdateModelCase0,"point in center of screen");
00022 _LIT(KTxtUpdateModelCase1,"bolder point in center of screen");
00023 _LIT(KTxtUpdateModelCase2,"really bold point in center of screen");
00024 _LIT(KTxtUpdateModelCase3,"a line");
00025 _LIT(KTxtUpdateModelCase4,"a thicker line");
00026 _LIT(KTxtUpdateModelCase5,"really thick - note round ends and clipping");
00027 _LIT(KTxtUpdateModelCase6,"dotted line");
00028 _LIT(KTxtUpdateModelCase7,"dot-dash line");
00029 _LIT(KTxtUpdateModelCase8,"triangle using relative drawing");
00030 _LIT(KTxtUpdateModelCase9,"thick triangle - note rounded corners");
00031 _LIT(KTxtUpdateModelCase10,"dotted triangle - note pattern continuation");
00032 _LIT(KTxtUpdateModelCase11,"centered ellipse");
00033 _LIT(KTxtUpdateModelCase12,"arc - part of ellipse");
00034 _LIT(KTxtUpdateModelCase13,"arc - other part - see also construction elements");
00035 _LIT(KTxtUpdateModelCase14,"pie slices");
00036 _LIT(KTxtUpdateModelCase15,"centered rectangle with rounded corners");
00037 _LIT(KTxtUpdateModelCase16,"rounded rectangle showing corner ellipse");
00038 _LIT(KTxtUpdateModelCase17,"polyline");
00039 _LIT(KTxtUpdateModelCase18,"polygon with winding-fill rule");
00040 _LIT(KTxtUpdateModelCase19,"polygon using alternate-fill rule");
00041 _LIT(KTxtUpdateModelCase20,"copying using CopyRect()");
00042 _LIT(KTxtUpdateModelCase21,"left-justified boxed text");
00043 _LIT(KTxtUpdateModelCase22,"centered boxed text");
00044 _LIT(KTxtUpdateModelCase23,"right-justified offset text");
00045 _LIT(KTxtUpdateModelCase24,"cross-hatched box");
00046 _LIT(KTxtUpdateModelCase25,"teeny preview font!");
00047 _LIT(KTxtUpdateModelDefault,"overran!");
00048 
00049 static CArrayFix<TPoint>* CreatePointsArrayL();
00050 
00051 void CDrawControl::UpdateModelL()
00052         {
00053         switch (Phase())
00054                 {
00055                 case 0:
00056                         iGraphObserver->NotifyStatus(KTxtUpdateModelCase0);
00057                         break;
00058                 case 1:
00059                         iGraphObserver->NotifyStatus(KTxtUpdateModelCase1);
00060                         break;
00061                 case 2:
00062                         iGraphObserver->NotifyStatus(KTxtUpdateModelCase2);
00063                         break;
00064                 case 3:
00065                         iGraphObserver->NotifyStatus(KTxtUpdateModelCase3);
00066                         break;
00067                 case 4:
00068                         iGraphObserver->NotifyStatus(KTxtUpdateModelCase4);
00069                         break;
00070                 case 5:
00071                         iGraphObserver->NotifyStatus(KTxtUpdateModelCase5);
00072                         break;
00073                 case 6:
00074                         iGraphObserver->NotifyStatus(KTxtUpdateModelCase6);
00075                         break;
00076                 case 7:
00077                         iGraphObserver->NotifyStatus(KTxtUpdateModelCase7);
00078                         break;
00079                 case 8:
00080                         iGraphObserver->NotifyStatus(KTxtUpdateModelCase8);
00081                         break;
00082                 case 9:
00083                         iGraphObserver->NotifyStatus(KTxtUpdateModelCase9);
00084                         break;
00085                 case 10:
00086                         iGraphObserver->NotifyStatus(KTxtUpdateModelCase10);
00087                         break;
00088                 case 11:
00089                         iGraphObserver->NotifyStatus(KTxtUpdateModelCase11);
00090                         break;
00091                 case 12:
00092                         iGraphObserver->NotifyStatus(KTxtUpdateModelCase12);
00093                         break;
00094                 case 13:
00095                         iGraphObserver->NotifyStatus(KTxtUpdateModelCase13);
00096                         break;
00097                 case 14:
00098                         iGraphObserver->NotifyStatus(KTxtUpdateModelCase14);
00099                         break;
00100                 case 15:
00101                         iGraphObserver->NotifyStatus(KTxtUpdateModelCase15);
00102                         break;
00103                 case 16:
00104                         {
00105                         iGraphObserver->NotifyStatus(KTxtUpdateModelCase16);
00106                         }
00107                         break;
00108                 case 17:
00109                         iGraphObserver->NotifyStatus(KTxtUpdateModelCase17);
00110                         break;
00111                 case 18:
00112                         iGraphObserver->NotifyStatus(KTxtUpdateModelCase18);
00113                         break;
00114                 case 19:
00115                         iGraphObserver->NotifyStatus(KTxtUpdateModelCase19);
00116                         break;
00117                 case 20:
00118                         {
00119                         iGraphObserver->NotifyStatus(KTxtUpdateModelCase20);
00120                         }
00121                         break;
00122                 case 21:
00123                         iGraphObserver->NotifyStatus(KTxtUpdateModelCase21);
00124                         break;
00125                 case 22:
00126                         iGraphObserver->NotifyStatus(KTxtUpdateModelCase22);
00127                         break;
00128                 case 23:
00129                         iGraphObserver->NotifyStatus(KTxtUpdateModelCase23);
00130                         break;
00131                 case 24:
00132                         iGraphObserver->NotifyStatus(KTxtUpdateModelCase24);
00133                         break;
00134                 case 25:
00135                         iGraphObserver->NotifyStatus(KTxtUpdateModelCase25);
00136                         break;
00137                 default:
00138                         iGraphObserver->NotifyStatus(KTxtUpdateModelDefault);
00139                         break;
00140                 }
00141         }
00142 
00143 
00144 // Text printed to the console in UpdateModeL()
00145 _LIT(KTxtDrawCase21,"White text left justified in dark gray box");
00146 _LIT(KTxtDrawCase22,"White text centered in black box");
00147 _LIT(KTxtDrawCase23,"Dark gray text right justified in lite gray box");
00148 _LIT(KTxtDrawCase25,"This text overwrites the cleared area");
00149 
00150         
00151 void CDrawControl::Draw(const TRect& /* aRect */) const
00152         {
00153         // put the next line back in to see the individual drawing actions
00154         // (iCoeEnv->WsSession()).SetAutoFlush(ETrue);
00155         // draw surrounding rectangle
00156         CWindowGc& gc=SystemGc(); // graphics context we draw to
00157         gc.UseFont(iMessageFont); // use the system message font
00158         gc.Clear();
00159         SystemGc().DrawRect(Rect()); // surrounding rectangle to draw into
00160         TRect rect=Rect(); // a centered rectangle of the default size
00161         TRect ellipseRect=Rect(); // for arcs and ellipse
00162         ellipseRect.Shrink(10,10); // set size so inside the border rectangle
00163         TRect box=Rect(); // a smaller centered rectangle, for text in a box
00164         box.Shrink(10,10); // set size of text box
00165         TRect tinyBox=Rect(); // a tiny box to clear
00166         tinyBox.Shrink(220,90); // set size of tiny box to clear
00167         TInt offset=0; // offset, for text in a box
00168         TPoint screenCenterPoint=rect.Center(); // the center of the screen 
00169         // set up a pair of construction points for arc and pie slice drawing
00170         // set up the size for half a screen (divided vertically)
00171         TPoint constructionPoint1(15,15); // outside the construction ellipse
00172         TPoint constructionPoint2(200,150); // inside the construction ellipse
00173         // set up a pair of points for drawing diagonal lines
00174         TPoint startPoint(50,50);
00175         TPoint endPoint(590,190);
00176         // set up an array of points for drawing a polyline and a polygon etc
00177         // will be used relative to top left of rectangle
00178         CArrayFix<TPoint>* mypoints=NULL;
00179         TRAPD(err,mypoints = CreatePointsArrayL());
00180         if(err)
00181                 {
00182                 return;
00183                 }
00184         // set up a black, a dark gray, a lite gray and a white RGB color
00185         TRgb black(0,0,0);
00186         TRgb darkGray(85,85,85);
00187         TRgb liteGray(170,170,170);
00188         TRgb white(255,255,255); // appears as blank screen gray-green color
00189         // Set up a "bold" size for the pen tip to (default is 1,1)
00190         TSize penSizeBold(3,3);
00191         // Set up a "fat" size for the pen tip
00192         TSize penSizeFat(30,30);
00193         // decide what to do, and do it
00194         switch (Phase())
00195                 {
00196                 case 0:
00197                         // draw a single pixel point in the center of the screen
00198                         // it is so small that some text is needed to explain the screen...
00199                         gc.Plot(screenCenterPoint);
00200                         break;
00201                 case 1:
00202                         // draw a "bold" point 3 pixels across
00203                         gc.SetPenSize(penSizeBold);
00204                         gc.Plot(screenCenterPoint);
00205                         break;
00206                 case 2:
00207                         // draw a "fat" point (circular blob),
00208                         // illustrating the effect of a very wide pen
00209                         gc.SetPenSize(penSizeFat);
00210                         gc.Plot(screenCenterPoint);
00211                         break;
00212                 case 3:
00213                         // draw a thin line fromtop left to bottom right
00214                         gc.DrawLine(startPoint,endPoint);
00215                         break;
00216                 case 4:
00217                         // draw a "bold" line fromtop left to bottom right
00218                         gc.SetPenSize(penSizeBold);
00219                         gc.DrawLine(startPoint,endPoint);
00220                         break;
00221                 case 5:
00222                         // draw a rather wide line from top left to bottom right,
00223                         // illustrating rounded ends and their clipping
00224                         gc.SetPenSize(penSizeFat);
00225                         gc.DrawLine(startPoint,endPoint);
00226                         break;
00227                 case 6:
00228                         // draw a dotted line from top left to bottom right
00229                         gc.SetPenStyle(CGraphicsContext::EDottedPen);
00230                         gc.DrawLine(startPoint,endPoint);
00231                         break;
00232                 case 7:
00233                         // draw a dot-dash line from top left to bottom right
00234                         gc.SetPenStyle(CGraphicsContext::EDotDashPen);
00235                         gc.DrawLine(startPoint,endPoint);
00236                         break;
00237                 case 8:
00238                         // draw a triangle by relative drawing
00239                         gc.MoveTo(TPoint(300,50)); // drawing position (300,50)
00240                         gc.DrawLineBy(TPoint(205,100)); // drawing position (505,150)
00241                         gc.DrawLineBy(TPoint(-410,0)); // drawing position (95,150)
00242                         gc.DrawLineBy(TPoint(205,-100)); // drawing position (300,50)
00243                         break;
00244                 case 9:
00245                         // draw a triangle, by relative drawing
00246                         // illustrating rounded ends at corners when using very wide lines
00247                         gc.SetPenSize(penSizeFat);
00248                         gc.MoveTo(TPoint(300,50)); // drawing position (300,50)
00249                         gc.DrawLineBy(TPoint(205,100)); // drawing position (505,150)
00250                         gc.DrawLineBy(TPoint(-410,0)); // drawing position (95,150)
00251                         gc.DrawLineBy(TPoint(205,-100)); // drawing position (300,50)
00252                         break;
00253                 case 10:
00254                         // draw a triangle by sequential drawing between specified points,
00255                         // using dot-dash line style, illustrating line pattern continuation 
00256                         gc.SetPenStyle(CGraphicsContext::EDotDashPen);
00257                         gc.MoveTo(TPoint(300,50)); // drawing position (300,50)
00258                         gc.DrawLineTo(TPoint(505,150)); // drawing position (505,150)
00259                         gc.DrawLineTo(TPoint(95,150)); // drawing position (95,150)
00260                         gc.DrawLineTo(TPoint(300,50)); // drawing position (300,50)
00261                         break;
00262                 case 11:
00263                         // draw an ellipse centered in the rectangle
00264                         gc.DrawEllipse(ellipseRect);
00265                         break;
00266                 case 12:
00267                         // draw an arc centered in the rectangle
00268                         gc.DrawArc(ellipseRect,constructionPoint1,constructionPoint2);
00269                         // gc.Clear();
00270                         break;
00271                 case 13:
00272                         // draw an arc centered in the rectangle that is the other
00273                         // portion of the ellipse (arguments reversed)
00274                         gc.DrawArc(ellipseRect,constructionPoint2,constructionPoint1);
00275                         // draw construction lines and points
00276                         gc.SetPenStyle(CGraphicsContext::EDottedPen);
00277                         gc.MoveTo(constructionPoint1);
00278                         gc.DrawLineTo(screenCenterPoint);
00279                         gc.DrawLineTo(constructionPoint2);
00280                         gc.SetPenSize(penSizeBold);
00281                         gc.Plot(constructionPoint1);
00282                         gc.Plot(constructionPoint2);
00283                         gc.Plot(screenCenterPoint);
00284                         break;
00285                 case 14:
00286                         // draw a pie slice centered in the rectangle
00287                         gc.SetBrushStyle(CGraphicsContext::ESolidBrush);
00288                         gc.SetBrushColor(white);
00289                         gc.DrawPie(ellipseRect,constructionPoint1,constructionPoint2);
00290                         // draw the other portion of the elliptical disc
00291                         gc.SetBrushStyle(CGraphicsContext::EVerticalHatchBrush);
00292                         gc.DrawPie(ellipseRect,constructionPoint2,constructionPoint1);
00293                         break;
00294                 case 15:
00295                         {
00296                         // draw a rectangle with rounded corners, centered in the rectangle
00297                         TSize cornerSize(20,20); // size of a rounded corner
00298                         gc.DrawRoundRect(box,cornerSize); // same rect as text box
00299                         }
00300                         break;
00301                 case 16:
00302                         {
00303                         // draw a rectangle with rounded corners,
00304                         //centered in the rectangle, showing a corner ellipse
00305                         TSize cornerSize(20,20); // size of a rounded corner
00306                         // rect for corner ellipse is twice the corner size
00307                         TSize cornerEllipseSize(cornerSize.iHeight*2,cornerSize.iWidth*2);
00308                         TRect cornerRectTl(box.iTl,cornerEllipseSize);
00309                         gc.DrawRoundRect(box,cornerSize);
00310                         gc.SetPenStyle(CGraphicsContext::EDottedPen);
00311                         gc.DrawEllipse(cornerRectTl); // corner construction ellipse
00312                         }
00313                         break;
00314                 case 17:
00315                         // draw a polyline
00316                         gc.DrawPolyLine(mypoints);
00317                         break;
00318                 case 18:
00319                         // draw self-crossing polygon using the winding fill rule
00320                         gc.SetBrushStyle(CGraphicsContext::ESquareCrossHatchBrush);
00321                         gc.SetBrushColor(black);
00322                         gc.DrawPolygon(mypoints,CGraphicsContext::EWinding);
00323                         break;
00324                 case 19:
00325                         // draw self-crossing polygon using the alternate fill rule
00326                         gc.SetBrushStyle(CGraphicsContext::EDiamondCrossHatchBrush);
00327                         gc.SetBrushColor(black);
00328                         gc.DrawPolygon(mypoints,CGraphicsContext::EAlternate);
00329                         break;
00330                 case 20:
00331                         {
00332                         // draw self-crossing polygon using the alternate fill rule,
00333                         // and copy the lhs to the rhs of the screen
00334                         gc.SetBrushStyle(CGraphicsContext::EDiamondCrossHatchBrush);
00335                         gc.SetBrushColor(black);
00336                         gc.DrawPolygon(mypoints,CGraphicsContext::EAlternate);
00337                         TPoint screenOrigin(0,0); // top left of the screen
00338                         TSize halfScreenLR(320,240); // size of vertical half of screen
00339                         rect.SetRect(screenOrigin,halfScreenLR); // lhs of screen
00340                         TPoint offset(halfScreenLR.iWidth,0); // half screen width offset
00341                         gc.CopyRect(offset,rect); //  copy lhs of screen to rhs
00342                         }
00343                         break;
00344                 case 21:
00345                         // draw some text left justified in a box,
00346                         // offset so text is just inside top of box
00347                         {
00348                         CFont* font=iMessageFont; // get the system message font
00349                         TInt fontAscent(font->AscentInPixels()); // system message font ascent
00350                         offset=fontAscent+3; // add a 3 pixel text line spacing
00351                         TInt margin=2; // left margin is two pixels
00352                         gc.SetBrushStyle(CGraphicsContext::ESolidBrush);
00353                         gc.SetBrushColor(darkGray);
00354                         gc.SetPenColor(white);
00355                         gc.UseFont(iMessageFont);
00356                         gc.DrawText(KTxtDrawCase21,box,offset,CGraphicsContext::ELeft,margin);
00357                         }
00358                         break;
00359                 case 22:
00360                         // draw some text centered in a box, (margin is zero)
00361                         {
00362                         TInt boxHeight=box.Height(); // get height of text box
00363                         CFont* font=iMessageFont; // get the system message font
00364                         TInt textHeight(font->HeightInPixels()); // system message font height
00365                         offset=(textHeight+boxHeight)/2; // 1/2 font ht below halfway down box
00366                         TInt margin=0; // margin is zero
00367                         gc.SetBrushStyle(CGraphicsContext::ESolidBrush);
00368                         gc.SetBrushColor(black);
00369                         gc.SetPenColor(white);
00370                         gc.UseFont(iMessageFont);
00371                         gc.DrawText(KTxtDrawCase22,box,offset,CGraphicsContext::ECenter,margin);
00372                         }
00373                         break;
00374                 case 23:
00375                         // draw some text right justified in a box,
00376                         // offset so text is just inside bottom of box
00377                         {
00378                         TInt boxHeight=box.Height(); // get height of text box
00379                         CFont* font=iMessageFont; // get the system message font
00380                         TInt fontDescent=font->DescentInPixels(); // system message font descent
00381                         offset=boxHeight-fontDescent-3;// offset, 3 pixel text line spacing 
00382                         TInt margin=2; // right margin is two pixels
00383                         gc.SetBrushStyle(CGraphicsContext::ESolidBrush);
00384                         gc.SetBrushColor(liteGray);
00385                         gc.SetPenColor(darkGray);
00386                         gc.UseFont(iMessageFont);
00387                         gc.DrawText(KTxtDrawCase23,box,offset,CGraphicsContext::ERight,margin);
00388                         }
00389                         break;
00390                 case 24:
00391                         {
00392                         // draw a cross-hatched box
00393                         // then clear a small central rectangle
00394                         gc.SetBrushColor(darkGray);
00395                         gc.SetBrushStyle(CGraphicsContext::ESquareCrossHatchBrush);
00396                         gc.DrawRect(rect);
00397                         // clear a small rectangle
00398                         gc.SetBrushColor(liteGray); // change the brush color
00399                         gc.Clear(tinyBox); // clear to brush color
00400                         }
00401                         break;
00402                 case 25:
00403                         {
00404                         // draw a cross-hatched box
00405                         // then clear a small central rectangle
00406                         // and write some text in it in smallest Swiss font,
00407                         // (which is actually a tiny "block" print-preview font)
00408                         // starting bottom left (illustrating flicker, overlap, mess)
00409                         gc.SetBrushColor(darkGray);
00410                         gc.SetBrushStyle(CGraphicsContext::ESquareCrossHatchBrush);
00411                         gc.DrawRect(rect);
00412                         // clear a small rectangle
00413                         gc.SetBrushColor(liteGray); // change the brush color
00414                         gc.Clear(tinyBox); // clear to brush color
00415                         // get an alternative font
00416                         CFont* myFont;
00417                         _LIT(KTxtArial,"Arial");
00418                         TFontSpec myFontSpec(KTxtArial,1); // to get smallest Arial font
00419                         CGraphicsDevice* screenDevice=(iCoeEnv->ScreenDevice());
00420                         screenDevice->GetNearestFontInTwips(myFont,myFontSpec);
00421                         gc.UseFont(myFont);
00422                         // set the text drawing position & draw (demonstrating flicker)
00423                         TInt fontDescent=myFont->DescentInPixels();
00424                         TPoint pos(0,tinyBox.Height()-fontDescent);
00425                         pos+=tinyBox.iTl;
00426                         gc.DrawText(KTxtDrawCase25,pos);
00427                         // discard and destroy the font
00428                         gc.DiscardFont();
00429                         screenDevice->ReleaseFont(myFont);
00430                         }
00431                         break;
00432                 default:
00433                         break;
00434                 }
00435         delete mypoints; // an array must be destroyed after use
00436         }
00437 
00438 static CArrayFix<TPoint>* CreatePointsArrayL()
00439         {
00440         CArrayFixFlat<TPoint>* pointsArray = new CArrayFixFlat<TPoint>(5);
00441         
00442         TPoint point1(20,20);
00443         TPoint point2(100,190);
00444         TPoint point3(110,90);
00445         TPoint point4(50,150);
00446         TPoint point5(200,150);
00447         
00448         pointsArray->AppendL(point1);
00449         pointsArray->AppendL(point2);
00450         pointsArray->AppendL(point3);
00451         pointsArray->AppendL(point4);
00452         pointsArray->AppendL(point5);
00453         
00454         return pointsArray;
00455         }
Generated by  doxygen 1.6.2

Copyright ©2010 Nokia Corporation and/or its subsidiary(-ies).
All rights reserved. Unless otherwise stated, these materials are provided under the terms of the Eclipse Public License v1.0.