Changeset 1307

Timestamp:

11/09/07 18:54:51 (11 months ago)

Author:

calvin

Message:

zonajs patch: recent files in file menu.
added basic drag+drop+save gear/index.txt in "all machines"-view (disabled by default), added property for wave level sample rate

Location:

trunk/src/buzelib

Files:

• BuzeConfiguration.cpp (modified) (1 diff)
• BuzeConfiguration.h (modified) (1 diff)
• Document.cpp (modified) (1 diff)
• Document.h (modified) (1 diff)
• MachineDropTarget.cpp (modified) (1 diff)
• MachineDropTarget.h (modified) (2 diffs)
• MachineFolderView.cpp (modified) (8 diffs)
• MachineFolderView.h (modified) (2 diffs)
• MachineView.cpp (modified) (1 diff)
• MachineView.h (modified) (1 diff)
• MainFrm.cpp (modified) (12 diffs)
• MainFrm.h (modified) (4 diffs)
• Properties.cpp (modified) (2 diffs)
• Properties.h (modified) (1 diff)
• Utils/DragDropImpl.cpp (modified) (2 diffs)
• Utils/DragDropImpl.h (modified) (1 diff)
• Utils/MachineIndex.cpp (modified) (5 diffs)
• Utils/MachineIndex.h (modified) (3 diffs)
• buze.rc (modified) (2 diffs)
• resource.h (modified) (1 diff)

trunk/src/buzelib/BuzeConfiguration.cpp

@@ -186 +186 @@
 }
 
+std::string CConfiguration::getRecentSong(int index) {
+        string recent;
+
+        if (!getConfigString("Settings", "RecentSong" + stringFromInt(index), &recent))
+                return "";
+        return recent;
+}
+
+void CConfiguration::insertRecentSong(std::string fileName) {
+        std::vector<std::string> recs;
+        std::string str;
+        int i;
+
+        for (i = 0; i < getMaxRecentSongs(); ++i) {
+                str.clear();
+                getConfigString("Settings", "RecentSong" + stringFromInt(i), &(str));
+                if (str == fileName) {
+                        if(!i)
+                                return;
+                        continue;
+                }
+                if (str.size())
+                        recs.push_back(str);
+        }
+
+        recs.insert(recs.begin(), fileName);
+
+        // resave all recent songs
+
+        for(i = 0; i < getMaxRecentSongs() && i < recs.size(); ++i) {
+                setConfigString("Settings", "RecentSong" + stringFromInt(i), recs[i]);
+        }
+}
+
+int CConfiguration::getMaxRecentSongs() {
+        DWORD dw = 10;
+        getConfigNumber("Settings", "MaxRecentSongs", &dw);
+        if(dw > 100)
+                dw = 100;
+        return dw;
+}
+
+void CConfiguration::setMaxRecentSongs(int max) {
+        setConfigNumber("Settings", "MaxRecentSongs", max);
+}
+
 std::string CConfiguration::getExternalWaveEditor() {
         string cmd;

trunk/src/buzelib/BuzeConfiguration.h

@@ -28 +28 @@
         std::string getTheme();
         void setTheme(std::string theme);
+
+        std::string getRecentSong(int index);
+        void insertRecentSong(std::string fileName);
+        int getMaxRecentSongs();
+        void setMaxRecentSongs(int max);
 
         void setMachineParameterVisibility(std::string uri, int parameterIndex, bool state);

trunk/src/buzelib/Document.cpp

@@ -1021 +1021 @@
 }
 
+void CDocument::setWaveLevelSampleRate(zzub::wave_level* entry, int rate) {
+        entry->samples_per_second = rate;
+        updateAllViews(0, UpdateSelectedWaveEntry, entry);
+
+}
+
+int CDocument::getWaveLevelSampleRate(zzub::wave_level* entry) {
+        return entry->samples_per_second;
+}
+
 
 

trunk/src/buzelib/Document.h

@@ -243 +243 @@
         void setWaveLevelType(zzub::wave_level* entry, int bits);
         int getWaveLevelType(zzub::wave_level* entry);
+        void setWaveLevelSampleRate(zzub::wave_level* entry, int rate);
+        int getWaveLevelSampleRate(zzub::wave_level* entry);
 
         // machine loading properties

trunk/src/buzelib/MachineDropTarget.cpp

