GradTable Class Reference

A kernel representation of a graduation table. (This is a table of 8-bpp dither pattern specifiers for GDraw). More...

#include <gradtbl.h>

Inheritance diagram for GradTable:

List of all members.

Public Member Functions
	GradTable (BOOL LargeTable=FALSE)
	Default constructor for a GradTable.
	~GradTable ()
	Destructor for a GradTable.
void	SetTableSize (BOOL LargeTable)
	To set the size of this Grad table.
INT32	GetTableLength (void)
BOOL	BuildTable (DocColour &StartCol, DocColour &EndCol, View *ContextView, EFFECTTYPE Effect, BOOL LargeTable=FALSE)
	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, CProfileBiasGain &BiasGain, BOOL LargeTable=FALSE)
	Generates a graduated fill table that is modified by biasgain values.
BOOL	BuildTable (DocColour &StartCol, DocColour &EndCol, ColourRamp *pColourRamp, View *ContextView, EFFECTTYPE Effect, BOOL LargeTable=FALSE)
	Writes a colour ramp fill record to the filter.
BOOL	BuildHighQualityRepeatTable (DocColour &StartCol, DocColour &EndCol, ColourRamp *pColourRamp, View *ContextView, EFFECTTYPE Effect)
	Generates a high quality repeating graduated fill table. Handles both those with fill ramps and those without.
BOOL	BuildHighQualityRepeatTable (DocColour &StartCol, DocColour &EndCol, View *ContextView, EFFECTTYPE Effect, CProfileBiasGain &BiasGain)
	Generates a high quality repeating graduated fill table for the supplied profile.
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.
BOOL	AddToTable (DocColour &NewCol, View *ContextView, DWORD Index)
	Adds a colour to a GradTable, at the specified index This is used for multi-stage fills.
GraduationTable *	GetTable (void)
BOOL	IsLarge (void)
Protected Member Functions
void	FillTable (DWORD StartIndex, DWORD EndIndex, PColourRGBT *StartDef, PColourRGBT *EndDef)
	Builds a GradTable from StartIndex to EndIndex by linearly interpolating between the StartDef and EndDef RGB colours.
INT32	GetTableSize (GDrawContext *GD, BOOL LargeTable)
INT32	GetTableLength (GDrawContext *GD, BOOL LargeTable)
Private Attributes
BOOL	m_bLargeTable
GraduationTable *	m_pTable

---

Detailed Description

A kernel representation of a graduation table. (This is a table of 8-bpp dither pattern specifiers for GDraw).

Author:

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

Date:

14/9/94

See also:

GradTable32

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 138 of file gradtbl.h.

---

Constructor & Destructor Documentation

GradTable::GradTable (  BOOL  LargeTable = FALSE  )

Default constructor for a GradTable. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 14/9/94 Notes: Sets the default table size to 0x100 entries long See also: GradTable::SetTableSize Definition at line 167 of file gradtbl.cpp. { m_bLargeTable = LargeTable; m_pTable = NULL; }

GradTable::~GradTable (   )

Destructor for a GradTable. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 16/10/96 Definition at line 185 of file gradtbl.cpp. { if (m_pTable != NULL) { CCFree(m_pTable); m_pTable = NULL; } }

---

Member Function Documentation

BOOL GradTable::AddToTable (  DocColour &  NewCol, View *  ContextView, DWORD  Index )

