MaterialTreeView.cpp

Go to the documentation of this file.

/*
===========================================================================

Doom 3 GPL Source Code
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company. 

This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).  

Doom 3 Source Code is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

Doom 3 Source Code is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Doom 3 Source Code.  If not, see <http://www.gnu.org/licenses/>.

In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code.  If not, please request a copy in writing from id Software at the address below.

If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.

===========================================================================
*/
#include "../../idlib/precompiled.h"
#pragma hdrstop

#include "MaterialTreeView.h"

#define IMAGE_FOLDER                            0
#define IMAGE_FILE                                      1
#define IMAGE_MATERIAL                          2
#define IMAGE_MATERIAL_FOLDER           3
#define IMAGE_FILE_MOD                          4
#define IMAGE_MATERIAL_MOD                      5
#define IMAGE_MATERIAL_MOD_APPLY        6

#define HOVER_EXPAND_DELAY 500

#define MSG_RENAME_FOLDER_COMPLETE (WM_USER + 1000)
#define MSG_RENAME_MATERIAL_COMPLETE (WM_USER + 1001)

IMPLEMENT_DYNCREATE(MaterialTreeView, CTreeView)

BEGIN_MESSAGE_MAP(MaterialTreeView, CTreeView)
        ON_WM_CREATE()
        ON_NOTIFY_REFLECT(TVN_SELCHANGED,               OnTvnSelchanged)
        ON_NOTIFY_REFLECT(TVN_BEGINLABELEDIT,   OnTvnBeginlabeledit)
        ON_NOTIFY_REFLECT(TVN_ENDLABELEDIT,             OnTvnEndlabeledit)
        ON_WM_CONTEXTMENU()
        ON_NOTIFY_REFLECT(NM_RCLICK,                    OnNMRclick)
        ON_WM_CHAR()
        ON_NOTIFY_REFLECT(TVN_BEGINDRAG,                OnTvnBegindrag)
        ON_WM_MOUSEMOVE()
        ON_WM_LBUTTONUP()

        ON_COMMAND(ID_POPUP_APPLYMATERIAL,              OnApplyMaterial)
        ON_COMMAND(ID_POPUP_APPLYFILE,                  OnApplyFile)
        ON_COMMAND(ID_POPUP_APPLYALL,                   OnApplyAll)
        ON_COMMAND(ID_POPUP_SAVEMATERIAL,               OnSaveMaterial)
        ON_COMMAND(ID_POPUP_SAVEFILE,                   OnSaveFile)
        ON_COMMAND(ID_POPUP_SAVEALL,                    OnSaveAll)
        ON_COMMAND(ID_POPUP_RENAMEMATERIAL,             OnRenameMaterial)
        ON_COMMAND(ID_POPUP_ADDMATERIAL,                OnAddMaterial)
        ON_COMMAND(ID_POPUP_ADDFOLDER,                  OnAddFolder)
        ON_COMMAND(ID_POPUP_DELETEMATERIAL,             OnDeleteMaterial)
        ON_COMMAND(ID_POPUP_RELOADFILE,                 OnReloadFile)

        ON_COMMAND(ID_POPUP_CUT,                                OnCut)
        ON_COMMAND(ID_POPUP_COPY,                               OnCopy)
        ON_COMMAND(ID_POPUP_PASTE,                              OnPaste)

        ON_MESSAGE(MSG_RENAME_FOLDER_COMPLETE, OnRenameFolderComplete)
        ON_MESSAGE(MSG_RENAME_MATERIAL_COMPLETE, OnRenameMaterialComplete)      
END_MESSAGE_MAP()

MaterialTreeView::MaterialTreeView() {
        treeWithFile = false;
        bDragging = false;
        hoverItem = NULL;
        internalChange = false;
}

MaterialTreeView::~MaterialTreeView() {
}

void MaterialTreeView::InitializeMaterialList(bool includeFile, const char* filename) {

        treeWithFile = includeFile;

        CTreeCtrl& tree = GetTreeCtrl();

        tree.DeleteAllItems();
        quickTree.Clear();
        materialToTree.Clear();
        fileToTree.Clear();

        BuildMaterialList(includeFile, filename);
}

void MaterialTreeView::BuildMaterialList(bool includeFile, const char* filename) {

        CTreeCtrl& tree = GetTreeCtrl();

        idStrList list(1024);

        int count = declManager->GetNumDecls( DECL_MATERIAL );
        if (count > 0) {
                for (int i = 0; i < count; i++) {
                        const idMaterial        *mat = declManager->MaterialByIndex(i, false);

                        if(filename && strcmp(filename, mat->GetFileName())) {
                                continue;
                        }

                        idStr temp;

                        //Do Not Include Implicit File Definitions
                        idStr filename = mat->GetFileName();
                        if(!filename.Icmp("<implicit file>")) {
                                continue;
                        }

                        if(filename.Find("def") != -1) {
                                int x = 0;
                        }

                        if(includeFile) {
                                filename.StripPath();
                                temp = idStr(mat->GetFileName()) + "/" + idStr(mat->GetName()) + "|" + filename;
                        } else {
                                temp = mat->GetName();
                        }

                        list.Append(temp);
                }
                AddStrList(NULL, &list, includeFile);
        }
}

void MaterialTreeView::MV_OnMaterialChange(MaterialDoc* pMaterial) {

        CTreeCtrl& tree = GetTreeCtrl();

        //When a material changes place an asterik next to the material and the file
        HTREEITEM* materialItem = NULL;
        materialToTree.Get(pMaterial->name, &materialItem);


        if(!materialItem)
                return;

        tree.SetItemImage(*materialItem, IMAGE_MATERIAL_MOD_APPLY, IMAGE_MATERIAL_MOD_APPLY);


        if(treeWithFile) {
                HTREEITEM* fileItem = NULL;
                idStr file = pMaterial->renderMaterial->GetFileName();

                //common->Printf("Filename = %s\n", file.c_str());

                if(fileToTree.Get(file, &fileItem)){
                        //common->Printf("Found: %d\n", *fileItem);
                        tree.SetItemImage(*fileItem, IMAGE_FILE_MOD, IMAGE_FILE_MOD);
                }
        }
}

void MaterialTreeView::MV_OnMaterialApply(MaterialDoc* pMaterial) {
        CTreeCtrl& tree = GetTreeCtrl();

        //When a material is applied then just change the image to material modified
        HTREEITEM* materialItem = NULL;
        materialToTree.Get(pMaterial->name, &materialItem);

        if(!materialItem)
                return;

        tree.SetItemImage(*materialItem, IMAGE_MATERIAL_MOD, IMAGE_MATERIAL_MOD);
}

