/*
 * Copyright (c) 2010 The Regents of the University of California.
 * All rights reserved.
 *
 * '$Author: crawl $'
 * '$Date: 2012-08-09 21:27:41 +0000 (Thu, 09 Aug 2012) $' 
 * '$Revision: 30392 $'
 * 
 * Permission is hereby granted, without written agreement and without
 * license or royalty fees, to use, copy, modify, and distribute this
 * software and its documentation for any purpose, provided that the above
 * copyright notice and the following two paragraphs appear in all copies
 * of this software.
 *
 * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY
 * FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
 * THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE
 * PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF
 * CALIFORNIA HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES,
 * ENHANCEMENTS, OR MODIFICATIONS.
 *
 */

package org.kepler.reporting.gui;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Image;
import java.awt.Insets;
import java.awt.Rectangle;
import java.awt.Toolkit;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
import java.awt.dnd.DnDConstants;
import java.awt.dnd.DropTarget;
import java.awt.dnd.DropTargetDragEvent;
import java.awt.dnd.DropTargetDropEvent;
import java.awt.dnd.DropTargetEvent;
import java.awt.dnd.DropTargetListener;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.event.WindowFocusListener;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

import javax.imageio.ImageIO;
import javax.swing.AbstractAction;
import javax.swing.Box;
import javax.swing.ImageIcon;
import javax.swing.JCheckBox;
import javax.swing.JFileChooser;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.JScrollPane;
import javax.swing.JSplitPane;
import javax.swing.JTextField;
import javax.swing.JToolBar;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
import javax.swing.text.BadLocationException;

import org.kepler.gui.KeplerGraphFrame;
import org.kepler.gui.TabManager;
import org.kepler.gui.TabPane;
import org.kepler.gui.TabPaneFactory;
import org.kepler.gui.state.ReportingStateChangeEvent;
import org.kepler.gui.state.StateChangeEvent;
import org.kepler.gui.state.StateChangeListener;
import org.kepler.gui.state.StateChangeMonitor;
import org.kepler.moml.NamedObjId;
import org.kepler.objectmanager.lsid.KeplerLSID;
import org.kepler.reporting.rio.DynamicReportItem;
import org.kepler.reporting.rio.Item;
import org.kepler.reporting.rio.ItemValue;
import org.kepler.reporting.rio.StaticReportItem;
import org.kepler.reporting.rio.StaticReportItemHR;
import org.kepler.reporting.rio.StaticReportItemImage;
import org.kepler.reporting.rio.StaticReportItemSection;
import org.kepler.reporting.rio.StaticReportItemText;
import org.kepler.reporting.rio.fop.ReportRenderer;
import org.kepler.reporting.rio.test.ReportTest;
import org.kepler.reporting.rio.util.ImageUtil;
import org.kepler.reporting.rio.util.ProvenanceUtil;
import org.kepler.reporting.roml.ReportLayout;
import org.kepler.util.WorkflowRun;
import org.kepler.workflow.WorkflowManager;

import ptolemy.actor.gui.PtolemyFrame;
import ptolemy.actor.gui.TableauFrame;
import ptolemy.data.StringToken;
import ptolemy.data.expr.Parameter;
import ptolemy.gui.ExtensionFilenameFilter;
import ptolemy.gui.PtFileChooser;
import ptolemy.kernel.Port;
import ptolemy.kernel.util.IllegalActionException;
import ptolemy.kernel.util.NameDuplicationException;
import ptolemy.kernel.util.NamedObj;
import ptolemy.vergil.toolbox.PtolemyTransferable;

/**
 * This class creates a gui pane the allows users to create a report layout for
 * a Kepler Workflow. It implements TabPane, which is an extension point for
 * additional tabbed contents in the Kepler gui. See TabPane for more details.
 * 
 * 
 * @author staggs created January 7, 2009
 * 
 * 
 */

