jcledisef.pas

East make Tray Icon in delphi

  ListItem: TEDISEFDataObjectListItem;
begin
  if Element.UserAttribute <> '' then
    Result := Result + Element.UserAttribute;
  Result := Result + Element.Id;
  if Element.OutOfSequenceOrdinal then
    Result := Result + SEFDelimiter_AtSign + IntToStr(Element.Ordinal);
  // Get Default Values
  CompareElement := nil;
  if ELMSList <> nil then
  begin
    ListItem := ELMSList.FindItemByName(Element.Id);
    if ListItem <> nil then
      CompareElement := TEDISEFElement(ListItem.EDISEFDataObject);
  end;
  // Test for changes in default values
  if CompareElement <> nil then
  begin
    if (CompareElement.MinimumLength <> Element.MinimumLength) or
      (CompareElement.MaximumLength <> Element.MaximumLength) then
    begin
      Result := Result + SEFDelimiter_SemiColon;
      if CompareElement.MinimumLength <> Element.MinimumLength then
        Result := Result + IntToStr(Element.MinimumLength);
      Result := Result + SEFDelimiter_Colon;
      if CompareElement.MaximumLength <> Element.MaximumLength then
        Result := Result + IntToStr(Element.MaximumLength);
    end;
  end
  else
  begin
    Result := Result + SEFDelimiter_SemiColon;
    Result := Result + IntToStr(Element.MinimumLength);
    Result := Result + SEFDelimiter_Colon;
    Result := Result + IntToStr(Element.MaximumLength);
  end;
  if (Element.RequirementDesignator <> '') and
    (Element.RequirementDesignator <> Value_Optional) then
    Result := Result + SEFDelimiter_Comma + Element.RequirementDesignator;
  if Element.RepeatCount > 1 then
  begin
    if (Element.RequirementDesignator = '') or
      (Element.RequirementDesignator = Value_Optional) then
      Result := Result + SEFDelimiter_Comma;
    Result := Result + SEFDelimiter_Comma + IntToStr(Element.RepeatCount);
  end;
end;

procedure ParseELMSDataOfSEGSDefinition(Data: string; Element: TEDISEFElement;
  ELMSList: TEDISEFDataObjectList);
var
  I, J, K, L, M, N, O, P: Integer;
  ListItem: TEDISEFDataObjectListItem;
begin
  // Clear any old values
  Element.UserAttribute := '';
  Element.Ordinal := -1;
  Element.ElementType := '';
  Element.MinimumLength := 0;
  Element.MaximumLength := 0;
  Element.RequirementDesignator := Value_Optional;
  Element.RepeatCount := 1;
  // Parse User Attribute
  if Data[1] in EDISEFUserAttributeSet then
  begin
    Element.UserAttribute := Data[1];
    I := 2;
  end
  else
    I := 1;
  // Get delimiter locations
  J := StrSearch(SEFDelimiter_AtSign, Data, 1);
  K := StrSearch(SEFDelimiter_SemiColon, Data, 1);
  L := StrSearch(SEFDelimiter_Colon, Data, 1);
  M := StrSearch(SEFDelimiter_Comma, Data, 1);
  N := StrSearch(SEFDelimiter_Comma, Data, M + 1);
  P := Length(Data) + 1;
  // Parse Id
  O := P;
  if J <> 0 then
    if O > J then
      O := J;
  if K <> 0 then
    if O > K then
      O := K;
  if L <> 0 then
    if O > L then
      O := L;
  if M <> 0 then
    if O > M then
      O := M;
  Element.Id := Copy(Data, I, O - I);
  // Get Default Values
  if ELMSList <> nil then
  begin
    ListItem := ELMSList.FindItemByName(Element.Id);
    if ListItem <> nil then
      Element.Assign(TEDISEFElement(ListItem.EDISEFDataObject));
  end;
  // Parse other attributes
  if J <> 0 then
  begin
    Inc(J);                                       
    O := P; 
    if K <> 0 then
      if O > K then
        O := K;
    if L <> 0 then
      if O > L then
        O := L;
    if M <> 0 then
      if O > M then
        O := M;
    if (O - J) > 0 then
      Element.Ordinal := StrToInt(Copy(Data, J, O - J));
  end;
  if K <> 0 then
  begin
    Inc(K);
    O := P;
    if L <> 0 then
      if O > L then
        O := L;
    if M <> 0 then
      if O > M then
        O := M;
    if (O - K) > 0 then
      Element.MinimumLength := StrToInt(Copy(Data, K, O - K));
  end;
  if L <> 0 then
  begin
    Inc(L);
    O := P;
    if M <> 0 then
      if O > M then
        O := M;
    if (O - L) > 0 then
      Element.MaximumLength := StrToInt(Copy(Data, L, O - L));
  end;
  if M <> 0 then
  begin
    Inc(M);
    O := P;
    if N <> 0 then
      if O > N then
        O := N;
    if (O - M) > 0 then
      Element.RequirementDesignator := Copy(Data, M, O - M);
  end;
  if N <> 0 then
  begin
    Inc(N);
    if (P - N) > 0 then
      Element.RepeatCount := StrToInt(Copy(Data, N, 1));
  end;
