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

[DEV] start clean eSystem

Browse Source
This commit is contained in:
Edouard DUPIN 2012-11-26 21:53:04 +01:00
parent 50db842954
commit 4f296ba2b9
14 changed files with 258 additions and 324 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
build

@ -1 +1 @@
Subproject commit d207607bac4827ecc6dd02ccb08059ec9d191e4f
Subproject commit a4e1c141f04e96da02edfa64644a85ab332eadad

6
sources/Android.mk
View File

@ -27,8 +27,8 @@ LOCAL_EXPORT_LDLIBS := -lGLESv2
LOCAL_EXPORT_LDLIBS += -ldl -llog
FILE_ABSTRACTION:=$(LOCAL_PATH)/ewol/os/gui.Android.base.cpp
FILE_ABSTRACTION_DEST:=ewol/os/gui.Android.tmp.cpp
FILE_ABSTRACTION:=$(LOCAL_PATH)/ewol/renderer/os/gui.Android.base.cpp
FILE_ABSTRACTION_DEST:=ewol/renderer/os/gui.Android.tmp.cpp
EWOL_TMP_PATH:=$(LOCAL_PATH)
@ -51,7 +51,7 @@ LOCAL_PREREQUISITES := $(FILE_ABSTRACTION_DEST)
# load the common sources file of the platform
include $(LOCAL_PATH)/file.mk
LOCAL_SRC_FILES := ewol/os/gui.Android.cpp $(FILE_LIST)
LOCAL_SRC_FILES := ewol/renderer/os/gui.Android.cpp $(FILE_LIST)
include $(BUILD_STATIC_LIBRARY)

2
sources/Windows.mk
View File

@ -26,7 +26,7 @@ LOCAL_CFLAGS := -Wno-write-strings \
# load the common sources file of the platform
include $(LOCAL_PATH)/file.mk
LOCAL_SRC_FILES := $(FILE_LIST) ewol/os/gui.Windows.cpp
LOCAL_SRC_FILES := $(FILE_LIST) ewol/renderer/os/gui.Windows.cpp

3
sources/ewol/commandLine.cpp
View File

@ -6,6 +6,7 @@
* @license BSD v3 (see license file)
*/
#include <ewol/debug.h>
#include <ewol/commandLine.h>
#include <etk/Vector.h>
@ -18,7 +19,9 @@ static etk::Vector<etk::UString> listArgs;
void ewol::commandLine::Clean(void)
{
EWOL_DEBUG("Clean commandLine (START)");
listArgs.Clear();
EWOL_DEBUG("Clean commandLine (END)");
}
int32_t ewol::commandLine::Size(void)

33
sources/ewol/ewol.cpp
View File

@ -11,6 +11,7 @@
#include <ewol/renderer/os/eSystem.h>
#include <ewol/renderer/os/gui.h>
#include <ewol/commandLine.h>
#undef __class__
#define __class__ "ewol"
@ -18,8 +19,38 @@
int32_t ewol::Run(int32_t argc, const char* argv[])
{
EWOL_DEBUG("Store commangLine in the specific system");
ewol::commandLine::Clean();
for( int32_t i=1 ; i<argc; i++) {
EWOL_INFO("commandLine : \"" << argv[i] << "\"" );
if (0==strncmp("-l0", argv[i], 256)) {
GeneralDebugSetLevel(etk::LOG_LEVEL_NONE);
} else if (0==strncmp("-l1", argv[i], 256)) {
GeneralDebugSetLevel(etk::LOG_LEVEL_CRITICAL);
} else if (0==strncmp("-l2", argv[i], 256)) {
GeneralDebugSetLevel(etk::LOG_LEVEL_ERROR);
} else if (0==strncmp("-l3", argv[i], 256)) {
GeneralDebugSetLevel(etk::LOG_LEVEL_WARNING);
} else if (0==strncmp("-l4", argv[i], 256)) {
GeneralDebugSetLevel(etk::LOG_LEVEL_INFO);
} else if (0==strncmp("-l5", argv[i], 256)) {
GeneralDebugSetLevel(etk::LOG_LEVEL_DEBUG);
} else if( 0==strncmp("-l6", argv[i], 256)
|| 0==strncmp("-l7", argv[i], 256)
|| 0==strncmp("-l8", argv[i], 256)
|| 0==strncmp("-l9", argv[i], 256)) {
GeneralDebugSetLevel(etk::LOG_LEVEL_VERBOSE);
} else {
etk::UString tmpString(argv[i]);
ewol::commandLine::Add(tmpString);
}
}
// call standard RUN ...
return guiInterface::main(argc, argv);
int32_t error = guiInterface::main(argc, argv);
ewol::commandLine::Clean();
return error;
}

37
sources/ewol/key.h
View File

