synedittextbuffer.pas

DBDesigner 4 is a database design system that integrates database design, modelling, creation and ma

end;

procedure TSynEditStringList.SetWordWrap(const Value: boolean);
begin
  if fWordWrap <> Value then begin
    FWordWrap := Value;
    if Value
      then DoWordWrap
      else DoWordUnWrap;
  end;
end;

{ Return wraping of all lines }
procedure TSynEditStringList.DoWordUnWrap;
begin
  DoUnWrapLines(0, fCount - 1);
end;

{ Wrap all lines }
procedure TSynEditStringList.DoWordWrap;
begin
  DoWrapLines(0, fCount - 1);
end;

{ wrap lines in visible windows - for write changing}
procedure TSynEditStringList.DoWrapLines(const FromLine: Integer; const ToLine: Integer);
var
  i: Integer;
begin
  BeginUpdate;
  try
    for i := ToLine downto FromLine do
      WrapLine(i);
  finally
    EndUpdate;
  end;
end;

procedure TSynEditStringList.DoUnWrapLines(const FromLine, ToLine: Integer);
var
  i : Integer;
  s : string;
begin
  BeginUpdate;
  try
    s := '';
    for i := ToLine downto FromLine do begin
      if (sfWrapped in fList^[i].fFlags) then begin
        s := Strings[i] + s;
        Delete(i);
      end
      else begin
        with fList^[i] do begin
          fString := fString + s;
          fExpandedLength := -1;
          fFlags := [sfExpandedLengthUnknown];
        end;
        s := '';
      end;
    end;
  finally
    EndUpdate;
  end;
end;

function TSynEditStringList.ReWrapLine(const LineNumber: Integer): Integer;
var
  i, LineBegin, LineEnd : Integer;
  s : string;
begin
  Result := LineNumber;
  if not fWordWrap then Exit;
  BeginUpdate;
  { first we must find begin of wraped line }
  LineBegin := LineNumber;
  while (LineBegin >= 0) and (sfWrapped in fList^[LineBegin].fFlags) do Dec(LineBegin);
  Result := LineBegin;
  { now we find end of wraped line }
  LineEnd := LineNumber;
  while (LineEnd < fCount - 1) and (sfWrapped in fList^[LineEnd + 1].fFlags) do Inc(LineEnd);
  { and we make back one long line }
  s := '';
  for i := LineEnd downto LineBegin do begin
    if (sfWrapped in fList^[i].fFlags) then begin
      s := Strings[i] + s;
      Delete(i);
    end
    else fList^[i].fString := fList^[i].fString + s;
  end;
  { finally wrap this line again }
  WrapLine(LineBegin);
  EndUpdate;
end;

procedure TSynEditStringList.WrapLine(const LineNumber: Integer);
var
  s, s1: string;
  tmpIndex: Integer;
begin
  s := fList^[LineNumber].fString;
  with fList^[LineNumber] do begin
    fString := WrapString(s);
    fExpandedLength := -1;
    fFlags := [sfExpandedLengthUnknown];
  end;
  if Length(s) > 0 then begin
    s1 := s;
    tmpIndex := LineNumber ;
    while Length(s1) > 0 do begin
      Inc(tmpIndex);
      if fCount = fCapacity then
        Grow;
      if tmpIndex < fCount then begin
        System.Move(fList^[tmpIndex], fList^[tmpIndex + 1],
        (fCount - tmpIndex) * SynEditStringRecSize);
      end;
      with fList^[tmpIndex] do begin
        Pointer(fString) := nil;
        fString := WrapString(s1);
        fObject := nil;
        fRange := NullRange;
        fExpandedLength := -1;
        fFlags := [sfExpandedLengthUnknown, sfWrapped];
      end;
      Inc(fCount);
    end;
  end;
  fIndexOfLongestLine := -1;
end;

function TSynEditStringList.IsLineWraped(const LineNumber: Integer): Boolean;
begin
  Result := sfWrapped in fList^[LineNumber].fFlags;
end;
{end}                                                                           //Fiala 2001-12-17

