示例#1
0
        private void ExportSlides_Click(object sender, RoutedEventArgs e)
        {
            e.Handled = true;
            if (Library.SelectedItems.Count == 0)
            {
                return;
            }

            var dialog = new System.Windows.Forms.FolderBrowserDialog();

            System.Windows.Forms.DialogResult result = dialog.ShowDialog();
            if (result != System.Windows.Forms.DialogResult.OK)
            {
                return;
            }

            string temp = dialog.SelectedPath;

            foreach (SlmVignette slide in Library.SelectedItems)
            {
                string      st           = System.IO.Path.Combine(new string [] { temp, slide.Name + ".png" });
                SlideObject sld          = _slideLib._Slides [slide.Name];
                BitmapImage renderBitmap = sld.Export();

                PngBitmapEncoder encoder = new PngBitmapEncoder();
                encoder.Frames.Add(BitmapFrame.Create(renderBitmap));                    // Push the rendered bitmap to it
                using (FileStream outStream = new FileStream(st, FileMode.Create)) {     // Create a file stream for saving image
                    encoder.Save(outStream);
                }
            }
        }
示例#2
0
        private void Library_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            e.Handled = true;
            if (Library.SelectedItems.Count != 1)
            {
                preview.Slide = null;
                propertyGrid.SelectedObject = new SlmProperties(null, _slideLib);
                return;
            }

            SlmVignette item = Library.SelectedItem as SlmVignette;
            SlideObject sld  = _slideLib._Slides [item.Name];

            preview.Slide = sld;
            propertyGrid.SelectedObject = new SlmProperties(sld, _slideLib);
        }
 private void SaveSlideObject()
 {
     if (_savedSlideObject == null)
     {
         _savedSlideObject = new SlideObject();
     }
     if (_currentSlide == null)
     {
         return;
     }
     if (_savedSlideObject.SourceSlideMasters.ContainsKey(SlideSettingsManager.Instance.SlideSettings.Format))
     {
         _savedSlideObject.SourceSlideMasters[SlideSettingsManager.Instance.SlideSettings.Format] = _currentSlide.Name;
     }
     else
     {
         _savedSlideObject.SourceSlideMasters.Add(SlideSettingsManager.Instance.SlideSettings.Format, _currentSlide.Name);
     }
 }
示例#4
0
 public SlmProperties(SlideObject sld, SlideLibObject slb = null)
     : base()
 {
     if (slb != null)
     {
         slbName     = slb._Name;
         slbFileName = slb._FileName;
         slbSize     = slb._FileLength;
         slbNbSlide  = slb._Slides.Count;
         slbVersion  = "1.0";
     }
     if (sld != null)
     {
         sldName     = sld._Name;
         sldFileName = sld._FileName;
         sldSize     = sld._FileLength;
         sldWidth    = (int)sld._Size.Width;
         sldHeight   = (int)sld._Size.Height;
         sldVersion  = sld._Version.ToString("#.0#");
     }
 }
示例#5
0
 public void LoadData(SlideObject slideObject)
 {
     _slideObject = slideObject;
     ApplySavedState();
 }
