cde/programs/dtudcfonted/util.c

   1 /*
   2  * CDE - Common Desktop Environment
   3  *
   4  * Copyright (c) 1993-2012, The Open Group. All rights reserved.
   5  *
   6  * These libraries and programs are free software; you can
   7  * redistribute them and/or modify them under the terms of the GNU
   8  * Lesser General Public License as published by the Free Software
   9  * Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * These libraries and programs are distributed in the hope that
  13  * they will be useful, but WITHOUT ANY WARRANTY; without even the
  14  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE. See the GNU Lesser General Public License for more
  16  * details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with these librararies and programs; if not, write
  20  * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
  21  * Floor, Boston, MA 02110-1301 USA
  22  */
  23 /* util.c 1.22 - Fujitsu source for CDEnext    96/10/30 13:31:41      */
  24 /* $XConsortium: util.c /main/13 1996/11/08 01:56:34 cde-fuj $ */
  25 /*
  26  *  (c) Copyright 1995 FUJITSU LIMITED
  27  *  This is source code modified by FUJITSU LIMITED under the Joint
  28  *  Development Agreement for the CDEnext PST.
  29  *  This is unpublished proprietary source code of FUJITSU LIMITED
  30  */
  31
  32
  33
  34
  35 #include <stdlib.h>
  36 #include <wchar.h>
  37 #include <Xm/XmAll.h>
  38 #include <Xm/RowColumn.h>
  39 #include <Xm/MainW.h>
  40
  41 #include "util.h"
  42 #include "ufontrsrc.h"
  43 #include "FaLib.h"
  44
  45 extern Widget toplevel;
  46 static void _destroy();
  47 void _unmap();
  48
  49 extern Resource resource ;
  50
  51 #include "xpm.h"
  52 #include "pixmaps/Pencil.pm"
  53 #include "pixmaps/Line.pm"
  54 #include "pixmaps/Rectangle.pm"
  55 #include "pixmaps/Circle.pm"
  56 #include "pixmaps/Eraser.pm"
  57 #include "pixmaps/SelectArea.pm"
  58
  59 #ifdef XPM
  60 #define ReadXpm XpmCreatePixmapFromData
  61 #else
  62 #define ReadXpm _DtXpmCreatePixmapFromData
  63 #endif
  64 #define NUMPIX 6
  65
  66 #include "pixmaps/arrow.pm"
  67
  68 /*ARGSUSED*/
  69 Widget
  70 CreateCaptionFrame(owner, name, labelstr, type, thickness)
  71 Widget owner;
  72 String name;
  73 String labelstr;
  74 int type;
  75 int thickness;
  76 {
  77     Widget top, label, frame;
  78     Arg args[20];
  79     int n;
  80     XmString xmstr;
  81
  82     n = 0;
  83     top = XmCreateForm(owner, "form", args, n);
  84     if (labelstr && *labelstr){
  85         xmstr = XmStringCreateLocalized(labelstr);
  86         n = 0;
  87         XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM);  n++;
  88         XtSetArg(args[n], XmNlabelString, xmstr);  n++;
  89         label = XmCreateLabelGadget(top, "label", args, n);
  90         XtManageChild(label);
  91         XmStringFree(xmstr);
  92
  93         n = 0;
  94         XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET);  n++;
  95         XtSetArg(args[n], XmNtopWidget, label);  n++;
  96     }
  97     else{
  98         n = 0;
  99         XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM);  n++;
 100     }
 101     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM);  n++;
 102     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM);  n++;
 103     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM);  n++;
 104     XtSetArg(args[n], XmNresizable, resource.capt_resize  );  n++;
 105     XtSetArg(args[n], XmNshadowType, type);  n++;
 106     XtSetArg(args[n], XmNshadowThickness , thickness);  n++;
 107     XtSetArg(args[n], XmNleftOffset, resource.capt_lftoff );  n++;
 108     XtSetArg(args[n], XmNtopOffset, resource.capt_topoff );  n++;
 109     XtSetArg(args[n], XmNrightOffset, resource.capt_rghoff );  n++;
 110     frame = XmCreateFrame(top, "frame", args, n);
 111     XtManageChild(frame);
 112     XtManageChild(top);
 113     return(frame);
 114 }
 115
 116 /*
 117  *
 118  *      create pix button
 119  *
 120  */
 121
 122 Widget
 123 CreatePixButton(owner, name, data)
 124 Widget owner;
 125 String name;
 126 RadioButt *data;
 127 {
 128     Arg args[20];
 129     int i, n;
 130     Pixmap mask;
 131     XpmAttributes attr;
 132     Pixmap pix[NUMPIX];
 133     Widget top;
 134     Display *disp;
 135     Window root;
 136
 137     disp = XtDisplay(owner);
 138     root = DefaultRootWindow(disp);
 139
 140     n = 0;
 141     XtSetArg(args[n], XmNborderWidth, 1); n++;
 142     XtSetArg(args[n], XmNradioAlwaysOne, TRUE); n++;
 143     XtSetArg(args[n], XmNradioBehavior, TRUE); n++;
 144     top = XmCreateRowColumn(owner, name, args, n);
 145
 146     attr.valuemask = 0;
 147
 148     ReadXpm(disp, root, Pencil, &pix[0], &mask, &attr);
 149     ReadXpm(disp, root, Line, &pix[1], &mask, &attr);
 150     ReadXpm(disp, root, Rectangle, &pix[2], &mask, &attr);
 151     ReadXpm(disp, root, Circle, &pix[3], &mask, &attr);
 152     ReadXpm(disp, root, Eraser, &pix[4], &mask, &attr);
 153     ReadXpm(disp, root, SelectArea, &pix[5], &mask, &attr);
 154
 155     for (i=0; i < NUMPIX; i++) {
 156         n = 0;
 157         XtSetArg(args[n], XmNlabelType, XmPIXMAP); n++;
 158         XtSetArg(args[n], XmNlabelPixmap, pix[i]); n++;
 159         XtSetArg(args[n], XmNindicatorOn, False); n++;
 160         XtSetArg(args[n], XmNshadowThickness, 2); n++;
 161         XtSetArg(args[n], XmNfillOnSelect, False); n++;
 162         XtSetArg(args[n], XmNset, data->items[i].set); n++;
 163         XtSetArg(args[n], XmNwidth, 36); n++;
 164         XtSetArg(args[n], XmNheight, 36); n++;
 165         data->items[i].w = XmCreateToggleButton(top, data->items[i].name, args, n);
 166         XtManageChild(data->items[i].w);
 167         XtAddCallback(data->items[i].w, XmNvalueChangedCallback,
 168                                  data->items[i].cb, data->items[i].clientdata);
 169     }
 170     XtManageChild(top);
 171     return(top);
 172 }
 173
 174
 175 /*
 176  *
 177  *      returns the value what the text field has
 178  *
 179  */
 180
 181 #ifdef _HPUX_SOURCE
 182 String
 183 #else
 184 XtPointer
 185 #endif
 186 GetTextFieldValue(textf)
 187 TextField *textf;
 188 {
 189     char *s1, *s2, *s3;
 190     if (textf->w2 == NULL) {
 191             XtVaGetValues(textf->w1, XmNvalue, &s1, NULL);
 192             return(s1);
 193     } else {
 194         if (XtIsSensitive(textf->w2)) {
 195             XtVaGetValues(textf->w1, XmNvalue, &s1, NULL);
 196             XtVaGetValues(textf->w2, XmNvalue, &s2, NULL);
 197             s3 = (char *) XtMalloc(strlen(s1) + strlen(s2) + 2);
 198             strcpy(s3, s1);
 199             strcat(s3, "-");
 200             strcat(s3, s2);
 201             XtFree(s1);
 202             XtFree(s2);
 203             return(s3);
 204         } else {
 205             XtVaGetValues(textf->w1, XmNvalue, &s1, NULL);
 206             return(s1);
 207         }
 208     }
 209 }
 210
 211 /*ARGSUSED*/
 212 static void
 213 arrow_change(w, data)
 214 TextField *data;
 215 {
 216     if (XtIsSensitive(data->w2)) {
 217         XtSetSensitive(data->w2, False);
 218     } else {
 219         XtSetSensitive(data->w2, True);
 220     }
 221 }
 222
 223 static Widget           focus_widget=NULL;
 224 extern char             AreaStr[160];
 225 extern FalFontData      fullFontData;
 226
 227 static void
 228 focus(w)
 229 Widget w;
 230 {
 231     focus_widget = w;
 232 }
 233
 234 static void
 235 code_input()
 236 {
 237     extern void CodeWindow();
 238     CodeWindow(focus_widget, fullFontData.xlfdname, False);
 239 }
 240
 241 /*ARGSUSED*/
 242 void
 243 CreateTextField(owner, name, labelstr, data, maxlength)
 244 Widget owner;
 245 String name;
 246 String labelstr;
 247 TextField *data;
 248 int maxlength;
 249 {
 250     Widget              row, label, arrow, textfield, code;
 251     Arg                 args[20];
 252     register int        n;
 253     Display             *disp;
 254     Window              root;
 255     Pixmap              mask;
 256     XpmAttributes       attr;
 257     XmString            xms;
 258     extern Pixmap       arrow_pix;
 259
 260     n = 0;
 261     XtSetArg(args[n], XmNorientation, (XtArgVal)XmHORIZONTAL); n++;
 262     row = XmCreateRowColumn(owner, "row", args, n);
 263     XtManageChild(row);
 264
 265     n = 0;
 266     xms = XmStringCreateLocalized(labelstr);
 267     XtSetArg(args[n], XmNlabelString, xms);  n++;
 268     label = XmCreateLabelGadget(row, "label", args, n);
 269     XtManageChild(label);
 270     XmStringFree(xms);
 271
 272     n = 0;
 273     XtSetArg(args[n], XmNcolumns, maxlength);  n++;
 274     XtSetArg(args[n], XmNmaxLength, maxlength);  n++;
 275     data->w1 = focus_widget = textfield =
 276                                 XmCreateText(row, "textField", args, n);
 277     XtManageChild(textfield);
 278     XtAddCallback(textfield, XmNfocusCallback, (XtCallbackProc)focus, NULL);
 279
 280     if (! arrow_pix) {
 281         disp = XtDisplay(row);
 282         root = DefaultRootWindow(disp);
 283         attr.valuemask = 0;
 284         ReadXpm(disp, root, arrow_pm, &arrow_pix, &mask, &attr);
 285     }
 286
 287     n = 0;
 288     XtSetArg(args[n], XmNlabelPixmap, arrow_pix);  n++;
 289     XtSetArg(args[n], XmNlabelType, XmPIXMAP); n++;
 290     XtSetArg(args[n], XmNindicatorOn, False); n++;
 291     XtSetArg(args[n], XmNshadowThickness, 2); n++;
 292     XtSetArg(args[n], XmNfillOnSelect, False); n++;
 293     XtSetArg(args[n], XmNhighlightThickness, 0); n++;
 294     arrow = XmCreateToggleButton(row, "arrow", args, n);
 295     XtManageChild(arrow);
 296     XtAddCallback(arrow, XmNvalueChangedCallback,
 297                                 (XtCallbackProc)arrow_change, (XtPointer)data);
 298
 299     n = 0;
 300     XtSetArg(args[n], XmNcolumns, maxlength );  n++;
 301     XtSetArg(args[n], XmNmaxLength, maxlength);  n++;
 302     data->w2 = textfield = XmCreateText(row, "textField", args, n);
 303     XtManageChild(textfield);
 304     XtSetSensitive(textfield, False);
 305     XtAddCallback(textfield, XmNfocusCallback, (XtCallbackProc)focus, NULL);
 306
 307     n = 0;
 308     xms = XmStringCreateLocalized(resource.code) ;
 309     XtSetArg(args[n], XmNlabelString, xms); n++;
 310     XtSetArg(args[n], XmNhighlightThickness, 0); n++;
 311     code = XmCreatePushButton(row, "Code", args, n);
 312     XtManageChild(code);
 313     XmStringFree(xms);
 314
 315     XtAddCallback(code, XmNactivateCallback,
 316                         (XtCallbackProc)code_input, (XtPointer)textfield);
 317 }
 318
 319
 320 void
 321 #if __STDC__
 322 CreateMenuButtons( Widget owner, Button *buttons, int buttons_cnt )
 323 #else
 324 CreateMenuButtons( owner, buttons, buttons_cnt )
 325 Widget  owner;
 326 Button  *buttons;
 327 int             buttons_cnt;
 328 #endif
 329 {
 330     Arg args[4];
 331     char buf[64];
 332     XmString xms;
 333     int i, n;
 334
 335 #define LABEL(x)        (buttons->items[(x)].label)
 336 #define NMNIC(x)        (buttons->items[(x)].mnemonic)
 337 #define SENS(x)         (buttons->items[(x)].sensitive)
 338
 339     buttons->w = (Widget *) malloc(sizeof(Widget)*buttons_cnt);
 340
 341     if (buttons->w) {
 342         for (i=0; i<buttons_cnt; i++) {
 343             if (LABEL(i) && *((char *) LABEL(i))){
 344                 n=0;
 345                 if (strchr(LABEL(i), NMNIC(i))){
 346                     sprintf(buf, "%s", LABEL(i));
 347                 }else{
 348                     sprintf(buf, "%s(%c)", LABEL(i), NMNIC(i));
 349                 }
 350                 xms = XmStringCreateLocalized(buf);
 351                 XtSetArg(args[n],XmNlabelString, xms); n++;
 352                 XtSetArg(args[n],XmNmnemonic, NMNIC(i)); n++;
 353                 XtSetArg(args[n],XmNsensitive, SENS(i)); n++;
 354                 buttons->w[i] =
 355                 XmCreatePushButtonGadget(owner, "button", args, n);
 356                 if (buttons->items[i].cb){
 357                     XtAddCallback(buttons->w[i], XmNactivateCallback,
 358                             buttons->items[i].cb, buttons->items[i].clientdata);
 359                 }
 360                 XmStringFree(xms);
 361             } else{
 362                 n = 0;
 363                 XtSetArg(args[n], XmNseparatorType, XmSHADOW_ETCHED_IN); n++;
 364                 XtSetArg(args[n], XmNmargin, resource.menu_margin );  n++;
 365                 buttons->w[i] = XmCreateSeparatorGadget(owner,
 366                                                         "separater", args, n);
 367             }
 368             XtManageChild(buttons->w[i]);
 369         }
 370     }
 371 #undef LABEL
 372 #undef NMNIC
 373 #undef SENS
 374 }
 375
 376 static Atom
 377 DeleteWindowAtom()
 378 {
 379     static Atom delatom = NULL;
 380     if (! delatom){
 381         delatom = XInternAtom(XtDisplayOfObject(toplevel),
 382                 "WM_DELETE_WINDOW", False);
 383     }
 384     return(delatom);
 385 }
 386
 387 /*ARGSUSED*/
 388 Widget
 389 #if __STDC__
 390 CreateDialogAndButtons( Widget owner, String name,
 391         void (*delcb)(), Button *btns, int btns_cnt, Widget *pop )
 392 #else
 393 CreateDialogAndButtons( owner, name, delcb, btns, btns_cnt, pop )
 394 Widget owner;
 395 String name;
 396 void   (*delcb)();
 397 Button *btns;
 398 int    btns_cnt;
 399 Widget *pop;
 400 #endif
 401 {
 402     int         n;
 403     Arg         args[32];
 404     Arg arg[8];
 405     Widget      rowcol;
 406     XmString    cs1, cs2, cs3;
 407
 408     n = 0;
 409     XtSetArg( args[n], XmNautoUnmanage, resource. dia_tm_automng );     n++;
 410     XtSetArg( args[n], XmNmarginWidth, resource.dia_tm_width  );        n++;
 411     XtSetArg( args[n], XmNmarginHeight, resource.dia_tm_height  );      n++;
 412     if (btns->itemcnt > 0){
 413         cs1 = XmStringCreateLocalized(btns->items[0].label);
 414         XtSetArg(args[n], XmNokLabelString, cs1);  n++;
 415     }
 416     if (btns->itemcnt > 1){
 417         cs2 = XmStringCreateLocalized(btns->items[1].label);
 418         XtSetArg(args[n], XmNcancelLabelString, cs2);  n++;
 419     }
 420     if (btns->itemcnt > 2){
 421         cs3 = XmStringCreateLocalized(btns->items[2].label);
 422         XtSetArg(args[n], XmNhelpLabelString, cs3);  n++;
 423     }
 424     XtSetArg(args[n], XmNnoResize, resource.dia_tm_resize  );  n++;
 425     XtSetArg(args[n], XmNminimizeButtons, resource.dia_tm_minimize  );  n++;
 426     XtSetArg(args[n], XmNtitle, name  );  n++;
 427     *pop = XmCreateTemplateDialog(toplevel, "dialog", args, n);
 428     if (delcb)
 429         XmAddWMProtocolCallback(XtParent(*pop),
 430                         DeleteWindowAtom(), delcb, 0);
 431     n = 0;
 432     XtSetArg( arg[n], XmNmarginWidth, resource.dia_rw_width );   n++;
 433     XtSetArg( arg[n], XmNmarginHeight, resource.dia_rw_height );  n++;
 434     XtSetArg( arg[n], XmNspacing, resource.dia_rw_spacing  ); n++;
 435     XtSetArg( arg[n], XmNorientation, XmVERTICAL);  n++;
 436     rowcol = XmCreateRowColumn( *pop, "RowCol", arg, n);
 437     XtManageChild(rowcol);
 438     if (btns->itemcnt > 0){
 439         if (! btns->items[0].cb)
 440             XtAddCallback(*pop, XmNokCallback, _unmap, 0);
 441         XtAddCallback(*pop, XmNokCallback, btns->items[0].cb,
 442           (btns->items[0].clientdata != NULL) ? btns->items[0].clientdata : 0);
 443     }
 444     if (btns->itemcnt > 1){
 445         if (! btns->items[1].cb)
 446             XtAddCallback(*pop, XmNcancelCallback, _unmap, 0);
 447         XtAddCallback(*pop, XmNcancelCallback, btns->items[1].cb,
 448           (btns->items[1].clientdata != NULL) ? btns->items[1].clientdata : 0);
 449     }
 450     if (btns->itemcnt > 2){
 451         if (! btns->items[2].cb)
 452             XtAddCallback(*pop, XmNhelpCallback, _unmap, 0);
 453         XtAddCallback(*pop, XmNhelpCallback, btns->items[2].cb,
 454           (btns->items[2].clientdata != NULL) ? btns->items[2].clientdata : 0);
 455     }
 456     n = 0;
 457     XtSetValues(*pop, args, n);
 458     if (btns->itemcnt == 1){
 459         XmStringFree(cs1);
 460     }
 461     else if (btns->itemcnt == 2){
 462         XmStringFree(cs1);
 463         XmStringFree(cs2);
 464     }
 465     else if (btns->itemcnt == 3){
 466         XmStringFree(cs1);
 467         XmStringFree(cs2);
 468         XmStringFree(cs3);
 469     }
 470     return(rowcol);
 471 }
 472
 473
 474 /* Initialize GUI */
 475
 476 Widget
 477 GuiInitialize(app, class_name, ac, av)
 478 XtAppContext *app;
 479 String class_name;
 480 int *ac;
 481 String av[];
 482 {
 483         Widget top;
 484
 485         XtSetLanguageProc(NULL, NULL, NULL);
 486         _DtEnvControl(0);
 487
 488         top = XtAppInitialize(app, class_name, NULL,0, ac,av, NULL,NULL,0);
 489
 490         return(top);
 491 }
 492
 493 Widget
 494 CreateDrawingArea( owner, name, width, height, proc, val )
 495 Widget owner;
 496 String name;
 497 int width;
 498 int height;
 499 void (*proc)();
 500 int val;
 501 {
 502         int n;
 503         Arg arg[16];
 504         Widget drawarea;
 505
 506         n = 0;
 507         XtSetArg(arg[n], XmNwidth, width); n++;
 508         XtSetArg(arg[n], XmNheight, height); n++;
 509         XtSetArg(arg[n], XmNresizePolicy, XmRESIZE_NONE); n++;
 510         XtSetArg(arg[n], XmNborderWidth, resource.draw_border); n++;
 511         XtSetArg(arg[n], XmNbackground, resource.pane_background); n++;
 512         XtSetArg(arg[n], XmNtopAttachment, (XtArgVal)XmATTACH_FORM); n++;
 513         XtSetArg(arg[n], XmNleftAttachment, (XtArgVal)XmATTACH_FORM); n++;
 514         XtSetArg(arg[n], XmNtopOffset, (XtArgVal)resource.draw_topoff); n++;
 515         XtSetArg(arg[n], XmNleftOffset, (XtArgVal)resource.draw_lftoff); n++;
 516         drawarea = XmCreateDrawingArea(owner, name, arg, n);
 517         XtManageChild( drawarea );
 518         XtAddEventHandler(drawarea, ExposureMask, FALSE, proc, (XtPointer)val);
 519         return(drawarea);
 520 }
 521
 522
 523 #ifndef USE_MACRO
 524
 525 void
 526 AddLeftAttachWidget( w, ref, offset )
 527 Widget w;
 528 Widget ref;
 529 int offset;
 530 {
 531     XtVaSetValues( w,
 532     XmNleftAttachment, XmATTACH_WIDGET,
 533     XmNleftWidget, ref,
 534     XmNleftOffset, offset,
 535     0);
 536 }
 537
 538 void
 539 AddLeftAttachForm( w, offset )
 540 Widget w;
 541 int offset;
 542 {
 543     XtVaSetValues( w,
 544     XmNleftAttachment, XmATTACH_FORM,
 545     XmNleftOffset, offset,
 546     0);
 547 }
 548
 549 void
 550 AddTopAttachWidget( w, ref, offset )
 551 Widget w;
 552 Widget ref;
 553 int offset;
 554 {
 555     XtVaSetValues( w,
 556     XmNtopAttachment, XmATTACH_WIDGET,
 557     XmNtopWidget, ref,
 558     XmNtopOffset, offset,
 559     0);
 560 }
 561
 562 void
 563 AddTopAttachForm( w, offset )
 564 Widget w;
 565 int offset;
 566 {
 567     XtVaSetValues( w,
 568     XmNtopAttachment, XmATTACH_FORM,
 569     XmNtopOffset, offset,
 570     0);
 571 }
 572
 573 void
 574 AddRightAttachWidget( w, ref, offset )
 575 Widget w;
 576 Widget ref;
 577 int offset;
 578 {
 579     XtVaSetValues( w,
 580     XmNrightAttachment, XmATTACH_WIDGET,
 581     XmNrightWidget, ref,
 582     XmNrightOffset, offset,
 583     0);
 584 }
 585
 586 void
 587 AddRightAttachForm( w, offset )
 588 Widget w;
 589 int offset;
 590 {
 591     XtVaSetValues( w,
 592     XmNrightAttachment, XmATTACH_FORM,
 593     XmNrightOffset, offset,
 594     0);
 595 }
 596
 597 void
 598 AddBottomAttachForm( w, offset )
 599 Widget w;
 600 int offset;
 601 {
 602     XtVaSetValues( w,
 603     XmNbottomAttachment, XmATTACH_FORM,
 604     XmNbottomOffset, offset,
 605     0);
 606 }
 607 #endif  /* not USE_MACRO */
 608
 609 void
 610 PopupDialog(w)
 611 Widget w;
 612 {
 613     if (! XtIsManaged(w))
 614         XtManageChild(w);
 615     else
 616         XRaiseWindow(XtDisplayOfObject(w), XtWindow(XtParent(w)));
 617 }
 618
 619 void
 620 PopdownDialog(w)
 621 Widget w;
 622 {
 623     if (XtIsManaged(w)){
 624         XtUnmanageChild(w);
 625     }
 626 }
 627
 628 void
 629 ForcePopdownDialog(w)
 630 Widget w;
 631 {
 632     if (XtIsManaged(w)){
 633         XtUnmanageChild(w);
 634     }
 635 }
 636
 637 void
 638 SetLabelString(w, str)
 639 Widget w;
 640 String str;
 641 {
 642     XmString cs;
 643     cs = XmStringCreateLocalized(str);
 644     XtVaSetValues( w, XmNlabelString, cs, 0);
 645     XmStringFree( cs );
 646 }
 647
 648 void
 649 SetFooterString(w, str)
 650 Widget w;
 651 String str;
 652 {
 653     XmString cs;
 654     cs = XmStringCreateLocalized(str);
 655     XtVaSetValues( w, XmNlabelString, cs, 0);
 656     XmStringFree( cs );
 657         XmUpdateDisplay(w);
 658 }
 659
 660
 661 /***********************************************************************
 662  create and pop up the confirmaiton window
 663  **********************************************************************/
 664
 665 static Widget notice=NULL;
 666
 667 static void
 668 format_str(st, charcnt , str)
 669 Widget st;
 670 int     charcnt ;
 671 char *str;
 672 {
 673         int i ;
 674         char *s, *p;
 675         static char buf[512];
 676         int lw;
 677         int len ;
 678         wchar_t wc ;
 679         XmString cs;
 680
 681         if (! str || ! *str)    return;
 682
 683         for( p=str, s=buf, lw=0; *p != NULL;  ){
 684
 685                 if ( (*p == '\n') || (charcnt <= lw) ){
 686                         *s = '\n';      /* new line */
 687                         lw = 0;
 688                         s++;
 689                 }
 690                 if( (len = mbtowc( &wc, p, MB_CUR_MAX )) <= 0 ) break;
 691                 for( i=0; i<len ; i++, s++, p++ )  *s = *p ;
 692
 693                 lw += wcwidth( wc );
 694         }
 695         *s = NULL;
 696
 697         cs = XmStringCreateLocalized(buf);
 698         XtVaSetValues(st, XmNlabelString, (XtArgVal)cs, (String)0 );
 699         XmStringFree(cs);
 700 }
 701
 702 void _unmap()
 703 {
 704         if (notice && XtIsManaged(notice)){
 705                 XtUnmanageChild(notice);
 706         }
 707 }
 708
 709 static void _destroy(w)
 710 Widget w;
 711 {
 712         if (w){
 713                 XtDestroyWidget(w);
 714         }
 715         if (w == notice){
 716                 notice = NULL;
 717         }
 718 }
 719
 720
 721 /*ARGSUSED*/
 722 void
 723 PopupNotice( owner, message, type, button, do_format, title )
 724 Widget owner;
 725 char *message;
 726 unsigned char type;
 727 NButton *button;
 728 Boolean do_format;
 729 String title;
 730 {
 731     Widget      label, help, cancel;
 732     int         n;
 733     Arg         args[32];
 734     XmString cs1, cs2, cs3;
 735
 736     n = 0;
 737     XtSetArg(args[n], XmNtitle, title ); n++;
 738     XtSetArg(args[n], XmNnoResize, resource.pop_resize  ); n++;
 739     XtSetArg(args[n], XmNminimizeButtons, resource.pop_minimize ); n++;
 740     XtSetArg(args[n], XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL); n++;
 741     XtSetArg(args[n], XmNdialogType, type);  n++;
 742     notice = XmCreateMessageDialog( toplevel , "PopupNotice", args, n);
 743     n = 0;
 744     if (button->itemcnt > 0){
 745         cs1 = XmStringCreateLocalized(button->items[0].label);
 746         XtSetArg(args[n], XmNokLabelString, cs1);  n++;
 747         if (button->items[0].cb)
 748             XtAddCallback(notice, XmNokCallback, button->items[0].cb, NULL);
 749         cancel = XmMessageBoxGetChild(notice, XmDIALOG_CANCEL_BUTTON);
 750         help = XmMessageBoxGetChild(notice, XmDIALOG_HELP_BUTTON);
 751     }
 752     if (button->itemcnt > 1){
 753         cs2 = XmStringCreateLocalized(button->items[1].label);
 754         XtSetArg(args[n], XmNcancelLabelString, cs2);  n++;
 755         if (button->items[1].cb)
 756             XtAddCallback(notice, XmNcancelCallback, button->items[1].cb, NULL);
 757     }
 758     if (button->itemcnt > 2){
 759         cs3 = XmStringCreateLocalized(button->items[2].label);
 760         XtSetArg(args[n], XmNhelpLabelString, cs3);  n++;
 761         if (button->items[2].cb)
 762             XtAddCallback(notice, XmNhelpCallback, button->items[2].cb, NULL);
 763         XtAddCallback(help, XmNactivateCallback, (XtCallbackProc)_unmap, NULL);
 764     }
 765     XtSetValues(notice, args, n);
 766     XtAddCallback(notice, XmNunmapCallback, (XtCallbackProc)_destroy, NULL);
 767     if (button->itemcnt == 1){
 768         XmStringFree(cs1);
 769         XtUnmanageChild(cancel);
 770         XtUnmanageChild(help);
 771     }
 772     else if (button->itemcnt == 2){
 773         XmStringFree(cs1);
 774         XmStringFree(cs2);
 775         XtUnmanageChild(help);
 776     }
 777     else if (button->itemcnt == 3){
 778         XmStringFree(cs1);
 779         XmStringFree(cs2);
 780         XmStringFree(cs3);
 781     }
 782
 783     label = XmMessageBoxGetChild(notice, XmDIALOG_MESSAGE_LABEL);
 784
 785     if (do_format)
 786         format_str(label, 52, message);
 787     else{
 788         cs1 = XmStringCreateLocalized(message);
 789         XtVaSetValues(notice,
 790             XmNmessageString, (XtArgVal) cs1, (String) 0);
 791         XtVaSetValues(notice,
 792             XmNmessageAlignment, XmALIGNMENT_CENTER, (String) 0);
 793         XmStringFree(cs1);
 794     }
 795     XtManageChild(notice);
 796     XBell(XtDisplayOfObject( toplevel ), 0);
 797 }
 798
 799
 800 /*ARGSUSED*/
 801 static void
 802 _layout_centerEH(w, clientdata)
 803 Widget w;
 804 XtPointer clientdata;
 805 {
 806     Widget *child;
 807     int num;
 808     Dimension bbw, mw, sw, cw;
 809
 810
 811     XtVaGetValues(w, XmNchildren, &child, XmNnumChildren, &num, 0);
 812     XtVaGetValues(XtParent(w),
 813         XmNwidth, &bbw,
 814         XmNmarginWidth, &mw,
 815         XmNshadowThickness, &sw,
 816         0);
 817     XtVaGetValues(child[0], XmNwidth, &cw, 0);
 818     XtVaSetValues(w, XmNwidth, ((int)bbw-2*((int)mw+(int)sw)), NULL);
 819     XtVaSetValues(child[0], XmNx,
 820                         ((((int)bbw-2*((int)mw+(int)sw))-(int)cw)/2), NULL);
 821 }
 822
 823 /*ARGSUSED*/
 824 Widget
 825 CreateTemplateDialog( w, message, type, button, title, pop )
 826 Widget w;
 827 char *message;
 828 unsigned char type;
 829 NButton *button;
 830 String title;
 831 Widget *pop;
 832 {
 833     int         n;
 834     Arg         args[32];
 835     XmString    cs, cs1=NULL, cs2=NULL, cs3=NULL;
 836     Widget      brtnb;
 837
 838     n = 0;
 839     cs = XmStringCreateLocalized(message);
 840     XtSetArg(args[n], XmNnoResize, resource.temp_resize );  n++;
 841     XtSetArg(args[n], XmNminimizeButtons, resource.temp_minimize );  n++;
 842     XtSetArg(args[n], XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL); n++;
 843     XtSetArg(args[n], XmNmessageString, cs);  n++;
 844     XtSetArg(args[n], XmNmessageAlignment, XmALIGNMENT_CENTER);  n++;
 845     XtSetArg(args[n], XmNtitle, title ); n++;
 846
 847     if (button->itemcnt > 0){
 848         cs1 = XmStringCreateLocalized(button->items[0].label);
 849         XtSetArg(args[n], XmNokLabelString, cs1);  n++;
 850     }
 851     if (button->itemcnt > 1){
 852         cs2 = XmStringCreateLocalized(button->items[1].label);
 853         XtSetArg(args[n], XmNcancelLabelString, cs2);  n++;
 854     }
 855     if (button->itemcnt > 2){
 856         cs3 = XmStringCreateLocalized(button->items[2].label);
 857         XtSetArg(args[n], XmNhelpLabelString, cs3);  n++;
 858     }
 859     *pop = XmCreateTemplateDialog(w, "TemplateDialog", args, n);
 860     if (button->itemcnt > 0 && button->items[0].cb)
 861         XtAddCallback(*pop, XmNokCallback, button->items[0].cb, NULL);
 862     if (button->itemcnt > 1 && button->items[1].cb)
 863         XtAddCallback(*pop, XmNcancelCallback, button->items[1].cb, NULL);
 864     if (button->itemcnt > 2 && button->items[2].cb)
 865         XtAddCallback(*pop, XmNhelpCallback, button->items[2].cb, NULL);
 866
 867     XmStringFree(cs);
 868     if (cs1) XmStringFree(cs1);
 869     if (cs2) XmStringFree(cs2);
 870     if (cs3) XmStringFree(cs3);
 871
 872     XtAddCallback(*pop, XmNunmapCallback, (XtCallbackProc)_destroy, NULL);
 873     n = 0;
 874     XtSetArg(args[n], XmNwidth, resource.temp_width );  n++;
 875     XtSetArg(args[n], XmNheight, resource.temp_height );  n++;
 876     brtnb = XmCreateBulletinBoard(*pop, "BulletinBo", args, n);
 877     XtManageChild(brtnb);
 878     XtAddEventHandler(brtnb,
 879         StructureNotifyMask, True, (XtEventHandler)_layout_centerEH, NULL);
 880     return(brtnb);
 881 }
 882
 883
 884
 885
 886 void
 887 AddDeleteProc(w, delcb)
 888 Widget w;
 889 void (*delcb)();
 890 {
 891         Atom del = DeleteWindowAtom();
 892         XmAddWMProtocols( w, &del, 1);
 893         XmAddWMProtocolCallback( w, del, delcb, NULL );
 894 }
 895
 896 void
 897 AddPopupProc(w, popupcb)
 898 Widget w;
 899 void (*popupcb)();
 900 {
 901     XtAddCallback(XtParent(w), XmNpopupCallback, popupcb, 0);
 902 }
 903
 904 void
 905 AddDestroyProc(w, destroycb)
 906 Widget w;
 907 void (*destroycb)();
 908 {
 909     XtAddCallback(XtParent(w), XmNdestroyCallback, destroycb, 0);
 910 }
 911
 912 Widget
 913 CreateMenuBarAndFooterMessageForm(owner, name, buttons, bcnt, pop, footer)
 914 Widget owner;
 915 String name;
 916 MButton *buttons;
 917 int bcnt;
 918 Widget *pop;
 919 Widget *footer;
 920 {
 921     Widget menuBar, form;
 922     Widget footerFrame, footerForm, footerLabel, sep, casBtn, baseForm;
 923     XmString cs;
 924     char buf[64];
 925     Arg arg[20];
 926     int n, i;
 927
 928     n = 0;
 929     XtSetArg( arg[n], XmNiconName, name ); n++;
 930     XtSetArg( arg[n], XmNdeleteResponse, XmUNMAP ); n++;
 931     XtSetArg( arg[n], XmNmwmFunctions,
 932                 (MWM_FUNC_MOVE | MWM_FUNC_MINIMIZE | MWM_FUNC_CLOSE)); n++;
 933     *pop = XtCreatePopupShell(name, applicationShellWidgetClass, owner, arg, n);
 934
 935     n = 0;
 936     XtSetArg( arg[n], XmNshowSeparator, True ); n++;
 937     form = XmCreateMainWindow( *pop, "MainW", arg, n);
 938     XtManageChild(form);
 939
 940     n = 0;
 941     menuBar = XmCreateMenuBar( form, "menuBar", arg, n);
 942     XtManageChild(menuBar);
 943
 944     n = 0;
 945     baseForm = XmCreateForm( form, "wgeForm", arg, n);
 946     XtManageChild(baseForm);
 947
 948     for (i=0; i<bcnt; i++){
 949         n = 0;
 950         XtSetArg(arg[n], XmNtearOffModel, XmTEAR_OFF_ENABLED);  n++;
 951         buttons->items[i].menu =
 952         XmCreatePulldownMenu(menuBar, "menu", arg, n);
 953         n = 0;
 954         if (strchr(buttons->items[i].label, buttons->items[i].mnemonic)){
 955             sprintf(buf, "%s", buttons->items[i].label);
 956         }else{
 957             strcpy(buf, buttons->items[i].label);
 958             strcat(buf, "(");
 959             strcat(buf, &(buttons->items[i].mnemonic));
 960             strcat(buf, ")");
 961         }
 962         cs = XmStringCreateLocalized(buf);
 963         XtSetArg(arg[n],XmNmnemonic, buttons->items[i].mnemonic ); n++;
 964         XtSetArg(arg[n],XmNlabelString, cs ); n++;
 965         XtSetArg(arg[n],XmNsubMenuId,   buttons->items[i].menu ); n++;
 966         casBtn = XmCreateCascadeButton( menuBar, "casBtnA", arg, n);
 967         XtManageChild(casBtn);
 968         XmStringFree(cs);
 969     }
 970
 971     n = 0;
 972     XtSetArg( arg[n], XmNshadowType,       XmSHADOW_IN ); n++;
 973     footerFrame = XmCreateFrame( form, "footerFrame", arg, n);
 974     XtManageChild(footerFrame);
 975     XtVaSetValues(form, XmNmessageWindow, footerFrame, NULL);
 976
 977     n = 0;
 978     XtSetArg( arg[n], XmNtopAttachment,    XmATTACH_FORM); n++;
 979     XtSetArg( arg[n], XmNbottomAttachment, XmATTACH_FORM); n++;
 980     XtSetArg( arg[n], XmNleftAttachment,   XmATTACH_FORM); n++;
 981     XtSetArg( arg[n], XmNrightAttachment,  XmATTACH_FORM); n++;
 982     footerForm = XmCreateForm( footerFrame, "footerForm", arg, n);
 983     XtManageChild(footerForm);
 984
 985     n = 0;
 986     cs = XmStringCreateLocalized(resource.message);
 987     XtSetArg( arg[n], XmNlabelString,      cs); n++;
 988     XtSetArg( arg[n], XmNtopAttachment,    XmATTACH_FORM); n++;
 989     XtSetArg( arg[n], XmNbottomAttachment, XmATTACH_FORM); n++;
 990     XtSetArg( arg[n], XmNleftAttachment,   XmATTACH_FORM); n++;
 991     XtSetArg( arg[n], XmNmarginTop,    resource.ed_msg_margintop );  n++;
 992     XtSetArg( arg[n], XmNmarginBottom, resource.ed_msg_marginbtm );  n++;
 993     footerLabel = XmCreateLabel(footerForm, "Message", arg,n);
 994     XtManageChild(footerLabel);
 995     XmStringFree(cs);
 996
 997     n = 0;
 998     cs = XmStringCreateLocalized("");
 999     XtSetArg( arg[n], XmNtopAttachment,    XmATTACH_FORM); n++;
1000     XtSetArg( arg[n], XmNbottomAttachment, XmATTACH_FORM); n++;
1001     XtSetArg( arg[n], XmNrightAttachment,  XmATTACH_FORM); n++;
1002     XtSetArg( arg[n], XmNleftAttachment,   XmATTACH_WIDGET); n++;
1003     XtSetArg( arg[n], XmNleftWidget,   footerLabel); n++;
1004     XtSetArg( arg[n], XmNalignment,    XmALIGNMENT_BEGINNING);  n++;
1005     XtSetArg( arg[n], XmNmarginTop,    resource.ed_mesg_margintop );  n++;
1006     XtSetArg( arg[n], XmNmarginBottom, resource.ed_mesg_marginbtm );  n++;
1007     XtSetArg( arg[n], XmNlabelString, cs);  n++;
1008     *footer = XmCreateLabelGadget(footerForm, "MessageG", arg, n);
1009     XtManageChild(*footer);
1010     XmStringFree(cs);
1011
1012     return(baseForm);
1013 }
1014
1015 Widget
1016 GetMenuWidget( buttons, buttons_num )
1017 MButton *buttons;
1018 int buttons_num;
1019 {
1020     return(buttons->items[buttons_num].menu);
1021 }
1022
1023 Widget
1024 CreateForm( owner, name )
1025 Widget owner;
1026 String name;
1027 {
1028         Widget form;
1029         int n;
1030         Arg arg[8];
1031
1032         n=0;
1033         form = XmCreateForm( owner, name, arg, n );
1034         XtManageChild(form);
1035         return(form);
1036 }
1037
1038 /*ARGSUSED*/
1039 Widget
1040 CreateLabel( owner, name, str )
1041 Widget owner;
1042 String name;
1043 String str;
1044 {
1045         Widget label;
1046         Arg arg[2];
1047         int n=0;
1048         XmString cs = XmStringCreateLocalized(str);
1049         XtSetArg( arg[n], XmNlabelString, cs); n++;
1050         label = XmCreateLabel( owner, "label", arg, n);
1051         XtManageChild(label);
1052         return(label);
1053 }
1054
1055
1056 /*ARGSUSED*/
1057 Widget
1058 CreateFrame(owner, name, type, thickness)
1059 Widget owner;
1060 String name;
1061 XtPointer type;
1062 XtPointer thickness;
1063 {
1064         Widget frame;
1065         Arg args[20];
1066         int n;
1067
1068         n = 0;
1069         XtSetArg(args[n], XmNresizable, resource.frame_resize );  n++;
1070         XtSetArg(args[n], XmNshadowType, type);  n++;
1071         XtSetArg(args[n], XmNshadowThickness , thickness);  n++;
1072         frame = XmCreateFrame(owner, "frame", args, n);
1073         XtManageChild(frame);
1074         return(frame);
1075 }
1076
1077 /*ARGSUSED*/
1078 Widget
1079 CreateRowColumn(owner, name, layout, space, marginw, marginh)
1080 Widget owner;
1081 String name;
1082 int layout;
1083 int space;
1084 int marginw;
1085 int marginh;
1086 {
1087         Widget rc;
1088         Arg args[20];
1089         int n;
1090
1091         n = 0;
1092         XtSetArg(args[n], XmNorientation, layout);  n++;
1093         XtSetArg(args[n], XmNspacing, space);  n++;
1094         XtSetArg(args[n], XmNmarginWidth, marginw);  n++;
1095         XtSetArg(args[n], XmNmarginHeight, marginh);  n++;
1096         rc = XmCreateRowColumn(owner, "rowColumn", args, n);
1097         XtManageChild(rc);
1098         return(rc);
1099 }
1100
1101 /*ARGSUSED*/
1102 Widget
1103 CreateScrollBar( owner, name, height, val, min, max, proc )
1104 Widget owner;
1105 String name;
1106 int height;
1107 int val;
1108 int min;
1109 int max;
1110 void (*proc)();
1111 {
1112     Widget sc;
1113     int n;
1114     Arg arg[16];
1115
1116     n = 0;
1117     XtSetArg( arg[n], XmNsliderSize, (XtArgVal)val );  n++;
1118     XtSetArg( arg[n], XmNpageIncrement, (XtArgVal)val );   n++;
1119     XtSetArg( arg[n], XmNmaximum,        (XtArgVal)max );        n++;
1120
1121     sc = XmCreateScrollBar(owner, "wgeScro", arg, n);
1122     XtManageChild( sc );
1123     XtAddCallback( sc, XmNvalueChangedCallback, proc, NULL );
1124     return(sc);
1125 }
1126
1127
1128 /*ARGSUSED*/
1129 static void
1130 _scbase_cb( w, proc, calldata )
1131 Widget w;
1132 void (*proc)();
1133 XmScrollBarCallbackStruct *calldata;
1134 {
1135     (*proc)(calldata->value);
1136 }
1137
1138 Widget
1139 CreateScrollBase( owner, name, min, max, val, vcnt, sbproc )
1140 Widget owner;
1141 String name;
1142 int min;
1143 int max;
1144 int val;
1145 int vcnt;
1146 void (*sbproc)();
1147 {
1148     int n;
1149     Arg arg[16];
1150     Widget base, frame, rwclm, sc;
1151
1152     n=0;
1153     XtSetArg( arg[n], XmNwidth, resource.scll_fr_width ); n++;
1154     base = XmCreateForm( owner, name, arg, n );
1155     XtManageChild( base );
1156     n=0;
1157     XtSetArg( arg[n], XmNshadowType, XmSHADOW_IN ); n++;
1158     XtSetArg( arg[n], XmNshadowThickness, resource.scll_fr_thick ); n++;
1159     XtSetArg( arg[n], XmNbottomAttachment, XmATTACH_FORM ); n++;
1160     frame = XmCreateFrame( base, name, arg, n );
1161     XtManageChild( frame );
1162     n=0;
1163     rwclm = XmCreateRowColumn( frame, name, arg, n );
1164     XtManageChild( rwclm );
1165     if (vcnt < (max-min)){
1166         n=0;
1167         XtSetArg( arg[n], XmNsliderSize, vcnt ); n++;
1168         XtSetArg( arg[n], XmNminimum, min ); n++;
1169         XtSetArg( arg[n], XmNmaximum, max ); n++;
1170         XtSetArg( arg[n], XmNvalue, val ); n++;
1171         XtSetArg( arg[n], XmNleftAttachment, XmATTACH_WIDGET ); n++;
1172         XtSetArg( arg[n], XmNleftWidget, rwclm ); n++;
1173         XtSetArg( arg[n], XmNleftOffset, resource.scll_bar_lftoff ); n++;
1174         XtSetArg( arg[n], XmNtopAttachment, XmATTACH_FORM ); n++;
1175         XtSetArg( arg[n], XmNbottomAttachment, XmATTACH_FORM ); n++;
1176         sc = XmCreateScrollBar( base, name, arg, n );
1177         XtManageChild( sc );
1178         XtAddCallback( sc, XmNvalueChangedCallback,
1179                                 (XtCallbackProc)_scbase_cb, (XtPointer)sbproc);
1180     }
1181     return( rwclm );
1182 }