void MaterialTreeView::MV_OnMaterialSaved(MaterialDoc* pMaterial) {
        CTreeCtrl& tree = GetTreeCtrl();

        //Remove the asterik
        HTREEITEM* materialItem = NULL;
        materialToTree.Get(pMaterial->name, &materialItem);

        //We will get this message for a delete file so the material will not be in the tree
        if(materialItem) {
                tree.SetItemImage(*materialItem, IMAGE_MATERIAL, IMAGE_MATERIAL);
        }

        //Check if the file is completely saved
        if(treeWithFile) {

                if(!materialDocManager->IsFileModified(pMaterial->renderMaterial->GetFileName())) {

                        HTREEITEM* fileItem = NULL;
                        idStr file = pMaterial->renderMaterial->GetFileName();

                        if(fileToTree.Get(file, &fileItem)) {
                                tree.SetItemImage(*fileItem, IMAGE_FILE, IMAGE_FILE);
                        }
                }
        }
}

void MaterialTreeView::MV_OnMaterialAdd(MaterialDoc* pMaterial) {

        idStrList list(1024);

        idMaterial      *mat = pMaterial->renderMaterial;
        idStr temp;

        if(treeWithFile) {
                idStr filename = mat->GetFileName();
                filename.StripPath();
                temp = idStr(mat->GetFileName()) + "/" + idStr(mat->GetName()) + "|" + filename;
        } else {
                temp = mat->GetName();
        }

        list.Append(temp);
        AddStrList(NULL, &list, treeWithFile);  

        //Keep the items sorted
        HTREEITEM* item = NULL;
        materialToTree.Get(pMaterial->name, &item);
        if(*item) {
                CTreeCtrl& tree = GetTreeCtrl();
                HTREEITEM parent = tree.GetParentItem(*item);
                tree.SortChildren(parent);
        }

        MV_OnMaterialChange(pMaterial);
}

void MaterialTreeView::MV_OnMaterialDelete(MaterialDoc* pMaterial) {

        //Our doc told us a material has been deleted. Lets find and remove the item from our tree
        HTREEITEM* materialItem = NULL;
        materialToTree.Get(pMaterial->name, &materialItem);

        CTreeCtrl& tree = GetTreeCtrl();
        tree.DeleteItem(*materialItem);

        //Remove our old quick lookup value
        materialToTree.Remove(pMaterial->name.c_str());
}

void MaterialTreeView::MV_OnMaterialNameChanged(MaterialDoc* pMaterial, const char* oldName) {

        CTreeCtrl& tree = GetTreeCtrl();

        if(!internalChange) {
                
                //Delete the old tree item
                HTREEITEM* item = NULL;
                materialToTree.Get(oldName, &item);
                CTreeCtrl& tree = GetTreeCtrl();
                HTREEITEM tempItem = *item;
                CleanLookupTrees(tempItem);
                tree.DeleteItem(tempItem);
                

                //Now add it back
                idStrList list(1024);
                idMaterial      *mat = pMaterial->renderMaterial;
                idStr temp;

                if(treeWithFile) {
                        idStr filename = mat->GetFileName();
                        filename.StripPath();
                        temp = idStr(mat->GetFileName()) + "/" + idStr(mat->GetName()) + "|" + filename;
                } else {
                        temp = mat->GetName();
                }

                list.Append(temp);
                AddStrList(NULL, &list, treeWithFile);  

                //Keep the items sorted
                //item = NULL;
                materialToTree.Get(pMaterial->name.c_str(), &item);
                if(*item) {
                        CTreeCtrl& tree = GetTreeCtrl();
                        HTREEITEM parent = tree.GetParentItem(*item);
                        tree.SortChildren(parent);
                }

                MV_OnMaterialChange(pMaterial);

        }
}

void MaterialTreeView::MV_OnFileReload(const char* filename) {

        HTREEITEM* fileItem = NULL;
        fileToTree.Get(filename, &fileItem);

        HTREEITEM item = *fileItem;

        CTreeCtrl& tree = GetTreeCtrl();
        CleanLookupTrees(item);
        tree.DeleteItem(item);

        BuildMaterialList(treeWithFile, filename);

        //Resort the parent to make sure the file is back where it was
        HTREEITEM* newItem = NULL;
        fileToTree.Get(filename, &newItem);
        if(*newItem) {
                CTreeCtrl& tree = GetTreeCtrl();
                HTREEITEM parent = tree.GetParentItem(*newItem);
                tree.SortChildren(parent);
        }
}

bool MaterialTreeView::CanCopy() {

        CTreeCtrl& tree = GetTreeCtrl();

        HTREEITEM item = tree.GetSelectedItem();
        DWORD itemType = tree.GetItemData(item);

        if(item && itemType == TYPE_MATERIAL) {
                return true;
        } else {
                return false;
        }
}

bool MaterialTreeView::CanPaste() {
        return materialDocManager->IsCopyMaterial();
}

bool MaterialTreeView::CanCut() {

        CTreeCtrl& tree = GetTreeCtrl();

        HTREEITEM item = tree.GetSelectedItem();
        DWORD itemType = tree.GetItemData(item);

        if(item && itemType == TYPE_MATERIAL) {
                return true;
        } else {
                return false;
        }
}

bool MaterialTreeView::CanDelete() {

        CTreeCtrl& tree = GetTreeCtrl();

        HTREEITEM item = tree.GetSelectedItem();
        DWORD itemType = tree.GetItemData(item);

        if(itemType == TYPE_MATERIAL_FOLDER || itemType == TYPE_MATERIAL) {
                return true;
        }

        return false;
}

bool MaterialTreeView::CanRename() {

        CTreeCtrl& tree = GetTreeCtrl();

        HTREEITEM item = tree.GetSelectedItem();
        DWORD itemType = tree.GetItemData(item);

        if(itemType == TYPE_MATERIAL_FOLDER || itemType == TYPE_MATERIAL) {
                return true;
        }
        return false;
}

bool MaterialTreeView::CanSaveFile() {

        CTreeCtrl& tree = GetTreeCtrl();
        HTREEITEM item = tree.GetSelectedItem();

        idStr filename;
        if(item && GetFileName(item, filename)) {
                if(materialDocManager->IsFileModified(filename.c_str()))
                        return true;
                else
                        return false;
        } else {
                return false;
        }
}

idStr MaterialTreeView::GetSaveFilename() {

        CTreeCtrl& tree = GetTreeCtrl();
        HTREEITEM item = tree.GetSelectedItem();

        idStr filename = "";
        if(item) {
                if(!GetFileName(item, filename)) {
                        filename = "";
                }
        }

        return filename;
}

bool MaterialTreeView::FindNextMaterial(MaterialSearchData_t* searchData) {

        CTreeCtrl& tree = GetTreeCtrl();

        HTREEITEM selected = tree.GetSelectedItem();
        if(!selected) {
                selected = tree.GetRootItem();
                if(!selected) {
                        return false;
                }
        }

        //Make sure we are in a file
        if(searchData->searchScope == 0) {
                DWORD type = tree.GetItemData(selected);
                if(type == TYPE_FOLDER || type == TYPE_ROOT)
                        return false;
        }

        HTREEITEM search =selected;

        while((search = GetNextSeachItem(search, (searchData->searchScope == 0))) != NULL) {
                HTREEITEM found = FindNextMaterial(search, searchData);
                if(found) {
                        tree.SelectItem(found);
                        return true;
                }
        }
        return false;
}