示例#6
0
        public override void LoadData()
        {
            _allowToSave = false;

            switch (CustomTabInfo.TopTabType)
            {
            case ShiftTopTabType.Cover:
                switch (CustomTabInfo.TabType)
                {
                case ShiftChildTabType.U:
                    _sourceSlideObject = SlideContainer.EditedContent.CoverState.TabU.Slide;
                    break;

                case ShiftChildTabType.V:
                    _sourceSlideObject = SlideContainer.EditedContent.CoverState.TabV.Slide;
                    break;

                case ShiftChildTabType.W:
                    _sourceSlideObject = SlideContainer.EditedContent.CoverState.TabW.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("Shift tab type is not defined");
                }
                slidesEditContainer.LoadData(_sourceSlideObject);
                break;

            case ShiftTopTabType.Intro:
                switch (CustomTabInfo.TabType)
                {
                case ShiftChildTabType.U:
                    _sourceSlideObject = SlideContainer.EditedContent.IntroState.TabU.Slide;
                    break;

                case ShiftChildTabType.V:
                    _sourceSlideObject = SlideContainer.EditedContent.IntroState.TabV.Slide;
                    break;

                case ShiftChildTabType.W:
                    _sourceSlideObject = SlideContainer.EditedContent.IntroState.TabW.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("Shift tab type is not defined");
                }
                slidesEditContainer.LoadData(_sourceSlideObject);
                break;

            case ShiftTopTabType.Agenda:
                switch (CustomTabInfo.TabType)
                {
                case ShiftChildTabType.U:
                    _sourceSlideObject = SlideContainer.EditedContent.AgendaState.TabU.Slide;
                    break;

                case ShiftChildTabType.V:
                    _sourceSlideObject = SlideContainer.EditedContent.AgendaState.TabV.Slide;
                    break;

                case ShiftChildTabType.W:
                    _sourceSlideObject = SlideContainer.EditedContent.AgendaState.TabW.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("Shift tab type is not defined");
                }
                slidesEditContainer.LoadData(_sourceSlideObject);
                break;

            case ShiftTopTabType.Goals:
                switch (CustomTabInfo.TabType)
                {
                case ShiftChildTabType.U:
                    _sourceSlideObject = SlideContainer.EditedContent.GoalsState.TabU.Slide;
                    break;

                case ShiftChildTabType.V:
                    _sourceSlideObject = SlideContainer.EditedContent.GoalsState.TabV.Slide;
                    break;

                case ShiftChildTabType.W:
                    _sourceSlideObject = SlideContainer.EditedContent.GoalsState.TabW.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("Shift tab type is not defined");
                }
                slidesEditContainer.LoadData(_sourceSlideObject);
                break;

            case ShiftTopTabType.Market:
                switch (CustomTabInfo.TabType)
                {
                case ShiftChildTabType.U:
                    _sourceSlideObject = SlideContainer.EditedContent.MarketState.TabU.Slide;
                    break;

                case ShiftChildTabType.V:
                    _sourceSlideObject = SlideContainer.EditedContent.MarketState.TabV.Slide;
                    break;

                case ShiftChildTabType.W:
                    _sourceSlideObject = SlideContainer.EditedContent.MarketState.TabW.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("Shift tab type is not defined");
                }
                slidesEditContainer.LoadData(_sourceSlideObject);
                break;

            case ShiftTopTabType.Partnership:
                switch (CustomTabInfo.TabType)
                {
                case ShiftChildTabType.U:
                    _sourceSlideObject = SlideContainer.EditedContent.PartnershipState.TabU.Slide;
                    break;

                case ShiftChildTabType.V:
                    _sourceSlideObject = SlideContainer.EditedContent.PartnershipState.TabV.Slide;
                    break;

                case ShiftChildTabType.W:
                    _sourceSlideObject = SlideContainer.EditedContent.PartnershipState.TabW.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("Shift tab type is not defined");
                }
                slidesEditContainer.LoadData(_sourceSlideObject);
                break;

            case ShiftTopTabType.NeedsSolutions:
                switch (CustomTabInfo.TabType)
                {
                case ShiftChildTabType.U:
                    _sourceSlideObject = SlideContainer.EditedContent.NeedsSolutionsState.TabU.Slide;
                    break;

                case ShiftChildTabType.V:
                    _sourceSlideObject = SlideContainer.EditedContent.NeedsSolutionsState.TabV.Slide;
                    break;

                case ShiftChildTabType.W:
                    _sourceSlideObject = SlideContainer.EditedContent.NeedsSolutionsState.TabW.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("Shift tab type is not defined");
                }
                slidesEditContainer.LoadData(_sourceSlideObject);
                break;

            case ShiftTopTabType.CBC:
                switch (CustomTabInfo.TabType)
                {
                case ShiftChildTabType.U:
                    _sourceSlideObject = SlideContainer.EditedContent.CBCState.TabU.Slide;
                    break;

                case ShiftChildTabType.V:
                    _sourceSlideObject = SlideContainer.EditedContent.CBCState.TabV.Slide;
                    break;

                case ShiftChildTabType.W:
                    _sourceSlideObject = SlideContainer.EditedContent.CBCState.TabW.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("Shift tab type is not defined");
                }
                slidesEditContainer.LoadData(_sourceSlideObject);
                break;

            case ShiftTopTabType.IntegratedSolution:
                switch (CustomTabInfo.TabType)
                {
                case ShiftChildTabType.U:
                    _sourceSlideObject = SlideContainer.EditedContent.IntegratedSolutionState.TabU.Slide;
                    break;

                case ShiftChildTabType.V:
                    _sourceSlideObject = SlideContainer.EditedContent.IntegratedSolutionState.TabV.Slide;
                    break;

                case ShiftChildTabType.W:
                    _sourceSlideObject = SlideContainer.EditedContent.IntegratedSolutionState.TabW.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("Shift tab type is not defined");
                }
                slidesEditContainer.LoadData(_sourceSlideObject);
                break;

            case ShiftTopTabType.Approach:
                switch (CustomTabInfo.TabType)
                {
                case ShiftChildTabType.U:
                    _sourceSlideObject = SlideContainer.EditedContent.ApproachState.TabU.Slide;
                    break;

                case ShiftChildTabType.V:
                    _sourceSlideObject = SlideContainer.EditedContent.ApproachState.TabV.Slide;
                    break;

                case ShiftChildTabType.W:
                    _sourceSlideObject = SlideContainer.EditedContent.ApproachState.TabW.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("Shift tab type is not defined");
                }
                slidesEditContainer.LoadData(_sourceSlideObject);
                break;

            default:
                _sourceSlideObject = new SlideObject();
                slidesEditContainer.LoadData(_sourceSlideObject);
                slidesEditContainer.SaveData();
                break;
            }

            _allowToSave = true;
        }
 public SlidesTabState()
 {
     Slide = new SlideObject();
 }
