Classe TBasePageProducer

O constructor create inicializa os parâmetros padrões da classe e instancia a classe FPTemplate.

• Parâmetro usado aqui:

  • TConsts.DefaultStartDelimiter;

  • TConsts.DefaultEndDelimiter;

  • TConsts.DefaultParamStartDelimiter;

  • TConsts.DefaultParamValueSeparator;

  • TConsts.DefaultParamEndDelimiter;

  • TConsts.DefaultAllowTagParams;

O Destructor destroy destroy a classe TBasePageProducer e livra da memória o atributo FPTemplate criado em constructor.

O método ListFilesText retorna uma string com o nome de todos os arquivos com a extensão passada por a aMask.

• PARÂMETROS

  • aTagName

    • Nome da tag

  • atemplate

    • Modelo onde cada nome de arquivo deve ser inserido

      
      <!--# tgCustom [- ListFilesText=Arquivo:
                                      -"˜ListFilesText" -]
      #-->

  • aPath

    • Nome do diretório

  • aMask

    • Filtro de pesquisa.

      • Ex: *.html

• EXEMPLO

  
  procedure TForm_pageproducer_test.PageProducer1HTMLTag_tgCustom(
           Sender: TObject; const TagString: string; TagParams: TStrings;  var ReplaceText: string);
  
    var
      s1 : string;
  begin
    s1 := TagParams.Values['ListFilesText'];
    if s1 <> ''
    Then begin //Retorna a lista de links.
           ReplaceText:=TPageProducer.ListFilesText('ListFilesText',s1,'','*');
         end;
  end;

• NOTA

  • O parâmetro atemplate pode conter qualquer formato em cada linha, visto que o modelo passado por atemplate é inserido o nome do arquivo no lugar de aTagName.

A classe método StringReplaceTgImage recebe um template tipo image e retorna o mesmo preenchido com o conteúdo os parâmetros: aSrc, aAlt, aTitle, aFigcaption.

• O método StringReplaceTgLink é usado para preencher templates html tgLink usado nos templates do componente TPageProducer.

  • PARÂMETROS

    • aAlias = Apelido do template

    • atemplate = <!–# tgLink [- %s=[a href="˜url" target="_blank" title="˜title"] ˜text [/a] -] #–>

    • aURL = Endereço do link

    • atarget = Destino onde a página deve ser aberta, se vazio abre na aba atual.

    • aTitle = Documentação do link

    • aText = Descrição do link

  • ATRIBUTOS DO TEMPLATE

    • ˜alias = Apelido do template;

    • ˜url = Endereço do link

    • ˜target = Destino onde a página deve ser aberta, se vazio abre na aba atual.

    • ˜title = Documentação do link

    • ˜text = Descrição do link

A classe método StringReplaceTgTable é usado para preencher um template passado por template dentro de um template.html para criar tabelas html usado na tag tbTable.

• EXEMPLOS

  • Template esperado no evento OnHTMLTag_tgTable

  
  <!--# tgTable [- ALUNOS=[title="Cadastro de Alunos:";
                          Header="Column1:      ",":Column2:     ",":Column3      ",":Column4    ";
                          OneRow=["1 Paulo Sérgio","Marcos Pacheco","George Bruno  ","George Bruno",/,
                                  "2 José Carlos" ,"Antônio       ","Paulo Henrique","George Bruno",/,
                                 ];
                          FooterCols="soma Columm1","soma Columm2","soma Columm3","soma Columm4";
                          NOTFOUND="Mensagem em caso de erro";
                          template="<Table id="table">
                                      <thead>
                                        <tr>˜Alias</tr> <br>
                                        <tr>
                                          ˜HeaderCols <br>
                                        <tr>
                                      </thead>
  
                                      <tbody>
                                        ˜OneRowCols <br>
                                      </tbody>
  
                                      <tfoot>
                                       ˜FooterCols <br>
                                      </tfoot>
  
                                   </Table>"
                         ]
                -]
  #-->

O método DoOnHTMLTag_tgCustom Executa o evento OnHTMLTag_tgCustom se o mesmo for assinalado visualmente ou não pelo usuário para preencher as tags do tipo tgCustom.

O método DoOnHTMLTag_tgLink Executa o evento OnHTMLTag_tgLink se o mesmo for assinalado visualmente ou não pelo usuário para preencher as tags do tipo tgLink.

