syneditcodefolding.pas

SynEditStudio delphi 代码编辑器

begin
  if not Assigned(fAllRanges) then Exit;                    //###mod memory leak
  for i := 0 to fAllRanges.Count-1 do TObject(fAllRanges[i]).Free();//###mod memory leak
  fAllRanges.Clear();
end;

constructor TSynEditAllFoldRanges.Create;
begin
  inherited;
	fAllRanges := TList.Create;
end;

procedure TSynEditAllFoldRanges.Delete(Index: Integer);
begin
	fAllRanges.Delete(Index);
end;

destructor TSynEditAllFoldRanges.Destroy;
var i: Integer;                                                //###mod memory leak
begin
  if not Assigned(fAllRanges) then Exit;                       //###mod memory leak
  for i := 0 to fAllRanges.Count - 1 do TObject(fAllRanges[i]).Free();//###mod memory leak
  FreeAndNil(fAllRanges);                                      //###mod memory leak
	inherited;
	//fAllRanges.Free;                                           //###mod memory leak
end;

function TSynEditAllFoldRanges.GetAllCount: Integer;
begin
	Result := fAllRanges.Count;
end;

function TSynEditAllFoldRanges.GetAllFoldRange(
  Index: Integer): TSynEditFoldRange;
begin
	Result := fAllRanges[Index];
end;

{ TSynEditFoldRanges }

function TSynEditFoldRanges.Add(AAllFold: TSynEditAllFoldRanges; AFromLine,
	ALevel, ARealLevel: Integer; AFoldRegion: TFoldRegionItem;
  AToLine: Integer): TSynEditFoldRange;
begin
	Result := TSynEditFoldRange.Create;
  Result.fFromLine := AFromLine;
  Result.fToLine := AToLine;
  Result.fLevel := ALevel;
  Result.fRealLevel := ARealLevel;
  Result.fAllFoldRanges := AAllFold;
  Result.fFoldRegion := AFoldRegion;
  fRanges.Add(Result);
  AAllFold.fAllRanges.Add(Result);
end;

procedure TSynEditFoldRanges.AddF(FoldRange: TSynEditFoldRange);
begin
	fRanges.Add(FoldRange);
end;

procedure TSynEditFoldRanges.Clear;
begin
	fRanges.Clear;
end;

constructor TSynEditFoldRanges.Create;
begin
	fRanges := TList.Create;
end;

destructor TSynEditFoldRanges.Destroy;
begin
  fRanges.Free;
  inherited;
end;

function TSynEditFoldRanges.GetCount: Integer;
begin
	Result := fRanges.Count;
end;

function TSynEditFoldRanges.GetSynEditFoldRange(
  Index: Integer): TSynEditFoldRange;
begin
	Result := fRanges[Index];
end;

{ TSynEditFoldRange }

function TSynEditFoldRange.Collapsable: Boolean;
begin
	Result := fFromLine <> fToLine;
end;

constructor TSynEditFoldRange.Create;
begin
	fSubFoldRanges := TSynEditFoldRanges.Create;
  fCollapsedLines := TStringList.Create;
  fCollapsedBy := -1;
end;

destructor TSynEditFoldRange.Destroy;
begin
  fSubFoldRanges.Free;
  fCollapsedLines.Free;
  inherited;
end;

procedure TSynEditFoldRange.MoveBy(LineCount: Integer);
begin
	Inc(fFromLine, LineCount);
  Inc(fToLine, LineCount);
end;

procedure TSynEditFoldRange.MoveChildren(By: Integer);
var
	i: Integer;
begin
	for i := 0 to fSubFoldRanges.Count - 1 do
  begin
  	fSubFoldRanges[i].MoveChildren(By);
    
  	with fAllFoldRanges.FAllRanges do
    	if fSubFoldRanges[i].fParentCollapsed then
    		Move(IndexOf(fSubFoldRanges[i]), IndexOf(fSubFoldRanges[i]) + By);
  end;
end;

