jcledixml.pas

East make Tray Icon in delphi

    SetLength(FElements, Length(FElements) + I);
    // Shift
    for J := High(FElements) downto InsertIndex + I do
    begin
      FElements[J] := FElements[J - I];
      FElements[J - I] := nil;
    end;
    // Insert
    K := 0;
    for J := InsertIndex to (InsertIndex + I) - 1 do
    begin
      FElements[J] := ElementArray[K];
      FElements[J].Parent := Self;
      Inc(K);
    end;
  end
  else
    Result := AppendElements(ElementArray);
end;

function TEDIXMLSegment.InsertElements(InsertIndex, Count: Integer): Integer;
var
  I: Integer;
begin
  Result := InsertIndex;
  if (Length(FElements) > 0) and (InsertIndex >= Low(FElements)) and
    (InsertIndex <= High(FElements)) then
  begin
    // Resize
    SetLength(FElements, Length(FElements) + Count);
    // Shift
    for I := High(FElements) downto InsertIndex + Count do
    begin
      FElements[I] := FElements[I - Count];
      FElements[I - Count] := nil;
    end;
    // Insert
    for I := InsertIndex to (InsertIndex + Count) - 1 do
      FElements[I] := InternalCreateElement;
  end
  else
    Result := AddElements(Count);
end;

function TEDIXMLSegment.InternalAssignDelimiters: TEDIXMLDelimiters;
begin
  Result := nil;
  if not Assigned(FDelimiters) then // Attempt to assign the delimiters
  begin
    // Get the delimiters from the transaction set loop
    if Assigned(Parent) and (Parent is TEDIXMLTransactionSetLoop) then
    begin
      if Assigned(Parent.Delimiters) then
      begin
        Result := TEDIXMLTransactionSetLoop(Parent).ParentTransactionSet.Delimiters;
        Exit;
      end;
    end;
    // Get the delimiters from the transaction set
    if Assigned(Parent) and (Parent is TEDIXMLTransactionSet) then
    begin
      if Assigned(Parent.Delimiters) then
      begin
        Result := Parent.Delimiters;
        Exit;
      end;
      // Get the delimiters from the functional group
      if Assigned(Parent.Parent) and (Parent.Parent is TEDIXMLFunctionalGroup) then
      begin
        if Assigned(Parent.Parent.Delimiters) then
        begin
          Result := Parent.Parent.Delimiters;
          Exit;
        end;
        // Get the delimiters from the interchange control header
        if Assigned(Parent.Parent.Parent) and
          (Parent.Parent.Parent is TEDIXMLInterchangeControl) then
          if Assigned(Parent.Parent.Parent.Delimiters) then
            Result := Parent.Parent.Parent.Delimiters;
      end;
    end;
  end;
end;

function TEDIXMLSegment.InternalCreateElement: TEDIXMLElement;
begin
  Result := TEDIXMLElement.Create(Self);
end;

procedure TEDIXMLSegment.SetElement(Index: Integer; Element: TEDIXMLElement);
begin
  if Length(FElements) > 0 then
    if Index >= Low(FElements) then
      if Index <= High(FElements) then
      begin
        FreeAndNil(FElements[Index]);
        FElements[Index] := Element;
      end
      else
        raise EJclEDIError.CreateResFmt(@EDIXMLError053, [IntToStr(Index)])
    else
      raise EJclEDIError.CreateResFmt(@EDIXMLError052, [IntToStr(Index)])
  else
    raise EJclEDIError.CreateResFmt(@EDIXMLError051, [IntToStr(Index)]);
end;

//=== { TEDIXMLTransactionSetSegment } =======================================

constructor TEDIXMLTransactionSetSegment.Create(Parent: TEDIXMLDataObject);
begin
  inherited Create(Parent);
  if Assigned(Parent) and (Parent is TEDIXMLTransactionSet) then
    FParent := Parent;
end;

constructor TEDIXMLTransactionSetSegment.Create(Parent: TEDIXMLDataObject; ElementCount: Integer);
begin
  inherited Create(Parent, ElementCount);
  if Assigned(Parent) and (Parent is TEDIXMLTransactionSet) then
    FParent := Parent;
end;

function TEDIXMLTransactionSetSegment.InternalAssignDelimiters: TEDIXMLDelimiters;
begin
  Result := inherited InternalAssignDelimiters;
end;

//=== { TEDIXMLFunctionalGroupSegment } ======================================

constructor TEDIXMLFunctionalGroupSegment.Create(Parent: TEDIXMLDataObject);
begin
  inherited Create(Parent);
  if Assigned(Parent) and (Parent is TEDIXMLFunctionalGroup) then
    FParent := Parent;
end;

constructor TEDIXMLFunctionalGroupSegment.Create(Parent: TEDIXMLDataObject;
  ElementCount: Integer);