end;

// Parse TEDISEFCompositeElement or Repeating Pattern in TEDISEFCompositeElement

procedure InternalParseCOMSDataOfCOMSDefinition(Data: string; Element: TEDISEFDataObjectGroup;
  ELMSList: TEDISEFDataObjectList);
var
  I, J, K, L, M, N: Integer;
  RepeatCount: Integer;
  RepeatData: string;
  SubElement: TEDISEFSubElement;
  RepeatingPattern: TEDISEFRepeatingPattern;
begin
  I := StrSearch(SEFDelimiter_EqualSign, Data, 1);
  if (I > 0) and (Element is TEDISEFCompositeElement) then
  begin
    Element.EDISEFDataObjects.Clear;
    Element.Id := Copy(Data, 1, I - 1);
  end;
  Inc(I);
  M := I;
  while I > 0 do
  begin
    // Start search
    I := StrSearch(SEFDelimiter_OpeningBracket, Data, M);
    if I = 0 then
      Break;
    J := StrSearch(SEFDelimiter_ClosingBracket, Data, M);
    K := StrSearch(SEFDelimiter_OpeningBrace, Data, M);
    L := StrSearch(SEFDelimiter_ClosingBrace, Data, M);
    // Determine if data block to process is a repetition
    if (I < K) or (K = 0) then // Normal data block
    begin
      SubElement := AddSubElementTo(Element);
      SubElement.Data := Copy(Data, I + 1, (J - I) - 1);
      SubElement.Disassemble;
      M := J + 1;
    end
    else // Repeating data block (K = 1 on the first pass)
    begin
      // Get repeat count
      N := StrSearch(SEFDelimiter_OpeningBracket, Data, K);
      RepeatCount := StrToInt(Copy(Data, K + 1, (N - K) - 1));
      // Correct start position
      K := StrSearch(SEFDelimiter_OpeningBracket, Data, K);
      // Validate end position
      N := StrSearch(SEFDelimiter_OpeningBrace, Data, K + 1);
      while (N <> 0) and (N < L) do // Detect nested repetition
      begin
        N := StrSearch(SEFDelimiter_OpeningBrace, Data, N + 1); // Search for nested repetition
        L := StrSearch(SEFDelimiter_ClosingBrace, Data, L + 1); // Correct end position
      end;
      // Copy data for repetition
      RepeatData := Copy(Data, K, L - K);
      M := L + 1;
      // Handle Repeating Data Block
      RepeatingPattern := AddRepeatingPatternTo(Element);
      RepeatingPattern.RepeatCount := RepeatCount;
      RepeatingPattern.Data := RepeatData;
      RepeatingPattern.Disassemble;
    end;
  end;
  // Store Currently Unused Data
  if (M <= Length(Data)) and (Element is TEDISEFCompositeElement) then
    TEDISEFCompositeElement(Element).FExtendedData := Copy(Data, M, (Length(Data) - M) + 1);
end;

procedure ParseCOMSDataOfCOMSDefinition(Data: string; CompositeElement: TEDISEFCompositeElement;
  ELMSList: TEDISEFDataObjectList);
begin
  InternalParseCOMSDataOfCOMSDefinition(Data, CompositeElement, ELMSList);
end;

function CombineCOMSDataOfCOMSDefinition(CompositeElement: TEDISEFCompositeElement): string;
var
  ListItem: TEDISEFDataObjectListItem;
