motif_l/m_tags.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_tags.c,v 8.1 1996/12/11 19:34:33 bostic Exp $ (Berkeley) $Date: 1996/12/11 19:34:33 $";
  14 #endif /* not lint */
  15
  16 /* This module implements a dialog for navigating the tag stack
  17  *
  18  * Interface:
  19  * void __vi_show_tags_dialog( Widget parent, String title )
  20  *      Pops up a Tags dialog.  We allow one per session.  It is not modal.
  21  *
  22  * void __vi_push_tag( String text )
  23  * void __vi_pop_tag()
  24  * void __vi_clear_tag()
  25  *      When core changes the tag stack we will change our representation
  26  *      of it.  When this dialog appears, we need core to send a slew of
  27  *      messages so we can display the current tag stack.
  28  *
  29  * void __vi_set_tag_text( String text )
  30  *      the text field in the dialog is set to the string.  ideally,
  31  *      this should be kept in sync with the word following the caret
  32  *      in the current editor window
  33  *
  34  * To Do:
  35  *      The push-buttons should activate and deactivate according to
  36  *      the state of the tag stack and the text field.
  37  *
  38  *      Need to send VI commands rather than strings
  39  *
  40  *      Need IPO command to start/stop asking for the current tag stack
  41  */
  42
  43 \f
  44 /* context */
  45 #include <X11/X.h>
  46 #include <X11/Intrinsic.h>
  47 #include <Xm/DialogS.h>
  48 #include <Xm/Form.h>
  49 #include <Xm/LabelG.h>
  50 #include <Xm/TextF.h>
  51 #include <Xm/List.h>
  52 #include <Xm/RowColumn.h>
  53 #include <Xm/PushBG.h>
  54
  55 #if ! defined(SelfTest)
  56 #include <stdio.h>
  57 #include <bitstring.h>
  58 #include <sys/types.h>
  59 #include <sys/queue.h>
  60 #include <string.h>
  61 #include "../common/common.h"
  62 #include "../ip_vi/ip.h"
  63 #endif
  64
  65 \f
  66 /* globals */
  67
  68 static  Widget  db_tabs = NULL,
  69                 db_text,
  70                 db_list;
  71
  72 static  Boolean active = False;
  73
  74 typedef struct  {
  75     String      name;
  76     Boolean     is_default;
  77     void        (*cb)();
  78 } ButtonData;
  79
  80 static  void go_to_tag();
  81 static  void split_to_tag();
  82 static  void pop_tag();
  83
  84 static  ButtonData button_data[] = {
  85     { "Go To Tag",      True,   go_to_tag       },
  86     { "Split To Tag",   False,  split_to_tag    },
  87     { "Pop Tag",        False,  pop_tag         },
  88 };
  89
  90 \f
  91 /* manage the tags stack list */
  92
  93 void    __vi_pop_tag()
  94 {
  95     if ( ! active ) return;
  96
  97     XmListDeletePos( db_list, 1 );
  98 }
  99
 100
 101 void    __vi_clear_tag()
 102 {
 103     if ( ! active ) return;
 104
 105     XmListDeleteAllItems( db_list );
 106 }
 107
 108
 109 void    __vi_push_tag( text )
 110 String  text;
 111 {
 112     XmString    str;
 113
 114     if ( ! active ) return;
 115
 116     str = XmStringCreateSimple( text );
 117     XmListAddItem( db_list, str, 1 );
 118     XmStringFree( str );
 119 }
 120
 121 \f
 122 /* create a set of push buttons */
 123
 124 #define SpacingRatio    4       /* 3:1 button to spaces */
 125
 126 #if defined(__STDC__)
 127 static  Widget  create_push_buttons( Widget parent,
 128                                      ButtonData *data,
 129                                      int count
 130                                     )
 131 #else
 132 static  Widget  create_push_buttons( parent, data, count )
 133     Widget      parent;
 134     ButtonData  *data;
 135     int         count;
 136 #endif
 137 {
 138     Widget      w, form;
 139     int         pos = 1, base;
 140
 141     base = SpacingRatio*count + 1;
 142     form = XtVaCreateManagedWidget( "buttons",
 143                                     xmFormWidgetClass,
 144                                     parent,
 145                                     XmNleftAttachment,  XmATTACH_FORM,
 146                                     XmNrightAttachment, XmATTACH_FORM,
 147                                     XmNfractionBase,    base,
 148                                     XmNshadowType,      XmSHADOW_ETCHED_IN,
 149                                     XmNshadowThickness, 2,
 150                                     XmNverticalSpacing, 4,
 151                                     0
 152                                     );
 153
 154     while ( count-- > 0 ) {
 155         w = XtVaCreateManagedWidget(data->name,
 156                                     xmPushButtonGadgetClass,
 157                                     form,
 158                                     XmNtopAttachment,   XmATTACH_FORM,
 159                                     XmNbottomAttachment,XmATTACH_FORM,
 160                                     XmNleftAttachment,  XmATTACH_POSITION,
 161                                     XmNleftPosition,    pos,
 162                                     XmNshowAsDefault,   data->is_default,
 163                                     XmNdefaultButtonShadowThickness,    data->is_default,
 164                                     XmNrightAttachment, XmATTACH_POSITION,
 165                                     XmNrightPosition,   pos+SpacingRatio-1,
 166                                     0
 167                                     );
 168         if ( data->is_default )
 169             XtVaSetValues( form, XmNdefaultButton, w, 0 );
 170         XtAddCallback( w, XmNactivateCallback, data->cb, 0 );
 171         pos += SpacingRatio;
 172         data++;
 173     }
 174
 175     return form;
 176 }
 177
 178 \f
 179 /* callbacks */
 180
 181 void cancel_cb()
 182 {
 183 #if defined(SelfTest)
 184     puts( "cancelled" );
 185 #endif
 186     active = False;
 187 }
 188
 189
 190 static  void            set_text_field( w, ptr, cbs )
 191 Widget                  w;
 192 XtPointer               ptr;
 193 XmListCallbackStruct    *cbs;
 194 {
 195     String str;
 196
 197     XmStringGetLtoR( cbs->item, XmSTRING_DEFAULT_CHARSET, &str );
 198     XmTextFieldSetString( db_text, str );
 199     XtFree( str );
 200 }
 201
 202
 203 void    __vi_set_tag_text( text )
 204 String  text;
 205 {
 206     if ( active ) XmTextFieldSetString( db_text, text );
 207 }
 208
 209
 210 static  void destroyed()
 211 {
 212 #if defined(SelfTest)
 213     puts( "destroyed" );
 214 #endif
 215
 216     /* some window managers destroy us upon popdown */
 217     db_tabs = NULL;
 218     active  = False;
 219 }
 220
 221
 222 #if defined(__STDC__)
 223 static  void    pop_tag( Widget w )
 224 #else
 225 static  void    pop_tag( w )
 226         Widget  w;
 227 #endif
 228 {
 229     static String buffer = ":tagpop";
 230
 231 #if defined(SelfTest)
 232     printf( "sending command <<%s>>\n", buffer );
 233     __vi_pop_tag();
 234 #else
 235     __vi_send_command_string( buffer );
 236 #endif
 237 }
 238
 239
 240 #if defined(__STDC__)
 241 static  void    split_to_tag( Widget w )
 242 #else
 243 static  void    split_to_tag( w )
 244         Widget  w;
 245 #endif
 246 {
 247     IP_BUF      ipb;
 248     String      str;
 249
 250     str = XmTextFieldGetString( db_text );
 251
 252 #if defined(SelfTest)
 253     printf( "sending command <<:Tag %s>>\n", str );
 254 #else
 255     /*
 256      * XXX
 257      * This is REALLY sleazy.  We pass the nul along with the
 258      * string so that the core editor doesn't have to copy the
 259      * string to get a nul termination.  This should be fixed
 260      * as part of making the editor fully 8-bit clean.
 261      */
 262     ipb.code = VI_TAGSPLIT;
 263     ipb.str = str;
 264     ipb.len = strlen(str) + 1;
 265     __vi_send("s", &ipb);
 266 #endif
 267
 268     XtFree( str );
 269 }
 270
 271
 272 #if defined(__STDC__)
 273 static  void    go_to_tag( Widget w )
 274 #else
 275 static  void    go_to_tag( w )
 276         Widget  w;
 277 #endif
 278 {
 279     IP_BUF      ipb;
 280     String      str;
 281
 282     str = XmTextFieldGetString( db_text );
 283
 284 #if defined(SelfTest)
 285     printf( "sending command <<:tag %s>>\n", str );
 286 #else
 287     /*
 288      * XXX
 289      * This is REALLY sleazy.  We pass the nul along with the
 290      * string so that the core editor doesn't have to copy the
 291      * string to get a nul termination.  This should be fixed
 292      * as part of making the editor fully 8-bit clean.
 293      */
 294     ipb.code = VI_TAGAS;
 295     ipb.str = str;
 296     ipb.len = strlen(str) + 1;
 297     __vi_send("s", &ipb);
 298 #endif
 299
 300     XtFree( str );
 301 }
 302
 303
 304 \f
 305 /* Draw and display a dialog the describes nvi options */
 306
 307 #if defined(__STDC__)
 308 static  Widget  create_tags_dialog( Widget parent, String title )
 309 #else
 310 static  Widget  create_tags_dialog( parent, title )
 311         Widget  parent;
 312         String  title;
 313 #endif
 314 {
 315     Widget      box, form, form2, form3, buttons;
 316
 317     /* already built? */
 318     if ( db_tabs != NULL ) return db_tabs;
 319
 320     box = XtVaCreatePopupShell( title,
 321                                 xmDialogShellWidgetClass,
 322                                 parent,
 323                                 XmNtitle,               title,
 324                                 XmNallowShellResize,    False,
 325                                 0
 326                                 );
 327     XtAddCallback( box, XmNpopdownCallback, cancel_cb, 0 );
 328     XtAddCallback( box, XmNdestroyCallback, destroyed, 0 );
 329
 330     form = XtVaCreateWidget( "Tags",
 331                              xmFormWidgetClass,
 332                              box,
 333                              0
 334                              );
 335
 336     buttons = create_push_buttons( form, button_data, XtNumber(button_data) );
 337     XtVaSetValues( buttons,
 338                    XmNbottomAttachment, XmATTACH_FORM,
 339                    0
 340                    );
 341
 342     form3 = XtVaCreateWidget( "form",
 343                               xmFormWidgetClass,
 344                               form,
 345                               XmNleftAttachment,        XmATTACH_FORM,
 346                               XmNrightAttachment,       XmATTACH_FORM,
 347                               XmNbottomAttachment,      XmATTACH_WIDGET,
 348                               XmNbottomWidget,          buttons,
 349                               0
 350                               );
 351
 352     form2 = XtVaCreateWidget( "form",
 353                               xmFormWidgetClass,
 354                               form,
 355                               XmNtopAttachment,         XmATTACH_FORM,
 356                               XmNleftAttachment,        XmATTACH_FORM,
 357                               XmNrightAttachment,       XmATTACH_FORM,
 358                               XmNbottomAttachment,      XmATTACH_WIDGET,
 359                               XmNbottomWidget,          form3,
 360                               0
 361                               );
 362
 363     db_list = XtVaCreateManagedWidget( "list",
 364                                 xmListWidgetClass,
 365                                 form2,
 366                                 XmNtopAttachment,       XmATTACH_FORM,
 367                                 XmNleftAttachment,      XmATTACH_POSITION,
 368                                 XmNleftPosition,        20,
 369                                 XmNrightAttachment,     XmATTACH_FORM,
 370                                 XmNbottomAttachment,    XmATTACH_FORM,
 371 #if defined(SelfTest)
 372                                 XmNvisibleItemCount,    5,
 373 #endif
 374                                 XmNselectionPolicy,     XmSINGLE_SELECT,
 375                                 0
 376                                 );
 377     XtAddCallback( db_list, XmNsingleSelectionCallback, set_text_field, 0 );
 378     XtAddCallback( db_list, XmNdefaultActionCallback, go_to_tag, 0 );
 379
 380     XtVaCreateManagedWidget( "Tag Stack",
 381                              xmLabelGadgetClass,
 382                              form2,
 383                              XmNtopAttachment,          XmATTACH_FORM,
 384                              XmNbottomAttachment,       XmATTACH_FORM,
 385                              XmNleftAttachment,         XmATTACH_FORM,
 386                              XmNrightAttachment,        XmATTACH_POSITION,
 387                              XmNrightPosition,          20,
 388                              XmNalignment,              XmALIGNMENT_END,
 389                              0
 390                              );
 391
 392     XtVaCreateManagedWidget( "Tag",
 393                              xmLabelGadgetClass,
 394                              form3,
 395                              XmNtopAttachment,          XmATTACH_FORM,
 396                              XmNbottomAttachment,       XmATTACH_FORM,
 397                              XmNleftAttachment,         XmATTACH_FORM,
 398                              XmNrightAttachment,        XmATTACH_POSITION,
 399                              XmNrightPosition,          20,
 400                              XmNalignment,              XmALIGNMENT_END,
 401                              0
 402                              );
 403
 404     db_text = XtVaCreateManagedWidget( "text",
 405                             xmTextFieldWidgetClass,
 406                             form3,
 407                             XmNtopAttachment,           XmATTACH_FORM,
 408                             XmNbottomAttachment,        XmATTACH_FORM,
 409                             XmNrightAttachment,         XmATTACH_FORM,
 410                             XmNleftAttachment,          XmATTACH_POSITION,
 411                             XmNleftPosition,            20,
 412                             0
 413                             );
 414     XtAddCallback( db_text, XmNactivateCallback, go_to_tag, 0 );
 415
 416     /* keep this global, we might destroy it later */
 417     db_tabs = form;
 418
 419     /* done */
 420     XtManageChild( form3 );
 421     XtManageChild( form2 );
 422     return form;
 423 }
 424
 425
 426 \f
 427 /* module entry point
 428  *      __vi_show_tags_dialog( parent, title )
 429  */
 430
 431 #if defined(__STDC__)
 432 void    __vi_show_tags_dialog( Widget parent, String title )
 433 #else
 434 void    __vi_show_tags_dialog( parent, title )
 435 Widget  parent;
 436 String  title;
 437 #endif
 438 {
 439     Widget      db = create_tags_dialog( parent, title ),
 440                 shell = XtParent(db);
 441
 442     XtManageChild( db );
 443
 444     /* get the current window's text */
 445     __vi_set_tag_text( (String) __vi_get_word_at_caret( NULL ) );
 446
 447     /* TODO:  ask vi core for the current tag stack now */
 448
 449     /* leave this guy up (or just raise it) */
 450     XtPopup( shell, XtGrabNone );
 451     XMapRaised( XtDisplay( shell ), XtWindow( shell ) );
 452
 453     active = True;
 454 }
 455
 456
 457 \f
 458 #if defined(SelfTest)
 459
 460 #if XtSpecificationRelease == 4
 461 #define ArgcType        Cardinal *
 462 #else
 463 #define ArgcType        int *
 464 #endif
 465
 466 static  void    add_a_tag( Widget w )
 467 {
 468     static      String  tags[] = { "first", "second", "this is the third" };
 469     static      int     i = 0;
 470
 471     __vi_push_tag( tags[i] );
 472     i = (i+1) % XtNumber(tags);
 473 }
 474
 475 #if defined(__STDC__)
 476 static void show_tags( Widget w, XtPointer data, XtPointer cbs )
 477 #else
 478 static void show_tags( w, data, cbs )
 479 Widget w;
 480 XtPointer       data;
 481 XtPointer       cbs;
 482 #endif
 483 {
 484     __vi_show_tags_dialog( data, "Tags" );
 485 }
 486
 487 main( int argc, char *argv[] )
 488 {
 489     XtAppContext        ctx;
 490     Widget              top_level, rc, button;
 491     extern              exit();
 492
 493     /* create a top-level shell for the window manager */
 494     top_level = XtVaAppInitialize( &ctx,
 495                                    argv[0],
 496                                    NULL, 0,     /* options */
 497                                    (ArgcType) &argc,
 498                                    argv,        /* might get modified */
 499                                    NULL,
 500                                    NULL
 501                                    );
 502
 503     rc = XtVaCreateManagedWidget( "rc",
 504                                   xmRowColumnWidgetClass,
 505                                   top_level,
 506                                   0
 507                                   );
 508
 509     button = XtVaCreateManagedWidget( "Pop up tags dialog",
 510                                       xmPushButtonGadgetClass,
 511                                       rc,
 512                                       0
 513                                       );
 514     XtAddCallback( button, XmNactivateCallback, show_tags, rc );
 515
 516     button = XtVaCreateManagedWidget( "Add a tag",
 517                                       xmPushButtonGadgetClass,
 518                                       rc,
 519                                       0
 520                                       );
 521     XtAddCallback( button, XmNactivateCallback, add_a_tag, rc );
 522
 523     button = XtVaCreateManagedWidget( "Quit",
 524                                       xmPushButtonGadgetClass,
 525                                       rc,
 526                                       0
 527                                       );
 528     XtAddCallback( button, XmNactivateCallback, exit, 0 );
 529
 530     XtRealizeWidget(top_level);
 531     XtAppMainLoop(ctx);
 532 }
 533 #endif