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