atria-soft/ewol
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[DEV] update to echrono

Browse Source
This commit is contained in:
Edouard DUPIN 2016-10-14 21:13:39 +02:00
parent b451e97293
commit 3cc6e1577e
14 changed files with 71 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
ewol/context/Context.cpp
View File

@ -20,7 +20,7 @@
#include <gale/renderer/openGL/openGL.hpp> #include <gale/renderer/openGL/openGL.hpp>
#include <gale/Dimension.hpp> #include <gale/Dimension.hpp>
#include <ewol/translate.hpp> #include <etranslate/etranslate.hpp>
#include <ewol/object/Object.hpp> #include <ewol/object/Object.hpp>
#include <ewol/object/Manager.hpp> #include <ewol/object/Manager.hpp>
#include <ewol/widget/Widget.hpp> #include <ewol/widget/Widget.hpp>
@ -65,8 +65,8 @@ void ewol::Context::inputEventUnGrabPointer() {
void ewol::Context::onCreate(gale::Context& _context) { void ewol::Context::onCreate(gale::Context& _context) {
EWOL_INFO(" == > Ewol system create (BEGIN)"); EWOL_INFO(" == > Ewol system create (BEGIN)");
// Add basic ewol translation: // Add basic ewol translation:
ewol::translate::addPath("ewol", "{ewol}DATA:translate/ewol/"); etranslate::addPath("ewol", "{ewol}DATA:translate/ewol/");
ewol::translate::autoDetectLanguage(); etranslate::autoDetectLanguage();
// By default we set 2 themes (1 color and 1 shape ...) : // By default we set 2 themes (1 color and 1 shape ...) :
etk::theme::setNameDefault("GUI", "shape/square/"); etk::theme::setNameDefault("GUI", "shape/square/");
etk::theme::setNameDefault("COLOR", "color/black/"); etk::theme::setNameDefault("COLOR", "color/black/");
@ -335,7 +335,7 @@ void ewol::Context::requestUpdateSize() {
context.requestUpdateSize(); context.requestUpdateSize();
} }
void ewol::Context::onPeriod(int64_t _time) { void ewol::Context::onPeriod(const echrono::Clock& _time) {
m_objectManager.timeCall(_time); m_objectManager.timeCall(_time);
} }

2
ewol/context/Context.hpp
View File

@ -148,7 +148,7 @@ namespace ewol {
* @brief Request a display after call a resize * @brief Request a display after call a resize
*/ */
void requestUpdateSize(); void requestUpdateSize();
void onPeriod(int64_t _time) override; void onPeriod(const echrono::Clock& _time) override;
}; };
/** /**
* @brief From everyware in the program, we can get the context inteface. * @brief From everyware in the program, we can get the context inteface.

10
ewol/context/InputManager.cpp
View File

@ -22,10 +22,10 @@
//#define EVENT_DEBUG EWOL_DEBUG //#define EVENT_DEBUG EWOL_DEBUG
void ewol::context::InputManager::calculateLimit() { void ewol::context::InputManager::calculateLimit() {
m_eventInputLimit.sepatateTime = 300000; // µs m_eventInputLimit.sepatateTime = echrono::Duration(std::chrono::milliseconds(300));
m_eventInputLimit.DpiOffset = m_dpi*100; m_eventInputLimit.DpiOffset = m_dpi*100;
m_eventMouseLimit.sepatateTime = 300000; // µs m_eventMouseLimit.sepatateTime = echrono::Duration(std::chrono::milliseconds(300));
m_eventMouseLimit.DpiOffset = (float)m_dpi*(float)0.1; m_eventMouseLimit.DpiOffset = float(m_dpi)*0.1f;
} }
void ewol::context::InputManager::setDpi(int32_t newDPI) { void ewol::context::InputManager::setDpi(int32_t newDPI) {
@ -76,7 +76,7 @@ void ewol::context::InputManager::cleanElement(InputPoperty *_eventTable,
//EWOL_INFO("CleanElement[" << idInput << "] = @" << (int64_t)eventTable); //EWOL_INFO("CleanElement[" << idInput << "] = @" << (int64_t)eventTable);
_eventTable[_idInput].isUsed = false; _eventTable[_idInput].isUsed = false;
_eventTable[_idInput].destinationInputId = 0; _eventTable[_idInput].destinationInputId = 0;
_eventTable[_idInput].lastTimeEvent = 0; _eventTable[_idInput].lastTimeEvent.reset();
_eventTable[_idInput].curentWidgetEvent.reset(); _eventTable[_idInput].curentWidgetEvent.reset();
_eventTable[_idInput].origin.setValue(0,0); _eventTable[_idInput].origin.setValue(0,0);
_eventTable[_idInput].size.setValue(99999999,99999999); _eventTable[_idInput].size.setValue(99999999,99999999);
@ -342,7 +342,7 @@ void ewol::context::InputManager::state(enum gale::key::type _type,
return; return;
} }
// get the curent time ... // get the curent time ...
int64_t currentTime = ewol::getTime(); echrono::Clock currentTime = echrono::Clock::now();
ewol::widget::WindowsShared tmpWindows = m_context.getWindows(); ewol::widget::WindowsShared tmpWindows = m_context.getWindows();
if (_isDown == true) { if (_isDown == true) {

4
ewol/context/InputManager.hpp
View File

@ -18,7 +18,7 @@ namespace ewol {
public: public:
bool isUsed; bool isUsed;
int32_t destinationInputId; int32_t destinationInputId;
int64_t lastTimeEvent; echrono::Clock lastTimeEvent;
ewol::WidgetWeak curentWidgetEvent; ewol::WidgetWeak curentWidgetEvent;
vec2 origin; vec2 origin;
vec2 size; vec2 size;
@ -35,7 +35,7 @@ namespace ewol {
*/ */
class InputLimit { class InputLimit {
public: public:
int32_t sepatateTime; echrono::Duration sepatateTime;
int32_t DpiOffset; int32_t DpiOffset;
}; };
class Context; class Context;

50
ewol/event/Time.hpp
View File

@ -6,20 +6,22 @@
#pragma once #pragma once
#include <etk/types.hpp> #include <etk/types.hpp>
#include <echrono/Clock.hpp>
#include <echrono/Duration.hpp>
namespace ewol { namespace ewol {
namespace event { namespace event {
class Time { class Time {
private: private:
int64_t m_timeSystem; //!< Current system time (micro-second) echrono::Clock m_timeSystem; //!< Current system time (micro-second)
int64_t m_timeUpAppl; //!< Current application wake up-time (micro-second) echrono::Clock m_timeUpAppl; //!< Current application wake up-time (micro-second)
float m_timeDelta; //!< Time from the last cycle call of the system (main appl tick) (second) echrono::Duration m_timeDelta; //!< Time from the last cycle call of the system (main appl tick) (second)
float m_timeDeltaCall; //!< Time from the last call (when we can manage periodic call with specifying periode) (second) echrono::Duration m_timeDeltaCall; //!< Time from the last call (when we can manage periodic call with specifying periode) (second)
public: public:
Time(int64_t _timeSystem, Time(const echrono::Clock& _timeSystem,
int64_t _timeUpAppl, const echrono::Clock& _timeUpAppl,
float _timeDelta, const echrono::Duration& _timeDelta,
float _timeDeltaCall) : const echrono::Duration& _timeDeltaCall) :
m_timeSystem(_timeSystem), m_timeSystem(_timeSystem),
m_timeUpAppl(_timeUpAppl), m_timeUpAppl(_timeUpAppl),
m_timeDelta(_timeDelta), m_timeDelta(_timeDelta),
@ -27,32 +29,38 @@ namespace ewol {
}; };
public: public:
void setTime(int64_t _timeSystem) { void setTime(const echrono::Clock& _timeSystem) {
m_timeSystem=_timeSystem; m_timeSystem = _timeSystem;
}; };
inline int64_t getTime() const { inline const echrono::Clock& getTime() const {
return m_timeSystem; return m_timeSystem;
}; };
void setApplWakeUpTime(int64_t _timeUpAppl) { void setApplWakeUpTime(const echrono::Clock& _timeUpAppl) {
m_timeUpAppl=_timeUpAppl; m_timeUpAppl = _timeUpAppl;
}; };
inline int64_t getApplWakeUpTime() const { inline const echrono::Clock& getApplWakeUpTime() const {
return m_timeUpAppl; return m_timeUpAppl;
}; };
inline int64_t getApplUpTime() const { inline echrono::Duration getApplUpTime() const {
return m_timeSystem-m_timeUpAppl; return m_timeSystem-m_timeUpAppl;
}; };
void setDelta(float _timeDelta) { void setDelta(const echrono::Duration& _timeDelta) {
m_timeDelta=_timeDelta; m_timeDelta = _timeDelta;
}; };
inline float getDelta() const { inline const echrono::Duration& getDeltaDuration() const {
return m_timeDelta; return m_timeDelta;
}; };
void setDeltaCall(float _timeDeltaCall) { inline float getDelta() const {
m_timeDeltaCall=_timeDeltaCall; return m_timeDelta.toSeconds();
};
void setDeltaCall(const echrono::Duration& _timeDeltaCall) {
m_timeDeltaCall = _timeDeltaCall;
};
inline const echrono::Duration& getDeltaCallDuration() const {
return m_timeDeltaCall;
}; };
inline float getDeltaCall() const { inline float getDeltaCall() const {
return m_timeDeltaCall; return m_timeDeltaCall.toSeconds();
}; };
}; };
std::ostream& operator <<(std::ostream& _os, const ewol::event::Time& _obj); std::ostream& operator <<(std::ostream& _os, const ewol::event::Time& _obj);

28
ewol/ewol.cpp
View File

@ -17,36 +17,10 @@
#define EWOL_VERSION "0.0.0" #define EWOL_VERSION "0.0.0"
#endif #endif
std::string ewol::getCompilationMode() {
#ifdef MODE_RELEASE
return "Release";
#else
return "Debug";
#endif
}
std::string ewol::getBoardType() {
#ifdef __TARGET_OS__Linux
return "Linux";
#elif defined(__TARGET_OS__Android)
return "Android";
#elif defined(__TARGET_OS__Windows)
return "Windows";
#elif defined(__TARGET_OS__IOs)
return "IOs";
#elif defined(__TARGET_OS__MacOs)
return "MacOs";
#else
return "Unknown";
#endif
}
std::string ewol::getVersion() { std::string ewol::getVersion() {
return EWOL_VERSION; return EWOL_VERSION;
} }
int64_t ewol::getTime() {
return gale::getTime();
}
int32_t ewol::run(ewol::context::Application* _application, int32_t ewol::run(ewol::context::Application* _application,
int32_t _argc, int32_t _argc,

21
ewol/ewol.hpp
View File

@ -21,29 +21,10 @@ namespace ewol {
* @param[in] _argv Standard argv * @param[in] _argv Standard argv
* @return normal error int for the application error management * @return normal error int for the application error management
*/ */
int32_t run(ewol::context::Application* _application, int32_t _argc = 0, const char* _argv[] = NULL); int32_t run(ewol::context::Application* _application, int32_t _argc = 0, const char* _argv[] = nullptr);
/** /**
* @brief get EWOL version * @brief get EWOL version
* @return The string that describe ewol version * @return The string that describe ewol version
*/ */
std::string getVersion(); std::string getVersion();
/**
* @brief get current time in us...
* @return The current time
* @note is implemented by the OS implementation cf renderer/X11/...
*/
// TODO : Remove ...
int64_t getTime();
/**
* @brief get compilation mode (release/debug)
* @return the string of the mode of commpilation
*/
// TODO : Remove ...
std::string getCompilationMode();
/**
* @brief get the board type (Android/Linux/MacOs/...)
* @return the string of the mode of commpilation
*/
// TODO : Remove ...
std::string getBoardType();
}; };

14
ewol/object/Manager.cpp
View File

@ -18,8 +18,8 @@ ewol::object::Manager::Manager(ewol::Context& _context) :
EWOL_DEBUG(" == > init Object-Manager"); EWOL_DEBUG(" == > init Object-Manager");
periodicCall.setPeriodic(true); periodicCall.setPeriodic(true);
// set the basic time properties : // set the basic time properties :
m_applWakeUpTime = ewol::getTime(); m_applWakeUpTime = echrono::Clock::now();
m_lastPeriodicCallTime = ewol::getTime(); m_lastPeriodicCallTime = echrono::Clock::now();
} }
ewol::object::Manager::~Manager() { ewol::object::Manager::~Manager() {
@ -30,7 +30,7 @@ ewol::object::Manager::~Manager() {
EWOL_ERROR("Must not have anymore eObject !!!"); EWOL_ERROR("Must not have anymore eObject !!!");
hasError = true; hasError = true;
} }
if (true == hasError) { if (hasError == true) {
EWOL_ERROR("Check if the function UnInit has been called !!!"); EWOL_ERROR("Check if the function UnInit has been called !!!");
} }
displayListObject(); displayListObject();
@ -136,19 +136,19 @@ void ewol::object::Manager::workerRemove(const ewol::ObjectShared& _worker) {
} }
} }
void ewol::object::Manager::timeCall(int64_t _localTime) { void ewol::object::Manager::timeCall(const echrono::Clock& _localTime) {
std::unique_lock<std::recursive_mutex> lock(m_mutex); std::unique_lock<std::recursive_mutex> lock(m_mutex);
int64_t previousTime = m_lastPeriodicCallTime; echrono::Clock previousTime = m_lastPeriodicCallTime;
m_lastPeriodicCallTime = _localTime; m_lastPeriodicCallTime = _localTime;
if (periodicCall.size() <= 0) { if (periodicCall.size() <= 0) {
return; return;
} }
float deltaTime = (float)(_localTime - previousTime)/1000000.0; echrono::Duration deltaTime = _localTime - previousTime;
ewol::event::Time myTime(_localTime, m_applWakeUpTime, deltaTime, deltaTime); ewol::event::Time myTime(_localTime, m_applWakeUpTime, deltaTime, deltaTime);
periodicCall.emit(myTime); periodicCall.emit(myTime);
} }
void ewol::object::Manager::timeCallResume(int64_t _localTime) { void ewol::object::Manager::timeCallResume(const echrono::Clock& _localTime) {
std::unique_lock<std::recursive_mutex> lock(m_mutex); std::unique_lock<std::recursive_mutex> lock(m_mutex);
m_lastPeriodicCallTime = _localTime; m_lastPeriodicCallTime = _localTime;
} }

10
ewol/object/Manager.hpp
View File

@ -9,6 +9,8 @@
#include <ewol/object/Object.hpp> #include <ewol/object/Object.hpp>
#include <esignal/Signal.hpp> #include <esignal/Signal.hpp>
#include <ewol/event/Time.hpp> #include <ewol/event/Time.hpp>
#include <echrono/Steady.hpp>
#include <echrono/Duration.hpp>
namespace ewol { namespace ewol {
class Context; class Context;
@ -78,19 +80,19 @@ namespace ewol {
public: public:
esignal::Signal<ewol::event::Time> periodicCall; esignal::Signal<ewol::event::Time> periodicCall;
private: private:
int64_t m_applWakeUpTime; //!< Time of the application initialize echrono::Clock m_applWakeUpTime; //!< Time of the application initialize
int64_t m_lastPeriodicCallTime; //!< last call time ... echrono::Clock m_lastPeriodicCallTime; //!< last call time ...
public: // ewol system internal : public: // ewol system internal :
/** /**
* @brief Call every time we can with the current time * @brief Call every time we can with the current time
* @param[in] _localTime Current system Time. * @param[in] _localTime Current system Time.
*/ */
void timeCall(int64_t _localTime); void timeCall(const echrono::Clock& _localTime);
/** /**
* @brief If the application is suspended The Ewol Object manager does not know it, just call this to update delta call * @brief If the application is suspended The Ewol Object manager does not know it, just call this to update delta call
* @param[in] _localTime Current system Time. * @param[in] _localTime Current system Time.
*/ */
void timeCallResume(int64_t _localTime); void timeCallResume(const echrono::Clock& _localTime);
/** /**
* @breif check if the Interface have some user that request a periodic call * @breif check if the Interface have some user that request a periodic call
* @return true, have some periodic event... * @return true, have some periodic event...

18
ewol/translate.cpp
View File

@ -5,7 +5,7 @@
*/ */
#include <ewol/debug.hpp> #include <ewol/debug.hpp>
#include <ewol/translate.hpp> #include <etranslate/etranslate.hpp>
#include <map> #include <map>
#include <etk/os/FSNode.hpp> #include <etk/os/FSNode.hpp>
#include <ejson/ejson.hpp> #include <ejson/ejson.hpp>
@ -213,31 +213,31 @@ static LocalInstanceTranslation& getInstanceTranslation() {
return g_val; return g_val;
} }
void ewol::translate::addPath(const std::string& _lib, const std::string& _path, bool _major) { void etranslate::addPath(const std::string& _lib, const std::string& _path, bool _major) {
getInstanceTranslation().addPath(_lib, _path, _major); getInstanceTranslation().addPath(_lib, _path, _major);
} }
const std::string& ewol::translate::getPaths(const std::string& _lib) { const std::string& etranslate::getPaths(const std::string& _lib) {
return getInstanceTranslation().getPaths(_lib); return getInstanceTranslation().getPaths(_lib);
} }
void ewol::translate::setLanguageDefault(const std::string& _lang) { void etranslate::setLanguageDefault(const std::string& _lang) {
getInstanceTranslation().setLanguageDefault(_lang); getInstanceTranslation().setLanguageDefault(_lang);
} }
const std::string& ewol::translate::getLanguageDefault() { const std::string& etranslate::getLanguageDefault() {
return getInstanceTranslation().getLanguageDefault(); return getInstanceTranslation().getLanguageDefault();
} }
void ewol::translate::setLanguage(const std::string& _lang) { void etranslate::setLanguage(const std::string& _lang) {
getInstanceTranslation().setLanguage(_lang); getInstanceTranslation().setLanguage(_lang);
} }
const std::string& ewol::translate::getLanguage() { const std::string& etranslate::getLanguage() {
return getInstanceTranslation().getLanguage(); return getInstanceTranslation().getLanguage();
} }
void ewol::translate::autoDetectLanguage() { void etranslate::autoDetectLanguage() {
EWOL_VERBOSE("Auto-detect language of system"); EWOL_VERBOSE("Auto-detect language of system");
std::string nonameLocalName; std::string nonameLocalName;
std::string userLocalName; std::string userLocalName;
@ -292,7 +292,7 @@ void ewol::translate::autoDetectLanguage() {
#endif #endif
} }
std::string ewol::translate::get(const std::string& _instance) { std::string etranslate::get(const std::string& _instance) {
return getInstanceTranslation().get(_instance); return getInstanceTranslation().get(_instance);
} }

2
ewol/translate.hpp
View File

@ -70,4 +70,4 @@ namespace ewol {
}; };
}; };
// Here we define a simple macro to Translate all string simply: // Here we define a simple macro to Translate all string simply:
#define TRANSLATE(a) ewol::translate::get(a) #define TRANSLATE(a) etranslate::get(a)

2
ewol/widget/Label.cpp
View File

@ -149,7 +149,7 @@ bool ewol::widget::Label::loadXML(const exml::Element& _node) {
void ewol::widget::Label::onChangePropertyValue() { void ewol::widget::Label::onChangePropertyValue() {
if (*propertyAutoTranslate == true) { if (*propertyAutoTranslate == true) {
m_value = etk::to_u32string(ewol::translate::get(*propertyValue)); m_value = etk::to_u32string(etranslate::get(*propertyValue));
} else { } else {
m_value = etk::to_u32string(*propertyValue); m_value = etk::to_u32string(*propertyValue);
} }

2
ewol/widget/Widget.hpp
View File

@ -29,7 +29,7 @@ namespace ewol {
#include <ewol/event/Input.hpp> #include <ewol/event/Input.hpp>
#include <ewol/event/Entry.hpp> #include <ewol/event/Entry.hpp>
#include <ewol/event/Time.hpp> #include <ewol/event/Time.hpp>
#include <ewol/translate.hpp> #include <etranslate/etranslate.hpp>
#include <esignal/Signal.hpp> #include <esignal/Signal.hpp>
#include <ewol/DrawProperty.hpp> #include <ewol/DrawProperty.hpp>
#include <ewol/gravity.hpp> #include <ewol/gravity.hpp>

6
lutin_ewol.py
View File

@ -32,7 +32,6 @@ def configure(target, my_module):
'ewol/ewol.cpp', 'ewol/ewol.cpp',
'ewol/debug.cpp', 'ewol/debug.cpp',
'ewol/Padding.cpp', 'ewol/Padding.cpp',
'ewol/translate.cpp',
'ewol/DrawProperty.cpp', 'ewol/DrawProperty.cpp',
'ewol/gravity.cpp' 'ewol/gravity.cpp'
]) ])
@ -40,7 +39,6 @@ def configure(target, my_module):
'ewol/debug.hpp', # TODO : Remove this ... 'ewol/debug.hpp', # TODO : Remove this ...
'ewol/ewol.hpp', 'ewol/ewol.hpp',
'ewol/Padding.hpp', 'ewol/Padding.hpp',
'ewol/translate.hpp',
'ewol/DrawProperty.hpp', 'ewol/DrawProperty.hpp',
'ewol/gravity.hpp' 'ewol/gravity.hpp'
]) ])
@ -251,7 +249,9 @@ def configure(target, my_module):
'exml', 'exml',
'ejson', 'ejson',
'egami', 'egami',
'edtaa3']) 'edtaa3',
'etranslate',
])
my_module.add_path(".") my_module.add_path(".")