TEdit ou TDBEdit para usar com IBX?

unit UPai;

interface



uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, DB, ImgList, ComCtrls, ToolWin, ExtCtrls, DBCtrls, Grids,
  DBGrids, DBClient, SqlExpr, StdCtrls, RlReport;

type
  TfrmPai = class(TForm)
    ToolBar1: TToolBar;
    tbNovo: TToolButton;
    ToolButton2: TToolButton;
    tbEditar: TToolButton;
    ToolButton1: TToolButton;
    tbSalvar: TToolButton;
    ToolButton3: TToolButton;
    tbCancelar: TToolButton;
    ToolButton4: TToolButton;
    tbExcluir: TToolButton;
    ToolButton5: TToolButton;
    StbPrincipal: TStatusBar;
    ImageList1: TImageList;
    DataSource: TDataSource;
    pcPrincipal: TPageControl;
    tsExibicao: TTabSheet;
    DBGrid1: TDBGrid;
    tsEdicao: TTabSheet;
    tbPesquisar: TToolButton;
    tbRelatorio: TToolButton;
    dbNavegar: TDBNavigator;
    ToolButton8: TToolButton;
    procedure DataSourceStateChange(Sender: TObject);
    procedure tbNovoClick(Sender: TObject);
    procedure tbEditarClick(Sender: TObject);
    procedure tbSalvarClick(Sender: TObject);
    procedure tbExcluirClick(Sender: TObject);
    procedure tbCancelarClick(Sender: TObject);
    procedure tbNovoMouseMove(Sender: TObject; Shift: TShiftState; X,
      Y: Integer);
    procedure FormMouseMove(Sender: TObject; Shift: TShiftState; X,
      Y: Integer);
    procedure FormCreate(Sender: TObject);
    procedure pcPrincipalChanging(Sender: TObject;
      var AllowChange: Boolean);
    procedure DBGrid1DblClick(Sender: TObject);
    procedure FormClose(Sender: TObject; var Action: TCloseAction);
    Procedure Focalizar(parCampo : TDBEdit); // Esta rotina colocará o focus no primeiro campo do dataset, quando o mesmo
                                       // entrar no modo de edição ou Inclusão
    Procedure Enter(parBotao : TToolButton; parTecha : Char); // Esta rotina simulará o click do botão salvar para que alterações ou inclusões de registros
                                                   // sejam salvar. Será ativada quando o usuário techar "ENTER"
    Procedure EstadoBotoes;     // Habilita / Desabilita os botões de manipulação de registros , de acordo com os estados do DataSet (dsBrowse,dsInsert,dsEdit...)
    procedure tbPesquisarClick(Sender: TObject);
    Procedure ExibirRelatorio(parReport : TRLReport; parClientDataSet : TClientDataSet; parParametro : String);
  private
     Procedure NovoRegistro;     // Adicinar um novo registro ao banco de dados
     Procedure ExcluirRegistro;  // Exclui registros
     Procedure EscreverHints(parBotao : TToolButton); // Recebe como parâmetro um TToolButton e adiciona o hint do mesmo no Panels[1] (Central) da barra de status...
     Procedure LimparHints; // Limpa o conteúdo do Panels[1] que foi adicionado(Hint do botão) e adiciona a mesma o valor "SCMV"
     Procedure EscreverCaption(parFormulario : TForm); // Escreve o caption do formulário que é passado como parâmetro (Form Atual) no Panels[2] da barra de status.
     Procedure EscreverEstadoDataSet; // Escreve o estado do DataSet (dsBrowse,dsEdit,dsInsert..) no Panels[0] da barra de status.
     Procedure ControlarPageControl; // Controla a mudança das abas do PageControl, de acordo com o estado atual do DataSet(dsBrowse,dsEdit,dsInsert..)
     Procedure DesejaSalvar(Var parAcao : TCloseAction);
     // A rotina acima será chamada quando o usuário estiver editando ou incluindo um novo registro. É nessa hora que o usuário não poderá
     // fechar a janela de Alterações/Inclusões. Caso ele tente fechar a janela, o rotina irá verificar se o usuário está editando ou incluindo
     // registros. Se estiver editando ou incluindo, irá ser exibido na tela uma mensagem perguntando se ele deseja salvar as alterções.
     // parAcao: Esse parâmetro será passado por referência e representará a janela atual de edição ou inclusão. É ele que controla se a janela
     // poderá ser fechada ou não, e pode receber:
     // caNone: A janela não será fechada;
     // cafree: A janela será fechada e liberada de memória;
    { Private declarations }
  public
     Procedure EditarRegistro;   // Edição de registros
     Procedure CancelarRegistro; // Cancelamento de edições ou inclusões de registros
     Procedure SalvarRegistro;   // Salva edições ou inclusões de registros
     Procedure AutoIncrementar(parTabela : String; parCh_Primaria : TField);
     // O Procedimento acima recebe como parâmetro o nome de uma tabela, um Field q seja chave
     // primária da tabela. Atua como AutoIncremento.
     Procedure AplicarRegistro;
     Function TemCampoEmBranco : Boolean; // Esta rotima verifica se existe algum field requerido pelo banco de dados e que esteja vazio.
    { Public declarations } // Caso esteja vazio, não será salvo no banco de dados o registro que está sendo editado ou inserido.
