static void
clientAutoMaximize (Client * c, int full_w, int full_h)
{
if (FLAG_TEST (c->flags, CLIENT_FLAG_FULLSCREEN) ||
!FLAG_TEST (c->xfwm_flags, XFWM_FLAG_HAS_BORDER))
{
/*
* Fullscreen or undecorated windows should not be
* automatically maximized...
*/
return;
}
if (!FLAG_TEST (c->flags, CLIENT_FLAG_MAXIMIZED_HORIZ) &&
(frameWidth (c) > full_w))
{
TRACE ("The application \"%s\" has requested a window width "
"(%u) larger than the actual width available in the workspace (%u), "
"the window will be maximized horizontally.", c->name, frameWidth (c), full_w);
FLAG_SET (c->flags, CLIENT_FLAG_MAXIMIZED_HORIZ);
}
if (!FLAG_TEST (c->flags, CLIENT_FLAG_MAXIMIZED_VERT) &&
(frameHeight (c) > full_h))
{
TRACE ("The application \"%s\" has requested a window height "
"(%u) larger than the actual height available in the workspace (%u), "
"the window will be maximized vertically.", c->name, frameHeight (c), full_h);
FLAG_SET (c->flags, CLIENT_FLAG_MAXIMIZED_VERT);
}
}
static void
mousePlacement (Client * c, int full_x, int full_y, int full_w, int full_h, int mx, int my)
{
g_return_if_fail (c != NULL);
TRACE ("entering mousePlacement");
c->x = mx + frameLeft(c) - frameWidth(c) / 2;
c->y = my + frameTop(c) - frameHeight(c) / 2;
c->x = MIN (c->x, full_x + full_w - frameWidth(c) + frameLeft(c));
c->y = MIN (c->y, full_y + full_h - frameHeight(c) + frameTop(c));
c->x = MAX (c->x, full_x + frameLeft(c));
c->y = MAX (c->y, full_y + frameTop(c));
}
void renderScene2(void)
{
for (int y = 0; y < frameHeight(); y++)
for (int x = 0; x < frameWidth(); x++)
//vfb[y][x] = Color(x / (float) frameWidth(), y / (float) frameHeight(), 0.0f;
vfb[y][x] = Color(0,1,1);
}
// ---
QGAMES::Frame* QGAMES::Sprite2D::createFrame (int nf)
{
int pX = -1; int pY = -1;
int w = -1; int h = -1;
int xO = -1; int yO = -1;
std::map <int, int>::const_iterator i1 = _frameData._realFrameXPosition.find (nf);
std::map <int, int>::const_iterator i2 = _frameData._realFrameYPosition.find (nf);
std::map <int, int>::const_iterator i3 = _frameData._realFrameDefinitionWidth.find (nf);
std::map <int, int>::const_iterator i4 = _frameData._realFrameDefinitionHeight.find (nf);
std::map <int, int>::const_iterator i5 = _frameData._realXOffSet.find (nf);
std::map <int, int>::const_iterator i6 = _frameData._realYOffSet.find (nf);
// It could be special when the position for the frame
// has been defined. It is needed to define both x and y positions...
// If some of them has not been defined, then the frame
// is considered as normnal!
if (i1 == _frameData._realFrameXPosition.end () ||
i2 == _frameData._realFrameYPosition.end ())
{
return (new QGAMES::Sprite2DFrame (this, nf)); // Standard frame...
}
// But if both have been defined, the frae is special
// But the width and the height of the frame
// are not mandatory....if any of them is not defined then
// the generic one is caught!
else
{
pX = (*i1).second; pY = (*i2).second;
w = (i3 == _frameData._realFrameDefinitionWidth.end ()) ? frameWidth () : (*i3).second;
h = (i4 == _frameData._realFrameDefinitionHeight.end ()) ? frameHeight () : (*i4).second;
xO = (i5 == _frameData._realXOffSet.end ()) ? frameXOffset () : (*i5).second;
yO = (i6 == _frameData._realYOffSet.end ()) ? frameYOffset () : (*i6).second;
return (new QGAMES::Sprite2DFrame (this, nf, pX, pY, w, h, xO, yO)); // Specific frame...
}
}
static void
centerPlacement (Client * c, int full_x, int full_y, int full_w, int full_h)
{
g_return_if_fail (c != NULL);
TRACE ("entering centerPlacement");
c->x = MAX (full_x + frameLeft(c) + (full_w - frameWidth(c)) / 2, full_x + frameLeft(c));
c->y = MAX (full_y + frameTop(c) + (full_h - frameHeight(c)) / 2, full_y + frameTop(c));
}
Ray Camera::getScreenRay(double x, double y)
{
Vector dest = upLeft + (upRight - upLeft) * (x / frameWidth())
+ (downLeft - upLeft) * (y / frameHeight());
Ray result;
result.start = pos;
result.dir = dest - pos;
result.dir.normalize();
return result;
}
void
clientFill (Client * c, int fill_type)
{
ScreenInfo *screen_info;
Client *east_neighbour;
Client *west_neighbour;
Client *north_neighbour;
Client *south_neighbour;
Client *c2;
GdkRectangle rect;
XWindowChanges wc;
unsigned short mask;
guint i;
gint cx, cy, full_x, full_y, full_w, full_h;
gint tmp_x, tmp_y, tmp_w, tmp_h;
g_return_if_fail (c != NULL);
TRACE ("entering clientFill");
if (!CLIENT_CAN_FILL_WINDOW (c))
{
return;
}
screen_info = c->screen_info;
mask = 0;
east_neighbour = NULL;
west_neighbour = NULL;
north_neighbour = NULL;
south_neighbour = NULL;
for (c2 = screen_info->clients, i = 0; i < screen_info->client_count; c2 = c2->next, i++)
{
/* Filter out all windows which are not visible, or not on the same layer
* as well as the client window itself
*/
if ((c != c2) && FLAG_TEST (c2->xfwm_flags, XFWM_FLAG_VISIBLE) && (c2->win_layer == c->win_layer))
{
/* Fill horizontally */
if (fill_type & CLIENT_FILL_HORIZ)
{
/*
* check if the neigbour client (c2) is located
* east or west of our client.
*/
if (segment_overlap (frameY(c), frameY(c) + frameHeight(c), frameY(c2), frameY(c2) + frameHeight(c2)))
{
if ((frameX(c2) + frameWidth(c2)) <= frameX(c))
{
if (west_neighbour)
{
/* Check if c2 is closer to the client
* then the west neighbour already found
*/
if ((frameX(west_neighbour) + frameWidth(west_neighbour)) < (frameX(c2) + frameWidth(c2)))
{
west_neighbour = c2;
}
}
else
{
west_neighbour = c2;
}
}
if ((frameX(c) + frameWidth(c)) <= frameX(c2))
{
/* Check if c2 is closer to the client
* then the west neighbour already found
*/
if (east_neighbour)
{
if (frameX(c2) < frameX(east_neighbour))
{
east_neighbour = c2;
}
}
else
{
east_neighbour = c2;
}
}
}
}
/* Fill vertically */
if (fill_type & CLIENT_FILL_VERT)
{
/* check if the neigbour client (c2) is located
* north or south of our client.
*/
if (segment_overlap (frameX(c), frameX(c) + frameWidth(c), frameX(c2), frameX(c2) + frameWidth(c2)))
{
if ((frameY(c2) + frameHeight(c2)) <= frameY(c))
{
if (north_neighbour)
{
/* Check if c2 is closer to the client
* then the north neighbour already found
*/
if ((frameY(north_neighbour) + frameHeight(north_neighbour)) < (frameY(c2) + frameHeight(c2)))
{
north_neighbour = c2;
}
}
else
{
north_neighbour = c2;
}
}
if ((frameY(c) + frameHeight(c)) <= frameY(c2))
{
if (south_neighbour)
{
/* Check if c2 is closer to the client
* then the south neighbour already found
*/
if (frameY(c2) < frameY(south_neighbour))
{
south_neighbour = c2;
}
}
else
{
south_neighbour = c2;
}
}
}
}
}
}
/* Compute the largest size available, based on struts, margins and Xinerama layout */
tmp_x = frameX (c);
tmp_y = frameY (c);
tmp_h = frameHeight (c);
tmp_w = frameWidth (c);
cx = tmp_x + (tmp_w / 2);
cy = tmp_y + (tmp_h / 2);
myScreenFindMonitorAtPoint (screen_info, cx, cy, &rect);
full_x = MAX (screen_info->params->xfwm_margins[STRUTS_LEFT], rect.x);
full_y = MAX (screen_info->params->xfwm_margins[STRUTS_TOP], rect.y);
full_w = MIN (screen_info->width - screen_info->params->xfwm_margins[STRUTS_RIGHT],
rect.x + rect.width) - full_x;
full_h = MIN (screen_info->height - screen_info->params->xfwm_margins[STRUTS_BOTTOM],
rect.y + rect.height) - full_y;
if ((fill_type & CLIENT_FILL) == CLIENT_FILL)
{
mask = CWX | CWY | CWHeight | CWWidth;
/* Adjust size to the largest size available, not covering struts */
clientMaxSpace (screen_info, &full_x, &full_y, &full_w, &full_h);
}
else if (fill_type & CLIENT_FILL_VERT)
{
mask = CWY | CWHeight;
/* Adjust size to the tallest size available, for the current horizontal position/width */
clientMaxSpace (screen_info, &tmp_x, &full_y, &tmp_w, &full_h);
}
else if (fill_type & CLIENT_FILL_HORIZ)
{
mask = CWX | CWWidth;
/* Adjust size to the widest size available, for the current vertical position/height */
clientMaxSpace (screen_info, &full_x, &tmp_y, &full_w, &tmp_h);
}
/* If there are neighbours, resize to their borders.
* If not, resize to the largest size available that you just have computed.
*/
wc.x = full_x + frameLeft(c);
if (west_neighbour)
{
wc.x += MAX (frameX(west_neighbour) + frameWidth(west_neighbour) - full_x, 0);
}
wc.width = full_w - frameRight(c) - (wc.x - full_x);
if (east_neighbour)
{
wc.width -= MAX (full_w - (frameX(east_neighbour) - full_x), 0);
}
wc.y = full_y + frameTop(c);
if (north_neighbour)
{
wc.y += MAX (frameY(north_neighbour) + frameHeight(north_neighbour) - full_y, 0);
}
wc.height = full_h - frameBottom(c) - (wc.y - full_y);
if (south_neighbour)
{
wc.height -= MAX (full_h - (frameY(south_neighbour) - full_y), 0);
}
TRACE ("Fill size request: (%d,%d) %dx%d", wc.x, wc.y, wc.width, wc.height);
if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_MANAGED))
{
clientConfigure(c, &wc, mask, NO_CFG_FLAG);
}
}
void
clientInitPosition (Client * c)
{
ScreenInfo *screen_info;
Client *c2;
GdkRectangle rect;
int full_x, full_y, full_w, full_h, msx, msy;
gint n_monitors;
gboolean place;
gboolean position;
g_return_if_fail (c != NULL);
TRACE ("entering clientInitPosition");
screen_info = c->screen_info;
msx = 0;
msy = 0;
position = (c->size->flags & (PPosition | USPosition));
n_monitors = myScreenGetNumMonitors (c->screen_info);
if ((n_monitors > 1) || (screen_info->params->placement_mode == PLACE_MOUSE))
{
getMouseXY (screen_info, screen_info->xroot, &msx, &msy);
myScreenFindMonitorAtPoint (screen_info, msx, msy, &rect);
}
else
{
gdk_screen_get_monitor_geometry (screen_info->gscr, 0, &rect);
}
if (position || (c->type & (WINDOW_TYPE_DONT_PLACE | WINDOW_TYPE_DIALOG)) || clientIsTransient (c))
{
if (!position && clientIsTransient (c) && (c2 = clientGetTransient (c)))
{
/* Center transient relative to their parent window */
c->x = c2->x + (c2->width - c->width) / 2;
c->y = c2->y + (c2->height - c->height) / 2;
if (n_monitors > 1)
{
msx = frameX (c) + (frameWidth (c) / 2);
msy = frameY (c) + (frameHeight (c) / 2);
myScreenFindMonitorAtPoint (screen_info, msx, msy, &rect);
}
}
if (CONSTRAINED_WINDOW (c))
{
clientKeepVisible (c, n_monitors, &rect);
}
place = FALSE;
}
else
{
place = TRUE;
}
full_x = MAX (screen_info->params->xfwm_margins[STRUTS_LEFT], rect.x);
full_y = MAX (screen_info->params->xfwm_margins[STRUTS_TOP], rect.y);
full_w = MIN (screen_info->width - screen_info->params->xfwm_margins[STRUTS_RIGHT],
rect.x + rect.width) - full_x;
full_h = MIN (screen_info->height - screen_info->params->xfwm_margins[STRUTS_BOTTOM],
rect.y + rect.height) - full_y;
/* Adjust size to the widest size available, not covering struts */
clientMaxSpace (screen_info, &full_x, &full_y, &full_w, &full_h);
/*
If the windows is smaller than the given ratio of the available screen area,
or if the window is larger than the screen area or if the given ratio is higher
than 100% place the window at the center.
Otherwise, place the window "smartly", using the good old CPU consuming algorithm...
*/
if (place)
{
if ((screen_info->params->placement_ratio >= 100) ||
(100 * frameWidth(c) * frameHeight(c)) < (screen_info->params->placement_ratio * full_w * full_h))
{
if (screen_info->params->placement_mode == PLACE_MOUSE)
{
mousePlacement (c, full_x, full_y, full_w, full_h, msx, msy);
}
else
{
centerPlacement (c, full_x, full_y, full_w, full_h);
}
}
else if ((frameWidth(c) >= full_w) && (frameHeight(c) >= full_h))
{
centerPlacement (c, full_x, full_y, full_w, full_h);
}
else
{
smartPlacement (c, full_x, full_y, full_w, full_h);
}
}
if (c->type & WINDOW_REGULAR_FOCUSABLE)
{
clientAutoMaximize (c, full_w, full_h);
}
}
static void
smartPlacement (Client * c, int full_x, int full_y, int full_w, int full_h)
{
Client *c2;
ScreenInfo *screen_info;
gfloat best_overlaps;
guint i;
gint test_x, test_y, xmax, ymax, best_x, best_y;
gint frame_height, frame_width, frame_left, frame_top;
gboolean first;
gint c2_x, c2_y;
g_return_if_fail (c != NULL);
TRACE ("entering smartPlacement");
screen_info = c->screen_info;
frame_height = frameHeight (c);
frame_width = frameWidth (c);
frame_left = frameLeft(c);
frame_top = frameTop (c);
test_x = 0;
test_y = 0;
best_overlaps = 0.0;
first = TRUE;
xmax = full_x + full_w - c->width - frameRight (c);
ymax = full_y + full_h - c->height - frameBottom (c);
best_x = full_x + frameLeft (c);
best_y = full_y + frameTop (c);
test_y = full_y + frameTop (c);
do
{
test_x = full_x + frameLeft (c);
do
{
gfloat count_overlaps = 0.0;
TRACE ("analyzing %i clients", screen_info->client_count);
for (c2 = screen_info->clients, i = 0; i < screen_info->client_count; c2 = c2->next, i++)
{
if ((c2 != c) && (c2->type != WINDOW_DESKTOP)
&& (c->win_workspace == c2->win_workspace)
&& FLAG_TEST (c2->xfwm_flags, XFWM_FLAG_VISIBLE))
{
c2_x = frameX (c2);
c2_y = frameY (c2);
count_overlaps += overlap (test_x - frame_left,
test_y - frame_top,
test_x - frame_left + frame_width,
test_y - frame_top + frame_height,
c2_x,
c2_y,
c2_x + frameWidth (c2),
c2_y + frameHeight (c2));
}
}
if (count_overlaps < 0.1)
{
TRACE ("overlaps is 0 so it's the best we can get");
c->x = test_x;
c->y = test_y;
return;
}
else if ((count_overlaps < best_overlaps) || (first))
{
best_x = test_x;
best_y = test_y;
best_overlaps = count_overlaps;
}
if (first)
{
first = FALSE;
}
test_x += 8;
}
while (test_x <= xmax);
test_y += 8;
}
while (test_y <= ymax);
c->x = best_x;
c->y = best_y;
}
/* clientConstrainPos() is used when moving windows
to ensure that the window stays accessible to the user
Returns the position in which the window was constrained.
CLIENT_CONSTRAINED_TOP = 1<<0
CLIENT_CONSTRAINED_BOTTOM = 1<<1
CLIENT_CONSTRAINED_LEFT = 1<<2
CLIENT_CONSTRAINED_RIGHT = 1<<3
*/
unsigned int
clientConstrainPos (Client * c, gboolean show_full)
{
Client *c2;
ScreenInfo *screen_info;
guint i;
gint cx, cy, disp_x, disp_y, disp_max_x, disp_max_y;
gint frame_height, frame_width, frame_top, frame_left;
gint frame_x, frame_y, frame_visible;
gint screen_width, screen_height;
guint ret;
GdkRectangle rect;
gint min_visible;
g_return_val_if_fail (c != NULL, 0);
TRACE ("entering clientConstrainPos %s",
show_full ? "(with show full)" : "(w/out show full)");
TRACE ("client \"%s\" (0x%lx)", c->name, c->window);
/* We use a bunch of local vars to reduce the overhead of calling other functions all the time */
frame_x = frameX (c);
frame_y = frameY (c);
frame_height = frameHeight (c);
frame_width = frameWidth (c);
frame_top = frameTop (c);
frame_left = frameLeft (c);
frame_visible = (frame_top ? frame_top : frame_height);
min_visible = MAX (frame_top, CLIENT_MIN_VISIBLE);
ret = 0;
cx = frame_x + (frame_width / 2);
cy = frame_y + (frame_height / 2);
screen_info = c->screen_info;
myScreenFindMonitorAtPoint (screen_info, cx, cy, &rect);
screen_width = screen_info->width;
screen_height = screen_info->height;
disp_x = rect.x;
disp_y = rect.y;
disp_max_x = rect.x + rect.width;
disp_max_y = rect.y + rect.height;
if (FLAG_TEST (c->flags, CLIENT_FLAG_FULLSCREEN))
{
TRACE ("ignoring constrained for client \"%s\" (0x%lx)", c->name,
c->window);
return 0;
}
if (show_full)
{
/* Struts and other partial struts */
for (c2 = screen_info->clients, i = 0; i < screen_info->client_count; c2 = c2->next, i++)
{
if (FLAG_TEST (c2->flags, CLIENT_FLAG_HAS_STRUT)
&& FLAG_TEST (c2->xfwm_flags, XFWM_FLAG_VISIBLE)
&& (c2 != c))
{
/* Right */
if (segment_overlap (frame_y, frame_y + frame_height,
c2->struts[STRUTS_RIGHT_START_Y], c2->struts[STRUTS_RIGHT_END_Y]))
{
if (segment_overlap (frame_x, frame_x + frame_width,
screen_width - c2->struts[STRUTS_RIGHT],
screen_width))
{
c->x = screen_width - c2->struts[STRUTS_RIGHT] - frame_width + frame_left;
frame_x = frameX (c);
ret |= CLIENT_CONSTRAINED_RIGHT;
}
}
/* Bottom */
if (segment_overlap (frame_x, frame_x + frame_width,
c2->struts[STRUTS_BOTTOM_START_X], c2->struts[STRUTS_BOTTOM_END_X]))
{
if (segment_overlap (frame_y, frame_y + frame_height,
screen_height - c2->struts[STRUTS_BOTTOM],
screen_height))
{
c->y = screen_height - c2->struts[STRUTS_BOTTOM] - frame_height + frame_top;
frame_y = frameY (c);
ret |= CLIENT_CONSTRAINED_BOTTOM;
}
}
}
}
if (frame_x + frame_width >= disp_max_x)
{
c->x = disp_max_x - frame_width + frame_left;
frame_x = frameX (c);
ret |= CLIENT_CONSTRAINED_RIGHT;
}
if (frame_x <= disp_x)
{
c->x = disp_x + frame_left;
frame_x = frameX (c);
ret |= CLIENT_CONSTRAINED_LEFT;
}
if (frame_y + frame_height >= disp_max_y)
{
c->y = disp_max_y - frame_height + frame_top;
frame_y = frameY (c);
ret |= CLIENT_CONSTRAINED_BOTTOM;
}
if (frame_y <= disp_y)
{
c->y = disp_y + frame_top;
frame_y = frameY (c);
ret |= CLIENT_CONSTRAINED_TOP;
}
for (c2 = screen_info->clients, i = 0; i < screen_info->client_count; c2 = c2->next, i++)
{
if (FLAG_TEST (c2->flags, CLIENT_FLAG_HAS_STRUT)
&& FLAG_TEST (c2->xfwm_flags, XFWM_FLAG_VISIBLE)
&& (c2 != c))
{
/* Left */
if (segment_overlap (frame_y, frame_y + frame_height,
c2->struts[STRUTS_LEFT_START_Y], c2->struts[STRUTS_LEFT_END_Y]))
{
if (segment_overlap (frame_x, frame_x + frame_width,
0, c2->struts[STRUTS_LEFT]))
{
c->x = c2->struts[STRUTS_LEFT] + frame_left;
frame_x = frameX (c);
ret |= CLIENT_CONSTRAINED_LEFT;
}
}
/* Top */
if (segment_overlap (frame_x,
frame_x + frame_width,
c2->struts[STRUTS_TOP_START_X],
c2->struts[STRUTS_TOP_END_X]))
{
if (segment_overlap (frame_y, frame_y + frame_height,
0, c2->struts[STRUTS_TOP]))
{
c->y = c2->struts[STRUTS_TOP] + frame_top;
frame_y = frameY (c);
ret |= CLIENT_CONSTRAINED_TOP;
}
}
}
}
}
else
{
if (frame_x + frame_width <= disp_x + min_visible)
{
c->x = disp_x + min_visible - frame_width + frame_left;
frame_x = frameX (c);
ret |= CLIENT_CONSTRAINED_LEFT;
}
if (frame_x + min_visible >= disp_max_x)
{
c->x = disp_max_x - min_visible + frame_left;
frame_x = frameX (c);
ret |= CLIENT_CONSTRAINED_RIGHT;
}
if (frame_y + frame_height <= disp_y + min_visible)
{
c->y = disp_y + min_visible - frame_height + frame_top;
frame_y = frameY (c);
ret |= CLIENT_CONSTRAINED_TOP;
}
if (frame_y + min_visible >= disp_max_y)
{
c->y = disp_max_y - min_visible + frame_top;
frame_y = frameY (c);
ret |= CLIENT_CONSTRAINED_BOTTOM;
}
if ((frame_y <= disp_y) && (frame_y >= disp_y - frame_top))
{
c->y = disp_y + frame_top;
frame_y = frameY (c);
ret |= CLIENT_CONSTRAINED_TOP;
}
/* Struts and other partial struts */
for (c2 = screen_info->clients, i = 0; i < screen_info->client_count; c2 = c2->next, i++)
{
if (FLAG_TEST (c2->flags, CLIENT_FLAG_HAS_STRUT)
&& FLAG_TEST (c2->xfwm_flags, XFWM_FLAG_VISIBLE)
&& (c2 != c))
{
/* Right */
if (segment_overlap (frame_y, frame_y + frame_height,
c2->struts[STRUTS_RIGHT_START_Y], c2->struts[STRUTS_RIGHT_END_Y]))
{
if (frame_x >= screen_width - c2->struts[STRUTS_RIGHT] - min_visible)
{
c->x = screen_width - c2->struts[STRUTS_RIGHT] - min_visible + frame_left;
frame_x = frameX (c);
ret |= CLIENT_CONSTRAINED_RIGHT;
}
}
/* Left */
if (segment_overlap (frame_y, frame_y + frame_height,
c2->struts[STRUTS_LEFT_START_Y], c2->struts[STRUTS_LEFT_END_Y]))
{
if (frame_x + frame_width <= c2->struts[STRUTS_LEFT] + min_visible)
{
c->x = c2->struts[STRUTS_LEFT] + min_visible - frame_width + frame_left;
frame_x = frameX (c);
ret |= CLIENT_CONSTRAINED_LEFT;
}
}
/* Bottom */
if (segment_overlap (frame_x, frame_x + frame_width,
c2->struts[STRUTS_BOTTOM_START_X], c2->struts[STRUTS_BOTTOM_END_X]))
{
if (frame_y >= screen_height - c2->struts[STRUTS_BOTTOM] - min_visible)
{
c->y = screen_height - c2->struts[STRUTS_BOTTOM] - min_visible + frame_top;
frame_y = frameY (c);
ret |= CLIENT_CONSTRAINED_BOTTOM;
}
}
/* Top */
if (segment_overlap (frame_x, frame_x + frame_width,
c2->struts[STRUTS_TOP_START_X], c2->struts[STRUTS_TOP_END_X]))
{
if (segment_overlap (frame_y, frame_y + frame_visible, 0, c2->struts[STRUTS_TOP]))
{
c->y = c2->struts[STRUTS_TOP] + frame_top;
frame_y = frameY (c);
ret |= CLIENT_CONSTRAINED_TOP;
}
if (frame_y + frame_height <= c2->struts[STRUTS_TOP] + min_visible)
{
c->y = c2->struts[STRUTS_TOP] + min_visible - frame_height + frame_top;
frame_y = frameY (c);
ret |= CLIENT_CONSTRAINED_TOP;
}
}
}
}
}
return ret;
}
// ---
int QGAMES::Sprite2D::frameHeightForFrame (int nF) const
{
std::map <int, int>::const_iterator i = _frameData._realHeight.find (nF);
return ((i == _frameData._realHeight.end ()) ? frameHeight () : (*i).second);
}
