src/mathed/math_panel.C

   1 /*
   2  *  File:        math_panel.C
   3  *  Purpose:     Mathed GUI for lyx
   4  *  Author:      Alejandro Aguilar Sierra <asierra@servidor.unam.mx>
   5  *  Created:     March 28, 1996
   6  *
   7  *  Dependencies: Xlib, Xpm, XForms, Lyx
   8  *
   9  *  Copyright: 1996, Alejandro Aguilar Sierra
  10  *
  11  *   You are free to use and modify it under the terms of
  12  *   the GNU General Public Licence version 2 or later.
  13  */
  14
  15 #include <config.h>
  16
  17 #include "Lsstream.h"
  18
  19 #include FORMS_H_LOCATION
  20
  21 #include "lyx_gui_misc.h"
  22 #include "math_panel.h"
  23 #include "symbol_def.h"
  24 #include "formula.h"
  25 #include "lyxfunc.h"
  26 #include "gettext.h"
  27
  28 /* Bitmaps */
  29 #include "delim.xbm"
  30 #include "delim0.xpm"
  31 #include "delim.xpm"
  32 #include "deco.xbm"
  33 #include "deco.xpm"
  34 #include "space.xpm"
  35 #include "sqrt.xpm"
  36 #include "frac.xpm"
  37 #include "matrix.xpm"
  38 #include "equation.xpm"
  39
  40
  41 static LyXFunc * lyxfunc = 0;
  42
  43 //static FD_panel* symb_form= 0;
  44
  45 FD_panel  * fd_panel;
  46 FD_delim  * fd_delim;
  47 FD_deco   * fd_deco;
  48 FD_space  * fd_space;
  49 FD_matrix * fd_matrix;
  50
  51 int delim_code[] = {
  52    '(', ')', LM_lceil,  LM_rceil,  LM_uparrow,  LM_Uparrow,
  53    '[', ']', LM_lfloor,  LM_rfloor,  LM_updownarrow, LM_Updownarrow,
  54    '{', '}',  '/', LM_backslash,  LM_downarrow,  LM_Downarrow,
  55    LM_langle,  LM_rangle, '|', LM_Vert, '.', 0
  56 };
  57
  58 // indexes to get the left and right versions of each delimiter
  59 // Contributed by Pablo De Napoli (pdenapo@dm.uba.ar)
  60 int delim_lversion[] = { 0,0,2,2,4,5,
  61                          6,6,8,8,10,11,
  62                          12,12,14,15,16,17,
  63                          18,18,20,21,22,23 };
  64
  65 int delim_rversion[] = { 1,1,3,3,4,5,
  66                         7,7,9,9,10,11,
  67                         13,13,14,15,16,17,
  68                         19,19,20,21,22,23 };
  69
  70
  71 static char const * deco_code[] = {
  72    "widehat", "widetilde", "overbrace", "overleftarrow", "overrightarrow",
  73    "overline", "underbrace", "underline"
  74 };
  75
  76
  77 static char const * func_code[] = {
  78     "arccos", "arcsin", "arctan", "arg", "bmod",
  79     "cos", "cosh", "cot", "coth", "csc", "deg",
  80     "det", "dim", "exp", "gcd", "hom", "inf", "ker",
  81     "lg", "lim", "liminf", "limsup", "ln", "log",
  82     "max", "min", "sec", "sin", "sinh", "sup",
  83     "tan", "tanh"
  84 };
  85
  86 static char h_align_str[80] = "c";
  87
  88 /* callbacks for form panel */
  89 void button_cb(FL_OBJECT * ob, long data)
  90 {
  91    extern void free_symbols_form();
  92    switch (data)  {
  93     case MM_GREEK:
  94     case MM_VARSIZE:
  95     case MM_BRELATS:
  96     case MM_ARROW:
  97     case MM_BOP:
  98     case MM_MISC:
  99       {
 100          BitmapMenu * menu = static_cast<BitmapMenu *>(ob->u_vdata);
 101          menu->Show();
 102          break;
 103       }
 104     case MM_FRAC:
 105        lyxfunc->Dispatch(LFUN_INSERT_MATH, "frac");
 106       break;
 107     case MM_SQRT:
 108        lyxfunc->Dispatch(LFUN_INSERT_MATH, "sqrt");
 109       break;
 110     case MM_DELIM:
 111       fl_show_form(fd_delim->delim,
 112                    FL_PLACE_MOUSE | FL_FREE_SIZE, FL_TRANSIENT,
 113                    _("Delimiter"));
 114        fl_set_form_atclose(fd_delim->delim, CancelCloseBoxCB, 0);
 115       break;
 116     case MM_DECO:
 117       fl_show_form(fd_deco->deco,
 118                    FL_PLACE_MOUSE | FL_FREE_SIZE, FL_TRANSIENT,
 119                    _("Decoration"));
 120        fl_set_form_atclose(fd_deco->deco, CancelCloseBoxCB, 0);
 121       break;
 122     case MM_SPACE:
 123       fl_show_form(fd_space->space,
 124                    FL_PLACE_MOUSE | FL_FREE_SIZE, FL_TRANSIENT,
 125                    _("Spacing"));
 126        fl_set_form_atclose(fd_space->space, CancelCloseBoxCB, 0);
 127       break;
 128     case MM_MATRIX:
 129       fl_show_form(fd_matrix->matrix,
 130                    FL_PLACE_MOUSE | FL_FREE_SIZE, FL_TRANSIENT,
 131                    _("Matrix"));
 132        fl_set_form_atclose(fd_matrix->matrix, CancelCloseBoxCB, 0);
 133       break;
 134     case MM_EQU:
 135        lyxfunc->Dispatch(LFUN_MATH_DISPLAY);
 136       break;
 137     case MM_FUNC:
 138       {
 139           int i = fl_get_browser(fd_panel->func_browse) - 1;
 140           lyxfunc->Dispatch(LFUN_INSERT_MATH, func_code[i]);
 141           break;
 142       }
 143     case 100:
 144       free_symbols_form();
 145       break;
 146    }
 147 }
 148
 149
 150 /* callbacks for form delim */
 151 void delim_cb(FL_OBJECT *, long data)
 152 {
 153    int left = fd_delim->left->u_ldata, right= fd_delim->right->u_ldata;
 154    int side = (fl_get_button(fd_delim->right)!= 0);
 155
 156    switch (data) {
 157     case MM_APPLY:
 158     case MM_OK:
 159       {
 160               std::ostringstream ost;
 161               ost << delim_code[left] << ' ' << delim_code[right];
 162               lyxfunc->Dispatch(LFUN_MATH_DELIM, ost.str().c_str());
 163               if (data == MM_APPLY) break;
 164       }
 165     case MM_CLOSE: fl_hide_form(fd_delim->delim); break;
 166     case 2:
 167       {
 168           int i = fl_get_bmtable(fd_delim->menu);
 169           int button = fl_get_bmtable_numb(fd_delim->menu);
 170           bool both = (button==FL_MIDDLE_MOUSE);
 171
 172           if (i>= 0) {
 173
 174               if (side || (button== FL_RIGHT_MOUSE)) {
 175                   right = i;
 176               } else {
 177                   left = i;
 178                   if (both)
 179                     right = delim_rversion[i];
 180               }
 181           }
 182           Pixmap p1, p2;
 183           p1 = fl_get_pixmap_pixmap(fd_delim->pix, &p1, &p2);
 184           fl_draw_bmtable_item(fd_delim->menu, left, p1, 0, 0);
 185           fl_draw_bmtable_item(fd_delim->menu, right, p1, 16, 0);
 186           fl_redraw_object(fd_delim->pix);
 187
 188           fd_delim->left->u_ldata = left;
 189           fd_delim->right->u_ldata = right;
 190
 191           break;
 192       }
 193     case 3: break;
 194     case 4: break;
 195    }
 196 }
 197
 198 /* callbacks for form matrix */
 199 void matrix_cb(FL_OBJECT *, long data)
 200 {
 201    static char v_align_c[] = "tcb";
 202
 203    switch (data) {
 204     case MM_APPLY:
 205     case MM_OK:
 206       {
 207          char c = v_align_c[fl_get_choice(fd_matrix->valign) - 1];
 208          char const * sh = fl_get_input(fd_matrix->halign);
 209          int nx = int(fl_get_slider_value(fd_matrix->columns) + 0.5);
 210          int ny = int(fl_get_slider_value(fd_matrix->rows) + 0.5);
 211          if (data == MM_OK) fl_hide_form(fd_matrix->matrix);
 212          std::ostringstream ost;
 213          ost << nx << ' ' << ny << ' ' << c << sh;
 214          lyxfunc->Dispatch(LFUN_INSERT_MATRIX, ost.str().c_str());
 215          break;
 216       }
 217     case MM_CLOSE: fl_hide_form(fd_matrix->matrix); break;
 218     case 2:
 219       {
 220          int nx = int(fl_get_slider_value(fd_matrix->columns)+0.5);
 221          for (int i = 0; i < nx; ++i) h_align_str[i] = 'c';
 222          //memset(h_align_str, 'c', nx);
 223          h_align_str[nx] = '\0';
 224 //       fl_freeze_form(fd_form_main->form_main);
 225 //      fl_addto_form(fd_form_main->form_main);
 226
 227          fl_set_input(fd_matrix->halign, h_align_str);
 228          fl_redraw_object(fd_matrix->halign);
 229          break;
 230       }
 231    }
 232 }
 233
 234 /* callbacks for form deco */
 235 void deco_cb(FL_OBJECT *, long data)
 236 {
 237    switch (data) {
 238     case MM_APPLY:
 239     case MM_OK:
 240       {
 241          int const i = fl_get_bmtable(fd_deco->menu);
 242          int const l = sizeof(deco_code)/sizeof(deco_code[0]);
 243          // ideally the callback should not be called if the index is
 244          // greater than the maxitem of the bmtable, but I do not know
 245          // how to enforce that (JMarc)
 246          if (i <= l) {
 247            lyxfunc->Dispatch(LFUN_INSERT_MATH, deco_code[i]);
 248            if (data == MM_APPLY) break;
 249          }
 250          else break;
 251       }
 252     case MM_CLOSE: fl_hide_form(fd_deco->deco); break;
 253    }
 254 }
 255
 256
 257 /* callbacks for form space */
 258 void space_cb(FL_OBJECT *, long data)
 259 {
 260    static short sp = -1;
 261    extern char * latex_mathspace[];
 262
 263    if (data >= 0 && data < 6)
 264       sp = short(data);
 265    else
 266    switch (data) {
 267     case MM_APPLY:
 268     case MM_OK:
 269       {
 270           if (sp>= 0)
 271             lyxfunc->Dispatch(LFUN_INSERT_MATH, latex_mathspace[sp]);
 272          if (data == MM_APPLY) break;
 273       }
 274     case MM_CLOSE: fl_hide_form(fd_space->space); break;
 275    }
 276 }
 277
 278
 279 extern "C" int align_filter(FL_OBJECT *, char const *, char const * cur, int c)
 280 {
 281    int n = int(fl_get_slider_value(fd_matrix->columns)+0.5) - strlen(cur);
 282    return ((c == 'c'||c == 'l'||c == 'r') && n>= 0) ? FL_VALID: FL_INVALID;
 283 }
 284
 285
 286 char const ** mathed_get_pixmap_from_icon(int d)
 287 {
 288    switch (d) {
 289     case MM_FRAC: return frac;
 290     case MM_SQRT: return sqrt_xpm;
 291     case MM_DELIM: return delim;
 292     case MM_MATRIX: return matrix;
 293     case MM_EQU: return equation;
 294     case MM_DECO: return deco;
 295     case MM_SPACE: return space_xpm;
 296     default: return 0;
 297    }
 298 }
 299
 300
 301 FD_panel * create_math_panel( )
 302 {
 303    fd_panel = create_form_panel();
 304    fd_delim = create_form_delim();
 305    fd_deco = create_form_deco();
 306    fd_space = create_form_space();
 307    fd_matrix = create_form_matrix();
 308
 309    /* fill-in form initialization code */
 310    fl_set_button(fd_delim->left, 1);
 311    fl_set_pixmap_data(fd_delim->pix, const_cast<char**>(delim0));
 312    fl_set_bmtable_data(fd_delim->menu, 6, 4, delim_width, delim_height,
 313                        delim_bits);
 314    fl_set_bmtable_maxitems(fd_delim->menu, 23);
 315
 316    fl_set_pixmap_data(fd_panel->sqrt, const_cast<char**>(sqrt_xpm));
 317    fl_set_pixmap_data(fd_panel->frac, const_cast<char**>(frac));
 318    fl_set_pixmap_data(fd_panel->delim, const_cast<char**>(delim));
 319    fl_set_pixmap_data(fd_panel->deco, const_cast<char**>(deco));
 320    fl_set_pixmap_data(fd_panel->space, const_cast<char**>(space_xpm));
 321    fl_set_pixmap_data(fd_panel->matrix, const_cast<char**>(matrix));
 322    fl_set_pixmap_data(fd_panel->equation, const_cast<char**>(equation));
 323
 324    for (int i = 0; i < 32; ++i) {
 325        fl_add_browser_line(fd_panel->func_browse, func_code[i]);
 326    }
 327
 328    fl_addto_choice(fd_matrix->valign, _("Top | Center | Bottom"));
 329    fl_set_choice(fd_matrix->valign, 2);
 330    fl_set_input(fd_matrix->halign, h_align_str);
 331    fl_set_input_filter(fd_matrix->halign, align_filter);
 332
 333    fl_set_bmtable_data(fd_deco->menu, 3, 3, deco_width, deco_height,
 334                        deco_bits);
 335    fl_set_bmtable_maxitems(fd_deco->menu, 8);
 336
 337    fd_delim->left->u_ldata = 0;
 338    fd_delim->right->u_ldata = 1;
 339
 340    return fd_panel;
 341 }
 342
 343 extern BitmapMenu * sym_menu;
 344 extern void  create_symbol_menues(FD_panel *);
 345
 346
 347 void free_symbols_form()
 348 {
 349    if (fd_panel) {
 350       fl_hide_form(fd_panel->panel);
 351       fl_free_form(fd_panel->panel);
 352       delete sym_menu;
 353       free(fd_panel);
 354       fd_panel = 0;
 355    }
 356 }
 357
 358
 359 extern "C" int AtClose_symbols_form(FL_FORM *, void *)
 360 {
 361   free_symbols_form();
 362   return FL_IGNORE;
 363 }
 364
 365
 366 void show_symbols_form(LyXFunc * lf)
 367 {
 368     lyxfunc = lf;
 369     if (!fd_panel) {
 370         fd_panel = create_math_panel();
 371         fl_register_raw_callback(fd_panel->panel,
 372                                  ButtonPressMask|KeyPressMask, C_peek_event);
 373         create_symbol_menues(fd_panel);
 374         fl_set_form_atclose(fd_panel->panel, AtClose_symbols_form, 0);
 375     }
 376     if (fd_panel->panel->visible) {
 377         fl_raise_form(fd_panel->panel);
 378     } else {
 379       fl_show_form(fd_panel->panel,
 380                    FL_PLACE_MOUSE | FL_FREE_SIZE, FL_TRANSIENT,
 381                    _("Math Panel"));
 382     }
 383 }