~ubuntu-branches/ubuntu/gutsy/flwm/gutsy

// Frame.C

#include "config.h"

#include "Frame.H"

#include "Desktop.H"

#include <string.h>

#include <stdio.h>

#include <FL/fl_draw.H>

#include "Rotated.H"

static Atom wm_state = 0;

static Atom wm_change_state;

static Atom wm_protocols;

static Atom wm_delete_window;

static Atom wm_take_focus;

static Atom wm_save_yourself;

static Atom wm_colormap_windows;

static Atom _motif_wm_hints;

static Atom kwm_win_decoration;

#if DESKTOPS

static Atom kwm_win_desktop;

static Atom kwm_win_sticky;

#endif

//static Atom wm_client_leader;

static Atom _wm_quit_app;

// these are set by initialize in main.C:

Atom _win_hints;

Atom _win_state;

#if DESKTOPS

extern Atom _win_workspace;

#endif

#ifdef SHOW_CLOCK

extern char clock_buf[];

extern int clock_alarm_on;

#endif

static const int XEventMask =

ExposureMask|StructureNotifyMask

|KeyPressMask|KeyReleaseMask|KeymapStateMask|FocusChangeMask

|ButtonPressMask|ButtonReleaseMask

|EnterWindowMask|LeaveWindowMask

|PointerMotionMask|SubstructureRedirectMask|SubstructureNotifyMask;

extern Fl_Window* Root;

Frame* Frame::active_;

Frame* Frame::first;

static inline int max(int a, int b) {return a > b ? a : b;}

static inline int min(int a, int b) {return a < b ? a : b;}

////////////////////////////////////////////////////////////////

// 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),

  state_flags_(0),

  flags_(0),

  transient_for_xid(None),

  transient_for_(0),

  revert_to(active_),

  colormapWinCount(0),

  close_button(BUTTON_LEFT,BUTTON_TOP,BUTTON_W,BUTTON_H,"X"),

  iconize_button(BUTTON_LEFT,BUTTON_TOP,BUTTON_W,BUTTON_H,"i"),

  max_h_button(BUTTON_LEFT,BUTTON_TOP+3*BUTTON_H,BUTTON_W,BUTTON_H,"h"),

  max_w_button(BUTTON_LEFT,BUTTON_TOP+BUTTON_H,BUTTON_W,BUTTON_H,"w"),

  min_w_button(BUTTON_LEFT,BUTTON_TOP+2*BUTTON_H,BUTTON_W,BUTTON_H,"W")

