void TreeList_Update(HWND hwnd)
{
TTreeList_Data *data = (TTreeList_Data *)sttTreeList_GeWindowData(hwnd);
HTREELISTITEM hItem = data->root;
int sortIndex = 0;
SendMessage(hwnd, WM_SETREDRAW, FALSE, 0);
if (data->sortMode)
TreeList_RecursiveApply(hItem, sttTreeList_SortItems, (LPARAM)data->sortMode);
TreeList_RecursiveApply(hItem, sttTreeList_ResetIndex, (LPARAM)&sortIndex);
if (data->filter)
TreeList_RecursiveApply(hItem, sttTreeList_FilterItems, (LPARAM)data->filter);
for (int i = ListView_GetItemCount(hwnd); i--;) {
LVITEM lvi = {0};
lvi.mask = LVIF_PARAM;
lvi.iItem = i;
lvi.iSubItem = 0;
ListView_GetItem(hwnd, &lvi);
HTREELISTITEM ptli = (HTREELISTITEM)lvi.lParam;
if ((ptli->flags & TLIF_VISIBLE) && (!data->filter || (ptli->flags & TLIF_FILTERED))) {
ptli->flags |= TLIF_HASITEM;
if (ptli->flags & TLIF_MODIFIED) {
lvi.mask = LVIF_TEXT | LVIF_STATE | LVIF_IMAGE | LVIF_TEXT;
lvi.iItem = i;
lvi.iSubItem = 0;
lvi.pszText = ptli->text[0];
lvi.stateMask = LVIS_OVERLAYMASK|LVIS_STATEIMAGEMASK;
lvi.iImage = ptli->iIcon;
if (data->mode == TLM_TREE)
lvi.state =
INDEXTOSTATEIMAGEMASK(
((ptli->subItems.getCount() == 0) && !(ptli->flags & TLIF_FAKEPARENT)) ? 0 :
(ptli->flags & TLIF_EXPANDED) ? 1 : 2) |
INDEXTOOVERLAYMASK(ptli->iOverlay);
else
lvi.state =
INDEXTOSTATEIMAGEMASK(
((ptli->subItems.getCount() == 0) && !(ptli->flags & TLIF_FAKEPARENT)) ? 0 : 3) |
INDEXTOOVERLAYMASK(ptli->iOverlay);
ListView_SetItem(hwnd, &lvi);
for (int j = 1; j < ptli->text.getCount(); ++j)
ListView_SetItemText(hwnd, i, j, ptli->text[j]);
}
}
else ListView_DeleteItem(hwnd, i);
}
if (data->mode == TLM_TREE)
TreeList_RecursiveApply(hItem, sttTreeList_CreateItems, (LPARAM)hwnd);
else {
for (int i = data->hItemSelected->subItems.getCount(); i--;)
sttTreeList_CreateItems_List(data->hItemSelected->subItems[i], (LPARAM)hwnd);
for (HTREELISTITEM hItem = data->hItemSelected; !(hItem->flags & TLIF_ROOT); hItem = hItem->parent)
sttTreeList_CreateItems_List(hItem, (LPARAM)hwnd);
}
ListView_SortItems(hwnd, sttTreeList_SortFunc, 0);
SendMessage(hwnd, WM_SETREDRAW, TRUE, 0);
UpdateWindow(hwnd);
}
BOOL CLiveItem::Update(CListCtrl* pCtrl, int nItem, int nColumns)
{
ASSERT_VALID( this );
ASSERT_VALID( pCtrl );
BOOL bModified = FALSE;
LV_ITEM pMainItem = {
LVIF_PARAM | LVIF_IMAGE | LVIF_STATE,
nItem,
0,
0,
LVIS_OVERLAYMASK|LVIS_STATEIMAGEMASK
};
if ( ! pCtrl->GetItem( &pMainItem ) || pMainItem.lParam != (LPARAM)m_nParam )
return FALSE;
if ( ( pMainItem.state & (LVIS_OVERLAYMASK|LVIS_STATEIMAGEMASK) ) != ( INDEXTOOVERLAYMASK( m_nMaskOverlay ) | INDEXTOSTATEIMAGEMASK( m_nMaskState ) ) )
{
pMainItem.state = INDEXTOOVERLAYMASK( m_nMaskOverlay ) | INDEXTOSTATEIMAGEMASK( m_nMaskState );
pMainItem.stateMask = LVIS_OVERLAYMASK | LVIS_STATEIMAGEMASK;
bModified = TRUE;
}
if ( bModified )
VERIFY( pCtrl->SetItem( &pMainItem ) );
CString buf;
for ( int i = 0 ; i < nColumns ; ++i )
{
LV_ITEM pItem = { LVIF_IMAGE | LVIF_TEXT, nItem, i, 0, 0, buf.GetBuffer( 1024 ), 1024 };
BOOL bResult = pCtrl->GetItem( &pItem );
buf.ReleaseBuffer();
if ( ! bResult )
return FALSE;
pItem.mask = 0;
if ( ! pItem.pszText || m_pColumn[ pItem.iSubItem ] != pItem.pszText )
{
pItem.mask |= LVIF_TEXT;
pItem.pszText = (LPTSTR)(LPCTSTR)m_pColumn[ pItem.iSubItem ];
}
if ( m_nImage[ pItem.iSubItem ] >= 0 &&
m_nImage[ pItem.iSubItem ] != pItem.iImage )
{
pItem.mask |= LVIF_IMAGE;
pItem.iImage = m_nImage[ pItem.iSubItem ];
}
if ( pItem.mask )
{
VERIFY( pCtrl->SetItem( &pItem ) );
bModified = TRUE;
}
}
return bModified;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CGroupList::GetCheck(HTREEITEM hItem)
{
UINT uState = (GetItemState(hItem, TVIS_OVERLAYMASK) & TVIS_OVERLAYMASK);
if (uState == INDEXTOOVERLAYMASK(1))
{
return 1;
}
else if (uState == INDEXTOOVERLAYMASK(0))
{
return 0;
}
return -1;
}
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);
}
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);
}
// called by CWList::populateListCtrl
// This default implementation just adds one row for the entry
int CWListEntry::addYourRowsToListCtrl(CListCtrl &clc, int iStartingRow)
{
LV_ITEM lvi;
lvi.mask = LVIF_TEXT | LVIF_PARAM | LVIF_STATE | LVIF_IMAGE;
lvi.state = 0;
lvi.stateMask = 0;
lvi.pszText = LPSTR_TEXTCALLBACK; // app. maintains text
lvi.iImage = getIconIndex();
lvi.iSubItem = 0;
lvi.iItem = iStartingRow;
lvi.lParam = (LPARAM) this;
if(!m_bEnabled)
{
lvi.state = INDEXTOOVERLAYMASK(1); // draw the 'not' icon over it
lvi.stateMask = LVIS_OVERLAYMASK;
}
else
{
lvi.state = 0;
lvi.stateMask = NULL;
}
ASSERTX(-1 != clc.InsertItem(&lvi));
return 1+ iStartingRow; // the next row that will be inserted
}
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);
}
HICON
CMainFrame::_CreateTaskbarIcon(bool NormalOrFailure /* = true */)
{
return m_taskbarImageList.GetIcon(
m_nTaskbarNormal,
NormalOrFailure ? ILD_NORMAL : INDEXTOOVERLAYMASK(1));
}
int CLiveItem::Add(CListCtrl* pCtrl, int nItem, int nColumns)
{
ASSERT_VALID( this );
ASSERT_VALID( pCtrl );
LV_ITEM pItem = {};
pItem.mask = LVIF_PARAM|LVIF_TEXT|LVIF_STATE;
pItem.iItem = nItem >= 0 ? nItem : pCtrl->GetItemCount();
if ( m_nImage[ 0 ] >= 0 )
{
pItem.mask |= LVIF_IMAGE;
pItem.iImage = m_nImage[ 0 ];
}
pItem.lParam = (LPARAM)m_nParam;
pItem.state = INDEXTOOVERLAYMASK( m_nMaskOverlay ) | INDEXTOSTATEIMAGEMASK( m_nMaskState );
pItem.stateMask = LVIS_OVERLAYMASK | LVIS_STATEIMAGEMASK;
pItem.pszText = (LPTSTR)(LPCTSTR)m_pColumn[0];
pItem.iItem = pCtrl->InsertItem( &pItem );
if ( pItem.iItem != -1 )
{
for ( pItem.iSubItem = 1 ; pItem.iSubItem < nColumns ; pItem.iSubItem++ )
{
pItem.mask = LVIF_TEXT;
pItem.pszText = (LPTSTR)(LPCTSTR)m_pColumn[ pItem.iSubItem ];
if ( m_nImage[ pItem.iSubItem ] >= 0 )
{
pItem.mask |= LVIF_IMAGE;
pItem.iImage = m_nImage[ pItem.iSubItem ];
}
VERIFY( pCtrl->SetItem( &pItem ) );
}
}
return pItem.iItem;
}
//
/// Draws an image onto a target DC at a given coordinate and with a given style.
//
bool
TImageList::Draw(int index, TDC& dc, int x, int y, uint style, int overlay)
{
// Frank Rast: ILD_OVERLAYMASK must not be used here
if (overlay)
style |= INDEXTOOVERLAYMASK(overlay);
return TCommCtrl::Dll()->ImageList_Draw(Handle, index, dc, x, y, style);
}
void LoadModuleIcons(MODULEINFO *mi)
{
HIMAGELIST hList = ImageList_Create(16, 16, ILC_COLOR32 | ILC_MASK, 0, 0);
int overlayIcon = ImageList_AddIcon(hList, GetCachedIcon("chat_overlay"));
ImageList_SetOverlayImage(hList, overlayIcon, 1);
int index = ImageList_AddIcon(hList, Skin_LoadProtoIcon(mi->pszModule, ID_STATUS_ONLINE));
mi->hOnlineIcon = ImageList_GetIcon(hList, index, ILD_TRANSPARENT);
mi->hOnlineTalkIcon = ImageList_GetIcon(hList, index, ILD_TRANSPARENT | INDEXTOOVERLAYMASK(1));
index = ImageList_AddIcon(hList, Skin_LoadProtoIcon(mi->pszModule, ID_STATUS_OFFLINE));
mi->hOfflineIcon = ImageList_GetIcon(hList, index, ILD_TRANSPARENT);
mi->hOfflineTalkIcon = ImageList_GetIcon(hList, index, ILD_TRANSPARENT | INDEXTOOVERLAYMASK(1));
ImageList_Destroy(hList);
}
int ShellBrowserChild::InsertSubitems(HTREEITEM hParentItem, ShellDirectory* dir)
{
CONTEXT("ShellBrowserChild::InsertSubitems()");
WaitCursor wait;
int cnt = 0;
SendMessage(_left_hwnd, WM_SETREDRAW, FALSE, 0);
try {
dir->smart_scan();
} catch(COMException& e) {
HandleException(e, g_Globals._hMainWnd);
}
// remove old children items
for(HTREEITEM hchild,hnext=TreeView_GetChild(_left_hwnd, hParentItem); hchild=hnext; ) {
hnext = TreeView_GetNextSibling(_left_hwnd, hchild);
TreeView_DeleteItem(_left_hwnd, hchild);
}
TV_ITEM tvItem;
TV_INSERTSTRUCT tvInsert;
for(ShellEntry*entry=dir->_down; entry; entry=entry->_next) {
#ifndef _LEFT_FILES
if (entry->_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
#endif
{
ZeroMemory(&tvItem, sizeof(tvItem));
tvItem.mask = TVIF_PARAM | TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_CHILDREN;
tvItem.pszText = LPSTR_TEXTCALLBACK;
tvItem.iImage = tvItem.iSelectedImage = I_IMAGECALLBACK;
tvItem.lParam = (LPARAM)entry;
tvItem.cChildren = entry->_shell_attribs & SFGAO_HASSUBFOLDER? 1: 0;
if (entry->_shell_attribs & SFGAO_SHARE) {
tvItem.mask |= TVIF_STATE;
tvItem.stateMask |= TVIS_OVERLAYMASK;
tvItem.state |= INDEXTOOVERLAYMASK(1);
}
tvInsert.item = tvItem;
tvInsert.hInsertAfter = TVI_LAST;
tvInsert.hParent = hParentItem;
TreeView_InsertItem(_left_hwnd, &tvInsert);
++cnt;
}
}
SendMessage(_left_hwnd, WM_SETREDRAW, TRUE, 0);
return cnt;
}
//-----------------------------------------------------------------------------
// Purpose: Sets the check status for the given group.
// Input : pVisGroup -
// nCheckState - 0=not checked, 1=checked, -1=gray check (undefined)
//-----------------------------------------------------------------------------
void CGroupList::SetCheck(CVisGroup *pVisGroup, int nCheckState)
{
HTREEITEM hItem = FindVisGroupItem(pVisGroup);
if (hItem)
{
UINT uState = INDEXTOOVERLAYMASK(0);
if (nCheckState == 1)
{
uState = INDEXTOOVERLAYMASK(1);
}
else if (nCheckState != 0)
{
uState = INDEXTOOVERLAYMASK(2);
}
SetItemState(hItem, uState, TVIS_OVERLAYMASK);
}
}
void CRowListView::CheckItem(int nNewCheckedItem)
{
CListCtrl& ListCtrl = GetListCtrl();
// reset if there is checked item
if (m_nCheckedItem != -1)
{
if (m_bStateIcons)
{
ListCtrl.SetItemState(m_nCheckedItem,
INDEXTOSTATEIMAGEMASK(1), LVIS_STATEIMAGEMASK);
}
else
{
ListCtrl.SetItemState(m_nCheckedItem,
INDEXTOSTATEIMAGEMASK(1),
LVIS_STATEIMAGEMASK | LVIS_OVERLAYMASK);
}
::DestroyIcon(m_hSmallIcon);
::DestroyIcon(m_hLargeIcon);
}
// check new item and set its icon as the app icon
CWnd* pMainWnd = AfxGetMainWnd();
if (m_nCheckedItem == nNewCheckedItem)
{
m_nCheckedItem = -1;
pMainWnd->SetIcon(NULL, FALSE);
pMainWnd->SetIcon(NULL, TRUE);
}
else if ((m_nCheckedItem = nNewCheckedItem) != -1)
{
if (m_bStateIcons)
{
ListCtrl.SetItemState(m_nCheckedItem,
INDEXTOSTATEIMAGEMASK(2), LVIS_STATEIMAGEMASK);
}
else
{
ListCtrl.SetItemState(m_nCheckedItem,
INDEXTOSTATEIMAGEMASK(2) | INDEXTOOVERLAYMASK(1),
LVIS_STATEIMAGEMASK | LVIS_OVERLAYMASK);
}
m_hSmallIcon =
ListCtrl.GetImageList(LVSIL_SMALL)->ExtractIcon(nNewCheckedItem);
pMainWnd->SetIcon(m_hSmallIcon,FALSE);
m_hLargeIcon =
ListCtrl.GetImageList(LVSIL_NORMAL)->ExtractIcon(nNewCheckedItem);
pMainWnd->SetIcon(m_hLargeIcon,TRUE);
}
}
void CSharedDirsTreeCtrl::FileSystemTreeSetShareState(CDirectoryItem* pDir, bool bShared, bool bSubDirectories){
if (m_bUseIcons && pDir->m_htItem != NULL)
SetItemState(pDir->m_htItem,bShared ? INDEXTOOVERLAYMASK(1) : 0, TVIS_OVERLAYMASK);
if (bSubDirectories){
POSITION pos = pDir->liSubDirectories.GetHeadPosition();
while (pos != NULL){
FileSystemTreeSetShareState(pDir->liSubDirectories.GetNext(pos), bShared, true);
}
}
}
void FolderTree::checkRemovedDirs(const tstring& aParentPath, HTREEITEM hParent) {
string parentPath = Text::fromT(aParentPath);
for(auto& sd: sp->getCurItems()) {
if (sd->found || !sd->isCurItem())
continue;
auto dir = Util::getParentDir(sd->dir->path);
if (dir == parentPath) {
//this should have been inserted
FolderTreeItemInfo* pItem = new FolderTreeItemInfo;
pItem->m_sFQPath = Text::toT(sd->dir->path);
pItem->m_sRelativePath = Text::toT(Util::getLastDir(sd->dir->path));
pItem->m_removed = true;
tstring sLabel;
//Correct the label if need be
if(IsDrive(pItem->m_sFQPath) && m_bShowDriveLabels)
sLabel = GetDriveLabel(pItem->m_sFQPath);
else
sLabel = GetCorrectedLabel(pItem);
sLabel = _T("REMOVED: ") + sLabel;
//Add the actual item
TV_INSERTSTRUCT tvis;
memzero(&tvis, sizeof(TV_INSERTSTRUCT));
tvis.hParent = hParent;
tvis.hInsertAfter = TVI_FIRST;
tvis.item.mask = TVIF_CHILDREN | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_TEXT | TVIF_PARAM;
//tvis.item.iImage = 7;
//tvis.item.iSelectedImage = 7;
tvis.item.iImage = 1;
tvis.item.iSelectedImage = 1;
tvis.item.lParam = (LPARAM) pItem;
tvis.item.pszText = (LPWSTR)sLabel.c_str();
tvis.item.cChildren = false;
tvis.item.mask |= TVIF_STATE;
tvis.item.stateMask |= TVIS_OVERLAYMASK;
tvis.item.state = TVIS_BOLD | INDEXTOOVERLAYMASK(1); //1 is the index for the shared overlay image
tvis.item.state |= TVIS_BOLD;
//tvis.item.state = TVIS_BOLD;
//tvis.item.stateMask = TVIS_BOLD;
HTREEITEM hItem = InsertItem(&tvis);
//SetItemImage(hItem, MAKEINTRESOURCE(IDI_ERROR), MAKEINTRESOURCE(IDI_ERROR));
SetChecked(hItem, true);
SetItemState(hItem, TVIS_BOLD, TVIS_BOLD);
}
}
}
void CRepositoryBrowser::FillListCtrlForShadowTree(CShadowFilesTree* pTree)
{
for (TShadowFilesTreeMap::iterator itShadowTree = pTree->m_ShadowTree.begin(); itShadowTree != pTree->m_ShadowTree.end(); ++itShadowTree)
{
int icon = m_nIconFolder;
if (!(*itShadowTree).second.m_bFolder && !(*itShadowTree).second.m_bSubmodule)
{
icon = SYS_IMAGE_LIST().GetFileIconIndex((*itShadowTree).second.m_sName);
}
int indexItem = m_RepoList.InsertItem(m_RepoList.GetItemCount(), (*itShadowTree).second.m_sName, icon);
if ((*itShadowTree).second.m_bSubmodule)
{
m_RepoList.SetItemState(indexItem, INDEXTOOVERLAYMASK(OVERLAY_EXTERNAL), LVIS_OVERLAYMASK);
}
if ((*itShadowTree).second.m_bExecutable)
m_RepoList.SetItemState(indexItem, INDEXTOOVERLAYMASK(OVERLAY_EXECUTABLE), LVIS_OVERLAYMASK);
if ((*itShadowTree).second.m_bSymlink)
m_RepoList.SetItemState(indexItem, INDEXTOOVERLAYMASK(OVERLAY_SYMLINK), LVIS_OVERLAYMASK);
m_RepoList.SetItemData(indexItem, (DWORD_PTR)&(*itShadowTree).second);
if (!(*itShadowTree).second.m_bFolder && !(*itShadowTree).second.m_bSubmodule)
{
CString temp;
temp = CPathUtils::GetFileExtFromPath((*itShadowTree).second.m_sName);
m_RepoList.SetItemText(indexItem, eCol_Extension, temp);
StrFormatByteSize64((*itShadowTree).second.m_iSize, temp.GetBuffer(20), 20);
temp.ReleaseBuffer();
m_RepoList.SetItemText(indexItem, eCol_FileSize, temp);
}
}
CRepoListCompareFunc compareFunc(&m_RepoList, m_currSortCol, m_currSortDesc);
m_RepoList.SortItemsEx(&CRepoListCompareFunc::StaticCompare, (DWORD_PTR)&compareFunc);
SetSortArrowA(&m_RepoList, m_currSortCol, !m_currSortDesc);
UpdateInfoLabel();
}
//
/// Extended version of draw that takes a foreground color and background color.
//
bool
TImageList::Draw(int index, TDC& dc, int x, int y, int dx, int dy,
const TColor& bgClr, const TColor& fgClr, uint style,
int overlay)
{
// Frank Rast: ILD_OVERLAYMASK must not be used here
if (overlay)
style |= INDEXTOOVERLAYMASK(overlay);
COLORREF bgCr = (bgClr == TColor::None) ? (COLORREF)CLR_NONE : (COLORREF)bgClr;
COLORREF fgCr = (fgClr == TColor::None) ? (COLORREF)CLR_NONE : (COLORREF)fgClr;
return TCommCtrl::Dll()->ImageList_DrawEx(Handle, index, dc, x, y, dx, dy, bgCr, fgCr, style);
}
void CSetOverlayIcons::AddFileTypeGroup(CString sFileType, bool bSmallIcons)
{
UINT flags = SHGFI_ICON | SHGFI_USEFILEATTRIBUTES;
if (bSmallIcons)
flags |= SHGFI_SMALLICON;
else
flags |= SHGFI_LARGEICON;
SHFILEINFO sfi;
SecureZeroMemory(&sfi, sizeof sfi);
SHGetFileInfo(
sFileType,
FILE_ATTRIBUTE_NORMAL,
&sfi, sizeof sfi,
flags);
int imageindex = 0;
if (bSmallIcons)
imageindex = m_ImageList.Add(sfi.hIcon);
else
imageindex = m_ImageListBig.Add(sfi.hIcon);
DestroyIcon(sfi.hIcon);
int index = 0;
index = m_cIconList.InsertItem(m_cIconList.GetItemCount(), m_sNormal+sFileType, imageindex);
m_cIconList.SetItemState(index, INDEXTOOVERLAYMASK(1), TVIS_OVERLAYMASK);
index = m_cIconList.InsertItem(m_cIconList.GetItemCount(), m_sModified+sFileType, imageindex);
m_cIconList.SetItemState(index, INDEXTOOVERLAYMASK(2), TVIS_OVERLAYMASK);
index = m_cIconList.InsertItem(m_cIconList.GetItemCount(), m_sConflicted+sFileType, imageindex);
m_cIconList.SetItemState(index, INDEXTOOVERLAYMASK(3), TVIS_OVERLAYMASK);
index = m_cIconList.InsertItem(m_cIconList.GetItemCount(), m_sReadOnly+sFileType, imageindex);
m_cIconList.SetItemState(index, INDEXTOOVERLAYMASK(4), TVIS_OVERLAYMASK);
index = m_cIconList.InsertItem(m_cIconList.GetItemCount(), m_sDeleted+sFileType, imageindex);
m_cIconList.SetItemState(index, INDEXTOOVERLAYMASK(5), TVIS_OVERLAYMASK);
index = m_cIconList.InsertItem(m_cIconList.GetItemCount(), m_sLocked+sFileType, imageindex);
m_cIconList.SetItemState(index, INDEXTOOVERLAYMASK(6), TVIS_OVERLAYMASK);
index = m_cIconList.InsertItem(m_cIconList.GetItemCount(), m_sAdded+sFileType, imageindex);
m_cIconList.SetItemState(index, INDEXTOOVERLAYMASK(7), TVIS_OVERLAYMASK);
index = m_cIconList.InsertItem(m_cIconList.GetItemCount(), m_sIgnored+sFileType, imageindex);
m_cIconList.SetItemState(index, INDEXTOOVERLAYMASK(8), TVIS_OVERLAYMASK);
index = m_cIconList.InsertItem(m_cIconList.GetItemCount(), m_sUnversioned+sFileType, imageindex);
m_cIconList.SetItemState(index, INDEXTOOVERLAYMASK(9), TVIS_OVERLAYMASK);
}
HTREEITEM FolderTree::InsertFileItem(HTREEITEM hParent, FolderTreeItemInfo *pItem, bool bShared, int nIcon, int nSelIcon, bool bCheckForChildren)
{
tstring sLabel;
//Correct the label if need be
if(IsDrive(pItem->m_sFQPath) && m_bShowDriveLabels)
sLabel = GetDriveLabel(pItem->m_sFQPath);
else
sLabel = GetCorrectedLabel(pItem);
//Add the actual item
TV_INSERTSTRUCT tvis;
memzero(&tvis, sizeof(TV_INSERTSTRUCT));
tvis.hParent = hParent;
tvis.hInsertAfter = TVI_LAST;
tvis.item.mask = TVIF_CHILDREN | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_TEXT | TVIF_PARAM;
tvis.item.iImage = nIcon;
tvis.item.iSelectedImage = nSelIcon;
tvis.item.lParam = (LPARAM) pItem;
tvis.item.pszText = (LPWSTR)sLabel.c_str();
if (bCheckForChildren)
tvis.item.cChildren = HasGotSubEntries(pItem->m_sFQPath);
else
tvis.item.cChildren = true;
if(bShared)
{
tvis.item.mask |= TVIF_STATE;
tvis.item.stateMask |= TVIS_OVERLAYMASK;
tvis.item.state |= INDEXTOOVERLAYMASK(1); //1 is the index for the shared overlay image
}
HTREEITEM hItem = InsertItem(&tvis);
bool bChecked = false;
if (!pItem->m_sFQPath.empty()) {
string path = Text::fromT(pItem->m_sFQPath);
if( path[ path.length() -1 ] != PATH_SEPARATOR )
path += PATH_SEPARATOR;
bChecked = sp->shareFolder(path);
SetChecked(hItem, bChecked);
}
if(!bChecked)
SetHasSharedChildren(hItem);
return hItem;
}
void CWListView::OnBookmarkClear()
{
int nCurItem, nIndexOverlay;
nCurItem=getFirstSelectedRow();
if( m_nBookmarkCount>0 )
{
for( int i=0; i<m_listCtrl.GetItemCount(); i++ )
{
UINT nStateFlag=m_listCtrl.GetItemState( i, LVIS_OVERLAYMASK );
BOOL bChange=FALSE;
switch( nStateFlag )
{
case 512:
nIndexOverlay=0;
m_nBookmarkCount--;
bChange=TRUE;
break;
case 768:
nIndexOverlay=1;
m_nBookmarkCount--;
bChange=TRUE;
break;
}
if(bChange)
m_listCtrl.SetItemState(i,INDEXTOOVERLAYMASK(nIndexOverlay),
LVIS_OVERLAYMASK );
}
// redrawWindow();
RedrawWindow( NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASE );
//setListModified( TRUE ); // parce que les signets sont enregistrés
// dans le fichier | commentaire {{01}}
// 1er chiffre
}
}
void CMyTreeView::EnumObjects(HTREEITEM hParentItem, CShellFolder& cParentFolder, Cpidl& cpidlParent)
{
CEnumIDList cEnum;
if (SUCCEEDED(cParentFolder.EnumObjects(NULL, SHCONTF_FOLDERS | SHCONTF_INCLUDEHIDDEN, cEnum))) {
ULONG ulFetched = 1;
Cpidl cpidlRel;
//enumerate the item's PIDLs
while (S_OK == (cEnum.Next(1, cpidlRel, ulFetched)) && ulFetched) {
TVITEM tvItem = {0};
TVINSERTSTRUCT tvInsert = {0};
ULONG ulAttribs;
//fill in the TV_ITEM structure for this item
tvItem.mask = TVIF_PARAM | TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_CHILDREN;
//Store a pointer to the TreeItemData in the lParam and m_pItems
TreeItemData* pItem = new TreeItemData(cpidlParent, cpidlRel, cParentFolder);
tvItem.lParam = (LPARAM)pItem;
m_pItems.push_back(pItem);
//text and images are done on a callback basis
tvItem.pszText = LPSTR_TEXTCALLBACK;
tvItem.iImage = tvItem.iSelectedImage = I_IMAGECALLBACK;
//determine if the item has children or shared
ulAttribs = SFGAO_HASSUBFOLDER | SFGAO_FOLDER | SFGAO_SHARE;
cParentFolder.GetAttributesOf(1, cpidlRel, ulAttribs);
tvItem.cChildren = (ulAttribs & SFGAO_HASSUBFOLDER);
//determine if the item is shared
if (ulAttribs & SFGAO_SHARE) {
tvItem.mask |= TVIF_STATE;
tvItem.stateMask |= TVIS_OVERLAYMASK;
tvItem.state |= INDEXTOOVERLAYMASK(1); //1 is the index for the shared overlay image
}
//fill in the TV_INSERTSTRUCT structure for this item
tvInsert.item = tvItem;
tvInsert.hInsertAfter = TVI_LAST;
tvInsert.hParent = hParentItem;
InsertItem(tvInsert);
ulFetched = 0;
}
}
}
void CRasterResourceListCtrl::_PrepareLVITEM(LVITEM *pItem)
{
__super::_PrepareLVITEM(pItem);
// Say that we want to be called back for images.
pItem->mask |= LVIF_IMAGE;
pItem->iImage = I_IMAGECALLBACK;
const ResourceBlob *pData = (const ResourceBlob*)pItem->lParam;
if (pData)
{
// Add an overlay that indicates it is not the most recent.
if (!theApp._resourceRecency.IsResourceMostRecent(pData))
{
pItem->mask |= LVIF_STATE;
pItem->state = INDEXTOOVERLAYMASK(OVERLAYINDEX_UNUSED);
pItem->stateMask = LVIS_OVERLAYMASK;
}
}
}
static void sttTreeList_CreateItems_List(HTREELISTITEM hItem, LPARAM data)
{
TTreeList_Data *listData = (TTreeList_Data *)sttTreeList_GeWindowData((HWND)data);
if ((!listData->filter || (hItem->flags & TLIF_FILTERED)) && !(hItem->flags & TLIF_HASITEM) && !(hItem->flags & TLIF_ROOT)) {
LVITEM lvi = {0};
lvi.mask = LVIF_INDENT | LVIF_PARAM | LVIF_IMAGE | LVIF_TEXT | LVIF_STATE;
lvi.iIndent = hItem->indent;
lvi.lParam = (LPARAM)hItem;
lvi.pszText = hItem->text[0];
lvi.stateMask = LVIS_OVERLAYMASK|LVIS_STATEIMAGEMASK;
lvi.iImage = hItem->iIcon;
lvi.state =
INDEXTOSTATEIMAGEMASK(
((hItem->subItems.getCount() == 0) && !(hItem->flags & TLIF_FAKEPARENT)) ? 0 : 3) |
INDEXTOOVERLAYMASK(hItem->iOverlay);
int idx = ListView_InsertItem((HWND)data, &lvi);
for (int i = 1; i < hItem->text.getCount(); i++)
ListView_SetItemText((HWND)data, idx, i, hItem->text[i]);
} }
void CMyListCtrl::CheckItem(int nNewCheckedItem)
{
// reset if there is checked item
if (m_nCheckedItem != -1)
{
if (m_bStateIcons)
{
this->SetItemState(m_nCheckedItem,
INDEXTOSTATEIMAGEMASK(1), LVIS_STATEIMAGEMASK);
}
else
{
this->SetItemState(m_nCheckedItem,
INDEXTOSTATEIMAGEMASK(1),
LVIS_STATEIMAGEMASK | LVIS_OVERLAYMASK);
}
}
if (m_nCheckedItem == nNewCheckedItem)
{
m_nCheckedItem = -1;
}
else if ((m_nCheckedItem = nNewCheckedItem) != -1)
{
if (m_bStateIcons)
{
this->SetItemState(m_nCheckedItem,
INDEXTOSTATEIMAGEMASK(2), LVIS_STATEIMAGEMASK);
this->GetParent()->SetDlgItemTextW(IDC_ID,this->GetItemText(nNewCheckedItem,0));
this->GetParent()->SetDlgItemTextW(IDC_NAME,this->GetItemText(nNewCheckedItem,1));
this->GetParent()->SetDlgItemTextW(IDC_STATUS,this->GetItemText(nNewCheckedItem,3));
}
else
{
this->SetItemState(m_nCheckedItem,
INDEXTOSTATEIMAGEMASK(2) | INDEXTOOVERLAYMASK(1),
LVIS_STATEIMAGEMASK | LVIS_OVERLAYMASK);
}
}
}
void CRowListView::OnViewStateIcons()
{
m_bStateIcons =! m_bStateIcons;
CListCtrl& ListCtrl = GetListCtrl();
if (m_bStateIcons)
{
ListCtrl.SetImageList(&m_StateImageList, LVSIL_STATE);
ListCtrl.SetItemState(m_nCheckedItem, 0, LVIS_OVERLAYMASK);
}
else
{
ListCtrl.SetImageList(NULL,LVSIL_STATE);
if (m_nCheckedItem != -1)
{
ListCtrl.SetItemState(m_nCheckedItem,
INDEXTOOVERLAYMASK(1), LVIS_OVERLAYMASK);
}
}
}
void CLiveListCtrl::OnLvnGetdispinfoA(NMHDR *pNMHDR, LRESULT *pResult)
{
LVITEM& pDispInfo = reinterpret_cast<NMLVDISPINFO*>(pNMHDR)->item;
*pResult = 0;
if ( pDispInfo.iItem < 0 || pDispInfo.iItem >= (int)m_pIndex.size() )
return;
const CLiveItemPtr pItem = m_pIndex[ pDispInfo.iItem ];
if ( pDispInfo.mask & LVIF_TEXT )
{
if ( pDispInfo.iSubItem >= 0 && pDispInfo.iSubItem < pItem->m_pColumn.GetSize() )
{
CString sText = pItem->m_pColumn.GetAt( pDispInfo.iSubItem );
WideCharToMultiByte( CP_ACP, 0, sText, -1,
(LPSTR)pDispInfo.pszText, pDispInfo.cchTextMax, NULL, NULL );
}
}
if ( pDispInfo.mask & LVIF_IMAGE )
{
if ( pDispInfo.iSubItem >= 0 && pDispInfo.iSubItem < pItem->m_pColumn.GetSize() )
{
pDispInfo.iImage = pItem->m_nImage[ pDispInfo.iSubItem ];
}
}
if ( pDispInfo.mask & LVIF_STATE )
{
pDispInfo.state = INDEXTOOVERLAYMASK( pItem->m_nMaskOverlay ) |
INDEXTOSTATEIMAGEMASK( pItem->m_nMaskState );
}
if ( pDispInfo.mask & LVFI_PARAM )
{
pDispInfo.lParam = pItem->m_nParam;
}
}
HTREEITEM FolderView::InsertItem(ShellFolder* shl_folder, HTREEITEM parent, HTREEITEM insert_after)
{
if (!shl_folder->GetFullIDL())
return NULL;
bool is_link= false;
TCHAR name[MAX_PATH + MAX_PATH];
if (!shl_folder->GetName(name))
*name = NULL;
int iconIndex= shl_folder->GetIconIndex(FALSE);
int selectedIconIndex= shl_folder->GetSelectedIconIndex(FALSE);
shl_folder->ReleaseFullIDL();
if (iconIndex < 0)
iconIndex = 0;
if (selectedIconIndex < 0)
selectedIconIndex = iconIndex;
TVINSERTSTRUCT tvis;
tvis.hParent = parent;
tvis.hInsertAfter = insert_after;
tvis.item.mask = TVIF_CHILDREN | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM | TVIF_TEXT | TVIF_STATE;
tvis.item.pszText = name;
tvis.item.iImage = iconIndex;
tvis.item.state = 0;
tvis.item.iSelectedImage = selectedIconIndex;
tvis.item.lParam = reinterpret_cast<LPARAM>(shl_folder);
tvis.item.cChildren = /*shl_folder->ContainFileSystemFolder() &&*/ shl_folder->HasSubFolder() ? 1 : 0;
if (shl_folder->IsLink())
{
tvis.item.state |= INDEXTOOVERLAYMASK(2);
tvis.item.stateMask |= TVIS_OVERLAYMASK;
}
return tree_->InsertItem(&tvis);
}
void CProcessTemplate::addItemToListControl(CListCtrl & clc, const CProcessSequence* pSeq)
{
LV_ITEM lvi;
lvi.mask = LVIF_TEXT | LVIF_PARAM |LVIF_STATE; //; | LVIF_STATE;
lvi.pszText = LPSTR_TEXTCALLBACK; // app. maintains text
lvi.iImage = 1; // image list index
lvi.iSubItem = 0;
lvi.iItem = 999; // make it the last
lvi.lParam = (LPARAM) this;
if(!getCanAddToSeq(pSeq))
lvi.state = INDEXTOOVERLAYMASK(1); // draw the 'not' icon over it
//lvi.state = LVIS_CUT;
else
{ lvi.state = 0; // getStateValue();
lvi.stateMask = LVIS_OVERLAYMASK;
ASSERTX(-1 != clc.InsertItem(&lvi)); // only insert the availible ones
}
//lvi.stateMask = LVIS_CUT;
//ASSERTX(-1 != clc.InsertItem(&lvi));
}
void CDownloadClientsCtrl::DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct)
{
if( !theApp.emuledlg->IsRunning() )
return;
if (!lpDrawItemStruct->itemData)
return;
CDC* odc = CDC::FromHandle(lpDrawItemStruct->hDC);
BOOL bCtrlFocused = ((GetFocus() == this ) || (GetStyle() & LVS_SHOWSELALWAYS));
if (lpDrawItemStruct->itemState & ODS_SELECTED) {
if(bCtrlFocused)
odc->SetBkColor(m_crHighlight);
else
odc->SetBkColor(m_crNoHighlight);
}
else
odc->SetBkColor(GetBkColor());
const CUpDownClient* client = (CUpDownClient*)lpDrawItemStruct->itemData;
CMemDC dc(odc, &lpDrawItemStruct->rcItem);
CFont* pOldFont = dc.SelectObject(GetFont());
CRect cur_rec(lpDrawItemStruct->rcItem);
COLORREF crOldTextColor = dc.SetTextColor((lpDrawItemStruct->itemState & ODS_SELECTED) ? m_crHighlightText : m_crWindowText);
if(client->GetSlotNumber() > theApp.uploadqueue->GetActiveUploadsCount()) {
dc.SetTextColor(::GetSysColor(COLOR_GRAYTEXT));
}
int iOldBkMode;
if (m_crWindowTextBk == CLR_NONE){
DefWindowProc(WM_ERASEBKGND, (WPARAM)(HDC)dc, 0);
iOldBkMode = dc.SetBkMode(TRANSPARENT);
}
else
iOldBkMode = OPAQUE;
CHeaderCtrl *pHeaderCtrl = GetHeaderCtrl();
int iCount = pHeaderCtrl->GetItemCount();
cur_rec.right = cur_rec.left - 8;
cur_rec.left += 4;
CString Sbuffer;
for(int iCurrent = 0; iCurrent < iCount; iCurrent++){
int iColumn = pHeaderCtrl->OrderToIndex(iCurrent);
if( !IsColumnHidden(iColumn) ){
cur_rec.right += GetColumnWidth(iColumn);
switch(iColumn){
case 0:{
uint8 image;
if (client->credits != NULL){
if (client->IsFriend())
image = 4;
else if (client->GetClientSoft() == SO_EDONKEYHYBRID){
//==> Xman CreditSystem [shadow2004]
if (client->credits->GetScoreRatio(client/*->GetIP()*/) > 1)
image = 8;
else
image = 7;
}
else if (client->GetClientSoft() == SO_MLDONKEY){
if (client->credits->GetScoreRatio(client/*->GetIP()*/) > 1)
image = 6;
else
image = 5;
}
else if (client->GetClientSoft() == SO_SHAREAZA){
if(client->credits->GetScoreRatio(client/*->GetIP()*/) > 1)
image = 10;
else
image = 9;
}
else if (client->GetClientSoft() == SO_AMULE){
if(client->credits->GetScoreRatio(client/*->GetIP()*/) > 1)
image = 12;
else
image = 11;
}
else if (client->GetClientSoft() == SO_LPHANT){
if(client->credits->GetScoreRatio(client/*->GetIP()*/) > 1)
image = 14;
else
image = 13;
}
else if (client->ExtProtocolAvailable()){
if(client->credits->GetScoreRatio(client/*->GetIP()*/) > 1)
image = 3;
else
image = 1;
}
else{
if (client->credits->GetScoreRatio(client/*->GetIP()*/) > 1)
//<== Xman CreditSystem [shadow2004]
image = 2;
else
image = 0;
}
}
else
image = 0;
POINT point = {cur_rec.left, cur_rec.top+1};
m_ImageList.Draw(dc,image, point, ILD_NORMAL | ((client->Credits() && client->Credits()->GetCurrentIdentState(client->GetIP()) == IS_IDENTIFIED) ? INDEXTOOVERLAYMASK(1) : 0));
Sbuffer = client->GetUserName();
cur_rec.left +=20;
dc.DrawText(Sbuffer,Sbuffer.GetLength(),&cur_rec,DLC_DT_TEXT);
cur_rec.left -=20;
break;
}
case 1:
Sbuffer.Format(_T("%s"), client->GetClientSoftVer());
break;
case 2:
Sbuffer.Format(_T("%s"), client->GetRequestFile()->GetFileName());
break;
case 3:
Sbuffer=CastItoXBytes( (float)client->GetDownloadDatarate() , false, true);
dc.DrawText(Sbuffer,Sbuffer.GetLength(),&cur_rec, DLC_DT_TEXT | DT_RIGHT);
break;
case 4:
cur_rec.bottom--;
cur_rec.top++;
client->DrawStatusBar(dc, &cur_rec, false);
cur_rec.bottom++;
cur_rec.top--;
break;
case 5:
if(client->Credits() && client->GetSessionDown() < client->credits->GetDownloadedTotal())
Sbuffer.Format(_T("%s (%s)"), CastItoXBytes(client->GetSessionDown()), CastItoXBytes(client->credits->GetDownloadedTotal()));
else
Sbuffer.Format(_T("%s"), CastItoXBytes(client->GetSessionDown()));
break;
case 6:
if(client->Credits() && client->GetSessionUp() < client->credits->GetUploadedTotal())
Sbuffer.Format(_T("%s (%s)"), CastItoXBytes(client->GetSessionUp()), CastItoXBytes(client->credits->GetUploadedTotal()));
else
Sbuffer.Format(_T("%s"), CastItoXBytes(client->GetSessionUp()));
break;
case 7:
switch(client->GetSourceFrom()){
case SF_SERVER:
Sbuffer = _T("eD2K Server");
break;
case SF_KADEMLIA:
Sbuffer = GetResString(IDS_KADEMLIA);
break;
case SF_SOURCE_EXCHANGE:
Sbuffer = GetResString(IDS_SE);
break;
case SF_PASSIVE:
Sbuffer = GetResString(IDS_PASSIVE);
break;
case SF_LINK:
Sbuffer = GetResString(IDS_SW_LINK);
break;
default:
Sbuffer = GetResString(IDS_UNKNOWN);
break;
}
break;
}
if( iColumn != 4 && iColumn != 0 && iColumn != 3 && iColumn != 11)
dc.DrawText(Sbuffer,Sbuffer.GetLength(),&cur_rec,DLC_DT_TEXT);
cur_rec.left += GetColumnWidth(iColumn);
}
}
//draw rectangle around selected item(s)
if (lpDrawItemStruct->itemState & ODS_SELECTED)
{
RECT outline_rec = lpDrawItemStruct->rcItem;
outline_rec.top--;
outline_rec.bottom++;
dc.FrameRect(&outline_rec, &CBrush(GetBkColor()));
outline_rec.top++;
outline_rec.bottom--;
outline_rec.left++;
outline_rec.right--;
if (bCtrlFocused)
dc.FrameRect(&outline_rec, &CBrush(m_crFocusLine));
else
dc.FrameRect(&outline_rec, &CBrush(m_crNoFocusLine));
}
if (m_crWindowTextBk == CLR_NONE)
dc.SetBkMode(iOldBkMode);
dc.SelectObject(pOldFont);
dc.SetTextColor(crOldTextColor);
}
