BOOL TabCtrl_SwapItems(HWND hTabCtrl, int iItem1, int iItem2)
{
TCITEM tcItem;
TCHAR szText1[512];
tcItem.mask = TCIF_TEXT | TCIF_PARAM | TCIF_IMAGE;
tcItem.pszText = szText1;
tcItem.cchTextMax = SIZEOF_ARRAY(szText1);
BOOL bRet = TabCtrl_GetItem(hTabCtrl, iItem1, &tcItem);
if(!bRet)
{
return FALSE;
}
LPARAM lParam1;
int iImage1;
lParam1 = tcItem.lParam;
iImage1 = tcItem.iImage;
TCHAR szText2[512];
tcItem.mask = TCIF_TEXT | TCIF_PARAM | TCIF_IMAGE;
tcItem.pszText = szText2;
tcItem.cchTextMax = SIZEOF_ARRAY(szText2);
bRet = TabCtrl_GetItem(hTabCtrl, iItem2, &tcItem);
if(!bRet)
{
return FALSE;
}
LPARAM lParam2;
int iImage2;
lParam2 = tcItem.lParam;
iImage2 = tcItem.iImage;
tcItem.mask = TCIF_TEXT | TCIF_PARAM | TCIF_IMAGE;
tcItem.pszText = szText1;
tcItem.lParam = lParam1;
tcItem.iImage = iImage1;
bRet = TabCtrl_SetItem(hTabCtrl, iItem2, &tcItem);
if(!bRet)
{
return FALSE;
}
tcItem.mask = TCIF_TEXT | TCIF_PARAM | TCIF_IMAGE;
tcItem.pszText = szText2;
tcItem.lParam = lParam2;
tcItem.iImage = iImage2;
bRet = TabCtrl_SetItem(hTabCtrl, iItem1, &tcItem);
if(!bRet)
{
return FALSE;
}
return TRUE;
}
bool wxNotebook::SetPageText(size_t nPage, const wxString& strText)
{
wxCHECK_MSG( IS_VALID_PAGE(nPage), false, wxT("notebook page out of range") );
TC_ITEM tcItem;
tcItem.mask = TCIF_TEXT;
tcItem.pszText = wxMSW_CONV_LPTSTR(strText);
if ( !HasFlag(wxNB_MULTILINE) )
return TabCtrl_SetItem(GetHwnd(), nPage, &tcItem) != 0;
// multiline - we need to set new page size if a line is added or removed
int rows = GetRowCount();
bool ret = TabCtrl_SetItem(GetHwnd(), nPage, &tcItem) != 0;
if ( ret && rows != GetRowCount() )
{
const wxRect r = GetPageSize();
const size_t count = m_pages.Count();
for ( size_t page = 0; page < count; page++ )
m_pages[page]->SetSize(r);
}
return ret;
}
static void SetTabTitle(WindowInfo *win, TabInfo *tab)
{
TCITEM tcs;
tcs.mask = TCIF_TEXT;
tcs.pszText = (WCHAR *)tab->GetTabTitle();
TabCtrl_SetItem(win->hwndTabBar, win->tabs.Find(tab), &tcs);
}
/// Function name : updateDocumentTitle
// Description : Updates the document's tab to reflect it's current title and modified status
//
// DOCUMENT* pDocument : [in] Target Document
//
VOID updateDocumentTitle(DOCUMENT* pDocument)
{
DOCUMENTS_DATA* pWindowData; // Window data
TCITEM oTabData; // Document Tab data
INT iIndex; // Document index
// Prepare
pWindowData = getDocumentsControlData(getMainWindowData()->hDocumentsTab);
oTabData.pszText = utilCreateEmptyString(128);
oTabData.mask = TCIF_TEXT;
/// [CHECK] Is the document modified?
if (isModified(pDocument))
// [MODIFIED] Append an asterix to the filename
StringCchPrintf(oTabData.pszText, 128, TEXT("%s *"), getDocumentFileName(pDocument));
else
// [UN-MODIFED] Use filename
StringCchCopy(oTabData.pszText, 128, getDocumentFileName(pDocument));
/// Display new title
findDocumentIndexByValue(pWindowData, pDocument, iIndex);
TabCtrl_SetItem(pWindowData->hTabCtrl, iIndex, &oTabData);
// Refresh document window (Document is erased but not invalidated by TabCtrl_SetItem)
utilRedrawWindow(pDocument->hWnd);
// Cleanup
utilDeleteString(oTabData.pszText);
}
void SendQueue::showErrorControls(TWindowData *dat, const int showCmd) const
{
UINT myerrorControls[] = { IDC_STATICERRORICON, IDC_STATICTEXT, IDC_RETRY, IDC_CANCELSEND, IDC_MSGSENDLATER};
int i;
HWND hwndDlg = dat->hwnd;
if (showCmd) {
TCITEM item = {0};
dat->hTabIcon = PluginConfig.g_iconErr;
item.mask = TCIF_IMAGE;
item.iImage = 0;
TabCtrl_SetItem(GetDlgItem(dat->pContainer->hwnd, IDC_MSGTABS), dat->iTabID, &item);
dat->dwFlags |= MWF_ERRORSTATE;
}
else {
dat->dwFlags &= ~MWF_ERRORSTATE;
dat->hTabIcon = dat->hTabStatusIcon;
}
for (i = 0; i < 5; i++) {
if (IsWindow(GetDlgItem(hwndDlg, myerrorControls[i])))
Utils::showDlgControl(hwndDlg, myerrorControls[i], showCmd ? SW_SHOW : SW_HIDE);
}
SendMessage(hwndDlg, WM_SIZE, 0, 0);
DM_ScrollToBottom(dat, 0, 1);
if (m_jobs[0].hOwner != 0)
EnableSending(dat, TRUE);
}
void ControlsTab::renameTab(int index, const TCHAR *newName)
{
TCITEM tie;
tie.mask = TCIF_TEXT;
tie.pszText = (TCHAR *)newName;
TabCtrl_SetItem(_hSelf, index, &tie);
}
// Set the image for an item
bool wxTabCtrl::SetItemImage(int item, int image)
{
TC_ITEM tcItem;
tcItem.mask = TCIF_IMAGE;
tcItem.iImage = image;
return ( TabCtrl_SetItem( (HWND) GetHWND(), item, & tcItem) != 0 );
}
// Set the data for an item
bool wxTabCtrl::SetItemData(int item, void* data)
{
TC_ITEM tcItem;
tcItem.mask = TCIF_PARAM;
tcItem.lParam = (long) data;
return ( TabCtrl_SetItem( (HWND) GetHWND(), item, & tcItem) != 0 );
}
bool wxNotebook::SetPageImage(size_t nPage, int nImage)
{
wxCHECK_MSG( IS_VALID_PAGE(nPage), false, wxT("notebook page out of range") );
TC_ITEM tcItem;
tcItem.mask = TCIF_IMAGE;
tcItem.iImage = nImage;
return TabCtrl_SetItem(GetHwnd(), nPage, &tcItem) != 0;
}
// Set the text for an item
bool wxTabCtrl::SetItemText(int item, const wxString& text)
{
wxChar buf[256];
TC_ITEM tcItem;
tcItem.mask = TCIF_TEXT;
wxStrcpy(buf, (const wxChar*) text);
tcItem.pszText = buf;
tcItem.cchTextMax = 256;
return ( TabCtrl_SetItem( (HWND) GetHWND(), item, & tcItem) != 0 );
}
void ChatContainer::setUnread(ChatWindow *child, int unread) {
if (!unread || child != active) {
TCITEM tci;
tci.mask = TCIF_IMAGE;
if (unread) {
tci.iImage = 0;
} else {
tci.iImage = -1;
}
TabCtrl_SetItem(GetDlgItem(hWnd, IDC_TABS), getChildTab(child), &tci);
}
}
void NotebookPage::setTabLabel(const char *str) {
if(tab.name) free(tab.name);
tab.name = strdup(str);
#ifdef USE_GTK
gtk_label_set_text(GTK_LABEL(tab.label),str);
#endif
#ifdef USE_WIN32
TCITEM ti = {TCIF_TEXT};
ti.pszText = (tchar_t *)tstrdup(str);
TabCtrl_SetItem((HWND)tab.notebook->getComponent(),tab.index,&ti);
tfree(ti.pszText);
#endif
}
static void SwapTabs(WindowInfo *win, int tab1, int tab2)
{
if (tab1 == tab2 || tab1 < 0 || tab2 < 0)
return;
std::swap(win->tabs.At(tab1), win->tabs.At(tab2));
TCITEM tcs;
tcs.mask = TCIF_TEXT;
tcs.pszText = (WCHAR *)win->tabs.At(tab1)->tabTitle;
TabCtrl_SetItem(win->hwndTabBar, tab1, &tcs);
tcs.mask = TCIF_TEXT;
tcs.pszText = (WCHAR *)win->tabs.At(tab2)->tabTitle;
TabCtrl_SetItem(win->hwndTabBar, tab2, &tcs);
int current = TabCtrl_GetCurSel(win->hwndTabBar);
if (tab1 == current)
TabCtrl_SetCurSel(win->hwndTabBar, tab2);
else if (tab2 == current)
TabCtrl_SetCurSel(win->hwndTabBar, tab1);
}
BOOL TabCtrl_SetItemText(HWND hTabCtrl, int iItem, const TCHAR *pszText)
{
/* The const_cast below isn't
particularly good, but is
required. Information is only
being set, so the function
has no reason to modify the
string. */
TCITEM tcItem;
tcItem.mask = TCIF_TEXT;
tcItem.pszText = const_cast<LPTSTR>(pszText);
return TabCtrl_SetItem(hTabCtrl, iItem, &tcItem);
}
//设置Item文字
void SiTabCtl_SetItemText(HWND hwnd,char* text)
{
int idx = SiTabCtl_FindItem(hwnd);
if(idx == -1)
return;
TCITEM tci;
memset(&tci,0,sizeof(TCITEM));
tci.mask = TCIF_TEXT | TCIF_PARAM;
TabCtrl_GetItem(hwnd_tab_ctl,idx,&tci);
tci.pszText = (LPSTR)text;
TabCtrl_SetItem(hwnd_tab_ctl,idx,&tci);
}
void ChatContainer::changeChildData(ChatWindow *child) {
int tabId;
HWND hwndTabs = GetDlgItem(hWnd, IDC_TABS);
tabId = getChildTab(child);
if (tabId >=0) {
TCITEM tci;
tci.mask = TCIF_TEXT;
tci.pszText = (char *)child->getRoomName();
TabCtrl_SetItem(hwndTabs, childCount-1, &tci);
}
if (child == active) {
SetWindowText(hWnd, child->getRoomName());
}
}
/* Sets a tabs icon. Normally, this icon
is the folders icon, however if the tab
is locked, the icon will be a lock. */
void Explorerplusplus::SetTabIcon(int iIndex,int iTabId,LPITEMIDLIST pidlDirectory)
{
TCITEM tcItem;
SHFILEINFO shfi;
ICONINFO IconInfo;
int iImage;
int iRemoveImage;
/* If the tab is locked, use a lock icon. */
if(m_TabInfo[iTabId].bAddressLocked || m_TabInfo[iTabId].bLocked)
{
iImage = TAB_ICON_LOCK_INDEX;
}
else
{
SHGetFileInfo((LPCTSTR)pidlDirectory,0,&shfi,sizeof(shfi),
SHGFI_PIDL|SHGFI_ICON|SHGFI_SMALLICON);
/* TODO: The proxy icon may also be the lock icon, if
the tab is locked. */
SetTabProxyIcon(iTabId,shfi.hIcon);
GetIconInfo(shfi.hIcon,&IconInfo);
iImage = ImageList_Add(TabCtrl_GetImageList(m_hTabCtrl),
IconInfo.hbmColor,IconInfo.hbmMask);
DeleteObject(IconInfo.hbmColor);
DeleteObject(IconInfo.hbmMask);
DestroyIcon(shfi.hIcon);
}
/* Get the index of the current image. This image
will be removed after the new image is set. */
tcItem.mask = TCIF_IMAGE;
TabCtrl_GetItem(m_hTabCtrl,iIndex,&tcItem);
iRemoveImage = tcItem.iImage;
/* Set the new image. */
tcItem.mask = TCIF_IMAGE;
tcItem.iImage = iImage;
TabCtrl_SetItem(m_hTabCtrl,iIndex,&tcItem);
if(iRemoveImage != TAB_ICON_LOCK_INDEX)
{
/* Remove the old image. */
TabCtrl_RemoveImage(m_hTabCtrl,iRemoveImage);
}
}
static void SwapTabs(WindowInfo *win, int tab1, int tab2)
{
if (tab1 == tab2 || tab1 < 0 || tab2 < 0)
return;
WCHAR buf1[MAX_PATH], buf2[MAX_PATH];
LPARAM lp;
TCITEM tcs;
tcs.mask = TCIF_TEXT | TCIF_PARAM;
tcs.cchTextMax = MAX_PATH;
tcs.pszText = buf1;
if (!TabCtrl_GetItem(win->hwndTabBar, tab1, &tcs))
return;
if (tcs.pszText != buf1)
str::BufSet(buf1, dimof(buf1), tcs.pszText);
lp = tcs.lParam;
tcs.pszText = buf2;
if (!TabCtrl_GetItem(win->hwndTabBar, tab2, &tcs))
return;
if (tcs.pszText != buf2)
str::BufSet(buf2, dimof(buf2), tcs.pszText);
tcs.pszText = buf2;
TabCtrl_SetItem(win->hwndTabBar, tab1, &tcs);
tcs.pszText = buf1;
tcs.lParam = lp;
TabCtrl_SetItem(win->hwndTabBar, tab2, &tcs);
int current = TabCtrl_GetCurSel(win->hwndTabBar);
if (tab1 == current)
TabCtrl_SetCurSel(win->hwndTabBar, tab2);
else if (tab2 == current)
TabCtrl_SetCurSel(win->hwndTabBar, tab1);
}
// Добавляет закладку, или меняет (при необходимости) заголовок существующей
void CTabPanelWin::AddTabInt(LPCWSTR text, int i, bool bAdmin, int iTabIcon)
{
if (!IsTabbarCreated())
return;
int iIconIdx = mp_Owner->GetTabIcon(bAdmin);
_ASSERTE(text && *text);
TCITEM tie;
// иконку обновляем всегда. она может измениться для таба
tie.mask = TCIF_TEXT | (mp_Owner->GetTabIcons() ? TCIF_IMAGE : 0);
tie.pszText = (LPWSTR)text ;
tie.iImage = (iTabIcon > 0) ? iTabIcon : mp_Owner->GetTabIcon(bAdmin); // Пока иконка только одна - для табов со щитом
int nCurCount = GetItemCountInt();
if (i>=nCurCount)
{
DEBUGSTRTABS(L"Add", i, text);
TabCtrl_InsertItem(mh_Tabbar, i, &tie);
}
else
{
// Проверим, изменился ли текст
wchar_t sOldTabName[CONEMUTABMAX];
if (!GetTabText(i, sOldTabName, countof(sOldTabName)) || !wcscmp(sOldTabName, text))
tie.mask &= ~TCIF_TEXT;
#ifdef _DEBUG
else
DEBUGSTRTABS(L"Set", i, text);
#endif
// Изменилась ли иконка
if (tie.mask & TCIF_IMAGE)
{
TCITEM told;
told.mask = TCIF_IMAGE;
TabCtrl_GetItem(mh_Tabbar, i, &told);
if (told.iImage == tie.iImage)
tie.mask &= ~TCIF_IMAGE;
}
// "меняем" только если он реально меняется
if (tie.mask)
TabCtrl_SetItem(mh_Tabbar, i, &tie);
}
}
// Refresh the tab's title
void TabsOnChangedDoc(WindowInfo *win)
{
if (win->tabs.Count() == 0)
return;
int current = TabCtrl_GetCurSel(win->hwndTabBar);
TabInfo *tdata = win->currentTab;
CrashIf(!tdata);
VerifyTabInfo(win, tdata);
TCITEM tcs;
tcs.mask = TCIF_TEXT;
tcs.pszText = (WCHAR *)tdata->tabTitle;
TabCtrl_SetItem(win->hwndTabBar, current, &tcs);
UpdateCurrentTabBgColor(win);
}
// Refresh the tab's title
void TabsOnChangedDoc(WindowInfo *win)
{
if (TabsGetCount(win) <= 0)
return;
int current = TabCtrl_GetCurSel(win->hwndTabBar);
TabData *tdata = GetTabData(win, current);
CrashIf(!tdata);
SaveTabData(win, tdata);
TCITEM tcs;
tcs.mask = TCIF_TEXT;
tcs.pszText = (WCHAR *)path::GetBaseName(win->loadedFilePath);
TabCtrl_SetItem(win->hwndTabBar, current, &tcs);
UpdateCurrentTabBgColForWindow(win);
}
void Explorerplusplus::SetTabName(int iTab,std::wstring strName,BOOL bUseCustomName)
{
TCITEM tcItem;
tcItem.mask = TCIF_PARAM;
TabCtrl_GetItem(m_hTabCtrl,iTab,&tcItem);
StringCchCopy(m_TabInfo[static_cast<int>(tcItem.lParam)].szName,
SIZEOF_ARRAY(m_TabInfo[static_cast<int>(tcItem.lParam)].szName),strName.c_str());
m_TabInfo[static_cast<int>(tcItem.lParam)].bUseCustomName = bUseCustomName;
TCHAR szName[256];
StringCchCopy(szName,SIZEOF_ARRAY(szName),strName.c_str());
tcItem.mask = TCIF_TEXT;
tcItem.pszText = szName;
TabCtrl_SetItem(m_hTabCtrl,iTab,&tcItem);
}
void UpdateStrings() {
// Update window title
PropSheet_SetTitle(g_cfgwnd, 0, l10n->title);
// Update tab titles
HWND tc = PropSheet_GetTabControl(g_cfgwnd);
int numrows_prev = TabCtrl_GetRowCount(tc);
wchar_t *titles[] = { l10n->tab_general, l10n->tab_input, l10n->tab_blacklist, l10n->tab_advanced, l10n->tab_about };
int i;
for (i=0; i < ARRAY_SIZE(titles); i++) {
TCITEM ti;
ti.mask = TCIF_TEXT;
ti.pszText = titles[i];
TabCtrl_SetItem(tc, i, &ti);
}
// Modify UI if number of rows have changed
int numrows = TabCtrl_GetRowCount(tc);
if (numrows_prev != numrows) {
HWND page = PropSheet_GetCurrentPageHwnd(g_cfgwnd);
if (page != NULL) {
int diffrows = numrows-numrows_prev;
WINDOWPLACEMENT wndpl = { sizeof(WINDOWPLACEMENT) };
// Resize window
GetWindowPlacement(g_cfgwnd, &wndpl);
wndpl.rcNormalPosition.bottom += 18*diffrows;
SetWindowPlacement(g_cfgwnd, &wndpl);
// Resize tabcontrol
GetWindowPlacement(tc, &wndpl);
wndpl.rcNormalPosition.bottom += 18*diffrows;
SetWindowPlacement(tc, &wndpl);
// Move button
HWND button = GetDlgItem(g_cfgwnd, IDOK);
GetWindowPlacement(button, &wndpl);
int height = wndpl.rcNormalPosition.bottom-wndpl.rcNormalPosition.top;
wndpl.rcNormalPosition.top += 18*diffrows;
wndpl.rcNormalPosition.bottom = wndpl.rcNormalPosition.top+height;
SetWindowPlacement(button, &wndpl);
// Re-select tab
PropSheet_SetCurSel(g_cfgwnd, page, 0);
// Invalidate region
GetWindowPlacement(g_cfgwnd, &wndpl);
InvalidateRect(g_cfgwnd, &wndpl.rcNormalPosition, TRUE);
}
}
}
BOOL HexCloseFile(MAINWND *mainWnd, int iItem)
{
TCITEM tci = { TCIF_PARAM };
HWND hwndHV;
TCHAR szFilePath[MAX_PATH];
if(!TabCtrl_GetItem(mainWnd->hwndTabView, iItem, &tci))
return FALSE;
hwndHV = (HWND)tci.lParam;
// is this the last tab left?
if(TabCtrl_GetItemCount(mainWnd->hwndTabView) == 1)
{
HexView_Clear((HWND)tci.lParam);
tci.mask = TCIF_TEXT;
tci.pszText = TEXT("(Untitled)");
TabCtrl_SetItem(mainWnd->hwndTabView, 0, &tci);
tci.lParam = 0;
}
else
{
// remove the tab
TabCtrl_DeleteItem(mainWnd->hwndTabView, iItem);
}
// set focus to a new tab
iItem = TabCtrl_GetCurSel(mainWnd->hwndTabView);
HexSetCurFile(mainWnd->hwndMain, iItem, TRUE);
// lastly destroy the unwanted hexview
SaveHighlights(hwndHV);
HexView_GetFileName(hwndHV, szFilePath, MAX_PATH);
if(hwndHV == (HWND)tci.lParam)
DestroyWindow(hwndHV);
UpdateHighlight(szFilePath, 0, TRUE);
return TRUE;
}
void CContainer::OnRenameTabOk(HWND hDlg)
{
HWND hEditName;
TCITEM tcItem;
UINT uCheckStatus;
TCHAR szTabText[MAX_PATH];
tcItem.mask = TCIF_PARAM;
TabCtrl_GetItem(m_hTabCtrl,g_iTab,&tcItem);
uCheckStatus = IsDlgButtonChecked(hDlg,IDC_RENAMETAB_USEFOLDERNAME);
/* If the button is checked, use the
current folders name as the tab text.
If the button is not checked, use
whatever text is in the edit control. */
if(uCheckStatus == BST_CHECKED)
{
LPITEMIDLIST pidlDirectory = NULL;
pidlDirectory = m_pActiveShellBrowser->QueryCurrentDirectoryIdl();
GetDisplayName(pidlDirectory,szTabText,SHGDN_INFOLDER);
CoTaskMemFree(pidlDirectory);
}
else
{
hEditName = GetDlgItem(hDlg,IDC_RENAMETAB_NEWTABNAME);
GetWindowText(hEditName,szTabText,SIZEOF_ARRAY(szTabText));
}
StringCchCopy(m_TabInfo[(int)tcItem.lParam].szName,
SIZEOF_ARRAY(m_TabInfo[(int)tcItem.lParam].szName),szTabText);
m_TabInfo[(int)tcItem.lParam].bUseCustomName = (uCheckStatus != BST_CHECKED);
tcItem.mask = TCIF_TEXT;
tcItem.pszText = szTabText;
TabCtrl_SetItem(m_hTabCtrl,g_iTab,&tcItem);
EndDialog(hDlg,1);
}
// Must be called when the active tab is losing selection.
// This happens when a new document is loaded or when another tab is selected.
void SaveCurrentTabData(WindowInfo *win)
{
if (!win)
return;
int current = TabCtrl_GetCurSel(win->hwndTabBar);
if (current == -1) {
return;
}
TCITEM tcs;
tcs.mask = TCIF_PARAM;
if (!TabCtrl_GetItem(win->hwndTabBar, current, &tcs)) {
return;
}
// we use the lParam member of the TCITEM structure of the tab, to save the TabData pointer in
PrepareAndSaveTabData(win, (TabData **)&tcs.lParam);
TabCtrl_SetItem(win->hwndTabBar, current, &tcs);
// update the selection history
win->tabSelectionHistory->Remove((TabData *)tcs.lParam);
win->tabSelectionHistory->Push((TabData *)tcs.lParam);
}
void UpdateMainTabs(HWND hwndTabView)
{
int i;
TCITEM tci = { TCIF_PARAM, 0, 0, NULL, 0, 0, 0 };
for(i = 0; TabCtrl_GetItem(hwndTabView, i, &tci); i++)
{
HWND hwndHV = (HWND)tci.lParam;
TCHAR szPath[MAX_PATH];
if(HexView_GetFileName(hwndHV, szPath, MAX_PATH))
{
TCITEM tci2 = {0};
tci.mask = TCIF_PARAM | TCIF_TEXT | TCIF_STATE;
tci.dwState = TCIS_FILENAME;
tci.lParam = (LPARAM)hwndHV;
tci.pszText = (WCHAR *)szPath;//g_szFileTitle;
TabCtrl_SetItem(hwndTabView, i, &tci);
}
}
}
bool SetTabIcon(HWND TabWindow, int Index, HICON Icon)
{
assert(IsWindow(TabWindow));
assert(Index >= 0);
assert(Index < TabCtrl_GetItemCount(TabWindow));
HIMAGELIST ImageList = TabCtrl_GetImageList(TabWindow);
if(!ImageList) // Create a new image list
{
ImageList = ImageList_Create(16, 16, ILC_COLOR32 | ILC_MASK, 0, 1);
TabCtrl_SetImageList(TabWindow, ImageList);
}
TC_ITEM TabData;
TabData.mask = TCIF_IMAGE;
if(TabCtrl_GetItem(TabWindow, Index, &TabData))
{
if(Icon) // Add icon
{
if(TabData.iImage == -1) // There is no icon yet
TabData.iImage = ImageList_AddIcon(ImageList, Icon);
else
TabData.iImage = ImageList_ReplaceIcon(ImageList, TabData.iImage, Icon);
}
else // Remove icon
{
if(TabData.iImage != -1) // Skip if there is no icon
{
TabCtrl_RemoveImage(TabWindow, TabData.iImage);
TabData.iImage = -1;
}
}
return TabCtrl_SetItem(TabWindow, Index, &TabData);
}
return false;
}
void ChatContainer::activateChild(ChatWindow *window) {
RECT rcChild;
getChildWindowRect(&rcChild);
if (window!=NULL) {
SetWindowPos(window->getHWND(), HWND_TOP, rcChild.left, rcChild.top, rcChild.right-rcChild.left, rcChild.bottom - rcChild.top, SWP_NOSIZE);
}
if(window != active) {
ChatWindow *prev = active;
active = window;
SendMessage(hWnd, WM_SIZE, 0, 0);
ShowWindow(active->getHWND(), SW_SHOW);
// SendMessage(active->getHWND(), DM_UPDATETITLE, 0, 0);
if (prev!=NULL) {
ShowWindow(prev->getHWND(), SW_HIDE);
}
SetWindowText(hWnd, window->getRoomName());
}
TCITEM tci;
tci.mask = TCIF_IMAGE;
tci.iImage = -1;
TabCtrl_SetItem(GetDlgItem(hWnd, IDC_TABS), getChildTab(window), &tci);
SendMessage(active->getHWND(), WM_ACTIVATE, WA_ACTIVE, 0);
SetFocus(active->getHWND());
}
BOOL CALLBACK DlgProcParentWindow(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
DWORD ws;
struct ParentWindowData *dat;
dat = (struct ParentWindowData *) GetWindowLong(hwndDlg, GWL_USERDATA);
if (!dat && msg!=WM_INITDIALOG) return FALSE;
switch (msg) {
case WM_INITDIALOG:
{
HMENU hMenu;
HANDLE hSContact;
int savePerContact = DBGetContactSettingByte(NULL, SRMMMOD, SRMSGSET_SAVEPERCONTACT, SRMSGDEFSET_SAVEPERCONTACT);
struct NewMessageWindowLParam *newData = (struct NewMessageWindowLParam *) lParam;
dat = (struct ParentWindowData *) malloc(sizeof(struct ParentWindowData));
dat->foregroundWindow = GetForegroundWindow();
dat->hContact = newData->hContact;
dat->nFlash = 0;
dat->nFlashMax = DBGetContactSettingByte(NULL, SRMMMOD, SRMSGSET_FLASHCOUNT, SRMSGDEFSET_FLASHCOUNT);
dat->childrenCount = 0;
dat->children = NULL;
dat->hwnd = hwndDlg;
dat->flags = g_dat->flags;// | SMF_SHOWTITLEBAR;
dat->mouseLBDown = 0;
dat->windowWasCascaded = 0;
dat->bMinimized = 0;
dat->hwndStatus = CreateWindowEx(0, STATUSCLASSNAME, NULL, WS_CHILD | WS_VISIBLE | SBARS_SIZEGRIP, 0, 0, 0, 0, hwndDlg, NULL, g_hInst, NULL);
{
int statwidths[4];
RECT rc;
SendMessage(dat->hwndStatus, SB_SETMINHEIGHT, GetSystemMetrics(SM_CYSMICON), 0);
GetWindowRect(dat->hwndStatus, &rc);
/*
statwidths[0] = rc.right - rc.left - SB_CHAR_WIDTH - SB_TYPING_WIDTH - SB_SENDING_WIDTH;
statwidths[1] = rc.right - rc.left - SB_TYPING_WIDTH - SB_SENDING_WIDTH; //rc.right - rc.left - SB_CHAR_WIDTH;
statwidths[2] = rc.right - rc.left - SB_TYPING_WIDTH; //rc.right - rc.left - SB_CHAR_WIDTH;
statwidths[3] = -1;
SendMessage(dat->hwndStatus, SB_SETPARTS, 4, (LPARAM) statwidths);
*/
statwidths[0] = rc.right - rc.left - SB_CHAR_WIDTH - SB_TYPING_WIDTH;
statwidths[1] = rc.right - rc.left - SB_TYPING_WIDTH;
statwidths[2] = -1;
SendMessage(dat->hwndStatus, SB_SETPARTS, 3, (LPARAM) statwidths);
}
dat->hwndTabs = GetDlgItem(hwndDlg, IDC_TABS);
dat->hwndActive = NULL;
SetWindowLong(hwndDlg, GWL_USERDATA, (LONG) dat);
if (g_dat->hIconList != NULL) {
TabCtrl_SetImageList(dat->hwndTabs, g_dat->hIconList);
}
WindowList_Add(g_dat->hParentWindowList, hwndDlg, 0);
dat->tabCtrlDat = (struct TabCtrlData *) malloc(sizeof(struct TabCtrlData));
dat->tabCtrlDat->bDragging = FALSE;
SetWindowLong(dat->hwndTabs, GWL_USERDATA, (LONG) dat->tabCtrlDat);
OldTabCtrlProc = (WNDPROC) SetWindowLong(dat->hwndTabs, GWL_WNDPROC, (LONG) TabCtrlProc);
ws = GetWindowLong(dat->hwndTabs, GWL_STYLE) & ~(TCS_BOTTOM);
if (dat->flags & SMF_TABSATBOTTOM) {
ws |= TCS_BOTTOM;
}
SetWindowLong(dat->hwndTabs, GWL_STYLE, ws);
ws = GetWindowLong(hwndDlg, GWL_STYLE) & ~(WS_CAPTION);
if (dat->flags & SMF_SHOWTITLEBAR) {
ws |= WS_CAPTION;
SetWindowLong(hwndDlg, GWL_STYLE, ws);
} else {
RECT rc;
SetWindowLong(hwndDlg, GWL_STYLE, ws);
GetWindowRect(hwndDlg, &rc);
SetWindowPos(hwndDlg, 0, 0, 0, rc.right - rc.left, rc.bottom - rc.top,
SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER | SWP_FRAMECHANGED | SWP_NOSENDCHANGING);
}
ws = GetWindowLong(hwndDlg, GWL_EXSTYLE) & ~WS_EX_LAYERED;
ws |= dat->flags & SMF_USETRANSPARENCY ? WS_EX_LAYERED : 0;
SetWindowLong(hwndDlg , GWL_EXSTYLE , ws);
if (dat->flags & SMF_USETRANSPARENCY) {
pSetLayeredWindowAttributes(hwndDlg, RGB(255,255,255), (BYTE)(255-g_dat->inactiveAlpha), LWA_ALPHA);
// RedrawWindow(hwndDlg, NULL, NULL, RDW_ERASE | RDW_INVALIDATE | RDW_FRAME | RDW_ALLCHILDREN);
}
if (!(dat->flags & SMF_SHOWSTATUSBAR)) {
ShowWindow(dat->hwndStatus, SW_HIDE);
}
hSContact = !(dat->flags & SMF_USETABS) && savePerContact ? dat->hContact : NULL;
dat->bTopmost = DBGetContactSettingByte(hSContact, SRMMMOD, SRMSGSET_TOPMOST, SRMSGDEFSET_TOPMOST);
if (ScriverRestoreWindowPosition(hwndDlg, hSContact, SRMMMOD, "", 0, SW_HIDE)) {
if (ScriverRestoreWindowPosition(hwndDlg, hSContact, SRMMMOD, "", RWPF_NOSIZE, SW_HIDE)) {
SetWindowPos(GetParent(hwndDlg), 0, 0, 0, 450, 300, SWP_NOZORDER | SWP_HIDEWINDOW);
} else {
SetWindowPos(hwndDlg, 0, 0, 0, 450, 300, SWP_NOZORDER | SWP_NOMOVE | SWP_HIDEWINDOW);
}
}
if (!(dat->flags & SMF_USETABS)) {
if (!savePerContact && DBGetContactSettingByte(NULL, SRMMMOD, SRMSGSET_CASCADE, SRMSGDEFSET_CASCADE))
WindowList_Broadcast(g_dat->hParentWindowList, DM_CASCADENEWWINDOW, (WPARAM) hwndDlg, (LPARAM) & dat->windowWasCascaded);
}
hMenu = GetSystemMenu( hwndDlg, FALSE );
AppendMenu( hMenu, MF_SEPARATOR, 0, NULL );
if (dat->bTopmost) {
AppendMenu( hMenu, MF_ENABLED | MF_CHECKED | MF_STRING, IDM_TOPMOST, TranslateT("Always On Top"));
SetWindowPos(hwndDlg, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
} else {
AppendMenu( hMenu, MF_ENABLED | MF_UNCHECKED | MF_STRING, IDM_TOPMOST, TranslateT("Always On Top"));
}
}
return TRUE;
case WM_GETMINMAXINFO:
{
MINMAXINFO *mmi = (MINMAXINFO *) lParam;
SIZE size;
if (GetKeyState(VK_CONTROL) & 0x8000) {
WINDOWPLACEMENT wp;
RECT rcDesktop;
wp.length = sizeof(wp);
GetWindowPlacement(hwndDlg, &wp);
SystemParametersInfo(SPI_GETWORKAREA, 0, &rcDesktop, 0);
mmi->ptMaxSize.x = wp.rcNormalPosition.right - wp.rcNormalPosition.left;
mmi->ptMaxSize.y = rcDesktop.bottom - rcDesktop.top;
mmi->ptMaxPosition.x = wp.rcNormalPosition.left;
if(IsIconic(hwndDlg)) {
mmi->ptMaxPosition.y = rcDesktop.top;
} else {
mmi->ptMaxPosition.y = 0;
}
}
GetMinimunWindowSize(dat, &size);
mmi->ptMinTrackSize.x = size.cx;
mmi->ptMinTrackSize.y = size.cy;
return FALSE;
}
case WM_SIZE:
if (wParam == SIZE_MINIMIZED) {
dat->bMinimized = 1;
}
if (IsIconic(hwndDlg)) {
MoveWindow(dat->hwndActive, dat->childRect.left, dat->childRect.top, dat->childRect.right-dat->childRect.left, dat->childRect.bottom - dat->childRect.top, TRUE);
} else {
// }
// if (!IsIconic(hwndDlg)) {
int i;
RECT rc, rcStatus, rcChild, rcWindow;
SIZE size;
dat->bMinimized = 0;
GetClientRect(hwndDlg, &rc);
GetWindowRect(hwndDlg, &rcWindow);
rcStatus.top = rcStatus.bottom = 0;
if (dat->flags & SMF_SHOWSTATUSBAR) {
int statwidths[4];
GetWindowRect(dat->hwndStatus, &rcStatus);
statwidths[0] = rc.right - rc.left - SB_CHAR_WIDTH - SB_TYPING_WIDTH;
statwidths[1] = rc.right - rc.left - SB_TYPING_WIDTH;
statwidths[2] = -1;
SendMessage(dat->hwndStatus, SB_SETPARTS, 3, (LPARAM) statwidths);
SendMessage(dat->hwndStatus, WM_SIZE, 0, 0);
}
MoveWindow(dat->hwndTabs, 0, 2, (rc.right - rc.left), (rc.bottom - rc.top) - (rcStatus.bottom - rcStatus.top) - 2, FALSE);
RedrawWindow(dat->hwndTabs, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE);
GetMinimunWindowSize(dat, &size);
if ((rcWindow.bottom-rcWindow.top) < size.cy || (rcWindow.right-rcWindow.left) < size.cx) {
if ((rcWindow.bottom-rcWindow.top) < size.cy) {
rcWindow.bottom = rcWindow.top + size.cy;
}
if ((rcWindow.right-rcWindow.left) < size.cx) {
rcWindow.right = rcWindow.left + size.cx;
}
MoveWindow(hwndDlg, rcWindow.left, rcWindow.top, rcWindow.right - rcWindow.left, rcWindow.bottom - rcWindow.top, TRUE);
}
GetChildWindowRect(dat, &rcChild);
memcpy(&dat->childRect, &rcChild, sizeof(RECT));
for (i=0;i<dat->childrenCount;i++) {
if (dat->children[i] == dat->hwndActive) {
MoveWindow(dat->children[i], rcChild.left, rcChild.top, rcChild.right-rcChild.left, rcChild.bottom - rcChild.top, TRUE);
RedrawWindow(GetDlgItem(dat->children[i], IDC_LOG), NULL, NULL, RDW_INVALIDATE);
}
}
if (dat->flags & SMF_SHOWSTATUSBAR) {
RedrawWindow(dat->hwndStatus, NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASE);
}
}
return FALSE;
case WM_SETFOCUS:
if (dat->hwndActive != NULL) {
SetFocus(dat->hwndActive);
}
return TRUE;
case WM_CLOSE:
DestroyWindow(hwndDlg);
return TRUE;
case WM_COMMAND:
switch (LOWORD(wParam)) {
case IDCANCEL:
//DestroyWindow(hwndDlg);
return TRUE;
}
case WM_NOTIFY:
{
NMHDR* pNMHDR = (NMHDR*) lParam;
if (pNMHDR->hwndFrom == dat->hwndTabs) {
switch (pNMHDR->code) {
case TCN_SELCHANGE:
{
TCITEM tci = {0};
int iSel = TabCtrl_GetCurSel(dat->hwndTabs);
tci.mask = TCIF_PARAM;
if (TabCtrl_GetItem(dat->hwndTabs, iSel, &tci)) {
struct MessageWindowData * mdat = (struct MessageWindowData *) tci.lParam;
ActivateChild(dat, mdat->hwnd);
SetFocus(dat->hwndActive);
}
}
break;
case NM_RCLICK:
{
TCHITTESTINFO thinfo;
int tabId, x, y;
GetCursorPos(&thinfo.pt);
x = thinfo.pt.x;
y = thinfo.pt.y;
ScreenToClient(dat->hwndTabs, &thinfo.pt);
tabId = TabCtrl_HitTest(dat->hwndTabs, &thinfo);
if (tabId != -1) {
struct MessageWindowData * mwd = GetChildFromTab(dat->hwndTabs, tabId);
//CallService(MS_USERINFO_SHOWDIALOG, (WPARAM) mwd->hContact, 0);
HMENU hMenu = (HMENU) CallService(MS_CLIST_MENUBUILDCONTACT, (WPARAM) mwd->hContact, 0);
TrackPopupMenu(hMenu, 0, x, y, 0, mwd->hwnd, NULL);
DestroyMenu(hMenu);
}
}
break;
}
} else if (pNMHDR->hwndFrom == dat->hwndStatus) {
switch (pNMHDR->code) {
case NM_CLICK:
{
NMMOUSE *nm=(NMMOUSE*)lParam;
RECT rc;
SendMessage(dat->hwndStatus, SB_GETRECT, SendMessage(dat->hwndStatus, SB_GETPARTS, 0, 0) - 1, (LPARAM)&rc);
if (nm->pt.x >= rc.left)
SendMessage(dat->hwndActive, DM_SWITCHUNICODE, 0, 0);
}
}
break;
}
}
break;
case WM_DROPFILES:
SendMessage(dat->hwndActive, WM_DROPFILES, wParam, lParam);
break;
case WM_TIMER:
if (wParam == TIMERID_FLASHWND) {
if ((dat->nFlash > dat->nFlashMax)) {// || ((GetActiveWindow() == hwndDlg) && (GetForegroundWindow() == hwndDlg))) {
KillTimer(hwndDlg, TIMERID_FLASHWND);
FlashWindow(hwndDlg, FALSE);
} else if (dat->nFlash < dat->nFlashMax) {
FlashWindow(hwndDlg, TRUE);
dat->nFlash++;
}
}
break;
case WM_CONTEXTMENU:
{
if (dat->hwndStatus && dat->hwndStatus == (HWND) wParam) {
RECT rc;
POINT pt, pt2;
GetCursorPos(&pt);
pt2.x = pt.x;
pt2.y = pt.y;
ScreenToClient(dat->hwndStatus, &pt);
SendMessage(dat->hwndStatus, SB_GETRECT, SendMessage(dat->hwndStatus, SB_GETPARTS, 0, 0) - 1, (LPARAM)&rc);
if (pt.x >= rc.left && dat->hwndActive != NULL) {
int codePage = (int) SendMessage(dat->hwndActive, DM_GETCODEPAGE, 0, 0);
int i, iSel;
for(i = 0; i < GetMenuItemCount(g_dat->hMenuANSIEncoding); i++) {
CheckMenuItem (g_dat->hMenuANSIEncoding, i, MF_BYPOSITION | MF_UNCHECKED);
}
if(codePage == CP_ACP) {
CheckMenuItem(g_dat->hMenuANSIEncoding, 0, MF_BYPOSITION | MF_CHECKED);
} else {
CheckMenuItem(g_dat->hMenuANSIEncoding, codePage, MF_BYCOMMAND | MF_CHECKED);
}
iSel = TrackPopupMenu(g_dat->hMenuANSIEncoding, TPM_RETURNCMD, pt2.x, pt2.y, 0, hwndDlg, NULL);
if (iSel >= 500) {
if (iSel == 500) iSel = CP_ACP;
SendMessage(dat->hwndActive, DM_SETCODEPAGE, 0, iSel);
}
}
else
SendMessage(dat->hwndActive, WM_CONTEXTMENU, (WPARAM)hwndDlg, 0);
}
break;
}
case WM_ACTIVATE:
if (LOWORD(wParam) == WA_INACTIVE) {
ws = GetWindowLong(hwndDlg, GWL_EXSTYLE) & ~WS_EX_LAYERED;
ws |= dat->flags & SMF_USETRANSPARENCY ? WS_EX_LAYERED : 0;
SetWindowLong(hwndDlg , GWL_EXSTYLE , ws);
if (dat->flags & SMF_USETRANSPARENCY) {
pSetLayeredWindowAttributes(hwndDlg, RGB(255,255,255), (BYTE)(255-g_dat->inactiveAlpha), LWA_ALPHA);
// RedrawWindow(hwndDlg, NULL, NULL, RDW_ERASE | RDW_INVALIDATE | RDW_FRAME | RDW_ALLCHILDREN);
}
}
if (LOWORD(wParam) != WA_ACTIVE)
break;
if (dat->hwndActive == NULL) { // do not set foreground window at all (always stay in the background !)
// SendMessage(hwndDlg, DM_DEACTIVATE, 0, 0);
} else {
PostMessage(hwndDlg, WM_SETFOCUS, 0, 0);
}
case WM_MOUSEACTIVATE:
if (KillTimer(hwndDlg, TIMERID_FLASHWND)) {
FlashWindow(hwndDlg, FALSE);
dat->nFlash = 0;
}
ws = GetWindowLong(hwndDlg, GWL_EXSTYLE) & ~WS_EX_LAYERED;
ws |= dat->flags & SMF_USETRANSPARENCY ? WS_EX_LAYERED : 0;
SetWindowLong(hwndDlg , GWL_EXSTYLE , ws);
if (dat->flags & SMF_USETRANSPARENCY) {
pSetLayeredWindowAttributes(hwndDlg, RGB(255,255,255), (BYTE)(255-g_dat->activeAlpha), LWA_ALPHA);
// RedrawWindow(hwndDlg, NULL, NULL, RDW_ERASE | RDW_INVALIDATE | RDW_FRAME | RDW_ALLCHILDREN);
}
break;
case WM_LBUTTONDOWN:
if (!IsZoomed(hwndDlg)) {
POINT pt;
GetCursorPos(&pt);
// dat->mouseLBDown = 1;
// GetCursorPos(&dat->mouseLBDownPos);
return SendMessage(hwndDlg, WM_SYSCOMMAND, SC_MOVE | HTCAPTION, MAKELPARAM(pt.x, pt.y));
// SetCapture(hwndDlg);
}
break;
case WM_LBUTTONUP:
//if (dat->mouseLBDown) {
// dat->mouseLBDown = 0;
// ReleaseCapture();
//}
break;
case WM_MOUSEMOVE:/*
if (dat->mouseLBDown) {
POINT pt;
RECT rc;
GetCursorPos(&pt);
GetWindowRect(hwndDlg, &rc);
SetWindowPos(hwndDlg, 0, rc.left - (dat->mouseLBDownPos.x - pt.x), rc.top - (dat->mouseLBDownPos.y - pt.y), 0, 0, SWP_NOZORDER | SWP_NOSIZE);
dat->mouseLBDownPos = pt;
}*/
break;
case WM_MOVING:
{
int snapPixels = 10;
RECT rcDesktop;
RECT *pRect = (RECT *)lParam;
POINT pt;
SIZE szSize = {pRect->right-pRect->left,pRect->bottom-pRect->top};
GetCursorPos(&pt);
SystemParametersInfo(SPI_GETWORKAREA, 0, &rcDesktop, 0);
pRect->left = pt.x-dat->mouseLBDownPos.x;
pRect->top = pt.y-dat->mouseLBDownPos.y;
pRect->right = pRect->left+szSize.cx;
pRect->bottom = pRect->top+szSize.cy;
if (!(GetAsyncKeyState(VK_CONTROL) & 0x8000)) {
if(pRect->top < snapPixels && pRect->top > -snapPixels) {
pRect->top = 0;
pRect->bottom = szSize.cy;
}
if(pRect->left < snapPixels && pRect->left > -snapPixels) {
pRect->left = 0;
pRect->right = szSize.cx;
}
if(pRect->right < rcDesktop.right+snapPixels && pRect->right > rcDesktop.right-snapPixels) {
pRect->right = rcDesktop.right;
pRect->left = rcDesktop.right-szSize.cx;
}
if(pRect->bottom < rcDesktop.bottom+snapPixels && pRect->bottom > rcDesktop.bottom-snapPixels) {
pRect->bottom = rcDesktop.bottom;
pRect->top = rcDesktop.bottom-szSize.cy;
}
}
}
break;
case WM_SYSCOMMAND:
if ((wParam & 0xFFF0) == SC_MOVE) {
RECT rc;
GetWindowRect(hwndDlg, &rc);
dat->mouseLBDownPos.x = LOWORD(lParam) - rc.left;
dat->mouseLBDownPos.y = HIWORD(lParam) - rc.top;
} else if (wParam == IDM_TOPMOST) {
HMENU hMenu = GetSystemMenu(hwndDlg, FALSE);
if (dat->bTopmost) {
CheckMenuItem(hMenu, IDM_TOPMOST, MF_BYCOMMAND | MF_UNCHECKED);
SetWindowPos(hwndDlg, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
dat->bTopmost = FALSE;
}
else {
CheckMenuItem(hMenu, IDM_TOPMOST, MF_BYCOMMAND | MF_CHECKED);
SetWindowPos(hwndDlg, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
dat->bTopmost = TRUE;
}
}
break;
case WM_DESTROY:
{
WINDOWPLACEMENT wp = { 0 };
HANDLE hContact;
g_dat->hParent = NULL;
SetWindowLong(hwndDlg, GWL_USERDATA, 0);
WindowList_Remove(g_dat->hParentWindowList, hwndDlg);
if (dat->children!=NULL) free (dat->children);
free(dat->tabCtrlDat);
free(dat);
if (!(dat->flags & SMF_USETABS) && DBGetContactSettingByte(NULL, SRMMMOD, SRMSGSET_SAVEPERCONTACT, SRMSGDEFSET_SAVEPERCONTACT))
hContact = dat->hContact;
else
hContact = NULL;
wp.length = sizeof(wp);
GetWindowPlacement(hwndDlg, &wp);
if (!dat->windowWasCascaded) {
DBWriteContactSettingDword(hContact, SRMMMOD, "x", wp.rcNormalPosition.left);
DBWriteContactSettingDword(hContact, SRMMMOD, "y", wp.rcNormalPosition.top);
}
DBWriteContactSettingDword(hContact, SRMMMOD, "width", wp.rcNormalPosition.right - wp.rcNormalPosition.left);
DBWriteContactSettingDword(hContact, SRMMMOD, "height", wp.rcNormalPosition.bottom - wp.rcNormalPosition.top);
DBWriteContactSettingByte(hContact, SRMMMOD, SRMSGSET_TOPMOST, (BYTE)dat->bTopmost);
}
break;
case DM_DEACTIVATE:
SetForegroundWindow(dat->foregroundWindow);
break;
case DM_ERRORDECIDED:
break;
case DM_STARTFLASHING:
if (GetActiveWindow() != hwndDlg || GetForegroundWindow() != hwndDlg) {
dat->nFlash = 0;
SetTimer(hwndDlg, TIMERID_FLASHWND, TIMEOUT_FLASHWND, NULL);
}
break;
case DM_REMOVECHILD:
{
RemoveChild(dat, (HWND) lParam);
if (dat->childrenCount != 0) {
SetFocus(dat->hwndActive);
} else {
DestroyWindow(hwndDlg);
}
}
return TRUE;
case DM_ADDCHILD:
{
struct MessageWindowData * mdat = (struct MessageWindowData *) lParam;
AddChild(dat, mdat);
}
return TRUE;
case DM_ACTIVATECHILD:
// if((HWND) lParam != dat->hwndActive) {
ActivateChild(dat, (HWND) lParam);
// }
return TRUE;
case DM_ACTIVATEPREV:
ActivatePrevChild(dat, (HWND) lParam);
SetFocus(dat->hwndActive);
return TRUE;
case DM_ACTIVATENEXT:
ActivateNextChild(dat, (HWND) lParam);
SetFocus(dat->hwndActive);
return TRUE;
case DM_SENDMESSAGE:
{
int i;
for (i=0;i<dat->childrenCount;i++) {
SendMessage(dat->children[i], DM_SENDMESSAGE, wParam, lParam);
}
}
break;
case DM_OPTIONSAPPLIED:
{
RECT rc;
dat->flags = g_dat->flags;
if (!(dat->flags & SMF_SHOWSTATUSBAR)) {
ShowWindow(dat->hwndStatus, SW_HIDE);
} else {
ShowWindow(dat->hwndStatus, SW_SHOW);
}
ws = GetWindowLong(hwndDlg, GWL_STYLE) & ~(WS_CAPTION);
if (dat->flags & SMF_SHOWTITLEBAR) {
ws |= WS_CAPTION;
}
SetWindowLong(hwndDlg, GWL_STYLE, ws);
ws = GetWindowLong(hwndDlg, GWL_EXSTYLE)& ~WS_EX_LAYERED;
ws |= dat->flags & SMF_USETRANSPARENCY ? WS_EX_LAYERED : 0;
SetWindowLong(hwndDlg , GWL_EXSTYLE , ws);
if (dat->flags & SMF_USETRANSPARENCY) {
pSetLayeredWindowAttributes(hwndDlg, RGB(255,255,255), (BYTE)(255-g_dat->inactiveAlpha), LWA_ALPHA);
// RedrawWindow(hwndDlg, NULL, NULL, RDW_ERASE | RDW_INVALIDATE | RDW_FRAME | RDW_ALLCHILDREN);
}
ws = GetWindowLong(dat->hwndTabs, GWL_STYLE) & ~(TCS_BOTTOM);
if (dat->flags & SMF_TABSATBOTTOM) {
ws |= TCS_BOTTOM;
}
SetWindowLong(dat->hwndTabs, GWL_STYLE, ws);
RedrawWindow(dat->hwndTabs, NULL, NULL, RDW_INVALIDATE);
GetWindowRect(hwndDlg, &rc);
SetWindowPos(hwndDlg, 0, 0, 0, rc.right - rc.left, rc.bottom - rc.top,
SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER | SWP_FRAMECHANGED | SWP_NOSENDCHANGING);
SendMessage(hwndDlg, WM_SIZE, 0, 0);
//RedrawWindow(hwndDlg, NULL, NULL, RDW_ERASE | RDW_INVALIDATE | RDW_FRAME | RDW_ALLCHILDREN);
break;
}
case DM_UPDATETITLE:
{
struct MessageWindowData * mdat = (struct MessageWindowData *) lParam;
TCITEM tci;
int tabId;
TCHAR *tContactName;
if (mdat && mdat->hwnd == dat->hwndActive) {
TCHAR *newtitle, oldtitle[256];
#if defined ( _UNICODE )
newtitle = GetWindowTitle(mdat->hContact, mdat->szProto);
#else
newtitle = GetWindowTitle(mdat->hContact, mdat->szProto);
#endif
GetWindowText(hwndDlg, oldtitle, sizeof(oldtitle));
if (lstrcmp(newtitle, oldtitle)) { //swt() flickers even if the title hasn't actually changed
SetWindowText(hwndDlg, newtitle);
//SendMessage(hwndDlg, WM_SIZE, 0, 0);
}
free(newtitle);
}
tabId = GetTabFromHWND(dat, mdat->hwnd);
tContactName = GetTabName(mdat->hContact);
tci.mask = TCIF_TEXT;
tci.pszText = tContactName;
TabCtrl_SetItem(dat->hwndTabs, tabId, &tci);
free(tContactName);
break;
}
case DM_UPDATEWINICON:
{
struct MessageWindowData * mdat = (struct MessageWindowData *) lParam;
if (mdat) {
if (mdat->szProto) {
int i, icoIdx = 0;
WORD wStatus;
char *szProto = mdat->szProto;
HANDLE hContact = mdat->hContact;
if (strcmp(mdat->szProto, "MetaContacts") == 0 && DBGetContactSettingByte(NULL,"CLC","Meta",0) == 0) {
hContact = (HANDLE)CallService(MS_MC_GETMOSTONLINECONTACT,(UINT)mdat->hContact, 0);
if (hContact != NULL) {
szProto = (char*)CallService(MS_PROTO_GETCONTACTBASEPROTO,(UINT)hContact,0);
} else {
hContact = mdat->hContact;
}
}
wStatus = DBGetContactSettingWord(hContact, szProto, "Status", ID_STATUS_OFFLINE);
mdat->wStatus = wStatus;
if (mdat->hwnd == dat->hwndActive) {
if (DBGetContactSettingByte(NULL, SRMMMOD, SRMSGSET_STATUSICON, SRMSGDEFSET_STATUSICON)) {
if (mdat->showTyping && (g_dat->flags&SMF_SHOWTYPINGWIN)) {
SendMessage(hwndDlg, WM_SETICON, (WPARAM) ICON_BIG, (LPARAM) g_dat->hIcons[SMF_ICON_TYPING]);
} else if (mdat->showUnread && (GetActiveWindow() != hwndDlg || GetForegroundWindow() != hwndDlg)) {
SendMessage(hwndDlg, WM_SETICON, (WPARAM) ICON_BIG, (LPARAM) LoadSkinnedIcon(SKINICON_EVENT_MESSAGE));
} else {
SendMessage(hwndDlg, WM_SETICON, (WPARAM) ICON_BIG, (LPARAM) LoadSkinnedProtoIcon(szProto, wStatus));
}
} else {
SendMessage(hwndDlg, WM_SETICON, (WPARAM) ICON_BIG, (LPARAM) LoadSkinnedIcon(SKINICON_EVENT_MESSAGE));
}
}
SendDlgItemMessage(mdat->hwnd, IDC_USERMENU, BM_SETIMAGE, IMAGE_ICON, (LPARAM) LoadSkinnedProtoIcon(szProto, wStatus));
icoIdx = 0;
for (i = 0; i < g_dat->protoNum; i++) {
if (!strcmp(g_dat->protoNames[i], szProto)) {
icoIdx = wStatus - ID_STATUS_OFFLINE + (ID_STATUS_OUTTOLUNCH - ID_STATUS_OFFLINE + 1) * (i +1) + 2;
break;
}
}
if (mdat->hwnd != dat->hwndActive) {
if (mdat->showTyping) {
icoIdx = 1;
} else if (mdat->showUnread & 1) {
icoIdx = 0;
}
}
i = GetTabFromHWND(dat, mdat->hwnd);
if (i>=0) {
TCITEM tci;
tci.mask = TCIF_IMAGE;
tci.iImage = icoIdx;
TabCtrl_SetItem(dat->hwndTabs, i, &tci);
}
}
}
break;
}
case DM_UPDATESTATUSBAR:
break;
case DM_SWITCHSTATUSBAR:
dat->flags ^= SMF_SHOWSTATUSBAR;
if (!(dat->flags & SMF_SHOWSTATUSBAR)) {
ShowWindow(dat->hwndStatus, SW_HIDE);
} else {
ShowWindow(dat->hwndStatus, SW_SHOW);
}
SendMessage(hwndDlg, WM_SIZE, 0, 0);
break;
case DM_SWITCHTOOLBAR:
{
int i;
dat->flags ^= SMF_SHOWBTNS;
for (i=0;i<dat->childrenCount;i++) {
SendMessage(dat->children[i], DM_SWITCHTOOLBAR, 0, 0);
}
SendMessage(hwndDlg, WM_SIZE, 0, 0);
}
break;
case DM_SWITCHTITLEBAR:
{
RECT rc;
dat->flags ^= SMF_SHOWTITLEBAR;
ws = GetWindowLong(hwndDlg, GWL_STYLE) & ~(WS_CAPTION);
if (dat->flags & SMF_SHOWTITLEBAR) {
ws |= WS_CAPTION;
}
SetWindowLong(hwndDlg, GWL_STYLE, ws);
GetWindowRect(hwndDlg, &rc);
SetWindowPos(hwndDlg, 0, 0, 0, rc.right - rc.left, rc.bottom - rc.top,
SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER | SWP_FRAMECHANGED | SWP_NOSENDCHANGING);
// SendMessage(hwndDlg, WM_SIZE, 0, 0);
RedrawWindow(hwndDlg, NULL, NULL, RDW_ERASE | RDW_FRAME | RDW_INVALIDATE | RDW_ALLCHILDREN);
}
break;
case DM_CASCADENEWWINDOW:
if ((HWND) wParam == hwndDlg)
break;
{
RECT rcThis, rcNew;
GetWindowRect(hwndDlg, &rcThis);
GetWindowRect((HWND) wParam, &rcNew);
if (abs(rcThis.left - rcNew.left) < 3 && abs(rcThis.top - rcNew.top) < 3) {
int offset = GetSystemMetrics(SM_CYCAPTION) + GetSystemMetrics(SM_CYFRAME);
SetWindowPos((HWND) wParam, 0, rcNew.left + offset, rcNew.top + offset, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
*(int *) lParam = 1;
}
}
break;
//case DM_MESSAGESENDING:
// dat->messagesInProgress += wParam ? -1 : 1;
// if (dat->messagesInProgress < 0) dat->messagesInProgress = 0;
// break;
}
return FALSE;
}
