accessibility/source/standard/accessiblemenubasecomponent.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 <standard/accessiblemenubasecomponent.hxx>
  21 #include <standard/vclxaccessiblemenu.hxx>
  22 #include <standard/vclxaccessiblemenuitem.hxx>
  23 #include <standard/vclxaccessiblemenuseparator.hxx>
  24 #include <toolkit/helper/convert.hxx>
  25
  26 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  27 #include <com/sun/star/accessibility/AccessibleRole.hpp>
  28 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  29 #include <comphelper/accessiblecontexthelper.hxx>
  30 #include <cppuhelper/supportsservice.hxx>
  31 #include <o3tl/safeint.hxx>
  32 #include <vcl/menu.hxx>
  33 #include <vcl/vclevent.hxx>
  34
  35 #include <array>
  36
  37 using namespace ::com::sun::star;
  38 using namespace ::com::sun::star::lang;
  39 using namespace ::com::sun::star::uno;
  40 using namespace ::com::sun::star::accessibility;
  41 using namespace ::comphelper;
  42
  43
  44 // OAccessibleMenuBaseComponent
  45
  46
  47 OAccessibleMenuBaseComponent::OAccessibleMenuBaseComponent( Menu* pMenu )
  48     :m_pMenu( pMenu )
  49     ,m_bEnabled( false )
  50     ,m_bFocused( false )
  51     ,m_bVisible( false )
  52     ,m_bSelected( false )
  53     ,m_bChecked( false )
  54 {
  55     if ( m_pMenu )
  56     {
  57         m_aAccessibleChildren.assign( m_pMenu->GetItemCount(), Reference< XAccessible >() );
  58         m_pMenu->AddEventListener( LINK( this, OAccessibleMenuBaseComponent, MenuEventListener ) );
  59     }
  60 }
  61
  62
  63 OAccessibleMenuBaseComponent::~OAccessibleMenuBaseComponent()
  64 {
  65     if ( m_pMenu )
  66         m_pMenu->RemoveEventListener( LINK( this, OAccessibleMenuBaseComponent, MenuEventListener ) );
  67 }
  68
  69
  70 bool OAccessibleMenuBaseComponent::IsEnabled()
  71 {
  72     return false;
  73 }
  74
  75
  76 bool OAccessibleMenuBaseComponent::IsFocused()
  77 {
  78     return false;
  79 }
  80
  81
  82 bool OAccessibleMenuBaseComponent::IsVisible()
  83 {
  84     return false;
  85 }
  86
  87
  88 bool OAccessibleMenuBaseComponent::IsSelected()
  89 {
  90     return false;
  91 }
  92
  93
  94 bool OAccessibleMenuBaseComponent::IsChecked()
  95 {
  96     return false;
  97 }
  98
  99
 100 void OAccessibleMenuBaseComponent::SetStates()
 101 {
 102     m_bEnabled = IsEnabled();
 103     m_bFocused = IsFocused();
 104     m_bVisible = IsVisible();
 105     m_bSelected = IsSelected();
 106     m_bChecked = IsChecked();
 107 }
 108
 109
 110 void OAccessibleMenuBaseComponent::SetEnabled( bool bEnabled )
 111 {
 112     if ( m_bEnabled == bEnabled )
 113         return;
 114
 115     sal_Int64 nStateType=AccessibleStateType::ENABLED;
 116     if (IsMenuHideDisabledEntries())
 117     {
 118         nStateType = AccessibleStateType::VISIBLE;
 119     }
 120     std::array<Any, 2> aOldValue, aNewValue;
 121     if ( m_bEnabled )
 122     {
 123         aOldValue[0] <<= AccessibleStateType::SENSITIVE;
 124         aOldValue[1] <<= nStateType;
 125     }
 126     else
 127     {
 128         aNewValue[0] <<= nStateType;
 129         aNewValue[1] <<= AccessibleStateType::SENSITIVE;
 130     }
 131     m_bEnabled = bEnabled;
 132     NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue[0], aNewValue[0] );
 133     NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue[1], aNewValue[1] );
 134 }
 135
 136
 137 void OAccessibleMenuBaseComponent::SetFocused( bool bFocused )
 138 {
 139     if ( m_bFocused != bFocused )
 140     {
 141         Any aOldValue, aNewValue;
 142         if ( m_bFocused )
 143             aOldValue <<= AccessibleStateType::FOCUSED;
 144         else
 145             aNewValue <<= AccessibleStateType::FOCUSED;
 146         m_bFocused = bFocused;
 147         NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 148     }
 149 }
 150
 151
 152 void OAccessibleMenuBaseComponent::SetVisible( bool bVisible )
 153 {
 154     if ( m_bVisible != bVisible )
 155     {
 156         Any aOldValue, aNewValue;
 157         if ( m_bVisible )
 158             aOldValue <<= AccessibleStateType::VISIBLE;
 159         else
 160             aNewValue <<= AccessibleStateType::VISIBLE;
 161         m_bVisible = bVisible;
 162         NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 163     }
 164 }
 165
 166
 167 void OAccessibleMenuBaseComponent::SetSelected( bool bSelected )
 168 {
 169     if ( m_bSelected != bSelected )
 170     {
 171         Any aOldValue, aNewValue;
 172         if ( m_bSelected )
 173             aOldValue <<= AccessibleStateType::SELECTED;
 174         else
 175             aNewValue <<= AccessibleStateType::SELECTED;
 176         m_bSelected = bSelected;
 177         NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 178     }
 179 }
 180
 181
 182 void OAccessibleMenuBaseComponent::SetChecked( bool bChecked )
 183 {
 184     if ( m_bChecked != bChecked )
 185     {
 186         Any aOldValue, aNewValue;
 187         if ( m_bChecked )
 188             aOldValue <<= AccessibleStateType::CHECKED;
 189         else
 190             aNewValue <<= AccessibleStateType::CHECKED;
 191         m_bChecked = bChecked;
 192         NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 193     }
 194 }
 195
 196
 197 void OAccessibleMenuBaseComponent::UpdateEnabled( sal_Int32 i, bool bEnabled )
 198 {
 199     if ( i >= 0 && o3tl::make_unsigned(i) < m_aAccessibleChildren.size() )
 200     {
 201         Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
 202         if ( xChild.is() )
 203         {
 204             OAccessibleMenuBaseComponent* pComp = static_cast< OAccessibleMenuBaseComponent* >( xChild.get() );
 205             if ( pComp )
 206                 pComp->SetEnabled( bEnabled );
 207         }
 208     }
 209 }
 210
 211
 212 void OAccessibleMenuBaseComponent::UpdateFocused( sal_Int32 i, bool bFocused )
 213 {
 214     if ( i >= 0 && o3tl::make_unsigned(i) < m_aAccessibleChildren.size() )
 215     {
 216         Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
 217         if ( xChild.is() )
 218         {
 219             OAccessibleMenuBaseComponent* pComp = static_cast< OAccessibleMenuBaseComponent* >( xChild.get() );
 220             if ( pComp )
 221                 pComp->SetFocused( bFocused );
 222         }
 223     }
 224 }
 225
 226
 227 void OAccessibleMenuBaseComponent::UpdateVisible()
 228 {
 229     SetVisible( IsVisible() );
 230     for (const Reference<XAccessible>& xChild : m_aAccessibleChildren)
 231     {
 232         if ( xChild.is() )
 233         {
 234             OAccessibleMenuBaseComponent* pComp = static_cast< OAccessibleMenuBaseComponent* >( xChild.get() );
 235             if ( pComp )
 236                 pComp->SetVisible( pComp->IsVisible() );
 237         }
 238     }
 239 }
 240
 241
 242 void OAccessibleMenuBaseComponent::UpdateSelected( sal_Int32 i, bool bSelected )
 243 {
 244     NotifyAccessibleEvent( AccessibleEventId::SELECTION_CHANGED, Any(), Any() );
 245
 246     if ( i >= 0 && o3tl::make_unsigned(i) < m_aAccessibleChildren.size() )
 247     {
 248         Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
 249         if ( xChild.is() )
 250         {
 251             OAccessibleMenuBaseComponent* pComp = static_cast< OAccessibleMenuBaseComponent* >( xChild.get() );
 252             if ( pComp )
 253                 pComp->SetSelected( bSelected );
 254         }
 255     }
 256 }
 257
 258
 259 void OAccessibleMenuBaseComponent::UpdateChecked( sal_Int32 i, bool bChecked )
 260 {
 261     if ( i >= 0 && o3tl::make_unsigned(i) < m_aAccessibleChildren.size() )
 262     {
 263         Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
 264         if ( xChild.is() )
 265         {
 266             OAccessibleMenuBaseComponent* pComp = static_cast< OAccessibleMenuBaseComponent* >( xChild.get() );
 267             if ( pComp )
 268                 pComp->SetChecked( bChecked );
 269         }
 270     }
 271 }
 272
 273
 274 void OAccessibleMenuBaseComponent::UpdateAccessibleName( sal_Int32 i )
 275 {
 276     if ( i >= 0 && o3tl::make_unsigned(i) < m_aAccessibleChildren.size() )
 277     {
 278         Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
 279         if ( xChild.is() )
 280         {
 281             OAccessibleMenuItemComponent* pComp = static_cast< OAccessibleMenuItemComponent* >( xChild.get() );
 282             if ( pComp )
 283                 pComp->SetAccessibleName( pComp->GetAccessibleName() );
 284         }
 285     }
 286 }
 287
 288
 289 void OAccessibleMenuBaseComponent::UpdateItemText( sal_Int32 i )
 290 {
 291     if ( i >= 0 && o3tl::make_unsigned(i) < m_aAccessibleChildren.size() )
 292     {
 293         Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
 294         if ( xChild.is() )
 295         {
 296             OAccessibleMenuItemComponent* pComp = static_cast< OAccessibleMenuItemComponent* >( xChild.get() );
 297             if ( pComp )
 298                 pComp->SetItemText( pComp->GetItemText() );
 299         }
 300     }
 301 }
 302
 303
 304 sal_Int64 OAccessibleMenuBaseComponent::GetChildCount() const
 305 {
 306     return m_aAccessibleChildren.size();
 307 }
 308
 309
 310 Reference< XAccessible > OAccessibleMenuBaseComponent::GetChild( sal_Int64 i )
 311 {
 312     Reference< XAccessible > xChild = m_aAccessibleChildren[i];
 313     if ( !xChild.is() )
 314     {
 315         if ( m_pMenu )
 316         {
 317             // create a new child
 318             rtl::Reference<OAccessibleMenuBaseComponent> pChild;
 319
 320             if ( m_pMenu->GetItemType( static_cast<sal_uInt16>(i) ) == MenuItemType::SEPARATOR )
 321             {
 322                 pChild = new VCLXAccessibleMenuSeparator( m_pMenu, static_cast<sal_uInt16>(i) );
 323             }
 324             else
 325             {
 326                 PopupMenu* pPopupMenu = m_pMenu->GetPopupMenu( m_pMenu->GetItemId( static_cast<sal_uInt16>(i) ) );
 327                 if ( pPopupMenu )
 328                 {
 329                     pChild = new VCLXAccessibleMenu( m_pMenu, static_cast<sal_uInt16>(i), pPopupMenu );
 330                     pPopupMenu->SetAccessible( pChild );
 331                 }
 332                 else
 333                 {
 334                     pChild = new VCLXAccessibleMenuItem( m_pMenu, static_cast<sal_uInt16>(i) );
 335                 }
 336             }
 337
 338             // set states
 339             pChild->SetStates();
 340
 341             xChild = pChild;
 342
 343             // insert into menu item list
 344             m_aAccessibleChildren[i] = xChild;
 345         }
 346     }
 347
 348     return xChild;
 349 }
 350
 351
 352 Reference< XAccessible > OAccessibleMenuBaseComponent::GetChildAt( const awt::Point& rPoint )
 353 {
 354     Reference< XAccessible > xChild;
 355     for ( sal_Int64 i = 0, nCount = getAccessibleChildCount(); i < nCount; ++i )
 356     {
 357         Reference< XAccessible > xAcc = getAccessibleChild( i );
 358         if ( xAcc.is() )
 359         {
 360             Reference< XAccessibleComponent > xComp( xAcc->getAccessibleContext(), UNO_QUERY );
 361             if ( xComp.is() )
 362             {
 363                 tools::Rectangle aRect = VCLRectangle( xComp->getBounds() );
 364                 Point aPos = VCLPoint( rPoint );
 365                 if ( aRect.Contains( aPos ) )
 366                 {
 367                     xChild = xAcc;
 368                     break;
 369                 }
 370             }
 371         }
 372     }
 373
 374     return xChild;
 375 }
 376
 377
 378 void OAccessibleMenuBaseComponent::InsertChild( sal_Int32 i )
 379 {
 380     if ( i < 0 )
 381         return;
 382
 383     if ( o3tl::make_unsigned(i) > m_aAccessibleChildren.size() )
 384         i = m_aAccessibleChildren.size();
 385
 386     // insert entry in child list
 387     m_aAccessibleChildren.insert( m_aAccessibleChildren.begin() + i, Reference< XAccessible >() );
 388
 389     // update item position of accessible children
 390     for ( sal_uInt32 j = i, nCount = m_aAccessibleChildren.size(); j < nCount; ++j )
 391     {
 392         Reference< XAccessible > xAcc( m_aAccessibleChildren[j] );
 393         if ( xAcc.is() )
 394         {
 395             OAccessibleMenuItemComponent* pComp = static_cast< OAccessibleMenuItemComponent* >( xAcc.get() );
 396             if ( pComp )
 397                 pComp->SetItemPos( static_cast<sal_uInt16>(j) );
 398         }
 399     }
 400
 401     // send accessible child event
 402     Reference< XAccessible > xChild( GetChild( i ) );
 403     if ( xChild.is() )
 404     {
 405         Any aOldValue, aNewValue;
 406         aNewValue <<= xChild;
 407         NotifyAccessibleEvent( AccessibleEventId::CHILD, aOldValue, aNewValue );
 408     }
 409 }
 410
 411
 412 void OAccessibleMenuBaseComponent::RemoveChild( sal_Int32 i )
 413 {
 414     if ( i < 0 || o3tl::make_unsigned(i) >= m_aAccessibleChildren.size() )
 415         return;
 416
 417     // keep the accessible of the removed item
 418     Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
 419
 420     // remove entry in child list
 421     m_aAccessibleChildren.erase( m_aAccessibleChildren.begin() + i );
 422
 423     // update item position of accessible children
 424     for ( sal_uInt32 j = i, nCount = m_aAccessibleChildren.size(); j < nCount; ++j )
 425     {
 426         Reference< XAccessible > xAcc( m_aAccessibleChildren[j] );
 427         if ( xAcc.is() )
 428         {
 429             OAccessibleMenuItemComponent* pComp = static_cast< OAccessibleMenuItemComponent* >( xAcc.get() );
 430             if ( pComp )
 431                 pComp->SetItemPos( static_cast<sal_uInt16>(j) );
 432         }
 433     }
 434
 435     // send accessible child event
 436     if ( xChild.is() )
 437     {
 438         Any aOldValue, aNewValue;
 439         aOldValue <<= xChild;
 440         NotifyAccessibleEvent( AccessibleEventId::CHILD, aOldValue, aNewValue );
 441
 442         Reference< XComponent > xComponent( xChild, UNO_QUERY );
 443         if ( xComponent.is() )
 444             xComponent->dispose();
 445     }
 446 }
 447
 448
 449 bool OAccessibleMenuBaseComponent::IsHighlighted()
 450 {
 451     return false;
 452 }
 453
 454
 455 bool OAccessibleMenuBaseComponent::IsChildHighlighted()
 456 {
 457     bool bChildHighlighted = false;
 458
 459     for (const Reference<XAccessible>& xChild : m_aAccessibleChildren)
 460     {
 461         if ( xChild.is() )
 462         {
 463             OAccessibleMenuBaseComponent* pComp = static_cast< OAccessibleMenuBaseComponent* >( xChild.get() );
 464             if ( pComp && pComp->IsHighlighted() )
 465             {
 466                 bChildHighlighted = true;
 467                 break;
 468             }
 469         }
 470     }
 471
 472     return bChildHighlighted;
 473 }
 474
 475
 476 void OAccessibleMenuBaseComponent::SelectChild( sal_Int32 i )
 477 {
 478     // open the menu
 479     if ( getAccessibleRole() == AccessibleRole::MENU && !IsPopupMenuOpen() )
 480         Click();
 481
 482     // highlight the child
 483     if ( m_pMenu )
 484         m_pMenu->HighlightItem( static_cast<sal_uInt16>(i) );
 485 }
 486
 487
 488 void OAccessibleMenuBaseComponent::DeSelectAll()
 489 {
 490     if ( m_pMenu )
 491         m_pMenu->DeHighlight();
 492 }
 493
 494
 495 bool OAccessibleMenuBaseComponent::IsChildSelected( sal_Int32 i )
 496 {
 497     bool bSelected = false;
 498
 499     if ( m_pMenu && m_pMenu->IsHighlighted( static_cast<sal_uInt16>(i) ) )
 500         bSelected = true;
 501
 502     return bSelected;
 503 }
 504
 505
 506 void OAccessibleMenuBaseComponent::Click()
 507 {
 508 }
 509
 510
 511 bool OAccessibleMenuBaseComponent::IsPopupMenuOpen()
 512 {
 513     return false;
 514 }
 515
 516
 517 IMPL_LINK( OAccessibleMenuBaseComponent, MenuEventListener, VclMenuEvent&, rEvent, void )
 518 {
 519     OSL_ENSURE( rEvent.GetMenu(), "OAccessibleMenuBaseComponent - Menu?" );
 520     ProcessMenuEvent( rEvent );
 521 }
 522
 523
 524 void OAccessibleMenuBaseComponent::ProcessMenuEvent( const VclMenuEvent& rVclMenuEvent )
 525 {
 526     sal_uInt16 nItemPos = rVclMenuEvent.GetItemPos();
 527
 528     switch ( rVclMenuEvent.GetId() )
 529     {
 530         case VclEventId::MenuShow:
 531         case VclEventId::MenuHide:
 532         {
 533             UpdateVisible();
 534         }
 535         break;
 536         case VclEventId::MenuHighlight:
 537         {
 538             SetFocused( false );
 539             UpdateFocused( nItemPos, true );
 540             UpdateSelected( nItemPos, true );
 541         }
 542         break;
 543         case VclEventId::MenuDehighlight:
 544         {
 545             UpdateFocused( nItemPos, false );
 546             UpdateSelected( nItemPos, false );
 547         }
 548         break;
 549         case VclEventId::MenuSubmenuActivate:
 550         {
 551         }
 552         break;
 553         case VclEventId::MenuSubmenuDeactivate:
 554         {
 555             UpdateFocused( nItemPos, true );
 556         }
 557         break;
 558         case VclEventId::MenuEnable:
 559         {
 560             UpdateEnabled( nItemPos, true );
 561         }
 562         break;
 563         case VclEventId::MenuDisable:
 564         {
 565             UpdateEnabled( nItemPos, false );
 566         }
 567         break;
 568         case VclEventId::MenuSubmenuChanged:
 569         {
 570             RemoveChild( nItemPos );
 571             InsertChild( nItemPos );
 572         }
 573         break;
 574         case VclEventId::MenuInsertItem:
 575         {
 576             InsertChild( nItemPos );
 577         }
 578         break;
 579         case VclEventId::MenuRemoveItem:
 580         {
 581             RemoveChild( nItemPos );
 582         }
 583         break;
 584         case VclEventId::MenuAccessibleNameChanged:
 585         {
 586             UpdateAccessibleName( nItemPos );
 587         }
 588         break;
 589         case VclEventId::MenuItemTextChanged:
 590         {
 591             UpdateAccessibleName( nItemPos );
 592             UpdateItemText( nItemPos );
 593         }
 594         break;
 595         case VclEventId::MenuItemChecked:
 596         {
 597             UpdateChecked( nItemPos, true );
 598         }
 599         break;
 600         case VclEventId::MenuItemUnchecked:
 601         {
 602             UpdateChecked( nItemPos, false );
 603         }
 604         break;
 605         case VclEventId::ObjectDying:
 606         {
 607             if ( m_pMenu )
 608             {
 609                 m_pMenu->RemoveEventListener( LINK( this, OAccessibleMenuBaseComponent, MenuEventListener ) );
 610
 611                 m_pMenu = nullptr;
 612
 613                 // dispose all menu items
 614                 for (const Reference<XAccessible>& i : m_aAccessibleChildren)
 615                 {
 616                     Reference< XComponent > xComponent( i, UNO_QUERY );
 617                     if ( xComponent.is() )
 618                         xComponent->dispose();
 619                 }
 620                 m_aAccessibleChildren.clear();
 621             }
 622         }
 623         break;
 624         default:
 625         {
 626         }
 627         break;
 628     }
 629 }
 630
 631
 632 // XComponent
 633
 634
 635 void OAccessibleMenuBaseComponent::disposing()
 636 {
 637     OAccessibleExtendedComponentHelper::disposing();
 638
 639     if ( !m_pMenu )
 640         return;
 641
 642     m_pMenu->RemoveEventListener( LINK( this, OAccessibleMenuBaseComponent, MenuEventListener ) );
 643
 644     m_pMenu = nullptr;
 645
 646     // dispose all menu items
 647     for (const Reference<XAccessible>& i : m_aAccessibleChildren)
 648     {
 649         Reference< XComponent > xComponent( i, UNO_QUERY );
 650         if ( xComponent.is() )
 651             xComponent->dispose();
 652     }
 653     m_aAccessibleChildren.clear();
 654 }
 655
 656
 657 // XServiceInfo
 658
 659
 660 sal_Bool OAccessibleMenuBaseComponent::supportsService( const OUString& rServiceName )
 661 {
 662     return cppu::supportsService(this, rServiceName);
 663 }
 664
 665
 666 // XAccessible
 667
 668
 669 Reference< XAccessibleContext > OAccessibleMenuBaseComponent::getAccessibleContext(  )
 670 {
 671     OExternalLockGuard aGuard( this );
 672
 673     return this;
 674 }
 675
 676
 677 // XAccessibleContext
 678
 679
 680 sal_Int64 OAccessibleMenuBaseComponent::getAccessibleStateSet(  )
 681 {
 682     OExternalLockGuard aGuard( this );
 683
 684     sal_Int64 nStateSet = 0;
 685
 686     if ( !rBHelper.bDisposed && !rBHelper.bInDispose )
 687     {
 688         FillAccessibleStateSet( nStateSet );
 689     }
 690     else
 691     {
 692         nStateSet |= AccessibleStateType::DEFUNC;
 693     }
 694
 695     return nStateSet;
 696 }
 697
 698
 699 bool OAccessibleMenuBaseComponent::IsMenuHideDisabledEntries()
 700 {
 701     return false;
 702 }
 703
 704 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */