X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fevent%2Fevents%2Fevent-processor.cpp;h=611d6f7db5f434eeb44413bd0139a38e674b04a3;hb=de3ed8ed62cadc6ec663d8bdd84aca42b7d56325;hp=31ce118a38e31cbbb00d66823dfb3f3aa89d28a3;hpb=571a6bf115be6c1ed26805e79e9a0f14bd0439e2;p=platform%2Fcore%2Fuifw%2Fdali-core.git

diff --git a/dali/internal/event/events/event-processor.cpp b/dali/internal/event/events/event-processor.cpp
index 31ce118..611d6f7 100755
--- a/dali/internal/event/events/event-processor.cpp
+++ b/dali/internal/event/events/event-processor.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,27 +21,24 @@
 // INTERNAL INCLUDES
 #include <dali/integration-api/debug.h>
 #include <dali/integration-api/events/event.h>
+#include <dali/integration-api/events/hover-event-integ.h>
 #include <dali/integration-api/events/key-event-integ.h>
-#include <dali/integration-api/events/wheel-event-integ.h>
 #include <dali/integration-api/events/touch-event-integ.h>
-#include <dali/integration-api/events/hover-event-integ.h>
-#include <dali/internal/event/events/gesture-event-processor.h>
+#include <dali/integration-api/events/wheel-event-integ.h>
 #include <dali/internal/common/core-impl.h>
 #include <dali/internal/event/common/notification-manager.h>
