GradTable32 Class Reference

A kernel representation of a 32 bpp graduation table. (This is a table of COLORREF RGB values for GDraw). More...

#include <gradtbl.h>

Inheritance diagram for GradTable32:

List of all members.

Public Member Functions
	GradTable32 ()
	Default constructor for a GradTable32.
	~GradTable32 ()
	Destructor for a GradTable32.
void	SetTableSize (BOOL LargeTable)
	To set the size of this Grad table.
BOOL	BuildTable (DocColour &StartCol, DocColour &EndCol, View *ContextView, EFFECTTYPE Effect, DWORD TableSize=0x100)
	Builds a GradTable from StartCol to EndCol, filling in the entire table with appropriate GDraw dither patterns.
BOOL	BuildTable (DocColour &StartCol, DocColour &EndCol, View *ContextView, EFFECTTYPE Effect, DWORD FirstEntry, DWORD LastEntry)
	Builds a GradTable from StartCol to EndCol, filling in a portion of the table with appropriate GDraw dither patterns.
Static Public Member Functions
static BOOL	BuildGraduatedPalette (DocColour &StartCol, DocColour &EndCol, View *ContextView, EFFECTTYPE Effect, DWORD TableSize, COLORREF *pTable)
	Builds a Graduated Table, filling in the given table with COLORREF entries. The entries will be colour corrected and/or separated as appropriate to the context view.
static BOOL	BuildGraduatedPalette (DocColour &StartCol, DocColour &EndCol, View *ContextView, EFFECTTYPE Effect, DWORD FirstEntry, DWORD LastEntry, COLORREF *pTable)
	Builds a Graduated Table from StartCol to EndCol, filling in the given table with COLORREF entries. The entries will be colour corrected and/or separated as appropriate to the context view.
static BOOL	BuildGraduatedPalette (DocColour &StartCol, DocColour &EndCol, View *ContextView, EFFECTTYPE Effect, DWORD TableSize, RGBQUAD *pTable)
	Builds a Graduated Table, filling in the given table with RGBQUAD entries. The entries will be colour corrected and/or separated as appropriate to the context view.
static BOOL	BuildGraduatedPalette (DocColour &StartCol, DocColour &EndCol, View *ContextView, EFFECTTYPE Effect, DWORD TableSize, RGBQUAD *pTable, CProfileBiasGain &BiasGain)
	Builds a Graduated Table, filling in the given table with RGBQUAD entries (taking into account the biasgain). The entries will be colour corrected and/or separated as appropriate to the context view.
static BOOL	BuildGraduatedPalette (DocColour &StartCol, DocColour &EndCol, View *ContextView, EFFECTTYPE Effect, DWORD FirstEntry, DWORD LastEntry, RGBQUAD *pTable)
	Builds a Graduated Table from StartCol to EndCol, filling in the given table with RGBQUAD entries. The entries will be colour corrected and/or separated as appropriate to the context view.
Static Protected Member Functions
static BOOL	BuildPaletteInternal (DocColour &StartCol, DocColour &EndCol, View *ContextView, EFFECTTYPE Effect, DWORD FirstEntry, DWORD LastEntry, void *pTable, BOOL IsColorRef, CProfileBiasGain &BiasGain)
	Builds a Graduated Table from StartCol to EndCol, filling in the given table with either COLORREF or RGBQUAD entries. The entries will be colour corrected and/or separated as appropriate to the context view.
static BOOL	BuildPaletteInternalRGB (DocColour &StartCol, DocColour &EndCol, View *ContextView, DWORD FirstEntry, DWORD LastEntry, void *pTable, BOOL IsColorRef, CProfileBiasGain &BiasGain)
	Builds a Graduated (RGB Mix) Table from StartCol to EndCol, filling in the given table with either COLORREF or RGBQUAD entries.
static BOOL	BuildPaletteInternalHSV (DocColour &StartCol, DocColour &EndCol, View *ContextView, EFFECTTYPE Effect, DWORD FirstEntry, DWORD LastEntry, void *pTable, BOOL IsColorRef, CProfileBiasGain &BiasGain)
	Builds a Graduated (HSV rainbow/alt-rainbow) Table from StartCol to EndCol, filling in the given table with either COLORREF or RGBQUAD entries.
static BOOL	BuildPaletteInternalRGBComposite (DocColour &StartCol, DocColour &EndCol, View *ContextView, DWORD FirstEntry, DWORD LastEntry, void *pTable, BOOL IsColorRef)
	Builds a Graduated (RGB Mix) Table from StartCol to EndCol, filling in the given table with either COLORREF or RGBQUAD entries.

---

Detailed Description

A kernel representation of a 32 bpp graduation table. (This is a table of COLORREF RGB values for GDraw).

Author:

Will_Cowling (Xara Group Ltd) <camelotdev@xara.com>

Date:

14/9/94

See also:

GradTable

Notes: There are now 3 base functions in GradTable and GradTable32 which build graduation tables. The tables are actually identical in meaning, but are encoded as: (a) Gavin 8bpp dither patterns, (b) RGBQUAD RGB structures, (c) COLORREF RGB values this is because the different places that use these tables demand the different formats, and converting all the code to use only one table format is non-trivial and/or inefficient.

Definition at line 286 of file gradtbl.h.

---

Constructor & Destructor Documentation

GradTable32::GradTable32 (   )

Default constructor for a GradTable32. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 14/9/94 Returns: Errors: - Definition at line 1597 of file gradtbl.cpp. { }

GradTable32::~GradTable32 (   )

Destructor for a GradTable32. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 16/10/96 Definition at line 1612 of file gradtbl.cpp. { }

---

Member Function Documentation