{

  close_button.callback(button_cb_static);

  iconize_button.callback(button_cb_static);

  max_h_button.type(FL_TOGGLE_BUTTON);

  max_h_button.callback(button_cb_static);

  max_w_button.type(FL_TOGGLE_BUTTON);

  max_w_button.callback(button_cb_static);

  min_w_button.type(FL_TOGGLE_BUTTON);

  min_w_button.callback(button_cb_static);

  end();

  box(FL_NO_BOX); // relies on background color erasing interior

  next = first;

  first = this;

  // do this asap so we don't miss any events...

  if (!dont_set_event_mask)

    XSelectInput(fl_display, window_,

		 ColormapChangeMask | PropertyChangeMask | FocusChangeMask

		 );

  if (!wm_state) {

    // allocate all the atoms if this is the first time

    wm_state		= XInternAtom(fl_display, "WM_STATE",		0);

    wm_change_state	= XInternAtom(fl_display, "WM_CHANGE_STATE",	0);

    wm_protocols	= XInternAtom(fl_display, "WM_PROTOCOLS",	0);

    wm_delete_window	= XInternAtom(fl_display, "WM_DELETE_WINDOW",	0);

    wm_take_focus	= XInternAtom(fl_display, "WM_TAKE_FOCUS",	0);

    wm_save_yourself	= XInternAtom(fl_display, "WM_SAVE_YOURSELF",	0);

    wm_colormap_windows	= XInternAtom(fl_display, "WM_COLORMAP_WINDOWS",0);

    _motif_wm_hints	= XInternAtom(fl_display, "_MOTIF_WM_HINTS",	0);

    kwm_win_decoration	= XInternAtom(fl_display, "KWM_WIN_DECORATION",	0);

#if DESKTOPS

    kwm_win_desktop	= XInternAtom(fl_display, "KWM_WIN_DESKTOP",	0);

    kwm_win_sticky	= XInternAtom(fl_display, "KWM_WIN_STICKY",	0);

#endif

//  wm_client_leader	= XInternAtom(fl_display, "WM_CLIENT_LEADER",	0);

    _wm_quit_app	= XInternAtom(fl_display, "_WM_QUIT_APP",	0);

  }

  label_y = label_h = label_w = 0;

  getLabel();

  // getIconLabel();

  {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);

  }

  left = top = dwidth = dheight = 0; // pretend border is zero-width for now

  app_border_width = attr.border_width;

  x(attr.x+app_border_width); restore_x = x();

  y(attr.y+app_border_width); restore_y = y();

  w(attr.width); restore_w = w();

  h(attr.height); restore_h = h();

  colormap = attr.colormap;}

  getColormaps();

  //group_ = 0;

  {XWMHints* hints = XGetWMHints(fl_display, window_);

  if (hints) {

    if ((hints->flags & InputHint) && !hints->input) set_flag(NO_FOCUS);

    //if (hints && hints->flags&WindowGroupHint) group_ = hints->window_group;

  }

  switch (getIntProperty(wm_state, wm_state, 0)) {

  case NormalState:

    state_ = NORMAL; break;

  case IconicState:

    state_ = ICONIC; break;

  // X also defines obsolete values ZoomState and InactiveState

  default:

    if (hints && (hints->flags&StateHint) && hints->initial_state==IconicState)

      state_ = ICONIC;

    else

      state_ = NORMAL;

  }

  if (hints) XFree(hints);}

  // Maya sets this, seems to mean the same as group:

  // if (!group_) group_ = getIntProperty(wm_client_leader, XA_WINDOW);

  XGetTransientForHint(fl_display, window_, &transient_for_xid);

  getProtocols();

  getMotifHints();

  // get Gnome hints:

  int p = getIntProperty(_win_hints, XA_CARDINAL);

  if (p&1) set_flag(NO_FOCUS);		// WIN_HINTS_SKIP_FOCUS

  // if (p&2)				// WIN_HINTS_SKIP_WINLIST

  // if (p&4)				// WIN_HINTS_SKIP_TASKBAR

  // if (p&8) ...			// WIN_HINTS_GROUP_TRANSIENT

  if (p&16) set_flag(CLICK_TO_FOCUS);	// WIN_HINTS_FOCUS_ON_CLICK

  // get KDE hints:

  p = getIntProperty(kwm_win_decoration, kwm_win_decoration, 1);

  if (!(p&3)) set_flag(NO_BORDER);

  else if (p & 2) set_flag(THIN_BORDER);

  if (p & 256) set_flag(NO_FOCUS);

  fix_transient_for();

  if (transient_for()) {

    if (state_ == NORMAL) state_ = transient_for()->state_;

#if DESKTOPS

    desktop_ = transient_for()->desktop_;

#endif

  }

#if DESKTOPS

  // see if anybody thinks window is "sticky:"

  else if ((getIntProperty(_win_state, XA_CARDINAL) & 1) // WIN_STATE_STICKY

      || getIntProperty(kwm_win_sticky, kwm_win_sticky)) {

    desktop_ = 0;

  } else {

    // get the desktop from either Gnome or KDE (Gnome takes precedence):

    p = getIntProperty(_win_workspace, XA_CARDINAL, -1) + 1; // Gnome desktop

    if (p <= 0) p = getIntProperty(kwm_win_desktop, kwm_win_desktop);

    if (p > 0 && p < 25)

      desktop_ = Desktop::number(p, 1);

    else

      desktop_ = Desktop::current();

  }

  if (desktop_ && desktop_ != Desktop::current())

    if (state_ == NORMAL) state_ = OTHER_DESKTOP;