+#include <dali/internal/event/events/gesture-event-processor.h>
 
 using Dali::Integration::Event;
 
 namespace Dali
 {
-
 namespace Internal
 {
-
 namespace // unnamed namespace
 {
-
-static const std::size_t MAX_MESSAGE_SIZE = std::max( sizeof(Integration::TouchEvent),
-                                                      std::max( sizeof(Integration::KeyEvent), sizeof(Integration::WheelEvent) ) );
+static const std::size_t MAX_MESSAGE_SIZE = std::max(sizeof(Integration::TouchEvent),
+                                                     std::max(sizeof(Integration::KeyEvent), sizeof(Integration::WheelEvent)));
 
 static const std::size_t INITIAL_MIN_CAPACITY = 4;
 
@@ -49,49 +46,49 @@ static const std::size_t INITIAL_BUFFER_SIZE = MAX_MESSAGE_SIZE * INITIAL_MIN_CA
 
 } // unnamed namespace
 
-EventProcessor::EventProcessor( Scene& scene, GestureEventProcessor& gestureEventProcessor )
-: mScene( scene ),
-  mTouchEventProcessor( scene ),
-  mHoverEventProcessor( scene ),
-  mGestureEventProcessor( gestureEventProcessor ),
-  mKeyEventProcessor( scene ),
-  mWheelEventProcessor( scene ),
-  mEventQueue0( INITIAL_BUFFER_SIZE ),
-  mEventQueue1( INITIAL_BUFFER_SIZE ),
-  mCurrentEventQueue( &mEventQueue0 )
+EventProcessor::EventProcessor(Scene& scene, GestureEventProcessor& gestureEventProcessor)
+: mScene(scene),
+  mTouchEventProcessor(scene),
+  mHoverEventProcessor(scene),
+  mGestureEventProcessor(gestureEventProcessor),
+  mKeyEventProcessor(scene),
+  mWheelEventProcessor(scene),
+  mEventQueue0(INITIAL_BUFFER_SIZE),
+  mEventQueue1(INITIAL_BUFFER_SIZE),
+  mCurrentEventQueue(&mEventQueue0)
 {
 }
 
 EventProcessor::~EventProcessor()
 {
-  for( MessageBuffer::Iterator iter = mEventQueue0.Begin(); iter.IsValid(); iter.Next() )
+  for(MessageBuffer::Iterator iter = mEventQueue0.Begin(); iter.IsValid(); iter.Next())
   {
     // Call virtual destructor explictly; since delete will not be called after placement new
-    Event* event = reinterpret_cast< Event* >( iter.Get() );
+    Event* event = reinterpret_cast<Event*>(iter.Get());
     event->~Event();
   }
 
-  for( MessageBuffer::Iterator iter = mEventQueue1.Begin(); iter.IsValid(); iter.Next() )
+  for(MessageBuffer::Iterator iter = mEventQueue1.Begin(); iter.IsValid(); iter.Next())
   {
     // Call virtual destructor explictly; since delete will not be called after placement new
-    Event* event = reinterpret_cast< Event* >( iter.Get() );
+    Event* event = reinterpret_cast<Event*>(iter.Get());
     event->~Event();
   }
 }
 
-void EventProcessor::QueueEvent( const Event& event )
+void EventProcessor::QueueEvent(const Event& event)
 {
-  switch( event.type )
+  switch(event.type)
   {
     case Event::Touch:
     {
       typedef Integration::TouchEvent DerivedType;
 
       // Reserve some memory inside the message queue
-      uint32_t* slot = mCurrentEventQueue->ReserveMessageSlot( sizeof( DerivedType ) );
+      uint32_t* slot = mCurrentEventQueue->ReserveMessageSlot(sizeof(DerivedType));
 
       // Construct message in the message queue memory; note that delete should not be called on the return value
-      new (slot) DerivedType( static_cast<const DerivedType&>(event) );
+      new(slot) DerivedType(static_cast<const DerivedType&>(event));
 
       break;
     }
@@ -101,10 +98,10 @@ void EventProcessor::QueueEvent( const Event& event )
       using DerivedType = Integration::HoverEvent;
 
       // Reserve some memory inside the message queue
-      uint32_t* slot = mCurrentEventQueue->ReserveMessageSlot( sizeof( DerivedType ) );
+      uint32_t* slot = mCurrentEventQueue->ReserveMessageSlot(sizeof(DerivedType));
 
       // Construct message in the message queue memory; note that delete should not be called on the return value
-      new (slot) DerivedType( static_cast<const DerivedType&>(event) );
+      new(slot) DerivedType(static_cast<const DerivedType&>(event));
 
       break;
     }
@@ -114,10 +111,10 @@ void EventProcessor::QueueEvent( const Event& event )
       using DerivedType = Integration::KeyEvent;
 
       // Reserve some memory inside the message queue
-      uint32_t* slot = mCurrentEventQueue->ReserveMessageSlot( sizeof( DerivedType ) );
+      uint32_t* slot = mCurrentEventQueue->ReserveMessageSlot(sizeof(DerivedType));
 
       // Construct message in the message queue memory; note that delete should not be called on the return value
-      new (slot) DerivedType( static_cast<const DerivedType&>(event) );
+      new(slot) DerivedType(static_cast<const DerivedType&>(event));
 
       break;
     }
@@ -127,10 +124,10 @@ void EventProcessor::QueueEvent( const Event& event )
       using DerivedType = Integration::WheelEvent;
 
       // Reserve some memory inside the message queue
-      uint32_t* slot = mCurrentEventQueue->ReserveMessageSlot( sizeof( DerivedType ) );
+      uint32_t* slot = mCurrentEventQueue->ReserveMessageSlot(sizeof(DerivedType));
 
       // Construct message in the message queue memory; note that delete should not be called on the return value
-      new (slot) DerivedType( static_cast<const DerivedType&>(event) );
+      new(slot) DerivedType(static_cast<const DerivedType&>(event));
 
       break;
     }
@@ -142,25 +139,25 @@ void EventProcessor::ProcessEvents()
   MessageBuffer* queueToProcess = mCurrentEventQueue;
 
   // Switch current queue; events can be added safely while iterating through the other queue.
-  mCurrentEventQueue = ( &mEventQueue0 == mCurrentEventQueue ) ? &mEventQueue1 : &mEventQueue0;
+  mCurrentEventQueue = (&mEventQueue0 == mCurrentEventQueue) ? &mEventQueue1 : &mEventQueue0;
 
-  for( MessageBuffer::Iterator iter = queueToProcess->Begin(); iter.IsValid(); iter.Next() )
+  for(MessageBuffer::Iterator iter = queueToProcess->Begin(); iter.IsValid(); iter.Next())
   {
-    Event* event = reinterpret_cast< Event* >( iter.Get() );
+    Event* event = reinterpret_cast<Event*>(iter.Get());
 
-    switch( event->type )
+    switch(event->type)
     {
       case Event::Touch:
       {
         Integration::TouchEvent& touchEvent = static_cast<Integration::TouchEvent&>(*event);
-        const bool consumed = mTouchEventProcessor.ProcessTouchEvent( touchEvent );
+        const bool               consumed   = mTouchEventProcessor.ProcessTouchEvent(touchEvent);
 
         // If touch is consumed, then gestures should be cancelled
         // Do this by sending an interrupted event to the GestureEventProcessor
-        if( consumed )
+        if(consumed)
         {
           // Integration::Point& point = touchEvent.GetPoint(0);
-          // point.SetState( PointState::INTERRUPTED );
+          // point.SetState(PointState::INTERRUPTED);
         }
 
         mGestureEventProcessor.ProcessTouchEvent(mScene, touchEvent);
@@ -169,19 +166,19 @@ void EventProcessor::ProcessEvents()
 
       case Event::Hover:
       {
-        mHoverEventProcessor.ProcessHoverEvent( static_cast<const Integration::HoverEvent&>(*event) );
+        mHoverEventProcessor.ProcessHoverEvent(static_cast<const Integration::HoverEvent&>(*event));
         break;
       }
 
       case Event::Key:
       {
-        mKeyEventProcessor.ProcessKeyEvent( static_cast<const Integration::KeyEvent&>(*event) );
+        mKeyEventProcessor.ProcessKeyEvent(static_cast<const Integration::KeyEvent&>(*event));
         break;
       }
 
       case Event::Wheel:
       {
-        mWheelEventProcessor.ProcessWheelEvent( static_cast<const Integration::WheelEvent&>(*event) );
+        mWheelEventProcessor.ProcessWheelEvent(static_cast<const Integration::WheelEvent&>(*event));
         break;
       }
     }