/*
- * Copyright (c) 2019 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.
#include <dali/internal/system/common/environment-options.h>
// EXTERNAL INCLUDES
-#include <cstdlib>
#include <dali/integration-api/render-controller.h>
#include <dali/public-api/math/math-utils.h>
+#include <cstdlib>
+#include <functional>
// INTERNAL INCLUDES
-#include <dali/internal/trace/common/trace-factory.h>
#include <dali/internal/system/common/environment-variables.h>
+#include <dali/internal/trace/common/trace-factory.h>
namespace Dali
{
-
namespace Internal
{
-
namespace Adaptor
{
-
namespace
{
-const unsigned int DEFAULT_STATISTICS_LOG_FREQUENCY = 2;
-const int DEFAULT_MULTI_SAMPLING_LEVEL = -1;
-const bool DEFAULT_DEPTH_BUFFER_REQUIRED_SETTING = true;
-const bool DEFAULT_STENCIL_BUFFER_REQUIRED_SETTING = true;
-const bool DEFAULT_PARTIAL_UPDATE_REQUIRED_SETTING = false;
+const unsigned int DEFAULT_STATISTICS_LOG_FREQUENCY = 2;
+const int DEFAULT_MULTI_SAMPLING_LEVEL = -1;
+const bool DEFAULT_DEPTH_BUFFER_REQUIRED_SETTING = true;
+const bool DEFAULT_STENCIL_BUFFER_REQUIRED_SETTING = true;
+const bool DEFAULT_PARTIAL_UPDATE_REQUIRED_SETTING = true;
-unsigned int GetIntegerEnvironmentVariable( const char* variable, unsigned int defaultValue )
+unsigned int GetEnvironmentVariable(const char* variable, unsigned int defaultValue)
{
const char* variableParameter = std::getenv(variable);
return intValue;
}
-bool GetIntegerEnvironmentVariable( const char* variable, int& intValue )
+bool GetEnvironmentVariable(const char* variable, int& intValue)
{
const char* variableParameter = std::getenv(variable);
- if( !variableParameter )
+ if(!variableParameter)
{
return false;
}
return true;
}
-bool GetFloatEnvironmentVariable( const char* variable, float& floatValue )
+bool GetEnvironmentVariable(const char* variable, float& floatValue)
{
const char* variableParameter = std::getenv(variable);
- if( !variableParameter )
+ if(!variableParameter)
{
return false;
}
return true;
}
-const char * GetCharEnvironmentVariable( const char * variable )
+void SetFromEnvironmentVariable(const char* variable, std::string& stringValue)
{
- return std::getenv( variable );
+ const char* charValue = std::getenv(variable);
+ if(charValue)
+ {
+ stringValue = charValue;
+ }
}
+template<typename Type>
+void SetFromEnvironmentVariable(const char* variable, Type& memberVariable)
+{
+ Type envVarValue = -1;
+ if(GetEnvironmentVariable(variable, envVarValue))
+ {
+ memberVariable = envVarValue;
+ }
+}
+
+template<typename Type>
+void SetFromEnvironmentVariable(const char* variable, std::function<void(Type)> function)
+{
+ Type envVarValue = -1;
+ if(GetEnvironmentVariable(variable, envVarValue))
+ {
+ function(envVarValue);
+ }
+}
+
+/// Provides a functor which ensures a non-negative number is set for the given member variable
+struct MinimumZero
+{
+ MinimumZero(int& memberValue)
+ : mMemberValue(memberValue)
+ {
+ }
+
+ void operator()(int value)
+ {
+ // Negative Amounts do not make sense
+ mMemberValue = std::max(0, value);
+ }
+
+ int& mMemberValue;
+};
+
+/// Provides a functor which clamps the environment variable between 0.0f and 1.0f
+struct ClampBetweenZeroAndOne
+{
+ ClampBetweenZeroAndOne(float& memberValue)
+ : mMemberValue(memberValue)
+ {
+ }
+
+ void operator()(float value)
+ {
+ value = Clamp(value, 0.0f, 1.0f);
+ mMemberValue = value;
+ }
+
+ float& mMemberValue;
+};
+
+/// Provides a functor which only sets the member variable if the environment variable value is greater than the specified constant
+struct GreaterThan
+{
+ GreaterThan(unsigned int& memberValue, int greaterThanValue)
+ : mMemberValue(memberValue),
+ mGreaterThanValue(greaterThanValue)
+ {
+ }
+
+ void operator()(int value)
+ {
+ if(value > mGreaterThanValue)
+ {
+ mMemberValue = value;
+ }
+ }
+
+ unsigned int& mMemberValue;
+ const int mGreaterThanValue;
+};
+
+/// Provides a functor which sets the member to 1 if if the environment variable value is not zero
+struct EnableIfNonZero
+{
+ EnableIfNonZero(int& memberValue)
+ : mMemberValue(memberValue)
+ {
+ }
+
+ void operator()(int value)
+ {
+ mMemberValue = (value == 0) ? 0 : 1;
+ }
+
+ int& mMemberValue;
+};
+
+/// Provides a functor which sets the member to false if the environment variable value is not zero
+struct DisableIfNonZero
+{
+ DisableIfNonZero(bool& memberValue)
+ : mMemberValue(memberValue)
+ {
+ }
+
+ void operator()(int value)
+ {
+ if(value > 0)
+ {
+ mMemberValue = false;
+ }
+ }
+
+ bool& mMemberValue;
+};
+
} // unnamed namespace
EnvironmentOptions::EnvironmentOptions()
-: mLogFunction( NULL ),
+: mLogFunction(NULL),
mWindowName(),
mWindowClassName(),
- mNetworkControl( 0 ),
- mFpsFrequency( 0 ),
- mUpdateStatusFrequency( 0 ),
- mObjectProfilerInterval( 0 ),
- mPerformanceStatsLevel( 0 ),
- mPerformanceStatsFrequency( DEFAULT_STATISTICS_LOG_FREQUENCY ),
- mPerformanceTimeStampOutput( 0 ),
- mPanGestureLoggingLevel( 0 ),
- mWindowWidth( 0u ),
- mWindowHeight( 0u ),
- mRenderRefreshRate( 1u ),
- mMaxTextureSize( 0 ),
- mRenderToFboInterval( 0u ),
- mPanGesturePredictionMode( -1 ),
- mPanGesturePredictionAmount( -1 ), ///< only sets value in pan gesture if greater than 0
- mPanGestureMaxPredictionAmount( -1 ),
- mPanGestureMinPredictionAmount( -1 ),
- mPanGesturePredictionAmountAdjustment( -1 ),
- mPanGestureSmoothingMode( -1 ),
- mPanGestureSmoothingAmount( -1.0f ),
- mPanGestureUseActualTimes( -1 ),
- mPanGestureInterpolationTimeRange( -1 ),
- mPanGestureScalarOnlyPredictionEnabled( -1 ),
- mPanGestureTwoPointPredictionEnabled( -1 ),
- mPanGestureTwoPointInterpolatePastTime( -1 ),
- mPanGestureTwoPointVelocityBias( -1.0f ),
- mPanGestureTwoPointAccelerationBias( -1.0f ),
- mPanGestureMultitapSmoothingRange( -1 ),
- mPanMinimumDistance( -1 ),
- mPanMinimumEvents( -1 ),
- mPinchMinimumDistance( -1.0f ),
- mPinchMinimumTouchEvents( -1 ),
- mPinchMinimumTouchEventsAfterStart( -1 ),
- mRotationMinimumTouchEvents( -1 ),
- mRotationMinimumTouchEventsAfterStart( -1 ),
- mLongPressMinimumHoldingTime( -1 ),
- mGlesCallTime( 0 ),
- mMultiSamplingLevel( DEFAULT_MULTI_SAMPLING_LEVEL ),
- mThreadingMode( ThreadingMode::COMBINED_UPDATE_RENDER ),
- mGlesCallAccumulate( false ),
- mDepthBufferRequired( DEFAULT_DEPTH_BUFFER_REQUIRED_SETTING ),
- mStencilBufferRequired( DEFAULT_STENCIL_BUFFER_REQUIRED_SETTING ),
- mPartialUpdateRequired( DEFAULT_PARTIAL_UPDATE_REQUIRED_SETTING )
+ mNetworkControl(0),
+ mFpsFrequency(0),
+ mUpdateStatusFrequency(0),
+ mObjectProfilerInterval(0),
+ mPerformanceStatsLevel(0),
+ mPerformanceStatsFrequency(DEFAULT_STATISTICS_LOG_FREQUENCY),
+ mPerformanceTimeStampOutput(0),
+ mPanGestureLoggingLevel(0),
+ mWindowWidth(0u),
+ mWindowHeight(0u),
+ mRenderRefreshRate(1u),
+ mMaxTextureSize(0),
+ mRenderToFboInterval(0u),
+ mPanGesturePredictionMode(-1),
+ mPanGesturePredictionAmount(-1), ///< only sets value in pan gesture if greater than 0
+ mPanGestureMaxPredictionAmount(-1),
+ mPanGestureMinPredictionAmount(-1),
+ mPanGesturePredictionAmountAdjustment(-1),
+ mPanGestureSmoothingMode(-1),
+ mPanGestureSmoothingAmount(-1.0f),
+ mPanGestureUseActualTimes(-1),
+ mPanGestureInterpolationTimeRange(-1),
+ mPanGestureScalarOnlyPredictionEnabled(-1),
+ mPanGestureTwoPointPredictionEnabled(-1),
+ mPanGestureTwoPointInterpolatePastTime(-1),
+ mPanGestureTwoPointVelocityBias(-1.0f),
+ mPanGestureTwoPointAccelerationBias(-1.0f),
+ mPanGestureMultitapSmoothingRange(-1),
+ mPanMinimumDistance(-1),
+ mPanMinimumEvents(-1),
+ mPinchMinimumDistance(-1.0f),
+ mPinchMinimumTouchEvents(-1),
+ mPinchMinimumTouchEventsAfterStart(-1),
+ mRotationMinimumTouchEvents(-1),
+ mRotationMinimumTouchEventsAfterStart(-1),
+ mLongPressMinimumHoldingTime(-1),
+ mTapMaximumAllowedTime(-1),
+ mGlesCallTime(0),
+ mMultiSamplingLevel(DEFAULT_MULTI_SAMPLING_LEVEL),
+ mThreadingMode(ThreadingMode::COMBINED_UPDATE_RENDER),
+ mGlesCallAccumulate(false),
+ mDepthBufferRequired(DEFAULT_DEPTH_BUFFER_REQUIRED_SETTING),
+ mStencilBufferRequired(DEFAULT_STENCIL_BUFFER_REQUIRED_SETTING),
+ mPartialUpdateRequired(DEFAULT_PARTIAL_UPDATE_REQUIRED_SETTING)
{
ParseEnvironmentOptions();
}
{
}
-void EnvironmentOptions::CreateTraceManager( PerformanceInterface* performanceInterface )
+void EnvironmentOptions::CreateTraceManager(PerformanceInterface* performanceInterface)
{
- mTraceManager = TraceManagerFactory::CreateTraceFactory( performanceInterface );
+ mTraceManager = TraceManagerFactory::CreateTraceFactory(performanceInterface);
}
void EnvironmentOptions::InstallTraceFunction() const
{
- if( mTraceManager )
+ if(mTraceManager)
{
mTraceManager->Initialise();
}
}
-void EnvironmentOptions::SetLogFunction( const Dali::Integration::Log::LogFunction& logFunction )
+void EnvironmentOptions::SetLogFunction(const Dali::Integration::Log::LogFunction& logFunction)
{
mLogFunction = logFunction;
}
void EnvironmentOptions::InstallLogFunction() const
{
- Dali::Integration::Log::InstallLogFunction( mLogFunction );
+ Dali::Integration::Log::InstallLogFunction(mLogFunction);
}
void EnvironmentOptions::UnInstallLogFunction() const
return mLongPressMinimumHoldingTime;
}
+int EnvironmentOptions::GetTapMaximumAllowedTime() const
+{
+ return mTapMaximumAllowedTime;
+}
+
unsigned int EnvironmentOptions::GetWindowWidth() const
{
return mWindowWidth;
bool EnvironmentOptions::PerformanceServerRequired() const
{
- return ( ( GetPerformanceStatsLoggingOptions() > 0) ||
- ( GetPerformanceTimeStampOutput() > 0 ) ||
- ( GetNetworkControlMode() > 0) );
+ return ((GetPerformanceStatsLoggingOptions() > 0) ||
+ (GetPerformanceTimeStampOutput() > 0) ||
+ (GetNetworkControlMode() > 0));
}
bool EnvironmentOptions::DepthBufferRequired() const
void EnvironmentOptions::ParseEnvironmentOptions()
{
// get logging options
- mFpsFrequency = GetIntegerEnvironmentVariable( DALI_ENV_FPS_TRACKING, 0 );
- mUpdateStatusFrequency = GetIntegerEnvironmentVariable( DALI_ENV_UPDATE_STATUS_INTERVAL, 0 );
- mObjectProfilerInterval = GetIntegerEnvironmentVariable( DALI_ENV_OBJECT_PROFILER_INTERVAL, 0 );
- mPerformanceStatsLevel = GetIntegerEnvironmentVariable( DALI_ENV_LOG_PERFORMANCE_STATS, 0 );
- mPerformanceStatsFrequency = GetIntegerEnvironmentVariable( DALI_ENV_LOG_PERFORMANCE_STATS_FREQUENCY, 0 );
- mPerformanceTimeStampOutput = GetIntegerEnvironmentVariable( DALI_ENV_PERFORMANCE_TIMESTAMP_OUTPUT, 0 );
- mNetworkControl = GetIntegerEnvironmentVariable( DALI_ENV_NETWORK_CONTROL, 0 );
- mPanGestureLoggingLevel = GetIntegerEnvironmentVariable( DALI_ENV_LOG_PAN_GESTURE, 0 );
-
- int predictionMode;
- if( GetIntegerEnvironmentVariable(DALI_ENV_PAN_PREDICTION_MODE, predictionMode) )
- {
- mPanGesturePredictionMode = predictionMode;
- }
- int predictionAmount(-1);
- if( GetIntegerEnvironmentVariable(DALI_ENV_PAN_PREDICTION_AMOUNT, predictionAmount) )
- {
- if( predictionAmount < 0 )
- {
- // do not support times in the past
- predictionAmount = 0;
- }
- mPanGesturePredictionAmount = predictionAmount;
- }
- int minPredictionAmount(-1);
- if( GetIntegerEnvironmentVariable(DALI_ENV_PAN_MIN_PREDICTION_AMOUNT, minPredictionAmount) )
- {
- if( minPredictionAmount < 0 )
- {
- // do not support times in the past
- minPredictionAmount = 0;
- }
- mPanGestureMinPredictionAmount = minPredictionAmount;
- }
- int maxPredictionAmount(-1);
- if( GetIntegerEnvironmentVariable(DALI_ENV_PAN_MAX_PREDICTION_AMOUNT, maxPredictionAmount) )
- {
- if( minPredictionAmount > -1 && maxPredictionAmount < minPredictionAmount )
- {
- // maximum amount should not be smaller than minimum amount
- maxPredictionAmount = minPredictionAmount;
- }
- mPanGestureMaxPredictionAmount = maxPredictionAmount;
- }
- int predictionAmountAdjustment(-1);
- if( GetIntegerEnvironmentVariable(DALI_ENV_PAN_PREDICTION_AMOUNT_ADJUSTMENT, predictionAmountAdjustment) )
- {
- if( predictionAmountAdjustment < 0 )
- {
- // negative amount doesn't make sense
- predictionAmountAdjustment = 0;
- }
- mPanGesturePredictionAmountAdjustment = predictionAmountAdjustment;
- }
- int smoothingMode;
- if( GetIntegerEnvironmentVariable(DALI_ENV_PAN_SMOOTHING_MODE, smoothingMode) )
- {
- mPanGestureSmoothingMode = smoothingMode;
- }
- float smoothingAmount = 1.0f;
- if( GetFloatEnvironmentVariable(DALI_ENV_PAN_SMOOTHING_AMOUNT, smoothingAmount) )
- {
- smoothingAmount = Clamp(smoothingAmount, 0.0f, 1.0f);
- mPanGestureSmoothingAmount = smoothingAmount;
- }
-
- int useActualTimes( -1 );
- if( GetIntegerEnvironmentVariable( DALI_ENV_PAN_USE_ACTUAL_TIMES, useActualTimes ) )
- {
- mPanGestureUseActualTimes = useActualTimes == 0 ? 0 : 1;
- }
-
- int interpolationTimeRange( -1 );
- if( GetIntegerEnvironmentVariable( DALI_ENV_PAN_INTERPOLATION_TIME_RANGE, interpolationTimeRange ) )
- {
- if( interpolationTimeRange < 0 )
- {
- interpolationTimeRange = 0;
- }
- mPanGestureInterpolationTimeRange = interpolationTimeRange;
- }
-
- int scalarOnlyPredictionEnabled( -1 );
- if( GetIntegerEnvironmentVariable( DALI_ENV_PAN_SCALAR_ONLY_PREDICTION_ENABLED, scalarOnlyPredictionEnabled ) )
- {
- mPanGestureScalarOnlyPredictionEnabled = scalarOnlyPredictionEnabled == 0 ? 0 : 1;
- }
-
- int twoPointPredictionEnabled( -1 );
- if( GetIntegerEnvironmentVariable( DALI_ENV_PAN_TWO_POINT_PREDICTION_ENABLED, twoPointPredictionEnabled ) )
- {
- mPanGestureTwoPointPredictionEnabled = twoPointPredictionEnabled == 0 ? 0 : 1;
- }
-
- int twoPointPastInterpolateTime( -1 );
- if( GetIntegerEnvironmentVariable( DALI_ENV_PAN_TWO_POINT_PAST_INTERPOLATE_TIME, twoPointPastInterpolateTime ) )
- {
- if( twoPointPastInterpolateTime < 0 )
- {
- twoPointPastInterpolateTime = 0;
- }
- mPanGestureTwoPointInterpolatePastTime = twoPointPastInterpolateTime;
- }
-
- float twoPointVelocityBias = -1.0f;
- if( GetFloatEnvironmentVariable( DALI_ENV_PAN_TWO_POINT_VELOCITY_BIAS, twoPointVelocityBias ) )
- {
- twoPointVelocityBias = Clamp( twoPointVelocityBias, 0.0f, 1.0f );
- mPanGestureTwoPointVelocityBias = twoPointVelocityBias;
- }
-
- float twoPointAccelerationBias = -1.0f;
- if( GetFloatEnvironmentVariable( DALI_ENV_PAN_TWO_POINT_ACCELERATION_BIAS, twoPointAccelerationBias ) )
- {
- twoPointAccelerationBias = Clamp( twoPointAccelerationBias, 0.0f, 1.0f );
- mPanGestureTwoPointAccelerationBias = twoPointAccelerationBias;
- }
-
- int multitapSmoothingRange( -1 );
- if( GetIntegerEnvironmentVariable( DALI_ENV_PAN_MULTITAP_SMOOTHING_RANGE, multitapSmoothingRange ) )
- {
- if( multitapSmoothingRange < 0 )
- {
- multitapSmoothingRange = 0;
- }
- mPanGestureMultitapSmoothingRange = multitapSmoothingRange;
- }
-
- int minimumDistance(-1);
- if ( GetIntegerEnvironmentVariable(DALI_ENV_PAN_MINIMUM_DISTANCE, minimumDistance ))
- {
- mPanMinimumDistance = minimumDistance;
- }
-
- int minimumEvents(-1);
- if ( GetIntegerEnvironmentVariable(DALI_ENV_PAN_MINIMUM_EVENTS, minimumEvents ))
- {
- mPanMinimumEvents = minimumEvents;
- }
-
- float pinchMinimumDistance = -1.0f;
- if( GetFloatEnvironmentVariable( DALI_ENV_PINCH_MINIMUM_DISTANCE, pinchMinimumDistance ) )
- {
- mPinchMinimumDistance = pinchMinimumDistance;
- }
-
- int pinchMinimumTouchEvents = -1;
- if( GetIntegerEnvironmentVariable( DALI_ENV_PINCH_MINIMUM_TOUCH_EVENTS, pinchMinimumTouchEvents ) )
- {
- mPinchMinimumTouchEvents = pinchMinimumTouchEvents;
- }
-
- int pinchMinimumTouchEventsAfterStart = -1;
- if( GetIntegerEnvironmentVariable( DALI_ENV_PINCH_MINIMUM_TOUCH_EVENTS_AFTER_START, pinchMinimumTouchEventsAfterStart ) )
- {
- mPinchMinimumTouchEventsAfterStart = pinchMinimumTouchEventsAfterStart;
- }
-
- int rotationMinimumTouchEvents = -1;
- if( GetIntegerEnvironmentVariable( DALI_ENV_ROTATION_MINIMUM_TOUCH_EVENTS, rotationMinimumTouchEvents ) )
- {
- mRotationMinimumTouchEvents = rotationMinimumTouchEvents;
- }
-
- int rotationMinimumTouchEventsAfterStart = -1;
- if( GetIntegerEnvironmentVariable( DALI_ENV_ROTATION_MINIMUM_TOUCH_EVENTS_AFTER_START, rotationMinimumTouchEventsAfterStart ) )
- {
- mRotationMinimumTouchEventsAfterStart = rotationMinimumTouchEventsAfterStart;
- }
-
- int longPressMinimumHoldingTime = -1;
- if( GetIntegerEnvironmentVariable( DALI_ENV_LONG_PRESS_MINIMUM_HOLDING_TIME, longPressMinimumHoldingTime ) )
- {
- mLongPressMinimumHoldingTime = longPressMinimumHoldingTime;
- }
-
- int glesCallTime(0);
- if ( GetIntegerEnvironmentVariable(DALI_GLES_CALL_TIME, glesCallTime ))
- {
- mGlesCallTime = glesCallTime;
- }
-
- int glesCallAccumulate( 0 );
- if ( GetIntegerEnvironmentVariable( DALI_GLES_CALL_ACCUMULATE, glesCallAccumulate ) )
- {
- mGlesCallAccumulate = glesCallAccumulate != 0;
- }
+ mFpsFrequency = GetEnvironmentVariable(DALI_ENV_FPS_TRACKING, 0);
+ mUpdateStatusFrequency = GetEnvironmentVariable(DALI_ENV_UPDATE_STATUS_INTERVAL, 0);
+ mObjectProfilerInterval = GetEnvironmentVariable(DALI_ENV_OBJECT_PROFILER_INTERVAL, 0);
+ mPerformanceStatsLevel = GetEnvironmentVariable(DALI_ENV_LOG_PERFORMANCE_STATS, 0);
+ mPerformanceStatsFrequency = GetEnvironmentVariable(DALI_ENV_LOG_PERFORMANCE_STATS_FREQUENCY, 0);
+ mPerformanceTimeStampOutput = GetEnvironmentVariable(DALI_ENV_PERFORMANCE_TIMESTAMP_OUTPUT, 0);
+ mNetworkControl = GetEnvironmentVariable(DALI_ENV_NETWORK_CONTROL, 0);
+ mPanGestureLoggingLevel = GetEnvironmentVariable(DALI_ENV_LOG_PAN_GESTURE, 0);
+
+ SetFromEnvironmentVariable(DALI_ENV_PAN_PREDICTION_MODE, mPanGesturePredictionMode);
+ SetFromEnvironmentVariable<int>(DALI_ENV_PAN_PREDICTION_AMOUNT, MinimumZero(mPanGesturePredictionAmount));
+ SetFromEnvironmentVariable<int>(DALI_ENV_PAN_MIN_PREDICTION_AMOUNT, MinimumZero(mPanGestureMinPredictionAmount));
+ SetFromEnvironmentVariable<int>(DALI_ENV_PAN_MAX_PREDICTION_AMOUNT,
+ [&](int maxPredictionAmount) {
+ if(mPanGestureMinPredictionAmount > -1 && maxPredictionAmount < mPanGestureMinPredictionAmount)
+ {
+ // maximum amount should not be smaller than minimum amount
+ maxPredictionAmount = mPanGestureMinPredictionAmount;
+ }
+ mPanGestureMaxPredictionAmount = maxPredictionAmount;
+ });
+ SetFromEnvironmentVariable<int>(DALI_ENV_PAN_PREDICTION_AMOUNT_ADJUSTMENT, MinimumZero(mPanGesturePredictionAmountAdjustment));
+ SetFromEnvironmentVariable(DALI_ENV_PAN_SMOOTHING_MODE, mPanGestureSmoothingMode);
+ SetFromEnvironmentVariable<float>(DALI_ENV_PAN_SMOOTHING_AMOUNT, ClampBetweenZeroAndOne(mPanGestureSmoothingAmount));
+ SetFromEnvironmentVariable<int>(DALI_ENV_PAN_USE_ACTUAL_TIMES, EnableIfNonZero(mPanGestureUseActualTimes));
+ SetFromEnvironmentVariable<int>(DALI_ENV_PAN_INTERPOLATION_TIME_RANGE, MinimumZero(mPanGestureInterpolationTimeRange));
+ SetFromEnvironmentVariable<int>(DALI_ENV_PAN_SCALAR_ONLY_PREDICTION_ENABLED, EnableIfNonZero(mPanGestureScalarOnlyPredictionEnabled));
+ SetFromEnvironmentVariable<int>(DALI_ENV_PAN_TWO_POINT_PREDICTION_ENABLED, EnableIfNonZero(mPanGestureTwoPointPredictionEnabled));
+ SetFromEnvironmentVariable<int>(DALI_ENV_PAN_TWO_POINT_PAST_INTERPOLATE_TIME, MinimumZero(mPanGestureTwoPointInterpolatePastTime));
+ SetFromEnvironmentVariable<float>(DALI_ENV_PAN_TWO_POINT_VELOCITY_BIAS, ClampBetweenZeroAndOne(mPanGestureTwoPointVelocityBias));
+ SetFromEnvironmentVariable<float>(DALI_ENV_PAN_TWO_POINT_ACCELERATION_BIAS, ClampBetweenZeroAndOne(mPanGestureTwoPointAccelerationBias));
+ SetFromEnvironmentVariable<int>(DALI_ENV_PAN_MULTITAP_SMOOTHING_RANGE, MinimumZero(mPanGestureMultitapSmoothingRange));
+ SetFromEnvironmentVariable(DALI_ENV_PAN_MINIMUM_DISTANCE, mPanMinimumDistance);
+ SetFromEnvironmentVariable(DALI_ENV_PAN_MINIMUM_EVENTS, mPanMinimumEvents);
+
+ SetFromEnvironmentVariable(DALI_ENV_PINCH_MINIMUM_DISTANCE, mPinchMinimumDistance);
+ SetFromEnvironmentVariable(DALI_ENV_PINCH_MINIMUM_TOUCH_EVENTS, mPinchMinimumTouchEvents);
+ SetFromEnvironmentVariable(DALI_ENV_PINCH_MINIMUM_TOUCH_EVENTS_AFTER_START, mPinchMinimumTouchEventsAfterStart);
+
+ SetFromEnvironmentVariable(DALI_ENV_ROTATION_MINIMUM_TOUCH_EVENTS, mRotationMinimumTouchEvents);
+ SetFromEnvironmentVariable(DALI_ENV_ROTATION_MINIMUM_TOUCH_EVENTS_AFTER_START, mRotationMinimumTouchEventsAfterStart);
+
+ SetFromEnvironmentVariable(DALI_ENV_LONG_PRESS_MINIMUM_HOLDING_TIME, mLongPressMinimumHoldingTime);
+ SetFromEnvironmentVariable(DALI_ENV_TAP_MAXIMUM_ALLOWED_TIME, mTapMaximumAllowedTime);
+
+ SetFromEnvironmentVariable(DALI_GLES_CALL_TIME, mGlesCallTime);
+ SetFromEnvironmentVariable<int>(DALI_GLES_CALL_ACCUMULATE, [&](int glesCallAccumulate) { mGlesCallAccumulate = glesCallAccumulate != 0; });
int windowWidth(0), windowHeight(0);
- if ( GetIntegerEnvironmentVariable( DALI_WINDOW_WIDTH, windowWidth ) && GetIntegerEnvironmentVariable( DALI_WINDOW_HEIGHT, windowHeight ) )
+ if(GetEnvironmentVariable(DALI_WINDOW_WIDTH, windowWidth) && GetEnvironmentVariable(DALI_WINDOW_HEIGHT, windowHeight))
{
- mWindowWidth = windowWidth;
+ mWindowWidth = windowWidth;
mWindowHeight = windowHeight;
}
+ SetFromEnvironmentVariable(DALI_WINDOW_NAME, mWindowName);
+ SetFromEnvironmentVariable(DALI_WINDOW_CLASS_NAME, mWindowClassName);
- const char * windowName = GetCharEnvironmentVariable( DALI_WINDOW_NAME );
- if ( windowName )
- {
- mWindowName = windowName;
- }
+ SetFromEnvironmentVariable<int>(DALI_THREADING_MODE,
+ [&](int threadingMode) {
+ switch(threadingMode)
+ {
+ case ThreadingMode::COMBINED_UPDATE_RENDER:
+ {
+ mThreadingMode = static_cast<ThreadingMode::Type>(threadingMode);
+ break;
+ }
+ }
+ });
- const char * windowClassName = GetCharEnvironmentVariable( DALI_WINDOW_CLASS_NAME );
- if ( windowClassName )
- {
- mWindowClassName = windowClassName;
- }
+ SetFromEnvironmentVariable<int>(DALI_REFRESH_RATE, GreaterThan(mRenderRefreshRate, 1));
- int threadingMode(0);
- if ( GetIntegerEnvironmentVariable( DALI_THREADING_MODE, threadingMode ) )
- {
- switch( threadingMode )
- {
- case ThreadingMode::COMBINED_UPDATE_RENDER:
- {
- mThreadingMode = static_cast< ThreadingMode::Type >( threadingMode );
- break;
- }
- }
- }
+ SetFromEnvironmentVariable(DALI_ENV_MULTI_SAMPLING_LEVEL, mMultiSamplingLevel);
- int renderRefreshRate(0);
- if ( GetIntegerEnvironmentVariable( DALI_REFRESH_RATE, renderRefreshRate ) )
- {
- // Only change it if it's valid
- if( renderRefreshRate > 1 )
- {
- mRenderRefreshRate = renderRefreshRate;
- }
- }
+ SetFromEnvironmentVariable<int>(DALI_ENV_MAX_TEXTURE_SIZE, GreaterThan(mMaxTextureSize, 0));
- int multiSamplingLevel( 0 );
- if( GetIntegerEnvironmentVariable( DALI_ENV_MULTI_SAMPLING_LEVEL, multiSamplingLevel ) )
- {
- mMultiSamplingLevel = multiSamplingLevel;
- }
-
- int maxTextureSize( 0 );
- if( GetIntegerEnvironmentVariable( DALI_ENV_MAX_TEXTURE_SIZE, maxTextureSize ) )
- {
- if( maxTextureSize > 0 )
- {
- mMaxTextureSize = maxTextureSize;
- }
- }
-
- mRenderToFboInterval = GetIntegerEnvironmentVariable( DALI_RENDER_TO_FBO, 0u );
-
-
- int depthBufferRequired( -1 );
- if( GetIntegerEnvironmentVariable( DALI_ENV_DISABLE_DEPTH_BUFFER, depthBufferRequired ) )
- {
- if( depthBufferRequired > 0 )
- {
- mDepthBufferRequired = false;
- mStencilBufferRequired = false; // Disable stencil buffer as well
- }
- }
+ mRenderToFboInterval = GetEnvironmentVariable(DALI_RENDER_TO_FBO, 0u);
- int stencilBufferRequired( -1 );
- if( GetIntegerEnvironmentVariable( DALI_ENV_DISABLE_STENCIL_BUFFER, stencilBufferRequired ) )
- {
- if( stencilBufferRequired > 0 )
- {
- mStencilBufferRequired = false;
- }
- }
+ SetFromEnvironmentVariable<int>(DALI_ENV_DISABLE_DEPTH_BUFFER,
+ [&](int depthBufferRequired) {
+ if(depthBufferRequired > 0)
+ {
+ mDepthBufferRequired = false;
+ mStencilBufferRequired = false; // Disable stencil buffer as well
+ }
+ });
+ SetFromEnvironmentVariable<int>(DALI_ENV_DISABLE_STENCIL_BUFFER, DisableIfNonZero(mStencilBufferRequired));
- int partialUpdateRequired( -1 );
- if( GetIntegerEnvironmentVariable( DALI_ENV_ENABLE_PARTIAL_UPDATE, partialUpdateRequired ) )
- {
- if( partialUpdateRequired > 0 )
- {
- mPartialUpdateRequired = true;
- }
- }
+ SetFromEnvironmentVariable<int>(DALI_ENV_DISABLE_PARTIAL_UPDATE, DisableIfNonZero(mPartialUpdateRequired));
}
-} // Adaptor
+} // namespace Adaptor
-} // Internal
+} // namespace Internal
-} // Dali
+} // namespace Dali
projects / platform / core / uifw / dali-adaptor.git / blobdiff