idftplistoutput.pas

photo.163.com 相册下载器 多线程下载

      Result := 0;
    end;
  end;
  if Result=0 then
  begin
    Result := RawSortAscFName (AItem1, AItem2);
  end;
end;

function RawSortDescSize(AItem1, AItem2: TObject): Integer;
begin
  Result := -RawSortAscSize(AItem1,AItem2,False);
end;

{DirEntry objects}
function DESortAscFName(AItem1, AItem2: TObject): Integer;
var L1, L2 : TDirEntry;
begin
  L1 := TDirEntry(AItem1);
  L2 := TDirEntry(AItem2);
  Result := -IndyCompareStr(L1.PathName,L2.PathName);
end;

function DESortAscMTime(AItem1, AItem2: TObject): Integer;
var L1, L2 : TIdFTPListItem;   
{
> 0 (positive)	Item1 is less than Item2
   0	Item1 is equal to Item2
< 0 (negative)	Item1 is greater than Item2
}
begin
  L1 := TDirEntry(AItem1).DirListItem;
  L2 := TDirEntry(AItem2).DirListItem;
  if L1.ModifiedDate > L2.ModifiedDate then
  begin
    Result := -1;
  end
  else
  begin
    if L1.ModifiedDate = L2.ModifiedDate then
    begin
      Result := 0;
    end
    else
    begin
      Result := 1;
    end;
  end;
  if Result = 0 then
  begin
    Result := DESortAscFName(AItem1,AItem2);
  end;
end;

function DESortDescMTime(AItem1, AItem2: TObject): Integer;
begin
  Result := -DESortAscMTime(AItem1,AItem2);
end; 


function DESortDescFName(AItem1, AItem2: TObject): Integer;
begin
  Result := -DESortAscFName(AItem1, AItem2);
end;

{stringlist objects}
function StrSortAscMTime(List: TIdStringList; Index1, Index2: Integer): Integer;
var L1, L2 : TIdFTPListItem;
begin
  L1 := TIdFTPListItem(List.Objects[Index1]);
  L2 := TIdFTPListItem(List.Objects[Index2]);
  Result := RawSortAscMTime(L1,L2);
end;

function StrSortDescMTime(List: TIdStringList; Index1, Index2: Integer): Integer;
var L1, L2 : TIdFTPListItem;
begin
  L1 := TIdFTPListItem(List.Objects[Index1]);
  L2 := TIdFTPListItem(List.Objects[Index2]);
  Result := RawSortDescMTime(L1,L2);
end;

function StrSortAscSize(List: TIdStringList; Index1, Index2: Integer): Integer;
var L1, L2 : TIdFTPListItem;
begin
  L1 := TIdFTPListItem(List.Objects[Index1]);
  L2 := TIdFTPListItem(List.Objects[Index2]);
  Result := RawSortAscSize(L1,L2);
end;

function StrSortDescSize(List: TIdStringList; Index1, Index2: Integer): Integer;
var L1, L2 : TIdFTPListItem;
begin
  L1 := TIdFTPListItem(List.Objects[Index1]);
  L2 := TIdFTPListItem(List.Objects[Index2]);
  Result := RawSortDescSize(L1,L2);
end;

function StrSortAscFName(List: TIdStringList; Index1, Index2: Integer): Integer;
var L1, L2 : TIdFTPListItem;
begin
  L1 := TIdFTPListItem(List.Objects[Index1]);
  L2 := TIdFTPListItem(List.Objects[Index2]);
  Result := RawSortAscFName(L1,L2);
end;

function StrSortDescFName(List: TIdStringList; Index1, Index2: Integer): Integer;
var L1, L2 : TIdFTPListItem;
begin
  L1 := TIdFTPListItem(List.Objects[Index1]);
  L2 := TIdFTPListItem(List.Objects[Index2]);
  Result := RawSortDescFName(L1,L2);
end;

function StrSortAscFNameExt(List: TIdStringList; Index1, Index2: Integer): Integer;
var L1, L2 : TIdFTPListItem;
begin
  L1 := TIdFTPListItem(List.Objects[Index1]);
  L2 := TIdFTPListItem(List.Objects[Index2]);
  Result := RawSortAscFNameExt(L1,L2);
end;

function StrSortDescFNameExt(List: TIdStringList; Index1, Index2: Integer): Integer;
var L1, L2 : TIdFTPListItem;
begin
  L1 := TIdFTPListItem(List.Objects[Index1]);
  L2 := TIdFTPListItem(List.Objects[Index2]);
  Result := RawSortDescFNameExt(L1,L2);
end;

{ TIdFTPListOutput }

function TIdFTPListOutput.Add: TIdFTPListOutputItem;
begin
  Result := TIdFTPListOutputItem( inherited Add);
end;

constructor TIdFTPListOutput.Create;
begin
  inherited Create(TIdFTPListOutputItem);
  FDirFormat := doUnix;
end;