end;

var
  frmPai: TfrmPai;

implementation

uses UDtModConexao, DateUtils, Funcoes, UDtModEstoque, UPesquisaPadrao;



{$R *.dfm}

{ TfrmPai }

procedure TfrmPai.AplicarRegistro;
begin
   Try
     (DataSource.DataSet As TClientDataSet).ApplyUpdates(-1); // Grava as atualizações ou inserções para o banco de dados
   Except
     On E : Exception do
       ShowMessage(E.Message);
   End;
end;

procedure TfrmPai.CancelarRegistro;
begin
   If(DataSource.DataSet.State In [dsInsert,dsEdit])Then
   Begin                           // Se DataSet estiver no modo de edião ou inserção, o mesmo será cancelado
      DataSource.DataSet.Cancel;
      EstadoBotoes; // Habilita / Desabilita botões de manipulação de registros(Novo,Salvar,Excluir...)
   End;
end;

procedure TfrmPai.EditarRegistro;
begin
   If(DataSource.DataSet.State = dsBrowse)Then
     DataSource.DataSet.Edit; // Se DataSet estiver no modo de Visualização, o mesmo será Editado.
end;

procedure TfrmPai.EstadoBotoes;
begin                          // Esta rotina é responsável pela Habilitação / Desabilitação dos Botões que manipulam
   With(DataSource.DataSet)Do  // registros, de acordo com o estado atual do DataSet.
   Begin
      tbNovo.Enabled := State = dsBrowse;
      tbSalvar.Enabled := State In [dsInsert,dsEdit];
      tbEditar.Enabled := ((State = dsBrowse) And (RecordCount > 0));
      tbCancelar.Enabled := State In [dsInsert,dsEdit];
      tbExcluir.Enabled := ((State = dsBrowse) And (RecordCount > 0));
      dbNavegar.Enabled := State = dsBrowse;
      tbPesquisar.Enabled := ((State = dsBrowse) And (RecordCount > 0));
      tbRelatorio.Enabled := ((State = dsBrowse) And (RecordCount > 0));
   End;
end;

procedure TfrmPai.ExcluirRegistro;
begin                         // Se DataSet estiver no modo de Visualização, o mesmo será excluído
   If(DataSource.DataSet.State = dsBrowse)Then // caso o usuário confirme a exclusão.
   Begin
      MessageBeep(64);
      If(MessageDlg(´Excluir Registro?´,mtConfirmation,[mbYes,mbNo],0) = mrYes)Then
      Begin
         DataSource.DataSet.Delete; // Exclusão
         AplicarRegistro; // Exclui o registro do banco de dados
         EstadoBotoes; // Habilita / Desabilita botões de manipulação de registros(Novo,Salvar,Excluir...)
      End;
   End;
end;

procedure TfrmPai.NovoRegistro;
begin           // Se DataSet estiver no modo de Visualização, um novo registro será criado.
   If(DataSource.DataSet.State = dsBrowse)Then
     DataSource.DataSet.Insert;
end;

