Changeset 17347


Ignore:
Timestamp:
10/03/2016 06:48:12 PM (7 months ago)
Author:
ghazan
Message:
  • inlined helpers for fonts, colors & effects creation replaced with functions;
  • services for getting fonts, colors & effects removed;
  • some memory corruptions removed
Location:
trunk
Files:
47 edited

Legend:

Unmodified
Added
Removed
  • trunk/include/delphi/m_fontservice.inc

    r8473 r17347  
    113113 
    114114const 
    115   { register a font } 
    116   { wparam = pointer to FontID structure} 
    117   { lparam = hLangpack } 
    118   MS_FONT_REGISTERA:PAnsiChar = 'Font/Register'; 
    119   MS_FONT_REGISTERW:PAnsiChar = 'Font/RegisterW'; 
    120  
    121   { get a font } 
    122   { wparam = pointer to FontID structure (only name and group matter) } 
    123   { lParam = pointer to LOGFONT structure } 
    124   { returns the font's colour } 
    125   MS_FONT_GETA:PAnsiChar = 'Font/Get'; 
    126   MS_FONT_GETW:PAnsiChar = 'Font/GetW'; 
    127  
    128115  { fired when a user modifies font settings, so reget your fonts } 
    129116  ME_FONT_RELOAD:PAnsiChar = 'Font/Reload'; 
     117 
     118function Font_Register(pFont:pFontID; hLang:int) : int; stdcall; external AppDll; 
     119function Font_Get(pGroup,pName:pAnsiChar; pFont:pLogFontA) : longint; stdcall; external AppDll; 
    130120 
    131121type 
     
    159149 
    160150const 
    161   { register a colour (this should be used for everything except actual text colour for registered fonts) } 
    162   { [note - a colour with name 'Background' has special meaning and will be used as the background colour of  } 
    163   { the font list box in the options, for the given group] } 
    164   { wparam = pointer to ColourID structure } 
    165   { lparam = hLangpack } 
    166   MS_COLOUR_REGISTERA:PAnsiChar = 'Colour/Register'; 
    167   MS_COLOUR_REGISTERW:PAnsiChar = 'Colour/RegisterW'; 
    168  
    169   { get a colour } 
    170   { wparam = pointer to ColourID structure (only name and group matter) } 
    171   { returns the colour (as COLORREF), or -1 if not found } 
    172   MS_COLOUR_GETA:PAnsiChar = 'Colour/Get'; 
    173   MS_COLOUR_GETW:PAnsiChar = 'Colour/GetW'; 
    174  
    175151  { fired when a user modifies font settings, so reget your fonts and colours } 
    176152  ME_COLOUR_RELOAD:PAnsiChar = 'Colour/Reload'; 
    177153 
    178 var 
    179   MS_FONT_REGISTER  :PAnsiChar absolute MS_FONT_REGISTERW; 
    180   MS_FONT_GET       :PAnsiChar absolute MS_FONT_GETW; 
    181   MS_COLOUR_REGISTER:PAnsiChar absolute MS_COLOUR_REGISTERW; 
    182   MS_COLOUR_GET     :PAnsiChar absolute MS_COLOUR_GETW; 
    183  
     154function Colour_Register(pColour:pColourID; hLang:int) : int; stdcall; external AppDll; 
     155function Colour_Get(pGroup,pName:pAnsiChar) : longint; stdcall; external AppDll; 
    184156 
    185157////////////////////////////////////////////////////////////////////////// 
     
    226198 
    227199const 
    228 // register an effect 
    229 // wparam = (EffectID *)&effect_id 
    230 // lparam = hLangpack 
    231   MS_EFFECT_REGISTERA:PAnsiChar = 'Effect/Register'; 
    232   MS_EFFECT_REGISTERW:PAnsiChar = 'Effect/RegisterW'; 
    233  
    234 // get a effect 
    235 // wparam = (EffectID *)&effect_id (only name and group matter) 
    236 // lparam = (FONTEFFECT *)&effect 
    237 // rerturns 0, or -1 if not found 
    238   MS_EFFECT_GET :PAnsiChar = 'Effect/Get'; 
    239   MS_EFFECT_GETW:PAnsiChar = 'Effect/GetW'; 
    240  
    241200// fired when a user modifies font settings, so reget your fonts and colours 
    242201// wparam = lparam = 0 
  • trunk/include/delphi/m_helpers.inc

    r17274 r17347  
    6161procedure Icon_RegisterW(hInst:HINST; const szSection:PWideChar; pIcons:pIconItemW; iCount:size_t; prefix:PAnsiChar); 
    6262 
    63 procedure FontRegister (pFontID:pFontID); 
    64 procedure FontRegisterW(pFontID:pFontIDW); 
    65  
    66 procedure ColourRegister (pColorID:pColourID); 
    67 procedure ColourRegisterW(pColorID:pColourIDW); 
    68  
    69 procedure EffectRegister (pEffectID:pEffectID); 
    70 procedure EffectRegisterW(pEffectID:pEffectIDW); 
     63procedure FontRegister(pFontID:pFontID); 
     64procedure ColourRegister(pColorID:pColourID); 
    7165 
    7266function TopToolbar_AddButton(pButton:PTTBButton):THANDLE; 
     
    422416procedure FontRegister(pFontID:pFontID); 
    423417begin 
    424         CallService(MS_FONT_REGISTERA, WPARAM(pFontID), hLangpack); 
    425 end; 
    426 procedure FontRegisterW(pFontID:pFontIDW); 
    427 begin 
    428         CallService(MS_FONT_REGISTERW, WPARAM(pFontID), hLangpack); 
     418   Font_Register(pFontID, hLangpack); 
    429419end; 
    430420 
    431421procedure ColourRegister(pColorID:pColourID); 
    432422begin 
    433         CallService(MS_COLOUR_REGISTERA, WPARAM(pColorID), hLangpack); 
    434 end; 
    435 procedure ColourRegisterW(pColorID:pColourIDW); 
    436 begin 
    437         CallService(MS_COLOUR_REGISTERW, WPARAM(pColorID), hLangpack); 
    438 end; 
    439  
    440 procedure EffectRegister(pEffectID:pEffectID); 
    441 begin 
    442         CallService(MS_EFFECT_REGISTERA, WPARAM(pEffectID), hLangpack); 
    443 end; 
    444 procedure EffectRegisterW(pEffectID:pEffectIDW); 
    445 begin 
    446         CallService(MS_EFFECT_REGISTERW, WPARAM(pEffectID), hLangpack); 
     423        Colour_Register(pColorID, hLangpack); 
    447424end; 
    448425 
  • trunk/include/m_fontservice.h

    r17158 r17347  
    9494 
    9595// register a font 
    96 // wparam = (FontID *)&font_id 
    97 // lparam = hLangpack 
    98  
    9996extern int hLangpack; 
    10097 
    101 __forceinline void FontRegister(FontID* pFontID) 
    102 { 
    103         CallService("Font/Register", (WPARAM)pFontID, hLangpack); 
    104 } 
    105  
    106 __forceinline void FontRegisterW(FontIDW* pFontID) 
    107 { 
    108         CallService("Font/RegisterW", (WPARAM)pFontID, hLangpack); 
    109 } 
     98EXTERN_C MIR_APP_DLL(int) Font_Register(FontID *pFont, int = hLangpack); 
     99EXTERN_C MIR_APP_DLL(int) Font_RegisterW(FontIDW *pFont, int = hLangpack); 
    110100 
    111101// get a font 
     
    113103// or the global default font settings otherwise (i.e. no user choice and default set, or font not registered) 
    114104// global default font is gotten using SPI_GETICONTITLELOGFONT, color COLOR_WINDOWTEXT, size 8. 
    115 // wparam = (FontID *)&font_id (only name and group matter) 
    116 // lParam = (LOGFONT *)&logfont 
    117105// returns the font's colour 
    118 #define MS_FONT_GET           "Font/Get" 
    119 #define MS_FONT_GETW          "Font/GetW" 
     106 
     107EXTERN_C MIR_APP_DLL(COLORREF) Font_Get(const char *szGroup, const char *szName, LOGFONTA *pFont); 
     108EXTERN_C MIR_APP_DLL(COLORREF) Font_GetW(const wchar_t *wszGroup, const wchar_t *wszName, LOGFONTW *pFont); 
     109 
     110__forceinline COLORREF Font_Get(FontID &p, LOGFONTA *pFont) 
     111{       return Font_Get(p.group, p.name, pFont); 
     112} 
     113__forceinline COLORREF Font_GetW(FontIDW &p, LOGFONTW *pFont) 
     114{       return Font_GetW(p.group, p.name, pFont); 
     115} 
    120116 
    121117// fired when a user modifies font settings, so reload your fonts 
     
    163159// [note - a colour with name 'Background' [translated!] has special meaning and will be used as the background colour of 
    164160// the font list box in the options, for the given group] 
    165 // wparam = (ColourID *)&colour_id 
    166 // lparam = hLangpack 
    167  
    168 __forceinline void ColourRegister(ColourID* pColorID) 
    169 { 
    170         CallService("Colour/Register", (WPARAM)pColorID, hLangpack); 
     161 
     162EXTERN_C MIR_APP_DLL(int) Colour_Register(ColourID *pFont, int = hLangpack); 
     163EXTERN_C MIR_APP_DLL(int) Colour_RegisterW(ColourIDW *pFont, int = hLangpack); 
     164 
     165// get a colour 
     166EXTERN_C MIR_APP_DLL(COLORREF) Colour_Get(const char *szGroup, const char *szName); 
     167EXTERN_C MIR_APP_DLL(COLORREF) Colour_GetW(const wchar_t *wszGroup, const wchar_t *wszName); 
     168 
     169__forceinline COLORREF Colour_GetW(ColourIDW &p) 
     170{       return Colour_GetW(p.group, p.name); 
    171171} 
    172  
    173 __forceinline void ColourRegisterW(ColourIDW* pColorID) 
    174 { 
    175         CallService("Colour/RegisterW", (WPARAM)pColorID, hLangpack); 
    176 } 
    177  
    178 // get a colour 
    179 // wparam = (ColourID *)&colour_id (only name and group matter) 
    180 // rerturns the colour (as COLORREF), or -1 if not found 
    181 #define MS_COLOUR_GET         "Colour/Get" 
    182 #define MS_COLOUR_GETW        "Colour/GetW" 
    183172 
    184173// fired when a user modifies font settings, so reget your fonts and colours 
     
    231220// lparam = 0 
    232221 
    233 __forceinline void EffectRegister(EffectID* pEffectID) 
    234 { 
    235         CallService("Effect/Register", (WPARAM)pEffectID, hLangpack); 
    236 } 
    237  
    238 __forceinline void EffectRegisterW(EffectIDW* pEffectID) 
    239 { 
    240         CallService("Effect/RegisterW", (WPARAM)pEffectID, hLangpack); 
    241 } 
     222EXTERN_C MIR_APP_DLL(int) Effect_Register(EffectID *pEffect, int = hLangpack); 
     223EXTERN_C MIR_APP_DLL(int) Effect_RegisterW(EffectIDW *pEffect, int = hLangpack); 
    242224 
    243225// get a effect 
     
    245227// lparam = (FONTEFFECT *)&effect 
    246228// rerturns 0, or -1 if not found 
    247 #define MS_EFFECT_GET         "Effect/Get" 
    248 #define MS_EFFECT_GETW        "Effect/GetW" 
     229 
     230EXTERN_C MIR_APP_DLL(int) Effect_Get(const char *szGroup, const char *wszName, FONTEFFECT *pEffect); 
     231EXTERN_C MIR_APP_DLL(int) Effect_GetW(const wchar_t *wszGroup, const wchar_t *szName, FONTEFFECT *pEffect); 
    249232 
    250233// fired when a user modifies font settings, so reget your fonts and colours 
  • trunk/plugins/Alarms/src/alarm_win.cpp

    r17143 r17347  
    332332{ 
    333333        LOGFONT log_font; 
    334         title_font_colour = CallService(MS_FONT_GETW, (WPARAM)&title_font_id, (LPARAM)&log_font); 
     334        title_font_colour = Font_GetW(title_font_id, &log_font); 
    335335        DeleteObject(hTitleFont); 
    336336        hTitleFont = CreateFontIndirect(&log_font); 
    337337 
    338         window_font_colour = CallService(MS_FONT_GETW, (WPARAM)&window_font_id, (LPARAM)&log_font); 
     338        window_font_colour = Font_GetW(window_font_id, &log_font); 
    339339        DeleteObject(hWindowFont); 
    340340        hWindowFont = CreateFontIndirect(&log_font); 
    341341 
    342         COLORREF bkCol = CallService(MS_COLOUR_GETW, (WPARAM)&bk_colour_id, 0); 
     342        COLORREF bkCol = Colour_GetW(bk_colour_id); 
    343343        DeleteObject(hBackgroundBrush); 
    344344        hBackgroundBrush = CreateSolidBrush(bkCol); 
     
    359359        title_font_id.flags = 0; 
    360360        title_font_id.order = 0; 
    361         FontRegisterW(&title_font_id); 
     361        Font_RegisterW(&title_font_id); 
    362362 
    363363        window_font_id.cbSize = sizeof(FontIDW); 
     
    370370        window_font_id.flags = 0; 
    371371        window_font_id.order = 1; 
    372         FontRegisterW(&window_font_id); 
     372        Font_RegisterW(&window_font_id); 
    373373 
    374374        bk_colour_id.cbSize = sizeof(ColourIDW); 
     
    381381        bk_colour_id.order = 0; 
    382382 
    383         ColourRegisterW(&bk_colour_id); 
     383        Colour_RegisterW(&bk_colour_id); 
    384384 
    385385        ReloadFonts(0, 0); 
  • trunk/plugins/Alarms/src/frame.cpp

    r17158 r17347  
    434434        DeleteObject(hFont); 
    435435 
    436         LOGFONT log_font; 
    437         fontColour = CallService(MS_FONT_GET, (WPARAM)&font_id, (LPARAM)&log_font); 
    438         hFont = CreateFontIndirect(&log_font); 
     436        LOGFONTA log_font; 
     437        fontColour = Font_Get(font_id, &log_font); 
     438        hFont = CreateFontIndirectA(&log_font); 
    439439        SendMessage(hwnd_list, WM_SETFONT, (WPARAM)hFont, TRUE); 
    440440 
     
    569569        strncpy(font_id.prefix, "Font", sizeof(font_id.prefix)); 
    570570        font_id.order = 0; 
    571         FontRegister(&font_id); 
     571        Font_Register(&font_id); 
    572572 
    573573        framebk_colour_id.cbSize = sizeof(ColourID); 
     
    579579        framebk_colour_id.flags = 0; 
    580580        framebk_colour_id.order = 0; 
    581         ColourRegister(&framebk_colour_id); 
    582  
    583         LOGFONT log_font; 
    584         fontColour = CallService(MS_FONT_GET, (WPARAM)&font_id, (LPARAM)&log_font); 
    585         hFont = CreateFontIndirect(&log_font); 
     581        Colour_Register(&framebk_colour_id); 
     582 
     583        LOGFONTA log_font; 
     584        fontColour = Font_Get(font_id, &log_font); 
     585        hFont = CreateFontIndirectA(&log_font); 
    586586        SendMessage(hwnd_list, WM_SETFONT, (WPARAM)hFont, TRUE); 
    587587         
  • trunk/plugins/AutoShutdown/src/frame.cpp

    r17138 r17347  
    224224        case M_REFRESH_COLORS: 
    225225                COLORREF clrBar; 
    226                 if (FontService_GetColor(L"Automatic shutdown", L"Progress bar", &clrBar)) 
     226                clrBar = Colour_GetW(L"Automatic shutdown", L"Progress bar"); 
     227                if (clrBar == -1) 
    227228                        clrBar = GetDefaultColor(FRAMEELEMENT_BAR); 
    228                 if (FontService_GetColor(L"Automatic shutdown", L"Background", &dat->clrBackground)) 
     229                 
     230                dat->clrBackground = Colour_GetW(L"Automatic shutdown", L"Background"); 
     231                if (dat->clrBackground == -1) 
    229232                        dat->clrBackground = GetDefaultColor(FRAMEELEMENT_BKGRND); 
    230                 if (dat->hbrBackground != NULL) DeleteObject(dat->hbrBackground); 
     233                 
     234                if (dat->hbrBackground != NULL) 
     235                        DeleteObject(dat->hbrBackground); 
    231236                dat->hbrBackground = CreateSolidBrush(dat->clrBackground); 
     237 
    232238                SendMessage(dat->hwndProgress, PBM_SETBARCOLOR, 0, (LPARAM)clrBar); 
    233239                SendMessage(dat->hwndProgress, PBM_SETBKCOLOR, 0, (LPARAM)dat->clrBackground); 
     
    241247                { 
    242248                        LOGFONT lf; 
    243                         if (!FontService_GetFont(L"Automatic shutdown", L"Countdown on frame", &dat->clrText, &lf)) { 
    244                                 if (dat->hFont != NULL) DeleteObject(dat->hFont); 
    245                                 dat->hFont = CreateFontIndirect(&lf); 
    246                         } 
    247                         else { 
    248                                 dat->clrText = GetDefaultColor(FRAMEELEMENT_TEXT); 
    249                                 if (GetDefaultFont(&lf) != NULL) { 
    250                                         if (dat->hFont != NULL) DeleteObject(dat->hFont); 
    251                                         dat->hFont = CreateFontIndirect(&lf); 
    252                                 } 
    253                         } 
     249                        dat->clrText = Font_GetW(L"Automatic shutdown", L"Countdown on frame", &lf); 
     250                        if (dat->hFont != NULL) DeleteObject(dat->hFont); 
     251                        dat->hFont = CreateFontIndirect(&lf); 
    254252                } 
    255253                if (dat->hwndDesc != NULL) 
  • trunk/plugins/BASS_interface/src/Main.cpp

    r17267 r17347  
    425425int ReloadColors(WPARAM, LPARAM) 
    426426{ 
    427         ColourIDW colourid = { 0 }; 
    428         colourid.cbSize = sizeof(colourid); 
    429         mir_wstrcpy(colourid.group, _A2W(ModuleName)); 
    430         mir_wstrcpy(colourid.name, LPGENW("Frame background")); 
    431         clBack = CallService(MS_COLOUR_GETW, (WPARAM)&colourid, 0); 
     427        clBack = Colour_GetW(_A2W(ModuleName), LPGENW("Frame background")); 
    432428 
    433429        if (hBkgBrush) 
     
    475471 
    476472        colourid.defcolour = GetSysColor(COLOR_3DFACE); 
    477         ColourRegisterW(&colourid); 
     473        Colour_RegisterW(&colourid); 
    478474 
    479475        HookEvent(ME_COLOUR_RELOAD, ReloadColors); 
  • trunk/plugins/BasicHistory/src/Options.cpp

    r17226 r17347  
    256256                wcsncpy_s(fid.backgroundName, g_FontOptionsList[i].szBackgroundName, _TRUNCATE); 
    257257                fid.flags = FIDF_DEFAULTVALID | FIDF_CLASSGENERAL | g_FontOptionsList[i].flags; 
    258                 FontRegisterW(&fid); 
     258                Font_RegisterW(&fid); 
    259259        } 
    260260 
     
    266266                cid.order = i; 
    267267                cid.defcolour = g_ColorOptionsList[i].def; 
    268                 ColourRegisterW(&cid); 
     268                Colour_RegisterW(&cid); 
    269269        } 
    270270 
     
    413413COLORREF Options::GetFont(Fonts fontId, PLOGFONT font) 
    414414{ 
    415         FontIDW fid = { 0 }; 
    416         fid.cbSize = sizeof(FontIDW); 
    417         wcsncpy_s(fid.group, LPGENW("History"), _TRUNCATE); 
    418         wcsncpy_s(fid.name, g_FontOptionsList[fontId].szDescr, _TRUNCATE); 
    419         return (COLORREF)CallService(MS_FONT_GETW, (WPARAM)&fid, (LPARAM)font); 
     415        return Font_GetW(LPGENW("History"), g_FontOptionsList[fontId].szDescr, font); 
    420416} 
    421417 
    422418COLORREF Options::GetColor(Colors colorId) 
    423419{ 
    424         ColourIDW cid = { 0 }; 
    425         cid.cbSize = sizeof(ColourIDW); 
    426         wcsncpy_s(cid.group, LPGENW("History"), _TRUNCATE); 
    427         wcsncpy_s(cid.name, g_ColorOptionsList[colorId].tszName, _TRUNCATE); 
    428         return (COLORREF)CallService(MS_COLOUR_GETW, (WPARAM)&cid, NULL); 
     420        return Colour_GetW(LPGENW("History"), g_ColorOptionsList[colorId].tszName); 
    429421} 
    430422 
  • trunk/plugins/Clist_modern/src/modern_clcopts.cpp

    r17243 r17347  
    151151                mir_wstrncpy(fontid.deffontsettings.szFace, fontOptionsList[i].szDefFace, _countof(fontid.deffontsettings.szFace)); 
    152152 
    153                 FontRegisterW(&fontid); 
     153                Font_RegisterW(&fontid); 
    154154 
    155155                mir_wstrncpy(effectid.group, fontOptionsList[i].szGroup, _countof(effectid.group)); 
     
    163163                effectid.defeffect.secondaryColour = fontOptionsList[i].defeffect.secondaryColour; 
    164164 
    165                 EffectRegisterW(&effectid); 
     165                Effect_RegisterW(&effectid); 
    166166        } 
    167167 
     
    176176                colourid.defcolour = colourOptionsList[i].defColour; 
    177177                colourid.order = i + 1; 
    178                 ColourRegisterW(&colourid); 
     178                Colour_RegisterW(&colourid); 
    179179        } 
    180180        registered = true; 
     
    204204                return; 
    205205 
    206         FontIDW fontid = { 0 }; 
    207         fontid.cbSize = sizeof(fontid); 
    208         mir_wstrncpy(fontid.group, fontOptionsList[index].szGroup, _countof(fontid.group)); 
    209         mir_wstrncpy(fontid.name, fontOptionsList[index].szDescr, _countof(fontid.name)); 
    210  
    211         COLORREF col = CallService(MS_FONT_GETW, (WPARAM)&fontid, (LPARAM)lf); 
     206        COLORREF col = Font_GetW(fontOptionsList[index].szGroup, fontOptionsList[index].szDescr, lf); 
    212207 
    213208        if (colour) 
  • trunk/plugins/Clist_nicer/src/clui.cpp

    r17255 r17347  
    20002000                strncpy(fid.prefix, idstr, _countof(fid.prefix)); 
    20012001                fid.order = i; 
    2002                 FontRegisterW(&fid); 
     2002                Font_RegisterW(&fid); 
    20032003        } 
    20042004        ReleaseDC(NULL, hdc); 
     
    20142014        wcsncpy(colourid.group, LPGENW("Contact list"), _countof(colourid.group)); 
    20152015        colourid.defcolour = CLCDEFAULT_BKCOLOUR; 
    2016         ColourRegisterW(&colourid); 
     2016        Colour_RegisterW(&colourid); 
    20172017 
    20182018        strncpy(colourid.setting, "SelTextColour", sizeof(colourid.setting)); 
     
    20202020        colourid.order = 1; 
    20212021        colourid.defcolour = CLCDEFAULT_SELTEXTCOLOUR; 
    2022         ColourRegisterW(&colourid); 
     2022        Colour_RegisterW(&colourid); 
    20232023 
    20242024        strncpy(colourid.setting, "HotTextColour", sizeof(colourid.setting)); 
     
    20262026        colourid.order = 1; 
    20272027        colourid.defcolour = CLCDEFAULT_HOTTEXTCOLOUR; 
    2028         ColourRegisterW(&colourid); 
     2028        Colour_RegisterW(&colourid); 
    20292029 
    20302030        strncpy(colourid.setting, "QuickSearchColour", sizeof(colourid.setting)); 
     
    20322032        colourid.order = 1; 
    20332033        colourid.defcolour = CLCDEFAULT_QUICKSEARCHCOLOUR; 
    2034         ColourRegisterW(&colourid); 
     2034        Colour_RegisterW(&colourid); 
    20352035 
    20362036        strncpy(colourid.dbSettingsGroup, "CLUI", sizeof(colourid.dbSettingsGroup)); 
     
    20392039        colourid.order = 1; 
    20402040        colourid.defcolour = RGB(40, 40, 40); 
    2041         ColourRegisterW(&colourid); 
    2042 } 
     2041        Colour_RegisterW(&colourid); 
     2042} 
  • trunk/plugins/Console/src/Console.cpp

    r17291 r17347  
    10721072{ 
    10731073        if (hwndConsole) { 
    1074                 ColourID cid = { 0 }; 
    1075  
    1076                 cid.cbSize = sizeof(cid); 
    1077                 mir_strcpy(cid.group, "Console"); 
    1078                 mir_strcpy(cid.name, "Background"); 
    1079                 mir_strcpy(cid.dbSettingsGroup, "Console"); 
    1080                 mir_strcpy(cid.setting, "BgColor"); 
    1081  
    1082                 colBackground = (COLORREF)CallService(MS_COLOUR_GET, (WPARAM)&cid, 0); 
     1074                colBackground = Colour_Get("Console", "Background"); 
    10831075                if (colBackground != -1) 
    10841076                        SendMessage(hwndConsole, HM_SETCOLOR, (WPARAM)hfLogFont, (LPARAM)colBackground); 
     
    10931085                HFONT hf = NULL; 
    10941086                LOGFONT LogFont = { 0 }; 
    1095                 FontIDW fid = { 0 }; 
    1096                 fid.cbSize = sizeof(fid); 
    1097  
    1098                 mir_wstrncpy(fid.group, LPGENW("Console"), _countof(fid.group)); 
    1099                 mir_wstrncpy(fid.name, LPGENW("Text"), _countof(fid.name)); 
    1100  
    1101                 colLogFont = (COLORREF)CallService(MS_FONT_GETW, (WPARAM)&fid, (LPARAM)&LogFont); 
     1087                colLogFont = Font_GetW(L"Console", L"Text", &LogFont); 
    11021088 
    11031089                if (LogFont.lfHeight != 0) { 
     
    11321118        fid.deffontsettings.style = 0; 
    11331119        mir_wstrncpy(fid.deffontsettings.szFace, L"Courier", _countof(fid.deffontsettings.szFace)); 
    1134         FontRegisterW(&fid); 
     1120        Font_RegisterW(&fid); 
    11351121 
    11361122        HookEvent(ME_FONT_RELOAD, OnFontChange); 
     
    11431129        mir_strncpy(cid.setting, "BgColor", _countof(cid.setting)); 
    11441130        cid.defcolour = RGB(255, 255, 255); 
    1145         ColourRegisterW(&cid); 
     1131        Colour_RegisterW(&cid); 
    11461132 
    11471133        HookEvent(ME_COLOUR_RELOAD, OnColourChange); 
  • trunk/plugins/FavContacts/src/services.cpp

    r17265 r17347  
    128128 
    129129        LOGFONT lf = { 0 }; 
    130         FontIDW fontid = { sizeof(fontid) }; 
    131         mir_wstrcpy(fontid.group, LPGENW("Favorite Contacts")); 
    132         mir_wstrcpy(fontid.name, LPGENW("Contact name")); 
    133         g_Options.clLine1 = CallService(MS_FONT_GETW, (WPARAM)&fontid, (LPARAM)&lf); 
     130        g_Options.clLine1 = Font_GetW(LPGENW("Favorite Contacts"), LPGENW("Contact name"), &lf); 
    134131        g_Options.hfntName = CreateFontIndirect(&lf); 
    135132 
    136         mir_wstrcpy(fontid.name, LPGENW("Second line")); 
    137         g_Options.clLine2 = CallService(MS_FONT_GETW, (WPARAM)&fontid, (LPARAM)&lf); 
     133        g_Options.clLine2 = Font_GetW(LPGENW("Favorite Contacts"), LPGENW("Second line"), &lf); 
    138134        g_Options.hfntSecond = CreateFontIndirect(&lf); 
    139135 
    140         mir_wstrcpy(fontid.name, LPGENW("Selected contact name (color)")); 
    141         g_Options.clLine1Sel = CallService(MS_FONT_GETW, (WPARAM)&fontid, (LPARAM)&lf); 
    142  
    143         mir_wstrcpy(fontid.name, LPGENW("Selected second line (color)")); 
    144         g_Options.clLine2Sel = CallService(MS_FONT_GETW, (WPARAM)&fontid, (LPARAM)&lf); 
    145  
    146         ColourIDW colourid = { sizeof(colourid) }; 
    147         mir_wstrcpy(colourid.group, LPGENW("Favorite Contacts")); 
    148         mir_wstrcpy(colourid.name, LPGENW("Background")); 
    149         g_Options.clBack = CallService(MS_COLOUR_GETW, (WPARAM)&colourid, (LPARAM)&lf); 
    150  
    151         mir_wstrcpy(colourid.name, LPGENW("Selected background")); 
    152         g_Options.clBackSel = CallService(MS_COLOUR_GETW, (WPARAM)&colourid, (LPARAM)&lf); 
     136        g_Options.clLine1Sel = Font_GetW(LPGENW("Favorite Contacts"), LPGENW("Selected contact name (color)"), &lf); 
     137        g_Options.clLine2Sel = Font_GetW(LPGENW("Favorite Contacts"), LPGENW("Selected second line (color)"), &lf); 
     138 
     139        g_Options.clBack = Colour_GetW(LPGENW("Favorite Contacts"), LPGENW("Background")); 
     140        g_Options.clBackSel = Colour_GetW(LPGENW("Favorite Contacts"), LPGENW("Selected background")); 
    153141 
    154142        return 0; 
     
    187175        fontid.deffontsettings.colour = GetSysColor(COLOR_MENUTEXT); 
    188176        fontid.deffontsettings.style = DBFONTF_BOLD; 
    189         FontRegisterW(&fontid); 
     177        Font_RegisterW(&fontid); 
    190178 
    191179        mir_wstrcpy(fontid.name, LPGENW("Second line")); 
     
    193181        fontid.deffontsettings.colour = sttShadeColor(GetSysColor(COLOR_MENUTEXT), GetSysColor(COLOR_MENU)); 
    194182        fontid.deffontsettings.style = 0; 
    195         FontRegisterW(&fontid); 
     183        Font_RegisterW(&fontid); 
    196184 
    197185        mir_wstrcpy(fontid.backgroundName, LPGENW("Selected background")); 
     
    201189        fontid.deffontsettings.colour = GetSysColor(COLOR_HIGHLIGHTTEXT); 
    202190        fontid.deffontsettings.style = DBFONTF_BOLD; 
    203         FontRegisterW(&fontid); 
     191        Font_RegisterW(&fontid); 
    204192 
    205193        mir_wstrcpy(fontid.name, LPGENW("Selected second line (color)")); 
     
    207195        fontid.deffontsettings.colour = sttShadeColor(GetSysColor(COLOR_HIGHLIGHTTEXT), GetSysColor(COLOR_HIGHLIGHT)); 
    208196        fontid.deffontsettings.style = 0; 
    209         FontRegisterW(&fontid); 
     197        Font_RegisterW(&fontid); 
    210198 
    211199        ///////////////////////////////////////////////////////////////////////////////////// 
     
    218206        mir_strcpy(colourid.setting, "BackColour"); 
    219207        colourid.defcolour = GetSysColor(COLOR_MENU); 
    220         ColourRegisterW(&colourid); 
     208        Colour_RegisterW(&colourid); 
    221209 
    222210        mir_wstrcpy(colourid.name, LPGENW("Selected background")); 
    223211        mir_strcpy(colourid.setting, "SelectedColour"); 
    224212        colourid.defcolour = GetSysColor(COLOR_HIGHLIGHT); 
    225         ColourRegisterW(&colourid); 
     213        Colour_RegisterW(&colourid); 
    226214 
    227215        HookEvent(ME_FONT_RELOAD, ProcessReloadFonts); 
  • trunk/plugins/FloatingContacts/src/main.cpp

    r17267 r17347  
    533533 
    534534                LOGFONT lf; 
    535                 FontService_GetFont(LPGENW("Floating contacts"), s_fonts[nFontId], &tColor[nFontId], &lf); 
     535                tColor[nFontId] = Font_GetW(LPGENW("Floating contacts"), s_fonts[nFontId], &lf); 
    536536                hFont[nFontId] = CreateFontIndirect(&lf); 
    537537        } 
  • trunk/plugins/HistoryPlusPlus/hpp_options.pas

    r14176 r17347  
    363363  size: Integer = -11; 
    364364var 
    365   fid: TFontID; 
    366365  lf: TLogFontA; 
    367366  col: TColor; 
    368367begin 
    369   fid.cbSize := sizeof(fid); 
    370   fid.group := hppName; 
    371   lstrcpya(fid.name, hppFontItems[Order].name { TRANSLATE-IGNORE } ); 
    372   col := CallService(MS_FONT_GETA, WPARAM(@fid), LPARAM(@lf)); 
     368  col := Font_Get(hppName, hppFontItems[Order].name, @lf); 
    373369  F.handle := CreateFontIndirectA(lf); 
    374370  F.color := col; 
  • trunk/plugins/MyDetails/src/frame.cpp

    r17255 r17347  
    199199 
    200200                LOGFONT log_font; 
    201                 font_colour[i] = CallService(MS_FONT_GETW, (WPARAM)&font_id[i], (LPARAM)&log_font); 
     201                font_colour[i] = Font_GetW(font_id[i], &log_font); 
    202202                hFont[i] = CreateFontIndirect(&log_font); 
    203203        } 
     
    209209int ReloadColour(WPARAM, LPARAM) 
    210210{ 
    211         opts.bkg_color = (COLORREF)CallService(MS_COLOUR_GET, (WPARAM)&bg_colour, 0); 
    212         opts.draw_avatar_border_color = (COLORREF)CallService(MS_COLOUR_GET, (WPARAM)&av_colour, 0); 
     211        opts.bkg_color = Colour_Get(bg_colour.group, bg_colour.name); 
     212        opts.draw_avatar_border_color = Colour_Get(av_colour.group, av_colour.name); 
    213213 
    214214        RefreshFrame(); 
     
    226226        HDC hdc = GetDC(NULL); 
    227227 
    228         ColourRegister(&bg_colour); 
    229         ColourRegister(&av_colour); 
     228        Colour_Register(&bg_colour); 
     229        Colour_Register(&av_colour); 
    230230        ReloadColour(0, 0); 
    231231        HookEvent(ME_COLOUR_RELOAD, ReloadColour); 
     
    250250                font_id[i].order = i; 
    251251                font_id[i].flags = FIDF_DEFAULTVALID; 
    252                 FontRegisterW(&font_id[i]); 
     252                Font_RegisterW(&font_id[i]); 
    253253        } 
    254254 
  • trunk/plugins/NotesAndReminders/src/options.cpp

    r17346 r17347  
    254254                strncpy(fontid.backgroundName, fontOptionsList[i].szBkgName, _countof(fontid.backgroundName)); 
    255255 
    256                 FontRegister(&fontid); 
     256                Font_Register(&fontid); 
    257257        } 
    258258 
     
    270270                strncpy(colorid.setting, colourOptionsList[i].szSettingName, _countof(colorid.setting)); 
    271271 
    272                 ColourRegister(&colorid); 
     272                Colour_Register(&colorid); 
    273273        } 
    274274 
     
    279279void LoadNRFont(int i, LOGFONT *lf, COLORREF *colour) 
    280280{ 
    281         FontID fontid = { 0 }; 
    282         fontid.cbSize = sizeof(fontid); 
    283         strncpy(fontid.group, LPGEN(SECTIONNAME), _countof(fontid.group)); 
    284         strncpy(fontid.name, fontOptionsList[i].szDescr, _countof(fontid.name)); 
    285  
    286         COLORREF col = CallService(MS_FONT_GET, (WPARAM)&fontid, (LPARAM)lf); 
     281        COLORREF col = Font_Get(SECTIONNAME, fontOptionsList[i].szDescr, lf); 
    287282        if (colour) 
    288283                *colour = col; 
  • trunk/plugins/Ping/src/pingthread.cpp

    r17143 r17347  
    782782 
    783783        LOGFONT log_font; 
    784         CallService(MS_FONT_GETW, (WPARAM)&font_id, (LPARAM)&log_font); 
     784        Font_GetW(font_id, &log_font); 
    785785        hFont = CreateFontIndirect(&log_font); 
    786786        SendMessage(list_hwnd, WM_SETFONT, (WPARAM)hFont, TRUE); 
    787787 
    788         bk_col = CallService(MS_COLOUR_GETW, (WPARAM)&bk_col_id, 0); 
     788        bk_col = Colour_GetW(bk_col_id); 
    789789        RefreshWindow(0, 0); 
    790790 
     
    932932        mir_wstrncpy(font_id.deffontsettings.szFace, L"Tahoma", _countof(font_id.deffontsettings.szFace)); 
    933933 
    934         FontRegisterW(&font_id); 
     934        Font_RegisterW(&font_id); 
    935935 
    936936        bk_col_id.cbSize = sizeof(ColourIDW); 
     
    940940        mir_strncpy(bk_col_id.setting, "BgColor", _countof(bk_col_id.setting)); 
    941941        bk_col_id.defcolour = RGB(0, 0, 0); 
    942         ColourRegisterW(&bk_col_id); 
     942        Colour_RegisterW(&bk_col_id); 
    943943 
    944944        HookEvent(ME_FONT_RELOAD, ReloadFont); 
  • trunk/plugins/Popup/src/font.cpp

    r17157 r17347  
    4444        fid.deffontsettings.style = DBFONTF_BOLD; 
    4545        fid.deffontsettings.colour = RGB(0, 0, 0); 
    46         FontRegisterW(&fid); 
     46        Font_RegisterW(&fid); 
    4747 
    4848        mir_wstrncpy(fid.name, _A2W(PU_FNT_NAME_CLOCK), _countof(fid.name)); 
    4949        mir_snprintf(fid.prefix, PU_FNT_PREFIX, PU_FNT_NAME_CLOCK); 
    50         FontRegisterW(&fid); 
     50        Font_RegisterW(&fid); 
    5151 
    5252        mir_wstrncpy(fid.name, _A2W(PU_FNT_NAME_TEXT), _countof(fid.name)); 
    5353        mir_snprintf(fid.prefix, PU_FNT_PREFIX, PU_FNT_NAME_TEXT); 
    5454        fid.deffontsettings.style = 0; 
    55         FontRegisterW(&fid); 
     55        Font_RegisterW(&fid); 
    5656 
    5757        mir_wstrncpy(fid.name, _A2W(PU_FNT_NAME_ACTION), _countof(fid.name)); 
     
    5959        fid.flags = FIDF_DEFAULTVALID | FIDF_ALLOWEFFECTS; 
    6060        fid.deffontsettings.colour = RGB(0, 0, 255); 
    61         FontRegisterW(&fid); 
     61        Font_RegisterW(&fid); 
    6262 
    6363        mir_wstrncpy(fid.name, _A2W(PU_FNT_NAME_HOVERED_ACTION), _countof(fid.name)); 
    6464        mir_snprintf(fid.prefix, PU_FNT_PREFIX, PU_FNT_NAME_HOVERED_ACTION); 
    6565        fid.deffontsettings.style = DBFONTF_UNDERLINE; 
    66         FontRegisterW(&fid); 
     66        Font_RegisterW(&fid); 
    6767 
    6868        ColourIDW cid = { 0 }; 
     
    7474        mir_strncpy(cid.setting, PU_COL_BACK_SETTING, _countof(cid.setting)); 
    7575        cid.defcolour = SETTING_BACKCOLOUR_DEFAULT; 
    76         ColourRegisterW(&cid); 
     76        Colour_RegisterW(&cid); 
    7777 
    7878        mir_wstrncpy(cid.name, PU_COL_AVAT_NAME, _countof(cid.name)); 
    7979        mir_strncpy(cid.setting, PU_COL_AVAT_SETTING, _countof(cid.setting)); 
    8080        cid.defcolour = SETTING_TEXTCOLOUR_DEFAULT; 
    81         ColourRegisterW(&cid); 
     81        Colour_RegisterW(&cid); 
    8282 
    8383        ReloadFonts(); 
     
    9494 
    9595        LOGFONT lf = { 0 }; 
    96         FontIDW fid = { 0 }; 
    97         fid.cbSize = sizeof(FontIDW); 
    98         mir_wstrncpy(fid.group, _A2W(PU_FNT_AND_COLOR), _countof(fid.name)); 
    99  
    100         mir_wstrncpy(fid.name, _A2W(PU_FNT_NAME_TITLE), _countof(fid.name)); 
    101         fonts.clTitle = (COLORREF)CallService(MS_FONT_GETW, (WPARAM)&fid, (LPARAM)&lf); 
     96        fonts.clTitle = Font_GetW(_A2W(PU_FNT_AND_COLOR), _A2W(PU_FNT_NAME_TITLE), &lf); 
    10297        fonts.title = CreateFontIndirect(&lf); 
    10398 
    104         mir_wstrncpy(fid.name, _A2W(PU_FNT_NAME_CLOCK), _countof(fid.name)); 
    105         fonts.clClock = (COLORREF)CallService(MS_FONT_GETW, (WPARAM)&fid, (LPARAM)&lf); 
     99        fonts.clClock = Font_GetW(_A2W(PU_FNT_AND_COLOR), _A2W(PU_FNT_NAME_CLOCK), &lf); 
    106100        fonts.clock = CreateFontIndirect(&lf); 
    107101 
    108         mir_wstrncpy(fid.name, _A2W(PU_FNT_NAME_TEXT), _countof(fid.name)); 
    109         fonts.clText = (COLORREF)CallService(MS_FONT_GETW, (WPARAM)&fid, (LPARAM)&lf); 
     102        fonts.clText = Font_GetW(_A2W(PU_FNT_AND_COLOR), _A2W(PU_FNT_NAME_TEXT), &lf); 
    110103        fonts.text = CreateFontIndirect(&lf); 
    111104 
    112         mir_wstrncpy(fid.name, _A2W(PU_FNT_NAME_ACTION), _countof(fid.name)); 
    113         fonts.clAction = (COLORREF)CallService(MS_FONT_GETW, (WPARAM)&fid, (LPARAM)&lf); 
     105        fonts.clAction = Font_GetW(_A2W(PU_FNT_AND_COLOR), _A2W(PU_FNT_NAME_ACTION), &lf); 
    114106        fonts.action = CreateFontIndirect(&lf); 
    115107 
    116         mir_wstrncpy(fid.name, _A2W(PU_FNT_NAME_HOVERED_ACTION), _countof(fid.name)); 
    117         fonts.clActionHover = (COLORREF)CallService(MS_FONT_GETW, (WPARAM)&fid, (LPARAM)&lf); 
     108        fonts.clActionHover = Font_GetW(_A2W(PU_FNT_AND_COLOR), _A2W(PU_FNT_NAME_HOVERED_ACTION), &lf); 
    118109        fonts.actionHover = CreateFontIndirect(&lf); 
    119110 
    120         ColourIDW cid = { 0 }; 
    121         cid.cbSize = sizeof(ColourIDW); 
    122         mir_wstrncpy(cid.group, _A2W(PU_FNT_AND_COLOR), _countof(cid.group)); 
    123         mir_wstrncpy(cid.name, PU_COL_BACK_NAME, _countof(cid.name)); 
    124         fonts.clBack = (COLORREF)CallService(MS_COLOUR_GETW, (WPARAM)&cid, (LPARAM)&lf); 
    125  
    126         mir_wstrncpy(cid.group, _A2W(PU_FNT_AND_COLOR), _countof(cid.group)); 
    127         mir_wstrncpy(cid.name, PU_COL_AVAT_NAME, _countof(cid.name)); 
    128         fonts.clAvatarBorder = (COLORREF)CallService(MS_COLOUR_GETW, (WPARAM)&cid, (LPARAM)&lf); 
     111        fonts.clBack = Colour_GetW(_A2W(PU_FNT_AND_COLOR), PU_COL_BACK_NAME); 
     112        fonts.clAvatarBorder = Colour_GetW(_A2W(PU_FNT_AND_COLOR), PU_COL_AVAT_NAME); 
    129113 
    130114        // update class popupps(only temp at this point, must rework) 
  • trunk/plugins/Popup/src/notifications.cpp

    r17138 r17347  
    197197        mir_snprintf(fontid.prefix, "{%s/%s}text", notification->lpzGroup, notification->lpzName); 
    198198        fontid.deffontsettings.style = 0; 
    199         FontRegister(&fontid); 
     199        Font_Register(&fontid); 
    200200 
    201201        ColourID colourid = { 0 }; 
     
    206206        mir_snprintf(colourid.setting, "{%s/%s}backColor", notification->lpzGroup, notification->lpzName); 
    207207        colourid.defcolour = ptd->notification.colorBack; 
    208         ColourRegister(&colourid); 
     208        Colour_Register(&colourid); 
    209209 
    210210        gTreeData.insert(ptd); 
     
    235235 
    236236        LOGFONTA lf; // dummy to make FS happy (use LOGFONTA coz we use MS_FONT_GET) 
    237         FontID fontid = { 0 }; // use ansi version of fontID coz POPUPNOTIFICATION use char 
    238         fontid.cbSize = sizeof(fontid); 
    239         mir_snprintf(fontid.group, PU_FNT_AND_COLOR"/%s", ptd->notification.lpzGroup); 
    240         mir_snprintf(fontid.name, "%s (colors only)", ptd->notification.lpzName); 
    241         ppd->colorText = (COLORREF)CallService(MS_FONT_GET, (WPARAM)&fontid, (LPARAM)&lf); 
    242  
    243         ColourID colourid = { 0 }; // use ansi version of ColourID coz POPUPNOTIFICATION use char 
    244         colourid.cbSize = sizeof(colourid); 
    245         mir_snprintf(colourid.group, PU_FNT_AND_COLOR"/%s", ptd->notification.lpzGroup); 
    246         mir_snprintf(colourid.name, "%s (colors only)", ptd->notification.lpzName); 
    247         ppd->colorBack = (COLORREF)CallService(MS_COLOUR_GET, (WPARAM)&colourid, 0); 
     237        CMStringA szGroup(FORMAT, PU_FNT_AND_COLOR"/%s", ptd->notification.lpzGroup); 
     238        CMStringA szName(FORMAT, "%s (colors only)", ptd->notification.lpzName); 
     239        ppd->colorText = Font_Get(szGroup, szName, &lf); 
     240        ppd->colorBack = Colour_Get(szGroup, szName); 
    248241 
    249242        ppd->lchIcon = IcoLib_GetIconByHandle(ptd->hIcoLib); 
  • trunk/plugins/Popup/src/services.cpp

    r17157 r17347  
    393393        fid.deffontsettings.style = 0; 
    394394        fid.deffontsettings.colour = fonts.clText; 
    395         FontRegisterW(&fid); 
     395        Font_RegisterW(&fid); 
    396396 
    397397        // we ignore pc->colorBack and use fonts.clBack as default (if no setting found in DB) 
     
    405405        mir_snprintf(cid.setting, "%s/BgCol", ptd->pupClass.pszName); 
    406406        cid.defcolour = fonts.clBack; 
    407         ColourRegisterW(&cid); 
     407        Colour_RegisterW(&cid); 
    408408 
    409409        gTreeData.insert(ptd); 
  • trunk/plugins/QuickSearch/i_ok.inc

    r17296 r17347  
    6262function ColorReload(wParam:WPARAM;lParam:LPARAM):int;cdecl; 
    6363var 
    64   cid:TColourID; 
    6564  i:tqscolor; 
    6665begin 
    6766  result:=0; 
    68   cid.cbSize:=SizeOf(cid); 
    69   StrCopy(cid.group,qs_module); 
    7067  for i:=Low(tqscolor) to High(tqscolor) do 
    7168  begin 
    72     StrCopy(cid.name ,QSColors[i].descr); 
    73     QSColors[i].color:=CallService(MS_COLOUR_GETA,tlparam(@cid),0); 
     69    QSColors[i].color:=Colour_Get(qs_module,QSColors[i].descr); 
    7470  end; 
    7571end; 
  • trunk/plugins/QuickSearch/sr_frame.pas

    r14386 r17347  
    128128 
    129129function ColorReload(wParam:WPARAM;lParam:LPARAM):int;cdecl; 
    130 var 
    131   cid:TColourID; 
    132130begin 
    133131  result:=0; 
    134   cid.cbSize:=SizeOf(cid); 
    135   StrCopy(cid.group,'QuickSearch'); 
    136   StrCopy(cid.name ,frm_back); 
    137   frm_bkg:=CallService(MS_COLOUR_GETA,twparam(@cid),0); 
     132  frm_bkg:=Colour_Get('QuickSearch',frm_back); 
    138133  DeleteObject(hbr); 
    139134  hbr:=CreateSolidBrush(frm_bkg); 
  • trunk/plugins/Scriver/src/msgoptions.cpp

    r17268 r17347  
    124124                wcsncpy(fid.deffontsettings.szFace, fontOptionsList[i].szDefFace, _countof(fid.deffontsettings.szFace)); 
    125125                wcsncpy(fid.backgroundName, fontOptionsList[i].szBkgName, _countof(fid.backgroundName)); 
    126                 FontRegisterW(&fid); 
     126                Font_RegisterW(&fid); 
    127127        } 
    128128 
     
    140140 
    141141                strncpy(cid.setting, colourOptionsList[i].szSettingName, _countof(cid.setting)); 
    142                 ColourRegisterW(&cid); 
     142                Colour_RegisterW(&cid); 
    143143        } 
    144144} 
  • trunk/plugins/SmileyAdd/src/main.cpp

    r16389 r17347  
    7474        strcpy_s(cid.setting, "SelWndBkgClr"); 
    7575        cid.defcolour = GetSysColor(COLOR_WINDOW); 
    76         ColourRegister(&cid); 
     76        Colour_Register(&cid); 
    7777        return 0; 
    7878} 
  • trunk/plugins/TabSRMM/src/chat/options.cpp

    r17143 r17347  
    553553                        break; 
    554554                } 
    555                 FontRegisterW(&fid); 
     555                Font_RegisterW(&fid); 
    556556        } 
    557557 
     
    579579                        wcsncpy(fid.group, LPGENW("Message Sessions"), _countof(fid.group)); 
    580580                } 
    581                 FontRegisterW(&fid); 
     581                Font_RegisterW(&fid); 
    582582        } 
    583583 
     
    600600                        break; 
    601601                } 
    602                 ColourRegisterW(&cid); 
     602                Colour_RegisterW(&cid); 
    603603        } 
    604604        cid.order++; 
     
    606606        strncpy_s(cid.setting, "ColorNicklistBG", _TRUNCATE); 
    607607        cid.defcolour = SRMSGDEFSET_BKGCOLOUR; 
    608         ColourRegisterW(&cid); 
     608        Colour_RegisterW(&cid); 
    609609 
    610610        cid.order++; 
    611611        wcsncpy_s(cid.name, LPGENW("Group chat log background"), _TRUNCATE); 
    612612        strncpy_s(cid.setting, "ColorLogBG", _TRUNCATE); 
    613         ColourRegisterW(&cid); 
     613        Colour_RegisterW(&cid); 
    614614 
    615615        // static colors (info panel, tool bar background etc...) 
     
    626626                else 
    627627                        cid.defcolour = _clrs[i].def; 
    628                 ColourRegisterW(&cid); 
     628                Colour_RegisterW(&cid); 
    629629        } 
    630630 
     
    642642                        cid.defcolour = _tabclrs[i].def; 
    643643 
    644                 ColourRegisterW(&cid); 
     644                Colour_RegisterW(&cid); 
    645645        } 
    646646} 
  • trunk/plugins/TipperYM/src/tipper.cpp

    r17267 r17347  
    7070        LOGFONT logFont; 
    7171        if (hFontTitle) DeleteObject(hFontTitle); 
    72         opt.colTitle = CallService(MS_FONT_GETW, (WPARAM)&fontTitle, (LPARAM)&logFont); 
     72        opt.colTitle = Font_GetW(fontTitle, &logFont); 
    7373        hFontTitle = CreateFontIndirect(&logFont); 
     74 
    7475        if (hFontLabels) DeleteObject(hFontLabels); 
    75         opt.colLabel = CallService(MS_FONT_GETW, (WPARAM)&fontLabels, (LPARAM)&logFont); 
     76        opt.colLabel = Font_GetW(fontLabels, &logFont); 
    7677        hFontLabels = CreateFontIndirect(&logFont); 
     78 
    7779        if (hFontValues) DeleteObject(hFontValues); 
    78         opt.colValue = CallService(MS_FONT_GETW, (WPARAM)&fontValues, (LPARAM)&logFont); 
     80        opt.colValue = Font_GetW(fontValues, &logFont); 
    7981        hFontValues = CreateFontIndirect(&logFont); 
     82 
    8083        if (hFontTrayTitle) DeleteObject(hFontTrayTitle); 
    81         opt.colTrayTitle = CallService(MS_FONT_GETW, (WPARAM)&fontTrayTitle, (LPARAM)&logFont); 
     84        opt.colTrayTitle = Font_GetW(fontTrayTitle, &logFont); 
    8285        hFontTrayTitle = CreateFontIndirect(&logFont); 
    8386 
    84         opt.colBg = CallService(MS_COLOUR_GETW, (WPARAM)&colourBg, 0); 
    85         opt.colBorder = CallService(MS_COLOUR_GETW, (WPARAM)&colourBorder, 0); 
    86         opt.colAvatarBorder = CallService(MS_COLOUR_GETW, (WPARAM)&colourAvatarBorder, 0); 
    87         opt.colSidebar = CallService(MS_COLOUR_GETW, (WPARAM)&colourSidebar, 0); 
    88         opt.colDivider = CallService(MS_COLOUR_GETW, (WPARAM)&colourDivider, 0); 
     87        opt.colBg = Colour_GetW(colourBg); 
     88        opt.colBorder = Colour_GetW(colourBorder); 
     89        opt.colAvatarBorder = Colour_GetW(colourAvatarBorder); 
     90        opt.colSidebar = Colour_GetW(colourSidebar); 
     91        opt.colDivider = Colour_GetW(colourDivider); 
    8992 
    9093        return 0; 
     
    131134        colourBg.defcolour = RGB(219, 219, 219); 
    132135        colourBg.order = 0; 
    133         ColourRegisterW(&colourBg); 
     136        Colour_RegisterW(&colourBg); 
    134137 
    135138        colourBorder.cbSize = sizeof(ColourIDW); 
     
    140143        colourBorder.defcolour = 0; 
    141144        colourBorder.order = 0; 
    142         ColourRegisterW(&colourBorder); 
     145        Colour_RegisterW(&colourBorder); 
    143146 
    144147        colourAvatarBorder.cbSize = sizeof(ColourIDW); 
     
    149152        colourAvatarBorder.defcolour = 0; 
    150153        colourAvatarBorder.order = 0; 
    151         ColourRegisterW(&colourAvatarBorder); 
     154        Colour_RegisterW(&colourAvatarBorder); 
    152155 
    153156        colourDivider.cbSize = sizeof(ColourIDW); 
     
    158161        colourDivider.defcolour = 0; 
    159162        colourDivider.order = 0; 
    160         ColourRegisterW(&colourDivider); 
     163        Colour_RegisterW(&colourDivider); 
    161164 
    162165        colourSidebar.cbSize = sizeof(ColourIDW); 
     
    167170        colourSidebar.defcolour = RGB(192, 192, 192); 
    168171        colourSidebar.order = 0; 
    169         ColourRegisterW(&colourSidebar); 
     172        Colour_RegisterW(&colourSidebar); 
    170173 
    171174        fontTitle.cbSize = sizeof(FontIDW); 
     
    233236        fontTrayTitle.flags |= FIDF_DEFAULTVALID; 
    234237 
    235         FontRegisterW(&fontTitle); 
    236         FontRegisterW(&fontLabels); 
    237         FontRegisterW(&fontValues); 
    238         FontRegisterW(&fontTrayTitle); 
     238        Font_RegisterW(&fontTitle); 
     239        Font_RegisterW(&fontLabels); 
     240        Font_RegisterW(&fontValues); 
     241        Font_RegisterW(&fontTrayTitle); 
    239242 
    240243        hReloadFonts = HookEvent(ME_FONT_RELOAD, ReloadFont); 
  • trunk/plugins/TooltipNotify/src/TooltipNotify.cpp

    r17265 r17347  
    9696                strncpy(fontId.prefix, s_fontTable[i].fontPrefix, _countof(fontId.prefix) - 1); 
    9797                wcsncpy(fontId.backgroundName, s_fontTable[i].name, _countof(fontId.backgroundName) - 1); 
    98                 ::FontRegisterW(&fontId); 
     98                ::Font_RegisterW(&fontId); 
    9999 
    100100                wcsncpy(colorId.name, s_fontTable[i].name, _countof(colorId.name) - 1); 
    101101                strncpy(colorId.setting, s_fontTable[i].clrPrefix, _countof(colorId.setting) - 1); 
    102                 ::ColourRegisterW(&colorId); 
     102                ::Colour_RegisterW(&colorId); 
    103103        } 
    104104} 
     
    112112                } 
    113113        } 
    114         if (fontName == 0) { 
     114        if (fontName == 0) 
    115115                fontName = s_fontTable[_countof(s_fontTable) - 1].name; 
    116         } 
    117116 
    118117        // name and group only 
    119         FontIDW fontId = { sizeof(fontId), FONTSERV_GROUP, 0 }; 
    120         wcsncpy(fontId.name, fontName, _countof(fontId.name) - 1); 
    121         *text = (COLORREF)::CallService(MS_FONT_GETW, (WPARAM)&fontId, (LPARAM)lf); 
    122         ColourIDW colorId = { sizeof(colorId), FONTSERV_GROUP, 0 }; 
    123         wcsncpy(colorId.name, fontName, _countof(colorId.name) - 1); 
    124         *bg = (COLORREF)::CallService(MS_COLOUR_GETW, (WPARAM)&colorId, 0); 
     118        *text = ::Font_GetW(FONTSERV_GROUP, fontName, lf); 
     119        *bg = ::Colour_GetW(FONTSERV_GROUP, fontName); 
    125120} 
    126121 
  • trunk/plugins/TrafficCounter/src/TrafficCounter.cpp

    r17267 r17347  
    257257        mir_wstrcpy(TrafficFontID.deffontsettings.szFace, L"Arial"); 
    258258        TrafficFontID.order = 0; 
    259         FontRegisterW(&TrafficFontID); 
     259        Font_RegisterW(&TrafficFontID); 
    260260 
    261261        // Ðåãèñòðèðóåì öâåò ôîíà 
     
    266266        mir_strcpy(TrafficBackgroundColorID.setting, "FontBkColor"); 
    267267        TrafficBackgroundColorID.defcolour = GetSysColor(COLOR_BTNFACE); 
    268         ColourRegisterW(&TrafficBackgroundColorID); 
     268        Colour_RegisterW(&TrafficBackgroundColorID); 
    269269 
    270270        HookEvent(ME_FONT_RELOAD, UpdateFonts); 
     
    11631163{ 
    11641164        LOGFONT logfont; 
    1165         //if no font service 
    1166         if (!ServiceExists(MS_FONT_GETW)) return 0; 
    11671165        //update traffic font 
    11681166        if (Traffic_h_font) DeleteObject(Traffic_h_font); 
    1169         Traffic_FontColor = CallService(MS_FONT_GETW, (WPARAM)&TrafficFontID, (LPARAM)&logfont); 
     1167        Traffic_FontColor = Font_GetW(TrafficFontID, &logfont); 
    11701168        Traffic_h_font = CreateFontIndirect(&logfont); 
    1171         // 
     1169 
    11721170        TrafficFontHeight = abs(logfont.lfHeight) + 1; 
    1173         Traffic_BkColor = CallService(MS_COLOUR_GETW, (WPARAM)&TrafficBackgroundColorID, 0); 
     1171        Traffic_BkColor = Colour_GetW(TrafficBackgroundColorID); 
    11741172 
    11751173        // Êëþ÷åâîé öâåò 
  • trunk/plugins/Weather/src/weather_mwin.cpp

    r17255 r17347  
    156156 
    157157                                clr = db_get_dw(NULL, WEATHERPROTONAME, "ColorMwinFrame", GetSysColor(COLOR_3DFACE)); 
    158  
    159                                 { 
    160                                         FontIDW fntid = { 0 }; 
    161                                         mir_wstrcpy(fntid.group, _A2W(WEATHERPROTONAME)); 
    162                                         mir_wstrcpy(fntid.name, LPGENW("Frame Font")); 
    163                                         fntc = CallService(MS_FONT_GETW, (WPARAM)&fntid, (LPARAM)&lfnt); 
    164  
    165                                         mir_wstrcpy(fntid.name, LPGENW("Frame Title Font")); 
    166                                         fntc1 = CallService(MS_FONT_GETW, (WPARAM)&fntid, (LPARAM)&lfnt1); 
    167                                 } 
     158                                fntc = Font_GetW(_A2W(WEATHERPROTONAME), LPGENW("Frame Font"), &lfnt); 
     159                                fntc1 = Font_GetW(_A2W(WEATHERPROTONAME), LPGENW("Frame Title Font"), &lfnt1); 
    168160 
    169161                                ptrW tszInfo(db_get_wsa(data->hContact, WEATHERCONDITION, "WeatherInfo")); 
     
    332324        mir_wstrcpy(colourid.group, _A2W(WEATHERPROTONAME)); 
    333325        colourid.defcolour = GetSysColor(COLOR_3DFACE); 
    334         ColourRegisterW(&colourid); 
     326        Colour_RegisterW(&colourid); 
    335327 
    336328        FontIDW fontid = { 0 }; 
     
    350342        mir_wstrcpy(fontid.backgroundGroup, _A2W(WEATHERPROTONAME)); 
    351343        mir_wstrcpy(fontid.backgroundName, LPGENW("Frame Background")); 
    352         FontRegisterW(&fontid); 
     344        Font_RegisterW(&fontid); 
    353345 
    354346        fontid.deffontsettings.style = DBFONTF_BOLD; 
    355347        mir_wstrcpy(fontid.name, LPGENW("Frame Title Font")); 
    356348        mir_strcpy(fontid.prefix, "fnt1"); 
    357         FontRegisterW(&fontid); 
     349        Font_RegisterW(&fontid); 
    358350 
    359351        for (MCONTACT hContact = db_find_first(WEATHERPROTONAME); hContact; hContact = db_find_next(hContact, WEATHERPROTONAME)) 
  • trunk/plugins/YAPP/src/yapp.cpp

    r17267 r17347  
    5858        LOGFONT log_font; 
    5959        if (hFontFirstLine) DeleteObject(hFontFirstLine); 
    60         colFirstLine = CallService(MS_FONT_GETW, (WPARAM)&font_id_firstline, (LPARAM)&log_font); 
     60        colFirstLine = Font_GetW(font_id_firstline, &log_font); 
    6161        hFontFirstLine = CreateFontIndirect(&log_font); 
    6262        if (hFontSecondLine) DeleteObject(hFontSecondLine); 
    63         colSecondLine = CallService(MS_FONT_GETW, (WPARAM)&font_id_secondline, (LPARAM)&log_font); 
     63        colSecondLine = Font_GetW(font_id_secondline, &log_font); 
    6464        hFontSecondLine = CreateFontIndirect(&log_font); 
    6565        if (hFontTime) DeleteObject(hFontTime); 
    66         colTime = CallService(MS_FONT_GETW, (WPARAM)&font_id_time, (LPARAM)&log_font); 
     66        colTime = Font_GetW(font_id_time, &log_font); 
    6767        hFontTime = CreateFontIndirect(&log_font); 
    6868 
    69         colBg = CallService(MS_COLOUR_GETW, (WPARAM)&colour_id_bg, 0); 
    70         colBorder = CallService(MS_COLOUR_GETW, (WPARAM)&colour_id_border, 0); 
    71         colSidebar = CallService(MS_COLOUR_GETW, (WPARAM)&colour_id_sidebar, 0); 
    72         colTitleUnderline = CallService(MS_COLOUR_GETW, (WPARAM)&colour_id_titleunderline, 0); 
     69        colBg = Colour_GetW(colour_id_bg); 
     70        colBorder = Colour_GetW(colour_id_border); 
     71        colSidebar = Colour_GetW(colour_id_sidebar); 
     72        colTitleUnderline = Colour_GetW(colour_id_titleunderline); 
    7373        return 0; 
    7474} 
     
    102102        mir_wstrcpy(font_id_firstline.backgroundName, L"Background"); 
    103103        font_id_firstline.order = 0; 
    104         FontRegisterW(&font_id_firstline); 
     104        Font_RegisterW(&font_id_firstline); 
    105105 
    106106        font_id_secondline.cbSize = sizeof(FontIDW); 
     
    113113        mir_wstrcpy(font_id_secondline.backgroundName, L"Background"); 
    114114        font_id_secondline.order = 1; 
    115         FontRegisterW(&font_id_secondline); 
     115        Font_RegisterW(&font_id_secondline); 
    116116 
    117117        font_id_time.cbSize = sizeof(FontIDW); 
     
    124124        mir_wstrcpy(font_id_time.backgroundName, L"Background"); 
    125125        font_id_time.order = 2; 
    126         FontRegisterW(&font_id_time); 
     126        Font_RegisterW(&font_id_time); 
    127127 
    128128        colour_id_bg.cbSize = sizeof(ColourIDW); 
     
    133133        colour_id_bg.defcolour = GetSysColor(COLOR_3DSHADOW); 
    134134        colour_id_bg.order = 0; 
    135         ColourRegisterW(&colour_id_bg); 
     135        Colour_RegisterW(&colour_id_bg); 
    136136 
    137137        colour_id_border.cbSize = sizeof(ColourIDW); 
     
    142142        colour_id_border.defcolour = RGB(0, 0, 0); 
    143143        colour_id_border.order = 1; 
    144         ColourRegisterW(&colour_id_border); 
     144        Colour_RegisterW(&colour_id_border); 
    145145 
    146146        colour_id_sidebar.cbSize = sizeof(ColourIDW); 
     
    151151        colour_id_sidebar.defcolour = RGB(128, 128, 128); 
    152152        colour_id_sidebar.order = 2; 
    153         ColourRegisterW(&colour_id_sidebar); 
     153        Colour_RegisterW(&colour_id_sidebar); 
    154154 
    155155        colour_id_titleunderline.cbSize = sizeof(ColourIDW); 
     
    160160        colour_id_titleunderline.defcolour = GetSysColor(COLOR_3DSHADOW); 
    161161        colour_id_titleunderline.order = 3; 
    162         ColourRegisterW(&colour_id_titleunderline); 
     162        Colour_RegisterW(&colour_id_titleunderline); 
    163163 
    164164        ReloadFont(0, 0); 
  • trunk/plugins/mRadio/rframeapi.pas

    r14386 r17347  
    182182function ColorReload(wParam:WPARAM;lParam:LPARAM):int;cdecl; 
    183183var 
    184   cid:TColourID; 
    185184  wnd:HWND; 
    186185begin 
    187186  result:=0; 
    188   cid.cbSize:=SizeOf(cid); 
    189   StrCopy(cid.group,cPluginName); 
    190   StrCopy(cid.name ,frm_back); 
    191   frm_bkg:=CallService(MS_COLOUR_GETA,twparam(@cid),0); 
     187  frm_bkg:=Colour_Get(cPluginName,frm_back); 
    192188  if hbr<>0 then DeleteObject(hbr); 
    193189  hbr:=CreateSolidBrush(frm_bkg); 
  • trunk/protocols/JabberG/src/jabber.cpp

    r17305 r17347  
    143143        strncpy_s(fontid.prefix, "fntFrameTitle", _TRUNCATE); 
    144144        fontid.deffontsettings.style = DBFONTF_BOLD; 
    145         FontRegisterW(&fontid); 
     145        Font_RegisterW(&fontid); 
    146146 
    147147        wcsncpy_s(fontid.name, LPGENW("Frame text"), _TRUNCATE); 
    148148        strncpy_s(fontid.prefix, "fntFrameClock", _TRUNCATE); 
    149149        fontid.deffontsettings.style = 0; 
    150         FontRegisterW(&fontid); 
     150        Font_RegisterW(&fontid); 
    151151 
    152152        ColourIDW colourid = {0}; 
     
    158158        strncpy_s(colourid.setting, "clFrameBack", _TRUNCATE); 
    159159        colourid.defcolour = GetSysColor(COLOR_WINDOW); 
    160         ColourRegisterW(&colourid); 
     160        Colour_RegisterW(&colourid); 
    161161 
    162162        return 0; 
  • trunk/protocols/JabberG/src/jabber_frame.cpp

    r17243 r17347  
    240240{ 
    241241        LOGFONT lfFont; 
    242  
    243         FontIDW fontid = {0}; 
    244         fontid.cbSize = sizeof(fontid); 
    245         wcsncpy_s(fontid.group, L"Jabber", _TRUNCATE); 
    246         wcsncpy_s(fontid.name, L"Frame title", _TRUNCATE); 
    247         m_clTitle = CallService(MS_FONT_GETW, (WPARAM)&fontid, (LPARAM)&lfFont); 
     242        m_clTitle = Font_GetW(L"Jabber", L"Frame title", &lfFont); 
    248243        DeleteObject(m_hfntTitle); 
    249244        m_hfntTitle = CreateFontIndirect(&lfFont); 
    250245 
    251         wcsncpy_s(fontid.name, L"Frame text", _TRUNCATE); 
    252         m_clText = CallService(MS_FONT_GETW, (WPARAM)&fontid, (LPARAM)&lfFont); 
     246        m_clText = Font_GetW(L"Jabber", L"Frame text",&lfFont); 
    253247        DeleteObject(m_hfntText); 
    254248        m_hfntText = CreateFontIndirect(&lfFont); 
    255249 
    256         ColourIDW colourid = {0}; 
    257         colourid.cbSize = sizeof(colourid); 
    258         wcsncpy_s(colourid.group, L"Jabber", _TRUNCATE); 
    259         wcsncpy_s(colourid.name, L"Background", _TRUNCATE); 
    260         m_clBack = CallService(MS_COLOUR_GETW, (WPARAM)&colourid, 0); 
     250        m_clBack = Colour_GetW(L"Jabber", L"Background"); 
    261251 
    262252        UpdateSize(); 
  • trunk/src/core/stdchat/src/main.cpp

    r17309 r17347  
    293293        wcsncpy(colourid.name, LPGENW("Group chat log background"), _countof(colourid.name)); 
    294294        colourid.defcolour = GetSysColor(COLOR_WINDOW); 
    295         ColourRegisterW(&colourid); 
     295        Colour_RegisterW(&colourid); 
    296296 
    297297        strncpy(colourid.setting, "ColorMessageBG", _countof(colourid.setting)); 
    298298        wcsncpy(colourid.name, LPGENW("Message background"), _countof(colourid.name)); 
    299299        colourid.defcolour = GetSysColor(COLOR_WINDOW); 
    300         ColourRegisterW(&colourid); 
     300        Colour_RegisterW(&colourid); 
    301301 
    302302        strncpy(colourid.setting, "ColorNicklistBG", _countof(colourid.setting)); 
    303303        wcsncpy(colourid.name, LPGENW("Nick list background"), _countof(colourid.name)); 
    304304        colourid.defcolour = GetSysColor(COLOR_WINDOW); 
    305         ColourRegisterW(&colourid); 
     305        Colour_RegisterW(&colourid); 
    306306 
    307307        strncpy(colourid.setting, "ColorNicklistLines", _countof(colourid.setting)); 
    308308        wcsncpy(colourid.name, LPGENW("Nick list lines"), _countof(colourid.name)); 
    309309        colourid.defcolour = GetSysColor(COLOR_INACTIVEBORDER); 
    310         ColourRegisterW(&colourid); 
     310        Colour_RegisterW(&colourid); 
    311311 
    312312        strncpy(colourid.setting, "ColorNicklistSelectedBG", _countof(colourid.setting)); 
    313313        wcsncpy(colourid.name, LPGENW("Nick list background (selected)"), _countof(colourid.name)); 
    314314        colourid.defcolour = GetSysColor(COLOR_HIGHLIGHT); 
    315         ColourRegisterW(&colourid); 
     315        Colour_RegisterW(&colourid); 
    316316} 
    317317 
  • trunk/src/core/stdclist/src/clcfonts.cpp

    r17143 r17347  
    7777                strncpy(fontid.prefix, idstr, _countof(fontid.prefix)); 
    7878                fontid.order = i; 
    79                 FontRegisterW(&fontid); 
     79                Font_RegisterW(&fontid); 
    8080        } 
    8181        ReleaseDC(NULL, hdc); 
     
    9191        wcsncpy(colourid.group, LPGENW("Contact list"), _countof(colourid.group)); 
    9292        colourid.defcolour = CLCDEFAULT_BKCOLOUR; 
    93         ColourRegisterW(&colourid); 
     93        Colour_RegisterW(&colourid); 
    9494 
    9595        strncpy(colourid.setting, "SelTextColour", sizeof(colourid.setting)); 
     
    9797        colourid.order = 1; 
    9898        colourid.defcolour = CLCDEFAULT_SELTEXTCOLOUR; 
    99         ColourRegisterW(&colourid); 
     99        Colour_RegisterW(&colourid); 
    100100 
    101101        strncpy(colourid.setting, "HotTextColour", sizeof(colourid.setting)); 
     
    103103        colourid.order = 1; 
    104104        colourid.defcolour = CLCDEFAULT_HOTTEXTCOLOUR; 
    105         ColourRegisterW(&colourid); 
     105        Colour_RegisterW(&colourid); 
    106106 
    107107        strncpy(colourid.setting, "QuickSearchColour", sizeof(colourid.setting)); 
     
    109109        colourid.order = 1; 
    110110        colourid.defcolour = CLCDEFAULT_QUICKSEARCHCOLOUR; 
    111         ColourRegisterW(&colourid); 
     111        Colour_RegisterW(&colourid); 
    112112 
    113113        HookEvent(ME_FONT_RELOAD, FS_FontsChanged); 
  • trunk/src/core/stdmsg/src/msgoptions.cpp

    r17268 r17347  
    118118                wcsncpy_s(fontid.backgroundGroup, LPGENW("Message log"), _TRUNCATE); 
    119119                wcsncpy_s(fontid.backgroundName, LPGENW("Background"), _TRUNCATE); 
    120                 FontRegisterW(&fontid); 
     120                Font_RegisterW(&fontid); 
    121121        } 
    122122 
     
    127127        wcsncpy_s(colourid.name, LPGENW("Background"), _TRUNCATE); 
    128128        wcsncpy_s(colourid.group, LPGENW("Message log"), _TRUNCATE); 
    129         ColourRegisterW(&colourid); 
     129        Colour_RegisterW(&colourid); 
    130130} 
    131131 
  • trunk/src/mir_app/src/FontService.cpp

    r17270 r17347  
    272272} 
    273273 
    274 static INT_PTR RegisterFontW(WPARAM wParam, LPARAM lParam) 
    275 { 
    276         return sttRegisterFontWorker((FontIDW*)wParam, (int)lParam); 
    277 } 
    278  
    279 static INT_PTR RegisterFont(WPARAM wParam, LPARAM lParam) 
     274MIR_APP_DLL(int) Font_RegisterW(FontIDW *pFont, int _hLang) 
     275{ 
     276        return sttRegisterFontWorker(pFont, _hLang); 
     277} 
     278 
     279MIR_APP_DLL(int) Font_Register(FontID *pFont, int _hLang) 
    280280{ 
    281281        FontIDW temp; 
    282         if (!ConvertFontID((FontID*)wParam, &temp)) return -1; 
    283         return sttRegisterFontWorker(&temp, (int)lParam); 
     282        if (!ConvertFontID(pFont, &temp)) return -1; 
     283        return sttRegisterFontWorker(&temp, _hLang); 
    284284} 
    285285 
     
    287287// GetFont service 
    288288 
    289 static INT_PTR sttGetFontWorker(FontIDW *font_id, LOGFONT *lf) 
     289static COLORREF sttGetFontWorker(const wchar_t *wszGroup, const wchar_t *wszName, LOGFONTW *lf) 
    290290{ 
    291291        COLORREF colour; 
     
    293293        for (int i = 0; i < font_id_list.getCount(); i++) { 
    294294                FontInternal& F = font_id_list[i]; 
    295                 if (!wcsncmp(F.name, font_id->name, _countof(F.name)) && !wcsncmp(F.group, font_id->group, _countof(F.group))) { 
     295                if (!wcsncmp(F.name, wszName, _countof(F.name)) && !wcsncmp(F.group, wszGroup, _countof(F.group))) { 
    296296                        if (GetFontSettingFromDB(F.dbSettingsGroup, F.prefix, lf, &colour, F.flags) && (F.flags & FIDF_DEFAULTVALID)) { 
    297297                                CreateFromFontSettings(&F.deffontsettings, lf); 
     
    307307} 
    308308 
    309 static INT_PTR GetFontW(WPARAM wParam, LPARAM lParam) 
    310 { 
    311         return sttGetFontWorker((FontIDW*)wParam, (LOGFONT*)lParam); 
    312 } 
    313  
    314 static INT_PTR GetFont(WPARAM wParam, LPARAM lParam) 
    315 { 
    316         FontIDW temp; 
    317         if (!ConvertFontID((FontID*)wParam, &temp)) 
    318                 return -1; 
    319  
    320         LOGFONT lftemp; 
    321         int ret = sttGetFontWorker(&temp, &lftemp); 
    322         ConvertLOGFONT(&lftemp, (LOGFONTA*)lParam); 
     309MIR_APP_DLL(COLORREF) Font_GetW(const wchar_t *wszGroup, const wchar_t *wszName, LOGFONTW *pFont) 
     310{ 
     311        return sttGetFontWorker(wszGroup, wszName, pFont); 
     312} 
     313 
     314MIR_APP_DLL(COLORREF) Font_Get(const char *szGroup, const char *szName, LOGFONTA *pFont) 
     315{ 
     316        LOGFONTW lftemp; 
     317        COLORREF ret = sttGetFontWorker(_A2T(szGroup), _A2T(szName), &lftemp); 
     318        ConvertLOGFONT(&lftemp, pFont); 
    323319        return ret; 
    324320} 
     
    367363} 
    368364 
    369 static INT_PTR RegisterColourW(WPARAM wParam, LPARAM lParam) 
    370 { 
    371         return sttRegisterColourWorker((ColourIDW*)wParam, (int)lParam); 
    372 } 
    373  
    374 static INT_PTR RegisterColour(WPARAM wParam, LPARAM lParam) 
     365MIR_APP_DLL(int) Colour_RegisterW(ColourIDW *pFont, int _hLang) 
     366{ 
     367        return sttRegisterColourWorker(pFont, _hLang); 
     368} 
     369 
     370MIR_APP_DLL(int) Colour_Register(ColourID *pFont, int _hLang) 
    375371{ 
    376372        ColourIDW temp; 
    377         if (!ConvertColourID((ColourID*)wParam, &temp)) return -1; 
    378         return sttRegisterColourWorker(&temp, (int)lParam); 
     373        if (!ConvertColourID(pFont, &temp)) return -1; 
     374        return sttRegisterColourWorker(&temp, _hLang); 
    379375} 
    380376 
     
    382378// GetColour service 
    383379 
    384 static INT_PTR sttGetColourWorker(ColourIDW *colour_id) 
     380static INT_PTR sttGetColourWorker(const wchar_t *wszGroup, const wchar_t *wszName) 
    385381{ 
    386382        for (int i = 0; i < colour_id_list.getCount(); i++) { 
    387383                ColourInternal& C = colour_id_list[i]; 
    388                 if (!mir_wstrcmp(C.group, colour_id->group) && !mir_wstrcmp(C.name, colour_id->name)) 
     384                if (!mir_wstrcmp(C.group, wszGroup) && !mir_wstrcmp(C.name, wszName)) 
    389385                        return db_get_dw(NULL, C.dbSettingsGroup, C.setting, C.defcolour); 
    390386        } 
     
    393389} 
    394390 
    395 static INT_PTR GetColourW(WPARAM wParam, LPARAM) 
    396 { 
    397         return sttGetColourWorker((ColourIDW*)wParam); 
    398 } 
    399  
    400 static INT_PTR GetColour(WPARAM wParam, LPARAM) 
    401 { 
    402         ColourIDW temp; 
    403         if (!ConvertColourID((ColourID*)wParam, &temp)) return -1; 
    404         return sttGetColourWorker(&temp); 
     391MIR_APP_DLL(COLORREF) Colour_GetW(const wchar_t *wszGroup, const wchar_t *wszName) 
     392{ 
     393        return sttGetColourWorker(wszGroup, wszName); 
     394} 
     395 
     396MIR_APP_DLL(COLORREF) Colour_Get(const char *szGroup, const char *szName) 
     397{ 
     398        return sttGetColourWorker(_A2T(szGroup), _A2T(szName)); 
    405399} 
    406400 
     
    439433// RegisterEffect service 
    440434 
    441 static INT_PTR sttRegisterEffectWorker(EffectIDW *effect_id, int _hLang) 
     435static int sttRegisterEffectWorker(EffectIDW *effect_id, int _hLang) 
    442436{ 
    443437        if (effect_id->cbSize != sizeof(EffectIDW)) 
     
    459453} 
    460454 
    461 static INT_PTR RegisterEffectW(WPARAM wParam, LPARAM lParam) 
    462 { 
    463         return sttRegisterEffectWorker((EffectIDW*)wParam, (int)lParam); 
    464 } 
    465  
    466 static INT_PTR RegisterEffect(WPARAM wParam, LPARAM lParam) 
     455MIR_APP_DLL(int) Effect_RegisterW(EffectIDW *pFont, int _hLang) 
     456{ 
     457        return sttRegisterEffectWorker(pFont, _hLang); 
     458} 
     459 
     460MIR_APP_DLL(int) Effect_Register(EffectID *pFont, int _hLang) 
    467461{ 
    468462        EffectIDW temp; 
    469         if (!ConvertEffectID((EffectID*)wParam, &temp)) return -1; 
    470         return sttRegisterEffectWorker(&temp, (int)lParam); 
     463        if (!ConvertEffectID(pFont, &temp)) return -1; 
     464        return sttRegisterEffectWorker(&temp, _hLang); 
    471465} 
    472466 
     
    474468// GetEffect service 
    475469 
    476 static INT_PTR sttGetEffectWorker(EffectIDW *effect_id, FONTEFFECT *effect) 
     470static INT_PTR sttGetEffectWorker(const wchar_t *wszGroup, const wchar_t *wszName, FONTEFFECT *effect) 
    477471{ 
    478472        for (int i = 0; i < effect_id_list.getCount(); i++) { 
    479473                EffectInternal& E = effect_id_list[i]; 
    480                 if (!wcsncmp(E.name, effect_id->name, _countof(E.name)) && !wcsncmp(E.group, effect_id->group, _countof(E.group))) { 
    481                         FONTEFFECT temp; 
    482                         UpdateEffectSettings(effect_id, &temp); 
    483  
    484                         effect->effectIndex = temp.effectIndex; 
    485                         effect->baseColour = temp.baseColour; 
    486                         effect->secondaryColour = temp.secondaryColour; 
     474                if (!wcsncmp(E.name, wszName, _countof(E.name)) && !wcsncmp(E.group, wszGroup, _countof(E.group))) { 
     475                        UpdateEffectSettings(&E, effect); 
    487476                        return TRUE; 
    488477                } 
     
    492481} 
    493482 
    494 static INT_PTR GetEffectW(WPARAM wParam, LPARAM lParam) 
    495 { 
    496         return sttGetEffectWorker((EffectIDW*)wParam, (FONTEFFECT*)lParam); 
    497 } 
    498  
    499 static INT_PTR GetEffect(WPARAM wParam, LPARAM lParam) 
    500 { 
    501         EffectIDW temp; 
    502         if (!ConvertEffectID((EffectID*)wParam, &temp)) return -1; 
    503         return sttGetEffectWorker(&temp, (FONTEFFECT*)lParam); 
     483EXTERN_C MIR_APP_DLL(int) Effect_GetW(const wchar_t *wszGroup, const wchar_t *wszName, FONTEFFECT *pEffect) 
     484{ 
     485        return sttGetEffectWorker(wszGroup, wszName, pEffect); 
     486} 
     487 
     488MIR_APP_DLL(int) Effect_Get(const char *szGroup, const char *szName, FONTEFFECT *pEffect) 
     489{ 
     490        return sttGetEffectWorker(_A2T(szGroup), _A2T(szName), pEffect); 
    504491} 
    505492 
     
    538525{ 
    539526        code_page = Langpack_GetDefaultCodePage(); 
    540  
    541         CreateServiceFunction("Font/Register", RegisterFont); 
    542         CreateServiceFunction("Font/RegisterW", RegisterFontW); 
    543         CreateServiceFunction(MS_FONT_GET, GetFont); 
    544         CreateServiceFunction(MS_FONT_GETW, GetFontW); 
    545  
    546         CreateServiceFunction("Colour/Register", RegisterColour); 
    547         CreateServiceFunction("Colour/RegisterW", RegisterColourW); 
    548         CreateServiceFunction(MS_COLOUR_GET, GetColour); 
    549         CreateServiceFunction(MS_COLOUR_GETW, GetColourW); 
    550  
    551         CreateServiceFunction("Effect/Register", RegisterEffect); 
    552         CreateServiceFunction("Effect/RegisterW", RegisterEffectW); 
    553         CreateServiceFunction(MS_EFFECT_GET, GetEffect); 
    554         CreateServiceFunction(MS_EFFECT_GETW, GetEffectW); 
    555527 
    556528        CreateServiceFunction(MS_FONT_RELOAD, ReloadFonts); 
     
    568540        fontid.flags = FIDF_APPENDNAME | FIDF_NOAS | FIDF_SAVEPOINTSIZE | FIDF_ALLOWEFFECTS | FIDF_CLASSHEADER; 
    569541        strncpy(fontid.prefix, "Header", _countof(fontid.prefix)); 
    570         FontRegisterW(&fontid); 
     542        Font_RegisterW(&fontid); 
    571543 
    572544        wcsncpy_s(fontid.name, LPGENW("Generic text"), _TRUNCATE); 
    573545        fontid.flags = FIDF_APPENDNAME | FIDF_NOAS | FIDF_SAVEPOINTSIZE | FIDF_ALLOWEFFECTS | FIDF_CLASSGENERAL; 
    574546        strncpy(fontid.prefix, "Generic", _countof(fontid.prefix)); 
    575         FontRegisterW(&fontid); 
     547        Font_RegisterW(&fontid); 
    576548 
    577549        wcsncpy_s(fontid.name, LPGENW("Small text"), _TRUNCATE); 
    578550        fontid.flags = FIDF_APPENDNAME | FIDF_NOAS | FIDF_SAVEPOINTSIZE | FIDF_ALLOWEFFECTS | FIDF_CLASSSMALL; 
    579551        strncpy(fontid.prefix, "Small", _countof(fontid.prefix)); 
    580         FontRegisterW(&fontid); 
     552        Font_RegisterW(&fontid); 
    581553 
    582554        // do last for silly dyna plugin 
  • trunk/src/mir_app/src/mir_app.def

    r17335 r17347  
    312312Chat_Control @313 
    313313Clist_FindItem @314 
     314Colour_Get @315 
     315Colour_GetW @316 
     316Colour_Register @317 
     317Colour_RegisterW @318 
     318Effect_Get @319 
     319Effect_GetW @320 
     320Effect_Register @321 
     321Effect_RegisterW @322 
     322Font_Get @323 
     323Font_GetW @324 
     324Font_Register @325 
     325Font_RegisterW @326 
  • trunk/src/mir_app/src/mir_app64.def

    r17335 r17347  
    312312Chat_Control @313 
    313313Clist_FindItem @314 
     314Colour_Get @315 
     315Colour_GetW @316 
     316Colour_Register @317 
     317Colour_RegisterW @318 
     318Effect_Get @319 
     319Effect_GetW @320 
     320Effect_Register @321 
     321Effect_RegisterW @322 
     322Font_Get @323 
     323Font_GetW @324 
     324Font_Register @325 
     325Font_RegisterW @326 
  • trunk/utils/mir_fonts.cpp

    r17143 r17347  
    3131                mir_wstrncpy(fid.deffontsettings.szFace, plfDefault->lfFaceName, _countof(fid.deffontsettings.szFace)); /* buffer safe */ 
    3232        } 
    33         FontRegisterW(&fid); 
     33        Font_RegisterW(&fid); 
    3434        return 0; 
    35 } 
    36  
    37 int FontService_GetFont(const wchar_t *pszSection, const wchar_t *pszDescription, COLORREF *pclr, LOGFONT *plf) 
    38 { 
    39         FontIDW fid = { 0 }; 
    40         mir_wstrncpy(fid.group, pszSection, _countof(fid.group)); /* buffer sfae */ 
    41         mir_wstrncpy(fid.name, pszDescription, _countof(fid.name)); /* buffer safe */ 
    42         *pclr = (COLORREF)CallService(MS_FONT_GETW, (WPARAM)&fid, (LPARAM)plf); /* uses fallback font on error */ 
    43         return (int)*pclr == -1; 
    4435} 
    4536 
     
    5344        mir_wstrncpy(cid.group, pszSection, _countof(cid.group)); /* buffer safe */ 
    5445        mir_wstrncpy(cid.name, pszDescription, _countof(cid.name)); /* buffer safe */ 
    55         ColourRegisterW(&cid); 
     46        Colour_RegisterW(&cid); 
    5647        return 0; 
    5748} 
    58  
    59 int FontService_GetColor(const wchar_t *pszSection, const wchar_t *pszDescription, COLORREF *pclr) 
    60 { 
    61         ColourIDW cid = { 0 }; 
    62         cid.cbSize = sizeof(cid); 
    63         wcsncpy_s(cid.group, pszSection, _TRUNCATE); 
    64         wcsncpy_s(cid.name, pszDescription, _TRUNCATE); 
    65         *pclr = (COLORREF)CallService(MS_COLOUR_GETW, (WPARAM)&cid, 0); 
    66         return (int)*pclr == -1; 
    67 } 
  • trunk/utils/mir_fonts.h

    r15592 r17347  
    11 
    22int FontService_RegisterFont(const char *pszDbModule, const char *pszDbName, const TCHAR *pszSection, const TCHAR *pszDescription, const TCHAR* pszBackgroundGroup, const TCHAR* pszBackgroundName, int position, BOOL bAllowEffects, LOGFONT *plfDefault, COLORREF clrDefault); 
    3 int FontService_GetFont(const TCHAR *pszSection, const TCHAR *pszDescription, COLORREF *pclr, LOGFONT *plf); 
    4  
    53int FontService_RegisterColor(const char *pszDbModule,const char *pszDbName,const TCHAR *pszSection,const TCHAR *pszDescription,COLORREF clrDefault); 
    6 int FontService_GetColor(const TCHAR *pszSection,const TCHAR *pszDescription,COLORREF *pclr); 
Note: See TracChangeset for help on using the changeset viewer.