private void ImageHelperOnImageChanged(object sender, MvxValueEventArgs <UIImage> mvxValueEventArgs) { if (KittenImageView != null && mvxValueEventArgs.Value != null) { KittenImageView.Image = mvxValueEventArgs.Value; } }
protected override void HandleSaveInstanceStateCalled(object sender, MvxValueEventArgs <Bundle> bundleArgs) { // it is guarannted that SaveInstanceState call will be executed before OnStop (thus before Fragment detach) // it is safe to assume that Fragment has activity attached if (!FragmentView.GetType().IsFragmentCacheable(Fragment.Activity.GetType())) { return; } var mvxBundle = FragmentView.CreateSaveStateBundle(); if (mvxBundle != null) { IMvxSavedStateConverter converter; if (!Mvx.TryResolve(out converter)) { MvxTrace.Warning("Saved state converter not available - saving state will be hard"); } else { converter.Write(bundleArgs.Value, mvxBundle); } } var cache = Mvx.Resolve <IMvxMultipleViewModelCache>(); cache.Cache(FragmentView.ViewModel, FragmentView.UniqueImmutableCacheTag); }
protected override void HandleSaveInstanceStateCalled(object sender, MvxValueEventArgs <Bundle> bundleArgs) { if (!FragmentView.GetType().IsOwnedViewModelFragment()) { return; } var mvxBundle = FragmentView.CreateSaveStateBundle(); if (mvxBundle != null) { IMvxSavedStateConverter converter; if (!Mvx.TryResolve(out converter)) { MvxTrace.Warning("Saved state converter not available - saving state will be hard"); } else { converter.Write(bundleArgs.Value, mvxBundle); } } var cache = Mvx.Resolve <IMvxMultipleViewModelCache>(); cache.Cache(FragmentView.ViewModel); }
private void MoveJoystickOnNewCoordinates(object sender, MvxValueEventArgs<CartesianPositionParameters> eventArgs) { if (ViewModel != null) { ViewModel.Movement.RollCommand.Execute(eventArgs.Value); } }
private void MoveJoystickOnNewCoordinates(object sender, MvxValueEventArgs <CartesianPositionParameters> eventArgs) { if (ViewModel != null) { ViewModel.Movement.RollCommand.Execute(eventArgs.Value); } }
private void OnWillAppearCalled(object sender, MvxValueEventArgs <bool> e) { var topController = sender as IMvxEventSourceViewController; topController.ViewDidDisappearCalled -= OnDidDisappearCalled; topController.ViewWillAppearCalled -= OnWillAppearCalled; }
private void SpeechListenerOnHeard(object sender, MvxValueEventArgs <PossibleWord> e) { if (!SpeechIsOn) { return; } MethodInfo methodInfo; if (!_speechMethods.TryGetValue(e.Value.Word, out methodInfo)) { return; } methodInfo.Invoke(this, new object[0]); this.InvokeOnMainThread(() => { HeardSoFar.Insert(0, e.Value.Word); while (HeardSoFar.Count > 100) { HeardSoFar.RemoveAt(HeardSoFar.Count - 1); } }); }
protected override void HandleCreateCalled(object sender, MvxValueEventArgs <Bundle> bundleArgs) { FragmentView.EnsureSetupInitialized(); // Create is called after Fragment is attached to Activity // it's safe to assume that Fragment has activity if (!FragmentView.GetType().IsFragmentCacheable(Fragment.Activity.GetType())) { return; } FragmentView.RegisterFragmentViewToCacheIfNeeded(Fragment.Activity.GetType()); Bundle bundle = null; MvxViewModelRequest request = null; if (bundleArgs?.Value != null) { // saved state bundle = bundleArgs.Value; } else { var fragment = FragmentView as Fragment; if (fragment?.Arguments != null) { bundle = fragment.Arguments; var json = bundle.GetString("__mvxViewModelRequest"); if (!string.IsNullOrEmpty(json)) { IMvxNavigationSerializer serializer; if (!Mvx.TryResolve(out serializer)) { MvxTrace.Warning( "Navigation Serializer not available, deserializing ViewModel Request will be hard"); } else { request = serializer.Serializer.DeserializeObject <MvxViewModelRequest>(json); } } } } IMvxSavedStateConverter converter; if (!Mvx.TryResolve(out converter)) { MvxTrace.Warning("Saved state converter not available - saving state will be hard"); } else { if (bundle != null) { var mvxBundle = converter.Read(bundle); FragmentView.OnCreate(mvxBundle, request); } } }
private void ImageHelperOnImageChanged(object sender, MvxValueEventArgs <Bitmap> mvxValueEventArgs) { using (var h = new Handler(Looper.MainLooper)) h.Post(() => { this.SetImageBitmap(mvxValueEventArgs.Value); }); }
private void ImageHelperOnImageChanged(object sender, MvxValueEventArgs<UIImage> mvxValueEventArgs) { InvokeOnMainThread(() => { if (ImageView != null) ImageView.Image = mvxValueEventArgs.Value; }); }
// Note - this is public because we use it in weak referenced situations public virtual void ImageHelperOnImageChanged( object sender, MvxValueEventArgs <UIImage> mvxValueEventArgs) { var helper = (IMvxResizedImageHelper <UIImage>)sender; _imageSetAction(mvxValueEventArgs.Value, helper.CurrentImageState); }
private void ImageHelperOnImageChanged(object sender, MvxValueEventArgs <UIImage> mvxValueEventArgs) { var imageView = _imageView(); if (imageView != null && mvxValueEventArgs.Value != null) { imageView.Image = mvxValueEventArgs.Value; } }
public void HandleSelectedSalepointMarkers(object sender, MvxValueEventArgs <int?> e) { ClearOrdersMarkers(); if (e.Value.HasValue) { SetOrdersMarkers(); } }
private void CurrentImageRequestOnError(object sender, MvxValueEventArgs <Exception> mvxExceptionEventArgs) { if (sender != _currentImageRequest) { return; } HttpImageErrorSeen(); ClearCurrentHttpImageRequest(); }
private void ImageHelperOnImageChanged(object sender, MvxValueEventArgs <UIImage> mvxValueEventArgs) { InvokeOnMainThread(() => { if (ImageView != null) { ImageView.Image = mvxValueEventArgs.Value; } }); }
protected override void EventSourceOnActivityResultCalled(object sender, MvxValueEventArgs <MvxActivityResultParameters> args) { var sink = Mvx.IoCProvider.Resolve <IMvxIntentResultSink>(); var resultParameters = args.Value; var intentResult = new MvxIntentResultEventArgs(resultParameters.RequestCode, resultParameters.ResultCode, resultParameters.Data); sink.OnResult(intentResult); }
private void OnMapDelegateDetailsClick(object sender, MvxValueEventArgs <IMapAnnotation> e) { var venueAnnotation = e.Value as VenueAnnotation; if (venueAnnotation != null && ViewModel.NavigateVenueCommand.CanExecute(venueAnnotation.Venue)) { ViewModel.NavigateVenueCommand.Execute(venueAnnotation.Venue); } }
protected override void HandleCreateCalled(object sender, MvxValueEventArgs<Bundle> bundleArgs) { FragmentView.EnsureSetupInitialized(); // Create is called after Fragment is attached to Activity // it's safe to assume that Fragment has activity if (!FragmentView.GetType().IsFragmentCacheable(Fragment.Activity.GetType())) return; FragmentView.RegisterFragmentViewToCacheIfNeeded(Fragment.Activity.GetType()); Bundle bundle = null; MvxViewModelRequest request = null; if (bundleArgs?.Value != null) { // saved state bundle = bundleArgs.Value; } else { var fragment = FragmentView as Fragment; if (fragment?.Arguments != null) { bundle = fragment.Arguments; var json = bundle.GetString("__mvxViewModelRequest"); if (!string.IsNullOrEmpty(json)) { IMvxNavigationSerializer serializer; if (!Mvx.TryResolve(out serializer)) { MvxTrace.Warning( "Navigation Serializer not available, deserializing ViewModel Request will be hard"); } else { request = serializer.Serializer.DeserializeObject<MvxViewModelRequest>(json); } } } } IMvxSavedStateConverter converter; if (!Mvx.TryResolve(out converter)) { MvxTrace.Warning("Saved state converter not available - saving state will be hard"); } else { if (bundle != null) { var mvxBundle = converter.Read(bundle); FragmentView.OnCreate(mvxBundle, request); } } }
protected override void HandleCreateCalled(object sender, MvxValueEventArgs <Bundle> bundleArgs) { FragmentView.EnsureSetupInitialized(); if (!FragmentView.GetType().IsOwnedViewModelFragment()) { return; } Bundle bundle = null; MvxViewModelRequest request = null; if (bundleArgs != null && bundleArgs.Value != null) { // saved state bundle = bundleArgs.Value; } else { var fragment = FragmentView as Fragment; if (fragment != null && fragment.Arguments != null) { bundle = fragment.Arguments; var json = bundle.GetString("__mvxViewModelRequest"); if (!string.IsNullOrEmpty(json)) { IMvxNavigationSerializer serializer; if (!Mvx.TryResolve(out serializer)) { MvxTrace.Warning( "Navigation Serializer not available, deserializing ViewModel Request will be hard"); } else { request = serializer.Serializer.DeserializeObject <MvxViewModelRequest>(json); } } } } IMvxSavedStateConverter converter; if (!Mvx.TryResolve(out converter)) { MvxTrace.Warning("Saved state converter not available - saving state will be hard"); } else { if (bundle != null) { var mvxBundle = converter.Read(bundle); FragmentView.OnCreate(mvxBundle, request); } } }
private void OnServiceStatus(object sender, MvxValueEventArgs <StatusInteraction> args) { UIAlertView alert = new UIAlertView() { Title = args.Value.Title, Message = args.Value.Message }; alert.AddButton("OK"); alert.Show(); }
private void CurrentImageRequestOnComplete(object sender, MvxValueEventArgs <T> mvxValueEventArgs) { if (sender != _currentImageRequest) { return; } var image = mvxValueEventArgs.Value; NewImageAvailable(image); ClearCurrentHttpImageRequest(); }
private void CurrentImageRequestOnError(object sender, MvxValueEventArgs <Exception> mvxExceptionEventArgs) { if (sender != _currentImageRequest) { return; } Mvx.Trace("failed to download image {0} : {1}", _currentImageRequest.Url, mvxExceptionEventArgs.Value.ToLongString()); HttpImageErrorSeen(); ClearCurrentHttpImageRequest(); }
private void OnDidDisappearCalled(object sender, MvxValueEventArgs <bool> e) { var controller = sender as IUnbindable; if (controller != null) { UnbindCycle(ref controller); } sender.DisposeIfDisposable(); sender = null; }
private void OnZoomToVenue(object sender, MvxValueEventArgs <Venue> e) { EndSearch(); var annotation = GetAnnotationByVenue(ViewModel.SelectedVenueOnMap); var shiftedCoord = annotation.Coordinate; shiftedCoord.Latitude += 0.0008f; VenuesMapView.SetRegion( MapUtil.CoordinateRegionForCoordinates(shiftedCoord), true); }
private void OnActivityResult(object sender, MvxValueEventArgs <MvxActivityResultParameters> args) { switch (args.Value.RequestCode) { case FileSelectedRequestCode: if (args.Value.Data != null) { var inputStream = OpenStreamForUri(args.Value.Data.Data); _streamWaitingTaskCompletionSource.SetResult(inputStream); } break; } }
protected override void NewIntent(MvxValueEventArgs <Intent> e) { string id = GetIdFromTag(e.Value); var tagAsNdefMessage = e.Value.GetParcelableArrayExtra(NfcAdapter.ExtraNdefMessages); if (tagAsNdefMessage != null) { var tag = tagAsNdefMessage[0] as NdefMessage; byte[] message = tag.ToByteArray(); var ndefMessage = NdefLibrary.Ndef.NdefMessage.FromByteArray(message); NewMessage(id, ndefMessage); } }
protected override void NewIntent(MvxValueEventArgs<Intent> e) { string id=GetIdFromTag(e.Value); var tagAsNdefMessage = e.Value.GetParcelableArrayExtra(NfcAdapter.ExtraNdefMessages); if (tagAsNdefMessage != null) { var tag = tagAsNdefMessage[0] as NdefMessage; byte[] message = tag.ToByteArray(); var ndefMessage = NdefLibrary.Ndef.NdefMessage.FromByteArray(message); NewMessage(id,ndefMessage); } }
protected override void EventSourceOnStartActivityForResultCalled(object sender, MvxValueEventArgs <MvxStartActivityForResultParameters> MvxValueEventArgs) { var requestCode = MvxValueEventArgs.Value.RequestCode; switch (requestCode) { case (int)MvxIntentRequestCode.PickFromFile: MvxLog.Instance.Warn("Warning - activity request code may clash with Mvx code for {0}", (MvxIntentRequestCode)requestCode); break; } }
protected override void EventSourceOnSaveInstanceStateCalled(object sender, MvxValueEventArgs <Bundle> bundleArgs) { var converter = Mvx.Resolve <IMvxSavedStateConverter>(); var mvxBundle = AndroidView.CreateSaveStateBundle(); if (mvxBundle != null) { converter.Write(bundleArgs.Value, mvxBundle); } var cache = Mvx.Resolve <IMvxSingleViewModelCache>(); cache.Cache(AndroidView.ViewModel, bundleArgs.Value); }
protected override void HandleCreateCalled(object sender, MvxValueEventArgs<Bundle> bundleArgs) { FragmentView.EnsureSetupInitialized(); if (!FragmentView.GetType().IsOwnedViewModelFragment()) return; Bundle bundle = null; MvxViewModelRequest request = null; if (bundleArgs != null && bundleArgs.Value != null) { // saved state bundle = bundleArgs.Value; } else { var fragment = FragmentView as Fragment; if (fragment != null && fragment.Arguments != null) { bundle = fragment.Arguments; var json = bundle.GetString("__mvxViewModelRequest"); if (!string.IsNullOrEmpty(json)) { IMvxNavigationSerializer serializer; if (!Mvx.TryResolve(out serializer)) { MvxTrace.Warning( "Navigation Serializer not available, deserializing ViewModel Request will be hard"); } else { request = serializer.Serializer.DeserializeObject<MvxViewModelRequest>(json); } } } } IMvxSavedStateConverter converter; if (!Mvx.TryResolve(out converter)) { MvxTrace.Warning("Saved state converter not available - saving state will be hard"); } else { if (bundle != null) { var mvxBundle = converter.Read(bundle); FragmentView.OnCreate(mvxBundle, request); } } }
protected override void EventSourceOnStartActivityForResultCalled( object sender, MvxValueEventArgs <MvxStartActivityForResultParameters> eventArgs) { var requestCode = eventArgs.Value.RequestCode; switch (requestCode) { case (int)MvxIntentRequestCode.PickFromFile: MvxLogHost.GetLog <MvxActivityAdapter>()?.Log(LogLevel.Warning, "Warning - activity request code may clash with Mvx code for {requestCode}", (MvxIntentRequestCode)requestCode); break; } }
private void OnRefreshCompleted(object sender, MvxValueEventArgs <bool> e) { var pullToRefresh = ListView.RefreshControl != null && ListView.RefreshControl.Refreshing; if (pullToRefresh) { ListView.RefreshControl.EndRefreshing(); } UpdateMessageState(Localization.NoContentAvailable, !e.Value); OnViewModelRefreshed(e.Value, pullToRefresh); }
protected override void EventSourceOnStartActivityForResultCalled(object sender, MvxValueEventArgs <MvxStartActivityForResultParameters> MvxValueEventArgs) { var requestCode = MvxValueEventArgs.Value.RequestCode; switch (requestCode) { case (int)MvxIntentRequestCode.PickFromFile: MvxTrace.Warning("Warning - activity request code may clash with Mvx code for {0}", (MvxIntentRequestCode)requestCode); break; } }
private void AccelerometerOnReadingAvailable(object sender, MvxValueEventArgs <Reading> mvxValueEventArgs) { // note that the switchover between Y and X here is deliberate! // and that we invert Y // this may need tweaking platform-by-platform // and phone by phone - and maybe at runtime too! var parameters = new CartesianPositionParameters { X = MakeSafe(-mvxValueEventArgs.Value.Y), Y = MakeSafe(mvxValueEventArgs.Value.X), }; DoRoll(parameters); }
private void AccelerometerOnReadingAvailable(object sender, MvxValueEventArgs<Reading> mvxValueEventArgs) { // note that the switchover between Y and X here is deliberate! // and that we invert Y // this may need tweaking platform-by-platform // and phone by phone - and maybe at runtime too! var parameters = new CartesianPositionParameters { X = MakeSafe(-mvxValueEventArgs.Value.Y), Y = MakeSafe(mvxValueEventArgs.Value.X), }; DoRoll(parameters); }
private void OnInteractionRequested(object sender, MvxValueEventArgs <bool> eventArgs) { Activity.RunOnUiThread(() => { if (eventArgs.Value) { _btnUpload.setProgress(100); _btnUpload.Enabled = false; } else { _btnUpload.setProgress(-1); } }); }
private void PermissionChanged(object sender, MvxValueEventArgs <MvxLocationPermission> e) { Console.WriteLine("Permission changed: " + e.Value.ToString()); if (e.Value != MvxLocationPermission.Denied) { return; } TaskCompletionSource <MvxCoordinates> source; lock (_lock) { source = _taskSource; _taskSource = null; } source?.SetException(new Exception(MvxLocationErrorCode.PermissionDenied.ToString())); }
protected override void EventSourceOnSaveInstanceStateCalled(object sender, MvxValueEventArgs<Bundle> bundleArgs) { var mvxBundle = AndroidView.CreateSaveStateBundle(); if (mvxBundle != null) { IMvxSavedStateConverter converter; if (!Mvx.TryResolve<IMvxSavedStateConverter>(out converter)) { MvxTrace.Warning("Saved state converter not available - saving state will be hard"); } else { converter.Write(bundleArgs.Value, mvxBundle); } } var cache = Mvx.Resolve<IMvxSingleViewModelCache>(); cache.Cache(AndroidView.ViewModel, bundleArgs.Value); }
private void SpeechListenerOnHeard(object sender, MvxValueEventArgs<PossibleWord> e) { if (!SpeechIsOn) return; MethodInfo methodInfo; if (!_speechMethods.TryGetValue(e.Value.Word, out methodInfo)) return; methodInfo.Invoke(this, new object[0]); this.InvokeOnMainThread(() => { HeardSoFar.Insert(0, e.Value.Word); while (HeardSoFar.Count > 100) { HeardSoFar.RemoveAt(HeardSoFar.Count - 1); } }); }
private void OpenPopupMenu(object sender, MvxValueEventArgs<PopupMenuRequest> request) { this.CleanAll(); _currentRequest = request.Value; var view = base.Target as View; if (view == null) return; _menu = new PopupMenu(view.Context, view); int menuId = Menu.First + 1; foreach (var item in _currentRequest.LstPopupItem) { _menu.Menu.Add(0, menuId, item.Order, item.Title); menuId++; } _menu.MenuItemClick += MenuItemClick; _menu.DismissEvent += MenuDismissEvent; _menu.Show(); }
private void ImageHelperOnImageChanged(object sender, MvxValueEventArgs<Bitmap> mvxValueEventArgs) { SetImageBitmap(mvxValueEventArgs.Value); }
protected override void EventSourceOnCreateCalled(object sender, MvxValueEventArgs<Bundle> eventArgs) { this.AndroidView.OnViewCreate(eventArgs.Value); }
public override void HandleAwakeCalled(object sender, MvxValueEventArgs<NSObject> e) { this.WatchOSView.OnViewCreate(); base.HandleAwakeCalled(sender, e); }
protected virtual void EventSourceOnActivityResultCalled(object sender, MvxValueEventArgs<MvxActivityResultParameters> MvxValueEventArgs) { }
protected virtual void EventSourceOnNewIntentCalled(object sender, MvxValueEventArgs<Intent> MvxValueEventArgs) { }
protected virtual void HandleAttachCalled(object sender, MvxValueEventArgs<Activity> e) { }
protected virtual void HandleCreateCalled(object sender, MvxValueEventArgs<Bundle> e) { }
protected virtual void HandleSaveInstanceStateCalled(object sender, MvxValueEventArgs<Bundle> e) { }
protected override void EventSourceOnCreateWillBeCalled(object sender, MvxValueEventArgs<Bundle> MvxValueEventArgs) { this.BindingContext.ClearAllBindings(); base.EventSourceOnCreateWillBeCalled(sender, MvxValueEventArgs); }
protected override void HandleSaveInstanceStateCalled(object sender, MvxValueEventArgs<Bundle> bundleArgs) { if (!FragmentView.GetType().IsOwnedViewModelFragment()) return; var mvxBundle = FragmentView.CreateSaveStateBundle(); if (mvxBundle != null) { IMvxSavedStateConverter converter; if (!Mvx.TryResolve(out converter)) { MvxTrace.Warning("Saved state converter not available - saving state will be hard"); } else { converter.Write(bundleArgs.Value, mvxBundle); } } var cache = Mvx.Resolve<IMvxMultipleViewModelCache>(); cache.Cache(FragmentView.ViewModel); }
protected override void HandleCreateViewCalled(object sender, MvxValueEventArgs<MvxCreateViewParameters> args) { FragmentView.EnsureBindingContextIsSet(args.Value.Inflater); }
private void ImageHelperOnImageChanged(object sender, MvxValueEventArgs<UIImage> mvxValueEventArgs) { if (ImageView != null) ImageView.Image = mvxValueEventArgs.Value; }
protected virtual void EventSourceOnSaveInstanceStateCalled(object sender, MvxValueEventArgs<Bundle> mvxValueEventArgs) { }
protected virtual void HandleCreateViewCalled(object sender, MvxValueEventArgs<MvxCreateViewParameters> mvxValueEventArgs) { }
protected virtual void EventSourceOnCreateCalled(object sender, MvxValueEventArgs<Bundle> MvxValueEventArgs) { }
protected override void EventSourceOnActivityResultCalled(object sender, MvxValueEventArgs<MvxActivityResultParameters> args) { var sink = Mvx.Resolve<IMvxIntentResultSink>(); var resultParameters = args.Value; var intentResult = new MvxIntentResultEventArgs(resultParameters.RequestCode, resultParameters.ResultCode, resultParameters.Data); sink.OnResult(intentResult); }
private void ImageHelperOnImageChanged(object sender, MvxValueEventArgs<UIImage> mvxValueEventArgs) { Image = mvxValueEventArgs.Value; }
protected override void EventSourceOnNewIntentCalled(object sender, MvxValueEventArgs<Intent> MvxValueEventArgs) { this.AndroidView.OnViewNewIntent(); }
private void ImageHelperOnImageChanged(object sender, MvxValueEventArgs<Bitmap> mvxValueEventArgs) { using (var h = new Handler(Looper.MainLooper)) h.Post(() => { this.SetImageBitmap(mvxValueEventArgs.Value); }); }
public virtual void HandleViewDidAppearCalled(object sender, MvxValueEventArgs<bool> e) { }