path: root/src/qtraylabel.cpp

/*
 * Copyright (C) 2004 Girish Ramakrishnan All Rights Reserved.
 *
 * This is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This software is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this software; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
 * USA.
 */

// $Id: qtraylabel.cpp,v 1.31 2005/06/21 10:04:36 cs19713 Exp $

// Include all TQt includes before X
#include <tqstring.h>
#include <tqevent.h>
#include <tqpoint.h>
#include <tqtooltip.h>
#include <tqtimer.h>
#include <tqimage.h>
#include <tqpixmap.h>
#include <tqfileinfo.h>
#include <tqapplication.h>
#include "trace.h"
#include "qtraylabel.h"

#include <kiconloader.h>
#include <kglobal.h>

#include <X11/cursorfont.h>
#include <X11/xpm.h>
#include <X11/Xmu/WinUtil.h>

#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>

#include "util.h"

void TQTrayLabel::initialize(void)
{
  mDocked = false;
  mWithdrawn = true;
  mBalloonTimeout = 4000;
  mSkippingTaskbar = false;
  mDockWhenMinimized = true;
  mDesktop = 666; // setDockedWindow would set it a saner value

  // Balloon's properties are set to match a TQt tool tip (see TQt source)
  mBalloon = new TQLabel(0, "balloon", WType_TopLevel | WStyle_StaysOnTop |
                                      WStyle_Customize | WStyle_NoBorder | 
                                      WStyle_Tool | WX11BypassWM);
  mBalloon->setFont(TQToolTip::font());
  mBalloon->setPalette(TQToolTip::palette());
  mBalloon->setAlignment(TQt::AlignLeft | TQt::AlignTop);
  mBalloon->setAutoMask(FALSE);
  mBalloon->setAutoResize(true);
  setAlignment(TQt::AlignCenter);
  setBackgroundMode(X11ParentRelative);

  connect(&mRealityMonitor, SIGNAL(timeout()), this, SLOT(realityCheck()));
  setDockedWindow(mDockedWindow);

  sysTrayStatus(TQPaintDevice::x11AppDisplay(), &mSysTray);
  // Subscribe to system tray window notifications
  if (mSysTray != None)
    subscribe(TQPaintDevice::x11AppDisplay(), mSysTray,
              StructureNotifyMask, true);
}

// Describe ourselves in a few words
const char *TQTrayLabel::me(void) const
{
  static char temp[100];
  snprintf(temp, sizeof(temp), "(%s,PID=%i,WID=0x%x)", 
      mProgName[0].latin1(), mPid, (unsigned) mDockedWindow);
  return temp;
}

TQTrayLabel::TQTrayLabel(Window w, TQWidget* parent, const TQString& text)
  :TQLabel(parent, text.utf8(), WStyle_Customize | WStyle_NoBorder | WStyle_Tool),
   mDockedWindow(w), mPid(0)
{
  initialize();
}

TQTrayLabel::TQTrayLabel(const TQStringList& pname, pid_t pid, TQWidget* parent)
 :TQLabel(parent, "TrayLabel", WStyle_Customize | WStyle_NoBorder | WStyle_Tool),
  mDockedWindow(None), mProgName(pname), mPid(pid)
{
  if (pname[0].at(0) != '/' && pname[0].find('/', 1) > 0) 
    mProgName[0] = TQFileInfo(pname[0]).absFilePath(); // convert to absolute
  initialize();
}

TQTrayLabel::~TQTrayLabel()
{
  TRACE("%s Goodbye", me());
  if (mDockedWindow == None) return;
  // Leave the docked window is some sane state
  mSkippingTaskbar = false;
  skipTaskbar();
  map();
}

/*
 * Scans the windows in the desktop and checks if a window exists that we might
 * be interested in
 */
void TQTrayLabel::scanClients()
{
   Window r, parent, *children;
   unsigned nchildren = 0;
   Display *display = TQPaintDevice::x11AppDisplay();
   TQString ename = TQFileInfo(mProgName[0]).fileName(); // strip out the path

   XQueryTree(display, tqt_xrootwin(), &r, &parent, &children, &nchildren);
   TRACE("%s nchildren=%i", me(), nchildren);
   for(unsigned i=0; i<nchildren; i++)
   {
     Window w = XmuClientWindow(display, children[i]);
     TRACE("\t%s checking 0x%x", me(), (unsigned) w);
     if (!isNormalWindow(display, w)) continue;
     if (analyzeWindow(display, w, mPid, ename.latin1()))
     {
       TRACE("\t%s SOULMATE FOUND", me());
       setDockedWindow(w);
       break;
     }
  }
}