begin
  Result := CompositeElement.Id + SEFDelimiter_EqualSign;
  ListItem := CompositeElement.EDISEFDataObjects.First;
  while ListItem <> nil do
  begin
    if not (ListItem.EDIObject is TEDISEFRepeatingPattern) then
      Result := Result + SEFDelimiter_OpeningBracket + ListItem.EDISEFDataObject.Assemble +
        SEFDelimiter_ClosingBracket
    else
      Result := Result + SEFDelimiter_OpeningBrace + ListItem.EDISEFDataObject.Assemble +
        SEFDelimiter_ClosingBrace;
    ListItem := ListItem.NextItem;
  end;
  Result := Result + CompositeElement.FExtendedData;
end;

procedure ParseCOMSDataOfSEGSDefinition(Data: string; CompositeElement: TEDISEFCompositeElement;
  COMSList: TEDISEFDataObjectList);
var
  Temp: TStringList;
  ListItem: TEDISEFDataObjectListItem;
  DefaultCompositeElement: TEDISEFCompositeElement;
begin
  CompositeElement.EDISEFDataObjects.Clear;
  Temp := TStringList.Create;
  try
    Temp.CommaText := Data;
    if Temp.Count >= 1 then
      CompositeElement.Id := Temp[0];
    ListItem := COMSList.FindItemByName(CompositeElement.Id);
    if (ListItem <> nil) and (ListItem.EDISEFDataObject <> nil) then
    begin
      DefaultCompositeElement := TEDISEFCompositeElement(ListItem.EDISEFDataObject);
      CompositeElement.Assign(DefaultCompositeElement);
    end;
    if Temp.Count >= 2 then
      CompositeElement.RequirementDesignator := Temp[1];
  finally
    Temp.Free;
  end;
end;

function CombineCOMSDataOfSEGSDefinition(CompositeElement: TEDISEFCompositeElement): string;
begin
  if CompositeElement.UserAttribute <> '' then
    Result := Result + CompositeElement.UserAttribute;
  Result := Result + CompositeElement.Id;
  if CompositeElement.OutOfSequenceOrdinal then
    Result := Result + SEFDelimiter_AtSign + IntToStr(CompositeElement.Ordinal);
  if (CompositeElement.RequirementDesignator <> '') and
    (CompositeElement.RequirementDesignator <> Value_Optional) then
  begin
    Result := Result + SEFDelimiter_Comma + CompositeElement.RequirementDesignator;
  end;
end;

// Parse TEDISEFSegment or Repeating Pattern in TEDISEFSegment

procedure InternalParseSEGSDataOfSEGSDefinition(Data: string; Segment: TEDISEFDataObjectGroup;
  SEFFile: TEDISEFFile);
var
  I, J, K, L, M, N: Integer;
  ElementData: string;
  RepeatCount: Integer;
  RepeatData: string;
  Element: TEDISEFElement;
  CompositeElement: TEDISEFCompositeElement;
  RepeatingPattern: TEDISEFRepeatingPattern;
begin
  I := StrSearch(SEFDelimiter_EqualSign, Data, 1);
  if (I > 0) and (Segment is TEDISEFSegment) then
  begin
    Segment.EDISEFDataObjects.Clear;
    Segment.Id := Copy(Data, 1, I - 1);
    TEDISEFSegment(Segment).RequirementDesignator := Value_Optional;
    TEDISEFSegment(Segment).MaximumUse := 1;
  end;
  Inc(I);
  M := I;
  while I > 0 do
  begin
    // Start search
    I := StrSearch(SEFDelimiter_OpeningBracket, Data, M);
    if I = 0 then
      Break;
    J := StrSearch(SEFDelimiter_ClosingBracket, Data, M);
    K := StrSearch(SEFDelimiter_OpeningBrace, Data, M);
    L := StrSearch(SEFDelimiter_ClosingBrace, Data, M);
    // Determine if data block to process is a repetition
    if (I < K) or (K = 0) then // Normal data block
    begin
      ElementData := Copy(Data, I + 1, (J - I) - 1);
      if ElementData[1] = Value_Conditional then
      begin
        CompositeElement := AddCompositeElementTo(Segment);
        CompositeElement.SEFFile := SEFFile;
        CompositeElement.Data := ElementData;
        CompositeElement.Disassemble;
      end
      else
      begin
        Element := AddElementTo(Segment);
        Element.SEFFile := SEFFile;
        Element.Data := ElementData;
        Element.Disassemble;
      end;
      M := J + 1;