ede/ede-panel/taskbutton.cpp

622 lines
14 KiB
C++
Raw Normal View History

2009-02-20 16:04:52 +03:00
#include "taskbutton.h"
#include <stdlib.h>
#include <stdio.h>
#include <efltk/fl_draw.h>
#include <efltk/Fl_Image.h>
#include <efltk/Fl.h>
#include <efltk/Fl_Config.h>
#include <efltk/Fl_Box.h>
#include <efltk/Fl_Value_Input.h>
#include <efltk/Fl_Divider.h>
#include "../edewm/Windowmanager.h"
// Forward declaration
static int GetState(Window w);
static bool IsWindowManageable(Window w);
Fl_Menu_ *TaskButton::menu = 0;
TaskButton *TaskButton::pushed = 0;
int calculate_height(Fl_Menu_ *m)
{
Fl_Style *s = Fl_Style::find("Menu");
int Height = s->box->dh();
for(int n=0; n<m->children(); n++)
{
Fl_Widget *i = m->child(n);
if(!i) break;
if(!i->visible()) continue;
fl_font(i->label_font(), i->label_size());
Height += i->height()+s->leading;
}
return Height;
}
void task_button_cb(TaskButton *b, Window w)
{
if(Fl::event_button()==FL_RIGHT_MOUSE)
{
// Window will lose focus so lets reflect this on taskbar
TaskBar::active = 0;
// 'pushed' lets the menu_cb() know which button was pressed
TaskButton::pushed = b;
// Create menu
TaskButton::menu->color(b->color());
TaskButton::menu->popup(Fl::event_x(), Fl::event_y()-calculate_height(TaskButton::menu));
}
else
{
if(TaskBar::active==w)
{
// Click on active window will minimize it
XIconifyWindow(fl_display, w, fl_screen);
XSync(fl_display, True);
TaskBar::active = 0;
b->m_minimized=true;
}
else
{
// Else give focus to window
Fl_WM::set_active_window(w);
TaskBar::active = w;
b->m_minimized=false;
}
}
}
#define CLOSE 1
#define KILL 2
#define MIN 3
#define MAX 4
//#define SET_SIZE 5
#define RESTORE 6
void menu_cb(Fl_Menu_ *menu, void *)
{
// try to read information how much window can be maximized
//int title_height;
//Fl_Config wm_config(fl_find_config_file("wmanager.conf", true));
//wm_config.get("TitleBar", "Height",title_height,20);
//int frame_width=3; // pixels
Window win = TaskButton::pushed->argument();
int ID = menu->item()->argument();
//int x, y, width, height;
Atom _XA_NET_WM_STATE = XInternAtom(fl_display, "_NET_WM_STATE", False);
Atom _XA_EDE_WM_ACTION= XInternAtom(fl_display, "_EDE_WM_ACTION", False);
// use _NET_WM_STATE_MAXIMIZED_HORZ or _NET_WM_ACTION_MAXIMIZE_HORZ ???
Atom _XA_NET_WM_STATE_MAXIMIZED_HORZ = XInternAtom(fl_display, "_NET_WM_STATE_MAXIMIZED_HORZ", False);
Atom _XA_NET_WM_STATE_MAXIMIZED_VERT = XInternAtom(fl_display, "_NET_WM_STATE_MAXIMIZED_VERT", False);
Atom _XA_EDE_WM_RESTORE_SIZE = XInternAtom(fl_display, "_EDE_WM_RESTORE_SIZE", False);
XClientMessageEvent evt;
switch(ID)
{
case CLOSE:
// TODO: closing should be handled by edewm
if(Fl_WM::close_window(win))
break;
case KILL:
// TODO: killing should be handled by edewm
XKillClient(fl_display, win);
break;
case MIN:
XIconifyWindow(fl_display, win, fl_screen);
XSync(fl_display, True);
TaskBar::active = 0;
TaskButton::pushed->m_minimized=true;
break;
case MAX:
memset(&evt, 0, sizeof(evt));
evt.type = ClientMessage;
evt.window = win;
evt.message_type = _XA_NET_WM_STATE;
evt.format = 32;
evt.data.l[0] = 0;
evt.data.l[1] = _XA_NET_WM_STATE_MAXIMIZED_HORZ;
evt.data.l[2] = _XA_NET_WM_STATE_MAXIMIZED_VERT;
XSendEvent(fl_display, RootWindow(fl_display, DefaultScreen(fl_display)), False, SubstructureNotifyMask,
(XEvent*)& evt);
TaskButton::pushed->m_minimized=false;
TaskBar::active = win;
/*
Fl_WM::get_workarea(x, y, width, height);
// leave room for widgets
y += title_height+frame_width;
x += frame_width;
height -= title_height+frame_width*2;
width -= frame_width*2;
// resize window
XMoveResizeWindow(fl_display, win, x, y, width, height);
XSync(fl_display, True);
// window lost focus so lets be nice and give it back
Fl_WM::set_active_window(win);
TaskBar::active = win;
TaskButton::pushed->m_minimized=false;
*/
break;
/*
case SET_SIZE:
{
Fl_Window *win = new Fl_Window(300, 110, _("Set Size"));
win->begin();
Fl_Box *b = new Fl_Box(_("Set size to window:"), 20);
b->label_font(b->label_font()->bold());
//b = new Fl_Box(menu_frame->label(), 20); //here goes title of window
Fl_Group *g = new Fl_Group("", 23);
Fl_Value_Input *w_width = new Fl_Value_Input(_("Width:"), 70, FL_ALIGN_LEFT, 60);
w_width->step(1);
Fl_Value_Input *w_height = new Fl_Value_Input(_("Height:"), 70, FL_ALIGN_LEFT, 60);
w_height->step(1);
g->end();
Fl_Divider *div = new Fl_Divider(10, 15);
div->layout_align(FL_ALIGN_TOP);
g = new Fl_Group("", 50, FL_ALIGN_CLIENT);
//Fl_Button *but = ok_button = new Fl_Button(40,0,100,20, _("&OK"));
//but->callback(real_set_size_cb);
but = new Fl_Button(155,0,100,20, _("&Cancel"));
//but->callback(close_set_size_cb);
g->end();
win->end();
//w_width->value(menu_frame->w());
//w_height->value(menu_frame->h());
//ok_button->user_data(menu_frame);
//win->callback(close_set_size_cb);
win->show();
}
break;*/
case RESTORE:
//Fl_WM::set_active_window(win);
memset(&evt, 0, sizeof(evt));
evt.type = ClientMessage;
evt.window = win;
evt.message_type = _XA_EDE_WM_ACTION;
evt.format = 32;
evt.data.l[0] = _XA_EDE_WM_RESTORE_SIZE;
XSendEvent(fl_display, RootWindow(fl_display, DefaultScreen(fl_display)), False, SubstructureNotifyMask,
(XEvent*)& evt);
TaskBar::active = win;
TaskButton::pushed->m_minimized=false;
break;
}
Fl::redraw();
}
TaskButton::TaskButton(Window win) : Fl_Button(0,0,0,0)
{
layout_align(FL_ALIGN_LEFT);
callback((Fl_Callback1*)task_button_cb, win);
if(!menu)
{
Fl_Group *saved = Fl_Group::current();
Fl_Group::current(0);
menu = new Fl_Menu_();
menu->callback((Fl_Callback*)menu_cb);
//Fl_Widget* add(const char*, int shortcut, Fl_Callback*, void* = 0, int = 0);
menu->add(_(" Close "), 0, 0, (void*)CLOSE, FL_MENU_DIVIDER);
new Fl_Divider(10, 15);
menu->add(_(" Kill"), 0, 0, (void*)KILL, FL_MENU_DIVIDER);
new Fl_Divider(10, 15);
menu->add(_(" Maximize "), 0, 0, (void*)MAX);
menu->add(_(" Minimize"), 0, 0, (void*)MIN);
menu->add(_(" Restore"), 0, 0, (void*)RESTORE);
//menu->add(" Set size", 0, 0, (void*)SET_SIZE, FL_MENU_DIVIDER);
//-----
Fl_Group::current(saved);
}
}
void TaskButton::draw()
{
// Draw method contains most of the logic of taskbar button
// appearance
// TODO: There seems to be no X event when window get minimized
// so taskbar might not reflect it until next update() call
// TODO: See how we can make minimized icons gray...
Fl_Color color = Fl_Button::default_style->color;
Fl_Color lcolor = Fl_Button::default_style->label_color;
Window win = this->argument();
this->color(color);
this->highlight_color(fl_lighter(color));
this->label_color(lcolor);
this->highlight_label_color(lcolor);
this->box(FL_UP_BOX);
if (win == TaskBar::active)
{
this->box(FL_DOWN_BOX);
this->color(fl_lighter(color));
this->highlight_color(fl_lighter(fl_lighter(color)));
}
else if (m_minimized)
{
this->label_color(fl_lighter(fl_lighter(lcolor)));
this->highlight_label_color(fl_lighter(fl_lighter(lcolor)));
}
Fl_Button::draw();
}
/////////////////////////
// Task bar /////////////
/////////////////////////
#include "icons/tux.xpm"
static Fl_Image default_icon(tux_xpm);
Window TaskBar::active = 0;
bool TaskBar::variable_width = true;
bool TaskBar::all_desktops = false;
TaskBar::TaskBar()
: Fl_Group(0,0,0,0)
{
m_max_taskwidth = 150;
layout_align(FL_ALIGN_CLIENT);
layout_spacing(2);
Fl_Config pConfig(fl_find_config_file("ede.conf", true));
pConfig.get("Panel", "VariableWidthTaskbar",variable_width,true);
pConfig.get("Panel", "AllDesktops",all_desktops,false);
update();
end();
}
// Logic for button sizes
void TaskBar::layout()
{
if(!children()) return;
int maxW = w()-layout_spacing()*2;
int avgW = maxW / children();
int n;
int buttonsW = layout_spacing()*2;
for(n=0; n<children(); n++)
{
int W = child(n)->width(), tmph;
if(TaskBar::variable_width)
{
child(n)->preferred_size(W, tmph);
W += 10;
} else
W = avgW;
if(W > m_max_taskwidth) W = m_max_taskwidth;
child(n)->w(W);
buttonsW += W+layout_spacing();
}
float scale = 0.0f;
if(buttonsW > maxW)
scale = (float)maxW / (float)buttonsW;
int X=layout_spacing();
for(n=0; n<children(); n++)
{
Fl_Widget *widget = child(n);
int W = widget->w();
if(scale>0.0f)
W = (int)((float)W * scale);
widget->resize(X, 0, W, h());
X += widget->w()+layout_spacing();
}
Fl_Widget::layout();
}
// Recreate all buttons in taskbar
// Called... occasionally ;)
void TaskBar::update()
{
Fl_WM::clear_handled();
int n;
// Delete all icons:
for(n=0; n<children(); n++)
{
Fl_Image *i = child(n)->image();
if(i && i!=&default_icon)
delete i;
}
clear();
Window *wins=0;
int num_windows = Fl_WM::get_windows_mapping(wins);
if(num_windows<=0)
return;
// Cleared window list
Fl_Int_List winlist;
int current_workspace = Fl_WM::get_current_workspace();
for(n=0; n<num_windows; n++)
{
if ((all_desktops
|| current_workspace == Fl_WM::get_window_desktop(wins[n]))
&& IsWindowManageable(wins[n]))
{
winlist.append(wins[n]);
}
}
if(winlist.size()>0)
{
for(n=0; n<(int)winlist.size(); n++)
{
add_new_task(winlist[n]);
}
}
free(wins);
// Probably redundant
relayout();
redraw();
parent()->redraw();
}
// Called when another window becomes active
void TaskBar::update_active(Window active)
{
if (active)
if (IsWindowManageable(active)) TaskBar::active=active;
redraw();
}
// A somewhat lighter version of update() when window
// just changes name
// Some apps like to do it a lot
void TaskBar::update_name(Window win)
{
//printf ("+update_name\n");
for(int n=0; n<children(); n++)
{
Fl_Widget *w = child(n);
Window window = w->argument();
if(window==win)
{
char *name = 0;
bool ret = Fl_WM::get_window_icontitle(win, name);
if(!ret || !name) ret = Fl_WM::get_window_title(win, name);
if(ret && name)
{
w->label(name);
w->tooltip(name);
free(name);
}
else
{
w->label("...");
w->tooltip("...");
}
// Update icon also..
Fl_Image *icon = w->image();
if(icon!=&default_icon) delete icon;
if(Fl_WM::get_window_icon(win, icon, 16, 16))
w->image(icon);
else
w->image(default_icon);
w->redraw();
break;
}
}
redraw();
}
// Callback for show desktop button
void TaskBar::minimize_all()
{
Window *wins=0;
int num_windows = Fl_WM::get_windows_mapping(wins);
int current_workspace = Fl_WM::get_current_workspace();
for(int n=0; n<num_windows; n++)
{
if(current_workspace == Fl_WM::get_window_desktop(wins[n]))
XIconifyWindow(fl_display, wins[n], fl_screen);
}
XSync(fl_display, True);
active = 0;
}
// Called by update() to add a single button
void TaskBar::add_new_task(Window w)
{
if (!w) return;
// Add to Fl_WM module handled windows.
Fl_WM::handle_window(w);
TaskButton *b;
char *name = 0;
Fl_Image *icon = 0;
begin();
b = new TaskButton(w);
bool ret = Fl_WM::get_window_icontitle(w, name);
if(!ret || !name) ret = Fl_WM::get_window_title(w, name);
if(ret && name)
{
b->label(name);
b->tooltip(name);
free(name);
}
else
{
b->label("...");
b->tooltip("...");
}
if(Fl_WM::get_window_icon(w, icon, 16, 16))
{
b->image(icon);
}
else
{
b->image(default_icon);
}
b->accept_focus(false);
b->align(FL_ALIGN_LEFT | FL_ALIGN_INSIDE | FL_ALIGN_CLIP);
if(Fl_WM::get_active_window()==w)
{
TaskBar::active = w;
}
if(GetState(w) == IconicState)
b->m_minimized=true;
else
b->m_minimized=false;
end();
}
//////////////////////////
// Below are window management functions that aren't present in Fl_WM
// We can't add them to Fl_WM because we change api, and efltk will be
// dropped in EDE 2.0.... So this functions are just duct tape...
// ugly, non-generic, non-optimized...
static 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;
}
static 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;
}
// 0 ERROR
// 3 - IconicState
// 1 - NormalState
// 2 - WithdrawnState
static int GetState(Window w)
{
static Atom _XA_WM_STATE = 0;
if(!_XA_WM_STATE) _XA_WM_STATE = XInternAtom(fl_display, "WM_STATE", False);
int ret=0;
int state = getIntProperty(w, _XA_WM_STATE, _XA_WM_STATE, 0, &ret);
if(ret!=Success) return 0;
return state;
}
// Returns false if window w is of type DESKTOP or DOCK
// Not generic enough!!
static bool IsWindowManageable(Window w)
{
static Atom _XA_NET_WM_WINDOW_TYPE = 0;
if(!_XA_NET_WM_WINDOW_TYPE) _XA_NET_WM_WINDOW_TYPE = XInternAtom(fl_display, "_NET_WM_WINDOW_TYPE", False);
static Atom _XA_NET_WM_WINDOW_TYPE_DESKTOP = 0;
if(!_XA_NET_WM_WINDOW_TYPE_DESKTOP) _XA_NET_WM_WINDOW_TYPE_DESKTOP = XInternAtom(fl_display, "_NET_WM_WINDOW_TYPE_DESKTOP", False);
static Atom _XA_NET_WM_WINDOW_TYPE_DOCK = 0;
if(!_XA_NET_WM_WINDOW_TYPE_DOCK) _XA_NET_WM_WINDOW_TYPE_DOCK = XInternAtom(fl_display, "_NET_WM_WINDOW_TYPE_DOCK", False);
static Atom _XA_NET_WM_WINDOW_TYPE_SPLASH = 0;
if(!_XA_NET_WM_WINDOW_TYPE_SPLASH) _XA_NET_WM_WINDOW_TYPE_SPLASH = XInternAtom(fl_display, "_NET_WM_WINDOW_TYPE_SPLASH", False);
Atom window_type = None;
Atom actual_type;
int actual_format;
unsigned long nitems, bytes_after;
unsigned char *prop_return = NULL;
if(Success == XGetWindowProperty(fl_display, w, _XA_NET_WM_WINDOW_TYPE, 0L, sizeof(Atom),
False, XA_ATOM, &actual_type,
&actual_format, &nitems, &bytes_after,
&prop_return) && prop_return)
{
window_type = *(Atom *)prop_return;
XFree(prop_return);
}
if(window_type == _XA_NET_WM_WINDOW_TYPE_DESKTOP
|| window_type == _XA_NET_WM_WINDOW_TYPE_DOCK
|| window_type == _XA_NET_WM_WINDOW_TYPE_SPLASH)
return false;
else return true;
}