bool appl::TextViewer::replace(const std::string& _data, const appl::Buffer::Iterator& _pos, const appl::Buffer::Iterator& _posEnd) {
if (m_buffer == nullptr) {
return false;
}
markToRedraw();
if (m_pluginManager->onReplace(*this, _pos, _data, _posEnd) == true) {
// no call of the move cursor, because pluging might call theses function to copy and cut data...
updateScrolling();
return true;
}
bool ret = m_buffer->replace(_data, _pos, _posEnd);
m_pluginManager->onCursorMove(*this, m_buffer->cursor());
updateScrolling();
return ret;
}
void appl::TextViewer::remove() {
if (m_buffer == nullptr) {
return;
}
if (m_buffer->hasTextSelected() == false) {
// nothing to do ...
return;
}
markToRedraw();
if (m_pluginManager->onRemove(*this, m_buffer->selectStart(), m_buffer->selectStop()) == true) {
return;
}
m_buffer->removeSelection();
m_pluginManager->onCursorMove(*this, m_buffer->cursor());
}
// select the specific file
void ewol::widget::ListFileSystem::setSelect(const std::string& _data) {
// remove selected line
m_selectedLine = -1;
// search the coresponding file :
for (size_t iii=0; iii<m_list.size(); iii++) {
if (nullptr!=m_list[iii]) {
if (m_list[iii]->getNameFile() == _data) {
// we find the line :
m_selectedLine = iii;
break;
}
}
}
markToRedraw();
}
void appl::TextViewer::moveCursorLeft(appl::TextViewer::moveMode _mode) {
if (m_buffer == nullptr) {
return;
}
markToRedraw();
appl::Buffer::Iterator it;
switch (_mode) {
default:
case moveLetter:
it = m_buffer->cursor();
--it;
moveCursor(it);
break;
case moveWord:
// TODO : ...
break;
case moveEnd:
it = m_buffer->getStartLine(m_buffer->cursor());
moveCursor(it);
break;
}
}
void ewol::widget::Button::onChangePropertyValue() {
if (*propertyToggleMode == true) {
if (*propertyValue == false) {
m_idWidgetDisplayed = 0;
} else {
m_idWidgetDisplayed = 1;
}
}
if (*propertyEnableSingle == true) {
if ( m_idWidgetDisplayed == 0
&& m_subWidget[0] == nullptr
&& m_subWidget[1] != nullptr) {
m_idWidgetDisplayed = 1;
} else if ( m_idWidgetDisplayed == 1
&& m_subWidget[1] == nullptr
&& m_subWidget[0] != nullptr) {
m_idWidgetDisplayed = 0;
}
}
CheckStatus();
markToRedraw();
}
void ewol::widget::Image::calculateMinMaxSize() {
vec2 imageBoder = m_border->getPixel()*2.0f;
vec2 imageSize = m_imageSize->getPixel();
vec2 size = m_userMinSize->getPixel();
if (imageSize != vec2(0,0)) {
m_minSize = imageBoder+imageSize;
m_maxSize = m_minSize;
} else {
vec2 imageSizeReal = m_compositing.getRealSize();
vec2 min1 = imageBoder+m_userMinSize->getPixel();
m_minSize = imageBoder+imageSizeReal;
//EWOL_DEBUG(" set max : " << m_minSize << " " << min1);
m_minSize.setMax(min1);
//EWOL_DEBUG(" result : " << m_minSize);
m_maxSize = imageBoder+m_userMaxSize->getPixel();
m_minSize.setMin(m_maxSize);
}
m_imageRenderSize = m_minSize;
m_minSize.setMax(size);
m_maxSize.setMax(m_minSize);
//EWOL_ERROR("set widget min=" << m_minSize << " max=" << m_maxSize << " with real Image size=" << m_imageRenderSize << " img size=" << imageSize << " " << m_imageSize);
markToRedraw();
}
void ewol::widget::Spacer::onParameterChangeValue(const ewol::parameter::Ref& _paramPointer) {
ewol::Widget::onParameterChangeValue(_paramPointer);
if (_paramPointer == m_color) {
markToRedraw();
}
}
void ewol::widget::ColorBar::calculateMinMaxSize() {
m_minSize.setValue(160, 80);
markToRedraw();
}
void ewol::widget::ContextMenu::calculateSize(const vec2& _availlable) {
//EWOL_DEBUG("CalculateSize=" << availlable);
// pop-up fill all the display :
m_size = _availlable;
ewol::Padding padding = m_shaper->getPadding();
EWOL_VERBOSE("our origin=" << m_origin << " size=" << m_size);
if (nullptr != m_subWidget) {
vec2 subWidgetSize;
vec2 subWidgetOrigin;
subWidgetSize = m_subWidget->getCalculateMinSize();
if (true == m_subWidget->canExpand().x()) {
subWidgetSize.setX(m_size.x());
}
if (true == m_subWidget->canExpand().y()) {
subWidgetSize.setY(m_size.y());
}
int32_t minWidth = 100;
int32_t maxWidth = 300;
subWidgetSize.setX((int32_t)std::max(minWidth, (int32_t)subWidgetSize.x()));
subWidgetSize.setX((int32_t)std::min(maxWidth, (int32_t)subWidgetSize.x()));
subWidgetSize.setY((int32_t)subWidgetSize.y());
// set config to the Sub-widget
switch (m_arrawBorder) {
case markTop:
subWidgetOrigin.setX((int32_t)(m_arrowPos->x() - subWidgetSize.x()/2));
subWidgetOrigin.setY((int32_t)(m_arrowPos->y() - m_offset - subWidgetSize.y()));
break;
case markButtom:
subWidgetOrigin.setX((int32_t)(m_arrowPos->x() - subWidgetSize.x()/2));
subWidgetOrigin.setY((int32_t)(m_arrowPos->y() + m_offset));
break;
case markRight:
case markLeft:
default:
subWidgetOrigin.setX((int32_t)(m_size.x() - m_origin.x() - subWidgetSize.x())/2 + m_origin.x());
subWidgetOrigin.setY((int32_t)(m_size.y() - m_origin.y() - subWidgetSize.y())/2 + m_origin.y());
break;
}
// set the widget position at the border of the screen
subWidgetOrigin.setX( (int32_t)( std::max(0, (int32_t)(subWidgetOrigin.x()-padding.x()))
+ padding.x()) );
subWidgetOrigin.setY( (int32_t)( std::max(0, (int32_t)(subWidgetOrigin.y()-padding.y()))
+ padding.y()) );
switch (m_arrawBorder) {
default:
case markTop:
case markButtom:
if (m_arrowPos->x() <= m_offset ) {
subWidgetOrigin.setX(m_arrowPos->x()+padding.xLeft());
}
break;
case markRight:
case markLeft:
if (m_arrowPos->y() <= m_offset ) {
subWidgetOrigin.setY(m_arrowPos->y()+padding.yButtom());
}
break;
}
EWOL_VERBOSE(" == > sub origin=" << subWidgetOrigin << " size=" << subWidgetSize);
m_subWidget->setOrigin(subWidgetOrigin);
m_subWidget->calculateSize(subWidgetSize);
}
markToRedraw();
}
void ewol::widget::Button::periodicCall(const ewol::event::Time& _event) {
if (m_shaper.periodicCall(_event) == false) {
m_PCH.disconnect();
}
markToRedraw();
}
void appl::TextViewer::onCallbackIsModify() {
markToRedraw();
}
bool appl::TextViewer::onEventInput(const ewol::event::Input& _event) {
if ( _event.getId() != 0
&& _event.getStatus() == gale::key::status::down) {
keepFocus();
}
//tic();
if (m_buffer == nullptr) {
return false;
}
// First call the scrolling widget :
if (ewol::widget::WidgetScrolled::onEventInput(_event) == true) {
markToRedraw();
return true;
}
// Second call plugin
if (m_pluginManager->onEventInput(*this, _event) == true) {
markToRedraw();
return true;
}
vec2 relativePos = relativePosition(_event.getPos());
// offset for the lineNumber:
relativePos -= vec2(m_lastOffsetDisplay, 0);
// offset for the scrolling:
relativePos += vec2(m_originScrooled.x(), -m_originScrooled.y());
// invert for the buffer event ...
relativePos.setY(m_size.y()-relativePos.y());
if (relativePos.x()<0) {
relativePos.setX(0);
}
if ( _event.getId() == 12
&& _event.getStatus() == gale::key::status::pressSingle) {
APPL_TODO("RAT5 SAVE button ==> TODO implement");
// Rat5 save event
//sendMultiCast(ednMsgGuiSave, "current");
return true;
}
// just forward event == > manage directly in the buffer
if (_event.getId() == 1) {
// mouse selection :
//if (_event.getType() == gale::key::typeMouse) {
if (_event.getStatus() == gale::key::status::down) {
//if (_event.getSpecialKey().isSetShift() == false) {
appl::Buffer::Iterator newPos = getMousePosition(relativePos);
m_buffer->setSelectMode(false);
moveCursor(newPos);
m_buffer->setSelectMode(true);
markToRedraw();
return true;
//}
} else if (_event.getStatus() == gale::key::status::up) {
appl::Buffer::Iterator newPos = getMousePosition(relativePos);
moveCursor(newPos);
m_buffer->setSelectMode(false);
// Copy selection :
std::string value;
m_buffer->copy(value);
if (value.size() != 0) {
gale::context::clipBoard::set(gale::context::clipBoard::clipboardSelection, value);
}
markToRedraw();
return true;
}
//}
if (_event.getStatus() == gale::key::status::pressSingle) {
if ( _event.getType() == gale::key::type::mouse
|| _event.getType() == gale::key::type::finger) {
appl::Buffer::Iterator newPos = getMousePosition(relativePos);
moveCursor(newPos);
markToRedraw();
return true;
}
} else if (_event.getStatus() == gale::key::status::pressDouble) {
mouseEventDouble();
// Copy selection :
std::string value;
m_buffer->copy(value);
if (value.size() != 0) {
gale::context::clipBoard::set(gale::context::clipBoard::clipboardSelection, value);
}
markToRedraw();
return true;
} else if (_event.getStatus() == gale::key::status::pressTriple) {
mouseEventTriple();
// Copy selection :
std::string value;
m_buffer->copy(value);
if (value.size() != 0) {
gale::context::clipBoard::set(gale::context::clipBoard::clipboardSelection, value);
}
markToRedraw();
return true;
} else if (_event.getStatus() == gale::key::status::move) {
if (m_buffer->getSelectMode() == true) {
//int64_t timeStart = ewol::getTime();
appl::Buffer::Iterator newPos = getMousePosition(relativePos);
//int64_t timeMedium1 = ewol::getTime();
moveCursor(newPos);
//int64_t timeMedium2 = ewol::getTime();
markToRedraw();
/*
int64_t timeStop = ewol::getTime();
APPL_DEBUG("Display selection=" << (timeStop-timeStart)/1000.0f << " ms");
APPL_DEBUG(" 1=" << (timeMedium1-timeStart)/1000.0f << " ms");
APPL_DEBUG(" 2=" << (timeMedium2-timeMedium1)/1000.0f << " ms");
*/
return true;
}
}
} else if (2 == _event.getId()) {
if (gale::key::status::pressSingle == _event.getStatus()) {
appl::Buffer::Iterator newPos = getMousePosition(relativePos);
moveCursor(newPos);
gale::context::clipBoard::request(gale::context::clipBoard::clipboardSelection);
markToRedraw();
return true;
}
}
return false;
}
bool appl::TextViewer::onEventEntry(const ewol::event::Entry& _event) {
if (m_buffer == nullptr) {
return false;
}
// First call plugin
if (m_pluginManager->onEventEntry(*this, _event) == true) {
markToRedraw();
return true;
}
// just forward event == > manage directly in the buffer
if (_event.getType() == gale::key::keyboard::character) {
//APPL_DEBUG("KB EVENT : \"" << UTF8_data << "\" size=" << strlen(UTF8_data) << "type=" << (int32_t)typeEvent);
if (_event.getStatus() != gale::key::status::down) {
return false;
}
char32_t localValue = _event.getChar();
if (localValue == u32char::Return) {
if (true == _event.getSpecialKey().getShift()) {
localValue = u32char::CarrierReturn;
}
} else if (localValue == u32char::Suppress ) {
//APPL_INFO("keyEvent : <suppr> pos=" << m_cursorPos);
if (m_buffer->hasTextSelected()) {
remove();
} else {
appl::Buffer::Iterator pos = m_buffer->cursor();
appl::Buffer::Iterator posEnd = pos;
++posEnd;
replace("", pos, posEnd);
}
return true;
} else if (localValue == u32char::Delete) {
//APPL_INFO("keyEvent : <del> pos=" << m_cursorPos);
if (m_buffer->hasTextSelected()) {
remove();
} else {
appl::Buffer::Iterator pos = m_buffer->cursor();
appl::Buffer::Iterator posEnd = pos;
--pos;
replace("", pos, posEnd);
}
return true;
}
m_buffer->setSelectMode(false);
// normal adding char ...
char output[5];
output[0] = '0';
u32char::convertUtf8(localValue, output);
if ( m_buffer->hasTextSelected() == false
&& _event.getSpecialKey().getInsert() == true) {
appl::Buffer::Iterator pos = m_buffer->cursor();
appl::Buffer::Iterator posEnd = pos;
++posEnd;
replace(output, pos, posEnd);
//TODO : choisce UTF ... replace(localValue, pos, posEnd);
} else {
std::string myString = output;
write(myString);
}
return true;
}
// move events ...
if (_event.getStatus() == gale::key::status::down) {
// selection when shift is set:
m_buffer->setSelectMode(_event.getSpecialKey().getShift());
// check selection event ...
switch(_event.getType()) {
case gale::key::keyboard::insert:
m_insertMode = m_insertMode==true?false:true;
markToRedraw();
break;
case gale::key::keyboard::left:
//APPL_INFO("keyEvent : <LEFT>");
moveCursorLeft();
break;
case gale::key::keyboard::right:
//APPL_INFO("keyEvent : <RIGHT>");
moveCursorRight();
break;
case gale::key::keyboard::up:
//APPL_INFO("keyEvent : <UP>");
moveCursorUp(1);
break;
case gale::key::keyboard::down:
//APPL_INFO("keyEvent : <DOWN>");
moveCursorDown(1);
break;
case gale::key::keyboard::pageUp:
//APPL_INFO("keyEvent : <PAGE-UP>");
moveCursorUp(15); // TODO : Set the real number of line ...
break;
case gale::key::keyboard::pageDown:
//APPL_INFO("keyEvent : <PAGE-DOWN>");
moveCursorDown(15); // TODO : Set the real number of line ...
break;
case gale::key::keyboard::start:
//APPL_INFO("keyEvent : <Start of line>");
moveCursorLeft(moveEnd);
break;
case gale::key::keyboard::end:
//APPL_INFO("keyEvent : <End of line>");
moveCursorRight(moveEnd);
break;
default:
break;
}
return true;
}
return false;
}
void ewol::widget::Parameter::init() {
ewol::widget::PopUp::init();
std::shared_ptr<ewol::widget::Sizer> mySizerVert = nullptr;
std::shared_ptr<ewol::widget::Sizer> mySizerHori = nullptr;
std::shared_ptr<ewol::widget::Spacer> mySpacer = nullptr;
#ifdef __TARGET_OS__Android
setMinSize(ewol::Dimension(vec2(90, 90), ewol::Dimension::Pourcent));
#else
setMinSize(ewol::Dimension(vec2(80, 80), ewol::Dimension::Pourcent));
#endif
mySizerVert = ewol::widget::Sizer::create(widget::Sizer::modeVert);
if (nullptr == mySizerVert) {
EWOL_ERROR("Can not allocate widget == > display might be in error");
} else {
EWOL_INFO("add widget");
mySizerVert->lockExpand(bvec2(true,true));
mySizerVert->setExpand(bvec2(true,true));
// set it in the pop-up-system :
setSubWidget(mySizerVert);
mySizerHori = ewol::widget::Sizer::create(widget::Sizer::modeHori);
if (nullptr == mySizerHori) {
EWOL_ERROR("Can not allocate widget == > display might be in error");
} else {
mySizerVert->subWidgetAdd(mySizerHori);
mySpacer = ewol::widget::Spacer::create();
if (nullptr == mySpacer) {
EWOL_ERROR("Can not allocate widget == > display might be in error");
} else {
mySpacer->setExpand(bvec2(true,false));
mySizerHori->subWidgetAdd(mySpacer);
}
std::shared_ptr<ewol::widget::Button> tmpButton = widget::Button::create();
if (nullptr == tmpButton) {
EWOL_ERROR("Can not allocate widget == > display might be in error");
} else {
tmpButton->setSubWidget(ewol::widget::Composer::create(widget::Composer::String,
"<composer>\n"
" <sizer mode=\"hori\">\n"
" <image src=\"THEME:GUI:Save.svg\" expand=\"true\" size=\"8,8mm\"/>\n"
" <label>Save</label>\n"
" </sizer>\n"
"</composer>\n"));
tmpButton->signalPressed.bind(shared_from_this(), &ewol::widget::Parameter::onCallbackParameterSave);
mySizerHori->subWidgetAdd(tmpButton);
}
mySpacer = ewol::widget::Spacer::create();
if (nullptr == mySpacer) {
EWOL_ERROR("Can not allocate widget == > display might be in error");
} else {
mySpacer->setExpand(bvec2(false,false));
mySpacer->setMinSize(ewol::Dimension(vec2(10,0)));
mySizerHori->subWidgetAdd(mySpacer);
}
tmpButton = ewol::widget::Button::create();
if (nullptr == tmpButton) {
EWOL_ERROR("Can not allocate widget == > display might be in error");
} else {
tmpButton->setSubWidget(ewol::widget::Composer::create(widget::Composer::String,
"<composer>\n"
" <sizer mode=\"hori\">\n"
" <image src=\"THEME:GUI:Remove.svg\" expand=\"true\" size=\"8,8mm\"/>\n"
" <label>Close</label>\n"
" </sizer>\n"
"</composer>\n"));
tmpButton->signalPressed.bind(shared_from_this(), &ewol::widget::Parameter::onCallbackMenuclosed);
mySizerHori->subWidgetAdd(tmpButton);
}
}
mySizerHori = ewol::widget::Sizer::create(widget::Sizer::modeHori);
if (nullptr == mySizerHori) {
EWOL_ERROR("Can not allocate widget == > display might be in error");
} else {
mySizerVert->subWidgetAdd(mySizerHori);
m_paramList = ewol::widget::ParameterList::create();
if (nullptr == m_paramList) {
EWOL_ERROR("Can not allocate widget == > display might be in error");
} else {
m_paramList->signalSelect.bind(shared_from_this(), &ewol::widget::Parameter::onCallbackMenuSelected);
m_paramList->setFill(bvec2(false,true));
m_paramList->setExpand(bvec2(false,true));
mySizerHori->subWidgetAdd(m_paramList);
}
mySpacer = ewol::widget::Spacer::create();
if (nullptr == mySpacer) {
EWOL_ERROR("Can not allocate widget == > display might be in error");
} else {
mySpacer->setFill(bvec2(false,true));
mySpacer->setMinSize(vec2(5,5));
mySpacer->setColor(0x000000BF);
mySizerHori->subWidgetAdd(mySpacer);
}
std::shared_ptr<ewol::widget::Sizer> mySizerVert2 = widget::Sizer::create(widget::Sizer::modeVert);
if (nullptr == mySizerVert2) {
EWOL_ERROR("Can not allocate widget == > display might be in error");
} else {
mySizerHori->subWidgetAdd(mySizerVert2);
mySpacer = ewol::widget::Spacer::create();
if (nullptr == mySpacer) {
EWOL_ERROR("Can not allocate widget == > display might be in error");
} else {
mySpacer->setExpand(bvec2(true,false));
mySpacer->setMinSize(vec2(5,5));
mySpacer->setColor(0x000000BF);
mySizerVert2->subWidgetAdd(mySpacer);
}
m_wSlider = ewol::widget::WSlider::create();
if (nullptr == m_wSlider) {
EWOL_ERROR("Can not allocate widget == > display might be in error");
} else {
m_wSlider->setTransitionSpeed(0.5);
m_wSlider->setTransitionMode(ewol::widget::WSlider::sladingTransitionVert);
m_wSlider->setExpand(bvec2(true,true));
mySizerVert2->subWidgetAdd(m_wSlider);
}
}
}
mySpacer = ewol::widget::Spacer::create();
if (nullptr == mySpacer) {
EWOL_ERROR("Can not allocate widget == > display might be in error");
} else {
mySpacer->setExpand(bvec2(true,false));
mySpacer->setMinSize(vec2(5,5));
mySpacer->setColor(0x000000BF);
mySizerVert->subWidgetAdd(mySpacer);
}
m_widgetTitle = ewol::widget::Label::create("File chooser ...");
if (nullptr == m_widgetTitle) {
EWOL_ERROR("Can not allocate widget == > display might be in error");
} else {
m_widgetTitle->setExpand(bvec2(true,false));
mySizerVert->subWidgetAdd(m_widgetTitle);
}
}
markToRedraw();
}
void ege::widget::Scene::periodicCall(const ewol::event::Time& _event) {
markToRedraw();
}
void appl::widget::VectorDisplay::setValue(const std::vector<float>& _data) {
m_data = _data;
markToRedraw();
}
void appl::widget::VectorDisplay::init() {
ewol::Widget::init();
markToRedraw();
}
void appl::TextViewer::onCallbackSelectChange() {
markToRedraw();
}
void ewol::widget::Button::changeStatusIn(int32_t _newStatusId) {
if (m_shaper.changeStatusIn(_newStatusId) == true) {
m_PCH = getObjectManager().periodicCall.connect(this, &ewol::widget::Button::periodicCall);
markToRedraw();
}
}
void appl::TextViewer::onGetFocus() {
showKeyboard();
APPL_INFO("Focus - In");
setCurrentSelect();
markToRedraw();
}
void ewol::widget::Button::onChangePropertyShape() {
m_shaper.setSource(*propertyShape);
markToRedraw();
}
void appl::TextViewer::onLostFocus() {
hideKeyboard();
APPL_INFO("Focus - out");
markToRedraw();
}
bool ewol::widget::Button::onEventInput(const ewol::event::Input& _event) {
EWOL_VERBOSE("Event on BT : " << _event);
// disable event in the lock access mode :
if(ewol::widget::Button::lockAccess == *propertyLock) {
return false;
}
if( gale::key::status::leave == _event.getStatus()
|| gale::key::status::abort == _event.getStatus()) {
m_mouseHover = false;
m_buttonPressed = false;
} else {
vec2 relativePos = relativePosition(_event.getPos());
// prevent error from ouside the button
if( relativePos.x() < m_selectableAreaPos.x()
|| relativePos.y() < m_selectableAreaPos.y()
|| relativePos.x() > m_selectableAreaPos.x() + m_selectableAreaSize.x()
|| relativePos.y() > m_selectableAreaPos.y() + m_selectableAreaSize.y() ) {
m_mouseHover = false;
m_buttonPressed = false;
} else {
m_mouseHover = true;
}
}
EWOL_VERBOSE("Event on BT ... mouse hover : " << m_mouseHover);
if (true == m_mouseHover) {
if (1 == _event.getId()) {
if(gale::key::status::down == _event.getStatus()) {
EWOL_VERBOSE(*propertyName << " : Generate event : " << signalDown);
signalDown.emit();
m_buttonPressed = true;
markToRedraw();
}
if(gale::key::status::up == _event.getStatus()) {
EWOL_VERBOSE(*propertyName << " : Generate event : " << signalUp);
signalUp.emit();
m_buttonPressed = false;
markToRedraw();
}
if(gale::key::status::pressSingle == _event.getStatus()) {
if( ( *propertyValue == true
&& ewol::widget::Button::lockWhenPressed == propertyLock)
|| ( *propertyValue == false
&& ewol::widget::Button::lockWhenReleased == propertyLock) ) {
// nothing to do : Lock mode ...
// user might set himself the new correct value with @ref setValue(xxx)
} else {
// inverse value :
propertyValue.set((*propertyValue)?false:true);
EWOL_VERBOSE(*propertyName << " : Generate event : " << signalPressed);
signalPressed.emit();
EWOL_VERBOSE(*propertyName << " : Generate event : " << signalValue << " val=" << *propertyValue );
signalValue.emit(*propertyValue);
if( *propertyToggleMode == false
&& *propertyValue == true) {
propertyValue.set(false);
EWOL_VERBOSE(*propertyName << " : Generate event : " << signalValue << " val=" << *propertyValue);
signalValue.emit(*propertyValue);
}
}
markToRedraw();
}
}
}
CheckStatus();
return m_mouseHover;
}
void ewol::widget::ButtonColor::changeStatusIn(int32_t _newStatusId) {
if (true == m_shaper.changeStatusIn(_newStatusId) ) {
periodicCallEnable();
markToRedraw();
}
}
bool ewol::widget::ColorBar::onEventInput(const ewol::event::Input& _event) {
vec2 relativePos = relativePosition(_event.getPos());
//EWOL_DEBUG("Event on BT ...");
if (1 == _event.getId()) {
relativePos.setValue( std::avg(0.0f, m_size.x(),relativePos.x()),
std::avg(0.0f, m_size.y(),relativePos.y()) );
if( gale::key::status_single == _event.getStatus()
|| gale::key::status_move == _event.getStatus()) {
// nothing to do ...
m_currentUserPos.setValue( relativePos.x()/m_size.x(),
relativePos.y()/m_size.y() );
markToRedraw();
// == > try to estimate color
EWOL_VERBOSE("event on (" << relativePos.x() << "," << relativePos.y() << ")");
int32_t bandID = (int32_t)(relativePos.x()/(m_size.x()/6));
float localPos = relativePos.x() - (m_size.x()/6) * bandID;
float poroportionnalPos = localPos/(m_size.x()/6);
EWOL_VERBOSE("bandId=" << bandID << " relative pos=" << localPos);
etk::Color<> estimateColor = etk::color::white;
if (s_listColor[bandID].r() == s_listColor[bandID+1].r()) {
estimateColor.setR(s_listColor[bandID].r());
} else if (s_listColor[bandID].r() < s_listColor[bandID+1].r()) {
estimateColor.setR(s_listColor[bandID].r() + (s_listColor[bandID+1].r()-s_listColor[bandID].r())*poroportionnalPos);
} else {
estimateColor.setR(s_listColor[bandID+1].r() + (s_listColor[bandID].r()-s_listColor[bandID+1].r())*(1-poroportionnalPos));
}
if (s_listColor[bandID].g() == s_listColor[bandID+1].g()) {
estimateColor.setG(s_listColor[bandID].g());
} else if (s_listColor[bandID].g() < s_listColor[bandID+1].g()) {
estimateColor.setG(s_listColor[bandID].g() + (s_listColor[bandID+1].g()-s_listColor[bandID].g())*poroportionnalPos);
} else {
estimateColor.setG(s_listColor[bandID+1].g() + (s_listColor[bandID].g()-s_listColor[bandID+1].g())*(1-poroportionnalPos));
}
if (s_listColor[bandID].b() == s_listColor[bandID+1].b()) {
estimateColor.setB(s_listColor[bandID].b());
} else if (s_listColor[bandID].b() < s_listColor[bandID+1].b()) {
estimateColor.setB(s_listColor[bandID].b() + (s_listColor[bandID+1].b()-s_listColor[bandID].b())*poroportionnalPos);
} else {
estimateColor.setB(s_listColor[bandID+1].b() + (s_listColor[bandID].b()-s_listColor[bandID+1].b())*(1-poroportionnalPos));
}
// step 2 generate the white and black ...
if (m_currentUserPos.y() == 0.5) {
// nothing to do ... just get the current color ...
} else if (m_currentUserPos.y() < 0.5) {
float poroportionnalWhite = (0.5-m_currentUserPos.y())*2.0;
estimateColor.setR(estimateColor.r() + (0xFF-estimateColor.r())*poroportionnalWhite);
estimateColor.setG(estimateColor.g() + (0xFF-estimateColor.g())*poroportionnalWhite);
estimateColor.setB(estimateColor.b() + (0xFF-estimateColor.b())*poroportionnalWhite);
} else {
float poroportionnalBlack = (m_currentUserPos.y()-0.5)*2.0;
estimateColor.setR(estimateColor.r() - estimateColor.r()*poroportionnalBlack);
estimateColor.setG(estimateColor.g() - estimateColor.g()*poroportionnalBlack);
estimateColor.setB(estimateColor.b() - estimateColor.b()*poroportionnalBlack);
}
if(m_currentColor != estimateColor) {
m_currentColor = estimateColor;
signalChange.emit(m_currentColor);
}
return true;
}
}
return false;
}
void ewol::widget::Spacer::onChangePropertyColor() {
markToRedraw();
}
bool ewol::widget::ButtonColor::onEventInput(const ewol::event::Input& _event) {
bool previousHoverState = m_mouseHover;
if(ewol::key::statusLeave == _event.getStatus()) {
m_mouseHover = false;
m_buttonPressed = false;
} else {
vec2 relativePos = relativePosition(_event.getPos());
// prevent error from ouside the button
if( relativePos.x() < m_selectableAreaPos.x()
|| relativePos.y() < m_selectableAreaPos.y()
|| relativePos.x() > m_selectableAreaPos.x() + m_selectableAreaSize.x()
|| relativePos.y() > m_selectableAreaPos.y() + m_selectableAreaSize.y() ) {
m_mouseHover = false;
m_buttonPressed = false;
} else {
m_mouseHover = true;
}
}
bool previousPressed = m_buttonPressed;
//EWOL_DEBUG("Event on BT ... mouse position : " << m_mouseHover);
if (true == m_mouseHover) {
if (1 == _event.getId()) {
if(ewol::key::statusDown == _event.getStatus()) {
m_buttonPressed = true;
markToRedraw();
}
if(ewol::key::statusUp == _event.getStatus()) {
m_buttonPressed = false;
markToRedraw();
}
if(ewol::key::statusSingle == _event.getStatus()) {
m_buttonPressed = false;
m_mouseHover = false;
// create a context menu :
m_widgetContextMenu = ewol::widget::ContextMenu::create();
if (nullptr == m_widgetContextMenu) {
EWOL_ERROR("Allocation Error");
return true;
}
vec2 tmpPos = m_origin + m_selectableAreaPos + m_selectableAreaSize;
tmpPos.setX( tmpPos.x() - m_minSize.x()/2.0);
m_widgetContextMenu->setPositionMark(ewol::widget::ContextMenu::markButtom, tmpPos );
std::shared_ptr<ewol::widget::ColorChooser> myColorChooser = widget::ColorChooser::create();
myColorChooser->setColor(m_textColorFg.get());
// set it in the pop-up-system :
m_widgetContextMenu->setSubWidget(myColorChooser);
myColorChooser->signalChange.bind(shared_from_this(), &ewol::widget::ButtonColor::onCallbackColorChange);
std::shared_ptr<ewol::widget::Windows> currentWindows = getWindows();
if (currentWindows == nullptr) {
EWOL_ERROR("Can not get the curent Windows...");
m_widgetContextMenu.reset();
} else {
currentWindows->popUpWidgetPush(m_widgetContextMenu);
}
markToRedraw();
}
}
}
if( m_mouseHover != previousHoverState
|| m_buttonPressed != previousPressed) {
if (true == m_buttonPressed) {
changeStatusIn(STATUS_PRESSED);
} else {
if (true == m_mouseHover) {
changeStatusIn(STATUS_HOVER);
} else {
changeStatusIn(STATUS_UP);
}
}
}
return m_mouseHover;
}
bool ewol::widget::ListFileSystem::onItemEvent(int32_t _IdInput,
enum gale::key::status _typeEvent,
int32_t _colomn,
int32_t _raw,
float _x,
float _y) {
int32_t offset = 0;
if (m_showFolder == true) {
if (m_folder.get() == "/") {
offset = 1;
} else {
offset = 2;
}
}
if (_typeEvent == gale::key::status_single) {
EWOL_VERBOSE("Event on List : IdInput=" << _IdInput << " colomn=" << _colomn << " raw=" << _raw );
if (1 == _IdInput) {
int32_t previousRaw = m_selectedLine;
if (_raw > (int32_t)m_list.size()+offset ) {
m_selectedLine = -1;
} else {
m_selectedLine = _raw;
}
if (previousRaw != m_selectedLine) {
if( m_showFolder == true
&& m_selectedLine == 0) {
// "." folder
signalFolderSelect.emit(".");
} else if ( m_showFolder == true
&& m_selectedLine == 1) {
// ".." folder
signalFolderSelect.emit("..");
} else if( m_selectedLine-offset >= 0
&& m_selectedLine-offset < (int32_t)m_list.size()
&& nullptr != m_list[m_selectedLine-offset] ) {
// generate event extern :
switch(m_list[m_selectedLine-offset]->getNodeType()) {
case etk::FSN_FILE :
signalFileSelect.emit(m_list[m_selectedLine-offset]->getNameFile());
break;
case etk::FSN_FOLDER :
signalFolderSelect.emit(m_list[m_selectedLine-offset]->getNameFile());
break;
default:
EWOL_ERROR("Can not generate event on an unknow type");
break;
}
}
} else {
if( m_showFolder == true
&& m_selectedLine == 0) {
// "." folder
signalFolderValidate.emit(".");
} else if ( m_showFolder == true
&& m_selectedLine == 1) {
// ".." folder
signalFolderValidate.emit("..");
} else if( m_selectedLine-offset >= 0
&& m_selectedLine-offset < (int32_t)m_list.size()
&& nullptr != m_list[m_selectedLine-offset] ) {
switch(m_list[m_selectedLine-offset]->getNodeType()) {
case etk::FSN_FILE :
signalFileValidate.emit(m_list[m_selectedLine-offset]->getNameFile());
break;
case etk::FSN_FOLDER :
signalFolderValidate.emit(m_list[m_selectedLine-offset]->getNameFile());
break;
default:
EWOL_ERROR("Can not generate event on an unknow type");
break;
}
}
}
// need to regenerate the display of the list :
markToRedraw();
return true;
}
}
return false;
}
void ewol::widget::ButtonColor::periodicCall(const ewol::event::Time& _event) {
if (false == m_shaper.periodicCall(_event) ) {
periodicCallDisable();
}
markToRedraw();
}
void ewol::widget::ButtonColor::onChangePropertyShape() {
m_shaper.setSource(propertyShape.get());
markToRedraw();
}
