Programmer 7500/MAX_PROGRAMMERS.iso/PASCAL/ECO30603.ZIP/ECO30603.LZH/ECOLIBII/ECO_TREE.PAS

Pascal/Delphi Source File | 1993-03-03 | 37.2 KB | 1,132 lines

(*

         ┌────────────────[ file information report ]────────────────┐
         │                                                           │
         │   Sourcefile for The Fast Commander, v3.51 and higher.    │
         │   All material is protected and licensed.                 │
         │   (C) Copyright 1992 by EUROCON PANATIONAL CORPORATION.   │
         │   Written exclusively by Floor Naaijkens for              │
         │   UltiHouse Software / The ECO Group All Rights Reserved. │
         │   See various documentory files for further information   │
         │   on how to handle these files.                           │
         │                                                           │
         │   Filename:      ECO_TREE.PAS                             │
         │   Version:       3.51                                     │
         │   Last change:   August 30, 1991, 18:51                   │
         │   Dependencies:  KEY·, SUP·, STR·, SCN·, EXT·, WIN·,      │
         │                  DOS·, ····, ····, ····, ····, ····.      │
         │                                                           │
         │   Features/Remarks: Object Oriented Unit.                 │
         │                     Uses extended syntax.                 │
         │                                                           │
         └───────────────────────────────────────────────────────────┘


*)

{$A-,B-,D-,E-,F-,I-,L-,N-,O-,R-,S-,V-}
unit eco_tree;

interface

uses
  dos, eco_lib

  ;


const
  mainsize : word    =   512;
  debug    : boolean = false;


type
  srec_ptr = ^srec_chain;
  srec_chain = record
    srec : searchrec;
    bid  :   longint;
    prev :      word;
    link :  srec_ptr;
  end;

  str_ptrar = array[0..511] of string[78];
  str_ptr = ^str_ptrar;

  nodes = record
    name    : string[12];
    bid     :    longint; { bytes in directory }
    parent  :       word;
  end;

  nodearraytype =  array[0..511] of nodes;
  nodearraytypeptr = ^nodearraytype;



  treepanelobj = object { data must not be altered directly }
    autoscan, fullwide        : boolean;
    boxtype,
    x1, y1, x2, y2,
    panel_f, panel_b,
    header_f, header_b        :    byte;
    footer_f, footer_b        :    byte;
    showscan                  : boolean;
    x3, y3, x4, y4,
    popup_f, popup_b,
    tagnocsr_f, tagnocsr_b,
    tagcsr_f, tagcsr_b,
    scrollbar_f, scrollbar_b,
    curactbar_f, curactbar_b  :    byte;

    {=================================}
    nodedispptr     :          str_ptr;
    nodearray       : nodearraytypeptr;
    walkcsr,
    walkoffset      :             word;
    newtreeoff      :          boolean;
    checkdriv,
    drivechar       :             char;
    nodenumber      :             word;
    prevparent      :             word;
    sizedir         :          boolean;
    adjwidth        :          boolean;
    widetree        :          boolean;
    showdirnum      :          boolean;
    showpath        :          boolean;
    treeinfofile    :          pathstr;
    horspace        :           string;
    horbar          :           string;

    {============================== external =================================}
    procedure init                                                            ;
    procedure done                                                            ;
    procedure setdrive(dr: char)                                              ;
    procedure trace_tree                                                      ;
    procedure draw                      { not needed when walk_tree is run }  ;
    procedure putdefaults                                                     ;
    procedure increase_bar;
    procedure decrease_bar;
    procedure getoptions(
      var
        auto,
        treefullwide , treeshowpath        : boolean;
      var
        bt,
        treex1, treey1, treex2, treey2,
        treepanel_f, treepanel_b,
        treeheader_f, treeheader_b         :    byte;
        treefooter_f, treefooter_b         :    byte;
      var
        treeshowscan                       : boolean;
      var
        treex3, treey3, treex4, treey4,
        treepopup_f, treepopup_b,
        treetagnocsr_f, treetagnocsr_b,
        treetagcsr_f, treetagcsr_b,
        treescrollbar_f, treescrollbar_b,
        treecuractbar_f, treecuractbar_b   :    byte
    );
    procedure setoptions(
      auto,
      treefullwide , treeshowpath          : boolean;
      bt,
      treex1, treey1, treex2, treey2,
      treepanel_f, treepanel_b,
      treeheader_f, treeheader_b           :    byte;
      treefooter_f, treefooter_b           :    byte;
      treeshowscan                         : boolean;
      treex3, treey3, treex4, treey4,
      treepopup_f, treepopup_b,
      treetagnocsr_f, treetagnocsr_b,
      treetagcsr_f, treetagcsr_b,
      treescrollbar_f, treescrollbar_b,
      treecuractbar_f, treecuractbar_b     :    byte
    );
    function  walk_tree_(
      returnkeys : pointer; numberofretkeys: byte; var retkey  : word
    ): pathstr;
    {============================== internal ================================ }
    procedure search_tree(level: word)                                        ;
    procedure save_tree(fname: pathstr)                                       ;
    procedure load_tree(fname: pathstr)                                       ;
    procedure del_subtree(b: word)                                            ;
    procedure jump_curpath                                                    ;
    procedure build_tree(complete: boolean)                                   ;
    function  trace_path(temphead: integer) :                          pathstr;
    function  succpresent(j: word) :                                   boolean;
    function  prevpresent(j: word) :                                   boolean;
    function  calcsucc(j: word) :                                         word;
    function  calcprev(j: word) :                                         word;
    function  calccurpath(var notfound: boolean):                         word;
    function  calc_lvl(j: word) :                                         word;
  end; { treepanelobj }