Adds a colour to a GradTable, at the specified index This is used for multi-stage fills. Author: Will_Cowling (Xara Group Ltd) <camelotdev@xara.com> Date: 14/9/94 Parameters: NewCol  - The colour to place into the GradTable [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) Index - The index of the table entry to overwrite Returns: Errors: - Definition at line 996 of file gradtbl.cpp. { ColourContextRGBT *cc = (ColourContextRGBT *) ColourManager::GetColourContext(COLOURMODEL_RGBT, ContextView); ERROR3IF(cc == NULL, "Unable to find an RGB colour context for the view"); ERROR3IF(Index >= m_pTable->Length, "Illegal table index"); PColourRGBT Result; cc->ConvertColour(&NewCol, (ColourPacked *) &Result); COLORREF Col = RGB(Result.Red, Result.Green, Result.Blue); // Get GDraw to fill in the table entry for us. FALSE => RGB colour return(GRenderRegion::GetStaticDrawContext()->AddToGraduationTable(Col, FALSE, m_pTable, Index)); }

BOOL GradTable::BuildHighQualityRepeatTable (  DocColour &  StartCol, DocColour &  EndCol, View *  ContextView, EFFECTTYPE  Effect, CProfileBiasGain &  BiasGain )

Generates a high quality repeating graduated fill table for the supplied profile. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> Date: 4/2/2000 Parameters: StartCol,EndCol  - Define the end colours of the graduation [INPUTS] pColourRamp - Define the colours and positions of a colour ramp 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 BiasGain - the profile to build for Returns: TRUE, error thrown otherwise (but only for input variables) See also: - Definition at line 819 of file gradtbl.cpp. { // Find a GDraw context to generate dithertable entries for us GDrawContext *GD = GRenderRegion::GetStaticDrawContext(); ERROR3IF(GD == NULL, "GradTable::BuildHighQualityRepeatTable - No GDraw context?!"); // 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; // Get colour contexts: we need 2 - first, an RGB context 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; ColourContext *ccRGB = ColourManager::GetColourContext(COLOURMODEL_RGBT, ContextView); 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 || ccRGB == NULL, "GradTable::BuildHighQualityRepeatTable - Can't find my colour context!"); // Fill in the Start and End colours of the table, if we've hit them PColourRGBT Result; // set our table size for this grad SetTableSize(TRUE); ccRGB->ConvertColour(&StartCol, (ColourPacked *) &Result); m_pTable->StartColour = RGB(Result.Red, Result.Green, Result.Blue); ccRGB->ConvertColour(&EndCol, (ColourPacked *) &Result); m_pTable->EndColour = RGB(Result.Red, Result.Green, Result.Blue); const INT32 TableLength = m_pTable->Length; INT32 halfTableLength = TableLength/2; double MixFraction; BiasGain.SetIntervals (AFp (0), AFp (m_pTable->Length/2)); DocColour temp; INT32 r, g, b; double res; BOOL secondHalf = FALSE; INT32 secondHalfVal =0; // NOTE: this loop could be optimised to avoid calculating the same colour value twice for (INT32 col = 0; col < TableLength; col++) { if (!secondHalf) { res = BiasGain.MapInterval( AFp( col) ); } else { res = BiasGain.MapInterval( AFp( secondHalfVal) ); } MixFraction = res / halfTableLength; // 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); temp.GetRGBValue (&r, &g, &b); // Get GDraw to fill in the dither entry for us (FALSE means it's an RGB colour) GD->AddToGraduationTable(RGB(r, g, b), FALSE, m_pTable, col); if (!(col < halfTableLength)) { secondHalfVal = TableLength - col; secondHalf = TRUE; } } return (TRUE); }

BOOL GradTable::BuildHighQualityRepeatTable (  DocColour &  StartCol, DocColour &  EndCol, ColourRamp *  pColourRamp, View *  ContextView, EFFECTTYPE  Effect )

Generates a high quality repeating graduated fill table. Handles both those with fill ramps and those without. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> Date: 4/2/2000 Parameters: StartCol,EndCol  - Define the end colours of the graduation [INPUTS] pColourRamp - Define the colours and positions of a colour ramp 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 Returns: TRUE, error thrown otherwise (but only for input variables) See also: - Definition at line 694 of file gradtbl.cpp. { if (!pColourRamp) { // Find a GDraw context to generate dithertable entries for us GDrawContext *GD = GRenderRegion::GetStaticDrawContext(); ERROR3IF(GD == NULL, "GradTable::BuildHighQualityRepeatTable - No GDraw context?!"); // 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; // Get colour contexts: we need 2 - first, an RGB context 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; ColourContext *ccRGB = ColourManager::GetColourContext(COLOURMODEL_RGBT, ContextView); 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 || ccRGB == NULL, "GradTable::BuildHighQualityRepeatTable - Can't find my colour context!"); // Fill in the Start and End colours of the table, if we've hit them PColourRGBT Result; // set our table size for this grad SetTableSize(TRUE); ccRGB->ConvertColour(&StartCol, (ColourPacked *) &Result); ccRGB->ConvertColour(& EndCol, (ColourPacked *) &Result); m_pTable->StartColour = RGB(Result.Red, Result.Green, Result.Blue); m_pTable->EndColour = RGB(Result.Red, Result.Green, Result.Blue); const INT32 TableLength = m_pTable->Length; double MixFraction = 0.0; double MixStep = 0; if (TableLength != 0) MixStep = 2.0 / TableLength; DocColour temp; INT32 r, g, b; // NOTE: this loop could be optimised to avoid calculating the same colour value twice for (INT32 col = 0 ; (col<<1)<TableLength ; 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); temp.GetRGBValue (&r, &g, &b); // Get GDraw to fill in the dither entry for us (FALSE means it's an RGB colour) GD->AddToGraduationTable(RGB(r, g, b), FALSE, m_pTable, col); GD->AddToGraduationTable(RGB(r, g, b), FALSE, m_pTable, TableLength-col-1); MixFraction += MixStep; } } else { // set our table size for this grad SetTableSize(TRUE); ColRampItem *pCTI = pColourRamp->GetFirstCol(); if (pCTI!=NULL) { DocColour *pFirstCol=&StartCol, *pSecondCol; DWORD fi=0 , si=0; while (pCTI) { // whip out the colour definition pSecondCol = pCTI->GetColourAddr(); // calculate the index for the next colour si = (DWORD)((pCTI->GetPosition() * m_pTable->Length)+0.5); // build this section of the table if (!BuildTable(*pFirstCol, *pSecondCol, ContextView, Effect, fi, si)) return FALSE; // now skip round to the next pFirstCol = pSecondCol; fi = si; pCTI = pColourRamp->GetNextCol(pCTI); } // do the final section return BuildTable(*pSecondCol, StartCol, ContextView, Effect, si, m_pTable->Length); } } return (TRUE); }

BOOL GradTable::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. No longer calls GDraw to build the table. The colours are generated by us (mainly so that we can support proper colour correction and separation by allowing the colour system to do its stuff) This method could be somewhat more optimal than it is, if we start poking around more in the internals of the colour system. For the time being, I'm leaving it tidy, however. Returns: Errors: ERROR2's if it runs out of memory See also: GradTable::SetTableSize Definition at line 437 of file gradtbl.cpp. { // The range should be within 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 || LastEntry > m_pTable->Length, "GradTable::BuildTable expects sensible First/Last Entry values"); // Find a GDraw context to generate dithertable entries for us GDrawContext *GD = GRenderRegion::GetStaticDrawContext(); ERROR3IF(GD == NULL, "GradTable::BuildTable - No GDraw context?!"); // 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; // Get colour contexts: we need 2 - first, an RGB context 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; ColourContext *ccRGB = ColourManager::GetColourContext(COLOURMODEL_RGBT, ContextView); 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 || ccRGB == NULL, "GradTable::BuildTable - Can't find my colour context!"); // Fill in the Start and End colours of the table, if we've hit them PColourRGBT Result; if (FirstEntry == 0) { ccRGB->ConvertColour(&StartCol, (ColourPacked *) &Result); m_pTable->StartColour = RGB(Result.Red, Result.Green, Result.Blue); } if (LastEntry >= m_pTable->Length) { LastEntry = m_pTable->Length; ccRGB->ConvertColour(&EndCol, (ColourPacked *) &Result); m_pTable->EndColour = RGB(Result.Red, Result.Green, Result.Blue); } const BOOL ValidColourPlate = (ccRGB->GetColourPlate() != NULL && !ccRGB->GetColourPlate()->IsDisabled()); if (ValidColourPlate || FirstEntry > 0 || LastEntry < m_pTable->Length) { if (ValidColourPlate && ccRGB->GetColourPlate()->GetType() == COLOURPLATE_COMPOSITE) { // We're doing a composite print preview. 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, (Effect == EFFECT_HSV_LONG), ccRGB); ccRGB->ConvertColour(&TempCol, (ColourPacked *) &EndDef); // Linearly interpolate all colours in the run FillTable(StartIndex, EndIndex, &StartDef, &EndDef); // And step on to the next run StartIndex = EndIndex; } } else { // We have some type of colour separation on the go - we must convert all intermediate // colours through the colour system in order to ensure the results are correct. // This is quite slow, but acceptable (ish) when printing. double MixFraction = 0.0; // This next line requires the -1 because otherwise it doesn't reach the end colour // This is ok if LastEntry = StartEntry + 1 as MixStep will be calculated as zero // and the StartCol will be used to fill in the single entry required double denumerator = (double) (LastEntry - FirstEntry - 1); double MixStep = 0; if (denumerator != 0) { MixStep = 1.0 / denumerator; } 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); // Get GDraw to fill in the dither entry for us (FALSE means it's an RGB colour) GD->AddToGraduationTable(RGB(Result.Red, Result.Green, Result.Blue), FALSE, m_pTable, col); // And step to the next mix fraction value MixFraction += MixStep; } } } else { // We're doing a completely normal view, and building the entire 256-entry table, so // call GDraw to blindly interpolate between the colours, which is much (much) faster. GD->BuildGraduationTable(m_pTable->StartColour, m_pTable->EndColour, Effect, m_pTable); } return(TRUE); }

BOOL GradTable::BuildTable (  DocColour &  StartCol, DocColour &  EndCol, ColourRamp *  pColRamp, View *  ContextView, EFFECTTYPE  Effect, BOOL  LargeTable = FALSE )

Writes a colour ramp fill record to the filter. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 25/2/97 Parameters: StartCol,EndCol  - Define the end colours of the graduation [INPUTS] pColList - Define the colours and positions of a colour ramp 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: TRUE if record is written, FALSE if not See also: - Definition at line 931 of file gradtbl.cpp. { // set our table size for this grad SetTableSize(LargeTable); // if we've been passed a colour table, lets use it if (pColRamp!=NULL) { ColRampItem *pCTI = pColRamp->GetFirstCol(); if (pCTI!=NULL) { DocColour *pFirstCol=&StartCol, *pSecondCol; DWORD fi=0 , si=0; while (pCTI) { // whip out the colour definition pSecondCol = pCTI->GetColourAddr(); // calculate the index for the next colour si = (DWORD)((pCTI->GetPosition() * m_pTable->Length)+0.5); // build this section of the table if (!BuildTable(*pFirstCol, *pSecondCol, ContextView, Effect, fi, si)) return FALSE; // now skip round to the next pFirstCol = pSecondCol; fi = si; pCTI = pColRamp->GetNextCol(pCTI); } // do the final section return BuildTable(*pSecondCol, EndCol, ContextView, Effect, si, m_pTable->Length); } } // otherwise do the normal double end linear fill. return (BuildTable(StartCol, EndCol, ContextView, Effect, 0, m_pTable->Length)); }

BOOL GradTable::BuildTable (  DocColour &  StartCol, DocColour &  EndCol, View *  ContextView, EFFECTTYPE  Effect, CProfileBiasGain &  BiasGain, BOOL  LargeTable = FALSE )

Generates a graduated fill table that is modified by biasgain values. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> Date: 4/2/2000 Parameters: StartCol,EndCol  - Define the end colours of the graduation [INPUTS] pColList - Define the colours and positions of a colour ramp 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 BiasGain - The baisgain values that are to alter the fill table TableSize - The number of entries you wish to make the table (0x100 or 0x800) Returns: TRUE, error thrown otherwise (but only for input variables) See also: - Definition at line 604 of file gradtbl.cpp. { // Find a GDraw context to generate dithertable entries for us GDrawContext *GD = GRenderRegion::GetStaticDrawContext(); ERROR3IF(GD == NULL, "GradTable::BuildTable - No GDraw context?!"); // 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; // Get colour contexts: we need 2 - first, an RGB context 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; ColourContext *ccRGB = ColourManager::GetColourContext(COLOURMODEL_RGBT, ContextView); 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 || ccRGB == NULL, "GradTable::BuildTable - Can't find my colour context!"); // Fill in the Start and End colours of the table, if we've hit them PColourRGBT Result; // set our table size for this grad SetTableSize(LargeTable); ccRGB->ConvertColour(&StartCol, (ColourPacked *) &Result); m_pTable->StartColour = RGB(Result.Red, Result.Green, Result.Blue); ccRGB->ConvertColour(&EndCol, (ColourPacked *) &Result); m_pTable->EndColour = RGB(Result.Red, Result.Green, Result.Blue); BiasGain.SetIntervals (AFp (0), AFp (m_pTable->Length)); const INT32 TableLength = m_pTable->Length; double MixFraction; DocColour temp; INT32 r, g, b; double res; for (INT32 col = 0; col < TableLength; col++) { res = BiasGain.MapInterval( AFp( col ) ); MixFraction = res / TableLength; // 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); temp.GetRGBValue (&r, &g, &b); // Get GDraw to fill in the dither entry for us (FALSE means it's an RGB colour) GD->AddToGraduationTable(RGB(r, g, b), FALSE, m_pTable, col); } return (TRUE); }

BOOL GradTable::BuildTable (  DocColour &  StartCol, DocColour &  EndCol, View *  ContextView, EFFECTTYPE  Effect, BOOL  LargeTable = FALSE )

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 324 of file gradtbl.cpp. { SetTableSize(LargeTable); return(BuildTable(StartCol, EndCol, ContextView, Effect, 0, m_pTable->Length)); }

void GradTable::FillTable (  DWORD  StartIndex, DWORD  EndIndex, PColourRGBT *  StartDef, PColourRGBT *  EndDef )  [protected]

Builds a GradTable from StartIndex to EndIndex by linearly interpolating between the StartDef and EndDef RGB colours. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 21/7/96 Parameters: StartIndex,EndIndex  - Define the indices into the grad fill table [INPUTS] between which you want to fill in the table. NOTE that Table[StartIndex] is filled in, while table[EndIndex] is NOT. StartDef, EndDef - Define the end colours of the graduation Notes: In order to correctly handle Rainbow fills, you must interpolate only small sections of the table - it is recommended that you fill no more than 16 entries of the table at a time with this linear interpolation. Definition at line 357 of file gradtbl.cpp. { GDrawContext *GD = GRenderRegion::GetStaticDrawContext(); // Place the StartDef in as the first entry GD->AddToGraduationTable(RGB(StartDef->Red, StartDef->Green, StartDef->Blue), FALSE, m_pTable, StartIndex); // ...and start interpolating from the second entry DWORD MixStep = (1 << 24) / (EndIndex - StartIndex); DWORD MixFraction = MixStep; DWORD R,G,B; for (DWORD Index = StartIndex + 1; Index < EndIndex; Index++) { // Calculate intermediate RGB values into 8bpp values R = (StartDef->Red * (0x01000000 - MixFraction)) + (EndDef->Red * MixFraction); R >>= 24; G = (StartDef->Green * (0x01000000 - MixFraction)) + (EndDef->Green * MixFraction); G >>= 24; B = (StartDef->Blue * (0x01000000 - MixFraction)) + (EndDef->Blue * MixFraction); B >>= 24; // Get Gavin to fill in the dither entry for us (FALSE means it's an RGB Indexour) GD->AddToGraduationTable(RGB(R,G,B), FALSE, m_pTable, Index); MixFraction += MixStep; } }

GraduationTable* GradTable::GetTable (  void   )  [inline]

Definition at line 189 of file gradtbl.h. { return(m_pTable); };

INT32 GradTable::GetTableLength (  GDrawContext *  GD, BOOL  LargeTable )  [protected]

Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 17/10/96 Parameters: GD  - pointer to GDraw context to use [INPUTS] LargeTable - if true then use a long grad table Returns: The number of entries in a grad table for the specified context Definition at line 234 of file gradtbl.cpp. { if (LargeTable) { return(GD->GetLongGraduationTableLength()); } else { return(GD->GetGraduationTableLength()); } }

INT32 GradTable::GetTableLength (  void   )  [inline]

Definition at line 149 of file gradtbl.h. { return(m_pTable->Length); };

INT32 GradTable::GetTableSize (  GDrawContext *  GD, BOOL  LargeTable )  [protected]

Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 17/10/96 Parameters: GD  - pointer to GDraw context to use [INPUTS] LargeTable - if true then use a long grad table Returns: The size in bytes of a grad table for the specified context Definition at line 208 of file gradtbl.cpp. { if (LargeTable) { return(GD->GetLongGraduationTableSize()); } else { return(GD->GetGraduationTableSize()); } }

BOOL GradTable::IsLarge (  void   )  [inline]

Definition at line 192 of file gradtbl.h. { return(m_bLargeTable); };

void GradTable::SetTableSize (  BOOL  LargeTable  )

To set the size of this Grad table. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 17/10/96 Parameters: LargeTable  - if true then use a long grad table [INPUTS] Notes: The table defaults to small Definition at line 262 of file gradtbl.cpp. { // If we don't have the right table size or no table at all if ((LargeTable != m_bLargeTable) || (m_pTable == NULL)) { m_bLargeTable = LargeTable; if (m_pTable != NULL) { CCFree(m_pTable); m_pTable = NULL; } GDrawContext *GD = GRenderRegion::GetStaticDrawContext(); if (GD != NULL) { INT32 Size = GetTableSize(GD, m_bLargeTable); m_pTable = (GraduationTable*) CCMalloc(Size); if (m_pTable != NULL) { m_pTable->Length = GetTableLength(GD, LargeTable); } } } }

---

Member Data Documentation

BOOL GradTable::m_bLargeTable [private]

Definition at line 206 of file gradtbl.h.

GraduationTable* GradTable::m_pTable [private]

Definition at line 207 of file gradtbl.h.

---

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

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

---