function TSynEditFoldRange.RealLinesCollapsed: Integer;
	function RealLinesCollapsedEx(FoldRange: TSynEditFoldRange): Integer;
  var
  	i: Integer;
  begin
  	Result := 0;

    with FoldRange do
  		for i := 0 to fSubFoldRanges.Count - 1 do
      begin
    		Inc(Result, RealLinesCollapsedEx(fSubFoldRanges[i]));
        
    		if fSubFoldRanges[i].fCollapsed then
      		Inc(Result, fSubFoldRanges[i].fLinesCollapsed + 1);
    	end;
  end;
begin
	Result := fLinesCollapsed + RealLinesCollapsedEx(Self);
end;

procedure TSynEditFoldRange.SetPCOfSubFoldRanges(AParentCollapsed: Boolean;
  ACollapsedBy: Integer);
var
	i: Integer;
begin
	for i := 0 to fSubFoldRanges.Count - 1 do
  begin
  	fSubFoldRanges[i].SetPCOfSubFoldRanges(AParentCollapsed, ACollapsedBy);

    if (fSubFoldRanges[i].fCollapsedBy = -1) or
    (fSubFoldRanges[i].fCollapsedBy = ACollapsedBy) then
    begin
    	fSubFoldRanges[i].fParentCollapsed := AParentCollapsed;

      if not AParentCollapsed then
      	fSubFoldRanges[i].fCollapsedBy := -1
      else
      	fSubFoldRanges[i].fCollapsedBy := ACollapsedBy;
    end;
  end;
end;

procedure TSynEditFoldRange.SetRealLevel(const Value: Integer);
var
	i: Integer;
begin
	if fParentCollapsed then
  	fCollapsedBy := Value - 1;

  fRealLevel := Value;

  for i := 0 to fSubFoldRanges.Count - 1 do
  	fSubFoldRanges[i].RealLevel := fRealLevel + 1;
end;

procedure TSynEditFoldRange.Widen(LineCount: Integer);
begin
	Inc(fToLine, LineCount);
end;

{ TStack }

constructor TStack.Create;
begin
	fFirstNode := nil;
end;

destructor TStack.Destroy;
begin
	while not IsEmpty
  	do Pop;

  inherited;
end;

function TStack.IsEmpty: Boolean;
begin
	Result := fFirstNode = nil;
end;

function TStack.Peak: Pointer;
begin
	if IsEmpty then
		Result := nil
	else
		Result := fFirstNode.fValue;
end;

function TStack.Pop: Pointer;
var
	TmpNode: TNode;
begin
	if IsEmpty then
		Result := nil
	else
  begin
		TmpNode := fFirstNode;
		Result := fFirstNode.Value;
		fFirstNode := fFirstNode.fChildNode;
		TmpNode.Free;
	end;
end;

procedure TStack.Push(Value: Pointer);
var
	Node: TNode;
begin
	Node := TNode.Create(Value);

	if not IsEmpty then
  begin
		Node.fChildNode := fFirstNode;
		fFirstNode.fParentNode := Node;
	end;

	fFirstNode := Node;
end;

{ TNode }

constructor TNode.Create(AValue: Pointer);
begin
	fValue := AValue;
	fChildNode := nil;
end;

{ TFoldRegion }

constructor TFoldRegionItem.Create(Collection: TCollection);
begin
	inherited Create(Collection);
	fSubFoldRegions := TFoldRegions.Create(TFoldRegionItem);
end;

destructor TFoldRegionItem.Destroy;
begin
  //#mod memory leak
  if fOpen <> nil then FreeMem(fOpen);
  if fClose <> nil then FreeMem(fClose);
  if fRegExpOpen <> nil then FreeMem(fRegExpOpen);
  if fRegExpClose <> nil then FreeMem(fRegExpClose);
  //#mod memory leak
	fSubFoldRegions.Free;
  inherited;
end;

{ TFoldRegions }

function TFoldRegions.Add(AType: TFoldRegionType; AAddEnding,
	ANoSubFoldRegions, AWholeWords: Boolean; AOpen, AClose: PChar;
  AParentRegion: TFoldRegionItem): TFoldRegionItem;
