mirror of
https://github.com/bearstonem/openmohaa-vr.git
synced 2026-10-28 06:00:26 +01:00
362 lines
9.7 KiB
C++
362 lines
9.7 KiB
C++
/*
|
|
===========================================================================
|
|
Copyright (C) 2023 the OpenMoHAA team
|
|
|
|
This file is part of OpenMoHAA source code.
|
|
|
|
OpenMoHAA source code is free software; you can redistribute it
|
|
and/or modify it under the terms of the GNU General Public License as
|
|
published by the Free Software Foundation; either version 2 of the License,
|
|
or (at your option) any later version.
|
|
|
|
OpenMoHAA source code is distributed in the hope that it will be
|
|
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with OpenMoHAA source code; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
===========================================================================
|
|
*/
|
|
|
|
#include "ui_local.h"
|
|
|
|
CLASS_DECLARATION(UIWidget, UIChildSpaceWidget, NULL) {
|
|
{NULL, NULL}
|
|
};
|
|
|
|
UIChildSpaceWidget::UIChildSpaceWidget() {}
|
|
|
|
qboolean UIChildSpaceWidget::KeyEvent(int key, unsigned int time)
|
|
{
|
|
if (m_parent) {
|
|
//
|
|
// Transmit the key event to the parent
|
|
//
|
|
return m_parent->KeyEvent(key, 0);
|
|
}
|
|
|
|
return qfalse;
|
|
}
|
|
|
|
CLASS_DECLARATION(UIWidget, UIFloatingWindow, NULL) {
|
|
{&W_LeftMouseDown, &UIFloatingWindow::Pressed },
|
|
{&W_LeftMouseDragged, &UIFloatingWindow::Dragged },
|
|
{&W_LeftMouseUp, &UIFloatingWindow::Released },
|
|
{&UIFloatingWindow::W_ClosePressed, &UIFloatingWindow::ClosePressed },
|
|
{&UIFloatingWindow::W_MinimizePressed, &UIFloatingWindow::MinimizePressed},
|
|
{&W_SizeChanged, &UIFloatingWindow::SizeChanged },
|
|
{&W_Activated, &UIFloatingWindow::OnActivated },
|
|
{NULL, NULL }
|
|
};
|
|
|
|
Event UIFloatingWindow::W_ClosePressed(
|
|
"floatingwindow_close_pressed", EV_DEFAULT, NULL, NULL, "Signal that the window was closed"
|
|
);
|
|
Event UIFloatingWindow::W_MinimizePressed(
|
|
"floatingwindow_minimize_pressed", EV_DEFAULT, NULL, NULL, "Signal that the window was minimized"
|
|
);
|
|
|
|
UIFloatingWindow::UIFloatingWindow()
|
|
{
|
|
m_clickpoint = UIPoint2D(-20.0, -20.0);
|
|
m_isPressed = false;
|
|
m_minimized = false;
|
|
m_canactivate = true;
|
|
m_clicktime = -20000;
|
|
// create buttons that compose a window
|
|
m_closeButton = new UIButton();
|
|
m_minimizeButton = new UIButton();
|
|
m_childspace = new UIChildSpaceWidget();
|
|
}
|
|
|
|
UIFloatingWindow::~UIFloatingWindow() {}
|
|
|
|
void UIFloatingWindow::FrameInitialized(void)
|
|
{
|
|
FrameInitialized(true);
|
|
}
|
|
|
|
void UIFloatingWindow::FrameInitialized(bool bHasDragBar)
|
|
{
|
|
//
|
|
// Initialize the close button
|
|
//
|
|
m_closeButton->InitFrame(
|
|
this,
|
|
m_frame.size.width - 18.0 * getHighResScale()[0],
|
|
2.0,
|
|
16.0 * getHighResScale()[0],
|
|
16.0 * getHighResScale()[1],
|
|
-1,
|
|
"marlett"
|
|
);
|
|
|
|
m_closeButton->setTitle("r");
|
|
m_closeButton->setName("closebutton");
|
|
|
|
//
|
|
// Initialize the minimize button
|
|
//
|
|
m_minimizeButton->InitFrame(
|
|
this,
|
|
m_frame.size.width - 36.0 * getHighResScale()[0],
|
|
2.0,
|
|
16.0 * getHighResScale()[0],
|
|
16.0 * getHighResScale()[1],
|
|
-1,
|
|
"marlett"
|
|
);
|
|
m_minimizeButton->setTitle("0");
|
|
m_minimizeButton->setName("minimizebutton");
|
|
|
|
m_closeButton->Connect(this, W_Button_Pressed, UIFloatingWindow::W_ClosePressed);
|
|
m_minimizeButton->Connect(this, W_Button_Pressed, UIFloatingWindow::W_MinimizePressed);
|
|
//
|
|
// Size event
|
|
//
|
|
Connect(this, W_SizeChanged, W_SizeChanged);
|
|
Connect(this, W_Activated, W_Activated);
|
|
|
|
//
|
|
// Child space
|
|
//
|
|
if (bHasDragBar) {
|
|
m_childspace->InitFrame(
|
|
this,
|
|
UIRect2D(
|
|
2.0,
|
|
20.0 * getHighResScale()[1],
|
|
m_frame.size.width - 4.0,
|
|
m_frame.size.height - 22.0 * getHighResScale()[1]
|
|
),
|
|
0,
|
|
"verdana-12"
|
|
);
|
|
} else {
|
|
m_childspace->InitFrame(this, UIRect2D(UIPoint2D(0, 0), m_frame.size), 0, "verdana-12");
|
|
}
|
|
|
|
m_childspace->setTitle("Child space");
|
|
m_childspace->AllowActivate(true);
|
|
}
|
|
|
|
void UIFloatingWindow::ClosePressed(Event *ev)
|
|
{
|
|
PostEvent(EV_Remove, 0.0);
|
|
}
|
|
|
|
void UIFloatingWindow::MinimizePressed(Event *ev)
|
|
{
|
|
UISize2D size = getSize();
|
|
|
|
if (!m_minimized) {
|
|
m_minimized = true;
|
|
// save the hold height
|
|
// so the window can be restored later
|
|
m_restoredHeight = size.height;
|
|
size.height = 20.0 * getHighResScale()[1];
|
|
m_minimizeButton->setTitle("1");
|
|
} else {
|
|
m_minimized = false;
|
|
size.height = m_restoredHeight;
|
|
m_minimizeButton->setTitle("0");
|
|
}
|
|
|
|
setSize(size);
|
|
uWinMan.ActivateControl(this);
|
|
}
|
|
|
|
void UIFloatingWindow::Pressed(Event *ev)
|
|
{
|
|
UIPoint2D p = MouseEventToClientPoint(ev);
|
|
|
|
m_clickOffset.x = p.x;
|
|
m_clickOffset.y = p.y;
|
|
|
|
if (uid.time - 500 >= m_clicktime) {
|
|
m_clicktime = uid.time;
|
|
} else {
|
|
if (fabs(m_clickpoint.x - m_clickOffset.x) > 2.0 || fabs(m_clickpoint.y - m_clickOffset.y) > 2.0) {
|
|
m_clicktime = uid.time;
|
|
} else {
|
|
ProcessEvent(W_MinimizePressed);
|
|
m_clicktime = -20000;
|
|
}
|
|
}
|
|
|
|
m_clickpoint = m_clickOffset;
|
|
if (m_clickOffset.y < 18.0) {
|
|
uWinMan.setFirstResponder(this);
|
|
m_isPressed = true;
|
|
}
|
|
}
|
|
|
|
void UIFloatingWindow::Released(Event *ev)
|
|
{
|
|
if (!m_isPressed) {
|
|
return;
|
|
}
|
|
|
|
uWinMan.setFirstResponder(NULL);
|
|
m_isPressed = false;
|
|
OnActivated(NULL);
|
|
}
|
|
|
|
void UIFloatingWindow::Dragged(Event *ev)
|
|
{
|
|
if (!m_isPressed) {
|
|
return;
|
|
}
|
|
|
|
UIPoint2D point = MouseEventToClientPoint(ev);
|
|
UIPoint2D newpos;
|
|
|
|
newpos.x = point.x - m_clickOffset.x;
|
|
newpos.y = point.y - m_clickOffset.y;
|
|
newpos.x += m_frame.pos.x;
|
|
newpos.y += m_frame.pos.y;
|
|
|
|
setFrame(UIRect2D(newpos, getSize()));
|
|
}
|
|
|
|
void UIFloatingWindow::SizeChanged(Event *ev)
|
|
{
|
|
UIRect2D childRect;
|
|
childRect.pos.x = 2.0;
|
|
childRect.pos.y = 20.0 * getHighResScale()[1];
|
|
childRect.size.width = m_frame.size.width - 4.0 * getHighResScale()[0];
|
|
childRect.size.height = m_frame.size.height - 22.0 * getHighResScale()[1];
|
|
|
|
if (childRect.size.width <= 0.0 || childRect.size.height <= 0.0) {
|
|
return;
|
|
}
|
|
|
|
m_childspace->setFrame(childRect);
|
|
m_closeButton->setFrame(UIRect2D(
|
|
m_frame.size.width - 18.0 * getHighResScale()[0], 2.0, 16.0 * getHighResScale()[0], 16.0 * getHighResScale()[1]
|
|
));
|
|
m_minimizeButton->setFrame(UIRect2D(
|
|
m_frame.size.width - 36.0 * getHighResScale()[0], 2.0, 16.0 * getHighResScale()[0], 16.0 * getHighResScale()[1]
|
|
));
|
|
}
|
|
|
|
void UIFloatingWindow::OnActivated(Event *ev)
|
|
{
|
|
UIWidget *next;
|
|
|
|
if (!IsActive()) {
|
|
return;
|
|
}
|
|
|
|
for (next = m_childspace->getFirstChild(); next; next = m_childspace->getNextChild(next)) {
|
|
if (next->CanActivate()) {
|
|
uWinMan.ActivateControl(next);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void UIFloatingWindow::OnDeactivated(Event *ev)
|
|
{
|
|
PostEvent(EV_Remove, 0.0);
|
|
}
|
|
|
|
void UIFloatingWindow::Create(
|
|
UIWidget *parent, const UIRect2D& rect, const char *title, const UColor& bgColor, const UColor& fgColor
|
|
)
|
|
{
|
|
m_titleColor = bgColor;
|
|
m_textColor = fgColor;
|
|
setTitle(title);
|
|
// actually create the window
|
|
InitFrame(parent, rect.pos.x, rect.pos.y, rect.size.width, rect.size.height, 0, "verdana-14");
|
|
}
|
|
|
|
void UIFloatingWindow::Draw(void)
|
|
{
|
|
UColor titleBar;
|
|
UColor textColor;
|
|
UBorderColor titleBorder;
|
|
UBorderColor windowBorder;
|
|
|
|
if (IsThisOrChildActive()) {
|
|
UColor newColor;
|
|
|
|
titleBar = m_titleColor;
|
|
textColor = m_textColor;
|
|
|
|
UColorHSV tmp(titleBar);
|
|
tmp.s *= 0.75;
|
|
tmp.v *= 1.333;
|
|
newColor = tmp;
|
|
|
|
titleBorder.dark = newColor;
|
|
titleBorder.reallydark = newColor;
|
|
titleBorder.light = newColor;
|
|
|
|
} else {
|
|
UColor newColor(0.1125, 0.147, 0.2085, 1.0);
|
|
|
|
titleBar = newColor;
|
|
textColor = UBlack;
|
|
|
|
titleBorder.CreateSolidBorder(newColor, DARK);
|
|
titleBorder.reallydark = newColor;
|
|
titleBorder.light = newColor;
|
|
}
|
|
|
|
UColor newColor(0.15, 0.196, 0.278, 1.0);
|
|
newColor.ScaleColor(0.666f);
|
|
|
|
windowBorder.dark = newColor;
|
|
windowBorder.reallydark = newColor;
|
|
windowBorder.light = newColor;
|
|
|
|
setForegroundColor(textColor);
|
|
m_closeButton->setForegroundColor(textColor);
|
|
m_closeButton->setBackgroundColor(titleBar, true);
|
|
m_minimizeButton->setForegroundColor(textColor);
|
|
m_minimizeButton->setBackgroundColor(titleBar, true);
|
|
|
|
if (!IsMinimized()) {
|
|
DrawBoxWithSolidBorder(
|
|
getClientFrame(), UColor(0.15, 0.195, 0.278, 1.0), UColor(0.075, 0.097, 0.139, 1.0), 2, 2, 1.0
|
|
);
|
|
}
|
|
|
|
const float maxTitleBarHeight = 20 * getHighResScale()[1];
|
|
|
|
DrawBox(
|
|
0.0,
|
|
0.0,
|
|
m_frame.size.width,
|
|
m_frame.size.height > maxTitleBarHeight ? maxTitleBarHeight : m_frame.size.height,
|
|
titleBar,
|
|
1.0
|
|
);
|
|
|
|
Draw3DBox(
|
|
0.0,
|
|
0.0,
|
|
m_frame.size.width,
|
|
m_frame.size.height > maxTitleBarHeight ? maxTitleBarHeight : m_frame.size.height,
|
|
false,
|
|
titleBorder,
|
|
1.0
|
|
);
|
|
|
|
DrawTitle(3.0, 3.0);
|
|
}
|
|
|
|
UIChildSpaceWidget *UIFloatingWindow::getChildSpace(void)
|
|
{
|
|
return m_childspace;
|
|
}
|
|
|
|
bool UIFloatingWindow::IsMinimized(void)
|
|
{
|
|
return m_minimized;
|
|
}
|