examples/logging/logging-example.cpp

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include "../shared/view.h"
  19 #include <dali/dali.h>
  20 #include <dali-toolkit/dali-toolkit.h>
  21
  22 #include <sstream>
  23
  24 using namespace Dali;
  25
  26 namespace
  27 {
  28 // Used to produce visually same dimensions on desktop and device builds
  29 float ScalePointSize( int pointSize )
  30 {
  31   Dali::Vector2 dpi = Dali::Stage::GetCurrent().GetDpi();
  32   float meanDpi = (dpi.height + dpi.width) * 0.5f;
  33   return pointSize * meanDpi / 220.0f;
  34 }
  35
  36 } // namespace
  37
  38 // Define this so that it is interchangeable
  39 // "DP" stands for Device independent Pixels
  40 #define DP(x) ScalePointSize(x)
  41
  42 //enum ButtonType
  43 //{
  44 //  PUSH_BUTTON,
  45 //  TOGGLE_BUTTON
  46 //};
  47 //
  48 //struct ButtonItem
  49 //{
  50 //  ButtonType type;
  51 //  const char* name;
  52 //  const char* text;
  53 //  const char* altText;
  54 //};
  55
  56 namespace
  57 {
  58
  59 const char* const BACKGROUND_IMAGE = DALI_IMAGE_DIR "background-gradient.jpg";
  60 const char* const TOOLBAR_IMAGE = DALI_IMAGE_DIR "top-bar.png";
  61
  62 const char* const TOOLBAR_TITLE = "Logging";
  63 //const int TOOLBAR_HEIGHT = 62;
  64
  65 const int MARGIN_SIZE = 10;
  66 const int TOP_MARGIN = 85;
  67
  68 const int LOGGER_GROUP_HEIGHT = 84;
  69 const int LOGGER_RADIO_GROUP_HEIGHT = 200;
  70
  71 const int LOGGER_RADIO_SPACING = 48;
  72
  73 const int CONSOLE_HEIGHT = 84;
  74
  75 const int BUTTON_WIDTH = 200;
  76 const int BUTTON_HEIGHT = LOGGER_GROUP_HEIGHT - MARGIN_SIZE * 2;
  77
  78 const Vector4 BACKGROUND_COLOUR( 1.0f, 1.0f, 1.0f, 0.15f );
  79
  80 const char* const PUSHBUTTON_PRESS_IMAGE = DALI_IMAGE_DIR "button-down.9.png";
  81 const char* const PUSHBUTTON_BUTTON_IMAGE = DALI_IMAGE_DIR "button-up.9.png";
  82 const char* const PUSHBUTTON_DISABLED_IMAGE = DALI_IMAGE_DIR "button-disabled.9.png";
  83
  84 // Button IDs
  85 const char* const LOGGER_1_RADIO_ID = "LOGGER_1_RADIO";
  86 const char* const LOGGER_2_RADIO_ID = "LOGGER_2_RADIO";
  87 const char* const LOGGER_3_RADIO_ID = "LOGGER_3_RADIO";
  88
  89 const char* const FREQUENCY_1_RADIO_ID = "FREQUENCY_1_RADIO";
  90 const char* const FREQUENCY_2_RADIO_ID = "FREQUENCY_2_RADIO";
  91 const char* const FREQUENCY_3_RADIO_ID = "FREQUENCY_3_RADIO";
  92
  93 const char* const CREATE_BUTTON_ID = "CREATE_BUTTON";
  94 const char* const DELETE_BUTTON_ID = "DELETE_BUTTON";
  95 const char* const START_BUTTON_ID = "START_BUTTON";
  96 const char* const STOP_BUTTON_ID = "STOP_BUTTON";
  97 const char* const HIGH_FREQ_BUTTON_ID = "INC_FREQ_BUTTON";
  98 const char* const LOW_FREQ_BUTTON_ID = "DEC_FREQ_BUTTON";
  99 const char* const ENABLE_BUTTON_ID = "ENABLE_BUTTON";
 100 const char* const DISABLE_BUTTON_ID = "DISABLE_BUTTON";
 101 const char* const VSYNC_BUTTON_ID = "VSYNC_BUTTON";
 102
 103 const char* const CREATE_BUTTON_TEXT = "Create";
 104 const char* const DELETE_BUTTON_TEXT = "Delete";
 105 const char* const START_BUTTON_TEXT = "Start";
 106 const char* const STOP_BUTTON_TEXT = "Stop";
 107 const char* const ENABLE_BUTTON_TEXT = "Enable";
 108 const char* const DISABLE_BUTTON_TEXT = "Disable";
 109 const char* const VSYNC_BUTTON_TEXT = "Vsync";
 110
 111 const char* const FREQUENCY_1_RADIO_TEXT = "1";
 112 const char* const FREQUENCY_2_RADIO_TEXT = "2";
 113 const char* const FREQUENCY_3_RADIO_TEXT = "10";
 114
 115 const char* const LOGGER_TEXT = "Logger:";
 116 const char* const FREQUENCY_TEXT = "Frequency (sec):";
 117
 118 const unsigned int NUM_LOGGERS = 3;
 119
 120 const unsigned int HIGH_FREQUENCY = 1;   // Seconds
 121 const unsigned int MEDIUM_FREQUENCY = 2;   // Seconds
 122 const unsigned int LOW_FREQUENCY = 10;   // Seconds
 123 const unsigned int NUM_FREQUENCIES = 3;
 124
 125 }  // namespace
 126
 127 /**
 128  * This example is a test harness for performance loggers.
 129  *
 130  * Press one of the create buttons to create a logger. This will output on vsync at the default frequency (2 seconds).
 131  * In case nothing appears in the log, force a vsync by touching anywhere on the screen. Loggers can be deleted
 132  * with the delete buttons. They can be enabled or disabled in which case logging will appear or disappear in the console
 133  * respectively. To record information in a logger press the start and then stop button in succession quickly in between
 134  * the time period when it would print to the console. This is necessary as the logger is cleared of information when
 135  * it prints. The output will contain the smallest and largest times between start and stop recorded (minimum and maximum),
 136  * the total time recorded by the logger as well as the average and standard deviation of all the times recorded. The
 137  * frequency of log output can be set to high frequency (every 1 second) or low frequency (every 10 seconds).
 138  */
 139 class LoggingController: public ConnectionTracker
 140 {
 141  public:
 142
 143   LoggingController( Application& application )
 144     : mApplication( application )
 145   {
 146     // Connect to the Application's Init signal
 147     mApplication.InitSignal().Connect( this, &LoggingController::Create );
 148   }
 149
 150   ~LoggingController()
 151   {
 152     // Nothing to do here
 153   }
 154
 155   void Create( Application& application )
 156   {
 157     // The Init signal is received once (only) during the Application lifetime
 158
 159     mCurrentLogger = 0;
 160     mPerformanceLoggers.reserve( NUM_LOGGERS );
 161     mPerformanceLoggers.resize( NUM_LOGGERS );
 162
 163     mPerformanceLoggerNames.reserve( NUM_LOGGERS );
 164     mPerformanceLoggerNames.resize( NUM_LOGGERS );
 165
 166     mLoggerStates.reserve( NUM_LOGGERS );
 167     mLoggerStates.resize( NUM_LOGGERS );
 168
 169     mLogRadioButtons.reserve( NUM_LOGGERS );
 170     mLogRadioButtons.resize( NUM_LOGGERS );
 171
 172     mFrequencyRadioButtons.reserve( NUM_FREQUENCIES );
 173     mFrequencyRadioButtons.resize( NUM_FREQUENCIES );
 174
 175     // Respond to key events
 176     Stage::GetCurrent().KeyEventSignal().Connect(this, &LoggingController::OnKeyEvent);
 177
 178     // Creates a default view with a default tool bar.
 179     // The view is added to the stage.
 180     mContentLayer = DemoHelper::CreateView( application,
 181                                             mView,
 182                                             mToolBar,
 183                                             BACKGROUND_IMAGE,
 184                                             TOOLBAR_IMAGE,
 185                                             TOOLBAR_TITLE );
 186
 187     Vector2 stageSize = Stage::GetCurrent().GetSize();
 188
 189     int yPos = TOP_MARGIN + MARGIN_SIZE;
 190
 191     // Logger selector radio group
 192     Actor radioGroupBackground = Toolkit::CreateSolidColorActor( BACKGROUND_COLOUR );
 193     radioGroupBackground.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 194     radioGroupBackground.SetParentOrigin( ParentOrigin::TOP_LEFT );
 195     radioGroupBackground.SetPosition( DP(MARGIN_SIZE), DP(yPos) );
 196     radioGroupBackground.SetSize( stageSize.width - 2 * DP(MARGIN_SIZE), DP(LOGGER_RADIO_GROUP_HEIGHT) );
 197     mContentLayer.Add( radioGroupBackground );
 198
 199     // Radio group
 200     Actor radioButtonsGroup = Actor::New();
 201     radioButtonsGroup.SetParentOrigin( ParentOrigin::TOP_LEFT );
 202     radioButtonsGroup.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 203     radioButtonsGroup.SetPosition( DP(MARGIN_SIZE), 0 );
 204
 205     radioGroupBackground.Add( radioButtonsGroup );
 206
 207     int radioX = 0;
 208     int radioY = MARGIN_SIZE + 28;
 209
 210     // Radio 1
 211     {
 212       Toolkit::RadioButton radioButton = Toolkit::RadioButton::New();
 213       radioButton.SetName( LOGGER_1_RADIO_ID );
 214       radioButton.SetParentOrigin( ParentOrigin::TOP_LEFT );
 215       radioButton.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 216       radioButton.SetPosition( DP(radioX), DP(radioY) );
 217       radioButton.SetSelected( true );
 218
 219       radioButton.StateChangedSignal().Connect( this, &LoggingController::LoggingRadioSelect );
 220
 221       radioButtonsGroup.Add( radioButton );
 222       mLogRadioButtons[0] = radioButton;
 223     }
 224
 225     // Radio 2
 226     {
 227       radioY += LOGGER_RADIO_SPACING;
 228
 229       Toolkit::RadioButton radioButton = Toolkit::RadioButton::New();
 230       radioButton.SetName( LOGGER_2_RADIO_ID );
 231       radioButton.SetParentOrigin( ParentOrigin::TOP_LEFT );
 232       radioButton.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 233       radioButton.SetPosition( DP(radioX), DP(radioY) );
 234
 235       radioButton.StateChangedSignal().Connect( this, &LoggingController::LoggingRadioSelect );
 236
 237       radioButtonsGroup.Add( radioButton );
 238       mLogRadioButtons[1] = radioButton;
 239     }
 240
 241     // Radio 3
 242     {
 243       radioY += LOGGER_RADIO_SPACING;
 244
 245       Toolkit::RadioButton radioButton = Toolkit::RadioButton::New();
 246       radioButton.SetName( LOGGER_3_RADIO_ID );
 247       radioButton.SetParentOrigin( ParentOrigin::TOP_LEFT );
 248       radioButton.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 249       radioButton.SetPosition( DP(radioX), DP(radioY) );
 250
 251       radioButton.StateChangedSignal().Connect( this, &LoggingController::LoggingRadioSelect );
 252
 253       radioButtonsGroup.Add( radioButton );
 254       mLogRadioButtons[2] = radioButton;
 255     }
 256
 257     // Create/delete/disable group
 258     yPos += LOGGER_RADIO_GROUP_HEIGHT + MARGIN_SIZE;
 259
 260     Actor createGroupBackground = Toolkit::CreateSolidColorActor( BACKGROUND_COLOUR );
 261     createGroupBackground.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 262     createGroupBackground.SetParentOrigin( ParentOrigin::TOP_LEFT );
 263     createGroupBackground.SetPosition( DP(MARGIN_SIZE), DP(yPos) );
 264     createGroupBackground.SetSize( stageSize.width - 2 * DP(MARGIN_SIZE), DP(LOGGER_GROUP_HEIGHT) );
 265     mContentLayer.Add( createGroupBackground );
 266
 267     int buttonXDP = DP(MARGIN_SIZE);
 268     int buttonWidthDP = (createGroupBackground.GetSize().width - DP(MARGIN_SIZE) * 3) / 2;
 269
 270     {
 271       Toolkit::PushButton button = Toolkit::PushButton::New();
 272       button.SetName( CREATE_BUTTON_ID );
 273       button.SetLabel( CREATE_BUTTON_TEXT );
 274       button.SetParentOrigin( ParentOrigin::CENTER_LEFT );
 275       button.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
 276       button.SetPosition( buttonXDP, 0 );
 277       button.SetSize( buttonWidthDP, DP(BUTTON_HEIGHT) );
 278
 279       button.SetSelectedImage( Dali::ResourceImage::New( PUSHBUTTON_PRESS_IMAGE ) );
 280       button.SetButtonImage( Dali::ResourceImage::New( PUSHBUTTON_BUTTON_IMAGE ) );
 281       button.SetDisabledImage( Dali::ResourceImage::New( PUSHBUTTON_DISABLED_IMAGE ) );
 282
 283       button.ClickedSignal().Connect( this, &LoggingController::OnButtonClicked );
 284
 285       createGroupBackground.Add( button );
 286     }
 287
 288     {
 289       buttonXDP += DP(MARGIN_SIZE) + buttonWidthDP;
 290
 291       Toolkit::PushButton button = Toolkit::PushButton::New();
 292       button.SetName( DELETE_BUTTON_ID );
 293       button.SetLabel( DELETE_BUTTON_TEXT );
 294       button.SetParentOrigin( ParentOrigin::CENTER_LEFT );
 295       button.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
 296       button.SetPosition( buttonXDP, 0 );
 297       button.SetSize( buttonWidthDP, DP(BUTTON_HEIGHT) );
 298
 299       button.SetSelectedImage( Dali::ResourceImage::New( PUSHBUTTON_PRESS_IMAGE ) );
 300       button.SetButtonImage( Dali::ResourceImage::New( PUSHBUTTON_BUTTON_IMAGE ) );
 301       button.SetDisabledImage( Dali::ResourceImage::New( PUSHBUTTON_DISABLED_IMAGE ) );
 302
 303       button.ClickedSignal().Connect( this, &LoggingController::OnButtonClicked );
 304
 305       createGroupBackground.Add( button );
 306     }
 307
 308     // Start/stop group
 309     yPos += LOGGER_GROUP_HEIGHT + MARGIN_SIZE;
 310
 311     Actor timingGroupBackground = Toolkit::CreateSolidColorActor( BACKGROUND_COLOUR );
 312     timingGroupBackground.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 313     timingGroupBackground.SetParentOrigin( ParentOrigin::TOP_LEFT );
 314     timingGroupBackground.SetPosition( DP(MARGIN_SIZE), DP(yPos) );
 315     timingGroupBackground.SetSize( stageSize.width - 2 * DP(MARGIN_SIZE), DP(LOGGER_GROUP_HEIGHT) );
 316     mContentLayer.Add( timingGroupBackground );
 317
 318     buttonXDP = DP(MARGIN_SIZE);
 319     buttonWidthDP = (timingGroupBackground.GetSize().width - DP(MARGIN_SIZE) * 3) / 2;
 320
 321     {
 322       Toolkit::PushButton button = Toolkit::PushButton::New();
 323       button.SetName( START_BUTTON_ID );
 324       button.SetLabel( START_BUTTON_TEXT );
 325       button.SetParentOrigin( ParentOrigin::CENTER_LEFT );
 326       button.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
 327       button.SetPosition( buttonXDP, 0 );
 328       button.SetSize( buttonWidthDP, DP(BUTTON_HEIGHT) );
 329
 330       button.SetSelectedImage( Dali::ResourceImage::New( PUSHBUTTON_PRESS_IMAGE ) );
 331       button.SetButtonImage( Dali::ResourceImage::New( PUSHBUTTON_BUTTON_IMAGE ) );
 332       button.SetDisabledImage( Dali::ResourceImage::New( PUSHBUTTON_DISABLED_IMAGE ) );
 333
 334       button.ClickedSignal().Connect( this, &LoggingController::OnButtonClicked );
 335
 336       timingGroupBackground.Add( button );
 337     }
 338
 339     {
 340       buttonXDP += DP(MARGIN_SIZE) + buttonWidthDP;
 341
 342       Toolkit::PushButton button = Toolkit::PushButton::New();
 343       button.SetName( STOP_BUTTON_ID );
 344       button.SetLabel( STOP_BUTTON_TEXT );
 345       button.SetParentOrigin( ParentOrigin::CENTER_LEFT );
 346       button.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
 347       button.SetPosition( buttonXDP, 0 );
 348       button.SetSize( buttonWidthDP, DP(BUTTON_HEIGHT) );
 349
 350       button.SetSelectedImage( Dali::ResourceImage::New( PUSHBUTTON_PRESS_IMAGE ) );
 351       button.SetButtonImage( Dali::ResourceImage::New( PUSHBUTTON_BUTTON_IMAGE ) );
 352       button.SetDisabledImage( Dali::ResourceImage::New( PUSHBUTTON_DISABLED_IMAGE ) );
 353
 354       button.ClickedSignal().Connect( this, &LoggingController::OnButtonClicked );
 355
 356       timingGroupBackground.Add( button );
 357     }
 358
 359     // Enable/disable group
 360     yPos += LOGGER_GROUP_HEIGHT + MARGIN_SIZE;
 361
 362     Actor enableGroupBackground = Toolkit::CreateSolidColorActor( BACKGROUND_COLOUR );
 363     enableGroupBackground.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 364     enableGroupBackground.SetParentOrigin( ParentOrigin::TOP_LEFT );
 365     enableGroupBackground.SetPosition( DP(MARGIN_SIZE), DP(yPos) );
 366     enableGroupBackground.SetSize( stageSize.width - 2 * DP(MARGIN_SIZE), DP(LOGGER_GROUP_HEIGHT) );
 367     mContentLayer.Add( enableGroupBackground );
 368
 369     buttonXDP = DP(MARGIN_SIZE);
 370     buttonWidthDP = (enableGroupBackground.GetSize().width - DP(MARGIN_SIZE) * 3) / 2;
 371
 372     {
 373       Toolkit::PushButton button = Toolkit::PushButton::New();
 374       button.SetName( ENABLE_BUTTON_ID );
 375       button.SetLabel( ENABLE_BUTTON_TEXT );
 376       button.SetParentOrigin( ParentOrigin::CENTER_LEFT );
 377       button.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
 378       button.SetPosition( buttonXDP, 0 );
 379       button.SetSize( buttonWidthDP, DP(BUTTON_HEIGHT) );
 380
 381       button.SetSelectedImage( Dali::ResourceImage::New( PUSHBUTTON_PRESS_IMAGE ) );
 382       button.SetButtonImage( Dali::ResourceImage::New( PUSHBUTTON_BUTTON_IMAGE ) );
 383       button.SetDisabledImage( Dali::ResourceImage::New( PUSHBUTTON_DISABLED_IMAGE ) );
 384
 385       button.ClickedSignal().Connect( this, &LoggingController::OnButtonClicked );
 386
 387       enableGroupBackground.Add( button );
 388     }
 389
 390     {
 391       buttonXDP += DP(MARGIN_SIZE) + buttonWidthDP;
 392
 393       Toolkit::PushButton button = Toolkit::PushButton::New();
 394       button.SetName( DISABLE_BUTTON_ID );
 395       button.SetLabel( DISABLE_BUTTON_TEXT );
 396       button.SetParentOrigin( ParentOrigin::CENTER_LEFT );
 397       button.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
 398       button.SetPosition( buttonXDP, 0 );
 399       button.SetSize( buttonWidthDP, DP(BUTTON_HEIGHT) );
 400
 401       button.SetSelectedImage( Dali::ResourceImage::New( PUSHBUTTON_PRESS_IMAGE ) );
 402       button.SetButtonImage( Dali::ResourceImage::New( PUSHBUTTON_BUTTON_IMAGE ) );
 403       button.SetDisabledImage( Dali::ResourceImage::New( PUSHBUTTON_DISABLED_IMAGE ) );
 404
 405       button.ClickedSignal().Connect( this, &LoggingController::OnButtonClicked );
 406
 407       enableGroupBackground.Add( button );
 408     }
 409
 410     yPos += LOGGER_GROUP_HEIGHT + MARGIN_SIZE;
 411
 412     // Logger selector radio group
 413     unsigned int groupHeight = LOGGER_GROUP_HEIGHT + 30;
 414
 415     Actor frequencyRadioGroupBackground = Toolkit::CreateSolidColorActor( BACKGROUND_COLOUR );
 416     frequencyRadioGroupBackground.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 417     frequencyRadioGroupBackground.SetParentOrigin( ParentOrigin::TOP_LEFT );
 418     frequencyRadioGroupBackground.SetPosition( DP(MARGIN_SIZE), DP(yPos) );
 419     frequencyRadioGroupBackground.SetSize( stageSize.width - 2 * DP(MARGIN_SIZE), DP(groupHeight) );
 420     mContentLayer.Add( frequencyRadioGroupBackground );
 421
 422     // Radio group
 423     Actor frequencyRadioButtonsGroup = Actor::New();
 424     frequencyRadioButtonsGroup.SetParentOrigin( ParentOrigin::TOP_LEFT );
 425     frequencyRadioButtonsGroup.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 426     frequencyRadioButtonsGroup.SetPosition( DP(MARGIN_SIZE), DP(40) );
 427
 428     frequencyRadioGroupBackground.Add( frequencyRadioButtonsGroup );
 429
 430     radioX = 0;
 431     radioY = 0;
 432     const int frequencyRadioWidth = 100;
 433
 434     // Radio 1
 435     {
 436       Toolkit::RadioButton radioButton = Toolkit::RadioButton::New( FREQUENCY_1_RADIO_TEXT );
 437       radioButton.SetName( FREQUENCY_1_RADIO_ID );
 438       radioButton.SetParentOrigin( ParentOrigin::TOP_LEFT );
 439       radioButton.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 440       radioButton.SetPosition( DP(radioX), DP(radioY) );
 441
 442       radioButton.StateChangedSignal().Connect( this, &LoggingController::FrequencyRadioSelect );
 443
 444       frequencyRadioButtonsGroup.Add( radioButton );
 445       mFrequencyRadioButtons[0] = radioButton;
 446     }
 447
 448     // Radio 2
 449     {
 450       radioX += frequencyRadioWidth;
 451
 452       Toolkit::RadioButton radioButton = Toolkit::RadioButton::New( FREQUENCY_2_RADIO_TEXT );
 453       radioButton.SetName( FREQUENCY_2_RADIO_ID );
 454       radioButton.SetParentOrigin( ParentOrigin::TOP_LEFT );
 455       radioButton.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 456       radioButton.SetPosition( DP(radioX), DP(radioY) );
 457       radioButton.SetSelected( true );
 458
 459       radioButton.StateChangedSignal().Connect( this, &LoggingController::FrequencyRadioSelect );
 460
 461       frequencyRadioButtonsGroup.Add( radioButton );
 462       mFrequencyRadioButtons[1] = radioButton;
 463     }
 464
 465     // Radio 3
 466     {
 467       radioX += frequencyRadioWidth;
 468
 469       Toolkit::RadioButton radioButton = Toolkit::RadioButton::New( FREQUENCY_3_RADIO_TEXT );
 470       radioButton.SetName( FREQUENCY_3_RADIO_ID );
 471       radioButton.SetParentOrigin( ParentOrigin::TOP_LEFT );
 472       radioButton.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 473       radioButton.SetPosition( DP(radioX), DP(radioY) );
 474
 475       radioButton.StateChangedSignal().Connect( this, &LoggingController::FrequencyRadioSelect );
 476
 477       frequencyRadioButtonsGroup.Add( radioButton );
 478       mFrequencyRadioButtons[2] = radioButton;
 479     }
 480
 481     // Vsync group
 482     yPos += groupHeight + MARGIN_SIZE;
 483
 484     Actor vsyncGroupBackground = Toolkit::CreateSolidColorActor( BACKGROUND_COLOUR );
 485     vsyncGroupBackground.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 486     vsyncGroupBackground.SetParentOrigin( ParentOrigin::TOP_LEFT );
 487     vsyncGroupBackground.SetPosition( DP(MARGIN_SIZE), DP(yPos) );
 488     vsyncGroupBackground.SetSize( stageSize.width - 2 * DP(MARGIN_SIZE), DP(LOGGER_GROUP_HEIGHT) );
 489     mContentLayer.Add( vsyncGroupBackground );
 490
 491     buttonXDP = DP(MARGIN_SIZE);
 492     buttonWidthDP = vsyncGroupBackground.GetSize().width - DP(MARGIN_SIZE) * 2;
 493
 494     {
 495       Toolkit::PushButton button = Toolkit::PushButton::New();
 496       button.SetName( VSYNC_BUTTON_ID );
 497       button.SetLabel( VSYNC_BUTTON_TEXT );
 498       button.SetParentOrigin( ParentOrigin::CENTER_LEFT );
 499       button.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
 500       button.SetPosition( buttonXDP, 0 );
 501       button.SetSize( buttonWidthDP, DP(BUTTON_HEIGHT) );
 502
 503       button.SetSelectedImage( Dali::ResourceImage::New( PUSHBUTTON_PRESS_IMAGE ) );
 504       button.SetButtonImage( Dali::ResourceImage::New( PUSHBUTTON_BUTTON_IMAGE ) );
 505       button.SetDisabledImage( Dali::ResourceImage::New( PUSHBUTTON_DISABLED_IMAGE ) );
 506
 507       button.ClickedSignal().Connect( this, &LoggingController::OnButtonClicked );
 508
 509       vsyncGroupBackground.Add( button );
 510     }
 511
 512     WriteConsole();
 513   }
 514
 515   void WriteConsole()
 516   {
 517     // TODO
 518   }
 519
 520   bool LoggingRadioSelect( Toolkit::Button button )
 521   {
 522     if( button.GetName() == LOGGER_1_RADIO_ID && button.IsSelected() == true )
 523     {
 524       mCurrentLogger = 0;
 525     }
 526     else if( button.GetName() == LOGGER_2_RADIO_ID && button.IsSelected() == true )
 527     {
 528       mCurrentLogger = 1;
 529     }
 530     else if( button.GetName() == LOGGER_3_RADIO_ID && button.IsSelected() == true )
 531     {
 532       mCurrentLogger = 2;
 533     }
 534
 535     UpdateState();
 536
 537     return true;
 538   }
 539
 540   void UpdateState()
 541   {
 542     DALI_ASSERT_DEBUG( mCurrentLogger < mLoggerStates.size() );
 543     const unsigned int frequency = mLoggerStates[mCurrentLogger].frequency;
 544     if( frequency == HIGH_FREQUENCY )
 545     {
 546       mFrequencyRadioButtons[0].SetSelected( true );
 547     }
 548     else if( frequency == MEDIUM_FREQUENCY )
 549     {
 550       mFrequencyRadioButtons[1].SetSelected( true );
 551     }
 552     else if( frequency == LOW_FREQUENCY )
 553     {
 554       mFrequencyRadioButtons[2].SetSelected( true );
 555     }
 556   }
 557
 558   bool FrequencyRadioSelect( Toolkit::Button button )
 559   {
 560     if( button.GetName() == FREQUENCY_1_RADIO_ID && button.IsSelected() == true )
 561     {
 562       if( mPerformanceLoggers[mCurrentLogger] )
 563       {
 564         DALI_ASSERT_DEBUG( mCurrentLogger < mPerformanceLoggers.size() );
 565         mPerformanceLoggers[mCurrentLogger].SetLoggingFrequency( HIGH_FREQUENCY );
 566
 567         DALI_ASSERT_DEBUG( mCurrentLogger < mLoggerStates.size() );
 568         mLoggerStates[mCurrentLogger].frequency = HIGH_FREQUENCY;
 569       }
 570     }
 571     else if( button.GetName() == FREQUENCY_2_RADIO_ID && button.IsSelected() == true )
 572     {
 573       if( mPerformanceLoggers[mCurrentLogger] )
 574       {
 575         DALI_ASSERT_DEBUG( mCurrentLogger < mPerformanceLoggers.size() );
 576         mPerformanceLoggers[mCurrentLogger].SetLoggingFrequency( MEDIUM_FREQUENCY );
 577
 578         DALI_ASSERT_DEBUG( mCurrentLogger < mLoggerStates.size() );
 579         mLoggerStates[mCurrentLogger].frequency = MEDIUM_FREQUENCY;
 580       }
 581     }
 582     else if( button.GetName() == FREQUENCY_3_RADIO_ID && button.IsSelected() == true )
 583     {
 584       if( mPerformanceLoggers[mCurrentLogger] )
 585       {
 586         DALI_ASSERT_DEBUG( mCurrentLogger < mPerformanceLoggers.size() );
 587         mPerformanceLoggers[mCurrentLogger].SetLoggingFrequency( LOW_FREQUENCY );
 588
 589         DALI_ASSERT_DEBUG( mCurrentLogger < mLoggerStates.size() );
 590         mLoggerStates[mCurrentLogger].frequency = LOW_FREQUENCY;
 591       }
 592     }
 593
 594     return true;
 595   }
 596
 597   void OnKeyEvent( const KeyEvent& event )
 598   {
 599     if( event.state == KeyEvent::Down )
 600     {
 601       if( IsKey( event, Dali::DALI_KEY_ESCAPE ) || IsKey( event, Dali::DALI_KEY_BACK ) )
 602       {
 603         // Exit application when click back or escape.
 604         mApplication.Quit();
 605       }
 606     }
 607   }
 608
 609   bool OnButtonClicked(Toolkit::Button button)
 610   {
 611     if( button.GetName() == CREATE_BUTTON_ID )
 612     {
 613       std::stringstream ss;
 614       ss << "Test logger " << (mCurrentLogger + 1);
 615
 616       DALI_ASSERT_DEBUG( mCurrentLogger < mPerformanceLoggerNames.size() );
 617       mPerformanceLoggerNames[mCurrentLogger] = ss.str();
 618
 619       DALI_ASSERT_DEBUG( mCurrentLogger < mPerformanceLoggers.size() );
 620       mPerformanceLoggers[mCurrentLogger] = Dali::PerformanceLogger::New( mPerformanceLoggerNames[mCurrentLogger].c_str() );
 621
 622       DALI_ASSERT_DEBUG( mCurrentLogger < mLoggerStates.size() );
 623       mLoggerStates[mCurrentLogger].isTiming = false;
 624       mLoggerStates[mCurrentLogger].isEnabled = true;
 625       mLoggerStates[mCurrentLogger].frequency = MEDIUM_FREQUENCY;
 626
 627       UpdateState();
 628     }
 629     else if ( button.GetName() == DELETE_BUTTON_ID )
 630     {
 631       DALI_ASSERT_DEBUG( mCurrentLogger < mPerformanceLoggers.size() );
 632       mPerformanceLoggers[mCurrentLogger].Reset();
 633
 634       DALI_ASSERT_DEBUG( mCurrentLogger < mLoggerStates.size() );
 635       mLoggerStates[mCurrentLogger].isTiming = false;
 636       mLoggerStates[mCurrentLogger].isEnabled = true;
 637       mLoggerStates[mCurrentLogger].frequency = MEDIUM_FREQUENCY;
 638
 639       UpdateState();
 640     }
 641     else if ( button.GetName() == START_BUTTON_ID )
 642     {
 643       if( mPerformanceLoggers[mCurrentLogger] )
 644       {
 645         DALI_ASSERT_DEBUG( mCurrentLogger < mPerformanceLoggers.size() );
 646         mPerformanceLoggers[mCurrentLogger].AddMarker( Dali::PerformanceLogger::START_EVENT );
 647
 648         DALI_ASSERT_DEBUG( mCurrentLogger < mLoggerStates.size() );
 649         mLoggerStates[mCurrentLogger].isTiming = true;
 650       }
 651     }
 652     else if ( button.GetName() == STOP_BUTTON_ID )
 653     {
 654       if( mPerformanceLoggers[mCurrentLogger] )
 655       {
 656         DALI_ASSERT_DEBUG( mCurrentLogger < mPerformanceLoggers.size() );
 657         mPerformanceLoggers[mCurrentLogger].AddMarker( Dali::PerformanceLogger::END_EVENT );
 658
 659         DALI_ASSERT_DEBUG( mCurrentLogger < mLoggerStates.size() );
 660         mLoggerStates[mCurrentLogger].isTiming = false;
 661       }
 662     }
 663     else if ( button.GetName() == ENABLE_BUTTON_ID )
 664     {
 665       if( mPerformanceLoggers[mCurrentLogger] )
 666       {
 667         DALI_ASSERT_DEBUG( mCurrentLogger < mPerformanceLoggers.size() );
 668         mPerformanceLoggers[mCurrentLogger].EnableLogging( true );
 669
 670         DALI_ASSERT_DEBUG( mCurrentLogger < mLoggerStates.size() );
 671         mLoggerStates[mCurrentLogger].isEnabled = true;
 672       }
 673     }
 674     else if ( button.GetName() == DISABLE_BUTTON_ID )
 675     {
 676       if( mPerformanceLoggers[mCurrentLogger] )
 677       {
 678         DALI_ASSERT_DEBUG( mCurrentLogger < mPerformanceLoggers.size() );
 679         mPerformanceLoggers[mCurrentLogger].EnableLogging( false );
 680
 681         DALI_ASSERT_DEBUG( mCurrentLogger < mLoggerStates.size() );
 682         mLoggerStates[mCurrentLogger].isEnabled = false;
 683       }
 684     }
 685
 686     WriteConsole();
 687
 688     return true;
 689   }
 690
 691  private:
 692
 693   struct LoggerState
 694   {
 695     LoggerState() : frequency( 0 ), isTiming( false ), isEnabled( true ) {}
 696
 697     unsigned int frequency;
 698     bool isTiming;
 699     bool isEnabled;
 700   };
 701
 702   Application&      mApplication;
 703   Toolkit::View     mView;                   ///< The View instance.
 704   Toolkit::ToolBar  mToolBar;                ///< The View's Toolbar.
 705   Layer             mContentLayer;           ///< Content layer
 706
 707   typedef std::vector< std::string > Strings;
 708   Strings mPerformanceLoggerNames;
 709
 710   typedef std::vector< Dali::PerformanceLogger > PerformanceLoggers;
 711   PerformanceLoggers mPerformanceLoggers;
 712   unsigned int mCurrentLogger;
 713
 714   typedef std::vector< LoggerState > LoggerStates;
 715   LoggerStates mLoggerStates;
 716
 717   typedef std::vector< Toolkit::RadioButton > RadioButtons;
 718   RadioButtons mLogRadioButtons;
 719   RadioButtons mFrequencyRadioButtons;
 720 };
 721
 722 void RunTest( Application& application )
 723 {
 724   LoggingController test( application );
 725
 726   application.MainLoop();
 727 }
 728
 729 // Entry point for Linux & SLP applications
 730 //
 731 int main( int argc, char **argv )
 732 {
 733   Application application = Application::New( &argc, &argv );
 734
 735   RunTest( application );
 736
 737   return 0;
 738 }