function TIdFTPListOutput.EPLFItem(AItem: TIdFTPListOutputItem): String;
var LFileName : String;
begin
  LFileName := IndyGetFileName(AItem.FileName);
  if AItem.ModifiedDateGMT > EPLF_BASE_DATE then
  begin
        Result := '+m'+GMTDateTimeToEPLFDate(AItem.ModifiedDateGMT);
  end
  else
  begin
    if AItem.ModifiedDate > EPLF_BASE_DATE then
    begin
      Result := '+m'+LocalDateTimeToEPLFDate(AItem.ModifiedDate);
    end;
  end;
  if AItem.ItemType = ditFile then
  begin
        Result := Result + ',r';
  end
  else
  begin
        Result := Result + ',/';
  end;
  Result := Result + ',s'+IntToStr(AItem.Size);
  Result := Result + #9 + LFileName;
end;

function TIdFTPListOutput.GetItems(AIndex: Integer): TIdFTPListOutputItem;
begin
  Result := TIdFTPListOutputItem( inherited GetItem(AIndex));
end;

function TIdFTPListOutput.GetLocalModTime(
  AItem: TIdFTPListOutputItem): TDateTime;
begin
  if AItem.ModifiedDateGMT<>0 then
  begin
    Result := AItem.ModifiedDateGMT - TimeZoneBias;
  end
  else
  begin
    Result := AItem.ModifiedDate;
  end;
end;

function TIdFTPListOutput.IndexOf(AItem: TIdFTPListOutputItem): Integer;
Var
  i: Integer;
begin
  result := -1;
  for i := 0 to Count - 1 do
    if AItem = Items[i] then begin
      result := i;
      break;
    end;
end;

procedure TIdFTPListOutput.InternelOutputDir(AOutput: TIdStrings;
  ADetails: Boolean);
type TIdDirOutputType = (doColsAccross, doColsDown, doOneCol, doOnlyDirs, doComma, doLong);

