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