ede/pekwm/Client.hh

414 lines
13 KiB
C++
Raw Normal View History

//
// Client.hh for pekwm
// Copyright © 2003-2009 Claes Nästén <me{@}pekdon{.}net>
//
// client.hh for aewm++
// Copyright (C) 2002 Frank Hale <frankhale@yahoo.com>
// http://sapphire.sourceforge.net/
//
// This program is licensed under the GNU GPL.
// See the LICENSE file for more information.
//
#ifndef _CLIENT_HH_
#define _CLIENT_HH_
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif // HAVE_CONFIG_H
#include "pekwm.hh"
#include "Observer.hh"
#include "PTexturePlain.hh"
#include "PDecor.hh"
class PScreen;
class Strut;
class PWinObj;
class ClassHint;
class AutoProperty;
class Frame;
#include <string>
extern "C" {
#include <X11/Xutil.h>
}
class LayerObservation : public Observation {
public:
LayerObservation(enum Layer _layer) : layer(_layer) { };
virtual ~LayerObservation(void) { };
public:
const enum Layer layer; /**< Layer client changed to. */
};
class Client : public PWinObj, public Observer
{
// FIXME: This relationship should end as soon as possible, but I need to
// figure out a good way of sharing. :)
friend class Frame;
public: // Public Member Functions
struct MwmHints {
ulong flags;
ulong functions;
ulong decorations;
};
enum {
MWM_HINTS_FUNCTIONS = (1L << 0),
MWM_HINTS_DECORATIONS = (1L << 1),
MWM_HINTS_NUM = 3
};
enum {
MWM_FUNC_ALL = (1L << 0),
MWM_FUNC_RESIZE = (1L << 1),
MWM_FUNC_MOVE = (1L << 2),
MWM_FUNC_ICONIFY = (1L << 3),
MWM_FUNC_MAXIMIZE = (1L << 4),
MWM_FUNC_CLOSE = (1L << 5)
};
enum {
MWM_DECOR_ALL = (1L << 0),
MWM_DECOR_BORDER = (1L << 1),
MWM_DECOR_HANDLE = (1L << 2),
MWM_DECOR_TITLE = (1L << 3),
MWM_DECOR_MENU = (1L << 4),
MWM_DECOR_ICONIFY = (1L << 5),
MWM_DECOR_MAXIMIZE = (1L << 6)
};
Client(Window new_client, bool is_new = false);
virtual ~Client(void);
// START - PWinObj interface.
virtual void mapWindow(void);
virtual void unmapWindow(void);
virtual void iconify(void);
virtual void stick(void);
virtual void move(int x, int y);
virtual void resize(uint width, uint height);
virtual void moveResize(int x, int y, uint width, uint height);
virtual void setWorkspace(uint workspace);
virtual void giveInputFocus(void);
virtual void reparent(PWinObj *parent, int x, int y);
virtual ActionEvent *handleButtonPress(XButtonEvent *ev) {
if (_parent) { return _parent->handleButtonPress(ev); }
return 0;
}
virtual ActionEvent *handleButtonRelease(XButtonEvent *ev) {
if (_parent) { return _parent->handleButtonRelease(ev); }
return 0;
}
virtual ActionEvent *handleMapRequest(XMapRequestEvent *ev);
virtual ActionEvent *handleUnmapEvent(XUnmapEvent *ev);
// END - PWinObj interface.
// START - Observer interface.
virtual void notify(Observable *observable, Observation *observation);
// END - Observer interface.
static Client *findClient(Window win);
static Client *findClientFromWindow(Window win);
static Client *findClientFromHint(const ClassHint *class_hint);
static Client *findClientFromID(uint id);
static void findFamilyFromWindow(std::list<Client*> &client_list, Window win);
static void mapOrUnmapTransients(Window win, bool hide);
// START - Iterators
static uint client_size(void) { return _client_list.size(); }
static std::list<Client*>::iterator client_begin(void) {
return _client_list.begin();
}
static std::list<Client*>::iterator client_end(void) {
return _client_list.end();
}
static std::list<Client*>::reverse_iterator client_rbegin(void) {
return _client_list.rbegin();
}
static std::list<Client*>::reverse_iterator client_rend(void) {
return _client_list.rend();
}
unsigned int transient_size(void) { return _transient_clients.size(); }
std::list<Client*>::iterator transient_begin(void) {
return _transient_clients.begin(); }
std::list<Client*>::iterator transient_end(void) {
return _transient_clients.end(); }
// END - Iterators
bool validate(void);
inline uint getClientID(void) { return _id; }
/**< Return title item for client name. */
inline PDecor::TitleItem *getTitle(void) { return &_title; }
/**< Return title item for client icon name. */
inline PDecor::TitleItem *getIconName(void) { return &_icon_name; }
inline const ClassHint* getClassHint(void) const { return _class_hint; }
bool isTransient(void) const { return _transient_window != None; }
Client *getTransientClient(void) const { return _transient; }
Window getTransientClientWindow(void) const { return _transient_window; }
void findAndRaiseIfTransient(void);
inline XSizeHints* getXSizeHints(void) const { return _size; }
bool isViewable(void);
bool setPUPosition(void);
inline bool hasTitlebar(void) const { return (_state.decor&DECOR_TITLEBAR); }
inline bool hasBorder(void) const { return (_state.decor&DECOR_BORDER); }
inline bool isShaped(void) const { return _shaped; }
inline bool hasStrut(void) const { return (_strut); }
Strut *getStrut(void) const { return _strut; }
PTexture *getIcon(void) const { return _icon; }
/** Return PID of client. */
long getPid(void) const { return _pid; }
/** Return true if client is remote. */
bool isRemote(void) const { return _is_remote; }
// State accessors
inline bool isMaximizedVert(void) const { return _state.maximized_vert; }
inline bool isMaximizedHorz(void) const { return _state.maximized_horz; }
inline bool isShaded(void) const { return _state.shaded; }
inline bool isFullscreen(void) const { return _state.fullscreen; }
inline bool isPlaced(void) const { return _state.placed; }
inline uint getInitialFrameOrder(void) const { return _state.initial_frame_order; }
inline uint getSkip(void) const { return _state.skip; }
inline bool isSkip(Skip skip) const { return (_state.skip&skip); }
inline uint getDecorState(void) const { return _state.decor; }
inline bool isCfgDeny(uint deny) { return (_state.cfg_deny&deny); }
inline bool allowMove(void) const { return _actions.move; }
inline bool allowResize(void) const { return _actions.resize; }
inline bool allowMinimize(void) const { return _actions.minimize; }
inline bool allowShade(void) const { return _actions.shade; }
inline bool allowStick(void) const { return _actions.stick; }
inline bool allowMaximizeHorz(void) const { return _actions.maximize_horz; }
inline bool allowMaximizeVert(void) const { return _actions.maximize_vert; }
inline bool allowFullscreen(void) const { return _actions.fullscreen; }
inline bool allowChangeDesktop(void) const { return _actions.change_desktop; }
inline bool allowClose(void) const { return _actions.close; }
inline bool isAlive(void) const { return _alive; }
inline bool isMarked(void) const { return _marked; }
// We have this public so that we can reload button actions.
void grabButtons(void);
void setStateCfgDeny(StateAction sa, uint deny);
inline void setStateMarked(StateAction sa) {
if (ActionUtil::needToggle(sa, _marked)) {
_marked = !_marked;
if (_marked) {
_title.infoAdd(PDecor::TitleItem::INFO_MARKED);
} else {
_title.infoRemove(PDecor::TitleItem::INFO_MARKED);
}
_title.updateVisible();
}
}
// toggles
void alwaysOnTop(bool top);
void alwaysBelow(bool bottom);
void setSkip(uint skip);
inline void setStateSkip(StateAction sa, Skip skip) {
if ((isSkip(skip) && (sa == STATE_SET)) || (! isSkip(skip) && (sa == STATE_UNSET))) {
return;
}
_state.skip ^= skip;
}
void setStateDemandsAttention(StateAction sa, bool attention);
inline void setTitlebar(bool titlebar) {
if (titlebar) {
_state.decor |= DECOR_TITLEBAR;
} else {
_state.decor &= ~DECOR_TITLEBAR;
}
}
inline void setBorder(bool border) {
if (border) {
_state.decor |= DECOR_BORDER;
} else {
_state.decor &= ~DECOR_BORDER;
}
}
/** Set shaped flag on Client. */
inline void setShaped(bool shaped) {
_shaped = shaped;
}
void close(void);
void kill(void);
// Event handlers below - Used by WindowManager
void handleDestroyEvent(XDestroyWindowEvent *ev);
void handleColormapChange(XColormapEvent *ev);
inline bool setConfigureRequestLock(bool lock) {
bool old_lock = _cfg_request_lock;
_cfg_request_lock = lock;
return old_lock;
}
void configureRequestSend(void);
void sendTakeFocusMessage(void);
bool getAspectSize(uint *r_w, uint *r_h, uint w, uint h);
bool getIncSize(uint *r_w, uint *r_h, uint w, uint h, bool incr=false);
bool getEwmhStates(NetWMStates &win_states);
void updateEwmhStates(void);
void getWMNormalHints(void);
void getWMProtocols(void);
void getTransientForHint(void);
void getStrutHint(void);
void readName(void);
void readIconName(void);
void removeStrutHint(void);
long getPekwmFrameOrder(void);
void setPekwmFrameOrder(long num);
bool getPekwmFrameActive(void);
void setPekwmFrameActive(bool active);
static void setClientEnvironment(Client *client);
AutoProperty* readAutoprops(uint type = 0);
private:
bool getAndUpdateWindowAttributes(void);
void findOrCreateFrame(AutoProperty *autoproperty);
bool findTaggedFrame(void);
bool findPreviousFrame(void);
bool findAutoGroupFrame(AutoProperty *autoproperty);
void setInitialState(void);
void setMappedStateAndFocus(bool is_new, AutoProperty *autoproperty);
bool titleApplyRule(std::wstring &wtitle);
uint titleFindID(std::wstring &wtitle);
void setWmState(ulong state);
long getWmState(void);
int sendXMessage(Window window, Atom atom, long mask,
long v1 = 0l, long v2 = 0l, long v3 = 0l,
long v4 = 0l, long v5 = 0l);
MwmHints* getMwmHints(Window w);
// these are used by frame
inline void setMaximizedVert(bool m) { _state.maximized_vert = m; }
inline void setMaximizedHorz(bool m) { _state.maximized_horz = m; }
inline void setShade(bool s) { _state.shaded = s; }
inline void setFullscreen(bool f) { _state.fullscreen = f; }
inline void setFocusable(bool f) { _focusable = f; }
// Grabs button with Caps,Num and so on
void grabButton(int button, int mod, int mask, Window win, Cursor curs);
void readHints(void);
ulong readWmHints(void);
void readClassRoleHints(void);
void readEwmhHints(void);
void readMwmHints(void);
void readPekwmHints(void);
void readIcon(void);
void applyAutoprops(AutoProperty *ap);
void applyActionAccessMask(uint mask, bool value);
void readClientPid(void);
void readClientRemote(void);
static uint findClientID(void);
static void returnClientID(uint id);
private: // Private Member Variables
uint _id; //<! Unique ID of the Client.
XSizeHints *_size;
Colormap _cmap;
Client *_transient; /**< Client for which this client is transient for */
Window _transient_window;
std::list<Client*> _transient_clients; /**< List of transient clients. */
Strut *_strut;
PDecor::TitleItem _title; /**< Name of the client. */
PDecor::TitleItem _icon_name; /**< Name of the client when iconified. */
PTextureImage *_icon;
long _pid; /**< _NET_WM_PID of the client, only valid if is_remote is false. */
bool _is_remote; /**< Boolean flag */
ClassHint *_class_hint;
bool _alive, _marked;
bool _send_focus_message, _send_close_message, _wm_hints_input;
bool _cfg_request_lock;
bool _shaped;
bool _extended_net_name;
class State {
public:
State(void)
: maximized_vert(false), maximized_horz(false), shaded(false), fullscreen(false),
placed(false), initial_frame_order(0),
skip(0), decor(DECOR_TITLEBAR|DECOR_BORDER),
cfg_deny(CFG_DENY_NO), demands_attention(true) { }
~State(void) { }
bool maximized_vert, maximized_horz;
bool shaded;
bool fullscreen;
// pekwm states
bool placed;
uint initial_frame_order; /**< Initial frame position */
uint skip, decor, cfg_deny;
bool demands_attention; /**< If true, the client requires attention from the user. */
} _state;
class Actions {
public:
Actions(void) : move(true), resize(true), minimize(true),
shade(true), stick(true), maximize_horz(true),
maximize_vert(true), fullscreen(true),
change_desktop(true), close(true) { }
~Actions(void) { }
bool move;
bool resize;
bool minimize; // iconify
bool shade;
bool stick;
bool maximize_horz;
bool maximize_vert;
bool fullscreen;
bool change_desktop; // workspace
bool close;
} _actions;
static std::list<Client*> _client_list; //!< List of all Clients.
static std::vector<uint> _clientid_list; //!< List of free Client IDs.
};
#endif // _CLIENT_HH_