@@ -26 +26 @@
 CDropTarget::CDropTarget(CDropTargetWindow* dtw):CIDropTarget(dtw->hWndTarget) {
         dropTargetWindow = dtw;
+}
+
+bool CDropTarget::OnDragOver(const POINTL& pt, FORMATETC* pFmtEtc, STGMEDIUM& medium, DWORD *pdwEffect) {
+        return dropTargetWindow->OnDragOver(pt, pFmtEtc, medium, pdwEffect);
+}
+
+void CDropTarget::OnDragLeave() {
+        dropTargetWindow->OnDragLeave();
 }
 

trunk/src/buzelib/MachineDropTarget.h

@@ -6 +6 @@
 
     virtual bool OnDrop(const POINTL& pt, FORMATETC* pFmtEtc, STGMEDIUM& medium, DWORD *pdwEffect) = 0;
+        virtual bool OnDragOver(const POINTL& pt, FORMATETC* pFmtEtc, STGMEDIUM& medium,DWORD *pdwEffect) = 0;
+        virtual void OnDragLeave() = 0;
 };
 
@@ -13 +15 @@
         CDropTarget(CDropTargetWindow* dtw);
         virtual bool OnDrop(const POINTL& pt, FORMATETC* pFmtEtc, STGMEDIUM& medium, DWORD *pdwEffect);
-
+        virtual bool OnDragOver(const POINTL& pt, FORMATETC* pFmtEtc, STGMEDIUM& medium,DWORD *pdwEffect);
+        virtual void OnDragLeave();
 };
 

trunk/src/buzelib/MachineFolderView.cpp

@@ -39 +39 @@
 }
 
+HTREEITEM g_hCurrentDragItem = 0;
+extern MachineMenu* g_effectMenu;
+extern MachineMenu* g_generatorMenu;
+
 LRESULT MachineFolderView::OnBeginDrag(int idCtrl, LPNMHDR pnmh, BOOL& bHandled) {
 
         NMTREEVIEW* pnmtv = (NMTREEVIEW*)pnmh;
 
-        const char* machineFileName = (const char*)treeCtrl.GetItemData(pnmtv->itemNew.hItem);
+        g_hCurrentDragItem = pnmtv->itemNew.hItem;
+        const char* machineFileName = (const char*)treeCtrl.GetItemData(g_hCurrentDragItem);
         if (machineFileName == 0) return 0;
 
@@ -79 +84 @@
 }
 
-void MachineFolderView::bindMachineItems(MachineMenu* item, HTREEITEM parent) {
+int MachineFolderView::bindMachineItems(MachineMenu* item, HTREEITEM parent) {
+
+        DWORD dwEnabled = 0;
+        mainFrame->document->configuration->getConfigNumber("Settings", "IndexEditing", &dwEnabled);
+
+        int machineCounter = 0;
 
         for (size_t i = 0; i < item->items.size(); i++) {
@@ -113 +123 @@
                     strcat(fileName, mi->instrumentName.c_str());
                 }
+                                machineCounter++;
                         }
 
@@ -118 +129 @@
                         treeCtrl.SetItemData(treeItem, (DWORD)fileName);
 
-                        if (ii->type == 0)
-                                bindMachineItems((MachineMenu*)ii, treeItem);
-                }
-        }
+                        ii->userData = treeItem;
+
+                        if (ii->type == 0) {
+                                int bindCount = bindMachineItems((MachineMenu*)ii, treeItem);
+                                // keep even machine menus because we might want to drop something into them
+
+                                if (!bindCount && dwEnabled!=0) {
+                                        HTREEITEM placeholder = treeCtrl.InsertItem( "(drop on me)", treeItem, TVI_LAST);
+                                        treeCtrl.SetItemData(treeItem, (DWORD)0);
+                                }
+                                machineCounter += bindCount;
+                        }
+                }
+        }
+        return machineCounter;
 }
 
@@ -154 +176 @@
 LRESULT MachineFolderView::OnCreate(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/) {
         using namespace std;
-        treeCtrl.Create(this->m_hWnd, rcDefault, NULL, WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | TVS_HASLINES | TVS_LINESATROOT | TVS_SHOWSELALWAYS|TVS_HASBUTTONS, WS_EX_CLIENTEDGE, IDC_MACHINETREE);
+        treeCtrl.Create(this->m_hWnd, rcDefault, NULL, WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | TVS_HASLINES | TVS_LINESATROOT | TVS_SHOWSELALWAYS | TVS_HASBUTTONS | TVS_TRACKSELECT, WS_EX_CLIENTEDGE, IDC_MACHINETREE);
 
         CImageList il;
@@ -163 +185 @@
         CreateThread(0, 0, PopulateMachinesThread, this, 0, &dwId);
 
-        /*
-    bindMachineItems(&mainFrame->document->machineIndex.root, hMachines);       
-
-        treeCtrl.Expand(hMachines);
-
-        for (int i = 0; i<player->getMachineLoaders(); i++) {
-                pluginloader* loader = player->getMachineLoader(i);
-                HTREEITEM hmachineItem;
-                if (loader->getType() == plugin_type_effect)
-                        hmachineItem = treeCtrl.InsertItem( loader->getName(), hEffectItem, TVI_LAST); else
-                        hmachineItem = treeCtrl.InsertItem( loader->getName(), hGeneratorItem, TVI_LAST); 
-                treeCtrl.SetItemData(hmachineItem, (DWORD)loader->getUri());
-        }*/
-
-    /*
-    if (!createDropTarget(*this)) return 0;
+        if (!createDropTarget(*this)) return 0;
         FORMATETC ftetc = {0}; 
         ftetc.cfFormat = CF_TEXT; 
@@ -187 +194 @@
         ftetc.cfFormat=CF_HDROP; 
         dropTarget->AddSuportedFormat(ftetc);
-*/
+
         return 0;
 }