procedure TfrmPai.SalvarRegistro;
begin
   If(DataSource.DataSet.State In [dsInsert,dsEdit])Then
   Begin   // Se DataSet estiver no modo de Inserção ou Edição, Salvará as alterações ou Inclusões na memória.
      DataSource.DataSet.Post;
      AplicarRegistro; // Salvar as Alterações ou Inserções no Banco de Dados
   End;
end;

procedure TfrmPai.DataSourceStateChange(Sender: TObject);
begin
   EstadoBotoes; // Habilita / Desabilita botões de manipulação de registros(Novo,Salvar,Excluir...)
   EscreverEstadoDataSet; // Escreve o estado do DataSet (dsBrowse,dsEdit,dsInsert..) no Panels[0] da barra de status.
   ControlarPageControl; // Controla a mudança das abas do PageControl, de acordo com o estado atual do DataSet(dsBrowse,dsEdit,dsInsert..)
end;

procedure TfrmPai.tbNovoClick(Sender: TObject);
begin
   NovoRegistro; // Chamada da rotina para inserir novo registro
end;

procedure TfrmPai.tbEditarClick(Sender: TObject);
begin
   EditarRegistro; // Chamada da rotina para Edição de registro
end;

procedure TfrmPai.tbSalvarClick(Sender: TObject);
begin
   If(Not(TemCampoEmBranco))Then // Se todos os fields forão preenchidos então salve no banco.
     SalvarRegistro;
end;

procedure TfrmPai.tbExcluirClick(Sender: TObject);
begin
   ExcluirRegistro; // Chamada da rotina para Exclusão de registro
   AplicarRegistro; // Exclui o registro do banco de dados
end;

procedure TfrmPai.tbCancelarClick(Sender: TObject);
begin
   CancelarRegistro; // Chamada da rotina para Cancelamento de Inclusões ou Alterações
end;

procedure TfrmPai.EscreverHints(parBotao: TToolButton);
begin
   StbPrincipal.Panels[1].Text := parBotao.Hint; // Escreve na barra de status o hinto do botão que for passada como parâemtro
end;

procedure TfrmPai.tbNovoMouseMove(Sender: TObject; Shift: TShiftState; X,
  Y: Integer);
begin // Escreve na barra de status o hinto do botão que for passada como parâemtro.
      // O parâmetro Sender representa o componente que chamou o evento. Por isso, utilizei o TypeCasting para
      // que este código sirva para todos os botões da Classe "TToolButton". Esta rotina foi implementada no evento
      // "OnMouseMove"  do botão tbNovo e todos os outros botões da classe "TToolButton" tiveram o seu evento "OnMouseMove"
      // direcionados para este evento.
   EscreverHints(Sender As TToolButton);
end;

procedure TfrmPai.LimparHints;
begin
   StbPrincipal.Panels[1].Text := ´SCMV´; // Limpa o conteúdo do Panels[1] que foi adicionado(Hint do botão) e adiciona a mesma o valor "SCMV"
end;

procedure TfrmPai.FormMouseMove(Sender: TObject; Shift: TShiftState; X,
  Y: Integer);
begin
   LimparHints; // Limpa o conteúdo do Panels[1] que foi adicionado(Hint do botão) e adiciona a mesma o valor "SCMV"
end;

procedure TfrmPai.EscreverCaption(parFormulario: TForm);
begin
   StbPrincipal.Panels[2].Text := parFormulario.Caption;// Escreve o caption do formulário que é passado como parâmetro (Form Atual) no Panels[2] da barra de status.
end;

procedure TfrmPai.FormCreate(Sender: TObject);
begin
   EscreverCaption(Sender As TForm);// Escreve o caption do formulário que é passado como parâmetro (Form Atual) no Panels[2] da barra de status.
   LimparHints; // Limpa o conteúdo do Panels[1] que foi adicionado(Hint do botão) e adiciona a mesma o valor "SCMV"
end;

procedure TfrmPai.EscreverEstadoDataSet;
begin  // Esta rotina escreve no Panels[0] da barra de status o modo em que o DataSet se encontra (dsBrowse,dsEdit,dsInsert...)
   With(DataSource.DataSet)Do
   Begin
      If(State = dsBrowse)Then
         StbPrincipal.Panels[0].Text := ´Modo de Visualização´
      Else
        If(State = dsInsert)Then
           StbPrincipal.Panels[0].Text := ´Modo de Inclusão´
        Else
          If(State = dsEdit)Then
            StbPrincipal.Panels[0].Text := ´Modo de Edição´
   End;
