//searches ALL lists and removes listener from all of them.
 //pretty slow op; remove from individual lists if you can
 public static void RemoveListener(IEventListener listener)
 {
     foreach (EventType type in eventListenerMap.Keys)
     {
         eventListenerMap[type].Remove(listener);
     }
 }

 public void AddEventListener(IEventListener eventListener)
 {
     if (!(m_EventListeners.Contains(eventListener)))
     {
         m_EventListeners.Add(eventListener);
     }
 }

        public static void Initialize(IEventListener touchEventListener)
        {
            if (_initialized)
                return;

            /// Lack of constructors in native code, forces to
            /// initialize TouchPanel before we initialize event sink.

            /// We have only one touch panel right now.
            /// But this is to keep the options open for future.
            _activeTouchPanel = new TouchPanel();
            _activeTouchPanel.Enabled = true;

            /// Add a touch event processor.
            Microsoft.SPOT.EventSink.AddEventProcessor(EventCategory.Touch, new TouchEventProcessor());

            /// Start the event sink process. This will pump
            /// events neatly out of the other world.
            Microsoft.SPOT.EventSink.AddEventListener(EventCategory.Touch, touchEventListener);

            /// Also add generic for Gesture stuff.
            Microsoft.SPOT.EventSink.AddEventListener(EventCategory.Gesture, touchEventListener);

            _initialized = true;
        }

 public WeakEventListenerWrapper(IEventListener listener)
 {
     if (listener.IsWeak)
         _item = listener;
     else
         _item = ToolkitExtensions.GetWeakReference(listener);
 }

    ///////////////////////////////////////////////////////////
    /**
     * Add a listener to the event manager that will receive any events of the
     * supplied event name.
     */
    public static bool AddListener(IEventListener listener, string eventName)
    {
        if (!appQuitting) {
            if (listener == null || eventName == null) {
                Debug.Log("[EVENTMANAGER]: Failed to add listener: listener["+(listener == null ? "listener argument cannot be null" : listener.GetType().ToString())+"] eventName["+(eventName == null ? "eventName argument cannot be null" : eventName)+"]");
                return false;
            }

            EventManager em = EventManager.getInstance();
            if (!em.listenerTable.ContainsKey(eventName)) {
                //Debug.Log("adding listener for event ["+eventName+"]. listener ["+listener+"]");
                em.listenerTable.Add(eventName, new ArrayList());
            }

            ArrayList listenerList = em.listenerTable[eventName] as ArrayList;
            if (listenerList.Contains(listener)) {
                Debug.Log("[EVENTMANAGER]: listener["+(listener.GetType().ToString())+"] is already in list for eventName["+eventName+"]");
                return false;
            }

            // Debug.Log("[EVENTMANAGER]: Added listener["+(listener.GetType().ToString())+"]");
            listenerList.Add(listener);
        }
        /*
        else {
            Debug.Log("[EVENTMANAGER]: Addition of listener["+(listener.GetType().ToString())+"] skipped since app is quitting");
        }
        */
        return false;
    }

    /**
     * Remove a listener from the specified event.
     */
    public static bool DetachListener(IEventListener listener, string eventName)
    {
        if (!appQuitting) {

            EventManager em = EventManager.getInstance();

            if (!em.listenerTable.ContainsKey(eventName)) {
                return false;
            }

            ArrayList listenerList = em.listenerTable[eventName] as ArrayList;
            if (!listenerList.Contains(listener)) {
                return false;
            }

            //Debug.Log("[EVENTMANAGER]: Removed listener["+(listener.GetType().ToString())+"]");
            listenerList.Remove(listener);
        }
        /*
        else {
            Debug.Log("[EVENTMANAGER]: Removal of listener["+(listener.GetType().ToString())+"] skipped since app is quitting");
        }
        */
        return true;
    }

 public static void RemoveListener(IEventListener listener)
 {
     if (listeners.Contains(listener))
     {
         listeners.Remove(listener);
     }
 }

        protected override ImporterConverterAbstract GetNext(IEventListener iel, CancellationToken iCancellationToken)
        {
            try
            {
                IMccDescompactor Sex = Context.RarManager.InstanciateExctractor(_FN, iel, Context);
                if (Sex == null)
                    return null;

                bool exportsuccess = false;

                using (Sex)
                {
                    exportsuccess = Sex.Extract(iel, iCancellationToken);
                }

                OutPutFiles = Sex.DescompactedFiles;

                if (iCancellationToken.IsCancellationRequested)
                {
                    return null;
                }

                if (exportsuccess==false)
                    return null;

               return new XMLImporter(Sex.RootXML, _ImportAllMetaData, Context.Folders.File) { Rerooter = Sex.Rerooter};
            }
            catch (Exception e)
            {
                iel.Report(new UnknownRarError(_FN));
                Trace.WriteLine("Decompressing problem " + e.ToString());
                return null;
            }
        }

        public static void AddListener(int type, IEventListener listener, IEventDispatcher source = null)
        {
            if (!listeners.ContainsKey(type))
                listeners.Add(type, new List<ListenerData>());

            listeners[type].Add(new ListenerData(listener, source));
        }

        /// <summary>
        /// Initializes a new instance of the SharedObjectMessage class with given listener, name, version and persistence flag.
        /// </summary>
        /// <param name="source">Event listener.</param>
        /// <param name="name">Event name.</param>
        /// <param name="version">Shared object version.</param>
        /// <param name="persistent">Indicates whether shared object is persistent.</param>
        internal SharedObjectMessage(IEventListener source, string name, int version, bool persistent)
            : base(EventType.SHARED_OBJECT, Constants.TypeSharedObject, source)
		{
			_name = name;
			_version = version;
			_persistent = persistent;
		}

        protected override ImporterConverterAbstract GetNext(IEventListener iel, CancellationToken iCancellationToken)
         {
 
            string dp = Path.GetFileName(_FileName);
            iel.Report(new ExtractProgessEventArgs(dp));

            ImporterConverterAbstract next = null;            

            try
            {
                IRarDescompactor Sex = Context.RarManager.InstanciateExctractorWithPassword(_FileName, iel);

                if (Sex == null)
                {
                    return next;
                }

                using (Sex)
                {
                    if (iCancellationToken.IsCancellationRequested)
                        return null;

                    Sex.DescompactedFiles = _ExtractedFiles;

                    bool res = Sex.Extract(iel, iCancellationToken);

                    _RarFileNames =Sex.ArchiveNames;

                    if (iCancellationToken.IsCancellationRequested)
                        return null;

                    if (res)
                    {

                        NonRecursiveFolderInspector nfr = new NonRecursiveFolderInspector(_IInternalMusicSession,_ExtractedFiles, Sex.Helper, iel);
                        ImporterConverterAbstract[] Importers = nfr.Importers;

                        if (Importers.Length == 0)
                        {
                            iel.Report(new NoMusicImportErrorEventArgs(Sex.Helper.DisplayName));
                        }
                        else if (Importers.Length > 1)
                        {
                            Trace.WriteLine("Unhandled configuration in a rar file");
                            iel.Report(new UnhandledRarFile(Sex.Helper.DisplayName));
                        }
                        else
                            next = Importers[0];
                    }
                }
            }
            catch(Exception e)
            {
                iel.Report(new UnknownRarError(dp));
                Trace.WriteLine("Decompressing problem " + e.ToString());
                next = null;
            }

            return next;
        }

        public void AddEventListener(IEventListener listener)
        {
            if (Equals(listener, null))
                throw new ArgumentNullException("listener");

            Listeners.Add(listener);
        }

 internal NonRecursiveFolderInspector(IInternalMusicSession iIMusicConverter, IEnumerable<string> Files, IImportHelper Clue, IEventListener iel)
 {
     _IMusicConverter = iIMusicConverter;
     _Files = Files;
     _ClueName = Clue;
     _IEL = iel;
 }

 /// <summary>
 /// 挂载一个消息监听器到当前的消息节点上
 /// </summary>
 /// <param name="key">消息ID</param>
 /// <param name="listener">消息监听器</param>
 /// <returns>当前消息节点已经挂载了这个消息监听器那么返回false</returns>
 public bool AttachEventListener(int key, IEventListener listener)
 {
     if (listener == null)
     {
         return false;
     }
     if (!mListeners.ContainsKey(key))
     {
         mListeners.Add(key, new List<IEventListener>() { listener });
         return true;
     }
     if (mListeners[key].Contains(listener))
     {
         return false;
     }
     int pos = 0;
     for (int i = 0; i < mListeners[key].Count; i++)
     {
         if (listener.EventPriority() > mListeners[key][i].EventPriority())
             break;
         pos++;
     }
     mListeners[key].Insert(pos, listener);
     return true;
 }

			public void RemoveListener(IEventListener listener)
			{
				try
				{
					listerners.Remove(listener);
				}
				catch { }
			}

        /// <summary>
        /// Initializes a new instance.
        /// </summary>
        /// <param name="eventType"></param>
        /// <param name="listener"></param>
        /// <param name="capture"></param>
        public EventListenerRegistration(string eventType,IEventListener listener, bool capture )
        {
            Contract.Requires<ArgumentNullException>(!string.IsNullOrWhiteSpace(eventType));
            Contract.Requires<ArgumentNullException>(listener != null);

            this.eventType = eventType;
            this.listener = listener;
            this.capture = capture;
        }

 internal FolderInspector(IInternalMusicSession iMusicConverter, DirectoryInfo DI, IEventListener iel)
 {
     _IMusicConverter = iMusicConverter;
     _RootDir = DI;
     _IEL = iel;
     string DirName = Path.GetDirectoryName(DI.FullName);
     _SkipDir = (DirName == null) ? DI.FullName.Length : DirName.Length;
     _SkipDir++;
 }

        public static void RemoveEventFilter(EventCategory eventCategory, IEventListener eventFilter)
        {
            EventInfo eventInfo = GetEventInfo(eventCategory);

            if (eventInfo.EventFilter == eventFilter)
            {
                eventInfo.EventFilter = null;
            }
        }

 /// <summary>
 ///   Connects an event listener to our message bus
 /// </summary>
 /// <param name = "listener">The event listener, which will be marshalled from another AppDomain</param>
 /// <param name = "context">Run context event raiser</param>
 /// <remarks>
 ///   We cannot pass the message bus instance to the event listener, since the listener may be in a remote AppDomain
 /// </remarks>
 private static void RegisterEventListener(IEventListener listener, IRunContextEvents context)
 {
     context.OnRunStarted += (s, e) => listener.RunStarted();
     context.OnRunFinished += (s, e) => listener.RunFinished();
     context.OnFeatureStarted += (s, e) => listener.FeatureStarted(e.EventInfo);
     context.OnFeatureFinished += (s, e) => listener.FeatureFinished(e.EventInfo);
     context.OnScenarioStarted += (s, e) => listener.ScenarioStarted(e.EventInfo.Title);
     context.OnScenarioFinished += (s, e) => listener.ScenarioFinished(e.EventInfo);
 }

 public PrimaryListener(IEventListener eventListener)
 {
     m_EventListener = eventListener;
     if (m_EventListener != null) {
         //EventThread.SetApartmentState(ApartmentState.MTA);
         EventThread.Priority = ThreadPriority.BelowNormal;
         EventThread.IsBackground = true;
         EventThread.Start(this);
     }
 }