O método DoOnHTMLTag_tgImage Executa o evento OnHTMLTag_tgImage se o mesmo for assinalado visualmente ou não pelo usuário para preencher as tags do tipo tgImage.

O método DoOnHTMLTag_tgTable Executa o evento OnHTMLTag_tgTable se o mesmo for assinalado visualmente ou não pelo usuário para preencher as tags do tipo tgTable.

O método DoOnHTMLTag_tgImageMap Executa o evento OnHTMLTag_tgImageMap se o mesmo for assinalado visualmente ou não pelo usuário para preencher as tags do tipo tgImageMap.

O método DoOnHTMLTag_tgObject Executa o evento OnHTMLTag_tgObject se o mesmo for assinalado visualmente ou não pelo usuário para preencher as tags do tipo tgObject.

O método DoOnHTMLTag_tgEmbed Executa o evento OnHTMLTag_tgEmbed se o mesmo for assinalado visualmente ou não pelo usuário para preencher as tags do tipo tgEmbed.

O método DoOnHTMLTag_tgVideo Executa o evento OnHTMLTag_tgVideo se o mesmo for assinalado visualmente ou não pelo usuário para preencher as tags do tipo tgVideo.

O método DoOnHTMLTag_tgAudio Executa o evento OnHTMLTag_tgAudio se o mesmo for assinalado visualmente ou não pelo usuário para preencher as tags do tipo tgAudio.

O método DoOnHTMLTag_Undefined Executa o evento OnHTMLTag_Undefined se o mesmo for assinalado visualmente ou não pelo usuário para preencher as tags personalizadas sem uso da tah tbCustom.

O método DoReplaceTag_Default

O método GetHTMLContent retorna para a propriedade HTMLContent o documento processado pela método FPTemplate.GetContent.

• NOTA

  • Só processa o template se a propriedade OnHTMLTag for igual a true.

A propriedade GetHTMLFile contém o nome do arquivo do template.

• Nota:

  • O arquivo deve estar na pasta de templates.

O método SaveHTMLContentToFile salva no arquivo FileNameDest o conteúdo da propriedade HTMLContent.

O método SaveHTMLContentToFile salva no arquivo htmlFileResult o conteúdo da propriedade HTMLContent.

A propriedade GetHtmlTable recebe uma tag do tipo tgTable e retorna uma tabela preenchida com os parâmetros passado.

• PARÂMETROS

  • atgTable: String;

    • Recebe uma tag no padrão abaixo:

      
      <!--# tgTable [- ALUNOS=[Alias="Cadastro de Alunos";
                               Header="Column1:      ",":Column2:     ",":Column3      ",":Column4    ";
                               widths="300px"         ,"250px"         ,"150px"         ,"180px";
                               OneRow=["1 Paulo Sérgio","Marcos Pacheco","George Bruno  ","George Bruno",/,
                                       "2 José Carlos" ,"Antônio       ","Paulo Henrique","George Bruno",/,
                                      ];
                               Footer="soma Columm1","soma Columm2","soma Columm3","soma Columm4";
                               NotFound="Mensagem em caso de erro";
                               template="<Table id="table">
                                             <thead id="theadAlunos">
                                                <tr><th colspan="4"> <p  style="text-align: center">  ˜Alias  </p> </th>  </tr>
                                                <tr>˜HeaderCols</tr>
                                             </thead>
                                             <tbody id="tbodyAlunos">
                                                ˜OneRowCols
                                             </tbody>
                                             <tfoot id="tfootAlunos">
                                                ˜FooterCols
                                             </tfoot>
                                         </Table>"
                              ]
                    -]
         #-->

  • aNameTable: String;

    • Nome da tabela usado no parâmetro, no exemplo acima a tag ALUNOS.

  • aTypeTable: String

A propriedade GetHtmlImageMap recebe uma tag do tipo tgImageMap e retorna uma tabela preenchida com os parâmetros passado.

• TAG EXEMPLO:

