#include "dock.h"
#include <efltk/Fl_Window.h>
#include <efltk/Fl_Button.h>
#include <efltk/Fl.h>
#include <efltk/x.h>
#include <X11/Xatom.h>
//#include <vector>
#include <efltk/Fl_WM.h>
#include <unistd.h>
#include <X11/Xproto.h> //For CARD32
#define SYSTEM_TRAY_REQUEST_DOCK 0
#define SYSTEM_TRAY_BEGIN_MESSAGE 1
#define SYSTEM_TRAY_CANCEL_MESSAGE 2
Dock *currentDock; //Can't pass a pointer to handle_x11_event; must be a better way though
int panelheight=0;
struct straydata {
Window id;
Fl_Window *win;
straydata *next;
} *traydata;
Dock::Dock()
: Fl_Group(0,0,0,0)
{
register_notification_area();
// box(FL_THIN_DOWN_BOX);
color(FL_INVALID_COLOR); //Draw with parent color
layout_align(FL_ALIGN_RIGHT);
layout_spacing(1);
traydata=0;
end();
winstate=0;
}
Dock::~Dock() {
Atom selection_atom;
char selection_atom_name[20];
sprintf(selection_atom_name, "_NET_SYSTEM_TRAY_S%d", fl_screen);
selection_atom = XInternAtom (fl_display, selection_atom_name, false);
XSetSelectionOwner(fl_display, selection_atom, None, CurrentTime);
}
void Dock::register_notification_area()
{
Atom selection_atom;
char selection_atom_name[20];
sprintf(selection_atom_name, "_NET_SYSTEM_TRAY_S%d", fl_screen);
selection_atom = XInternAtom (fl_display, selection_atom_name, false);
if (XGetSelectionOwner(fl_display, selection_atom)) {
printf("The notification area service is being provided by a different program. I'll just handle EDE components. \n");
return;
}
//Register
XSetSelectionOwner(fl_display, selection_atom, fl_message_window, CurrentTime);
//Check registration was successful
if (XGetSelectionOwner(fl_display, selection_atom) != fl_message_window) {
printf("Could not register as notification area service.\n");
return;
}
XClientMessageEvent xev;
xev.type = ClientMessage;
xev.message_type = XInternAtom (fl_display, "MANAGER", false);
xev.format = 32;
xev.data.l[0] = CurrentTime;
xev.data.l[1] = selection_atom;
xev.data.l[2] = fl_message_window;
xev.data.l[3] = 0;
xev.data.l[4] = 0;
XSendEvent (fl_display, RootWindow(fl_display, fl_screen), false, StructureNotifyMask, (XEvent *)&xev);
opcode = XInternAtom(fl_display, "_NET_SYSTEM_TRAY_OPCODE", false);
message_data = XInternAtom(fl_display,"_NET_SYSTEM_TRAY_MESSAGE_DATA", false);
currentDock = this;
Fl::add_handler(handle_x11_event);
}
int Dock::handle_x11_event(int e)
{
if (fl_xevent.type == ClientMessage && fl_xevent.xclient.message_type == currentDock->opcode ) {
if (fl_xevent.xclient.data.l[1] == SYSTEM_TRAY_REQUEST_DOCK) {
currentDock->embed_window(fl_xevent.xclient.data.l[2]);
return true;
}
if (fl_xevent.xclient.data.l[1] == SYSTEM_TRAY_BEGIN_MESSAGE) {
return true;
}
if (fl_xevent.xclient.data.l[1] == SYSTEM_TRAY_CANCEL_MESSAGE) {
return true;
}
} else if (fl_xevent.type == DestroyNotify) {
XDestroyWindowEvent xev = fl_xevent.xdestroywindow;
// Loop trough linked list to find destroyed window
struct straydata *p=traydata;
struct straydata *p1=0;
while (p!=0) {
if (p->id == xev.window) {
currentDock->remove_from_tray(p->win);
delete p->win;
if (p1 == 0)
traydata = p->next;
else
p1->next = p->next;
delete p;
break;
}
p1=p;
p=p->next;
}
}
return false;
}
// Helper for Dock::embed_window()
// Kopied from kdelibs/kdeui/qxembed.cpp
static int get_parent(Window winid, Window *out_parent)
{
Window root, *children=0;
unsigned int nchildren;
int st = XQueryTree(fl_display, winid, &root, out_parent, &children, &nchildren);
if (st && children)
XFree(children);
return st;
}
void Dock::embed_window(Window id)
{
if (id==0) return;
// Store window id in a linked list structure
struct straydata *p=traydata;
struct straydata *p1;
while (p!=0) {
// Sometimes the app will reuse the same id on next start?
// if (p->id == id)
// return;
p1=p;
p=p->next;
}
p = new straydata;
if (traydata == 0) { traydata=p; } else { p1->next = p; }
p->id = id;
p->next = 0;
Fl_Window *win = new Fl_Window(24, 24);
win->end();
this->add_to_tray(win);
win->show();
p->win = win;
// printf("id: %ld -> %ld\n", id, fl_xid(win));
XReparentWindow(fl_display, id, fl_xid(win), 0, 0);
// Hack to get KDE icons working...
Window parent = 0;
get_parent(id, &parent);
// printf(" ++ parent: %ld\n", parent);
XMapWindow(fl_display, id);
//Need to know when child dies
XSelectInput(fl_display, fl_xid(win), SubstructureNotifyMask);
/* Some ideas from KDE code... consider using (sometime)
----------------
Does this have any effect?
static Atom hack_atom = XInternAtom( fl_display, "_KDE_SYSTEM_TRAY_EMBEDDING", False );
XChangeProperty( fl_display, id, hack_atom, hack_atom, 32, PropModeReplace, NULL, 0 );
.....
XDeleteProperty( fl_display, id, hack_atom );
----------------
Force window to withdraw (?)
// Helper for Dock::embed_window()
// Kopied from kdelibs/kdeui/qxembed.cpp
static bool wstate_withdrawn( Window winid )
{
static Atom _XA_WM_STATE = 0;
if(!_XA_WM_STATE) _XA_WM_STATE = XInternAtom(fl_display, "WM_STATE", False);
Atom type;
int format;
unsigned long length, after;
unsigned char *data;
int r = XGetWindowProperty( fl_display, winid, _XA_WM_STATE, 0, 2,
false, AnyPropertyType, &type, &format,
&length, &after, &data );
bool withdrawn = true;
// L1610: Non managed windows have no WM_STATE property.
// Returning true ensures that the loop L1711 stops.
if ( r == Success && data && format == 32 ) {
uint32 *wstate = (uint32*)data;
withdrawn = (*wstate == WithdrawnState );
XFree( (char *)data );
}
return withdrawn;
}
if ( !wstate_withdrawn(id) ) {
XWithdrawWindow(fl_display, id, fl_screen);
XFlush(fl_display);
// L1711: See L1610
while (!wstate_withdrawn(id))
sleep(1);
}
----------------
XEMBED support:
#define XEMBED_EMBEDDED_NOTIFY 0
#define XEMBED_WINDOW_ACTIVATE 1
#define XEMBED_WINDOW_DEACTIVATE 2
#define XEMBED_REQUEST_FOCUS 3
#define XEMBED_FOCUS_IN 4
#define XEMBED_FOCUS_OUT 5
#define XEMBED_FOCUS_NEXT 6
#define XEMBED_FOCUS_PREV 7
#define XEMBED_MODALITY_ON 10
// L0500: Helper to send XEmbed messages.
static void sendXEmbedMessage( Window window, long message, long detail = 0,
long data1 = 0, long data2 = 0)
{
static Atom xembed=0;
if (!xembed) xembed = XInternAtom( fl_display, "_XEMBED", False );
if (!window) return;
XEvent ev;
memset(&ev, 0, sizeof(ev));
ev.xclient.type = ClientMessage;
ev.xclient.window = window;
ev.xclient.message_type = xembed;
ev.xclient.format = 32;
ev.xclient.data.l[0] = CurrentTime;
ev.xclient.data.l[1] = message;
ev.xclient.data.l[2] = detail;
ev.xclient.data.l[3] = data1;
ev.xclient.data.l[4] = data2;
XSendEvent(fl_display, window, false, NoEventMask, &ev);
XSync(fl_display, false);
}
static Atom _XA_XEMBED_INFO = 0;
if(!_XA_XEMBED_INFO) _XA_XEMBED_INFO = XInternAtom(fl_display, "_XEMBED_INFO", False);
int status=1;
CARD32* prop = (CARD32*)getProperty(id, _XA_XEMBED_INFO, XA_CARDINAL, 0, &status);
if (status == 0) {
// Not XEMBED
.......
} else {
sendXEmbedMessage( id, XEMBED_EMBEDDED_NOTIFY, 0, fl_xid(win) );
}
*/
}
void Dock::add_to_tray(Fl_Widget *w)
{
insert(*w, 0);
w->layout_align(FL_ALIGN_LEFT);
w->show();
int new_width = this->w() + w->width() + layout_spacing();
this->w(new_width);
parent()->relayout();
Fl::redraw();
}
void Dock::remove_from_tray(Fl_Widget *w)
{
remove(w);
int new_width = this->w() - w->width() - layout_spacing();
this->w(new_width);
parent()->relayout();
Fl::redraw();
}
int Dock::handle(int event) {
struct straydata *p=traydata;
while (p!=0) {
Fl_Window *w = p->win;
if (Fl::event_x()>=w->x() && Fl::event_x()<=(w->x() + w->w())
&& Fl::event_y()>=w->y() && Fl::event_y()<=(w->y() + w->h())) {
int ret = w->handle(event);
w->throw_focus();
return ret;
}
p=p->next;
}
return Fl_Group::handle(event);
}
syntax highlighted by Code2HTML, v. 0.9.1