mirror/ede
1
0
Fork 0
mirror of https://github.com/edeproject/ede.git synced 2023-08-10 21:13:03 +03:00
Code Issues Projects Releases Wiki Activity
7bb1048773
ede/edewm/Frame.cpp
Sanel Zukan 7513426131 Copying wm from old ede
2009-02-20 13:05:43 +00:00

1675 lines
37 KiB
C++
Raw Blame History

// Frame.cpp
//#define TITLE_H 20
#define TITLE_H title->h()
#include "config.h"
#include "Frame.h"
#include "Windowmanager.h"
#include "Desktop.h"
#include "Winhints.h"
#include "Netwm.h"
#include "Icon.h"
#include "Theme.h"
#include "debug.h"
#include <string.h>
#include <stdio.h>
#include <efltk/fl_draw.h>
#include <efltk/Fl_Tooltip.h>
static const int XEventMask =
ExposureMask
|StructureNotifyMask|VisibilityChangeMask
|KeyPressMask|KeyReleaseMask|KeymapStateMask|FocusChangeMask
|ButtonPressMask|ButtonReleaseMask
|EnterWindowMask|LeaveWindowMask
|PointerMotionMask|SubstructureRedirectMask|SubstructureNotifyMask;
extern bool grab();
extern void grab_cursor(bool grab);
extern Fl_Window* Root;
extern int title_active_color, title_active_color_text;
extern int title_normal_color, title_normal_color_text;
Frame* Frame::active_ = 0;
// Resizes opaque (draws everything), if this set to true
bool Frame::do_opaque = false;
bool Frame::focus_follows_mouse = false;
bool Frame::animate = true;
int Frame::animate_speed = 15;
static int px,py,pw,ph;
static GC invertGc=0;
static void draw_current_rect() { XDrawRectangle(fl_display, RootWindow(fl_display, fl_screen), invertGc, px, py, pw, ph); }
void clear_overlay() { if (pw > 0) { draw_current_rect(); pw = 0; } }
void draw_overlay(int x, int y, int w, int h) {
if(!invertGc) {
XGCValues v;
v.subwindow_mode = IncludeInferiors;
v.foreground = 0xffffffff;
v.function = GXxor;
v.line_width = 2;
v.graphics_exposures = False;
int mask = GCForeground|GCSubwindowMode|GCFunction|GCLineWidth|GCGraphicsExposures;
invertGc = XCreateGC(fl_display, RootWindow(fl_display, fl_screen), mask, &v);
}
if (w < 0) {x += w; w = -w;} else if (!w) w = 1;
if (h < 0) {y += h; h = -h;} else if (!h) h = 1;
if (pw > 0) {
if (x==px && y==py && w==pw && h==ph) return;
draw_current_rect();
}
px = x; py = y; pw = w; ph = h;
draw_current_rect();
}
static void animate(int fx, int fy, int fw, int fh, int tx, int ty, int tw, int th)
{
# undef max
# define max(a,b) (a) > (b) ? (a) : (b)
double max_steps = max( (tw-fw), (th-fh) );
double min_steps = max( (fw-tw), (fh-th) );
double steps = max(max_steps, min_steps);
steps/=Frame::animate_speed;
double sx = max( ((double)(fx-tx)/steps), ((double)(tx-fx)/steps) );
double sy = max( ((double)(fy-ty)/steps), ((double)(ty-fy)/steps) );
double sw = max( ((double)(fw-tw)/steps), ((double)(tw-fw)/steps) );
double sh = max( ((double)(fh-th)/steps), ((double)(th-fh)/steps) );
int xinc = fx < tx ? 1 : -1;
int yinc = fy < ty ? 1 : -1;
int winc = fw < tw ? 1 : -1;
int hinc = fh < th ? 1 : -1;
double rx=fx,ry=fy,rw=fw,rh=fh;
XGrabServer(fl_display);
while(steps-- > 0) {
rx+=(sx*xinc);
ry+=(sy*yinc);
rw+=(sw*winc);
rh+=(sh*hinc);
draw_overlay((int)rx, (int)ry, (int)rw, (int)rh);
Fl::sleep(10);
XFlush(fl_display);
}
clear_overlay();
XUngrabServer(fl_display);
}
// The constructor is by far the most complex part, as it collects
// all the scattered pieces of information about the window that
// X has and uses them to initialize the structure, position the
// window, and then finally create it.
int dont_set_event_mask = 0; // used by FrameWindow
// "existing" is a pointer to an XWindowAttributes structure that is
// passed for an already-existing window when the window manager is
// starting up. If so we don't want to alter the state, size, or
// position. If null than this is a MapRequest of a new window.
Frame::Frame(Window window, XWindowAttributes* existing)
: Fl_Window(0,0),
window_(window),
frame_flags_(0), state_flags_(0), decor_flags_(0), func_flags_(0),
transient_for_xid(None),
transient_for_(0),
revert_to(active_),
colormapWinCount(0)
{
wintype = TYPE_NORMAL;
maximized = false;
offset_x = offset_y = offset_w = offset_h = 0;
strut_ = 0;
icon_ = 0;
mwm_hints = 0;
wm_hints = 0;
size_hints = XAllocSizeHints();
begin();
title = new Titlebar(0, 0, 100, Titlebar::default_height, _("Untitled"));
title->align(FL_ALIGN_LEFT|FL_ALIGN_INSIDE);
title->label_color((Fl_Color)title_normal_color_text);
title->color((Fl_Color)title_normal_color);
title->label_font(label_font()->bold());
end();
bool autoplace = ICCCM::size_hints(this);
// do this asap so we don't miss any events...
if(!dont_set_event_mask) {
XSelectInput(fl_display, window_, VisibilityChangeMask | ColormapChangeMask | PropertyChangeMask | FocusChangeMask );
}
XGetTransientForHint(fl_display, window_, &transient_for_xid);
getColormaps();
get_protocols();
MWM::get_hints(this);
MWM::update_hints(this);
get_wm_hints();
update_wm_hints();
NETWM::get_strut(this);
if(NETWM::get_window_type(this)) {
// This call overwrites MWM hints!
get_funcs_from_type();
} else if(transient_for_xid) {// && wintype==TYPE_NORMAL && decor_flag(BORDER)) {
//title->h(15); title->label(0);
if(decor_flag(BORDER) || decor_flag(THIN_BORDER)) {
clear_decor_flag(BORDER);
set_decor_flag(THIN_BORDER);
wintype = TYPE_DIALOG;
get_funcs_from_type();
}
}
getLabel();
{
XWindowAttributes attr;
if(existing)
attr = *existing;
else {
// put in some legal values in case XGetWindowAttributes fails:
attr.x = attr.y = 0;
attr.width = attr.height = 100;
attr.colormap = fl_colormap;
attr.border_width = 0;
XGetWindowAttributes(fl_display, window, &attr);
}
int W=attr.width, H=attr.height;
ICCCM::get_size(this, W, H);
resize(attr.x, attr.y, W, H);
restore_x = attr.x;
restore_y = attr.y;
restore_w = attr.width;
restore_h = attr.height;
colormap = attr.colormap;
}
// Get icon & mask:
icon_ = new Icon(wm_hints);
switch(getIntProperty(_XA_WM_STATE, _XA_WM_STATE, 0))
{
case NormalState:
state_ = NORMAL; break;
case IconicState:
state_ = ICONIC; break;
// X also defines obsolete values ZoomState and InactiveState
default:
if(wm_hints && (wm_hints->flags&StateHint) && wm_hints->initial_state==IconicState)
state_ = ICONIC;
else
state_ = NORMAL;
}
fix_transient_for();
if(transient_for()) {
DBG("WIN %lx is transient for %lx", window_, transient_for()->window());
// Get state from parent
if(state_ == NORMAL)
state_ = transient_for()->state_;
// And put it on same desktop
desktop_ = transient_for()->desktop();
} else {
// get the desktop from either NET or GNOME (NET takes preference):
int p = getDesktop();
if (p > 0 && p <= 8)
desktop_ = Desktop::desktop(p);
DBG("WIN %lx belongs to %d", window_, desktop_?desktop_->number():-2);
}
send_desktop();
// some Motif programs assumme this will force the size to conform :-(
if(w() < size_hints->min_width || h() < size_hints->min_height) {
if(w() < size_hints->min_width) w(size_hints->min_width);
if(h() < size_hints->min_height) h(size_hints->min_height);
XResizeWindow(fl_display, window_, w(), h());
}
updateBorder();
if (autoplace && !existing && !(transient_for() && (x() || y()))) {
// autoplacement (stupid version for now)
x(root->x()+(root->w()-w())/2);
y(root->y()+(root->h()-h())/2);
// move it until it does not hide any existing windows:
const int delta = 20;//TITLE_WIDTH+LEFT;
for(uint n=0; n<map_order.size(); n++) {
Frame *f = map_order[n];
if(f==this) continue;
if (f->x()+delta > x() && f->y()+delta > y() &&
f->x()+f->w()-delta < x()+w() && f->y()+f->h()-delta < y()+h()) {
x(max(x(),f->x()+delta));
y(max(y(),f->y()+delta));
f = this;
}
}
}
// move window so contents and border are visible:
x(force_x_onscreen(x(), w()));
y(force_y_onscreen(y(), h()));
// FLTK thinks its override window, so it doesnt send any X junk to wm
set_override();
// Create Fl_X class and xid
create();
const int mask =
CWBitGravity|
CWBorderPixel|
CWColormap|
CWEventMask|
CWBackPixel|
CWOverrideRedirect;
XSetWindowAttributes sattr;
sattr.bit_gravity = NorthWestGravity;
sattr.event_mask = XEventMask;
sattr.colormap = fl_colormap;
sattr.border_pixel = fl_xpixel(FL_BLACK);
sattr.override_redirect = 0;
sattr.background_pixel = fl_xpixel(FL_GRAY);
XChangeWindowAttributes(fl_display, fl_xid(this), mask, &sattr);
send_state_property();
if(!dont_set_event_mask)
XAddToSaveSet(fl_display, window_);
if(existing)
set_state_flag(IGNORE_UNMAP);
// Reparent window to frames
XReparentWindow(fl_display, window_, fl_xid(this), offset_x, offset_y);
XSetWindowBorderWidth(fl_display, window_, 0);
XGrabButton(fl_display, AnyButton, AnyModifier, window_, False,
ButtonPressMask, GrabModeSync, GrabModeAsync, None, None);
if(state_ == NORMAL) {
XMapWindow(fl_display, window_);
if(decor_flag(TITLEBAR)) title->show();
show();
// many apps expect this even if window size unchanged
send_configurenotify();
if(!existing)
activate_if_transient();
}
#ifdef SHAPE
XShapeSelectInput(fl_display, window_, ShapeNotifyMask);
if(get_shape()) {
clear_decor_flag(BORDER|THIN_BORDER);
XShapeCombineShape(fl_display, fl_xid(this), ShapeBounding,
0, 0, window_,
ShapeBounding, ShapeSet);
}
#endif
map_order.append(this);
stack_order.append(this);
WindowManager::update_client_list();
if(strut()) root->update_workarea(true);
}
extern bool wm_shutdown;
// destructor
// The destructor is called on DestroyNotify, so I don't have to do anything
// to the contained window, which is already been destroyed.
Frame::~Frame()
{
}
void Frame::destroy_frame()
{
if(shown()) {
XUnmapWindow(fl_display, fl_xid(this));
XUnmapWindow(fl_display, window_);
if(title->shown()) XUnmapWindow(fl_display, fl_xid(title));
}
// It is possible for the frame to be destroyed while the menu is
// popped-up, and the menu will still contain a pointer to it. To
// fix this the menu checks the state_ location for a legal and
// non-withdrawn state value before doing anything. This should
// be reliable unless something reallocates the memory and writes
// a legal state value to this location:
state_ = UNMAPPED;
// fix fltk bug:
Fl::focus_ = 0;
for(uint n=0; n<map_order.size(); n++) {
Frame *f = map_order[n];
if(f->transient_for_ == this) f->transient_for_ = transient_for_;
if(f->revert_to == this) f->revert_to = revert_to;
}
throw_focus(1);
if(colormapWinCount) {
XFree((char *)colormapWindows);
delete[] window_Colormaps;
}
if(mwm_hints) XFree((char *)mwm_hints);
if(wm_hints) XFree((char *)wm_hints);
if(size_hints) XFree((char *)size_hints);
if(icon_) {
delete icon_;
icon_ = 0;
}
// remove any pointers to this:
if(!wm_shutdown) {
stack_order.remove(this);
map_order.remove(this);
WindowManager::update_client_list();
}
if(strut_)
{
delete strut_;
strut_=0;
root->update_workarea(true);
}
if(grab()) grab_cursor(false);
remove_list.append(this);
Fl::awake();
}
bool Frame::get_shape()
{
#ifdef SHAPE
shaped = 0;
int xws, yws, xbs, ybs;
unsigned wws, hws, wbs, hbs;
Bool boundingShaped, clipShaped;
XShapeQueryExtents(fl_display, window_,
&boundingShaped, &xws, &yws, &wws, &hws,
&clipShaped, &xbs, &ybs, &wbs, &hbs);
return (shaped = boundingShaped);
#else
return false;
#endif
}
void Frame::get_funcs_from_type()
{
DBG("get_funcs_from_type() = %d", wintype);
switch(wintype) {
case TYPE_DESKTOP:
case TYPE_DOCK:
case TYPE_SPLASH:
desktop_ = 0;
clear_func_flags();
clear_decor_flags();
if(wintype == TYPE_DOCK)
set_frame_flag(SKIP_LIST|SKIP_FOCUS);
else
set_frame_flag(SKIP_LIST);
break;
case TYPE_TOOLBAR:
case TYPE_MENU:
clear_decor_flags();
set_frame_flag(SKIP_LIST|SKIP_FOCUS|NO_FOCUS);
break;
case TYPE_DIALOG:
case TYPE_UTIL:
title->h(Titlebar::default_height);
clear_decor_flag(BORDER);
set_decor_flag(THIN_BORDER);
break;
case TYPE_NORMAL:
default:
// Dont do anything for NORMAL and UNKNOWN types...
break;
};
}
void Frame::settings_changed_all()
{
for(uint n=0; n<map_order.size(); n++) {
Frame *f = map_order[n];
f->settings_changed();
}
XFlush(fl_display);
}
void Frame::settings_changed()
{
if(title && title->shown())
title->setting_changed();
if(!desktop() || desktop()==Desktop::current()) {
if(title && title->shown()) {
XClearWindow(fl_display, fl_xid(title)); //expose title
redraw(); //Set damage bits
draw(); //FORCE DRAW!
}
}
}
// modify the passed X & W to a legal horizontal window position
// Note (by V.): Previous code preserved the window dimensions so that the
// window middle was centered on screen
// I believe that window top left corner should remain visible, so that
// user can resize window
int Frame::force_x_onscreen(int X, int W)
{
if(X<root->x()) X=root->x();
// if(X+W > root->x()+root->w()) X=root->x()+root->w()-W;
return X;
}
// modify the passed Y & H to a legal vertical window position:
int Frame::force_y_onscreen(int Y, int H)
{
if(Y<root->y()) Y=root->y();
// if(Y+H > root->y()+root->h()) Y=root->y()+root->h()-H;
return Y;
}
int Frame::getDesktop()
{
if(wintype == TYPE_DESKTOP ||
wintype == TYPE_DOCK ||
wintype == TYPE_SPLASH ) {
set_frame_flag(STICKY);
return -2;
}
int ret=0;
unsigned long desk;
desk = getIntProperty(_XA_NET_WM_DESKTOP, XA_CARDINAL, 100000, &ret);
if(ret!=Success || desk==100000) {
clear_frame_flag(STICKY);
return Desktop::current_num();
}
if(desk==0xFFFFFFFF || desk==0xFFFFFFFE) {
desktop_ = 0;
set_frame_flag(STICKY);
DBG("getDesktop() returns 0xFFFFFFFF");
return -2;
}
if(desk>=0) {
clear_frame_flag(STICKY);
desk++;
}
DBG("getDesktop() returns %ld", desk);
return desk;
}
void Frame::getLabel(bool del, Atom from_atom)
{
char *newname=0;
if(!del)
{
if(from_atom==_XA_NET_WM_NAME || from_atom==0)
newname = NETWM::get_title(this);
if((from_atom==XA_WM_NAME||from_atom==0) && !newname)
newname = ICCCM::get_title(this);
} else {
label(0);
}
if(newname) {
// since many window managers print a default label when none is
// given, many programs send spaces to make a blank label. Detect
// this and make it really be blank:
char* c = newname;
while(*c == ' ') c++;
if(!*c) {
XFree(newname);
newname = 0;
}
}
if(newname) {
label(newname);
XFree(newname);
}
title->layout();
title->redraw();
}
void Frame::getColormaps(void)
{
if (colormapWinCount) {
XFree((char *)colormapWindows);
delete[] window_Colormaps;
}
unsigned long n;
Window* cw = (Window*)getProperty(_XA_WM_COLORMAP_WINDOWS, XA_WINDOW, &n);
if (cw) {
colormapWinCount = n;
colormapWindows = cw;
window_Colormaps = new Colormap[n];
for(unsigned int i = 0; i < n; ++i) {
if (cw[i] == window_) {
window_Colormaps[i] = colormap;
} else {
XWindowAttributes attr;
XSelectInput(fl_display, cw[i], ColormapChangeMask);
XGetWindowAttributes(fl_display, cw[i], &attr);
window_Colormaps[i] = attr.colormap;
}
}
} else {
colormapWinCount = 0;
}
}
void Frame::installColormap() const
{
for (int i = colormapWinCount; i--;)
if (colormapWindows[i] != window_ && window_Colormaps[i])
XInstallColormap(fl_display, window_Colormaps[i]);
if (colormap)
XInstallColormap(fl_display, colormap);
}
// figure out transient_for(), based on the windows that exist, the
// transient_for and group attributes, etc:
void Frame::fix_transient_for()
{
Frame* p = 0;
if(transient_for_xid)
{
p = root->find_by_wid(transient_for_xid);
for(Frame* q = p; q; q = q->transient_for_) {
if(q == this) {
p = 0;
break;
}
}
}
transient_for_ = p;
}
int Frame::is_transient_for(const Frame* f) const
{
if(f) {
for (Frame* p = transient_for(); p!=0; p = p->transient_for())
if(p == f)
return 1;
}
return 0;
}
// When a program maps or raises a window, this is called. It guesses
// if this window is in fact a modal window for the currently active
// window and if so transfers the active state to this:
// This also activates new main windows automatically
bool Frame::activate_if_transient()
{
if(!transient_for() || is_transient_for(active_)) {
return activate();
}
return false;
}
bool Frame::activate()
{
DBG("Frame::activate()");
// see if a modal & newer window is up:
//for(uint n=map_order.size(); n--;)
for(uint n=map_order.size(); n--;)
{
Frame *c = map_order[n];
if(c->state()!=NORMAL) continue;
if(c->frame_flag(MODAL) && c->transient_for()==this)
if(c->activate())
return true;
}
// ignore invisible windows:
if(state() != NORMAL) return 0;
// always put in the colormap:
installColormap();
// skip windows that don't want focus:
if(frame_flag(NO_FOCUS)) return false;
// set this even if we think it already has it, this seems to fix
// bugs with Motif popups:
XSetInputFocus(fl_display, window_, RevertToPointerRoot, fl_event_time);
// Change active window
if(active_ != this) {
if(active_) active_->deactivate();
active_ = this;
//Update titlebar
title->color((Fl_Color)title_active_color);
title->label_color((Fl_Color)title_active_color_text);
title->redraw();
XSetInputFocus(fl_display, window_, RevertToPointerRoot, fl_event_time);
NETWM::set_active_window(window_);
//And last thing is focus
if(frame_flag(TAKE_FOCUS_PRT))
sendMessage(_XA_WM_PROTOCOLS, _XA_WM_TAKE_FOCUS);
}
return true;
}
// this private function should only be called by constructor and if
// the window is active():
void Frame::deactivate()
{
title->color((Fl_Color)title_normal_color);
title->label_color((Fl_Color)title_normal_color_text);
title->redraw();
}
// After the XGrabButton, the main loop will get the mouse clicks, and
// it will call here when it gets them:
void Frame::content_click()
{
activate();
if(wintype==TYPE_DOCK || wintype==TYPE_DESKTOP) {
XAllowEvents(fl_display, ReplayPointer, CurrentTime);
return;
}
if(fl_xevent.xbutton.button == 1) raise();
if(fl_xevent.xbutton.button == 1 && Fl::get_key_state(FL_Alt_L)) {
int mx = Fl::event_x_root()-x();
int my = Fl::event_y_root()-y();
int ny,nx;
if(!Frame::do_opaque) {
XGrabServer(fl_display);
}
grab_cursor(true);
bool grabbing=true;
while(grabbing)
{
Fl::wait();
nx = Fl::event_x_root()-mx;
ny = Fl::event_y_root()-my;
handle_move(nx, ny);
if( !Fl::get_key_state(FL_Alt_L) || !Fl::event_state(FL_BUTTON1) )
grabbing=false;
}
if(!Frame::do_opaque) {
XUngrabServer(fl_display);
clear_overlay();
set_size(nx, ny, w(), h());
}
grab_cursor(false);
}
XAllowEvents(fl_display, ReplayPointer, CurrentTime);
}
// get rid of the focus by giving it to somebody, if possible,
// but not to workpanel
void Frame::throw_focus(int destructor)
{
if(!active()) return;
DBG("Frame::throw_focus(%d)", destructor);
if(!destructor) deactivate();
active_ = 0;
bool is_active;
for(uint i = stack_order.size(); --i;)
{
Frame *f = stack_order[i];
if(f != 0 && f != this && f->window_type() != TYPE_DOCK)
{
is_active = f->activate();
if(is_active)
f->raise();
return;
}
}
}
// change the state of the window (this is a private function and
// it ignores the transient-for or desktop information):
void Frame::state(short newstate)
{
short oldstate = state();
if (newstate == oldstate) return;
state_ = newstate;
DBG("Frame(%s)::state(%d -> %d)", label().c_str(), oldstate, newstate);
switch (newstate) {
case UNMAPPED:
XRemoveFromSaveSet(fl_display, window_);
case OTHER_DESKTOP:
set_state_flag(IGNORE_UNMAP);
XUnmapWindow(fl_display, fl_xid(this));
XUnmapWindow(fl_display, window_);
title->hide();
break;
case ICONIC:
set_state_flag(ICONIC);
XUnmapWindow(fl_display, fl_xid(this));
XUnmapWindow(fl_display, window_);
title->hide();
break;
case NORMAL: {
int desktop = getDesktop();
if(desktop<0 || (desktop==Desktop::current_num()) ) {
if(oldstate == UNMAPPED) XAddToSaveSet(fl_display, window_);
XMapWindow(fl_display, window_);
if(decor_flag(TITLEBAR)) title->show();
show();
clear_state_flag(IGNORE_UNMAP);
} else {
state_ = OTHER_DESKTOP;
}
break;
}
default:
DBG("state() default:");
if(oldstate == UNMAPPED) {
XAddToSaveSet(fl_display, window_);
} else if(oldstate == NORMAL) {
throw_focus();
set_state_flag(IGNORE_UNMAP);
XUnmapWindow(fl_display, fl_xid(this));
XUnmapWindow(fl_display, window_);
title->hide();
} else { // don't setStateProperty IconicState multiple times
return;
}
break;
}
send_state_property();
}
void Frame::send_state_property()
{
switch(state())
{
case UNMAPPED:
ICCCM::state_withdrawn(this);
break;
case NORMAL:
case OTHER_DESKTOP:
ICCCM::state_normal(this);
break;
default :
ICCCM::state_iconic(this);
break;
}
}
void Frame::send_configurenotify()
{
ICCCM::configure(this);
}
void Frame::send_desktop()
{
// sends desktop where window belongs to server
if(desktop_) {
setProperty(_XA_NET_WM_DESKTOP, XA_CARDINAL, desktop_->number()-1);
if(desktop_!=Desktop::current() && state_==NORMAL)
state_=OTHER_DESKTOP;
} else {
// means sticky...
setProperty(_XA_NET_WM_DESKTOP, XA_CARDINAL, 0xFFFFFFFF);
//hmmm.. GNOME sticky should send also?!?
}
}
void Frame::raise(Window wid)
{
if(wid==None) {
Frame::active_=0;
for(uint n=0; n<map_order.size(); n++) {
Frame *f = map_order[n];
f->deactivate();
}
} else {
for(uint n=0; n<map_order.size(); n++) {
Frame *f = map_order[n];
if(wid==f->window()) {
f->raise();
f->activate_if_transient();
return;
}
}
}
}
// Public state modifiers that move all transient_for(this) children
// with the frame and do the desktops right:
void Frame::raise()
{
DBG("Frame(%s)::raise()", title->label().c_str());
Frame* newtop = 0;
int previous_state = state_;
Frame_List raise_list;
Frame *f;
uint n;
stack_order.remove(this);
raise_list.append(this);
if(desktop() && desktop()!=Desktop::current()) state(OTHER_DESKTOP);
else state(NORMAL);
for(n=0; n<stack_order.size(); n++) {
f = stack_order[n];
if(f==this || f->state()==UNMAPPED) continue;
if(f->is_transient_for(this)) {
stack_order.remove(f);
raise_list.append(f);
} else
continue;
if(f->desktop() && f->desktop()!=Desktop::current())
f->state(OTHER_DESKTOP);
else
f->state(NORMAL);
}
for(n=0; n<raise_list.size(); n++) {
f = raise_list[n];
stack_order.append(f);
newtop = f;
}
if(stack_order.count()!=map_order.count())
Fl::fatal(_("EDEWM: Internal bug, when restacking (%d != %d)! Exiting... "),
stack_order.count(), map_order.count());
if(!transient_for() && desktop_ && desktop_ != Desktop::current()) {
// for main windows we also must move to the current desktop
desktop(Desktop::current());
}
if(previous_state!=NORMAL && newtop->state_==NORMAL)
newtop->activate_if_transient();
DBG("Calling restack_windows()");
root->restack_windows();
DBG("Calling update_task_list()");
}
void Frame::lower()
{
DBG("Frame::lower()");
if(map_order.count()<2) return; // if we have just only one window
Frame* t = transient_for();
if(t) t->lower();
stack_order.remove(this);
stack_order.prepend(this);
root->restack_windows();
}
void Frame::iconize()
{
DBG("Frame::iconize()");
if(window_type()==TYPE_NORMAL || is_transient_for(this) && state() != UNMAPPED)
{
state(ICONIC);
throw_focus(1);
}
}
// maximize window
void Frame::maximize()
{
if(maximized)
return;
bool m = true;
int W=root->w();
int H=root->h();
W-=offset_w;
H-=offset_h;
if(ICCCM::get_size(this, W, H))
m=false;
restore_x = x();
restore_y = y();
restore_w = w();
restore_h = h();
W+=offset_w;
H+=offset_h;
if(Frame::animate)
::animate(x(), y(), w(), h(), root->x(), root->y(), root->w(), root->h());
set_size(root->x(), root->y(), W, H);
maximized = m;
redraw();
}
// restore window size
void Frame::restore()
{
if(!maximized)
return;
if(Frame::animate)
::animate(x(), y(), w(), h(), restore_x, restore_y, restore_w, restore_h);
set_size(restore_x, restore_y, restore_w, restore_h);
maximized = false;
}
void Frame::desktop(Window wid, int desktop)
{
for(uint n=0; n<map_order.size(); n++) {
Frame *f = map_order[n];
if(f->window()==wid) {
if(desktop==-2) f->desktop(0);
else f->desktop(Desktop::desktop(desktop));
return;
}
}
}
void Frame::desktop(Desktop* d)
{
DBG("Frame(%s)::desktop(%d)", label().c_str(), d->number());
if(d == desktop_) return;
if(d) clear_frame_flag(STICKY);
else set_frame_flag(STICKY);
// Put all the relatives onto the desktop as well:
for(uint n=0; n<map_order.size(); n++) {
Frame *c = map_order[n];
if(c==this || c->is_transient_for(this)) {
c->desktop_ = d;
if(d) {
c->setProperty(_XA_NET_WM_DESKTOP, XA_CARDINAL, d->number()-1);
} else {
// means sticky...
c->setProperty(_XA_NET_WM_DESKTOP, XA_CARDINAL, 0xFFFFFFFF);
}
if(!d || d == Desktop::current()) {
if(c->state() == OTHER_DESKTOP)
c->state(NORMAL);
} else {
if(c->state() == NORMAL)
c->state(OTHER_DESKTOP);
}
}
}
}
void Frame::handle_move(int &nx, int &ny)
{
int X = root->x();
if(nx < X && nx > X-SCREEN_SNAP) {
int t = X;
if(t <= x() && t > nx) nx = t;
}
int Y = root->y();
if(ny < Y && ny > Y-SCREEN_SNAP) {
int t = Y;
if(t <= y() && t > ny) ny = t;
}
int W = root->x()+root->w();
if (nx+w() > W && nx+w() < W+SCREEN_SNAP) {
int t = W-w();
if (t >= x() && t < nx) nx = t;
}
int H = root->y()+root->h();
if (ny+h() > H && ny+h() < H+SCREEN_SNAP) {
int t = H-h();
if(t >= y() && t < ny) ny = t;
}
if(!Frame::do_opaque) {
draw_overlay(nx-1, ny-1, w()+2, h()+2);
} else
set_size(nx, ny, w(), h());
}
// Resize and/or move the window. The size is given for the frame, not
// the contents. This also sets the buttons on/off as needed:
void Frame::set_size(int nx, int ny, int nw, int nh)
{
maximized = false;
int dx = nx-x();
int dy = ny-y();
if(!dx && !dy && nw == w() && nh == h())
return;
x(nx);
y(ny);
if(nw != w()) w(nw);
if(nh != h()) h(nh);
XMoveWindow(fl_display, fl_xid(this), nx, ny);
XResizeWindow(fl_display, fl_xid(this), nw, nh);
XResizeWindow(fl_display, window_, nw-offset_w, nh-offset_h);
send_configurenotify();
redraw();
//XSync(fl_display, False);
}
// Resize the frame to match the current border type:
void Frame::updateBorder()
{
DBG("updateBorder(): %s", label().c_str());
int nx = x()+offset_x;
int ny = y()+offset_y;
int nw = w()-offset_w;
int nh = h()-offset_h;
// Set boxes, according decorations flags
if(decor_flag(THIN_BORDER) && box()!=FL_UP_BOX)
box(FL_UP_BOX);
else if(decor_flag(BORDER) && box()!=FL_THICK_UP_BOX)
box(FL_THICK_UP_BOX);
else if(!decor_flag(THIN_BORDER) && !decor_flag(BORDER) && box()!=FL_NO_BOX)
box(FL_NO_BOX);
if(!decor_flag(BORDER) && !decor_flag(THIN_BORDER)) {
offset_x=offset_y=offset_w=offset_h=0;
if(decor_flag(TITLEBAR)) offset_y += TITLE_H;
} else {
offset_x = box()->dx();
offset_y = box()->dy();
offset_w = box()->dw();
offset_h = box()->dh();
offset_y+=title->h();
offset_h+=title->h();
}
nx -= offset_x;
ny -= offset_y;
nw += offset_w;
nh += offset_h;
if(x()==nx && y()==ny && w()==nw && h()==nh)
return;
x(nx); y(ny);
w(nw); h(nh);
redraw();
if(!shown())
return; // this is so constructor can call this
if(!decor_flag(TITLEBAR)) title->hide();
else title->show();
// try to make the contents not move while the border changes around it:
XSetWindowAttributes a;
a.win_gravity = StaticGravity;
XChangeWindowAttributes(fl_display, window_, CWWinGravity, &a);
XMoveResizeWindow(fl_display, fl_xid(this), nx, ny, nw, nh);
a.win_gravity = NorthWestGravity;
XChangeWindowAttributes(fl_display, window_, CWWinGravity, &a);
// fix the window position if the X server didn't do the gravity:
XMoveWindow(fl_display, window_, offset_x, offset_y);
}
void Frame::close(Window wid)
{
for(uint n=0; n<map_order.size(); n++) {
Frame *f = map_order[n];
if(wid==f->window()) {
f->close();
return;
}
}
}
void Frame::close()
{
DBG("Frame::close()");
if(frame_flag(DELETE_WIN_PRT))
sendMessage(_XA_WM_PROTOCOLS, _XA_WM_DELETE_WINDOW);
else
kill();
}
void Frame::kill()
{
DBG("Frame::kill()");
XUnmapWindow(fl_display, fl_xid(this));
XUnmapWindow(fl_display, window_);
XUnmapWindow(fl_display, fl_xid(title));
XKillClient(fl_display, window_);
destroy_frame();
}
// Drawing code:
void Frame::draw()
{
if((!decor_flag(BORDER) || !decor_flag(THIN_BORDER)) && !decor_flag(TITLEBAR))
return;
if(!(damage()&FL_DAMAGE_ALL|FL_DAMAGE_EXPOSE) )
return;
DBG("Frame::draw(%x)", damage());
if(!Theme::use_theme() || Theme::frame_color()==FL_NO_COLOR)
{
if(!decor_flag(BORDER) || !decor_flag(THIN_BORDER))
draw_frame();
}
else
{
Fl_Color color = Theme::frame_color();
fl_color(fl_lighter(color));
fl_line(0,0,0,h());
fl_line(0,0,w(),0);
fl_color(fl_darker(color));
fl_line(w()-1,0,w()-1,h());
fl_line(0,h()-1,w(),h()-1);
fl_color(color);
fl_rect(1,1,w()-2,h()-2);
fl_rect(2,2,w()-4,h()-4);
}
if(decor_flag(TITLEBAR))
{
if(active()) { // this here to update colors of the titlebar when are changed
title->color((Fl_Color)title_active_color);
title->label_color((Fl_Color)title_active_color_text);
} else {
title->color((Fl_Color)title_normal_color);
title->label_color((Fl_Color)title_normal_color_text);
}
// Resize and draw titlebar
if(decor_flag(BORDER) || decor_flag(THIN_BORDER)) {
XMoveResizeWindow(fl_display, fl_xid(title), box()->dx(), box()->dy(), w()-box()->dw(), TITLE_H);
title->resize(box()->dx(), box()->dy(), w()-box()->dw(), TITLE_H);
} else {
//XMoveResizeWindow(fl_display, fl_xid(title), 0, 0, w(), TITLE_H);
title->resize(0, 0, w(), TITLE_H);
}
title->layout();
draw_child(*title);
}
}
// User interface code:
// This method figures out what way the mouse will resize the window.
// It is used to set the cursor and to actually control what you grab.
// If the window cannot be resized in some direction this should not
// return that direction.
int Frame::mouse_location()
{
int x = Fl::event_x();
int y = Fl::event_y();
int r = 0;
if(!decor_flag(RESIZE)) return 0;
if(size_hints->min_height != size_hints->max_height) {
if(y < RESIZE_EDGE)
r |= FL_ALIGN_TOP;
else if(y >= h()-RESIZE_EDGE)
r |= FL_ALIGN_BOTTOM;
}
if(size_hints->min_width != size_hints->max_width) {
if(x < RESIZE_EDGE)
r |= FL_ALIGN_LEFT;
else if (x >= w()-RESIZE_EDGE)
r |= FL_ALIGN_RIGHT;
}
return r;
}
// set the cursor correctly for a return value from mouse_location():
static Frame* previous_frame=0;
void Frame::set_cursor(int r) {
Fl_Cursor c = FL_CURSOR_ARROW;
switch (r) {
case FL_ALIGN_TOP:
case FL_ALIGN_BOTTOM:
c = FL_CURSOR_NS;
break;
case FL_ALIGN_LEFT:
case FL_ALIGN_RIGHT:
c = FL_CURSOR_WE;
break;
case FL_ALIGN_LEFT|FL_ALIGN_TOP:
case FL_ALIGN_RIGHT|FL_ALIGN_BOTTOM:
c = FL_CURSOR_NWSE;
break;
case FL_ALIGN_LEFT|FL_ALIGN_BOTTOM:
case FL_ALIGN_RIGHT|FL_ALIGN_TOP:
c = FL_CURSOR_NESW;
break;
}
if(this != previous_frame || c != root->get_cursor()) {
previous_frame = this;
if(r<=0)
root->set_default_cursor();
else
root->set_cursor(c, FL_WHITE ,FL_BLACK);
}
}
#ifdef AUTO_RAISE
// timeout callback to cause autoraise:
void auto_raise(void*) {
if (Frame::activeFrame() && !Fl::grab() && !Fl::pushed())
Frame::activeFrame()->raise();
}
#endif
// If cursor is in the contents of a window this is set to that window.
// This is only used to force the cursor to an arrow even though X keeps
// sending mysterious erroneous move events:
static Frame* cursor_inside = 0;
//If true, we send all push, move, drag events to titlebar
bool handle_title = false;
// Handle an fltk event.
int Frame::handle(int e)
{
static bool grabbed=false;
static int what, dx, dy, ix, iy, iw, ih;
switch (e) {
case FL_SHOW:
case FL_HIDE:
return 0; // prevent fltk from messing things up
case FL_ENTER:
set_cursor(mouse_location());
if (Frame::focus_follows_mouse == true) activate(); // AEW
return 1;
case FL_LEAVE:
set_cursor(-1);
return 1;
case FL_MOVE:
// Tooltips...
if(!handle_title && Fl::event_inside(title->x(), title->y(), title->w(), title->h())) {
if(!title->tooltip().empty()) {
tooltip(title->tooltip());
Fl_Tooltip::enter(this);
} else
tooltip("");
handle_title = true;
} else if(!Fl::event_inside(title->x(), title->y(), title->w(), title->h()) ) { //Fl::belowmouse()==title) {
tooltip(0);
Fl_Tooltip::exit();
handle_title = false;
}
if(Fl::belowmouse() != this || cursor_inside == this) {
set_cursor(-1);
} else {
set_cursor(mouse_location());
}
return 1;
case FL_PUSH:
if(grabbed) return 1;
activate();
raise();
ix = x(); iy = y(); iw = w(); ih = h();
what = mouse_location();
if(Fl::event_button() > 1) what = 0; // middle button does drag
// FL_MOVE sets this!
if(handle_title) {
return title->handle(e);
}
dx = Fl::event_x_root()-ix;
if (what & FL_ALIGN_RIGHT) dx -= iw;
dy = Fl::event_y_root()-iy;
if (what & FL_ALIGN_BOTTOM) dy -= ih;
set_cursor(what);
if(!decor_flag(RESIZE)) return 0;
if(!Frame::do_opaque && !grabbed) {
XGrabServer(fl_display);
grabbed = true;
}
//We need to grab cursor, otherwise it keeps changing while resizing
grab_cursor(true);
return 1;
case FL_DRAG:
if(handle_title) {
return title->handle(e);
}
if(Fl::event_is_click()) return 1; // don't drag yet
if(!Fl::event_state(FL_BUTTON1)) return 0;
case FL_RELEASE:
if(e==FL_RELEASE) {
set_cursor(mouse_location());
if(Fl::event_state(FL_BUTTON1)) return 1;
}
// Check if titlebar handles event
if(handle_title) {
handle_title = false;
return title->handle(e);
}
//Otherwise it's resize event
int nx = ix;
int ny = iy;
int nw = iw;
int nh = ih;
if (what & FL_ALIGN_RIGHT)
nw = Fl::event_x_root()-dx-nx;
else if (what & FL_ALIGN_LEFT)
nw = ix+iw-(Fl::event_x_root()-dx);
else {
nx = x();
nw = w();
}
if (what & FL_ALIGN_BOTTOM)
nh = Fl::event_y_root()-dy-ny;
else if (what & FL_ALIGN_TOP)
nh = iy+ih-(Fl::event_y_root()-dy);
else {
ny = y();
nh = h();
}
int W=nw, H=nh;
ICCCM::get_size(this, W, H);
if(nw!=w()) {
nw = W;
nw -= (nw-offset_w)%size_hints->width_inc;
}
if(nh!=h())
nh = H;
if(what & FL_ALIGN_LEFT) nx = ix+iw-nw;
if(what & FL_ALIGN_TOP) ny = iy+ih-nh;
if(Frame::do_opaque || e==FL_RELEASE) {
set_size(nx,ny,nw,nh);
redraw();
} else {
draw_overlay(nx,ny,nw,nh);
}
if(e==FL_RELEASE) {
if(grabbed && !Frame::do_opaque) {
XUngrabServer(fl_display);
clear_overlay();
grabbed = false;
}
grab_cursor(false);
}
return 1;
}
return 0;
}
// Handle events that fltk did not recognize (mostly ones directed
// at the desktop):
int Frame::handle(const XEvent* ei)
{
switch (ei->type)
{
case VisibilityNotify: return visibility_event(&(ei->xvisibility));
case ConfigureRequest: return configure_event(&(ei->xconfigurerequest));
case MapRequest: return map_event(&(ei->xmaprequest));
case UnmapNotify: return unmap_event(&(ei->xunmap));
case DestroyNotify: return destroy_event(&(ei->xdestroywindow));
case ReparentNotify: return reparent_event(&(ei->xreparent));
case ClientMessage: return clientmsg_event(&(ei->xclient));
case ColormapNotify: return colormap_event(&(ei->xcolormap));
case PropertyNotify: return property_event(&(ei->xproperty));
case EnterNotify:
{
// see if cursor skipped over frame and directly to interior:
if (ei->xcrossing.detail == NotifyVirtual || ei->xcrossing.detail == NotifyNonlinearVirtual)
cursor_inside = this;
else
{
// cursor is now pointing at frame:
cursor_inside = 0;
set_cursor(0);
}
return 1;
}
case LeaveNotify:
{
if (ei->xcrossing.detail == NotifyInferior)
{
// cursor moved from frame to interior
cursor_inside = this;
set_cursor(0);
}
return 1;
}
default:
#ifdef SHAPE
if(ei->type == (root->XShapeEventBase + ShapeNotify))
return shape_event((XShapeEvent *)&ei);
#endif
break;
}
return 0;
}
// X utility routines:
void* getProperty(Window w, Atom a, Atom type, unsigned long *np, int *ret)
{
Atom realType;
int format;
unsigned long n, extra;
int status;
uchar *prop=0;
status = XGetWindowProperty(fl_display, w, a, 0L, 0x7fffffff,
False, type, &realType,
&format, &n, &extra, (uchar**)&prop);
if(ret) *ret = status;
if (status != Success) return 0;
if (!prop) { return 0; }
if (!n) { XFree(prop); return 0; }
if (np) *np = n;
return prop;
}
int getIntProperty(Window w, Atom a, Atom type, int deflt, int *ret)
{
void* prop = getProperty(w, a, type, 0, ret);
if(!prop) return deflt;
int r = int(*(long*)prop);
XFree(prop);
return r;
}
void setProperty(Window w, Atom a, Atom type, int v)
{
long prop = v;
XChangeProperty(fl_display, w, a, type, 32, PropModeReplace, (uchar*)&prop,1);
}
void Frame::setProperty(Atom a, Atom type, int v) const
{
::setProperty(window_, a, type, v);
}
int Frame::getIntProperty(Atom a, Atom type, int deflt, int *ret) const
{
return ::getIntProperty(window_, a, type, deflt, ret);
}
void* Frame::getProperty(Atom a, Atom type, unsigned long *np, int *ret) const
{
return ::getProperty(window_, a, type, np, ret);
}
void Frame::sendMessage(Atom a, Atom l) const
{
XEvent ev;
long mask;
memset(&ev, 0, sizeof(ev));
ev.xclient.type = ClientMessage;
ev.xclient.window = window_;
ev.xclient.message_type = a;
ev.xclient.format = 32;
ev.xclient.data.l[0] = long(l);
ev.xclient.data.l[1] = long(fl_event_time);
mask = 0L;
XSendEvent(fl_display, window_, False, mask, &ev);
}
Reference in New Issue View Git Blame Copy Permalink