aboutsummaryrefslogtreecommitdiff
path: root/nx-X11/lib/src/xcms
diff options
context:
space:
mode:
authorMike Gabriel <mike.gabriel@das-netzwerkteam.de>2017-07-21 12:31:09 +0200
committerMike Gabriel <mike.gabriel@das-netzwerkteam.de>2017-08-25 10:06:49 +0200
commitc350873c7c977efe5210484f04160be45f84ba7e (patch)
tree717d33eb315f4def1307d65108d14715696cd5cf /nx-X11/lib/src/xcms
parent1472e7e37838f17b7ed948fa206e8c3434a9d346 (diff)
downloadnx-libs-c350873c7c977efe5210484f04160be45f84ba7e.tar.gz
nx-libs-c350873c7c977efe5210484f04160be45f84ba7e.tar.bz2
nx-libs-c350873c7c977efe5210484f04160be45f84ba7e.zip
Convert nx-X11/lib/ build flow from imake to autotools.
Diffstat (limited to 'nx-X11/lib/src/xcms')
-rw-r--r--nx-X11/lib/src/xcms/AddDIC.c149
-rw-r--r--nx-X11/lib/src/xcms/AddSF.c145
-rw-r--r--nx-X11/lib/src/xcms/CCC.c285
-rw-r--r--nx-X11/lib/src/xcms/Cv.h189
-rw-r--r--nx-X11/lib/src/xcms/CvColW.c141
-rw-r--r--nx-X11/lib/src/xcms/CvCols.c1030
-rw-r--r--nx-X11/lib/src/xcms/HVC.c625
-rw-r--r--nx-X11/lib/src/xcms/HVCGcC.c149
-rw-r--r--nx-X11/lib/src/xcms/HVCGcV.c201
-rw-r--r--nx-X11/lib/src/xcms/HVCGcVC.c262
-rw-r--r--nx-X11/lib/src/xcms/HVCMnV.c163
-rw-r--r--nx-X11/lib/src/xcms/HVCMxC.c243
-rw-r--r--nx-X11/lib/src/xcms/HVCMxV.c247
-rw-r--r--nx-X11/lib/src/xcms/HVCMxVC.c235
-rw-r--r--nx-X11/lib/src/xcms/HVCMxVs.c161
-rw-r--r--nx-X11/lib/src/xcms/HVCWpAj.c114
-rw-r--r--nx-X11/lib/src/xcms/IdOfPr.c106
-rw-r--r--nx-X11/lib/src/xcms/LRGB.c1841
-rw-r--r--nx-X11/lib/src/xcms/Lab.c431
-rw-r--r--nx-X11/lib/src/xcms/LabGcC.c127
-rw-r--r--nx-X11/lib/src/xcms/LabGcL.c174
-rw-r--r--nx-X11/lib/src/xcms/LabGcLC.c223
-rw-r--r--nx-X11/lib/src/xcms/LabMnL.c216
-rw-r--r--nx-X11/lib/src/xcms/LabMxC.c203
-rw-r--r--nx-X11/lib/src/xcms/LabMxL.c216
-rw-r--r--nx-X11/lib/src/xcms/LabMxLC.c218
-rw-r--r--nx-X11/lib/src/xcms/LabWpAj.c97
-rw-r--r--nx-X11/lib/src/xcms/Luv.c401
-rw-r--r--nx-X11/lib/src/xcms/LuvGcC.c127
-rw-r--r--nx-X11/lib/src/xcms/LuvGcL.c174
-rw-r--r--nx-X11/lib/src/xcms/LuvGcLC.c223
-rw-r--r--nx-X11/lib/src/xcms/LuvMnL.c216
-rw-r--r--nx-X11/lib/src/xcms/LuvMxC.c204
-rw-r--r--nx-X11/lib/src/xcms/LuvMxL.c216
-rw-r--r--nx-X11/lib/src/xcms/LuvMxLC.c218
-rw-r--r--nx-X11/lib/src/xcms/LuvWpAj.c96
-rw-r--r--nx-X11/lib/src/xcms/Makefile.am92
-rw-r--r--nx-X11/lib/src/xcms/OfCCC.c162
-rw-r--r--nx-X11/lib/src/xcms/PrOfId.c97
-rw-r--r--nx-X11/lib/src/xcms/QBlack.c84
-rw-r--r--nx-X11/lib/src/xcms/QBlue.c84
-rw-r--r--nx-X11/lib/src/xcms/QGreen.c84
-rw-r--r--nx-X11/lib/src/xcms/QRed.c84
-rw-r--r--nx-X11/lib/src/xcms/QWhite.c84
-rw-r--r--nx-X11/lib/src/xcms/QuCol.c78
-rw-r--r--nx-X11/lib/src/xcms/QuCols.c78
-rw-r--r--nx-X11/lib/src/xcms/SetCCC.c138
-rw-r--r--nx-X11/lib/src/xcms/SetGetCols.c301
-rw-r--r--nx-X11/lib/src/xcms/StCol.c82
-rw-r--r--nx-X11/lib/src/xcms/StCols.c112
-rw-r--r--nx-X11/lib/src/xcms/UNDEFINED.c131
-rw-r--r--nx-X11/lib/src/xcms/XRGB.c242
-rw-r--r--nx-X11/lib/src/xcms/XYZ.c203
-rw-r--r--nx-X11/lib/src/xcms/Xcms.txt44
-rw-r--r--nx-X11/lib/src/xcms/Xcmsint.h260
-rw-r--r--nx-X11/lib/src/xcms/cmsAllCol.c74
-rw-r--r--nx-X11/lib/src/xcms/cmsAllNCol.c198
-rw-r--r--nx-X11/lib/src/xcms/cmsCmap.c492
-rw-r--r--nx-X11/lib/src/xcms/cmsColNm.c1050
-rw-r--r--nx-X11/lib/src/xcms/cmsGlobls.c126
-rw-r--r--nx-X11/lib/src/xcms/cmsInt.c411
-rw-r--r--nx-X11/lib/src/xcms/cmsLkCol.c193
-rw-r--r--nx-X11/lib/src/xcms/cmsMath.c140
-rw-r--r--nx-X11/lib/src/xcms/cmsProp.c153
-rw-r--r--nx-X11/lib/src/xcms/cmsTrig.c578
-rw-r--r--nx-X11/lib/src/xcms/uvY.c423
-rw-r--r--nx-X11/lib/src/xcms/xyY.c395
67 files changed, 16739 insertions, 0 deletions
diff --git a/nx-X11/lib/src/xcms/AddDIC.c b/nx-X11/lib/src/xcms/AddDIC.c
new file mode 100644
index 000000000..ecc6650ab
--- /dev/null
+++ b/nx-X11/lib/src/xcms/AddDIC.c
@@ -0,0 +1,149 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ * NAME
+ * XcmsAddDIC.c
+ *
+ * DESCRIPTION
+ * Source for XcmsAddColorSpace
+ *
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+
+/*
+ * DEFINES
+ */
+#define NextUnregDiCsID(lastid) \
+ (XCMS_UNREG_ID(lastid) ? ++lastid : XCMS_FIRST_UNREG_DI_ID)
+#define MAX(x,y) ((x) < (y) ? (y) : (x))
+
+
+/*
+ * NAME
+ * XcmsAddColorSpace - Add a Device-Independent Color Space
+ *
+ * SYNOPSIS
+ */
+Status
+XcmsAddColorSpace(XcmsColorSpace *pCS)
+/*
+ * DESCRIPTION
+ * DI Color Spaces are managed on a global basis.
+ * This means that with exception of the provided DI color spaces:
+ * CIEXYZ, CIExyY, CIELab, CIEuvY, CIELuv, and TekHVC
+ * DI color spaces may have different XcmsColorFormat IDs between
+ * clients. So, you must be careful when using XcmsColor
+ * structures between clients! Use the routines XcmsFormatOfPrefix()
+ * and XcmsPrefixOfFormat() appropriately.
+ *
+ * RETURNS
+ * XcmsSuccess if succeeded, otherwise XcmsFailure
+ */
+{
+ XcmsColorSpace **papColorSpaces;
+ XcmsColorSpace *ptmpCS;
+ XcmsColorFormat lastID = 0;
+
+ if ((pCS->id = _XcmsRegFormatOfPrefix(pCS->prefix)) != 0) {
+ if (XCMS_DD_ID(pCS->id)) {
+ /* This is a Device-Dependent Color Space */
+ return(XcmsFailure);
+ }
+ /*
+ * REGISTERED DI Color Space
+ * then see if the color space has already been added to the
+ * system:
+ * a. If the same ID/prefix and same XcmsColorSpec is found,
+ * then its a duplicate, so return success.
+ * b. If same ID/prefix but different XcmsColorSpec is
+ * found, then add the color space to the front of the
+ * list using the same ID. This allows one to override
+ * an existing DI Color Space.
+ * c. Otherwise none found so just add the color space.
+ */
+ if ((papColorSpaces = _XcmsDIColorSpaces) != NULL) {
+ while ((ptmpCS = *papColorSpaces++) != NULL) {
+ if (pCS->id == ptmpCS->id) {
+ if (pCS == ptmpCS) {
+ /* a. duplicate*/
+ return(XcmsSuccess);
+ }
+ /* b. same ID/prefix but different XcmsColorSpace */
+ break;
+ }
+ }
+ }
+ /* c. None found */
+ } else {
+ /*
+ * UNREGISTERED DI Color Space
+ * then see if the color space has already been added to the
+ * system:
+ * a. If same prefix and XcmsColorSpec, then
+ * its a duplicate ... return success.
+ * b. If same prefix but different XcmsColorSpec, then
+ * add the color space to the front of the list using
+ * the same ID. This allows one to override an existing
+ * DI Color Space.
+ * c. Otherwise none found so, add the color space using the
+ * next unregistered ID for the connection.
+ */
+ if ((papColorSpaces = _XcmsDIColorSpaces) != NULL) {
+ while ((ptmpCS = *papColorSpaces++) != NULL) {
+ lastID = MAX(lastID, ptmpCS->id);
+ if (strcmp(pCS->prefix, ptmpCS->prefix) == 0) {
+ if (pCS == ptmpCS) {
+ /* a. duplicate */
+ return(XcmsSuccess);
+ }
+ /* b. same prefix but different XcmsColorSpec */
+ pCS->id = ptmpCS->id;
+ goto AddColorSpace;
+ }
+ }
+ }
+ /* c. None found */
+ pCS->id = NextUnregDiCsID(lastID);
+ }
+
+
+AddColorSpace:
+ if ((papColorSpaces = (XcmsColorSpace **)
+ _XcmsPushPointerArray((XPointer *)_XcmsDIColorSpaces,
+ (XPointer)pCS,
+ (XPointer *)_XcmsDIColorSpacesInit)) == NULL) {
+ return(XcmsFailure);
+ }
+ _XcmsDIColorSpaces = papColorSpaces;
+ return(XcmsSuccess);
+}
diff --git a/nx-X11/lib/src/xcms/AddSF.c b/nx-X11/lib/src/xcms/AddSF.c
new file mode 100644
index 000000000..2e244e73b
--- /dev/null
+++ b/nx-X11/lib/src/xcms/AddSF.c
@@ -0,0 +1,145 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ * NAME
+ * XcmsAddSF.c
+ *
+ * DESCRIPTION
+ * Source for XcmsAddFunctionSet
+ *
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+/*
+ * DEFINES
+ */
+#define NextUnregDdCsID(lastid) \
+ (XCMS_UNREG_ID(lastid) ? ++lastid : XCMS_FIRST_UNREG_DD_ID)
+#define MIN(x,y) ((x) > (y) ? (y) : (x))
+
+
+/*
+ * NAME
+ * XcmsAddFunctionSet - Add an Screen Color Characterization
+ * Function Set
+ *
+ * SYNOPSIS
+ */
+Status
+XcmsAddFunctionSet(XcmsFunctionSet *pNewFS)
+/*
+ * DESCRIPTION
+ * Additional Screen Color Characterization Function Sets are
+ * managed on a global basis. This means that with exception
+ * of the provided DD color spaces:
+ * RGB and RGBi
+ * DD color spaces may have different XcmsColorFormat IDs between
+ * clients. So, you must be careful when using XcmsColorFormat
+ * across clients! Use the routines XcmsFormatOfPrefix()
+ * and XcmsPrefixOfFormat() appropriately.
+ *
+ * RETURNS
+ * XcmsSuccess if succeeded, otherwise XcmsFailure
+ *
+ * CAVEATS
+ * Additional Screen Color Characterization Function Sets
+ * should be added prior to any use of the routine
+ * XcmsCreateCCC(). If not, XcmsCCC structures created
+ * prior to the call of this routines will not have had
+ * a chance to initialize using the added Screen Color
+ * Characterization Function Set.
+ */
+{
+ XcmsFunctionSet **papSCCFuncSets = _XcmsSCCFuncSets;
+ XcmsColorSpace **papNewCSs;
+ XcmsColorSpace *pNewCS, **paptmpCS;
+ XcmsColorFormat lastID = 0;
+
+
+ if (papSCCFuncSets != NULL) {
+ if ((papNewCSs = pNewFS->DDColorSpaces) == NULL) {
+ /*
+ * Error, new Screen Color Characterization Function Set
+ * missing color spaces
+ */
+ return(XcmsFailure);
+ }
+ while ((pNewCS = *papNewCSs++) != NULL) {
+ if ((pNewCS->id = _XcmsRegFormatOfPrefix(pNewCS->prefix)) != 0) {
+ if (XCMS_DI_ID(pNewCS->id)) {
+ /* This is a Device-Independent Color Space */
+ return(XcmsFailure);
+ }
+ /*
+ * REGISTERED DD Color Space
+ * therefore use the registered ID.
+ */
+ } else {
+ /*
+ * UNREGISTERED DD Color Space
+ * then see if the color space is already in
+ * _XcmsDDColorSpaces.
+ * a. If same prefix, then use the same ID.
+ * b. Otherwise, use a new ID.
+ */
+ for (paptmpCS = _XcmsDDColorSpaces; *paptmpCS != NULL;
+ paptmpCS++){
+ lastID = MIN(lastID, (*paptmpCS)->id);
+ if (strcmp(pNewCS->prefix, (*paptmpCS)->prefix) == 0) {
+ pNewCS->id = (*paptmpCS)->id;
+ break;
+ }
+ }
+ if (pNewCS->id == 0) {
+ /* still haven't found one */
+ pNewCS->id = NextUnregDdCsID(lastID);
+ if ((paptmpCS = (XcmsColorSpace **)_XcmsPushPointerArray(
+ (XPointer *) _XcmsDDColorSpaces,
+ (XPointer) pNewCS,
+ (XPointer *) _XcmsDDColorSpacesInit)) == NULL) {
+ return(XcmsFailure);
+ }
+ _XcmsDDColorSpaces = paptmpCS;
+ }
+ }
+ }
+ }
+ if ((papSCCFuncSets = (XcmsFunctionSet **)
+ _XcmsPushPointerArray((XPointer *) _XcmsSCCFuncSets,
+ (XPointer) pNewFS,
+ (XPointer *)_XcmsSCCFuncSetsInit)) == NULL) {
+ return(XcmsFailure);
+ }
+ _XcmsSCCFuncSets = papSCCFuncSets;
+
+ return(XcmsSuccess);
+}
diff --git a/nx-X11/lib/src/xcms/CCC.c b/nx-X11/lib/src/xcms/CCC.c
new file mode 100644
index 000000000..de6d6318a
--- /dev/null
+++ b/nx-X11/lib/src/xcms/CCC.c
@@ -0,0 +1,285 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ * NAME
+ * XcmsCCC.c - Color Conversion Context Routines
+ *
+ * DESCRIPTION
+ * Routines to create, access, and free Color Conversion
+ * Context structures.
+ *
+ *
+ */
+
+/*
+
+Copyright 1994, 1998 The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization
+from The Open Group.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <stdio.h>
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+
+
+/************************************************************************
+ * *
+ * PUBLIC INTERFACES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsCreateCCC
+ *
+ * SYNOPSIS
+ */
+
+XcmsCCC
+XcmsCreateCCC(
+ Display *dpy,
+ int screenNumber,
+ Visual *visual,
+ XcmsColor *clientWhitePt,
+ XcmsCompressionProc gamutCompProc,
+ XPointer gamutCompClientData,
+ XcmsWhiteAdjustProc whitePtAdjProc,
+ XPointer whitePtAdjClientData)
+/*
+ * DESCRIPTION
+ * Given a Display, Screen, Visual, etc., this routine creates
+ * an appropriate Color Conversion Context.
+ *
+ * RETURNS
+ * Returns NULL if failed; otherwise address of the newly
+ * created XcmsCCC.
+ *
+ */
+{
+ XcmsCCC pDefaultCCC = XcmsDefaultCCC(dpy, screenNumber);
+ XcmsCCC newccc;
+ XcmsIntensityMap *pIMap;
+ XcmsPerScrnInfo *pNewScrnInfo;
+
+ if (pDefaultCCC == NULL ||
+ !(newccc = Xcalloc(1, sizeof(XcmsCCCRec)))) {
+ return(NULL);
+ }
+
+ /*
+ * Should inherit the following as result of a memmove():
+ * dpy
+ * screenNumber
+ * pPerScrnInfo
+ */
+ memcpy((char *)newccc, (char *)pDefaultCCC, sizeof(XcmsCCCRec));
+ if (clientWhitePt) {
+ memcpy((char *)&newccc->clientWhitePt, (char *)clientWhitePt,
+ sizeof(XcmsColor));
+ }
+ if (gamutCompProc) {
+ newccc->gamutCompProc = gamutCompProc;
+ }
+ if (gamutCompClientData) {
+ newccc->gamutCompClientData = gamutCompClientData;
+ }
+ if (whitePtAdjProc) {
+ newccc->whitePtAdjProc = whitePtAdjProc;
+ }
+ if (whitePtAdjClientData) {
+ newccc->whitePtAdjClientData = whitePtAdjClientData;
+ }
+
+ /*
+ * Now check our list of per-Visual Intensity tables.
+ * If one exists replace the pPerScrnInfo.
+ */
+ if ((pIMap = _XcmsGetIntensityMap(dpy, visual)) != NULL) {
+ if (!(pNewScrnInfo = Xcalloc(1, sizeof(XcmsPerScrnInfo)))) {
+ Xfree(newccc);
+ return(NULL);
+ }
+ memcpy((char *)pNewScrnInfo, (char *)newccc->pPerScrnInfo,
+ sizeof(XcmsPerScrnInfo));
+ pNewScrnInfo->screenData = pIMap->screenData;
+ newccc->pPerScrnInfo = pNewScrnInfo;
+ }
+
+ /*
+ * Set visual component
+ */
+ newccc->visual = visual;
+
+ return(newccc);
+}
+
+
+/*
+ * NAME
+ * XcmsDefaultCCC
+ *
+ * SYNOPSIS
+ */
+XcmsCCC
+XcmsDefaultCCC(
+ Display *dpy,
+ int screenNumber)
+/*
+ * DESCRIPTION
+ * Given a Display and Screen, this routine creates
+ * returns the Screen's default Color Conversion Context.
+ * Note that a Screen's default CCC is built with the
+ * screen default visual.
+ *
+ * RETURNS
+ * Returns NULL if failed; otherwise address of the
+ * XcmsCCC for the Screen's default CCC.
+ *
+ */
+{
+ XcmsCCC ccc;
+
+
+ if ((screenNumber < 0) || (screenNumber >= ScreenCount(dpy))) {
+ return((XcmsCCC)NULL);
+ }
+
+ /*
+ * Check if the XcmsCCC's for each screen has been created
+ */
+ if ((XcmsCCC)dpy->cms.defaultCCCs == NULL) {
+ if (!_XcmsInitDefaultCCCs(dpy)) {
+ return((XcmsCCC)NULL);
+ }
+ }
+
+ ccc = (XcmsCCC)dpy->cms.defaultCCCs + screenNumber;
+
+ if (!ccc->pPerScrnInfo) {
+ /*
+ * Need to create the XcmsPerScrnInfo structure. The
+ * _XcmsInitScrnInfo routine will create the XcmsPerScrnInfo
+ * structure as well as initialize its functionSet and pScreenData
+ * components.
+ */
+ if (!_XcmsInitScrnInfo(dpy, screenNumber)) {
+ return((XcmsCCC)NULL);
+ }
+ return(ccc);
+ } else {
+ /*
+ * If ccc->pPerScrnInfo->state == XcmsInitSuccess,
+ * then the pPerScrnInfo component has already been initialized
+ * therefore, just return ccc.
+ * If ccc->pPerScrnInfo->state == XcmsInitFailure,
+ * then this means that we already attempted to initialize
+ * the pPerScrnInfo component but failed therefore stuffing
+ * the pPerScrnInfo component with defaults. Just return ccc.
+ * If ccc->pPerScrnInfo->state == XcmsInitNone,
+ * then attempt to initialize the pPerScrnInfo component.
+ */
+ switch (ccc->pPerScrnInfo->state) {
+ case XcmsInitFailure :
+ /* fall through */
+ case XcmsInitSuccess :
+ return(ccc);
+ case XcmsInitNone :
+ /* XcmsPerScreenInfo has not been initialized */
+ if (!_XcmsInitScrnInfo(dpy, screenNumber)) {
+ return((XcmsCCC)NULL);
+ }
+ return(ccc);
+ default :
+ return((XcmsCCC)NULL);
+ }
+ }
+}
+
+
+/*
+ * NAME
+ * XcmsFreeCCC
+ *
+ * SYNOPSIS
+ */
+void
+XcmsFreeCCC(XcmsCCC ccc)
+/*
+ * DESCRIPTION
+ * Frees memory associated with a Color Conversion Context
+ * that was created with XcmsCreateCCC().
+ *
+ * RETURNS
+ * void
+ *
+ */
+{
+ if (ccc->dpy->cms.defaultCCCs &&
+ ccc == ((XcmsCCC)ccc->dpy->cms.defaultCCCs) + ccc->screenNumber) {
+ /* do not allow clients to free DefaultCCC's */
+ return;
+ }
+
+ /*
+ * Note that XcmsPerScrnInfo sub-structures are freed here only if
+ * they are for visuals that have per-Visual intensity tables.
+ * Otherwise the XcmsPerScrnInfo structure is being shared!
+ * For the latter, there is only one allocated per Screen and it just
+ * so happens * that we place its initial reference is placed in the
+ * default CCC. The routine _XcmsFreeDefaultCCCs frees them.
+ */
+ if (_XcmsGetIntensityMap(ccc->dpy, ccc->visual) != NULL) {
+ Xfree(ccc->pPerScrnInfo);
+ }
+
+ Xfree(ccc);
+}
diff --git a/nx-X11/lib/src/xcms/Cv.h b/nx-X11/lib/src/xcms/Cv.h
new file mode 100644
index 000000000..0b662811f
--- /dev/null
+++ b/nx-X11/lib/src/xcms/Cv.h
@@ -0,0 +1,189 @@
+
+#ifndef _CV_H_
+#define _CV_H_
+
+/* variables */
+extern const char _XcmsCIEXYZ_prefix[];
+extern const char _XcmsCIEuvY_prefix[];
+extern const char _XcmsCIExyY_prefix[];
+extern const char _XcmsCIELab_prefix[];
+extern const char _XcmsCIELuv_prefix[];
+extern const char _XcmsTekHVC_prefix[];
+extern const char _XcmsRGBi_prefix[];
+extern const char _XcmsRGB_prefix[];
+
+extern XcmsColorSpace XcmsUNDEFINEDColorSpace;
+extern XcmsColorSpace XcmsTekHVCColorSpace;
+extern XcmsColorSpace XcmsCIEXYZColorSpace;
+extern XcmsColorSpace XcmsCIEuvYColorSpace;
+extern XcmsColorSpace XcmsCIExyYColorSpace;
+extern XcmsColorSpace XcmsCIELabColorSpace;
+extern XcmsColorSpace XcmsCIELuvColorSpace;
+extern XcmsColorSpace XcmsRGBColorSpace;
+extern XcmsColorSpace XcmsRGBiColorSpace;
+
+extern XcmsColorSpace *_XcmsDIColorSpacesInit[];
+extern XcmsColorSpace **_XcmsDIColorSpaces;
+
+extern XcmsColorSpace *_XcmsDDColorSpacesInit[];
+extern XcmsColorSpace **_XcmsDDColorSpaces;
+
+extern XcmsFunctionSet XcmsLinearRGBFunctionSet;
+
+extern XcmsFunctionSet *_XcmsSCCFuncSetsInit[];
+extern XcmsFunctionSet **_XcmsSCCFuncSets;
+
+extern XcmsRegColorSpaceEntry _XcmsRegColorSpaces[];
+
+/* functions */
+extern XPointer *
+_XcmsCopyPointerArray(
+ XPointer *pap);
+extern void
+_XcmsFreePointerArray(
+ XPointer *pap);
+extern XPointer *
+_XcmsPushPointerArray(
+ XPointer *pap,
+ XPointer p,
+ XPointer *papNoFree);
+extern Status
+_XcmsCIEXYZ_ValidSpec(
+ XcmsColor *pColor);
+extern Status
+_XcmsCIEuvY_ValidSpec(
+ XcmsColor *pColor);
+extern int
+_XcmsTekHVC_CheckModify(
+ XcmsColor *pColor);
+
+extern Status
+_XcmsTekHVCQueryMaxVCRGB(
+ XcmsCCC ccc,
+ XcmsFloat hue,
+ XcmsColor *pColor_return,
+ XcmsRGBi *pRGB_return);
+extern Status
+_XcmsCIELabQueryMaxLCRGB(
+ XcmsCCC ccc,
+ XcmsFloat hue, /* hue in radians */
+ XcmsColor *pColor_return,
+ XcmsRGBi *pRGB_return);
+extern Status
+_XcmsConvertColorsWithWhitePt(
+ XcmsCCC ccc,
+ XcmsColor *pColors_in_out,
+ XcmsColor *pWhitePt,
+ unsigned int nColors,
+ XcmsColorFormat newFormat,
+ Bool *pCompressed);
+
+extern Status
+_XcmsDIConvertColors(
+ XcmsCCC ccc,
+ XcmsColor *pColors_in_out,
+ XcmsColor *pWhitePt,
+ unsigned int nColors,
+ XcmsColorFormat newFormat);
+extern Status
+_XcmsDDConvertColors(
+ XcmsCCC ccc,
+ XcmsColor *pColors_in_out,
+ unsigned int nColors,
+ XcmsColorFormat newFormat,
+ Bool *pCompressed);
+extern XcmsColorFormat
+_XcmsRegFormatOfPrefix(
+ _Xconst char *prefix);
+extern void
+_XColor_to_XcmsRGB(
+ XcmsCCC ccc,
+ XColor *pXColors,
+ XcmsColor *pColors,
+ unsigned int nColors);
+extern Status
+_XcmsSetGetColor(
+ Status (*xColorProc)(
+ Display* /* display */,
+ Colormap /* colormap */,
+ XColor* /* screen_in_out */),
+ Display *dpy,
+ Colormap cmap,
+ XcmsColor *pColors_in_out,
+ XcmsColorFormat result_format,
+ Bool *pCompressed);
+extern Status
+_XcmsSetGetColors(
+ Status (*xColorProc)(
+ Display* /* display */,
+ Colormap /* colormap */,
+ XColor* /* screen_in_out */,
+ int /* nColors */),
+ Display *dpy,
+ Colormap cmap,
+ XcmsColor *pColors_in_out,
+ int nColors,
+ XcmsColorFormat result_format,
+ Bool *pCompressed);
+extern Status
+_XcmsCIELuvQueryMaxLCRGB(
+ XcmsCCC ccc,
+ XcmsFloat hue, /* hue in radians */
+ XcmsColor *pColor_return,
+ XcmsRGBi *pRGB_return);
+
+extern XcmsIntensityMap *
+_XcmsGetIntensityMap(
+ Display *dpy,
+ Visual *visual);
+extern int
+_XcmsInitDefaultCCCs(
+ Display *dpy);
+extern int
+_XcmsInitScrnInfo(
+ register Display *dpy,
+ int screenNumber);
+extern XcmsCmapRec *
+_XcmsCopyCmapRecAndFree(
+ Display *dpy,
+ Colormap src_cmap,
+ Colormap copy_cmap);
+extern void
+_XcmsCopyISOLatin1Lowered(
+ char *dst,
+ const char *src);
+extern int
+_XcmsEqualWhitePts(
+ XcmsCCC ccc, XcmsColor *pWhitePt1, XcmsColor *pWhitePt2);
+extern int
+_XcmsLRGB_InitScrnDefault(
+ Display *dpy,
+ int screenNumber,
+ XcmsPerScrnInfo *pPerScrnInfo);
+extern void
+_XcmsFreeIntensityMaps(
+ Display *dpy);
+extern int
+_XcmsGetProperty(
+ Display *pDpy,
+ Window w,
+ Atom property,
+ int *pFormat,
+ unsigned long *pNItems,
+ unsigned long *pNBytes,
+ char **pValue);
+extern unsigned long
+_XcmsGetElement(
+ int format,
+ char **pValue,
+ unsigned long *pCount);
+extern void
+_XcmsUnresolveColor(
+ XcmsCCC ccc,
+ XcmsColor *pColor);
+extern void
+_XcmsResolveColor(
+ XcmsCCC ccc,
+ XcmsColor *pXcmsColor);
+
+#endif /* _CV_H_ */
diff --git a/nx-X11/lib/src/xcms/CvColW.c b/nx-X11/lib/src/xcms/CvColW.c
new file mode 100644
index 000000000..4aabded0d
--- /dev/null
+++ b/nx-X11/lib/src/xcms/CvColW.c
@@ -0,0 +1,141 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ *
+ * NAME
+ * XcmsCvColW.c
+ *
+ * DESCRIPTION
+ * <overall description of what the package does>
+ *
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+
+/************************************************************************
+ * *
+ * API PRIVATE ROUTINES *
+ * *
+ ************************************************************************/
+
+
+/*
+ * NAME
+ * _XcmsConvertColorsWithWhitePt - Convert XcmsColor structures
+ *
+ * SYNOPSIS
+ */
+Status
+_XcmsConvertColorsWithWhitePt(
+ XcmsCCC ccc,
+ XcmsColor *pColors_in_out,
+ XcmsColor *pWhitePt,
+ unsigned int nColors,
+ XcmsColorFormat newFormat,
+ Bool *pCompressed)
+/*
+ * DESCRIPTION
+ * Convert XcmsColor structures between device-independent
+ * and/or device-dependent formats but allowing the calling
+ * routine to specify the white point to be associated
+ * with the color specifications (overriding
+ * ccc->clientWhitePt).
+ *
+ * This routine has been provided for use in white point
+ * adjustment routines.
+ *
+ * RETURNS
+ * XcmsFailure if failed,
+ * XcmsSuccess if succeeded without gamut compression,
+ * XcmsSuccessWithCompression if succeeded with gamut
+ * compression.
+ *
+ */
+{
+ if (ccc == NULL || pColors_in_out == NULL ||
+ pColors_in_out->format == XcmsUndefinedFormat) {
+ return(XcmsFailure);
+ }
+
+ if (nColors == 0 || pColors_in_out->format == newFormat) {
+ /* do nothing */
+ return(XcmsSuccess);
+ }
+
+ if (XCMS_DI_ID(pColors_in_out->format) && XCMS_DI_ID(newFormat)) {
+ /*
+ * Device-Independent to Device-Independent Conversion
+ */
+ return(_XcmsDIConvertColors(ccc, pColors_in_out, pWhitePt, nColors,
+ newFormat));
+ }
+ if (XCMS_DD_ID(pColors_in_out->format) && XCMS_DD_ID(newFormat)) {
+ /*
+ * Device-Dependent to Device-Dependent Conversion
+ */
+ return(_XcmsDDConvertColors(ccc, pColors_in_out, nColors, newFormat,
+ pCompressed));
+ }
+
+ /*
+ * Otherwise we have:
+ * 1. Device-Independent to Device-Dependent Conversion
+ * OR
+ * 2. Device-Dependent to Device-Independent Conversion
+ */
+
+ if (XCMS_DI_ID(pColors_in_out->format)) {
+ /*
+ * 1. Device-Independent to Device-Dependent Conversion
+ */
+ /* First convert to CIEXYZ */
+ if (_XcmsDIConvertColors(ccc, pColors_in_out, pWhitePt, nColors,
+ XcmsCIEXYZFormat) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+ /* Then convert to DD Format */
+ return(_XcmsDDConvertColors(ccc, pColors_in_out, nColors, newFormat,
+ pCompressed));
+ } else {
+ /*
+ * 2. Device-Dependent to Device-Independent Conversion
+ */
+ /* First convert to CIEXYZ */
+ if (_XcmsDDConvertColors(ccc, pColors_in_out, nColors,
+ XcmsCIEXYZFormat, pCompressed) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+ /* Then convert to DI Format */
+ return(_XcmsDIConvertColors(ccc, pColors_in_out, pWhitePt, nColors,
+ newFormat));
+ }
+}
diff --git a/nx-X11/lib/src/xcms/CvCols.c b/nx-X11/lib/src/xcms/CvCols.c
new file mode 100644
index 000000000..87d49311c
--- /dev/null
+++ b/nx-X11/lib/src/xcms/CvCols.c
@@ -0,0 +1,1030 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ * NAME
+ * XcmsCvCols.c
+ *
+ * DESCRIPTION
+ * Xcms API routine that converts between the
+ * device-independent color spaces.
+ *
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+/*
+ * LOCAL DEFINES
+ */
+#define DD_FORMAT 0x01
+#define DI_FORMAT 0x02
+#define MIX_FORMAT 0x04
+#ifndef MAX
+# define MAX(x,y) ((x) > (y) ? (x) : (y))
+#endif
+
+
+/************************************************************************
+ * *
+ * PRIVATE ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * EqualCIEXYZ
+ *
+ * SYNOPSIS
+ */
+static int
+EqualCIEXYZ(
+ XcmsColor *p1, XcmsColor *p2)
+/*
+ * DESCRIPTION
+ * Compares two XcmsColor structures that are in XcmsCIEXYZFormat
+ *
+ * RETURNS
+ * Returns 1 if equal; 0 otherwise.
+ *
+ */
+{
+ if (p1->format != XcmsCIEXYZFormat || p2->format != XcmsCIEXYZFormat) {
+ return(0);
+ }
+ if ((p1->spec.CIEXYZ.X != p2->spec.CIEXYZ.X)
+ || (p1->spec.CIEXYZ.Y != p2->spec.CIEXYZ.Y)
+ || (p1->spec.CIEXYZ.Z != p2->spec.CIEXYZ.Z)) {
+ return(0);
+ }
+ return(1);
+}
+
+
+/*
+ * NAME
+ * XcmsColorSpace
+ *
+ * SYNOPSIS
+ */
+static XcmsColorSpace *
+ColorSpaceOfID(
+ XcmsCCC ccc,
+ XcmsColorFormat id)
+/*
+ * DESCRIPTION
+ * Returns a pointer to the color space structure
+ * (XcmsColorSpace) associated with the specified color space
+ * ID.
+ *
+ * RETURNS
+ * Pointer to matching XcmsColorSpace structure if found;
+ * otherwise NULL.
+ */
+{
+ XcmsColorSpace **papColorSpaces;
+
+ if (ccc == NULL) {
+ return(NULL);
+ }
+
+ /*
+ * First try Device-Independent color spaces
+ */
+ papColorSpaces = _XcmsDIColorSpaces;
+ if (papColorSpaces != NULL) {
+ while (*papColorSpaces != NULL) {
+ if ((*papColorSpaces)->id == id) {
+ return(*papColorSpaces);
+ }
+ papColorSpaces++;
+ }
+ }
+
+ /*
+ * Next try Device-Dependent color spaces
+ */
+ papColorSpaces = ((XcmsFunctionSet *)ccc->pPerScrnInfo->functionSet)->DDColorSpaces;
+ if (papColorSpaces != NULL) {
+ while (*papColorSpaces != NULL) {
+ if ((*papColorSpaces)->id == id) {
+ return(*papColorSpaces);
+ }
+ papColorSpaces++;
+ }
+ }
+
+ return(NULL);
+}
+
+
+/*
+ * NAME
+ * ValidDIColorSpaceID
+ *
+ * SYNOPSIS
+ */
+static int
+ValidDIColorSpaceID(
+ XcmsColorFormat id)
+/*
+ * DESCRIPTION
+ * Determines if the specified color space ID is a valid
+ * Device-Independent color space in the specified Color
+ * Conversion Context.
+ *
+ * RETURNS
+ * Returns zero if not valid; otherwise non-zero.
+ */
+{
+ XcmsColorSpace **papRec;
+ papRec = _XcmsDIColorSpaces;
+ if (papRec != NULL) {
+ while (*papRec != NULL) {
+ if ((*papRec)->id == id) {
+ return(1);
+ }
+ papRec++;
+ }
+ }
+ return(0);
+}
+
+
+/*
+ * NAME
+ * ValidDDColorSpaceID
+ *
+ * SYNOPSIS
+ */
+static int
+ValidDDColorSpaceID(
+ XcmsCCC ccc,
+ XcmsColorFormat id)
+/*
+ * DESCRIPTION
+ * Determines if the specified color space ID is a valid
+ * Device-Dependent color space in the specified Color
+ * Conversion Context.
+ *
+ * RETURNS
+ * Returns zero if not valid; otherwise non-zero.
+ */
+{
+ XcmsColorSpace **papRec;
+
+ if (ccc->pPerScrnInfo->state != XcmsInitNone) {
+ papRec = ((XcmsFunctionSet *)ccc->pPerScrnInfo->functionSet)->DDColorSpaces;
+ while (*papRec != NULL) {
+ if ((*papRec)->id == id) {
+ return(1);
+ }
+ papRec++;
+ }
+ }
+ return(0);
+}
+
+
+/*
+ * NAME
+ * ConvertMixedColors - Convert XcmsColor structures
+ *
+ * SYNOPSIS
+ */
+static Status
+ConvertMixedColors(
+ XcmsCCC ccc,
+ XcmsColor *pColors_in_out,
+ XcmsColor *pWhitePt,
+ unsigned int nColors,
+ XcmsColorFormat targetFormat,
+ unsigned char format_flag)
+/*
+ * DESCRIPTION
+ * This routine will only convert the following types of
+ * batches:
+ * DI to DI
+ * DD to DD
+ * DD to CIEXYZ
+ * In other words, it will not convert the following types of
+ * batches:
+ * DI to DD
+ * DD to DI(not CIEXYZ)
+ *
+ * format_flag:
+ * 0x01 : convert Device-Dependent only specifications to the
+ * target format.
+ * 0x02 : convert Device-Independent only specifications to the
+ * target format.
+ * 0x03 : convert all specifications to the target format.
+ *
+ * RETURNS
+ * XcmsFailure if failed,
+ * XcmsSuccess if none of the color specifications were
+ * compressed in the conversion process
+ * XcmsSuccessWithCompression if at least one of the
+ * color specifications were compressed in the
+ * conversion process.
+ *
+ */
+{
+ XcmsColor *pColor, *pColors_start;
+ XcmsColorFormat format;
+ Status retval_tmp;
+ Status retval = XcmsSuccess;
+ unsigned int iColors;
+ unsigned int nBatch;
+
+ /*
+ * Convert array of mixed color specifications in batches of
+ * contiguous formats to the target format
+ */
+ iColors = 0;
+ while (iColors < nColors) {
+ /*
+ * Find contiguous array of color specifications with the
+ * same format
+ */
+ pColor = pColors_start = pColors_in_out + iColors;
+ format = pColors_start->format;
+ nBatch = 0;
+ while (iColors < nColors && pColor->format == format) {
+ pColor++;
+ nBatch++;
+ iColors++;
+ }
+ if (format != targetFormat) {
+ /*
+ * Need to convert this batch from current format to target format.
+ */
+ if (XCMS_DI_ID(format) && (format_flag & DI_FORMAT) &&
+ XCMS_DI_ID(targetFormat)) {
+ /*
+ * DI->DI
+ *
+ * Format of interest is Device-Independent,
+ * This batch contains Device-Independent specifications, and
+ * the Target format is Device-Independent.
+ */
+ retval_tmp = _XcmsDIConvertColors(ccc, pColors_start, pWhitePt,
+ nBatch, targetFormat);
+ } else if (XCMS_DD_ID(format) && (format_flag & DD_FORMAT) &&
+ (targetFormat == XcmsCIEXYZFormat)) {
+ /*
+ * DD->CIEXYZ
+ *
+ * Format of interest is Device-Dependent,
+ * This batch contains Device-Dependent specifications, and
+ * the Target format is CIEXYZ.
+ *
+ * Since DD->CIEXYZ we can use NULL instead of pCompressed.
+ */
+ if ((ccc->whitePtAdjProc != NULL) && !_XcmsEqualWhitePts(ccc,
+ pWhitePt, ScreenWhitePointOfCCC(ccc))) {
+ /*
+ * Need to call WhiteAdjustProc (Screen White Point to
+ * White Point).
+ */
+ retval_tmp = (*ccc->whitePtAdjProc)(ccc,
+ ScreenWhitePointOfCCC(ccc), pWhitePt,
+ XcmsCIEXYZFormat, pColors_start, nBatch,
+ (Bool *)NULL);
+ } else {
+ retval_tmp = _XcmsDDConvertColors(ccc, pColors_start,
+ nBatch, XcmsCIEXYZFormat, (Bool *)NULL);
+ }
+ } else if (XCMS_DD_ID(format) && (format_flag & DD_FORMAT) &&
+ XCMS_DD_ID(targetFormat)) {
+ /*
+ * DD->DD(not CIEXYZ)
+ *
+ * Format of interest is Device-Dependent,
+ * This batch contains Device-Dependent specifications, and
+ * the Target format is Device-Dependent and not CIEXYZ.
+ */
+ retval_tmp = _XcmsDDConvertColors(ccc, pColors_start, nBatch,
+ targetFormat, (Bool *)NULL);
+ } else {
+ /*
+ * This routine is called for the wrong reason.
+ */
+ return(XcmsFailure);
+ }
+ if (retval_tmp == XcmsFailure) {
+ return(XcmsFailure);
+ }
+ retval = MAX(retval, retval_tmp);
+ }
+ }
+ return(retval);
+}
+
+
+/************************************************************************
+ * *
+ * API PRIVATE ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * _XcmsEqualWhitePts
+ *
+ * SYNOPSIS
+ */
+int
+_XcmsEqualWhitePts(XcmsCCC ccc, XcmsColor *pWhitePt1, XcmsColor *pWhitePt2)
+/*
+ * DESCRIPTION
+ *
+ * RETURNS
+ * Returns 0 if not equal; otherwise 1.
+ *
+ */
+{
+ XcmsColor tmp1, tmp2;
+
+ memcpy((char *)&tmp1, (char *)pWhitePt1, sizeof(XcmsColor));
+ memcpy((char *)&tmp2, (char *)pWhitePt2, sizeof(XcmsColor));
+
+ if (tmp1.format != XcmsCIEXYZFormat) {
+ if (_XcmsDIConvertColors(ccc, &tmp1, (XcmsColor *) NULL, 1,
+ XcmsCIEXYZFormat)==0) {
+ return(0);
+ }
+ }
+
+ if (tmp2.format != XcmsCIEXYZFormat) {
+ if (_XcmsDIConvertColors(ccc, &tmp2, (XcmsColor *) NULL, 1,
+ XcmsCIEXYZFormat)==0) {
+ return(0);
+ }
+ }
+
+ return (EqualCIEXYZ(&tmp1, &tmp2));
+}
+
+
+/*
+ * NAME
+ * _XcmsDIConvertColors - Convert XcmsColor structures
+ *
+ * SYNOPSIS
+ */
+Status
+_XcmsDIConvertColors(
+ XcmsCCC ccc,
+ XcmsColor *pColors_in_out,
+ XcmsColor *pWhitePt,
+ unsigned int nColors,
+ XcmsColorFormat newFormat)
+/*
+ * DESCRIPTION
+ * Convert XcmsColor structures to another Device-Independent
+ * form.
+ *
+ * Here are some assumptions that this routine makes:
+ * 1. The calling routine has already checked if
+ * pColors_in_out->format == newFormat, therefore
+ * there is no need to check again here.
+ * 2. The calling routine has already checked nColors,
+ * therefore this routine assumes nColors > 0.
+ * 3. The calling routine may want to convert only between
+ * CIExyY <-> CIEXYZ <-> CIEuvY
+ * therefore, this routine allows pWhitePt to equal NULL.
+ *
+ *
+ * RETURNS
+ * XcmsFailure if failed,
+ * XcmsSuccess if succeeded.
+ *
+ */
+{
+ XcmsColorSpace *pFrom, *pTo;
+ XcmsDIConversionProc *src_to_CIEXYZ, *src_from_CIEXYZ;
+ XcmsDIConversionProc *dest_to_CIEXYZ, *dest_from_CIEXYZ;
+ XcmsDIConversionProc *to_CIEXYZ_stop, *from_CIEXYZ_start;
+ XcmsDIConversionProc *tmp;
+
+ /*
+ * Allow pWhitePt to equal NULL. This appropriate when converting
+ * anywhere between:
+ * CIExyY <-> CIEXYZ <-> CIEuvY
+ */
+
+ if (pColors_in_out == NULL ||
+ !ValidDIColorSpaceID(pColors_in_out->format) ||
+ !ValidDIColorSpaceID(newFormat)) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Get a handle on the function list for the current specification format
+ */
+ if ((pFrom = ColorSpaceOfID(ccc, pColors_in_out->format))
+ == NULL) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Get a handle on the function list for the new specification format
+ */
+ if ((pTo = ColorSpaceOfID(ccc, newFormat)) == NULL) {
+ return(XcmsFailure);
+ }
+
+ src_to_CIEXYZ = pFrom->to_CIEXYZ;
+ src_from_CIEXYZ = pFrom->from_CIEXYZ;
+ dest_to_CIEXYZ = pTo->to_CIEXYZ;
+ dest_from_CIEXYZ = pTo->from_CIEXYZ;
+
+ if (pTo->inverse_flag && pFrom->inverse_flag) {
+ /*
+ * Find common function pointers
+ */
+ for (to_CIEXYZ_stop = src_to_CIEXYZ; *to_CIEXYZ_stop; to_CIEXYZ_stop++){
+ for (tmp = dest_to_CIEXYZ; *tmp; tmp++) {
+ if (*to_CIEXYZ_stop == *tmp) {
+ goto Continue;
+ }
+ }
+ }
+
+Continue:
+
+ /*
+ * Execute the functions to CIEXYZ, stopping short as necessary
+ */
+ while (src_to_CIEXYZ != to_CIEXYZ_stop) {
+ if ((*src_to_CIEXYZ++)(ccc, pWhitePt, pColors_in_out,
+ nColors) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+ }
+
+ /*
+ * Determine where to start on the from_CIEXYZ path.
+ */
+ from_CIEXYZ_start = dest_from_CIEXYZ;
+ tmp = src_from_CIEXYZ;
+ while ((*from_CIEXYZ_start == *tmp) && (*from_CIEXYZ_start != NULL)) {
+ from_CIEXYZ_start++;
+ tmp++;
+ }
+
+ } else {
+ /*
+ * The function in at least one of the Color Spaces are not
+ * complementary, i.e.,
+ * for an i, 0 <= i < n elements
+ * from_CIEXYZ[i] is not the inverse of to_CIEXYZ[i]
+ *
+ * Execute the functions all the way to CIEXYZ
+ */
+ while (*src_to_CIEXYZ) {
+ if ((*src_to_CIEXYZ++)(ccc, pWhitePt, pColors_in_out,
+ nColors) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+ }
+
+ /*
+ * Determine where to start on the from_CIEXYZ path.
+ */
+ from_CIEXYZ_start = dest_from_CIEXYZ;
+ }
+
+
+ /*
+ * Execute the functions from CIEXYZ.
+ */
+ while (*from_CIEXYZ_start) {
+ if ((*from_CIEXYZ_start++)(ccc, pWhitePt, pColors_in_out,
+ nColors) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+ }
+
+ return(XcmsSuccess);
+}
+
+
+/*
+ * NAME
+ * _XcmsDDConvertColors - Convert XcmsColor structures
+ *
+ * SYNOPSIS
+ */
+Status
+_XcmsDDConvertColors(
+ XcmsCCC ccc,
+ XcmsColor *pColors_in_out,
+ unsigned int nColors,
+ XcmsColorFormat newFormat,
+ Bool *pCompressed)
+/*
+ * DESCRIPTION
+ * Convert XcmsColor structures:
+ *
+ * 1. From CIEXYZ to Device-Dependent formats (typically RGB and
+ * RGBi),
+ * or
+ * 2. Between Device-Dependent formats (typically RGB and RGBi).
+ *
+ * Assumes that these specifications have already been white point
+ * adjusted if necessary from Client White Point to Screen
+ * White Point. Therefore, the white point now associated
+ * with the specifications is the Screen White Point.
+ *
+ * pCompressed may be NULL. If so this indicates that the
+ * calling routine is not interested in knowing exactly which
+ * color was compressed, if any.
+ *
+ *
+ * RETURNS
+ * XcmsFailure if failed,
+ * XcmsSuccess if none of the color specifications were
+ * compressed in the conversion process
+ * XcmsSuccessWithCompression if at least one of the
+ * color specifications were compressed in the
+ * conversion process.
+ *
+ */
+{
+ XcmsColorSpace *pFrom, *pTo;
+ XcmsDDConversionProc *src_to_CIEXYZ, *src_from_CIEXYZ;
+ XcmsDDConversionProc *dest_to_CIEXYZ, *dest_from_CIEXYZ;
+ XcmsDDConversionProc *from_CIEXYZ_start, *to_CIEXYZ_stop;
+ XcmsDDConversionProc *tmp;
+ int retval;
+ int hasCompressed = 0;
+
+ if (ccc == NULL || pColors_in_out == NULL) {
+ return(XcmsFailure);
+ }
+
+ if (nColors == 0 || pColors_in_out->format == newFormat) {
+ /* do nothing */
+ return(XcmsSuccess);
+ }
+
+ if (((XcmsFunctionSet *)ccc->pPerScrnInfo->functionSet) == NULL) {
+ return(XcmsFailure); /* hmm, an internal error? */
+ }
+
+ /*
+ * Its ok if pColors_in_out->format == XcmsCIEXYZFormat
+ * or
+ * if newFormat == XcmsCIEXYZFormat
+ */
+ if ( !( ValidDDColorSpaceID(ccc, pColors_in_out->format)
+ ||
+ (pColors_in_out->format == XcmsCIEXYZFormat))
+ ||
+ !(ValidDDColorSpaceID(ccc, newFormat)
+ ||
+ newFormat == XcmsCIEXYZFormat)) {
+ return(XcmsFailure);
+ }
+
+ if ((pFrom = ColorSpaceOfID(ccc, pColors_in_out->format)) == NULL){
+ return(XcmsFailure);
+ }
+
+ if ((pTo = ColorSpaceOfID(ccc, newFormat)) == NULL) {
+ return(XcmsFailure);
+ }
+
+ src_to_CIEXYZ = (XcmsDDConversionProc *)pFrom->to_CIEXYZ;
+ src_from_CIEXYZ = (XcmsDDConversionProc *)pFrom->from_CIEXYZ;
+ dest_to_CIEXYZ = (XcmsDDConversionProc *)pTo->to_CIEXYZ;
+ dest_from_CIEXYZ = (XcmsDDConversionProc *)pTo->from_CIEXYZ;
+
+ if (pTo->inverse_flag && pFrom->inverse_flag) {
+ /*
+ * Find common function pointers
+ */
+ for (to_CIEXYZ_stop = src_to_CIEXYZ; *to_CIEXYZ_stop; to_CIEXYZ_stop++){
+ for (tmp = dest_to_CIEXYZ; *tmp; tmp++) {
+ if (*to_CIEXYZ_stop == *tmp) {
+ goto Continue;
+ }
+ }
+ }
+Continue:
+
+ /*
+ * Execute the functions
+ */
+ while (src_to_CIEXYZ != to_CIEXYZ_stop) {
+ retval = (*src_to_CIEXYZ++)(ccc, pColors_in_out, nColors,
+ pCompressed);
+ if (retval == XcmsFailure) {
+ return(XcmsFailure);
+ }
+ hasCompressed |= (retval == XcmsSuccessWithCompression);
+ }
+
+ /*
+ * Determine where to start on the from_CIEXYZ path.
+ */
+ from_CIEXYZ_start = dest_from_CIEXYZ;
+ tmp = src_from_CIEXYZ;
+ while ((*from_CIEXYZ_start == *tmp) && (*from_CIEXYZ_start != NULL)) {
+ from_CIEXYZ_start++;
+ tmp++;
+ }
+
+ } else {
+ /*
+ * The function in at least one of the Color Spaces are not
+ * complementary, i.e.,
+ * for an i, 0 <= i < n elements
+ * from_CIEXYZ[i] is not the inverse of to_CIEXYZ[i]
+ *
+ * Execute the functions all the way to CIEXYZ
+ */
+ while (*src_to_CIEXYZ) {
+ retval = (*src_to_CIEXYZ++)(ccc, pColors_in_out, nColors,
+ pCompressed);
+ if (retval == XcmsFailure) {
+ return(XcmsFailure);
+ }
+ hasCompressed |= (retval == XcmsSuccessWithCompression);
+ }
+
+ /*
+ * Determine where to start on the from_CIEXYZ path.
+ */
+ from_CIEXYZ_start = dest_from_CIEXYZ;
+ }
+
+ while (*from_CIEXYZ_start) {
+ retval = (*from_CIEXYZ_start++)(ccc, pColors_in_out, nColors,
+ pCompressed);
+ if (retval == XcmsFailure) {
+ return(XcmsFailure);
+ }
+ hasCompressed |= (retval == XcmsSuccessWithCompression);
+ }
+
+ return(hasCompressed ? XcmsSuccessWithCompression : XcmsSuccess);
+}
+
+
+/************************************************************************
+ * *
+ * PUBLIC ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsConvertColors - Convert XcmsColor structures
+ *
+ * SYNOPSIS
+ */
+Status
+XcmsConvertColors(
+ XcmsCCC ccc,
+ XcmsColor *pColors_in_out,
+ unsigned int nColors,
+ XcmsColorFormat targetFormat,
+ Bool *pCompressed)
+/*
+ * DESCRIPTION
+ * Convert XcmsColor structures to another format
+ *
+ * RETURNS
+ * XcmsFailure if failed,
+ * XcmsSuccess if succeeded without gamut compression,
+ * XcmsSuccessWithCompression if succeeded with gamut
+ * compression.
+ *
+ */
+{
+ XcmsColor clientWhitePt;
+ XcmsColor Color1;
+ XcmsColor *pColors_tmp;
+ int callWhiteAdjustProc = 0;
+ XcmsColorFormat format;
+ Status retval;
+ unsigned char contents_flag = 0x00;
+ unsigned int iColors;
+
+ if (ccc == NULL || pColors_in_out == NULL ||
+ !(ValidDIColorSpaceID(targetFormat) ||
+ ValidDDColorSpaceID(ccc, targetFormat))) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Check formats in color specification array
+ */
+ format = pColors_in_out->format;
+ for (pColors_tmp = pColors_in_out, iColors = nColors; iColors; pColors_tmp++, iColors--) {
+ if (!(ValidDIColorSpaceID(pColors_tmp->format) ||
+ ValidDDColorSpaceID(ccc, pColors_tmp->format))) {
+ return(XcmsFailure);
+ }
+ if (XCMS_DI_ID(pColors_tmp->format)) {
+ contents_flag |= DI_FORMAT;
+ } else {
+ contents_flag |= DD_FORMAT;
+ }
+ if (pColors_tmp->format != format) {
+ contents_flag |= MIX_FORMAT;
+ }
+ }
+
+ /*
+ * Check if we need the Client White Point.
+ */
+ if ((contents_flag & DI_FORMAT) || XCMS_DI_ID(targetFormat)) {
+ /* To proceed, we need to get the Client White Point */
+ memcpy((char *)&clientWhitePt, (char *)&ccc->clientWhitePt,
+ sizeof(XcmsColor));
+ if (clientWhitePt.format == XcmsUndefinedFormat) {
+ /*
+ * Client White Point is undefined, therefore set to the Screen
+ * White Point.
+ * Since Client White Point == Screen White Point, WhiteAdjustProc
+ * is not called.
+ */
+ memcpy((char *)&clientWhitePt,
+ (char *)&ccc->pPerScrnInfo->screenWhitePt,
+ sizeof(XcmsColor));
+ } else if ((ccc->whitePtAdjProc != NULL) && !_XcmsEqualWhitePts(ccc,
+ &clientWhitePt, ScreenWhitePointOfCCC(ccc))) {
+ /*
+ * Client White Point != Screen White Point, and WhiteAdjustProc
+ * is not NULL, therefore, will need to call it when
+ * converting between DI and DD specifications.
+ */
+ callWhiteAdjustProc = 1;
+ }
+ }
+
+ /*
+ * Make copy of array of color specifications
+ */
+ if (nColors > 1) {
+ pColors_tmp = Xmalloc(nColors * sizeof(XcmsColor));
+ } else {
+ pColors_tmp = &Color1;
+ }
+ memcpy((char *)pColors_tmp, (char *)pColors_in_out,
+ nColors * sizeof(XcmsColor));
+
+ /*
+ * zero out pCompressed
+ */
+ if (pCompressed) {
+ bzero((char *)pCompressed, nColors * sizeof(Bool));
+ }
+
+ if (contents_flag == DD_FORMAT || contents_flag == DI_FORMAT) {
+ /*
+ * ENTIRE ARRAY IS IN ONE FORMAT.
+ */
+ if (XCMS_DI_ID(format) && XCMS_DI_ID(targetFormat)) {
+ /*
+ * DI-to-DI only conversion
+ */
+ retval = _XcmsDIConvertColors(ccc, pColors_tmp,
+ &clientWhitePt, nColors, targetFormat);
+ } else if (XCMS_DD_ID(format) && XCMS_DD_ID(targetFormat)) {
+ /*
+ * DD-to-DD only conversion
+ * Since DD->DD there will be no compressed thus we can
+ * pass NULL instead of pCompressed.
+ */
+ retval = _XcmsDDConvertColors(ccc, pColors_tmp, nColors,
+ targetFormat, (Bool *)NULL);
+ } else {
+ /*
+ * Otherwise we have:
+ * 1. Device-Independent to Device-Dependent Conversion
+ * OR
+ * 2. Device-Dependent to Device-Independent Conversion
+ *
+ * We need to go from oldFormat -> CIEXYZ -> targetFormat
+ * adjusting for white points as necessary.
+ */
+
+ if (XCMS_DI_ID(format)) {
+ /*
+ * 1. Device-Independent to Device-Dependent Conversion
+ */
+ if (callWhiteAdjustProc) {
+ /*
+ * White Point Adjustment
+ * Client White Point to Screen White Point
+ */
+ retval = (*ccc->whitePtAdjProc)(ccc, &clientWhitePt,
+ ScreenWhitePointOfCCC(ccc), targetFormat,
+ pColors_tmp, nColors, pCompressed);
+ } else {
+ if (_XcmsDIConvertColors(ccc, pColors_tmp,
+ &clientWhitePt, nColors, XcmsCIEXYZFormat)
+ == XcmsFailure) {
+ goto Failure;
+ }
+ retval = _XcmsDDConvertColors(ccc, pColors_tmp, nColors,
+ targetFormat, pCompressed);
+ }
+ } else {
+ /*
+ * 2. Device-Dependent to Device-Independent Conversion
+ */
+ if (callWhiteAdjustProc) {
+ /*
+ * White Point Adjustment
+ * Screen White Point to Client White Point
+ */
+ retval = (*ccc->whitePtAdjProc)(ccc,
+ ScreenWhitePointOfCCC(ccc), &clientWhitePt,
+ targetFormat, pColors_tmp, nColors, pCompressed);
+ } else {
+ /*
+ * Since DD->CIEXYZ, no compression takes place therefore
+ * we can pass NULL instead of pCompressed.
+ */
+ if (_XcmsDDConvertColors(ccc, pColors_tmp, nColors,
+ XcmsCIEXYZFormat, (Bool *)NULL) == XcmsFailure) {
+ goto Failure;
+ }
+ retval = _XcmsDIConvertColors(ccc, pColors_tmp,
+ &clientWhitePt, nColors, targetFormat);
+ }
+ }
+ }
+ } else {
+ /*
+ * ARRAY HAS MIXED FORMATS.
+ */
+ if ((contents_flag == (DI_FORMAT | MIX_FORMAT)) &&
+ XCMS_DI_ID(targetFormat)) {
+ /*
+ * Convert from DI to DI in batches of contiguous formats
+ *
+ * Because DI->DI, WhiteAdjustProc not called.
+ */
+ retval = ConvertMixedColors(ccc, pColors_tmp, &clientWhitePt,
+ nColors, targetFormat, (unsigned char)DI_FORMAT);
+ } else if ((contents_flag == (DD_FORMAT | MIX_FORMAT)) &&
+ XCMS_DD_ID(targetFormat)) {
+ /*
+ * Convert from DD to DD in batches of contiguous formats
+ *
+ * Because DD->DD, WhiteAdjustProc not called.
+ */
+ retval = ConvertMixedColors(ccc, pColors_tmp,
+ (XcmsColor *)NULL, nColors, targetFormat,
+ (unsigned char)DD_FORMAT);
+ } else if (XCMS_DI_ID(targetFormat)) {
+ /*
+ * We need to convert from DI-to-DI and DD-to-DI, therefore
+ * 1. convert DD specifications to CIEXYZ, then
+ * 2. convert all in batches to the target DI format.
+ *
+ * Note that ConvertMixedColors will call WhiteAdjustProc
+ * as necessary.
+ */
+
+ /*
+ * Convert only DD specifications in batches of contiguous formats
+ * to CIEXYZ
+ *
+ * Since DD->CIEXYZ, ConvertMixedColors will apply WhiteAdjustProc
+ * if required.
+ */
+ retval = ConvertMixedColors(ccc, pColors_tmp, &clientWhitePt,
+ nColors, XcmsCIEXYZFormat, (unsigned char)DD_FORMAT);
+
+ /*
+ * Because at this point we may have a mix of DI formats
+ * (e.g., CIEXYZ, CIELuv) we must convert the specs to the
+ * target DI format in batches of contiguous source formats.
+ */
+ retval = ConvertMixedColors(ccc, pColors_tmp, &clientWhitePt,
+ nColors, targetFormat, (unsigned char)DI_FORMAT);
+ } else {
+ /*
+ * We need to convert from DI-to-DD and DD-to-DD, therefore
+ * 1. convert DI specifications to CIEXYZ, then
+ * 2. convert all to the DD target format.
+ *
+ * This allows white point adjustment and gamut compression
+ * to be applied to all the color specifications in one
+ * swoop if those functions do in fact modify the entire
+ * group of color specifications.
+ */
+
+ /*
+ * Convert in batches to CIEXYZ
+ *
+ * If DD->CIEXYZ, ConvertMixedColors will apply WhiteAdjustProc
+ * if required.
+ */
+ if ((retval = ConvertMixedColors(ccc, pColors_tmp, &clientWhitePt,
+ nColors, XcmsCIEXYZFormat,
+ (unsigned char)(DI_FORMAT | DD_FORMAT))) == XcmsFailure) {
+ goto Failure;
+ }
+
+ /*
+ * Convert all specifications (now in CIEXYZ format) to
+ * the target DD format.
+ * Since CIEXYZ->DD, compression MAY take place therefore
+ * we must pass pCompressed.
+ * Note that WhiteAdjustProc must be used if necessary.
+ */
+ if (callWhiteAdjustProc) {
+ /*
+ * White Point Adjustment
+ * Client White Point to Screen White Point
+ */
+ retval = (*ccc->whitePtAdjProc)(ccc,
+ &clientWhitePt, ScreenWhitePointOfCCC(ccc),
+ targetFormat, pColors_tmp, nColors, pCompressed);
+ } else {
+ retval = _XcmsDDConvertColors(ccc, pColors_tmp, nColors,
+ targetFormat, pCompressed);
+ }
+ }
+ }
+
+ if (retval != XcmsFailure) {
+ memcpy((char *)pColors_in_out, (char *)pColors_tmp,
+ nColors * sizeof(XcmsColor));
+ }
+ if (nColors > 1) {
+ Xfree(pColors_tmp);
+ }
+ return(retval);
+
+Failure:
+ if (nColors > 1) {
+ Xfree(pColors_tmp);
+ }
+ return(XcmsFailure);
+}
+
+
+/*
+ * NAME
+ * XcmsRegFormatOfPrefix
+ *
+ * SYNOPSIS
+ */
+XcmsColorFormat
+_XcmsRegFormatOfPrefix(
+ _Xconst char *prefix)
+/*
+ * DESCRIPTION
+ * Returns a color space ID associated with the specified
+ * X Consortium registered color space prefix.
+ *
+ * RETURNS
+ * The color space ID if found;
+ * otherwise NULL.
+ */
+{
+ XcmsRegColorSpaceEntry *pEntry = _XcmsRegColorSpaces;
+
+ while (pEntry->prefix != NULL) {
+ if (strcmp(prefix, pEntry->prefix) == 0) {
+ return(pEntry->id);
+ }
+ pEntry++;
+ }
+ return(XcmsUndefinedFormat);
+}
diff --git a/nx-X11/lib/src/xcms/HVC.c b/nx-X11/lib/src/xcms/HVC.c
new file mode 100644
index 000000000..98d7142c3
--- /dev/null
+++ b/nx-X11/lib/src/xcms/HVC.c
@@ -0,0 +1,625 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. TekColor is a
+ * trademark of Tektronix, Inc. The term "TekHVC" designates a particular
+ * color space that is the subject of U.S. Patent No. 4,985,853 (equivalent
+ * foreign patents pending). Permission is hereby granted to use, copy,
+ * modify, sell, and otherwise distribute this software and its
+ * documentation for any purpose and without fee, provided that:
+ *
+ * 1. This copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and any modification thereof and in
+ * supporting documentation;
+ * 2. Any color-handling application which displays TekHVC color
+ * cooordinates identifies these as TekHVC color coordinates in any
+ * interface that displays these coordinates and in any associated
+ * documentation;
+ * 3. The term "TekHVC" is always used, and is only used, in association
+ * with the mathematical derivations of the TekHVC Color Space,
+ * including those provided in this file and any equivalent pathways and
+ * mathematical derivations, regardless of digital (e.g., floating point
+ * or integer) representation.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ * NAME
+ * TekHVC.c
+ *
+ * DESCRIPTION
+ * This file contains routines that support the TekHVC
+ * color space to include conversions to and from the CIE
+ * XYZ space.
+ *
+ * DOCUMENTATION
+ * "TekColor Color Management System, System Implementor's Manual"
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include <nx-X11/Xos.h>
+#include <math.h>
+#include "Cv.h"
+
+#include <stdio.h>
+
+/*
+ * DEFINES
+ */
+#define u_BR 0.7127 /* u' Best Red */
+#define v_BR 0.4931 /* v' Best Red */
+#define EPS 0.001
+#define CHROMA_SCALE_FACTOR 7.50725
+#ifndef PI
+# ifdef M_PI
+# define PI M_PI
+# else
+# define PI 3.14159265358979323846264338327950
+# endif
+#endif
+#ifndef degrees
+# define degrees(r) ((XcmsFloat)(r) * 180.0 / PI)
+#endif /* degrees */
+#ifndef radians
+# define radians(d) ((XcmsFloat)(d) * PI / 180.0)
+#endif /* radians */
+
+/*************************************************************************
+ * Note: The DBL_EPSILON for ANSI is 1e-5 so my checks need to take
+ * this into account. If your DBL_EPSILON is different then
+ * adjust this define.
+ *
+ * Also note that EPS is the error factor in the calculations
+ * This may need to be the same as XMY_DBL_EPSILON in
+ * some implementations.
+ **************************************************************************/
+#ifdef DBL_EPSILON
+# define XMY_DBL_EPSILON DBL_EPSILON
+#else
+# define XMY_DBL_EPSILON 0.00001
+#endif
+
+/*
+ * FORWARD DECLARATIONS
+ */
+static int TekHVC_ParseString(register char *spec, XcmsColor *pColor);
+static Status XcmsTekHVC_ValidSpec(XcmsColor *pColor);
+
+/*
+ * LOCAL VARIABLES
+ */
+
+ /*
+ * NULL terminated list of functions applied to get from TekHVC to CIEXYZ
+ */
+static XcmsConversionProc Fl_TekHVC_to_CIEXYZ[] = {
+ XcmsTekHVCToCIEuvY,
+ XcmsCIEuvYToCIEXYZ,
+ NULL
+};
+
+ /*
+ * NULL terminated list of functions applied to get from CIEXYZ to TekHVC
+ */
+static XcmsConversionProc Fl_CIEXYZ_to_TekHVC[] = {
+ XcmsCIEXYZToCIEuvY,
+ XcmsCIEuvYToTekHVC,
+ NULL
+};
+
+/*
+ * GLOBALS
+ */
+
+ /*
+ * TekHVC Color Space
+ */
+XcmsColorSpace XcmsTekHVCColorSpace =
+ {
+ _XcmsTekHVC_prefix, /* prefix */
+ XcmsTekHVCFormat, /* id */
+ TekHVC_ParseString, /* parseString */
+ Fl_TekHVC_to_CIEXYZ, /* to_CIEXYZ */
+ Fl_CIEXYZ_to_TekHVC, /* from_CIEXYZ */
+ 1
+ };
+
+
+
+
+/************************************************************************
+ * *
+ * PRIVATE ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * TekHVC_ParseString
+ *
+ * SYNOPSIS
+ */
+static int
+TekHVC_ParseString(
+ register char *spec,
+ XcmsColor *pColor)
+/*
+ * DESCRIPTION
+ * This routines takes a string and attempts to convert
+ * it into a XcmsColor structure with XcmsTekHVCFormat.
+ * The assumed TekHVC string syntax is:
+ * TekHVC:<H>/<V>/<C>
+ * Where H, V, and C are in string input format for floats
+ * consisting of:
+ * a. an optional sign
+ * b. a string of numbers possibly containing a decimal point,
+ * c. an optional exponent field containing an 'E' or 'e'
+ * followed by a possibly signed integer string.
+ *
+ * RETURNS
+ * XcmsFailure if invalid;
+ * XcmsSuccess if valid.
+ */
+{
+ size_t n;
+ char *pchar;
+
+ if ((pchar = strchr(spec, ':')) == NULL) {
+ return(XcmsFailure);
+ }
+ n = (size_t)(pchar - spec);
+
+ /*
+ * Check for proper prefix.
+ */
+ if (strncmp(spec, _XcmsTekHVC_prefix, n) != 0) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Attempt to parse the value portion.
+ */
+ if (sscanf(spec + n + 1, "%lf/%lf/%lf",
+ &pColor->spec.TekHVC.H,
+ &pColor->spec.TekHVC.V,
+ &pColor->spec.TekHVC.C) != 3) {
+ char *s; /* Maybe failed due to locale */
+ int f;
+ if ((s = strdup(spec))) {
+ for (f = 0; s[f]; ++f)
+ if (s[f] == '.')
+ s[f] = ',';
+ else if (s[f] == ',')
+ s[f] = '.';
+ if (sscanf(s + n + 1, "%lf/%lf/%lf",
+ &pColor->spec.TekHVC.H,
+ &pColor->spec.TekHVC.V,
+ &pColor->spec.TekHVC.C) != 3) {
+ free(s);
+ return(XcmsFailure);
+ }
+ free(s);
+ } else
+ return(XcmsFailure);
+ }
+ pColor->format = XcmsTekHVCFormat;
+ pColor->pixel = 0;
+ return(XcmsTekHVC_ValidSpec(pColor));
+}
+
+
+/*
+ * NAME
+ * ThetaOffset -- compute thetaOffset
+ *
+ * SYNOPSIS
+ */
+static int
+ThetaOffset(
+ XcmsColor *pWhitePt,
+ XcmsFloat *pThetaOffset)
+/*
+ * DESCRIPTION
+ * This routine computes the theta offset of a given
+ * white point, i.e. XcmsColor. It is used in both this
+ * conversion and the printer conversions.
+ *
+ * RETURNS
+ * 0 if failed.
+ * 1 if succeeded with no modifications.
+ *
+ * ASSUMPTIONS
+ * Assumes:
+ * pWhitePt != NULL
+ * pWhitePt->format == XcmsCIEuvYFormat
+ *
+ */
+{
+ double div, slopeuv;
+
+ if (pWhitePt == NULL || pWhitePt->format != XcmsCIEuvYFormat) {
+ return(0);
+ }
+
+ if ((div = u_BR - pWhitePt->spec.CIEuvY.u_prime) == 0.0) {
+ return(0);
+ }
+ slopeuv = (v_BR - pWhitePt->spec.CIEuvY.v_prime) / div;
+ *pThetaOffset = degrees(XCMS_ATAN(slopeuv));
+ return(1);
+}
+
+
+
+/************************************************************************
+ * *
+ * PUBLIC ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsTekHVC_ValidSpec()
+ *
+ * SYNOPSIS
+ */
+static int
+XcmsTekHVC_ValidSpec(
+ XcmsColor *pColor)
+/*
+ * DESCRIPTION
+ * Checks if values in the color specification are valid.
+ * Also brings hue into the range 0.0 <= Hue < 360.0
+ *
+ * RETURNS
+ * 0 if not valid.
+ * 1 if valid.
+ *
+ */
+{
+ if (pColor->format != XcmsTekHVCFormat) {
+ return(XcmsFailure);
+ }
+ if (pColor->spec.TekHVC.V < (0.0 - XMY_DBL_EPSILON)
+ || pColor->spec.TekHVC.V > (100.0 + XMY_DBL_EPSILON)
+ || (pColor->spec.TekHVC.C < 0.0 - XMY_DBL_EPSILON)) {
+ return(XcmsFailure);
+ }
+
+ if (pColor->spec.TekHVC.V < 0.0) {
+ pColor->spec.TekHVC.V = 0.0 + XMY_DBL_EPSILON;
+ } else if (pColor->spec.TekHVC.V > 100.0) {
+ pColor->spec.TekHVC.V = 100.0 - XMY_DBL_EPSILON;
+ }
+
+ if (pColor->spec.TekHVC.C < 0.0) {
+ pColor->spec.TekHVC.C = 0.0 - XMY_DBL_EPSILON;
+ }
+
+ while (pColor->spec.TekHVC.H < 0.0) {
+ pColor->spec.TekHVC.H += 360.0;
+ }
+ while (pColor->spec.TekHVC.H >= 360.0) {
+ pColor->spec.TekHVC.H -= 360.0;
+ }
+ return(XcmsSuccess);
+}
+
+/*
+ * NAME
+ * XcmsTekHVCToCIEuvY - convert TekHVC to CIEuvY
+ *
+ * SYNOPSIS
+ */
+Status
+XcmsTekHVCToCIEuvY(
+ XcmsCCC ccc,
+ XcmsColor *pHVC_WhitePt,
+ XcmsColor *pColors_in_out,
+ unsigned int nColors)
+/*
+ * DESCRIPTION
+ * Transforms an array of TekHVC color specifications, given
+ * their associated white point, to CIECIEuvY.color
+ * specifications.
+ *
+ * RETURNS
+ * XcmsFailure if failed, XcmsSuccess otherwise.
+ *
+ */
+{
+ XcmsFloat thetaOffset;
+ XcmsColor *pColor = pColors_in_out;
+ XcmsColor whitePt;
+ XcmsCIEuvY uvY_return;
+ XcmsFloat tempHue, u, v;
+ XcmsFloat tmpVal;
+ unsigned int i;
+
+ /*
+ * Check arguments
+ */
+ if (pHVC_WhitePt == NULL || pColors_in_out == NULL) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Make sure white point is in CIEuvY form
+ */
+ if (pHVC_WhitePt->format != XcmsCIEuvYFormat) {
+ /* Make copy of the white point because we're going to modify it */
+ memcpy((char *)&whitePt, (char *)pHVC_WhitePt, sizeof(XcmsColor));
+ if (!_XcmsDIConvertColors(ccc, &whitePt, (XcmsColor *)NULL, 1,
+ XcmsCIEuvYFormat)) {
+ return(XcmsFailure);
+ }
+ pHVC_WhitePt = &whitePt;
+ }
+ /* Make sure it is a white point, i.e., Y == 1.0 */
+ if (pHVC_WhitePt->spec.CIEuvY.Y != 1.0) {
+ return(XcmsFailure);
+ }
+
+ /* Get the thetaOffset */
+ if (!ThetaOffset(pHVC_WhitePt, &thetaOffset)) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Now convert each XcmsColor structure to CIEXYZ form
+ */
+ for (i = 0; i < nColors; i++, pColor++) {
+
+ /* Make sure original format is TekHVC and is valid */
+ if (!XcmsTekHVC_ValidSpec(pColor)) {
+ return(XcmsFailure);
+ }
+
+ if (pColor->spec.TekHVC.V == 0.0 || pColor->spec.TekHVC.V == 100.0) {
+ if (pColor->spec.TekHVC.V == 100.0) {
+ uvY_return.Y = 1.0;
+ } else { /* pColor->spec.TekHVC.V == 0.0 */
+ uvY_return.Y = 0.0;
+ }
+ uvY_return.u_prime = pHVC_WhitePt->spec.CIEuvY.u_prime;
+ uvY_return.v_prime = pHVC_WhitePt->spec.CIEuvY.v_prime;
+ } else {
+
+ /* Find the hue based on the white point offset */
+ tempHue = pColor->spec.TekHVC.H + thetaOffset;
+
+ while (tempHue < 0.0) {
+ tempHue += 360.0;
+ }
+ while (tempHue >= 360.0) {
+ tempHue -= 360.0;
+ }
+
+ tempHue = radians(tempHue);
+
+ /* Calculate u'v' for the obtained hue */
+ u = (XcmsFloat) ((XCMS_COS(tempHue) * pColor->spec.TekHVC.C) /
+ (pColor->spec.TekHVC.V * (double)CHROMA_SCALE_FACTOR));
+ v = (XcmsFloat) ((XCMS_SIN(tempHue) * pColor->spec.TekHVC.C) /
+ (pColor->spec.TekHVC.V * (double)CHROMA_SCALE_FACTOR));
+
+ /* Based on the white point get the offset from best red */
+ uvY_return.u_prime = u + pHVC_WhitePt->spec.CIEuvY.u_prime;
+ uvY_return.v_prime = v + pHVC_WhitePt->spec.CIEuvY.v_prime;
+
+ /* Calculate the Y value based on the L* = V. */
+ if (pColor->spec.TekHVC.V < 7.99953624) {
+ uvY_return.Y = pColor->spec.TekHVC.V / 903.29;
+ } else {
+ tmpVal = (pColor->spec.TekHVC.V + 16.0) / 116.0;
+ uvY_return.Y = tmpVal * tmpVal * tmpVal; /* tmpVal ** 3 */
+ }
+ }
+
+ /* Copy result to pColor */
+ memcpy((char *)&pColor->spec, (char *)&uvY_return, sizeof(XcmsCIEuvY));
+
+ /* Identify that the format is now CIEuvY */
+ pColor->format = XcmsCIEuvYFormat;
+ }
+ return(XcmsSuccess);
+}
+
+
+/*
+ * NAME
+ * XcmsCIEuvYToTekHVC - convert CIEuvY to TekHVC
+ *
+ * SYNOPSIS
+ */
+Status
+XcmsCIEuvYToTekHVC(
+ XcmsCCC ccc,
+ XcmsColor *pHVC_WhitePt,
+ XcmsColor *pColors_in_out,
+ unsigned int nColors)
+/*
+ * DESCRIPTION
+ * Transforms an array of CIECIEuvY.color specifications, given
+ * their assiciated white point, to TekHVC specifications.
+ *
+ * RETURNS
+ * XcmsFailure if failed, XcmsSuccess otherwise.
+ *
+ */
+{
+ XcmsFloat theta, L2, u, v, nThetaLow, nThetaHigh;
+ XcmsFloat thetaOffset;
+ XcmsColor *pColor = pColors_in_out;
+ XcmsColor whitePt;
+ XcmsTekHVC HVC_return;
+ unsigned int i;
+
+ /*
+ * Check arguments
+ */
+ if (pHVC_WhitePt == NULL || pColors_in_out == NULL) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Make sure white point is in CIEuvY form
+ */
+ if (pHVC_WhitePt->format != XcmsCIEuvYFormat) {
+ /* Make copy of the white point because we're going to modify it */
+ memcpy((char *)&whitePt, (char *)pHVC_WhitePt, sizeof(XcmsColor));
+ if (!_XcmsDIConvertColors(ccc, &whitePt, (XcmsColor *)NULL, 1,
+ XcmsCIEuvYFormat)) {
+ return(XcmsFailure);
+ }
+ pHVC_WhitePt = &whitePt;
+ }
+ /* Make sure it is a white point, i.e., Y == 1.0 */
+ if (pHVC_WhitePt->spec.CIEuvY.Y != 1.0) {
+ return(XcmsFailure);
+ }
+ if (!ThetaOffset(pHVC_WhitePt, &thetaOffset)) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Now convert each XcmsColor structure to CIEXYZ form
+ */
+ for (i = 0; i < nColors; i++, pColor++) {
+ if (!_XcmsCIEuvY_ValidSpec(pColor)) {
+ return(XcmsFailure);
+ }
+
+ /* Use the white point offset to determine HVC */
+ u = pColor->spec.CIEuvY.u_prime - pHVC_WhitePt->spec.CIEuvY.u_prime;
+ v = pColor->spec.CIEuvY.v_prime - pHVC_WhitePt->spec.CIEuvY.v_prime;
+
+ /* Calculate the offset */
+ if (u == 0.0) {
+ theta = 0.0;
+ } else {
+ theta = v / u;
+ theta = (XcmsFloat) XCMS_ATAN((double)theta);
+ theta = degrees(theta);
+ }
+
+ nThetaLow = 0.0;
+ nThetaHigh = 360.0;
+ if (u > 0.0 && v > 0.0) {
+ nThetaLow = 0.0;
+ nThetaHigh = 90.0;
+ } else if (u < 0.0 && v > 0.0) {
+ nThetaLow = 90.0;
+ nThetaHigh = 180.0;
+ } else if (u < 0.0 && v < 0.0) {
+ nThetaLow = 180.0;
+ nThetaHigh = 270.0;
+ } else if (u > 0.0 && v < 0.0) {
+ nThetaLow = 270.0;
+ nThetaHigh = 360.0;
+ }
+ while (theta < nThetaLow) {
+ theta += 90.0;
+ }
+ while (theta >= nThetaHigh) {
+ theta -= 90.0;
+ }
+
+ /* calculate the L value from the given Y */
+ L2 = (pColor->spec.CIEuvY.Y < 0.008856)
+ ?
+ (pColor->spec.CIEuvY.Y * 903.29)
+ :
+ ((XcmsFloat)(XCMS_CUBEROOT(pColor->spec.CIEuvY.Y) * 116.0) - 16.0);
+ HVC_return.C = L2 * CHROMA_SCALE_FACTOR * XCMS_SQRT((double) ((u * u) + (v * v)));
+ if (HVC_return.C < 0.0) {
+ theta = 0.0;
+ }
+ HVC_return.V = L2;
+ HVC_return.H = theta - thetaOffset;
+
+ /*
+ * If this is within the error margin let some other routine later
+ * in the chain worry about the slop in the calculations.
+ */
+ while (HVC_return.H < -EPS) {
+ HVC_return.H += 360.0;
+ }
+ while (HVC_return.H >= 360.0 + EPS) {
+ HVC_return.H -= 360.0;
+ }
+
+ /* Copy result to pColor */
+ memcpy((char *)&pColor->spec, (char *)&HVC_return, sizeof(XcmsTekHVC));
+
+ /* Identify that the format is now CIEuvY */
+ pColor->format = XcmsTekHVCFormat;
+ }
+ return(XcmsSuccess);
+}
+
+
+/*
+ * NAME
+ * _XcmsTekHVC_CheckModify
+ *
+ * SYNOPSIS
+ */
+int
+_XcmsTekHVC_CheckModify(
+ XcmsColor *pColor)
+/*
+ * DESCRIPTION
+ * Checks if values in the color specification are valid.
+ * If they are not it modifies the values.
+ * Also brings hue into the range 0.0 <= Hue < 360.0
+ *
+ * RETURNS
+ * 0 if not valid.
+ * 1 if valid.
+ *
+ */
+{
+ int n;
+
+ /* For now only use the TekHVC numbers as inputs */
+ if (pColor->format != XcmsTekHVCFormat) {
+ return(0);
+ }
+
+ if (pColor->spec.TekHVC.V < 0.0) {
+ pColor->spec.TekHVC.V = 0.0 + XMY_DBL_EPSILON;
+ } else if (pColor->spec.TekHVC.V > 100.0) {
+ pColor->spec.TekHVC.V = 100.0 - XMY_DBL_EPSILON;
+ }
+
+ if (pColor->spec.TekHVC.C < 0.0) {
+ pColor->spec.TekHVC.C = 0.0 - XMY_DBL_EPSILON;
+ }
+
+ if (pColor->spec.TekHVC.H < 0.0) {
+ n = -pColor->spec.TekHVC.H / 360.0;
+ pColor->spec.TekHVC.H += (n + 1) * 360.0;
+ if (pColor->spec.TekHVC.H >= 360.0)
+ pColor->spec.TekHVC.H -= 360.0;
+ } else if (pColor->spec.TekHVC.H >= 360.0) {
+ n = pColor->spec.TekHVC.H / 360.0;
+ pColor->spec.TekHVC.H -= n * 360.0;
+ }
+ return(1);
+}
diff --git a/nx-X11/lib/src/xcms/HVCGcC.c b/nx-X11/lib/src/xcms/HVCGcC.c
new file mode 100644
index 000000000..6d52eac63
--- /dev/null
+++ b/nx-X11/lib/src/xcms/HVCGcC.c
@@ -0,0 +1,149 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. TekColor is a
+ * trademark of Tektronix, Inc. The term "TekHVC" designates a particular
+ * color space that is the subject of U.S. Patent No. 4,985,853 (equivalent
+ * foreign patents pending). Permission is hereby granted to use, copy,
+ * modify, sell, and otherwise distribute this software and its
+ * documentation for any purpose and without fee, provided that:
+ *
+ * 1. This copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and any modification thereof and in
+ * supporting documentation;
+ * 2. Any color-handling application which displays TekHVC color
+ * cooordinates identifies these as TekHVC color coordinates in any
+ * interface that displays these coordinates and in any associated
+ * documentation;
+ * 3. The term "TekHVC" is always used, and is only used, in association
+ * with the mathematical derivations of the TekHVC Color Space,
+ * including those provided in this file and any equivalent pathways and
+ * mathematical derivations, regardless of digital (e.g., floating point
+ * or integer) representation.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ * NAME
+ * TekHVCGcC.c
+ *
+ * DESCRIPTION
+ * Source for XcmsTekHVCClipC() gamut compression routine.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+
+/************************************************************************
+ * *
+ * PUBLIC ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsTekHVCClipC - Reduce the chroma for a hue and value
+ *
+ * SYNOPSIS
+ */
+/* ARGSUSED */
+Status
+XcmsTekHVCClipC (
+ XcmsCCC ccc,
+ XcmsColor *pColors_in_out,
+ unsigned int nColors,
+ unsigned int i,
+ Bool *pCompressed)
+/*
+ * DESCRIPTION
+ * Reduce the Chroma for a specific hue and value to
+ * to bring the given color into the gamut of the
+ * specified device. As required of gamut compression
+ * functions in Xcms, this routine returns pColor_in_out
+ * in XcmsCIEXYZFormat on successful completion.
+ *
+ * Since this routine works with the value within
+ * pColor_in_out intermediate results may be returned
+ * even though it may be invalid.
+ *
+ * RETURNS
+ * XcmsFailure - Failure
+ * XcmsSuccess - Succeeded
+ *
+ */
+{
+ Status retval;
+ XcmsColor *pColor;
+
+ /*
+ * Color specification passed as input can be assumed to:
+ * 1. Be in XcmsCIEXYZFormat
+ * 2. Already be white point adjusted for the Screen White Point.
+ * This means that the white point now associated with this
+ * color spec is the Screen White Point (even if the
+ * ccc->clientWhitePt differs).
+ */
+
+ /*
+ * Insure TekHVC installed
+ */
+ if (XcmsAddColorSpace(&XcmsTekHVCColorSpace) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ pColor = pColors_in_out + i;
+
+ if (ccc->visual->class < StaticColor &&
+ FunctionSetOfCCC(ccc) != (XPointer) &XcmsLinearRGBFunctionSet) {
+ /*
+ * GRAY !
+ */
+ _XcmsDIConvertColors(ccc, pColor, &ccc->pPerScrnInfo->screenWhitePt,
+ 1, XcmsTekHVCFormat);
+ pColor->spec.TekHVC.H = pColor->spec.TekHVC.C = 0.0;
+ _XcmsDIConvertColors(ccc, pColor, &ccc->pPerScrnInfo->screenWhitePt,
+ 1, XcmsCIEXYZFormat);
+ if (pCompressed) {
+ *(pCompressed + i) = True;
+ }
+ return(XcmsSuccess);
+ } else {
+ if (pColor->format != XcmsTekHVCFormat) {
+ if (_XcmsDIConvertColors(ccc, pColor,
+ &ccc->pPerScrnInfo->screenWhitePt, 1, XcmsTekHVCFormat)
+ == XcmsFailure) {
+ return(XcmsFailure);
+ }
+ }
+ if (XcmsTekHVCQueryMaxC(ccc,
+ pColor->spec.TekHVC.H,
+ pColor->spec.TekHVC.V,
+ pColor)
+ == XcmsFailure) {
+ return(XcmsFailure);
+ }
+ retval = _XcmsDIConvertColors(ccc, pColor,
+ &ccc->pPerScrnInfo->screenWhitePt, 1, XcmsCIEXYZFormat);
+ if (retval != XcmsFailure && pCompressed != NULL) {
+ *(pCompressed + i) = True;
+ }
+ return(retval);
+ }
+}
diff --git a/nx-X11/lib/src/xcms/HVCGcV.c b/nx-X11/lib/src/xcms/HVCGcV.c
new file mode 100644
index 000000000..0752a0724
--- /dev/null
+++ b/nx-X11/lib/src/xcms/HVCGcV.c
@@ -0,0 +1,201 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. TekColor is a
+ * trademark of Tektronix, Inc. The term "TekHVC" designates a particular
+ * color space that is the subject of U.S. Patent No. 4,985,853 (equivalent
+ * foreign patents pending). Permission is hereby granted to use, copy,
+ * modify, sell, and otherwise distribute this software and its
+ * documentation for any purpose and without fee, provided that:
+ *
+ * 1. This copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and any modification thereof and in
+ * supporting documentation;
+ * 2. Any color-handling application which displays TekHVC color
+ * cooordinates identifies these as TekHVC color coordinates in any
+ * interface that displays these coordinates and in any associated
+ * documentation;
+ * 3. The term "TekHVC" is always used, and is only used, in association
+ * with the mathematical derivations of the TekHVC Color Space,
+ * including those provided in this file and any equivalent pathways and
+ * mathematical derivations, regardless of digital (e.g., floating point
+ * or integer) representation.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ * NAME
+ * TekHVCGcV.c
+ *
+ * DESCRIPTION
+ * Source for XcmsTekHVCClipV() gamut compression routine.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+
+/************************************************************************
+ * *
+ * PUBLIC ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsTekHVCClipV - Return the closest value
+ *
+ * SYNOPSIS
+ */
+/* ARGSUSED */
+Status
+XcmsTekHVCClipV (
+ XcmsCCC ccc,
+ XcmsColor *pColors_in_out,
+ unsigned int nColors,
+ unsigned int i,
+ Bool *pCompressed)
+/*
+ * DESCRIPTION
+ * Return the closest value for a specific hue and chroma.
+ * This routine takes any color as input and outputs
+ * a CIE XYZ color.
+ *
+ * Since this routine works with the value within
+ * pColor_in_out intermediate results may be returned
+ * even though it may be invalid.
+ *
+ * RETURNS
+ * XcmsFailure - Failure
+ * XcmsSuccess - Succeeded
+ *
+ */
+{
+ XcmsColor *pColor;
+ XcmsColor hvc_max;
+ XcmsCCCRec myCCC;
+ Status retval;
+
+ /*
+ * Insure TekHVC installed
+ */
+ if (XcmsAddColorSpace(&XcmsTekHVCColorSpace) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ /* Use my own CCC */
+ memcpy ((char *)&myCCC, (char *)ccc, sizeof(XcmsCCCRec));
+ myCCC.clientWhitePt.format = XcmsUndefinedFormat;/* Inherit Screen WP */
+ myCCC.gamutCompProc = (XcmsCompressionProc)NULL;/* no gamut compression */
+
+ /*
+ * Color specification passed as input can be assumed to:
+ * 1. Be in XcmsCIEXYZFormat
+ * 2. Already be white point adjusted for the Screen White Point.
+ * This means that the white point now associated with this
+ * color spec is the Screen White Point (even if the
+ * ccc->clientWhitePt differs).
+ */
+
+ pColor = pColors_in_out + i;
+
+ if (ccc->visual->class < StaticColor &&
+ FunctionSetOfCCC(ccc) != (XPointer) &XcmsLinearRGBFunctionSet) {
+ /*
+ * GRAY !
+ */
+ return(XcmsFailure);
+ } else {
+ /* Convert from CIEXYZ to TekHVC format */
+ if (_XcmsDIConvertColors(&myCCC, pColor,
+ &myCCC.pPerScrnInfo->screenWhitePt, 1, XcmsTekHVCFormat)
+ == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ /* check to make sure we have a valid TekHVC number */
+ if (!_XcmsTekHVC_CheckModify (pColor)) {
+ return (XcmsFailure);
+ }
+
+ /* Step 1: compute the maximum value and chroma for this hue. */
+ /* This copy may be overkill but it preserves the pixel etc. */
+ memcpy((char *)&hvc_max, (char *)pColor, sizeof(XcmsColor));
+ if (_XcmsTekHVCQueryMaxVCRGB (&myCCC, hvc_max.spec.TekHVC.H, &hvc_max,
+ (XcmsRGBi *)NULL) == XcmsFailure) {
+ return (XcmsFailure);
+ }
+
+ /* Now check and return the appropriate value */
+ if (pColor->spec.TekHVC.C == hvc_max.spec.TekHVC.C) {
+ /* When the chroma input is equal to the maximum chroma */
+ /* merely return the value for that chroma. */
+ pColor->spec.TekHVC.V = hvc_max.spec.TekHVC.V;
+ if (!_XcmsTekHVC_CheckModify (pColor)) {
+ return (XcmsFailure);
+ }
+ retval = _XcmsDIConvertColors(&myCCC, pColor,
+ &myCCC.pPerScrnInfo->screenWhitePt, 1, XcmsCIEXYZFormat);
+ } else if (pColor->spec.TekHVC.C > hvc_max.spec.TekHVC.C) {
+ /* When the chroma input is greater than the maximum chroma */
+ /* merely return the value and chroma for the given hue. */
+ pColor->spec.TekHVC.C = hvc_max.spec.TekHVC.C;
+ pColor->spec.TekHVC.V = hvc_max.spec.TekHVC.V;
+ return (XcmsFailure);
+ } else if (pColor->spec.TekHVC.V < hvc_max.spec.TekHVC.V) {
+ /* When the value input is less than the maximum value point */
+ /* compute the intersection of the line from 0,0 to max_V, max_C */
+ /* using the chroma input. */
+ pColor->spec.TekHVC.V = pColor->spec.TekHVC.C *
+ hvc_max.spec.TekHVC.V / hvc_max.spec.TekHVC.C;
+ if (pColor->spec.TekHVC.V >= hvc_max.spec.TekHVC.V) {
+ pColor->spec.TekHVC.C = hvc_max.spec.TekHVC.C;
+ pColor->spec.TekHVC.V = hvc_max.spec.TekHVC.V;
+ }
+ if (!_XcmsTekHVC_CheckModify (pColor)) {
+ return (XcmsFailure);
+ }
+ retval = _XcmsDIConvertColors(&myCCC, pColor,
+ &myCCC.pPerScrnInfo->screenWhitePt, 1, XcmsCIEXYZFormat);
+ } else {
+ /* When the value input is greater than the maximum value point */
+ /* use HvcMaxValue to find the maximum value for the given chroma. */
+ if (pColor->format != XcmsTekHVCFormat) {
+ if (_XcmsDIConvertColors(ccc, pColor,
+ &ccc->pPerScrnInfo->screenWhitePt, 1, XcmsCIEXYZFormat)
+ == XcmsFailure) {
+ return(XcmsFailure);
+ }
+ }
+ if (XcmsTekHVCQueryMaxV(&myCCC,
+ pColor->spec.TekHVC.H,
+ pColor->spec.TekHVC.C,
+ pColor)
+ == XcmsFailure) {
+ return (XcmsFailure);
+ }
+ retval = _XcmsDIConvertColors(&myCCC, pColor,
+ &myCCC.pPerScrnInfo->screenWhitePt, 1, XcmsCIEXYZFormat);
+ }
+ if (retval != XcmsFailure && pCompressed != NULL) {
+ *(pCompressed + i) = True;
+ }
+ return(retval);
+ }
+}
diff --git a/nx-X11/lib/src/xcms/HVCGcVC.c b/nx-X11/lib/src/xcms/HVCGcVC.c
new file mode 100644
index 000000000..7ace5f13f
--- /dev/null
+++ b/nx-X11/lib/src/xcms/HVCGcVC.c
@@ -0,0 +1,262 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. TekColor is a
+ * trademark of Tektronix, Inc. The term "TekHVC" designates a particular
+ * color space that is the subject of U.S. Patent No. 4,985,853 (equivalent
+ * foreign patents pending). Permission is hereby granted to use, copy,
+ * modify, sell, and otherwise distribute this software and its
+ * documentation for any purpose and without fee, provided that:
+ *
+ * 1. This copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and any modification thereof and in
+ * supporting documentation;
+ * 2. Any color-handling application which displays TekHVC color
+ * cooordinates identifies these as TekHVC color coordinates in any
+ * interface that displays these coordinates and in any associated
+ * documentation;
+ * 3. The term "TekHVC" is always used, and is only used, in association
+ * with the mathematical derivations of the TekHVC Color Space,
+ * including those provided in this file and any equivalent pathways and
+ * mathematical derivations, regardless of digital (e.g., floating point
+ * or integer) representation.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ * NAME
+ * TekHVCGcVC.c
+ *
+ * DESCRIPTION
+ * Source for XcmsTekHVCClipVC() gamut
+ * compression function.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include <math.h>
+#include "Cv.h"
+
+/*
+ * INTERNALS
+ * Internal defines that need NOT be exported to any package or
+ * program using this package.
+ */
+#define MAXBISECTCOUNT 100
+
+
+/************************************************************************
+ * *
+ * PUBLIC ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsTekHVCClipVC - Return the closest value and chroma
+ *
+ * SYNOPSIS
+ */
+/* ARGSUSED */
+Status
+XcmsTekHVCClipVC (
+ XcmsCCC ccc,
+ XcmsColor *pColors_in_out,
+ unsigned int nColors,
+ unsigned int i,
+ Bool *pCompressed)
+/*
+ * DESCRIPTION
+ * This routine will find the closest value and chroma
+ * for a specific hue. The color input is converted to
+ * HVC format and returned as CIE XYZ format.
+ *
+ * Since this routine works with the value within
+ * pColor_in_out intermediate results may be returned
+ * even though it may be invalid.
+ *
+ * RETURNS
+ * XcmsFailure - Failure
+ * XcmsSuccess - Succeeded
+ *
+ */
+{
+ Status retval;
+ XcmsCCCRec myCCC;
+ XcmsColor *pColor;
+ XcmsColor hvc_max;
+ XcmsRGBi rgb_max;
+ int nCount, nMaxCount, nI, nILast;
+ XcmsFloat Chroma, Value, bestChroma, bestValue, nT, saveDist, tmpDist;
+
+ /*
+ * Insure TekHVC installed
+ */
+ if (XcmsAddColorSpace(&XcmsTekHVCColorSpace) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ /* Use my own CCC */
+ memcpy ((char *)&myCCC, (char *)ccc, sizeof(XcmsCCCRec));
+ myCCC.clientWhitePt.format = XcmsUndefinedFormat;/* inherit screen white pt */
+ myCCC.gamutCompProc = (XcmsCompressionProc)NULL;/* no gamut compression func */
+
+ /*
+ * Color specification passed as input can be assumed to:
+ * 1. Be in XcmsCIEXYZFormat
+ * 2. Already be white point adjusted for the Screen White Point.
+ * This means that the white point now associated with this
+ * color spec is the Screen White Point (even if the
+ * ccc->clientWhitePt differs).
+ */
+
+ pColor = pColors_in_out + i;
+
+ if (ccc->visual->class < StaticColor &&
+ FunctionSetOfCCC(ccc) != (XPointer) &XcmsLinearRGBFunctionSet) {
+ /*
+ * GRAY !
+ */
+ _XcmsDIConvertColors(ccc, pColor, &ccc->pPerScrnInfo->screenWhitePt,
+ 1, XcmsTekHVCFormat);
+ pColor->spec.TekHVC.H = pColor->spec.TekHVC.C = 0.0;
+ _XcmsDIConvertColors(ccc, pColor, &ccc->pPerScrnInfo->screenWhitePt,
+ 1, XcmsCIEXYZFormat);
+ if (pCompressed) {
+ *(pCompressed + i) = True;
+ }
+ return(XcmsSuccess);
+ } else {
+ /* Convert from CIEXYZ to TekHVC format */
+ if (_XcmsDIConvertColors(&myCCC, pColor,
+ &myCCC.pPerScrnInfo->screenWhitePt, 1, XcmsTekHVCFormat)
+ == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ if (!_XcmsTekHVC_CheckModify(pColor)) {
+ return (XcmsFailure);
+ }
+
+ /* Step 1: compute the maximum value and chroma for this hue. */
+ /* This copy may be overkill but it preserves the pixel etc. */
+ memcpy((char *)&hvc_max, (char *)pColor, sizeof(XcmsColor));
+ if (_XcmsTekHVCQueryMaxVCRGB (&myCCC, hvc_max.spec.TekHVC.H, &hvc_max,
+ &rgb_max) == XcmsFailure) {
+ return (XcmsFailure);
+ }
+
+ /* Now check and return the appropriate value */
+ if (pColor->spec.TekHVC.V == hvc_max.spec.TekHVC.V) {
+ /* When the value input is equal to the maximum value */
+ /* merely return the chroma for that value. */
+ pColor->spec.TekHVC.C = hvc_max.spec.TekHVC.C;
+ retval = _XcmsDIConvertColors(&myCCC, pColor,
+ &myCCC.pPerScrnInfo->screenWhitePt, 1, XcmsCIEXYZFormat);
+ }
+
+ if (pColor->spec.TekHVC.V < hvc_max.spec.TekHVC.V) {
+ /* return the intersection of the perpindicular line through */
+ /* the value and chroma given and the line from 0,0 and hvc_max. */
+ Chroma = pColor->spec.TekHVC.C;
+ Value = pColor->spec.TekHVC.V;
+ pColor->spec.TekHVC.C =
+ (Value + (hvc_max.spec.TekHVC.C / hvc_max.spec.TekHVC.V * Chroma)) /
+ ((hvc_max.spec.TekHVC.V / hvc_max.spec.TekHVC.C) +
+ (hvc_max.spec.TekHVC.C / hvc_max.spec.TekHVC.V));
+ if (pColor->spec.TekHVC.C >= hvc_max.spec.TekHVC.C) {
+ pColor->spec.TekHVC.C = hvc_max.spec.TekHVC.C;
+ pColor->spec.TekHVC.V = hvc_max.spec.TekHVC.V;
+ } else {
+ pColor->spec.TekHVC.V = pColor->spec.TekHVC.C *
+ hvc_max.spec.TekHVC.V / hvc_max.spec.TekHVC.C;
+ }
+ retval = _XcmsDIConvertColors(&myCCC, pColor,
+ &myCCC.pPerScrnInfo->screenWhitePt, 1, XcmsCIEXYZFormat);
+
+ if (retval != XcmsFailure && pCompressed != NULL) {
+ *(pCompressed + i) = True;
+ }
+ return (retval);
+ }
+
+ /* return the closest point on the upper part of the hue leaf. */
+ /* must do a bisection here to compute the delta e. */
+ nMaxCount = MAXBISECTCOUNT;
+ nI = nMaxCount / 2;
+ bestValue = Value = pColor->spec.TekHVC.V;
+ bestChroma = Chroma = pColor->spec.TekHVC.C;
+ saveDist = (XcmsFloat) XCMS_SQRT ((double) (((Chroma - hvc_max.spec.TekHVC.C) *
+ (Chroma - hvc_max.spec.TekHVC.C)) +
+ ((Value - hvc_max.spec.TekHVC.V) *
+ (Value - hvc_max.spec.TekHVC.V))));
+ for (nCount = 0; nCount < nMaxCount; nCount++) {
+ nT = (XcmsFloat) nI / (XcmsFloat) nMaxCount;
+ pColor->spec.RGBi.red = rgb_max.red * (1.0 - nT) + nT;
+ pColor->spec.RGBi.green = rgb_max.green * (1.0 - nT) + nT;
+ pColor->spec.RGBi.blue = rgb_max.blue * (1.0 - nT) + nT;
+ pColor->format = XcmsRGBiFormat;
+
+ /* Convert from RGBi to HVC */
+ if (_XcmsConvertColorsWithWhitePt(&myCCC, pColor,
+ &myCCC.pPerScrnInfo->screenWhitePt, 1, XcmsTekHVCFormat,
+ (Bool *) NULL)
+ == XcmsFailure) {
+ return (XcmsFailure);
+ }
+ if (!_XcmsTekHVC_CheckModify(pColor)) {
+ return (XcmsFailure);
+ }
+ tmpDist = (XcmsFloat) XCMS_SQRT ((double)
+ (((Chroma - pColor->spec.TekHVC.C) *
+ (Chroma - pColor->spec.TekHVC.C)) +
+ ((Value - pColor->spec.TekHVC.V) *
+ (Value - pColor->spec.TekHVC.V))));
+ nILast = nI;
+ if (tmpDist > saveDist) {
+ nI /= 2;
+ } else {
+ nI = (nMaxCount + nI) / 2;
+ saveDist = tmpDist;
+ bestValue = pColor->spec.TekHVC.V;
+ bestChroma = pColor->spec.TekHVC.C;
+ }
+ if (nI == nILast || nI == 0) {
+ break;
+ }
+
+ }
+
+ if (bestChroma >= hvc_max.spec.TekHVC.C) {
+ pColor->spec.TekHVC.C = hvc_max.spec.TekHVC.C;
+ pColor->spec.TekHVC.V = hvc_max.spec.TekHVC.V;
+ } else {
+ pColor->spec.TekHVC.C = bestChroma;
+ pColor->spec.TekHVC.V = bestValue;
+ }
+ if (!_XcmsTekHVC_CheckModify(pColor)) {
+ return (XcmsFailure);
+ }
+ retval = _XcmsDIConvertColors(&myCCC, pColor,
+ &myCCC.pPerScrnInfo->screenWhitePt, 1, XcmsCIEXYZFormat);
+
+ if (retval != XcmsFailure && pCompressed != NULL) {
+ *(pCompressed + i) = True;
+ }
+ return(retval);
+ }
+}
diff --git a/nx-X11/lib/src/xcms/HVCMnV.c b/nx-X11/lib/src/xcms/HVCMnV.c
new file mode 100644
index 000000000..10a9f857a
--- /dev/null
+++ b/nx-X11/lib/src/xcms/HVCMnV.c
@@ -0,0 +1,163 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. TekColor is a
+ * trademark of Tektronix, Inc. The term "TekHVC" designates a particular
+ * color space that is the subject of U.S. Patent No. 4,985,853 (equivalent
+ * foreign patents pending). Permission is hereby granted to use, copy,
+ * modify, sell, and otherwise distribute this software and its
+ * documentation for any purpose and without fee, provided that:
+ *
+ * 1. This copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and any modification thereof and in
+ * supporting documentation;
+ * 2. Any color-handling application which displays TekHVC color
+ * cooordinates identifies these as TekHVC color coordinates in any
+ * interface that displays these coordinates and in any associated
+ * documentation;
+ * 3. The term "TekHVC" is always used, and is only used, in association
+ * with the mathematical derivations of the TekHVC Color Space,
+ * including those provided in this file and any equivalent pathways and
+ * mathematical derivations, regardless of digital (e.g., floating point
+ * or integer) representation.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ * NAME
+ * TekHVCMnV.c
+ *
+ * DESCRIPTION
+ * Source for XcmsTekHVCQueryMinV gamut boundary querying routine.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+/*
+ * DEFINES
+ */
+#define EPS 0.001
+
+
+/************************************************************************
+ * *
+ * PUBLIC ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsTekHVCQueryMinV - Compute minimum value for hue and chroma
+ *
+ * SYNOPSIS
+ */
+Status
+XcmsTekHVCQueryMinV (
+ XcmsCCC ccc,
+ XcmsFloat hue,
+ XcmsFloat chroma,
+ XcmsColor *pColor_return)
+
+/*
+ * DESCRIPTION
+ * Return the minimum value for a specific hue, and the
+ * corresponding chroma. The input color specification
+ * may be in any format, however output is in XcmsTekHVCFormat.
+ *
+ * Since this routine works with the value within
+ * pColor_return intermediate results may be returned
+ * even though it may be invalid.
+ *
+ * ASSUMPTIONS
+ * This routine assumes that the white point associated with
+ * the color specification is the Screen White Point. The
+ * Screen White Point will also be associated with the
+ * returned color specification.
+ *
+ * RETURNS
+ * XcmsFailure - Failure
+ * XcmsSuccess - Succeeded with no modifications
+ *
+ */
+{
+ XcmsCCCRec myCCC;
+ XcmsColor tmp;
+ XcmsColor max_vc;
+
+ /*
+ * Check Arguments
+ */
+ if (ccc == NULL || pColor_return == NULL) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Insure TekHVC installed
+ */
+ if (XcmsAddColorSpace(&XcmsTekHVCColorSpace) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ /* Use my own CCC */
+ memcpy ((char *)&myCCC, (char *)ccc, sizeof(XcmsCCCRec));
+ myCCC.clientWhitePt.format = XcmsUndefinedFormat;/* inherit screen white pt */
+ myCCC.gamutCompProc = (XcmsCompressionProc)NULL;/* no gamut comp func */
+
+ tmp.spec.TekHVC.H = hue;
+ tmp.spec.TekHVC.V = 100.0;
+ tmp.spec.TekHVC.C = chroma;
+ tmp.pixel = pColor_return->pixel;
+ tmp.format = XcmsTekHVCFormat;
+
+
+ /* Check for a valid HVC */
+ if (!_XcmsTekHVC_CheckModify (&tmp)) {
+ return(XcmsFailure);
+ }
+
+ /* Step 1: compute the maximum value and chroma for this hue. */
+ /* This copy may be overkill but it preserves the pixel etc. */
+ memcpy((char *)&max_vc, (char *)&tmp, sizeof(XcmsColor));
+ if (_XcmsTekHVCQueryMaxVCRGB (&myCCC, max_vc.spec.TekHVC.H, &max_vc,
+ (XcmsRGBi *)NULL) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ /* Step 2: find the intersection with the maximum hvc and chroma line. */
+ if (tmp.spec.TekHVC.C > max_vc.spec.TekHVC.C + EPS) {
+ /* If the chroma is to large then return maximum hvc. */
+ tmp.spec.TekHVC.C = max_vc.spec.TekHVC.C;
+ tmp.spec.TekHVC.V = max_vc.spec.TekHVC.V;
+ } else {
+ tmp.spec.TekHVC.V = tmp.spec.TekHVC.C *
+ max_vc.spec.TekHVC.V / max_vc.spec.TekHVC.C;
+ if (tmp.spec.TekHVC.V > max_vc.spec.TekHVC.V) {
+ tmp.spec.TekHVC.V = max_vc.spec.TekHVC.V;
+ } else if (tmp.spec.TekHVC.V < 0.0) {
+ tmp.spec.TekHVC.V = tmp.spec.TekHVC.C = 0.0;
+ }
+ }
+ if (_XcmsTekHVC_CheckModify (&tmp)) {
+ memcpy ((char *) pColor_return, (char *) &tmp, sizeof (XcmsColor));
+ return(XcmsSuccess);
+ } else {
+ return(XcmsFailure);
+ }
+}
diff --git a/nx-X11/lib/src/xcms/HVCMxC.c b/nx-X11/lib/src/xcms/HVCMxC.c
new file mode 100644
index 000000000..074844ccc
--- /dev/null
+++ b/nx-X11/lib/src/xcms/HVCMxC.c
@@ -0,0 +1,243 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. TekColor is a
+ * trademark of Tektronix, Inc. The term "TekHVC" designates a particular
+ * color space that is the subject of U.S. Patent No. 4,985,853 (equivalent
+ * foreign patents pending). Permission is hereby granted to use, copy,
+ * modify, sell, and otherwise distribute this software and its
+ * documentation for any purpose and without fee, provided that:
+ *
+ * 1. This copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and any modification thereof and in
+ * supporting documentation;
+ * 2. Any color-handling application which displays TekHVC color
+ * cooordinates identifies these as TekHVC color coordinates in any
+ * interface that displays these coordinates and in any associated
+ * documentation;
+ * 3. The term "TekHVC" is always used, and is only used, in association
+ * with the mathematical derivations of the TekHVC Color Space,
+ * including those provided in this file and any equivalent pathways and
+ * mathematical derivations, regardless of digital (e.g., floating point
+ * or integer) representation.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ * NAME
+ * TekHVCMxC.c
+ *
+ * DESCRIPTION
+ * Source for the XcmsTekHVCQueryMaxC() gamut boudary
+ * querying routine.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include <math.h>
+#include "Cv.h"
+
+/*
+ * DEFINES
+ */
+#define MAXBISECTCOUNT 100
+#define EPS 0.001
+
+
+/************************************************************************
+ * *
+ * PUBLIC ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsTekHVCQueryMaxC - Compute the maximum chroma for a hue and value
+ *
+ * SYNOPSIS
+ */
+Status
+XcmsTekHVCQueryMaxC(
+ XcmsCCC ccc,
+ XcmsFloat hue,
+ XcmsFloat value,
+ XcmsColor *pColor_return)
+/*
+ * DESCRIPTION
+ * Return the maximum chroma for a specific hue and value.
+ * The returned format is in XcmsTekHVCFormat.
+ *
+ *
+ * ASSUMPTIONS
+ * This routine assumes that the white point associated with
+ * the color specification is the Screen White Point. The
+ * Screen White Point will also be associated with the
+ * returned color specification.
+ *
+ * RETURNS
+ * XcmsFailure - Failure
+ * XcmsSuccess - Succeeded
+ *
+ */
+{
+ XcmsCCCRec myCCC;
+ XcmsColor tmp;
+ XcmsColor max_vc;
+ XcmsRGBi rgb_saved;
+ int nCount, nMaxCount;
+ XcmsFloat nValue, savedValue, lastValue, lastChroma, prevValue;
+ XcmsFloat maxDist, nT, rFactor;
+ XcmsFloat ftmp1, ftmp2;
+
+ /*
+ * Check Arguments
+ */
+ if (ccc == NULL || pColor_return == NULL) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Insure TekHVC installed
+ */
+ if (XcmsAddColorSpace(&XcmsTekHVCColorSpace) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ /* Use my own CCC */
+ memcpy ((char *)&myCCC, (char *)ccc, sizeof(XcmsCCCRec));
+ myCCC.clientWhitePt.format = XcmsUndefinedFormat; /* inherit screen white Pt */
+ myCCC.gamutCompProc = (XcmsCompressionProc)NULL;/* no gamut comp func */
+
+ tmp.spec.TekHVC.H = hue;
+ tmp.spec.TekHVC.V = value;
+ tmp.spec.TekHVC.C = 100.0;
+ tmp.pixel = pColor_return->pixel;
+ tmp.format = XcmsTekHVCFormat;
+
+ /* check to make sure we have a valid TekHVC number */
+ if (!_XcmsTekHVC_CheckModify(&tmp)) {
+ return(XcmsFailure);
+ }
+
+ /* Step 1: compute the maximum value and chroma for this hue. */
+ memcpy((char *)&max_vc, (char *)&tmp, sizeof(XcmsColor));
+ if (_XcmsTekHVCQueryMaxVCRGB(&myCCC, hue, &max_vc, &rgb_saved)
+ == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ /* Step 2: If the value is less than the value for the maximum */
+ /* value, chroma point then the chroma is on the line */
+ /* from max_vc to 0,0. */
+ if (value <= max_vc.spec.TekHVC.V) {
+ tmp.spec.TekHVC.C = value
+ * max_vc.spec.TekHVC.C / max_vc.spec.TekHVC.V;
+ if (_XcmsTekHVC_CheckModify (&tmp)) {
+ memcpy((char *)pColor_return, (char *)&tmp, sizeof(XcmsColor));
+ return(XcmsSuccess);
+ } else {
+ return(XcmsFailure);
+ }
+ } else {
+ /* must do a bisection here to compute the maximum chroma */
+ /* save the structure input so that any elements that */
+ /* are not touched are recopied later in the routine. */
+ nValue = savedValue = value;
+ lastChroma = -1.0;
+ lastValue = -1.0;
+ nMaxCount = MAXBISECTCOUNT;
+ maxDist = 100.0 - max_vc.spec.TekHVC.V;
+ rFactor = 1.0;
+
+ for (nCount = 0; nCount < nMaxCount; nCount++) {
+ prevValue = lastValue;
+ lastValue = tmp.spec.TekHVC.V;
+ lastChroma = tmp.spec.TekHVC.C;
+ nT = (nValue - max_vc.spec.TekHVC.V) / maxDist * rFactor;
+ tmp.spec.RGBi.red = rgb_saved.red * (1.0 - nT) + nT;
+ tmp.spec.RGBi.green = rgb_saved.green * (1.0 - nT) + nT;
+ tmp.spec.RGBi.blue = rgb_saved.blue * (1.0 - nT) + nT;
+ tmp.format = XcmsRGBiFormat;
+
+ /* convert from RGB to HVC */
+ if (_XcmsConvertColorsWithWhitePt(&myCCC, &tmp,
+ &myCCC.pPerScrnInfo->screenWhitePt, 1, XcmsTekHVCFormat,
+ (Bool *) NULL) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ /* Now check the return against what is expected */
+ if (tmp.spec.TekHVC.V <= savedValue + EPS &&
+ tmp.spec.TekHVC.V >= savedValue - EPS) {
+ /* make sure to return the input hue */
+ tmp.spec.TekHVC.H = hue;
+ if (_XcmsTekHVC_CheckModify (&tmp)) {
+ memcpy((char *)pColor_return, (char *)&tmp, sizeof(XcmsColor));
+ return(XcmsSuccess);
+ } else {
+ return(XcmsFailure);
+ }
+ }
+ nValue += savedValue - tmp.spec.TekHVC.V;
+ if (nValue < max_vc.spec.TekHVC.V) {
+ nValue = max_vc.spec.TekHVC.V;
+ rFactor *= 0.5; /* selective relaxation employed */
+ } else if (nValue > 100.0) {
+ /* make sure to return the input hue */
+ tmp.spec.TekHVC.H = hue;
+ /* avoid using fabs */
+ ftmp1 = lastValue - savedValue;
+ if (ftmp1 < 0.0)
+ ftmp1 = -ftmp1;
+ ftmp2 = tmp.spec.TekHVC.V - savedValue;
+ if (ftmp2 < 0.0)
+ ftmp2 = -ftmp2;
+ if (ftmp1 < ftmp2) {
+ tmp.spec.TekHVC.V = lastValue;
+ tmp.spec.TekHVC.C = lastChroma;
+ }
+ if (_XcmsTekHVC_CheckModify (&tmp)) {
+ memcpy((char *)pColor_return, (char *)&tmp, sizeof(XcmsColor));
+ return(XcmsSuccess);
+ } else {
+ return(XcmsFailure);
+ }
+ } else if (tmp.spec.TekHVC.V <= prevValue + EPS &&
+ tmp.spec.TekHVC.V >= prevValue - EPS) {
+ rFactor *= 0.5; /* selective relaxation employed */
+ }
+ }
+ if (nCount >= nMaxCount) {
+ /* avoid using fabs */
+ ftmp1 = lastValue - savedValue;
+ if (ftmp1 < 0.0)
+ ftmp1 = -ftmp1;
+ ftmp2 = tmp.spec.TekHVC.V - savedValue;
+ if (ftmp2 < 0.0)
+ ftmp2 = -ftmp2;
+ if (ftmp1 < ftmp2) {
+ tmp.spec.TekHVC.V = lastValue;
+ tmp.spec.TekHVC.C = lastChroma;
+ }
+ }
+ }
+ /* make sure to return the input hue */
+ tmp.spec.TekHVC.H = hue;
+ memcpy((char *)pColor_return, (char *)&tmp, sizeof(XcmsColor));
+ return(XcmsSuccess);
+}
diff --git a/nx-X11/lib/src/xcms/HVCMxV.c b/nx-X11/lib/src/xcms/HVCMxV.c
new file mode 100644
index 000000000..d5ef94ec5
--- /dev/null
+++ b/nx-X11/lib/src/xcms/HVCMxV.c
@@ -0,0 +1,247 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. TekColor is a
+ * trademark of Tektronix, Inc. The term "TekHVC" designates a particular
+ * color space that is the subject of U.S. Patent No. 4,985,853 (equivalent
+ * foreign patents pending). Permission is hereby granted to use, copy,
+ * modify, sell, and otherwise distribute this software and its
+ * documentation for any purpose and without fee, provided that:
+ *
+ * 1. This copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and any modification thereof and in
+ * supporting documentation;
+ * 2. Any color-handling application which displays TekHVC color
+ * cooordinates identifies these as TekHVC color coordinates in any
+ * interface that displays these coordinates and in any associated
+ * documentation;
+ * 3. The term "TekHVC" is always used, and is only used, in association
+ * with the mathematical derivations of the TekHVC Color Space,
+ * including those provided in this file and any equivalent pathways and
+ * mathematical derivations, regardless of digital (e.g., floating point
+ * or integer) representation.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ * NAME
+ * TekHVCMxV.c
+ *
+ * DESCRIPTION
+ * Source for the XcmsTekHVCQueryMaxV() gamut boundary
+ * querying routine.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include <math.h>
+#include "Cv.h"
+
+/*
+ * DEFINES
+ */
+#define MAXBISECTCOUNT 100
+#define EPS 0.001
+
+
+/************************************************************************
+ * *
+ * PUBLIC ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsTekHVCQueryMaxV - Compute maximum value for a hue and chroma
+ *
+ * SYNOPSIS
+ */
+Status
+XcmsTekHVCQueryMaxV(
+ XcmsCCC ccc,
+ XcmsFloat hue,
+ XcmsFloat chroma,
+ XcmsColor *pColor_return)
+/*
+ * DESCRIPTION
+ * Return the maximum value for a specified hue and chroma.
+ *
+ * ASSUMPTIONS
+ * This routine assumes that the white point associated with
+ * the color specification is the Screen White Point. The
+ * Screen White Point will also be associated with the
+ * returned color specification.
+ *
+ * RETURNS
+ * XcmsFailure - Failure
+ * XcmsSuccess - Succeeded with no modifications
+ *
+ */
+{
+ XcmsCCCRec myCCC;
+ XcmsColor tmp;
+ XcmsColor max_vc;
+ XcmsRGBi rgb_saved;
+ int nCount, nMaxCount;
+ XcmsFloat nT, nChroma, savedChroma, lastValue, lastChroma, prevChroma;
+ XcmsFloat rFactor;
+ XcmsFloat ftmp1, ftmp2;
+
+ /*
+ * Check Arguments
+ */
+ if (ccc == NULL || pColor_return == NULL) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Insure TekHVC installed
+ */
+ if (XcmsAddColorSpace(&XcmsTekHVCColorSpace) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ /* setup the CCC to use for the conversions. */
+ memcpy ((char *) &myCCC, (char *) ccc, sizeof(XcmsCCCRec));
+ myCCC.clientWhitePt.format = XcmsUndefinedFormat;
+ myCCC.gamutCompProc = (XcmsCompressionProc) NULL;
+
+ tmp.spec.TekHVC.H = hue;
+ tmp.spec.TekHVC.V = 0.0;
+ tmp.spec.TekHVC.C = chroma;
+ tmp.pixel = pColor_return->pixel;
+ tmp.format = XcmsTekHVCFormat;
+
+ if (!_XcmsTekHVC_CheckModify (&tmp)) {
+ return(XcmsFailure);
+ }
+
+ /* Step 1: compute the maximum value and chroma for this hue. */
+ /* This copy may be overkill but it preserves the pixel etc. */
+ memcpy((char *)&max_vc, (char *)&tmp, sizeof(XcmsColor));
+ hue = max_vc.spec.TekHVC.H;
+ if (_XcmsTekHVCQueryMaxVCRGB(&myCCC, max_vc.spec.TekHVC.H, &max_vc, &rgb_saved)
+ == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ if (max_vc.spec.TekHVC.C < tmp.spec.TekHVC.C) {
+ /*
+ * If the chroma is greater than the chroma for the
+ * maximum value/chroma point then the value is the
+ * the value for the maximum value, chroma point.
+ * This is an error but it I return the best approximation I can.
+ * Thus the inconsistency.
+ */
+ tmp.spec.TekHVC.C = max_vc.spec.TekHVC.C;
+ tmp.spec.TekHVC.V = max_vc.spec.TekHVC.V;
+ memcpy ((char *) pColor_return, (char *) &tmp, sizeof (XcmsColor));
+ return(XcmsSuccess);
+ } else if (max_vc.spec.TekHVC.C == tmp.spec.TekHVC.C) {
+ /*
+ * If the chroma is equal to the chroma for the
+ * maximum value/chroma point then the value is the
+ * the value for the maximum value, chroma point.
+ */
+ tmp.spec.TekHVC.V = max_vc.spec.TekHVC.V;
+ memcpy ((char *) pColor_return, (char *) &tmp, sizeof (XcmsColor));
+ return(XcmsSuccess);
+ } else {
+ /* must do a bisection here to compute the maximum value */
+ /* save the structure input so that any elements that */
+ /* are not touched are recopied later in the routine. */
+ nChroma = savedChroma = tmp.spec.TekHVC.C;
+ tmp.spec.TekHVC.C = max_vc.spec.TekHVC.C;
+ tmp.spec.TekHVC.V = max_vc.spec.TekHVC.V;
+ lastChroma = -1.0;
+ lastValue = -1.0;
+ nMaxCount = MAXBISECTCOUNT;
+ rFactor = 1.0;
+
+ for (nCount = 0; nCount < nMaxCount; nCount++) {
+ prevChroma = lastChroma;
+ lastValue = tmp.spec.TekHVC.V;
+ lastChroma = tmp.spec.TekHVC.C;
+ nT = (1.0 - (nChroma / max_vc.spec.TekHVC.C)) * rFactor;
+ tmp.spec.RGBi.red = rgb_saved.red * (1.0 - nT) + nT;
+ tmp.spec.RGBi.green = rgb_saved.green * (1.0 - nT) + nT;
+ tmp.spec.RGBi.blue = rgb_saved.blue * (1.0 - nT) + nT;
+ tmp.format = XcmsRGBiFormat;
+
+ /* convert from RGB to HVC */
+ if (_XcmsConvertColorsWithWhitePt(&myCCC, &tmp,
+ &myCCC.pPerScrnInfo->screenWhitePt, 1, XcmsTekHVCFormat,
+ (Bool *) NULL) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ /* Now check the return against what is expected */
+ if (tmp.spec.TekHVC.C <= savedChroma + EPS &&
+ tmp.spec.TekHVC.C >= savedChroma - EPS) {
+ tmp.spec.TekHVC.H = hue; /* use the saved hue */
+ memcpy ((char *) pColor_return, (char *) &tmp, sizeof (XcmsColor));
+ return(XcmsSuccess);
+ }
+ nChroma += savedChroma - tmp.spec.TekHVC.C;
+ if (nChroma > max_vc.spec.TekHVC.C) {
+ nChroma = max_vc.spec.TekHVC.C;
+ rFactor *= 0.5; /* selective relaxation employed */
+ } else if (nChroma < 0.0) {
+ /* avoid using fabs */
+ ftmp1 = lastChroma - savedChroma;
+ if (ftmp1 < 0.0)
+ ftmp1 = -ftmp1;
+ ftmp2 = tmp.spec.TekHVC.C - savedChroma;
+ if (ftmp2 < 0.0)
+ ftmp2 = -ftmp2;
+ if (ftmp1 < ftmp2) {
+ tmp.spec.TekHVC.V = lastValue;
+ tmp.spec.TekHVC.C = lastChroma;
+ }
+ /* make sure to return the input hue */
+ tmp.spec.TekHVC.H = hue;
+ if (!_XcmsTekHVC_CheckModify(&tmp)) {
+ return(XcmsFailure);
+ }
+ memcpy ((char *) pColor_return, (char *) &tmp, sizeof (XcmsColor));
+ return(XcmsSuccess);
+ } else if (tmp.spec.TekHVC.C <= prevChroma + EPS &&
+ tmp.spec.TekHVC.C >= prevChroma - EPS) {
+ rFactor *= 0.5; /* selective relaxation employed */
+ }
+ }
+ if (nCount >= nMaxCount) {
+ /* avoid using fabs */
+ ftmp1 = lastChroma - savedChroma;
+ if (ftmp1 < 0.0)
+ ftmp1 = -ftmp1;
+ ftmp2 = tmp.spec.TekHVC.C - savedChroma;
+ if (ftmp2 < 0.0)
+ ftmp2 = -ftmp2;
+ if (ftmp1 < ftmp2) {
+ tmp.spec.TekHVC.V = lastValue;
+ tmp.spec.TekHVC.C = lastChroma;
+ }
+ }
+ }
+
+ /* make sure to return the input hue */
+ tmp.spec.TekHVC.H = hue;
+ memcpy ((char *) pColor_return, (char *) &tmp, sizeof (XcmsColor));
+ return(XcmsSuccess);
+}
diff --git a/nx-X11/lib/src/xcms/HVCMxVC.c b/nx-X11/lib/src/xcms/HVCMxVC.c
new file mode 100644
index 000000000..c7e087866
--- /dev/null
+++ b/nx-X11/lib/src/xcms/HVCMxVC.c
@@ -0,0 +1,235 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. TekColor is a
+ * trademark of Tektronix, Inc. The term "TekHVC" designates a particular
+ * color space that is the subject of U.S. Patent No. 4,985,853 (equivalent
+ * foreign patents pending). Permission is hereby granted to use, copy,
+ * modify, sell, and otherwise distribute this software and its
+ * documentation for any purpose and without fee, provided that:
+ *
+ * 1. This copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and any modification thereof and in
+ * supporting documentation;
+ * 2. Any color-handling application which displays TekHVC color
+ * cooordinates identifies these as TekHVC color coordinates in any
+ * interface that displays these coordinates and in any associated
+ * documentation;
+ * 3. The term "TekHVC" is always used, and is only used, in association
+ * with the mathematical derivations of the TekHVC Color Space,
+ * including those provided in this file and any equivalent pathways and
+ * mathematical derivations, regardless of digital (e.g., floating point
+ * or integer) representation.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ * NAME
+ * TekHVCMxVC.c
+ *
+ * DESCRIPTION
+ * Source for the XcmsTekHVCQueryMaxVC() gamut boundary
+ * querying routine.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+/*
+ * DEFINES
+ */
+#define MIN(x,y) ((x) > (y) ? (y) : (x))
+#define MIN3(x,y,z) ((x) > (MIN((y), (z))) ? (MIN((y), (z))) : (x))
+#define MAX(x,y) ((x) > (y) ? (x) : (y))
+#define MAX3(x,y,z) ((x) > (MAX((y), (z))) ? (x) : (MAX((y), (z))))
+#define START_V 40.0
+#define START_C 120.0
+
+
+/************************************************************************
+ * *
+ * API PRIVATE ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * _XcmsTekHVCQueryMaxVCRGB - Compute maximum value/chroma.
+ *
+ * SYNOPSIS
+ */
+Status
+_XcmsTekHVCQueryMaxVCRGB(
+ XcmsCCC ccc,
+ XcmsFloat hue,
+ XcmsColor *pColor_return,
+ XcmsRGBi *pRGB_return)
+
+/*
+ * DESCRIPTION
+ * Return the maximum chroma for a specified hue, and the
+ * corresponding value. This is computed by a binary search of
+ * all possible chromas. An assumption is made that there are
+ * no local maxima. Use the unrounded Max Chroma because
+ * the difference check can be small.
+ *
+ * NOTE: No local CCC is used because this is a private
+ * routine and all routines that call it are expected
+ * to behave properly, i.e. send a local CCC with
+ * no white adjust function and no gamut compression
+ * function.
+ *
+ * This routine only accepts hue as input and outputs
+ * HVC's and RGBi's.
+ *
+ * RETURNS
+ * XcmsFailure - Failure
+ * XCMS_SUCCUSS - Succeeded
+ *
+ */
+{
+ XcmsFloat nSmall, nLarge;
+ XcmsColor tmp;
+
+ tmp.format = XcmsTekHVCFormat;
+ tmp.spec.TekHVC.H = hue;
+ /* Use some unreachable color on the given hue */
+ tmp.spec.TekHVC.V = START_V;
+ tmp.spec.TekHVC.C = START_C;
+
+
+ /*
+ * Convert from HVC to RGB
+ *
+ * Note that the CIEXYZ to RGBi conversion routine must stuff the
+ * out of bounds RGBi values in tmp when the ccc->gamutCompProc
+ * is NULL.
+ */
+ if ((_XcmsConvertColorsWithWhitePt(ccc, &tmp,
+ &ccc->pPerScrnInfo->screenWhitePt, 1, XcmsRGBiFormat, (Bool *) NULL)
+ == XcmsFailure) && tmp.format != XcmsRGBiFormat) {
+ return (XcmsFailure);
+ }
+
+ /* Now pick the smallest RGB */
+ nSmall = MIN3(tmp.spec.RGBi.red,
+ tmp.spec.RGBi.green,
+ tmp.spec.RGBi.blue);
+ /* Make the smallest RGB equal to zero */
+ tmp.spec.RGBi.red -= nSmall;
+ tmp.spec.RGBi.green -= nSmall;
+ tmp.spec.RGBi.blue -= nSmall;
+
+ /* Now pick the largest RGB */
+ nLarge = MAX3(tmp.spec.RGBi.red,
+ tmp.spec.RGBi.green,
+ tmp.spec.RGBi.blue);
+ /* Scale the RGB values based on the largest one */
+ tmp.spec.RGBi.red /= nLarge;
+ tmp.spec.RGBi.green /= nLarge;
+ tmp.spec.RGBi.blue /= nLarge;
+ tmp.format = XcmsRGBiFormat;
+
+ /* If the calling routine wants RGB value give them the ones used. */
+ if (pRGB_return) {
+ pRGB_return->red = tmp.spec.RGBi.red;
+ pRGB_return->green = tmp.spec.RGBi.green;
+ pRGB_return->blue = tmp.spec.RGBi.blue;
+ }
+
+ /* Convert from RGBi to HVC */
+ if (_XcmsConvertColorsWithWhitePt(ccc, &tmp,
+ &ccc->pPerScrnInfo->screenWhitePt, 1, XcmsTekHVCFormat, (Bool *) NULL)
+ == XcmsFailure) {
+ return (XcmsFailure);
+ }
+
+ /* make sure to return the input hue */
+ tmp.spec.TekHVC.H = hue;
+ memcpy((char *)pColor_return, (char *)&tmp, sizeof(XcmsColor));
+ return (XcmsSuccess);
+}
+
+
+/************************************************************************
+ * *
+ * PUBLIC ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsTekHVCQueryMaxVC - Compute maximum value and chroma.
+ *
+ * SYNOPSIS
+ */
+Status
+XcmsTekHVCQueryMaxVC (
+ XcmsCCC ccc,
+ XcmsFloat hue,
+ XcmsColor *pColor_return)
+
+/*
+ * DESCRIPTION
+ * Return the maximum chroma for the specified hue, and the
+ * corresponding value.
+ *
+ * ASSUMPTIONS
+ * This routine assumes that the white point associated with
+ * the color specification is the Screen White Point. The
+ * Screen White Point will also be associated with the
+ * returned color specification.
+ *
+ * RETURNS
+ * XcmsFailure - Failure
+ * XcmsSuccess - Succeeded
+ *
+ */
+{
+ XcmsCCCRec myCCC;
+
+ /*
+ * Check Arguments
+ */
+ if (ccc == NULL || pColor_return == NULL) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Insure TekHVC installed
+ */
+ if (XcmsAddColorSpace(&XcmsTekHVCColorSpace) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ /* Use my own CCC */
+ memcpy ((char *)&myCCC, (char *)ccc, sizeof(XcmsCCCRec));
+ myCCC.clientWhitePt.format = XcmsUndefinedFormat;
+ myCCC.gamutCompProc = (XcmsCompressionProc)NULL;
+
+ while (hue < 0.0) {
+ hue += 360.0;
+ }
+ while (hue >= 360.0) {
+ hue -= 360.0;
+ }
+
+ return(_XcmsTekHVCQueryMaxVCRGB (&myCCC, hue, pColor_return,
+ (XcmsRGBi *)NULL));
+}
diff --git a/nx-X11/lib/src/xcms/HVCMxVs.c b/nx-X11/lib/src/xcms/HVCMxVs.c
new file mode 100644
index 000000000..540e5c2f4
--- /dev/null
+++ b/nx-X11/lib/src/xcms/HVCMxVs.c
@@ -0,0 +1,161 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. TekColor is a
+ * trademark of Tektronix, Inc. The term "TekHVC" designates a particular
+ * color space that is the subject of U.S. Patent No. 4,985,853 (equivalent
+ * foreign patents pending). Permission is hereby granted to use, copy,
+ * modify, sell, and otherwise distribute this software and its
+ * documentation for any purpose and without fee, provided that:
+ *
+ * 1. This copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and any modification thereof and in
+ * supporting documentation;
+ * 2. Any color-handling application which displays TekHVC color
+ * cooordinates identifies these as TekHVC color coordinates in any
+ * interface that displays these coordinates and in any associated
+ * documentation;
+ * 3. The term "TekHVC" is always used, and is only used, in association
+ * with the mathematical derivations of the TekHVC Color Space,
+ * including those provided in this file and any equivalent pathways and
+ * mathematical derivations, regardless of digital (e.g., floating point
+ * or integer) representation.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ * NAME
+ * TekHVCMxVs.c
+ *
+ * DESCRIPTION
+ * Source for the XcmsTekHVCQueryMaxVSamples() gamut boundary
+ * querying routine.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+
+/************************************************************************
+ * *
+ * PUBLIC ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsTekHVCQueryMaxVSamples - Compute a set of value/chroma
+ * pairs.
+ *
+ * SYNOPSIS
+ */
+Status
+XcmsTekHVCQueryMaxVSamples(
+ XcmsCCC ccc,
+ XcmsFloat hue,
+ XcmsColor *pColor_in_out,
+ unsigned int nSamples)
+
+/*
+ * DESCRIPTION
+ * Return a set of values and chromas for the input Hue.
+ * This routine will take any color as input.
+ * It returns TekHVC colors.
+ *
+ * Since this routine works with the value within
+ * pColor_in_out intermediate results may be returned
+ * even though it may be invalid.
+ *
+ * ASSUMPTIONS
+ * This routine assumes that the white point associated with
+ * the color specification is the Screen White Point. The
+ * Screen White Point will also be associated with the
+ * returned color specification.
+ *
+ * RETURNS
+ * XcmsFailure - Failure
+ * XcmsSuccess - Succeeded
+ *
+ */
+{
+ XcmsCCCRec myCCC;
+ XcmsColor *pHVC;
+ XcmsRGBi rgb_saved;
+ unsigned short nI;
+ XcmsFloat nT;
+
+ /*
+ * Check Arguments
+ */
+ if (ccc == NULL || pColor_in_out == NULL || nSamples == 0) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Insure TekHVC installed
+ */
+ if (XcmsAddColorSpace(&XcmsTekHVCColorSpace) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ /* setup the CCC to use for the conversions. */
+ memcpy ((char *) &myCCC, (char *) ccc, sizeof(XcmsCCCRec));
+ myCCC.clientWhitePt.format = XcmsUndefinedFormat;
+ myCCC.gamutCompProc = (XcmsCompressionProc) NULL;
+
+ /* Step 1: compute the maximum value and chroma for this hue. */
+
+
+ /* save the Hue for use later. */
+ while (hue < 0.0) {
+ hue += 360.0;
+ }
+ while (hue > 360.0) {
+ hue -= 360.0;
+ }
+ pColor_in_out->spec.TekHVC.H = hue;
+ pColor_in_out->format = XcmsTekHVCFormat;
+
+ /* Get the maximum value and chroma point for this hue */
+ if (_XcmsTekHVCQueryMaxVCRGB(&myCCC, pColor_in_out->spec.TekHVC.H,
+ pColor_in_out, (XcmsRGBi *)&rgb_saved) == XcmsFailure) {
+ return (XcmsFailure);
+ }
+
+ /* Step 2: Convert each of the RGBi's to HVC's */
+ pHVC = pColor_in_out;
+ for (nI = 0; nI < nSamples; nI++, pHVC++) {
+ nT = (XcmsFloat) nI / (XcmsFloat) nSamples;
+ pHVC->spec.RGBi.red = rgb_saved.red * (1.0 - nT) + nT;
+ pHVC->spec.RGBi.green = rgb_saved.green * (1.0 - nT) + nT;
+ pHVC->spec.RGBi.blue = rgb_saved.blue * (1.0 - nT) + nT;
+ pHVC->format = XcmsRGBiFormat;
+ pHVC->pixel = pColor_in_out->pixel;
+ /* convert from RGB to HVC */
+ if (_XcmsConvertColorsWithWhitePt(&myCCC, pHVC,
+ &myCCC.pPerScrnInfo->screenWhitePt, 1, XcmsTekHVCFormat,
+ (Bool *) NULL) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ /* make sure to return the input hue */
+ pHVC->spec.TekHVC.H = hue;
+ }
+
+ return(XcmsSuccess);
+}
diff --git a/nx-X11/lib/src/xcms/HVCWpAj.c b/nx-X11/lib/src/xcms/HVCWpAj.c
new file mode 100644
index 000000000..dcefe7535
--- /dev/null
+++ b/nx-X11/lib/src/xcms/HVCWpAj.c
@@ -0,0 +1,114 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. TekColor is a
+ * trademark of Tektronix, Inc. The term "TekHVC" designates a particular
+ * color space that is the subject of U.S. Patent No. 4,985,853 (equivalent
+ * foreign patents pending). Permission is hereby granted to use, copy,
+ * modify, sell, and otherwise distribute this software and its
+ * documentation for any purpose and without fee, provided that:
+ *
+ * 1. This copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and any modification thereof and in
+ * supporting documentation;
+ * 2. Any color-handling application which displays TekHVC color
+ * cooordinates identifies these as TekHVC color coordinates in any
+ * interface that displays these coordinates and in any associated
+ * documentation;
+ * 3. The term "TekHVC" is always used, and is only used, in association
+ * with the mathematical derivations of the TekHVC Color Space,
+ * including those provided in this file and any equivalent pathways and
+ * mathematical derivations, regardless of digital (e.g., floating point
+ * or integer) representation.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ * DESCRIPTION
+ * TekHVCWpAj.c
+ *
+ * DESCRIPTION
+ * This file contains routine(s) that support white point
+ * adjustment of color specifications in the TekHVC color
+ * space.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+
+/************************************************************************
+ * *
+ * PUBLIC ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsTekHVCWhiteShiftColors
+ *
+ * SYNOPSIS
+ */
+Status
+XcmsTekHVCWhiteShiftColors(
+ XcmsCCC ccc,
+ XcmsColor *pWhitePtFrom,
+ XcmsColor *pWhitePtTo,
+ XcmsColorFormat destSpecFmt,
+ XcmsColor *pColors_in_out,
+ unsigned int nColors,
+ Bool *pCompressed)
+/*
+ * DESCRIPTION
+ * Convert color specifications in an array of XcmsColor structures
+ * for differences in white points.
+ *
+ * RETURNS
+ * XcmsFailure if failed,
+ * XcmsSuccess if succeeded without gamut compression,
+ * XcmsSuccessWithCompression if succeeded with
+ * gamut compression.
+ */
+{
+ if (pWhitePtFrom == NULL || pWhitePtTo == NULL || pColors_in_out == NULL) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Insure TekHVC installed
+ */
+ if (XcmsAddColorSpace(&XcmsTekHVCColorSpace) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Convert to TekHVC using pWhitePtFrom
+ * We can ignore return value for compression because we are converting
+ * to XcmsTekHVCFormat which is device-independent, not device-dependent.
+ */
+ if (_XcmsConvertColorsWithWhitePt(ccc, pColors_in_out, pWhitePtFrom,
+ nColors, XcmsTekHVCFormat, pCompressed) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Convert from TekHVC to destSpecFmt using pWhitePtTo
+ */
+ return(_XcmsConvertColorsWithWhitePt(ccc, pColors_in_out, pWhitePtTo,
+ nColors, destSpecFmt, pCompressed));
+}
diff --git a/nx-X11/lib/src/xcms/IdOfPr.c b/nx-X11/lib/src/xcms/IdOfPr.c
new file mode 100644
index 000000000..9f43dd387
--- /dev/null
+++ b/nx-X11/lib/src/xcms/IdOfPr.c
@@ -0,0 +1,106 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ * NAME
+ * XcmsIdOfPr.c
+ *
+ * DESCRIPTION
+ * Source for XcmsFormatOfPrefix()
+ *
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+
+/*
+ * NAME
+ * XcmsFormatOfPrefix
+ *
+ * SYNOPSIS
+ */
+XcmsColorFormat
+XcmsFormatOfPrefix(char *prefix)
+/*
+ * DESCRIPTION
+ * Returns the Color Space ID for the specified prefix
+ * if the color space is found in the Color Conversion
+ * Context.
+ *
+ * RETURNS
+ * Color Space ID if found; zero otherwise.
+ */
+{
+ XcmsColorSpace **papColorSpaces;
+ char string_buf[64];
+ char *string_lowered;
+ size_t len;
+
+ /*
+ * While copying prefix to string_lowered, convert to lowercase
+ */
+ if ((len = strlen(prefix)) >= sizeof(string_buf)) {
+ string_lowered = Xmalloc(len+1);
+ } else {
+ string_lowered = string_buf;
+ }
+ _XcmsCopyISOLatin1Lowered(string_lowered, prefix);
+
+ /*
+ * First try Device-Independent color spaces
+ */
+ papColorSpaces = _XcmsDIColorSpaces;
+ if (papColorSpaces != NULL) {
+ while (*papColorSpaces != NULL) {
+ if (strcmp((*papColorSpaces)->prefix, string_lowered) == 0) {
+ if (len >= sizeof(string_buf)) Xfree(string_lowered);
+ return((*papColorSpaces)->id);
+ }
+ papColorSpaces++;
+ }
+ }
+
+ /*
+ * Next try Device-Dependent color spaces
+ */
+ papColorSpaces = _XcmsDDColorSpaces;
+ if (papColorSpaces != NULL) {
+ while (*papColorSpaces != NULL) {
+ if (strcmp((*papColorSpaces)->prefix, string_lowered) == 0) {
+ if (len >= sizeof(string_buf)) Xfree(string_lowered);
+ return((*papColorSpaces)->id);
+ }
+ papColorSpaces++;
+ }
+ }
+
+ if (len >= sizeof(string_buf)) Xfree(string_lowered);
+ return(XcmsUndefinedFormat);
+}
diff --git a/nx-X11/lib/src/xcms/LRGB.c b/nx-X11/lib/src/xcms/LRGB.c
new file mode 100644
index 000000000..38cc6cfb4
--- /dev/null
+++ b/nx-X11/lib/src/xcms/LRGB.c
@@ -0,0 +1,1841 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ * NAME
+ * XcmsLRGB.c
+ *
+ * DESCRIPTION
+ * This file contains the conversion routines:
+ * 1. CIE XYZ to RGB intensity
+ * 2. RGB intensity to device RGB
+ * 3. device RGB to RGB intensity
+ * 4. RGB intensity to CIE XYZ
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <stdio.h>
+#include <nx-X11/Xos.h>
+#include <nx-X11/Xatom.h>
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+/*
+ * LOCAL DEFINES
+ * #define declarations local to this package.
+ */
+#define EPS 0.001
+#ifndef MIN
+#define MIN(x,y) ((x) > (y) ? (y) : (x))
+#endif /* MIN */
+#ifndef MAX
+#define MAX(x,y) ((x) > (y) ? (x) : (y))
+#endif /* MAX */
+#ifndef MIN3
+#define MIN3(x,y,z) ((x) > (MIN((y), (z))) ? (MIN((y), (z))) : (x))
+#endif /* MIN3 */
+#ifndef MAX3
+#define MAX3(x,y,z) ((x) > (MAX((y), (z))) ? (x) : (MAX((y), (z))))
+#endif /* MAX3 */
+
+/*
+ * LOCAL TYPEDEFS
+ * typedefs local to this package (for use with local vars).
+ *
+ */
+
+/*
+ * FORWARD DECLARATIONS
+ */
+static void LINEAR_RGB_FreeSCCData(XPointer pScreenDataTemp);
+static int LINEAR_RGB_InitSCCData(Display *dpy,
+ int screenNumber, XcmsPerScrnInfo *pPerScrnInfo);
+static int XcmsLRGB_RGB_ParseString(register char *spec, XcmsColor *pColor);
+static int XcmsLRGB_RGBi_ParseString(register char *spec, XcmsColor *pColor);
+static Status
+_XcmsGetTableType0(
+ IntensityTbl *pTbl,
+ int format,
+ char **pChar,
+ unsigned long *pCount);
+static Status
+_XcmsGetTableType1(
+ IntensityTbl *pTbl,
+ int format,
+ char **pChar,
+ unsigned long *pCount);
+
+/*
+ * LOCALS VARIABLES
+ * Variables local to this package.
+ * Usage example:
+ * static int ExampleLocalVar;
+ */
+
+static unsigned short const MASK[17] = {
+ 0x0000, /* 0 bitsPerRGB */
+ 0x8000, /* 1 bitsPerRGB */
+ 0xc000, /* 2 bitsPerRGB */
+ 0xe000, /* 3 bitsPerRGB */
+ 0xf000, /* 4 bitsPerRGB */
+ 0xf800, /* 5 bitsPerRGB */
+ 0xfc00, /* 6 bitsPerRGB */
+ 0xfe00, /* 7 bitsPerRGB */
+ 0xff00, /* 8 bitsPerRGB */
+ 0xff80, /* 9 bitsPerRGB */
+ 0xffc0, /* 10 bitsPerRGB */
+ 0xffe0, /* 11 bitsPerRGB */
+ 0xfff0, /* 12 bitsPerRGB */
+ 0xfff8, /* 13 bitsPerRGB */
+ 0xfffc, /* 14 bitsPerRGB */
+ 0xfffe, /* 15 bitsPerRGB */
+ 0xffff /* 16 bitsPerRGB */
+};
+
+
+ /*
+ * A NULL terminated array of function pointers that when applied
+ * in series will convert an XcmsColor structure from XcmsRGBFormat
+ * to XcmsCIEXYZFormat.
+ */
+static XcmsConversionProc Fl_RGB_to_CIEXYZ[] = {
+ (XcmsConversionProc)XcmsRGBToRGBi,
+ (XcmsConversionProc)XcmsRGBiToCIEXYZ,
+ NULL
+};
+
+ /*
+ * A NULL terminated array of function pointers that when applied
+ * in series will convert an XcmsColor structure from XcmsCIEXYZFormat
+ * to XcmsRGBFormat.
+ */
+static XcmsConversionProc Fl_CIEXYZ_to_RGB[] = {
+ (XcmsConversionProc)XcmsCIEXYZToRGBi,
+ (XcmsConversionProc)XcmsRGBiToRGB,
+ NULL
+};
+
+ /*
+ * A NULL terminated array of function pointers that when applied
+ * in series will convert an XcmsColor structure from XcmsRGBiFormat
+ * to XcmsCIEXYZFormat.
+ */
+static XcmsConversionProc Fl_RGBi_to_CIEXYZ[] = {
+ (XcmsConversionProc)XcmsRGBiToCIEXYZ,
+ NULL
+};
+
+ /*
+ * A NULL terminated array of function pointers that when applied
+ * in series will convert an XcmsColor structure from XcmsCIEXYZFormat
+ * to XcmsRGBiFormat.
+ */
+static XcmsConversionProc Fl_CIEXYZ_to_RGBi[] = {
+ (XcmsConversionProc)XcmsCIEXYZToRGBi,
+ NULL
+};
+
+ /*
+ * RGBi Color Spaces
+ */
+XcmsColorSpace XcmsRGBiColorSpace =
+ {
+ _XcmsRGBi_prefix, /* prefix */
+ XcmsRGBiFormat, /* id */
+ XcmsLRGB_RGBi_ParseString, /* parseString */
+ Fl_RGBi_to_CIEXYZ, /* to_CIEXYZ */
+ Fl_CIEXYZ_to_RGBi, /* from_CIEXYZ */
+ 1
+ };
+
+ /*
+ * RGB Color Spaces
+ */
+XcmsColorSpace XcmsRGBColorSpace =
+ {
+ _XcmsRGB_prefix, /* prefix */
+ XcmsRGBFormat, /* id */
+ XcmsLRGB_RGB_ParseString, /* parseString */
+ Fl_RGB_to_CIEXYZ, /* to_CIEXYZ */
+ Fl_CIEXYZ_to_RGB, /* from_CIEXYZ */
+ 1
+ };
+
+ /*
+ * Device-Independent Color Spaces known to the
+ * LINEAR_RGB Screen Color Characteristics Function Set.
+ */
+static XcmsColorSpace *DDColorSpaces[] = {
+ &XcmsRGBColorSpace,
+ &XcmsRGBiColorSpace,
+ NULL
+};
+
+
+/*
+ * GLOBALS
+ * Variables declared in this package that are allowed
+ * to be used globally.
+ */
+
+ /*
+ * LINEAR_RGB Screen Color Characteristics Function Set.
+ */
+XcmsFunctionSet XcmsLinearRGBFunctionSet =
+ {
+ &DDColorSpaces[0], /* pDDColorSpaces */
+ LINEAR_RGB_InitSCCData, /* pInitScrnFunc */
+ LINEAR_RGB_FreeSCCData /* pFreeSCCData */
+ };
+
+/*
+ * DESCRIPTION
+ * Contents of Default SCCData should be replaced if other
+ * data should be used as default.
+ *
+ *
+ */
+
+/*
+ * NAME Tektronix 19" (Sony) CRT
+ * PART_NUMBER 119-2451-00
+ * MODEL Tek4300, Tek4800
+ */
+
+static IntensityRec const Default_RGB_RedTuples[] = {
+ /* {unsigned short value, XcmsFloat intensity} */
+ { 0x0000, 0.000000 },
+ { 0x0909, 0.000000 },
+ { 0x0a0a, 0.000936 },
+ { 0x0f0f, 0.001481 },
+ { 0x1414, 0.002329 },
+ { 0x1919, 0.003529 },
+ { 0x1e1e, 0.005127 },
+ { 0x2323, 0.007169 },
+ { 0x2828, 0.009699 },
+ { 0x2d2d, 0.012759 },
+ { 0x3232, 0.016392 },
+ { 0x3737, 0.020637 },
+ { 0x3c3c, 0.025533 },
+ { 0x4141, 0.031119 },
+ { 0x4646, 0.037431 },
+ { 0x4b4b, 0.044504 },
+ { 0x5050, 0.052373 },
+ { 0x5555, 0.061069 },
+ { 0x5a5a, 0.070624 },
+ { 0x5f5f, 0.081070 },
+ { 0x6464, 0.092433 },
+ { 0x6969, 0.104744 },
+ { 0x6e6e, 0.118026 },
+ { 0x7373, 0.132307 },
+ { 0x7878, 0.147610 },
+ { 0x7d7d, 0.163958 },
+ { 0x8282, 0.181371 },
+ { 0x8787, 0.199871 },
+ { 0x8c8c, 0.219475 },
+ { 0x9191, 0.240202 },
+ { 0x9696, 0.262069 },
+ { 0x9b9b, 0.285089 },
+ { 0xa0a0, 0.309278 },
+ { 0xa5a5, 0.334647 },
+ { 0xaaaa, 0.361208 },
+ { 0xafaf, 0.388971 },
+ { 0xb4b4, 0.417945 },
+ { 0xb9b9, 0.448138 },
+ { 0xbebe, 0.479555 },
+ { 0xc3c3, 0.512202 },
+ { 0xc8c8, 0.546082 },
+ { 0xcdcd, 0.581199 },
+ { 0xd2d2, 0.617552 },
+ { 0xd7d7, 0.655144 },
+ { 0xdcdc, 0.693971 },
+ { 0xe1e1, 0.734031 },
+ { 0xe6e6, 0.775322 },
+ { 0xebeb, 0.817837 },
+ { 0xf0f0, 0.861571 },
+ { 0xf5f5, 0.906515 },
+ { 0xfafa, 0.952662 },
+ { 0xffff, 1.000000 }
+};
+
+static IntensityRec const Default_RGB_GreenTuples[] = {
+ /* {unsigned short value, XcmsFloat intensity} */
+ { 0x0000, 0.000000 },
+ { 0x1313, 0.000000 },
+ { 0x1414, 0.000832 },
+ { 0x1919, 0.001998 },
+ { 0x1e1e, 0.003612 },
+ { 0x2323, 0.005736 },
+ { 0x2828, 0.008428 },
+ { 0x2d2d, 0.011745 },
+ { 0x3232, 0.015740 },
+ { 0x3737, 0.020463 },
+ { 0x3c3c, 0.025960 },
+ { 0x4141, 0.032275 },
+ { 0x4646, 0.039449 },
+ { 0x4b4b, 0.047519 },
+ { 0x5050, 0.056520 },
+ { 0x5555, 0.066484 },
+ { 0x5a5a, 0.077439 },
+ { 0x5f5f, 0.089409 },
+ { 0x6464, 0.102418 },
+ { 0x6969, 0.116485 },
+ { 0x6e6e, 0.131625 },
+ { 0x7373, 0.147853 },
+ { 0x7878, 0.165176 },
+ { 0x7d7d, 0.183604 },
+ { 0x8282, 0.203140 },
+ { 0x8787, 0.223783 },
+ { 0x8c8c, 0.245533 },
+ { 0x9191, 0.268384 },
+ { 0x9696, 0.292327 },
+ { 0x9b9b, 0.317351 },
+ { 0xa0a0, 0.343441 },
+ { 0xa5a5, 0.370580 },
+ { 0xaaaa, 0.398747 },
+ { 0xafaf, 0.427919 },
+ { 0xb4b4, 0.458068 },
+ { 0xb9b9, 0.489165 },
+ { 0xbebe, 0.521176 },
+ { 0xc3c3, 0.554067 },
+ { 0xc8c8, 0.587797 },
+ { 0xcdcd, 0.622324 },
+ { 0xd2d2, 0.657604 },
+ { 0xd7d7, 0.693588 },
+ { 0xdcdc, 0.730225 },
+ { 0xe1e1, 0.767459 },
+ { 0xe6e6, 0.805235 },
+ { 0xebeb, 0.843491 },
+ { 0xf0f0, 0.882164 },
+ { 0xf5f5, 0.921187 },
+ { 0xfafa, 0.960490 },
+ { 0xffff, 1.000000 }
+};
+
+static IntensityRec const Default_RGB_BlueTuples[] = {
+ /* {unsigned short value, XcmsFloat intensity} */
+ { 0x0000, 0.000000 },
+ { 0x0e0e, 0.000000 },
+ { 0x0f0f, 0.001341 },
+ { 0x1414, 0.002080 },
+ { 0x1919, 0.003188 },
+ { 0x1e1e, 0.004729 },
+ { 0x2323, 0.006766 },
+ { 0x2828, 0.009357 },
+ { 0x2d2d, 0.012559 },
+ { 0x3232, 0.016424 },
+ { 0x3737, 0.021004 },
+ { 0x3c3c, 0.026344 },
+ { 0x4141, 0.032489 },
+ { 0x4646, 0.039481 },
+ { 0x4b4b, 0.047357 },
+ { 0x5050, 0.056154 },
+ { 0x5555, 0.065903 },
+ { 0x5a5a, 0.076634 },
+ { 0x5f5f, 0.088373 },
+ { 0x6464, 0.101145 },
+ { 0x6969, 0.114968 },
+ { 0x6e6e, 0.129862 },
+ { 0x7373, 0.145841 },
+ { 0x7878, 0.162915 },
+ { 0x7d7d, 0.181095 },
+ { 0x8282, 0.200386 },
+ { 0x8787, 0.220791 },
+ { 0x8c8c, 0.242309 },
+ { 0x9191, 0.264937 },
+ { 0x9696, 0.288670 },
+ { 0x9b9b, 0.313499 },
+ { 0xa0a0, 0.339410 },
+ { 0xa5a5, 0.366390 },
+ { 0xaaaa, 0.394421 },
+ { 0xafaf, 0.423481 },
+ { 0xb4b4, 0.453547 },
+ { 0xb9b9, 0.484592 },
+ { 0xbebe, 0.516587 },
+ { 0xc3c3, 0.549498 },
+ { 0xc8c8, 0.583291 },
+ { 0xcdcd, 0.617925 },
+ { 0xd2d2, 0.653361 },
+ { 0xd7d7, 0.689553 },
+ { 0xdcdc, 0.726454 },
+ { 0xe1e1, 0.764013 },
+ { 0xe6e6, 0.802178 },
+ { 0xebeb, 0.840891 },
+ { 0xf0f0, 0.880093 },
+ { 0xf5f5, 0.919723 },
+ { 0xfafa, 0.959715 },
+ { 0xffff, 1.00000 }
+};
+
+static IntensityTbl Default_RGB_RedTbl = {
+ /* IntensityRec *pBase */
+ (IntensityRec *) Default_RGB_RedTuples,
+ /* unsigned int nEntries */
+ 52
+};
+
+static IntensityTbl Default_RGB_GreenTbl = {
+ /* IntensityRec *pBase */
+ (IntensityRec *)Default_RGB_GreenTuples,
+ /* unsigned int nEntries */
+ 50
+};
+
+static IntensityTbl Default_RGB_BlueTbl = {
+ /* IntensityRec *pBase */
+ (IntensityRec *)Default_RGB_BlueTuples,
+ /* unsigned int nEntries */
+ 51
+};
+
+static LINEAR_RGB_SCCData Default_RGB_SCCData = {
+ /* XcmsFloat XYZtoRGBmatrix[3][3] */
+ {
+ { 3.48340481253539000, -1.52176374927285200, -0.55923133354049780 },
+ {-1.07152751306193600, 1.96593795204372400, 0.03673691339553462 },
+ { 0.06351179790497788, -0.20020501000496480, 0.81070942031648220 }
+ },
+
+ /* XcmsFloat RGBtoXYZmatrix[3][3] */
+ {
+ { 0.38106149108714790, 0.32025712365352110, 0.24834578525933100 },
+ { 0.20729745115140850, 0.68054638776373240, 0.11215616108485920 },
+ { 0.02133944350088028, 0.14297193020246480, 1.24172892629665500 }
+ },
+
+ /* IntensityTbl *pRedTbl */
+ &Default_RGB_RedTbl,
+
+ /* IntensityTbl *pGreenTbl */
+ &Default_RGB_GreenTbl,
+
+ /* IntensityTbl *pBlueTbl */
+ &Default_RGB_BlueTbl
+};
+
+/************************************************************************
+ * *
+ * PRIVATE ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * LINEAR_RGB_InitSCCData()
+ *
+ * SYNOPSIS
+ */
+static Status
+LINEAR_RGB_InitSCCData(
+ Display *dpy,
+ int screenNumber,
+ XcmsPerScrnInfo *pPerScrnInfo)
+/*
+ * DESCRIPTION
+ *
+ * RETURNS
+ * XcmsFailure if failed.
+ * XcmsSuccess if succeeded.
+ *
+ */
+{
+ Atom CorrectAtom = XInternAtom (dpy, XDCCC_CORRECT_ATOM_NAME, True);
+ Atom MatrixAtom = XInternAtom (dpy, XDCCC_MATRIX_ATOM_NAME, True);
+ int format_return, count, cType, nTables;
+ unsigned long nitems, nbytes_return;
+ char *property_return, *pChar;
+ XcmsFloat *pValue;
+#ifdef ALLDEBUG
+ IntensityRec *pIRec;
+#endif /* ALLDEBUG */
+ VisualID visualID;
+
+ LINEAR_RGB_SCCData *pScreenData, *pScreenDefaultData;
+ XcmsIntensityMap *pNewMap;
+
+ /*
+ * Allocate memory for pScreenData
+ */
+ if (!(pScreenData = pScreenDefaultData = (LINEAR_RGB_SCCData *)
+ Xcalloc (1, sizeof(LINEAR_RGB_SCCData)))) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * 1. Get the XYZ->RGB and RGB->XYZ matrices
+ */
+
+ if (MatrixAtom == None ||
+ !_XcmsGetProperty (dpy, RootWindow(dpy, screenNumber), MatrixAtom,
+ &format_return, &nitems, &nbytes_return, &property_return) ||
+ nitems != 18 || format_return != 32) {
+ /*
+ * As per the XDCCC, there must be 18 data items and each must be
+ * in 32 bits !
+ */
+ goto FreeSCCData;
+
+ } else {
+
+ /*
+ * RGBtoXYZ and XYZtoRGB matrices
+ */
+ pValue = (XcmsFloat *) pScreenData;
+ pChar = property_return;
+ for (count = 0; count < 18; count++) {
+ *pValue++ = (long)_XcmsGetElement(format_return, &pChar,
+ &nitems) / (XcmsFloat)XDCCC_NUMBER;
+ }
+ Xfree (property_return);
+ pPerScrnInfo->screenWhitePt.spec.CIEXYZ.X =
+ pScreenData->RGBtoXYZmatrix[0][0] +
+ pScreenData->RGBtoXYZmatrix[0][1] +
+ pScreenData->RGBtoXYZmatrix[0][2];
+ pPerScrnInfo->screenWhitePt.spec.CIEXYZ.Y =
+ pScreenData->RGBtoXYZmatrix[1][0] +
+ pScreenData->RGBtoXYZmatrix[1][1] +
+ pScreenData->RGBtoXYZmatrix[1][2];
+ pPerScrnInfo->screenWhitePt.spec.CIEXYZ.Z =
+ pScreenData->RGBtoXYZmatrix[2][0] +
+ pScreenData->RGBtoXYZmatrix[2][1] +
+ pScreenData->RGBtoXYZmatrix[2][2];
+
+ /*
+ * Compute the Screen White Point
+ */
+ if ((pPerScrnInfo->screenWhitePt.spec.CIEXYZ.Y < (1.0 - EPS) )
+ || (pPerScrnInfo->screenWhitePt.spec.CIEXYZ.Y > (1.0 + EPS))) {
+ goto FreeSCCData;
+ } else {
+ pPerScrnInfo->screenWhitePt.spec.CIEXYZ.Y = 1.0;
+ }
+ pPerScrnInfo->screenWhitePt.format = XcmsCIEXYZFormat;
+ pPerScrnInfo->screenWhitePt.pixel = 0;
+
+#ifdef PDEBUG
+ printf ("RGB to XYZ Matrix values:\n");
+ printf (" %f %f %f\n %f %f %f\n %f %f %f\n",
+ pScreenData->RGBtoXYZmatrix[0][0],
+ pScreenData->RGBtoXYZmatrix[0][1],
+ pScreenData->RGBtoXYZmatrix[0][2],
+ pScreenData->RGBtoXYZmatrix[1][0],
+ pScreenData->RGBtoXYZmatrix[1][1],
+ pScreenData->RGBtoXYZmatrix[1][2],
+ pScreenData->RGBtoXYZmatrix[2][0],
+ pScreenData->RGBtoXYZmatrix[2][1],
+ pScreenData->RGBtoXYZmatrix[2][2]);
+ printf ("XYZ to RGB Matrix values:\n");
+ printf (" %f %f %f\n %f %f %f\n %f %f %f\n",
+ pScreenData->XYZtoRGBmatrix[0][0],
+ pScreenData->XYZtoRGBmatrix[0][1],
+ pScreenData->XYZtoRGBmatrix[0][2],
+ pScreenData->XYZtoRGBmatrix[1][0],
+ pScreenData->XYZtoRGBmatrix[1][1],
+ pScreenData->XYZtoRGBmatrix[1][2],
+ pScreenData->XYZtoRGBmatrix[2][0],
+ pScreenData->XYZtoRGBmatrix[2][1],
+ pScreenData->XYZtoRGBmatrix[2][2]);
+ printf ("Screen White Pt value: %f %f %f\n",
+ pPerScrnInfo->screenWhitePt.spec.CIEXYZ.X,
+ pPerScrnInfo->screenWhitePt.spec.CIEXYZ.Y,
+ pPerScrnInfo->screenWhitePt.spec.CIEXYZ.Z);
+#endif /* PDEBUG */
+ }
+
+ /*
+ * 2. Get the Intensity Profile
+ */
+ if (CorrectAtom == None ||
+ !_XcmsGetProperty (dpy, RootWindow(dpy, screenNumber), CorrectAtom,
+ &format_return, &nitems, &nbytes_return, &property_return)) {
+ goto FreeSCCData;
+ }
+
+ pChar = property_return;
+
+ while (nitems) {
+ switch (format_return) {
+ case 8:
+ /*
+ * Must have at least:
+ * VisualID0
+ * VisualID1
+ * VisualID2
+ * VisualID3
+ * type
+ * count
+ * length
+ * intensity1
+ * intensity2
+ */
+ if (nitems < 9) {
+ goto Free_property_return;
+ }
+ count = 3;
+ break;
+ case 16:
+ /*
+ * Must have at least:
+ * VisualID0
+ * VisualID3
+ * type
+ * count
+ * length
+ * intensity1
+ * intensity2
+ */
+ if (nitems < 7) {
+ goto Free_property_return;
+ }
+ count = 1;
+ break;
+ case 32:
+ /*
+ * Must have at least:
+ * VisualID0
+ * type
+ * count
+ * length
+ * intensity1
+ * intensity2
+ */
+ if (nitems < 6) {
+ goto Free_property_return;
+ }
+ count = 0;
+ break;
+ default:
+ goto Free_property_return;
+ }
+
+ /*
+ * Get VisualID
+ */
+ visualID = _XcmsGetElement(format_return, &pChar, &nitems);
+ while (count--) {
+ visualID = visualID << format_return;
+ visualID |= _XcmsGetElement(format_return, &pChar, &nitems);
+ }
+
+ if (visualID == 0) {
+ /*
+ * This is a shared intensity table
+ */
+ pScreenData = pScreenDefaultData;
+ } else {
+ /*
+ * This is a per-Visual intensity table
+ */
+ if (!(pScreenData = (LINEAR_RGB_SCCData *)
+ Xcalloc (1, sizeof(LINEAR_RGB_SCCData)))) {
+ goto Free_property_return;
+ }
+ /* copy matrices */
+ memcpy((char *)pScreenData, (char *)pScreenDefaultData,
+ 18 * sizeof(XcmsFloat));
+
+ /* Create, initialize, and add map */
+ if (!(pNewMap = (XcmsIntensityMap *)
+ Xcalloc (1, sizeof(XcmsIntensityMap)))) {
+ Xfree(pScreenData);
+ goto Free_property_return;
+ }
+ pNewMap->visualID = visualID;
+ pNewMap->screenData = (XPointer)pScreenData;
+ pNewMap->pFreeScreenData = LINEAR_RGB_FreeSCCData;
+ pNewMap->pNext =
+ (XcmsIntensityMap *)dpy->cms.perVisualIntensityMaps;
+ dpy->cms.perVisualIntensityMaps = (XPointer)pNewMap;
+ dpy->free_funcs->intensityMaps = _XcmsFreeIntensityMaps;
+ }
+
+ cType = _XcmsGetElement(format_return, &pChar, &nitems);
+ nTables = _XcmsGetElement(format_return, &pChar, &nitems);
+
+ if (cType == 0) {
+
+ /* Red Intensity Table */
+ if (!(pScreenData->pRedTbl = (IntensityTbl *)
+ Xcalloc (1, sizeof(IntensityTbl)))) {
+ goto Free_property_return;
+ }
+ if (_XcmsGetTableType0(pScreenData->pRedTbl, format_return, &pChar,
+ &nitems) == XcmsFailure) {
+ goto FreeRedTbl;
+ }
+
+ if (nTables == 1) {
+ /* Green Intensity Table */
+ pScreenData->pGreenTbl = pScreenData->pRedTbl;
+ /* Blue Intensity Table */
+ pScreenData->pBlueTbl = pScreenData->pRedTbl;
+ } else {
+ /* Green Intensity Table */
+ if (!(pScreenData->pGreenTbl = (IntensityTbl *)
+ Xcalloc (1, sizeof(IntensityTbl)))) {
+ goto FreeRedTblElements;
+ }
+ if (_XcmsGetTableType0(pScreenData->pGreenTbl, format_return, &pChar,
+ &nitems) == XcmsFailure) {
+ goto FreeGreenTbl;
+ }
+
+ /* Blue Intensity Table */
+ if (!(pScreenData->pBlueTbl = (IntensityTbl *)
+ Xcalloc (1, sizeof(IntensityTbl)))) {
+ goto FreeGreenTblElements;
+ }
+ if (_XcmsGetTableType0(pScreenData->pBlueTbl, format_return, &pChar,
+ &nitems) == XcmsFailure) {
+ goto FreeBlueTbl;
+ }
+ }
+ } else if (cType == 1) {
+ /* Red Intensity Table */
+ if (!(pScreenData->pRedTbl = (IntensityTbl *)
+ Xcalloc (1, sizeof(IntensityTbl)))) {
+ goto Free_property_return;
+ }
+ if (_XcmsGetTableType1(pScreenData->pRedTbl, format_return, &pChar,
+ &nitems) == XcmsFailure) {
+ goto FreeRedTbl;
+ }
+
+ if (nTables == 1) {
+
+ /* Green Intensity Table */
+ pScreenData->pGreenTbl = pScreenData->pRedTbl;
+ /* Blue Intensity Table */
+ pScreenData->pBlueTbl = pScreenData->pRedTbl;
+
+ } else {
+
+ /* Green Intensity Table */
+ if (!(pScreenData->pGreenTbl = (IntensityTbl *)
+ Xcalloc (1, sizeof(IntensityTbl)))) {
+ goto FreeRedTblElements;
+ }
+ if (_XcmsGetTableType1(pScreenData->pGreenTbl, format_return, &pChar,
+ &nitems) == XcmsFailure) {
+ goto FreeGreenTbl;
+ }
+
+ /* Blue Intensity Table */
+ if (!(pScreenData->pBlueTbl = (IntensityTbl *)
+ Xcalloc (1, sizeof(IntensityTbl)))) {
+ goto FreeGreenTblElements;
+ }
+ if (_XcmsGetTableType1(pScreenData->pBlueTbl, format_return, &pChar,
+ &nitems) == XcmsFailure) {
+ goto FreeBlueTbl;
+ }
+ }
+ } else {
+ goto Free_property_return;
+ }
+
+#ifdef ALLDEBUG
+ printf ("Intensity Table RED %d\n", pScreenData->pRedTbl->nEntries);
+ pIRec = (IntensityRec *) pScreenData->pRedTbl->pBase;
+ for (count = 0; count < pScreenData->pRedTbl->nEntries; count++, pIRec++) {
+ printf ("\t0x%4x\t%f\n", pIRec->value, pIRec->intensity);
+ }
+ if (pScreenData->pGreenTbl->pBase != pScreenData->pRedTbl->pBase) {
+ printf ("Intensity Table GREEN %d\n", pScreenData->pGreenTbl->nEntries);
+ pIRec = (IntensityRec *)pScreenData->pGreenTbl->pBase;
+ for (count = 0; count < pScreenData->pGreenTbl->nEntries; count++, pIRec++) {
+ printf ("\t0x%4x\t%f\n", pIRec->value, pIRec->intensity);
+ }
+ }
+ if (pScreenData->pBlueTbl->pBase != pScreenData->pRedTbl->pBase) {
+ printf ("Intensity Table BLUE %d\n", pScreenData->pBlueTbl->nEntries);
+ pIRec = (IntensityRec *) pScreenData->pBlueTbl->pBase;
+ for (count = 0; count < pScreenData->pBlueTbl->nEntries; count++, pIRec++) {
+ printf ("\t0x%4x\t%f\n", pIRec->value, pIRec->intensity);
+ }
+ }
+#endif /* ALLDEBUG */
+ }
+
+ Xfree (property_return);
+
+ /* Free the old memory and use the new structure created. */
+ LINEAR_RGB_FreeSCCData(pPerScrnInfo->screenData);
+
+ pPerScrnInfo->functionSet = (XPointer) &XcmsLinearRGBFunctionSet;
+
+ pPerScrnInfo->screenData = (XPointer) pScreenData;
+
+ pPerScrnInfo->state = XcmsInitSuccess;
+
+ return(XcmsSuccess);
+
+FreeBlueTbl:
+ Xfree(pScreenData->pBlueTbl);
+
+FreeGreenTblElements:
+ Xfree(pScreenData->pGreenTbl->pBase);
+
+FreeGreenTbl:
+ Xfree(pScreenData->pGreenTbl);
+
+FreeRedTblElements:
+ Xfree(pScreenData->pRedTbl->pBase);
+
+FreeRedTbl:
+ Xfree(pScreenData->pRedTbl);
+
+Free_property_return:
+ Xfree (property_return);
+
+FreeSCCData:
+ Xfree(pScreenDefaultData);
+ pPerScrnInfo->state = XcmsInitNone;
+ return(XcmsFailure);
+}
+
+
+/*
+ * NAME
+ * LINEAR_RGB_FreeSCCData()
+ *
+ * SYNOPSIS
+ */
+static void
+LINEAR_RGB_FreeSCCData(
+ XPointer pScreenDataTemp)
+/*
+ * DESCRIPTION
+ *
+ * RETURNS
+ * 0 if failed.
+ * 1 if succeeded with no modifications.
+ *
+ */
+{
+ LINEAR_RGB_SCCData *pScreenData = (LINEAR_RGB_SCCData *) pScreenDataTemp;
+
+ if (pScreenData && pScreenData != &Default_RGB_SCCData) {
+ if (pScreenData->pRedTbl) {
+ if (pScreenData->pGreenTbl) {
+ if (pScreenData->pRedTbl->pBase !=
+ pScreenData->pGreenTbl->pBase) {
+ if (pScreenData->pGreenTbl->pBase) {
+ Xfree (pScreenData->pGreenTbl->pBase);
+ }
+ }
+ if (pScreenData->pGreenTbl != pScreenData->pRedTbl) {
+ Xfree (pScreenData->pGreenTbl);
+ }
+ }
+ if (pScreenData->pBlueTbl) {
+ if (pScreenData->pRedTbl->pBase !=
+ pScreenData->pBlueTbl->pBase) {
+ if (pScreenData->pBlueTbl->pBase) {
+ Xfree (pScreenData->pBlueTbl->pBase);
+ }
+ }
+ if (pScreenData->pBlueTbl != pScreenData->pRedTbl) {
+ Xfree (pScreenData->pBlueTbl);
+ }
+ }
+ if (pScreenData->pRedTbl->pBase) {
+ Xfree (pScreenData->pRedTbl->pBase);
+ }
+ Xfree (pScreenData->pRedTbl);
+ }
+ Xfree (pScreenData);
+ }
+}
+
+
+
+/************************************************************************
+ * *
+ * API PRIVATE ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * _XcmsGetTableType0
+ *
+ * SYNOPSIS
+ */
+static Status
+_XcmsGetTableType0(
+ IntensityTbl *pTbl,
+ int format,
+ char **pChar,
+ unsigned long *pCount)
+/*
+ * DESCRIPTION
+ *
+ * RETURNS
+ * XcmsFailure if failed.
+ * XcmsSuccess if succeeded.
+ *
+ */
+{
+ unsigned int nElements;
+ IntensityRec *pIRec;
+
+ nElements = pTbl->nEntries =
+ _XcmsGetElement(format, pChar, pCount) + 1;
+ if (!(pIRec = pTbl->pBase = (IntensityRec *)
+ Xcalloc (nElements, sizeof(IntensityRec)))) {
+ return(XcmsFailure);
+ }
+
+ switch (format) {
+ case 8:
+ for (; nElements--; pIRec++) {
+ /* 0xFFFF/0xFF = 0x101 */
+ pIRec->value = _XcmsGetElement (format, pChar, pCount) * 0x101;
+ pIRec->intensity =
+ _XcmsGetElement (format, pChar, pCount) / (XcmsFloat)255.0;
+ }
+ break;
+ case 16:
+ for (; nElements--; pIRec++) {
+ pIRec->value = _XcmsGetElement (format, pChar, pCount);
+ pIRec->intensity = _XcmsGetElement (format, pChar, pCount)
+ / (XcmsFloat)65535.0;
+ }
+ break;
+ case 32:
+ for (; nElements--; pIRec++) {
+ pIRec->value = _XcmsGetElement (format, pChar, pCount);
+ pIRec->intensity = _XcmsGetElement (format, pChar, pCount)
+ / (XcmsFloat)4294967295.0;
+ }
+ break;
+ default:
+ return(XcmsFailure);
+ }
+ return(XcmsSuccess);
+}
+
+
+/*
+ * NAME
+ * _XcmsGetTableType1
+ *
+ * SYNOPSIS
+ */
+static Status
+_XcmsGetTableType1(
+ IntensityTbl *pTbl,
+ int format,
+ char **pChar,
+ unsigned long *pCount)
+/*
+ * DESCRIPTION
+ *
+ * RETURNS
+ * XcmsFailure if failed.
+ * XcmsSuccess if succeeded.
+ *
+ */
+{
+ unsigned int count;
+ unsigned int max_index;
+ IntensityRec *pIRec;
+
+ max_index = _XcmsGetElement(format, pChar, pCount);
+ pTbl->nEntries = max_index + 1;
+ if (!(pIRec = pTbl->pBase = (IntensityRec *)
+ Xcalloc (max_index+1, sizeof(IntensityRec)))) {
+ return(XcmsFailure);
+ }
+
+ switch (format) {
+ case 8:
+ for (count = 0; count < max_index+1; count++, pIRec++) {
+ pIRec->value = (count * 65535) / max_index;
+ pIRec->intensity = _XcmsGetElement (format, pChar, pCount)
+ / (XcmsFloat)255.0;
+ }
+ break;
+ case 16:
+ for (count = 0; count < max_index+1; count++, pIRec++) {
+ pIRec->value = (count * 65535) / max_index;
+ pIRec->intensity = _XcmsGetElement (format, pChar, pCount)
+ / (XcmsFloat)65535.0;
+ }
+ break;
+ case 32:
+ for (count = 0; count < max_index+1; count++, pIRec++) {
+ pIRec->value = (count * 65535) / max_index;
+ pIRec->intensity = _XcmsGetElement (format, pChar, pCount)
+ / (XcmsFloat)4294967295.0;
+ }
+ break;
+ default:
+ return(XcmsFailure);
+ }
+
+ return(XcmsSuccess);
+}
+
+
+/*
+ * NAME
+ * ValueCmp
+ *
+ * SYNOPSIS
+ */
+static int
+_XcmsValueCmp(
+ IntensityRec *p1, IntensityRec *p2)
+/*
+ * DESCRIPTION
+ * Compares the value component of two IntensityRec
+ * structures.
+ *
+ * RETURNS
+ * 0 if p1->value is equal to p2->value
+ * < 0 if p1->value is less than p2->value
+ * > 0 if p1->value is greater than p2->value
+ *
+ */
+{
+ return (p1->value - p2->value);
+}
+
+
+/*
+ * NAME
+ * IntensityCmp
+ *
+ * SYNOPSIS
+ */
+static int
+_XcmsIntensityCmp(
+ IntensityRec *p1, IntensityRec *p2)
+/*
+ * DESCRIPTION
+ * Compares the intensity component of two IntensityRec
+ * structures.
+ *
+ * RETURNS
+ * 0 if equal;
+ * < 0 if first precedes second
+ * > 0 if first succeeds second
+ *
+ */
+{
+ if (p1->intensity < p2->intensity) {
+ return (-1);
+ }
+ if (p1->intensity > p2->intensity) {
+ return (XcmsSuccess);
+ }
+ return (XcmsFailure);
+}
+
+/*
+ * NAME
+ * ValueInterpolation
+ *
+ * SYNOPSIS
+ */
+/* ARGSUSED */
+static int
+_XcmsValueInterpolation(
+ IntensityRec *key, IntensityRec *lo, IntensityRec *hi, IntensityRec *answer,
+ int bitsPerRGB)
+/*
+ * DESCRIPTION
+ * Based on a given value, performs a linear interpolation
+ * on the intensities between two IntensityRec structures.
+ * Note that the bitsPerRGB parameter is ignored.
+ *
+ * RETURNS
+ * Returns 0 if failed; otherwise non-zero.
+ */
+{
+ XcmsFloat ratio;
+
+ ratio = ((XcmsFloat)key->value - (XcmsFloat)lo->value) /
+ ((XcmsFloat)hi->value - (XcmsFloat)lo->value);
+ answer->value = key->value;
+ answer->intensity = (hi->intensity - lo->intensity) * ratio;
+ answer->intensity += lo->intensity;
+ return (XcmsSuccess);
+}
+
+/*
+ * NAME
+ * IntensityInterpolation
+ *
+ * SYNOPSIS
+ */
+static int
+_XcmsIntensityInterpolation(
+ IntensityRec *key, IntensityRec *lo, IntensityRec *hi, IntensityRec *answer,
+ int bitsPerRGB)
+/*
+ * DESCRIPTION
+ * Based on a given intensity, performs a linear interpolation
+ * on the values between two IntensityRec structures.
+ * The bitsPerRGB parameter is necessary to perform rounding
+ * to the correct number of significant bits.
+ *
+ * RETURNS
+ * Returns 0 if failed; otherwise non-zero.
+ */
+{
+ XcmsFloat ratio;
+ long target, up, down;
+ int shift = 16 - bitsPerRGB;
+ int max_color = (1 << bitsPerRGB) - 1;
+
+ ratio = (key->intensity - lo->intensity) / (hi->intensity - lo->intensity);
+ answer->intensity = key->intensity;
+ target = hi->value - lo->value;
+ target *= ratio;
+ target += lo->value;
+
+ /*
+ * Ok now, lets find the closest in respects to bits per RGB
+ */
+ up = ((target >> shift) * 0xFFFF) / max_color;
+ if (up < target) {
+ down = up;
+ up = (MIN((down >> shift) + 1, max_color) * 0xFFFF) / max_color;
+ } else {
+ down = (MAX((up >> shift) - 1, 0) * 0xFFFF) / max_color;
+ }
+ answer->value = ((up - target) < (target - down) ? up : down);
+ answer->value &= MASK[bitsPerRGB];
+ return (XcmsSuccess);
+}
+
+
+
+typedef int (*comparProcp)(
+ char *p1,
+ char *p2);
+typedef int (*interpolProcp)(
+ char *key,
+ char *lo,
+ char *hi,
+ char *answer,
+ int bitsPerRGB);
+
+/*
+ * NAME
+ * _XcmsTableSearch
+ *
+ * SYNOPSIS
+ */
+static int
+_XcmsTableSearch(
+ char *key,
+ int bitsPerRGB,
+ char *base,
+ unsigned nel,
+ unsigned nKeyPtrSize,
+ int (*compar)(
+ char *p1,
+ char *p2),
+ int (*interpol)(
+ char *key,
+ char *lo,
+ char *hi,
+ char *answer,
+ int bitsPerRGB),
+ char *answer)
+
+/*
+ * DESCRIPTION
+ * A binary search through the specificied table.
+ *
+ * RETURNS
+ * Returns 0 if failed; otherwise non-zero.
+ *
+ */
+{
+ char *hi, *lo, *mid, *last;
+ int result;
+
+ last = hi = base + ((nel - 1) * nKeyPtrSize);
+ mid = lo = base;
+
+ /* use only the significants bits, then scale into 16 bits */
+ ((IntensityRec *)key)->value = ((unsigned long)
+ (((IntensityRec *)key)->value >> (16 - bitsPerRGB)) * 0xFFFF)
+ / ((1 << bitsPerRGB) - 1);
+
+ /* Special case so that zero intensity always maps to zero value */
+ if ((*compar) (key,lo) <= 0) {
+ memcpy (answer, lo, nKeyPtrSize);
+ ((IntensityRec *)answer)->value &= MASK[bitsPerRGB];
+ return XcmsSuccess;
+ }
+ while (mid != last) {
+ last = mid;
+ mid = lo + (((unsigned)(hi - lo) / nKeyPtrSize) / 2) * nKeyPtrSize;
+ result = (*compar) (key, mid);
+ if (result == 0) {
+
+ memcpy(answer, mid, nKeyPtrSize);
+ ((IntensityRec *)answer)->value &= MASK[bitsPerRGB];
+ return (XcmsSuccess);
+ } else if (result < 0) {
+ hi = mid;
+ } else {
+ lo = mid;
+ }
+ }
+
+ /*
+ * If we got to here, we didn't find a solution, so we
+ * need to apply interpolation.
+ */
+ return ((*interpol)(key, lo, hi, answer, bitsPerRGB));
+}
+
+
+/*
+ * NAME
+ * _XcmsMatVec - multiply a 3 x 3 by a 3 x 1 vector
+ *
+ * SYNOPSIS
+ */
+static void _XcmsMatVec(
+ XcmsFloat *pMat, XcmsFloat *pIn, XcmsFloat *pOut)
+/*
+ * DESCRIPTION
+ * Multiply the passed vector by the passed matrix to return a
+ * vector. Matrix is 3x3, vectors are of length 3.
+ *
+ * RETURNS
+ * void
+ */
+{
+ int i, j;
+
+ for (i = 0; i < 3; i++) {
+ pOut[i] = 0.0;
+ for (j = 0; j < 3; j++)
+ pOut[i] += *(pMat+(i*3)+j) * pIn[j];
+ }
+}
+
+
+/************************************************************************
+ * *
+ * PUBLIC ROUTINES *
+ * *
+ ************************************************************************/
+
+
+/*
+ * NAME
+ * XcmsLRGB_RGB_ParseString
+ *
+ * SYNOPSIS
+ */
+static int
+XcmsLRGB_RGB_ParseString(
+ register char *spec,
+ XcmsColor *pColor)
+/*
+ * DESCRIPTION
+ * This routines takes a string and attempts to convert
+ * it into a XcmsColor structure with XcmsRGBFormat.
+ *
+ * RETURNS
+ * 0 if failed, non-zero otherwise.
+ */
+{
+ register int n, i;
+ unsigned short r, g, b;
+ char c;
+ char *pchar;
+ unsigned short *pShort;
+
+ /*
+ * Check for old # format
+ */
+ if (*spec == '#') {
+ /*
+ * Attempt to parse the value portion.
+ */
+ spec++;
+ n = strlen(spec);
+ if (n != 3 && n != 6 && n != 9 && n != 12) {
+ return(XcmsFailure);
+ }
+
+ n /= 3;
+ g = b = 0;
+ do {
+ r = g;
+ g = b;
+ b = 0;
+ for (i = n; --i >= 0; ) {
+ c = *spec++;
+ b <<= 4;
+ if (c >= '0' && c <= '9')
+ b |= c - '0';
+ /* assume string in lowercase
+ else if (c >= 'A' && c <= 'F')
+ b |= c - ('A' - 10);
+ */
+ else if (c >= 'a' && c <= 'f')
+ b |= c - ('a' - 10);
+ else return (XcmsFailure);
+ }
+ } while (*spec != '\0');
+
+ /*
+ * Succeeded !
+ */
+ n <<= 2;
+ n = 16 - n;
+ /* shift instead of scale, to match old broken semantics */
+ pColor->spec.RGB.red = r << n;
+ pColor->spec.RGB.green = g << n;
+ pColor->spec.RGB.blue = b << n;
+ } else {
+ if ((pchar = strchr(spec, ':')) == NULL) {
+ return(XcmsFailure);
+ }
+ n = (int)(pchar - spec);
+
+ /*
+ * Check for proper prefix.
+ */
+ if (strncmp(spec, _XcmsRGB_prefix, n) != 0) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Attempt to parse the value portion.
+ */
+ spec += (n + 1);
+ pShort = &pColor->spec.RGB.red;
+ for (i = 0; i < 3; i++, pShort++, spec++) {
+ n = 0;
+ *pShort = 0;
+ while (*spec != '/' && *spec != '\0') {
+ if (++n > 4) {
+ return(XcmsFailure);
+ }
+ c = *spec++;
+ *pShort <<= 4;
+ if (c >= '0' && c <= '9')
+ *pShort |= c - '0';
+ /* assume string in lowercase
+ else if (c >= 'A' && c <= 'F')
+ *pShort |= c - ('A' - 10);
+ */
+ else if (c >= 'a' && c <= 'f')
+ *pShort |= c - ('a' - 10);
+ else return (XcmsFailure);
+ }
+ if (n == 0)
+ return (XcmsFailure);
+ if (n < 4) {
+ *pShort = ((unsigned long)*pShort * 0xFFFF) / ((1 << n*4) - 1);
+ }
+ }
+ }
+ pColor->format = XcmsRGBFormat;
+ pColor->pixel = 0;
+ return (XcmsSuccess);
+}
+
+
+/*
+ * NAME
+ * XcmsLRGB_RGBi_ParseString
+ *
+ * SYNOPSIS
+ */
+static int
+XcmsLRGB_RGBi_ParseString(
+ register char *spec,
+ XcmsColor *pColor)
+/*
+ * DESCRIPTION
+ * This routines takes a string and attempts to convert
+ * it into a XcmsColor structure with XcmsRGBiFormat.
+ * The assumed RGBi string syntax is:
+ * RGBi:<r>/<g>/<b>
+ * Where r, g, and b are in string input format for floats
+ * consisting of:
+ * a. an optional sign
+ * b. a string of numbers possibly containing a decimal point,
+ * c. an optional exponent field containing an 'E' or 'e'
+ * followed by a possibly signed integer string.
+ *
+ * RETURNS
+ * 0 if failed, non-zero otherwise.
+ */
+{
+ size_t n;
+ char *pchar;
+
+ if ((pchar = strchr(spec, ':')) == NULL) {
+ return(XcmsFailure);
+ }
+ n = (size_t)(pchar - spec);
+
+ /*
+ * Check for proper prefix.
+ */
+ if (strncmp(spec, _XcmsRGBi_prefix, n) != 0) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Attempt to parse the value portion.
+ */
+ if (sscanf(spec + n + 1, "%lf/%lf/%lf",
+ &pColor->spec.RGBi.red,
+ &pColor->spec.RGBi.green,
+ &pColor->spec.RGBi.blue) != 3) {
+ char *s; /* Maybe failed due to locale */
+ int f;
+ if ((s = strdup(spec))) {
+ for (f = 0; s[f]; ++f)
+ if (s[f] == '.')
+ s[f] = ',';
+ else if (s[f] == ',')
+ s[f] = '.';
+ if (sscanf(s + n + 1, "%lf/%lf/%lf",
+ &pColor->spec.RGBi.red,
+ &pColor->spec.RGBi.green,
+ &pColor->spec.RGBi.blue) != 3) {
+ free(s);
+ return(XcmsFailure);
+ }
+ free(s);
+ } else
+ return(XcmsFailure);
+ }
+
+ /*
+ * Succeeded !
+ */
+ pColor->format = XcmsRGBiFormat;
+ pColor->pixel = 0;
+ return (XcmsSuccess);
+}
+
+
+/*
+ * NAME
+ * XcmsCIEXYZToRGBi - convert CIE XYZ to RGB
+ *
+ * SYNOPSIS
+ */
+/* ARGSUSED */
+Status
+XcmsCIEXYZToRGBi(
+ XcmsCCC ccc,
+ XcmsColor *pXcmsColors_in_out,/* pointer to XcmsColors to convert */
+ unsigned int nColors, /* Number of colors */
+ Bool *pCompressed) /* pointer to an array of Bool */
+/*
+ * DESCRIPTION
+ * Converts color specifications in an array of XcmsColor
+ * structures from RGB format to RGBi format.
+ *
+ * RETURNS
+ * XcmsFailure if failed,
+ * XcmsSuccess if succeeded without gamut compression.
+ * XcmsSuccessWithCompression if succeeded with gamut
+ * compression.
+ */
+{
+ LINEAR_RGB_SCCData *pScreenData;
+ XcmsFloat tmp[3];
+ int hasCompressed = 0;
+ unsigned int i;
+ XcmsColor *pColor = pXcmsColors_in_out;
+
+ if (ccc == NULL) {
+ return(XcmsFailure);
+ }
+
+ pScreenData = (LINEAR_RGB_SCCData *)ccc->pPerScrnInfo->screenData;
+
+ /*
+ * XcmsColors should be White Point Adjusted, if necessary, by now!
+ */
+
+ /*
+ * NEW!!! for extended gamut compression
+ *
+ * 1. Need to zero out pCompressed
+ *
+ * 2. Need to save initial address of pColor
+ *
+ * 3. Need to save initial address of pCompressed
+ */
+
+ for (i = 0; i < nColors; i++) {
+
+ /* Make sure format is XcmsCIEXYZFormat */
+ if (pColor->format != XcmsCIEXYZFormat) {
+ return(XcmsFailure);
+ }
+
+ /* Multiply [A]-1 * [XYZ] to get RGB intensity */
+ _XcmsMatVec((XcmsFloat *) pScreenData->XYZtoRGBmatrix,
+ (XcmsFloat *) &pColor->spec, tmp);
+
+ if ((MIN3 (tmp[0], tmp[1], tmp[2]) < -EPS) ||
+ (MAX3 (tmp[0], tmp[1], tmp[2]) > (1.0 + EPS))) {
+
+ /*
+ * RGBi out of screen's gamut
+ */
+
+ if (ccc->gamutCompProc == NULL) {
+ /*
+ * Aha!! Here's that little trick that will allow
+ * gamut compression routines to get the out of bound
+ * RGBi.
+ */
+ memcpy((char *)&pColor->spec, (char *)tmp, sizeof(tmp));
+ pColor->format = XcmsRGBiFormat;
+ return(XcmsFailure);
+ } else if ((*ccc->gamutCompProc)(ccc, pXcmsColors_in_out, nColors,
+ i, pCompressed) == 0) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * The gamut compression function should return colors in CIEXYZ
+ * Also check again to if the new color is within gamut.
+ */
+ if (pColor->format != XcmsCIEXYZFormat) {
+ return(XcmsFailure);
+ }
+ _XcmsMatVec((XcmsFloat *) pScreenData->XYZtoRGBmatrix,
+ (XcmsFloat *) &pColor->spec, tmp);
+ if ((MIN3 (tmp[0], tmp[1], tmp[2]) < -EPS) ||
+ (MAX3 (tmp[0], tmp[1], tmp[2]) > (1.0 + EPS))) {
+ return(XcmsFailure);
+ }
+ hasCompressed++;
+ }
+ memcpy((char *)&pColor->spec, (char *)tmp, sizeof(tmp));
+ /* These if statements are done to ensure the fudge factor is */
+ /* is taken into account. */
+ if (pColor->spec.RGBi.red < 0.0) {
+ pColor->spec.RGBi.red = 0.0;
+ } else if (pColor->spec.RGBi.red > 1.0) {
+ pColor->spec.RGBi.red = 1.0;
+ }
+ if (pColor->spec.RGBi.green < 0.0) {
+ pColor->spec.RGBi.green = 0.0;
+ } else if (pColor->spec.RGBi.green > 1.0) {
+ pColor->spec.RGBi.green = 1.0;
+ }
+ if (pColor->spec.RGBi.blue < 0.0) {
+ pColor->spec.RGBi.blue = 0.0;
+ } else if (pColor->spec.RGBi.blue > 1.0) {
+ pColor->spec.RGBi.blue = 1.0;
+ }
+ (pColor++)->format = XcmsRGBiFormat;
+ }
+ return (hasCompressed ? XcmsSuccessWithCompression : XcmsSuccess);
+}
+
+
+/*
+ * NAME
+ * LINEAR_RGBi_to_CIEXYZ - convert RGBi to CIEXYZ
+ *
+ * SYNOPSIS
+ */
+/* ARGSUSED */
+Status
+XcmsRGBiToCIEXYZ(
+ XcmsCCC ccc,
+ XcmsColor *pXcmsColors_in_out,/* pointer to XcmsColors to convert */
+ unsigned int nColors, /* Number of colors */
+ Bool *pCompressed) /* pointer to a bit array */
+/*
+ * DESCRIPTION
+ * Converts color specifications in an array of XcmsColor
+ * structures from RGBi format to CIEXYZ format.
+ *
+ * RETURNS
+ * XcmsFailure if failed,
+ * XcmsSuccess if succeeded.
+ */
+{
+ LINEAR_RGB_SCCData *pScreenData;
+ XcmsFloat tmp[3];
+
+ /*
+ * pCompressed ignored in this function.
+ */
+
+ if (ccc == NULL) {
+ return(XcmsFailure);
+ }
+
+ pScreenData = (LINEAR_RGB_SCCData *)ccc->pPerScrnInfo->screenData;
+
+ /*
+ * XcmsColors should be White Point Adjusted, if necessary, by now!
+ */
+
+ while (nColors--) {
+
+ /* Multiply [A]-1 * [XYZ] to get RGB intensity */
+ _XcmsMatVec((XcmsFloat *) pScreenData->RGBtoXYZmatrix,
+ (XcmsFloat *) &pXcmsColors_in_out->spec, tmp);
+
+ memcpy((char *)&pXcmsColors_in_out->spec, (char *)tmp, sizeof(tmp));
+ (pXcmsColors_in_out++)->format = XcmsCIEXYZFormat;
+ }
+ return(XcmsSuccess);
+}
+
+
+/*
+ * NAME
+ * XcmsRGBiToRGB
+ *
+ * SYNOPSIS
+ */
+/* ARGSUSED */
+Status
+XcmsRGBiToRGB(
+ XcmsCCC ccc,
+ XcmsColor *pXcmsColors_in_out,/* pointer to XcmsColors to convert */
+ unsigned int nColors, /* Number of colors */
+ Bool *pCompressed) /* pointer to a bit array */
+/*
+ * DESCRIPTION
+ * Converts color specifications in an array of XcmsColor
+ * structures from RGBi format to RGB format.
+ *
+ * RETURNS
+ * XcmsFailure if failed,
+ * XcmsSuccess if succeeded without gamut compression.
+ * XcmsSuccessWithCompression if succeeded with gamut
+ * compression.
+ */
+{
+ LINEAR_RGB_SCCData *pScreenData;
+ XcmsRGB tmpRGB;
+ IntensityRec keyIRec, answerIRec;
+
+ /*
+ * pCompressed ignored in this function.
+ */
+
+ if (ccc == NULL) {
+ return(XcmsFailure);
+ }
+
+ pScreenData = (LINEAR_RGB_SCCData *)ccc->pPerScrnInfo->screenData;
+
+ while (nColors--) {
+
+ /* Make sure format is XcmsRGBiFormat */
+ if (pXcmsColors_in_out->format != XcmsRGBiFormat) {
+ return(XcmsFailure);
+ }
+
+ keyIRec.intensity = pXcmsColors_in_out->spec.RGBi.red;
+ if (!_XcmsTableSearch((char *)&keyIRec, ccc->visual->bits_per_rgb,
+ (char *)pScreenData->pRedTbl->pBase,
+ (unsigned)pScreenData->pRedTbl->nEntries,
+ (unsigned)sizeof(IntensityRec),
+ (comparProcp)_XcmsIntensityCmp, (interpolProcp)_XcmsIntensityInterpolation, (char *)&answerIRec)) {
+ return(XcmsFailure);
+ }
+ tmpRGB.red = answerIRec.value;
+
+ keyIRec.intensity = pXcmsColors_in_out->spec.RGBi.green;
+ if (!_XcmsTableSearch((char *)&keyIRec, ccc->visual->bits_per_rgb,
+ (char *)pScreenData->pGreenTbl->pBase,
+ (unsigned)pScreenData->pGreenTbl->nEntries,
+ (unsigned)sizeof(IntensityRec),
+ (comparProcp)_XcmsIntensityCmp, (interpolProcp)_XcmsIntensityInterpolation, (char *)&answerIRec)) {
+ return(XcmsFailure);
+ }
+ tmpRGB.green = answerIRec.value;
+
+ keyIRec.intensity = pXcmsColors_in_out->spec.RGBi.blue;
+ if (!_XcmsTableSearch((char *)&keyIRec, ccc->visual->bits_per_rgb,
+ (char *)pScreenData->pBlueTbl->pBase,
+ (unsigned)pScreenData->pBlueTbl->nEntries,
+ (unsigned)sizeof(IntensityRec),
+ (comparProcp)_XcmsIntensityCmp, (interpolProcp)_XcmsIntensityInterpolation, (char *)&answerIRec)) {
+ return(XcmsFailure);
+ }
+ tmpRGB.blue = answerIRec.value;
+
+ memcpy((char *)&pXcmsColors_in_out->spec, (char *)&tmpRGB, sizeof(XcmsRGB));
+ (pXcmsColors_in_out++)->format = XcmsRGBFormat;
+ }
+ return(XcmsSuccess);
+}
+
+
+/*
+ * NAME
+ * XcmsRGBToRGBi
+ *
+ * SYNOPSIS
+ */
+/* ARGSUSED */
+Status
+XcmsRGBToRGBi(
+ XcmsCCC ccc,
+ XcmsColor *pXcmsColors_in_out,/* pointer to XcmsColors to convert */
+ unsigned int nColors, /* Number of colors */
+ Bool *pCompressed) /* pointer to a bit array */
+/*
+ * DESCRIPTION
+ * Converts color specifications in an array of XcmsColor
+ * structures from RGB format to RGBi format.
+ *
+ * RETURNS
+ * XcmsFailure if failed,
+ * XcmsSuccess if succeeded.
+ */
+{
+ LINEAR_RGB_SCCData *pScreenData;
+ XcmsRGBi tmpRGBi;
+ IntensityRec keyIRec, answerIRec;
+
+ /*
+ * pCompressed ignored in this function.
+ */
+
+ if (ccc == NULL) {
+ return(XcmsFailure);
+ }
+
+ pScreenData = (LINEAR_RGB_SCCData *)ccc->pPerScrnInfo->screenData;
+
+ while (nColors--) {
+
+ /* Make sure format is XcmsRGBFormat */
+ if (pXcmsColors_in_out->format != XcmsRGBFormat) {
+ return(XcmsFailure);
+ }
+
+ keyIRec.value = pXcmsColors_in_out->spec.RGB.red;
+ if (!_XcmsTableSearch((char *)&keyIRec, ccc->visual->bits_per_rgb,
+ (char *)pScreenData->pRedTbl->pBase,
+ (unsigned)pScreenData->pRedTbl->nEntries,
+ (unsigned)sizeof(IntensityRec),
+ (comparProcp)_XcmsValueCmp, (interpolProcp)_XcmsValueInterpolation, (char *)&answerIRec)) {
+ return(XcmsFailure);
+ }
+ tmpRGBi.red = answerIRec.intensity;
+
+ keyIRec.value = pXcmsColors_in_out->spec.RGB.green;
+ if (!_XcmsTableSearch((char *)&keyIRec, ccc->visual->bits_per_rgb,
+ (char *)pScreenData->pGreenTbl->pBase,
+ (unsigned)pScreenData->pGreenTbl->nEntries,
+ (unsigned)sizeof(IntensityRec),
+ (comparProcp)_XcmsValueCmp, (interpolProcp)_XcmsValueInterpolation, (char *)&answerIRec)) {
+ return(XcmsFailure);
+ }
+ tmpRGBi.green = answerIRec.intensity;
+
+ keyIRec.value = pXcmsColors_in_out->spec.RGB.blue;
+ if (!_XcmsTableSearch((char *)&keyIRec, ccc->visual->bits_per_rgb,
+ (char *)pScreenData->pBlueTbl->pBase,
+ (unsigned)pScreenData->pBlueTbl->nEntries,
+ (unsigned)sizeof(IntensityRec),
+ (comparProcp)_XcmsValueCmp, (interpolProcp)_XcmsValueInterpolation, (char *)&answerIRec)) {
+ return(XcmsFailure);
+ }
+ tmpRGBi.blue = answerIRec.intensity;
+
+ memcpy((char *)&pXcmsColors_in_out->spec, (char *)&tmpRGBi, sizeof(XcmsRGBi));
+ (pXcmsColors_in_out++)->format = XcmsRGBiFormat;
+ }
+ return(XcmsSuccess);
+}
+
+/*
+ * NAME
+ * _XcmsInitScrnDefaultInfo
+ *
+ * SYNOPSIS
+ */
+/* ARGSUSED */
+int
+_XcmsLRGB_InitScrnDefault(
+ Display *dpy,
+ int screenNumber,
+ XcmsPerScrnInfo *pPerScrnInfo)
+/*
+ * DESCRIPTION
+ * Given a display and screen number, this routine attempts
+ * to initialize the Xcms per Screen Info structure
+ * (XcmsPerScrnInfo) with defaults.
+ *
+ * RETURNS
+ * Returns zero if initialization failed; non-zero otherwise.
+ */
+{
+ pPerScrnInfo->screenData = (XPointer)&Default_RGB_SCCData;
+ pPerScrnInfo->screenWhitePt.spec.CIEXYZ.X =
+ Default_RGB_SCCData.RGBtoXYZmatrix[0][0] +
+ Default_RGB_SCCData.RGBtoXYZmatrix[0][1] +
+ Default_RGB_SCCData.RGBtoXYZmatrix[0][2];
+ pPerScrnInfo->screenWhitePt.spec.CIEXYZ.Y =
+ Default_RGB_SCCData.RGBtoXYZmatrix[1][0] +
+ Default_RGB_SCCData.RGBtoXYZmatrix[1][1] +
+ Default_RGB_SCCData.RGBtoXYZmatrix[1][2];
+ pPerScrnInfo->screenWhitePt.spec.CIEXYZ.Z =
+ Default_RGB_SCCData.RGBtoXYZmatrix[2][0] +
+ Default_RGB_SCCData.RGBtoXYZmatrix[2][1] +
+ Default_RGB_SCCData.RGBtoXYZmatrix[2][2];
+ if ((pPerScrnInfo->screenWhitePt.spec.CIEXYZ.Y < (1.0 - EPS) )
+ || (pPerScrnInfo->screenWhitePt.spec.CIEXYZ.Y > (1.0 + EPS))) {
+ pPerScrnInfo->screenData = (XPointer)NULL;
+ pPerScrnInfo->state = XcmsInitNone;
+ return(0);
+ }
+ pPerScrnInfo->screenWhitePt.spec.CIEXYZ.Y = 1.0;
+ pPerScrnInfo->screenWhitePt.format = XcmsCIEXYZFormat;
+ pPerScrnInfo->screenWhitePt.pixel = 0;
+ pPerScrnInfo->functionSet = (XPointer)&XcmsLinearRGBFunctionSet;
+ pPerScrnInfo->state = XcmsInitFailure; /* default initialization */
+ return(1);
+}
diff --git a/nx-X11/lib/src/xcms/Lab.c b/nx-X11/lib/src/xcms/Lab.c
new file mode 100644
index 000000000..6f7075643
--- /dev/null
+++ b/nx-X11/lib/src/xcms/Lab.c
@@ -0,0 +1,431 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of XCMS based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ * NAME
+ * CIELab.c
+ *
+ * DESCRIPTION
+ * This file contains routines that support the CIE L*a*b*
+ * color space to include conversions to and from the CIE
+ * XYZ space. These conversions are from Principles of
+ * Color Technology Second Edition, Fred W. Billmeyer, Jr.
+ * and Max Saltzman, John Wiley & Sons, Inc., 1981.
+ *
+ * Note that the range for L* is 0 to 1.
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <nx-X11/Xos.h>
+#include <stdio.h> /* sscanf */
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+/*
+ * DEFINES
+ * Internal definitions that need NOT be exported to any package
+ * or program using this package.
+ */
+#ifdef DBL_EPSILON
+# define XMY_DBL_EPSILON DBL_EPSILON
+#else
+# define XMY_DBL_EPSILON 0.00001
+#endif
+#define DIV16BY116 0.137931
+
+/*
+ * FORWARD DECLARATIONS
+ */
+
+static int CIELab_ParseString(register char *spec, XcmsColor *pColor);
+static Status XcmsCIELab_ValidSpec(XcmsColor *pColor);
+
+
+/*
+ * LOCAL VARIABLES
+ */
+
+
+ /*
+ * NULL terminated list of functions applied to get from CIELab to CIEXYZ
+ */
+static XcmsConversionProc Fl_CIELab_to_CIEXYZ[] = {
+ XcmsCIELabToCIEXYZ,
+ NULL
+};
+
+ /*
+ * NULL terminated list of functions applied to get from CIEXYZ to CIELab
+ */
+static XcmsConversionProc Fl_CIEXYZ_to_CIELab[] = {
+ XcmsCIEXYZToCIELab,
+ NULL
+};
+
+
+/*
+ * GLOBALS
+ */
+ /*
+ * CIE Lab Color Space
+ */
+XcmsColorSpace XcmsCIELabColorSpace =
+ {
+ _XcmsCIELab_prefix, /* prefix */
+ XcmsCIELabFormat, /* id */
+ CIELab_ParseString, /* parseString */
+ Fl_CIELab_to_CIEXYZ, /* to_CIEXYZ */
+ Fl_CIEXYZ_to_CIELab, /* from_CIEXYZ */
+ 1
+ };
+
+
+/************************************************************************
+ * *
+ * PRIVATE ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * CIELab_ParseString
+ *
+ * SYNOPSIS
+ */
+static int
+CIELab_ParseString(
+ register char *spec,
+ XcmsColor *pColor)
+/*
+ * DESCRIPTION
+ * This routines takes a string and attempts to convert
+ * it into a XcmsColor structure with XcmsCIELabFormat.
+ * The assumed CIELab string syntax is:
+ * CIELab:<L>/<a>/<b>
+ * Where L, a, and b are in string input format for floats
+ * consisting of:
+ * a. an optional sign
+ * b. a string of numbers possibly containing a decimal point,
+ * c. an optional exponent field containing an 'E' or 'e'
+ * followed by a possibly signed integer string.
+ *
+ * RETURNS
+ * 0 if failed, non-zero otherwise.
+ */
+{
+ int n;
+ char *pchar;
+
+ if ((pchar = strchr(spec, ':')) == NULL) {
+ return(XcmsFailure);
+ }
+ n = (int)(pchar - spec);
+
+ /*
+ * Check for proper prefix.
+ */
+ if (strncmp(spec, _XcmsCIELab_prefix, n) != 0) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Attempt to parse the value portion.
+ */
+ if (sscanf(spec + n + 1, "%lf/%lf/%lf",
+ &pColor->spec.CIELab.L_star,
+ &pColor->spec.CIELab.a_star,
+ &pColor->spec.CIELab.b_star) != 3) {
+ char *s; /* Maybe failed due to locale */
+ int f;
+ if ((s = strdup(spec))) {
+ for (f = 0; s[f]; ++f)
+ if (s[f] == '.')
+ s[f] = ',';
+ else if (s[f] == ',')
+ s[f] = '.';
+ if (sscanf(s + n + 1, "%lf/%lf/%lf",
+ &pColor->spec.CIELab.L_star,
+ &pColor->spec.CIELab.a_star,
+ &pColor->spec.CIELab.b_star) != 3) {
+ free(s);
+ return(XcmsFailure);
+ }
+ free(s);
+ } else
+ return(XcmsFailure);
+ }
+ pColor->format = XcmsCIELabFormat;
+ pColor->pixel = 0;
+
+ return(XcmsCIELab_ValidSpec(pColor));
+}
+
+
+
+/************************************************************************
+ * *
+ * PUBLIC ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsCIELab_ValidSpec
+ *
+ * SYNOPSIS
+ */
+static Status
+XcmsCIELab_ValidSpec(
+ XcmsColor *pColor)
+/*
+ * DESCRIPTION
+ * Checks if color specification valid for CIE L*a*b*.
+ *
+ * RETURNS
+ * XcmsFailure if invalid,
+ * XcmsSuccess if valid.
+ *
+ */
+{
+ if (pColor->format != XcmsCIELabFormat
+ ||
+ (pColor->spec.CIELab.L_star < 0.0 - XMY_DBL_EPSILON)
+ ||
+ (pColor->spec.CIELab.L_star > 100.0 + XMY_DBL_EPSILON)) {
+ return(XcmsFailure);
+ }
+ return(XcmsSuccess);
+}
+
+
+/*
+ * NAME
+ * XcmsCIELabToCIEXYZ - convert CIELab to CIEXYZ
+ *
+ * SYNOPSIS
+ */
+Status
+XcmsCIELabToCIEXYZ(
+ XcmsCCC ccc,
+ XcmsColor *pLab_WhitePt,
+ XcmsColor *pColors_in_out,
+ unsigned int nColors)
+/*
+ * DESCRIPTION
+ * Converts color specifications in an array of XcmsColor
+ * structures from CIELab format to CIEXYZ format.
+ *
+ * WARNING: This routine assumes that Yn = 1.0;
+ *
+ * RETURNS
+ * XcmsFailure if failed,
+ * XcmsSuccess if succeeded.
+ *
+ */
+{
+ XcmsCIEXYZ XYZ_return;
+ XcmsFloat tmpFloat, tmpL;
+ XcmsColor whitePt;
+ unsigned int i;
+ XcmsColor *pColor = pColors_in_out;
+
+ /*
+ * Check arguments
+ */
+ if (pLab_WhitePt == NULL || pColors_in_out == NULL) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Make sure white point is in CIEXYZ form, if not, convert it.
+ */
+ if (pLab_WhitePt->format != XcmsCIEXYZFormat) {
+ /* Make a copy of the white point because we're going to modify it */
+ memcpy((char *)&whitePt, (char *)pLab_WhitePt, sizeof(XcmsColor));
+ if (!_XcmsDIConvertColors(ccc, &whitePt,
+ (XcmsColor *)NULL, 1, XcmsCIEXYZFormat)) {
+ return(XcmsFailure);
+ }
+ pLab_WhitePt = &whitePt;
+ }
+
+ /*
+ * Make sure it is a white point, i.e., Y == 1.0
+ */
+ if (pLab_WhitePt->spec.CIEXYZ.Y != 1.0) {
+ return (0);
+ }
+
+ /*
+ * Now convert each XcmsColor structure to CIEXYZ form
+ */
+ for (i = 0; i < nColors; i++, pColor++) {
+
+ /* Make sure original format is CIELab */
+ if (!XcmsCIELab_ValidSpec(pColor)) {
+ return(XcmsFailure);
+ }
+
+ /* Calculate Y: assume that Yn = 1.0 */
+ tmpL = (pColor->spec.CIELab.L_star + 16.0) / 116.0;
+ XYZ_return.Y = tmpL * tmpL * tmpL;
+
+ if (XYZ_return.Y < 0.008856) {
+ /* Calculate Y: assume that Yn = 1.0 */
+ tmpL = pColor->spec.CIELab.L_star / 9.03292;
+
+ /* Calculate X */
+ XYZ_return.X = pLab_WhitePt->spec.CIEXYZ.X *
+ ((pColor->spec.CIELab.a_star / 3893.5) + tmpL);
+ /* Calculate Y */
+ XYZ_return.Y = tmpL;
+ /* Calculate Z */
+ XYZ_return.Z = pLab_WhitePt->spec.CIEXYZ.Z *
+ (tmpL - (pColor->spec.CIELab.b_star / 1557.4));
+ } else {
+ /* Calculate X */
+ tmpFloat = tmpL + (pColor->spec.CIELab.a_star / 5.0);
+ XYZ_return.X = pLab_WhitePt->spec.CIEXYZ.X * tmpFloat * tmpFloat * tmpFloat;
+
+ /* Calculate Z */
+ tmpFloat = tmpL - (pColor->spec.CIELab.b_star / 2.0);
+ XYZ_return.Z = pLab_WhitePt->spec.CIEXYZ.Z * tmpFloat * tmpFloat * tmpFloat;
+ }
+
+ memcpy((char *)&pColor->spec.CIEXYZ, (char *)&XYZ_return,
+ sizeof(XcmsCIEXYZ));
+ pColor->format = XcmsCIEXYZFormat;
+ }
+
+ return (1);
+}
+
+
+/*
+ * NAME
+ * XcmsCIEXYZToCIELab - convert CIEXYZ to CIELab
+ *
+ * SYNOPSIS
+ */
+Status
+XcmsCIEXYZToCIELab(
+ XcmsCCC ccc,
+ XcmsColor *pLab_WhitePt,
+ XcmsColor *pColors_in_out,
+ unsigned int nColors)
+/*
+ * DESCRIPTION
+ * Converts color specifications in an array of XcmsColor
+ * structures from CIEXYZ format to CIELab format.
+ *
+ * WARNING: This routine assumes that Yn = 1.0;
+ *
+ * RETURNS
+ * XcmsFailure if failed,
+ * XcmsSuccess if succeeded.
+ *
+ */
+{
+ XcmsCIELab Lab_return;
+ XcmsFloat fX_Xn, fY_Yn, fZ_Zn;
+ XcmsColor whitePt;
+ unsigned int i;
+ XcmsColor *pColor = pColors_in_out;
+
+ /*
+ * Check arguments
+ */
+ if (pLab_WhitePt == NULL || pColors_in_out == NULL) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Make sure white point is in CIEXYZ form, if not, convert it.
+ */
+ if (pLab_WhitePt->format != XcmsCIEXYZFormat) {
+ /* Make a copy of the white point because we're going to modify it */
+ memcpy((char *)&whitePt, (char *)pLab_WhitePt, sizeof(XcmsColor));
+ if (!_XcmsDIConvertColors(ccc, &whitePt, (XcmsColor *)NULL,
+ 1, XcmsCIEXYZFormat)) {
+ return(XcmsFailure);
+ }
+ pLab_WhitePt = &whitePt;
+ }
+
+ /*
+ * Make sure it is a white point, i.e., Y == 1.0
+ */
+ if (pLab_WhitePt->spec.CIEXYZ.Y != 1.0) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Now convert each XcmsColor structure to CIEXYZ form
+ */
+ for (i = 0; i < nColors; i++, pColor++) {
+
+ /* Make sure original format is CIELab */
+ if (!_XcmsCIEXYZ_ValidSpec(pColor)) {
+ return(XcmsFailure);
+ }
+
+ /* Calculate L*: assume Yn = 1.0 */
+ if (pColor->spec.CIEXYZ.Y < 0.008856) {
+ fY_Yn = (0.07787 * pColor->spec.CIEXYZ.Y) + DIV16BY116;
+ /* note fY_Yn used to compute Lab_return.a below */
+ Lab_return.L_star = 116.0 * (fY_Yn - DIV16BY116);
+ } else {
+ fY_Yn = (XcmsFloat)XCMS_CUBEROOT(pColor->spec.CIEXYZ.Y);
+ /* note fY_Yn used to compute Lab_return.a_star below */
+ Lab_return.L_star = (116.0 * fY_Yn) - 16.0;
+ }
+
+ /* Calculate f(X/Xn) */
+ if ((fX_Xn = pColor->spec.CIEXYZ.X / pLab_WhitePt->spec.CIEXYZ.X) < 0.008856) {
+ fX_Xn = (0.07787 * fX_Xn) + DIV16BY116;
+ } else {
+ fX_Xn = (XcmsFloat) XCMS_CUBEROOT(fX_Xn);
+ }
+
+ /* Calculate f(Z/Zn) */
+ if ((fZ_Zn = pColor->spec.CIEXYZ.Z / pLab_WhitePt->spec.CIEXYZ.Z) < 0.008856) {
+ fZ_Zn = (0.07787 * fZ_Zn) + DIV16BY116;
+ } else {
+ fZ_Zn = (XcmsFloat) XCMS_CUBEROOT(fZ_Zn);
+ }
+
+ Lab_return.a_star = 5.0 * (fX_Xn - fY_Yn);
+ Lab_return.b_star = 2.0 * (fY_Yn - fZ_Zn);
+
+ memcpy((char *)&pColor->spec.CIELab, (char *)&Lab_return,
+ sizeof(XcmsCIELab));
+ pColor->format = XcmsCIELabFormat;
+ }
+
+ return(XcmsSuccess);
+}
diff --git a/nx-X11/lib/src/xcms/LabGcC.c b/nx-X11/lib/src/xcms/LabGcC.c
new file mode 100644
index 000000000..a5ec9f457
--- /dev/null
+++ b/nx-X11/lib/src/xcms/LabGcC.c
@@ -0,0 +1,127 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of XCMS based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ * NAME
+ * CIELabGcC.c
+ *
+ * DESCRIPTION
+ * Source for XcmsCIELabClipuv() gamut compression routine.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+
+/************************************************************************
+ * *
+ * PUBLIC ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsCIELabClipab - Reduce the chroma for a hue and L*
+ *
+ * SYNOPSIS
+ */
+/* ARGSUSED */
+Status
+XcmsCIELabClipab (
+ XcmsCCC ccc,
+ XcmsColor *pColors_in_out,
+ unsigned int nColors,
+ unsigned int i,
+ Bool *pCompressed)
+/*
+ * DESCRIPTION
+ * Reduce the Chroma for a specific hue and chroma to
+ * to bring the given color into the gamut of the
+ * specified device. As required of gamut compression
+ * functions, this routine returns pColor_in_out
+ * in XcmsCIEXYZFormat on successful completion.
+ *
+ * Since this routine works with the L* within
+ * pColor_in_out intermediate results may be returned
+ * even though it may be invalid.
+ *
+ * RETURNS
+ * XcmsFailure - Failure
+ * XcmsSuccess - Succeeded
+ *
+ */
+{
+ Status retval;
+ XcmsColor *pColor;
+
+ /*
+ * Color specification passed as input can be assumed to:
+ * 1. Be in XcmsCIEXYZFormat
+ * 2. Already be white point adjusted for the Screen White Point.
+ * This means that the white point now associated with this
+ * color spec is the Screen White Point (even if the
+ * ccc->clientWhitePt differs).
+ */
+
+ pColor = pColors_in_out + i;
+
+ if (ccc->visual->class < PseudoColor) {
+ /*
+ * GRAY !
+ */
+ _XcmsDIConvertColors(ccc, pColor, ScreenWhitePointOfCCC(ccc),
+ 1, XcmsCIELabFormat);
+ _XcmsDIConvertColors(ccc, pColor, ScreenWhitePointOfCCC(ccc),
+ 1, XcmsCIEXYZFormat);
+ if (pCompressed) {
+ *(pCompressed + i) = True;
+ }
+ return(XcmsSuccess);
+ } else {
+ if (pColor->format != XcmsCIELabFormat) {
+ if (_XcmsDIConvertColors(ccc, pColor,
+ &ccc->pPerScrnInfo->screenWhitePt, 1, XcmsCIELabFormat)
+ == XcmsFailure) {
+ return(XcmsFailure);
+ }
+ }
+ if (XcmsCIELabQueryMaxC(ccc,
+ degrees(XCMS_CIELAB_PMETRIC_HUE(pColor->spec.CIELab.a_star,
+ pColor->spec.CIELab.b_star)),
+ pColor->spec.CIELab.L_star,
+ pColor) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+ retval = _XcmsDIConvertColors(ccc, pColor,
+ &ccc->pPerScrnInfo->screenWhitePt, 1, XcmsCIEXYZFormat);
+ if (retval != XcmsFailure && pCompressed != NULL) {
+ *(pCompressed + i) = True;
+ }
+ return(retval);
+ }
+}
diff --git a/nx-X11/lib/src/xcms/LabGcL.c b/nx-X11/lib/src/xcms/LabGcL.c
new file mode 100644
index 000000000..3038b18a8
--- /dev/null
+++ b/nx-X11/lib/src/xcms/LabGcL.c
@@ -0,0 +1,174 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of XCMS based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ * NAME
+ * CIELabGcL.c
+ *
+ * DESCRIPTION
+ * Source for XcmsCIELabClipL() gamut compression routine.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+
+/************************************************************************
+ * *
+ * PUBLIC ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsCIELabClipL - Return the closest L*
+ *
+ * SYNOPSIS
+ */
+/* ARGSUSED */
+Status
+XcmsCIELabClipL (
+ XcmsCCC ccc,
+ XcmsColor *pColors_in_out,
+ unsigned int nColors,
+ unsigned int i,
+ Bool *pCompressed)
+/*
+ * DESCRIPTION
+ * Return the closest L* for a specific hue and chroma.
+ * This routine takes any color as input and outputs
+ * a CIE XYZ color.
+ *
+ * Since this routine works with the L* within
+ * pColor_in_out intermediate results may be returned
+ * even though it may be invalid.
+ *
+ * RETURNS
+ * XcmsFailure - Failure
+ * XcmsSuccess - Succeeded
+ *
+ */
+{
+ XcmsCCCRec myCCC;
+ XcmsColor *pColor;
+ XcmsColor Lab_max;
+ XcmsFloat hue, chroma, maxChroma;
+ Status retval;
+
+ /* Use my own CCC */
+ memcpy ((char *)&myCCC, (char *)ccc, sizeof(XcmsCCCRec));
+ myCCC.clientWhitePt.format = XcmsUndefinedFormat;/* Inherit Screen WP */
+ myCCC.gamutCompProc = (XcmsCompressionProc)NULL;/* no gamut compression */
+
+ /*
+ * Color specification passed as input can be assumed to:
+ * 1. Be in XcmsCIEXYZFormat
+ * 2. Already be white point adjusted for the Screen White Point.
+ * This means that the white point now associated with this
+ * color spec is the Screen White Point (even if the
+ * ccc->clientWhitePt differs).
+ */
+
+ pColor = pColors_in_out + i;
+
+ if (ccc->visual->class < StaticColor) {
+ /*
+ * GRAY !
+ */
+ return(XcmsFailure);
+ } else {
+ /* Convert from CIEXYZ to CIE L*u*v* format */
+ if (_XcmsDIConvertColors(&myCCC, pColor,
+ ScreenWhitePointOfCCC(&myCCC), 1, XcmsCIELabFormat)
+ == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ hue = XCMS_CIELAB_PMETRIC_HUE(pColor->spec.CIELab.a_star,
+ pColor->spec.CIELab.b_star);
+ chroma = XCMS_CIELAB_PMETRIC_CHROMA(pColor->spec.CIELab.a_star,
+ pColor->spec.CIELab.b_star);
+ /* Step 1: compute the maximum L* and chroma for this hue. */
+ /* This copy may be overkill but it preserves the pixel etc. */
+ memcpy((char *)&Lab_max, (char *)pColor, sizeof(XcmsColor));
+ if (_XcmsCIELabQueryMaxLCRGB (&myCCC, hue, &Lab_max,
+ (XcmsRGBi *)NULL) == XcmsFailure) {
+ return (XcmsFailure);
+ }
+ maxChroma = XCMS_CIELAB_PMETRIC_CHROMA(Lab_max.spec.CIELab.a_star,
+ Lab_max.spec.CIELab.b_star);
+
+ /* Now check and return the appropriate L* */
+ if (chroma == maxChroma) {
+ /* When the chroma input is equal to the maximum chroma */
+ /* merely return the L* for that chroma. */
+ memcpy((char *)pColor, (char *)&Lab_max, sizeof(XcmsColor));
+ retval = _XcmsDIConvertColors(&myCCC, pColor,
+ ScreenWhitePointOfCCC(&myCCC), 1, XcmsCIEXYZFormat);
+ } else if (chroma > maxChroma) {
+ /* When the chroma input is greater than the maximum chroma */
+ /* merely return the L* and chroma for the given hue. */
+ memcpy((char *)pColor, (char *)&Lab_max, sizeof(XcmsColor));
+ return (XcmsFailure);
+ } else if (pColor->spec.CIELab.L_star < Lab_max.spec.CIELab.L_star) {
+ /* Find the minimum lightness for the given chroma. */
+ if (pColor->format != XcmsCIELabFormat) {
+ if (_XcmsDIConvertColors(ccc, pColor,
+ ScreenWhitePointOfCCC(ccc), 1, XcmsCIELabFormat)
+ == XcmsFailure) {
+ return(XcmsFailure);
+ }
+ }
+ if (XcmsCIELabQueryMinL(&myCCC, degrees(hue), chroma, pColor)
+ == XcmsFailure) {
+ return (XcmsFailure);
+ }
+ retval = _XcmsDIConvertColors(&myCCC, pColor,
+ ScreenWhitePointOfCCC(&myCCC), 1, XcmsCIEXYZFormat);
+ } else {
+ /* Find the maximum lightness for the given chroma. */
+ if (pColor->format != XcmsCIELabFormat) {
+ if (_XcmsDIConvertColors(ccc, pColor,
+ ScreenWhitePointOfCCC(ccc), 1, XcmsCIELabFormat)
+ == XcmsFailure) {
+ return(XcmsFailure);
+ }
+ }
+ if (XcmsCIELabQueryMaxL(&myCCC, degrees(hue), chroma, pColor)
+ == XcmsFailure) {
+ return (XcmsFailure);
+ }
+ retval = _XcmsDIConvertColors(&myCCC, pColor,
+ ScreenWhitePointOfCCC(&myCCC), 1, XcmsCIEXYZFormat);
+ }
+ if (retval != XcmsFailure && pCompressed != NULL) {
+ *(pCompressed + i) = True;
+ }
+ return(retval);
+ }
+}
diff --git a/nx-X11/lib/src/xcms/LabGcLC.c b/nx-X11/lib/src/xcms/LabGcLC.c
new file mode 100644
index 000000000..494d34e57
--- /dev/null
+++ b/nx-X11/lib/src/xcms/LabGcLC.c
@@ -0,0 +1,223 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of XCMS based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ * NAME
+ * CIELabGcLC.c
+ *
+ * DESCRIPTION
+ * Source for XcmsCIELabClipLab() gamut
+ * compression function.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include <math.h>
+#include "Cv.h"
+
+/*
+ * INTERNALS
+ * Internal defines that need NOT be exported to any package or
+ * program using this package.
+ */
+#define MAXBISECTCOUNT 100
+
+
+/************************************************************************
+ * *
+ * PUBLIC ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsCIELabClipLab - Return the closest L* and chroma
+ *
+ * SYNOPSIS
+ */
+/* ARGSUSED */
+Status
+XcmsCIELabClipLab (
+ XcmsCCC ccc,
+ XcmsColor *pColors_in_out,
+ unsigned int nColors,
+ unsigned int i,
+ Bool *pCompressed)
+/*
+ * DESCRIPTION
+ * This routine will find the closest L* and chroma
+ * for a specific hue. The color input is converted to
+ * CIE L*u*v* format and returned as CIE XYZ format.
+ *
+ * Since this routine works with the L* within
+ * pColor_in_out intermediate results may be returned
+ * even though it may be invalid.
+ *
+ * RETURNS
+ * XcmsFailure - Failure
+ * XcmsSuccess - Succeeded
+ *
+ */
+{
+ Status retval;
+ XcmsCCCRec myCCC;
+ XcmsColor *pColor;
+ XcmsColor Lab_max;
+ XcmsFloat hue, chroma, maxChroma;
+ XcmsFloat Chroma, bestChroma, Lstar, maxLstar, saveLstar;
+ XcmsFloat bestLstar, bestastar, bestbstar;
+ XcmsFloat nT, saveDist, tmpDist;
+ XcmsRGBi rgb_max;
+ int nCount, nMaxCount, nI, nILast;
+
+ /* Use my own CCC */
+ memcpy ((char *)&myCCC, (char *)ccc, sizeof(XcmsCCCRec));
+ myCCC.clientWhitePt.format = XcmsUndefinedFormat;/* inherit screen white */
+ myCCC.gamutCompProc = (XcmsCompressionProc)NULL;/* no gamut compression func */
+
+ /*
+ * Color specification passed as input can be assumed to:
+ * 1. Be in XcmsCIEXYZFormat
+ * 2. Already be white point adjusted for the Screen White Point.
+ * This means that the white point now associated with this
+ * color spec is the Screen White Point (even if the
+ * ccc->clientWhitePt differs).
+ */
+
+ pColor = pColors_in_out + i;
+
+ if (ccc->visual->class < StaticColor) {
+ /*
+ * GRAY !
+ */
+ _XcmsDIConvertColors(ccc, pColor, ScreenWhitePointOfCCC(ccc),
+ 1, XcmsCIELabFormat);
+ _XcmsDIConvertColors(ccc, pColor, ScreenWhitePointOfCCC(ccc),
+ 1, XcmsCIEXYZFormat);
+ if (pCompressed) {
+ *(pCompressed + i) = True;
+ }
+ return(XcmsSuccess);
+ }
+
+ /* Convert from CIEXYZ to CIELab format */
+ if (_XcmsDIConvertColors(&myCCC, pColor,
+ ScreenWhitePointOfCCC(&myCCC), 1, XcmsCIELabFormat)
+ == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ /* Step 1: compute the maximum L* and chroma for this hue. */
+ /* This copy may be overkill but it preserves the pixel etc. */
+ saveLstar = pColor->spec.CIELab.L_star;
+ hue = XCMS_CIELAB_PMETRIC_HUE(pColor->spec.CIELab.a_star,
+ pColor->spec.CIELab.b_star);
+ chroma = XCMS_CIELAB_PMETRIC_CHROMA(pColor->spec.CIELab.a_star,
+ pColor->spec.CIELab.b_star);
+ memcpy((char *)&Lab_max, (char *)pColor, sizeof(XcmsColor));
+ if (_XcmsCIELabQueryMaxLCRGB (&myCCC, hue, &Lab_max, &rgb_max)
+ == XcmsFailure) {
+ return (XcmsFailure);
+ }
+ maxLstar = Lab_max.spec.CIELab.L_star;
+
+ /* Now check and return the appropriate L* */
+ if (saveLstar == maxLstar) {
+ /* When the L* input is equal to the maximum L* */
+ /* merely return the maximum Lab point. */
+ memcpy((char *)pColor, (char *)&Lab_max, sizeof(XcmsColor));
+ retval = _XcmsDIConvertColors(&myCCC, pColor,
+ ScreenWhitePointOfCCC(&myCCC), 1, XcmsCIEXYZFormat);
+ } else {
+ /* return the closest point on the hue leaf. */
+ /* must do a bisection here to compute the delta e. */
+ maxChroma = XCMS_CIELAB_PMETRIC_CHROMA(Lab_max.spec.CIELab.a_star,
+ Lab_max.spec.CIELab.b_star);
+ nMaxCount = MAXBISECTCOUNT;
+ nI = nMaxCount / 2;
+ bestLstar = Lstar = pColor->spec.CIELab.L_star;
+ bestastar = pColor->spec.CIELab.a_star;
+ bestbstar = pColor->spec.CIELab.b_star;
+ bestChroma = Chroma = chroma;
+ saveDist = XCMS_SQRT(((Chroma - maxChroma) * (Chroma - maxChroma)) +
+ ((Lstar - maxLstar) * (Lstar - maxLstar)));
+ for (nCount = 0; nCount < nMaxCount; nCount++) {
+ nT = (XcmsFloat) nI / (XcmsFloat) nMaxCount;
+ if (saveLstar > maxLstar) {
+ pColor->spec.RGBi.red = rgb_max.red * (1.0 - nT) + nT;
+ pColor->spec.RGBi.green = rgb_max.green * (1.0 - nT) + nT;
+ pColor->spec.RGBi.blue = rgb_max.blue * (1.0 - nT) + nT;
+ } else {
+ pColor->spec.RGBi.red = rgb_max.red - (rgb_max.red * nT);
+ pColor->spec.RGBi.green = rgb_max.green - (rgb_max.green * nT);
+ pColor->spec.RGBi.blue = rgb_max.blue - (rgb_max.blue * nT);
+ }
+ pColor->format = XcmsRGBiFormat;
+
+ /* Convert from RGBi to CIE Lab */
+ if (_XcmsConvertColorsWithWhitePt(&myCCC, pColor,
+ ScreenWhitePointOfCCC(&myCCC), 1, XcmsCIELabFormat,
+ (Bool *) NULL) == XcmsFailure) {
+ return (XcmsFailure);
+ }
+ chroma = XCMS_CIELAB_PMETRIC_CHROMA(pColor->spec.CIELab.a_star,
+ pColor->spec.CIELab.b_star);
+ tmpDist = XCMS_SQRT(((Chroma - chroma) * (Chroma - chroma)) +
+ ((Lstar - pColor->spec.CIELab.L_star) *
+ (Lstar - pColor->spec.CIELab.L_star)));
+ nILast = nI;
+ if (tmpDist > saveDist) {
+ nI /= 2;
+ } else {
+ nI = (nMaxCount + nI) / 2;
+ saveDist = tmpDist;
+ bestLstar = pColor->spec.CIELab.L_star;
+ bestastar = pColor->spec.CIELab.a_star;
+ bestbstar = pColor->spec.CIELab.b_star;
+ bestChroma = chroma;
+ }
+ if (nI == nILast || nI == 0) {
+ break;
+ }
+ }
+ if (bestChroma >= maxChroma) {
+ pColor->spec.CIELab.L_star = maxLstar;
+ pColor->spec.CIELab.a_star = Lab_max.spec.CIELab.a_star;
+ pColor->spec.CIELab.b_star = Lab_max.spec.CIELab.b_star;
+ } else {
+ pColor->spec.CIELab.L_star = bestLstar;
+ pColor->spec.CIELab.a_star = bestastar;
+ pColor->spec.CIELab.b_star = bestbstar;
+ }
+ retval = _XcmsDIConvertColors(&myCCC, pColor,
+ ScreenWhitePointOfCCC(&myCCC), 1, XcmsCIEXYZFormat);
+
+ if (retval != XcmsFailure && pCompressed != NULL) {
+ *(pCompressed + i) = True;
+ }
+ }
+ return(retval);
+}
diff --git a/nx-X11/lib/src/xcms/LabMnL.c b/nx-X11/lib/src/xcms/LabMnL.c
new file mode 100644
index 000000000..18ff04cd1
--- /dev/null
+++ b/nx-X11/lib/src/xcms/LabMnL.c
@@ -0,0 +1,216 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of XCMS based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ * NAME
+ * CIELabMnL.c
+ *
+ * DESCRIPTION
+ * Source for the XcmsCIELabQueryMinL() gamut boundary
+ * querying routine.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include <math.h>
+#include "Cv.h"
+
+/*
+ * DEFINES
+ */
+#define MAXBISECTCOUNT 100
+#define EPS (XcmsFloat)0.001
+#define START_L_STAR (XcmsFloat)40.0
+
+
+/************************************************************************
+ * *
+ * PUBLIC ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsCIELabQueryMinL - Compute max Lstar for a hue and chroma
+ *
+ * SYNOPSIS
+ */
+Status
+XcmsCIELabQueryMinL(
+ XcmsCCC ccc,
+ XcmsFloat hue_angle, /* hue angle in degrees */
+ XcmsFloat chroma,
+ XcmsColor *pColor_return)
+/*
+ * DESCRIPTION
+ * Return the maximum Lstar for a specified hue_angle and chroma.
+ *
+ * ASSUMPTIONS
+ * This routine assumes that the white point associated with
+ * the color specification is the Screen White Point. The
+ * Screen White Point will also be associated with the
+ * returned color specification.
+ *
+ * RETURNS
+ * XcmsFailure - Failure
+ * XcmsSuccess - Succeeded with no modifications
+ *
+ */
+{
+ XcmsCCCRec myCCC;
+ XcmsColor max_lc, tmp, prev;
+ XcmsFloat max_chroma, tmp_chroma;
+ XcmsFloat hue, nT, nChroma, lastChroma, prevChroma;
+ XcmsFloat rFactor;
+ XcmsRGBi rgb_saved;
+ int nCount, nMaxCount;
+
+ /*
+ * Check Arguments
+ */
+ if (ccc == NULL || pColor_return == NULL) {
+ return(XcmsFailure);
+ }
+
+ /* setup the CCC to use for the conversions. */
+ memcpy ((char *) &myCCC, (char *) ccc, sizeof(XcmsCCCRec));
+ myCCC.clientWhitePt.format = XcmsUndefinedFormat;
+ myCCC.gamutCompProc = (XcmsCompressionProc) NULL;
+
+ while (hue_angle < 0.0) {
+ hue_angle += 360.0;
+ }
+ while (hue_angle >= 360.0) {
+ hue_angle -= 360.0;
+ }
+
+ hue = radians(hue_angle);
+ tmp.spec.CIELab.L_star = START_L_STAR;
+ tmp.spec.CIELab.a_star = XCMS_CIEASTAROFHUE(hue, chroma);
+ tmp.spec.CIELab.b_star = XCMS_CIEBSTAROFHUE(hue, chroma);
+ tmp.pixel = pColor_return->pixel;
+ tmp.format = XcmsCIELabFormat;
+
+ /* Step 1: Obtain the maximum L_star and chroma for this hue. */
+ if (_XcmsCIELabQueryMaxLCRGB(&myCCC, hue, &max_lc, &rgb_saved)
+ == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ max_chroma = XCMS_CIELAB_PMETRIC_CHROMA(max_lc.spec.CIELab.a_star,
+ max_lc.spec.CIELab.b_star);
+
+ if (max_chroma <= chroma) {
+ /*
+ * If the chroma is greater than the chroma for the
+ * maximum L/chroma point then the L_star is the
+ * the L_star for the maximum L_star/chroma point.
+ * This is an error but I return the best approximation I can.
+ * Thus the inconsistency.
+ */
+ memcpy ((char *) pColor_return, (char *) &max_lc, sizeof (XcmsColor));
+ return(XcmsSuccess);
+ }
+
+ /*
+ * If the chroma is equal to the chroma for the
+ * maximum L_star/chroma point then the L_star is the
+ * the L_star for the maximum L* and chroma point.
+ */
+ /* if (max_chroma == chroma) {
+ * memcpy ((char *) pColor_return, (char *) &max_lc, sizeof (XcmsColor));
+ * return(XcmsSuccess);
+ * }
+ */
+
+ /* must do a bisection here to compute the maximum L* */
+ /* save the structure input so that any elements that */
+ /* are not touched are recopied later in the routine. */
+ nChroma = chroma;
+ tmp_chroma = max_chroma;
+ lastChroma = -1.0;
+ nMaxCount = MAXBISECTCOUNT;
+ rFactor = 1.0;
+
+ for (nCount = 0; nCount < nMaxCount; nCount++) {
+ prevChroma = lastChroma;
+ lastChroma = tmp_chroma;
+ nT = (nChroma - max_chroma) / max_chroma * rFactor;
+ memcpy ((char *)&prev, (char *)&tmp, sizeof(XcmsColor));
+ tmp.spec.RGBi.red = rgb_saved.red + (rgb_saved.red * nT);
+ tmp.spec.RGBi.green = rgb_saved.green + (rgb_saved.green * nT);
+ tmp.spec.RGBi.blue = rgb_saved.blue + (rgb_saved.blue * nT);
+ tmp.format = XcmsRGBiFormat;
+
+ /* convert from RGB to CIELab */
+ if (_XcmsConvertColorsWithWhitePt(&myCCC, &tmp,
+ ScreenWhitePointOfCCC(&myCCC), 1, XcmsCIELabFormat,
+ (Bool *) NULL) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ /* Now check the return against what is expected */
+ tmp_chroma = XCMS_CIELAB_PMETRIC_CHROMA(tmp.spec.CIELab.a_star,
+ tmp.spec.CIELab.b_star);
+ if (tmp_chroma <= chroma + EPS && tmp_chroma >= chroma - EPS) {
+ /* Found It! */
+ memcpy ((char *) pColor_return, (char *) &tmp, sizeof (XcmsColor));
+ return(XcmsSuccess);
+ }
+ nChroma += chroma - tmp_chroma;
+ if (nChroma > max_chroma) {
+ nChroma = max_chroma;
+ rFactor *= 0.5; /* selective relaxation employed */
+ } else if (nChroma < 0.0) {
+ if (XCMS_FABS(lastChroma - chroma) <
+ XCMS_FABS(tmp_chroma - chroma)) {
+ memcpy ((char *)pColor_return, (char *)&prev,
+ sizeof(XcmsColor));
+ } else {
+ memcpy ((char *)pColor_return, (char *)&tmp,
+ sizeof(XcmsColor));
+ }
+ return(XcmsSuccess);
+ } else if (tmp_chroma <= prevChroma + EPS &&
+ tmp_chroma >= prevChroma - EPS) {
+ rFactor *= 0.5; /* selective relaxation employed */
+ }
+ }
+
+ if (nCount >= nMaxCount) {
+ if (XCMS_FABS(lastChroma - chroma) <
+ XCMS_FABS(tmp_chroma - chroma)) {
+ memcpy ((char *)pColor_return, (char *)&prev,
+ sizeof(XcmsColor));
+ } else {
+ memcpy ((char *)pColor_return, (char *)&tmp,
+ sizeof(XcmsColor));
+ }
+ }
+ memcpy ((char *) pColor_return, (char *) &tmp, sizeof (XcmsColor));
+ return(XcmsSuccess);
+}
diff --git a/nx-X11/lib/src/xcms/LabMxC.c b/nx-X11/lib/src/xcms/LabMxC.c
new file mode 100644
index 000000000..fcadd236a
--- /dev/null
+++ b/nx-X11/lib/src/xcms/LabMxC.c
@@ -0,0 +1,203 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of XCMS based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ *
+ * NAME
+ * CIELabMxC.c
+ *
+ * DESCRIPTION
+ * Source for the XcmsCIELabQueryMaxC() gamut boundary
+ * querying routine.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include <math.h>
+#include "Cv.h"
+
+/*
+ * DEFINES
+ */
+#define MAXBISECTCOUNT 100
+#define EPS (XcmsFloat)0.001
+#define START_CHROMA (XcmsFloat)3.6
+#define TOPL (XcmsFloat)100.0
+
+
+/************************************************************************
+ * *
+ * PUBLIC ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsCIELabQueryMaxC - max chroma for a hue_angle and L_star
+ *
+ * SYNOPSIS
+ */
+Status
+XcmsCIELabQueryMaxC(
+ XcmsCCC ccc,
+ XcmsFloat hue_angle, /* hue angle in degrees */
+ XcmsFloat L_star,
+ XcmsColor *pColor_return)
+/*
+ * DESCRIPTION
+ * Return the maximum chroma for a specific hue_angle and L_star.
+ * The returned format is in XcmsCIELabFormat.
+ *
+ *
+ * ASSUMPTIONS
+ * This routine assumes that the white point associated with
+ * the color specification is the Screen White Point. The
+ * Screen White Point will also be associated with the
+ * returned color specification.
+ *
+ * RETURNS
+ * XcmsFailure - Failure
+ * XcmsSuccess - Succeeded
+ *
+ */
+{
+ XcmsCCCRec myCCC;
+ XcmsColor tmp;
+ XcmsColor max_lc;
+ XcmsFloat n_L_star, last_L_star, prev_L_star;
+ XcmsFloat hue, lastaStar, lastbStar, /*lastChroma,*/ maxDist, nT, rFactor;
+ XcmsRGBi rgb_saved;
+ int nCount, nMaxCount;
+
+ /*
+ * Check Arguments
+ */
+ if (ccc == NULL || pColor_return == NULL) {
+ return(XcmsFailure);
+ }
+
+ /* Use my own CCC and inherit screen white Pt */
+ memcpy ((char *)&myCCC, (char *)ccc, sizeof(XcmsCCCRec));
+ myCCC.clientWhitePt.format = XcmsUndefinedFormat;
+ myCCC.gamutCompProc = (XcmsCompressionProc)NULL;/* no gamut comp func */
+
+ while (hue_angle < 0.0) {
+ hue_angle += 360.0;
+ }
+ while (hue_angle >= 360.0) {
+ hue_angle -= 360.0;
+ }
+
+ hue = radians(hue_angle);
+ tmp.spec.CIELab.L_star = L_star;
+ tmp.spec.CIELab.a_star = XCMS_CIEASTAROFHUE(hue, START_CHROMA);
+ tmp.spec.CIELab.b_star = XCMS_CIEBSTAROFHUE(hue, START_CHROMA);
+ tmp.pixel = pColor_return->pixel;
+ tmp.format = XcmsCIELabFormat;
+
+ /* Step 1: compute the maximum L_star and chroma for this hue. */
+ memcpy((char *)&max_lc, (char *)&tmp, sizeof(XcmsColor));
+ if (_XcmsCIELabQueryMaxLCRGB(&myCCC, hue, &max_lc, &rgb_saved)
+ == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Step 2: Do a bisection here to compute the maximum chroma
+ * Note the differences between when the point to be found
+ * is above the maximum LC point and when it is below.
+ */
+ if (L_star <= max_lc.spec.CIELab.L_star) {
+ maxDist = max_lc.spec.CIELab.L_star;
+ } else {
+ maxDist = TOPL - max_lc.spec.CIELab.L_star;
+ }
+
+ n_L_star = L_star;
+ last_L_star = -1.0;
+ nMaxCount = MAXBISECTCOUNT;
+ rFactor = 1.0;
+
+ for (nCount = 0; nCount < nMaxCount; nCount++) {
+ prev_L_star = last_L_star;
+ last_L_star = tmp.spec.CIELab.L_star;
+/* lastChroma = XCMS_CIELAB_PMETRIC_CHROMA(tmp.spec.CIELab.a_star, */
+/* tmp.spec.CIELab.b_star); */
+ lastaStar = tmp.spec.CIELab.a_star;
+ lastbStar = tmp.spec.CIELab.b_star;
+ nT = (n_L_star - max_lc.spec.CIELab.L_star) / maxDist * rFactor;
+ if (nT > 0) {
+ tmp.spec.RGBi.red = rgb_saved.red * (1.0 - nT) + nT;
+ tmp.spec.RGBi.green = rgb_saved.green * (1.0 - nT) + nT;
+ tmp.spec.RGBi.blue = rgb_saved.blue * (1.0 - nT) + nT;
+ } else {
+ tmp.spec.RGBi.red = rgb_saved.red + (rgb_saved.red * nT);
+ tmp.spec.RGBi.green = rgb_saved.green + (rgb_saved.green * nT);
+ tmp.spec.RGBi.blue = rgb_saved.blue + (rgb_saved.blue * nT);
+ }
+ tmp.format = XcmsRGBiFormat;
+
+ /* convert from RGB to CIELab */
+ if (_XcmsConvertColorsWithWhitePt(&myCCC, &tmp,
+ ScreenWhitePointOfCCC(&myCCC), 1, XcmsCIELabFormat,
+ (Bool *) NULL) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Now check if we've reached the target L_star
+ */
+ /* printf("result Lstar = %lf\n", tmp.spec.CIELab.L_star); */
+ if (tmp.spec.CIELab.L_star <= L_star + EPS &&
+ tmp.spec.CIELab.L_star >= L_star - EPS) {
+ memcpy((char *)pColor_return, (char *)&tmp, sizeof(XcmsColor));
+ return(XcmsSuccess);
+ }
+ if (nT > 0) {
+ n_L_star += ((TOPL - n_L_star) *
+ (L_star - tmp.spec.CIELab.L_star)) / (TOPL - L_star);
+ } else {
+ n_L_star *= L_star / tmp.spec.CIELuv.L_star;
+ }
+ if (tmp.spec.CIELab.L_star <= prev_L_star + EPS &&
+ tmp.spec.CIELab.L_star >= prev_L_star - EPS) {
+ rFactor *= 0.5; /* selective relaxation employed */
+ /* printf("rFactor = %lf\n", rFactor); */
+ }
+ }
+ if (XCMS_FABS(last_L_star - L_star) <
+ XCMS_FABS(tmp.spec.CIELab.L_star - L_star)) {
+ tmp.spec.CIELab.a_star = lastaStar;
+ tmp.spec.CIELab.b_star = lastbStar;
+/* tmp.spec.CIELab.a_star = XCMS_CIEASTAROFHUE(hue, lastChroma); */
+/* tmp.spec.CIELab.b_star = XCMS_CIEBSTAROFHUE(hue, lastChroma); */
+ }
+ tmp.spec.CIELab.L_star = L_star;
+ memcpy((char *)pColor_return, (char *)&tmp, sizeof(XcmsColor));
+ return(XcmsSuccess);
+}
diff --git a/nx-X11/lib/src/xcms/LabMxL.c b/nx-X11/lib/src/xcms/LabMxL.c
new file mode 100644
index 000000000..66ef48481
--- /dev/null
+++ b/nx-X11/lib/src/xcms/LabMxL.c
@@ -0,0 +1,216 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of XCMS based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ * NAME
+ * CIELabMxL.c
+ *
+ * DESCRIPTION
+ * Source for the XcmsCIELabQueryMaxL() gamut boundary
+ * querying routine.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include <math.h>
+#include "Cv.h"
+
+/*
+ * DEFINES
+ */
+#define MAXBISECTCOUNT 100
+#define EPS (XcmsFloat)0.001
+#define START_L_STAR (XcmsFloat)40
+
+
+/************************************************************************
+ * *
+ * PUBLIC ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsCIELabQueryMaxL - Compute max Lstar for a hue and chroma
+ *
+ * SYNOPSIS
+ */
+Status
+XcmsCIELabQueryMaxL(
+ XcmsCCC ccc,
+ XcmsFloat hue_angle, /* hue in degrees */
+ XcmsFloat chroma,
+ XcmsColor *pColor_return)
+/*
+ * DESCRIPTION
+ * Return the maximum Lstar for a specified hue_angle and chroma.
+ *
+ * ASSUMPTIONS
+ * This routine assumes that the white point associated with
+ * the color specification is the Screen White Point. The
+ * Screen White Point will also be associated with the
+ * returned color specification.
+ *
+ * RETURNS
+ * XcmsFailure - Failure
+ * XcmsSuccess - Succeeded with no modifications
+ *
+ */
+{
+ XcmsCCCRec myCCC;
+ XcmsColor max_lc, tmp, prev;
+ XcmsFloat max_chroma, tmp_chroma;
+ XcmsFloat hue, nT, nChroma, lastChroma, prevChroma;
+ XcmsFloat rFactor;
+ XcmsRGBi rgb_saved;
+ int nCount, nMaxCount;
+
+ /*
+ * Check Arguments
+ */
+ if (ccc == NULL || pColor_return == NULL) {
+ return(XcmsFailure);
+ }
+
+ /* setup the CCC to use for the conversions. */
+ memcpy ((char *) &myCCC, (char *) ccc, sizeof(XcmsCCCRec));
+ myCCC.clientWhitePt.format = XcmsUndefinedFormat;
+ myCCC.gamutCompProc = (XcmsCompressionProc) NULL;
+
+ while (hue_angle < 0.0) {
+ hue_angle += 360.0;
+ }
+ while (hue_angle >= 360.0) {
+ hue_angle -= 360.0;
+ }
+
+ hue = radians(hue_angle);
+ tmp.spec.CIELab.L_star = START_L_STAR;
+ tmp.spec.CIELab.a_star = XCMS_CIEASTAROFHUE(hue, chroma);
+ tmp.spec.CIELab.b_star = XCMS_CIEBSTAROFHUE(hue, chroma);
+ tmp.pixel = pColor_return->pixel;
+ tmp.format = XcmsCIELabFormat;
+
+ /* Step 1: Obtain the maximum L_star and chroma for this hue. */
+ if (_XcmsCIELabQueryMaxLCRGB(&myCCC, hue, &max_lc, &rgb_saved)
+ == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ max_chroma = XCMS_CIELAB_PMETRIC_CHROMA(max_lc.spec.CIELab.a_star,
+ max_lc.spec.CIELab.b_star);
+
+ if (max_chroma <= chroma) {
+ /*
+ * If the chroma is greater than the chroma for the
+ * maximum L/chroma point then the L_star is the
+ * the L_star for the maximum L_star/chroma point.
+ * This is an error but I return the best approximation I can.
+ * Thus the inconsistency.
+ */
+ memcpy ((char *) pColor_return, (char *) &max_lc, sizeof (XcmsColor));
+ return(XcmsSuccess);
+ }
+
+ /*
+ * If the chroma is equal to the chroma for the
+ * maximum L_star/chroma point then the L_star is the
+ * the L_star for the maximum L* and chroma point.
+ */
+ /* if (max_chroma == chroma) {
+ * memcpy ((char *) pColor_return, (char *) &max_lc, sizeof (XcmsColor));
+ * return(XcmsSuccess);
+ * }
+ */
+
+ /* must do a bisection here to compute the maximum L* */
+ /* save the structure input so that any elements that */
+ /* are not touched are recopied later in the routine. */
+ nChroma = chroma;
+ tmp_chroma = max_chroma;
+ lastChroma = -1.0;
+ nMaxCount = MAXBISECTCOUNT;
+ rFactor = 1.0;
+
+ for (nCount = 0; nCount < nMaxCount; nCount++) {
+ prevChroma = lastChroma;
+ lastChroma = tmp_chroma;
+ nT = (1.0 - (nChroma / max_chroma)) * rFactor;
+ memcpy ((char *)&prev, (char *)&tmp, sizeof(XcmsColor));
+ tmp.spec.RGBi.red = rgb_saved.red * (1.0 - nT) + nT;
+ tmp.spec.RGBi.green = rgb_saved.green * (1.0 - nT) + nT;
+ tmp.spec.RGBi.blue = rgb_saved.blue * (1.0 - nT) + nT;
+ tmp.format = XcmsRGBiFormat;
+
+ /* convert from RGB to CIELab */
+ if (_XcmsConvertColorsWithWhitePt(&myCCC, &tmp,
+ ScreenWhitePointOfCCC(&myCCC), 1, XcmsCIELabFormat,
+ (Bool *) NULL) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ /* Now check the return against what is expected */
+ tmp_chroma = XCMS_CIELAB_PMETRIC_CHROMA(tmp.spec.CIELab.a_star,
+ tmp.spec.CIELab.b_star);
+ if (tmp_chroma <= chroma + EPS && tmp_chroma >= chroma - EPS) {
+ /* Found It! */
+ memcpy ((char *) pColor_return, (char *) &tmp, sizeof (XcmsColor));
+ return(XcmsSuccess);
+ }
+ nChroma += chroma - tmp_chroma;
+ if (nChroma > max_chroma) {
+ nChroma = max_chroma;
+ rFactor *= 0.5; /* selective relaxation employed */
+ } else if (nChroma < 0.0) {
+ if (XCMS_FABS(lastChroma - chroma) <
+ XCMS_FABS(tmp_chroma - chroma)) {
+ memcpy ((char *)pColor_return, (char *)&prev,
+ sizeof(XcmsColor));
+ } else {
+ memcpy ((char *)pColor_return, (char *)&tmp,
+ sizeof(XcmsColor));
+ }
+ return(XcmsSuccess);
+ } else if (tmp_chroma <= prevChroma + EPS &&
+ tmp_chroma >= prevChroma - EPS) {
+ rFactor *= 0.5; /* selective relaxation employed */
+ }
+ }
+
+ if (nCount >= nMaxCount) {
+ if (XCMS_FABS(lastChroma - chroma) <
+ XCMS_FABS(tmp_chroma - chroma)) {
+ memcpy ((char *)pColor_return, (char *)&prev,
+ sizeof(XcmsColor));
+ } else {
+ memcpy ((char *)pColor_return, (char *)&tmp,
+ sizeof(XcmsColor));
+ }
+ }
+ memcpy ((char *) pColor_return, (char *) &tmp, sizeof (XcmsColor));
+ return(XcmsSuccess);
+}
diff --git a/nx-X11/lib/src/xcms/LabMxLC.c b/nx-X11/lib/src/xcms/LabMxLC.c
new file mode 100644
index 000000000..8cc089a22
--- /dev/null
+++ b/nx-X11/lib/src/xcms/LabMxLC.c
@@ -0,0 +1,218 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of XCMS based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ *
+ * NAME
+ * CIELabMxVC.c
+ *
+ * DESCRIPTION
+ * Source for the XcmsCIELabQueryMaxLC() gamut boundary
+ * querying routine.
+ *
+ * DOCUMENTATION
+ * "TekColor Color Management System, System Implementor's Manual"
+ * and
+ * Fred W. Billmeyer & Max Saltzman, "Principles of Color
+ * Technology", John Wily & Sons, Inc, 1981.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+/*
+ * DEFINES
+ */
+#define MIN(x,y) ((x) > (y) ? (y) : (x))
+#define MIN3(x,y,z) ((x) > (MIN((y), (z))) ? (MIN((y), (z))) : (x))
+#define MAX(x,y) ((x) > (y) ? (x) : (y))
+#define MAX3(x,y,z) ((x) > (MAX((y), (z))) ? (x) : (MAX((y), (z))))
+#define START_LSTAR (XcmsFloat)40.0
+#define START_CHROMA (XcmsFloat)3.6
+
+
+/************************************************************************
+ * *
+ * API PRIVATE ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * _XcmsCIELabQueryMaxLCRGB - Compute maximum L* and chroma.
+ *
+ * SYNOPSIS
+ */
+Status
+_XcmsCIELabQueryMaxLCRGB(
+ XcmsCCC ccc,
+ XcmsFloat hue, /* hue in radians */
+ XcmsColor *pColor_return,
+ XcmsRGBi *pRGB_return)
+/*
+ * DESCRIPTION
+ * Return the maximum psychometric chroma for a specified
+ * hue, and the corresponding L*. This is computed
+ * by a binary search of all possible chromas. An assumption
+ * is made that there are no local maxima. Use the unrounded
+ * Max psychometric chroma because the difference check can be
+ * small.
+ *
+ * NOTE: No local CCC is used because this is a private
+ * routine and all routines that call it are expected
+ * to behave properly, i.e. send a local CCC with
+ * no white adjust function and no gamut compression
+ * function.
+ *
+ * This routine only accepts hue in radians as input and outputs
+ * Lab and RGBi.
+ *
+ * RETURNS
+ * XcmsFailure - Failure
+ * XcmsSuccess - Succeeded
+ *
+ */
+{
+ XcmsFloat nSmall, nLarge;
+ XcmsColor tmp;
+
+ tmp.format = XcmsCIELabFormat;
+ /* Use some unreachable color on the given hue */
+ tmp.spec.CIELab.L_star = START_LSTAR;
+ tmp.spec.CIELab.a_star = XCMS_CIEASTAROFHUE(hue, START_CHROMA);
+ tmp.spec.CIELab.b_star = XCMS_CIEBSTAROFHUE(hue, START_CHROMA);
+ /*
+ * Convert from Lab to RGB
+ *
+ * Note that the CIEXYZ to RGBi conversion routine must stuff the
+ * out of bounds RGBi values in tmp when the ccc->gamutCompProc
+ * is NULL.
+ */
+ if ((_XcmsConvertColorsWithWhitePt(ccc, &tmp, ScreenWhitePointOfCCC(ccc),
+ (unsigned int)1, XcmsRGBiFormat, (Bool *) NULL)
+ == XcmsFailure) && tmp.format != XcmsRGBiFormat) {
+ return (XcmsFailure);
+ }
+
+ /* Now pick the smallest RGB */
+ nSmall = MIN3(tmp.spec.RGBi.red,
+ tmp.spec.RGBi.green,
+ tmp.spec.RGBi.blue);
+ /* Make the smallest RGB equal to zero */
+ tmp.spec.RGBi.red -= nSmall;
+ tmp.spec.RGBi.green -= nSmall;
+ tmp.spec.RGBi.blue -= nSmall;
+
+ /* Now pick the largest RGB */
+ nLarge = MAX3(tmp.spec.RGBi.red,
+ tmp.spec.RGBi.green,
+ tmp.spec.RGBi.blue);
+ /* Scale the RGB values based on the largest one */
+ tmp.spec.RGBi.red /= nLarge;
+ tmp.spec.RGBi.green /= nLarge;
+ tmp.spec.RGBi.blue /= nLarge;
+ tmp.format = XcmsRGBiFormat;
+
+ /* If the calling routine wants RGB value give them the ones used. */
+ if (pRGB_return) {
+ pRGB_return->red = tmp.spec.RGBi.red;
+ pRGB_return->green = tmp.spec.RGBi.green;
+ pRGB_return->blue = tmp.spec.RGBi.blue;
+ }
+
+ /* Convert from RGBi to Lab */
+ if (_XcmsConvertColorsWithWhitePt(ccc, &tmp,
+ ScreenWhitePointOfCCC(ccc), 1, XcmsCIELabFormat, (Bool *) NULL)
+ == XcmsFailure) {
+ return (XcmsFailure);
+ }
+
+ memcpy((char *)pColor_return, (char *)&tmp, sizeof(XcmsColor));
+ return (XcmsSuccess);
+}
+
+
+/************************************************************************
+ * *
+ * PUBLIC ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsCIELabQueryMaxLC - Compute maximum L* and chroma.
+ *
+ * SYNOPSIS
+ */
+Status
+XcmsCIELabQueryMaxLC (
+ XcmsCCC ccc,
+ XcmsFloat hue_angle, /* hue_angle in degrees */
+ XcmsColor *pColor_return)
+
+/*
+ * DESCRIPTION
+ * Return the point of maximum chroma for the specified
+ * hue_angle.
+ *
+ * ASSUMPTIONS
+ * This routine assumes that the white point associated with
+ * the color specification is the Screen White Point. The
+ * Screen White Point will also be associated with the
+ * returned color specification.
+ *
+ * RETURNS
+ * XcmsFailure - Failure
+ * XcmsSuccess - Succeeded
+ *
+ */
+{
+ XcmsCCCRec myCCC;
+
+ /*
+ * Check Arguments
+ */
+ if (ccc == NULL || pColor_return == NULL) {
+ return(XcmsFailure);
+ }
+
+ /* Use my own CCC */
+ memcpy ((char *)&myCCC, (char *)ccc, sizeof(XcmsCCCRec));
+ myCCC.clientWhitePt.format = XcmsUndefinedFormat;
+ myCCC.gamutCompProc = (XcmsCompressionProc)NULL;
+
+ while (hue_angle < 0.0) {
+ hue_angle += 360.0;
+ }
+ while (hue_angle >= 360.0) {
+ hue_angle -= 360.0;
+ }
+
+ return(_XcmsCIELabQueryMaxLCRGB (&myCCC, radians(hue_angle), pColor_return,
+ (XcmsRGBi *)NULL));
+}
diff --git a/nx-X11/lib/src/xcms/LabWpAj.c b/nx-X11/lib/src/xcms/LabWpAj.c
new file mode 100644
index 000000000..0559fdee3
--- /dev/null
+++ b/nx-X11/lib/src/xcms/LabWpAj.c
@@ -0,0 +1,97 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of XCMS based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ * NAME
+ * CIELabWpAj.c
+ *
+ * DESCRIPTION
+ * This file contains routine(s) that support white point
+ * adjustment of color specifications in the CIE L*a*b* color
+ * space.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+/*
+ * EXTERNS
+ */
+
+
+/************************************************************************
+ * *
+ * PUBLIC ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsCIELabWhiteShiftColors
+ *
+ * SYNOPSIS
+ */
+Status
+XcmsCIELabWhiteShiftColors(
+ XcmsCCC ccc,
+ XcmsColor *pWhitePtFrom,
+ XcmsColor *pWhitePtTo,
+ XcmsColorFormat destSpecFmt,
+ XcmsColor *pColors_in_out,
+ unsigned int nColors,
+ Bool *pCompressed)
+/*
+ * DESCRIPTION
+ * Adjust color specifications in XcmsColor structures for
+ * differences in white points.
+ *
+ * RETURNS
+ * XcmsFailure if failed,
+ * XcmsSuccess if succeeded without gamut compression,
+ * XcmsSuccessWithCompression if succeeded with gamut
+ * compression.
+ */
+{
+ if (pWhitePtFrom == NULL || pWhitePtTo == NULL || pColors_in_out == NULL) {
+ return(0);
+ }
+
+ /*
+ * Convert to CIELab using pWhitePtFrom
+ */
+ if (_XcmsConvertColorsWithWhitePt(ccc, pColors_in_out, pWhitePtFrom,
+ nColors, XcmsCIELabFormat, pCompressed) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Convert from CIELab to destSpecFmt using pWhitePtTo
+ */
+ return(_XcmsConvertColorsWithWhitePt(ccc, pColors_in_out,
+ pWhitePtTo, nColors, destSpecFmt, pCompressed));
+}
diff --git a/nx-X11/lib/src/xcms/Luv.c b/nx-X11/lib/src/xcms/Luv.c
new file mode 100644
index 000000000..2bce977ea
--- /dev/null
+++ b/nx-X11/lib/src/xcms/Luv.c
@@ -0,0 +1,401 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of XCMS based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ * NAME
+ * CIELuv.c
+ *
+ * DESCRIPTION
+ * This file contains routines that support the CIE L*u*v*
+ * color space to include conversions to and from the CIE
+ * XYZ space.
+ *
+ * DOCUMENTATION
+ * "TekColor Color Management System, System Implementor's Manual"
+ * and
+ * Fred W. Billmeyer & Max Saltzman, "Principles of Color
+ * Technology", John Wily & Sons, Inc, 1981.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <nx-X11/Xos.h>
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+#include <stdio.h> /* sscanf */
+
+
+/*
+ * FORWARD DECLARATIONS
+ */
+
+static int CIELuv_ParseString(register char *spec, XcmsColor *pColor);
+static Status XcmsCIELuv_ValidSpec(XcmsColor *pColor);
+
+/*
+ * DEFINES
+ * Internal definitions that need NOT be exported to any package
+ * or program using this package.
+ */
+#ifdef DBL_EPSILON
+# define XMY_DBL_EPSILON DBL_EPSILON
+#else
+# define XMY_DBL_EPSILON 0.00001
+#endif
+
+
+/*
+ * LOCAL VARIABLES
+ */
+
+ /*
+ * NULL terminated list of functions applied to get from CIELuv to CIEXYZ
+ */
+static XcmsConversionProc Fl_CIELuv_to_CIEXYZ[] = {
+ XcmsCIELuvToCIEuvY,
+ XcmsCIEuvYToCIEXYZ,
+ NULL
+};
+
+ /*
+ * NULL terminated list of functions applied to get from CIEXYZ to CIELuv
+ */
+static XcmsConversionProc Fl_CIEXYZ_to_CIELuv[] = {
+ XcmsCIEXYZToCIEuvY,
+ XcmsCIEuvYToCIELuv,
+ NULL
+};
+
+/*
+ * GLOBALS
+ */
+
+ /*
+ * CIE Luv Color Space
+ */
+XcmsColorSpace XcmsCIELuvColorSpace =
+ {
+ _XcmsCIELuv_prefix, /* prefix */
+ XcmsCIELuvFormat, /* id */
+ CIELuv_ParseString, /* parseString */
+ Fl_CIELuv_to_CIEXYZ, /* to_CIEXYZ */
+ Fl_CIEXYZ_to_CIELuv, /* from_CIEXYZ */
+ 1
+ };
+
+
+/************************************************************************
+ * *
+ * PRIVATE ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * CIELuv_ParseString
+ *
+ * SYNOPSIS
+ */
+static int
+CIELuv_ParseString(
+ register char *spec,
+ XcmsColor *pColor)
+/*
+ * DESCRIPTION
+ * This routines takes a string and attempts to convert
+ * it into a XcmsColor structure with XcmsCIELuvFormat.
+ * The assumed CIELuv string syntax is:
+ * CIELuv:<L>/<u>/<v>
+ * Where L, u, and v are in string input format for floats
+ * consisting of:
+ * a. an optional sign
+ * b. a string of numbers possibly containing a decimal point,
+ * c. an optional exponent field containing an 'E' or 'e'
+ * followed by a possibly signed integer string.
+ *
+ * RETURNS
+ * 0 if failed, non-zero otherwise.
+ */
+{
+ int n;
+ char *pchar;
+
+ if ((pchar = strchr(spec, ':')) == NULL) {
+ return(XcmsFailure);
+ }
+ n = (int)(pchar - spec);
+
+ /*
+ * Check for proper prefix.
+ */
+ if (strncmp(spec, _XcmsCIELuv_prefix, n) != 0) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Attempt to parse the value portion.
+ */
+ if (sscanf(spec + n + 1, "%lf/%lf/%lf",
+ &pColor->spec.CIELuv.L_star,
+ &pColor->spec.CIELuv.u_star,
+ &pColor->spec.CIELuv.v_star) != 3) {
+ char *s; /* Maybe failed due to locale */
+ int f;
+ if ((s = strdup(spec))) {
+ for (f = 0; s[f]; ++f)
+ if (s[f] == '.')
+ s[f] = ',';
+ else if (s[f] == ',')
+ s[f] = '.';
+ if (sscanf(s + n + 1, "%lf/%lf/%lf",
+ &pColor->spec.CIELuv.L_star,
+ &pColor->spec.CIELuv.u_star,
+ &pColor->spec.CIELuv.v_star) != 3) {
+ free(s);
+ return(XcmsFailure);
+ }
+ free(s);
+ } else
+ return(XcmsFailure);
+ }
+ pColor->format = XcmsCIELuvFormat;
+ pColor->pixel = 0;
+ return(XcmsCIELuv_ValidSpec(pColor));
+}
+
+
+/************************************************************************
+ * *
+ * PUBLIC ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsCIELuv_ValidSpec
+ *
+ * SYNOPSIS
+ */
+static Status
+XcmsCIELuv_ValidSpec(
+ XcmsColor *pColor)
+/*
+ * DESCRIPTION
+ * Checks if color specification valid for CIE L*u*v*.
+ *
+ * RETURNS
+ * XcmsFailure if invalid,
+ * XcmsSuccess if valid.
+ *
+ */
+{
+ if (pColor->format != XcmsCIELuvFormat
+ ||
+ (pColor->spec.CIELuv.L_star < 0.0 - XMY_DBL_EPSILON)
+ ||
+ (pColor->spec.CIELuv.L_star > 100.0 + XMY_DBL_EPSILON)) {
+ return(XcmsFailure);
+ }
+ return(XcmsSuccess);
+}
+
+
+/*
+ * NAME
+ * XcmsCIELuvToCIEuvY - convert CIELuv to CIEuvY
+ *
+ * SYNOPSIS
+ */
+Status
+XcmsCIELuvToCIEuvY(
+ XcmsCCC ccc,
+ XcmsColor *pLuv_WhitePt,
+ XcmsColor *pColors_in_out,
+ unsigned int nColors)
+/*
+ * DESCRIPTION
+ * Converts color specifications in an array of XcmsColor
+ * structures from CIELuv format to CIEuvY format.
+ *
+ * RETURNS
+ * XcmsFailure if failed,
+ * XcmsSuccess if succeeded.
+ *
+ */
+{
+ XcmsColor *pColor = pColors_in_out;
+ XcmsColor whitePt;
+ XcmsCIEuvY uvY_return;
+ XcmsFloat tmpVal;
+ unsigned int i;
+
+ /*
+ * Check arguments
+ */
+ if (pLuv_WhitePt == NULL || pColors_in_out == NULL) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Make sure white point is in CIEuvY form
+ */
+ if (pLuv_WhitePt->format != XcmsCIEuvYFormat) {
+ /* Make copy of the white point because we're going to modify it */
+ memcpy((char *)&whitePt, (char *)pLuv_WhitePt, sizeof(XcmsColor));
+ if (!_XcmsDIConvertColors(ccc, &whitePt, (XcmsColor *)NULL,
+ 1, XcmsCIEuvYFormat)) {
+ return(XcmsFailure);
+ }
+ pLuv_WhitePt = &whitePt;
+ }
+ /* Make sure it is a white point, i.e., Y == 1.0 */
+ if (pLuv_WhitePt->spec.CIEuvY.Y != 1.0) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Now convert each XcmsColor structure to CIEXYZ form
+ */
+ for (i = 0; i < nColors; i++, pColor++) {
+
+ /* Make sure original format is CIELuv and is valid */
+ if (!XcmsCIELuv_ValidSpec(pColor)) {
+ return(XcmsFailure);
+ }
+
+ if (pColor->spec.CIELuv.L_star < 7.99953624) {
+ uvY_return.Y = pColor->spec.CIELuv.L_star / 903.29;
+ } else {
+ tmpVal = (pColor->spec.CIELuv.L_star + 16.0) / 116.0;
+ uvY_return.Y = tmpVal * tmpVal * tmpVal; /* tmpVal ** 3 */
+ }
+
+
+
+ if (pColor->spec.CIELuv.L_star == 0.0) {
+ uvY_return.u_prime = pLuv_WhitePt->spec.CIEuvY.u_prime;
+ uvY_return.v_prime = pLuv_WhitePt->spec.CIEuvY.v_prime;
+ } else {
+ tmpVal = 13.0 * (pColor->spec.CIELuv.L_star / 100.0);
+ uvY_return.u_prime = pColor->spec.CIELuv.u_star/tmpVal +
+ pLuv_WhitePt->spec.CIEuvY.u_prime;
+ uvY_return.v_prime = pColor->spec.CIELuv.v_star/tmpVal +
+ pLuv_WhitePt->spec.CIEuvY.v_prime;
+ }
+ /* Copy result to pColor */
+ memcpy((char *)&pColor->spec, (char *)&uvY_return, sizeof(XcmsCIEuvY));
+
+ /* Identify that the format is now CIEuvY */
+ pColor->format = XcmsCIEuvYFormat;
+ }
+ return(XcmsSuccess);
+}
+
+
+/*
+ * NAME
+ * XcmsCIEuvYToCIELuv - convert CIEuvY to CIELuv
+ *
+ * SYNOPSIS
+ */
+Status
+XcmsCIEuvYToCIELuv(
+ XcmsCCC ccc,
+ XcmsColor *pLuv_WhitePt,
+ XcmsColor *pColors_in_out,
+ unsigned int nColors)
+/*
+ * DESCRIPTION
+ * Converts color specifications in an array of XcmsColor
+ * structures from CIEuvY format to CIELab format.
+ *
+ * RETURNS
+ * XcmsFailure if failed,
+ * XcmsSuccess if succeeded.
+ *
+ */
+{
+ XcmsColor *pColor = pColors_in_out;
+ XcmsColor whitePt;
+ XcmsCIELuv Luv_return;
+ XcmsFloat tmpVal;
+ unsigned int i;
+
+ /*
+ * Check arguments
+ */
+ if (pLuv_WhitePt == NULL || pColors_in_out == NULL) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Make sure white point is in CIEuvY form
+ */
+ if (pLuv_WhitePt->format != XcmsCIEuvYFormat) {
+ /* Make copy of the white point because we're going to modify it */
+ memcpy((char *)&whitePt, (char *)pLuv_WhitePt, sizeof(XcmsColor));
+ if (!_XcmsDIConvertColors(ccc, &whitePt,
+ (XcmsColor *)NULL, 1, XcmsCIEuvYFormat)) {
+ return(XcmsFailure);
+ }
+ pLuv_WhitePt = &whitePt;
+ }
+ /* Make sure it is a white point, i.e., Y == 1.0 */
+ if (pLuv_WhitePt->spec.CIEuvY.Y != 1.0) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Now convert each XcmsColor structure to CIEXYZ form
+ */
+ for (i = 0; i < nColors; i++, pColor++) {
+
+ if (!_XcmsCIEuvY_ValidSpec(pColor)) {
+ return(XcmsFailure);
+ }
+
+ /* Now convert the uvY to Luv */
+ Luv_return.L_star =
+ (pColor->spec.CIEuvY.Y < 0.008856)
+ ?
+ (pColor->spec.CIEuvY.Y * 903.29)
+ :
+ ((XcmsFloat)(XCMS_CUBEROOT(pColor->spec.CIEuvY.Y) * 116.0) - 16.0);
+ tmpVal = 13.0 * (Luv_return.L_star / 100.0);
+ Luv_return.u_star = tmpVal *
+ (pColor->spec.CIEuvY.u_prime - pLuv_WhitePt->spec.CIEuvY.u_prime);
+ Luv_return.v_star = tmpVal *
+ (pColor->spec.CIEuvY.v_prime - pLuv_WhitePt->spec.CIEuvY.v_prime);
+
+ /* Copy result to pColor */
+ memcpy((char *)&pColor->spec, (char *)&Luv_return, sizeof(XcmsCIELuv));
+
+ /* Identify that the format is now CIEuvY */
+ pColor->format = XcmsCIELuvFormat;
+ }
+ return(XcmsSuccess);
+}
diff --git a/nx-X11/lib/src/xcms/LuvGcC.c b/nx-X11/lib/src/xcms/LuvGcC.c
new file mode 100644
index 000000000..cadf4a8b2
--- /dev/null
+++ b/nx-X11/lib/src/xcms/LuvGcC.c
@@ -0,0 +1,127 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of XCMS based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ * NAME
+ * CIELuvGcC.c
+ *
+ * DESCRIPTION
+ * Source for XcmsCIELuvClipuv() gamut compression routine.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+
+/************************************************************************
+ * *
+ * PUBLIC ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsCIELuvClipuv - Reduce the chroma for a hue and L*
+ *
+ * SYNOPSIS
+ */
+/* ARGSUSED */
+Status
+XcmsCIELuvClipuv (
+ XcmsCCC ccc,
+ XcmsColor *pColors_in_out,
+ unsigned int nColors,
+ unsigned int i,
+ Bool *pCompressed)
+/*
+ * DESCRIPTION
+ * Reduce the Chroma for a specific hue and chroma to
+ * to bring the given color into the gamut of the
+ * specified device. As required of gamut compression
+ * functions, this routine returns pColor_in_out
+ * in XcmsCIEXYZFormat on successful completion.
+ *
+ * Since this routine works with the L* within
+ * pColor_in_out intermediate results may be returned
+ * even though it may be invalid.
+ *
+ * RETURNS
+ * XcmsFailure - Failure
+ * XcmsSuccess - Succeeded
+ *
+ */
+{
+ Status retval;
+ XcmsColor *pColor;
+
+ /*
+ * Color specification passed as input can be assumed to:
+ * 1. Be in XcmsCIEXYZFormat
+ * 2. Already be white point adjusted for the Screen White Point.
+ * This means that the white point now associated with this
+ * color spec is the Screen White Point (even if the
+ * ccc->clientWhitePt differs).
+ */
+
+ pColor = pColors_in_out + i;
+
+ if (ccc->visual->class < PseudoColor) {
+ /*
+ * GRAY !
+ */
+ _XcmsDIConvertColors(ccc, pColor, ScreenWhitePointOfCCC(ccc),
+ 1, XcmsCIELuvFormat);
+ _XcmsDIConvertColors(ccc, pColor, ScreenWhitePointOfCCC(ccc),
+ 1, XcmsCIEXYZFormat);
+ if (pCompressed) {
+ *(pCompressed + i) = True;
+ }
+ return(XcmsSuccess);
+ } else {
+ if (pColor->format != XcmsCIELuvFormat) {
+ if (_XcmsDIConvertColors(ccc, pColor,
+ &ccc->pPerScrnInfo->screenWhitePt, 1, XcmsCIELuvFormat)
+ == XcmsFailure) {
+ return(XcmsFailure);
+ }
+ }
+ if (XcmsCIELuvQueryMaxC(ccc,
+ degrees(XCMS_CIELUV_PMETRIC_HUE(pColor->spec.CIELuv.u_star,
+ pColor->spec.CIELuv.v_star)),
+ pColor->spec.CIELuv.L_star,
+ pColor) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+ retval = _XcmsDIConvertColors(ccc, pColor,
+ &ccc->pPerScrnInfo->screenWhitePt, 1, XcmsCIEXYZFormat);
+ if (retval != XcmsFailure && pCompressed != NULL) {
+ *(pCompressed + i) = True;
+ }
+ return(retval);
+ }
+}
diff --git a/nx-X11/lib/src/xcms/LuvGcL.c b/nx-X11/lib/src/xcms/LuvGcL.c
new file mode 100644
index 000000000..f5b6d99e4
--- /dev/null
+++ b/nx-X11/lib/src/xcms/LuvGcL.c
@@ -0,0 +1,174 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of XCMS based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ * NAME
+ * CIELuvGcL.c
+ *
+ * DESCRIPTION
+ * Source for XcmsCIELuvClipL() gamut compression routine.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+
+/************************************************************************
+ * *
+ * PUBLIC ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsCIELuvClipL - Return the closest L*
+ *
+ * SYNOPSIS
+ */
+/* ARGSUSED */
+Status
+XcmsCIELuvClipL (
+ XcmsCCC ccc,
+ XcmsColor *pColors_in_out,
+ unsigned int nColors,
+ unsigned int i,
+ Bool *pCompressed)
+/*
+ * DESCRIPTION
+ * Return the closest L* for a specific hue and chroma.
+ * This routine takes any color as input and outputs
+ * a CIE XYZ color.
+ *
+ * Since this routine works with the L* within
+ * pColor_in_out intermediate results may be returned
+ * even though it may be invalid.
+ *
+ * RETURNS
+ * XcmsFailure - Failure
+ * XcmsSuccess - Succeeded
+ *
+ */
+{
+ XcmsCCCRec myCCC;
+ XcmsColor *pColor;
+ XcmsColor Luv_max;
+ XcmsFloat hue, chroma, maxChroma;
+ Status retval;
+
+ /* Use my own CCC */
+ memcpy ((char *)&myCCC, (char *)ccc, sizeof(XcmsCCCRec));
+ myCCC.clientWhitePt.format = XcmsUndefinedFormat;/* Inherit Screen WP */
+ myCCC.gamutCompProc = (XcmsCompressionProc)NULL;/* no gamut compression */
+
+ /*
+ * Color specification passed as input can be assumed to:
+ * 1. Be in XcmsCIEXYZFormat
+ * 2. Already be white point adjusted for the Screen White Point.
+ * This means that the white point now associated with this
+ * color spec is the Screen White Point (even if the
+ * ccc->clientWhitePt differs).
+ */
+
+ pColor = pColors_in_out + i;
+
+ if (ccc->visual->class < StaticColor) {
+ /*
+ * GRAY !
+ */
+ return(XcmsFailure);
+ } else {
+ /* Convert from CIEXYZ to CIE L*u*v* format */
+ if (_XcmsDIConvertColors(&myCCC, pColor,
+ ScreenWhitePointOfCCC(&myCCC), 1, XcmsCIELuvFormat)
+ == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ hue = XCMS_CIELUV_PMETRIC_HUE(pColor->spec.CIELuv.u_star,
+ pColor->spec.CIELuv.v_star);
+ chroma = XCMS_CIELUV_PMETRIC_CHROMA(pColor->spec.CIELuv.u_star,
+ pColor->spec.CIELuv.v_star);
+ /* Step 1: compute the maximum L* and chroma for this hue. */
+ /* This copy may be overkill but it preserves the pixel etc. */
+ memcpy((char *)&Luv_max, (char *)pColor, sizeof(XcmsColor));
+ if (_XcmsCIELuvQueryMaxLCRGB (&myCCC, hue, &Luv_max,
+ (XcmsRGBi *)NULL) == XcmsFailure) {
+ return (XcmsFailure);
+ }
+ maxChroma = XCMS_CIELUV_PMETRIC_CHROMA(Luv_max.spec.CIELuv.u_star,
+ Luv_max.spec.CIELuv.v_star);
+
+ /* Now check and return the appropriate L* */
+ if (chroma == maxChroma) {
+ /* When the chroma input is equal to the maximum chroma */
+ /* merely return the L* for that chroma. */
+ memcpy((char *)pColor, (char *)&Luv_max, sizeof(XcmsColor));
+ retval = _XcmsDIConvertColors(&myCCC, pColor,
+ ScreenWhitePointOfCCC(&myCCC), 1, XcmsCIEXYZFormat);
+ } else if (chroma > maxChroma) {
+ /* When the chroma input is greater than the maximum chroma */
+ /* merely return the L* and chroma for the given hue. */
+ memcpy((char *)pColor, (char *)&Luv_max, sizeof(XcmsColor));
+ return (XcmsFailure);
+ } else if (pColor->spec.CIELuv.L_star < Luv_max.spec.CIELuv.L_star) {
+ /* Find the minimum lightness for the given chroma. */
+ if (pColor->format != XcmsCIELuvFormat) {
+ if (_XcmsDIConvertColors(ccc, pColor,
+ ScreenWhitePointOfCCC(ccc), 1, XcmsCIELuvFormat)
+ == XcmsFailure) {
+ return(XcmsFailure);
+ }
+ }
+ if (XcmsCIELuvQueryMinL(&myCCC, degrees(hue), chroma, pColor)
+ == XcmsFailure) {
+ return (XcmsFailure);
+ }
+ retval = _XcmsDIConvertColors(&myCCC, pColor,
+ ScreenWhitePointOfCCC(&myCCC), 1, XcmsCIEXYZFormat);
+ } else {
+ /* Find the maximum lightness for the given chroma. */
+ if (pColor->format != XcmsCIELuvFormat) {
+ if (_XcmsDIConvertColors(ccc, pColor,
+ ScreenWhitePointOfCCC(ccc), 1, XcmsCIELuvFormat)
+ == XcmsFailure) {
+ return(XcmsFailure);
+ }
+ }
+ if (XcmsCIELuvQueryMaxL(&myCCC, degrees(hue), chroma, pColor)
+ == XcmsFailure) {
+ return (XcmsFailure);
+ }
+ retval = _XcmsDIConvertColors(&myCCC, pColor,
+ ScreenWhitePointOfCCC(&myCCC), 1, XcmsCIEXYZFormat);
+ }
+ if (retval != XcmsFailure && pCompressed != NULL) {
+ *(pCompressed + i) = True;
+ }
+ return(retval);
+ }
+}
diff --git a/nx-X11/lib/src/xcms/LuvGcLC.c b/nx-X11/lib/src/xcms/LuvGcLC.c
new file mode 100644
index 000000000..a9f8cbaf1
--- /dev/null
+++ b/nx-X11/lib/src/xcms/LuvGcLC.c
@@ -0,0 +1,223 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of XCMS based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ * NAME
+ * CIELuvGcLC.c
+ *
+ * DESCRIPTION
+ * Source for XcmsCIELuvClipLuv() gamut
+ * compression function.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include <math.h>
+#include "Cv.h"
+
+/*
+ * INTERNALS
+ * Internal defines that need NOT be exported to any package or
+ * program using this package.
+ */
+#define MAXBISECTCOUNT 100
+
+
+/************************************************************************
+ * *
+ * PUBLIC ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsCIELuvClipLuv - Return the closest L* and chroma
+ *
+ * SYNOPSIS
+ */
+/* ARGSUSED */
+Status
+XcmsCIELuvClipLuv (
+ XcmsCCC ccc,
+ XcmsColor *pColors_in_out,
+ unsigned int nColors,
+ unsigned int i,
+ Bool *pCompressed)
+/*
+ * DESCRIPTION
+ * This routine will find the closest L* and chroma
+ * for a specific hue. The color input is converted to
+ * CIE L*u*v* format and returned as CIE XYZ format.
+ *
+ * Since this routine works with the L* within
+ * pColor_in_out intermediate results may be returned
+ * even though it may be invalid.
+ *
+ * RETURNS
+ * XcmsFailure - Failure
+ * XcmsSuccess - Succeeded
+ *
+ */
+{
+ Status retval;
+ XcmsCCCRec myCCC;
+ XcmsColor *pColor;
+ XcmsColor Luv_max;
+ XcmsFloat hue, chroma, maxChroma;
+ XcmsFloat Chroma, bestChroma, Lstar, maxLstar, saveLstar;
+ XcmsFloat bestLstar, bestustar, bestvstar;
+ XcmsFloat nT, saveDist, tmpDist;
+ XcmsRGBi rgb_max;
+ int nCount, nMaxCount, nI, nILast;
+
+ /* Use my own CCC */
+ memcpy ((char *)&myCCC, (char *)ccc, sizeof(XcmsCCCRec));
+ myCCC.clientWhitePt.format = XcmsUndefinedFormat;/* inherit screen white */
+ myCCC.gamutCompProc = (XcmsCompressionProc)NULL;/* no gamut compression func */
+
+ /*
+ * Color specification passed as input can be assumed to:
+ * 1. Be in XcmsCIEXYZFormat
+ * 2. Already be white point adjusted for the Screen White Point.
+ * This means that the white point now associated with this
+ * color spec is the Screen White Point (even if the
+ * ccc->clientWhitePt differs).
+ */
+
+ pColor = pColors_in_out + i;
+
+ if (ccc->visual->class < StaticColor) {
+ /*
+ * GRAY !
+ */
+ _XcmsDIConvertColors(ccc, pColor, ScreenWhitePointOfCCC(ccc),
+ 1, XcmsCIELuvFormat);
+ _XcmsDIConvertColors(ccc, pColor, ScreenWhitePointOfCCC(ccc),
+ 1, XcmsCIEXYZFormat);
+ if (pCompressed) {
+ *(pCompressed + i) = True;
+ }
+ return(XcmsSuccess);
+ }
+
+ /* Convert from CIEXYZ to CIELuv format */
+ if (_XcmsDIConvertColors(&myCCC, pColor,
+ ScreenWhitePointOfCCC(&myCCC), 1, XcmsCIELuvFormat)
+ == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ /* Step 1: compute the maximum L* and chroma for this hue. */
+ /* This copy may be overkill but it preserves the pixel etc. */
+ saveLstar = pColor->spec.CIELuv.L_star;
+ hue = XCMS_CIELUV_PMETRIC_HUE(pColor->spec.CIELuv.u_star,
+ pColor->spec.CIELuv.v_star);
+ chroma = XCMS_CIELUV_PMETRIC_CHROMA(pColor->spec.CIELuv.u_star,
+ pColor->spec.CIELuv.v_star);
+ memcpy((char *)&Luv_max, (char *)pColor, sizeof(XcmsColor));
+ if (_XcmsCIELuvQueryMaxLCRGB (&myCCC, hue, &Luv_max, &rgb_max)
+ == XcmsFailure) {
+ return (XcmsFailure);
+ }
+ maxLstar = Luv_max.spec.CIELuv.L_star;
+
+ /* Now check and return the appropriate L* */
+ if (saveLstar == maxLstar) {
+ /* When the L* input is equal to the maximum L* */
+ /* merely return the maximum Luv point. */
+ memcpy((char *)pColor, (char *)&Luv_max, sizeof(XcmsColor));
+ retval = _XcmsDIConvertColors(&myCCC, pColor,
+ ScreenWhitePointOfCCC(&myCCC), 1, XcmsCIEXYZFormat);
+ } else {
+ /* return the closest point on the hue leaf. */
+ /* must do a bisection here to compute the delta e. */
+ maxChroma = XCMS_CIELUV_PMETRIC_CHROMA(Luv_max.spec.CIELuv.u_star,
+ Luv_max.spec.CIELuv.v_star);
+ nMaxCount = MAXBISECTCOUNT;
+ nI = nMaxCount / 2;
+ bestLstar = Lstar = pColor->spec.CIELuv.L_star;
+ bestustar = pColor->spec.CIELuv.u_star;
+ bestvstar = pColor->spec.CIELuv.v_star;
+ bestChroma = Chroma = chroma;
+ saveDist = XCMS_SQRT(((Chroma - maxChroma) * (Chroma - maxChroma)) +
+ ((Lstar - maxLstar) * (Lstar - maxLstar)));
+ for (nCount = 0; nCount < nMaxCount; nCount++) {
+ nT = (XcmsFloat) nI / (XcmsFloat) nMaxCount;
+ if (saveLstar > maxLstar) {
+ pColor->spec.RGBi.red = rgb_max.red * (1.0 - nT) + nT;
+ pColor->spec.RGBi.green = rgb_max.green * (1.0 - nT) + nT;
+ pColor->spec.RGBi.blue = rgb_max.blue * (1.0 - nT) + nT;
+ } else {
+ pColor->spec.RGBi.red = rgb_max.red - (rgb_max.red * nT);
+ pColor->spec.RGBi.green = rgb_max.green - (rgb_max.green * nT);
+ pColor->spec.RGBi.blue = rgb_max.blue - (rgb_max.blue * nT);
+ }
+ pColor->format = XcmsRGBiFormat;
+
+ /* Convert from RGBi to CIE Luv */
+ if (_XcmsConvertColorsWithWhitePt(&myCCC, pColor,
+ ScreenWhitePointOfCCC(&myCCC), 1, XcmsCIELuvFormat,
+ (Bool *) NULL) == XcmsFailure) {
+ return (XcmsFailure);
+ }
+ chroma = XCMS_CIELUV_PMETRIC_CHROMA(pColor->spec.CIELuv.u_star,
+ pColor->spec.CIELuv.v_star);
+ tmpDist = XCMS_SQRT(((Chroma - chroma) * (Chroma - chroma)) +
+ ((Lstar - pColor->spec.CIELuv.L_star) *
+ (Lstar - pColor->spec.CIELuv.L_star)));
+ nILast = nI;
+ if (tmpDist > saveDist) {
+ nI /= 2;
+ } else {
+ nI = (nMaxCount + nI) / 2;
+ saveDist = tmpDist;
+ bestLstar = pColor->spec.CIELuv.L_star;
+ bestustar = pColor->spec.CIELuv.u_star;
+ bestvstar = pColor->spec.CIELuv.v_star;
+ bestChroma = chroma;
+ }
+ if (nI == nILast || nI == 0) {
+ break;
+ }
+ }
+ if (bestChroma >= maxChroma) {
+ pColor->spec.CIELuv.L_star = maxLstar;
+ pColor->spec.CIELuv.u_star = Luv_max.spec.CIELuv.u_star;
+ pColor->spec.CIELuv.v_star = Luv_max.spec.CIELuv.v_star;
+ } else {
+ pColor->spec.CIELuv.L_star = bestLstar;
+ pColor->spec.CIELuv.u_star = bestustar;
+ pColor->spec.CIELuv.v_star = bestvstar;
+ }
+ retval = _XcmsDIConvertColors(&myCCC, pColor,
+ ScreenWhitePointOfCCC(&myCCC), 1, XcmsCIEXYZFormat);
+
+ if (retval != XcmsFailure && pCompressed != NULL) {
+ *(pCompressed + i) = True;
+ }
+ }
+ return(retval);
+}
diff --git a/nx-X11/lib/src/xcms/LuvMnL.c b/nx-X11/lib/src/xcms/LuvMnL.c
new file mode 100644
index 000000000..b873fa652
--- /dev/null
+++ b/nx-X11/lib/src/xcms/LuvMnL.c
@@ -0,0 +1,216 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of XCMS based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ * NAME
+ * CIELuvMnL.c
+ *
+ * DESCRIPTION
+ * Source for the XcmsCIELuvQueryMinL() gamut boundary
+ * querying routine.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include <math.h>
+#include "Cv.h"
+
+/*
+ * DEFINES
+ */
+#define MAXBISECTCOUNT 100
+#define EPS (XcmsFloat)0.001
+#define START_L_STAR (XcmsFloat)40.0
+
+
+/************************************************************************
+ * *
+ * PUBLIC ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsCIELuvQueryMinL - Compute max Lstar for a hue and chroma
+ *
+ * SYNOPSIS
+ */
+Status
+XcmsCIELuvQueryMinL(
+ XcmsCCC ccc,
+ XcmsFloat hue_angle, /* hue angle in degrees */
+ XcmsFloat chroma,
+ XcmsColor *pColor_return)
+/*
+ * DESCRIPTION
+ * Return the maximum Lstar for a specified hue_angle and chroma.
+ *
+ * ASSUMPTIONS
+ * This routine assumes that the white point associated with
+ * the color specification is the Screen White Point. The
+ * Screen White Point will also be associated with the
+ * returned color specification.
+ *
+ * RETURNS
+ * XcmsFailure - Failure
+ * XcmsSuccess - Succeeded with no modifications
+ *
+ */
+{
+ XcmsCCCRec myCCC;
+ XcmsColor max_lc, tmp, prev;
+ XcmsFloat max_chroma, tmp_chroma;
+ XcmsFloat hue, nT, nChroma, lastChroma, prevChroma;
+ XcmsFloat rFactor;
+ XcmsRGBi rgb_saved;
+ int nCount, nMaxCount;
+
+ /*
+ * Check Arguments
+ */
+ if (ccc == NULL || pColor_return == NULL) {
+ return(XcmsFailure);
+ }
+
+ /* setup the CCC to use for the conversions. */
+ memcpy ((char *) &myCCC, (char *) ccc, sizeof(XcmsCCCRec));
+ myCCC.clientWhitePt.format = XcmsUndefinedFormat;
+ myCCC.gamutCompProc = (XcmsCompressionProc) NULL;
+
+ while (hue_angle < 0.0) {
+ hue_angle += 360.0;
+ }
+ while (hue_angle >= 360.0) {
+ hue_angle -= 360.0;
+ }
+
+ hue = radians(hue_angle);
+ tmp.spec.CIELuv.L_star = START_L_STAR;
+ tmp.spec.CIELuv.u_star = XCMS_CIEUSTAROFHUE(hue, chroma);
+ tmp.spec.CIELuv.v_star = XCMS_CIEVSTAROFHUE(hue, chroma);
+ tmp.pixel = pColor_return->pixel;
+ tmp.format = XcmsCIELuvFormat;
+
+ /* Step 1: Obtain the maximum L_star and chroma for this hue. */
+ if (_XcmsCIELuvQueryMaxLCRGB(&myCCC, hue, &max_lc, &rgb_saved)
+ == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ max_chroma = XCMS_CIELUV_PMETRIC_CHROMA(max_lc.spec.CIELuv.u_star,
+ max_lc.spec.CIELuv.v_star);
+
+ if (max_chroma <= chroma) {
+ /*
+ * If the chroma is greater than the chroma for the
+ * maximum L/chroma point then the L_star is the
+ * the L_star for the maximum L_star/chroma point.
+ * This is an error but I return the best approximation I can.
+ * Thus the inconsistency.
+ */
+ memcpy ((char *) pColor_return, (char *) &max_lc, sizeof (XcmsColor));
+ return(XcmsSuccess);
+ }
+
+ /*
+ * If the chroma is equal to the chroma for the
+ * maximum L_star/chroma point then the L_star is the
+ * the L_star for the maximum L* and chroma point.
+ */
+ /* if (max_chroma == chroma) {
+ * memcpy ((char *) pColor_return, (char *) &max_lc, sizeof (XcmsColor));
+ * return(XcmsSuccess);
+ * }
+ */
+
+ /* must do a bisection here to compute the maximum L* */
+ /* save the structure input so that any elements that */
+ /* are not touched are recopied later in the routine. */
+ nChroma = chroma;
+ tmp_chroma = max_chroma;
+ lastChroma = -1.0;
+ nMaxCount = MAXBISECTCOUNT;
+ rFactor = 1.0;
+
+ for (nCount = 0; nCount < nMaxCount; nCount++) {
+ prevChroma = lastChroma;
+ lastChroma = tmp_chroma;
+ nT = (nChroma - max_chroma) / max_chroma * rFactor;
+ memcpy ((char *)&prev, (char *)&tmp, sizeof(XcmsColor));
+ tmp.spec.RGBi.red = rgb_saved.red + (rgb_saved.red * nT);
+ tmp.spec.RGBi.green = rgb_saved.green + (rgb_saved.green * nT);
+ tmp.spec.RGBi.blue = rgb_saved.blue + (rgb_saved.blue * nT);
+ tmp.format = XcmsRGBiFormat;
+
+ /* convert from RGB to CIELuv */
+ if (_XcmsConvertColorsWithWhitePt(&myCCC, &tmp,
+ ScreenWhitePointOfCCC(&myCCC), 1, XcmsCIELuvFormat,
+ (Bool *) NULL) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ /* Now check the return against what is expected */
+ tmp_chroma = XCMS_CIELUV_PMETRIC_CHROMA(tmp.spec.CIELuv.u_star,
+ tmp.spec.CIELuv.v_star);
+ if (tmp_chroma <= chroma + EPS && tmp_chroma >= chroma - EPS) {
+ /* Found It! */
+ memcpy ((char *) pColor_return, (char *) &tmp, sizeof (XcmsColor));
+ return(XcmsSuccess);
+ }
+ nChroma += chroma - tmp_chroma;
+ if (nChroma > max_chroma) {
+ nChroma = max_chroma;
+ rFactor *= 0.5; /* selective relaxation employed */
+ } else if (nChroma < 0.0) {
+ if (XCMS_FABS(lastChroma - chroma) <
+ XCMS_FABS(tmp_chroma - chroma)) {
+ memcpy ((char *)pColor_return, (char *)&prev,
+ sizeof(XcmsColor));
+ } else {
+ memcpy ((char *)pColor_return, (char *)&tmp,
+ sizeof(XcmsColor));
+ }
+ return(XcmsSuccess);
+ } else if (tmp_chroma <= prevChroma + EPS &&
+ tmp_chroma >= prevChroma - EPS) {
+ rFactor *= 0.5; /* selective relaxation employed */
+ }
+ }
+
+ if (nCount >= nMaxCount) {
+ if (XCMS_FABS(lastChroma - chroma) <
+ XCMS_FABS(tmp_chroma - chroma)) {
+ memcpy ((char *)pColor_return, (char *)&prev,
+ sizeof(XcmsColor));
+ } else {
+ memcpy ((char *)pColor_return, (char *)&tmp,
+ sizeof(XcmsColor));
+ }
+ }
+ memcpy ((char *) pColor_return, (char *) &tmp, sizeof (XcmsColor));
+ return(XcmsSuccess);
+}
diff --git a/nx-X11/lib/src/xcms/LuvMxC.c b/nx-X11/lib/src/xcms/LuvMxC.c
new file mode 100644
index 000000000..a67251477
--- /dev/null
+++ b/nx-X11/lib/src/xcms/LuvMxC.c
@@ -0,0 +1,204 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of XCMS based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ *
+ * NAME
+ * CIELuvMxC.c
+ *
+ * DESCRIPTION
+ * Source for the XcmsCIELuvQueryMaxC() gamut boundary
+ * querying routine.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include <math.h>
+#include "Cv.h"
+
+/*
+ * DEFINES
+ */
+#define MAXBISECTCOUNT 100
+#define EPS (XcmsFloat)0.001
+#define START_CHROMA (XcmsFloat)2.2
+#define TOPL (XcmsFloat)100.0
+
+
+/************************************************************************
+ * *
+ * PUBLIC ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsCIELuvQueryMaxC - max chroma for a hue_angle and L_star
+ *
+ * SYNOPSIS
+ */
+Status
+XcmsCIELuvQueryMaxC(
+ XcmsCCC ccc,
+ XcmsFloat hue_angle, /* hue angle in degrees */
+ XcmsFloat L_star,
+ XcmsColor *pColor_return)
+/*
+ * DESCRIPTION
+ * Return the maximum chroma for a specific hue_angle and L_star.
+ * The returned format is in XcmsCIELuvFormat.
+ *
+ *
+ * ASSUMPTIONS
+ * This routine assumes that the white point associated with
+ * the color specification is the Screen White Point. The
+ * Screen White Point will also be associated with the
+ * returned color specification.
+ *
+ * RETURNS
+ * XcmsFailure - Failure
+ * XcmsSuccess - Succeeded
+ *
+ */
+{
+ XcmsCCCRec myCCC;
+ XcmsColor tmp;
+ XcmsColor max_lc;
+ XcmsFloat n_L_star, last_L_star, prev_L_star;
+ XcmsFloat hue, lastuStar, lastvStar, /*lastChroma,*/ maxDist, nT, rFactor;
+ XcmsRGBi rgb_saved;
+ int nCount, nMaxCount;
+
+ /*
+ * Check Arguments
+ */
+ if (ccc == NULL || pColor_return == NULL) {
+ return(XcmsFailure);
+ }
+
+ /* Use my own CCC and inherit screen white Pt */
+ memcpy ((char *)&myCCC, (char *)ccc, sizeof(XcmsCCCRec));
+ myCCC.clientWhitePt.format = XcmsUndefinedFormat;
+ myCCC.gamutCompProc = (XcmsCompressionProc)NULL;/* no gamut comp func */
+
+ while (hue_angle < 0.0) {
+ hue_angle += 360.0;
+ }
+ while (hue_angle >= 360.0) {
+ hue_angle -= 360.0;
+ }
+
+ hue = radians(hue_angle);
+ tmp.spec.CIELuv.L_star = L_star;
+ tmp.spec.CIELuv.u_star = XCMS_CIEUSTAROFHUE(hue, START_CHROMA);
+ tmp.spec.CIELuv.v_star = XCMS_CIEVSTAROFHUE(hue, START_CHROMA);
+ tmp.pixel = pColor_return->pixel;
+ tmp.format = XcmsCIELuvFormat;
+
+ /* Step 1: compute the maximum L_star and chroma for this hue. */
+ memcpy((char *)&max_lc, (char *)&tmp, sizeof(XcmsColor));
+ if (_XcmsCIELuvQueryMaxLCRGB(&myCCC, hue, &max_lc, &rgb_saved)
+ == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Step 2: Do a bisection here to compute the maximum chroma
+ * Note the differences between when the point to be found
+ * is above the maximum LC point and when it is below.
+ */
+ if (L_star <= max_lc.spec.CIELuv.L_star) {
+ maxDist = max_lc.spec.CIELuv.L_star;
+ } else {
+ maxDist = TOPL - max_lc.spec.CIELuv.L_star;
+ }
+
+ n_L_star = L_star;
+ last_L_star = -1.0;
+ nMaxCount = MAXBISECTCOUNT;
+ rFactor = 1.0;
+
+ for (nCount = 0; nCount < nMaxCount; nCount++) {
+ prev_L_star = last_L_star;
+ last_L_star = tmp.spec.CIELuv.L_star;
+/* lastChroma = XCMS_CIELUV_PMETRIC_CHROMA(tmp.spec.CIELuv.u_star, */
+/* tmp.spec.CIELuv.v_star); */
+ lastuStar = tmp.spec.CIELuv.u_star;
+ lastvStar = tmp.spec.CIELuv.v_star;
+ nT = (n_L_star - max_lc.spec.CIELuv.L_star) / maxDist * rFactor;
+ /* printf("(n_L_star, nT) = %lf %lf ", n_L_star, nT); */
+ if (nT > 0) {
+ tmp.spec.RGBi.red = rgb_saved.red * (1.0 - nT) + nT;
+ tmp.spec.RGBi.green = rgb_saved.green * (1.0 - nT) + nT;
+ tmp.spec.RGBi.blue = rgb_saved.blue * (1.0 - nT) + nT;
+ } else {
+ tmp.spec.RGBi.red = rgb_saved.red + (rgb_saved.red * nT);
+ tmp.spec.RGBi.green = rgb_saved.green + (rgb_saved.green * nT);
+ tmp.spec.RGBi.blue = rgb_saved.blue + (rgb_saved.blue * nT);
+ }
+ tmp.format = XcmsRGBiFormat;
+
+ /* convert from RGB to CIELuv */
+ if (_XcmsConvertColorsWithWhitePt(&myCCC, &tmp,
+ ScreenWhitePointOfCCC(&myCCC), 1, XcmsCIELuvFormat,
+ (Bool *) NULL) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Now check if we've reached the target L_star
+ */
+ /* printf("result Lstar = %lf\n", tmp.spec.CIELuv.L_star); */
+ if (tmp.spec.CIELuv.L_star <= L_star + EPS &&
+ tmp.spec.CIELuv.L_star >= L_star - EPS) {
+ memcpy((char *)pColor_return, (char *)&tmp, sizeof(XcmsColor));
+ return(XcmsSuccess);
+ }
+ if (nT > 0) {
+ n_L_star += ((TOPL - n_L_star) *
+ (L_star - tmp.spec.CIELuv.L_star)) / (TOPL - L_star);
+ } else {
+ n_L_star *= L_star / tmp.spec.CIELuv.L_star;
+ }
+ if (tmp.spec.CIELuv.L_star <= prev_L_star + EPS &&
+ tmp.spec.CIELuv.L_star >= prev_L_star - EPS) {
+ rFactor *= 0.5; /* selective relaxation employed */
+ /* printf("rFactor = %lf\n", rFactor); */
+ }
+ }
+ if (XCMS_FABS(last_L_star - L_star) <
+ XCMS_FABS(tmp.spec.CIELuv.L_star - L_star)) {
+ tmp.spec.CIELuv.u_star = lastuStar;
+ tmp.spec.CIELuv.v_star = lastvStar;
+/* tmp.spec.CIELuv.u_star = XCMS_CIEUSTAROFHUE(hue, lastChroma); */
+/* tmp.spec.CIELuv.v_star = XCMS_CIEVSTAROFHUE(hue, lastChroma); */
+ }
+ tmp.spec.CIELuv.L_star = L_star;
+ memcpy((char *)pColor_return, (char *)&tmp, sizeof(XcmsColor));
+ return(XcmsSuccess);
+}
diff --git a/nx-X11/lib/src/xcms/LuvMxL.c b/nx-X11/lib/src/xcms/LuvMxL.c
new file mode 100644
index 000000000..d1d495b08
--- /dev/null
+++ b/nx-X11/lib/src/xcms/LuvMxL.c
@@ -0,0 +1,216 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of XCMS based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ * NAME
+ * CIELuvMxL.c
+ *
+ * DESCRIPTION
+ * Source for the XcmsCIELuvQueryMaxL() gamut boundary
+ * querying routine.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include <math.h>
+#include "Cv.h"
+
+/*
+ * DEFINES
+ */
+#define MAXBISECTCOUNT 100
+#define EPS (XcmsFloat)0.001
+#define START_L_STAR (XcmsFloat)40.0
+
+
+/************************************************************************
+ * *
+ * PUBLIC ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsCIELuvQueryMaxL - Compute max Lstar for a hue and chroma
+ *
+ * SYNOPSIS
+ */
+Status
+XcmsCIELuvQueryMaxL(
+ XcmsCCC ccc,
+ XcmsFloat hue_angle, /* hue angle in degrees */
+ XcmsFloat chroma,
+ XcmsColor *pColor_return)
+/*
+ * DESCRIPTION
+ * Return the maximum Lstar for a specified hue_angle and chroma.
+ *
+ * ASSUMPTIONS
+ * This routine assumes that the white point associated with
+ * the color specification is the Screen White Point. The
+ * Screen White Point will also be associated with the
+ * returned color specification.
+ *
+ * RETURNS
+ * XcmsFailure - Failure
+ * XcmsSuccess - Succeeded with no modifications
+ *
+ */
+{
+ XcmsCCCRec myCCC;
+ XcmsColor max_lc, tmp, prev;
+ XcmsFloat max_chroma, tmp_chroma;
+ XcmsFloat hue, nT, nChroma, lastChroma, prevChroma;
+ XcmsFloat rFactor;
+ XcmsRGBi rgb_saved;
+ int nCount, nMaxCount;
+
+ /*
+ * Check Arguments
+ */
+ if (ccc == NULL || pColor_return == NULL) {
+ return(XcmsFailure);
+ }
+
+ /* setup the CCC to use for the conversions. */
+ memcpy ((char *) &myCCC, (char *) ccc, sizeof(XcmsCCCRec));
+ myCCC.clientWhitePt.format = XcmsUndefinedFormat;
+ myCCC.gamutCompProc = (XcmsCompressionProc) NULL;
+
+ while (hue_angle < 0.0) {
+ hue_angle += 360.0;
+ }
+ while (hue_angle >= 360.0) {
+ hue_angle -= 360.0;
+ }
+
+ hue = radians(hue_angle);
+ tmp.spec.CIELuv.L_star = START_L_STAR;
+ tmp.spec.CIELuv.u_star = XCMS_CIEUSTAROFHUE(hue, chroma);
+ tmp.spec.CIELuv.v_star = XCMS_CIEVSTAROFHUE(hue, chroma);
+ tmp.pixel = pColor_return->pixel;
+ tmp.format = XcmsCIELuvFormat;
+
+ /* Step 1: Obtain the maximum L_star and chroma for this hue. */
+ if (_XcmsCIELuvQueryMaxLCRGB(&myCCC, hue, &max_lc, &rgb_saved)
+ == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ max_chroma = XCMS_CIELUV_PMETRIC_CHROMA(max_lc.spec.CIELuv.u_star,
+ max_lc.spec.CIELuv.v_star);
+
+ if (max_chroma <= chroma) {
+ /*
+ * If the chroma is greater than the chroma for the
+ * maximum L/chroma point then the L_star is the
+ * the L_star for the maximum L_star/chroma point.
+ * This is an error but I return the best approximation I can.
+ * Thus the inconsistency.
+ */
+ memcpy ((char *) pColor_return, (char *) &max_lc, sizeof (XcmsColor));
+ return(XcmsSuccess);
+ }
+
+ /*
+ * If the chroma is equal to the chroma for the
+ * maximum L_star/chroma point then the L_star is the
+ * the L_star for the maximum L* and chroma point.
+ */
+ /* if (max_chroma == chroma) {
+ * memcpy ((char *) pColor_return, (char *) &max_lc, sizeof (XcmsColor));
+ * return(XcmsSuccess);
+ * }
+ */
+
+ /* must do a bisection here to compute the maximum L* */
+ /* save the structure input so that any elements that */
+ /* are not touched are recopied later in the routine. */
+ nChroma = chroma;
+ tmp_chroma = max_chroma;
+ lastChroma = -1.0;
+ nMaxCount = MAXBISECTCOUNT;
+ rFactor = 1.0;
+
+ for (nCount = 0; nCount < nMaxCount; nCount++) {
+ prevChroma = lastChroma;
+ lastChroma = tmp_chroma;
+ nT = (1.0 - (nChroma / max_chroma)) * rFactor;
+ memcpy ((char *)&prev, (char *)&tmp, sizeof(XcmsColor));
+ tmp.spec.RGBi.red = rgb_saved.red * (1.0 - nT) + nT;
+ tmp.spec.RGBi.green = rgb_saved.green * (1.0 - nT) + nT;
+ tmp.spec.RGBi.blue = rgb_saved.blue * (1.0 - nT) + nT;
+ tmp.format = XcmsRGBiFormat;
+
+ /* convert from RGB to CIELuv */
+ if (_XcmsConvertColorsWithWhitePt(&myCCC, &tmp,
+ ScreenWhitePointOfCCC(&myCCC), 1, XcmsCIELuvFormat,
+ (Bool *) NULL) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ /* Now check the return against what is expected */
+ tmp_chroma = XCMS_CIELUV_PMETRIC_CHROMA(tmp.spec.CIELuv.u_star,
+ tmp.spec.CIELuv.v_star);
+ if (tmp_chroma <= chroma + EPS && tmp_chroma >= chroma - EPS) {
+ /* Found It! */
+ memcpy ((char *) pColor_return, (char *) &tmp, sizeof (XcmsColor));
+ return(XcmsSuccess);
+ }
+ nChroma += chroma - tmp_chroma;
+ if (nChroma > max_chroma) {
+ nChroma = max_chroma;
+ rFactor *= 0.5; /* selective relaxation employed */
+ } else if (nChroma < 0.0) {
+ if (XCMS_FABS(lastChroma - chroma) <
+ XCMS_FABS(tmp_chroma - chroma)) {
+ memcpy ((char *)pColor_return, (char *)&prev,
+ sizeof(XcmsColor));
+ } else {
+ memcpy ((char *)pColor_return, (char *)&tmp,
+ sizeof(XcmsColor));
+ }
+ return(XcmsSuccess);
+ } else if (tmp_chroma <= prevChroma + EPS &&
+ tmp_chroma >= prevChroma - EPS) {
+ rFactor *= 0.5; /* selective relaxation employed */
+ }
+ }
+
+ if (nCount >= nMaxCount) {
+ if (XCMS_FABS(lastChroma - chroma) <
+ XCMS_FABS(tmp_chroma - chroma)) {
+ memcpy ((char *)pColor_return, (char *)&prev,
+ sizeof(XcmsColor));
+ } else {
+ memcpy ((char *)pColor_return, (char *)&tmp,
+ sizeof(XcmsColor));
+ }
+ }
+ memcpy ((char *) pColor_return, (char *) &tmp, sizeof (XcmsColor));
+ return(XcmsSuccess);
+}
diff --git a/nx-X11/lib/src/xcms/LuvMxLC.c b/nx-X11/lib/src/xcms/LuvMxLC.c
new file mode 100644
index 000000000..60b954916
--- /dev/null
+++ b/nx-X11/lib/src/xcms/LuvMxLC.c
@@ -0,0 +1,218 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of XCMS based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ *
+ * NAME
+ * CIELuvMxVC.c
+ *
+ * DESCRIPTION
+ * Source for the XcmsCIELuvQueryMaxLC() gamut boundary
+ * querying routine.
+ *
+ * DOCUMENTATION
+ * "TekColor Color Management System, System Implementor's Manual"
+ * and
+ * Fred W. Billmeyer & Max Saltzman, "Principles of Color
+ * Technology", John Wily & Sons, Inc, 1981.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+/*
+ * DEFINES
+ */
+#define MIN(x,y) ((x) > (y) ? (y) : (x))
+#define MIN3(x,y,z) ((x) > (MIN((y), (z))) ? (MIN((y), (z))) : (x))
+#define MAX(x,y) ((x) > (y) ? (x) : (y))
+#define MAX3(x,y,z) ((x) > (MAX((y), (z))) ? (x) : (MAX((y), (z))))
+#define START_LSTAR (XcmsFloat)40.0
+#define START_CHROMA (XcmsFloat)2.2
+
+
+/************************************************************************
+ * *
+ * API PRIVATE ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * _XcmsCIELuvQueryMaxLCRGB - Compute maximum L* and chroma.
+ *
+ * SYNOPSIS
+ */
+Status
+_XcmsCIELuvQueryMaxLCRGB(
+ XcmsCCC ccc,
+ XcmsFloat hue, /* hue in radians */
+ XcmsColor *pColor_return,
+ XcmsRGBi *pRGB_return)
+/*
+ * DESCRIPTION
+ * Return the maximum psychometric chroma for a specified
+ * hue angle(radians), and the corresponding L*. This is computed
+ * by a binary search of all possible chromas. An assumption
+ * is made that there are no local maxima. Use the unrounded
+ * Max psychometric chroma because the difference check can be
+ * small.
+ *
+ * NOTE: No local CCC is used because this is a private
+ * routine and all routines that call it are expected
+ * to behave properly, i.e. send a local CCC with
+ * no white adjust function and no gamut compression
+ * function.
+ *
+ * This routine only accepts hue as input and outputs
+ * Luv and RGBi.
+ *
+ * RETURNS
+ * XcmsFailure - Failure
+ * XcmsSuccess - Succeeded
+ *
+ */
+{
+ XcmsFloat nSmall, nLarge;
+ XcmsColor tmp;
+
+ tmp.format = XcmsCIELuvFormat;
+ /* Use some unreachable color on the given hue angle */
+ tmp.spec.CIELuv.L_star = START_LSTAR;
+ tmp.spec.CIELuv.u_star = XCMS_CIEUSTAROFHUE(hue, START_CHROMA);
+ tmp.spec.CIELuv.v_star = XCMS_CIEVSTAROFHUE(hue, START_CHROMA);
+ /*
+ * Convert from Luv to RGB
+ *
+ * Note that the CIEXYZ to RGBi conversion routine must stuff the
+ * out of bounds RGBi values in tmp when the ccc->gamutCompProc
+ * is NULL.
+ */
+ if ((_XcmsConvertColorsWithWhitePt(ccc, &tmp, ScreenWhitePointOfCCC(ccc),
+ (unsigned int)1, XcmsRGBiFormat, (Bool *) NULL)
+ == XcmsFailure) && tmp.format != XcmsRGBiFormat) {
+ return (XcmsFailure);
+ }
+
+ /* Now pick the smallest RGB */
+ nSmall = MIN3(tmp.spec.RGBi.red,
+ tmp.spec.RGBi.green,
+ tmp.spec.RGBi.blue);
+ /* Make the smallest RGB equal to zero */
+ tmp.spec.RGBi.red -= nSmall;
+ tmp.spec.RGBi.green -= nSmall;
+ tmp.spec.RGBi.blue -= nSmall;
+
+ /* Now pick the largest RGB */
+ nLarge = MAX3(tmp.spec.RGBi.red,
+ tmp.spec.RGBi.green,
+ tmp.spec.RGBi.blue);
+ /* Scale the RGB values based on the largest one */
+ tmp.spec.RGBi.red /= nLarge;
+ tmp.spec.RGBi.green /= nLarge;
+ tmp.spec.RGBi.blue /= nLarge;
+ tmp.format = XcmsRGBiFormat;
+
+ /* If the calling routine wants RGB value give them the ones used. */
+ if (pRGB_return) {
+ pRGB_return->red = tmp.spec.RGBi.red;
+ pRGB_return->green = tmp.spec.RGBi.green;
+ pRGB_return->blue = tmp.spec.RGBi.blue;
+ }
+
+ /* Convert from RGBi to Luv */
+ if (_XcmsConvertColorsWithWhitePt(ccc, &tmp,
+ ScreenWhitePointOfCCC(ccc), 1, XcmsCIELuvFormat, (Bool *) NULL)
+ == XcmsFailure) {
+ return (XcmsFailure);
+ }
+
+ memcpy((char *)pColor_return, (char *)&tmp, sizeof(XcmsColor));
+ return (XcmsSuccess);
+}
+
+
+/************************************************************************
+ * *
+ * PUBLIC ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsCIELuvQueryMaxLC - Compute maximum L* and chroma.
+ *
+ * SYNOPSIS
+ */
+Status
+XcmsCIELuvQueryMaxLC (
+ XcmsCCC ccc,
+ XcmsFloat hue_angle, /* hue angle in degrees */
+ XcmsColor *pColor_return)
+
+/*
+ * DESCRIPTION
+ * Return the point of maximum chroma for the specified
+ * hue angle.
+ *
+ * ASSUMPTIONS
+ * This routine assumes that the white point associated with
+ * the color specification is the Screen White Point. The
+ * Screen White Point will also be associated with the
+ * returned color specification.
+ *
+ * RETURNS
+ * XcmsFailure - Failure
+ * XcmsSuccess - Succeeded
+ *
+ */
+{
+ XcmsCCCRec myCCC;
+
+ /*
+ * Check Arguments
+ */
+ if (ccc == NULL || pColor_return == NULL) {
+ return(XcmsFailure);
+ }
+
+ /* Use my own CCC */
+ memcpy ((char *)&myCCC, (char *)ccc, sizeof(XcmsCCCRec));
+ myCCC.clientWhitePt.format = XcmsUndefinedFormat;
+ myCCC.gamutCompProc = (XcmsCompressionProc)NULL;
+
+ while (hue_angle < 0.0) {
+ hue_angle += 360.0;
+ }
+ while (hue_angle >= 360.0) {
+ hue_angle -= 360.0;
+ }
+
+ return(_XcmsCIELuvQueryMaxLCRGB (&myCCC, radians(hue_angle), pColor_return,
+ (XcmsRGBi *)NULL));
+}
diff --git a/nx-X11/lib/src/xcms/LuvWpAj.c b/nx-X11/lib/src/xcms/LuvWpAj.c
new file mode 100644
index 000000000..aa2a3f462
--- /dev/null
+++ b/nx-X11/lib/src/xcms/LuvWpAj.c
@@ -0,0 +1,96 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of XCMS based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ * NAME
+ * CIELuvWpAj.c
+ *
+ * DESCRIPTION
+ * This file contains routine(s) that support white point
+ * adjustment of color specifications in the CIE CIELuv.color
+ * space.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+
+
+/************************************************************************
+ * *
+ * PUBLIC ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsCIELuvWhiteShiftColors
+ *
+ * SYNOPSIS
+ */
+Status
+XcmsCIELuvWhiteShiftColors(
+ XcmsCCC ccc,
+ XcmsColor *pWhitePtFrom,
+ XcmsColor *pWhitePtTo,
+ XcmsColorFormat destSpecFmt,
+ XcmsColor *pColors_in_out,
+ unsigned int nColors,
+ Bool *pCompressed)
+/*
+ * DESCRIPTION
+ * Adjusts color specifications in an array of XcmsColor
+ * structures for white point differences.
+ *
+ * RETURNS
+ * XcmsFailure if failed,
+ * XcmsSuccess if succeeded without gamut compression,
+ * XcmsSuccessWithCompression if succeeded with
+ * gamut compression.
+ */
+{
+ if (pWhitePtFrom == NULL || pWhitePtTo == NULL || pColors_in_out == NULL) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Convert to CIELuv using pWhitePtFrom
+ * We can ignore return value for compression because we are converting
+ * to XcmsCIELuvFormat which is device-independent, not device-dependent.
+ */
+ if (_XcmsConvertColorsWithWhitePt(ccc, pColors_in_out, pWhitePtFrom,
+ nColors, XcmsCIELuvFormat, pCompressed) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Convert from CIELuv to destSpecFmt using pWhitePtTo
+ */
+ return(_XcmsConvertColorsWithWhitePt(ccc, pColors_in_out, pWhitePtTo,
+ nColors, destSpecFmt, pCompressed));
+}
diff --git a/nx-X11/lib/src/xcms/Makefile.am b/nx-X11/lib/src/xcms/Makefile.am
new file mode 100644
index 000000000..ba7ab2403
--- /dev/null
+++ b/nx-X11/lib/src/xcms/Makefile.am
@@ -0,0 +1,92 @@
+NULL =
+
+noinst_LTLIBRARIES = libxcms.la
+
+AM_CPPFLAGS = \
+ -I$(top_srcdir)/include \
+ -I$(top_srcdir)/include/X11 \
+ -I$(top_builddir)/include \
+ -I$(top_builddir)/include/X11 \
+ -I$(top_srcdir)/src/xcms \
+ -I$(top_srcdir)/src/xkb \
+ -I$(top_srcdir)/src/xlibi18n \
+ -I$(top_srcdir)/src \
+ -I$(top_srcdir)/../exports/include \
+ -D_GNU_SOURCE \
+ -DXCMSDIR=\"$(X11dir)\" \
+ $(NULL)
+
+AM_CFLAGS = \
+ $(X11_CFLAGS) \
+ $(BIGFONT_CFLAGS) \
+ $(XMALLOC_ZERO_CFLAGS) \
+ $(CWARNFLAGS)
+
+libxcms_la_SOURCES = \
+ AddDIC.c \
+ AddSF.c \
+ CCC.c \
+ CvColW.c \
+ CvCols.c \
+ HVC.c \
+ HVCGcC.c \
+ HVCGcV.c \
+ HVCGcVC.c \
+ HVCMnV.c \
+ HVCMxC.c \
+ HVCMxV.c \
+ HVCMxVC.c \
+ HVCMxVs.c \
+ HVCWpAj.c \
+ IdOfPr.c \
+ LRGB.c \
+ Lab.c \
+ LabGcC.c \
+ LabGcL.c \
+ LabGcLC.c \
+ LabMnL.c \
+ LabMxC.c \
+ LabMxL.c \
+ LabMxLC.c \
+ LabWpAj.c \
+ Luv.c \
+ LuvGcC.c \
+ LuvGcL.c \
+ LuvGcLC.c \
+ LuvMnL.c \
+ LuvMxC.c \
+ LuvMxL.c \
+ LuvMxLC.c \
+ LuvWpAj.c \
+ OfCCC.c \
+ PrOfId.c \
+ QBlack.c \
+ QBlue.c \
+ QGreen.c \
+ QRed.c \
+ QWhite.c \
+ QuCol.c \
+ QuCols.c \
+ SetCCC.c \
+ SetGetCols.c \
+ StCol.c \
+ StCols.c \
+ UNDEFINED.c \
+ XRGB.c \
+ XYZ.c \
+ cmsAllCol.c \
+ cmsAllNCol.c \
+ cmsCmap.c \
+ cmsColNm.c \
+ cmsGlobls.c \
+ cmsInt.c \
+ cmsLkCol.c \
+ cmsMath.c \
+ cmsProp.c \
+ cmsTrig.c \
+ uvY.c \
+ xyY.c \
+ $(NULL)
+
+X11dir = $(X11_DATADIR)
+dist_X11_DATA = Xcms.txt
diff --git a/nx-X11/lib/src/xcms/OfCCC.c b/nx-X11/lib/src/xcms/OfCCC.c
new file mode 100644
index 000000000..06fc3d7a1
--- /dev/null
+++ b/nx-X11/lib/src/xcms/OfCCC.c
@@ -0,0 +1,162 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ * NAME
+ * XcmsOfCCC.c - Color Conversion Context Querying Routines
+ *
+ * DESCRIPTION
+ * Routines to query components of a Color Conversion
+ * Context structure.
+ *
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlib.h"
+#include "Xcms.h"
+
+
+
+/************************************************************************
+ * *
+ * PUBLIC INTERFACES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsDisplayOfCCC
+ *
+ * SYNOPSIS
+ */
+
+Display *
+XcmsDisplayOfCCC(
+ XcmsCCC ccc)
+/*
+ * DESCRIPTION
+ * Queries the Display of the specified CCC.
+ *
+ * RETURNS
+ * Pointer to the Display.
+ *
+ */
+{
+ return(ccc->dpy);
+}
+
+
+/*
+ * NAME
+ * XcmsVisualOfCCC
+ *
+ * SYNOPSIS
+ */
+
+Visual *
+XcmsVisualOfCCC(
+ XcmsCCC ccc)
+/*
+ * DESCRIPTION
+ * Queries the Visual of the specified CCC.
+ *
+ * RETURNS
+ * Pointer to the Visual.
+ *
+ */
+{
+ return(ccc->visual);
+}
+
+
+/*
+ * NAME
+ * XcmsScreenNumberOfCCC
+ *
+ * SYNOPSIS
+ */
+
+int
+XcmsScreenNumberOfCCC(
+ XcmsCCC ccc)
+/*
+ * DESCRIPTION
+ * Queries the screen number of the specified CCC.
+ *
+ * RETURNS
+ * screen number.
+ *
+ */
+{
+ return(ccc->screenNumber);
+}
+
+
+/*
+ * NAME
+ * XcmsScreenWhitePointOfCCC
+ *
+ * SYNOPSIS
+ */
+
+XcmsColor *
+XcmsScreenWhitePointOfCCC(
+ XcmsCCC ccc)
+/*
+ * DESCRIPTION
+ * Queries the screen white point of the specified CCC.
+ *
+ * RETURNS
+ * Pointer to the XcmsColor containing the screen white point.
+ *
+ */
+{
+ return(&ccc->pPerScrnInfo->screenWhitePt);
+}
+
+
+/*
+ * NAME
+ * XcmsClientWhitePointOfCCC
+ *
+ * SYNOPSIS
+ */
+
+XcmsColor *
+XcmsClientWhitePointOfCCC(
+ XcmsCCC ccc)
+/*
+ * DESCRIPTION
+ * Queries the client white point of the specified CCC.
+ *
+ * RETURNS
+ * Pointer to the XcmsColor containing the client white point.
+ *
+ */
+{
+ return(&ccc->clientWhitePt);
+}
diff --git a/nx-X11/lib/src/xcms/PrOfId.c b/nx-X11/lib/src/xcms/PrOfId.c
new file mode 100644
index 000000000..a96d28cec
--- /dev/null
+++ b/nx-X11/lib/src/xcms/PrOfId.c
@@ -0,0 +1,97 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ * NAME
+ * XcmsPrOfId.c
+ *
+ * DESCRIPTION
+ * Source for XcmsPrefixOfFormat()
+ *
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+
+/*
+ * NAME
+ * XcmsPrefixOfId
+ *
+ * SYNOPSIS
+ */
+char *
+XcmsPrefixOfFormat(
+ XcmsColorFormat id)
+/*
+ * DESCRIPTION
+ * Returns the color space prefix for the specified color
+ * space ID if the color space is found in the Color
+ * Conversion Context.
+ *
+ * RETURNS
+ * Returns a color space prefix.
+ *
+ * CAVEATS
+ * Space is allocated for the returned string, therefore,
+ * the application is responsible for freeing (using XFree)
+ * the space.
+ *
+ */
+{
+ XcmsColorSpace **papColorSpaces;
+
+ /*
+ * First try Device-Independent color spaces
+ */
+ papColorSpaces = _XcmsDIColorSpaces;
+ if (papColorSpaces != NULL) {
+ while (*papColorSpaces != NULL) {
+ if ((*papColorSpaces)->id == id) {
+ return strdup((*papColorSpaces)->prefix);
+ }
+ papColorSpaces++;
+ }
+ }
+
+ /*
+ * Next try Device-Dependent color spaces
+ */
+ papColorSpaces = _XcmsDDColorSpaces;
+ if (papColorSpaces != NULL) {
+ while (*papColorSpaces != NULL) {
+ if ((*papColorSpaces)->id == id) {
+ return strdup((*papColorSpaces)->prefix);
+ }
+ papColorSpaces++;
+ }
+ }
+
+ return(NULL);
+}
diff --git a/nx-X11/lib/src/xcms/QBlack.c b/nx-X11/lib/src/xcms/QBlack.c
new file mode 100644
index 000000000..d7a69d399
--- /dev/null
+++ b/nx-X11/lib/src/xcms/QBlack.c
@@ -0,0 +1,84 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ * NAME
+ * XcmsQBlack.c - Query Black
+ *
+ * DESCRIPTION
+ * Routine to obtain a color specification for zero
+ * red, green, and blue intensities.
+ *
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcms.h"
+
+
+
+/************************************************************************
+ * *
+ * PUBLIC INTERFACES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsQueryBlack
+ *
+ * SYNOPSIS
+ */
+
+Status
+XcmsQueryBlack(
+ XcmsCCC ccc,
+ XcmsColorFormat target_format,
+ XcmsColor *pColor_ret)
+/*
+ * DESCRIPTION
+ * Returns the color specification in the target format for
+ * zero intensity red, green, and blue.
+ *
+ * RETURNS
+ * Returns XcmsSuccess, if failed; otherwise XcmsFailure
+ *
+ */
+{
+ XcmsColor tmp;
+
+ tmp.format = XcmsRGBiFormat;
+ tmp.pixel = 0;
+ tmp.spec.RGBi.red = 0.0;
+ tmp.spec.RGBi.green = 0.0;
+ tmp.spec.RGBi.blue = 0.0;
+ if (XcmsConvertColors(ccc, &tmp, 1, target_format, NULL) != XcmsSuccess) {
+ return(XcmsFailure);
+ }
+ memcpy((char *)pColor_ret, (char *)&tmp, sizeof(XcmsColor));
+ return(XcmsSuccess);
+}
diff --git a/nx-X11/lib/src/xcms/QBlue.c b/nx-X11/lib/src/xcms/QBlue.c
new file mode 100644
index 000000000..4555344e6
--- /dev/null
+++ b/nx-X11/lib/src/xcms/QBlue.c
@@ -0,0 +1,84 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ * NAME
+ * XcmsQBlue.c - Query Blue
+ *
+ * DESCRIPTION
+ * Routine to obtain a color specification for full
+ * blue intensity and zero red and green intensities.
+ *
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcms.h"
+
+
+
+/************************************************************************
+ * *
+ * PUBLIC INTERFACES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsQueryBlue
+ *
+ * SYNOPSIS
+ */
+
+Status
+XcmsQueryBlue(
+ XcmsCCC ccc,
+ XcmsColorFormat target_format,
+ XcmsColor *pColor_ret)
+/*
+ * DESCRIPTION
+ * Returns the color specification in the target format for
+ * full intensity blue and zero intensity red and green.
+ *
+ * RETURNS
+ * Returns XcmsSuccess, if failed; otherwise XcmsFailure
+ *
+ */
+{
+ XcmsColor tmp;
+
+ tmp.format = XcmsRGBiFormat;
+ tmp.pixel = 0;
+ tmp.spec.RGBi.red = 0.0;
+ tmp.spec.RGBi.green = 0.0;
+ tmp.spec.RGBi.blue = 1.0;
+ if (XcmsConvertColors(ccc, &tmp, 1, target_format, NULL) != XcmsSuccess) {
+ return(XcmsFailure);
+ }
+ memcpy((char *)pColor_ret, (char *)&tmp, sizeof(XcmsColor));
+ return(XcmsSuccess);
+}
diff --git a/nx-X11/lib/src/xcms/QGreen.c b/nx-X11/lib/src/xcms/QGreen.c
new file mode 100644
index 000000000..0c888358a
--- /dev/null
+++ b/nx-X11/lib/src/xcms/QGreen.c
@@ -0,0 +1,84 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ * NAME
+ * XcmsQGreen.c - Query Green
+ *
+ * DESCRIPTION
+ * Routine to obtain a color specification for full
+ * green intensity and zero red and blue intensities.
+ *
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcms.h"
+
+
+
+/************************************************************************
+ * *
+ * PUBLIC INTERFACES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsQueryGreen
+ *
+ * SYNOPSIS
+ */
+
+Status
+XcmsQueryGreen(
+ XcmsCCC ccc,
+ XcmsColorFormat target_format,
+ XcmsColor *pColor_ret)
+/*
+ * DESCRIPTION
+ * Returns the color specification in the target format for
+ * full intensity green and zero intensity red and blue.
+ *
+ * RETURNS
+ * Returns XcmsSuccess, if failed; otherwise XcmsFailure
+ *
+ */
+{
+ XcmsColor tmp;
+
+ tmp.format = XcmsRGBiFormat;
+ tmp.pixel = 0;
+ tmp.spec.RGBi.red = 0.0;
+ tmp.spec.RGBi.green = 1.0;
+ tmp.spec.RGBi.blue = 0.0;
+ if (XcmsConvertColors(ccc, &tmp, 1, target_format, NULL) != XcmsSuccess) {
+ return(XcmsFailure);
+ }
+ memcpy((char *)pColor_ret, (char *)&tmp, sizeof(XcmsColor));
+ return(XcmsSuccess);
+}
diff --git a/nx-X11/lib/src/xcms/QRed.c b/nx-X11/lib/src/xcms/QRed.c
new file mode 100644
index 000000000..357380d60
--- /dev/null
+++ b/nx-X11/lib/src/xcms/QRed.c
@@ -0,0 +1,84 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ * NAME
+ * XcmsQRed.c - Query Red
+ *
+ * DESCRIPTION
+ * Routine to obtain a color specification for full
+ * red intensity and zero green and blue intensities.
+ *
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcms.h"
+
+
+
+/************************************************************************
+ * *
+ * PUBLIC INTERFACES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsQueryRed
+ *
+ * SYNOPSIS
+ */
+
+Status
+XcmsQueryRed(
+ XcmsCCC ccc,
+ XcmsColorFormat target_format,
+ XcmsColor *pColor_ret)
+/*
+ * DESCRIPTION
+ * Returns the color specification in the target format for
+ * full intensity red and zero intensity green and blue.
+ *
+ * RETURNS
+ * Returns XcmsSuccess, if failed; otherwise XcmsFailure
+ *
+ */
+{
+ XcmsColor tmp;
+
+ tmp.format = XcmsRGBiFormat;
+ tmp.pixel = 0;
+ tmp.spec.RGBi.red = 1.0;
+ tmp.spec.RGBi.green = 0.0;
+ tmp.spec.RGBi.blue = 0.0;
+ if (XcmsConvertColors(ccc, &tmp, 1, target_format, NULL) != XcmsSuccess) {
+ return(XcmsFailure);
+ }
+ memcpy((char *)pColor_ret, (char *)&tmp, sizeof(XcmsColor));
+ return(XcmsSuccess);
+}
diff --git a/nx-X11/lib/src/xcms/QWhite.c b/nx-X11/lib/src/xcms/QWhite.c
new file mode 100644
index 000000000..36b764c9d
--- /dev/null
+++ b/nx-X11/lib/src/xcms/QWhite.c
@@ -0,0 +1,84 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ * NAME
+ * XcmsQWhite.c - Query White
+ *
+ * DESCRIPTION
+ * Routine to obtain a color specification for full
+ * red, green, and blue intensities.
+ *
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcms.h"
+
+
+
+/************************************************************************
+ * *
+ * PUBLIC INTERFACES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsQueryWhite
+ *
+ * SYNOPSIS
+ */
+
+Status
+XcmsQueryWhite(
+ XcmsCCC ccc,
+ XcmsColorFormat target_format,
+ XcmsColor *pColor_ret)
+/*
+ * DESCRIPTION
+ * Returns the color specification in the target format for
+ * full intensity red, green, and blue.
+ *
+ * RETURNS
+ * Returns XcmsSuccess, if failed; otherwise XcmsFailure
+ *
+ */
+{
+ XcmsColor tmp;
+
+ tmp.format = XcmsRGBiFormat;
+ tmp.pixel = 0;
+ tmp.spec.RGBi.red = 1.0;
+ tmp.spec.RGBi.green = 1.0;
+ tmp.spec.RGBi.blue = 1.0;
+ if (XcmsConvertColors(ccc, &tmp, 1, target_format, NULL) != XcmsSuccess) {
+ return(XcmsFailure);
+ }
+ memcpy((char *)pColor_ret, (char *)&tmp, sizeof(XcmsColor));
+ return(XcmsSuccess);
+}
diff --git a/nx-X11/lib/src/xcms/QuCol.c b/nx-X11/lib/src/xcms/QuCol.c
new file mode 100644
index 000000000..b4c1cd33a
--- /dev/null
+++ b/nx-X11/lib/src/xcms/QuCol.c
@@ -0,0 +1,78 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ * NAME
+ * XcmsQuCol.c
+ *
+ * DESCRIPTION
+ * Source for XcmsQueryColors
+ *
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+
+/************************************************************************
+ * *
+ * PUBLIC ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsQueryColor - Query Color
+ *
+ * SYNOPSIS
+ */
+Status
+XcmsQueryColor(
+ Display *dpy,
+ Colormap colormap,
+ XcmsColor *pXcmsColor_in_out,
+ XcmsColorFormat result_format)
+/*
+ * DESCRIPTION
+ * This routine uses XQueryColor to obtain the X RGB values
+ * stored in the specified colormap for the specified pixel.
+ * The X RGB values are then converted to the target format as
+ * specified by the format component of the XcmsColor structure.
+ *
+ * RETURNS
+ * XcmsFailure if failed;
+ * XcmsSuccess if it succeeded.
+ *
+ * Returns a color specification of the color stored in the
+ * specified pixel.
+ */
+{
+ return(_XcmsSetGetColor(XQueryColor, dpy, colormap,
+ pXcmsColor_in_out, result_format, (Bool *) NULL));
+}
diff --git a/nx-X11/lib/src/xcms/QuCols.c b/nx-X11/lib/src/xcms/QuCols.c
new file mode 100644
index 000000000..25a38b818
--- /dev/null
+++ b/nx-X11/lib/src/xcms/QuCols.c
@@ -0,0 +1,78 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ * NAME
+ * XcmsQuCol.c
+ *
+ * DESCRIPTION
+ * Source for XcmsQueryColors
+ *
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+
+/************************************************************************
+ * *
+ * PUBLIC ROUTINES *
+ * *
+ ************************************************************************/
+/*
+ * NAME
+ * XcmsQueryColors - Query Colors
+ *
+ * SYNOPSIS
+ */
+Status
+XcmsQueryColors(
+ Display *dpy,
+ Colormap colormap,
+ XcmsColor *pXcmsColors_in_out,
+ unsigned int nColors,
+ XcmsColorFormat result_format)
+/*
+ * DESCRIPTION
+ * This routine uses XQueryColors to obtain the X RGB values
+ * stored in the specified colormap for the specified pixels.
+ * The X RGB values are then converted to the target format as
+ * specified by the format component of the XcmsColor structure.
+ *
+ * RETURNS
+ * XcmsFailure if failed;
+ * XcmsSuccess if it succeeded.
+ *
+ * Returns the color specifications of the colors stored in the
+ * specified pixels.
+ */
+{
+ return(_XcmsSetGetColors(XQueryColors, dpy, colormap,
+ pXcmsColors_in_out, nColors, result_format, (Bool *) NULL));
+}
diff --git a/nx-X11/lib/src/xcms/SetCCC.c b/nx-X11/lib/src/xcms/SetCCC.c
new file mode 100644
index 000000000..e8171b4ea
--- /dev/null
+++ b/nx-X11/lib/src/xcms/SetCCC.c
@@ -0,0 +1,138 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ * NAME
+ * XcmsSetCCC.c - Color Conversion Context Setting Routines
+ *
+ * DESCRIPTION
+ * Routines to set components of a Color Conversion
+ * Context structure.
+ *
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcms.h"
+
+
+
+/************************************************************************
+ * *
+ * PUBLIC INTERFACES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsSetWhitePoint
+ *
+ * SYNOPSIS
+ */
+
+Status
+XcmsSetWhitePoint(
+ XcmsCCC ccc,
+ XcmsColor *pColor)
+/*
+ * DESCRIPTION
+ * Sets the Client White Point in the specified CCC.
+ *
+ * RETURNS
+ * Returns XcmsSuccess if succeeded; otherwise XcmsFailure.
+ *
+ */
+{
+ if (pColor == NULL || pColor->format == XcmsUndefinedFormat) {
+ ccc->clientWhitePt.format = XcmsUndefinedFormat;
+ } else if (pColor->format != XcmsCIEXYZFormat &&
+ pColor->format != XcmsCIEuvYFormat &&
+ pColor->format != XcmsCIExyYFormat) {
+ return(XcmsFailure);
+ } else {
+ memcpy((char *)&ccc->clientWhitePt, (char *)pColor, sizeof(XcmsColor));
+ }
+ return(XcmsSuccess);
+}
+
+
+/*
+ * NAME
+ * XcmsSetCompressionProc
+ *
+ * SYNOPSIS
+ */
+
+XcmsCompressionProc
+XcmsSetCompressionProc(
+ XcmsCCC ccc,
+ XcmsCompressionProc compression_proc,
+ XPointer client_data)
+/*
+ * DESCRIPTION
+ * Set the specified CCC's compression function and client data.
+ *
+ * RETURNS
+ * Returns the old compression function.
+ *
+ */
+{
+ XcmsCompressionProc old = ccc->gamutCompProc;
+
+ ccc->gamutCompProc = compression_proc;
+ ccc->gamutCompClientData = client_data;
+ return(old);
+}
+
+
+/*
+ * NAME
+ * XcmsSetWhiteAdjustProc
+ *
+ * SYNOPSIS
+ */
+
+XcmsWhiteAdjustProc
+XcmsSetWhiteAdjustProc(
+ XcmsCCC ccc,
+ XcmsWhiteAdjustProc white_adjust_proc,
+ XPointer client_data )
+/*
+ * DESCRIPTION
+ * Set the specified CCC's white_adjust function and client data.
+ *
+ * RETURNS
+ * Returns the old white_adjust function.
+ *
+ */
+{
+ XcmsWhiteAdjustProc old = ccc->whitePtAdjProc;
+
+ ccc->whitePtAdjProc = white_adjust_proc;
+ ccc->whitePtAdjClientData = client_data;
+ return(old);
+}
diff --git a/nx-X11/lib/src/xcms/SetGetCols.c b/nx-X11/lib/src/xcms/SetGetCols.c
new file mode 100644
index 000000000..83fa4c200
--- /dev/null
+++ b/nx-X11/lib/src/xcms/SetGetCols.c
@@ -0,0 +1,301 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ * NAME
+ * XcmsSetGet.c
+ *
+ * DESCRIPTION
+ * Source for _XcmsSetGetColors()
+ *
+ *
+ */
+
+/*
+ * EXTERNAL INCLUDES
+ * Include files that must be exported to any package or
+ * program using this package.
+ */
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+
+/************************************************************************
+ * *
+ * API PRIVATE ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsSetColor -
+ *
+ * SYNOPSIS
+ */
+Status
+_XcmsSetGetColor(
+ Status (*xColorProc)(
+ Display* /* display */,
+ Colormap /* colormap */,
+ XColor* /* screen_in_out */),
+ Display *dpy,
+ Colormap cmap,
+ XcmsColor *pColors_in_out,
+ XcmsColorFormat result_format,
+ Bool *pCompressed)
+/*
+ * DESCRIPTION
+ * Routine containing code common to:
+ * XcmsAllocColor
+ * XcmsQueryColor
+ * XcmsStoreColor
+ *
+ * RETURNS
+ * XcmsFailure if failed;
+ * XcmsSuccess if it succeeded without gamut compression;
+ * XcmsSuccessWithCompression if it succeeded with gamut
+ * compression;
+ */
+{
+ XcmsCCC ccc;
+ XColor XColors_in_out;
+ Status retval = XcmsSuccess;
+
+ /*
+ * Argument Checking
+ * 1. Assume xColorProc is correct
+ * 2. Insure ccc not NULL
+ * 3. Assume cmap correct (should be checked by Server)
+ * 4. Insure pColors_in_out valid
+ * 5. Assume method_in is valid (should be checked by Server)
+ */
+
+ if (dpy == NULL) {
+ return(XcmsFailure);
+ }
+
+ if (result_format == XcmsUndefinedFormat) {
+ return(XcmsFailure);
+ }
+
+ if ( !((*xColorProc == XAllocColor) || (*xColorProc == XStoreColor)
+ || (*xColorProc == XQueryColor)) ) {
+ return(XcmsFailure);
+ }
+
+ if ((ccc = XcmsCCCOfColormap(dpy, cmap)) == (XcmsCCC)NULL) {
+ return(XcmsFailure);
+ }
+
+ if (*xColorProc == XQueryColor) {
+ goto Query;
+ }
+
+ /*
+ * Convert to RGB, adjusting for white point differences if necessary.
+ */
+ if ((retval = XcmsConvertColors(ccc, pColors_in_out, 1, XcmsRGBFormat,
+ pCompressed)) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+Query:
+ /*
+ * Convert XcmsColor to XColor structures
+ */
+ _XcmsRGB_to_XColor(pColors_in_out, &XColors_in_out, 1);
+
+ /*
+ * Now make appropriate X Call
+ */
+ if (*xColorProc == XAllocColor) {
+ if ((*xColorProc)(ccc->dpy, cmap, &XColors_in_out) == 0) {
+ return(XcmsFailure);
+ }
+ } else if ((*xColorProc == XQueryColor) || (*xColorProc == XStoreColor)) {
+ /* Note: XQueryColor and XStoreColor do not return any Status */
+ (*xColorProc)(ccc->dpy, cmap, &XColors_in_out);
+ } else {
+ return(XcmsFailure);
+ }
+
+ if ((*xColorProc == XStoreColor)) {
+ return(retval);
+ }
+
+ /*
+ * Now, convert the returned XColor (i.e., rgb) to XcmsColor structures
+ */
+ _XColor_to_XcmsRGB(ccc, &XColors_in_out, pColors_in_out, 1);
+
+ /*
+ * Then, convert XcmsColor structures to the original specification
+ * format. Note that we must use NULL instead of passing
+ * pCompressed.
+ */
+
+ if (result_format != XcmsRGBFormat) {
+ if (XcmsConvertColors(ccc, pColors_in_out, 1, result_format,
+ (Bool *) NULL) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+ }
+ return(retval);
+}
+
+/*
+ * NAME
+ * XcmsSetColors -
+ *
+ * SYNOPSIS
+ */
+Status
+_XcmsSetGetColors(
+ Status (*xColorProc)(
+ Display* /* display */,
+ Colormap /* colormap */,
+ XColor* /* screen_in_out */,
+ int /* nColors */),
+ Display *dpy,
+ Colormap cmap,
+ XcmsColor *pColors_in_out,
+ int nColors,
+ XcmsColorFormat result_format,
+ Bool *pCompressed)
+/*
+ * DESCRIPTION
+ * Routine containing code common to:
+ * XcmsQueryColors
+ * XcmsStoreColors
+ *
+ * RETURNS
+ * XcmsFailure if failed;
+ * XcmsSuccess if it succeeded without gamut compression;
+ * XcmsSuccessWithCompression if it succeeded with gamut
+ * compression;
+ */
+{
+ XcmsCCC ccc;
+ XColor *pXColors_in_out;
+ Status retval = XcmsSuccess;
+
+ /*
+ * Argument Checking
+ * 1. Assume xColorProc is correct
+ * 2. Insure ccc not NULL
+ * 3. Assume cmap correct (should be checked by Server)
+ * 4. Insure pColors_in_out valid
+ * 5. Assume method_in is valid (should be checked by Server)
+ * 6. Insure nColors > 0
+ */
+
+ if (dpy == NULL) {
+ return(XcmsFailure);
+ }
+
+ if (nColors == 0) {
+ return(XcmsSuccess);
+ }
+
+ if (result_format == XcmsUndefinedFormat) {
+ return(XcmsFailure);
+ }
+
+ if ( !((*xColorProc == XStoreColors) || (*xColorProc == XQueryColors)) ) {
+ return(XcmsFailure);
+ }
+
+ if ((ccc = XcmsCCCOfColormap(dpy, cmap)) == (XcmsCCC)NULL) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Allocate space for XColors
+ */
+ if ((pXColors_in_out = Xcalloc(nColors, sizeof(XColor))) ==
+ NULL) {
+ return(XcmsFailure);
+ }
+
+ if (*xColorProc == XQueryColors) {
+ goto Query;
+ }
+
+ /*
+ * Convert to RGB, adjusting for white point differences if necessary.
+ */
+ if ((retval = XcmsConvertColors(ccc, pColors_in_out, nColors, XcmsRGBFormat,
+ pCompressed)) == XcmsFailure) {
+ Xfree(pXColors_in_out);
+ return(XcmsFailure);
+ }
+
+Query:
+ /*
+ * Convert XcmsColor to XColor structures
+ */
+ _XcmsRGB_to_XColor(pColors_in_out, pXColors_in_out, nColors);
+
+ /*
+ * Now make appropriate X Call
+ */
+ if ((*xColorProc == XQueryColors) || (*xColorProc == XStoreColors)){
+ /* Note: XQueryColors and XStoreColors do not return any Status */
+ (*xColorProc)(ccc->dpy, cmap, pXColors_in_out, nColors);
+ } else {
+ Xfree(pXColors_in_out);
+ return(XcmsFailure);
+ }
+
+ if (*xColorProc == XStoreColors) {
+ Xfree(pXColors_in_out);
+ return(retval);
+ }
+
+ /*
+ * Now, convert the returned XColor (i.e., rgb) to XcmsColor structures
+ */
+ _XColor_to_XcmsRGB(ccc, pXColors_in_out, pColors_in_out, nColors);
+ Xfree(pXColors_in_out);
+
+ /*
+ * Then, convert XcmsColor structures to the original specification
+ * format. Note that we must use NULL instead of passing
+ * pCompressed.
+ */
+ if (result_format != XcmsRGBFormat) {
+ if (XcmsConvertColors(ccc, pColors_in_out, nColors, result_format,
+ (Bool *) NULL) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+ }
+
+ return(retval);
+}
+
+/* ### EOF ### */
diff --git a/nx-X11/lib/src/xcms/StCol.c b/nx-X11/lib/src/xcms/StCol.c
new file mode 100644
index 000000000..941ad0743
--- /dev/null
+++ b/nx-X11/lib/src/xcms/StCol.c
@@ -0,0 +1,82 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ * NAME
+ * XcmsStCol.c
+ *
+ * DESCRIPTION
+ * Source for XcmsStoreColor
+ *
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+
+/************************************************************************
+ * *
+ * PUBLIC ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsStoreColor - Store Color
+ *
+ * SYNOPSIS
+ */
+Status
+XcmsStoreColor(
+ Display *dpy,
+ Colormap colormap,
+ XcmsColor *pColor_in)
+/*
+ * DESCRIPTION
+ * Given a device-dependent or device-independent color
+ * specification, this routine will convert it to X RGB
+ * values then use it in a call to XStoreColor.
+ *
+ * RETURNS
+ * XcmsFailure if failed;
+ * XcmsSuccess if it succeeded without gamut compression;
+ * XcmsSuccessWithCompression if it succeeded with gamut
+ * compression;
+ *
+ * Since XStoreColor has no return value this routine
+ * does not return the color specification of the color actually
+ * stored.
+ */
+{
+ XcmsColor tmpColor;
+
+ tmpColor = *pColor_in;
+ return(_XcmsSetGetColor(XStoreColor, dpy, colormap,
+ &tmpColor, XcmsRGBFormat, (Bool *) NULL));
+}
diff --git a/nx-X11/lib/src/xcms/StCols.c b/nx-X11/lib/src/xcms/StCols.c
new file mode 100644
index 000000000..42a29cd7f
--- /dev/null
+++ b/nx-X11/lib/src/xcms/StCols.c
@@ -0,0 +1,112 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ * NAME
+ * XcmsStCols.c
+ *
+ * DESCRIPTION
+ * Source for XcmsStoreColors
+ *
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+
+/************************************************************************
+ * *
+ * PUBLIC ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsStoreColors - Store Colors
+ *
+ * SYNOPSIS
+ */
+Status
+XcmsStoreColors(
+ Display *dpy,
+ Colormap colormap,
+ XcmsColor *pColors_in,
+ unsigned int nColors,
+ Bool *pCompressed)
+/*
+ * DESCRIPTION
+ * Given device-dependent or device-independent color
+ * specifications, this routine will convert them to X RGB
+ * values then use it in a call to XStoreColors.
+ *
+ * RETURNS
+ * XcmsFailure if failed;
+ * XcmsSuccess if it succeeded without gamut compression;
+ * XcmsSuccessWithCompression if it succeeded with gamut
+ * compression;
+ *
+ * Since XStoreColors has no return value, this routine
+ * does not return color specifications of the colors actually
+ * stored.
+ */
+{
+ XcmsColor Color1;
+ XcmsColor *pColors_tmp;
+ Status retval;
+
+ /*
+ * Make copy of array of color specifications so we don't
+ * overwrite the contents.
+ */
+ if (nColors > 1) {
+ pColors_tmp = Xmalloc(nColors * sizeof(XcmsColor));
+ } else {
+ pColors_tmp = &Color1;
+ }
+ memcpy((char *)pColors_tmp, (char *)pColors_in,
+ nColors * sizeof(XcmsColor));
+
+ /*
+ * Call routine to store colors using the copied color structures
+ */
+ retval = _XcmsSetGetColors (XStoreColors, dpy, colormap,
+ pColors_tmp, nColors, XcmsRGBFormat, pCompressed);
+
+ /*
+ * Free copies as needed.
+ */
+ if (nColors > 1) {
+ Xfree(pColors_tmp);
+ }
+
+ /*
+ * Ah, finally return.
+ */
+ return(retval);
+}
diff --git a/nx-X11/lib/src/xcms/UNDEFINED.c b/nx-X11/lib/src/xcms/UNDEFINED.c
new file mode 100644
index 000000000..7b1bdb68c
--- /dev/null
+++ b/nx-X11/lib/src/xcms/UNDEFINED.c
@@ -0,0 +1,131 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ *
+ * NAME
+ * UNDEFINED.c
+ *
+ * DESCRIPTION
+ * UNDEFINED Color Space
+ *
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+
+/*
+ * FORWARD DECLARATIONS
+ */
+static int DummyParseStringProc(
+ char* /* color_string */,
+ XcmsColor* /* color_return */
+ );
+static Status ReturnZero(
+ XcmsCCC /* ccc */,
+ XcmsColor* /* white_point */,
+ XcmsColor* /* colors */,
+ unsigned int /* ncolors */
+ );
+
+
+/*
+ * LOCALS VARIABLES
+ */
+
+static Status (*(Fl_ReturnZero[]))(
+ XcmsCCC /* ccc */,
+ XcmsColor* /* white_point */,
+ XcmsColor* /* colors */,
+ unsigned int /* ncolors */
+ ) = {
+ ReturnZero,
+ NULL
+};
+
+
+/*
+ * GLOBALS
+ * Variables declared in this package that are allowed
+ * to be used globally.
+ */
+ /*
+ * UNDEFINED Color Space
+ */
+XcmsColorSpace XcmsUNDEFINEDColorSpace =
+ {
+ "undefined", /* prefix */
+ XcmsUndefinedFormat, /* id */
+ &DummyParseStringProc, /* parseString */
+ Fl_ReturnZero, /* to_CIEXYZ */
+ Fl_ReturnZero /* from_CIEXYZ */
+ };
+
+
+
+/************************************************************************
+ * *
+ * PRIVATE ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * ReturnZero
+ *
+ * SYNOPSIS
+ */
+/* ARGSUSED */
+static Status
+ReturnZero(
+ XcmsCCC ccc /* ccc */,
+ XcmsColor* white /* white_point */,
+ XcmsColor* colors /* colors */,
+ unsigned int ncolors /* ncolors */
+ )
+/*
+ * DESCRIPTION
+ * Does nothing.
+ *
+ * RETURNS
+ * 0
+ *
+ */
+{
+ return(0);
+}
+
+static int DummyParseStringProc(
+ char* color_string /* color_string */,
+ XcmsColor* color_return /* color_return */
+ )
+{
+ return(0);
+}
+
+/* ### EOF ### */
diff --git a/nx-X11/lib/src/xcms/XRGB.c b/nx-X11/lib/src/xcms/XRGB.c
new file mode 100644
index 000000000..03f980e99
--- /dev/null
+++ b/nx-X11/lib/src/xcms/XRGB.c
@@ -0,0 +1,242 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ * NAME
+ * XcmsRtoX.c
+ *
+ * DESCRIPTION
+ * Convert color specifications in XcmsRGB format in one array of
+ * XcmsColor structures to RGB in an array of XColor structures.
+ *
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+/*
+ * LOCAL VARIABLES
+ */
+
+static unsigned short const MASK[17] = {
+ 0x0000, /* 0 bitsPerRGB */
+ 0x8000, /* 1 bitsPerRGB */
+ 0xc000, /* 2 bitsPerRGB */
+ 0xe000, /* 3 bitsPerRGB */
+ 0xf000, /* 4 bitsPerRGB */
+ 0xf800, /* 5 bitsPerRGB */
+ 0xfc00, /* 6 bitsPerRGB */
+ 0xfe00, /* 7 bitsPerRGB */
+ 0xff00, /* 8 bitsPerRGB */
+ 0xff80, /* 9 bitsPerRGB */
+ 0xffc0, /* 10 bitsPerRGB */
+ 0xffe0, /* 11 bitsPerRGB */
+ 0xfff0, /* 12 bitsPerRGB */
+ 0xfff8, /* 13 bitsPerRGB */
+ 0xfffc, /* 14 bitsPerRGB */
+ 0xfffe, /* 15 bitsPerRGB */
+ 0xffff /* 16 bitsPerRGB */
+};
+
+
+
+/************************************************************************
+ * *
+ * API PRIVATE ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * _XcmsRGB_to_XColor -
+ *
+ * SYNOPSIS
+ */
+void
+_XcmsRGB_to_XColor(
+ XcmsColor *pColors,
+ XColor *pXColors,
+ unsigned int nColors)
+/*
+ * DESCRIPTION
+ * Translates a color specification in XcmsRGBFormat in a XcmsColor
+ * structure to an XColor structure.
+ *
+ * RETURNS
+ * void.
+ */
+{
+ for (; nColors--; pXColors++, pColors++) {
+ pXColors->pixel = pColors->pixel;
+ pXColors->red = pColors->spec.RGB.red;
+ pXColors->green = pColors->spec.RGB.green;
+ pXColors->blue = pColors->spec.RGB.blue;
+ pXColors->flags = (DoRed | DoGreen | DoBlue);
+ }
+}
+
+
+/*
+ * NAME
+ * _XColor_to_XcmsRGB
+ *
+ * SYNOPSIS
+ */
+void
+_XColor_to_XcmsRGB(
+ XcmsCCC ccc,
+ XColor *pXColors,
+ XcmsColor *pColors,
+ unsigned int nColors)
+/*
+ * DESCRIPTION
+ * Translates an RGB color specification in an XColor
+ * structure to an XcmsRGB structure.
+ *
+ * IMPORTANT NOTE: Bit replication that may have been caused
+ * with ResolveColor() routine in the X Server is undone
+ * here if requested! For example, if red = 0xcaca and the
+ * bits_per_rgb is 8, then spec.RGB.red will be 0xca00.
+ *
+ * RETURNS
+ * void
+ */
+{
+ int bits_per_rgb = ccc->visual->bits_per_rgb;
+
+ for (; nColors--; pXColors++, pColors++) {
+ pColors->spec.RGB.red = (pXColors->red & MASK[bits_per_rgb]);
+ pColors->spec.RGB.green = (pXColors->green & MASK[bits_per_rgb]);
+ pColors->spec.RGB.blue = (pXColors->blue & MASK[bits_per_rgb]);
+ pColors->format = XcmsRGBFormat;
+ pColors->pixel = pXColors->pixel;
+ }
+}
+
+
+/*
+ * NAME
+ * _XcmsResolveColor
+ *
+ * SYNOPSIS
+ */
+void
+_XcmsResolveColor(
+ XcmsCCC ccc,
+ XcmsColor *pXcmsColor)
+/*
+ * DESCRIPTION
+ * Uses the X Server ResolveColor() algorithm to
+ * modify values to closest values supported by hardware.
+ * Old algorithm simply masked low-order bits. The new algorithm
+ * has the effect of replicating significant bits into lower order
+ * bits in order to stretch the hardware value into all 16 bits.
+ *
+ * On a display with N-bit DACs, the "hardware" color is computed as:
+ *
+ * ((unsignedlong)(ClientValue >> (16-N)) * 0xFFFF) / ((1 << N) - 1)
+ *
+ *
+ * RETURNS
+ * void.
+ */
+{
+ int shift;
+ int max_color;
+
+ shift = 16 - ccc->visual->bits_per_rgb;
+ max_color = (1 << ccc->visual->bits_per_rgb) - 1;
+
+
+ pXcmsColor->spec.RGB.red =
+ ((unsigned long)(pXcmsColor->spec.RGB.red >> shift) * 0xFFFF)
+ / max_color;
+ pXcmsColor->spec.RGB.green =
+ ((unsigned long)(pXcmsColor->spec.RGB.green >> shift) * 0xFFFF)
+ / max_color;
+ pXcmsColor->spec.RGB.blue =
+ ((unsigned long)(pXcmsColor->spec.RGB.blue >> shift) * 0xFFFF)
+ / max_color;
+}
+
+
+/*
+ * NAME
+ * _XcmsUnresolveColor
+ *
+ * SYNOPSIS
+ */
+void
+_XcmsUnresolveColor(
+ XcmsCCC ccc,
+ XcmsColor *pColor)
+/*
+ * DESCRIPTION
+ * Masks out insignificant bits.
+ *
+ * RETURNS
+ * void.
+ *
+ * ASSUMPTIONS
+ * format == XcmsRGBFormat
+ */
+{
+ int bits_per_rgb = ccc->visual->bits_per_rgb;
+
+ pColor->spec.RGB.red &= MASK[bits_per_rgb];
+ pColor->spec.RGB.green &= MASK[bits_per_rgb];
+ pColor->spec.RGB.blue &= MASK[bits_per_rgb];
+}
+
+
+/*
+ * NAME
+ * _XUnresolveColor
+ *
+ * SYNOPSIS
+ */
+void
+_XUnresolveColor(
+ XcmsCCC ccc,
+ XColor *pXColor)
+/*
+ * DESCRIPTION
+ * Masks out insignificant bits.
+ *
+ * RETURNS
+ * void.
+ */
+{
+ int bits_per_rgb = ccc->visual->bits_per_rgb;
+
+ pXColor->red &= MASK[bits_per_rgb];
+ pXColor->green &= MASK[bits_per_rgb];
+ pXColor->blue &= MASK[bits_per_rgb];
+}
+
diff --git a/nx-X11/lib/src/xcms/XYZ.c b/nx-X11/lib/src/xcms/XYZ.c
new file mode 100644
index 000000000..826565773
--- /dev/null
+++ b/nx-X11/lib/src/xcms/XYZ.c
@@ -0,0 +1,203 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of XCMS based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ *
+ * NAME
+ * CIEXYZ.c
+ *
+ * DESCRIPTION
+ * CIE XYZ Color Space
+ *
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <nx-X11/Xos.h>
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+#include <stdio.h> /* sscanf */
+
+/*
+ * DEFINES
+ * Internal definitions that need NOT be exported to any package
+ * or program using this package.
+ */
+#ifdef DBL_EPSILON
+# define XMY_DBL_EPSILON DBL_EPSILON
+#else
+# define XMY_DBL_EPSILON 0.00001
+#endif
+
+/*
+ * FORWARD DECLARATIONS
+ */
+static int CIEXYZ_ParseString(register char *spec, XcmsColor *pColor);
+
+/*
+ * LOCALS VARIABLES
+ */
+
+static XcmsConversionProc Fl_CIEXYZ_to_CIEXYZ[] = {
+ NULL
+};
+
+
+
+/*
+ * GLOBALS
+ * Variables declared in this package that are allowed
+ * to be used globally.
+ */
+ /*
+ * CIE XYZ Color Space
+ */
+XcmsColorSpace XcmsCIEXYZColorSpace =
+ {
+ _XcmsCIEXYZ_prefix, /* prefix */
+ XcmsCIEXYZFormat, /* id */
+ CIEXYZ_ParseString, /* parseString */
+ Fl_CIEXYZ_to_CIEXYZ, /* to_CIEXYZ */
+ Fl_CIEXYZ_to_CIEXYZ, /* from_CIEXYZ */
+ 1
+ };
+
+
+/************************************************************************
+ * *
+ * PRIVATE ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * CIEXYZ_ParseString
+ *
+ * SYNOPSIS
+ */
+static int
+CIEXYZ_ParseString(
+ register char *spec,
+ XcmsColor *pColor)
+/*
+ * DESCRIPTION
+ * This routines takes a string and attempts to convert
+ * it into a XcmsColor structure with XcmsCIEXYZFormat.
+ * The assumed CIEXYZ string syntax is:
+ * CIEXYZ:<X>/<Y>/<Z>
+ * Where X, Y, and Z are in string input format for floats
+ * consisting of:
+ * a. an optional sign
+ * b. a string of numbers possibly containing a decimal point,
+ * c. an optional exponent field containing an 'E' or 'e'
+ * followed by a possibly signed integer string.
+ *
+ * RETURNS
+ */
+{
+ size_t n;
+ char *pchar;
+
+ if ((pchar = strchr(spec, ':')) == NULL) {
+ return(XcmsFailure);
+ }
+ n = (size_t)(pchar - spec);
+
+ /*
+ * Check for proper prefix.
+ */
+ if (strncmp(spec, _XcmsCIEXYZ_prefix, n) != 0) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Attempt to parse the value portion.
+ */
+ if (sscanf(spec + n + 1, "%lf/%lf/%lf",
+ &pColor->spec.CIEXYZ.X,
+ &pColor->spec.CIEXYZ.Y,
+ &pColor->spec.CIEXYZ.Z) != 3) {
+ char *s; /* Maybe failed due to locale */
+ int f;
+ if ((s = strdup(spec))) {
+ for (f = 0; s[f]; ++f)
+ if (s[f] == '.')
+ s[f] = ',';
+ else if (s[f] == ',')
+ s[f] = '.';
+ if (sscanf(s + n + 1, "%lf/%lf/%lf",
+ &pColor->spec.CIEXYZ.X,
+ &pColor->spec.CIEXYZ.Y,
+ &pColor->spec.CIEXYZ.Z) != 3) {
+ free(s);
+ return(XcmsFailure);
+ }
+ free(s);
+ } else
+ return(XcmsFailure);
+ }
+ pColor->format = XcmsCIEXYZFormat;
+ pColor->pixel = 0;
+ return(_XcmsCIEXYZ_ValidSpec(pColor));
+}
+
+
+/************************************************************************
+ * *
+ * PUBLIC ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsCIELab_ValidSpec
+ *
+ * SYNOPSIS
+ */
+Status
+_XcmsCIEXYZ_ValidSpec(
+ XcmsColor *pColor)
+/*
+ * DESCRIPTION
+ * Checks if color specification valid for CIE XYZ
+ *
+ * RETURNS
+ * XcmsFailure if invalid,
+ * XcmsSuccess if valid.
+ *
+ */
+{
+ if (pColor->format != XcmsCIEXYZFormat
+ ||
+ (pColor->spec.CIEXYZ.Y < 0.0 - XMY_DBL_EPSILON)
+ ||
+ (pColor->spec.CIEXYZ.Y > 1.0 + XMY_DBL_EPSILON)) {
+ return(XcmsFailure);
+ }
+ return(XcmsSuccess);
+}
diff --git a/nx-X11/lib/src/xcms/Xcms.txt b/nx-X11/lib/src/xcms/Xcms.txt
new file mode 100644
index 000000000..1c5b1adec
--- /dev/null
+++ b/nx-X11/lib/src/xcms/Xcms.txt
@@ -0,0 +1,44 @@
+/*
+ * (c) Copyright 1990 1991 Tektronix Inc.
+ * All Rights Reserved
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation for any purpose and without fee is hereby granted,
+ * provided that the above copyright notice appear in all copies and that
+ * both that copyright notice and this permission notice appear in
+ * supporting documentation, and that the name of Tektronix not be used
+ * in advertising or publicity pertaining to distribution of the software
+ * without specific, written prior permission.
+ *
+ * Tektronix disclaims all warranties with regard to this software, including
+ * all implied warranties of merchantability and fitness, in no event shall
+ * Tektronix be liable for any special, indirect or consequential damages or
+ * any damages whatsoever resulting from loss of use, data or profits,
+ * whether in an action of contract, negligence or other tortious action,
+ * arising out of or in connection with the use or performance of this
+ * software.
+ *
+ *
+ * NAME
+ * Xcms.txt
+ *
+ * DESCRIPTION
+ * Sample Color Name Database
+ *
+ */
+
+
+This device-independent color name database is provided just as an example.
+There are no claims that these color specifications are or should be bound
+to the corresponding color name.
+
+As you can see, the start of the database is indicated by "XCMS_COLORDB_START".
+Anything before this is assumed to be comments. The "0.1" indicates the
+version number of the format/syntax used in this file. The color name is
+delimited from the color specification by one or more tabs.
+
+XCMS_COLORDB_START 0.1
+cms red CIEXYZ:0.3811/0.2073/0.0213
+cms green CIEXYZ:0.3203/0.6805/0.1430
+cms blue CIEXYZ:0.2483/0.1122/1.2417
+XCMS_COLORDB_END
diff --git a/nx-X11/lib/src/xcms/Xcmsint.h b/nx-X11/lib/src/xcms/Xcmsint.h
new file mode 100644
index 000000000..8a2decb11
--- /dev/null
+++ b/nx-X11/lib/src/xcms/Xcmsint.h
@@ -0,0 +1,260 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ * DESCRIPTION
+ * Private include file for Color Management System.
+ * (i.e., for API internal use only)
+ *
+ */
+
+#ifndef _XCMSINT_H_
+#define _XCMSINT_H_
+
+#include <nx-X11/Xcms.h>
+
+/*
+ * DEFINES
+ */
+
+ /*
+ * Private Status Value
+ */
+#define _XCMS_NEWNAME -1
+
+ /*
+ * Color Space ID's are of XcmsColorFormat type.
+ *
+ * bit 31
+ * 0 == Device-Independent
+ * 1 == Device-Dependent
+ *
+ * bit 30:
+ * 0 == Registered with X Consortium
+ * 1 == Unregistered
+ */
+#define XCMS_DD_ID(id) ((id) & (XcmsColorFormat)0x80000000)
+#define XCMS_DI_ID(id) (!((id) & (XcmsColorFormat)0x80000000))
+#define XCMS_UNREG_ID(id) ((id) & (XcmsColorFormat)0x40000000)
+#define XCMS_REG_ID(id) (!((id) & (XcmsColorFormat)0x40000000))
+#define XCMS_FIRST_REG_DI_ID (XcmsColorFormat)0x00000001
+#define XCMS_FIRST_UNREG_DI_ID (XcmsColorFormat)0x40000000
+#define XCMS_FIRST_REG_DD_ID (XcmsColorFormat)0x80000000
+#define XCMS_FIRST_UNREG_DD_ID (XcmsColorFormat)0xc0000000
+
+/*
+ * TYPEDEFS
+ */
+
+ /*
+ * Structure for caching Colormap info.
+ * This is provided for the Xlib modifications to:
+ * XAllocNamedColor()
+ * XLookupColor()
+ * XParseColor()
+ * XStoreNamedColor()
+ */
+typedef struct _XcmsCmapRec {
+ Colormap cmapID;
+ Display *dpy;
+ Window windowID;
+ Visual *visual;
+ struct _XcmsCCC *ccc;
+ struct _XcmsCmapRec *pNext;
+} XcmsCmapRec;
+
+ /*
+ * Intensity Record (i.e., value / intensity tuple)
+ */
+typedef struct _IntensityRec {
+ unsigned short value;
+ XcmsFloat intensity;
+} IntensityRec;
+
+ /*
+ * Intensity Table
+ */
+typedef struct _IntensityTbl {
+ IntensityRec *pBase;
+ unsigned int nEntries;
+} IntensityTbl;
+
+ /*
+ * Structure for storing per-Visual Intensity Tables (aka gamma maps).
+ */
+typedef struct _XcmsIntensityMap {
+ VisualID visualID;
+ XPointer screenData; /* pointer to corresponding Screen Color*/
+ /* Characterization Data */
+ void (*pFreeScreenData)(XPointer pScreenDataTemp); /* Function that frees a Screen */
+ /* structure. */
+ struct _XcmsIntensityMap *pNext;
+} XcmsIntensityMap;
+
+
+ /*
+ * Structure for storing "registered" color space prefix/ID
+ */
+typedef struct _XcmsRegColorSpaceEntry {
+ const char *prefix; /* Color Space prefix (e.g., "CIEXYZ:") */
+ XcmsColorFormat id; /* Color Space ID (e.g., XcmsCIEXYZFormat) */
+} XcmsRegColorSpaceEntry;
+
+
+ /*
+ * Xcms Per Display (i.e. connection) related data
+ */
+typedef struct _XcmsPerDpyInfo {
+
+ XcmsCCC paDefaultCCC; /* based on default visual of screen */
+ /*
+ * Pointer to an array of XcmsCCC structures, one for
+ * each screen.
+ */
+ XcmsCmapRec *pClientCmaps; /* Pointer to linked list of XcmsCmapRec's */
+
+} XcmsPerDpyInfo, *XcmsPerDpyInfoPtr;
+
+/*
+ * DEFINES
+ */
+
+#define XDCCC_NUMBER 0x8000000L /* 2**27 per XDCCC */
+
+#ifdef GRAY
+#define XDCCC_SCREENWHITEPT_ATOM_NAME "XDCCC_GRAY_SCREENWHITEPOINT"
+#define XDCCC_GRAY_CORRECT_ATOM_NAME "XDCCC_GRAY_CORRECTION"
+#endif /* GRAY */
+
+#ifndef _ConversionValues
+typedef struct _ConversionValues {
+ IntensityTbl IntensityTbl;
+} ConversionValues;
+#endif
+
+#ifdef GRAY
+typedef struct {
+ IntensityTbl *IntensityTbl;
+} GRAY_SCCData;
+#endif /* GRAY */
+
+/*
+ * DEFINES
+ */
+
+#define XDCCC_MATRIX_ATOM_NAME "XDCCC_LINEAR_RGB_MATRICES"
+#define XDCCC_CORRECT_ATOM_NAME "XDCCC_LINEAR_RGB_CORRECTION"
+
+typedef struct {
+ XcmsFloat XYZtoRGBmatrix[3][3];
+ XcmsFloat RGBtoXYZmatrix[3][3];
+ IntensityTbl *pRedTbl;
+ IntensityTbl *pGreenTbl;
+ IntensityTbl *pBlueTbl;
+} LINEAR_RGB_SCCData;
+
+/* function prototypes */
+extern XcmsCmapRec *
+_XcmsAddCmapRec(
+ Display *dpy,
+ Colormap cmap,
+ Window windowID,
+ Visual *visual);
+extern void
+_XcmsRGB_to_XColor(
+ XcmsColor *pColors,
+ XColor *pXColors,
+ unsigned int nColors);
+extern Status
+_XcmsResolveColorString (
+ XcmsCCC ccc,
+ const char **color_string,
+ XcmsColor *pColor_exact_return,
+ XcmsColorFormat result_format);
+extern void
+_XUnresolveColor(
+ XcmsCCC ccc,
+ XColor *pXColor);
+/*
+ * DESCRIPTION
+ * Include file for defining the math macros used in the
+ * XCMS source. Instead of using math library routines
+ * directly, XCMS uses macros so that based on the
+ * definitions here, vendors and sites can specify exactly
+ * what routine will be called (those from libm.a or their
+ * custom routines). If not defined to math library routines
+ * (e.g., sqrt in libm.a), then the client is not forced to
+ * be linked with -lm.
+ */
+
+#define XCMS_ATAN(x) _XcmsArcTangent(x)
+#define XCMS_COS(x) _XcmsCosine(x)
+#define XCMS_CUBEROOT(x) _XcmsCubeRoot(x)
+#define XCMS_FABS(x) ((x) < 0.0 ? -(x) : (x))
+#define XCMS_SIN(x) _XcmsSine(x)
+#define XCMS_SQRT(x) _XcmsSquareRoot(x)
+#define XCMS_TAN(x) (XCMS_SIN(x) / XCMS_COS(x))
+
+double _XcmsArcTangent(double a);
+double _XcmsCosine(double a);
+double _XcmsCubeRoot(double a);
+double _XcmsSine(double a);
+double _XcmsSquareRoot(double a);
+
+/*
+ * DEFINES FOR GAMUT COMPRESSION AND QUERY ROUTINES
+ */
+#ifndef PI
+# ifdef M_PI
+# define PI M_PI
+# else
+# define PI 3.14159265358979323846264338327950
+# endif /* M_PI */
+#endif /* PI */
+#ifndef degrees
+# define degrees(r) ((XcmsFloat)(r) * 180.0 / PI)
+#endif /* degrees */
+#ifndef radians
+# define radians(d) ((XcmsFloat)(d) * PI / 180.0)
+#endif /* radians */
+
+#define XCMS_CIEUSTAROFHUE(h,c) \
+((XCMS_COS((h)) == 0.0) ? (XcmsFloat)0.0 : (XcmsFloat) \
+((XcmsFloat)(c) / (XcmsFloat)XCMS_SQRT((XCMS_TAN(h) * XCMS_TAN(h)) + \
+(XcmsFloat)1.0)))
+#define XCMS_CIEVSTAROFHUE(h,c) \
+((XCMS_COS((h)) == 0.0) ? (XcmsFloat)0.0 : (XcmsFloat) \
+((XcmsFloat)(c) / (XcmsFloat)XCMS_SQRT(((XcmsFloat)1.0 / \
+(XcmsFloat)(XCMS_TAN(h) * XCMS_TAN(h))) + (XcmsFloat)1.0)))
+/* this hue is returned in radians */
+#define XCMS_CIELUV_PMETRIC_HUE(u,v) \
+(((u) != 0.0) ? XCMS_ATAN( (v) / (u)) : ((v >= 0.0) ? PI / 2 : -(PI / 2)))
+#define XCMS_CIELUV_PMETRIC_CHROMA(u,v) XCMS_SQRT(((u)*(u)) + ((v)*(v)))
+
+#define XCMS_CIEASTAROFHUE(h,c) XCMS_CIEUSTAROFHUE((h), (c))
+#define XCMS_CIEBSTAROFHUE(h,c) XCMS_CIEVSTAROFHUE((h), (c))
+#define XCMS_CIELAB_PMETRIC_HUE(a,b) XCMS_CIELUV_PMETRIC_HUE((a), (b))
+#define XCMS_CIELAB_PMETRIC_CHROMA(a,b) XCMS_CIELUV_PMETRIC_CHROMA((a), (b))
+
+#endif /* _XCMSINT_H_ */
diff --git a/nx-X11/lib/src/xcms/cmsAllCol.c b/nx-X11/lib/src/xcms/cmsAllCol.c
new file mode 100644
index 000000000..aeea46461
--- /dev/null
+++ b/nx-X11/lib/src/xcms/cmsAllCol.c
@@ -0,0 +1,74 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ * NAME
+ * XcmsAllCol.c
+ *
+ * DESCRIPTION
+ * Source for XcmsAllocColor
+ *
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+
+/*
+ * NAME
+ * XcmsAllocColor - Allocate Color
+ *
+ * SYNOPSIS
+ */
+Status
+XcmsAllocColor(
+ Display *dpy,
+ Colormap colormap,
+ XcmsColor *pXcmsColor_in_out,
+ XcmsColorFormat result_format)
+/*
+ * DESCRIPTION
+ * Given a device-dependent or device-independent color
+ * specification, XcmsAllocColor will convert it to X RGB
+ * values then use it in a call to XAllocColor.
+ *
+ * RETURNS
+ * XcmsFailure if failed;
+ * XcmsSuccess if it succeeded without gamut compression;
+ * XcmsSuccessWithCompression if it succeeded with gamut
+ * compression;
+ *
+ * Also returns the pixel value of the color cell and a color
+ * specification of the color actually stored.
+ *
+ */
+{
+ return(_XcmsSetGetColor(XAllocColor, dpy, colormap, pXcmsColor_in_out,
+ result_format, (Bool *)NULL));
+}
diff --git a/nx-X11/lib/src/xcms/cmsAllNCol.c b/nx-X11/lib/src/xcms/cmsAllNCol.c
new file mode 100644
index 000000000..d39de6cbd
--- /dev/null
+++ b/nx-X11/lib/src/xcms/cmsAllNCol.c
@@ -0,0 +1,198 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ * NAME
+ * XcmsAlNCol.c
+ *
+ * DESCRIPTION
+ * Source for XcmsAllocNamedColor
+ *
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <stdio.h>
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+
+/*
+ * NAME
+ * XcmsAllocNamedColor -
+ *
+ * SYNOPSIS
+ */
+Status
+XcmsAllocNamedColor (
+ Display *dpy,
+ Colormap cmap,
+ _Xconst char *colorname,
+ XcmsColor *pColor_scrn_return,
+ XcmsColor *pColor_exact_return,
+ XcmsColorFormat result_format)
+/*
+ * DESCRIPTION
+ * Finds the color specification associated with the color
+ * name in the Device-Independent Color Name Database, then
+ * converts that color specification to an RGB format. This
+ * RGB value is then used in a call to XAllocColor to allocate
+ * a read-only color cell.
+ *
+ * RETURNS
+ * 0 if failed to parse string or find any entry in the database.
+ * 1 if succeeded in converting color name to XcmsColor.
+ * 2 if succeeded in converting color name to another color name.
+ *
+ */
+{
+ long nbytes;
+ xAllocNamedColorReply rep;
+ xAllocNamedColorReq *req;
+ XColor hard_def;
+ XColor exact_def;
+ Status retval1 = 1;
+ Status retval2 = XcmsSuccess;
+ XcmsColor tmpColor;
+ XColor XColor_in_out;
+ XcmsCCC ccc;
+
+ /*
+ * 0. Check for invalid arguments.
+ */
+ if (dpy == NULL || colorname[0] == '\0' || pColor_scrn_return == 0
+ || pColor_exact_return == NULL) {
+ return(XcmsFailure);
+ }
+
+ if ((ccc = XcmsCCCOfColormap(dpy, cmap)) == (XcmsCCC)NULL) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * 1. Convert string to a XcmsColor using Xcms and i18n mechanism
+ */
+ if ((retval1 = _XcmsResolveColorString(ccc, &colorname,
+ &tmpColor, result_format)) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+ if (retval1 == _XCMS_NEWNAME) {
+ goto PassToServer;
+ }
+ memcpy((char *)pColor_exact_return, (char *)&tmpColor, sizeof(XcmsColor));
+
+ /*
+ * 2. Convert tmpColor to RGB
+ * Assume pColor_exact_return is now adjusted to Client White Point
+ */
+ if ((retval2 = XcmsConvertColors(ccc, &tmpColor,
+ 1, XcmsRGBFormat, (Bool *) NULL)) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * 3. Convert to XColor and call XAllocColor
+ */
+ _XcmsRGB_to_XColor(&tmpColor, &XColor_in_out, 1);
+ if (XAllocColor(ccc->dpy, cmap, &XColor_in_out) == 0) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * 4. pColor_scrn_return
+ *
+ * Now convert to the target format.
+ * We can ignore the return value because we're already in a
+ * device-dependent format.
+ */
+ _XColor_to_XcmsRGB(ccc, &XColor_in_out, pColor_scrn_return, 1);
+ if (result_format != XcmsRGBFormat) {
+ if (result_format == XcmsUndefinedFormat) {
+ result_format = pColor_exact_return->format;
+ }
+ if (XcmsConvertColors(ccc, pColor_scrn_return, 1, result_format,
+ (Bool *) NULL) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+ }
+
+ return(retval1 > retval2 ? retval1 : retval2);
+
+PassToServer:
+ /*
+ * All previous methods failed, so lets pass it to the server
+ * for parsing.
+ */
+ dpy = ccc->dpy;
+ LockDisplay(dpy);
+ GetReq(AllocNamedColor, req);
+
+ req->cmap = cmap;
+ nbytes = req->nbytes = strlen(colorname);
+ req->length += (nbytes + 3) >> 2; /* round up to mult of 4 */
+
+ _XSend(dpy, colorname, nbytes);
+ /* _XSend is more efficient that Data, since _XReply follows */
+
+ if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) {
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return (0);
+ }
+
+ exact_def.red = rep.exactRed;
+ exact_def.green = rep.exactGreen;
+ exact_def.blue = rep.exactBlue;
+
+ hard_def.red = rep.screenRed;
+ hard_def.green = rep.screenGreen;
+ hard_def.blue = rep.screenBlue;
+
+ exact_def.pixel = hard_def.pixel = rep.pixel;
+
+ UnlockDisplay(dpy);
+ SyncHandle();
+
+ /*
+ * Now convert to the target format.
+ */
+ _XColor_to_XcmsRGB(ccc, &exact_def, pColor_exact_return, 1);
+ _XColor_to_XcmsRGB(ccc, &hard_def, pColor_scrn_return, 1);
+ if (result_format != XcmsRGBFormat
+ && result_format != XcmsUndefinedFormat) {
+ if (XcmsConvertColors(ccc, pColor_exact_return, 1, result_format,
+ (Bool *) NULL) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+ if (XcmsConvertColors(ccc, pColor_scrn_return, 1, result_format,
+ (Bool *) NULL) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+ }
+
+ return(XcmsSuccess);
+}
diff --git a/nx-X11/lib/src/xcms/cmsCmap.c b/nx-X11/lib/src/xcms/cmsCmap.c
new file mode 100644
index 000000000..c7087ecb1
--- /dev/null
+++ b/nx-X11/lib/src/xcms/cmsCmap.c
@@ -0,0 +1,492 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ * NAME
+ * XcmsCmap.c - Client Colormap Management Routines
+ *
+ * DESCRIPTION
+ * Routines that store additional information about
+ * colormaps being used by the X Client.
+ *
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Xutil.h"
+#include "Cmap.h"
+#include "Cv.h"
+
+/*
+ * FORWARD DECLARATIONS
+ */
+static void _XcmsFreeClientCmaps(Display *dpy);
+
+
+/************************************************************************
+ * *
+ * PRIVATE INTERFACES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * CmapRecForColormap
+ *
+ * SYNOPSIS
+ */
+static XcmsCmapRec *
+CmapRecForColormap(
+ Display *dpy,
+ Colormap cmap)
+/*
+ * DESCRIPTION
+ * Find the corresponding XcmsCmapRec for cmap. In not found
+ * this routines attempts to create one.
+ *
+ * RETURNS
+ * Returns NULL if failed; otherwise the address to
+ * the corresponding XcmsCmapRec.
+ *
+ */
+{
+ XcmsCmapRec *pRec;
+ int nScrn;
+ int i, j;
+ XVisualInfo visualTemplate; /* Template of the visual we want */
+ XVisualInfo *visualList; /* List for visuals that match */
+ int nVisualsMatched; /* Number of visuals that match */
+ Window tmpWindow;
+ Visual *vp;
+ unsigned long border = 0;
+ _XAsyncHandler async;
+ _XAsyncErrorState async_state;
+
+ for (pRec = (XcmsCmapRec *)dpy->cms.clientCmaps; pRec != NULL;
+ pRec = pRec->pNext) {
+ if (pRec->cmapID == cmap) {
+ return(pRec);
+ }
+ }
+
+ /*
+ * Can't find an XcmsCmapRec associated with cmap in our records.
+ * Let's try to see if its a default colormap
+ */
+ nScrn = ScreenCount(dpy);
+ for (i = 0; i < nScrn; i++) {
+ if (cmap == DefaultColormap(dpy, i)) {
+ /* It is ... lets go ahead and store that info */
+ if ((pRec = _XcmsAddCmapRec(dpy, cmap, RootWindow(dpy, i),
+ DefaultVisual(dpy, i))) == NULL) {
+ return((XcmsCmapRec *)NULL);
+ }
+ pRec->ccc = XcmsCreateCCC(
+ dpy,
+ i, /* screenNumber */
+ DefaultVisual(dpy, i),
+ (XcmsColor *)NULL, /* clientWhitePt */
+ (XcmsCompressionProc)NULL, /* gamutCompProc */
+ (XPointer)NULL, /* gamutCompClientData */
+ (XcmsWhiteAdjustProc)NULL, /* whitePtAdjProc */
+ (XPointer)NULL /* whitePtAdjClientData */
+ );
+ return(pRec);
+ }
+ }
+
+ /*
+ * Nope, its not a default colormap, so it's probably a foreign color map
+ * of which we have no specific details. Let's go through the
+ * rigorous process of finding this colormap:
+ * for each screen
+ * for each screen's visual types
+ * create a window with cmap specified as the colormap
+ * if successful
+ * Add a CmapRec
+ * Create an XcmsCCC
+ * return the CmapRec
+ * else
+ * continue
+ */
+
+ async_state.error_code = 0; /* don't care */
+ async_state.major_opcode = X_CreateWindow;
+ async_state.minor_opcode = 0;
+ for (i = 0; i < nScrn; i++) {
+ visualTemplate.screen = i;
+ visualList = XGetVisualInfo(dpy, VisualScreenMask, &visualTemplate,
+ &nVisualsMatched);
+ if (visualList == NULL) {
+ continue;
+ }
+
+ /*
+ * Attempt to create a window with cmap
+ */
+ j = 0;
+ do {
+ vp = (visualList+j)->visual;
+ LockDisplay(dpy);
+ {
+ register xCreateWindowReq *req;
+
+ GetReq(CreateWindow, req);
+ async_state.min_sequence_number = dpy->request;
+ async_state.max_sequence_number = dpy->request;
+ async_state.error_count = 0;
+ async.next = dpy->async_handlers;
+ async.handler = _XAsyncErrorHandler;
+ async.data = (XPointer)&async_state;
+ dpy->async_handlers = &async;
+ req->parent = RootWindow(dpy, i);
+ req->x = 0;
+ req->y = 0;
+ req->width = 1;
+ req->height = 1;
+ req->borderWidth = 0;
+ req->depth = (visualList+j)->depth;
+ req->class = CopyFromParent;
+ req->visual = vp->visualid;
+ tmpWindow = req->wid = XAllocID(dpy);
+ req->mask = CWBorderPixel | CWColormap;
+ req->length += 2;
+ Data32 (dpy, (long *) &border, 4);
+ Data32 (dpy, (long *) &cmap, 4);
+ }
+ {
+ xGetInputFocusReply rep;
+ _X_UNUSED register xReq *req;
+
+ GetEmptyReq(GetInputFocus, req);
+ (void) _XReply (dpy, (xReply *)&rep, 0, xTrue);
+ }
+ DeqAsyncHandler(dpy, &async);
+ UnlockDisplay(dpy);
+ SyncHandle();
+ } while (async_state.error_count > 0 && ++j < nVisualsMatched);
+
+ Xfree(visualList);
+
+ /*
+ * if successful
+ */
+ if (j < nVisualsMatched) {
+ if ((pRec = _XcmsAddCmapRec(dpy, cmap, tmpWindow, vp)) == NULL)
+ return((XcmsCmapRec *)NULL);
+ pRec->ccc = XcmsCreateCCC(
+ dpy,
+ i, /* screenNumber */
+ vp,
+ (XcmsColor *)NULL, /* clientWhitePt */
+ (XcmsCompressionProc)NULL, /* gamutCompProc */
+ (XPointer)NULL, /* gamutCompClientData */
+ (XcmsWhiteAdjustProc)NULL, /* whitePtAdjProc */
+ (XPointer)NULL /* whitePtAdjClientData */
+ );
+ XDestroyWindow(dpy, tmpWindow);
+ return(pRec);
+ }
+ }
+
+ return(NULL);
+}
+
+
+
+/************************************************************************
+ * *
+ * API PRIVATE INTERFACES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * _XcmsAddCmapRec
+ *
+ * SYNOPSIS
+ */
+XcmsCmapRec *
+_XcmsAddCmapRec(
+ Display *dpy,
+ Colormap cmap,
+ Window windowID,
+ Visual *visual)
+/*
+ * DESCRIPTION
+ * Create an XcmsCmapRec for the specified cmap, windowID,
+ * and visual, then adds it to its list of CmapRec's.
+ *
+ * RETURNS
+ * Returns NULL if failed; otherwise the address to
+ * the added XcmsCmapRec.
+ *
+ */
+{
+ XcmsCmapRec *pNew;
+
+ if ((pNew = Xcalloc(1, sizeof(XcmsCmapRec))) == NULL) {
+ return((XcmsCmapRec *)NULL);
+ }
+
+ pNew->cmapID = cmap;
+ pNew->dpy = dpy;
+ pNew->windowID = windowID;
+ pNew->visual = visual;
+ pNew->pNext = (XcmsCmapRec *)dpy->cms.clientCmaps;
+ dpy->cms.clientCmaps = (XPointer)pNew;
+ dpy->free_funcs->clientCmaps = _XcmsFreeClientCmaps;
+
+ /*
+ * Note, we don't create the XcmsCCC for pNew->ccc here because
+ * it may require the use of XGetWindowAttributes (a round trip request)
+ * to determine the screen.
+ */
+ return(pNew);
+}
+
+
+/*
+ * NAME
+ * _XcmsCopyCmapRecAndFree
+ *
+ * SYNOPSIS
+ */
+XcmsCmapRec *
+_XcmsCopyCmapRecAndFree(
+ Display *dpy,
+ Colormap src_cmap,
+ Colormap copy_cmap)
+/*
+ * DESCRIPTION
+ * Augments Xlib's XCopyColormapAndFree() to copy
+ * XcmsCmapRecs.
+ *
+ * RETURNS
+ * Returns NULL if failed; otherwise the address to
+ * the copy XcmsCmapRec.
+ *
+ */
+{
+ XcmsCmapRec *pRec_src;
+ XcmsCmapRec *pRec_copy;
+
+ if ((pRec_src = CmapRecForColormap(dpy, src_cmap)) != NULL) {
+ pRec_copy =_XcmsAddCmapRec(dpy, copy_cmap, pRec_src->windowID,
+ pRec_src->visual);
+ if (pRec_copy != NULL && pRec_src->ccc) {
+ pRec_copy->ccc = Xcalloc(1, sizeof(XcmsCCCRec));
+ memcpy((char *)pRec_copy->ccc, (char *)pRec_src->ccc,
+ sizeof(XcmsCCCRec));
+ }
+ return(pRec_copy);
+ }
+ return((XcmsCmapRec *)NULL);
+}
+
+
+/*
+ * NAME
+ * _XcmsDeleteCmapRec
+ *
+ * SYNOPSIS
+ */
+void
+_XcmsDeleteCmapRec(
+ Display *dpy,
+ Colormap cmap)
+/*
+ * DESCRIPTION
+ * Removes and frees the specified XcmsCmapRec structure
+ * from the linked list of structures.
+ *
+ * RETURNS
+ * void
+ *
+ */
+{
+ XcmsCmapRec **pPrevPtr;
+ XcmsCmapRec *pRec;
+ int scr;
+
+ /* If it is the default cmap for a screen, do not delete it,
+ * because the server will not actually free it */
+ for (scr = ScreenCount(dpy); --scr >= 0; ) {
+ if (cmap == DefaultColormap(dpy, scr))
+ return;
+ }
+
+ /* search for it in the list */
+ pPrevPtr = (XcmsCmapRec **)&dpy->cms.clientCmaps;
+ while ((pRec = *pPrevPtr) && (pRec->cmapID != cmap)) {
+ pPrevPtr = &pRec->pNext;
+ }
+
+ if (pRec) {
+ if (pRec->ccc) {
+ XcmsFreeCCC(pRec->ccc);
+ }
+ *pPrevPtr = pRec->pNext;
+ Xfree(pRec);
+ }
+}
+
+
+/*
+ * NAME
+ * _XcmsFreeClientCmaps
+ *
+ * SYNOPSIS
+ */
+static void
+_XcmsFreeClientCmaps(
+ Display *dpy)
+/*
+ * DESCRIPTION
+ * Frees all XcmsCmapRec structures in the linked list
+ * and sets dpy->cms.clientCmaps to NULL.
+ *
+ * RETURNS
+ * void
+ *
+ */
+{
+ XcmsCmapRec *pRecNext, *pRecFree;
+
+ pRecNext = (XcmsCmapRec *)dpy->cms.clientCmaps;
+ while (pRecNext != NULL) {
+ pRecFree = pRecNext;
+ pRecNext = pRecNext->pNext;
+ if (pRecFree->ccc) {
+ /* Free the XcmsCCC structure */
+ XcmsFreeCCC(pRecFree->ccc);
+ }
+ /* Now free the XcmsCmapRec structure */
+ Xfree(pRecFree);
+ }
+ dpy->cms.clientCmaps = (XPointer)NULL;
+}
+
+
+
+/************************************************************************
+ * *
+ * PUBLIC INTERFACES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsCCCOfColormap
+ *
+ * SYNOPSIS
+ */
+XcmsCCC
+XcmsCCCOfColormap(
+ Display *dpy,
+ Colormap cmap)
+/*
+ * DESCRIPTION
+ * Finds the XcmsCCC associated with the specified colormap.
+ *
+ * RETURNS
+ * Returns NULL if failed; otherwise the address to
+ * the associated XcmsCCC structure.
+ *
+ */
+{
+ XWindowAttributes windowAttr;
+ XcmsCmapRec *pRec;
+ int nScrn = ScreenCount(dpy);
+ int i;
+
+ if ((pRec = CmapRecForColormap(dpy, cmap)) != NULL) {
+ if (pRec->ccc) {
+ /* XcmsCmapRec already has a XcmsCCC */
+ return(pRec->ccc);
+ }
+
+ /*
+ * The XcmsCmapRec does not have a XcmsCCC yet, so let's create
+ * one. But first, we need to know the screen associated with
+ * cmap, so use XGetWindowAttributes() to extract that
+ * information. Unless, of course there is only one screen!!
+ */
+ if (nScrn == 1) {
+ /* Assume screenNumber == 0 */
+ return(pRec->ccc = XcmsCreateCCC(
+ dpy,
+ 0, /* screenNumber */
+ pRec->visual,
+ (XcmsColor *)NULL, /* clientWhitePt */
+ (XcmsCompressionProc)NULL, /* gamutCompProc */
+ (XPointer)NULL, /* gamutCompClientData */
+ (XcmsWhiteAdjustProc)NULL, /* whitePtAdjProc */
+ (XPointer)NULL /* whitePtAdjClientData */
+ ));
+ } else {
+ if (XGetWindowAttributes(dpy, pRec->windowID, &windowAttr)) {
+ for (i = 0; i < nScrn; i++) {
+ if (ScreenOfDisplay(dpy, i) == windowAttr.screen) {
+ return(pRec->ccc = XcmsCreateCCC(
+ dpy,
+ i, /* screenNumber */
+ pRec->visual,
+ (XcmsColor *)NULL, /* clientWhitePt */
+ (XcmsCompressionProc)NULL, /* gamutCompProc */
+ (XPointer)NULL, /* gamutCompClientData */
+ (XcmsWhiteAdjustProc)NULL, /* whitePtAdjProc */
+ (XPointer)NULL /* whitePtAdjClientData */
+ ));
+ }
+ }
+ }
+ }
+ }
+
+ /*
+ * No such cmap
+ */
+ return(NULL);
+}
+
+XcmsCCC XcmsSetCCCOfColormap(
+ Display *dpy,
+ Colormap cmap,
+ XcmsCCC ccc)
+{
+ XcmsCCC prev_ccc = NULL;
+ XcmsCmapRec *pRec;
+
+ pRec = CmapRecForColormap(dpy, cmap);
+ if (pRec) {
+ prev_ccc = pRec->ccc;
+ pRec->ccc = ccc;
+ }
+ return prev_ccc;
+}
diff --git a/nx-X11/lib/src/xcms/cmsColNm.c b/nx-X11/lib/src/xcms/cmsColNm.c
new file mode 100644
index 000000000..c6f1e0f31
--- /dev/null
+++ b/nx-X11/lib/src/xcms/cmsColNm.c
@@ -0,0 +1,1050 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ * NAME
+ * XcmsColNm.c
+ *
+ * DESCRIPTION
+ * Source for _XcmsLookupColorName().
+ *
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include <nx-X11/Xos.h>
+#include <sys/stat.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <limits.h>
+#define XK_LATIN1
+#include <nx-X11/keysymdef.h>
+#include "Cv.h"
+
+/* forwards/locals */
+static Status LoadColornameDB(void);
+
+
+/*
+ * LOCAL DEFINES
+ * #define declarations local to this package.
+ */
+#ifndef XCMSDB
+#define XCMSDB XCMSDIR "/Xcms.txt"
+#endif
+
+#ifndef isgraph
+# define isgraph(c) (isprint((c)) && !isspace((c)))
+#endif
+
+#ifndef XCMSDB_MAXLINELEN
+# define XCMSDB_MAXLINELEN 256
+#endif
+
+#define FORMAT_VERSION "0.1"
+#define START_TOKEN "XCMS_COLORDB_START"
+#define END_TOKEN "XCMS_COLORDB_END"
+#define DELIM_CHAR '\t'
+
+#define NOT_VISITED 0x0
+#define VISITED 0x1
+#define CYCLE 0xFFFF
+#define XcmsDbInitNone -1
+#define XcmsDbInitFailure 0
+#define XcmsDbInitSuccess 1
+
+/*
+ * LOCAL TYPEDEFS
+ */
+typedef struct _XcmsPair {
+ const char *first;
+ const char *second;
+ int flag;
+} XcmsPair;
+
+/*
+ * LOCAL VARIABLES
+ */
+static int XcmsColorDbState = XcmsDbInitNone;
+static int nEntries;
+static char *strings;
+static XcmsPair *pairs;
+static const char whitePtStr[] = "WhitePoint";
+
+
+/************************************************************************
+ * *
+ * PRIVATE ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * _XcmsColorSpaceOfString
+ *
+ * SYNOPSIS
+ */
+static XcmsColorSpace *
+_XcmsColorSpaceOfString(
+ XcmsCCC ccc,
+ const char *color_string)
+/*
+ * DESCRIPTION
+ * Returns a pointer to the color space structure
+ * (XcmsColorSpace) associated with the specified color string.
+ *
+ * RETURNS
+ * Pointer to matching XcmsColorSpace structure if found;
+ * otherwise NULL.
+ *
+ * CAVEATS
+ *
+ */
+{
+ XcmsColorSpace **papColorSpaces;
+ size_t n;
+ char *pchar;
+
+ if ((pchar = strchr(color_string, ':')) == NULL) {
+ return(XcmsFailure);
+ }
+ n = (size_t)(pchar - color_string);
+
+ if (ccc == NULL) {
+ return(NULL);
+ }
+
+ /*
+ * First try Device-Independent color spaces
+ */
+ papColorSpaces = _XcmsDIColorSpaces;
+ if (papColorSpaces != NULL) {
+ while (*papColorSpaces != NULL) {
+ if (strncmp((*papColorSpaces)->prefix, color_string, n) == 0 &&
+ !((*papColorSpaces)->prefix)[n]) {
+ return(*papColorSpaces);
+ }
+ papColorSpaces++;
+ }
+ }
+
+ /*
+ * Next try Device-Dependent color spaces
+ */
+ papColorSpaces = ((XcmsFunctionSet *)ccc->pPerScrnInfo->functionSet)->DDColorSpaces;
+ if (papColorSpaces != NULL) {
+ while (*papColorSpaces != NULL) {
+ if (strncmp((*papColorSpaces)->prefix, color_string, n) == 0 &&
+ !((*papColorSpaces)->prefix)[n]) {
+ return(*papColorSpaces);
+ }
+ papColorSpaces++;
+ }
+ }
+
+ return(NULL);
+}
+
+
+/*
+ * NAME
+ * _XcmsParseColorString
+ *
+ * SYNOPSIS
+ */
+static int
+_XcmsParseColorString(
+ XcmsCCC ccc,
+ const char *color_string,
+ XcmsColor *pColor)
+/*
+ * DESCRIPTION
+ * Assuming color_string contains a numerical string color
+ * specification, attempts to parse a string into an
+ * XcmsColor structure.
+ *
+ * RETURNS
+ * 0 if failed; otherwise non-zero.
+ *
+ * CAVEATS
+ * A color string containing a numerical color specification
+ * must be in ISO Latin-1 encoding!
+ */
+{
+ XcmsColorSpace *pColorSpace;
+ char string_buf[64];
+ char *string_lowered;
+ size_t len;
+ int res;
+
+ if (ccc == NULL) {
+ return(0);
+ }
+
+ /*
+ * While copying color_string to string_lowered, convert to lowercase
+ */
+ if ((len = strlen(color_string)) >= sizeof(string_buf)) {
+ string_lowered = Xmalloc(len+1);
+ } else {
+ string_lowered = string_buf;
+ }
+
+ _XcmsCopyISOLatin1Lowered(string_lowered, color_string);
+
+ if (*string_lowered == '#') {
+ if ((pColorSpace = _XcmsColorSpaceOfString(ccc, "rgb:")) != NULL) {
+ res = (*pColorSpace->parseString)(string_lowered, pColor);
+ if (len >= sizeof(string_buf)) Xfree(string_lowered);
+ return res;
+ }
+ }
+
+ if ((pColorSpace = _XcmsColorSpaceOfString(ccc, string_lowered)) != NULL) {
+ res = (*pColorSpace->parseString)(string_lowered, pColor);
+ if (len >= sizeof(string_buf)) Xfree(string_lowered);
+ return res;
+ }
+
+ if (len >= sizeof(string_buf)) Xfree(string_lowered);
+ return(0);
+}
+
+
+/*
+ * NAME
+ * FirstCmp - Compare color names of pair recs
+ *
+ * SYNOPSIS
+ */
+static int
+FirstCmp(const void *p1, const void *p2)
+/*
+ * DESCRIPTION
+ * Compares the color names of XcmsColorTuples.
+ * This routine is public to allow access from qsort???.
+ *
+ * RETURNS
+ * 0 if equal;
+ * < 0 if first precedes second,
+ * > 0 if first succeeds second.
+ *
+ */
+{
+ return(strcmp(((const XcmsPair *)p1)->first, ((const XcmsPair *)p2)->first));
+}
+
+
+
+/*
+ * NAME
+ * stringSectionSize - determine memory needed for strings
+ *
+ * SYNOPSIS
+ */
+static void
+SetNoVisit(void)
+/*
+ * DESCRIPTION
+ *
+ * RETURNS
+ * void
+ *
+ */
+{
+ int i;
+ XcmsPair *pair = pairs;
+
+ for (i = 0; i < nEntries; i++, pair++) {
+ if (pair->flag != CYCLE) {
+ pair->flag = NOT_VISITED;
+ }
+ }
+}
+
+
+
+
+/*
+ * NAME
+ * field2 - extract two fields
+ *
+ * SYNOPSIS
+ */
+static int
+field2(
+ char *pBuf,
+ char delim, /* in: field delimiter */
+ char **p1, /* in/out: pointer to pointer to field 1 */
+ char **p2) /* in/out: pointer to pointer to field 2 */
+/*
+ * DESCRIPTION
+ * Extracts two fields from a "record".
+ *
+ * RETURNS
+ * XcmsSuccess if succeeded, otherwise XcmsFailure.
+ *
+ */
+{
+ *p1 = *p2 = NULL;
+
+ /* Find Field 1 */
+ while (!isgraph(*pBuf)) {
+ if ((*pBuf != '\n') || (*pBuf != '\0')) {
+ return(XcmsFailure);
+ }
+ if (isspace(*pBuf) || (*pBuf == delim)) {
+ pBuf++;
+ }
+ }
+ *p1 = pBuf;
+
+ /* Find end of Field 2 */
+ while (isprint(*pBuf) && (*pBuf != delim)) {
+ pBuf++;
+ }
+ if ((*pBuf == '\n') || (*pBuf == '\0')) {
+ return(XcmsFailure);
+ }
+ if ((*pBuf == ' ') || (*pBuf == delim)) {
+ *pBuf++ = '\0'; /* stuff end of string character */
+ } else {
+ return(XcmsFailure);
+ }
+
+ /* Find Field 2 */
+ while (!isgraph(*pBuf)) {
+ if ((*pBuf == '\n') || (*pBuf == '\0')) {
+ return(XcmsFailure);
+ }
+ if (isspace(*pBuf) || (*pBuf == delim)) {
+ pBuf++;
+ }
+ }
+ *p2 = pBuf;
+
+ /* Find end of Field 2 */
+ while (isprint(*pBuf) && (*pBuf != delim)) {
+ pBuf++;
+ }
+ if (*pBuf != '\0') {
+ *pBuf = '\0'; /* stuff end of string character */
+ }
+
+ return(XcmsSuccess);
+}
+
+
+/*
+ * NAME
+ * _XcmsLookupColorName - Lookup DB entry for a color name
+ *
+ * SYNOPSIS
+ */
+static Status
+_XcmsLookupColorName(
+ XcmsCCC ccc,
+ const char **name,
+ XcmsColor *pColor)
+/*
+ * DESCRIPTION
+ * Searches for an entry in the Device-Independent Color Name
+ * Database for the specified string.
+ *
+ * RETURNS
+ * XcmsFailure if failed to find a matching entry in
+ * the database.
+ * XcmsSuccess if succeeded in converting color name to
+ * XcmsColor.
+ * _XCMS_NEWNAME if succeeded in converting color string (which
+ * is a color name to yet another color name. Note
+ * that the new name is passed back via 'name'.
+ */
+ {
+ Status retval = 0;
+ char name_lowered_64[64];
+ char *name_lowered;
+ register int i, j, left, right;
+ int len;
+ const char *tmpName;
+ XcmsPair *pair = NULL;
+
+ /*
+ * Check state of Database:
+ * XcmsDbInitNone
+ * XcmsDbInitSuccess
+ * XcmsDbInitFailure
+ */
+ if (XcmsColorDbState == XcmsDbInitFailure) {
+ return(XcmsFailure);
+ }
+ if (XcmsColorDbState == XcmsDbInitNone) {
+ if (!LoadColornameDB()) {
+ return(XcmsFailure);
+ }
+ }
+
+ SetNoVisit();
+
+ /*
+ * While copying name to name_lowered, convert to lowercase
+ */
+
+ tmpName = *name;
+
+Retry:
+ if ((len = strlen(tmpName)) > 63) {
+ name_lowered = Xmalloc(len+1);
+ } else {
+ name_lowered = name_lowered_64;
+ }
+
+ _XcmsCopyISOLatin1Lowered(name_lowered, tmpName);
+
+ /*
+ * Now, remove spaces.
+ */
+ for (i = 0, j = 0; j < len; j++) {
+ if (!isspace(name_lowered[j])) {
+ name_lowered[i++] = name_lowered[j];
+ }
+ }
+ name_lowered[i] = '\0';
+
+ left = 0;
+ right = nEntries - 1;
+ while (left <= right) {
+ i = (left + right) >> 1;
+ pair = &pairs[i];
+ j = strcmp(name_lowered, pair->first);
+ if (j < 0)
+ right = i - 1;
+ else if (j > 0)
+ left = i + 1;
+ else {
+ break;
+ }
+ }
+ if (len > 63) Xfree(name_lowered);
+
+ if (left > right) {
+ if (retval == 2) {
+ if (*name != tmpName) {
+ *name = tmpName;
+ }
+ return(_XCMS_NEWNAME);
+ }
+ return(XcmsFailure);
+ }
+
+ if (pair->flag == CYCLE) {
+ return(XcmsFailure);
+ }
+ if (pair->flag == VISITED) {
+ pair->flag = CYCLE;
+ return(XcmsFailure);
+ }
+
+ if (_XcmsParseColorString(ccc, pair->second, pColor) == XcmsSuccess) {
+ /* f2 contains a numerical string specification */
+ return(XcmsSuccess);
+ } else {
+ /* f2 does not contain a numerical string specification */
+ tmpName = pair->second;
+ pair->flag = VISITED;
+ retval = 2;
+ goto Retry;
+ }
+}
+
+
+/*
+ * NAME
+ * RemoveSpaces
+ *
+ * SYNOPSIS
+ */
+static int
+RemoveSpaces(
+ char *pString)
+/*
+ * DESCRIPTION
+ * Removes spaces from string.
+ *
+ * RETURNS
+ * Void
+ *
+ */
+{
+ int i, count = 0;
+ char *cptr;
+
+ /* REMOVE SPACES */
+ cptr = pString;
+ for (i = strlen(pString); i; i--, cptr++) {
+ if (!isspace(*cptr)) {
+ *pString++ = *cptr;
+ count++;
+ }
+ }
+ *pString = '\0';
+ return(count);
+}
+
+
+/*
+ * NAME
+ * stringSectionSize - determine memory needed for strings
+ *
+ * SYNOPSIS
+ */
+static int
+stringSectionSize(
+ FILE *stream,
+ int *pNumEntries,
+ int *pSectionSize)
+/*
+ * DESCRIPTION
+ * Determines the amount of memory required to store the
+ * color name strings and also the number of strings.
+ *
+ * RETURNS
+ * XcmsSuccess if succeeded, otherwise XcmsFailure.
+ *
+ */
+{
+ char buf[XCMSDB_MAXLINELEN];
+ char token[XCMSDB_MAXLINELEN];
+ char token2[XCMSDB_MAXLINELEN];
+ char *pBuf;
+ char *f1;
+ char *f2;
+ size_t i;
+
+ unsigned int numEntries = 0;
+ unsigned int sectionSize = 0;
+
+ *pNumEntries = 0;
+ *pSectionSize = 0;
+
+ /*
+ * Advance to START_TOKEN
+ * Anything before is just considered as comments.
+ */
+
+ while((pBuf = fgets(buf, XCMSDB_MAXLINELEN, stream)) != NULL) {
+ if ((sscanf(buf, "%s %s", token, token2))
+ && (strcmp(token, START_TOKEN) == 0)) {
+ if (strcmp(token2, FORMAT_VERSION) != 0) {
+ /* text file not in the right format */
+ return(XcmsFailure);
+ }
+ break;
+ } /* else it was just a blank line or comment */
+ }
+
+ if (pBuf == NULL) {
+ return(XcmsFailure);
+ }
+
+ while((fgets(buf, XCMSDB_MAXLINELEN, stream)) != NULL) {
+ if ((sscanf(buf, "%s", token)) && (strcmp(token, END_TOKEN) == 0)) {
+ break;
+ }
+
+ if (field2(buf, DELIM_CHAR, &f1, &f2) != XcmsSuccess) {
+ return(XcmsFailure);
+ }
+
+ numEntries++;
+ if (numEntries >= INT_MAX)
+ return(XcmsFailure);
+
+ i = strlen(f1);
+ if (i >= INT_MAX - sectionSize)
+ return(XcmsFailure);
+ sectionSize += i + 1;
+ for (; i; i--, f1++) {
+ /* REMOVE SPACES FROM COUNT */
+ if (isspace(*f1)) {
+ sectionSize--;
+ }
+ }
+
+ i = strlen(f2);
+ if (i >= INT_MAX - sectionSize)
+ return(XcmsFailure);
+ sectionSize += i + 1;
+ for (; i; i--, f2++) {
+ /* REMOVE SPACES FROM COUNT */
+ if (isspace(*f2)) {
+ sectionSize--;
+ }
+ }
+
+ }
+
+ *pNumEntries = (int) numEntries;
+ *pSectionSize = (int) sectionSize;
+
+ return(XcmsSuccess);
+}
+
+
+/*
+ * NAME
+ * ReadColornameDB - Read the Color Name Database
+ *
+ * SYNOPSIS
+ */
+static Status
+ReadColornameDB(
+ FILE *stream,
+ XcmsPair *pRec,
+ char *pString)
+/*
+ * DESCRIPTION
+ * Loads the Color Name Database from a text file.
+ *
+ * RETURNS
+ * XcmsSuccess if succeeded, otherwise XcmsFailure.
+ *
+ */
+{
+ char buf[XCMSDB_MAXLINELEN];
+ char token[XCMSDB_MAXLINELEN];
+ char token2[XCMSDB_MAXLINELEN];
+ char *f1;
+ char *f2;
+ char *pBuf;
+
+ /*
+ * Advance to START_TOKEN
+ * Anything before is just considered as comments.
+ */
+
+ while((pBuf = fgets(buf, XCMSDB_MAXLINELEN, stream)) != NULL) {
+ if ((sscanf(buf, "%s %s", token, token2))
+ && (strcmp(token, START_TOKEN) == 0)) {
+ if (strcmp(token2, FORMAT_VERSION) != 0) {
+ /* text file not in the right format */
+ return(XcmsFailure);
+ }
+ break;
+ } /* else it was just a blank line or comment */
+ }
+
+ if (pBuf == NULL) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Process lines between START_TOKEN to END_TOKEN
+ */
+
+ while ((fgets(buf, XCMSDB_MAXLINELEN, stream)) != NULL) {
+ if ((sscanf(buf, "%s", token)) && (strcmp(token, END_TOKEN) == 0)) {
+ /*
+ * Found END_TOKEN so break out of for loop
+ */
+ break;
+ }
+
+ /*
+ * Get pairs
+ */
+ if (field2(buf, DELIM_CHAR, &f1, &f2) != XcmsSuccess) {
+ /* Invalid line */
+ continue;
+ }
+
+ /*
+ * Add strings
+ */
+
+ /* Left String */
+ pRec->first = pString;
+ _XcmsCopyISOLatin1Lowered(pString, f1);
+ pString += (1 + RemoveSpaces(pString));
+ pRec->second = pString;
+ /* Right String */
+ _XcmsCopyISOLatin1Lowered(pString, f2);
+ pString += RemoveSpaces(pString) + 1;
+ pRec++;
+
+ }
+
+ return(XcmsSuccess);
+}
+
+
+/*
+ * NAME
+ * LoadColornameDB - Load the Color Name Database
+ *
+ * SYNOPSIS
+ */
+static Status
+LoadColornameDB(void)
+/*
+ * DESCRIPTION
+ * Loads the Color Name Database from a text file.
+ *
+ * RETURNS
+ * XcmsSuccess if succeeded, otherwise XcmsFailure.
+ *
+ */
+{
+ int size;
+ FILE *stream;
+ const char *pathname;
+ struct stat txt;
+ int length;
+
+ /* use and name of this env var is not part of the standard */
+ /* implementation-dependent feature */
+ if ((pathname = getenv("XCMSDB")) == NULL) {
+ pathname = XCMSDB;
+ }
+
+ length = strlen(pathname);
+ if ((length == 0) || (length >= (BUFSIZ - 5))){
+ XcmsColorDbState = XcmsDbInitFailure;
+ return(XcmsFailure);
+ }
+
+ if (stat(pathname, &txt)) {
+ /* can't stat file */
+ XcmsColorDbState = XcmsDbInitFailure;
+ return(XcmsFailure);
+ }
+
+ if ((stream = _XFopenFile (pathname, "r")) == NULL) {
+ /* can't open file */
+ XcmsColorDbState = XcmsDbInitFailure;
+ return(XcmsFailure);
+ }
+
+ if (stringSectionSize(stream, &nEntries, &size) != XcmsSuccess ||
+ nEntries == 0) {
+ (void) fclose(stream);
+ XcmsColorDbState = XcmsDbInitFailure;
+ return(XcmsFailure);
+ }
+ rewind(stream);
+
+ strings = Xmalloc(size);
+ pairs = Xcalloc(nEntries, sizeof(XcmsPair));
+
+ ReadColornameDB(stream, pairs, strings);
+ (void) fclose(stream);
+
+ /*
+ * sort the pair recs
+ */
+ qsort((char *)pairs, nEntries, sizeof(XcmsPair), FirstCmp);
+
+ XcmsColorDbState = XcmsDbInitSuccess;
+ return(XcmsSuccess);
+}
+
+
+/************************************************************************
+ * *
+ * API PRIVATE ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * _XcmsCopyISOLatin1Lowered
+ *
+ * SYNOPSIS
+ */
+void
+_XcmsCopyISOLatin1Lowered(
+ char *dst,
+ const char *src)
+/*
+ * DESCRIPTION
+ * ISO Latin-1 case conversion routine
+ * Identical to XmuCopyISOLatin1Lowered() but provided here
+ * to eliminate need to link with libXmu.a.
+ *
+ * IMPLEMENTORS NOTE:
+ * This routine is also used in XcmsFormatOfPrefix.
+ *
+ * RETURNS
+ * Void
+ *
+ */
+{
+ register unsigned char *dest;
+ register const unsigned char *source;
+
+ for (dest = (unsigned char *)dst, source = (const unsigned char *)src;
+ *source;
+ source++, dest++)
+ {
+ if ((*source >= XK_A) && (*source <= XK_Z))
+ *dest = *source + (XK_a - XK_A);
+ else if ((*source >= XK_Agrave) && (*source <= XK_Odiaeresis))
+ *dest = *source + (XK_agrave - XK_Agrave);
+ else if ((*source >= XK_Ooblique) && (*source <= XK_Thorn))
+ *dest = *source + (XK_oslash - XK_Ooblique);
+ else
+ *dest = *source;
+ }
+ *dest = '\0';
+}
+
+
+/*
+ * NAME
+ * _XcmsResolveColorString -
+ *
+ * SYNOPSIS
+ */
+Status
+_XcmsResolveColorString (
+ XcmsCCC ccc,
+ const char **color_string,
+ XcmsColor *pColor_exact_return,
+ XcmsColorFormat result_format)
+/*
+ * DESCRIPTION
+ * The XcmsLookupColor function finds the color specification
+ * associated with a color name in the Device-Independent Color
+ * Name Database.
+ * RETURNS
+ * XcmsFailure if failed to convert valid color string.
+ * XcmsSuccess if succeeded in converting color string to
+ * XcmsColor.
+ * _XCMS_NEWNAME if failed to parse the string or find it in
+ * the database, or if succeeded in looking it up and
+ * found another name which is not in the database.
+ * Note that the new name is returned in color_string.
+ *
+ * This function returns both the color specification found in the
+ * database (db specification) and the color specification for the
+ * color displayable by the specified screen (screen
+ * specification). The calling routine sets the format for these
+ * returned specifications in the XcmsColor format component.
+ * If XcmsUndefinedFormat, the specification is returned in the
+ * format used to store the color in the database.
+ */
+{
+ XcmsColor dbWhitePt; /* whitePt associated with pColor_exact_return*/
+ /* the screen's white point */
+ XcmsColor *pClientWhitePt;
+ int retval;
+ const char *strptr = whitePtStr;
+
+/*
+ * 0. Check for invalid arguments.
+ */
+ if (ccc == NULL || (*color_string)[0] == '\0' || pColor_exact_return == NULL) {
+ return(XcmsFailure);
+ }
+
+/*
+ * 1. First attempt to parse the string
+ * If successful, then convert the specification to the target format
+ * and return.
+ */
+ if (_XcmsParseColorString(ccc, *color_string, pColor_exact_return)
+ == 1) {
+ if (result_format != XcmsUndefinedFormat
+ && pColor_exact_return->format != result_format) {
+ /* need to be converted to the target format */
+ return(XcmsConvertColors(ccc, pColor_exact_return, 1,
+ result_format, (Bool *)NULL));
+ } else {
+ return(XcmsSuccess);
+ }
+ }
+
+/*
+ * 2. Attempt to find it in the DI Color Name Database
+ */
+
+ /*
+ * a. Convert String into a XcmsColor structure
+ * Attempt to extract the specification for color_string from the
+ * DI Database (pColor_exact_return). If the DI Database does not
+ * have this entry, then return failure.
+ */
+ retval = _XcmsLookupColorName(ccc, color_string, pColor_exact_return);
+
+ if (retval != XcmsSuccess) {
+ /* color_string replaced with a color name, or not found */
+ return(_XCMS_NEWNAME);
+ }
+
+ if (pColor_exact_return->format == XcmsUndefinedFormat) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * b. If result_format not defined, then assume target format
+ * is the exact format.
+ */
+ if (result_format == XcmsUndefinedFormat) {
+ result_format = pColor_exact_return->format;
+ }
+
+ if ((ClientWhitePointOfCCC(ccc))->format == XcmsUndefinedFormat) {
+ pClientWhitePt = ScreenWhitePointOfCCC(ccc);
+ } else {
+ pClientWhitePt = ClientWhitePointOfCCC(ccc);
+ }
+
+ /*
+ * c. Convert to the target format, making adjustments for white
+ * point differences as necessary.
+ */
+ if (XCMS_DD_ID(pColor_exact_return->format)) {
+ /*
+ * The spec format is Device-Dependent, therefore assume the
+ * its white point is the Screen White Point.
+ */
+ if (XCMS_DD_ID(result_format)) {
+ /*
+ * Target format is Device-Dependent
+ * Therefore, DD --> DD conversion
+ */
+ return(_XcmsDDConvertColors(ccc, pColor_exact_return,
+ 1, result_format, (Bool *) NULL));
+ } else {
+ /*
+ * Target format is Device-Independent
+ * Therefore, DD --> DI conversion
+ */
+ if (ccc->whitePtAdjProc && !_XcmsEqualWhitePts(ccc,
+ pClientWhitePt, ScreenWhitePointOfCCC(ccc))) {
+ return((*ccc->whitePtAdjProc)(ccc, ScreenWhitePointOfCCC(ccc),
+ pClientWhitePt, result_format,
+ pColor_exact_return, 1, (Bool *) NULL));
+ } else {
+ if (_XcmsDDConvertColors(ccc, pColor_exact_return, 1,
+ XcmsCIEXYZFormat, (Bool *) NULL) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+ return(_XcmsDIConvertColors(ccc, pColor_exact_return,
+ pClientWhitePt, 1, result_format));
+ }
+ }
+ } else {
+ /*
+ * The spec format is Device-Independent, therefore attempt
+ * to find a database white point.
+ *
+ * If the Database does not have a white point, then assume the
+ * database white point is the same as the Screen White Point.
+ */
+
+ if (_XcmsLookupColorName(ccc, &strptr, &dbWhitePt) != 1) {
+ memcpy((char *)&dbWhitePt,
+ (char *)&ccc->pPerScrnInfo->screenWhitePt,
+ sizeof(XcmsColor));
+ }
+ if (XCMS_DD_ID(result_format)) {
+ /*
+ * Target format is Device-Dependent
+ * Therefore, DI --> DD conversion
+ */
+ if (ccc->whitePtAdjProc && !_XcmsEqualWhitePts(ccc,
+ &dbWhitePt, ScreenWhitePointOfCCC(ccc))) {
+ return((*ccc->whitePtAdjProc)(ccc, &dbWhitePt,
+ ScreenWhitePointOfCCC(ccc), result_format,
+ pColor_exact_return, 1, (Bool *)NULL));
+ } else {
+ if (pColor_exact_return->format != XcmsCIEXYZFormat) {
+ if (_XcmsDIConvertColors(ccc, pColor_exact_return,
+ &dbWhitePt, 1, XcmsCIEXYZFormat) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+ }
+ return (_XcmsDDConvertColors(ccc, pColor_exact_return, 1,
+ result_format, (Bool *)NULL));
+ }
+ } else {
+ /*
+ * Target format is Device-Independent
+ * Therefore, DI --> DI conversion
+ */
+ if (ccc->whitePtAdjProc && !_XcmsEqualWhitePts(ccc,
+ &dbWhitePt, pClientWhitePt)) {
+ /*
+ * The calling routine wants to resolve this color
+ * in terms if it's white point (i.e. Client White Point).
+ * Therefore, apply white adjustment for the displacement
+ * between dbWhitePt to clientWhitePt.
+ */
+ return((*ccc->whitePtAdjProc)(ccc, &dbWhitePt,
+ pClientWhitePt, result_format,
+ pColor_exact_return, 1, (Bool *)NULL));
+ } else if (_XcmsEqualWhitePts(ccc,
+ &dbWhitePt, pClientWhitePt)) {
+ /*
+ * Can use either dbWhitePt or pClientWhitePt to
+ * convert to the result_format.
+ */
+ if (pColor_exact_return->format == result_format) {
+ return(XcmsSuccess);
+ } else {
+ return (_XcmsDIConvertColors(ccc, pColor_exact_return,
+ &dbWhitePt, 1, result_format));
+ }
+ } else {
+ /*
+ * Need to convert to a white point independent color
+ * space (let's choose CIEXYZ) then convert to the
+ * target color space. Why? Lets assume that
+ * pColor_exact_return->format and result format
+ * are white point dependent format (e.g., CIELUV, CIELAB,
+ * TekHVC ... same or any combination). If so, we'll
+ * need to convert the color with dbWhitePt to an absolute
+ * spec (i.e. non-white point dependent) then convert that
+ * absolute value with clientWhitePt to the result_format.
+ */
+ if (pColor_exact_return->format != XcmsCIEXYZFormat) {
+ if (_XcmsDIConvertColors(ccc, pColor_exact_return,
+ &dbWhitePt, 1, XcmsCIEXYZFormat) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+ }
+ if (result_format == XcmsCIEXYZFormat) {
+ return(XcmsSuccess);
+ } else {
+ return(_XcmsDIConvertColors(ccc, pColor_exact_return,
+ pClientWhitePt, 1, result_format));
+ }
+ }
+ }
+ }
+}
diff --git a/nx-X11/lib/src/xcms/cmsGlobls.c b/nx-X11/lib/src/xcms/cmsGlobls.c
new file mode 100644
index 000000000..c9e82f242
--- /dev/null
+++ b/nx-X11/lib/src/xcms/cmsGlobls.c
@@ -0,0 +1,126 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ * NAME
+ * XcmsGlobls.c
+ *
+ * DESCRIPTION
+ * Source file containing Xcms globals
+ *
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+/*
+ * GLOBALS
+ * Variables declared in this package that are allowed
+ * to be used globally.
+ */
+
+ /*
+ * Initial array of Device Independent Color Spaces
+ */
+XcmsColorSpace *_XcmsDIColorSpacesInit[] = {
+ &XcmsCIEXYZColorSpace,
+ &XcmsCIEuvYColorSpace,
+ &XcmsCIExyYColorSpace,
+ &XcmsCIELabColorSpace,
+ &XcmsCIELuvColorSpace,
+ &XcmsTekHVCColorSpace,
+ &XcmsUNDEFINEDColorSpace,
+ NULL
+};
+ /*
+ * Pointer to the array of pointers to XcmsColorSpace structures for
+ * Device-Independent Color Spaces that are currently accessible by
+ * the color management system. End of list is indicated by a NULL pointer.
+ */
+XcmsColorSpace **_XcmsDIColorSpaces = _XcmsDIColorSpacesInit;
+
+ /*
+ * Initial array of Device Dependent Color Spaces
+ */
+XcmsColorSpace *_XcmsDDColorSpacesInit[] = {
+ &XcmsRGBColorSpace,
+ &XcmsRGBiColorSpace,
+ NULL
+};
+ /*
+ * Pointer to the array of pointers to XcmsColorSpace structures for
+ * Device-Dependent Color Spaces that are currently accessible by
+ * the color management system. End of list is indicated by a NULL pointer.
+ */
+XcmsColorSpace **_XcmsDDColorSpaces = &_XcmsDDColorSpacesInit[0];
+
+ /*
+ * Initial array of Screen Color Characterization Function Sets
+ */
+XcmsFunctionSet *_XcmsSCCFuncSetsInit[] = {
+ &XcmsLinearRGBFunctionSet,
+#ifdef GRAY
+ &XcmsGrayFunctionSet,
+#endif /* GRAY */
+ NULL};
+ /*
+ * Pointer to the array of pointers to XcmsSCCFuncSet structures
+ * (Screen Color Characterization Function Sets) that are currently
+ * accessible by the color management system. End of list is
+ * indicated by a NULL pointer.
+ */
+XcmsFunctionSet **_XcmsSCCFuncSets = _XcmsSCCFuncSetsInit;
+
+ /*
+ * X Consortium Registered Device-Independent Color Spaces
+ * Note that prefix must be in lowercase.
+ */
+const char _XcmsCIEXYZ_prefix[] = "ciexyz";
+const char _XcmsCIEuvY_prefix[] = "cieuvy";
+const char _XcmsCIExyY_prefix[] = "ciexyy";
+const char _XcmsCIELab_prefix[] = "cielab";
+const char _XcmsCIELuv_prefix[] = "cieluv";
+const char _XcmsTekHVC_prefix[] = "tekhvc";
+ /*
+ * Registered Device-Dependent Color Spaces
+ */
+const char _XcmsRGBi_prefix[] = "rgbi";
+const char _XcmsRGB_prefix[] = "rgb";
+
+XcmsRegColorSpaceEntry _XcmsRegColorSpaces[] = {
+ { _XcmsCIEXYZ_prefix, XcmsCIEXYZFormat },
+ { _XcmsCIEuvY_prefix, XcmsCIEuvYFormat },
+ { _XcmsCIExyY_prefix, XcmsCIExyYFormat },
+ { _XcmsCIELab_prefix, XcmsCIELabFormat },
+ { _XcmsCIELuv_prefix, XcmsCIELuvFormat },
+ { _XcmsTekHVC_prefix, XcmsTekHVCFormat },
+ { _XcmsRGB_prefix, XcmsRGBFormat },
+ { _XcmsRGBi_prefix, XcmsRGBiFormat },
+ { NULL, 0 }
+};
diff --git a/nx-X11/lib/src/xcms/cmsInt.c b/nx-X11/lib/src/xcms/cmsInt.c
new file mode 100644
index 000000000..f4aef04ff
--- /dev/null
+++ b/nx-X11/lib/src/xcms/cmsInt.c
@@ -0,0 +1,411 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ * NAME
+ * XcmsInt.c - Xcms API utility routines
+ *
+ * DESCRIPTION
+ * Xcms Application Program Interface (API) utility
+ * routines for hanging information directly onto
+ * the Display structure.
+ *
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <stdio.h>
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+#ifndef XCMSCOMPPROC
+# define XCMSCOMPPROC XcmsTekHVCClipC
+#endif
+
+/* forward/static */
+static void _XcmsFreeDefaultCCCs(Display *dpy);
+
+
+/************************************************************************
+ * *
+ * API PRIVATE ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * _XcmsCopyPointerArray
+ *
+ * SYNOPSIS
+ */
+XPointer *
+_XcmsCopyPointerArray(
+ XPointer *pap)
+/*
+ * DESCRIPTION
+ * Copies an array of NULL terminated pointers.
+ *
+ * RETURNS
+ * Returns NULL if failed; otherwise the address to
+ * the copy.
+ *
+ */
+{
+ XPointer *newArray;
+ char **tmp;
+ int n;
+
+ for (tmp = pap, n = 0; *tmp != NULL; tmp++, n++);
+ n++; /* add 1 to include the NULL pointer */
+
+ if ((newArray = Xmalloc(n * sizeof(XPointer)))) {
+ memcpy((char *)newArray, (char *)pap,
+ (unsigned)(n * sizeof(XPointer)));
+ }
+ return((XPointer *)newArray);
+}
+
+/*
+ * NAME
+ * _XcmsFreePointerArray
+ *
+ * SYNOPSIS
+ */
+void
+_XcmsFreePointerArray(
+ XPointer *pap)
+/*
+ * DESCRIPTION
+ * Frees an array of NULL terminated pointers.
+ *
+ * RETURNS
+ * void
+ *
+ */
+{
+ Xfree(pap);
+}
+
+/*
+ * NAME
+ * _XcmsPushPointerArray
+ *
+ * SYNOPSIS
+ */
+XPointer *
+_XcmsPushPointerArray(
+ XPointer *pap,
+ XPointer p,
+ XPointer *papNoFree)
+/*
+ * DESCRIPTION
+ * Places the specified pointer at the head of an array of NULL
+ * terminated pointers.
+ *
+ * RETURNS
+ * Returns NULL if failed; otherwise the address to
+ * the head of the array.
+ *
+ */
+{
+ XPointer *newArray;
+ char **tmp;
+ int n;
+
+ for (tmp = pap, n = 0; *tmp != NULL; tmp++, n++);
+
+ /* add 2: 1 for the new pointer and another for the NULL pointer */
+ n += 2;
+
+ if ((newArray = Xmalloc(n * sizeof(XPointer)))) {
+ memcpy((char *)(newArray+1),(char *)pap,
+ (unsigned)((n-1) * sizeof(XPointer)));
+ *newArray = p;
+ }
+ if (pap != papNoFree) {
+ _XcmsFreePointerArray(pap);
+ }
+ return((XPointer *)newArray);
+}
+
+/*
+ * NAME
+ * _XcmsInitDefaultCCCs
+ *
+ * SYNOPSIS
+ */
+int
+_XcmsInitDefaultCCCs(
+ Display *dpy)
+/*
+ * DESCRIPTION
+ * Initializes the Xcms per Display Info structure
+ * (XcmsPerDpyInfo).
+ *
+ * RETURNS
+ * Returns 0 if failed; otherwise non-zero.
+ *
+ */
+{
+ int nScrn = ScreenCount(dpy);
+ int i;
+ XcmsCCC ccc;
+
+ if (nScrn <= 0) {
+ return(0);
+ }
+
+ /*
+ * Create an array of XcmsCCC structures, one for each screen.
+ * They serve as the screen's default CCC.
+ */
+ if (!(ccc = Xcalloc((unsigned)nScrn, sizeof(XcmsCCCRec)))) {
+ return(0);
+ }
+ dpy->cms.defaultCCCs = (XPointer)ccc;
+ dpy->free_funcs->defaultCCCs = _XcmsFreeDefaultCCCs;
+
+ for (i = 0; i < nScrn; i++, ccc++) {
+ ccc->dpy = dpy;
+ ccc->screenNumber = i;
+ ccc->visual = DefaultVisual(dpy, i);
+ /*
+ * Used calloc to allocate memory so:
+ * ccc->clientWhitePt->format == XcmsUndefinedFormat
+ * ccc->gamutCompProc == NULL
+ * ccc->whitePtAdjProc == NULL
+ * ccc->pPerScrnInfo = NULL
+ *
+ * Don't need to create XcmsPerScrnInfo and its functionSet and
+ * pScreenData components until the default CCC is accessed.
+ * Note that the XcmsDefaultCCC routine calls _XcmsInitScrnInto
+ * to do this.
+ */
+ ccc->gamutCompProc = XCMSCOMPPROC;
+ }
+
+ return(1);
+}
+
+
+/*
+ * NAME
+ * _XcmsFreeDefaultCCCs - Free Default CCCs and its PerScrnInfo
+ *
+ * SYNOPSIS
+ */
+static void
+_XcmsFreeDefaultCCCs(
+ Display *dpy)
+/*
+ * DESCRIPTION
+ * This routine frees the default XcmsCCC's associated with
+ * each screen and its associated substructures as neccessary.
+ *
+ * RETURNS
+ * void
+ *
+ *
+ */
+{
+ int nScrn = ScreenCount(dpy);
+ XcmsCCC ccc;
+ int i;
+
+ /*
+ * Free Screen data in each DefaultCCC
+ * Do not use XcmsFreeCCC here because it will not free
+ * DefaultCCC's.
+ */
+ ccc = (XcmsCCC)dpy->cms.defaultCCCs;
+ for (i = nScrn; i--; ccc++) {
+ /*
+ * Check if XcmsPerScrnInfo exists.
+ *
+ * This is the only place where XcmsPerScrnInfo structures
+ * are freed since there is only one allocated per Screen.
+ * It just so happens that we place its reference in the
+ * default CCC.
+ */
+ if (ccc->pPerScrnInfo) {
+ /* Check if SCCData exists */
+ if (ccc->pPerScrnInfo->state != XcmsInitNone
+ && ccc->pPerScrnInfo->screenData) {
+ (*((XcmsFunctionSet *)ccc->pPerScrnInfo->functionSet)->screenFreeProc)
+ (ccc->pPerScrnInfo->screenData);
+ }
+ Xfree(ccc->pPerScrnInfo);
+ }
+ }
+
+ /*
+ * Free the array of XcmsCCC structures
+ */
+ Xfree(dpy->cms.defaultCCCs);
+ dpy->cms.defaultCCCs = (XPointer)NULL;
+}
+
+
+
+/*
+ * NAME
+ * _XcmsInitScrnInfo
+ *
+ * SYNOPSIS
+ */
+int
+_XcmsInitScrnInfo(
+ register Display *dpy,
+ int screenNumber)
+/*
+ * DESCRIPTION
+ * Given a display and screen number, this routine attempts
+ * to initialize the Xcms per Screen Info structure
+ * (XcmsPerScrnInfo).
+ *
+ * RETURNS
+ * Returns zero if initialization failed; non-zero otherwise.
+ */
+{
+ XcmsFunctionSet **papSCCFuncSet = _XcmsSCCFuncSets;
+ XcmsCCC defaultccc;
+
+ /*
+ * Check if the XcmsCCC's for each screen has been created.
+ * Really dont need to be created until some routine uses the Xcms
+ * API routines.
+ */
+ if ((XcmsCCC)dpy->cms.defaultCCCs == NULL) {
+ if (!_XcmsInitDefaultCCCs(dpy)) {
+ return(0);
+ }
+ }
+
+ defaultccc = (XcmsCCC)dpy->cms.defaultCCCs + screenNumber;
+
+ /*
+ * For each SCCFuncSet, try its pInitScrnFunc.
+ * If the function succeeds, then we got it!
+ */
+
+ if (!defaultccc->pPerScrnInfo) {
+ /*
+ * This is one of two places where XcmsPerScrnInfo structures
+ * are allocated. There is one allocated per Screen that is
+ * shared among visuals that do not have specific intensity
+ * tables. Other XcmsPerScrnInfo structures are created
+ * for the latter (see XcmsCreateCCC). The ones created
+ * here are referenced by the default CCC.
+ */
+ if (!(defaultccc->pPerScrnInfo =
+ Xcalloc(1, sizeof(XcmsPerScrnInfo)))) {
+ return(0);
+ }
+ defaultccc->pPerScrnInfo->state = XcmsInitNone;
+ }
+
+ while (*papSCCFuncSet != NULL) {
+ if ((*(*papSCCFuncSet)->screenInitProc)(dpy, screenNumber,
+ defaultccc->pPerScrnInfo)) {
+ defaultccc->pPerScrnInfo->state = XcmsInitSuccess;
+ return(1);
+ }
+ papSCCFuncSet++;
+ }
+
+ /*
+ * Use Default SCCData
+ */
+ return(_XcmsLRGB_InitScrnDefault(dpy, screenNumber, defaultccc->pPerScrnInfo));
+}
+
+
+/*
+ * NAME
+ * _XcmsFreeIntensityMaps
+ *
+ * SYNOPSIS
+ */
+void
+_XcmsFreeIntensityMaps(
+ Display *dpy)
+/*
+ * DESCRIPTION
+ * Frees all XcmsIntensityMap structures in the linked list
+ * and sets dpy->cms.perVisualIntensityMaps to NULL.
+ *
+ * RETURNS
+ * void
+ *
+ */
+{
+ XcmsIntensityMap *pNext, *pFree;
+
+ pNext = (XcmsIntensityMap *)dpy->cms.perVisualIntensityMaps;
+ while (pNext != NULL) {
+ pFree = pNext;
+ pNext = pNext->pNext;
+ (*pFree->pFreeScreenData)(pFree->screenData);
+ /* Now free the XcmsIntensityMap structure */
+ Xfree(pFree);
+ }
+ dpy->cms.perVisualIntensityMaps = (XPointer)NULL;
+}
+
+
+/*
+ * NAME
+ * _XcmsGetIntensityMap
+ *
+ * SYNOPSIS
+ */
+XcmsIntensityMap *
+_XcmsGetIntensityMap(
+ Display *dpy,
+ Visual *visual)
+/*
+ * DESCRIPTION
+ * Attempts to return a per-Visual intensity map.
+ *
+ * RETURNS
+ * Pointer to the XcmsIntensityMap structure if found;
+ * otherwise NULL
+ *
+ */
+{
+ VisualID targetID = visual->visualid;
+ XcmsIntensityMap *pNext;
+
+ pNext = (XcmsIntensityMap *)dpy->cms.perVisualIntensityMaps;
+ while (pNext != NULL) {
+ if (targetID == pNext->visualID) {
+ return(pNext);
+ }
+ pNext = pNext->pNext;
+ }
+ return((XcmsIntensityMap *)NULL);
+}
diff --git a/nx-X11/lib/src/xcms/cmsLkCol.c b/nx-X11/lib/src/xcms/cmsLkCol.c
new file mode 100644
index 000000000..15e987424
--- /dev/null
+++ b/nx-X11/lib/src/xcms/cmsLkCol.c
@@ -0,0 +1,193 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ * NAME
+ * XcmsLkCol.c
+ *
+ * DESCRIPTION
+ * Source for XcmsLookupColor
+ *
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <stdio.h>
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+
+/*
+ * NAME
+ * XcmsLookupColor -
+ *
+ * SYNOPSIS
+ */
+Status
+XcmsLookupColor (
+ Display *dpy,
+ Colormap cmap,
+ _Xconst char *colorname,
+ XcmsColor *pColor_exact_return,
+ XcmsColor *pColor_scrn_return,
+ XcmsColorFormat result_format)
+/*
+ * DESCRIPTION
+ * The XcmsLookupColor function finds the color specification
+ * associated with a color name in the Device-Independent Color
+ * Name Database.
+ * RETURNS
+ * This function returns both the color specification found in the
+ * database (db specification) and the color specification for the
+ * color displayable by the specified screen (screen
+ * specification). The calling routine sets the format for these
+ * returned specifications in the XcmsColor format component.
+ * If XcmsUndefinedFormat, the specification is returned in the
+ * format used to store the color in the database.
+ */
+{
+ Status retval1 = XcmsSuccess;
+ Status retval2 = XcmsSuccess;
+ XcmsCCC ccc;
+ register int n;
+ xLookupColorReply reply;
+ register xLookupColorReq *req;
+ XColor def, scr;
+
+/*
+ * 0. Check for invalid arguments.
+ */
+ if (dpy == NULL || colorname[0] == '\0' || pColor_scrn_return == 0
+ || pColor_exact_return == NULL) {
+ return(XcmsFailure);
+ }
+
+ if ((ccc = XcmsCCCOfColormap(dpy, cmap)) == (XcmsCCC)NULL) {
+ return(XcmsFailure);
+ }
+
+/*
+ * 1. Convert string to a XcmsColor
+ */
+ if ((retval1 = _XcmsResolveColorString(ccc, &colorname,
+ pColor_exact_return, result_format)) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+ if (retval1 == _XCMS_NEWNAME) {
+ goto PassToServer;
+ }
+
+/*
+ * 2. pColor_scrn_return
+ * Assume the pColor_exact_return has already been adjusted to
+ * the Client White Point.
+ *
+ */
+ /*
+ * Convert to RGB, adjusting for white point differences if necessary.
+ */
+ memcpy((char *)pColor_scrn_return, (char *)pColor_exact_return,
+ sizeof(XcmsColor));
+ if (pColor_scrn_return->format == XcmsRGBFormat) {
+ retval2 = XcmsSuccess;
+ } else if ((retval2 = XcmsConvertColors(ccc, pColor_scrn_return, 1,
+ XcmsRGBFormat, (Bool *)NULL)) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Then, convert XcmsColor structure to the target specification
+ * format. Note that we must use NULL instead of passing
+ * pCompressed.
+ */
+
+ if (result_format == XcmsUndefinedFormat) {
+ result_format = pColor_exact_return->format;
+ }
+ if (result_format == XcmsRGBFormat) {
+ _XcmsUnresolveColor(ccc, pColor_scrn_return);
+ } else {
+ _XcmsResolveColor(ccc, pColor_scrn_return);
+ if (XcmsConvertColors(ccc, pColor_scrn_return, 1, result_format,
+ (Bool *) NULL) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+ }
+
+ return(retval1 > retval2 ? retval1 : retval2);
+
+PassToServer:
+ /*
+ * Xcms and i18n methods failed, so lets pass it to the server
+ * for parsing.
+ */
+
+ LockDisplay(dpy);
+ GetReq (LookupColor, req);
+ req->cmap = cmap;
+ req->nbytes = n = strlen(colorname);
+ req->length += (n + 3) >> 2;
+ Data (dpy, colorname, (long)n);
+ if (!_XReply (dpy, (xReply *) &reply, 0, xTrue)) {
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return (XcmsFailure);
+ }
+ def.red = reply.exactRed;
+ def.green = reply.exactGreen;
+ def.blue = reply.exactBlue;
+
+ scr.red = reply.screenRed;
+ scr.green = reply.screenGreen;
+ scr.blue = reply.screenBlue;
+
+ UnlockDisplay(dpy);
+ SyncHandle();
+
+ _XColor_to_XcmsRGB(ccc, &def, pColor_exact_return, 1);
+ _XColor_to_XcmsRGB(ccc, &scr, pColor_scrn_return, 1);
+
+ /*
+ * Then, convert XcmsColor structure to the target specification
+ * format. Note that we must use NULL instead of passing
+ * pCompressed.
+ */
+
+ if (result_format != XcmsRGBFormat
+ && result_format != XcmsUndefinedFormat) {
+ if (XcmsConvertColors(ccc, pColor_exact_return, 1, result_format,
+ (Bool *) NULL) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+ if (XcmsConvertColors(ccc, pColor_scrn_return, 1, result_format,
+ (Bool *) NULL) == XcmsFailure) {
+ return(XcmsFailure);
+ }
+ }
+
+ return(XcmsSuccess);
+}
diff --git a/nx-X11/lib/src/xcms/cmsMath.c b/nx-X11/lib/src/xcms/cmsMath.c
new file mode 100644
index 000000000..487eb3f9c
--- /dev/null
+++ b/nx-X11/lib/src/xcms/cmsMath.c
@@ -0,0 +1,140 @@
+
+/*
+
+Copyright 1990, 1998 The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+
+/*
+ * Stephen Gildea, MIT X Consortium, January 1991
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include "Xcmsint.h"
+
+#ifdef DEBUG
+#include <stdio.h>
+#endif
+
+#include <float.h>
+#ifndef DBL_EPSILON
+#define DBL_EPSILON 1e-6
+#endif
+
+#ifdef _X_ROOT_STATS
+int cbrt_loopcount;
+int sqrt_loopcount;
+#endif
+
+/* Newton's Method: x_n+1 = x_n - ( f(x_n) / f'(x_n) ) */
+
+
+/* for cube roots, x^3 - a = 0, x_new = x - 1/3 (x - a/x^2) */
+
+double
+_XcmsCubeRoot(double a)
+{
+ register double abs_a, cur_guess, delta;
+
+#ifdef DEBUG
+ printf("_XcmsCubeRoot passed in %g\n", a);
+#endif
+#ifdef _X_ROOT_STATS
+ cbrt_loopcount = 0;
+#endif
+ if (a == 0.)
+ return 0.;
+
+ abs_a = a<0. ? -a : a; /* convert to positive to speed loop tests */
+
+ /* arbitrary first guess */
+ if (abs_a > 1.)
+ cur_guess = abs_a/8.;
+ else
+ cur_guess = abs_a*8.;
+
+ do {
+#ifdef _X_ROOT_STATS
+ cbrt_loopcount++;
+#endif
+ delta = (cur_guess - abs_a/(cur_guess*cur_guess))/3.;
+ cur_guess -= delta;
+ if (delta < 0.) delta = -delta;
+ } while (delta >= cur_guess*DBL_EPSILON);
+
+ if (a < 0.)
+ cur_guess = -cur_guess;
+
+#ifdef DEBUG
+ printf("_XcmsCubeRoot returning %g\n", cur_guess);
+#endif
+ return cur_guess;
+}
+
+
+
+/* for square roots, x^2 - a = 0, x_new = x - 1/2 (x - a/x) */
+
+double
+_XcmsSquareRoot(double a)
+{
+ register double cur_guess, delta;
+
+#ifdef DEBUG
+ printf("_XcmsSquareRoot passed in %g\n", a);
+#endif
+#ifdef _X_ROOT_STATS
+ sqrt_loopcount = 0;
+#endif
+ if (a == 0.)
+ return 0.;
+
+ if (a < 0.) {
+ /* errno = EDOM; */
+ return 0.;
+ }
+
+ /* arbitrary first guess */
+ if (a > 1.)
+ cur_guess = a/4.;
+ else
+ cur_guess = a*4.;
+
+ do {
+#ifdef _X_ROOT_STATS
+ sqrt_loopcount++;
+#endif
+ delta = (cur_guess - a/cur_guess)/2.;
+ cur_guess -= delta;
+ if (delta < 0.) delta = -delta;
+ } while (delta >= cur_guess*DBL_EPSILON);
+
+#ifdef DEBUG
+ printf("_XcmsSquareRoot returning %g\n", cur_guess);
+#endif
+ return cur_guess;
+}
+
diff --git a/nx-X11/lib/src/xcms/cmsProp.c b/nx-X11/lib/src/xcms/cmsProp.c
new file mode 100644
index 000000000..a7aa5b5c5
--- /dev/null
+++ b/nx-X11/lib/src/xcms/cmsProp.c
@@ -0,0 +1,153 @@
+
+/*
+ *
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ * NAME
+ * XcmsProp.c
+ *
+ * DESCRIPTION
+ * This utility routines for manipulating properties.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <nx-X11/Xatom.h>
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+
+/************************************************************************
+ * *
+ * API PRIVATE ROUTINES *
+ * *
+ ************************************************************************/
+
+
+/*
+ * NAME
+ * _XcmsGetElement -- get an element value from the property passed
+ *
+ * SYNOPSIS
+ */
+unsigned long
+_XcmsGetElement(
+ int format,
+ char **pValue,
+ unsigned long *pCount)
+/*
+ * DESCRIPTION
+ * Get the next element from the property and return it.
+ * Also increment the pointer the amount needed.
+ *
+ * Returns
+ * unsigned long
+ */
+{
+ unsigned long value;
+
+ switch (format) {
+ case 32:
+ value = *((unsigned long *)(*pValue)) & 0xFFFFFFFF;
+ *pValue += sizeof(unsigned long);
+ *pCount -= 1;
+ break;
+ case 16:
+ value = *((unsigned short *)(*pValue));
+ *pValue += sizeof(unsigned short);
+ *pCount -= 1;
+ break;
+ case 8:
+ value = *((unsigned char *) (*pValue));
+ *pValue += 1;
+ *pCount -= 1;
+ break;
+ default:
+ value = 0;
+ break;
+ }
+ return(value);
+}
+
+
+/*
+ * NAME
+ * _XcmsGetProperty -- Determine the existance of a property
+ *
+ * SYNOPSIS
+ */
+int
+_XcmsGetProperty(
+ Display *pDpy,
+ Window w,
+ Atom property,
+ int *pFormat,
+ unsigned long *pNItems,
+ unsigned long *pNBytes,
+ char **pValue)
+/*
+ * DESCRIPTION
+ *
+ * Returns
+ * 0 if property does not exist.
+ * 1 if property exists.
+ */
+{
+ char *prop_ret;
+ int format_ret;
+ long len = 6516;
+ #ifdef NXAGENT_SERVER
+ unsigned long nitems_ret, after_ret = 0;
+ #else
+ unsigned long nitems_ret, after_ret;
+ #endif
+ Atom atom_ret;
+ int xgwp_ret;
+
+ while (True) {
+ xgwp_ret = XGetWindowProperty (pDpy, w, property, 0, len, False,
+ XA_INTEGER, &atom_ret, &format_ret,
+ &nitems_ret, &after_ret,
+ (unsigned char **)&prop_ret);
+ if (xgwp_ret == Success && after_ret > 0) {
+ len += nitems_ret * (format_ret >> 3);
+ XFree (prop_ret);
+ } else {
+ break;
+ }
+ }
+ if (xgwp_ret != Success || format_ret == 0 || nitems_ret == 0) {
+ /* the property does not exist or is of an unexpected type or
+ getting window property failed */
+ return(XcmsFailure);
+ }
+
+ *pFormat = format_ret;
+ *pNItems = nitems_ret;
+ *pNBytes = nitems_ret * (format_ret >> 3);
+ *pValue = prop_ret;
+ return(XcmsSuccess);
+}
diff --git a/nx-X11/lib/src/xcms/cmsTrig.c b/nx-X11/lib/src/xcms/cmsTrig.c
new file mode 100644
index 000000000..b23033aa8
--- /dev/null
+++ b/nx-X11/lib/src/xcms/cmsTrig.c
@@ -0,0 +1,578 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/*
+ * It should be pointed out that for simplicity's sake, the
+ * environment parameters are defined as floating point constants,
+ * rather than octal or hexadecimal initializations of allocated
+ * storage areas. This means that the range of allowed numbers
+ * may not exactly match the hardware's capabilities. For example,
+ * if the maximum positive double precision floating point number
+ * is EXACTLY 1.11...E100 and the constant "MAXDOUBLE is
+ * defined to be 1.11E100 then the numbers between 1.11E100 and
+ * 1.11...E100 are considered to be undefined. For most
+ * applications, this will cause no problems.
+ *
+ * An alternate method is to allocate a global static "double" variable,
+ * say "maxdouble", and use a union declaration and initialization
+ * to initialize it with the proper bits for the EXACT maximum value.
+ * This was not done because the only compilers available to the
+ * author did not fully support union initialization features.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xcmsint.h"
+
+/* forward/static */
+static double _XcmsModulo(double value, double base);
+static double _XcmsPolynomial(
+ register int order,
+ double const *coeffs,
+ double x);
+static double
+_XcmsModuloF(
+ double val,
+ register double *dp);
+
+/*
+ * DEFINES
+ */
+#define XCMS_MAXERROR 0.000001
+#define XCMS_MAXITER 10000
+#define XCMS_PI 3.14159265358979323846264338327950
+#define XCMS_TWOPI 6.28318530717958620
+#define XCMS_HALFPI 1.57079632679489660
+#define XCMS_FOURTHPI 0.785398163397448280
+#define XCMS_SIXTHPI 0.523598775598298820
+#define XCMS_RADIANS(d) ((d) * XCMS_PI / 180.0)
+#define XCMS_DEGREES(r) ((r) * 180.0 / XCMS_PI)
+#define XCMS_X6_UNDERFLOWS (4.209340e-52) /* X**6 almost underflows */
+#define XCMS_X16_UNDERFLOWS (5.421010e-20) /* X**16 almost underflows*/
+#define XCMS_CHAR_BIT 8
+#define XCMS_LONG_MAX 0x7FFFFFFF
+#define XCMS_DEXPLEN 11
+#define XCMS_NBITS(type) (XCMS_CHAR_BIT * (int)sizeof(type))
+#define XCMS_FABS(x) ((x) < 0.0 ? -(x) : (x))
+
+/* XCMS_DMAXPOWTWO - largest power of two exactly representable as a double */
+#define XCMS_DMAXPOWTWO ((double)(XCMS_LONG_MAX) * \
+ (1L << ((XCMS_NBITS(double)-XCMS_DEXPLEN) - XCMS_NBITS(int) + 1)))
+
+/*
+ * LOCAL VARIABLES
+ */
+
+static double const cos_pcoeffs[] = {
+ 0.12905394659037374438e7,
+ -0.37456703915723204710e6,
+ 0.13432300986539084285e5,
+ -0.11231450823340933092e3
+};
+
+static double const cos_qcoeffs[] = {
+ 0.12905394659037373590e7,
+ 0.23467773107245835052e5,
+ 0.20969518196726306286e3,
+ 1.0
+};
+
+static double const sin_pcoeffs[] = {
+ 0.20664343336995858240e7,
+ -0.18160398797407332550e6,
+ 0.35999306949636188317e4,
+ -0.20107483294588615719e2
+};
+
+static double const sin_qcoeffs[] = {
+ 0.26310659102647698963e7,
+ 0.39270242774649000308e5,
+ 0.27811919481083844087e3,
+ 1.0
+};
+
+/*
+ *
+ * FUNCTION
+ *
+ * _XcmsCosine double precision cosine
+ *
+ * KEY WORDS
+ *
+ * cos
+ * machine independent routines
+ * trigonometric functions
+ * math libraries
+ *
+ * DESCRIPTION
+ *
+ * Returns double precision cosine of double precision
+ * floating point argument.
+ *
+ * USAGE
+ *
+ * double _XcmsCosine (x)
+ * double x;
+ *
+ * REFERENCES
+ *
+ * Computer Approximations, J.F. Hart et al, John Wiley & Sons,
+ * 1968, pp. 112-120.
+ *
+ * RESTRICTIONS
+ *
+ * The sin and cos routines are interactive in the sense that
+ * in the process of reducing the argument to the range -PI/4
+ * to PI/4, each may call the other. Ultimately one or the
+ * other uses a polynomial approximation on the reduced
+ * argument. The sin approximation has a maximum relative error
+ * of 10**(-17.59) and the cos approximation has a maximum
+ * relative error of 10**(-16.18).
+ *
+ * These error bounds assume exact arithmetic
+ * in the polynomial evaluation. Additional rounding and
+ * truncation errors may occur as the argument is reduced
+ * to the range over which the polynomial approximation
+ * is valid, and as the polynomial is evaluated using
+ * finite-precision arithmetic.
+ *
+ * PROGRAMMER
+ *
+ * Fred Fish
+ *
+ * INTERNALS
+ *
+ * Computes cos(x) from:
+ *
+ * (1) Reduce argument x to range -PI to PI.
+ *
+ * (2) If x > PI/2 then call cos recursively
+ * using relation cos(x) = -cos(x - PI).
+ *
+ * (3) If x < -PI/2 then call cos recursively
+ * using relation cos(x) = -cos(x + PI).
+ *
+ * (4) If x > PI/4 then call sin using
+ * relation cos(x) = sin(PI/2 - x).
+ *
+ * (5) If x < -PI/4 then call cos using
+ * relation cos(x) = sin(PI/2 + x).
+ *
+ * (6) If x would cause underflow in approx
+ * evaluation arithmetic then return
+ * sqrt(1.0 - x**2).
+ *
+ * (7) By now x has been reduced to range
+ * -PI/4 to PI/4 and the approximation
+ * from HART pg. 119 can be used:
+ *
+ * cos(x) = ( p(y) / q(y) )
+ * Where:
+ *
+ * y = x * (4/PI)
+ *
+ * p(y) = SUM [ Pj * (y**(2*j)) ]
+ * over j = {0,1,2,3}
+ *
+ * q(y) = SUM [ Qj * (y**(2*j)) ]
+ * over j = {0,1,2,3}
+ *
+ * P0 = 0.12905394659037374438571854e+7
+ * P1 = -0.3745670391572320471032359e+6
+ * P2 = 0.134323009865390842853673e+5
+ * P3 = -0.112314508233409330923e+3
+ * Q0 = 0.12905394659037373590295914e+7
+ * Q1 = 0.234677731072458350524124e+5
+ * Q2 = 0.2096951819672630628621e+3
+ * Q3 = 1.0000...
+ * (coefficients from HART table #3843 pg 244)
+ *
+ *
+ * **** NOTE **** The range reduction relations used in
+ * this routine depend on the final approximation being valid
+ * over the negative argument range in addition to the positive
+ * argument range. The particular approximation chosen from
+ * HART satisfies this requirement, although not explicitly
+ * stated in the text. This may not be true of other
+ * approximations given in the reference.
+ *
+ */
+
+double _XcmsCosine(double x)
+{
+ auto double y;
+ auto double yt2;
+ double retval;
+
+ if (x < -XCMS_PI || x > XCMS_PI) {
+ x = _XcmsModulo (x, XCMS_TWOPI);
+ if (x > XCMS_PI) {
+ x = x - XCMS_TWOPI;
+ } else if (x < -XCMS_PI) {
+ x = x + XCMS_TWOPI;
+ }
+ }
+ if (x > XCMS_HALFPI) {
+ retval = -(_XcmsCosine (x - XCMS_PI));
+ } else if (x < -XCMS_HALFPI) {
+ retval = -(_XcmsCosine (x + XCMS_PI));
+ } else if (x > XCMS_FOURTHPI) {
+ retval = _XcmsSine (XCMS_HALFPI - x);
+ } else if (x < -XCMS_FOURTHPI) {
+ retval = _XcmsSine (XCMS_HALFPI + x);
+ } else if (x < XCMS_X6_UNDERFLOWS && x > -XCMS_X6_UNDERFLOWS) {
+ retval = _XcmsSquareRoot (1.0 - (x * x));
+ } else {
+ y = x / XCMS_FOURTHPI;
+ yt2 = y * y;
+ retval = _XcmsPolynomial (3, cos_pcoeffs, yt2) / _XcmsPolynomial (3, cos_qcoeffs, yt2);
+ }
+ return (retval);
+}
+
+
+/*
+ * FUNCTION
+ *
+ * _XcmsModulo double precision modulo
+ *
+ * KEY WORDS
+ *
+ * _XcmsModulo
+ * machine independent routines
+ * math libraries
+ *
+ * DESCRIPTION
+ *
+ * Returns double precision modulo of two double
+ * precision arguments.
+ *
+ * USAGE
+ *
+ * double _XcmsModulo (value, base)
+ * double value;
+ * double base;
+ *
+ * PROGRAMMER
+ *
+ * Fred Fish
+ *
+ */
+static double _XcmsModulo(double value, double base)
+{
+ auto double intpart;
+
+ value /= base;
+ value = _XcmsModuloF (value, &intpart);
+ value *= base;
+ return(value);
+}
+
+
+/*
+ * frac = (double) _XcmsModuloF(double val, double *dp)
+ * return fractional part of 'val'
+ * set *dp to integer part of 'val'
+ *
+ * Note -> only compiled for the CA or KA. For the KB/MC,
+ * "math.c" instantiates a copy of the inline function
+ * defined in "math.h".
+ */
+static double
+_XcmsModuloF(
+ double val,
+ register double *dp)
+{
+ register double abs;
+ /*
+ * Don't use a register for this. The extra precision this results
+ * in on some systems causes problems.
+ */
+ double ip;
+
+ /* should check for illegal values here - nan, inf, etc */
+ abs = XCMS_FABS(val);
+ if (abs >= XCMS_DMAXPOWTWO) {
+ ip = val;
+ } else {
+ ip = abs + XCMS_DMAXPOWTWO; /* dump fraction */
+ ip -= XCMS_DMAXPOWTWO; /* restore w/o frac */
+ if (ip > abs) /* if it rounds up */
+ ip -= 1.0; /* fix it */
+ ip = XCMS_FABS(ip);
+ }
+ *dp = ip;
+ return (val - ip); /* signed fractional part */
+}
+
+
+/*
+ * FUNCTION
+ *
+ * _XcmsPolynomial double precision polynomial evaluation
+ *
+ * KEY WORDS
+ *
+ * poly
+ * machine independent routines
+ * math libraries
+ *
+ * DESCRIPTION
+ *
+ * Evaluates a polynomial and returns double precision
+ * result. Is passed a the order of the polynomial,
+ * a pointer to an array of double precision polynomial
+ * coefficients (in ascending order), and the independent
+ * variable.
+ *
+ * USAGE
+ *
+ * double _XcmsPolynomial (order, coeffs, x)
+ * int order;
+ * double *coeffs;
+ * double x;
+ *
+ * PROGRAMMER
+ *
+ * Fred Fish
+ *
+ * INTERNALS
+ *
+ * Evalates the polynomial using recursion and the form:
+ *
+ * P(x) = P0 + x(P1 + x(P2 +...x(Pn)))
+ *
+ */
+
+static double _XcmsPolynomial(
+ register int order,
+ double const *coeffs,
+ double x)
+{
+ auto double rtn_value;
+
+ coeffs += order;
+ rtn_value = *coeffs--;
+ while(order-- > 0)
+ rtn_value = *coeffs-- + (x * rtn_value);
+
+ return(rtn_value);
+}
+
+
+/*
+ * FUNCTION
+ *
+ * _XcmsSine double precision sine
+ *
+ * KEY WORDS
+ *
+ * sin
+ * machine independent routines
+ * trigonometric functions
+ * math libraries
+ *
+ * DESCRIPTION
+ *
+ * Returns double precision sine of double precision
+ * floating point argument.
+ *
+ * USAGE
+ *
+ * double _XcmsSine (x)
+ * double x;
+ *
+ * REFERENCES
+ *
+ * Computer Approximations, J.F. Hart et al, John Wiley & Sons,
+ * 1968, pp. 112-120.
+ *
+ * RESTRICTIONS
+ *
+ * The sin and cos routines are interactive in the sense that
+ * in the process of reducing the argument to the range -PI/4
+ * to PI/4, each may call the other. Ultimately one or the
+ * other uses a polynomial approximation on the reduced
+ * argument. The sin approximation has a maximum relative error
+ * of 10**(-17.59) and the cos approximation has a maximum
+ * relative error of 10**(-16.18).
+ *
+ * These error bounds assume exact arithmetic
+ * in the polynomial evaluation. Additional rounding and
+ * truncation errors may occur as the argument is reduced
+ * to the range over which the polynomial approximation
+ * is valid, and as the polynomial is evaluated using
+ * finite-precision arithmetic.
+ *
+ * PROGRAMMER
+ *
+ * Fred Fish
+ *
+ * INTERNALS
+ *
+ * Computes sin(x) from:
+ *
+ * (1) Reduce argument x to range -PI to PI.
+ *
+ * (2) If x > PI/2 then call sin recursively
+ * using relation sin(x) = -sin(x - PI).
+ *
+ * (3) If x < -PI/2 then call sin recursively
+ * using relation sin(x) = -sin(x + PI).
+ *
+ * (4) If x > PI/4 then call cos using
+ * relation sin(x) = cos(PI/2 - x).
+ *
+ * (5) If x < -PI/4 then call cos using
+ * relation sin(x) = -cos(PI/2 + x).
+ *
+ * (6) If x is small enough that polynomial
+ * evaluation would cause underflow
+ * then return x, since sin(x)
+ * approaches x as x approaches zero.
+ *
+ * (7) By now x has been reduced to range
+ * -PI/4 to PI/4 and the approximation
+ * from HART pg. 118 can be used:
+ *
+ * sin(x) = y * ( p(y) / q(y) )
+ * Where:
+ *
+ * y = x * (4/PI)
+ *
+ * p(y) = SUM [ Pj * (y**(2*j)) ]
+ * over j = {0,1,2,3}
+ *
+ * q(y) = SUM [ Qj * (y**(2*j)) ]
+ * over j = {0,1,2,3}
+ *
+ * P0 = 0.206643433369958582409167054e+7
+ * P1 = -0.18160398797407332550219213e+6
+ * P2 = 0.359993069496361883172836e+4
+ * P3 = -0.2010748329458861571949e+2
+ * Q0 = 0.263106591026476989637710307e+7
+ * Q1 = 0.3927024277464900030883986e+5
+ * Q2 = 0.27811919481083844087953e+3
+ * Q3 = 1.0000...
+ * (coefficients from HART table #3063 pg 234)
+ *
+ *
+ * **** NOTE **** The range reduction relations used in
+ * this routine depend on the final approximation being valid
+ * over the negative argument range in addition to the positive
+ * argument range. The particular approximation chosen from
+ * HART satisfies this requirement, although not explicitly
+ * stated in the text. This may not be true of other
+ * approximations given in the reference.
+ *
+ */
+
+double
+_XcmsSine (double x)
+{
+ double y;
+ double yt2;
+ double retval;
+
+ if (x < -XCMS_PI || x > XCMS_PI) {
+ x = _XcmsModulo (x, XCMS_TWOPI);
+ if (x > XCMS_PI) {
+ x = x - XCMS_TWOPI;
+ } else if (x < -XCMS_PI) {
+ x = x + XCMS_TWOPI;
+ }
+ }
+ if (x > XCMS_HALFPI) {
+ retval = -(_XcmsSine (x - XCMS_PI));
+ } else if (x < -XCMS_HALFPI) {
+ retval = -(_XcmsSine (x + XCMS_PI));
+ } else if (x > XCMS_FOURTHPI) {
+ retval = _XcmsCosine (XCMS_HALFPI - x);
+ } else if (x < -XCMS_FOURTHPI) {
+ retval = -(_XcmsCosine (XCMS_HALFPI + x));
+ } else if (x < XCMS_X6_UNDERFLOWS && x > -XCMS_X6_UNDERFLOWS) {
+ retval = x;
+ } else {
+ y = x / XCMS_FOURTHPI;
+ yt2 = y * y;
+ retval = y * (_XcmsPolynomial (3, sin_pcoeffs, yt2) / _XcmsPolynomial(3, sin_qcoeffs, yt2));
+ }
+ return(retval);
+}
+
+
+/*
+ * NAME
+ * _XcmsArcTangent
+ *
+ * SYNOPSIS
+ */
+double
+_XcmsArcTangent(double x)
+/*
+ * DESCRIPTION
+ * Computes the arctangent.
+ * This is an implementation of the Gauss algorithm as
+ * described in:
+ * Forman S. Acton, Numerical Methods That Work,
+ * New York, NY, Harper & Row, 1970.
+ *
+ * RETURNS
+ * Returns the arctangent
+ */
+{
+ double ai, a1 = 0.0, bi, b1 = 0.0, l, d;
+ double maxerror;
+ int i;
+
+ if (x == 0.0) {
+ return (0.0);
+ }
+ if (x < 1.0) {
+ maxerror = x * XCMS_MAXERROR;
+ } else {
+ maxerror = XCMS_MAXERROR;
+ }
+ ai = _XcmsSquareRoot( 1.0 / (1.0 + (x * x)) );
+ bi = 1.0;
+ for (i = 0; i < XCMS_MAXITER; i++) {
+ a1 = (ai + bi) / 2.0;
+ b1 = _XcmsSquareRoot((a1 * bi));
+ if (a1 == b1)
+ break;
+ d = XCMS_FABS(a1 - b1);
+ if (d < maxerror)
+ break;
+ ai = a1;
+ bi = b1;
+ }
+
+ l = ((a1 > b1) ? b1 : a1);
+
+ a1 = _XcmsSquareRoot(1 + (x * x));
+ return (x / (a1 * l));
+}
diff --git a/nx-X11/lib/src/xcms/uvY.c b/nx-X11/lib/src/xcms/uvY.c
new file mode 100644
index 000000000..19e6c5232
--- /dev/null
+++ b/nx-X11/lib/src/xcms/uvY.c
@@ -0,0 +1,423 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of XCMS based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ *
+ * NAME
+ * CIEuvy.c
+ *
+ * DESCRIPTION
+ * This file contains routines that support the CIE u'v'Y
+ * color space to include conversions to and from the CIE
+ * XYZ space.
+ *
+ * DOCUMENTATION
+ * "TekColor Color Management System, System Implementor's Manual"
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <nx-X11/Xos.h>
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+#include <stdio.h>
+
+/*
+ * FORWARD DECLARATIONS
+ */
+static int CIEuvY_ParseString(register char *spec, XcmsColor *pColor);
+
+/*
+ * DEFINES
+ * Internal definitions that need NOT be exported to any package
+ * or program using this package.
+ */
+#ifdef DBL_EPSILON
+# define XMY_DBL_EPSILON DBL_EPSILON
+#else
+# define XMY_DBL_EPSILON 0.00001
+#endif
+
+
+/*
+ * LOCAL VARIABLES
+ */
+
+ /*
+ * NULL terminated list of functions applied to get from CIEuvY to CIEXYZ
+ */
+static XcmsConversionProc Fl_CIEuvY_to_CIEXYZ[] = {
+ XcmsCIEuvYToCIEXYZ,
+ NULL
+};
+
+ /*
+ * NULL terminated list of functions applied to get from CIEXYZ to CIEuvY
+ */
+static XcmsConversionProc Fl_CIEXYZ_to_CIEuvY[] = {
+ XcmsCIEXYZToCIEuvY,
+ NULL
+};
+
+
+/*
+ * GLOBALS
+ */
+
+ /*
+ * CIE uvY Color Space
+ */
+XcmsColorSpace XcmsCIEuvYColorSpace =
+ {
+ _XcmsCIEuvY_prefix, /* prefix */
+ XcmsCIEuvYFormat, /* id */
+ CIEuvY_ParseString, /* parseString */
+ Fl_CIEuvY_to_CIEXYZ, /* to_CIEXYZ */
+ Fl_CIEXYZ_to_CIEuvY, /* from_CIEXYZ */
+ 1
+ };
+
+
+
+/************************************************************************
+ * *
+ * PRIVATE ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * CIEuvY_ParseString
+ *
+ * SYNOPSIS
+ */
+static int
+CIEuvY_ParseString(
+ register char *spec,
+ XcmsColor *pColor)
+/*
+ * DESCRIPTION
+ * This routines takes a string and attempts to convert
+ * it into a XcmsColor structure with XcmsCIEuvYFormat.
+ * The assumed CIEuvY string syntax is:
+ * CIEuvY:<u>/<v>/<Y>
+ * Where u, v, and Y are in string input format for floats
+ * consisting of:
+ * a. an optional sign
+ * b. a string of numbers possibly containing a decimal point,
+ * c. an optional exponent field containing an 'E' or 'e'
+ * followed by a possibly signed integer string.
+ *
+ * RETURNS
+ * 0 if failed, non-zero otherwise.
+ */
+{
+ size_t n;
+ char *pchar;
+
+ if ((pchar = strchr(spec, ':')) == NULL) {
+ return(XcmsFailure);
+ }
+ n = (size_t)(pchar - spec);
+
+ /*
+ * Check for proper prefix.
+ */
+ if (strncmp(spec, _XcmsCIEuvY_prefix, n) != 0) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Attempt to parse the value portion.
+ */
+ if (sscanf(spec + n + 1, "%lf/%lf/%lf",
+ &pColor->spec.CIEuvY.u_prime,
+ &pColor->spec.CIEuvY.v_prime,
+ &pColor->spec.CIEuvY.Y) != 3) {
+ char *s; /* Maybe failed due to locale */
+ int f;
+ if ((s = strdup(spec))) {
+ for (f = 0; s[f]; ++f)
+ if (s[f] == '.')
+ s[f] = ',';
+ else if (s[f] == ',')
+ s[f] = '.';
+ if (sscanf(s + n + 1, "%lf/%lf/%lf",
+ &pColor->spec.CIEuvY.u_prime,
+ &pColor->spec.CIEuvY.v_prime,
+ &pColor->spec.CIEuvY.Y) != 3) {
+ free(s);
+ return(XcmsFailure);
+ }
+ free(s);
+ } else
+ return(XcmsFailure);
+ }
+ pColor->format = XcmsCIEuvYFormat;
+ pColor->pixel = 0;
+ return(_XcmsCIEuvY_ValidSpec(pColor));
+}
+
+
+/************************************************************************
+ * *
+ * PUBLIC ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * XcmsCIEuvY_ValidSpec
+ *
+ * SYNOPSIS
+ */
+Status
+_XcmsCIEuvY_ValidSpec(
+ XcmsColor *pColor)
+/*
+ * DESCRIPTION
+ * Checks if color specification valid for CIE u'v'Y.
+ *
+ * RETURNS
+ * XcmsFailure if invalid,
+ * XcmsSuccess if valid.
+ *
+ */
+{
+ if (pColor->format != XcmsCIEuvYFormat
+ ||
+ (pColor->spec.CIEuvY.Y < 0.0 - XMY_DBL_EPSILON)
+ ||
+ (pColor->spec.CIEuvY.Y > 1.0 + XMY_DBL_EPSILON)) {
+ return(XcmsFailure);
+ }
+ return(XcmsSuccess);
+}
+
+
+/*
+ * NAME
+ * XcmsCIEuvYToCIEXYZ - convert CIEuvY to CIEXYZ
+ *
+ * SYNOPSIS
+ */
+Status
+XcmsCIEuvYToCIEXYZ(
+ XcmsCCC ccc,
+ XcmsColor *puvY_WhitePt,
+ XcmsColor *pColors_in_out,
+ unsigned int nColors)
+/*
+ * DESCRIPTION
+ * Converts color specifications in an array of XcmsColor
+ * structures from CIEuvY format to CIEXYZ format.
+ *
+ * RETURNS
+ * XcmsFailure if failed,
+ * XcmsSuccess if succeeded.
+ *
+ */
+{
+ XcmsCIEXYZ XYZ_return;
+ XcmsColor whitePt;
+ unsigned int i;
+ XcmsColor *pColor = pColors_in_out;
+ XcmsFloat div, x, y, z, Y;
+
+ /*
+ * Check arguments
+ * Postpone checking puvY_WhitePt until it is actually needed
+ * otherwise converting between XYZ and uvY will fail.
+ */
+ if (pColors_in_out == NULL) {
+ return(XcmsFailure);
+ }
+
+
+ /*
+ * Now convert each XcmsColor structure to CIEXYZ form
+ */
+ for (i = 0; i < nColors; i++, pColor++) {
+
+ /* Make sure original format is CIEuvY */
+ if (!_XcmsCIEuvY_ValidSpec(pColor)) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Convert to CIEXYZ
+ */
+
+ Y = pColor->spec.CIEuvY.Y;
+
+ /* Convert color u'v' to xyz space */
+ div = (6.0 * pColor->spec.CIEuvY.u_prime) - (16.0 * pColor->spec.CIEuvY.v_prime) + 12.0;
+ if (div == 0.0) {
+ /* use white point since div == 0 */
+ if (puvY_WhitePt == NULL ) {
+ return(XcmsFailure);
+ }
+ /*
+ * Make sure white point is in CIEuvY form
+ */
+ if (puvY_WhitePt->format != XcmsCIEuvYFormat) {
+ /* Make copy of the white point because we're going to modify it */
+ memcpy((char *)&whitePt, (char *)puvY_WhitePt, sizeof(XcmsColor));
+ if (!_XcmsDIConvertColors(ccc, &whitePt, (XcmsColor *)NULL, 1,
+ XcmsCIEuvYFormat)) {
+ return(XcmsFailure);
+ }
+ puvY_WhitePt = &whitePt;
+ }
+ /* Make sure it is a white point, i.e., Y == 1.0 */
+ if (puvY_WhitePt->spec.CIEuvY.Y != 1.0) {
+ return(XcmsFailure);
+ }
+ div = (6.0 * puvY_WhitePt->spec.CIEuvY.u_prime) -
+ (16.0 * puvY_WhitePt->spec.CIEuvY.v_prime) + 12.0;
+ if (div == 0) {
+ /* internal error */
+ return(XcmsFailure);
+ }
+ x = 9.0 * puvY_WhitePt->spec.CIEuvY.u_prime / div;
+ y = 4.0 * puvY_WhitePt->spec.CIEuvY.v_prime / div;
+ } else {
+ x = 9.0 * pColor->spec.CIEuvY.u_prime / div;
+ y = 4.0 * pColor->spec.CIEuvY.v_prime / div;
+ }
+ z = 1.0 - x - y;
+
+ /* Convert from xyz to XYZ */
+ /* Conversion uses color normalized lightness based on Y */
+ if (y != 0.0) {
+ XYZ_return.X = x * Y / y;
+ } else {
+ XYZ_return.X = x;
+ }
+ XYZ_return.Y = Y;
+ if (y != 0.0) {
+ XYZ_return.Z = z * Y / y;
+ } else {
+ XYZ_return.Z = z;
+ }
+
+ memcpy((char *)&pColor->spec.CIEXYZ, (char *)&XYZ_return, sizeof(XcmsCIEXYZ));
+ /* Identify that format is now CIEXYZ */
+ pColor->format = XcmsCIEXYZFormat;
+ }
+
+ return(XcmsSuccess);
+}
+
+
+/*
+ * NAME
+ * XcmsCIEXYZToCIEuvY - convert CIEXYZ to CIEuvY
+ *
+ * SYNOPSIS
+ */
+Status
+XcmsCIEXYZToCIEuvY(
+ XcmsCCC ccc,
+ XcmsColor *puvY_WhitePt,
+ XcmsColor *pColors_in_out,
+ unsigned int nColors)
+/*
+ * DESCRIPTION
+ * Converts color specifications in an array of XcmsColor
+ * structures from CIEXYZ format to CIEuvY format.
+ *
+ * RETURNS
+ * XcmsFailure if failed,
+ * XcmsSuccess if succeeded.
+ *
+ */
+{
+ XcmsCIEuvY uvY_return;
+ XcmsColor whitePt;
+ unsigned int i;
+ XcmsColor *pColor = pColors_in_out;
+ XcmsFloat div;
+
+ /*
+ * Check arguments
+ * Postpone checking puvY_WhitePt until it is actually needed
+ * otherwise converting between XYZ and uvY will fail.
+ */
+ if (pColors_in_out == NULL) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Now convert each XcmsColor structure to CIEuvY form
+ */
+ for (i = 0; i < nColors; i++, pColor++) {
+
+ /* Make sure original format is CIEXYZ */
+ if (!_XcmsCIEXYZ_ValidSpec(pColor)) {
+ return(XcmsFailure);
+ }
+
+ /* Convert to CIEuvY */
+ div = pColor->spec.CIEXYZ.X + (15.0 * pColor->spec.CIEXYZ.Y) +
+ (3.0 * pColor->spec.CIEXYZ.Z);
+ if (div == 0.0) {
+ /* Use white point since div == 0.0 */
+ if (puvY_WhitePt == NULL ) {
+ return(XcmsFailure);
+ }
+ /*
+ * Make sure white point is in CIEuvY form
+ */
+ if (puvY_WhitePt->format != XcmsCIEuvYFormat) {
+ /* Make copy of the white point because we're going to modify it */
+ memcpy((char *)&whitePt, (char *)puvY_WhitePt, sizeof(XcmsColor));
+ if (!_XcmsDIConvertColors(ccc, &whitePt, (XcmsColor *)NULL, 1,
+ XcmsCIEuvYFormat)) {
+ return(XcmsFailure);
+ }
+ puvY_WhitePt = &whitePt;
+ }
+ /* Make sure it is a white point, i.e., Y == 1.0 */
+ if (puvY_WhitePt->spec.CIEuvY.Y != 1.0) {
+ return(XcmsFailure);
+ }
+ uvY_return.Y = pColor->spec.CIEXYZ.Y;
+ uvY_return.u_prime = puvY_WhitePt->spec.CIEuvY.u_prime;
+ uvY_return.v_prime = puvY_WhitePt->spec.CIEuvY.v_prime;
+ } else {
+ uvY_return.u_prime = 4.0 * pColor->spec.CIEXYZ.X / div;
+ uvY_return.v_prime = 9.0 * pColor->spec.CIEXYZ.Y / div;
+ uvY_return.Y = pColor->spec.CIEXYZ.Y;
+ }
+
+ memcpy((char *)&pColor->spec.CIEuvY, (char *)&uvY_return, sizeof(XcmsCIEuvY));
+ /* Identify that format is now CIEuvY */
+ pColor->format = XcmsCIEuvYFormat;
+ }
+
+ return(XcmsSuccess);
+}
diff --git a/nx-X11/lib/src/xcms/xyY.c b/nx-X11/lib/src/xcms/xyY.c
new file mode 100644
index 000000000..e85b8d249
--- /dev/null
+++ b/nx-X11/lib/src/xcms/xyY.c
@@ -0,0 +1,395 @@
+
+/*
+ * Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc.
+ * All Rights Reserved
+ *
+ * This file is a component of an X Window System-specific implementation
+ * of Xcms based on the TekColor Color Management System. Permission is
+ * hereby granted to use, copy, modify, sell, and otherwise distribute this
+ * software and its documentation for any purpose and without fee, provided
+ * that this copyright, permission, and disclaimer notice is reproduced in
+ * all copies of this software and in supporting documentation. TekColor
+ * is a trademark of Tektronix, Inc.
+ *
+ * Tektronix makes no representation about the suitability of this software
+ * for any purpose. It is provided "as is" and with all faults.
+ *
+ * TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE,
+ * INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE.
+ *
+ * NAME
+ * CIExyY.c
+ *
+ * DESCRIPTION
+ * This file contains routines that support the CIE xyY
+ * color space to include conversions to and from the CIE
+ * XYZ space.
+ *
+ * DOCUMENTATION
+ * "TekColor Color Management System, System Implementor's Manual"
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <stdio.h>
+#include <nx-X11/Xos.h>
+#include "Xlibint.h"
+#include "Xcmsint.h"
+#include "Cv.h"
+
+/*
+ * DEFINES
+ */
+#define EPS 0.00001 /* some extremely small number */
+#ifdef DBL_EPSILON
+# define XMY_DBL_EPSILON DBL_EPSILON
+#else
+# define XMY_DBL_EPSILON 0.00001
+#endif
+
+/*
+ * FORWARD DECLARATIONS
+ */
+
+static int CIExyY_ParseString(register char *spec, XcmsColor *pColor);
+static Status XcmsCIExyY_ValidSpec(XcmsColor *pColor);
+
+
+/*
+ * LOCAL VARIABLES
+ */
+
+ /*
+ * NULL terminated list of functions applied to get from CIExyY to CIEXYZ
+ */
+static XcmsConversionProc Fl_CIExyY_to_CIEXYZ[] = {
+ XcmsCIExyYToCIEXYZ,
+ NULL
+};
+
+ /*
+ * NULL terminated list of functions applied to get from CIEXYZ to CIExyY
+ */
+static XcmsConversionProc Fl_CIEXYZ_to_CIExyY[] = {
+ XcmsCIEXYZToCIExyY,
+ NULL
+};
+
+
+/*
+ * GLOBALS
+ */
+
+ /*
+ * CIE xyY Color Space
+ */
+XcmsColorSpace XcmsCIExyYColorSpace =
+ {
+ _XcmsCIExyY_prefix, /* prefix */
+ XcmsCIExyYFormat, /* id */
+ CIExyY_ParseString, /* parseString */
+ Fl_CIExyY_to_CIEXYZ, /* to_CIEXYZ */
+ Fl_CIEXYZ_to_CIExyY, /* from_CIEXYZ */
+ 1
+ };
+
+
+
+/************************************************************************
+ * *
+ * PRIVATE ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * CIExyY_ParseString
+ *
+ * SYNOPSIS
+ */
+static int
+CIExyY_ParseString(
+ register char *spec,
+ XcmsColor *pColor)
+/*
+ * DESCRIPTION
+ * This routines takes a string and attempts to convert
+ * it into a XcmsColor structure with XcmsCIExyYFormat.
+ * The assumed CIExyY string syntax is:
+ * CIExyY:<x>/<y>/<Y>
+ * Where x, y, and Y are in string input format for floats
+ * consisting of:
+ * a. an optional sign
+ * b. a string of numbers possibly containing a decimal point,
+ * c. an optional exponent field containing an 'E' or 'e'
+ * followed by a possibly signed integer string.
+ *
+ * RETURNS
+ * 0 if failed, non-zero otherwise.
+ */
+{
+ int n;
+ char *pchar;
+
+ if ((pchar = strchr(spec, ':')) == NULL) {
+ return(XcmsFailure);
+ }
+ n = (int)(pchar - spec);
+
+ /*
+ * Check for proper prefix.
+ */
+ if (strncmp(spec, _XcmsCIExyY_prefix, n) != 0) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Attempt to parse the value portion.
+ */
+ if (sscanf(spec + n + 1, "%lf/%lf/%lf",
+ &pColor->spec.CIExyY.x,
+ &pColor->spec.CIExyY.y,
+ &pColor->spec.CIExyY.Y) != 3) {
+ char *s; /* Maybe failed due to locale */
+ int f;
+ if ((s = strdup(spec))) {
+ for (f = 0; s[f]; ++f)
+ if (s[f] == '.')
+ s[f] = ',';
+ else if (s[f] == ',')
+ s[f] = '.';
+ if (sscanf(s + n + 1, "%lf/%lf/%lf",
+ &pColor->spec.CIExyY.x,
+ &pColor->spec.CIExyY.y,
+ &pColor->spec.CIExyY.Y) != 3) {
+ free(s);
+ return(XcmsFailure);
+ }
+ free(s);
+ } else
+ return(XcmsFailure);
+ }
+ pColor->format = XcmsCIExyYFormat;
+ pColor->pixel = 0;
+ return(XcmsCIExyY_ValidSpec(pColor));
+}
+
+
+
+/************************************************************************
+ * *
+ * PUBLIC ROUTINES *
+ * *
+ ************************************************************************/
+
+/*
+ * NAME
+ * CIExyY_ValidSpec()
+ *
+ * SYNOPSIS
+ */
+static Status
+XcmsCIExyY_ValidSpec(
+ XcmsColor *pColor)
+/*
+ * DESCRIPTION
+ * Checks a valid CIExyY color specification.
+ *
+ * RETURNS
+ * XcmsFailure if invalid.
+ * XcmsSuccess if valid.
+ *
+ */
+{
+ if (pColor->format != XcmsCIExyYFormat
+ ||
+ (pColor->spec.CIExyY.x < 0.0 - XMY_DBL_EPSILON)
+ ||
+ (pColor->spec.CIExyY.x > 1.0 + XMY_DBL_EPSILON)
+ ||
+ (pColor->spec.CIExyY.y < 0.0 - XMY_DBL_EPSILON)
+ ||
+ (pColor->spec.CIExyY.y > 1.0 + XMY_DBL_EPSILON)
+ ||
+ (pColor->spec.CIExyY.Y < 0.0 - XMY_DBL_EPSILON)
+ ||
+ (pColor->spec.CIExyY.Y > 1.0 + XMY_DBL_EPSILON)) {
+ return(XcmsFailure);
+ }
+ return(XcmsSuccess);
+}
+
+
+/*
+ * NAME
+ * XcmsCIExyYToCIEXYZ - convert CIExyY to CIEXYZ
+ *
+ * SYNOPSIS
+ */
+Status
+XcmsCIExyYToCIEXYZ(
+ XcmsCCC ccc,
+ XcmsColor *pxyY_WhitePt,
+ XcmsColor *pColors_in_out,
+ unsigned int nColors)
+/*
+ * DESCRIPTION
+ * Converts color specifications in an array of XcmsColor
+ * structures from CIExyY format to CIEXYZ format.
+ *
+ * RETURNS
+ * XcmsFailure if failed,
+ * XcmsSuccess if succeeded.
+ */
+{
+ XcmsColor *pColor = pColors_in_out;
+ XcmsColor whitePt;
+ XcmsCIEXYZ XYZ_return;
+ XcmsFloat div; /* temporary storage in case divisor is zero */
+ XcmsFloat u, v, x, y, z; /* temporary storage */
+ unsigned int i;
+
+ /*
+ * Check arguments
+ */
+ if (pxyY_WhitePt == NULL || pColors_in_out == NULL) {
+ return(XcmsFailure);
+ }
+
+
+ /*
+ * Now convert each XcmsColor structure to CIEXYZ form
+ */
+ for (i = 0; i < nColors; i++, pColor++) {
+ /* Make sure original format is CIExyY and valid */
+ if (!XcmsCIExyY_ValidSpec(pColor)) {
+ return(XcmsFailure);
+ }
+
+ if ((div = (-2 * pColor->spec.CIExyY.x) + (12 * pColor->spec.CIExyY.y) + 3) == 0.0) {
+ /* Note that the divisor is zero */
+ /* This return is abitrary. */
+ XYZ_return.X = 0;
+ XYZ_return.Y = 0;
+ XYZ_return.Z = 0;
+ } else {
+ /*
+ * Make sure white point is in CIEXYZ form
+ */
+ if (pxyY_WhitePt->format != XcmsCIEXYZFormat) {
+ /* Make copy of the white point because we're going to modify it */
+ memcpy((char *)&whitePt, (char *)pxyY_WhitePt, sizeof(XcmsColor));
+ if (!_XcmsDIConvertColors(ccc, &whitePt, (XcmsColor *)NULL, 1,
+ XcmsCIEXYZFormat)) {
+ return(XcmsFailure);
+ }
+ pxyY_WhitePt = &whitePt;
+ }
+
+ /* Make sure it is a white point, i.e., Y == 1.0 */
+ if (pxyY_WhitePt->spec.CIEXYZ.Y != 1.0) {
+ return(XcmsFailure);
+ }
+
+ /* Convert from xyY to uvY to XYZ */
+ u = (4 * pColor->spec.CIExyY.x) / div;
+ v = (9 * pColor->spec.CIExyY.y) / div;
+ div = (6.0 * u) - (16.0 * v) + 12.0;
+ if (div == 0.0) {
+ /* Note that the divisor is zero */
+ /* This return is abitrary. */
+ if ((div = (6.0 * whitePt.spec.CIEuvY.u_prime) -
+ (16.0 * whitePt.spec.CIEuvY.v_prime) + 12.0) == 0.0) {
+ div = EPS;
+ }
+ x = 9.0 * whitePt.spec.CIEuvY.u_prime / div;
+ y = 4.0 * whitePt.spec.CIEuvY.u_prime / div;
+ } else {
+ /* convert u, v to small xyz */
+ x = 9.0 * u / div;
+ y = 4.0 * v / div;
+ }
+ z = 1.0 - x - y;
+ if (y == 0.0) y = EPS; /* Have to worry about divide by 0 */
+ XYZ_return.Y = pColor->spec.CIExyY.Y;
+ XYZ_return.X = x * XYZ_return.Y / y;
+ XYZ_return.Z = z * XYZ_return.Y / y;
+ }
+
+ /* Copy result to pColor */
+ memcpy ((char *)&pColor->spec, (char *)&XYZ_return, sizeof(XcmsCIEXYZ));
+
+ /* Identify that the format is now CIEXYZ */
+ pColor->format = XcmsCIEXYZFormat;
+ }
+ return(XcmsSuccess);
+}
+
+
+/*
+ * NAME
+ * XcmsCIEXYZToCIExyY - convert CIEXYZ to CIExyY
+ *
+ * SYNOPSIS
+ */
+/* ARGSUSED */
+Status
+XcmsCIEXYZToCIExyY(
+ XcmsCCC ccc,
+ XcmsColor *pxyY_WhitePt,
+ XcmsColor *pColors_in_out,
+ unsigned int nColors)
+/*
+ * DESCRIPTION
+ * Converts color specifications in an array of XcmsColor
+ * structures from CIEXYZ format to CIExyY format.
+ *
+ * RETURNS
+ * XcmsFailure if failed,
+ * XcmsSuccess if succeeded.
+ *
+ */
+{
+ XcmsColor *pColor = pColors_in_out;
+ XcmsCIExyY xyY_return;
+ XcmsFloat div; /* temporary storage in case divisor is zero */
+ unsigned int i;
+
+ /*
+ * Check arguments
+ * pxyY_WhitePt ignored
+ */
+ if (pColors_in_out == NULL) {
+ return(XcmsFailure);
+ }
+
+ /*
+ * Now convert each XcmsColor structure to CIEXYZ form
+ */
+ for (i = 0; i < nColors; i++, pColor++) {
+
+ if (!_XcmsCIEXYZ_ValidSpec(pColor)) {
+ return(XcmsFailure);
+ }
+ /* Now convert for XYZ to xyY */
+ if ((div = pColor->spec.CIEXYZ.X + pColor->spec.CIEXYZ.Y + pColor->spec.CIEXYZ.Z) == 0.0) {
+ div = EPS;
+ }
+ xyY_return.x = pColor->spec.CIEXYZ.X / div;
+ xyY_return.y = pColor->spec.CIEXYZ.Y / div;
+ xyY_return.Y = pColor->spec.CIEXYZ.Y;
+
+ /* Copy result to pColor */
+ memcpy ((char *)&pColor->spec, (char *)&xyY_return, sizeof(XcmsCIExyY));
+
+ /* Identify that the format is now CIEXYZ */
+ pColor->format = XcmsCIExyYFormat;
+ }
+ return(XcmsSuccess);
+}