/*
 * Do a reality check :). Note that this timer runs only when required. Does 3
 * things,
 *  1) If the system tray had disappeared, checks for arrival of new system tray
 *  2) Check root window subscription since it is overwritten by TQt (see below)
 *  3) Checks health of the process whose windows we are docking
 */
void TQTrayLabel::realityCheck(void)
{
  if (mSysTray == None)
  {
    // Check the system tray status if we were docked
    if (sysTrayStatus(TQPaintDevice::x11AppDisplay(), &mSysTray)
            != SysTrayPresent) return; // no luck

    TRACE("%s System tray present", me());
    dock();
    subscribe(TQPaintDevice::x11AppDisplay(), mSysTray,
              StructureNotifyMask, true);
    mRealityMonitor.stop();
    return;
  }

  /*
   * I am not sure when, but TQt at some point in time overwrites our
   * subscription (SubstructureNotifyMask) on the root window. So, we check
   * the status of root window subscription periodically. Now, from the time 
   * TQt overwrote our subscription to the time we discovered it, the
   * window we are looking for could have been mapped and we would have never
   * been informed (since TQt overrwrote the subscription). So we have to
   * scan existing client list and dock. I have never seen this happen 
   * but I see it likely to happen during session restoration
   */
  Display *display = TQPaintDevice::x11AppDisplay();
  XWindowAttributes attr;
  XGetWindowAttributes(display, tqt_xrootwin(), &attr);

  if (!(attr.your_event_mask & SubstructureNotifyMask)) 
  {
    subscribe(display, None, SubstructureNotifyMask, true);
    TRACE("%s rescanning clients since qt overrode mask", me());
    scanClients();
  }

  if (mPid)
  {
     // Check process health
    int status;
    if (waitpid(mPid, &status, WNOHANG) == 0) return; // still running
    TRACE("%s processDead", me());
    mPid = 0;
    processDead();
  }
}

/*
 * Sends a message to the WM to show this window on all the desktops
 */
void TQTrayLabel::showOnAllDesktops(void)
{
  TRACE("Showing on all desktops");
  Display *d = TQPaintDevice::x11AppDisplay();
  long l[5] = { -1, 0, 0, 0, 0 }; // -1 = all, 0 = Desktop1, 1 = Desktop2 ...
  sendMessage(d, tqt_xrootwin(), mDockedWindow, "_NET_WM_DESKTOP", 32,
              SubstructureNotifyMask | SubstructureRedirectMask, l, sizeof(l));
}

// System tray messages
const long SYSTEM_TRAY_REQUEST_DOCK = 0;
const long SYSTEM_TRAY_BEGIN_MESSAGE = 1;
const long SYSTEM_TRAY_CANCEL_MESSAGE = 2;

/*
 * Add the window to the system tray. Different WM require different hints to be
 * set. We support the following (Google for more information),
 * 1. GNOME - SYSTEM_TRAY_REQUEST_DOCK (freedesktop.org)
 * 2. KDE 3.x and above - _KDE_NET_WM_SYSTEM_TRAY_WINDOW_FOR
 * 3. Older KDE - KWM_DOCKWINDOW (Untested)
 */
