diff options
Diffstat (limited to 'WebCore/page/gtk')
-rw-r--r-- | WebCore/page/gtk/AXObjectCacheAtk.cpp | 52 | ||||
-rw-r--r-- | WebCore/page/gtk/AccessibilityObjectAtk.cpp | 30 | ||||
-rw-r--r-- | WebCore/page/gtk/AccessibilityObjectWrapperAtk.cpp | 676 | ||||
-rw-r--r-- | WebCore/page/gtk/AccessibilityObjectWrapperAtk.h | 62 | ||||
-rw-r--r-- | WebCore/page/gtk/DragControllerGtk.cpp | 66 | ||||
-rw-r--r-- | WebCore/page/gtk/EventHandlerGtk.cpp | 123 | ||||
-rw-r--r-- | WebCore/page/gtk/FrameGtk.cpp | 37 |
7 files changed, 1046 insertions, 0 deletions
diff --git a/WebCore/page/gtk/AXObjectCacheAtk.cpp b/WebCore/page/gtk/AXObjectCacheAtk.cpp new file mode 100644 index 0000000..3535cf1 --- /dev/null +++ b/WebCore/page/gtk/AXObjectCacheAtk.cpp @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2008 Nuanti Ltd. + * + * 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; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#include "config.h" +#include "AXObjectCache.h" + +#include "AccessibilityObject.h" +#include "AccessibilityObjectWrapperAtk.h" + +namespace WebCore { + +void AXObjectCache::detachWrapper(AccessibilityObject* obj) +{ + webkit_accessible_detach(WEBKIT_ACCESSIBLE(obj->wrapper())); +} + +void AXObjectCache::attachWrapper(AccessibilityObject* obj) +{ + AtkObject* atkObj = ATK_OBJECT(webkit_accessible_new(obj)); + obj->setWrapper(atkObj); + g_object_unref(atkObj); +} + +void AXObjectCache::postNotification(RenderObject*, const String&) +{ +} + +void AXObjectCache::postNotificationToElement(RenderObject*, const String&) +{ +} + +void AXObjectCache::handleFocusedUIElementChanged() +{ +} + +} // namespace WebCore diff --git a/WebCore/page/gtk/AccessibilityObjectAtk.cpp b/WebCore/page/gtk/AccessibilityObjectAtk.cpp new file mode 100644 index 0000000..b755645 --- /dev/null +++ b/WebCore/page/gtk/AccessibilityObjectAtk.cpp @@ -0,0 +1,30 @@ +/* + * Copyright (C) 2008 Apple Ltd. + * + * 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; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#include "config.h" +#include "AccessibilityObject.h" + +namespace WebCore { + +bool AccessibilityObject::accessibilityIgnoreAttachment() const +{ + return false; +} + +} // namespace WebCore diff --git a/WebCore/page/gtk/AccessibilityObjectWrapperAtk.cpp b/WebCore/page/gtk/AccessibilityObjectWrapperAtk.cpp new file mode 100644 index 0000000..b46fb60 --- /dev/null +++ b/WebCore/page/gtk/AccessibilityObjectWrapperAtk.cpp @@ -0,0 +1,676 @@ +/* + * Copyright (C) 2008 Nuanti Ltd. + * + * 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; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#include "config.h" +#include "AccessibilityObjectWrapperAtk.h" + +#include "AXObjectCache.h" +#include "AccessibilityListBox.h" +#include "AccessibilityRenderObject.h" +#include "AtomicString.h" +#include "CString.h" +#include "Document.h" +#include "Editor.h" +#include "Frame.h" +#include "FrameView.h" +#include "IntRect.h" +#include "NotImplemented.h" + +#include <atk/atk.h> + +using namespace WebCore; + +// Used to provide const char* returns. +static const char* returnString(const String& str) +{ + static CString returnedString; + returnedString = str.utf8(); + return returnedString.data(); +} + +static AccessibilityObject* core(WebKitAccessible* accessible) +{ + if (!accessible) + return 0; + + return accessible->m_object; +} + +static AccessibilityObject* core(AtkObject* object) +{ + if (!WEBKIT_IS_ACCESSIBLE(object)) + return 0; + + return core(WEBKIT_ACCESSIBLE(object)); +} + +static AccessibilityObject* core(AtkAction* action) +{ + return core(ATK_OBJECT(action)); +} + +static AccessibilityObject* core(AtkStreamableContent* streamable) +{ + return core(ATK_OBJECT(streamable)); +} + +static AccessibilityObject* core(AtkText* text) +{ + return core(ATK_OBJECT(text)); +} + +static AccessibilityObject* core(AtkEditableText* text) +{ + return core(ATK_OBJECT(text)); +} + +extern "C" { + +static gpointer parent_class = NULL; + +static void webkit_accessible_init(AtkObject* object, gpointer data) +{ + g_return_if_fail(WEBKIT_IS_ACCESSIBLE(object)); + g_return_if_fail(data); + + if (ATK_OBJECT_CLASS(parent_class)->initialize) + ATK_OBJECT_CLASS(parent_class)->initialize(object, data); + + WEBKIT_ACCESSIBLE(object)->m_object = reinterpret_cast<AccessibilityObject*>(data); +} + +static void webkit_accessible_finalize(GObject* object) +{ + // This is a good time to clear the return buffer. + returnString(String()); + + if (G_OBJECT_CLASS(parent_class)->finalize) + G_OBJECT_CLASS(parent_class)->finalize(object); +} + +static const gchar* webkit_accessible_get_name(AtkObject* object) +{ + // TODO: Deal with later changes. + if (!object->name) + atk_object_set_name(object, core(object)->title().utf8().data()); + return object->name; +} + +static const gchar* webkit_accessible_get_description(AtkObject* object) +{ + // TODO: the Mozilla MSAA implementation prepends "Description: " + // Should we do this too? + + // TODO: Deal with later changes. + if (!object->description) + atk_object_set_description(object, core(object)->accessibilityDescription().utf8().data()); + return object->description; +} + +static AtkObject* webkit_accessible_get_parent(AtkObject* object) +{ + AccessibilityObject* coreParent = core(object)->parentObject(); + + if (!coreParent) + return NULL; + + return coreParent->wrapper(); +} + +static gint webkit_accessible_get_n_children(AtkObject* object) +{ + return core(object)->children().size(); +} + +static AtkObject* webkit_accessible_ref_child(AtkObject* object, gint index) +{ + AccessibilityObject* coreObject = core(object); + + g_return_val_if_fail(index >= 0, NULL); + g_return_val_if_fail(static_cast<size_t>(index) < coreObject->children().size(), NULL); + + AccessibilityObject* coreChild = coreObject->children().at(index).get(); + + if (!coreChild) + return NULL; + + AtkObject* child = coreChild->wrapper(); + // TODO: Should we call atk_object_set_parent() here? + //atk_object_set_parent(child, object); + g_object_ref(child); + + return child; +} + +static gint webkit_accessible_get_index_in_parent(AtkObject* object) +{ + // FIXME: This needs to be implemented. + notImplemented(); + return 0; +} + +static AtkRole atkRole(AccessibilityRole role) +{ + switch (role) { + case WebCore::ButtonRole: + return ATK_ROLE_PUSH_BUTTON; + case WebCore::RadioButtonRole: + return ATK_ROLE_RADIO_BUTTON; + case WebCore::CheckBoxRole: + return ATK_ROLE_CHECK_BOX; + case WebCore::SliderRole: + return ATK_ROLE_SLIDER; + case WebCore::TabGroupRole: + return ATK_ROLE_PAGE_TAB_LIST; + case WebCore::TextFieldRole: + case WebCore::TextAreaRole: + case WebCore::ListMarkerRole: + return ATK_ROLE_ENTRY; + case WebCore::StaticTextRole: + return ATK_ROLE_TEXT; //? + case WebCore::OutlineRole: + return ATK_ROLE_TREE; + case WebCore::ColumnRole: + return ATK_ROLE_UNKNOWN; //? + case WebCore::RowRole: + return ATK_ROLE_LIST_ITEM; + case WebCore::GroupRole: + return ATK_ROLE_UNKNOWN; //? + case WebCore::ListRole: + return ATK_ROLE_LIST; + case WebCore::TableRole: + return ATK_ROLE_TABLE; + case WebCore::LinkRole: + case WebCore::WebCoreLinkRole: + return ATK_ROLE_LINK; + case WebCore::ImageMapRole: + case WebCore::ImageRole: + return ATK_ROLE_IMAGE; + default: + return ATK_ROLE_UNKNOWN; + } +} + +static AtkRole webkit_accessible_get_role(AtkObject* object) +{ + return atkRole(core(object)->roleValue()); +} + +static void webkit_accessible_class_init(AtkObjectClass* klass) +{ + GObjectClass* gobject_class = G_OBJECT_CLASS(klass); + + parent_class = g_type_class_peek_parent(klass); + + klass->initialize = webkit_accessible_init; + + gobject_class->finalize = webkit_accessible_finalize; + + klass->get_name = webkit_accessible_get_name; + klass->get_description = webkit_accessible_get_description; + klass->get_parent = webkit_accessible_get_parent; + klass->get_n_children = webkit_accessible_get_n_children; + klass->ref_child = webkit_accessible_ref_child; + //klass->get_index_in_parent = webkit_accessible_get_index_in_parent; + klass->get_role = webkit_accessible_get_role; + //klass->get_attributes = webkit_accessible_get_attributes; + //klass->ref_state_set = webkit_accessible_ref_state_set; + //klass->ref_relation_set = webkit_accessible_ref_relation_set; +} + +static gboolean webkit_accessible_action_do_action(AtkAction* action, gint i) +{ + g_return_val_if_fail(i == 0, FALSE); + return core(action)->performDefaultAction(); +} + +static gint webkit_accessible_action_get_n_actions(AtkAction* action) +{ + return 1; +} + +static const gchar* webkit_accessible_action_get_description(AtkAction* action, gint i) +{ + g_return_val_if_fail(i == 0, NULL); + // TODO: Need a way to provide/localize action descriptions. + notImplemented(); + return ""; +} + +static const gchar* webkit_accessible_action_get_keybinding(AtkAction* action, gint i) +{ + g_return_val_if_fail(i == 0, NULL); + // FIXME: Construct a proper keybinding string. + return returnString(core(action)->accessKey().string()); +} + +static const gchar* webkit_accessible_action_get_name(AtkAction* action, gint i) +{ + g_return_val_if_fail(i == 0, NULL); + return returnString(core(action)->actionVerb()); +} + +static void atk_action_interface_init(AtkActionIface* iface) +{ + g_return_if_fail(iface); + + iface->do_action = webkit_accessible_action_do_action; + iface->get_n_actions = webkit_accessible_action_get_n_actions; + iface->get_description = webkit_accessible_action_get_description; + iface->get_keybinding = webkit_accessible_action_get_keybinding; + iface->get_name = webkit_accessible_action_get_name; +} + +// Text + +static gchar* webkit_accessible_text_get_text(AtkText* text, gint start_offset, gint end_offset) +{ + String ret = core(text)->doAXStringForRange(PlainTextRange(start_offset, end_offset - start_offset)); + // TODO: Intentionally copied? + return g_strdup(ret.utf8().data()); +} + +static gchar* webkit_accessible_text_get_text_after_offset(AtkText* text, gint offset, AtkTextBoundary boundary_type, gint* start_offset, gint* end_offset) +{ + notImplemented(); + return NULL; +} + +static gchar* webkit_accessible_text_get_text_at_offset(AtkText* text, gint offset, AtkTextBoundary boundary_type, gint* start_offset, gint* end_offset) +{ + notImplemented(); + return NULL; +} + +static gunichar webkit_accessible_text_get_character_at_offset(AtkText* text, gint offset) +{ + notImplemented(); + return 0; +} + +static gchar* webkit_accessible_text_get_text_before_offset(AtkText* text, gint offset, AtkTextBoundary boundary_type, gint* start_offset, gint* end_offset) +{ + notImplemented(); + return NULL; +} + +static gint webkit_accessible_text_get_caret_offset(AtkText* text) +{ + // TODO: Verify this, especially for RTL text. + return core(text)->selectionStart(); +} + +static AtkAttributeSet* webkit_accessible_text_get_run_attributes(AtkText* text, gint offset, gint* start_offset, gint* end_offset) +{ + notImplemented(); + return NULL; +} + +static AtkAttributeSet* webkit_accessible_text_get_default_attributes(AtkText* text) +{ + notImplemented(); + return NULL; +} + +static void webkit_accessible_text_get_character_extents(AtkText* text, gint offset, gint* x, gint* y, gint* width, gint* height, AtkCoordType coords) +{ + IntRect extents = core(text)->doAXBoundsForRange(PlainTextRange(offset, 1)); + // FIXME: Use the AtkCoordType + // Requires WebCore::ScrollView::contentsToScreen() to be implemented + +#if 0 + switch(coords) { + case ATK_XY_SCREEN: + extents = core(text)->document()->view()->contentsToScreen(extents); + break; + case ATK_XY_WINDOW: + // No-op + break; + } +#endif + + *x = extents.x(); + *y = extents.y(); + *width = extents.width(); + *height = extents.height(); +} + +static gint webkit_accessible_text_get_character_count(AtkText* text) +{ + return core(text)->textLength(); +} + +static gint webkit_accessible_text_get_offset_at_point(AtkText* text, gint x, gint y, AtkCoordType coords) +{ + // FIXME: Use the AtkCoordType + // TODO: Is it correct to ignore range.length? + IntPoint pos(x, y); + PlainTextRange range = core(text)->doAXRangeForPosition(pos); + return range.start; +} + +static gint webkit_accessible_text_get_n_selections(AtkText* text) +{ + notImplemented(); + return 0; +} + +static gchar* webkit_accessible_text_get_selection(AtkText* text, gint selection_num, gint* start_offset, gint* end_offset) +{ + notImplemented(); + return NULL; +} + +static gboolean webkit_accessible_text_add_selection(AtkText* text, gint start_offset, gint end_offset) +{ + notImplemented(); + return FALSE; +} + +static gboolean webkit_accessible_text_remove_selection(AtkText* text, gint selection_num) +{ + notImplemented(); + return FALSE; +} + +static gboolean webkit_accessible_text_set_selection(AtkText* text, gint selection_num, gint start_offset, gint end_offset) +{ + notImplemented(); + return FALSE; +} + +static gboolean webkit_accessible_text_set_caret_offset(AtkText* text, gint offset) +{ + // TODO: Verify + //core(text)->setSelectedTextRange(PlainTextRange(offset, 0)); + AccessibilityObject* coreObject = core(text); + coreObject->setSelectedVisiblePositionRange(coreObject->visiblePositionRangeForRange(PlainTextRange(offset, 0))); + return TRUE; +} + +#if 0 +// Signal handlers +static void webkit_accessible_text_text_changed(AtkText* text, gint position, gint length) +{ +} + +static void webkit_accessible_text_text_caret_moved(AtkText* text, gint location) +{ +} + +static void webkit_accessible_text_text_selection_changed(AtkText* text) +{ +} + +static void webkit_accessible_text_text_attributes_changed(AtkText* text) +{ +} + +static void webkit_accessible_text_get_range_extents(AtkText* text, gint start_offset, gint end_offset, AtkCoordType coord_type, AtkTextRectangle* rect) +{ +} + +static AtkTextRange** webkit_accessible_text_get_bounded_ranges(AtkText* text, AtkTextRectangle* rect, AtkCoordType coord_type, AtkTextClipType x_clip_type, AtkTextClipType y_clip_type) +{ +} +#endif + +static void atk_text_interface_init(AtkTextIface* iface) +{ + g_return_if_fail(iface); + + iface->get_text = webkit_accessible_text_get_text; + iface->get_text_after_offset = webkit_accessible_text_get_text_after_offset; + iface->get_text_at_offset = webkit_accessible_text_get_text_at_offset; + iface->get_character_at_offset = webkit_accessible_text_get_character_at_offset; + iface->get_text_before_offset = webkit_accessible_text_get_text_before_offset; + iface->get_caret_offset = webkit_accessible_text_get_caret_offset; + iface->get_run_attributes = webkit_accessible_text_get_run_attributes; + iface->get_default_attributes = webkit_accessible_text_get_default_attributes; + iface->get_character_extents = webkit_accessible_text_get_character_extents; + //iface->get_range_extents = ; + iface->get_character_count = webkit_accessible_text_get_character_count; + iface->get_offset_at_point = webkit_accessible_text_get_offset_at_point; + iface->get_n_selections = webkit_accessible_text_get_n_selections; + iface->get_selection = webkit_accessible_text_get_selection; + + // set methods + iface->add_selection = webkit_accessible_text_add_selection; + iface->remove_selection = webkit_accessible_text_remove_selection; + iface->set_selection = webkit_accessible_text_set_selection; + iface->set_caret_offset = webkit_accessible_text_set_caret_offset; +} + +// EditableText + +static gboolean webkit_accessible_editable_text_set_run_attributes(AtkEditableText* text, AtkAttributeSet* attrib_set, gint start_offset, gint end_offset) +{ + notImplemented(); + return FALSE; +} + +static void webkit_accessible_editable_text_set_text_contents(AtkEditableText* text, const gchar* string) +{ + // FIXME: string nullcheck? + core(text)->setValue(String::fromUTF8(string)); +} + +static void webkit_accessible_editable_text_insert_text(AtkEditableText* text, const gchar* string, gint length, gint* position) +{ + // FIXME: string nullcheck? + + AccessibilityObject* coreObject = core(text); + // FIXME: Not implemented in WebCore + //coreObject->setSelectedTextRange(PlainTextRange(*position, 0)); + //coreObject->setSelectedText(String::fromUTF8(string)); + + if (!coreObject->document() || !coreObject->document()->frame()) + return; + coreObject->setSelectedVisiblePositionRange(coreObject->visiblePositionRangeForRange(PlainTextRange(*position, 0))); + coreObject->setFocused(true); + // FIXME: We should set position to the actual inserted text length, which may be less than that requested. + if (coreObject->document()->frame()->editor()->insertTextWithoutSendingTextEvent(String::fromUTF8(string), false, 0)) + *position += length; +} + +static void webkit_accessible_editable_text_copy_text(AtkEditableText* text, gint start_pos, gint end_pos) +{ + notImplemented(); +} + +static void webkit_accessible_editable_text_cut_text(AtkEditableText* text, gint start_pos, gint end_pos) +{ + notImplemented(); +} + +static void webkit_accessible_editable_text_delete_text(AtkEditableText* text, gint start_pos, gint end_pos) +{ + AccessibilityObject* coreObject = core(text); + // FIXME: Not implemented in WebCore + //coreObject->setSelectedTextRange(PlainTextRange(start_pos, end_pos - start_pos)); + //coreObject->setSelectedText(String()); + + if (!coreObject->document() || !coreObject->document()->frame()) + return; + coreObject->setSelectedVisiblePositionRange(coreObject->visiblePositionRangeForRange(PlainTextRange(start_pos, end_pos - start_pos))); + coreObject->setFocused(true); + coreObject->document()->frame()->editor()->performDelete(); +} + +static void webkit_accessible_editable_text_paste_text(AtkEditableText* text, gint position) +{ + notImplemented(); +} + +static void atk_editable_text_interface_init(AtkEditableTextIface* iface) +{ + g_return_if_fail(iface); + + iface->set_run_attributes = webkit_accessible_editable_text_set_run_attributes; + iface->set_text_contents = webkit_accessible_editable_text_set_text_contents; + iface->insert_text = webkit_accessible_editable_text_insert_text; + iface->copy_text = webkit_accessible_editable_text_copy_text; + iface->cut_text = webkit_accessible_editable_text_cut_text; + iface->delete_text = webkit_accessible_editable_text_delete_text; + iface->paste_text = webkit_accessible_editable_text_paste_text; +} + +// StreamableContent + +static gint webkit_accessible_streamable_content_get_n_mime_types(AtkStreamableContent* streamable) +{ + notImplemented(); + return 0; +} + +static G_CONST_RETURN gchar* webkit_accessible_streamable_content_get_mime_type(AtkStreamableContent* streamable, gint i) +{ + notImplemented(); + return ""; +} + +static GIOChannel* webkit_accessible_streamable_content_get_stream(AtkStreamableContent* streamable, const gchar* mime_type) +{ + notImplemented(); + return NULL; +} + +static G_CONST_RETURN gchar* webkit_accessible_streamable_content_get_uri(AtkStreamableContent* streamable, const gchar* mime_type) +{ + notImplemented(); + return NULL; +} + +static void atk_streamable_content_interface_init(AtkStreamableContentIface* iface) +{ + g_return_if_fail(iface); + + iface->get_n_mime_types = webkit_accessible_streamable_content_get_n_mime_types; + iface->get_mime_type = webkit_accessible_streamable_content_get_mime_type; + iface->get_stream = webkit_accessible_streamable_content_get_stream; + iface->get_uri = webkit_accessible_streamable_content_get_uri; +} + +GType webkit_accessible_get_type() +{ + static GType type = 0; + + if (!type) { + static const GTypeInfo tinfo = { + sizeof(WebKitAccessibleClass), + (GBaseInitFunc)NULL, + (GBaseFinalizeFunc)NULL, + (GClassInitFunc)webkit_accessible_class_init, + (GClassFinalizeFunc)NULL, + NULL, /* class data */ + sizeof(WebKitAccessible), /* instance size */ + 0, /* nb preallocs */ + (GInstanceInitFunc)NULL, + NULL /* value table */ + }; + + type = g_type_register_static(ATK_TYPE_OBJECT, "WebKitAccessible", &tinfo, static_cast<GTypeFlags>(0)); + + // TODO: Only implement interfaces when necessary, not for all objects. + static const GInterfaceInfo atk_action_info = + { + (GInterfaceInitFunc) atk_action_interface_init, + (GInterfaceFinalizeFunc) NULL, + NULL + }; + g_type_add_interface_static(type, ATK_TYPE_ACTION, &atk_action_info); + + static const GInterfaceInfo atk_text_info = + { + (GInterfaceInitFunc) atk_text_interface_init, + (GInterfaceFinalizeFunc) NULL, + NULL + }; + g_type_add_interface_static(type, ATK_TYPE_TEXT, &atk_text_info); + + static const GInterfaceInfo atk_editable_text_info = + { + (GInterfaceInitFunc) atk_editable_text_interface_init, + (GInterfaceFinalizeFunc) NULL, + NULL + }; + g_type_add_interface_static(type, ATK_TYPE_EDITABLE_TEXT, &atk_editable_text_info); + + static const GInterfaceInfo atk_streamable_content_info = + { + (GInterfaceInitFunc) atk_streamable_content_interface_init, + (GInterfaceFinalizeFunc) NULL, + NULL + }; + g_type_add_interface_static(type, ATK_TYPE_STREAMABLE_CONTENT, &atk_streamable_content_info); + } + return type; +} + +WebKitAccessible* webkit_accessible_new(AccessibilityObject* coreObject) +{ + GType type = WEBKIT_TYPE_ACCESSIBLE; + AtkObject* object = static_cast<AtkObject*>(g_object_new(type, NULL)); + atk_object_initialize(object, coreObject); + return WEBKIT_ACCESSIBLE(object); +} + +AccessibilityObject* webkit_accessible_get_accessibility_object(WebKitAccessible* accessible) +{ + return accessible->m_object; +} + +// FIXME: Remove this static initialization. +static AXObjectCache* fallbackCache = new AXObjectCache(); + +void webkit_accessible_detach(WebKitAccessible* accessible) +{ + ASSERT(accessible->m_object); + + // We replace the WebCore AccessibilityObject with a fallback object that + // provides default implementations to avoid repetitive null-checking after + // detachment. + + // FIXME: Using fallbackCache->get(ListBoxOptionRole) is a hack. + accessible->m_object = fallbackCache->get(ListBoxOptionRole); +} + +} + +namespace WebCore { + +// AccessibilityObject implementations + +AccessibilityObjectWrapper* AccessibilityObject::wrapper() const +{ + return m_wrapper; +} + +void AccessibilityObject::setWrapper(AccessibilityObjectWrapper* wrapper) +{ + if (m_wrapper) + g_object_unref(m_wrapper); + + m_wrapper = wrapper; + + if (m_wrapper) + g_object_ref(m_wrapper); +} + +} // namespace WebCore diff --git a/WebCore/page/gtk/AccessibilityObjectWrapperAtk.h b/WebCore/page/gtk/AccessibilityObjectWrapperAtk.h new file mode 100644 index 0000000..ecfb99e --- /dev/null +++ b/WebCore/page/gtk/AccessibilityObjectWrapperAtk.h @@ -0,0 +1,62 @@ +/* + * Copyright (C) 2008 Nuanti Ltd. + * + * 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; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#ifndef AccessibilityObjectWrapperAtk_h +#define AccessibilityObjectWrapperAtk_h + +#include <atk/atk.h> + +namespace WebCore { + class AccessibilityObject; +} + +G_BEGIN_DECLS + +#define WEBKIT_TYPE_ACCESSIBLE (webkit_accessible_get_type ()) +#define WEBKIT_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), WEBKIT_TYPE_ACCESSIBLE, WebKitAccessible)) +#define WEBKIT_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), WEBKIT_TYPE_ACCESSIBLE, WebKitAccessibleClass)) +#define WEBKIT_IS_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), WEBKIT_TYPE_ACCESSIBLE)) +#define WEBKIT_IS_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), WEBKIT_TYPE_ACCESSIBLE)) +#define WEBKIT_ACCESSIBLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), WEBKIT_TYPE_ACCESSIBLE, WebKitAccessibleClass)) + +typedef struct _WebKitAccessible WebKitAccessible; +typedef struct _WebKitAccessibleClass WebKitAccessibleClass; + +struct _WebKitAccessible +{ + AtkObject parent; + WebCore::AccessibilityObject* m_object; +}; + +struct _WebKitAccessibleClass +{ + AtkObjectClass parent_class; +}; + +GType webkit_accessible_get_type (void) G_GNUC_CONST; + +WebKitAccessible* webkit_accessible_new (WebCore::AccessibilityObject* core_object); + +WebCore::AccessibilityObject* webkit_accessible_get_accessibility_object (WebKitAccessible* accessible); + +void webkit_accessible_detach (WebKitAccessible* accessible); + +G_END_DECLS + +#endif // AccessibilityObjectWrapperAtk_h diff --git a/WebCore/page/gtk/DragControllerGtk.cpp b/WebCore/page/gtk/DragControllerGtk.cpp new file mode 100644 index 0000000..62f4421 --- /dev/null +++ b/WebCore/page/gtk/DragControllerGtk.cpp @@ -0,0 +1,66 @@ +/* + * Copyright (C) 2007 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "DragController.h" + +#include "DragData.h" +#include "Frame.h" +#include "FrameView.h" +#include "Page.h" + +namespace WebCore { + +// FIXME: These values are straight out of DragControllerMac, so probably have +// little correlation with Gdk standards... +const int DragController::LinkDragBorderInset = 2; +const int DragController::MaxOriginalImageArea = 1500 * 1500; +const int DragController::DragIconRightInset = 7; +const int DragController::DragIconBottomInset = 3; + +const float DragController::DragImageAlpha = 0.75f; + +bool DragController::isCopyKeyDown() +{ + return false; +} + +DragOperation DragController::dragOperation(DragData* dragData) +{ + //FIXME: This logic is incomplete + if (dragData->containsURL()) + return DragOperationCopy; + + return DragOperationNone; +} + +const IntSize& DragController::maxDragImageSize() +{ + static const IntSize maxDragImageSize(400, 400); + + return maxDragImageSize; +} + +} diff --git a/WebCore/page/gtk/EventHandlerGtk.cpp b/WebCore/page/gtk/EventHandlerGtk.cpp new file mode 100644 index 0000000..bb650b4 --- /dev/null +++ b/WebCore/page/gtk/EventHandlerGtk.cpp @@ -0,0 +1,123 @@ +/* + * Copyright (C) 2006 Zack Rusin <zack@kde.org> + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "EventHandler.h" + +#include "ClipboardGtk.h" +#include "FloatPoint.h" +#include "FocusController.h" +#include "Frame.h" +#include "FrameView.h" +#include "KeyboardEvent.h" +#include "MouseEventWithHitTestResults.h" +#include "NotImplemented.h" +#include "Page.h" +#include "PlatformKeyboardEvent.h" +#include "PlatformWheelEvent.h" +#include "RenderWidget.h" +#include "Scrollbar.h" + +namespace WebCore { + +unsigned EventHandler::s_accessKeyModifiers = PlatformKeyboardEvent::AltKey; + +const double EventHandler::TextDragDelay = 0.0; + +bool EventHandler::tabsToAllControls(KeyboardEvent* event) const +{ + // We always allow tabs to all controls + return true; +} + +void EventHandler::focusDocumentView() +{ + if (Page* page = m_frame->page()) + page->focusController()->setFocusedFrame(m_frame); +} + +bool EventHandler::passWidgetMouseDownEventToWidget(const MouseEventWithHitTestResults& event) +{ + // Figure out which view to send the event to. + RenderObject* target = event.targetNode() ? event.targetNode()->renderer() : 0; + if (!target || !target->isWidget()) + return false; + + return passMouseDownEventToWidget(static_cast<RenderWidget*>(target)->widget()); +} + +bool EventHandler::passWidgetMouseDownEventToWidget(RenderWidget* renderWidget) +{ + return passMouseDownEventToWidget(renderWidget->widget()); +} + +bool EventHandler::passMouseDownEventToWidget(Widget* widget) +{ + notImplemented(); + return false; +} + +bool EventHandler::eventActivatedView(const PlatformMouseEvent&) const +{ + //GTK+ activation is not necessarily tied to mouse events, so it may + //not make sense to implement this + + notImplemented(); + return false; +} + +bool EventHandler::passWheelEventToWidget(PlatformWheelEvent& event, Widget* widget) +{ + ASSERT(widget); + if (!widget->isFrameView()) + return false; + + return static_cast<FrameView*>(widget)->frame()->eventHandler()->handleWheelEvent(event); +} + +PassRefPtr<Clipboard> EventHandler::createDraggingClipboard() const +{ + return ClipboardGtk::create(ClipboardWritable, true); +} + +bool EventHandler::passMousePressEventToSubframe(MouseEventWithHitTestResults& mev, Frame* subframe) +{ + subframe->eventHandler()->handleMousePressEvent(mev.event()); + return true; +} + +bool EventHandler::passMouseMoveEventToSubframe(MouseEventWithHitTestResults& mev, Frame* subframe, HitTestResult* hoveredNode) +{ + subframe->eventHandler()->handleMouseMoveEvent(mev.event(), hoveredNode); + return true; +} + +bool EventHandler::passMouseReleaseEventToSubframe(MouseEventWithHitTestResults& mev, Frame* subframe) +{ + subframe->eventHandler()->handleMouseReleaseEvent(mev.event()); + return true; +} + +} diff --git a/WebCore/page/gtk/FrameGtk.cpp b/WebCore/page/gtk/FrameGtk.cpp new file mode 100644 index 0000000..3cab5a0 --- /dev/null +++ b/WebCore/page/gtk/FrameGtk.cpp @@ -0,0 +1,37 @@ +/* + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "Frame.h" + +#include "NotImplemented.h" + +namespace WebCore { + +DragImageRef Frame::dragImageForSelection() +{ + notImplemented(); + return 0; +} + +} |