示例#8
0
        private ObservableCollection <SlmVignette> MergeAndGenerateBadges(string [] files)
        {
            Point pt = Library.PointToScreen(new Point(0, 0));

            _margins = new Thickness(pt.X, pt.Y, pt.X + Library.ActualWidth, pt.Y + Library.ActualHeight);

            _waitThread = new Thread(this.RunWaitThread);
            _waitThread.IsBackground = true;
            _waitThread.SetApartmentState(ApartmentState.STA);
            _waitThread.Start();
            Thread.Sleep(0);

            ObservableCollection <SlmVignette> newItems = new ObservableCollection <SlmVignette> ();
            ObservableCollection <SlmVignette> items    = new ObservableCollection <SlmVignette> ();

            if (Library.ItemsSource != null)
            {
                items = new ObservableCollection <SlmVignette> ((IEnumerable <SlmVignette>)Library.ItemsSource);
            }
            foreach (string fileName in files)
            {
                if (SlideLibObject.IsSlideLibrary(fileName))
                {
                    SlideLibObject slb = new SlideLibObject(fileName);
                    //_slideLib._Slides =_slideLib._Slides.Concat (slb._Slides).GroupBy (d => d.Key)
                    //	.ToDictionary (d => d.Key, d => d.First ().Value) ;
                    foreach (KeyValuePair <string, SlideObject> slide in slb._Slides)
                    {
                        string name = slide.Key;
                        if (_slideLib._Slides.ContainsKey(slide.Key))
                        {
                            for (int i = 0;; i++)
                            {
                                string st = name + i;
                                if (!_slideLib._Slides.ContainsKey(st))
                                {
                                    name = st;
                                    break;
                                }
                            }
                        }
                        _slideLib._Slides.Add(name, slide.Value);

                        SlmVignette badge = new SlmVignette()
                        {
                            Name  = name,
                            Type  = slide.Value._Size.Width + "x" + slide.Value._Size.Height,
                            Image = slide.Value.Export(70, 70)
                        };
                        items.Add(badge);
                        newItems.Add(badge);
                    }
                    _dirty = true;
                }
                if (SlideObject.IsSlide(fileName) && !_slideLib._Slides.ContainsKey(System.IO.Path.GetFileNameWithoutExtension(fileName)))
                {
                    SlideObject sld = new SlideObject(fileName);
                    sld._Name = System.IO.Path.GetFileNameWithoutExtension(fileName);
                    _slideLib._Slides.Add(sld._Name, sld);
                    _dirty = true;

                    SlmVignette badge = new SlmVignette()
                    {
                        Name  = sld._Name,
                        Type  = sld._Size.Width + "x" + sld._Size.Height,
                        Image = sld.Export(70, 70)
                    };
                    items.Add(badge);
                    newItems.Add(badge);
                }
                Thread.Sleep(0);
            }

            Library.ItemsSource = items;
            Library.Items.Refresh();

            Thread.Sleep(200);
            while (_waitDialog == null)
            {
                Thread.Sleep(100);
            }
            _waitDialog.Dispatcher.BeginInvoke(DispatcherPriority.Normal, (Action)(() => {
                _waitDialog.Close();
            }));
            if (_waitThread.IsAlive)
            {
                _waitThread.Abort();
            }

            return(newItems);
        }
        public override void LoadData()
        {
            _allowToSave = false;

            _savedSlideObject = null;

            switch (CustomTabInfo.TopTabType)
            {
            case StarTopTabType.Cover:
                switch (CustomTabInfo.TabType)
                {
                case StarChildTabType.K:
                    _savedSlideObject = SlideContainer.EditedContent.CoverState.TabK.Slide;
                    break;

                case StarChildTabType.L:
                    _savedSlideObject = SlideContainer.EditedContent.CoverState.TabL.Slide;
                    break;

                case StarChildTabType.M:
                    _savedSlideObject = SlideContainer.EditedContent.CoverState.TabM.Slide;
                    break;

                case StarChildTabType.N:
                    _savedSlideObject = SlideContainer.EditedContent.CoverState.TabN.Slide;
                    break;

                case StarChildTabType.O:
                    _savedSlideObject = SlideContainer.EditedContent.CoverState.TabO.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("StarApp tab type is not defined");
                }
                break;

            case StarTopTabType.CNA:
                switch (CustomTabInfo.TabType)
                {
                case StarChildTabType.K:
                    _savedSlideObject = SlideContainer.EditedContent.CNAState.TabK.Slide;
                    break;

                case StarChildTabType.L:
                    _savedSlideObject = SlideContainer.EditedContent.CNAState.TabL.Slide;
                    break;

                case StarChildTabType.M:
                    _savedSlideObject = SlideContainer.EditedContent.CNAState.TabM.Slide;
                    break;

                case StarChildTabType.N:
                    _savedSlideObject = SlideContainer.EditedContent.CNAState.TabN.Slide;
                    break;

                case StarChildTabType.O:
                    _savedSlideObject = SlideContainer.EditedContent.CNAState.TabO.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("StarApp tab type is not defined");
                }
                break;

            case StarTopTabType.Fishing:
                switch (CustomTabInfo.TabType)
                {
                case StarChildTabType.K:
                    _savedSlideObject = SlideContainer.EditedContent.FishingState.TabK.Slide;
                    break;

                case StarChildTabType.L:
                    _savedSlideObject = SlideContainer.EditedContent.FishingState.TabL.Slide;
                    break;

                case StarChildTabType.M:
                    _savedSlideObject = SlideContainer.EditedContent.FishingState.TabM.Slide;
                    break;

                case StarChildTabType.N:
                    _savedSlideObject = SlideContainer.EditedContent.FishingState.TabN.Slide;
                    break;

                case StarChildTabType.O:
                    _savedSlideObject = SlideContainer.EditedContent.FishingState.TabO.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("StarApp tab type is not defined");
                }
                break;

            case StarTopTabType.Customer:
                switch (CustomTabInfo.TabType)
                {
                case StarChildTabType.K:
                    _savedSlideObject = SlideContainer.EditedContent.CustomerState.TabK.Slide;
                    break;

                case StarChildTabType.L:
                    _savedSlideObject = SlideContainer.EditedContent.CustomerState.TabL.Slide;
                    break;

                case StarChildTabType.M:
                    _savedSlideObject = SlideContainer.EditedContent.CustomerState.TabM.Slide;
                    break;

                case StarChildTabType.N:
                    _savedSlideObject = SlideContainer.EditedContent.CustomerState.TabN.Slide;
                    break;

                case StarChildTabType.O:
                    _savedSlideObject = SlideContainer.EditedContent.CustomerState.TabO.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("StarApp tab type is not defined");
                }
                break;

            case StarTopTabType.Share:
                switch (CustomTabInfo.TabType)
                {
                case StarChildTabType.K:
                    _savedSlideObject = SlideContainer.EditedContent.ShareState.TabK.Slide;
                    break;

                case StarChildTabType.L:
                    _savedSlideObject = SlideContainer.EditedContent.ShareState.TabL.Slide;
                    break;

                case StarChildTabType.M:
                    _savedSlideObject = SlideContainer.EditedContent.ShareState.TabM.Slide;
                    break;

                case StarChildTabType.N:
                    _savedSlideObject = SlideContainer.EditedContent.ShareState.TabN.Slide;
                    break;

                case StarChildTabType.O:
                    _savedSlideObject = SlideContainer.EditedContent.ShareState.TabO.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("StarApp tab type is not defined");
                }
                break;

            case StarTopTabType.ROI:
                switch (CustomTabInfo.TabType)
                {
                case StarChildTabType.K:
                    _savedSlideObject = SlideContainer.EditedContent.ROIState.TabK.Slide;
                    break;

                case StarChildTabType.L:
                    _savedSlideObject = SlideContainer.EditedContent.ROIState.TabL.Slide;
                    break;

                case StarChildTabType.M:
                    _savedSlideObject = SlideContainer.EditedContent.ROIState.TabM.Slide;
                    break;

                case StarChildTabType.N:
                    _savedSlideObject = SlideContainer.EditedContent.ROIState.TabN.Slide;
                    break;

                case StarChildTabType.O:
                    _savedSlideObject = SlideContainer.EditedContent.ROIState.TabO.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("StarApp tab type is not defined");
                }
                break;

            case StarTopTabType.Market:
                switch (CustomTabInfo.TabType)
                {
                case StarChildTabType.K:
                    _savedSlideObject = SlideContainer.EditedContent.MarketState.TabK.Slide;
                    break;

                case StarChildTabType.L:
                    _savedSlideObject = SlideContainer.EditedContent.MarketState.TabL.Slide;
                    break;

                case StarChildTabType.M:
                    _savedSlideObject = SlideContainer.EditedContent.MarketState.TabM.Slide;
                    break;

                case StarChildTabType.N:
                    _savedSlideObject = SlideContainer.EditedContent.MarketState.TabN.Slide;
                    break;

                case StarChildTabType.O:
                    _savedSlideObject = SlideContainer.EditedContent.MarketState.TabO.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("StarApp tab type is not defined");
                }
                break;

            case StarTopTabType.Video:
                switch (CustomTabInfo.TabType)
                {
                case StarChildTabType.K:
                    _savedSlideObject = SlideContainer.EditedContent.VideoState.TabK.Slide;
                    break;

                case StarChildTabType.L:
                    _savedSlideObject = SlideContainer.EditedContent.VideoState.TabL.Slide;
                    break;

                case StarChildTabType.M:
                    _savedSlideObject = SlideContainer.EditedContent.VideoState.TabM.Slide;
                    break;

                case StarChildTabType.N:
                    _savedSlideObject = SlideContainer.EditedContent.VideoState.TabN.Slide;
                    break;

                case StarChildTabType.O:
                    _savedSlideObject = SlideContainer.EditedContent.VideoState.TabO.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("StarApp tab type is not defined");
                }
                break;

            case StarTopTabType.Audience:
                switch (CustomTabInfo.TabType)
                {
                case StarChildTabType.K:
                    _savedSlideObject = SlideContainer.EditedContent.AudienceState.TabK.Slide;
                    break;

                case StarChildTabType.L:
                    _savedSlideObject = SlideContainer.EditedContent.AudienceState.TabL.Slide;
                    break;

                case StarChildTabType.M:
                    _savedSlideObject = SlideContainer.EditedContent.AudienceState.TabM.Slide;
                    break;

                case StarChildTabType.N:
                    _savedSlideObject = SlideContainer.EditedContent.AudienceState.TabN.Slide;
                    break;

                case StarChildTabType.O:
                    _savedSlideObject = SlideContainer.EditedContent.AudienceState.TabO.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("StarApp tab type is not defined");
                }
                break;

            case StarTopTabType.Solution:
                switch (CustomTabInfo.TabType)
                {
                case StarChildTabType.K:
                    _savedSlideObject = SlideContainer.EditedContent.SolutionState.TabK.Slide;
                    break;

                case StarChildTabType.L:
                    _savedSlideObject = SlideContainer.EditedContent.SolutionState.TabL.Slide;
                    break;

                case StarChildTabType.M:
                    _savedSlideObject = SlideContainer.EditedContent.SolutionState.TabM.Slide;
                    break;

                case StarChildTabType.N:
                    _savedSlideObject = SlideContainer.EditedContent.SolutionState.TabN.Slide;
                    break;

                case StarChildTabType.O:
                    _savedSlideObject = SlideContainer.EditedContent.SolutionState.TabO.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("StarApp tab type is not defined");
                }
                break;

            case StarTopTabType.Closers:
                switch (CustomTabInfo.TabType)
                {
                case StarChildTabType.K:
                    _savedSlideObject = SlideContainer.EditedContent.ClosersState.TabK.Slide;
                    break;

                case StarChildTabType.L:
                    _savedSlideObject = SlideContainer.EditedContent.ClosersState.TabL.Slide;
                    break;

                case StarChildTabType.M:
                    _savedSlideObject = SlideContainer.EditedContent.ClosersState.TabM.Slide;
                    break;

                case StarChildTabType.N:
                    _savedSlideObject = SlideContainer.EditedContent.ClosersState.TabN.Slide;
                    break;

                case StarChildTabType.O:
                    _savedSlideObject = SlideContainer.EditedContent.ClosersState.TabO.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("StarApp tab type is not defined");
                }
                break;
            }

            if (_savedSlideObject != null && _savedSlideObject.SourceSlideMasters.ContainsKey(SlideSettingsManager.Instance.SlideSettings.Format))
            {
                var slideMasterName = _savedSlideObject.SourceSlideMasters[SlideSettingsManager.Instance.SlideSettings.Format];
                _currentSlide = CustomTabInfo.Slides.Slides.FirstOrDefault(slideMaster =>
                                                                           String.Equals(slideMaster.Name, slideMasterName, StringComparison.OrdinalIgnoreCase));
            }
            else
            {
                _currentSlide = CustomTabInfo.Slides.Slides.FirstOrDefault(slideMaster =>
                                                                           slideMaster.Format == SlideSettingsManager.Instance.SlideSettings.Format);
            }

            SaveSlideObject();

            UpdateDataControl();

            _allowToSave = true;
        }