void TQTrayLabel::dock(void)
{
  TRACE("%s", me());
  mDocked = true;
  if (mDockedWindow == None) return;			// nothing to add
  
  if (mSysTray == None)                   // no system tray yet
  {
    TRACE("%s starting reality monitor", me());
    mRealityMonitor.start(500);
    return;
  }

  Display *display = TQPaintDevice::x11AppDisplay();
  Window wid = winId();

  // 1. GNOME and NET WM Specification
  long l[5] = { CurrentTime, SYSTEM_TRAY_REQUEST_DOCK, wid, 0, 0 };
  sendMessage(display, mSysTray, mSysTray, "_NET_SYSTEM_TRAY_OPCODE", 
              32, 0L, l, sizeof(l));

  // 2. KDE 3.x and above
  Atom tray_atom = 
    XInternAtom(display, "_KDE_NET_WM_SYSTEM_TRAY_WINDOW_FOR", False);
  XChangeProperty(display, wid, tray_atom, XA_WINDOW, 32,
		              PropModeReplace, (unsigned char *) &wid, 1);

  // 3. All other KDEs 
  tray_atom = XInternAtom(display, "KWM_DOCKWINDOW", False);
  XChangeProperty(display, wid, tray_atom, XA_WINDOW, 32,
                  PropModeReplace, (unsigned char *) &wid, 1);

  TRACE("%s ", me());

  handleTitleChange();
  handleIconChange();
	
	if (mProgName.count() == 0) setAppName(mClass);

  /*
   * For Gnome, a delay is required before we do a show (dont ask me why)
   * If I do a show() without any delay, sometimes the icon has width=1 pixel
   * even though the minimumSizeHint = 24, 24. I have successfully got it
   * working with with a delay of as little as 50ms. But since I
   * dont understand why this delay is required, I am justifiably paranoid
   */
  TQTimer::singleShot(500, this, SLOT(show()));

  // let the world know
  emit docked(this);
  emit docked();
}

/*
 * Undocks. Removes us from the system tray. The spec doesnt say how an icon
 * can be removed from the tray. KDE Spec says XUnmapWindow or XWithdraw should
 * be used. It works but the system tray does not fill the void that we left
 * in the tray. Looks like the system tray will resize only for DestroyEvents
 */
void TQTrayLabel::undock(void)
{
  TRACE("%s stopping reality monitor", me());
  mRealityMonitor.stop();
  XUnmapWindow(TQPaintDevice::x11AppDisplay(), winId());
  emit undocked(this);
  emit undocked();
}

/*
 * Maps the window from the same place it was withdrawn from
 */
void TQTrayLabel::map(void)
{
  TRACE("%s", me());
  mWithdrawn = false;
  if (mDockedWindow == None) return;
  
  Display *display = TQPaintDevice::x11AppDisplay();

  if (mDesktop == -1)
  {
      /*
       * We track _NET_WM_DESKTOP changes in the x11EventFilter. Its used here.
       * _NET_WM_DESKTOP is set by the WM to the active desktop for newly
       * mapped windows (like this one) at some point in time. We give
       * the WM 200ms to do that. We will override that value to -1 (all
       * desktops) on showOnAllDesktops().        
       */
       TQTimer::singleShot(200, this, SLOT(showOnAllDesktops()));
  }

  /*
   * A simple XMapWindow would not do. Some applications like xmms wont
   * redisplay its other windows (like the playlist, equalizer) since the 
   * Withdrawn->Normal state change code does not map them. So we make the
   * window go through Withdrawn->Iconify->Normal state.
   */
  XWMHints *wm_hint = XGetWMHints(display, mDockedWindow);
  if (wm_hint) 
  {
    wm_hint->initial_state = IconicState;
    XSetWMHints(display, mDockedWindow, wm_hint);
    XFree(wm_hint);
  }

  XMapWindow(display, mDockedWindow);
  mSizeHint.flags = USPosition;	// Obsolete ?
  XSetWMNormalHints(display, mDockedWindow, &mSizeHint);
  // make it the active window
  long l[5] = { None, CurrentTime, None, 0, 0 };
  sendMessage(display, tqt_xrootwin(), mDockedWindow, "_NET_ACTIVE_WINDOW", 32,
	            SubstructureNotifyMask | SubstructureRedirectMask, l, sizeof(l));
  // skipTaskbar modifies _NET_WM_STATE. Make sure we dont override WMs value
  TQTimer::singleShot(230, this, SLOT(skipTaskbar()));
  // disable docking when minized for some time (since we went to Iconic state)
  mDockWhenMinimized = !mDockWhenMinimized;
  TQTimer::singleShot(230, this, SLOT(toggleDockWhenMinimized()));
}

