vcl/unx/gtk/a11y/atkutil.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: atkutil.cxx,v $
  10  * $Revision: 1.10 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_vcl.hxx"
  33
  34 #include <com/sun/star/accessibility/XAccessibleContext.hpp>
  35 #include <com/sun/star/accessibility/XAccessibleEventBroadcaster.hpp>
  36 #include <com/sun/star/accessibility/XAccessibleSelection.hpp>
  37 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  38 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  39 // --> OD 2009-04-14 #i93269#
  40 #include <com/sun/star/accessibility/XAccessibleText.hpp>
  41 // <--
  42 #include <cppuhelper/implbase1.hxx>
  43 #include <vos/mutex.hxx>
  44 #include <rtl/ref.hxx>
  45
  46 #include <vcl/svapp.hxx>
  47 #include <vcl/window.hxx>
  48 #include <vcl/menu.hxx>
  49 #include <vcl/toolbox.hxx>
  50
  51 #include "atkwrapper.hxx"
  52 #include "atkutil.hxx"
  53
  54 #include <gtk/gtk.h>
  55
  56 #include <set>
  57
  58 // #define ENABLE_TRACING
  59
  60 #ifdef ENABLE_TRACING
  61 #include <stdio.h>
  62 #endif
  63
  64 using namespace ::com::sun::star;
  65
  66 static uno::WeakReference< accessibility::XAccessible > xNextFocusObject;
  67 static guint focus_notify_handler = 0;
  68
  69 /*****************************************************************************/
  70
  71 extern "C" {
  72
  73 static gint
  74 atk_wrapper_focus_idle_handler (gpointer data)
  75 {
  76     vos::OGuard aGuard( Application::GetSolarMutex() );
  77
  78     focus_notify_handler = 0;
  79
  80     uno::Reference< accessibility::XAccessible > xAccessible = xNextFocusObject;
  81     if( xAccessible.get() == reinterpret_cast < accessibility::XAccessible * > (data) )
  82     {
  83         // Gail does not notify focus changes to NULL, so do we ..
  84         if( xAccessible.is() )
  85         {
  86             AtkObject *atk_obj = atk_object_wrapper_ref( xAccessible );
  87
  88 #ifdef ENABLE_TRACING
  89             fprintf(stderr, "notifying focus event for %p\n", atk_obj);
  90 #endif
  91             atk_focus_tracker_notify(atk_obj);
  92             // --> OD 2009-04-14 #i93269#
  93             // emit text_caret_moved event for <XAccessibleText> object,
  94             // if cursor is inside the <XAccessibleText> object.
  95             // also emit state-changed:focused event under the same condition.
  96             {
  97                 AtkObjectWrapper* wrapper_obj = ATK_OBJECT_WRAPPER (atk_obj);
  98                 if( !wrapper_obj->mpText && wrapper_obj->mpContext )
  99                 {
 100                     uno::Any any = wrapper_obj->mpContext->queryInterface( accessibility::XAccessibleText::static_type(NULL) );
 101                     if ( typelib_TypeClass_INTERFACE == any.pType->eTypeClass &&
 102                          any.pReserved != 0 )
 103                     {
 104                         wrapper_obj->mpText = reinterpret_cast< accessibility::XAccessibleText * > (any.pReserved);
 105                         if ( wrapper_obj->mpText != 0 )
 106                         {
 107                             wrapper_obj->mpText->acquire();
 108                             gint caretPos = wrapper_obj->mpText->getCaretPosition();
 109
 110                             if ( caretPos != -1 )
 111                             {
 112                                 atk_object_notify_state_change( atk_obj, ATK_STATE_FOCUSED, TRUE );
 113                                 g_signal_emit_by_name( atk_obj, "text_caret_moved", caretPos );
 114                             }
 115                         }
 116                     }
 117                 }
 118             }
 119             // <--
 120             g_object_unref(atk_obj);
 121         }
 122     }
 123
 124     return FALSE;
 125 }
 126
 127 } // extern "C"
 128
 129 /*****************************************************************************/
 130
 131 static void
 132 atk_wrapper_focus_tracker_notify_when_idle( const uno::Reference< accessibility::XAccessible > &xAccessible )
 133 {
 134     if( focus_notify_handler )
 135         g_source_remove(focus_notify_handler);
 136
 137     xNextFocusObject = xAccessible;
 138
 139     focus_notify_handler = g_idle_add (atk_wrapper_focus_idle_handler, xAccessible.get());
 140 }
 141
 142 /*****************************************************************************/
 143
 144 class DocumentFocusListener :
 145     public ::cppu::WeakImplHelper1< accessibility::XAccessibleEventListener >
 146 {
 147
 148     std::set< uno::Reference< uno::XInterface > > m_aRefList;
 149
 150 public:
 151     void attachRecursive(
 152         const uno::Reference< accessibility::XAccessible >& xAccessible
 153     ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException);
 154
 155     void attachRecursive(
 156         const uno::Reference< accessibility::XAccessible >& xAccessible,
 157         const uno::Reference< accessibility::XAccessibleContext >& xContext
 158     ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException);
 159
 160     void attachRecursive(
 161         const uno::Reference< accessibility::XAccessible >& xAccessible,
 162         const uno::Reference< accessibility::XAccessibleContext >& xContext,
 163         const uno::Reference< accessibility::XAccessibleStateSet >& xStateSet
 164     ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException);
 165
 166     void detachRecursive(
 167         const uno::Reference< accessibility::XAccessible >& xAccessible
 168     ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException);
 169
 170     void detachRecursive(
 171         const uno::Reference< accessibility::XAccessible >& xAccessible,
 172         const uno::Reference< accessibility::XAccessibleContext >& xContext
 173     ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException);
 174
 175     void detachRecursive(
 176         const uno::Reference< accessibility::XAccessible >& xAccessible,
 177         const uno::Reference< accessibility::XAccessibleContext >& xContext,
 178         const uno::Reference< accessibility::XAccessibleStateSet >& xStateSet
 179     ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException);
 180
 181     static uno::Reference< accessibility::XAccessible > getAccessible(const lang::EventObject& aEvent )
 182         throw (lang::IndexOutOfBoundsException, uno::RuntimeException);
 183
 184     // XEventListener
 185     virtual void disposing( const lang::EventObject& Source ) throw (uno::RuntimeException);
 186
 187     // XAccessibleEventListener
 188     virtual void notifyEvent( const accessibility::AccessibleEventObject& aEvent ) throw( uno::RuntimeException );
 189 };
 190
 191 /*****************************************************************************/
 192
 193 void DocumentFocusListener::disposing( const lang::EventObject& aEvent )
 194     throw (uno::RuntimeException)
 195 {
 196 //    fprintf(stderr, "In DocumentFocusListener::disposing (%p)\n", this);
 197 //    fprintf(stderr, "m_aRefList has %d entries\n", m_aRefList.size());
 198
 199     // Unref the object here, but do not remove as listener since the object
 200     // might no longer be in a state that safely allows this.
 201     if( aEvent.Source.is() )
 202         m_aRefList.erase(aEvent.Source);
 203
 204 //    fprintf(stderr, "m_aRefList has %d entries\n", m_aRefList.size());
 205
 206 }
 207
 208 /*****************************************************************************/
 209
 210 void DocumentFocusListener::notifyEvent( const accessibility::AccessibleEventObject& aEvent )
 211     throw( uno::RuntimeException )
 212 {
 213     switch( aEvent.EventId )
 214     {
 215         case accessibility::AccessibleEventId::STATE_CHANGED:
 216             try
 217             {
 218                 sal_Int16 nState = accessibility::AccessibleStateType::INVALID;
 219                 aEvent.NewValue >>= nState;
 220
 221                 if( accessibility::AccessibleStateType::FOCUSED == nState )
 222                     atk_wrapper_focus_tracker_notify_when_idle( getAccessible(aEvent) );
 223             }
 224             catch(lang::IndexOutOfBoundsException e)
 225             {
 226                 g_warning("Focused object has invalid index in parent");
 227             }
 228             break;
 229
 230         case accessibility::AccessibleEventId::CHILD:
 231         {
 232             uno::Reference< accessibility::XAccessible > xChild;
 233             if( (aEvent.OldValue >>= xChild) && xChild.is() )
 234                 detachRecursive(xChild);
 235
 236             if( (aEvent.NewValue >>= xChild) && xChild.is() )
 237                 attachRecursive(xChild);
 238         }
 239             break;
 240
 241         case accessibility::AccessibleEventId::INVALIDATE_ALL_CHILDREN:
 242 /*        {
 243             uno::Reference< accessibility::XAccessible > xAccessible( getAccessible(aEvent) );
 244             detachRecursive(xAccessible);
 245             attachRecursive(xAccessible);
 246         }
 247 */
 248             g_warning( "Invalidate all children called\n" );
 249             break;
 250         default:
 251             break;
 252     }
 253 }
 254
 255 /*****************************************************************************/
 256
 257 uno::Reference< accessibility::XAccessible > DocumentFocusListener::getAccessible(const lang::EventObject& aEvent )
 258     throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
 259 {
 260     uno::Reference< accessibility::XAccessible > xAccessible(aEvent.Source, uno::UNO_QUERY);
 261
 262     if( xAccessible.is() )
 263         return xAccessible;
 264
 265     uno::Reference< accessibility::XAccessibleContext > xContext(aEvent.Source, uno::UNO_QUERY);
 266
 267     if( xContext.is() )
 268     {
 269         uno::Reference< accessibility::XAccessible > xParent( xContext->getAccessibleParent() );
 270         if( xParent.is() )
 271         {
 272             uno::Reference< accessibility::XAccessibleContext > xParentContext( xParent->getAccessibleContext() );
 273             if( xParentContext.is() )
 274             {
 275                 return xParentContext->getAccessibleChild( xContext->getAccessibleIndexInParent() );
 276             }
 277         }
 278     }
 279
 280     return uno::Reference< accessibility::XAccessible >();
 281 }
 282
 283 /*****************************************************************************/
 284
 285 void DocumentFocusListener::attachRecursive(
 286     const uno::Reference< accessibility::XAccessible >& xAccessible
 287 ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
 288 {
 289     uno::Reference< accessibility::XAccessibleContext > xContext =
 290         xAccessible->getAccessibleContext();
 291
 292     if( xContext.is() )
 293         attachRecursive(xAccessible, xContext);
 294 }
 295
 296 /*****************************************************************************/
 297
 298 void DocumentFocusListener::attachRecursive(
 299     const uno::Reference< accessibility::XAccessible >& xAccessible,
 300     const uno::Reference< accessibility::XAccessibleContext >& xContext
 301 )  throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
 302 {
 303     uno::Reference< accessibility::XAccessibleStateSet > xStateSet =
 304         xContext->getAccessibleStateSet();
 305
 306     if( xStateSet.is() )
 307         attachRecursive(xAccessible, xContext, xStateSet);
 308 }
 309
 310 /*****************************************************************************/
 311
 312 void DocumentFocusListener::attachRecursive(
 313     const uno::Reference< accessibility::XAccessible >& xAccessible,
 314     const uno::Reference< accessibility::XAccessibleContext >& xContext,
 315     const uno::Reference< accessibility::XAccessibleStateSet >& xStateSet
 316 ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
 317 {
 318     if( xStateSet->contains(accessibility::AccessibleStateType::FOCUSED ) )
 319         atk_wrapper_focus_tracker_notify_when_idle( xAccessible );
 320
 321     uno::Reference< accessibility::XAccessibleEventBroadcaster > xBroadcaster =
 322         uno::Reference< accessibility::XAccessibleEventBroadcaster >(xContext, uno::UNO_QUERY);
 323
 324     // If not already done, add the broadcaster to the list and attach as listener.
 325     if( xBroadcaster.is() && m_aRefList.insert(xBroadcaster).second )
 326     {
 327         xBroadcaster->addEventListener(static_cast< accessibility::XAccessibleEventListener *>(this));
 328
 329         if( ! xStateSet->contains(accessibility::AccessibleStateType::MANAGES_DESCENDANTS ) )
 330         {
 331             sal_Int32 n, nmax = xContext->getAccessibleChildCount();
 332             for( n = 0; n < nmax; n++ )
 333             {
 334                 uno::Reference< accessibility::XAccessible > xChild( xContext->getAccessibleChild( n ) );
 335
 336                 if( xChild.is() )
 337                     attachRecursive(xChild);
 338             }
 339         }
 340     }
 341 }
 342
 343 /*****************************************************************************/
 344
 345 void DocumentFocusListener::detachRecursive(
 346     const uno::Reference< accessibility::XAccessible >& xAccessible
 347 ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
 348 {
 349     uno::Reference< accessibility::XAccessibleContext > xContext =
 350         xAccessible->getAccessibleContext();
 351
 352     if( xContext.is() )
 353         detachRecursive(xAccessible, xContext);
 354 }
 355
 356 /*****************************************************************************/
 357
 358 void DocumentFocusListener::detachRecursive(
 359     const uno::Reference< accessibility::XAccessible >& xAccessible,
 360     const uno::Reference< accessibility::XAccessibleContext >& xContext
 361 )  throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
 362 {
 363     uno::Reference< accessibility::XAccessibleStateSet > xStateSet =
 364         xContext->getAccessibleStateSet();
 365
 366     if( xStateSet.is() )
 367         detachRecursive(xAccessible, xContext, xStateSet);
 368 }
 369
 370 /*****************************************************************************/
 371
 372 void DocumentFocusListener::detachRecursive(
 373     const uno::Reference< accessibility::XAccessible >&,
 374     const uno::Reference< accessibility::XAccessibleContext >& xContext,
 375     const uno::Reference< accessibility::XAccessibleStateSet >& xStateSet
 376 ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
 377 {
 378     uno::Reference< accessibility::XAccessibleEventBroadcaster > xBroadcaster =
 379         uno::Reference< accessibility::XAccessibleEventBroadcaster >(xContext, uno::UNO_QUERY);
 380
 381     if( xBroadcaster.is() && 0 < m_aRefList.erase(xBroadcaster) )
 382     {
 383         xBroadcaster->removeEventListener(static_cast< accessibility::XAccessibleEventListener *>(this));
 384
 385         if( ! xStateSet->contains(accessibility::AccessibleStateType::MANAGES_DESCENDANTS ) )
 386         {
 387             sal_Int32 n, nmax = xContext->getAccessibleChildCount();
 388             for( n = 0; n < nmax; n++ )
 389             {
 390                 uno::Reference< accessibility::XAccessible > xChild( xContext->getAccessibleChild( n ) );
 391
 392                 if( xChild.is() )
 393                     detachRecursive(xChild);
 394             }
 395         }
 396     }
 397 }
 398
 399 /*****************************************************************************/
 400
 401 /*
 402  * page tabs in gtk are widgets, so we need to simulate focus events for those
 403  */
 404
 405 static void handle_tabpage_activated(Window *pWindow)
 406 {
 407     uno::Reference< accessibility::XAccessible > xAccessible =
 408         pWindow->GetAccessible();
 409
 410     if( ! xAccessible.is() )
 411         return;
 412
 413     uno::Reference< accessibility::XAccessibleSelection > xSelection(
 414         xAccessible->getAccessibleContext(), uno::UNO_QUERY);
 415
 416     if( xSelection.is() )
 417         atk_wrapper_focus_tracker_notify_when_idle( xSelection->getSelectedAccessibleChild(0) );
 418 }
 419
 420 /*****************************************************************************/
 421
 422 /*
 423  * toolbar items in gtk are widgets, so we need to simulate focus events for those
 424  */
 425
 426 static void notify_toolbox_item_focus(ToolBox *pToolBox)
 427 {
 428     uno::Reference< accessibility::XAccessible > xAccessible =
 429         pToolBox->GetAccessible();
 430
 431     if( ! xAccessible.is() )
 432         return;
 433
 434     uno::Reference< accessibility::XAccessibleContext > xContext =
 435         xAccessible->getAccessibleContext();
 436
 437     if( ! xContext.is() )
 438         return;
 439
 440     sal_Int32 nPos = pToolBox->GetItemPos( pToolBox->GetHighlightItemId() );
 441     if( nPos != TOOLBOX_ITEM_NOTFOUND )
 442         atk_wrapper_focus_tracker_notify_when_idle( xContext->getAccessibleChild( nPos ) );
 443 }
 444
 445 static void handle_toolbox_highlight(Window *pWindow)
 446 {
 447     ToolBox *pToolBox = static_cast <ToolBox *> (pWindow);
 448
 449     // Make sure either the toolbox or its parent toolbox has the focus
 450     if ( ! pToolBox->HasFocus() )
 451     {
 452         ToolBox* pToolBoxParent = dynamic_cast< ToolBox* >( pToolBox->GetParent() );
 453         if ( ! pToolBoxParent || ! pToolBoxParent->HasFocus() )
 454             return;
 455     }
 456
 457     notify_toolbox_item_focus(pToolBox);
 458 }
 459
 460 static void handle_toolbox_highlightoff(Window *pWindow)
 461 {
 462     ToolBox *pToolBox = static_cast <ToolBox *> (pWindow);
 463     ToolBox* pToolBoxParent = dynamic_cast< ToolBox* >( pToolBox->GetParent() );
 464
 465     // Notify when leaving sub toolboxes
 466     if( pToolBoxParent && pToolBoxParent->HasFocus() )
 467         notify_toolbox_item_focus( pToolBoxParent );
 468 }
 469
 470 /*****************************************************************************/
 471
 472 static void create_wrapper_for_child(
 473     const uno::Reference< accessibility::XAccessibleContext >& xContext,
 474     sal_Int32 index)
 475 {
 476     if( xContext.is() )
 477     {
 478         uno::Reference< accessibility::XAccessible > xChild(xContext->getAccessibleChild(index));
 479         if( xChild.is() )
 480         {
 481             // create the wrapper object - it will survive the unref unless it is a transient object
 482             g_object_unref( atk_object_wrapper_ref( xChild ) );
 483         }
 484     }
 485 }
 486
 487 /*****************************************************************************/
 488
 489 static void handle_toolbox_buttonchange(VclWindowEvent const *pEvent)
 490 {
 491     Window* pWindow = pEvent->GetWindow();
 492     sal_Int32 index = (sal_Int32)(sal_IntPtr) pEvent->GetData();
 493
 494     if( pWindow && pWindow->IsReallyVisible() )
 495     {
 496         uno::Reference< accessibility::XAccessible > xAccessible(pWindow->GetAccessible());
 497         if( xAccessible.is() )
 498         {
 499             create_wrapper_for_child(xAccessible->getAccessibleContext(), index);
 500         }
 501     }
 502 }
 503
 504 /*****************************************************************************/
 505
 506 static void create_wrapper_for_children(Window *pWindow)
 507 {
 508     if( pWindow && pWindow->IsReallyVisible() )
 509     {
 510         uno::Reference< accessibility::XAccessible > xAccessible(pWindow->GetAccessible());
 511         if( xAccessible.is() )
 512         {
 513             uno::Reference< accessibility::XAccessibleContext > xContext(xAccessible->getAccessibleContext());
 514             if( xContext.is() )
 515             {
 516                 sal_Int32 nChildren = xContext->getAccessibleChildCount();
 517                 for( sal_Int32 i = 0; i < nChildren; ++i )
 518                     create_wrapper_for_child(xContext, i);
 519             }
 520         }
 521     }
 522 }
 523
 524 /*****************************************************************************/
 525
 526 static std::set< Window * > g_aWindowList;
 527
 528 static void handle_get_focus(::VclWindowEvent const * pEvent)
 529 {
 530     static rtl::Reference< DocumentFocusListener > aDocumentFocusListener =
 531         new DocumentFocusListener();
 532
 533     Window *pWindow = pEvent->GetWindow();
 534
 535     // The menu bar is handled through VCLEVENT_MENU_HIGHLIGHTED
 536     if( ! pWindow || !pWindow->IsReallyVisible() || pWindow->GetType() == WINDOW_MENUBARWINDOW )
 537         return;
 538
 539     // ToolBoxes are handled through VCLEVENT_TOOLBOX_HIGHLIGHT
 540     if( pWindow->GetType() == WINDOW_TOOLBOX )
 541         return;
 542
 543     if( pWindow->GetType() == WINDOW_TABCONTROL )
 544     {
 545         handle_tabpage_activated( pWindow );
 546         return;
 547     }
 548
 549     uno::Reference< accessibility::XAccessible > xAccessible =
 550         pWindow->GetAccessible();
 551
 552     if( ! xAccessible.is() )
 553         return;
 554
 555     uno::Reference< accessibility::XAccessibleContext > xContext =
 556         xAccessible->getAccessibleContext();
 557
 558     if( ! xContext.is() )
 559         return;
 560
 561     uno::Reference< accessibility::XAccessibleStateSet > xStateSet =
 562         xContext->getAccessibleStateSet();
 563
 564     if( ! xStateSet.is() )
 565         return;
 566
 567 /* the UNO ToolBox wrapper does not (yet?) support XAccessibleSelection, so we
 568  * need to add listeners to the children instead of re-using the tabpage stuff
 569  */
 570     if( xStateSet->contains(accessibility::AccessibleStateType::FOCUSED) &&
 571         ( pWindow->GetType() != WINDOW_TREELISTBOX ) )
 572     {
 573         atk_wrapper_focus_tracker_notify_when_idle( xAccessible );
 574     }
 575     else
 576     {
 577         if( g_aWindowList.find(pWindow) == g_aWindowList.end() )
 578         {
 579             g_aWindowList.insert(pWindow);
 580             aDocumentFocusListener->attachRecursive(xAccessible, xContext, xStateSet);
 581         }
 582 #ifdef ENABLE_TRACING
 583         else
 584             fprintf(stderr, "Window %p already in the list\n", pWindow );
 585 #endif
 586     }
 587 }
 588
 589 /*****************************************************************************/
 590
 591 static void handle_menu_highlighted(::VclMenuEvent const * pEvent)
 592 {
 593     try
 594     {
 595         Menu* pMenu = pEvent->GetMenu();
 596         USHORT nPos = pEvent->GetItemPos();
 597
 598         if( pMenu &&  nPos != 0xFFFF)
 599         {
 600             uno::Reference< accessibility::XAccessible > xAccessible ( pMenu->GetAccessible() );
 601
 602             if( xAccessible.is() )
 603             {
 604                 uno::Reference< accessibility::XAccessibleContext > xContext ( xAccessible->getAccessibleContext() );
 605
 606                 if( xContext.is() )
 607                     atk_wrapper_focus_tracker_notify_when_idle( xContext->getAccessibleChild( nPos ) );
 608             }
 609         }
 610     }
 611     catch( uno::Exception e )
 612     {
 613         g_warning( "Exception caught processing menu highlight events" );
 614     }
 615 }
 616
 617 /*****************************************************************************/
 618
 619 long WindowEventHandler(void *, ::VclSimpleEvent const * pEvent)
 620 {
 621     try {
 622     switch (pEvent->GetId())
 623     {
 624     case VCLEVENT_WINDOW_SHOW:
 625 //        fprintf(stderr, "got VCLEVENT_WINDOW_SHOW for %p\n",
 626 //            static_cast< ::VclWindowEvent const * >(pEvent)->GetWindow());
 627         break;
 628     case VCLEVENT_WINDOW_HIDE:
 629 //        fprintf(stderr, "got VCLEVENT_WINDOW_HIDE for %p\n",
 630 //            static_cast< ::VclWindowEvent const * >(pEvent)->GetWindow());
 631         break;
 632     case VCLEVENT_WINDOW_CLOSE:
 633 //        fprintf(stderr, "got VCLEVENT_WINDOW_CLOSE for %p\n",
 634 //            static_cast< ::VclWindowEvent const * >(pEvent)->GetWindow());
 635         break;
 636     case VCLEVENT_WINDOW_GETFOCUS:
 637         handle_get_focus(static_cast< ::VclWindowEvent const * >(pEvent));
 638         break;
 639     case VCLEVENT_WINDOW_LOSEFOCUS:
 640 //        fprintf(stderr, "got VCLEVENT_WINDOW_LOSEFOCUS for %p\n",
 641 //            static_cast< ::VclWindowEvent const * >(pEvent)->GetWindow());
 642         break;
 643     case VCLEVENT_WINDOW_MINIMIZE:
 644 //        fprintf(stderr, "got VCLEVENT_WINDOW_MINIMIZE for %p\n",
 645 //            static_cast< ::VclWindowEvent const * >(pEvent)->GetWindow());
 646         break;
 647     case VCLEVENT_WINDOW_NORMALIZE:
 648 //        fprintf(stderr, "got VCLEVENT_WINDOW_NORMALIZE for %p\n",
 649 //            static_cast< ::VclWindowEvent const * >(pEvent)->GetWindow());
 650         break;
 651     case VCLEVENT_WINDOW_KEYINPUT:
 652     case VCLEVENT_WINDOW_KEYUP:
 653     case VCLEVENT_WINDOW_COMMAND:
 654     case VCLEVENT_WINDOW_MOUSEMOVE:
 655         break;
 656  /*
 657         fprintf(stderr, "got VCLEVENT_WINDOW_COMMAND (%d) for %p\n",
 658             static_cast< ::CommandEvent const * > (
 659                 static_cast< ::VclWindowEvent const * >(pEvent)->GetData())->GetCommand(),
 660             static_cast< ::VclWindowEvent const * >(pEvent)->GetWindow());
 661  */
 662     case VCLEVENT_MENU_HIGHLIGHT:
 663         if (const VclMenuEvent* pMenuEvent = dynamic_cast<const VclMenuEvent*>(pEvent))
 664         {
 665             handle_menu_highlighted(pMenuEvent);
 666         }
 667         else if (const VclAccessibleEvent* pAccEvent = dynamic_cast<const VclAccessibleEvent*>(pEvent))
 668         {
 669             uno::Reference< accessibility::XAccessible > xAccessible = pAccEvent->GetAccessible();
 670             if (xAccessible.is())
 671                 atk_wrapper_focus_tracker_notify_when_idle(xAccessible);
 672         }
 673         break;
 674
 675     case VCLEVENT_TOOLBOX_HIGHLIGHT:
 676         handle_toolbox_highlight(static_cast< ::VclWindowEvent const * >(pEvent)->GetWindow());
 677         break;
 678
 679     case VCLEVENT_TOOLBOX_BUTTONSTATECHANGED:
 680         handle_toolbox_buttonchange(static_cast< ::VclWindowEvent const * >(pEvent));
 681         break;
 682
 683     case VCLEVENT_OBJECT_DYING:
 684         g_aWindowList.erase( static_cast< ::VclWindowEvent const * >(pEvent)->GetWindow() );
 685         // fallthrough intentional !
 686     case VCLEVENT_TOOLBOX_HIGHLIGHTOFF:
 687         handle_toolbox_highlightoff(static_cast< ::VclWindowEvent const * >(pEvent)->GetWindow());
 688         break;
 689
 690     case VCLEVENT_TABPAGE_ACTIVATE:
 691         handle_tabpage_activated(static_cast< ::VclWindowEvent const * >(pEvent)->GetWindow());
 692         break;
 693
 694     case VCLEVENT_COMBOBOX_SETTEXT:
 695         create_wrapper_for_children(static_cast< ::VclWindowEvent const * >(pEvent)->GetWindow());
 696         break;
 697
 698     default:
 699 //        OSL_TRACE("got event %d \n", pEvent->GetId());
 700         break;
 701     }
 702     } catch(lang::IndexOutOfBoundsException e)
 703     {
 704         g_warning("Focused object has invalid index in parent");
 705     }
 706     return 0;
 707 }
 708
 709 static Link g_aEventListenerLink( NULL, (PSTUB) WindowEventHandler );
 710
 711 /*****************************************************************************/
 712
 713 extern "C" {
 714
 715 static G_CONST_RETURN gchar *
 716 ooo_atk_util_get_toolkit_name (void)
 717 {
 718     return "VCL";
 719 }
 720
 721 /*****************************************************************************/
 722
 723 static G_CONST_RETURN gchar *
 724 ooo_atk_util_get_toolkit_version (void)
 725 {
 726     /*
 727      * Version is passed in as a -D flag when this file is
 728      * compiled.
 729      */
 730
 731     return VERSION;
 732 }
 733
 734 /*****************************************************************************/
 735
 736 /*
 737  * GObject inheritance
 738  */
 739
 740 static void
 741 ooo_atk_util_class_init (AtkUtilClass *)
 742 {
 743     AtkUtilClass *atk_class;
 744     gpointer data;
 745
 746     data = g_type_class_peek (ATK_TYPE_UTIL);
 747     atk_class = ATK_UTIL_CLASS (data);
 748
 749     atk_class->get_toolkit_name = ooo_atk_util_get_toolkit_name;
 750     atk_class->get_toolkit_version = ooo_atk_util_get_toolkit_version;
 751
 752     Application::AddEventListener( g_aEventListenerLink );
 753 }
 754
 755 } // extern "C"
 756
 757 /*****************************************************************************/
 758
 759 GType
 760 ooo_atk_util_get_type (void)
 761 {
 762     static GType type = 0;
 763
 764     if (!type)
 765     {
 766         GType parent_type = g_type_from_name( "GailUtil" );
 767
 768         if( ! parent_type )
 769         {
 770             g_warning( "Unknown type: GailUtil" );
 771             parent_type = ATK_TYPE_UTIL;
 772         }
 773
 774         GTypeQuery type_query;
 775         g_type_query( parent_type, &type_query );
 776
 777         static const GTypeInfo typeInfo =
 778         {
 779             type_query.class_size,
 780             (GBaseInitFunc) NULL,
 781             (GBaseFinalizeFunc) NULL,
 782             (GClassInitFunc) ooo_atk_util_class_init,
 783             (GClassFinalizeFunc) NULL,
 784             NULL,
 785             type_query.instance_size,
 786             0,
 787             (GInstanceInitFunc) NULL,
 788             NULL
 789         } ;
 790
 791         type = g_type_register_static (parent_type, "OOoUtil", &typeInfo, (GTypeFlags)0) ;
 792   }
 793
 794   return type;
 795 }
 796
 797