HTREEITEM MaterialTreeView::FindNextMaterial(HTREEITEM item, MaterialSearchData_t* searchData) {

        CTreeCtrl& tree = GetTreeCtrl();
        DWORD type = tree.GetItemData(item);

        if(type == TYPE_MATERIAL) {
                //check the tree name first
                idStr itemName = tree.GetItemText(item);
                int findPos = itemName.Find(searchData->searchText, false);
                if(findPos != -1) {
                        //Todo: Include match whole word
                        return item;
                }

                if(!searchData->nameOnly) {
                        //Check the material
                        idStr materialName = GetMediaPath(item, TYPE_MATERIAL);
                        if(materialDocManager->FindMaterial(materialName, searchData, false)) {
                                return item;
                        }
                }
        } else {
                //Just check the tree name
                idStr itemName = tree.GetItemText(item);

                int findPos = itemName.Find(searchData->searchText, false);
                if(findPos != -1) {
                        //Todo: Include match whole word
                        return item;
                }
        }
        return NULL;
}

HTREEITEM MaterialTreeView::GetNextSeachItem(HTREEITEM item, bool stayInFile) {
        CTreeCtrl& tree = GetTreeCtrl();

        HTREEITEM nextItem = NULL;

        //Check our children
        if(tree.ItemHasChildren(item)) {
                nextItem = tree.GetChildItem(item);
                return nextItem;
        }

        //Check our siblings
        nextItem = tree.GetNextSiblingItem(item);
        if(nextItem) {
                return nextItem;
        }

        //Check our parents next sibiling
        HTREEITEM parent = item;
        while((parent = tree.GetParentItem(parent)) != NULL) {
                DWORD parType = tree.GetItemData(parent);
                if(stayInFile && parType == TYPE_FILE)
                        break;

                HTREEITEM sib = tree.GetNextSiblingItem(parent);
                if(sib) {
                        nextItem = sib;
                        break;
                }
        }
        return nextItem;
}

void  MaterialTreeView::DeleteFolder(HTREEITEM item, bool addUndo) {

        CTreeCtrl& tree = GetTreeCtrl();

        idList<MaterialTreeItem_t> materialsToDelete;

        //Get the complete list of materials to delete
        GetMaterialPaths(item, &materialsToDelete);

        idStrList affectedMaterials;

        //Now delete the materials
        for(int i = 0; i < materialsToDelete.Num(); i++) {

                affectedMaterials.Append(materialsToDelete[i].materialName);

                const idMaterial* material = declManager->FindMaterial(materialsToDelete[i].materialName);

                MaterialDoc* pMaterial = NULL;
                pMaterial = materialDocManager->CreateMaterialDoc(const_cast<idMaterial *>(material));
                materialDocManager->DeleteMaterial(pMaterial, false);
        }

        //Make our undo modifier
        if(addUndo) {
                DeleteMaterialFolderModifier* mod = new DeleteMaterialFolderModifier(materialDocManager, tree.GetItemText(item), this, tree.GetParentItem(item), &affectedMaterials);
                materialDocManager->AddMaterialUndoModifier(mod);
        }


        //Now clean up the folders and quicktree
        CleanLookupTrees(item);

        //Remove any folders that were there
        tree.DeleteItem(item);
}

HTREEITEM MaterialTreeView::AddFolder(const char* name, HTREEITEM parent) {

        CTreeCtrl& tree = GetTreeCtrl();

        HTREEITEM newItem = tree.InsertItem(name, parent);
        tree.SetItemImage(newItem, IMAGE_MATERIAL_FOLDER, IMAGE_MATERIAL_FOLDER);
        tree.SetItemData(newItem, TYPE_MATERIAL_FOLDER);
        tree.Expand(newItem, TVE_EXPAND); 

        //Make sure the tree is still sorted
        tree.SortChildren(parent);

        //Build the entire path to this item for the quicktree
        idStr qt = GetQuicktreePath(newItem);
        quickTree.Set(qt, newItem);

        return newItem;
}

void MaterialTreeView::RenameFolder(HTREEITEM item, const char* name) {

        CTreeCtrl& tree = GetTreeCtrl();

        //Clean up the quicktree with the current tree before we allow the edit to commit
        CleanLookupTrees(item);

        //Store some data so the we can make the appropriate changes after the commit
        renamedFolder = item;

        affectedMaterials.Clear();
        GetMaterialPaths(renamedFolder, &affectedMaterials);

        tree.SetItemText(item, name);

        PostMessage(MSG_RENAME_FOLDER_COMPLETE); 
}

BOOL MaterialTreeView::PreTranslateMessage(MSG* pMsg) {

        CTreeCtrl& tree = GetTreeCtrl();
        if (pMsg->hwnd == tree.GetSafeHwnd()) {

                if (pMsg->message == WM_KEYDOWN && pMsg->wParam == VK_DELETE) {
                        OnDeleteMaterial();
                        return TRUE;
                }
        }
        return FALSE;
}

int MaterialTreeView::OnCreate(LPCREATESTRUCT lpCreateStruct) {

        lpCreateStruct->style |= TVS_HASLINES | TVS_HASBUTTONS | TVS_LINESATROOT | TVS_EDITLABELS | TVS_SHOWSELALWAYS | TVS_INFOTIP;
        if (CTreeView::OnCreate(lpCreateStruct) == -1)
                return -1;

        CTreeCtrl& tree = GetTreeCtrl();
        m_image.Create(IDB_ME_TREEBITMAP, 16, 1, RGB(255, 255, 255));
        tree.SetImageList(&m_image, TVSIL_NORMAL);
        
        return 0;
}

void MaterialTreeView::OnTvnSelchanged(NMHDR *pNMHDR, LRESULT *pResult) {
        
        LPNMTREEVIEW pNMTreeView = reinterpret_cast<LPNMTREEVIEW>(pNMHDR);
        
        if(pNMTreeView->itemNew.hItem) {
                CTreeCtrl& tree = GetTreeCtrl();

                DWORD type = tree.GetItemData(pNMTreeView->itemNew.hItem);
                if(type == TYPE_MATERIAL) {
                        idStr mediaName = GetMediaPath(pNMTreeView->itemNew.hItem, type);
                        const idMaterial* material = declManager->FindMaterial(mediaName);
                        
                        materialDocManager->SetSelectedMaterial(const_cast<idMaterial*>(material));
                        
                } else {
                        
                        materialDocManager->SetSelectedMaterial(NULL);
                }

        } else {
                
                materialDocManager->SetSelectedMaterial(NULL);
        }

        *pResult = 0;
}

void MaterialTreeView::OnTvnBeginlabeledit(NMHDR *pNMHDR, LRESULT *pResult) {
        
        LPNMTVDISPINFO pTVDispInfo = reinterpret_cast<LPNMTVDISPINFO>(pNMHDR);

        CTreeCtrl& tree = GetTreeCtrl();
        DWORD type = tree.GetItemData(pTVDispInfo->item.hItem);

        //Only allow renaming of materials and material folders
        if(type == TYPE_MATERIAL || type == TYPE_MATERIAL_FOLDER) {
                *pResult = 0;
        } else {
                *pResult = 1;
        }
}

void MaterialTreeView::OnTvnEndlabeledit(NMHDR *pNMHDR, LRESULT *pResult) {

        LPNMTVDISPINFO pTVDispInfo = reinterpret_cast<LPNMTVDISPINFO>(pNMHDR);

        *pResult = 0;

        if(pTVDispInfo->item.pszText) {
                
                //Convert any edited text to lower case to keep the name canonical
                idStr newLabel = pTVDispInfo->item.pszText;
                newLabel.ToLower();
                strncpy( pTVDispInfo->item.pszText, newLabel.c_str(), pTVDispInfo->item.cchTextMax);

                CTreeCtrl& tree = GetTreeCtrl();
                DWORD type = tree.GetItemData(pTVDispInfo->item.hItem);

                if(type == TYPE_MATERIAL) {

                        MaterialDoc* pMaterial = materialDocManager->GetCurrentMaterialDoc();

                        //Remove our old quick lookup value
                        materialToTree.Remove(pMaterial->name.c_str());

                        //Generate the new name
                        idStr material;
                        HTREEITEM parent = tree.GetParentItem(pTVDispInfo->item.hItem);
                        DWORD parentType = tree.GetItemData(parent);
                        if(parentType == TYPE_MATERIAL_FOLDER) {
                                //Need to include the material folder
                                material = GetMediaPath(parent, TYPE_MATERIAL_FOLDER);
                                material += "/";
                        }

                        material += pTVDispInfo->item.pszText;

                        if(declManager->FindMaterial(material, false)) {
                                //Can't rename because it conflicts with an existing file
                                MessageBox("Unable to rename material because it conflicts with another material", "Error");
                        } else {
                                //Add it to our quick lookup
                                materialToTree.Set(material, pTVDispInfo->item.hItem);

                                //Finally make the change
                                internalChange = true;
                                pMaterial->SetMaterialName(material);
                                internalChange = false;

                                renamedFolder = pTVDispInfo->item.hItem;
                                PostMessage(MSG_RENAME_MATERIAL_COMPLETE); 

                                *pResult = 1;
                        }

                } else if (type == TYPE_MATERIAL_FOLDER) {

                        //Clean up the quicktree with the current tree before we allow the edit to commit
                        CleanLookupTrees(pTVDispInfo->item.hItem);

                        //Store some data so the we can make the appropriate changes after the commit
                        renamedFolder = pTVDispInfo->item.hItem;

                        affectedMaterials.Clear();
                        GetMaterialPaths(renamedFolder, &affectedMaterials);

                        PostMessage(MSG_RENAME_FOLDER_COMPLETE); 

                        RenameMaterialFolderModifier* mod = new RenameMaterialFolderModifier(materialDocManager, pTVDispInfo->item.pszText, this, pTVDispInfo->item.hItem, tree.GetItemText(pTVDispInfo->item.hItem));
                        materialDocManager->AddMaterialUndoModifier(mod);

                        *pResult = 1;
                }
        }
}

void MaterialTreeView::OnContextMenu(CWnd* pWnd, CPoint point)
{
        ScreenToClient (&point);
        PopupMenu (&point);
}

void MaterialTreeView::OnNMRclick(NMHDR *pNMHDR, LRESULT *pResult)
{
        CTreeCtrl& tree = GetTreeCtrl();

        DWORD dwPos = GetMessagePos();

        CPoint pt( LOWORD( dwPos ), HIWORD ( dwPos ) );

        CPoint spt = pt;
        tree.ScreenToClient( &spt );

        UINT test;
        HTREEITEM item = tree.HitTest( spt, &test );

        if ( item != NULL  )
        {
                if ( test & TVHT_ONITEM )
                {
                        //Select the item
                        tree.SelectItem(item);
                        OnContextMenu( this, pt );
                }
        }

        *pResult = 0;
}

void MaterialTreeView::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags)
{
        if(nChar == 3 && GetKeyState(VK_CONTROL)) {
                OnCopy();
        }

        if(nChar == 22 && GetKeyState(VK_CONTROL)) {
                OnPaste();
        }

        if(nChar == 24 && GetKeyState(VK_CONTROL)) {
                OnCut();
        }

        CTreeView::OnChar(nChar, nRepCnt, nFlags);
}

void MaterialTreeView::OnTvnBegindrag(NMHDR *pNMHDR, LRESULT *pResult)
{
        LPNMTREEVIEW pNMTreeView = reinterpret_cast<LPNMTREEVIEW>(pNMHDR);

        CTreeCtrl& tree = GetTreeCtrl();

        HTREEITEM selecteditem = tree.GetSelectedItem();

        //Check to see if the are clicking on an item
        UINT flags;
        HTREEITEM item = tree.HitTest(pNMTreeView->ptDrag, &flags);

        if(item && (TVHT_ONITEM & flags)) {
                if(item != selecteditem) {
                        tree.SelectItem(item);
                }
        }

        DWORD itemType = tree.GetItemData(item);

        if(itemType == TYPE_MATERIAL) {

                //Create the drag image
                dragImage = tree.CreateDragImage(item);
                dragImage->BeginDrag(0, CPoint (8, 8));
                dragImage->DragEnter(GetDesktopWindow(), pNMTreeView->ptDrag);

                //Drag is in progress
                bDragging = true;

                dragItem = item;

                //Capture the messages
                SetCapture();
        }

        *pResult = 0;
}

void MaterialTreeView::OnMouseMove(UINT nFlags, CPoint point) {
        if( bDragging ) {
                CTreeCtrl& tree = GetTreeCtrl();

                dropPoint = point;
                ClientToScreen(&dropPoint);

                //Move the drag image
                dragImage->DragMove(dropPoint);
                dragImage->DragShowNolock(FALSE);

                dragImage->DragShowNolock(TRUE);
        }

        if(bDragging) {
                //Test the hover item

                CTreeCtrl& tree = GetTreeCtrl();

                CPoint point;
                GetCursorPos(&point);
                ScreenToClient(&point);

                UINT flags;
                HTREEITEM item = tree.HitTest(point, &flags);
                if(item && (TVHT_ONITEM & flags)) {
                        if(item != hoverItem) {
                                hoverItem = item;
                                hoverStartTime = timeGetTime();
                        } else {
                                DWORD currentTime = timeGetTime();
                                if(currentTime - hoverStartTime > HOVER_EXPAND_DELAY) {

                                        UINT state = tree.GetItemState(hoverItem, TVIS_EXPANDED);
                                        if(state != TVIS_EXPANDED && tree.ItemHasChildren(hoverItem)) {
                                                tree.Expand(hoverItem, TVE_EXPAND);
                                        }

                                }
                        }
                }
        }

        CTreeView::OnMouseMove(nFlags, point);
}

