void Start()
{
radial = RadialTimer.GetComponent<Image>();
radialText = RadialTimer.GetComponentInChildren<Text>();
viewState = ViewStates.BUILDING;
co = ChoosePicture();
}
public void HideTabs()
{
NotificationBubbleState = NotificationBubble.Visibility;
tabHost.TabWidget.Visibility = ViewStates.Gone;
NotificationBubble.Visibility = ViewStates.Gone;
}
protected override void OnWindowVisibilityChanged (ViewStates visibility)
{
base.OnWindowVisibilityChanged (visibility);
// When we become visible or invisible, play is paused.
SetGamePaused (true);
}
protected FlyerViewModelBase(SelectedMaterialProvider selectedMaterialProvider, IFontService fontService,
ViewStates viewState)
{
this.viewState = viewState;
SelectedMaterialProvider = selectedMaterialProvider;
FontService = fontService;
CanAddLogo = true;
}
protected override void OnWindowVisibilityChanged(ViewStates visibility)
{
base.OnWindowVisibilityChanged(visibility);
// It is needed because a size of popup has not updated on Android 7+. See #209
if (visibility == ViewStates.Visible)
{
RequestLayout();
}
}
private void HandleButtonsForProgress(ActiveQuestViewHolder holder, Quest questData)
{
ViewStates doneFailState = questData.IsLeaf ? ViewStates.Visible : ViewStates.Gone;
holder.StartButton.Visibility = ViewStates.Gone;
holder.CancelButton.Visibility = ViewStates.Visible;
holder.DeleteButton.Visibility = ViewStates.Visible;
holder.DoneButton.Visibility = doneFailState;
holder.FailButton.Visibility = doneFailState;
}
public void StartAlphaAnimation(View view, long duration, ViewStates visibility)
{
AlphaAnimation alphaAnimation = (visibility == ViewStates.Visible)
? new AlphaAnimation(0f, 1f)
: new AlphaAnimation(1f, 0f);
alphaAnimation.Duration = duration;
alphaAnimation.FillAfter = true;
view.StartAnimation(alphaAnimation);
}
protected override void OnVisibilityChanged(View changedView, [GeneratedEnum] ViewStates visibility)
{
base.OnVisibilityChanged(changedView, visibility);
if (changedView.GetType().Name == "PageContainer")
{
_isContainerShown = visibility == ViewStates.Visible;
SetAutoUpdate(_isContainerShown);
}
}
public CounterpartiesRowItemAdapter(
Context context,
IRoleManager roleManager)
: base(context, roleManager, Resource.Layout.CounterpartiesRowItem)
{
DeleteVisibility = roleManager.Permissions.ContainsKey(Resource.Id.CounterpartiesRowItemDelete) ? ViewStates.Visible : ViewStates.Invisible;
ReadVisibility = roleManager.Permissions.ContainsKey(Resource.Id.CounterpartiesRowItemInfo) ? ViewStates.Visible : ViewStates.Invisible;
EditVisibility = roleManager.Permissions.ContainsKey(Resource.Id.CounterpartiesRowItemEdit) ? ViewStates.Visible : ViewStates.Invisible;
_styleProvider = ColorConditionalStyleProvider.Instance;
}
public void SetVisibility(Activity activity, ViewStates viewState)
{
View view = GetView(activity);
if (view == null)
{
return;
}
view.Visibility = viewState;
}
void Update()
{
if(viewState != ViewStates.BUILDING) {
Ray ray = Camera.main.ViewportPointToRay(new Vector3(0.5F, 0.5F, 0));
RaycastHit hit;
if(Physics.Raycast(ray, out hit, 25.0f)) {
// look for a new game object;
if(hit.transform.tag == "image" && target != hit.transform.gameObject) {
ResetSelectedPanel();
target = hit.transform.gameObject;
oldPosition = target.transform.position;
oldRotation = target.transform.rotation;
DestroyAndCreateNewHighlight();
}
// same target?
else if(target == hit.transform.gameObject) {
timer -= Time.fixedDeltaTime;
// halfway? Invoke the radial
if(timer <= timeToFocus / 2) {
if(viewState == ViewStates.LOOKING) {
RadialTimer.SetActive(true);
viewState = ViewStates.CHOSEN;
StartCoroutine(co);
}
}
// full way? we are viewing the picture!
if(timer <= 0) {
if(viewState == ViewStates.CHOSEN) {
RadialTimer.SetActive(false);
viewState = ViewStates.VIEWING;
}
}
}
}
// no target?
else {
Destroy(tempHighlightTexture);
ResetSelectedPanel();
target = null;
}
}
if(viewState == ViewStates.VIEWING) {
if(!viewingThePhoto) {
target.transform.parent = transform;
target.transform.localPosition = new Vector3(0, 0, 0.8f);
target.transform.localRotation = Quaternion.identity;
target.transform.parent = null;
viewingThePhoto = true;
}
}
}
protected internal TreeViewAttributes(TreeViewAttributes attributes)
{
this.TraceVisibility = attributes.TraceVisibility;
this.TraceColor = attributes.TraceColor;
this.TraceWidth = attributes.TraceWidth;
this.TraceMargin = attributes.TraceMargin;
this.NodeMargin = attributes.NodeMargin;
this.HeadMargin = attributes.HeadMargin;
this.MaxLevel = attributes.MaxLevel;
this.Level = attributes.Level;
}
public void Show(Action p_action)
{
EnableInputs(false);
gameObject.SetActive(true);
State = ViewStates.Showing;
StartAnimation(ViewAnimations.Show, () =>
{
EnableInputs(true);
p_action?.Invoke();
});
}
protected override void OnWindowVisibilityChanged(ViewStates visibility)
{
if (visibility == ViewStates.Gone)
{
_isFirstDesign = true;
}
//else
// _isFirstDesign = false;
base.OnWindowVisibilityChanged(visibility);
}
private void ChangeLoginViewState(bool isSignIn)
{
mIsSignIn = isSignIn;
ViewStates signInState = isSignIn ? ViewStates.Visible : ViewStates.Gone;
ViewStates signUpState = isSignIn ? ViewStates.Gone : ViewStates.Visible;
mNicknameLayout.Visibility = signUpState;
mSignInButton.Visibility = signInState;
mSignUpButton.Visibility = signUpState;
mSignUpClickableText.Text = isSignIn ? "注册" : "登录";
}
protected override void OnWindowVisibilityChanged(ViewStates visibility)
{
base.OnWindowVisibilityChanged(visibility);
if (isFirstTime)
{
ActionBar actionBar = activity.ActionBar;
ColorDrawable colorDrawable = new ColorDrawable(Styling.BarColor.ToAndroid());
actionBar.SetStackedBackgroundDrawable(colorDrawable);
isFirstTime = false;
}
}
private ViewStates _tempState; // used exclusively by editAsync and CancelAsync to reset state to previous state.
private void EditAsync(Object argument)
{
_tempState = this.State;
this.State = ViewStatesHelper.MoveToState(this.State, ViewStates.Updating);
if (this.InitialState != ViewStates.Creating)
{
this.RaisePropertyChanged(nameof(this.State));
}
this._refreshAction();
}
protected override void OnVisibilityChanged(View changedView, ViewStates visibility)
{
base.OnVisibilityChanged(changedView, visibility);
if (visibility == ViewStates.Visible)
{
this.sensorManager.RegisterListener(this, this.accelerometer, SensorDelay.Normal);
}
else if ((visibility == ViewStates.Invisible) || (visibility == ViewStates.Gone))
{
this.sensorManager.UnregisterListener(this, this.accelerometer);
}
}
protected override void OnVisibilityChanged(View changedView, ViewStates visibility)
{
base.OnVisibilityChanged(changedView, visibility);
if (visibility == ViewStates.Visible)
{
Start();
}
else
{
Stop();
}
}
public bool IsVisible()
{
ViewStates visibility = imageView.Visibility;
if (visibility == ViewStates.Visible)
{
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Toggles the visibility of a card action.
/// </summary>
/// <returns>The Card itself, allows for chaining of calls</returns>
/// <param name="actionId"></param>
/// <param name="isVisible"></param>
public Card SetActionVisibility(int actionId, Boolean isVisible)
{
ViewStates visibilityFlag = isVisible ? ViewStates.Visible : ViewStates.Gone;
foreach (CardAction action in mCardActions)
{
if (action.Id == actionId && action.ActionView != null)
{
action.ActionView.Visibility = visibilityFlag;
}
}
return(this);
}
protected override void OnWindowVisibilityChanged(ViewStates visibility)
{
base.OnWindowVisibilityChanged(visibility);
if (visibility == ViewStates.Visible)
{
RemoveCallbacks(this);
Post(this);
}
else if (visibility == ViewStates.Gone)
{
RemoveCallbacks(this);
}
}
protected override void OnVisibilityChanged(View changedView, ViewStates visibility)
{
base.OnVisibilityChanged(changedView, visibility);
if (visibility == ViewStates.Visible)
{
LoadItems();
}
else
{
UnloadItems();
}
}
protected override void OnVisibilityChanged(View changedView, [GeneratedEnum] ViewStates visibility)
{
base.OnVisibilityChanged(changedView, visibility);
if (visibility == ViewStates.Gone || visibility == ViewStates.Invisible)
{
stopAnimation();
}
else
{
startAnimation();
}
}
private void RestoreAllControls(ViewStates RemoveButtonState)
{
//ActivityIndicatorLayout.IsVisible = false;
MainGridLayout.Visibility = ViewStates.Visible;
ActivityGridLayout.Visibility = ViewStates.Invisible;
DecryptButton.Enabled = true;
OpenFileButton.Enabled = true;
RemoveButton.Visibility = RemoveButtonState;
TextInputEditor.Enabled = true;
PasswordSwitch.Enabled = true;
CustomPasswordEntry.Enabled = true;
DecryptButton.Text = "Start Decryption";
}
/// <summary>
/// Always tap once before going into the view.
/// </summary>
/// <param name="ViewStates">Say the view state, where it is calling from.</param>
/// <param name="App">Gives the model if it is a editing state or creating posting state or when deleting.</param>
/// <returns>If successfully saved returns true or else false.</returns>
private bool ViewTapping(ViewStates view, App app = null)
{
switch (view)
{
case ViewStates.Index:
break;
case ViewStates.Create:
ViewBag.ShowAllDivs = "false";
break;
case ViewStates.CreatePost: // before saving it
ViewBag.ShowAllDivs = "true";
break;
case ViewStates.Edit:
ViewBag.ShowAllDivs = "true";
ViewBag.preexistGallery = GetAppGalleryImageCountValueStatic(app.UploadGuid);
break;
case ViewStates.Details:
break;
case ViewStates.EditPost: // before saving it
ViewBag.preexistGallery = GetAppGalleryImageCountValueStatic(app.UploadGuid);
ViewBag.ShowAllDivs = "true";
break;
case ViewStates.SavingAppDraftBeforePost: // before saving it
break;
case ViewStates.SavingAppDraftAfterPost: // before saving it
break;
case ViewStates.DraftsIndex:
break;
case ViewStates.DraftsToApp:
ViewBag.preexistGallery = GetAppGalleryImageCountValueStatic(app.UploadGuid);
if (ViewBag.preexistGallery > 0)
{
ViewBag.ShowAllDivs = "true";
}
break;
case ViewStates.Delete:
break;
}
return(true);
}
private async void ShowRegistration(ViewStates state)
{
var lblemail = FindViewById <GridLayout>(Resource.Id.newUserLayout);
lblemail.Visibility = state;
var countryList = (await _countryService.GetCountries()).Select(x => x.Name).ToList();
var spnCountry = FindViewById <Spinner>(Resource.Id.spnCountry);
var countryAdapter = new ArrayAdapter <string>(this, Android.Resource.Layout.SimpleSpinnerItem, countryList);
countryAdapter.SetDropDownViewResource(Android.Resource.Layout.SimpleSpinnerDropDownItem);
spnCountry.Adapter = countryAdapter;
}
protected override void OnGlobalLayoutChangedInternal(View view)
{
ViewStates visibility = view.Visibility;
if (_oldValue == visibility)
{
return;
}
_oldValue = visibility;
if (!_listenerRef.EventListener.TryHandle(view, EventArgs.Empty))
{
Dispose();
}
}
public MaximisedBubble(Context context, BubbleData bubbleData) : base(context, bubbleData)
{
this.bubbleData = bubbleData;
if (bubbleData.DeliveryDate != string.Empty)
{
deliveryVisibility = ViewStates.Visible;
backgroundDrawable = ContextCompat.GetDrawable(context, Resource.Drawable.bg_transparent_black);
}
else
{
deliveryVisibility = ViewStates.Gone;
backgroundDrawable = ContextCompat.GetDrawable(context, Resource.Drawable.bg_rounded_bottom_black);
}
}
protected override void OnVisibilityChanged(View changedView, ViewStates visibility)
{
base.OnVisibilityChanged(changedView, visibility);
bool visible = visibility == ViewStates.Visible && Visibility == ViewStates.Visible;
if (visible)
{
StartAnimation();
}
else
{
StopAnimation();
}
}
/// <summary>
/// Create a ListBoxItem with the specified parameters.
/// </summary>
/// <param name="icon">Icon texture for this item.</param>
/// <param name="theme">Textile theme represented by this item.</param>
/// <param name="horizontalSize">Item's horizontal size as a fraction of the listbox viewport width.</param>
/// <param name="verticalSize">Item's vertical size as a fraction of the listbox viewport height./param>
public ListBoxItem(Texture2D icon, Textiles.Theme theme, float horizontalSize, float verticalSize)
: base(null, horizontalSize, verticalSize)
{
Icon = icon;
Theme = theme;
viewState = ViewStates.Minimized;
// Default animations steps based on the default Game.TargetElapsedType of 1/60 of a second.
animationSteps = Convert.ToInt32(animationDuration/targetElapsedMilliSeconds);
scaleStep = new Vector2((float)(maxItemWidth - minItemWidth)/maxItemWidth ,
(float)(maxItemHeight - minItemHeight)/maxItemHeight);
scaleStep /= (float) animationSteps;
}
void AdjustUIForMediaType(UpcInvCore.ADAS adas)
{
if (m_txtLocation == null || m_ebLocation == null || m_ebNotes == null)
{
return;
}
RunOnUiThread(
() =>
{
ViewStates visLocation = ViewStates.Gone;
ViewStates visNotes = ViewStates.Gone;
ViewStates visBin = ViewStates.Gone;
switch (adas)
{
case UpcInvCore.ADAS.Book:
visLocation = ViewStates.Visible;
break;
case UpcInvCore.ADAS.Wine:
visNotes = ViewStates.Visible;
break;
case UpcInvCore.ADAS.WineRack:
visBin = ViewStates.Visible;
break;
case UpcInvCore.ADAS.DVD:
break;
case UpcInvCore.ADAS.Generic:
break;
}
m_txtLocation.Visibility = visLocation;
m_ebLocation.Visibility = visLocation;
m_ebNotes.Visibility = visNotes;
m_txtBinCode.Visibility = visBin;
m_txtColumn.Visibility = visBin;
m_txtRow.Visibility = visBin;
m_ebBinCode.Visibility = visBin;
m_ebColumn.Visibility = visBin;
m_ebRow.Visibility = visBin;
});
}
public static View FadeOut(this View view, ViewStates viewStateAfterAnimation, long duration = 350)
{
view.Animation?.Cancel();
view.Animate()
.Alpha(0)
.SetDuration(duration)
.SetStartDelay(125)
.SetListener(
new AnimatorActionListenerWrapper(
x => { },
x => view.Visibility = viewStateAfterAnimation,
x => { },
x => { }))
.Start();
return(view);
}
private void SetBarVisibility(ViewStates visibility)
{
if (OuterContainer != null)
{
OuterContainer.Visibility = visibility;
}
if (_backgroundView != null)
{
_backgroundView.Visibility = visibility;
}
if (_backgroundOverlay != null)
{
_backgroundOverlay.Visibility = visibility;
}
}
protected override void OnWindowVisibilityChanged([GeneratedEnum] ViewStates visibility)
{
base.OnWindowVisibilityChanged(visibility);
if (visibility == ViewStates.Visible)
{
Activity activity = CrossCurrentActivity.Current.Activity;
activity.Window.AddFlags(WindowManagerFlags.KeepScreenOn);
}
else
{
Activity activity = CrossCurrentActivity.Current.Activity;
activity.Window.ClearFlags(WindowManagerFlags.KeepScreenOn);
}
}
private void ShowConversionButton(View parent, ViewStates visible)
{
LinearLayout addProductButton = parent.FindViewById <LinearLayout>(Resource.Id.linAddProduct);
if (addProductButton == null)
{
return;
}
addProductButton.Visibility = visible;
TextView titleTextView = addProductButton.FindViewById <TextView>(Resource.Id.txt_additional_product);
titleTextView.SetText(Resource.String.existing_prospect_register_customer);
titleTextView.SetAllCaps(true);
TextView detailsTextView = addProductButton.FindViewById <TextView>(Resource.Id.txt_additional_product_details);
detailsTextView.SetText(Resource.String.existing_prospect_go_cust_reg);
}
public TimeEntryViewData(TimeEntryViewModel timeEntryViewModel)
{
TimeEntryViewModel = timeEntryViewModel;
var spannableString = new SpannableStringBuilder();
if (TimeEntryViewModel.HasProject)
{
spannableString.Append(TimeEntryViewModel.ProjectName, new ForegroundColorSpan(Color.ParseColor(TimeEntryViewModel.ProjectColor)), SpanTypes.ExclusiveInclusive);
if (!string.IsNullOrEmpty(TimeEntryViewModel.TaskName))
{
spannableString.Append($": {TimeEntryViewModel.TaskName}");
}
if (!string.IsNullOrEmpty(TimeEntryViewModel.ClientName))
{
spannableString.Append($" {TimeEntryViewModel.ClientName}", new ForegroundColorSpan(Color.ParseColor(ClientNameColor)), SpanTypes.ExclusiveExclusive);
}
ProjectTaskClientText = spannableString;
ProjectTaskClientVisibility = ViewStates.Visible;
}
else
{
ProjectTaskClientText = new SpannableString(string.Empty);
ProjectTaskClientVisibility = ViewStates.Gone;
}
DurationText = TimeEntryViewModel.Duration.HasValue
? DurationAndFormatToString.Convert(TimeEntryViewModel.Duration.Value, TimeEntryViewModel.DurationFormat)
: "";
DescriptionVisibility = TimeEntryViewModel.HasDescription.ToVisibility();
AddDescriptionLabelVisibility = (!TimeEntryViewModel.HasDescription).ToVisibility();
ContinueImageVisibility = TimeEntryViewModel.CanContinue.ToVisibility();
ErrorImageViewVisibility = (!TimeEntryViewModel.CanContinue).ToVisibility();
ErrorNeedsSyncVisibility = TimeEntryViewModel.NeedsSync.ToVisibility();
ContinueButtonVisibility = TimeEntryViewModel.CanContinue.ToVisibility();
BillableIconVisibility = TimeEntryViewModel.IsBillable.ToVisibility();
HasTagsIconVisibility = TimeEntryViewModel.HasTags.ToVisibility();
}
public void ToggleViews()
{
switch (ViewState)
{
case ViewStates.Both:
ViewState = ViewStates.OnlyInput;
break;
case ViewStates.OnlyInput:
ViewState = ViewStates.OnlyPreview;
break;
case ViewStates.OnlyPreview:
ViewState = ViewStates.Both;
break;
default:
throw new ArgumentOutOfRangeException();
}
}
/// <summary>
/// Reduces the size of the ListBox viewport.
/// </summary>
public void Minimize()
{
targetWidth = MinimumListBoxWidth;
listBoxViewState = ViewStates.Contracting;
ScrollBar.Reveal(animationSteps);
}
void FinishedBuildingPanelsEvent()
{
viewState = ViewStates.LOOKING;
}
/// <summary>
/// Increases the size of the ListBox viewport.
/// </summary>
public void Maximize()
{
targetWidth = itemWidth * listBoxStateMachine.Items.Count;
// Because of Elasticity the value out can be outside the range [0,1]
// But we can only restore a value between [0, 1 - HorizontalViewPortsize].
viewPortStartPosition = MathHelper.Clamp(listBoxStateMachine.HorizontalViewportStartPosition,
0f,
1f - listBoxStateMachine.HorizontalViewportSize);
viewportStep = viewPortStartPosition/animationSteps;
listBoxViewState = ViewStates.Expanding;
ScrollBar.Hide(animationSteps);
}
/// <summary>
/// Updates the item's state.
/// </summary>
internal void Update()
{
if (IsPressed)
{
// Item is pressed.
switch (viewState)
{
case ViewStates.Minimized:
// Begin expansion animation.
animationStepCount = 0;
animationScale = new Vector2((float)minItemWidth/maxItemWidth,
(float)minItemHeight/maxItemHeight);
viewState = ViewStates.Expanding;
break;
case ViewStates.Contracting:
// Reverse the animation.
viewState = ViewStates.Expanding;
// Reset the step count so that the number of steps remaining
// is equal to the number of steps taken.
animationStepCount = animationSteps - animationStepCount;
AnimationScale += scaleStep;
animationStepCount++;
if (animationStepCount >= animationSteps - 1)
{
viewState = ViewStates.Maximized;
}
break;
case ViewStates.Expanding:
// Continue expansion animation.
// Detect finish condition.
AnimationScale += scaleStep;
animationStepCount++;
if (animationStepCount >= animationSteps - 1)
{
viewState = ViewStates.Maximized;
}
break;
}
}
else
{
switch (viewState)
{
case ViewStates.Maximized:
// Start contraction animation.
animationStepCount = 0;
AnimationScale = Vector2.One;
viewState = ViewStates.Contracting;
break;
case ViewStates.Expanding:
// Reverse the animation.
viewState = ViewStates.Contracting;
// Reset the step count so that the number of steps remaining
// is equal to the number of steps taken.
animationStepCount = animationSteps - animationStepCount;
AnimationScale -= scaleStep;
animationStepCount++;
// Detect finish condition.
if (animationStepCount >= animationSteps - 1)
{
viewState = ViewStates.Minimized;
}
break;
case ViewStates.Contracting:
// Continue contraction animation.
AnimationScale -= scaleStep;
animationStepCount++;
// Detect finish condition.
if (animationStepCount >= animationSteps - 1)
{
viewState = ViewStates.Minimized;
}
break;
}
}
}
/// <summary>
/// Updates ScrollBar state.
/// </summary>
/// <remarks>Extends Update method from UIElement.</remarks>
/// <param name="gameTime"></param>
public override void Update(GameTime gameTime)
{
// Thumb animation state.
if (scrollBarStateMachine.SelectedPart == ScrollBarPart.None)
{
switch(thumbViewState)
{
case ViewStates.Maximized:
// Start contraction animation.
thumbAnimationStart = gameTime.TotalGameTime;
thumbViewState = ViewStates.Contracting;
break;
case ViewStates.Expanding:
// Reverse the animation.
// Adjust the animationStart time so that the time remaining
// is equal the time the animation has run in the opposing direction.
TimeSpan remaining = thumbAnimationStart + thumbAnimationDuration - gameTime.TotalGameTime;
thumbAnimationStart = gameTime.TotalGameTime - remaining;
thumbViewState = ViewStates.Contracting;
break;
case ViewStates.Contracting:
// Continue contraction animation.
// Detect finish condition.
if (gameTime.TotalGameTime > thumbAnimationStart + thumbAnimationDuration)
{
thumbViewState = ViewStates.Minimized;
}
break;
}
}
else
{
// Scrollbar is Selected.
switch (thumbViewState)
{
case ViewStates.Minimized:
// Begin expansion animation.
thumbAnimationStart = gameTime.TotalGameTime;
thumbViewState = ViewStates.Expanding;
break;
case ViewStates.Contracting:
// Reverse the animation.
// Adjust the animationStart time so that the time remaining
// is equal the time the animation has run in the opposing direction.
TimeSpan remaining = thumbAnimationStart + thumbAnimationDuration - gameTime.TotalGameTime;
thumbAnimationStart = gameTime.TotalGameTime - remaining;
thumbViewState = ViewStates.Expanding;
break;
case ViewStates.Expanding:
// Continue expansion animation.
// Detect finish condition.
if (gameTime.TotalGameTime > thumbAnimationStart + thumbAnimationDuration)
{
thumbViewState = ViewStates.Maximized;
}
break;
}
}
// Hide and reveal animation.
if (scrollBarViewState == ViewStates.Contracting)
{
alphaValue = MathHelper.Clamp(alphaValue - alphaStep, 0f, 1f);
translate -= translateStep;
if (alphaValue == 0f)
{
// Animation complete.
scrollBarViewState = ViewStates.Minimized;
Visible = false;
Active = false;
}
}
if (scrollBarViewState == ViewStates.Expanding)
{
alphaValue = MathHelper.Clamp(alphaValue + alphaStep, 0f, 1f);
translate += translateStep;
if (alphaValue == 1f)
{
// Animation complete.
scrollBarViewState = ViewStates.Maximized;
translate = 0f;
Visible = true;
Active = true;
}
}
// Set the spriteColor for hide and reveal animation.
Vector4 color = spriteColor.ToVector4();
color.W = alphaValue;
spriteColor = new Color(color);
base.Update(gameTime);
}
/// <summary>
/// Sets if the edit ccontent of the card is visible or not.
/// </summary>
/// <param name="state">The ViewState that specifies if things are shown or not.</param>
private void SetContentVisible(ViewStates state)
{
foreach (var item in new List<View>() { cardFood, cardInterest, cardLanguage })
{
// When hidded, these are set to gone, otherwise there will be a lot of empty space at the buttom of the card.
item.FindViewById<ImageView>(Resource.Id.confirm_input).Visibility = state.Equals(ViewStates.Visible) ? ViewStates.Visible : ViewStates.Gone;
item.FindViewById<TextInputLayout>(Resource.Id.info_input_container).Visibility = state.Equals(ViewStates.Visible) ? ViewStates.Visible : ViewStates.Gone;
// Get each entry in the card, and toggle the remove button.
var content = item.FindViewById<LinearLayout>(Resource.Id.profile_card_entry);
var childCount = content.ChildCount;
for (int i = 0; i < childCount; i++)
{
var entry = content.GetChildAt(i);
var icon = entry.FindViewById<ImageView>(Resource.Id.profile_card_entry_remove);
icon.Visibility = state;
}
}
}
void ResetSelectedPanel()
{
if(target) {
target.transform.position = oldPosition;
target.transform.rotation = oldRotation;
if(tempHighlightTexture)
Destroy(tempHighlightTexture);
}
viewState = ViewStates.LOOKING;
viewingThePhoto = false;
timer = timeToFocus;
RadialTimer.SetActive(false);
StopCoroutine(co);
co = ChoosePicture();
}
/// <summary>
/// Updates the ListBox state.
/// </summary>
/// <param name="gameTime"></param>
public override void Update(GameTime gameTime)
{
if (minMaxButton.GotClicked)
{
// Prohibit state change if scrollbar is selected.
if (ScrollBar.StateMachine.SelectedPart == ScrollBarPart.None)
{
// Button will be unresponsive until animation completes.
if (listBoxViewState == ViewStates.Minimized)
{
Maximize();
minMaxButton.DefaultImage = minimizeDefault;
minMaxButton.PressedImage = minimizeHit;
}
if (listBoxViewState == ViewStates.Maximized)
{
Minimize();
minMaxButton.DefaultImage = maximizeDefault;
minMaxButton.PressedImage = maximizeHit;
}
}
}
foreach (ListBoxStateMachineItem item in listBoxStateMachine.Items)
{
ListBoxItem listBoxItem = item as ListBoxItem;
listBoxItem.Update();
}
if (listBoxViewState == ViewStates.Expanding)
{
float width = Width + widthStep;
if (width >= targetWidth)
{
// Expand animation complete.
width = targetWidth;
listBoxViewState = ViewStates.Maximized;
ScrollBar.Visible = false;
ScrollBar.Enabled = false;
ScrollBar.Active = false;
}
float viewportStart = listBoxStateMachine.HorizontalViewportStartPosition - viewportStep;
viewportStart = MathHelper.Clamp(viewportStart, 0f, 1 - listBoxStateMachine.HorizontalViewportSize);
listBoxStateMachine.HorizontalViewportStartPosition = viewportStart;
Width = width;
listBoxStateMachine.NumberOfPixelsInHorizontalAxis = Convert.ToInt32(Width);
}
if (listBoxViewState == ViewStates.Contracting)
{
float width = Width - widthStep;
if (width <= targetWidth)
{
// Contract animation complete.
width = targetWidth;
listBoxViewState = ViewStates.Minimized;
ScrollBar.Visible = true;
ScrollBar.Active = true;
}
Width = width;
listBoxStateMachine.NumberOfPixelsInHorizontalAxis = Convert.ToInt32(Width);
if (listBoxViewState == ViewStates.Minimized)
{
listBoxStateMachine.HorizontalViewportStartPosition = viewPortStartPosition;
}
else
{
float viewportStart = listBoxStateMachine.HorizontalViewportStartPosition + viewportStep;
viewportStart = MathHelper.Clamp(viewportStart, 0f, 1 - listBoxStateMachine.HorizontalViewportSize);
listBoxStateMachine.HorizontalViewportStartPosition = viewportStart;
}
}
listBoxStateMachine.HorizontalElasticity =
pixelsOfElasticity / listBoxStateMachine.NumberOfPixelsInHorizontalAxis;
base.Update(gameTime);
}
private void ChangeButtonsVisibility(ViewStates visibility)
{
int lastItem = this.HideFirstItemOnCollapse
? this.Buttons.Count
: this.Buttons.Count - 1;
for (int i = 0; i < lastItem; i++)
{
View button = this.Buttons[i];
button.Visibility = visibility;
}
}
public LayoutViewModel(SelectedMaterialProvider selectedMaterialProvider, IFontService fontService,
ViewStates viewState)
: base(selectedMaterialProvider, fontService, viewState)
{
}
/// <summary>
/// Begin scroll bar hide animation.
/// </summary>
/// <param name="animationSteps">Number of update cycles the animation should take.</param>
public void Hide(float animationSteps)
{
System.Diagnostics.Debug.Assert(scrollBarViewState == ViewStates.Maximized || scrollBarViewState == ViewStates.Expanding);
alphaStep = 1f / animationSteps;
translateStep = scrollBarBackground.Height / animationSteps;
scrollBarViewState = ViewStates.Contracting;
}
static bool ConvertBack(ViewStates viewState)
{
return viewState == ViewStates.Visible;
}
void SetVisibility(ViewStates state)
{
mSwitchTexture.Visibility = state;
mMenuContainer.Visibility = state;
}
/// <summary>
/// Begin scroll bar reveal animation.
/// </summary>
/// <param name="animationSteps">Number of update cycles the animation should take.</param>
public void Reveal(float animationSteps)
{
alphaStep = 1f / animationSteps;
translateStep = scrollBarBackground.Height / animationSteps;
scrollBarViewState = ViewStates.Expanding;
Visible = true;
}
private void UpdateUIVisibilityState(ViewStates state)
{
var views = new List<View>
{
FindViewById<ToggleButton>(Resource.Id.toggleButton),
FindViewById<ImageButton>(Resource.Id.btn_settings),
FindViewById<TextView>(Resource.Id.txt_time_left),
FindViewById<TextView>(Resource.Id.txt_time_mins),
FindViewById<TextView>(Resource.Id.City_Name),
FindViewById<TextView>(Resource.Id.txt_time_hrs),
FindViewById<TextView>(Resource.Id.NextSunRiseLabel)
};
views.ForEach(v => v.Visibility = state);
}
public VisiblityObserver(View view, IEventListener handler)
: base(view, true)
{
_listenerRef = handler.ToWeakWrapper();
_oldValue = view.Visibility;
}
protected override void OnWindowVisibilityChanged (ViewStates visibility)
{
// When we become visible, we show our navigation elements briefly
// before hiding them.
SetNavVisibility (true);
Handler.PostDelayed (mNavHider, 2000);
}
protected override void OnGlobalLayoutChangedInternal(View view)
{
ViewStates visibility = view.Visibility;
if (_oldValue == visibility)
return;
_oldValue = visibility;
if (!_listenerRef.EventListener.TryHandle(view, EventArgs.Empty))
Dispose();
}
void SetProgressBarVisibility(ViewStates visibility) {
FindViewById(Resource.Id.progress).Visibility = visibility;
}
public static ViewStates VisibilityInverterConverter(ViewStates arg)
{
return arg == ViewStates.Visible ? ViewStates.Gone : ViewStates.Visible;
}