public class ReportDesignerPanel extends JPanel implements TabPane,
                ActionListener, DropTargetListener, StateChangeListener, WindowFocusListener {

        private final ReportDesignerPanel ref = this;
        
        public static final String IMAGES_DIR = "images/";

        private static int LAYOUT_PANEL_WIDTH = 700;
        // XXX LAYOUT_PANEL_HEIGHT isn't really used, we dynamically 
        // set height in redrawView.setPreferredSize
        private static int LAYOUT_PANEL_HEIGHT = 700;
        private static int HEADER_PANEL_WIDTH = 100;
        private static int HEADER_PANEL_HEIGHT = 30;
        private static int DESIGNER_PANE_WIDTH = 700;
        private static int DESIGNER_PANE_HEIGHT = 200;

        // extra empty space so user can distinguish end of layout
        private static int PANEL_HEIGHT_DEADSPACE = 50;

        // empty space around panels to facilitate drag n drop
        private static int PANEL_INSET_TOP = 0;
        private static int PANEL_INSET_LEFT = 10;
        private static int PANEL_INSET_BOTTOM = 20;
        private static int PANEL_INSET_RIGHT = 30;
        
        private final static String TITLETEXT = "Title: ";
        private TableauFrame _frame;
        private String _title;
        private ReportLayout reportLayout = null;
        private Item selectedItem; // this is for getting the properties, not for
                                                           // the DragAndDropPanels
        private JPanel layoutpanel, headerpanel;
        
        private Item prevSelectedItem;  
        private Item thecurrentitem;

        private JRadioButton getimagebtn;
        
        private JSplitPane designersplitpane;
        private final List<DragAndDropPanel> reportitemPanels;
        private static DataFlavor dragAndDropPanelDataFlavor = null;
        
        private DragAndDropPanel prevSelectedPanel;
        private DragAndDropPanel currSelectedPanel;
        
        private Color transparentblue = new Color(6, 128, 255, 129);  // transparent blue
        //private Color bluenoalpha = new Color(91, 169, 248);  // non-alpha blue

        public static final DataFlavor jlabelFlavor = new DataFlavor(JLabel.class,
                        "Swing JLabel");
        
        private String layoutDiscardWarning =  "Discard current report layout and load old report layout?";
        private JCheckBox dontShowDialogCheckBox = new JCheckBox("Do not show this message again.");
                
        private static Cursor droppableCursor = Cursor
                        .getPredefinedCursor(Cursor.DEFAULT_CURSOR);

        public ReportDesignerPanel(String title, String workflowName) {

                super(new BorderLayout());
                _title = title;
                
                reportitemPanels = new ArrayList<DragAndDropPanel>();
                this.setTransferHandler(new DragAndDropTransferHandler());
                
                //set up listeners
                StateChangeMonitor.getInstance().addStateChangeListener(ReportingStateChangeEvent.REPORT_LAYOUT_CHANGED, this);
                StateChangeMonitor.getInstance().addStateChangeListener(WorkflowRun.WORKFLOWRUN_SELECTED, this);
                
                //TODO on windowClosed we should remove this ReportDesignerPanel from listening to the above
        }

        /**
         * getSelectedItem and setSelectedItem are currently used to create the
         * properties table that appears in the 'Items of Interest' panel.
         * 
         * @return selectedItem for setting the items' properties in the properties
         *         table in the ItemsOfInterestPanel.
         */
        public Item getSelectedItem() { // IMPORTANT Note: this is not for the
                                                                        // panels, it is for the
                return selectedItem;            // item properties selection.
        }

        public void setSelectedItem(Item selectedItem) {
                this.selectedItem = selectedItem;
        }

        /**
         * Initializes the tab for this TabPane in which the Report Designer is
         * displayed.
         */
        public void initializeTab() throws Exception { 

                // We query the report layouts and if there is one we will use it
                // and if not we will add a blank one.
                
                NamedObj reference = ((PtolemyFrame) _frame).getModel();
                KeplerLSID lsid = NamedObjId.getIdFor(reference);
                
                // need to setRankingTableauFrame here so the ReportLayoutKAREntryHandler gets the new frame
                // on an open, because it hasn't been set via windowGainedFocus
                WorkflowManager.setRankingTableauFrame(_frame);

                //do this whether the reportLayout is null or not:
                reportLayout = WorkflowManager.getInstance().getWorkflow(_frame, lsid).getReportLayout(_frame);
                        
                if (reportLayout == null){
                        reportLayout = new ReportLayout();
                        // associate the layout with the workflow
                        reportLayout.setWorkflowLSID(lsid);
                        WorkflowManager.getInstance().getWorkflow(_frame, lsid).addReportLayout(_frame, reportLayout);
                }

                createTabContents();
                
                renderReportLayout();
                
                WindowFocusListener[] wfl = _frame.getWindowFocusListeners();
                boolean add = true;
                for (int i=0; i<wfl.length; i++){
                        if (wfl[i] == this){
                                add = false;
                        }
                }
                if (add){
                        _frame.addWindowFocusListener(this);
                }
                
                // clean up the listener when the frame closes
                   final StateChangeListener listenerReference = this;
                    _frame.addWindowListener(new WindowAdapter() {
                                public void windowClosed(WindowEvent e) {
                                        StateChangeMonitor.getInstance().removeStateChangeListener(ReportingStateChangeEvent.REPORT_LAYOUT_CHANGED, listenerReference);
                                        StateChangeMonitor.getInstance().removeStateChangeListener(WorkflowRun.WORKFLOWRUN_SELECTED, listenerReference);
                                }
                        });
                
        }
        

        /**
         * createTabContents() - You can modify this to change what appears in the report designer tab.
         * This is used to create the layout and contents of the report designer GUI.
         */
        private void createTabContents() {
                
                /**
                 * The header panel and the layout panel are both inside of a split pane
                 * that is inside of the Report Designer Panel.  The header panel
                 * holds the title of the report, and the layout panel is where
                 * the user will drop the report items to create the report layout.
                 */

                /**
                 * Create the header panel
                 */
                headerpanel = new JPanel();
                headerpanel.setLayout(new BorderLayout());
                headerpanel.setBackground(Color.white);
                headerpanel.setMaximumSize(new Dimension(HEADER_PANEL_WIDTH, HEADER_PANEL_HEIGHT));
                headerpanel.setMinimumSize(new Dimension(HEADER_PANEL_WIDTH, HEADER_PANEL_HEIGHT));
                headerpanel.setPreferredSize(new Dimension(HEADER_PANEL_WIDTH, HEADER_PANEL_HEIGHT));
                                

                /**
                 * Set up the text fields and their corresponding labels inside of the
                 * header panel
                 */
                JTextField titletxt = new JTextField("");
                titletxt.setText(reportLayout.getTitle());
                Font titlefont = new Font("SansSerif", Font.BOLD, 16);
                titletxt.setFont(titlefont);
                
                // Listen for changes to text
                titletxt.getDocument().addDocumentListener(new TitleDocumentListener());
                
                JLabel lbltitle = new JLabel(TITLETEXT);
                
            headerpanel.add(lbltitle, BorderLayout.WEST);
                headerpanel.add(titletxt, BorderLayout.CENTER);

                /**
                 * Create the layout panel.
                 * 
                 * The general idea of the layout panel is that each individual element 
                 * of a report called a "report item" is represented by its own type of 
                 * component, in this case a JPanel (DragAndDropPanel extends JPanel)
                 * with an appropriate icon, etc. 
                 * Since a report item object (Item class) is associated with each of the panels.
                 * the user controls the order of the report items by adding, deleting,
                 * and re-arranging the report item panels.
                 *
                 * So... when the user re-arranges the panels, the order of the
                 * report items is also re-arranged temporarily (in memory), and then
                 * written out to the Report model.
                 * 
                 * 
                 */
                
                //The lines below show the 'drag to create a report' background in the report layout area.
                // A small dot is also used, which replaces the graphic of the 'drag to here' image
                // after the first report item is dropped into the report layout area.
                URL placeholderdotURL = getIconURL("placeholderdot", "png");
                URL paperURL = getIconURL("papertrans","png");
                if (reportitemPanels.isEmpty()){
                        layoutpanel = new ImagePanel(new ImageIcon(paperURL).getImage());
                } else {
                        layoutpanel = new ImagePanel(new ImageIcon(placeholderdotURL).getImage());
                }
                
                layoutpanel.setLayout(new GridBagLayout());
                layoutpanel.setBackground(Color.white);
                
                layoutpanel.scrollRectToVisible(getVisibleRect());              
                
                layoutpanel.setMinimumSize(new Dimension(LAYOUT_PANEL_WIDTH, LAYOUT_PANEL_HEIGHT));
                layoutpanel.setPreferredSize(new Dimension(LAYOUT_PANEL_WIDTH, LAYOUT_PANEL_HEIGHT));

                layoutpanel.setDropTarget(new DropTarget(layoutpanel,
                                DnDConstants.ACTION_COPY_OR_MOVE, this, true, null));
                layoutpanel.setTransferHandler(new DragAndDropTransferHandler());
                layoutpanel.setCursor(Cursor.getDefaultCursor());
                
                

                /**
                 * Create the split pane and put the header panel and layout panel
                 * inside of scroll pane and add to the ReportDesignerPanel.
                 */
                designersplitpane = new JSplitPane(JSplitPane.VERTICAL_SPLIT,
                                add(headerpanel), add(new JScrollPane(layoutpanel)));

                designersplitpane.setBackground(Color.white);
                designersplitpane.setMinimumSize(new Dimension(DESIGNER_PANE_WIDTH, DESIGNER_PANE_HEIGHT));
                designersplitpane.setPreferredSize(new Dimension(DESIGNER_PANE_WIDTH, DESIGNER_PANE_HEIGHT));

                add(designersplitpane);
        }


        /**
         * Method that sets the location for the images directory for the icons and
         * appends ".gif" or ".png", etc. to the name of the file if you pass it the name of the
         * image that you would like to use.
         * 
         * @param iconname
         * @param extension
         * 
         * @return the URL for the icon.
         * 
         * 
         */
        public URL getIconURL(String iconname, String extension) {

                String IconLocation = IMAGES_DIR + iconname + "." + extension;
                URL iconURL = ItemsOfInterestPanel.class.getResource(IconLocation);

                return iconURL;
        }

        

        /**
         * creates a generic Drag and Drop Panel these are the panels that you can
         * drag around and re-order a new panel is created when the user drops any
         * item of interest onto the report layout canvas. This method also adds the
         * newly created panel to the ReportItemPanels list.
         * 
         * @return DragAndDropPanel panel
         */
        private DragAndDropPanel createDragAndDropPanel() {
                DragAndDropPanel panel = new DragAndDropPanel(this);

                panel.setBounds(200, 200, 400, 500); // this sets the size of the draggable  ## SET SIZE
                                                                                        // area

                getReportItemPanels().add(panel);

                return panel;
        }

        /**
         * creates a Drag and Drop Panel that represents a Dynamic Report Item.
         * a Dynamic Report Item represents something that is from the
         * workflow and is recorded by the Provenance recorder.
         * 
         * @param tmpItem
         * @param dynamicreportItemButton
         * 
         * @return DragAndDropPanel panel
         */
        private DragAndDropPanel createDynamicReportItemView(Item tmpItem,
                        ReportItemButton dynamicreportItemButton) {
          
                String strItemFullName = tmpItem.getName(); 
                dynamicreportItemButton.setToolTipText(strItemFullName);
                DeleteItemButton deleteitembutton = makeDynamicItemDeleteButton("delete", "delete", tmpItem, "Delete", "Delete");
                //deleteitembutton.setBackground(transparentblue);  //##

                DynamicReportItemPanel panel = new DynamicReportItemPanel(this, tmpItem,
                                dynamicreportItemButton, deleteitembutton, strItemFullName, reportLayout, _frame);
                
                deleteitembutton.setAssociatedPanel(panel);

                panel.setBounds(0, 0, 500, 550); // this sets the size of the draggable  // area
                
                panel.setBackground(Color.white);

                getReportItemPanels().add(panel);
        

                return panel;
        }

        /**
         * get ReportItemPanels() gets the ReportItemPanels in general, the panels are laid out directly
         * from the report model, but this is used for the GUI to re-arrange the
         * panels and access report items that are associated with them.
         * 
         * @return reportitemPanels
         */
        public List<DragAndDropPanel> getReportItemPanels() {
                
                return reportitemPanels;
        }

        /**
         * redrawView() redraws the view, from getReportItemPanels 
         * using GridBagConstraints
         */
        protected void redrawView() {
        
                // Create the GridBag constraints, and set the ones that
                // don't change.

                final GridBagConstraints gbc = new GridBagConstraints();
                gbc.gridwidth = GridBagConstraints.REMAINDER;
                gbc.gridx = 0;
                gbc.anchor = GridBagConstraints.NORTH;
                gbc.weighty = 0.0;
                gbc.fill = GridBagConstraints.NONE;

                int row = 0;

                // Clear out all (and I do mean ALL, not just the DnD Panels) components
                // from the ReportDesignerPanel.

                removeAll();
                // _frame.pack();

                // At this point, just sets up the Report Designer Panel titled border..
                createTabContents();

                // Put some room around the panels so the user can drag and
                // drop them easily. 
                gbc.insets = new Insets(PANEL_INSET_TOP, 
                                PANEL_INSET_LEFT, PANEL_INSET_BOTTOM, PANEL_INSET_RIGHT);

                // dynamically resize layoutpanel based on sum of heights of
                // contained DragAndDropPanels, + some deads space for distinguishing 
                // the end of layout + space between panels
                int newLayoutPanelHeight = PANEL_HEIGHT_DEADSPACE+
                        (getReportItemPanels().size()*(PANEL_INSET_BOTTOM+PANEL_INSET_TOP));
                
                for (DragAndDropPanel dragAndDropPanel : getReportItemPanels()) {
                        gbc.gridy = row++;

                        Item item = dragAndDropPanel.getAssociatedItem();

                        if (item.isSelected()) {
                                dragAndDropPanel.selectPanel();
                        } else {
                                dragAndDropPanel.deselectPanel();
                        }
                        
                        // FIXME seems like it would make more sense to call 
                        // dragAndDropPanel.getHeight(), but these are returning heights
                        // larger than I expect, so:
                        if (dragAndDropPanel instanceof DynamicReportItemPanel){
                                newLayoutPanelHeight += DynamicReportItemPanel.DYNAMIC_REPORT_ITEM_VIEW_HEIGHT;
                        }
                        else {
                                newLayoutPanelHeight += DragAndDropPanel.DRAG_AND_DROP_PANEL_HEIGHT;
                        }

                        layoutpanel.add(dragAndDropPanel, gbc);
                }

                gbc.weighty = 1.0;
                gbc.weightx = 1.0;
                gbc.fill = GridBagConstraints.BOTH;
                gbc.gridy = row++;
                Component strut = Box.createVerticalStrut(1);
                layoutpanel.add(strut, gbc);
                
                layoutpanel.setPreferredSize(new Dimension(LAYOUT_PANEL_WIDTH, newLayoutPanelHeight));

                
                validate();
                repaint();
        }

        /**
         * addDeleteButton() adds the delete button to the toolbar.
         * there is also an 'Open ROML' button that is commented out, but can be uncommented
         * if necessary for testing purposes.  Note: 'Open ROMl' works with a test class located in
         * org.kepler.reporting.rio.test  ReportTest.java
         * 
         * @param toolBar
         * @param associtem
         * @param panel
         * 
         */
        protected void addDeleteButton(JToolBar toolBar, Item associtem, DragAndDropPanel panel) {

                DeleteItemButton btndeleteitem = null;

                btndeleteitem = makeDeleteButton("delete", "delete",
                                associtem, panel, "Delete", "Delete");
                
                if (!isWindows()){
                        btndeleteitem.setBackground(transparentblue);
                }
                
                btndeleteitem.setBorderPainted(false);
                btndeleteitem.setText("Delete");
                toolBar.add(btndeleteitem);
        }
        
        
        /**
         * makeDeleteButton() creates the Delete Button for the Static Items.
         * 
         * @param imageName
         * @parma actionCommand
         * @param associtem
         * @param panel
         * @param toolTipText
         * @param altText
         * 
         * @return DeleteItemButton deletebutton
         * 
         */
        protected DeleteItemButton makeDeleteButton(String imageName,
                        String actionCommand, Item associtem, DragAndDropPanel panel, String toolTipText, String altText) {
                
                DeleteItemButton deletebutton = new DeleteItemButton();
                // Look for the image.
                String imgLocation = IMAGES_DIR + imageName + ".png";
                URL imageURL = ReportDesignerPanel.class.getResource(imgLocation);

                // Create and initialize the button.
                deletebutton.setActionCommand(actionCommand);
                deletebutton.setToolTipText(toolTipText);
                deletebutton.addActionListener(this);
        //      deletebutton.setBackground(buttonbackgroundcolor2);
                
                deletebutton.setAssociatedItem(associtem);
                deletebutton.setAssociatedPanel(panel);

                if (imageURL != null) { // image found
                        deletebutton.setIcon(new ImageIcon(imageURL, altText));
                } else { // no image found
                        deletebutton.setText(altText);
                        System.err.println("Resource not found: " + imgLocation);
                }
                
                deletebutton.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
                deletebutton.setToolTipText("Delete this report item");
                return deletebutton;
        }

        
        /**
         * makeDynamicItemDeleteButton() creates the Delete Button for the Dynamic Items.
         * 
         * @param imageName
         * @parma actionCommand
         * @param associtem
         * @param toolTipText
         * @param altText
         * 
         * @return DeleteItemButton deletebutton
         * 
         */
        protected DeleteItemButton makeDynamicItemDeleteButton(String imageName,
                        String actionCommand, Item associtem, String toolTipText, String altText) {
                
                DeleteItemButton deletebutton = new DeleteItemButton();
                // Look for the image.
                String imgLocation = IMAGES_DIR + imageName + ".png";
                URL imageURL = ReportDesignerPanel.class.getResource(imgLocation);

                // Create and initialize the button.
                deletebutton.setActionCommand(actionCommand);
                deletebutton.setToolTipText(toolTipText);
                deletebutton.addActionListener(this);
                
                if (!isWindows()){
                        deletebutton.setBackground(transparentblue);
                }
                
                deletebutton.setAssociatedItem(associtem);

                if (imageURL != null) { // image found
                        //deletebutton.setIcon(new ImageIcon(imageURL, altText));
                        deletebutton.setIcon(new ImageIcon(imageURL));
                } else { // no image found
                        deletebutton.setText(altText);
                        System.err.println("Resource not found: " + imgLocation);
                }
                
                deletebutton.setText(altText);
                deletebutton.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
                deletebutton.setToolTipText("Delete this report item");
                return deletebutton;
        }
        
        
        public static boolean isWindows() {
                String os = System.getProperty("os.name").toLowerCase();
                return (os.indexOf("win") >= 0);
                
        }
        
        public static boolean isMac() {
                String os = System.getProperty("os.name").toLowerCase();
                return (os.indexOf("mac") >=0);
        }
        
        public static boolean isUnix() {
                String os = System.getProperty("os.name").toLowerCase();
                return (os.indexOf("nix") >=0 || os.indexOf("nux") >=0);
        }

        public void actionPerformed(ActionEvent e) {
                String cmd = e.getActionCommand();
                String delete = "delete";
                String addsection = "add";
                String openroml = "open";
                String openimagefile = "openimagefile";
                                
                if (delete.equals(cmd)) {

                        if (!getReportItemPanels().isEmpty()) {
                                
                                DeleteItemButton deleteButton = (DeleteItemButton) e.getSource();
                                Item itemtodelete = deleteButton.getAssociatedItem();
                                DragAndDropPanel clickedDnDPanel = deleteButton.getAssociatedPanel();
                                DragAndDropPanel prevPanel = getPrevPanel();

                                if (!clickedDnDPanel.equals(prevPanel)) {
                                        prevPanel.deselectPanel();
                                        clickedDnDPanel.selectPanel();
                                        setCurrPanel(clickedDnDPanel);
                                }

                                requestFocusInWindow();
                                
                                setPrevPanel(clickedDnDPanel);
                                
                                clickedDnDPanel.selectPanel();
                
                                deleteItemFromLayout(itemtodelete);
                                
                                // XXX no need to redraw here, since redraw also called 
                                // from renderReportLayout, right?
                                //redrawView();
                                renderReportLayout();
                                
                                // XXX find suitable replacement for hardcode 100
                                //System.out.println("delete occurred, scroll to "+(clickedDnDPanel.getY()+100));
                                Rectangle visibleRect = new Rectangle(0, clickedDnDPanel.getY()+100, 0, 0);
                                layoutpanel.scrollRectToVisible(visibleRect);
                        }


                } else if (addsection.equals(cmd)) {
                        // System.out.println("Add A Section");

                } else if (openroml.equals(cmd)) {

                        this.reportLayout = ReportTest.makeReportLayout();
                        this.renderReportLayout();

                } else if (openimagefile.equals(cmd)) {
                        
                        //TODO it would probably be better to check if the Image ( see
                        // setImageButtonIconfromFile) has changed before rolling revision:
                        reportLayout.setModified(_frame);
                        
                        JRadioButton imageButton = (JRadioButton) e.getSource();
                        DragAndDropPanel imagePanel = (DragAndDropPanel) imageButton
                                .getParent();
                        Item imageitem = imagePanel.getAssociatedItem();
                        imageitem.getValues().clear();
                        JRadioButton button = (JRadioButton) imagePanel.getComponent(0);
                        setImageButtonIconfromFile(button, imageitem);
                }       
        }
        
        
        /**
         * setImageButtonIconfromFile() creates a new icon for a static report item
         * of the type image.  When the user selects an image file from the filesystem,
         * this method creates a new icon using that image.
         * 
         * @param button
         * @parma imageitem
         * 
         */
        private void setImageButtonIconfromFile(JRadioButton button, Item imageitem) {
                
                PtFileChooser fc = new PtFileChooser(_frame, "Choose image", JFileChooser.OPEN_DIALOG);
                String extensions[] = {"gif", "jpg", "jpeg", "png"};
                ExtensionFilenameFilter filter = new ExtensionFilenameFilter(extensions, "images");
                fc.addChoosableFileFilter(filter);
        
                int status = fc.showDialog(_frame, "Open");

                if (status == JFileChooser.APPROVE_OPTION) {
                        File file = fc.getSelectedFile();

                        String imagefilepath = file.getAbsolutePath();

                        ItemValue imageitemvalue = new ItemValue();
                        imageitemvalue.setValue(new StringToken(imagefilepath));
                        imageitem.getValues().add(imageitemvalue);

                        Image image = Toolkit.getDefaultToolkit().getImage(
                                        file.getPath());

                        image = new ImageIcon(image).getImage();

                        image = image.getScaledInstance(42, 42, Image.SCALE_SMOOTH);
                        ImageIcon newicon = new ImageIcon(image);

                        button.setIcon(newicon);

                } else {
                        // System.out.println("Open command cancelled by the user");
                }
        }

        

        /**
         * 
         * clearReportLayout() as it says ... Clears the report Layout object model.
         * 
         */
        private void clearReportLayout() {

                reportLayout.getSections().get(0).getColumns().get(0).getItems()
                                .clear();
        }

        /**
         * 
         * Renders the GUI view of the Report Layout, where each report item
         * is represented by a DragAndDropPanel that contains a reference to it's
         * report item, and that report item's associated values, labels,
         * and properties.  Report items can be Dynamic or Static.
         * Dynamic report items are items that come from the workflow ports
         * or parameters.  Static report items are used for entering static
         * text, images, section headers, and horizontal rules.
         * 
         */
        private void renderReportLayout() {
                
                ///String newtitle = reportLayout.getTitle();
                ///titletxt.setText(newtitle);

                List<Item> inMemoryItemList = null;
        
                getReportItemPanels().clear();
                
                // Get a list of report items from the reportLayout
                inMemoryItemList = reportLayout.getSections().get(0).getColumns()
                                .get(0).getItems();

                for (int i = 0; i < inMemoryItemList.size(); i++) {                     
                        final Item tmpItem = inMemoryItemList.get(i);

                        if (tmpItem instanceof DynamicReportItem) {
                                renderDynamicReportItem(tmpItem);
                        } else if (tmpItem instanceof StaticReportItem) {
                                renderStaticReportItem(tmpItem);
                        }
                }

                redrawView();
        }
        
        //validate();   //These were not needed here, but leaving them in case they are needed at some point in the future.
        //repaint();
        
        /**
         * 
         * renderStaticReportItem() - Renders the Static Report Items
         * 
         *  @param tmpItem
         *  
         *  @return DragAndDropPanel columnPanel
         *  
         *  Note: there is a reason that these are called 'columPanel', this is because
         *  in the Report model these panels represent the last nested element in the
         *  report that represents a 'column'.  Even though we don't have multiple column
         *  layouts in this release.
         *  
         * 
         */
        public DragAndDropPanel renderStaticReportItem(Item tmpItem){
                
                // Note: A panel is added to the list of Panels at the time it
                // is created.
                DragAndDropPanel columnPanel = createDragAndDropPanel();
                columnPanel = createStaticReportItemView(tmpItem, columnPanel);
                columnPanel.setAssociatedItem(tmpItem);
                
                JToolBar toolbar = new JToolBar();
                
                if (!isWindows()){
                        toolbar.setBackground(transparentblue);
                }
                
                toolbar.setFloatable(false);
                toolbar.setBorderPainted(false);

                addDeleteButton(toolbar, tmpItem, columnPanel);
                
                columnPanel.add(BorderLayout.EAST,toolbar);

                DragAndDropPanel prevSelectedPanel = getPrevPanel();

                if (prevSelectedPanel != null) {
                        
                        prevSelectedPanel.deselectPanel();
                        Item itemtodeselect = prevSelectedPanel.getAssociatedItem();
                        itemtodeselect.setSelected(false);
                        setPrevPanel(columnPanel);
                        tmpItem.setSelected(true);
                        columnPanel.selectPanel();
                        setPrevPanel(columnPanel);
                } else {

                        setPrevPanel(columnPanel);
                        tmpItem.setSelected(true);
                        columnPanel.selectPanel();      
                        setPrevPanel(columnPanel);
                }
        
                return columnPanel;
        }
        
        
        /**
         *  createStaticReportItemView - Creates the Views for the Static Report Items.
         *  
         *  @param Item tmpItem
         *  @param DragAndDropPanel columnPanel
         *  
         *  @return DragAndDropPanel columnPanel
         *  
         */
        public DragAndDropPanel createStaticReportItemView(final Item tmpItem,
                        DragAndDropPanel columnPanel) {

                JLabel staticreportItemLabel = new JLabel();
                // staticreportItemLabel.setBackground(buttonbackgroundcolor);
                ReportItemButton staticreportItemButton = new ReportItemButton();
                // staticreportItemButton.setBackground(buttonbackgroundcolor);
                columnPanel.setPropertiesButton(staticreportItemButton);
                staticreportItemButton.setAssociatedPanel(columnPanel);
                ReportItemButtonListener statlistener = new ReportItemButtonListener();
                
                staticreportItemButton.addMouseListener(statlistener);

                List<ItemValue> inMemoryValuesList = null; // init values
                inMemoryValuesList = tmpItem.getValues();
                
                // associates the static report item with its properties
                // that are set from the properties panel.
                staticreportItemButton.setAction(new AbstractAction(tmpItem.getName()) {
                        public void actionPerformed(ActionEvent e) {
                                ref.setSelectedItem(tmpItem);
                                TabManager.getInstance().tabEvent(ref.getParentFrame(),
                                                new ActionEvent(ref, 0, "Properties"));
                        }
                        
                });
                
                
                if (tmpItem instanceof StaticReportItemText) {
                        
                        // Text items may have a list of values.
                        // Typically at this point it is just one value, in a list.

                        if (inMemoryValuesList.size() == 0) {
                                List<ItemValue> initval = new ArrayList<ItemValue>();
                                ItemValue val = new ItemValue();
                                StringToken strvaluetoken = new StringToken();

                                val.setValue(strvaluetoken);
                                initval.add(val);
                                tmpItem.setValues(initval);
                                String strvalue = strvaluetoken.stringValue();
                                columnPanel.setAssociatedItem(tmpItem); 

                                columnPanel = renderTextPanel(columnPanel,
                                                staticreportItemLabel, staticreportItemButton, strvalue);

                        } else {
                                StringToken strtoken = (StringToken) inMemoryValuesList.get(0)
                                                .getValue();
                                String strvalue = strtoken.stringValue();
                                tmpItem.getItemProperties();
                                columnPanel.setAssociatedItem(tmpItem);

                                columnPanel = renderTextPanel(columnPanel,
                                                staticreportItemLabel, staticreportItemButton, strvalue);
                        }

                        columnPanel.setAssociatedItem((StaticReportItemText) tmpItem);

                } else if (tmpItem instanceof StaticReportItemHR) {

                        columnPanel = renderHRPanel(columnPanel, staticreportItemLabel,
                                        staticreportItemButton);
                        columnPanel.setAssociatedItem((StaticReportItemHR) tmpItem);

                } else if (tmpItem instanceof StaticReportItemImage) {

                        columnPanel.setAssociatedItem((StaticReportItemImage) tmpItem);
                        columnPanel = renderImagePanel(tmpItem, columnPanel, staticreportItemLabel,
                                        staticreportItemButton);
                        
                } else if (tmpItem instanceof StaticReportItemSection) {

                        columnPanel.setAssociatedItem((StaticReportItemSection) tmpItem);

                        if (inMemoryValuesList.size() == 0) {
                                List<ItemValue> initval = new ArrayList<ItemValue>();
                                ItemValue val = new ItemValue();
                                StringToken strvaluetoken = new StringToken();
                                val.setValue(strvaluetoken);
                                initval.add(val);
                                tmpItem.setValues(initval);
                                String strvalue = strvaluetoken.stringValue();
                                columnPanel = renderSectionPanel(columnPanel,
                                                staticreportItemLabel, staticreportItemButton, strvalue);

                        } else {
                                StringToken strtoken = (StringToken) inMemoryValuesList.get(0)
                                                .getValue();
                                String strvalue = strtoken.stringValue();
                                tmpItem.getItemProperties();
                                columnPanel = renderSectionPanel(columnPanel,
                                                staticreportItemLabel, staticreportItemButton, strvalue);
                                columnPanel = renderSectionPanel(columnPanel,
                                                staticreportItemLabel, staticreportItemButton, strvalue);

                        }

                }

                if (tmpItem.isSelected()) {
                        columnPanel.selectPanel();
                
                }

                return columnPanel;

        }
        
        
        

        
        /**
         * Data Flavor for the Drag and Drop Data Transfer Handler.
         * 
         * @return dragAndDropPanelDataFlavor
         * 
         */
        public static DataFlavor getDragAndDropPanelDataFlavor() throws Exception {
                if (dragAndDropPanelDataFlavor == null) {
                        dragAndDropPanelDataFlavor = new DataFlavor(
                                        DataFlavor.javaJVMLocalObjectMimeType
                                                        + "; class = org.kepler.reporting.gui.DragAndDropPanel");
                }

                return dragAndDropPanelDataFlavor;

        }

        
        /**
         * Adds an item to the Report Layout model.
         * Used when you add a report item panel.
         * 
         * @param item
         * 
         */
        public void addItemToLayout(Item item) {
                
                reportLayout.getSections().get(0).getColumns().get(0).getItems().add(
                                item);
                
                /// don't call setModified here since everytime a DnD panel
                // is dragged, the entire layout is cleared and rebuilt.        
        }
        
        
        /**
         * Removes an item from the Report Layout.
         * Used when you delete a report item panel.
         * 
         * @param item
         * 
         */
        public void deleteItemFromLayout(Item item) {

                reportLayout.getSections().get(0).getColumns().get(0).getItems()
                                .remove(item);
                reportLayout.setModified(_frame);
        }

        
        /**
         * ArrangePanels is used to re-order the existing panels when you drag and drop them.
         * 
         * This is also used to translate the order of the panels in the GUI to the order of
         * the items in the report model. 
         * 
         * @param columnPanel
         * @param dropYLoc
         * 
         */
        public void arrangePanels(DragAndDropPanel columnPanel, int dropYLoc) {
                
                Item varitem = columnPanel.getAssociatedItem();
                varitem.setSelected(true);

                TreeMap<Integer, DragAndDropPanel> yLocMapForPanels = new TreeMap<Integer, DragAndDropPanel>();
                yLocMapForPanels.put(dropYLoc, columnPanel);
                
                for (DragAndDropPanel dragAndDropPanel : getReportItemPanels()) {
                        // get the y value
                        int y = dragAndDropPanel.getY();

                        // if it is the dropped panel, then skip it
                        if (!dragAndDropPanel.equals(columnPanel)) {
                                yLocMapForPanels.put(y, dragAndDropPanel);
                        }
                }
                
                // clear the previous reportLayout
                clearReportLayout();

                // get the associated report items for each drag and drop panel and
                // create a newly re-ordered list of report items that reflects the 
                // order of the panels. This bit is important because it is what 
                // generates the model.
                for (int i: yLocMapForPanels.keySet()){
                        DragAndDropPanel dragAndDropPanel = yLocMapForPanels.get(i);
                        Item item = dragAndDropPanel.getAssociatedItem();
                        addItemToLayout(item);
                }

                renderReportLayout();
                
                // XXX find suitable replacement for hardcode 100
                // dropYLoc alone wasn't high enough. 
                Rectangle visibleRect = new Rectangle(0, dropYLoc+100, 0, 0);
                layoutpanel.scrollRectToVisible(visibleRect);
        }
        

        // View classes
        
        /**
         * renderTextPanel() - Renders the view for the StaticReportItemText
         * 
         * @param columnPanel
         * @param staticreprotItemLabel
         * @param staticreportItemButton
         * @param strtoken
         * 
         */
        public DragAndDropPanel renderTextPanel(DragAndDropPanel columnPanel,
                        JLabel staticreportItemLabel, JRadioButton staticreportItemButton,
                        String strtoken) {

                staticreportItemButton.setText("");

                URL texticonURL = getIconURL("text3", "png");
                ImageIcon texticon = new ImageIcon(texticonURL);

                staticreportItemButton.setIcon(texticon);
                staticreportItemButton.setCursor(Cursor
                                .getPredefinedCursor(Cursor.HAND_CURSOR));

                TextAreaReporting textPanelTextArea = new TextAreaReporting("", 15, 50);
                textPanelTextArea.setCursor(Cursor.getPredefinedCursor(Cursor.TEXT_CURSOR));

                Item columnpanelitem = columnPanel.getAssociatedItem();
                textPanelTextArea.setAssociatedItem(columnpanelitem);
        textPanelTextArea.setAssociatedPanel(columnPanel);
        
                textPanelTextArea.setLineWrap(true);
                textPanelTextArea.setText(strtoken);
                //textPanelTextArea.setEditable(false);

                TextAreaItemMouseListener textareaMouseListener = new TextAreaItemMouseListener();
                textPanelTextArea.addMouseListener(textareaMouseListener);
                
                TextAreaDocumentListener textAreaDocumentListener = new TextAreaDocumentListener();
                textPanelTextArea.getDocument().addDocumentListener(textAreaDocumentListener);
                //TODO: putting the textPanelTextArea in as a property seems poor:
                textPanelTextArea.getDocument().putProperty("TextAreaReporting", textPanelTextArea);

                textPanelTextArea.setVisible(true);
                JScrollPane txtscroll = new JScrollPane(textPanelTextArea);

                ItemValue textpanelItemValue = new ItemValue();
                List<ItemValue> textpanelItemValuesList = new ArrayList<ItemValue>();
                String textareastring = textPanelTextArea.getText();
                textpanelItemValue.setValue(new StringToken(textareastring));
                textpanelItemValuesList.add(textpanelItemValue);

                columnPanel.add(staticreportItemButton, BorderLayout.WEST);
                columnPanel.add(txtscroll);

                return columnPanel;
        }
        
        
        /**
         * Renders the view for the StaticReportItemHR (Horizontal Rule)
         * 
         * @param columnPanel
         * @param staticreprotItemLabel
         * @param staticreportItemButton
         * 
         * @return columnPanel;
         * 
         */
        public DragAndDropPanel renderHRPanel(DragAndDropPanel columnPanel,
                        JLabel staticreportItemLabel, JRadioButton staticreportItemButton) {

                staticreportItemLabel.setText("Horizontal Rule");
                staticreportItemButton.setText("");

                URL horizontalruleURL = getIconURL("horizontalrule3", "png");
                ImageIcon horzruleicon = new ImageIcon(horizontalruleURL);

                staticreportItemButton.setIcon(horzruleicon);
                staticreportItemButton.setCursor(Cursor
                                .getPredefinedCursor(Cursor.HAND_CURSOR));

                columnPanel.add(staticreportItemButton);
                return columnPanel;
        }
        
        
        /**
         * Renders the view for the StaticReportItemSection (Section)
         * 
         * @param dragAndDropPanel
         * @param staticreprotItemLabel
         * @param staticreportItemButton
         * @param strtoken
         * 
         * @return columnPanel;
         * 
         */
        public DragAndDropPanel renderSectionPanel(DragAndDropPanel dragAndDropPanel,
                        JLabel staticreportItemLabel, JRadioButton staticreportItemButton,
                        String strtoken) {
                staticreportItemLabel.setText("Section");
                Font sectiontitlefont = new Font("SansSerif", Font.BOLD, 14);

                staticreportItemButton.setText("");
                URL sectionURL = getIconURL("sectionheader3", "png");
                ImageIcon sectionheadericon = new ImageIcon(sectionURL);
                staticreportItemButton.setIcon(sectionheadericon);

                staticreportItemButton.setCursor(Cursor
                                .getPredefinedCursor(Cursor.HAND_CURSOR));

                SectionTextReporting sectionheadertext = new SectionTextReporting();
                sectionheadertext.setAssociatedPanel(dragAndDropPanel);
                sectionheadertext.setFont(sectiontitlefont);
                sectionheadertext.setText(strtoken);

                SectionHeaderListener sectionheaderlistener = new SectionHeaderListener();
                sectionheadertext.addMouseListener(sectionheaderlistener);
                
                SectionHeaderDocumentListener sectionHeaderDocumentListener = 
                        new SectionHeaderDocumentListener();
                sectionheadertext.getDocument().addDocumentListener(sectionHeaderDocumentListener);
                //TODO putting sectionheadertext as property seems poor:
                sectionheadertext.getDocument().putProperty("SectionTextReporting", sectionheadertext);
        
                ItemValue sectionheaderitemvalue = new ItemValue();
                List<ItemValue> sectionItemValuesList = new ArrayList<ItemValue>();
                String textareastring = sectionheadertext.getText();
                sectionheaderitemvalue.setValue(new StringToken(textareastring));
                sectionItemValuesList.add(sectionheaderitemvalue);
                
                dragAndDropPanel.add(staticreportItemButton, BorderLayout.WEST);
                dragAndDropPanel.add(sectionheadertext);
                dragAndDropPanel.setPropertiesButton(staticreportItemButton);

                sectionheadertext.setVisible(true);
                sectionheadertext.requestFocus();  // doesn't do anything


                return dragAndDropPanel;
        }
        
        
        /**
         * Renders the view for the StaticReportItemImage (static image)
         *
         * @param dragAndDropPanel
         * @param staticreprotItemLabel
         * @param staticreportItemButton
         *
         * 
         * @return columnPanel;
         */
        public DragAndDropPanel renderImagePanel(Item tmpItem, DragAndDropPanel dragAndDropPanel,
                        JLabel staticreportItemLabel, JRadioButton staticreportItemButton) {
                
                // when we get here if it had a value, then the static reportItemButton
                // already has it's icon, if not, then we use the generic icon for an image
                // static report item.
                
                staticreportItemLabel.setText("Image");
                staticreportItemButton.setText("");
                

                List<ItemValue> tmpURLvalues = tmpItem.getValues();
                
                if (tmpURLvalues.size() != 0) {

                        ItemValue itemValue = tmpURLvalues.get(0);
                        StringToken urlStrToken = (StringToken) itemValue.getValue();
                        String urlStr = urlStrToken.stringValue();

                        Image userassignedimage = null;
                        URL errorURL = getIconURL("error", "png");

                        try {
                                userassignedimage = ImageIO.read(new File(urlStr));

                        } catch (IOException e) {
                                System.out
                                                .println("ReportDesignerPanel renderImagePanel can't read file:"
                                                                + urlStr);
                                try {
                                        urlStr = ImageUtil.decodeToFile(itemValue.getBase64data());
                                        userassignedimage = ImageIO.read(new File(urlStr));

                                } catch (IOException e1) {
                                        try {
                                                userassignedimage = ImageIO.read(errorURL);
                                        } catch (IOException e2) {
                                                // TODO Auto-generated catch block
                                                e2.printStackTrace();
                                        }
                                        e1.printStackTrace();
                                }
                        }

                        userassignedimage = userassignedimage.getScaledInstance(30, 30,
                                        Image.SCALE_SMOOTH);
                        userassignedimage = new ImageIcon(userassignedimage).getImage();

                        userassignedimage = userassignedimage.getScaledInstance(30, 30,
                                        Image.SCALE_SMOOTH);
                        ImageIcon userassignedicon = new ImageIcon(userassignedimage);

                        staticreportItemButton.setIcon(userassignedicon);

                        getimagebtn = new JRadioButton();
                        getimagebtn.setText("Get new image...");

                        URL addfileURL = getIconURL("add3", "png");
                        ImageIcon addicon = new ImageIcon(addfileURL);

                        getimagebtn.setIcon(addicon);

                        getimagebtn.setCursor(Cursor
                                        .getPredefinedCursor(Cursor.HAND_CURSOR));
                        getimagebtn.setActionCommand("openimagefile");
                        getimagebtn.addActionListener(this);
                        // getimagebtn.setBackground(buttonbackgroundcolor); // This is for
                        // the PC
                        getimagebtn.setToolTipText("Browse for image");

                        staticreportItemButton.setCursor(Cursor
                                        .getPredefinedCursor(Cursor.HAND_CURSOR));
                        staticreportItemButton.setToolTipText("View Item Properties");
                        dragAndDropPanel.add(staticreportItemButton, BorderLayout.WEST);
                        dragAndDropPanel.add(getimagebtn);
                } 
                else {
                
                        URL staticimageURL = getIconURL("image3", "png");
                        ImageIcon staticimageicon = new ImageIcon(staticimageURL);
                        staticreportItemButton.setIcon(staticimageicon);

                        getimagebtn = new JRadioButton();
                        getimagebtn.setText("Get image...");

                        URL addfileURL = getIconURL("add3", "png");
                        ImageIcon addicon = new ImageIcon(addfileURL);

                        getimagebtn.setIcon(addicon);

                        getimagebtn.setCursor(Cursor
                                        .getPredefinedCursor(Cursor.HAND_CURSOR));
                        getimagebtn.setActionCommand("openimagefile");
                        getimagebtn.addActionListener(this);

                        staticreportItemButton.setCursor(Cursor
                                        .getPredefinedCursor(Cursor.HAND_CURSOR));
                        dragAndDropPanel.add(staticreportItemButton, BorderLayout.WEST);
                        dragAndDropPanel.add(getimagebtn);
                }
        
                return dragAndDropPanel;
                
        }
        
        
        // Listener classes
        
        public class SectionHeaderDocumentListener implements DocumentListener{

                public void changedUpdate(DocumentEvent e) {                    
                }

                public void insertUpdate(DocumentEvent e) {
                        SectionTextReporting sectiontext = (SectionTextReporting) 
                                e.getDocument().getProperty("SectionTextReporting");
                        StringToken strtoken = new StringToken(sectiontext.getText());
                        ItemValue sectionheadertextvalue = new ItemValue(strtoken);
                        List<ItemValue> sectionheadertextvaluelist = new ArrayList<ItemValue>();
                        sectionheadertextvaluelist.add(sectionheadertextvalue);

                        DragAndDropPanel sectionPanel = (DragAndDropPanel) sectiontext
                                        .getParent();

                        Item item = sectionPanel.getAssociatedItem();

                        item.setValues(sectionheadertextvaluelist);
                        reportLayout.setModified(_frame);
                }

                public void removeUpdate(DocumentEvent e) {
                        SectionTextReporting sectiontext = (SectionTextReporting) 
                        e.getDocument().getProperty("SectionTextReporting");
                        StringToken strtoken = new StringToken(sectiontext.getText());
                        ItemValue sectionheadertextvalue = new ItemValue(strtoken);
                        List<ItemValue> sectionheadertextvaluelist = new ArrayList<ItemValue>();
                        sectionheadertextvaluelist.add(sectionheadertextvalue);

                        DragAndDropPanel sectionPanel = (DragAndDropPanel) sectiontext
                        .getParent();

                        Item item = sectionPanel.getAssociatedItem();

                        item.setValues(sectionheadertextvaluelist);
                        reportLayout.setModified(_frame);
                }
                
        }
        
        
        /**
         * SectionHeaderListener - Mouse Listener for the Section static report item
         */
        public class SectionHeaderListener implements MouseListener {

                public void mouseClicked(MouseEvent e) {
                        
                        SectionTextReporting sectiontext = (SectionTextReporting) e.getSource();
                        
                        DragAndDropPanel sectiontextpanel = sectiontext.getAssociatedPanel();                   
                        DragAndDropPanel prevPanel = getPrevPanel();
                        prevPanel.deselectPanel();
                        sectiontextpanel.selectPanel();
                        sectiontextpanel.getAssociatedItem().setSelected(true);
                        sectiontextpanel.setBorder(new OvalBorder(3, 3, Color.blue, Color.blue));
                        sectiontextpanel.setOpaque(false);
                        sectiontextpanel.setBackground(new Color(6, 128, 255, 129).darker());
                        setCurrPanel(sectiontextpanel);
                        setPrevPanel(sectiontextpanel);
                }
        
                public void mousePressed(MouseEvent e) {
                        
                        SectionTextReporting sectiontext = (SectionTextReporting) e.getSource();
                        DragAndDropPanel clickedDnDPanel = (DragAndDropPanel) sectiontext.getAssociatedPanel();
                        DragAndDropPanel prevPanel = getPrevPanel();
                        
                        if (!clickedDnDPanel.equals(prevPanel)) {

                                        prevPanel.deselectPanel();
                                        
                                        ///clickedDnDPanel.selected = true;
                                        clickedDnDPanel.setBorder(new OvalBorder(3, 3, Color.blue, Color.blue));
                                        clickedDnDPanel.setOpaque(false);
                                        clickedDnDPanel.setBackground(new Color(6, 128, 255, 129).darker()); 
                                        setCurrPanel(clickedDnDPanel);
                                        setPrevPanel(clickedDnDPanel);
                                }
                }

                public void mouseReleased(MouseEvent e) {
                }
                public void mouseEntered(MouseEvent e) {
                }
                public void mouseExited(MouseEvent e) {
                }
                
        }
        
        
        public class TitleDocumentListener implements DocumentListener {

                public void changedUpdate(DocumentEvent e) {
                }
                public void removeUpdate(DocumentEvent e) {
                        try {
                                reportLayout.setTitle(e.getDocument().getText(0, e.getDocument().getLength()));
                                reportLayout.setModified(_frame);
                        } catch (BadLocationException e1) {
                                // TODO Auto-generated catch block
                                e1.printStackTrace();
                        }
                }
                public void insertUpdate(DocumentEvent e) {
                        try {
                                reportLayout.setTitle(e.getDocument().getText(0, e.getDocument().getLength()));
                                reportLayout.setModified(_frame);
                        } catch (BadLocationException e1) {
                                // TODO Auto-generated catch block
                                e1.printStackTrace();
                        }
                }
        }
        

        /**
         * Mouse Listener for the Text area static report item
         */
        public class TextAreaItemMouseListener implements MouseListener {

                public void mouseClicked(MouseEvent e) {

                        TextAreaReporting textareatext = (TextAreaReporting) e.getSource();
                        DragAndDropPanel clickedDnDPanel = (DragAndDropPanel) textareatext.getAssociatedPanel();
                        DragAndDropPanel prevPanel = getPrevPanel();
                        
                        if (!clickedDnDPanel.equals(prevPanel)) {

                                        prevPanel.deselectPanel();
                                        
                                        clickedDnDPanel.getAssociatedItem().setSelected(true);
                                        clickedDnDPanel.selectPanel();
                                        clickedDnDPanel.setBorder(new OvalBorder(3, 3, Color.blue, Color.blue));
                                        clickedDnDPanel.setOpaque(false);
                                        clickedDnDPanel.setBackground(new Color(6, 128, 255, 129).darker()); 
                                        setCurrPanel(clickedDnDPanel);
                                        setPrevPanel(clickedDnDPanel);
                                }
                }

                public void mouseEntered(MouseEvent e) {
                }
                public void mouseExited(MouseEvent e) {
                }
                public void mousePressed(MouseEvent e) {
                }
                public void mouseReleased(MouseEvent e) {
                }
                
        }

        public class TextAreaDocumentListener implements DocumentListener{

                public void changedUpdate(DocumentEvent e) {
                }

                public void insertUpdate(DocumentEvent e) {
                        
                        TextAreaReporting textareatext = 
                                (TextAreaReporting) e.getDocument().getProperty("TextAreaReporting");
                        ///textareatext.setEditable(true);
                        String textFromTextArea = textareatext.getText();

                        if (textFromTextArea.equals("")) {
                                StringToken strtoken = new StringToken("");
                                ItemValue exittext = new ItemValue(strtoken);
                                List<ItemValue> exittextlist = new ArrayList<ItemValue>();
                                exittextlist.add(exittext);
                                Item item = textareatext.getAssociatedItem();
                                item.setValues(exittextlist);
                                reportLayout.setModified(_frame);

                        } else {
                                StringToken strtoken = new StringToken(textFromTextArea);
                                ItemValue exittext = new ItemValue(strtoken);
                                List<ItemValue> exittextlist = new ArrayList<ItemValue>();
                                exittextlist.add(exittext);
                                Item item = textareatext.getAssociatedItem();
                                // item.getValues().clear();
                                item.setValues(exittextlist);
                                reportLayout.setModified(_frame);
                        }
                                
                }

                public void removeUpdate(DocumentEvent e) {
                        
                        TextAreaReporting textareatext = 
                                (TextAreaReporting) e.getDocument().getProperty("TextAreaReporting");
                        ///textareatext.setEditable(true);
                        String textFromTextArea = textareatext.getText();

                        if (textFromTextArea.equals("")) {
                                StringToken strtoken = new StringToken("");
                                ItemValue exittext = new ItemValue(strtoken);
                                List<ItemValue> exittextlist = new ArrayList<ItemValue>();
                                exittextlist.add(exittext);
                                Item item = textareatext.getAssociatedItem();
                                item.setValues(exittextlist);
                                reportLayout.setModified(_frame);

                        } else {
                                StringToken strtoken = new StringToken(textFromTextArea);
                                ItemValue exittext = new ItemValue(strtoken);
                                List<ItemValue> exittextlist = new ArrayList<ItemValue>();
                                exittextlist.add(exittext);
                                Item item = textareatext.getAssociatedItem();
                                // item.getValues().clear();
                                item.setValues(exittextlist);
                                reportLayout.setModified(_frame);
                        }
                        
                }
                
        }
        
        
        /**
         * DeletePanel - deletes a panel when the 'delete panel' button is pressed.
         * 
         * @param deletedPanel
         * @param deletedYLoc
         * 
         */
        public void deletePanel(DragAndDropPanel deletedPanel, int deletedYLoc) {
                
                Map<Integer, DragAndDropPanel> yLocMapForPanels = new HashMap<Integer, DragAndDropPanel>();
                yLocMapForPanels.put(deletedYLoc, deletedPanel);

                for (DragAndDropPanel dragAndDropPanel : getReportItemPanels()) {

                        // if it is the dropped panel, then skip it
                        if (!dragAndDropPanel.equals(deletedPanel)) {
                                // get the y value
                                int y = dragAndDropPanel.getY();
                                yLocMapForPanels.remove(y);
                        }
                }

        }
        
        /**
         * getPrevSelectedPanel - figures out which panel was previously selected, so that we
         * can de-select it, and change the colors, etc.
         * 
         * @param List<DragAndDropPanel> reportpanelslist
         * 
         * @return DragAndDropPanel prevSelectedPanel
         * 
         */
        public DragAndDropPanel getPrevSelectedPanel(
                        List<DragAndDropPanel> reportpanelslist) {

                if (reportpanelslist.size() != 0) {
                        for (int i = 0; i < (reportpanelslist.size()); i++) {

                                DragAndDropPanel panel = reportpanelslist.get(i);

                                if (panel.isSelected()) {
                                        prevSelectedPanel = panel;
                                        currSelectedPanel = panel;
                                        panel.selectPanel();
                                }

                        }
                }

                return prevSelectedPanel;
        }
        
        
        /**
         * getSelectedPanel - figures out which panel is currently selected, so that we
         * can see if it is the same as the previously selected one, and if it isn't the
         * same -- then change the colors, etc.
         * 
         * @param List<DragAndDropPanel> reportpanelslist
         * 
         * @return DragAndDropPanel currSelectedPanel
         * 
         */
        public DragAndDropPanel getSelectedPanel(
                        List<DragAndDropPanel> reportpanelslist) {

                if (!reportpanelslist.isEmpty()) {
                        for (DragAndDropPanel panel: reportpanelslist) {                                
                                if (panel.isSelected()) {
                                        currSelectedPanel = panel;
                                }
                        }
                }

                return currSelectedPanel;
        }


        public void setPrevPanel(DragAndDropPanel prevpanel) {
                prevSelectedPanel = prevpanel;
        }

        public void setPrevSelectedItem(Item prevItem) {
                prevSelectedItem = prevItem;
        }

        public Item getPrevSelectedItem() {
                return prevSelectedItem;
        }

        public void setCurrPanel(DragAndDropPanel currpanel) {
                currSelectedPanel = currpanel;
        }
        
        public void setCurrSelectedItem(Item currItem) {
                thecurrentitem = currItem;
        }

        public Item getCurrSelectedItem() {
                return thecurrentitem;
        }
        
        public DragAndDropPanel getPrevPanel() {
                return prevSelectedPanel;
        }
        
        
        public void dragEnter(DropTargetDragEvent dtde) {

        }

        public void dragExit(DropTargetEvent dte) {

        }

        public void dragOver(DropTargetDragEvent dtde) {
                if (!this.getCursor().equals(droppableCursor)) {
                        this.setCursor(droppableCursor);    // droppableCursor
                }
        
        }

        public void drop(DropTargetDropEvent dtde) {
                
                final int dropYLoc = dtde.getLocation().y;
                
                try {

                        // First we get the transferable proxy from the drop event.

                        Transferable tr = dtde.getTransferable();   // The transfer object is not actually transferring any text, only the JPanel itself is being transferred.

                        // get the named object from the outline
                        NamedObj droppedObj = null;
                        try {
                                List droppedObjects = (List) tr
                                                .getTransferData(PtolemyTransferable.namedObjFlavor);
                                if (droppedObjects != null && droppedObjects.size() > 0) {
                                        droppedObj = (NamedObj) droppedObjects.get(0);
                                        List children = droppedObj.attributeList();
                                        
                                        if (!children.isEmpty()) {
                                                if (
                                                                !(droppedObj instanceof Parameter)
                                                                &&
                                                                !(droppedObj instanceof Port)
                                                                // FIXME if Provenance records the CompositeActor tokens, then we can report on them.
                                                                // see: http://bugzilla.ecoinformatics.org/show_bug.cgi?id=4436
                                                                //&&
                                                                //!(droppedObj.getContainer() instanceof CompositeActor)
                                                                
                                                ) {
                                                        dtde.rejectDrop();
                                                        return;
                                                }
                                        }
                                }
                        } catch (Exception e) {
                                // ignore this - just unsupported data
                        }

                        
                        // mark here to avoid marking on rejectDrop
                        reportLayout.setModified(_frame);
                        
                        
                        ///DropTargetContext c = dtde.getDropTargetContext();
                        
                        // Here it is already a Report Item Panel, and we 
                        // don't need to create a new panel, we just need to re-arrange the
                        // order.
                        
                        if (tr.isDataFlavorSupported(dragAndDropPanelDataFlavor)) {

                                DragAndDropPanel droppedPanel = (DragAndDropPanel) tr
                                                .getTransferData(dragAndDropPanelDataFlavor);
                                getPrevPanel().getAssociatedItem().setSelected(false);
                                getPrevPanel().deselectPanel();
                                droppedPanel.selectPanel();
                                setCurrPanel(droppedPanel);
                                
                                Item anitem = droppedPanel.getAssociatedItem();
                                anitem.setSelected(true);
                                arrangePanels(droppedPanel, dropYLoc);   // renders the report layout
                                dtde.dropComplete(true);
                                
                                return;
                                
                        } else if (!tr.isDataFlavorSupported(dragAndDropPanelDataFlavor)
                                        && (!tr.isDataFlavorSupported(jlabelFlavor))) {
                                // Here it is a NEW Dynamic Item

                                DynamicReportItem dynamicreportItem = new DynamicReportItem();

                                String strItemFullName = (String) tr
                                                .getTransferData(DataFlavor.stringFlavor);

                                if (droppedObj != null) {
                                        strItemFullName = droppedObj.getFullName();
                                }

                                dynamicreportItem.setName(strItemFullName);
                                DragAndDropPanel columnPanel = renderDynamicReportItem(dynamicreportItem);
                                
                            layoutpanel.repaint();
                            
                                getPrevPanel().getAssociatedItem().setSelected(false);
                                getPrevPanel().deselectPanel();
                                columnPanel.selectPanel();
                                arrangePanels(columnPanel, dropYLoc);  // renders the report layout
                                dtde.dropComplete(true);

                                return;

                        } else if (!tr.isDataFlavorSupported(dragAndDropPanelDataFlavor)
                                        && (tr.isDataFlavorSupported(jlabelFlavor))) {
                                 // Here it is not a panel, and it is jlabelFlavor, so it must be
                                 // a static item.
                                
                                /** first we get the transferable in jlabelFlavor */
                                tr.getTransferData(jlabelFlavor);

                                /** get the label that you transferred */
                                JLabel staticreportItemLabel = (JLabel) tr
                                                .getTransferData(jlabelFlavor);

                                /**
                                 * Instantiate a new StaticReportItem for the type that was
                                 * dropped, and then add it to the report layout
                                 */
                                String staticitemname = (String) staticreportItemLabel
                                                .getText();
                                

                                if (staticitemname.equals(StaticReportItemText.TEXT)) {
        
                                        StaticReportItem staticreportItemText = new StaticReportItemText();
                                        DragAndDropPanel columnPanel = renderStaticReportItem(staticreportItemText);
                                        arrangePanels(columnPanel, dropYLoc); // renders the report layout
                                
                                } else if (staticitemname.equals(StaticReportItemHR.HR)) {
                                        
                                        StaticReportItem staticreportItemHR = new StaticReportItemHR();
                                        DragAndDropPanel columnPanel = renderStaticReportItem(staticreportItemHR);
                                        arrangePanels(columnPanel, dropYLoc); // renders the report layout

                                } else if (staticitemname.equals(StaticReportItemImage.IMAGE)) {
                                        
                                        StaticReportItem staticreportItemImage = new StaticReportItemImage();
                                        DragAndDropPanel columnPanel = renderStaticReportItem(staticreportItemImage);
                                        arrangePanels(columnPanel, dropYLoc); // renders the report layout
                                
                                } else if (staticitemname.equals(StaticReportItemSection.SECTION)) {
                                        
                                        StaticReportItem staticreportItemSection = new StaticReportItemSection();
                                        DragAndDropPanel columnPanel = renderStaticReportItem(staticreportItemSection); 
                                        arrangePanels(columnPanel, dropYLoc); // renders the report layout
                                }               
                                
                                //renderReportLayout();  not needed here, is already done in arrangePanels.
                                // leaving it here temporarily for future use if necessary.
                        
                                dtde.dropComplete(true);
                                
                                return;
                        }

                } catch (Exception e) {
                        e.printStackTrace();
                        dtde.rejectDrop();
                }
                
        }


        public void dropActionChanged(DropTargetDragEvent dtde) {
                // don't do anything
        }
        
        
        /**
         * renders a Dynamic Report Item.
         * a Dynamic Report Item represents something that is from the
         * workflow and is recorded by the Provenance recorder.
         * 
         * @param tmpItem
         * 
         * @return DragAndDropPanel columnPanel
         */
        public DragAndDropPanel renderDynamicReportItem(final Item tmpItem) {
                
                // get Dynamic Report Item icon
                URL portIconURL = getIconURL("actor", "gif");
                ImageIcon portIcon = new ImageIcon(portIconURL);
                tmpItem.setIcon(portIcon);

                JLabel dynamicreportItemCenterLabel = new JLabel(tmpItem
                                .getIcon());
                dynamicreportItemCenterLabel.setCursor(Cursor
                                .getPredefinedCursor(Cursor.HAND_CURSOR));
                        
                final String strItemFullName = tmpItem.getName(); 
                
                dynamicreportItemCenterLabel.setToolTipText(strItemFullName);                           
                String strItemShortName = tmpItem.getShortName();

                
                // We are using a radio button here because it
                // provides a 'button' functionality without making us
                // show a square button.
                final ReportItemButton dynamicReportItemButton = new ReportItemButton(
                                strItemShortName, dynamicreportItemCenterLabel.getIcon(), strItemFullName);
                
                dynamicReportItemButton.setToolTipText(strItemFullName);
                
                ReportItemButtonListener dybuttlistener = new ReportItemButtonListener();
                dynamicReportItemButton.addMouseListener(dybuttlistener);
                
                // This creates the panel that represents a dynamic report item.
                DragAndDropPanel dragAndDropPanel = createDynamicReportItemView(
                                tmpItem, dynamicReportItemButton);
                dragAndDropPanel.setAssociatedItem(tmpItem);
                
                dynamicReportItemButton.setAssociatedPanel(dragAndDropPanel);
                
                // This is important because it associates a report item
                // with its properties, that are set from the 'properties panel'                
                dynamicReportItemButton.setAction(new AbstractAction(
                                strItemShortName) {
                        public void actionPerformed(ActionEvent e) {
                                ref.setSelectedItem(tmpItem);
                                TabManager.getInstance().tabEvent(ref.getParentFrame(),
                                                new ActionEvent(ref, 0, "Properties"));
                                dynamicReportItemButton.setToolTipText(strItemFullName);
                                dynamicReportItemButton.setBackground(Color.white);
                        }
                });

                
                dragAndDropPanel.setPropertiesButton(dynamicReportItemButton);
                
                
                requestFocusInWindow();

                // This is used so that we know what to de-select, when
                // the user clicks on a new panel.
                DragAndDropPanel prevSelectedPanel = getPrevPanel();
                if (prevSelectedPanel != null) {
                        prevSelectedPanel.deselectPanel();
                        Item itemtodeselect = prevSelectedPanel.getAssociatedItem();
                        itemtodeselect.setSelected(false);
                        setPrevPanel(dragAndDropPanel);
                        tmpItem.setSelected(true);
                        
                        dragAndDropPanel.selectPanel();
                        setPrevPanel(dragAndDropPanel);

                } else {

                        setPrevPanel(dragAndDropPanel);
                        tmpItem.setSelected(true);
                        dragAndDropPanel.selectPanel();
                }
        
                
                return dragAndDropPanel;
        }
        
        
        /**
         * Mouse Listener for the Report Item Buttons
         */
        public class ReportItemButtonListener implements MouseListener {

                public void mouseClicked(MouseEvent e) {

                        ReportItemButton staticbutton = (ReportItemButton) e.getSource();
                        DragAndDropPanel clickedDnDPanel = (DragAndDropPanel) staticbutton.getAssociatedPanel();
                        DragAndDropPanel prevPanel = getPrevPanel();
                        
                        if (!clickedDnDPanel.equals(prevPanel)) {

                                        prevPanel.deselectPanel();
                                        
                                        clickedDnDPanel.setSelected(true);
                                        clickedDnDPanel.setBorder(new OvalBorder(3, 3, Color.blue, Color.blue));
                                        clickedDnDPanel.setOpaque(false);
                                        clickedDnDPanel.setBackground(new Color(6, 128, 255, 129).darker()); 
                                        setCurrPanel(clickedDnDPanel);
                                        setPrevPanel(clickedDnDPanel);
                                }

                        requestFocusInWindow();
                        
                        //redrawView();                         These are not used, but leaving them in just
                        //renderReportLayout();     in case they become necessary.
                }

                public void mouseEntered(MouseEvent e) {
                        // nothing to do
                }
                public void mouseExited(MouseEvent e) {
                        // nothing to do
                }
                public void mousePressed(MouseEvent e) {
                        // nothing to do
                }
                public void mouseReleased(MouseEvent e) {
                        // nothing to do        
                }
        }
        


        /* Below are all of the methods for the Tab Pane implementation */

        /**
         * Implementation of TabPane getName()
         */
        public String getTabName() {
                return _title;
        }

        /**
         * Implementation of TabPane setParentFrame(TableauFrame)
         */
        public void setParentFrame(TableauFrame parent) {
                _frame = parent;
        }

        /**
         * Implementation of getParentFrame getName()
         */
        public TableauFrame getParentFrame() {
                return _frame;
        }

        /**
         * A factory that creates the library panel for the editors.
         * 
         *@author aaron
         */
        public static class Factory extends TabPaneFactory {
                /**
                 * Create a factory with the given name and container.
                 * 
                 *@param container
                 *            The container.
                 *@param name
                 *            The name of the entity.
                 *@exception IllegalActionException
                 *                If the container is incompatible with this attribute.
                 *@exception NameDuplicationException
                 *                If the name coincides with an attribute already in the
                 *                container.
                 */
                public Factory(NamedObj container, String name)
                                throws IllegalActionException, NameDuplicationException {
                        super(container, name);
                }

                /**
                 * Create a library pane that displays the given library of actors.
                 * 
                 * @return A new LibraryPaneTab that displays the library
                 */
                public TabPane createTabPane(TableauFrame parent) {
                        
                        ReportDesignerPanel rdp = new ReportDesignerPanel(this.getName(),
                                        ((PtolemyFrame) parent).getModel().getName());
                        return rdp;
                }
        }

        
        /**
         * 
         */
        public void handleStateChange(StateChangeEvent event) {
                NamedObj model = ((PtolemyFrame)_frame).getModel();
                if (event instanceof ReportingStateChangeEvent) {
                        ReportingStateChangeEvent reportingEvent = (ReportingStateChangeEvent) event;
                        if (reportingEvent.getChangedState().equals(ReportingStateChangeEvent.REPORT_LAYOUT_CHANGED)) {
                                //System.out.println("report layout changed");
                                
                                NamedObj eventReference = reportingEvent.getReference();
                                KeplerLSID eventRefLSID = NamedObjId.getIdFor(eventReference);
                                KeplerLSID refLSID = NamedObjId.getIdFor(model);
                                
                                if (eventRefLSID.toStringWithoutRevision().equals(refLSID.toStringWithoutRevision())) {
                                        try {
                                                this.initializeTab();
                                        } catch (Exception e) {
                                                // TODO Auto-generated catch block
                                                e.printStackTrace();
                                        }
                                }
                        }
                }
                
                
                if (event.getChangedState().equals(WorkflowRun.WORKFLOWRUN_SELECTED)) {

                        // only show msg if event is from this window
                        if (event.getSource() == (KeplerGraphFrame) this._frame) {

                                if (dontShowDialogCheckBox.isSelected() || 
                                                reportLayout == null || reportLayout.isBlank()) {
                                        showRun(event, model);
                                } else {
                                        int _reply = showDiscardWarning(layoutDiscardWarning);
                                        if (_reply == 0) {
                                                showRun(event, model);
                                        }
                                }
                        }

                }
        }
        
        
        /**
         * 
         * @param event
         * @param reference
         */
        public void showRun(StateChangeEvent event, NamedObj reference) {
                NamedObj namedObj = event.getReference();
                if (namedObj instanceof WorkflowRun) {
                        WorkflowRun wfRun = (WorkflowRun) namedObj;
                        KeplerLSID referenceLSID = NamedObjId.getIdFor(reference);
                        //only change if the event is from this window
                        if (event.getSource() == (KeplerGraphFrame) this._frame){
                                final Integer execId = wfRun.getExecId();
                                //look up the ROML as it was at this execution
                                try {
                                        ReportLayout rl = this.lookupReportLayout(execId);
                                        //if (rl != null) {
                                                WorkflowManager.getInstance().getWorkflow(_frame, referenceLSID).addReportLayout(_frame, rl);
                                                initializeTab();
                                        //}
                                        /*
                                        else{
                                                ////reportitemPanels.clear();
                                                ////redrawView();
                                        }
                                        */
                                } catch (Exception e) {
                                        // TODO Auto-generated catch block
                                        e.printStackTrace();
                                }
                        }
                }
        }
        
        public int showDiscardWarning(String message) {
                Object[] params = { message, dontShowDialogCheckBox };
                int reply = JOptionPane.showConfirmDialog(this._frame, params,
                                "Warning", JOptionPane.YES_NO_OPTION, JOptionPane.WARNING_MESSAGE);
                return reply;
        }

                
        public ReportLayout lookupReportLayout(Integer execId) throws Exception {
                
                ReportLayout rl = null;
                
                // look up the the workflow LSID
                NamedObj reference = ((PtolemyFrame)_frame).getModel();
                KeplerLSID lsid = NamedObjId.getIdFor(reference);
                
                // get the latest execution if there was none given
                if (execId == null) {
                        System.out.println("ReportDesignerPanel lookupReportLayout execId == null ----- does this ever happen????????");
                        execId = ProvenanceUtil.getQueryable(lsid, _frame).getLastExecutionForWorkflow(lsid);
                }
                if (execId == null) {
                        if (_frame != null){
                                String warnMessage = "ReportDesignerPanel lookupReportLayout - No execution history found for this workflow. Please run the workflow.";
                                JOptionPane.showMessageDialog(_frame, warnMessage, "Error",
                        JOptionPane.ERROR_MESSAGE);
                }
                        return rl;
                }
                
                // look up the ROML instance XML in provenance
                Map<String, String> metadataMap = new HashMap<String, String>();
                metadataMap.put("type", ReportLayout.class.getName());
                List<byte[]> dataList = ProvenanceUtil.getQueryable(lsid, _frame).getAssociatedDataForExecution(execId, metadataMap, false);
                if (dataList != null && !dataList.isEmpty()) {
                        rl = ReportRenderer.convertXML2Report(new ByteArrayInputStream(dataList.get(0)));
                }
                return rl;
        }
        
        
        public void windowGainedFocus(WindowEvent e) {
                WorkflowManager.setRankingTableauFrame(_frame);
        }

        public void windowLostFocus(WindowEvent e) {
        }

}