public static void Show(string message, Callback OnFinish = null)
    {
        instance.text.text = message;
        instance.anim.SetBool("display", true);

        instance.onFinish = OnFinish;
    }

 public ReferenceFrameSelector(
     ManagerInterface manager,
     IntPtr plugin,
     Callback on_change,
     string name) : base(manager) {
   plugin_ = plugin;
   on_change_ = on_change;
   name_ = name;
   frame_type = FrameType.BODY_CENTRED_NON_ROTATING;
   expanded_ = new Dictionary<CelestialBody, bool>();
   foreach (CelestialBody celestial in FlightGlobals.Bodies) {
     if (!celestial.is_leaf() && !celestial.is_root()) {
       expanded_.Add(celestial, false);
     }
   }
   selected_celestial_ =
       FlightGlobals.currentMainBody ?? Planetarium.fetch.Sun;
   for (CelestialBody celestial = selected_celestial_;
        celestial.orbit != null;
        celestial = celestial.orbit.referenceBody) {
     if (!celestial.is_leaf()) {
       expanded_[celestial] = true;
     }
   }
   on_change_(FrameParameters());
   window_rectangle_.x = UnityEngine.Screen.width / 2;
   window_rectangle_.y = UnityEngine.Screen.height / 3;
 }

 public DelayedCall(Callback cb, int milliseconds)
     : this()
 {
     PrepareDCObject(this, milliseconds, false);
     callback = cb;
     if (milliseconds > 0) Start();
 }

		/**
		 * Add a callback when this window is canceled.
		 */
		public void AddOnCancelListener(Callback listener)
		{
			if(OnCancel != null)
				OnCancel += listener;
			else
				OnCancel = listener;
		}

 public LoginServerCall(string id, string deviceType, string version, Callback callback)
 {
     this.id = id;
     this.deviceType = deviceType;
     this.version = version;
     this.callback = callback;
 }

 public string getShareCatalogResults(string requestParam)
 {
     string RetVal = string.Empty;
     Callback objCallback = new Callback(new System.Web.UI.Page());
     RetVal = objCallback.ShareSearchResult(requestParam);
     return RetVal;
 }

  static void Main() 
  {
    Console.WriteLine("Adding and calling a normal C++ callback");
    Console.WriteLine("----------------------------------------");

    Caller caller = new Caller();
    using (Callback callback = new Callback())
    {
      caller.setCallback(callback);
      caller.call();
      caller.resetCallback();
    }

    Console.WriteLine();
    Console.WriteLine("Adding and calling a C# callback");
    Console.WriteLine("------------------------------------");

    using (Callback callback = new CSharpCallback())
    {
      caller.setCallback(callback);
      caller.call();
      caller.resetCallback();
    }

    Console.WriteLine();
    Console.WriteLine("C# exit");
  }

	public void OnEnable() {
		m_RemoteStorageAppSyncedClient = Callback<RemoteStorageAppSyncedClient_t>.Create(OnRemoteStorageAppSyncedClient);
		m_RemoteStorageAppSyncedServer = Callback<RemoteStorageAppSyncedServer_t>.Create(OnRemoteStorageAppSyncedServer);
		m_RemoteStorageAppSyncProgress = Callback<RemoteStorageAppSyncProgress_t>.Create(OnRemoteStorageAppSyncProgress);
		m_RemoteStorageAppSyncStatusCheck = Callback<RemoteStorageAppSyncStatusCheck_t>.Create(OnRemoteStorageAppSyncStatusCheck);
		m_RemoteStorageConflictResolution = Callback<RemoteStorageConflictResolution_t>.Create(OnRemoteStorageConflictResolution);
		m_RemoteStoragePublishedFileSubscribed = Callback<RemoteStoragePublishedFileSubscribed_t>.Create(OnRemoteStoragePublishedFileSubscribed);
		m_RemoteStoragePublishedFileUnsubscribed = Callback<RemoteStoragePublishedFileUnsubscribed_t>.Create(OnRemoteStoragePublishedFileUnsubscribed);
		m_RemoteStoragePublishedFileDeleted = Callback<RemoteStoragePublishedFileDeleted_t>.Create(OnRemoteStoragePublishedFileDeleted);
		m_RemoteStoragePublishFileProgress = Callback<RemoteStoragePublishFileProgress_t>.Create(OnRemoteStoragePublishFileProgress);
		m_RemoteStoragePublishedFileUpdated = Callback<RemoteStoragePublishedFileUpdated_t>.Create(OnRemoteStoragePublishedFileUpdated);

		RemoteStorageFileShareResult = CallResult<RemoteStorageFileShareResult_t>.Create(OnRemoteStorageFileShareResult);
		RemoteStoragePublishFileResult = CallResult<RemoteStoragePublishFileResult_t>.Create(OnRemoteStoragePublishFileResult);
		RemoteStorageDeletePublishedFileResult = CallResult<RemoteStorageDeletePublishedFileResult_t>.Create(OnRemoteStorageDeletePublishedFileResult);
		RemoteStorageEnumerateUserPublishedFilesResult = CallResult<RemoteStorageEnumerateUserPublishedFilesResult_t>.Create(OnRemoteStorageEnumerateUserPublishedFilesResult);
		RemoteStorageSubscribePublishedFileResult = CallResult<RemoteStorageSubscribePublishedFileResult_t>.Create(OnRemoteStorageSubscribePublishedFileResult);
		RemoteStorageEnumerateUserSubscribedFilesResult = CallResult<RemoteStorageEnumerateUserSubscribedFilesResult_t>.Create(OnRemoteStorageEnumerateUserSubscribedFilesResult);
		RemoteStorageUnsubscribePublishedFileResult = CallResult<RemoteStorageUnsubscribePublishedFileResult_t>.Create(OnRemoteStorageUnsubscribePublishedFileResult);
		RemoteStorageUpdatePublishedFileResult = CallResult<RemoteStorageUpdatePublishedFileResult_t>.Create(OnRemoteStorageUpdatePublishedFileResult);
		RemoteStorageDownloadUGCResult = CallResult<RemoteStorageDownloadUGCResult_t>.Create(OnRemoteStorageDownloadUGCResult);
		RemoteStorageGetPublishedFileDetailsResult = CallResult<RemoteStorageGetPublishedFileDetailsResult_t>.Create(OnRemoteStorageGetPublishedFileDetailsResult);
		RemoteStorageEnumerateWorkshopFilesResult = CallResult<RemoteStorageEnumerateWorkshopFilesResult_t>.Create(OnRemoteStorageEnumerateWorkshopFilesResult);
		RemoteStorageGetPublishedItemVoteDetailsResult = CallResult<RemoteStorageGetPublishedItemVoteDetailsResult_t>.Create(OnRemoteStorageGetPublishedItemVoteDetailsResult);
		RemoteStorageUpdateUserPublishedItemVoteResult = CallResult<RemoteStorageUpdateUserPublishedItemVoteResult_t>.Create(OnRemoteStorageUpdateUserPublishedItemVoteResult);
		RemoteStorageUserVoteDetails = CallResult<RemoteStorageUserVoteDetails_t>.Create(OnRemoteStorageUserVoteDetails);
		RemoteStorageEnumerateUserSharedWorkshopFilesResult = CallResult<RemoteStorageEnumerateUserSharedWorkshopFilesResult_t>.Create(OnRemoteStorageEnumerateUserSharedWorkshopFilesResult);
		RemoteStorageSetUserPublishedFileActionResult = CallResult<RemoteStorageSetUserPublishedFileActionResult_t>.Create(OnRemoteStorageSetUserPublishedFileActionResult);
		RemoteStorageEnumeratePublishedFilesByUserActionResult = CallResult<RemoteStorageEnumeratePublishedFilesByUserActionResult_t>.Create(OnRemoteStorageEnumeratePublishedFilesByUserActionResult);
	}

 public string OptimizeAdaptationDataBase()
 {
     string RetVal = string.Empty;
     Callback objCallback = new Callback();
     RetVal = objCallback.GenerateCacheResults("1" + Constants.Delimiters.ParamDelimiter + "General");
     return RetVal;
 }

	public void OnEnable() {
		m_HTML_NeedsPaint = Callback<HTML_NeedsPaint_t>.Create(OnHTML_NeedsPaint);
		m_HTML_StartRequest = Callback<HTML_StartRequest_t>.Create(OnHTML_StartRequest);
		m_HTML_CloseBrowser = Callback<HTML_CloseBrowser_t>.Create(OnHTML_CloseBrowser);
		m_HTML_URLChanged = Callback<HTML_URLChanged_t>.Create(OnHTML_URLChanged);
		m_HTML_FinishedRequest = Callback<HTML_FinishedRequest_t>.Create(OnHTML_FinishedRequest);
		m_HTML_OpenLinkInNewTab = Callback<HTML_OpenLinkInNewTab_t>.Create(OnHTML_OpenLinkInNewTab);
		m_HTML_ChangedTitle = Callback<HTML_ChangedTitle_t>.Create(OnHTML_ChangedTitle);
		m_HTML_SearchResults = Callback<HTML_SearchResults_t>.Create(OnHTML_SearchResults);
		m_HTML_CanGoBackAndForward = Callback<HTML_CanGoBackAndForward_t>.Create(OnHTML_CanGoBackAndForward);
		m_HTML_HorizontalScroll = Callback<HTML_HorizontalScroll_t>.Create(OnHTML_HorizontalScroll);
		m_HTML_VerticalScroll = Callback<HTML_VerticalScroll_t>.Create(OnHTML_VerticalScroll);
		m_HTML_LinkAtPosition = Callback<HTML_LinkAtPosition_t>.Create(OnHTML_LinkAtPosition);
		m_HTML_JSAlert = Callback<HTML_JSAlert_t>.Create(OnHTML_JSAlert);
		m_HTML_JSConfirm = Callback<HTML_JSConfirm_t>.Create(OnHTML_JSConfirm);
		m_HTML_FileOpenDialog = Callback<HTML_FileOpenDialog_t>.Create(OnHTML_FileOpenDialog);
		m_HTML_NewWindow = Callback<HTML_NewWindow_t>.Create(OnHTML_NewWindow);
		m_HTML_SetCursor = Callback<HTML_SetCursor_t>.Create(OnHTML_SetCursor);
		m_HTML_StatusText = Callback<HTML_StatusText_t>.Create(OnHTML_StatusText);
		m_HTML_ShowToolTip = Callback<HTML_ShowToolTip_t>.Create(OnHTML_ShowToolTip);
		m_HTML_UpdateToolTip = Callback<HTML_UpdateToolTip_t>.Create(OnHTML_UpdateToolTip);
		m_HTML_HideToolTip = Callback<HTML_HideToolTip_t>.Create(OnHTML_HideToolTip);

		m_HTML_BrowserReadyResult = CallResult<HTML_BrowserReady_t>.Create(OnHTML_BrowserReady);

		m_Init = SteamHTMLSurface.Init();
		print("SteamHTMLSurface.Init() : " + m_Init);

		m_Texture = null;
	}

 protected override void ForAll(bool include_internals, Callback callback)
 {
     foreach(Widget w in children)
     {
         if(w.Visible) callback (w);
     }
 }

 /// <summary>
 /// Adds a String and OnEvent to the Susbribers Dictionary
 /// </summary>
 /// <param name="sPub"> As stated before. The awaited message from publisher</param>
 /// <param name="onEvent">OnEvent functions to be called when message is later resieved</param>
 public void Subsribe(string sPub, Callback onEvent)
 {
     if (Subscribers != null && Subscribers.ContainsKey(sPub.ToLower()))
         Subscribers[sPub.ToLower()] += onEvent;
     else
         Subscribers.Add(sPub.ToLower(), onEvent);
 }

 public override void Initialize()
 {
     this._reader.Start();
     CoreSocialModule.OnTick += new Action(this._writer.SendAll);
     Terraria.Social.Steam.NetSocialModule netSocialModule = this;
     this._lobbyChatMessage = Callback<LobbyChatMsg_t>.Create(new Callback<LobbyChatMsg_t>.DispatchDelegate(netSocialModule.OnLobbyChatMessage));
 }

 /// <summary>
 /// Utility method for adding callback tasks to a queue
 /// that will eventually be handle in the Unity game loop 
 /// method 'Update()'.
 /// </summary>
 public void QueueCallback(Callback newTask)
 {
     lock (_CallbackQueue)
     {
         _CallbackQueue.Enqueue(newTask);
     }
 }

    /// <summary>
    /// Hide menu
    /// </summary>
    public virtual void hideMenu(float transitionTimer, MenuTransition path = MenuTransition.BACKWARD, Callback callback = null)
    {
        // Stop any transition that's currently in effect
        TransitionHandler.removeTransition(alphaTransition);
        TransitionHandler.removeTransition(positionTransition);

        if(transitionTimer == 0.0f) {

            // Make UI object invisible
            imgAlpha.alpha = 0.0f;

            // Turn off the UI game object
            gameObject.SetActive(false);

            if(callback != null) {
                callback();
            }
        }
        else {

            // Animate the position transition
            positionTransition = TransitionHandler.addTransition(() => Vector2.zero, x => menuTransform.anchoredPosition = x, new Vector2(0, -30), transitionTimer).toggleTimeScale(false);

            // Fade out the menu then disable the object after it's finished fading out
            alphaTransition = TransitionHandler.addTransition(()=>getAlpha.alpha, x => getAlpha.alpha = x, 0.0f, transitionTimer).toggleTimeScale(false).finishLerp(() => {
                gameObject.SetActive(false);
                if (callback != null) {
                    callback();
                }
            });
        }
    }

 /// <summary>
 /// Remove this pair of message, function from the Dictionary
 /// </summary>
 /// <param name ="message">
 /// the message to remove to
 /// </param>
 /// <param name ="function">
 /// the function to remove to
 /// </param>
 public static void removeSub(string message, Callback function)
 {
     if (events.ContainsKey(message))
     {
         events[message] = (Callback)events[message] - function;
     }
 }

        public void StartWizard(Experiment experimentToBeBenchmarked)
        {
            if (experimentToBeBenchmarked == null)
                throw new InvalidOperationException("Benchmark cannot be run with null experiment.");

            //if webservice is set access webservice, and load benchmarks from there... on OnRetrieveListOfBenchmarksCallCompleted will load load also local benchmarks
            //and discover those that are online contests
            if (m_settings.WebserviceAddress != null)
            {
                m_webService = new WebserviceAccessor(m_settings.WebserviceAddress, true);

                if (m_webService != null)
                {
                    var listOfContestsCallback = new Callback<ListOfContestsResponse>();
                    listOfContestsCallback.CallCompleted += OnRetrieveListOfBenchmarksCallCompleted;
                    m_webService.RetrieveListOfContests(listOfContestsCallback);
                }
                else
                {
                    //load only local benchmarks
                    Benchmarks = BenchmarkLoader.LoadBenchmarksInfo(BenchmarksDirectory);
                }
            }
            else
            {
                //load only local benchmarks
                Benchmarks = BenchmarkLoader.LoadBenchmarksInfo(BenchmarksDirectory);
            }
            ExperimentToBeBenchmarked = experimentToBeBenchmarked;
        }

 /// <summary>
 /// Process the answer received from the engine
 /// </summary>
 /// <param name="answer">The String containing the answer</param>
 /// <param name="type">The type of the answer (unused)</param>
 /// <param name="callback">The delegate to call</param>
 /// <param name="data">CogaenEdit data that is linked to this answer (e.g. a gameobject)</param>
 public void answer(String answer, byte type, uint id, Callback callback, object data)
 {
     m_queueMutex.WaitOne();
     m_messageQueue.Enqueue(new CMessage(answer, type, id, callback, data));
     m_queueSema.Release(1);
     m_queueMutex.ReleaseMutex();
 }

        public void EnqueueFrame(ATCommandFrame frame, Callback callback)
        {
            int frameID = UnusedFrameId;
            if (frameID == NOTFOUND)
            {
                waitingForSendingQueue.Enqueue(frame, callback);
                return;
            }

            if (callback != null)
            {
                frame.FrameID = (byte)frameID;
                waitingForResponseQueue.Enqueue(frame, callback);

                if (waitingForResponseQueue.Count > MaxWaitingForResponseNumber)
                {
                    Callback kickOutcallback = waitingForResponseQueue.CallbackForFrameAtIndex(0);
                    if (kickOutcallback != null)
                    {
                        kickOutcallback(null);
                    }
                    waitingForResponseQueue.RemoveAt(0);
                }
            }
            else
            {
                frame.FrameID = 0;
            }

            SendFrame(frame);
        }

 public Command(string name, string shortDesctiption, string description, Callback callback)
 {
     Name = name;
     ShortDescription = shortDesctiption;
     Description = description;
     Handler = callback;
 }