BOOL GradTable32::BuildGraduatedPalette (  DocColour &  StartCol, DocColour &  EndCol, View *  ContextView, EFFECTTYPE  Effect, DWORD  FirstEntry, DWORD  LastEntry, RGBQUAD *  pTable )  [static]

Builds a Graduated Table from StartCol to EndCol, filling in the given table with RGBQUAD entries. The entries will be colour corrected and/or separated as appropriate to the context view. Parameters: StartCol,EndCol  - Define the end colours of the graduation [INPUTS] ContextView - Points to the view in which the gradation is to be displayed. (This is necessary for correction and separation etc. If proper colour handling is not needed, then you may pass NULL, but generally, this parameter should be sensible) Effect - EFFECT_FADE, EFFECT_HSV_SHORT, or EFFECT_HSV_LONG FirstEntry - The index of the first entry (inclusive) to fill in (0 is the first) LastEntry - The index of the last entry (exclusive) to fill in (TableSize is the last) (i.e. to fill entire table use (0,TableSize) which will fill in entries 0..Tablesize-1) Parameters: pTable  - On return, will be filled in with appropriate colours [OUTPUTS] Returns: FALSE if it fails Errors: Out of memory Definition at line 1950 of file gradtbl.cpp. { CProfileBiasGain DefaultBiasGain; // we need a 'default' profile so we call // standardise the following call .... return(BuildPaletteInternal(StartCol, EndCol, ContextView, Effect, FirstEntry, LastEntry, (void *) pTable, FALSE, DefaultBiasGain)); }

BOOL GradTable32::BuildGraduatedPalette (  DocColour &  StartCol, DocColour &  EndCol, View *  ContextView, EFFECTTYPE  Effect, DWORD  TableSize, RGBQUAD *  pTable, CProfileBiasGain &  BiasGain )  [static]

Builds a Graduated Table, filling in the given table with RGBQUAD entries (taking into account the biasgain). The entries will be colour corrected and/or separated as appropriate to the context view. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> Date: 14/2/2000 Parameters: StartCol,EndCol  - Define the end colours of the graduation [INPUTS] ContextView - Points to the view in which the gradation is to be displayed. (This is necessary for correction and separation etc. If proper colour handling is not needed, then you may pass NULL, but generally, this parameter should be sensible) Effect - EFFECT_FADE, EFFECT_HSV_SHORT, or EFFECT_HSV_LONG TableSize - Number of entries in the table BiasGain - The biasgain profile that is to alter the table Parameters: pTable  - On return, will be filled in with appropriate colours [OUTPUTS] Returns: FALSE if it fails Errors: - Definition at line 1905 of file gradtbl.cpp. { return(BuildPaletteInternal(StartCol, EndCol, ContextView, Effect, 0, TableSize, (void *) pTable, FALSE, BiasGain)); }

BOOL GradTable32::BuildGraduatedPalette (  DocColour &  StartCol, DocColour &  EndCol, View *  ContextView, EFFECTTYPE  Effect, DWORD  TableSize, RGBQUAD *  pTable )  [static]

Builds a Graduated Table, filling in the given table with RGBQUAD entries. The entries will be colour corrected and/or separated as appropriate to the context view. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 14/5/96 Parameters: StartCol,EndCol  - Define the end colours of the graduation [INPUTS] ContextView - Points to the view in which the gradation is to be displayed. (This is necessary for correction and separation etc. If proper colour handling is not needed, then you may pass NULL, but generally, this parameter should be sensible) Effect - EFFECT_FADE, EFFECT_HSV_SHORT, or EFFECT_HSV_LONG TableSize - Number of entries in the table Parameters: pTable  - On return, will be filled in with appropriate colours [OUTPUTS] Returns: FALSE if it fails Errors: - Definition at line 1859 of file gradtbl.cpp. { CProfileBiasGain DefaultBiasGain; // we need a 'default' profile so we call // standardise the following call .... return(BuildPaletteInternal(StartCol, EndCol, ContextView, Effect, 0, TableSize, (void *) pTable, FALSE, DefaultBiasGain)); }

BOOL GradTable32::BuildGraduatedPalette (  DocColour &  StartCol, DocColour &  EndCol, View *  ContextView, EFFECTTYPE  Effect, DWORD  FirstEntry, DWORD  LastEntry, COLORREF *  pTable )  [static]

Builds a Graduated Table from StartCol to EndCol, filling in the given table with COLORREF entries. The entries will be colour corrected and/or separated as appropriate to the context view. Parameters: StartCol,EndCol  - Define the end colours of the graduation [INPUTS] ContextView - Points to the view in which the gradation is to be displayed. (This is necessary for correction and separation etc. If proper colour handling is not needed, then you may pass NULL, but generally, this parameter should be sensible) Effect - EFFECT_FADE, EFFECT_HSV_SHORT, or EFFECT_HSV_LONG FirstEntry - The index of the first entry (inclusive) to fill in (0 is the first) LastEntry - The index of the last entry (exclusive) to fill in (TableSize is the last) (i.e. to fill entire table use (0,TableSize) which will fill in entries 0..Tablesize-1) Parameters: pTable  - On return, will be filled in with appropriate colours [OUTPUTS] Returns: FALSE if it fails Errors: Out of memory Definition at line 1815 of file gradtbl.cpp. { CProfileBiasGain DefaultBiasGain; // we need a 'default' profile so we call // standardise the following call .... return(BuildPaletteInternal(StartCol, EndCol, ContextView, Effect, FirstEntry, LastEntry, (void *) pTable, TRUE, DefaultBiasGain)); }

BOOL GradTable32::BuildGraduatedPalette (  DocColour &  StartCol, DocColour &  EndCol, View *  ContextView, EFFECTTYPE  Effect, DWORD  TableSize, COLORREF *  pTable )  [static]

Builds a Graduated Table, filling in the given table with COLORREF entries. The entries will be colour corrected and/or separated as appropriate to the context view. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 14/5/96 Parameters: StartCol,EndCol  - Define the end colours of the graduation [INPUTS] ContextView - Points to the view in which the gradation is to be displayed. (This is necessary for correction and separation etc. If proper colour handling is not needed, then you may pass NULL, but generally, this parameter should be sensible) Effect - EFFECT_FADE, EFFECT_HSV_SHORT, or EFFECT_HSV_LONG TableSize - Number of entries in the table Parameters: pTable  - On return, will be filled in with appropriate colours [OUTPUTS] Returns: FALSE if it fails Errors: - Definition at line 1769 of file gradtbl.cpp. { CProfileBiasGain DefaultBiasGain; // we need a 'default' profile so we call // standardise the following call .... return(BuildPaletteInternal(StartCol, EndCol, ContextView, Effect, 0, TableSize, (void *) pTable, TRUE, DefaultBiasGain)); }

BOOL GradTable32::BuildPaletteInternal (  DocColour &  StartCol, DocColour &  EndCol, View *  ContextView, EFFECTTYPE  Effect, DWORD  FirstEntry, DWORD  LastEntry, void *  pTable, BOOL  IsColorRef, CProfileBiasGain &  BiasGain )  [static, protected]

Builds a Graduated Table from StartCol to EndCol, filling in the given table with either COLORREF or RGBQUAD entries. The entries will be colour corrected and/or separated as appropriate to the context view. Parameters: StartCol,EndCol  - Define the end colours of the graduation [INPUTS] ContextView - Points to the view in which the gradation is to be displayed. (This is necessary for correction and separation etc. If proper colour handling is not needed, then you may pass NULL, but generally, this parameter should be sensible) Effect - EFFECT_FADE, EFFECT_HSV_SHORT, or EFFECT_HSV_LONG FirstEntry - The index of the first entry (inclusive) to fill in (0 is the first) LastEntry - The index of the last entry (exclusive) to fill in (TableSize is the last) (i.e. to fill entire table use (0,TableSize) which will fill in entries 0..Tablesize-1) IsColorRef - TRUE if the pTable pointer is a (COLORREF *) FALSE if the pTable pointer is an (RGBQUAD *) Parameters: pTable  - On return, will be filled in with appropriate colours, in the format [OUTPUTS] indicated by the IsColorRef flag. Returns: FALSE if it fails This is an internal shared function used by all the other GradTable32 grad palette building methods Notes: This routine supplies a simple, generic mixing loop. However, for normal (no colour plate) rendering, this function will call the other internal methods which are optimised for specific cases - this gives about a 3x performance enhancement for normal rendering. Returns: Errors: Out of memory Definition at line 2010 of file gradtbl.cpp. { ERROR3IF(pTable == NULL, "Illegal NULL param"); // The range should be withion the table size. We only ERROR3, though, because // the physical table is always large enough for the maximum number of entries. ERROR3IF(FirstEntry < 0 || FirstEntry > LastEntry, "GradTable32::BuildPaletteInternal expects sensible First/Last Entry values"); // Determine if either the start or end colour is a spot colour - if it is, we must // coerce the fill into a "mix" (rgb) rather than rainbow fill style if (Effect != EFFECT_RGB && (StartCol.GetSpotParent() != NULL || EndCol.GetSpotParent() != NULL)) Effect = EFFECT_RGB; // --- Optimisation - are we trying to build a simple grad table under normal rendering // circumstances? If so, special case this to make it as fast as possible. This more than // doubles the speed of table generation. ColourContext *ccRGB = ColourManager::GetColourContext(COLOURMODEL_RGBT, ContextView); ERROR3IF(ccRGB == NULL, "GradTable32::BuildPaletteInternal - Can't find my colour context!"); if (ccRGB->GetColourPlate() == NULL || ccRGB->GetColourPlate()->IsDisabled()) { if (Effect == EFFECT_RGB) // RGB mix? { return(BuildPaletteInternalRGB(StartCol, EndCol, ContextView, FirstEntry, LastEntry, pTable, IsColorRef, BiasGain)); } // HSV (rainbow) mix return(BuildPaletteInternalHSV(StartCol, EndCol, ContextView, Effect, FirstEntry, LastEntry, pTable, IsColorRef, BiasGain)); } if (Effect == EFFECT_RGB && ccRGB->GetColourPlate()->GetType() == COLOURPLATE_COMPOSITE && (StartCol.GetColourModel() != COLOURMODEL_CMYK || EndCol.GetColourModel() != COLOURMODEL_CMYK)) { return(BuildPaletteInternalRGBComposite(StartCol, EndCol, ContextView, FirstEntry, LastEntry, pTable, IsColorRef)); } // --- OK, we're trying to do something special. Drop back to the generic (slow) code RGBQUAD *pRGBTable = (RGBQUAD *) pTable; // Cast the table pointer to the two COLORREF *pRefTable = (COLORREF *) pTable; // possible types // Get colour contexts: we need 2 - first, an RGB context (got above) for the ContextView, which // will be used to get colour-corrected/separated/etc output colour in RGB; and second, // a generic RGB or HSV context to provide a "mixing colourspace" for the graduations. ColourContext *cc = NULL; if (Effect == EFFECT_RGB) cc = ColourManager::GetColourContext(COLOURMODEL_RGBT); // RGB fade else cc = ColourManager::GetColourContext(COLOURMODEL_HSVT); // HSV fade // If we can't find RGB/HSV contexts, something is seriously broken ERROR3IF(cc == NULL, "GradTable32::BuildPaletteInternal - Can't find my colour context!"); // Fill in the Start and End colours of the table, if we've hit them PColourRGBT Result; // And build our graduated palette double MixFraction = 0.0; double MixStep = 1.0 / (double) (LastEntry - FirstEntry - 1); DocColour temp; for (DWORD col = FirstEntry; col < LastEntry; col++) { // Create a new colour which is an appropriate mixture of the start/end colours temp.Mix(&StartCol, &EndCol, MixFraction, cc, (Effect == EFFECT_HSV_LONG), ccRGB); // Convert back to the raw RGB and place it in the palette. // Note that this will colour correct and separate in an appropriate manner. // Note also that we're using a special ConvertColour call which returns 8-bit // "packed" component values instead of FIXED24's. ccRGB->ConvertColour(&temp, (ColourPacked *) &Result); // And add to the table if (IsColorRef) { pRefTable[col] = RGB(Result.Red, Result.Green, Result.Blue); } else { pRGBTable[col].rgbRed = Result.Red; pRGBTable[col].rgbGreen = Result.Green; pRGBTable[col].rgbBlue = Result.Blue; pRGBTable[col].rgbReserved = 0; } // And step to the next mix fraction value MixFraction += MixStep; } return(TRUE); }

BOOL GradTable32::BuildPaletteInternalHSV (  DocColour &  StartCol, DocColour &  EndCol, View *  ContextView, EFFECTTYPE  Effect, DWORD  FirstEntry, DWORD  LastEntry, void *  pTable, BOOL  IsColorRef, CProfileBiasGain &  BiasGain )  [static, protected]

Builds a Graduated (HSV rainbow/alt-rainbow) Table from StartCol to EndCol, filling in the given table with either COLORREF or RGBQUAD entries. Parameters: StartCol,EndCol  - Define the end colours of the graduation [INPUTS] ContextView - Points to the view in which the gradation is to be displayed. (This is necessary for correction and separation etc. If proper colour handling is not needed, then you may pass NULL, but generally, this parameter should be sensible) Effect - EFFECT_HSV_SHORT or EFFECT_HSV_LONG FirstEntry - The index of the first entry (inclusive) to fill in (0 is the first) LastEntry - The index of the last entry (exclusive) to fill in (TableSize is the last) (i.e. to fill entire table use (0,TableSize) which will fill in entries 0..Tablesize-1) IsColorRef - TRUE if the pTable pointer is a (COLORREF *) FALSE if the pTable pointer is an (RGBQUAD *) BiasGain - The profile that controls how the table is built Parameters: pTable  - On return, will be filled in with appropriate colours, in the format [OUTPUTS] indicated by the IsColorRef flag. Returns: FALSE if it fails NOTE that the generated entries will NOT be colour corrected or separated in any way. You should not use this code when generating colour plates. Definition at line 2306 of file gradtbl.cpp. { ERROR3IF(ContextView == NULL || pTable == NULL, "Illegal NULL params"); ERROR3IF(Effect != EFFECT_HSV_SHORT && Effect != EFFECT_HSV_LONG, "Unsupported HSV effect"); ColourContext *ccHSV = ColourManager::GetColourContext(COLOURMODEL_HSVT, ContextView); ERROR3IF(ccHSV == NULL, "No colour context"); PColourHSVT StartDef; PColourHSVT EndDef; if (StartCol.IsTransparent()) { StartDef.Hue = 0; // If transparent, use white StartDef.Value = 255; StartDef.Saturation = 0; } else ccHSV->ConvertColour(&StartCol, (ColourPacked *) &StartDef); if (EndCol.IsTransparent()) { EndDef.Hue = 0; // If transparent, use white EndDef.Value = 255; EndDef.Saturation = 0; } else ccHSV->ConvertColour(&EndCol, (ColourPacked *) &EndDef); // When doing alt-rainbow, if one end colour has no specific hue (saturation near 0) // then use the other colour's hue (if any) // // TODO: WRONG!!! This should always be doing these two tests, not just when // the Effect equals EFFECT_HSV_LONG. Note also that the INT32 HSV colour // generation is incorrect, although I'm not too sure why. (Gavin). // if (Effect == EFFECT_HSV_LONG) { if (StartDef.Saturation < 2 && EndDef.Saturation >= 2) StartDef.Hue = EndDef.Hue; else if (StartDef.Saturation >= 2 && EndDef.Saturation < 2) EndDef.Hue = StartDef.Hue; } // Now work out which way we have to do the mix (rainbow or alt-rainbow) BOOL BlendNormally = TRUE; // Calc. the "simple" (non-wrapping) distance between the hues double StartHue = StartDef.Hue / 360.0; double EndHue = EndDef.Hue / 360.0; const double SimpleDist = fabs(StartHue - EndHue); // Determine whether we do a simple blend, or we have to "wrap" if (SimpleDist <= 0.5) BlendNormally = (Effect != EFFECT_HSV_LONG); else BlendNormally = (Effect == EFFECT_HSV_LONG); // If we have to go the long way, then move the smaller of the two hue // values up by 360 degrees (1.0) - after blending we'll 'mod' the result // back down into gamut. if (!BlendNormally) { if (StartHue > EndHue) EndHue += 1.0; else StartHue += 1.0; } // Precalculate mixing fraction and step to minimise mul/div in the inner loop // We use an 8.24 bit fixed point notation (homebrew FIXED24s) double MixStep = 1.0 / (double)(LastEntry - FirstEntry); double MixFraction = 0.0; if (IsColorRef) { COLORREF *pRefTable = (COLORREF *) pTable; double H, S, V; for (DWORD col = FirstEntry; col < LastEntry; col++) { const double InvFraction = 1.0 - MixFraction; // Calculate intermediate RGB values into 8bpp values H = (StartHue * InvFraction) + (EndHue * MixFraction); // 0.0 - 1.0 if (H > 1.0) H -= 1.0; // If necessary, "mod" the value back down into the 0..1 range S = ((StartDef.Saturation * InvFraction) + (EndDef.Saturation * MixFraction)) / 255.0; // 0.0 - 1.0 V = (StartDef.Value * InvFraction) + (EndDef.Value * MixFraction); // 0.0 - 255.0 // Convert the HSV value to an RGB table entry if (S == 0) { BYTE Val = (BYTE) V; pRefTable[col] = RGB(Val, Val, Val); } else { H *= 6.0; const INT32 I = (INT32) floor(H); const double F = H - I; const double P = V * (1.0 - S); const double Q = V * (1.0 - (S * F)); const double T = V * (1.0 - (S * (1.0 - F))); switch (I) { case 1: pRefTable[col] = RGB(BYTE(Q), BYTE(V), BYTE(P)); break; case 2: pRefTable[col] = RGB(BYTE(P), BYTE(V), BYTE(T)); break; case 3: pRefTable[col] = RGB(BYTE(P), BYTE(Q), BYTE(V)); break; case 4: pRefTable[col] = RGB(BYTE(T), BYTE(P), BYTE(V)); break; case 5: pRefTable[col] = RGB(BYTE(V), BYTE(P), BYTE(Q)); break; default: pRefTable[col] = RGB(BYTE(V), BYTE(T), BYTE(P)); break; } } MixFraction += MixStep; } } else { CProfileBiasGain DefaultBiasGain; // default if (BiasGain == DefaultBiasGain) { RGBQUAD *pRGBTable = (RGBQUAD *) pTable; double H, S, V; for (DWORD col = FirstEntry; col < LastEntry; col++) { const double InvFraction = 1.0 - MixFraction; // Calculate intermediate RGB values into 8bpp values H = (StartHue * InvFraction) + (EndHue * MixFraction); // 0.0 - 1.0 if (H > 1.0) H -= 1.0; // If necessary, "mod" the value back down into the 0..1 range S = ((StartDef.Saturation * InvFraction) + (EndDef.Saturation * MixFraction)) / 255.0; // 0.0 - 1.0 V = (StartDef.Value * InvFraction) + (EndDef.Value * MixFraction); // 0.0 - 255.0 // Convert the HSV value to an RGB table entry if (S == 0) { pRGBTable[col].rgbRed = pRGBTable[col].rgbGreen = pRGBTable[col].rgbBlue = (BYTE) V; } else { H *= 6.0; const INT32 I = (INT32) floor(H); const double F = H - I; const double P = V * (1.0 - S); const double Q = V * (1.0 - (S * F)); const double T = V * (1.0 - (S * (1.0 - F))); // Define a wee macro to make this all a lot more readable #if 0 #define SETRGBENTRY(P1,P2,P3) pRGBTable[col].rgbRed = (BYTE)P3; pRGBTable[col].rgbGreen = (BYTE)P2; pRGBTable[col].rgbBlue = (BYTE)P1; #else #define SETRGBENTRY(P1,P2,P3) pRGBTable[col].rgbRed = (BYTE)P1; pRGBTable[col].rgbGreen = (BYTE)P2; pRGBTable[col].rgbBlue = (BYTE)P3; #endif switch (I) { case 1: SETRGBENTRY(Q, V, P); break; case 2: SETRGBENTRY(P, V, T); break; case 3: SETRGBENTRY(P, Q, V); break; case 4: SETRGBENTRY(T, P, V); break; case 5: SETRGBENTRY(V, P, Q); break; default: SETRGBENTRY(V, T, P); break; } #undef SETRGBENTRY } pRGBTable[col].rgbReserved = 0; MixFraction += MixStep; } } else { BiasGain.SetIntervals (AFp (0), AFp (LastEntry)); RGBQUAD *pRGBTable = (RGBQUAD *) pTable; double MixFraction; double InvFraction; double RLastEntry = 1.0/LastEntry; double H, S, V; for (DWORD col = FirstEntry; col < LastEntry; col++) { //const double InvFraction = 1.0 - MixFraction; MixFraction = (INT32) BiasGain.MapInterval( AFp( col ) ); MixFraction *= RLastEntry; InvFraction = 1 - MixFraction; // Calculate intermediate RGB values into 8bpp values H = (StartHue * InvFraction) + (EndHue * MixFraction); // 0.0 - 1.0 if (H > 1.0) H -= 1.0; // If necessary, "mod" the value back down into the 0..1 range S = ((StartDef.Saturation * InvFraction) + (EndDef.Saturation * MixFraction)) / 255.0; // 0.0 - 1.0 V = (StartDef.Value * InvFraction) + (EndDef.Value * MixFraction); // 0.0 - 255.0 // Convert the HSV value to an RGB table entry if (S == 0) { pRGBTable[col].rgbRed = pRGBTable[col].rgbGreen = pRGBTable[col].rgbBlue = (BYTE) V; } else { H *= 6.0; const INT32 I = (INT32) floor(H); const double F = H - I; const double P = V * (1.0 - S); const double Q = V * (1.0 - (S * F)); const double T = V * (1.0 - (S * (1.0 - F))); // Define a wee macro to make this all a lot more readable #define SETRGBENTRY(P1,P2,P3) pRGBTable[col].rgbRed = (BYTE)P1; pRGBTable[col].rgbGreen = (BYTE)P2; pRGBTable[col].rgbBlue = (BYTE)P3; switch (I) { case 1: SETRGBENTRY(Q, V, P); break; case 2: SETRGBENTRY(P, V, T); break; case 3: SETRGBENTRY(P, Q, V); break; case 4: SETRGBENTRY(T, P, V); break; case 5: SETRGBENTRY(V, P, Q); break; default: SETRGBENTRY(V, T, P); break; } #undef SETRGBENTRY } pRGBTable[col].rgbReserved = 0; MixFraction += MixStep; } } } return(TRUE); }

BOOL GradTable32::BuildPaletteInternalRGB (  DocColour &  StartCol, DocColour &  EndCol, View *  ContextView, DWORD  FirstEntry, DWORD  LastEntry, void *  pTable, BOOL  IsColorRef, CProfileBiasGain &  BiasGain )  [static, protected]

Builds a Graduated (RGB Mix) Table from StartCol to EndCol, filling in the given table with either COLORREF or RGBQUAD entries. Parameters: StartCol,EndCol  - Define the end colours of the graduation [INPUTS] ContextView - Points to the view in which the gradation is to be displayed. (This is necessary for correction and separation etc. If proper colour handling is not needed, then you may pass NULL, but generally, this parameter should be sensible) FirstEntry - The index of the first entry (inclusive) to fill in (0 is the first) LastEntry - The index of the last entry (exclusive) to fill in (TableSize is the last) (i.e. to fill entire table use (0,TableSize) which will fill in entries 0..Tablesize-1) IsColorRef - TRUE if the pTable pointer is a (COLORREF *) FALSE if the pTable pointer is an (RGBQUAD *) BiasGain - The profile that controls how the table is built Parameters: pTable  - On return, will be filled in with appropriate colours, in the format [OUTPUTS] indicated by the IsColorRef flag. Returns: FALSE if it fails NOTE that the generated entries will NOT be colour corrected or separated in any way. You should not use this code when generating colour plates. Definition at line 2154 of file gradtbl.cpp. { ERROR3IF(ContextView == NULL || pTable == NULL, "Illegal NULL params"); ColourContext *ccRGB = ColourManager::GetColourContext(COLOURMODEL_RGBT, ContextView); ERROR3IF(ccRGB == NULL, "No colour context"); PColourRGBT StartDef; PColourRGBT EndDef; if (StartCol.IsTransparent()) StartDef.Red = StartDef.Green = StartDef.Blue = 255L; // If transparent, use white else ccRGB->ConvertColour(&StartCol, (ColourPacked *) &StartDef); if (EndCol.IsTransparent()) EndDef.Red = EndDef.Green = EndDef.Blue = 255L; // If transparent, use white else ccRGB->ConvertColour(&EndCol, (ColourPacked *) &EndDef); // Precalculate mixing fraction and step to minimise mul/div in the inner loop // We use an 8.24 bit fixed point notation (homebrew FIXED24s) DWORD MixStep = (1 << 24) / (LastEntry - FirstEntry); DWORD MixFraction = 0; if (IsColorRef) { COLORREF *pRefTable = (COLORREF *) pTable; DWORD R,G,B; for (DWORD col = FirstEntry; col < LastEntry; col++) { const DWORD InvFraction = 0x01000000 - MixFraction; // Calculate intermediate RGB values into 8bpp values R = ((StartDef.Red * InvFraction) + (EndDef.Red * MixFraction)) >> 24; G = ((StartDef.Green * InvFraction) + (EndDef.Green * MixFraction)) >> 24; B = ((StartDef.Blue * InvFraction) + (EndDef.Blue * MixFraction)) >> 24; // Fill in this table entry pRefTable[col] = RGB(R, G, B); MixFraction += MixStep; } } else { CProfileBiasGain DefaultBiasGain; // default if (BiasGain == DefaultBiasGain) { RGBQUAD *pRGBTable = (RGBQUAD *) pTable; DWORD InvFraction; for (DWORD col = FirstEntry; col < LastEntry; col++) { InvFraction = 0x01000000 - MixFraction; // Calculate intermediate RGB values into the 8bpp table values #if defined(__WXMSW__) pRGBTable[col].rgbRed = static_cast<BYTE> (((StartDef.Red * InvFraction) + (EndDef.Red * MixFraction)) >> 24); pRGBTable[col].rgbGreen = static_cast<BYTE> (((StartDef.Green * InvFraction) + (EndDef.Green * MixFraction)) >> 24); pRGBTable[col].rgbBlue = static_cast<BYTE> (((StartDef.Blue * InvFraction) + (EndDef.Blue * MixFraction)) >> 24); #else pRGBTable[col].rgbBlue = static_cast<BYTE> (((StartDef.Red * InvFraction) + (EndDef.Red * MixFraction)) >> 24); pRGBTable[col].rgbGreen = static_cast<BYTE> (((StartDef.Green * InvFraction) + (EndDef.Green * MixFraction)) >> 24); pRGBTable[col].rgbRed = static_cast<BYTE> (((StartDef.Blue * InvFraction) + (EndDef.Blue * MixFraction)) >> 24); #endif pRGBTable[col].rgbReserved = 0; MixFraction += MixStep; } } else { BiasGain.SetIntervals (AFp (0), AFp (LastEntry)); RGBQUAD *pRGBTable = (RGBQUAD *) pTable; double MixFraction; double InvFraction; double RLastEntry = 1.0/LastEntry; for (DWORD col = FirstEntry; col < LastEntry; col++) { MixFraction = (INT32) BiasGain.MapInterval( AFp( col ) ); MixFraction *= RLastEntry; InvFraction = 1 - MixFraction; // Calculate intermediate RGB values into the 8bpp table values #if defined(__WXMSW__) pRGBTable[col].rgbRed = static_cast<BYTE> (((StartDef.Red * InvFraction) + (EndDef.Red * MixFraction))); pRGBTable[col].rgbGreen = static_cast<BYTE> (((StartDef.Green * InvFraction) + (EndDef.Green * MixFraction))); pRGBTable[col].rgbBlue = static_cast<BYTE> (((StartDef.Blue * InvFraction) + (EndDef.Blue * MixFraction))); #else pRGBTable[col].rgbBlue = static_cast<BYTE> (((StartDef.Red * InvFraction) + (EndDef.Red * MixFraction))); pRGBTable[col].rgbGreen = static_cast<BYTE> (((StartDef.Green * InvFraction) + (EndDef.Green * MixFraction))); pRGBTable[col].rgbRed = static_cast<BYTE> (((StartDef.Blue * InvFraction) + (EndDef.Blue * MixFraction))); #endif pRGBTable[col].rgbReserved = 0; } } } return(TRUE); }

BOOL GradTable32::BuildPaletteInternalRGBComposite (  DocColour &  StartCol, DocColour &  EndCol, View *  ContextView, DWORD  FirstEntry, DWORD  LastEntry, void *  pTable, BOOL  IsColorRef )  [static, protected]

Builds a Graduated (RGB Mix) Table from StartCol to EndCol, filling in the given table with either COLORREF or RGBQUAD entries. Parameters: StartCol,EndCol  - Define the end colours of the graduation [INPUTS] ContextView - Points to the view in which the gradation is to be displayed. (This is necessary for correction and separation etc. If proper colour handling is not needed, then you may pass NULL, but generally, this parameter should be sensible) FirstEntry - The index of the first entry (inclusive) to fill in (0 is the first) LastEntry - The index of the last entry (exclusive) to fill in (TableSize is the last) (i.e. to fill entire table use (0,TableSize) which will fill in entries 0..Tablesize-1) IsColorRef - TRUE if the pTable pointer is a (COLORREF *) FALSE if the pTable pointer is an (RGBQUAD *) Parameters: pTable  - On return, will be filled in with appropriate colours, in the format [OUTPUTS] indicated by the IsColorRef flag. Returns: FALSE if it fails The table is constructed taking into account "Composite Print Preview" colour correction. You must only call this when generating a COLOURPLATE_COPMPOSITE colour plate, when doing RGB mixes of non-CMYK colours! Notes: (Analogue of GradTable code in BuildTable() and Filltable()) For composite preview, I've only bothered to optimise the RGB mix case, as this is by far and away the most common one. See also: GradTable32::BuildPaletteInternal Definition at line 2598 of file gradtbl.cpp. { ERROR3IF(ContextView == NULL || pTable == NULL, "Illegal NULL params"); ColourContext *ccRGB = ColourManager::GetColourContext(COLOURMODEL_RGBT, ContextView); ColourContext *cc = ColourManager::GetColourContext(COLOURMODEL_RGBT); // RGB fade ERROR3IF(cc == NULL || ccRGB == NULL, "No colour context"); ERROR3IF(ccRGB->GetColourPlate() == NULL || ccRGB->GetColourPlate()->IsDisabled() || ccRGB->GetColourPlate()->GetType() != COLOURPLATE_COMPOSITE, "BuildPaletteInternalRGBComposite called under incorrect conditions"); ERROR3IF(StartCol.GetColourModel() == COLOURMODEL_CMYK && EndCol.GetColourModel() == COLOURMODEL_CMYK, "BuildPaletteInternalRGBComposite called for CMYK -> CMYK fill!"); COLORREF *pRefTable = (COLORREF *) pTable; RGBQUAD *pRGBTable = (RGBQUAD *) pTable; PColourRGBT StartDef; PColourRGBT EndDef; ccRGB->ConvertColour(&StartCol, (ColourPacked *) &EndDef); DWORD StartIndex = FirstEntry; DWORD EndIndex; DocColour TempCol; while (StartIndex < LastEntry) { // Move the last run's end colour into Start memcpy(&StartDef, &EndDef, sizeof(PColourRGBT)); // Calculate the end of this run EndIndex = StartIndex + FillStep; if (EndIndex > LastEntry) EndIndex = LastEntry; // Calculate the colour at the end of this run, and convert into EndDef TempCol.Mix(&StartCol, &EndCol, ((double)(EndIndex - FirstEntry)) / ((double)(LastEntry - FirstEntry)), cc, FALSE, ccRGB); ccRGB->ConvertColour(&TempCol, (ColourPacked *) &EndDef); // Linearly interpolate all colours in the run (cf GradTable::FillTable code) // BLOCK { #define MFX 24 // optimised code by Mike INT32 MixFracR = ((INT32)StartDef.Red) <<MFX; INT32 MixFracG = ((INT32)StartDef.Green)<<MFX; INT32 MixFracB = ((INT32)StartDef.Blue) <<MFX; INT32 MixStepR = ((INT32)(EndDef.Red - StartDef.Red ))<<MFX; INT32 MixStepG = ((INT32)(EndDef.Green - StartDef.Green))<<MFX; INT32 MixStepB = ((INT32)(EndDef.Blue - StartDef.Blue ))<<MFX; MixStepR = MixStepR / ((INT32)(EndIndex-StartIndex)); MixStepG = MixStepG / ((INT32)(EndIndex-StartIndex)); MixStepB = MixStepB / ((INT32)(EndIndex-StartIndex)); if (IsColorRef) { for (DWORD Index=StartIndex; Index<EndIndex; Index++) { // Calculate intermediate RGB values into 8bpp values pRefTable[Index] = RGB(MixFracR>>MFX, MixFracG>>MFX, MixFracB>>MFX); MixFracR += MixStepR; MixFracG += MixStepG; MixFracB += MixStepB; } } else { for (DWORD Index=StartIndex; Index<EndIndex; Index++) { // Calculate intermediate RGB values into 8bpp values pRGBTable[Index].rgbRed = (BYTE)(MixFracR>>MFX); pRGBTable[Index].rgbGreen = (BYTE)(MixFracG>>MFX); pRGBTable[Index].rgbBlue = (BYTE)(MixFracB>>MFX); pRGBTable[Index].rgbReserved = 0; MixFracR += MixStepR; MixFracG += MixStepG; MixFracB += MixStepB; } } #undef MFX /* // Place the StartDef in as the first entry if (IsColorRef) pRefTable[StartIndex] = RGB(StartDef.Red, StartDef.Green, StartDef.Blue); else { pRGBTable[StartIndex].rgbRed = StartDef.Red; pRGBTable[StartIndex].rgbGreen = StartDef.Green; pRGBTable[StartIndex].rgbBlue = StartDef.Blue; pRGBTable[StartIndex].rgbReserved = 0; } // ...and start interpolating from the second entry DWORD MixStep = (1 << 24) / (EndIndex - StartIndex); DWORD MixFraction = MixStep; DWORD R,G,B; if (IsColorRef) { for (DWORD Index = StartIndex + 1; Index < EndIndex; Index++) { // Calculate intermediate RGB values into 8bpp values const DWORD InvFraction = (0x01000000 - MixFraction); R = ((StartDef.Red * InvFraction) + (EndDef.Red * MixFraction)) >> 24; G = ((StartDef.Green * InvFraction) + (EndDef.Green * MixFraction)) >> 24; B = ((StartDef.Blue * InvFraction) + (EndDef.Blue * MixFraction)) >> 24; pRefTable[Index] = RGB(R, G, B); MixFraction += MixStep; } } else { for (DWORD Index = StartIndex + 1; Index < EndIndex; Index++) { // Calculate intermediate RGB values into 8bpp values const DWORD InvFraction = (0x01000000 - MixFraction); R = ((StartDef.Red * InvFraction) + (EndDef.Red * MixFraction)) >> 24; G = ((StartDef.Green * InvFraction) + (EndDef.Green * MixFraction)) >> 24; B = ((StartDef.Blue * InvFraction) + (EndDef.Blue * MixFraction)) >> 24; // Fill in this table entry pRGBTable[Index].rgbRed = (BYTE)R; pRGBTable[Index].rgbGreen = (BYTE)G; pRGBTable[Index].rgbBlue = (BYTE)B; pRGBTable[Index].rgbReserved = 0; MixFraction += MixStep; } } */ } // And step on to the next run StartIndex = EndIndex; } return(TRUE); }

BOOL GradTable32::BuildTable (  DocColour &  StartCol, DocColour &  EndCol, View *  ContextView, EFFECTTYPE  Effect, DWORD  FirstEntry, DWORD  LastEntry )

Builds a GradTable from StartCol to EndCol, filling in a portion of the table with appropriate GDraw dither patterns. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> (Will) Date: 14/5/96 (14/9/94) Parameters: StartCol,EndCol  - Define the end colours of the graduation [INPUTS] ContextView - Points to the view in which the gradation is to be displayed. (This is necessary for correction and separation etc. If proper colour handling is not needed, then you may pass NULL, but generally, this parameter should be sensible) Effect - EFFECT_FADE, EFFECT_HSV_SHORT, or EFFECT_HSV_LONG FirstEntry - The index of the first entry (inclusive) to fill in (0 is the first) LastEntry - The index of the last entry (exclusive) to fill in (TableSize is the last) (i.e. to fill entire table use (0,TableSize) which will fill in entries 0..Tablesize-1) Returns: FALSE if it fails Notes: GDraw requires the Start and End colours for the entire table to be set separately in the table structure. These will be set if FirstEntry==0 and/or if LastEntry==TableSize, respectively. See also: GradTable::SetTableSize Definition at line 1722 of file gradtbl.cpp. { ERROR3("GradTable32::BuildTable() is rampant so don't use it\n"); return(FALSE); /* return(BuildPaletteInternal(StartCol, EndCol, ContextView, Effect, FirstEntry, LastEntry, (void *)Table.Table, TRUE)); */ }

BOOL GradTable32::BuildTable (  DocColour &  StartCol, DocColour &  EndCol, View *  ContextView, EFFECTTYPE  Effect, DWORD  TableSize = 0x100 )

Builds a GradTable from StartCol to EndCol, filling in the entire table with appropriate GDraw dither patterns. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> (Will) Date: 14/5/96 (14/9/94) Parameters: StartCol,EndCol  - Define the end colours of the graduation [INPUTS] ContextView - Points to the view in which the gradation is to be displayed. (This is necessary for correction and separation etc. If proper colour handling is not needed, then you may pass NULL, but generally, this parameter should be sensible) Effect - EFFECT_FADE, EFFECT_HSV_SHORT, or EFFECT_HSV_LONG TableSize - The number of entries you wish to make the table (0x100 or 0x800) Returns: FALSE if it fails == NOTE that this version of the call also implicitly sets the table size! == See also: GradTable::SetTableSize Definition at line 1669 of file gradtbl.cpp. { ERROR3("GradTable32::BuildTable() is rampant so don't use it\n"); return(FALSE); /* SetTableSize(TableSize); return(BuildPaletteInternal(StartCol, EndCol, ContextView, Effect, 0, Table.Length, (void *)Table.Table, TRUE)); */ }

void GradTable32::SetTableSize (  BOOL  LargeTable  )

To set the size of this Grad table. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 14/5/96 Parameters: NewSize  - The new size (number of entries) in this table. [INPUTS] May only be 0x100 or 0x800 Notes: The default table size is 0x100 entries Definition at line 1632 of file gradtbl.cpp. { }

---

The documentation for this class was generated from the following files:

• Kernel/gradtbl.h (r1785/r1282)
• Kernel/gradtbl.cpp (r1785/r1372)

---