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

Change the input event to support special key of the keyboard, and add shortcut on the widget

Browse Source
This commit is contained in:
Edouard Dupin 2012-01-17 17:13:46 +01:00
parent 3204e48c80
commit 5c68e20a7e
5 changed files with 297 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

183
Sources/libewol/ewol/Widget.cpp
View File

@ -25,6 +25,51 @@
#include <ewol/Widget.h>
#include <ewol/WidgetManager.h>
char* ewol::GetCharTypeMoveEvent(eventKbMoveType_te type)
{
char * returnValue = "?";
switch(type) {
case ewol::EVENT_KB_MOVE_TYPE_LEFT: returnValue = "LEFT"; break;
case ewol::EVENT_KB_MOVE_TYPE_RIGHT: returnValue = "RIGHT"; break;
case ewol::EVENT_KB_MOVE_TYPE_UP: returnValue = "UP"; break;
case ewol::EVENT_KB_MOVE_TYPE_DOWN: returnValue = "DOWN"; break;
case ewol::EVENT_KB_MOVE_TYPE_PAGE_UP: returnValue = "PAGE_UP"; break;
case ewol::EVENT_KB_MOVE_TYPE_PAGE_DOWN: returnValue = "PAGE_DOWN"; break;
case ewol::EVENT_KB_MOVE_TYPE_START: returnValue = "START"; break;
case ewol::EVENT_KB_MOVE_TYPE_END: returnValue = "END"; break;
case ewol::EVENT_KB_MOVE_TYPE_CENTER: returnValue = "CENTER"; break;
case ewol::EVENT_KB_MOVE_TYPE_ARRET_DEFIL: returnValue = "ARRET_DEFIL"; break;
case ewol::EVENT_KB_MOVE_TYPE_WAIT: returnValue = "WAIT"; break;
case ewol::EVENT_KB_MOVE_TYPE_INSERT: returnValue = "INSERT"; break;
case ewol::EVENT_KB_MOVE_TYPE_F1: returnValue = "F1"; break;
case ewol::EVENT_KB_MOVE_TYPE_F2: returnValue = "F2"; break;
case ewol::EVENT_KB_MOVE_TYPE_F3: returnValue = "F3"; break;
case ewol::EVENT_KB_MOVE_TYPE_F4: returnValue = "F4"; break;
case ewol::EVENT_KB_MOVE_TYPE_F5: returnValue = "F5"; break;
case ewol::EVENT_KB_MOVE_TYPE_F6: returnValue = "F6"; break;
case ewol::EVENT_KB_MOVE_TYPE_F7: returnValue = "F7"; break;
case ewol::EVENT_KB_MOVE_TYPE_F8: returnValue = "F8"; break;
case ewol::EVENT_KB_MOVE_TYPE_F9: returnValue = "F9"; break;
case ewol::EVENT_KB_MOVE_TYPE_F10: returnValue = "F10"; break;
case ewol::EVENT_KB_MOVE_TYPE_F11: returnValue = "F11"; break;
case ewol::EVENT_KB_MOVE_TYPE_F12: returnValue = "F12"; break;
case ewol::EVENT_KB_MOVE_TYPE_CAPLOCK: returnValue = "CAPLOCK"; break;
case ewol::EVENT_KB_MOVE_TYPE_SHIFT_LEFT: returnValue = "SHIFT_LEFT"; break;
case ewol::EVENT_KB_MOVE_TYPE_SHIFT_RIGHT: returnValue = "SHIFT_RIGHT"; break;
case ewol::EVENT_KB_MOVE_TYPE_CTRL_LEFT: returnValue = "CTRL_LEFT"; break;
case ewol::EVENT_KB_MOVE_TYPE_CTRL_RIGHT: returnValue = "CTRL_RIGHT"; break;
case ewol::EVENT_KB_MOVE_TYPE_META_LEFT: returnValue = "META_LEFT"; break;
case ewol::EVENT_KB_MOVE_TYPE_META_RIGHT: returnValue = "META_RIGHT"; break;
case ewol::EVENT_KB_MOVE_TYPE_ALT: returnValue = "ALT"; break;
case ewol::EVENT_KB_MOVE_TYPE_ALT_GR: returnValue = "ALT_GR"; break;
case ewol::EVENT_KB_MOVE_TYPE_CONTEXT_MENU: returnValue = "CONTEXT_MENU"; break;
case ewol::EVENT_KB_MOVE_TYPE_VER_NUM: returnValue = "VER_NUM"; break;
}
return returnValue;
}
#undef __class__
#define __class__ "ewol::Widget"
@ -73,33 +118,31 @@ bool ewol::Widget::GenEventInput(int32_t IdInput, eventInputType_te typeEvent, e
{
bool ended = false;
//EWOL_WARNING("Input event : " << IdInput << " pos(" << x << "," << y << ")");
for(int32_t iii=m_inputEvent.Size()-1; iii>=0; iii--) {
if (EWOL_EVENT_AREA == m_inputEvent[iii].mode) {
if( m_inputEvent[iii].area.origin.x <= x
&& m_inputEvent[iii].area.origin.y <= y
&& m_inputEvent[iii].area.origin.x + m_inputEvent[iii].area.size.x > x
&& m_inputEvent[iii].area.origin.y + m_inputEvent[iii].area.size.y > y )
for(int32_t iii=m_inputAreaEvent.Size()-1; iii>=0; iii--) {
if( m_inputAreaEvent[iii].origin.x <= x
&& m_inputAreaEvent[iii].origin.y <= y
&& m_inputAreaEvent[iii].origin.x + m_inputAreaEvent[iii].size.x > x
&& m_inputAreaEvent[iii].origin.y + m_inputAreaEvent[iii].size.y > y )
{
if( (m_inputAreaEvent[iii].flags & (1<<(IdInput-1)) )
&& ( ( (FLAG_EVENT_INPUT_MOTION & m_inputAreaEvent[iii].flags) && EVENT_INPUT_TYPE_MOVE == typeEvent)
|| ( (FLAG_EVENT_INPUT_ENTER & m_inputAreaEvent[iii].flags) && EVENT_INPUT_TYPE_ENTER == typeEvent)
|| ( (FLAG_EVENT_INPUT_LEAVE & m_inputAreaEvent[iii].flags) && EVENT_INPUT_TYPE_LEAVE == typeEvent)
|| ( (FLAG_EVENT_INPUT_DOWN & m_inputAreaEvent[iii].flags) && EVENT_INPUT_TYPE_DOWN == typeEvent)
|| ( (FLAG_EVENT_INPUT_UP & m_inputAreaEvent[iii].flags) && EVENT_INPUT_TYPE_UP == typeEvent)
|| ( (FLAG_EVENT_INPUT_CLICKED & m_inputAreaEvent[iii].flags) && EVENT_INPUT_TYPE_SINGLE == typeEvent)
|| ( (FLAG_EVENT_INPUT_CLICKED_DOUBLE & m_inputAreaEvent[iii].flags) && EVENT_INPUT_TYPE_DOUBLE == typeEvent)
|| ( (FLAG_EVENT_INPUT_CLICKED_TRIPLE & m_inputAreaEvent[iii].flags) && EVENT_INPUT_TYPE_TRIPLE == typeEvent)
)
)
{
if( (m_inputEvent[iii].area.flags & (1<<(IdInput-1)) )
&& ( ( (FLAG_EVENT_INPUT_MOTION & m_inputEvent[iii].area.flags) && EVENT_INPUT_TYPE_MOVE == typeEvent)
|| ( (FLAG_EVENT_INPUT_ENTER & m_inputEvent[iii].area.flags) && EVENT_INPUT_TYPE_ENTER == typeEvent)
|| ( (FLAG_EVENT_INPUT_LEAVE & m_inputEvent[iii].area.flags) && EVENT_INPUT_TYPE_LEAVE == typeEvent)
|| ( (FLAG_EVENT_INPUT_DOWN & m_inputEvent[iii].area.flags) && EVENT_INPUT_TYPE_DOWN == typeEvent)
|| ( (FLAG_EVENT_INPUT_UP & m_inputEvent[iii].area.flags) && EVENT_INPUT_TYPE_UP == typeEvent)
|| ( (FLAG_EVENT_INPUT_CLICKED & m_inputEvent[iii].area.flags) && EVENT_INPUT_TYPE_SINGLE == typeEvent)
|| ( (FLAG_EVENT_INPUT_CLICKED_DOUBLE & m_inputEvent[iii].area.flags) && EVENT_INPUT_TYPE_DOUBLE == typeEvent)
|| ( (FLAG_EVENT_INPUT_CLICKED_TRIPLE & m_inputEvent[iii].area.flags) && EVENT_INPUT_TYPE_TRIPLE == typeEvent)
)
)
{
ended = OnEventArea(m_inputEvent[iii].generateEventId, x, y);
if (true == ended) {
break;
}
if (true == GenEventInputExternal(m_inputEvent[iii].generateEventId, x, y)) {
ended = true;
break;
}
ended = OnEventArea(m_inputAreaEvent[iii].generateEventId, x, y);
if (true == ended) {
break;
}
if (true == GenEventInputExternal(m_inputAreaEvent[iii].generateEventId, x, y)) {
ended = true;
break;
}
}
}
@ -133,9 +176,35 @@ bool ewol::Widget::GenEventInputExternal(const char * generateEventId, etkFloat_
return ended;
}
bool ewol::Widget::GenEventShortCut(bool shift, bool control, bool alt, bool pomme, char UTF8_data[UTF8_MAX_SIZE])
bool ewol::Widget::GenEventShortCut(bool shift, bool control, bool alt, bool meta, uint32_t unicodeValue)
{
return true;
bool ended = false;
//EWOL_WARNING("Input event : " << IdInput << " pos(" << x << "," << y << ")");
for(int32_t iii=m_inputShortCutEvent.Size()-1; iii>=0; iii--) {
if( m_inputShortCutEvent[iii].shift == shift
&& m_inputShortCutEvent[iii].control == control
&& m_inputShortCutEvent[iii].alt == alt
&& m_inputShortCutEvent[iii].meta == meta
&& m_inputShortCutEvent[iii].UnicodeValue == unicodeValue)
{
/*
ended = OnEventArea(m_inputShortCutEvent[iii].generateEventId, -1, -1);
if (true == ended) {
break;
}
*/
if (true == GenEventInputExternal(m_inputShortCutEvent[iii].generateEventId, -1, -1)) {
ended = true;
break;
}
}
}
/*
if (false == ended) {
return OnEventInput(IdInput, typeEvent, -1, -1);
}
*/
return ended;
}
@ -167,30 +236,66 @@ bool ewol::Widget::AddEventArea(coord origin, coord size, uint64_t flags, const
return false;
}
*/
event_ts newEvent;
eventArea_ts newEvent;
newEvent.generateEventId = generateEventId;
newEvent.mode = EWOL_EVENT_AREA;
newEvent.area.origin.x = origin.x + m_origin.x;
newEvent.area.origin.y = origin.y + m_origin.y;
newEvent.area.size = size;
newEvent.area.flags = flags;
m_inputEvent.PushBack(newEvent);
newEvent.origin.x = origin.x + m_origin.x;
newEvent.origin.y = origin.y + m_origin.y;
newEvent.size = size;
newEvent.flags = flags;
m_inputAreaEvent.PushBack(newEvent);
//EWOL_DEBUG("Add an area event...");
return true;
}
bool ewol::Widget::AddEventShortCut(bool shift, bool control, bool alt, bool pomme, char UTF8_data[UTF8_MAX_SIZE], const char * generateEventId)
bool ewol::Widget::AddEventShortCut(bool shift, bool control, bool alt, bool meta, uint32_t unicodeValue, const char * generateEventId)
{
EWOL_TODO("code not writed now...");
eventShortCut_ts newEvent;
newEvent.generateEventId = generateEventId;
newEvent.shift = shift;
newEvent.control = control;
newEvent.alt = alt;
newEvent.meta = meta;
newEvent.UnicodeValue = unicodeValue;
m_inputShortCutEvent.PushBack(newEvent);
return true;
}
bool ewol::Widget::AddEventShortCut(char * descriptiveString, const char * generateEventId)
{
EWOL_TODO("code not writed now...");
return true;
if( NULL==descriptiveString
|| 0==strlen(descriptiveString))
{
return false;
}
bool shift = false;
bool control = false;
bool alt = false;
bool meta = false;
uint32_t UnicodeValue = 0;
// parsing of the string :
//"ctrl+shift+alt+meta+s"
char * tmp = strstr(descriptiveString, "ctrl");
if(NULL != tmp) {
control = true;
}
tmp = strstr(descriptiveString, "shift");
if(NULL != tmp) {
shift = true;
}
tmp = strstr(descriptiveString, "alt");
if(NULL != tmp) {
alt = true;
}
tmp = strstr(descriptiveString, "meta");
if(NULL != tmp) {
meta = true;
}
UnicodeValue = descriptiveString[strlen(descriptiveString) -1];
// add with generic Adding function ...
return AddEventShortCut(shift, control, alt, meta, UnicodeValue, generateEventId);
}

70
Sources/libewol/ewol/Widget.h
View File

@ -67,8 +67,37 @@ namespace ewol {
EVENT_KB_MOVE_TYPE_PAGE_DOWN,
EVENT_KB_MOVE_TYPE_START,
EVENT_KB_MOVE_TYPE_END,
EVENT_KB_MOVE_TYPE_CENTER,
EVENT_KB_MOVE_TYPE_ARRET_DEFIL,
EVENT_KB_MOVE_TYPE_WAIT,
EVENT_KB_MOVE_TYPE_INSERT,
EVENT_KB_MOVE_TYPE_F1,
EVENT_KB_MOVE_TYPE_F2,
EVENT_KB_MOVE_TYPE_F3,
EVENT_KB_MOVE_TYPE_F4,
EVENT_KB_MOVE_TYPE_F5,
EVENT_KB_MOVE_TYPE_F6,
EVENT_KB_MOVE_TYPE_F7,
EVENT_KB_MOVE_TYPE_F8,
EVENT_KB_MOVE_TYPE_F9,
EVENT_KB_MOVE_TYPE_F10,
EVENT_KB_MOVE_TYPE_F11,
EVENT_KB_MOVE_TYPE_F12,
EVENT_KB_MOVE_TYPE_CAPLOCK,
EVENT_KB_MOVE_TYPE_SHIFT_LEFT,
EVENT_KB_MOVE_TYPE_SHIFT_RIGHT,
EVENT_KB_MOVE_TYPE_CTRL_LEFT,
EVENT_KB_MOVE_TYPE_CTRL_RIGHT,
EVENT_KB_MOVE_TYPE_META_LEFT,
EVENT_KB_MOVE_TYPE_META_RIGHT,
EVENT_KB_MOVE_TYPE_ALT,
EVENT_KB_MOVE_TYPE_ALT_GR,
EVENT_KB_MOVE_TYPE_CONTEXT_MENU,
EVENT_KB_MOVE_TYPE_VER_NUM,
} eventKbMoveType_te;
char* GetCharTypeMoveEvent(eventKbMoveType_te type);
enum {
FLAG_EVENT_INPUT_1 = 1 << 0,
FLAG_EVENT_INPUT_2 = 1 << 1,
@ -112,22 +141,18 @@ namespace ewol {
extern "C" {
typedef struct {
const char * generateEventId; // event generate ID (to be unique it was pointer on the string name)
int32_t mode; //!< EWOL_EVENT_UNION or EWOL_EVENT_SHORTCUT
union {
struct {
bool shift;
bool control;
bool alt;
bool pomme;
char UTF8_data[UTF8_MAX_SIZE];
} shortCut;
struct {
coord origin; // widget specific
coord size; // widget specific
uint64_t flags; // widget specific
} area;
};
} event_ts;
coord origin; // widget specific
coord size; // widget specific
uint64_t flags; // widget specific
} eventArea_ts;
typedef struct {
const char * generateEventId; // event generate ID (to be unique it was pointer on the string name)
bool shift;
bool control;
bool alt;
bool meta;
uint32_t UnicodeValue;
} eventShortCut_ts;
typedef struct {
const char * generateEventId; //!< event generate ID (to be unique it was pointer on the string name)
int32_t widgetCall; //!< unique ID of the widget
@ -222,23 +247,24 @@ namespace ewol {
// -- Shortcut: (only for computer) ==> must be manage otherwise for tablette pc
// ----------------------------------------------------------------------------------------------------------------
private:
etk::VectorType<event_ts> m_inputEvent; //!< generic area and short-cut event
etk::VectorType<eventExtern_ts> m_externEvent; //!< Generic list of event generation for output link
etk::VectorType<const char*> m_ListEventAvaillable; //!< List of all event availlable for this widget
etk::VectorType<eventArea_ts> m_inputAreaEvent; //!< generic area event
etk::VectorType<eventShortCut_ts> m_inputShortCutEvent; //!< generic short-cut event
etk::VectorType<eventExtern_ts> m_externEvent; //!< Generic list of event generation for output link
etk::VectorType<const char*> m_ListEventAvaillable; //!< List of all event availlable for this widget
public:
// external acces to set an input event on this widget.
bool GenEventInput(int32_t IdInput, eventInputType_te typeEvent, etkFloat_t X, etkFloat_t Y); // call when input event arrive and call OnEventInput, if no event detected
bool GenEventInputExternal(const char * generateEventId, etkFloat_t x, etkFloat_t y);
bool GenEventShortCut(bool shift, bool control, bool alt, bool pomme, char UTF8_data[UTF8_MAX_SIZE]);
bool GenEventShortCut(bool shift, bool control, bool alt, bool meta, uint32_t unicodeValue);
protected:
void AddEventId(const char * generateEventId) {
if (NULL != generateEventId) {
m_ListEventAvaillable.PushBack(generateEventId);
}
}
void EventAreaRemoveAll(void) { m_inputEvent.Clear(); };
void EventAreaRemoveAll(void) { m_inputAreaEvent.Clear();m_inputShortCutEvent.Clear(); };
bool AddEventArea(coord origin, coord size, uint64_t flags, const char * generateEventId);
bool AddEventShortCut(bool shift, bool control, bool alt, bool pomme, char UTF8_data[UTF8_MAX_SIZE], const char * generateEventId);
bool AddEventShortCut(bool shift, bool control, bool alt, bool pomme, uint32_t unicodeValue, const char * generateEventId);
bool AddEventShortCut(char * descriptiveString, const char * generateEventId);
public:
// to link an extern widget at the internal event of this one it will access by here :

1
Sources/libewol/ewol/Windows.cpp
View File

@ -254,7 +254,6 @@ void ewol::Windows::PopUpWidgetPop(void)
bool ewol::Windows::OnEventAreaExternal(int32_t widgetID, const char * generateEventId, const char * eventExternId, etkFloat_t x, etkFloat_t y)
{
EWOL_DEBUG("kjhlkjhlkjhlkjhlkhlkjhlkjhlkjhlkjhlkjhlkjh");
if(ewolEventWindowsHideKeyboard == generateEventId) {
EWOL_INFO("Request Hide keyboard");
KeyboardHide();

1
Sources/libewol/ewol/base/gui.h
View File

@ -46,6 +46,7 @@ namespace guiAbstraction
void KeyboardHide(void);
void ForceRedrawAll(void);
void SendKeyboardEvent(bool isDown, etk::String &keyInput);
void SendKeyboardEventMove(bool isDown, ewol::eventKbMoveType_te &keyInput);
};
//!< must be define in CPP by the application ...

116
Sources/libewol/ewol/base/guiX11.cpp
View File

@ -641,16 +641,95 @@ namespace guiAbstraction {
case KeyRelease:
//EWOL_DEBUG("X11 event : " << event.type << " = \"KeyPress/KeyRelease\" ");
{
char buf[11];
KeySym keysym;
XComposeStatus status;
int count = XLookupString(&event.xkey, buf, 10, &keysym, &status);
buf[count] = '\0';
etk::String tmpData = buf;
if(event.type == KeyPress) {
SendKeyboardEvent(true, tmpData);
} else {
SendKeyboardEvent(true, tmpData);
EWOL_DEBUG("eventKey : " << event.xkey.keycode);
bool find = true;
ewol::eventKbMoveType_te keyInput;
switch (event.xkey.keycode) {
case 80: // keypad
case 111: keyInput = ewol::EVENT_KB_MOVE_TYPE_UP; break;
case 83: // keypad
case 113: keyInput = ewol::EVENT_KB_MOVE_TYPE_LEFT; break;
case 85: // keypad
case 114: keyInput = ewol::EVENT_KB_MOVE_TYPE_RIGHT; break;
case 88: // keypad
case 116: keyInput = ewol::EVENT_KB_MOVE_TYPE_DOWN; break;
case 81: // keypad
case 112: keyInput = ewol::EVENT_KB_MOVE_TYPE_PAGE_UP; break;
case 89: // keypad
case 117: keyInput = ewol::EVENT_KB_MOVE_TYPE_PAGE_DOWN; break;
case 79: // keypad
case 110: keyInput = ewol::EVENT_KB_MOVE_TYPE_START; break;
case 87: // keypad
case 115: keyInput = ewol::EVENT_KB_MOVE_TYPE_END; break;
case 78: keyInput = ewol::EVENT_KB_MOVE_TYPE_ARRET_DEFIL; break;
case 127: keyInput = ewol::EVENT_KB_MOVE_TYPE_WAIT; break;
case 90: // keypad
case 118: keyInput = ewol::EVENT_KB_MOVE_TYPE_INSERT; break;
case 84: keyInput = ewol::EVENT_KB_MOVE_TYPE_CENTER; break;
case 67: keyInput = ewol::EVENT_KB_MOVE_TYPE_F1; break;
case 68: keyInput = ewol::EVENT_KB_MOVE_TYPE_F2; break;
case 69: keyInput = ewol::EVENT_KB_MOVE_TYPE_F3; break;
case 70: keyInput = ewol::EVENT_KB_MOVE_TYPE_F4; break;
case 71: keyInput = ewol::EVENT_KB_MOVE_TYPE_F5; break;
case 72: keyInput = ewol::EVENT_KB_MOVE_TYPE_F6; break;
case 73: keyInput = ewol::EVENT_KB_MOVE_TYPE_F7; break;
case 74: keyInput = ewol::EVENT_KB_MOVE_TYPE_F8; break;
case 75: keyInput = ewol::EVENT_KB_MOVE_TYPE_F9; break;
case 76: keyInput = ewol::EVENT_KB_MOVE_TYPE_F10; break;
case 95: keyInput = ewol::EVENT_KB_MOVE_TYPE_F11; break;
case 96: keyInput = ewol::EVENT_KB_MOVE_TYPE_F12; break;
case 66: keyInput = ewol::EVENT_KB_MOVE_TYPE_CAPLOCK; break;
case 50: keyInput = ewol::EVENT_KB_MOVE_TYPE_SHIFT_LEFT; break;
case 62: keyInput = ewol::EVENT_KB_MOVE_TYPE_SHIFT_RIGHT; break;
case 37: keyInput = ewol::EVENT_KB_MOVE_TYPE_CTRL_LEFT; break;
case 105: keyInput = ewol::EVENT_KB_MOVE_TYPE_CTRL_RIGHT; break;
case 133: keyInput = ewol::EVENT_KB_MOVE_TYPE_META_LEFT; break;
case 134: keyInput = ewol::EVENT_KB_MOVE_TYPE_META_RIGHT; break;
case 64: keyInput = ewol::EVENT_KB_MOVE_TYPE_ALT; break;
case 108: keyInput = ewol::EVENT_KB_MOVE_TYPE_ALT_GR; break;
case 135: keyInput = ewol::EVENT_KB_MOVE_TYPE_CONTEXT_MENU; break;
case 77: keyInput = ewol::EVENT_KB_MOVE_TYPE_VER_NUM; break;
case 91: // Suppr on keypad
find = false;
{
char buf[2];
buf[0] = 0x7F;
buf[1] = 0x00;
etk::String tmpData = buf;
if(event.type == KeyPress) {
SendKeyboardEvent(true, tmpData);
} else {
SendKeyboardEvent(false, tmpData);
}
}
default:
find = false;
{
char buf[11];
KeySym keysym;
XComposeStatus status;
int count = XLookupString(&event.xkey, buf, 10, &keysym, &status);
buf[count] = '\0';
if (count>0) {
etk::String tmpData = buf;
if(event.type == KeyPress) {
SendKeyboardEvent(true, tmpData);
} else {
SendKeyboardEvent(false, tmpData);
}
} else {
EWOL_WARNING("Unknow event Key : " << event.xkey.keycode);
}
}
break;
}
if (true == find) {
EWOL_DEBUG("eventKey Move type : " << GetCharTypeMoveEvent(keyInput) );
if(event.type == KeyPress) {
SendKeyboardEventMove(true, keyInput);
} else {
SendKeyboardEventMove(false, keyInput);
}
}
break;
}
@ -670,7 +749,7 @@ namespace guiAbstraction {
}
}
Draw();
usleep( 100000 );
//usleep( 100000 );
}
};
@ -871,7 +950,6 @@ void guiAbstraction::ForceRedrawAll(void)
}
}
void guiAbstraction::SendKeyboardEvent(bool isDown, etk::String &keyInput)
{
// Get the current Focused Widget :
@ -887,6 +965,20 @@ void guiAbstraction::SendKeyboardEvent(bool isDown, etk::String &keyInput)
}
}
void guiAbstraction::SendKeyboardEventMove(bool isDown, ewol::eventKbMoveType_te &keyInput)
{
// Get the current Focused Widget :
ewol::Widget * tmpWidget = ewol::widgetManager::FocusGet();
if (NULL != tmpWidget) {
if(true == isDown) {
tmpWidget->OnEventKbMove(ewol::EVENT_KB_TYPE_DOWN, keyInput);
} else {
tmpWidget->OnEventKbMove(ewol::EVENT_KB_TYPE_UP, keyInput);
}
}
}
#include <ewol/ewol.h>