home *** CD-ROM | disk | FTP | other *** search
/ Chip 2002 November / Chip_2002-11_cd1.bin / zkuste / vbasic / Data / Utils / WME71SDK.exe / RCDATA / CABINET / encoderview.cpp < prev    next >
C/C++ Source or Header  |  2001-03-02  |  47KB  |  1,739 lines
  1. // EncoderView.cpp : Implementation of CEncoderView
  2.  
  3. #include "stdafx.h"
  4. #include "Encview.h"
  5. #include "common.h"
  6. #include "EncoderView.h"
  7. /////////////////////////////////////////////////////////////////////////////
  8. // CEncoderView
  9. CEncoderView::CEncoderView() 
  10. :m_bDragging(false)
  11. ,m_hDragItem(NULL)
  12. {
  13.     m_bWindowOnly = TRUE;
  14.     CalcExtent(m_sizeExtent);
  15.     InitMaps();
  16. }
  17.  
  18. HRESULT CEncoderView::FinalConstruct()
  19. {
  20.  
  21.     return S_OK;
  22. }
  23.  
  24. void CEncoderView::FinalRelease() 
  25. {
  26.  
  27. }
  28.  
  29.  
  30. STDMETHODIMP CEncoderView::get_Root(IDispatch **pVal)
  31. {
  32.     HRESULT hr = NOERROR;
  33.     if(!pVal)
  34.     {
  35.         return E_POINTER;
  36.     }
  37.     *pVal = m_pRoot;
  38.     if(*pVal)
  39.         (*pVal)->AddRef();
  40.  
  41.     return S_OK;
  42. }
  43.  
  44. STDMETHODIMP CEncoderView::put_Root(IDispatch *newVal)
  45. {
  46.     m_pRoot = newVal;
  47.     return S_OK;
  48. }
  49.  
  50.  
  51.  
  52. // use root whenever possible, if it's absent, use machine name
  53.  
  54. STDMETHODIMP CEncoderView::Refresh()
  55. {
  56.     HRESULT hr = NOERROR;
  57.  
  58.     DeleteChildren(NULL);
  59.  
  60.     if(m_pRoot) 
  61.     {
  62.         CComQIPtr<IWMEncoder> pEnc(m_pRoot);
  63.         if(pEnc!=NULL)
  64.             hr = DisplayEncoder(pEnc, NULL);
  65.  
  66.     }
  67.     // display all machines that we are given
  68.     else
  69.     {
  70.         if(m_vecMachines.empty())
  71.             return hr;
  72.  
  73.         using namespace std;
  74.         USES_CONVERSION;
  75.         for(int i=0; i< m_vecMachines.size();i++)
  76.         {
  77.             CComPtr<IWMEncoderAgent> pAgent;    
  78.             CComPtr<IWMEncoderNamesCollection> pEncCol;
  79.             CComPtr<IDispatch> pDisp;
  80.             CComPtr<IClassFactory> pCF;
  81.             
  82.             HRESULT hr = NOERROR;
  83.             COSERVERINFO cs;
  84.             ZeroMemory(&cs,sizeof(cs));
  85.             USES_CONVERSION;
  86.             cs.pwszName = T2W((LPTSTR)(LPCTSTR)(m_vecMachines[i]));
  87.             hr = ::CoGetClassObject(CLSID_WMEncoderAgent,CLSCTX_ALL,
  88.                 &cs,IID_IClassFactory, (VOID**)&pCF);
  89.             if(SUCCEEDED(hr))
  90.             {
  91.                 hr = pCF->CreateInstance(NULL,IID_IWMEncoderAgent,(void**)&pAgent);
  92.                 if(SUCCEEDED(hr))
  93.                 {
  94.                     CComPtr<IUnknown> pUnk;
  95.                     hr = pAgent.QueryInterface(&pUnk);
  96.                     if(SUCCEEDED(hr))
  97.                     {
  98.                         InsertNode((HTREEITEM)NULL,m_vecMachines[i],pUnk.p, 
  99.                             &CEncoderView::ShowMachineDetails);
  100.                     }
  101.                 }
  102.             }
  103.             if(FAILED(hr))
  104.             {
  105.                 CString strError = GetErrorFromHR(hr);
  106.                 InsertNode((HTREEITEM)NULL,strError,NULL, 
  107.                             NULL);
  108.             }
  109.         }
  110.     }
  111.  
  112.     return hr;
  113. }
  114.  
  115.  
  116. // helper functions
  117.  
  118. HTREEITEM CEncoderView::InsertNode(HTREEITEM hParent, CString strText, LPUNKNOWN pUnk, LPFNDISPLAY pfn)
  119. {
  120.     TREEDATA* ptd = new TREEDATA(pUnk,pfn);
  121.     if(!ptd)
  122.         return NULL;
  123.  
  124.     USES_CONVERSION;
  125.     TV_INSERTSTRUCT tvs;
  126.     ZeroMemory(&tvs, sizeof(tvs));
  127.     tvs.hParent = hParent;
  128.     tvs.hInsertAfter = TVI_LAST;
  129.     tvs.item.mask = TVIF_CHILDREN | TVIF_PARAM | TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
  130.     tvs.item.cChildren = 1;
  131.     tvs.item.lParam = (LPARAM)ptd; 
  132.     tvs.item.pszText = (LPTSTR)(LPCTSTR)strText;
  133.     tvs.item.cchTextMax = MAX_PATH;
  134.     tvs.item.iImage = 0;
  135.     tvs.item.iSelectedImage = 1;
  136.     return m_Tree.InsertItem(&tvs);
  137.     
  138. }
  139.  
  140. HTREEITEM CEncoderView::InsertNode(HTREEITEM hParent, CString strText, TREEDATA* pData)
  141. {
  142.     USES_CONVERSION;
  143.     TV_INSERTSTRUCT tvs;
  144.     ZeroMemory(&tvs, sizeof(tvs));
  145.     tvs.hParent = hParent;
  146.     tvs.hInsertAfter = TVI_LAST;
  147.     tvs.item.mask = TVIF_CHILDREN | TVIF_PARAM | TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
  148.     tvs.item.cChildren = 1;
  149.     tvs.item.lParam = (LPARAM)pData; 
  150.     tvs.item.pszText = (LPTSTR)(LPCTSTR)strText;
  151.     tvs.item.cchTextMax = MAX_PATH;
  152.     tvs.item.iImage = 0;
  153.     tvs.item.iSelectedImage = 1;
  154.     return m_Tree.InsertItem(&tvs);
  155.     
  156. }
  157.  
  158. HRESULT CEncoderView::DisplayEncoder(IWMEncoder* pEnc, HTREEITEM hParent)
  159. {
  160.     if(!pEnc)
  161.         return E_POINTER;
  162.     HRESULT hr = NOERROR;
  163.     CComBSTR bstrName;
  164.     hr = pEnc->get_Name(&bstrName);
  165.     HR_TEST(hr);
  166.     
  167.     USES_CONVERSION;
  168.     CString strName = W2T(bstrName);
  169.     CComObject<CEncoderEventSink>* pSink = NULL;
  170.     hr = CComObject<CEncoderEventSink>::CreateInstance(&pSink);
  171.     HR_TEST(hr);
  172.     CComPtr<IUnknown> pUnk;
  173.     hr = pEnc->QueryInterface(IID_IUnknown, (void**)&pUnk);
  174.     HR_TEST(hr);
  175.     HTREEITEM hItem = NULL;
  176.     if(pSink)
  177.     {
  178.         pSink->AddRef();        
  179.         ENCDATA* pData = new ENCDATA((LPUNKNOWN)pUnk.p, &CEncoderView::ShowEncoderDetails, pSink);
  180.         hr = pSink->DispEventAdvise(pEnc);
  181.         pSink->m_hMsgWnd = m_hWnd;
  182.         hItem = InsertNode(hParent, strName,pData);
  183.         pSink->m_dwParam = (DWORD)hItem; 
  184.     }
  185.     else
  186.     {
  187.         hItem = InsertNode(hParent, strName, (LPUNKNOWN)pUnk.p, &CEncoderView::ShowEncoderDetails);
  188.     }
  189.     
  190.     if(hItem)
  191.         m_Tree.Expand(hItem);
  192.     return hr;
  193. }
  194.  
  195.  
  196.  
  197. // message handlers
  198. LRESULT CEncoderView::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
  199. {
  200.     InitTreeView();
  201.     m_Tree.Attach(GetDlgItem(IDC_TREE_ENCODER));
  202.     _ASSERT(m_Tree.IsWindow());
  203.     m_ImageList.Create(IDB_ENCODERVIEW,16,0,0);
  204.     _ASSERT(m_ImageList!=NULL);
  205.     m_Tree.SetImageList(m_ImageList,TVSIL_NORMAL );
  206.     Refresh();
  207.     return 0;
  208. }
  209.  
  210. LRESULT CEncoderView::OnItemexpandingTree_encoder(int idCtrl, LPNMHDR pnmh, BOOL& bHandled)
  211. {
  212.     LPNMTREEVIEW pnmtv = (LPNMTREEVIEW)pnmh;
  213.     if(pnmtv->action==TVE_COLLAPSE)
  214.         return 0L;
  215.     LPTREEDATA lptrdata = (LPTREEDATA)pnmtv->itemNew.lParam;
  216.     if((lptrdata==NULL) || (lptrdata->pfnDisplay==NULL) || (lptrdata->pUnk==NULL))
  217.     {
  218.         return 0;
  219.     }
  220.     
  221.     //if ((pnmtv->itemNew.state & TVIS_EXPANDEDONCE))
  222. //         return 0L;
  223.     // clean up all items first
  224.     DeleteChildren(pnmtv->itemNew.hItem);
  225.  
  226.     _ASSERT(lptrdata->pUnk);
  227.     LPFNDISPLAY pfn = lptrdata->pfnDisplay;
  228.     //(lptrdata->*pfnDisplay)(pnmtv->itemOld.hItem,lptrdata->pUnk);
  229.     (this->*pfn)(pnmtv->itemNew.hItem,lptrdata->pUnk);
  230.     bHandled = FALSE;
  231.     return 0;
  232. }
  233.  
  234.  
  235. LRESULT CEncoderView::OnDeleteitemTree_encoder(int idCtrl, LPNMHDR pnmh, BOOL& bHandled)
  236. {
  237.     LPNMTREEVIEW pnmtv = (LPNMTREEVIEW)pnmh;
  238.     LPTREEDATA lptrdata = (LPTREEDATA)pnmtv->itemOld.lParam;
  239.     if(lptrdata)
  240.         delete lptrdata;
  241.  
  242.     return 0;
  243. }
  244.  
  245. LRESULT CEncoderView::OnBegindragTree_encoder(int idCtrl, LPNMHDR pnmh, BOOL& bHandled)
  246. {
  247.     LPNMTREEVIEW pnmtv = (LPNMTREEVIEW)pnmh;
  248.     m_hDragItem = pnmtv->itemNew.hItem;
  249.     CImageList ImageList = m_Tree.CreateDragImage(m_hDragItem);
  250.     m_ImageList.BeginDrag(0,0,0);
  251.     ShowCursor(FALSE);
  252.     SetCapture();
  253.     m_bDragging = true;
  254.     CPoint pt(pnmtv->ptDrag);
  255.     m_Tree.ClientToScreen(&pt);
  256.     m_ImageList.DragEnter(NULL,pt);
  257.     return 0;
  258. }
  259.  
  260. LRESULT CEncoderView::OnMouseMove(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
  261. {
  262.     if(m_bDragging)
  263.     {
  264.         CPoint pt(GET_X_LPARAM(lParam),GET_Y_LPARAM(lParam));
  265.         m_ImageList.DragLeave(NULL);
  266.         UINT flags;
  267.         HTREEITEM hHitItem = m_Tree.HitTest(pt,&flags);
  268.         if(hHitItem)
  269.         {
  270.             m_Tree.SelectDropTarget(hHitItem);
  271.         }
  272.         m_Tree.ClientToScreen(&pt);
  273.         m_ImageList.DragMove(pt);
  274.         m_ImageList.DragEnter(NULL,pt);
  275.  
  276.     }
  277.     return 0;
  278. }
  279.  
  280.  
  281. LRESULT CEncoderView::OnLButtonUP(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
  282. {
  283.     if(m_bDragging)
  284.     {
  285.         m_ImageList.DragLeave(NULL);
  286.         m_ImageList.EndDrag();
  287.         ReleaseCapture();
  288.         CPoint pt(GET_X_LPARAM(lParam),GET_Y_LPARAM(lParam));;
  289.         UINT nFlags;
  290.  
  291.         HTREEITEM hHitItem = m_Tree.HitTest(pt,&nFlags);
  292.         if(hHitItem && (nFlags &TVHT_ONITEM ))
  293.         {
  294.             Move(m_hDragItem,hHitItem);
  295.         }
  296.         
  297.         ShowCursor(TRUE) ;
  298.         m_bDragging = false;
  299.  
  300.     }
  301.     return 0;
  302. }
  303.  
  304. LRESULT CEncoderView::OnCommand(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
  305. {
  306.     if(HIWORD(wParam)!=0) // not from menu
  307.         return 0;
  308.     UINT nID = LOWORD(wParam);
  309.     
  310.     CComPtr<IWMEncoder> pEnc;
  311.     GetSelectedEncoder(&pEnc);
  312.     if(!pEnc)
  313.         return 0;
  314.  
  315.     switch(nID)
  316.     {
  317.     case ID_MENU_START:
  318.         pEnc->Start();
  319.         break;
  320.  
  321.     case ID_MENU_STOP:
  322.         pEnc->Stop();
  323.         break;
  324.  
  325.     case ID_MENU_RESET:
  326.         pEnc->Reset();
  327.         break;
  328.     default:
  329.         break;
  330.     }
  331.  
  332.     return 0;
  333. }
  334.  
  335. HRESULT CEncoderView::GetSelectedEncoder(IWMEncoder** pEnc)
  336. {
  337.     HRESULT hr = NOERROR;
  338.     if(!pEnc)
  339.         return E_POINTER;
  340.     HTREEITEM hItem = m_Tree.GetSelectedItem();
  341.     if(hItem)
  342.     {
  343.         LPTREEDATA lpdata = (LPTREEDATA)m_Tree.GetItemData(hItem);
  344.         if(!lpdata)
  345.             return hr;
  346.         
  347.         hr = lpdata->pUnk->QueryInterface(IID_IWMEncoder, (void**)pEnc);
  348.  
  349.     }
  350.  
  351.     return hr;
  352. }
  353. // we first find out what type of node this is, and then show corresponding context menu.
  354. // simple way to handle this would be to store the type information of the node at the node itself
  355. // but more elegant solution we will use is to get the IUnknown stored here and then QI it to
  356. // find out who the node is and then show the corresponding context menu
  357. // so we use a map that maps all the interfaces that have context id's to the menu id
  358.  
  359. LRESULT CEncoderView::OnContextMenu(int , LPNMHDR pnmh, BOOL& )
  360. {
  361.     // we currently have popup menu's only for the encoder, so we check if the item hit was
  362.     // encoder, or else we simply return
  363.     DWORD dwPos = ::GetMessagePos();
  364.     POINT pt = {LOWORD(dwPos), HIWORD(dwPos)};
  365.     
  366.     if(pnmh->hwndFrom ==m_Tree.m_hWnd)
  367.     {
  368.         TV_HITTESTINFO tvhti;
  369.         TV_ITEM        tvi;
  370.  
  371.         m_Tree.ScreenToClient(&pt);
  372.         tvhti.pt = pt;
  373.         m_Tree.HitTest(&tvhti);
  374.         m_Tree.SelectItem(tvhti.hItem);
  375.  
  376.         if (tvhti.flags & TVHT_ONITEMLABEL)
  377.         {
  378.             m_Tree.ClientToScreen(&pt);
  379.             tvi.mask=TVIF_PARAM;
  380.             tvi.hItem=tvhti.hItem;
  381.  
  382.             if (!m_Tree.GetItem(&tvi))
  383.                 return 0;
  384.  
  385.             LPTREEDATA lpt=(LPTREEDATA)tvi.lParam;
  386.             if(!lpt || !lpt->pUnk )
  387.                 return 0;
  388.             CComQIPtr<IWMEncoder> pEnc(lpt->pUnk);
  389.             if(!pEnc)
  390.                 return 0;
  391.  
  392.             CMenu Menu;
  393.             if(!Menu.CreatePopupMenu())
  394.                 return 0;
  395.             BOOL bRet = FALSE;
  396.             bRet = Menu.AppendMenu(MF_STRING | MF_ENABLED, ID_MENU_START, _T("&Start"));
  397.             _ASSERT(bRet);
  398.  
  399.             bRet = Menu.AppendMenu(MF_STRING | MF_ENABLED, ID_MENU_STOP, _T("&Stop"));
  400.             _ASSERT(bRet);
  401.  
  402.             bRet = Menu.AppendMenu(MF_STRING | MF_ENABLED, ID_MENU_RESET, _T("&Reset"));
  403.             _ASSERT(bRet);
  404.  
  405.             Menu.TrackPopupMenu(TPM_LEFTALIGN | TPM_LEFTBUTTON,pt.x ,pt.y ,m_hWnd);
  406.         }
  407.     }
  408.  
  409.     return 0;
  410. }
  411.  
  412. UINT CEncoderView::GetItemIndex(CTreeItem& Item)
  413. {
  414.     CTreeItem ParentItem(Item.GetParent());
  415.     if(ParentItem==NULL)
  416.         return -1;
  417.  
  418.     HTREEITEM hChild;
  419.     UINT nRet = 0;
  420.     while((hChild = m_Tree.GetNextItem(ParentItem,TVGN_CHILD))!=Item)
  421.     {
  422.         nRet++;
  423.     }
  424.     return nRet;
  425. }
  426.  
  427. HRESULT CEncoderView::Move(HTREEITEM hDragItem,HTREEITEM hHitItem)
  428. {
  429.     HRESULT hr = NOERROR;
  430.     // if the parents aren't the same simply return
  431.     CTreeItem DragItem(hDragItem, &m_Tree);
  432.     CTreeItem HitItem(hHitItem, &m_Tree);
  433.     if(DragItem.GetParent() != HitItem.GetParent())
  434.         return hr;
  435.     TREEDATA* pData = (TREEDATA*)m_Tree.GetItemData(DragItem.GetParent());
  436.     if(!pData || !pData->pUnk)
  437.         return hr;
  438.     CComPtr<IWMEncTransformCollection> pTrCol;
  439.     hr = pData->pUnk->QueryInterface(IID_IWMEncTransformCollection, (void**)&pTrCol);
  440.     if(SUCCEEDED(hr))
  441.     {
  442.         UINT nDragItemIndex = GetItemIndex(DragItem);
  443.         UINT nHitItemIndex = GetItemIndex(HitItem);
  444.         hr = pTrCol->Move(nDragItemIndex, nHitItemIndex);
  445.     }
  446.     else
  447.     {
  448.         CComPtr<IWMEncSourceGroupCollection> pSGCol;
  449.         hr = pData->pUnk->QueryInterface(IID_IWMEncSourceGroupCollection, (void**)&pSGCol);
  450.         if(SUCCEEDED(hr))
  451.         {
  452.             TREEDATA* pFirst =     (TREEDATA*)m_Tree.GetItemData(DragItem);
  453.             TREEDATA* pSecond = (TREEDATA*)m_Tree.GetItemData(HitItem);
  454.             CComQIPtr<IWMEncSourceGroup> pSGFirst(pFirst->pUnk);
  455.             CComQIPtr<IWMEncSourceGroup> pSGSecond(pSecond->pUnk);
  456.             hr = pSGCol->Move(pSGFirst, pSGSecond);
  457.         }
  458.     }
  459.     HR_TEST(hr);
  460.     // move must have succeeded, so now move the tree items
  461.     hr = MoveTreeItems(hDragItem, hHitItem);
  462.  
  463.     // update the display
  464.     m_Tree.Expand(DragItem.GetParent(), TVE_COLLAPSE | TVE_COLLAPSERESET);
  465.     m_Tree.Expand(DragItem.GetParent());
  466.     
  467.     return hr;
  468. }
  469.  
  470. HRESULT CEncoderView::MoveTreeItems(HTREEITEM hDragItem,HTREEITEM hHitItem)
  471. {
  472.     HRESULT hr = NOERROR;
  473.     TV_INSERTSTRUCT     tvstruct;
  474.     TCHAR               sztBuffer[1024];
  475.  
  476.     tvstruct.item.hItem = hDragItem;
  477.     tvstruct.item.cchTextMax = 49;
  478.     tvstruct.item.pszText = sztBuffer;
  479.     tvstruct.item.mask = TVIF_PARAM | TVIF_CHILDREN | TVIF_HANDLE | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_TEXT;
  480.     m_Tree.GetItem(&tvstruct.item);  // 
  481.     
  482.     TREEDATA* pOldData = (TREEDATA*)(tvstruct.item.lParam);
  483.     _ASSERT(pOldData);
  484.     TREEDATA* pData = new TREEDATA(*pOldData);
  485.     tvstruct.item.lParam = (LPARAM)pData;
  486.  
  487.     // insert the item at new place
  488.     CTreeItem Item(hDragItem,&m_Tree);
  489.     tvstruct.hParent = Item.GetParent();
  490.     tvstruct.hInsertAfter = hHitItem;
  491.     tvstruct.item.mask = TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_TEXT | TVIF_PARAM ;
  492.     CTreeItem NewItem = m_Tree.InsertItem(&tvstruct);
  493.  
  494.     // delete the item at old place
  495.     m_Tree.DeleteItem(hDragItem);
  496.  
  497.     return hr;
  498.  
  499. }
  500.  
  501.  
  502. LRESULT CEncoderView::OnEncoderEvent(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
  503. {
  504.     // get tree item for encoder node
  505.     HTREEITEM hEncItem = (HTREEITEM)wParam;
  506.     if(!hEncItem)
  507.         return 0L;
  508.  
  509.     // get corresponding sink object
  510.     TREEDATA* pData = (TREEDATA*)m_Tree.GetItemData(hEncItem);
  511.     if(!pData)
  512.         return 0L;
  513.     ENCDATA* pEncData = static_cast<ENCDATA*>(pData);
  514.     if(!pEncData)
  515.         return 0L;
  516.     CEncoderEventSink* pSink = reinterpret_cast<CEncoderEventSink*>(pEncData->pEvent);
  517.     if(!pSink)
  518.         return 0L;
  519.     // get event type
  520.     long lEventID = GetEventType(pSink);
  521.     if(!lEventID)
  522.         return 0L;
  523.  
  524.     // get the node
  525.     HTREEITEM hNode = GetEventTreeNode(hEncItem,lEventID);
  526.     if(!hNode)
  527.         return 0L;
  528. // get data associated with so that we can call the corresponding function
  529. /*
  530.     pData = (TREEDATA*) m_Tree.GetItemData(hNode);
  531.     if(!pData)
  532.         return 0L;
  533.  
  534.     LPFNDISPLAY pfn = pData->pfnDisplay ;
  535.     (this->*pfn)(hNode, (LPUNKNOWN)pSink);
  536. */
  537.     m_Tree.Expand(hNode, TVE_COLLAPSE | TVE_COLLAPSERESET);
  538.     m_Tree.Expand(hNode);
  539.  
  540.     return 0L;
  541. }
  542.  
  543.  
  544. HRESULT CEncoderView::InitTreeView()
  545. {
  546.     SHFILEINFO sfi;
  547.     memset(&sfi, 0, sizeof(SHFILEINFO));
  548.     HIMAGELIST hImageList = (HIMAGELIST)SHGetFileInfo((LPCTSTR)_T("C:\\"), 
  549.                                       0,
  550.                                        &sfi, 
  551.                                        sizeof(SHFILEINFO), 
  552.                                        SHGFI_SYSICONINDEX | SHGFI_SMALLICON);
  553.  
  554.     // Attach ImageList to TreeView
  555.     if (hImageList && m_Tree.IsWindow())
  556.         m_Tree.SetImageList(hImageList,0);
  557.     return S_OK;
  558. }
  559.  
  560. void CEncoderView::DeleteChildren(HTREEITEM hItem)
  561. {
  562.     HTREEITEM hChild;
  563.     while((hChild = m_Tree.GetNextItem(hItem,TVGN_CHILD))!=0)
  564.     {
  565.         CTreeItem Child(hChild,&m_Tree);
  566.         Child.Delete();
  567.     }
  568. }
  569.  
  570.  
  571. void CEncoderView::GetNormalAndSelectedIcons(LPITEMIDLIST lpifq,LPTV_ITEM lptvitem)
  572. {
  573.    //Note that we don't check the return value here because if GetIcon()
  574.    //fails, then we're in big trouble...
  575. /*
  576.    lptvitem->iImage = GetIcon(lpifq, SHGFI_PIDL | 
  577.                               SHGFI_SYSICONINDEX | 
  578.                               SHGFI_SMALLICON);
  579.    
  580.    lptvitem->iSelectedImage = GetIcon(lpifq, SHGFI_PIDL | 
  581.                                       SHGFI_SYSICONINDEX | 
  582.                                       SHGFI_SMALLICON |
  583.                                       SHGFI_OPENICON);
  584.   */ 
  585.    return;
  586. }
  587.  
  588. HRESULT CEncoderView::ShowMachineDetails(HTREEITEM hParent, IUnknown* pUnk)
  589. {
  590.     if(!pUnk)
  591.         return E_POINTER;
  592.     _ASSERT(m_Tree.IsWindow());
  593.     HRESULT hr = NOERROR;
  594.     CComQIPtr<IWMEncoderAgent> pAgent(pUnk);
  595.     if(pAgent==NULL)
  596.         return E_NOINTERFACE;
  597.     
  598.     CComPtr<IWMEncoderNamesCollection> pEncCol;
  599.     CComPtr<IDispatch> pDisp;
  600.         hr = pAgent->get_EncoderNamesCollection((LPDISPATCH*)&pDisp);
  601.     HR_TEST(hr);
  602.     
  603.     hr = pDisp->QueryInterface(IID_IWMEncoderNamesCollection, (void**)&pEncCol);
  604.     HR_TEST(hr);
  605.     
  606.     // get name of the encoder and get IWMEncoder pointer from that
  607.     long lCount=0;
  608.     hr = pEncCol->get_Count(&lCount);
  609.     HR_TEST(hr);
  610.     for(long i=0; i<lCount; i++)
  611.     {
  612.         CComPtr<IWMEncoder> pEnc;
  613.         CComPtr<IDispatch> pDisp2;
  614.         CComBSTR bstrName;
  615.         hr = pEncCol->Item(i, &bstrName);
  616.         if(FAILED(hr))
  617.             continue;
  618.         hr = pAgent->GetEncoder(bstrName,(LPDISPATCH*)&pDisp2);
  619.         if(FAILED(hr))
  620.             continue;
  621.         hr = pDisp2->QueryInterface(IID_IWMEncoder, (void**)&pEnc);
  622.         if(FAILED(hr))
  623.             continue;
  624.         
  625.         hr = DisplayEncoder(pEnc.p, hParent);
  626.         if(FAILED(hr))
  627.             continue;
  628.     }
  629.  
  630.     return hr;    
  631. }
  632.  
  633. HRESULT CEncoderView::ShowEncoderDetails(HTREEITEM hParent, IUnknown* pUnk)
  634. {
  635.     if(!pUnk)
  636.         return E_POINTER;
  637.     _ASSERT(m_Tree.IsWindow());
  638.     HRESULT hr = NOERROR;
  639.     CComQIPtr<IWMEncoder> pEnc(pUnk);
  640.     if(pEnc==NULL)
  641.         return E_NOINTERFACE;
  642.     
  643.     VARIANT_BOOL bVal = VARIANT_FALSE;
  644.     CString strRes;
  645.  
  646.     // AUTOSTOP
  647.     CString strText = _T("AutoStop = ");
  648.     hr = InsertProperty(&IWMEncoder::get_AutoStop, pEnc.p, hParent, strText,
  649.         g_mapShortToString);
  650.  
  651.     //EnableAutoArchive
  652.     strText = _T("EnableAutoArchive = ");
  653.     hr = InsertProperty(&IWMEncoder::get_EnableAutoArchive, pEnc.p, hParent, strText,
  654.         g_mapShortToString);
  655.  
  656.     //RunState
  657.     strText = _T("RunState = ");
  658.     hr = InsertProperty(&IWMEncoder::get_RunState, pEnc.p,  hParent, strText,
  659.     g_mapRunState);
  660.  
  661.     // ErrorState
  662.     strText = _T("ErrorState = ");
  663.     hr = InsertProperty(&IWMEncoder::get_ErrorState, pEnc.p,  hParent, strText);
  664.  
  665.     //ArchiveState
  666.     strText = _T("ArchiveState");
  667.     HTREEITEM hItem = InsertNode(hParent, strText,NULL,NULL);
  668.     
  669.     WMENC_ARCHIVE_TYPE enumType = WMENC_ARCHIVE_LOCAL ;
  670.     WMENC_ARCHIVE_STATE arState;
  671.  
  672.     strText = _T("WMENC_ARCHIVE_LOCAL =");
  673.     hr = pEnc->get_ArchiveState(enumType, &arState);
  674.     if(FAILED(hr))
  675.     {
  676.         strRes = GetError();
  677.     }
  678.     else
  679.     {
  680.         strRes = g_archMap[arState];
  681.     }
  682.     strText += strRes;
  683.     m_Tree.InsertItem(strText,hItem,TVI_LAST);
  684.     
  685.  
  686.     //RemoteAdmin
  687.     strText = _T("RemoteAdmin = ");
  688.     hr = InsertProperty(&IWMEncoder::get_RemoteAdmin, pEnc.p,  hParent, strText,g_mapShortToString);
  689.  
  690.     //IndexerState
  691.     strText = _T("IndexerState = ");
  692.     hr = InsertProperty(&IWMEncoder::get_IndexerState, pEnc.p,  hParent, strText,g_mapIndexerState);
  693.  
  694.     //AutoIndex
  695.  
  696.     strText = _T("AutoIndex = ");
  697.     hr = InsertProperty(&IWMEncoder::get_AutoIndex, pEnc.p,  hParent, strText,g_mapShortToString);
  698.  
  699.     //SourceGroupCollection
  700.     strText = _T("SourceGroupCollection");
  701.     InsertNode(hParent, strText, &IWMEncoder::get_SourceGroupCollection, 
  702.         pEnc.p, &CEncoderView::ShowSGCDetails);
  703.  
  704.     // SourcePluginInfoManager
  705.     strText = _T("SourcePluginInfoManager");
  706.     InsertNode(hParent, strText, &IWMEncoder::get_SourcePluginInfoManager, 
  707.         pEnc.p, &CEncoderView::ShowSrcPlInfoMgr);
  708.  
  709.     //IWMEncTransformPluginInfoManager
  710.     strText = _T("TransformPluginInfoManager");
  711.     InsertNode(hParent, strText, &IWMEncoder::get_TransformPluginInfoManager, 
  712.         pEnc.p, &CEncoderView::ShowTrPlInfoMgr);
  713.     
  714.     //IWMEncDisplayInfo
  715.     strText = _T("DisplayInfo");
  716.     InsertNode(hParent, strText, &IWMEncoder::get_DisplayInfo, 
  717.         pEnc.p, &CEncoderView::ShowDisplayInfo);
  718.     
  719.     //IWMEncAttributes
  720.     strText = _T("Attributes");
  721.     InsertNode(hParent, strText, &IWMEncoder::get_Attributes, 
  722.         pEnc.p, &CEncoderView::ShowAttributes);
  723.  
  724.     //IWMEncBroadcast
  725.     strText = _T("Broadcast");
  726.     InsertNode(hParent, strText, &IWMEncoder::get_Broadcast, 
  727.         pEnc.p, &CEncoderView::ShowBroadcast);
  728.  
  729.     //IWMEncFile
  730.     strText = _T("File");
  731.     InsertNode(hParent, strText, &IWMEncoder::get_File, 
  732.         pEnc.p, &CEncoderView::ShowFile);
  733.  
  734.     //IWMEncStatistics
  735.     strText = _T("Statistics");
  736.     InsertNode(hParent, strText, &IWMEncoder::get_Statistics, 
  737.         pEnc.p, &CEncoderView::ShowStatistics);
  738.  
  739.     //IWMEncProfileCollection
  740.     strText = _T("ProfileCollection");
  741.     InsertNode(hParent, strText, &IWMEncoder::get_ProfileCollection, 
  742.         pEnc.p, &CEncoderView::ShowProfileCollection);
  743.     // get the eventsink pointer stored at the node to pass to the event children
  744.  
  745.     ENCDATA* pData = (ENCDATA*) m_Tree.GetItemData(hParent);
  746.     _ASSERT(pData!=NULL);
  747.     // SourceState Events
  748.     strText = g_mapEventIDToDisplayString[DISPID_ENCODEREVENT_SRCSTATECHANGE];
  749.     InsertNode(hParent, strText, (LPUNKNOWN)pData->pEvent, &CEncoderView::ShowSourceStateEvents); 
  750.  
  751.     // Archive state events
  752.     strText = g_mapEventIDToDisplayString[DISPID_ENCODEREVENT_ARCHIVESTATECHANGE];
  753.     InsertNode(hParent, strText, (LPUNKNOWN)pData->pEvent, &CEncoderView::ShowArchiveStateEvents); 
  754.  
  755.     // Client connect events
  756.     strText = g_mapEventIDToDisplayString[DISPID_ENCODEREVENT_CLIENTCONNECT];
  757.     InsertNode(hParent, strText, (LPUNKNOWN)pData->pEvent, &CEncoderView::ShowClientConnectEvents); 
  758.  
  759.     // Client connect events
  760.     strText = g_mapEventIDToDisplayString[DISPID_ENCODEREVENT_STATECHANGE];
  761.     InsertNode(hParent, strText, (LPUNKNOWN)pData->pEvent, &CEncoderView::ShowStateEvents); 
  762.  
  763.     // Client connect events
  764.     strText = g_mapEventIDToDisplayString[DISPID_ENCODEREVENT_CLIENTDISCONNECT];
  765.     InsertNode(hParent, strText, (LPUNKNOWN)pData->pEvent, &CEncoderView::ShowClientDisconnectEvents); 
  766.  
  767.     // Client connect events
  768.     strText = g_mapEventIDToDisplayString[DISPID_ENCODEREVENT_CONFIGCHANGE];
  769.     InsertNode(hParent, strText, (LPUNKNOWN)pData->pEvent, &CEncoderView::ShowConfigEvents); 
  770.  
  771.     // Client connect events
  772.     strText = g_mapEventIDToDisplayString[DISPID_ENCODEREVENT_ERROR];
  773.     InsertNode(hParent, strText, (LPUNKNOWN)pData->pEvent, &CEncoderView::ShowErrorEvents); 
  774.  
  775.     // Client connect events
  776.     strText = g_mapEventIDToDisplayString[DISPID_ENCODEREVENT_INDEXERSTATECHANGE];
  777.     InsertNode(hParent, strText, (LPUNKNOWN)pData->pEvent, &CEncoderView::ShowIndexerStateEvents); 
  778.  
  779.     return hr;
  780.  
  781.  
  782. }
  783.  
  784. HRESULT CEncoderView::ShowSGCDetails(HTREEITEM hItem,IUnknown* pUnk)
  785. {
  786.     if(!pUnk)
  787.         return E_POINTER;
  788.     _ASSERT(m_Tree.IsWindow());
  789.     HRESULT hr = NOERROR;
  790.     CComQIPtr<IWMEncSourceGroupCollection> pSGC(pUnk);
  791.     if(pSGC==NULL)
  792.         return E_NOINTERFACE;
  793.     
  794.     long lCount=0;
  795.     hr = pSGC->get_Count(&lCount);
  796.     HR_TEST(hr);
  797.     USES_CONVERSION;
  798.  
  799.     // get active SG if any and display it accordingly
  800.     CComPtr<IWMEncSourceGroup> pActiveSG;
  801.     hr = pSGC->get_Active(&pActiveSG); 
  802.  
  803.     for(long l=0;l<lCount;l++)
  804.     {
  805.         CComPtr<IWMEncSourceGroup> pSG;
  806.         CComVariant var((long)l);
  807.         hr = pSGC->Item(var, &pSG);
  808.         if(FAILED(hr))
  809.             continue;
  810.         CComBSTR bstrName;
  811.         hr = pSG->get_Name(&bstrName);
  812.         if(FAILED(hr))
  813.             bstrName = _T("No Name");
  814.         CString strText = W2T(bstrName);
  815.         if(pActiveSG.p == pSG.p) // it's active
  816.             strText += _T(" [ACTIVE] ");
  817.  
  818.         InsertNode(hItem,strText,pSG.p,&CEncoderView::ShowSGDetails);
  819.  
  820.     }
  821.  
  822.     return hr;
  823. }
  824.  
  825. HRESULT CEncoderView::ShowSGDetails(HTREEITEM hItem,IUnknown* pUnk)
  826. {
  827.     if(!pUnk)
  828.         return E_POINTER;
  829.     _ASSERT(m_Tree.IsWindow());
  830.     HRESULT hr = NOERROR;
  831.     CComQIPtr<IWMEncSourceGroup> pSG(pUnk);
  832.     if(pSG==NULL)
  833.         return E_NOINTERFACE;
  834.  
  835.     CString strText;
  836.     // display sources
  837.     WMENC_SOURCE_TYPE srcType;
  838.     short sCount=0;
  839.     for( int i = 0 ; i < WMENC_TOTAL ; i++)
  840.     {
  841.         srcType = (WMENC_SOURCE_TYPE)(long) pow(2,i);
  842.         hr = pSG->get_SourceCount(srcType, &sCount);
  843.         if(FAILED(hr))
  844.             continue;
  845.         for(short s=0; s < sCount; s++)
  846.         {
  847.             CComPtr<IWMEncSource> pS;
  848.             hr = pSG->get_Source(srcType, s, &pS);
  849.             if(FAILED(hr))
  850.                 continue;
  851.             CString strText;
  852.             strText.Format(_T("%s %d"),g_mapSourceType[srcType], s);
  853.             InsertNode(hItem, strText, pS.p, &CEncoderView::ShowSrcDetails);
  854.         }
  855.     }
  856.  
  857.     // DISPLAY profile
  858.     CComPtr<IWMEncProfile> pProf;
  859.     hr = pSG->get_Profile(&pProf);
  860.     if(SUCCEEDED(hr))
  861.     {
  862.         strText = _T("Profile = ");
  863.         CComBSTR bstrText;
  864.         hr = pProf->get_Name(&bstrText);
  865.         USES_CONVERSION;
  866.         strText += W2T(bstrText);
  867.         InsertNode(hItem, strText, pProf.p, &CEncoderView::ShowProfile);
  868.     }
  869.  
  870.     // AudienceCollection
  871.     strText = _T("AudienceCollection");
  872.     InsertNode(hItem,strText,&IWMEncSourceGroup::get_AudienceCollection, 
  873.         pSG.p, &CEncoderView::ShowAudienceCollection);
  874.  
  875.     //AutoArcive
  876.     strText = _T("AutoArcive");
  877.     HTREEITEM hChild = InsertNode(hItem, strText,NULL,NULL);
  878.  
  879.     WMENC_ARCHIVE_TYPE enumType = WMENC_ARCHIVE_LOCAL ;
  880.     WMENC_ARCHIVE_OPERATION archOp;
  881.     hr = pSG->get_AutoArchive(enumType, &archOp);
  882.     strText = _T("WMENC_ARCHIVE_LOCAL =");
  883.     CString strRes;
  884.     if(FAILED(hr))
  885.     {
  886.         strRes = GetError();
  887.     }
  888.     else
  889.     {
  890.         strRes = g_mapArchOp[archOp];
  891.     }
  892.     strText += strRes;
  893.     m_Tree.InsertItem(strText,hChild,TVI_LAST);
  894.     
  895.     //GroupTransformCollection
  896.     strText = _T("GroupTransformCollection");
  897.     InsertNode(hItem, strText, &IWMEncSourceGroup::get_GroupTransformCollection, pSG.p,
  898.         &CEncoderView::ShowGroupTransformCollection);
  899.  
  900.     //GetGroupTransformPluginCount
  901.     strText = _T("GetGroupTransformPluginCount = ");
  902.     hr = InsertProperty(&IWMEncSourceGroup::GetGroupTransformPluginCount, pSG.p, hItem, strText);
  903.  
  904.     return hr;
  905. }
  906.  
  907. HRESULT CEncoderView::ShowProfile(HTREEITEM hItem,IUnknown* pUnk)
  908. {
  909.     if(!pUnk)
  910.         return E_POINTER;
  911.     _ASSERT(m_Tree.IsWindow());
  912.     HRESULT hr = NOERROR;
  913.     CComQIPtr<IWMEncProfile> pProf(pUnk);
  914.     if(pProf==NULL)
  915.         return E_NOINTERFACE;
  916.     
  917.     CString strText;
  918.     //Description
  919.     strText = _T("Description = ");
  920.     InsertPropertyBSTR(&IWMEncProfile::get_Description, pProf.p, hItem, strText);
  921.     
  922.     //MediaCount
  923.     strText = _T("MediaCount");
  924.     HTREEITEM hChild = m_Tree.InsertItem(strText,hItem,TVI_LAST);
  925.  
  926.     WMENC_SOURCE_TYPE srcType;
  927.     short sCount=0;
  928.     for( int i = 0 ; i < WMENC_TOTAL ; i++)
  929.     {
  930.         srcType = (WMENC_SOURCE_TYPE)(long) pow(2,i);
  931.         hr = pProf->get_MediaCount(srcType, &sCount);
  932.         if(FAILED(hr))
  933.             continue;
  934.         CString strText;
  935.         strText.Format(_T("%s = %d"),g_mapSourceType[srcType], sCount);
  936.         m_Tree.InsertItem(strText,hChild,TVI_LAST);
  937.         
  938.     }
  939.  
  940.     //MultipleBitrate
  941.     strText = _T("MultipleBitrate = ");
  942.     hr = InsertProperty(&IWMEncProfile::get_MultipleBitrate, pProf.p, hItem, strText,
  943.         g_mapShortToString);
  944.     
  945.     // MaxPacketSize
  946.     strText = _T("MaxPacketSize = ");
  947.     hr = InsertProperty(&IWMEncProfile::get_MaxPacketSize, pProf.p, hItem, strText);
  948.  
  949.     return hr;
  950.  
  951. }
  952.  
  953. // no implementation
  954. HRESULT CEncoderView::ShowAudienceCollection(HTREEITEM hItem,IUnknown* pUnk)
  955. {
  956.     HRESULT hr = NOERROR;
  957.     
  958.     return hr;
  959. }
  960.  
  961. HRESULT CEncoderView::ShowSrcDetails(HTREEITEM hItem,IUnknown* pUnk)
  962. {
  963.     if(!pUnk)
  964.         return E_POINTER;
  965.     _ASSERT(m_Tree.IsWindow());
  966.     HRESULT hr = NOERROR;
  967.     CComQIPtr<IWMEncSource> pSrc(pUnk);
  968.     if(pSrc==NULL)
  969.         return E_NOINTERFACE;
  970.  
  971.     // we show source details first and then QI for video source
  972.     // Input
  973.     CComBSTR bstrStreamName, bstrScheme, bstrInput;
  974.     hr = pSrc->GetInput(&bstrStreamName, &bstrScheme, &bstrInput);
  975.     CString strStreamName = _T("StreamName = ");
  976.     CString strScheme = _T("Scheme = ");
  977.     CString strInput = _T("Input = ");
  978.     if(SUCCEEDED(hr))
  979.     {
  980.         USES_CONVERSION;
  981.         strStreamName += W2T(bstrStreamName);
  982.         strScheme += W2T(bstrScheme);
  983.         strInput += W2T(bstrInput);
  984.     }
  985.     else
  986.     {
  987.         CString strRes = GetError();
  988.         strStreamName += strRes;
  989.         strScheme += strRes;
  990.         strInput += strRes;
  991.     }
  992.     m_Tree.InsertItem(strStreamName,hItem,TVI_LAST);
  993.     m_Tree.InsertItem(strScheme,hItem,TVI_LAST);
  994.     m_Tree.InsertItem(strInput,hItem,TVI_LAST);
  995.  
  996.     // Repeat
  997.     CString strText = _T("Repeat = ");
  998.     hr = InsertProperty(&IWMEncSource::get_Repeat, pSrc.p, hItem, strText,
  999.         g_mapShortToString);
  1000.     
  1001.     // MarkIn
  1002.     strText = _T("MarkIn = ");
  1003.     hr = InsertProperty(&IWMEncSource::get_MarkIn, pSrc.p, hItem, strText);
  1004.  
  1005.     // MarkOut
  1006.     strText = _T("MarkOut = ");
  1007.     hr = InsertProperty(&IWMEncSource::get_MarkOut, pSrc.p, hItem, strText);
  1008.  
  1009.     //TransformCollection
  1010.     strText = _T("TransformCollection");
  1011.     InsertNode(hItem, strText, IWMEncSource::get_TransformCollection,
  1012.         pSrc.p,&CEncoderView::ShowTransformDetails);
  1013.  
  1014.     //PreviewCollection
  1015.     strText = _T("PreviewCollection");
  1016.     InsertNode(hItem, strText, IWMEncSource::get_PreviewCollection,
  1017.         pSrc.p,&CEncoderView::ShowPreviewCollection);
  1018.  
  1019.     //PostviewCollection
  1020.     strText = _T("PostviewCollection");
  1021.     InsertNode(hItem, strText, IWMEncSource::get_PostviewCollection,
  1022.         pSrc.p,&CEncoderView::ShowPostviewCollection);
  1023.  
  1024.  
  1025.  
  1026.     return hr;
  1027. }
  1028.  
  1029. HRESULT CEncoderView::ShowGroupTransformCollection(HTREEITEM hItem,IUnknown* pUnk)
  1030. {
  1031.     return ShowTransformDetails(hItem,pUnk);
  1032. }
  1033.  
  1034. HRESULT CEncoderView::ShowTransformDetails(HTREEITEM hItem,IUnknown* pUnk)
  1035. {
  1036.     if(!pUnk)
  1037.         return E_POINTER;
  1038.     _ASSERT(m_Tree.IsWindow());
  1039.     HRESULT hr = NOERROR;
  1040.     CComQIPtr<IWMEncTransformCollection> pTrCol(pUnk);
  1041.     if(pTrCol==NULL)
  1042.         return E_NOINTERFACE;
  1043.  
  1044.     long lCount = 0;
  1045.     hr = pTrCol->get_Count(&lCount);
  1046.     HR_TEST(hr);
  1047.     for(long l=0; l< lCount ; l++)
  1048.     {
  1049.         CComPtr<IWMEncTransform> pTr;
  1050.         hr = pTrCol->Item(l,&pTr);
  1051.         if(!pTr)
  1052.             continue;
  1053.         CComBSTR bstrInitData, bstrScheme, bstrInput;
  1054.         hr = pTr->GetInput(&bstrScheme, &bstrInitData, &bstrInput);
  1055.  
  1056.         CString strInitData = _T("InitData = "), strScheme = _T("Scheme = "), strInput = _T("Input = ");
  1057.         USES_CONVERSION;
  1058.         strInitData += W2T(bstrInitData);
  1059.         strScheme += W2T(bstrScheme);
  1060.         strInput += W2T(bstrInput);
  1061.  
  1062.         m_Tree.InsertItem(strInitData,hItem,TVI_LAST);
  1063.         m_Tree.InsertItem(strScheme,hItem,TVI_LAST);
  1064.         m_Tree.InsertItem(strInput,hItem,TVI_LAST);
  1065.     }
  1066.     
  1067.     return hr;
  1068. }
  1069.  
  1070. HRESULT CEncoderView::ShowPreviewCollection(HTREEITEM hItem,IUnknown* pUnk)
  1071. {
  1072.     return ShowPreOrPostViewCollection(hItem,pUnk);
  1073. }
  1074.  
  1075. HRESULT CEncoderView::ShowPostviewCollection(HTREEITEM hItem,IUnknown* pUnk)
  1076. {
  1077.     return ShowPreOrPostViewCollection(hItem,pUnk);
  1078. }
  1079.  
  1080. HRESULT CEncoderView::ShowPreOrPostViewCollection(HTREEITEM hItem,IUnknown* pUnk)
  1081. {
  1082.     if(!pUnk)
  1083.         return E_POINTER;
  1084.     _ASSERT(m_Tree.IsWindow());
  1085.     HRESULT hr = NOERROR;
  1086.     CComQIPtr<IWMEncDataViewCollection> pViewCol(pUnk);
  1087.     if(pViewCol==NULL)
  1088.         return E_NOINTERFACE;
  1089.     
  1090.     long lCount = 0;
  1091.     hr = pViewCol->get_Count(&lCount);
  1092.     HR_TEST(hr);
  1093.     for(long i=0; i<lCount;i++)
  1094.     {
  1095.         CComPtr<IUnknown> pUnk;
  1096.         long dwCookie = 0;
  1097.         hr = pViewCol->Item(i,&pUnk,&dwCookie);
  1098.         HR_TEST(hr);
  1099.         CString strText;
  1100.         strText.Format(_T("Cookie = %d"), dwCookie);
  1101.         m_Tree.InsertItem(strText,hItem,TVI_LAST);
  1102.  
  1103.     }
  1104.     return hr;
  1105. }
  1106.  
  1107. HRESULT CEncoderView::ShowSrcPlInfoMgr(HTREEITEM hItem,IUnknown* pUnk)
  1108. {
  1109.     CComQIPtr<IWMEncSourcePluginInfoManager> p(pUnk);
  1110.     if(p==NULL)
  1111.         return E_NOINTERFACE;
  1112.  
  1113.     return ShowCollection(hItem,p.p, &CEncoderView::ShowSrcPlInfo, (IWMEncPluginInfo*)NULL);
  1114. }
  1115.  
  1116. HRESULT CEncoderView::ShowSrcPlInfo(HTREEITEM hParent, IUnknown* pUnk)
  1117. {
  1118.     HRESULT hr = NOERROR;
  1119.     CString strText;
  1120.     
  1121.     CComQIPtr<IWMEncPluginInfo> pSrcPlInfo(pUnk);
  1122.     if(pSrcPlInfo==NULL)
  1123.         return E_NOINTERFACE;
  1124.  
  1125.     //Schemetype
  1126.     strText = _T("Schemetype = ");
  1127.     InsertPropertyBSTR(&IWMEncPluginInfo::get_SchemeType, pSrcPlInfo.p, hParent, strText);
  1128.  
  1129.     //CLSID
  1130.     strText = _T("CLSID = ");
  1131.     InsertPropertyBSTR(&IWMEncPluginInfo::get_CLSID, pSrcPlInfo.p, hParent, strText);
  1132.     
  1133.     //Name
  1134.     strText = _T("Name = ");
  1135.     InsertPropertyBSTR(&IWMEncPluginInfo::get_Name, pSrcPlInfo.p, hParent, strText);
  1136.  
  1137.     //MediaType
  1138.     strText = _T("MediaType = ");
  1139.     InsertProperty(&IWMEncPluginInfo::get_MediaType, pSrcPlInfo.p, hParent, strText, g_mapSourceType);
  1140.  
  1141.     //PluginType
  1142.     strText = _T("PluginType = ");
  1143.     InsertProperty(&IWMEncPluginInfo::get_PluginType, pSrcPlInfo.p, hParent, strText, g_mapPluginType);
  1144.  
  1145.     //Copyright
  1146.     strText = _T("Copyright = ");
  1147.     InsertPropertyBSTR(&IWMEncPluginInfo::get_Copyright, pSrcPlInfo.p, hParent, strText);
  1148.  
  1149.     //InfoURL
  1150.     strText = _T("InfoURL = ");
  1151.     InsertPropertyBSTR(&IWMEncPluginInfo::get_InfoURL, pSrcPlInfo.p, hParent, strText);
  1152.     
  1153.     //Resources
  1154.     strText = _T("Resources = ");
  1155.     InsertProperty(&IWMEncPluginInfo::get_Resources, pSrcPlInfo.p, hParent, strText, g_mapShortToString);
  1156.  
  1157.     //Exclusive
  1158.     strText = _T("Exclusive = ");
  1159.     InsertProperty(&IWMEncPluginInfo::get_Exclusive, pSrcPlInfo.p, hParent, strText, g_mapShortToString);
  1160.  
  1161.     //PropertyPage
  1162.     strText = _T("PropertyPage = ");
  1163.     InsertProperty(&IWMEncPluginInfo::get_PropertyPage, pSrcPlInfo.p, hParent, strText, g_mapShortToString);
  1164.  
  1165.     //TransformFlags
  1166.     strText = _T("TransformFlags = ");
  1167.     InsertProperty(&IWMEncPluginInfo::get_TransformFlags, pSrcPlInfo.p, hParent, strText);
  1168.  
  1169.     //Hidden
  1170.     strText = _T("Hidden = ");
  1171.     InsertProperty(&IWMEncPluginInfo::get_Hidden, pSrcPlInfo.p, hParent, strText, g_mapShortToString);
  1172.  
  1173.     //Count
  1174.     strText = _T("Count = ");
  1175.     InsertProperty(&IWMEncPluginInfo::get_Count, pSrcPlInfo.p, hParent, strText);
  1176.  
  1177.     // Item 
  1178.  
  1179.  
  1180.     return hr;
  1181. }
  1182.  
  1183. HRESULT CEncoderView::ShowTrPlInfoMgr(HTREEITEM hItem,IUnknown* pUnk)
  1184. {
  1185.     CComQIPtr<IWMEncTransformPluginInfoManager> pTRI(pUnk);
  1186.     if(pTRI==NULL)
  1187.         return E_NOINTERFACE;
  1188.  
  1189.     return ShowCollection(hItem,pTRI.p, &CEncoderView::ShowSrcPlInfo, (IWMEncPluginInfo*)NULL);
  1190. }
  1191.  
  1192. HRESULT CEncoderView::ShowDisplayInfo(HTREEITEM hItem,IUnknown* pUnk)
  1193. {
  1194.     if(!pUnk)
  1195.         return E_POINTER;
  1196.     _ASSERT(m_Tree.IsWindow());
  1197.     HRESULT hr = NOERROR;
  1198.     CComQIPtr<IWMEncDisplayInfo> pDI(pUnk);
  1199.     if(pDI==NULL)
  1200.         return E_NOINTERFACE;
  1201.     
  1202.  
  1203.  
  1204.     return hr;
  1205. }
  1206.  
  1207. HRESULT CEncoderView::ShowAttributes(HTREEITEM hItem,IUnknown* pUnk)
  1208. {
  1209.     if(!pUnk)
  1210.         return E_POINTER;
  1211.     _ASSERT(m_Tree.IsWindow());
  1212.     HRESULT hr = NOERROR;
  1213.     CComQIPtr<IWMEncAttributes> pAttr(pUnk);
  1214.     if(pAttr==NULL)
  1215.         return E_NOINTERFACE;
  1216.     
  1217.     long lCount=0;
  1218.     hr = pAttr->get_Count(&lCount);
  1219.     HR_TEST(hr);
  1220.     for(long l=0; l<lCount;l++)
  1221.     {
  1222.         CComBSTR bstrName;
  1223.         CComVariant val;
  1224.         hr = pAttr->Item(l,&bstrName,&val);
  1225.         if(FAILED(hr))
  1226.             continue;
  1227.         USES_CONVERSION;
  1228.         CString strText;
  1229.         switch(val.vt)
  1230.         {
  1231.         case VT_BSTR :
  1232.             strText.Format(_T("%s = %s"), W2T(bstrName), W2T(val.bstrVal));
  1233.             break;
  1234.         case VT_I2:
  1235.             strText.Format(_T("%s = %d"), W2T(bstrName), val.iVal);
  1236.             break;
  1237.  
  1238.         case VT_I4:
  1239.             strText.Format(_T("%s = %d"), W2T(bstrName), val.lVal);
  1240.             break;
  1241.  
  1242.         default:
  1243.             break;
  1244.         }
  1245.  
  1246.         m_Tree.InsertItem(strText,hItem,TVI_LAST);
  1247.     
  1248.     }
  1249.  
  1250.  
  1251.     return hr;
  1252. }
  1253.  
  1254. HRESULT CEncoderView::ShowBroadcast(HTREEITEM hItem,IUnknown* pUnk)
  1255. {
  1256.     if(!pUnk)
  1257.         return E_POINTER;
  1258.     _ASSERT(m_Tree.IsWindow());
  1259.     HRESULT hr = NOERROR;
  1260.     CComQIPtr<IWMEncBroadcast> pBR(pUnk);
  1261.     if(pBR==NULL)
  1262.         return E_NOINTERFACE;
  1263.     
  1264.     // port number
  1265.     WMENC_BROADCAST_PROTOCOL protocol = WMENC_PROTOCOL_HTTP;
  1266.     long sPort = 0;
  1267.     hr = pBR->get_PortNumber(protocol, &sPort);
  1268.     HR_TEST(hr);
  1269.     CString strText;
  1270.     strText.Format(_T("WMENC_PROTOCOL_HTTP = %d"), sPort);
  1271.  
  1272.     m_Tree.InsertItem(strText,hItem,TVI_LAST);
  1273.  
  1274.     return hr;
  1275. }
  1276.  
  1277. HRESULT CEncoderView::ShowFile(HTREEITEM hItem,IUnknown* pUnk)
  1278. {
  1279.     if(!pUnk)
  1280.         return E_POINTER;
  1281.     _ASSERT(m_Tree.IsWindow());
  1282.     HRESULT hr = NOERROR;
  1283.     CComQIPtr<IWMEncFile> pFile(pUnk);
  1284.     if(pFile==NULL)
  1285.         return E_NOINTERFACE;
  1286.     
  1287.     CString strFile;
  1288.     CComBSTR bstrFile;
  1289.     USES_CONVERSION;
  1290.     hr = pFile->get_LocalFileName(&bstrFile);
  1291.     if(SUCCEEDED(hr) && bstrFile)
  1292.     {
  1293.         strFile.Format(_T("LocalFileName = %s"), W2T(bstrFile));
  1294.         m_Tree.InsertItem(strFile,hItem,TVI_LAST);
  1295.         strFile.Empty();
  1296.         bstrFile.Empty();
  1297.     }
  1298.     
  1299.     hr = pFile->get_RemoteFileName(&bstrFile);
  1300.     if(SUCCEEDED(hr))
  1301.     {
  1302.         strFile.Format(_T("LocalFileName = %s"), W2T(bstrFile));
  1303.         m_Tree.InsertItem(strFile,hItem,TVI_LAST);
  1304.         strFile.Empty();
  1305.     }
  1306.     
  1307.     return hr; 
  1308. }
  1309.  
  1310. HRESULT CEncoderView::ShowStatistics(HTREEITEM hItem,IUnknown* pUnk)
  1311. {
  1312.     if(!pUnk)
  1313.         return E_POINTER;
  1314.     _ASSERT(m_Tree.IsWindow());
  1315.     HRESULT hr = NOERROR;
  1316.     CComQIPtr<IWMEncStatistics> pStats(pUnk);
  1317.     if(pStats==NULL)
  1318.         return E_NOINTERFACE;
  1319.     
  1320.     //EncodingTime
  1321.     InsertProperty(&IWMEncStatistics::get_EncodingTime,pStats.p, hItem, _T("EncodingTime = "));
  1322.     
  1323.     //StreamOutputCount
  1324.     CString strText = _T("StreamOutputCount");
  1325.     HTREEITEM hChild = InsertNode(hItem, strText,NULL,NULL);
  1326.     WMENC_SOURCE_TYPE srcType;
  1327.     for( int i = 0 ; i < WMENC_TOTAL ; i++)
  1328.     {
  1329.         srcType = (WMENC_SOURCE_TYPE)(long) pow(2,i);
  1330.         short nStreamCount=0;
  1331.         hr = pStats->get_StreamOutputCount(srcType,0,&nStreamCount);
  1332.         if(FAILED(hr))
  1333.             continue;
  1334.         strText.Format(_T("WMENC_SOURCE_TYPE = %s MediaIndex = %d SreamOutputCount = %d"), 
  1335.             g_mapSourceType[srcType], 0, nStreamCount);
  1336.         m_Tree.InsertItem(strText,hChild,TVI_LAST);
  1337.  
  1338.     }
  1339.  
  1340.     //WMFOutputStats
  1341.     InsertNode(hItem,_T("WMFOutputStats"),&IWMEncStatistics::get_WMFOutputStats,pStats.p,
  1342.         &CEncoderView::ShowWMFOutputStats);
  1343.  
  1344.     //NetConnectionStats
  1345.     InsertNode(hItem,_T("NetConnectionStats"),&IWMEncStatistics::get_NetConnectionStats,pStats.p,
  1346.         &CEncoderView::ShowNetConnectionStats);
  1347.  
  1348.     //FileArchiveStats
  1349.     InsertNode(hItem,_T("FileArchiveStats"),&IWMEncStatistics::get_FileArchiveStats,pStats.p,
  1350.         &CEncoderView::ShowFileArchiveStats);
  1351.  
  1352.     //IndexerStats
  1353.     InsertNode(hItem,_T("IndexerStats"),&IWMEncStatistics::get_IndexerStats,pStats.p,
  1354.         &CEncoderView::ShowIndexerStats);
  1355.  
  1356.  
  1357.     return hr;
  1358. }
  1359.  
  1360. HRESULT CEncoderView::ShowWMFOutputStats(HTREEITEM hItem,IUnknown* pUnk)
  1361. {
  1362.     if(!pUnk)
  1363.         return E_POINTER;
  1364.     _ASSERT(m_Tree.IsWindow());
  1365.     HRESULT hr = NOERROR;
  1366.     CComQIPtr<IWMEncOutputStats > pWMFStats(pUnk);
  1367.     if(pWMFStats==NULL)
  1368.         return E_NOINTERFACE;
  1369.     
  1370.     CString strText;
  1371.     //SampleCount
  1372.     strText = _T("SampleCount = ");
  1373.     hr = InsertProperty(&IWMEncOutputStats::get_SampleCount, pWMFStats.p,  hItem, strText);
  1374.  
  1375.     //ByteCount
  1376.     strText = _T("ByteCount = ");
  1377.     hr = InsertProperty(&IWMEncOutputStats::get_ByteCount, pWMFStats.p,  hItem, strText);
  1378.  
  1379.     //DroppedSampleCount
  1380.     strText = _T("DroppedSampleCount = ");
  1381.     hr = InsertProperty(&IWMEncOutputStats::get_DroppedSampleCount, pWMFStats.p,  hItem, strText);
  1382.  
  1383.     //DroppedByteCount
  1384.     strText = _T("DroppedByteCount = ");
  1385.     hr = InsertProperty(&IWMEncOutputStats::get_DroppedByteCount, pWMFStats.p,  hItem, strText);
  1386.  
  1387.     //CurrentBitrate
  1388.     strText = _T("CurrentBitrate = ");
  1389.     hr = InsertProperty(&IWMEncOutputStats::get_CurrentBitrate, pWMFStats.p,  hItem, strText);
  1390.  
  1391.     //AverageBitrate
  1392.     strText = _T("AverageBitrate = ");
  1393.     hr = InsertProperty(&IWMEncOutputStats::get_AverageBitrate, pWMFStats.p,  hItem, strText);
  1394.  
  1395.     //ExpectedBitrate
  1396.     strText = _T("ExpectedBitrate = ");
  1397.     hr = InsertProperty(&IWMEncOutputStats::get_ExpectedBitrate, pWMFStats.p,  hItem, strText);
  1398.  
  1399.     //CurrentSampleRate
  1400.     strText = _T("CurrentSampleRate = ");
  1401.     hr = InsertProperty(&IWMEncOutputStats::get_CurrentSampleRate, pWMFStats.p,  hItem, strText);
  1402.  
  1403.     //AverageSampleRate
  1404.     strText = _T("AverageSampleRate = ");
  1405.     hr = InsertProperty(&IWMEncOutputStats::get_AverageSampleRate, pWMFStats.p,  hItem, strText);
  1406.  
  1407.     //ExpectedSampleRate
  1408.     strText = _T("ExpectedSampleRate = ");
  1409.     hr = InsertProperty(&IWMEncOutputStats::get_ExpectedSampleRate, pWMFStats.p,  hItem, strText);
  1410.  
  1411.     return hr;
  1412. }
  1413.  
  1414. HRESULT CEncoderView::ShowNetConnectionStats(HTREEITEM hItem,IUnknown* pUnk)
  1415. {
  1416.     if(!pUnk)
  1417.         return E_POINTER;
  1418.     _ASSERT(m_Tree.IsWindow());
  1419.     HRESULT hr = NOERROR;
  1420.     CComQIPtr<IWMEncNetConnectionStats > pNetConStats(pUnk);
  1421.     if(pNetConStats==NULL)
  1422.         return E_NOINTERFACE;
  1423.  
  1424.     // Get client count first
  1425.     long lCount = 0;
  1426.     hr = pNetConStats->get_ClientCount(&lCount);
  1427.     USES_CONVERSION;
  1428.     for(long l=0; l<lCount;l++)
  1429.     {
  1430.         CComBSTR bstrIP;
  1431.         WMENC_BROADCAST_PROTOCOL br;
  1432.         hr = pNetConStats->get_ClientInfo(l,&br,&bstrIP);
  1433.         if(FAILED(hr))
  1434.             continue;
  1435.         // since we know this is the only protocol we are supporting 
  1436.         // there is no need to have the protocol type displayed as well
  1437.         m_Tree.InsertItem(W2T(bstrIP),hItem,TVI_LAST);
  1438.     }
  1439.     return hr;
  1440. }
  1441.  
  1442.  
  1443. HRESULT CEncoderView::ShowFileArchiveStats(HTREEITEM hItem,IUnknown* pUnk)
  1444. {
  1445.     if(!pUnk)
  1446.         return E_POINTER;
  1447.     _ASSERT(m_Tree.IsWindow());
  1448.     HRESULT hr = NOERROR;
  1449.     CComQIPtr<IWMEncFileArchiveStats> pFileArcStats(pUnk);
  1450.     if(pFileArcStats==NULL)
  1451.         return E_NOINTERFACE;
  1452.  
  1453.     //FileSize
  1454.     WMENC_LONGLONG llOutputSize;
  1455.     hr = pFileArcStats->get_FileSize(&llOutputSize);
  1456.     if(SUCCEEDED(hr))
  1457.     {
  1458.         CString strText;
  1459.         strText.Format(_T("FileSize = %d"), llOutputSize);
  1460.         m_Tree.InsertItem(strText,hItem,TVI_LAST);
  1461.     }
  1462.  
  1463.     //FileDuration
  1464.     WMENC_LONGLONG llDuration;
  1465.     hr = pFileArcStats->get_FileDuration(&llDuration);
  1466.     if(SUCCEEDED(hr))
  1467.     {
  1468.         CString strText;
  1469.         strText.Format(_T("FileDuration = %d"), llDuration);
  1470.         m_Tree.InsertItem(strText,hItem,TVI_LAST);
  1471.     }
  1472.  
  1473.     return hr;
  1474. }
  1475.  
  1476. HRESULT CEncoderView::ShowIndexerStats(HTREEITEM hItem,IUnknown* pUnk)
  1477. {
  1478.     if(!pUnk)
  1479.         return E_POINTER;
  1480.     _ASSERT(m_Tree.IsWindow());
  1481.     HRESULT hr = NOERROR;
  1482.     CComQIPtr<IWMEncIndexerStats  > pIndexerStats(pUnk);
  1483.     if(pIndexerStats==NULL)
  1484.         return E_NOINTERFACE;
  1485.  
  1486.     long lCount = 0;
  1487.     hr = pIndexerStats->get_FileCount(&lCount);
  1488.     HR_TEST(hr);
  1489.     USES_CONVERSION;
  1490. // FileName
  1491.     for(long l=0; l<lCount;l++)
  1492.     {
  1493.         CComBSTR bstrFile;
  1494.         hr = pIndexerStats->get_FileName(l,&bstrFile);
  1495.         if(FAILED(hr))
  1496.             continue;
  1497.         m_Tree.InsertItem(W2T(bstrFile),hItem,TVI_LAST);
  1498.     }
  1499.  
  1500. //PercentComplete
  1501.     InsertProperty(&IWMEncIndexerStats::get_PercentComplete, pIndexerStats.p,
  1502.         hItem, _T("PercentComplete = "));
  1503.  
  1504.     return hr;
  1505. }
  1506.  
  1507. HRESULT CEncoderView::ShowProfileCollection(HTREEITEM hItem,IUnknown* pUnk)
  1508. {
  1509.     if(!pUnk)
  1510.         return E_POINTER;
  1511.     _ASSERT(m_Tree.IsWindow());
  1512.     HRESULT hr = NOERROR;
  1513.     CComQIPtr<IWMEncProfileCollection> pProfCol(pUnk);
  1514.     if(pProfCol==NULL)
  1515.         return E_NOINTERFACE;
  1516.     
  1517.     return ShowCollection(hItem,pProfCol.p, &CEncoderView::ShowProfile, (IWMEncProfile*)NULL);
  1518.     return hr;
  1519. }
  1520.  
  1521.  
  1522. STDMETHODIMP CEncoderView::AddMachine(BSTR bstrMachineName)
  1523. {
  1524.     if(!bstrMachineName)
  1525.     {
  1526.         return E_POINTER;
  1527.     }
  1528.     
  1529.     USES_CONVERSION;
  1530.     CString strMachine = W2T(bstrMachineName);
  1531.     m_vecMachines.push_back(strMachine);
  1532.     return S_OK;
  1533. }
  1534.  
  1535. long CEncoderView::GetEventType(CEncoderEventSink* pSink)
  1536. {
  1537.     _ASSERT(pSink!=NULL);
  1538.     if(!pSink)
  1539.         return 0;
  1540.  
  1541.     map<HANDLE,long> mapEventHandleToEventID;
  1542.     
  1543.     // initialize map with dispids
  1544.     mapEventHandleToEventID[pSink->m_eveArchiveState] = DISPID_ENCODEREVENT_ARCHIVESTATECHANGE;
  1545.     mapEventHandleToEventID[pSink->m_eveClientConnect] = DISPID_ENCODEREVENT_CLIENTCONNECT;
  1546.     mapEventHandleToEventID[pSink->m_eveClientDisconnect] = DISPID_ENCODEREVENT_CLIENTDISCONNECT;
  1547.     mapEventHandleToEventID[pSink->m_eveConfig] = DISPID_ENCODEREVENT_CONFIGCHANGE;
  1548.     mapEventHandleToEventID[pSink->m_eveError] = DISPID_ENCODEREVENT_ERROR;
  1549.     mapEventHandleToEventID[pSink->m_eveIndexerState] = DISPID_ENCODEREVENT_INDEXERSTATECHANGE;
  1550.     mapEventHandleToEventID[pSink->m_eveSourceState] = DISPID_ENCODEREVENT_SRCSTATECHANGE;
  1551.     mapEventHandleToEventID[pSink->m_eveStateChange] = DISPID_ENCODEREVENT_STATECHANGE;
  1552.  
  1553.     HANDLE hEve[] = 
  1554.     {
  1555.         pSink->m_eveArchiveState
  1556.         ,pSink->m_eveClientConnect
  1557.         ,pSink->m_eveClientDisconnect
  1558.         ,pSink->m_eveConfig
  1559.         ,pSink->m_eveError
  1560.         ,pSink->m_eveIndexerState
  1561.         ,pSink->m_eveSourceState
  1562.         ,pSink->m_eveStateChange
  1563.     };
  1564.  
  1565.     // we know atleast one of them is certainly set
  1566.     DWORD nCount = sizeof(hEve)/sizeof(HANDLE);
  1567.  
  1568.     DWORD dwRet = ::WaitForMultipleObjects(nCount,hEve,FALSE,INFINITE); 
  1569.     
  1570.     return mapEventHandleToEventID[ hEve[dwRet-WAIT_OBJECT_0] ]; 
  1571.     
  1572. }
  1573.  
  1574. // we return tree node corrseponding to this event, 
  1575. // to do this, we simply look in the map we store to get the display string for the id first and then
  1576. // get the treeitem from string
  1577. HTREEITEM CEncoderView::GetEventTreeNode(HTREEITEM hParent, long lEventID)
  1578. {
  1579.     CString strText = g_mapEventIDToDisplayString[lEventID];
  1580.     if(strText.IsEmpty())
  1581.         return NULL;
  1582.  
  1583.     HTREEITEM hChild = NULL;
  1584.     hChild = m_Tree.GetNextItem(hParent,TVGN_CHILD);
  1585.     while(hChild!=0)
  1586.     {
  1587.         CTreeItem Child(hChild,&m_Tree);
  1588.         CString strLabel;
  1589.         if(Child.GetText(strLabel))
  1590.         {
  1591.             if(strText==strLabel)
  1592.                 return hChild;
  1593.         }
  1594.         hChild = m_Tree.GetNextItem(hChild,TVGN_NEXT);
  1595.     }
  1596.     
  1597.     return NULL;
  1598. }
  1599.  
  1600. HRESULT CEncoderView::ShowArchiveStateEvents(HTREEITEM hItem,IUnknown* pUnk)
  1601. {
  1602.     HRESULT hr = NOERROR;
  1603.     CEncoderEventSink* pSink = reinterpret_cast<CEncoderEventSink*>(pUnk);
  1604.     if(!pSink)
  1605.         return E_FAIL;
  1606.  
  1607.     // show arcive state
  1608.     CString strText;
  1609.     strText.Format(_T("%s = %s"), _T("WMENC_ARCHIVE_LOCAL"),
  1610.         g_mapArchOp[pSink->m_archiveStateChange.m_archiveOperation]);
  1611.  
  1612.     HTREEITEM hChild = m_Tree.InsertItem(strText,hItem,TVI_LAST);
  1613.  
  1614.     return hr;
  1615.  
  1616. }
  1617.  
  1618. HRESULT CEncoderView::ShowClientConnectEvents(HTREEITEM hItem,IUnknown* pUnk)
  1619. {
  1620.     HRESULT hr = NOERROR;
  1621.     CEncoderEventSink* pSink = reinterpret_cast<CEncoderEventSink*>(pUnk);
  1622.     if(!pSink)
  1623.         return E_FAIL;
  1624.  
  1625.     // show client connect state
  1626.     CString strText;
  1627.     USES_CONVERSION;
  1628.     strText.Format(_T("%s = %s"), g_mapBrProtocol[pSink->m_ClientConnect.m_BrProtocol]
  1629.         ,W2T(pSink->m_ClientConnect.m_bstr));
  1630.  
  1631.     HTREEITEM hChild = m_Tree.InsertItem(strText,hItem,TVI_LAST);
  1632.     return hr;
  1633. }
  1634.  
  1635. HRESULT CEncoderView::ShowClientDisconnectEvents(HTREEITEM hItem,IUnknown* pUnk)
  1636. {
  1637.     HRESULT hr = NOERROR;
  1638.     CEncoderEventSink* pSink = reinterpret_cast<CEncoderEventSink*>(pUnk);
  1639.     if(!pSink)
  1640.         return E_FAIL;
  1641.  
  1642.     // show client disconnect state
  1643.     CString strText;
  1644.     USES_CONVERSION;
  1645.     strText.Format(_T("%s = %s"), g_mapBrProtocol[pSink->m_ClientDisconnect.m_BrProtocol]
  1646.         ,W2T(pSink->m_ClientDisconnect.m_bstr));
  1647.  
  1648.     HTREEITEM hChild = m_Tree.InsertItem(strText,hItem,TVI_LAST);
  1649.     return hr;
  1650. }
  1651.  
  1652. HRESULT CEncoderView::ShowConfigEvents(HTREEITEM hItem,IUnknown* pUnk)
  1653. {
  1654.     HRESULT hr = NOERROR;
  1655.     CEncoderEventSink* pSink = reinterpret_cast<CEncoderEventSink*>(pUnk);
  1656.     if(!pSink)
  1657.         return E_FAIL;
  1658.  
  1659.     // show config state
  1660.     CString strText;
  1661.     USES_CONVERSION;
  1662.     strText.Format(_T("%s = %d"), W2T(pSink->m_ConfigChange.m_bstr)
  1663.         ,pSink->m_ConfigChange.m_lHr);
  1664.  
  1665.     HTREEITEM hChild = m_Tree.InsertItem(strText,hItem,TVI_LAST);
  1666.     return hr;
  1667. }
  1668.  
  1669. HRESULT CEncoderView::ShowErrorEvents(HTREEITEM hItem,IUnknown* pUnk)
  1670. {
  1671.     HRESULT hr = NOERROR;
  1672.     CEncoderEventSink* pSink = reinterpret_cast<CEncoderEventSink*>(pUnk);
  1673.     if(!pSink)
  1674.         return E_FAIL;
  1675.  
  1676.     // show error state
  1677.     CString strText = GetErrorFromHR(pSink->m_lError);
  1678.     
  1679.     HTREEITEM hChild = m_Tree.InsertItem(strText,hItem,TVI_LAST);
  1680.     return hr;
  1681. }
  1682.  
  1683. HRESULT CEncoderView::ShowIndexerStateEvents(HTREEITEM hItem,IUnknown* pUnk)
  1684. {
  1685.     HRESULT hr = NOERROR;
  1686.     CEncoderEventSink* pSink = reinterpret_cast<CEncoderEventSink*>(pUnk);
  1687.     if(!pSink)
  1688.         return E_FAIL;
  1689.  
  1690.     // show config state
  1691.     CString strText;
  1692.     USES_CONVERSION;
  1693.     strText.Format(_T("File = %s, State =  %s"), W2T(pSink->m_IndexerStateChange.m_bstrFile)
  1694.         ,g_mapIndexerState[pSink->m_IndexerStateChange.m_IndexerStateChange]);
  1695.  
  1696.     HTREEITEM hChild = m_Tree.InsertItem(strText,hItem,TVI_LAST);
  1697.     return hr;
  1698. }
  1699.  
  1700. HRESULT CEncoderView::ShowSourceStateEvents(HTREEITEM hItem,IUnknown* pUnk)
  1701. {
  1702.     HRESULT hr = NOERROR;
  1703.     CEncoderEventSink* pSink = reinterpret_cast<CEncoderEventSink*>(pUnk);
  1704.     if(!pSink)
  1705.         return E_FAIL;
  1706.  
  1707.     USES_CONVERSION;
  1708.     // show source state
  1709.     CString strText;
  1710.     strText.Format(_T("Index = %d"), pSink->m_srcStateChange.m_nIndex);
  1711.     m_Tree.InsertItem(strText,hItem,TVI_LAST);
  1712.  
  1713.     strText.Format(_T("SrcType = %s"), g_mapSourceType[pSink->m_srcStateChange.m_SrcType]);
  1714.     m_Tree.InsertItem(strText,hItem,TVI_LAST);
  1715.  
  1716.     strText.Format(_T("Sourcegroup = %s"), pSink->m_srcStateChange.m_bstrSG);
  1717.     m_Tree.InsertItem(strText,hItem,TVI_LAST);
  1718.  
  1719.     strText.Format(_T("State = %s"), g_mapSrcState[pSink->m_srcStateChange.m_State]);
  1720.     m_Tree.InsertItem(strText,hItem,TVI_LAST);
  1721.     return hr;
  1722. }
  1723.  
  1724. HRESULT CEncoderView::ShowStateEvents(HTREEITEM hItem,IUnknown* pUnk)
  1725. {
  1726.     HRESULT hr = NOERROR;
  1727.     CEncoderEventSink* pSink = reinterpret_cast<CEncoderEventSink*>(pUnk);
  1728.     if(!pSink)
  1729.         return E_FAIL;
  1730.  
  1731.     // show error state
  1732.     CString strText;
  1733.     USES_CONVERSION;
  1734.     strText.Format(_T("%s"), g_mapRunState[pSink->m_StateChange]);
  1735.  
  1736.     HTREEITEM hChild = m_Tree.InsertItem(strText,hItem,TVI_LAST);
  1737.     return hr;
  1738. }
  1739.