Interação entre componentes e bancos de dados locais

Quando um componente é instalado em um banco local, seu nome aparece na Página Métodos do Explorador do banco local, no tema Métodos componente. Os métodos projeto compartilhados são listados como listas hierárquicas e, se o componente é interpretado, seu conteúdo é mostrado na área de pré-vizualização.

Para mais informação sobre a definição dos métodos compartilhados, consulte Compartilhar métodos projeto.

Certos tipos de objetos definidos por um componente se desenvolvem em um espaço de execução próprio, o que elimina as possibilidades de conflitos com os objetos existentes da base local e com outros componentes. Estes objetos se chamam “não compartilhados” ou “divididos.” Por exemplo, as variáveis estão divididas, o que significa que una variável <>Minhavar de tipo Inteiro longo criada e manipulada por um componente pode coexistir com uma variável <>Minhavar variável de tipo Texto criada e utilizada pelo banco local (ou por outro componente).

Outros objetos compartilham o mesmo espaço de execução entre a base local e os componentes. O emprego destes objetos requer mais precauções, mas não permite à base local e aos componentes se comunicarem mutuamente. Estes objetos se chamam “compartilhados” ou “não-divididos.”

Por exemplo, os conjuntos são não divididos, o que significa que se um componente cria o conjunto meuConjunto, este será apagado se a base local executar a instrução

Os objetos não compartidos (particionados) entre os componentes e os bancos locais são os seguintes:

• folhas de estilo
• mensagens de ajuda
• listas de seleção
• imagens da livraria
• menus e barras de menus criadas pelo editor de menus
• métodos de projeto sem a propriedade “Compartilhado por componentes e banco local”
• semáforos
• processos
• variáveis (locais, processos e interprocesso)
• variáveis sistema (OK, Document, etc.)
• formulários tabela.
• formulários projeto sem a propriedade "Publicar como subformulário"
• recursos e referências aos arquivos de recursos abertos

Os objetos compartilhados (não divididos) são os seguintes:

•  conjuntos
•  seleções temporárias
•  listas hierárquicas utilizando uma referência (criadas pelos comandos New list, Load list, Copy list ou BLOB to list)
•  menus e barras de menus utilizando a referência devolvida pelo comando Create menu.
• Referências Window (WinRef)
• métodos de projeto com a propriedade “Compartilhado por componentes e banco local”
• formulários projeto com a propriedade "Publicada como subformulário no banco local"
•  referências de estrutura XML
•  referências de arquivos abertos (exceto para os arquivos de recursos)
•  ponteiros

Nota Obviamente, os objetos não utilizáveis presentes em um banco matriz são ignorados pelo banco local (ver Objetos utilizáveis e não utilizáveis).

Todos os métodos projeto de uma base matriz se incluem por definição no componente (o banco é o componente), o que significa que podem ser chamados e executados pelo componente.

Por outro lado, conseqüentemente estes métodos de projeto não serão visíveis, nem podem ser chamados pela base local. Na base matriz, você deve designar explicitamente os métodos que quer compartilhar com a base local. Estes métodos de projeto serão visíveis na Página Métodos do Explorador e podem chamar-se no código do banco local (mas não podem ser modificados no editor de métodos do banco local). Estes métodos constituem os pontos de entrada no componente.

Pelo contrário, por razões de segurança, conseqüentemente um componente não pode executar métodos projeto que pertençam à base local.
Em alguns casos, você poderia necessitar autorizar a um componente a aceder aos métodos de projeto de sua base local. Para fazê-lo, você deve designar explicitamente os métodos projeto do banco local que quer que sejam acessíveis aos componentes.

Esta configuração é efetuada por meio da propriedade Compartilhado por componentes e banco local na caixa de diálogo de propriedades dos métodos:

O efeito desta opção está definido pelo contexto de utilização da base: se a base é utilizada como um componente, o método será acessível na base local e visível no Explorador. Se a base é uma base local, o método será utilizável pelos componentes.

Pode compartir os formulários do banco matriz e usá-los como subformulários no banco local.

Do lado do componente (banco matriz), só os subformulários projeto podem ser especificados como subformulários publicados.

Para que um formulário de componente possa ser selecionado como um subformulário em um banco local, deve ter sido expressamente designado como "formulário publicado" na caixa de diálogo das propriedades do formulário através da opção. Publicado como subformulário no banco local:

Nota: esta caixa de diálogo é acessível através do comando Propriedades do formulário do menu contextual ou do menu de ação do Explorador (ver Propriedades de formulário (Explorador)).

Deve administrar as interações entre o subformulário e os formulários pais do banco local utilizando os mecanismos e ferramentas descritas em  Subformulários em modo página.