begin
  inherited Create(Parent, ElementCount);
  if Assigned(Parent) and (Parent is TEDIXMLFunctionalGroup) then
    FParent := Parent;
end;

function TEDIXMLFunctionalGroupSegment.InternalAssignDelimiters: TEDIXMLDelimiters;
begin
  Result := nil;
  // Attempt to assign the delimiters
  if not Assigned(FDelimiters) then
    // Get the delimiters from the functional group
    if Assigned(Parent) and (Parent is TEDIXMLFunctionalGroup) then
      if Assigned(Parent.Delimiters) then
        Result := Parent.Delimiters
      else
      // Get the delimiters from the interchange control
        if Assigned(Parent.Parent) and (Parent.Parent is TEDIXMLInterchangeControl) then
        Result := Parent.Parent.Delimiters;
end;

//=== { TEDIXMLInterchangeControlSegment } ===================================

constructor TEDIXMLInterchangeControlSegment.Create(Parent: TEDIXMLDataObject);
begin
  inherited Create(Parent);
  if Assigned(Parent) and (Parent is TEDIXMLInterchangeControl) then
    FParent := Parent;
end;

constructor TEDIXMLInterchangeControlSegment.Create(Parent: TEDIXMLDataObject;
  ElementCount: Integer);
begin
  inherited Create(Parent, ElementCount);
  if Assigned(Parent) and (Parent is TEDIXMLInterchangeControl) then
    FParent := Parent;
end;

function TEDIXMLInterchangeControlSegment.InternalAssignDelimiters: TEDIXMLDelimiters;
begin
  Result := nil;
  // Attempt to assign the delimiters
  if not Assigned(FDelimiters) then
    // Get the delimiters from the interchange control
    if Assigned(Parent) and (Parent is TEDIXMLInterchangeControl) then
      Result := Parent.Delimiters;
end;

//=== { TEDIXMLDataObjectGroup } =============================================

constructor TEDIXMLDataObjectGroup.Create(Parent: TEDIXMLDataObject);
begin
  inherited Create(Parent);
end;

destructor TEDIXMLDataObjectGroup.Destroy;
begin
  DeleteEDIDataObjects;
  inherited Destroy;
end;

function TEDIXMLDataObjectGroup.AddGroup: Integer;
var
  EDIGroup: TEDIXMLDataObjectGroup;
begin
  EDIGroup := InternalCreateDataObjectGroup;
  Result := AppendEDIDataObject(EDIGroup);
end;

function TEDIXMLDataObjectGroup.AddSegment: Integer;
var
  EDISegment: TEDIXMLSegment;
begin
  EDISegment := TEDIXMLSegment.Create(Self);
  Result := AppendEDIDataObject(EDISegment);
end;

function TEDIXMLDataObjectGroup.AppendEDIDataObject(EDIDataObject: TEDIXMLDataObject): Integer;
begin
  SetLength(FEDIDataObjects, Length(FEDIDataObjects) + 1);
  FEDIDataObjects[High(FEDIDataObjects)] := EDIDataObject;
  EDIDataObject.Parent := Self;
  Result := High(FEDIDataObjects);
end;

procedure TEDIXMLDataObjectGroup.DeleteEDIDataObject(EDIDataObject: TEDIXMLDataObject);
var
  I: Integer;
begin
  for I := Low(FEDIDataObjects) to High(FEDIDataObjects) do
    if FEDIDataObjects[I] = EDIDataObject then
      DeleteEDIDataObject(I);
end;

procedure TEDIXMLDataObjectGroup.DeleteEDIDataObject(Index: Integer);
var
  I: Integer;
begin
  if (Length(FEDIDataObjects) > 0) and (Index >= Low(FEDIDataObjects)) and
    (Index <= High(FEDIDataObjects)) then
  begin
    // Delete
    FreeAndNil(FEDIDataObjects[Index]);
    // Shift
    for I := Index + 1 to High(FEDIDataObjects) do
      FEDIDataObjects[I - 1] := FEDIDataObjects[I];
    // Resize
    SetLength(FEDIDataObjects, High(FEDIDataObjects));
  end
  else
    raise EJclEDIError.CreateRes(@EDIXMLError040);
end;

procedure TEDIXMLDataObjectGroup.DeleteEDIDataObjects;
var
  I: Integer;
begin
  for I := Low(FEDIDataObjects) to High(FEDIDataObjects) do
    FreeAndNil(FEDIDataObjects[I]);
  // Resize
  SetLength(FEDIDataObjects, 0);
end;

