fluxbox/src/Workspace.cc
2004-03-21 09:00:25 +00:00

668 lines
21 KiB
C++

// Workspace.cc for Fluxbox
// Copyright (c) 2001 - 2004 Henrik Kinnunen (fluxgen[at]users.sourceforge.net)
//
// 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: Workspace.cc,v 1.95 2004/03/21 09:00:25 rathnor Exp $
#include "Workspace.hh"
#include "I18n.hh"
#include "fluxbox.hh"
#include "Screen.hh"
#include "Window.hh"
#include "WinClient.hh"
#include "FbWinFrame.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>
#include <cstdio>
#include <cstring>
#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() {
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();
}
}
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 throu 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
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().update();
}
void Workspace::setName(const std::string &name) {
if (!name.empty()) {
m_name = name;
} else { //if name == 0 then set default name from nls
char tname[128];
sprintf(tname, I18n::instance()->
getMessage(FBNLS::WorkspaceSet,
FBNLS::WorkspaceDefaultNameFormat,
"Workspace %d"), m_id + 1); //m_id starts at 0
m_name = tname;
}
screen().updateWorkspaceNamesAtom();
menu().setLabel(m_name.c_str());
menu().update();
}
/**
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().update();
}
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 > head_right)
test_x = head_right;
if (test_y < head_top)
test_y = head_top;
if (test_y > head_bot)
test_y = head_bot;
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());
}