RELEASE_2_1_13/src/blocks/forms/java/org/apache/cocoon/forms/formmodel/RepeaterActionDefinition.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.cocoon.forms.formmodel;

import org.apache.avalon.framework.CascadingRuntimeException;
import org.apache.cocoon.forms.FormsException;
import org.apache.cocoon.forms.binding.BindingException;
import org.apache.cocoon.forms.event.ActionEvent;
import org.apache.cocoon.forms.event.ActionListener;

/**
 * Abstract repeater action. Subclasses will typically just self-add an event
 * handler that will act on the repeater.
 * 
 * @see RepeaterActionDefinitionBuilder
 * @version $Id$
 */
public abstract class RepeaterActionDefinition extends ActionDefinition {

    private String name = null;

    /**
     * Builds an action whose target repeater is the parent of this widget
     */
    public RepeaterActionDefinition() {
    }

    /**
     * Builds an action whose target is a sibling of this widget
     * @param repeaterName the name of the repeater
     */
    public RepeaterActionDefinition(String repeaterName) {
        this.name = repeaterName;
    }

    /**
     * initialize this definition with the other, sort of like a copy constructor
     */
    public void initializeFrom(WidgetDefinition definition) throws Exception {
        super.initializeFrom(definition);

        if (!(definition instanceof RepeaterActionDefinition)) {
            throw new FormsException("Ancestor definition " + definition.getClass().getName() + " is not a RepeaterActionDefinition.",
                                     getLocation());
        }

        RepeaterActionDefinition other = (RepeaterActionDefinition) definition;

        this.name = other.name;
    }

    public Widget createInstance() {
        return new RepeaterAction(this);
    }

    /**
     * Get the name of the repeater on which to act. If <code>null</code>, the repeater
     * is the parent of the current widget (i.e. actions are in repeater rows). Otherwise,
     *the repeater is a sibling of the current widget.
     * 
     * @return the repeater name (can be <code>null</code>).
     */
    public String getRepeaterName() {
        return this.name;
    }

    // ---------------------------------------------------------------------------------------------

    /**
     * The definition of a repeater action that deletes the selected rows of a sibling repeater.
     * <p>
     * The action listeners attached to this action, if any, are called <em>before</em> the rows
     * are actually removed
     */
    public static class DeleteRowsActionDefinition extends RepeaterActionDefinition {

        private String selectName;

        public DeleteRowsActionDefinition(String repeaterName, String selectName) {
            super(repeaterName);
            this.selectName = selectName;
        }

        /**
         * initialize this definition with the other, sort of like a copy constructor
         */
        public void initializeFrom(WidgetDefinition definition) throws Exception {
            super.initializeFrom(definition);

            if (!(definition instanceof DeleteRowsActionDefinition)) {
                throw new FormsException("Ancestor definition " + definition.getClass().getName() + " is not a DeleteRowsActionDefinition.",
                                         getLocation());
            }

            DeleteRowsActionDefinition other = (DeleteRowsActionDefinition) definition;

            this.selectName = other.selectName;
        }

        public boolean hasActionListeners() {
            // we always want to be notified
            return true;
        }

        public void fireActionEvent(ActionEvent event) {
            // Call action listeners, if any
            super.fireActionEvent(event);

            Repeater repeater = ((RepeaterAction) event.getSource()).getRepeater();

            // and actually delete the rows
            for (int i = repeater.getSize() - 1; i >= 0; i--) {
                Repeater.RepeaterRow row = repeater.getRow(i);
                if (Boolean.TRUE.equals(row.getChild(this.selectName).getValue())) {
                    repeater.removeRow(i);
                }
            }

            if (repeater instanceof EnhancedRepeater) {
                try {
                    ((EnhancedRepeater) repeater).refreshPage();
                } catch (BindingException e) {
                    throw new CascadingRuntimeException("Error refreshing repeater page", e);
                }
            }

        }
    }

    // ---------------------------------------------------------------------------------------------

    /**
     * The definition of a repeater action that adds a row to a sibling repeater.
     */
    public static class AddRowActionDefinition extends RepeaterActionDefinition {
        private int insertRows;