• PARÂMETROS

  • atgImageMap: String;

    • Recebe uma tag igual a essa:

      <!--# tgImageMap [- img_map=[src="./img/img_map.jpg";
                                   Alt="Imagem teste de imagens clicáveis";
                                   useMap="img_map";
                                   oneRowArea="["target" , "alt_rect"   , "title_rect"   , "href_rect.html"   , "19,53,66,107", "rect",
                                                "target" , "alt_circle" , "title_circle" , "href_circle.html" , "126,85,34","circle",
                                                "target" , "alt_poly"   , "title_poly"   , "href_poly.html"   , "202,54,266,52,265,98,247,93,233,97,222,101,207,103,198,98","poly"
                                               ]";
                                    templateOneRowArea="<area target="˜target" alt="˜alt" title="˜title" href="˜href" coords="˜coords" shape="˜shape">";
                                    templateImageMap="<img src="˜src" Alt="˜alt" usemap="#˜useMap">
                                                       <map name="˜useMap" Alt="˜Alt">
                                                          <area shape="default" nohref />
                                                          ˜oneRowArea
                                                       </map>"
                                  ]
                       -]
      #-->

  • aNameImageMap

    • Nome do mapa de imagem.

• A propriedade ID_Dinamic retorno um string com um registro tipo **TGuid** para representar a classe.

• O evento OnHTMLTag_tgcustom retorna em ReplaceText o código preenchido passado por TagString e TagParams.

  • DESCRIÇÃO

    • A propriedade OnHTMLTag_tgcustom foi criado para processar todo template criado pelo usuário e que não tem relação com nome de tags html.

  • EXEMPLO DE TEMPLATE CUSTOMIZADO

    • A Tag <# tgCustom [- ListFilesText=Arquivo:-"˜ListFilesText" -]#> informa ao componente TPageProduce que deve executar o método ListFilesText, porém o resultado deve ser uma lista de textos com nome dos arquivos da pasta atual e de suas subpastas.

      • Formato de saída:

        • Arquivo:

          • xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

        • Arquivo:

          • xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

      
      <!--# tgCustom [- ListFilesText=
                        Arquivo:
                          -"˜ListFilesText" -]
      #-->

    • O método OnHTMLTag_tgcustom retorna no parâmetro em ReplaceText a lista de texto.

      
      procedure TForm_pageproducer_test.PageProducer1HTMLTag_tgCustom(
                Sender: TObject; const TagString: string; TagParams: TStrings;  var ReplaceText: string);
      
      
      var
        s1 : string;
      begin
        if AnsiCompareText(TagString, 'tgCustom') = 0 then
        begin
          s1 := TagParams.Values['ListFilesText'];
          if s1 <> ''
          Then begin //Retorna a lista de links.
                 ReplaceText:=TPageProducer.ListFilesText('ListFilesText',s1,'','*');
               end;
        end
        else ReplaceText:='A tag <'+TagString+'>Não conhecida';
      end;

• O evento OnHTMLTag_tgLink retorna em ReplaceText o código preenchido passado por TagString e TagParams, onde TagString, contém a tag tgLink e TagParams contém o template de um link html com os atributos hRef, target, title, text.

  • DESCRIÇÃO

    • O método OnHTMLTag_tgLink foi criado para processar todos os templates referentes a links cuja a tag seja tgLink dentro do arquivo de templates.html

  • EXEMPLO DE TEMPLATE

    • O template abaixo dentro de TPageProduce.FileName, informa para o evento OnHTMLTag_tgLink que os parâmetros BlogPsspAppBr e PsspAppBr deve ser preenchido com um link. A função FindFilesAll deve retornar um código html com uma lista de links de todos os nomes de arquivos dentro da pasta corrente e subpastas.

      <!-- Arquivo: template.html -->
      
      <html lang="pt-BR">
        <head>
            <meta charset="UTF-8">
            <title>Teste do componente mi.rtl.Objects.Methods.TPageProduce</title>
      
            <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
      
        </head>
      
      <bodY>
        <h3> Meu Blog </h3>
      
        <p> A tag abaixo deve ser preenchida com o endereço: http://www.pssp.app.br
             onde o destino da visualização é uma nova aba do browser<p>
        <!--# tgLink [- BlogPsspAppBr=[a href="˜url" target="_blank" title="˜title"] ˜text [/a]  -] #-->
      
        <p> A tag abaixo deve ser preenchida com o endereço: http://www.pssp.app.br
             onde o destino da visualização é uma variável definida no ato da produção
             da página</p>
        <!--# tgLink [-     PsspAppBr=[a href="˜url" target="˜target" title="˜title"] ˜text [/a]  -] #-->
      
        <br>
      
        <h3> Link com a lista de arquivos .html da pasta corrente</h3>
        <!--# tgLink [- FindFilesAll=[a href="˜url" target="_blank" title="˜title"] ˜text [/a]  -] #-->
        <br>
       </body>
      </html>

    • O método OnHTMLTag_tgLink retorna no parâmetro em ReplaceText o template acima preenchido.

      
      procedure TFPWebModule.@name(Sender: TObject; const TagString:  String; TagParams: TStringList; Out ReplaceText: String);override;
      begin
        s1 := TagParams.Values['BlogPsspAppBr'];
        ReplaceText := TObjectss.StringReplaceTgLink('BlogPsspAppBr',
                                                      s1,
                                                      'http://www.pssp.app.br',
                                                      '', // Mantém o destino definido no ptemplate
                                                      'Blog do Paulo Sérgio da Silva Pacheco',
                                                      'http://www.pssp.app.br  ➚');
      
        s1 := TagParams.Values['PsspAppBr'];
        if s1 <> ''
        then ReplaceText := TObjectss.StringReplaceTgLink('PsspAppBr',
                                                          s1,
                                                          'http://www.pssp.app.br',
                                                          '_self', //Abre o documento na mesma aba
                                                          'Blog do Paulo Pacheco',
                                                          'http://www.pssp.app.br')
        else begin
               s1 := TagParams.Values['FindFilesAll'];
               if s1 <> ''
               Then begin //Retorna a lista de links.
                      ReplaceText:=ListFilesURLs(s1);
                    end;
             end;
      end;

    • Notas:

      • A ação padrão de OnHTMLTag_tgLink é executar o evento OnHTMLTag_tgLink, porém é possível ser redefinido para ter outro tipo de comportamento conforme preferência da aplicação que o utiliza.

