void CelSelect::ShowDetails ()
{
double flat;
struct cs_Eldef_ *elPtr;
elPtr = CS_eldef (m_KeyName);
if (elPtr == NULL)
{
char errMesg [256];
CS_errmsg (errMesg,sizeof (errMesg));
AfxMessageBox (errMesg);
return;
}
flat = 0.0;
if (fabs (elPtr->flat) > 1.0E-10) flat = 1.0 / elPtr->flat;
m_Description = elPtr->name;
m_Source = elPtr->source;
m_Numbers.Format ("%12.3f, %12.3f, %10.5f, %10.8f",
elPtr->e_rad,
elPtr->p_rad,
flat,
elPtr->ecent * elPtr->ecent);
CS_free (elPtr);
UpdateData (FALSE);
return;
}
int EXP_LVL1 CS_geoctrSetUp (const char* ellipsoid)
{
extern double csGeoCtrErad;
extern double csGeoCtrEsq;
extern double cs_Zero;
int status;
struct cs_Eldef_ *elPtr;
elPtr = CS_eldef (ellipsoid);
if (elPtr != NULL)
{
csGeoCtrErad = elPtr->e_rad;
csGeoCtrEsq = elPtr->ecent * elPtr->ecent;
status = 0;
}
else
{
csGeoCtrErad = cs_Zero;
csGeoCtrEsq = cs_Zero;
status = -1;
}
return status;
}
char * EXP_LVL1 CS_eldflt (Const char *dflt_el)
{
extern char csElDflt [];
struct cs_Eldef_ *elp;
CS_stncp (previous,csElDflt,sizeof (previous));
if (dflt_el == NULL)
{
return (previous);
}
if (*dflt_el == '\0')
{
csElDflt [0] = '\0';
return (previous);
}
elp = CS_eldef (dflt_el);
if (elp == NULL)
{
return (NULL);
}
CS_free (elp);
CS_stncp (csElDflt,dflt_el,cs_KEYNM_DEF);
return (previous);
}
int EXP_LVL1 CS_el2Wkt (char *bufr,size_t bufrSize,const char *elKeyName,int flavor)
{
int rtnValue = -1;
struct cs_Eldef_ *elDefPtr = 0;
if (bufrSize > 0)
{
*bufr = '\0';
elDefPtr = CS_eldef (elKeyName);
if (elDefPtr != 0)
{
rtnValue = CSel2Wkt (bufr,bufrSize,(ErcWktFlavor)flavor,elDefPtr);
CS_free (elDefPtr);
elDefPtr = 0;
}
}
return rtnValue;
}
int EXP_LVL1 CS_el2WktEx (char *bufr,size_t bufrSize,const char *elKeyName,int flavor,unsigned short flags)
{
int rtnValue = -1;
struct cs_Eldef_ *elDefPtr = 0;
if (bufrSize > 0)
{
*bufr = '\0';
elDefPtr = CS_eldef (elKeyName);
if (elDefPtr != 0)
{
rtnValue = CSel2WktEx (bufr,bufrSize,flavor,elDefPtr,flags);
CS_free (elDefPtr);
elDefPtr = 0;
}
}
return rtnValue;
}
void CdtSelect::ShowDetails ()
{
int ii, ident;
struct cs_Dtdef_ *dtPtr;
struct cs_Eldef_ *elPtr;
TCHAR description [64];
dtPtr = CSt_dtdef (m_KeyName);
if (dtPtr == NULL)
{
TCHAR errMesg [256];
CSt_errmsg (errMesg,tchrCount (errMesg));
AfxMessageBox (errMesg);
return;
}
CSt_cstringAssign (m_Description,dtPtr->name);
CSt_cstringAssign (m_Source,dtPtr->source);
elPtr = CS_eldef (dtPtr->ell_knm);
if (elPtr == NULL) m_Ellipsoid = _T("???");
else
{
CSt_cstringAssign (m_Ellipsoid,elPtr->name);
CS_free (elPtr);
}
m_Technique = _T("???");
for (ii = 0;
CSt_viaEnum (ii,description,tchrCount (description),&ident) > 0;
ii += 1)
{
if (dtPtr->to84_via == ident)
{
m_Technique = description;
break;
}
}
CS_free (dtPtr);
UpdateData (FALSE);
return;
}
int EXP_LVL1 CS_cs2WktEx (char *bufr,size_t bufrSize,const char *csKeyName,int flavor,unsigned short flags)
{
int rtnValue = -1;
struct cs_Dtdef_ *dtDefPtr = 0;
struct cs_Eldef_ *elDefPtr = 0;
struct cs_Csdef_ *csDefPtr = 0;
if (bufrSize > 0)
{
*bufr = '\0';
csDefPtr = CS_csdef (csKeyName);
if (csDefPtr != 0)
{
if (csDefPtr->dat_knm [0] == '\0')
{
CS_erpt (cs_WKT_NODTREF);
}
else
{
dtDefPtr = CS_dtdef (csDefPtr->dat_knm);
if (dtDefPtr != 0)
{
elDefPtr = CS_eldef (dtDefPtr->ell_knm);
if (elDefPtr != 0)
{
rtnValue = CScs2WktEx (bufr,bufrSize,flavor,csDefPtr,dtDefPtr,elDefPtr,flags); /*lint !e64 */
CS_free (elDefPtr);
elDefPtr = 0;
}
CS_free (dtDefPtr);
dtDefPtr = 0;
}
}
CS_free (csDefPtr);
csDefPtr = 0;
}
}
return rtnValue;
}
void CdtSelect::ShowDetails ()
{
int ii, ident;
struct cs_Dtdef_ *dtPtr;
struct cs_Eldef_ *elPtr;
char description [64];
dtPtr = CS_dtdef (m_KeyName);
if (dtPtr == NULL)
{
char errMesg [256];
CS_errmsg (errMesg,sizeof (errMesg));
AfxMessageBox (errMesg);
return;
}
m_Description = dtPtr->name;
m_Source = dtPtr->source;
elPtr = CS_eldef (dtPtr->ell_knm);
if (elPtr == NULL) m_Ellipsoid = "???";
else
{
m_Ellipsoid = elPtr->name;
CS_free (elPtr);
}
m_Technique = "???";
for (ii = 0;
CS_viaEnum (ii,description,sizeof (description),&ident) > 0;
ii += 1)
{
if (dtPtr->to84_via == ident)
{
m_Technique = description;
break;
}
}
CS_free (dtPtr);
UpdateData (FALSE);
return;
}
int EXP_LVL1 CS_cs2Wkt (char *bufr,size_t bufrSize,const char *csKeyName,int flavor)
{
int rtnValue = -1;
const char* flavoredCsNamePtr = 0;
const char* flavoredDtNamePtr = 0;
const char* flavoredElNamePtr = 0;
const char* msiCsNamePtr = 0;
const char* msiDtNamePtr = 0;
const char* msiElNamePtr = 0;
struct cs_Dtdef_ *dtDefPtr = 0;
struct cs_Eldef_ *elDefPtr = 0;
struct cs_Csdef_ *csDefPtr = 0;
if (bufrSize > 0)
{
*bufr = '\0';
csDefPtr = CS_csdef (csKeyName);
if (csDefPtr != 0)
{
if (csDefPtr->dat_knm [0] == '\0')
{
CS_erpt (cs_WKT_NODTREF);
}
else
{
dtDefPtr = CS_dtdef (csDefPtr->dat_knm);
if (dtDefPtr != 0)
{
elDefPtr = CS_eldef (dtDefPtr->ell_knm);
if (elDefPtr != 0)
{
msiCsNamePtr = csDefPtr->key_nm;
msiDtNamePtr = dtDefPtr->key_nm;
msiElNamePtr = elDefPtr->key_nm;
/* now flavor that name */
if (flavor == wktFlvrEsri)
{
if (msiCsNamePtr != 0) /*lint !e774 */
{
flavoredCsNamePtr = CS_msiName2Esri(msiCsNamePtr);
}
if (msiDtNamePtr != 0) /*lint !e774 */
{
flavoredDtNamePtr = CS_msiDtmName2Esri(msiDtNamePtr, 0);
}
if (msiElNamePtr != 0) /*lint !e774 */
{
flavoredElNamePtr = CS_msiElpName2Esri(msiElNamePtr);
}
}
else if (flavor == wktFlvrOracle)
{
if (msiCsNamePtr != 0) /*lint !e774 */
{
flavoredCsNamePtr=CS_msiName2Oracle(msiCsNamePtr);
}
if (msiDtNamePtr != 0) /*lint !e774 */
{
flavoredDtNamePtr=CS_msiDtmName2Oracle(msiDtNamePtr, 0);
}
if (msiElNamePtr != 0) /*lint !e774 */
{
flavoredElNamePtr=CS_msiElpName2Oracle(msiElNamePtr);
}
}
if (flavoredCsNamePtr != 0)
{
CS_stncp (csDefPtr->key_nm,flavoredCsNamePtr,cs_KEYNM_MAX);
}
if (flavoredDtNamePtr != 0)
{
CS_stncp (csDefPtr->dat_knm,flavoredDtNamePtr,cs_KEYNM_MAX);
CS_stncp (dtDefPtr->key_nm,flavoredDtNamePtr,cs_KEYNM_MAX);
}
if (flavoredElNamePtr != 0)
{
CS_stncp (dtDefPtr->ell_knm,flavoredElNamePtr,cs_KEYNM_MAX);
CS_stncp (elDefPtr->key_nm,flavoredElNamePtr,cs_KEYNM_MAX);
}
rtnValue = CScs2Wkt (bufr,bufrSize,flavor,csDefPtr,dtDefPtr,elDefPtr); /*lint !e64 */
CS_free (elDefPtr);
elDefPtr = 0;
}
CS_free (dtDefPtr);
dtDefPtr = 0;
}
}
CS_free (csDefPtr);
csDefPtr = 0;
}
}
return rtnValue;
}
int CStest1 (bool verbose,bool crypt)
{
short protectSave;
char uniqueSave;
int st;
int cnt;
int my_crypt;
csFILE *elStrm;
struct tst_lst_ *tp;
char last_name [48];
__ALIGNMENT__1 /* Required by some Sun compilers. */
struct cs_Eldef_ el_def;
protectSave = cs_Protect;
uniqueSave = cs_Unique;
printf ("Testing Ellipsoid Dictionary functions.\n");
/* Test the Ellipsoid Dictionary manipulation functions
by fetching, updating, deleteing, and updating again
all the ellipsoids in the test list structure for
ellipsoids. Most of these were all chosen as ellipsoids
used in the coordinate calculation test. Thus, the
validity of the results can be tested by using test 4
after the completion of this test. */
tp = el_tst;
while (tp->name [0] != '\0')
{
cs_Protect = protectSave;
cs_Unique = uniqueSave;
/* First we fetch the ellipsoid definition. */
if (verbose)
{
printf ("Fetching %s ellipsoid definition.",tp->name);
}
tp->el_ptr = CS_eldef (tp->name);
if (tp->el_ptr == NULL)
{
(void)printf ("CS_eldef failed on %s. [%d:%d]\n",tp->name,cs_Error,cs_Errno);
return (1);
}
if (verbose) printf (" OK.\n");
/* There are two tests. One with protection on, one with it off.
If this is not a TEST ellipsoid, then we can only do an update
with protection off. If it is a TEST ellipsoid, we can test
with protection on. */
if (CS_stricmp (tp->el_ptr->group,"teSt"))
{
/* Now we put it back in, with protection off. */
if (verbose)
{
printf ("Updating %s ellipsoid definition, protection off.",tp->name);
}
cs_Protect = -1;
st = CS_elupd (tp->el_ptr,crypt);
if (st != 1)
{
(void)printf ("\nCS_elupd failed on %s at line %d. [%d:%d]\n",tp->name,(__LINE__-3),cs_Error,cs_Errno);
return (1);
}
if (verbose) printf (" OK.\n");
/* Now we delete it. */
if (verbose)
{
printf ("Deleting %s ellipsoid definition, protection off.",tp->name);
}
st = CS_eldel (tp->el_ptr);
if (st != 0)
{
(void)printf ("\nCS_eldel failed on %s at line %d. [%d:%d]\n",tp->name,(__LINE__-3),cs_Error,cs_Errno);
return (1);
}
if (verbose) printf (" OK.\n");
}
else
{
/* Now we put it back in, with protection on. */
if (verbose)
{
printf ("Updating %s ellipsoid definition, protection on.",tp->name);
}
cs_Protect = 10000; /* Sets protect date 27 years into the future. */
st = CS_elupd (tp->el_ptr,crypt);
if (st != 1)
{
(void)printf ("\nCS_elupd failed on %s at line %d. [%d:%d]\n",tp->name,(__LINE__-3),cs_Error,cs_Errno);
return (1);
}
if (verbose) printf (" OK.\n");
/* Now we delete it. */
if (verbose)
{
printf ("Deleting %s ellipsoid definition, protection on.",tp->name);
}
st = CS_eldel (tp->el_ptr);
if (st != 0)
{
(void)printf ("\nCS_eldel failed on %s at line %d. [%d:%d]\n",tp->name,(__LINE__-3),cs_Error,cs_Errno);
return (1);
}
if (verbose) printf (" OK.\n");
}
tp++;
}
/* Now we put all the deleted ellipsoid definitions back in.
This is a test of the add case since they shouldn't be
there any more. */
tp = el_tst;
while (tp->name [0] != '\0')
{
cs_Protect = protectSave;
cs_Unique = uniqueSave;
if (verbose)
{
printf ("Putting %s ellipsoid definition back in.",tp->name);
}
/* I can't really do a prtected test without changeing the name of the
definition. So, we're stuck with testing with protection off. */
cs_Unique = '\0';
st = CS_elupd (tp->el_ptr,crypt);
if (st != 0)
{
(void)printf ("\nCS_elupd failed on %s at line %d. [%d:%d]\n",tp->name,(__LINE__-3),cs_Error,cs_Errno);
return (st);
}
if (verbose) printf (" OK.\n");
CS_free (tp->el_ptr);
tp++;
}
/* Finally, we cruise through the ellipsoid file and verify
that all are in sorted order and that there are no
duplicates. */
if (verbose)
{
printf ("Checking order of Ellipsoid Dictionary.\n");
}
cnt = 0;
elStrm = CS_elopn (_STRM_BINRD);
st = CS_elrd (elStrm,&el_def,&my_crypt);
CS_stncp (last_name,el_def.key_nm,sizeof (last_name));
while (CS_elrd (elStrm,&el_def,&my_crypt))
{
cnt += 1;
if (verbose && (cnt % 3) == 0) putchar ('.');
st = CS_stricmp (last_name,el_def.key_nm);
if (st > 0)
{
printf ("\nEllipsoid Dictionary no longer sorted!!!\n");
CS_fclose (elStrm);
return (1);
}
else if (st == 0)
{
printf ("\nDuplicate entries in Ellipsoid Dictionary!!!\n");
CS_fclose (elStrm);
return (1);
}
}
CS_elDictCls (elStrm);
if (verbose) printf (" OK.\n");
return (0);
}