void MaterialTreeView::OnLButtonUp(UINT nFlags, CPoint point) {
        CTreeCtrl& tree = GetTreeCtrl();

        if( bDragging ) {
                //Release mouse capture
                ReleaseCapture();

                //Delete the drag image
                dragImage->DragLeave(GetDesktopWindow());
                dragImage->EndDrag();

                bDragging = false;

                delete dragImage;

                UINT flags;
                HTREEITEM item = tree.HitTest(point, &flags);
                if(item && (TVHT_ONITEM & flags)) {

                        DWORD itemType = tree.GetItemData(item);

                        if(itemType == TYPE_MATERIAL) //Backup one if a file is selected
                                item = tree.GetParentItem(item);

                        //Make sure we aren't dragging to the same place
                        HTREEITEM dragItemParent = tree.GetParentItem(dragItem);
                        if(dragItemParent != item) {


                                idStr dragFile;
                                GetFileName(dragItem, dragFile);

                                idStr filename;
                                GetFileName(item, filename);

                                //Move within a file copy across files
                                if(!dragFile.Icmp(filename)) {
                                        materialDocManager->CopyMaterial(materialDocManager->GetCurrentMaterialDoc(), true);
                                } else {
                                        materialDocManager->CopyMaterial(materialDocManager->GetCurrentMaterialDoc(), false);
                                }

                                //Generate the name

                                idStr materialName = GetMediaPath(item, itemType);

                                idStr copyName = materialDocManager->GetCopyMaterialName();
                                idStr copyMaterialName;
                                copyName.ExtractFileName(copyMaterialName);
                                materialName += "/" + copyMaterialName;

                                //If the material name already exists add numbers until we don't find it
                                materialName = materialDocManager->GetUniqueMaterialName(materialName);

                                //Paste
                                materialDocManager->PasteMaterial(materialName, filename);
                        }
                }
        }

        CTreeView::OnLButtonUp(nFlags, point);
}

void MaterialTreeView::OnApplyMaterial() {
        materialDocManager->ApplyMaterial(materialDocManager->GetCurrentMaterialDoc());
}

void MaterialTreeView::OnApplyFile() {
        idStr filename;
        HTREEITEM item = GetTreeCtrl().GetSelectedItem();
        if(GetFileName(item, filename)) {
                materialDocManager->ApplyFile(filename.c_str());
        }
}

void MaterialTreeView::OnApplyAll() {
        materialDocManager->ApplyAll();
}

void MaterialTreeView::OnSaveMaterial() {
        materialDocManager->SaveMaterial(materialDocManager->GetCurrentMaterialDoc());
}

void MaterialTreeView::OnSaveFile() {
        idStr filename;
        HTREEITEM item = GetTreeCtrl().GetSelectedItem();
        if(GetFileName(item, filename)) {
                materialDocManager->SaveFile(filename.c_str());
        }
}

void MaterialTreeView::OnSaveAll() {
        materialDocManager->SaveAllMaterials();
}

void MaterialTreeView::OnRenameMaterial() {

        CTreeCtrl& tree = GetTreeCtrl();

        HTREEITEM item = tree.GetSelectedItem();
        tree.EditLabel(item);
}

void MaterialTreeView::OnAddMaterial() {

        CTreeCtrl& tree = GetTreeCtrl();

        HTREEITEM item = tree.GetSelectedItem();
        DWORD itemType = tree.GetItemData(item);

        //Determine the file
        HTREEITEM parent = NULL;
        if(itemType != TYPE_FILE) {

                parent = tree.GetParentItem(item);
                while(1) {
                        if(tree.GetItemData(parent) == TYPE_FILE)
                                break;
                        parent = tree.GetParentItem(parent);
                }
        } else {
                parent = item;
        }
        idStr filename = GetMediaPath(parent, TYPE_FILE);


        //Determine the material folder
        idStr materialFolder = "";
        switch(itemType) {
                case TYPE_MATERIAL:
                        {
                                HTREEITEM parentFolderItem = tree.GetParentItem(item);
                                if(tree.GetItemData(parentFolderItem) == TYPE_MATERIAL_FOLDER)
                                        materialFolder = GetMediaPath(parentFolderItem, TYPE_MATERIAL_FOLDER);
                        }
                        break;
                case TYPE_MATERIAL_FOLDER:
                        materialFolder = GetMediaPath(item, TYPE_MATERIAL_FOLDER);
                        break;
                case TYPE_FILE:
                        //There is no material folder
                        break;
        }

        idStr name;
        int num = 1;
        while(1) {
                if(materialFolder.Length() > 0) {
                        name = va("%s/newmaterial%d", materialFolder.c_str(), num);
                } else {
                        name = va("newmaterial%d", num);
                }
                if(!declManager->FindMaterial(name, false))
                        break;
                num++;
        }

        materialDocManager->AddMaterial(name.c_str(), filename.c_str());

}

void MaterialTreeView::OnAddFolder() {

        CTreeCtrl& tree = GetTreeCtrl();

        HTREEITEM item = tree.GetSelectedItem();
        DWORD itemType = tree.GetItemData(item);


        //Backup if the selected item is a material
        if(itemType == TYPE_MATERIAL) {
                item = tree.GetParentItem(item);
        }

        //Pick a unique material name
        idStr newFolder;
        int num = 1;
        while(1) {
                newFolder = va("newfolder%d", num);
                if(tree.ItemHasChildren(item)) {
                        HTREEITEM hChildItem = tree.GetChildItem(item);
                        bool found = false;
                        while (hChildItem != NULL)
                        {
                                if(!newFolder.Icmp(tree.GetItemText(hChildItem))) {
                                        found = true;
                                        break;
                                }
                                hChildItem = tree.GetNextSiblingItem(hChildItem);
                        }
                        if(!found)
                                break;
                } else {
                        break;
                }
                num++;
        }

        HTREEITEM newItem = AddFolder(newFolder, item);

        AddMaterialFolderModifier* mod = new AddMaterialFolderModifier(materialDocManager, newFolder, this, newItem, item);
        materialDocManager->AddMaterialUndoModifier(mod);
}

void MaterialTreeView::OnDeleteMaterial() {

        CTreeCtrl& tree = GetTreeCtrl();

        HTREEITEM item = tree.GetSelectedItem();
        DWORD itemType = tree.GetItemData(item);

        if(itemType == TYPE_MATERIAL_FOLDER) {
                int result = MessageBox("Are you sure you want to delete this folder?", "Delete?", MB_ICONQUESTION | MB_YESNO);
                if(result == IDYES) {
                        DeleteFolder(item);
                }
        } else if (itemType == TYPE_MATERIAL) {
                int result = MessageBox("Are you sure you want to delete this material?", "Delete?", MB_ICONQUESTION | MB_YESNO);
                if(result == IDYES) {
                        materialDocManager->DeleteMaterial(materialDocManager->GetCurrentMaterialDoc());
                }
        }
}

