contrib/dialog/rangebox.c

   1 /*
   2  *  $Id: rangebox.c,v 1.17 2013/03/17 16:02:00 tom Exp $
   3  *
   4  *  rangebox.c -- implements the rangebox dialog
   5  *
   6  *  Copyright 2012,2013 Thomas E. Dickey
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU Lesser General Public License, version 2.1
  10  *  as published by the Free Software Foundation.
  11  *
  12  *  This program is distributed in the hope that it will be useful, but
  13  *  WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  *  Lesser General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU Lesser General Public
  18  *  License along with this program; if not, write to
  19  *      Free Software Foundation, Inc.
  20  *      51 Franklin St., Fifth Floor
  21  *      Boston, MA 02110, USA.
  22  */
  23
  24 #include <dialog.h>
  25 #include <dlg_keys.h>
  26
  27 #define ONE_HIGH 1
  28
  29 #define MIN_HIGH (ONE_HIGH + 1 + (4 * MARGIN))
  30 #define MIN_WIDE (10 + 2 + (2 * MARGIN))
  31
  32 struct _box;
  33
  34 typedef struct _box {
  35     WINDOW *parent;
  36     WINDOW *window;
  37     int x;
  38     int y;
  39     int width;
  40     int height;
  41     int period;
  42     int value;
  43 } BOX;
  44
  45 typedef struct {
  46     /* window in which the value and slider are drawn */
  47     WINDOW *window;
  48     int min_value;
  49     int max_value;
  50     /* position and width of the numeric field */
  51     int value_x;
  52     int value_len;
  53     int value_col;
  54     /* position and width of the slider field */
  55     int slide_x;
  56     int slide_y;
  57     int slide_len;
  58     /* current value drawn */
  59     int current;
  60     /* value to add to make slider move by one cell */
  61     int slide_inc;
  62 } VALUE;
  63
  64 static int
  65 digits_of(int value)
  66 {
  67     char temp[80];
  68     sprintf(temp, "%d", value);
  69     return (int) strlen(temp);
  70 }
  71
  72 static int
  73 digit_of(VALUE * data)
  74 {
  75     int col = data->value_col;
  76     int result = 1;
  77
  78     while (++col < data->value_len) {
  79         result *= 10;
  80     }
  81     return result;
  82 }
  83
  84 static bool
  85 set_digit(VALUE * data, int chr)
  86 {
  87     bool result = FALSE;
  88     char buffer[80];
  89     long check;
  90     char *next = 0;
  91
  92     sprintf(buffer, "%*d", data->value_len, data->current);
  93     buffer[data->value_col] = (char) chr;
  94     check = strtol(buffer, &next, 10);
  95     if (next == 0 || *next == '\0') {
  96         if ((check <= (long) data->max_value) &&
  97             (check >= (long) data->min_value)) {
  98             result = TRUE;
  99             data->current = (int) check;
 100         }
 101     }
 102
 103     return result;
 104 }
 105
 106 /*
 107  * This is similar to the gauge code, but differs in the way the number
 108  * is displayed, etc.
 109  */
 110 static void
 111 draw_value(VALUE * data, int value)
 112 {
 113     if (value != data->current) {
 114         WINDOW *win = data->window;
 115         int y, x;
 116         int n;
 117         int ranges = (data->max_value + 1 - data->min_value);
 118         int offset = (value - data->min_value);
 119         int scaled;
 120
 121         getyx(win, y, x);
 122
 123         if (ranges > data->slide_len) {
 124             scaled = (offset + data->slide_inc) / data->slide_inc;
 125         } else if (ranges < data->slide_len) {
 126             scaled = (offset + 1) * data->slide_inc;
 127         } else {
 128             scaled = offset;
 129         }
 130
 131         (void) wattrset(win, gauge_attr);
 132         wmove(win, data->slide_y, data->slide_x);
 133         for (n = 0; n < data->slide_len; ++n) {
 134             (void) waddch(win, ' ');
 135         }
 136         wmove(win, data->slide_y, data->value_x);
 137         wprintw(win, "%*d", data->value_len, value);
 138         if ((gauge_attr & A_REVERSE) != 0) {
 139             wattroff(win, A_REVERSE);
 140         } else {
 141             (void) wattrset(win, A_REVERSE);
 142         }
 143         wmove(win, data->slide_y, data->slide_x);
 144         for (n = 0; n < scaled; ++n) {
 145             chtype ch2 = winch(win);
 146             if (gauge_attr & A_REVERSE) {
 147                 ch2 &= ~A_REVERSE;
 148             }
 149             (void) waddch(win, ch2);
 150         }
 151         (void) wattrset(win, dialog_attr);
 152
 153         wmove(win, y, x);
 154         data->current = value;
 155
 156         dlg_trace_msg("drew %d offset %d scaled %d limit %d inc %d\n",
 157                       value,
 158                       offset,
 159                       scaled,
 160                       data->slide_len,
 161                       data->slide_inc);
 162
 163         dlg_trace_win(win);
 164     }
 165 }
 166
 167 /*
 168  * Allow the user to select from a range of values, e.g., using a slider.
 169  */
 170 int
 171 dialog_rangebox(const char *title,
 172                 const char *cprompt,
 173                 int height,
 174                 int width,
 175                 int min_value,
 176                 int max_value,
 177                 int default_value)
 178 {
 179     /* *INDENT-OFF* */
 180     static DLG_KEYS_BINDING binding[] = {
 181         DLG_KEYS_DATA( DLGK_DELETE_RIGHT,KEY_DC ),
 182         HELPKEY_BINDINGS,
 183         ENTERKEY_BINDINGS,
 184         DLG_KEYS_DATA( DLGK_ENTER,      ' ' ),
 185         DLG_KEYS_DATA( DLGK_FIELD_NEXT, CHR_NEXT ),
 186         DLG_KEYS_DATA( DLGK_FIELD_NEXT, KEY_RIGHT ),
 187         DLG_KEYS_DATA( DLGK_FIELD_NEXT, TAB ),
 188         DLG_KEYS_DATA( DLGK_FIELD_PREV, CHR_BACKSPACE ),
 189         DLG_KEYS_DATA( DLGK_FIELD_PREV, CHR_PREVIOUS ),
 190         DLG_KEYS_DATA( DLGK_FIELD_PREV, KEY_BTAB ),
 191         DLG_KEYS_DATA( DLGK_FIELD_PREV, KEY_LEFT ),
 192         DLG_KEYS_DATA( DLGK_ITEM_FIRST, KEY_HOME),
 193         DLG_KEYS_DATA( DLGK_ITEM_LAST,  KEY_END),
 194         DLG_KEYS_DATA( DLGK_ITEM_LAST,  KEY_LL ),
 195         DLG_KEYS_DATA( DLGK_ITEM_NEXT,  '+'),
 196         DLG_KEYS_DATA( DLGK_ITEM_NEXT,  KEY_DOWN),
 197         DLG_KEYS_DATA( DLGK_ITEM_PREV,  '-' ),
 198         DLG_KEYS_DATA( DLGK_ITEM_PREV,  KEY_UP ),
 199         DLG_KEYS_DATA( DLGK_PAGE_NEXT,  KEY_NEXT),
 200         DLG_KEYS_DATA( DLGK_PAGE_NEXT,  KEY_NPAGE),
 201         DLG_KEYS_DATA( DLGK_PAGE_PREV,  KEY_PPAGE ),
 202         DLG_KEYS_DATA( DLGK_PAGE_PREV,  KEY_PREVIOUS ),
 203         END_KEYS_BINDING
 204     };
 205     /* *INDENT-ON* */
 206
 207 #ifdef KEY_RESIZE
 208     int old_height = height;
 209     int old_width = width;
 210 #endif
 211     VALUE data;
 212     int key = 0, key2, fkey;
 213     int button;
 214     int result = DLG_EXIT_UNKNOWN;
 215     WINDOW *dialog;
 216     int state = dlg_default_button();
 217     const char **buttons = dlg_ok_labels();
 218     char *prompt = dlg_strclone(cprompt);
 219     char buffer[MAX_LEN];
 220     int cur_value = default_value;
 221     int usable;
 222     int ranges;
 223     int yorg, xorg;
 224
 225     if (max_value < min_value)
 226         max_value = min_value;
 227     if (cur_value > max_value)
 228         cur_value = max_value;
 229     if (cur_value < min_value)
 230         cur_value = min_value;
 231
 232     dlg_does_output();
 233
 234 #ifdef KEY_RESIZE
 235   retry:
 236 #endif
 237
 238     dlg_auto_size(title, prompt, &height, &width, 0, 0);
 239     height += MIN_HIGH;
 240     if (width < MIN_WIDE)
 241         width = MIN_WIDE;
 242     dlg_button_layout(buttons, &width);
 243     dlg_print_size(height, width);
 244     dlg_ctl_size(height, width);
 245
 246     dialog = dlg_new_window(height, width,
 247                             yorg = dlg_box_y_ordinate(height),
 248                             xorg = dlg_box_x_ordinate(width));
 249
 250     data.window = dialog;
 251
 252     data.min_value = min_value;
 253     data.max_value = max_value;
 254
 255     usable = (width - 2 - 4 * MARGIN);
 256     ranges = max_value - min_value + 1;
 257
 258     /*
 259      * Center the number after allowing for its maximum number of digits.
 260      */
 261     data.value_len = digits_of(max_value);
 262     if (digits_of(min_value) > data.value_len)
 263         data.value_len = digits_of(min_value);
 264     data.value_x = (usable - data.value_len) / 2 + MARGIN;
 265     data.value_col = data.value_len - 1;
 266
 267     /*
 268      * The slider is scaled, to try to use the width of the dialog.
 269      */
 270     if (ranges > usable) {
 271         data.slide_inc = (ranges + usable - 1) / usable;
 272         data.slide_len = 1 + ranges / data.slide_inc;
 273     } else if (ranges < usable) {
 274         data.slide_inc = usable / ranges;
 275         data.slide_len = ranges * data.slide_inc;
 276     } else {
 277         data.slide_inc = 1;
 278         data.slide_len = usable;
 279     }
 280     data.slide_x = (usable - data.slide_len) / 2 + MARGIN + 2;
 281     data.slide_y = height - 5;
 282
 283     data.current = cur_value - 1;
 284
 285     dlg_register_window(dialog, "rangebox", binding);
 286     dlg_register_buttons(dialog, "rangebox", buttons);
 287
 288     dlg_draw_box2(dialog, 0, 0, height, width, dialog_attr, border_attr, border2_attr);
 289     dlg_mouse_setbase(xorg, yorg);
 290     dlg_mouse_mkregion(data.slide_y - 1, data.slide_x - 1, 3, usable + 2, 'i');
 291     dlg_draw_box2(dialog,
 292                   height - 6, data.slide_x - MARGIN,
 293                   2 + MARGIN, data.slide_len + 2 * MARGIN,
 294                   dialog_attr,
 295                   border_attr,
 296                   border2_attr);
 297     dlg_draw_bottom_box2(dialog, border_attr, border2_attr, dialog_attr);
 298     dlg_draw_title(dialog, title);
 299     dlg_draw_helpline(dialog, FALSE);
 300
 301     (void) wattrset(dialog, dialog_attr);
 302     dlg_print_autowrap(dialog, prompt, height, width);
 303
 304     dlg_trace_win(dialog);
 305     while (result == DLG_EXIT_UNKNOWN) {
 306         draw_value(&data, cur_value);
 307         button = (state < 0) ? 0 : state;
 308         dlg_draw_buttons(dialog, height - 2, 0, buttons, button, FALSE, width);
 309         if (state < 0) {
 310             data.value_col = data.value_len + state;
 311             wmove(dialog, data.slide_y, data.value_x + data.value_col);
 312         }
 313
 314         key = dlg_mouse_wgetch(dialog, &fkey);
 315         if (dlg_result_key(key, fkey, &result))
 316             break;
 317
 318         if ((key2 = dlg_char_to_button(key, buttons)) >= 0) {
 319             result = key2;
 320         } else {
 321             /* handle function-keys */
 322             if (fkey) {
 323                 switch (key) {
 324                 case DLGK_ENTER:
 325                     result = dlg_ok_buttoncode(button);
 326                     break;
 327                 case DLGK_FIELD_PREV:
 328                     if (state < 0 && state > -data.value_len) {
 329                         --state;
 330                     } else {
 331                         state = dlg_prev_ok_buttonindex(state, -data.value_len);
 332                     }
 333                     break;
 334                 case DLGK_FIELD_NEXT:
 335                     if (state < 0) {
 336                         ++state;
 337                     } else {
 338                         state = dlg_next_ok_buttonindex(state, -data.value_len);
 339                     }
 340                     break;
 341                 case DLGK_ITEM_FIRST:
 342                     cur_value = min_value;
 343                     break;
 344                 case DLGK_ITEM_LAST:
 345                     cur_value = max_value;
 346                     break;
 347                 case DLGK_ITEM_PREV:
 348                     if (state < 0) {
 349                         cur_value -= digit_of(&data);
 350                     } else {
 351                         cur_value -= 1;
 352                     }
 353                     if (cur_value < min_value)
 354                         cur_value = min_value;
 355                     break;
 356                 case DLGK_ITEM_NEXT:
 357                     if (state < 0) {
 358                         cur_value += digit_of(&data);
 359                     } else {
 360                         cur_value += 1;
 361                     }
 362                     if (cur_value > max_value)
 363                         cur_value = max_value;
 364                     break;
 365                 case DLGK_PAGE_PREV:
 366                     cur_value -= data.slide_inc;
 367                     if (cur_value < min_value)
 368                         cur_value = min_value;
 369                     break;
 370                 case DLGK_PAGE_NEXT:
 371                     cur_value += data.slide_inc;
 372                     if (cur_value > max_value)
 373                         cur_value = max_value;
 374                     break;
 375 #ifdef KEY_RESIZE
 376                 case KEY_RESIZE:
 377                     /* reset data */
 378                     height = old_height;
 379                     width = old_width;
 380                     /* repaint */
 381                     dlg_clear();
 382                     dlg_del_window(dialog);
 383                     refresh();
 384                     dlg_mouse_free_regions();
 385                     goto retry;
 386 #endif
 387                 case DLGK_MOUSE('i'):
 388                     state = -data.value_len;
 389                     break;
 390                 default:
 391                     if (is_DLGK_MOUSE(key)) {
 392                         result = dlg_ok_buttoncode(key - M_EVENT);
 393                         if (result < 0)
 394                             result = DLG_EXIT_OK;
 395                     }
 396                     break;
 397                 }
 398             } else if (isdigit(key) && state < 0) {
 399                 if (set_digit(&data, key)) {
 400                     cur_value = data.current;
 401                     data.current--;
 402                 }
 403             } else {
 404                 beep();
 405             }
 406         }
 407     }
 408
 409     sprintf(buffer, "%d", cur_value);
 410     dlg_add_result(buffer);
 411     dlg_add_separator();
 412     dlg_add_last_key(-1);
 413
 414     dlg_del_window(dialog);
 415     dlg_mouse_free_regions();
 416     free(prompt);
 417
 418     return result;
 419 }