{ TSynEditUndoItem }

procedure TSynEditUndoItem.Assign(Source: TPersistent);
begin
  if (Source is TSynEditUndoItem) then
  begin
    fChangeReason:=TSynEditUndoItem(Source).fChangeReason;
    fChangeSelMode:=TSynEditUndoItem(Source).fChangeSelMode;
    fChangeStartPos:=TSynEditUndoItem(Source).fChangeStartPos;
    fChangeEndPos:=TSynEditUndoItem(Source).fChangeEndPos;
    fChangeStr:=TSynEditUndoItem(Source).fChangeStr;
    fChangeNumber:=TSynEditUndoItem(Source).fChangeNumber;
  end
  else
    inherited Assign(Source);
end;


{ TSynEditUndoList }

constructor TSynEditUndoList.Create;
begin
  inherited Create;
  fItems := TList.Create;
  fMaxUndoActions := 1024;
  fNextChangeNumber := 1;                                                       //sbs 2000-11-19
end;

destructor TSynEditUndoList.Destroy;
begin
  Clear;
  fItems.Free;
  inherited Destroy;
end;

procedure TSynEditUndoList.Assign(Source: TPersistent);
var
  i: Integer;
  UndoItem: TSynEditUndoItem;
begin
  if (Source is TSynEditUndoList) then
  begin
    Clear;
    for i:=0 to TSynEditUndoList(Source).fItems.Count-1 do
    begin
      UndoItem:=TSynEditUndoItem.Create;
      UndoItem.Assign(TSynEditUndoList(Source).fItems[i]);
      fItems.Add(UndoItem);
    end;
    fBlockChangeNumber:=TSynEditUndoList(Source).fBlockChangeNumber;
    fBlockCount:=TSynEditUndoList(Source).fBlockCount;
    fFullUndoImposible:=TSynEditUndoList(Source).fFullUndoImposible;
    fLockCount:=TSynEditUndoList(Source).fLockCount;
    fMaxUndoActions:=TSynEditUndoList(Source).fMaxUndoActions;
    fNextChangeNumber:=TSynEditUndoList(Source).fNextChangeNumber;
  end
  else
    inherited Assign(Source);
end;

procedure TSynEditUndoList.AddChange(AReason: TSynChangeReason; AStart,
  AEnd: TPoint; ChangeText: string; SelMode: TSynSelectionMode);
var
  NewItem: TSynEditUndoItem;
begin
  if fLockCount = 0 then begin
    NewItem := TSynEditUndoItem.Create;
    try
      with NewItem do begin
        fChangeReason := AReason;
        fChangeSelMode := SelMode;
        fChangeStartPos := AStart;
        fChangeEndPos := AEnd;
        fChangeStr := ChangeText;
{begin}                                                                         //sbs 2000-11-19
        if fBlockChangeNumber <> 0 then
          fChangeNumber := fBlockChangeNumber
        else begin
          fChangeNumber := fNextChangeNumber;
          if fBlockCount = 0 then begin
            Inc(fNextChangeNumber);
            if fNextChangeNumber = 0 then
              Inc(fNextChangeNumber);
          end;
        end;
{end}                                                                           //sbs 2000-11-19
      end;
      PushItem(NewItem);
    except
      NewItem.Free;
      raise;
    end;
  end;
end;

{begin}                                                                         //sbs 2000-11-19
procedure TSynEditUndoList.BeginBlock;
begin
  Inc(fBlockCount);
  fBlockChangeNumber := fNextChangeNumber;
end;
{end}                                                                           //sbs 2000-11-19

procedure TSynEditUndoList.Clear;
var
  i: integer;
begin
  for i := 0 to fItems.Count - 1 do
    TSynEditUndoItem(fItems[i]).Free;
  fItems.Clear;
  fFullUndoImposible := FALSE;                                                  //mh 2000-10-03
end;

{begin}                                                                         //sbs 2000-11-19
procedure TSynEditUndoList.EndBlock;
var
  iBlockID: integer;
