/**
* @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);
}