@ -104,27 +104,26 @@ namespace ewol
class SpecialKey {
public:
unsigned capLock : 1;
unsigned shift : 1;
unsigned ctrl : 1;
unsigned meta : 1;
unsigned alt : 1;
unsigned altGr : 1;
unsigned verNum : 1;
unsigned insert : 1;
union {
uint32_t value;
struct {
unsigned capLock : 1;
unsigned shift : 1;
unsigned ctrl : 1;
unsigned meta : 1;
unsigned alt : 1;
unsigned altGr : 1;
unsigned verNum : 1;
unsigned insert : 1;
};
};
SpecialKey(void) :
value(0)
{
}
};
/*
SpecialKey(void)
{
capLock = false;
shift = false;
ctrl = false;
meta = false;
alt = false;
altGr = false;
verNum = false;
insert = false;
}
bool IsSetCapsLock(void)
{
return capLock;

230
sources/ewol/renderer/os/eSystem.cpp
View File

@ -40,7 +40,8 @@ void eSystem::InputEventTransfertWidget(ewol::Widget* source, ewol::Widget* dest
}
enum {
typedef enum {
THREAD_NONE,
THREAD_INIT,
THREAD_RECALCULATE_SIZE,
THREAD_RESIZE,
@ -54,37 +55,44 @@ enum {
THREAD_KEYBORAD_MOVE,
THREAD_CLIPBOARD_ARRIVE,
};
} theadMessage_te;
#include <unistd.h>
typedef struct {
int w;
int h;
} eventResize_ts;
typedef struct {
ewol::keyEvent::type_te type;
int pointerID;
bool state;
float x;
float y;
} eventInput_ts;
typedef struct {
int32_t TypeMessage;
union {
class eSystemMessage {
public :
// specify the message type
theadMessage_te TypeMessage;
// can not set a union ...
ewol::clipBoard::clipboardListe_te clipboardID;
eventResize_ts resize;
eventInput_ts input;
eSystem::keyboardMove_ts keyboardMove;
eSystem::keyboardKey_ts keyboardKey;
};
} eSystemMessage_ts;
// InputId
ewol::keyEvent::type_te inputType;
int32_t inputId;
// generic dimentions
etk::Vector2D<float> dimention;
// keyboard events :
bool stateIsDown;
uniChar_t keyboardChar;
ewol::keyEvent::keyboard_te keyboardMove;
ewol::SpecialKey keyboardSpecial;
eSystemMessage(void) :
TypeMessage(THREAD_NONE),
clipboardID(ewol::clipBoard::clipboardStd),
inputType(ewol::keyEvent::typeUnknow),
inputId(-1),
dimention(0,0),
stateIsDown(false),
keyboardChar(0),
keyboardMove(ewol::keyEvent::keyboardUnknow)
{
}
};
// deblare the message system
static etk::MessageFifo<eSystemMessage_ts> l_msgSystem;
static etk::MessageFifo<eSystemMessage> l_msgSystem;
static bool requestEndProcessing = false;
@ -92,7 +100,7 @@ void ewolProcessEvents(void)
{
int32_t nbEvent = 0;
//EWOL_DEBUG(" ******** Event");
eSystemMessage_ts data;
eSystemMessage data;
while (l_msgSystem.Count()>0)
{
nbEvent++;
@ -108,83 +116,52 @@ void ewolProcessEvents(void)
break;
case THREAD_RESIZE:
//EWOL_DEBUG("Receive MSG : THREAD_RESIZE");
windowsSize.x = data.resize.w;
windowsSize.y = data.resize.h;
windowsSize.x = data.dimention.x;
windowsSize.y = data.dimention.y;
eSystem::ForceRedrawAll();
break;
case THREAD_INPUT_MOTION:
//EWOL_DEBUG("Receive MSG : THREAD_INPUT_MOTION");
{
etk::Vector2D<float> pos;
pos.x = data.input.x;
pos.y = data.input.y;
l_managementInput.Motion(data.input.type, data.input.pointerID, pos);
}
l_managementInput.Motion(data.inputType, data.inputId, data.dimention);
break;
case THREAD_INPUT_STATE:
//EWOL_DEBUG("Receive MSG : THREAD_INPUT_STATE");
{
etk::Vector2D<float> pos;
pos.x = data.input.x;
pos.y = data.input.y;
l_managementInput.State(data.input.type, data.input.pointerID, data.input.state, pos);
}
l_managementInput.State(data.inputType, data.inputId, data.stateIsDown, data.dimention);
break;
case THREAD_KEYBORAD_KEY:
//EWOL_DEBUG("Receive MSG : THREAD_KEYBORAD_KEY");
{
ewol::SpecialKey& specialCurrentKey = ewol::GetCurrentSpecialKeyStatus();
specialCurrentKey = data.keyboardKey.special;
if (NULL != windowsCurrent) {
if (false==windowsCurrent->OnEventShortCut(data.keyboardKey.special,
data.keyboardKey.myChar,
ewol::keyEvent::keyboardUnknow,
data.keyboardKey.isDown)) {
// Get the current Focused Widget :
ewol::Widget * tmpWidget = ewol::widgetManager::FocusGet();
if (NULL != tmpWidget) {
// check Widget shortcut
if (false==tmpWidget->OnEventShortCut(data.keyboardKey.special,
data.keyboardKey.myChar,
ewol::keyEvent::keyboardUnknow,
data.keyboardKey.isDown)) {
// generate the direct event ...
if(true == data.keyboardKey.isDown) {
EWOL_VERBOSE("GUI PRESSED : \"" << data.keyboardKey.myChar << "\"");
tmpWidget->OnEventKb(ewol::keyEvent::statusDown, data.keyboardKey.myChar);
} else {
EWOL_VERBOSE("GUI Release : \"" << data.keyboardKey.myChar << "\"");
tmpWidget->OnEventKb(ewol::keyEvent::statusUp, data.keyboardKey.myChar);
}
}
}
}
}
specialCurrentKey = data.keyboardSpecial;
}
break;
// no break ... (normal case ...)
case THREAD_KEYBORAD_MOVE:
//EWOL_DEBUG("Receive MSG : THREAD_KEYBORAD_MOVE");
// check main shortcut
if (NULL != windowsCurrent) {
if (false==windowsCurrent->OnEventShortCut(data.keyboardKey.special,
data.keyboardKey.myChar,
ewol::keyEvent::keyboardUnknow,
data.keyboardKey.isDown)) {
ewol::SpecialKey& specialCurrentKey = ewol::GetCurrentSpecialKeyStatus();
specialCurrentKey = data.keyboardMove.special;
if (false==windowsCurrent->OnEventShortCut(data.keyboardSpecial,
data.keyboardChar,
data.keyboardMove,
data.stateIsDown) ) {
// Get the current Focused Widget :
ewol::Widget * tmpWidget = ewol::widgetManager::FocusGet();
if (NULL != tmpWidget) {
// check Widget shortcut
if (false==tmpWidget->OnEventShortCut(data.keyboardKey.special,
data.keyboardKey.myChar,
ewol::keyEvent::keyboardUnknow,
data.keyboardKey.isDown)) {
if (false==tmpWidget->OnEventShortCut(data.keyboardSpecial,
data.keyboardChar,
data.keyboardMove,
data.stateIsDown) ) {
// generate the direct event ...
if(true == data.keyboardMove.isDown) {
tmpWidget->OnEventKbMove(ewol::keyEvent::statusDown, data.keyboardMove.move);
} else {
tmpWidget->OnEventKbMove(ewol::keyEvent::statusUp, data.keyboardMove.move);
if (data.TypeMessage == THREAD_KEYBORAD_KEY) {
if(true == data.stateIsDown) {
tmpWidget->OnEventKb(ewol::keyEvent::statusDown, data.keyboardChar);
} else {
tmpWidget->OnEventKb(ewol::keyEvent::statusUp, data.keyboardChar);
}
} else { // THREAD_KEYBORAD_MOVE
if(true == data.stateIsDown) {
tmpWidget->OnEventKbMove(ewol::keyEvent::statusDown, data.keyboardMove);
} else {
tmpWidget->OnEventKbMove(ewol::keyEvent::statusUp, data.keyboardMove);
}
}
}
}
@ -252,7 +229,7 @@ bool isGlobalSystemInit = false;
void RequestInit(void)
{
if (true == isGlobalSystemInit) {
eSystemMessage_ts data;
eSystemMessage data;
data.TypeMessage = THREAD_INIT;
l_msgSystem.Post(data);
}
@ -317,7 +294,7 @@ void eSystem::UnInit(void)
void eSystem::RequestUpdateSize(void)
{
if (true == isGlobalSystemInit) {
eSystemMessage_ts data;
eSystemMessage data;
data.TypeMessage = THREAD_RECALCULATE_SIZE;
l_msgSystem.Post(data);
}
@ -326,10 +303,10 @@ void eSystem::RequestUpdateSize(void)
void eSystem::Resize(int w, int h )
{
if (true == isGlobalSystemInit) {
eSystemMessage_ts data;
eSystemMessage data;
data.TypeMessage = THREAD_RESIZE;
data.resize.w = w;
data.resize.h = h;
data.dimention.x = w;
data.dimention.y = h;
l_msgSystem.Post(data);
}
}
@ -337,7 +314,7 @@ void eSystem::Move(int w, int h )
{
if (true == isGlobalSystemInit) {
/*
eSystemMessage_ts data;
eSystemMessage data;
data.TypeMessage = THREAD_RESIZE;
data.resize.w = w;
data.resize.h = h;
@ -349,27 +326,27 @@ void eSystem::Move(int w, int h )
void eSystem::SetInputMotion(int pointerID, float x, float y )
{
if (true == isGlobalSystemInit) {
eSystemMessage_ts data;
eSystemMessage data;
data.TypeMessage = THREAD_INPUT_MOTION;
data.input.type = ewol::keyEvent::typeFinger;
data.input.pointerID = pointerID;
data.input.x = x;
data.input.y = y;
data.inputType = ewol::keyEvent::typeFinger;
data.inputId = pointerID;
data.dimention.x = x;
data.dimention.y = y;
l_msgSystem.Post(data);
}
}
void eSystem::SetInputState(int pointerID, bool isUp, float x, float y )
void eSystem::SetInputState(int pointerID, bool isDown, float x, float y )
{
if (true == isGlobalSystemInit) {
eSystemMessage_ts data;
eSystemMessage data;
data.TypeMessage = THREAD_INPUT_STATE;
data.input.type = ewol::keyEvent::typeFinger;
data.input.pointerID = pointerID;
data.input.state = isUp;
data.input.x = x;
data.input.y = y;
data.inputType = ewol::keyEvent::typeFinger;
data.inputId = pointerID;
data.stateIsDown = isDown;
data.dimention.x = x;
data.dimention.y = y;
l_msgSystem.Post(data);
}
}
@ -378,47 +355,56 @@ void eSystem::SetInputState(int pointerID, bool isUp, float x, float y )
void eSystem::SetMouseMotion(int pointerID, float x, float y )
{
if (true == isGlobalSystemInit) {
eSystemMessage_ts data;
eSystemMessage data;
data.TypeMessage = THREAD_INPUT_MOTION;
data.input.type = ewol::keyEvent::typeMouse;
data.input.pointerID = pointerID;
data.input.x = x;
data.input.y = y;
data.inputType = ewol::keyEvent::typeMouse;
data.inputId = pointerID;
data.dimention.x = x;
data.dimention.y = y;
l_msgSystem.Post(data);
}
}
void eSystem::SetMouseState(int pointerID, bool isUp, float x, float y )
void eSystem::SetMouseState(int pointerID, bool isDown, float x, float y )
{
if (true == isGlobalSystemInit) {
eSystemMessage_ts data;
eSystemMessage data;
data.TypeMessage = THREAD_INPUT_STATE;
data.input.type = ewol::keyEvent::typeMouse;
data.input.pointerID = pointerID;
data.input.state = isUp;
data.input.x = x;
data.input.y = y;
data.inputType = ewol::keyEvent::typeMouse;
data.inputId = pointerID;
data.stateIsDown = isDown;
data.dimention.x = x;
data.dimention.y = y;
l_msgSystem.Post(data);
}
}
void eSystem::SetKeyboard(eSystem::keyboardKey_ts& keyInput)
void eSystem::SetKeyboard(ewol::SpecialKey& special,
uniChar_t myChar,
bool isDown)
{
if (true == isGlobalSystemInit) {
eSystemMessage_ts data;
eSystemMessage data;
data.TypeMessage = THREAD_KEYBORAD_KEY;
data.keyboardKey = keyInput;
data.stateIsDown = isDown;
data.keyboardChar = myChar;
data.keyboardSpecial = special;
l_msgSystem.Post(data);
}
}
void eSystem::SetKeyboardMove(eSystem::keyboardMove_ts& keyInput)
void eSystem::SetKeyboardMove(ewol::SpecialKey& special,
ewol::keyEvent::keyboard_te move,
bool isDown)
{
if (true == isGlobalSystemInit) {
eSystemMessage_ts data;
eSystemMessage data;
data.TypeMessage = THREAD_KEYBORAD_MOVE;
data.keyboardMove = keyInput;
data.stateIsDown = isDown;
data.keyboardMove = move;
data.keyboardSpecial = special;
l_msgSystem.Post(data);
}
}
@ -427,7 +413,7 @@ void eSystem::SetKeyboardMove(eSystem::keyboardMove_ts& keyInput)
void eSystem::Hide(void)
{
if (true == isGlobalSystemInit) {
eSystemMessage_ts data;
eSystemMessage data;
data.TypeMessage = THREAD_HIDE;
l_msgSystem.Post(data);
}
@ -436,7 +422,7 @@ void eSystem::Hide(void)
void eSystem::Show(void)
{
if (true == isGlobalSystemInit) {
eSystemMessage_ts data;
eSystemMessage data;
data.TypeMessage = THREAD_SHOW;
l_msgSystem.Post(data);
}
@ -446,7 +432,7 @@ void eSystem::Show(void)
void eSystem::ClipBoardArrive(ewol::clipBoard::clipboardListe_te clipboardID)
{
if (true == isGlobalSystemInit) {
eSystemMessage_ts data;
eSystemMessage data;
data.TypeMessage = THREAD_CLIPBOARD_ARRIVE;
data.clipboardID = clipboardID;
l_msgSystem.Post(data);

24
sources/ewol/renderer/os/eSystem.h
View File

@ -27,25 +27,17 @@ namespace eSystem
void Show(void);
void SetInputMotion(int pointerID, float x, float y);
void SetInputState(int pointerID, bool isUp, float x, float y);
void SetInputState(int pointerID, bool isDown, float x, float y);
void SetMouseMotion(int pointerID, float x, float y);
void SetMouseState(int pointerID, bool isUp, float x, float y);
void SetMouseState(int pointerID, bool isDown, float x, float y);
typedef struct {
bool isDown;
uniChar_t myChar;
ewol::SpecialKey special;
} keyboardKey_ts;
typedef struct {
bool isDown;
ewol::keyEvent::keyboard_te move;
ewol::SpecialKey special;
} keyboardMove_ts;
void SetKeyboard(eSystem::keyboardKey_ts& keyInput);
void SetKeyboardMove(eSystem::keyboardMove_ts& keyInput);
void SetKeyboard(ewol::SpecialKey& special,
uniChar_t myChar,
bool isDown);
void SetKeyboardMove(ewol::SpecialKey& special,
ewol::keyEvent::keyboard_te move,
bool isDown);
void ClipBoardArrive(ewol::clipBoard::clipboardListe_te clipboardID);

29
sources/ewol/renderer/os/gui.Android.base.cpp
View File

@ -11,10 +11,10 @@
#include <time.h>
#include <stdint.h>
#include <pthread.h>
#include <ewol/Debug.h>
#include <ewol/os/eSystem.h>
#include <ewol/audio/audio.h>
#include <ewol/os/gui.h>
#include <ewol/debug.h>
#include <ewol/renderer/os/eSystem.h>
#include <ewol/renderer/audio/audio.h>
#include <ewol/renderer/os/gui.h>
// get a resources from the java environement :
static JNIEnv* JavaVirtualMachinePointer = NULL; // the JVM
@ -31,6 +31,10 @@ static int32_t m_currentHeight = 0;
static JavaVM* g_JavaVM = NULL;
// special key of the android system :
static ewol::SpecialKey guiKeyBoardSpecialKeyMode;
// jni doc : /usr/lib/jvm/java-1.6.0-openjdk/include
@ -401,10 +405,7 @@ extern "C"
void Java_org_ewol_interfaceJNI_IOKeyboardEventKey( JNIEnv* env, jobject thiz, jint uniChar, jboolean isdown)
{
EWOL_DEBUG("IO keyboard Key event : \"" << uniChar << "\" is down=" << isdown);
eSystem::keyboardKey_ts keyInput;
keyInput.myChar = uniChar;
keyInput.isDown = isdown;
eSystem::SetKeyboard(keyInput);
eSystem::SetKeyboard(guiKeyBoardSpecialKeyMode, uniChar, isdown);
}
enum {
@ -488,6 +489,10 @@ extern "C"
#define __class__ "guiInterface"
int guiInterface::main(int argc, const char *argv[])
{
// unneeded fuction, all is controlled by android java ...
}
int64_t guiInterface::GetTime(void)
{
@ -516,12 +521,12 @@ void guiInterface::ClipBoardGet(ewol::clipBoard::clipboardListe_te clipboardID)
l_clipBoardOwnerStd = true;
switch (clipboardID)
{
case ewol::clipBoard::CLIPBOARD_SELECTION:
case ewol::clipBoard::clipboardSelection:
// NOTE : Windows does not support the middle button the we do it internaly
// just transmit an event , we have the data in the system
eSystem::ClipBoardArrive(clipboardID);
break;
case ewol::clipBoard::CLIPBOARD_STD:
case ewol::clipBoard::clipboardStd:
if (false == l_clipBoardOwnerStd) {
// Generate a request TO the OS
// TODO : Send the message to the OS "We disire to receive the copy buffer ...
@ -540,10 +545,10 @@ void guiInterface::ClipBoardSet(ewol::clipBoard::clipboardListe_te clipboardID)
{
switch (clipboardID)
{
case ewol::clipBoard::CLIPBOARD_SELECTION:
case ewol::clipBoard::clipboardSelection:
// NOTE : nothing to do : Windows deas ot supported Middle button
break;
case ewol::clipBoard::CLIPBOARD_STD:
case ewol::clipBoard::clipboardStd:
// Request the clipBoard :
if (false == l_clipBoardOwnerStd) {
// TODO : Inform the OS that we have the current buffer of copy ...

2
sources/ewol/renderer/os/gui.Android.cpp
View File

@ -7,4 +7,4 @@
*/
// this include a dynamic generating file ==> this is really stupid, but it is needed for the dependency coherency
#include <ewol/os/gui.Android.tmp.cpp>
#include <ewol/renderer/os/gui.Android.tmp.cpp>

