int UnsafeNativeMethods.IOleContainer.EnumObjects(int grfFlags, out UnsafeNativeMethods.IEnumUnknown ppenum)
        {
            ppenum = null;

            Debug.Assert(_host != null, "gotta have the avalon activex host");

            object ax = _host.ActiveXInstance;

            //We support only one control, return that here
            //How does one add multiple controls to a container?
            if (ax != null
                &&
                ( ((grfFlags & NativeMethods.OLECONTF_EMBEDDINGS) != 0)
                  ||
                  ((grfFlags & NativeMethods.OLECONTF_ONLYIFRUNNING) != 0 &&
                    _host.ActiveXState == ActiveXHelper.ActiveXState.Running )) )
            {
                Object[] temp = new Object[1];
                temp[0]= ax;
                ppenum = new EnumUnknown(temp);
                return NativeMethods.S_OK;
            }

            ppenum = new EnumUnknown(null);
            return NativeMethods.S_OK;
        }

        internal HtmlWindow(HtmlShimManager shimManager, UnsafeNativeMethods.IHTMLWindow2 win)
        {
            this.htmlWindow2 = win;
            Debug.Assert(this.NativeHtmlWindow != null, "The window object should implement IHTMLWindow2");

            this.shimManager = shimManager;
        }

 public int GetDropTarget(
     UnsafeNativeMethods.IOleDropTarget pDropTarget,
     out UnsafeNativeMethods.IOleDropTarget ppDropTarget)
 {
     // no additional drop target
     ppDropTarget = pDropTarget;
     return NativeMethods.SRESULTS.S_FALSE;
 }

        internal HtmlDocument(HtmlShimManager shimManager, UnsafeNativeMethods.IHTMLDocument doc)
        {
            this.htmlDocument2 = (UnsafeNativeMethods.IHTMLDocument2)doc;
            Debug.Assert(this.NativeHtmlDocument2 != null, "The document should implement IHtmlDocument2");

            this.shimManager = shimManager;

        }

        internal HtmlElement(HtmlShimManager shimManager, UnsafeNativeMethods.IHTMLElement element)
        {
            this.htmlElement = element;
            Debug.Assert(this.NativeHtmlElement != null, "The element object should implement IHTMLElement");

            this.shimManager = shimManager;

        }

 string GetStringHelper(UnsafeNativeMethods.ArgsGetLineStringConsts which)
 {
   IntPtr ptr_const_this = ConstPointer();
   using (var sh = new StringHolder())
   {
     IntPtr ptr_string = sh.NonConstPointer();
     UnsafeNativeMethods.CArgsRhinoGetLine_GetString(ptr_const_this, which, ptr_string);
     return sh.ToString();
   }
 }

 public static void EvtSeek(
                     EventLogHandle resultSet,
                     long position,
                     EventLogHandle bookmark,
                     int timeout,
                     UnsafeNativeMethods.EvtSeekFlags flags) {
     bool status = UnsafeNativeMethods.EvtSeek(resultSet, position, bookmark, timeout, flags);
     int win32Error = Marshal.GetLastWin32Error();
     if (!status)
         EventLogException.Throw(win32Error);
 }

 /// <summary>
 /// Called when removing a delegate from an event, see the
 /// GroundPlane.Changed event for an example.
 /// </summary>
 /// <param name="type">
 /// The event watcher type index
 /// </param>
 /// <param name="value">
 /// Delegate to remove
 /// </param>
 public static void Remove(UnsafeNativeMethods.EventSyncDocumentSettingsChangedFlag type, EventHandler<RenderPropertyChangedEvent> value)
 {
   // Remove from the dictionary
   if (g_event_dictionary.ContainsKey(type)) g_event_dictionary[type] -= value;
   // If there are still event hooks set then bail
   if (!IsEmpty) return;
   // There are no event hooks set so call into rhcmnrdk_c to set the
   // callback hook to null.
   UnsafeNativeMethods.CRdkCmnEventWatcher_SetDocumentSettingsChangedEventCallback(null, Rhino.Runtime.HostUtils.m_rdk_ew_report);
   g_settings_changed_hook = null;
 }

 int UnsafeNativeMethods.IOleContainer.EnumObjects(int grfFlags, out UnsafeNativeMethods.IEnumUnknown ppenum) {
     ppenum = null;
     if ((grfFlags & 1) != 0) { // 1 == OLECONTF_EMBEDDINGS
         Debug.Assert(parent != null, "gotta have it...");
         ArrayList list = new ArrayList();
         ListAXControls(list, true);
         if (list.Count > 0) {
             Object[] temp = new Object[list.Count];
             list.CopyTo(temp, 0);
             ppenum = new AxHost.EnumUnknown(temp);
             return NativeMethods.S_OK;
         }
     }
     ppenum = new AxHost.EnumUnknown(null);
     return NativeMethods.S_OK;
 }

 /// <summary>
 /// Called when adding a delegate to a event, see the GroundPlane.Changed
 /// event for an example.
 /// </summary>
 /// <param name="type">
 /// The event watcher type index
 /// </param>
 /// <param name="value">
 /// Delegate to add
 /// </param>
 public static void Add(UnsafeNativeMethods.EventSyncDocumentSettingsChangedFlag type, EventHandler<RenderPropertyChangedEvent> value)
 {
   // If the callback hook has not been set then set it now
   if (g_settings_changed_hook == null)
   {
     // Call into rhcmnrdk_c to set the callback hook
     g_settings_changed_hook = OnSettingsChanged;
     UnsafeNativeMethods.CRdkCmnEventWatcher_SetDocumentSettingsChangedEventCallback(g_settings_changed_hook, Rhino.Runtime.HostUtils.m_rdk_ew_report);
   }
   if (!g_event_dictionary.ContainsKey(type))
     g_event_dictionary.Add(type, null);
   // Need to do this to ensure the delegate does not get added twice
   g_event_dictionary[type] -= value;
   // Add the new delegate to the event list
   g_event_dictionary[type] += value;
 }

 int UnsafeNativeMethods.IOleClientSite.GetContainer(out UnsafeNativeMethods.IOleContainer container) 
 {
     container = this.Host.Container;
     return NativeMethods.S_OK;
 }

 void SetBool(UnsafeNativeMethods.FileWriteOptionsBoolConsts which, bool value)
 {
   if (m_bDoDelete) // means this is not "const"
     UnsafeNativeMethods.CRhinoFileWriteOptions_SetBool(m_ptr, which, value);
 }

 public int ResizeBorder(
     NativeMethods.COMRECT rect,
     UnsafeNativeMethods.IOleInPlaceUIWindow doc,
     bool fFrameWindow)
 {
     // We don't have any UI by default, so pretend we updated it.
     return NativeMethods.SRESULTS.S_OK;
 }

 public static extern IntPtr GetHGlobalFromILockBytes(UnsafeNativeMethods.ILockBytes pLkbyt);

 public static extern UnsafeNativeMethods.IStorage StgCreateDocfileOnILockBytes(UnsafeNativeMethods.ILockBytes iLockBytes, int grfMode, int reserved);

 void UnsafeNativeMethods.IEnumUnknown.Clone(out UnsafeNativeMethods.IEnumUnknown ppenum)
 {
     ppenum = new EnumUnknown(this.arr, this.loc);
 }

 internal HtmlElementCollection(HtmlShimManager shimManager, UnsafeNativeMethods.IHTMLElementCollection elements) {
     this.htmlElementCollection = elements;
     this.elementsArray = null;
     this.shimManager = shimManager;
     Debug.Assert(this.NativeHtmlElementCollection != null, "The element collection object should implement IHTMLElementCollection");
 }

        internal int CallISAPI(UnsafeNativeMethods.CallISAPIFunc iFunction, byte [] bufIn, byte [] bufOut) {

            if (_wr == null || !(_wr is System.Web.Hosting.ISAPIWorkerRequest))
                throw new HttpException(SR.GetString(SR.Cannot_call_ISAPI_functions));
#if !FEATURE_PAL // FEATURE_PAL does not enable IIS-based hosting features
            return ((System.Web.Hosting.ISAPIWorkerRequest) _wr).CallISAPI(iFunction, bufIn, bufOut);
#else // !FEATURE_PAL
                throw new NotImplementedException ("ROTORTODO");
#endif // !FEATURE_PAL
        }

 internal State RefreshStorage(UnsafeNativeMethods.IPersistStorage iPersistStorage) {
     Debug.Assert(storage != null, "how can we not have a storage object?");
     Debug.Assert(iLockBytes != null, "how can we have a storage w/o ILockBytes?");
     if (storage == null || iLockBytes == null) return null;
     iPersistStorage.Save(storage, true);
     storage.Commit(0);
     iPersistStorage.HandsOffStorage();
     try {
         buffer = null;
         ms = null;
         NativeMethods.STATSTG stat = new NativeMethods.STATSTG();
         iLockBytes.Stat(stat, NativeMethods.Ole.STATFLAG_NONAME);
         length = (int) stat.cbSize;
         buffer = new byte[length];
         IntPtr hglobal = UnsafeNativeMethods.GetHGlobalFromILockBytes(iLockBytes);
         IntPtr pointer = UnsafeNativeMethods.GlobalLock(new HandleRef(null, hglobal));
         try {
             if (pointer != IntPtr.Zero) {
                 Marshal.Copy(pointer, buffer, 0, length);
             }
             else {
                 length = 0;
                 buffer = null;
             }
         }
         finally {
             UnsafeNativeMethods.GlobalUnlock(new HandleRef(null, hglobal));
         }
     }
     finally {
         iPersistStorage.SaveCompleted(storage);
     }
     return this;
 }

 private static string TranslateReturnCode(UnsafeNativeMethods.CredUIReturnCodes result)
 {
     return string.Format(CultureInfo.CurrentUICulture, Properties.Resources.CredUIReturn, result.ToString());
 }