svx/source/accessibility/svxpixelctlaccessiblecontext.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <com/sun/star/accessibility/AccessibleRole.hpp>
  21 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  22 #include <unotools/accessiblestatesethelper.hxx>
  23 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  24 #include <com/sun/star/beans/PropertyChangeEvent.hpp>
  25 #include <com/sun/star/awt/XWindow.hpp>
  26 #include <cppuhelper/supportsservice.hxx>
  27 #include <cppuhelper/typeprovider.hxx>
  28 #include <toolkit/helper/vclunohelper.hxx>
  29 #include <toolkit/helper/convert.hxx>
  30 #include <vcl/svapp.hxx>
  31 #include <vcl/settings.hxx>
  32 #include <osl/mutex.hxx>
  33 #include <rtl/uuid.h>
  34 #include <tools/debug.hxx>
  35 #include <tools/gen.hxx>
  36
  37 #include <svx/dialogs.hrc>
  38 #include "accessibility.hrc"
  39 #include <svx/dlgctrl.hxx>
  40
  41 #include <svx/dialmgr.hxx>
  42 #include <comphelper/accessibleeventnotifier.hxx>
  43
  44 #include <unotools/accessiblerelationsethelper.hxx>
  45
  46 #include "svxpixelctlaccessiblecontext.hxx"
  47 #include <com/sun/star/accessibility/AccessibleRelationType.hpp>
  48
  49 using namespace ::cppu;
  50 using namespace ::osl;
  51 using namespace ::rtl;
  52 using namespace ::com::sun::star;
  53 using namespace ::com::sun::star::uno;
  54 using namespace ::com::sun::star::accessibility;
  55
  56 SvxPixelCtlAccessible::SvxPixelCtlAccessible( SvxPixelCtl& rControl) :
  57     SvxPixelCtlAccessible_BASE(m_aMutex),
  58     mrPixelCtl(rControl),
  59     mnClientId(0)
  60 {
  61 }
  62
  63 SvxPixelCtlAccessible::~SvxPixelCtlAccessible()
  64 {
  65     if( IsAlive() )
  66     {
  67         osl_atomic_increment( &m_refCount );
  68         dispose();      // set mpRepr = NULL & release all childs
  69     }
  70 }
  71 /*-- 04.02.2002 14:11:55---------------------------------------------------
  72
  73   -----------------------------------------------------------------------*/
  74 uno::Reference< XAccessibleContext > SvxPixelCtlAccessible::getAccessibleContext(  )
  75     throw (uno::RuntimeException, std::exception)
  76 {
  77     return this;
  78 }
  79
  80 sal_Int32 SvxPixelCtlAccessible::getAccessibleChildCount(  ) throw (uno::RuntimeException, std::exception)
  81 {
  82     ::osl::MutexGuard   aGuard( m_aMutex );
  83     return mrPixelCtl.GetSquares();
  84 }
  85 /*-- 04.02.2002 14:11:56---------------------------------------------------
  86
  87   -----------------------------------------------------------------------*/
  88 uno::Reference< XAccessible > SvxPixelCtlAccessible::getAccessibleChild( sal_Int32 i )
  89     throw (lang::IndexOutOfBoundsException, uno::RuntimeException, std::exception)
  90 {
  91     ::osl::MutexGuard   aGuard( m_aMutex );
  92     if ( i < 0 || i >= getAccessibleChildCount())
  93         throw lang::IndexOutOfBoundsException();
  94     uno::Reference <XAccessible> xAcc;
  95     return CreateChild(i, mrPixelCtl.IndexToPoint(i));
  96 }
  97
  98
  99
 100 uno::Reference< XAccessible > SvxPixelCtlAccessible::getAccessibleParent(  )
 101     throw (uno::RuntimeException, std::exception)
 102 {
 103     ::osl::MutexGuard   aGuard( m_aMutex );
 104     Window *pTabPage = getNonLayoutParent(&mrPixelCtl);
 105     assert(pTabPage && WINDOW_TABPAGE == pTabPage->GetType());
 106     return pTabPage->GetAccessible( true );
 107 }
 108
 109 sal_Int32 SvxPixelCtlAccessible::getAccessibleIndexInParent(  )
 110     throw (uno::RuntimeException, std::exception)
 111 {
 112     ::osl::MutexGuard   aGuard( m_aMutex );
 113     sal_uInt16 nIdx = 0;
 114     Window *pTabPage = getNonLayoutParent(&mrPixelCtl);
 115     assert(pTabPage && WINDOW_TABPAGE == pTabPage->GetType());
 116     sal_uInt16 nChildren = pTabPage->GetChildCount();
 117     for(nIdx = 0; nIdx < nChildren; nIdx++)
 118         if(pTabPage->GetChild( nIdx ) == &mrPixelCtl)
 119             break;
 120     return nIdx;
 121 }
 122 /*-- 04.02.2002 14:11:57---------------------------------------------------
 123
 124   -----------------------------------------------------------------------*/
 125 sal_Int16 SvxPixelCtlAccessible::getAccessibleRole(  ) throw (uno::RuntimeException, std::exception)
 126 {
 127     return AccessibleRole::LIST;
 128 }
 129
 130 OUString SvxPixelCtlAccessible::getAccessibleDescription(  )
 131     throw (uno::RuntimeException, std::exception)
 132 {
 133
 134     ::osl::MutexGuard   aGuard( m_aMutex );
 135     return mrPixelCtl.GetAccessibleDescription();
 136 }
 137
 138 OUString SvxPixelCtlAccessible::getAccessibleName(  )
 139     throw (uno::RuntimeException, std::exception)
 140 {
 141
 142     ::osl::MutexGuard   aGuard( m_aMutex );
 143     return mrPixelCtl.GetAccessibleName();
 144 }
 145
 146 uno::Reference< XAccessibleRelationSet > SvxPixelCtlAccessible::getAccessibleRelationSet(  )
 147     throw (uno::RuntimeException, std::exception)
 148 {
 149     ::osl::MutexGuard   aGuard( m_aMutex );
 150     utl::AccessibleRelationSetHelper* rRelationSet = new utl::AccessibleRelationSetHelper;
 151     uno::Reference< css::accessibility::XAccessibleRelationSet > rSet = rRelationSet;
 152     Window *pLabeledBy = mrPixelCtl.GetAccessibleRelationLabeledBy();
 153     if ( pLabeledBy && pLabeledBy != &mrPixelCtl )
 154     {
 155         uno::Sequence< uno::Reference< uno::XInterface > > aSequence(1);
 156         aSequence[0] = pLabeledBy->GetAccessible();
 157         rRelationSet->AddRelation( css::accessibility::AccessibleRelation( css::accessibility::AccessibleRelationType::LABELED_BY, aSequence ) );
 158     }
 159
 160     Window* pMemberOf = mrPixelCtl.GetAccessibleRelationMemberOf();
 161     if ( pMemberOf && pMemberOf != &mrPixelCtl )
 162     {
 163         uno::Sequence< uno::Reference< uno::XInterface > > aSequence(1);
 164         aSequence[0] = pMemberOf->GetAccessible();
 165         rRelationSet->AddRelation( css::accessibility::AccessibleRelation( css::accessibility::AccessibleRelationType::MEMBER_OF, aSequence ) );
 166     }
 167     return rSet;
 168 }
 169
 170
 171 uno::Reference< XAccessibleStateSet > SvxPixelCtlAccessible::getAccessibleStateSet(  )
 172     throw (uno::RuntimeException, std::exception)
 173 {
 174     ::osl::MutexGuard   aGuard( m_aMutex );
 175     utl::AccessibleStateSetHelper* pStateSetHelper = new utl::AccessibleStateSetHelper;
 176     uno::Reference< XAccessibleStateSet > xRet = pStateSetHelper;
 177
 178     const sal_Int16 aStandardStates[] =
 179     {
 180         AccessibleStateType::FOCUSABLE,
 181         AccessibleStateType::SELECTABLE,
 182         AccessibleStateType::SHOWING,
 183         AccessibleStateType::VISIBLE,
 184         AccessibleStateType::OPAQUE,
 185         0
 186     };
 187
 188     sal_Int16 nState = 0;
 189     while(aStandardStates[nState])
 190     {
 191         pStateSetHelper->AddState(aStandardStates[nState++]);
 192     }
 193     if(mrPixelCtl.IsEnabled())
 194         pStateSetHelper->AddState(AccessibleStateType::ENABLED);
 195     if(mrPixelCtl.HasFocus())
 196         pStateSetHelper->AddState(AccessibleStateType::FOCUSED);
 197     pStateSetHelper->AddState(AccessibleStateType::MANAGES_DESCENDANTS);
 198
 199     return xRet;
 200 }
 201
 202
 203 com::sun::star::lang::Locale SvxPixelCtlAccessible::getLocale(  )
 204     throw (IllegalAccessibleComponentStateException, uno::RuntimeException, std::exception)
 205 {
 206     ::osl::MutexGuard   aGuard( m_aMutex );
 207     if( getAccessibleParent().is() )
 208     {
 209         uno::Reference< XAccessibleContext >        xParentContext( getAccessibleParent()->getAccessibleContext() );
 210         if( xParentContext.is() )
 211             return xParentContext->getLocale();
 212     }
 213
 214     //  No locale and no parent.  Therefore throw exception to indicate this
 215     //  cluelessness.
 216     throw IllegalAccessibleComponentStateException();
 217 }
 218
 219
 220 sal_Bool SvxPixelCtlAccessible::containsPoint( const awt::Point& aPt )
 221     throw (uno::RuntimeException, std::exception)
 222 {
 223     ::osl::MutexGuard   aGuard( m_aMutex );
 224     Point aPoint(aPt.X, aPt.Y);
 225     return (aPoint.X() >= 0)
 226         && (aPoint.X() < mrPixelCtl.GetSizePixel().getWidth())
 227         && (aPoint.Y() >= 0)
 228         && (aPoint.Y() < mrPixelCtl.GetSizePixel().getHeight());
 229 }
 230 uno::Reference<XAccessible > SAL_CALL SvxPixelCtlAccessible::getAccessibleAtPoint (
 231         const awt::Point& aPoint)
 232     throw (uno::RuntimeException, std::exception)
 233 {
 234     ::osl::MutexGuard   aGuard( m_aMutex );
 235     ensureIsAlive();
 236     uno::Reference <XAccessible> xAcc;
 237
 238     Point childPoint;
 239     childPoint.X() = aPoint.X;
 240     childPoint.Y() = aPoint.Y;
 241
 242     Point pt= mrPixelCtl.PixelToLogic(childPoint);
 243     long nIndex = mrPixelCtl.PointToIndex(pt);
 244     return CreateChild(nIndex, mrPixelCtl.IndexToPoint(nIndex));
 245 }
 246
 247 awt::Rectangle SvxPixelCtlAccessible::getBounds(  ) throw (uno::RuntimeException, std::exception)
 248 {
 249     ::osl::MutexGuard   aGuard( m_aMutex );
 250     awt::Rectangle aRet;
 251     Size aSz = mrPixelCtl.GetSizePixel();
 252     Point aPos = mrPixelCtl.GetPosPixel();
 253     aRet.X = aPos.X();
 254     aRet.Y = aPos.Y();
 255     aRet.Width = aSz.Width();
 256     aRet.Height = aSz.Height();
 257     return aRet;
 258 }
 259
 260 awt::Point SvxPixelCtlAccessible::getLocation(  ) throw (uno::RuntimeException, std::exception)
 261 {
 262     ::osl::MutexGuard   aGuard( m_aMutex );
 263     Point aPos;
 264     aPos = mrPixelCtl.GetPosPixel();
 265     awt::Point aRet(aPos.X(), aPos.Y());
 266     return aRet;
 267 }
 268
 269 awt::Point SvxPixelCtlAccessible::getLocationOnScreen(  ) throw (uno::RuntimeException, std::exception)
 270 {
 271     ::osl::MutexGuard   aGuard( m_aMutex );
 272     Rectangle rect = mrPixelCtl.GetWindowExtentsRelative(NULL);
 273     return awt::Point(rect.Left(),rect.Top() );
 274 }
 275
 276 awt::Size SvxPixelCtlAccessible::getSize(  ) throw (uno::RuntimeException, std::exception)
 277 {
 278     ::osl::MutexGuard   aGuard( m_aMutex );
 279     Size aSz = mrPixelCtl.GetSizePixel();
 280     return awt::Size(aSz.Width(),aSz.Height());
 281 }
 282 void SvxPixelCtlAccessible::grabFocus(  ) throw (uno::RuntimeException, std::exception)
 283 {
 284     ::osl::MutexGuard   aGuard( m_aMutex );
 285     mrPixelCtl.GrabFocus();
 286 }
 287
 288 sal_Int32 SvxPixelCtlAccessible::getForeground(  )
 289         throw (::com::sun::star::uno::RuntimeException, std::exception)
 290 {
 291     ::osl::MutexGuard   aGuard( m_aMutex );
 292     return mrPixelCtl.GetControlForeground().GetColor();
 293 }
 294
 295 sal_Int32 SvxPixelCtlAccessible::getBackground(  )
 296         throw (::com::sun::star::uno::RuntimeException, std::exception)
 297 {
 298     ::osl::MutexGuard   aGuard( m_aMutex );
 299     return mrPixelCtl.GetControlBackground().GetColor();
 300 }
 301
 302 OUString SvxPixelCtlAccessible::getImplementationName(  ) throw (uno::RuntimeException, std::exception)
 303 {
 304     return OUString("SvxPixelCtlAccessible");
 305 }
 306
 307 sal_Bool SvxPixelCtlAccessible::supportsService( const OUString& rServiceName )
 308     throw (uno::RuntimeException, std::exception)
 309 {
 310     return cppu::supportsService( this, rServiceName );
 311 }
 312
 313 uno::Sequence< OUString > SvxPixelCtlAccessible::getSupportedServiceNames(  )
 314     throw (uno::RuntimeException, std::exception)
 315 {
 316     uno::Sequence< OUString > aRet(2);
 317     OUString* pArray = aRet.getArray();
 318     pArray[0] = "Accessible";
 319     pArray[1] = "AccessibleContext";
 320     pArray[2] = "AccessibleComponent";
 321     return aRet;
 322 }
 323
 324
 325 // XAccessibleSelection
 326
 327 void SAL_CALL SvxPixelCtlAccessible::selectAccessibleChild( sal_Int32 nChildIndex ) throw (lang::IndexOutOfBoundsException, RuntimeException, std::exception)
 328 {
 329     ::osl::MutexGuard   aGuard( m_aMutex );
 330
 331     if ( nChildIndex < 0 || nChildIndex >= getAccessibleChildCount())
 332         throw lang::IndexOutOfBoundsException();
 333
 334     long nIndex = mrPixelCtl.ShowPosition(mrPixelCtl.IndexToPoint(nChildIndex));
 335     NotifyChild(nIndex,true,false);
 336 }
 337
 338 sal_Bool SAL_CALL SvxPixelCtlAccessible::isAccessibleChildSelected( sal_Int32 nChildIndex ) throw (lang::IndexOutOfBoundsException, RuntimeException, std::exception)
 339 {
 340     ::osl::MutexGuard   aGuard( m_aMutex );
 341
 342     return mrPixelCtl.GetFoucsPosIndex() == nChildIndex;
 343 }
 344
 345 void SAL_CALL SvxPixelCtlAccessible::clearAccessibleSelection(  ) throw (RuntimeException, std::exception)
 346 {
 347 }
 348
 349 void SAL_CALL SvxPixelCtlAccessible::selectAllAccessibleChildren(  ) throw (RuntimeException, std::exception)
 350 {
 351 }
 352
 353 sal_Int32 SAL_CALL SvxPixelCtlAccessible::getSelectedAccessibleChildCount(  ) throw (RuntimeException, std::exception)
 354 {
 355     return 1;
 356 }
 357
 358 uno::Reference< XAccessible > SAL_CALL SvxPixelCtlAccessible::getSelectedAccessibleChild( sal_Int32 nSelectedChildIndex ) throw (lang::IndexOutOfBoundsException, RuntimeException, std::exception)
 359 {
 360     ::osl::MutexGuard   aGuard( m_aMutex );
 361
 362     if ( nSelectedChildIndex >= 1)
 363         throw lang::IndexOutOfBoundsException();
 364
 365     uno::Reference< XAccessible > xChild;
 366     if(m_xCurChild.is())
 367     {
 368         xChild = m_xCurChild;
 369     }
 370     return xChild;
 371 }
 372
 373 void SAL_CALL SvxPixelCtlAccessible::deselectAccessibleChild( sal_Int32 ) throw (lang::IndexOutOfBoundsException, RuntimeException, std::exception)
 374 {
 375 }
 376
 377 // Added by lq
 378 void SvxPixelCtlAccessible::ensureIsAlive() const
 379     throw ( lang::DisposedException )
 380 {
 381     if( !IsAlive() )
 382         throw lang::DisposedException();
 383 }
 384
 385 //XAccessibleEventBroadcaster
 386 void SAL_CALL SvxPixelCtlAccessible::addAccessibleEventListener( const uno::Reference< XAccessibleEventListener >& xListener )  throw( RuntimeException, std::exception )
 387 {
 388     if (xListener.is())
 389     {
 390         ::osl::MutexGuard   aGuard( m_aMutex );
 391         if (!mnClientId)
 392                 mnClientId = comphelper::AccessibleEventNotifier::registerClient( );
 393         comphelper::AccessibleEventNotifier::addEventListener( mnClientId, xListener );
 394     }
 395 }
 396
 397 void SAL_CALL SvxPixelCtlAccessible::removeAccessibleEventListener( const uno::Reference< XAccessibleEventListener >& xListener )
 398     throw( RuntimeException, std::exception )
 399 {
 400     if (xListener.is())
 401     {
 402         ::osl::MutexGuard   aGuard( m_aMutex );
 403
 404         sal_Int32 nListenerCount = comphelper::AccessibleEventNotifier::removeEventListener( mnClientId, xListener );
 405         if ( !nListenerCount )
 406         {
 407             comphelper::AccessibleEventNotifier::revokeClient( mnClientId );
 408             mnClientId = 0;
 409         }
 410     }
 411 }
 412 void SvxPixelCtlAccessible::CommitChange( const AccessibleEventObject& rEvent )
 413 {
 414     if (mnClientId)
 415         comphelper::AccessibleEventNotifier::addEvent( mnClientId, rEvent );
 416 }
 417
 418 //Solution:Add the event handling method
 419 void SvxPixelCtlAccessible::FireAccessibleEvent (short nEventId, const ::com::sun::star::uno::Any& rOld, const ::com::sun::star::uno::Any& rNew)
 420 {
 421     const uno::Reference< XInterface >  xSource( *this );
 422     CommitChange( AccessibleEventObject( xSource, nEventId, rNew,rOld ) );
 423 }
 424
 425 void SAL_CALL SvxPixelCtlAccessible::disposing()
 426 {
 427     if( !rBHelper.bDisposed )
 428     {
 429         {
 430             ::osl::MutexGuard   aGuard( m_aMutex );
 431             if ( mnClientId )
 432             {
 433                 comphelper::AccessibleEventNotifier::revokeClientNotifyDisposing( mnClientId, *this );
 434                 mnClientId =  0;
 435             }
 436         }
 437         //mxParent = uno::Reference< XAccessible >();
 438
 439     }
 440 }
 441
 442 void SvxPixelCtlAccessible::NotifyChild(long nIndex,bool bSelect ,bool bCheck)
 443 {
 444     DBG_ASSERT( !(!bSelect && !bCheck),"" );//non is false
 445
 446     SvxPixelCtlAccessibleChild *pChild= NULL;
 447
 448     if (m_xCurChild.is())
 449     {
 450         pChild= static_cast<SvxPixelCtlAccessibleChild*>(m_xCurChild.get());
 451         DBG_ASSERT(pChild,"Child Must be Valid");
 452         if (pChild->getAccessibleIndexInParent() == nIndex )
 453         {
 454             if (bSelect)
 455             {
 456                 pChild->SelectChild(true);
 457             }
 458             if (bCheck)
 459             {
 460                 pChild->ChangePixelColorOrBG( mrPixelCtl.GetBitmapPixel(sal_uInt16(nIndex)) != 0);
 461                 pChild->CheckChild();
 462             }
 463             return ;
 464         }
 465     }
 466     uno::Reference <XAccessible> xNewChild =CreateChild(nIndex, mrPixelCtl.IndexToPoint(nIndex));
 467     SvxPixelCtlAccessibleChild *pNewChild= static_cast<SvxPixelCtlAccessibleChild*>(xNewChild.get());
 468     DBG_ASSERT(pNewChild,"Child Must be Valid");
 469
 470     Any aNewValue,aOldValue;
 471     aNewValue<<= xNewChild;
 472     FireAccessibleEvent(    AccessibleEventId::ACTIVE_DESCENDANT_CHANGED,
 473                             aOldValue,
 474                             aNewValue );
 475
 476     if (bSelect)
 477     {
 478         if (pChild)
 479         {
 480             pChild->SelectChild(false);
 481         }
 482         pNewChild->SelectChild(true);
 483     }
 484     if (bCheck)
 485     {
 486         pNewChild->CheckChild();
 487     }
 488     m_xCurChild= xNewChild;
 489
 490
 491 }
 492
 493 uno::Reference<XAccessible> SvxPixelCtlAccessible::CreateChild (long nIndex,Point mPoint)
 494 {
 495     long nX = mPoint.X();
 496     long nY = mPoint.Y();
 497     if( Application::GetSettings().GetLayoutRTL())
 498     {
 499         nX = (sal_uInt16) mrPixelCtl.GetWidth() - 1 - nX;
 500     }
 501
 502     bool bPixelColorOrBG = mrPixelCtl.GetBitmapPixel(sal_uInt16(nIndex)) != 0;
 503     Size size(mrPixelCtl.GetWidth() / mrPixelCtl.GetLineCount(),mrPixelCtl.GetHeight() / mrPixelCtl.GetLineCount());
 504     uno::Reference<XAccessible> xChild;
 505     xChild = new SvxPixelCtlAccessibleChild(mrPixelCtl,
 506                 bPixelColorOrBG,
 507                 Point(nX,nY),
 508                 Rectangle(mPoint,size),
 509                 this,
 510                 nIndex);
 511
 512     return xChild;
 513 }
 514
 515
 516 void SvxPixelCtlAccessible::LoseFocus()
 517 {
 518     m_xCurChild = uno::Reference< XAccessible >() ;
 519 }
 520
 521 void SvxPixelCtlAccessibleChild::CheckChild()
 522 {
 523     Any aChecked;
 524     aChecked <<= AccessibleStateType::CHECKED;
 525
 526     if (m_bPixelColorOrBG)//Current Child State
 527     {
 528         FireAccessibleEvent(    AccessibleEventId::STATE_CHANGED,
 529                                 Any(),
 530                                 aChecked);
 531     }
 532     else
 533     {
 534         FireAccessibleEvent(    AccessibleEventId::STATE_CHANGED,
 535                                 aChecked,
 536                                 Any() );
 537     }
 538 }
 539
 540 void SvxPixelCtlAccessibleChild::SelectChild( bool bSelect)
 541 {
 542     Any aSelected;
 543     aSelected <<= AccessibleStateType::SELECTED;
 544
 545     if (bSelect)
 546     {
 547         FireAccessibleEvent(    AccessibleEventId::STATE_CHANGED,
 548                                 Any(),
 549                                 aSelected);
 550     }
 551     else
 552     {
 553         FireAccessibleEvent(    AccessibleEventId::STATE_CHANGED,
 554                                 aSelected,
 555                                 Any());
 556     }
 557 }
 558 void SvxPixelCtlAccessibleChild::FireAccessibleEvent (
 559     short nEventId,
 560     const ::com::sun::star::uno::Any& rOld,
 561     const ::com::sun::star::uno::Any& rNew)
 562 {
 563     const uno::Reference< XInterface >  xSource( *this );
 564     CommitChange( AccessibleEventObject( xSource, nEventId, rNew,rOld ) );
 565 }
 566
 567 SvxPixelCtlAccessibleChild::SvxPixelCtlAccessibleChild(
 568     SvxPixelCtl& rWindow,
 569     bool bPixelColorOrBG,
 570     const Point &aPoint,
 571     const Rectangle& rBoundingBox,
 572     const uno::Reference<XAccessible>&  rxParent,
 573     long nIndexInParent ) :
 574     SvxPixelCtlAccessibleChild_BASE( m_aMutex ),
 575     mrParentWindow( rWindow ),
 576     mxParent(rxParent),
 577     m_bPixelColorOrBG(bPixelColorOrBG),
 578     maPoint(aPoint),
 579     mpBoundingBox( new Rectangle( rBoundingBox ) ),
 580     mnIndexInParent( nIndexInParent ),
 581     mnClientId( 0 )
 582 {
 583 }
 584
 585
 586 SvxPixelCtlAccessibleChild::~SvxPixelCtlAccessibleChild()
 587 {
 588     if( IsAlive() )
 589     {
 590         osl_atomic_increment( &m_refCount );
 591         dispose();      // set mpRepr = NULL & release all childs
 592     }
 593 }
 594
 595 //=====  XAccessible  =========================================================
 596
 597 uno::Reference< XAccessibleContext> SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleContext( void ) throw( RuntimeException, std::exception )
 598 {
 599     return this;
 600 }
 601
 602 //=====  XAccessibleComponent  ================================================
 603
 604 sal_Bool SAL_CALL SvxPixelCtlAccessibleChild::containsPoint( const awt::Point& rPoint ) throw( RuntimeException, std::exception )
 605 {
 606     // no guard -> done in getBounds()
 607 //  return GetBoundingBox().IsInside( VCLPoint( rPoint ) );
 608     return Rectangle( Point( 0, 0 ), GetBoundingBox().GetSize() ).IsInside( VCLPoint( rPoint ) );
 609 }
 610
 611 uno::Reference< XAccessible > SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleAtPoint( const awt::Point& ) throw( RuntimeException, std::exception )
 612 {
 613     return uno::Reference< XAccessible >();
 614 }
 615
 616 awt::Rectangle SAL_CALL SvxPixelCtlAccessibleChild::getBounds() throw( RuntimeException, std::exception )
 617 {
 618     // no guard -> done in getBoundingBox()
 619     //Modified by lq, 09/26
 620     //return AWTRectangle( GetBoundingBox() );
 621     awt::Rectangle rect = AWTRectangle( GetBoundingBox() );
 622     rect.X = rect.X + mrParentWindow.GetClientWindowExtentsRelative(NULL).Left()-mrParentWindow.GetWindowExtentsRelative(NULL).Left();
 623     rect.Y = rect.Y + mrParentWindow.GetClientWindowExtentsRelative(NULL).Top()-mrParentWindow.GetWindowExtentsRelative(NULL).Top();
 624     return rect;
 625     // End
 626 }
 627
 628 awt::Point SAL_CALL SvxPixelCtlAccessibleChild::getLocation() throw( RuntimeException, std::exception )
 629 {
 630     // no guard -> done in getBoundingBox()
 631     return AWTPoint( GetBoundingBox().TopLeft() );
 632 }
 633
 634 awt::Point SAL_CALL SvxPixelCtlAccessibleChild::getLocationOnScreen() throw( RuntimeException, std::exception )
 635 {
 636     // no guard -> done in getBoundingBoxOnScreen()
 637     return AWTPoint( GetBoundingBoxOnScreen().TopLeft() );
 638 }
 639
 640 awt::Size SAL_CALL SvxPixelCtlAccessibleChild::getSize() throw( RuntimeException, std::exception )
 641 {
 642     // no guard -> done in getBoundingBox()
 643     return AWTSize( GetBoundingBox().GetSize() );
 644 }
 645
 646 void SAL_CALL SvxPixelCtlAccessibleChild::grabFocus() throw( RuntimeException, std::exception )
 647 {
 648 }
 649
 650 sal_Int32 SvxPixelCtlAccessibleChild::getForeground(  )
 651         throw (::com::sun::star::uno::RuntimeException, std::exception)
 652 {
 653     //::vos::OGuard       aSolarGuard( Application::GetSolarMutex() );
 654     ::osl::MutexGuard   aGuard( m_aMutex );
 655     ThrowExceptionIfNotAlive();
 656     return mrParentWindow.GetControlForeground().GetColor();
 657 }
 658 sal_Int32 SvxPixelCtlAccessibleChild::getBackground(  )
 659         throw (::com::sun::star::uno::RuntimeException, std::exception)
 660 {
 661     //::vos::OGuard       aSolarGuard( Application::GetSolarMutex() );
 662     ::osl::MutexGuard   aGuard( m_aMutex );
 663
 664     ThrowExceptionIfNotAlive();
 665     return mrParentWindow.GetControlBackground().GetColor();
 666 }
 667
 668 //=====  XAccessibleContext  ==================================================
 669
 670 sal_Int32 SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleChildCount( void ) throw( RuntimeException, std::exception )
 671 {
 672     return 0;
 673 }
 674
 675 uno::Reference< XAccessible > SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleChild( sal_Int32 )
 676     throw (lang::IndexOutOfBoundsException, uno::RuntimeException, std::exception)
 677 {
 678     throw lang::IndexOutOfBoundsException();
 679 }
 680
 681 uno::Reference< XAccessible > SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleParent( void ) throw( RuntimeException, std::exception )
 682 {
 683     return mxParent;
 684 }
 685
 686 sal_Int32 SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleIndexInParent( void ) throw( RuntimeException, std::exception )
 687 {
 688    return mnIndexInParent;
 689 }
 690
 691 sal_Int16 SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleRole( void ) throw( RuntimeException, std::exception )
 692 {
 693     return AccessibleRole::CHECK_BOX;
 694 }
 695
 696 OUString SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleDescription( void ) throw( RuntimeException, std::exception )
 697 {
 698     ::osl::MutexGuard   aGuard( m_aMutex );
 699
 700     return  GetName();
 701 }
 702
 703 OUString SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleName( void ) throw( RuntimeException, std::exception )
 704 {
 705     ::osl::MutexGuard   aGuard( m_aMutex );
 706     return  GetName();
 707 }
 708
 709 /** Return empty uno::Reference to indicate that the relation set is not
 710     supported.
 711 */
 712 uno::Reference<XAccessibleRelationSet> SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleRelationSet( void ) throw( RuntimeException, std::exception )
 713 {
 714     return uno::Reference< XAccessibleRelationSet >();
 715 }
 716
 717 uno::Reference< XAccessibleStateSet > SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleStateSet( void ) throw( RuntimeException, std::exception )
 718 {
 719     ::osl::MutexGuard                       aGuard( m_aMutex );
 720     utl::AccessibleStateSetHelper*          pStateSetHelper = new utl::AccessibleStateSetHelper;
 721
 722     if( IsAlive() )
 723     {
 724
 725         pStateSetHelper->AddState( AccessibleStateType::TRANSIENT );
 726         pStateSetHelper->AddState( AccessibleStateType::ENABLED );
 727         pStateSetHelper->AddState( AccessibleStateType::OPAQUE );
 728         pStateSetHelper->AddState( AccessibleStateType::SELECTABLE );
 729         pStateSetHelper->AddState( AccessibleStateType::SHOWING );
 730         pStateSetHelper->AddState( AccessibleStateType::VISIBLE );
 731
 732         long nIndex = mrParentWindow.GetFoucsPosIndex();
 733         if ( nIndex == mnIndexInParent)
 734         {
 735             pStateSetHelper->AddState( AccessibleStateType::SELECTED );
 736         }
 737         if (mrParentWindow.GetBitmapPixel(sal_uInt16(mnIndexInParent)))
 738         {
 739             pStateSetHelper->AddState( AccessibleStateType::CHECKED );
 740         }
 741     }
 742     else
 743         pStateSetHelper->AddState( AccessibleStateType::DEFUNC );
 744
 745     return pStateSetHelper;
 746 }
 747
 748 lang::Locale SAL_CALL SvxPixelCtlAccessibleChild::getLocale( void ) throw( IllegalAccessibleComponentStateException, RuntimeException, std::exception )
 749 {
 750     ::osl::MutexGuard                       aGuard( m_aMutex );
 751     if( mxParent.is() )
 752     {
 753         uno::Reference< XAccessibleContext >        xParentContext( mxParent->getAccessibleContext() );
 754         if( xParentContext.is() )
 755             return xParentContext->getLocale();
 756     }
 757
 758     //  No locale and no parent.  Therefore throw exception to indicate this
 759     //  cluelessness.
 760     throw IllegalAccessibleComponentStateException();
 761 }
 762
 763 void SAL_CALL SvxPixelCtlAccessibleChild::addAccessibleEventListener( const uno::Reference< XAccessibleEventListener >& xListener )
 764     throw( RuntimeException, std::exception )
 765 {
 766     if (xListener.is())
 767     {
 768         ::osl::MutexGuard   aGuard( m_aMutex );
 769         if (!mnClientId)
 770             mnClientId = comphelper::AccessibleEventNotifier::registerClient( );
 771         comphelper::AccessibleEventNotifier::addEventListener( mnClientId, xListener );
 772     }
 773 }
 774
 775 void SAL_CALL SvxPixelCtlAccessibleChild::removeAccessibleEventListener( const uno::Reference< XAccessibleEventListener >& xListener )
 776     throw( RuntimeException, std::exception )
 777 {
 778     if (xListener.is())
 779     {
 780         ::osl::MutexGuard   aGuard( m_aMutex );
 781
 782         sal_Int32 nListenerCount = comphelper::AccessibleEventNotifier::removeEventListener( mnClientId, xListener );
 783         if ( !nListenerCount )
 784         {
 785             // no listeners anymore
 786             // -> revoke ourself. This may lead to the notifier thread dying (if we were the last client),
 787             // and at least to us not firing any events anymore, in case somebody calls
 788             // NotifyAccessibleEvent, again
 789             comphelper::AccessibleEventNotifier::revokeClient( mnClientId );
 790             mnClientId = 0;
 791         }
 792     }
 793 }
 794
 795
 796 //=====  XServiceInfo  ========================================================
 797 OUString SAL_CALL SvxPixelCtlAccessibleChild::getImplementationName( void ) throw( RuntimeException, std::exception )
 798 {
 799     return OUString( RTL_CONSTASCII_USTRINGPARAM( "SvxPixelCtlAccessibleChild" ) );
 800 }
 801
 802 sal_Bool SAL_CALL SvxPixelCtlAccessibleChild::supportsService( const OUString& rServiceName ) throw( RuntimeException, std::exception )
 803 {
 804     return cppu::supportsService( this, rServiceName );
 805 }
 806
 807 Sequence< OUString > SAL_CALL SvxPixelCtlAccessibleChild::getSupportedServiceNames( void ) throw( RuntimeException, std::exception )
 808 {
 809     uno::Sequence< OUString > aRet(3);
 810     OUString* pArray = aRet.getArray();
 811     pArray[0] = "Accessible";
 812     pArray[1] = "AccessibleContext";
 813     pArray[2] = "AccessibleComponent";
 814     return aRet;
 815 }
 816
 817 //=====  internal  ============================================================
 818
 819 void SvxPixelCtlAccessibleChild::CommitChange( const AccessibleEventObject& rEvent )
 820 {
 821     if (mnClientId)
 822         comphelper::AccessibleEventNotifier::addEvent( mnClientId, rEvent );
 823 }
 824
 825 void SAL_CALL SvxPixelCtlAccessibleChild::disposing()
 826 {
 827     if( !rBHelper.bDisposed )
 828     {
 829         ::osl::MutexGuard   aGuard( m_aMutex );
 830
 831         // Send a disposing to all listeners.
 832         if ( mnClientId )
 833         {
 834             comphelper::AccessibleEventNotifier::revokeClientNotifyDisposing( mnClientId, *this );
 835             mnClientId =  0;
 836         }
 837
 838         mxParent = uno::Reference< XAccessible >();
 839
 840         delete mpBoundingBox;
 841     }
 842 }
 843
 844 void SvxPixelCtlAccessibleChild::ThrowExceptionIfNotAlive( void ) throw( lang::DisposedException )
 845 {
 846     if( IsNotAlive() )
 847         throw lang::DisposedException();
 848 }
 849
 850 Rectangle SvxPixelCtlAccessibleChild::GetBoundingBoxOnScreen( void ) throw( RuntimeException )
 851 {
 852     ::osl::MutexGuard   aGuard( m_aMutex );
 853
 854     // no ThrowExceptionIfNotAlive() because its done in GetBoundingBox()
 855     Rectangle           aRect( GetBoundingBox() );
 856
 857     return Rectangle( mrParentWindow.OutputToAbsoluteScreenPixel( aRect.TopLeft() ), aRect.GetSize() );
 858 }
 859
 860 Rectangle SvxPixelCtlAccessibleChild::GetBoundingBox( void ) throw( RuntimeException )
 861 {
 862     // no guard necessary, because no one changes mpBoundingBox after creating it
 863     ThrowExceptionIfNotAlive();
 864
 865     return *mpBoundingBox;
 866 }
 867
 868 OUString SvxPixelCtlAccessibleChild::GetName()
 869 {
 870     sal_Int32 nXIndex = mnIndexInParent % mrParentWindow.GetLineCount();
 871     sal_Int32 nYIndex = mnIndexInParent / mrParentWindow.GetLineCount();
 872
 873     OUString str;
 874     str += "(";
 875     str += OUString::number(nXIndex);
 876     str += ",";
 877     str += OUString::number(nYIndex);
 878     str += ")";
 879     return str;
 880 }
 881
 882 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */