data->ag.times[page] = 0;

if (FreeImage_GetMetadata(FIMD_ANIMATION, dib, "DisposalMethod", &tag))

else

data->ag.frame.disposal_method = 0;

int transparent_color = -1;

if (FreeImage_IsTransparent(dib)) {

int count = FreeImage_GetTransparencyCount(dib);

for (int i = 0; i < count; i++) {

if (table[i] == 0) {

have_transparent = true;

//copy page data into logical buffer, with full alpha opaqueness

for (int y = 0; y < data->ag.frame.height; y++) {

RGBQUAD *scanline = (RGBQUAD*)FreeImage_GetScanLine(data->ag.dib, data->ag.logicalHeight - (y + data->ag.frame.top) - 1) + data->ag.frame.left;

for (int x = 0; x < data->ag.frame.width; x++) {

if (!have_transparent || *pageline != transparent_color) {

*scanline = pal[*pageline];

return;

DWORD dwLen = bmp.bmWidth * bmp.bmHeight * (bmp.bmBitsPixel / 8);

if (p == nullptr)

return;

GetObject(hBitmap, sizeof(bmp), &bmp);

DWORD dwLen = bmp.bmWidth * bmp.bmHeight * 4;

if (p == nullptr)

return nullptr;

RGB32BitsBITMAPINFO.bmiHeader.biPlanes = 1;

RGB32BitsBITMAPINFO.bmiHeader.biBitCount = 32;

HBITMAP hDirectBitmap = CreateDIBSection(nullptr, (BITMAPINFO *)&RGB32BitsBITMAPINFO, DIB_RGB_COLORS, (void **)&ptPixels, nullptr, 0);

// Copy data

return;

DWORD dwLen = bmp.bmWidth * bmp.bmHeight * (bmp.bmBitsPixel / 8);

if (p == nullptr)

return;

memset(p, 0, dwLen);

bool changed = false;

for (int y = 0; y < bmp.bmHeight; ++y) {

for (int x = 0; x < bmp.bmWidth; ++x) {

if (px[3] == 0) {

// Other utilities ////////////////////////////////////////////////////////////////////////////////

{

return abs(px1[0] - px2[0]) <= colorDiff

&& abs(px1[1] - px2[1]) <= colorDiff

(*topPos)++;

}

{

// If any of the corners have transparency, forget about it

// Not using != 255 because some MSN bmps have 254 in some positions

return FALSE;

DWORD dwLen = width * height * 4;

if (p == nullptr)

return FALSE;

// **** Get corner colors

// Top left

BOOL foundBkg[8];

if (!GetColorForPoint(colorDiff, p, width, 0, 0, 0, 1, 1, 0, &foundBkg[0], &colors[0])) {

if (hBmpTmp != *hBitmap)

count = 0;

for (j = 0; j < 8; j++) {

count++;

}

bkgColor[1] = 0;

bkgColor[2] = 0;

for (i = 0; i < 8; i++) {

bkgColor[0] += colors[i][0];

bkgColor[1] += colors[i][1];

bkgColor[2] += colors[i][2];

int y = stack[curPos]; curPos++;

// Get pixel

// It won't change the transparency if one exists

// (This avoid an endless loop too)

// Not using == 255 because some MSN bmps have 254 in some positions

if (px1[3] >= 253) {

px1[3] = (transpProportional) ? min(252,

(abs(px1[0] - colors[selectedColor][0])

+ abs(px1[1] - colors[selectedColor][1])

{

wchar_t szFinalName[MAX_PATH];

DBVARIANT dbv = { 0 };

szFinalName[0] = 0;

INT_PTR ProtectAvatar(WPARAM hContact, LPARAM lParam)

{

return 0;

if (hContact) {

struct OpenFileSubclassData

{

};

UINT_PTR CALLBACK OpenFileSubclass(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)

data = (OpenFileSubclassData *)malloc(sizeof(OpenFileSubclassData));

SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)data);

data->setView = TRUE;

CheckDlgButton(hwnd, IDC_PROTECTAVATAR, *(data->locking_request) ? BST_CHECKED : BST_UNCHECKED);

}

{

wchar_t FileName[MAX_PATH];

wchar_t *szFinalName;

if (hContact == NULL)

return 0;

unsigned short action;

wchar_t *szCommand;

wchar_t *szCommandParams;

int flags, day_mask;

} ALARM;

{

char szSetting[MAXMODULELABELLENGTH];

mir_snprintf(szSetting, "enabled_%s", assoc->pszClassName);

}

static void SetAssocEnabled(const ASSOCDATA *assoc, BOOL fEnabled)

char szSetting[MAXMODULELABELLENGTH];

wchar_t szDLL[MAX_PATH], szBuf[MAX_PATH];

mir_snprintf(szSetting, "enabled_%s", assoc->pszClassName);

// dll name for uninstall

if (assoc->hInstance != nullptr && assoc->hInstance != g_plugin.getInst() && assoc->hInstance != GetModuleHandle(nullptr))

if (GetModuleFileName(assoc->hInstance, szBuf, _countof(szBuf)))

/************************* Mime Reg *******************************/

{

char szSetting[MAXMODULELABELLENGTH];

mir_snprintf(szSetting, "mime_%s", pszMimeType);

void UninitAssocList(void)

{

// Assoc List

for (auto &it : arAssocList)

if (fOnlyWhileRunning)

UnregisterAssoc(it); // remove registry keys

HKEY hSubKey;

LONG res = RegCreateKeyEx(hMainKey, pszSubKey, 0, nullptr, 0, KEY_SET_VALUE | KEY_QUERY_VALUE, nullptr, &hSubKey, nullptr);

if (!res) {

RegCloseKey(hSubKey);

}

return res;

size_t dwSize = (mir_wstrlen(pszVal) + mir_wstrlen(pszValPrefix) + 1) * sizeof(wchar_t);

wchar_t *pszStr = (wchar_t*)_alloca(dwSize);

mir_wstrcat(mir_wstrcpy(pszStr, pszValPrefix), pszVal); // buffer safe

}

// hKey must have been opened with KEY_QUERY_VALUE access right

wchar_t *pszVal = (wchar_t*)mir_alloc(dwSize + sizeof(wchar_t));

if (pszVal != nullptr) {

// get value

pszVal[dwSize / sizeof(wchar_t)] = 0;

if (dwType == REG_EXPAND_SZ) {

dwSize = MAX_PATH;

#define REGF_ANSI 0x80000000 // this bit is set in dwType for ANSI registry data

// pData must always be Unicode data, registry supports Unicode even on Win95

{

size_t cbLen = cbData + sizeof(DWORD);

uint8_t *buf = (uint8_t*)mir_alloc(cbLen);

}

// mir_free() the value returned in ppData

{

DBVARIANT dbv;

if (!db_get(0, MODULENAME, pszSetting, &dbv)) {

// enum values

pszName = (char*)mir_alloc(nMaxValNameLen + 1);

if (nMaxValSize == 0) nMaxValSize = 1;

if (pszName != nullptr && pData != nullptr) {

DWORD index = 0;

while (!res) {

break;

char *pszValName = pslash;

// read data

DWORD dwType, cbData;

if (ReadDbBackupData(ppszSettings[i], &dwType, &pData, &cbData)) {

// set value

if (fUrlProto) BackupRegTree(hRootKey, pszClassName, "bak_");

// type description

if (fUrlProto) SetRegStrPrefixValue(hClassKey, L"URL:", pszTypeDescription);

// default icon

if (pszIconLoc != nullptr) SetRegSubKeyStrDefValue(hClassKey, L"DefaultIcon", pszIconLoc);

// url protocol

// edit flags

{

DWORD dwFlags = 0, dwSize = sizeof(dwFlags);

if (fBrowserAutoOpen) dwFlags = (dwFlags & ~FTA_AlwaysUnsafe) | FTA_OpenIsSafe;

if (!fUrlProto) dwFlags |= FTA_HasExtension;

else dwFlags = (dwFlags & ~FTA_HasExtension) | FTA_Show; // show classes without extension

}

if (fIsShortcut) {

RegSetValueExA(hClassKey, "IsShortcut", 0, REG_SZ, nullptr, 0);

// shell

if ((res = RegCreateKeyEx(hClassKey, L"shell", 0, nullptr, 0, KEY_SET_VALUE | KEY_CREATE_SUB_KEY, nullptr, &hShellKey, nullptr)) == ERROR_SUCCESS) {

// default verb (when empty "open" is used)

// verb

if ((res = RegCreateKeyEx(hShellKey, L"open", 0, nullptr, 0, KEY_SET_VALUE | KEY_CREATE_SUB_KEY | DELETE, nullptr, &hVerbKey, nullptr)) == ERROR_SUCCESS) {

// verb description

if (pszVerbDesc == nullptr) RegDeleteValue(hVerbKey, nullptr);

// friendly appname (mui string)

// command

SetRegSubKeyStrDefValue(hVerbKey, L"command", pszRunCmd);

// ddeexec

if (pszDdeCmd != nullptr) {

if (!RegCreateKeyEx(hVerbKey, L"ddeexec", 0, nullptr, 0, KEY_SET_VALUE | KEY_CREATE_SUB_KEY | DELETE, nullptr, &hDdeKey, nullptr)) {

// command

// application

SetRegSubKeyStrDefValue(hDdeKey, L"application", pszDdeApp);

// topic

}

mir_free(pszPrevClass); // does NULL check

// class name

// mime type e.g. "application/x-icq"

// perceived type e.g. text (WinXP+)

RegCloseKey(hExtKey);

}

if (!RegCreateKeyExA(hDbKey, pszMimeType, 0, nullptr, 0, KEY_QUERY_VALUE | KEY_SET_VALUE, nullptr, &hTypeKey, nullptr)) {

// file ext

if (RegQueryValueExA(hTypeKey, "Extension", nullptr, nullptr, nullptr, nullptr)) // only set if not present

RegCloseKey(hTypeKey);

}

RegCloseKey(hDbKey);

// filename

if (!RegCreateKeyEx(hAppsKey, pszAppFileName, 0, nullptr, 0, KEY_SET_VALUE | KEY_CREATE_SUB_KEY, nullptr, &hExeKey, nullptr)) {

// appname

// no open-with flag

if (fAllowOpenWith) RegDeleteValue(hExeKey, L"NoOpenWith");

else RegSetValueEx(hExeKey, L"NoOpenWith", 0, REG_SZ, nullptr, 0);

// shell

if (!RegCreateKeyEx(hExeKey, L"shell", 0, nullptr, 0, KEY_SET_VALUE | KEY_CREATE_SUB_KEY, nullptr, &hShellKey, nullptr)) {

// default verb (when empty "open" is used)

// verb

if (!RegCreateKeyEx(hShellKey, L"open", 0, nullptr, 0, KEY_SET_VALUE | KEY_CREATE_SUB_KEY, nullptr, &hVerbKey, nullptr)) {

// friendly appname (mui string)

// command

SetRegSubKeyStrDefValue(hVerbKey, L"command", pszRunCmd);

// ddeexec

if (pszDdeCmd != nullptr)

if (!RegCreateKeyEx(hVerbKey, L"ddeexec", 0, nullptr, 0, KEY_SET_VALUE | KEY_CREATE_SUB_KEY, nullptr, &hDdeKey, nullptr)) {

// command

// application

SetRegSubKeyStrDefValue(hDdeKey, L"application", pszDdeApp);

// topic

if (!RegCreateKeyEx(hExeKey, L"SupportedTypes", 0, nullptr, 0, KEY_SET_VALUE, nullptr, &hTypesKey, nullptr)) {

ptrW ptszFileExt(mir_a2u(pszFileExt));

if (ptszFileExt != nullptr)

mir_free(ptszFileExt); // does NULL check

RegCloseKey(hTypesKey);

}

HKEY hRunKey;

if (!RegCreateKeyEx(HKEY_CURRENT_USER, L"Software\\Microsoft\\Windows\\CurrentVersion\\Run", 0, nullptr, 0, KEY_SET_VALUE, nullptr, &hRunKey, nullptr)) {

// appname

RegCloseKey(hRunKey);

}

return fSuccess;

mir_free(mbp);

}

{

char szText[256]; /* max for systray */

BOOL EnumDbPrefixSettings(const char *pszModule, const char *pszSettingPrefix, char ***pSettings, int *pnSettingsCount);

/* Error Output */

char* GetWinErrorDescription(DWORD dwLastError);

{

CMPlugin();

int Load() override;

};

if (RegCreateKeyEx(ROOT_KEY, SUB_KEY, 0, nullptr, 0, KEY_CREATE_SUB_KEY | KEY_SET_VALUE, nullptr, &hKey, &dw) == ERROR_SUCCESS) {

wchar_t result[MAX_PATH];

GetProfilePath(result, _countof(result));

RegCloseKey(hKey);

}

break;

if (!RegOpenKeyEx(hKeyServices, pszServiceName, 0, KEY_QUERY_VALUE | KEY_SET_VALUE, &hKeyService)) {

if (!RegOpenKeyEx(hKeyService, L"Performance", 0, KEY_QUERY_VALUE | KEY_SET_VALUE, &hKeyPerf)) {

dwDataSize = sizeof(DWORD);

if ((dwData != 0) != fDisable)

RegCloseKey(hKeyPerf);

}

RegCloseKey(hKeyService);

DWORD *pidThread;

};

{

if (param->hFirstEvent != nullptr) {

/* return value for PollCpuUsage() */

static void WinNT_PollThread(CpuUsageThreadParams *param)

{

DWORD dwBufferSize = 0, dwCount;

PERF_DATA_BLOCK *pPerfData = nullptr;

LONG res, lCount;

PERF_OBJECT_TYPE *pPerfObj;

PERF_COUNTER_BLOCK *pPerfCounterBlock;

DWORD dwObjectId, dwCounterId;

wchar_t wszValueName[11], *pwszInstanceName;

BOOL fSwitched, fFound, fIsFirst = FALSE;

LARGE_INTEGER liPrevCounterValue = { 0 }, liCurrentCounterValue = { 0 }, liPrevPerfTime100nSec = { 0 };

/* poll */

for (;;) {

/* retrieve data for given object */

while (!pBuffer || res == ERROR_MORE_DATA) {

if (!pBuffer) break;

pPerfData = (PERF_DATA_BLOCK*)pBuffer;

res = RegQueryValueExW(HKEY_PERFORMANCE_DATA, wszValueName, nullptr, nullptr, pBuffer, &dwBufferSize);

/* find object in data */

fFound = FALSE;

/* first object */

for (dwCount = 0; dwCount < pPerfData->NumObjectTypes; ++dwCount) {

if (pPerfObj->ObjectNameTitleIndex == dwObjectId) {

/* find counter in object data */

/* first counter */

for (dwCount = 0; dwCount < (pPerfObj->NumCounters); ++dwCount) {

if (pPerfCounter->CounterNameTitleIndex == dwCounterId) {

/* find instance in counter data */

if (pPerfObj->NumInstances == PERF_NO_INSTANCES) {

fFound = TRUE;

}

else {

/* first instance */

for (lCount = 0; lCount < (pPerfObj->NumInstances); ++lCount) {

fFound = TRUE;

break;

}

/* next instance */

}

}

break;

}

/* next counter */

}

break;

}

/* next object */

}

if (!fFound)

break;

* counter type: PERF_100NSEC_TIMER_INV

* calc: time base=100Ns, value=100*(1-(data_diff)/(100NsTime_diff)) */

if (!fIsFirst) {

if (!CallBackAndWait(param, nCpuUsage))

break;

}

#pragma once

/* Start Thread */

DWORD PollCpuUsage(CPUUSAGEAVAILPROC pfnDataAvailProc,LPARAM lParam,DWORD dwDelayMillis);

#define FRAMEELEMENT_BKGRND 2

#define FRAMEELEMENT_TEXT 3

{

switch (id) {

case FRAMEELEMENT_BAR:

COLORREF clrBackground, clrText;

HFONT hFont;

WORD fTimeFlags;

};

/* Flags */

case WM_NOTIFY:

switch (((NMHDR*)lParam)->code) {

case PSN_APPLY:

g_plugin.setWord("ConfirmDlgCountdown", (WORD)GetDlgItemInt(hwndDlg, IDC_EDIT_CONFIRMDLGCOUNTDOWN, nullptr, FALSE));

if (IsWindowEnabled(GetDlgItem(hwndDlg, IDC_CHECK_WEATHER)))

return TRUE;

}

break;

EnableWindow(hwndDlg, fEnable);

}

{

/* dialog closed? */

if (!IsWindow((HWND)lParam))

}

/* cpuusage threshold */

{

SendDlgItemMessage(hwndDlg, IDC_SPIN_CPUUSAGE, UDM_SETRANGE, 0, MAKELPARAM(100, 1));

SendDlgItemMessage(hwndDlg, IDC_EDIT_CPUUSAGE, EM_SETLIMITTEXT, (WPARAM)3, 0);

SendDlgItemMessage(hwndDlg, IDC_SPIN_CPUUSAGE, UDM_SETPOS, 0, MAKELPARAM(setting, 0));

/* shutdown types */

{

HWND hwndCombo = GetDlgItem(hwndDlg, IDC_COMBO_SHUTDOWNTYPE);

SendMessage(hwndCombo, CB_SETLOCALE, (WPARAM)locale, 0); /* sort order */

SendMessage(hwndCombo, CB_SETEXTENDEDUI, TRUE, 0);

SendMessage(hwndCombo, CB_INITSTORAGE, SDSDT_MAX, SDSDT_MAX * 32);

if (ServiceIsTypeEnabled(shutdownType, 0)) {

wchar_t *pszText = (wchar_t*)ServiceGetTypeDescription(shutdownType, GSTDF_TCHAR); /* never fails */

int index = SendMessage(hwndCombo, CB_ADDSTRING, 0, (LPARAM)pszText);

case M_UPDATE_SHUTDOWNDESC: /* lParam=(LPARAM)(HWND)hwndCombo */

{

SetDlgItemText(hwndDlg, IDC_TEXT_SHUTDOWNTYPE, (wchar_t*)ServiceGetTypeDescription(shutdownType, GSTDF_LONGDESC | GSTDF_TCHAR));

}

return TRUE;

{

int index = SendDlgItemMessage(hwndDlg, IDC_COMBO_SHUTDOWNTYPE, CB_GETCURSEL, 0, 0);

if (index != LB_ERR)

index = SendDlgItemMessage(hwndDlg, IDC_COMBO_COUNTDOWNUNIT, CB_GETCURSEL, 0, 0);

if (index != LB_ERR)

g_plugin.setDword("CountdownUnit", (DWORD)SendDlgItemMessage(hwndDlg, IDC_COMBO_COUNTDOWNUNIT, CB_GETITEMDATA, (WPARAM)index, 0));

g_plugin.setDword("Countdown", (DWORD)GetDlgItemInt(hwndDlg, IDC_EDIT_COUNTDOWN, nullptr, FALSE));

}

/* watcher type */

{

}

/************************* Workers ************************************/

{

BOOL bReturn = FALSE;

switch (shutdownType) {

return bReturn;

}

{

DWORD dwErrCode = ERROR_SUCCESS;

switch (shutdownType) {

#define M_UPDATE_COUNTDOWN (WM_APP+112)

static INT_PTR CALLBACK ShutdownDlgProc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)

{

WORD countdown = (WORD)GetWindowLongPtr(GetDlgItem(hwndDlg, IDC_TEXT_HEADER), GWLP_USERDATA);

switch (msg) {

{

/* passing 0 as wParam is only to be used internally, undocumented */

if (!wParam) wParam = g_plugin.getByte("ShutdownType", SETTING_SHUTDOWNTYPE_DEFAULT);

if ((BOOL)lParam && hwndShutdownDlg != nullptr) return 2;

/* ask others if allowed */

NotifyEventHooks(hEventShutdown, wParam, lParam);

/* show dialog */

if (lParam && g_plugin.getByte("ShowConfirmDlg", SETTING_SHOWCONFIRMDLG_DEFAULT))

return 0;

/* show error */

if (dwErrCode != ERROR_SUCCESS) {

char *pszErr = GetWinErrorDescription(dwErrCode);

ShowInfoMessage(NIIF_ERROR, Translate("Automatic shutdown error"), Translate("Initiating the shutdown process failed!\nReason: %s"), (pszErr != nullptr) ? pszErr : Translate("Unknown"));

INT_PTR ServiceIsTypeEnabled(WPARAM wParam, LPARAM)

{

}

const wchar_t *apszShort[] = {

INT_PTR ServiceGetTypeDescription(WPARAM wParam, LPARAM lParam)

{

/* shutdownType range check */

/* select description */

wchar_t *pszDesc = (wchar_t*)((lParam & GSTDF_LONGDESC) ? apszLong : apszShort)[wParam - 1];

if (!(lParam & GSTDF_UNTRANSLATED))

mir_free(mbp);

}

{

char szText[256]; /* max for systray */

#pragma once

/* Error Output */

char* GetWinErrorDescription(DWORD dwLastError);

/* Time */

static DWORD idCpuUsageThread;

{

/* terminated? */

if (idCpuUsageThread != GetCurrentThreadId()) {

nTimesBelow = 0;

return FALSE; /* stop poll thread */

}

/* ignore random peaks */

else nTimesBelow = 0;

if (nTimesBelow == 3) {

nTimesBelow = 0;

case IDOK:

if (HIWORD(wParam) == BN_CLICKED) {

MCONTACT hContact = (MCONTACT)GetWindowLongPtr(hwnd, GWLP_USERDATA);

CleanupAvatarPic(hwnd);

EndDialog(hwnd, 0);

wchar_t popup_removed[1024];

WORD popup_delay_type;

WORD popup_timeout;

COLORREF popup_bkg_color;

COLORREF popup_text_color;

WORD popup_left_click_action;

if (!ProtocolEnabled(proto))

return false;

return (globpref && userpref == BST_INDETERMINATE) || userpref == BST_CHECKED;

}

#include <stdint.h>

#define WINAPI

#define CALLBACK

typedef uint16_t WORD;

typedef uint32_t DWORD;

typedef uint64_t QWORD;

#define TRUE 1

#define FALSE 0

#endif

#define LOWORD(a) (WORD)(a)

#define HIWORD(a) (WORD)((a)>>16)

#define MAKEWORD(a,b) (WORD)(((a)&0xff)|((b)<<8))

#define BASS_TAG_APE_BINARY 0x1000 // + index #, binary APE tag : TAG_APE_BINARY structure

#define BASS_TAG_MUSIC_NAME 0x10000 // MOD music name : ANSI string

#define BASS_TAG_MUSIC_MESSAGE 0x10001 // MOD message : ANSI string

#define BASS_TAG_MUSIC_AUTH 0x10003 // MOD author : UTF-8 string

#define BASS_TAG_MUSIC_INST 0x10100 // + instrument #, MOD instrument name : ANSI string

#define BASS_TAG_MUSIC_CHAN 0x10200 // + channel #, MOD channel name : ANSI string

char album[30];

char year[4];

char comment[30];

} TAG_ID3;

// Binary APE tag structure

char OriginationTime[8]; // time of creation (hh-mm-ss)

QWORD TimeReference; // first sample count since midnight (little-endian)

WORD Version; // BWF version (little-endian)

#if defined(__GNUC__) && __GNUC__<3

char CodingHistory[0]; // history

#elif 1 // change to 0 if compiler fails the following line

wchar_t* szDescr;

COLORREF defColour;

wchar_t* szDefFace;

char defSize;

wchar_t* szBackgroundName;

DWORD flags;

#pragma pack(push, 2)

typedef struct

{

WORD wPlanes; // Color Planes

WORD wBitCount; // Bits per pixel

DWORD dwBytesInRes; // How many bytes in this resource?

}

}

return 0;

}

PROTOACCOUNT **proto;

unsigned *oldStatus;

wchar_t **oldStatusMsg;

CMPlugin g_plugin;

if (g_wMask & OPT_CHANGESTATUS) // is this even needed?

{

unsigned uMode = (STATUS_ARR_TO_ID[bReqMode]);

DBVARIANT dbVar;

if (g_wMask & OPT_USEDEFMSG || g_plugin.getWString("statmsg", &dbVar)) {

{

WORD wHotKey = db_get_w(0, "SkinHotKeys", "Hide/Show Miranda", HOTKEYCODE(HOTKEYF_CONTROL, VK_F12));

static wchar_t buf[128];

mir_snwprintf(buf, L"%s%s%s%s%s",

void ComboboxSelState()

{

WORD wMode = STATUS_ARR_TO_ID[bSelection];

if (m_chkUsrDefMsg.GetState()) {

wchar_t *ptszDefMsg = GetDefStatusMsg(wMode, nullptr);

// write down status type

if (m_chkChangeStatus.GetState()) {

// status msg, if needed

if (m_edtStatMsg.Enabled()) { // meaning we should save it

options.iShowPopup2 = g_plugin.getByte("iShowPopUp2", 1);

options.iShowEvent2 = g_plugin.getByte("iShowEvent2", 0);

options.notifyFirstOnline = g_plugin.getByte("bShowFirstSight", 0) ? true : false;

options.hideInactive = g_plugin.getByte("bHideInactive", 0) ? true : false;

options.enableMissYou = g_plugin.getByte("bMissYouEnabled", 1) ? true : false;

g_plugin.setByte("iShowPopUp2", options.iShowPopup2);

g_plugin.setByte("iShowEvent2", options.iShowEvent2);

g_plugin.setByte("bShowFirstSight", options.notifyFirstOnline ? 1 : 0);

g_plugin.setByte("bHideInactive", options.hideInactive ? 1 : 0);

g_plugin.setByte("bMissYouEnabled", options.enableMissYou ? 1 : 0);

}

// check to reuse

if (reuse > 1)

else {

g_plugin.setByte(ack->hContact, "Reuse", 0);

g_plugin.setWString(ack->hContact, "PounceMsg", L"");

g_plugin.setWString(hContact, "PounceMsg", message);

g_plugin.setWord(hContact, "SendIfMyStatusIsFLAG", (WORD)g_plugin.getWord("SendIfMyStatusIsFLAG", 1));

g_plugin.setWord(hContact, "SendIfTheirStatusIsFLAG", (WORD)g_plugin.getWord("SendIfTheirStatusIsFLAG", 1));

g_plugin.setDword(hContact, "GiveUpDate", (DWORD)(g_plugin.getByte(hContact, "GiveUpDays", 0)*SECONDSINADAY));

return 0;

}

edtNumber.SetInt(g_plugin.getWord(hContact, "ConfirmTimeout"));

break;

}

NotifyChange();

}

{

switch (g_plugin.getByte(hContact, "LastSetting", 2)) {

case 3: // Reuse Pounce

break;

case 4: // Give Up delay

g_plugin.setDword(hContact, "GiveUpDate", (DWORD)edtNumber.GetInt() * SECONDSINADAY);

break;

case 5: // confirm window

BOOL ChangeSystemLayout;

BOOL CopyToClipboard;

BOOL ShowPopup;

} MainOptions;

typedef struct

{

COLORREF crTextColour;

COLORREF crBackColour;

POPUPACTION paActions[1];

} PopupOptions;

SHORT shVirtualKey = VkKeyScanExW(ptszKeybEng[i], g_plugin.hklEng);

UINT iScanCode = MapVirtualKeyExW(shVirtualKey & 0x00FF, 0, g_plugin.hklEng);

if (shVirtualKey & 0x0100) bState[VK_SHIFT] = 0x80;

if (shVirtualKey & 0x0200) bState[VK_CONTROL] = 0x80;

return hklCurLay;

}

{

HKL hklCurLay = nullptr, hklToLay = nullptr;

CHARRANGE crSelection = { 0 }, crTemp = { 0 };

DWORD dwStartWord, dwEndWord;

BOOL WindowIsReadOnly, TwoWay;

if (hTextWnd == nullptr)

HKL GetLayoutOfText(LPCTSTR ptzsInText);

wchar_t *ChangeTextCase(LPCTSTR ptszInText);

wchar_t *ChangeTextLayout(LPCTSTR ptzsInText, HKL hklCurLay, HKL hklToLay, BOOL TwoWay);

#endif \ No newline at end of file

DestroyWindow(hMenuWnd);

}

{

MCONTACT hContact = PUGetContact(hWnd);

switch (Action) {

exStyle |= checkBoxToStyleEx[i].flag;

db_set_dw(0, "CLC", "ExStyle", exStyle);

db_set_w(0, "CLC", "ScrollTime", (WORD)SendDlgItemMessage(m_hwnd, IDC_SMOOTHTIMESPIN, UDM_GETPOS, 0, 0));

wchar_t tmp[1024];

GetDlgItemText(m_hwnd, IDC_T_CONTACT, tmp, _countof(tmp));

{

int iTrayIcon = chkDontCycle.IsChecked() ? SETTING_TRAYICON_SINGLE : (chkCycle.IsChecked() ? SETTING_TRAYICON_CYCLE : SETTING_TRAYICON_MULTI);

g_plugin.setByte("TrayIcon", iTrayIcon);

g_plugin.setWord("CycleTime", (WORD)SendDlgItemMessage(m_hwnd, IDC_CYCLETIMESPIN, UDM_GETPOS, 0, 0));

g_plugin.setWord("IconFlashTime", (WORD)SendDlgItemMessage(m_hwnd, IDC_BLINKSPIN, UDM_GETPOS, 0, 0));

int cur = SendDlgItemMessage(m_hwnd, IDC_PRIMARYSTATUS, CB_GETCURSEL, 0, 0);

PROTOACCOUNT *pa = (PROTOACCOUNT *)SendDlgItemMessage(m_hwnd, IDC_PRIMARYSTATUS, CB_GETITEMDATA, cur, 0);

bool OnApply() override

{

g_plugin.setWord("HideTime", spinHideTime.GetPosition());

db_set_b(0, "CLUI", "MaxSizeHeight", spinMaxSize.GetPosition());

ShowWindow(g_clistApi.hwndContactList, IsDlgButtonChecked(m_hwnd, IDC_MIN2TRAY) ? SW_HIDE : SW_SHOW);

if (IsDlgButtonChecked(m_hwnd, IDC_TRANSPARENT)) {

SetWindowLongPtr(g_clistApi.hwndContactList, GWL_EXSTYLE, GetWindowLongPtr(g_clistApi.hwndContactList, GWL_EXSTYLE) | WS_EX_LAYERED);

}

else SetWindowLongPtr(g_clistApi.hwndContactList, GWL_EXSTYLE, GetWindowLongPtr(g_clistApi.hwndContactList, GWL_EXSTYLE) & ~WS_EX_LAYERED);

{

chkShow.SetState(db_get_b(0, "CLUI", "ShowSBar", 1));

CheckDlgButton(m_hwnd, IDC_SHOWICON, showOpts & 1 ? BST_CHECKED : BST_UNCHECKED);

CheckDlgButton(m_hwnd, IDC_SHOWPROTO, showOpts & 2 ? BST_CHECKED : BST_UNCHECKED);

CheckDlgButton(m_hwnd, IDC_SHOWSTATUS, showOpts & 4 ? BST_CHECKED : BST_UNCHECKED);

{

db_set_b(0, "CLUI", "ShowSBar", chkShow.GetState());

db_set_b(0, "CLUI", "SBarShow",

(IsDlgButtonChecked(m_hwnd, IDC_SHOWPROTO) ? 2 : 0) |

(IsDlgButtonChecked(m_hwnd, IDC_SHOWSTATUS) ? 4 : 0)));

g_clistApi.pfnLoadCluiGlobalOpts();

HWND parent = GetParent(g_clistApi.hwndStatus);

int flags = WS_CHILD | CCS_BOTTOM;

ShowWindow(g_clistApi.hwndStatus, SW_HIDE);

DestroyWindow(g_clistApi.hwndStatus);

flags |= db_get_b(0, "CLUI", "ShowSBar", 1) ? WS_VISIBLE : 0;

static COLORREF sttSelBkColour;

static BOOL sttBkUseWinColours;

//for old multiwindow

#define MPCF_CONTEXTFRAMEMENU 3

return 0;

}

{

for (int i = 0; i < g_nFramesCount; i++) {

FRAMEWND &F = g_pfwFrames[i];

CMStringA buf;

db_set_ws(0, CLUIFrameModule, buf.Format("Name%d", storpos), F.name);

db_set_w(0, CLUIFrameModule, buf.Format("Height%d", storpos), (WORD)F.height);

db_set_w(0, CLUIFrameModule, buf.Format("HeightCollapsed%d", storpos), (WORD)F.HeightWhenCollapsed);

db_set_w(0, CLUIFrameModule, buf.Format("FloatW%d", storpos), (WORD)F.FloatingSize.x);

db_set_w(0, CLUIFrameModule, buf.Format("FloatH%d", storpos), (WORD)F.FloatingSize.y);

db_set_w(0, CLUIFrameModule, buf.Format("Order%d", storpos), (WORD)F.order);

db_set_w(0, CLUIFrameModule, "StoredFrames", (WORD)maxstored);

switch (msg) {

case WM_ACTIVATE:

if (g_bTransparentFlag) {

if ((wParam != WA_INACTIVE || ((HWND)lParam == hwnd) || GetParent((HWND)lParam) == hwnd)) {

HWND hw = lParam ? GetParent((HWND)lParam) : nullptr;

alpha = g_plugin.getByte("Alpha", SETTING_ALPHA_DEFAULT);

BOOL bPlaying;

int overlayIconIdx;

BOOL bOrderTop;

BOOL bPaused; // was request do not draw

{

RECT rcPos;

int idxOverlay;

};

struct ANIAVA_SYNCCALLITEM

static mir_cs s_CS;

// options

static COLORREF s_borderColor;

static COLORREF s_bkgColor;

static HIMAGELIST s_overlayIconImageList;

s_cornerRadius = g_plugin.getByte("AvatarsUseCustomCornerSize", SETTINGS_AVATARUSECUTOMCORNERSIZE_DEFAULT) ? g_plugin.getWord("AvatarsCustomCornerSize", SETTINGS_AVATARCORNERSIZE_DEFAULT) : 0;

if (s_bFlags & AAO_HAS_OVERLAY) {

// check image list

switch (type) {

case SETTING_AVATAR_OVERLAY_TYPE_NORMAL:

s_overlayIconImageList = hAvatarOverlays;

if (dat->bPlaying && IsWindowVisible(dat->hWindow)) {

POINT ptWnd = { 0 };

SIZE szWnd = { dat->rcPos.right - dat->rcPos.left, dat->rcPos.bottom - dat->rcPos.top };

POINT pt_from = { 0, 0 };

HDC hDC_animation = GetDC(nullptr);

HDC copyFromDC;

/////////////////////////////////////////////////////////////////////////////////////////

// update avatars pos

{

aacheck 0;

mir_cslock lck(s_CS);

static HANDLE hShowInfoTipEvent;

static POINT HitPoint;

static BOOL fMouseUpped;

static int StartDragPos = 0;

static int StartScrollPos = 0;

static BOOL g_bSortTimerIsSet = FALSE;

fMouseUpped = TRUE;

if (hitcontact != nullptr && dat->bMetaExpanding) {

CLUI_SafeSetTimer(hwnd, TIMERID_SUBEXPAND, GetDoubleClickTime()*doubleClickExpand, nullptr);

}

else if (dat->iHotTrack == -1 && dat->iDragItem == -1)

static LRESULT clcOnIntmGroupChanged(ClcData *dat, HWND hwnd, UINT, WPARAM wParam, LPARAM)

{

WORD iExtraImage[EXTRA_ICON_COUNT];

ClcContact *contact;

if (!Clist_FindItem(hwnd, dat, wParam, &contact))

int ClcUnloadModule()

{

Clist::UseGroups = g_CluiData.bOldUseGroups;

Clist::HideOffline = g_CluiData.boldHideOffline;

return 0;

struct tContactItems

{

RECT itemRect;

};

RECT pos_contact_time;

RECT pos_extra[EXTRA_ICON_COUNT];

DWORD lastPaintCounter;

// For extended layout

BOOL ext_fItemsValid;

tContactItems ext_mpItemsDesc[EXTRA_ICON_COUNT + 10]; //up to 10 items

HFONT hFont;

int fontHeight, changed;

COLORREF colour;

COLORREF effectColour1;

COLORREF effectColour2;

};

struct ClcData : public ClcDataBase

{

time_t last_tick_time;

bool bForceInDialog, bPlaceOfflineToRoot, bMetaIgnoreEmptyExtra, bMetaExpanding;

int subIndent;

BOOL row_align_right_items_to_right;

int row_items[NUM_ITEM_TYPE];

BOOL row_hide_group_icon;

// Avatar

BOOL avatars_show;

ClcModernFontInfo fontModernInfo[FONTID_MODERN_MAX + 1];

HWND hWnd;

int menuOwnerID;

DWORD m_paintCouter; //range is enoght to 49 days if painting will occure each one millisecond

int nInsertionLevel;

XPTHANDLE hCheckBoxTheme;

__forceinline int getRowHeight(int iRow) const

{ return (row_heights && row_variable_height) ? row_heights[iRow] : rowHeight;

// clcopts.c

int ClcOptInit(WPARAM wParam, LPARAM lParam);

DWORD GetDefaultExStyle(void);

// groups.c

int GetContactCachedStatus(MCONTACT hContact);

index += contact->iSubNumber;

}

if (k) {

for (int i = 0; i < mainindex; i++) {

ClcContact *tempCont = group->cl[i];

const wchar_t *szDescr;

COLORREF defColour;

const wchar_t *szDefFace;

char defSize;

FONTEFFECT defeffect;

COLORREF colour;

wchar_t szFace[LF_FACESIZE];

char size;

}

static fontOptionsList[] =

return ret;

}

{

for (auto &p : fontOptionsList) {

if (p.fontID == i) {

static void CheckButtons(HWND hwndDlg)

{

EnableWindow(GetDlgItem(hwndDlg, IDC_METADBLCLK), t);

EnableWindow(GetDlgItem(hwndDlg, IDC_METASUBEXTRA), t);

EnableWindow(GetDlgItem(hwndDlg, IDC_SUBINDENTSPIN), t);

case 0:

switch (((LPNMHDR)lParam)->code) {

case PSN_APPLY:

ClcOptionsChanged();

CLUI_ReloadCLUIOptions();

PostMessage(g_clistApi.hwndContactList, WM_SIZE, 0, 0);

else

db_set_dw(0, "CLC", "GreyoutFlags", 0);

db_set_w(0, "CLC", "ScrollTime", (WORD)SendDlgItemMessage(hwndDlg, IDC_SMOOTHTIMESPIN, UDM_GETPOS, 0, 0));

ClcOptionsChanged();

return TRUE;

case 0:

switch (((LPNMHDR)lParam)->code) {

case PSN_APPLY:

int hil = 0;

if (IsDlgButtonChecked(hwndDlg, IDC_HILIGHTMODE1)) hil = 1;

if (IsDlgButtonChecked(hwndDlg, IDC_HILIGHTMODE2)) hil = 2;

if (IsDlgButtonChecked(hwndDlg, IDC_HILIGHTMODE3)) hil = 3;

int s1 = SendDlgItemMessage(hwndDlg, IDC_CLSORT1, CB_GETCURSEL, 0, 0);

int s2 = SendDlgItemMessage(hwndDlg, IDC_CLSORT2, CB_GETCURSEL, 0, 0);

if (s1 >= 0) s1 = sortbyValue[s1];

if (s2 >= 0) s2 = sortbyValue[s2];

if (s3 >= 0) s3 = sortbyValue[s3];

Clist_LoadContactTree(); /* this won't do job properly since it only really works when changes happen */

Clist_InitAutoRebuild(g_clistApi.hwndContactTree); /* force reshuffle */

CheckDlgButton(hwndDlg, IDC_NOOFFLINEMOVE, g_plugin.getByte("NoOfflineBottom", SETTING_NOOFFLINEBOTTOM_DEFAULT) ? BST_CHECKED : BST_UNCHECKED);

CheckDlgButton(hwndDlg, IDC_OFFLINETOROOT, g_plugin.getByte("PlaceOfflineToRoot", SETTING_PLACEOFFLINETOROOT_DEFAULT) ? BST_CHECKED : BST_UNCHECKED);

{

CheckDlgButton(hwndDlg, IDC_SHOWXSTATUS, (trayOption & 3) ? BST_CHECKED : BST_UNCHECKED);

CheckDlgButton(hwndDlg, IDC_SHOWNORMAL, (trayOption & 2) ? BST_CHECKED : BST_UNCHECKED);

CheckDlgButton(hwndDlg, IDC_TRANSPARENTOVERLAY, (trayOption & 4) ? BST_CHECKED : BST_UNCHECKED);

switch (((LPNMHDR)lParam)->code) {

case PSN_APPLY:

g_plugin.setWord("IconFlashTime", (WORD)SendDlgItemMessage(hwndDlg, IDC_BLINKSPIN, UDM_GETPOS, 0, 0));

xOptions = IsDlgButtonChecked(hwndDlg, IDC_SHOWXSTATUS) ? 1 : 0;

xOptions |= (xOptions && IsDlgButtonChecked(hwndDlg, IDC_SHOWNORMAL)) ? 2 : 0;

xOptions |= (xOptions && IsDlgButtonChecked(hwndDlg, IDC_TRANSPARENTOVERLAY)) ? 4 : 0;

case WM_NOTIFY:

switch (((LPNMHDR)lParam)->code) {

case PSN_APPLY:

db_set_w(0, "ModernData", "ShowDelay", (WORD)SendDlgItemMessage(hwndDlg, IDC_HIDETIMESPIN2, UDM_GETPOS, 0, 0));

db_set_w(0, "ModernData", "HideDelay", (WORD)SendDlgItemMessage(hwndDlg, IDC_HIDETIMESPIN3, UDM_GETPOS, 0, 0));

db_set_w(0, "ModernData", "HideBehindBorderSize", (WORD)SendDlgItemMessage(hwndDlg, IDC_HIDETIMESPIN4, UDM_GETPOS, 0, 0));

g_bChangingMode = true;

db_set_b(0, "CLUI", "EventArea",

g_plugin.setWord("HideTime", (WORD)SendDlgItemMessage(hwndDlg, IDC_HIDETIMESPIN, UDM_GETPOS, 0, 0));

CLUI_ChangeWindowMode();

SendMessage(g_clistApi.hwndContactTree, WM_SIZE, 0, 0); //forces it to send a cln_listsizechanged

case WM_NOTIFY:

switch (((LPNMHDR)lParam)->code) {

case PSN_APPLY:

db_set_b(0, "ModernData", "DisableEngine", IsDlgButtonChecked(hwndDlg, IDC_DISABLEENGINE));

db_set_b(0, "ModernData", "AeroGlass", IsDlgButtonChecked(hwndDlg, IDC_AEROGLASS));

if (BST_UNCHECKED == IsDlgButtonChecked(hwndDlg, IDC_DISABLEENGINE)) {

db_unset(0, "ModernData", "EnableLayering");

}

g_CluiData.dwKeyColor = db_get_dw(0, "ModernSettings", "KeyColor", (DWORD)SETTING_KEYCOLOR_DEFAULT);

SetWindowPos(g_clistApi.hwndContactList, IsDlgButtonChecked(hwndDlg, IDC_ONTOP) ? HWND_TOPMOST : HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);

//====== Non-Layered Mode ======

{

wchar_t title[256];

GetDlgItemText(hwndDlg, IDC_TITLETEXT, title, _countof(title));

g_plugin.setWString("TitleText", title);

}

//====== End of Non-Layered Mode ======

g_bChangingMode = true;

g_CluiData.fOnDesktop = false;

}

AniAva_UpdateParent();

g_CluiData.fSmoothAnimation = IsDlgButtonChecked(hwndDlg, IDC_FADEINOUT) != 0;

{

int i1 = SendDlgItemMessage(hwndDlg, IDC_FRAMESSPIN, UDM_GETPOS, 0, 0);

db_set_dw(0, "CLUIFrames", "GapBetweenTitleBar", (DWORD)i2);

Sync(CLUIFramesOnClistResize, (WPARAM)g_clistApi.hwndContactList, 0);

}

ske_LoadSkinFromDB();

CLUI_UpdateLayeredMode();

struct BkgrItem

{

COLORREF bkColor, selColor;

char filename[MAX_PATH];

WORD flags;

};

struct BkgrData

{

continue;

char *module = bkgrList[indx] + mir_strlen(bkgrList[indx]) + 1;

COLORREF col;

if ((col = p.bkColor) == DEFAULT_BKCOLOUR)

else

db_set_dw(0, module, "SelBkColour", col);

char str[MAX_PATH];

int retval = PathToAbsolute(p.filename, str);

const int CLCPaint::MIN_TEXT_WIDTH = 20;

const int CLCPaint::BUF2SIZE = 7;

CLCPaint::CLCPaint()

{

int gValue = GetRValue(pc.tmpbkcolour) + gDelta;

int bValue = GetRValue(pc.tmpbkcolour) + bDelta;

pc.hBrushAlternateGrey = CreateSolidBrush(GetNearestColor(pc.hdcMem, RGB(brValue, bgValue, bbValue)));

}

text_rc.left = min(text_rc.left, prcItem->left);

}

{

if (Drawing->type == CLCIT_GROUP) {

wchar_t *szCounts = Clist_GetGroupCountsText(dat, Drawing);

static const int MIN_TEXT_WIDTH;

static const int BUF2SIZE;

enum tagenumHASHINDEX

{

void _DrawContactAvatar(HDC hdcMem, ClcData *dat, ClcContact *Drawing, RECT *row_rc, int& selected, int& hottrack, RECT *prcItem);

void _DrawContactIcon(HDC hdcMem, ClcData *dat, ClcContact *Drawing, int& selected, int& hottrack, RECT *prcItem);

void _DrawContactText(HDC hdcMem, ClcData *dat, ClcContact *Drawing, int& selected, int& hottrack, RECT& text_rc, RECT *prcItem, UINT uTextFormat);

void _DrawContactTime(HDC hdcMem, ClcData *dat, ClcContact *Drawing, RECT *prcItem);

void _DrawContactExtraIcon(HDC hdcMem, ClcData *dat, ClcContact *Drawing, int& selected, int& hottrack, RECT *rc, int iImage);

void _DrawContactSelection(HDC hdcMem, ClcData *dat, int& selected, int& hottrack, RECT *rcPaint, RECT *prcItem);

static int FAV_OnContactMenuBuild(WPARAM hContact, LPARAM)

{

if (bContactRate > _countof(rates) - 1)

bContactRate = _countof(rates) - 1;

INT_PTR FAV_SetRate(WPARAM hContact, LPARAM nRate)

{

if (hContact)

return 0;

}

HICON cliGetIconFromStatusMode(MCONTACT hContact, const char *szProto, int status)

{

// check if options is turned on

if ((trayOption & 3) && szProto != nullptr) {

if (ProtoServiceExists(szProto, PS_GETCUSTOMSTATUSICON)) {

// check status is online

#define GWVS_PARTIALLY_COVERED 4

int GetWindowVisibleState(HWND, int, int);

{

DWORD res = 0;

if (X >= 0 && X < Width && Y >= 0 && Y < Height && ptr)

int maxx = 0;

int maxy = 0;

int wx = 0;

HRGN rgn = nullptr;

HBITMAP WindowImage = g_CluiData.fLayered ? ske_GetCurrentWindowImage() : nullptr;

if (WindowImage && g_CluiData.fLayered) {

BITMAP bmp;

GetObject(WindowImage, sizeof(BITMAP), &bmp);

maxx = bmp.bmWidth;

maxy = bmp.bmHeight;

wx = bmp.bmWidthBytes;

return GWVS_PARTIALLY_COVERED;

}

int cliShowHide(bool bAlwaysShow)

{

case PSN_APPLY:

g_plugin.setWord("MinRowHeight", (WORD)SendDlgItemMessage(hwndDlg, IDC_MIN_ROW_HEIGHT_SPIN, UDM_GETPOS, 0, 0));

g_plugin.setWord("RowBorder", (WORD)SendDlgItemMessage(hwndDlg, IDC_ROW_BORDER_SPIN, UDM_GETPOS, 0, 0));

{

HWND hwndList = GetDlgItem(hwndDlg, IDC_LIST_ORDER);

for (int i = 0; i < NUM_ITEM_TYPE; i++) {

case 0:

switch (((LPNMHDR)lParam)->code) {

case PSN_APPLY:

g_plugin.setDword("AvatarsBorderColor", (DWORD)SendDlgItemMessage(hwndDlg, IDC_AVATAR_BORDER_COLOR, CPM_GETCOLOUR, 0, 0));

g_plugin.setWord("AvatarsCustomCornerSize", (WORD)SendDlgItemMessage(hwndDlg, IDC_AVATAR_CUSTOM_CORNER_SIZE_SPIN, UDM_GETPOS, 0, 0));

g_plugin.setWord("AvatarsSize", (WORD)SendDlgItemMessage(hwndDlg, IDC_AVATAR_SIZE_SPIN, UDM_GETPOS, 0, 0));

g_plugin.setWord("AvatarsWidth", (WORD)SendDlgItemMessage(hwndDlg, IDC_AVATAR_WIDTH_SPIN, UDM_GETPOS, 0, 0));

case 0:

switch (((LPNMHDR)lParam)->code) {

case PSN_APPLY:

{

if (ovr) ovr += IsDlgButtonChecked(hwndDlg, IDC_DRAWSTATUSOVERLAY) ? 2 : 0;

db_set_b(0, "CLC", "DrawOverlayedStatus", ovr);

}

case 0:

switch (((LPNMHDR)lParam)->code) {

case PSN_APPLY:

ClcOptionsChanged();

return TRUE;

}

case 0:

switch (((LPNMHDR)lParam)->code) {

case PSN_APPLY:

ClcOptionsChanged();

return TRUE;

}

case 0:

switch (((LPNMHDR)lParam)->code) {

case PSN_APPLY:

g_plugin.setWord("SecondLineTopSpace", (WORD)SendDlgItemMessage(hwndDlg, IDC_TOP_SPACE_SPIN, UDM_GETPOS, 0, 0));

WORD radio;

if (IsDlgButtonChecked(hwndDlg, IDC_STATUS))

t[TEXT_TEXT_MAX_LENGTH - 1] = '\0';

g_plugin.setWString("SecondLineText", t);

ClcOptionsChanged();

return TRUE;

}

case 0:

switch (((LPNMHDR)lParam)->code) {

case PSN_APPLY:

g_plugin.setWord("ThirdLineTopSpace", (WORD)SendDlgItemMessage(hwndDlg, IDC_TOP_SPACE_SPIN, UDM_GETPOS, 0, 0));

{

int radio;

if (IsDlgButtonChecked(hwndDlg, IDC_STATUS))

g_plugin.setWString("ThirdLineText", t);

}

ClcOptionsChanged();

return TRUE;

}

void SettingsMigrate(void)

{

ptrA PrimaryStatus(g_plugin.getStringA("PrimaryStatus"));

// these strings must always be set

return res;

}

UINT_PTR TimerID = 0;

int cliTrayIconInit(HWND hwnd)

return 0;

}

if (!bDiffers) // all equal

OldMode = Mode = g_plugin.getByte("tiModeS", TRAY_ICON_MODE_GLOBAL);

else

GetGoodAccNum(&bDiffers, &bConn);

// if the icon number to be changed, reinitialize module from scratch

if (Mode != OldMode) {

OldMode = Mode;

Clist_TrayIconIconsChanged();

/* Module global variables */

static int bOldHideOffline;

static int bOldUseGroups;

static BOOL CLUI_WaitThreadsCompletion()

{

TRACE("CLUI_WaitThreadsCompletion Enter");

if (bEntersCount < bcMAX_AWAITING_RETRY && (g_CluiData.mutexPaintLock || g_hAwayMsgThread || g_hGetTextAsyncThread || g_hSmoothAnimationThread) && !Miranda_IsTerminated()) {

TRACE("Waiting threads");

return 1;

}

{

if (!g_CluiData.fLayered && (!g_CluiData.fSmoothAnimation && !g_bTransparentFlag)) {

if (GoalAlpha > 0 && wParam != 2) {

// change

bTransparentFocus = inwnd;

if (bTransparentFocus)

else

}

if (!bTransparentFocus)

KillTimer(m_hWnd, TM_AUTOALPHA);

}

RedrawWindow(m_hWnd, nullptr, nullptr, RDW_INVALIDATE | RDW_ALLCHILDREN);

if (g_bTransparentFlag) {

if (wParam != WA_INACTIVE || CLUI_CheckOwnedByClui((HWND)lParam) || ((HWND)lParam == m_hWnd) || GetParent((HWND)lParam) == m_hWnd)

alpha = g_plugin.getByte("Alpha", SETTING_ALPHA_DEFAULT);

else

if (lParam) return 0;

if (mutex_bShowHideCalledFromAnimation) return 1;

if (wParam) {

g_CluiData.bCurrentAlpha = 0;

Sync(CLUIFrames_OnShowHide, 1);

UnLoadCLUIFramesModule();

//ExtFrames_Uninit();

TRACE("CLUI.c: WM_DESTROY - UnLoadCLUIFramesModule DONE\n");

ske_UnloadSkin(&g_SkinObjectList);

delete m_pCLUI;

extern bool g_bTransparentFlag;

extern bool g_bFullRepaint;

extern bool g_bMultiConnectionMode;

extern HWND g_hCLUIOptionsWnd;

extern UINT g_dwMainThreadID;

extern HWND g_hwndViewModeFrame;

int CLUI_ShowFromBehindEdge();

int CLUI_SizingGetWindowRect(HWND hwnd, RECT *rc);

int CLUI_SizingOnBorder(POINT, int);

int CLUI_TestCursorOnBorders();

int CLUI_UpdateTimer();

void CLUI_UpdateLayeredMode();

/* ModernSkinButton */

int ModernSkinButton_AddButton(HWND parent, char *ID, char *CommandService, char *StateDefService, char *HandeService, int Left, int Top, int Right, int Bottom, DWORD AlignedTo, wchar_t *Hint, char *DBkey, char *TypeDef, int MinWidth, int MinHeight);

int ModernSkinButtonLoadModule();

int ModernSkinButtonUnloadModule(WPARAM, LPARAM);

/* RowHeight */

int ske_BltBackImage(HWND destHWND, HDC destDC, RECT *BltClientRect);

HBITMAP ske_CreateDIB32(int cx, int cy);

HBITMAP ske_CreateDIB32Point(int cx, int cy, void ** bits);

int ske_DrawImageAt(HDC hdc, RECT *rc);

BOOL ske_DrawIconEx(HDC hdc, int xLeft, int yTop, HICON hIcon, int cxWidth, int cyWidth, UINT istepIfAniCur, HBRUSH hbrFlickerFreeDraw, UINT diFlags);

int ske_DrawNonFramedObjects(BOOL Erase, RECT *r);

BOOL ske_DrawText(HDC hdc, LPCTSTR lpString, int nCount, RECT *lpRect, UINT format);

HBITMAP ske_GetCurrentWindowImage();

int ske_GetFullFilename(wchar_t *buf, const wchar_t *file, wchar_t *skinfolder, BOOL madeAbsolute);

BOOL ske_ImageList_DrawEx(HIMAGELIST himl, int i, HDC hdcDst, int x, int y, int dx, int dy, COLORREF rgbBk, COLORREF rgbFg, UINT fStyle);

int ske_ReCreateBackImage(BOOL Erase, RECT *w);

int ske_RedrawCompleteWindow();

bool ske_ResetTextEffect(HDC);

INT_PTR ske_Service_DrawGlyph(WPARAM wParam, LPARAM lParam);

BOOL ske_SetRectOpaque(HDC memdc, RECT *fr, BOOL force = FALSE);

BOOL ske_SetRgnOpaque(HDC memdc, HRGN hrgn, BOOL force = FALSE);

int DrawTitleBar(HDC hdcMem2, RECT *rect, int Frameid);

int FindFrameID(HWND FrameHwnd);

/* others TODO: move above */

void DrawBackGround(HWND hwnd, HDC mhdc, HBITMAP hBmpBackground, COLORREF bkColour, DWORD backgroundBmpUse);

HRESULT BackgroundsLoadModule();

int BackgroundsUnloadModule();

DWORD CompareContacts2_getLMTime(MCONTACT u); //contact.c

DWORD mod_CalcHash(const char *a); //mod_skin_selector.c

HICON cliGetIconFromStatusMode(MCONTACT hContact, const char *szProto, int status); //clistmod.c

INT_PTR ToggleSounds(WPARAM wParam, LPARAM lParam); //contact.c

void ClcOptionsChanged(); //clc.c

void Docking_GetMonitorRectFromWindow(HWND hWnd, RECT *rc); //Docking.c

void InitGdiPlus(); //gdiplus.cpp

void ShutdownGdiPlus(); //gdiplus.cpp

void UnloadAvatarOverlayIcon(); //clc.c

/* SkinEngine.c */

extern OVERLAYICONINFO g_pAvatarOverlayIcons[MAX_STATUS_COUNT];

extern OVERLAYICONINFO g_pStatusOverlayIcons[MAX_STATUS_COUNT];

ClcCacheEntry *c1 = contact1->pce, *c2 = contact2->pce;

for (int i = 0; i < _countof(g_CluiData.bSortByOrder); i++) {

if (by == SORTBY_STATUS) { //status

int ordera = GetStatusModeOrdering(c1->getStatus());

INT_PTR ToggleSounds(WPARAM, LPARAM)

{

db_set_b(0, "Skin", "UseSound",

return 0;

}

MSG *msg = (MSG*)wParam;

if (msg->message == WM_DESTROY)

if (!g_CluiData.fDocked && msg->message != WM_CREATE && msg->message != WM_MOVING && msg->message != WM_CREATEDOCKED && msg->message != WM_MOVE && msg->message != WM_SIZE) return 0;

switch (msg->message) {

Sync(CLUIFrames_OnMoving, msg->hwnd, (LPRECT)msg->lParam);

g_CluiData.mutexPreventDockMoving = 1;

mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);

ModernSkinButton_ReposButtons(msg->hwnd, SBRF_DO_NOT_DRAW, nullptr);

return TRUE;

}

GetCursorPos(&pt);

PostMessage(msg->hwnd, WM_NCLBUTTONDOWN, HTCAPTION, MAKELPARAM(pt.x, pt.y));

SetWindowPos(msg->hwnd, nullptr, pt.x - rc.right / 2, pt.y - GetSystemMetrics(SM_CYFRAME) - GetSystemMetrics(SM_CYSMCAPTION) / 2, g_plugin.getDword("Width", 0), g_plugin.getDword("Height", 0), SWP_NOZORDER);

// ModernSkinButton_ReposButtons(msg->hwnd, SBRF_DO_NOT_DRAW, nullptr);

}

return 1;

typedef struct _MODERNEFFECTMATRIX

{

sbyte matrix[25];

}MODERNEFFECTMATRIX;

typedef struct _MODERNEFFECT

{

MODERNEFFECTMATRIX EffectMatrix;

DWORD EffectColor1;

DWORD EffectColor2;

extern wchar_t * ModernEffectNames[];

#endif

extern BOOL SkinEngine_ResetTextEffect(HDC);

HBITMAP ske_CreateDIB32(int cx, int cy);

ULONG_PTR g_gdiplusToken;

int g_hottrack;

0.0f, 0.0f, 0.0f, 0.0f, 1.0f

};

{

}

HBITMAP GDIPlus_LoadGlyphImage(const wchar_t *tszFileName)

return hbmp;

}

{

BITMAP bmp;

Bitmap *bm;

GetObject(hbmp, sizeof(BITMAP), &bmp);

Graphics g(hDestDC);

if (bmp.bmBitsPixel == 32 && (flag&AVS_PREMULTIPLIED)) {

if (!bmbits) {

GetBitmapBits(hbmp, bmp.bmHeight*bmp.bmWidthBytes, bmbits);

}

bm = new Bitmap(bmp.bmWidth, bmp.bmHeight, bmp.bmWidthBytes, PixelFormat32bppPARGB, bmbits);

Bitmap *bm;

if (bmp.bmBitsPixel == 32 && bf->AlphaFormat) {

bm->RotateFlip(RotateNoneFlipY);

}

else bm = new Bitmap(hbmp, nullptr);

char varFilter[2048];

DWORD lastMsgFilter;

char current_viewmode[256], old_viewmode[256];

DWORD statusMaskFilter;

DWORD stickyMaskFilter;

DWORD filterFlags;

bool fSortNoOfflineBottom;

bool fAutoSize;

bool fAeroGlass;

signed char nBehindEdgeState;

{

if (hdcDest == nullptr || pos < 0 || pos >= iad->nodes_size)

return FALSE;

BOOL ImageArray_RemoveImage(IMAGE_ARRAY_DATA *iad, int pos);

// Draw an image

#endif // __IMAGE_ARRAY_H__

typedef struct _ModernSkinButtonCtrl

{

HWND hwnd;

BOOL fCallOnPress;

char * ID;

char * CommandService;

case 'b':

curval = db_get_b(0, section, key, l2);

curval = (curval == l2) ? l1 : l2;

break;

}

mir_free(section);

typedef struct _MButton

{

HWND hwnd;

int OrL, OrR, OrT, OrB;

int minW, minH;

ModernSkinButtonCtrl * bct;

Buttons[ButtonsCount].OrT = Top;

Buttons[ButtonsCount].OrR = Right;

Buttons[ButtonsCount].OrB = Bottom;

Buttons[ButtonsCount].minH = MinHeight;

Buttons[ButtonsCount].minW = MinWidth;

ButtonsCount++;

return 0;

}

{

RECT rc, clr, rd;

BOOL altDraw = FALSE;

/* tga header */

struct tga_header_t

{

short cm_first_entry; /* colormap origin */

short cm_length; /* colormap length */

short x_origin; /* bottom left x coord origin */

short y_origin; /* bottom left y coord origin */

short width; /* picture width (in pixels) */

short height; /* picture height (in pixels) */

};

#pragma pack(pop)

static char **pszSettingName = nullptr;

static int nArrayLen = 0;

static BOOL bGammaWeightFilled = FALSE;

static mir_cs cs_SkinChanging;

static LISTMODERNMASK *MainModernMaskList = nullptr;

/* Private module procedures */

static INT_PTR ske_Service_AlphaTextOut(WPARAM wParam, LPARAM lParam);

static INT_PTR ske_Service_DrawIconEx(WPARAM wParam, LPARAM lParam);

static int ske_GetSkinFromDB(char * szSection, SKINOBJECTSLIST * Skin);

static SKINOBJECTDESCRIPTOR* ske_FindObject(const char *szName, SKINOBJECTSLIST *Skin);

static int ske_LoadSkinFromResource(BOOL bOnlyObjects);

static int ske_ValidateSingleFrameImage(FRAMEWND * Frame, BOOL SkipBkgBlitting);

static INT_PTR ske_Service_UpdateFrameImage(WPARAM wParam, LPARAM lParam);

static INT_PTR ske_Service_InvalidateFrameImage(WPARAM wParam, LPARAM lParam);

//////////////////////////////////////////////////////////////////////////

// Ini file parser

{

_DoInit();

if (!tcsFileName) return;

}

}

{

_DoInit();

_LoadResourceIni(hInst, resourceName, resourceType);

switch (szValue[0]) {

case 'b':

break;

case 'w':

BOOL ske_SetRectOpaque(HDC memdc, RECT *fr, BOOL force)

{

int f = 0;

BITMAP bmp;

if (g_CluiData.fDisableSkinEngine && !force)

if (!bmp.bmBits) {

f = 1;

GetBitmapBits(hbmp, bmp.bmWidthBytes*bmp.bmHeight, bits);

}

else

int sx = (fr->left > 0) ? fr->left : 0;

int sy = (fr->top > 0) ? fr->top : 0;

int width = ex - sx;

for (int y = 0; y < (ey - sy); y++) {

for (int x = 0; x < width; x++) {

*pColumn = 255;

pColumn += 4;

return 1;

}

{

BLENDFUNCTION bf = { AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };

return DirectBitmap;

}

{

if (!g_pCachedWindow)

return nullptr;

int k = 0;

//BITMAP bmp = {0};

HBITMAP membmp = nullptr, oldbmp = nullptr, oldglyph = nullptr;

RECT PRect;

POINT mode2offset = { 0 };

int depth = 0;

if ((k > 0 || k == -1) && mode == 2) {

{

OffsetRect(&PRect, mode2offset.x, mode2offset.y);

ske_AlphaBlend(preq->hDC, PRect.left, PRect.top, PRect.right - PRect.left, PRect.bottom - PRect.top,

memdc, 0, 0, PRect.right - PRect.left, PRect.bottom - PRect.top, bf);

return sk->pMaskList ? skin_FindObjectByMask(pModernMask, sk->pMaskList) : nullptr;

}

{

SKINOBJECTSLIST *sk = (Skin == nullptr) ? (&g_SkinObjectList) : Skin;

for (DWORD i = 0; i < sk->dwObjLPAlocated; i++) {

if (gl->hGlyph) {

BITMAP bmp = { 0 };

GetObject(gl->hGlyph, sizeof(BITMAP), &bmp);

gl->bmHeight = bmp.bmHeight;

gl->bmWidth = bmp.bmWidth;

}

}

{

BITMAP bmp;

BOOL flag = FALSE;

DWORD Len;

int bh, bw, y, x;

GetBitmapBits(hbmp, Len, pBitmapBits);

}

else

for (y = 0; y < bh; ++y) {

for (x = 0; x < bw; ++x) {

if (Mult) {

Major part of routines is from http://tfcduke.developpez.com/tutoriel/format/tga/fichiers/tga.c

*/

{

FILE *fp = !fromSize ? (FILE *)From : nullptr;

DWORD destCount = 0;

DWORD fromCount = 0;

if (!RLE) {

while (((from && fromCount < fromSize) || (fp && fromCount < bufSize))

&& (destCount < bufSize)) {

pos[destCount++] = r;

pos[destCount++] = g;

pos[destCount++] = b;

}

}

else {

int i;

while (ptr < pos + bufSize) {

/* read first byte */

if (from) from++;

size = 1 + (packet_header & 0x7f);

if (packet_header & 0x80) {

*((DWORD*)rgba) = *((DWORD*)(from + fromCount));

fromCount += 4;

}

for (i = 0; i < size; ++i, ptr += 4) {

ptr[2] = rgba[2];

ptr[1] = rgba[1];

}

else { /* not run-length packet */

for (i = 0; i < size; ++i, ptr += 4) {

}

}

}

static HBITMAP ske_LoadGlyphImage_TGA(const wchar_t *szFilename)

{

int cx = 0, cy = 0;

BOOL err = FALSE;

tga_header_t header;

}

/*memory allocation */

cx = header.width;

cy = header.height;

fseek(fp, header.id_lenght, SEEK_CUR);

HGLOBAL hRes = LoadResource(g_plugin.getInst(), hRSrc);

if (!hRes) return nullptr;

DWORD size = SizeofResource(g_plugin.getInst(), hRSrc);

if (size > sizeof(header)) {

tga_header_t *tgahdr = (tga_header_t*)mem;

if (tgahdr->pixel_depth == 32 && (tgahdr->image_type == 2 || tgahdr->image_type == 10)) {

cx = tgahdr->width;

cy = tgahdr->height;

ske_ReadTGAImageData((void*)(mem + sizeof(tga_header_t) + tgahdr->id_lenght + tgahdr->cm_length), size - (sizeof(tga_header_t) + tgahdr->id_lenght + tgahdr->cm_length), colormap, cx*cy * 4, tgahdr->image_type == 10);

return nullptr;

// create dib section

HBITMAP hbmp = ske_CreateDIB32Point(cx, cy, (void**)&pt);

if (hbmp)

memcpy(pt, colormap, cx*cy * 4);

return true;

}