static void lxynth_shutdown_driver (void)
{
DEBUGF ("%s (%s:%d)\n", __FUNCTION__, __FILE__, __LINE__);
if (lxynth_root->running) {
lxynth_root->running = 0;
s_window_quit(lxynth_root->window);
s_thread_join(lxynth_root->tid, NULL);
kill_timer(lxynth_root->timerid);
}
while (!s_list_eol(lxynth_root->eventq->list, 0)) {
s_event_t *event = s_list_get(lxynth_root->eventq->list, 0);
s_list_remove(lxynth_root->eventq->list, 0);
s_event_uninit(event);
}
s_free(lxynth_root->eventq->list);
s_thread_mutex_destroy(lxynth_root->eventq->mut);
s_free(lxynth_root->eventq);
while (!s_list_eol(lxynth_root->gd->list, 0)) {
struct graphics_device *gd = s_list_get(lxynth_root->gd->list, 0);
lxynth_device_t *wd = (lxynth_device_t *) gd->driver_data;
s_list_remove(lxynth_root->gd->list, 0);
s_free(wd->title);
s_surface_destroy(wd->surface);
s_free(wd);
s_free(gd);
}
s_free(lxynth_root->gd->list);
s_thread_mutex_destroy(lxynth_root->gd->mut);
s_free(lxynth_root->gd);
s_free(lxynth_root);
}
void taskbar_atevent (s_window_t *window, s_event_t *event)
{
int pos = 0;
tbar_data_t *tbar_data;
tbar_progs_t *tbar_progs;
s_desktop_client_t *desktopc;
if (event->type & EVENT_TYPE_MOUSE_EXIT) {
}
if (!(event->type & EVENT_TYPE_DESKTOP)) {
return;
}
tbar_data = (tbar_data_t *) window->data;
tbar_progs = (tbar_progs_t *) tbar_data->tbar_progs;
while (!s_list_eol(tbar_progs->desktop->clients, 0)) {
desktopc = (s_desktop_client_t *) s_list_get(tbar_progs->desktop->clients, 0);
s_list_remove(tbar_progs->desktop->clients, 0);
s_free(desktopc->title);
s_free(desktopc);
}
while (!s_list_eol(event->desktop->clients, pos)) {
desktopc = (s_desktop_client_t *) s_list_get(event->desktop->clients, pos);
if ((desktopc->id != window->id) &&
(desktopc->id != window->parent->id)) {
s_list_remove(event->desktop->clients, pos);
s_list_add(tbar_progs->desktop->clients, desktopc, -1);
} else {
pos++;
}
}
taskbar_progs_draw(window);
}
int w_clistbox_item_del (w_object_t *object, w_clistbox_item_t *item)
{
int p;
w_clistbox_t *lb;
w_clistbox_item_t *active;
lb = object->data[OBJECT_CLISTBOX];
active = s_list_get(lb->items, lb->active);
p = s_list_get_pos(lb->items, item);
s_list_remove(lb->items, p);
w_clistbox_item_uninit(item);
if (lb->active == p) {
active = s_list_get(lb->items, p);
if (active == NULL) {
active = s_list_get(lb->items, p - 1);
} else {
lb->pactive = -1;
}
}
if (active == NULL) {
lb->active = 0;
} else {
lb->active = s_list_get_pos(lb->items, active);
}
if (lb->active < 0) {
lb->active = 0;
}
lb->dirty = 1;
w_object_draw(object);
return 0;
}
void s_event_parse_mouse (s_window_t *window, s_event_t *event)
{
int pos;
s_handler_t *work;
pos = 0;
s_thread_mutex_lock(window->handlers->mut);
while (!s_list_eol(window->handlers->list, pos)) {
work = (s_handler_t *) s_list_get(window->handlers->list, pos++);
if (work->type != MOUSE_HANDLER) {
continue;
}
if (s_event_parse_handler_over(window, event, work) == 0) {
break;
}
}
pos = 0;
while (!s_list_eol(window->handlers->list, pos)) {
work = (s_handler_t *) s_list_get(window->handlers->list, pos++);
if (work->type != MOUSE_HANDLER) {
continue;
}
if (s_event_parse_handler_notover(window, event, work) == 0) {
break;
}
}
s_thread_mutex_unlock(window->handlers->mut);
return;
}
int s_dir_print (s_dir_t *dir)
{
int i;
int j;
int l;
s_dir_t *d;
s_file_t *f;
l = s_dir_get_level(dir);
if (l == 0) {
printf("+ %s\n", dir->path);
} else {
for (i = 0; i < l - 1; i++) {
if (s_dir_has_trailer(dir, i)) {
printf("| ");
} else {
printf(" ");
}
}
printf("|---+ %s\n", dir->name);
}
i = 0;
while (!s_list_eol(dir->dirs, i)) {
d = (s_dir_t *) s_list_get(dir->dirs, i);
s_dir_print(d);
i++;
}
i = 0;
while (!s_list_eol(dir->files, i)) {
f = (s_file_t *) s_list_get(dir->files, i);
for (j = 0; j < l; j++) {
if (s_dir_has_trailer(dir, j)) {
printf("| ");
} else {
printf(" ");
}
}
printf("|---- %s\n", f->name);
i++;
}
if (dir->dirs->nb_elt || dir->files->nb_elt) {
for (i = 0; i < l; i++) {
if (s_dir_has_trailer(dir, i)) {
printf("| ");
} else {
printf(" ");
}
}
printf("\n");
}
return 0;
}
int s_eventq_wait (s_window_t *window, s_event_t **event)
{
int ret;
s_event_t *e;
s_thread_mutex_lock(window->eventq->mut);
while (window->eventq->queue->nb_elt <= 0) {
if (s_thread_cond_wait(window->eventq->cond, window->eventq->mut)) {
debugf(DSYS, "s_thread_cond_wait failed");
return -1;
}
}
e = (s_event_t *) s_list_get(window->eventq->queue, 0);
if (e == NULL) {
ret = -1;
} else {
s_list_remove(window->eventq->queue, 0);
*event = e;
ret = 0;
}
s_thread_mutex_unlock(window->eventq->mut);
return ret;
}
int w_frame_set_image (w_object_t *object, unsigned int style, unsigned int rotation, unsigned int nimgs, char **imgs)
{
int pos;
char *file;
w_frame_t *frame;
w_frame_image_t *fimg;
frame = (w_frame_t *) object->data[OBJECT_FRAME];
for (pos = 0; !s_list_eol(frame->images, pos); pos++) {
fimg = (w_frame_image_t *) s_list_get(frame->images, pos);
if (fimg->style == style) {
s_list_remove(frame->images, pos);
w_frame_image_uninit(fimg);
break;
}
}
for (pos = 0; pos < nimgs; pos++) {
if (access(imgs[pos], R_OK)) {
return -1;
}
}
w_frame_image_init(&fimg);
fimg->style = style;
fimg->rotation = rotation;
for (pos = 0; pos < nimgs; pos++) {
file = imgs[pos];
#if defined(WIDGET_OPTIMIZE_MEMORY) && WIDGET_OPTIMIZE_MEMORY >= 1
#else
w_window_image_add(object->window, file);
#endif
s_list_add(fimg->names, strdup(file), -1);
}
s_list_add(frame->images, fimg, -1);
return 0;
}
void header_generate_function (s_xml_node_t *node, FILE *g_header)
{
int p;
s_xml_node_t *tmp;
if (strcmp(node->name, "draw") == 0) {
fprintf(g_header, "void %s (w_object_t *object);\n", node->value);
} else if (strcmp(node->name, "event") == 0) {
fprintf(g_header, "void %s (w_object_t *object, s_event_t *event);\n", node->value);
} else if (strcmp(node->name, "onload") == 0) {
fprintf(g_header, "void %s (w_object_t *object);\n", node->value);
} else if (strcmp(node->name, "unload") == 0) {
fprintf(g_header, "void %s (w_object_t *object);\n", node->value);
} else if (strcmp(node->name, "pressed") == 0) {
fprintf(g_header, "void %s (w_object_t *object, int button);\n", node->value);
} else if (strcmp(node->name, "released") == 0) {
fprintf(g_header, "void %s (w_object_t *object, int button);\n", node->value);
} else if (strcmp(node->name, "changed") == 0) {
fprintf(g_header, "void %s (w_object_t *object, int state);\n", node->value);
}
p = 0;
while (!s_list_eol(node->nodes, p)) {
tmp = (s_xml_node_t *) s_list_get(node->nodes, p);
header_generate_function(tmp, g_header);
p++;
}
}
void taskbar_progs_draw (s_window_t *window)
{
int x;
int pos;
int w = 0;
s_surface_t *srf;
tbar_data_t *tbar_data;
tbar_progs_t *tbar_progs;
s_desktop_client_t *desktopc;
pos = 0;
tbar_data = (tbar_data_t *) window->data;
tbar_progs = (tbar_progs_t *) tbar_data->tbar_progs;
if (tbar_progs->desktop->clients->nb_elt > 0) {
w = ((tbar_progs->rect.w / tbar_progs->desktop->clients->nb_elt) > 125) ? 125 : (tbar_progs->rect.w / tbar_progs->desktop->clients->nb_elt);
}
if (s_surface_create(&srf, tbar_progs->rect.w, tbar_progs->rect.h, window->surface->bitsperpixel)) {
return;
}
for (x = 0; x <= tbar_progs->rect.w; x++) {
s_putboxpart(srf, x, 0, 1, tbar_progs->rect.h, 1, 30, tbar_progs->tbar_img->buf, 0, tbar_progs->rect.y);
}
while (!s_list_eol(tbar_progs->desktop->clients, pos)) {
desktopc = (s_desktop_client_t *) s_list_get(tbar_progs->desktop->clients, pos);
taskbar_progs_draw_client(tbar_progs, srf, desktopc, w * pos, 0, w, tbar_progs->rect.h);
pos++;
}
s_putbox(window->surface, tbar_progs->rect.x, tbar_progs->rect.y, tbar_progs->rect.w, tbar_progs->rect.h, srf->vbuf);
s_surface_destroy(srf);
}
void taskbar_atexit (s_window_t *window)
{
tbar_data_t *tbar_data;
tbar_progs_t *tbar_progs;
tbar_clock_t *tbar_clock;
s_desktop_client_t *desktopc;
tbar_data = (tbar_data_t *) window->data;
tbar_progs = (tbar_progs_t *) tbar_data->tbar_progs;
tbar_clock = (tbar_clock_t *) tbar_data->tbar_clock;
s_font_uninit(tbar_clock->font);
s_font_uninit(tbar_progs->prog_font);
s_image_uninit(tbar_progs->tbar_img);
s_image_uninit(tbar_progs->prog_img[0]);
s_image_uninit(tbar_progs->prog_img[1]);
while (!s_list_eol(tbar_progs->desktop->clients, 0)) {
desktopc = (s_desktop_client_t *) s_list_get(tbar_progs->desktop->clients, 0);
s_list_remove(tbar_progs->desktop->clients, 0);
s_free(desktopc->title);
s_free(desktopc);
}
s_free(tbar_progs->desktop->clients);
s_free(tbar_progs->desktop);
s_free(tbar_progs);
s_free(tbar_data->tbar_clock);
taskbar_clean_smenu(tbar_data->tbar_smenu->progs);
s_image_uninit(tbar_data->tbar_smenu->img);
s_free(tbar_data->tbar_smenu);
s_free(tbar_data);
}
void taskbar_progs_handler_r (s_window_t *window, s_event_t *event, s_handler_t *handler)
{
int w;
int px;
int py;
int pos;
tbar_data_t *tbar_data;
tbar_progs_t *tbar_progs;
s_desktop_client_t *desktopc;
tbar_data = (tbar_data_t *) window->data;
tbar_progs = (tbar_progs_t *) tbar_data->tbar_progs;
px = event->mouse->x - tbar_progs->rect.x;
py = event->mouse->y - tbar_progs->rect.y;
if (tbar_progs->desktop->clients->nb_elt <= 0) {
return;
}
w = ((tbar_progs->rect.w / tbar_progs->desktop->clients->nb_elt) > 125) ? 125 : (tbar_progs->rect.w / tbar_progs->desktop->clients->nb_elt);
if ((px > 0) && (px < w * tbar_progs->desktop->clients->nb_elt)) {
pos = px / w;
} else {
return;
}
desktopc = (s_desktop_client_t *) s_list_get(tbar_progs->desktop->clients, pos);
if (desktopc != NULL) {
s_socket_request(window, SOC_DATA_SHOW, desktopc->id, NULL, 0);
}
}
static void lxynth_timer (void *arg)
{
int x = 0;
int y = 0;
int k = 0;
int flag = 0;
s_event_t *event;
s_thread_mutex_lock(lxynth_root->eventq->mut);
while (!s_list_eol(lxynth_root->eventq->list, 0)) {
event = (s_event_t *) s_list_get(lxynth_root->eventq->list, 0);
s_list_remove(lxynth_root->eventq->list, 0);
switch (event->type & EVENT_MASK) {
case QUIT_EVENT: break;
case MOUSE_EVENT: lxynth_event_parse_mouse(event); break;
case KEYBD_EVENT: lxynth_event_parse_keybd(event); break;
case CONFIG_EVENT: lxynth_event_parse_config(event); break;
}
s_event_uninit(event);
}
s_thread_mutex_unlock(lxynth_root->eventq->mut);
if (lxynth_root->running) {
lxynth_root->timerid = install_timer(20, lxynth_timer, NULL);
}
}
static void lxynth_shutdown_device (struct graphics_device *dev)
{
int acc = 0;
int pos = 0;
lxynth_device_t *wd;
struct graphics_device *gd;
DEBUGF ("%s (%s:%d)\n", __FUNCTION__, __FILE__, __LINE__);
s_thread_mutex_lock(lxynth_root->gd->mut);
while (!s_list_eol(lxynth_root->gd->list, pos)) {
gd = (struct graphics_device *) s_list_get(lxynth_root->gd->list, pos);
if (gd == dev) {
s_list_remove(lxynth_root->gd->list, pos);
if (lxynth_root->gd->list->nb_elt > 0) {
lxynth_root->gd->active = (struct graphics_device *) s_list_get(lxynth_root->gd->list, 0);
acc = 1;
} else {
lxynth_root->gd->active = NULL;
}
break;
}
pos++;
}
unregister_bottom_half(lxynth_surface_register_update, dev);
wd = (lxynth_device_t *) dev->driver_data;
s_free(wd->title);
s_surface_destroy(wd->surface);
s_free(wd);
s_free(dev);
s_thread_mutex_unlock(lxynth_root->gd->mut);
if (acc && lxynth_root->running) {
char *title;
struct rect r;
r.x1 = 0;
r.y1 = 0;
r.x2 = lxynth_root->window->surface->buf->w;
r.y2 = lxynth_root->window->surface->buf->h;
title = strdup(((lxynth_device_t *) lxynth_root->gd->active->driver_data)->title);
lxynth_set_title(lxynth_root->gd->active, title);
lxynth_root->gd->active->resize_handler(lxynth_root->gd->active);
lxynth_root->gd->active->redraw_handler(lxynth_root->gd->active, &r);
s_free(title);
}
}
int s_event_parse_handler_over (s_window_t *window, s_event_t *event, s_handler_t *work)
{
switch (s_event_mouse_handler_state(window, event, &(work->mouse), 1)) {
case MOUSE_OVER:
if (work->mouse.o != NULL) {
s_thread_mutex_unlock(window->handlers->mut);
work->mouse.o(window, event, work);
s_thread_mutex_lock(window->handlers->mut);
}
goto not_over;
case MOUSE_PRESSED:
if (work->mouse.p != NULL) {
s_thread_mutex_unlock(window->handlers->mut);
work->mouse.p(window, event, work);
s_thread_mutex_lock(window->handlers->mut);
}
goto not_over;
case MOUSE_CLICKED:
if (work->mouse.c != NULL) {
s_thread_mutex_unlock(window->handlers->mut);
work->mouse.c(window, event, work);
s_thread_mutex_lock(window->handlers->mut);
work = (s_handler_t *) s_list_get(window->handlers->list, s_list_get_pos(window->handlers->list, work));
if (work == NULL) {
goto not_over;
}
}
/* no break */
case MOUSE_RELEASED:
if (work->mouse.r != NULL) {
s_thread_mutex_unlock(window->handlers->mut);
work->mouse.r(window, event, work);
s_thread_mutex_lock(window->handlers->mut);
}
goto not_over;
case (MOUSE_RELEASED | MOUSE_HINT):
/* mouse button released, but the prev. press was not on us */
if (work->mouse.hr != NULL) {
s_thread_mutex_unlock(window->handlers->mut);
work->mouse.hr(window, event, work);
s_thread_mutex_lock(window->handlers->mut);
}
goto not_over;
case (MOUSE_OVER | MOUSE_HINT):
/* on over, but mouse button is still pressed */
if (work->mouse.ho != NULL) {
s_thread_mutex_unlock(window->handlers->mut);
work->mouse.ho(window, event, work);
s_thread_mutex_lock(window->handlers->mut);
}
goto not_over;
}
return -1;
not_over:
return 0;
}
int w_frame_image_uninit (w_frame_image_t *fimg)
{
char *name;
s_image_t *img;
while (!s_list_eol(fimg->images, 0)) {
img = (s_image_t *) s_list_get(fimg->images, 0);
s_list_remove(fimg->images, 0);
s_image_uninit(img);
}
s_list_uninit(fimg->images);
while (!s_list_eol(fimg->names, 0)) {
name = (char *) s_list_get(fimg->names, 0);
s_list_remove(fimg->names, 0);
s_free(name);
}
s_list_uninit(fimg->names);
s_free(fimg);
return 0;
}
int s_dir_sort (s_dir_t *dir)
{
int i;
int j;
s_dir_t *d;
s_dir_t *di;
s_dir_t *dj;
s_file_t *fi;
s_file_t *fj;
for (i = 0; i < dir->dirs->nb_elt - 1; i++) {
for (j = 0; j < dir->dirs->nb_elt - 1; j++) {
di = (s_dir_t *) s_list_get(dir->dirs, j);
dj = (s_dir_t *) s_list_get(dir->dirs, j + 1);
if (strcmp(dj->path, di->path) < 0) {
s_list_remove(dir->dirs, j);
s_list_add(dir->dirs, di, j + 1);
}
}
}
for (i = 0; i < dir->files->nb_elt - 1; i++) {
for (j = 0; j < dir->files->nb_elt - 1; j++) {
fi = (s_file_t *) s_list_get(dir->files, j);
fj = (s_file_t *) s_list_get(dir->files, j + 1);
if (strcmp(fj->path, fi->path) < 0) {
s_list_remove(dir->files, j);
s_list_add(dir->files, fi, j + 1);
}
}
}
i = 0;
while (!s_list_eol(dir->dirs, i)) {
d = (s_dir_t *) s_list_get(dir->dirs, i);
s_dir_sort(d);
i++;
}
return 0;
}
int s_config_uninit (s_config_t *cfg)
{
while (!s_list_eol(cfg->category, 0)) {
s_config_cat_t *cat = (s_config_cat_t *) s_list_get(cfg->category, 0);
s_list_remove(cfg->category, 0);
s_config_category_uninit(cat);
}
s_list_uninit(cfg->category);
s_free(cfg);
return 0;
}
int s_config_category_uninit (s_config_cat_t *cat)
{
while (!s_list_eol(cat->variable, 0)) {
s_config_var_t *var = (s_config_var_t *) s_list_get(cat->variable, 0);
s_list_remove(cat->variable, 0);
s_config_variable_uninit(var);
}
s_list_uninit(cat->variable);
s_free(cat->name);
s_free(cat);
return 0;
}
void w_clistbox_uninit (w_object_t *object)
{
w_clistbox_t *lb;
w_clistbox_item_t *li;
w_clistbox_item_image_t *ii;
lb = object->data[OBJECT_CLISTBOX];
while (!s_list_eol(lb->items, 0)) {
li = (w_clistbox_item_t *) s_list_get(lb->items, 0);
s_list_remove(lb->items, 0);
w_clistbox_item_uninit(li);
}
while (!s_list_eol(lb->item_images, 0)) {
ii = (w_clistbox_item_image_t *) s_list_get(lb->item_images, 0);
s_list_remove(lb->item_images, 0);
w_clistbox_item_image_uninit(ii);
}
s_list_uninit(lb->item_images);
s_list_uninit(lb->items);
w_frame_uninit(object);
s_free(lb);
}
static void button0_pressed (w_object_t *object, int buttonp)
{
int i;
w_object_t *obj;
area_hide = (area_hide + 1) % 2;
if (area_hide) {
for (i = 0; !s_list_eol(object->parent->childs, i); i++) {
obj = (w_object_t *) s_list_get(object->parent->childs, i);
if (obj != object) {
w_object_hide(obj);
}
}
} else {
for (i = 0; !s_list_eol(object->parent->childs, i); i++) {
obj = (w_object_t *) s_list_get(object->parent->childs, i);
if (obj != object) {
w_object_show(obj);
}
}
}
}
static void button2_pressed (w_object_t *object, int button)
{
int r;
int show;
w_object_t *obj;
r = rand();
if (r == 0) {
r++;
}
show = r % area->object->childs->nb_elt;
obj = (w_object_t *) s_list_get(area->object->childs, show);
w_object_show(obj);
}
int s_files_uninit (s_list_t *files)
{
s_file_t *file;
while (!s_list_eol(files, 0)) {
file = (s_file_t *) s_list_get(files, 0);
s_list_remove(files, 0);
s_file_uninit(file);
}
free(files);
return 0;
}
int s_dirs_uninit (s_list_t *dirs)
{
s_dir_t *dir;
while (!s_list_eol(dirs, 0)) {
dir = (s_dir_t *) s_list_get(dirs, 0);
s_list_remove(dirs, 0);
s_dir_uninit(dir);
}
free(dirs);
return 0;
}
void code_parse_element (s_xml_node_t *node, s_xml_node_t *style)
{
int p;
s_xml_node_t *tmp;
s_xml_node_t *dmp;
s_xml_node_t *chl;
s_xml_node_attr_t *sid;
s_xml_node_attr_t *stype;
s_xml_node_attr_t *ntype;
if (style == NULL) {
return;
}
for (p = 0; !s_list_eol(node->nodes, p); p++) {
tmp = (s_xml_node_t *) s_list_get(node->nodes, p);
code_parse_element(tmp, style);
}
ntype = s_xml_node_get_attr(node, "type");
if (strcmp(node->name, "element") == 0 && ntype && ntype->value != NULL) {
for (p = 0; !s_list_eol(style->nodes, p); p++) {
tmp = (s_xml_node_t *) s_list_get(style->nodes, p);
sid = s_xml_node_get_attr(tmp, "id");
stype = s_xml_node_get_attr(tmp, "type");
if (strcmp(tmp->name, "element") == 0 && sid && strcmp(sid->value, ntype->value) == 0) {
s_xml_node_dublicate(tmp, &dmp);
s_free(node->name);
s_free(ntype->value);
node->name = strdup("object");
ntype->value = (stype->value) ? strdup(stype->value) : NULL;
while (!s_list_eol(dmp->nodes, 0)) {
chl = (s_xml_node_t *) s_list_get(dmp->nodes, dmp->nodes->nb_elt - 1);
chl->parent = node;
s_list_add(node->nodes, chl, 0);
s_list_remove(dmp->nodes, dmp->nodes->nb_elt - 1);
}
s_xml_node_uninit(dmp);
}
}
}
}
static void button0_draw (w_object_t *object)
{
w_object_t *obj;
w_button_draw(object);
obj = (w_object_t *) s_list_get(object->childs, 0);
if (obj == NULL) {
return;
}
if (area_hide) {
w_textbox_set_str(obj, "show area");
} else {
w_textbox_set_str(obj, "hide area");
}
}
void w_frame_uninit (w_object_t *object)
{
w_frame_t *frame;
w_frame_image_t *fimg;
frame = (w_frame_t *) object->data[OBJECT_FRAME];
w_object_uninit(object);
while (!s_list_eol(frame->images, 0)) {
fimg = s_list_get(frame->images, 0);
s_list_remove(frame->images, 0);
w_frame_image_uninit(fimg);
}
s_list_uninit(frame->images);
s_free(frame);
}
int s_image_layers_uninit (s_image_t *img)
{
s_image_t *img_;
while (!s_list_eol(img->layers, 0)) {
img_ = (s_image_t *) s_list_get(img->layers, 0);
s_list_remove(img->layers, 0);
s_image_layer_uninit(img_);
}
s_list_uninit(img->layers);
img->layers = NULL;
return 0;
}
static void button1_pressed (w_object_t *object, int button)
{
int i;
int w;
int h;
w_object_t *obj;
w = object->window->window->surface->buf->w;
h = object->window->window->surface->buf->h;
for (i = 0; !s_list_eol(area->object->childs, i); i++) {
obj = (w_object_t *) s_list_get(area->object->childs, i);
w_object_move(obj, (rand() + 1) % (w - 10), (rand() + 1) % (h - 100),
(rand() + 1) % (w - 10), (rand() + 1) % (h - 100));
}
w_signal_send(object, object, button1_signal_func, NULL);
}
int w_clistbox_item_add (w_object_t *object, w_clistbox_item_t *item)
{
w_clistbox_t *lb;
w_clistbox_item_t *active;
lb = object->data[OBJECT_CLISTBOX];
active = s_list_get(lb->items, lb->active);
s_list_add(lb->items, item, -1);
if (active == NULL) {
lb->active = 0;
} else {
lb->active = s_list_get_pos(lb->items, active);
}
// w_object_draw(object);
return 0;
}
void taskbar_clean_smenu (s_list_t *list)
{
smenu_prog_t *p;
while (!s_list_eol(list, 0)) {
p = s_list_get(list, 0);
s_list_remove(list, 0);
s_free(p->name);
s_free(p->icon);
s_free(p->menu);
s_free(p->exec);
taskbar_clean_smenu(p->progs);
s_free(p);
}
s_free(list);
}
