diff options
Diffstat (limited to 'packages/gtk2/src/atk')
24 files changed, 2605 insertions, 0 deletions
diff --git a/packages/gtk2/src/atk/atk.inc b/packages/gtk2/src/atk/atk.inc new file mode 100644 index 0000000000..91d4cb3fd4 --- /dev/null +++ b/packages/gtk2/src/atk/atk.inc @@ -0,0 +1,55 @@ +{ Pointers to basic pascal types, inserted by h2pas conversion program.} +Type + PLongint = ^Longint; + PSmallInt = ^SmallInt; + PByte = ^Byte; + PWord = ^Word; + PDWord = ^DWord; + PDouble = ^Double; + +{$PACKRECORDS C} + +{ ATK - Accessibility Toolkit + Copyright 2001 Sun Microsystems Inc. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library 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. + } +{$ifndef __ATK_H__} +{$define __ATK_H__} +{$include <atk/atkobject.inc} +{$include <atk/atkaction.inc} +{$include <atk/atkcomponent.inc} +{$include <atk/atkdocument.inc} +{$include <atk/atkeditabletext.inc} +{$include <atk/atkgobjectaccessible.inc} +{$include <atk/atkhyperlink.inc} +{$include <atk/atkhypertext.inc} +{$include <atk/atkimage.inc} +{$include <atk/atkobjectfactory.inc} +{$include <atk/atkregistry.inc} +{$include <atk/atkrelation.inc} +{$include <atk/atkrelationset.inc} +{$include <atk/atkselection.inc} +{$include <atk/atkstate.inc} +{$include <atk/atkstateset.inc} +{$include <atk/atkstreamablecontent.inc} +{$include <atk/atktable.inc} +{$include <atk/atktext.inc} +{$include <atk/atkutil.inc} +{$include <atk/atkvalue.inc} +{$endif} +{ __ATK_H__ } + diff --git a/packages/gtk2/src/atk/atk.pas b/packages/gtk2/src/atk/atk.pas new file mode 100644 index 0000000000..2af1927fc6 --- /dev/null +++ b/packages/gtk2/src/atk/atk.pas @@ -0,0 +1,91 @@ +{ ATK - Accessibility Toolkit + Copyright 2001 Sun Microsystems Inc. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library 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. + } +unit atk; // keep unit name lowercase for kylix + +{$IFDEF FPC} + {$mode objfpc} +{$ENDIF} +{$IFDEF VER140} + {$DEFINE KYLIX} +{$ENDIF} + +interface + +uses glib2; + +const +{$ifdef win32} + {$define atkwin} + atklib = 'libatk-1.0-0.dll'; + {$IFDEF FPC} + {$ifndef NO_SMART_LINK} + {$smartlink on} + {$endif} + {$ENDIF} +{$else} + {$ifdef UseCustomLibs} + atklib = ''; + {$else} + atklib = 'libatk-1.0.so'; + {$endif} +{$endif} + +{$IFNDEF KYLIX} + {$PACKRECORDS C} +{$ELSE} + {$ALIGN 4} + {$WEAKPACKAGEUNIT} + {$WARNINGS OFF} +{$ENDIF} + +type +{$DEFINE read_forward_definitions} + // internal types + PAtkImplementor = pointer; + PAtkAction = pointer; + PAtkComponent = pointer; + PAtkDocument = pointer; + PAtkEditableText = pointer; + PAtkHypertext = pointer; + PAtkImage = pointer; + PAtkSelection = pointer; + PAtkStreamableContent = pointer; + PAtkTable = pointer; + PAtkText = pointer; + PAtkValue = pointer; + +{$include atkincludes.inc} +{$UNDEF read_forward_definitions} + +{$DEFINE read_interface_types} +{$include atkincludes.inc} +{$UNDEF read_interface_types} + +{$DEFINE read_interface_rest} +{$include atkincludes.inc} +{$UNDEF read_interface_rest} + +implementation + +// call implementation parts of header files +{$DEFINE read_implementation} +{$include atkincludes.inc} +{$UNDEF read_implementation} + +end. diff --git a/packages/gtk2/src/atk/atkaction.inc b/packages/gtk2/src/atk/atkaction.inc new file mode 100644 index 0000000000..e7ba644cf1 --- /dev/null +++ b/packages/gtk2/src/atk/atkaction.inc @@ -0,0 +1,89 @@ +// included by atk.pp + +{ + The interface AtkAction should be supported by any anObject that can + perform one or more actions. The interface provides the standard + mechanism for an assistive technology to determine what those actions + are as well as tell the anObject to perform them. Any anObject that can + be manipulated should support this interface. + } + +{$IFDEF read_forward_definitions} +{$ENDIF read_forward_definitions} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_types} + PAtkActionIface = ^TAtkActionIface; + TAtkActionIface = record + parent : TGTypeInterface; + do_action : function (action:PAtkAction; i:gint):gboolean; cdecl; + get_n_actions : function (action:PAtkAction):gint; cdecl; + get_description : function (action:PAtkAction; i:gint):Pgchar; cdecl; + get_name : function (action:PAtkAction; i:gint):Pgchar; cdecl; + get_keybinding : function (action:PAtkAction; i:gint):Pgchar; cdecl; + set_description : function (action:PAtkAction; i:gint; desc:Pgchar):gboolean; cdecl; + pad1 : TAtkFunction; + pad2 : TAtkFunction; + end; + +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} +function ATK_TYPE_ACTION : GType; +function ATK_IS_ACTION(obj: pointer) : boolean; +function ATK_ACTION(obj: pointer) : PAtkAction; +function ATK_ACTION_GET_IFACE(obj: pointer) : PAtkActionIface; + + +{ + These are the function which would be called by an application with + the argument being a AtkObject anObject cast to (AtkAction). + + The function will just check that the corresponding + function pointer is not NULL and will call it. + + The "real" implementation of the function for accessible will be + provided in a support library + } +function atk_action_get_type:GType; cdecl; external atklib; +function atk_action_do_action(action:PAtkAction; i:gint):gboolean; cdecl; external atklib; +function atk_action_get_n_actions(action:PAtkAction):gint; cdecl; external atklib; +function atk_action_get_description(action:PAtkAction; i:gint):Pgchar; cdecl; external atklib; +function atk_action_get_name(action:PAtkAction; i:gint):Pgchar; cdecl; external atklib; +function atk_action_get_keybinding(action:PAtkAction; i:gint):Pgchar; cdecl; external atklib; +function atk_action_set_description(action:PAtkAction; i:gint; desc:Pgchar):gboolean; cdecl; external atklib; +{ + Additional GObject properties exported by AtkAction: + "accessible_action" + (an accessible action, or the list of actions, has changed) + } +{$ENDIF read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function ATK_TYPE_ACTION : GType; +begin + ATK_TYPE_ACTION:=atk_action_get_type; +end; + +function ATK_IS_ACTION(obj: pointer) : boolean; +begin + ATK_IS_ACTION:=G_TYPE_CHECK_INSTANCE_TYPE(obj,ATK_TYPE_ACTION); +end; + +function ATK_ACTION(obj: pointer) : PAtkAction; +begin + ATK_ACTION:=PAtkAction(G_TYPE_CHECK_INSTANCE_CAST(obj,ATK_TYPE_ACTION)); +end; + +function ATK_ACTION_GET_IFACE(obj: pointer) : PAtkActionIface; +begin + ATK_ACTION_GET_IFACE:=PAtkActionIface(G_TYPE_INSTANCE_GET_INTERFACE(obj,ATK_TYPE_ACTION)); +end; + +{$ENDIF read_implementation} + diff --git a/packages/gtk2/src/atk/atkcomponent.inc b/packages/gtk2/src/atk/atkcomponent.inc new file mode 100644 index 0000000000..369ce3b0d8 --- /dev/null +++ b/packages/gtk2/src/atk/atkcomponent.inc @@ -0,0 +1,92 @@ +// included by atk.pp + +{$IFDEF read_forward_definitions} +{$ENDIF read_forward_definitions} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_types} + TAtkFocusHandler = procedure (para1:PAtkObject; para2:gboolean); cdecl; + PAtkComponentIface = ^TAtkComponentIface; + TAtkComponentIface = record + parent : TGTypeInterface; + add_focus_handler : function (component:PAtkComponent; handler:TAtkFocusHandler):guint; cdecl; + contains : function (component:PAtkComponent; x:gint; y:gint; coord_type:TAtkCoordType):gboolean; cdecl; + ref_accessible_at_point : function (component:PAtkComponent; x:gint; y:gint; coord_type:TAtkCoordType):PAtkObject; cdecl; + get_extents : procedure (component:PAtkComponent; x:Pgint; y:Pgint; width:Pgint; height:Pgint; + coord_type:TAtkCoordType); cdecl; + get_position : procedure (component:PAtkComponent; x:Pgint; y:Pgint; coord_type:TAtkCoordType); cdecl; + get_size : procedure (component:PAtkComponent; width:Pgint; height:Pgint); cdecl; + grab_focus : function (component:PAtkComponent):gboolean; cdecl; + remove_focus_handler : procedure (component:PAtkComponent; handler_id:guint); cdecl; + set_extents : function (component:PAtkComponent; x:gint; y:gint; width:gint; height:gint; + coord_type:TAtkCoordType):gboolean; cdecl; + set_position : function (component:PAtkComponent; x:gint; y:gint; coord_type:TAtkCoordType):gboolean; cdecl; + set_size : function (component:PAtkComponent; width:gint; height:gint):gboolean; cdecl; + get_layer : function (component:PAtkComponent):TAtkLayer; cdecl; + get_mdi_zorder : function (component:PAtkComponent):gint; cdecl; + pad1 : TAtkFunction; + pad2 : TAtkFunction; + end; + +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} +{ + The AtkComponent interface should be supported by any anObject that is + rendered on the screen. The interface provides the standard mechanism + for an assistive technology to determine and set the graphical + representation of an anObject. + } +function ATK_TYPE_COMPONENT : GType; +function ATK_IS_COMPONENT(obj: pointer) : boolean; +function ATK_COMPONENT(obj: pointer) : PAtkComponent; +function ATK_COMPONENT_GET_IFACE(obj: pointer) : PAtkComponentIface; + + +{ convenience functions } +function atk_component_get_type:GType; cdecl; external atklib; +function atk_component_add_focus_handler(component:PAtkComponent; handler:TAtkFocusHandler):guint; cdecl; external atklib; +function atk_component_contains(component:PAtkComponent; x:gint; y:gint; coord_type:TAtkCoordType):gboolean; cdecl; external atklib; +function atk_component_ref_accessible_at_point(component:PAtkComponent; x:gint; y:gint; coord_type:TAtkCoordType):PAtkObject; cdecl; external atklib; +procedure atk_component_get_extents(component:PAtkComponent; x:Pgint; y:Pgint; width:Pgint; height:Pgint; + coord_type:TAtkCoordType); cdecl; external atklib; +procedure atk_component_get_position(component:PAtkComponent; x:Pgint; y:Pgint; coord_type:TAtkCoordType); cdecl; external atklib; +procedure atk_component_get_size(component:PAtkComponent; width:Pgint; height:Pgint); cdecl; external atklib; +function atk_component_get_layer(component:PAtkComponent):TAtkLayer; cdecl; external atklib; +function atk_component_get_mdi_zorder(component:PAtkComponent):gint; cdecl; external atklib; +function atk_component_grab_focus(component:PAtkComponent):gboolean; cdecl; external atklib; +procedure atk_component_remove_focus_handler(component:PAtkComponent; handler_id:guint); cdecl; external atklib; +function atk_component_set_extents(component:PAtkComponent; x:gint; y:gint; width:gint; height:gint; + coord_type:TAtkCoordType):gboolean; cdecl; external atklib; +function atk_component_set_position(component:PAtkComponent; x:gint; y:gint; coord_type:TAtkCoordType):gboolean; cdecl; external atklib; +function atk_component_set_size(component:PAtkComponent; width:gint; height:gint):gboolean; cdecl; external atklib; +{$ENDIF read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function ATK_TYPE_COMPONENT : GType; +begin + ATK_TYPE_COMPONENT:=atk_component_get_type; +end; + +function ATK_IS_COMPONENT(obj: pointer) : boolean; +begin + ATK_IS_COMPONENT:=G_TYPE_CHECK_INSTANCE_TYPE(obj,ATK_TYPE_COMPONENT); +end; + +function ATK_COMPONENT(obj: pointer) : PAtkComponent; +begin + ATK_COMPONENT:=PAtkComponent(G_TYPE_CHECK_INSTANCE_CAST(obj,ATK_TYPE_COMPONENT)); +end; + +function ATK_COMPONENT_GET_IFACE(obj: pointer) : PAtkComponentIface; +begin + ATK_COMPONENT_GET_IFACE:=PAtkComponentIface(G_TYPE_INSTANCE_GET_INTERFACE(obj,ATK_TYPE_COMPONENT)); +end; + +{$ENDIF read_implementation} + diff --git a/packages/gtk2/src/atk/atkdocument.inc b/packages/gtk2/src/atk/atkdocument.inc new file mode 100644 index 0000000000..f19e69b020 --- /dev/null +++ b/packages/gtk2/src/atk/atkdocument.inc @@ -0,0 +1,71 @@ +// included by atk.pp + +{ + The AtkDocument interface should be supported by any anObject that has an + associated document anObject model (DOM). This interface provides the + standard mechanism allowing an assistive technology access to the DOM. + } + + +{$IFDEF read_forward_definitions} +{$ENDIF read_forward_definitions} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_types} + PAtkDocumentIface = ^TAtkDocumentIface; + TAtkDocumentIface = record + parent : TGTypeInterface; + get_document_type : function (document:PAtkDocument):Pgchar; cdecl; + get_document : function (document:PAtkDocument):gpointer; cdecl; + pad1 : TAtkFunction; + pad2 : TAtkFunction; + pad3 : TAtkFunction; + pad4 : TAtkFunction; + pad5 : TAtkFunction; + pad6 : TAtkFunction; + pad7 : TAtkFunction; + pad8 : TAtkFunction; + end; + +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} +function ATK_TYPE_DOCUMENT : GType; +function ATK_IS_DOCUMENT(obj: pointer) : boolean; +function ATK_DOCUMENT(obj: pointer) : PAtkDocument; +function ATK_DOCUMENT_GET_IFACE(obj: pointer) : PAtkDocumentIface; + + +function atk_document_get_type:GType; cdecl; external atklib; +function atk_document_get_document_type(document:PAtkDocument):Pgchar; cdecl; external atklib; +function atk_document_get_document(document:PAtkDocument):gpointer; cdecl; external atklib; +{$ENDIF read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function ATK_TYPE_DOCUMENT : GType; +begin + ATK_TYPE_DOCUMENT:=atk_document_get_type; +end; + +function ATK_IS_DOCUMENT(obj: pointer) : boolean; +begin + ATK_IS_DOCUMENT:=G_TYPE_CHECK_INSTANCE_TYPE(obj,ATK_TYPE_DOCUMENT); +end; + +function ATK_DOCUMENT(obj: pointer) : PAtkDocument; +begin + ATK_DOCUMENT:=PAtkDocument(G_TYPE_CHECK_INSTANCE_CAST(obj,ATK_TYPE_DOCUMENT)); +end; + +function ATK_DOCUMENT_GET_IFACE(obj: pointer) : PAtkDocumentIface; +begin + ATK_DOCUMENT_GET_IFACE:=PAtkDocumentIface(G_TYPE_INSTANCE_GET_INTERFACE(obj,ATK_TYPE_DOCUMENT)); +end; + +{$ENDIF read_implementation} + diff --git a/packages/gtk2/src/atk/atkeditabletext.inc b/packages/gtk2/src/atk/atkeditabletext.inc new file mode 100644 index 0000000000..42948fbfa0 --- /dev/null +++ b/packages/gtk2/src/atk/atkeditabletext.inc @@ -0,0 +1,73 @@ +// included by atk.pp + +{ + AtkEditableText is used to support access in an "accessibility" context + to editing features of editable text widgets. + } + +{$IFDEF read_forward_definitions} +{$ENDIF read_forward_definitions} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_types} + PAtkEditableTextIface = ^TAtkEditableTextIface; + TAtkEditableTextIface = record + parent_interface : TGTypeInterface; + set_run_attributes : function (text:PAtkEditableText; attrib_set:PAtkAttributeSet; start_offset:gint; end_offset:gint):gboolean; cdecl; + set_text_contents : procedure (text:PAtkEditableText; _string:Pgchar); cdecl; + insert_text : procedure (text:PAtkEditableText; _string:Pgchar; length:gint; position:Pgint); cdecl; + copy_text : procedure (text:PAtkEditableText; start_pos:gint; end_pos:gint); cdecl; + cut_text : procedure (text:PAtkEditableText; start_pos:gint; end_pos:gint); cdecl; + delete_text : procedure (text:PAtkEditableText; start_pos:gint; end_pos:gint); cdecl; + paste_text : procedure (text:PAtkEditableText; position:gint); cdecl; + pad1 : TAtkFunction; + pad2 : TAtkFunction; + end; + +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} +function ATK_TYPE_EDITABLE_TEXT : GType; +function ATK_IS_EDITABLE_TEXT(obj: pointer) : boolean; +function ATK_EDITABLE_TEXT(obj: pointer) : PAtkEditableText; +function ATK_EDITABLE_TEXT_GET_IFACE(obj: pointer) : PAtkEditableTextIface; + + +function atk_editable_text_get_type:GType; cdecl; external atklib; +function atk_editable_text_set_run_attributes(text:PAtkEditableText; attrib_set:PAtkAttributeSet; start_offset:gint; end_offset:gint):gboolean; cdecl; external atklib; +procedure atk_editable_text_set_text_contents(text:PAtkEditableText; _string:Pgchar); cdecl; external atklib; +procedure atk_editable_text_insert_text(text:PAtkEditableText; _string:Pgchar; length:gint; position:Pgint); cdecl; external atklib; +procedure atk_editable_text_copy_text(text:PAtkEditableText; start_pos:gint; end_pos:gint); cdecl; external atklib; +procedure atk_editable_text_cut_text(text:PAtkEditableText; start_pos:gint; end_pos:gint); cdecl; external atklib; +procedure atk_editable_text_delete_text(text:PAtkEditableText; start_pos:gint; end_pos:gint); cdecl; external atklib; +procedure atk_editable_text_paste_text(text:PAtkEditableText; position:gint); cdecl; external atklib; +{$ENDIF read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function ATK_TYPE_EDITABLE_TEXT : GType; +begin + ATK_TYPE_EDITABLE_TEXT:=atk_editable_text_get_type; +end; + +function ATK_IS_EDITABLE_TEXT(obj: pointer) : boolean; +begin + ATK_IS_EDITABLE_TEXT:=G_TYPE_CHECK_INSTANCE_TYPE(obj,ATK_TYPE_EDITABLE_TEXT); +end; + +function ATK_EDITABLE_TEXT(obj: pointer) : PAtkEditableText; +begin + ATK_EDITABLE_TEXT:=PAtkEditableText(G_TYPE_CHECK_INSTANCE_CAST(obj,ATK_TYPE_EDITABLE_TEXT)); +end; + +function ATK_EDITABLE_TEXT_GET_IFACE(obj: pointer) : PAtkEditableTextIface; +begin + ATK_EDITABLE_TEXT_GET_IFACE:=PAtkEditableTextIface(G_TYPE_INSTANCE_GET_INTERFACE(obj,ATK_TYPE_EDITABLE_TEXT)); +end; + +{$ENDIF read_implementation} + diff --git a/packages/gtk2/src/atk/atkgobjectaccessible.inc b/packages/gtk2/src/atk/atkgobjectaccessible.inc new file mode 100644 index 0000000000..95d6c4b073 --- /dev/null +++ b/packages/gtk2/src/atk/atkgobjectaccessible.inc @@ -0,0 +1,79 @@ +// included by atk.pp + +{ + The AtkGObjectAccessible class is provided as a basis for implementing + accessibility support for objects which are not GTK+ widgets + } + +{$IFDEF read_forward_definitions} +{$ENDIF read_forward_definitions} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_types} + PAtkGObjectAccessible = ^TAtkGObjectAccessible; + TAtkGObjectAccessible = record + parent : TAtkObject; + end; + + PAtkGObjectAccessibleClass = ^TAtkGObjectAccessibleClass; + TAtkGObjectAccessibleClass = record + parent_class : TAtkObjectClass; + pad1 : TAtkFunction; + pad2 : TAtkFunction; + end; + +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} +function ATK_TYPE_GOBJECT_ACCESSIBLE : GType; +function ATK_GOBJECT_ACCESSIBLE(obj: pointer) : PAtkGObjectAccessible; +function ATK_GOBJECT_ACCESSIBLE_CLASS(klass: pointer) : PAtkGObjectAccessibleClass; +function ATK_IS_GOBJECT_ACCESSIBLE(obj: pointer) : boolean; +function ATK_IS_GOBJECT_ACCESSIBLE_CLASS(klass: pointer) : boolean; +function ATK_GOBJECT_ACCESSIBLE_GET_CLASS(obj: pointer) : PAtkGObjectAccessibleClass; + + +function atk_gobject_accessible_get_type:GType; cdecl; external atklib; + +function atk_gobject_accessible_for_object(obj:PGObject):PAtkObject; cdecl; external atklib; +function atk_gobject_accessible_get_object(obj:PAtkGObjectAccessible):PGObject; cdecl; external atklib; +{$ENDIF read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function ATK_TYPE_GOBJECT_ACCESSIBLE : GType; +begin + ATK_TYPE_GOBJECT_ACCESSIBLE:=atk_gobject_accessible_get_type; +end; + +function ATK_GOBJECT_ACCESSIBLE(obj: pointer) : PAtkGObjectAccessible; +begin + ATK_GOBJECT_ACCESSIBLE:=PAtkGObjectAccessible(G_TYPE_CHECK_INSTANCE_CAST(obj,ATK_TYPE_GOBJECT_ACCESSIBLE)); +end; + +function ATK_GOBJECT_ACCESSIBLE_CLASS(klass: pointer) : PAtkGObjectAccessibleClass; +begin + ATK_GOBJECT_ACCESSIBLE_CLASS:=PAtkGObjectAccessibleClass(G_TYPE_CHECK_CLASS_CAST(klass,ATK_TYPE_GOBJECT_ACCESSIBLE)); +end; + +function ATK_IS_GOBJECT_ACCESSIBLE(obj: pointer) : boolean; +begin + ATK_IS_GOBJECT_ACCESSIBLE:=G_TYPE_CHECK_INSTANCE_TYPE(obj,ATK_TYPE_GOBJECT_ACCESSIBLE); +end; + +function ATK_IS_GOBJECT_ACCESSIBLE_CLASS(klass: pointer) : boolean; +begin + ATK_IS_GOBJECT_ACCESSIBLE_CLASS:=G_TYPE_CHECK_CLASS_TYPE(klass,ATK_TYPE_GOBJECT_ACCESSIBLE); +end; + +function ATK_GOBJECT_ACCESSIBLE_GET_CLASS(obj: pointer) : PAtkGObjectAccessibleClass; +begin + ATK_GOBJECT_ACCESSIBLE_GET_CLASS:=PAtkGObjectAccessibleClass(G_TYPE_INSTANCE_GET_CLASS(obj,ATK_TYPE_GOBJECT_ACCESSIBLE)); +end; + +{$ENDIF read_implementation} + diff --git a/packages/gtk2/src/atk/atkhyperlink.inc b/packages/gtk2/src/atk/atkhyperlink.inc new file mode 100644 index 0000000000..ff0fb50571 --- /dev/null +++ b/packages/gtk2/src/atk/atkhyperlink.inc @@ -0,0 +1,101 @@ +// included by atk.pp + +{ + AtkHyperlink encapsulates a link or set of links in a hypertext document. + + It implements the AtkAction interface. + } + +{$IFDEF read_forward_definitions} +{$ENDIF read_forward_definitions} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_types} + PAtkHyperlink = ^TAtkHyperlink; + TAtkHyperlink = record + parent : TGObject; + end; + +{ Returns a string specifying the URI associated with the nth anchor + of this link. } +{ Returns an anObject which represents the link action, as appropriate for + that link. } +{ Gets the index with the hypertext document at which this link ends } +{ Gets the index with the hypertext document at which this link begins } +{ Since the document a link is associated with may have changed, this + method returns whether or not this link is still valid (with respect + to the document is references) } +{ Returns the number of anchors associated with this link } + PAtkHyperlinkClass = ^TAtkHyperlinkClass; + TAtkHyperlinkClass = record + parent : TGObjectClass; + get_uri : function (link:PAtkHyperlink; i:gint):Pgchar; cdecl; + get_object : function (link:PAtkHyperlink; i:gint):PAtkObject; cdecl; + get_end_index : function (link:PAtkHyperlink):gint; cdecl; + get_start_index : function (link:PAtkHyperlink):gint; cdecl; + is_valid : function (link:PAtkHyperlink):gboolean; cdecl; + get_n_anchors : function (link:PAtkHyperlink):gint; cdecl; + pad1 : TAtkFunction; + pad2 : TAtkFunction; + pad3 : TAtkFunction; + pad4 : TAtkFunction; + end; + +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} +function ATK_TYPE_HYPERLINK : GType; +function ATK_HYPERLINK(obj: pointer) : PAtkHyperlink; +function ATK_HYPERLINK_CLASS(klass: pointer) : PAtkHyperlinkClass; +function ATK_IS_HYPERLINK(obj: pointer) : boolean; +function ATK_IS_HYPERLINK_CLASS(klass: pointer) : boolean; +function ATK_HYPERLINK_GET_CLASS(obj: pointer) : PAtkHyperlinkClass; + + +function atk_hyperlink_get_type:GType; cdecl; external atklib; +function atk_hyperlink_get_uri(link:PAtkHyperlink; i:gint):Pgchar; cdecl; external atklib; +function atk_hyperlink_get_object(link:PAtkHyperlink; i:gint):PAtkObject; cdecl; external atklib; +function atk_hyperlink_get_end_index(link:PAtkHyperlink):gint; cdecl; external atklib; +function atk_hyperlink_get_start_index(link:PAtkHyperlink):gint; cdecl; external atklib; +function atk_hyperlink_is_valid(link:PAtkHyperlink):gboolean; cdecl; external atklib; +function atk_hyperlink_get_n_anchors(link:PAtkHyperlink):gint; cdecl; external atklib; +{$ENDIF read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function ATK_TYPE_HYPERLINK : GType; +begin + ATK_TYPE_HYPERLINK:=atk_hyperlink_get_type; +end; + +function ATK_HYPERLINK(obj: pointer) : PAtkHyperlink; +begin + ATK_HYPERLINK:=PAtkHyperlink(G_TYPE_CHECK_INSTANCE_CAST(obj,ATK_TYPE_HYPERLINK)); +end; + +function ATK_HYPERLINK_CLASS(klass: pointer) : PAtkHyperlinkClass; +begin + ATK_HYPERLINK_CLASS:=PAtkHyperlinkClass(G_TYPE_CHECK_CLASS_CAST(klass,ATK_TYPE_HYPERLINK)); +end; + +function ATK_IS_HYPERLINK(obj: pointer) : boolean; +begin + ATK_IS_HYPERLINK:=G_TYPE_CHECK_INSTANCE_TYPE(obj,ATK_TYPE_HYPERLINK); +end; + +function ATK_IS_HYPERLINK_CLASS(klass: pointer) : boolean; +begin + ATK_IS_HYPERLINK_CLASS:=G_TYPE_CHECK_CLASS_TYPE(klass,ATK_TYPE_HYPERLINK); +end; + +function ATK_HYPERLINK_GET_CLASS(obj: pointer) : PAtkHyperlinkClass; +begin + ATK_HYPERLINK_GET_CLASS:=PAtkHyperlinkClass(G_TYPE_INSTANCE_GET_CLASS(obj,ATK_TYPE_HYPERLINK)); +end; + +{$ENDIF read_implementation} + diff --git a/packages/gtk2/src/atk/atkhypertext.inc b/packages/gtk2/src/atk/atkhypertext.inc new file mode 100644 index 0000000000..12b996dff8 --- /dev/null +++ b/packages/gtk2/src/atk/atkhypertext.inc @@ -0,0 +1,68 @@ +// included by atk.pp + +{ + The AtkHypertext interface provides standard mechanisms for manipulating + hyperlinks. + } + + +{$IFDEF read_forward_definitions} +{$ENDIF read_forward_definitions} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_types} + PAtkHypertextIface = ^TAtkHypertextIface; + TAtkHypertextIface = record + parent : TGTypeInterface; + get_link : function (hypertext:PAtkHypertext; link_index:gint):PAtkHyperlink; cdecl; + get_n_links : function (hypertext:PAtkHypertext):gint; cdecl; + get_link_index : function (hypertext:PAtkHypertext; char_index:gint):gint; cdecl; + pad1 : TAtkFunction; + pad2 : TAtkFunction; + pad3 : TAtkFunction; + pad4 : TAtkFunction; + end; + +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} +function ATK_TYPE_HYPERTEXT : GType; +function ATK_IS_HYPERTEXT(obj: pointer) : boolean; +function ATK_HYPERTEXT(obj: pointer) : PAtkHypertext; +function ATK_HYPERTEXT_GET_IFACE(obj: pointer) : PAtkHypertextIface; + + +function atk_hypertext_get_type:GType; cdecl; external atklib; +function atk_hypertext_get_link(hypertext:PAtkHypertext; link_index:gint):PAtkHyperlink; cdecl; external atklib; +function atk_hypertext_get_n_links(hypertext:PAtkHypertext):gint; cdecl; external atklib; +function atk_hypertext_get_link_index(hypertext:PAtkHypertext; char_index:gint):gint; cdecl; external atklib; +{$ENDIF read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function ATK_TYPE_HYPERTEXT : GType; +begin + ATK_TYPE_HYPERTEXT:=atk_hypertext_get_type; +end; + +function ATK_IS_HYPERTEXT(obj: pointer) : boolean; +begin + ATK_IS_HYPERTEXT:=G_TYPE_CHECK_INSTANCE_TYPE(obj,ATK_TYPE_HYPERTEXT); +end; + +function ATK_HYPERTEXT(obj: pointer) : PAtkHypertext; +begin + ATK_HYPERTEXT:=PAtkHypertext(G_TYPE_CHECK_INSTANCE_CAST(obj,ATK_TYPE_HYPERTEXT)); +end; + +function ATK_HYPERTEXT_GET_IFACE(obj: pointer) : PAtkHypertextIface; +begin + ATK_HYPERTEXT_GET_IFACE:=PAtkHypertextIface(G_TYPE_INSTANCE_GET_INTERFACE(obj,ATK_TYPE_HYPERTEXT)); +end; + +{$ENDIF read_implementation} + diff --git a/packages/gtk2/src/atk/atkimage.inc b/packages/gtk2/src/atk/atkimage.inc new file mode 100644 index 0000000000..a3b4a3d61c --- /dev/null +++ b/packages/gtk2/src/atk/atkimage.inc @@ -0,0 +1,68 @@ +// included by atk.pp + +{ + The AtkImage interface should be supported by any anObject that has an + associated image. This interface provides the standard mechanism for + an assistive technology to get descriptive information about images. + } + +{$IFDEF read_forward_definitions} +{$ENDIF read_forward_definitions} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_types} + PAtkImageIface = ^TAtkImageIface; + TAtkImageIface = record + parent : TGTypeInterface; + get_image_position : procedure (image:PAtkImage; x:Pgint; y:Pgint; coord_type:TAtkCoordType); cdecl; + get_image_description : function (image:PAtkImage):Pgchar; cdecl; + get_image_size : procedure (image:PAtkImage; width:Pgint; height:Pgint); cdecl; + set_image_description : function (image:PAtkImage; description:Pgchar):gboolean; cdecl; + pad1 : TAtkFunction; + pad2 : TAtkFunction; + end; + +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} +function ATK_TYPE_IMAGE : GType; +function ATK_IS_IMAGE(obj: pointer) : boolean; +function ATK_IMAGE(obj: pointer) : PAtkImage; +function ATK_IMAGE_GET_IFACE(obj: pointer) : PAtkImageIface; + + +function atk_image_get_type:GType; cdecl; external atklib; +function atk_image_get_image_description(image:PAtkImage):Pgchar; cdecl; external atklib; +procedure atk_image_get_image_size(image:PAtkImage; width:Pgint; height:Pgint); cdecl; external atklib; +function atk_image_set_image_description(image:PAtkImage; description:Pgchar):gboolean; cdecl; external atklib; +procedure atk_image_get_image_position(image:PAtkImage; x:Pgint; y:Pgint; coord_type:TAtkCoordType); cdecl; external atklib; +{$ENDIF read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function ATK_TYPE_IMAGE : GType; +begin + ATK_TYPE_IMAGE:=atk_image_get_type; +end; + +function ATK_IS_IMAGE(obj: pointer) : boolean; +begin + ATK_IS_IMAGE:=G_TYPE_CHECK_INSTANCE_TYPE(obj,ATK_TYPE_IMAGE); +end; + +function ATK_IMAGE(obj: pointer) : PAtkImage; +begin + ATK_IMAGE:=PAtkImage(G_TYPE_CHECK_INSTANCE_CAST(obj,ATK_TYPE_IMAGE)); +end; + +function ATK_IMAGE_GET_IFACE(obj: pointer) : PAtkImageIface; +begin + ATK_IMAGE_GET_IFACE:=PAtkImageIface(G_TYPE_INSTANCE_GET_INTERFACE(obj,ATK_TYPE_IMAGE)); +end; + +{$ENDIF read_implementation} + diff --git a/packages/gtk2/src/atk/atkincludes.inc b/packages/gtk2/src/atk/atkincludes.inc new file mode 100644 index 0000000000..04ab86b350 --- /dev/null +++ b/packages/gtk2/src/atk/atkincludes.inc @@ -0,0 +1,23 @@ +// included by atk.pp +{$include atkobject.inc} +{$include atkaction.inc} +{$include atkcomponent.inc} +{$include atkdocument.inc} +{$include atkeditabletext.inc} +{$include atkgobjectaccessible.inc} +{$include atkhyperlink.inc} +{$include atkhypertext.inc} +{$include atkimage.inc} +{$include atkobjectfactory.inc} +{$include atkregistry.inc} +{$include atkrelation.inc} +{$include atkrelationset.inc} +{$include atkselection.inc} +{$include atkstate.inc} +{$include atkstateset.inc} +{$include atkstreamablecontent.inc} +{$include atktable.inc} +{$include atktext.inc} +{$include atkutil.inc} +{$include atkvalue.inc} + diff --git a/packages/gtk2/src/atk/atkobject.inc b/packages/gtk2/src/atk/atkobject.inc new file mode 100644 index 0000000000..f82c377246 --- /dev/null +++ b/packages/gtk2/src/atk/atkobject.inc @@ -0,0 +1,510 @@ +// included by atk.pp + +{ + AtkObject represents the minimum information all accessible objects + return. This information includes accessible name, accessible + description, role and state of the anObject, as well information about + its parent and children. It is also possible to obtain more specific + accessibility information about a component if it supports one or more + of the following interfaces: + } + +{$IFDEF read_forward_definitions} +{$ENDIF read_forward_definitions} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_types} + +{ + AtkRole: + @ATK_ROLE_INVALID: Invalid role + @ATK_ROLE_ACCEL_LABEL: A label which represents an accelerator + @ATK_ROLE_ALERT: An anObject which is an alert to the user + @ATK_ROLE_ANIMATION: An anObject which is an animated image + @ATK_ROLE_ARROW: An arrow in one of the four cardinal directions + @ATK_ROLE_CALENDAR: An anObject that displays a calendar and allows the user to select a date + @ATK_ROLE_CANVAS: An anObject that can be drawn into and is used to trap events + @ATK_ROLE_CHECK_BOX: A choice that can be checked or unchecked and provides a separate indicator for the current state + @ATK_ROLE_CHECK_MENU_ITEM: A menu item with a check box + @ATK_ROLE_COLOR_CHOOSER: A specialized dialog that lets the user choose a color + @ATK_ROLE_COLUMN_HEADER: The header for a column of data + @ATK_ROLE_COMBO_BOX: A list of choices the user can select from + @ATK_ROLE_DATE_EDITOR: An anObject whose purpose is to allow a user to edit a date + @ATK_ROLE_DESKTOP_ICON: An inconifed internal frame within a DESKTOP_PANE + @ATK_ROLE_DESKTOP_FRAME: A pane that supports internal frames and iconified versions of those internal frames + @ATK_ROLE_DIAL: An anObject whose purpose is to allow a user to set a value + @ATK_ROLE_DIALOG: A top level window with title bar and a border + @ATK_ROLE_DIRECTORY_PANE: A pane that allows the user to navigate through and select the contents of a directory + @ATK_ROLE_DRAWING_AREA: An anObject used for drawing custom user interface elements + @ATK_ROLE_FILE_CHOOSER: A specialized dialog that lets the user choose a file + @ATK_ROLE_FILLER: A anObject that fills up space in a user interface + @ATK_ROLE_FONT_CHOOSER: A specialized dialog that lets the user choose a font + @ATK_ROLE_FRAME: A top level window with a title bar, border, menubar, etc. + @ATK_ROLE_GLASS_PANE: A pane that is guaranteed to be painted on top of all panes beneath it + @ATK_ROLE_HTML_CONTAINER: A document container for HTML, whose children represent the document content + @ATK_ROLE_ICON: A small fixed size picture, typically used to decorate components + @ATK_ROLE_IMAGE: An anObject whose primary purpose is to display an image + @ATK_ROLE_INTERNAL_FRAME: A frame-like anObject that is clipped by a desktop pane + @ATK_ROLE_LABEL: An anObject used to present an icon or short string in an interface + @ATK_ROLE_LAYERED_PANE: A specialized pane that allows its children to be drawn in layers, providing a form of stacking order + @ATK_ROLE_LIST: An anObject that presents a list of objects to the user and allows the user to select one or more of them + @ATK_ROLE_LIST_ITEM: An anObject that represents an element of a list + @ATK_ROLE_MENU: An anObject usually found inside a menu bar that contains a list of actions the user can choose from + @ATK_ROLE_MENU_BAR: An anObject usually drawn at the top of the primary dialog box of an application that contains a list of menus the user can choose from + @ATK_ROLE_MENU_ITEM: An anObject usually contained in a menu that presents an action the user can choose + @ATK_ROLE_OPTION_PANE: A specialized pane whose primary use is inside a DIALOG + @ATK_ROLE_PAGE_TAB: An anObject that is a child of a page tab list + @ATK_ROLE_PAGE_TAB_LIST: An anObject that presents a series of panels (or page tabs), one at a time, through some mechanism provided by the anObject + @ATK_ROLE_PANEL: A generic container that is often used to group objects + @ATK_ROLE_PASSWORD_TEXT: A text anObject uses for passwords, or other places where the text content is not shown visibly to the user + @ATK_ROLE_POPUP_MENU: A temporary window that is usually used to offer the user a list of choices, and then hides when the user selects one of those choices + @ATK_ROLE_PROGRESS_BAR: An anObject used to indicate how much of a task has been completed + @ATK_ROLE_PUSH_BUTTON: An anObject the user can manipulate to tell the application to do something + @ATK_ROLE_RADIO_BUTTON: A specialized check box that will cause other radio buttons in the same group to become unchecked when this one is checked + @ATK_ROLE_RADIO_MENU_ITEM: A check menu item which belongs to a group. At each instant exactly one of the radio menu items from a group is selected + @ATK_ROLE_ROOT_PANE: A specialized pane that has a glass pane and a layered pane as its children + @ATK_ROLE_ROW_HEADER: The header for a row of data + @ATK_ROLE_SCROLL_BAR: An anObject usually used to allow a user to incrementally view a large amount of data. + @ATK_ROLE_SCROLL_PANE: An anObject that allows a user to incrementally view a large amount of information + @ATK_ROLE_SEPARATOR: An anObject usually contained in a menu to provide a visible and logical separation of the contents in a menu + @ATK_ROLE_SLIDER: An anObject that allows the user to select from a bounded range + @ATK_ROLE_SPLIT_PANE: A specialized panel that presents two other panels at the same time + @ATK_ROLE_SPIN_BUTTON: An anObject used to get an integer or floating point number from the user + @ATK_ROLE_STATUSBAR: An anObject which reports messages of minor importance to the user + @ATK_ROLE_TABLE: An anObject used to represent information in terms of rows and columns + @ATK_ROLE_TABLE_CELL: A cell in a table + @ATK_ROLE_TABLE_COLUMN_HEADER: The header for a column of a table + @ATK_ROLE_TABLE_ROW_HEADER: The header for a row of a table + @ATK_ROLE_TEAR_OFF_MENU_ITEM: A menu item used to tear off and reattach its menu + @ATK_ROLE_TERMINAL: An anObject that represents an accessible terminal + @ATK_ROLE_TEXT: An anObject that presents text to the user + @ATK_ROLE_TOGGLE_BUTTON: A specialized push button that can be checked or unchecked, but does not provide a separate indicator for the current state + @ATK_ROLE_TOOL_BAR: A bar or palette usually composed of push buttons or toggle buttons + @ATK_ROLE_TOOL_TIP: An anObject that provides information about another anObject + @ATK_ROLE_TREE: An anObject used to represent hierarchical information to the user + @ATK_ROLE_TREE_TABLE: An anObject capable of expanding and collapsing rows as well as showing multiple columns of data + @ATK_ROLE_UNKNOWN: The anObject contains some Accessible information, but its role is not known + @ATK_ROLE_VIEWPORT: An anObject usually used in a scroll pane + @ATK_ROLE_WINDOW: A top level window with no title or border + @ATK_ROLE_LAST_DEFINED: not a valid role, used for finding theEnd of enumeration + + Describes the role of an anObject + } + PAtkRole = ^TAtkRole; + TAtkRole = ( + ATK_ROLE_INVALID {:= 0}, + ATK_ROLE_ACCEL_LABEL, + ATK_ROLE_ALERT, + ATK_ROLE_ANIMATION, + ATK_ROLE_ARROW, + ATK_ROLE_CALENDAR, + ATK_ROLE_CANVAS, + ATK_ROLE_CHECK_BOX, + ATK_ROLE_CHECK_MENU_ITEM, + ATK_ROLE_COLOR_CHOOSER, + ATK_ROLE_COLUMN_HEADER, + ATK_ROLE_COMBO_BOX, + ATK_ROLE_DATE_EDITOR, + ATK_ROLE_DESKTOP_ICON, + ATK_ROLE_DESKTOP_FRAME, + ATK_ROLE_DIAL, + ATK_ROLE_DIALOG, + ATK_ROLE_DIRECTORY_PANE, + ATK_ROLE_DRAWING_AREA, + ATK_ROLE_FILE_CHOOSER, + ATK_ROLE_FILLER, + ATK_ROLE_FONT_CHOOSER, + ATK_ROLE_FRAME, + ATK_ROLE_GLASS_PANE, + ATK_ROLE_HTML_CONTAINER, + ATK_ROLE_ICON, + ATK_ROLE_IMAGE, + ATK_ROLE_INTERNAL_FRAME, + ATK_ROLE_LABEL, + ATK_ROLE_LAYERED_PANE, + ATK_ROLE_LIST, + ATK_ROLE_LIST_ITEM, + ATK_ROLE_MENU, + ATK_ROLE_MENU_BAR, + ATK_ROLE_MENU_ITEM, + ATK_ROLE_OPTION_PANE, + ATK_ROLE_PAGE_TAB, + ATK_ROLE_PAGE_TAB_LIST, + ATK_ROLE_PANEL, + ATK_ROLE_PASSWORD_TEXT, + ATK_ROLE_POPUP_MENU, + ATK_ROLE_PROGRESS_BAR, + ATK_ROLE_PUSH_BUTTON, + ATK_ROLE_RADIO_BUTTON, + ATK_ROLE_RADIO_MENU_ITEM, + ATK_ROLE_ROOT_PANE, + ATK_ROLE_ROW_HEADER, + ATK_ROLE_SCROLL_BAR, + ATK_ROLE_SCROLL_PANE, + ATK_ROLE_SEPARATOR, + ATK_ROLE_SLIDER, + ATK_ROLE_SPLIT_PANE, + ATK_ROLE_SPIN_BUTTON, + ATK_ROLE_STATUSBAR, + ATK_ROLE_TABLE, + ATK_ROLE_TABLE_CELL, + ATK_ROLE_TABLE_COLUMN_HEADER, + ATK_ROLE_TABLE_ROW_HEADER, + ATK_ROLE_TEAR_OFF_MENU_ITEM, + ATK_ROLE_TERMINAL, + ATK_ROLE_TEXT, + ATK_ROLE_TOGGLE_BUTTON, + ATK_ROLE_TOOL_BAR, + ATK_ROLE_TOOL_TIP, + ATK_ROLE_TREE, + ATK_ROLE_TREE_TABLE, + ATK_ROLE_UNKNOWN, + ATK_ROLE_VIEWPORT, + ATK_ROLE_WINDOW, + ATK_ROLE_LAST_DEFINED + ); + + +{ + AtkLayer: + @ATK_LAYER_INVALID: The anObject does not have a layer + @ATK_LAYER_BACKGROUND: This layer is reserved for the desktop background + @ATK_LAYER_CANVAS: This layer is used for Canvas components + @ATK_LAYER_WIDGET: This layer is normally used for components + @ATK_LAYER_MDI: This layer is used for layered components + @ATK_LAYER_POPUP: This layer is used for popup components, such as menus + @ATK_LAYER_OVERLAY: This layer is reserved for future use. + + Describes the layer of a component + } + PAtkLayer = ^TAtkLayer; + TAtkLayer = ( + ATK_LAYER_INVALID, + ATK_LAYER_BACKGROUND, + ATK_LAYER_CANVAS, + ATK_LAYER_WIDGET, + ATK_LAYER_MDI, + ATK_LAYER_POPUP, + ATK_LAYER_OVERLAY + ); + + + PAtkPropertyValues = ^TAtkPropertyValues; + TAtkPropertyValues = record + property_name : Pgchar; + old_value : TGValue; + new_value : TGValue; + end; + + + TAtkFunction = function (data:gpointer):gboolean; cdecl; +{ + For most properties the old_value field of AtkPropertyValues will + not contain a valid value. + + Currently, the only property for which old_value is used is + accessible-state; for instance if there is a focus state the + property change handler will be called for the anObject which lost the focus + with the old_value containing an AtkState value corresponding to focused + and the property change handler will be called for the anObject which + received the focus with the new_value containing an AtkState value + corresponding to focused. + } + + PAtkObject = ^TAtkObject; + PPAtkObject = ^PAtkObject; + TAtkObject = record + parent : TGObject; + description : Pgchar; + name : Pgchar; + accessible_parent : PAtkObject; + role : TAtkRole; + relation_set : PAtkRelationSet; + layer : TAtkLayer; + end; + + TAtkPropertyChangeHandler = procedure (para1:PAtkObject; para2:PAtkPropertyValues); cdecl; + +{ + Gets the accessible name of the anObject + } +{ + Gets the accessible description of the anObject + } +{ + Gets the accessible parent of the anObject + } +{ + Gets the number of accessible children of the anObject + } +{ + Returns a reference to the specified accessible child of the anObject. + The accessible children are 0-based so the first accessible child is + at index 0, the second at index 1 and so on. + } +{ + Gets the 0-based index of this anObject in its parent; returns -1 if the + anObject does not have an accessible parent. + } +{ + Gets the RelationSet associated with the anObject + } +{ + Gets the role of the anObject + } +{ + Gets the state set of the anObject + } +{ + Sets the accessible name of the anObject + } +{ + Sets the accessible description of the anObject + } +{ + Sets the accessible parent of the anObject + } +{ + Sets the accessible role of the anObject + } +{ + Specifies a function to be called when a property changes value + } +{ + Removes a property change handler which was specified using + connect_property_change_handler + } +{ + The signal handler which is executed when there is a change in the + children of the anObject + } +{ + The signal handler which is executed when there is a focus event + for an anObject. + } +{ + The signal handler which is executed when there is a property_change + signal for an anObject. + } +{ + The signal handler which is executed when there is a state_change + signal for an anObject. + } +{ + The signal handler which is executed when there is a change in the + visible data for an anObject + } + PAtkObjectClass = ^TAtkObjectClass; + TAtkObjectClass = record + parent : TGObjectClass; + get_name : function (accessible:PAtkObject):Pgchar; cdecl; + get_description : function (accessible:PAtkObject):Pgchar; cdecl; + get_parent : function (accessible:PAtkObject):PAtkObject; cdecl; + get_n_children : function (accessible:PAtkObject):gint; cdecl; + ref_child : function (accessible:PAtkObject; i:gint):PAtkObject; cdecl; + get_index_in_parent : function (accessible:PAtkObject):gint; cdecl; + ref_relation_set : function (accessible:PAtkObject):PAtkRelationSet; cdecl; + get_role : function (accessible:PAtkObject):TAtkRole; cdecl; + get_layer : function (accessible:PAtkObject):TAtkLayer; cdecl; + get_mdi_zorder : function (accessible:PAtkObject):gint; cdecl; + ref_state_set : function (accessible:PAtkObject):PAtkStateSet; cdecl; + set_name : procedure (accessible:PAtkObject; name:Pgchar); cdecl; + set_description : procedure (accessible:PAtkObject; description:Pgchar); cdecl; + set_parent : procedure (accessible:PAtkObject; parent:PAtkObject); cdecl; + set_role : procedure (accessible:PAtkObject; role:TAtkRole); cdecl; + connect_property_change_handler : function (accessible:PAtkObject; handler:TAtkPropertyChangeHandler):guint; cdecl; + remove_property_change_handler : procedure (accessible:PAtkObject; handler_id:guint); cdecl; + initialize : procedure (accessible:PAtkObject; data:gpointer); cdecl; + children_changed : procedure (accessible:PAtkObject; change_index:guint; changed_child:gpointer); cdecl; + focus_event : procedure (accessible:PAtkObject; focus_in:gboolean); cdecl; + property_change : procedure (accessible:PAtkObject; values:PAtkPropertyValues); cdecl; + state_change : procedure (accessible:PAtkObject; name:Pgchar; state_set:gboolean); cdecl; + visible_data_changed : procedure (accessible:PAtkObject); cdecl; + pad1 : TAtkFunction; + pad2 : TAtkFunction; + pad3 : TAtkFunction; + pad4 : TAtkFunction; + end; + + PAtkImplementorIface = ^TAtkImplementorIface; + TAtkImplementorIface = record + parent : TGTypeInterface; + ref_accessible : function (implementor:PAtkImplementor):PAtkObject; cdecl; + end; + + +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} +function atk_role_register(name:Pgchar):TAtkRole; cdecl; external atklib; + +function atk_object_get_type:GType; cdecl; external atklib; + +function ATK_TYPE_OBJECT : GType; +function ATK_OBJECT(obj: pointer) : PAtkObject; +function ATK_OBJECT_CLASS(klass: pointer) : PAtkObjectClass; +function ATK_IS_OBJECT(obj: pointer) : boolean; +function ATK_IS_OBJECT_CLASS(klass: pointer) : boolean; +function ATK_OBJECT_GET_CLASS(obj: pointer) : PAtkObjectClass; + +function ATK_TYPE_IMPLEMENTOR : GType; +function ATK_IS_IMPLEMENTOR(obj: pointer) : boolean; +function ATK_IMPLEMENTOR(obj: pointer) : PAtkImplementor; +function ATK_IMPLEMENTOR_GET_IFACE(obj: pointer) : PAtkImplementorIface; + +function atk_implementor_get_type:GType; cdecl; external atklib; +{ + This method uses the ref_accessible method in AtkImplementorIface, + if the anObject's class implements AtkImplementorIface. + Otherwise it returns %NULL. + + IMPORTANT: + Note also that because this method may return flyweight objects, + it increments the returned AtkObject's reference count. + Therefore it is the responsibility of the calling + program to unreference the anObject when no longer needed. + (c.f. gtk_widget_get_accessible() where this is not the case). + } +function atk_implementor_ref_accessible(implementor:PAtkImplementor):PAtkObject; cdecl; external atklib; +{ + Properties directly supported by AtkObject + } +function atk_object_get_name(accessible:PAtkObject):Pgchar; cdecl; external atklib; +function atk_object_get_description(accessible:PAtkObject):Pgchar; cdecl; external atklib; +function atk_object_get_parent(accessible:PAtkObject):PAtkObject; cdecl; external atklib; +function atk_object_get_n_accessible_children(accessible:PAtkObject):gint; cdecl; external atklib; +function atk_object_ref_accessible_child(accessible:PAtkObject; i:gint):PAtkObject; cdecl; external atklib; +function atk_object_ref_relation_set(accessible:PAtkObject):PAtkRelationSet; cdecl; external atklib; +function atk_object_get_role(accessible:PAtkObject):TAtkRole; cdecl; external atklib; +function atk_object_get_layer(accessible:PAtkObject):TAtkLayer; cdecl; external atklib; +function atk_object_get_mdi_zorder(accessible:PAtkObject):gint; cdecl; external atklib; +function atk_object_ref_state_set(accessible:PAtkObject):PAtkStateSet; cdecl; external atklib; +function atk_object_get_index_in_parent(accessible:PAtkObject):gint; cdecl; external atklib; +procedure atk_object_set_name(accessible:PAtkObject; name:Pgchar); cdecl; external atklib; +procedure atk_object_set_description(accessible:PAtkObject; description:Pgchar); cdecl; external atklib; +procedure atk_object_set_parent(accessible:PAtkObject; parent:PAtkObject); cdecl; external atklib; +procedure atk_object_set_role(accessible:PAtkObject; role:TAtkRole); cdecl; external atklib; +function atk_object_connect_property_change_handler(accessible:PAtkObject; handler:TAtkPropertyChangeHandler):guint; cdecl; external atklib; +procedure atk_object_remove_property_change_handler(accessible:PAtkObject; handler_id:guint); cdecl; external atklib; +procedure atk_object_notify_state_change(accessible:PAtkObject; state:TAtkState; value:gboolean); cdecl; external atklib; +procedure atk_object_initialize(accessible:PAtkObject; data:gpointer); cdecl; external atklib; +function atk_role_get_name(role:TAtkRole):Pgchar; cdecl; external atklib; +function atk_role_for_name(name:Pgchar):TAtkRole; cdecl; external atklib; +{ + Note: the properties which are registered with the GType + property registry, for type ATK_TYPE_OBJECT, are as follows: + + "accessible-name" + "accessible-description" + "accessible-parent" + "accessible-role" + "accessible-value" + "accessible-component-layer" + "accessible-component-zorder" + "accessible-table-caption" + "accessible-table-column-description" + "accessible-table-column-header" + "accessible-table-row-description" + "accessible-table-row-header" + "accessible-table-summary" + "accessible-model" + + accessibility property change listeners should use the + normal GObject property interfaces and "property-change" + signal handler semantics to interpret the property change + information relayed from AtkObject. + (AtkObject instances will connect to the "notify" + signal in their host objects, and relay the signals when appropriate). + } +(* For other signals, see related interfaces + + AtkActionIface, + AtkComponentIface, + AtkHypertextIface, + AtkImageIface, + AtkSelectionIface, + AtkTableIface, + AtkTextIface, + AtkValueIface. + + The usage model for obtaining these interface instances is: + ATK_<interfacename>_GET_IFACE(GObject accessible), + where accessible, though specified as a GObject, is + the AtkObject instance being queried. + More usually, the interface will be used via a cast to the + interface's corresponding "type": + + var + textImpl: PAtkText; + begin + textImpl := ATK_TEXT(accessible); + if (textImpl<>nil) then + cpos := atk_text_get_caret_position(textImpl); + end; + + If it's known in advance that accessible implements AtkTextIface, + this is shortened to: + + cpos := atk_text_get_caret_position (ATK_TEXT (accessible)); +*) + +{$ENDIF read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function ATK_TYPE_OBJECT : GType; +begin + ATK_TYPE_OBJECT:=atk_object_get_type; +end; + +function ATK_OBJECT(obj: pointer) : PAtkObject; +begin + ATK_OBJECT:=PAtkObject(G_TYPE_CHECK_INSTANCE_CAST(obj,ATK_TYPE_OBJECT)); +end; + +function ATK_OBJECT_CLASS(klass: pointer) : PAtkObjectClass; +begin + ATK_OBJECT_CLASS:=PAtkObjectClass(G_TYPE_CHECK_CLASS_CAST(klass,ATK_TYPE_OBJECT)); +end; + +function ATK_IS_OBJECT(obj: pointer) : boolean; +begin + ATK_IS_OBJECT:=G_TYPE_CHECK_INSTANCE_TYPE(obj,ATK_TYPE_OBJECT); +end; + +function ATK_IS_OBJECT_CLASS(klass: pointer) : boolean; +begin + ATK_IS_OBJECT_CLASS:=G_TYPE_CHECK_CLASS_TYPE(klass,ATK_TYPE_OBJECT); +end; + +function ATK_OBJECT_GET_CLASS(obj: pointer) : PAtkObjectClass; +begin + ATK_OBJECT_GET_CLASS:=PAtkObjectClass(G_TYPE_INSTANCE_GET_CLASS(obj,ATK_TYPE_OBJECT)); +end; + +function ATK_TYPE_IMPLEMENTOR : GType; +begin + ATK_TYPE_IMPLEMENTOR:=atk_implementor_get_type; +end; + +function ATK_IS_IMPLEMENTOR(obj: pointer) : boolean; +begin + ATK_IS_IMPLEMENTOR:=G_TYPE_CHECK_INSTANCE_TYPE(obj,ATK_TYPE_IMPLEMENTOR); +end; + +function ATK_IMPLEMENTOR(obj: pointer) : PAtkImplementor; +begin + ATK_IMPLEMENTOR:=PAtkImplementor(G_TYPE_CHECK_INSTANCE_CAST(obj,ATK_TYPE_IMPLEMENTOR)); +end; + +function ATK_IMPLEMENTOR_GET_IFACE(obj: pointer) : PAtkImplementorIface; +begin + ATK_IMPLEMENTOR_GET_IFACE:=PAtkImplementorIface(G_TYPE_INSTANCE_GET_INTERFACE(obj,ATK_TYPE_IMPLEMENTOR)); +end; + +{$ENDIF read_implementation} + diff --git a/packages/gtk2/src/atk/atkobjectfactory.inc b/packages/gtk2/src/atk/atkobjectfactory.inc new file mode 100644 index 0000000000..dfdc990972 --- /dev/null +++ b/packages/gtk2/src/atk/atkobjectfactory.inc @@ -0,0 +1,77 @@ +// included by atk.pp + +{$IFDEF read_forward_definitions} +{$ENDIF read_forward_definitions} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_types} + PAtkObjectFactory = ^TAtkObjectFactory; + TAtkObjectFactory = record + parent : TGObject; + end; + + PAtkObjectFactoryClass = ^TAtkObjectFactoryClass; + TAtkObjectFactoryClass = record + parent_class : TGObjectClass; + create_accessible : function (obj:PGObject):PAtkObject; cdecl; + invalidate : procedure (factory:PAtkObjectFactory); cdecl; + get_accessible_type : function :GType; cdecl; + pad1 : TAtkFunction; + pad2 : TAtkFunction; + end; + +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} +function ATK_TYPE_OBJECT_FACTORY : GType; +function ATK_OBJECT_FACTORY(obj: pointer) : PAtkObjectFactory; +function ATK_OBJECT_FACTORY_CLASS(klass: pointer) : PAtkObjectFactoryClass; +function ATK_IS_OBJECT_FACTORY(obj: pointer) : boolean; +function ATK_IS_OBJECT_FACTORY_CLASS(klass: pointer) : boolean; +function ATK_OBJECT_FACTORY_GET_CLASS(obj: pointer) : PAtkObjectFactoryClass; + + +function atk_object_factory_get_type:GType; cdecl; external atklib; +function atk_object_factory_create_accessible(factory:PAtkObjectFactory; obj:PGObject):PAtkObject; cdecl; external atklib; +procedure atk_object_factory_invalidate(factory:PAtkObjectFactory); cdecl; external atklib; +function atk_object_factory_get_accessible_type(factory:PAtkObjectFactory):GType; cdecl; external atklib; +{$ENDIF read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function ATK_TYPE_OBJECT_FACTORY : GType; +begin + ATK_TYPE_OBJECT_FACTORY:=atk_object_factory_get_type; +end; + +function ATK_OBJECT_FACTORY(obj: pointer) : PAtkObjectFactory; +begin + ATK_OBJECT_FACTORY:=PAtkObjectFactory(G_TYPE_CHECK_INSTANCE_CAST(obj,ATK_TYPE_OBJECT_FACTORY)); +end; + +function ATK_OBJECT_FACTORY_CLASS(klass: pointer) : PAtkObjectFactoryClass; +begin + ATK_OBJECT_FACTORY_CLASS:=PAtkObjectFactoryClass(G_TYPE_CHECK_CLASS_CAST(klass,ATK_TYPE_OBJECT_FACTORY)); +end; + +function ATK_IS_OBJECT_FACTORY(obj: pointer) : boolean; +begin + ATK_IS_OBJECT_FACTORY:=G_TYPE_CHECK_INSTANCE_TYPE(obj,ATK_TYPE_OBJECT_FACTORY); +end; + +function ATK_IS_OBJECT_FACTORY_CLASS(klass: pointer) : boolean; +begin + ATK_IS_OBJECT_FACTORY_CLASS:=G_TYPE_CHECK_CLASS_TYPE(klass,ATK_TYPE_OBJECT_FACTORY); +end; + +function ATK_OBJECT_FACTORY_GET_CLASS(obj: pointer) : PAtkObjectFactoryClass; +begin + ATK_OBJECT_FACTORY_GET_CLASS:=PAtkObjectFactoryClass(G_TYPE_INSTANCE_GET_CLASS(obj,ATK_TYPE_OBJECT_FACTORY)); +end; + +{$ENDIF read_implementation} + diff --git a/packages/gtk2/src/atk/atkregistry.inc b/packages/gtk2/src/atk/atkregistry.inc new file mode 100644 index 0000000000..41e1bbefcf --- /dev/null +++ b/packages/gtk2/src/atk/atkregistry.inc @@ -0,0 +1,75 @@ +// included by atk.pp + +{$IFDEF read_forward_definitions} +{$ENDIF read_forward_definitions} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_types} + PAtkRegistry = ^TAtkRegistry; + TAtkRegistry = record + parent : TGObject; + factory_type_registry : PGHashTable; + factory_singleton_cache : PGHashTable; + end; + + PAtkRegistryClass = ^TAtkRegistryClass; + TAtkRegistryClass = record + parent_class : TGObjectClass; + end; + +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} +function ATK_TYPE_REGISTRY : GType; +function ATK_REGISTRY(obj: pointer) : PAtkRegistry; +function ATK_REGISTRY_CLASS(klass: pointer) : PAtkRegistryClass; +function ATK_IS_REGISTRY(obj: pointer) : boolean; +function ATK_IS_REGISTRY_CLASS(klass: pointer) : boolean; +function ATK_REGISTRY_GET_CLASS(obj: pointer) : PAtkRegistryClass; + + +function atk_registry_get_type:GType; cdecl; external atklib; +procedure atk_registry_set_factory_type(registry:PAtkRegistry; _type:GType; factory_type:GType); cdecl; external atklib; +function atk_registry_get_factory_type(registry:PAtkRegistry; _type:GType):GType; cdecl; external atklib; +function atk_registry_get_factory(registry:PAtkRegistry; _type:GType):PAtkObjectFactory; cdecl; external atklib; +function atk_get_default_registry:PAtkRegistry; cdecl; external atklib; +{$ENDIF read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function ATK_TYPE_REGISTRY : GType; +begin + ATK_TYPE_REGISTRY:=atk_registry_get_type; +end; + +function ATK_REGISTRY(obj: pointer) : PAtkRegistry; +begin + ATK_REGISTRY:=PAtkRegistry(G_TYPE_CHECK_INSTANCE_CAST(obj,ATK_TYPE_REGISTRY)); +end; + +function ATK_REGISTRY_CLASS(klass: pointer) : PAtkRegistryClass; +begin + ATK_REGISTRY_CLASS:=PAtkRegistryClass(G_TYPE_CHECK_CLASS_CAST(klass,ATK_TYPE_REGISTRY)); +end; + +function ATK_IS_REGISTRY(obj: pointer) : boolean; +begin + ATK_IS_REGISTRY:=G_TYPE_CHECK_INSTANCE_TYPE(obj,ATK_TYPE_REGISTRY); +end; + +function ATK_IS_REGISTRY_CLASS(klass: pointer) : boolean; +begin + ATK_IS_REGISTRY_CLASS:=G_TYPE_CHECK_CLASS_TYPE(klass,ATK_TYPE_REGISTRY); +end; + +function ATK_REGISTRY_GET_CLASS(obj: pointer) : PAtkRegistryClass; +begin + ATK_REGISTRY_GET_CLASS:=PAtkRegistryClass(G_TYPE_INSTANCE_GET_CLASS(obj,ATK_TYPE_REGISTRY)); +end; + +{$ENDIF read_implementation} + diff --git a/packages/gtk2/src/atk/atkrelation.inc b/packages/gtk2/src/atk/atkrelation.inc new file mode 100644 index 0000000000..38a57a6da8 --- /dev/null +++ b/packages/gtk2/src/atk/atkrelation.inc @@ -0,0 +1,113 @@ +// included by atk.pp + +{ + An AtkRelation describes a relation between the anObject and one or more + other objects. The actual relations that an anObject has with other objects + are defined as an AtkRelationSet, which is a set of AtkRelations. + } + +{$IFDEF read_forward_definitions} +{$ENDIF read_forward_definitions} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_types} +{ + AtkRelationType: + @ATK_RELATION_NULL: + @ATK_RELATION_CONTROLLED_BY: Indicates an anObject controlled by one or more target objects. + @ATK_RELATION_CONTROLLER_FOR: Indicates an anObject is an controller for one or more target objects. + @ATK_RELATION_LABEL_FOR: Indicates an anObject is a label for one or more target objects. + @ATK_RELATION_LABELLED_BY: Indicates an anObject is labelled by one or more target objects. + @ATK_RELATION_MEMBER_OF: Indicates an anObject is a member of a group of one or more target objects. + @ATK_RELATION_NODE_CHILD_OF: Indicates an anObject is a cell in a treetable which is displayed because a cell in the same column is expanded and identifies that cell. + @ATK_RELATION_LAST_DEFINED: + + Describes the type of the relation + } + PAtkRelationType = ^TAtkRelationType; + TAtkRelationType = ( + ATK_RELATION_NULL {:= 0}, + ATK_RELATION_CONTROLLED_BY, + ATK_RELATION_CONTROLLER_FOR, + ATK_RELATION_LABEL_FOR, + ATK_RELATION_LABELLED_BY, + ATK_RELATION_MEMBER_OF, + ATK_RELATION_NODE_CHILD_OF, + ATK_RELATION_LAST_DEFINED + ); + + + PAtkRelation = ^TAtkRelation; + TAtkRelation = record + parent : TGObject; + target : PGPtrArray; + relationship : TAtkRelationType; + end; + + PAtkRelationClass = ^TAtkRelationClass; + TAtkRelationClass = record + parent : TGObjectClass; + end; + +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} + +function ATK_TYPE_RELATION : GType; +function ATK_RELATION(obj: pointer) : PAtkRelation; +function ATK_RELATION_CLASS(klass: pointer) : PAtkRelationClass; +function ATK_IS_RELATION(obj: pointer) : boolean; +function ATK_IS_RELATION_CLASS(klass: pointer) : boolean; +function ATK_RELATION_GET_CLASS(obj: pointer) : PAtkRelationClass; + + +function atk_relation_get_type:GType; cdecl; external atklib; +function atk_relation_type_register(name:Pgchar):TAtkRelationType; cdecl; external atklib; +function atk_relation_type_get_name(_type:TAtkRelationType):Pgchar; cdecl; external atklib; +function atk_relation_type_for_name(name:Pgchar):TAtkRelationType; cdecl; external atklib; +{ Create a new relation for the specified key and the specified list of targets. } +function atk_relation_new(targets:PPAtkObject; n_targets:gint; relationship:TAtkRelationType):PAtkRelation; cdecl; external atklib; +{ Returns the type of a relation. } +function atk_relation_get_relation_type(relation:PAtkRelation):TAtkRelationType; cdecl; external atklib; +{ Returns the target list of a relation. } +function atk_relation_get_target(relation:PAtkRelation):PGPtrArray; cdecl; external atklib; +{$ENDIF read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function ATK_TYPE_RELATION : GType; +begin + ATK_TYPE_RELATION:=atk_relation_get_type; +end; + +function ATK_RELATION(obj: pointer) : PAtkRelation; +begin + ATK_RELATION:=PAtkRelation(G_TYPE_CHECK_INSTANCE_CAST(obj,ATK_TYPE_RELATION)); +end; + +function ATK_RELATION_CLASS(klass: pointer) : PAtkRelationClass; +begin + ATK_RELATION_CLASS:=PAtkRelationClass(G_TYPE_CHECK_CLASS_CAST(klass,ATK_TYPE_RELATION)); +end; + +function ATK_IS_RELATION(obj: pointer) : boolean; +begin + ATK_IS_RELATION:=G_TYPE_CHECK_INSTANCE_TYPE(obj,ATK_TYPE_RELATION); +end; + +function ATK_IS_RELATION_CLASS(klass: pointer) : boolean; +begin + ATK_IS_RELATION_CLASS:=G_TYPE_CHECK_CLASS_TYPE(klass,ATK_TYPE_RELATION); +end; + +function ATK_RELATION_GET_CLASS(obj: pointer) : PAtkRelationClass; +begin + ATK_RELATION_GET_CLASS:=PAtkRelationClass(G_TYPE_INSTANCE_GET_CLASS(obj,ATK_TYPE_RELATION)); +end; + +{$ENDIF read_implementation} + diff --git a/packages/gtk2/src/atk/atkrelationset.inc b/packages/gtk2/src/atk/atkrelationset.inc new file mode 100644 index 0000000000..2c8639ec7e --- /dev/null +++ b/packages/gtk2/src/atk/atkrelationset.inc @@ -0,0 +1,79 @@ +// included by atk.pp + +{$IFDEF read_forward_definitions} + PAtkRelationSet = ^TAtkRelationSet; +{$ENDIF read_forward_definitions} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_types} + TAtkRelationSet = record + parent : TGObject; + relations : PGPtrArray; + end; + + PAtkRelationSetClass = ^TAtkRelationSetClass; + TAtkRelationSetClass = record + parent : TGObjectClass; + pad1 : TAtkFunction; + pad2 : TAtkFunction; + end; + +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} +function ATK_TYPE_RELATION_SET : GType; +function ATK_RELATION_SET(obj: pointer) : PAtkRelationSet; +function ATK_RELATION_SET_CLASS(klass: pointer) : PAtkRelationSetClass; +function ATK_IS_RELATION_SET(obj: pointer) : boolean; +function ATK_IS_RELATION_SET_CLASS(klass: pointer) : boolean; +function ATK_RELATION_SET_GET_CLASS(obj: pointer) : PAtkRelationSetClass; + + +function atk_relation_set_get_type:GType; cdecl; external atklib; +function atk_relation_set_new:PAtkRelationSet; cdecl; external atklib; +function atk_relation_set_contains(RelationSet:PAtkRelationSet; relationship:TAtkRelationType):gboolean; cdecl; external atklib; +procedure atk_relation_set_remove(RelationSet:PAtkRelationSet; relation:PAtkRelation); cdecl; external atklib; +procedure atk_relation_set_add(RelationSet:PAtkRelationSet; relation:PAtkRelation); cdecl; external atklib; +function atk_relation_set_get_n_relations(RelationSet:PAtkRelationSet):gint; cdecl; external atklib; +function atk_relation_set_get_relation(RelationSet:PAtkRelationSet; i:gint):PAtkRelation; cdecl; external atklib; +function atk_relation_set_get_relation_by_type(RelationSet:PAtkRelationSet; relationship:TAtkRelationType):PAtkRelation; cdecl; external atklib; +{$ENDIF read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function ATK_TYPE_RELATION_SET : GType; +begin + ATK_TYPE_RELATION_SET:=atk_relation_set_get_type; +end; + +function ATK_RELATION_SET(obj: pointer) : PAtkRelationSet; +begin + ATK_RELATION_SET:=PAtkRelationSet(G_TYPE_CHECK_INSTANCE_CAST(obj,ATK_TYPE_RELATION_SET)); +end; + +function ATK_RELATION_SET_CLASS(klass: pointer) : PAtkRelationSetClass; +begin + ATK_RELATION_SET_CLASS:=PAtkRelationSetClass(G_TYPE_CHECK_CLASS_CAST(klass,ATK_TYPE_RELATION_SET)); +end; + +function ATK_IS_RELATION_SET(obj: pointer) : boolean; +begin + ATK_IS_RELATION_SET:=G_TYPE_CHECK_INSTANCE_TYPE(obj,ATK_TYPE_RELATION_SET); +end; + +function ATK_IS_RELATION_SET_CLASS(klass: pointer) : boolean; +begin + ATK_IS_RELATION_SET_CLASS:=G_TYPE_CHECK_CLASS_TYPE(klass,ATK_TYPE_RELATION_SET); +end; + +function ATK_RELATION_SET_GET_CLASS(obj: pointer) : PAtkRelationSetClass; +begin + ATK_RELATION_SET_GET_CLASS:=PAtkRelationSetClass(G_TYPE_INSTANCE_GET_CLASS(obj,ATK_TYPE_RELATION_SET)); +end; + +{$ENDIF read_implementation} + diff --git a/packages/gtk2/src/atk/atkselection.inc b/packages/gtk2/src/atk/atkselection.inc new file mode 100644 index 0000000000..ffb5e81110 --- /dev/null +++ b/packages/gtk2/src/atk/atkselection.inc @@ -0,0 +1,77 @@ +// included by atk.pp + +{ + This AtkSelection interface provides the standard mechanism for an + assistive technology to determine what the current selected children are, + as well as modify the selection set. Any anObject that has children that + can be selected should support the AtkSelection interface. + } + +{$IFDEF read_forward_definitions} +{$ENDIF read_forward_definitions} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_types} +{ signal handlers } + PAtkSelectionIface = ^TAtkSelectionIface; + TAtkSelectionIface = record + parent : TGTypeInterface; + add_selection : function (selection:PAtkSelection; i:gint):gboolean; cdecl; + clear_selection : function (selection:PAtkSelection):gboolean; cdecl; + ref_selection : function (selection:PAtkSelection; i:gint):PAtkObject; cdecl; + get_selection_count : function (selection:PAtkSelection):gint; cdecl; + is_child_selected : function (selection:PAtkSelection; i:gint):gboolean; cdecl; + remove_selection : function (selection:PAtkSelection; i:gint):gboolean; cdecl; + select_all_selection : function (selection:PAtkSelection):gboolean; cdecl; + selection_changed : procedure (selection:PAtkSelection); cdecl; + pad1 : TAtkFunction; + pad2 : TAtkFunction; + end; + +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} +function ATK_TYPE_SELECTION : GType; +function ATK_IS_SELECTION(obj: pointer) : boolean; +function ATK_SELECTION(obj: pointer) : PAtkSelection; +function ATK_SELECTION_GET_IFACE(obj: pointer) : PAtkSelectionIface; + + +function atk_selection_get_type:GType; cdecl; external atklib; +function atk_selection_add_selection(selection:PAtkSelection; i:gint):gboolean; cdecl; external atklib; +function atk_selection_clear_selection(selection:PAtkSelection):gboolean; cdecl; external atklib; +function atk_selection_ref_selection(selection:PAtkSelection; i:gint):PAtkObject; cdecl; external atklib; +function atk_selection_get_selection_count(selection:PAtkSelection):gint; cdecl; external atklib; +function atk_selection_is_child_selected(selection:PAtkSelection; i:gint):gboolean; cdecl; external atklib; +function atk_selection_remove_selection(selection:PAtkSelection; i:gint):gboolean; cdecl; external atklib; +function atk_selection_select_all_selection(selection:PAtkSelection):gboolean; cdecl; external atklib; +{$ENDIF read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function ATK_TYPE_SELECTION : GType; +begin + ATK_TYPE_SELECTION:=atk_selection_get_type; +end; + +function ATK_IS_SELECTION(obj: pointer) : boolean; +begin + ATK_IS_SELECTION:=G_TYPE_CHECK_INSTANCE_TYPE(obj,ATK_TYPE_SELECTION); +end; + +function ATK_SELECTION(obj: pointer) : PAtkSelection; +begin + ATK_SELECTION:=PAtkSelection(G_TYPE_CHECK_INSTANCE_CAST(obj,ATK_TYPE_SELECTION)); +end; + +function ATK_SELECTION_GET_IFACE(obj: pointer) : PAtkSelectionIface; +begin + ATK_SELECTION_GET_IFACE:=PAtkSelectionIface(G_TYPE_INSTANCE_GET_INTERFACE(obj,ATK_TYPE_SELECTION)); +end; + +{$ENDIF read_implementation} + diff --git a/packages/gtk2/src/atk/atkstate.inc b/packages/gtk2/src/atk/atkstate.inc new file mode 100644 index 0000000000..82e567c79c --- /dev/null +++ b/packages/gtk2/src/atk/atkstate.inc @@ -0,0 +1,96 @@ +// included by atk.pp + +{$IFDEF read_forward_definitions} +{$ENDIF read_forward_definitions} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_types} +{ + AtkStateType: + @ATK_STATE_INVALID: Indicates an invalid state + @ATK_STATE_ACTIVE: Indicates a window is currently the active window + @ATK_STATE_ARMED: Indicates that the anObject is armed + @ATK_STATE_BUSY: Indicates the current anObject is busy + @ATK_STATE_CHECKED: Indicates this anObject is currently checked + @ATK_STATE_DEFUNCT: Indicates the user interface anObject corresponding to this anObject no longer exists + @ATK_STATE_EDITABLE: Indicates the user can change the contents of this anObject + @ATK_STATE_ENABLED: Indicates that this anObject is enabled + @ATK_STATE_EXPANDABLE: Indicates this anObject allows progressive disclosure of its children + @ATK_STATE_EXPANDED: Indicates this anObject its expanded + @ATK_STATE_FOCUSABLE: Indicates this anObject can accept keyboard focus, which means all events resulting from typing on the keyboard will normally be passed to it when it has focus + @ATK_STATE_FOCUSED: Indicates this anObject currently has the keyboard focus + @ATK_STATE_HORIZONTAL: Indicates the orientation of this anObject is horizontal + @ATK_STATE_ICONIFIED: Indicates this anObject is minimized and is represented only by an icon + @ATK_STATE_MODAL: Indicates something must be done with this anObject before the user can interact with an anObject in a different window + @ATK_STATE_MULTI_LINE: Indicates this (text) anObject can contain multiple lines of text + @ATK_STATE_MULTISELECTABLE: Indicates this anObject allows more than one of its children to be selected at the same time + @ATK_STATE_OPAQUE: Indicates this anObject paints every pixel within its rectangular region + @ATK_STATE_PRESSED: Indicates this anObject is currently pressed + @ATK_STATE_RESIZABLE: Indicates the size of this anObject is not fixed + @ATK_STATE_SELECTABLE: Indicates this anObject is the child of an anObject that allows its children to be selected and that this child is one of those children that can be selected + @ATK_STATE_SELECTED: Indicates this anObject is the child of an anObject that allows its children to be selected and that this child is one of those children that has been selected + @ATK_STATE_SENSITIVE: Indicates this anObject is sensitive + @ATK_STATE_SHOWING: Indicates this anObject, the anObject's parent, the anObject's parent's parent, and so on, are all visible + @ATK_STATE_SINGLE_LINE: Indicates this (text) anObject can contain only a single line of text + @ATK_STATE_STALE: Indicates that the index associated with this anObject has changed since the user accessed the anObject. + @ATK_STATE_TRANSIENT: Indicates this anObject is transient + @ATK_STATE_VERTICAL: Indicates the orientation of this anObject is vertical + @ATK_STATE_VISIBLE: Indicates this anObject is visible + @ATK_STATE_LAST_DEFINED: Not a valid role, used for finding theEnd of enumeration + + The possible types of states of an anObject + } + PAtkStateType = ^TAtkStateType; + TAtkStateType = ( + ATK_STATE_INVALID, + ATK_STATE_ACTIVE, + ATK_STATE_ARMED, + ATK_STATE_BUSY, + ATK_STATE_CHECKED, + ATK_STATE_DEFUNCT, + ATK_STATE_EDITABLE, + ATK_STATE_ENABLED, + ATK_STATE_EXPANDABLE, + ATK_STATE_EXPANDED, + ATK_STATE_FOCUSABLE, + ATK_STATE_FOCUSED, + ATK_STATE_HORIZONTAL, + ATK_STATE_ICONIFIED, + ATK_STATE_MODAL, + ATK_STATE_MULTI_LINE, + ATK_STATE_MULTISELECTABLE, + ATK_STATE_OPAQUE, + ATK_STATE_PRESSED, + ATK_STATE_RESIZABLE, + ATK_STATE_SELECTABLE, + ATK_STATE_SELECTED, + ATK_STATE_SENSITIVE, + ATK_STATE_SHOWING, + ATK_STATE_SINGLE_LINE, + ATK_STATE_STALE, + ATK_STATE_TRANSIENT, + ATK_STATE_VERTICAL, + ATK_STATE_VISIBLE, + ATK_STATE_LAST_DEFINED + ); + + PAtkState = ^TAtkState; + TAtkState = guint64; + +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} + +function atk_state_type_register(name:Pgchar):TAtkStateType; cdecl; external atklib; +function atk_state_type_get_name(_type:TAtkStateType):Pgchar; cdecl; external atklib; +function atk_state_type_for_name(name:Pgchar):TAtkStateType; cdecl; external atklib; +{$ENDIF read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +{$ENDIF read_implementation} + diff --git a/packages/gtk2/src/atk/atkstateset.inc b/packages/gtk2/src/atk/atkstateset.inc new file mode 100644 index 0000000000..7b0adfde03 --- /dev/null +++ b/packages/gtk2/src/atk/atkstateset.inc @@ -0,0 +1,80 @@ +// included by atk.pp + +{$IFDEF read_forward_definitions} + PAtkStateSet = ^TAtkStateSet; +{$ENDIF read_forward_definitions} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_types} + TAtkStateSet = record + parent : TGObject; + end; + + PAtkStateSetClass = ^TAtkStateSetClass; + TAtkStateSetClass = record + parent : TGObjectClass; + end; + +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} +function ATK_TYPE_STATE_SET : GType; +function ATK_STATE_SET(obj: pointer) : PAtkStateSet; +function ATK_STATE_SET_CLASS(klass: pointer) : PAtkStateSetClass; +function ATK_IS_STATE_SET(obj: pointer) : boolean; +function ATK_IS_STATE_SET_CLASS(klass: pointer) : boolean; +function ATK_STATE_SET_GET_CLASS(obj: pointer) : PAtkStateSetClass; + + +function atk_state_set_get_type:GType; cdecl; external atklib; +function atk_state_set_new:PAtkStateSet; cdecl; external atklib; +function atk_state_set_is_empty(StateSet:PAtkStateSet):gboolean; cdecl; external atklib; +function atk_state_set_add_state(StateSet:PAtkStateSet; _type:TAtkStateType):gboolean; cdecl; external atklib; +procedure atk_state_set_add_states(StateSet:PAtkStateSet; types:PAtkStateType; n_types:gint); cdecl; external atklib; +procedure atk_state_set_clear_states(StateSet:PAtkStateSet); cdecl; external atklib; +function atk_state_set_contains_state(StateSet:PAtkStateSet; _type:TAtkStateType):gboolean; cdecl; external atklib; +function atk_state_set_contains_states(StateSet:PAtkStateSet; types:PAtkStateType; n_types:gint):gboolean; cdecl; external atklib; +function atk_state_set_remove_state(StateSet:PAtkStateSet; _type:TAtkStateType):gboolean; cdecl; external atklib; +function atk_state_set_and_sets(StateSet:PAtkStateSet; compare_set:PAtkStateSet):PAtkStateSet; cdecl; external atklib; +function atk_state_set_or_sets(StateSet:PAtkStateSet; compare_set:PAtkStateSet):PAtkStateSet; cdecl; external atklib; +function atk_state_set_xor_sets(StateSet:PAtkStateSet; compare_set:PAtkStateSet):PAtkStateSet; cdecl; external atklib; +{$ENDIF read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function ATK_TYPE_STATE_SET : GType; +begin + ATK_TYPE_STATE_SET:=atk_state_set_get_type; +end; + +function ATK_STATE_SET(obj: pointer) : PAtkStateSet; +begin + ATK_STATE_SET:=PAtkStateSet(G_TYPE_CHECK_INSTANCE_CAST(obj,ATK_TYPE_STATE_SET)); +end; + +function ATK_STATE_SET_CLASS(klass: pointer) : PAtkStateSetClass; +begin + ATK_STATE_SET_CLASS:=PAtkStateSetClass(G_TYPE_CHECK_CLASS_CAST(klass,ATK_TYPE_STATE_SET)); +end; + +function ATK_IS_STATE_SET(obj: pointer) : boolean; +begin + ATK_IS_STATE_SET:=G_TYPE_CHECK_INSTANCE_TYPE(obj,ATK_TYPE_STATE_SET); +end; + +function ATK_IS_STATE_SET_CLASS(klass: pointer) : boolean; +begin + ATK_IS_STATE_SET_CLASS:=G_TYPE_CHECK_CLASS_TYPE(klass,ATK_TYPE_STATE_SET); +end; + +function ATK_STATE_SET_GET_CLASS(obj: pointer) : PAtkStateSetClass; +begin + ATK_STATE_SET_GET_CLASS:=PAtkStateSetClass(G_TYPE_INSTANCE_GET_CLASS(obj,ATK_TYPE_STATE_SET)); +end; + +{$ENDIF read_implementation} + diff --git a/packages/gtk2/src/atk/atkstreamablecontent.inc b/packages/gtk2/src/atk/atkstreamablecontent.inc new file mode 100644 index 0000000000..c6c899dabf --- /dev/null +++ b/packages/gtk2/src/atk/atkstreamablecontent.inc @@ -0,0 +1,78 @@ +// included by atk.pp + +{$IFDEF read_forward_definitions} +{$ENDIF read_forward_definitions} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_types} +{ Get the number of mime types supported by this anObject } +{ Gets the specified mime type supported by this anObject. + The mime types are 0-based so the first mime type is + at index 0, the second at index 1 and so on. + + This assumes that the strings for the mime types are stored in the + AtkStreamableContent. Alternatively the could be removed + and the caller would be responsible for calling g_free() on the + returned value. + } +{ + Is one possible implementation for this method that it constructs the + content appropriate for the mime type and then creates a temporary + file containing the content, opens the file and then calls + g_io_channel_unix_new_fd(). + } + PAtkStreamableContentIface = ^TAtkStreamableContentIface; + TAtkStreamableContentIface = record + parent : TGTypeInterface; + get_n_mime_types : function (streamable:PAtkStreamableContent):gint; cdecl; + get_mime_type : function (streamable:PAtkStreamableContent; i:gint):Pgchar; cdecl; + get_stream : function (streamable:PAtkStreamableContent; mime_type:Pgchar):PGIOChannel; cdecl; + pad1 : TAtkFunction; + pad2 : TAtkFunction; + pad3 : TAtkFunction; + pad4 : TAtkFunction; + end; + +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} +function ATK_TYPE_STREAMABLE_CONTENT : GType; +function ATK_IS_STREAMABLE_CONTENT(obj: pointer) : boolean; +function ATK_STREAMABLE_CONTENT(obj: pointer) : PAtkStreamableContent; +function ATK_STREAMABLE_CONTENT_GET_IFACE(obj: pointer) : PAtkStreamableContentIface; + + +function atk_streamable_content_get_type:GType; cdecl; external atklib; +function atk_streamable_content_get_n_mime_types(streamable:PAtkStreamableContent):gint; cdecl; external atklib; +function atk_streamable_content_get_mime_type(streamable:PAtkStreamableContent; i:gint):Pgchar; cdecl; external atklib; +function atk_streamable_content_get_stream(streamable:PAtkStreamableContent; mime_type:Pgchar):PGIOChannel; cdecl; external atklib; +{$ENDIF read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function ATK_TYPE_STREAMABLE_CONTENT : GType; +begin + ATK_TYPE_STREAMABLE_CONTENT:=atk_streamable_content_get_type; +end; + +function ATK_IS_STREAMABLE_CONTENT(obj: pointer) : boolean; +begin + ATK_IS_STREAMABLE_CONTENT:=G_TYPE_CHECK_INSTANCE_TYPE(obj,ATK_TYPE_STREAMABLE_CONTENT); +end; + +function ATK_STREAMABLE_CONTENT(obj: pointer) : PAtkStreamableContent; +begin + ATK_STREAMABLE_CONTENT:=PAtkStreamableContent(G_TYPE_CHECK_INSTANCE_CAST(obj,ATK_TYPE_STREAMABLE_CONTENT)); +end; + +function ATK_STREAMABLE_CONTENT_GET_IFACE(obj: pointer) : PAtkStreamableContentIface; +begin + ATK_STREAMABLE_CONTENT_GET_IFACE:=PAtkStreamableContentIface(G_TYPE_INSTANCE_GET_INTERFACE(obj,ATK_TYPE_STREAMABLE_CONTENT)); +end; + +{$ENDIF read_implementation} + diff --git a/packages/gtk2/src/atk/atktable.inc b/packages/gtk2/src/atk/atktable.inc new file mode 100644 index 0000000000..fa8cf962c4 --- /dev/null +++ b/packages/gtk2/src/atk/atktable.inc @@ -0,0 +1,129 @@ +// included by atk.pp + +{ + AtkTable describes a user-interface component that presents data in + two-dimensional table format. + } + +{$IFDEF read_forward_definitions} +{$ENDIF read_forward_definitions} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_types} +{ + signal handlers + } + PAtkTableIface = ^TAtkTableIface; + TAtkTableIface = record + parent : TGTypeInterface; + ref_at : function (table:PAtkTable; row:gint; column:gint):PAtkObject; cdecl; + get_index_at : function (table:PAtkTable; row:gint; column:gint):gint; cdecl; + get_column_at_index : function (table:PAtkTable; index:gint):gint; cdecl; + get_row_at_index : function (table:PAtkTable; index:gint):gint; cdecl; + get_n_columns : function (table:PAtkTable):gint; cdecl; + get_n_rows : function (table:PAtkTable):gint; cdecl; + get_column_extent_at : function (table:PAtkTable; row:gint; column:gint):gint; cdecl; + get_row_extent_at : function (table:PAtkTable; row:gint; column:gint):gint; cdecl; + get_caption : function (table:PAtkTable):PAtkObject; cdecl; + get_column_description : function (table:PAtkTable; column:gint):Pgchar; cdecl; + get_column_header : function (table:PAtkTable; column:gint):PAtkObject; cdecl; + get_row_description : function (table:PAtkTable; row:gint):Pgchar; cdecl; + get_row_header : function (table:PAtkTable; row:gint):PAtkObject; cdecl; + get_summary : function (table:PAtkTable):PAtkObject; cdecl; + set_caption : procedure (table:PAtkTable; caption:PAtkObject); cdecl; + set_column_description : procedure (table:PAtkTable; column:gint; description:Pgchar); cdecl; + set_column_header : procedure (table:PAtkTable; column:gint; header:PAtkObject); cdecl; + set_row_description : procedure (table:PAtkTable; row:gint; description:Pgchar); cdecl; + set_row_header : procedure (table:PAtkTable; row:gint; header:PAtkObject); cdecl; + set_summary : procedure (table:PAtkTable; accessible:PAtkObject); cdecl; + get_selected_columns : function (table:PAtkTable; selected:PPgint):gint; cdecl; + get_selected_rows : function (table:PAtkTable; selected:PPgint):gint; cdecl; + is_column_selected : function (table:PAtkTable; column:gint):gboolean; cdecl; + is_row_selected : function (table:PAtkTable; row:gint):gboolean; cdecl; + is_selected : function (table:PAtkTable; row:gint; column:gint):gboolean; cdecl; + add_row_selection : function (table:PAtkTable; row:gint):gboolean; cdecl; + remove_row_selection : function (table:PAtkTable; row:gint):gboolean; cdecl; + add_column_selection : function (table:PAtkTable; column:gint):gboolean; cdecl; + remove_column_selection : function (table:PAtkTable; column:gint):gboolean; cdecl; + row_inserted : procedure (table:PAtkTable; row:gint; num_inserted:gint); cdecl; + column_inserted : procedure (table:PAtkTable; column:gint; num_inserted:gint); cdecl; + row_deleted : procedure (table:PAtkTable; row:gint; num_deleted:gint); cdecl; + column_deleted : procedure (table:PAtkTable; column:gint; num_deleted:gint); cdecl; + row_reordered : procedure (table:PAtkTable); cdecl; + column_reordered : procedure (table:PAtkTable); cdecl; + model_changed : procedure (table:PAtkTable); cdecl; + pad1 : TAtkFunction; + pad2 : TAtkFunction; + pad3 : TAtkFunction; + pad4 : TAtkFunction; + end; + +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} +function ATK_TYPE_TABLE : GType; +function ATK_IS_TABLE(obj: pointer) : boolean; +function ATK_TABLE(obj: pointer) : PAtkTable; +function ATK_TABLE_GET_IFACE(obj: pointer) : PAtkTableIface; + + +function atk_table_get_type:GType; cdecl; external atklib; +function atk_table_ref_at(table:PAtkTable; row:gint; column:gint):PAtkObject; cdecl; external atklib; +function atk_table_get_index_at(table:PAtkTable; row:gint; column:gint):gint; cdecl; external atklib; +function atk_table_get_column_at_index(table:PAtkTable; index:gint):gint; cdecl; external atklib; +function atk_table_get_row_at_index(table:PAtkTable; index:gint):gint; cdecl; external atklib; +function atk_table_get_n_columns(table:PAtkTable):gint; cdecl; external atklib; +function atk_table_get_n_rows(table:PAtkTable):gint; cdecl; external atklib; +function atk_table_get_column_extent_at(table:PAtkTable; row:gint; column:gint):gint; cdecl; external atklib; +function atk_table_get_row_extent_at(table:PAtkTable; row:gint; column:gint):gint; cdecl; external atklib; +function atk_table_get_caption(table:PAtkTable):PAtkObject; cdecl; external atklib; +function atk_table_get_column_description(table:PAtkTable; column:gint):Pgchar; cdecl; external atklib; +function atk_table_get_column_header(table:PAtkTable; column:gint):PAtkObject; cdecl; external atklib; +function atk_table_get_row_description(table:PAtkTable; row:gint):Pgchar; cdecl; external atklib; +function atk_table_get_row_header(table:PAtkTable; row:gint):PAtkObject; cdecl; external atklib; +function atk_table_get_summary(table:PAtkTable):PAtkObject; cdecl; external atklib; +procedure atk_table_set_caption(table:PAtkTable; caption:PAtkObject); cdecl; external atklib; +procedure atk_table_set_column_description(table:PAtkTable; column:gint; description:Pgchar); cdecl; external atklib; +procedure atk_table_set_column_header(table:PAtkTable; column:gint; header:PAtkObject); cdecl; external atklib; +procedure atk_table_set_row_description(table:PAtkTable; row:gint; description:Pgchar); cdecl; external atklib; +procedure atk_table_set_row_header(table:PAtkTable; row:gint; header:PAtkObject); cdecl; external atklib; +procedure atk_table_set_summary(table:PAtkTable; accessible:PAtkObject); cdecl; external atklib; +function atk_table_get_selected_columns(table:PAtkTable; selected:PPgint):gint; cdecl; external atklib; +function atk_table_get_selected_rows(table:PAtkTable; selected:PPgint):gint; cdecl; external atklib; +function atk_table_is_column_selected(table:PAtkTable; column:gint):gboolean; cdecl; external atklib; +function atk_table_is_row_selected(table:PAtkTable; row:gint):gboolean; cdecl; external atklib; +function atk_table_is_selected(table:PAtkTable; row:gint; column:gint):gboolean; cdecl; external atklib; +function atk_table_add_row_selection(table:PAtkTable; row:gint):gboolean; cdecl; external atklib; +function atk_table_remove_row_selection(table:PAtkTable; row:gint):gboolean; cdecl; external atklib; +function atk_table_add_column_selection(table:PAtkTable; column:gint):gboolean; cdecl; external atklib; +function atk_table_remove_column_selection(table:PAtkTable; column:gint):gboolean; cdecl; external atklib; +{$ENDIF read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function ATK_TYPE_TABLE : GType; +begin + ATK_TYPE_TABLE:=atk_table_get_type; +end; + +function ATK_IS_TABLE(obj: pointer) : boolean; +begin + ATK_IS_TABLE:=G_TYPE_CHECK_INSTANCE_TYPE(obj,ATK_TYPE_TABLE); +end; + +function ATK_TABLE(obj: pointer) : PAtkTable; +begin + ATK_TABLE:=PAtkTable(G_TYPE_CHECK_INSTANCE_CAST(obj,ATK_TYPE_TABLE)); +end; + +function ATK_TABLE_GET_IFACE(obj: pointer) : PAtkTableIface; +begin + ATK_TABLE_GET_IFACE:=PAtkTableIface(G_TYPE_INSTANCE_GET_INTERFACE(obj,ATK_TYPE_TABLE)); +end; + +{$ENDIF read_implementation} + diff --git a/packages/gtk2/src/atk/atktext.inc b/packages/gtk2/src/atk/atktext.inc new file mode 100644 index 0000000000..d53c62a6c4 --- /dev/null +++ b/packages/gtk2/src/atk/atktext.inc @@ -0,0 +1,230 @@ +// included by atk.pp + +{ + AtkAttributeSet: + + This is a singly-linked list (a #GSList) of #AtkAttribute. It is + used by atk_text_get_run_attributes(), atk_text_get_default_attributes() + and atk_editable_text_set_run_attributes() + } + +{$IFDEF read_forward_definitions} + PAtkAttributeSet = ^TAtkAttributeSet; +{$ENDIF read_forward_definitions} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_types} + TAtkAttributeSet = TGSList; + +{ + AtkAttribute: + @name: The attribute name. Call atk_text_attr_get_name() + @value: the value of the attribute, represented as a string. + Call atk_text_attr_get_value() for those which are strings. + For values which are numbers, the string representation of the number + is in value. + + A string name/value pair representing a text attribute. + } + PAtkAttribute = ^TAtkAttribute; + TAtkAttribute = record + name : Pgchar; + value : Pgchar; + end; + +{ + AtkTextAttribute + @ATK_TEXT_ATTR_INVALID: Invalid attribute + @ATK_TEXT_ATTR_LEFT_MARGIN: The pixel width of the left margin + @ATK_TEXT_ATTR_RIGHT_MARGIN: The pixel width of the right margin + @ATK_TEXT_ATTR_INDENT: The number of pixels that the text is indented + @ATK_TEXT_ATTR_INVISIBLE: Either "true" or "false" indicating whether text is visible or not + @ATK_TEXT_ATTR_EDITABLE: Either "true" or "false" indicating whether text is editable or not + @ATK_TEXT_ATTR_PIXELS_ABOVE_LINES: Pixels of blank space to leave above each newline-terminated line. + @ATK_TEXT_ATTR_PIXELS_BELOW_LINES: Pixels of blank space to leave below each newline-terminated line. + @ATK_TEXT_ATTR_PIXELS_INSIDE_WRAP: Pixels of blank space to leave between wrapped lines inside the same newline-terminated line (paragraph). + @ATK_TEXT_ATTR_BG_FULL_HEIGHT: "true" or "false" whether to make the background color for each character the height of the highest font used on the current line, or the height of the font used for the current character. + @ATK_TEXT_ATTR_RISE: Number of pixels that the characters are risen above the baseline + @ATK_TEXT_ATTR_UNDERLINE: "none", "single", "double" or "low" + @ATK_TEXT_ATTR_STRIKETHROUGH: "true" or "false" whether the text is strikethrough + @ATK_TEXT_ATTR_SIZE: The size of the characters. + @ATK_TEXT_ATTR_SCALE: The scale of the characters. The value is a string representation of a double + @ATK_TEXT_ATTR_WEIGHT: The weight of the characters. + @ATK_TEXT_ATTR_LANGUAGE: The language used + @ATK_TEXT_ATTR_FAMILY_NAME: The font family name + @ATK_TEXT_ATTR_BG_COLOR: The background color. The value is an RGB value of the format "%u,%u,%u" + @ATK_TEXT_ATTR_FG_COLOR:The foreground color. The value is an RGB value of the format "%u,%u,%u" + @ATK_TEXT_ATTR_BG_STIPPLE: "true" if a #GdkBitmap is set for stippling the background color. + @ATK_TEXT_ATTR_FG_STIPPLE: "true" if a #GdkBitmap is set for stippling the foreground color. + @ATK_TEXT_ATTR_WRAP_MODE: The wrap mode of the text, if any. Values are "none", "char" or "word" + @ATK_TEXT_ATTR_DIRECTION: The direction of the text, if set. Values are "none", "ltr" or "rtl" + @ATK_TEXT_ATTR_JUSTIFICATION: The justification of the text, if set. Values are "left", "right", "center" or "fill" + @ATK_TEXT_ATTR_STRETCH: The stretch of the text, if set. Values are "ultra_condensed", "extra_condensed", "condensed", "semi_condensed", "normal", "semi_expanded", "expanded", "extra_expanded" or "ultra_expanded" + @ATK_TEXT_ATTR_VARIANT: The capitalization variant of the text, if set. Values are "normal" or "small_caps" + @ATK_TEXT_ATTR_STYLE: The slant style of the text, if set. Values are "normal", "oblique" or "italic" + @ATK_TEXT_ATTR_LAST_DEFINED: not a valid text attribute, used for finding theEnd of enumeration + + Describes the text attributes supported + } + + PAtkTextAttribute = ^TAtkTextAttribute; + TAtkTextAttribute = ( + ATK_TEXT_ATTR_INVALID {:= 0}, + ATK_TEXT_ATTR_LEFT_MARGIN, + ATK_TEXT_ATTR_RIGHT_MARGIN, + ATK_TEXT_ATTR_INDENT, + ATK_TEXT_ATTR_INVISIBLE, + ATK_TEXT_ATTR_EDITABLE, + ATK_TEXT_ATTR_PIXELS_ABOVE_LINES, + ATK_TEXT_ATTR_PIXELS_BELOW_LINES, + ATK_TEXT_ATTR_PIXELS_INSIDE_WRAP, + ATK_TEXT_ATTR_BG_FULL_HEIGHT, + ATK_TEXT_ATTR_RISE, + ATK_TEXT_ATTR_UNDERLINE, + ATK_TEXT_ATTR_STRIKETHROUGH, + ATK_TEXT_ATTR_SIZE, + ATK_TEXT_ATTR_SCALE, + ATK_TEXT_ATTR_WEIGHT, + ATK_TEXT_ATTR_LANGUAGE, + ATK_TEXT_ATTR_FAMILY_NAME, + ATK_TEXT_ATTR_BG_COLOR, + ATK_TEXT_ATTR_FG_COLOR, + ATK_TEXT_ATTR_BG_STIPPLE, + ATK_TEXT_ATTR_FG_STIPPLE, + ATK_TEXT_ATTR_WRAP_MODE, + ATK_TEXT_ATTR_DIRECTION, + ATK_TEXT_ATTR_JUSTIFICATION, + ATK_TEXT_ATTR_STRETCH, + ATK_TEXT_ATTR_VARIANT, + ATK_TEXT_ATTR_STYLE, + ATK_TEXT_ATTR_LAST_DEFINED + ); + + +{ + AtkTextBoundary: + @ATK_TEXT_BOUNDARY_CHAR: + @ATK_TEXT_BOUNDARY_WORD_START: + @ATK_TEXT_BOUNDARY_WORD_END: + @ATK_TEXT_BOUNDARY_SENTENCE_START: + @ATK_TEXT_BOUNDARY_SENTENCE_END: + @ATK_TEXT_BOUNDARY_LINE_START: + @ATK_TEXT_BOUNDARY_LINE_END: + + Text boundary types used for specifying boundaries for regions of text + } + + PAtkTextBoundary = ^TAtkTextBoundary; + TAtkTextBoundary = ( + ATK_TEXT_BOUNDARY_CHAR, + ATK_TEXT_BOUNDARY_WORD_START, + ATK_TEXT_BOUNDARY_WORD_END, + ATK_TEXT_BOUNDARY_SENTENCE_START, + ATK_TEXT_BOUNDARY_SENTENCE_END, + ATK_TEXT_BOUNDARY_LINE_START, + ATK_TEXT_BOUNDARY_LINE_END + ); +{ + signal handlers + } + PAtkTextIface = ^TAtkTextIface; + TAtkTextIface = record + parent : TGTypeInterface; + get_text : function (text:PAtkText; start_offset:gint; end_offset:gint):Pgchar; cdecl; + get_text_after_offset : function (text:PAtkText; offset:gint; boundary_type:TAtkTextBoundary; start_offset:Pgint; end_offset:Pgint):Pgchar; cdecl; + get_text_at_offset : function (text:PAtkText; offset:gint; boundary_type:TAtkTextBoundary; start_offset:Pgint; end_offset:Pgint):Pgchar; cdecl; + get_character_at_offset : function (text:PAtkText; offset:gint):gunichar; cdecl; + get_text_before_offset : function (text:PAtkText; offset:gint; boundary_type:TAtkTextBoundary; start_offset:Pgint; end_offset:Pgint):Pgchar; cdecl; + get_caret_offset : function (text:PAtkText):gint; cdecl; + get_run_attributes : function (text:PAtkText; offset:gint; start_offset:Pgint; end_offset:Pgint):PAtkAttributeSet; cdecl; + get_default_attributes : function (text:PAtkText):PAtkAttributeSet; cdecl; + get_character_extents : procedure (text:PAtkText; offset:gint; x:Pgint; y:Pgint; width:Pgint; + height:Pgint; coords:TAtkCoordType); cdecl; + get_character_count : function (text:PAtkText):gint; cdecl; + get_offset_at_point : function (text:PAtkText; x:gint; y:gint; coords:TAtkCoordType):gint; cdecl; + get_n_selections : function (text:PAtkText):gint; cdecl; + get_selection : function (text:PAtkText; selection_num:gint; start_offset:Pgint; end_offset:Pgint):Pgchar; cdecl; + add_selection : function (text:PAtkText; start_offset:gint; end_offset:gint):gboolean; cdecl; + remove_selection : function (text:PAtkText; selection_num:gint):gboolean; cdecl; + set_selection : function (text:PAtkText; selection_num:gint; start_offset:gint; end_offset:gint):gboolean; cdecl; + set_caret_offset : function (text:PAtkText; offset:gint):gboolean; cdecl; + text_changed : procedure (text:PAtkText; position:gint; length:gint); cdecl; + text_caret_moved : procedure (text:PAtkText; location:gint); cdecl; + text_selection_changed : procedure (text:PAtkText); cdecl; + pad1 : TAtkFunction; + pad2 : TAtkFunction; + pad3 : TAtkFunction; + pad4 : TAtkFunction; + end; + +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} + +function atk_text_attribute_register(name:Pgchar):TAtkTextAttribute; cdecl; external atklib; + +function ATK_TYPE_TEXT : GType; +function ATK_IS_TEXT(obj: pointer) : boolean; +function ATK_TEXT(obj: pointer) : PAtkText; +function ATK_TEXT_GET_IFACE(obj: pointer) : PAtkTextIface; + + +{ + Additional AtkObject properties used by AtkText: + "accessible_text" (accessible text has changed) + "accessible_caret" (accessible text cursor position changed: + editable text only) + } +function atk_text_get_type:GType; cdecl; external atklib; +function atk_text_get_text(text:PAtkText; start_offset:gint; end_offset:gint):Pgchar; cdecl; external atklib; +function atk_text_get_character_at_offset(text:PAtkText; offset:gint):gunichar; cdecl; external atklib; +function atk_text_get_text_after_offset(text:PAtkText; offset:gint; boundary_type:TAtkTextBoundary; start_offset:Pgint; end_offset:Pgint):Pgchar; cdecl; external atklib; +function atk_text_get_text_at_offset(text:PAtkText; offset:gint; boundary_type:TAtkTextBoundary; start_offset:Pgint; end_offset:Pgint):Pgchar; cdecl; external atklib; +function atk_text_get_text_before_offset(text:PAtkText; offset:gint; boundary_type:TAtkTextBoundary; start_offset:Pgint; end_offset:Pgint):Pgchar; cdecl; external atklib; +function atk_text_get_caret_offset(text:PAtkText):gint; cdecl; external atklib; +procedure atk_text_get_character_extents(text:PAtkText; offset:gint; x:Pgint; y:Pgint; width:Pgint; + height:Pgint; coords:TAtkCoordType); cdecl; external atklib; +function atk_text_get_run_attributes(text:PAtkText; offset:gint; start_offset:Pgint; end_offset:Pgint):PAtkAttributeSet; cdecl; external atklib; +function atk_text_get_default_attributes(text:PAtkText):PAtkAttributeSet; cdecl; external atklib; +function atk_text_get_character_count(text:PAtkText):gint; cdecl; external atklib; +function atk_text_get_offset_at_point(text:PAtkText; x:gint; y:gint; coords:TAtkCoordType):gint; cdecl; external atklib; +function atk_text_get_n_selections(text:PAtkText):gint; cdecl; external atklib; +function atk_text_get_selection(text:PAtkText; selection_num:gint; start_offset:Pgint; end_offset:Pgint):Pgchar; cdecl; external atklib; +function atk_text_add_selection(text:PAtkText; start_offset:gint; end_offset:gint):gboolean; cdecl; external atklib; +function atk_text_remove_selection(text:PAtkText; selection_num:gint):gboolean; cdecl; external atklib; +function atk_text_set_selection(text:PAtkText; selection_num:gint; start_offset:gint; end_offset:gint):gboolean; cdecl; external atklib; +function atk_text_set_caret_offset(text:PAtkText; offset:gint):gboolean; cdecl; external atklib; +procedure atk_attribute_set_free(attrib_set:PAtkAttributeSet); cdecl; external atklib; +function atk_text_attribute_get_name(attr:TAtkTextAttribute):Pgchar; cdecl; external atklib; +function atk_text_attribute_for_name(name:Pgchar):TAtkTextAttribute; cdecl; external atklib; +function atk_text_attribute_get_value(attr:TAtkTextAttribute; index:gint):Pgchar; cdecl; external atklib; +{$ENDIF read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function ATK_TYPE_TEXT : GType; +begin + ATK_TYPE_TEXT:=atk_text_get_type; +end; + +function ATK_IS_TEXT(obj: pointer) : boolean; +begin + ATK_IS_TEXT:=G_TYPE_CHECK_INSTANCE_TYPE(obj,ATK_TYPE_TEXT); +end; + +function ATK_TEXT(obj: pointer) : PAtkText; +begin + ATK_TEXT:=PAtkText(G_TYPE_CHECK_INSTANCE_CAST(obj,ATK_TYPE_TEXT)); +end; + +function ATK_TEXT_GET_IFACE(obj: pointer) : PAtkTextIface; +begin + ATK_TEXT_GET_IFACE:=PAtkTextIface(G_TYPE_INSTANCE_GET_INTERFACE(obj,ATK_TYPE_TEXT)); +end; + +{$ENDIF read_implementation} + diff --git a/packages/gtk2/src/atk/atkutil.inc b/packages/gtk2/src/atk/atkutil.inc new file mode 100644 index 0000000000..23524dd5da --- /dev/null +++ b/packages/gtk2/src/atk/atkutil.inc @@ -0,0 +1,175 @@ +// included by atk.pp + +{$IFDEF read_forward_definitions} +{ + AtkCoordType: + @ATK_XY_SCREEN: specifies xy coordinates relative to the screen + @ATK_XY_WINDOW: specifies xy coordinates relative to the widgets + top-level window + + Specifies how xy coordinates are to be interpreted. Used by functions such + as atk_component_get_position() and atk_text_get_character_extents() + } + PAtkCoordType = ^TAtkCoordType; + TAtkCoordType = ( + ATK_XY_SCREEN, + ATK_XY_WINDOW + ); +{$ENDIF read_forward_definitions} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_types} +{ + A focus tracker is a function which is called when an anObject + receives focus. + } + TAtkEventListener = procedure (para1:PAtkObject); cdecl; + + TAtkEventListenerInitProc = procedure; + TAtkEventListenerInit = procedure (para1: TAtkEventListenerInitProc); cdecl; + + PAtkKeyEventStruct = ^TAtkKeyEventStruct; + TAtkKeyEventStruct = record + _type : gint; + state : guint; + keyval : guint; + length : gint; + _string : Pgchar; + keycode : guint16; + timestamp : guint32; + end; + TAtkKeySnoopFunc = function (event:PAtkKeyEventStruct; func_data:gpointer):gint; cdecl; + + + PAtkKeyEventType = ^TAtkKeyEventType; + TAtkKeyEventType = ( + ATK_KEY_EVENT_PRESS, + ATK_KEY_EVENT_RELEASE, + ATK_KEY_EVENT_LAST_DEFINED + ); + + PAtkUtil = ^TAtkUtil; + TAtkUtil = record + parent : TGObject; + end; + + PAtkUtilClass = ^TAtkUtilClass; + TAtkUtilClass = record + parent : TGObjectClass; + add_global_event_listener : function (listener:TGSignalEmissionHook; event_type:Pgchar):guint; cdecl; + remove_global_event_listener : procedure (listener_id:guint); cdecl; + add_key_event_listener : function (listener:TAtkKeySnoopFunc; data:gpointer):guint; cdecl; + remove_key_event_listener : procedure (listener_id:guint); cdecl; + get_root : function :PAtkObject; cdecl; + get_toolkit_name : function :Pgchar; cdecl; + get_toolkit_version : function :Pgchar; cdecl; + end; + + + +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} +function ATK_TYPE_UTIL : GType; +function ATK_IS_UTIL(obj: pointer) : boolean; +function ATK_UTIL(obj: pointer) : PAtkUtil; +function ATK_UTIL_CLASS(klass: pointer) : PAtkUtilClass; +function ATK_IS_UTIL_CLASS(klass: pointer) : boolean; +function ATK_UTIL_GET_CLASS(obj: pointer) : PAtkUtilClass; + + +function atk_util_get_type:GType; cdecl; external atklib; + +{ + Adds the specified function to the list of functions to be called + when an anObject receives focus. + } + +function atk_add_focus_tracker(focus_tracker:TAtkEventListener):guint; cdecl; external atklib; +{ + Removes the specified focus tracker from the list of function + to be called when any anObject receives focus + } +procedure atk_remove_focus_tracker(tracker_id:guint); cdecl; external atklib; +{ + Specifies the function to be called for focus tracker initialization. + removal. This function should be called by an implementation of the + ATK interface if any specific work needs to be done to enable + focus tracking. + } +procedure atk_focus_tracker_init(add_function:TAtkEventListenerInit); cdecl; external atklib; +{ + Cause the focus tracker functions which have been specified to be + executed for the anObject. + } +procedure atk_focus_tracker_notify(anObject:PAtkObject); cdecl; external atklib; +{ + Adds the specified function to the list of functions to be called + when an event of type event_type occurs. + } +function atk_add_global_event_listener(listener:TGSignalEmissionHook; event_type:Pgchar):guint; cdecl; external atklib; +{ + Removes the specified event listener + } +procedure atk_remove_global_event_listener(listener_id:guint); cdecl; external atklib; +{ + Adds the specified function to the list of functions to be called + when an keyboard event occurs. + } +function atk_add_key_event_listener(listener:TAtkKeySnoopFunc; data:gpointer):guint; cdecl; external atklib; +{ + Removes the specified event listener + } +procedure atk_remove_key_event_listener(listener_id:guint); cdecl; external atklib; +{ + Returns the root accessible container for the current application. + } +function atk_get_root:PAtkObject; cdecl; external atklib; +{ + Returns name string for the GUI toolkit. + } +function atk_get_toolkit_name:Pgchar; cdecl; external atklib; +{ + Returns version string for the GUI toolkit. + } +function atk_get_toolkit_version:Pgchar; cdecl; external atklib; +{$ENDIF read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function ATK_TYPE_UTIL : GType; +begin + ATK_TYPE_UTIL:=atk_util_get_type; +end; + +function ATK_IS_UTIL(obj: pointer) : boolean; +begin + ATK_IS_UTIL:=G_TYPE_CHECK_INSTANCE_TYPE(obj,ATK_TYPE_UTIL); +end; + +function ATK_UTIL(obj: pointer) : PAtkUtil; +begin + ATK_UTIL:=PAtkUtil(G_TYPE_CHECK_INSTANCE_CAST(obj,ATK_TYPE_UTIL)); +end; + +function ATK_UTIL_CLASS(klass: pointer) : PAtkUtilClass; +begin + ATK_UTIL_CLASS:=PAtkUtilClass(G_TYPE_CHECK_CLASS_CAST(klass,ATK_TYPE_UTIL)); +end; + +function ATK_IS_UTIL_CLASS(klass: pointer) : boolean; +begin + ATK_IS_UTIL_CLASS:=G_TYPE_CHECK_CLASS_TYPE(klass,ATK_TYPE_UTIL); +end; + +function ATK_UTIL_GET_CLASS(obj: pointer) : PAtkUtilClass; +begin + ATK_UTIL_GET_CLASS:=PAtkUtilClass(G_TYPE_INSTANCE_GET_CLASS(obj,ATK_TYPE_UTIL)); +end; + +{$ENDIF read_implementation} + diff --git a/packages/gtk2/src/atk/atkvalue.inc b/packages/gtk2/src/atk/atkvalue.inc new file mode 100644 index 0000000000..47a12f7c14 --- /dev/null +++ b/packages/gtk2/src/atk/atkvalue.inc @@ -0,0 +1,76 @@ +// included by atk.pp + +{ + The AtkValue interface should be supported by any anObject that + supports a numerical value (e.g., a scroll bar). This interface + provides the standard mechanism for an assistive technology to + determine and set the numerical value as well as get the minimum + and maximum values. + } + +{$IFDEF read_forward_definitions} +{$ENDIF read_forward_definitions} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_types} + PAtkValueIface = ^TAtkValueIface; + TAtkValueIface = record + parent : TGTypeInterface; + get_current_value : procedure (obj:PAtkValue; value:PGValue); cdecl; + get_maximum_value : procedure (obj:PAtkValue; value:PGValue); cdecl; + get_minimum_value : procedure (obj:PAtkValue; value:PGValue); cdecl; + set_current_value : function (obj:PAtkValue; value:PGValue):gboolean; cdecl; + pad1 : TAtkFunction; + pad2 : TAtkFunction; + end; + +{$ENDIF read_interface_types} + +//------------------------------------------------------------------------------ + +{$IFDEF read_interface_rest} +function ATK_TYPE_VALUE : GType; +function ATK_IS_VALUE(obj: pointer) : boolean; +function ATK_VALUE(obj: pointer) : PAtkValue; +function ATK_VALUE_GET_IFACE(obj: pointer) : PAtkValueIface; + + +function atk_value_get_type:GType; cdecl; external atklib; +procedure atk_value_get_current_value(obj:PAtkValue; value:PGValue); cdecl; external atklib; +procedure atk_value_get_maximum_value(obj:PAtkValue; value:PGValue); cdecl; external atklib; +procedure atk_value_get_minimum_value(obj:PAtkValue; value:PGValue); cdecl; external atklib; +function atk_value_set_current_value(obj:PAtkValue; value:PGValue):gboolean; cdecl; external atklib; +{ + Additional GObject properties exported by GaccessibleValue: + "accessible_value" + (the accessible value has changed) + } + +{$ENDIF read_interface_rest} + +//------------------------------------------------------------------------------ + +{$IFDEF read_implementation} +function ATK_TYPE_VALUE : GType; +begin + ATK_TYPE_VALUE:=atk_value_get_type; +end; + +function ATK_IS_VALUE(obj: pointer) : boolean; +begin + ATK_IS_VALUE:=G_TYPE_CHECK_INSTANCE_TYPE(obj,ATK_TYPE_VALUE); +end; + +function ATK_VALUE(obj: pointer) : PAtkValue; +begin + ATK_VALUE:=PAtkValue(G_TYPE_CHECK_INSTANCE_CAST(obj,ATK_TYPE_VALUE)); +end; + +function ATK_VALUE_GET_IFACE(obj: pointer) : PAtkValueIface; +begin + ATK_VALUE_GET_IFACE:=PAtkValueIface(G_TYPE_INSTANCE_GET_INTERFACE(obj,ATK_TYPE_VALUE)); +end; + +{$ENDIF read_implementation} + |