end;

procedure TfrmPai.pcPrincipalChanging(Sender: TObject;
  var AllowChange: Boolean);
begin // Quando a variável "AllowChange" recebe true, o usuário poderá alternar entre os
      // TabSheets do PageControl; Se o seu valor for false, não poderá alternar entre as TabSheets.
   AllowChange := False; // Não permite que o usuário alterne entre as TabSheet do PageControl.
end;

procedure TfrmPai.ControlarPageControl;
begin // Se o DataSet entrar no modo de Edição ou de Inserção, a TabSheet ativa será a de edição;
      // Caso o DataSet não se encontre em modo de Edição ou Inserção, a TabSheet ativa será a de Exibição
   If(DataSource.DataSet.State In [dsInsert,dsEdit])Then
     pcPrincipal.ActivePage := tsEdicao
   Else
     pcPrincipal.ActivePage := tsExibicao;
end;

procedure TfrmPai.DBGrid1DblClick(Sender: TObject);
begin
   If(DataSource.DataSet.RecordCount > 0)Then // Se o DataSet possuir registros cadastrados então
     EditarRegistro; // Quando o usuário der um DuploClick no DbGrid, o DataSet entrará no modo de Edição;
end;

function TfrmPai.TemCampoEmBranco : Boolean;
Var
  Cont : Byte; // Variável que controlará o laçõ em todos os Fields do DataSet
begin
   Result := False; // Supõe que todos os campos estejam preenchidos
   With(DataSource.DataSet)Do
   Begin
      For Cont := 0 To FieldCount -1 Do // Faz um laço em todos os Fields a procura de fields que são requeridos e estão
      Begin                             // em branco(não foi preenchido) e que tenha a tag = 0(zero). Caso encontre, o sistema entrará na rotina abaixo.
                                        // Todos os fields que são primary key terão sua propriedade requerid como false, pois os mesmos não deverão entrar nesta rotina,
                                        // já que seus velores são gerados pela rotina "AutoIncrementar()".
            If((Trim(Fields[Cont].AsString) = ´´)And(Fields[Cont].Required))Then
            Begin
               MessageBeep(64);
               MessageDlg(Format(´Preencha o campo ´´¬s´´´,[Fields[Cont].DisplayLabel]),mtInformation,[mbOk],0);
               Fields[Cont].FocusControl; // Focaliza o cursor no Fields que não foi preenchido.
               Result := True; // Informa que existem campos requeridos que não forão preenchidos.
               Break; // Sai do laço
               Exit;  // Sai da Rotina
            End;
         End;
   End;
end;

procedure TfrmPai.AutoIncrementar(parTabela: String; parCh_Primaria : TField);
Var
  Qry : TSQLQuery;
begin
   If(DataSource.DataSet.State <> dsInsert)Then
     Exit;
   Qry := TSQLQuery.Create(Nil);
   Try// Está rotina é responsável pelo autoincremento dos campos que são chave primária de uma determinada tabela.
      // parTabela: Este parâmetro representa o nome da tabela pelo qual se quer adicionar um novo valor para sua chave primária.
      // parCh_Primaria: Este parâmetro representa um Field. Este Field deverá ser a chave primária da tabela que se quer
         // incluir um novo registro.
     Qry.SQLConnection := DtModConexao.SqlConexao;
     Qry.SQL.Add(´SELECT MAX(´+parCh_Primaria.FieldName+´)From ´+parTabela);
     Try
       Qry.Open; // Execução do Sql
       If(Qry.Fields[0].IsNull)Then
         parCh_Primaria.AsInteger := 1
       Else
         parCh_Primaria.AsInteger := Qry.Fields[0].AsInteger + 1; // O novo valor gerado é adicionado a chave primária da tabela.
     Except // Caso ocorra erro, será gerado o erro abaixo.
       On Exc: EDatabaseError Do
         MessageDlg(´Erro ao abrir a query AUTOINCREMENTO: ´+Exc.Message,mtError,[mbOk],0);
     End;
   Finally
     FreeAndNil(Qry); // Libera o objeto da memória.
   End;