O evento OnHTMLTag_tgImage retorna em ReplaceText o código preenchido passado por TagString e TagParams, onde TagString, contém a tag tgImage e TagParams contém o template de um link html para imagem com os atributos Src, Alt, aTitle e text.

• DESCRIÇÃO

  • O método OnHTMLTag_tgImage foi criado para processar todos os templates referentes a img cuja a tag seja tgimage dentro do arquivo de templates.html

• ATRIBUTOS:

  • src : Especifica o caminho para a imagem;

    • Value : URL.

  • Alt : Especifica um texto alternativo para uma imagem;

    • Value : Text.

  • usemap : Associa na tag <img> ao nome do mapa de imagem definido na tag <map> </map>. lado do cliente;

    • Value : Nome da tag mapa

      • Ex..: #image_tag Obs: Deve ter o símbolo cancela (#) para indicar que a imagem está na mesma página;

    • Exemplo: <img src="form_instalar_pacotes.jpeg" usemap="#image-map">

  • height : Especifica a altura de uma imagem;

    • Value : pixels.

  • width : Especifica a largura de uma imagem;

    • Value : pixels.

• EXEMPLO DE TAG DE IMAGEM

  <!-- Arquivo: template.html
       Code template: mi_HTMLTag_tgImage_template
  -->
  
  <!--# tgImage [- NomeDaFigura=[ <figure>
                                     <img src="˜src"
                                          alt="˜alt"
                                          title="˜title"
                                          style="width:10%">
                                     <figcaption>˜figcaption</figcaption>
                                  </figure>
                                ]
                -]
  #-->

  <!-- EVENTO USADO PARA PREENCHER O TEMPLATE
  
       Code Template: mi_HTMLTag_tgImage_Event
  -->
  
  procedure TForm_pageproducer_test.PageProducer1HTMLTag_tgImage(Sender: TObject;
    const TagString: string; TagParams: TStrings; var ReplaceText: string);
  var
    s1 : string;
  begin
    s1 := TagParams.Values['NomeDaFigura'];
    if s1 <> ''
    Then begin //Retorna a tag com a figura
           ReplaceText:= TPageProducer.StringReplaceTgImage(s1,'./img/brasao.png','Pachecos','Hint da imagem','Brasão da Família Pacheco');
  
         end;
  end;

O método OnHTMLTag_tgTable retorna em ReplaceText o código preenchido passado por TagString e TagParams.

• O evento OnHTMLTag_tgTable é usado para tratar especificamente criação de tabelas.

