示例#1
0
        /// <summary>
        /// Listens to the Wizard part's notifications
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void WizardPart_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            IWizardPart wizardPart = sender as IWizardPart;

            if (WizardPart == null || wizardPart.WizardPage != WizardPart.WizardPage)
            {
                return;
            }

            // MigrateWorkitem Part's State notification
            if (String.CompareOrdinal(e.PropertyName, SummaryPart.MigrationStateTag) == 0)
            {
                SummaryPart summaryPart = sender as SummaryPart;
                if (summaryPart.MigrationState != WizardActionState.InProgress)
                {
                    IsMigrationCompleted = true;
                }
            }
            // Wizard Part's CanConfirm Notification
            else if (String.CompareOrdinal(e.PropertyName, BaseWizardPart.CanConfirmPropertyName) == 0 ||
                     String.CompareOrdinal(e.PropertyName, BaseWizardPart.CanNextPropertyName) == 0)
            {
                CanShowOtherWizardParts();
            }
        }
示例#2
0
        /// <summary>
        /// Initializes the Wiard State  to Wizard Part hash Table
        /// </summary>
        private void InitializeWizardHashTable()
        {
            m_wizardPageHashTable = new Dictionary <WizardPage, IWizardPart>();
            m_wizardPageHashTable.Add(WizardPage.Welcome, new WelcomePart());
            m_wizardPageHashTable.Add(WizardPage.SelectDataSource, new SelectDataSourcePart());
            m_wizardPageHashTable.Add(WizardPage.SelectDestinationServer, new SelectDestinationServerPart());
            m_wizardPageHashTable.Add(WizardPage.SettingsFile, new SettingsFilePart());
            m_wizardPageHashTable.Add(WizardPage.FieldsSelection, new FieldsSelectionPart());
            m_wizardPageHashTable.Add(WizardPage.FieldMapping, new FieldMappingPart());
            m_wizardPageHashTable.Add(WizardPage.DataMapping, new DataMappingPart());
            m_wizardPageHashTable.Add(WizardPage.Linking, new LinkingPart());
            m_wizardPageHashTable.Add(WizardPage.MiscSettings, new MiscSettingsPart());
            m_wizardPageHashTable.Add(WizardPage.ConfirmSettings, new ConfirmSettingsPart());
            m_wizardPageHashTable.Add(WizardPage.Summary, new SummaryPart());

            WizardParts = new ObservableCollection <IWizardPart>();
            foreach (WizardPage page in m_wizardPages)
            {
                IWizardPart part = m_wizardPageHashTable[page];
                part.PropertyChanged += new PropertyChangedEventHandler(WizardPart_PropertyChanged);

                if (page != WizardPage.Summary)
                {
                    WizardParts.Add(part);
                }
            }
        }
示例#3
0
        public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            IWizardPart part = value as IWizardPart;

            if (part == null)
            {
                return(null);
            }
            if (m_views.ContainsKey(part))
            {
                return(m_views[part]);
            }
            else
            {
                Visual visual = GetVisual(part);
                m_views.Add(part, visual);
                return(visual);
            }
        }
