rom/filesys/console_handler/completion.c

   1 /*
   2     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6     Lang: english
   7 */
   8
   9 #include <exec/memory.h>
  10 #include <dos/dos.h>
  11 #include <utility/utility.h>
  12 #include <intuition/intuition.h>
  13 #include <graphics/rastport.h>
  14 #include <libraries/gadtools.h>
  15 #include <libraries/asl.h>
  16 #include <devices/rawkeycodes.h>
  17
  18 #include <proto/exec.h>
  19 #include <proto/dos.h>
  20 #include <proto/intuition.h>
  21 #include <proto/graphics.h>
  22 #include <proto/utility.h>
  23 #include <proto/alib.h>
  24 #include <proto/gadtools.h>
  25 #include <proto/asl.h>
  26 #include "con_handler_intern.h"
  27 #include "support.h"
  28 #include "completion.h"
  29
  30 #include <string.h>
  31 #include <stdlib.h>
  32
  33 #define DEBUG 0
  34 #include <aros/debug.h>
  35
  36 /****************************************************************************************/
  37
  38 struct matchnode
  39 {
  40     struct Node     node;
  41     UBYTE           name[1];
  42 };
  43
  44 /****************************************************************************************/
  45
  46 struct completioninfo
  47 {
  48     struct filehandle  *fh;
  49     struct List         matchlist;
  50     APTR                pool;
  51     WORD                nummatchnodes;
  52     WORD                wordstart;
  53     BOOL                wordquoted;
  54     UBYTE               filepart[256];
  55     UBYTE               dirpart[256];
  56     UBYTE               pattern[256*2+3];
  57     UBYTE               match[256];
  58 };
  59
  60 /****************************************************************************************/
  61
  62 /* Delay opening of the gadtools.library to the first time InitCompletion is called */
  63
  64 static struct completioninfo *InitCompletion(struct filehandle *fh)
  65 {
  66     struct completioninfo *ci = NULL;
  67     APTR                   pool;
  68
  69     if (fh->gtbase == NULL)
  70         fh->gtbase = OpenLibrary("gadtools.library", 39);
  71
  72     if (fh->gfxbase == NULL)
  73         fh->gfxbase = (APTR)OpenLibrary("graphics.library", 39);
  74
  75     if (fh->lastwritetask && GadToolsBase)
  76     if (fh->lastwritetask->tc_Node.ln_Type == NT_PROCESS)
  77     {
  78         if ((pool = CreatePool(MEMF_CLEAR, 1024, 1024)))
  79         {
  80             BOOL ok = FALSE;
  81
  82             if ((ci = (struct completioninfo *)AllocPooled(pool, sizeof(*ci))))
  83             {
  84                 ci->pool = pool;
  85                 ci->fh = fh;
  86                 NewList(&ci->matchlist);
  87
  88                 ok = TRUE;
  89             }
  90
  91             if (!ok)
  92             {
  93                 DeletePool(pool);
  94                 ci = NULL;
  95             }
  96         }
  97     }
  98
  99     return ci;
 100 }
 101
 102 /****************************************************************************************/
 103
 104 static void CleanupCompletion(struct completioninfo *ci)
 105 {
 106     DeletePool(ci->pool);
 107 }
 108
 109 /****************************************************************************************/
 110
 111 static void PrepareCompletion(struct filehandle *fh, struct completioninfo *ci)
 112 {
 113     WORD i;
 114     BOOL in_quotes = FALSE;
 115
 116     /* Find word start */
 117
 118     ci->wordstart = i = ci->fh->inputstart;
 119
 120     while(i != ci->fh->inputpos)
 121     {
 122         switch(ci->fh->inputbuffer[i++])
 123         {
 124             case '"':
 125                 in_quotes = !in_quotes;
 126                 if (in_quotes) ci->wordstart = i;
 127                 break;
 128
 129             case ' ':
 130                 if (!in_quotes) ci->wordstart = i;
 131                 break;
 132         }
 133     }
 134
 135     strncpy(ci->dirpart,
 136             &ci->fh->inputbuffer[ci->wordstart],
 137             ci->fh->inputpos - ci->wordstart);
 138     strcpy(ci->filepart, FilePart(ci->dirpart));
 139
 140     *(PathPart(ci->dirpart)) = '\0';
 141
 142     ci->wordquoted = in_quotes;
 143
 144     D(bug("PrepareCompletion: dirpart = \"%s\"  filepart = \"%s\"\n", ci->dirpart, ci->filepart));
 145 }
 146
 147 /****************************************************************************************/
 148
 149 static void AddQuotes(struct completioninfo *ci, STRPTR s, LONG s_size)
 150 {
 151     LONG len = strlen(s);
 152
 153     if (!ci->wordquoted)
 154     {
 155         if (len < s_size - 1)
 156         memmove(s + 1, s, len + 1);
 157         s[0] = '"';
 158     }
 159     else
 160     {
 161         len--;
 162     }
 163
 164     if (len < s_size - 3)
 165     {
 166         if ((s[len] != '/') && (s[len] != ':'))
 167         {
 168             s[len + 1] = '"';
 169             s[len + 2] = '\0';
 170         }
 171     }
 172 }
 173
 174 /****************************************************************************************/
 175
 176 static void InsertIntoConBuffer(struct completioninfo *ci, STRPTR s)
 177 {
 178     WORD i = ci->fh->conbufferpos;
 179
 180     /* Lame code, but speed is no issue here */
 181     while((ci->fh->conbuffersize < CONSOLEBUFFER_SIZE) && *s)
 182     {
 183         memmove(&ci->fh->consolebuffer[i + 1],
 184                 &ci->fh->consolebuffer[i],
 185                 ci->fh->conbuffersize - i);
 186
 187         ci->fh->consolebuffer[i++] = *s++;
 188         ci->fh->conbuffersize++;
 189     }
 190 }
 191
 192 /****************************************************************************************/
 193
 194 static void DoFileReq(struct filehandle *fh, struct completioninfo *ci)
 195 {
 196     struct Library *AslBase;
 197     BPTR            lock, olddir;
 198
 199     if ((lock = DupLock(((struct Process *)ci->fh->lastwritetask)->pr_CurrentDir)))
 200     {
 201         olddir = CurrentDir(lock);
 202
 203         if ((AslBase = OpenLibrary("asl.library", 36)))
 204         {
 205             struct FileRequester *fr;
 206             struct TagItem tags[] =
 207             {
 208                 {ASLFR_Window        , (IPTR)ci->fh->window },
 209                 {ASLFR_DoPatterns    , (IPTR)TRUE           },
 210                 {ASLFR_InitialPattern, (IPTR)"~(#?.info)"   },
 211                 {TAG_DONE                                   }
 212             };
 213
 214             if ((fr = AllocAslRequest(ASL_FileRequest, tags)))
 215             {
 216                 if (AslRequest(fr, NULL))
 217                 {
 218                     UBYTE c;
 219
 220                     strcpy(ci->match, fr->fr_Drawer);
 221                     AddPart(ci->match, fr->fr_File, sizeof(ci->match));
 222
 223                     if (ci->match[0])
 224                     {
 225                         if (strchr(ci->match, ' ')) AddQuotes(ci, ci->match, sizeof(ci->match));
 226
 227                         c = ci->match[strlen(ci->match) - 1];
 228                         if ((c != '/') && (c != ':'))
 229                         {
 230                             strncat(ci->match, " ", sizeof(ci->match));
 231                         }
 232
 233                         InsertIntoConBuffer(ci, ci->match);
 234                     }
 235
 236                 }
 237                 FreeAslRequest(fr);
 238             }
 239
 240             CloseLibrary(AslBase);
 241
 242         } /* if ((AslBase = OpenLibrary("asl.library", 36))) */
 243
 244         CurrentDir(olddir);
 245         UnLock(lock);
 246     }
 247 }
 248
 249 /****************************************************************************************/
 250
 251 static BOOL PreparePattern(struct filehandle *fh, struct completioninfo *ci)
 252 {
 253     WORD parsecode;
 254
 255     parsecode = ParsePatternNoCase(ci->filepart, ci->pattern, sizeof(ci->pattern));
 256     if (parsecode != -1)
 257     {
 258         if (parsecode == 0)
 259         {
 260             strncat(ci->filepart, "~(#?.info)", sizeof(ci->filepart));
 261             parsecode = ParsePatternNoCase(ci->filepart, ci->pattern, sizeof(ci->pattern));
 262         }
 263     }
 264
 265     return (parsecode == 1);
 266
 267 }
 268
 269 /****************************************************************************************/
 270
 271 static void AddMatchNode(struct filehandle *fh, struct completioninfo *ci,
 272                          STRPTR name, WORD type)
 273 {
 274     struct matchnode    *mn;
 275     struct Node         *prev, *check;
 276     WORD                 size;
 277     BOOL                 exists = FALSE;
 278
 279     size = strlen(name) + 1 + sizeof(struct matchnode) + ((type > 0) ? 1 : 0);
 280
 281     if ((mn = AllocPooled(ci->pool, size)))
 282     {
 283         strcpy(mn->name, name);
 284         mn->node.ln_Name = mn->name;
 285
 286         if (type == 1) strcat(mn->name, "/");
 287         if (type == 2) strcat(mn->name, ":");
 288
 289         /* Sort into matchlist */
 290
 291         prev = NULL;
 292         ForeachNode(&ci->matchlist, check)
 293         {
 294             WORD match;
 295
 296             match = Stricmp(mn->name, ((struct matchnode *)check)->name);
 297             if (match < 0) break;
 298             if (match == 0)
 299             {
 300                 exists = TRUE;
 301                 break;
 302             }
 303
 304             prev = check;
 305         }
 306
 307         if (!exists)
 308         {
 309             Insert(&ci->matchlist, (struct Node *)mn, prev);
 310             ci->nummatchnodes++;
 311         }
 312         else
 313         {
 314             FreePooled(ci->pool, mn, size);
 315         }
 316     }
 317 }
 318
 319 /****************************************************************************************/
 320
 321 static void ScanDir(struct filehandle *fh, struct completioninfo *ci)
 322 {
 323     struct FileInfoBlock *fib;
 324     BPTR                  lock;
 325
 326     if ((fib = AllocDosObject(DOS_FIB, 0)))
 327     {
 328         if ((lock = Lock(ci->dirpart, SHARED_LOCK)))
 329         {
 330             if (Examine(lock, fib))
 331             {
 332                 while(ExNext(lock, fib))
 333                 {
 334                     if (MatchPatternNoCase(ci->pattern, fib->fib_FileName))
 335                     {
 336                         BOOL isdir = (fib->fib_DirEntryType > 0);
 337
 338                         AddMatchNode(fh, ci, fib->fib_FileName, (isdir ? 1 : 0));
 339                     }
 340                 }
 341             }
 342
 343             UnLock(lock);
 344         }
 345
 346         FreeDosObject(DOS_FIB, fib);
 347     }
 348 }
 349
 350 /****************************************************************************************/
 351
 352
 353 static void ScanVol(struct filehandle *fh, struct completioninfo *ci)
 354 {
 355     struct DosList *dlist;
 356
 357     dlist = LockDosList(LDF_READ | LDF_VOLUMES | LDF_DEVICES | LDF_ASSIGNS);
 358
 359     while ((dlist = NextDosEntry(dlist, LDF_VOLUMES | LDF_ASSIGNS | LDF_DEVICES)) != NULL)
 360     {
 361         STRPTR devname = AROS_BSTR_ADDR(dlist->dol_Name);
 362
 363         if (MatchPatternNoCase(ci->pattern, devname))
 364         {
 365             AddMatchNode(fh, ci, devname, 2);
 366
 367         }
 368     }
 369     UnLockDosList(LDF_READ | LDF_VOLUMES | LDF_DEVICES | LDF_ASSIGNS);
 370 }
 371
 372 static void DoScan(struct filehandle *fh, struct completioninfo *ci)
 373 {
 374     BPTR            lock, olddir;
 375
 376     if ((lock = DupLock(((struct Process *)ci->fh->lastwritetask)->pr_CurrentDir)))
 377     {
 378         olddir = CurrentDir(lock);
 379
 380         if (ci->dirpart[0] == 0) ScanVol(fh, ci);
 381         ScanDir(fh, ci);
 382
 383         CurrentDir(olddir);
 384         UnLock(lock);
 385     }
 386 }
 387
 388 /****************************************************************************************/
 389
 390 #define BUTTON_EXTRA_WIDTH      16
 391 #define BUTTON_EXTRA_HEIGHT     6
 392 #define BORDER_X                4
 393 #define BORDER_Y                4
 394 #define BUTTON_SPACING_X        8
 395 #define LV_BUTTON_SPACING_Y     4
 396 #define LV_EXTRA_HEIGHT         4
 397
 398 #define ID_LISTVIEW 1
 399 #define ID_OK       2
 400 #define ID_CANCEL   3
 401
 402 /****************************************************************************************/
 403
 404 static BOOL DoChooseReq(struct filehandle *fh, struct completioninfo *ci)
 405 {
 406     static const char oktext[] = "Ok";
 407     static const char canceltext[] = "Cancel";
 408     static const char titletext[] = "Select filename";
 409
 410     struct RastPort     temprp;
 411     struct DrawInfo     *dri;
 412     struct Window       *win;
 413     struct Gadget       *gadlist, *gad, *lvgad;
 414     struct NewGadget    ng;
 415     APTR                vi;
 416     WORD                i, buttonwidth, buttonheight, visible_lv_lines;
 417     WORD                winwidth, winheight, winleft, wintop;
 418     LONG                sec, micro, secold, microold;
 419     BOOL                retval = FALSE;
 420
 421     if ((dri = GetScreenDrawInfo(ci->fh->window->WScreen)))
 422     {
 423         if ((vi = GetVisualInfoA(ci->fh->window->WScreen, NULL)))
 424         {
 425             InitRastPort(&temprp);
 426             SetFont(&temprp, dri->dri_Font);
 427
 428             buttonwidth = TextLength(&temprp, oktext, strlen(oktext));
 429             i = TextLength(&temprp, canceltext, strlen(canceltext));
 430             buttonwidth = (buttonwidth > i) ? buttonwidth : i;
 431             buttonwidth += BUTTON_EXTRA_WIDTH;
 432
 433             buttonheight = dri->dri_Font->tf_YSize + BUTTON_EXTRA_HEIGHT;
 434
 435             i = ci->nummatchnodes > 15 ? 15 : ci->nummatchnodes;
 436             if (i < 4) i = 4;
 437
 438             winheight = i * (dri->dri_Font->tf_YSize + 1) +
 439                         LV_EXTRA_HEIGHT +
 440                         LV_BUTTON_SPACING_Y +
 441                         buttonheight +
 442                         BORDER_Y * 2;
 443
 444             winwidth = buttonwidth * 2 + BUTTON_SPACING_X + BORDER_X * 2;
 445             i = ci->fh->window->WScreen->Width * 1 / 3;
 446             if (i > winwidth) winwidth = i;
 447
 448             winleft = ci->fh->window->WScreen->MouseX -
 449                       (winwidth + ci->fh->window->WScreen->WBorLeft +
 450                       ci->fh->window->WScreen->WBorRight) / 2;
 451             wintop = ci->fh->window->WScreen->MouseY -
 452                       (winheight + ci->fh->window->WScreen->WBorTop +
 453                       dri->dri_Font->tf_YSize + 1 +
 454                       ci->fh->window->WScreen->WBorBottom) / 2;
 455
 456             gad = CreateContext(&gadlist);
 457
 458             ng.ng_LeftEdge   = ci->fh->window->WScreen->WBorLeft + BORDER_X;
 459             ng.ng_TopEdge    = ci->fh->window->WScreen->WBorTop + dri->dri_Font->tf_YSize + 1 + BORDER_Y;
 460             ng.ng_Width      = winwidth - BORDER_X * 2;
 461             ng.ng_Height     = winheight - BORDER_Y * 2 - buttonheight - LV_BUTTON_SPACING_Y;
 462             ng.ng_GadgetText = NULL;
 463             ng.ng_TextAttr   = NULL;
 464             ng.ng_GadgetID   = ID_LISTVIEW;
 465             ng.ng_Flags      = 0;
 466             ng.ng_VisualInfo = vi;
 467             ng.ng_UserData   = 0;
 468
 469             {
 470                 struct TagItem lvtags[] =
 471                 {
 472                     {GTLV_Labels        , (IPTR)&ci->matchlist  },
 473                     {GTLV_ShowSelected  , 0                     },
 474                     {GTLV_Selected      , 0                     },
 475                     {TAG_DONE                                   }
 476                 };
 477
 478                 gad = lvgad = CreateGadgetA(LISTVIEW_KIND, gad, &ng, lvtags);
 479
 480                 visible_lv_lines = (ng.ng_Height - LV_EXTRA_HEIGHT) / (dri->dri_Font->tf_YSize + 1);
 481             }
 482
 483             ng.ng_TopEdge += ng.ng_Height + LV_BUTTON_SPACING_Y;
 484             ng.ng_Width = buttonwidth;
 485             ng.ng_Height = buttonheight;
 486             ng.ng_GadgetText = oktext;
 487             ng.ng_GadgetID = ID_OK;
 488
 489             gad = CreateGadgetA(BUTTON_KIND, gad, &ng, NULL);
 490
 491             ng.ng_LeftEdge += winwidth - buttonwidth - BORDER_X * 2;
 492             ng.ng_GadgetText = canceltext;
 493             ng.ng_GadgetID = ID_CANCEL;
 494
 495             gad = CreateGadgetA(BUTTON_KIND, gad, &ng, NULL);
 496
 497             if (gad)
 498             {
 499                 struct TagItem wintags[] =
 500                 {
 501                     {WA_CustomScreen, (IPTR)ci->fh->window->WScreen },
 502                     {WA_Title       , (IPTR)titletext               },
 503                     {WA_CloseGadget , TRUE                          },
 504                     {WA_DragBar     , TRUE                          },
 505                     {WA_DepthGadget , TRUE                          },
 506                     {WA_Activate    , TRUE                          },
 507                     {WA_AutoAdjust  , TRUE                          },
 508                     {WA_Left        , winleft                       },
 509                     {WA_Top         , wintop                        },
 510                     {WA_InnerWidth  , winwidth                      },
 511                     {WA_InnerHeight , winheight                     },
 512                     {WA_IDCMP       , IDCMP_CLOSEWINDOW |
 513                                       IDCMP_RAWKEY      |
 514                                       IDCMP_VANILLAKEY  |
 515                                       LISTVIEWIDCMP     |
 516                                       BUTTONIDCMP                   },
 517                     {WA_Gadgets     , (IPTR)gadlist                 },
 518                     {TAG_DONE                                       }
 519
 520                 };
 521
 522                 if ((win = OpenWindowTagList(NULL, wintags)))
 523                 {
 524                     BOOL done = FALSE;
 525                     BOOL doit = FALSE;
 526
 527                     CurrentTime(&secold, &microold);
 528
 529                     while (!done && !doit)
 530                     {
 531                         struct IntuiMessage *msg;
 532
 533                         WaitPort(win->UserPort);
 534
 535                         while((msg = GT_GetIMsg(win->UserPort)))
 536                         {
 537                             switch(msg->Class)
 538                             {
 539                                 case IDCMP_CLOSEWINDOW:
 540                                     done = TRUE;
 541                                     break;
 542
 543                                 case IDCMP_VANILLAKEY:
 544                                     switch(msg->Code)
 545                                     {
 546                                         case 27:
 547                                             done = TRUE;
 548                                             break;
 549
 550                                         case 13:
 551                                             doit = TRUE;
 552                                             break;
 553                                     }
 554                                     break;
 555
 556                                 case IDCMP_RAWKEY:
 557                                     {
 558                                         WORD scroll = 0;
 559                                         BOOL page = FALSE;
 560                                         BOOL extreme = FALSE;
 561
 562                                         switch(msg->Code)
 563                                         {
 564                                             case RAWKEY_UP:
 565                                                 scroll = -1;
 566                                                 break;
 567
 568                                             case RAWKEY_DOWN:
 569                                                 scroll = 1;
 570                                                 break;
 571
 572                                             case RAWKEY_PAGEUP:
 573                                                 scroll = -1;
 574                                                 page = TRUE;
 575                                                 break;
 576
 577                                             case RAWKEY_PAGEDOWN:
 578                                                 scroll = 1;
 579                                                 page = TRUE;
 580                                                 break;
 581
 582                                             case RAWKEY_HOME:
 583                                                 scroll = -1;
 584                                                 extreme = TRUE;
 585                                                 break;
 586
 587                                             case RAWKEY_END:
 588                                                 scroll = 1;
 589                                                 extreme = TRUE;
 590                                                 break;
 591
 592                                             case RAWKEY_NM_WHEEL_UP:
 593                                                 scroll = -1;
 594                                                 break;
 595
 596                                             case RAWKEY_NM_WHEEL_DOWN:
 597                                                 scroll = 1;
 598                                                 break;
 599                                         }
 600
 601                                         if (msg->Qualifier & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT))
 602                                         {
 603                                             page = TRUE;
 604                                         }
 605
 606                                         if (msg->Qualifier & (IEQUALIFIER_LALT | IEQUALIFIER_RALT | IEQUALIFIER_CONTROL))
 607                                         {
 608                                             extreme = TRUE;
 609                                         }
 610
 611                                         if (scroll)
 612                                         {
 613                                             IPTR getsel;
 614                                             struct TagItem tags[] =
 615                                             {
 616                                                 {GTLV_Selected, (IPTR)&getsel   },
 617                                                 {TAG_IGNORE   , TRUE            },
 618                                                 {TAG_DONE                       }
 619                                             };
 620                                             WORD sel;
 621
 622                                             GT_GetGadgetAttrsA(lvgad, win, NULL, tags);
 623                                             sel = (WORD)getsel;
 624
 625                                             if (extreme)
 626                                             {
 627                                                 scroll *= ci->nummatchnodes;
 628                                             }
 629                                             else if (page)
 630                                             {
 631                                                 scroll *= visible_lv_lines;
 632                                             }
 633
 634                                             sel += scroll;
 635                                             if (sel < 0) sel = ci->nummatchnodes - 1;
 636                                             if (sel >= ci->nummatchnodes) sel = 0;
 637
 638                                             tags[0].ti_Data = (IPTR)sel;
 639                                             tags[1].ti_Tag  = GTLV_MakeVisible;
 640                                             tags[1].ti_Data = (IPTR)sel;
 641
 642                                             GT_SetGadgetAttrsA(lvgad, win, NULL, tags);
 643                                         }
 644                                     }
 645                                     break;
 646
 647                                 case IDCMP_GADGETUP:
 648                                     gad = (struct Gadget *)msg->IAddress;
 649
 650                                     switch(gad->GadgetID)
 651                                     {
 652                                         case ID_OK:
 653                                             doit = TRUE;
 654                                             break;
 655
 656                                         case ID_CANCEL:
 657                                             done = TRUE;
 658                                             break;
 659
 660                                         case ID_LISTVIEW:
 661                                             CurrentTime(&sec, &micro);
 662                                             if (DoubleClick(secold, microold, sec, micro)) doit = TRUE;
 663                                             secold = sec; microold = micro;
 664                                             break;
 665                                     }
 666                                     break;
 667
 668                             } /* switch(msg->Class) */
 669
 670                             GT_ReplyIMsg(msg);
 671
 672                         } /* while((msg = GT_GetIMsg(win->UserPort))) */
 673
 674                     } /* while (!done && !doit) */
 675
 676                     if (doit)
 677                     {
 678                         struct Node *node;
 679                         IPTR sel;
 680
 681                         struct TagItem gettags[] =
 682                         {
 683                             {GTLV_Selected, (IPTR)&sel  },
 684                             {TAG_DONE                   }
 685                         };
 686
 687                         GT_GetGadgetAttrsA(lvgad, win, NULL, gettags);
 688
 689                         i = 0;
 690                         ForeachNode(&ci->matchlist, node)
 691                         {
 692                             if ((WORD)sel == i)
 693                             {
 694                                 AddPart(ci->match, node->ln_Name, sizeof(ci->match));
 695
 696                                 retval = TRUE;
 697                                 break;
 698                             }
 699                             i++;
 700                         }
 701
 702                     } /* if (doit) */
 703
 704                     CloseWindow(win);
 705
 706                 } /* if ((win = OpenWindowTagList(NULL, wintags))) */
 707
 708             } /* if (gad) */
 709
 710             FreeGadgets(gadlist);
 711             FreeVisualInfo(vi);
 712
 713         } /* if ((vi = GetVisualInfoA(ci->fh->window->WScreen, NULL))) */
 714
 715         FreeScreenDrawInfo(ci->fh->window->WScreen, dri);
 716
 717     } /* if ((dri = GetScreenDrawInfo(fh->window->WScreen))) */
 718
 719     return retval;
 720 }
 721
 722 /****************************************************************************************/
 723
 724 void Completion(struct filehandle *fh)
 725 {
 726     struct completioninfo *ci;
 727
 728     if ((ci = InitCompletion(fh)))
 729     {
 730         PrepareCompletion(fh, ci);
 731
 732         if (!ci->dirpart[0] && !ci->filepart[0])
 733         {
 734             DoFileReq(fh, ci);
 735         }
 736         else
 737         {
 738             if (PreparePattern(fh, ci))
 739             {
 740                 BOOL doprint = FALSE;
 741
 742                 DoScan(fh, ci);
 743
 744                 strncpy(ci->match, ci->dirpart, sizeof(ci->match));
 745
 746                 if (ci->nummatchnodes == 1)
 747                 {
 748                     AddPart(ci->match,
 749                             ((struct matchnode *)GetHead(&ci->matchlist))->name,
 750                             sizeof(ci->match));
 751
 752                     doprint = TRUE;
 753                 }
 754                 else if (ci->nummatchnodes > 1)
 755                 {
 756                     doprint = DoChooseReq(fh, ci);
 757                 }
 758
 759                 if (doprint)
 760                 {
 761                     WORD backspaces;
 762                     UBYTE c;
 763
 764                     if (strchr(ci->match, ' ')) AddQuotes(ci, ci->match, sizeof(ci->match));
 765
 766                     /* Insert as many backspaces in front of the string,
 767                        to erase whole "word" first (starting at ci->wordstart)
 768                        before reprinting expanded filename */
 769
 770                     backspaces = ci->fh->inputpos - ci->wordstart;
 771
 772                     memmove(ci->match + backspaces, ci->match, sizeof(ci->match) - backspaces);
 773                     memset(ci->match, 8, backspaces);
 774
 775                     c = ci->match[strlen(ci->match) - 1];
 776                     if ((c != '/') && (c != ':'))
 777                     {
 778                         strncat(ci->match, " ", sizeof(ci->match));
 779                     }
 780
 781                     InsertIntoConBuffer(ci, ci->match);
 782
 783                 }
 784             }
 785         }
 786
 787         CleanupCompletion(ci);
 788
 789     } /* if ((ci = InitCompletion())) */
 790
 791 }
 792
 793 /****************************************************************************************/