void TQTrayLabel::withdraw(void)
{
  TRACE("%s", me());
  mWithdrawn = true;
  if (mDockedWindow == None) return;

  Display *display = TQPaintDevice::x11AppDisplay();
  int screen = DefaultScreen(display);
  long dummy;
 
  XGetWMNormalHints(display, mDockedWindow, &mSizeHint, &dummy);

  /*
   * A simple call to XWithdrawWindow wont do. Here is what we do:
   * 1. Iconify. This will make the application hide all its other windows. For 
   *    example, xmms would take off the playlist and equalizer window.
   * 2. Next tell the WM, that we would like to go to withdrawn state. Withdrawn
   *    state will remove us from the taskbar.
   *    Reference: ICCCM 4.1.4 Changing Window State
   */
  XIconifyWindow(display, mDockedWindow, screen);	// good for effects too
  XUnmapWindow(display, mDockedWindow);
  XUnmapEvent ev;
  memset(&ev, 0, sizeof(ev));
  ev.type = UnmapNotify;
  ev.display = display;
  ev.event = tqt_xrootwin();
  ev.window = mDockedWindow;
  ev.from_configure = false;
  XSendEvent(display, tqt_xrootwin(), False,
             SubstructureRedirectMask|SubstructureNotifyMask, (XEvent *)&ev);
  XSync(display, False);
}

/*
 * Skipping the taskbar is a bit painful. Basically, NET_WM_STATE needs to 
 * have _NET_WM_STATE_SKIP_TASKBAR. NET_WM_STATE needs to be updated 
 * carefully since it is a set of states.
 */
void TQTrayLabel::skipTaskbar(void)
{
  Atom __attribute__ ((unused)) type;
  int __attribute__ ((unused)) format;
  unsigned long __attribute__ ((unused)) left;
  Atom *data = NULL;
  unsigned long nitems = 0, num_states = 0;
  Display *display = TQPaintDevice::x11AppDisplay();

  TRACE("%s", me());
  Atom _NET_WM_STATE = XInternAtom(display, "_NET_WM_STATE", True);
  Atom skip_atom = XInternAtom(display, "_NET_WM_STATE_SKIP_TASKBAR", False);
  int ret = XGetWindowProperty(display, mDockedWindow, _NET_WM_STATE, 0,
			                         20, False, AnyPropertyType, &type, &format,
			                         &nitems, &left, (unsigned char **) &data);
  Atom *old_states = (Atom *) data;
  bool append = true, replace = false;

  if ((ret == Success) && data)
  {
    // Search for the skip_atom. Stop when found
    for (num_states = 0; num_states < nitems; num_states++)
      if (old_states[num_states] == skip_atom) break;

    if (mSkippingTaskbar)
      append = (num_states >= nitems);
    else
    {
      if (num_states < nitems)
      {
        replace = true;		// need to remove skip_atom
        for (; num_states < nitems - 1; num_states++)
          old_states[num_states] = old_states[num_states + 1];
      }
    }
    XFree(data);
  }

  TRACE("%s SkippingTaskar=%i append=%i replace=%i", me(), mSkippingTaskbar,
                                                     append, replace);

  if (mSkippingTaskbar)
  {
    if (append)
      XChangeProperty(display, mDockedWindow, _NET_WM_STATE, XA_ATOM, 32, 
                      PropModeAppend, (unsigned char *) &skip_atom, 1);
  }
  else if (replace)
    XChangeProperty(display, mDockedWindow, _NET_WM_STATE, XA_ATOM, 32, 
                    PropModeReplace, (unsigned char *) &old_states, nitems - 1);
}

void TQTrayLabel::setSkipTaskbar(bool skip)
{
  TRACE("%s Skip=%i", me(), skip);
  mSkippingTaskbar = skip;
  if (mDockedWindow != None && !mWithdrawn) skipTaskbar();
}

/*
 * Closes a window by sending _NET_CLOSE_WINDOW. For reasons best unknown we 
 * need to first map and then send the request.
 */
void TQTrayLabel::close(void)
{
  TRACE("%s", me());
  Display *display = TQPaintDevice::x11AppDisplay();
  long l[5] = { 0, 0, 0, 0, 0 };
  map();
  sendMessage(display, tqt_xrootwin(), mDockedWindow, "_NET_CLOSE_WINDOW", 32,
              SubstructureNotifyMask | SubstructureRedirectMask, 
              l, sizeof(l));
}