#endif

  int autoplace = getSizes();

  // some Motif programs assumme this will force the size to conform :-(

  if (w() < min_w || h() < min_h) {

    if (w() < min_w) w(min_w);

    if (h() < min_h) h(min_h);

    XResizeWindow(fl_display, window_, w(), h());

  }

  // try to detect programs that think "transient_for" means "no border":

  if (transient_for_xid && !label() && !flag(NO_BORDER)) {

    set_flag(THIN_BORDER);

  }

  updateBorder();

  show_hide_buttons();

  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 = TITLE_WIDTH+LEFT;

    for (Frame* f = next; f; f = f->next) {

      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()));

  // guess some values for the "restore" fields, if already maximized:

  if (max_w_button.value()) {

    restore_w = min_w + ((w()-dwidth-min_w)/2/inc_w) * inc_w;

    restore_x = x()+left + (w()-dwidth-restore_w)/2;

  }

  if (max_h_button.value()) {

    restore_h = min_h + ((h()-dheight-min_h)/2/inc_h) * inc_h;

    restore_y = y()+top + (h()-dheight-restore_h)/2;

  }

  const int mask = CWBorderPixel | CWColormap | CWEventMask | CWBitGravity

    | CWBackPixel | CWOverrideRedirect;

  XSetWindowAttributes sattr;

  sattr.event_mask = XEventMask;

  sattr.colormap = fl_colormap;

  sattr.border_pixel = fl_xpixel(FL_GRAY0);

  sattr.bit_gravity = NorthWestGravity;

  sattr.override_redirect = 1;

  sattr.background_pixel = fl_xpixel(FL_GRAY);

  Fl_X::set_xid(this, XCreateWindow(fl_display, fl_xid(Root),

			     x(), y(), w(), h(), 0,

			     fl_visual->depth,

			     InputOutput,

			     fl_visual->visual,

			     mask, &sattr));

  setStateProperty();

  if (!dont_set_event_mask) XAddToSaveSet(fl_display, window_);

  if (existing) set_state_flag(IGNORE_UNMAP);

  XReparentWindow(fl_display, window_, fl_xid(this), left, top);

  XSetWindowBorderWidth(fl_display, window_, 0);

  if (state_ == NORMAL) XMapWindow(fl_display, window_);

  sendConfigureNotify(); // many apps expect this even if window size unchanged

#if CLICK_RAISES || CLICK_TO_TYPE

  XGrabButton(fl_display, AnyButton, AnyModifier, window, False,

	      ButtonPressMask, GrabModeSync, GrabModeAsync, None, None);

#endif

  if (state_ == NORMAL) {

    XMapWindow(fl_display, fl_xid(this));

    if (!existing) activate_if_transient();

  }

}

// modify the passed X & W to a legal horizontal window position

int Frame::force_x_onscreen(int X, int W) {

  // force all except the black border on-screen:

  X = min(X, Root->x()+Root->w()+1-W);

  X = max(X, Root->x()-1);

  // force the contents on-screen:

  X = min(X, Root->x()+Root->w()-W+dwidth-left);

  if (W-dwidth > Root->w() || h()-dheight > Root->h())

    // windows bigger than the screen need title bar so they can move

    X = max(X, Root->x()-LEFT);

  else

    X = max(X, Root->x()-left);

  return X;

}

// modify the passed Y & H to a legal vertical window position:

int Frame::force_y_onscreen(int Y, int H) {

  // force border (except black edge) to be on-screen:

  Y = min(Y, Root->y()+Root->h()+1-H);

  Y = max(Y, Root->y()-1);

  // force contents to be on-screen:

  Y = min(Y, Root->y()+Root->h()-H+dheight-top);

  Y = max(Y, Root->y()-top);

  return Y;

}

////////////////////////////////////////////////////////////////

// destructor

// The destructor is called on DestroyNotify, so I don't have to do anything

// to the contained window, which is already been destroyed.

// fltk bug: it does not clear these pointers when window is deleted,

// causing flwm to crash on window close sometimes:

extern Fl_Window *fl_xfocus;

extern Fl_Window *fl_xmousewin;