var i : Integer;
//    LIdx : Integer;
//    LBlockCount : Integer;
    //note we use this for sorting pathes with recursive dirs
    LRootPath : TDirEntry;
    LShowNavSym : BOolean;

    function DetermineOp : TIdDirOutputType;
    //we do things this way because the last switch in a mutually exclusive set
    //always takes precidence over the others.
    var
        LStopScan : Boolean;
        i : Integer;
    begin
      if ADetails then
      begin
        Result := doLong;
      end
      else
      begin
        Result := doOneCol;
      end;
      if DirFormat <> doUnix then
      begin
        Exit;
      end;

      LStopScan := False;
      for i := Length(Switches) downto 1 do
      begin
        case Switches[i] of
          SWITCH_COLS_ACCROSS : begin
                  Result := doColsAccross;
                  LStopScan := True;
                end;
          SWITCH_COLS_DOWN : begin
                  Result := doColsDown;
                  LStopScan := True;
                end;
          SWITCH_ONE_COL : begin
                  Result := doOneCol;
                  LStopScan := True;
                end;
          SWITCH_ONE_DIR : begin
                  Result := doOnlyDirs;
                  LStopScan := True;
                end;
          SWITCH_COMMA_STREAM : begin
                  Result := doComma;
                  LStopScan := True;
                end;
          SWITCH_LONG_FORM : begin
                  Result := doLong;
                  LStopScan := True;
                end;
        end;
        if LStopScan then
        begin
          break;
        end;
      end;
    end;

    procedure PrintSubDirHeader(ARoot, ACurDir : TDirEntry; AOutput : TIdStrings; const Recurse : Boolean = False);
    var LUnixPrependPath : Boolean;
    begin
       LUnixPrependPath := (IndyPos(SWITCH_SORT_REVERSE,Switches)>0) or (IndyPos(SWITCH_SORTBY_MTIME,Switches)>0)
         or (DetermineOp<>doLong);
        if (ACurDir <> ARoot) or LUnixPrependPath then
        begin
          //we don't want an empty line to start the list
          if (ACurDir <> ARoot) then
          begin
            AOutput.Add('');
          end;
          if Self.DirFormat = doWin32 then
          begin
            AOutput.Add(MS_DOS_CURDIR + UnixPathToDOSPath(ACurDir.PathName)+':');
          end
          else
          begin
            if LUnixPrependPath then
            begin
              if ACurDir = ARoot then
              begin
                AOutput.Add(CUR_DIR+':')
              end
              else
              begin
                AOutput.Add(UNIX_CURDIR + DOSPathToUnixPath (ACurDir.PathName)+':');
              end;
            end
            else
            begin
              AOutput.Add(DOSPathToUnixPath (ACurDir.PathName)+':');
            end;
          end;
        end;
    end;

    procedure ProcessOnePathCol(ARoot, ACurDir : TDirEntry; AOutput : TIdStrings; const Recurse : Boolean = False);
    var i : Integer;
      LCurItem : TIdFTPListOutputItem;
    begin
      if Recurse and Assigned(ACurDir.SubDirs) then
      begin
        if Recurse then
        begin
          PrintSubDirHeader(ARoot,ACurDir,AOutput,Recurse);
        end;
      end;
      for i := 0 to ACurDir.FileList.Count -1 do
      begin
        AOutput.Add(NListItem(TIdFTPListOutputItem(ACurDir.FileList.Objects[i])));
      end;
      if Recurse and Assigned(ACurDir.SubDirs) then
      begin
        for i := 0 to ACurDir.SubDirs.Count -1 do
        begin
          LCurItem := TDirEntry(ACurDir.SubDirs[i]).DirListItem;
          if LCurItem.DirError then
          begin
            if i = 0 then
            begin
              AOutput.Add('');
            end;
            AOutput.Add(Format('/bin/ls: %s: Permission denied', [LCurItem.FileName])); {do not localize}
          end
          else
          begin
            ProcessOnePathCol(ARoot,TDirEntry(ACurDir.SubDirs[i]),AOutput,Recurse);
          end;
        end;
      end;
    end;

    function CalcMaxLen(ARoot, ACurDir : TDirEntry; AOutput : TIdStrings; const Recurse : Boolean = False) : Integer;
    var LEntryMaxLen : Integer;
        i : Integer;
    begin
      Result := 0;
      for i := 0 to ACurDir.FileList.Count -1 do
      begin
        LEntryMaxLen := Length(NListItem(TIdFTPListOutputItem(ACurDir.FileList.Objects[i])) );
        if LEntryMaxLen > Result then
        begin
          Result := LEntryMaxLen;
        end;
      end;
      if Recurse and Assigned(ACurDir.SubDirs) then
      begin
        for i := 0 to ACurDir.SubDirs.Count -1 do
        begin
          LEntryMaxLen := CalcMaxLen(ARoot,TDirEntry(ACurDir.SubDirs[i]),AOutput,Recurse);
          if LEntryMaxLen > Result then
          begin
            Result := LEntryMaxLen;
          end;
        end;
      end;
    end;

    procedure ProcessPathAccross(ARoot, ACurDir : TDirEntry; AOutput : TIdStrings; const Recurse : Boolean = False);
    var i, j : Integer;
        LTmp : String;
        LMaxLen : Integer;
        LCols : Integer;
        LCurItem : TIdFTPListOutputItem;
    begin
      if ACurDir.FileList.Count = 0 then
      begin
        Exit;
      end;
    //Note that we will assume a console width of 80 and we don't want something to wrap
    //causing a blank line
      LMaxLen := CalcMaxLen(ARoot, ACurDir, AOutput, Recurse);
      //if more than 39, we probably are going to exceed the width of the screen,
      //just treat as one column
      if (LMaxLen > 39) then
      begin
        ProcessOnePathCol(ARoot, ACurDir, AOutput, Recurse);
        Exit;
      end;
      if Recurse and Assigned(ACurDir.SubDirs) then
      begin
        if Recurse then
        begin
          PrintSubDirHeader(ARoot,ACurDir,AOutput,Recurse);
        end;
      end;
      LCols := 79 div (LMaxLen + 2);//2 spaces between columns
      j := 0;
      repeat
        LTmp := '';
        for i := 0 to LCols -1 do
        begin
          LTmp := LTmp + PadSpaces(NListItem(TIdFTPListOutputItem(ACurDir.FileList.Objects[j])),LMaxLen)+'  ';
          Inc(j);
          if j = ACurDir.FileList.Count then
          begin
            Break;
          end;
        end;
        AOutput.Add(TrimRight(LTmp));
      until (j = ACurDir.FileList.Count);

      if Recurse and Assigned(ACurDir.SubDirs) then
      begin
        for i := 0 to ACurDir.SubDirs.Count -1 do
        begin
          LCurItem := TDirEntry(ACurDir.SubDirs[i]).DirListItem;
          if LCurItem.DirError then
          begin
            if i = 0 then
            begin
              AOutput.Add('');
            end;
            AOutput.Add(Format('/bin/ls: %s: Permission denied', [LCurItem.FileName])); {do not localize}
          end
          else
          begin
            ProcessPathAccross(ARoot, TDirEntry(ACurDir.SubDirs[i]), AOutput, Recurse);
          end;
        end;
      end;
    end;

    procedure ProcessPathDown(ARoot, ACurDir : TDirEntry; AOutput : TIdStrings; const Recurse : Boolean = False);
    var i, j : Integer;
        LTmp : String;
        LMaxLen : Integer;
        LCols : Integer;
        LLines : Integer;
        LFrm : String;
        LCurItem : TIdFTPListOutputItem;
    begin
      LFrm := '';
      if ACurDir.FileList.Count = 0 then
      begin
        Exit;
      end;
    //Note that we will assume a console width of 80 and we don't want something to wrap
    //causing a blank line
      LMaxLen := CalcMaxLen(ARoot, ACurDir, AOutput, Recurse);
      //if more than 39, we probably are going to exceed the width of the screen,