PaletteManager Class Reference

#include <palman.h>

List of all members.

Static Public Member Functions
static BOOL	EnsurePalette (wxWindow *CWindow, BOOL ForceRedraw)
	To respond to WM_QUERYNEWPALETTE and WM_ONPALETTECHANGED Whenever you get one of these messages for youre window, call this method if you want to use the normal GDraw palette. The only splitter in this area to date is the splashbox window.
static wxPalette *	StartPaintPalette (wxDC *hDC, wxPalette *pHPal=NULL, BOOL bForceBackground=FALSE)
	To select and realise the mainframe GDraw palette before painting Scope: Static public.
static wxPalette *	StopPaintPalette (wxDC *RenderDC, wxPalette *OldPalette, BOOL bForceBackground=TRUE)
	To restore the palette after painting, using the palette returned to you by StartPaintPalette.
static BOOL	Init (void)
	Initialises the palette manager.
static BOOL	UsePalette (void)
static void	UpdatePalette (void)
	Sets up the static main frame palette This will be called whenever the palette needs updating.
static wxPalette *	GetPalette (void)
static void	LockPalette (BOOL fLocked)
	"Locks" or "unlocks" the palette, preventing or allowing palette changes due to window repaints. Ultra-bodge way of preventing splash-box palette flash during workspace restoration.
static void	RedrawAllPalettedWindows (wxWindow *ParentWindow=NULL)
	To redraw the given window (and all children) that are reliant upon 256- colour palettes. Usually called with NULL to just redraw the MainFrame.
static void	MakePaletteBrowserCompatible (LPLOGPALETTE pPalette, BOOL IncludeSystemColours)
	This inserts all the browser colours into the palette, and marks all other entries so that they are not used when creating bitmaps.
static void	FillWithBrowserColours (LPLOGPALETTE pPalette, INT32 StartIndex)
	Stuffs all the browser colours into the palette provided Also markes each peFlags entry to 0 (i.e. so Gavin will use it).
static BOOL	ContainsAllBrowserColours (LPLOGPALETTE pPalette)
	A test to see if the palette contains all the 216 browser palette entries.
static LPLOGPALETTE	CreateBrowserPalette (BOOL AvoidSystemColours)
	Creates a palette of browser colours.
static void	FindNearestColour (const ColourRGBT &Colour, LPLOGPALETTE pPalette, ColourRGBT *const pResult)
	Finds the closest colour in the given palette.
static PALETTEENTRY	FindNearestColour (const PALETTEENTRY &PalColour, LPLOGPALETTE pPalette)
	Finds the closest colour in the given palette.
static INT32	FindIndexOfNearestColour (const PALETTEENTRY &PalColour, LPLOGPALETTE pPalette)
static double	FindColourDistanceSquared (const PALETTEENTRY *pPal1, const PALETTEENTRY *pPal2)
	Finds the distance between two colours.
static void	FindNearestBrowserColour (const ColourRGBT &Colour, ColourRGBT *const pResult)
	Finds the closest colour in the browser palette.
static void	SnapToPalette (LPLOGPALETTE pPalette, const LPLOGPALETTE pPaletteToSnapTo)
	This snaps each colour in pPalette to the closest definition in pPaletteToSnapTo.
static void	SnapToBrowserPalette (LPLOGPALETTE pPalette)
	This snaps each colour in pPalette to the closest definition in browser palette.
static void	PokePaletteEntry (LPLOGPALETTE Palette, INT32 *index, BYTE red, BYTE green, BYTE blue, BYTE Flags=0)
	Puts the required value of rgb into the specified palette entry.
static LPLOGPALETTE	Get4bppBrowserPalette (UINT32 ReservedColours)
	This produces a browser compatible 4bpp Palette.
static INT32	FindFirstDontUseColourInPalette (LPLOGPALETTE pPalette)
	This finds the first colour marked as don't use in the specified palette. This colour should correspond to the transparent colour.
Static Protected Member Functions
static BOOL CALLBACK	InvalidateChildProc (wxWindow *hWnd, LPARAM lParam)
	A callback proc to invalidate child windows if they need to be redrawn as a result of a palette change.
static BOOL	IsRedrawOnPaletteChangeRequired (wxWindow *hWnd, BOOL *pNotifyFirst=NULL)
	To respond to InvalidateChildProc. Determines if the given window needs to be redrawn as a result of a palette change.
Static Protected Attributes
static wxPalette	sm_MainPalette
static BOOL	sm_bUseMainPalette = FALSE
static BOOL	m_fPaletteLocked = FALSE

---

Detailed Description

Definition at line 108 of file palman.h.

---

Member Function Documentation