@@ -220 +227 @@
 
 LRESULT MachineFolderView::OnViewProperties(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/) {
-    return 0;
+        return 0;
 }
 
 LRESULT MachineFolderView::OnMouseMove(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/) {
-    /*
-    not called while dragging - update CIDropTarget
-
-    POINT pt = { LOWORD(lParam), HIWORD(lParam) };
-    UINT flags;
+        return 0;
+}
+
+LRESULT MachineFolderView::OnLButtonUp(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/) {
+        return 0;
+}
+
+
+// copyitem / copybranch by Zafir Anjum
+// http://www.codeguru.com/cpp/controls/treeview/dragdrop/article.php/c695/
+
+HTREEITEM CopyItem(CTreeViewCtrl& treeView, HTREEITEM hItem, HTREEITEM htiNewParent, HTREEITEM htiAfter = TVI_LAST) {
+        TV_INSERTSTRUCT tvstruct;
+        HTREEITEM hNewItem;
+
+        // get information of the source item
+        tvstruct.item.hItem = hItem;
+        tvstruct.item.mask = TVIF_CHILDREN | TVIF_HANDLE | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
+        treeView.GetItem(&tvstruct.item);  
+        char itemText[1024];
+        treeView.GetItemText( hItem, itemText, 1024 );
+
+        tvstruct.item.cchTextMax = strlen(itemText);
+        tvstruct.item.pszText = itemText;
+
+        // Insert the item at proper location
+        tvstruct.hParent = htiNewParent;
+        tvstruct.hInsertAfter = htiAfter;
+        tvstruct.item.mask = TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_TEXT;
+        hNewItem = treeView.InsertItem(&tvstruct);
+
+        // Now copy item data and item state.
+        treeView.SetItemData( hNewItem, treeView.GetItemData( hItem ));
+        treeView.SetItemState( hNewItem, treeView.GetItemState( hItem, TVIS_STATEIMAGEMASK ), TVIS_STATEIMAGEMASK );
+
+        return hNewItem;
+}
+
+HTREEITEM CopyBranch(CTreeViewCtrl& treeView, HTREEITEM htiBranch, HTREEITEM htiNewParent, HTREEITEM htiAfter = TVI_LAST) {
+        HTREEITEM hChild;
+
+        HTREEITEM hNewItem = CopyItem(treeView, htiBranch, htiNewParent, htiAfter);
+        hChild = treeView.GetChildItem(htiBranch);
+        while (hChild != NULL) {
+        // recursively transfer all the items
+        CopyBranch(treeView, hChild, hNewItem);  
+        hChild = treeView.GetNextSiblingItem( hChild );
+        }
+        return hNewItem;
+}
+
+CMenuHandle FindMenuItem(CMenuHandle menuItem, std::string text, int& pos) {
+        char menuText[1024];
+
+        pos = -1;
+        for (UINT i = 0; i < menuItem.GetMenuItemCount(); i++) {
+                menuItem.GetMenuString(i, menuText, 1024, MF_BYPOSITION);
+                if (text == menuText) {
+                        pos = i;
+                        return menuItem;
+                }
+                CMenuHandle submenu = menuItem.GetSubMenu(i);
+                if (submenu.m_hMenu == 0) continue;
+
+                submenu = FindMenuItem(submenu, text, pos);
+                if (submenu.m_hMenu != 0) return submenu;
+
+        }
+        return CMenuHandle();
+}
+
+void* GetMenuItemData(CMenuHandle menu, int pos) {
+        MENUITEMINFO mii;
+        memset(&mii, 0, sizeof(MENUITEMINFO));
+        mii.cbSize = sizeof(MENUITEMINFO);
+        mii.fMask = MIIM_DATA;
+        menu.GetMenuItemInfo(pos, TRUE, &mii);
+        return (void*)mii.dwItemData;
+}
+
+CMenuHandle FindMenuItemByData(CMenuHandle menuItem, void* data, int& pos) {
+        char menuText[1024];
+
+        pos = -1;
+        for (UINT i = 0; i < menuItem.GetMenuItemCount(); i++) {
+                void* itemData = GetMenuItemData(menuItem, i);
+                if (itemData == data) {
+                        pos = i;
+                        return menuItem;
+                }
+                CMenuHandle submenu = menuItem.GetSubMenu(i);
+                if (submenu.m_hMenu == 0) continue;
+
+                submenu = FindMenuItemByData(submenu, data, pos);
+                if (submenu.m_hMenu != 0) return submenu;
+
+        }
+        return CMenuHandle();
+}
+
+int CountTreeItems(CTreeViewCtrl& tree, HTREEITEM hItem = NULL, BOOL recurse = TRUE) {
+        int count = 0;
+        if (hItem == NULL)
+                hItem = tree.GetSelectedItem();
+
+        if (tree.ItemHasChildren(hItem)) {
+                hItem = tree.GetNextItem(hItem, TVGN_CHILD);
+                while (hItem) {
+                        count++;
+                        if (recurse)
+                                count += CountTreeItems(tree, hItem, recurse);
+                        hItem = tree.GetNextItem(hItem, TVGN_NEXT);
+                }
+        }
+        return count;
+}
+
+#include "Utils/MachineIndex.h"
+
+extern void InsertMenuItemFromIndexItem(IndexItem* ii, CMenuHandle parentMenu, int pos);
+
+bool MachineFolderView::OnDropMachine(std::string machineName, std::string instrumentName, int x, int y) {
+        treeCtrl.RemoveInsertMark();
+
+        DWORD dwEnabled = 0;
+        mainFrame->document->configuration->getConfigNumber("Settings", "IndexEditing", &dwEnabled);
+        if (!dwEnabled) return true;
+
+        POINT pt = { x, y };
+        UINT flags;
+        HTREEITEM dropItem = treeCtrl.HitTest(pt, &flags);
+        if (dropItem == 0) return true;
+
+        // TODO: if dropped item is an expandable thing and its expanded, we want to add the dragItem as the first child here
+
+        IndexItem* dropIndex = mainFrame->document->machineIndex.root.getItemByData(dropItem);
+        IndexItem* dragIndex = mainFrame->document->machineIndex.root.getItemByData(g_hCurrentDragItem);
+
+        if (dropIndex == dragIndex) return true;
+
+        // are we dropping in a machine list?
+        if (dropIndex && dropIndex->type == 0) {
+                MachineMenu* mm = (MachineMenu*)dropIndex;
+                // are we dropping on a preloaded machine?
+                if (mm->preloadReplaced != 0) return true;
+        } else
+        if (dropIndex && dropIndex->type == 1) {
+                if (dropIndex->parent->type == 0) {
+                        MachineMenu* mm = (MachineMenu*)dropIndex->parent;
+                        // are we dropping inside a preloaded machine?
+                        if (mm->preloadReplaced != 0) return true;
+                }
+        }
+
+        HTREEITEM dropParent = treeCtrl.GetParentItem(dropItem);
+        HTREEITEM dragParent = treeCtrl.GetParentItem(g_hCurrentDragItem);
+
+        char dragItemText[1024];
+        treeCtrl.GetItemText(g_hCurrentDragItem, dragItemText, 1024);
+        char dropItemText[1024];
+        treeCtrl.GetItemText(dropItem, dropItemText, 1024);
+
+        treeCtrl.SetRedraw(FALSE);
+
+        HTREEITEM dragCopy = CopyBranch(treeCtrl, g_hCurrentDragItem, dropParent, dropItem);
+        if (dragIndex != 0) {
+                treeCtrl.DeleteItem(g_hCurrentDragItem);
+                int dragFromSiblings = CountTreeItems(treeCtrl, dragParent);
+                if (dragFromSiblings == 0) {
+                        HTREEITEM placeholder = treeCtrl.InsertItem("(drop on me)", dragParent, TVI_LAST);
+                        treeCtrl.SetItemData(dragParent, (DWORD)0);
+                }
+        }
+
+        bool created = false;
+        if (dragIndex == 0) {
+                // we dragged an item from out-of-index into the index, so we create a new item for it
+                zzub::pluginloader* loader = mainFrame->player->getMachineLoader(machineName);
+
+                MachineItem* mi = new MachineItem();
+                mi->label = loader->plugin_info->name;
+                mi->fileName = loader->plugin_info->name;
+                mi->fullMachineName = machineName;
+                mi->instrumentName = instrumentName;
+                dragIndex = mi;
+
+                created = true;
+        }
+        dragIndex->userData = dragCopy;
+
+        if (!created) dragIndex->parent->removeItem(dragIndex);
+        if (dropIndex != 0) {
+                dropIndex->parent->insertAfter(dragIndex, dropIndex);
+        } else {
+                // need to find parent of where we are dropping, in case it is a drop target
+                if ((std::string)dropItemText == "(drop on me)") {
+                        treeCtrl.DeleteItem(dropItem);
+                }
+                IndexItem* parentIndex = mainFrame->document->machineIndex.root.getItemByData(dropParent);
+                if (parentIndex == 0) return true;
+                parentIndex->append(dragIndex);
+        }
+
+        treeCtrl.SetRedraw(TRUE);
+
+        IndexItem* generatorParent = g_generatorMenu->parent;
+        IndexItem* effectParent = g_effectMenu->parent;
+
+        // temporarily remove the Unsorted Generators and Unsorted Effects
+        generatorParent->removeItem(g_generatorMenu);
+        effectParent->removeItem(g_effectMenu);
+
+        // we could also revert the PlaceGeneratorHere-thing but its not needed
+        mainFrame->document->machineIndex.save(_Module.mapPath("Gear/index.txt").c_str());
+
+        generatorParent->append(g_generatorMenu);
+        effectParent->append(g_effectMenu);
+
+        g_hCurrentDragItem = 0;
+
+        // rebuild right-click menu in machine view because we are now out of sync
+
+        int machines = 0;
+        if (mainFrame->createMachineMenu.IsMenu()) mainFrame->createMachineMenu.DestroyMenu();
+        mainFrame->createMachineMenu.CreatePopupMenu();
+        mainFrame->insertMachineMenu(mainFrame->createMachineMenu.m_hMenu, mainFrame->document->machineIndex.root, machines);
+
+        return true;
+}
+
+bool MachineFolderView::OnDragOver(const POINTL& ptl, FORMATETC* pFmtEtc, STGMEDIUM& medium,DWORD *pdwEffect) {
+        POINT pt = { ptl.x, ptl.y };
+        treeCtrl.ScreenToClient(&pt);
+        UINT flags;
         HTREEITEM item = treeCtrl.HitTest(pt, &flags);
-    if (item != 0) {
-        treeCtrl.SetInsertMark(item, TRUE);//TVM_SETINSERTMARK 
-    }*/
-    return 0;
-}
-
-LRESULT MachineFolderView::OnLButtonUp(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/) {
-    return 0;
-}
-
-
-bool MachineFolderView::OnDropMachine(std::string machineName, std::string instrumentName, int x, int y) {
-
-    return true;
-}
+        if (item == 0) return true;
+                
+        treeCtrl.SetInsertMark(item, TRUE);
+
+        return true;
+}
+
+void MachineFolderView::OnDragLeave() {
+        treeCtrl.RemoveInsertMark();
+}

