bool ewol::widget::Slider::onEventInput(const ewol::event::Input& _event) {
vec2 relativePos = relativePosition(_event.getPos());
//EWOL_DEBUG("Event on Slider ..." << _event);
if (1 == _event.getId()) {
if( gale::key::status_single == _event.getStatus()
|| gale::key::status_move == _event.getStatus()) {
// get the new position :
EWOL_VERBOSE("Event on Slider (" << relativePos.x() << "," << relativePos.y() << ")");
float oldValue = m_value.get();
updateValue(m_min + (float)(relativePos.x() - dotRadius) / (m_size.x()-2*dotRadius) * (m_max-m_min));
if (oldValue != m_value) {
EWOL_VERBOSE(" new value : " << m_value << " in [" << m_min << ".." << m_max << "]");
signalChange.emit(m_value);
}
return true;
}
}
return false;
}
double Line::getDistanceTo(const Line& other) const
{
if (relativePosition(other) != 0) // distance between non-parallel lines
{
Vector cross = vector->crossProduct(*(other.getVector()));
//norm the vector
cross = cross*(1 / cross.getLength());
double distance = cross.dotProduct(Vector(*point, *other.point));
return distance;
}
else // distance between parallel lines
{
Point P1 = *point;
Point P2 = *other.point;
Vector differenceVector = Vector(P1, P2);
Vector projectionVector = ((vector->dotProduct(differenceVector)) / (pow(vector->getLength(), 2))) * (*vector);
Vector distanceVector = differenceVector + (-1)*projectionVector;
return distanceVector.getLength();
}
}
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::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;
}
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;
}
int main(int argc, char *argv[])
{
int i, N=2500;
const float L=1,W=1,dt=1e-6;
G=2.0/N;
double *x,*y,*mass,*forceX,*forceY,*u,*v,ax,ay;
const int frameskip=100;
int frame=frameskip-1;
const double initSpeedLimit=0.001;
const float theta = 0.8;
x = (double *)malloc(N*sizeof(double));
y = (double *)malloc(N*sizeof(double));
u = (double *)malloc(N*sizeof(double));
v = (double *)malloc(N*sizeof(double));
mass = (double *)malloc(N*sizeof(double));
forceX = (double *)malloc(N*sizeof(double));
forceY = (double *)malloc(N*sizeof(double));
#ifndef DISTRIBUTION_AS_IN_ASSIGNMENT
for(i=0;i<N;i++)
{
x[i]=frand(0,1);
y[i]=frand(.25,.75);
relativePosition(&u[i], &v[i], 0, 0, x[i], y[i]);
u[i]*=frand(-initSpeedLimit,initSpeedLimit);
v[i]*=frand(-initSpeedLimit,initSpeedLimit);
mass[i]=frand(1, 100);
forceX[i]=0;
forceY[i]=0;
}
x[0]=x[1]=0.5;
y[0]=0.45; y[1]=0.55;
v[0]=v[1]=0;
u[0]=-0.007;
u[1]=0.007;
mass[0]=mass[1]=1000;
#endif
#ifdef DISTRIBUTION_AS_IN_ASSIGNMENT
const double alpha=0.25;
const double V=20.0;
for(i = 0; i<N; i++)
{
mass[i]=1;
double R=frand(0, L/4.0);
double fi=frand(0, 2*3.1415);
x[i]=L/2.0+R*cos(fi);
y[i]=W/2.0+alpha*R*sin(fi);
double Rprim = sqrt((x[i]-L/2.0)*(x[i]-L/2.0) + (y[i]-W/2.0)*(y[i]-W/2.0));
u[i] = -V*Rprim*sin(fi);
v[i] = V*Rprim*cos(fi);
forceX[i]=0;
forceY[i]=0;
}
#endif
InitializeGraphics(argv[0],windowWidth,windowWidth);
SetCAxes(0,1);
Node *root;
printf("Hit q to quit.\n");
int iterations=0;
while(!CheckForQuit())
{
iterations++;
#ifndef BARNESHUT
for(i=0;i<N;i++) {
#endif
#ifdef BARNESHUT
// Bounce(&x[0],&y[0],&u[0],&v[0],L,W);
root = createNode(0,x,y,mass);
for(i=1;i<N;i++) {
#endif
if (x[i] > 2*L || x[i]< -1 || y[i] > 2*W || y[i] < -1)
{
printf("Things are going out of bounds");
exit(-1);
}
// Bounce(&x[i],&y[i],&u[i],&v[i],L,W);
#ifndef BARNESHUT
calculateForce(&forceX[i], &forceY[i], i, x, y, mass, N);
#endif
#ifdef BARNESHUT
insertParticle(root, x, y, mass, i);
#endif
}
#ifdef BARNESHUT
for(i=0; i<N; i++)
BarnesHut(root, x, y, mass, theta, i, &forceX[i], &forceY[i]);
#endif
update(x,y,u,v,mass,forceX, forceY,dt, N);
frame++;
frame=frame%frameskip;
if(frame==0) {
ClearScreen();
for(i=0;i<N;i++)
DrawCircle(x[i],y[i],L,W,(1+log10(mass[i]))*circleRadius,circleColor);
Refresh();
}
freeNodes(root);
}
XFlush(display);
XCloseDisplay(display);
printf("Iterations: %d\n", iterations);
return 0;
}
/*
* Function: Bounce
* Usage: Bounce(&x[i],&y[i],&u[i],&v[i],L,W);
* -------------------------------------------
* If a particle moves beyond any of the boundaries then set
* it on the other side of the boundary back in the domain and
* reverse the velocities.
*
*/
void Bounce(double *x, double *y, double *u, double *v, double L, double W) {
if(*x>L ) {
*x=2*L-*x;
*u=-*u;
}
if(*x<0 ) {
*x=-*x;
*u=-*u;
}
if(*y>W ) {
*y=2*W-*y;
*v=-*v;
}
if(*y<0 ) {
*y=-*y;
*v=-*v;
}
}
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;
}
int game::next_turn(unsigned int delay = 0){
if(game_complete){
return 0;
}
switch(color){
case 0:
case 1:
case 2:
++color;
break;
case 3:
default:
color = 0;
break;
}
// global_color = color;
rollDice();
relative.dice = getDiceRoll();
relative.pos = relativePosition();
emit set_color(color);
emit set_dice_result(dice_result);
msleep(delay);
switch(color){
case 0:
for(int i = 0 ; i < 4 ; i++){
if(relative.pos[i] == 99){
player1_in_goal[i] = 1;
}
}
emit player1_start(relative);
break;
case 1:
for(int i = 0 ; i < 4 ; i++){
if(relative.pos[i] == 99){
player2_in_goal[i] = 1;
}
}
emit player2_start(relative);
break;
case 2:
for(int i = 0 ; i < 4 ; i++){
if(relative.pos[i] == 99){
player3_in_goal[i] = 1;
}
}
emit player3_start(relative);
break;
case 3:
for(int i = 0 ; i < 4 ; i++){
if(relative.pos[i] == 99){
player4_in_goal[i] = 1;
}
}
emit player4_start(relative);
default:
break;
}
return 0;
}
void game::movePiece(int relative_piece){
int fixed_piece = rel_to_fixed(relative_piece); //index of the piece in player_positions
int modifier = color * 13;
int relative_pos = player_positions[fixed_piece];
int target_pos = 0;
if(player_positions[fixed_piece] == -1){ //if the selected piece is in the safe house, try to move it to start
move_start(fixed_piece);
} else {
//convert to relative position
if(relative_pos == 99){
std::cout << "I tought this would be it ";
}else if(relative_pos == 51 && color != 0){
int tmp_abs = relative_pos - 52;
relative_pos = (tmp_abs - modifier); //Alien attack prevention
}else if(relative_pos < modifier) {
relative_pos = relative_pos + 52 - modifier;
} else if( relative_pos > 50) {
relative_pos = relative_pos - color * 5 - 1;
} else {//if(relative >= modifier)
relative_pos = relative_pos - modifier;
}
if(DEBUG) std::cout << "color: " << color << " pos: " << relative_pos << " + " << dice_result << " = " << relative_pos + dice_result;
//add dice roll
relative_pos += dice_result; //this is relative position of the selected token + the dice number
int jump = isStar(relative_pos); //return 0 | 6 | 7
if(jump){
if(jump + relative_pos == 57){
relative_pos = 56;
} else {
relative_pos += jump;
}
}
//special case checks
if(relative_pos > 56 && relative_pos < 72){ // go back
target_pos = 56-(relative_pos-56) + color * 5 + 1; //If the player moves over the goal, it should move backwards
}else if(relative_pos == 56 || relative_pos >= 99){
target_pos = 99;
}else if(relative_pos > 50){ // goal stretch
target_pos = relative_pos + color * 5 + 1;
} else {
int new_pos = relative_pos + color * 13;
if(new_pos < 52){
target_pos = new_pos;
} else { //wrap around
target_pos = new_pos - 52; //this is the global position wrap around at the green entry point
}
}
//check for game stuff
if(isOccupied(target_pos)){
if(isGlobe(target_pos)){
target_pos = -1; //send me home
} else {
send_them_home(target_pos);
}
}
if(DEBUG) std::cout << " => " << target_pos << std::endl;
player_positions[fixed_piece] = target_pos;
}
std::vector<int> new_relative = relativePosition();
switch(color){
case 0:
emit player1_end(new_relative);
break;
case 1:
emit player2_end(new_relative);
break;
case 2:
emit player3_end(new_relative);
break;
case 3:
emit player4_end(new_relative);
default:
break;
}
emit update_graphics(player_positions);
}
