/**************************************************************
 * 
 * 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_awt_UnoControlRoadmapModel_idl__
#define __com_sun_star_awt_UnoControlRoadmapModel_idl__


#ifndef __com_sun_star_awt_UnoControlModel_idl__
#include <com/sun/star/awt/UnoControlModel.idl>
#endif
#ifndef __com_sun_star_container_XIndexContainer_idl__
#include <com/sun/star/container/XIndexContainer.idl>
#endif
#ifndef __com_sun_star_beans_XPropertyChangeListener_idl__
#include <com/sun/star/beans/XPropertyChangeListener.idl>
#endif
#ifndef com_sun_star_graphic_XGraphic_idl
#include <com/sun/star/graphic/XGraphic.idl>
#endif

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

 module com {  module sun {  module star {  module awt {

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

/** specifies the standard model of an <type>UnoControlContainer</type>.
 */
service UnoControlRoadmapModel
{
    service com::sun::star::awt::UnoControlModel;

    /** The control serves as an indexed container typically for RoadmapItems
        as specified in com::sun::star::awt:RoadmapItem. The RoadmapItems are
        held in a sequence.
        When inserting such items their ID is set equal to the Index of their
        insertion by default.
        After removing items the CurrentItem property is - when beyound the upper sequence
        boundaries - set equal to last index of the RoadmapItem Array.
     */
    interface com::sun::star::container::XIndexContainer;

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


    /** specifies the background color (RGB) of the control.
        The Default value is white
     */
    [property] long BackgroundColor;

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

    /** determines whether the control is interactive or not.

        <p>A roadmap control which is interactive allows selecting its items out-of-order,
        by simply clicking them.</p>
     */
    [property] boolean Interactive;

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

    /** determines whether the control container is complete or not. If it is
        false than a non - interactive RoadmapItem is appended
     */
    [property] boolean Complete;


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

    /** specifies an URL to an image to use for the control.
        The image is placed in the lower right corner of the control
        @see Graphic
     */
    [property] string ImageURL;

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

    /** specifies a graphic to be displayed on the control

        <p>If this property is present, it interacts with the <member>ImageURL</member>in the
        following way:
        <ul><li>If <member>ImageURL</member> is set, <member>Graphic</member> will be reset
            to an object as loaded from the given image URL, or <NULL/> if <member>ImageURL</member>
            does not point to a valid image file.</li>
            <li>If <member>Graphic</member> is set, <member>ImageURL</member> will be reset
            to an empty string.</li>
        </ul></p>

        @since OpenOffice 2.1
     */
    [optional, property, transient] com::sun::star::graphic::XGraphic Graphic;

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

    /** specifies the border style of the control.

        <pre>
        0: No border
        1: 3D border
        2: simple border
        </pre>
     */
    [property] short Border;

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

    /** specifies whether the control will be printed with the document.
     */
    [property] boolean Printable;

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

    /** specifies the text displayed in the control.
     */
    [property] string Text;

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

    /** refers to the  ID of the currently selected item. Initially this property is set to '-1'
        which is equal to 'undefined"
        If the Roadmap Item that the CurrentItemID refers to is removed the property
        'CurrentItemID' is set to -1
     */
    [property] short CurrentItemID;


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

    /** specifies the help text of the control.
     */
    [property] string HelpText;


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

    /** specifies the help URL of the control.
     */
    [property] string HelpURL;

};

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

}; }; }; };

#endif