示例#10
0
        public override void LoadData()
        {
            _allowToSave = false;

            _savedSlideObject = null;

            switch (CustomTabInfo.TopTabType)
            {
            case ShiftTopTabType.Cover:
                switch (CustomTabInfo.TabType)
                {
                case ShiftChildTabType.K:
                    _savedSlideObject = SlideContainer.EditedContent.CoverState.TabK.Slide;
                    break;

                case ShiftChildTabType.L:
                    _savedSlideObject = SlideContainer.EditedContent.CoverState.TabL.Slide;
                    break;

                case ShiftChildTabType.M:
                    _savedSlideObject = SlideContainer.EditedContent.CoverState.TabM.Slide;
                    break;

                case ShiftChildTabType.N:
                    _savedSlideObject = SlideContainer.EditedContent.CoverState.TabN.Slide;
                    break;

                case ShiftChildTabType.O:
                    _savedSlideObject = SlideContainer.EditedContent.CoverState.TabO.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("Shift tab type is not defined");
                }
                break;

            case ShiftTopTabType.Intro:
                switch (CustomTabInfo.TabType)
                {
                case ShiftChildTabType.K:
                    _savedSlideObject = SlideContainer.EditedContent.IntroState.TabK.Slide;
                    break;

                case ShiftChildTabType.L:
                    _savedSlideObject = SlideContainer.EditedContent.IntroState.TabL.Slide;
                    break;

                case ShiftChildTabType.M:
                    _savedSlideObject = SlideContainer.EditedContent.IntroState.TabM.Slide;
                    break;

                case ShiftChildTabType.N:
                    _savedSlideObject = SlideContainer.EditedContent.IntroState.TabN.Slide;
                    break;

                case ShiftChildTabType.O:
                    _savedSlideObject = SlideContainer.EditedContent.IntroState.TabO.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("Shift tab type is not defined");
                }
                break;

            case ShiftTopTabType.Agenda:
                switch (CustomTabInfo.TabType)
                {
                case ShiftChildTabType.K:
                    _savedSlideObject = SlideContainer.EditedContent.AgendaState.TabK.Slide;
                    break;

                case ShiftChildTabType.L:
                    _savedSlideObject = SlideContainer.EditedContent.AgendaState.TabL.Slide;
                    break;

                case ShiftChildTabType.M:
                    _savedSlideObject = SlideContainer.EditedContent.AgendaState.TabM.Slide;
                    break;

                case ShiftChildTabType.N:
                    _savedSlideObject = SlideContainer.EditedContent.AgendaState.TabN.Slide;
                    break;

                case ShiftChildTabType.O:
                    _savedSlideObject = SlideContainer.EditedContent.AgendaState.TabO.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("Shift tab type is not defined");
                }
                break;

            case ShiftTopTabType.Goals:
                switch (CustomTabInfo.TabType)
                {
                case ShiftChildTabType.K:
                    _savedSlideObject = SlideContainer.EditedContent.GoalsState.TabK.Slide;
                    break;

                case ShiftChildTabType.L:
                    _savedSlideObject = SlideContainer.EditedContent.GoalsState.TabL.Slide;
                    break;

                case ShiftChildTabType.M:
                    _savedSlideObject = SlideContainer.EditedContent.GoalsState.TabM.Slide;
                    break;

                case ShiftChildTabType.N:
                    _savedSlideObject = SlideContainer.EditedContent.GoalsState.TabN.Slide;
                    break;

                case ShiftChildTabType.O:
                    _savedSlideObject = SlideContainer.EditedContent.GoalsState.TabO.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("Shift tab type is not defined");
                }
                break;

            case ShiftTopTabType.Market:
                switch (CustomTabInfo.TabType)
                {
                case ShiftChildTabType.K:
                    _savedSlideObject = SlideContainer.EditedContent.MarketState.TabK.Slide;
                    break;

                case ShiftChildTabType.L:
                    _savedSlideObject = SlideContainer.EditedContent.MarketState.TabL.Slide;
                    break;

                case ShiftChildTabType.M:
                    _savedSlideObject = SlideContainer.EditedContent.MarketState.TabM.Slide;
                    break;

                case ShiftChildTabType.N:
                    _savedSlideObject = SlideContainer.EditedContent.MarketState.TabN.Slide;
                    break;

                case ShiftChildTabType.O:
                    _savedSlideObject = SlideContainer.EditedContent.MarketState.TabO.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("Shift tab type is not defined");
                }
                break;

            case ShiftTopTabType.Partnership:
                switch (CustomTabInfo.TabType)
                {
                case ShiftChildTabType.K:
                    _savedSlideObject = SlideContainer.EditedContent.PartnershipState.TabK.Slide;
                    break;

                case ShiftChildTabType.L:
                    _savedSlideObject = SlideContainer.EditedContent.PartnershipState.TabL.Slide;
                    break;

                case ShiftChildTabType.M:
                    _savedSlideObject = SlideContainer.EditedContent.PartnershipState.TabM.Slide;
                    break;

                case ShiftChildTabType.N:
                    _savedSlideObject = SlideContainer.EditedContent.PartnershipState.TabN.Slide;
                    break;

                case ShiftChildTabType.O:
                    _savedSlideObject = SlideContainer.EditedContent.PartnershipState.TabO.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("Shift tab type is not defined");
                }
                break;

            case ShiftTopTabType.NeedsSolutions:
                switch (CustomTabInfo.TabType)
                {
                case ShiftChildTabType.K:
                    _savedSlideObject = SlideContainer.EditedContent.NeedsSolutionsState.TabK.Slide;
                    break;

                case ShiftChildTabType.L:
                    _savedSlideObject = SlideContainer.EditedContent.NeedsSolutionsState.TabL.Slide;
                    break;

                case ShiftChildTabType.M:
                    _savedSlideObject = SlideContainer.EditedContent.NeedsSolutionsState.TabM.Slide;
                    break;

                case ShiftChildTabType.N:
                    _savedSlideObject = SlideContainer.EditedContent.NeedsSolutionsState.TabN.Slide;
                    break;

                case ShiftChildTabType.O:
                    _savedSlideObject = SlideContainer.EditedContent.NeedsSolutionsState.TabO.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("Shift tab type is not defined");
                }
                break;

            case ShiftTopTabType.CBC:
                switch (CustomTabInfo.TabType)
                {
                case ShiftChildTabType.K:
                    _savedSlideObject = SlideContainer.EditedContent.CBCState.TabK.Slide;
                    break;

                case ShiftChildTabType.L:
                    _savedSlideObject = SlideContainer.EditedContent.CBCState.TabL.Slide;
                    break;

                case ShiftChildTabType.M:
                    _savedSlideObject = SlideContainer.EditedContent.CBCState.TabM.Slide;
                    break;

                case ShiftChildTabType.N:
                    _savedSlideObject = SlideContainer.EditedContent.CBCState.TabN.Slide;
                    break;

                case ShiftChildTabType.O:
                    _savedSlideObject = SlideContainer.EditedContent.CBCState.TabO.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("Shift tab type is not defined");
                }
                break;

            case ShiftTopTabType.IntegratedSolution:
                switch (CustomTabInfo.TabType)
                {
                case ShiftChildTabType.K:
                    _savedSlideObject = SlideContainer.EditedContent.IntegratedSolutionState.TabK.Slide;
                    break;

                case ShiftChildTabType.L:
                    _savedSlideObject = SlideContainer.EditedContent.IntegratedSolutionState.TabL.Slide;
                    break;

                case ShiftChildTabType.M:
                    _savedSlideObject = SlideContainer.EditedContent.IntegratedSolutionState.TabM.Slide;
                    break;

                case ShiftChildTabType.N:
                    _savedSlideObject = SlideContainer.EditedContent.IntegratedSolutionState.TabN.Slide;
                    break;

                case ShiftChildTabType.O:
                    _savedSlideObject = SlideContainer.EditedContent.IntegratedSolutionState.TabO.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("Shift tab type is not defined");
                }
                break;

            case ShiftTopTabType.Approach:
                switch (CustomTabInfo.TabType)
                {
                case ShiftChildTabType.K:
                    _savedSlideObject = SlideContainer.EditedContent.ApproachState.TabK.Slide;
                    break;

                case ShiftChildTabType.L:
                    _savedSlideObject = SlideContainer.EditedContent.ApproachState.TabL.Slide;
                    break;

                case ShiftChildTabType.M:
                    _savedSlideObject = SlideContainer.EditedContent.ApproachState.TabM.Slide;
                    break;

                case ShiftChildTabType.N:
                    _savedSlideObject = SlideContainer.EditedContent.ApproachState.TabN.Slide;
                    break;

                case ShiftChildTabType.O:
                    _savedSlideObject = SlideContainer.EditedContent.ApproachState.TabO.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("Shift tab type is not defined");
                }
                break;

            case ShiftTopTabType.ROI:
                switch (CustomTabInfo.TabType)
                {
                case ShiftChildTabType.K:
                    _savedSlideObject = SlideContainer.EditedContent.ROIState.TabK.Slide;
                    break;

                case ShiftChildTabType.L:
                    _savedSlideObject = SlideContainer.EditedContent.ROIState.TabL.Slide;
                    break;

                case ShiftChildTabType.M:
                    _savedSlideObject = SlideContainer.EditedContent.ROIState.TabM.Slide;
                    break;

                case ShiftChildTabType.N:
                    _savedSlideObject = SlideContainer.EditedContent.ROIState.TabN.Slide;
                    break;

                case ShiftChildTabType.O:
                    _savedSlideObject = SlideContainer.EditedContent.ROIState.TabO.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("Shift tab type is not defined");
                }
                break;
            }

            if (_savedSlideObject != null && _savedSlideObject.SourceSlideMasters.ContainsKey(SlideSettingsManager.Instance.SlideSettings.Format))
            {
                var slideMasterName = _savedSlideObject.SourceSlideMasters[SlideSettingsManager.Instance.SlideSettings.Format];
                _currentSlide = CustomTabInfo.Slides.Slides.FirstOrDefault(slideMaster =>
                                                                           String.Equals(slideMaster.Name, slideMasterName, StringComparison.OrdinalIgnoreCase));
            }
            else
            {
                _currentSlide = CustomTabInfo.Slides.Slides.FirstOrDefault(slideMaster =>
                                                                           slideMaster.Format == SlideSettingsManager.Instance.SlideSettings.Format);
            }

            SaveSlideObject();

            UpdateDataControl();

            _allowToSave = true;
        }
