motif_l/m_search.c

   1 /*-
   2  * Copyright (c) 1996
   3  *      Rob Zimmermann.  All rights reserved.
   4  * Copyright (c) 1996
   5  *      Keith Bostic.  All rights reserved.
   6  *
   7  * See the LICENSE file for redistribution information.
   8  */
   9
  10 #include "config.h"
  11
  12 #ifndef lint
  13 static const char sccsid[] = "$Id: m_search.c,v 8.6 1996/12/11 20:58:25 bostic Exp $ (Berkeley) $Date: 1996/12/11 20:58:25 $";
  14 #endif /* not lint */
  15
  16 #include <sys/queue.h>
  17
  18 /* context */
  19 #include <X11/X.h>
  20 #include <X11/Intrinsic.h>
  21 #include <Xm/DialogS.h>
  22 #include <Xm/Form.h>
  23 #include <Xm/Label.h>
  24 #include <Xm/PushBG.h>
  25 #include <Xm/TextF.h>
  26 #include <Xm/ToggleB.h>
  27 #include <Xm/RowColumn.h>
  28
  29 #include <bitstring.h>
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32
  33 #include "../common/common.h"
  34 #include "../ip/ip.h"
  35 #include "ipc_extern.h"
  36
  37 \f
  38 /* types */
  39
  40 typedef struct sds {
  41     struct sds  *next;
  42     Widget      shell;
  43 } save_dialog;
  44
  45 static  save_dialog     *dialogs = NULL;
  46
  47 typedef struct  {
  48     String      name;
  49     Boolean     is_default;
  50     void        (*cb)();
  51 } ButtonData;
  52
  53 \f
  54 #if defined(SelfTest)
  55
  56 typedef struct  {
  57     String      name;
  58     Boolean     *value;
  59     int         flag;
  60 } ToggleData;
  61
  62 static  ToggleData      toggle_data[] = {
  63     { "Ignore Case",            0, VI_SEARCH_IC         },
  64     { "Incremental",            0, VI_SEARCH_INCR       }
  65     { "Literal",                0, VI_SEARCH_LIT        },
  66     { "Wrap End Of File",       0, VI_SEARCH_WR         },
  67 };
  68
  69 #endif
  70
  71 \f
  72 /* globals and constants */
  73
  74 static  String  PatternWidget    = "text";
  75
  76 static void done_func __P((Widget));
  77 static void next_func __P((Widget));
  78 static void prev_func __P((Widget));
  79 static void search __P((Widget, int));
  80
  81 static  ButtonData button_data[] = {
  82     { "Next",           True,   next_func       },
  83     { "Previous",       False,  prev_func       },
  84     { "Cancel",         False,  done_func       }
  85 };
  86
  87 static  String          pattern = NULL;
  88
  89 \f
  90 /* Xt utilities */
  91
  92 #if defined(__STDC__)
  93 static  Widget  get_child_widget( Widget parent, String name )
  94 #else
  95 static  Widget  get_child_widget( parent, name )
  96         Widget  parent;
  97         String  name;
  98 #endif
  99 {
 100     char buffer[1024];
 101
 102     strcpy( buffer, "*" );
 103     strcat( buffer, name );
 104     return XtNameToWidget( parent, buffer );
 105 }
 106
 107
 108 #if defined(__STDC__)
 109 static  String  get_widget_string( Widget w, String resource )
 110 #else
 111 static  String  get_widget_string( w, resource )
 112         Widget  w;
 113         String  resource;
 114 #endif
 115 {
 116     XmString    xmstr;
 117     String      str;
 118
 119     XtVaGetValues( w, resource, &xmstr, 0 );
 120     XmStringGetLtoR( xmstr, XmSTRING_DEFAULT_CHARSET, &str );
 121     XmStringFree( xmstr );
 122
 123     return str;
 124 }
 125
 126 \f
 127 /* sync the global state */
 128
 129 #if defined(__STDC__)
 130 static  void    get_state( Widget w )
 131 #else
 132 static  void    get_state( w )
 133         Widget  w;
 134 #endif
 135 {
 136     int         i;
 137     String      str;
 138     Widget      shell = w;
 139
 140     /* get all the data from the root of the widget tree */
 141     while ( ! XtIsShell(shell) ) shell = XtParent(shell);
 142
 143 #if defined(SelfTest)
 144     /* which flags? */
 145     for (i=0; i<XtNumber(toggle_data); i++) {
 146         if (( w = get_child_widget( shell, toggle_data[i].name )) != NULL ) {
 147             XtVaGetValues( w, XmNset, &toggle_data[i].value, 0 );
 148         }
 149     }
 150 #endif
 151
 152     /* what's the pattern? */
 153     if (( w = get_child_widget( shell, PatternWidget )) != NULL ) {
 154         if ( pattern != NULL ) XtFree( pattern );
 155         pattern = XmTextFieldGetString( w );
 156     }
 157 }
 158
 159 \f
 160 /* Translate the user's actions into nvi commands */
 161 /*
 162  * next_func --
 163  *      Action for next button.
 164  */
 165 static void
 166 next_func(w)
 167         Widget w;
 168 {
 169         search(w, 0);
 170 }
 171
 172 /*
 173  * prev_func --
 174  *      Action for previous button.
 175  */
 176 static void
 177 prev_func(w)
 178         Widget w;
 179 {
 180         search(w, VI_SEARCH_REV);
 181 }
 182
 183 /*
 184  * search --
 185  *      Perform the search.
 186  */
 187 static void
 188 search(w, flags)
 189         Widget w;
 190         int flags;
 191 {
 192     IP_BUF ipb;
 193     int i;
 194
 195     /* get current data from the root of the widget tree? */
 196     if ( w != NULL ) get_state( w );
 197
 198     ipb.str = pattern;
 199     ipb.len = strlen(pattern);
 200
 201 #if defined(SelfTest)
 202     /* initialize the search flags based on the buttons. */
 203     ipb.val1 = flags;
 204     for (i=0; i<XtNumber(toggle_data); i++) {
 205         if (toggle_data[i].value)
 206             ipb.val1 |= toggle_data[i].flag;
 207     }
 208 #endif
 209
 210     ipb.code = VI_C_SEARCH;
 211     __vi_send("1s", &ipb);
 212 }
 213
 214 #if defined(__STDC__)
 215 static  void    done_func( Widget w )
 216 #else
 217 static  void    done_func( w )
 218         Widget  w;
 219 #endif
 220 {
 221     save_dialog *ptr;
 222
 223 #if defined(SelfTest)
 224     puts( XtName(w) );
 225 #endif
 226
 227     while ( ! XtIsShell(w) ) w = XtParent(w);
 228     XtPopdown( w );
 229
 230     /* save it for later */
 231     ptr         = (save_dialog *) malloc( sizeof(save_dialog) );
 232     ptr->next   = dialogs;
 233     ptr->shell  = w;
 234     dialogs     = ptr;
 235 }
 236
 237 \f
 238 /* create a set of push buttons */
 239
 240 #define SpacingRatio    4       /* 3:1 button to spaces */
 241
 242 #if defined(__STDC__)
 243 static  Widget  create_push_buttons( Widget parent,
 244                                      ButtonData *data,
 245                                      int count
 246                                     )
 247 #else
 248 static  Widget  create_push_buttons( parent, data, count )
 249     Widget      parent;
 250     ButtonData  *data;
 251     int         count;
 252 #endif
 253 {
 254     Widget      w, form;
 255     int         pos = 1, base;
 256
 257     base = SpacingRatio*count + 1;
 258     form = XtVaCreateManagedWidget( "buttons",
 259                                     xmFormWidgetClass,
 260                                     parent,
 261                                     XmNleftAttachment,  XmATTACH_FORM,
 262                                     XmNrightAttachment, XmATTACH_FORM,
 263                                     XmNfractionBase,    base,
 264                                     XmNshadowType,      XmSHADOW_ETCHED_IN,
 265                                     XmNshadowThickness, 2,
 266                                     XmNverticalSpacing, 4,
 267                                     0
 268                                     );
 269
 270     while ( count-- > 0 ) {
 271         w = XtVaCreateManagedWidget(data->name,
 272                                     xmPushButtonGadgetClass,
 273                                     form,
 274                                     XmNtopAttachment,   XmATTACH_FORM,
 275                                     XmNbottomAttachment,XmATTACH_FORM,
 276                                     XmNleftAttachment,  XmATTACH_POSITION,
 277                                     XmNleftPosition,    pos,
 278                                     XmNshowAsDefault,   data->is_default,
 279                                     XmNdefaultButtonShadowThickness,    data->is_default,
 280                                     XmNrightAttachment, XmATTACH_POSITION,
 281                                     XmNrightPosition,   pos+SpacingRatio-1,
 282                                     0
 283                                     );
 284         if ( data->is_default )
 285             XtVaSetValues( form, XmNdefaultButton, w, 0 );
 286         XtAddCallback( w, XmNactivateCallback, data->cb, 0 );
 287         pos += SpacingRatio;
 288         data++;
 289     }
 290
 291     return form;
 292 }
 293
 294 \f
 295 /* create a set of check boxes */
 296
 297 #if defined(SelfTest)
 298
 299 #if defined(__STDC__)
 300 static  Widget  create_check_boxes( Widget parent,
 301                                     ToggleData *toggles,
 302                                     int count
 303                                     )
 304 #else
 305 static  Widget  create_check_boxes( parent, toggles, count )
 306         Widget  parent;
 307         ToggleData *toggles;
 308         int     count;
 309 #endif
 310 {
 311     Widget      form;
 312     int         pos = 1, base;
 313
 314     base = SpacingRatio*count +1;
 315     form = XtVaCreateManagedWidget( "toggles",
 316                                     xmFormWidgetClass,
 317                                     parent,
 318                                     XmNleftAttachment,  XmATTACH_FORM,
 319                                     XmNrightAttachment, XmATTACH_FORM,
 320                                     XmNfractionBase,    base,
 321                                     XmNverticalSpacing, 4,
 322                                     0
 323                                     );
 324
 325     while ( count-- > 0 ) {
 326         XtVaCreateManagedWidget(toggles->name,
 327                                 xmToggleButtonWidgetClass,
 328                                 form,
 329                                 XmNtopAttachment,       XmATTACH_FORM,
 330                                 XmNbottomAttachment,    XmATTACH_FORM,
 331                                 XmNleftAttachment,      XmATTACH_POSITION,
 332                                 XmNleftPosition,        pos,
 333                                 XmNrightAttachment,     XmATTACH_POSITION,
 334                                 XmNrightPosition,       pos+SpacingRatio-1,
 335                                 0
 336                                 );
 337         pos += SpacingRatio;
 338         ++toggles;
 339     }
 340
 341     return form;
 342 }
 343
 344 #endif
 345
 346 \f
 347 /* Routines to handle the text field widget */
 348
 349 /* when the user hits 'CR' in a text widget, fire the default pushbutton */
 350 #if defined(__STDC__)
 351 static  void    text_cr( Widget w, void *ptr, void *ptr2 )
 352 #else
 353 static  void    text_cr( w, ptr, ptr2 )
 354         Widget  w;
 355         void    *ptr;
 356         void    *ptr2;
 357 #endif
 358 {
 359     next_func( w );
 360 }
 361
 362
 363 #ifdef notdef
 364 /*
 365  * when the user hits any other character, if we are doing incremental
 366  * search, send the updated string to nvi
 367  *
 368  * XXX
 369  * I don't currently see any way to make this work -- incremental search
 370  * is going to be really nasty.  What makes it worse is that the dialog
 371  * box almost certainly obscured a chunk of the text file, so there's no
 372  * way to use it even if it works.
 373  */
 374 #if defined(__STDC__)
 375 static  void    value_changed( Widget w, void *ptr, void *ptr2 )
 376 #else
 377 static  void    value_changed( w, ptr, ptr2 )
 378         Widget  w;
 379         void    *ptr;
 380         void    *ptr2;
 381 #endif
 382 {
 383     /* get all the data from the root of the widget tree */
 384     get_state( w );
 385
 386     /* send it along? */
 387 #if defined(SelfTest)
 388     if ( incremental_search ) send_command( w );
 389 #else
 390     if ( __vi_incremental_search() ) send_command( w );
 391 #endif
 392 }
 393 #endif /* notdef */
 394
 395 \f
 396 /* Draw and display a dialog the describes nvi search capability */
 397
 398 #if defined(__STDC__)
 399 static  Widget  create_search_dialog( Widget parent, String title )
 400 #else
 401 static  Widget  create_search_dialog( parent, title )
 402         Widget  parent;
 403         String  title;
 404 #endif
 405 {
 406     Widget      box, form, label, text, checks, buttons, form2;
 407     save_dialog *ptr;
 408
 409     /* use an existing one? */
 410     if ( dialogs != NULL ) {
 411         box = dialogs->shell;
 412         ptr = dialogs->next;
 413         free( dialogs );
 414         dialogs = ptr;
 415         return box;
 416     }
 417
 418     box = XtVaCreatePopupShell( title,
 419                                 xmDialogShellWidgetClass,
 420                                 parent,
 421                                 XmNtitle,               title,
 422                                 XmNallowShellResize,    False,
 423                                 0
 424                                 );
 425
 426     form = XtVaCreateWidget( "form",
 427                                 xmFormWidgetClass,
 428                                 box,
 429                                 XmNverticalSpacing,     4,
 430                                 XmNhorizontalSpacing,   4,
 431                                 0
 432                                 );
 433
 434     form2 = XtVaCreateManagedWidget( "form",
 435                                 xmFormWidgetClass,
 436                                 form,
 437                                 XmNtopAttachment,       XmATTACH_FORM,
 438                                 XmNleftAttachment,      XmATTACH_FORM,
 439                                 XmNrightAttachment,     XmATTACH_FORM,
 440                                 0
 441                                 );
 442
 443     label = XtVaCreateManagedWidget( "Pattern:",
 444                                     xmLabelWidgetClass,
 445                                     form2,
 446                                     XmNtopAttachment,   XmATTACH_FORM,
 447                                     XmNbottomAttachment,XmATTACH_FORM,
 448                                     XmNleftAttachment,  XmATTACH_FORM,
 449                                     0
 450                                     );
 451
 452     text = XtVaCreateManagedWidget( PatternWidget,
 453                                     xmTextFieldWidgetClass,
 454                                     form2,
 455                                     XmNtopAttachment,   XmATTACH_FORM,
 456                                     XmNbottomAttachment,XmATTACH_FORM,
 457                                     XmNleftAttachment,  XmATTACH_WIDGET,
 458                                     XmNleftWidget,      label,
 459                                     XmNrightAttachment, XmATTACH_FORM,
 460                                     0
 461                                     );
 462 #ifdef notdef
 463     XtAddCallback( text, XmNvalueChangedCallback, value_changed, 0 );
 464 #endif
 465     XtAddCallback( text, XmNactivateCallback, text_cr, 0 );
 466
 467     buttons = create_push_buttons( form, button_data, XtNumber(button_data) );
 468     XtVaSetValues( buttons,
 469                    XmNbottomAttachment, XmATTACH_FORM,
 470                    0
 471                    );
 472
 473 #if defined(SelfTest)
 474     checks = create_check_boxes( form, toggle_data, XtNumber(toggle_data) );
 475 #else
 476     checks = (Widget) __vi_create_search_toggles( form );
 477 #endif
 478     XtVaSetValues( checks,
 479                    XmNtopAttachment,    XmATTACH_WIDGET,
 480                    XmNtopWidget,        form2,
 481                    XmNbottomAttachment, XmATTACH_WIDGET,
 482                    XmNbottomWidget,     buttons,
 483                    0
 484                    );
 485
 486     XtManageChild( form );
 487     return box;
 488 }
 489
 490 \f
 491 /* Module interface to the outside world
 492  *
 493  *      xip_show_search_dialog( parent, title )
 494  *      pops up a search dialog
 495  *
 496  *      xip_next_search()
 497  *      simulates a 'next' assuming that a search has been done
 498  */
 499
 500 #if defined(__STDC__)
 501 void    __vi_show_search_dialog( Widget parent, String title )
 502 #else
 503 void    __vi_show_search_dialog( parent, data, cbs )
 504 Widget  parent;
 505 String  title;
 506 #endif
 507 {
 508     Widget      db = create_search_dialog( parent, title );
 509     Dimension   height;
 510
 511     /* we can handle getting taller and wider or narrower, but not shorter */
 512     XtVaGetValues( db, XmNheight, &height, 0 );
 513     XtVaSetValues( db, XmNmaxHeight, height, XmNminHeight, height, 0 );
 514
 515     /* post the dialog */
 516     XtPopup( db, XtGrabNone );
 517
 518     /* request initial focus to the text widget */
 519     XmProcessTraversal( get_child_widget( db, PatternWidget ),
 520                         XmTRAVERSE_CURRENT
 521                         );
 522 }
 523
 524
 525 /*
 526  * __vi_search --
 527  *
 528  * PUBLIC: void __vi_search __P((void));
 529  */
 530 void
 531 __vi_search()
 532 {
 533     next_func( NULL );
 534 }
 535
 536 \f
 537 #if defined(SelfTest)
 538
 539 #if defined(__STDC__)
 540 static void show_search( Widget w, XtPointer data, XtPointer cbs )
 541 #else
 542 static void show_search( w, data, cbs )
 543 Widget w;
 544 XtPointer       data;
 545 XtPointer       cbs;
 546 #endif
 547 {
 548     __vi_show_search_dialog( data, "Search" );
 549 }
 550
 551 main( int argc, char *argv[] )
 552 {
 553     XtAppContext        ctx;
 554     Widget              top_level, rc, button;
 555     extern              exit();
 556
 557     /* create a top-level shell for the window manager */
 558     top_level = XtVaAppInitialize( &ctx,
 559                                    argv[0],
 560                                    NULL, 0,     /* options */
 561                                    (ArgcType) &argc,
 562                                    argv,        /* might get modified */
 563                                    NULL,
 564                                    NULL
 565                                    );
 566
 567     rc = XtVaCreateManagedWidget( "rc",
 568                                   xmRowColumnWidgetClass,
 569                                   top_level,
 570                                   0
 571                                   );
 572
 573     button = XtVaCreateManagedWidget( "Pop up search dialog",
 574                                       xmPushButtonGadgetClass,
 575                                       rc,
 576                                       0
 577                                       );
 578     XtAddCallback( button, XmNactivateCallback, show_search, rc );
 579
 580     button = XtVaCreateManagedWidget( "Quit",
 581                                       xmPushButtonGadgetClass,
 582                                       rc,
 583                                       0
 584                                       );
 585     XtAddCallback( button, XmNactivateCallback, exit, 0 );
 586
 587     XtRealizeWidget(top_level);
 588     XtAppMainLoop(ctx);
 589 }
 590
 591 #endif