/*
 * Sets the tray icon. If the icon failed to load, we revert to application icon
 */
void TQTrayLabel::setTrayIcon(const TQString& icon)
{
  mCustomIcon = icon;
  if (TQPixmap(mCustomIcon).isNull()) mCustomIcon = TQString::null;
  TRACE("%s mCustomIcon=%s", me(), mCustomIcon.latin1());
  updateIcon();
}

/*
 * Sets the docked window to w. 
 *   A) Start/stop reality timer. 
 *   B) Subscribe/Unsubscribe for root/w notifications as appropriate
 *   C) And of course, dock the window and apply some settings
 */
void TQTrayLabel::setDockedWindow(Window w)
{
  TRACE("%s %s reality monitor", me(), 
        mDockedWindow==None ? "Starting" : "Stopping");

  // Check if we are allowed to dock this window (allows custom rules)
  if (w != None) mDockedWindow = canDockWindow(w) ? w : None;
  else mDockedWindow = None;

  if (mDockedWindow == None) mRealityMonitor.start(500);
  else mRealityMonitor.stop();

  Display *d = TQPaintDevice::x11AppDisplay();
  
  // Subscribe for window or root window events
  if (w == None) subscribe(d, None, SubstructureNotifyMask, true);
  else
  {
    if (canUnsubscribeFromRoot()) 
      subscribe(d, None, ~SubstructureNotifyMask, false);
    else subscribe(d, None, SubstructureNotifyMask, true);
      
    subscribe(d, w, 
              StructureNotifyMask | PropertyChangeMask | 
							VisibilityChangeMask | FocusChangeMask, 
              true);
  }

  if (mDocked && w!=None)
  {
    // store the desktop on which the window is being shown
    getCardinalProperty(d, mDockedWindow,  
                        XInternAtom(d, "_NET_WM_DESKTOP", True), &mDesktop);

    if (mWithdrawn) 
      // show the window for sometime before docking
      TQTimer::singleShot(1000, this, SLOT(withdraw()));
    else map();
    dock();
  }
}

/*
 * Balloon text. Overload this if you dont like the way things are ballooned
 */
void TQTrayLabel::balloonText()
{
  TRACE("%s BalloonText=%s ToolTipText=%s", me(),
        mBalloon->text().latin1(), TQToolTip::textFor(this).latin1());
                                          
  if (mBalloon->text() == TQToolTip::textFor(this)) return;
#if 0 // I_GOT_NETWM_BALLOONING_TO_WORK
  // if you can get NET WM ballooning to work let me know
  static int id = 1;
  long l[5] = { CurrentTime, SYSTEM_TRAY_BEGIN_MESSAGE, 2000,
                mTitle.length(), id++
  };
  sendMessage(display, mSystemTray, winId(), "_NET_SYSTEM_TRAY_OPCODE", 32, 
              SubstructureNotifyMask | SubstructureRedirectMask,
              l, sizeof(l));
  int length = mTitle.length();
  const char *data = mTitle.latin1();
  while (length > 0)
  {
    sendMessage(display, mSystemTray, winId(), "_NET_SYSTEM_TRAY_MESSAGE_DATA", 8,
                SubstructureNotifyMask | SubstructureRedirectMask,
                (void *) data, length > 20 ? 20 : length);
    length -= 20;
    data += 20;
  }
#else
  // Manually do ballooning. See the TQt ToolTip code
  TQString oldText = mBalloon->text();
  mBalloon->setText(TQToolTip::textFor(this));
  if (oldText.isEmpty()) return; // dont tool tip the first time
  TQPoint p = mapToGlobal(TQPoint(0, -1 - mBalloon->height()));
  if (p.x() + mBalloon->width() > TQApplication::desktop()->width())
    p.setX(p.x() + width() - mBalloon->width());

  if (p.y() < 0) p.setY(height() + 1);

  mBalloon->move(p);
  mBalloon->show();
  TQTimer::singleShot(mBalloonTimeout, mBalloon, SLOT(hide()));
#endif
}

/*
 * Update the title in the menu. Balloon the title change if necessary
 */
