/// <summary>
/// This method will handle the logic of the options menu. It will only be called when an options menu exists, and all logic will skip when it is inactive.
/// </summary>
/// <param name="pack">see doPacket</param>
public override void doThis(doPacket pack)
{
double t;
switch (activationState)
{
case ActivationState.activating: //When this is in the middle of activating
activationState = ActivationState.active;
break;
case ActivationState.active: //When this is active
if (pack.controller.confirm())
{
switch (selectedIndex)
{
case 0:
pack.state.removeOptions(pack);
break;
}
}
break;
case ActivationState.deactivating: //When this is in the middle of deactivating
break;
case ActivationState.inactive: //When this has successfully deactivated
break;
}
}
public SAProblem(float2 interval, int sampleNum, OptType type = OptType.Swimming) : base()
{
this.state = new ActivationState(new Parameter()
{
interval = interval, sampleNum = sampleNum, type = type
});
}
//-------------------------------------------------------------------
private string Activate(string jsonCmd)
{
string jsonResult = "";
JObject cmdObject = JObject.Parse(jsonCmd);
PaddleProductID prodID = cmdObject.Value <PaddleProductID>(kPaddleCmdKey_SKU);
string emailStr = cmdObject.Value <string>(kPaddleCmdKey_EMAIL);
string snStr = cmdObject.Value <string>(kPaddleCmdKey_SERIAL_NUMBER);
PaddleProduct product = Paddle_GetProduct(prodID);
ScTask task = new ScTask();
product.ActivateWithEmail(emailStr, snStr,
(PaddleSDK.Product.VerificationState verifyState, string resultStr) =>
{
ActivationState state = ConvertState_VerifyToActivate(verifyState);
CJsonResult jResult = new CJsonResult {
successB = state == ActivationState.Activated,
resultI = Convert.ToInt32(state),
errStr = resultStr
};
task.set_result(CreateJsonResult(jResult));
});
jsonResult = task.await_result();
return(jsonResult);
}
private Vector2 POSITION_RETURN; //The position of the return menu item
#endregion Fields
#region Constructors
/// <summary>
/// Standard constructor.
/// </summary>
public OptionsMenuState()
: base(1)
{
animator = 0;
activationState = ActivationState.inactive;
drawRect = new Rectangle();
}
// Start is called before the first frame update
void Start()
{
panelBottomInitialPos = panelBottom.rectTransform.anchoredPosition;
responseTextInitialPos = responseText.rectTransform.anchoredPosition;
responseSelectionBarInitialPos = responseSelectionBar.rectTransform.anchoredPosition;
openingPanelLoadingBarInitialPos = openingPanelLoadingBar.rectTransform.anchoredPosition;
panelSpacerHeight = panelSpacer.texture.height;
panelSpacerWidth = panelSpacer.rectTransform.rect.width;
responseSelectionBarDefaultHeight = responseSelectionBar.texture.height;
openingPanelLoadingBarInitialHeight = openingPanelLoadingBar.rectTransform.rect.height;
responseSelectionBar.enabled = false;
openingPanelLoadingBar.enabled = false;
ShowSpecialFunctionsIcons(false);
ActivationMode = ActivationState.Closed;
SelectionMode = SelectionState.NotSelecting;
openingPanelLoadingBar.enabled = false;
openingPanelCurrentFrame = 0;
openingPanelRefTime = 0;
specialFunctionsCurrentIndex = 0;
specialFunctionsFlashRefTime = 0;
iconAlphaDecreasing = true;
}
static void OnConfigureLifeCycle(IWindowsLifecycleBuilder windows)
{
windows.OnLaunching((app, args) =>
{
// This is the initial Init to set up any system services registered by
// Forms.Init(). This happens before any UI has appeared.
// This creates a dummy MauiContext.
// We need to call this so the Window and Root Page can new up successfully
// The dispatcher that's inside of Forms.Init needs to be setup before the initial
// window and root page start creating.
// Inside OnLaunched we grab the MauiContext that's on the window so we can have the correct
// MauiContext inside Forms
var services = MauiWinUIApplication.Current.Services;
var mauiContext = new MauiContext(services);
var state = new ActivationState(mauiContext, args);
Forms.Init(state, new InitializationOptions {
Flags = InitializationFlags.SkipRenderers
});
})
.OnMauiContextCreated((mauiContext) =>
{
// This is the final Init that sets up the real context from the application.
var state = new ActivationState(mauiContext);
Forms.Init(state);
});
}
public static void CreatePlatformWindow(this CoreApplication platformApplication, IApplication application)
{
if (application.Handler?.MauiContext is not IMauiContext applicationContext)
{
return;
}
var tizenWindow = GetDefaultWindow();
if (tizenWindow == null)
{
throw new InvalidOperationException($"The {nameof(tizenWindow)} instance was not found.");
}
var mauiContext = applicationContext.MakeWindowScope(tizenWindow, out var windowScope);
tizenWindow.SetWindowCloseRequestHandler(() => platformApplication.Exit());
applicationContext.Services.InvokeLifecycleEvents <TizenLifecycle.OnMauiContextCreated>(del => del(mauiContext));
var activationState = new ActivationState(mauiContext);
var window = application.CreateWindow(activationState);
tizenWindow.SetWindowHandler(window, mauiContext);
}
static void OnConfigureLifeCycle(IAndroidLifecycleBuilder android)
{
android
.OnApplicationCreating((app) =>
{
// This is the initial Init to set up any system services registered by
// Forms.Init(). This happens in the Application's OnCreate - before
// any UI has appeared.
// This creates a dummy MauiContext that wraps the Application.
var services = MauiApplication.Current.Services;
var mauiContext = new MauiContext(services, app);
var state = new ActivationState(mauiContext);
Forms.Init(state, new InitializationOptions {
Flags = InitializationFlags.SkipRenderers
});
})
.OnMauiContextCreated((mauiContext) =>
{
// This is the final Init that sets up the real context from the activity.
var state = new ActivationState(mauiContext);
Forms.Init(state);
});
}
static void OnConfigureLifeCycle(IiOSLifecycleBuilder iOS)
{
iOS.WillFinishLaunching((app, options) =>
{
// This is the initial Init to set up any system services registered by
// Forms.Init(). This happens before any UI has appeared.
// This creates a dummy MauiContext.
var services = MauiUIApplicationDelegate.Current.Services;
var mauiContext = new MauiContext(services);
var state = new ActivationState(mauiContext);
#pragma warning disable CS0612 // Type or member is obsolete
Forms.Init(state, new InitializationOptions {
Flags = InitializationFlags.SkipRenderers
});
#pragma warning restore CS0612 // Type or member is obsolete
return(true);
})
.OnMauiContextCreated((mauiContext) =>
{
// This is the final Init that sets up the real context from the application.
var state = new ActivationState(mauiContext);
#pragma warning disable CS0612 // Type or member is obsolete
Forms.Init(state);
#pragma warning restore CS0612 // Type or member is obsolete
});
}
public void SetActivationState(ActivationState newState)
{
if ((m_activationState1 != ActivationState.DISABLE_DEACTIVATION) && (m_activationState1 != ActivationState.DISABLE_SIMULATION))
{
m_activationState1 = newState;
}
}
static UIWindow?CreatePlatformWindow(IApplication application, UIWindowScene?windowScene, NSDictionary[]?states)
{
if (application.Handler?.MauiContext is not IMauiContext applicationContext)
{
return(null);
}
var uiWindow = windowScene is not null
#pragma warning disable CA1416 // UIWindow(windowScene) is only supported on: ios 13.0 and later
? new UIWindow(windowScene)
#pragma warning restore CA1416
: new UIWindow();
var mauiContext = applicationContext.MakeWindowScope(uiWindow, out var windowScope);
applicationContext.Services?.InvokeLifecycleEvents <iOSLifecycle.OnMauiContextCreated>(del => del(mauiContext));
var activationState = new ActivationState(mauiContext, states);
var mauiWindow = application.CreateWindow(activationState);
uiWindow.SetWindowHandler(mauiWindow, mauiContext);
return(uiWindow);
}
private void EstimateInjectorActivationState(ActivationStatus status)
{
switch (status)
{
case ActivationStatus.NotRetrievable:
ActivationState.Set(StatusType.Failed, Localization.Localization.Current.Get("ActivationStatusNotRetrievable"));
break;
case ActivationStatus.NotRunning:
ActivationState.Set(StatusType.Failed, Localization.Localization.Current.Get("ActivationStatusNotRunning"));
break;
case ActivationStatus.Running:
ActivationState.Set(StatusType.Information, Localization.Localization.Current.Get("ActivationStatusRunning"));
break;
case ActivationStatus.PluginLoaded:
ActivationState.Set(StatusType.Ok, Localization.Localization.Current.Get("ActivationStatusPluginLoaded"));
break;
case ActivationStatus.PluginActivationPending:
case ActivationStatus.PluginActivated:
case ActivationStatus.PluginActivationFailed:
break;
default:
throw new ArgumentOutOfRangeException(nameof(status), status, null);
}
}
/// <summary>
/// Evaluate whether an item of the specified type has been activated optionally at the specidied location
/// </summary>
/// <param name="nodeId"></param>
/// <param name="filter"></param>
public ItemTypeIsActivated(EntityConfig entityConfig = null,
ActivationState activationState = ActivationState.Active,
IEntityFilter <Simulation, SimulationConfiguration> filter = null)
{
_entityConfig = entityConfig;
_activationState = activationState;
_filter = filter;
}
public async void Initialize(IShell shell, ActivationState activationState)
{
Shell = shell;
NavigationService.Frame = Shell.NavigationFrame;
NavigationService.Navigated += OnNavigated;
NavigationService.Navigate(activationState.ViewModel.ToString(), activationState.Parameter);
UserContact = await GetUserContactAsync();
}
private void FixedUpdate()
{
if (_previousState != CurrentState)
{
OnStateChanged(_previousState, CurrentState);
}
_previousState = CurrentState;
StateFixedUpdate();
}
public void ShowInfoBgdPanelPromptOnly(int numOfLines)
{
ActivationMode = ActivationState.CommsWindow;
panelTop.enabled = true;
panelSpacer.enabled = true;
panelBottom.enabled = true;
SizePanelsToTextPromptOnly(numOfLines);
}
internal void OnDispatcherReceiveInvalidActivation(Message message, ActivationState activationState)
{
if (this.IsEnabled(DispatcherReceiveInvalidActivationEventName))
{
this.Write(DispatcherReceiveInvalidActivationEventName, new { Message = message, ActivationState = activationState });
}
MessagingProcessingStatisticsGroup.OnDispatcherMessageProcessedError(message);
LogDispatcherReceiveInvalidActivation(this, activationState, message, null);
}
public async Task InitializeAsync(ActivationState activationState)
{
_activationState = activationState;
UserName = await GetUserNameAsync();
IsLoginWithWindowsHello = IsWindowsHelloEnabled(UserName);
IsLoginWithPassword = !IsLoginWithWindowsHello;
IsBusy = false;
}
public ActivationState ToggleStructureIfPossible()
{
ActivationState returnActivationState = CanToggleStructure();
if (returnActivationState == ActivationState.ActivationPossible)
{
returnActivationState = structureTile.ToggleStructureIfPossible();
}
return(returnActivationState);
}
public void OrganizationIsActiveInBackground(int orgId, ActivationState state)
{
var org = _organizationService.FirstOrDefault(i => i.ID == orgId);
var users = _userService.Where(i => i.OrganizationID == orgId).Where(i => i.IsActive == true);
foreach (var user in users)
{
BackgroundJob.Enqueue <IUserNotificationService>(
s => s.OrganizationIsActiveJob(user.Email, user.Name, org.Name, state));
}
}
public ActivationState CanToggleStructure()
{
ActivationState returnActivationState = ActivationState.ImpossibleMissingStructure;
if (structureTile != null)
{
returnActivationState = structureTile.CanToggleStructure();
}
return(returnActivationState);
}
protected override void CopyProperties(PlanNodeDO source)
{
var activity = (ActivityDO)source;
base.CopyProperties(source);
Label = activity.Label;
CrateStorage = activity.CrateStorage;
AuthorizationTokenId = activity.AuthorizationTokenId;
ActivityTemplateId = activity.ActivityTemplateId;
ActivationState = activity.ActivationState;
}
public void ShowOpeningPanel()
{
ActivationMode = ActivationState.Opening;
panelTop.enabled = true;
panelBottom.enabled = true;
SizeOpeningPanel();
openingPanelRefTime = Time.time;
openingPanelCurrentFrame = 0;
}
public ActivationEmailModel(
string username,
string emailAddress,
string activationCode,
DateTime expiry,
ActivationState activationState)
{
this.username = username;
this.emailAddress = emailAddress;
this.activationCode = activationCode;
this.expiry = expiry;
this.activationState = activationState;
}
public void UpdatedAccountState(int userId, ActivationState state)
{
var user = _userService.FirstOrDefault(i => i.ID == userId);
var email = new AccountStateChangedEmail
{
To = user.Email,
From = _emailSettings.SmtpFromEmail,
Name = user.Name,
State = state.GetDescription()
};
Send(email);
}
public void ShowInfoBgdPanel(int numOfLines, int numOfResponseLines)
{
ActivationMode = ActivationState.CommsWindow;
panelTop.enabled = true;
panelSpacer.enabled = true;
panelBottom.enabled = true;
responsePanelTop.enabled = true;
responsePanelSpacer.enabled = true;
responsePanelBottom.enabled = true;
SizePanelsToText(numOfLines, numOfResponseLines);
}
public void ToggleStructure()
{
BaseTileData selectedTile = MouseManager.Instance.SelectedTile;
ActivationState activationState = selectedTile.ToggleStructureIfPossible();
string currentErrorText;
if (_errorTextDico.TryGetValue(activationState, out currentErrorText))
{
_errorText.gameObject.SetActive(true);
_errorText.text = currentErrorText;
}
else
{
_errorText.gameObject.SetActive(false);
}
}
public void ShowSpecialSelectionPanel()
{
ActivationMode = ActivationState.SpecialSelectionMenu;
panelTop.enabled = true;
panelSpacer.enabled = true;
panelBottom.enabled = true;
SizeSpecialSelectionPanel();
UpdateAvailableSpecialFunctionsIcons();
ShowSpecialFunctionsIcons(true);
specialFunctionsCurrentIndex = 0;
availableFunctionsIcons[specialFunctionsCurrentIndex].transform.GetChild(0).GetComponent <Text>().enabled = true;
}
//async Task IActivate.Activate(CancellationToken cancellationToken)
//{
// var state = new ActivationState(isInitialized, isActive);
// var wasCanceled = false;
// var wasRaisedWhileInitilazation = false;
// try
// {
// if (IsActive)
// {
// return;
// }
// var initialized = false;
// var handler = Activated;
// // raise event to let the framework show the ui before we initializing
// if (!IsInitialized)
// {
// var handler1 = handler;
// await Execute.OnUIThreadAsync(() => handler1?.Invoke(this, new ActivationEventArgs { WasInitialized = false }));
// wasRaisedWhileInitilazation = true;
// }
// if (!IsInitialized)
// {
// IsInitialized = initialized = true;
// Log.Info("**** Initializing {0}.", this);
// await OnInitialize(cancellationToken);
// }
// IsActive = true;
// Log.Info("Activating {0}.", this);
// await OnActivate(cancellationToken);
// Log.Info("**** Activating finished {0}.", this);
// if (!wasRaisedWhileInitilazation)
// {
// handler = Activated;
// if (handler != null)
// {
// handler(this,
// new ActivationEventArgs
// {
// WasInitialized = initialized
// });
// }
// }
// }
// catch (OperationCanceledException)
// {
// wasCanceled = true;
// Log.Info("**** Activating canceled {0}.", this);
// throw;
// }
// finally
// {
// if (wasCanceled)
// {
// IsActive = state.IsActive;
// IsInitialized = state.IsInitialized;
// }
// }
//}
async Task IActivate.Activate(CancellationToken cancellationToken)
{
var wasCanceled = false;
var state = new ActivationState(isInitialized, isActive);
try
{
if (IsActive)
{
return;
}
var initialized = false;
if (!IsInitialized)
{
IsInitialized = initialized = true;
await OnInitialize(cancellationToken);
}
IsActive = true;
Log.Info("Activating {0}.", this);
await OnActivate(cancellationToken);
var handler = Activated;
handler?.Invoke(this,
new ActivationEventArgs
{
WasInitialized = initialized
});
}
catch (OperationCanceledException)
{
wasCanceled = true;
Log.Info($"Canceling Activate {this}");
throw;
}
finally
{
if (wasCanceled)
{
IsActive = state.IsActive;
IsInitialized = state.IsInitialized;
}
}
}
public virtual void PlayCustomTransition(bool isHurried, int animationIndex, ActivationState activationState)
{
switch (activationState)
{
case ActivationState.Inert:
PlayAnimation(isHurried, animationIndex);
break;
case ActivationState.ActivateThenExecute:
Open(customAnimationIndex: animationIndex);
break;
case ActivationState.DeactivateAfterCompletion:
Close(customAnimationIndex: animationIndex);
break;
}
}
/// <summary>
/// Updates constraint information for the active object, if applicable.
/// </summary>
private void Update()
{
if (Input.GetMouseButtonDown(0) && (Input.GetKey(KeyCode.LeftAlt) || Input.GetKey(KeyCode.RightAlt)) && constraint == null)
{
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
BulletSharp.Math.Vector3 start = ray.origin.ToBullet();
BulletSharp.Math.Vector3 end = ray.GetPoint(100).ToBullet();
ClosestRayResultCallback callback = new ClosestRayResultCallback(ref start, ref end);
BPhysicsWorld.Get().world.RayTest(start, end, callback);
rayDistance = (start - callback.HitPointWorld).Length;
if (callback.CollisionObject != null)
{
BRigidBody rigidBody = callback.CollisionObject.UserObject as BRigidBody;
if (rigidBody != null && rigidBody.mass > 0f)
{
initialState = rigidBody.GetCollisionObject().ActivationState;
rigidBody.GetCollisionObject().ActivationState = ActivationState.DisableDeactivation;
initialDamping = rigidBody.angularDamping;
rigidBody.angularDamping = 0.9f;
constraint = rigidBody.gameObject.AddComponent <BBallSocketConstraintEx>();
constraint.PivotInA = rigidBody.transform.InverseTransformPoint(callback.HitPointWorld.ToUnity()).ToBullet();
constraint.constraintType = BTypedConstraint.ConstraintType.constrainToPointInSpace;
}
}
}
else if (Input.GetMouseButtonUp(0) && constraint != null)
{
constraint.thisRigidBody.GetCollisionObject().ActivationState = initialState;
constraint.GetComponent <BRigidBody>().angularDamping = initialDamping;
Destroy(constraint);
constraint = null;
}
else if (constraint != null)
{
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
constraint.PivotInB = ray.GetPoint(rayDistance).ToBullet();
}
}
// ----------------------------------------------------------------------
// since ActivationState doesn't exist in PaddleSDK v 2.0.10, we
// implement it here so we have a consistent cross platform API
private ActivationState ConvertState_VerifyToActivate(
PaddleSDK.Product.VerificationState verifyState)
{
ActivationState state = ActivationState.Invalid;
switch (verifyState)
{
case PaddleSDK.Product.VerificationState.Verified: {
state = ActivationState.Activated;
} break;
case PaddleSDK.Product.VerificationState.Unverified:
case PaddleSDK.Product.VerificationState.UnableToVerify: {
state = ActivationState.Failed;
} break;
}
return(state);
}
public static void CreatePlatformWindow(this Activity activity, IApplication application, Bundle?savedInstanceState = null)
{
if (application.Handler?.MauiContext is not IMauiContext applicationContext)
{
return;
}
savedInstanceState ??= activity.Intent?.Extras;
var mauiContext = applicationContext.MakeWindowScope(activity, out var windowScope);
applicationContext.Services.InvokeLifecycleEvents <AndroidLifecycle.OnMauiContextCreated>(del => del(mauiContext));
var activationState = new ActivationState(mauiContext, savedInstanceState);
var window = application.CreateWindow(activationState);
activity.SetWindowHandler(window, mauiContext);
}
public void SetActivationState(ActivationState newState)
{
if ((m_activationState1 != ActivationState.DISABLE_DEACTIVATION) && (m_activationState1 != ActivationState.DISABLE_SIMULATION))
{
m_activationState1 = newState;
}
}
public override void ForceActivationState(BulletBody pCollisionObject, ActivationState pActivationState)
{
CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).body;
collisionObject.ForceActivationState((BulletXNA.BulletCollision.ActivationState)(uint)pActivationState);
}
public CollisionObject()
{
_activationState = ActivationState.Active;
_hitFraction = 1;
}
public void ForceActivationState(ActivationState newState)
{
m_activationState1 = newState;
}
public void SetState(ActivationState state)
{
State = state;
}
public override void ForceActivationState(BulletBody obj, ActivationState state)
{
BulletBodyUnman bodyu = obj as BulletBodyUnman;
BSAPICPP.ForceActivationState2(bodyu.ptr, state);
}
public static extern void ForceActivationState2(IntPtr obj, ActivationState state);
static extern void btCollisionObject_setActivationState(IntPtr obj, ActivationState newState);
public void ForceActivationState(ActivationState newState)
{
btCollisionObject_forceActivationState(_native, newState);
}
internal static void ForceActivationState2(object pBody, ActivationState pActivationState)
{
CollisionObject body = pBody as CollisionObject;
body.ForceActivationState((BulletXNA.BulletCollision.ActivationState)(uint)pActivationState);
}
/// <summary>
/// This method will activate the options menu. It should be called after the game has been paused.
/// </summary>
/// <param name="s">The state to return to once options are completed.</param>
/// <param name="pack">see doPacket</param>
public void activate(State s, doPacket pack)
{
activationState = ActivationState.activating;
returnState = s;
animator = 0;
}
public override void ForceActivationState(BulletBody pBody, ActivationState pActivationState)
{
CollisionObject body = ((BulletBodyXNA)pBody).body;
body.ForceActivationState((BulletXNA.BulletCollision.ActivationState)(uint)pActivationState);
}
public abstract void ForceActivationState(BulletBody obj, ActivationState state);
/// <summary>
/// This will load the assets for this state
/// </summary>
/// <param name="content">The content manager to load the assets</param>
public override void loadState(GameState state, ContentManager content)
{
this.state = state;
background = content.Load<Texture2D>("junk\\junkoptions");
font = content.Load<SpriteFont>("realassets\\russellsquare");
drawRect = new Rectangle(100, 100, 960, 540);
POSITION_RETURN = new Vector2(200, 200);
activationState = ActivationState.activating;
animator = 0;
}