678 lines
21 KiB
C++
678 lines
21 KiB
C++
// Workspace.cc for Fluxbox
|
|
// Copyright (c) 2001 - 2005 Henrik Kinnunen (fluxgen at fluxbox dot org)
|
|
//
|
|
// Workspace.cc for Blackbox - an X11 Window manager
|
|
// Copyright (c) 1997 - 2000 Brad Hughes (bhughes at tcac.net)
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a
|
|
// copy of this software and associated documentation files (the "Software"),
|
|
// to deal in the Software without restriction, including without limitation
|
|
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
// and/or sell copies of the Software, and to permit persons to whom the
|
|
// Software is furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in
|
|
// all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
// DEALINGS IN THE SOFTWARE.
|
|
|
|
// $Id$
|
|
|
|
#include "Workspace.hh"
|
|
|
|
#include "fluxbox.hh"
|
|
#include "Screen.hh"
|
|
#include "Window.hh"
|
|
#include "WinClient.hh"
|
|
#include "FbWinFrame.hh"
|
|
|
|
#include "FbTk/I18n.hh"
|
|
#include "FbTk/MenuItem.hh"
|
|
#include "FbTk/StringUtil.hh"
|
|
|
|
// use GNU extensions
|
|
#ifndef _GNU_SOURCE
|
|
#define _GNU_SOURCE
|
|
#endif // _GNU_SOURCE
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif // HAVE_CONFIG_H
|
|
|
|
#include <X11/Xlib.h>
|
|
#include <X11/Xatom.h>
|
|
|
|
#ifdef HAVE_CSTDIO
|
|
#include <cstdio>
|
|
#else
|
|
#include <stdio.h>
|
|
#endif
|
|
#ifdef HAVE_CSTRING
|
|
#include <cstring>
|
|
#else
|
|
#include <string.h>
|
|
#endif
|
|
|
|
#include <algorithm>
|
|
#include <iostream>
|
|
#include <iterator>
|
|
|
|
using namespace std;
|
|
|
|
namespace { // anonymous
|
|
|
|
int countTransients(const WinClient &client) {
|
|
if (client.transientList().empty())
|
|
return 0;
|
|
// now go throu the entire tree and count transients
|
|
size_t ret = client.transientList().size();
|
|
WinClient::TransientList::const_iterator it = client.transientList().begin();
|
|
WinClient::TransientList::const_iterator it_end = client.transientList().end();
|
|
for (; it != it_end; ++it)
|
|
ret += countTransients(*(*it));
|
|
|
|
return ret;
|
|
}
|
|
|
|
class ClientMenuItem:public FbTk::MenuItem {
|
|
public:
|
|
ClientMenuItem(WinClient &client):
|
|
FbTk::MenuItem(client.title().c_str(), client.fbwindow() ? &client.fbwindow()->menu() : 0),
|
|
m_client(client) {
|
|
|
|
}
|
|
void click(int button, int time) {
|
|
if (m_client.fbwindow() == 0)
|
|
return;
|
|
FluxboxWindow &win = *m_client.fbwindow();
|
|
|
|
win.screen().changeWorkspaceID(win.workspaceNumber());
|
|
win.setCurrentClient(m_client);
|
|
win.raiseAndFocus();
|
|
}
|
|
|
|
const std::string &label() const { return m_client.title(); }
|
|
bool isSelected() const {
|
|
if (m_client.fbwindow() == 0)
|
|
return false;
|
|
if (m_client.fbwindow()->isFocused() == false)
|
|
return false;
|
|
return (&(m_client.fbwindow()->winClient()) == &m_client);
|
|
|
|
}
|
|
private:
|
|
WinClient &m_client;
|
|
};
|
|
|
|
};
|
|
|
|
Workspace::GroupList Workspace::m_groups;
|
|
|
|
Workspace::Workspace(BScreen &scrn, FbTk::MultLayers &layermanager,
|
|
const std::string &name, unsigned int id):
|
|
m_screen(scrn),
|
|
m_lastfocus(0),
|
|
m_clientmenu(scrn.menuTheme(), scrn.imageControl(),
|
|
*scrn.layerManager().getLayer(Fluxbox::instance()->getMenuLayer())),
|
|
m_layermanager(layermanager),
|
|
m_name(name),
|
|
m_id(id) {
|
|
|
|
|
|
m_cascade_x = new int[scrn.numHeads() + 1];
|
|
m_cascade_y = new int[scrn.numHeads() + 1];
|
|
for (int i=0; i < scrn.numHeads()+1; i++) {
|
|
m_cascade_x[i] = 32 + scrn.getHeadX(i);
|
|
m_cascade_y[i] = 32 + scrn.getHeadY(i);
|
|
}
|
|
menu().setInternalMenu();
|
|
setName(name);
|
|
}
|
|
|
|
|
|
Workspace::~Workspace() {
|
|
delete [] m_cascade_x;
|
|
delete [] m_cascade_y;
|
|
}
|
|
|
|
void Workspace::setLastFocusedWindow(FluxboxWindow *win) {
|
|
// make sure we have this window in the list
|
|
if (std::find(m_windowlist.begin(), m_windowlist.end(), win) != m_windowlist.end())
|
|
m_lastfocus = win;
|
|
else
|
|
m_lastfocus = 0;
|
|
}
|
|
|
|
void Workspace::addWindow(FluxboxWindow &w, bool place) {
|
|
// we don't need to add a window that already exist in our list
|
|
if (find(m_windowlist.begin(), m_windowlist.end(), &w) != m_windowlist.end())
|
|
return;
|
|
|
|
w.setWorkspace(m_id);
|
|
// attach signals
|
|
w.titleSig().attach(this);
|
|
|
|
if (place)
|
|
placeWindow(w);
|
|
|
|
m_windowlist.push_back(&w);
|
|
updateClientmenu();
|
|
|
|
if (!w.isStuck()) {
|
|
FluxboxWindow::ClientList::iterator client_it =
|
|
w.clientList().begin();
|
|
FluxboxWindow::ClientList::iterator client_it_end =
|
|
w.clientList().end();
|
|
for (; client_it != client_it_end; ++client_it)
|
|
screen().updateNetizenWindowAdd((*client_it)->window(), m_id);
|
|
}
|
|
|
|
}
|
|
|
|
// still_alive is true if the window will continue to exist after
|
|
// this event. Particularly, this isn't the removeWindow for
|
|
// the destruction of the window. Because if so, the focus revert
|
|
// is done in another place
|
|
int Workspace::removeWindow(FluxboxWindow *w, bool still_alive) {
|
|
|
|
if (w == 0)
|
|
return -1;
|
|
|
|
// detach from signals
|
|
w->titleSig().detach(this);
|
|
|
|
if (m_lastfocus == w) {
|
|
m_lastfocus = 0;
|
|
}
|
|
|
|
if (w->isFocused() && still_alive)
|
|
Fluxbox::instance()->unfocusWindow(w->winClient(), true, true);
|
|
|
|
// we don't remove it from the layermanager, as it may be being moved
|
|
Windows::iterator erase_it = remove(m_windowlist.begin(),
|
|
m_windowlist.end(), w);
|
|
if (erase_it != m_windowlist.end())
|
|
m_windowlist.erase(erase_it);
|
|
|
|
updateClientmenu();
|
|
|
|
if (m_lastfocus == w || m_windowlist.empty())
|
|
m_lastfocus = 0;
|
|
|
|
|
|
if (!w->isStuck()) {
|
|
FluxboxWindow::ClientList::iterator client_it =
|
|
w->clientList().begin();
|
|
FluxboxWindow::ClientList::iterator client_it_end =
|
|
w->clientList().end();
|
|
for (; client_it != client_it_end; ++client_it)
|
|
screen().updateNetizenWindowDel((*client_it)->window());
|
|
}
|
|
|
|
return m_windowlist.size();
|
|
}
|
|
|
|
void Workspace::showAll() {
|
|
Windows::iterator it = m_windowlist.begin();
|
|
Windows::iterator it_end = m_windowlist.end();
|
|
for (; it != it_end; ++it)
|
|
(*it)->deiconify(false, false);
|
|
}
|
|
|
|
|
|
void Workspace::hideAll(bool interrupt_moving) {
|
|
Windows::reverse_iterator it = m_windowlist.rbegin();
|
|
Windows::reverse_iterator it_end = m_windowlist.rend();
|
|
for (; it != it_end; ++it) {
|
|
if (! (*it)->isStuck())
|
|
(*it)->withdraw(interrupt_moving);
|
|
}
|
|
}
|
|
|
|
|
|
void Workspace::removeAll() {
|
|
Windows::iterator it = m_windowlist.begin();
|
|
Windows::const_iterator it_end = m_windowlist.end();
|
|
for (; it != it_end; ++it)
|
|
(*it)->iconify();
|
|
}
|
|
|
|
|
|
void Workspace::reconfigure() {
|
|
menu().reconfigure();
|
|
|
|
Windows::iterator it = m_windowlist.begin();
|
|
Windows::iterator it_end = m_windowlist.end();
|
|
for (; it != it_end; ++it) {
|
|
if ((*it)->winClient().validateClient())
|
|
(*it)->reconfigure();
|
|
}
|
|
}
|
|
|
|
int Workspace::numberOfWindows() const {
|
|
return m_windowlist.size();
|
|
}
|
|
|
|
namespace {
|
|
// helper class for checkGrouping
|
|
class FindInGroup {
|
|
public:
|
|
FindInGroup(const FluxboxWindow &w):m_w(w) { }
|
|
bool operator ()(const string &name) const {
|
|
return (name == m_w.winClient().getWMClassName());
|
|
}
|
|
private:
|
|
const FluxboxWindow &m_w;
|
|
};
|
|
|
|
};
|
|
|
|
//Note: this function doesn't check if the window is groupable
|
|
bool Workspace::checkGrouping(FluxboxWindow &win) {
|
|
if (win.numClients() == 0)
|
|
return false;
|
|
#ifdef DEBUG
|
|
cerr<<__FILE__<<"("<<__LINE__<<"): Checking grouping. ("<<win.title()<<")"<<endl;
|
|
#endif // DEBUG
|
|
if (!win.isGroupable()) { // make sure this window can hold a tab
|
|
#ifdef DEBUG
|
|
cerr<<__FILE__<<"("<<__LINE__<<"): window can't use a tab"<<endl;
|
|
#endif // DEBUG
|
|
return false;
|
|
}
|
|
|
|
string instance_name = win.winClient().getWMClassName();
|
|
|
|
// go through every group and search for matching win instancename
|
|
GroupList::iterator g(m_groups.begin());
|
|
GroupList::iterator g_end(m_groups.end());
|
|
for (; g != g_end; ++g) {
|
|
Group::iterator name((*g).begin());
|
|
Group::iterator name_end((*g).end());
|
|
for (; name != name_end; ++name) {
|
|
|
|
if ((*name) != instance_name)
|
|
continue;
|
|
|
|
// find a window with the specific name
|
|
Windows::iterator wit(m_windowlist.begin());
|
|
Windows::iterator wit_end(m_windowlist.end());
|
|
for (; wit != wit_end; ++wit) {
|
|
#ifdef DEBUG
|
|
cerr<<__FILE__<<" check group with : "<<(*wit)->winClient().getWMClassName()<<endl;
|
|
#endif // DEBUG
|
|
if (find_if((*g).begin(),
|
|
(*g).end(),
|
|
FindInGroup(*(*wit))) != (*g).end()) {
|
|
// make sure the window is groupable
|
|
// and don't group with ourself
|
|
if ( !(*wit)->isGroupable() || (*wit)->winClient().fbwindow() == &win)
|
|
break; // try next name
|
|
#ifdef DEBUG
|
|
cerr<<__FILE__<<"("<<__FUNCTION__<<"): window ("<<*wit<<") attaching window ("<<&win<<")"<<endl;
|
|
#endif // DEBUG
|
|
(*wit)->attachClient(win.winClient());
|
|
return true; // grouping done
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool Workspace::loadGroups(const std::string &filename) {
|
|
string real_filename = FbTk::StringUtil::expandFilename(filename);
|
|
FbTk::StringUtil::removeTrailingWhitespace(real_filename);
|
|
ifstream infile(real_filename.c_str());
|
|
if (!infile)
|
|
return false;
|
|
|
|
m_groups.clear(); // erase old groups
|
|
|
|
// load new groups
|
|
while (!infile.eof()) {
|
|
string line;
|
|
vector<string> names;
|
|
getline(infile, line);
|
|
FbTk::StringUtil::stringtok(names, line);
|
|
m_groups.push_back(names);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void Workspace::update(FbTk::Subject *subj) {
|
|
menu().updateMenu();
|
|
}
|
|
|
|
|
|
void Workspace::setName(const std::string &name) {
|
|
if (!name.empty()) {
|
|
m_name = name;
|
|
} else { //if name == 0 then set default name from nls
|
|
_FB_USES_NLS;
|
|
char tname[128];
|
|
sprintf(tname,
|
|
_FBTEXT(Workspace, DefaultNameFormat,
|
|
"Workspace %d", "Default workspace names, with a %d for the workspace number"),
|
|
m_id + 1); //m_id starts at 0
|
|
m_name = tname;
|
|
}
|
|
|
|
screen().updateWorkspaceNamesAtom();
|
|
|
|
menu().setLabel(m_name.c_str());
|
|
menu().updateMenu();
|
|
}
|
|
|
|
/**
|
|
Calls restore on all windows
|
|
on the workspace and then
|
|
clears the m_windowlist
|
|
*/
|
|
void Workspace::shutdown() {
|
|
// note: when the window dies it'll remove it self from the list
|
|
while (!m_windowlist.empty()) {
|
|
// restore with remap on all clients in that window
|
|
m_windowlist.back()->restore(true);
|
|
//delete window (the window removes it self from m_windowlist)
|
|
delete m_windowlist.back();
|
|
}
|
|
}
|
|
|
|
void Workspace::updateClientmenu() {
|
|
// remove all items and then add them again
|
|
menu().removeAll();
|
|
// for each fluxboxwindow add every client in them to our clientlist
|
|
Windows::iterator win_it = m_windowlist.begin();
|
|
Windows::iterator win_it_end = m_windowlist.end();
|
|
for (; win_it != win_it_end; ++win_it) {
|
|
// add every client in this fluxboxwindow to menu
|
|
FluxboxWindow::ClientList::iterator client_it =
|
|
(*win_it)->clientList().begin();
|
|
FluxboxWindow::ClientList::iterator client_it_end =
|
|
(*win_it)->clientList().end();
|
|
for (; client_it != client_it_end; ++client_it)
|
|
menu().insert(new ClientMenuItem(*(*client_it)));
|
|
}
|
|
|
|
menu().updateMenu();
|
|
}
|
|
|
|
void Workspace::placeWindow(FluxboxWindow &win) {
|
|
|
|
bool placed = false;
|
|
|
|
// restrictions
|
|
int head = (signed) screen().getCurrHead();
|
|
int head_left = (signed) screen().maxLeft(head);
|
|
int head_right = (signed) screen().maxRight(head);
|
|
int head_top = (signed) screen().maxTop(head);
|
|
int head_bot = (signed) screen().maxBottom(head);
|
|
|
|
int place_x = head_left, place_y = head_top, change_x = 1, change_y = 1;
|
|
|
|
if (screen().getColPlacementDirection() == BScreen::BOTTOMTOP)
|
|
change_y = -1;
|
|
if (screen().getRowPlacementDirection() == BScreen::RIGHTLEFT)
|
|
change_x = -1;
|
|
|
|
int win_w = win.width() + win.fbWindow().borderWidth()*2,
|
|
win_h = win.height() + win.fbWindow().borderWidth()*2;
|
|
|
|
|
|
int test_x, test_y, curr_x, curr_y, curr_w, curr_h;
|
|
|
|
switch (screen().getPlacementPolicy()) {
|
|
case BScreen::UNDERMOUSEPLACEMENT: {
|
|
int root_x, root_y, ignore_i;
|
|
|
|
unsigned int ignore_ui;
|
|
|
|
Window ignore_w;
|
|
|
|
XQueryPointer(FbTk::App::instance()->display(),
|
|
screen().rootWindow().window(), &ignore_w,
|
|
&ignore_w, &root_x, &root_y,
|
|
&ignore_i, &ignore_i, &ignore_ui);
|
|
|
|
test_x = root_x - (win_w / 2);
|
|
test_y = root_y - (win_h / 2);
|
|
|
|
// keep the window inside the screen
|
|
|
|
if (test_x < head_left)
|
|
test_x = head_left;
|
|
|
|
if (test_x + win_w > head_right)
|
|
test_x = head_right - win_w;
|
|
|
|
if (test_y < head_top)
|
|
test_y = head_top;
|
|
|
|
if (test_y + win_h > head_bot)
|
|
test_y = head_bot - win_h;
|
|
|
|
place_x = test_x;
|
|
place_y = test_y;
|
|
|
|
placed = true;
|
|
|
|
break;
|
|
} // end case UNDERMOUSEPLACEMENT
|
|
|
|
case BScreen::ROWSMARTPLACEMENT: {
|
|
int next_x, next_y;
|
|
bool top_bot = screen().getColPlacementDirection() == BScreen::TOPBOTTOM;
|
|
bool left_right = screen().getRowPlacementDirection() == BScreen::LEFTRIGHT;
|
|
|
|
if (top_bot)
|
|
test_y = head_top;
|
|
else
|
|
test_y = head_bot - win_h;
|
|
|
|
while (!placed &&
|
|
(top_bot ? test_y + win_h <= head_bot
|
|
: test_y >= head_top)) {
|
|
|
|
if (left_right)
|
|
test_x = head_left;
|
|
else
|
|
test_x = head_right - win_w;
|
|
|
|
// The trick here is that we set it to the furthest away one,
|
|
// then the code brings it back down to the safest one that
|
|
// we can go to (i.e. the next untested area)
|
|
if (top_bot)
|
|
next_y = head_bot; // will be shrunk
|
|
else
|
|
next_y = head_top-1;
|
|
|
|
while (!placed &&
|
|
(left_right ? test_x + win_w <= head_right
|
|
: test_x >= head_left)) {
|
|
|
|
placed = true;
|
|
|
|
next_x = test_x + change_x;
|
|
|
|
Windows::iterator win_it = m_windowlist.begin();
|
|
const Windows::iterator win_it_end = m_windowlist.end();
|
|
|
|
for (; win_it != win_it_end && placed; ++win_it) {
|
|
FluxboxWindow &window = **win_it;
|
|
|
|
curr_x = window.x();
|
|
curr_y = window.y();
|
|
curr_w = window.width() + window.fbWindow().borderWidth()*2;
|
|
curr_h = window.height() + window.fbWindow().borderWidth()*2;
|
|
|
|
if (curr_x < test_x + win_w &&
|
|
curr_x + curr_w > test_x &&
|
|
curr_y < test_y + win_h &&
|
|
curr_y + curr_h > test_y) {
|
|
// this window is in the way
|
|
placed = false;
|
|
|
|
// we find the next x that we can go to (a window will be in the way
|
|
// all the way to its far side)
|
|
if (left_right) {
|
|
if (curr_x + curr_w > next_x)
|
|
next_x = curr_x + curr_w;
|
|
} else {
|
|
if (curr_x - win_w < next_x)
|
|
next_x = curr_x - win_w;
|
|
}
|
|
|
|
// but we can only go to the nearest y, since that is where the
|
|
// next time current windows in the way will change
|
|
if (top_bot) {
|
|
if (curr_y + curr_h < next_y)
|
|
next_y = curr_y + curr_h;
|
|
} else {
|
|
if (curr_y - win_h > next_y)
|
|
next_y = curr_y - win_h;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
if (placed) {
|
|
place_x = test_x;
|
|
place_y = test_y;
|
|
|
|
break;
|
|
}
|
|
|
|
test_x = next_x;
|
|
} // end while
|
|
|
|
test_y = next_y;
|
|
} // end while
|
|
|
|
break;
|
|
} // end case ROWSMARTPLACEMENT
|
|
|
|
case BScreen::COLSMARTPLACEMENT: {
|
|
int next_x, next_y;
|
|
bool top_bot = screen().getColPlacementDirection() == BScreen::TOPBOTTOM;
|
|
bool left_right = screen().getRowPlacementDirection() == BScreen::LEFTRIGHT;
|
|
|
|
if (left_right)
|
|
test_x = head_left;
|
|
else
|
|
test_x = head_right - win_w;
|
|
|
|
while (!placed &&
|
|
(left_right ? test_x + win_w <= head_right
|
|
: test_x >= head_left)) {
|
|
|
|
if (left_right)
|
|
next_x = head_right; // it will get shrunk
|
|
else
|
|
next_x = head_left-1;
|
|
|
|
if (top_bot)
|
|
test_y = head_top;
|
|
else
|
|
test_y = head_bot - win_h;
|
|
|
|
while (!placed &&
|
|
(top_bot ? test_y + win_h <= head_bot
|
|
: test_y >= head_top)) {
|
|
placed = True;
|
|
|
|
next_y = test_y + change_y;
|
|
|
|
Windows::iterator it = m_windowlist.begin();
|
|
Windows::iterator it_end = m_windowlist.end();
|
|
for (; it != it_end && placed; ++it) {
|
|
curr_x = (*it)->x();
|
|
curr_y = (*it)->y();
|
|
curr_w = (*it)->width() + (*it)->fbWindow().borderWidth()*2;
|
|
curr_h = (*it)->height() + (*it)->fbWindow().borderWidth()*2;
|
|
|
|
if (curr_x < test_x + win_w &&
|
|
curr_x + curr_w > test_x &&
|
|
curr_y < test_y + win_h &&
|
|
curr_y + curr_h > test_y) {
|
|
// this window is in the way
|
|
placed = False;
|
|
|
|
// we find the next y that we can go to (a window will be in the way
|
|
// all the way to its bottom)
|
|
if (top_bot) {
|
|
if (curr_y + curr_h > next_y)
|
|
next_y = curr_y + curr_h;
|
|
} else {
|
|
if (curr_y - win_h < next_y)
|
|
next_y = curr_y - win_h;
|
|
}
|
|
|
|
// but we can only go to the nearest x, since that is where the
|
|
// next time current windows in the way will change
|
|
if (left_right) {
|
|
if (curr_x + curr_w < next_x)
|
|
next_x = curr_x + curr_w;
|
|
} else {
|
|
if (curr_x - win_w > next_x)
|
|
next_x = curr_x - win_w;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (placed) {
|
|
place_x = test_x;
|
|
place_y = test_y;
|
|
}
|
|
|
|
test_y = next_y;
|
|
} // end while
|
|
|
|
test_x = next_x;
|
|
} // end while
|
|
|
|
break;
|
|
} // end COLSMARTPLACEMENT
|
|
|
|
}
|
|
|
|
// cascade placement or smart placement failed
|
|
if (! placed) {
|
|
|
|
if ((m_cascade_x[head] > ((head_left + head_right) / 2)) ||
|
|
(m_cascade_y[head] > ((head_top + head_bot) / 2))) {
|
|
m_cascade_x[head] = head_left + 32;
|
|
m_cascade_y[head] = head_top + 32;
|
|
}
|
|
|
|
place_x = m_cascade_x[head];
|
|
place_y = m_cascade_y[head];
|
|
|
|
// just one borderwidth, so they can share a borderwidth (looks better)
|
|
int titlebar_height = win.titlebarHeight() + win.fbWindow().borderWidth();
|
|
if (titlebar_height < 4) // make sure it is not insignificant
|
|
titlebar_height = 32;
|
|
m_cascade_x[head] += titlebar_height;
|
|
m_cascade_y[head] += titlebar_height;
|
|
}
|
|
|
|
if (place_x + win_w > head_right)
|
|
place_x = (head_right - win_w) / 2;
|
|
if (place_y + win_h > head_bot)
|
|
place_y = (head_bot - win_h) / 2;
|
|
|
|
|
|
win.moveResize(place_x, place_y, win.width(), win.height());
|
|
}
|