ede/eiconman/eiconman.cpp
Sanel Zukan 1781407ef0 Added some basic UTF-16 to UTF-8 code. Works nicely with mozilla/seamonkey
clipboard, but messes everything else. More work, more work...
Also added terminating char when strncpy is used. I miss that strlcpy...
2007-07-30 12:46:37 +00:00

1052 lines
24 KiB
C++

/*
* $Id$
*
* Eiconman, desktop and icon manager
* Part of Equinox Desktop Environment (EDE).
* Copyright (c) 2000-2007 EDE Authors.
*
* This program is licensed under terms of the
* GNU General Public License version 2 or newer.
* See COPYING for details.
*/
#include "eiconman.h"
#include "DesktopIcon.h"
#include "Utils.h"
#include "Wallpaper.h"
#include "NotifyBox.h"
#include "Utf8.h"
#include <edelib/Debug.h>
#include <edelib/File.h>
#include <edelib/DesktopFile.h>
#include <edelib/Directory.h>
#include <edelib/MimeType.h>
#include <edelib/StrUtil.h>
#include <edelib/IconTheme.h>
#include <edelib/Nls.h>
#include <FL/Fl.h>
#include <FL/x.h>
#include <FL/fl_draw.h>
#include <FL/Fl_Box.h>
#include <FL/Fl_Shared_Image.h>
#include <FL/Fl_Menu_Button.h>
#include <FL/fl_ask.h>
#if 0
#include <X11/extensions/Xdamage.h>
#endif
#include <signal.h>
#include <stdlib.h> // rand, srand
#include <time.h> // time
#define CONFIG_NAME "eiconman.conf"
#define SELECTION_SINGLE (Fl::event_button() == 1)
#define SELECTION_MULTI (Fl::event_button() == 1 && (Fl::event_key(FL_Shift_L) || Fl::event_key(FL_Shift_R)))
#define MIN(x,y) ((x) < (y) ? (x) : (y))
#define MAX(x,y) ((x) > (y) ? (x) : (y))
/*
* Which widgets Fl::belowmouse() should skip. This should be updated
* when new non-icon child is added to Desktop window.
*/
#define NOT_SELECTABLE(widget) ((widget == this) || (widget == wallpaper) || (widget == dmenu))
Fl_Menu_Item desktop_menu[] = {
{_(" &New desktop item "), 0, 0, 0, FL_SUBMENU},
{_(" &Application... "), 0, 0},
{_(" &Directory... "), 0, 0},
{_(" &URL... "), 0, 0},
{_(" &Link... "), 0, 0},
{0},
{_(" &Arrange "), 0, 0, 0, FL_SUBMENU | FL_MENU_DIVIDER},
{_(" &By name "), 0, 0},
{_(" &Vertical line up "), 0, 0},
{_(" &Horizontal line up "), 0, 0},
{0},
{_(" &Copy "), 0, 0},
{_(" &Paste "), 0, 0, 0, FL_MENU_DIVIDER},
{_(" &Icons settings... "), 0, 0},
{_(" &Background... "), 0, 0},
{0}
};
#if 0
XserverRegion xregion;
XserverRegion xpart;
Damage xdamage;
int xevent_base, xerror_base;
#endif
Desktop* Desktop::pinstance = NULL;
bool running = false;
inline unsigned int random_pos(int max) {
return (rand() % max);
}
inline bool intersects(int x1, int y1, int w1, int h1, int x2, int y2, int w2, int h2) {
return (MAX(x1, x2) <= MIN(w1, w2) &&
MAX(y1, y2) <= MIN(h1, h2));
}
// assume fl_open_display() is called before
inline void dpy_sizes(int& width, int& height) {
width = DisplayWidth(fl_display, fl_screen);
height = DisplayHeight(fl_display, fl_screen);
}
void exit_signal(int signum) {
EDEBUG(ESTRLOC ": Exiting (got signal %d)\n", signum);
running = false;
}
void restart_signal(int signum) {
EDEBUG(ESTRLOC ": Restarting (got signal %d)\n", signum);
}
int desktop_xmessage_handler(int event) {
#if 0
if(fl_xevent->type == xevent_base + XDamageNotify) {
XDamageNotifyEvent* xdev = (XDamageNotifyEvent*)fl_xevent;
EDEBUG(ESTRLOC ": Damaged region %i %i %i %i on 0x%lx\n", xdev->area.x, xdev->area.y,
xdev->area.width, xdev->area.height, xdev->drawable);
//XDamageSubtract(fl_display, xdev->damage, None, None);
XFixesSetRegion(fl_display, xpart, &xdev->area, 1);
XFixesUnionRegion(fl_display, xregion, xregion, xpart);
}
XDamageSubtract(fl_display, xdamage, xregion, None);
XFixesSetRegion(fl_display, xregion, 0, 0);
#endif
if(fl_xevent->type == PropertyNotify) {
if(fl_xevent->xproperty.atom == _XA_NET_CURRENT_DESKTOP) {
Desktop::instance()->notify_desktop_changed();
return 1;
}
if(fl_xevent->xproperty.atom == _XA_EDE_DESKTOP_NOTIFY) {
char buff[256];
if(ede_get_desktop_notify(buff, 256) && buff[0] != '\0')
Desktop::instance()->notify_box(buff, true);
return 1;
}
if(fl_xevent->xproperty.atom == _XA_EDE_DESKTOP_NOTIFY_COLOR) {
Desktop::instance()->notify_box_color(ede_get_desktop_notify_color());
return 1;
}
if(fl_xevent->xproperty.atom == _XA_NET_WORKAREA) {
Desktop::instance()->update_workarea();
return 1;
}
}
return 0;
}
Desktop::Desktop() : DESKTOP_WINDOW(0, 0, 100, 100, "") {
selection_x = selection_y = 0;
moving = false;
selbox = new SelectionOverlay;
selbox->x = selbox->y = selbox->w = selbox->h = 0;
selbox->show = false;
dsett = new DesktopSettings;
dsett->color = FL_GRAY;
dsett->wp_use = false;
}
Desktop::~Desktop() {
EDEBUG("Desktop::~Desktop()\n");
delete dsett;
delete selbox;
delete notify;
}
void Desktop::init_internals(void) {
init_atoms();
update_workarea();
/*
* NOTE: order how childs are added is important. First
* non iconable ones should be added (wallpaper, menu, ...)
* then icons, so they can be drawn at top of them.
*/
begin();
dmenu = new Fl_Menu_Button(0, 0, 0, 0);
dmenu->menu(desktop_menu);
wallpaper = new Wallpaper(0, 0, w(), h());
wallpaper->set("/home/sanel/wallpapers/katebig.jpg");
//wallpaper->set_tiled("/home/sanel/wallpapers/katesmall.jpg");
//wallpaper->set_tiled("/home/sanelz/walls/katesmall.jpg");
//wallpaper->set_tiled("/home/sanelz/walls/kate.jpg");
//wallpaper->set("/home/sanelz/walls/katebig.jpg");
//wallpaper->hide();
//wallpaper->set("/home/sanelz/walls/katesmall.jpg");
//wallpaper->set("/home/sanelz/walls/nin/1024x768-04.jpg");
//wallpaper->set("/home/sanelz/walls/nin/1024x768-02.jpg");
end();
notify = new NotifyBox(w(), h());
set_bg_color(dsett->color, false);
read_config();
running = true;
}
void Desktop::init(void) {
if(Desktop::pinstance != NULL)
return;
Desktop::pinstance = new Desktop();
Desktop::pinstance->init_internals();
}
void Desktop::shutdown(void) {
if(Desktop::pinstance == NULL)
return;
delete Desktop::pinstance;
Desktop::pinstance = NULL;
}
Desktop* Desktop::instance(void) {
EASSERT(Desktop::pinstance != NULL && "Desktop::init() should be run first");
return Desktop::pinstance;
}
/*
* This function must be overriden so window can inform
* wm to see it as desktop. It will send data when window
* is created, but before is shown.
*/
void Desktop::show(void) {
if(!shown()) {
Fl_X::make_xid(this);
net_make_me_desktop(this);
#if 0
XDamageQueryExtension(fl_display, &xevent_base, &xerror_base);
xdamage = XDamageCreate(fl_display, fl_xid(this), XDamageReportBoundingBox);
xregion = XFixesCreateRegionFromWindow(fl_display, fl_xid(this), 0);
xpart = XFixesCreateRegionFromWindow(fl_display, fl_xid(this), 0);
#endif
}
}
/*
* If someone intentionaly hide desktop
* then quit from it.
*/
void Desktop::hide(void) {
running = false;
}
void Desktop::update_workarea(void) {
int X, Y, W, H;
if(!net_get_workarea(X, Y, W, H)) {
EWARNING(ESTRLOC ": wm does not support _NET_WM_WORKAREA; using screen sizes...\n");
X = Y = 0;
dpy_sizes(W, H);
}
resize(X, Y, W, H);
}
void Desktop::set_bg_color(int c, bool do_redraw) {
if(color() == c)
return;
dsett->color = c;
color(c);
if(do_redraw)
redraw();
}
void Desktop::read_config(void) {
edelib::Config conf;
if(!conf.load(CONFIG_NAME)) {
EWARNING(ESTRLOC ": Can't load %s, using default...\n", CONFIG_NAME);
return;
}
/*
* TODO:
* Add IconArea[X,Y,W,H] so icons can live
* inside that area only (aka margins).
*/
int default_bg_color = FL_BLUE;
int default_wp_use = false;
char wpath[256];
// read Desktop section
conf.get("Desktop", "Color", dsett->color, default_bg_color);
if(conf.error() != edelib::CONF_ERR_SECTION) {
conf.get("Desktop", "WallpaperUse", dsett->wp_use, default_wp_use);
conf.get("Desktop", "Wallpaper", wpath, sizeof(wpath));
// keep path but disable wallpaper if file does not exists
if(!edelib::file_exists(wpath)) {
EDEBUG(ESTRLOC ": %s as wallpaper does not exists\n", wpath);
dsett->wp_use = false;
}
} else {
// color is already filled
dsett->wp_use = default_wp_use;
}
// read Icons section
conf.get("Icons", "Label Background", gisett.label_background, FL_BLUE);
conf.get("Icons", "Label Foreground", gisett.label_foreground, FL_WHITE);
conf.get("Icons", "Label Fontsize", gisett.label_fontsize, 12);
conf.get("Icons", "Label Maxwidth", gisett.label_maxwidth, 75);
conf.get("Icons", "Label Transparent",gisett.label_transparent, false);
conf.get("Icons", "Label Visible", gisett.label_draw, true);
conf.get("Icons", "OneClickExec", gisett.one_click_exec, false);
conf.get("Icons", "AutoArrange", gisett.auto_arrange, true);
/*
* Now try to load icons, first looking inside ~/Desktop directory
* then inside config since config could contain removed entries
* from $HOME/Desktop
*
* FIXME: dir_exists() can't handle '~/Desktop' ???
*/
edelib::String dd = edelib::dir_home();
if(dd.empty()) {
EWARNING(ESTRLOC ": Can't read home directory; icons will not be loaded\n");
return;
}
dd += "/Desktop";
load_icons(dd.c_str(), conf);
}
void Desktop::save_config(void) {
// TODO
}
void Desktop::load_icons(const char* path, edelib::Config& conf) {
EASSERT(path != NULL);
if(!edelib::dir_exists(path)) {
EDEBUG(ESTRLOC ": %s does not exists\n", path);
return;
}
edelib::vector<edelib::String> lst;
// list without full path, so we can use name as entry in config file
if(!dir_list(path, lst)) {
EDEBUG(ESTRLOC ": Can't read %s\n", path);
return;
}
const char* name = NULL;
int icon_x = 0;
int icon_y = 0;
edelib::String full_path;
full_path.reserve(256);
bool can_add = false;
edelib::MimeType mt;
unsigned int sz = lst.size();
for(unsigned int i = 0; i < sz; i++) {
name = lst[i].c_str();
full_path = path;
full_path += '/';
full_path += name;
can_add = false;
IconSettings is;
// see is possible .desktop file, icon, name fields are filled from read_desktop_file()
if(edelib::str_ends(name, ".desktop")) {
if(read_desktop_file(full_path.c_str(), is))
can_add = true;
} else {
// then try to figure out it's mime; if fails, ignore it
if(mt.set(full_path.c_str())) {
EDEBUG(ESTRLOC ": Loading icon as mime-type %s\n", mt.icon_name().c_str());
is.icon = mt.icon_name();
// icon label is name of file
is.name = name;
is.type = ICON_FILE;
can_add = true;
} else {
EDEBUG(ESTRLOC ": Failed mime-type for %s, ignoring...\n", name);
can_add = false;
}
}
if(can_add) {
is.key_name = name;
// random_pos() is used if X/Y keys are not found
conf.get(name, "X", icon_x, random_pos(w() - 10));
conf.get(name, "Y", icon_y, random_pos(h() - 10));
EDEBUG(ESTRLOC ": %s found with: %i %i\n", name, icon_x, icon_y);
is.x = icon_x;
is.y = icon_y;
DesktopIcon* dic = new DesktopIcon(&gisett, &is, dsett->color);
add_icon(dic);
}
}
}
// read .desktop files
bool Desktop::read_desktop_file(const char* path, IconSettings& is) {
EASSERT(path != NULL);
if(!edelib::file_exists(path)) {
EDEBUG(ESTRLOC ": %s don't exists\n");
return false;
}
edelib::DesktopFile dconf;
if(!dconf.load(path)) {
EWARNING(ESTRLOC ": Can't read %s\n", path);
return false;
}
char buff[128];
int buffsz = sizeof(buff);
/*
* Check for 'EmptyIcon' key since via it is determined
* is icon trash type or not (in case of trash, 'Icon' key is used for full trash).
* FIXME: any other way to check for trash icons ???
*/
if(dconf.get("Desktop Entry", "EmptyIcon", buff, buffsz)) {
is.type = ICON_TRASH;
is.icon = buff;
} else
is.type = ICON_NORMAL;
if(!dconf.icon(buff, buffsz)) {
EWARNING(ESTRLOC ": No Icon key, balling out\n");
return false;
}
if(is.type == ICON_TRASH)
is.icon2 = buff;
else
is.icon = buff;
edelib::DesktopFileType dtype = dconf.type();
if(dtype == edelib::DESK_FILE_TYPE_LINK) {
is.cmd_is_url = true;
dconf.url(buff, buffsz);
}
else {
is.cmd_is_url = false;
dconf.exec(buff, buffsz);
}
is.cmd = buff;
if(!dconf.name(buff, buffsz)) {
EDEBUG(ESTRLOC ": No Name key\n");
is.name = "(none)";
} else
is.name = buff;
return true;
}
void Desktop::add_icon(DesktopIcon* ic) {
EASSERT(ic != NULL);
icons.push_back(ic);
add((Fl_Widget*)ic);
}
void Desktop::unfocus_all(void) {
unsigned int sz = icons.size();
DesktopIcon* ic;
for(unsigned int i = 0; i < sz; i++) {
ic = icons[i];
if(ic->is_focused()) {
ic->do_unfocus();
ic->fast_redraw();
}
}
}
void Desktop::select(DesktopIcon* ic, bool do_redraw) {
EASSERT(ic != NULL);
if(in_selection(ic))
return;
selectionbuff.push_back(ic);
if(!ic->is_focused()) {
ic->do_focus();
if(do_redraw)
ic->fast_redraw();
}
}
void Desktop::select_only(DesktopIcon* ic) {
EASSERT(ic != NULL);
unfocus_all();
selectionbuff.clear();
selectionbuff.push_back(ic);
ic->do_focus();
ic->fast_redraw();
}
bool Desktop::in_selection(const DesktopIcon* ic) {
EASSERT(ic != NULL);
unsigned int sz = selectionbuff.size();
for(unsigned int i = 0; i < sz; i++) {
if(ic == selectionbuff[i])
return true;
}
return false;
}
void Desktop::move_selection(int x, int y, bool apply) {
unsigned int sz = selectionbuff.size();
if(sz == 0)
return;
int prev_x, prev_y, tmp_x, tmp_y;
DesktopIcon* ic;
for(unsigned int i = 0; i < sz; i++) {
ic = selectionbuff[i];
prev_x = ic->drag_icon_x();
prev_y = ic->drag_icon_y();
tmp_x = x - selection_x;
tmp_y = y - selection_y;
ic->drag(prev_x + tmp_x, prev_y + tmp_y, apply);
// very slow if not checked
//if(apply == true)
// ic->fast_redraw();
}
selection_x = x;
selection_y = y;
/*
* Redraw whole screen so it reflects
* new icon position
*/
if(apply)
redraw();
}
/*
* Tries to figure out icon below mouse. It is alternative to
* Fl::belowmouse() since with this we hunt only icons, not other
* childs (wallpaper, menu), which can be returned by Fl::belowmouse()
* and bad things be hapened.
*/
DesktopIcon* Desktop::below_mouse(int px, int py) {
unsigned int sz = icons.size();
DesktopIcon* ic = NULL;
for(unsigned int i = 0; i < sz; i++) {
ic = icons[i];
if(ic->x() < px && ic->y() < py && px < (ic->x() + ic->h()) && py < (ic->y() + ic->h()))
return ic;
}
return NULL;
}
void Desktop::select_in_area(void) {
if(!selbox->show)
return;
int ax = selbox->x;
int ay = selbox->y;
int aw = selbox->w;
int ah = selbox->h;
if(aw < 0) {
ax += aw;
aw = -aw;
} else if(!aw)
aw = 1;
if(ah < 0) {
ay += ah;
ah = -ah;
} else if(!ah)
ah = 1;
/*
* XXX: This function can fail since icon coordinates are absolute (event_x_root)
* but selbox use relative (event_root). It will work as expected if desktop is at x=0 y=0.
* This should be checked further.
*/
unsigned int sz = icons.size();
DesktopIcon* ic = NULL;
for(unsigned int i = 0; i < sz; i++) {
ic = icons[i];
EASSERT(ic != NULL && "Impossible to happen");
if(intersects(ax, ay, ax+aw, ay+ah, ic->x(), ic->y(), ic->w()+ic->x(), ic->h()+ic->y())) {
if(!ic->is_focused()) {
ic->do_focus();
// updated from Desktop::draw()
ic->damage(EDAMAGE_CHILD_LABEL);
}
} else {
if(ic->is_focused()) {
ic->do_unfocus();
// updated from Desktop::draw()
ic->fast_redraw();
//ic->damage(EDAMAGE_CHILD_LABEL);
//ic->redraw();
//ic->damage(EDAMAGE_CHILD_LABEL);
}
}
}
}
void Desktop::notify_box(const char* msg, bool copy) {
if(!msg)
return;
if(copy)
notify->copy_label(msg);
else
notify->label(msg);
if(!notify->shown())
notify->show();
}
void Desktop::notify_box_color(Fl_Color col) {
notify->color(col);
}
void Desktop::notify_desktop_changed(void) {
int num = net_get_current_desktop();
if(num == -1)
return;
char** names;
int ret = net_get_workspace_names(names);
if(num >= ret) {
XFreeStringList(names);
return;
}
notify_box(names[num], true);
XFreeStringList(names);
}
void Desktop::drop_source(const char* src, int src_len, int x, int y) {
if(!src)
return;
if(src_len < 1)
return;
#if 0
/*
* Commented for now since is_utf16() does not works as expected;
* on other hand, UTF-16 conversion is fine
*/
if(is_utf16((unsigned short*)src, src_len)) {
char* utf_src = new char[src_len * 5];
if(utf16_to_utf8_str((unsigned short*)src, src_len, utf_src)) {
utf_src[src_len] = '\0';
EDEBUG(ESTRLOC ":==========> %s|\n", utf_src);
}
delete [] utf_src;
}
#endif
char* src_copy = new char[src_len + 1];
int real_len = 0;
// mozilla sends UTF-16 form; for now use this hack untill Utf8.cpp code is ready
for(int i = 0, j = 0; i < src_len; i++) {
if(src[i] != 0) {
src_copy[j++] = src[i];
real_len++;
}
}
src_copy[real_len] = '\0';
if(real_len < 1) {
delete [] src_copy;
return;
}
EDEBUG(ESTRLOC ": DND on Desktop, got: %s\n", src_copy);
// valid url's (if got) ends with \r\n, clean that
char* pp = strstr(src_copy, "\r\n");
if(pp)
*pp = '\0';
char* sptr = 0;
if((real_len > 7) && (strncmp(src_copy, "file://", 7) == 0))
sptr = src_copy + 7;
else
sptr = src_copy;
if(!edelib::file_exists(sptr) && !edelib::dir_exists(sptr)) {
fl_message("Droping file content is not implemented yet. Soon, soon... :)");
delete [] src_copy;
return;
}
IconSettings is;
is.x = x;
is.y = y;
bool is_read = false;
if(edelib::str_ends(src_copy, ".desktop")) {
edelib::DesktopFile dconf;
edelib::String path = sptr;
edelib::DesktopFile dfile;
if(dfile.load(path.c_str())) {
char buff[256];
if(dfile.type() == edelib::DESK_FILE_TYPE_LINK) {
dfile.url(buff, 256);
is.cmd_is_url = true;
}
else {
dfile.exec(buff, 256);
is.cmd_is_url = false;
}
is.cmd = buff;
is.type = ICON_NORMAL;
dfile.name(buff, 256);
is.name = buff;
dfile.icon(buff, 256);
is.icon = buff;
is_read = true;
}
}
if(!is_read) {
// absolute path is (for now) seen as non-url
if(sptr[0] == '/')
is.cmd_is_url = false;
else
is.cmd_is_url = true;
is.cmd = "(none)";
is.type = ICON_NORMAL;
edelib::MimeType mt;
if(!mt.set(sptr)) {
EWARNING(ESTRLOC ": MimeType for %s (%s) failed, not dropping icon\n", sptr, src_copy);
delete [] src_copy;
return;
}
is.name = get_basename(sptr);
is.icon = mt.icon_name();
}
DesktopIcon* dic = new DesktopIcon(&gisett, &is, color());
add_icon(dic);
delete [] src_copy;
redraw();
}
void Desktop::draw(void) {
if(!damage())
return;
if(damage() & (FL_DAMAGE_ALL | FL_DAMAGE_EXPOSE)) {
/*
* If any overlay was previously visible during full
* redraw, it will not be cleared because of fast flip.
* This will assure that does not happened.
*/
clear_xoverlay();
DESKTOP_WINDOW::draw();
EDEBUG(ESTRLOC ": REDRAW ALL\n");
}
if(damage() & EDAMAGE_OVERLAY) {
if(selbox->show)
draw_xoverlay(selbox->x, selbox->y, selbox->w, selbox->h);
else
clear_xoverlay();
/*
* now scan all icons and see if they needs redraw, and if do
* just update their label since it is indicator of selection
*/
for(int i = 0; i < children(); i++) {
if(child(i)->damage() == EDAMAGE_CHILD_LABEL) {
update_child(*child(i));
child(i)->clear_damage();
EDEBUG(ESTRLOC ": ICON REDRAW \n");
}
}
}
clear_damage();
}
int Desktop::handle(int event) {
switch(event) {
case FL_FOCUS:
case FL_UNFOCUS:
case FL_SHORTCUT:
return 1;
case FL_PUSH: {
/*
* First check where we clicked. If we do it on desktop
* unfocus any possible focused childs, and handle
* specific clicks. Otherwise, do rest for childs.
*/
Fl_Widget* clicked = Fl::belowmouse();
if(NOT_SELECTABLE(clicked)) {
EDEBUG(ESTRLOC ": DESKTOP CLICK !!!\n");
if(!selectionbuff.empty()) {
/*
* Only focused are in selectionbuff, so this is
* fine to do; also will prevent full redraw when is clicked on desktop
*/
unfocus_all();
selectionbuff.clear();
}
// track position so moving can be deduced
if(Fl::event_button() == 1) {
selbox->x = Fl::event_x();
selbox->y = Fl::event_y();
} else if(Fl::event_button() == 3) {
dmenu->menu()->popup(Fl::event_x(), Fl::event_y());
}
return 1;
}
// from here, all events are managed for icons
DesktopIcon* tmp_icon = (DesktopIcon*)clicked;
/*
* do no use assertion on this, since
* fltk::belowmouse() can miss our icon
*/
if(!tmp_icon)
return 1;
if(SELECTION_MULTI) {
Fl::event_is_click(0);
select(tmp_icon);
return 1;
} else if(SELECTION_SINGLE) {
if(!in_selection(tmp_icon)) {
/*
* for testing:
* notify_box(tmp_icon->label());
*/
select_only(tmp_icon);
}
} else if(Fl::event_button() == 3) {
select_only(tmp_icon);
/*
* for testing:
* notify_box(tmp_icon->label());
*/
}
/*
* Let child handle the rest.
* Also prevent click on other mouse buttons during move.
*/
if(!moving)
tmp_icon->handle(FL_PUSH);
EDEBUG(ESTRLOC ": FL_PUSH from desktop\n");
selection_x = Fl::event_x_root();
selection_y = Fl::event_y_root();
return 1;
}
case FL_DRAG:
moving = true;
if(!selectionbuff.empty()) {
EDEBUG(ESTRLOC ": DRAG icon from desktop\n");
move_selection(Fl::event_x_root(), Fl::event_y_root(), false);
} else {
EDEBUG(ESTRLOC ": DRAG from desktop\n");
/*
* Moving is started with pushed button.
* From this point selection box is created and is rolled until release
*/
if(selbox->x != 0 || selbox->y != 0) {
selbox->w = Fl::event_x() - selbox->x;
selbox->h = Fl::event_y() - selbox->y;
selbox->show = true;
// see if there some icons inside selection area
select_in_area();
// redraw selection box
damage(EDAMAGE_OVERLAY);
}
}
return 1;
case FL_RELEASE:
EDEBUG(ESTRLOC ": RELEASE from desktop\n");
EDEBUG(ESTRLOC ": clicks: %i\n", Fl::event_is_click());
if(selbox->show) {
selbox->x = selbox->y = selbox->w = selbox->h = 0;
selbox->show = false;
damage(EDAMAGE_OVERLAY);
/*
* Now pickup those who are in is_focused() state.
*
* Possible flickers due overlay will be later removed when is
* called move_selection(), which will in turn redraw icons again
* after position them.
*/
if(!selectionbuff.empty())
selectionbuff.clear();
for(unsigned int i = 0; i < icons.size(); i++) {
if(icons[i]->is_focused())
select(icons[i], false);
}
return 1;
}
if(!selectionbuff.empty() && moving)
move_selection(Fl::event_x_root(), Fl::event_y_root(), true);
/*
* Do not send FL_RELEASE during move
*
* TODO: should be alowed FL_RELEASE to multiple icons? (aka. run
* command for all selected icons ?
*/
if(selectionbuff.size() == 1 && !moving)
selectionbuff[0]->handle(FL_RELEASE);
moving = false;
return 1;
case FL_DND_ENTER:
case FL_DND_DRAG:
case FL_DND_LEAVE:
return 1;
case FL_DND_RELEASE: {
DesktopIcon* di = below_mouse(Fl::event_x(), Fl::event_y());
if(di)
return di->handle(event);
return 1;
}
case FL_PASTE: {
DesktopIcon* di = below_mouse(Fl::event_x(), Fl::event_y());
if(di)
return di->handle(event);
drop_source(Fl::event_text(), Fl::event_length(), Fl::event_x(), Fl::event_y());
return 1;
}
case FL_ENTER:
case FL_LEAVE:
case FL_MOVE:
return DESKTOP_WINDOW::handle(event);
default:
break;
}
return 0;
}
int main() {
signal(SIGTERM, exit_signal);
signal(SIGKILL, exit_signal);
signal(SIGINT, exit_signal);
signal(SIGHUP, restart_signal);
srand(time(NULL));
// a lot of preparing code depends on this
fl_open_display();
fl_register_images();
edelib::IconTheme::init("edeneu");
Desktop::init();
Desktop::instance()->show();
/*
* XSelectInput will redirect PropertyNotify messages, which
* are listened for
*/
XSelectInput(fl_display, RootWindow(fl_display, fl_screen), PropertyChangeMask | StructureNotifyMask | ClientMessage);
Fl::add_handler(desktop_xmessage_handler);
while(running)
Fl::wait();
Desktop::shutdown();
edelib::IconTheme::shutdown();
return 0;
}