examples/radial-menu/radial-menu-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 <dali/dali.h>
  19 #include <dali-toolkit/dali-toolkit.h>
  20 #include "shared/view.h"
  21 #include "radial-sweep-view.h"
  22 #include "radial-sweep-view-impl.h"
  23
  24 using namespace Dali;
  25 using namespace Dali::Toolkit;
  26
  27 namespace
  28 {
  29 const char* TEST_OUTER_RING_FILENAME = DALI_IMAGE_DIR "layer2.png"; // Image to be masked
  30 const char* TEST_INNER_RING_FILENAME = DALI_IMAGE_DIR "layer1.png"; // Image to be masked
  31 const char* TEST_MENU_FILENAME = DALI_IMAGE_DIR "layer3.png"; // Image to be masked
  32 const char* TEST_DIAL_FILENAME = DALI_IMAGE_DIR "layer4.png"; // Image to be masked
  33 const char* TOOLBAR_IMAGE( DALI_IMAGE_DIR "top-bar.png" ); // Background for toolbar
  34 const char* APPLICATION_TITLE( "Radial Menu" );
  35 const char * const PLAY_ICON( DALI_IMAGE_DIR "icon-play.png" );
  36 const char * const STOP_ICON( DALI_IMAGE_DIR "icon-stop.png" );
  37 }
  38
  39
  40 /********************************************************************************
  41  * Application controller class
  42  */
  43
  44 // This example shows how to create a mesh actor for use as a stencil buffer
  45 class RadialMenuExample : public ConnectionTracker
  46 {
  47 public:
  48   /**
  49    * Constructor
  50    * @param[in] app The application handle
  51    */
  52   RadialMenuExample(Application app);
  53
  54   /**
  55    * Destructor
  56    */
  57   ~RadialMenuExample();
  58
  59 private:
  60
  61   /**
  62    * Initialization signal handler - all actor initialization should happen here
  63    * @param[in] app The application handle
  64    */
  65   void OnInit(Application& app);
  66
  67   /**
  68    * Create a sweep view with the given image and parameters
  69    */
  70   RadialSweepView CreateSweepView( std::string imageName, Degree initial, Degree final );
  71
  72   void StartAnimation();
  73
  74   bool OnButtonClicked( Toolkit::Button button );
  75
  76   void OnAnimationFinished( Animation& source );
  77
  78   /**
  79    * Main key event handler
  80    *
  81    * @param[in] event The key event to respond to
  82    */
  83   void OnKeyEvent(const KeyEvent& event);
  84
  85 private: // Member variables
  86   enum AnimState
  87   {
  88     STOPPED,
  89     PAUSED,
  90     PLAYING
  91   };
  92
  93   Application     mApplication; ///< The application handle
  94   Toolkit::View   mView;        ///< The toolbar view
  95   Layer           mContents;    ///< The toolbar contents pane
  96   ImageActor      mImageActor;  ///< Image actor shown by stencil mask
  97   Animation       mAnimation;
  98   AnimState       mAnimationState;
  99
 100   Image               mIconPlay;
 101   Image               mIconStop;
 102   Toolkit::PushButton mPlayStopButton;
 103   ImageActor      mDialActor;
 104   RadialSweepView mRadialSweepView1;
 105   RadialSweepView mRadialSweepView2;
 106   RadialSweepView mRadialSweepView3;
 107 };
 108
 109 RadialMenuExample::RadialMenuExample(Application app)
 110 : mApplication( app ),
 111   mAnimationState(STOPPED)
 112 {
 113   // Connect to the Application's Init signal
 114   app.InitSignal().Connect(this, &RadialMenuExample::OnInit);
 115 }
 116
 117 RadialMenuExample::~RadialMenuExample()
 118 {
 119   // Nothing to do here; actor handles will clean up themselves.
 120 }
 121
 122 void RadialMenuExample::OnInit(Application& app)
 123 {
 124   DemoHelper::RequestThemeChange();
 125
 126   Stage stage = Dali::Stage::GetCurrent();
 127
 128   // The Init signal is received once (only) during the Application lifetime
 129   stage.KeyEventSignal().Connect(this, &RadialMenuExample::OnKeyEvent);
 130
 131   // Create toolbar & view
 132   Toolkit::ToolBar toolBar;
 133   mContents = DemoHelper::CreateView( mApplication,
 134                                       mView,
 135                                       toolBar,
 136                                       "",
 137                                       TOOLBAR_IMAGE,
 138                                       APPLICATION_TITLE );
 139
 140   mIconPlay = ResourceImage::New( PLAY_ICON );
 141   mIconStop = ResourceImage::New( STOP_ICON );
 142   mPlayStopButton = Toolkit::PushButton::New();
 143   mPlayStopButton.SetBackgroundImage( mIconStop );
 144
 145   mPlayStopButton.ClickedSignal().Connect( this, &RadialMenuExample::OnButtonClicked );
 146
 147   toolBar.AddControl( mPlayStopButton,
 148                       DemoHelper::DEFAULT_VIEW_STYLE.mToolBarButtonPercentage,
 149                       Toolkit::Alignment::HorizontalRight,
 150                       DemoHelper::DEFAULT_PLAY_PADDING );
 151
 152   Vector2 imgSize = ResourceImage::GetImageSize(TEST_OUTER_RING_FILENAME);
 153   Vector2 stageSize = stage.GetSize();
 154   float minStageDimension = std::min(stageSize.width, stageSize.height);
 155
 156   if(stageSize.height <= stageSize.width)
 157   {
 158     minStageDimension -= DemoHelper::DEFAULT_VIEW_STYLE.mToolBarHeight * 2.0f;
 159   }
 160   float scale = minStageDimension / imgSize.width;
 161
 162   mRadialSweepView1 = CreateSweepView( TEST_OUTER_RING_FILENAME, Degree(-90.0f), Degree(-90.0f));
 163   mRadialSweepView2 = CreateSweepView( TEST_INNER_RING_FILENAME, Degree(90.0f),  Degree(0.0f));
 164   mRadialSweepView3 = CreateSweepView( TEST_MENU_FILENAME, Degree(100.0f), Degree(0.0f));
 165   mRadialSweepView3.SetInitialActorAngle(Degree(-110));
 166   mRadialSweepView3.SetFinalActorAngle(Degree(0));
 167
 168   Image dial = ResourceImage::New( TEST_DIAL_FILENAME );
 169   mDialActor = ImageActor::New( dial );
 170   mDialActor.SetPositionInheritanceMode(USE_PARENT_POSITION);
 171   mDialActor.SetScale(scale);
 172   Layer dialLayer = Layer::New();
 173
 174   dialLayer.Add(mDialActor);
 175   dialLayer.SetPositionInheritanceMode(USE_PARENT_POSITION);
 176   dialLayer.SetSize(stage.GetSize());
 177   mContents.Add(dialLayer);
 178
 179   mRadialSweepView1.SetScale(scale);
 180   mRadialSweepView2.SetScale(scale);
 181   mRadialSweepView3.SetScale(scale);
 182
 183   StartAnimation();
 184 }
 185
 186 void RadialMenuExample::StartAnimation()
 187 {
 188   mDialActor.SetOpacity(0.0f);
 189   mRadialSweepView1.SetOpacity(0.0f);
 190   mAnimation = Animation::New(6.0f);
 191   mRadialSweepView1.Activate(mAnimation, 0.0f, 3.0f);
 192   mRadialSweepView2.Activate(mAnimation, 1.5f, 3.0f);
 193   mRadialSweepView3.Activate(mAnimation, 3.0f, 3.0f);
 194   mAnimation.OpacityTo(mDialActor, 1.0f, AlphaFunctions::EaseIn, 0.0f, 0.8f);
 195   mAnimation.OpacityTo(mRadialSweepView1, 1.0f, AlphaFunctions::EaseIn, 0.0f, 0.5f);
 196   mAnimation.FinishedSignal().Connect( this, &RadialMenuExample::OnAnimationFinished );
 197
 198   mAnimationState = PLAYING;
 199   mAnimation.Play();
 200 }
 201
 202 bool RadialMenuExample::OnButtonClicked( Toolkit::Button button )
 203 {
 204   switch( mAnimationState )
 205   {
 206     case PLAYING:
 207     {
 208       mAnimation.Pause();
 209       mPlayStopButton.SetBackgroundImage( mIconPlay );
 210     }
 211     break;
 212
 213     case PAUSED:
 214     {
 215       mAnimation.Play();
 216       mPlayStopButton.SetBackgroundImage( mIconStop );
 217     }
 218     break;
 219
 220     case STOPPED:
 221     {
 222       mPlayStopButton.SetBackgroundImage( mIconStop );
 223       mRadialSweepView1.Deactivate();
 224       mRadialSweepView2.Deactivate();
 225       mRadialSweepView3.Deactivate();
 226       StartAnimation();
 227     }
 228   }
 229   return false;
 230 }
 231
 232 void RadialMenuExample::OnAnimationFinished( Animation& source )
 233 {
 234   mAnimationState = STOPPED;
 235   mPlayStopButton.SetBackgroundImage( mIconPlay );
 236 }
 237
 238 RadialSweepView RadialMenuExample::CreateSweepView( std::string imageName,
 239                                                     Degree initialAngle,
 240                                                     Degree finalAngle)
 241 {
 242   // Create the image
 243   Image image = ResourceImage::New(imageName);
 244   mImageActor = ImageActor::New(image);
 245   mImageActor.SetParentOrigin(ParentOrigin::CENTER);
 246   mImageActor.SetAnchorPoint(AnchorPoint::CENTER);
 247
 248   // Create the stencil
 249   Vector2 imageSize = ResourceImage::GetImageSize(imageName);
 250   float diameter = std::max(imageSize.width, imageSize.height);
 251   RadialSweepView radialSweepView = RadialSweepView::New();
 252   radialSweepView.SetDiameter( diameter );
 253   radialSweepView.SetInitialAngle( initialAngle );
 254   radialSweepView.SetFinalAngle( finalAngle );
 255   radialSweepView.SetInitialSector( Degree(0.0f) );
 256   radialSweepView.SetFinalSector( Degree(359.999f) );
 257   radialSweepView.SetSize( Stage::GetCurrent().GetSize());
 258   radialSweepView.SetEasingFunction( Dali::AlphaFunctions::EaseInOut );
 259   radialSweepView.SetPositionInheritanceMode(USE_PARENT_POSITION);
 260   mContents.Add(radialSweepView);
 261   radialSweepView.Add( mImageActor );
 262   mImageActor.SetPositionInheritanceMode(USE_PARENT_POSITION);
 263
 264   return radialSweepView;
 265 }
 266
 267
 268 void RadialMenuExample::OnKeyEvent(const KeyEvent& event)
 269 {
 270   if(event.state == KeyEvent::Down)
 271   {
 272     if( IsKey( event, Dali::DALI_KEY_ESCAPE) || IsKey( event, Dali::DALI_KEY_BACK) )
 273     {
 274       mApplication.Quit();
 275     }
 276   }
 277 }
 278
 279 void RunTest(Application app)
 280 {
 281   RadialMenuExample test(app);
 282
 283   app.MainLoop();
 284 }
 285
 286 // Entry point for Linux & Tizen applications
 287 int main(int argc, char **argv)
 288 {
 289   Application app = Application::New(&argc, &argv);
 290
 291   RunTest(app);
 292
 293   return 0;
 294 }