• EXEMPLO DE TAG

  
  <!-- Arquivo......: template.html
       Code template: mi_HTMLTag_tgtable_template
  -->
  
  <!-- Adicionar a linha abaixo em header do documento-->
  <link type="text/css" href="./css/$Param(NomeDaTabela).css" rel="stylesheet" />
  
  <!-- Tag para criar uma tabela no estilo $Param(table)
    <!--# tgTable [- $Param(NomeDaTabela)=
                     [ Alias="$Param(Alias_da_tabela)";
                       Header="$Param(Column1):",":$Param(Column2):",":$Param(Column3)",":$Param(Column4)";
                       widths="$Param(300px)","$Param(250px)","$Param(150px)","$Param(180px)";
                       OneRow=["$Param(a11)","$Param(a12)","$Param(a13)  ","$Param(a14)",/,
                               "$Param(a21)" ,"$Param(a22)","$Param(a23)","$Param(a24)",/,
                               <!-- Adicione aqui ,mais linhas semelhantes a linha acima e apague esse comentário-->
                              ];
                       Footer="$Param(soma Columm1)","$Param(soma Columm2)","$Param(soma Columm3)","$Param(soma Columm4)";
                       NotFound="$Param(Mensagem em caso de erro)";
                       template="<Table id="$Param(table)">
                                     <thead id="thead$Param(NomeDaTabela)">
                                        <tr><th colspan="$Param(4)"> <p  style="text-align: center"> ˜Alias  </p> </th>  </tr>
                                        <tr>˜HeaderCols</tr>
                                     </thead>
                                     <tbody id="tbody$Param(NomeDaTabela)">
                                        ˜OneRowCols
                                     </tbody>
                                     <tfoot id="tfoot$Param(NomeDaTabela)">
                                        ˜FooterCols
                                     </tfoot>
                                 </Table>"
                     ]
                  -]
    #-->

  • PARÂMETROS ESPERADOS EM TAGPARAMS

    • Alias

      • Descrição da tabela que deve fica na primeira linha do header da tabela.

    • Header

      • Em Header se informa o título das colunas e através de : se informa o alinhamento da coluna, podendo ser a esquerda :Column1, ou a direita Column2: ou ao centro :Column3: ou usar padrão da tabela como na Column4

    • Widths

      • Em width se informa a largura de cada coluna;

    • OneRow

      • Em OneRow se informa o conteúdo das linhas onde a colunas deve estar entre aspa(") e separado por vírgula(,) e o fim da linha se usa a barra (/) sem as aspa (").

    • Footer

      • O parâmetro Footer usado para separar a ultima linha da tabela quando a mesma contem conteúdo de soma da coluna.

    • NotFound

      • O parâmetro NotFound é usado para dar uma mensagem quando não existe registro para inserir em OneRow.

    • Template

      • O parâmetro Template deve conter o html usado para criar a tabela.

• EXEMPLO DE CÓDIGO A TAG ACIMA

  
  //Code template: mi_HTMLTag_tgtable_event
  
  procedure TForm_pageproducer_test.$Param(NomeDoObjeto)HTMLTag_tgTable(Sender: TObject;
               const TagString: string; TagParams: TStrings; var ReplaceText: string);
    Var
      s1 : string='';
  begin
  
    s1 := TagParams.Values['$Param(NomeDaTabela)'];
    if s1 <> '' Then
    begin
  
      ReplaceText:= $Param(NomeDoObjeto).GetHtmlTable(TagParams,'$Param(NomeDaTabela)','$Param(table)');
      exit;
    end;//$Param(NomeDaTabela)
  
  end;

• 🔝

O método OnHTMLTag_tgImageMap retorna em ReplaceText o código preenchido passado por TagString e TagParams.

• O evento OnHTMLTag_tgImageMap é usado para tratar especificamente mapa de imagem, com áreas clicáveis.

• <map name="#Name_usemap"></map>

  • <area> : Tag usada para informar uma área dentro da imagem #Name_usemap;

    • atributos:

      • Alt : Especifica um texto alternativo para a área da imagem;

        • Value : Text.

      • Shape : A forma do ponto de acesso associado. As especificações para html 5 e HTML 4 definem os valores rect para região rectangular; circle para uma região circular e poli para um polígono determinado por toda região determinada pelas coordenadas.

        • Value:

          • rect: Espera em Coords dois pontos: x1, y1 x2,y2;

          • circle: Espera em Coodes 2 pontos e o raio: x,y,r;

          • poly : Espera em Coodes n pares de pontos: x1,y1,x2,y2, x3,y3..xn,yn;

      • Coords

        • Value:

          • Se shape = rect então o valor é dois pontos: x1, y1 x2,y2;

          • Se shape = circle então o valor é 2 pontos e o raio: x,y,r;

          • Se shape = poly então o valor é n pares de pontos: x1,y1,x2, y2,x3,y3..xn,yn;

  • Notas:

    • Entre as tags <map></map> é esperado uma lista de tag <area>.

      <map name="#Name_usemap">
        <area ... >
        <area ... >
        <area ... >
        <area ... >
      </map>

