Ejemplo n.º 1
0
        protected override void OnBeforePerformingCommand(SwissAcademic.Controls.BeforePerformingCommandEventArgs e)
        {
            Project project = Program.ActiveProjectShell.Project;

            switch (e.Key)
            {
                #region Reference-based commands
            case "ParallelReportersParse":
            {
                List <Reference> listSelectedReferences = Program.ActiveProjectShell.PrimaryMainForm.GetSelectedReferences();
                e.Handled = true;
                ParallelReporterParser.ParseReporters(project, listSelectedReferences);
            }
            break;

            case "ShorthandChangeInParallelReporters":
            {
                e.Handled = true;
                ToolboxReference.ChangeShorthands();
            }
            break;
                #endregion

                #region ReferenceEditorUriLocationsPopupMenu

            case "CopyLocationPathToClipboard":
            {
                e.Handled = true;
                ToolboxReference.CopyLocationClipboard();
            }
            break;

                #endregion
            }
            base.OnBeforePerformingCommand(e);
        }
        protected override void OnBeforePerformingCommand(SwissAcademic.Controls.BeforePerformingCommandEventArgs e)
        {
            Project project = Program.ActiveProjectShell.Project;

            switch (e.Key)
            {
            case "GenerateShortTitle":
            {
                e.Handled = true;

                List <Reference> listSelectedReferences = Program.ActiveProjectShell.PrimaryMainForm.GetSelectedReferences();

                var filter = new ShortTitleGenerator();

                foreach (Reference reference in listSelectedReferences)
                {
                    reference.ShortTitle           = filter.GetFilterResult(reference, out bool handled);
                    reference.ShortTitleUpdateType = UpdateType.Automatic;
                }
            }
            break;
            }
            base.OnBeforePerformingCommand(e);
        }