BOOL PaletteManager::ContainsAllBrowserColours (  LPLOGPALETTE  pPalette  )  [static]

A test to see if the palette contains all the 216 browser palette entries. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 20/6/97 Parameters: pPalette  = ptr palette [INPUTS] Returns: TRUE if palette contains all the 216 browser palette entries FALSE otherwise See also: - Definition at line 841 of file palman.cpp. { for (INT32 r=0;r <= 255;r += 51) { BYTE ra = r; for (INT32 g=0;g <=255;g += 51) { BYTE ga = g; for (INT32 b=0;b <=255;b += 51) { BYTE ba = b; BOOL found = FALSE; for (INT32 i=0;i<pPalette->palNumEntries;i++) { // if peFlags != 255, then it hasn't been marked as "Don't use", so check it if (pPalette->palPalEntry[i].peFlags != 255) { found = pPalette->palPalEntry[i].peRed == ra && pPalette->palPalEntry[i].peGreen == ga && pPalette->palPalEntry[i].peBlue == ba; if ( found ) break; } } if (!found) return FALSE; } } } return TRUE; }

LPLOGPALETTE PaletteManager::CreateBrowserPalette (  BOOL  AvoidSystemColours  )  [static]

Creates a palette of browser colours. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 20/6/97 Parameters: AvoidSystemColours  = TRUE if you want the system colour palette entries to be left alone. [INPUTS] FALSE if you want the first 216 entries to be the browser palette. Returns: ptr to a palette, or NULL if it fails To delete the palette, use CCFree(). See also: - Definition at line 891 of file palman.cpp. { LPLOGPALETTE pPalette = NULL; const size_t TotalPal = sizeof(LOGPALETTE) + ( sizeof(PALETTEENTRY) * 256 ); pPalette = (LPLOGPALETTE)CCMalloc( TotalPal ); if (pPalette!= NULL) { pPalette->palVersion = 0x300; pPalette->palNumEntries = 256; MakePaletteBrowserCompatible(pPalette,AvoidSystemColours); } return pPalette; }

BOOL PaletteManager::EnsurePalette (  wxWindow *  hWnd, BOOL  ForceRedraw )  [static]

To respond to WM_QUERYNEWPALETTE and WM_ONPALETTECHANGED Whenever you get one of these messages for youre window, call this method if you want to use the normal GDraw palette. The only splitter in this area to date is the splashbox window. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 26/5/95 Parameters: hWnd  - the window for which EnsurePalette was called [INPUTS] or CWindow the CWnd equivalent ForceRedraw - TRUE to force a redraw even when we haven't (seeminlgy) affected the palette Returns: TRUE if it chnaged the palette in the course of realising the GDraw palette Now returns TRUE if it selects a palette Scope: Static public Notes: Use ForceRedraw = FALSE for WM_QUERYNEWPALETTE, TRUE for WM_ONPALETTECHANGED Definition at line 385 of file palman.cpp. { /* GAT #if DEBUG_PALMAN TRACE( _T("BOOL PaletteManager::EnsurePalette(HWND hWnd = %d, BOOL ForceRedraw = %d)\n"), (DWORD)hWnd, ForceRedraw); #endif static PALETTEENTRY OldSysPal[256]; BOOL ForceBackground = m_fPaletteLocked; static BOOL SelectingPalette = FALSE; // This code may well look a bit odd but it is necessary to prevent reentrancy problems BOOL CheckPalette = !SelectingPalette; #ifdef RALPH if(!RalphDocument::ForegroundPalette) ForceBackground = TRUE; #endif // This "event" is directed at the application as a whole but the palette we set up is // always associated with the Selected DocView and so we'll set Current to Selected... if (Document::GetSelected != NULL) Document::GetSelected()->SetCurrent(); if (DocView::GetSelected() != NULL) DocView::GetSelected()->SetCurrent(); if (!UsePalette()) // We don't use a special palette, so do nothing return(FALSE); // This check (to stop us changing the palette when minimised) has been removed (Jason - 26/7/95) // The reason for this is: // (a) This is contrary to microsoft coding guidelines, // (b) If you restore camelot from minimised state, it fails to realise its palette! // (c) The behaviour is now "correct" and exactly the same as all other apps // // if (MainFrame->IsIconic()) // We are currently in an iconised state, so do nothing // return(FALSE); SelectingPalette = TRUE; HDC hDC = ::GetDC(hWnd); // We need to check that the palette actully has changed // because RealizePalette() will say that 256 colours have changed // if you close the help file on NT4/95 PALETTEENTRY NewSysPal[256]; HPALETTE OldPal = ::SelectPalette(hDC, sm_MainPalette, ForceBackground); UINT32 NumColoursChanged = ::RealizePalette(hDC); ::SelectPalette(hDC, OldPal, TRUE); ::RealizePalette(hDC); GetSystemPaletteEntries(hDC, 0, 256, NewSysPal); ::ReleaseDC(hWnd, hDC); SelectingPalette = FALSE; if (CheckPalette) { for (DWORD Index = 0; Index < 256; Index++) NewSysPal[Index].peFlags = 0; // If the palette has really changed if (memcmp(NewSysPal, OldSysPal, sizeof(PALETTEENTRY) * 256) != 0) { // TRACEUSER( "Gerry", _T("Palette has actually changed\n")); // Update the old palette memcpy(OldSysPal, NewSysPal, sizeof(PALETTEENTRY) * 256); // TRACEUSER( "Gerry", _T("Cols changed %d\n"), NumColoursChanged); // Only set the flag if the OS thinks the palette has changed if (NumColoursChanged != 0) ForceRedraw = TRUE; } // else // { // TRACEUSER( "Gerry", _T("Palette not actually changed\n")); // } } // else // { // TRACEUSER( "Gerry", _T("Not checking palette\n")); // } if (ForceRedraw) { // TRACEUSER( "Gerry", _T("Forcing redraw\n")); GRenderRegion::GColInit(NULL, TRUE); // tell GDraw of new palette RedrawAllPalettedWindows(hWnd); // And redraw everything } // This used to return the commented out line below but was changed // to help fix a problem with the help file // return(NumColoursChanged != 0); */ return(TRUE); }

void PaletteManager::FillWithBrowserColours (  LPLOGPALETTE  pPalette, INT32  StartIndex )  [static]

Stuffs all the browser colours into the palette provided Also markes each peFlags entry to 0 (i.e. so Gavin will use it). Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 20/6/97 Parameters: pPalette  = ptr palette [INPUTS] StartIndex = the index to start filling the entries from Returns: - See also: - Definition at line 798 of file palman.cpp. { ERROR3IF(pPalette == NULL,"NULL Entry param"); if (pPalette == NULL) return; INT32 i = StartIndex; // Generate the entire browser palette for (INT32 r=0;r <= 255;r += 51) { for (INT32 g=0;g <=255;g += 51) { for (INT32 b=0;b <=255;b += 51) { if (i < pPalette->palNumEntries) // Extra safety check { pPalette->palPalEntry[i].peRed = r; pPalette->palPalEntry[i].peGreen = g; pPalette->palPalEntry[i].peBlue = b; pPalette->palPalEntry[i].peFlags = 0; // Mark as "Use this colour if you want" } i++; // Next entry please } } } }

double PaletteManager::FindColourDistanceSquared (  const PALETTEENTRY *  pPal1, const PALETTEENTRY *  pPal2 )  [static]

Finds the distance between two colours. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 7/7/97 Parameters: pPal1  = Colour 1 [INPUTS] pPal2 = Colour 2 Returns: The distance between the two colours with the RGB cube, squared See also: - Definition at line 1057 of file palman.cpp. { ERROR2IF(pPal1 == NULL || pPal2 == NULL,0.0,"NULL pal entry pointer"); double dr = double(pPal1->peRed - pPal2->peRed ); double dg = double(pPal1->peGreen - pPal2->peGreen); double db = double(pPal1->peBlue - pPal2->peBlue ); return dr*dr+dg*dg+db*db ; }

INT32 PaletteManager::FindFirstDontUseColourInPalette (  LPLOGPALETTE  pPalette  )  [static]

This finds the first colour marked as don't use in the specified palette. This colour should correspond to the transparent colour. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Humprhys Date: 15/8/97 Parameters: pPalette  palette to check [INPUTS] Returns: index of the transparent colour or -1 Definition at line 1276 of file palman.cpp. { ERROR2IF(pPalette == NULL,-1,"FindFirstDontUseColourInPalette Bad palette"); UINT32 colours = pPalette->palNumEntries; INT32 DontUseColour = -1; PALETTEENTRY * pPaletteEntry = pPalette->palPalEntry; for (UINT32 i = 0; (i < colours) && (DontUseColour == -1); i++) { if (pPaletteEntry[i].peFlags == 0xFF) DontUseColour = i; } return DontUseColour; }

INT32 PaletteManager::FindIndexOfNearestColour (  const PALETTEENTRY &  PalColour, LPLOGPALETTE  pPalette )  [static]

Definition at line 1005 of file palman.cpp. { // PALETTEENTRY Dummy = {0,0,0,0}; double SmallestDistance = 0.0; BOOL FirstDistanceCalc = TRUE; INT32 ClosestColourIndex = 0; // look at all the colours in the palette for (INT32 i=0;i<pPalette->palNumEntries;i++) { // If the peFlags is 0, then it's not been marked as "ignore", so look at it if (pPalette->palPalEntry[i].peFlags == 0) { // Get the distance between the colour and this palette entry double d = FindColourDistanceSquared(&PalColour, &(pPalette->palPalEntry[i])); if (FirstDistanceCalc) { // First time around, so 'd' must be closest yet FirstDistanceCalc = FALSE; SmallestDistance = d; ClosestColourIndex = i; } else if (d < SmallestDistance) { // Smallest distance so far? if so remember the distance & index SmallestDistance = d; ClosestColourIndex = i; } } } // Return the closest palette entry return ClosestColourIndex; }

void PaletteManager::FindNearestBrowserColour (  const ColourRGBT &  Colour, ColourRGBT *const   pResult )  [static]

Finds the closest colour in the browser palette. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 7/7/97 Parameters: Colour  = Original colour definition [INPUTS] pResult = place to put closest colour definition Returns: pResult contains a colour from the browser palette that's closest to the original The closest colour is the one that is closest in terms of distance within the RGB colour cube. See also: - Definition at line 1086 of file palman.cpp. { ERROR3IF(pResult == NULL,"NULL pResult pointer"); if (pResult == NULL) return; LPLOGPALETTE pBrowserPalette = PaletteManager::CreateBrowserPalette(FALSE); if (pBrowserPalette != NULL) { FindNearestColour(Colour,pBrowserPalette,pResult); CCFree(pBrowserPalette); } }

PALETTEENTRY PaletteManager::FindNearestColour (  const PALETTEENTRY &  PalColour, LPLOGPALETTE  pPalette )  [static]

Finds the closest colour in the given palette. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 7/7/97 Parameters: PalColour  = Original colour definition [INPUTS] pPalette = look-up palette Returns: A colour from the palette that's closest to the original The closest colour is the one that is closest in terms of distance within the RGB colour cube. See also: - Definition at line 964 of file palman.cpp. { PALETTEENTRY Dummy = {0,0,0,0}; ERROR2IF(pPalette == NULL,Dummy,"NULL Palette ptr"); ERROR2IF(pPalette->palNumEntries < 1,Dummy,"No Palette entries"); double SmallestDistance = 0.0; BOOL FirstDistanceCalc = TRUE; INT32 ClosestColourIndex = 0; // look at all the colours in the palette for (INT32 i=0;i<pPalette->palNumEntries;i++) { // If the peFlags is 0, then it's not been marked as "ignore", so look at it if (pPalette->palPalEntry[i].peFlags == 0) { // Get the distance between the colour and this palette entry double d = FindColourDistanceSquared(&PalColour, &(pPalette->palPalEntry[i])); if (FirstDistanceCalc) { // First time around, so 'd' must be closest yet FirstDistanceCalc = FALSE; SmallestDistance = d; ClosestColourIndex = i; } else if (d < SmallestDistance) { // Smallest distance so far? if so remember the distance & index SmallestDistance = d; ClosestColourIndex = i; } } } // Return the closest palette entry return (pPalette->palPalEntry[ClosestColourIndex]); }

void PaletteManager::FindNearestColour (  const ColourRGBT &  Colour, LPLOGPALETTE  pPalette, ColourRGBT *const   pResult )  [static]

Finds the closest colour in the given palette. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 7/7/97 Parameters: Colour  = Original colour definition [INPUTS] pPalette = look-up palette pResult = place to put closest colour definition Returns: pResult contains a colour from the palette that's closest to the original The closest colour is the one that is closest in terms of distance within the RGB colour cube. See also: - Definition at line 925 of file palman.cpp. { ERROR3IF(pResult == NULL,"NULL pResult pointer"); if (pResult == NULL) return; // Convert original colour into an RGB palette entry PALETTEENTRY PalColour; PalColour.peRed = BYTE(Colour.Red.MakeDouble()*255); PalColour.peGreen = BYTE(Colour.Green.MakeDouble()*255); PalColour.peBlue = BYTE(Colour.Blue.MakeDouble()*255); // Find the closest palette entry PALETTEENTRY ClosestPalColour = FindNearestColour(PalColour,pPalette); // Convert back to a ColourRGBT pResult->Red = FIXED24(double(ClosestPalColour.peRed)/255.0); pResult->Green = FIXED24(double(ClosestPalColour.peGreen)/255.0); pResult->Blue = FIXED24(double(ClosestPalColour.peBlue)/255.0); }

LPLOGPALETTE PaletteManager::Get4bppBrowserPalette (  UINT32  ReservedColours  )  [static]

This produces a browser compatible 4bpp Palette. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Humprhys Date: 15/8/97 Parameters: ReservedColours  number of reserved colours in this palette e.g. transparent colour [INPUTS] Returns: LOGPALETTE containing the required palette or NULL Definition at line 1217 of file palman.cpp. { ERROR3IF(ReservedColours > 15,"Bad number of reserved colours"); LPLOGPALETTE pPalette = DIBUtil::AllocateLogPalette(16); if (pPalette == NULL) return NULL; INT32 i = 0; // Gavin uses a fixed 16 colour palette // Usually we use a half intensity value, instead we need to snap it to either // 40% (102) or 60% (153) to be browser compatible // Define a constant so its easy to change this snapped half intensity value const BYTE Shiv = 153; // We shall just use a browser snapped version of this PokePaletteEntry(pPalette, &i, 0x00, 0x00, 0x00); // black PokePaletteEntry(pPalette, &i, Shiv, 0x00, 0x00); // brown PokePaletteEntry(pPalette, &i, 0x00, Shiv, 0x00); // Half green PokePaletteEntry(pPalette, &i, Shiv, Shiv, 0x00); // Half browny (red/green) PokePaletteEntry(pPalette, &i, 0x00, 0x00, Shiv); // Dark blue PokePaletteEntry(pPalette, &i, Shiv, 0x00, Shiv); // Mauve PokePaletteEntry(pPalette, &i, 0x00, Shiv, Shiv); // greeny/blue PokePaletteEntry(pPalette, &i, Shiv, Shiv, Shiv); // mid grey PokePaletteEntry(pPalette, &i, 0xcc, 0xcc, 0xcc); // light grey from 196 to 204 PokePaletteEntry(pPalette, &i, 0xff, 0x00, 0x00); // red PokePaletteEntry(pPalette, &i, 0x00, 0xff, 0x00); // green PokePaletteEntry(pPalette, &i, 0xff, 0xff, 0x00); // yellow PokePaletteEntry(pPalette, &i, 0x00, 0x00, 0xff); // blue PokePaletteEntry(pPalette, &i, 0xff, 0x00, 0xff); // magenta PokePaletteEntry(pPalette, &i, 0x00, 0xff, 0xff); // cyan PokePaletteEntry(pPalette, &i, 0xff, 0xff, 0xff); // white /* if (ReservedColours > 0) { // Used to pick index 10 to be transparent but now we pick the light grey i = 8; PokePaletteEntry(pPalette, &i, 0xFF, 0xFF, 0xFF, 0xFF); // don't use white // Warn if we try to pick more than 1 reserved colour ERROR3IF(ReservedColours > 1,"Get4bppBrowserPalette We can only cope with 1 reserved colour"); } */ return pPalette; }

static wxPalette* PaletteManager::GetPalette (  void   )  [inline, static]

Definition at line 140 of file palman.h. { return(sm_bUseMainPalette ? &sm_MainPalette : NULL); }

BOOL PaletteManager::Init (  void   )  [static]

Initialises the palette manager. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 28/6/96 See also: PaletteManager::UpdatePalette Definition at line 139 of file palman.cpp. { #if DEBUG_PALMAN TRACE( _T("BOOL PaletteManager::Init(void)\n")); #endif UpdatePalette(); return(TRUE); }

BOOL CALLBACK PaletteManager::InvalidateChildProc (  wxWindow *  hWnd, LPARAM  lParam )  [static, protected]

A callback proc to invalidate child windows if they need to be redrawn as a result of a palette change. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 26/5/95 Parameters: hWnd  - the window to invalidate [INPUTS] lParam - unused Returns: TRUE (success) Scope: Static public Definition at line 200 of file palman.cpp. { /* GAT #if DEBUG_PALMAN TRACE( _T("BOOL CALLBACK PaletteManager::InvalidateChildProc(HWND hWnd = %d, LPARAM lParam = %d)\n"), (DWORD)hWnd, (DWORD)lParam); #endif BOOL bNotify = FALSE; if (PaletteManager::IsRedrawOnPaletteChangeRequired(hWnd, &bNotify)) { if (bNotify) SendMessage(hWnd, WM_CAM_PALETTECHANGE, 0, 0); ::InvalidateRect(hWnd, NULL, TRUE); } */ return(TRUE); }

BOOL PaletteManager::IsRedrawOnPaletteChangeRequired (  wxWindow *  hWnd, BOOL *  pNotifyFirst = NULL )  [static, protected]

To respond to InvalidateChildProc. Determines if the given window needs to be redrawn as a result of a palette change. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 30/5/95 Parameters: hWnd  - a window potentially to be redrawn [INPUTS] Returns: TRUE if this window should redraw, FALSE if not Scope: Static public Definition at line 277 of file palman.cpp. { return FALSE; /* GAT #if DEBUG_PALMAN TRACE( _T("BOOL PaletteManager::IsRedrawOnPaletteChangeRequired(HWND hWnd = %d)\n"), (DWORD)hWnd); #endif if (pNotifyFirst) *pNotifyFirst = FALSE; #ifdef RALPH // Nasty Ralph bodge to get the palette working sensibly return(TRUE); #else // First see if it is an MFC Window // Well this does some of it CWnd* pCWnd = CWnd::FromHandlePermanent(hWnd); // don't redraw it then // Note we keep its children separately #ifndef STANDALONE if (pCWnd) { if (pCWnd->IsKindOf(RUNTIME_CLASS(CColourBar)) || // Redraw the colour bar pCWnd->IsKindOf(RUNTIME_CLASS(CRenderWnd))) // and the view windows { return TRUE; } return FALSE; } #else if (pCWnd) { if (pCWnd->IsKindOf(RUNTIME_CLASS(CRenderWnd))) // Redraw the view windows return TRUE; return FALSE; } #endif // OK, it's not an MFC window String_256 ClassNameStr; // The control type // Find out the class type of the gadget GetClassName(hWnd, (TCHAR*)ClassNameStr, 255); if ((ClassNameStr == String_16(TEXT("cc_DialogDraw")))) return TRUE; if ((ClassNameStr == String_16(TEXT("cc_BitmapButton")))) { if (pNotifyFirst) *pNotifyFirst = TRUE; return TRUE; } if ((ClassNameStr == String_16(TEXT("cc_SmallButton")))) { if (pNotifyFirst) *pNotifyFirst = TRUE; return TRUE; } if ((ClassNameStr == String_16(TEXT("cc_StaticBitmap")))) { if (pNotifyFirst) *pNotifyFirst = TRUE; return TRUE; } return FALSE; #endif */ }

void PaletteManager::LockPalette (  BOOL  fLocked  )  [static]

"Locks" or "unlocks" the palette, preventing or allowing palette changes due to window repaints. Ultra-bodge way of preventing splash-box palette flash during workspace restoration. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 16/10/95 Parameters: fLocked  if TRUE, lock the palette, if FALSE, unlock it. [INPUTS] Notes: This bodge has been toned down (Jason). It now does not stop us realizing palettes (which is a big big big no-no) but instead forces us to background palette realization so that it does not affect the physical screen palette. See also: PaletteManager::IsRedrawOnPaletteChangeRequired Definition at line 170 of file palman.cpp. { #if DEBUG_PALMAN TRACE( _T("void PaletteManager::LockPalette(BOOL fLocked = %d)\n"), fLocked); #endif m_fPaletteLocked = fLocked; }

void PaletteManager::MakePaletteBrowserCompatible (  LPLOGPALETTE  pPalette, BOOL  AvoidSystemColours )  [static]

This inserts all the browser colours into the palette, and marks all other entries so that they are not used when creating bitmaps. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 8/2/97 Parameters: pPalette  = ptr to 256 entry palette [INPUTS] AvoidSystemColours = TRUE if you want the system colour palette entries to be lefte alone FALSE if you want the first 216 entries to be the browser palette. An entry is marked as "don't use" by setting the peFlags member to 255 (e.g. pPalette->palPalEntry[x].peFlags = 255); if AvoidSystemColours is TRUE, the system colour palette entries are marked as "don't use" Introduced for Webster. Modified heavily for Webster v2 by Markn 20/6/97 See also: - Definition at line 742 of file palman.cpp. { if (pPalette == NULL) { ERROR3("Null palette ptr"); return; } if (pPalette->palNumEntries != 256) { ERROR3("Only suitable for 8bpp 256 entry palettes"); return; } // Set all entries to be "Don't use" INT32 i; for (i = 0; i < pPalette->palNumEntries;i++) { pPalette->palPalEntry[i].peRed = 0; pPalette->palPalEntry[i].peGreen = 0; pPalette->palPalEntry[i].peBlue = 0; pPalette->palPalEntry[i].peFlags = 255; } // If system colours entries are to be avoided, start from the first non-system colour entry (index value 11) if (AvoidSystemColours) i = 11; // 11 in case the bitmap is transparent, in which case index 10 will hold the transparent colour else i = 1; // 1 in case the bitmap is transparent, in which case index 0 will hold the transparent colour // Fill it with the browser colours PaletteManager::FillWithBrowserColours(pPalette,i); // Debug sanity check #ifdef _DEBUG TRACE( _T("Checking 216 colours\n")); if (!ContainsAllBrowserColours(pPalette)) ERROR3("Do what! Some browser colours are missing!"); #endif }

void PaletteManager::PokePaletteEntry (  LPLOGPALETTE  Palette, INT32 *  index, BYTE  red, BYTE  green, BYTE  blue, BYTE  Flags = 0 )  [static]

Puts the required value of rgb into the specified palette entry. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 15/8/97 Parameters: Palette  palette to write to. [INPUTS] index address of variable holding palette entry to write to red red value to enter into palette entry green green value to enter into palette entry blue blue value to enter into palette entry index  incremented by one [OUTPUTS] Returns: - See also: OutputDIB::PokePaletteEntry; Definition at line 1190 of file palman.cpp. { ERROR3IF(Palette == NULL || index == NULL,"PaletteManager::PokePaletteEntry bad params"); if (Palette == NULL || index == NULL) return; Palette->palPalEntry[*index].peRed = red; Palette->palPalEntry[*index].peGreen = green; Palette->palPalEntry[*index].peBlue = blue; Palette->palPalEntry[*index].peFlags = 0; // increment the counter and return it (*index) ++; }

void PaletteManager::RedrawAllPalettedWindows (  wxWindow *  hWnd = NULL  )  [static]

To redraw the given window (and all children) that are reliant upon 256- colour palettes. Usually called with NULL to just redraw the MainFrame. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 9/4/96 Parameters: hWnd  - the parent window to invalidate, or NULL to use Camelot's MainFrame [INPUTS] Definition at line 235 of file palman.cpp. { /* GAT #if DEBUG_PALMAN TRACE( _T("void PaletteManager::RedrawAllPalettedWindows(HWND hWnd = %d)\n"), (DWORD)hWnd); #endif if (hWnd == NULL) { CMainFrame *MainFrame = GetMainFrame(); if (MainFrame != NULL) hWnd = MainFrame->m_hWnd; } if (hWnd != NULL) { if (IsRedrawOnPaletteChangeRequired(hWnd)) ::InvalidateRect(hWnd, NULL, TRUE); // And redraw everything if necessary EnumChildWindows(hWnd, InvalidateChildProc, 0); // And redraw all children which need it } */ }

void PaletteManager::SnapToBrowserPalette (  LPLOGPALETTE  pPalette  )  [static]

This snaps each colour in pPalette to the closest definition in browser palette. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 22/7/97 Parameters: pPalette  = ptr to palette that will be snapped [INPUTS] Returns: - The closest colour is the one that is closest in terms of distance within the RGB colour cube. See also: - Definition at line 1158 of file palman.cpp. { ERROR3IF(pPalette == NULL,"NULL pPalette pointer"); if (pPalette == NULL) return; LPLOGPALETTE pBrowserPalette = PaletteManager::CreateBrowserPalette(FALSE); if (pBrowserPalette != NULL) { SnapToPalette(pPalette,pBrowserPalette); CCFree(pBrowserPalette); } }

void PaletteManager::SnapToPalette (  LPLOGPALETTE  pPalette, const LPLOGPALETTE  pPaletteToSnapTo )  [static]

This snaps each colour in pPalette to the closest definition in pPaletteToSnapTo. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 22/7/97 Parameters: pPalette  = ptr to palette that will be snapped [INPUTS] pPaletteToSnapTo = ptr to palette to snap to Returns: - The closest colour is the one that is closest in terms of distance within the RGB colour cube. See also: - Definition at line 1119 of file palman.cpp. { ERROR3IF(pPalette == NULL || pPaletteToSnapTo == NULL,"NULL pal pointer"); if (pPalette == NULL || pPaletteToSnapTo == NULL) return; // look at all the colours in the palette for (INT32 i=0;i<pPalette->palNumEntries;i++) { // Get the next pal entry PALETTEENTRY PalEntry = pPalette->palPalEntry[i]; // Find the closest pal entry in the palette to snap to PALETTEENTRY NearestPalEntry = FindNearestColour(PalEntry, pPaletteToSnapTo); // Set the pal entry to the nearest colour pPalette->palPalEntry[i] = NearestPalEntry; } }

wxPalette * PaletteManager::StartPaintPalette (  wxDC *  hDC, wxPalette *  pHPal = NULL, BOOL  bForceBackground = FALSE )  [static]

To select and realise the mainframe GDraw palette before painting Scope: Static public. Author: Alex_Bligh (Xara Group Ltd) <camelotdev@xara.com> Date: 26/5/95 Parameters: RenderDC  = the DC we're using [INPUTS] bForceBackground = value to pass to the force background param in SelectPalette If you don't understand foreground/background Windows palettes, use the default or ask Jason HPal = palette to use (3 only) Parameters: pHPal  - if non-null, filled in with the palette which was selected into your DC (2 only) [OUTPUTS] Returns: Pointer to the old palette (or NULL if DC doesn't support palette) See also: PaletteManager::StopPaintPalette Definition at line 556 of file palman.cpp. { #if 1 // GAT return NULL; #else #if DEBUG_PALMAN TRACE( _T("HPALETTE PaletteManager::StartPaintPalette(HDC hDC = %d, HPALETTE *pHPal = %d, BOOL bForceBackground = %d)\n"), (DWORD)hDC, (DWORD)pHPal, bForceBackground); #endif ERROR2IF(!hDC, NULL, "PaletteManager passed NULL DC"); #ifdef RALPH if(!RalphDocument::ForegroundPalette) bForceBackground = TRUE; #endif if (!(::GetDeviceCaps(hDC, RASTERCAPS) & RC_PALETTE)) return(NULL); HPALETTE NewPalette = sm_MainPalette; // Sneaky HPALETTE operator if (pHPal) *pHPal = NewPalette; if (m_fPaletteLocked) bForceBackground = TRUE; HPALETTE OldPalette = ::SelectPalette(hDC, NewPalette, bForceBackground); ::RealizePalette(hDC); return OldPalette; #endif }

wxPalette * PaletteManager::StopPaintPalette (  wxDC *  RenderDC, wxPalette *  OldPalette, BOOL  bForceBackground = TRUE )  [static]

To restore the palette after painting, using the palette returned to you by StartPaintPalette. Parameters: RenderDC/hDC  - the DC we're using [INPUTS] OldPalette - The palette returned to you when you called StartPaintPalette bForceBackground = value to pass to the forcebackground param in SelectPalette It's not expected that this will ever be anything other than TRUE Parameters: -  [OUTPUTS] Returns: Pointer to the old palette (or NULL if DC doesn't support palette) See also: PaletteManager::StartPaintPalette Scope: Static public Definition at line 650 of file palman.cpp. { #if DEBUG_PALMAN TRACE( _T("CPalette *PaletteManager::StopPaintPalette(CDC *RenderDC = %d, CPalette *OldPalette = %d, BOOL bForceBackground = %d)\n"), (DWORD)RenderDC, (DWORD)OldPalette, bForceBackground); #endif ERROR2IF (!RenderDC, NULL, "PaletteManager passed NULL RenderRC"); // GAT // if (!(RenderDC->GetDeviceCaps(RASTERCAPS) & RC_PALETTE)) return(NULL); /* if (m_fPaletteLocked) bForceBackground = TRUE; CPalette *PrevPalette = RenderDC->SelectPalette(OldPalette, bForceBackground); RenderDC->RealizePalette(); return PrevPalette; */ }

void PaletteManager::UpdatePalette (  void   )  [static]

Sets up the static main frame palette This will be called whenever the palette needs updating. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 28/5/96 See also: - Definition at line 684 of file palman.cpp. { /* GAT #if DEBUG_PALMAN TRACE( _T("void PaletteManager::UpdatePalette(void)\n")); #endif HPALETTE hPal = (HPALETTE) sm_MainPalette.Detach(); // Detach the palette object if (hPal != NULL) { ::DeleteObject(hPal); hPal = NULL; } sm_bUseMainPalette = FALSE; LPLOGPALETTE lpPal = (LPLOGPALETTE)GRenderRegion::GetRecommendedPalette(); if (lpPal) { TRACEUSER( "Gerry", _T("Got a palette in PaletteManager::UpdatePalette()\n")); // Gavin's palette has 10 unused entries at the front and 10 at the back, which // is dead handy indeed hPal = DIBUtil::MakeIdentityPalette( lpPal->palPalEntry, 256 ); if (hPal) { sm_bUseMainPalette = sm_MainPalette.Attach(hPal); } } */ }

static BOOL PaletteManager::UsePalette (  void   )  [inline, static]

Definition at line 131 of file palman.h. { return(sm_bUseMainPalette); };

---

Member Data Documentation

BOOL PaletteManager::m_fPaletteLocked = FALSE [static, protected]

Definition at line 205 of file palman.h.

BOOL PaletteManager::sm_bUseMainPalette = FALSE [static, protected]

Definition at line 202 of file palman.h.

wxPalette PaletteManager::sm_MainPalette [static, protected]

Definition at line 201 of file palman.h.

---

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

• wxOil/palman.h (r1785/r1282)
• wxOil/palman.cpp (r1785/r1282)

---