137
sources/ewol/renderer/os/gui.Windows.cpp
View File

@ -7,19 +7,20 @@
*/
#include <ewol/Debug.h>
#include <ewol/debug.h>
#include <ewol/ewol.h>
#include <etk/math/math.h>
#include <etk/math/Vector2D.h>
#include <etk/math/Vector3D.h>
#include <etk/UString.h>
#include <etk/unicode.h>
#include <ewol/widget/WidgetManager.h>
#include <ewol/os/gui.h>
#include <ewol/renderer/os/gui.h>
#include <ewol/texture/Texture.h>
#include <ewol/texture/TextureBMP.h>
#include <ewol/os/eSystem.h>
#include <ewol/openGL/openGL.h>
#include <ewol/renderer/resources/Texture.h>
#include <ewol/renderer/resources/Image.h>
#include <ewol/renderer/os/eSystem.h>
#include <ewol/renderer/openGL.h>
#include <sys/time.h>
@ -106,12 +107,12 @@ void guiInterface::ClipBoardGet(ewol::clipBoard::clipboardListe_te clipboardID)
l_clipBoardOwnerStd = true;
switch (clipboardID)
{
case ewol::clipBoard::CLIPBOARD_SELECTION:
case ewol::clipBoard::clipboardSelection:
// NOTE : Windows does not support the middle button the we do it internaly
// just transmit an event , we have the data in the system
eSystem::ClipBoardArrive(clipboardID);
break;
case ewol::clipBoard::CLIPBOARD_STD:
case ewol::clipBoard::clipboardStd:
if (false == l_clipBoardOwnerStd) {
// Generate a request TO the OS
// TODO : Send the message to the OS "We disire to receive the copy buffer ...
@ -131,10 +132,10 @@ void guiInterface::ClipBoardSet(ewol::clipBoard::clipboardListe_te clipboardID)
{
switch (clipboardID)
{
case ewol::clipBoard::CLIPBOARD_SELECTION:
case ewol::clipBoard::clipboardSelection:
// NOTE : nothing to do : Windows deas ot supported Middle button
break;
case ewol::clipBoard::CLIPBOARD_STD:
case ewol::clipBoard::clipboardStd:
// Request the clipBoard :
if (false == l_clipBoardOwnerStd) {
// TODO : Inform the OS that we have the current buffer of copy ...
@ -159,7 +160,13 @@ void EnableOpenGL(HWND hWnd, HDC * hDC, HGLRC * hRC);
void DisableOpenGL(HWND hWnd, HDC hDC, HGLRC hRC);
int Windows_Run(void);
int main(int argc, char *argv[])
/**
* @brief Main of the program
* @param std IO
* @return std IO
*/
int guiInterface::main(int argc, const char *argv[])
{
glewInit();
if (!glewIsSupported("GL_VERSION_2_0")) {
@ -167,29 +174,6 @@ int main(int argc, char *argv[])
return 1;
}
ewol::CmdLine::Clean();
for( int32_t i=1 ; i<argc; i++) {
EWOL_INFO("CmdLine : \"" << argv[i] << "\"" );
if (0==strncmp("-l0", argv[i], 256)) {
GeneralDebugSetLevel(etk::LOG_LEVEL_NONE);
} else if (0==strncmp("-l1", argv[i], 256)) {
GeneralDebugSetLevel(etk::LOG_LEVEL_CRITICAL);
} else if (0==strncmp("-l2", argv[i], 256)) {
GeneralDebugSetLevel(etk::LOG_LEVEL_ERROR);
} else if (0==strncmp("-l3", argv[i], 256)) {
GeneralDebugSetLevel(etk::LOG_LEVEL_WARNING);
} else if (0==strncmp("-l4", argv[i], 256)) {
GeneralDebugSetLevel(etk::LOG_LEVEL_INFO);
} else if (0==strncmp("-l5", argv[i], 256)) {
GeneralDebugSetLevel(etk::LOG_LEVEL_DEBUG);
} else if (0==strncmp("-l6", argv[i], 256)) {
GeneralDebugSetLevel(etk::LOG_LEVEL_VERBOSE);
} else {
etk::UString tmpString(argv[i]);
ewol::CmdLine::Add(tmpString);
}
}
for (int32_t iii=0; iii<NB_MAX_INPUT; iii++) {
inputIsPressed[iii] = false;
}
@ -214,7 +198,6 @@ int main(int argc, char *argv[])
guiInterface::Stop();
// uninit ALL :
eSystem::UnInit();
ewol::CmdLine::Clean();
return 0;
}
@ -351,42 +334,42 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
case WM_KEYDOWN:
{
uniChar_t tmpChar = 0;
ewol::eventKbMoveType_te keyInput;
ewol::keyEvent::keyboard_te keyInput;
switch (wParam) {
//case 80: // keypad
case VK_UP: keyInput = ewol::EVENT_KB_MOVE_TYPE_UP; break;
case VK_UP: keyInput = ewol::keyEvent::keyboardUp; break;
//case 83: // keypad
case VK_LEFT: keyInput = ewol::EVENT_KB_MOVE_TYPE_LEFT; break;
case VK_LEFT: keyInput = ewol::keyEvent::keyboardLeft; break;
//case 85: // keypad
case VK_RIGHT: keyInput = ewol::EVENT_KB_MOVE_TYPE_RIGHT; break;
case VK_RIGHT: keyInput = ewol::keyEvent::keyboardRight; break;
//case 88: // keypad
case VK_DOWN: keyInput = ewol::EVENT_KB_MOVE_TYPE_DOWN; break;
case VK_DOWN: keyInput = ewol::keyEvent::keyboardDown; break;
//case 81: // keypad
case VK_PRIOR: keyInput = ewol::EVENT_KB_MOVE_TYPE_PAGE_UP; break;
case VK_PRIOR: keyInput = ewol::keyEvent::keyboardPageUp; break;
//case 89: // keypad
case VK_NEXT: keyInput = ewol::EVENT_KB_MOVE_TYPE_PAGE_DOWN; break;
case VK_NEXT: keyInput = ewol::keyEvent::keyboardPageDown; break;
//case 79: // keypad
case VK_HOME: keyInput = ewol::EVENT_KB_MOVE_TYPE_START; break;
case VK_HOME: keyInput = ewol::keyEvent::keyboardStart; break;
//case 87: // keypad
case VK_END: keyInput = ewol::EVENT_KB_MOVE_TYPE_END; break;
//case VK_: keyInput = ewol::EVENT_KB_MOVE_TYPE_ARRET_DEFIL; break;
case VK_PAUSE: keyInput = ewol::EVENT_KB_MOVE_TYPE_WAIT; break;
case VK_END: keyInput = ewol::keyEvent::keyboardEnd; break;
//case VK_: keyInput = ewol::keyEvent::keyboardStopDefil; break;
case VK_PAUSE: keyInput = ewol::keyEvent::keyboardWait; break;
//case 90: // keypad
case VK_INSERT:
keyInput = ewol::EVENT_KB_MOVE_TYPE_INSERT;
keyInput = ewol::keyEvent::keyboardInsert;
guiKeyBoardMode.insert = buttonIsDown;
break;
case VK_F1: keyInput = ewol::EVENT_KB_MOVE_TYPE_F1; break;
case VK_F2: keyInput = ewol::EVENT_KB_MOVE_TYPE_F2; break;
case VK_F3: keyInput = ewol::EVENT_KB_MOVE_TYPE_F3; break;
case VK_F4: keyInput = ewol::EVENT_KB_MOVE_TYPE_F4; break;
case VK_F5: keyInput = ewol::EVENT_KB_MOVE_TYPE_F5; break;
case VK_F6: keyInput = ewol::EVENT_KB_MOVE_TYPE_F6; break;
case VK_F7: keyInput = ewol::EVENT_KB_MOVE_TYPE_F7; break;
case VK_F8: keyInput = ewol::EVENT_KB_MOVE_TYPE_F8; break;
case VK_F9: keyInput = ewol::EVENT_KB_MOVE_TYPE_F9; break;
case VK_F10: keyInput = ewol::EVENT_KB_MOVE_TYPE_F10; break;
case VK_F11: keyInput = ewol::EVENT_KB_MOVE_TYPE_F11; break;
case VK_F1: keyInput = ewol::keyEvent::keyboardF1; break;
case VK_F2: keyInput = ewol::keyEvent::keyboardF2; break;
case VK_F3: keyInput = ewol::keyEvent::keyboardF3; break;
case VK_F4: keyInput = ewol::keyEvent::keyboardF4; break;
case VK_F5: keyInput = ewol::keyEvent::keyboardF5; break;
case VK_F6: keyInput = ewol::keyEvent::keyboardF6; break;
case VK_F7: keyInput = ewol::keyEvent::keyboardF7; break;
case VK_F8: keyInput = ewol::keyEvent::keyboardF8; break;
case VK_F9: keyInput = ewol::keyEvent::keyboardF9; break;
case VK_F10: keyInput = ewol::keyEvent::keyboardF10; break;
case VK_F11: keyInput = ewol::keyEvent::keyboardF11; break;
case VK_F12:
case VK_F13:
case VK_F14:
@ -399,25 +382,25 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
case VK_F21:
case VK_F22:
case VK_F23:
case VK_F24: keyInput = ewol::EVENT_KB_MOVE_TYPE_F12; break;
case VK_CAPITAL: keyInput = ewol::EVENT_KB_MOVE_TYPE_CAPLOCK; guiKeyBoardMode.capLock = buttonIsDown; break;
case VK_F24: keyInput = ewol::keyEvent::keyboardF12; break;
case VK_CAPITAL: keyInput = ewol::keyEvent::keyboardCapLock; guiKeyBoardMode.capLock = buttonIsDown; break;
case VK_SHIFT:
case VK_LSHIFT: keyInput = ewol::EVENT_KB_MOVE_TYPE_SHIFT_LEFT; guiKeyBoardMode.shift = buttonIsDown; break;
case VK_RSHIFT: keyInput = ewol::EVENT_KB_MOVE_TYPE_SHIFT_RIGHT; guiKeyBoardMode.shift = buttonIsDown; break;
case VK_LSHIFT: keyInput = ewol::keyEvent::keyboardShiftLeft; guiKeyBoardMode.shift = buttonIsDown; break;
case VK_RSHIFT: keyInput = ewol::keyEvent::keyboardShiftRight; guiKeyBoardMode.shift = buttonIsDown; break;
case VK_CONTROL:
case VK_LCONTROL: keyInput = ewol::EVENT_KB_MOVE_TYPE_CTRL_LEFT; guiKeyBoardMode.ctrl = buttonIsDown; break;
case VK_RCONTROL: keyInput = ewol::EVENT_KB_MOVE_TYPE_CTRL_RIGHT; guiKeyBoardMode.ctrl = buttonIsDown; break;
case VK_LCONTROL: keyInput = ewol::keyEvent::keyboardCtrlLeft; guiKeyBoardMode.ctrl = buttonIsDown; break;
case VK_RCONTROL: keyInput = ewol::keyEvent::keyboardCtrlRight; guiKeyBoardMode.ctrl = buttonIsDown; break;
case VK_LWIN: keyInput = ewol::EVENT_KB_MOVE_TYPE_META_LEFT; guiKeyBoardMode.meta = buttonIsDown; break;
case VK_RWIN: keyInput = ewol::EVENT_KB_MOVE_TYPE_META_RIGHT; guiKeyBoardMode.meta = buttonIsDown; break;
case VK_LWIN: keyInput = ewol::keyEvent::keyboardMetaLeft; guiKeyBoardMode.meta = buttonIsDown; break;
case VK_RWIN: keyInput = ewol::keyEvent::keyboardMetaRight; guiKeyBoardMode.meta = buttonIsDown; break;
case VK_MENU:
case VK_LMENU: keyInput = ewol::EVENT_KB_MOVE_TYPE_ALT; guiKeyBoardMode.alt = buttonIsDown; break;
case VK_RMENU: keyInput = ewol::EVENT_KB_MOVE_TYPE_ALT_GR; guiKeyBoardMode.altGr = buttonIsDown; break;
//case : keyInput = ewol::EVENT_KB_MOVE_TYPE_CONTEXT_MENU; break;
case VK_NUMLOCK: keyInput = ewol::EVENT_KB_MOVE_TYPE_VER_NUM; guiKeyBoardMode.verNum = buttonIsDown; break;
case VK_LMENU: keyInput = ewol::keyEvent::keyboardAlt; guiKeyBoardMode.alt = buttonIsDown; break;
case VK_RMENU: keyInput = ewol::keyEvent::keyboardAltGr; guiKeyBoardMode.altGr = buttonIsDown; break;
//case : keyInput = ewol::keyEvent::keyboardContextMenu; break;
case VK_NUMLOCK: keyInput = ewol::keyEvent::keyboardVerNum; guiKeyBoardMode.verNum = buttonIsDown; break;
case VK_BACK: // DEL
tmpChar = 0x00000008;
break;
@ -446,17 +429,9 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
EWOL_DEBUG("kjhkjhkjhkjhkj = " << wParam);
if (tmpChar == 0) {
//EWOL_DEBUG("eventKey Move type : " << GetCharTypeMoveEvent(keyInput) );
eSystem::keyboardMove_ts specialEvent;
specialEvent.special = guiKeyBoardMode;
specialEvent.move = keyInput;
specialEvent.isDown = buttonIsDown;
eSystem::SetKeyboardMove(specialEvent);
eSystem::SetKeyboardMove(guiKeyBoardMode, keyInput, buttonIsDown);
} else {
eSystem::keyboardKey_ts specialEvent;
specialEvent.special = guiKeyBoardMode;
specialEvent.myChar = tmpChar;
specialEvent.isDown = buttonIsDown;
eSystem::SetKeyboard(specialEvent);
eSystem::SetKeyboard(guiKeyBoardMode, tmpChar, buttonIsDown);
}
}
return 0;

71
sources/ewol/renderer/os/gui.X11.cpp
View File

@ -867,31 +867,11 @@ void X11_Run(void)
case 77: keyInput = ewol::keyEvent::keyboardVerNum; guiKeyBoardMode.verNum = (event.type == KeyPress) ? true : false; break;
case 91: // Suppr on keypad
find = false;
{
eSystem::keyboardKey_ts specialEvent;
specialEvent.special = guiKeyBoardMode;
specialEvent.myChar = 0x0000007F;
if(event.type == KeyPress) {
specialEvent.isDown = true;
} else {
specialEvent.isDown = false;
}
eSystem::SetKeyboard(specialEvent);
}
eSystem::SetKeyboard(guiKeyBoardMode, 0x7F, (event.type==KeyPress));
break;
case 23: // special case for TAB
find = false;
{
eSystem::keyboardKey_ts specialEvent;
specialEvent.special = guiKeyBoardMode;
specialEvent.myChar = 0x00000009;
if(event.type == KeyPress) {
specialEvent.isDown = true;
} else {
specialEvent.isDown = false;
}
eSystem::SetKeyboard(specialEvent);
}
eSystem::SetKeyboard(guiKeyBoardMode, 0x09, (event.type==KeyPress));
break;
default:
find = false;
@ -915,17 +895,11 @@ void X11_Run(void)
buf[1] = '\0';
}
if (count>0) {
// transform iun unicode
eSystem::keyboardKey_ts specialEvent;
specialEvent.special = guiKeyBoardMode;
unicode::convertIsoToUnicode(unicode::EDN_CHARSET_ISO_8859_15, buf[0], specialEvent.myChar);
// transform it in unicode
uniChar_t tmpChar = 0;
unicode::convertIsoToUnicode(unicode::EDN_CHARSET_ISO_8859_15, buf[0], tmpChar);
//EWOL_INFO("event Key : " << event.xkey.keycode << " char=\"" << buf << "\"'len=" << strlen(buf) << " unicode=" << unicodeValue);
if(event.type == KeyPress) {
specialEvent.isDown = true;
} else {
specialEvent.isDown = false;
}
eSystem::SetKeyboard(specialEvent);
eSystem::SetKeyboard(guiKeyBoardMode, tmpChar, (event.type==KeyPress));
} else {
EWOL_WARNING("Unknow event Key : " << event.xkey.keycode);
}
@ -934,15 +908,7 @@ void X11_Run(void)
}
if (true == find) {
//EWOL_DEBUG("eventKey Move type : " << GetCharTypeMoveEvent(keyInput) );
eSystem::keyboardMove_ts specialEvent;
specialEvent.special = guiKeyBoardMode;
if(event.type == KeyPress) {
specialEvent.isDown = true;
} else {
specialEvent.isDown = false;
}
specialEvent.move = keyInput;
eSystem::SetKeyboardMove(specialEvent);
eSystem::SetKeyboardMove(guiKeyBoardMode, keyInput, (event.type==KeyPress));
}
}
break;
@ -1114,28 +1080,6 @@ void guiInterface::GetAbsPos(etk::Vector2D<int32_t>& pos)
*/
int guiInterface::main(int argc, const char *argv[])
{
ewol::commandLine::Clean();
for( int32_t i=1 ; i<argc; i++) {
EWOL_INFO("commandLine : \"" << argv[i] << "\"" );
if (0==strncmp("-l0", argv[i], 256)) {
GeneralDebugSetLevel(etk::LOG_LEVEL_NONE);
} else if (0==strncmp("-l1", argv[i], 256)) {
GeneralDebugSetLevel(etk::LOG_LEVEL_CRITICAL);
} else if (0==strncmp("-l2", argv[i], 256)) {
GeneralDebugSetLevel(etk::LOG_LEVEL_ERROR);
} else if (0==strncmp("-l3", argv[i], 256)) {
GeneralDebugSetLevel(etk::LOG_LEVEL_WARNING);
} else if (0==strncmp("-l4", argv[i], 256)) {
GeneralDebugSetLevel(etk::LOG_LEVEL_INFO);
} else if (0==strncmp("-l5", argv[i], 256)) {
GeneralDebugSetLevel(etk::LOG_LEVEL_DEBUG);
} else if (0==strncmp("-l6", argv[i], 256)) {
GeneralDebugSetLevel(etk::LOG_LEVEL_VERBOSE);
} else {
etk::UString tmpString(argv[i]);
ewol::commandLine::Add(tmpString);
}
}
for (int32_t iii=0; iii<NB_MAX_INPUT; iii++) {
inputIsPressed[iii] = false;
@ -1163,7 +1107,6 @@ int guiInterface::main(int argc, const char *argv[])
guiInterface::Stop();
// uninit ALL :
eSystem::UnInit();
ewol::commandLine::Clean();
return 0;
}

4
sources/ewol/renderer/resources/FontFreeType.cpp
View File

@ -37,12 +37,11 @@ void ewol::FreeTypeInit(void)
void ewol::FreeTypeUnInit(void)
{
EWOL_DEBUG("==> Un-Init Font-Manager");
/*int32_t error = FT_Done_FreeType( library );
int32_t error = FT_Done_FreeType( library );
library = NULL;
if(0 != error) {
EWOL_CRITICAL(" when Un-loading FreeType Librairy ...");
}
*/
}
@ -100,6 +99,7 @@ ewol::FontFreeType::~FontFreeType(void)
m_FileBuffer = NULL;
}
// must be deleted fftFace
FT_Done_Face( m_fftFace );
}

2
sources/ewol/widget/PopUp.cpp
View File

@ -157,7 +157,7 @@ void widget::PopUp::OnRegenerateDisplay(void)
etk::Vector2D<float> tmpOrigin = m_subWidget->GetOrigin();
BGOObjects->SetColor(m_colorBorder);
BGOObjects->SetPos(etk::Vector3D<float>(tmpOrigin.x-BORDER_SIZE_TMP, tmpOrigin.y-BORDER_SIZE_TMP,0) );
BGOObjects->Rectangle(etk::Vector3D<float>(tmpSize.x+2*BORDER_SIZE_TMP, tmpSize.y+2*BORDER_SIZE_TMP, 0) );
BGOObjects->RectangleWidth(etk::Vector3D<float>(tmpSize.x+2*BORDER_SIZE_TMP, tmpSize.y+2*BORDER_SIZE_TMP, 0) );
BGOObjects->SetColor(m_colorBackGroung);
BGOObjects->SetPos(etk::Vector3D<float>(tmpOrigin.x, tmpOrigin.y,0) );
BGOObjects->RectangleWidth(etk::Vector3D<float>(tmpSize.x, tmpSize.y, 0) );