begin
	Result := TFoldRegionItem(inherited Add);
  Result.fType := AType;
  Result.fAddEnding := AAddEnding;
  Result.fNoSubFoldRegions := ANoSubFoldRegions;
  Result.fWholeWords := AWholeWords;
  //#mod memory leak
  //GetMem(Result.fOpen, StrLen(AOpen) + 1);
  //StrCopy(Result.fOpen, AOpen);
  Result.Open := AOpen;
  //GetMem(Result.fClose, StrLen(AClose) + 1);
  //StrCopy(Result.fClose, AClose);
  Result.Close := AClose;
  //#mod memory leak

  Result.fParentRegion := AParentRegion;
end;

constructor TFoldRegions.Create(ItemClass: TCollectionItemClass);
begin
  inherited Create(ItemClass);
	fSkipRegions := TSkipRegions.Create(TSkipRegionItem);
end;

destructor TFoldRegions.Destroy;
begin
	fSkipRegions.Free;
  inherited;
end;

function TFoldRegions.GetItem(Index: Integer): TFoldRegionItem;
begin
	Result := TFoldRegionItem(inherited Items[Index]);
end;

procedure TFoldRegionItem.SetClose(const Value: PChar);
begin
  if fClose <> nil then FreeMem(fClose); //#mod memory leak
  GetMem(fClose, StrLen(Value) + 1);
  StrCopy(fClose, Value);
end;

procedure TFoldRegionItem.SetOpen(const Value: PChar);
begin
  if fOpen <> nil then FreeMem(fOpen); //#mod memory leak
  GetMem(fOpen, StrLen(Value) + 1);
  StrCopy(fOpen, Value);
end;

procedure TFoldRegionItem.SetRegExpClose(const Value: PChar);
begin
  if fRegExpClose <> nil then FreeMem(fRegExpClose); //#mod memory leak
  GetMem(fRegExpClose, StrLen(Value) + 1);
  StrCopy(fRegExpClose, Value);
end;

procedure TFoldRegionItem.SetRegExpOpen(const Value: PChar);
begin
  if fRegExpOpen <> nil then FreeMem(fRegExpOpen); //#mod memory leak
  GetMem(fRegExpOpen, StrLen(Value) + 1);
  StrCopy(fRegExpOpen, Value);
end;

{ TSkipRegions }

function TSkipRegions.Add(const aOpen, aClose, aEscape: String;
  aType: TSkipRegionItemType): TSkipRegionItem;
var
  
  RI: TSkipRegionItem; //###mod CF bugs
begin
  RI := TSkipRegionItem(inherited Add);
  with RI do
  begin
  	Open := PChar(aOpen);
    Close := PChar(aClose);
    Escape := PChar(aEscape);
    RegionType := aType;
  end;
  Result := RI;
end;

function TSkipRegions.GetSkipRegionItem(Index: Integer): TSkipRegionItem;
begin
	Result := TSkipRegionItem(inherited Items[Index]);
end;

{ TSkipRegionItem }

procedure TSkipRegionItem.SetClose(const Value: PChar);
begin
  if Assigned(fClose) then
    FreeMem(fClose);

  GetMem(fClose, StrLen(Value) + 1);
  StrCopy(fClose, Value);
end;

procedure TSkipRegionItem.SetEscape(const Value: PChar);
begin
  //if fOpen <> nil then FreeMem(fEscape);
  if Assigned(fEscape) then FreeMem(fEscape); //#mod memory leak
  GetMem(fEscape, StrLen(Value) + 1);
  StrCopy(fEscape, Value);
end;

procedure TSkipRegionItem.SetOpen(const Value: PChar);
begin
  if Assigned(fOpen) then
    FreeMem(fOpen);

  GetMem(fOpen, StrLen(Value) + 1);
  StrCopy(fOpen, Value);
end;

destructor TSkipRegionItem.Destroy(); //#mod memory leak
begin
  inherited;
  if Assigned(fOpen) then FreeMem(fOpen);
  if Assigned(fClose) then FreeMem(fClose);
  if Assigned(fEscape) then FreeMem(fEscape);
end;

end.