Ticket #2312: dnd-new-templated-pages.patch

src/main/java/org/sophie2/main/app/commons/book/panels/BookPanelLogic.java

@@ -5 +5 @@
 import org.sophie2.base.bound.ComboInput;
 import org.sophie2.base.layout.impl.DefaultDocView;
 import org.sophie2.base.model.book.BookH;
+import org.sophie2.base.model.resources.r4.ResourceRefR4;
 import org.sophie2.base.model.resources.r4.changes.AutoAction;
 import org.sophie2.base.model.resources.r4.resources.ResourceR4;
 import org.sophie2.core.logging.SophieLog;
@@ -340 +341 @@
                                 return true; // Handled, no changes made.
                         }
 
-                        bookView.addNewPage(pageIndex);
+                        bookView.addNewPage(pageIndex, ResourceRefR4.NONE_REF);
                 } else {
 
                         assert pageIndex >= 0 && pageIndex <= model.getPages().size() :

src/main/java/org/sophie2/main/app/commons/book/BookView.java

@@ -478 +478 @@
 
         /**
          * Adds a new page to this book to the given index and sets it to be
-         * current.
+         * current. 
+         * If the <code>templateRef</code> is not {@link ResourceRefR4#NONE_REF},
+         * applies this page template to the new page. Otherwise, it way apply 
+         * the default page template or it may not apply a template at all.
          * 
          * @param index
          *            The index where in the pages list the new page should be
          *            created.
+         * @param templateRef
          */
-        public void addNewPage(final int index) {
+        public void addNewPage(final int index, ResourceRefR4 templateRef) {
 
                 assert !getViewOptions().isPreviewMode() : "You should not add pages in preview mode";
 
@@ -492 +496 @@
                 final ResourceRefList pages = model().get().getPages();
                 final String pageName = ResourceUtil.getNextTitle(this.access().get().getRef(),
                                 PageR4.DEFAULT_TITLE);
+                ResourceRefR4 realTemplateRef = getTemplateRef(templateRef);
+                boolean significant = ResourceRefR4.NONE_REF.equals(realTemplateRef);
 
-                new AutoAction("Add a new page", true) {
+                new AutoAction("Add a new page", significant) {
 
                         @Override
                         public void performAuto() {
@@ -502 +508 @@
 
                 }.register(getAccess());
 
-                ResourceRefR4 templatePageRef = model().get().getDefaultPageTemplate();                          
+                if(!ResourceRefR4.NONE_REF.equals(realTemplateRef)) {
 
-                if(! templatePageRef.equals(ResourceRefR4.NONE_REF)) {
+                        if (!realTemplateRef.isAbsolute()) {
+                                realTemplateRef = this.getAccess().getRef().getAbsolute(realTemplateRef);
+                        }
+                        assert realTemplateRef.isAbsolute();
+                        final ResourceRefR4 pageToTemplateRef = ResourceRefR4.getRelativeRef(pageRef,
+                                        realTemplateRef);
 
-                        ResourceRefR4 absoluteDefRef = this.getAccess().getRef().getAbsolute(templatePageRef);
-                        assert absoluteDefRef.isAbsolute();
-                        final ResourceRefR4 templateRef =ResourceRefR4.getRelativeRef(pageRef,
-                                        absoluteDefRef);
+                        ResourceAccess templateAccess = this.getAccess().open(pageToTemplateRef, null);
 
-                        ResourceAccess templateAccess = this.getAccess().open(templateRef, null);
-
                         ResourceAccess pageAccess = this.getPageView(pageRef).getAccess();
 
                         PageH templateH = ResourceH.getHelper(templateAccess, PageH.class);
                         final NaiveImmList<TemplatedKey<?>> immKeys = templateH.getApplicableTemplatedKeys();
 
-                        new AutoAction("Apply page template.", true) {
+                        new AutoAction("Add a new templated page.", true) {
                                 @Override
                                 public void performAuto() {
-                                        TemplateUtil.applyPageTemplate(getChanger(), templateRef, immKeys);
+                                        TemplateUtil.applyPageTemplate(getChanger(), pageToTemplateRef, immKeys);
                                 }
                         }.register(pageAccess);
 
-                        SophieLog.debugf("Added a new page with index %d to the %s book.", index, model().get()
-                                        .getTitle());
+                        SophieLog.debugf("Added a new page with index %d to the %s book.", index, 
+                                        model().get().getTitle());
+                }
+                
+                goToPage(model().get().getPages().get(index));
 
-                        goToPage(model().get().getPages().get(index));
-
-                        SophieLog.debugf("Went to page %d.", index + 1);
+                SophieLog.debugf("Went to page %d.", index + 1);
+        }
+        
+        private ResourceRefR4 getTemplateRef(ResourceRefR4 templateRef) {
+                if (templateRef != null && !ResourceRefR4.NONE_REF.equals(templateRef)) {
+                        return templateRef;
+                } 
+                
+                ResourceRefR4 defaultTemplateRef = model().get().getDefaultPageTemplate();      
+                if (defaultTemplateRef != null && !ResourceRefR4.NONE_REF.equals(defaultTemplateRef)) {
+                        return defaultTemplateRef;
                 }
+                
+                return ResourceRefR4.NONE_REF;          
         }
+        
         /**
          * The events that may be fired by this.
          * 

src/main/java/org/sophie2/main/app/commons/util/TemplateUtil.java

@@ -169 +169 @@
                                 if (key.equals(ResourceFrame.KEY_MAIN_RESOURCE) && skipMainResource) {
                                         continue;
                                 }
-                                
                                 changer.setRaw(key, null);
                                 changer.setRaw(key.getLockKey(), false); 
                         }

src/main/java/org/sophie2/main/app/layout/left/pages/PagePreviewPaletteLogic.java

@@ -1 +1 @@
 package org.sophie2.main.app.layout.left.pages;
 
+import java.awt.Rectangle;
+
 import org.sophie2.base.commons.util.position.ImmPoint;
+import org.sophie2.base.commons.util.position.ImmRect;
 import org.sophie2.base.dialogs.DialogManager;
 import org.sophie2.base.dnd.DndData;
 import org.sophie2.base.dnd.SophieDragDropHandler;
@@ -32 +35 @@
  * Event handlers for the {@link PagePreviewPalette}.
  */
 public enum PagePreviewPaletteLogic implements OperationDef {
-        
+                
         /**
          * Handles a user request to add a new page before current page.
          */
@@ -169 +172 @@
         
         /**
          * Handles dropping a page template over the {@link PagePreviewPalette}.
-         * Applies the template to the page over which it was dropped.
+         * Applies the template to the page over which it was dropped or creates a new page
+         * if it was dropped over the blank space between page items.
          */
         ON_DND_APPLY_TEMPLATE {
+                
+                /**
+                 * The padding (in pixels) page items are assumed to have.
+                 * If a page template is dropped over the top or bottom padding, a new page
+                 * will be created from it.
+                 * Otherwise, it is assumed that it was dropped over the page thumbnail 
+                 * and the template is applied to the page.
+                 */
+                public static final int PAGE_ITEM_PADDING = 10;
 
                 public void defineFilter(EventFilterBuilder filter) {
                         filter.setSourceClass(PagePreviewPalette.class);
@@ -180 +193 @@
 
                 public boolean handle(EventR3 event) {
                         
+                        PagePreviewPalette palette = event.getSource(PagePreviewPalette.class);
+                        BookView bookView = AppViewUtil.getCurrentBookView(palette);
+                        if (bookView.getViewOptions().isPreviewMode()) {
+                                return false;
+                        }
+                        BookH book = bookView.model().get();
+                        
                         DndImport dndImport = event.getEventParam(
                                         SophieDragDropHandler.TransferEventIds.TRANSACTION_PARAM_INDEX,
                                         DndImport.class);
@@ -188 +208 @@
                                         SophieDragDropHandler.TransferEventIds.POINT_PARAM_INDEX,
                                         ImmPoint.class);
                         
-                        // find the page over which the template was dropped
-                        PagePreviewPalette palette = event.getSource(PagePreviewPalette.class);
+                        // find the page item over which the template was dropped
                         int index = palette.mainComponent().get().locationToIndex(point.toPoint());
-                        if (!palette.mainComponent().get().getCellBounds(index, index).contains(point.toPoint())) {
-                                return false;
-                        }                                               
-                        PageItem pageItem = palette.items().get().get(index);
+                        PageItem pageItem = palette.items().get().get(index);                   
                         PageH page = pageItem.pageView().get().model().get();
                         
-                        // apply the template
-                        BookH book = AppViewUtil.getCurrentBook(palette);
-                        boolean handled = TemplateUtil.applyPageTemplate(dndImport.getTransferable(), page, book);
+                        // determine whether the template was dropped over the page itself or over blank space
+                        Rectangle bounds = palette.mainComponent().get().getCellBounds(index, index);
+                        ImmRect topPaddingRect = new ImmRect(bounds.x, bounds.y, bounds.width, PAGE_ITEM_PADDING);
+                        ImmRect innerRect = new ImmRect(bounds.x, bounds.y + PAGE_ITEM_PADDING, 
+                                                bounds.width, bounds.height - 2 * PAGE_ITEM_PADDING);
+                        ImmRect bottomPaddingRect = new ImmRect(bounds.x, bounds.y + bounds.height - PAGE_ITEM_PADDING,
+                                        bounds.width, PAGE_ITEM_PADDING);
                         
-                        // go to the page that was changed
-                        if (handled == true) {
-                                BookView bookView = AppViewUtil.getCurrentBookView(palette);
-                                ResourceRefR4 bookToPageRef = ResourceRefR4.getRelativeRef(book.getRef(), page.getRef());
-                                bookView.goToPage(bookToPageRef);
+                        if (innerRect.contains(point)) {                                
+                                boolean handled = TemplateUtil.applyPageTemplate(dndImport.getTransferable(), page, book);
+                                
+                                if (handled == true) {
+                                        ResourceRefR4 bookToPageRef = ResourceRefR4.getRelativeRef(book.getRef(), page.getRef());
+                                        bookView.goToPage(bookToPageRef);
+                                }
+                                
+                                return handled;                         
                         }
                         
-                        return handled;
+                        TemplateRefData refData = dndImport.getTransferable().getDndData(TemplateRefData.class);
+                        if (refData == null || !TemplateUtil.isPageTemplate(book, refData.getTemplateRef())) {
+                                return false;
+                        }
+                        
+                        if (topPaddingRect.contains(point)) {
+                                insertPage(bookView, page.getRef(), false, refData.getTemplateRef());
+                                return true;
+                        }
+                                                
+                        if (bottomPaddingRect.contains(point)) {
+                                insertPage(bookView, page.getRef(), true, refData.getTemplateRef());
+                                return true;
+                        }
+                        
+                        if (!bounds.contains(point.toPoint())) {
+                                insertPage(bookView, page.getRef(), true, refData.getTemplateRef());
+                                return true;
+                        }
+                        
+                        return false;
                 }
         };
 
@@ -230 +274 @@
 
                 BookView bookView = AppViewUtil.getCurrentBookView(palette);
 
-                if ("author".equals(System.getProperty("edition")) && !bookView.getViewOptions().isPreviewMode()) {
-                        BookH book = bookView.model().get();
+                if (!bookView.getViewOptions().isPreviewMode()) {
 
                         RootPageView pageView = bookView.getCurrentPageView();
-
                         ResourceRefR4 currPage = pageView.model().get().getRef();
-                        int currentIndex = book.getIndexOf(currPage);
-                        assert currentIndex >= 0;
+                        insertPage(bookView, currPage, after, ResourceRefR4.NONE_REF);
+                }
 
-                        if (after) {
-                                currentIndex++;
-                        }
-                        final int index = currentIndex;
+                return true;
+        }
+        
+        /**
+         * Inserts a new page in the book model of the given BookView. The page is inserted
+         * right before or after the given page, depending on the <code>after</code> argument.
+         * If the <code>templateRef</code> is points to a valid page template, it is applied
+         * to the new page.
+         * 
+         * @param bookView
+         *              BookView of the book in which to insert the new page.
+         * @param pageRef
+         *              Reference to the page before or after which the new one should be inserted.
+         * @param after
+         *              Whether the new page should be inserted after the given one.
+         * @param templateRef
+         *              A reference to the template that should be applied to the new page.
+         */
+        protected static void insertPage(BookView bookView, ResourceRefR4 pageRef,
+                        boolean after, ResourceRefR4 templateRef) {
+                BookH book = bookView.model().get();
+                
+                int currentIndex = book.getIndexOf(pageRef);
+                assert currentIndex >= 0;
 
-                        bookView.addNewPage(index);
+                if (after) {
+                        currentIndex++;
                 }
+                final int index = currentIndex;
 
-                return true;
+                bookView.addNewPage(index, templateRef);
         }
 }