/** * @param target_pos target position for each point in Polygon * @param frame_count number of frame that construct the tweening */ public void tweening(int[,] start_pos, int[,] target_pos, double progress, Callback callback) { if (target_pos.GetLength(0) < this.vertices.GetLength(0) || (progress < 0 || progress > 1)) { Console.WriteLine("[Debug] Tweening failed, new points length not match." + progress); return; } for (int i = 0; i < this.vertices.GetLength(0); i++) { double x = ((1 - progress) * start_pos[i, 0] + (progress * target_pos[i, 0])); double y = ((1 - progress) * start_pos[i, 1] + (progress * target_pos[i, 1])); Console.WriteLine("[" + i + "] " + x + ", " + y); this.vertices[i].translate((int)x, (int)y, false); } callback(); return; System.Windows.Forms.Timer timr = new System.Windows.Forms.Timer(); timr.Tick += (sender, e) => { for (int i = 0; i < this.vertices.GetLength(0); i++) { int x = (int) ((1 - progress) * target_pos[i, 0] + (progress * start_pos[i, 0])); int y = (int) ((1 - progress) * target_pos[i, 1] + (progress * start_pos[i, 1])); this.vertices[i].translate(x, y, false); } }; timr.Interval = 50; timr.Start(); }
public void Un(string message, Callback callback) { List<Callback> group = null; if (callback != null && Listeners.TryGetValue(message, out group)) { group.Remove(callback); } }
private IVsThreadedWaitDialog3 CreateDialog( IVsThreadedWaitDialogFactory dialogFactory, bool showProgress) { Marshal.ThrowExceptionForHR(dialogFactory.CreateInstance(out var dialog2)); Contract.ThrowIfNull(dialog2); var dialog3 = (IVsThreadedWaitDialog3)dialog2; var callback = new Callback(this); dialog3.StartWaitDialogWithCallback( szWaitCaption: _title, szWaitMessage: _message, szProgressText: null, varStatusBmpAnim: null, szStatusBarText: null, fIsCancelable: _allowCancel, iDelayToShowDialog: DelayToShowDialogSecs, fShowProgress: showProgress, iTotalSteps: this.ProgressTracker.TotalItems, iCurrentStep: this.ProgressTracker.CompletedItems, pCallback: callback); return dialog3; }
public static void Show(string message, Callback OnFinish = null) { instance.text.text = message; instance.anim.SetBool("display", true); instance.onFinish = OnFinish; }
public DelayedCall(Callback cb, int milliseconds) : this() { PrepareDCObject(this, milliseconds, false); callback = cb; if (milliseconds > 0) Start(); }
public BaseInfoControl(string name , Callback cb) { InitializeComponent(); mPipeName = name; ShowContent(name); mCB = cb; }
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 ProgressBarForm(string title, Callback callback, Object arg) { InitializeComponent(); this.callback = callback; this.arg = arg; this.Text = title; }
public LoginServerCall(string id, string deviceType, string version, Callback callback) { this.id = id; this.deviceType = deviceType; this.version = version; this.callback = callback; }
/** * Add a callback when this window is dismissed due to 'Save' being called. */ public void AddOnSaveListener(Callback<string> listener) { if(OnSave != null) OnSave += listener; else OnSave = listener; }
/** * Add a callback when this window is canceled. */ public void AddOnCancelListener(Callback listener) { if(OnCancel != null) OnCancel += listener; else OnCancel = listener; }
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); }
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 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; }
public string getShareCatalogResults(string requestParam) { string RetVal = string.Empty; Callback objCallback = new Callback(new System.Web.UI.Page()); RetVal = objCallback.ShareSearchResult(requestParam); return RetVal; }
public string GetQDSResults(string indicatorNId, string iCNId, string areaNId, string languageCode, string dBNId) { string RetVal = string.Empty; Callback objCB = new Callback(); RetVal = objCB.GetQDSResults(indicatorNId + Constants.Delimiters.ParamDelimiter + iCNId + Constants.Delimiters.ParamDelimiter + areaNId + Constants.Delimiters.ParamDelimiter + languageCode + Constants.Delimiters.ParamDelimiter + dBNId); return RetVal; }
/// <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(); } }); } }
public TimedItem(Callback callback, float time) { //this.SpriteKey = key; this.cb = callback; this.Time = time; this.TimerElapsed = 0; }
public static void CreateServiceFunction(string serviceName, Callback callback, MirandaPlugin owner) { if (String.IsNullOrEmpty(serviceName)) throw new ArgumentNullException("serviceName"); if (callback == null) throw new ArgumentNullException("callback"); if (owner == null) throw new ArgumentNullException("owner"); if (!owner.Initialized) throw new InvalidOperationException(TextResources.ExceptionMsg_PluginNotInitialized); HookDescriptorCollection collection = owner.Descriptor.ServiceFunctions; try { SynchronizationHelper.BeginPluginUpdate(owner); SynchronizationHelper.BeginCollectionUpdate(collection); HookDescriptor descriptor = HookDescriptor.SetUpAndStore(collection, serviceName, owner.Descriptor, callback, HookType.ServiceFunction); descriptor.RegisteredManually = true; HookManager.CreateHook(descriptor); } finally { SynchronizationHelper.EndUpdate(owner); SynchronizationHelper.EndUpdate(collection); } }
public Command(string name, string shortDesctiption, string description, Callback callback) { Name = name; ShortDescription = shortDesctiption; Description = description; Handler = callback; }
public Command(string name, string shortDesctiption, string description) { Name = name; ShortDescription = shortDesctiption; Description = description; Handler = new Callback(Unsupported); }
/// <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 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 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); } }
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> /// 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 string OptimizeAdaptationDataBase() { string RetVal = string.Empty; Callback objCallback = new Callback(); RetVal = objCallback.GenerateCacheResults("1" + Constants.Delimiters.ParamDelimiter + "General"); return RetVal; }
/// <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> /// 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(); }
//C++ TO C# CONVERTER TODO TASK: 'rvalue references' have no equivalent in C#: public override void getRandomOutsByAmounts(List <ulong> && amounts, ushort outsCount, List <CryptoNote.COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS.outs_for_amount> result, Callback callback) { }
public override void getBlocks(List <Crypto.Hash> blockHashes, List <CryptoNote.BlockDetails> blocks, Callback callback) { }
public override void getBlocks(List <uint> blockHeights, List <List <CryptoNote.BlockDetails> > blocks, Callback callback) { }
//C++ TO C# CONVERTER TODO TASK: 'rvalue references' have no equivalent in C#: public override void getPoolSymmetricDifference(List <Crypto.Hash> && knownPoolTxIds, Crypto.Hash knownBlockId, ref bool isBcActual, List <std::unique_ptr <CryptoNote.ITransactionReader> > newTxs, List <Crypto.Hash> deletedTxIds, Callback callback) { isBcActual = true; callback(std::error_code()); }
//C++ TO C# CONVERTER TODO TASK: 'rvalue references' have no equivalent in C#: public override void queryBlocks(List <Crypto.Hash> && knownBlockIds, ulong timestamp, List <CryptoNote.BlockShortEntry> newBlocks, ref uint startHeight, Callback callback) { startHeight = 0; callback(std::error_code()); }
public override void getTransactionOutsGlobalIndices(Crypto.Hash transactionHash, List <uint> outsGlobalIndices, Callback callback) { }
//C++ TO C# CONVERTER TODO TASK: 'rvalue references' have no equivalent in C#: public override void getNewBlocks(List <Crypto.Hash> && knownBlockIds, List <CryptoNote.RawBlock> newBlocks, ref uint startHeight, Callback callback) { startHeight = 0; callback(std::error_code()); }
public override void getTransactionHashesByPaymentId(Crypto.Hash paymentId, List <Crypto.Hash> transactionHashes, Callback callback) { callback(std::error_code()); }
public static void DetectGhosts(Callback Callback) { callback = Callback; start(); }
public override void relayTransaction(CryptoNote.Transaction transaction, Callback callback) { callback(std::error_code()); }
public BroadcastNotification(Callback callback) { this.callback = callback; }
public override void getBlockHashesByTimestamps(ulong timestampBegin, uint secondsCount, List <Crypto.Hash> blockHashes, Callback callback) { callback(std::error_code()); }
/// <summary> /// 单次计时触发器 /// </summary> /// <param name="delta">触发间隔(秒)</param> /// <param name="callBack">回调方法</param> /// <returns>计时器ID</returns> public static int SetTimeOut(float delta, Callback callBack) { return SetTimeOut(delta, callBack, 1); }
public TeamAggregatedStatsDTO(Callback callback) { this.callback = callback; }
public static MoveRectPositionTween Play(object obj, Vector2 endValue, float duration, ISimulateFunction function, TweenEndValueType endValueType = TweenEndValueType.To, Callback callback = null) { return((MoveRectPositionTween)(new MoveRectPositionTween(obj, endValue, duration, function, endValueType, callback)).PlayAndReturnSelf()); }
public void OnCellFormatting(GridCellFormatEventArgs args) { Callback.OnCellFormatting(Widget, args); }
public static MoveRectPositionTween Play(object obj, Vector2 endValue, float duration, AnimationCurve curve, TweenEndValueType endValueType = TweenEndValueType.To, Callback callback = null) { return(Play(obj, endValue, duration, new AnimationCurveSimulateFunction(curve), endValueType, callback)); }
static extern IntPtr c_newvm([MarshalAs(UnmanagedType.LPStr)] string name, Callback cb, out IntPtr err);
public MoveRectPositionTween(object obj, Vector2 endValue, float duration, EaseFunction ease, TweenEndValueType endValueType = TweenEndValueType.To, Callback callback = null) : this(obj, endValue, duration, new EaseSimulateFunction(ease), endValueType, callback) { }
public static MoveRectPositionTween Play(object obj, Vector2 endValue, float duration, EaseType easeType, TweenEndValueType endValueType = TweenEndValueType.To, Callback callback = null) { return(Play(obj, endValue, duration, new EaseSimulateFunction(TweenPerformer.Ease[easeType]), endValueType, callback)); }
public void unregisterWith(Callback handler) { link_.unregisterWith(handler); }
public MoveRectPositionTween(object obj, Vector2 endValue, float duration, ISimulateFunction function, TweenEndValueType endValueType = TweenEndValueType.To, Callback callback = null) : base(obj, endValue, duration, function, TweenType.MoveRectPosition, endValueType, callback) { }
void Start() { _instance = this; Callback_ServerConnected = Callback <SteamServersConnected_t> .CreateGameServer(OnSteamServerConnected); }
public MoveRectPositionTween(object obj, Vector2 endValue, TweenEndValueType endValueType = TweenEndValueType.To, Callback callback = null) : this(obj, endValue, 0, new EaseSimulateFunction(TweenPerformer.Ease[EaseType.EndValue]), endValueType, callback) { }
public void MultiplyBy(double n) { result *= n; equation += " * " + n.ToString(); Callback.Equals(result); }
public void unregisterWith(Callback handler) { notifyObserversEvent -= handler; }
public void AddTo(double n) { result += n; equation += " + " + n.ToString(); Callback.Equals(result); }
public void DivideBy(double n) { result /= n; equation += " / " + n.ToString(); Callback.Equals(result); }
public void Clear() { Callback.Equation(equation + " = " + result.ToString()); equation = result.ToString(); }
public void SubtractFrom(double n) { result -= n; equation += " - " + n.ToString(); Callback.Equals(result); }