add iconifying!!!!

also cleanup the map process a bit, the close action wasn't being set in the allowed actions.

src/client.cc

@@ -36,7 +36,7 @@ Client::Client(int screen, Window window)
   
   // update EVERYTHING the first time!!
 
-  // the state is kinda assumed to be normal. is this right? XXX
+  // we default to NormalState, visible
   _wmstate = NormalState; _iconic = false;
   // no default decors or functions, each has to be enabled
   _decorations = _functions = 0;
@@ -54,20 +54,28 @@ Client::Client(int screen, Window window)
   getType();
   getMwmHints();
 
-  setupDecorAndFunctions();
-  
-  getState();
+  getState(); // gets all the states except for iconic, which is found from
+              // the desktop == ICONIC_DESKTOP
   getShaped();
 
   updateProtocols();
-  getGravity(); // get the attribute gravity
+
+  // got the type, the mwmhints, and the protocols, so we're ready to set up
+  // the decorations/functions
+  setupDecorAndFunctions();
+  
+  getGravity();        // get the attribute gravity
   updateNormalHints(); // this may override the attribute gravity
-  updateWMHints();
+  updateWMHints(true); // also get the initial_state and set _iconic
   updateTitle();
   updateIconTitle();
   updateClass();
   updateStrut();
 
+  // restores iconic state when we restart.
+  // this will override the initial_state if that was set
+  if (_desktop == ICONIC_DESKTOP) _iconic = true;
+  
   changeState();
 }
 
@@ -88,6 +96,11 @@ Client::~Client()
     // these values should not be persisted across a window unmapping/mapping
     otk::Property::erase(_window, otk::Property::atoms.net_wm_desktop);
     otk::Property::erase(_window, otk::Property::atoms.net_wm_state);
+  } else {
+    // if we're left in an iconic state, the client wont be mapped. this is
+    // bad, since we will no longer be managing the window on restart
+    if (_iconic)
+      XMapWindow(**otk::display, _window);
   }
 }
 
@@ -173,6 +186,10 @@ void Client::setupDecorAndFunctions()
     Decor_AllDesktops | Decor_Iconify | Decor_Maximize;
   _functions = Func_Resize | Func_Move | Func_Iconify | Func_Maximize |
     Func_Shade;
