/*************************************************************************
 *
 *  OpenOffice.org - a multi-platform office productivity suite
 *
 *  $RCSfile: AgendaTemplate.java,v $
 *
 *  $Revision: 1.10 $
 *
 *  last change: $Author: kz $ $Date: 2006-07-06 14:13:53 $
 *
 *  The Contents of this file are made available subject to
 *  the terms of GNU Lesser General Public License Version 2.1.
 *
 *
 *    GNU Lesser General Public License Version 2.1
 *    =============================================
 *    Copyright 2005 by Sun Microsystems, Inc.
 *    901 San Antonio Road, Palo Alto, CA 94303, USA
 *
 *    This library is free software; you can redistribute it and/or
 *    modify it under the terms of the GNU Lesser General Public
 *    License version 2.1, as published by the Free Software Foundation.
 *
 *    This library is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *    Lesser General Public License for more details.
 *
 *    You should have received a copy of the GNU Lesser General Public
 *    License along with this library; if not, write to the Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *    MA  02111-1307  USA
 *
 ************************************************************************/package com.sun.star.wizards.agenda;

import java.util.Calendar;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import java.util.Vector;


import com.sun.star.awt.TextEvent;
import com.sun.star.beans.PropertyValue;
import com.sun.star.container.NoSuchElementException;
import com.sun.star.container.XIndexAccess;
import com.sun.star.container.XNamed;
import com.sun.star.frame.XComponentLoader;
import com.sun.star.frame.XTerminateListener;
import com.sun.star.i18n.NumberFormatIndex;
import com.sun.star.lang.Locale;
import com.sun.star.lang.WrappedTargetException;
import com.sun.star.lang.XMultiServiceFactory;
import com.sun.star.table.XCell;
import com.sun.star.table.XTableRows;
import com.sun.star.text.*;
import com.sun.star.uno.Any;
import com.sun.star.uno.UnoRuntime;
import com.sun.star.util.XNumberFormatsSupplier;
import com.sun.star.util.XNumberFormatter;
import com.sun.star.util.XSearchDescriptor;
import com.sun.star.util.XSearchable;
import com.sun.star.wizards.common.FileAccess;
import com.sun.star.wizards.common.Helper;
import com.sun.star.wizards.common.JavaTools;
import com.sun.star.wizards.common.NumberFormatter;
import com.sun.star.wizards.document.OfficeDocument;
import com.sun.star.wizards.text.TextDocument;
import com.sun.star.wizards.text.TextSectionHandler;
import com.sun.star.wizards.ui.UnoDialog2;
import com.sun.star.wizards.ui.event.DataAware;


/**
 *
 * The classes here implement the whole document-functionality of the agenda wizard:
 * the live-preview and the final "creation" of the document, when the user clicks "finish". <br/>
 * <br/>
 * <h2>Some terminology:<h2/>
 * items are names or headings. we don't make any distinction.
 *
 * <br/>
 * The Agenda Template is used as general "controller" of the whole document, whereas the
 * two child-classes ItemsTable and TopicsTable control the item tables (note plural!) and the
 * topics table (note singular).
 * <br/>   <br/>
 * Other small classes are used to abstract the handling of cells and text and we
 * try to use them as components.
 * <br/><br/>
 * We tried to keep the Agenda Template as flexible as possible, though there
 * must be many limitations, because it is generated dynamically.<br/><br/>
 * To keep the template flexible the following decisions were made:<br/>
 * 1. Item tables.<br/>
 * 1.a. there might be arbitrary number of Item tables.<br/>
 * 1.b. Item tables design (bordewr, background) is arbitrary.<br/>
 * 1.c. Items text styles are individual, and use stylelist styles with predefined names.<br/>
 * As result the following limitations:<br/>
 * Pairs of Name->value for each item.<br/>
 * Tables contain *only* those pairs.<br/>
 * 2. Topics table.<br/>
 * 2.a. arbitrary structure.<br/>
 * 2.b. design is arbitrary.<br/>
 * As result the following limitations:<br/>
 * No column merge is allowed.<br/>
 * One compolsary Heading row.<br/>
 * <br/><br/>
 * To let the template be flexible, we use a kind of "detection": we look where
 * the items are read the design of each table, reaplying it after writing the
 * table.
 * <br/><br/>
 * A note about threads:<br/>
 * Many methods here are synchronized, in order to avoid colission made by
 * events fired too often.
 * @author rpiterman
 *
 */
public class AgendaTemplate extends TextDocument implements TemplateConsts, DataAware.Listener
{
    /**
     * resources.
     */
    AgendaWizardDialogResources resources;
    /**
     * data model. This keeps the status of the agenda document, and
     * every redraw is done according to this data.
     * Exception: topic data is written programatically, event-oriented.
     */
    CGAgenda agenda;

    /**
     * the UNO Text Document serrvice
     */
    Object document;

    /**
     * Service Factory
     */
    XMultiServiceFactory docMSF;

    /**
     * The template-filename of the current template.
     * Since we often re-link section and the break the link,
     * inorder to restore them, we need a template to link to.
     * This is practically an identicall copy of the current template.
     */
    String template;

    /**
     * used for common operations on sections.
     */
    TextSectionHandler textSectionHandler;
    /**
     * a component loader.
     */
    XComponentLoader xComponentLoader;

    /**
     * an array containing all ItemTable object (which control each an Items
     * Table in the document.
     */
    ItemsTable[] itemsTables;

    /**
     * the controller of the topics table.
     */
    Topics topics;

    /**
     *  Stores reusable OOo Placeholder TextFields to insert to the document.
     */
    Map itemsCache;
    /**
     * This map is used to find which tables contains a certain Item, so
     * the keys are the different Items, the Objects are the ItemTable controllers.
     * When an Item must be redrawn (because the user checked or uncheced it),
     * the controller is retrieved from this Map, and a redraw is issued on this controller.
     */
    Map itemsMap = new Hashtable(11);

    /**
     * A temporary variable used to list all items and map them.
     */
    List _allItems = new Vector();


    /**
     * keep a reference on some static items in the document,
     * so when their content is changed (through the user), we
     * can just reference them and set their text.
     */
    TextElement teTitle, teDate, teTime, teLocation;
    XTextRange trTitle, trDate, trTime, trLocation;

    /**
     * used to format the date / time.
     */
    int dateFormat, timeFormat;
    XNumberFormatter dateFormatter, timeFormatter;

    /**
     * used to transfare time from VCL to UNO.
     */
    long docNullTime;
    Calendar calendar;

    /**
     * used to set the document title property (step 6).
     */
    private Object docInfo;

    /**
     * loads the given template, and analyze its structure.
     * @param templateURL
     * @param topics
     * @see AgendaTemplate.initialize()
     * @see AgendaTemplate.initializeData()
     */
    public synchronized void load(String templateURL, List topics) {
        template = calcTemplateName(templateURL);
        document = loadAsPreview(templateURL,false);
        docMSF = ((XMultiServiceFactory)UnoRuntime.queryInterface(XMultiServiceFactory.class,document));
        xFrame.getComponentWindow().setEnable(false);
        xTextDocument.lockControllers();
        initialize();
        initializeData(topics);
        xTextDocument.unlockControllers();
    }


    /**
     * The agenda templates are in format of aw-XXX.ott
     * the templates name is then XXX.ott.
     * This method calculates it.
     * @param url
     * @return the template name without the "aw-" at the beginning.
     */
    private String calcTemplateName(String url) {
        return FileAccess.connectURLs( FileAccess.getParentDir(url) ,FileAccess.getFilename(url).substring(3));
    }

