home *** CD-ROM | disk | FTP | other *** search
/ Computer Shopper 275 / DPCS0111DVD.ISO / Toolkit / Audio-Visual / VirtualDub / Source / VirtualDub-1.9.10-src.7z / src / Dita / source / w32base.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2009-09-14  |  15.3 KB  |  584 lines
  1. //    VirtualDub - Video processing and capture application
  2. //    Copyright (C) 1998-2004 Avery Lee
  3. //
  4. //    This program is free software; you can redistribute it and/or modify
  5. //    it under the terms of the GNU General Public License as published by
  6. //    the Free Software Foundation; either version 2 of the License, or
  7. //    (at your option) any later version.
  8. //
  9. //    This program is distributed in the hope that it will be useful,
  10. //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12. //    GNU General Public License for more details.
  13. //
  14. //    You should have received a copy of the GNU General Public License
  15. //    along with this program; if not, write to the Free Software
  16. //    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17.  
  18. #include <stdafx.h>
  19. #include <stdafx.h>
  20.  
  21. #include <vd2/system/w32assist.h>
  22. #include <vd2/Dita/w32base.h>
  23. #include <set>
  24.  
  25. VDUIBaseWindowW32::VDUIBaseWindowW32()
  26.     : mNextNativeID(1337)
  27.     , mpCB(NULL)
  28.     , mbCBAutoDelete(false)
  29.     , mbAutoDestroy(false)
  30.     , mbTick(false)
  31.     , mpModal(NULL)
  32. {
  33. }
  34.  
  35. VDUIBaseWindowW32::~VDUIBaseWindowW32() {
  36.     if (mpCB && mbCBAutoDelete)
  37.         delete mpCB;
  38. }
  39.  
  40. void *VDUIBaseWindowW32::AsInterface(uint32 id) {
  41.     switch(id) {
  42.         case IVDUIBase::kTypeID: return static_cast<IVDUIBase *>(this); break;
  43.     }
  44.  
  45.     return VDUICustomControlW32::AsInterface(id);
  46. }
  47.  
  48. void VDUIBaseWindowW32::Shutdown() {
  49.     DispatchEvent(this, mID, IVDUICallback::kEventDestroy, 0);
  50.     SetCallback(NULL, false);
  51.     VDUICustomControlW32::Shutdown();
  52. }
  53.  
  54. bool VDUIBaseWindowW32::Create(IVDUIParameters *pParams) {
  55.     bool is_child = pParams->GetB(nsVDUI::kUIParam_Child, false);
  56.  
  57.     mPadding = pParams->GetI(nsVDUI::kUIParam_Spacing, is_child ? 0 : 7);
  58.  
  59.     DWORD flags = 0;
  60.  
  61.     if (pParams->GetB(nsVDUI::kUIParam_SystemMenus, false))
  62.         flags |= WS_OVERLAPPEDWINDOW;
  63.  
  64.     return VDUICustomControlW32::Create(pParams, !is_child, flags);
  65. }
  66.  
  67. void VDUIBaseWindowW32::Destroy() {
  68.     if (VDINLINEASSERTFALSE(mpModal)) {
  69.         EndModal(-1);
  70.         return;
  71.     }
  72.  
  73.     VDUICustomControlW32::Destroy();
  74.  
  75.     if (mbAutoDestroy) {
  76.         mbAutoDestroy = false;
  77.         if (mpParent)
  78.             mpParent->RemoveChild(this);
  79.         Release();
  80.     }
  81. }
  82.  
  83. void VDUIBaseWindowW32::SetAutoDestroy(bool enable) {
  84.     if (enable)
  85.         AddRef();
  86.     if (mbAutoDestroy)
  87.         Release();
  88.     mbAutoDestroy = enable;
  89. }
  90.  
  91. void VDUIBaseWindowW32::SetTickEnable(bool enable) {
  92.     mbTick = enable;
  93. }
  94.  
  95. vduirect VDUIBaseWindowW32::MapUnitsToPixels(vduirect r) {
  96.     RECT rwin = {r.left, r.top, r.right, r.bottom};
  97.  
  98.     MapDialogRect(mhwnd, &rwin);
  99.  
  100.     return vduirect(rwin.left, rwin.top, rwin.right, rwin.bottom);
  101. }
  102.  
  103. vduisize VDUIBaseWindowW32::MapUnitsToPixels(vduisize s) {
  104.     RECT rwin = {0,0,s.w,s.h};
  105.  
  106.     MapDialogRect(mhwnd, &rwin);
  107.  
  108.     return vduisize(rwin.right, rwin.bottom);
  109. }
  110.  
  111. void VDUIBaseWindowW32::AddControl(IVDUIWindow *pWin) {
  112.     const uint32 id = pWin->GetID();
  113.     std::pair<tControls::iterator, tControls::iterator> result(mControls.equal_range(id));
  114.  
  115.     for(; result.first != result.second; ++result.first)
  116.         if ((*result.first).second == pWin)
  117.             return;
  118.  
  119.     mControls.insert(result.first, tControls::value_type(id, pWin));
  120. }
  121.  
  122. void VDUIBaseWindowW32::RemoveControl(IVDUIWindow *pWin) {
  123.     const uint32 id = pWin->GetID();
  124.     std::pair<tControls::iterator, tControls::iterator> result(mControls.equal_range(id));
  125.  
  126.     while(result.first != result.second)
  127.         if ((*result.first).second == pWin)
  128.             mControls.erase(result.first++);
  129.         else
  130.             ++result.first;
  131. }
  132.  
  133. IVDUIWindow *VDUIBaseWindowW32::GetControl(uint32 id) {
  134.     tControls::iterator it(mControls.find(id));
  135.  
  136.     if (it != mControls.end())
  137.         return (*it).second;
  138.  
  139.     return NULL;
  140. }
  141.  
  142. uint32 VDUIBaseWindowW32::GetNextNativeID() {
  143.     return mNextNativeID++;
  144. }
  145.  
  146. void VDUIBaseWindowW32::SetCallback(IVDUICallback *pCB, bool autoDelete) {
  147.     if (mpCB) {
  148.         DispatchEvent(this, GetID(), IVDUICallback::kEventDetach, 0);
  149.         if (mbCBAutoDelete)
  150.             delete mpCB;
  151.     }
  152.     mpCB = pCB;
  153.     mbCBAutoDelete = autoDelete;
  154.     DispatchEvent(this, GetID(), IVDUICallback::kEventAttach, 0);
  155. }
  156.  
  157. void VDUIBaseWindowW32::FinalizeDialog() {
  158.     Relayout();
  159.  
  160.     if (mhwnd && GetFocus() == mhwnd) {
  161.         // must init focus to a control or else shortcuts don't work at first
  162.         HWND hwndFirstFocus = GetNextDlgTabItem(mhwnd, NULL, FALSE);
  163.         if (hwndFirstFocus)
  164.             ::SetFocus(hwndFirstFocus);
  165.     }
  166. }
  167.  
  168. ////////////////////////////////////////////////////////////////////////////
  169.  
  170. struct VDUIBaseWindowW32::ModalData {
  171.     int        mReturnValue;
  172.     bool    mbOwnerWasEnabled;
  173.     HWND    mhwndOwner;
  174. };
  175.  
  176. int VDUIBaseWindowW32::DoModal() {
  177.     if (VDINLINEASSERTFALSE(mpModal))
  178.         return -1;
  179.  
  180.     ModalData data;
  181.  
  182.     mpModal = &data;
  183.  
  184.     HWND hwndParent = GetParentW32();        // Cannot use GetParent() as it isn't correct until after messages have been dispatched and the window hops to its real parent.
  185.  
  186.     data.mbOwnerWasEnabled = false;
  187.     data.mhwndOwner = hwndParent;
  188.  
  189.     if (data.mhwndOwner) {
  190.         data.mbOwnerWasEnabled = !(GetWindowLong(data.mhwndOwner, GWL_STYLE) & WS_DISABLED);
  191.  
  192.         if (data.mbOwnerWasEnabled)
  193.             EnableWindow(data.mhwndOwner, FALSE);
  194.     }
  195.  
  196.     MSG msg;
  197.     while(mpModal) {
  198.         if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
  199.             if (msg.message == WM_QUIT) {
  200.                 PostQuitMessage(msg.wParam);
  201.                 break;
  202.             }
  203.  
  204.             if (IsDialogMessage(mhwnd, &msg))
  205.                 continue;
  206.             TranslateMessage(&msg);
  207.             DispatchMessage(&msg);
  208.             continue;
  209.         }
  210.  
  211.         if (!mpModal)
  212.             break;
  213.  
  214.         if (mbTick) {
  215.             if (mpCB && mpCB->HandleUIEvent(this, NULL, 0, IVDUICallback::kEventTick, 0))
  216.                 continue;
  217.         }
  218.  
  219.         WaitMessage();
  220.     }
  221.  
  222.     mpModal = NULL;
  223.  
  224.     Shutdown();
  225.  
  226.     return data.mReturnValue;
  227. }
  228.  
  229. void VDUIBaseWindowW32::EndModal(int value) {
  230.     if (VDINLINEASSERTFALSE(!mpModal))
  231.         return;
  232.  
  233.     if (mpModal->mhwndOwner && mpModal->mbOwnerWasEnabled)
  234.         EnableWindow(mpModal->mhwndOwner, TRUE);
  235.  
  236.     if (mhwnd) {
  237.         // Set the popup flag on the window so it has a valid parent. This is needed so
  238.         // that on destruction the window manager reactivates the owner.
  239.         SetWindowLong(mhwnd, GWL_STYLE, GetWindowLong(mhwnd, GWL_STYLE) | WS_POPUP);
  240.     }
  241.  
  242.     mpModal->mReturnValue = value;
  243.     mpModal = NULL;
  244. }
  245.  
  246. void VDUIBaseWindowW32::Link(uint32 id, nsVDUI::LinkTarget target, const uint8 *src, size_t len) {
  247.     int expressions = *src++;
  248.  
  249.     while(expressions-- > 0) {
  250.         tLinkList::iterator it(mLinkList.insert(tLinkList::value_type(id, LinkEntry())));
  251.         LinkEntry& linkEnt = (*it).second;
  252.  
  253.         int refs = *src++;
  254.         linkEnt.mLinkSources.reserve(refs);
  255.  
  256.         while(refs-->0) {
  257.             const uint32 id = src[0] + ((uint32)src[1]<<8) + ((uint32)src[2]<<16) + ((uint32)src[3]<<24);
  258.             src += 4;
  259.  
  260.             linkEnt.mLinkSources.push_back(id);
  261.         }
  262.  
  263.         const int bclen = src[0] + ((uint32)src[1]<<8);
  264.         src += 2;
  265.         linkEnt.mByteCode.assign(src, src+bclen+1);
  266.         src += bclen+1;
  267.         linkEnt.mTarget = target;
  268.     }
  269.  
  270.     mbLinkUpdateMapDirty = true;
  271. }
  272.  
  273. void VDUIBaseWindowW32::ProcessActivation(IVDUIWindow *pWin, uint32 id) {
  274.     ExecuteLinks(id);
  275. }
  276.  
  277. void VDUIBaseWindowW32::ProcessValueChange(IVDUIWindow *pWin, uint32 id) {
  278.     ExecuteLinks(id);
  279. }
  280.  
  281. bool VDUIBaseWindowW32::DispatchEvent(IVDUIWindow *pWin, uint32 id, IVDUICallback::eEventType ev, int item) {
  282.     if (mpCB)
  283.         return mpCB->HandleUIEvent(this, pWin, id, ev, item);
  284.  
  285.     return false;
  286. }
  287.  
  288. namespace {
  289.     BOOL CALLBACK SetApplicationIconOnDialog(HMODULE hModule, LPCTSTR lpszType, LPTSTR lpszName, LONG_PTR lParam) {
  290.         HWND hdlg = (HWND)lParam;
  291.         HANDLE hLargeIcon = LoadImage((HINSTANCE)hModule, lpszName, IMAGE_ICON, GetSystemMetrics(SM_CXICON), GetSystemMetrics(SM_CYICON), LR_SHARED);
  292.         if (hLargeIcon)
  293.             SendMessage(hdlg, WM_SETICON, ICON_BIG, (LPARAM)hLargeIcon);
  294.  
  295.         HANDLE hSmallIcon = LoadImage((HINSTANCE)hModule, lpszName, IMAGE_ICON, GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), LR_SHARED);
  296.         if (hSmallIcon)
  297.             SendMessage(hdlg, WM_SETICON, ICON_SMALL, (LPARAM)hSmallIcon);
  298.  
  299.         return FALSE;
  300.     }
  301. }
  302.  
  303. LRESULT VDUIBaseWindowW32::WndProc(UINT msg, WPARAM wParam, LPARAM lParam) {
  304.     switch(msg) {
  305.         case WM_INITDIALOG:
  306.             {
  307.                 RECT r;
  308.                 GetWindowRect(mhwnd, &r);
  309.                 MapWindowPoints(mhwnd, ::GetParent(mhwnd), (LPPOINT)&r, 2);
  310.                 mArea.left = r.left;
  311.                 mArea.top = r.top;
  312.                 mArea.right = r.right;
  313.                 mArea.bottom = r.bottom;
  314.  
  315.                 DispatchEvent(this, mID, IVDUICallback::kEventCreate, 0);
  316.  
  317.                 DWORD dwStyle = GetWindowLong(mhwnd, GWL_STYLE);
  318.  
  319.                 if (dwStyle & WS_THICKFRAME) {
  320.                     EnumResourceNames(VDGetLocalModuleHandleW32(), RT_GROUP_ICON, SetApplicationIconOnDialog, (LONG_PTR)mhwnd);
  321.                 }
  322.  
  323.                 if (!(dwStyle & DS_CONTROL))
  324.                     Relayout();
  325.  
  326.                 ExecuteAllLinks();
  327.             }
  328.             return FALSE;
  329.    
  330.         case WM_GETMINMAXINFO:
  331.             {
  332.                 MINMAXINFO *pmmi = (MINMAXINFO *)lParam;
  333.    
  334.                 pmmi->ptMinTrackSize.x = mLayoutSpecs.minsize.w;
  335.                 pmmi->ptMinTrackSize.y = mLayoutSpecs.minsize.h;
  336.    
  337.                 if ((mAlignX & nsVDUI::kAlignTypeMask) != nsVDUI::kFill)
  338.                     pmmi->ptMaxTrackSize.x = mLayoutSpecs.minsize.w;
  339.    
  340.                 if ((mAlignY & nsVDUI::kAlignTypeMask) != nsVDUI::kFill)
  341.                     pmmi->ptMaxTrackSize.y = mLayoutSpecs.minsize.h;
  342.             }
  343.             return 0;
  344.  
  345.         case WM_SIZE:
  346.             if (!(GetWindowLong(mhwnd, GWL_STYLE) & WS_CHILD)) {
  347.                 vduirect r(GetClientArea());
  348.  
  349.                 if (r.size() != GetArea().size()) {
  350.                     r.left   += mInsets.left;
  351.                     r.top    += mInsets.top;
  352.                     r.right  -= mInsets.right;
  353.                     r.bottom -= mInsets.bottom;
  354.  
  355.                     tChildren::iterator it(mChildren.begin()), itEnd(mChildren.end());
  356.  
  357.                     for(; it!=itEnd; ++it) {
  358.                         IVDUIWindow *pWin = *it;
  359.  
  360.                         pWin->PostLayout(r);
  361.                     }
  362.                 }
  363.             }
  364.             return 0;
  365.  
  366.         case WM_CLOSE:
  367.             if (DispatchEvent(this, mID, IVDUICallback::kEventClose, 0))
  368.                 return 0;
  369.             goto handle_cancel;
  370.  
  371.         case WM_NOTIFYFORMAT:
  372.             return VDIsWindowsNT() ? NFR_UNICODE : NFR_ANSI;
  373.  
  374.         case WM_COMMAND:
  375.             // special handling for commands that have have keyboard equivalents in
  376.             // the dialog manager; we never assign these native IDs so it's safe to
  377.             // shortcut them
  378.             if (LOWORD(wParam) == IDOK) {
  379.                 DispatchEvent(this, 10, IVDUICallback::kEventSelect, 0);
  380.                 return 0;
  381.             } else if (LOWORD(wParam) == IDCANCEL) {
  382. handle_cancel:
  383.                 if (!DispatchEvent(this, 11, IVDUICallback::kEventSelect, 0)) {
  384.                     if (mpModal)
  385.                         EndModal(-1);
  386.                     else
  387.                         Shutdown();
  388.                 }
  389.                 return 0;
  390.             } else if (!lParam) {
  391.                 // dispatch menu/accelerator commands
  392.                 DispatchEvent(this, LOWORD(wParam), IVDUICallback::kEventSelect, 0);
  393.                 return 0;
  394.             }
  395.             break;
  396.     }
  397.  
  398.     return VDUICustomControlW32::WndProc(msg, wParam, lParam);
  399. }
  400.  
  401. void VDUIBaseWindowW32::Relayout() {
  402.     VDUILayoutSpecs constraints;
  403.  
  404.     constraints.minsize.w = GetSystemMetrics(SM_CXMAXIMIZED);
  405.     constraints.minsize.h = GetSystemMetrics(SM_CYMAXIMIZED);
  406.  
  407.     PreLayout(constraints);
  408.  
  409.     vduirect r(GetArea());
  410.  
  411.     if ((mAlignX & nsVDUI::kAlignTypeMask) != nsVDUI::kFill) {
  412.         if (r.width() > mLayoutSpecs.minsize.w)
  413.             r.right = r.left + mLayoutSpecs.minsize.w;
  414.     }
  415.  
  416.     if ((mAlignY & nsVDUI::kAlignTypeMask) != nsVDUI::kFill) {
  417.         if (r.height() > mLayoutSpecs.minsize.h)
  418.             r.bottom = r.top + mLayoutSpecs.minsize.h;
  419.     }
  420.  
  421.     PostLayout(r);
  422. }
  423.  
  424. void VDUIBaseWindowW32::PreLayoutBase(const VDUILayoutSpecs& parentConstraints) {
  425.     VDUILayoutSpecs rcConstraints(parentConstraints);
  426.     RECT rcBorders = {0,0,0,0};
  427.     RECT rcPad = {mPadding,mPadding,mPadding,mPadding};
  428.     bool bModeless = (0 != (GetWindowLong(mhwnd, GWL_STYLE) & DS_CONTROL));
  429.  
  430.     // If the dialog is modal, compute the insets for the dialog.
  431.  
  432.     if (!bModeless) {
  433.         MapDialogRect(mhwnd, &rcPad);
  434.  
  435.         mInsets = rcPad;
  436.  
  437.         AdjustWindowRectEx(&rcBorders, GetWindowLong(mhwnd, GWL_STYLE), GetMenu(mhwnd) != NULL, GetWindowLong(mhwnd, GWL_STYLE));
  438.  
  439.         // enlarge borders by pads
  440.         rcBorders.left        = rcBorders.left   - rcPad.left;
  441.         rcBorders.top        = rcBorders.top    - rcPad.top;
  442.         rcBorders.right        = rcBorders.right  + rcPad.right;
  443.         rcBorders.bottom    = rcBorders.bottom + rcPad.bottom;
  444.     } else
  445.         mInsets = rcBorders;
  446.  
  447.     // Shrink constraints by insets.
  448.  
  449.     mLayoutSpecs.minsize.w = rcBorders.right - rcBorders.left;
  450.     mLayoutSpecs.minsize.h = rcBorders.bottom - rcBorders.top;
  451.  
  452.     rcConstraints.minsize.w -= mLayoutSpecs.minsize.w;
  453.     rcConstraints.minsize.h -= mLayoutSpecs.minsize.h;
  454.  
  455.     // Layout children.
  456.  
  457.     tChildren::iterator it(mChildren.begin()), itEnd(mChildren.end());
  458.     vduisize minsize(0, 0);
  459.  
  460.     for(; it!=itEnd; ++it) {
  461.         IVDUIWindow *pWin = *it;
  462.  
  463.         pWin->PreLayout(rcConstraints);
  464.  
  465.         const VDUILayoutSpecs& prispecs = pWin->GetLayoutSpecs();
  466.  
  467.         if (minsize.w < prispecs.minsize.w)
  468.             minsize.w = prispecs.minsize.w;
  469.         if (minsize.h < prispecs.minsize.h)
  470.             minsize.h = prispecs.minsize.h;
  471.     }
  472.  
  473.     mLayoutSpecs.minsize.w += minsize.w;
  474.     mLayoutSpecs.minsize.h += minsize.h;
  475. }
  476.  
  477. void VDUIBaseWindowW32::PostLayoutBase(const vduirect& target) {
  478.     VDUIControlW32::PostLayoutBase(target);
  479.  
  480.     vduirect rc(GetClientArea());
  481.  
  482.     rc.left += mInsets.left;
  483.     rc.top += mInsets.top;
  484.     rc.right -= mInsets.right;
  485.     rc.bottom -= mInsets.bottom;
  486.  
  487.     tChildren::iterator it(mChildren.begin()), itEnd(mChildren.end());
  488.     vduisize minsize(0, 0);
  489.  
  490.     for(; it!=itEnd; ++it) {
  491.         IVDUIWindow *pWin = *it;
  492.  
  493.         pWin->PostLayout(rc);
  494.     }
  495. }
  496.  
  497. void VDUIBaseWindowW32::RebuildLinkUpdateMap() {
  498.     if (!mbLinkUpdateMapDirty)
  499.         return;
  500.  
  501.     mbLinkUpdateMapDirty = false;
  502.  
  503.     mLinkUpdateMap.clear();
  504.     for(tLinkList::const_iterator it(mLinkList.begin()), itEnd(mLinkList.end()); it != itEnd; ++it) {
  505.         const tLinkList::value_type& data = *it;
  506.         const LinkEntry& linkEntry = data.second;
  507.  
  508.         for(std::vector<uint32>::const_iterator itLink(linkEntry.mLinkSources.begin()), itLinkEnd(linkEntry.mLinkSources.end()); itLink != itLinkEnd; ++itLink) {
  509.             const uint32 sourceID = *itLink;
  510.  
  511.             mLinkUpdateMap.insert(tLinkUpdateMap::value_type(sourceID, &data));
  512.         }
  513.     }
  514. }
  515.  
  516. void VDUIBaseWindowW32::ExecuteLinks(uint32 id) {
  517.     std::list<uint32> queue;
  518.     queue.push_back(id);
  519.  
  520.     ExecuteLinks(queue);
  521. }
  522.  
  523. void VDUIBaseWindowW32::ExecuteAllLinks() {
  524.     uint32 last = 0;
  525.  
  526.     std::list<uint32> queue;
  527.     for(tControls::const_iterator it(mControls.begin()), itEnd(mControls.end()); it!=itEnd; ++it) {
  528.         uint32 id = (*it).first;
  529.  
  530.         if (last != id) {
  531.             last = id;
  532.  
  533.             queue.push_back(id);
  534.         }
  535.     }
  536.  
  537.     ExecuteLinks(queue);
  538. }
  539.  
  540. void VDUIBaseWindowW32::ExecuteLinks(std::list<uint32>& queue) {
  541.     if (mbLinkUpdateMapDirty)
  542.         RebuildLinkUpdateMap();
  543.  
  544.     std::set<uint32> visited;
  545.     while(!queue.empty()) {
  546.         uint32 id = queue.front();
  547.         queue.pop_front();
  548.  
  549.         std::pair<tLinkUpdateMap::iterator, tLinkUpdateMap::iterator> links(mLinkUpdateMap.equal_range(id));
  550.         std::vector<IVDUIWindow *> srcWindows;
  551.  
  552.         for(; links.first != links.second; ++links.first) {
  553.             const tLinkList::value_type *pLinkListEntry = (*links.first).second;
  554.             const uint32 targetID = pLinkListEntry->first;
  555.             const LinkEntry& linkEntry = pLinkListEntry->second;
  556.             const int sources = linkEntry.mLinkSources.size();
  557.  
  558.             IVDUIWindow *pTarget = GetControl(targetID);
  559.  
  560.             if (!pTarget)
  561.                 continue;
  562.  
  563.             if (visited.insert(targetID).second)
  564.                 queue.push_back(targetID);
  565.  
  566.             srcWindows.resize(sources);
  567.             for(int i=0; i<sources; ++i)
  568.                 srcWindows[i] = GetControl(linkEntry.mLinkSources[i]);
  569.  
  570.             const uint32 result = VDUIExecuteRuntimeExpression(&linkEntry.mByteCode.front(), &srcWindows.front());
  571.  
  572.             switch(linkEntry.mTarget) {
  573.                 case nsVDUI::kLinkTarget_Enable:
  574.                     pTarget->SetEnabled(result != 0);
  575.                     break;
  576.  
  577.                 case nsVDUI::kLinkTarget_Value:
  578.                     pTarget->SetValue(result);
  579.                     break;
  580.             }
  581.         }
  582.     }
  583. }
  584.