void MaterialTreeView::OnReloadFile() {

        CTreeCtrl& tree = GetTreeCtrl();

        HTREEITEM item = tree.GetSelectedItem();
        DWORD itemType = tree.GetItemData(item);

        if(itemType == TYPE_MATERIAL || itemType == TYPE_FILE || itemType == TYPE_MATERIAL_FOLDER) {
                idStr filename;
                GetFileName(item, filename);

                if(materialDocManager->IsFileModified(filename)) {
                        int result = MessageBox("This file has been modified. Are you sure you want to reload this file?", "Reload?", MB_ICONQUESTION | MB_YESNO);
                        if(result != IDYES) {
                                return;
                        }
                }
                materialDocManager->ReloadFile(filename);
        }
}

void MaterialTreeView::OnCut() {
        CTreeCtrl& tree = GetTreeCtrl();

        HTREEITEM item = tree.GetSelectedItem();
        DWORD itemType = tree.GetItemData(item);

        if(item && itemType == TYPE_MATERIAL) {
                materialDocManager->CopyMaterial(materialDocManager->GetCurrentMaterialDoc(), true);
        } else if (itemType == TYPE_MATERIAL_FOLDER) {
        }
}

void MaterialTreeView::OnCopy() {

        CTreeCtrl& tree = GetTreeCtrl();

        HTREEITEM item = tree.GetSelectedItem();
        DWORD itemType = tree.GetItemData(item);

        if(itemType == TYPE_MATERIAL) {
                materialDocManager->CopyMaterial(materialDocManager->GetCurrentMaterialDoc(), false);
        } else if (itemType == TYPE_MATERIAL_FOLDER) {
        }
}

void MaterialTreeView::OnPaste() {

        CTreeCtrl& tree = GetTreeCtrl();

        HTREEITEM item = tree.GetSelectedItem();
        DWORD itemType = tree.GetItemData(item);

        //Paste a material
        if(item && materialDocManager->IsCopyMaterial() && itemType >= TYPE_FILE) {

                //Generate the name
                if(itemType == TYPE_MATERIAL) {//Backup one if a file is selected
                        item = tree.GetParentItem(item);
                        itemType = tree.GetItemData(item);
                }

                idStr materialName = "";
                if(itemType != TYPE_FILE) {
                        materialName = GetMediaPath(item, itemType) + "/";
                }

                idStr copyName = materialDocManager->GetCopyMaterialName();
                idStr copyMaterialName;
                copyName.ExtractFileName(copyMaterialName);
                materialName += copyMaterialName;

                idStr filename;
                GetFileName(item, filename);

                //If the material name already exists add numbers until we don't find it
                materialName = materialDocManager->GetUniqueMaterialName(materialName);

                //Paste
                materialDocManager->PasteMaterial(materialName, filename);

        }       
}

LRESULT MaterialTreeView::OnRenameFolderComplete(WPARAM wParam, LPARAM lParam) {

        //Generate new quick tree info for all material folders
        BuildLookupTrees(renamedFolder);

        //Go through the list of affected materials and rename them
        for(int i = 0; i < affectedMaterials.Num(); i++) {
                RenameMaterial(affectedMaterials[i].treeItem, affectedMaterials[i].materialName);
        }

        //Make sure the tree stays sorted
        CTreeCtrl& tree = GetTreeCtrl();
        HTREEITEM parent = tree.GetParentItem(renamedFolder);
        tree.SortChildren(parent);

        return 0;
}

LRESULT MaterialTreeView::OnRenameMaterialComplete(WPARAM wParam, LPARAM lParam) {

        //Make sure the tree stays sorted
        CTreeCtrl& tree = GetTreeCtrl();
        HTREEITEM parent = tree.GetParentItem(renamedFolder);
        tree.SortChildren(parent);

        return 0;
}

void MaterialTreeView::RenameMaterial(HTREEITEM item, const char* originalName) {

        CTreeCtrl& tree = GetTreeCtrl();

        const idMaterial* material = declManager->FindMaterial(originalName);

        MaterialDoc* pMaterial;
        //pMaterial = materialDocManager->GetInProgressDoc(material);

        //if(!pMaterial) {
        pMaterial = materialDocManager->CreateMaterialDoc(const_cast<idMaterial *>(material));
        //}

        //Remove our old quick lookup value
        materialToTree.Remove(originalName);

        //Generate the new name
        idStr materialName;
        HTREEITEM parent = tree.GetParentItem(item);
        DWORD parentType = tree.GetItemData(parent);
        if(parentType == TYPE_MATERIAL_FOLDER) {
                //Need to include the material folder
                materialName = GetMediaPath(parent, TYPE_MATERIAL_FOLDER);
                materialName += "/";
        }
        materialName += tree.GetItemText(item);


        //Add it to our quick lookup
        materialToTree.Set(materialName, item);

        //Finally make the change
        internalChange = true;
        pMaterial->SetMaterialName(materialName, false);
        internalChange = false;
}

bool MaterialTreeView::GetFileName(HTREEITEM item, idStr& out) {

        out = "";

        CTreeCtrl& tree = GetTreeCtrl();
        DWORD type = tree.GetItemData(item);

        if(type != TYPE_MATERIAL && type != TYPE_MATERIAL_FOLDER && type != TYPE_FILE)
                return false;

        if(type == TYPE_FILE) {
                out = GetMediaPath(item, TYPE_FILE);
                return true;
        }

        HTREEITEM parent = tree.GetParentItem( item );
        while ( parent != NULL ) {
                DWORD parentType = tree.GetItemData(parent);
                if(parentType == TYPE_FILE) {
                        out = GetMediaPath(parent, TYPE_FILE);
                        return true;
                }
                parent = tree.GetParentItem( parent );
        }

        return false;
}

idStr MaterialTreeView::GetMediaPath(HTREEITEM item, DWORD type) {

        //Determine when to stop building the path
        DWORD stopType = TYPE_ROOT;
        switch(type) {
                case TYPE_MATERIAL:
                        stopType = TYPE_FILE;
                        break;
                case TYPE_MATERIAL_FOLDER:
                        stopType = TYPE_FILE;
                        break;
                case TYPE_FILE:
                        stopType = TYPE_ROOT;
                        break;
        };

        CTreeCtrl& tree = GetTreeCtrl();

        idStr mediaName = tree.GetItemText( item );

        // have to build the name back up
        HTREEITEM parent = tree.GetParentItem( item );
        while ( parent != NULL ) {

                //stop the iteration once we have found a specific type
                DWORD parentType = tree.GetItemData(parent);
                if(parentType == stopType) {
                        break;
                }

                idStr strParent = tree.GetItemText( parent );
                strParent += "/";
                strParent += mediaName;
                mediaName = strParent;
                parent = tree.GetParentItem( parent );

        }

        return mediaName;
}

void MaterialTreeView::GetMaterialPaths(HTREEITEM item, idList<MaterialTreeItem_t>* list) {

        CTreeCtrl& tree = GetTreeCtrl();
        if(tree.ItemHasChildren(item)) {

                HTREEITEM childItem = tree.GetChildItem(item);
                while(childItem != NULL) {

                        DWORD childType = tree.GetItemData(childItem);
                        if (childType == TYPE_MATERIAL) {
                                MaterialTreeItem_t mat;
                                mat.materialName = GetMediaPath(childItem, TYPE_MATERIAL);
                                mat.treeItem = childItem;
                                list->Append(mat);
                        } else if (childType == TYPE_MATERIAL_FOLDER) {
                                GetMaterialPaths(childItem, list);
                        }
                        childItem = tree.GetNextSiblingItem(childItem);
                }
        }
}

