void event_expose(XEvent* e) {
Panel* panel;
panel = get_panel(e->xany.window);
if (!panel) return;
// TODO : one panel_refresh per panel ?
panel_refresh = 1;
}
PanControlTest( long version, GlobalFunc *global, LWLayoutGeneric *local,
void *serverData )
{
LWPanelID panel;
unsigned long sysid;
long ver;
sysid = ( unsigned long ) global( LWSYSTEMID_GLOBAL, GFUSE_TRANSIENT );
ver = ( sysid & LWINF_BUILD ) == 429 ? 2 : 4;
if ( version != ver ) return AFUNC_BADVERSION;
panf = global( LWPANELFUNCS_GLOBAL, GFUSE_TRANSIENT );
if ( !panf ) return AFUNC_BADGLOBAL;
panf->globalFun = global;
panel = get_panel();
if ( !panel ) return AFUNC_BADGLOBAL;
panf->open( panel, PANF_BLOCKING );
PAN_KILL( panf, panel );
return AFUNC_OK;
}
void display_player_xtra_info(void)
{
int i;
int panels [] = { 1, 2, 3, 4};
bool left_adj [] = { 1, 0, 0, 0, 0 };
data_panel data[MAX_PANEL];
for (i = 0; i < (int)N_ELEMENTS(panels); i++)
{
int oid = panels[i];
int rows = get_panel(oid, data, N_ELEMENTS(data));
/* Hack: Don't show 'Level' in the name, class ... panel */
if (oid == 1) rows -= 1;
display_panel(data, rows, left_adj[i], &boundaries[oid]);
}
/* Indent output by 1 character, and wrap at column 72 */
text_out_wrap = 72;
text_out_indent = 1;
/* History */
Term_gotoxy(text_out_indent, 19);
text_out_to_screen(TERM_WHITE, p_ptr->history);
/* Reset text_out() vars */
text_out_wrap = 0;
text_out_indent = 0;
return;
}
/*
* Display the character on the screen (two different modes)
*
* The top two lines, and the bottom line (or two) are left blank.
*
* Mode 0 = standard display with skills/history
* Mode 1 = special display with equipment flags
*/
void display_player(int mode)
{
/* Erase screen */
clear_from(0);
/* Stat info */
display_player_stat_info();
if (mode)
{
data_panel data[MAX_PANEL];
int rows = get_panel(1, data, N_ELEMENTS(data));
display_panel(data, rows, 1, &boundaries[1]);
/* Stat/Sustain flags */
display_player_sust_info();
/* Other flags */
display_player_flag_info();
}
/* Standard */
else
{
/* Extra info */
display_player_xtra_info();
}
}
static VALUE rbncurs_c_del_panel(VALUE rb_panel) {
VALUE panels_hash = rb_iv_get(mPanel, "@panels_hash");
PANEL* panel = get_panel(rb_panel);
VALUE panel_adress = INT2NUM((long)(panel));
rb_funcall(panels_hash, rb_intern("delete"), 1, panel_adress);
rb_iv_set(rb_panel, "@destroyed", Qtrue);
return INT2NUM(del_panel(panel));
}
void event_button_motion_notify(XEvent* e) {
Panel* panel = get_panel(e->xany.window);
if (!panel || !task_drag) return;
// Find the taskbar on the event's location
point_T point = {e->xbutton.x, e->xbutton.y};
Taskbar* event_taskbar = click_taskbar(panel, point);
if (event_taskbar == NULL) return;
// Find the task on the event's location
Task* event_task = click_task(panel, point);
// If the event takes place on the same taskbar as the task being dragged
if (event_taskbar == task_drag->area.parent) {
// Swap the task_drag with the task on the event's location (if they differ)
if (event_task && event_task != task_drag) {
GSList* drag_iter = g_slist_find(event_taskbar->area.list, task_drag);
GSList* task_iter = g_slist_find(event_taskbar->area.list, event_task);
if (drag_iter && task_iter) {
gpointer temp = task_iter->data;
task_iter->data = drag_iter->data;
drag_iter->data = temp;
event_taskbar->area.resize = 1;
panel_refresh = 1;
task_dragged = 1;
}
}
} else { // The event is on another taskbar than the task being dragged
if (task_drag->desktop == ALLDESKTOP || panel_mode != MULTI_DESKTOP) return;
Taskbar* drag_taskbar = (Taskbar*)task_drag->area.parent;
drag_taskbar->area.list =
g_slist_remove(drag_taskbar->area.list, task_drag);
if (event_taskbar->area.posx > drag_taskbar->area.posx ||
event_taskbar->area.posy > drag_taskbar->area.posy) {
int i = (taskbarname_enabled) ? 1 : 0;
event_taskbar->area.list =
g_slist_insert(event_taskbar->area.list, task_drag, i);
} else
event_taskbar->area.list =
g_slist_append(event_taskbar->area.list, task_drag);
// Move task to other desktop (but avoid the 'Window desktop changed' code
// in 'event_property_notify')
task_drag->area.parent = event_taskbar;
task_drag->desktop = event_taskbar->desktop;
windows_set_desktop(task_drag->win, event_taskbar->desktop);
event_taskbar->area.resize = 1;
drag_taskbar->area.resize = 1;
task_dragged = 1;
panel_refresh = 1;
}
}
void event_button_press(XEvent* e) {
Panel* panel = get_panel(e->xany.window);
if (!panel) return;
if (wm_menu && !tinto_handles_click(panel, &e->xbutton)) {
forward_click(e);
return;
}
point_T point = {e->xbutton.x, e->xbutton.y};
task_drag = click_task(panel, point);
if (panel_layer == BOTTOM_LAYER) XLowerWindow(server.dsp, panel->main_win);
}
Atmosphere_UI( long version, GlobalFunc *global, LWInterface *local,
void *serverData )
{
if ( version != LWINTERFACE_VERSION ) return AFUNC_BADVERSION;
txedf = global( LWTXTREDFUNCS_GLOBAL, GFUSE_TRANSIENT );
xpanf = global( LWXPANELFUNCS_GLOBAL, GFUSE_TRANSIENT );
if ( !txedf || !xpanf ) return AFUNC_BADGLOBAL;
local->panel = get_panel( local->inst );
local->options = NULL;
local->command = NULL;
return AFUNC_OK;
}
XCALL_(int) Interface_SurfaceParameters( long version, GlobalFunc *global, LWInterface *local, void *serverData)
{
_global = global ;
_serverData = serverData;
if ( version != LWINTERFACE_VERSION ) return AFUNC_BADVERSION;
(void*&)colorpick = global( LWCOLORACTIVATEFUNC_GLOBAL, GFUSE_TRANSIENT );
(void*&)lwupdate = global( LWINSTUPDATE_GLOBAL, GFUSE_TRANSIENT );
(void*&)xpanf = global( LWXPANELFUNCS_GLOBAL, GFUSE_TRANSIENT );
if ( !colorpick || !lwupdate || !xpanf ) return AFUNC_BADGLOBAL;
local->panel = get_panel( (SurfaceInstance*)local->inst );
local->options = NULL;
local->command = NULL;
return local->panel ? AFUNC_OK : AFUNC_BADGLOBAL;
}
/**
* Return a target set of target_able monsters.
*/
struct point_set *target_get_monsters(int mode, monster_predicate pred)
{
int y, x;
int min_y, min_x, max_y, max_x;
struct point_set *targets = point_set_new(TS_INITIAL_SIZE);
/* Get the current panel */
get_panel(&min_y, &min_x, &max_y, &max_x);
/* Scan for targets */
for (y = min_y; y < max_y; y++) {
for (x = min_x; x < max_x; x++) {
struct loc grid = loc(x, y);
/* Check bounds */
if (!square_in_bounds_fully(cave, grid)) continue;
/* Require "interesting" contents */
if (!target_accept(y, x)) continue;
/* Special mode */
if (mode & (TARGET_KILL)) {
struct monster *mon = square_monster(cave, grid);
/* Must contain a monster */
if (mon == NULL) continue;
/* Must be a targettable monster */
if (!target_able(mon)) continue;
/* Must be the right sort of monster */
if (pred && !pred(mon)) continue;
}
/* Save the location */
add_to_point_set(targets, grid);
}
}
sort(targets->pts, point_set_size(targets), sizeof(*(targets->pts)),
cmp_distance);
return targets;
}
/**
* Return a target set of target_able monsters.
*/
struct point_set *target_get_monsters(int mode)
{
int y, x;
int min_y, min_x, max_y, max_x;
struct point_set *targets = point_set_new(TS_INITIAL_SIZE);
/* Get the current panel */
get_panel(&min_y, &min_x, &max_y, &max_x);
/* Scan for targets */
for (y = min_y; y < max_y; y++) {
for (x = min_x; x < max_x; x++) {
/* Check bounds */
if (!square_in_bounds_fully(cave, y, x)) continue;
/* Require "interesting" contents */
if (!target_accept(y, x)) continue;
/* Special mode */
if (mode & (TARGET_KILL)) {
/* Must contain a monster */
if (!(cave->squares[y][x].mon > 0)) continue;
/* Must be a targettable monster */
if (!target_able(square_monster(cave, y, x))) continue;
}
/* Save the location */
add_to_point_set(targets, y, x);
}
}
sort(targets->pts, point_set_size(targets), sizeof(*(targets->pts)),
cmp_distance);
return targets;
}
static VALUE rbncurs_c_panel_above(VALUE rb_panel)
{ return wrap_panel(panel_above(get_panel(rb_panel))); }
static VALUE rbncurs_c_show_panel(VALUE rb_panel)
{ return INT2NUM(show_panel(get_panel(rb_panel))); }
static VALUE rbncurs_c_set_panel_userptr(VALUE rb_panel, VALUE userptr)
{ return INT2NUM(set_panel_userptr(get_panel(rb_panel),
(void*)(userptr))); }
static VALUE rbncurs_c_panel_below(VALUE rb_panel)
{ return wrap_panel(panel_below(get_panel(rb_panel))); }
static VALUE rbncurs_c_panel_userptr(VALUE rb_panel)
{ return (VALUE)(panel_userptr(get_panel(rb_panel))); }
void event_button_release(XEvent* e) {
Panel* panel = get_panel(e->xany.window);
if (!panel) return;
if (wm_menu && !tinto_handles_click(panel, &e->xbutton)) {
forward_click(e);
if (panel_layer == BOTTOM_LAYER) XLowerWindow(server.dsp, panel->main_win);
task_drag = 0;
return;
}
int action = TOGGLE_ICONIFY;
switch (e->xbutton.button) {
case 1:
action = mouse_left;
break;
case 2:
action = mouse_middle;
break;
case 3:
action = mouse_right;
break;
case 4:
action = mouse_scroll_up;
break;
case 5:
action = mouse_scroll_down;
break;
case 6:
action = mouse_tilt_left;
break;
case 7:
action = mouse_tilt_right;
break;
}
point_T point = {e->xbutton.x, e->xbutton.y};
if (click_clock(panel, point)) {
clock_action(e->xbutton.button);
if (panel_layer == BOTTOM_LAYER) XLowerWindow(server.dsp, panel->main_win);
task_drag = 0;
return;
}
point.x = e->xbutton.x;
point.y = e->xbutton.y;
if (click_launcher(panel, point)) {
point.x = e->xbutton.x;
point.y = e->xbutton.y;
LauncherIcon* icon = click_launcher_icon(panel, point);
if (icon) {
launcher_action(icon, e);
}
task_drag = 0;
return;
}
Taskbar* tskbar;
if (!(tskbar = click_taskbar(panel, point))) {
// TODO: check better solution to keep window below
if (panel_layer == BOTTOM_LAYER) XLowerWindow(server.dsp, panel->main_win);
task_drag = 0;
return;
}
// drag and drop task
if (task_dragged) {
task_drag = 0;
task_dragged = 0;
return;
}
// switch desktop
if (panel_mode == MULTI_DESKTOP) {
if (tskbar->desktop != server.desktop && action != CLOSE &&
action != DESKTOP_LEFT && action != DESKTOP_RIGHT)
set_desktop(tskbar->desktop);
}
// action on task
// e->xbutton.x, e->xbutton.y
window_action(click_task(panel, point), action);
// to keep window below
if (panel_layer == BOTTOM_LAYER) XLowerWindow(server.dsp, panel->main_win);
}
static VALUE rbncurs_c_replace_panel(VALUE rb_panel, VALUE rb_window)
{ return INT2NUM(replace_panel(get_panel(rb_panel), get_window(rb_window))); }
static VALUE rbncurs_c_move_panel(VALUE rb_panel, VALUE starty, VALUE startx)
{ return INT2NUM(move_panel(get_panel(rb_panel), NUM2INT(starty),
NUM2INT(startx))); }
static VALUE rbncurs_c_panel_hidden(VALUE rb_panel)
{ return panel_hidden(get_panel(rb_panel)) ? Qtrue : Qfalse; }
static VALUE rbncurs_c_bottom_panel(VALUE rb_panel)
{ return INT2NUM(bottom_panel(get_panel(rb_panel))); }
static VALUE rbncurs_c_top_panel(VALUE rb_panel)
{ return INT2NUM(top_panel(get_panel(rb_panel))); }
static VALUE rbncurs_c_panel_window(VALUE rb_panel)
{ return wrap_window(panel_window(get_panel(rb_panel))); }
static VALUE rbncurs_c_hide_panel(VALUE rb_panel)
{ return INT2NUM(hide_panel(get_panel(rb_panel))); }
