// 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);
}