594 lines
16 KiB
C++
594 lines
16 KiB
C++
// Version: 2014.7.30 16:47:28
|
|
|
|
// File: T_HMI_DISPSETUP.cpp
|
|
|
|
#include "T_HMI_DISPSETUP.h"
|
|
|
|
T_HMI_DISPSETUP::T_HMI_DISPSETUP(){
|
|
// initialise all membervariables
|
|
initial();
|
|
}
|
|
T_HMI_DISPSETUP::~T_HMI_DISPSETUP(){
|
|
}
|
|
void T_HMI_DISPSETUP::initial(){
|
|
// initialise all membervariables
|
|
set_TableName("");
|
|
set_ColumnName("");
|
|
set_DispName("");
|
|
set_DispNameZi(-1);
|
|
set_GridName("");
|
|
set_GridNameZi(-1);
|
|
set_InsertName("");
|
|
set_InsertNameZi(-1);
|
|
set_Dispos(0);
|
|
set_DisposZi(-1);
|
|
set_Ratio(0.0);
|
|
set_RatioZi(-1);
|
|
set_DisposLR("");
|
|
set_DisposLRZi(-1);
|
|
set_toc("");
|
|
set_tocZi(-1);
|
|
set_tom("");
|
|
set_tomZi(-1);
|
|
set_mop("");
|
|
set_mopZi(-1);
|
|
set_mou("");
|
|
set_mouZi(-1);
|
|
// initialies Primary key members
|
|
set_k_TableName("");
|
|
set_k_ColumnName("");
|
|
}
|
|
T_HMI_DISPSETUP::T_HMI_DISPSETUP(const char* arg1,const char* arg2)
|
|
{
|
|
initial();
|
|
setPrimKey (arg1, arg2);
|
|
//read DB record
|
|
dbAccess = true;
|
|
dbMessage = readDB();
|
|
if ( dbMessage != NULL ) {dbAccess = false;}
|
|
}
|
|
|
|
char* T_HMI_DISPSETUP:: execute(const char* sql , long* count){
|
|
return( db.execute( sql , count ) );
|
|
}
|
|
|
|
char* T_HMI_DISPSETUP:: dbCommit(){
|
|
return( db.dbCommit( ) );
|
|
}
|
|
|
|
char* T_HMI_DISPSETUP:: dbRollback(){
|
|
return( db.dbRollback( ) );
|
|
}
|
|
|
|
char* T_HMI_DISPSETUP::readDB(){
|
|
// DB Trace is off
|
|
return( db.readDB(*this) );
|
|
}
|
|
|
|
char* T_HMI_DISPSETUP::updateDB(){
|
|
// DB Trace is off
|
|
return( db.updateDB(*this) );
|
|
}
|
|
|
|
char* T_HMI_DISPSETUP::insertDB(){
|
|
// DB Trace is off
|
|
return( db.insertDB(*this) );
|
|
}
|
|
|
|
char* T_HMI_DISPSETUP::deleteDB(){
|
|
// DB Trace is off
|
|
return( db.deleteDB(*this) );
|
|
}
|
|
|
|
char* T_HMI_DISPSETUP::deleteDB(const char * where, long* count){
|
|
// DB Trace is off
|
|
return( db.deleteDB( where , count ) );
|
|
}
|
|
|
|
char* T_HMI_DISPSETUP::openSetDB(const char * where,const char* order){
|
|
// DB Trace is off
|
|
return( db.openSetDB( where , order ) );
|
|
}
|
|
|
|
char* T_HMI_DISPSETUP::countDB(const char * where, long* count){
|
|
// DB Trace is off
|
|
return( db.countDB( where , count ) );
|
|
}
|
|
|
|
char* T_HMI_DISPSETUP::getSetDB(){
|
|
// DB Trace is off
|
|
return( db.getSetDB(*this) );
|
|
}
|
|
|
|
char* T_HMI_DISPSETUP::closeSetDB(){
|
|
// DB Trace is off
|
|
return( db.closeSetDB() );
|
|
}
|
|
|
|
char* T_HMI_DISPSETUP::storeDB(){
|
|
char* ret = NULL;
|
|
setKeysFromRecord();
|
|
ret=db.updateDB(*this);
|
|
if(ret != NULL){
|
|
ret=db.insertDB(*this);
|
|
if(ret != NULL){
|
|
dbAccess = false;
|
|
return(ret);
|
|
}
|
|
}
|
|
return(ret);
|
|
}
|
|
|
|
// public methode setPrimKey T_HMI_DISPSETUP
|
|
//
|
|
// this methode stores the unique key attributes
|
|
//
|
|
void T_HMI_DISPSETUP::setPrimKey( const char* arg1 , const char* arg2 ){
|
|
strncpy( (char*)c_k_TableName , arg1 , sizeof(c_k_TableName) );
|
|
c_k_TableName[sizeof(c_k_TableName)-1] = '\0';
|
|
strncpy( (char*)c_k_ColumnName , arg2 , sizeof(c_k_ColumnName) );
|
|
c_k_ColumnName[sizeof(c_k_ColumnName)-1] = '\0';
|
|
} // end of methode
|
|
|
|
void T_HMI_DISPSETUP::initInsertKeys( const char* arg1 , const char* arg2 ){
|
|
setPrimKey ( arg1 , arg2);
|
|
strncpy( (char*)c_TableName , arg1 , sizeof(c_TableName) );
|
|
c_TableName[sizeof(c_TableName)-1] = '\0';
|
|
strncpy( (char*)c_ColumnName , arg2 , sizeof(c_ColumnName) );
|
|
c_ColumnName[sizeof(c_ColumnName)-1] = '\0';
|
|
} // end of methode
|
|
void T_HMI_DISPSETUP::setKeysFromRecord(){
|
|
set_k_TableName( TableName() );
|
|
set_k_ColumnName( ColumnName() );
|
|
} // end of methode
|
|
//
|
|
//O P E R A T O R +
|
|
//===================
|
|
//
|
|
T_HMI_DISPSETUP T_HMI_DISPSETUP::operator+(const T_HMI_DISPSETUP &inst) const{
|
|
T_HMI_DISPSETUP ptrT_HMI_DISPSETUP(*this);
|
|
//----------------------------------------------------------
|
|
ptrT_HMI_DISPSETUP.set_TableName(inst.TableName());
|
|
//----------------------------------------------------------
|
|
ptrT_HMI_DISPSETUP.set_ColumnName(inst.ColumnName());
|
|
//----------------------------------------------------------
|
|
if(inst.DispNameZi() != -1){
|
|
ptrT_HMI_DISPSETUP.set_DispName(inst.DispName());
|
|
ptrT_HMI_DISPSETUP.set_DispNameZi(inst.DispNameZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.GridNameZi() != -1){
|
|
ptrT_HMI_DISPSETUP.set_GridName(inst.GridName());
|
|
ptrT_HMI_DISPSETUP.set_GridNameZi(inst.GridNameZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.InsertNameZi() != -1){
|
|
ptrT_HMI_DISPSETUP.set_InsertName(inst.InsertName());
|
|
ptrT_HMI_DISPSETUP.set_InsertNameZi(inst.InsertNameZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.DisposZi() != -1){
|
|
ptrT_HMI_DISPSETUP.set_Dispos(inst.Dispos());
|
|
ptrT_HMI_DISPSETUP.set_DisposZi(inst.DisposZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.RatioZi() != -1){
|
|
ptrT_HMI_DISPSETUP.set_Ratio(inst.Ratio());
|
|
ptrT_HMI_DISPSETUP.set_RatioZi(inst.RatioZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.DisposLRZi() != -1){
|
|
ptrT_HMI_DISPSETUP.set_DisposLR(inst.DisposLR());
|
|
ptrT_HMI_DISPSETUP.set_DisposLRZi(inst.DisposLRZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.tocZi() != -1){
|
|
ptrT_HMI_DISPSETUP.set_toc(inst.toc());
|
|
ptrT_HMI_DISPSETUP.set_tocZi(inst.tocZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.tomZi() != -1){
|
|
ptrT_HMI_DISPSETUP.set_tom(inst.tom());
|
|
ptrT_HMI_DISPSETUP.set_tomZi(inst.tomZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.mopZi() != -1){
|
|
ptrT_HMI_DISPSETUP.set_mop(inst.mop());
|
|
ptrT_HMI_DISPSETUP.set_mopZi(inst.mopZi());
|
|
}
|
|
//----------------------------------------------------------
|
|
if(inst.mouZi() != -1){
|
|
ptrT_HMI_DISPSETUP.set_mou(inst.mou());
|
|
ptrT_HMI_DISPSETUP.set_mouZi(inst.mouZi());
|
|
}
|
|
return (ptrT_HMI_DISPSETUP);
|
|
}
|
|
|
|
//
|
|
//O P E R A T O R =
|
|
//===================
|
|
//
|
|
const T_HMI_DISPSETUP& T_HMI_DISPSETUP::operator=(const T_HMI_DISPSETUP &inst){
|
|
//----------------------------------------------------------
|
|
this->set_TableName(inst.TableName());
|
|
//----------------------------------------------------------
|
|
this->set_ColumnName(inst.ColumnName());
|
|
//----------------------------------------------------------
|
|
this->set_DispName(inst.DispName());
|
|
this->set_DispNameZi(inst.DispNameZi());
|
|
//----------------------------------------------------------
|
|
this->set_GridName(inst.GridName());
|
|
this->set_GridNameZi(inst.GridNameZi());
|
|
//----------------------------------------------------------
|
|
this->set_InsertName(inst.InsertName());
|
|
this->set_InsertNameZi(inst.InsertNameZi());
|
|
//----------------------------------------------------------
|
|
this->set_Dispos(inst.Dispos());
|
|
this->set_DisposZi(inst.DisposZi());
|
|
//----------------------------------------------------------
|
|
this->set_Ratio(inst.Ratio());
|
|
this->set_RatioZi(inst.RatioZi());
|
|
//----------------------------------------------------------
|
|
this->set_DisposLR(inst.DisposLR());
|
|
this->set_DisposLRZi(inst.DisposLRZi());
|
|
//----------------------------------------------------------
|
|
this->set_toc(inst.toc());
|
|
this->set_tocZi(inst.tocZi());
|
|
//----------------------------------------------------------
|
|
this->set_tom(inst.tom());
|
|
this->set_tomZi(inst.tomZi());
|
|
//----------------------------------------------------------
|
|
this->set_mop(inst.mop());
|
|
this->set_mopZi(inst.mopZi());
|
|
//----------------------------------------------------------
|
|
this->set_mou(inst.mou());
|
|
this->set_mouZi(inst.mouZi());
|
|
return (*this);
|
|
}
|
|
//
|
|
//C O P Y - C O N S T R U C T O R
|
|
//===================
|
|
//
|
|
T_HMI_DISPSETUP::T_HMI_DISPSETUP(const T_HMI_DISPSETUP &inst){
|
|
//----------------------------------------------------------
|
|
this->set_TableName(inst.TableName());
|
|
//----------------------------------------------------------
|
|
this->set_ColumnName(inst.ColumnName());
|
|
//----------------------------------------------------------
|
|
this->set_DispName(inst.DispName());
|
|
this->set_DispNameZi(inst.DispNameZi());
|
|
//----------------------------------------------------------
|
|
this->set_GridName(inst.GridName());
|
|
this->set_GridNameZi(inst.GridNameZi());
|
|
//----------------------------------------------------------
|
|
this->set_InsertName(inst.InsertName());
|
|
this->set_InsertNameZi(inst.InsertNameZi());
|
|
//----------------------------------------------------------
|
|
this->set_Dispos(inst.Dispos());
|
|
this->set_DisposZi(inst.DisposZi());
|
|
//----------------------------------------------------------
|
|
this->set_Ratio(inst.Ratio());
|
|
this->set_RatioZi(inst.RatioZi());
|
|
//----------------------------------------------------------
|
|
this->set_DisposLR(inst.DisposLR());
|
|
this->set_DisposLRZi(inst.DisposLRZi());
|
|
//----------------------------------------------------------
|
|
this->set_toc(inst.toc());
|
|
this->set_tocZi(inst.tocZi());
|
|
//----------------------------------------------------------
|
|
this->set_tom(inst.tom());
|
|
this->set_tomZi(inst.tomZi());
|
|
//----------------------------------------------------------
|
|
this->set_mop(inst.mop());
|
|
this->set_mopZi(inst.mopZi());
|
|
//----------------------------------------------------------
|
|
this->set_mou(inst.mou());
|
|
this->set_mouZi(inst.mouZi());
|
|
}
|
|
char* T_HMI_DISPSETUP::TableName() const{
|
|
return((char*)c_TableName );
|
|
}
|
|
|
|
|
|
void T_HMI_DISPSETUP::set_TableName( const char* arg ){
|
|
strncpy((char*)c_TableName , arg , sizeof(c_TableName));
|
|
c_TableName[sizeof(c_TableName)-1] = '\0';
|
|
return;
|
|
}
|
|
|
|
|
|
char* T_HMI_DISPSETUP::ColumnName() const{
|
|
return((char*)c_ColumnName );
|
|
}
|
|
|
|
|
|
void T_HMI_DISPSETUP::set_ColumnName( const char* arg ){
|
|
strncpy((char*)c_ColumnName , arg , sizeof(c_ColumnName));
|
|
c_ColumnName[sizeof(c_ColumnName)-1] = '\0';
|
|
return;
|
|
}
|
|
|
|
|
|
char* T_HMI_DISPSETUP::DispName() const{
|
|
return((char*)c_DispName );
|
|
}
|
|
|
|
short T_HMI_DISPSETUP::DispNameZi() const{
|
|
return( s_DispNameZi);
|
|
}
|
|
|
|
void T_HMI_DISPSETUP::set_DispName( const char* arg ){
|
|
strncpy((char*)c_DispName , arg , sizeof(c_DispName));
|
|
c_DispName[sizeof(c_DispName)-1] = '\0';
|
|
s_DispNameZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_HMI_DISPSETUP::set_DispNameZi( short arg ) {
|
|
s_DispNameZi = arg;
|
|
}
|
|
|
|
char* T_HMI_DISPSETUP::GridName() const{
|
|
return((char*)c_GridName );
|
|
}
|
|
|
|
short T_HMI_DISPSETUP::GridNameZi() const{
|
|
return( s_GridNameZi);
|
|
}
|
|
|
|
void T_HMI_DISPSETUP::set_GridName( const char* arg ){
|
|
strncpy((char*)c_GridName , arg , sizeof(c_GridName));
|
|
c_GridName[sizeof(c_GridName)-1] = '\0';
|
|
s_GridNameZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_HMI_DISPSETUP::set_GridNameZi( short arg ) {
|
|
s_GridNameZi = arg;
|
|
}
|
|
|
|
char* T_HMI_DISPSETUP::InsertName() const{
|
|
return((char*)c_InsertName );
|
|
}
|
|
|
|
short T_HMI_DISPSETUP::InsertNameZi() const{
|
|
return( s_InsertNameZi);
|
|
}
|
|
|
|
void T_HMI_DISPSETUP::set_InsertName( const char* arg ){
|
|
strncpy((char*)c_InsertName , arg , sizeof(c_InsertName));
|
|
c_InsertName[sizeof(c_InsertName)-1] = '\0';
|
|
s_InsertNameZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_HMI_DISPSETUP::set_InsertNameZi( short arg ) {
|
|
s_InsertNameZi = arg;
|
|
}
|
|
|
|
short T_HMI_DISPSETUP::Dispos() const{
|
|
return((short)s_Dispos );
|
|
}
|
|
|
|
short T_HMI_DISPSETUP::DisposZi() const{
|
|
return( s_DisposZi);
|
|
}
|
|
|
|
void T_HMI_DISPSETUP::set_Dispos( short arg ){
|
|
s_Dispos = arg;
|
|
s_DisposZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_HMI_DISPSETUP::set_DisposZi( short arg ) {
|
|
s_DisposZi = arg;
|
|
}
|
|
|
|
double T_HMI_DISPSETUP::Ratio() const{
|
|
return((double)d_Ratio );
|
|
}
|
|
|
|
short T_HMI_DISPSETUP::RatioZi() const{
|
|
return( s_RatioZi);
|
|
}
|
|
|
|
void T_HMI_DISPSETUP::set_Ratio( double arg ){
|
|
d_Ratio = arg;
|
|
s_RatioZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_HMI_DISPSETUP::set_RatioZi( short arg ) {
|
|
s_RatioZi = arg;
|
|
}
|
|
|
|
char* T_HMI_DISPSETUP::DisposLR() const{
|
|
return((char*)c_DisposLR );
|
|
}
|
|
|
|
short T_HMI_DISPSETUP::DisposLRZi() const{
|
|
return( s_DisposLRZi);
|
|
}
|
|
|
|
void T_HMI_DISPSETUP::set_DisposLR( const char* arg ){
|
|
strncpy((char*)c_DisposLR , arg , sizeof(c_DisposLR));
|
|
c_DisposLR[sizeof(c_DisposLR)-1] = '\0';
|
|
s_DisposLRZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_HMI_DISPSETUP::set_DisposLRZi( short arg ) {
|
|
s_DisposLRZi = arg;
|
|
}
|
|
|
|
char* T_HMI_DISPSETUP::toc() const{
|
|
return((char*)c_toc );
|
|
}
|
|
|
|
short T_HMI_DISPSETUP::tocZi() const{
|
|
return( s_tocZi);
|
|
}
|
|
|
|
void T_HMI_DISPSETUP::set_toc( char* arg ){
|
|
strncpy((char*)c_toc , arg , sizeof(c_toc));
|
|
c_toc[sizeof(c_toc)-1] = '\0';
|
|
s_tocZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_HMI_DISPSETUP::set_tocZi( short arg ){
|
|
s_tocZi = arg;
|
|
}
|
|
|
|
char* T_HMI_DISPSETUP::tom() const{
|
|
return((char*)c_tom );
|
|
}
|
|
|
|
short T_HMI_DISPSETUP::tomZi() const{
|
|
return( s_tomZi);
|
|
}
|
|
|
|
void T_HMI_DISPSETUP::set_tom( char* arg ){
|
|
strncpy((char*)c_tom , arg , sizeof(c_tom));
|
|
c_tom[sizeof(c_tom)-1] = '\0';
|
|
s_tomZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_HMI_DISPSETUP::set_tomZi( short arg ){
|
|
s_tomZi = arg;
|
|
}
|
|
|
|
char* T_HMI_DISPSETUP::mop() const{
|
|
return((char*)c_mop );
|
|
}
|
|
|
|
short T_HMI_DISPSETUP::mopZi() const{
|
|
return( s_mopZi);
|
|
}
|
|
|
|
void T_HMI_DISPSETUP::set_mop( char* arg ){
|
|
strncpy((char*)c_mop , arg , sizeof(c_mop));
|
|
c_mop[sizeof(c_mop)-1] = '\0';
|
|
s_mopZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_HMI_DISPSETUP::set_mopZi( short arg ){
|
|
s_mopZi = arg;
|
|
}
|
|
|
|
char* T_HMI_DISPSETUP::mou() const{
|
|
return((char*)c_mou );
|
|
}
|
|
|
|
short T_HMI_DISPSETUP::mouZi() const{
|
|
return( s_mouZi);
|
|
}
|
|
|
|
void T_HMI_DISPSETUP::set_mou( char* arg ){
|
|
strncpy((char*)c_mou , arg , sizeof(c_mou));
|
|
c_mou[sizeof(c_mou)-1] = '\0';
|
|
s_mouZi= 0;
|
|
return;
|
|
}
|
|
|
|
void T_HMI_DISPSETUP::set_mouZi( short arg ){
|
|
s_mouZi = arg;
|
|
}
|
|
|
|
// methodes for Primary key
|
|
char* T_HMI_DISPSETUP::k_TableName(){
|
|
return((char*)c_k_TableName );
|
|
}
|
|
|
|
void T_HMI_DISPSETUP::set_k_TableName( char* arg ){
|
|
strncpy((char*)c_k_TableName , arg , sizeof(c_k_TableName));
|
|
c_k_TableName[sizeof(c_k_TableName)-1] = '\0';
|
|
return;
|
|
}
|
|
|
|
char* T_HMI_DISPSETUP::k_ColumnName(){
|
|
return((char*)c_k_ColumnName );
|
|
}
|
|
|
|
void T_HMI_DISPSETUP::set_k_ColumnName( char* arg ){
|
|
strncpy((char*)c_k_ColumnName , arg , sizeof(c_k_ColumnName));
|
|
c_k_ColumnName[sizeof(c_k_ColumnName)-1] = '\0';
|
|
return;
|
|
}
|
|
|
|
//
|
|
// public methode fillStructure
|
|
//
|
|
// this methode filles the classstructue with the private attributes
|
|
//
|
|
void T_HMI_DISPSETUP::fillStructure(){
|
|
strncpy ( structTable.TableName , TableName(),sizeof(structTable.TableName));
|
|
strncpy ( structTable.ColumnName , ColumnName(),sizeof(structTable.ColumnName));
|
|
strncpy ( structTable.DispName , DispName(),sizeof(structTable.DispName));
|
|
strncpy ( structTable.GridName , GridName(),sizeof(structTable.GridName));
|
|
strncpy ( structTable.InsertName , InsertName(),sizeof(structTable.InsertName));
|
|
structTable.Dispos = Dispos();
|
|
structTable.Ratio = Ratio();
|
|
strncpy ( structTable.DisposLR , DisposLR(),sizeof(structTable.DisposLR));
|
|
strncpy ( structTable.toc , toc(),sizeof(structTable.toc));
|
|
strncpy ( structTable.tom , tom(),sizeof(structTable.tom));
|
|
strncpy ( structTable.mop , mop(),sizeof(structTable.mop));
|
|
strncpy ( structTable.mou , mou(),sizeof(structTable.mou));
|
|
return;
|
|
}
|
|
///////////////////////////////////////////////////
|
|
void T_HMI_DISPSETUP::fillStructureZi(){
|
|
structTableZi.DispNameZi = DispNameZi();
|
|
structTableZi.GridNameZi = GridNameZi();
|
|
structTableZi.InsertNameZi = InsertNameZi();
|
|
structTableZi.DisposZi = DisposZi();
|
|
structTableZi.RatioZi = RatioZi();
|
|
structTableZi.DisposLRZi = DisposLRZi();
|
|
structTableZi.tocZi = tocZi();
|
|
structTableZi.tomZi = tomZi();
|
|
structTableZi.mopZi = mopZi();
|
|
structTableZi.mouZi = mouZi();
|
|
return;
|
|
}
|
|
///////////////////////////////////////////////////
|
|
void T_HMI_DISPSETUP::setStructure() {
|
|
set_DispName( structTable.DispName);
|
|
set_GridName( structTable.GridName);
|
|
set_InsertName( structTable.InsertName);
|
|
set_Dispos( structTable.Dispos);
|
|
set_Ratio( structTable.Ratio);
|
|
set_DisposLR( structTable.DisposLR);
|
|
set_toc(structTable.toc);
|
|
set_tom(structTable.tom);
|
|
set_mop(structTable.mop);
|
|
set_mou(structTable.mou);
|
|
return;
|
|
}
|
|
///////////////////////////////////////////////////
|
|
void T_HMI_DISPSETUP::setStructureZi() {
|
|
set_DispNameZi( structTableZi.DispNameZi);
|
|
set_GridNameZi( structTableZi.GridNameZi);
|
|
set_InsertNameZi( structTableZi.InsertNameZi);
|
|
set_DisposZi( structTableZi.DisposZi);
|
|
set_RatioZi( structTableZi.RatioZi);
|
|
set_DisposLRZi( structTableZi.DisposLRZi);
|
|
set_tocZi(structTableZi.tocZi);
|
|
set_tomZi(structTableZi.tomZi);
|
|
set_mopZi(structTableZi.mopZi);
|
|
set_mouZi(structTableZi.mouZi);
|
|
return;
|
|
}
|
|
///////////////////////////////////////////////////
|
|
char* T_HMI_DISPSETUP::getName(){
|
|
return("T_HMI_DISPSETUP");
|
|
}
|
|
///////////////////////////////////////////////////
|
|
int T_HMI_DISPSETUP::getSqlCode(){
|
|
return( db.dbSqlCode);
|
|
}
|
|
int T_HMI_DISPSETUP::getRowsProcessed(){
|
|
return( db.dbRowsProcessed);
|
|
}
|