static HTREEITEM AddTocItemToView(HWND hwnd, DocTocItem *entry, HTREEITEM parent, bool toggleItem)
{
TV_INSERTSTRUCT tvinsert;
tvinsert.hParent = parent;
tvinsert.hInsertAfter = TVI_LAST;
tvinsert.itemex.mask = TVIF_TEXT | TVIF_PARAM | TVIF_STATE;
tvinsert.itemex.state = entry->child && entry->open != toggleItem ? TVIS_EXPANDED : 0;
tvinsert.itemex.stateMask = TVIS_EXPANDED;
tvinsert.itemex.lParam = (LPARAM)entry;
// Replace unprintable whitespace with regular spaces
str::NormalizeWS(entry->title);
tvinsert.itemex.pszText = entry->title;
#ifdef DISPLAY_TOC_PAGE_NUMBERS
WindowInfo *win = FindWindowInfoByHwnd(hwnd);
if (entry->pageNo && win && win->IsDocLoaded() && !win->AsEbook()) {
ScopedMem<WCHAR> label(win->ctrl->GetPageLabel(entry->pageNo));
ScopedMem<WCHAR> text(str::Format(L"%s %s", entry->title, label));
tvinsert.itemex.pszText = text;
return TreeView_InsertItem(hwnd, &tvinsert);
}
#endif
return TreeView_InsertItem(hwnd, &tvinsert);
}
void
FileTransfer::ShowTreeViewItems(HWND hwnd, LPNMTREEVIEW m_lParam)
{
HANDLE m_handle;
WIN32_FIND_DATA m_FindFileData;
TVITEM tvi;
TVINSERTSTRUCT tvins;
char path[rfbMAX_PATH];
GetTVPath(GetDlgItem(hwnd, IDC_FTBROWSETREE), m_lParam->itemNew.hItem, path);
strcat(path, "\\*");
while (TreeView_GetChild(GetDlgItem(hwnd, IDC_FTBROWSETREE), m_lParam->itemNew.hItem) != NULL) {
TreeView_DeleteItem(GetDlgItem(hwnd, IDC_FTBROWSETREE), TreeView_GetChild(GetDlgItem(hwnd, IDC_FTBROWSETREE), m_lParam->itemNew.hItem));
}
SetErrorMode(SEM_FAILCRITICALERRORS);
m_handle = FindFirstFile(path, &m_FindFileData);
SetErrorMode(0);
if (m_handle == INVALID_HANDLE_VALUE) return;
while(1) {
if ((strcmp(m_FindFileData.cFileName, ".") != 0) &&
(strcmp(m_FindFileData.cFileName, "..") != 0)) {
if (m_FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
tvi.mask = TVIF_TEXT;
tvi.pszText = m_FindFileData.cFileName;
tvins.hParent = m_lParam->itemNew.hItem;
tvins.item = tvi;
tvins.hParent = TreeView_InsertItem(GetDlgItem(hwnd, IDC_FTBROWSETREE), &tvins);
TreeView_InsertItem(GetDlgItem(hwnd, IDC_FTBROWSETREE), &tvins);
}
}
if (!FindNextFile(m_handle, &m_FindFileData)) break;
}
FindClose(m_handle);
}
int FillSettingsBox(HWND htree,const char *szModule)
{
DBCONTACTENUMSETTINGS dbces;
HANDOVER hndvr;
HANDLE hcontact;
TVINSERTSTRUCT tvis;
HTREEITEM htvi;
char *pszContact;
hndvr.htree=htree;
hndvr.valid=0;
dbces.lParam=(LPARAM)&hndvr;
dbces.pfnEnumProc=EnumSettings;
dbces.szModule=szModule;
hcontact=(HANDLE)CallService(MS_DB_CONTACT_FINDFIRST,0,0);
while(hcontact!=NULL)
{
pszContact=strdup((const char *)CallService(MS_CLIST_GETCONTACTDISPLAYNAME,(WPARAM)hcontact,0));
tvis.hParent=TVI_ROOT;
tvis.hInsertAfter=TVI_SORT;
tvis.item.mask=TVIF_TEXT|TVIF_PARAM;
tvis.item.pszText=pszContact;
tvis.item.cchTextMax=strlen(pszContact);
tvis.item.lParam=(LPARAM)hcontact;
htvi=TreeView_InsertItem(htree,&tvis);
hndvr.htvi=htvi;
if(CallService(MS_DB_CONTACT_ENUMSETTINGS,(WPARAM)hcontact,(LPARAM)&dbces)==-1)
TreeView_DeleteItem(htree,htvi);
hcontact=(HANDLE)CallService(MS_DB_CONTACT_FINDNEXT,(WPARAM)hcontact,0);
}
hcontact=NULL;
pszContact=Translate("Main contact");
tvis.hParent=TVI_ROOT;
tvis.hInsertAfter=TVI_FIRST;
tvis.item.mask=TVIF_TEXT|TVIF_PARAM;
tvis.item.pszText=pszContact;
tvis.item.cchTextMax=strlen(pszContact);
tvis.item.lParam=(LPARAM)NULL;
htvi=TreeView_InsertItem(htree,&tvis);
hndvr.htvi=htvi;
if(CallService(MS_DB_CONTACT_ENUMSETTINGS,(WPARAM)hcontact,(LPARAM)&dbces)==-1)
TreeView_DeleteItem(htree,htvi);
return hndvr.valid;
}
static BOOL
LoadSystemIni(WCHAR * szPath, HWND hDlg)
{
WCHAR szBuffer[BUFFER_SIZE];
HWND hDlgCtrl;
HTREEITEM parent = NULL;
FILE* file;
UINT length;
TVINSERTSTRUCT insert;
wcscpy(szBuffer, szPath);
wcscat(szBuffer, L"\\system.ini");
file = _wfopen(szBuffer, L"rt");
if (!file)
return FALSE;
hDlgCtrl = GetDlgItem(hDlg, IDC_SYSTEM_TREE);
while(!feof(file))
{
if (fgetws(szBuffer, BUFFER_SIZE, file))
{
length = wcslen(szBuffer);
if (length > 1)
{
szBuffer[length] = L'\0';
szBuffer[length - 1] = L'\0';
insert.hInsertAfter = TVI_LAST;
insert.item.mask = TVIF_TEXT;
insert.item.pszText = szBuffer;
if (szBuffer[0] == L';' || szBuffer[0] == L'[')
{
/* Parent */
insert.hParent = NULL;
parent = TreeView_InsertItem(hDlgCtrl, &insert);
}
else
{
/* Child */
insert.hParent = parent;
TreeView_InsertItem(hDlgCtrl, &insert);
}
}
}
}
fclose(file);
return TRUE;
}
void PopulateProtocolList(HWND hWnd)
{
bool useOne = IsDlgButtonChecked(hWnd, IDC_USEBYPROTOCOL) == BST_UNCHECKED;
HWND hLstView = GetDlgItem(hWnd, IDC_PROTOLIST);
TreeView_DeleteAllItems(hLstView);
TVINSERTSTRUCT tvi = {0};
tvi.hParent = TVI_ROOT;
tvi.hInsertAfter = TVI_LAST;
tvi.item.mask = TVIF_TEXT | TVIF_IMAGE | TVIF_STATE | TVIF_SELECTEDIMAGE;
tvi.item.stateMask = TVIS_STATEIMAGEMASK;
NudgeElementList *n;
int i = 0;
if (GlobalNudge.useByProtocol)
{
#ifdef _UNICODE
wchar_t buff[256];
#endif
for(n = NudgeList;n != NULL; n = n->next)
{
#ifdef _UNICODE
MultiByteToWideChar(CP_ACP, 0, n->item.ProtocolName, -1, buff, 256);
tvi.item.pszText = buff;
#else
tvi.item.pszText = n->item.ProtocolName;
#endif
tvi.item.iImage = i;
n->item.iProtoNumber = i;
tvi.item.iSelectedImage = i;
tvi.item.state = INDEXTOSTATEIMAGEMASK(n->item.enabled?2:1);
TreeView_InsertItem(hLstView, &tvi);
i++;
}
}
else
{
tvi.item.pszText = TranslateT("Nudge");
tvi.item.iImage = nProtocol;
DefaultNudge.iProtoNumber = nProtocol;
tvi.item.iSelectedImage = nProtocol;
tvi.item.state = INDEXTOSTATEIMAGEMASK(DefaultNudge.enabled?2:1);
TreeView_InsertItem(hLstView, &tvi);
}
TreeView_SelectItem(hLstView, TreeView_GetRoot(hLstView));
//TreeView_SetCheckState(hLstView, TreeView_GetRoot(hLstView), TRUE)
}
void CTedTransformDialog::PopulateCategory(DMOCategory& category)
{
TVINSERTSTRUCT treeInserter;
treeInserter.hParent = TVI_ROOT;
treeInserter.hInsertAfter = TVI_FIRST;
CAtlString strName = LoadAtlString(category.m_nID);
TVITEM item;
item.mask = TVIF_TEXT;
item.pszText = strName.GetBuffer();
item.cchTextMax = strName.GetLength();
treeInserter.item = item;
HTREEITEM hBaseItem = (HTREEITEM) TreeView_InsertItem(m_hList, &treeInserter);
assert(hBaseItem != NULL);
treeInserter.hParent = hBaseItem;
item.mask = TVIF_TEXT | TVIF_PARAM;
DMO_PARTIAL_MEDIATYPE mediaType;
CComPtr<IEnumDMO> spDMOList;
mediaType.type = GUID_NULL;
mediaType.subtype = GUID_NULL;
IMFActivate** ppActivates = NULL;
UINT32 cMFTs = 0;
::MFTEnumEx(category.m_GUID, MFT_ENUM_FLAG_ALL, NULL, NULL, &ppActivates, &cMFTs);
for(DWORD i = 0; i < cMFTs; i++)
{
m_Activates.Add(ppActivates[i]);
LPWSTR pszName = NULL;
ppActivates[i]->GetAllocatedString(MFT_FRIENDLY_NAME_Attribute, &pszName, NULL);
m_strNames.Add(CAtlStringW(pszName));
item.pszText = m_strNames.GetAt(m_strNames.GetCount() - 1).GetBuffer();
item.lParam = (LPARAM) m_Activates.GetCount() - 1;
treeInserter.item = item;
TreeView_InsertItem(m_hList, &treeInserter);
CoTaskMemFree(pszName);
}
CoTaskMemFree(ppActivates);
}
void TrayNotifyDlg::InsertItem(HTREEITEM hparent, HTREEITEM after, const NotifyIconDlgInfo& entry,
HDC hdc, HICON hicon, NOTIFYICONMODE mode)
{
int idx = _info.size() + 1;
_info[idx] = entry;
String mode_str = string_from_mode(mode);
switch(mode) {
case NIM_SHOW: mode_str = ResString(IDS_NOTIFY_SHOW); break;
case NIM_HIDE: mode_str = ResString(IDS_NOTIFY_HIDE); break;
case NIM_AUTO: mode_str = ResString(IDS_NOTIFY_AUTOHIDE);
}
FmtString txt(TEXT("%s - %s [%s]"), entry._tipText.c_str(), entry._windowTitle.c_str(), mode_str.c_str());
TV_INSERTSTRUCT tvi;
tvi.hParent = hparent;
tvi.hInsertAfter = after;
TV_ITEM& tv = tvi.item;
tv.mask = TVIF_TEXT|TVIF_IMAGE|TVIF_SELECTEDIMAGE|TVIF_PARAM;
tv.lParam = (LPARAM)idx;
tv.pszText = txt.str();
tv.iSelectedImage = tv.iImage = ImageList_AddAlphaIcon(_himl, hicon, GetStockBrush(WHITE_BRUSH), hdc);
(void)TreeView_InsertItem(_tree_ctrl, &tvi);
}
bool CFileGroups::AddFile(HWND hwndTVCtrl, HTREEITEM hGroup, const char *filepath) {
_ASSERTE(hGroup != NULL);
_ASSERTE(filepath != 0);
_ASSERTE(qfileexist(filepath));
if (hGroup == NULL || filepath == 0 || !qfileexist(filepath)) return false;
for (HTREEITEM hChild = TreeView_GetChild(hwndTVCtrl, hGroup);
hChild != NULL; hChild = TreeView_GetNextSibling(hwndTVCtrl, hChild)) {
char text[MAX_PATH];
TVITEMEX tvi;
tvi.mask = TVIF_HANDLE | TVIF_TEXT;
tvi.hItem = hGroup;
tvi.pszText = text;
tvi.cchTextMax = sizeof text;
if (TreeView_GetItem(hwndTVCtrl, &tvi)) {
if (_stricmp(filepath, text) == 0) return false; // no dupes!
}
#ifdef _DEBUG
else
_RPTF4(_CRT_ERROR, "%s(%08X, ..., \"%s\"): TreeView_GetItem(%08X, ...) returned NULL",
__FUNCTION__, hwndTVCtrl, filepath, hwndTVCtrl);
#endif // _DEBUG
}
TVINSERTSTRUCT tvis;
tvis.hParent = hGroup;
tvis.hInsertAfter = TVI_SORT;
tvis.itemex.mask = TVIF_TEXT;
tvis.itemex.pszText = const_cast<LPTSTR>(filepath);
const HTREEITEM hti(TreeView_InsertItem(hwndTVCtrl, &tvis));
_ASSERTE(hti != NULL);
return hti != NULL;
}
static HTREEITEM
InsertIntoTreeView(HWND hTreeView,
HTREEITEM hRoot,
LPTSTR lpLabel,
LPTSTR DeviceID,
INT DevImage,
UINT OverlayImage)
{
TV_ITEM tvi;
TV_INSERTSTRUCT tvins;
ZeroMemory(&tvi, sizeof(tvi));
ZeroMemory(&tvins, sizeof(tvins));
tvi.mask = TVIF_TEXT | TVIF_PARAM | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
tvi.pszText = lpLabel;
tvi.cchTextMax = lstrlen(lpLabel);
tvi.lParam = (LPARAM)DeviceID;
tvi.iImage = DevImage;
tvi.iSelectedImage = DevImage;
if (OverlayImage != 0)
{
tvi.mask |= TVIF_STATE;
tvi.stateMask = TVIS_OVERLAYMASK;
tvi.state = INDEXTOOVERLAYMASK(OverlayImage);
}
tvins.item = tvi;
tvins.hParent = hRoot;
return TreeView_InsertItem(hTreeView, &tvins);
}
HTREEITEM
CDeviceView::InsertIntoTreeView(
_In_ HTREEITEM hParent,
_In_z_ LPWSTR lpLabel,
_In_ LPARAM lParam,
_In_ INT DevImage,
_In_ UINT OverlayImage
)
{
TV_ITEMW tvi;
TV_INSERTSTRUCT tvins;
ZeroMemory(&tvi, sizeof(tvi));
ZeroMemory(&tvins, sizeof(tvins));
tvi.mask = TVIF_TEXT | TVIF_PARAM | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
tvi.pszText = lpLabel;
tvi.cchTextMax = wcslen(lpLabel);
tvi.lParam = lParam;
tvi.iImage = DevImage;
tvi.iSelectedImage = DevImage;
if (OverlayImage != 0)
{
tvi.mask |= TVIF_STATE;
tvi.stateMask = TVIS_OVERLAYMASK;
tvi.state = INDEXTOOVERLAYMASK(OverlayImage);
}
tvins.item = tvi;
tvins.hParent = hParent;
return TreeView_InsertItem(m_hTreeView, &tvins);
}
void Manager::fillTree()
{
initRootItems();
TVINSERTSTRUCT tvi = { 0 };
tvi.hInsertAfter = TVI_LAST;
tvi.item.mask = TVIF_TEXT | TVIF_STATE;
tvi.item.stateMask = TVIS_STATEIMAGEMASK;
tvi.item.state = TreeItem::_UNCHECKED();
mir_cslock lock(DBEntry::mutexDB);
DBEntry *entry = DBEntry::getFirst();
while (entry != NULL) {
if ((UINT)entry->m_iFtpNum < m_rootItems.size()) {
tvi.item.pszText = mir_a2t(entry->m_szFileName);
tvi.hParent = m_rootItems[entry->m_iFtpNum]->m_handle;
HTREEITEM hItem = TreeView_InsertItem(m_hwndFileTree, &tvi);
AddLeaf(hItem, tvi.hParent, entry->m_fileID);
FREE(tvi.item.pszText);
}
entry = DBEntry::getNext(entry);
}
}
void AddToObjectTree(HTREEITEM hParent, Class *cls)
{
traceIn(AddToObjectTree);
static TVINSERTSTRUCT tvis;
if(cls == GetClass(EditorObject))
return;
zero(&tvis, sizeof(TVINSERTSTRUCT));
tvis.hParent = hParent;
tvis.hInsertAfter = TVI_SORT;
tvis.itemex.mask = TVIF_TEXT|TVIF_PARAM;
tvis.itemex.pszText = (TSTR)cls->GetName();
tvis.itemex.lParam = (LPARAM)cls;
HTREEITEM hItem = TreeView_InsertItem(hwndObjectTree, &tvis);
List<Class*> Children;
Class::GetClassChildren(cls, Children);
for(DWORD i=0; i<Children.Num(); i++)
AddToObjectTree(hItem, Children[i]);
if(hParent == NULL)
TreeView_Expand(hwndObjectTree, hItem, TVE_EXPAND);
traceOut;
}
VOID
FullStackInsertData(
__in PDIALOG_OBJECT Object,
__in PFULLSTACK_CONTEXT Context,
__in PTREELIST_OBJECT TreeList
)
{
PBTR_CPU_RECORD Record;
HWND hWndTree;
PBTR_CPU_SAMPLE Sample;
TVINSERTSTRUCT tvi = {0};
ULONG Number;
HTREEITEM hItem;
WCHAR Buffer[16];
Record = Context->Record;
hWndTree = TreeList->hWndTree;
for(Number = 0; Number < Record->ActiveCount + Record->RetireCount; Number += 1) {
Sample = &Record->Sample[Number];
tvi.hParent = TVI_ROOT;
tvi.hInsertAfter = TVI_LAST;
tvi.item.mask = TVIF_TEXT | TVIF_PARAM;
StringCchPrintf(Buffer, 16, L"%u", Sample->ThreadId);
tvi.item.pszText = Buffer;
tvi.item.lParam = (LPARAM)Sample;
hItem = TreeView_InsertItem(hWndTree, &tvi);
FullStackInsertBackTrace(Context, hWndTree, hItem, Sample);
}
}
HTREEITEM MoveItemAbove(HWND hTreeWnd, HTREEITEM hItem, HTREEITEM hInsertAfter)
{
TVITEM tvi={0};
tvi.mask=TVIF_HANDLE|TVIF_PARAM;
tvi.hItem=hItem;
if (!SendMessage(hTreeWnd, TVM_GETITEM, 0, (LPARAM)&tvi))
return NULL;
if (hItem && hInsertAfter) {
TVINSERTSTRUCT tvis;
TCHAR name[128];
if (hItem == hInsertAfter)
return hItem;
tvis.item.mask=TVIF_HANDLE|TVIF_PARAM|TVIF_TEXT|TVIF_IMAGE|TVIF_SELECTEDIMAGE;
tvis.item.stateMask=0xFFFFFFFF;
tvis.item.pszText=name;
tvis.item.cchTextMax=sizeof(name);
tvis.item.hItem=hItem;
tvis.item.iImage=tvis.item.iSelectedImage=((MenuItemOptData *)tvi.lParam)->show;
if(!SendMessage(hTreeWnd, TVM_GETITEM, 0, (LPARAM)&tvis.item))
return NULL;
if (!TreeView_DeleteItem(hTreeWnd,hItem))
return NULL;
tvis.hParent=NULL;
tvis.hInsertAfter=hInsertAfter;
return TreeView_InsertItem(hTreeWnd, &tvis);
}
return NULL;
}
static int InsertSeparator(HWND hwndDlg)
{
MenuItemOptData *PD;
TVINSERTSTRUCT tvis = {0};
TVITEM tvi = {0};
HTREEITEM hti = {0};
HWND hMenuTree = GetDlgItem( hwndDlg, IDC_MENUITEMS );
hti = TreeView_GetSelection( hMenuTree );
if ( hti == NULL )
return 1;
tvi.mask = TVIF_HANDLE | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM | TVIF_TEXT;
tvi.hItem = hti;
if ( TreeView_GetItem( hMenuTree, &tvi) == FALSE )
return 1;
PD = ( MenuItemOptData* )mir_alloc( sizeof( MenuItemOptData ));
ZeroMemory( PD, sizeof( MenuItemOptData ));
PD->id = -1;
PD->name = mir_tstrdup( STR_SEPARATOR );
PD->show = TRUE;
PD->pos = ((MenuItemOptData *)tvi.lParam)->pos-1;
tvis.item.lParam = (LPARAM)(PD);
tvis.item.pszText = PD->name;
tvis.item.iImage = tvis.item.iSelectedImage = PD->show;
tvis.hParent = NULL;
tvis.hInsertAfter = hti;
tvis.item.mask = TVIF_PARAM | TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
TreeView_InsertItem( hMenuTree, &tvis );
return 1;
}
static int BuildMenuObjectsTree(HWND hwndDlg)
{
TVINSERTSTRUCT tvis;
HWND hTree = GetDlgItem(hwndDlg,IDC_MENUOBJECTS);
int i;
tvis.hParent = NULL;
tvis.hInsertAfter = TVI_LAST;
tvis.item.mask = TVIF_PARAM | TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
TreeView_DeleteAllItems( hTree );
if ( g_menus.getCount() == 0 )
return FALSE;
for ( i=0; i < g_menus.getCount(); i++ ) {
if ( g_menus[i]->id == (int)hStatusMenuObject || !g_menus[i]->m_bUseUserDefinedItems )
continue;
tvis.item.lParam = ( LPARAM )g_menus[i]->id;
tvis.item.pszText = LangPackPcharToTchar( g_menus[i]->Name );
tvis.item.iImage = tvis.item.iSelectedImage = TRUE;
TreeView_InsertItem( hTree, &tvis );
mir_free( tvis.item.pszText );
}
return 1;
}
HTREEITEM wbAddTreeViewItemChild(PWBOBJ pwbo, HTREEITEM hItem, LPTSTR lpszItem, int lParam, BOOL bSetlParam, int nImageIndex, int nSelectedImageIndex)
{
TV_ITEM tvi;
TV_INSERTSTRUCT tvins;
PTREEDATA ptrdt = (PTREEDATA)pwbo->lparam;
if(!pwbo || !pwbo->hwnd || !IsWindow(pwbo->hwnd))
return FALSE;
if((!lpszItem || !*lpszItem))
return NULL;
// Add the item
tvi.mask = TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | (bSetlParam ? TVIF_PARAM : 0);
tvi.pszText = lpszItem;
tvi.cchTextMax = wcslen(lpszItem);
tvi.lParam = lParam;
tvi.iImage = (nImageIndex >= 0 ? nImageIndex : 4); // Default image indices: 4, 5
tvi.iSelectedImage = (nSelectedImageIndex >= 0 ? nSelectedImageIndex : 5);
if(!hItem)
tvins.hParent = TVI_ROOT;
else
tvins.hParent = hItem;
tvins.hInsertAfter = hItem;
tvins.item = tvi;
// Insert the item
ptrdt->hLast = TreeView_InsertItem(pwbo->hwnd, &tvins);
return ptrdt->hLast;
}
TreeItem * Resources::AddItem(TreeItem * parent,TreeItem * after,const char * caption, bool checked)
{
TVITEM tvi;
TVINSERTSTRUCT tvins;
TreeItem * item = new TreeItem(hTree);
tvi.mask = TVIF_TEXT | TVIF_PARAM | TVIF_STATE;
tvi.pszText = (char*)caption;
tvi.cchTextMax = lstrlen(caption);
tvi.lParam = (LPARAM) item;
tvi.stateMask = TVIS_STATEIMAGEMASK;
tvi.state = 0xffffffff;//INDEXTOSTATEIMAGEMASK(2);
//Since state images are one-based, 1 in this macro turns the check off, and
//2 turns it on.
tvins.item = tvi;
tvins.hInsertAfter = (after != NULL) ? after->Handle():(HTREEITEM) TVI_FIRST;
tvins.hParent = (parent != NULL) ? parent->Handle():TVI_ROOT;
item->handle = TreeView_InsertItem(hTree, &tvins);
return item;
}
void CConfig::FillTree(HWND hTree,bool bCList)
{
TreeView_DeleteAllItems(hTree);
TVINSERTSTRUCT tvis;
tvis.hParent=NULL;
tvis.hInsertAfter=TVI_LAST;
tvis.item.mask=TVIF_PARAM|TVIF_TEXT|TVIF_IMAGE|TVIF_SELECTEDIMAGE;
vector<CProtoFilter*>::iterator iter = m_ProtoList.begin();
while(iter != m_ProtoList.end())
{
tvis.item.lParam=(LPARAM)(*iter);
tvis.item.pszText= (LPTSTR)(*iter)->strName.c_str();
if(!bCList)
{
tvis.item.iImage= (*iter)->bNotificationFilter;
(*iter)->bTempNotificationFilter = (*iter)->bNotificationFilter;
}
else
{
tvis.item.iImage= (*iter)->bContactlistFilter;
(*iter)->bTempContactlistFilter = (*iter)->bContactlistFilter;
}
tvis.item.iSelectedImage= tvis.item.iImage;
TreeView_InsertItem(hTree,&tvis);
iter++;
}
}
// adds a new group if it doesn't exist yet; returns its hItem
HTREEITEM CCList::AddGroup(TCString GroupName)
{
if (GroupName == L"")
return TVI_ROOT;
MGROUP hGroupId = Clist_GroupExists(GroupName);
if (hGroupId == NULL)
return nullptr;
MCONTACT hContact = UINT_PTR(hGroupId) - 1 + HCONTACT_ISGROUP;
HTREEITEM hGroupItem = FindContact(hContact);
if (hGroupItem)
return hGroupItem; // exists already, just return its handle
TVINSERTSTRUCT tvIns = {};
tvIns.hParent = TVI_ROOT;
tvIns.item.pszText = wcsrchr(GroupName, '\\');
if (tvIns.item.pszText) {
TCString ParentGroupName(L"");
tvIns.hParent = AddGroup(ParentGroupName.DiffCat(GroupName, tvIns.item.pszText));
tvIns.item.pszText++;
}
else tvIns.item.pszText = GroupName;
tvIns.hInsertAfter = TVI_ROOT;
tvIns.item.mask = TVIF_TEXT | TVIF_STATE | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM;
tvIns.item.state = tvIns.item.stateMask = TVIS_BOLD | TVIS_EXPANDED;
tvIns.item.iImage = tvIns.item.iSelectedImage = IMAGE_GROUPOPEN;
tvIns.item.lParam = Items.AddElem(CCLItemData(hContact));
return TreeView_InsertItem(hTreeView, &tvIns);
}
static HTREEITEM AddLine(HWND hTree,TopButtonInt *b, HTREEITEM hItem, HIMAGELIST il)
{
TVINSERTSTRUCT tvis = { 0 };
tvis.hInsertAfter = hItem;
tvis.item.mask = TVIF_PARAM | TVIF_TEXT | TVIF_STATE | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
int index;
TCHAR* tmp;
if (b->dwFlags & TTBBF_ISSEPARATOR) {
tvis.item.pszText = _T("------------------");
index = -1;
}
else {
if (b->hIconHandleUp) {
HICON hIcon = IcoLib_GetIconByHandle(b->hIconHandleUp);
index = ImageList_AddIcon(il, hIcon);
IcoLib_ReleaseIcon(hIcon);
}
else index = ImageList_AddIcon(il, b->hIconUp);
tmp = mir_a2t( b->pszName );
tvis.item.pszText = TranslateTS(tmp);
}
tvis.item.iImage = tvis.item.iSelectedImage = index;
tvis.item.lParam = (LPARAM)b;
HTREEITEM hti = TreeView_InsertItem(hTree, &tvis);
if (!(b->dwFlags & TTBBF_ISSEPARATOR))
mir_free(tmp);
TreeView_SetCheckState(hTree, hti, b->isVisible());
return hti;
}
BBTreeViewNode *Win32TreeViewNode::insert( int index,BBString *str,int icon ){
HTREEITEM p;
if( index<=0 ){
p=TVI_FIRST;
}else if( index>=countKids() ){
p=TVI_LAST;
}else{
p=TreeView_GetChild( _tree,_item );
while( --index ){
p=TreeView_GetNextSibling( _tree,p );
}
}
TVINSERTSTRUCT it;
it.hParent=_item;
it.hInsertAfter=p;
it.item.mask=TVIF_TEXT;
it.item.pszText=(char*)str->c_str();
HTREEITEM item=TreeView_InsertItem( _tree,&it );
if( !item ) return 0;
Win32TreeViewNode *node=new Win32TreeViewNode( _tree,item,this );
TVITEM tv={TVIF_PARAM};
tv.hItem=item;
tv.lParam=(LPARAM)node;
if (icon>-1) {tv.mask|=TVIF_IMAGE|TVIF_SELECTEDIMAGE;tv.iImage=icon;tv.iSelectedImage=icon+0;}
TreeView_SetItem( _tree,&tv );
return node;
}
HTREEITEM
CDeviceView::InsertIntoTreeView(
_In_opt_ HTREEITEM hParent,
_In_ CNode *Node
)
{
LPWSTR lpLabel;
lpLabel = Node->GetDisplayName();
TV_ITEMW tvi;
TV_INSERTSTRUCT tvins;
ZeroMemory(&tvi, sizeof(tvi));
ZeroMemory(&tvins, sizeof(tvins));
tvi.mask = TVIF_TEXT | TVIF_PARAM | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
tvi.pszText = lpLabel;
tvi.cchTextMax = wcslen(lpLabel);
tvi.lParam = (LPARAM)Node;
tvi.iImage = Node->GetClassImage();
tvi.iSelectedImage = Node->GetClassImage();
// try to cast it to a device node. This will only suceed if it's the correct type
CDeviceNode *DeviceNode = dynamic_cast<CDeviceNode *>(Node);
if (DeviceNode && DeviceNode->GetOverlayImage())
{
tvi.mask |= TVIF_STATE;
tvi.stateMask = TVIS_OVERLAYMASK;
tvi.state = INDEXTOOVERLAYMASK(DeviceNode->GetOverlayImage());
}
tvins.item = tvi;
tvins.hParent = hParent;
return TreeView_InsertItem(m_hTreeView, &tvins);
}
void rowOptGenerateTreeView(pROWCELL cell, HTREEITEM node, HWND hwnd)
{
if (!cell) return;
TVINSERTSTRUCT tvis;
tvis.hParent = node;
tvis.hInsertAfter = TVI_LAST;
tvis.item.mask = TVIF_PARAM | TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
tvis.item.stateMask = TVIS_STATEIMAGEMASK;
tvis.item.lParam = (LPARAM)cell;
switch (cell->cont) {
case TC_ROW:
tvis.item.pszText = _T("Line");
break;
case TC_COL:
tvis.item.pszText = _T("Column");
}
tvis.item.iImage = cell->child ? 1 : 2;
tvis.item.iSelectedImage = cell->child ? 0 : 2;
HTREEITEM pnode = TreeView_InsertItem(hwnd, &tvis);
rowOptGenerateTreeView(cell->child, pnode, hwnd);
rowOptGenerateTreeView(cell->next, node, hwnd);
}
static HTREEITEM InsertFavTopLevelNode(HWND hwnd, DisplayState* fav, bool isExpanded) {
WCHAR* s = nullptr;
bool collapsed = fav->favorites->Count() == 1;
if (collapsed) {
isExpanded = false;
}
TV_INSERTSTRUCT tvinsert;
tvinsert.hParent = nullptr;
tvinsert.hInsertAfter = TVI_LAST;
tvinsert.itemex.mask = TVIF_TEXT | TVIF_STATE | TVIF_PARAM;
tvinsert.itemex.state = isExpanded ? TVIS_EXPANDED : 0;
tvinsert.itemex.stateMask = TVIS_EXPANDED;
tvinsert.itemex.lParam = 0;
if (collapsed) {
Favorite* fn = fav->favorites->At(0);
tvinsert.itemex.lParam = (LPARAM)fn;
s = FavCompactReadableName(fav, fn);
tvinsert.itemex.pszText = s;
} else {
tvinsert.itemex.pszText = (WCHAR*)path::GetBaseName(fav->filePath);
}
HTREEITEM ret = TreeView_InsertItem(hwnd, &tvinsert);
free(s);
return ret;
}
int FillTree(HWND hwnd)
{
ProtocolData *PD;
TVINSERTSTRUCT tvis;
tvis.hParent = NULL;
tvis.hInsertAfter = TVI_LAST;
tvis.item.mask = TVIF_PARAM | TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
TreeView_DeleteAllItems(hwnd);
int n;
PROTOACCOUNT** pa;
Proto_EnumAccounts(&n, &pa);
for (int i = 0; i < n; i++) {
if (Proto_IsAccountEnabled(pa[i])) {
PD = (ProtocolData*)mir_alloc(sizeof(ProtocolData));
PD->RealName = pa[i]->szModuleName;
PD->enabled = IsProtoIM(pa[i]);
PD->show = PD->enabled ? (plSets->ProtoDisabled(PD->RealName) ? 1 : 0) : 100;
tvis.item.lParam = (LPARAM)PD;
tvis.item.pszText = pa[i]->tszAccountName;
tvis.item.iImage = tvis.item.iSelectedImage = PD->show;
TreeView_InsertItem(hwnd, &tvis);
}
}
return 0;
}
void CContainer::InsertBookmarksIntoTreeView(HWND hTreeView,
HTREEITEM hParent,Bookmark_t *pBookmark)
{
TVINSERTSTRUCT tvis;
TVITEMEX tvItemEx;
HTREEITEM hTreeItem;
Bookmark_t Child;
HRESULT hr;
hr = m_Bookmark.GetChild(pBookmark,&Child);
tvItemEx.mask = TVIF_TEXT|TVIF_CHILDREN|TVIF_IMAGE|TVIF_SELECTEDIMAGE|TVIF_PARAM;
tvItemEx.pszText = pBookmark->szItemName;
tvItemEx.cChildren = (hr == S_OK);
tvItemEx.iImage = SHELLIMAGES_NEWTAB;
tvItemEx.iSelectedImage = SHELLIMAGES_NEWTAB;
tvItemEx.lParam = (LPARAM)pBookmark->pHandle;
tvis.hParent = hParent;
tvis.hInsertAfter = TVI_ROOT;
tvis.itemex = tvItemEx;
hTreeItem = TreeView_InsertItem(hTreeView,&tvis);
InsertBookmarksIntoTreeViewInternal(hTreeView,hTreeItem,pBookmark);
}
/*-------------------------------------------
set items to left tree view
---------------------------------------------*/
void InitTreeView(HWND hDlg)
{
HWND hTree;
TV_INSERTSTRUCT tv;
HTREEITEM hTreeItem[MAX_TREEITEM];
int i;
hTree = GetDlgItem(hDlg, IDC_TREE);
memset(&tv, 0, sizeof(TV_INSERTSTRUCT));
tv.hInsertAfter = TVI_LAST;
tv.item.mask = TVIF_TEXT | TVIF_STATE | TVIF_PARAM;
tv.item.state = TVIS_EXPANDED;
tv.item.stateMask = TVIS_EXPANDED;
for(i = 0; i < MAX_TREEITEM; i++)
{
int nParent = g_treeItem[i].nParent;
tv.item.lParam = i;
if(nParent < 0) tv.hParent = TVI_ROOT;
else tv.hParent = hTreeItem[nParent];
tv.item.pszText =
MyString(g_treeItem[i].idStr, g_treeItem[i].entry);
hTreeItem[i] = TreeView_InsertItem(hTree, &tv);
}
m_lastTreeItem = GetMyRegLong("", "LastTreeItem", 0);
if(m_lastTreeItem >= MAX_TREEITEM) m_lastTreeItem = 0;
TreeView_SelectItem(hTree, hTreeItem[m_lastTreeItem]);
}
HTREEITEM AddTreeViewItem ( HWND hWndTV,
HTREEITEM hParent,
HTREEITEM hInsertAfter,
int iImage,
int iSelectedImage,
LPSTR szText,
LPARAM lParam
)
{
TV_ITEM tvItem;
TV_INSERTSTRUCT tvIns;
// Set which attribytes we are going to fill out.
tvItem.mask = TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM;
// Set the attribytes
tvItem.pszText = szText;
tvItem.iImage = iImage;
tvItem.iSelectedImage = iSelectedImage;
tvItem.lParam = lParam;
// Fill out the TV_INSERTSTRUCT
tvIns.hParent = hParent;
tvIns.hInsertAfter = hInsertAfter;
tvIns.item = tvItem;
// And insert the item, returning its handle
return TreeView_InsertItem ( hWndTV, &tvIns );
}
HTREEITEM BuildTree::InsertViewItem(HTREEITEM hParentItem,char *szPath)
{
//找到就OK
char *ps = szPath;
char *pf(NULL);
char szTemp[_MAX_PATH];
pf = strchr(ps,'\\');
if (pf)
{
ZeroMemory(szTemp,_MAX_PATH);
memcpy(szTemp,ps,(int)(pf - ps));
HTREEITEM hItem = FindChildItem(hParentItem,szTemp);
if (!hItem)
{
TV_INSERTSTRUCT ti = {0};
ti.hParent = hParentItem;
ti.item.mask = TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM;
ti.item.lParam = -1;
ti.item.iImage = ICON_FOLDER;
ti.item.iSelectedImage = ICON_FOLDER;
ti.item.pszText = szTemp;
hItem = TreeView_InsertItem(s_hWndTV,&ti);
}
return InsertViewItem(hItem,pf + 1);
}
HTREEITEM hItem = FindChildItem(hParentItem,szTemp);
if (!hItem)
{
TV_INSERTSTRUCT ti = {0};
ti.hParent = hParentItem;
ti.item.mask = TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM;
ti.item.lParam = -1;
ti.item.iImage = ICON_FOLDER;
ti.item.iSelectedImage = ICON_FOLDER;
ti.item.pszText = szPath;
hItem = TreeView_InsertItem(s_hWndTV,&ti);
}
return hItem;
}