Frame::~Frame() {

  // 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_xfocus = 0;

  fl_xmousewin = 0;

  Fl::focus_ = 0;

  // remove any pointers to this:

  Frame** cp; for (cp = &first; *cp; cp = &((*cp)->next))

    if (*cp == this) {*cp = next; break;}

  for (Frame* f = first; f; f = f->next) {

    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 (iconlabel()) XFree((char*)iconlabel());

  if (label())     XFree((char*)label());

}

////////////////////////////////////////////////////////////////

void Frame::getLabel(int del) {

  char* old = (char*)label();

  char* nu = del ? 0 : (char*)getProperty(XA_WM_NAME);

  if (nu) {

    // 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 = nu; while (*c == ' ') c++;

    if (!*c) {XFree(nu); nu = 0;}

  }

  if (old) {

    if (nu && !strcmp(old,nu)) {XFree(nu); return;}

    XFree(old);

  } else {

    if (!nu) return;

  }

  Fl_Widget::label(nu);

  if (nu) {

    fl_font(TITLE_FONT_SLOT, TITLE_FONT_SIZE);

    label_w = int(fl_width(nu))+6;

  } else

    label_w = 0;

  if (shown() && label_h > 3 && left > 3)

    XClearArea(fl_display, fl_xid(this), 1, label_y+3, left-1, label_h-3, 1);

}

////////////////////////////////////////////////////////////////

int Frame::getGnomeState(int &) {

// values for _WIN_STATE property are from Gnome WM compliance docs:

#define WIN_STATE_STICKY          (1<<0) /*everyone knows sticky*/

#define WIN_STATE_MINIMIZED       (1<<1) /*Reserved - definition is unclear*/

#define WIN_STATE_MAXIMIZED_VERT  (1<<2) /*window in maximized V state*/

#define WIN_STATE_MAXIMIZED_HORIZ (1<<3) /*window in maximized H state*/

#define WIN_STATE_HIDDEN          (1<<4) /*not on taskbar but window visible*/

#define WIN_STATE_SHADED          (1<<5) /*shaded (MacOS / Afterstep style)*/

#define WIN_STATE_HID_WORKSPACE   (1<<6) /*not on current desktop*/

#define WIN_STATE_HID_TRANSIENT   (1<<7) /*owner of transient is hidden*/

#define WIN_STATE_FIXED_POSITION  (1<<8) /*window is fixed in position even*/

#define WIN_STATE_ARRANGE_IGNORE  (1<<9) /*ignore for auto arranging*/

  // nyi

  return 0;

}

////////////////////////////////////////////////////////////////

// Read the sizeHints, and try to remove the vast number of mistakes

// that some applications seem to do writing them.

// Returns true if autoplace should be done.

int Frame::getSizes() {

  XSizeHints sizeHints;

  long junk;

  if (!XGetWMNormalHints(fl_display, window_, &sizeHints, &junk))

    sizeHints.flags = 0;

  // get the increment, use 1 if none or illegal values:

  if (sizeHints.flags & PResizeInc) {

    inc_w = sizeHints.width_inc; if (inc_w < 1) inc_w = 1;

    inc_h = sizeHints.height_inc; if (inc_h < 1) inc_h = 1;

  } else {

    inc_w = inc_h = 1;

  }

  // get the current size of the window:

  int W = w()-dwidth;

  int H = h()-dheight;

  // I try a lot of places to get a good minimum size value.  Lots of

  // programs set illegal or junk values, so getting this correct is

  // difficult:

  min_w = W;

  min_h = H;

  // guess a value for minimum size in case it is not set anywhere:

  min_w = min(min_w, 4*BUTTON_H);

  min_w = ((min_w+inc_w-1)/inc_w) * inc_w;

  min_h = min(min_h, 4*BUTTON_H);

  min_h = ((min_h+inc_h-1)/inc_h) * inc_h;

  // some programs put the minimum size here:

  if (sizeHints.flags & PBaseSize) {

    junk = sizeHints.base_width; if (junk > 0) min_w = junk;

    junk = sizeHints.base_height; if (junk > 0) min_h = junk;

  }

  // finally, try the actual place the minimum size should be:

  if (sizeHints.flags & PMinSize) {

    junk = sizeHints.min_width; if (junk > 0) min_w = junk;

    junk = sizeHints.min_height; if (junk > 0) min_h = junk;

  }

  max_w = max_h = 0; // default maximum size is "infinity"

  if (sizeHints.flags & PMaxSize) {

    // Though not defined by ICCCM standard, I interpret any maximum

    // size that is less than the minimum to mean "infinity".  This

    // allows the maximum to be set in one direction only:

    junk = sizeHints.max_width;

    if (junk >= min_w && junk <= W) max_w = junk;

    junk = sizeHints.max_height;

    if (junk >= min_h && junk <= H) max_h = junk;

  }

  // set the maximize buttons according to current size:

  max_w_button.value(W == maximize_width());

  max_h_button.value(H == maximize_height());

  // Currently only 1x1 aspect works:

  if (sizeHints.flags & PAspect

      && sizeHints.min_aspect.x == sizeHints.min_aspect.y)

    set_flag(KEEP_ASPECT);

  // another fix for gimp, which sets PPosition to 0,0:

  if (x() <= 0 && y() <= 0) sizeHints.flags &= ~PPosition;

  return !(sizeHints.flags & (USPosition|PPosition));

}

int max_w_switch;

// return width of contents when maximize button pressed:

int Frame::maximize_width() {

  int W = max_w_switch; if (!W) W = Root->w();

  return ((W-TITLE_WIDTH-min_w)/inc_w) * inc_w + min_w;

}

int max_h_switch;

int Frame::maximize_height() {

  int H = max_h_switch; if (!H) H = Root->h();

  return ((H-min_h)/inc_h) * inc_h + min_h;

}

////////////////////////////////////////////////////////////////

void Frame::getProtocols() {

  int n; Atom* p = (Atom*)getProperty(wm_protocols, XA_ATOM, &n);

  if (p) {

    clear_flag(DELETE_WINDOW_PROTOCOL|TAKE_FOCUS_PROTOCOL|QUIT_PROTOCOL);

    for (int i = 0; i < n; ++i) {

      if (p[i] == wm_delete_window) {

	set_flag(DELETE_WINDOW_PROTOCOL);

      } else if (p[i] == wm_take_focus) {

	set_flag(TAKE_FOCUS_PROTOCOL);

      } else if (p[i] == wm_save_yourself) {

	set_flag(SAVE_PROTOCOL);

      } else if (p[i] == _wm_quit_app) {

	set_flag(QUIT_PROTOCOL);

      }

    }

  }

  XFree((char*)p);

}

////////////////////////////////////////////////////////////////

int Frame::getMotifHints() {

  long* prop = (long*)getProperty(_motif_wm_hints, _motif_wm_hints);

  if (!prop) return 0;

  // see /usr/include/X11/Xm/MwmUtil.h for meaning of these bits...

  // prop[0] = flags (what props are specified)

  // prop[1] = functions (all, resize, move, minimize, maximize, close, quit)

  // prop[2] = decorations (all, border, resize, title, menu, minimize,

  //                        maximize)

  // prop[3] = input_mode (modeless, primary application modal, system modal,

  //                       full application modal)

  // prop[4] = status (tear-off window)

  // Fill in the default value for missing fields:

  if (!(prop[0]&1)) prop[1] = 1;

  if (!(prop[0]&2)) prop[2] = 1;

  // The low bit means "turn the marked items off", invert this.

  // Transient windows already have size & iconize buttons turned off:

  if (prop[1]&1) prop[1] = ~prop[1] & (transient_for_xid ? ~0x58 : -1);

  if (prop[2]&1) prop[2] = ~prop[2] & (transient_for_xid ? ~0x60 : -1);

  int old_flags = flags();

  // see if they are trying to turn off border:

  if (!(prop[2])) set_flag(NO_BORDER); else clear_flag(NO_BORDER);

  // see if they are trying to turn off title & close box:

  if (!(prop[2]&0x18)) set_flag(THIN_BORDER); else clear_flag(THIN_BORDER);

  // some Motif programs use this to disable resize :-(

  // and some programs change this after the window is shown (*&%$#%)

  if (!(prop[1]&2) || !(prop[2]&4))

    set_flag(NO_RESIZE); else clear_flag(NO_RESIZE);

  // and some use this to disable the Close function.  The commented

  // out test is it trying to turn off the mwm menu button: it appears

  // programs that do that still expect Alt+F4 to close them, so I

  // leave the close on then:

  if (!(prop[1]&0x20) /*|| !(prop[2]&0x10)*/)

    set_flag(NO_CLOSE); else clear_flag(NO_CLOSE);

  // see if they set "input hint" to non-zero:

  // prop[3] should be nonzero but the only example of this I have

  // found is Netscape 3.0 and it sets it to zero...

  if (!shown() && (prop[0]&4) /*&& prop[3]*/) set_flag(MODAL);

  // see if it is forcing the iconize button back on.  This makes

  // transient_for act like group instead...

  if ((prop[1]&0x8) || (prop[2]&0x20)) set_flag(ICONIZE);

  // Silly 'ol Amazon paint ignores WM_DELETE_WINDOW and expects to

  // get the SGI-specific "_WM_QUIT_APP".  It indicates this by trying

  // to turn off the close box. SIGH!!!

  if (flag(QUIT_PROTOCOL) && !(prop[1]&0x20))

    clear_flag(DELETE_WINDOW_PROTOCOL);

  XFree((char*)prop);

  return (flags() ^ old_flags);

}

////////////////////////////////////////////////////////////////

void Frame::getColormaps(void) {

  if (colormapWinCount) {

    XFree((char *)colormapWindows);

    delete[] window_Colormaps;

  }

  int n;

  Window* cw = (Window*)getProperty(wm_colormap_windows, XA_WINDOW, &n);

  if (cw) {

    colormapWinCount = n;

    colormapWindows = cw;

    window_Colormaps = new Colormap[n];

    for (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 && !flag(ICONIZE)) {

    for (Frame* f = first; f; f = f->next) {

      if (f != this && f->window_ == transient_for_xid) {p = f; break;}

    }

    // loops are illegal:

    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; 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

int Frame::activate_if_transient() {

  if (!Fl::pushed())

    if (!transient_for() || is_transient_for(active_)) return activate(1);

  return 0;

}

////////////////////////////////////////////////////////////////

int Frame::activate(int warp) {

  // see if a modal & newer window is up:

  for (Frame* c = first; c && c != this; c = c->next)

    if (c->flag(MODAL) && c->transient_for() == this)

      if (c->activate(warp)) return 1;

  // ignore invisible windows:

  if (state() != NORMAL || w() <= dwidth) return 0;

  // always put in the colormap:

  installColormap();

  // move the pointer if desired:

  // (note that moving the pointer is pretty much required for point-to-type

  // unless you know the pointer is already in the window):

  if (!warp || Fl::event_state() & (FL_BUTTON1|FL_BUTTON2|FL_BUTTON3)) {

    ;

  } else if (warp==2) {

    // warp to point at title:

    XWarpPointer(fl_display, None, fl_xid(this), 0,0,0,0, left/2+1,

                 min(label_y+label_w/2+1,h()/2));

  } else {

    warp_pointer();

  }

  // skip windows that don't want focus:

  if (flag(NO_FOCUS)) return 0;

  // 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);

  if (active_ != this) {

    if (active_) active_->deactivate();

    active_ = this;

#if defined(ACTIVE_COLOR)

    XSetWindowAttributes a;

    a.background_pixel = fl_xpixel(FL_SELECTION_COLOR);

    XChangeWindowAttributes(fl_display, fl_xid(this), CWBackPixel, &a);

    labelcolor(contrast(FL_BLACK, FL_SELECTION_COLOR));

    XClearArea(fl_display, fl_xid(this), 2, 2, w()-4, h()-4, 1);

#else

#if defined(SHOW_CLOCK)

    redraw();

#endif

#endif

    if (flag(TAKE_FOCUS_PROTOCOL))

      sendMessage(wm_protocols, wm_take_focus);

  }

  return 1;

}

// this private function should only be called by constructor and if

// the window is active():

void Frame::deactivate() {

#if defined(ACTIVE_COLOR)

    XSetWindowAttributes a;

    a.background_pixel = fl_xpixel(FL_GRAY);

    XChangeWindowAttributes(fl_display, fl_xid(this), CWBackPixel, &a);

    labelcolor(FL_BLACK);

    XClearArea(fl_display, fl_xid(this), 2, 2, w()-4, h()-4, 1);