begin
  if fBlockCount > 0 then begin
    Dec(fBlockCount);
    if fBlockCount = 0 then begin
      iBlockID := fBlockChangeNumber;
      fBlockChangeNumber := 0;
      Inc(fNextChangeNumber);
      if fNextChangeNumber = 0 then
        Inc(fNextChangeNumber);
      if (fItems.Count > 0) and (PeekItem.ChangeNumber = iBlockID) and
        Assigned(OnAddedUndo) then
      begin
        OnAddedUndo( Self );
      end;
    end;
  end;
end;
{end}                                                                           //sbs 2000-11-19

procedure TSynEditUndoList.EnsureMaxEntries;
var
  Item: TSynEditUndoItem;
begin
  if fItems.Count > fMaxUndoActions then begin                                  //mh 2000-10-03
    fFullUndoImposible := TRUE;                                                 //mh 2000-10-03
    while fItems.Count > fMaxUndoActions do begin
      Item := fItems[0];
      Item.Free;
      fItems.Delete(0);
    end;
  end;
end;

function TSynEditUndoList.GetCanUndo: boolean;
begin
  Result := fItems.Count > 0;
end;

function TSynEditUndoList.GetItemCount: integer;
begin
  Result := fItems.Count;
end;

procedure TSynEditUndoList.Lock;
begin
  Inc(fLockCount);
end;

function TSynEditUndoList.PeekItem: TSynEditUndoItem;
var
  iLast: integer;
begin
  Result := nil;
  iLast := fItems.Count - 1;
  if iLast >= 0 then
    Result := fItems[iLast];
end;

function TSynEditUndoList.PopItem: TSynEditUndoItem;
var
  iLast: integer;
begin
  Result := nil;
  iLast := fItems.Count - 1;
  if iLast >= 0 then begin
    Result := fItems[iLast];
    fItems.Delete(iLast);
  end;
end;

procedure TSynEditUndoList.PushItem(Item: TSynEditUndoItem);
begin
  if Assigned(Item) then begin
    fItems.Add(Item);
    EnsureMaxEntries;
    if (Item.ChangeReason<>crGroupBreak) and Assigned(OnAddedUndo) then         //ek 2000-11-04
      OnAddedUndo(Self);
  end;
end;

procedure TSynEditUndoList.SetMaxUndoActions(Value: integer);
begin
  if Value < 0 then
    Value := 0;
  if Value <> fMaxUndoActions then begin
    fMaxUndoActions := Value;
    EnsureMaxEntries;
  end;
end;

procedure TSynEditUndoList.Unlock;
begin
  if fLockCount > 0 then
    Dec(fLockCount);
end;

function TSynEditUndoList.LastChangeReason: TSynChangeReason;
begin
  if fItems.Count = 0 then
    result := crNothing
  else
    result := TSynEditUndoItem(fItems[fItems.Count - 1]).fChangeReason;
end;


procedure TSynEditUndoList.AddGroupBreak;
begin
  //Add the GroupBreak even if ItemCount = 0. Since items are stored in
  //reverse order in TCustomSynEdit.fRedoList, a GroupBreak could be lost.
  if LastChangeReason <> crGroupBreak then
    AddChange(crGroupBreak, Point(0,0), Point(0,0), '', smNormal);
end;

procedure TSynEditUndoList.SetInitialState(const Value: boolean);
begin
  if Value then
  begin
    if ItemCount = 0 then
      fInitialChangeNumber := 0
    else
      fInitialChangeNumber := PeekItem.ChangeNumber;
  end
  else
    if ItemCount = 0 then
    begin
      if fInitialChangeNumber = 0 then
        fInitialChangeNumber := -1;
    end
    else if PeekItem.ChangeNumber = fInitialChangeNumber then
      fInitialChangeNumber := -1;
end;

function TSynEditUndoList.GetInitialState: boolean;
begin
  if ItemCount = 0 then
    Result := fInitialChangeNumber = 0
  else
    Result := PeekItem.ChangeNumber = fInitialChangeNumber;
end;

end.