//--------------------------------------------------------------------------- // Parser.cpp - parses a "themes.ini" file and builds the ThemeInfo entries //--------------------------------------------------------------------------- #include "stdafx.h" #include "scanner.h" #include "Parser.h" #include "Utils.h" #include "TmUtils.h" #include "TmSchema.h" #include "TmReg.h" //--------------------------------------------------------------------------- //#include "NtlParse.h" #define SYSCOLOR_STRINGS #include "SysColors.h" //--------------------------------------------------------------------------- #define SCHEMA_STRINGS #include "TmSchema.h" // implements GetSchemaInfo() #ifdef DEBUG // TODO: Isn't synchronized anymore (different processes), need to use a volatile reg key instead DWORD g_dwStockSize = 0; #endif static HBITMAP (*s_pfnSetBitmapAttributes)(HBITMAP, DWORD) = NULL; static HBITMAP (*s_pfnClearBitmapAttributes)(HBITMAP, DWORD) = NULL; //-------------------------------------------------------------------- CThemeParser::CThemeParser(BOOL fGlobalTheme) { _pCallBackObj = NULL; _pNameCallBack = NULL; _fGlobalsDefined = FALSE; _fClassSectionDefined = FALSE; _fDefiningColorScheme = FALSE; _fUsingResourceProperties = FALSE; _fDefiningMetrics = FALSE; _fMetricsDefined = FALSE; _fGlobalTheme = FALSE; _crBlend = RGB(0, 0, 0xFF); // Hard code to blue *_szResPropValue = 0; // not yet set #ifdef DEBUG // Provide a means of disabling stock bitmaps BOOL fStock = TRUE; GetCurrentUserThemeInt(L"StockBitmaps", TRUE, &fStock); if (fStock && fGlobalTheme) #else if (fGlobalTheme) #endif { // Just don't use stock bitmaps when not running on Whistler if (s_pfnSetBitmapAttributes != NULL) { _fGlobalTheme = TRUE; } else { HMODULE hMod = ::LoadLibrary(L"GDI32.DLL"); // No need to free if (hMod) { s_pfnSetBitmapAttributes = (HBITMAP (*)(HBITMAP, DWORD)) ::GetProcAddress(hMod, "SetBitmapAttributes"); s_pfnClearBitmapAttributes = (HBITMAP (*)(HBITMAP, DWORD)) ::GetProcAddress(hMod, "ClearBitmapAttributes"); if ((s_pfnSetBitmapAttributes != NULL) && (s_pfnClearBitmapAttributes != NULL)) { _fGlobalTheme = TRUE; } } } } *_szBaseSectionName = 0; *_szFullSectionName = 0; _iColorCount = 0; _iHueCount = 0; _uCharSet = DEFAULT_CHARSET; _iFontNumber = 0; _hinstThemeDll = NULL; } //--------------------------------------------------------------------------- HRESULT CThemeParser::SourceError(int iMsgResId, LPCWSTR pszParam1, LPCWSTR pszParam2) { LPCWSTR pszSrcLine = _scan._szLineBuff; LPCWSTR pszFileName = _scan._szFileName; int iLineNum = _scan._iLineNum; if (*_szResPropValue) // error in localizable property value { pszSrcLine = _szResPropValue; pszFileName = L"StringTable#"; iLineNum = _iResPropId; } HRESULT hr = MakeParseError(iMsgResId, pszParam1, pszParam2, pszFileName, pszSrcLine, iLineNum); return hr; } //--------------------------------------------------------------------------- PRIMVAL CThemeParser::GetPrimVal(LPCWSTR pszName) { int symcnt = _Symbols.GetSize(); for (int i=0; i < symcnt; i++) { if (AsciiStrCmpI(_Symbols[i].csName, pszName)==0) return _Symbols[i].ePrimVal; } return TMT_UNKNOWN; } //--------------------------------------------------------------------------- int CThemeParser::GetSymbolIndex(LPCWSTR pszName) { int symcnt = _Symbols.GetSize(); for (int i=0; i < symcnt; i++) { if (AsciiStrCmpI(_Symbols[i].csName, pszName)==0) return i; } return -1; } //--------------------------------------------------------------------------- HRESULT CThemeParser::AddSymbol(LPCWSTR pszName, SHORT sTypeNum, PRIMVAL ePrimVal) { //---- ensure symbol doesn't already exist ---- for (int i = 0; i < _Symbols.m_nSize; i++) { if (AsciiStrCmpI(_Symbols.m_aT[i].csName, pszName)==0) return SourceError(PARSER_IDS_TYPE_DEFINED_TWICE, pszName); } if (sTypeNum == -1) sTypeNum = (SHORT)_Symbols.GetSize(); SYMBOL symbol; symbol.csName = pszName; symbol.sTypeNum = sTypeNum; symbol.ePrimVal = ePrimVal; _Symbols.Add(symbol); return S_OK; } //--------------------------------------------------------------------------- HRESULT CThemeParser::InitializeSymbols() { _Symbols.RemoveAll(); _StockBitmapCleanupList.RemoveAll(); //---- get tm & comctl symbols ---- const TMSCHEMAINFO *si = GetSchemaInfo(); int cnt = si->iPropCount; const TMPROPINFO *pi = si->pPropTable; //---- first pass - add all symbols except ENUM definitions ---- for (int i=0; i < cnt; i++) { if (pi[i].bPrimVal == TMT_ENUMDEF) continue; if (pi[i].bPrimVal == TMT_ENUMVAL) continue; HRESULT hr = AddSymbol(pi[i].pszName, pi[i].sEnumVal, pi[i].bPrimVal); if (FAILED(hr)) return hr; } //---- second pass - add ENUM definitions ---- int iEnumPropNum = -1; for (int i=0; i < cnt; i++) { if (pi[i].bPrimVal == TMT_ENUMDEF) { int iSymIndex = GetSymbolIndex(pi[i].pszName); if (iSymIndex == -1) // not found - add it as a non-property enum symbol { HRESULT hr = AddSymbol(pi[i].pszName, -1, TMT_ENUM); if (FAILED(hr)) return hr; iSymIndex = GetSymbolIndex(pi[i].pszName); } if (iSymIndex > -1) iEnumPropNum = _Symbols[iSymIndex].sTypeNum; else iEnumPropNum = -1; } else if (pi[i].bPrimVal == TMT_ENUMVAL) { ENUMVAL enumval; enumval.csName = pi[i].pszName; enumval.iSymbolIndex = iEnumPropNum; enumval.iValue = pi[i].sEnumVal; _EnumVals.Add(enumval); } } return S_OK; } //--------------------------------------------------------------------------- HRESULT CThemeParser::ParseDocSection() { _scan.ForceNextLine(); // get line after section line //---- just skip over all lines in this section ---- while (1) { WCHAR szNameBuff[_MAX_PATH+1]; if (_scan.GetChar('[')) // start of new section break; if (! _scan.GetId(szNameBuff)) return SourceError(PARSER_IDS_EXPECTED_PROP_NAME); if (! _scan.GetChar('=')) return SourceError(PARSER_IDS_EXPECTED_EQUALS_SIGN); int cnt = _Symbols.GetSize(); for (int i=0; i < cnt; i++) { if (AsciiStrCmpI(_Symbols[i].csName, szNameBuff)==0) break; } int symtype; if (i == cnt) symtype = TMT_STRING; // unknown string property else symtype = _Symbols[i].sTypeNum; HRESULT hr; //---- check to see if caller is querying for a doc property ---- if ((_dwParseFlags & PTF_QUERY_DOCPROPERTY) && (lstrcmpi(_pszDocProperty, szNameBuff)==0)) hr = ParseStringValue(symtype, _pszResult, _dwMaxResultChars); else hr = ParseStringValue(symtype); if (FAILED(hr)) return hr; _scan.ForceNextLine(); } //---- done with [documentation] section - turn off callback flag for properties ---- _dwParseFlags &= (~PTF_CALLBACK_DOCPROPERTIES); return S_OK; } //--------------------------------------------------------------------------- HRESULT CThemeParser::ParseClassSectionName(LPCWSTR pszFirstName, LPWSTR appsym) { //---- validate section name ---- // // optional: appsym:: // _szClassName // optional: .partsym WCHAR partsym[_MAX_PATH+1]; WCHAR statesym[_MAX_PATH+1]; *appsym = 0; *partsym = 0; _iPartId = -1; _iStateId = -1; //---- copy the section name for callbacks ---- wsprintf(_szFullSectionName, L"%s%s", pszFirstName, _scan._p); WCHAR *p = wcschr(_szFullSectionName, ']'); if (p) *p = 0; HRESULT hr; hr = hr_lstrcpy(_szClassName, pszFirstName, ARRAYSIZE(_szClassName)); if (FAILED(hr)) return hr; if (_scan.GetChar(':')) { hr = hr_lstrcpy(appsym, _szClassName, MAX_PATH); if (FAILED(hr)) return hr; if (! _scan.GetChar(':')) return SourceError(PARSER_IDS_EXPECTED_DOUBLE_COLON); if (! _scan.GetId(_szClassName)) return SourceError(PARSER_IDS_MISSING_SECT_HDR_NAME); } else *appsym = 0; _fDefiningMetrics = (AsciiStrCmpI(_szClassName, L"SysMetrics")==0); if ((_fDefiningMetrics) && (*appsym)) return SourceError(PARSER_IDS_NOT_ALLOWED_SYSMETRICS); if (_scan.GetChar('.')) // an optional part id { //---- ensure a enum exists: Parts ---- WCHAR classparts[_MAX_PATH+1]; wsprintf(classparts, L"%sParts", _szClassName); int iSymIndex = GetSymbolIndex(classparts); if (iSymIndex == -1) // doesn't exist return SourceError(PARSER_IDS_PARTS_NOT_DEFINED, _szClassName); //---- _scan the part name ---- if (! _scan.GetId(partsym)) return SourceError(PARSER_IDS_MISSING_SECT_HDR_PART); //---- validate that it is a value for the Parts ---- hr = ValidateEnumSymbol(partsym, iSymIndex, &_iPartId); if (FAILED(hr)) return hr; } if (_scan.GetChar('(')) // an optional state { //---- ensure a enum exists: States ---- WCHAR statesname[_MAX_PATH+1]; WCHAR *pszBaseName; if (_iPartId == -1) pszBaseName = _szClassName; else pszBaseName = partsym; wsprintf(statesname, L"%sStates", pszBaseName); int iSymIndex = GetSymbolIndex(statesname); if (iSymIndex == -1) return SourceError(PARSER_IDS_STATES_NOT_DEFINED, pszBaseName); if (! _scan.GetId(statesym)) return SourceError(PARSER_IDS_MISSING_SECT_HDR_STATE); hr = ValidateEnumSymbol(statesym, iSymIndex, &_iStateId); if (FAILED(hr)) return hr; if (! _scan.GetChar(')')) return SourceError(PARSER_IDS_EXPECTED_RPAREN); } if (_iPartId > -1) { _iPartId = _EnumVals[_iPartId].iValue; lstrcpy_truncate(_szBaseSectionName, partsym, ARRAYSIZE(_szBaseSectionName)); } else // not specified { lstrcpy_truncate(_szBaseSectionName, _szClassName, ARRAYSIZE(_szBaseSectionName)); _iPartId = 0; } if (_iStateId > -1) _iStateId = _EnumVals[_iStateId].iValue; else _iStateId = 0; if (! _scan.GetChar(']')) return SourceError(PARSER_IDS_EXPECTED_END_OF_SECTION); return S_OK; } //--------------------------------------------------------------------------- HRESULT CThemeParser::ValidateEnumSymbol(LPCWSTR pszName, int iSymType, int *pIndex) { for (int i = 0; i < _EnumVals.m_nSize; i++) { if (AsciiStrCmpI(_EnumVals.m_aT[i].csName, pszName)==0) { if (_EnumVals.m_aT[i].iSymbolIndex == iSymType) { if (pIndex) *pIndex = i; return S_OK; } } } return SourceError(PARSER_IDS_NOT_ENUM_VALNAME, pszName, (LPCWSTR)_Symbols[iSymType].csName); } //--------------------------------------------------------------------------- HRESULT CThemeParser::AddThemeData(int iTypeNum, PRIMVAL ePrimVal, const void *pData, DWORD dwLen) { //Log("AddThemeData: typenum=%d, len=%d, data=0x%x", iTypeNum, dwLen, pData); if (! _pCallBackObj) return S_FALSE; HRESULT hr = _pCallBackObj->AddData((SHORT)iTypeNum, ePrimVal, pData, dwLen); if (FAILED(hr)) return SourceError(PARSER_IDS_THEME_TOO_BIG); return S_OK; } //--------------------------------------------------------------------------- HRESULT CThemeParser::ParseEnumValue(int iSymType) { WCHAR valbuff[_MAX_PATH+1]; HRESULT hr; int value; if (! _scan.GetId(valbuff)) return SourceError(PARSER_IDS_ENUM_VALNAME_EXPECTED); int index; hr = ValidateEnumSymbol(valbuff, iSymType, &index); if (FAILED(hr)) return hr; value = _EnumVals[index].iValue; hr = AddThemeData(iSymType, TMT_ENUM, &value, sizeof(value)); if (FAILED(hr)) return hr; return S_OK; } //--------------------------------------------------------------------------- HRESULT CThemeParser::GetEnumValue(LPCWSTR pszEnumName, LPCWSTR pszEnumValName, int *piValue) { if (! pszEnumName ) return SourceError(PARSER_IDS_ENUM_NOT_DEFINED); //---- lookup the Enum Name ---- int cnt = _Symbols.GetSize(); for (int i=0; i < cnt; i++) { if (AsciiStrCmpI(_Symbols[i].csName, pszEnumName)==0) break; } if (i == cnt) return SourceError(PARSER_IDS_NOT_ENUM_VALNAME, pszEnumValName, pszEnumName); int iSymType = _Symbols[i].sTypeNum; //---- lookup the Enum value name ---- int index; HRESULT hr = ValidateEnumSymbol(pszEnumValName, iSymType, &index); if (FAILED(hr)) return hr; *piValue = _EnumVals[index].iValue; return S_OK; } //--------------------------------------------------------------------------- HRESULT CThemeParser::ParseStringValue(int iSymType, LPWSTR pszBuff, DWORD dwMaxBuffChars) { HRESULT hr; //---- just store the raw string ---- _scan.SkipSpaces(); if (_fDefiningMetrics) { if ((iSymType < TMT_FIRSTSTRING) || (iSymType > TMT_LASTSTRING)) return SourceError(PARSER_IDS_NOT_ALLOWED_SYSMETRICS); } if (pszBuff) // special call { hr = hr_lstrcpy(pszBuff, _scan._p, dwMaxBuffChars); if (FAILED(hr)) return hr; } else { int len = 1 + lstrlen(_scan._p); hr = AddThemeData(iSymType, TMT_STRING, _scan._p, len*sizeof(WCHAR)); if (FAILED(hr)) return hr; } if ((iSymType >= TMT_FIRST_RCSTRING_NAME) && (iSymType <= TMT_LAST_RCSTRING_NAME)) { if ((_pNameCallBack) && (_dwParseFlags & PTF_CALLBACK_DOCPROPERTIES)) { int index = iSymType - TMT_FIRST_RCSTRING_NAME; BOOL fContinue = (*_pNameCallBack)(TCB_DOCPROPERTY, _scan._p, NULL, NULL, index, _lNameParam); if (! fContinue) return MakeErrorParserLast(); } } //---- advance _scanner to end of line ---- _scan._p += lstrlen(_scan._p); return S_OK; } //--------------------------------------------------------------------------- HRESULT CThemeParser::ParseIntValue(int iSymType, int *piValue) { int value; if (! _scan.GetNumber(&value)) return SourceError(PARSER_IDS_INT_EXPECTED); if (piValue) // special call *piValue = value; else { HRESULT hr = AddThemeData(iSymType, TMT_INT, &value, sizeof(value)); if (FAILED(hr)) return hr; } if (iSymType == TMT_CHARSET) { if (_iFontNumber) return SourceError(PARSER_IDS_CHARSETFIRST); if (_fGlobalsDefined) return SourceError(PARSER_IDS_CHARSET_GLOBALS_ONLY); _uCharSet = (UCHAR) value; } if (iSymType == TMT_MINCOLORDEPTH) { if ((_pNameCallBack) && (_dwParseFlags & PTF_CALLBACK_MINCOLORDEPTH)) { BOOL fContinue = (*_pNameCallBack)(TCB_MINCOLORDEPTH, _scan._szFileName, NULL, NULL, value, _lNameParam); if (! fContinue) return MakeErrorParserLast(); } } return S_OK; } //--------------------------------------------------------------------------- HRESULT CThemeParser::ParseBoolValue(int iSymType, LPCWSTR pszPropertyName) { WCHAR valbuff[_MAX_PATH+1]; BYTE bBoolVal; if (! _scan.GetId(valbuff)) return SourceError(PARSER_IDS_BOOL_EXPECTED); if (AsciiStrCmpI(valbuff, L"true")==0) bBoolVal = 1; else if (AsciiStrCmpI(valbuff, L"false")==0) bBoolVal = 0; else return SourceError(PARSER_IDS_EXPECTED_TRUE_OR_FALSE); if (_fDefiningMetrics) { if ((iSymType < TMT_FIRSTBOOL) || (iSymType > TMT_LASTBOOL)) return SourceError(PARSER_IDS_NOT_ALLOWED_SYSMETRICS); } //---- special handling for "MirrorImage" property ---- if (iSymType == TMT_MIRRORIMAGE) { //---- handle MirrorImage callbacks (packtime) ---- if ((_pNameCallBack) && (_dwParseFlags & PTF_CALLBACK_LOCALIZATIONS)) { BOOL fContinue = (*_pNameCallBack)(TCB_MIRRORIMAGE, _szClassName, _szFullSectionName, pszPropertyName, _iPartId, (LPARAM)bBoolVal); if (! fContinue) return MakeErrorParserLast(); } //---- handle getting value from string table (loadtime) ---- if (_fUsingResourceProperties) // substitute resource value { WCHAR szValue[MAX_PATH]; HRESULT hr = GetResourceProperty(pszPropertyName, szValue, ARRAYSIZE(szValue)); if (SUCCEEDED(hr)) { bBoolVal = (*szValue == '1'); } else { hr = S_OK; // non-fatal error } } } HRESULT hr = AddThemeData(iSymType, TMT_BOOL, &bBoolVal, sizeof(bBoolVal)); if (FAILED(hr)) return hr; return S_OK; } //--------------------------------------------------------------------------- COLORREF CThemeParser::ApplyColorSubstitution(COLORREF crOld) { //---- apply SOLID color substitutions ---- for (int i=0; i < _iColorCount; i++) { if (crOld == _crFromColors[i]) return _crToColors[i]; } //---- apply HUE color substitutions ---- WORD wHue, wLum, wSat; RGBtoHLS(crOld, &wHue, &wLum, &wSat); for (i=0; i < _iHueCount; i++) { if (wHue == _bFromHues[i]) // hues match { COLORREF crNew = HLStoRGB(_bToHues[i], wLum, wSat); // substitute new hue return crNew; } } return crOld; } //--------------------------------------------------------------------------- void CThemeParser::CleanupStockBitmaps() { if (s_pfnClearBitmapAttributes) { for (int i=0; i < _StockBitmapCleanupList.m_nSize; i++) { HBITMAP hbm = (*s_pfnClearBitmapAttributes)(_StockBitmapCleanupList[i], SBA_STOCK); if (hbm) { DeleteObject(hbm); } else { // We are totally out of luck today aren't we Log(LOG_TMBITMAP, L"Failed to clear stock bitmap on cleanup"); } } } _StockBitmapCleanupList.RemoveAll(); } //--------------------------------------------------------------------------- HRESULT CThemeParser::ParseColorValue(int iSymType, COLORREF *pcrValue, COLORREF *pcrValue2) { COLORREF color; HRESULT hr = S_OK; #if 0 if (_scan.GetId(idbuff)) // system color { hr = ParseSysColor(idbuff, &color); if (FAILED(hr)) goto exit; } else #endif { const WCHAR *parts[] = {L"r", L"g", L"b"}; int ints[3] = {0}; hr = GetIntList(ints, parts, ARRAYSIZE(ints), 0, 255); if (FAILED(hr)) { hr = SourceError(PARSER_IDS_BAD_COLOR_VALUE); goto exit; } color = RGB(ints[0], ints[1], ints[2]); } if (! _fDefiningColorScheme) color = ApplyColorSubstitution(color); if (_fDefiningMetrics) { if ((iSymType < TMT_FIRSTCOLOR) || (iSymType > TMT_LASTCOLOR)) { hr = SourceError(PARSER_IDS_NOT_ALLOWED_SYSMETRICS); goto exit; } } if (pcrValue2) { *pcrValue2 = color; } if (pcrValue) // special call *pcrValue = color; else { hr = AddThemeData(iSymType, TMT_COLOR, &color, sizeof(color)); if (FAILED(hr)) goto exit; } exit: return hr; } //--------------------------------------------------------------------------- HRESULT CThemeParser::ParseMarginsValue(int iSymType) { const WCHAR *parts[] = {L"lw", L"rw", L"th", L"bh"}; int ints[4]; HRESULT hr = GetIntList(ints, parts, ARRAYSIZE(ints), 0, 0); if (FAILED(hr)) return SourceError(PARSER_IDS_BAD_MARGINS_VALUE); hr = AddThemeData(iSymType, TMT_MARGINS, ints, sizeof(ints)); if (FAILED(hr)) return hr; return S_OK; } //--------------------------------------------------------------------------- HRESULT CThemeParser::ParseIntListValue(int iSymType) { INTLIST IntList; HRESULT hr = S_OK; //---- unnamed parts ---- for (int i=0; i < MAX_INTLIST_COUNT; i++) { if (! _scan.GetNumber(&IntList.iValues[i])) { if (_scan.EndOfLine()) break; hr = SourceError(PARSER_IDS_NUMBER_EXPECTED, _scan._p); goto exit; } _scan.GetChar(','); // optional comma } IntList.iValueCount = i; hr = AddThemeData(iSymType, TMT_INTLIST, &IntList, (1+i)*sizeof(int)); if (FAILED(hr)) goto exit; exit: return hr; } //--------------------------------------------------------------------------- HRESULT CThemeParser::PackageNtlCode(LPCWSTR szFileName) { #if 0 // not yet supported HRESULT hr = S_OK; RESOURCE WCHAR *pszSource = NULL; BYTE *pPCode = NULL; int iPCodeLen; CNtlParser NtlParser; //---- add TMT_NTLDATA data ---- WCHAR drive[_MAX_DRIVE], dir[_MAX_DIR], fname[_MAX_FNAME], ext[_MAX_EXT]; _wsplitpath(szFileName, drive, dir, fname, ext); WCHAR szResName[_MAX_PATH+1]; wsprintf(szResName, L"%s_NTL", fname); hr = AllocateTextResource(_hinstThemeDll, szResName, &pszSource); if (FAILED(hr)) goto exit; hr = NtlParser.ParseBuffer(pszSource, szFileName, this, &pPCode, &iPCodeLen); if (FAILED(hr)) goto exit; hr = AddThemeData(TMT_NTLDATA, TMT_NTLDATA, pPCode, iPCodeLen); if (FAILED(hr)) goto exit; exit: if (pszSource) delete [] pszSource; if (pPCode) delete [] pPCode; return hr; #else return E_NOTIMPL; #endif } //--------------------------------------------------------------------------- HRESULT CThemeParser::PackageImageData(LPCWSTR szFileNameR, LPCWSTR szFileNameG, LPCWSTR szFileNameB, int iDibPropNum) { HRESULT hr = S_OK; //---- add TMT_DIBDATA data ---- WCHAR drive[_MAX_DRIVE], dir[_MAX_DIR], fname[_MAX_FNAME], ext[_MAX_EXT]; _wsplitpath(szFileNameR, drive, dir, fname, ext); WCHAR szResName[_MAX_PATH+1]; DWORD len = lstrlen(dir); if ((len) && (dir[len-1] == L'\\')) { dir[len-1] = L'_'; } wsprintf(szResName, L"%s%s_BMP", dir, fname); HBITMAP hBitmapR = (HBITMAP) LoadImage(_hinstThemeDll, szResName, IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION); if (!hBitmapR) return SourceError(PARSER_IDS_NOOPEN_IMAGE, szResName); //---- convert to DIBDATA ---- CBitmapPixels pixels; DWORD *pPixelQuads; int iWidth, iHeight, iBytesPerPixel, iBytesPerRow, iPreviousBytesPerPixel; BOOL fUseDrawStream = TRUE; #if 0 // keep this in sync with #if in imagefile.cpp //---- force old code drawing ---- fUseDrawStream = FALSE; #endif // Allocate a TMBITMAPHEADER in addition to the bitmap hr = pixels.OpenBitmap(NULL, hBitmapR, TRUE, &pPixelQuads, &iWidth, &iHeight, &iBytesPerPixel, &iBytesPerRow, &iPreviousBytesPerPixel, TMBITMAPSIZE); if (FAILED(hr)) { DeleteObject(hBitmapR); return hr; } BOOL fWasAlpha = (iPreviousBytesPerPixel == 4); #if 0 //---- apply loaded color scheme, if any ---- if ((szFileNameG && szFileNameG[0]) && (szFileNameB && szFileNameB[0])) { _wsplitpath(szFileNameG, drive, dir, fname, ext); len = lstrlen(dir); if ((len) && (dir[len-1] == L'\\')) { dir[len-1] = L'_'; } wsprintf(szResName, L"%s%s_BMP", dir, fname); HBITMAP hBitmapG = (HBITMAP) LoadImage(_hinstThemeDll, szResName, IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION); _wsplitpath(szFileNameB, drive, dir, fname, ext); len = lstrlen(dir); if ((len) && (dir[len-1] == L'\\')) { dir[len-1] = L'_'; } wsprintf(szResName, L"%s%s_BMP", dir, fname); HBITMAP hBitmapB = (HBITMAP) LoadImage(_hinstThemeDll, szResName, IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION); DWORD dwRWeight = GetRValue(_crBlend); DWORD dwGWeight = GetGValue(_crBlend); DWORD dwBWeight = GetBValue(_crBlend); DWORD *pPixelQuadsG = NULL; DWORD *pPixelQuadsB = NULL; if (hBitmapG && hBitmapB) { HDC hdc = GetDC(NULL); if (hdc) { int dwLen = iWidth * iHeight; pPixelQuadsG = new DWORD[dwLen]; if (pPixelQuadsG) { pPixelQuadsB = new DWORD[dwLen]; if (pPixelQuadsB) { BITMAPINFO bi = {0}; bi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER); bi.bmiHeader.biWidth = iWidth; bi.bmiHeader.biHeight = iHeight; bi.bmiHeader.biPlanes = 1; bi.bmiHeader.biBitCount = 32; bi.bmiHeader.biCompression = BI_RGB; if (GetDIBits(hdc, hBitmapG, 0, iHeight, pPixelQuadsG, &bi, DIB_RGB_COLORS) && GetDIBits(hdc, hBitmapB, 0, iHeight, pPixelQuadsB, &bi, DIB_RGB_COLORS)) { DWORD* pdwR = pPixelQuads; DWORD* pdwG = pPixelQuadsG; DWORD* pdwB = pPixelQuadsB; for (int i = 0; i < dwLen; i++) { if ((*pdwR & 0xffffff) != RGB(255,0,255)) { *pdwR = (*pdwR & 0xff000000) | RGB(min(((GetRValue(*pdwR) * dwRWeight) + (GetRValue(*pdwG) * dwGWeight) + (GetRValue(*pdwB) * dwBWeight)) >> 8, 0xff), min(((GetGValue(*pdwR) * dwRWeight) + (GetGValue(*pdwG) * dwGWeight) + (GetGValue(*pdwB) * dwBWeight)) >> 8, 0xff), min(((GetBValue(*pdwR) * dwRWeight) + (GetBValue(*pdwG) * dwGWeight) + (GetBValue(*pdwB) * dwBWeight)) >> 8, 0xff)); } pdwR++; pdwG++; pdwB++; } } delete[] pPixelQuadsB; } delete[] pPixelQuadsG; } ReleaseDC(NULL, hdc); } } else { OutputDebugString(L"Failed to load bitmaps"); } if (hBitmapG) { DeleteObject(hBitmapG); hBitmapG = NULL; } if (hBitmapB) { DeleteObject(hBitmapB); hBitmapB = NULL; } } #endif BITMAPINFOHEADER *pBitmapHdr = pixels._hdrBitmap; //---- if alpha present, pre-multiply RGB values (as per AlphaBlend()) API ---- BOOL fTrueAlpha = FALSE; // We keep per-pixel alpha bitmaps as 32 bits DIBs, not compatible bitmaps if (fWasAlpha) { fTrueAlpha = (PreMultiplyAlpha(pPixelQuads, pBitmapHdr->biWidth, pBitmapHdr->biHeight) != 0); #ifdef DEBUG if (!fTrueAlpha) Log(LOG_TMBITMAP, L"%s is 32 bits, but not true alpha", szFileNameR); #endif } HBITMAP hbmStock = NULL; BOOL fFlipped = FALSE; if (fUseDrawStream && _fGlobalTheme) { HDC hdc = ::GetWindowDC(NULL); if (hdc) { typedef struct { BITMAPINFOHEADER bmih; ULONG masks[3]; } BITMAPHEADER; BITMAPHEADER bmi; bmi.bmih.biSize = sizeof(bmi.bmih); bmi.bmih.biWidth = pBitmapHdr->biWidth; bmi.bmih.biHeight = pBitmapHdr->biHeight; bmi.bmih.biPlanes = 1; bmi.bmih.biBitCount = 32; bmi.bmih.biCompression = BI_BITFIELDS; bmi.bmih.biSizeImage = 0; bmi.bmih.biXPelsPerMeter = 0; bmi.bmih.biYPelsPerMeter = 0; bmi.bmih.biClrUsed = 3; bmi.bmih.biClrImportant = 0; bmi.masks[0] = 0xff0000; // red bmi.masks[1] = 0x00ff00; // green bmi.masks[2] = 0x0000ff; // blue hbmStock = CreateDIBitmap(hdc, &bmi.bmih, CBM_INIT | CBM_CREATEDIB , pPixelQuads, (BITMAPINFO*)&bmi.bmih, DIB_RGB_COLORS); // Need to Force 32-bit DIBs in Multi-mon mode // Make it match the screen resolution setting if it is not an AlphaBlended image #if 0 if (hbmStock && !fTrueAlpha && !GetSystemMetrics(SM_REMOTESESSION)) { BOOL fForce16 = FALSE; //(iPreviousBytesPerPixel <= 2); HDC hdcTemp = CreateCompatibleDC(hdc); if (hdcTemp) { HBITMAP hbmTemp = CreateCompatibleBitmap(hdc, 2, 2); if (hbmTemp) { BITMAPINFOHEADER bi = {0}; bi.biSize = sizeof(bi); GetDIBits(hdcTemp, hbmTemp, 0, 1, NULL, (LPBITMAPINFO) &bi, DIB_RGB_COLORS); /*WCHAR szTemp[256]; wsprintf(szTemp, L"We're in %d-bit mode.\n", bi.biBitCount); OutputDebugString(szTemp);*/ bmi.bmih.biSize = sizeof(bmi.bmih); bmi.bmih.biWidth = pBitmapHdr->biWidth; bmi.bmih.biHeight = pBitmapHdr->biHeight; bmi.bmih.biPlanes = 1; bmi.bmih.biBitCount = 32; bmi.bmih.biCompression = BI_BITFIELDS; bmi.bmih.biSizeImage = 0; bmi.bmih.biXPelsPerMeter = 0; bmi.bmih.biYPelsPerMeter = 0; bmi.bmih.biClrUsed = 3; bmi.bmih.biClrImportant = 0; if ((bi.biBitCount == 16) || (fForce16)) { COLORREF crActual = 0; if (!fForce16) { HBITMAP hbmOld = (HBITMAP)SelectObject(hdcTemp, hbmTemp); SetPixel(hdcTemp, 0, 0, RGB(0, 255, 0)); crActual = GetPixel(hdcTemp, 0, 0); SelectObject(hdcTemp, hbmOld); } bmi.bmih.biBitCount = 16; if (fForce16 || (GetGValue(crActual) == 252))// Do a lame check for 5-6-5 { bmi.masks[0] = 0xF800; bmi.masks[1] = 0x07E0; bmi.masks[2] = 0x001F; } else { bmi.masks[0] = 0x7C00; // 5-5-5 mode bmi.masks[1] = 0x03E0; bmi.masks[2] = 0x001F; } } else if (bi.biBitCount == 24) { bmi.bmih.biBitCount = 24; bmi.masks[0] = 0xff0000; // red bmi.masks[1] = 0x00ff00; // green bmi.masks[2] = 0x0000ff; // blue } if (bmi.bmih.biBitCount != 32) { HBITMAP hbmNewStock = CreateDIBitmap(hdc, &bmi.bmih, CBM_INIT | CBM_CREATEDIB , pPixelQuads, (BITMAPINFO*)&bmi.bmih, DIB_RGB_COLORS); if (hbmNewStock) { HDC hdcNewStock = CreateCompatibleDC(hdc); if (hdcNewStock) { HBITMAP hbmOld = (HBITMAP)SelectObject(hdcNewStock, hbmNewStock); HBITMAP hbmOld2 = (HBITMAP)SelectObject(hdcTemp, hbmStock); BitBlt(hdcNewStock, 0, 0, pBitmapHdr->biWidth, pBitmapHdr->biHeight, hdcTemp, 0, 0, SRCCOPY); SelectObject(hdcTemp, hbmOld2); SelectObject(hdcNewStock, hbmOld); DeleteObject(hbmStock); hbmStock = hbmNewStock; } else { DeleteObject(hbmNewStock); } } } DeleteObject(hbmTemp); } DeleteDC(hdcTemp); } } #endif ::ReleaseDC(NULL, hdc); } if (!hbmStock) { hr = E_OUTOFMEMORY; } else { ASSERT(s_pfnSetBitmapAttributes != NULL); ASSERT(s_pfnClearBitmapAttributes != NULL); HBITMAP hbmOld = hbmStock; hbmStock = (*s_pfnSetBitmapAttributes)(hbmStock, SBA_STOCK); if (hbmStock == NULL) { DeleteObject(hbmOld); Log(LOG_ALWAYS, L"UxTheme: SetBitmapAttributes failed in CParser::PackageImageData"); hr = E_FAIL; } else { _StockBitmapCleanupList.Add(hbmStock); #ifdef DEBUG BITMAP bm; ::GetObject(hbmStock, sizeof bm, &bm); g_dwStockSize += bm.bmWidthBytes * bm.bmHeight; //Log(LOG_TMBITMAP, L"Created %d bytes of stock bitmaps, last is %8X", g_dwStockSize, hbmStock); #endif } } } ::DeleteObject(hBitmapR); // Fill in the TMBITMAPHEADER structure if (SUCCEEDED(hr)) { TMBITMAPHEADER *psbh = (TMBITMAPHEADER*) pixels.Buffer(); psbh->dwSize = TMBITMAPSIZE; psbh->fFlipped = fFlipped; psbh->hBitmap = hbmStock; psbh->fTrueAlpha = fTrueAlpha; psbh->dwColorDepth = iBytesPerPixel * 8; psbh->iBrushesOffset = 0; psbh->nBrushes = 0; if (hbmStock == NULL) // Pass DIB bits { int size = psbh->dwSize + sizeof(BITMAPINFOHEADER) + iHeight * iBytesPerRow; hr = AddThemeData(iDibPropNum, TMT_DIBDATA, psbh, size); } else // Pass the TMBITMAPHEADER structure only { hr = AddThemeData(iDibPropNum, TMT_DIBDATA, psbh, psbh->dwSize); } } return hr; } //--------------------------------------------------------------------------- HRESULT CThemeParser::ParseFileNameValue(int iSymType, LPWSTR pszBuff, DWORD dwMaxBuffChars) { WCHAR szFileNameR[_MAX_PATH+1] = {0}; WCHAR szFileNameG[_MAX_PATH+1] = {0}; WCHAR szFileNameB[_MAX_PATH+1] = {0}; HRESULT hr = S_OK; if (! _scan.GetFileName(szFileNameR, ARRAYSIZE(szFileNameR))) { hr = SourceError(PARSER_IDS_ENUM_VALNAME_EXPECTED); goto exit; } if (_scan.GetFileName(szFileNameG, ARRAYSIZE(szFileNameG))) { _scan.GetFileName(szFileNameB, ARRAYSIZE(szFileNameB)); } if (pszBuff) // special call { hr = hr_lstrcpy(pszBuff, szFileNameR, dwMaxBuffChars); if (FAILED(hr)) goto exit; } else if (_pCallBackObj) // emit data { //---- add TMT_FILENAME data ---- hr = AddThemeData(iSymType, TMT_FILENAME, &szFileNameR, sizeof(WCHAR)*(1+lstrlen(szFileNameR))); if (FAILED(hr)) goto exit; if ((szFileNameG[0] != 0) && (szFileNameB[0] != 0)) { hr = AddThemeData(iSymType, TMT_FILENAME, &szFileNameG, sizeof(WCHAR)*(1+lstrlen(szFileNameR))); if (FAILED(hr)) goto exit; hr = AddThemeData(iSymType, TMT_FILENAME, &szFileNameB, sizeof(WCHAR)*(1+lstrlen(szFileNameR))); if (FAILED(hr)) goto exit; } if (iSymType == TMT_IMAGEFILE) { hr = PackageImageData(szFileNameR, szFileNameG, szFileNameB, TMT_DIBDATA); } else if (iSymType == TMT_GLYPHIMAGEFILE) { hr = PackageImageData(szFileNameR, szFileNameG, szFileNameB, TMT_GLYPHDIBDATA); } else if (iSymType == TMT_STOCKIMAGEFILE) { hr = PackageImageData(szFileNameR, szFileNameG, szFileNameB, TMT_STOCKDIBDATA); } else if ((iSymType >= TMT_IMAGEFILE1) && (iSymType <= TMT_IMAGEFILE5)) { hr = PackageImageData(szFileNameR, szFileNameG, szFileNameB, TMT_DIBDATA1 + (iSymType-TMT_IMAGEFILE1)); } #if 0 // not yet implemented else if (iSymType == TMT_NTLFILE) { hr = PackageNtlCode(szFileNameR); } #endif if (FAILED(hr)) goto exit; } if ((_pNameCallBack) && (_dwParseFlags & PTF_CALLBACK_FILENAMES)) { BOOL fContinue = (*_pNameCallBack)(TCB_FILENAME, szFileNameR, NULL, NULL, iSymType, _lNameParam); if (! fContinue) { hr = MakeErrorParserLast(); goto exit; } if (szFileNameG[0] && szFileNameB[0]) { fContinue = (*_pNameCallBack)(TCB_FILENAME, szFileNameG, NULL, NULL, iSymType, _lNameParam); if (! fContinue) { hr = MakeErrorParserLast(); goto exit; } fContinue = (*_pNameCallBack)(TCB_FILENAME, szFileNameB, NULL, NULL, iSymType, _lNameParam); if (! fContinue) { hr = MakeErrorParserLast(); goto exit; } } } exit: return hr; } //--------------------------------------------------------------------------- HRESULT CThemeParser::ParseSizeValue(int iSymType) { int val; if (! _scan.GetNumber(&val)) return SourceError(PARSER_IDS_INT_EXPECTED); int pixels; HRESULT hr = ParseSizeInfoUnits(val, L"pixels", &pixels); if (FAILED(hr)) return hr; if (_fDefiningMetrics) { if ((iSymType < TMT_FIRSTSIZE) || (iSymType > TMT_LASTSIZE)) return SourceError(PARSER_IDS_NOT_ALLOWED_SYSMETRICS); } hr = AddThemeData(iSymType, TMT_SIZE, &pixels, sizeof(pixels)); if (FAILED(hr)) return hr; return S_OK; } //--------------------------------------------------------------------------- HRESULT CThemeParser::ParsePositionValue(int iSymType) { const WCHAR *parts[] = {L"x", L"y"}; int ints[2]; HRESULT hr = GetIntList(ints, parts, ARRAYSIZE(ints), 0, 0); if (FAILED(hr)) return SourceError(PARSER_IDS_ILLEGAL_SIZE_VALUE); hr = AddThemeData(iSymType, TMT_POSITION, ints, sizeof(ints)); if (FAILED(hr)) return hr; return S_OK; } //--------------------------------------------------------------------------- HRESULT CThemeParser::ParseRectValue(int iSymType, LPCWSTR pszPropertyName) { const WCHAR *parts[] = {L"l", L"t", L"r", L"b"}; int ints[4]; HRESULT hr = GetIntList(ints, parts, ARRAYSIZE(ints), 0, 0); if (FAILED(hr)) return SourceError(PARSER_IDS_ILLEGAL_RECT_VALUE); //---- special handling for localizable RECT properties ---- if (iSymType == TMT_DEFAULTPANESIZE) { //---- handle localizable callback (packtime) ---- if ((_pNameCallBack) && (_dwParseFlags & PTF_CALLBACK_LOCALIZATIONS)) { BOOL fContinue = (*_pNameCallBack)(TCB_LOCALIZABLE_RECT, _szClassName, _szFullSectionName, pszPropertyName, _iPartId, (LPARAM)(RECT *)ints); if (! fContinue) return MakeErrorParserLast(); } //---- handle getting value from string table (loadtime) ---- if (_fUsingResourceProperties) // substitute resource value { WCHAR szValue[MAX_PATH]; HRESULT hr = GetResourceProperty(pszPropertyName, szValue, ARRAYSIZE(szValue)); if (SUCCEEDED(hr)) { RECT rc; int cnt = swscanf(szValue, L"%d, %d, %d, %d", &rc.left, &rc.top, &rc.right, &rc.bottom); if (cnt == 4) { //---- override with localized values ---- memcpy(ints, &rc, sizeof(int)*4); } } else { hr = S_OK; // non-fatal error } } } hr = AddThemeData(iSymType, TMT_RECT, ints, sizeof(ints)); if (FAILED(hr)) return hr; return S_OK; } //--------------------------------------------------------------------------- HRESULT CThemeParser::ParseSizeInfoUnits(int iVal, LPCWSTR pszDefaultUnits, int *piPixels) { WCHAR units[_MAX_PATH+1]; HRESULT hr; //---- NOTE: this uses the THEME_DPI (96) for all size conversions! ---- //---- this gives us consistent LOGFONT, etc. across diff. resolution screens ---- //---- with the promise that we will do just-in-time DPI scaling, when appropriate ---- if (! _scan.GetId(units)) { hr = hr_lstrcpy(units, pszDefaultUnits, ARRAYSIZE(units)); if (FAILED(hr)) return hr; } if (AsciiStrCmpI(units, L"pixels")==0) ; // already correct else if (AsciiStrCmpI(units, L"twips")==0) { iVal = -MulDiv(iVal, THEME_DPI, 20*72); } else if (AsciiStrCmpI(units, L"points")==0) { iVal = -MulDiv(iVal, THEME_DPI, 72); } else return SourceError(PARSER_IDS_UNKNOWN_SIZE_UNITS, units); *piPixels = iVal; return S_OK; } //--------------------------------------------------------------------------- HRESULT CThemeParser::ParseSysColor(LPCWSTR szId, COLORREF *pcrValue) { if (! _scan.EndOfLine()) return SourceError(PARSER_IDS_END_OF_LINE_EXPECTED); //---- look up value of id ---- int index = GetSymbolIndex(szId); if (index == -1) return SourceError(PARSER_IDS_UNKNOWN_SYS_COLOR); int iPropNum = _Symbols[index].sTypeNum; if ((iPropNum < TMT_FIRSTCOLOR) || (iPropNum > TMT_LASTCOLOR)) return SourceError(PARSER_IDS_UNKNOWN_SYS_COLOR); *pcrValue = GetSysColor(iPropNum-TMT_FIRSTCOLOR); return S_OK; } //--------------------------------------------------------------------------- HRESULT CThemeParser::ParseSysFont(LOGFONT *pFont) { if (! _scan.GetChar('[')) return SourceError(PARSER_IDS_LBRACKET_EXPECTED); WCHAR idbuff[_MAX_PATH+1]; if (! _scan.GetId(idbuff)) return SourceError(PARSER_IDS_EXPECTED_SYSFONT_ID); if (! _scan.GetChar(']')) return SourceError(PARSER_IDS_RBRACKET_EXPECTED); if (! _scan.EndOfLine()) return SourceError(PARSER_IDS_END_OF_LINE_EXPECTED); //---- look up value of id ---- int index = GetSymbolIndex(idbuff); if (index == -1) return SourceError(PARSER_IDS_UNKNOWN_SYSFONT_ID); if ((index < TMT_FIRSTFONT) || (index > TMT_LASTFONT)) return SourceError(PARSER_IDS_EXPECTED_SYSFONT_ID); //---- get value of specified font ---- NONCLIENTMETRICS metrics; memset(&metrics, 0, sizeof(metrics)); metrics.cbSize = sizeof(metrics); BOOL gotem = SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(metrics), &metrics, 0); if (! gotem) return MakeErrorLast(); switch (index) { case TMT_CAPTIONFONT: *pFont = metrics.lfCaptionFont; break; case TMT_SMALLCAPTIONFONT: *pFont = metrics.lfSmCaptionFont; break; case TMT_MENUFONT: *pFont = metrics.lfMenuFont; break; case TMT_STATUSFONT: *pFont = metrics.lfStatusFont; break; case TMT_MSGBOXFONT: *pFont = metrics.lfMessageFont; break; } return S_OK; } //--------------------------------------------------------------------------- HRESULT CThemeParser::ParseFontValue(int iSymType, LPCWSTR pszPropertyName) { LOGFONT font; WCHAR szLineBuff[_MAX_PATH+1]; HRESULT hr; _scan.SkipSpaces(); // trim leading blanks memset(&font, 0, sizeof(font)); font.lfWeight = FW_NORMAL; font.lfCharSet = _uCharSet; #if 0 // turned off until we finalize design if (_scan.GetKeyword(L"SysFont")) { hr = ParseSysFont(&font); if (FAILED(hr)) return hr; goto addit; } #endif _iFontNumber++; BOOL fGotFont = FALSE; if (_fUsingResourceProperties) // substitute resource font string { hr = GetResourceProperty(pszPropertyName, szLineBuff, ARRAYSIZE(szLineBuff)); if (SUCCEEDED(hr)) { fGotFont = TRUE; } else { hr = S_OK; } } if (! fGotFont) { //---- copy font specs from scanner ---- hr = hr_lstrcpy(szLineBuff, _scan._p, ARRAYSIZE(szLineBuff)); if (FAILED(hr)) return hr; } //---- handle font callback ---- if ((_pNameCallBack) && (_dwParseFlags & PTF_CALLBACK_LOCALIZATIONS)) { WCHAR *p = szLineBuff; while (IsSpace(*p)) p++; BOOL fContinue = (*_pNameCallBack)(TCB_FONT, p, _szFullSectionName, pszPropertyName, 0, _lNameParam); if (! fContinue) return MakeErrorParserLast(); } //---- family name is required and must be first ---- WCHAR *p; p = wcschr(szLineBuff, ','); if (! p) // whole line is family name { hr = hr_lstrcpy(font.lfFaceName, szLineBuff, ARRAYSIZE(font.lfFaceName)); return hr; } *p++ = 0; hr = hr_lstrcpy(font.lfFaceName, szLineBuff, ARRAYSIZE(font.lfFaceName)); if (FAILED(hr)) return hr; _scan._p = p; int val; if (_scan.GetNumber(&val)) // font size { int pixels; hr = ParseSizeInfoUnits(val, L"points", &pixels); if (FAILED(hr)) return hr; font.lfHeight = pixels; _scan.GetChar(','); // optional comma } WCHAR flagname[_MAX_PATH+1]; while (_scan.GetId(flagname)) { if (AsciiStrCmpI(flagname, L"bold")==0) font.lfWeight = FW_BOLD; else if (AsciiStrCmpI(flagname, L"italic")==0) font.lfItalic = TRUE; else if (AsciiStrCmpI(flagname, L"underline")==0) font.lfUnderline = TRUE; else if (AsciiStrCmpI(flagname, L"strikeout")==0) font.lfStrikeOut = TRUE; else return SourceError(PARSER_IDS_UNKNOWN_FONT_FLAG, flagname); } // addit: if (_fDefiningMetrics) { if ((iSymType < TMT_FIRSTFONT) || (iSymType > TMT_LASTFONT)) return SourceError(PARSER_IDS_NOT_ALLOWED_SYSMETRICS); } hr = AddThemeData(iSymType, TMT_FONT, &font, sizeof(font)); if (FAILED(hr)) return hr; return S_OK; } //--------------------------------------------------------------------------- HRESULT CThemeParser::ParseClassLine(int *piSymType, int *piValue, LPWSTR pszBuff, DWORD dwMaxBuffChars) { WCHAR szNameBuff[_MAX_PATH+1]; WCHAR szSymbol[MAX_INPUT_LINE+1]; if (! _scan.GetId(szNameBuff)) return SourceError(PARSER_IDS_EXPECTED_PROP_NAME); if (! _scan.GetChar('=')) return SourceError(PARSER_IDS_EXPECTED_EQUALS_SIGN); int cnt = _Symbols.GetSize(); for (int i=0; i < cnt; i++) { if (AsciiStrCmpI(_Symbols[i].csName, szNameBuff)==0) break; } if (i == cnt) return SourceError(PARSER_IDS_UNKNOWN_PROP, szNameBuff); int symtype = _Symbols[i].sTypeNum; HRESULT hr; // Handle substituted symbols if ((_pNameCallBack) && (_dwParseFlags & PTF_CALLBACK_SUBSTSYMBOLS)) { if (wcschr(_scan._p, INI_MACRO_SYMBOL)) { // Pass ## if (_scan.GetChar(INI_MACRO_SYMBOL) && _scan.GetChar(INI_MACRO_SYMBOL)) { WCHAR szDrive[_MAX_DRIVE], szDir[_MAX_DIR], szBaseName[_MAX_FNAME], szExt[_MAX_EXT]; _wsplitpath(_scan._szFileName, szDrive, szDir, szBaseName, szExt); BOOL fContinue = (*_pNameCallBack)(TCB_NEEDSUBST, szBaseName, _scan._p, szSymbol, 0, _lNameParam); if (! fContinue) return MakeErrorParserLast(); _scan.UseSymbol(szSymbol); } } } switch (_Symbols[i].ePrimVal) { case TMT_ENUM: hr = ParseEnumValue(symtype); break; case TMT_STRING: hr = ParseStringValue(symtype, pszBuff, dwMaxBuffChars); break; case TMT_INT: hr = ParseIntValue(symtype, piValue); break; case TMT_INTLIST: hr = ParseIntListValue(symtype); break; case TMT_BOOL: hr = ParseBoolValue(symtype, szNameBuff); break; case TMT_COLOR: { COLORREF cr; hr = ParseColorValue(symtype, (COLORREF *)piValue, &cr); if (SUCCEEDED(hr)) { if (lstrcmpi(_Symbols[i].csName, L"BLENDCOLOR") == 0) { _crBlend = cr; } } } break; case TMT_MARGINS: hr = ParseMarginsValue(symtype); break; case TMT_FILENAME: hr = ParseFileNameValue(symtype, pszBuff, dwMaxBuffChars); break; case TMT_SIZE: hr = ParseSizeValue(symtype); break; case TMT_POSITION: hr = ParsePositionValue(symtype); break; case TMT_RECT: hr = ParseRectValue(symtype, szNameBuff); break; case TMT_FONT: hr = ParseFontValue(symtype, szNameBuff); break; default: hr = E_FAIL; break; } if ((_pNameCallBack) && (_dwParseFlags & PTF_CALLBACK_SUBSTSYMBOLS)) { _scan.UseSymbol(NULL); } *_szResPropValue = 0; // not yet set if (FAILED(hr)) return hr; if (piSymType) // special call *piSymType = symtype; if (! _scan.EndOfLine()) return SourceError(PARSER_IDS_EXTRA_PROP_TEXT, _scan._p); _scan.ForceNextLine(); return S_OK; } //--------------------------------------------------------------------------- HRESULT CThemeParser::ParseColorSchemeSection() { HRESULT hr; WCHAR SchemeName[_MAX_PATH+1]; WCHAR DisplayName[_MAX_PATH+1]; WCHAR ToolTip[MAX_INPUT_LINE+1]; WCHAR szBuff[MAX_INPUT_LINE+1]; if (! _scan.GetChar('.')) return SourceError(PARSER_IDS_EXPECTED_DOT_SN); if (! _scan.GetId(SchemeName, ARRAYSIZE(SchemeName))) return SourceError(PARSER_IDS_CS_NAME_EXPECTED); if (! _scan.GetChar(']')) return SourceError(PARSER_IDS_RBRACKET_EXPECTED); if (! _scan.EndOfLine()) return SourceError(PARSER_IDS_END_OF_LINE_EXPECTED); _scan.ForceNextLine(); // get line after section line *ToolTip = 0; *DisplayName = 0; bool fCorrectScheme = (lstrcmpi(_ColorParam, SchemeName)==0); if (fCorrectScheme) // initialize all subst. tables { hr = hr_lstrcpy(DisplayName, SchemeName, ARRAYSIZE(DisplayName)); // in case not specified if (FAILED(hr)) return hr; for (int i=0; i < HUE_SUBCNT; i++) { _bFromHues[i] = 0; _bToHues[i] = 0; } for (i=0; i < COLOR_SUBCNT; i++) { _crFromColors[i] = 0; _crToColors[i] = 0; } } //----- put into vars to make coding/debugging easier ---- int firstFromHue = TMT_FROMHUE1; int lastFromHue = TMT_FROMHUE1 + HUE_SUBCNT - 1; int firstToHue = TMT_TOHUE1; int lastToHue = TMT_TOHUE1 + HUE_SUBCNT - 1; int firstFromColor = TMT_FROMCOLOR1; int lastFromColor = TMT_FROMCOLOR1 + COLOR_SUBCNT - 1; int firstToColor = TMT_TOCOLOR1; int lastToColor = TMT_TOCOLOR1 + COLOR_SUBCNT - 1; while (1) // parse each line { if (_scan.EndOfFile()) break; if (_scan.GetChar('[')) // start of new section break; int iSymType, iValue; _fDefiningColorScheme = TRUE; //---- parse the COLOR or INT property line ---- hr = ParseClassLine(&iSymType, &iValue, szBuff, ARRAYSIZE(szBuff)); _fDefiningColorScheme = FALSE; if (FAILED(hr)) return hr; //---- store the HUE or COLOR param in local tables ---- if ((iSymType >= firstFromHue) && (iSymType <= lastFromHue)) { if (fCorrectScheme) _bFromHues[iSymType-firstFromHue] = (BYTE)iValue; } else if ((iSymType >= firstToHue) && (iSymType <= lastToHue)) { if (fCorrectScheme) _bToHues[iSymType-firstToHue] = (BYTE)iValue; } else if ((iSymType >= firstFromColor) && (iSymType <= lastFromColor)) { if (fCorrectScheme) _crFromColors[iSymType-firstFromColor] = (COLORREF)iValue; } else if ((iSymType >= firstToColor) && (iSymType <= lastToColor)) { if (fCorrectScheme) _crToColors[iSymType-firstToColor] = (COLORREF)iValue; } else if (iSymType == TMT_DISPLAYNAME) { hr = hr_lstrcpy(DisplayName, szBuff, ARRAYSIZE(DisplayName)); if (FAILED(hr)) return hr; } else if (iSymType == TMT_TOOLTIP) { hr = hr_lstrcpy(ToolTip, szBuff, ARRAYSIZE(ToolTip)); if (FAILED(hr)) return hr; } else { return SourceError(PARSER_IDS_ILLEGAL_CS_PROPERTY); } } if (fCorrectScheme) // adjust counts { _iHueCount = HUE_SUBCNT; while (_iHueCount > 0) { if (_bFromHues[_iHueCount-1] == _bToHues[_iHueCount-1]) _iHueCount--; else break; } _iColorCount = COLOR_SUBCNT; while (_iColorCount > 0) { if (_crFromColors[_iColorCount-1] == _crToColors[_iColorCount-1]) _iColorCount--; else break; } } if ((_pNameCallBack) && (_dwParseFlags & PTF_CALLBACK_COLORSECTION)) { BOOL fContinue = (*_pNameCallBack)(TCB_COLORSCHEME, SchemeName, DisplayName, ToolTip, 0, _lNameParam); if (! fContinue) return MakeErrorParserLast(); } // Create an empty subst table if ((_pNameCallBack) && (_dwParseFlags & PTF_CALLBACK_SUBSTTABLE)) { BOOL fContinue = (*_pNameCallBack)(TCB_SUBSTTABLE, SchemeName, NULL, NULL, 0, _lNameParam); if (! fContinue) return MakeErrorParserLast(); } return S_OK; } //--------------------------------------------------------------------------- HRESULT CThemeParser::ParseSizeSection() { HRESULT hr; WCHAR szSizeName[_MAX_PATH+1]; WCHAR szDisplayName[_MAX_PATH+1]; WCHAR szToolTip[MAX_INPUT_LINE+1]; WCHAR szBuff[MAX_INPUT_LINE+1]; if (! _scan.GetChar('.')) return SourceError(PARSER_IDS_EXPECTED_DOT_SN); if (! _scan.GetId(szSizeName, ARRAYSIZE(szSizeName))) return SourceError(PARSER_IDS_SS_NAME_EXPECTED); if (! _scan.GetChar(']')) return SourceError(PARSER_IDS_RBRACKET_EXPECTED); if (! _scan.EndOfLine()) return SourceError(PARSER_IDS_END_OF_LINE_EXPECTED); _scan.ForceNextLine(); // get line after section line while (1) // parse each line of section { if (_scan.EndOfFile()) break; if (_scan.GetChar('[')) // start of new section break; int iSymType, iValue; //---- parse the property line ---- hr = ParseClassLine(&iSymType, &iValue, szBuff, ARRAYSIZE(szBuff)); if (FAILED(hr)) return hr; if (iSymType == TMT_DISPLAYNAME) { hr = hr_lstrcpy(szDisplayName, szBuff, ARRAYSIZE(szDisplayName)); if (FAILED(hr)) return hr; } else if (iSymType == TMT_TOOLTIP) { hr = hr_lstrcpy(szToolTip, szBuff, ARRAYSIZE(szToolTip)); if (FAILED(hr)) return hr; } else { return SourceError(PARSER_IDS_ILLEGAL_SS_PROPERTY); } } if ((_pNameCallBack) && (_dwParseFlags & PTF_CALLBACK_SIZESECTION)) { BOOL fContinue = (*_pNameCallBack)(TCB_SIZENAME, szSizeName, szDisplayName, szToolTip, 0, _lNameParam); if (! fContinue) return MakeErrorParserLast(); } // Create an empty subst table if ((_pNameCallBack) && (_dwParseFlags & PTF_CALLBACK_SUBSTTABLE)) { BOOL fContinue = (*_pNameCallBack)(TCB_SUBSTTABLE, szSizeName, NULL, NULL, 0, _lNameParam); if (! fContinue) return MakeErrorParserLast(); } return S_OK; } //--------------------------------------------------------------------------- HRESULT CThemeParser::ParseFileSection() { HRESULT hr; WCHAR szSizeName[_MAX_PATH+1]; WCHAR szFileName[_MAX_PATH+1]; WCHAR szColorSchemes[_MAX_PATH+1]; WCHAR szSizes[MAX_INPUT_LINE+1]; WCHAR szBuff[MAX_INPUT_LINE+1]; if (! _scan.GetChar('.')) return SourceError(PARSER_IDS_EXPECTED_DOT_SN); if (! _scan.GetId(szSizeName, ARRAYSIZE(szSizeName))) return SourceError(PARSER_IDS_FS_NAME_EXPECTED); if (! _scan.GetChar(']')) return SourceError(PARSER_IDS_RBRACKET_EXPECTED); if (! _scan.EndOfLine()) return SourceError(PARSER_IDS_END_OF_LINE_EXPECTED); _scan.ForceNextLine(); // get line after section line while (1) // parse each line of section { if (_scan.EndOfFile()) break; if (_scan.GetChar('[')) // start of new section break; int iSymType, iValue; //---- parse the property line ---- hr = ParseClassLine(&iSymType, &iValue, szBuff, ARRAYSIZE(szBuff)); if (FAILED(hr)) return hr; if (iSymType == TMT_FILENAME) { hr = hr_lstrcpy(szFileName, szBuff, ARRAYSIZE(szFileName)); } else if (iSymType == TMT_COLORSCHEMES) { hr = hr_lstrcpy(szColorSchemes, szBuff, ARRAYSIZE(szColorSchemes)); } else if (iSymType == TMT_SIZES) { hr = hr_lstrcpy(szSizes, szBuff, ARRAYSIZE(szSizes)); } else { return SourceError(PARSER_IDS_ILLEGAL_SS_PROPERTY); } if (FAILED(hr)) return hr; } if ((_pNameCallBack) && (_dwParseFlags & PTF_CALLBACK_FILESECTION)) { BOOL fContinue = (*_pNameCallBack)(TCB_CDFILENAME, szSizeName, szFileName, NULL, 0, _lNameParam); if (! fContinue) return MakeErrorParserLast(); fContinue = (*_pNameCallBack)(TCB_CDFILECOMBO, szSizeName, szColorSchemes, szSizes, 0, _lNameParam); if (! fContinue) return MakeErrorParserLast(); } if ((_pNameCallBack) && (_dwParseFlags & PTF_CALLBACK_SUBSTTABLE)) { BOOL fContinue = (*_pNameCallBack)(TCB_SUBSTTABLE, szSizeName, SUBST_TABLE_INCLUDE, szColorSchemes, 0, _lNameParam); if (! fContinue) return MakeErrorParserLast(); fContinue = (*_pNameCallBack)(TCB_SUBSTTABLE, szSizeName, SUBST_TABLE_INCLUDE, szSizes, 0, _lNameParam); if (! fContinue) return MakeErrorParserLast(); } return S_OK; } //--------------------------------------------------------------------------- HRESULT CThemeParser::ParseSubstSection() { WCHAR szSubstTableName[_MAX_PATH+1]; WCHAR szId[MAX_INPUT_LINE+1]; WCHAR szValue[MAX_INPUT_LINE+1]; BOOL fFirst = TRUE; if (! _scan.GetChar('.')) return SourceError(PARSER_IDS_EXPECTED_DOT_SN); if (! _scan.GetId(szSubstTableName, ARRAYSIZE(szSubstTableName))) return SourceError(PARSER_IDS_FS_NAME_EXPECTED); if (! _scan.GetChar(']')) return SourceError(PARSER_IDS_RBRACKET_EXPECTED); if (! _scan.EndOfLine()) return SourceError(PARSER_IDS_END_OF_LINE_EXPECTED); _scan.ForceNextLine(); // get line after section line while (1) // parse each line of section { if (_scan.EndOfFile()) break; if (_scan.GetChar('[')) // start of new section { // Call the callback once for creating the empty table if (fFirst && (_pNameCallBack) && (_dwParseFlags & PTF_CALLBACK_SUBSTTABLE)) { BOOL fContinue = (*_pNameCallBack)(TCB_SUBSTTABLE, szSubstTableName, NULL, NULL, 0, _lNameParam); if (! fContinue) return MakeErrorParserLast(); } break; } //---- parse the property line ---- if (!_scan.GetIdPair(szId, szValue, ARRAYSIZE(szId))) return SourceError(PARSER_IDS_BAD_SUBST_SYMBOL); fFirst = FALSE; _scan.ForceNextLine(); if ((_pNameCallBack) && (_dwParseFlags & PTF_CALLBACK_SUBSTTABLE)) { BOOL fContinue = (*_pNameCallBack)(TCB_SUBSTTABLE, szSubstTableName, szId, szValue, 0, _lNameParam); if (! fContinue) return MakeErrorParserLast(); } } return S_OK; } //--------------------------------------------------------------------------- HRESULT CThemeParser::GenerateEmptySection(LPCWSTR pszSectionName, int iPartId, int iStateId) { int iStartIndex = 0; if (_pCallBackObj) iStartIndex = _pCallBackObj->GetNextDataIndex(); int index = 0; // will be updated later HRESULT hr = AddThemeData(TMT_JUMPTOPARENT, TMT_JUMPTOPARENT, &index, sizeof(index)); if (FAILED(hr)) return hr; if (_pCallBackObj) { int iLen = _pCallBackObj->GetNextDataIndex() - iStartIndex; hr = _pCallBackObj->AddIndex(L"", pszSectionName, iPartId, iStateId, iStartIndex, iLen); if (FAILED(hr)) return hr; } return S_OK; } //--------------------------------------------------------------------------- HRESULT CThemeParser::ParseClassSection(LPCWSTR pszFirstName) { HRESULT hr; int iStartIndex = 0; BOOL fGlobals = (AsciiStrCmpI(pszFirstName, GLOBALS_SECTION_NAME)==0); BOOL fMetrics = (AsciiStrCmpI(pszFirstName, SYSMETRICS_SECTION_NAME)==0); if (fGlobals) { if (_fClassSectionDefined) return SourceError(PARSER_IDS_GLOBALS_MUST_BE_FIRST); } else // regular class section { if (_dwParseFlags & PTF_CLASSDATA_PARSE) { if (! _fGlobalsDefined) // insert an empty [fGlobals] section { hr = GenerateEmptySection(GLOBALS_SECTION_NAME, 0, 0); if (FAILED(hr)) return hr; _fGlobalsDefined = true; } if ((! fMetrics) && (! _fMetricsDefined)) // insert an empty [sysmetrics] section { hr = GenerateEmptySection(SYSMETRICS_SECTION_NAME, 0, 0); if (FAILED(hr)) return hr; _fMetricsDefined = true; } else if ((fMetrics) && (_fClassSectionDefined)) return SourceError(PARSER_IDS_METRICS_MUST_COME_BEFORE_CLASSES); } _fClassSectionDefined = TRUE; } WCHAR appsym[_MAX_PATH+1]; if (_pCallBackObj) iStartIndex = _pCallBackObj->GetNextDataIndex(); hr = ParseClassSectionName(pszFirstName, appsym); if (FAILED(hr)) return hr; _scan.ForceNextLine(); // get line after section line while (1) // parse each line { if (_scan.EndOfFile()) break; if (_scan.GetChar('[')) // start of new section break; hr = ParseClassLine(); if (FAILED(hr)) return hr; } //---- end this section of theme data ---- int index = 0; // will be updated later hr = AddThemeData(TMT_JUMPTOPARENT, TMT_JUMPTOPARENT, &index, sizeof(index)); if (FAILED(hr)) return hr; if (_pCallBackObj) { int iLen = _pCallBackObj->GetNextDataIndex() - iStartIndex; hr = _pCallBackObj->AddIndex(appsym, _szClassName, _iPartId, _iStateId, iStartIndex, iLen); if (FAILED(hr)) return hr; } if (fGlobals) _fGlobalsDefined = true; else if (fMetrics) _fMetricsDefined = true; return S_OK; } //--------------------------------------------------------------------------- HRESULT CThemeParser::ParseThemeFile(LPCTSTR pszFileName, LPCWSTR pszColorParam, IParserCallBack *pCallBack, THEMEENUMPROC pNameCallBack, LPARAM lNameParam, DWORD dwParseFlags) { _pszDocProperty = NULL; HRESULT hr = InitializeSymbols(); if (FAILED(hr)) goto exit; hr = _scan.AttachFile(pszFileName); // "pszBuffer" contains the filename if (FAILED(hr)) goto exit; if (pszColorParam) { hr = hr_lstrcpy(_ColorParam, pszColorParam, ARRAYSIZE(_ColorParam)); if (FAILED(hr)) return hr; } else *_ColorParam = 0; _hinstThemeDll = NULL; hr = ParseThemeScanner(pCallBack, pNameCallBack, lNameParam, dwParseFlags); exit: return hr; } //--------------------------------------------------------------------------- HRESULT CThemeParser::ParseThemeBuffer(LPCWSTR pszBuffer, LPCWSTR pszFileName, LPCWSTR pszColorParam, HINSTANCE hinstThemeDll, IParserCallBack *pCallBack, THEMEENUMPROC pNameCallBack, LPARAM lNameParam, DWORD dwParseFlags, LPCWSTR pszDocProperty, OUT LPWSTR pszResult, DWORD dwMaxResultChars) { _pszDocProperty = pszDocProperty; _pszResult = pszResult; //---- initialize in case not found ---- if (_pszResult) *_pszResult = 0; _dwMaxResultChars = dwMaxResultChars; HRESULT hr = InitializeSymbols(); if (FAILED(hr)) goto exit; _hinstThemeDll = hinstThemeDll; _scan.AttachMultiLineBuffer(pszBuffer, pszFileName); if (pszColorParam) { hr = hr_lstrcpy(_ColorParam, pszColorParam, ARRAYSIZE(_ColorParam)); if (FAILED(hr)) return hr; } else *_ColorParam = 0; hr = ParseThemeScanner(pCallBack, pNameCallBack, lNameParam, dwParseFlags); //---- make error if doc property not found ---- if ((SUCCEEDED(hr)) && (_dwParseFlags & PTF_QUERY_DOCPROPERTY) && (! *_pszResult)) { hr = MakeError32(ERROR_NOT_FOUND); } exit: return hr; } //--------------------------------------------------------------------------- HRESULT CThemeParser::LoadResourceProperties() { WCHAR szFullString[2*MAX_PATH]; WCHAR szBaseIniName[_MAX_PATH]; HRESULT hr = S_OK; //---- extract base .ini name ---- WCHAR drive[_MAX_DRIVE], dir[_MAX_DIR], ext[_MAX_EXT]; _wsplitpath(_scan._szFileName, drive, dir, szBaseIniName, ext); //---- remove optional "_INI" part ---- LPWSTR pszExt = wcsstr(szBaseIniName, L"_INI"); if (pszExt) *pszExt = 0; //---- read all localizable property name/value pairs into memory ---- for (int i=RES_BASENUM_PROPVALUEPAIRS; ; i++) { if (! LoadString(_hinstThemeDll, i, szFullString, ARRAYSIZE(szFullString))) { //---- no more properties avail ---- break; } lstrcpy(_szResPropValue, szFullString); // for proper error reporting _iResPropId = i; //---- does this property belong to current file? ---- LPWSTR pszAtSign = wcschr(szFullString, '@'); if (! pszAtSign) { hr = SourceError(PARSER_IDS_BAD_RES_PROPERTY); break; } //---- zero terminate ini name ---- *pszAtSign = 0; if (lstrcmpi(szBaseIniName, szFullString) != 0) continue; //---- strip off the .ini name for faster comparing ---- LPCWSTR pszName = pszAtSign+1; LPWSTR pszValue = wcschr(pszName, '='); if (pszValue) { pszValue++; // skip over equals sign } else { hr = SourceError(PARSER_IDS_BAD_RES_PROPERTY); break; } //---- add the value ---- CWideString cwValue(pszValue); _PropertyValues.Add(cwValue); //---- zero-terminate the name ---- *pszValue = 0; //---- add the name ---- CWideString cwName(pszName); _PropertyNames.Add(cwName); //---- add the id ---- _iPropertyIds.Add(i); } return hr; } //--------------------------------------------------------------------------- void CThemeParser::EmptyResourceProperties() { _PropertyNames.RemoveAll(); _PropertyValues.RemoveAll(); } //--------------------------------------------------------------------------- HRESULT CThemeParser::GetResourceProperty(LPCWSTR pszPropName, LPWSTR pszValueBuff, int cchMaxValueChars) { WCHAR szPropTarget[2*MAX_PATH]; HRESULT hr = S_OK; BOOL fFound = FALSE; wsprintf(szPropTarget, L"[%s]%s=", _szFullSectionName, pszPropName); for (int i=0; i < _PropertyNames.m_nSize; i++) { if (AsciiStrCmpI(szPropTarget, _PropertyNames[i])==0) { fFound = TRUE; hr = hr_lstrcpy(pszValueBuff, _PropertyValues[i], cchMaxValueChars); if (SUCCEEDED(hr)) { hr = hr_lstrcpy(_szResPropValue, _PropertyValues[i], ARRAYSIZE(_szResPropValue)); _iResPropId = _iPropertyIds[i]; } break; } } if (! fFound) hr = E_FAIL; return hr; } //--------------------------------------------------------------------------- HRESULT CThemeParser::ParseThemeScanner(IParserCallBack *pCallBack, THEMEENUMPROC pNameCallBack, LPARAM lNameParam, DWORD dwParseFlags) { HRESULT hr; _pCallBackObj = pCallBack; _pNameCallBack = pNameCallBack; _lNameParam = lNameParam; _dwParseFlags = dwParseFlags; _fClassSectionDefined = FALSE; //---- setup for properties in the .res file ---- EmptyResourceProperties(); _fUsingResourceProperties = (pCallBack != NULL); if (_fUsingResourceProperties) { hr = LoadResourceProperties(); if (FAILED(hr)) goto exit; //---- set the error context for normal .ini parsing ---- *_szResPropValue = 0; // not yet set } //---- scan the first, non-comment WCHAR ---- if (! _scan.GetChar('[')) { if (! _scan.EndOfFile()) { hr = SourceError(PARSER_IDS_LBRACKET_EXPECTED); goto exit; } } while (! _scan.EndOfFile()) // process each section { WCHAR section[_MAX_PATH+1]; _scan.GetId(section); if (AsciiStrCmpI(section, L"documentation")==0) { if (_dwParseFlags & PTF_CLASSDATA_PARSE) return SourceError(PARSER_IDS_BADSECT_CLASSDATA); hr = ParseDocSection(); if (_dwParseFlags & PTF_QUERY_DOCPROPERTY) break; // quicker to leave in middle of file } else if (AsciiStrCmpI(section, L"ColorScheme")==0) { if (_dwParseFlags & PTF_CLASSDATA_PARSE) return SourceError(PARSER_IDS_BADSECT_CLASSDATA); hr = ParseColorSchemeSection(); } else if (AsciiStrCmpI(section, L"Size")==0) { if (_dwParseFlags & PTF_CLASSDATA_PARSE) return SourceError(PARSER_IDS_BADSECT_CLASSDATA); hr = ParseSizeSection(); } else if (AsciiStrCmpI(section, L"File")==0) { if (_dwParseFlags & PTF_CLASSDATA_PARSE) return SourceError(PARSER_IDS_BADSECT_CLASSDATA); hr = ParseFileSection(); } else if (AsciiStrCmpI(section, L"Subst")==0) { if (_dwParseFlags & PTF_CLASSDATA_PARSE) return SourceError(PARSER_IDS_BADSECT_CLASSDATA); hr = ParseSubstSection(); } else // "globals", "sysmetrics", or class section { if (_dwParseFlags & PTF_CONTAINER_PARSE) return SourceError(PARSER_IDS_BADSECT_THEMES_INI); hr = ParseClassSection(section); } if (FAILED(hr)) goto exit; } //---- check for empty theme ---- if (_dwParseFlags & PTF_CLASSDATA_PARSE) { if (! _fGlobalsDefined) // insert an empty [fGlobals] section { hr = GenerateEmptySection(GLOBALS_SECTION_NAME, 0, 0); if (FAILED(hr)) return hr; _fGlobalsDefined = true; } if (! _fMetricsDefined) // insert an empty [sysmetrics] section { hr = GenerateEmptySection(SYSMETRICS_SECTION_NAME, 0, 0); if (FAILED(hr)) return hr; } } hr = S_OK; exit: _outfile.Close(); _pCallBackObj = NULL; _pNameCallBack = NULL; return hr; } //--------------------------------------------------------------------------- HRESULT CThemeParser::GetIntList(int *pInts, LPCWSTR *pParts, int iCount, int iMin, int iMax) { bool bSet[255]; // assume 255 max ints //---- ensure we set each one once ---- for (int i=0; i < iCount; i++) bSet[i] = false; if (wcschr(_scan._p, ':')) { //---- named parts ---- for (int i=0; i < iCount; i++) { WCHAR idbuff[_MAX_PATH+1]; if (! _scan.GetId(idbuff)) return SourceError(PARSER_IDS_VALUE_NAME_EXPECTED, _scan._p); for (int j=0; j < iCount; j++) { if (AsciiStrCmpI(pParts[j], idbuff)==0) break; } if (j == iCount) // unknown part name return SourceError(PARSER_IDS_UNKNOWN_VALUE_NAME, idbuff); if (bSet[j]) // name set twice return SourceError(PARSER_IDS_VALUE_PART_SPECIFIED_TWICE, idbuff); if (! _scan.GetChar(':')) return SourceError(PARSER_IDS_COLOR_EXPECTED, _scan._p); if (! _scan.GetNumber(&pInts[j])) return SourceError(PARSER_IDS_NUMBER_EXPECTED, _scan._p); bSet[j] = true; _scan.GetChar(','); // optional comma } } else { //---- unnamed parts ---- for (int i=0; i < iCount; i++) { if (! _scan.GetNumber(&pInts[i])) return SourceError(PARSER_IDS_NUMBER_EXPECTED, _scan._p); _scan.GetChar(','); // optional comma } } //---- range check ---- if (iMin != iMax) { for (i=0; i < iCount; i++) { if ((pInts[i] < iMin) || (pInts[i] > iMax)) return SourceError(PARSER_IDS_NUMBER_OUT_OF_RANGE); } } return S_OK; } //--------------------------------------------------------------------------- HRESULT CThemeParser::GetPropertyNum(LPCWSTR pszName, int *piPropNum) { //---- for perf, avoid loading all symbols each time this func is called ---- //---- by using "GetSchemaInfo()" ---- //---- get tm & comctl symbols ---- const TMSCHEMAINFO *si = GetSchemaInfo(); int cnt = si->iPropCount; const TMPROPINFO *pi = si->pPropTable; for (int i=0; i < cnt; i++) { if (pi[i].sEnumVal < TMT_FIRST_RCSTRING_NAME) continue; if (pi[i].sEnumVal > TMT_LAST_RCSTRING_NAME) break; if (AsciiStrCmpI(pszName, pi[i].pszName)==0) { *piPropNum = pi[i].sEnumVal - TMT_FIRST_RCSTRING_NAME; // zero based return S_OK; } } return MakeError32(ERROR_NOT_FOUND); } //--------------------------------------------------------------------------- HRESULT CThemeParser::BitmapColorReplacement(DWORD *pPixelBuff, UINT iWidth, UINT iHeight) { if ((! _iHueCount) && (! _iColorCount)) return S_OK; DWORD *pPixel = pPixelBuff; for (UINT r=0; r < iHeight; r++) // for each row { for (UINT c=0; c < iWidth; c++, pPixel++) // for each pixel in row { //---- try to apply a COLOR substitution ---- if (_iColorCount) { COLORREF crPixel = REVERSE3(*pPixel); for (int h=0; h < _iColorCount; h++) { if (_crFromColors[h] == crPixel) { //---- preserve alpha value when doing COLOR replacement ---- *pPixel = ((ALPHACHANNEL(*pPixel)) << 24) | REVERSE3(_crToColors[h]); break; // only one replacement per pixel } } if (h < _iColorCount) // don't try hues if we got COLOR match continue; } if (_iHueCount) { WORD wPixelHue, wPixelLum, wPixelSat; RGBtoHLS(REVERSE3(*pPixel), &wPixelHue, &wPixelLum, &wPixelSat); //---- try to apply a HUE substitution ---- for (int h=0; h < _iHueCount; h++) { if (_bFromHues[h] == wPixelHue) { //---- preserve alpha value when doing HUE replacement ---- *pPixel = ((ALPHACHANNEL(*pPixel)) << 24) | REVERSE3(HLStoRGB(_bToHues[h], wPixelLum, wPixelSat)); break; // only one replacement per pixel }; } } } } return S_OK; } //--------------------------------------------------------------------------- HRESULT CThemeParser::GetStateNum(LPCWSTR pszStateName, BYTE *piNum) { WCHAR statesname[_MAX_PATH+1]; HRESULT hr = S_OK; if (! *_szBaseSectionName) { Log(LOG_ERROR, L"szBaseSectionName not set by caller of NtlRun"); hr = SourceError(PARSER_IDS_INTERNAL_TM_ERROR); goto exit; } wsprintf(statesname, L"%sStates", _szBaseSectionName); int iSymIndex; iSymIndex = GetSymbolIndex(statesname); if (iSymIndex == -1) { hr = SourceError(PARSER_IDS_UNKNOWN_STATE, statesname); goto exit; } int iStateIndex; hr = ValidateEnumSymbol(statesname, iSymIndex, &iStateIndex); if (FAILED(hr)) goto exit; *piNum = (BYTE)_EnumVals[iStateIndex].iValue; exit: return hr; } //---------------------------------------------------------------------------