/// <summary>
 /// Constructs a new instance of DataFormContentLoadEventArgs.
 /// </summary>
 /// <param name="content">The content that was loaded or will be loaded.</param>
 /// <param name="mode">The mode of the DataForm.</param>
 public DataFormContentLoadEventArgs(FrameworkElement content, DataFormMode mode)
 {
     this.Content = content;
     this.Mode = mode;
 }
Exemplo n.º 2
0
        /// <summary>
        /// Re-generates the UI if a template or direct content change requires it.
        /// </summary>
        /// <param name="changedTemplateMode">The mode for which template was changed, or null if the content was changed.</param>
        /// <param name="oldContent">The old Content value, or null in the case of a template change.</param>
        private void RegenerateUI(DataFormMode? changedTemplateMode, object oldContent)
        {
            if (this.CurrentItemType != null &&
                (this._currentlyUsedTemplate.Count == 0 || (this._currentlyUsedTemplate.ContainsKey(this.CurrentItemType) && this.ShouldRegenerateUI(changedTemplateMode))))
            {
                if (changedTemplateMode == null && this._contentPresenter.Content == oldContent && oldContent != null)
                {
                    this.RemoveContent(oldContent as FrameworkElement);
                }
                else if (this.Mode == DataFormMode.ReadOnly)
                {
                    this.RemoveContentForType(this.CurrentItemType, this._readOnlyContentsNew);
                    this.RemoveContentForType(this.CurrentItemType, this._readOnlyContentsOld);
                }
                else if (this.Mode == DataFormMode.Edit)
                {
                    this.RemoveContentForType(this.CurrentItemType, this._editContentsNew);
                    this.RemoveContentForType(this.CurrentItemType, this._editContentsOld);
                }
                else
                {
                    this.RemoveContentForType(this.CurrentItemType, this._addNewContentsNew);
                    this.RemoveContentForType(this.CurrentItemType, this._addNewContentsOld);
                }

                this.GenerateUI(false /* clearEntityErrors */);
            }

            SetAllCanPropertiesAndUpdate(this, true /* onlyUpdateStates */);
        }
Exemplo n.º 3
0
        /// <summary>
        /// Returns a value indicating whether or not the UI should be re-generated based on
        /// a changed template.
        /// </summary>
        /// <param name="changedTemplateMode">The mode for which template was changed, or null if the content was changed.</param>
        /// <returns>A value indicating whether or not the UI should be re-generated.</returns>
        private bool ShouldRegenerateUI(DataFormMode? changedTemplateMode)
        {
            Debug.Assert(this.CurrentItemType != null, "ShouldUpdateTemplate should never be called if the current item type is null.");

            // If the changed template was for the same mode as the current mode,
            // we know we should update the template.
            if (this.Mode == changedTemplateMode)
            {
                return true;
            }

            DataFormMode? currentlyUsedTemplateMode = this._currentlyUsedTemplate[this.CurrentItemType];
            if (currentlyUsedTemplateMode == null)
            {
                // We're currently using direct content, so we will re-generate the UI no matter what
                // template has changed (since every template takes precedence over the direct content).
                return true;
            }

            if (changedTemplateMode == null)
            {
                // We're using a template and the direct content has changed, so there's no need to update.
                return false;
            }

            // If the changed template was not for the same mode as the current mode,
            // then we should update the template if the mode for the currently used template
            // is after the mode for the changed template in the fallback list.
            if (this.Mode == DataFormMode.ReadOnly)
            {
                // If we're in read-only mode, the fallback mechanism is edit -> add-new.
                return
                    (currentlyUsedTemplateMode == DataFormMode.Edit && changedTemplateMode == DataFormMode.Edit) ||
                    currentlyUsedTemplateMode == DataFormMode.AddNew;
            }
            else if (this.Mode == DataFormMode.Edit)
            {
                // If we're in edit mode, the fallback mechanism is add-new -> read-only.
                return
                    (currentlyUsedTemplateMode == DataFormMode.AddNew && changedTemplateMode == DataFormMode.AddNew) ||
                    currentlyUsedTemplateMode == DataFormMode.ReadOnly;
            }
            else if (this.Mode == DataFormMode.AddNew)
            {
                // If we're in add-new mode, the fallback mechanism is edit -> read-only.
                return
                    (currentlyUsedTemplateMode == DataFormMode.Edit && changedTemplateMode == DataFormMode.Edit) ||
                    currentlyUsedTemplateMode == DataFormMode.ReadOnly;
            }

            return false;
        }