trunk/src/buzelib/MachineFolderView.h

@@ -54 +54 @@
         MachineFolderView(CMainFrame* mainFrm, ClientViewListener* clientViewListener);
         ~MachineFolderView(void);
-        void bindMachineItems(MachineMenu* item, HTREEITEM parent);
+        int bindMachineItems(MachineMenu* item, HTREEITEM parent);
 
         void loadFromIndex();
@@ -70 +70 @@
         LRESULT OnViewProperties(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/);
     bool OnDropMachine(std::string machineName, std::string instrumentName, int x, int y);
+        bool OnDragOver(const POINTL& pt, FORMATETC* pFmtEtc, STGMEDIUM& medium,DWORD *pdwEffect);
+        void OnDragLeave();
 
 public:

trunk/src/buzelib/MachineView.cpp

@@ -1690 +1690 @@
 }
 
+bool CMachineView::OnDragOver(const POINTL& pt, FORMATETC* pFmtEtc, STGMEDIUM& medium,DWORD *pdwEffect) { 
+        // TODO: maybe check if we are over a connection, a group machine or something
+        return true; 
+}
+
+void CMachineView::OnDragLeave() { 
+}
+
 bool CMachineView::OnDropMachine(std::string machineName, std::string instrumentName, int x, int y) {
 

trunk/src/buzelib/MachineView.h

@@ -147 +147 @@
         void OnUpdate(CView* pSender, LPARAM lHint, LPVOID pHint);
 
+        bool OnDragOver(const POINTL& pt, FORMATETC* pFmtEtc, STGMEDIUM& medium,DWORD *pdwEffect);
+        void OnDragLeave();
         bool OnDropMachine(std::string machineName, std::string instrumentName, int x, int y);
 

trunk/src/buzelib/MainFrm.cpp

@@ -1350 +1350 @@
 
         initializeThemes();
+        initializeRecent();
 
         if (!deserializeFromFile(_Module.mapPath("Gear/gui.xml"))) {
@@ -1547 +1548 @@
                 document->setCurrentFile(fileName);
                 setWindowTitle(document->currentFileName);
+                setMostRecent(fileName);
         }
         //player->getMaster()->releaseEvent(progressEventID);
@@ -2136 +2138 @@
 }
 