示例#4
0
        private Visual GetVisual(IWizardPart part)
        {
            WelcomePart welcomePart = part as WelcomePart;

            if (welcomePart != null)
            {
                return(new WelcomeView(welcomePart));
            }

            SelectDataSourcePart selectDataSourcePart = part as SelectDataSourcePart;

            if (selectDataSourcePart != null)
            {
                return(new SelectDataSourceView(selectDataSourcePart));
            }

            SelectDestinationServerPart selectDestinationServerPart = part as SelectDestinationServerPart;

            if (selectDestinationServerPart != null)
            {
                return(new SelectDestinationServerView(selectDestinationServerPart));
            }

            SettingsFilePart mappingsFilePart = part as SettingsFilePart;

            if (mappingsFilePart != null)
            {
                return(new SettingsFileView(mappingsFilePart));
            }

            FieldsSelectionPart fieldsSelectionPart = part as FieldsSelectionPart;

            if (fieldsSelectionPart != null)
            {
                return(new FieldsSelectionView(fieldsSelectionPart));
            }

            FieldMappingPart fieldMappingPart = part as FieldMappingPart;

            if (fieldMappingPart != null)
            {
                return(new FieldMappingView(fieldMappingPart));
            }

            DataMappingPart dataMappingPart = part as DataMappingPart;

            if (dataMappingPart != null)
            {
                return(new DataMappingView(dataMappingPart));
            }

            LinkingPart relationshipsMappingPart = part as LinkingPart;

            if (relationshipsMappingPart != null)
            {
                return(new LinkingView(relationshipsMappingPart));
            }

            MiscSettingsPart miscSettingsPart = part as MiscSettingsPart;

            if (miscSettingsPart != null)
            {
                return(new MiscSettingsView(miscSettingsPart));
            }

            ConfirmSettingsPart confirmSettingsPart = part as ConfirmSettingsPart;

            if (confirmSettingsPart != null)
            {
                return(new ConfirmSettingsView(confirmSettingsPart));
            }

            SummaryPart migrationProgressPart = part as SummaryPart;

            if (migrationProgressPart != null)
            {
                return(new SummaryView(migrationProgressPart));
            }

            throw new ArgumentException("Invalid Wizard Part");
        }
示例#5
0
        private void LoadWizardPartInBackgroundThread(object sender, DoWorkEventArgs e)
        {
            IsLoadingWizardPage = true;
            using (new AutoWaitCursor())
            {
                if (WizardPart == null)
                {
                    WizardPart = m_wizardPageHashTable[m_loadWizardPage];
                    WizardPart.Initialize(m_wizardInfo);
                }
                int newWizardPageIndex     = m_wizardPages.IndexOf(m_loadWizardPage);
                int currentWizardPageIndex = CurrentWizardIndex;
                if (newWizardPageIndex > CurrentWizardIndex)
                {
                    IWizardPart part = m_wizardPageHashTable[m_wizardPages[currentWizardPageIndex]];
                    while (currentWizardPageIndex < newWizardPageIndex)
                    {
                        if (!part.UpdateWizardPart())
                        {
                            break;
                        }
                        currentWizardPageIndex++;

                        part.IsActiveWizardPart = false;
                        part = m_wizardPageHashTable[m_wizardPages[currentWizardPageIndex]];
                        part.IsActiveWizardPart = true;

                        if (currentWizardPageIndex == newWizardPageIndex && part.CanInitialize)
                        {
                            WizardPart = part;
                        }

                        part.Initialize(m_wizardInfo);
                        if (!part.CanShow)
                        {
                            string warning = part.Warning;
                            currentWizardPageIndex--;
                            part         = m_wizardPageHashTable[m_wizardPages[currentWizardPageIndex]];
                            part.Warning = warning;
                            break;
                        }
                    }
                    WizardPart         = part;
                    WizardPart.Warning = WizardPart.Warning;
                    CanShowOtherWizardParts();
                }
                else
                {
                    WizardPart = m_wizardPageHashTable[m_loadWizardPage];
                }
            }
            WizardPart.CanNext = WizardPart.ValidatePartState();
            m_wizardPageHashTable[WizardPage.ConfirmSettings].Initialize(m_wizardInfo);
            WizardInfo.CanConfirm = m_wizardPageHashTable[WizardPage.ConfirmSettings].CanInitialize;
            DisableNavigationIfLastPage();

            NotifyPropertyChanged("IsSummaryPage");
            NotifyPropertyChanged("IsConfirmPage");
            NotifyPropertyChanged("IsConfirmVisible");

            IsLoadingWizardPage = false;
        }
示例#6
0
 /// <summary>
 /// Load Wizard Part
 /// </summary>
 /// <param name="part"></param>
 public void LoadWizardPart(IWizardPart part)
 {
     LoadWizardPart(part.WizardPage);
 }