function TEDIXMLDataObjectGroup.GetEDIDataObject(Index: Integer): TEDIXMLDataObject;
begin
  if Length(FEDIDataObjects) > 0 then
    if Index >= Low(FEDIDataObjects) then
      if Index <= High(FEDIDataObjects) then
      begin
        if not Assigned(FEDIDataObjects[Index]) then
          raise EJclEDIError.CreateResFmt(@EDIXMLError039, [IntToStr(Index)]);
        Result := FEDIDataObjects[Index];
      end
      else
        raise EJclEDIError.CreateResFmt(@EDIXMLError038, [IntToStr(Index)])
    else
      raise EJclEDIError.CreateResFmt(@EDIXMLError037, [IntToStr(Index)])
  else
    raise EJclEDIError.CreateResFmt(@EDIXMLError036, [IntToStr(Index)]);
end;

function TEDIXMLDataObjectGroup.InsertEDIDataObject(InsertIndex: Integer;
  EDIDataObject: TEDIXMLDataObject): Integer;
var
  I: Integer;
begin
  Result := InsertIndex;
  if (Length(FEDIDataObjects) > 0) and (InsertIndex >= Low(FEDIDataObjects)) and
    (InsertIndex <= High(FEDIDataObjects)) then
  begin
    // Resize
    SetLength(FEDIDataObjects, Length(FEDIDataObjects) + 1);
    // Shift
    for I := High(FEDIDataObjects) downto InsertIndex + 1 do
      FEDIDataObjects[I] := FEDIDataObjects[I - 1];
    // Insert
    FEDIDataObjects[InsertIndex] := EDIDataObject;
    FEDIDataObjects[InsertIndex].Parent := Self;
  end
  else
    Result := AppendEDIDataObject(EDIDataObject);
end;

function TEDIXMLDataObjectGroup.InsertGroup(InsertIndex: Integer): Integer;
var
  EDIGroup: TEDIXMLDataObjectGroup;
begin
  EDIGroup := InternalCreateDataObjectGroup;
  Result := InsertEDIDataObject(InsertIndex, EDIGroup);
end;

function TEDIXMLDataObjectGroup.InsertSegment(InsertIndex: Integer): Integer;
var
  EDISegment: TEDIXMLSegment;
begin
  EDISegment := TEDIXMLSegment.Create(Self);
  Result := InsertEDIDataObject(InsertIndex, EDISegment);
end;

function TEDIXMLDataObjectGroup.SearchForSegmentInDataString(Id: string;
  StartPos: Integer): Integer;
var
  SegmentTag: string;
  SearchResult, SegmentTagStartPos: Integer;
  EDIXMLAttributes: TEDIXMLAttributes;
begin
  Result := 0;
  EDIXMLAttributes := TEDIXMLAttributes.Create;
  SearchResult := StrSearch(FDelimiters.BTD + XMLTag_Segment, FData, StartPos);
  SegmentTagStartPos := SearchResult;
  while SearchResult > 0 do
  begin
    SearchResult := StrSearch(FDelimiters.ETD, FData, SegmentTagStartPos);
    if SearchResult > 0 then
    begin
      SegmentTag := Copy(FData, SegmentTagStartPos, ((SearchResult - SegmentTagStartPos) +
        FDelimiters.ETDLength));
      EDIXMLAttributes.ParseAttributes(SegmentTag);
      Result := EDIXMLAttributes.CheckAttribute(XMLAttribute_Id, Id);
      if Result >= 0 then
      begin
        Result := SegmentTagStartPos;
        Break;
      end;
    end;
    SegmentTagStartPos := SearchResult + FDelimiters.ETDLength;
    SearchResult := StrSearch(FDelimiters.BTD + XMLTag_Segment, FData, SegmentTagStartPos);
  end;
  EDIXMLAttributes.Free;
end;

procedure TEDIXMLDataObjectGroup.SetEDIDataObject(Index: Integer; EDIDataObject: TEDIXMLDataObject);
begin
  if Length(FEDIDataObjects) > 0 then
    if Index >= Low(FEDIDataObjects) then
      if Index <= High(FEDIDataObjects) then
      begin
        FreeAndNil(FEDIDataObjects[Index]);
        FEDIDataObjects[Index] := EDIDataObject;
      end
      else
        raise EJclEDIError.CreateResFmt(@EDIXMLError035, [IntToStr(Index)])
    else
      raise EJclEDIError.CreateResFmt(@EDIXMLError034, [IntToStr(Index)])
  else
    raise EJclEDIError.CreateResFmt(@EDIXMLError033, [IntToStr(Index)]);
end;

//=== { TEDIXMLTransactionSetLoop } ==========================================

constructor TEDIXMLTransactionSetLoop.Create(Parent: TEDIXMLDataObject);
begin
  inherited Create(Parent);
  if Assigned(Parent) and (Parent is TEDIXMLTransactionSet) then
    FParentTransactionSet := TEDIXMLTransactionSet(Parent)
  else
  if Assigned(Parent) and (Parent is TEDIXMLTransactionSetLoop) then
    FParentTransactionSet := TEDIXMLTransactionSetLoop(Parent).ParentTransactionSet