public void CreateRoom(EventObject evt = null)
 {
     if(NetworkManager.singleton.matches == null || NetworkManager.singleton.matches.Count == 0) {
         NetworkManager.singleton.matchMaker.CreateMatch("default", NetworkManager.singleton.matchSize, true, "", NetworkManager.singleton.OnMatchCreate);
         SetInfoText("Creating game...");
     }
 }

 public virtual void Reset(EventObject evt = null)
 {
     currentHits = 0;
     hasChanged = false;
     currentModelRoot.SetActive(true);
     destroyedModel.SetActive(false);
 }

 public void RegisterListener( EEventType eventType, ListenerDelegate delg )
 {
     EventObject obj = new EventObject();
     obj.MyEvent = eventType;
     obj.ThisDelegate = delg;
     listenerObjects.Add( obj );
 }

 public EventObjectAll(EventObject object1, EventObject object2, EventObject object3, EventObject object4, EventObject object5)
 {
     Object1 = object1;
     Object2 = object2;
     Object3 = object3;
     Object4 = object4;
     Object5 = object5;
 }

 public void Save(EventObject eventObject)
 {
     var session = SessionManager.OpenSessionIfRequired(this.sessionFactory);
     using (var transaction = session.BeginTransaction())
     {
         session.Save(eventObject);
         session.Transaction.Commit();
     }
 }

 /// <summary>
 /// Recycles ALL spawned pooled items.
 /// </summary>
 /// <param name="evt">Evt.</param>
 public void RecycleAllItems(EventObject evt = null)
 {
     List<GameObject> tempList = new List<GameObject>();
     tempList.AddRange(instance.spawnedItems.Keys);
     for(int i = 0; i < tempList.Count; i++) {
         RecycleToPool(tempList[i]);
     }
     tempList.Clear();
 }

 private static void RemoveListenerFromCache(object aListener, EventObject aEvent)
 {
     if (_listenerDict.ContainsKey(aListener))
     {
         if (_listenerDict[aListener].Contains(aEvent))
         {
             _listenerDict[aListener].Remove(aEvent);
         }
     }
 }

 void fireDisposingEvent(EventObject Source)
 {
     if (Disposing != null)
     {
         try
         {
             Disposing.Invoke(this, new EventObjectForwarder(Source));
         }
         catch { }
     }
 }

        private static void AddListenerToCache(object aListener, EventObject aEvent)
        {
            if (!_listenerDict.ContainsKey(aListener))
            {
                _listenerDict.Add(aListener, new List<EventObject>());
            }

            if (!_listenerDict[aListener].Contains(aEvent))
            {
                _listenerDict[aListener].Add(aEvent);
            }
        }

 public void Disconnect(EventObject evt)
 {
     if(isHost) {
         NetworkManager.singleton.StopHost();
         isHost = false;
     } else {
         if(NetworkManager.singleton.IsClientConnected()) {
             NetworkManager.singleton.client.Disconnect();
             //SceneManager.LoadScene(0);
             Application.LoadLevel (0);
         }
     }
 }

 void XEventListener.disposing(EventObject Source)
 {
     if (Disposing != null)
     {
         try
         {
             Disposing.Invoke(this, new ForwardedEventArgs(Source));
         }
         catch (Exception e)
         {
             Logger.Instance.Log(LogPriority.ALWAYS, this, "[ERROR] Could not forward disposing event: " + e);
         }
     }
 }

 public static void BroadcastEvent(string eventName, EventObject eventObj)
 {
     if(_events.ContainsKey(eventName))
     {
         List<EventManagerCallback> callbackList = _events[eventName];
         foreach(EventManagerCallback callback in callbackList)
         {
             if(callback != null)
             {
                 Debug.Log("** BROADCAST EVENT  " + eventName);
                 callback(eventObj);
             }
         }
     }
 }

    private void HandleInputFieldChange(EventObject evt)
    {
        if(evt.Params[0] != null) {
            InputFieldVO data = (InputFieldVO)evt.Params[0];

            if(data.inputKey == InputFieldKeys.MenuNameInput) {
                localPlayerName = data.inputValue;
            }
            else if(data.inputKey == InputFieldKeys.MenuTeamSelectInput) {
                if(data.inputValue == "Heroes") {
                    localPlayerTeam = Settings.HeroTeam;
                } else {
                    localPlayerTeam = Settings.VillainTeam;
                }
            }
        }
    }

 /// <summary>
 /// Removes the specified event handler
 /// </summary>
 public static void RemoveEventHandler(IEventHandler handler, EventType mask, HandlingPriority priority)
 {
     try
     {
         EventObject eo = new EventObject(handler, mask, priority);
         switch (priority)
         {
             case HandlingPriority.High:
                 highObjects.Remove(eo);
                 break;
             case HandlingPriority.Normal:
                 normalObjects.Remove(eo);
                 break;
             case HandlingPriority.Low:
                 lowObjects.Remove(eo);
                 break;
         }
     }
     catch (Exception ex)
     {
         ErrorManager.ShowError(ex);
     }
 }

 /// <summary>
 /// Parameters<li><span>ct</span> : <see cref="Ext.grid.header.Container">Ext.grid.header.Container</see><div><p>The grid's header Container which encapsulates all column headers.</p>
 /// </div></li><li><span>column</span> : <see cref="Ext.grid.column.Column">Ext.grid.column.Column</see><div><p>The Column header Component which provides the column definition</p>
 /// </div></li><li><span>e</span> : <see cref="Ext.EventObject">Ext.EventObject</see><div>
 /// </div></li><li><span>t</span> : HTMLElement<div>
 /// </div></li><li><span>eOpts</span> : <see cref="Object">Object</see><div><p>The options object passed to <see>Ext.util.Observable.addListener</see>.</p>
 /// </div></li>
 /// </summary>
 /// <param name="ct"><p>The grid's header Container which encapsulates all column headers.</p>
 /// </param>
 /// <param name="column"><p>The Column header Component which provides the column definition</p>
 /// </param>
 /// <param name="e">
 /// </param>
 /// <param name="t">
 /// </param>
 /// <param name="eOpts"><p>The options object passed to <see cref="Ext.util.Observable.addListener">Ext.util.Observable.addListener</see>.</p>
 /// </param>
 public void headertriggerclick(Ext.grid.header.Container ct, Ext.grid.column.Column column, EventObject e, object t, object eOpts){}

		protected void CreateFilmSession(FilmSession filmSession)
		{
			var message = new DicomMessage(null, (DicomAttributeCollection)filmSession.DicomAttributeProvider);
			this.Client.SendNCreateRequest(null, GetPresentationContextId(this.AssociationParameters), this.Client.NextMessageID(), message, DicomUids.BasicFilmSession);
			_eventObject = EventObject.FilmSession;

			Platform.Log(LogLevel.Debug, "Creating film session...");
		}

 public void JoinAsClient(EventObject evt = null)
 {
     CheckHostAddress ();
     NetworkManager.singleton.StartClient();
 }

 public void JoinRoom(EventObject evt = null)
 {
     NetworkManager.singleton.matchMaker.ListMatches(0, 20, "", delegate(ListMatchResponse response) {
         NetworkManager.singleton.OnMatchList(response);
         foreach(MatchDesc m in response.matches) {
             Debug.Log(m.name);
             if(m.name == "default") {
                 NetworkManager.singleton.matchName = m.name;
                 NetworkManager.singleton.matchSize = (uint)m.currentSize;
                 NetworkManager.singleton.matchMaker.JoinMatch(m.networkId, "", NetworkManager.singleton.OnMatchJoined);
                 SetInfoText("Found game, joining...");
             }
         }
         if(response.matches == null || response.matches.Count == 0) {
             SetInfoText("No online games found, create one!");
         }
     });
 }

 public void HostLan(EventObject evt = null)
 {
     isHost = true;
     CheckHostAddress();
     NetworkManager.singleton.StartHost();
 }

		protected void CreateFilmBox(FilmSession filmSession, FilmBox filmBox)
		{
			var referencedFilmSessionSequence = new ReferencedInstanceSequenceIod
			{
				ReferencedSopClassUid = SopClass.BasicFilmSessionSopClassUid,
				ReferencedSopInstanceUid = filmSession.SopInstanceUid.UID
			};

			filmBox.ReferencedFilmSessionSequenceList.Add(referencedFilmSessionSequence);

			var message = new DicomMessage(null, (DicomAttributeCollection)filmBox.DicomAttributeProvider);
			this.Client.SendNCreateRequest(null, GetPresentationContextId(this.AssociationParameters), this.Client.NextMessageID(), message, DicomUids.BasicFilmBoxSOP);
			_eventObject = EventObject.FilmBox;
			Platform.Log(LogLevel.Debug, "Creating film box...");
		}