var
  node_file       : file of nodes;
  srec            :     searchrec;
  s, r            :        string;
  notfound        :       boolean;
  i, j, levels    :          word;



implementation



  procedure treepanelobj.init;
  begin
    nodedispptr := nil; nodearray := nil;
    new(nodearray); new(nodedispptr);
    s := ''; getdir(0, _doscurpath); drivechar := _doscurpath[1];
    walkoffset := 0; { walkcsr := calccurpath(notfound); }
    walkcsr := 0; walkoffset := 0; prevparent := 0; nodenumber := 1;
  end;



  procedure treepanelobj.putdefaults;
  begin
    drivechar    :=              'C';
    checkdriv    :=              'C';
    sizedir      :=             true;
    adjwidth     :=            false;
    widetree     :=             true;
    showdirnum   :=             true;
    showpath     :=             true;
    boxtype      :=               15;
    treeinfofile :=  ':\TREEINFO.DR';
    horspace     :=          {1} ' ';
    horbar       :=          {1} '─';
  end;


  procedure treepanelobj.increase_bar;
  begin
    case length(horspace) of
      0: begin horspace := ' ';    horbar := '─'    end;
      1: begin horspace := '  ';   horbar := '──'   end;
      2: begin horspace := '   ';  horbar := '───'  end;
      3: begin horspace := '    '; horbar := '────' end;
      else begin horspace := '';     horbar := ''     end;
    end; build_tree(true); newtreeoff := true; draw
  end;


  procedure treepanelobj.decrease_bar;
  begin
    case length(horspace) of
      0: begin horspace := '    ';    horbar := '────'    end;
      1: begin horspace := '';   horbar := ''   end;
      2: begin horspace := ' ';  horbar := '─'  end;
      3: begin horspace := '  '; horbar := '──' end;
      else begin horspace := '   ';     horbar := '───'     end;
    end; build_tree(true); newtreeoff := true; draw;
  end;


  procedure treepanelobj.setoptions(
    auto,
    treefullwide , treeshowpath        : boolean;
    bt,
    treex1, treey1, treex2, treey2,
    treepanel_f, treepanel_b,
    treeheader_f, treeheader_b         :    byte;
    treefooter_f, treefooter_b         :    byte;
    treeshowscan                        : boolean;
    treex3, treey3, treex4, treey4,
    treepopup_f, treepopup_b,
    treetagnocsr_f, treetagnocsr_b,
    treetagcsr_f, treetagcsr_b,
    treescrollbar_f, treescrollbar_b,
    treecuractbar_f, treecuractbar_b   :    byte
  );

  begin
    autoscan := auto;
    fullwide := treefullwide; showpath := treeshowpath;
    x1 := treex1; y1 := treey1; x2 := treex2; y2 := treey2;
    panel_f := treepanel_f; panel_b := treepanel_b;
    header_f := treeheader_f; header_b := treeheader_b;
    footer_f := treefooter_f; footer_b := treefooter_b;
    showscan := treeshowscan; boxtype := bt;
    x3 := treex3; y3 := treey3; x4 := treex4; y4 := treey4;
    popup_f := treepopup_f; popup_b := treepopup_b;
    tagnocsr_f := treetagnocsr_f; tagnocsr_b := treetagnocsr_b;
    tagcsr_f := treetagcsr_f; tagcsr_b := treetagcsr_b;
    scrollbar_f := treescrollbar_f; scrollbar_b := treescrollbar_b;
    curactbar_f := treecuractbar_f; curactbar_b := treecuractbar_b;
  end;



  procedure treepanelobj.getoptions(
    var
      auto,
      treefullwide , treeshowpath        : boolean;
    var
      bt,
      treex1, treey1, treex2, treey2,
      treepanel_f, treepanel_b,
      treeheader_f, treeheader_b         :    byte;
      treefooter_f, treefooter_b         :    byte;
    var
      treeshowscan                       : boolean;
    var
      treex3, treey3, treex4, treey4,
      treepopup_f, treepopup_b,
      treetagnocsr_f, treetagnocsr_b,
      treetagcsr_f, treetagcsr_b,
      treescrollbar_f, treescrollbar_b,
      treecuractbar_f, treecuractbar_b   :    byte
  );

  begin
    auto := autoscan;
    treefullwide := fullwide; treeshowpath := showpath;
    treex1 := x1; treey1 := y1; treex2 := x2; treey2 := y2;
    treepanel_f := panel_f; treepanel_b := panel_b;
    treeheader_f := header_f; treeheader_b := header_b;
    treefooter_f := footer_f; treefooter_b := footer_b;
    treeshowscan := showscan; bt := boxtype;
    treex3 := x3; treey3 := y3; treex4 := x4; treey4 := y4;
    treepopup_f := popup_f; treepopup_b := popup_b;
    treetagnocsr_f := tagnocsr_f; treetagnocsr_b := tagnocsr_b;
    treetagcsr_f := tagcsr_f; treetagcsr_b := tagcsr_b;
    treescrollbar_f := scrollbar_f; treescrollbar_b := scrollbar_b;
    treecuractbar_f := curactbar_f; treecuractbar_b := curactbar_b;
  end;




  procedure treepanelobj.done;
  begin
    nodenumber := 1;
    if nodedispptr <> nil then dispose(nodedispptr);
    if nodearray <> nil then dispose(nodearray);
    nodedispptr := nil; nodearray := nil;
  end;



  procedure treepanelobj.setdrive(dr: char);
  begin
    drivechar := upcase(dr); trace_tree;
  end;



  procedure treepanelobj.draw;
  const
    onlyshow : word = $0000;

  var
    dkey :   word;

  begin
    newtreeoff := true;
    walk_tree_(@onlyshow, 1, dkey);
  end;




  function treepanelobj.trace_path(temphead: integer): pathstr;
  var
    off      :                    word;
    st       :                  string;
    i        :                    word;
    tmp      : array[1..50] of integer;

  begin
    off := 0;
    while temphead>0 do begin
      inc(off); tmp[off] := temphead;
      temphead := nodearray^[temphead].parent;
    end; st := '\';
    if off>0 then for i := off downto 1 do st := st +
      __cvtstr(nodearray^[tmp[i]].name, _dircase) + _dirslash;
    off := 0; fillchar(tmp, sizeof(tmp), chr(48));
    trace_path := st;
  end;




  procedure treepanelobj.search_tree(level: word);
  var
    i         :  integer;
    s         :   string;
    srec_root,
    srec_link : srec_ptr;


    { not much subdirs in one dir, so no efficiency taken into account }
    procedure sort(srec_root: srec_ptr);
    var
      srec1, srec2, srec3 :  srec_ptr;
      srec                : searchrec;

    begin
      srec1 := srec_root;
      while srec1^.link <> nil do begin
        srec2 := srec1^.link; srec3 := srec1;
        repeat { assume we are already sorted properly }
          if srec2^.srec.name < srec3^.srec.name then srec3 := srec2;
          srec2 := srec2^.link;
        until srec2 = nil;
        if srec3 <> srec1 then begin
          srec := srec1^.srec; srec1^.srec := srec3^.srec; srec3^.srec := srec;
        end; srec1 := srec1^.link;
      end;
    end;


  begin
    srec_root := nil;
    if sizedir then
      findfirst('*.*', anyfile, srec) else findfirst('*.*', directory, srec);
    nodearray^[nodenumber].bid := 0;
    while doserror=0 do begin
      inc(nodearray^[nodenumber].bid, __main(srec.size, mainsize));
      if (((srec.attr and directory)>0) and (srec.name[1]<>'.')) then begin
        if srec_root = nil then begin
          new(srec_root); srec_link := srec_root;
        end else begin
          new(srec_link^.link); srec_link := srec_link^.link;
        end; srec_link^.srec := srec; srec_link^.link := nil;
        srec_link^.prev := prevparent;
      end;
      findnext(srec);
    end; inc(prevparent);
    if srec_root <> nil then begin
      sort(srec_root);
      if (srec_root^.link = nil) and (level = 0) and showscan then __betwscn(
        x3, x4, y3+1, popup_f, popup_b, '\'
      );
      repeat
        s := srec_root^.srec.name;
        with nodearray^[nodenumber] do begin
          name := __lo(s); parent := srec_root^.prev;
        end;
        if showscan then __betwscn(
          x3, x4, y3+1, popup_f, popup_b, __rep(12, ' ')
        );
        if showscan then __betwscn(x3, x4, y3+1, popup_f, popup_b, s);
        inc(nodenumber);
        chdir(s); search_tree(level+1); chdir('..');
        srec_link := srec_root; srec_root := srec_root^.link;
        dispose(srec_link);
      until srec_root = nil;
    end else if (level = 0) and showscan then __betwscn(
      x3, x4, y3+1, popup_f, popup_b, 'No <DIR>''s'
    );
  end; { search_tree }




  procedure treepanelobj.trace_tree;
  begin
    chdir(drivechar+':\'); nodenumber :=  1; prevparent :=  0;
    fillchar(nodearray^, sizeof(nodearray^), ' ');
    search_tree(0); chdir(_doscurpath);
    for i := 0 to nodenumber do nodearray^[i].bid := nodearray^[i+1].bid;
  end;



  procedure treepanelobj.save_tree(fname: pathstr);
  begin
    assign(node_file, fname); rewrite(node_file);
    for i := 1 to nodenumber-1 do write(node_file, nodearray^[i]);
    close(node_file);
  end;



  procedure treepanelobj.load_tree(fname: pathstr);
  var
    rec: searchrec;

  begin
    nodenumber := 1;
    assign(node_file, fname); reset(node_file);
    while not(eof(node_file)) do begin
      read(node_file, nodearray^[nodenumber]); inc(nodenumber)
    end; close(node_file);
    nodearray^[0].bid := 0;
    findfirst('\*.*', anyfile, rec);
    while doserror=0 do begin
      inc(nodearray^[0].bid, __main(rec.size, 8192)); findnext(rec)
    end;
  end;




    { int functions, also used by walk_tree }
    function treepanelobj.succpresent(j: word): boolean;
    var
      nevdl : boolean;
      ll    :    word;

    begin
      nevdl := false;
        for ll := j+1 to nodenumber-1 do nevdl :=
          (nodearray^[ll].parent = nodearray^[j].parent) or nevdl;
      succpresent := nevdl;
    end;


    function treepanelobj.prevpresent(j: word): boolean;
    var
      nevdl : boolean;
      ll    :    word;

    begin
      nevdl := false;
        for ll := j-1 downto 1 do nevdl :=
          (nodearray^[ll].parent = nodearray^[j].parent) or nevdl;
      prevpresent := nevdl;
    end;


    function treepanelobj.calcsucc(j: word): word;
    {use succpresent first to check}
    var
      ll: word;

    begin
      ll := j+1;
      while (
        (nodearray^[ll].parent <> nodearray^[j].parent) and (ll<nodenumber)
      ) do inc(ll); calcsucc := ll
    end;


    function treepanelobj.calcprev(j: word): word;
    {use prevpresent first to check}
    var
      ll: word;

    begin
      ll := j-1;
      while (
        (nodearray^[ll].parent<>nodearray^[j].parent) and (ll>1)
      ) do dec(ll);
      calcprev := ll
    end;


    function treepanelobj.calc_lvl(j: word): word;
    var
      off: word;

    begin
      off := 0; while j>0 do begin inc(off); j := nodearray^[j].parent end;
      calc_lvl := off
    end;

    {============================================}



  procedure treepanelobj.build_tree;
  var
    s          : string;
    i, hor, k,
    jj, j, pnt :   word;

  begin
    chdir(drivechar + ':\');
    nodedispptr^[0] := '\'; hor := length(horspace);
    with nodearray^[0] do begin name := _dirslash; parent := 0 end;

    if nodenumber>0 then begin
      s := ''; levels := 1;
      for i := 1 to nodenumber do begin
        if nodearray^[i].parent < nodearray^[i - 1].parent then begin  { down }
          if widetree then
            s := copy(s, 1, calc_lvl(i) * (hor + hor + 2) - hor - 1) else
            s := copy(s, 1, length(s) - (levels - calc_lvl(i) +1) * (hor+1));
          if succpresent(i) then s := s + '├' else s := s + '└';
          s := s + horbar;
          levels := calc_lvl(i);
        end else if (nodearray^[i].parent>nodearray^[i - 1].parent) then begin
          s := copy(s, 1, length(s) - hor - 1);                          { up }
          if succpresent(nodearray^[i].parent) then
            s := s + '│' + horspace else s := s + ' ' + horspace;
          if succpresent(i) then s := s + '├' else s := s + '└';
          s := s + horbar; inc(levels);
        end else begin                                                 { next }
          s := copy(s, 1, length(s) - hor - 1);
          if succpresent(i) then s := s + '├' else s := s + '└';
          s := s + horbar;
        end;
        {▄▀▄▀▄▀▄▀▄▀▄▀▄▀▄▀▄▀▄▀▄▀▄▀▄▀▄▀▄▀▄▀▄▀▄▀▄▀▄▀▄▀▄▀▄▀▄▀▄▀▄▀▄▀▄▀▄▀▄▀▄▀▄ wide }
        if widetree then begin
          if i = 2 then for jj := 1 to hor+1 do s[jj] := ' ';
          if (i = nodearray^[i].parent + 1) and (i > 0) then begin
            s := copy(s, 1, length(s) - hor - 1);
            s := s + '└' + horbar;
            if succpresent(i) then s := s + '┬' else s := s + '─';
            s := s + horbar;
          end;
          if (nodearray^[i - 1].parent = i - 2) and (i > 1) then begin
            if (
              (nodearray^[i - 1].parent = nodearray^[i].parent)
            ) then begin
              for j := hor + hor + 1 downto 1 do if length(s) - j - hor>0 then
                s[length(s) - j - hor] := ' ';
            end else if (nodearray^[i].parent = i - 1) and (i > 2) then begin
              if not(succpresent(i-2)) then begin
                for j := (calc_lvl(i))*(hor+1)-1 downto 1 do
                  s[j+hor+3-1] := ' ';
              end else
              if succpresent(i-1) then begin
                {
                for j := (calc_lvl(i)-1)*hor+1 downto 1 do s[j+hor+3-1] := st[1];
                }
                j := (calc_lvl(i)-1)*hor+1;
                while s[j] <> '└' do inc(j);
                while not(s[j] in [' ', '│']) do begin s[j] := ' '; inc(j) end;
              end else begin
                k:=length(s); while (k>1) and (s[k]<>'└') do dec(k); dec(k);
                for j := k downto k-hor*2-1 do s[j] := ' '
              end; { multilevel down }
            end; { parent check }
          end; { previous parent check }
          if i = 2 then s[hor * 2 + 3] := '└';
        end; { wide }
        nodearray^[i].name := __cvtstr(nodearray^[i].name, _dircase);
        pnt := pos('.', nodearray^[i].name);
        if pnt = 0 then r := nodearray^[i].name else
          r := copy(nodearray^[i].name, 1, pnt - 1) +
            copy(nodearray^[i].name, pnt + 1, 3);
        nodedispptr^[i] := s + r;
      end; { i }
    end; { else "no <DIR>'s" }

    chdir(_doscurpath);
    if sizedir then for i := 0 to nodenumber+1 do
      if nodearray^[i].bid div 1024 div 1024 > 4 then nodedispptr^[i] :=
        __juststr(__num(nodearray^[i].bid div 1024 div 1024),
          ' ', 4, _right_just_str) + 'M ' + nodedispptr^[i] else
        nodedispptr^[i] := __juststr(__num(nodearray^[i].bid div 1024),
          ' ', 4, _right_just_str) + 'K ' + nodedispptr^[i];
  end; { build_tree }




  procedure treepanelobj.del_subtree(b: word);
  var
    i,j: word;


    function node_in_other(ii: word): boolean;
    var bytset : set of byte;
    begin
      bytset := [];
      while ii<>0 do begin
        bytset := bytset + [nodearray^[ii].parent];
        ii := nodearray^[ii].parent;
      end;
      node_in_other := (b in bytset);
    end;


  begin
    i := b+1;
    while node_in_other(i) and (i<nodenumber) do inc(i);
    move(nodearray^[i], nodearray^[b], (nodenumber-i+1)*sizeof(nodes));
    dec(nodenumber, i-b-1-1);
  end; { del }




  function treepanelobj.calccurpath(var notfound: boolean): word;
  var
    i,j      :    word;
    curpath  : pathstr;
    chops    :  string;

  begin
    getdir(0, curpath); notfound := false;
    curpath := __normfil(__backapp(curpath));
    if length(curpath) = 3 then calccurpath := 0 else begin
      i := length(curpath)-1; j := i;
      while not (curpath[i] in ['\', '/']) do dec(i);
      inc(i); chops := copy(curpath, i, j-i+1);

      j := 0; i := nodenumber - 1;
      while i > 0 do begin
        if debug then writeln(nodearray^[i].name:12, '  ', chops);
        if __comp(nodearray^[i].name, chops) then begin
          if debug then writeln('MATCH level 1');
          if __normfil(__backapp(trace_path(i))) = curpath then begin
            if debug then writeln('MATCH level 2');
            j := i; i := 1; { wordt nog een keer verlaagd = 0 }
          end;
        end;
        dec(i);
      end;
      if j=0 then notfound := true;
      calccurpath := j;
    end;
  end;




  procedure treepanelobj.jump_curpath;
  var
    error, check :      boolean;
    scnerr       :         word;
    tmpscn       : _scnimageptr;

  begin
    walkcsr := calccurpath(error);
    if error then begin
      new(tmpscn); __savscn(tmpscn);
      done; init;
      __bandwin(true, x3, y3, x4, y4, popup_f, popup_b, sh_default, 2);
      newtreeoff := true; walkoffset := 0; walkcsr := 0;
      __betwscn(x3, x4, y3, popup_f, popup_b, ' Autoscanning ');
      trace_tree;
      save_tree(checkdriv + treeinfofile + drivechar);
      if debug then writeln('Saving: ' + checkdriv + treeinfofile + drivechar);
      build_tree(true);
      walkcsr := calccurpath(error);
      __resscn(tmpscn); dispose(tmpscn);
    end;
    if nodenumber < (y2-y1-1-2) then walkoffset := 0 else begin
      if walkcsr>=(y2-y1-1-2) then walkoffset := walkcsr-(y2-y1-1-2)+1;
      if walkcsr+(y2-y1-1-2) < nodenumber then walkoffset := walkcsr else
        walkoffset := nodenumber - (y2-y1-1-2);
      if walkoffset < 0 then walkoffset := 0;
    end;
  end;





  function treepanelobj.walk_tree_(
    returnkeys  : pointer; numberofretkeys: byte; var retkey  : word
  ): pathstr;              { key 1: pad  2: drive scan  3: confirm }

  type
    arr = array[1..128] of word;
    ar  = ^arr;

  var
    check,
    retkeypressed :    boolean;
    fullscnlen,
    scan, bb, cl  :       word;
    jj, h, page,
    key, scnerr   :       word;
    statusbits    :    longint;
    st            :     string;
    pathpointer   :    pathstr;
    statusflags   : _keystatus;




    procedure disptreepart(offset: word);
    var i: word;
    begin
      newtreeoff := false;
      __boxscn(x1, y1, x2, y2, boxtype, panel_f, panel_b);
      __betwscn(x1, x2, y1, panel_b, panel_f, ' Tree ');
      __write(x1+1, y2-1, panel_f, panel_b, __rep(x2-x1-1, ' '));
      if boxtype = bt_double then
        __write(x1, y2-2, panel_f, panel_b, '╟'+__rep(x2-x1-1, '─')+'╢') else
        __write(x1, y2-2, panel_f, panel_b, '├'+__rep(x2-x1-1, '─')+'┤');
      __write(x1+1, y2-1, footer_f, footer_b,
        __juststr(
          __slashfil(
            __packfil(
              __cvtstr(
                __xlatestr(
                  _doscurpath,
                  '.', ' '
                ),
                _rem_white_str
              ),
              x2-x1-1
            )
          ),
          ' ', x2-x1-1, _left_just_str
        )
      );

      if nodenumber >= page then begin
        for i := 0 to page-1 do
          __write(x1+1, y1+1+i, panel_f, panel_b, __juststr(' ' +
            copy(nodedispptr^[i+offset], 1, x2-x1-1), ' ', x2-x1-1,
            _left_just_str)
          )
      end else begin
        for i := 0 to nodenumber-1 do
          __write(x1+1, y1+1+i, panel_f, panel_b,
            __juststr(' ' + copy(nodedispptr^[i],
            1, x2-x1-1), ' ', x2-x1-1, _left_just_str)
          );
        for i := nodenumber to page-1 do
          __write(x1+1, y1+1+i, panel_f, panel_b, __rep(x2-x1-1, ' '));
      end;
    end;




    function disptreecursor(loc: word; out: boolean): pathstr;
    var
      ff, bb, cl, hor :   word;
      st              : string;

    begin
      st := nodedispptr^[loc]; bb := length(st);
      if sizedir then cl := 6 else cl := 1;
      while (st[cl] in [' ', '─', '│', '└', '├', '┬']) and
        (cl<=bb) do inc(cl); dec(cl);
      hor := length(horbar); st := '';
      if out then begin
        ff := curactbar_f; bb := curactbar_b
      end else begin
        ff := scrollbar_f; bb := scrollbar_b
      end;
      if showdirnum then st := __juststr(__num(loc), '0', 4, _right_just_str);
      __write(x2 - 5, y1 + 1 + loc - walkoffset , panel_f, panel_b,
        chr(17) + st
      );
      if out then begin
        if hor > 0 then
          __write(x1+1+cl, y1 + 1 + loc - walkoffset, ff, bb, '▌');
        if (walkoffset + walkcsr=0) then __write(
          x1 + 1 + cl + 2,
          y1 + 1 + loc - walkoffset, ff, bb, '▐'
        ) else __write(__min(x1 + 1 + cl + 12, x2 - 6),
          y1 + 1 + loc - walkoffset, ff, bb, '▐'
        )
      end else if (hor>0) and (walkoffset + walkcsr > 0) then __write(
        x1 + 1 + cl, y1 + 1 + loc - walkoffset, bb, ff, '█'
      );
      if (walkoffset + walkcsr = 0) then __attrib(
        x1 + 1 + cl,
        y1 + 1 + loc - walkoffset,
        __min(x1 + 1 + cl + 2, x2 - 6),
        y1 + 1 + loc - walkoffset, ff, bb
      ) else __attrib(
        x1 + 1 + cl + 1,
        y1 + 1 + loc - walkoffset,
        __min(x1 + 1 + cl + 12, x2 - 6),
        y1 + 1 + loc - walkoffset, ff, bb
      ); disptreecursor := nodearray^[walkcsr].name
    end;




    procedure undisptreecursor(loc: word);
    var
      cl, hor, bb : word;
      st          : string;

    begin
      st := nodedispptr^[loc]; bb := length(st);
      if sizedir then cl := 6 else cl := 1;
      while (st[cl] in [' ', '─', '│', '└', '├', '┬']) and
        (cl<=bb) do inc(cl); dec(cl);
      hor := length(horbar);
      __write(x2 - 6, y1 + 1 + loc - walkoffset , panel_f, panel_b, '      ');
      if walkcsr<>0 then begin
        if hor > 0 then
          __write(x1 +1+cl, y1 + 1 + loc - walkoffset, panel_f, panel_b, '─');
        __attrib(
          __min(x1 + 1 + cl, x2 - 4),
          y1 + 1 + loc - walkoffset,
          __min(x1 + 1 + cl + 12, x2 - 4),
          y1 + 1 + loc - walkoffset, panel_f, panel_b
        )
      end else begin
        if (hor>0) or (walkcsr + walkoffset=0) then __write(
          x1 + 1 + cl,
          y1 + 1 + loc - walkoffset, panel_f, panel_b, ' '
        );
        __attrib(
          __min(x1 + cl, x2 - 4),
          y1 + 1 + loc - walkoffset,
          __min(x1 + 1 + cl + 12, x2 - 4),
          y1 + 1 + loc - walkoffset, panel_f, panel_b
        )
      end;
    end;

  var
    tmpscn : _scnimageptr;

  begin
    retkeypressed := false; page := y2 - y1 - 1 - 2;
    fullscnlen := x2 - x1 - 1;

    if (word((ar(returnkeys)^[1])) = $0000) or newtreeoff then begin
      newtreeoff := false; disptreepart(walkoffset);
      pathpointer := disptreecursor(walkcsr, true);
      __betwscn(x1, x2, y1, panel_f, panel_b, ' Tree '); exit;
    end; { just getting a nice picture and leave }

    st := nodedispptr^[walkcsr]; bb := length(st);
    if sizedir then cl := 7 else cl := 1;
    while (st[cl] in [' ','─','│','└','├','┬']) and (cl <= bb) do inc(cl);
    dec(cl);

    if (walkoffset+walkcsr=0) then __write(
      x1 - 1 + 4 + 4, y1 + 1 - walkoffset, panel_f, panel_b, ' \ '
    ) else __write(
      x1 - 1 + 2 + 12 + cl, y1+1 + walkcsr - walkoffset, panel_f, panel_b, ' '
    );

    __betwscn(x1, x2, y1, panel_b, panel_f, ' Tree ');

    repeat
      if newtreeoff then disptreepart(walkoffset); newtreeoff := false;
      pathpointer := disptreecursor(walkcsr, retkeypressed);
      newtreeoff := false;
      if showpath then __write(
        x1 + 1, y2 - 1, footer_f, footer_b,
        __lo(
          __juststr(
            __packfil(
              __cvtstr(
                __xlatestr(
                  __normfil(
                    trace_path(walkcsr)
                  ),
                  '.\', ' /'
                ),
                _rem_white_str
              ),
              x2 - x1 - 1
            ),
            ' ', x2 - x1 - 1, _left_just_str + _to_lowcase_str
          )
        )
      );


      if retkey=$0000 then key := __retkey else key := retkey;
      statusbits := __statkey(statusflags); retkey := $0000;
      undisptreecursor(walkcsr);

      case key of

        _up, _padup: begin
          if statusflags._scrollstate then begin
            if statusflags._capsstate then begin
              if (y1>1) then begin
                __copyscn(x1, y1, x2, y2, x1, y1 - 1);
                {__partscn(scn4, x1, y2, x2, y2, true);}
                dec(y1); dec(y2);
              end else {smallbeep};
            end else begin
              if y2 - y1 - 1 > 5 then begin
                __copyscn(x1, y2 - 2, x2, y2, x1, y2 - 3);
                __write(x1, y2 + 0, panel_f, panel_b, __rep(x2-x1 + 1,' '));
                dec(y2); newtreeoff := true; dec(page); jump_curpath;
                {__partscn(scn4, x1, y2 + 1, x2, y2 + 1, true);}
              end else {smallbeep};
            end;
          end else begin
            if walkcsr>0 then dec(walkcsr);
            if walkcsr<walkoffset then begin
              dec(walkoffset); __copyscn(
                x1 + 1, y1 + 1, x2 - 1, y2 - 4, x1 + 1, y1 + 2
              );
              __write(x1 + 1, y1 + 1, panel_f, panel_b,
                __juststr(' ' + copy(nodedispptr^[walkoffset], 1, x2 - x1 - 1),
                ' ', x2 - x1 - 1, _left_just_str)
              )
            end;
          end; { status }
        end;


        _down, _paddown: begin
          if statusflags._scrollstate then begin
            if statusflags._capsstate then begin
              if (y2<_currows - 2) then begin
                __copyscn(x1, y1, x2, y2, x1, y1 + 1);
                {__partscn(scn4, x1, y1, x2, y1, true);}
                inc(y1); inc(y2);
              end else {smallbeep};
            end else begin
              if y2 < _currows - 2 then begin
                __copyscn(x1, y2 - 2, x2, y2, x1, y2 - 1);
                __write(x1, y2 - 2, panel_f, panel_b, '║');
                __write(x2, y2 - 2, panel_f, panel_b, '║');
                inc(y2); newtreeoff := true; inc(page); jump_curpath;
              end else {smallbeep};
            end;
          end else begin
            if walkcsr < nodenumber-1 then inc(walkcsr);
            if walkcsr >= walkoffset + page then begin
              inc(walkoffset);
              __copyscn(x1 + 1, y1 + 2, x2 - 1, y2 - 3, x1 + 1, y1 + 1);
              __write(x1 + 1, y2 - 3, panel_f, panel_b,
                __juststr(' ' + copy(nodedispptr^[walkoffset + page - 1],
                  1, x2 - x1 - 1), ' ', x2 - x1 - 1, _left_just_str)
                )
            end;
          end; { status }
        end;


        _left, _padleft: begin
          if statusflags._scrollstate then begin
            if statusflags._capsstate then begin
              if (x1>1) then begin
                __copyscn(x1, y1, x2, y2, x1 - 1, y1);
                {__partscn(scn4, x2, y1, x2, y2, true);}
                dec(x1); dec(x2);
              end else {smallbeep};
            end else begin
              if x2>x1 + 14 then begin
                {__partscn(scn4, x2, y1, x2, y2, true);}
                dec(x2); fullscnlen := x2 - x1 - 1;
                if x2 - x1 + 1<30 then begin
                  fullwide := false; horspace := ' '; horbar := '─';
                end;
                newtreeoff := true; build_tree(true);
              end;
            end;
          end else begin
            walkcsr := nodearray^[walkcsr].parent;
            if walkcsr<walkoffset then walkoffset := walkcsr;
            newtreeoff := true;
          end;
        end;

        _right, _padright: begin
          if statusflags._scrollstate then begin
            if statusflags._capsstate then begin
              if (x2<_curcolumns) then begin
                __copyscn(x1, y1, x2, y2, x1 + 1, y1);
                {__partscn(scn4, x1, y1, x1, y2, true);}
                inc(x1); inc(x2);
              end else {smallbeep};
            end else begin
              if x2<80 then begin
                inc(x2); fullscnlen := x2 - x1 - 1; newtreeoff := true;
                if x2 - x1 + 1>=30 then fullwide := true
              end;
            end;
          end else begin
            jj := 0;
            while (jj<=nodenumber) and (nodearray^[jj].parent<>walkcsr) do
              inc(jj);
            if (
              (jj>0) and (jj<nodenumber) and
              (nodearray^[jj].parent=walkcsr)
            ) then walkcsr := jj else
              if walkcsr < nodenumber-1 then inc(walkcsr);
            if walkcsr > walkoffset + page - 1 then
              walkoffset := walkcsr-page+1;
            newtreeoff := true;
          end;
        end;

        _pgdn, _padpgdn: begin
          inc(walkcsr, page div 2);
          if walkcsr = walkoffset + page then walkcsr := walkoffset + page - 1;
          if walkcsr >= nodenumber then begin
            walkcsr := nodenumber - 1;
            if nodenumber - 1 >= page then
              walkoffset := walkcsr - page + 1 else walkoffset := 0;
          end else if walkcsr > walkoffset + page - 1 then
            walkoffset := walkcsr - page + 1;
          newtreeoff := true;
          if walkcsr >= nodenumber then walkcsr := nodenumber - 1;
        end;

        _pgup, _padpgup: begin
          dec(walkcsr, page div 2);
          if walkcsr<walkoffset then walkoffset := walkcsr; newtreeoff := true;
          if walkcsr<1 then walkcsr := 1; if walkoffset<0 then walkoffset := 0;
        end;

        _end, _padend: begin
          walkcsr := nodenumber -1;
          walkoffset := nodenumber - page; newtreeoff := true;
          if nodenumber - 1 < page then walkoffset := 0;
        end;

        _home, _padhome: begin
          walkcsr := 0; walkoffset := 0; newtreeoff := true;
        end;

        _padminus: begin
          if walkcsr>0 then begin
            if prevpresent(walkcsr) then begin
              walkcsr := calcprev(walkcsr);
              if walkcsr<0 then begin walkcsr := 0; walkoffset := 0 end;
              if walkcsr<walkoffset then walkoffset := walkcsr;
              newtreeoff := true;
            end
          end else walkcsr := 0;
        end;

        _padplus: begin
          if succpresent(walkcsr) then begin
            walkcsr := calcsucc(walkcsr);
            if (walkcsr > nodenumber) then begin
              walkcsr := nodenumber;
              if nodenumber >= page then
                walkoffset := walkcsr - page + 1 else
                walkoffset := 0;
            end else if walkcsr>walkoffset + page - 1 then
              walkoffset := walkcsr - page + 1; newtreeoff := true;
            if walkcsr > nodenumber then walkcsr := nodenumber;
          end;
        end;

        { := (key <> __keyword(_keys(ar(returnkeys)^[2])));}
        else retkeypressed := (key <> ar(returnkeys)^[2]);
      end; { case }

      if key = ar(returnkeys)^[2] then begin
        new(tmpscn); __savscn(tmpscn); done; init;
        __bandwin(true, x3, y3, x4, y4, popup_f, popup_b, sh_default, 2);
        newtreeoff := true; walkoffset := 0; walkcsr := 0;
        __betwscn(x3, x4, y3, popup_f, popup_b, ' Scanning tree ');
        trace_tree; save_tree(checkdriv + treeinfofile + drivechar);
        build_tree(true);
        __resscn(tmpscn); dispose(tmpscn); jump_curpath;
      end;
      if autoscan and __direction(retkey) then begin
        retkeypressed := true; retkey := _enter;
      end;

    until retkeypressed;

    __betwscn(x1, x2, y1, panel_f, panel_b, ' Tree ');
    pathpointer := disptreecursor(walkcsr, true);
    if (key = ar(returnkeys)^[3]) or (autoscan) then
      walk_tree_ := pathpointer else walk_tree_ := '';
    retkey := key;
  end; { walk_tree_ }





end. { unit }