void MaterialTreeView::AddStrList(const char *root, idStrList *list, bool includeFile) {
        
        CTreeCtrl& treeMedia = GetTreeCtrl();

        idStr           out, path;
        HTREEITEM       base = NULL;
        
        if(root) {
                base = treeMedia.GetRootItem();
                if (base) {
                        out = treeMedia.GetItemText(base);
                        if (stricmp(root, out)) {
                                base = NULL;
                        }
                }

                if (base == NULL) {
                        base = treeMedia.InsertItem(root);
                        treeMedia.SetItemData(base, TYPE_ROOT);
                }
        }

        HTREEITEM       item = base;
        HTREEITEM       add;

        list->Sort();
        int     count = list->Num();

        idStr   last, qt;
        for (int i = 0; i < count; i++) {
                idStr *strItem = &(*list)[i];
                

                idStr name = strItem->c_str();

                idStr filename;
                bool afterFile = true;
                if(includeFile) {
                        int index = name.Find("|");
                        if(index >= 0) {
                                afterFile = false;
                                filename = name.Right(name.Length() - index - 1);
                                name = name.Left(index);
                        }
                }

                // now break the name down convert to slashes
                name.BackSlashesToSlashes();
                name.Strip(' ');

                int index;
                int len = last.Length();
                if (len == 0) {
                        index = name.Last('/');
                        if (index >= 0) {
                                name.Left(index, last);
                        }
                }
                else if (idStr::Icmpn(last, name, len) == 0 && name.Last('/') <= len) {
                        name.Right(name.Length() - len - 1, out);
                        add = treeMedia.InsertItem(out, item);
                        qt = root;
                        qt += "/";
                        qt += name;
                        quickTree.Set(qt, add);
                        treeMedia.SetItemImage(add, IMAGE_MATERIAL, IMAGE_MATERIAL);
                        treeMedia.SetItemData(add, TYPE_MATERIAL);

                        //Add the item to a quick lookup table
                        idStr material = GetMediaPath(add, TYPE_MATERIAL);
                        materialToTree.Set(material, add);

                        continue;
                }
                else {
                        last.Empty();
                }

                index = 0;
                item = base;
                path = "";
                while (index >= 0) {
                        index = name.Find('/');
                        if (index >= 0) {
                                HTREEITEM newItem = NULL;
                                HTREEITEM *check = NULL;
                                name.Left(index, out);
                                path += out;
                                qt = root;
                                qt += "/";
                                qt += path;
                                if (quickTree.Get(qt, &check)) {
                                        newItem = *check;
                                }
                                
                                bool thisisfile = false;
                                if(out == filename) {
                                        thisisfile = true;
                                        afterFile = true;

                                }
                                
                                if (newItem == NULL) {
                                        newItem = treeMedia.InsertItem(out, item);
                                        qt = root;
                                        qt += "/";
                                        qt += path;
                                        quickTree.Set(qt, newItem);
                                        

                                        if(!afterFile || thisisfile) {
                                                if(thisisfile) {
                                                        afterFile = true;
                                                        treeMedia.SetItemImage(newItem, IMAGE_FILE, IMAGE_FILE);
                                                        treeMedia.SetItemData(newItem, TYPE_FILE);

                                                        //Add the item to a quick lookup table
                                                        idStr file = GetMediaPath(newItem, TYPE_FILE);
                                                        //common->Printf("Adding fileToTree: %s - %d\n", file.c_str(), newItem);
                                                        fileToTree.Set(file, newItem);

                                                } else {
                                                        treeMedia.SetItemImage(newItem, IMAGE_FOLDER, IMAGE_FOLDER);
                                                        treeMedia.SetItemData(newItem, TYPE_FOLDER);
                                                }
                                        } else {
                                                treeMedia.SetItemImage(newItem, IMAGE_MATERIAL_FOLDER, IMAGE_MATERIAL_FOLDER);
                                                treeMedia.SetItemData(newItem, TYPE_MATERIAL_FOLDER);

                                        }
                                }

                                
                                item = newItem;
                                name.Right(name.Length() - index - 1, out);
                                name = out;
                                path += "/";
                        }
                        else {
                                add = treeMedia.InsertItem(name, item);
                                qt = root;
                                qt += "/";
                                qt += path;
                                qt += name;
                                quickTree.Set(qt, add);
                                treeMedia.SetItemImage(add, IMAGE_MATERIAL, IMAGE_MATERIAL);
                                treeMedia.SetItemData(add, TYPE_MATERIAL);
                                path = "";

                                //Add the item to a quick lookup table
                                idStr material = GetMediaPath(add, TYPE_MATERIAL);
                                materialToTree.Set(material, add);
                        }
                }
        }
}

