Club Builder - Foros de discusión Club Builder
Foro de C++Builder en español
 
 FAQFAQ   BuscarBuscar   MiembrosMiembros   Grupos de UsuariosGrupos de Usuarios   RegistrarseRegistrarse 
 PerfilPerfil   Entra para ver tus mensajes privadosEntra para ver tus mensajes privados   EntrarEntrar 

Modificaciones en un form

 
Publicar nuevo tema   Responder al tema    Foros de discusión -> Consultas
Ver tema anterior :: Ver tema siguiente  
Autor Mensaje
Mensaje    Asunto: Modificaciones en un form Responder citando

Hola amigos:
Estoy realizando una aplicación que utiliza INTERBASE como motor de la Base de datos.
Mi problema es el siguiente.
Cuando entro para crear una nueva ficha de cliente, necesito activar el boton de Grabar, sólo si se han hecho modificaciones en la ficha y de esta forma si pulso salir sin grabar, debe avisarme.
Un método rápido es hacer un evento OnChange en cada uno de los controles y activar una variable Booleana indicando las modificaciones.
Poco elegante y lento.
Otro método sería hacer Trim a todos los textos de los controles de entrada y si son null, no hacer nada.
Poco elegante tambien.

¿Alguien sabe como hacerlo de forma eficiente?

Muchas gracias a todos
_________________
La pintura es la expresión de la mente.
Volver arriba
Ver perfil de usuario Enviar mensaje privado Enviar email
Mensaje    Asunto: Responder citando

Si, se puede hacer de manera mas eficiente.

Pero desconozco como tengas diseñado tu form para la entrada de datos. Al menos yo utilizo sólo dos botones en el formulario de entrada de datos, el boton Aceptar (equivale a grabar) y el botón Cancelar.

Como es sabido, cada quien utiliza diferentes técnicas para estos procesos, por lo que yo te pueda decir es de acuerdo a mi experiencia. Habrá muchas formas de hacerlo, pero eso depende -como te digo- de la experiencia de cada quien.

Saludos.
_________________
Quien hace una pregunta teme parecer un ignorante durante cinco minutos, quien no pregunta se mantiene ignorante toda la vida.
Volver arriba
Ver perfil de usuario Enviar mensaje privado Enviar email MSN Messenger
Mensaje    Asunto: Responder citando

En realidad lo que quiero no es tener dos botones sino que el sistema detecte si se ha producido algún cambio en algún control de entrada de datos. Es decir si en el nombre escribo "Fran", el botón de grabar se active.
_________________
La pintura es la expresión de la mente.
Volver arriba
Ver perfil de usuario Enviar mensaje privado Enviar email
Mensaje    Asunto: Responder citando

Pudes usar el estado del DataSet asociado, dependiendo el estado que ocurra dentro de la tabla, query o dataset,

ejemplo

Código:
if( TuDataSet->State == dsEdit || TuDataSet->State == dsInsert)
{
    //ponemos el boton a grabar o aceptar
    // ya que la tabla se encuentra en el estado de modificacion
    // o se encuentra en el estado de Inserccion
}


Donde "TuDataSet" es el DataSet que queres monitorear
_________________
Cool
Volver arriba
Ver perfil de usuario Enviar mensaje privado Enviar email MSN Messenger
Mensaje    Asunto: Responder citando

Bueno, pues me imagino que tienes un control DataSource asociado a tu DataSet. Puedes aprovechar el evento OnDataChange para hacer lo que necesitas.

Código:

       
        TDataSource  *Data = static_cast<TDataSource*>(Sender);

         //Si el Estado del DataSource es diferente del estado de
         //Exploracion se //habilita tu boton, esto quiere decir,
        //que el estado puede ser de Insercion o de Edicion
         
        if ( Data->State != dsBrowse )
                Button1->Enabled = true;


Saludos
_________________
Quien hace una pregunta teme parecer un ignorante durante cinco minutos, quien no pregunta se mantiene ignorante toda la vida.
Volver arriba
Ver perfil de usuario Enviar mensaje privado Enviar email MSN Messenger
Mensaje    Asunto: Responder citando

Se me paso poner el código completo.

Código:

void __fastcall TForm1::DataSource1DataChange(TObject *Sender,
      TField *Field)
{
        TDataSource  *Data = static_cast<TDataSource*>(Sender);

        if ( Data->State != dsBrowse )
                Button1->Enabled = true;
}

_________________
Quien hace una pregunta teme parecer un ignorante durante cinco minutos, quien no pregunta se mantiene ignorante toda la vida.
Volver arriba
Ver perfil de usuario Enviar mensaje privado Enviar email MSN Messenger
Mensaje    Asunto: Responder citando

Uso un componente que derive del TMainMenu y me facilita las cosas en este aspecto, simplemente lo coloco en el form y enlazo su propiedad DataSource al que apunte a la tabla deseada. El compo se ocupa de poner las propiedades de los componentes DataAware a read only segun el caso.

