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



#ifndef __com_sun_star_sheet_XNamedRanges_idl__
#define __com_sun_star_sheet_XNamedRanges_idl__

#ifndef __com_sun_star_container_XNameAccess_idl__
#include <com/sun/star/container/XNameAccess.idl>
#endif

#ifndef __com_sun_star_table_CellAddress_idl__
#include <com/sun/star/table/CellAddress.idl>
#endif

#ifndef __com_sun_star_table_CellRangeAddress_idl__
#include <com/sun/star/table/CellRangeAddress.idl>
#endif

#ifndef __com_sun_star_sheet_Border_idl__
#include <com/sun/star/sheet/Border.idl>
#endif

//=============================================================================

module com {  module sun {  module star {  module sheet {


//=============================================================================

/** provides access to the members in a collection of named ranges and to
	insert and remove them.

	@see com::sun::star::sheet::NamedRanges
	@see com::sun::star::sheet::NamedRange
 */
published interface XNamedRanges: com::sun::star::container::XNameAccess
{
	//-------------------------------------------------------------------------

	/** adds a new named range to the collection.

		@param aName
			the new name of the named range.

		@param aContent
			the formula expression.

			<p>A cell range address is one possible content of a named
			range.</p>

		@param aPosition
			specifies the base address for relative cell references.

		@param nType
			a combination of flags that specify the type of a named range,
			as defined in <type>NamedRangeFlag</type>.

			<p>This parameter will be zero for any common named range.</p>
	 */
	void addNewByName(
			[in] string aName,
			[in] string aContent,
			[in] com::sun::star::table::CellAddress aPosition,
			[in] long nType );

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

	/** creates named cell ranges from titles in a cell range.

		<p>The names for the named ranges are taken from title cells in the
		top or bottom row, or from the cells of the left or right column
		of the range (depending on the parameter <const>aBorder</const>.
		The named ranges refer to single columns or rows in the inner
		part of the original range, excluding the labels.</p>

		<p>Example: The source range is A1:B3. The named ranges shall be
		created using row titles. This requires <member>Border::TOP</member>
		for the second parameter. The method creates two named ranges. The
		name of the first is equal to the content of cell A1 and contains the
		range $Sheet.$A$2:$A$3 (excluding the title cell). The latter named
		range is named using cell B1 and contains the cell range address
		$Sheet.$B$2:$B$3.</p>

		@param aSource
			the cell range used to create the named ranges.

		@param aBorder
			specifies the location of the title cells.
	 */
	void addNewFromTitles(
			[in] com::sun::star::table::CellRangeAddress aSource,
			[in] com::sun::star::sheet::Border aBorder );

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

	/** removes a named range from the collection.
	 */
	void removeByName( [in] string aName );

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

	/** writes a list of all named ranges into the document.

		<p>The first column of the list contains the names. The second
		column contains the contents of the named ranges.</p>

		@param aOutputPosition
			specifies the top left cell of the output range.
	 */
	void outputList( [in] com::sun::star::table::CellAddress aOutputPosition );
	

};

//=============================================================================

}; }; }; };

#endif

