/**************************************************************
 * 
 * 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_AccessibleComboBox_idl__
#define __com_sun_star_awt_AccessibleComboBox_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 XAccessibleText;
 published interface XAccessibleExtendedComponent;
 published interface XAccessibleComponent;

}; }; }; };

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

/** specifies accessibility support for a combo box.

    @see com::sun::star::accessibility::AccessibleContext
	@see com::sun::star::accessibility::XAccessibleComponent
	@see com::sun::star::accessibility::XAccessibleExtendedComponent
	@since OOo 1.1.2
*/    
published service AccessibleComboBox
{
	/** This interface gives access to the structural information of a combo box:

       <ul>
       <li>Role: The role of a combo box is <const 
           scope="com::sun::star::accessibility"
           >AccessibleRole::COMBO_BOX</const>.</li>
       <li>Name: The name of a combo box is its localized label.</li>
       <li>Description: The description of a combo box is its localized
           help text.</li>
       <li>Children: There exists two children. 
			The first is a <type scope="com::sun::star::awt">AccessibleTextField</type> 
			and the 2nd is a <type scope="com::sun::star::awt">AccessibleList</type>. </li>            
       <li>Parent: The parent is the window that contains the combo box.</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::ACTIVE</const> is set
               if a child has currently the focus.</li>
		   <li><const scope="com::sun::star::accessibility"
               >AccessibleStateType::RESIZABLE</const> is set
               if the object can be resized.</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>
           </ul>
           </li>
       </ul>
    */

    service   com::sun::star::accessibility::AccessibleContext;

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

#endif