Exemplo n.º 4
0
 /// <summary>
 /// 'Add' button is hit
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 private void itemDataForm_AddingNewItem(object sender, DataFormAddingNewItemEventArgs e)
 {
     editMode = DataFormMode.AddNew;
 }
Exemplo n.º 5
0
 /// <summary>
 /// "Edit" button is hit
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 private void itemDataForm_BeginningEdit(object sender, System.ComponentModel.CancelEventArgs e)
 {
     editMode = DataFormMode.Edit;
 }
Exemplo n.º 6
0
 /// <summary>
 /// Constructs a new instance of DataFormContentLoadEventArgs.
 /// </summary>
 /// <param name="content">The content that was loaded or will be loaded.</param>
 /// <param name="mode">The mode of the DataForm.</param>
 public DataFormContentLoadEventArgs(FrameworkElement content, DataFormMode mode)
 {
     this.Content = content;
     this.Mode    = mode;
 }
 // Executes when the user navigates to this page.
 protected override void OnNavigatedTo(NavigationEventArgs e)
 {
     this.editMode       = DataFormMode.ReadOnly;
     this.ContentPageCtx = ModelProvider.Instance.GetContentPageContext(e.Uri.ToString());
     this.BeginUpdateEntireUI();
 }
        /// <summary>
        /// Thread body
        /// </summary>
        /// <param name="state"></param>
        private void StartWork(object state)
        {
            MediaView mediaView  = state as MediaView;
            media     savedMedia = null;
            media     theMedia   = new media();

            mediaView.Merge(theMedia, editMode);

            // Save to backend
            if (this.editMode == DataFormMode.Edit)
            {
                // Edit mode
                AutoResetEvent nextOneAutoResetEvent           = new AutoResetEvent(false);
                EventHandler <save_MediaCompletedEventArgs> h1 = (s, e) =>
                {
                    // TODO: handle error from server side
                    savedMedia = e.Result;
                    nextOneAutoResetEvent.Set();
                };
                Globals.WSClient.save_MediaCompleted += h1;
                Globals.WSClient.save_MediaAsync(theMedia);
                nextOneAutoResetEvent.WaitOne();
                Globals.WSClient.save_MediaCompleted -= h1;
            }
            else
            {
                //
                // Add new mode
                //

                // Get file content
                byte[] content = ShopproHelper.ReadFully(fileInfo.OpenRead());

                // Save to the backend
                AutoResetEvent nextOneAutoResetEvent = new AutoResetEvent(false);
                EventHandler <createNew_MediaCompletedEventArgs> h3 = (s, e) =>
                {
                    // TODO: handle error from server side
                    savedMedia = e.Result;
                    nextOneAutoResetEvent.Set();
                };
                Globals.WSClient.createNew_MediaCompleted += h3;
                Globals.WSClient.createNew_MediaAsync(theMedia, content);
                nextOneAutoResetEvent.WaitOne();
                Globals.WSClient.createNew_MediaCompleted -= h3;
            }

            // Check return result. If failure, savedCategory will be null
            if (savedMedia != null)
            {
                this.Dispatcher.BeginInvoke(delegate()
                {
                    mediaView.Restore(new MediaView(savedMedia));
                });
            }
            else
            {
                // Show error message
                ShopproHelper.ShowMessageWindow(this, "Error", "Fail to save this entry.", false);

                // Back to readonly mode
                this.Dispatcher.BeginInvoke(delegate()
                {
                    // Restore cached UI data
                    mediaView.CancelEdit();
                    this.mediaDataForm.CancelEdit();
                });
            }

            // No unsaved item
            this.editMode = DataFormMode.ReadOnly;
            this.fileInfo = null;

            // Hide busy indicator
            ShopproHelper.HideBusyIndicator(this);

            // Go to original page if necessary
            if (this.ContentPageCtx.GotoAddNewPage)
            {
                ShopproHelper.GoToContentPage(this, PageEnum.MediaListPage);
            }
        }