end;

procedure TfrmPai.DesejaSalvar(Var parAcao : TCloseAction);
Var
  Resp : Word; // Armazenará a resposta do usuários (Se ele deseja salvar ou não as alterações/Inclusões)
begin
   If(Not(DataSource.DataSet.State In [dsInsert,dsEdit]))Then // Se Não estiver no modo de Edição ou Inclusão
   Begin                                                      // então sairá da rotina.
     DataSource.DataSet.Close; // Fecha a query;
     Exit;
   End;
   MessageBeep(64);
   Resp := MessageDlg(´Deseja salvar as alterações?´,mtInformation,mbYesNoCancel,0);
   If(Resp = mrYes)Then // Entrerá aqui quando o usuário responder que deseja salvar as alterações.
   Begin                // Então, o registro poderá ser salvo (Se não houver campos em branco) e a janela
                        // Será liberado de memória.
      If(Not(TemCampoEmBranco))Then // Se não tiver campo em branco o registro atual será salvo e a janela
                                      // será liberada de memória.
      Begin
         SalvarRegistro; // Salvar o Registro
         parAcao := caFree; // Libera a janela de memória (parAcao que é passado por referência)
         DataSource.DataSet.Close; // Fecha a query;
      End
      Else
        Begin // Entrará aqui quando o usuário responder que deseja salvar as alterções, mas existe campos requerido
              // em branco. Então, será exibido uma mensagem para o usuário informando qual foi o campo que ele não
              // preencheu corretamente(Quem faz isso é a rotina "TemCampoEmBranco") e a janela não será liberada de memória.
           parAcao := caNone; // Não liberação da janela de memória (Não fecha o formulário de Inclusão/Edição)
        End;
   End
   Else
     If(Resp = mrNo)Then // Entrará aqui quando o usuário responder que não deseja salvar as alterações. Então, o registro
     Begin // que se está editando ou incluindo será cancelado e o formulário será liberado de memória (Fecha a Janela de edição/inclusão)
       CancelarRegistro; // Cancelamento do registro;
       parAcao := caFree; // Liberação do objeto de memória;
       DataSource.DataSet.Close; // Fecha a query;
     End
     Else // Entrerá aqui quando o usuário responder que deseja cancelar ou fechar a janelinha da pergunta.
          // Então, a janela não será fechada, pois o usuário pedio o cancelamento da merda que ele fez.....
       Begin
          parAcao := caNone; // Não fecha a janela de inclusão/edição de registro;
       End;
end;

procedure TfrmPai.FormClose(Sender: TObject; var Action: TCloseAction);
begin
   DesejaSalvar(Action); // Verifica se esta havendo alteraçao ou inclusão de registros antes de fechar a janela,
                            // perguntando se o usuário deseja salvar as alterações
end;

procedure TfrmPai.Focalizar(parCampo: TDBEdit);
begin   // Esta rotina coloca o focus em um campo que não é requido pelo sistema, evitando assim que não hora de gravar os dados, o sistema não ignore o campo atual focalizado.
   If(DataSource.DataSet.State In [dsInsert,dsEdit])Then
   parCampo.SetFocus;
end;


procedure TfrmPai.Enter(parBotao: TToolButton; parTecha: Char);
begin  // Esta rotina simulará o click do botão salvar para que alterações ou inclusões de registros
   If(parTecha = 13)Then // sejam salvar. Será ativada quando o usuário techar "ENTER"
     parBotao.Click;
end;

procedure TfrmPai.tbPesquisarClick(Sender: TObject);
begin
   frmPesquisaPadrao := TfrmPesquisaPadrao.Create(Self);
   Try
      frmPesquisaPadrao.ShowModal;
   Finally
      FreeAndNil(frmPesquisaPadrao);
   End;
end;

procedure TfrmPai.ExibirRelatorio(parReport: TRLReport; parClientDataSet : TClientDataSet; parParametro : String);
begin
   parClientDataSet.Close;
   parClientDataSet.Params[0].AsString := parParametro;
   parClientDataSet.Open;
   parReport.Preview;
end;

end.