Tiene los siguentes Menuitems: Nuevo, Editar, Borrar, Aceptar y Cancelar
estos se habilitan y deshabilitan automaticamente segun el estado de la
tabla aqui esta el codigo:
*.h
Código:
//---------------------------------------------------------------------------

#ifndef CBDataMenuH
#define CBDataMenuH
//---------------------------------------------------------------------------
#include <SysUtils.hpp>
#include <Db.hpp>
#include <Classes.hpp>
#include <Menus.hpp>
#include <Forms.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <DBClient.hpp>
#include <DBCtrls.hpp>
#include <ExtCtrls.hpp>
#include <Mask.hpp>
#include <DBGrids.hpp>
#include <Grids.hpp>
//---------------------------------------------------------------------------
class PACKAGE TCBDataMenu : public TMainMenu
{
private:
TDataSource *FMasterDataSource;
TDataSource *DataSource;

void __fastcall NuevoClick(TObject *Sender);
void __fastcall EditarClick(TObject *Sender);
void __fastcall AceptarClick(TObject *Sender);
void __fastcall CancelarClick(TObject *Sender);
void __fastcall BorrarClick(TObject *Sender);
void __fastcall DataSourceStateChange(TObject *Sender);
void __fastcall Habilitacion(bool Valor);

void __fastcall NuevoItemClick(TObject* Sender);


protected:
public:
        __fastcall TCBDataMenu(TComponent* Owner);
        void __fastcall CrearMenu();
        TMenuItem *ArchivoItem;
        TMenuItem *BorrarItem;
        TMenuItem *NuevoItem;
        TMenuItem *EditarItem;
        TMenuItem *SepItem;
        TMenuItem *AceptarItem;
        TMenuItem *CancelarItem;
__published:
__property TDataSource *MasterDataSource={read=FMasterDataSource,write=FMasterDataSource};
};
//---------------------------------------------------------------------------
#endif
El *.cpp
Código:
//---------------------------------------------------------------------------

#include <basepch.h>

#pragma hdrstop

#include "CBDataMenu.h"
#pragma package(smart_init)
//---------------------------------------------------------------------------
// ValidCtrCheck is used to assure that the components created do not have
// any pure virtual functions.
//

static inline void ValidCtrCheck(TCBDataMenu *)
{
        new TCBDataMenu(NULL);
}
//---------------------------------------------------------------------------
__fastcall TCBDataMenu::TCBDataMenu(TComponent* Owner)
        : TMainMenu(Owner)
{


}
//---------------------------------------------------------------------------
namespace Cbdatamenu
{
        void __fastcall PACKAGE Register()
        {
                 TComponentClass classes[1] = {__classid(TCBDataMenu)};
                 RegisterComponents("Club Builder", classes, 0);
        }
}
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
void __fastcall TCBDataMenu::NuevoClick(TObject *Sender)
{
 FMasterDataSource->DataSet->Append();
}
//---------------------------------------------------------------------------
void __fastcall TCBDataMenu::EditarClick(TObject *Sender)
{
 FMasterDataSource->DataSet->Edit();
}
//--------------------------------------------------------------------------
void __fastcall TCBDataMenu::AceptarClick(TObject *Sender)
{
 FMasterDataSource->DataSet->Post();
}
//--------------------------------------------------------------------------
void __fastcall TCBDataMenu::CancelarClick(TObject *Sender)
{
 FMasterDataSource->DataSet->Cancel();
}
//--------------------------------------------------------------------------

