e16
/
e16
3
0
Fork 1
Code Issues Pull Requests Projects Releases Wiki Activity
e16/src/dialog.c

2571 lines
60 KiB
C
Raw Blame History

/*
* Copyright (C) 2000-2007 Carsten Haitzler, Geoff Harrison and various contributors
* Copyright (C) 2004-2007 Kim Woelders
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies of the Software, its documentation and marketing & publicity
* materials, and acknowledgment shall be given in the documentation, materials
* and software packages that this Software was used.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include "E.h"
#include "dialog.h"
#include "e16-ecore_list.h"
#include "eimage.h"
#include "ewins.h"
#include "hints.h"
#include "iclass.h"
#include "tclass.h"
#include "timers.h"
#include "xwin.h"
#define DEBUG_DIALOGS 0
typedef struct
{
char horizontal;
char numeric;
char numeric_side;
int upper;
int lower;
int unit;
int jump;
int val;
int *val_ptr;
int min_length;
int base_orig_w, base_orig_h;
int knob_orig_w, knob_orig_h;
int border_orig_w, border_orig_h;
int base_x, base_y, base_w, base_h;
int knob_x, knob_y, knob_w, knob_h;
int border_x, border_y, border_w, border_h;
int numeric_x, numeric_y, numeric_w, numeric_h;
ImageClass *ic_base;
ImageClass *ic_knob;
ImageClass *ic_border;
char in_drag;
int wanted_val;
Win base_win;
Win knob_win;
Win border_win;
} DItemSlider;
typedef struct
{
Win area_win;
int w, h;
DialogItemCallbackFunc *init_func;
DialogItemCallbackFunc *event_func;
} DItemArea;
typedef struct
{
Win check_win;
int check_orig_w, check_orig_h;
char onoff;
char *onoff_ptr;
} DItemCheckButton;
typedef struct
{
char *image;
} DItemImage;
typedef struct
{
char horizontal;
} DItemSeparator;
typedef struct
{
int num_columns;
char border;
char homogenous_h;
char homogenous_v;
int num_items;
DItem **items;
} DItemTable;
typedef struct
{
Win radio_win;
int radio_orig_w, radio_orig_h;
char onoff;
int val;
int *val_ptr;
DItem *next;
DItem *first;
DialogItemCallbackFunc *event_func;
} DItemRadioButton;
struct _ditem
{
int type;
Dialog *dlg;
DialogCallbackFunc *func;
int val;
void *data;
ImageClass *iclass;
TextClass *tclass;
EImageBorder padding;
char fill_h;
char fill_v;
char do_close;
int align_h;
int align_v;
int row_span;
int col_span;
int x, y, w, h;
Win win;
char *text;
union
{
DItemCheckButton check_button;
DItemTable table;
DItemImage image;
DItemSeparator separator;
DItemRadioButton radio_button;
DItemSlider slider;
DItemArea area;
}
item;
char realized;
char update;
char state;
char hilited;
char clicked;
};
typedef struct
{
KeyCode key;
DialogCallbackFunc *func;
int val;
void *data;
} DKeyBind;
struct _dialog
{
EWin *ewin;
Win win;
Pixmap pmap;
int w, h;
char *name;
char *title;
PmapMask pmm_bg;
TextClass *tclass;
ImageClass *iclass;
DItem *item;
DialogCallbackFunc *exit_func;
int exit_val;
int num_bindings;
DKeyBind *keybindings;
void *data;
char redraw;
char update;
char resize;
char close;
int xu1, yu1, xu2, yu2;
};
static EWin *FindEwinByDialog(Dialog * d);
static int FindADialog(void);
static void DialogHandleEvents(Win win, XEvent * ev, void *prm);
static void DItemHandleEvents(Win win, XEvent * ev, void *prm);
static void MoveTableBy(Dialog * d, DItem * di, int dx, int dy);
static void DialogItemsRealize(Dialog * d);
static void DialogItemDestroy(DItem * di, int clean);
static int DialogItemCheckButtonGetState(DItem * di);
static void DialogUpdate(Dialog * d);
static void DialogAddFooter(Dialog * d, DItem * parent,
int flags, DialogCallbackFunc * cb);
static void DialogAddHeader(Dialog * d, DItem * parent,
const char *img, const char *txt);
static Ecore_List *dialog_list = NULL;
static char dialog_update_pending = 0;
void
DialogBindKey(Dialog * d, const char *key, DialogCallbackFunc * func, int val,
void *data)
{
d->num_bindings++;
if (!d->keybindings)
d->keybindings = Emalloc(sizeof(DKeyBind) * d->num_bindings);
else
d->keybindings =
Erealloc(d->keybindings, sizeof(DKeyBind) * d->num_bindings);
d->keybindings[d->num_bindings - 1].val = val;
d->keybindings[d->num_bindings - 1].func = func;
d->keybindings[d->num_bindings - 1].data = data;
d->keybindings[d->num_bindings - 1].key =
XKeysymToKeycode(disp, XStringToKeysym(key));
}
void
DialogKeybindingsDestroy(Dialog * d)
{
_EFREE(d->keybindings);
d->num_bindings = 0;
}
Dialog *
DialogCreate(const char *name)
{
Dialog *d;
d = Ecalloc(1, sizeof(Dialog));
if (!d)
return NULL;
if (!dialog_list)
dialog_list = ecore_list_new();
ecore_list_append(dialog_list, d);
d->name = Estrdup(name);
d->win = ECreateClientWindow(VRoot.win, -20, -20, 2, 2);
EventCallbackRegister(d->win, 0, DialogHandleEvents, d);
d->tclass = TextclassFind("DIALOG", 1);
if (d->tclass)
TextclassIncRefcount(d->tclass);
d->iclass = ImageclassFind("DIALOG", 1);
if (d->iclass)
ImageclassIncRefcount(d->iclass);
d->xu1 = d->yu1 = 99999;
d->xu2 = d->yu2 = 0;
return d;
}
static void
DialogDestroy(Dialog * d)
{
ecore_list_remove_node(dialog_list, d);
if (d->name)
Efree(d->name);
if (d->title)
Efree(d->title);
DialogKeybindingsDestroy(d);
if (d->item)
DialogItemDestroy(d->item, 0);
if (d->iclass)
ImageclassDecRefcount(d->iclass);
if (d->tclass)
TextclassDecRefcount(d->tclass);
FreePmapMask(&(d->pmm_bg));
EFreePixmap(d->pmap);
EDestroyWindow(d->win);
Efree(d);
}
static int
_DialogMatchName(const void *data, const void *match)
{
return strcmp(((const Dialog *)data)->name, match);
}
Dialog *
DialogFind(const char *name)
{
return ecore_list_find(dialog_list, _DialogMatchName, name);
}
void
DialogSetTitle(Dialog * d, const char *title)
{
if (d->title)
Efree(d->title);
d->title = Estrdup(title);
HintsSetWindowName(d->win, d->title);
}
void
DialogSetExitFunction(Dialog * d, DialogCallbackFunc * func, int val)
{
d->exit_func = func;
d->exit_val = val;
}
void
DialogCallExitFunction(Dialog * d)
{
if (d->exit_func)
d->exit_func(d, d->exit_val, NULL);
}
void
DialogSetData(Dialog * d, void *data)
{
d->data = data;
}
void *
DialogGetData(Dialog * d)
{
return d->data;
}
#if 0 /* FIXME - Merge/remove */
void
DialogAddButton(Dialog * d, const char *text, DialogCallbackFunc * func,
char doclose, int image)
{
DButton *db;
int w, h;
EImageBorder *pad;
db = Emalloc(sizeof(DButton));
d->num_buttons++;
d->button = Erealloc(d->button, d->num_buttons * (sizeof(DButton *)));
d->button[d->num_buttons - 1] = db;
db->parent = d;
db->text = Estrdup(text);
db->func = func;
db->image = image;
db->win = ECreateWindow(d->win, -20, -20, 2, 2, 0);
EventCallbackRegister(db->win, 0, DButtonHandleEvents, db);
EMapWindow(db->win);
db->x = -1;
db->y = -1;
db->w = -1;
db->h = -1;
db->hilited = 0;
db->clicked = 0;
db->close = doclose;
db->tclass = TextclassFind("DIALOG_BUTTON", 1);
if (db->tclass)
TextclassIncRefcount(db->tclass);
db->iclass = ImageclassFind("DIALOG_BUTTON", 1);
if (db->iclass)
ImageclassIncRefcount(db->iclass);
TextSize(db->tclass, 0, 0, STATE_NORMAL, text, &w, &h, 17);
pad = ImageclassGetPadding(db->iclass);
db->h = h + pad->top + pad->bottom;
db->w = w + pad->left + pad->right;
if (Conf.dialogs.button_image && db->image)
db->w += h + 2;
ESelectInput(db->win,
EnterWindowMask | LeaveWindowMask | ButtonPressMask |
ButtonReleaseMask);
}
static void
DialogDrawButton(Dialog * d __UNUSED__, DButton * db)
{
int state;
EImage *im;
state = STATE_NORMAL;
if ((db->hilited) && (db->clicked))
{
state = STATE_CLICKED;
}
else if ((db->hilited) && (!db->clicked))
{
state = STATE_HILITED;
}
else if (!(db->hilited) && (db->clicked))
{
state = STATE_CLICKED;
}
im = NULL;
if (Conf.dialogs.button_image)
{
switch (db->image)
{
case DLG_BUTTON_OK:
im = ThemeImageLoad("pix/ok.png");
break;
case DLG_BUTTON_CANCEL:
im = ThemeImageLoad("pix/cancel.png");
break;
case DLG_BUTTON_APPLY:
im = ThemeImageLoad("pix/apply.png");
break;
case DLG_BUTTON_CLOSE:
im = ThemeImageLoad("pix/close.png");
break;
default:
break;
}
}
if (im)
{
ImageClass *ic = db->iclass;
EImageBorder *pad;
int h;
ImageclassApply(db->iclass, db->win, db->w, db->h, 0, 0, state,
ST_WIDGET);
pad = ImageclassGetPadding(ic);
h = db->h - (pad->top + pad->bottom);
TextDraw(db->tclass, db->win, None, 0, 0, state, db->text,
h + 2 + pad->left, pad->top,
db->w - (h + 2 + pad->left + pad->right),
h, h, TextclassGetJustification(db->tclass));
EImageRenderOnDrawable(im, db->win, None, pad->left, pad->top, h, h, 1);
EImageFree(im);
}
else
{
ITApply(db->win, db->iclass, NULL, db->w, db->h, state, 0, 0,
ST_WIDGET, db->tclass, NULL, db->text);
}
}
#endif
DItem *
DialogItemAddButton(DItem * parent, const char *text, DialogCallbackFunc * func,
int val, char doclose, int image __UNUSED__)
{
DItem *di;
di = DialogAddItem(parent, DITEM_BUTTON);
DialogItemSetText(di, text);
DialogItemSetCallback(di, func, 0, NULL);
di->val = val;
di->do_close = doclose;
return di;
}
void
DialogRedraw(Dialog * d)
{
if ((!d->tclass) || (!d->iclass))
return;
#if DEBUG_DIALOGS
Eprintf("DialogRedraw win=%#lx pmap=%#lx\n", d->win, d->pmap);
#endif
FreePmapMask(&(d->pmm_bg));
ImageclassApplyCopy(d->iclass, d->win, d->w, d->h, 0, 0, STATE_NORMAL,
&(d->pmm_bg), 0, ST_DIALOG);
if (d->pmm_bg.pmap == None)
return;
if (d->resize || d->pmap == None)
{
if (d->pmap != None)
EFreePixmap(d->pmap);
d->pmap = ECreatePixmap(d->win, d->w, d->h, 0);
ESetWindowBackgroundPixmap(d->win, d->pmap);
}
EXCopyArea(d->pmm_bg.pmap, d->pmap, 0, 0, d->w, d->h, 0, 0);
d->redraw = 1;
DialogDrawItems(d, d->item, 0, 0, 99999, 99999);
}
static void
DialogEwinMoveResize(EWin * ewin, int resize __UNUSED__)
{
Dialog *d = ewin->data;
if (!d || Mode.mode != MODE_NONE || !EoIsShown(ewin))
return;
if (TransparencyUpdateNeeded() || ImageclassIsTransparent(d->iclass))
DialogRedraw(d);
}
static void
DialogEwinClose(EWin * ewin)
{
DialogDestroy(ewin->data);
ewin->client.win = NULL;
ewin->data = NULL;
}
static const EWinOps DialogEwinOps = {
NULL,
DialogEwinMoveResize,
DialogEwinClose,
};
static void
DialogEwinInit(EWin * ewin, void *ptr)
{
ewin->data = ptr;
ewin->ops = &DialogEwinOps;
ewin->props.focus_when_mapped = 1;
EoSetLayer(ewin, 10);
}
void
DialogArrange(Dialog * d, int resize)
{
if (resize)
DialogItemsRealize(d);
ICCCM_SetSizeConstraints(d->ewin, d->w, d->h, d->w, d->h, 0, 0, 1, 1,
0.0, 65535.0);
if (resize)
{
EwinResize(d->ewin, d->w, d->h);
d->resize = 1;
DialogRedraw(d);
DialogUpdate(d);
d->resize = 0;
ArrangeEwinCentered(d->ewin);
}
}
static void
DialogShowArranged(Dialog * d, int center)
{
EWin *ewin;
ewin = FindEwinByDialog(d);
if (ewin)
{
#if 0 /* Make dialogs sticky? */
if (EoGetDesk(ewin) != DesksGetCurrent())
EwinMoveToDesktop(ewin, DesksGetCurrent());
#endif
EwinRaise(ewin);
EwinShow(ewin);
return;
}
DialogItemsRealize(d);
HintsSetWindowClass(d->win, d->name, "Enlightenment_Dialog");
ewin = AddInternalToFamily(d->win, "DIALOG", EWIN_TYPE_DIALOG, d,
DialogEwinInit);
d->ewin = ewin;
if (!ewin)
return;
DialogArrange(d, 0);
ewin->client.event_mask |= KeyPressMask;
ESelectInput(d->win, ewin->client.event_mask);
EwinMoveToDesktop(ewin, EoGetDesk(ewin));
if (ewin->state.placed)
{
EwinMoveResize(ewin, EoGetX(ewin), EoGetY(ewin), d->w, d->h);
}
else
{
EwinResize(ewin, d->w, d->h);
if (center || FindADialog() == 1)
ArrangeEwinCentered(ewin);
else
ArrangeEwin(ewin);
}
DialogRedraw(d);
DialogUpdate(d);
EwinShow(ewin);
}
void
DialogShow(Dialog * d)
{
DialogShowArranged(d, 0);
}
void
DialogShowCentered(Dialog * d)
{
DialogShowArranged(d, 1);
}
void
DialogClose(Dialog * d)
{
d->close = 1;
}
static void
_DialogClose(Dialog * d)
{
if (!d)
return;
DialogCallExitFunction(d);
EwinHide(d->ewin);
}
void
DialogShowSimple(const DialogDef * dd, void *data)
{
DialogShowSimpleWithName(dd, dd->name, data);
}
void
DialogFill(Dialog * d, DItem * parent, const DialogDef * dd, void *data)
{
DItem *content;
if (Conf.dialogs.headers && (dd->header_image || dd->header_text))
DialogAddHeader(d, parent, dd->header_image, _(dd->header_text));
content = DialogAddItem(parent, DITEM_TABLE);
if (!content)
return;
dd->fill(d, content, data);
if (dd->func)
DialogAddFooter(d, parent, dd->flags, dd->func);
}
void
DialogShowSimpleWithName(const DialogDef * dd, const char *name, void *data)
{
Dialog *d;
DItem *table;
d = DialogFind(name);
if (d)
{
SoundPlay("SOUND_SETTINGS_ACTIVE");
DialogShow(d);
return;
}
SoundPlay(dd->sound);
d = DialogCreate(name);
if (!d)
return;
DialogSetTitle(d, _(dd->title));
table = DialogInitItem(d);
if (!table)
return;
DialogFill(d, table, dd, data);
DialogShow(d);
}
static DItem *
DialogItemCreate(int type)
{
DItem *di;
di = Ecalloc(1, sizeof(DItem));
di->type = type;
di->align_h = 512;
di->align_v = 512;
di->row_span = 1;
di->col_span = 1;
di->item.table.num_columns = 1;
di->item.table.border = 0;
di->item.table.homogenous_h = 0;
di->item.table.homogenous_v = 0;
di->item.table.num_items = 0;
di->item.table.items = NULL;
DialogItemSetPadding(di, 2, 2, 2, 2);
DialogItemSetFill(di, 1, 0);
return di;
}
DItem *
DialogInitItem(Dialog * d)
{
DItem *di;
if (d->item)
return NULL;
di = DialogItemCreate(DITEM_TABLE);
d->item = di;
if (!di)
return di;
di->dlg = d;
di->item.table.num_columns = 1;
return di;
}
DItem *
DialogAddItem(DItem * dii, int type)
{
DItem *di;
di = DialogItemCreate(type);
if (!di)
return di;
switch (di->type)
{
default:
break;
case DITEM_AREA:
di->item.area.w = 32;
di->item.area.h = 32;
break;
case DITEM_CHECKBUTTON:
di->item.check_button.check_win = 0;
di->item.check_button.onoff = 0;
di->item.check_button.onoff_ptr = &(di->item.check_button.onoff);
di->item.check_button.check_orig_w = 10;
di->item.check_button.check_orig_h = 10;
break;
case DITEM_TABLE:
di->item.table.num_columns = 1;
di->item.table.border = 0;
di->item.table.homogenous_h = 0;
di->item.table.homogenous_v = 0;
di->item.table.num_items = 0;
di->item.table.items = NULL;
break;
case DITEM_IMAGE:
di->item.image.image = NULL;
break;
case DITEM_SEPARATOR:
di->item.separator.horizontal = 0;
break;
case DITEM_RADIOBUTTON:
di->item.radio_button.radio_win = 0;
di->item.radio_button.onoff = 0;
di->item.radio_button.val = 0;
di->item.radio_button.val_ptr = 0;
di->item.radio_button.next = NULL;
di->item.radio_button.first = NULL;
di->item.radio_button.radio_orig_w = 10;
di->item.radio_button.radio_orig_h = 10;
di->item.radio_button.event_func = NULL;
break;
case DITEM_SLIDER:
di->item.slider.horizontal = 1;
di->item.slider.numeric = 0;
di->item.slider.numeric_side = 0;
di->item.slider.upper = 100;
di->item.slider.lower = 0;
di->item.slider.unit = 10;
di->item.slider.jump = 20;
di->item.slider.val = 0;
di->item.slider.val_ptr = NULL;
di->item.slider.min_length = 64;
di->item.slider.ic_base = NULL;
di->item.slider.ic_knob = NULL;
di->item.slider.ic_border = NULL;
di->item.slider.base_win = 0;
di->item.slider.knob_win = 0;
di->item.slider.border_win = 0;
di->item.slider.base_orig_w = 10;
di->item.slider.base_orig_h = 10;
di->item.slider.knob_orig_w = 6;
di->item.slider.knob_orig_h = 6;
di->item.slider.border_orig_w = 14;
di->item.slider.border_orig_h = 14;
di->item.slider.base_x = 0;
di->item.slider.base_y = 0;
di->item.slider.base_w = 0;
di->item.slider.base_h = 0;
di->item.slider.knob_x = 0;
di->item.slider.knob_y = 0;
di->item.slider.knob_w = 0;
di->item.slider.knob_h = 0;
di->item.slider.border_x = 0;
di->item.slider.border_y = 0;
di->item.slider.border_w = 0;
di->item.slider.border_h = 0;
di->item.slider.numeric_x = 0;
di->item.slider.numeric_y = 0;
di->item.slider.numeric_w = 0;
di->item.slider.numeric_h = 0;
di->item.slider.in_drag = 0;
di->item.slider.wanted_val = 0;
break;
}
if (dii)
{
dii->item.table.num_items++;
dii->item.table.items =
Erealloc(dii->item.table.items,
sizeof(DItem *) * dii->item.table.num_items);
dii->item.table.items[dii->item.table.num_items - 1] = di;
di->dlg = dii->dlg;
}
return di;
}
static void
DialogAddHeader(Dialog * d __UNUSED__, DItem * parent, const char *img,
const char *txt)
{
DItem *table, *di;
table = DialogAddItem(parent, DITEM_TABLE);
DialogItemTableSetOptions(table, 2, 0, 0, 0);
DialogItemSetAlign(table, 512, 0);
DialogItemSetFill(table, 0, 0);
di = DialogAddItem(table, DITEM_IMAGE);
DialogItemImageSetFile(di, img);
di = DialogAddItem(table, DITEM_TEXT);
DialogItemSetText(di, txt);
di = DialogAddItem(parent, DITEM_SEPARATOR);
}
static void
DialogAddFooter(Dialog * d, DItem * parent, int flags, DialogCallbackFunc * cb)
{
DItem *table, *di;
int n_buttons;
if (!(flags & DLG_NO_SEPARATOR))
di = DialogAddItem(parent, DITEM_SEPARATOR);
table = DialogAddItem(parent, DITEM_TABLE);
DialogItemSetAlign(table, 512, 0);
DialogItemSetFill(table, 0, 0);
/* FIXME - The "real" dialog buttons are slightly different */
n_buttons = 0;
if (flags & 1)
{
di = DialogItemAddButton(table, _("OK"), cb, 0, 1, DLG_BUTTON_OK);
n_buttons++;
}
if (flags & 2)
{
di = DialogItemAddButton(table, _("Apply"), cb, 1, 0, DLG_BUTTON_APPLY);
DialogBindKey(d, "Return", cb, 1, NULL);
n_buttons++;
}
if (flags & 4)
{
di =
DialogItemAddButton(table, _("Close"), NULL, 0, 1, DLG_BUTTON_CLOSE);
DialogBindKey(d, "Escape", DialogCallbackClose, 0, NULL);
n_buttons++;
}
DialogItemTableSetOptions(table, n_buttons, 0, 1, 0);
DialogSetExitFunction(d, cb, 2);
}
Dialog *
DialogItemGetDialog(DItem * di)
{
return di->dlg;
}
void
DialogItemSetCallback(DItem * di, DialogCallbackFunc * func, int val,
void *data)
{
di->func = func;
di->val = val;
di->data = data;
}
#if 0 /* Unused */
void
DialogItemSetClass(DItem * di, ImageClass * iclass, TextClass * tclass)
{
if (di->iclass)
ImageclassDecRefcount(di->iclass);
di->iclass = iclass;
if (di->iclass)
ImageclassIncRefcount(di->iclass);
if (di->tclass)
TextclassDecRefcount(di->tclass);
di->tclass = tclass;
if (di->tclass)
TextclassIncRefcount(di->tclass);
}
#endif
void
DialogItemSetPadding(DItem * di, int left, int right, int top, int bottom)
{
di->padding.left = left;
di->padding.right = right;
di->padding.top = top;
di->padding.bottom = bottom;
}
void
DialogItemSetFill(DItem * di, char fill_h, char fill_v)
{
di->fill_h = fill_h;
di->fill_v = fill_v;
}
void
DialogItemSetAlign(DItem * di, int align_h, int align_v)
{
di->align_h = align_h;
di->align_v = align_v;
}
void
DialogItemSetRowSpan(DItem * di, int row_span)
{
di->row_span = row_span;
}
void
DialogItemSetColSpan(DItem * di, int col_span)
{
di->col_span = col_span;
}
void
DialogItemCallCallback(Dialog * d, DItem * di)
{
if (di->func)
di->func(d, di->val, di->data);
}
static void
DialogRealizeItem(Dialog * d, DItem * di)
{
const char *def = NULL;
int iw = 0, ih = 0;
int register_win_callback;
EImage *im;
EImageBorder *pad;
if (di->realized && di->type != DITEM_TABLE)
return;
di->realized = 1;
if (di->type == DITEM_BUTTON)
{
def = "DIALOG_WIDGET_BUTTON";
}
else if (di->type == DITEM_CHECKBUTTON)
{
def = "DIALOG_WIDGET_CHECK_BUTTON";
}
else if (di->type == DITEM_TEXT)
{
def = "DIALOG_WIDGET_TEXT";
}
else if (di->type == DITEM_SEPARATOR)
{
def = "DIALOG_WIDGET_SEPARATOR";
}
else if (di->type == DITEM_TABLE)
{
def = "DIALOG_WIDGET_TABLE";
}
else if (di->type == DITEM_RADIOBUTTON)
{
def = "DIALOG_WIDGET_RADIO_BUTTON";
}
else if (di->type == DITEM_AREA)
{
def = "DIALOG_WIDGET_AREA";
}
else
{
def = "DIALOG_WIDGET_BUTTON";
}
if (!di->tclass)
di->tclass = TextclassFind(def, 1);
if (!di->iclass)
di->iclass = ImageclassFind(def, 1);
if (di->tclass)
TextclassIncRefcount(di->tclass);
if (di->iclass)
ImageclassIncRefcount(di->iclass);
if (di->type == DITEM_TABLE)
{
int i;
for (i = 0; i < di->item.table.num_items; i++)
DialogRealizeItem(d, di->item.table.items[i]);
}
register_win_callback = 1;
switch (di->type)
{
case DITEM_SLIDER:
if (di->item.slider.numeric)
{
di->win = ECreateWindow(d->win, -20, -20, 2, 2, 0);
EMapWindow(di->win);
ESelectInput(di->win,
EnterWindowMask | LeaveWindowMask | ButtonPressMask
| ButtonReleaseMask);
}
di->item.slider.base_win = ECreateWindow(d->win, -20, -20, 2, 2, 0);
EMapWindow(di->item.slider.base_win);
di->item.slider.knob_win = ECreateWindow(d->win, -20, -20, 2, 2, 0);
EMapWindow(di->item.slider.knob_win);
ESelectInput(di->item.slider.base_win,
EnterWindowMask | LeaveWindowMask | ButtonPressMask |
ButtonReleaseMask);
EventCallbackRegister(di->item.slider.base_win, 0, DItemHandleEvents,
di);
ESelectInput(di->item.slider.knob_win,
ButtonPressMask | ButtonReleaseMask | PointerMotionMask);
EventCallbackRegister(di->item.slider.knob_win, 0, DItemHandleEvents,
di);
if (!di->item.slider.ic_base)
{
if (di->item.slider.horizontal)
{
di->item.slider.ic_base =
ImageclassFind("DIALOG_WIDGET_SLIDER_BASE_HORIZONTAL", 1);
}
else
{
di->item.slider.ic_base =
ImageclassFind("DIALOG_WIDGET_SLIDER_BASE_VERTICAL", 1);
}
}
im = ImageclassGetImage(di->item.slider.ic_base, 0, 0, 0);
if (im)
{
EImageGetSize(im, &di->item.slider.base_orig_w,
&di->item.slider.base_orig_h);
EImageFree(im);
}
if (di->item.slider.ic_base)
ImageclassIncRefcount(di->item.slider.ic_base);
if (!di->item.slider.ic_knob)
{
if (di->item.slider.horizontal)
{
di->item.slider.ic_knob =
ImageclassFind("DIALOG_WIDGET_SLIDER_KNOB_HORIZONTAL", 1);
}
else
{
di->item.slider.ic_knob =
ImageclassFind("DIALOG_WIDGET_SLIDER_KNOB_VERTICAL", 1);
}
}
if (di->item.slider.ic_knob)
ImageclassIncRefcount(di->item.slider.ic_knob);
im = ImageclassGetImage(di->item.slider.ic_knob, 0, 0, 0);
if (im)
{
EImageGetSize(im, &di->item.slider.knob_orig_w,
&di->item.slider.knob_orig_h);
EImageFree(im);
}
if (!di->item.slider.ic_border)
{
if (di->item.slider.horizontal)
{
di->item.slider.ic_border =
ImageclassFind("DIALOG_WIDGET_SLIDER_BORDER_HORIZONTAL",
0);
}
else
{
di->item.slider.ic_border =
ImageclassFind("DIALOG_WIDGET_SLIDER_BORDER_VERTICAL", 0);
}
}
if (di->item.slider.ic_border)
{
im = ImageclassGetImage(di->item.slider.ic_border, 0, 0, 0);
if (im)
{
EImageGetSize(im, &di->item.slider.border_orig_w,
&di->item.slider.border_orig_h);
EImageFree(im);
di->item.slider.border_win =
ECreateWindow(d->win, -20, -20, 2, 2, 0);
EMapWindow(di->item.slider.border_win);
}
ImageclassIncRefcount(di->item.slider.ic_border);
}
pad = ImageclassGetPadding(di->item.slider.ic_base);
if (di->item.slider.horizontal)
{
iw = di->item.slider.min_length + pad->left + pad->right;
ih = di->item.slider.base_orig_h;
}
else
{
iw = di->item.slider.base_orig_w;
ih = di->item.slider.min_length + pad->top + pad->bottom;
}
di->w = iw;
di->h = ih;
break;
case DITEM_BUTTON:
pad = ImageclassGetPadding(di->iclass);
TextSize(di->tclass, 0, 0, STATE_NORMAL, di->text, &iw, &ih, 17);
iw += pad->left + pad->right;
ih += pad->top + pad->bottom;
di->win = ECreateWindow(d->win, -20, -20, 2, 2, 0);
EMapWindow(di->win);
ESelectInput(di->win,
EnterWindowMask | LeaveWindowMask | ButtonPressMask |
ButtonReleaseMask);
di->w = iw;
di->h = ih;
break;
case DITEM_AREA:
pad = ImageclassGetPadding(di->iclass);
iw = di->item.area.w;
ih = di->item.area.h;
iw += pad->left + pad->right;
ih += pad->top + pad->bottom;
di->win = ECreateWindow(d->win, -20, -20, 2, 2, 0);
EMapWindow(di->win);
di->item.area.area_win = ECreateWindow(di->win, -20, -20, 2, 2, 0);
EMapWindow(di->item.area.area_win);
ESelectInput(di->item.area.area_win,
EnterWindowMask | LeaveWindowMask | ButtonPressMask |
ButtonReleaseMask | PointerMotionMask);
EventCallbackRegister(di->item.area.area_win, 0, DItemHandleEvents, di);
di->w = iw;
di->h = ih;
break;
case DITEM_CHECKBUTTON:
pad = ImageclassGetPadding(di->iclass);
im = ImageclassGetImage(di->iclass, 0, 0, 0);
if (im)
{
EImageGetSize(im, &di->item.check_button.check_orig_w,
&di->item.check_button.check_orig_h);
EImageFree(im);
}
TextSize(di->tclass, 0, 0, STATE_NORMAL, di->text, &iw, &ih, 17);
if (ih < di->item.check_button.check_orig_h)
ih = di->item.check_button.check_orig_h;
iw += di->item.check_button.check_orig_w + pad->left;
di->item.check_button.check_win =
ECreateWindow(d->win, -20, -20, 2, 2, 0);
di->win = ECreateEventWindow(d->win, -20, -20, 2, 2);
EMapWindow(di->item.check_button.check_win);
EMapWindow(di->win);
ESelectInput(di->win,
EnterWindowMask | LeaveWindowMask | ButtonPressMask |
ButtonReleaseMask);
di->w = iw;
di->h = ih;
break;
case DITEM_TEXT:
TextSize(di->tclass, 0, 0, STATE_NORMAL, di->text, &iw, &ih, 17);
di->w = iw;
di->h = ih;
break;
case DITEM_IMAGE:
im = ThemeImageLoad(di->item.image.image);
if (im)
{
Pixmap pmap = 0, mask = 0;
EImageGetSize(im, &iw, &ih);
di->win = ECreateWindow(d->win, 0, 0, iw, ih, 0);
EMapWindow(di->win);
EImageRenderPixmaps(im, di->win, &pmap, &mask, 0, 0);
ESetWindowBackgroundPixmap(di->win, pmap);
EShapeCombineMask(di->win, ShapeBounding, 0, 0, mask, ShapeSet);
EClearWindow(di->win);
EImagePixmapFree(pmap);
EImageFree(im);
}
di->w = iw;
di->h = ih;
register_win_callback = 0;
break;
case DITEM_SEPARATOR:
pad = ImageclassGetPadding(di->iclass);
iw = pad->left + pad->right;
ih = pad->top + pad->bottom;
di->win = ECreateWindow(d->win, -20, -20, 2, 2, 0);
EMapWindow(di->win);
di->w = iw;
di->h = ih;
register_win_callback = 0;
break;
case DITEM_RADIOBUTTON:
pad = ImageclassGetPadding(di->iclass);
im = ImageclassGetImage(di->iclass, 0, 0, 0);
if (im)
{
EImageGetSize(im, &di->item.radio_button.radio_orig_w,
&di->item.radio_button.radio_orig_h);
EImageFree(im);
}
TextSize(di->tclass, 0, 0, STATE_NORMAL, di->text, &iw, &ih, 17);
if (ih < di->item.radio_button.radio_orig_h)
ih = di->item.radio_button.radio_orig_h;
iw += di->item.radio_button.radio_orig_w + pad->left;
di->item.radio_button.radio_win =
ECreateWindow(d->win, -20, -20, 2, 2, 0);
di->win = ECreateEventWindow(d->win, -20, -20, 2, 2);
EMapWindow(di->item.radio_button.radio_win);
EMapWindow(di->win);
ESelectInput(di->win,
EnterWindowMask | LeaveWindowMask | ButtonPressMask |
ButtonReleaseMask);
di->w = iw;
di->h = ih;
break;
case DITEM_TABLE:
{
int cols, rows;
pad = ImageclassGetPadding(d->iclass);
cols = di->item.table.num_columns;
rows = 1;
if (cols > 0)
{
int i, r, c, x, y;
int *col_size, *row_size;
col_size = Emalloc(sizeof(int) * cols);
row_size = Emalloc(sizeof(int) * rows);
row_size[0] = 0;
for (i = 0; i < cols; i++)
col_size[i] = 0;
r = c = 0;
for (i = 0; i < di->item.table.num_items; i++)
{
DItem *dii;
int w, h, j, ww;
dii = di->item.table.items[i];
w = dii->w + (dii->padding.left + dii->padding.right);
h = dii->h + (dii->padding.top + dii->padding.bottom);
ww = 0;
for (j = 0; j < dii->col_span; j++)
ww += col_size[c + j];
if (w > ww)
{
ww = (w + dii->col_span - 1) / dii->col_span;
for (j = 0; j < dii->col_span; j++)
if (col_size[c + j] < ww)
col_size[c + j] = ww;
}
if (h > row_size[r])
row_size[r] = h;
c += dii->col_span;
if (c >= cols)
{
c = 0;
r++;
rows++;
row_size = Erealloc(row_size, sizeof(int) * rows);
row_size[rows - 1] = 0;
}
}
if (di->item.table.homogenous_h)
{
int max = 0;
for (i = 0; i < cols; i++)
{
if (col_size[i] > max)
max = col_size[i];
}
for (i = 0; i < cols; i++)
col_size[i] = max;
}
if (di->item.table.homogenous_v)
{
int max = 0;
for (i = 0; i < rows; i++)
{
if (row_size[i] > max)
max = row_size[i];
}
for (i = 0; i < rows; i++)
row_size[i] = max;
}
iw = ih = 0;
for (i = 0; i < cols; i++)
iw += col_size[i];
for (i = 0; i < rows; i++)
ih += row_size[i];
di->w = iw;
di->h = ih;
x = y = 0;
r = c = 0;
for (i = 0; i < di->item.table.num_items; i++)
{
DItem *dii;
int j, sw = 0, sh = 0;
dii = di->item.table.items[i];
for (j = 0; j < dii->col_span; j++)
sw += col_size[c + j];
for (j = 0; j < dii->row_span; j++)
sh += row_size[r + j];
if (dii->fill_h)
dii->w = sw - (dii->padding.left + dii->padding.right);
if (dii->fill_v)
dii->h = sh - (dii->padding.top + dii->padding.bottom);
if (dii->type == DITEM_TABLE)
{
int dx, dy, newx, newy;
newx =
di->x + x + pad->left +
dii->padding.left +
(((sw
- (dii->padding.left + dii->padding.right) -
dii->w) * dii->align_h) >> 10);
newy =
di->y + y + pad->top +
dii->padding.top +
(((sh
- (dii->padding.top + dii->padding.bottom) -
dii->h) * dii->align_v) >> 10);
dx = newx - dii->x - pad->left;
dy = newy - dii->y - pad->top;
MoveTableBy(d, dii, dx, dy);
}
else
{
dii->x =
di->x + x + pad->left +
dii->padding.left +
(((sw
- (dii->padding.left + dii->padding.right) -
dii->w) * dii->align_h) >> 10);
dii->y =
di->y + y + pad->top +
dii->padding.top +
(((sh
- (dii->padding.top + dii->padding.bottom) -
dii->h) * dii->align_v) >> 10);
if (dii->win)
EMoveResizeWindow(dii->win, dii->x, dii->y,
dii->w, dii->h);
if (dii->type == DITEM_CHECKBUTTON)
EMoveResizeWindow(dii->item.check_button.
check_win, dii->x,
dii->y +
((dii->h -
dii->item.check_button.
check_orig_h) / 2),
dii->item.check_button.
check_orig_w,
dii->item.check_button.
check_orig_h);
if (dii->type == DITEM_RADIOBUTTON)
EMoveResizeWindow(dii->item.radio_button.
radio_win, dii->x,
dii->y +
((dii->h -
dii->item.radio_button.
radio_orig_h) / 2),
dii->item.radio_button.
radio_orig_w,
dii->item.radio_button.
radio_orig_h);
if (dii->type == DITEM_AREA)
{
pad = ImageclassGetPadding(dii->iclass);
dii->item.area.w =
dii->w - (pad->left + pad->right);
dii->item.area.h =
dii->h - (pad->top + pad->bottom);
EMoveResizeWindow(dii->item.area.area_win,
pad->left, pad->top,
dii->item.area.w,
dii->item.area.h);
}
if (dii->type == DITEM_SLIDER)
{
dii->item.slider.base_x = 0;
dii->item.slider.base_y = 0;
dii->item.slider.base_w = dii->w;
dii->item.slider.base_h = dii->h;
dii->item.slider.border_x = 0;
dii->item.slider.border_y = 0;
dii->item.slider.border_w = dii->w;
dii->item.slider.border_h = dii->h;
dii->item.slider.knob_w =
dii->item.slider.knob_orig_w;
dii->item.slider.knob_h =
dii->item.slider.knob_orig_h;
if (dii->item.slider.base_win)
EMoveResizeWindow(dii->item.slider.base_win,
dii->x +
dii->item.slider.base_x,
dii->y +
dii->item.slider.base_y,
dii->item.slider.base_w,
dii->item.slider.base_h);
if (dii->item.slider.border_win)
EMoveResizeWindow(dii->item.slider.
border_win,
dii->x +
dii->item.slider.border_x,
dii->y +
dii->item.slider.border_y,
dii->item.slider.border_w,
dii->item.slider.border_h);
if (dii->win)
EMoveResizeWindow(dii->win,
dii->x +
dii->item.slider.
numeric_x,
dii->y +
dii->item.slider.
numeric_y,
dii->item.slider.
numeric_w,
dii->item.slider.numeric_h);
}
}
x += sw;
c += dii->col_span;
if (c >= cols)
{
x = 0;
y += row_size[r];
c = 0;
r++;
}
}
if (col_size)
Efree(col_size);
if (row_size)
Efree(row_size);
}
}
break;
case DITEM_NONE:
default:
di->w = 0;
di->h = 0;
break;
}
if (di->win && register_win_callback)
EventCallbackRegister(di->win, 0, DItemHandleEvents, di);
}
static void
MoveTableBy(Dialog * d, DItem * di, int dx, int dy)
{
int i;
di->x += dx;
di->y += dy;
for (i = 0; i < di->item.table.num_items; i++)
{
DItem *dii;
dii = di->item.table.items[i];
if (dii->type == DITEM_TABLE)
{
MoveTableBy(d, dii, dx, dy);
continue;
}
dii->x += dx;
dii->y += dy;
if (dii->win)
EMoveWindow(dii->win, dii->x, dii->y);
switch (dii->type)
{
case DITEM_CHECKBUTTON:
EMoveWindow(dii->item.check_button.check_win, dii->x,
dii->y +
((dii->h - dii->item.check_button.check_orig_h) / 2));
break;
case DITEM_RADIOBUTTON:
EMoveWindow(dii->item.radio_button.radio_win, dii->x,
dii->y +
((dii->h - dii->item.radio_button.radio_orig_h) / 2));
break;
case DITEM_SLIDER:
{
if (dii->item.slider.base_win)
EMoveResizeWindow(dii->item.slider.base_win,
dii->x + dii->item.slider.base_x,
dii->y + dii->item.slider.base_y,
dii->item.slider.base_w,
dii->item.slider.base_h);
if (dii->item.slider.knob_win)
EMoveResizeWindow(dii->item.slider.knob_win,
dii->x + dii->item.slider.knob_x,
dii->y + dii->item.slider.knob_y,
dii->item.slider.knob_w,
dii->item.slider.knob_h);
if (dii->item.slider.border_win)
EMoveResizeWindow(dii->item.slider.border_win,
dii->x + dii->item.slider.border_x,
dii->y + dii->item.slider.border_y,
dii->item.slider.border_w,
dii->item.slider.border_h);
if (dii->win)
EMoveResizeWindow(dii->win,
dii->x + dii->item.slider.numeric_x,
dii->y + dii->item.slider.numeric_y,
dii->item.slider.numeric_w,
dii->item.slider.numeric_h);
break;
}
}
}
}
void
DialogDrawItems(Dialog * d, DItem * di, int x, int y, int w, int h)
{
d->update = 1;
di->update = 1;
if (d->xu1 > x)
d->xu1 = x;
if (d->yu1 > y)
d->yu1 = y;
x += w;
y += h;
if (d->xu2 < x)
d->xu2 = x;
if (d->yu2 < y)
d->yu2 = y;
dialog_update_pending = 1;
#if DEBUG_DIALOGS
Eprintf("DialogDrawItems t=%d u=%d - %d,%d -> %d,%d\n", di->type, di->update,
d->xu1, d->yu1, d->xu2, d->yu2);
#endif
}
static void
DialogDrawItem(Dialog * d, DItem * di)
{
int state, x, w;
EImageBorder *pad;
if (!di->update && di->type != DITEM_TABLE)
return;
if (di->x > d->xu2 || di->y > d->yu2 ||
di->x + di->w <= d->xu1 || di->y + di->h <= d->yu1)
goto done;
#if DEBUG_DIALOGS
Eprintf("DialogDrawItem t=%d u=%d - %d,%d -> %d,%d\n", di->type, di->update,
d->xu1, d->yu1, d->xu2, d->yu2);
#endif
switch (di->type)
{
case DITEM_TABLE:
{
int i;
DItem *dii;
for (i = 0; i < di->item.table.num_items; i++)
{
dii = di->item.table.items[i];
if (di->update)
dii->update = 1;
DialogDrawItem(d, dii);
}
#if 0 /* Debug */
{
XGCValues gcv;
GC gc;
pad = ImageclassGetPadding(d->iclass);
gcv.subwindow_mode = IncludeInferiors;
gc = EXCreateGC(d->pmap, GCSubwindowMode, &gcv);
XSetForeground(disp, gc, BlackPixel(disp, VRoot.scr));
XDrawRectangle(disp, d->pmap, gc, pad->left + di->x,
pad->top + di->y, di->w, di->h);
EXFreeGC(gc);
}
#endif
}
break;
case DITEM_SLIDER:
if (di->item.slider.horizontal)
{
di->item.slider.knob_x =
di->item.slider.base_x +
(((di->item.slider.base_w -
di->item.slider.knob_w) * (di->item.slider.val -
di->item.slider.lower)) /
(di->item.slider.upper - di->item.slider.lower));
di->item.slider.knob_y =
di->item.slider.base_y +
((di->item.slider.base_h - di->item.slider.knob_h) / 2);
}
else
{
di->item.slider.knob_y =
(di->item.slider.base_y + di->item.slider.base_h -
di->item.slider.knob_h) -
(((di->item.slider.base_h -
di->item.slider.knob_h) * (di->item.slider.val -
di->item.slider.lower)) /
(di->item.slider.upper - di->item.slider.lower));
di->item.slider.knob_x =
di->item.slider.base_x +
((di->item.slider.base_w - di->item.slider.knob_w) / 2);
}
if (di->item.slider.knob_win)
EMoveResizeWindow(di->item.slider.knob_win,
di->x + di->item.slider.knob_x,
di->y + di->item.slider.knob_y,
di->item.slider.knob_w, di->item.slider.knob_h);
if (di->item.slider.base_win)
ImageclassApply(di->item.slider.ic_base,
di->item.slider.base_win,
di->item.slider.base_w, di->item.slider.base_h,
0, 0, STATE_NORMAL, ST_WIDGET);
if (di->item.slider.border_win)
ImageclassApply(di->item.slider.ic_border,
di->item.slider.border_win,
di->item.slider.border_w,
di->item.slider.border_h, 0, 0, STATE_NORMAL,
ST_WIDGET);
state = STATE_NORMAL;
if ((di->hilited) && (di->clicked))
state = STATE_CLICKED;
else if ((di->hilited) && (!di->clicked))
state = STATE_HILITED;
else if (!(di->hilited) && (di->clicked))
state = STATE_CLICKED;
if (di->item.slider.knob_win)
ImageclassApply(di->item.slider.ic_knob,
di->item.slider.knob_win,
di->item.slider.knob_w, di->item.slider.knob_h,
0, 0, state, ST_WIDGET);
break;
case DITEM_BUTTON:
state = STATE_NORMAL;
if ((di->hilited) && (di->clicked))
state = STATE_CLICKED;
else if ((di->hilited) && (!di->clicked))
state = STATE_HILITED;
else if (!(di->hilited) && (di->clicked))
state = STATE_CLICKED;
ITApply(di->win, di->iclass, NULL, di->w, di->h, state, 0, 0,
ST_WIDGET, di->tclass, NULL, di->text);
break;
case DITEM_AREA:
if (!d->redraw)
break;
ImageclassApply(di->iclass, di->win, di->w, di->h, 0, 0,
STATE_NORMAL, ST_DIALOG);
if (di->item.area.init_func)
di->item.area.init_func(di, 0, NULL);
break;
case DITEM_SEPARATOR:
if (!d->redraw)
break;
if (di->item.separator.horizontal)
ImageclassApply(di->iclass, di->win, di->w, di->h, 0, 0,
STATE_NORMAL, ST_WIDGET);
else
ImageclassApply(di->iclass, di->win, di->w, di->h, 0, 0,
STATE_CLICKED, ST_WIDGET);
break;
case DITEM_TEXT:
state = STATE_NORMAL;
x = di->x;
w = di->w;
goto draw_text;
case DITEM_CHECKBUTTON:
state = STATE_NORMAL;
if ((di->hilited) && (di->clicked))
state = STATE_CLICKED;
else if ((di->hilited) && (!di->clicked))
state = STATE_HILITED;
else if (!(di->hilited) && (di->clicked))
state = STATE_CLICKED;
ImageclassApply(di->iclass, di->item.check_button.check_win,
di->item.check_button.check_orig_w,
di->item.check_button.check_orig_h,
DialogItemCheckButtonGetState(di), 0, state, ST_WIDGET);
if (!d->redraw &&
(TextclassGetTextState(di->tclass, di->state, 0, 0) ==
TextclassGetTextState(di->tclass, state, 0, 0)))
break;
pad = ImageclassGetPadding(di->iclass);
x = di->x + di->item.check_button.check_orig_w + pad->left;
w = di->w - di->item.check_button.check_orig_w - pad->left;
goto draw_text;
case DITEM_RADIOBUTTON:
state = STATE_NORMAL;
if ((di->hilited) && (di->clicked))
state = STATE_CLICKED;
else if ((di->hilited) && (!di->clicked))
state = STATE_HILITED;
else if (!(di->hilited) && (di->clicked))
state = STATE_CLICKED;
ImageclassApply(di->iclass, di->item.radio_button.radio_win,
di->item.radio_button.radio_orig_w,
di->item.radio_button.radio_orig_h,
di->item.radio_button.onoff, 0, state, ST_WIDGET);
if (!d->redraw &&
(TextclassGetTextState(di->tclass, di->state, 0, 0) ==
TextclassGetTextState(di->tclass, state, 0, 0)))
break;
pad = ImageclassGetPadding(di->iclass);
x = di->x + di->item.radio_button.radio_orig_w + pad->left;
w = di->w - di->item.radio_button.radio_orig_w - pad->left;
goto draw_text;
default:
break;
draw_text:
di->state = state;
if (!di->text)
break;
if (!d->redraw)
EXCopyArea(d->pmm_bg.pmap, d->pmap, di->x, di->y, di->w, di->h,
di->x, di->y);
TextDraw(di->tclass, d->win, d->pmap, 0, 0, state, di->text,
x, di->y, w, 99999, 17, TextclassGetJustification(di->tclass));
break;
}
done:
di->update = 0;
}
static void
DialogUpdate(Dialog * d)
{
if (d->item)
DialogDrawItem(d, d->item);
if (d->xu1 < d->xu2 && d->yu1 < d->yu2)
EClearArea(d->win, d->xu1, d->yu1, d->xu2 - d->xu1, d->yu2 - d->yu1,
False);
d->update = 0;
d->xu1 = d->yu1 = 99999;
d->xu2 = d->yu2 = 0;
}
static void
_DialogsCheckUpdate(void *data __UNUSED__)
{
Dialog *d;
if (!dialog_update_pending)
return;
dialog_update_pending = 0;
ECORE_LIST_FOR_EACH(dialog_list, d)
{
if (d->update)
DialogUpdate(d);
d->redraw = 0;
}
}
void
DialogsInit(void)
{
IdlerAdd(50, _DialogsCheckUpdate, NULL);
}
static void
DialogItemsRealize(Dialog * d)
{
EImageBorder *pad;
if (!d->item)
return;
DialogRealizeItem(d, d->item);
DialogDrawItems(d, d->item, 0, 0, 99999, 99999);
pad = ImageclassGetPadding(d->iclass);
d->w = d->item->w + pad->left + pad->right;
d->h = d->item->h + pad->top + pad->bottom;
EResizeWindow(d->win, d->w, d->h);
}
void
DialogItemSetText(DItem * di, const char *text)
{
if (di->text)
Efree(di->text);
di->text = Estrdup(text);
}
void
DialogItemRadioButtonSetEventFunc(DItem * di, DialogItemCallbackFunc * func)
{
di->item.radio_button.event_func = func;
}
void
DialogItemRadioButtonSetFirst(DItem * di, DItem * first)
{
di->item.radio_button.first = first;
if (di == first)
return;
while (first->item.radio_button.next)
first = first->item.radio_button.next;
first->item.radio_button.next = di;
}
void
DialogItemRadioButtonGroupSetValPtr(DItem * di, int *val_ptr)
{
while (di)
{
di->item.radio_button.val_ptr = val_ptr;
if (*val_ptr == di->item.radio_button.val)
di->item.radio_button.onoff = 1;
di = di->item.radio_button.next;
}
}
void
DialogItemRadioButtonGroupSetVal(DItem * di, int val)
{
di->item.radio_button.val = val;
}
void
DialogItemCheckButtonSetState(DItem * di, char onoff)
{
*(di->item.check_button.onoff_ptr) = onoff;
}
void
DialogItemCheckButtonSetPtr(DItem * di, char *onoff_ptr)
{
di->item.check_button.onoff_ptr = onoff_ptr;
}
static int
DialogItemCheckButtonGetState(DItem * di)
{
return *(di->item.check_button.onoff_ptr) ? 1 : 0;
}
void
DialogItemTableSetOptions(DItem * di, int num_columns, char border,
char homogenous_h, char homogenous_v)
{
di->item.table.num_columns = num_columns;
di->item.table.border = border;
di->item.table.homogenous_h = homogenous_h;
di->item.table.homogenous_v = homogenous_v;
}
void
DialogItemSeparatorSetOrientation(DItem * di, char horizontal)
{
di->item.separator.horizontal = horizontal;
}
void
DialogItemImageSetFile(DItem * di, const char *image)
{
if (di->item.image.image)
Efree(di->item.image.image);
di->item.image.image = Estrdup(image);
di->fill_h = 0;
di->fill_v = 0;
}
void
DialogItemSliderSetVal(DItem * di, int val)
{
if (val < di->item.slider.lower)
val = di->item.slider.lower;
else if (val > di->item.slider.upper)
val = di->item.slider.upper;
di->item.slider.val = val;
if (di->item.slider.val_ptr)
*di->item.slider.val_ptr = val;
}
void
DialogItemSliderSetValPtr(DItem * di, int *val_ptr)
{
di->item.slider.val_ptr = val_ptr;
DialogItemSliderSetVal(di, *val_ptr);
}
void
DialogItemSliderSetBounds(DItem * di, int lower, int upper)
{
if (lower < upper)
{
di->item.slider.lower = lower;
di->item.slider.upper = upper;
}
else
{
di->item.slider.lower = upper;
di->item.slider.upper = lower;
}
if (di->item.slider.upper <= di->item.slider.lower)
di->item.slider.upper = di->item.slider.lower + 1;
}
void
DialogItemSliderSetUnits(DItem * di, int units)
{
di->item.slider.unit = units;
}
void
DialogItemSliderSetJump(DItem * di, int jump)
{
di->item.slider.jump = jump;
}
void
DialogItemSliderSetMinLength(DItem * di, int min)
{
di->item.slider.min_length = min;
}
void
DialogItemSliderSetOrientation(DItem * di, char horizontal)
{
di->item.slider.horizontal = horizontal;
}
int
DialogItemSliderGetVal(DItem * di)
{
return di->item.slider.val;
}
void
DialogItemSliderGetBounds(DItem * di, int *lower, int *upper)
{
if (lower)
*lower = di->item.slider.lower;
if (upper)
*upper = di->item.slider.upper;
}
void
DialogItemAreaSetSize(DItem * di, int w, int h)
{
di->item.area.w = w;
di->item.area.h = h;
}
Win
DialogItemAreaGetWindow(DItem * di)
{
return di->item.area.area_win;
}
void
DialogItemAreaGetSize(DItem * di, int *w, int *h)
{
*w = di->item.area.w;
*h = di->item.area.h;
}
void
DialogItemAreaSetInitFunc(DItem * di, DialogItemCallbackFunc * func)
{
di->item.area.init_func = func;
}
void
DialogItemAreaSetEventFunc(DItem * di, DialogItemCallbackFunc * func)
{
di->item.area.event_func = func;
}
void
DialogItemTableEmpty(DItem * di)
{
int i;
if (di->type != DITEM_TABLE)
return;
for (i = 0; i < di->item.table.num_items; i++)
DialogItemDestroy(di->item.table.items[i], 1);
if (di->item.table.items)
Efree(di->item.table.items);
di->item.table.items = NULL;
di->item.table.num_items = 0;
}
static void
DialogItemDestroy(DItem * di, int clean)
{
if (di->type == DITEM_TABLE)
DialogItemTableEmpty(di);
if (di->text)
Efree(di->text);
switch (di->type)
{
default:
break;
case DITEM_CHECKBUTTON:
if (!clean)
break;
EDestroyWindow(di->item.check_button.check_win);
break;
case DITEM_IMAGE:
if (di->item.image.image)
Efree(di->item.image.image);
break;
case DITEM_RADIOBUTTON:
if (!clean)
break;
EDestroyWindow(di->item.radio_button.radio_win);
break;
case DITEM_SLIDER:
if (di->item.slider.ic_base)
ImageclassDecRefcount(di->item.slider.ic_base);
if (di->item.slider.ic_knob)
ImageclassDecRefcount(di->item.slider.ic_knob);
if (di->item.slider.ic_border)
ImageclassDecRefcount(di->item.slider.ic_border);
if (!clean)
break;
EDestroyWindow(di->item.slider.base_win);
EDestroyWindow(di->item.slider.knob_win);
EDestroyWindow(di->item.slider.border_win);
break;
case DITEM_AREA:
if (!clean)
break;
EDestroyWindow(di->item.area.area_win);
break;
}
if (clean && di->win)
EDestroyWindow(di->win);
if (di->iclass)
ImageclassDecRefcount(di->iclass);
if (di->tclass)
TextclassDecRefcount(di->tclass);
Efree(di);
}
/* Convenience callback to close dialog */
void
DialogCallbackClose(Dialog * d, int val __UNUSED__, void *data __UNUSED__)
{
DialogClose(d);
}
/*
* Predefined dialogs
*/
void
DialogOK(const char *title, const char *fmt, ...)
{
char text[10240];
va_list args;
va_start(args, fmt);
Evsnprintf(text, sizeof(text), fmt, args);
va_end(args);
DialogOKstr(title, text);
}
void
DialogOKstr(const char *title, const char *txt)
{
Dialog *d;
DItem *table, *di;
d = DialogCreate("DIALOG");
table = DialogInitItem(d);
DialogSetTitle(d, title);
di = DialogAddItem(table, DITEM_TEXT);
DialogItemSetText(di, txt);
di = DialogItemAddButton(table, _("OK"), DialogCallbackClose, 0, 1,
DLG_BUTTON_OK);
DialogItemSetFill(di, 0, 0);
DialogBindKey(d, "Return", DialogCallbackClose, 0, NULL);
DialogBindKey(d, "Escape", DialogCallbackClose, 0, NULL);
DialogShow(d);
}
void
DialogAlert(const char *fmt, ...)
{
char text[10240];
va_list args;
va_start(args, fmt);
Evsnprintf(text, 10240, fmt, args);
va_end(args);
Alert(text);
}
void
DialogAlertOK(const char *fmt, ...)
{
char text[10240];
va_list args;
va_start(args, fmt);
Evsnprintf(text, 10240, fmt, args);
va_end(args);
AlertX(_("Attention !!!"), _("OK"), NULL, NULL, text);
}
/*
* Dialog event handlers
*/
static void
DialogEventKeyPress(Dialog * d, XEvent * ev)
{
int i;
for (i = 0; i < d->num_bindings; i++)
{
if (ev->xkey.keycode != d->keybindings[i].key)
continue;
d->keybindings[i].func(d, d->keybindings[i].val,
d->keybindings[i].data);
break;
}
}
static void
DialogHandleEvents(Win win __UNUSED__, XEvent * ev, void *prm)
{
Dialog *d = (Dialog *) prm;
switch (ev->type)
{
case KeyPress:
DialogEventKeyPress(d, ev);
break;
}
if (d->close)
_DialogClose(d);
}
static void
DItemEventMotion(Win win __UNUSED__, DItem * di, XEvent * ev)
{
int dx, dy;
switch (di->type)
{
case DITEM_AREA:
if (di->item.area.event_func)
di->item.area.event_func(di, 0, ev);
break;
case DITEM_SLIDER:
if (!di->item.slider.in_drag)
break;
if (ev->xmotion.window == WinGetXwin(di->item.slider.knob_win))
{
dx = Mode.events.x - Mode.events.px;
dy = Mode.events.y - Mode.events.py;
if (di->item.slider.horizontal)
{
di->item.slider.wanted_val += dx;
di->item.slider.val =
di->item.slider.lower +
(((di->item.slider.wanted_val *
(di->item.slider.upper -
di->item.slider.lower)) /
(di->item.slider.base_w -
di->item.slider.knob_w)) /
di->item.slider.unit) * di->item.slider.unit;
}
else
{
di->item.slider.wanted_val += dy;
di->item.slider.val =
di->item.slider.lower +
((((di->item.
slider.base_h - di->item.slider.knob_h -
di->item.slider.wanted_val) *
(di->item.slider.upper -
di->item.slider.lower)) /
(di->item.slider.base_h -
di->item.slider.knob_h)) /
di->item.slider.unit) * di->item.slider.unit;
}
if (di->item.slider.val < di->item.slider.lower)
di->item.slider.val = di->item.slider.lower;
if (di->item.slider.val > di->item.slider.upper)
di->item.slider.val = di->item.slider.upper;
if (di->item.slider.val_ptr)
*di->item.slider.val_ptr = di->item.slider.val;
if (di->func)
(di->func) (di->dlg, di->val, di->data);
}
DialogDrawItems(di->dlg, di, di->x, di->y, di->w, di->h);
break;
}
}
static void
DItemEventMouseDown(Win win, DItem * di, XEvent * ev)
{
int x, y, wheel_jump;
switch (di->type)
{
case DITEM_AREA:
if (di->item.area.event_func)
di->item.area.event_func(di, 0, ev);
break;
case DITEM_SLIDER:
#if 0 /* Do any themes have this? */
if (win == di->item.slider.border_win)
break;
#endif
if (ev->xbutton.window == WinGetXwin(di->item.slider.knob_win))
{
if (ev->xbutton.button >= 1 && ev->xbutton.button <= 3)
{
di->item.slider.in_drag = 1;
if (di->item.slider.horizontal)
di->item.slider.wanted_val = di->item.slider.knob_x;
else
di->item.slider.wanted_val = di->item.slider.knob_y;
break;
}
}
/* Coords -> item.slider.base_win */
ETranslateCoordinates(win, di->item.slider.base_win,
ev->xbutton.x, ev->xbutton.y, &x, &y, NULL);
switch (ev->xbutton.button)
{
case 1:
case 3:
if (di->item.slider.horizontal)
{
if (ev->xbutton.x >
(di->item.slider.knob_x + (di->item.slider.knob_w / 2)))
di->item.slider.val += di->item.slider.jump;
else
di->item.slider.val -= di->item.slider.jump;
}
else
{
if (ev->xbutton.y >
(di->item.slider.knob_y + (di->item.slider.knob_h / 2)))
di->item.slider.val -= di->item.slider.jump;
else
di->item.slider.val += di->item.slider.jump;
}
break;
case 2:
if (di->item.slider.horizontal)
di->item.slider.val = x *
(di->item.slider.upper - di->item.slider.lower) / di->w;
else
di->item.slider.val = ((di->h - y) *
(di->item.slider.upper -
di->item.slider.lower) / di->h);
break;
case 4:
case 5:
wheel_jump = di->item.slider.jump / 2;
if (!wheel_jump)
wheel_jump++;
if (ev->xbutton.button == 5)
{
di->item.slider.val -= wheel_jump;
}
else if (ev->xbutton.button == 4)
{
di->item.slider.val += wheel_jump;
}
break;
}
if (di->item.slider.val < di->item.slider.lower)
di->item.slider.val = di->item.slider.lower;
if (di->item.slider.val > di->item.slider.upper)
di->item.slider.val = di->item.slider.upper;
if (di->item.slider.val_ptr)
*di->item.slider.val_ptr = di->item.slider.val;
#if 0 /* Remove? */
if (di->func)
(di->func) (d, di->val, di->data);
#endif
break;
}
di->clicked = 1;
DialogDrawItems(di->dlg, di, di->x, di->y, di->w, di->h);
}
static void
DItemEventMouseUp(Win win, DItem * di, XEvent * ev)
{
DItem *dii;
if (ev->xbutton.window != Mode.events.last_bpress)
return;
switch (di->type)
{
case DITEM_AREA:
if (di->item.area.event_func)
di->item.area.event_func(di, 0, ev);
break;
case DITEM_CHECKBUTTON:
DialogItemCheckButtonSetState(di, !DialogItemCheckButtonGetState(di));
break;
case DITEM_RADIOBUTTON:
dii = di->item.radio_button.first;
while (dii)
{
if (dii->item.radio_button.onoff)
{
dii->item.radio_button.onoff = 0;
DialogDrawItems(di->dlg, dii, dii->x, dii->y, dii->w, dii->h);
}
dii = dii->item.radio_button.next;
}
di->item.radio_button.onoff = 1;
if (di->item.radio_button.val_ptr)
*di->item.radio_button.val_ptr = di->item.radio_button.val;
break;
case DITEM_SLIDER:
if (win == di->item.slider.knob_win)
di->item.slider.in_drag = 0;
break;
}
if (di->hilited && di->clicked)
{
if (di->func)
di->func(di->dlg, di->val, di->data);
if (di->do_close)
di->dlg->close = 1;
}
di->clicked = 0;
DialogDrawItems(di->dlg, di, di->x, di->y, di->w, di->h);
}
static void
DItemEventMouseIn(Win win __UNUSED__, DItem * di, XEvent * ev)
{
switch (di->type)
{
case DITEM_AREA:
if (di->item.area.event_func)
di->item.area.event_func(di, 0, ev);
break;
case DITEM_RADIOBUTTON:
if (di->item.radio_button.event_func)
di->item.radio_button.event_func(di, di->item.radio_button.val, ev);
break;
}
di->hilited = 1;
DialogDrawItems(di->dlg, di, di->x, di->y, di->w, di->h);
}
static void
DItemEventMouseOut(Win win __UNUSED__, DItem * di, XEvent * ev)
{
switch (di->type)
{
case DITEM_AREA:
if (di->item.area.event_func)
di->item.area.event_func(di, 0, ev);
break;
case DITEM_RADIOBUTTON:
if (di->item.radio_button.event_func)
di->item.radio_button.event_func(di, di->item.radio_button.val,
NULL);
break;
}
di->hilited = 0;
DialogDrawItems(di->dlg, di, di->x, di->y, di->w, di->h);
}
static void
DItemHandleEvents(Win win, XEvent * ev, void *prm)
{
DItem *di = (DItem *) prm;
switch (ev->type)
{
case ButtonPress:
DItemEventMouseDown(win, di, ev);
break;
case ButtonRelease:
DItemEventMouseUp(win, di, ev);
break;
case MotionNotify:
DItemEventMotion(win, di, ev);
break;
case EnterNotify:
DItemEventMouseIn(win, di, ev);
break;
case LeaveNotify:
DItemEventMouseOut(win, di, ev);
break;
}
if (di->dlg->close)
_DialogClose(di->dlg);
}
/*
* Finders
*/
static EWin *
FindEwinByDialog(Dialog * d)
{
EWin *const *ewins;
int i, num;
ewins = EwinListGetAll(&num);
for (i = 0; i < num; i++)
{
if ((Dialog *) (ewins[i]->data) == d)
return ewins[i];
}
return NULL;
}
static int
FindADialog(void)
{
EWin *const *ewins;
int i, num, n;
ewins = EwinListGetAll(&num);
for (i = n = 0; i < num; i++)
{
if (ewins[i]->type == EWIN_TYPE_DIALOG)
n++;
}
return n;
}
Reference in New Issue View Git Blame Copy Permalink