        public AddRowActionDefinition(String repeaterName, int insertRows) {
            super(repeaterName);
            this.insertRows = insertRows;

            addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent event) {
                    Repeater repeater = ((RepeaterAction)event.getSource()).getRepeater();
                    if (repeater instanceof EnhancedRepeater) {
                        try {
                            ((EnhancedRepeater) repeater).goToPage(((EnhancedRepeater) repeater).getMaxPage());
                        } catch (BindingException e) {
                            throw new CascadingRuntimeException("Error switching page", e);
                        }
                    }
                    for (int i = 0; i < AddRowActionDefinition.this.insertRows; i++) {
                        repeater.addRow();
                    }
                }
            });
        }

    }

    // ---------------------------------------------------------------------------------------------

    /**
     * The definition of a repeater action that insert rows before the selected rows in a sibling repeater,
     * or at the end of the repeater if no row is selected.
     */
    public static class InsertRowsActionDefinition extends RepeaterActionDefinition {

        protected String selectName;

        /**
         * initialize this definition with the other, sort of like a copy constructor
         */
        public void initializeFrom(WidgetDefinition definition) throws Exception {
            super.initializeFrom(definition);

            if (!(definition instanceof InsertRowsActionDefinition)) {
                throw new FormsException("Ancestor definition " + definition.getClass().getName() + " is not an InsertRowsActionDefinition.",
                                         getLocation());
            }

            InsertRowsActionDefinition other = (InsertRowsActionDefinition) definition;

            this.selectName = other.selectName;
        }

        public InsertRowsActionDefinition(String repeaterName, String selectWidgetName) {
            super(repeaterName);
            this.selectName = selectWidgetName;

            this.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent event) {
                    Repeater repeater = ((RepeaterAction)event.getSource()).getRepeater();
                    boolean foundSelection = false;
                    for (int i = repeater.getSize() - 1; i >= 0; i--) {
                        Repeater.RepeaterRow row = repeater.getRow(i);
                        Widget selectWidget = row.getChild(selectName);
                        if (Boolean.TRUE.equals(selectWidget.getValue())) {
                            // Add a row
                            repeater.addRow(i);
                            foundSelection = true;
                        }
                    }

                    if (!foundSelection) {
                        // Add a row at the end
                        repeater.addRow();
                    }
                }
            });
        }
    }

    public static class SortActionDefinition extends RepeaterActionDefinition {
        protected String field = null;

        public SortActionDefinition(String repeaterName, String field) {
            super(repeaterName);
            this.field = field;

            this.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent event) {
                    Repeater repeater = ((RepeaterAction)event.getSource()).getRepeater();
                    if (repeater instanceof EnhancedRepeater) {
                        EnhancedRepeater erep = (EnhancedRepeater) repeater;
                        try {
                            if (repeater.validate()) {
                                erep.sortBy(SortActionDefinition.this.field);
                            }
                        } catch (Exception e) {
                            throw new CascadingRuntimeException("Error switching page", e);
                        }
                    }
                }
            });

        }
    }

    public static class ChangePageActionDefinition extends RepeaterActionDefinition {

        protected int method;

        public static final int FIRST = 0;
        public static final int PREV = 1;
        public static final int NEXT = 2;
        public static final int LAST = 3;
        public static final int CUSTOM = 4;

        /**
         * initialize this definition with the other, sort of like a copy constructor
         */
        public void initializeFrom(WidgetDefinition definition) throws Exception {
            super.initializeFrom(definition);
            if (definition instanceof ChangePageActionDefinition) {
                ChangePageActionDefinition other = (ChangePageActionDefinition) definition;
                this.method = other.method;
            } else {
                throw new Exception("Definition to inherit from is not of the right type! (at " + getLocation() + ")");
            }
        }

        public ChangePageActionDefinition(String repeaterName, int m) {
            super(repeaterName);

            this.method = m;

            this.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent event) {
                    Repeater repeater = ((RepeaterAction)event.getSource()).getRepeater();
                    if (repeater instanceof EnhancedRepeater) {
                        EnhancedRepeater erep = (EnhancedRepeater) repeater;
                        int page = erep.getCurrentPage();
                        if (method == FIRST) {
                            page = 0;
                        } else if (method == PREV && page > 0) {
                            page = erep.getCurrentPage() - 1;
                        } else if (method == NEXT && page < erep.getMaxPage()) {
                            page = erep.getCurrentPage() + 1;
                        } else if (method == LAST) {
                            page = erep.getMaxPage();
                        } else if (method == CUSTOM) {
                            page = erep.getCustomPageWidgetValue();
                        } else {
                            return;
                        }
                        try {
                            if (repeater.validate()) {
                                erep.goToPage(page);
                            }
                        } catch (Exception e) {
                            throw new CascadingRuntimeException("Error switching page", e);
                        }
                    }
                }
            });
        }
    }

}