//! draws the element and its children
void CGUIImage::draw()
{
if (!IsVisible)
return;
IGUISkin* skin = Environment->getSkin();
IVideoDriver* driver = Environment->getVideoDriver();
if (Texture)
{
if (ScaleImage)
{
const ColourValue Colors[] = { Color, Color, Color, Color };
driver->draw2DImage(Texture, AbsoluteRect,
rect<SINT32>(Position2d(0, 0), dimension2di(Texture->getOriginalSize())),
&AbsoluteClippingRect, Colors, UseAlphaChannel);
}
else
{
driver->draw2DImage(Texture, AbsoluteRect.UpperLeftCorner,
rect<SINT32>(Position2d(0, 0), dimension2di(Texture->getOriginalSize())),
&AbsoluteClippingRect, Color, UseAlphaChannel);
}
}
else
{
skin->draw2DRectangle(this, skin->getColor(EGDC_3D_DARK_SHADOW), AbsoluteRect, &AbsoluteClippingRect);
}
IGUIElement::draw();
}
//! adds an element to the env based on its type id
IGUIElement* CDefaultGUIElementFactory::addGUIElement(EGUI_ELEMENT_TYPE type, IGUIElement* parent)
{
switch (type)
{
case EGUIET_BUTTON:
return Environment->addButton(rect<SINT32>(0, 0, 100, 100), parent);
case EGUIET_CHECK_BOX:
return Environment->addCheckBox(false, rect<SINT32>(0, 0, 100, 100), parent);
case EGUIET_COLOR_SELECT_DIALOG:
return Environment->addColorSelectDialog(0, true, parent);
case EGUIET_COMBO_BOX:
return Environment->addComboBox(rect<SINT32>(0, 0, 100, 100), parent);
case EGUIET_CONTEXT_MENU:
return Environment->addContextMenu(rect<SINT32>(0, 0, 100, 100), parent);
case EGUIET_MENU:
return Environment->addMenu(parent);
case EGUIET_EDIT_BOX:
return Environment->addEditBox(0, rect<SINT32>(0, 0, 100, 100), true, parent);
case EGUIET_FILE_OPEN_DIALOG:
return Environment->addFileOpenDialog(0, true, parent);
case EGUIET_IMAGE:
return Environment->addImage(0, Position2d(0, 0), true, parent);
case EGUIET_IN_OUT_FADER:
return Environment->addInOutFader(0, parent);
case EGUIET_LIST_BOX:
return Environment->addListBox(rect<SINT32>(0, 0, 100, 100), parent);
case EGUIET_MESH_VIEWER:
return Environment->addMeshViewer(rect<SINT32>(0, 0, 100, 100), parent);
case EGUIET_MODAL_SCREEN:
return Environment->addModalScreen(parent);
case EGUIET_MESSAGE_BOX:
return Environment->addMessageBox(0, 0, false, 0, parent);
case EGUIET_SCROLL_BAR:
return Environment->addScrollBar(false, rect<SINT32>(0, 0, 100, 100), parent);
case EGUIET_STATIC_TEXT:
return Environment->addStaticText(0, rect<SINT32>(0, 0, 100, 100), false, true, parent);
case EGUIET_TAB:
return Environment->addTab(rect<SINT32>(0, 0, 100, 100), parent);
case EGUIET_TAB_CONTROL:
return Environment->addTabControl(rect<SINT32>(0, 0, 100, 100), parent);
case EGUIET_TABLE:
return Environment->addTable(rect<SINT32>(0, 0, 100, 100), parent);
case EGUIET_TOOL_BAR:
return Environment->addToolBar(parent);
case EGUIET_WINDOW:
return Environment->addWindow(rect<SINT32>(0, 0, 100, 100), false, 0, parent);
case EGUIET_SPIN_BOX:
return Environment->addSpinBox(L"0.0", rect<SINT32>(0, 0, 100, 100), true, parent);
case EGUIET_TREE_VIEW:
return Environment->addTreeView(rect<SINT32>(0, 0, 100, 100), parent);
default:
return 0;
}
}
//! Sets an image which should be displayed on the button when it is in pressed state.
void CGUIButton::setPressedImage(ITexture* image)
{
if (image)
image->grab();
if (PressedImage)
PressedImage->drop();
PressedImage = image;
if (image)
PressedImageRect = rect<SINT32>(Position2d(0, 0), image->getOriginalSize());
}
//! called if an event happened.
bool CGUIToolBar::OnEvent(const SEvent& event)
{
if (isEnabled())
{
if (event.EventType == EET_MOUSE_INPUT_EVENT &&
event.MouseInput.Event == EMIE_LMOUSE_PRESSED_DOWN)
{
if (AbsoluteClippingRect.isPointInside(Position2d(event.MouseInput.X, event.MouseInput.Y)))
return true;
}
}
return IGUIElement::OnEvent(event);
}
//! called if an event happened.
bool CGUIButton::OnEvent(const SEvent& event)
{
if (!isEnabled())
return IGUIElement::OnEvent(event);
switch (event.EventType)
{
case EET_KEY_INPUT_EVENT:
if (event.KeyInput.PressedDown &&
(event.KeyInput.Key == KEY_RETURN || event.KeyInput.Key == KEY_SPACE))
{
if (!IsPushButton)
setPressed(true);
else
setPressed(!Pressed);
return true;
}
if (Pressed && !IsPushButton && event.KeyInput.PressedDown && event.KeyInput.Key == KEY_ESCAPE)
{
setPressed(false);
return true;
}
else
if (!event.KeyInput.PressedDown && Pressed &&
(event.KeyInput.Key == KEY_RETURN || event.KeyInput.Key == KEY_SPACE))
{
if (!IsPushButton)
setPressed(false);
if (Parent)
{
SEvent newEvent;
newEvent.EventType = EET_GUI_EVENT;
newEvent.GUIEvent.Caller = this;
newEvent.GUIEvent.Element = 0;
newEvent.GUIEvent.EventType = EGET_BUTTON_CLICKED;
Parent->OnEvent(newEvent);
}
return true;
}
break;
case EET_GUI_EVENT:
if (event.GUIEvent.Caller == this)
{
if (event.GUIEvent.EventType == EGET_ELEMENT_FOCUS_LOST)
{
if (!IsPushButton)
setPressed(false);
FocusTime = Timer::getTime();
}
else if (event.GUIEvent.EventType == EGET_ELEMENT_FOCUSED)
{
FocusTime = Timer::getTime();
}
else if (event.GUIEvent.EventType == EGET_ELEMENT_HOVERED || event.GUIEvent.EventType == EGET_ELEMENT_LEFT)
{
HoverTime = Timer::getTime();
}
}
break;
case EET_MOUSE_INPUT_EVENT:
if (event.MouseInput.Event == EMIE_LMOUSE_PRESSED_DOWN)
{
if (Environment->hasFocus(this) &&
!AbsoluteClippingRect.isPointInside(Position2d(event.MouseInput.X, event.MouseInput.Y)))
{
Environment->removeFocus(this);
return false;
}
if (!IsPushButton)
setPressed(true);
Environment->setFocus(this);
return true;
}
else
if (event.MouseInput.Event == EMIE_LMOUSE_LEFT_UP)
{
bool wasPressed = Pressed;
if (!AbsoluteClippingRect.isPointInside(Position2d(event.MouseInput.X, event.MouseInput.Y)))
{
if (!IsPushButton)
setPressed(false);
return true;
}
if (!IsPushButton)
setPressed(false);
else
{
setPressed(!Pressed);
}
if ((!IsPushButton && wasPressed && Parent) ||
(IsPushButton && wasPressed != Pressed))
{
SEvent newEvent;
newEvent.EventType = EET_GUI_EVENT;
newEvent.GUIEvent.Caller = this;
newEvent.GUIEvent.Element = 0;
newEvent.GUIEvent.EventType = EGET_BUTTON_CLICKED;
Parent->OnEvent(newEvent);
}
return true;
}
break;
default:
break;
}
return Parent ? Parent->OnEvent(event) : false;
}
//! called if an event happened.
bool CGUIMenu::OnEvent(const SEvent& event)
{
if (isEnabled())
{
switch (event.EventType)
{
case EET_GUI_EVENT:
switch (event.GUIEvent.EventType)
{
case EGET_ELEMENT_FOCUS_LOST:
if (event.GUIEvent.Caller == this && !isMyChild(event.GUIEvent.Element))
{
closeAllSubMenus();
HighLighted = -1;
}
break;
case EGET_ELEMENT_FOCUSED:
if (event.GUIEvent.Caller == this && Parent)
{
Parent->bringToFront(this);
}
break;
default:
break;
}
break;
case EET_MOUSE_INPUT_EVENT:
switch (event.MouseInput.Event)
{
case EMIE_LMOUSE_PRESSED_DOWN:
{
if (!Environment->hasFocus(this))
{
Environment->setFocus(this);
}
if (Parent)
Parent->bringToFront(this);
Position2d p(event.MouseInput.X, event.MouseInput.Y);
bool shouldCloseSubMenu = hasOpenSubMenu();
if (!AbsoluteClippingRect.isPointInside(p))
{
shouldCloseSubMenu = false;
}
highlight(Position2d(event.MouseInput.X, event.MouseInput.Y), true);
if (shouldCloseSubMenu)
{
Environment->removeFocus(this);
}
return true;
}
case EMIE_LMOUSE_LEFT_UP:
{
Position2d p(event.MouseInput.X, event.MouseInput.Y);
if (!AbsoluteClippingRect.isPointInside(p))
{
SINT32 t = sendClick(p);
if ((t == 0 || t == 1) && Environment->hasFocus(this))
Environment->removeFocus(this);
}
return true;
}
case EMIE_MOUSE_MOVED:
if (Environment->hasFocus(this) && HighLighted >= 0)
{
SINT32 oldHighLighted = HighLighted;
highlight(Position2d(event.MouseInput.X, event.MouseInput.Y), true);
if (HighLighted < 0)
HighLighted = oldHighLighted; // keep last hightlight active when moving outside the area
}
return true;
default:
break;
}
break;
default:
break;
}
}
return IGUIElement::OnEvent(event);
}
//! runs the device. Returns false if device wants to be deleted
bool CSapphirDeviceConsole::run()
{
// increment timer
Timer::tick();
// process Windows console input
#ifdef _SAPPHIRE_WINDOWS_NT_CONSOLE_
INPUT_RECORD in;
DWORD oldMode;
DWORD count, waste;
// get old input mode
GetConsoleMode(WindowsSTDIn, &oldMode);
SetConsoleMode(WindowsSTDIn, ENABLE_WINDOW_INPUT | ENABLE_MOUSE_INPUT);
GetNumberOfConsoleInputEvents(WindowsSTDIn, &count);
// read keyboard and mouse input
while (count)
{
ReadConsoleInput(WindowsSTDIn, &in, 1, &waste);
switch (in.EventType)
{
case KEY_EVENT:
{
SEvent e;
e.EventType = EET_KEY_INPUT_EVENT;
e.KeyInput.PressedDown = (in.Event.KeyEvent.bKeyDown == TRUE);
e.KeyInput.Control = (in.Event.KeyEvent.dwControlKeyState & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED)) != 0;
e.KeyInput.Shift = (in.Event.KeyEvent.dwControlKeyState & SHIFT_PRESSED) != 0;
e.KeyInput.Key = EKEY_CODE(in.Event.KeyEvent.wVirtualKeyCode);
e.KeyInput.Char = in.Event.KeyEvent.uChar.UnicodeChar;
postEventFromUser(e);
break;
}
case MOUSE_EVENT:
{
SEvent e;
e.EventType = EET_MOUSE_INPUT_EVENT;
e.MouseInput.X = in.Event.MouseEvent.dwMousePosition.X;
e.MouseInput.Y = in.Event.MouseEvent.dwMousePosition.Y;
e.MouseInput.Wheel = 0.f;
e.MouseInput.ButtonStates =
((in.Event.MouseEvent.dwButtonState & FROM_LEFT_1ST_BUTTON_PRESSED) ? EMBSM_LEFT : 0) |
((in.Event.MouseEvent.dwButtonState & RIGHTMOST_BUTTON_PRESSED) ? EMBSM_RIGHT : 0) |
((in.Event.MouseEvent.dwButtonState & FROM_LEFT_2ND_BUTTON_PRESSED) ? EMBSM_MIDDLE : 0) |
((in.Event.MouseEvent.dwButtonState & FROM_LEFT_3RD_BUTTON_PRESSED) ? EMBSM_EXTRA1 : 0) |
((in.Event.MouseEvent.dwButtonState & FROM_LEFT_4TH_BUTTON_PRESSED) ? EMBSM_EXTRA2 : 0);
if (in.Event.MouseEvent.dwEventFlags & MOUSE_MOVED)
{
CursorControl->setPosition(Position2d(e.MouseInput.X, e.MouseInput.Y));
// create mouse moved event
e.MouseInput.Event = EMIE_MOUSE_MOVED;
postEventFromUser(e);
}
if (in.Event.MouseEvent.dwEventFlags & MOUSE_WHEELED)
{
e.MouseInput.Event = EMIE_MOUSE_WHEEL;
e.MouseInput.Wheel = (in.Event.MouseEvent.dwButtonState & 0xFF000000) ? -1.0f : 1.0f;
postEventFromUser(e);
}
if ((MouseButtonStates & EMBSM_LEFT) != (e.MouseInput.ButtonStates & EMBSM_LEFT))
{
e.MouseInput.Event = (e.MouseInput.ButtonStates & EMBSM_LEFT) ? EMIE_LMOUSE_PRESSED_DOWN : EMIE_LMOUSE_LEFT_UP;
postEventFromUser(e);
}
if ((MouseButtonStates & EMBSM_RIGHT) != (e.MouseInput.ButtonStates & EMBSM_RIGHT))
{
e.MouseInput.Event = (e.MouseInput.ButtonStates & EMBSM_RIGHT) ? EMIE_RMOUSE_PRESSED_DOWN : EMIE_RMOUSE_LEFT_UP;
postEventFromUser(e);
}
if ((MouseButtonStates & EMBSM_MIDDLE) != (e.MouseInput.ButtonStates & EMBSM_MIDDLE))
{
e.MouseInput.Event = (e.MouseInput.ButtonStates & EMBSM_MIDDLE) ? EMIE_MMOUSE_PRESSED_DOWN : EMIE_MMOUSE_LEFT_UP;
postEventFromUser(e);
}
// save current button states
MouseButtonStates = e.MouseInput.ButtonStates;
break;
}
case WINDOW_BUFFER_SIZE_EVENT:
VideoDriver->OnResize(
dimension2d<UINT32>(in.Event.WindowBufferSizeEvent.dwSize.X,
in.Event.WindowBufferSizeEvent.dwSize.Y));
break;
case FOCUS_EVENT:
IsWindowFocused = (in.Event.FocusEvent.bSetFocus == TRUE);
break;
default:
break;
}
GetNumberOfConsoleInputEvents(WindowsSTDIn, &count);
}
// set input mode
SetConsoleMode(WindowsSTDIn, oldMode);
#else
// todo: keyboard input from terminal in raw mode
#endif
return !Close;
}
//! called if an event happened.
bool CGUIWindow::OnEvent(const SEvent& event)
{
if (isEnabled())
{
switch (event.EventType)
{
case EET_GUI_EVENT:
if (event.GUIEvent.EventType == EGET_ELEMENT_FOCUS_LOST)
{
Dragging = false;
IsActive = false;
}
else
if (event.GUIEvent.EventType == EGET_ELEMENT_FOCUSED)
{
if (Parent && ((event.GUIEvent.Caller == this) || isMyChild(event.GUIEvent.Caller)))
{
Parent->bringToFront(this);
IsActive = true;
}
else
{
IsActive = false;
}
}
else
if (event.GUIEvent.EventType == EGET_BUTTON_CLICKED)
{
if (event.GUIEvent.Caller == CloseButton)
{
if (Parent)
{
// send close event to parent
SEvent e;
e.EventType = EET_GUI_EVENT;
e.GUIEvent.Caller = this;
e.GUIEvent.Element = 0;
e.GUIEvent.EventType = EGET_ELEMENT_CLOSED;
// if the event was not absorbed
if (!Parent->OnEvent(e))
remove();
return true;
}
else
{
remove();
return true;
}
}
}
break;
case EET_MOUSE_INPUT_EVENT:
switch (event.MouseInput.Event)
{
case EMIE_LMOUSE_PRESSED_DOWN:
DragStart.x = event.MouseInput.X;
DragStart.y = event.MouseInput.Y;
Dragging = IsDraggable;
if (Parent)
Parent->bringToFront(this);
return true;
case EMIE_LMOUSE_LEFT_UP:
Dragging = false;
return true;
case EMIE_MOUSE_MOVED:
if (!event.MouseInput.isLeftPressed())
Dragging = false;
if (Dragging)
{
// gui window should not be dragged outside its parent
if (Parent &&
(event.MouseInput.X < Parent->getAbsolutePosition().UpperLeftCorner.x + 1 ||
event.MouseInput.Y < Parent->getAbsolutePosition().UpperLeftCorner.y + 1 ||
event.MouseInput.X > Parent->getAbsolutePosition().LowerRightCorner.x - 1 ||
event.MouseInput.Y > Parent->getAbsolutePosition().LowerRightCorner.y - 1))
return true;
move(Position2d(event.MouseInput.X - DragStart.x, event.MouseInput.Y - DragStart.y));
DragStart.x = event.MouseInput.X;
DragStart.y = event.MouseInput.Y;
return true;
}
break;
default:
break;
}
default:
break;
}
}
return IGUIElement::OnEvent(event);
}
bool RoadPatch::fillData(XMLElement* titleElement)
{
m_number_of_diversions = 0;
// create strip collection and end pose collection of this roadPatch instance
m_strip_collection = std::make_shared<TrajectoryConstContainer>(); //< all strips
m_diversion_collection = std::make_shared<DiversionConstContainer>(); //< driving strips by diversion
m_endpose_collection = std::make_shared<PoseContainer>();
// check titleElement
int tmp = titleElement->IntAttribute(XML_TITLE_ID_);
if (tmp >= (int)PatchType::PATCH_COUNT) //< Error non valid ID
return false;
m_patch_type = (PatchType)tmp;
//****** ITERATE OVER DIVERSIONS *******/
u_int8_t current_diversion_id = 0;
XMLElement* diversion = titleElement->FirstChildElement(XML_DIVERSION_ELEMENT);
while( diversion != nullptr )
{
// read current diversion id
int32_t diversion_id = diversion->IntAttribute(XML_DIVERSION_ID);
if (diversion_id < 0 || diversion_id > 255)
return false; //< error invalid diversion ID
// read tags in correct order, skip wrong ids first
if ((u_int8_t)diversion_id != current_diversion_id)
{
diversion = diversion->NextSiblingElement(XML_DIVERSION_ELEMENT);
continue;
}
// Read diversion direction attribute
int32_t reverse_tag;
bool forward = true;
if (diversion->QueryIntAttribute(XML_DIVERSION_DIRECTION_ATTRIB, &reverse_tag) == tinyxml2::XML_SUCCESS)
{
if (reverse_tag == 1)
forward = false;
}
TrajectoryConstContainer current_diversion;
//****** ITERATE OVER STRIPS ***********/
u_int8_t current_strip_id = 0;
XMLElement* strip = diversion->FirstChildElement(XML_STRIP_ELEMENT);
while ( strip != nullptr )
{
// read current strip id
int32_t strip_id = strip->IntAttribute(XML_STRIP_ID);
if (strip_id < 0 || strip_id > 255)
return false; //< error invalid strip ID
// read tags in correct order, skip wrong ids first
if ((u_int8_t)strip_id != current_strip_id)
{
strip = strip->NextSiblingElement(XML_STRIP_ELEMENT);
continue;
}
//************ READ STRIP *************/
TrajectoryPtr driving_strip = std::make_shared<Trajectory2d>();
driving_strip->isForwardTrajectory() = forward;
// iterate over points of strip
for (XMLElement* p_child = strip->FirstChildElement(XML_POINT_ELEMENT); p_child != nullptr; p_child = p_child->NextSiblingElement(XML_POINT_ELEMENT))
{
ExtendedPose2d p;
PoseTraits<Pose2d>::fromPositionAndOrientationRPY(p.pose(),
p_child->DoubleAttribute(XML_POINT_X),
p_child->DoubleAttribute(XML_POINT_Y),
p_child->DoubleAttribute(XML_POINT_YAW));
driving_strip->push_back(p);
}
if (driving_strip->empty()) //< this is an error (empty file?)
return false;
// save strip as strip of current diversion
current_diversion.push_back(driving_strip);
// save strip in complete strip container
m_strip_collection->push_back(driving_strip);
// prepare search for next strip_id -> begin searching again at first strip
current_strip_id++;
strip = diversion->FirstChildElement(XML_STRIP_ELEMENT);
}
if (current_diversion.empty())
return false;
// Save strips of this diversion
m_diversion_collection->push_back(current_diversion);
//*********** READ ENDPOSE *************/
XMLElement* p_endpose = diversion->FirstChildElement(XML_ENDPOSE_ELEMENT);
if (p_endpose == nullptr)
return false;
Pose2d endpose;
PoseTraits<Pose2d>::fromPositionAndOrientationRPY(endpose,
p_endpose->DoubleAttribute(XML_ENDPOSE_X),
p_endpose->DoubleAttribute(XML_ENDPOSE_Y),
p_endpose->DoubleAttribute(XML_ENDPOSE_THETA));
m_endpose_collection->push_back(endpose);
// prepare search for next diversion id
current_diversion_id++;
diversion = titleElement->FirstChildElement(XML_DIVERSION_ELEMENT);
}
if (current_diversion_id == 0)
return false;
m_number_of_diversions = current_diversion_id;
// check for correct number of diversions
assert(m_number_of_diversions == m_endpose_collection->size());
//************ READ PATCH CORNERS *********/
// create corner array
m_patch_boundary = std::make_shared<PatchBoundary>();
for (XMLElement* corner = titleElement->FirstChildElement(XML_CORNER_ELEMENT); corner != nullptr; corner = corner->NextSiblingElement(XML_CORNER_ELEMENT))
{
std::string current_corner_id = corner->Attribute(XML_CORNER_ID);
u_int8_t i;
for (i = 0; i < (u_int8_t)CORNER_POINT::CORNER_POINT_COUNT; i++)
{
if (current_corner_id == XML_CORNER_IDS[i])
break;
}
if (i == (u_int8_t)CORNER_POINT::CORNER_POINT_COUNT) //< error wrong corner id
return false;
(*m_patch_boundary)[i] = Position2d(corner->DoubleAttribute(XML_CORNER_XVALUE), corner->DoubleAttribute(XML_CORNER_YVALUE));
}
return true;
}
