src/dialog.c

   1 /* Dialog box features module for the Midnight Commander
   2    Copyright (C) 1994, 1995, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
   3    2005, 2007, 2009, 2010  Free Software Foundation, Inc.
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 2 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, write to the Free Software
  17    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  */
  19
  20 /** \file dialog.c
  21  *  \brief Source: dialog box features module
  22  */
  23
  24 #include <config.h>
  25
  26 #include <ctype.h>
  27 #include <stdlib.h>
  28 #include <stdarg.h>
  29 #include <stdio.h>
  30 #include <string.h>
  31
  32 #include "lib/global.h"
  33
  34 #include "lib/tty/tty.h"
  35 #include "lib/skin.h"
  36 #include "lib/tty/mouse.h"
  37 #include "lib/tty/key.h"
  38 #include "lib/strutil.h"
  39
  40 #include "help.h"               /* interactive_display() */
  41 #include "layout.h"
  42 #include "execute.h"            /* suspend_cmd() */
  43 #include "cmddef.h"
  44 #include "keybind.h"
  45 #include "main.h"               /* fast_refresh */
  46 #include "setup.h"              /* mouse_close_dialog */
  47 #include "dialog.h"
  48
  49 #include "dialog-switch.h"
  50
  51 /* Color styles for normal and error dialogs */
  52 dlg_colors_t dialog_colors;
  53 dlg_colors_t alarm_colors;
  54
  55 /* Primitive way to check if the the current dialog is our dialog */
  56 /* This is needed by async routines like load_prompt */
  57 GList *top_dlg = NULL;
  58
  59 /* A hook list for idle events */
  60 Hook *idle_hook = NULL;
  61
  62 /* left click outside of dialog closes it */
  63 int mouse_close_dialog = 0;
  64
  65 static void dlg_broadcast_msg_to (Dlg_head * h, widget_msg_t message, gboolean reverse, int flags);
  66
  67 /* draw box in window */
  68 void
  69 draw_box (Dlg_head * h, int y, int x, int ys, int xs, gboolean single)
  70 {
  71     tty_draw_box (h->y + y, h->x + x, ys, xs, single);
  72 }
  73
  74 void
  75 init_widget (Widget * w, int y, int x, int lines, int cols,
  76              callback_fn callback, mouse_h mouse_handler)
  77 {
  78     w->x = x;
  79     w->y = y;
  80     w->cols = cols;
  81     w->lines = lines;
  82     w->callback = callback;
  83     w->mouse = mouse_handler;
  84     w->owner = NULL;
  85
  86     /* Almost all widgets want to put the cursor in a suitable place */
  87     w->options = W_WANT_CURSOR;
  88 }
  89
  90 void
  91 widget_set_size (Widget * widget, int y, int x, int lines, int cols)
  92 {
  93     widget->x = x;
  94     widget->y = y;
  95     widget->cols = cols;
  96     widget->lines = lines;
  97     send_message (widget, WIDGET_RESIZED, 0 /* unused */ );
  98 }
  99
 100 void
 101 widget_erase (Widget * w)
 102 {
 103     if (w != NULL)
 104         tty_fill_region (w->y, w->x, w->lines, w->cols, ' ');
 105 }
 106
 107 /* Clean the dialog area, draw the frame and the title */
 108 void
 109 common_dialog_repaint (Dlg_head *h)
 110 {
 111     int space;
 112
 113     if (h->state != DLG_ACTIVE)
 114         return;
 115
 116     space = (h->flags & DLG_COMPACT) ? 0 : 1;
 117
 118     tty_setcolor (h->color[DLG_COLOR_NORMAL]);
 119     dlg_erase (h);
 120     draw_box (h, space, space, h->lines - 2 * space, h->cols - 2 * space, FALSE);
 121
 122     if (h->title != NULL)
 123     {
 124         tty_setcolor (h->color[DLG_COLOR_TITLE]);
 125         dlg_move (h, space, (h->cols - str_term_width1 (h->title)) / 2);
 126         tty_print_string (h->title);
 127     }
 128 }
 129
 130 /* this function allows to set dialog position */
 131 void
 132 dlg_set_position (Dlg_head * h, int y1, int x1, int y2, int x2)
 133 {
 134     /* save old positions, will be used to reposition childs */
 135     int ox, oy, oc, ol;
 136     int shift_x, shift_y, scale_x, scale_y;
 137
 138     /* save old positions, will be used to reposition childs */
 139     ox = h->x;
 140     oy = h->y;
 141     oc = h->cols;
 142     ol = h->lines;
 143
 144     h->x = x1;
 145     h->y = y1;
 146     h->lines = y2 - y1;
 147     h->cols = x2 - x1;
 148
 149     /* dialog is empty */
 150     if (h->widgets == NULL)
 151         return;
 152
 153     if (h->current == NULL)
 154         h->current = h->widgets;
 155
 156     /* values by which controls should be moved */
 157     shift_x = h->x - ox;
 158     shift_y = h->y - oy;
 159     scale_x = h->cols - oc;
 160     scale_y = h->lines - ol;
 161
 162     if ((shift_x != 0) || (shift_y != 0) || (scale_x != 0) || (scale_y != 0))
 163     {
 164         GList *w;
 165
 166         for (w = h->widgets; w != NULL; w = g_list_next (w))
 167         {
 168             /* there are, mainly, 2 generally possible
 169                situations:
 170
 171                1. control sticks to one side - it
 172                should be moved
 173
 174                2. control sticks to two sides of
 175                one direction - it should be sized */
 176
 177             Widget *c = (Widget *) w->data;
 178             int x = c->x;
 179             int y = c->y;
 180             int cols = c->cols;
 181             int lines = c->lines;
 182
 183             if ((c->pos_flags & WPOS_KEEP_LEFT) && (c->pos_flags & WPOS_KEEP_RIGHT))
 184             {
 185                 x += shift_x;
 186                 cols += scale_x;
 187             }
 188             else if (c->pos_flags & WPOS_KEEP_LEFT)
 189                 x += shift_x;
 190             else if (c->pos_flags & WPOS_KEEP_RIGHT)
 191                 x += shift_x + scale_x;
 192
 193             if ((c->pos_flags & WPOS_KEEP_TOP) && (c->pos_flags & WPOS_KEEP_BOTTOM))
 194             {
 195                 y += shift_y;
 196                 lines += scale_y;
 197             }
 198             else if (c->pos_flags & WPOS_KEEP_TOP)
 199                 y += shift_y;
 200             else if (c->pos_flags & WPOS_KEEP_BOTTOM)
 201                 y += shift_y + scale_y;
 202
 203             widget_set_size (c, y, x, lines, cols);
 204         }
 205     }
 206 }
 207
 208 /* this function sets only size, leaving positioning to automatic methods */
 209 void
 210 dlg_set_size (Dlg_head * h, int lines, int cols)
 211 {
 212     int x = h->x;
 213     int y = h->y;
 214
 215     if (h->flags & DLG_CENTER)
 216     {
 217         y = (LINES - lines) / 2;
 218         x = (COLS - cols) / 2;
 219     }
 220
 221     if ((h->flags & DLG_TRYUP) && (y > 3))
 222         y -= 2;
 223
 224     dlg_set_position (h, y, x, y + lines, x + cols);
 225 }
 226
 227 /* Default dialog callback */
 228 cb_ret_t
 229 default_dlg_callback (Dlg_head * h, Widget * sender, dlg_msg_t msg, int parm, void *data)
 230 {
 231     (void) sender;
 232     (void) parm;
 233     (void) data;
 234
 235     switch (msg)
 236     {
 237     case DLG_DRAW:
 238         if (h->color != NULL)
 239         {
 240             common_dialog_repaint (h);
 241             return MSG_HANDLED;
 242         }
 243         return MSG_NOT_HANDLED;
 244
 245     case DLG_IDLE:
 246         dlg_broadcast_msg_to (h, WIDGET_IDLE, FALSE, W_WANT_IDLE);
 247         return MSG_HANDLED;
 248
 249     case DLG_RESIZE:
 250         /* this is default resizing mechanism */
 251         /* the main idea of this code is to resize dialog
 252            according to flags (if any of flags require automatic
 253            resizing, like DLG_CENTER, end after that reposition
 254            controls in dialog according to flags of widget) */
 255         dlg_set_size (h, h->lines, h->cols);
 256         return MSG_HANDLED;
 257
 258     default:
 259         break;
 260     }
 261
 262     return MSG_NOT_HANDLED;
 263 }
 264
 265 Dlg_head *
 266 create_dlg (gboolean modal, int y1, int x1, int lines, int cols,
 267             const int *colors, dlg_cb_fn callback, const char *help_ctx,
 268             const char *title, dlg_flags_t flags)
 269 {
 270     Dlg_head *new_d;
 271
 272     new_d = g_new0 (Dlg_head, 1);
 273     new_d->modal = modal;
 274     if (colors != NULL)
 275     {
 276         memmove (new_d->color, colors, sizeof (dlg_colors_t));
 277     }
 278     new_d->help_ctx = help_ctx;
 279     new_d->callback = (callback != NULL) ? callback : default_dlg_callback;
 280     new_d->x = x1;
 281     new_d->y = y1;
 282     new_d->flags = flags;
 283     new_d->data = NULL;
 284
 285     dlg_set_size (new_d, lines, cols);
 286     new_d->fullscreen = (new_d->x == 0 && new_d->y == 0
 287                          && new_d->cols == COLS && new_d->lines == LINES);
 288
 289     new_d->mouse_status = MOU_NORMAL;
 290
 291     /* Strip existing spaces, add one space before and after the title */
 292     if (title != NULL)
 293     {
 294         char *t;
 295
 296         t = g_strstrip (g_strdup (title));
 297         if (*t != '\0')
 298             new_d->title = g_strdup_printf (" %s ", t);
 299         g_free (t);
 300     }
 301
 302     return new_d;
 303 }
 304
 305 void
 306 dlg_set_default_colors (void)
 307 {
 308     dialog_colors[DLG_COLOR_NORMAL] = COLOR_NORMAL;
 309     dialog_colors[DLG_COLOR_FOCUS] = COLOR_FOCUS;
 310     dialog_colors[DLG_COLOR_HOT_NORMAL] = COLOR_HOT_NORMAL;
 311     dialog_colors[DLG_COLOR_HOT_FOCUS] = COLOR_HOT_FOCUS;
 312     dialog_colors[DLG_COLOR_TITLE] = COLOR_TITLE;
 313
 314     alarm_colors[DLG_COLOR_NORMAL] = ERROR_COLOR;
 315     alarm_colors[DLG_COLOR_FOCUS] = ERROR_FOCUS;
 316     alarm_colors[DLG_COLOR_HOT_NORMAL] = ERROR_HOT_NORMAL;
 317     alarm_colors[DLG_COLOR_HOT_FOCUS] = ERROR_HOT_FOCUS;
 318     alarm_colors[DLG_COLOR_TITLE] = ERROR_TITLE;
 319 }
 320
 321 void
 322 dlg_erase (Dlg_head * h)
 323 {
 324     if ((h != NULL) && (h->state == DLG_ACTIVE))
 325         tty_fill_region (h->y, h->x, h->lines, h->cols, ' ');
 326 }
 327
 328 void
 329 set_idle_proc (Dlg_head * d, int enable)
 330 {
 331     if (enable)
 332         d->flags |= DLG_WANT_IDLE;
 333     else
 334         d->flags &= ~DLG_WANT_IDLE;
 335 }
 336
 337 /*
 338  * Insert widget to dialog before current widget.  For dialogs populated
 339  * from the bottom, make the widget current.  Return widget number.
 340  */
 341 int
 342 add_widget_autopos (Dlg_head * h, void *w, widget_pos_flags_t pos_flags)
 343 {
 344     Widget *widget = (Widget *) w;
 345
 346     /* Don't accept 0 widgets */
 347     if (w == NULL)
 348         abort ();
 349
 350     widget->x += h->x;
 351     widget->y += h->y;
 352     widget->owner = h;
 353     widget->pos_flags = pos_flags;
 354     widget->id = g_list_length (h->widgets);
 355
 356     if ((h->flags & DLG_REVERSE) != 0)
 357         h->widgets = g_list_prepend (h->widgets, widget);
 358     else
 359         h->widgets = g_list_append (h->widgets, widget);
 360
 361     h->current = h->widgets;
 362
 363     return widget->id;
 364 }
 365
 366 /* wrapper to simply add lefttop positioned controls */
 367 int
 368 add_widget (Dlg_head * h, void *w)
 369 {
 370     return add_widget_autopos (h, w, WPOS_KEEP_LEFT | WPOS_KEEP_TOP);
 371 }
 372
 373 void
 374 do_refresh (void)
 375 {
 376     GList *d = top_dlg;
 377
 378     if (fast_refresh)
 379     {
 380         if ((d != NULL) && (d->data != NULL))
 381             dlg_redraw ((Dlg_head *) d->data);
 382     }
 383     else
 384     {
 385         /* Search first fullscreen dialog */
 386         for (; d != NULL; d = g_list_next (d))
 387             if ((d->data != NULL) && ((Dlg_head *) d->data)->fullscreen)
 388                 break;
 389         /* back to top dialog */
 390         for (; d != NULL; d = g_list_previous (d))
 391             if (d->data != NULL)
 392                 dlg_redraw ((Dlg_head *) d->data);
 393     }
 394 }
 395
 396 /* broadcast a message to all the widgets in a dialog that have
 397  * the options set to flags. If flags is zero, the message is sent
 398  * to all widgets.
 399  */
 400 static void
 401 dlg_broadcast_msg_to (Dlg_head * h, widget_msg_t message, gboolean reverse, int flags)
 402 {
 403     GList *p, *first;
 404
 405     if (h->widgets == NULL)
 406         return;
 407
 408     if (h->current == NULL)
 409         h->current = h->widgets;
 410
 411     if (reverse)
 412     {
 413         p = g_list_previous (h->current);
 414
 415         if (p == NULL)
 416             p = g_list_last (h->widgets);
 417     }
 418     else
 419     {
 420         p = g_list_next (h->current);
 421
 422         if (p == NULL)
 423             p = h->widgets;
 424     }
 425
 426     first = p;
 427
 428     do
 429     {
 430         Widget *w = (Widget *) p->data;
 431
 432         if (reverse)
 433         {
 434             p = g_list_previous (p);
 435
 436             if (p == NULL)
 437                 p = g_list_last (h->widgets);
 438         }
 439         else
 440         {
 441             p = g_list_next (p);
 442
 443             if (p == NULL)
 444                 p = h->widgets;
 445         }
 446
 447         if ((flags == 0) || ((flags & w->options) != 0))
 448             send_message (w, message, 0);
 449     }
 450     while (first != p);
 451 }
 452
 453 /* broadcast a message to all the widgets in a dialog */
 454 void
 455 dlg_broadcast_msg (Dlg_head * h, widget_msg_t message, gboolean reverse)
 456 {
 457     dlg_broadcast_msg_to (h, message, reverse, 0);
 458 }
 459
 460 int
 461 dlg_focus (Dlg_head * h)
 462 {
 463     /* cannot focus disabled widget ... */
 464
 465     if ((h->current != NULL) && (h->state == DLG_ACTIVE))
 466     {
 467         Widget *current = (Widget *) h->current->data;
 468
 469         if (((current->options & W_DISABLED) == 0)
 470             && (send_message (current, WIDGET_FOCUS, 0) == MSG_HANDLED))
 471         {
 472             h->callback (h, current, DLG_FOCUS, 0, NULL);
 473             return 1;
 474         }
 475     }
 476
 477     return 0;
 478 }
 479
 480 static int
 481 dlg_unfocus (Dlg_head * h)
 482 {
 483     /* ... but can unfocus disabled widget */
 484
 485     if ((h->current != NULL) && (h->state == DLG_ACTIVE))
 486     {
 487         Widget *current = (Widget *) h->current->data;
 488
 489         if (send_message (current, WIDGET_UNFOCUS, 0) == MSG_HANDLED)
 490         {
 491             h->callback (h, current, DLG_UNFOCUS, 0, NULL);
 492             return 1;
 493         }
 494     }
 495
 496     return 0;
 497 }
 498
 499 /* Return true if the windows overlap */
 500 int
 501 dlg_overlap (Widget * a, Widget * b)
 502 {
 503     return !((b->x >= a->x + a->cols)
 504              || (a->x >= b->x + b->cols) || (b->y >= a->y + a->lines) || (a->y >= b->y + b->lines));
 505 }
 506
 507 static int
 508 dlg_find_widget_callback (const void *a, const void *b)
 509 {
 510     const Widget *w = (const Widget *) a;
 511     callback_fn f = (callback_fn) b;
 512
 513     return (w->callback == f) ? 0 : 1;
 514 }
 515
 516 /* Find the widget with the given callback in the dialog h */
 517 Widget *
 518 find_widget_type (const Dlg_head * h, callback_fn callback)
 519 {
 520     GList *w;
 521
 522     w = g_list_find_custom (h->widgets, callback, dlg_find_widget_callback);
 523
 524     return (w == NULL) ? NULL : (Widget *) w->data;
 525 }
 526
 527 /* Find the widget with the given id */
 528 Widget *
 529 dlg_find_by_id (const Dlg_head * h, unsigned int id)
 530 {
 531     if (h->widgets != NULL)
 532     {
 533         GList *w;
 534
 535         for (w = h->widgets; w != NULL; w = g_list_next (w))
 536             if (((Widget *) w->data)->id == id)
 537                 return (Widget *) w->data;
 538     }
 539
 540     return NULL;
 541 }
 542
 543 /* Find the widget with the given id in the dialog h and select it */
 544 void
 545 dlg_select_by_id (const Dlg_head * h, unsigned int id)
 546 {
 547     Widget *w;
 548
 549     w = dlg_find_by_id (h, id);
 550     if (w != NULL)
 551         dlg_select_widget (w);
 552 }
 553
 554 /* What to do if the requested widget doesn't take focus */
 555 typedef enum
 556 {
 557     SELECT_NEXT,                /* go the the next widget */
 558     SELECT_PREV,                /* go the the previous widget */
 559     SELECT_EXACT                /* use current widget */
 560 } select_dir_t;
 561
 562 /*
 563  * Try to select another widget.  If forward is set, follow tab order.
 564  * Otherwise go to the previous widget.
 565  */
 566 static void
 567 do_select_widget (Dlg_head * h, GList * w, select_dir_t dir)
 568 {
 569     Widget *w0 = (Widget *) h->current->data;
 570
 571     if (!dlg_unfocus (h))
 572         return;
 573
 574     h->current = w;
 575
 576     do
 577     {
 578         if (dlg_focus (h))
 579             break;
 580
 581         switch (dir)
 582         {
 583         case SELECT_NEXT:
 584             h->current = g_list_next (h->current);
 585             if (h->current == NULL)
 586                 h->current = h->widgets;
 587             break;
 588         case SELECT_PREV:
 589             h->current = g_list_previous (h->current);
 590             if (h->current == NULL)
 591                 h->current = g_list_last (h->widgets);
 592             break;
 593         case SELECT_EXACT:
 594             h->current = g_list_find (h->widgets, w0);
 595             dlg_focus (h);
 596             return;
 597         }
 598     }
 599     while (h->current != w /* && (((Widget *) h->current->data)->options & W_DISABLED) == 0 */);
 600
 601     if (dlg_overlap (w0, (Widget *) h->current->data))
 602     {
 603         send_message ((Widget *) h->current->data, WIDGET_DRAW, 0);
 604         send_message ((Widget *) h->current->data, WIDGET_FOCUS, 0);
 605     }
 606 }
 607
 608 /*
 609  * Try to select widget in the dialog.
 610  */
 611 void
 612 dlg_select_widget (void *w)
 613 {
 614     const Widget *widget = (Widget *) w;
 615     Dlg_head *h = widget->owner;
 616
 617     do_select_widget (h, g_list_find (h->widgets, widget), SELECT_NEXT);
 618 }
 619
 620 /* Try to select previous widget in the tab order */
 621 void
 622 dlg_one_up (Dlg_head * h)
 623 {
 624     if (h->widgets != NULL)
 625     {
 626         GList *prev;
 627
 628         prev = g_list_previous (h->current);
 629         if (prev == NULL)
 630             prev = g_list_last (h->widgets);
 631
 632         do_select_widget (h, prev, SELECT_PREV);
 633     }
 634 }
 635
 636 /* Try to select next widget in the tab order */
 637 void
 638 dlg_one_down (Dlg_head * h)
 639 {
 640     if (h->widgets != NULL)
 641     {
 642         GList *next;
 643
 644         next = g_list_next (h->current);
 645         if (next == NULL)
 646             next = h->widgets;
 647         do_select_widget (h, next, SELECT_NEXT);
 648     }
 649 }
 650
 651 void
 652 update_cursor (Dlg_head * h)
 653 {
 654     GList *p = h->current;
 655
 656     if ((p != NULL) && (h->state == DLG_ACTIVE))
 657     {
 658         Widget *w;
 659
 660         w = (Widget *) p->data;
 661
 662         if (((w->options & W_DISABLED) == 0) && ((w->options & W_WANT_CURSOR) != 0))
 663             send_message (w, WIDGET_CURSOR, 0);
 664         else
 665             do
 666             {
 667                 p = g_list_next (p);
 668                 if (p == NULL)
 669                     p = h->widgets;
 670
 671                 if (p == h->current)
 672                     break;
 673
 674                 w = (Widget *) p->data;
 675
 676                 if (((w->options & W_DISABLED) == 0) && ((w->options & W_WANT_CURSOR) != 0))
 677                     if (send_message (w, WIDGET_CURSOR, 0) == MSG_HANDLED)
 678                         break;
 679             }
 680             while (TRUE);
 681     }
 682 }
 683
 684 /* Redraw the widgets in reverse order, leaving the current widget
 685  * as the last one
 686  */
 687 void
 688 dlg_redraw (Dlg_head * h)
 689 {
 690     if (h->state != DLG_ACTIVE)
 691         return;
 692
 693     if (h->winch_pending)
 694     {
 695         h->winch_pending = FALSE;
 696         h->callback (h, NULL, DLG_RESIZE, 0, NULL);
 697     }
 698
 699     h->callback (h, NULL, DLG_DRAW, 0, NULL);
 700     dlg_broadcast_msg (h, WIDGET_DRAW, TRUE);
 701     update_cursor (h);
 702 }
 703
 704 void
 705 dlg_stop (Dlg_head * h)
 706 {
 707     h->state = DLG_CLOSED;
 708 }
 709
 710 static void
 711 refresh_cmd (void)
 712 {
 713 #ifdef HAVE_SLANG
 714         tty_touch_screen ();
 715         mc_refresh ();
 716 #else
 717         /* Use this if the refreshes fail */
 718         clr_scr ();
 719         repaint_screen ();
 720 #endif /* HAVE_SLANG */
 721 }
 722
 723 static cb_ret_t
 724 dlg_execute_cmd (Dlg_head * h, unsigned long command)
 725 {
 726     cb_ret_t ret = MSG_HANDLED;
 727     switch (command)
 728     {
 729     case CK_DialogOK:
 730         h->ret_value = B_ENTER;
 731         dlg_stop (h);
 732         break;
 733     case CK_DialogCancel:
 734         h->ret_value = B_CANCEL;
 735         dlg_stop (h);
 736         break;
 737
 738     case CK_DialogPrevItem:
 739         dlg_one_up (h);
 740         break;
 741     case CK_DialogNextItem:
 742         dlg_one_down (h);
 743         break;
 744
 745     case CK_DialogHelp:
 746         interactive_display (NULL, h->help_ctx);
 747         do_refresh ();
 748         break;
 749
 750     case CK_DialogSuspend:
 751         suspend_cmd ();
 752         refresh_cmd ();
 753         break;
 754     case CK_DialogRefresh:
 755         refresh_cmd ();
 756         break;
 757
 758     case CK_DialogListCmd:
 759         if (!h->modal)
 760             dialog_switch_list ();
 761         else
 762             ret = MSG_NOT_HANDLED;
 763         break;
 764     case CK_DialogNextCmd:
 765         if (!h->modal)
 766             dialog_switch_next ();
 767         else
 768             ret = MSG_NOT_HANDLED;
 769         break;
 770     case CK_DialogPrevCmd:
 771         if (!h->modal)
 772             dialog_switch_prev ();
 773         else
 774             ret = MSG_NOT_HANDLED;
 775         break;
 776
 777     default:
 778         ret = MSG_NOT_HANDLED;
 779     }
 780
 781     return ret;
 782 }
 783
 784 static cb_ret_t
 785 dlg_handle_key (Dlg_head * h, int d_key)
 786 {
 787     unsigned long command;
 788     command = lookup_keymap_command (dialog_map, d_key);
 789     if ((command == CK_Ignore_Key) || (dlg_execute_cmd (h, command) == MSG_NOT_HANDLED))
 790         return MSG_NOT_HANDLED;
 791     else
 792         return MSG_HANDLED;
 793 }
 794
 795 static int
 796 dlg_mouse_event (Dlg_head * h, Gpm_Event * event)
 797 {
 798     GList *item;
 799     GList *starting_widget = h->current;
 800     Gpm_Event new_event;
 801     int x = event->x;
 802     int y = event->y;
 803
 804     /* close the dialog by mouse click out of dialog area */
 805     if (mouse_close_dialog && !h->fullscreen && ((event->buttons & GPM_B_LEFT) != 0) && ((event->type & GPM_DOWN) != 0) /* left click */
 806         && !((x > h->x) && (x <= h->x + h->cols) && (y > h->y) && (y <= h->y + h->lines)))
 807     {
 808         h->ret_value = B_CANCEL;
 809         dlg_stop (h);
 810         return MOU_NORMAL;
 811     }
 812
 813     item = starting_widget;
 814     do
 815     {
 816         Widget *widget;
 817
 818         widget = (Widget *) item->data;
 819         item = g_list_next (item);
 820         if (item == NULL)
 821             item = h->widgets;
 822
 823         if (((widget->options & W_DISABLED) == 0)
 824             && (x > widget->x) && (x <= widget->x + widget->cols)
 825             && (y > widget->y) && (y <= widget->y + widget->lines))
 826         {
 827             new_event = *event;
 828             new_event.x -= widget->x;
 829             new_event.y -= widget->y;
 830
 831             if (widget->mouse != NULL)
 832                 return widget->mouse (&new_event, widget);
 833         }
 834     }
 835     while (item != starting_widget);
 836
 837     return MOU_NORMAL;
 838 }
 839
 840 static cb_ret_t
 841 dlg_try_hotkey (Dlg_head * h, int d_key)
 842 {
 843     GList *hot_cur;
 844     Widget *current;
 845     cb_ret_t handled;
 846     int c;
 847
 848     if (h->widgets == NULL)
 849         return MSG_NOT_HANDLED;
 850
 851     if (h->current == NULL)
 852         h->current = h->widgets;
 853
 854     /*
 855      * Explanation: we don't send letter hotkeys to other widgets if
 856      * the currently selected widget is an input line
 857      */
 858
 859     current = (Widget *) h->current->data;
 860
 861     if ((current->options & W_DISABLED) != 0)
 862         return MSG_NOT_HANDLED;
 863
 864     if (current->options & W_IS_INPUT)
 865     {
 866         /* skip ascii control characters, anything else can valid character in
 867          * some encoding */
 868         if (d_key >= 32 && d_key < 256)
 869             return MSG_NOT_HANDLED;
 870     }
 871
 872     /* If it's an alt key, send the message */
 873     c = d_key & ~ALT (0);
 874     if (d_key & ALT (0) && g_ascii_isalpha (c))
 875         d_key = g_ascii_tolower (c);
 876
 877     handled = MSG_NOT_HANDLED;
 878     if ((current->options & W_WANT_HOTKEY) != 0)
 879         handled = send_message (current, WIDGET_HOTKEY, d_key);
 880
 881     /* If not used, send hotkey to other widgets */
 882     if (handled == MSG_HANDLED)
 883         return MSG_HANDLED;
 884
 885     hot_cur = g_list_next (h->current);
 886     if (hot_cur == NULL)
 887         hot_cur = h->widgets;
 888
 889     /* send it to all widgets */
 890     while (h->current != hot_cur && handled == MSG_NOT_HANDLED)
 891     {
 892         current = (Widget *) hot_cur->data;
 893
 894         if ((current->options & W_WANT_HOTKEY) != 0)
 895             handled = send_message (current, WIDGET_HOTKEY, d_key);
 896
 897         if (handled == MSG_NOT_HANDLED)
 898         {
 899             hot_cur = g_list_next (hot_cur);
 900             if (hot_cur == NULL)
 901                 hot_cur = h->widgets;
 902         }
 903     }
 904
 905     if (handled == MSG_HANDLED)
 906         do_select_widget (h, hot_cur, SELECT_EXACT);
 907
 908     return handled;
 909 }
 910
 911 static void
 912 dlg_key_event (Dlg_head * h, int d_key)
 913 {
 914     cb_ret_t handled;
 915
 916     if (h->widgets == NULL)
 917         return;
 918
 919     if (h->current == NULL)
 920         h->current = h->widgets;
 921
 922     /* TAB used to cycle */
 923     if ((h->flags & DLG_WANT_TAB) == 0)
 924     {
 925         if (d_key == '\t')
 926         {
 927             dlg_one_down (h);
 928             return;
 929         }
 930         else if (d_key == KEY_BTAB)
 931         {
 932             dlg_one_up (h);
 933             return;
 934         }
 935     }
 936
 937     /* first can dlg_callback handle the key */
 938     handled = h->callback (h, NULL, DLG_KEY, d_key, NULL);
 939
 940     /* next try the hotkey */
 941     if (handled == MSG_NOT_HANDLED)
 942         handled = dlg_try_hotkey (h, d_key);
 943
 944     if (handled == MSG_HANDLED)
 945         h->callback (h, NULL, DLG_HOTKEY_HANDLED, 0, NULL);
 946     else
 947         /* not used - then try widget_callback */
 948         handled = send_message ((Widget *) h->current->data, WIDGET_KEY, d_key);
 949
 950     /* not used- try to use the unhandled case */
 951     if (handled == MSG_NOT_HANDLED)
 952         handled = h->callback (h, NULL, DLG_UNHANDLED_KEY, d_key, NULL);
 953
 954     if (handled == MSG_NOT_HANDLED)
 955         handled = dlg_handle_key (h, d_key);
 956
 957     h->callback (h, NULL, DLG_POST_KEY, d_key, NULL);
 958 }
 959
 960 /* Init the process */
 961 void
 962 init_dlg (Dlg_head * h)
 963 {
 964     if ((top_dlg != NULL) && ((Dlg_head *) top_dlg->data)->modal)
 965         h->modal = TRUE;
 966
 967
 968     /* add dialog to the stack */
 969     top_dlg = g_list_prepend (top_dlg, h);
 970
 971     /* Initialize dialog manager and widgets */
 972     if (h->state == DLG_ACTIVE)
 973     {
 974         if (!h->modal)
 975             dialog_switch_add (h);
 976
 977         h->callback (h, NULL, DLG_INIT, 0, NULL);
 978         dlg_broadcast_msg (h, WIDGET_INIT, FALSE);
 979     }
 980
 981     h->state = DLG_ACTIVE;
 982
 983     dlg_redraw (h);
 984
 985     /* Select the first widget that takes focus */
 986     while (h->current != NULL && !dlg_focus (h))
 987     {
 988         h->current = g_list_next (h->current);
 989         if (h->current == NULL)
 990             h->current = h->widgets;
 991     }
 992
 993     h->ret_value = 0;
 994 }
 995
 996 void
 997 dlg_process_event (Dlg_head * h, int key, Gpm_Event * event)
 998 {
 999     if (key == EV_NONE)
1000     {
1001         if (tty_got_interrupt ())
1002             dlg_execute_cmd (h, CK_DialogCancel);
1003
1004         return;
1005     }
1006
1007     if (key == EV_MOUSE)
1008         h->mouse_status = dlg_mouse_event (h, event);
1009     else
1010         dlg_key_event (h, key);
1011 }
1012
1013 static void
1014 frontend_run_dlg (Dlg_head * h)
1015 {
1016     int d_key;
1017     Gpm_Event event;
1018
1019     event.x = -1;
1020
1021     /* close opened editors, viewers, etc */
1022     if (!h->modal && midnight_shutdown)
1023     {
1024         h->callback (h, NULL, DLG_VALIDATE, 0, NULL);
1025         return;
1026     }
1027
1028     while (h->state == DLG_ACTIVE)
1029     {
1030         if (winch_flag)
1031             change_screen_size ();
1032
1033         if (is_idle ())
1034         {
1035             if (idle_hook)
1036                 execute_hooks (idle_hook);
1037
1038             while ((h->flags & DLG_WANT_IDLE) && is_idle ())
1039                 h->callback (h, NULL, DLG_IDLE, 0, NULL);
1040
1041             /* Allow terminating the dialog from the idle handler */
1042             if (h->state != DLG_ACTIVE)
1043                 break;
1044         }
1045
1046         update_cursor (h);
1047
1048         /* Clear interrupt flag */
1049         tty_got_interrupt ();
1050         d_key = tty_get_event (&event, h->mouse_status == MOU_REPEAT, TRUE);
1051
1052         dlg_process_event (h, d_key, &event);
1053
1054         if (h->state == DLG_CLOSED)
1055             h->callback (h, NULL, DLG_VALIDATE, 0, NULL);
1056     }
1057 }
1058
1059 /* Shutdown the run_dlg */
1060 void
1061 dlg_run_done (Dlg_head * h)
1062 {
1063     top_dlg = g_list_remove (top_dlg, h);
1064
1065     if (h->state == DLG_CLOSED)
1066     {
1067         h->callback (h, (Widget *) h->current->data, DLG_END, 0, NULL);
1068         if (!h->modal)
1069             dialog_switch_remove (h);
1070     }
1071
1072 }
1073
1074 /* Standard run dialog routine
1075  * We have to keep this routine small so that we can duplicate it's
1076  * behavior on complex routines like the file routines, this way,
1077  * they can call the dlg_process_event without rewriting all the code
1078  */
1079 int
1080 run_dlg (Dlg_head * h)
1081 {
1082     init_dlg (h);
1083     frontend_run_dlg (h);
1084     dlg_run_done (h);
1085     return h->ret_value;
1086 }
1087
1088 void
1089 destroy_dlg (Dlg_head * h)
1090 {
1091     dlg_broadcast_msg (h, WIDGET_DESTROY, FALSE);
1092     g_list_foreach (h->widgets, (GFunc) g_free, NULL);
1093     g_list_free (h->widgets);
1094     g_free (h->title);
1095     g_free (h);
1096
1097     do_refresh ();
1098 }
1099
1100 char *
1101 dlg_get_title (const Dlg_head *h, size_t len)
1102 {
1103     char *t;
1104
1105     if (h == NULL)
1106         abort ();
1107
1108     if (h->get_title != NULL)
1109         t = h->get_title (h, len);
1110     else
1111         t = g_strdup ("");
1112
1113     return t;
1114 }
1115
1116 /* Replace widget old_w for widget new_w in the dialog */
1117 void
1118 dlg_replace_widget (Widget * old_w, Widget * new_w)
1119 {
1120     Dlg_head *h = old_w->owner;
1121     gboolean should_focus = FALSE;
1122
1123     if (h->widgets == NULL)
1124         return;
1125
1126     if (h->current == NULL)
1127         h->current = h->widgets;
1128
1129     if (old_w == h->current->data)
1130         should_focus = TRUE;
1131
1132     new_w->owner = h;
1133     new_w->id = old_w->id;
1134
1135     if (should_focus)
1136         h->current->data = new_w;
1137     else
1138         g_list_find (h->widgets, old_w)->data = new_w;
1139
1140     send_message (old_w, WIDGET_DESTROY, 0);
1141     send_message (new_w, WIDGET_INIT, 0);
1142
1143     if (should_focus)
1144         dlg_select_widget (new_w);
1145
1146     send_message (new_w, WIDGET_DRAW, 0);
1147 }