X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=adaptors%2Fbase%2Fenvironment-options.cpp;h=0dbf6141252095fa4d017989596ca1282d9da588;hb=72f8ac7ca4e3d423796439090044a4e3154966d5;hp=118eb29fcc8966ea79ce8df32f8eed173bca8083;hpb=e54d4d1af5dfd8eeaa591f177367cff25cfeb8b2;p=platform%2Fcore%2Fuifw%2Fdali-adaptor.git diff --git a/adaptors/base/environment-options.cpp b/adaptors/base/environment-options.cpp index 118eb29..0dbf614 100644 --- a/adaptors/base/environment-options.cpp +++ b/adaptors/base/environment-options.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2014 Samsung Electronics Co., Ltd. + * Copyright (c) 2015 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. @@ -18,6 +18,14 @@ // CLASS HEADER #include "environment-options.h" +// EXTERNAL INCLUDES +#include +#include +#include + +// INTERNAL INCLUDES +#include + namespace Dali { @@ -30,13 +38,58 @@ namespace Adaptor namespace { const unsigned int DEFAULT_STATISTICS_LOG_FREQUENCY = 2; + +unsigned int GetIntegerEnvironmentVariable( const char* variable, unsigned int defaultValue ) +{ + const char* variableParameter = std::getenv(variable); + + // if the parameter exists convert it to an integer, else return the default value + unsigned int intValue = variableParameter ? std::atoi(variableParameter) : defaultValue; + return intValue; +} + +bool GetIntegerEnvironmentVariable( const char* variable, int& intValue ) +{ + const char* variableParameter = std::getenv(variable); + + if( !variableParameter ) + { + return false; + } + // if the parameter exists convert it to an integer, else return the default value + intValue = std::atoi(variableParameter); + return true; } + +bool GetFloatEnvironmentVariable( const char* variable, float& floatValue ) +{ + const char* variableParameter = std::getenv(variable); + + if( !variableParameter ) + { + return false; + } + // if the parameter exists convert it to an integer, else return the default value + floatValue = std::atof(variableParameter); + return true; +} + +const char * GetCharEnvironmentVariable( const char * variable ) +{ + return std::getenv( variable ); +} + +} // unnamed namespace + EnvironmentOptions::EnvironmentOptions() -: mNetworkControl(0), +: mWindowName(), + mWindowClassName(), + mNetworkControl(0), mFpsFrequency(0), mUpdateStatusFrequency(0), + mObjectProfilerInterval( 0 ), mPerformanceStatsLevel(0), - mPerformanceStatsFrequency( DEFAULT_STATISTICS_LOG_FREQUENCY), + mPerformanceStatsFrequency( DEFAULT_STATISTICS_LOG_FREQUENCY ), mPerformanceTimeStampOutput(0), mPanGestureLoggingLevel(0), mPanGesturePredictionMode(-1), @@ -48,34 +101,25 @@ EnvironmentOptions::EnvironmentOptions() mPanGestureSmoothingAmount(-1.0f), mPanMinimumDistance(-1), mPanMinimumEvents(-1), - mGlesCallTime(0), + mGlesCallTime( 0 ), mWindowWidth( 0 ), mWindowHeight( 0 ), + mThreadingMode( ThreadingMode::COMBINED_UPDATE_RENDER ), + mRenderRefreshRate( 1 ), + mGlesCallAccumulate( false ), + mMultiSamplingLevel( 0 ), mLogFunction( NULL ) { + ParseEnvironmentOptions(); } EnvironmentOptions::~EnvironmentOptions() { } -void EnvironmentOptions::SetLogOptions( const Dali::Integration::Log::LogFunction& logFunction, - unsigned int networkControl, - unsigned int logFrameRateFrequency, - unsigned int logupdateStatusFrequency, - unsigned int logPerformanceStats, - unsigned int logPerformanceStatsFrequency, - unsigned int performanceTimeStampOutput, - unsigned int logPanGestureLevel ) +void EnvironmentOptions::SetLogFunction( const Dali::Integration::Log::LogFunction& logFunction ) { mLogFunction = logFunction; - mNetworkControl = networkControl; - mFpsFrequency = logFrameRateFrequency; - mUpdateStatusFrequency = logupdateStatusFrequency; - mPerformanceStatsLevel = logPerformanceStats; - mPerformanceStatsFrequency = logPerformanceStatsFrequency; - mPerformanceTimeStampOutput= performanceTimeStampOutput; - mPanGestureLoggingLevel = logPanGestureLevel; } void EnvironmentOptions::InstallLogFunction() const @@ -102,6 +146,11 @@ unsigned int EnvironmentOptions::GetUpdateStatusLoggingFrequency() const return mUpdateStatusFrequency; } +unsigned int EnvironmentOptions::GetObjectProfilerInterval() const +{ + return mObjectProfilerInterval; +} + unsigned int EnvironmentOptions::GetPerformanceStatsLoggingOptions() const { return mPerformanceStatsLevel; @@ -175,78 +224,195 @@ unsigned int EnvironmentOptions::GetWindowHeight() const return mWindowHeight; } -void EnvironmentOptions::SetPanGesturePredictionMode( unsigned int mode ) -{ - mPanGesturePredictionMode = mode; -} - -void EnvironmentOptions::SetPanGesturePredictionAmount( unsigned int amount ) -{ - mPanGesturePredictionAmount = amount; -} - -void EnvironmentOptions::SetPanGestureMaximumPredictionAmount( unsigned int amount ) -{ - mPanGestureMaxPredictionAmount = amount; -} - -void EnvironmentOptions::SetPanGestureMinimumPredictionAmount( unsigned int amount ) -{ - mPanGestureMinPredictionAmount = amount; -} - -void EnvironmentOptions::SetPanGesturePredictionAmountAdjustment( unsigned int amount ) -{ - mPanGesturePredictionAmountAdjustment = amount; -} - -void EnvironmentOptions::SetPanGestureSmoothingMode( unsigned int mode ) -{ - mPanGestureSmoothingMode = mode; -} - -void EnvironmentOptions::SetPanGestureSmoothingAmount( float amount ) +int EnvironmentOptions::GetGlesCallTime() const { - mPanGestureSmoothingAmount = amount; + return mGlesCallTime; } -void EnvironmentOptions::SetMinimumPanDistance( int distance ) +bool EnvironmentOptions::GetGlesCallAccumulate() const { - mPanMinimumDistance = distance; + return mGlesCallAccumulate; } -void EnvironmentOptions::SetMinimumPanEvents( int events ) +const std::string& EnvironmentOptions::GetWindowName() const { - mPanMinimumEvents = events; + return mWindowName; } -void EnvironmentOptions::SetGlesCallTime( int time ) +const std::string& EnvironmentOptions::GetWindowClassName() const { - mGlesCallTime = time; + return mWindowClassName; } -int EnvironmentOptions::GetGlesCallTime() const +ThreadingMode::Type EnvironmentOptions::GetThreadingMode() const { - return mGlesCallTime; + return mThreadingMode; } -void EnvironmentOptions::SetWindowWidth( int width ) +unsigned int EnvironmentOptions::GetRenderRefreshRate() const { - mWindowWidth = width; + return mRenderRefreshRate; } -void EnvironmentOptions::SetWindowHeight( int height ) +unsigned int EnvironmentOptions::GetMultiSamplingLevel() const { - mWindowHeight = height; + return mMultiSamplingLevel; } bool EnvironmentOptions::PerformanceServerRequired() const { - return ( (GetPerformanceStatsLoggingOptions() > 0) || + return ( ( GetPerformanceStatsLoggingOptions() > 0) || ( GetPerformanceTimeStampOutput() > 0 ) || ( GetNetworkControlMode() > 0) ); } +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 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; + } + + 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; + } + + int windowWidth(0), windowHeight(0); + if ( GetIntegerEnvironmentVariable( DALI_WINDOW_WIDTH, windowWidth ) && GetIntegerEnvironmentVariable( DALI_WINDOW_HEIGHT, windowHeight ) ) + { + mWindowWidth = windowWidth; + mWindowHeight = windowHeight; + } + + const char * windowName = GetCharEnvironmentVariable( DALI_WINDOW_NAME ); + if ( windowName ) + { + mWindowName = windowName; + } + + const char * windowClassName = GetCharEnvironmentVariable( DALI_WINDOW_CLASS_NAME ); + if ( windowClassName ) + { + mWindowClassName = windowClassName; + } + + int threadingMode(0); + if ( GetIntegerEnvironmentVariable( DALI_THREADING_MODE, threadingMode ) ) + { + switch( threadingMode ) + { + case ThreadingMode::SEPARATE_UPDATE_RENDER: + case ThreadingMode::COMBINED_UPDATE_RENDER: + case ThreadingMode::SINGLE_THREADED: + { + mThreadingMode = static_cast< ThreadingMode::Type >( threadingMode ); + break; + } + } + } + + int renderRefreshRate(0); + if ( GetIntegerEnvironmentVariable( DALI_REFRESH_RATE, renderRefreshRate ) ) + { + // Only change it if it's valid + if( renderRefreshRate > 1 ) + { + mRenderRefreshRate = renderRefreshRate; + } + } + + int multiSamplingLevel( 0 ); + if( GetIntegerEnvironmentVariable( DALI_ENV_MULTI_SAMPLING_LEVEL, multiSamplingLevel ) ) + { + if( multiSamplingLevel > 0 ) + { + mMultiSamplingLevel = multiSamplingLevel; + } + } +} + } // Adaptor } // Internal