mirror of
https://github.com/libretro/scummvm.git
synced 2024-12-14 13:50:13 +00:00
258 lines
6.7 KiB
C++
258 lines
6.7 KiB
C++
/* ScummVM - Graphic Adventure Engine
|
|
*
|
|
* ScummVM is the legal property of its developers, whose names
|
|
* are too numerous to list here. Please refer to the COPYRIGHT
|
|
* file distributed with this source distribution.
|
|
*
|
|
* This program 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 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
|
|
#include "glk/window_pair.h"
|
|
#include "glk/conf.h"
|
|
#include "glk/glk.h"
|
|
#include "glk/screen.h"
|
|
|
|
namespace Glk {
|
|
|
|
PairWindow::PairWindow(Windows *windows, uint method, Window *key, uint size) :
|
|
Window(windows, 0),
|
|
_dir(method & winmethod_DirMask),
|
|
_division(method & winmethod_DivisionMask),
|
|
_wBorder((method & winmethod_BorderMask) == winmethod_Border),
|
|
_vertical(_dir == winmethod_Left || _dir == winmethod_Right),
|
|
_backward(_dir == winmethod_Left || _dir == winmethod_Above),
|
|
_key(key), _size(size), _keyDamage(0) {
|
|
_type = wintype_Pair;
|
|
}
|
|
|
|
PairWindow::~PairWindow() {
|
|
for (uint idx = 0; idx < _children.size(); ++idx) {
|
|
_children[idx]->_parent = nullptr;
|
|
delete _children[idx];
|
|
}
|
|
}
|
|
|
|
void PairWindow::rearrange(const Rect &box) {
|
|
Rect box1, box2;
|
|
int min, diff, split, splitwid, max;
|
|
Window *ch1, *ch2;
|
|
|
|
_bbox = box;
|
|
|
|
if (_dir == winmethod_Arbitrary) {
|
|
// When a pair window is in "arbitrary" mode, each child window has it's own independent positioning,
|
|
// so thre's no need to be readjusting it
|
|
return;
|
|
}
|
|
|
|
if (!_backward) {
|
|
ch1 = _children[0];
|
|
ch2 = _children[1];
|
|
} else {
|
|
ch1 = _children[1];
|
|
ch2 = _children[0];
|
|
}
|
|
|
|
if (_vertical) {
|
|
min = _bbox.left;
|
|
max = _bbox.right;
|
|
} else {
|
|
min = _bbox.top;
|
|
max = _bbox.bottom;
|
|
}
|
|
diff = max - min;
|
|
|
|
// We now figure split.
|
|
if (_vertical)
|
|
splitwid = g_conf->_wPaddingX; // want border?
|
|
else
|
|
splitwid = g_conf->_wPaddingY; // want border?
|
|
|
|
switch (_division) {
|
|
case winmethod_Proportional:
|
|
split = (diff * _size) / 100;
|
|
break;
|
|
|
|
case winmethod_Fixed:
|
|
split = !_key ? 0 : _key->getSplit(_size, _vertical);
|
|
break;
|
|
|
|
default:
|
|
split = diff / 2;
|
|
break;
|
|
}
|
|
|
|
if (!_backward)
|
|
split = max - split - splitwid;
|
|
else
|
|
split = min + split;
|
|
|
|
if (min >= max) {
|
|
split = min;
|
|
} else {
|
|
if (split < min)
|
|
split = min;
|
|
else if (split > max - splitwid)
|
|
split = max - splitwid;
|
|
}
|
|
|
|
if (_vertical) {
|
|
box1.left = _bbox.left;
|
|
box1.right = split;
|
|
box2.left = split + splitwid;
|
|
box2.right = _bbox.right;
|
|
box1.top = _bbox.top;
|
|
box1.bottom = _bbox.bottom;
|
|
box2.top = _bbox.top;
|
|
box2.bottom = _bbox.bottom;
|
|
} else {
|
|
box1.top = _bbox.top;
|
|
box1.bottom = split;
|
|
box2.top = split + splitwid;
|
|
box2.bottom = _bbox.bottom;
|
|
box1.left = _bbox.left;
|
|
box1.right = _bbox.right;
|
|
box2.left = _bbox.left;
|
|
box2.right = _bbox.right;
|
|
}
|
|
|
|
ch1->rearrange(box1);
|
|
ch2->rearrange(box2);
|
|
}
|
|
|
|
void PairWindow::redraw() {
|
|
// When the windows can be in arbitrary positions, some of them may be transparent, so we always
|
|
// need to force a full screen redraw in such cases
|
|
if (_dir == winmethod_Arbitrary)
|
|
Windows::_forceRedraw = true;
|
|
|
|
Window::redraw();
|
|
|
|
for (int ctr = 0, idx = (_backward ? (int)_children.size() - 1 : 0); ctr < (int)_children.size();
|
|
++ctr, idx += (_backward ? -1 : 1)) {
|
|
_children[idx]->redraw();
|
|
}
|
|
|
|
Window *child = !_backward ? _children.front() : _children.back();
|
|
Rect box(child->_bbox.left, child->_yAdj ? child->_bbox.top - child->_yAdj : child->_bbox.top,
|
|
child->_bbox.right, child->_bbox.bottom);
|
|
|
|
if (_vertical) {
|
|
int xBord = _wBorder ? g_conf->_wBorderX : 0;
|
|
int xPad = (g_conf->_wPaddingX - xBord) / 2;
|
|
|
|
g_vm->_screen->fillRect(Rect(box.right + xPad, box.top, box.right + xPad + xBord, box.bottom),
|
|
g_conf->_borderColor);
|
|
} else {
|
|
int yBord = _wBorder ? g_conf->_wBorderY : 0;
|
|
int yPad = (g_conf->_wPaddingY - yBord) / 2;
|
|
g_vm->_screen->fillRect(Rect(box.left, box.bottom + yPad, box.right, box.bottom + yPad + yBord),
|
|
g_conf->_borderColor);
|
|
}
|
|
}
|
|
|
|
void PairWindow::getArrangement(uint *method, uint *size, Window **keyWin) {
|
|
uint val = _dir | _division;
|
|
if (!_wBorder)
|
|
val |= winmethod_NoBorder;
|
|
|
|
if (size)
|
|
*size = _size;
|
|
if (keyWin) {
|
|
if (_key)
|
|
*keyWin = _key;
|
|
else
|
|
*keyWin = nullptr;
|
|
}
|
|
|
|
if (method)
|
|
*method = val;
|
|
}
|
|
|
|
void PairWindow::setArrangement(uint method, uint size, Window *keyWin) {
|
|
uint newDir;
|
|
bool newVertical, newBackward;
|
|
assert((method & winmethod_DirMask) != winmethod_Arbitrary && _dir != winmethod_Arbitrary);
|
|
|
|
if (_key) {
|
|
Window *wx;
|
|
PairWindow *pairWin = dynamic_cast<PairWindow *>(_key);
|
|
|
|
if (pairWin) {
|
|
warning("setArrangement: keywin cannot be a Pair");
|
|
return;
|
|
}
|
|
|
|
for (wx = _key; wx; wx = wx->_parent) {
|
|
if (wx == this)
|
|
break;
|
|
}
|
|
if (wx == nullptr) {
|
|
warning("setArrangement: keywin must be a descendant");
|
|
return;
|
|
}
|
|
}
|
|
|
|
newDir = method & winmethod_DirMask;
|
|
newVertical = (newDir == winmethod_Left || newDir == winmethod_Right);
|
|
newBackward = (newDir == winmethod_Left || newDir == winmethod_Above);
|
|
if (!keyWin)
|
|
keyWin = _key;
|
|
|
|
if ((newVertical && !_vertical) || (!newVertical && _vertical)) {
|
|
if (!_vertical)
|
|
warning("setArrangement: split must stay horizontal");
|
|
else
|
|
warning("setArrangement: split must stay vertical");
|
|
return;
|
|
}
|
|
|
|
if (keyWin && dynamic_cast<BlankWindow *>(keyWin)
|
|
&& (method & winmethod_DivisionMask) == winmethod_Fixed) {
|
|
warning("setArrangement: a Blank window cannot have a fixed size");
|
|
return;
|
|
}
|
|
|
|
if ((newBackward && !_backward) || (!newBackward && _backward)) {
|
|
// switch the children
|
|
SWAP(_children[0], _children[1]);
|
|
}
|
|
|
|
// set up everything else
|
|
_dir = newDir;
|
|
_division = method & winmethod_DivisionMask;
|
|
_key = keyWin;
|
|
_size = size;
|
|
_wBorder = ((method & winmethod_BorderMask) == winmethod_Border);
|
|
|
|
_vertical = (_dir == winmethod_Left || _dir == winmethod_Right);
|
|
_backward = (_dir == winmethod_Left || _dir == winmethod_Above);
|
|
|
|
_windows->rearrange();
|
|
}
|
|
|
|
void PairWindow::click(const Point &newPos) {
|
|
// Note in case windows are partially overlapping, we want the top-most window to get the click.
|
|
// WHich is why we recurse in the opposite of the rendering direction (as the _backward flag) indicates
|
|
for (int ctr = 0, idx = (!_backward ? (int)_children.size() - 1 : 0); ctr < (int)_children.size();
|
|
++ctr, idx += (!_backward ? -1 : 1)) {
|
|
Window *w = _children[idx];
|
|
if (w->_bbox.contains(newPos))
|
|
w->click(newPos);
|
|
}
|
|
}
|
|
|
|
} // End of namespace Glk
|