示例#11
0
        public override void LoadData()
        {
            _allowToSave = false;

            switch (CustomTabInfo.TopTabType)
            {
            case StarTopTabType.Cover:
                switch (CustomTabInfo.TabType)
                {
                case StarChildTabType.U:
                    _sourceSlideObject = SlideContainer.EditedContent.CoverState.TabU.Slide;
                    break;

                case StarChildTabType.V:
                    _sourceSlideObject = SlideContainer.EditedContent.CoverState.TabV.Slide;
                    break;

                case StarChildTabType.W:
                    _sourceSlideObject = SlideContainer.EditedContent.CoverState.TabW.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("Star tab type is not defined");
                }
                break;

            case StarTopTabType.CNA:
                switch (CustomTabInfo.TabType)
                {
                case StarChildTabType.U:
                    _sourceSlideObject = SlideContainer.EditedContent.CNAState.TabU.Slide;
                    break;

                case StarChildTabType.V:
                    _sourceSlideObject = SlideContainer.EditedContent.CNAState.TabV.Slide;
                    break;

                case StarChildTabType.W:
                    _sourceSlideObject = SlideContainer.EditedContent.CNAState.TabW.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("Star tab type is not defined");
                }
                break;

            case StarTopTabType.Fishing:
                switch (CustomTabInfo.TabType)
                {
                case StarChildTabType.U:
                    _sourceSlideObject = SlideContainer.EditedContent.FishingState.TabU.Slide;
                    break;

                case StarChildTabType.V:
                    _sourceSlideObject = SlideContainer.EditedContent.FishingState.TabV.Slide;
                    break;

                case StarChildTabType.W:
                    _sourceSlideObject = SlideContainer.EditedContent.FishingState.TabW.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("Star tab type is not defined");
                }
                break;

            case StarTopTabType.Customer:
                switch (CustomTabInfo.TabType)
                {
                case StarChildTabType.U:
                    _sourceSlideObject = SlideContainer.EditedContent.CustomerState.TabU.Slide;
                    break;

                case StarChildTabType.V:
                    _sourceSlideObject = SlideContainer.EditedContent.CustomerState.TabV.Slide;
                    break;

                case StarChildTabType.W:
                    _sourceSlideObject = SlideContainer.EditedContent.CustomerState.TabW.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("Star tab type is not defined");
                }
                break;

            case StarTopTabType.Share:
                switch (CustomTabInfo.TabType)
                {
                case StarChildTabType.U:
                    _sourceSlideObject = SlideContainer.EditedContent.ShareState.TabU.Slide;
                    break;

                case StarChildTabType.V:
                    _sourceSlideObject = SlideContainer.EditedContent.ShareState.TabV.Slide;
                    break;

                case StarChildTabType.W:
                    _sourceSlideObject = SlideContainer.EditedContent.ShareState.TabW.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("Star tab type is not defined");
                }
                break;

            case StarTopTabType.ROI:
                switch (CustomTabInfo.TabType)
                {
                case StarChildTabType.U:
                    _sourceSlideObject = SlideContainer.EditedContent.ROIState.TabU.Slide;
                    break;

                case StarChildTabType.V:
                    _sourceSlideObject = SlideContainer.EditedContent.ROIState.TabV.Slide;
                    break;

                case StarChildTabType.W:
                    _sourceSlideObject = SlideContainer.EditedContent.ROIState.TabW.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("Star tab type is not defined");
                }
                break;

            case StarTopTabType.Market:
                switch (CustomTabInfo.TabType)
                {
                case StarChildTabType.U:
                    _sourceSlideObject = SlideContainer.EditedContent.MarketState.TabU.Slide;
                    break;

                case StarChildTabType.V:
                    _sourceSlideObject = SlideContainer.EditedContent.MarketState.TabV.Slide;
                    break;

                case StarChildTabType.W:
                    _sourceSlideObject = SlideContainer.EditedContent.MarketState.TabW.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("Star tab type is not defined");
                }
                break;

            case StarTopTabType.Video:
                switch (CustomTabInfo.TabType)
                {
                case StarChildTabType.U:
                    _sourceSlideObject = SlideContainer.EditedContent.VideoState.TabU.Slide;
                    break;

                case StarChildTabType.V:
                    _sourceSlideObject = SlideContainer.EditedContent.VideoState.TabV.Slide;
                    break;

                case StarChildTabType.W:
                    _sourceSlideObject = SlideContainer.EditedContent.VideoState.TabW.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("Star tab type is not defined");
                }
                break;

            case StarTopTabType.Audience:
                switch (CustomTabInfo.TabType)
                {
                case StarChildTabType.U:
                    _sourceSlideObject = SlideContainer.EditedContent.AudienceState.TabU.Slide;
                    break;

                case StarChildTabType.V:
                    _sourceSlideObject = SlideContainer.EditedContent.AudienceState.TabV.Slide;
                    break;

                case StarChildTabType.W:
                    _sourceSlideObject = SlideContainer.EditedContent.AudienceState.TabW.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("Star tab type is not defined");
                }
                break;

            case StarTopTabType.Solution:
                switch (CustomTabInfo.TabType)
                {
                case StarChildTabType.U:
                    _sourceSlideObject = SlideContainer.EditedContent.SolutionState.TabU.Slide;
                    break;

                case StarChildTabType.V:
                    _sourceSlideObject = SlideContainer.EditedContent.SolutionState.TabV.Slide;
                    break;

                case StarChildTabType.W:
                    _sourceSlideObject = SlideContainer.EditedContent.SolutionState.TabW.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("Star tab type is not defined");
                }
                break;

            case StarTopTabType.Closers:
                switch (CustomTabInfo.TabType)
                {
                case StarChildTabType.U:
                    _sourceSlideObject = SlideContainer.EditedContent.ClosersState.TabU.Slide;
                    break;

                case StarChildTabType.V:
                    _sourceSlideObject = SlideContainer.EditedContent.ClosersState.TabV.Slide;
                    break;

                case StarChildTabType.W:
                    _sourceSlideObject = SlideContainer.EditedContent.ClosersState.TabW.Slide;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("Star tab type is not defined");
                }
                break;

            default:
                throw new ArgumentOutOfRangeException("Star tab type is not defined");
            }

            slidesEditContainer.LoadData(_sourceSlideObject);
            Application.DoEvents();

            _allowToSave = true;
        }