/**************************************************************
 * 
 * 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_AccessibleToolBoxItem_idl__
#define __com_sun_star_awt_AccessibleToolBoxItem_idl__

#ifndef __com_sun_star_accessibility_AccessibleContext_idl__
#include <com/sun/star/accessibility/AccessibleContext.idl>
#endif


module com { module sun { module star { module accessibility {

 published interface XAccessibleAction;
 published interface XAccessibleText;
 published interface XAccessibleValue;
 published interface XAccessibleExtendedComponent;
 published interface XAccessibleComponent;

}; }; }; };

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

/** specifies accessibility support for a tool box item.

    @see com::sun::star::accessibility::AccessibleContext

    @see com::sun::star::accessibility::XAccessibleComponent
	@see com::sun::star::accessibility::XAccessibleExtendedComponent

    @see com::sun::star::accessibility::XAccessibleAction
	@see com::sun::star::accessibility::XAccessibleText
	@see com::sun::star::accessibility::XAccessibleValue

	@since OOo 1.1.2
*/    
published service AccessibleToolBoxItem
{
	/** This interface gives access to the structural information of a tool box item:

       <ul>
       <li>Role: The role of a tool box item is 
		   <const scope="com::sun::star::accessibility">AccessibleRole::PUSH_BUTTON</const> when the item is a push button, or
		   <const scope="com::sun::star::accessibility">AccessibleRole::TOGGLE_BUTTON</const> when the item is a button and checkable, or
		   <const scope="com::sun::star::accessibility">AccessibleRole::PANEL</const> when the item is a window, or
		   <const scope="com::sun::star::accessibility">AccessibleRole::FILLER</const> when the item is a fill item, or
		   <const scope="com::sun::star::accessibility">AccessibleRole::SEPARATOR</const> when the item is a separator.</li>
       <li>Name: The name of a tool box item is the name set.</li>
       <li>Description: The description of a tool box item is its localized
           help text.</li>
       <li>Children: There can exist one child. 
			This can be any kind of accessible object.</li>            
       <li>Parent: The parent is the tool box that contains the tool box item.</li>
       <li>Relations: There are no relations.</li>
       <li>States: The states supported by this service are
           <ul>
           <li><const scope="com::sun::star::accessibility"
               >AccessibleStateType::DEFUNC</const>
               is set if the object has already been disposed
               and subsequent calls to this object result in				
               <type scope="com::sun::star::lang">DisposedException</type>
               exceptions.</li>
           <li><const scope="com::sun::star::accessibility"
               >AccessibleStateType::ENABLED</const> is set
               if the object is enabled.</li>
           <li><const scope="com::sun::star::accessibility"
               >AccessibleStateType::FOCUSABLE</const> is always set.</li>
           <li><const scope="com::sun::star::accessibility"
               >AccessibleStateType::FOCUSED</const> is set
               if the object currently has the keyboard focus.</li>
           <li><const scope="com::sun::star::accessibility"
               >AccessibleStateType::SHOWING</const> is set
               if the object is displayed on the screen.</li>
           <li><const scope="com::sun::star::accessibility"
               >AccessibleStateType::VISIBLE</const> is always set.</li>
		   <li><const scope="com::sun::star::accessibility"
               >AccessibleStateType::CHECKED</const> is set
			   if the tool box item is checked.</li>
           </ul>
           </li>
       </ul>
    */
    service   com::sun::star::accessibility::AccessibleContext;

	interface com::sun::star::accessibility::XAccessibleComponent;
	interface com::sun::star::accessibility::XAccessibleExtendedComponent;

    /** This interface gives access to the actions that can be executed for
        a menu. The supported actions for a tool box item are:
        <ul>
        <li>click</li>
        </ul>
     */
    interface com::sun::star::accessibility::XAccessibleAction;

    /** This interface gives read-only access to the text representation
        of a tool box item.
     */
    interface com::sun::star::accessibility::XAccessibleText;
    /** This interface gives access to the numerical value of a
        tool box item, which is related to the tool box item's
        <const scope="com::sun::star::accessibility"
        >AccessibleStateType::CHECKED</const> state.
     */
    interface com::sun::star::accessibility::XAccessibleValue;
};
          
}; }; }; };

#endif