void TQTrayLabel::handleTitleChange(void)
{
  Display *display = TQPaintDevice::x11AppDisplay();
  char *window_name = NULL;

  XFetchName(display, mDockedWindow, &window_name);
  mTitle = window_name;
  TRACE("%s has title [%s]", me(), mTitle.latin1());
  if (window_name) XFree(window_name);

  XClassHint ch;
  if (XGetClassHint(display, mDockedWindow, &ch))
  {
    if (ch.res_class) mClass = TQString(ch.res_class);
    else if (ch.res_name) mClass = TQString(ch.res_name);

    if (ch.res_class) XFree(ch.res_class);
    if (ch.res_name) XFree(ch.res_name);
  }

  updateTitle();
  if (mBalloonTimeout) balloonText();
}

/*
 * Overload this if you want a tool tip format that is different from the one
 * below i.e "Title [Class]".
 */
void TQTrayLabel::updateTitle()
{
  TRACE("%s", me());
  TQString text = mTitle + " [" + mClass + "]";
  TQToolTip::remove(this);
  TQToolTip::add(this, text);

  if (mBalloonTimeout) balloonText();
}

void TQTrayLabel::handleIconChange(void)
{
  char **window_icon = NULL;

  TRACE("%s", me());
  if (mDockedWindow == None) return;

  Display *display = TQPaintDevice::x11AppDisplay();
  XWMHints *wm_hints = XGetWMHints(display, mDockedWindow);
  if (wm_hints != NULL)
  {
    if (!(wm_hints->flags & IconMaskHint))
      wm_hints->icon_mask = None;
    /*
     * We act paranoid here. Progams like KSnake has a bug where 
     * IconPixmapHint is set but no pixmap (Actually this happens with
     * quite a few KDE programs) X-(
     */
    if ((wm_hints->flags & IconPixmapHint) && (wm_hints->icon_pixmap))
      XpmCreateDataFromPixmap(display, &window_icon, wm_hints->icon_pixmap,
                              wm_hints->icon_mask, NULL);
    XFree(wm_hints);
  }
  TQImage image;
  if (!window_icon) 
  {
    image = KGlobal::iconLoader()->loadIcon("question", KIcon::NoGroup, KIcon::SizeMedium);
  }
  else image = TQPixmap((const char **) window_icon).convertToImage();
  if (window_icon) XpmFree(window_icon);
  mAppIcon = image.smoothScale(24, 24); // why?
  setMinimumSize(mAppIcon.size());
  setMaximumSize(mAppIcon.size());

  updateIcon();
}

/*
 * Overload this to possibly do operations on the pixmap before it is set
 */
void TQTrayLabel::updateIcon()
{
  TRACE("%s", me());
  setPixmap(mCustomIcon.isEmpty() ? mAppIcon : mCustomIcon);
  erase();
  TQPaintEvent pe(rect());
  paintEvent(&pe);
}

/*
 * Mouse activity on our label. RightClick = Menu. LeftClick = Toggle Map
 */
void TQTrayLabel::mouseReleaseEvent(TQMouseEvent * ev)
{
  emit clicked(ev->button(), ev->globalPos());
}

/*
 * Track drag event
 */
void TQTrayLabel::dragEnterEvent(TQDragEnterEvent *ev)
{
  ev->accept(); 
  map();
}

/*
 * Event dispatcher
 */
bool TQTrayLabel::x11EventFilter(XEvent *ev)
{
  XAnyEvent *event = (XAnyEvent *)ev;

  if (event->window == mSysTray)
  {
    if (event->type != DestroyNotify) return FALSE; // not interested in others
    emit sysTrayDestroyed();
    mSysTray = None;
    TRACE("%s SystemTray disappeared. Starting timer", me());
    mRealityMonitor.start(500);
    return true;
  }
  else if (event->window == mDockedWindow)
  {
    if (event->type == DestroyNotify)
      destroyEvent();
    else if (event->type == PropertyNotify)
      propertyChangeEvent(((XPropertyEvent *)event)->atom);
    else if (event->type == VisibilityNotify)
    {
      if (((XVisibilityEvent *) event)->state == VisibilityFullyObscured)
        obscureEvent();
    }
    else if (event->type == MapNotify)
    {
      mWithdrawn = false;
      mapEvent();
    }
    else if (event->type == UnmapNotify)
    {
      mWithdrawn = true;
      unmapEvent();
    }
		else if (event->type == FocusOut)
		{
			focusLostEvent();
		}
    return true; // Dont process this again
  }

  if (mDockedWindow != None || event->type != MapNotify) return FALSE;

  TRACE("%s Will analyze window 0x%x", me(), (int)((XMapEvent *)event)->window);
  // Check if this window is the soulmate we are looking for
  Display *display = TQPaintDevice::x11AppDisplay();
  Window w = XmuClientWindow(display, ((XMapEvent *) event)->window);
  if (!isNormalWindow(display, w)) return FALSE;
  if (!analyzeWindow(display, w, mPid, 
         TQFileInfo(mProgName[0]).fileName().latin1())) return FALSE;
  // All right. Lets dock this baby
  setDockedWindow(w);
  return true;
}

