Exemple #1
0
        /// <summary>this is an entry point for all objects handlers</summary>
        /// <param name="objectHashCode"> hash code of the object</param>
        /// <param name="eventName"> event name</param>
        /// <param name="parameters">event parameters</param>
        /// <returns></returns>
        public static void handleDotNetEvent(int objectHashCode, String eventName, Object[] parameters)
        {
            Object       invokedObject     = DNManager.getInstance().DNObjectEventsCollection.getObject(objectHashCode);
            GuiMgControl mgControl         = null;
            bool         raiseRuntimeEvent = true;

            Manager.ContextIDGuard contextIDGuard = null;

            // If Object is a control and it is 'our' control (not created dynamically, decided by .Tag)
            if (invokedObject is Control && ((Control)invokedObject).Tag != null)
            {
                ControlsMap controlsMap = ControlsMap.getInstance();
                MapData     mapData     = controlsMap.getControlMapData((Control)invokedObject);
                if (mapData == null)
                {
                    return;
                }

                mgControl = mapData.getControl();

                contextIDGuard = new Manager.ContextIDGuard(Manager.GetContextID(mgControl));
                //first execute default magic handling of event
                EventType type = DNControlEvents.getStandardEvent(eventName);
                if (type != EventType.NONE && parameters.Length == 2)
                {
                    DefaultHandler.getInstance().handleEvent(type, invokedObject, (EventArgs)parameters[1]);
                }

                if (eventName == "KeyDown") //QCR #736734 KeyDown is handled from Filter.cs on WM_KEYDOWN - do not duplicate the event
                {
                    raiseRuntimeEvent = false;
                }
                else if (eventName == "Disposed")
                {
                    // a Disposed event for a control can't be handled as a runtime-event after the task/form are closed
                    raiseRuntimeEvent = false;
                }
                else
                {
                    // raise .NET runtime event only if hooked from the application (i.e. have a handler in the task)
                    List <String> applicationHookedDNeventsNames = ((TagData)((Control)invokedObject).Tag).ApplicationHookedDNeventsNames;
                    if (applicationHookedDNeventsNames == null || !applicationHookedDNeventsNames.Contains(eventName))
                    {
                        raiseRuntimeEvent = false;
                    }
                }
            }

            // raise .NET event
            if (raiseRuntimeEvent)
            {
                Events.OnDotNetEvent(invokedObject, mgControl, eventName, parameters);
            }

            if (contextIDGuard != null)
            {
                contextIDGuard.Dispose();
            }
        }
Exemple #2
0
        private void handlePredefinedEvent(string eventName, object sender, EventArgs e)
        {
            GuiMgControl guiMgCtrl = null;

            Debug.Assert(sender is Control && DNControlEvents.isPredefinedEvent(eventName));
            ControlsMap controlsMap = ControlsMap.getInstance();
            MapData     mapData     = controlsMap.getMapData(sender);

            if (mapData != null)
            {
                guiMgCtrl = mapData.getControl();
            }
            Events.OnDotNetEvent(sender, guiMgCtrl, eventName, new[] { sender, e });
        }
Exemple #3
0
        /// <summary> adds events for control</summary>
        /// <param name="control"></param>
        /// <param name="dnEventsNames">comma-delimited string of events that should be raised for the object</param>
        internal void addHandler(Control control, List <String> dnEventsNames)
        {
            DNObjectEventsCollection.ObjectEvents objectEvents = DNManager.getInstance().DNObjectEventsCollection.checkAndCreateObjectEvents(control);

            foreach (string item in dnEventsNames)
            {
                ReflectionServices.addHandler(item, control, objectEvents, true);
            }

            ICollection <String> standartEvents = DNControlEvents.getStandardEventsNames();

            foreach (string item in standartEvents)
            {
                if (!dnEventsNames.Contains(item))
                {
                    ReflectionServices.addHandler(item, control, objectEvents, false);
                }
            }
        }
Exemple #4
0
        /// <summary>add handler for the .NET object:
        /// create a dynamic delegate according to the given event type
        /// add method body to the delegate
        /// in the method body call DefaultDotNetHandler which will handle the event</summary>
        /// <param name="eventName"> name of the event</param>
        /// <param name="objectToHook"> object to hook</param>
        /// <param name="objectEvents"> once registered, events are added to this collection</param>
        /// <param name="reportErrors"> indicates whether to log errors while hooking event. There are some
        /// default events that are hooked for each .NET control (see DNControlEvents._standardControlEvents).
        /// Errors occurring while hooking these events should not be reported.</param>
        /// TODO handle static events
        internal static void addHandler(String eventName, Object objectToHook, DNObjectEventsCollection.ObjectEvents objectEvents, bool reportErrors)
        {
            //subscribe for events only once , check if handler already added
            if (objectEvents.delegateExist(eventName))
            {
                return;
            }

            Type type = objectToHook.GetType();

            // Get an EventInfo representing the  event, and get the type of delegate that handles the event.
            EventInfo eventInfo = type.GetEvent(eventName);

            if (eventInfo != null)
            {
                // Get the "add" accessor of the event and invoke it late-bound, passing in the delegate instance.
                // This is equivalent to using the += operator in C#, or AddHandler in Visual Basic.
                // The instance on which the "add" accessor is invoked is the form;
                // the arguments must be passed as an array.
                MethodInfo addHandler = eventInfo.GetAddMethod();

                Delegate eventHandler = null;

                try
                {
#if !PocketPC
                    eventHandler = createDynamicDelegate(objectToHook.GetHashCode(), eventInfo);
#else
                    if (objectToHook is Control)
                    {
                        eventHandler = DNControlEvents.getPredefinedEvent(eventName);
                    }
#endif
                    try
                    {
                        addHandler.Invoke(objectToHook, new Object[] { eventHandler });
                    }
                    catch (Exception e)
                    {
                        if (e is TargetInvocationException && e.InnerException != null)
                        {
                            throw e.InnerException;
                        }
                        else
                        {
                            throw e;
                        }
                    }

                    objectEvents.add(eventName, eventHandler);
                }
                catch (Exception exception)
                {
                    if (reportErrors)
                    {
                        DNException dnException = Manager.GetCurrentRuntimeContext().DNException;
                        dnException.set(exception);
                    }
                }
            }
            else
            {
                if (reportErrors)
                {
                    Events.WriteExceptionToLog(String.Format("Event type \"{0}\" not supported", eventName));
                }
            }
        }