sfx2/source/view/userinputinterception.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
  21 #include <sfx2/userinputinterception.hxx>
  22
  23 #include <com/sun/star/awt/MouseButton.hpp>
  24 #include <com/sun/star/awt/KeyModifier.hpp>
  25
  26 #include <cppuhelper/interfacecontainer.hxx>
  27 #include <cppuhelper/weak.hxx>
  28 #include <vcl/event.hxx>
  29 #include <vcl/window.hxx>
  30
  31
  32 namespace sfx2
  33 {
  34
  35
  36     using ::com::sun::star::uno::Reference;
  37     using ::com::sun::star::uno::XInterface;
  38     using ::com::sun::star::uno::UNO_QUERY;
  39     using ::com::sun::star::uno::UNO_QUERY_THROW;
  40     using ::com::sun::star::uno::UNO_SET_THROW;
  41     using ::com::sun::star::uno::Exception;
  42     using ::com::sun::star::uno::RuntimeException;
  43     using ::com::sun::star::uno::Any;
  44     using ::com::sun::star::uno::makeAny;
  45     using ::com::sun::star::awt::MouseEvent;
  46     using ::com::sun::star::awt::KeyEvent;
  47     using ::com::sun::star::awt::InputEvent;
  48     using ::com::sun::star::awt::XKeyHandler;
  49     using ::com::sun::star::awt::XMouseClickHandler;
  50     using ::com::sun::star::lang::DisposedException;
  51
  52     namespace MouseButton = ::com::sun::star::awt::MouseButton;
  53     namespace KeyModifier = ::com::sun::star::awt::KeyModifier;
  54
  55     struct UserInputInterception_Data
  56     {
  57     public:
  58         ::cppu::OWeakObject&                m_rControllerImpl;
  59         ::cppu::OInterfaceContainerHelper   m_aKeyHandlers;
  60         ::cppu::OInterfaceContainerHelper   m_aMouseClickHandlers;
  61
  62     public:
  63         UserInputInterception_Data( ::cppu::OWeakObject& _rControllerImpl, ::osl::Mutex& _rMutex )
  64             :m_rControllerImpl( _rControllerImpl )
  65             ,m_aKeyHandlers( _rMutex )
  66             ,m_aMouseClickHandlers( _rMutex )
  67         {
  68         }
  69     };
  70
  71     namespace
  72     {
  73         template< class VLCEVENT >
  74         void lcl_initModifiers( InputEvent& _rEvent, const VLCEVENT& _rVclEvent )
  75         {
  76             _rEvent.Modifiers = 0;
  77
  78             if ( _rVclEvent.IsShift() )
  79                 _rEvent.Modifiers |= KeyModifier::SHIFT;
  80             if ( _rVclEvent.IsMod1() )
  81                 _rEvent.Modifiers |= KeyModifier::MOD1;
  82             if ( _rVclEvent.IsMod2() )
  83                 _rEvent.Modifiers |= KeyModifier::MOD2;
  84             if ( _rVclEvent.IsMod3() )
  85                 _rEvent.Modifiers |= KeyModifier::MOD3;
  86         }
  87
  88         void lcl_initKeyEvent( KeyEvent& rEvent, const ::KeyEvent& rEvt )
  89         {
  90             lcl_initModifiers( rEvent, rEvt.GetKeyCode() );
  91
  92             rEvent.KeyCode = rEvt.GetKeyCode().GetCode();
  93             rEvent.KeyChar = rEvt.GetCharCode();
  94             rEvent.KeyFunc = sal::static_int_cast< sal_Int16 >( rEvt.GetKeyCode().GetFunction());
  95         }
  96
  97         void lcl_initMouseEvent( MouseEvent& rEvent, const ::MouseEvent& rEvt )
  98         {
  99             lcl_initModifiers( rEvent, rEvt );
 100
 101             rEvent.Buttons = 0;
 102             if ( rEvt.IsLeft() )
 103                 rEvent.Buttons |= MouseButton::LEFT;
 104             if ( rEvt.IsRight() )
 105                 rEvent.Buttons |= MouseButton::RIGHT;
 106             if ( rEvt.IsMiddle() )
 107                 rEvent.Buttons |= MouseButton::MIDDLE;
 108
 109             rEvent.X = rEvt.GetPosPixel().X();
 110             rEvent.Y = rEvt.GetPosPixel().Y();
 111             rEvent.ClickCount = rEvt.GetClicks();
 112             rEvent.PopupTrigger = sal_False;
 113         }
 114
 115     }
 116
 117
 118     //= UserInputInterception
 119
 120
 121     UserInputInterception::UserInputInterception( ::cppu::OWeakObject& _rControllerImpl, ::osl::Mutex& _rMutex )
 122         :m_pData( new UserInputInterception_Data( _rControllerImpl, _rMutex ) )
 123     {
 124     }
 125
 126
 127     UserInputInterception::~UserInputInterception()
 128     {
 129     }
 130
 131
 132     void UserInputInterception::addKeyHandler( const Reference< XKeyHandler >& _rxHandler ) throw (RuntimeException)
 133     {
 134         if ( _rxHandler.is() )
 135             m_pData->m_aKeyHandlers.addInterface( _rxHandler );
 136     }
 137
 138
 139     void UserInputInterception::removeKeyHandler( const Reference< XKeyHandler >& _rxHandler ) throw (RuntimeException)
 140     {
 141         m_pData->m_aKeyHandlers.removeInterface( _rxHandler );
 142     }
 143
 144
 145     void UserInputInterception::addMouseClickHandler( const Reference< XMouseClickHandler >& _rxHandler ) throw (RuntimeException)
 146     {
 147         if ( _rxHandler.is() )
 148             m_pData->m_aMouseClickHandlers.addInterface( _rxHandler );
 149     }
 150
 151
 152     void UserInputInterception::removeMouseClickHandler( const Reference< XMouseClickHandler >& _rxHandler ) throw (RuntimeException)
 153     {
 154         m_pData->m_aMouseClickHandlers.removeInterface( _rxHandler );
 155     }
 156
 157
 158     bool UserInputInterception::hasKeyHandlers() const
 159     {
 160         return m_pData->m_aKeyHandlers.getLength() > 0;
 161     }
 162
 163
 164     bool UserInputInterception::hasMouseClickListeners() const
 165     {
 166         return m_pData->m_aMouseClickHandlers.getLength() > 0;
 167     }
 168
 169
 170     bool UserInputInterception::handleNotifyEvent( const NotifyEvent& _rEvent )
 171     {
 172         Reference < XInterface > xHoldAlive( m_pData->m_rControllerImpl );
 173
 174         MouseNotifyEvent nType = _rEvent.GetType();
 175         bool bHandled = false;
 176
 177         switch ( nType )
 178         {
 179             case MouseNotifyEvent::KEYINPUT:
 180             case MouseNotifyEvent::KEYUP:
 181             {
 182                 KeyEvent aEvent;
 183                 lcl_initKeyEvent( aEvent, *_rEvent.GetKeyEvent() );
 184                 if ( _rEvent.GetWindow() )
 185                     aEvent.Source = _rEvent.GetWindow()->GetComponentInterface();
 186
 187                 ::cppu::OInterfaceIteratorHelper aIterator( m_pData->m_aKeyHandlers );
 188                 while ( aIterator.hasMoreElements() )
 189                 {
 190                     Reference< XKeyHandler > xHandler( static_cast< XKeyHandler* >( aIterator.next() ) );
 191                     if ( !xHandler.is() )
 192                         continue;
 193
 194                     try
 195                     {
 196                         if ( nType == MouseNotifyEvent::KEYINPUT )
 197                             bHandled = xHandler->keyPressed( aEvent );
 198                         else
 199                             bHandled = xHandler->keyReleased( aEvent );
 200                     }
 201                     catch( const DisposedException& e )
 202                     {
 203                         if ( e.Context == xHandler )
 204                             aIterator.remove();
 205                     }
 206                     catch( const RuntimeException& )
 207                     {
 208                         throw;
 209                     }
 210                     catch( const Exception& )
 211                     {
 212                     }
 213                 }
 214             }
 215             break;
 216
 217             case MouseNotifyEvent::MOUSEBUTTONDOWN:
 218             case MouseNotifyEvent::MOUSEBUTTONUP:
 219             {
 220                 MouseEvent aEvent;
 221                 lcl_initMouseEvent( aEvent, *_rEvent.GetMouseEvent() );
 222                 if ( _rEvent.GetWindow() )
 223                     aEvent.Source = _rEvent.GetWindow()->GetComponentInterface();
 224
 225                 ::cppu::OInterfaceIteratorHelper aIterator( m_pData->m_aMouseClickHandlers );
 226                 while ( aIterator.hasMoreElements() )
 227                 {
 228                     Reference< XMouseClickHandler > xHandler( static_cast< XMouseClickHandler* >( aIterator.next() ) );
 229                     if ( !xHandler.is() )
 230                         continue;
 231
 232                     try
 233                     {
 234                         if ( nType == MouseNotifyEvent::MOUSEBUTTONDOWN )
 235                             bHandled = xHandler->mousePressed( aEvent );
 236                         else
 237                             bHandled = xHandler->mouseReleased( aEvent );
 238                     }
 239                     catch( const DisposedException& e )
 240                     {
 241                         if ( e.Context == xHandler )
 242                             aIterator.remove();
 243                     }
 244                     catch( const RuntimeException& )
 245                     {
 246                         throw;
 247                     }
 248                     catch( const Exception& )
 249                     {
 250                     }
 251                 }
 252             }
 253             break;
 254
 255             default:
 256                 OSL_FAIL( "UserInputInterception::handleNotifyEvent: illegal event type!" );
 257                 break;
 258         }
 259
 260         return bHandled;
 261     }
 262
 263
 264 } // namespace sfx2
 265
 266
 267 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */