static long get_graphic_double(DBADDR *paddr, struct dbr_grDouble *pgd)
{
calcoutRecord *prec = (calcoutRecord *)paddr->precord;
int fieldIndex = dbGetFieldIndex(paddr);
int linkNumber;
switch (fieldIndex) {
case indexof(VAL):
case indexof(HIHI):
case indexof(HIGH):
case indexof(LOW):
case indexof(LOLO):
case indexof(LALM):
case indexof(ALST):
case indexof(MLST):
pgd->lower_disp_limit = prec->lopr;
pgd->upper_disp_limit = prec->hopr;
break;
case indexof(ODLY):
recGblGetGraphicDouble(paddr,pgd);
pgd->lower_disp_limit = 0.0;
break;
default:
linkNumber = get_linkNumber(fieldIndex);
if (linkNumber >= 0) {
dbGetGraphicLimits(&prec->inpa + linkNumber,
&pgd->lower_disp_limit,
&pgd->upper_disp_limit);
} else
recGblGetGraphicDouble(paddr,pgd);
}
return 0;
}
/*****************************************************************************
*
* Allow for only sensible values for displays
*
******************************************************************************/
static long get_graphic_double(DBADDR *paddr, struct dbr_grDouble *pgd)
{
vsRecord *pvs = (vsRecord *)paddr->precord;
int fieldIndex = dbGetFieldIndex(paddr);
if (fieldIndex == vsRecordVAL || fieldIndex == vsRecordPRES) {
pgd->upper_disp_limit = pvs->hopr;
pgd->lower_disp_limit = pvs->lopr;
} else if (fieldIndex == vsRecordCGAP) {
pgd->upper_disp_limit = pvs->hapr;
pgd->lower_disp_limit = pvs->lapr;
} else if (fieldIndex == vsRecordCGBP) {
pgd->upper_disp_limit = pvs->hbpr;
pgd->lower_disp_limit = pvs->lbpr;
} else if (fieldIndex == vsRecordLPRS) {
pgd->upper_disp_limit = pvs->hlpr;
pgd->lower_disp_limit = pvs->llpr;
} else if (fieldIndex == vsRecordLCAP) {
pgd->upper_disp_limit = pvs->halr;
pgd->lower_disp_limit = pvs->lalr;
} else if (fieldIndex == vsRecordLCBP) {
pgd->upper_disp_limit = pvs->hblr;
pgd->lower_disp_limit = pvs->lblr;
} else
recGblGetGraphicDouble(paddr, pgd);
return (0);
}
static long get_graphic_double(DBADDR *paddr, struct dbr_grDouble *pgd)
{
selRecord *prec=(selRecord *)paddr->precord;
if(paddr->pfield==(void *)&prec->val
|| paddr->pfield==(void *)&prec->hihi
|| paddr->pfield==(void *)&prec->high
|| paddr->pfield==(void *)&prec->low
|| paddr->pfield==(void *)&prec->lolo){
pgd->upper_disp_limit = prec->hopr;
pgd->lower_disp_limit = prec->lopr;
return(0);
}
if(paddr->pfield>=(void *)&prec->a && paddr->pfield<=(void *)&prec->l){
pgd->upper_disp_limit = prec->hopr;
pgd->lower_disp_limit = prec->lopr;
return(0);
}
if(paddr->pfield>=(void *)&prec->la && paddr->pfield<=(void *)&prec->ll){
pgd->upper_disp_limit = prec->hopr;
pgd->lower_disp_limit = prec->lopr;
return(0);
}
recGblGetGraphicDouble(paddr,pgd);
return(0);
}
/*****************************************************************************
*
* Allow for only sensible values for entries and displays
*
******************************************************************************/
static long get_graphic_double(DBADDR *paddr, struct dbr_grDouble *pgd)
{
digitelRecord *pdg = (digitelRecord *) (paddr->precord);
void *p;
p = (void *) (paddr->pfield);
if ((p == &(pdg->s1hs)) || (p == &(pdg->s2hs)) || (p == &(pdg->s3hs)) ||
(p == &(pdg->s1hr)) || (p == &(pdg->s2hr)) || (p == &(pdg->s3hr))) {
pgd->upper_disp_limit = DIGITEL_MAXHY;
pgd->lower_disp_limit = DIGITEL_MINHY;
} else if ((p == &(pdg->sp1s)) || (p == &(pdg->sp2s)) ||
(p == &(pdg->sp3s)) || (p == &(pdg->sp1r)) ||
(p == &(pdg->sp2r)) || (p == &(pdg->sp3r))) {
pgd->upper_disp_limit = DIGITEL_MAXSP;
pgd->lower_disp_limit = DIGITEL_MINSP;
} else if (p == &(pdg->val)) {
pgd->upper_disp_limit = pdg->hopr;
pgd->lower_disp_limit = pdg->lopr;
} else if (p == &(pdg->crnt)) {
pgd->upper_disp_limit = pdg->hctr;
pgd->lower_disp_limit = pdg->lctr;
} else if (p == &(pdg->lval)) {
pgd->upper_disp_limit = pdg->hlpr;
pgd->lower_disp_limit = pdg->llpr;
} else if (p == &(pdg->volt)) {
pgd->upper_disp_limit = pdg->hvtr;
pgd->lower_disp_limit = pdg->lvtr;
} else
recGblGetGraphicDouble(paddr, pgd);
return (0);
}
static long get_graphic_double(DBADDR *paddr, struct dbr_grDouble *pgd)
{
subArrayRecord *prec = (subArrayRecord *) paddr->precord;
switch (dbGetFieldIndex(paddr)) {
case subArrayRecordVAL:
pgd->upper_disp_limit = prec->hopr;
pgd->lower_disp_limit = prec->lopr;
break;
case subArrayRecordINDX:
pgd->upper_disp_limit = prec->malm - 1;
pgd->lower_disp_limit = 0;
break;
case subArrayRecordNELM:
pgd->upper_disp_limit = prec->malm;
pgd->lower_disp_limit = 1;
break;
default:
recGblGetGraphicDouble(paddr, pgd);
}
return 0;
}
static long get_graphic_double(DBADDR *paddr, struct dbr_grDouble *pgd)
{
subRecord *prec = (subRecord *)paddr->precord;
int fieldIndex = dbGetFieldIndex(paddr);
switch (fieldIndex) {
case subRecordVAL:
case subRecordHIHI: case subRecordHIGH:
case subRecordLOW: case subRecordLOLO:
case subRecordA: case subRecordB:
case subRecordC: case subRecordD:
case subRecordE: case subRecordF:
case subRecordG: case subRecordH:
case subRecordI: case subRecordJ:
case subRecordK: case subRecordL:
case subRecordLA: case subRecordLB:
case subRecordLC: case subRecordLD:
case subRecordLE: case subRecordLF:
case subRecordLG: case subRecordLH:
case subRecordLI: case subRecordLJ:
case subRecordLK: case subRecordLL:
pgd->upper_disp_limit = prec->hopr;
pgd->lower_disp_limit = prec->lopr;
break;
default:
recGblGetGraphicDouble(paddr, pgd);
}
return 0;
}
static long get_graphic_double(DBADDR *paddr, struct dbr_grDouble *pgd)
{
waveformRecord *prec = (waveformRecord *) paddr->precord;
if (dbGetFieldIndex(paddr) == waveformRecordVAL) {
pgd->upper_disp_limit = prec->hopr;
pgd->lower_disp_limit = prec->lopr;
} else
recGblGetGraphicDouble(paddr, pgd);
return 0;
}
static long get_graphic_double(DBADDR *paddr,struct dbr_grDouble *pgd)
{
compressRecord *prec=(compressRecord *)paddr->precord;
if(paddr->pfield==(void *)prec->bptr
|| paddr->pfield==(void *)&prec->ihil
|| paddr->pfield==(void *)&prec->ilil){
pgd->upper_disp_limit = prec->hopr;
pgd->lower_disp_limit = prec->lopr;
} else recGblGetGraphicDouble(paddr,pgd);
return(0);
}
static long get_graphic_double(DBADDR *paddr,struct dbr_grDouble *pgd)
{
longoutRecord *prec=(longoutRecord *)paddr->precord;
int fieldIndex = dbGetFieldIndex(paddr);
if(fieldIndex == longoutRecordVAL
|| fieldIndex == longoutRecordHIHI
|| fieldIndex == longoutRecordHIGH
|| fieldIndex == longoutRecordLOW
|| fieldIndex == longoutRecordLOLO) {
pgd->upper_disp_limit = prec->hopr;
pgd->lower_disp_limit = prec->lopr;
} else recGblGetGraphicDouble(paddr,pgd);
return(0);
}
static long get_graphic_double(struct dbAddr *paddr, struct dbr_grDouble *pgd)
{
struct cvtRecord *pcvt = (struct cvtRecord *)paddr->precord;
int fieldIndex = dbGetFieldIndex(paddr);
switch (fieldIndex) {
case cvtRecordVAL:
case cvtRecordHIHI:
case cvtRecordHIGH:
case cvtRecordLOW:
case cvtRecordLOLO:
pgd->upper_disp_limit = pcvt->hopr;
pgd->lower_disp_limit = pcvt->lopr;
break;
default:
recGblGetGraphicDouble(paddr, pgd);
}
return 0;
}
static long get_graphic_double(DBADDR *paddr,struct dbr_grDouble *pgd)
{
longoutRecord *prec=(longoutRecord *)paddr->precord;
switch (dbGetFieldIndex(paddr)) {
case indexof(VAL):
case indexof(HIHI):
case indexof(HIGH):
case indexof(LOW):
case indexof(LOLO):
case indexof(LALM):
case indexof(ALST):
case indexof(MLST):
pgd->upper_disp_limit = prec->hopr;
pgd->lower_disp_limit = prec->lopr;
break;
default:
recGblGetGraphicDouble(paddr,pgd);
}
return(0);
}
static long get_graphic_double(struct dbAddr *paddr, struct dbr_grDouble *pgd)
{
struct epidRecord *pepid=(struct epidRecord *)paddr->precord;
int fieldIndex = dbGetFieldIndex(paddr);
if (
fieldIndex == epidRecordVAL
|| fieldIndex == epidRecordHIHI
|| fieldIndex == epidRecordHIGH
|| fieldIndex == epidRecordLOW
|| fieldIndex == epidRecordLOLO
|| fieldIndex == epidRecordCVAL) {
pgd->upper_disp_limit = pepid->hopr;
pgd->lower_disp_limit = pepid->lopr;
} else if (
fieldIndex == epidRecordOVAL
|| fieldIndex == epidRecordP
|| fieldIndex == epidRecordI
|| fieldIndex == epidRecordD) {
pgd->upper_disp_limit = pepid->drvh;
pgd->lower_disp_limit = pepid->drvl;
} else recGblGetGraphicDouble(paddr,pgd);
return(0);
}