void TQTrayLabel::minimizeEvent(void)
{
  TRACE("minimizeEvent");
  if (mDockWhenMinimized) withdraw();
}

void TQTrayLabel::destroyEvent(void)
{
  TRACE("%s destroyEvent", me());
  setDockedWindow(None);
  if (!mPid) undock();
}

void TQTrayLabel::propertyChangeEvent(Atom property)
{
  Display *display = TQPaintDevice::x11AppDisplay();
  static Atom WM_NAME = XInternAtom(display, "WM_NAME", True);
  static Atom WM_ICON = XInternAtom(display, "WM_ICON", True);
  static Atom WM_STATE = XInternAtom(display, "WM_STATE", True);
  static Atom _NET_WM_STATE = XInternAtom(display, "_NET_WM_STATE", True);
  static Atom _NET_WM_DESKTOP = XInternAtom(display, "_NET_WM_DESKTOP", True);

  if (property == WM_NAME)
    handleTitleChange();
  else if (property == WM_ICON)
    handleIconChange();
  else if (property == _NET_WM_STATE)
    ; // skipTaskbar();
  else if (property == _NET_WM_DESKTOP)
  {
      TRACE("_NET_WM_DESKTOP changed");
      getCardinalProperty(display, mDockedWindow, _NET_WM_DESKTOP, &mDesktop);
  }
  else if (property == WM_STATE)
  {
    Atom type = None;
    int format;
    unsigned long nitems, after;
    unsigned char *data = NULL;
    int r = XGetWindowProperty(display, mDockedWindow, WM_STATE,
			       0, 1, False, AnyPropertyType, &type,
			       &format, &nitems, &after, &data);

    if ((r == Success) && data && (*(long *) data == IconicState))
    {
      minimizeEvent();
      XFree(data);
    }
  }
}

// Session Management
bool TQTrayLabel::saveState(TQSettings &settings)
{
  TRACE("%s saving state", me());
  settings.writeEntry("/Application", mProgName.join(" "));
  settings.writeEntry("/CustomIcon", mCustomIcon);
  settings.writeEntry("/BalloonTimeout", mBalloonTimeout);
  settings.writeEntry("/DockWhenMinimized", mDockWhenMinimized);
  settings.writeEntry("/SkipTaskbar", mSkippingTaskbar);
  settings.writeEntry("/Withdraw", mWithdrawn);
  return true;
}

bool TQTrayLabel::restoreState(TQSettings &settings)
{
  TRACE("%s restoring state", me());
  mCustomIcon = settings.readEntry("/CustomIcon");
  setBalloonTimeout(settings.readNumEntry("/BalloonTimeout"));
  setDockWhenMinimized(settings.readBoolEntry("/DockWhenMinimized"));
  setSkipTaskbar(settings.readBoolEntry("/SkipTaskbar"));
  mWithdrawn = settings.readBoolEntry("/Withdraw");

  dock();

  /*
   * Since we are getting restored, it is likely that the application that we
   * are interested in has already been started (if we didnt launch it). 
   * So we scan the list of windows and grab the first one that satisfies us
   * This implicitly assumes that if mPid!=0 then we launched it. Wait till
   * the application really shows itself up before we do a scan (the reason
   * why we have 2s
   */
   if (!mPid) TQTimer::singleShot(2000, this, SLOT(scanClients()));

   return true;
}

// End kicking butt


#include "qtraylabel.moc"