src/programs/view/xdlg.cpp

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 1991-2000, University of Groningen, The Netherlands.
   5  * Copyright (c) 2001-2004, The GROMACS development team.
   6  * Copyright (c) 2013,2014,2015,2017, by the GROMACS development team, led by
   7  * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
   8  * and including many others, as listed in the AUTHORS file in the
   9  * top-level source directory and at http://www.gromacs.org.
  10  *
  11  * GROMACS is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Lesser General Public License
  13  * as published by the Free Software Foundation; either version 2.1
  14  * of the License, or (at your option) any later version.
  15  *
  16  * GROMACS is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public
  22  * License along with GROMACS; if not, see
  23  * http://www.gnu.org/licenses, or write to the Free Software Foundation,
  24  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
  25  *
  26  * If you want to redistribute modifications to GROMACS, please
  27  * consider that scientific software is very special. Version
  28  * control is crucial - bugs must be traceable. We will be happy to
  29  * consider code for inclusion in the official distribution, but
  30  * derived work must not be called official GROMACS. Details are found
  31  * in the README & COPYING files - if they are missing, get the
  32  * official version at http://www.gromacs.org.
  33  *
  34  * To help us fund GROMACS development, we humbly ask that you cite
  35  * the research papers on the package. Check out http://www.gromacs.org.
  36  */
  37 #include "gmxpre.h"
  38
  39 #include "xdlg.h"
  40
  41 #include <cstdio>
  42 #include <cstdlib>
  43 #include <cstring>
  44
  45 #include "gromacs/utility/cstringutil.h"
  46 #include "gromacs/utility/fatalerror.h"
  47 #include "gromacs/utility/smalloc.h"
  48
  49 #include "Xstuff.h"
  50 #include "xmb.h"
  51 #include "xutil.h"
  52 /*****************************
  53  *
  54  * Helpful routines
  55  *
  56  ****************************/
  57 t_dlgitem *FindItem(t_dlg *dlg, t_id id)
  58 {
  59     int i;
  60
  61     for (i = 0; (i < dlg->nitem); i++)
  62     {
  63         if (dlg->dlgitem[i]->ID == id)
  64         {
  65             return dlg->dlgitem[i];
  66         }
  67     }
  68     return nullptr;
  69 }
  70
  71 t_dlgitem *FindWin(t_dlg *dlg, Window win)
  72 {
  73     int i;
  74
  75     for (i = 0; (i < dlg->nitem); i++)
  76     {
  77         if (dlg->dlgitem[i]->win.self == win)
  78         {
  79             return dlg->dlgitem[i];
  80         }
  81     }
  82     return nullptr;
  83 }
  84
  85 /*****************************
  86  *
  87  * Routines to manipulate items on a dialog box
  88  *
  89  ****************************/
  90 bool QueryDlgItemSize(t_dlg *dlg, t_id id, int *w, int *h)
  91 {
  92     t_dlgitem *dlgitem;
  93
  94     if ((dlgitem = FindItem(dlg, id)) != nullptr)
  95     {
  96         *w = dlgitem->win.width;
  97         *h = dlgitem->win.height;
  98         return true;
  99     }
 100     return false;
 101 }
 102
 103 bool QueryDlgItemPos(t_dlg *dlg, t_id id, int *x0, int *y0)
 104 {
 105     t_dlgitem *dlgitem;
 106
 107     if ((dlgitem = FindItem(dlg, id)) != nullptr)
 108     {
 109         *x0 = dlgitem->win.x;
 110         *y0 = dlgitem->win.y;
 111         return true;
 112     }
 113     return false;
 114 }
 115
 116 int QueryDlgItemX(t_dlg *dlg, t_id id)
 117 {
 118     t_dlgitem *dlgitem;
 119
 120     if ((dlgitem = FindItem(dlg, id)) != nullptr)
 121     {
 122         return dlgitem->win.x;
 123     }
 124     return 0;
 125 }
 126
 127 int QueryDlgItemY(t_dlg *dlg, t_id id)
 128 {
 129     t_dlgitem *dlgitem;
 130
 131     if ((dlgitem = FindItem(dlg, id)) != nullptr)
 132     {
 133         return dlgitem->win.y;
 134     }
 135     return 0;
 136 }
 137
 138 int QueryDlgItemW(t_dlg *dlg, t_id id)
 139 {
 140     t_dlgitem *dlgitem;
 141
 142     if ((dlgitem = FindItem(dlg, id)) != nullptr)
 143     {
 144         return dlgitem->win.width;
 145     }
 146     return 0;
 147 }
 148
 149 int QueryDlgItemH(t_dlg *dlg, t_id id)
 150 {
 151     t_dlgitem *dlgitem;
 152
 153     if ((dlgitem = FindItem(dlg, id)) != nullptr)
 154     {
 155         return dlgitem->win.height;
 156     }
 157     return 0;
 158 }
 159
 160 bool SetDlgItemSize(t_dlg *dlg, t_id id, int w, int h)
 161 {
 162     t_dlgitem *dlgitem;
 163 #ifdef DEBUG
 164     int        old_w, old_h;
 165 #endif
 166
 167     if ((dlgitem = FindItem(dlg, id)) != nullptr)
 168     {
 169 #ifdef DEBUG
 170         old_w = dlgitem->win.width;
 171         old_h = dlgitem->win.height;
 172 #endif
 173         if (w)
 174         {
 175             dlgitem->win.width = w;
 176         }
 177         if (h)
 178         {
 179             dlgitem->win.height = h;
 180         }
 181 #ifdef DEBUG
 182         std::fprintf(dlg->x11->console,
 183                      "Size window from: %dx%d to %dx%d\n", old_w, old_h,
 184                      dlgitem->win.width, dlgitem->win.height);
 185         dlg->x11->Flush(dlg->x11);
 186 #endif
 187         if (dlgitem->win.self)
 188         {
 189             XResizeWindow(dlg->x11->disp, dlgitem->win.self, dlgitem->win.width,
 190                           dlgitem->win.height);
 191         }
 192         if ((w) && (dlgitem->type == edlgGB))
 193         {
 194             int  i;
 195             t_id gid = dlgitem->GroupID;
 196             t_id id  = dlgitem->ID;
 197             for (i = 0; (i < dlg->nitem); i++)
 198             {
 199                 t_dlgitem *child = dlg->dlgitem[i];
 200                 if ((child->GroupID == gid) && (child->ID != id))
 201                 {
 202                     SetDlgItemSize(dlg, child->ID, w-4*OFFS_X, 0);
 203                 }
 204             }
 205         }
 206         return true;
 207     }
 208     return false;
 209 }
 210
 211 bool SetDlgItemPos(t_dlg *dlg, t_id id, int x0, int y0)
 212 {
 213     t_dlgitem *dlgitem;
 214     int        old_x, old_y;
 215
 216     if ((dlgitem = FindItem(dlg, id)) != nullptr)
 217     {
 218         old_x          = dlgitem->win.x;
 219         old_y          = dlgitem->win.y;
 220         dlgitem->win.x = x0;
 221         dlgitem->win.y = y0;
 222 #ifdef DEBUG
 223         std::fprintf(dlg->x11->console,
 224                      "Move window from: %d,%d to %d,%d\n", old_x, old_y, x0, y0);
 225         dlg->x11->Flush(dlg->x11);
 226 #endif
 227         if (dlgitem->win.self)
 228         {
 229             XMoveWindow(dlg->x11->disp, dlgitem->win.self, x0, y0);
 230         }
 231         if (dlgitem->type == edlgGB)
 232         {
 233             int  i, x, y;
 234             t_id gid = dlgitem->GroupID;
 235             t_id id  = dlgitem->ID;
 236             x = dlgitem->win.x+2*OFFS_X-old_x;
 237             y = dlgitem->win.y+2*OFFS_Y-old_y;
 238             for (i = 0; (i < dlg->nitem); i++)
 239             {
 240                 t_dlgitem *child = dlg->dlgitem[i];
 241                 if ((child->GroupID == gid) && (child->ID != id))
 242                 {
 243                     SetDlgItemPos(dlg, child->ID, child->win.x+x, child->win.y+y);
 244                 }
 245             }
 246         }
 247         return true;
 248     }
 249     return false;
 250 }
 251
 252 /*****************************
 253  *
 254  * Routines to extract information from the dlg proc
 255  * after dlg is exec'ed
 256  *
 257  ****************************/
 258 bool IsCBChecked(t_dlg *dlg, t_id id)
 259 {
 260     t_dlgitem *dlgitem;
 261
 262     if ((dlgitem = FindItem(dlg, id)) != nullptr)
 263     {
 264         if (dlgitem->type == edlgCB)
 265         {
 266             return dlgitem->u.checkbox.bChecked;
 267         }
 268     }
 269
 270     return false;
 271 }
 272
 273 t_id RBSelected(t_dlg *dlg, int gid)
 274 {
 275     int i;
 276
 277     for (i = 0; (i < dlg->nitem); i++)
 278     {
 279         if ((dlg->dlgitem[i]->type == edlgRB) &&
 280             (dlg->dlgitem[i]->u.radiobutton.bSelect) &&
 281             (dlg->dlgitem[i]->GroupID == gid))
 282         {
 283             return dlg->dlgitem[i]->ID;
 284         }
 285     }
 286
 287     return -1;
 288 }
 289
 290 int EditTextLen(t_dlg *dlg, t_id id)
 291 {
 292     t_dlgitem *dlgitem;
 293
 294     if ((dlgitem = FindItem(dlg, id)) != nullptr)
 295     {
 296         if (dlgitem->type == edlgET)
 297         {
 298             return std::strlen(dlgitem->u.edittext.buf);
 299         }
 300     }
 301
 302     return 0;
 303 }
 304
 305 char *EditText(t_dlg *dlg, t_id id)
 306 {
 307     t_dlgitem *dlgitem;
 308
 309     if ((dlgitem = FindItem(dlg, id)) != nullptr)
 310     {
 311         if (dlgitem->type == edlgET)
 312         {
 313             return dlgitem->u.edittext.buf;
 314         }
 315     }
 316
 317     return nullptr;
 318 }
 319
 320 /*****************************
 321  *
 322  * Exececute the dialog box procedure
 323  * Returns when a button is pushed.
 324  * return value is the ID of the button
 325  *
 326  ****************************/
 327 void ShowDlg(t_dlg *dlg)
 328 {
 329     int        i;
 330     t_dlgitem *dlgitem;
 331
 332     XMapWindow(dlg->x11->disp, dlg->win.self);
 333     XMapSubwindows(dlg->x11->disp, dlg->win.self);
 334     for (i = 0; (i < dlg->nitem); i++)
 335     {
 336         LightBorder(dlg->x11->disp, dlg->dlgitem[i]->win.self, dlg->bg);
 337     }
 338     XSetForeground(dlg->x11->disp, dlg->x11->gc, dlg->x11->fg);
 339     for (i = 0; (i < dlg->nitem); i++)
 340     {
 341         dlgitem = dlg->dlgitem[i];
 342         if ((dlgitem->type == edlgBN) &&
 343             (dlgitem->u.button.bDefault))
 344         {
 345             PushMouse(dlg->x11->disp, dlgitem->win.self,
 346                       dlgitem->win.width/2, dlgitem->win.height/2);
 347             dlg->bPop = true;
 348             break;
 349         }
 350     }
 351     dlg->bGrab = false;
 352 }
 353
 354 void HideDlg(t_dlg *dlg)
 355 {
 356     if (dlg->bPop)
 357     {
 358         PopMouse(dlg->x11->disp);
 359     }
 360
 361     XUnmapSubwindows(dlg->x11->disp, dlg->win.self);
 362     XUnmapWindow(dlg->x11->disp, dlg->win.self);
 363 }
 364
 365 void NoHelp(t_dlg *dlg)
 366 {
 367     const char *lines[2] = {
 368         "Error",
 369         "No help for this item"
 370     };
 371     MessageBox(dlg->x11, dlg->wDad, "No Help", 2, lines,
 372                MB_OK | MB_ICONSTOP | MB_APPLMODAL, nullptr, nullptr);
 373 }
 374
 375 void HelpDlg(t_dlg *dlg)
 376 {
 377     const char *lines[] = {
 378         "Place the cursor over one of the items",
 379         "and press the F1 key to get more help.",
 380         "First press the OK button."
 381     };
 382     MessageBox(dlg->x11, dlg->win.self, "Help Dialogbox",
 383                3, lines, MB_OK | MB_ICONINFORMATION | MB_APPLMODAL, nullptr, nullptr);
 384 }
 385
 386 void HelpNow(t_dlg *dlg, t_dlgitem *dlgitem)
 387 {
 388     char     buf[80];
 389     bool     bCont = true;
 390     int      i, nlines = 0;
 391     char   **lines = nullptr;
 392
 393     if (!dlgitem->help)
 394     {
 395         NoHelp(dlg);
 396         return;
 397     }
 398
 399     std::printf("%s\n", dlgitem->help);
 400     do
 401     {
 402         fgets2(buf, 79, stdin);
 403 #ifdef DEBUG
 404         std::fprintf(dlg->x11->console, "buffer: '%s'\n", buf);
 405         dlg->x11->Flush(dlg->x11);
 406 #endif
 407         if (gmx_strcasecmp(buf, "nok") == 0)
 408         {
 409             /* An error occurred */
 410             if (lines)
 411             {
 412                 for (i = 0; (i < nlines); i++)
 413                 {
 414                     sfree(lines[i]);
 415                 }
 416                 sfree(lines);
 417             }
 418             NoHelp(dlg);
 419             return;
 420         }
 421         else
 422         {
 423             bCont = (gmx_strcasecmp(buf, "ok") != 0);
 424             if (bCont)
 425             {
 426                 srenew(lines, ++nlines);
 427                 lines[nlines-1] = gmx_strdup(buf);
 428             }
 429         }
 430     }
 431     while (bCont);
 432     MessageBox(dlg->x11, dlg->wDad, "Help",
 433                nlines, lines,
 434                MB_OK | MB_ICONINFORMATION | MB_APPLMODAL, nullptr, nullptr);
 435     for (i = 0; (i < nlines); i++)
 436     {
 437         sfree(lines[i]);
 438     }
 439     sfree(lines);
 440 }
 441
 442 static void EnterDlg(t_dlg *dlg)
 443 {
 444     if (dlg->flags & DLG_APPLMODAL)
 445     {
 446         dlg->bGrab = GrabOK(dlg->x11->console,
 447                             XGrabPointer(dlg->x11->disp, dlg->win.self,
 448                                          True, 0, GrabModeAsync, GrabModeAsync,
 449                                          dlg->win.self, None, CurrentTime));
 450     }
 451     dlg->x11->Flush(dlg->x11);
 452 }
 453
 454 static void ExitDlg(t_dlg *dlg)
 455 {
 456     if (dlg->bGrab)
 457     {
 458         XUngrabPointer(dlg->x11->disp, CurrentTime);
 459         dlg->bGrab = false;
 460     }
 461     HideDlg(dlg);
 462     if (dlg->flags & DLG_FREEONBUTTON)
 463     {
 464         FreeDlg(dlg);
 465     }
 466 }
 467
 468 static bool DlgCB(t_x11 *x11, XEvent *event, Window w, void *data)
 469 {
 470     t_dlg     *dlg = (t_dlg *)data;
 471     int        i, nWndProc;
 472     t_dlgitem *dlgitem;
 473
 474     if ((dlgitem = FindWin(dlg, w)) != nullptr)
 475     {
 476         nWndProc = (dlgitem->WndProc)(x11, dlgitem, event);
 477 #ifdef DEBUG
 478         std::fprintf(x11->console,
 479                      "window: %s, nWndProc: %d\n", dlgitem->win.text, nWndProc);
 480         x11->Flush(x11);
 481 #endif
 482         switch (nWndProc)
 483         {
 484             case ENTERPRESSED:
 485                 if ((dlgitem->type == edlgBN) && (dlgitem->u.button.bDefault))
 486                 {
 487                     if (dlg->cb)
 488                     {
 489                         dlg->cb(x11, DLG_EXIT, dlgitem->ID, dlgitem->win.text, dlg->data);
 490                     }
 491                     else
 492                     {
 493                         ExitDlg(dlg);
 494                     }
 495                 }
 496                 else
 497                 {
 498                     for (i = 0; (i < dlg->nitem); i++)
 499                     {
 500                         if ((dlg->dlgitem[i]->type == edlgBN) &&
 501                             (dlg->dlgitem[i]->u.button.bDefault))
 502                         {
 503                             PushMouse(x11->disp, dlg->dlgitem[i]->win.self,
 504                                       dlg->dlgitem[i]->win.width/2,
 505                                       dlg->dlgitem[i]->win.height/2);
 506                             break;
 507                         }
 508                     }
 509                 }
 510                 break;
 511             case BNPRESSED:
 512                 if (dlg->cb)
 513                 {
 514                     dlg->cb(x11, DLG_EXIT, dlgitem->ID, dlgitem->win.text, dlg->data);
 515                 }
 516                 else
 517                 {
 518                     ExitDlg(dlg);
 519                 }
 520                 break;
 521             case RBPRESSED:
 522             {
 523                 int  gid = dlgitem->GroupID;
 524                 t_id tid = RBSelected(dlg, gid);
 525 #ifdef DEBUG
 526                 std::fprintf(stderr, "RBPRESSED\n");
 527 #endif
 528                 if (tid != -1)
 529                 {
 530                     t_dlgitem *dit = FindItem(dlg, tid);
 531                     dit->u.radiobutton.bSelect = false;
 532                     ExposeWin(x11->disp, dit->win.self);
 533                 }
 534                 else
 535                 {
 536                     gmx_fatal(FARGS, "No RB Selected initially!\n");
 537                 }
 538                 dlgitem->u.radiobutton.bSelect = true;
 539                 ExposeWin(x11->disp, dlgitem->win.self);
 540                 if (dlg->cb)
 541                 {
 542                     dlg->cb(x11, DLG_SET, dlgitem->ID, dlgitem->win.text, dlg->data);
 543                 }
 544                 break;
 545             }
 546             case CBPRESSED:
 547                 ExposeWin(x11->disp, dlgitem->win.self);
 548                 if (dlg->cb)
 549                 {
 550                     dlg->cb(x11, DLG_SET, dlgitem->ID, dlgitem->set, dlg->data);
 551                 }
 552                 break;
 553             case ETCHANGED:
 554                 ExposeWin(x11->disp, dlgitem->win.self);
 555                 if (dlg->cb)
 556                 {
 557                     dlg->cb(x11, DLG_SET, dlgitem->ID, dlgitem->u.edittext.buf, dlg->data);
 558                 }
 559                 break;
 560             case HELPPRESSED:
 561                 HelpNow(dlg, dlgitem);
 562                 break;
 563             case ITEMOK:
 564                 break;
 565             default:
 566                 gmx_fatal(FARGS, "Invalid return code (%d) from wndproc\n", nWndProc);
 567         }
 568     }
 569     else if (w == dlg->win.self)
 570     {
 571         switch (event->type)
 572         {
 573             case Expose:
 574                 EnterDlg(dlg);
 575                 break;
 576             case ButtonPress:
 577             case KeyPress:
 578                 if (HelpPressed(event))
 579                 {
 580                     HelpDlg(dlg);
 581                 }
 582                 else
 583                 {
 584                     XBell(x11->disp, 50);
 585                 }
 586                 break;
 587             default:
 588                 break;
 589         }
 590     }
 591     return false;
 592 }
 593
 594 /*****************************
 595  *
 596  * Routine to add an item to the dialog box
 597  * The pointer to the item is copied to the dlg struct,
 598  * the item itself may not be freed until the dlg is done with
 599  *
 600  ****************************/
 601 void DoCreateDlg(t_dlg *dlg)
 602 {
 603     XSizeHints           hints;
 604     XSetWindowAttributes attr;
 605     unsigned long        Val;
 606
 607     attr.border_pixel      = dlg->x11->fg;
 608     attr.background_pixel  = dlg->bg;
 609     attr.override_redirect = False;
 610     attr.save_under        = True;
 611     attr.cursor            = XCreateFontCursor(dlg->x11->disp, XC_hand2);
 612     Val                    = CWBackPixel | CWBorderPixel | CWOverrideRedirect | CWSaveUnder |
 613         CWCursor;
 614     dlg->win.self = XCreateWindow(dlg->x11->disp, dlg->wDad,
 615                                   dlg->win.x, dlg->win.y,
 616                                   dlg->win.width, dlg->win.height,
 617                                   dlg->win.bwidth, CopyFromParent,
 618                                   InputOutput, CopyFromParent,
 619                                   Val, &attr);
 620     dlg->x11->RegisterCallback(dlg->x11, dlg->win.self, dlg->wDad,
 621                                DlgCB, dlg);
 622     dlg->x11->SetInputMask(dlg->x11, dlg->win.self,
 623                            ExposureMask | ButtonPressMask | KeyPressMask);
 624
 625     if (!CheckWindow(dlg->win.self))
 626     {
 627         std::exit(1);
 628     }
 629     hints.x     = dlg->win.x;
 630     hints.y     = dlg->win.y;
 631     hints.flags = PPosition;
 632     XSetStandardProperties(dlg->x11->disp, dlg->win.self, dlg->title,
 633                            dlg->title, None, nullptr, 0, &hints);
 634 }
 635
 636 void AddDlgItem(t_dlg *dlg, t_dlgitem *item)
 637 {
 638 #define EnterLeaveMask (EnterWindowMask | LeaveWindowMask)
 639 #define UserMask (ButtonPressMask | KeyPressMask)
 640     static unsigned long InputMask[edlgNR] = {
 641         ExposureMask | UserMask | EnterLeaveMask, /* edlgBN */
 642         ExposureMask | UserMask | EnterLeaveMask, /* edlgRB */
 643         ExposureMask,                             /* edlgGB */
 644         ExposureMask | UserMask | EnterLeaveMask, /* edlgCB */
 645         0,                                        /* edlgPM */
 646         ExposureMask,                             /* edlgST */
 647         ExposureMask | UserMask | EnterLeaveMask  /* edlgET */
 648     };
 649
 650     if (!dlg->win.self)
 651     {
 652         DoCreateDlg(dlg);
 653     }
 654     srenew(dlg->dlgitem, dlg->nitem+1);
 655     if (!item)
 656     {
 657         gmx_fatal(FARGS, "dlgitem not allocated");
 658     }
 659     item->win.self =
 660         XCreateSimpleWindow(dlg->x11->disp, dlg->win.self, item->win.x, item->win.y,
 661                             item->win.width, item->win.height,
 662                             item->win.bwidth, dlg->x11->fg, dlg->x11->bg);
 663     CheckWindow(item->win.self);
 664
 665     dlg->x11->RegisterCallback(dlg->x11, item->win.self, dlg->win.self,
 666                                DlgCB, dlg);
 667     dlg->x11->SetInputMask(dlg->x11, item->win.self, InputMask[item->type]);
 668
 669     switch (item->type)
 670     {
 671         case edlgPM:
 672             XSetWindowBackgroundPixmap(dlg->x11->disp, item->win.self, item->u.pixmap.pm);
 673             break;
 674         default:
 675             break;
 676     }
 677     dlg->dlgitem[dlg->nitem] = item;
 678
 679     dlg->nitem++;
 680 }
 681
 682 void AddDlgItems(t_dlg *dlg, int nitem, t_dlgitem *item[])
 683 {
 684     int i;
 685
 686     for (i = 0; (i < nitem); i++)
 687     {
 688 #ifdef DEBUG
 689         std::fprintf(dlg->x11->console,
 690                      "Adding item: %d from group %d\n", item[i]->ID, item[i]->GroupID);
 691         dlg->x11->Flush(dlg->x11);
 692 #endif
 693         AddDlgItem(dlg, item[i]);
 694     }
 695 }
 696
 697 void FreeDlgItem(t_dlg *dlg, t_id id)
 698 {
 699     t_dlgitem *dlgitem;
 700     int        i;
 701
 702     if ((dlgitem = FindItem(dlg, id)) != nullptr)
 703     {
 704         dlg->x11->UnRegisterCallback(dlg->x11, dlgitem->win.self);
 705         if (dlgitem->win.self)
 706         {
 707             XDestroyWindow(dlg->x11->disp, dlgitem->win.self);
 708         }
 709         FreeWin(dlg->x11->disp, &(dlgitem->win));
 710         switch (dlgitem->type)
 711         {
 712             case edlgBN:
 713             case edlgRB:
 714                 break;
 715             case edlgGB:
 716                 sfree(dlgitem->u.groupbox.item);
 717                 break;
 718             case edlgCB:
 719                 break;
 720             case edlgPM:
 721                 XFreePixmap(dlg->x11->disp, dlgitem->u.pixmap.pm);
 722                 break;
 723             case edlgST:
 724                 for (i = 0; (i < dlgitem->u.statictext.nlines); i++)
 725                 {
 726                     sfree(dlgitem->u.statictext.lines[i]);
 727                 }
 728                 sfree(dlgitem->u.statictext.lines);
 729                 break;
 730             case edlgET:
 731                 sfree(dlgitem->u.edittext.buf);
 732                 break;
 733             default:
 734                 break;
 735         }
 736     }
 737 }
 738
 739 void FreeDlg(t_dlg *dlg)
 740 {
 741     int i;
 742
 743     if (dlg->dlgitem)
 744     {
 745         HideDlg(dlg);
 746         dlg->x11->UnRegisterCallback(dlg->x11, dlg->win.self);
 747         for (i = 0; (i < dlg->nitem); i++)
 748         {
 749             FreeDlgItem(dlg, dlg->dlgitem[i]->ID);
 750             if (dlg->dlgitem[i])
 751             {
 752                 sfree(dlg->dlgitem[i]);
 753             }
 754         }
 755         sfree(dlg->dlgitem);
 756         if (dlg->win.self)
 757         {
 758             XDestroyWindow(dlg->x11->disp, dlg->win.self);
 759         }
 760         dlg->dlgitem = nullptr;
 761     }
 762 }
 763
 764 /*****************************
 765  *
 766  * Routine to create the DLG structure, returns NULL on failure
 767  *
 768  ****************************/
 769 t_dlg *CreateDlg(t_x11 *x11, Window Parent, const char *title,
 770                  int x0, int y0, int w, int h, int bw,
 771                  DlgCallback *cb, void *data)
 772 {
 773     t_dlg   *dlg;
 774     int      x = 0, y = 0;
 775
 776     snew(dlg, 1);
 777     dlg->x11  = x11;
 778     dlg->cb   = cb;
 779     dlg->data = data;
 780     if (title)
 781     {
 782         dlg->title = gmx_strdup(title);
 783     }
 784     else
 785     {
 786         dlg->title = nullptr;
 787     }
 788     if (w == 0)
 789     {
 790         w = 1;
 791     }
 792     if (h == 0)
 793     {
 794         h = 1;
 795     }
 796     if (!Parent)
 797     {
 798         Parent    = x11->root;
 799         dlg->xmax = DisplayWidth(x11->disp, x11->screen);
 800         dlg->ymax = DisplayHeight(x11->disp, x11->screen);
 801     }
 802     else
 803     {
 804         Window         root;
 805         unsigned int   dum;
 806
 807         XGetGeometry(x11->disp, Parent, &root, &x, &y,
 808                      &(dlg->xmax), &(dlg->ymax), &dum, &dum);
 809 #ifdef DEBUG
 810         std::fprintf(x11->console,
 811                      "Daddy is %d x %d at %d, %d\n", dlg->xmax, dlg->ymax, x, y);
 812         dlg->x11->Flush(dlg->x11);
 813 #endif
 814     }
 815     if (x0)
 816     {
 817         x = x0;
 818     }
 819     if (y0)
 820     {
 821         y = y0;
 822     }
 823     InitWin(&(dlg->win), x, y, w, h, bw, nullptr);
 824     SetDlgSize(dlg, w, h, x0 || y0);
 825
 826     dlg->wDad    = Parent;
 827     dlg->fg      = x11->fg;
 828     dlg->bg      = x11->bg;
 829     dlg->nitem   = 0;
 830     dlg->dlgitem = nullptr;
 831
 832     DoCreateDlg(dlg);
 833     return dlg;
 834 }
 835
 836 void SetDlgSize(t_dlg *dlg, int w, int h, bool bAutoPosition)
 837 {
 838     if (bAutoPosition)
 839     {
 840         int x, y;
 841
 842         x          = (dlg->xmax-w)/2;
 843         y          = (dlg->ymax-h)/2;
 844         dlg->win.x = x;
 845         dlg->win.y = y;
 846     }
 847     dlg->win.width  = w;
 848     dlg->win.height = h;
 849
 850 #ifdef DEBUG
 851     std::fprintf(dlg->x11->console, "SetDlgSize: Dialog is %dx%d, at %d,%d\n",
 852                  dlg->win.width, dlg->win.height, dlg->win.x, dlg->win.y);
 853     dlg->x11->Flush(dlg->x11);
 854 #endif
 855     if (dlg->win.self)
 856     {
 857         XMoveWindow(dlg->x11->disp, dlg->win.self, dlg->win.x, dlg->win.y);
 858         XResizeWindow(dlg->x11->disp, dlg->win.self, w, h);
 859     }
 860 }