Do lado do banco principal, é imperativo que os subformulários provenientes de componentes sejam utilizados em modo página: no editor de formulários, quando o objeto subformulário se seleciona no formulário pai, deselecione a opção Subformulário listado no tema "Subformulário" da Lista de Propriedades. 

Depois escolha <Nenhum> no menu "Tabela". Os formulários publicados pelos componentes são listados no menu "Formulário detalhado". Seu nome é seguido pelo do componente entre parênteses. Pode desmarcar desta lista o formulário a utilizar na lista "Formulário detalhado".

Uma nova instância do objeto selecionado é criado imediatamente no formulário.

Os componentes e os bancos locais não compartilham as variáveis locais processo ou interprocesso. A única forma de aceder às variáveis do componente desde a base local e vice-versa é utilizando ponteiros.

Exemplo utilizando um array:

• No banco local:
  
   ARRAY INTEGER(MiArray;10)
 AMethod(->MiArray)
• No componente, o método de projeto AMethod contém:
  
   APPEND TO ARRAY($1->;2)

Exemplos utilizando variáveis:

O uso de ponteiros para permitir a comunicação dos componentes e a base local requer que se tenham em conta as seguintes especificações: 

• O comando Get pointer não devolverá um ponteiro a uma variável da base local se é chamada desde um componente e vice-versa.

• A arquitetura dos componentes autoriza a coexistência, dentro da mesma base interpretada, de componentes interpretados e compilados (do contrário, somente os componentes compilados podem ser utilizados em um banco compilada). O uso de ponteiros neste caso deve respeitar o seguinte princípio: o intérprete pode desapontar um ponteiro construído em modo compilado, mas não é possível desapontar um ponteiro construído em modo interpretado.
  Vamos ilustrar este princípio com o seguinte exemplo: dados dois componentes, C (compilado) e I (interpretado), instalados no mesmo banco local:
  
  • se o componente C define a variável minhavarC, o componente I pode aceder ao valor desta variável utilizando o ponteiro >minhavarC.
  • se o componente define a variável minhavarI, o componente C não pode aceder a esta variável utilizando o ponteiro ->minhavarI. Esta sintaxe produz um erro de execução.
    

• A comparação de ponteiros através do comando RESOLVE POINTER não é recomendável com componentes já que o princípio de particionamento de variáveis autoriza a coexistência de variáveis do mesmo nome mas com conteúdo radicalmente diferente em um componente e o banco local (ou outro componente). O tipo de variável pode inclusive ser diferente em ambos contextos.
  Se os ponteiros miptr1 e miptr2 apontam cada um a uma variável, a comparação seguinte produzirá um resultado incorreto:
  
   RESOLVE POINTER(miptr1;vNomVar1;vnumtabla1;vnumcamp1)
 RESOLVE POINTER(miptr2;vNomVar2;vnumtabla2;vnumcamp2)
 If(vNomVar1=vNomVar2)
  //Esta prova devolve True mesmo que as variáveis sejan diferentes
  
  Neste caso, é necessário utilizar a comparação de ponteiros:
  
   If(miptr1=miptr2) //Esta prova devolve False

Ainda que os componentes não possam utilizar tabelas, os seguintes comandos podem ser chamados dentro de um componente:

DEFAULT TABLE
NO DEFAULT TABLE
Current default table

Efetivamente, estes comandos são úteis quando um componente deve utilizar tabelas da base local. Neste caso os ponteiros permitirão à base local e ao componente comunicar-se entre si. Por exemplo, este é um método que pode ser chamado desde um componente:

Exceto pelos Comandos não utilizáveis, um componente pode utilizar todo comando da linguagem 4D.

Quando se chamam os comandos desde um componente, são executados no contexto do componente, exceto pelo comando EXECUTE METHOD que utiliza o contexto do método especificado pelo comando. Note também que os comandos de leitura do tema “Usuário e Grupos” podem ser utilizados desde um componente, mas lerão os usuários e grupos da base local (um componente não tem seus próprios usuários e grupos).

Os comandos SET DATABASE PARAMETER e  Get database parameter são a exceção a este princípios: seu alcance é global à base. Quando estes comandos são chamados desde um componente, são aplicados à base local.
Além do mais, foram definidas medidas específicas para os comandos Structure file e Get 4D folder quando são utilizados no marco de componentes (ver o manual de Linguagem).

O comando COMPONENT LIST permite conhecer a lista dos componentes carregados pelo banco local.

Quando você utiliza componentes não compilados, seu código aparece no depurador padrão da base local.

O depurador respeita os espaços de execução dos objetos divididos. Assim que mostrar o valor da variável var1 da base local na janela de avaliação, execute o código que pertence ao componente que contém igualmente uma variável var1 e o valor mostrado não se atualizará. Você deve mostrar outra instância da variável na janela de avaliação para obter seu valor no contexto atual.