+  if (_delete_window) {
+    _decorations |= Decor_Close;
+    _functions |= Func_Close;
+  }
   
   switch (_type) {
   case Type_Normal:
@@ -367,16 +384,13 @@ void Client::updateProtocols()
   int num_return = 0;
 
   _focus_notify = false;
-  _decorations &= ~Decor_Close;
-  _functions &= ~Func_Close;
+  _delete_window = false;
 
   if (XGetWMProtocols(**otk::display, _window, &proto, &num_return)) {
     for (int i = 0; i < num_return; ++i) {
       if (proto[i] == otk::Property::atoms.wm_delete_window) {
-        _decorations |= Decor_Close;
-        _functions |= Func_Close;
-        if (frame)
-          frame->adjustSize(); // update the decorations
+        // this means we can request the window to close
+        _delete_window = true;
       } else if (proto[i] == otk::Property::atoms.wm_take_focus)
         // if this protocol is requested, then the window will be notified
         // by the window manager whenever it receives focus
@@ -434,7 +448,7 @@ void Client::updateNormalHints()
 }
 
 
-void Client::updateWMHints()
+void Client::updateWMHints(bool initstate)
 {
   XWMHints *hints;
 
@@ -446,6 +460,10 @@ void Client::updateWMHints()
     if (hints->flags & InputHint)
       _can_focus = hints->input;
 
+    // only do this when initstate is true!
+    if (initstate && (hints->flags & StateHint))
+      _iconic = hints->initial_state == IconicState;
+
     if (hints->flags & XUrgencyHint)
       _urgent = true;
 
@@ -613,8 +631,11 @@ void Client::propertyHandler(const XPropertyEvent &e)
     updateIconTitle();
   else if (e.atom == otk::Property::atoms.wm_class)
     updateClass();
-  else if (e.atom == otk::Property::atoms.wm_protocols)
+  else if (e.atom == otk::Property::atoms.wm_protocols) {
     updateProtocols();
+    setupDecorAndFunctions();
+    frame->adjustSize(); // update the decorations
+  }
   else if (e.atom == otk::Property::atoms.net_wm_strut)
     updateStrut();
 }
@@ -624,13 +645,12 @@ void Client::setWMState(long state)
 {
   if (state == _wmstate) return; // no change
   
-  _wmstate = state;
-  switch (_wmstate) {
+  switch (state) {
   case IconicState:
-    // XXX: cause it to iconify
+    setDesktop(ICONIC_DESKTOP);
     break;
   case NormalState:
-    // XXX: cause it to uniconify
+    setDesktop(openbox->screen(_screen)->desktop());
     break;
   }
 }
@@ -642,10 +662,13 @@ void Client::setDesktop(long target)
   
   printf("Setting desktop %ld\n", target);
 
-  if (!(target >= 0 || target == (signed)0xffffffff)) return;
+  if (!(target >= 0 || target == (signed)0xffffffff ||
+        target == ICONIC_DESKTOP))
+    return;
   
   _desktop = target;
 
+  // set the desktop hint
   otk::Property::set(_window, otk::Property::atoms.net_wm_desktop,
                      otk::Property::atoms.cardinal, (unsigned)_desktop);
   
@@ -656,6 +679,25 @@ void Client::setDesktop(long target)
   else
     frame->hide();
 
+  // Handle Iconic state. Iconic state is maintained by the client being a
+  // member of the ICONIC_DESKTOP, so this is where we make iconifying and
+  // uniconifying happen.
+  bool i = _desktop == ICONIC_DESKTOP;
+  if (i != _iconic) { // has the state changed?
+    _iconic = i;
+    if (_iconic) {
+      _wmstate = IconicState;
+      ignore_unmaps++;
+      // we unmap the client itself so that we can get MapRequest events, and
+      // because the ICCCM tells us to!
+      XUnmapWindow(**otk::display, _window);
+    } else {
+      _wmstate = NormalState;
+      XMapWindow(**otk::display, _window);
+    }
+    changeState();
+  }
+  
   frame->adjustState();
 }
 
@@ -884,6 +926,8 @@ void Client::clientMessageHandler(const XClientMessageEvent &e)
 #ifdef DEBUG
     printf("net_active_window for 0x%lx\n", _window);
 #endif
+    if (_iconic)
+      setDesktop(openbox->screen(_screen)->desktop());
     if (_shaded)
       shade(false);
     // XXX: deiconify
@@ -1113,6 +1157,11 @@ void Client::applyStartupState()
 {
   // these are in a carefully crafted order..
 
+  if (_iconic) {
+    _iconic = false;
+    _desktop = 0;    // set some other source desktop so this goes through
+    setDesktop(ICONIC_DESKTOP);
+  }
   if (_fullscreen) {
     _fullscreen = false;
     fullscreen(true);
@@ -1138,7 +1187,9 @@ void Client::shade(bool shade)
   if (!(_functions & Func_Shade) || // can't
       _shaded == shade) return;     // already done
 
-  _wmstate = shade ? IconicState : NormalState;
+  // when we're iconic, don't change the wmstate
+  if (!_iconic)
+    _wmstate = shade ? IconicState : NormalState;
   _shaded = shade;
   changeState();
   frame->adjustSize();
@@ -1280,7 +1331,8 @@ void Client::configureRequestHandler(const XConfigureRequestEvent &e)
   
   otk::EventHandler::configureRequestHandler(e);
 
-  // XXX: if we are iconic (or shaded? (fvwm does that)) ignore the event
+  // if we are iconic (or shaded (fvwm does this)) ignore the event
+  if (_iconic || _shaded) return;
 
   if (e.value_mask & CWBorderWidth)
     _border_width = e.border_width;
@@ -1399,4 +1451,17 @@ void Client::reparentHandler(const XReparentEvent &e)
   openbox->screen(_screen)->unmanageWindow(this);
 }
 
+void Client::mapRequestHandler(const XMapRequestEvent &e)
+{
+#ifdef    DEBUG
+  printf("MapRequest for already managed 0x%lx\n", e.window);
+#endif // DEBUG
+
+  assert(_iconic); // we shouldn't be able to get this unless we're iconic
+
+  // move to the current desktop (uniconify)
+  setDesktop(openbox->screen(_screen)->desktop());
+  // XXX: should we focus/raise the window? (basically a net_wm_active_window)
+}
+
 }

src/client.hh

@@ -164,6 +164,10 @@ public:
   static const long no_propagate_mask = ButtonPressMask | ButtonReleaseMask |
                                         ButtonMotionMask;
 
+  //! The desktop value which indicated the window is iconified and not on any
+  //! desktop
+  static const long ICONIC_DESKTOP = 0xfffffffe;
+
   //! The number of unmap events to ignore on the window
   int ignore_unmaps;
   
@@ -261,6 +265,9 @@ private:
   //! NormalState
   long _wmstate;
 
+  //! True if the client supports the delete_window protocol
+  bool _delete_window;
+  
   //! Was the window's position requested by the application? if not, we should
   //! place the window ourselves when it first appears
   bool _positioned;
@@ -352,6 +359,10 @@ private:
   void setState(StateAction action, long data1, long data2);
 
   //! Sends the window to the specified desktop
+  /*!
+    A window is iconified by sending it to the ICONIC_DESKTOP, and restored
+    by sending it to any other valid desktop.
+  */
   void setDesktop(long desktop);
   
   //! Calculates the stacking layer for the client window
@@ -363,7 +374,12 @@ private:
   //! Updates the WMNormalHints and adjusts things if they change
   void updateNormalHints();
   //! Updates the WMHints and adjusts things if they change
-  void updateWMHints();
+  /*!
+    @param initstate Whether to read the initial_state property from the
+                     WMHints. This should only be used during the mapping
+                     process.
+  */
+  void updateWMHints(bool initstate = false);
   //! Updates the window's title
   void updateTitle();
   //! Updates the window's icon title
@@ -577,6 +593,7 @@ BB    @param window The window id that the Client class should handle
   virtual void unmapHandler(const XUnmapEvent &e);
   virtual void destroyHandler(const XDestroyWindowEvent &e);
   virtual void reparentHandler(const XReparentEvent &e);
+  virtual void mapRequestHandler(const XMapRequestEvent &e);
 #if defined(SHAPE)
   virtual void shapeHandler(const XShapeEvent &e);
 #endif // SHAPE 

src/openbox.py

@@ -780,6 +780,7 @@ class Client(EventHandler,):
     State_Toggle = _openbox.Client_State_Toggle
     event_mask = _openbox.Client_event_mask
     no_propagate_mask = _openbox.Client_no_propagate_mask
+    ICONIC_DESKTOP = _openbox.Client_ICONIC_DESKTOP
     __swig_setmethods__["ignore_unmaps"] = _openbox.Client_ignore_unmaps_set
     __swig_getmethods__["ignore_unmaps"] = _openbox.Client_ignore_unmaps_get
     if _newclass:ignore_unmaps = property(_openbox.Client_ignore_unmaps_get,_openbox.Client_ignore_unmaps_set)
@@ -825,6 +826,7 @@ class Client(EventHandler,):
     def unmapHandler(*args): return apply(_openbox.Client_unmapHandler,args)
     def destroyHandler(*args): return apply(_openbox.Client_destroyHandler,args)
     def reparentHandler(*args): return apply(_openbox.Client_reparentHandler,args)
+    def mapRequestHandler(*args): return apply(_openbox.Client_mapRequestHandler,args)
     def __init__(self): raise RuntimeError, "No constructor defined"
     def __repr__(self):
         return "<C Client instance at %s>" % (self.this,)

src/openbox_wrap.cc

@@ -9564,6 +9564,28 @@ static PyObject *_wrap_Client_reparentHandler(PyObject *self, PyObject *args) {
 }
 
 
+static PyObject *_wrap_Client_mapRequestHandler(PyObject *self, PyObject *args) {
+    PyObject *resultobj;
+    ob::Client *arg1 = (ob::Client *) 0 ;
+    XMapRequestEvent *arg2 = 0 ;
+    PyObject * obj0  = 0 ;
+    PyObject * obj1  = 0 ;
+    
+    if(!PyArg_ParseTuple(args,(char *)"OO:Client_mapRequestHandler",&obj0,&obj1)) goto fail;
+    if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_ob__Client,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
+    if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_XMapRequestEvent,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
+    if (arg2 == NULL) {
+        PyErr_SetString(PyExc_TypeError,"null reference"); SWIG_fail; 
+    }
+    (arg1)->mapRequestHandler((XMapRequestEvent const &)*arg2);
+    
+    Py_INCREF(Py_None); resultobj = Py_None;
+    return resultobj;
+    fail:
+    return NULL;
+}
+
+
 static PyObject * Client_swigregister(PyObject *self, PyObject *args) {
     PyObject *obj;
     if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
@@ -11735,6 +11757,7 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"Client_unmapHandler", _wrap_Client_unmapHandler, METH_VARARGS },
 	 { (char *)"Client_destroyHandler", _wrap_Client_destroyHandler, METH_VARARGS },
 	 { (char *)"Client_reparentHandler", _wrap_Client_reparentHandler, METH_VARARGS },
+	 { (char *)"Client_mapRequestHandler", _wrap_Client_mapRequestHandler, METH_VARARGS },
 	 { (char *)"Client_swigregister", Client_swigregister, METH_VARARGS },
 	 { (char *)"new_Frame", _wrap_new_Frame, METH_VARARGS },
 	 { (char *)"delete_Frame", _wrap_delete_Frame, METH_VARARGS },
@@ -12061,6 +12084,7 @@ static swig_const_info swig_const_table[] = {
 { SWIG_PY_INT,     (char *)"Client_State_Toggle", (long) ob::Client::State_Toggle, 0, 0, 0},
 { SWIG_PY_INT,     (char *)"Client_event_mask", (long) ob::Client::event_mask, 0, 0, 0},
 { SWIG_PY_INT,     (char *)"Client_no_propagate_mask", (long) ob::Client::no_propagate_mask, 0, 0, 0},
+{ SWIG_PY_INT,     (char *)"Client_ICONIC_DESKTOP", (long) ob::Client::ICONIC_DESKTOP, 0, 0, 0},
 { SWIG_PY_INT,     (char *)"Frame_event_mask", (long) ob::Frame::event_mask, 0, 0, 0},
 { SWIG_PY_INT,     (char *)"MC_Frame", (long) ob::MC_Frame, 0, 0, 0},
 { SWIG_PY_INT,     (char *)"MC_Titlebar", (long) ob::MC_Titlebar, 0, 0, 0},