    /**
     * synchronize the document to the model.<br/>
     * this method rewrites all titles, item tables , and the topics table-
     * thus synchronizing the document to the data model (CGAgenda).
     * @param topicsData since the model does not contain Topics
     * information (it is only actualized on save) the given list
     * supplies this information.
     */
    private void initializeData(List topicsData) {
        for (int i = 0; i < itemsTables.length; i++) {
            try {
                itemsTables[i].write("");
            }
            catch (Exception ex) {
                ex.printStackTrace();
            }
        }
        redrawTitle("txtTitle");
        redrawTitle("txtDate");
        redrawTitle("txtTime");
        redrawTitle("cbLocation");

        topics.writeAll(topicsData);

        setTemplateTitle(agenda.cp_TemplateName);

    }

    /**
     * redraws/rewrites the table which contains the given item
     * This method is called when the user checks/unchecks an item.
     * The table is being found, in which the item is, and redrawn.
     * @param itemName
     */
    public synchronized void redraw(String itemName) {
        try {
            // get the table in which the item is...
            Object itemsTable =
                itemsMap.get(itemName);
            // rewrite the table.
            ((ItemsTable)itemsTable).write(null);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * update the documents title property to the given title
     * @param newTitle new title.
     */
    synchronized void setTemplateTitle(String newTitle) {
        Helper.setUnoPropertyValue(docInfo, "Title", newTitle );
    }

    /**
     * constructor. The document is *not* loaded here.
     * only some formal members are set.
     * @param xmsf_ service factory.
     * @param agenda_ the data model (CGAgenda)
     * @param resources_ resources.
     */
    AgendaTemplate(XMultiServiceFactory xmsf_, CGAgenda agenda_ , AgendaWizardDialogResources resources_, XTerminateListener listener) {
        super(xmsf_, listener, "WIZARD_LIVE_PREVIEW");

        agenda = agenda_;
        resources = resources_;

        if (itemsCache == null)
            initItemsCache();

        _allItems = null;

    }

    /**
     * checks the data model if the
     * item corresponding to the given string should be shown
     * @param itemName a string representing an Item (name or heading).
     * @return true if the model specifies that the item should be displayed.
     */
    boolean isShowItem(String itemName) {
        if ( itemName.equals(FILLIN_MEETING_TYPE) )
            return agenda.cp_ShowMeetingType;
        else if ( itemName.equals(FILLIN_READ) )
            return agenda.cp_ShowRead;
        else if ( itemName.equals(FILLIN_BRING) )
            return agenda.cp_ShowBring;
        else if ( itemName.equals(FILLIN_NOTES) )
            return agenda.cp_ShowNotes;

        else if ( itemName.equals(FILLIN_FACILITATOR) )
            return agenda.cp_ShowFacilitator;
        else if ( itemName.equals(FILLIN_TIMEKEEPER) )
            return agenda.cp_ShowTimekeeper;
        else if ( itemName.equals(FILLIN_NOTETAKER) )
            return agenda.cp_ShowNotetaker;
        else if ( itemName.equals(FILLIN_PARTICIPANTS) )
            return agenda.cp_ShowAttendees;
        else if ( itemName.equals(FILLIN_CALLED_BY) )
            return agenda.cp_ShowCalledBy;
        else if ( itemName.equals(FILLIN_OBSERVERS) )
            return agenda.cp_ShowObservers;
        else if ( itemName.equals(FILLIN_RESOURCE_PERSONS) )
            return agenda.cp_ShowResourcePersons;
        else throw new IllegalArgumentException("No such item");

    }

    /**
     * itemsCache is a Map containing all agenda item. These are object which
     * "write themselfs" to the table, given a table cursor.
     * A cache is used in order to reuse the objects, instead of recreate them.
     * This method fills the cache will all items objects (names and headings).
     */
    private void initItemsCache() {
        itemsCache = new Hashtable(11);

        XMultiServiceFactory xmsf = (XMultiServiceFactory)UnoRuntime.queryInterface(XMultiServiceFactory.class,document);
        // Headings

        itemsCache.put( FILLIN_MEETING_TYPE     ,
                new AgendaItem(FILLIN_MEETING_TYPE, new TextElement(  resources.itemMeetingType , STYLE_MEETING_TYPE ) ,
                new PlaceholderElement( STYLE_MEETING_TYPE_TEXT , resources.reschkMeetingTitle_value , resources.resPlaceHolderHint, xmsf ) ) );

        itemsCache.put( FILLIN_BRING        ,
                new AgendaItem( FILLIN_BRING,new TextElement(  resources.itemBring  , STYLE_BRING ) ,
                        new PlaceholderElement( STYLE_BRING_TEXT , resources.reschkBring_value , resources.resPlaceHolderHint, xmsf ) ) );

        itemsCache.put( FILLIN_READ     ,
                new AgendaItem( FILLIN_READ, new TextElement( resources.itemRead    , STYLE_READ ) ,
                        new PlaceholderElement( STYLE_READ_TEXT , resources.reschkRead_value , resources.resPlaceHolderHint, xmsf ) ) );

        itemsCache.put( FILLIN_NOTES        ,
                new AgendaItem(  FILLIN_NOTES, new TextElement( resources.itemNote , STYLE_NOTES ) ,
                        new PlaceholderElement( STYLE_NOTES_TEXT , resources.reschkNotes_value , resources.resPlaceHolderHint, xmsf ) ) );

        // Names

        itemsCache.put( FILLIN_CALLED_BY    ,
                new AgendaItem( FILLIN_CALLED_BY, new TextElement( resources.itemCalledBy   , STYLE_CALLED_BY ) ,
                        new PlaceholderElement( STYLE_CALLED_BY_TEXT , resources.reschkConvenedBy_value , resources.resPlaceHolderHint, xmsf ) ) );

        itemsCache.put( FILLIN_FACILITATOR  ,
                new AgendaItem( FILLIN_FACILITATOR, new TextElement( resources.itemFacilitator  , STYLE_FACILITATOR ) ,
                        new PlaceholderElement( STYLE_FACILITATOR_TEXT , resources.reschkPresiding_value , resources.resPlaceHolderHint, xmsf ) ) );

        itemsCache.put( FILLIN_PARTICIPANTS,
                new AgendaItem( FILLIN_PARTICIPANTS, new TextElement( resources.itemAttendees , STYLE_PARTICIPANTS ) ,
                        new PlaceholderElement( STYLE_PARTICIPANTS_TEXT , resources.reschkAttendees_value , resources.resPlaceHolderHint, xmsf )) );

        itemsCache.put( FILLIN_NOTETAKER    ,
                new AgendaItem( FILLIN_NOTETAKER,new TextElement(  resources.itemNotetaker, STYLE_NOTETAKER )  ,
                        new PlaceholderElement( STYLE_NOTETAKER_TEXT , resources.reschkNoteTaker_value , resources.resPlaceHolderHint, xmsf ) ) );

        itemsCache.put( FILLIN_TIMEKEEPER   ,
                new AgendaItem( FILLIN_TIMEKEEPER, new TextElement( resources.itemTimekeeper , STYLE_TIMEKEEPER )  ,
                        new PlaceholderElement( STYLE_TIMEKEEPER_TEXT , resources.reschkTimekeeper_value , resources.resPlaceHolderHint, xmsf ) ) );

        itemsCache.put( FILLIN_OBSERVERS    ,
                new AgendaItem( FILLIN_OBSERVERS,new TextElement( resources.itemObservers   , STYLE_OBSERVERS ),
                        new PlaceholderElement( STYLE_OBSERVERS_TEXT , resources.reschkObservers_value , resources.resPlaceHolderHint, xmsf ) ) );

        itemsCache.put( FILLIN_RESOURCE_PERSONS ,
                new AgendaItem( FILLIN_RESOURCE_PERSONS, new TextElement( resources.itemResource    , STYLE_RESOURCE_PERSONS )  ,
                        new PlaceholderElement( STYLE_RESOURCE_PERSONS_TEXT , resources.reschkResourcePersons_value , resources.resPlaceHolderHint, xmsf ) ) );

    }

    /**
     * Initializes a template.<br/>
     * This method does the following tasks:<br/>
     * Get a Time and Date format for the document, and retrieve the null date of the document (which is
     * document-specific).<br/>
     * Initializes the Items Cache map.
     * Analyses the document:<br/>
     * -find all "fille-ins" (apear as &gt;xxx&lt; in the document).
     * -analyze all items sections (and the tables in them).
     * -locate the titles and actualize them
     * -analyze the topics table
     */
    private void initialize()
    {
        /*
         * Get the default locale of the document, and create the date and time formatters.
         */
        XMultiServiceFactory docMSF = (XMultiServiceFactory)UnoRuntime.queryInterface(XMultiServiceFactory.class,document);
        try {
            Object defaults = docMSF.createInstance("com.sun.star.text.Defaults");
            Locale  l = (Locale) Helper.getUnoStructValue(defaults, "CharLocale");

            java.util.Locale jl = new java.util.Locale(
                    l.Language , l.Country, l.Variant );

            calendar = Calendar.getInstance(jl);

            XNumberFormatsSupplier nfs = (XNumberFormatsSupplier)UnoRuntime.queryInterface(XNumberFormatsSupplier.class,document);
            Object formatSettings = nfs.getNumberFormatSettings();
            com.sun.star.util.Date date = (com.sun.star.util.Date)Helper.getUnoPropertyValue( formatSettings, "NullDate");

            calendar.set(date.Year, date.Month - 1 , date.Day);

            docNullTime = JavaTools.getTimeInMillis(calendar);

            dateFormat = NumberFormatter.getNumberFormatterKey( nfs, NumberFormatIndex.DATE_SYSTEM_LONG );
            timeFormat = NumberFormatter.getNumberFormatterKey( nfs, NumberFormatIndex.TIME_HHMM );


            dateFormatter = NumberFormatter.createNumberFormatter(xMSF, nfs );
            timeFormatter = NumberFormatter.createNumberFormatter(xMSF, nfs );
        }
        catch (Exception ex) {
            ex.printStackTrace();
            throw new NullPointerException ("Fatal Error: could not initialize locale or date/time formats.");
        }

        /*
         * get the document info object.
         */
        docInfo = OfficeDocument.getDocumentInfo(document);

        initItemsCache();
        initializeItems();
        initializeTitles();
        initializeItemsSections();
        XMultiServiceFactory xMultiServiceFactory = (XMultiServiceFactory)UnoRuntime.queryInterface(XMultiServiceFactory.class,document);
        textSectionHandler = new TextSectionHandler(xMultiServiceFactory, (XTextDocument)UnoRuntime.queryInterface(XTextDocument.class,document));
        initializeTopics();
        _allItems.clear();
        _allItems = null;
    }

    /**
     * locates the titles (name, location, date, time) and saves a reference to thier Text ranges.
     *
     */
    private void initializeTitles() {
        XTextRange item = null;

        XMultiServiceFactory xmsf = (XMultiServiceFactory)UnoRuntime.queryInterface(XMultiServiceFactory.class,document);

        for (int i = 0; i < _allItems.size(); i++) {
            item = (XTextRange)_allItems.get(i);
            String text = item.getString().trim().toLowerCase();
            if (text.equals(FILLIN_TITLE)) {

                teTitle = new PlaceholderTextElement(item, resources.resPlaceHolderTitle, resources.resPlaceHolderHint, xmsf);
                trTitle = item;
                _allItems.remove(i--);
            }
            else if (text.equals(FILLIN_DATE)) {
                teDate = new PlaceholderTextElement(item, resources.resPlaceHolderDate, resources.resPlaceHolderHint, xmsf);
                trDate = item;
                _allItems.remove(i--);
            }
            else if (text.equals(FILLIN_TIME)) {
                teTime = new PlaceholderTextElement(item, resources.resPlaceHolderTime, resources.resPlaceHolderHint, xmsf);
                trTime = item;
                _allItems.remove(i--);
            }
            else if (text.equals(FILLIN_LOCATION)) {
                teLocation = new PlaceholderTextElement(item, resources.resPlaceHolderLocation, resources.resPlaceHolderHint, xmsf);
                trLocation = item;
                _allItems.remove(i--);
            }
        }
    }

    private void initializeTopics()
    {
        topics = new Topics();
    }

    private void initializeItems()
    {
        _allItems = searchFillInItems();
    }

    /**
     * searches the document for items in the format "&gt;*&lt;"
     * @return a vector containing the XTextRanges of the found items
     */
    private List searchFillInItems() {
        try {
            XSearchable xSearchable = (XSearchable)UnoRuntime.queryInterface(XSearchable.class,document);
            XSearchDescriptor sd = xSearchable.createSearchDescriptor();
            sd.setSearchString("<[^>]+>");
            sd.setPropertyValue("SearchRegularExpression", Boolean.TRUE);
            sd.setPropertyValue("SearchWords", Boolean.TRUE);

            XIndexAccess ia = xSearchable.findAll(sd);

            List l = new Vector(ia.getCount());
            for (int i = 0; i<ia.getCount(); i++) {
                try {
                    l.add((XTextRange)UnoRuntime.queryInterface(XTextRange.class,ia.getByIndex(i)));
                } catch (Exception ex) {
                    System.err.println("Nonfatal Error in finding fillins.");
                }
            }
            return l;
        }
        catch (Exception ex) {
            ex.printStackTrace();
            throw new IllegalArgumentException("Fatal Error: Loading template failed: searching fillins failed");
        }
    }

    /**
     * analyze the item sections in the template. delegates the analyze of each table to the
     * ItemsTable class.
     */
    private void initializeItemsSections()
    {
        String[] sections = getSections(document, TemplateConsts.SECTION_ITEMS);

        // for each section - there is a table...
        itemsTables = new ItemsTable[sections.length];

        for (int i = 0; i < itemsTables.length; i++) {
            try {
                itemsTables[i] = new ItemsTable(getSection(sections[i]), getTable(sections[i]));
            }
            catch (Exception ex) {
                ex.printStackTrace();
                throw new IllegalArgumentException("Fatal Error while initialilzing Template: items table in section " + sections[i]);
            }
        }

    }

    private String[] getSections(Object document, String s)
    {
        XTextSectionsSupplier xTextSectionsSupplier = (XTextSectionsSupplier) UnoRuntime.queryInterface(XTextSectionsSupplier.class, document);
        String[] allSections = xTextSectionsSupplier.getTextSections().getElementNames();
        return getNamesWhichStartWith(allSections, s);
    }


    Object getSection(String name) throws NoSuchElementException, WrappedTargetException
    {
        XTextSectionsSupplier xTextSectionsSupplier = (XTextSectionsSupplier) UnoRuntime.queryInterface(XTextSectionsSupplier.class, document);
        return ((Any)(xTextSectionsSupplier.getTextSections().getByName(name))).getObject();
    }

    Object getTable(String name) throws NoSuchElementException, WrappedTargetException
    {
        XTextTablesSupplier xTextTablesSupplier = (XTextTablesSupplier) UnoRuntime.queryInterface(XTextTablesSupplier.class, document);
        return ((Any)xTextTablesSupplier.getTextTables().getByName(name)).getObject();
    }

    /**
     * implementation of DataAware.Listener, is
     * called when title/date/time or location are
     * changed.
     */
    public synchronized void eventPerformed(Object param) {
        TextEvent te = (TextEvent)param;
        String controlName = (String)Helper.getUnoPropertyValue(
                UnoDialog2.getModel(te.Source),
                "Name");
        redrawTitle(controlName);

    }

    private synchronized void redrawTitle(String controlName) {
        if (controlName.equals("txtTitle"))
            writeTitle(teTitle, trTitle, agenda.cp_Title);
        else if (controlName.equals("txtDate")) {
            writeTitle(teDate, trDate, getDateString(agenda.cp_Date));}
        else if (controlName.equals("txtTime"))
            writeTitle(teTime, trTime, getTimeString(agenda.cp_Time));
        else if (controlName.equals("cbLocation"))
            writeTitle(teLocation, trLocation, agenda.cp_Location);
        else throw new IllegalArgumentException("No such title control...");
    }


    private void writeTitle( TextElement te, XTextRange tr, String text) {
        te.text = (text == null ? "" : text);
        te.write(tr);
    }
    private static long DAY_IN_MILLIS = ( 24 * 60 * 60 * 1000 );

    private String getDateString(String d) {
        if (d == null || d.equals(""))
            return "";

        int date = new Integer(d).intValue();
        calendar.clear();
        calendar.set( date / 10000 ,
                    ( date % 10000 ) / 100 - 1 ,
                      date % 100 ) ;

        long date1 = JavaTools.getTimeInMillis(calendar);
        /*
         * docNullTime and date1 are in millis, but
         * I need a day...
         */
        double daysDiff = ( date1 - docNullTime ) / DAY_IN_MILLIS + 1;

        return dateFormatter.convertNumberToString(dateFormat, daysDiff);
    }

    private String getTimeString(String s) {
        if (s == null || s.equals(""))
            return "";
        int time = new Integer(s).intValue();

        double t = ( (double) ( time / 1000000 ) / 24 ) + ( (double) ( ( time % 1000000 ) / 1000 ) / ( 24 * 60 ) );
        return timeFormatter.convertNumberToString(timeFormat, t);
    }


    /* *******************************************
     *  F I N I S H
     *********************************************/

    /** the user clicked finish **/
    public synchronized void finish(List topics) {
        createMinutes(topics);
        deleteHiddenSections();
        textSectionHandler.removeAllTextSections();
    }

    /**
     * hidden sections exist when an item's section is hidden because the
     * user specified not to display any items which it contains.
     * When finishing the wizard removes this sections entireley from the document.
     */
    private void deleteHiddenSections() {
        XTextSectionsSupplier xTextSectionsSupplier = (XTextSectionsSupplier) UnoRuntime.queryInterface(XTextSectionsSupplier.class, document);
        String[] allSections = xTextSectionsSupplier.getTextSections().getElementNames();
        try {
            for (int i = 0; i<allSections.length; i++) {
                Object section = getSection(allSections[i]);
                //Try3.showProps(section);
                boolean visible = ((Boolean)Helper.getUnoPropertyValue(section,"IsVisible")).booleanValue();
                if ( !visible )
                    ((XTextContent)UnoRuntime.queryInterface(XTextContent.class,section)).getAnchor().setString("");


            }
        }
        catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    /**
     * create the minutes for the given topics or remove the minutes section from the document.
     * If no topics are supplied, or the user
     * specified not to create minuts, the minutes section will be removed,
     * @param topicsData supplies PropertyValue arrays containing the values for the topics.
     */
    public synchronized void createMinutes(List topicsData) {

        // if the minutes section should be removed (the
        // user did not check "create minutes")
        if (!agenda.cp_IncludeMinutes || (topicsData.size() <= 1)) {
            try {
                Object minutesAllSection = getSection(SECTION_MINUTES_ALL);
                XTextSection xTextSection = (XTextSection)UnoRuntime.queryInterface(XTextSection.class,minutesAllSection);
                xTextSection.getAnchor().setString("");
            }
            catch (Exception ex) {
                ex.printStackTrace();
            }
        }
        // the user checked "create minutes"
        else {
            try {
                String itemText;
                XTextRange item;
                int topicStartTime = 0;
                try {
                    topicStartTime = new Integer(agenda.cp_Time).intValue();
                }
                catch (Exception ex) {}

                String time;

                // first I replace the minutes titles...
                List items = searchFillInItems();
                for ( int itemIndex = 0; itemIndex < items.size(); itemIndex++) {
                    item = (XTextRange)items.get(itemIndex);
                    itemText = item.getString().trim().toLowerCase();

                    if ( itemText.equals( FILLIN_MINUTES_TITLE ))
                        fillMinutesItem( item , agenda.cp_Title , resources.resPlaceHolderTitle);
                    else if ( itemText.equals( FILLIN_MINUTES_LOCATION))
                        fillMinutesItem( item , agenda.cp_Location  , resources.resPlaceHolderLocation);
                    else if ( itemText.equals( FILLIN_MINUTES_DATE ))
                        fillMinutesItem( item , getDateString ( agenda.cp_Date ) , resources.resPlaceHolderDate );
                    else if ( itemText.equals( FILLIN_MINUTES_TIME ))
                        fillMinutesItem( item , getTimeString ( agenda.cp_Time ) , resources.resPlaceHolderTime );
                }

                items.clear();

                /*
                 * now add minutes for each topic.
                 * The template contains *one* minutes section, so
                 * we first use the one available, and then add a new one...
                 *
                 * topics data has *always* an empty topic at the end...
                 */
                for (int i = 0; i < topicsData.size() - 1; i++) {
                    PropertyValue[] topic = (PropertyValue[])topicsData.get(i);

                    items = searchFillInItems();
                    for ( int itemIndex = 0; itemIndex < items.size(); itemIndex++) {
                        item = (XTextRange)items.get(itemIndex);
                        itemText = item.getString().trim().toLowerCase();

                        if ( itemText.equals( FILLIN_MINUTE_NUM ))
                            fillMinutesItem( item , topic[0].Value , "");
                        else if ( itemText.equals( FILLIN_MINUTE_TOPIC ))
                            fillMinutesItem( item , topic[1].Value , "" );
                        else if ( itemText.equals( FILLIN_MINUTE_RESPONSIBLE ))
                            fillMinutesItem( item , topic[2].Value , ""  );
                        else if ( itemText.equals( FILLIN_MINUTE_TIME )) {
                            int topicTime = 0;

                            try {
                                topicTime = (new Integer((String)topic[3].Value)).intValue();
                            }
                            catch (Exception ex) {}
                            // if the topic has no time, we do not display any time here.
                            if (topicTime == 0 || topicStartTime == 0)
                                time = (String)topic[3].Value;
                            else {
                                time = getTimeString( String.valueOf(topicStartTime) ) + " - ";
                                topicStartTime += topicTime * 1000;
                                time += getTimeString( String.valueOf(topicStartTime ) );
                            }
                            fillMinutesItem( item , time , "" );
                        }
                    }

                    textSectionHandler.removeTextSectionbyName( SECTION_MINUTES );

                    // after the last section we do not insert a new one.
                    if ( i < topicsData.size() - 2 )
                        textSectionHandler.insertTextSection( SECTION_MINUTES , template, false);

                }
            }
            catch (Exception ex) {
                ex.printStackTrace();
            }
        }
    }

    /**
     * given a text range and a text, fills the given
     * text range with the given text.
     * If the given text is empty, uses a placeholder with the giveb placeholder text.
     * @param range text range to fill
     * @param text the text to fill to the text range object.
     * @param placeholder the placeholder text to use, if the text argument is empty (null or "")
     */
    private void fillMinutesItem(XTextRange range, Object text, String placeholder) {
        String paraStyle = (String)Helper.getUnoPropertyValue(range,"ParaStyleName");
        range.setString((String)text);
        Helper.setUnoPropertyValue(range,"ParaStyleName",paraStyle);
        if (text == null || text.equals("")) {
            if ( placeholder!=null && !placeholder.equals("")) {
                XTextContent placeHolder = createPlaceHolder(docMSF, placeholder, resources.resPlaceHolderHint);
                try {
                    range.getStart().getText().insertTextContent(range.getStart(),placeHolder,true);
                }
                catch (Exception ex) {
                    ex.printStackTrace();
                }
            }

        }
    }

    /**
     * creates a placeholder field with the given text and given hint.
     * @param xmsf service factory
     * @param ph place holder text
     * @param hint hint text
     * @return the place holder field.
     */
    public static XTextContent createPlaceHolder(XMultiServiceFactory xmsf, String ph, String hint) {
        Object placeHolder;
        try {
            placeHolder = xmsf.createInstance("com.sun.star.text.TextField.JumpEdit");
        }
        catch (Exception ex) {
            ex.printStackTrace();
            return null;
        }
        Helper.setUnoPropertyValue(placeHolder, "PlaceHolder", ph);
        Helper.setUnoPropertyValue(placeHolder, "Hint", hint);
        Helper.setUnoPropertyValue(placeHolder, "PlaceHolderType", new Short(PlaceholderType.TEXT));
        return  (XTextContent)UnoRuntime.queryInterface(XTextContent.class,placeHolder);

    }

    /*
     * $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
     * =================================
     *  The ItemTable class
     * =================================
     * $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
     */



    public class ItemsTable  {

        Object table;
        Object section;

        /**
         * the items in the table.
         */
        List items = new Vector(6);


        public ItemsTable(Object section_, Object table_) {

            table = table_;
            section = section_;

            AgendaItem ai;
            XTextRange item;
            String iText;

            /* go through all <*> items in the document
             * and each one if it is in this table.
             * If they are, register them to belong here, notice their order
             * and remove them from the list of all <*> items, so the next
             * search will be faster.
             */
            for (int i = 0; i < _allItems.size(); i++) {
                item = (XTextRange)_allItems.get(i);
                Object t = Helper.getUnoPropertyValue(item,"TextTable");
                if ( ( t instanceof Any  ) &&  ((Any)t).getObject() == table) {
                    iText = item.getString().toLowerCase().trim();
                    ai = (AgendaItem)itemsCache.get(item.getString().toLowerCase().trim());
                    if (ai != null) {
                        items.add(ai);
                        _allItems.remove(i--);
                        itemsMap.put(iText,this);
                    }
                }
            }

        }

        /**
         * link the section to the template. this will restore the original table
         * with all the items.<br/>
         * then break the link, to make the section editable.<br/>
         * then, starting at cell one, write all items that should be visible.
         * then clear the rest and remove obsolete rows.
         * If no items are visible, hide the section.
         * @param dummy we need a param to make this an Implementation of AgendaElement.
         * @throws Exception
         */
        public synchronized void write(Object dummy) throws Exception {
            synchronized (this) {
            String name = getName(section);

            // link and unlink the section to the template.
            textSectionHandler.linkSectiontoTemplate(section,template,name);
            textSectionHandler.breakLinkOfTextSection(section);

            // we need to get a new instance after linking.
            table = getTable(name);
            section = getSection(name);

            XTextTable xTextTable = (XTextTable)UnoRuntime.queryInterface(XTextTable.class,table);
            XTextTableCursor cursor = xTextTable.createCursorByCellName("A1");
            AgendaItem ai ;
            // should this section be visible?
            boolean visible = false;

            // write items
            // ===========
            String cellName = "";

            /* now go through all items that belong to this
             * table. Check each one agains the model. If it should
             * be display, call it's write method.
             * All items are of type AgendaItem which means they write
             * two cells to the table: a title (text) and a placeholder.
             * see AgendaItem class below.
             */
            for (int i = 0; i < items.size(); i++) {
                ai = (AgendaItem)items.get(i);
                if (isShowItem(ai.name)) {
                    visible = true;
                    ai.table = table;
                    ai.write(cursor);
                    // I store the cell name which was last written...
                    cellName = cursor.getRangeName();

                    cursor.goRight((short)1,false);

                }
            }

            Helper.setUnoPropertyValue(section,"IsVisible",visible ? Boolean.TRUE : Boolean.FALSE);
            if (!visible)
                return;

            /* remove obsolete rows
             * ====================
             * if the cell that was last written is the current cell,
             * it means this is the end of the table, so we end here.
             * (because after getting the cellName above, I call the goRight method.
             * If it did not go right, it means its the last cell.
             */
            if (cellName.equals(cursor.getRangeName()))
                return;
            /*
             * if not, we continue and clear all cells until we are at the end of the row.
             */
            Object cell;
            while (  ( !cellName.equals(cursor.getRangeName())  && ( ! cursor.getRangeName().startsWith("A"))) ) {
                cell = xTextTable.getCellByName(cursor.getRangeName());
                ((XTextRange)UnoRuntime.queryInterface(XTextRange.class,cell)).setString("");
                cellName = cursor.getRangeName();
                cursor.goRight((short)1,false);
            }

            /*
             * again: if we are at the end of the table, end here.
             */
            if (cellName.equals(cursor.getRangeName()))
                return;


            int rowIndex = getRowIndex(cursor);
            int rowsCount = getRowCount((XTextTable)UnoRuntime.queryInterface(XTextTable.class,table));

            /* now before deleteing i move the cursor up so it
             * does not disappear, because it will crash office.
             */
            cursor.gotoStart(false);

            if (rowsCount >= rowIndex)
                removeTableRows(table, rowIndex - 1, ( rowsCount - rowIndex ) + 1);
            }
        }
    }

    /*
     * $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
     * =================================
     *  The Topics class
     * =================================
     * $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
     */


    /**
     * This class handles the preview of the topics table.
     * You can call it the controller of the topics table.
     * It differs from ItemsTable in that it has no data model -
     * the update is done programttically.<br/>
     * <br/>
     * The decision to make this class a class by its own
     * was done out of logic reasons and not design/functionality reasons,
     * since there is anyway only one instance of this class at runtime
     * it could have also be implemented in the AgendaTemplate class
     * but for clarity and separation I decided to make a sub class for it.
     *
     * @author rp143992
     */
    public class Topics {
        /**
         * the topics table
         */
        XTextTable table;

        /**
         * A List of Cell Formatters for the first row.
         */
        List firstRowFormat = new Vector();

        /**
         * A List of Cell Formatters for the last row.
         * (will contain them in reverse order)
         */
        List lastRowFormat = new Vector();

        /**
         * the format of the cell of each topic cell.
         */
        List topicCellFormats = new Vector();

        /**
         * for each topic cell there is
         * a member in this vector
         */
        List topicCells = new Vector();

        int rowsPerTopic;

        /**
         * fields which hold the number of the
         * fillins in the cells vectors.
         */
        int numCell = -1;
        int topicCell = -1;
        int responsibleCell = -1;
        int timeCell = -1;

        /**
         * this is a list which traces which topics were written to the document
         * and which not. When a cell needs to be actualized, it is checked that the
         * whole topic is already present in the document, using this vector.
         * The vector contains nulls for topics which were not written, and
         * empty strings for topics which were written (though any other
         * object would also do - i check only if it is a null or not...);
         */
        List writtenTopics = new Vector();


        /**
         * Analyze the structure of the Topics table.
         * The structure Must be as follows:<br>
         * -One Header Row. <br>
         * -arbitrary number of rows per topic <br>
         * -arbitrary content in the topics row <br>
         * -only soft formatting will be restored. <br>
         * -the topic rows must repeat three times. <br>
         * -in the topics rows, placeholders for number, topic, responsible, and duration
         * must be placed.<br>
         * <br>
         * A word about table format: to reconstruct the format of the
         * table we hold to the following formats: first row (header), topic, and last row.
         * We hold the format of the last row, because one might wish to give it
         * a special format, other than the one on the bottom of each topic.
         * The left and right borders of the whole table are, on the other side,
         * part of the topics rows format, and need not be preserved seperateley.
         */
        public Topics()
        {
            Object t;

            Map topicItems = new Hashtable(4);

            // This is the topics table. say hallo :-)
            try {
                t = getTable(SECTION_TOPICS);
            }
            catch (Exception ex) {
                ex.printStackTrace();
                throw new IllegalArgumentException("Fatal error while loading template: table " + SECTION_TOPICS + " could not load.");
            }

            // and this is the XTable.
            table = ((XTextTable)UnoRuntime.queryInterface(XTextTable.class,t));

            /* first I store all <*> ranges
             * which are in the topics table.
             * I store each <*> range in this - the key
             * is the cell it is in. Later when analyzing the topic,
             * cell by cell, I check in this map to know
             * if a cell contains a <*> or not.
             */
            Hashtable items = new Hashtable();

            XTextRange item;
            Object cell;
            for (int i = 0; i < _allItems.size(); i++) {
                item = (XTextRange)_allItems.get(i);
                t = Helper.getUnoPropertyValue(item,"TextTable");
                if ( ( t instanceof Any  ) &&  ((Any)t).getObject() == table) {
                    cell = Helper.getUnoPropertyValue(item,"Cell");
                    items.put(((Any)cell).getObject(),item);
                }
            }

            /*
             * in the topics table, there are always one
             * title row and three topics defined.
             * So no mutter how many rows a topic takes - we
             * can restore its structure and format.
             */
            int rows = getRowCount(table);

            rowsPerTopic= (rows - 1) / 3;

            String firstCell = "A" + (1 + rowsPerTopic + 1);
            String afterLastCell = "A" + (1 + ( rowsPerTopic * 2 ) + 1);

            // go to the first row of the 2. topic
            XTextTableCursor cursor = table.createCursorByCellName(firstCell);
            XTextRange range;

            // analyze the structure of the topic rows.
            while ( !cursor.getRangeName().equals(afterLastCell) ) {
                cell = table.getCellByName(cursor.getRangeName());
                XTextRange xTextRange = (XTextRange)UnoRuntime.queryInterface(XTextRange.class,cell);
                // first I store the content and para style of the cell
                AgendaElement ae = new TextElement(xTextRange);
                // if the cell contains a relevant <...>
                // i add the text element to the hash,
                // so it's text can be updated later.
                range = (XTextRange)items.get(cell);
                if (range != null) {
                    topicItems.put(xTextRange.getString().toLowerCase().trim() , ae);
                }

                topicCells.add(ae);

                // and store the format of the cell.
                topicCellFormats.add( new TableCellFormatter(table.getCellByName(cursor.getRangeName())));

                // goto next cell.
                cursor.goRight((short)1,false);
            }

            /*
             * now - in which cell is every fillin?
             */
            numCell = topicCells.indexOf( topicItems.get(FILLIN_TOPIC_NUMBER));
            topicCell = topicCells.indexOf( topicItems.get(FILLIN_TOPIC_TOPIC));
            responsibleCell = topicCells.indexOf( topicItems.get(FILLIN_TOPIC_RESPONSIBLE));
            timeCell = topicCells.indexOf( topicItems.get(FILLIN_TOPIC_TIME));



            /* now that we know how the topics look like,
             * we get the format of the first and last rows.
             */

            // format of first row
            cursor.gotoStart(false);
            do {
                firstRowFormat.add( new TableCellFormatter(table.getCellByName(cursor.getRangeName())) );
                cursor.goRight((short)1,false);
            }
            while  (!cursor.getRangeName().startsWith("A"));

            // format of the last row
            cursor.gotoEnd(false);
            while  (!cursor.getRangeName().startsWith("A"))
            {
                lastRowFormat.add( new TableCellFormatter(table.getCellByName(cursor.getRangeName())) );
                cursor.goLeft((short)1,false);
            }
            // we missed the A cell - so we have to add it also..
            lastRowFormat.add( new TableCellFormatter(table.getCellByName(cursor.getRangeName())) );

            removeTableRows(table, 1 + rowsPerTopic, rows - rowsPerTopic - 1);

        }

        /**
         * @param topic the topic number to write
         * @param data the data of the topic.
         * @return the number of rows that have been added
         * to the table. 0 or a negative number: no rows added.
         */
        private int write2(int topic, PropertyValue[] data) throws Exception {
            while (topic >= writtenTopics.size())
                writtenTopics.add(null);

            writtenTopics.set(topic,"");

            // make sure threr are enough rows for me...
            int rows = getRowCount(table);
            int reqRows = 1 + ( topic + 1) * rowsPerTopic;
            int firstRow = reqRows - rowsPerTopic + 1;
            int diff = reqRows - rows;
            if (diff > 0)
                insertTableRows(table,rows,diff);

            // set the item's text...
            setItemText(numCell, data[0].Value);
            setItemText(topicCell, data[1].Value);
            setItemText(responsibleCell, data[2].Value);
            setItemText(timeCell, data[3].Value);

            // now write !
            XTextTableCursor cursor = table.createCursorByCellName("A" + firstRow);

            for (int i = 0; i<topicCells.size(); i++) {
                ((AgendaElement)topicCells.get(i)).write(table.getCellByName(cursor.getRangeName()));
                cursor.goRight((short)1,false);
            }

            // now format !
            cursor.gotoCellByName("A" + firstRow, false);

            formatTable(cursor,topicCellFormats, false);

            return diff;

        }

        /**
         * check if the topic with the given index is written to the table.
         * @param topic the topic number (0 base)
         * @return true if the topic is already written to the table. False if not.
         * (false would mean new rows must be added to the table in order to
         * be able to write this topic).
         */
        private boolean isWritten(int topic) {
            return (writtenTopics.size() > topic && writtenTopics.get(topic) != null );
        }

        /**
         * rewrites a single cell containing.
         * This is used in order to refresh the topic/responsible/duration data in the
         * preview document, in response to a change in the gui (by the user).
         * Since the structure of the topics table is flexible, we don't reference a cell
         * number. Rather, we use "what" argument to specify which cell should be redrawn.
         * The Topics object, which analyzed the structure of the topics table appon
         * initialization, refreshes the approperiate cell.
         * @param topic index of the topic (0 based).
         * @param what 0 for num, 1 for topic, 2 for responsible, 3 for duration
         * @param data the row's data.
         * @throws Exception if something goes wrong (thow nothing should)
         */
        public void writeCell(int topic, int what, PropertyValue[] data) throws Exception {
            // if the whole row should be written...
            if (!isWritten(topic))
                write(topic,data);
            // write only the "what" cell.
            else {
                // calculate the table row.
                int firstRow = 1 + ( topic * rowsPerTopic ) + 1;
                // go to the first cell of this topic.
                XTextTableCursor cursor = table.createCursorByCellName("A" + firstRow);

                TextElement te = null;
                int cursorMoves = 0;

                switch (what) {
                    case 0 :
                        te = setItemText(numCell, data[0].Value);
                        cursorMoves = numCell;
                        break;
                    case 1 :
                        te = setItemText(topicCell, data[1].Value);
                        cursorMoves = topicCell;
                        break;
                    case 2 :
                        te = setItemText(responsibleCell, data[2].Value);
                        cursorMoves = responsibleCell;
                        break;
                    case 3 :
                        te = setItemText(timeCell, data[3].Value);
                        cursorMoves = timeCell;
                        break;
                }
                // move the cursor to the needed cell...
                cursor.goRight((short)cursorMoves, false);
                XCell xc = table.getCellByName(cursor.getRangeName());
                // and write it !
                te.write(xc);
                ((TableCellFormatter)topicCellFormats.get(cursorMoves)).format(xc);

            }
        }


        /**
         * writes the given topic.
         * if the first topic was involved, reformat the
         * first row.
         * If any rows were added to the table, reformat
         * the last row.
         * @param topic the index of the topic to write.
         * @param data the topic's data. (see TopicsControl
         * for explanation about the topics data model)
         * @throws Exception if something goes wrong (though nothing should).
         */
        public void write(int topic, PropertyValue[] data) throws Exception {
            int diff = write2(topic, data);
            /* if the first topic has been written,
             * one needs to reformat the first row.
             */
            if (topic == 0) {
                formatFirstRow();
            }
            /*
             * if any rows were added, one needs to format
             * the whole table again.
             */
            if ( diff > 0 ) {
                formatLastRow();
            }
        }

        /**
         * Writes all the topics to thetopics table.
         * @param topicsData a List containing all Topic's Data.
         */
        public void writeAll(List topicsData){
            try {
                for (int i = 0; i < topicsData.size() - 1; i++)
                    write2(i, (PropertyValue[])topicsData.get(i) );
                formatLastRow();
            }
            catch (Exception ex) {
                ex.printStackTrace();
            }
        }


        /**
         * removes obsolete rows, reducing the
         * topics table to the given number of topics.
         * Note this method does only reducing - if
         * the number of topics given is greater than the
         * number of actuall topics it does *not* add
         * new rows !
         * Note also that the first topic will never be removed.
         * If the table contains no topics, the whole section will
         * be removed uppon finishing.
         * The reason for that is a "table-design" one: the first topic is
         * maintained in order to be able to add rows with a design of this topic,
         * and not of the header row.
         * @param topics the number of topics the table should contain.
         * @throws Exception
         */
        public void reduceDocumentTo(int topics) throws Exception {
            // we never remove the first topic...
            if (topics <= 0)
                topics = 1;
            XTableRows tableRows = table.getRows();
            int targetNumOfRows = topics * rowsPerTopic + 1;
            if (tableRows.getCount() > targetNumOfRows)
                tableRows.removeByIndex(targetNumOfRows , tableRows.getCount() - targetNumOfRows );
            formatLastRow();
            while ( writtenTopics.size() > topics )
                writtenTopics.remove(topics);
        }

        /**
         * reapply the format of the first (header) row.
         */
        private void formatFirstRow() {
            XTextTableCursor cursor = table.createCursorByCellName("A1");
            formatTable(cursor,firstRowFormat, false );
        }

        /**
         * reaply the format of the last row.
         */
        private void formatLastRow() {
            XTextTableCursor cursor = table.createCursorByCellName("A1");
            cursor.gotoEnd(false);
            formatTable(cursor,lastRowFormat, true);
        }

        /**
         * returns a text element for the given cell,
         * which will write the given text.
         * @param cell the topics cell number.
         * @param value the value to write.
         * @return a TextElement object which will write the given value
         * to the given cell.
         */
        private TextElement setItemText(int cell, Object value) {
            if (cell >= 0) {
                TextElement te = ((TextElement)topicCells.get(cell));
                if (te != null)
                    te.text = value.toString();
                return te;
            }
            return null;
        }

        /**
         * formats a series of cells from the given one,
         * using the given List of TableCellFormatter objects,
         * in the given order.
         * This method is used to format the first (header) and the last
         * rows of the table.
         * @param cursor a table cursor, pointing to the start cell to format
         * @param formats a List containing TableCellFormatter objects. Each will format one cell in the direction specified.
         * @param reverse if true the cursor will move left, formatting in reverse order (used for the last row).
         */
        private void formatTable(XTextTableCursor cursor, List formats, boolean reverse) {
            for ( int i = 0; i < formats.size() ; i++ ) {
                ((TableCellFormatter)formats.get(i)).format(table.getCellByName(cursor.getRangeName()));
                if (reverse)
                    cursor.goLeft((short)1,false);
                else
                    cursor.goRight((short)1,false);
            }
        }


    }


    /*
     * =================================
     * Here are some static help methods
     * =================================
     */

    public static String[] getNamesWhichStartWith(String[] allNames, String prefix)
    {
        Vector v = new Vector();
        for (int i = 0; i < allNames.length; i++)
            if (allNames[i].startsWith(prefix))
                v.add(allNames[i]);
        String[] s = new String[v.size()];
        System.arraycopy(v.toArray(), 0, s, 0, s.length);
        return s;
    }

    /**
     * Convenience method, costs the given object to an XNamed, and returnes its name.
     * @param obj an XNamed object.
     * @return the name of the given object.
     */
    public static String getName(Object obj) {
        return ((XNamed)UnoRuntime.queryInterface(XNamed.class,obj)).getName();
    }

    /**
     * convenience method, for removing a number of cells from a table.
     * @param table
     * @param start
     * @param count
     */
    public static void removeTableRows(Object table, int start, int count) {
        XTableRows rows = ((XTextTable)UnoRuntime.queryInterface(XTextTable.class,table)).getRows();
        rows.removeByIndex(start, count);
    }

    /**
     * Convenience method for inserting some cells into a table.
     * @param table
     * @param start
     * @param count
     */
    public static void insertTableRows(Object table, int start, int count) {
        XTableRows rows = ((XTextTable)UnoRuntime.queryInterface(XTextTable.class,table)).getRows();
        rows.insertByIndex(start, count);
    }

    /**
     * returns the row index for this cursor, assuming
     * the cursor points to a single cell.
     * @param cursor
     * @return the row index in which the cursor is.
     */
    public static int getRowIndex(XTextTableCursor cursor) {
        return getRowIndex(cursor.getRangeName());
    }

    /**
     * returns the row index for this cell name.
     * @param cellName
     * @return the row index for this cell name.
     */
    public static int getRowIndex(String cellName) {
        return Integer.parseInt(cellName.substring(1));
    }

    /**
     * returns the rows count of this table, assuming
     * there is no vertical merged cells.
     * @param table
     * @return the rows count of the given table.
     */
    public static int getRowCount(XTextTable table) {
        String[] cells = table.getCellNames();
        return getRowIndex(cells[cells.length-1]);
    }

}

/*
 * ===========================================================================================
 *
 *                  End of AgendaTempalte class
 *
 * ===========================================================================================
 *
 */


/*
 * =================================
 *  The AgendaElement interface
 * =================================
 */

/**
 * Interface that is used for writing content to a Uno Text / TextRange
 * @author rp143992
 *
 */
interface AgendaElement
{
    void write(Object any) throws Exception;

}


/*
 * =================================
 *  The ParaStyled class
 * =================================
 */


/**
 * Basic implementation of the AgendaElement interface -
 * writes nothing, but applies a ParaStyle to the given XText/XTextRange
 * @author rp143992
 *
 * TODO To change the template for this generated type comment go to
 * Window - Preferences - Java - Code Style - Code Templates
 */
class ParaStyled implements AgendaElement {
    String paraStyle;

    ParaStyled(String paraStyle_) {
        paraStyle = paraStyle_;
    }

    void format(Object textRange) {
        XText o;
        o = ((XText)UnoRuntime.queryInterface(XText.class,textRange));
        if (o == null)
            o = ((XTextRange)UnoRuntime.queryInterface(XTextRange.class,textRange)).getText();

        XTextRange xtr = (XTextRange)UnoRuntime.queryInterface(XTextRange.class,textRange);
        XTextCursor cursor = o.createTextCursorByRange(xtr);

        Helper.setUnoPropertyValue(cursor, "ParaStyleName", paraStyle);
    }

    public void write(Object textRange) {
        format(textRange);
    }

}

/*
 * =================================
 *  The TextElement class
 * =================================
 */

/**
 * A basic implementation of AgendaElement:
 * writes a String to the given XText/XTextRange, and applies
 * a ParaStyle to it (using the parent class).
 * @author rp143992
 */
 class TextElement extends ParaStyled {
    String text;

    TextElement(XTextRange range) {
        this( range.getString() , (String) Helper.getUnoPropertyValue( range.getStart(), "ParaStyleName"));
    }

    TextElement(String text_, String paraStyle_) {
        super(paraStyle_);
        text= text_;
    }

    public void write(Object textRange) {
        ((XTextRange)UnoRuntime.queryInterface(XTextRange.class,textRange)).setString(text);
        if (!text.equals(""))
            super.write(textRange);
    }
}


/**
 * A Text element which, if the text to write is empty (null or "")
 * inserts a placeholder instead.
 * @author rp143992
 *
 * TODO To change the template for this generated type comment go to
 * Window - Preferences - Java - Code Style - Code Templates
 */
class PlaceholderTextElement extends TextElement {
    String hint;
    String placeHolderText;
    XMultiServiceFactory xmsf;

    PlaceholderTextElement(XTextRange textRange, String placeHolderText_, String hint_, XMultiServiceFactory xmsf_) {
        super(textRange);
        placeHolderText = placeHolderText_;
        hint = hint_;
        xmsf = xmsf_;
    }

    PlaceholderTextElement(String text, String paraStyle, String placeHolderText_, String hint_, XMultiServiceFactory xmsf_) {
        super(text,paraStyle);
        placeHolderText = placeHolderText_;
        hint = hint_;
        xmsf = xmsf_;
    }

    public void write(Object textRange) {
        super.write(textRange);
        if (text == null || text.equals("")) {
            XTextRange xTextRange = (XTextRange)UnoRuntime.queryInterface(XTextRange.class,textRange);
            try {
                XTextContent xTextContent = AgendaTemplate.createPlaceHolder(xmsf,placeHolderText, hint);
                xTextRange.getText().insertTextContent(xTextRange.getStart(), xTextContent, true);
            }
            catch (Exception ex) {
                ex.printStackTrace();
            }
        }
    }
}



/*
 * =================================
 *  The PlaceHolder class
 * =================================
 */


/**
 * An Agenda element which writes no text, but inserts a placeholder, and formats
 * it using a ParaStyleName.
 * @author rp143992
 *
 */
class PlaceholderElement extends ParaStyled {
    String hint;
    String placeHolderText;
    XMultiServiceFactory xmsf;

    PlaceholderElement(String paraStyle, String placeHolderText_, String hint_, XMultiServiceFactory xmsf_) {
        super(paraStyle);
        placeHolderText = placeHolderText_;
        hint = hint_;
        xmsf = xmsf_;
    }

    public void write(Object textRange) {
        XTextRange xTextRange = (XTextRange)UnoRuntime.queryInterface(XTextRange.class,textRange);
        try {
            XTextContent xTextContent = AgendaTemplate.createPlaceHolder(xmsf,placeHolderText, hint);
            xTextRange.getText().insertTextContent(xTextRange.getStart(), xTextContent, true);
            super.write(textRange);
        }
        catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}


/*
 * =================================
 *  The AgendaItem class
 * =================================
 */

/**
 * An implementation of AgendaElement which
 * gets as a parameter a table cursor, and writes
 * a text to the cell marked by this table cursor, and
 * a place holder to the next cell.
 * @author rp143992
 *
 * TODO To change the template for this generated type comment go to
 * Window - Preferences - Java - Code Style - Code Templates
 */

class AgendaItem implements AgendaElement {
    TextElement textElement;
    AgendaElement field;
    public Object table;
    String name;

    AgendaItem(String name_, TextElement te, AgendaElement f) {
        name = name_;
        field = f;
        textElement = te;
    }

    public void  write(Object tableCursor)  throws Exception {
        XTextTableCursor xTextTableCursor = (XTextTableCursor)UnoRuntime.queryInterface(XTextTableCursor.class,tableCursor);
        XTextTable xTextTable = (XTextTable)UnoRuntime.queryInterface(XTextTable.class,table);

        String cellname = xTextTableCursor.getRangeName();
        Object cell = xTextTable.getCellByName(cellname);

        textElement.write(cell);

        xTextTableCursor.goRight((short)1,false);

        //second field is actually always null...
        // this is a preparation for adding placeholders.
        if (field!= null)
            field.write(xTextTable.getCellByName(xTextTableCursor.getRangeName()));


    }
}

/*
 * =================================
 *  The TableCellFormatter class
 * =================================
 */

/**
 * reads/write a table cell format from/to a table cell or a group of cells.
 *
 */
class TableCellFormatter {
  static String[] properties = new String[] {
        "BackColor",
        "BackTransparent",
        "BorderDistance",
        "BottomBorder",
        "BottomBorderDistance",
        "LeftBorder",
        "LeftBorderDistance",
        "RightBorder",
        "RightBorderDistance",
        "TopBorder",
        "TopBorderDistance"
  };

  private Object[] values = new Object[properties.length];

  public TableCellFormatter(Object tableCell) {
    for (int i = 0; i<properties.length; i++)
        values[i] = Helper.getUnoPropertyValue(tableCell,properties[i]);
  }

  public void format(Object tableCell) {
    Helper.setUnoPropertyValues(tableCell,properties,values);
  }
}