void __fastcall TCBDataMenu::BorrarClick(TObject *Sender)
{
 FMasterDataSource->DataSet->Delete();
}
//---------------------------------------------------------------------------
void __fastcall TCBDataMenu::CrearMenu()
{


 ArchivoItem = new TMenuItem(Owner);
 ArchivoItem->Caption = "&Archivo";
 NuevoItem =new TMenuItem(Owner);
 NuevoItem->Caption = "&Nuevo";
 NuevoItem->OnClick=NuevoClick;
 ArchivoItem->Add(NuevoItem);
 EditarItem=new TMenuItem(Owner);
 EditarItem->Caption="&Editar";
 EditarItem->OnClick=EditarClick;
 ArchivoItem->Add(EditarItem);
 BorrarItem=new TMenuItem(Owner);
 BorrarItem->Caption="&Borrar";
 BorrarItem->OnClick=BorrarClick;
 ArchivoItem->Add(BorrarItem);
 SepItem=new TMenuItem(Owner);
 SepItem->Caption="-";
 ArchivoItem->Add(SepItem);
 AceptarItem=new TMenuItem(Owner);
 AceptarItem->Caption="&Aceptar";
 AceptarItem->OnClick=AceptarClick;
 AceptarItem->Enabled=false;
 ArchivoItem->Add(AceptarItem);
 CancelarItem= new TMenuItem(Owner);
 CancelarItem->Caption="&Cancelar";
 CancelarItem->OnClick=CancelarClick;
 CancelarItem->Enabled=false;
 ArchivoItem->Add(CancelarItem);
 this->Items->Add(ArchivoItem);
 ArchivoItem->MenuIndex=0;
  //*** chequear DataSource   por cambio de estado
 DataSource=new TDataSource(Owner);
 DataSource->DataSet=FMasterDataSource->DataSet;
 DataSource->OnStateChange=DataSourceStateChange;
 DataSourceStateChange(0);
}
//---------------------------------------------------------------------------
/*TMenuItem *ClickedItem = dynamic_cast<TMenuItem *>(Sender);
if (ClickedItem)*/
//---------------------------------------------------------------------------
void __fastcall TCBDataMenu::DataSourceStateChange(TObject *Sender)
{

 if(DataSource->DataSet->State==dsInsert||DataSource->DataSet->State==dsEdit)
                                           
   {
    //Deshabilitar todos los Items

    Habilitacion(false);
    //Habilitar los pertinentes
    ArchivoItem->Enabled=true;
    AceptarItem->Enabled=true;
    CancelarItem->Enabled=true;
    //Poner todos los controles DB ReadOnly=false;
   
   }
  else
   {
     //Habilitar todos los Items

    Habilitacion(true);
    //Deshabilitar los pertinentes
    AceptarItem->Enabled=false;
    CancelarItem->Enabled=false;

   }
}
//---------------------------------------------------------------------------
void __fastcall TCBDataMenu::Habilitacion(bool Valor)
{
TMenuItem *Item;
TForm *Form;
Form=(TForm *)Owner;
TDBGrid *Grid;
TDBNavigator *Nav;
TDBEdit *Edit;
TDBMemo *Memo;
TDBImage *Image;
TDBListBox *List;
TDBComboBox *Combo;
TDBCheckBox *Check;
TDBRadioGroup *Radio;
TDBLookupListBox *LookList;
TDBLookupComboBox *LookCombo;
TDBRichEdit *Rich;

 for(int i=0;i<Form->ComponentCount;i++)
    {
     if (Form->Components[i]->ClassNameIs("TMenuItem"))
       {
        Item = (TMenuItem *)Form->Components[i];
        Item->Enabled=Valor;
       }
     if (Form->Components[i]->ClassNameIs("TDBGrid"))
       {
        Grid = (TDBGrid *)Form->Components[i];
        Grid->ReadOnly=Valor;
       }
     if (Form->Components[i]->ClassNameIs("TDBNavigator"))
       {
        Nav = (TDBNavigator *)Form->Components[i];
        Nav->Enabled=Valor;
       }
     if (Form->Components[i]->ClassNameIs("TDBEdit"))
       {
        Edit = (TDBEdit *)Form->Components[i];
        Edit->ReadOnly=Valor;
       }
     if (Form->Components[i]->ClassNameIs("TDBMemo"))
       {
        Memo = (TDBMemo *)Form->Components[i];
        Memo->ReadOnly=Valor;
       }
     if (Form->Components[i]->ClassNameIs("TDBImage"))
       {
        Image = (TDBImage *)Form->Components[i];
        Image->ReadOnly=Valor;
       }
     if (Form->Components[i]->ClassNameIs("TDBListBox"))
       {
        List = (TDBListBox *)Form->Components[i];
        List->ReadOnly=Valor;
       }
     if (Form->Components[i]->ClassNameIs("TDBComboBox"))
       {
        Combo = (TDBComboBox *)Form->Components[i];
        Combo->ReadOnly=Valor;
       }
     if (Form->Components[i]->ClassNameIs("TDBCheckBox"))
       {
        Check = (TDBCheckBox *)Form->Components[i];
        Check->ReadOnly=Valor;
       }
     if (Form->Components[i]->ClassNameIs("TDBRadioGroup"))
       {
        Radio = (TDBRadioGroup *)Form->Components[i];
        Radio->ReadOnly=Valor;
       }
     if (Form->Components[i]->ClassNameIs("TDBLookupListBox"))
       {
        LookList = (TDBLookupListBox *)Form->Components[i];
        LookList->ReadOnly=Valor;
       }
     if (Form->Components[i]->ClassNameIs("TDBLookupComboBox"))
       {
        LookCombo = (TDBLookupComboBox *)Form->Components[i];
        LookCombo->ReadOnly=Valor;
       }
     if (Form->Components[i]->ClassNameIs("TDBRichEdit"))
       {
        Rich = (TDBRichEdit *)Form->Components[i];
        Rich->ReadOnly=Valor;
       }
    }
}
Volver arriba
Ver perfil de usuario Enviar mensaje privado Enviar email
Mostrar mensajes de anteriores:   
Cambiar a:  
No puedes publicar temas nuevos en este foro
No puedes responder a temas en este foro
No puedes editar tus mensajes en este foro
No puedes borrar tus mensajes en este foro
No puedes votar en las encuestas de este foro


Hosting WordPress Indedmedia desde 3,99 €
© 2002–2026 Club Builder · Funciona con phpBB.