• EXEMPLO DE TAG ESPERADO

  
  <!-- Arquivo......: template.html
       Code template: mi_HTMLTag_tgImageMap_template
  
       OneRowArea =
  -->
  
  <!-- Tag para uma imagem clicável -->
  
    <!--# tgImageMap [- $Param(NomeDaImagem)=[
                           src="$Param(src)";
                           alt="$Param(alt)";
                           width="$Param(300px)";
                           height="$Param(400PX)";
                           OneRow=["rect","$Param(x1)","$Param(y1)","$Param(x2)","$Param(y2)",/,
                                   "circle","$Param(x1)" ,"$Param(y1)","$Param(r)",/,
                                   "poly","$Param(x1)" ,"$Param(y1)","$Param(x2)" ,"$Param(y2)"$Param(xn)" ,"$Param(yn)",/,
                                   <!-- Adicione aqui ,mais linhas semelhantes a linha acima e apague esse comentário-->
                                  ];
                           templateOneRowArea =<area shape="˜shape" alt="˜alt"  href="˜href" coords="˜coords">
                           templateImageMap=<img src="˜src"
                                               alt="˜alt"
                                               usemap="#˜usemap"
                                               width="˜width"
                                               height="˜height">
                                               <map name="˜usemap">
                                                  OneRowArea
                                               </map>
  
                        ]
                  -]
    #-->

A propriedade OnHTMLTag_tgObject ..

A propriedade OnHTMLTag_Undefined ..

A propriedade HTMLContent retorna o template com as tags processadas.

A propriedade OnHTMLTag habilita e desabilita a produção de página html.

• NOTAS

  • True : Criar _FPTemplate

  • False : Livra da memória _FPTemplate

• EXEMPLO

  
  procedure TBasePageProducer.SetHTMLDoc(const aHTMLDoc: String);
  Begin
    _HTMLDoc := aHTMLDoc;
  
    OnHTMLTag := true;
    If OnHTMLTag
    Then begin
           FPTemplate.Template := aHTMLDoc;
  
         end;
  
  end;

A propriedade HTMLDoc contém um string usado como template para produção de documentos.

• NOTA

  • A tag HTMLDoc deve ser usada quando temos modelos de template em memória e não precisa de arquivo. Ex: Um template pode estar no arquivo de recurso, tais como: Template_html_tglink e Tag_html_tgTable.

  • Quando HTMLDoc <> '' então não existe htmlFileResult por não existir a propriedadehtmlFile.

A propriedade HTMLFile contém o nome do arquivo de template a ser usado para produzir a página

A propriedade HTMLFileResult contém o nome do arquivo resultado da chamada da propriedade HtmlContent

• Nota:

  • O nome do arquivo será o nome do template com a extensão .html porém na pasta HTML.

A propriedade StartDelimiter contém a marca inicial de tagParam.

• Nota:

  • Padrão é <!–#

A propriedade EndDelimiter contém a marca final de tagParam.

• Nota:

  • Padrão é #–>

A propriedade ParamStartDelimiter contém a marca inicial do parâmetro de tagParam.

• Nota:

  • Padrão é [

A propriedade ParamEndDelimiter contém a marca final do parâmetro de tagParam.

• Nota:

  • Padrão é ]

A propriedade ParamValueSeparator contém a marca de separação entre o parâmetro e o valor dele de tagParam.

• Nota:

  • Padrão é =

A propriedade AllowTagParams informa se a tags tem modelo simples ou complexo. contendo parâmeros internos a tag.

• Nota

  • Se true a tags de modelo com parâmetros é permitidos, o evento [FOnReplaceTag] é usado para todas as substituições de tags, caso seja false, o evento [FOnReplaceTag] não será executado.

  • O padrão é true.

A propriedade FPTemplate é o componente oficial do pacote fcl-web e tem como objetivo produzir documento usando <#tag>.

• Veja o documento fpTemplate.txt convertido para html:

  • ./fcl-base/src/fptemplate.html ➚