Ejemplo n.º 3
0
        protected override void OnBeforePerformingCommand(SwissAcademic.Controls.BeforePerformingCommandEventArgs e)
        {
            switch (e.Key)
            {
                #region Annotation-based menus
            case "ImportComments":
            {
                e.Handled = true;
                Reference reference = Program.ActiveProjectShell.PrimaryMainForm.GetSelectedReferences().FirstOrDefault();
                AnnotationsImporter.AnnotationsImport(QuotationType.Comment);
            }
            break;

            case "ImportDirectQuotations":
            {
                e.Handled = true;
                Reference reference = Program.ActiveProjectShell.PrimaryMainForm.GetSelectedReferences().FirstOrDefault();
                AnnotationsImporter.AnnotationsImport(QuotationType.DirectQuotation);
            }
            break;

            case "ImportIndirectQuotations":
            {
                e.Handled = true;
                Reference reference = Program.ActiveProjectShell.PrimaryMainForm.GetSelectedReferences().FirstOrDefault();
                AnnotationsImporter.AnnotationsImport(QuotationType.IndirectQuotation);
            }
            break;

            case "ImportQuickReferences":
            {
                e.Handled = true;
                Reference reference = Program.ActiveProjectShell.PrimaryMainForm.GetSelectedReferences().FirstOrDefault();
                AnnotationsImporter.AnnotationsImport(QuotationType.QuickReference);
            }
            break;

            case "ImportSummaries":
            {
                e.Handled = true;
                Reference reference = Program.ActiveProjectShell.PrimaryMainForm.GetSelectedReferences().FirstOrDefault();
                AnnotationsImporter.AnnotationsImport(QuotationType.Summary);
            }
            break;

            case "MergeAnnotations":
            {
                e.Handled = true;
                AnnotationsAndQuotationsMerger.MergeAnnotations();
            }
            break;

            case "SimplifyAnnotations":
            {
                e.Handled = true;
                AnnotationSimplifier.SimplifyAnnotations();
            }
            break;

                #endregion
                #region Reference-based commands
            case "ExportAnnotations":
            {
                e.Handled = true;
                List <Reference> references = Program.ActiveProjectShell.PrimaryMainForm.GetSelectedReferences().ToList();
                AnnotationsExporter.ExportAnnotations(references);
            }
            break;

            case "ExportBookmarks":
            {
                e.Handled = true;
                List <Reference> references = Program.ActiveProjectShell.PrimaryMainForm.GetSelectedReferences().ToList();
                QuickReferenceBookmarkExporter.ExportBookmarks(references);
            }
            break;

            case "MoveAttachment":
            {
                e.Handled = true;
                LocationMover.MoveAttachment();
            }
            break;

                #endregion
                #region Quotations Pop-Up Menu
            case "CleanQuotationsText":
            {
                e.Handled = true;
                List <KnowledgeItem> quotations = Program.ActiveProjectShell.PrimaryMainForm.GetSelectedQuotations().ToList();
                QuotationTextCleaner.CleanQuotationsText(quotations);
            }
            break;

            case "ConvertDirectQuoteToRedHighlight":
            {
                e.Handled = true;
                List <KnowledgeItem> quotations = Program.ActiveProjectShell.PrimaryMainForm.GetSelectedQuotations().ToList();
                QuotationTypeConverter.ConvertDirectQuoteToRedHighlight(quotations);
            }
            break;

            case "CreateCommentOnQuotation":
            {
                e.Handled = true;
                List <KnowledgeItem> quotations = Program.ActiveProjectShell.PrimaryMainForm.GetSelectedQuotations().ToList();
                CommentCreator.CreateCommentOnQuotation(quotations);
            }
            break;

            case "CreateSummaryOnQuotations":
            {
                e.Handled = true;
                List <KnowledgeItem> quotations = Program.ActiveProjectShell.PrimaryMainForm.GetSelectedQuotations().ToList();
                SummaryCreator.CreatesummaryOnQuotations(quotations);
            }
            break;

            case "KnowledgeItemsSortInReference":
            {
                e.Handled = true;
                List <KnowledgeItem> quotations = Program.ActiveProjectShell.PrimaryMainForm.GetSelectedQuotations().ToList();
                QuotationsSorter.SortQuotations(quotations);
            }
            break;

            case "CommentAnnotation":
            {
                e.Handled = true;
                List <KnowledgeItem> quotations = Program.ActiveProjectShell.PrimaryMainForm.GetSelectedQuotations().ToList();
                CommentAnnotationCreator.CreateCommentAnnotation(quotations);
            }
            break;

            case "LinkQuotations":
            {
                e.Handled = true;
                List <KnowledgeItem> quotations = Program.ActiveProjectShell.PrimaryMainForm.GetSelectedQuotations().ToList();
                QuotationLinker.LinkQuotations(quotations);
            }
            break;

            case "PageAssignFromPositionInPDF":
            {
                e.Handled = true;
                List <KnowledgeItem> quotations = Program.ActiveProjectShell.PrimaryMainForm.GetSelectedQuotations().ToList();
                PageRangeFromPositionInPDFAssigner.AssignPageRangeFromPositionInPDF(quotations);
            }
            break;

            case "PageAssignFromPreviousQuotation":
            {
                e.Handled = true;
                List <KnowledgeItem> quotations = Program.ActiveProjectShell.PrimaryMainForm.GetSelectedQuotations().ToList();
                PageRangeFromPrecedingQuotationAssigner.AssignPageRangeFromPrecedingQuotation(quotations);
            }
            break;

            case "QuotationsMerge":
            {
                e.Handled = true;
                List <KnowledgeItem> quotations = Program.ActiveProjectShell.PrimaryMainForm.GetSelectedQuotations().ToList();
                AnnotationsAndQuotationsMerger.MergeQuotations(quotations);
            }
            break;

            case "QuickReferenceTitleCase":
            {
                e.Handled = true;
                List <KnowledgeItem> quotations = Program.ActiveProjectShell.PrimaryMainForm.GetSelectedQuotations().ToList();
                QuickReferenceTitleCaser.TitleCaseQuickReference(quotations);
            }
            break;

            case "ShowQuotationAndSetPageRangeManually":
            {
                e.Handled = true;
                List <KnowledgeItem> quotations = Program.ActiveProjectShell.PrimaryMainForm.GetSelectedQuotations().ToList();
                PageRangeManualAssigner.AssignPageRangeManuallyAfterShowingAnnotation();
            }
            break;
                #endregion
                #region ReferenceEditorUriLocationsPopupMenu

                #endregion
                #region KnowledgeOrganizerKnowledgeItemsContextMenu
            case "OpenKnowledgeItemAttachment":
            {
                e.Handled = true;

                MainForm mainForm = Program.ActiveProjectShell.PrimaryMainForm;

                if (mainForm.ActiveWorkspace == MainFormWorkspace.KnowledgeOrganizer)
                {
                    KnowledgeItem knowledgeItem = Program.ActiveProjectShell.PrimaryMainForm.GetSelectedKnowledgeItems().FirstOrDefault();
                    if (knowledgeItem.EntityLinks.FirstOrDefault() == null)
                    {
                        break;
                    }
                    Annotation annotation = knowledgeItem.EntityLinks.FirstOrDefault().Target as Annotation;
                    if (annotation == null)
                    {
                        break;
                    }
                    Location location = annotation.Location;

                    SwissAcademic.Citavi.Shell.Controls.Preview.PreviewControl previewControl = Program.ActiveProjectShell.PrimaryMainForm.PreviewControl;

                    Program.ActiveProjectShell.ShowPreviewFullScreenForm(location, previewControl, null);
                }
            }
            break;

            case "SelectLinkedKnowledgeItem":
            {
                e.Handled = true;

                MainForm mainForm = Program.ActiveProjectShell.PrimaryMainForm;

                KnowledgeItem target;
                KnowledgeItem knowledgeItem;

                if (mainForm.ActiveWorkspace == MainFormWorkspace.ReferenceEditor)
                {
                    knowledgeItem = mainForm.GetSelectedQuotations().FirstOrDefault();
                }
                else if (mainForm.ActiveWorkspace == MainFormWorkspace.KnowledgeOrganizer)
                {
                    knowledgeItem = mainForm.ActiveKnowledgeItem;
                }
                else
                {
                    return;
                }

                if (knowledgeItem == null)
                {
                    return;
                }

                if (knowledgeItem.EntityLinks.Where(el => el.Indication == EntityLink.CommentOnQuotationIndication).Count() == 0)
                {
                    return;
                }

                if (knowledgeItem.QuotationType == QuotationType.Comment)
                {
                    target = knowledgeItem.EntityLinks.ToList().Where(n => n != null && n.Indication == EntityLink.CommentOnQuotationIndication && n.Target as KnowledgeItem != null).ToList().FirstOrDefault().Target as KnowledgeItem;
                }
                else
                {
                    target = knowledgeItem.EntityLinks.ToList().Where(n => n != null && n.Indication == EntityLink.CommentOnQuotationIndication && n.Target as KnowledgeItem != null).ToList().FirstOrDefault().Source as KnowledgeItem;
                }

                if (target == null)
                {
                    return;
                }

                if (mainForm.ActiveWorkspace == MainFormWorkspace.ReferenceEditor)
                {
                    Control quotationSmartRepeater = Program.ActiveProjectShell.PrimaryMainForm.Controls.Find("quotationSmartRepeater", true).FirstOrDefault();
                    SwissAcademic.Citavi.Shell.Controls.SmartRepeaters.QuotationSmartRepeater quotationSmartRepeaterAsQuotationSmartRepeater = quotationSmartRepeater as SwissAcademic.Citavi.Shell.Controls.SmartRepeaters.QuotationSmartRepeater;

                    Reference reference = target.Reference;
                    if (reference == null)
                    {
                        return;
                    }

                    List <KnowledgeItem> quotations = reference.Quotations.ToList();

                    int index = quotations.FindIndex(q => q == target);

                    quotationSmartRepeaterAsQuotationSmartRepeater.SelectAndActivate(quotations[index]);
                }
                else if (mainForm.ActiveWorkspace == MainFormWorkspace.KnowledgeOrganizer)
                {
                    mainForm.ActiveKnowledgeItem = target;
                }
                else
                {
                    return;
                }



                return;
            }

            case "SortKnowledgeItemsInSelection":
            {
                e.Handled = true;

                var mainForm = (MainForm)e.Form;
                if (mainForm.KnowledgeOrganizerFilterSet.Filters.Count() != 1 || mainForm.KnowledgeOrganizerFilterSet.Filters[0].Name == "Knowledge items without categories")
                {
                    MessageBox.Show("You must select one category.");
                    return;
                }

                KnowledgeItemInSelectionSorter.SortSelectedKnowledgeItems(mainForm);
            }
            break;

            case "SortKnowledgeItemsInCategory":
            {
                e.Handled = true;

                var mainForm = (MainForm)e.Form;
                if (mainForm.KnowledgeOrganizerFilterSet.Filters.Count() != 1 || mainForm.KnowledgeOrganizerFilterSet.Filters[0].Name == "Knowledge items without categories")
                {
                    MessageBox.Show("You must select one category.");
                    return;
                }

                KnowledgeItemInCategorySorter.SortKnowledgeItemsInCategorySorter(mainForm);
            }
            break;
                #endregion
            }
            base.OnBeforePerformingCommand(e);
        }