void MaterialTreeView::PopupMenu(CPoint* pt) {

        //Determine the type of object clicked on
        CTreeCtrl& tree = GetTreeCtrl();
        UINT test;
        HTREEITEM item = tree.HitTest( *pt, &test );
        if ( item == NULL ||  !(test & TVHT_ONITEM) )
                return;

        ClientToScreen (pt);

        CMenu FloatingMenu;
        VERIFY(FloatingMenu.LoadMenu(IDR_ME_MATERIALTREE_POPUP));
        CMenu* pPopupMenu = FloatingMenu.GetSubMenu (0);
        
        DWORD itemType = tree.GetItemData(item);

        //Enable/Disable based on the state
        MaterialDoc* pDoc = materialDocManager->GetCurrentMaterialDoc();


        //Apply Changes
        if(pDoc && pDoc->applyWaiting) {
                pPopupMenu->EnableMenuItem(ID_POPUP_APPLYMATERIAL, MF_BYCOMMAND | MF_ENABLED);
        } else {
                pPopupMenu->EnableMenuItem(ID_POPUP_APPLYMATERIAL, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
        }

        //Apply File
        idStr filename;
        if(GetFileName(item, filename)) {
                if(materialDocManager->DoesFileNeedApply(filename.c_str()))
                        pPopupMenu->EnableMenuItem(ID_POPUP_APPLYFILE, MF_BYCOMMAND | MF_ENABLED);
                else
                        pPopupMenu->EnableMenuItem(ID_POPUP_APPLYFILE, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
        } else {
                pPopupMenu->EnableMenuItem(ID_POPUP_APPLYFILE, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
        }

        //Apply All
        if(materialDocManager->DoesAnyNeedApply()) {
                pPopupMenu->EnableMenuItem(ID_POPUP_APPLYALL, MF_BYCOMMAND | MF_ENABLED);
        } else {
                pPopupMenu->EnableMenuItem(ID_POPUP_APPLYALL, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
        }

        //Save Material
        if(pDoc && pDoc->modified) {
                pPopupMenu->EnableMenuItem(ID_POPUP_SAVEMATERIAL, MF_BYCOMMAND | MF_ENABLED);
        } else {
                pPopupMenu->EnableMenuItem(ID_POPUP_SAVEMATERIAL, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
        }

        //Save File
        if(GetFileName(item, filename)) {
                if(materialDocManager->IsFileModified(filename.c_str()))
                        pPopupMenu->EnableMenuItem(ID_POPUP_SAVEFILE, MF_BYCOMMAND | MF_ENABLED);
                else
                        pPopupMenu->EnableMenuItem(ID_POPUP_SAVEFILE, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
        } else {
                pPopupMenu->EnableMenuItem(ID_POPUP_SAVEFILE, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
        }

        //Save All
        if(materialDocManager->IsAnyModified()) {
                pPopupMenu->EnableMenuItem(ID_POPUP_SAVEALL, MF_BYCOMMAND | MF_ENABLED);
        } else {
                pPopupMenu->EnableMenuItem(ID_POPUP_SAVEALL, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
        }

        if(itemType == TYPE_MATERIAL || itemType == TYPE_MATERIAL_FOLDER) {
                pPopupMenu->EnableMenuItem(ID_POPUP_RENAMEMATERIAL, MF_BYCOMMAND | MF_ENABLED);
                pPopupMenu->EnableMenuItem(ID_POPUP_DELETEMATERIAL, MF_BYCOMMAND | MF_ENABLED);
        } else {
                pPopupMenu->EnableMenuItem(ID_POPUP_RENAMEMATERIAL, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
                pPopupMenu->EnableMenuItem(ID_POPUP_DELETEMATERIAL, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
        }

        if(itemType == TYPE_FILE || itemType == TYPE_MATERIAL_FOLDER || itemType == TYPE_MATERIAL) {
                pPopupMenu->EnableMenuItem(ID_POPUP_ADDMATERIAL, MF_BYCOMMAND | MF_ENABLED);
                pPopupMenu->EnableMenuItem(ID_POPUP_ADDFOLDER, MF_BYCOMMAND | MF_ENABLED);
        } else {
                pPopupMenu->EnableMenuItem(ID_POPUP_ADDMATERIAL, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
                pPopupMenu->EnableMenuItem(ID_POPUP_ADDFOLDER, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
        }

        if(itemType == TYPE_MATERIAL) {
                pPopupMenu->EnableMenuItem(ID_POPUP_CUT, MF_BYCOMMAND | MF_ENABLED);
                pPopupMenu->EnableMenuItem(ID_POPUP_COPY, MF_BYCOMMAND | MF_ENABLED);
        } else {
                pPopupMenu->EnableMenuItem(ID_POPUP_CUT, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
                pPopupMenu->EnableMenuItem(ID_POPUP_COPY, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
        }

        if((itemType == TYPE_MATERIAL || itemType == TYPE_FILE || itemType == TYPE_MATERIAL_FOLDER) && materialDocManager->IsCopyMaterial()) {
                pPopupMenu->EnableMenuItem(ID_POPUP_PASTE, MF_BYCOMMAND | MF_ENABLED);
        } else {
                pPopupMenu->EnableMenuItem(ID_POPUP_PASTE, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
        }

        if(itemType == TYPE_MATERIAL || itemType == TYPE_FILE || itemType == TYPE_MATERIAL_FOLDER) {
                pPopupMenu->EnableMenuItem(ID_POPUP_RELOADFILE, MF_BYCOMMAND | MF_ENABLED);
        } else {
                pPopupMenu->EnableMenuItem(ID_POPUP_RELOADFILE, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
        }
        
        pPopupMenu->TrackPopupMenu (TPM_LEFTALIGN | TPM_RIGHTBUTTON, pt->x, pt->y, &GetTreeCtrl());
}

void MaterialTreeView::SetItemImage(HTREEITEM item, bool mod, bool apply, bool children) {

        CTreeCtrl& tree = GetTreeCtrl();

        int image;

        DWORD itemType = tree.GetItemData(item);
        switch(itemType) {
                case TYPE_FILE:
                        if(mod)
                                image = IMAGE_FILE_MOD;
                        else
                                image = IMAGE_FILE;
                        break;
                case TYPE_MATERIAL_FOLDER:
                        image = IMAGE_MATERIAL_FOLDER;
                        break;
                case TYPE_MATERIAL:
                        if(mod && apply)
                                image = IMAGE_MATERIAL_MOD_APPLY;
                        else if(mod)
                                image = IMAGE_MATERIAL_MOD;
                        else
                                image = IMAGE_MATERIAL;
                        break;
        }

        tree.SetItemImage(item, image, image);

        if(children) {
                if(tree.ItemHasChildren(item)) {
                        HTREEITEM hChildItem = tree.GetChildItem(item);
                        while (hChildItem != NULL) {
                                SetItemImage(hChildItem, mod, apply, children);
                                hChildItem = tree.GetNextSiblingItem(hChildItem);
                        }
                }
        }
}

void MaterialTreeView::CleanLookupTrees(HTREEITEM item) {

        idStr qt = GetQuicktreePath(item);
        quickTree.Remove(qt);

        CTreeCtrl& tree = GetTreeCtrl();

        //Clean special lookup tables
        DWORD type = tree.GetItemData(item);
        if(type == TYPE_FILE) {
                idStr file = GetMediaPath(item, TYPE_FILE);
                fileToTree.Remove(file);
        } else if(type == TYPE_MATERIAL) {
                idStr name = GetMediaPath(item, TYPE_MATERIAL);
                materialToTree.Remove(name);
        }

        //Clean all my children
        if(tree.ItemHasChildren(item)) {
                HTREEITEM childItem = tree.GetChildItem(item);
                while(childItem != NULL) {
                        CleanLookupTrees(childItem);
                        childItem = tree.GetNextSiblingItem(childItem);
                }
        }
}

void MaterialTreeView::BuildLookupTrees(HTREEITEM item) {

        //Add my quicktree item
        idStr qt = GetQuicktreePath(item);
        quickTree.Set(qt, item);

        CTreeCtrl& tree = GetTreeCtrl();
        if(tree.ItemHasChildren(item)) {
                HTREEITEM childItem = tree.GetChildItem(item);
                while(childItem != NULL) {
                        DWORD childType = tree.GetItemData(childItem);
                        if(childType == TYPE_MATERIAL_FOLDER) {
                                //Recursively call this method for all my child folders
                                BuildLookupTrees(childItem);
                        }
                        childItem = tree.GetNextSiblingItem(childItem);
                }
        }
}

idStr MaterialTreeView::GetQuicktreePath(HTREEITEM item) {
        CTreeCtrl& tree = GetTreeCtrl();

        idStr qt = "";
        HTREEITEM pathItem = item;
        while(pathItem != NULL) {
                qt = "/" + idStr(tree.GetItemText(pathItem)) + qt;
                pathItem = tree.GetParentItem(pathItem);
        }
        return qt;
}