+void SetMenuItemData(CMenuHandle menu, int pos, void* data) {
+        MENUITEMINFO mii;
+        memset(&mii, 0, sizeof(MENUITEMINFO));
+        mii.cbSize = sizeof(MENUITEMINFO);
+        mii.fMask = MIIM_DATA;
+        mii.dwItemData = (DWORD)data;
+        menu.SetMenuItemInfo(pos, TRUE, &mii);
+}
+
 
 int CMainFrame::insertMachineMenu(CMenuHandle parentMenu, MachineMenu& parentMachineMenu, int& index) {
 
-        int visibleCounter=0;
-        int maxEntriesPerPage=40;
-
-        bool prevWasSep=false;
+        int visibleCounter = 0;
+        int maxEntriesPerPage;
 
         CWindow desktop(GetDesktopWindow());
@@ -2148 +2157 @@
         RECT rcClient;
         desktop.GetClientRect(&rcClient);
-        maxEntriesPerPage=(rcClient.bottom-100)/16;
-
-        for (size_t i=0; i<parentMachineMenu.items.size(); i++) {
+        maxEntriesPerPage = (rcClient.bottom-100)/16;
+
+        for (size_t i = 0; i < parentMachineMenu.items.size(); i++) {
 
                 DWORD extraFlags = ((visibleCounter%maxEntriesPerPage)==(maxEntriesPerPage-1)?MF_MENUBARBREAK:0);
 
-                IndexItem* ii=parentMachineMenu.items[i];
-                if (ii->hide==true) continue;
-                if (ii->type==0) {
-                        MachineMenu& mmenu=*(MachineMenu*)ii;
+                IndexItem* ii = parentMachineMenu.items[i];
+                if (ii->hide == true) continue;
+                if (ii->type == 0) {
+                        MachineMenu& mmenu = *(MachineMenu*)ii;
 
                         CMenuHandle newMenu;
                         newMenu.CreatePopupMenu();
 
-                        // TODO: only insert if there are any child nodes worth mentioning
-                        if (!insertMachineMenu(newMenu.m_hMenu, mmenu, index)) continue;
+                        // only insert if there are any child nodes worth mentioning
+                        int insertedCount = insertMachineMenu(newMenu.m_hMenu, mmenu, index);
+                        if (!insertedCount) continue;
 
                         parentMenu.InsertMenu(-1, MF_BYPOSITION|MF_POPUP|extraFlags, (UINT_PTR)newMenu.m_hMenu, ii->label.c_str());
-                        visibleCounter++;
-                        prevWasSep=false;
+                        SetMenuItemData(parentMenu, parentMenu.GetMenuItemCount() - 1, ii);
+                        visibleCounter +=