source: OGRE/trunk/ogrenew/PlatformManagers/Win32/src/OgreWin32Input8.cpp @ 692

Revision 692, 24.7 KB checked in by mattausch, 19 years ago (diff)

adding ogre 1.2 and dependencies

Line 
1/*
2-----------------------------------------------------------------------------
3This source file is part of OGRE
4    (Object-oriented Graphics Rendering Engine)
5For the latest info, see http://www.ogre3d.org/
6
7Copyright (c) 2000-2005 The OGRE Team
8Also see acknowledgements in Readme.html
9
10This program is free software; you can redistribute it and/or modify it under
11the terms of the GNU Lesser General Public License as published by the Free Software
12Foundation; either version 2 of the License, or (at your option) any later
13version.
14
15This program is distributed in the hope that it will be useful, but WITHOUT
16ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
17FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
18
19You should have received a copy of the GNU Lesser General Public License along with
20this program; if not, write to the Free Software Foundation, Inc., 59 Temple
21Place - Suite 330, Boston, MA 02111-1307, USA, or go to
22http://www.gnu.org/copyleft/lesser.txt.
23-----------------------------------------------------------------------------
24*/
25#include "OgreWin32Input8.h"
26
27#ifndef OGRE_NO_DX_INPUT
28#ifndef DX7INPUTONLY
29
30#include "OgreRenderWindow.h"
31#include "OgreLogManager.h"
32#include "OgreException.h"
33#include "OgreRoot.h"
34#include "OgreRenderSystem.h"
35#include "OgreMouseEvent.h"
36#include "OgreInputEvent.h"
37#include "OgreEventQueue.h"
38#include "OgreCursor.h"
39#include <dxerr8.h>
40
41#define DINPUT_BUFFERSIZE  64
42//#define DIPROP_BUFFERSIZE 256
43
44namespace Ogre {
45    //-----------------------------------------------------------------------
46    Win32Input8::Win32Input8() :
47                InputReader()
48    {
49        mlpDI = 0;
50        mlpDIKeyboard = 0;
51        mlpDIMouse = 0;
52                mEventQueue = 0;
53                mMouseScale = 0.001;
54
55        memset(mKeyboardBuffer,0,256);
56    }
57    //-----------------------------------------------------------------------
58    Win32Input8::~Win32Input8()
59    {
60        // Shutdown
61        if (mlpDIKeyboard)
62        {
63            mlpDIKeyboard->Unacquire();
64            mlpDIKeyboard->Release();
65            mlpDIKeyboard = 0;
66        }
67        if (mlpDIMouse)
68        {
69            mlpDIMouse->Unacquire();
70            mlpDIMouse->Release();
71            mlpDIMouse = 0;
72        }
73        if (mlpDI)
74        {
75            mlpDI->Release();
76            mlpDI = 0;
77        }
78
79    }
80
81    //-----------------------------------------------------------------------
82    void Win32Input8::initialiseBufferedKeyboard()
83        {
84
85        HRESULT hr;
86        LogManager::getSingleton().logMessage("Win32Input8: Establishing keyboard input.");
87
88        // Create keyboard device
89        hr = mlpDI->CreateDevice(GUID_SysKeyboard, &mlpDIKeyboard, NULL);
90
91
92        if (FAILED(hr))
93            throw Exception(hr, "Unable to create DirectInput keyboard device.",
94                "Win32Input8 - initialise");
95
96        // Set data format
97        hr = mlpDIKeyboard->SetDataFormat(&c_dfDIKeyboard);
98        if (FAILED(hr))
99            throw Exception(hr, "Unable to set DirectInput keyboard device data format.",
100                "Win32Input8 - initialise");
101
102        // Make the window grab keyboard behaviour when foreground
103        hr = mlpDIKeyboard->SetCooperativeLevel(mHWnd,
104                   DISCL_FOREGROUND | DISCL_EXCLUSIVE);
105        if (FAILED(hr))
106            throw Exception(hr, "Unable to set DirectInput keyboard device co-operative level.",
107                "Win32Input8 - initialise");
108
109
110                // IMPORTANT STEP TO USE BUFFERED DEVICE DATA!
111                //
112                // DirectInput uses unbuffered I/O (buffer size = 0) by default.
113                // If you want to read buffered data, you need to set a nonzero
114                // buffer size.
115                //
116                // Set the buffer size to SAMPLE_BUFFER_SIZE (defined above) elements.
117                //
118                // The buffer size is a DWORD property associated with the device.
119                DIPROPDWORD dipdw;
120                dipdw.diph.dwSize       = sizeof(DIPROPDWORD);
121                dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
122                dipdw.diph.dwObj        = 0;
123                dipdw.diph.dwHow        = DIPH_DEVICE;
124                dipdw.dwData            = DINPUT_BUFFERSIZE; // Arbitary buffer size
125
126                hr = mlpDIKeyboard->SetProperty( DIPROP_BUFFERSIZE, &dipdw.diph );
127
128        if (FAILED(hr))
129            throw Exception(hr, "Unable to create DirectInput keyboard buffer.",
130                "Win32Input8 - initialise");
131
132        // Acquire input... we could have lost focus if the
133                // user tabbed away during init or perhaps we're in
134                // the debugger.  In either case when the input is
135                // checked we will try to acquire again.
136                hr = mlpDIKeyboard->Acquire();
137                if (FAILED(hr) && hr != DIERR_OTHERAPPHASPRIO)
138            throw Exception(hr, "Unable to set aquire DirectInput keyboard device.",
139                "Win32Input8 - initialise");
140
141        LogManager::getSingleton().logMessage("Win32Input8: Keyboard input established.");
142        }
143
144    //-----------------------------------------------------------------------
145    void Win32Input8::initialiseImmediateKeyboard()
146        {
147        HRESULT hr;
148        LogManager::getSingleton().logMessage("Win32Input8: Establishing keyboard input.");
149
150        // Create keyboard device
151        hr = mlpDI->CreateDevice(GUID_SysKeyboard, &mlpDIKeyboard, NULL);
152
153
154        if (FAILED(hr))
155            throw Exception(hr, "Unable to create DirectInput keyboard device.",
156                "Win32Input8 - initialise");
157
158        // Set data format
159        hr = mlpDIKeyboard->SetDataFormat(&c_dfDIKeyboard);
160        if (FAILED(hr))
161            throw Exception(hr, "Unable to set DirectInput keyboard device data format.",
162                "Win32Input8 - initialise");
163
164        // Make the window grab keyboard behaviour when foreground
165        // NB Keyboard is never exclusive
166        hr = mlpDIKeyboard->SetCooperativeLevel(mHWnd,
167                   DISCL_BACKGROUND | DISCL_NONEXCLUSIVE);
168        if (FAILED(hr))
169            throw Exception(hr, "Unable to set DirectInput keyboard device co-operative level.",
170                "Win32Input8 - initialise");
171
172                // IMPORTANT STEP TO USE BUFFERED DEVICE DATA!
173                //
174                // DirectInput uses unbuffered I/O (buffer size = 0) by default.
175                // If you want to read buffered data, you need to set a nonzero
176                // buffer size.
177                //
178                // Set the buffer size to DINPUT_BUFFERSIZE (defined above) elements.
179                //
180                // The buffer size is a DWORD property associated with the device.
181                DIPROPDWORD dipdw;
182
183                dipdw.diph.dwSize       = sizeof(DIPROPDWORD);
184                dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
185                dipdw.diph.dwObj        = 0;
186                dipdw.diph.dwHow        = DIPH_DEVICE;
187                dipdw.dwData            = DINPUT_BUFFERSIZE ; // Arbitary buffer size
188
189                hr = mlpDIKeyboard->SetProperty( DIPROP_BUFFERSIZE, &dipdw.diph ) ;
190
191        if (FAILED(hr))
192            throw Exception(hr, "Unable to create DirectInput keyboard buffer.",
193                "Win32Input8 - initialise");
194
195
196        // Acquire input... we could have lost focus if the
197                // user tabbed away during init or perhaps we're in
198                // the debugger.  In either case when the input is
199                // checked we will try to acquire again.        hr = mlpDIKeyboard->Acquire();
200                if (FAILED(hr) && hr != DIERR_OTHERAPPHASPRIO)
201            throw Exception(hr, "Unable to set aquire DirectInput keyboard device.",
202                "Win32Input8 - initialise");
203
204        LogManager::getSingleton().logMessage("Win32Input8: Keyboard input established.");
205        }
206    //-----------------------------------------------------------------------
207    void Win32Input8::initialiseImmediateMouse()
208        {
209        OgreGuard( "Win32Input8::initialiseImmediateMouse" );
210
211        HRESULT hr;
212        DIPROPDWORD dipdw;
213        LogManager::getSingleton().logMessage( "Win32Input8: Initializing mouse input in immediate mode." );
214
215        dipdw.diph.dwSize       = sizeof(DIPROPDWORD);
216        dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
217        dipdw.diph.dwObj        = 0;
218        dipdw.diph.dwHow        = DIPH_DEVICE;
219        dipdw.dwData            = DIPROPAXISMODE_ABS;
220
221        if( /* Create the DI Device. */
222            FAILED( hr = mlpDI->CreateDevice( GUID_SysMouse, &mlpDIMouse, NULL ) ) ||
223            /* Set the data format so that it knows it's a mouse. */
224            FAILED( hr = mlpDIMouse->SetDataFormat( &c_dfDIMouse2 ) ) ||
225            /* Absolute mouse input. We can derive the relative input from this. */
226            FAILED( hr = mlpDIMouse->SetProperty( DIPROP_AXISMODE, &dipdw.diph ) ) ||
227            /* Exclusive when in foreground, steps back when in background. */
228            FAILED( hr = mlpDIMouse->SetCooperativeLevel( mHWnd, DISCL_FOREGROUND | DISCL_EXCLUSIVE ) ) )
229        {
230            OGRE_EXCEPT( hr, "Unable to initialise mouse", "Win32Input8::initialiseImmediateMouse" );
231        }
232        /* Note that we did not acquire the mouse in the code above, since the call may fail (ie you're in the
233           debugger) and an exception would be thrown. Acquisition happens in the captureMouse() function. */
234
235        /* Get initial mouse data. We might as well fail this initial attempt, so no biggie. */
236        captureMouse();
237
238        /* Clear any relative mouse data. */
239        mMouseState.Xrel = mMouseState.Yrel = mMouseState.Zrel = 0;
240
241        LogManager::getSingleton().logMessage( "Win32Input8: Mouse input in immediate mode initialized." );
242
243        OgreUnguard();
244        }
245
246    //-----------------------------------------------------------------------
247    void Win32Input8::initialiseBufferedMouse()
248        {
249        HRESULT hr;
250        LogManager::getSingleton().logMessage("Win32Input8: Establishing mouse input.");
251
252        // Create mouse device
253        hr = mlpDI->CreateDevice(GUID_SysMouse, &mlpDIMouse, NULL);
254
255
256        if (FAILED(hr))
257            throw Exception(hr, "Unable to create DirectInput mouse device.",
258                "Win32Input8 - initialise");
259
260        // Set data format
261        hr = mlpDIMouse->SetDataFormat(&c_dfDIMouse2);
262        if (FAILED(hr))
263            throw Exception(hr, "Unable to set DirectInput mouse device data format.",
264                "Win32Input8 - initialise");
265
266        // Make the window grab mouse behaviour when foreground
267        hr = mlpDIMouse->SetCooperativeLevel(mHWnd,
268                   DISCL_FOREGROUND | DISCL_EXCLUSIVE);
269        if (FAILED(hr))
270            throw Exception(hr, "Unable to set DirectInput mouse device co-operative level.",
271                "Win32Input8 - initialise");
272
273
274                // IMPORTANT STEP TO USE BUFFERED DEVICE DATA!
275                //
276                // DirectInput uses unbuffered I/O (buffer size = 0) by default.
277                // If you want to read buffered data, you need to set a nonzero
278                // buffer size.
279                //
280                // Set the buffer size to SAMPLE_BUFFER_SIZE (defined above) elements.
281                //
282                // The buffer size is a DWORD property associated with the device.
283                DIPROPDWORD dipdw;
284                dipdw.diph.dwSize       = sizeof(DIPROPDWORD);
285                dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
286                dipdw.diph.dwObj        = 0;
287                dipdw.diph.dwHow        = DIPH_DEVICE;
288                dipdw.dwData            = DINPUT_BUFFERSIZE; // Arbitary buffer size
289
290                hr = mlpDIMouse->SetProperty( DIPROP_BUFFERSIZE, &dipdw.diph );
291
292        if (FAILED(hr))
293            throw Exception(hr, "Unable to create DirectInput mouse buffer.",
294                "Win32Input8 - initialise");
295
296        // Acquire input... we could have lost focus if the
297                // user tabbed away during init or perhaps we're in
298                // the debugger.  In either case when the input is
299                // checked we will try to acquire again.
300                hr = mlpDIMouse->Acquire();
301        if (FAILED(hr) && hr != DIERR_OTHERAPPHASPRIO)
302            throw Exception(hr, "Unable to set aquire DirectInput mouse device.",
303                "Win32Input8 - initialise");
304
305        LogManager::getSingleton().logMessage("Win32Input8: Mouse input established.");
306
307        }
308
309    //-----------------------------------------------------------------------
310    void Win32Input8::initialise(RenderWindow* pWindow, bool useKeyboard, bool useMouse, bool useGameController)
311    {
312        HRESULT hr;
313
314                mUseKeyboard = useKeyboard;
315                mUseMouse = useMouse;
316        LogManager::getSingleton().logMessage("Win32Input8: DirectInput Activation Starts");
317
318        // Get HINST
319        HINSTANCE hInst = GetModuleHandle(OGRE_PLATFORM_LIB);
320
321        // Get HWND
322        HWND hWnd = GetActiveWindow();
323
324        mHWnd = hWnd;
325
326        ShowCursor(FALSE);
327
328
329    // Register with the DirectInput subsystem and get a pointer
330    // to a IDirectInput interface we can use.
331    // Create a DInput object
332                hr = DirectInput8Create( hInst, DIRECTINPUT_VERSION, IID_IDirectInput8, (VOID**)&mlpDI, NULL );
333        if (FAILED(hr))
334            throw Exception(hr, "Unable to initialise DirectInput.",
335                "Win32Input8 - initialise");
336
337                if (useKeyboard)
338                {
339                        if (mUseBufferedKeys)
340                        {
341                                initialiseBufferedKeyboard();
342                        }
343                        else
344                        {
345                                initialiseImmediateKeyboard();
346                        }
347                }
348
349                if (useMouse)
350                {
351                        if (mUseBufferedMouse)
352                        {
353                                initialiseBufferedMouse();
354                        }
355                        else
356                        {
357                                initialiseImmediateMouse();
358                        }
359                }
360
361
362        LogManager::getSingleton().logMessage("Win32Input8: DirectInput OK.");
363
364    }
365
366/*        void Win32Input8::setBufferedInput(bool keys, bool mouse)
367    {
368                  flushAllBuffers();
369                  InputReader::setBufferedInput(keys, mouse);
370        }
371*/
372        void Win32Input8::flushAllBuffers()
373        {
374
375                DWORD dwItems = INFINITE;
376                HRESULT hr = mlpDIKeyboard->GetDeviceData( sizeof(DIDEVICEOBJECTDATA),
377                                                                                 NULL, &dwItems, 0 );
378                hr = mlpDIMouse->GetDeviceData( sizeof(DIDEVICEOBJECTDATA),
379                                                                                 NULL, &dwItems, 0 );
380        }
381
382    //-----------------------------------------------------------------------
383
384        // this function is not needed at the moment because we are making everything buffered
385          void Win32Input8::setBufferedInput(bool keys, bool mouse)
386    {
387                if (mUseKeyboard && mUseBufferedKeys != keys)
388                {
389                        if (mlpDIKeyboard)
390                        {
391                            mlpDIKeyboard->Unacquire();
392                            mlpDIKeyboard->Release();
393                                mlpDIKeyboard = 0;
394                        }
395                        if (keys)
396                        {
397                                initialiseBufferedKeyboard();
398                        }
399                        else
400                        {
401                                initialiseImmediateKeyboard();
402                        }
403
404                }
405                if (mUseMouse && mUseBufferedMouse != mouse)
406                {
407                        if (mlpDIMouse)
408                        {
409                            mlpDIMouse->Unacquire();
410                            mlpDIMouse->Release();
411                                mlpDIMouse= 0;
412                        }
413                        if (mouse)
414                        {
415                                initialiseBufferedMouse();
416                        }
417                        else
418                        {
419                                initialiseImmediateMouse();
420                        }
421
422                }
423                InputReader::setBufferedInput(keys,mouse);
424    }
425
426    //-----------------------------------------------------------------------
427    void Win32Input8::capture(void)
428    {
429                if (mUseKeyboard)
430                {
431                        if (mUseBufferedKeys )
432                        {
433                                readBufferedKeyboardData();
434                        }
435                        else
436                        {
437                                mModifiers = getKeyModifiers();
438                                captureKeyboard();
439                        }
440                }
441                if (mUseMouse)
442                {
443                        if (mUseBufferedMouse )
444                        {
445                                readBufferedMouseData();
446                        }
447                        else
448                        {
449                                captureMouse();
450                        }
451                }
452
453        }
454    //-----------------------------------------------------------------------
455    void Win32Input8::captureKeyboard(void)
456    {
457        HRESULT  hr;
458
459        // Get keyboard state
460        hr = mlpDIKeyboard->GetDeviceState(sizeof(mKeyboardBuffer),(LPVOID)&mKeyboardBuffer);
461        if (hr == DIERR_INPUTLOST || hr == DIERR_NOTACQUIRED)
462        {
463            hr = mlpDIKeyboard->Acquire();
464            if (hr == DIERR_OTHERAPPHASPRIO)
465            {
466                hr = 0;
467            }
468            else
469            {
470                hr = mlpDIKeyboard->GetDeviceState(sizeof(mKeyboardBuffer),(LPVOID)&mKeyboardBuffer);
471            }
472        }
473        else if (hr == DIERR_OTHERAPPHASPRIO)
474        {
475            // We've gone into the background - ignore
476            hr = 0;
477        }
478        else if (hr == DIERR_NOTINITIALIZED)
479        {
480            hr = 0;
481        }
482        else if (hr == E_PENDING)
483        {
484            hr = 0;
485        }
486        else if (FAILED(hr))
487        {
488            // Ignore for now
489            // TODO - sort this out
490            hr = 0;
491        }
492
493        }
494
495    //-----------------------------------------------------------------------
496    void Win32Input8::captureMouse(void)
497    {
498        DIMOUSESTATE2 mouseState;
499        HRESULT hr;
500
501        // Get mouse state
502        hr = mlpDIMouse->GetDeviceState( sizeof( DIMOUSESTATE2 ), (LPVOID)&mouseState );
503
504        if( SUCCEEDED( hr ) ||
505            ( ( hr == DIERR_INPUTLOST || hr == DIERR_NOTACQUIRED ) &&
506              SUCCEEDED( mlpDIMouse->Acquire() ) &&
507              SUCCEEDED( mlpDIMouse->GetDeviceState( sizeof( DIMOUSESTATE2 ), (LPVOID)&mouseState ) ) ) )
508        {
509            /* Register the new 'origin'. */
510            mMouseCenterX = mMouseState.Xabs;
511            mMouseCenterY = mMouseState.Yabs;
512            mMouseCenterZ = mMouseState.Zabs;
513
514            /* Get the new absolute position. */
515            mMouseState.Xabs = mouseState.lX;
516            mMouseState.Yabs = mouseState.lY;
517            mMouseState.Zabs = mouseState.lZ;
518
519            /* Compute the new relative position. */
520            mMouseState.Xrel = mMouseState.Xabs - mMouseCenterX;
521            mMouseState.Yrel = mMouseState.Yabs - mMouseCenterY;
522            mMouseState.Zrel = mMouseState.Zabs - mMouseCenterZ;
523
524            /* Get the mouse buttons. This for loop can be unwrapped for speed. */
525            mMouseState.Buttons = 0;
526            for( size_t i = 0; i < 8; i++ )
527                if( mouseState.rgbButtons[ i ] & 0x80 )
528                    mMouseState.Buttons |= ( 1 << i );
529        }
530        else if (hr == DIERR_OTHERAPPHASPRIO)
531        {
532            // We've gone into the background - ignore
533            hr = 0;
534        }
535        else if (hr == DIERR_NOTINITIALIZED)
536        {
537            hr = 0;
538        }
539        else if (hr == E_PENDING)
540        {
541            hr = 0;
542        }
543        else if (FAILED(hr))
544        {
545            // Ignore for now
546            // TODO - sort this out
547            hr = 0;
548        }
549
550   }
551
552
553
554        //-----------------------------------------------------------------------------
555        // Name: readBufferedData()
556        // Desc: Read the input device's state when in buffered mode and display it.
557        //-----------------------------------------------------------------------------
558        bool Win32Input8::readBufferedKeyboardData()
559        {
560                DIDEVICEOBJECTDATA didod[ DINPUT_BUFFERSIZE ];  // Receives buffered data
561                DWORD              dwElements;
562                HRESULT            hr;
563
564                if( NULL == mlpDIKeyboard )
565                        return true;
566
567                dwElements = DINPUT_BUFFERSIZE;
568
569                hr = mlpDIKeyboard->GetDeviceData( sizeof(DIDEVICEOBJECTDATA),
570                                                                                 didod, &dwElements, 0 );
571                if( FAILED(hr) )
572                {
573                        // Error
574                        hr = mlpDIKeyboard->Acquire();
575                        while( hr == DIERR_INPUTLOST )
576                                hr = mlpDIKeyboard->Acquire();
577
578                        // hr may be DIERR_OTHERAPPHASPRIO or other errors.  This
579                        // may occur when the app is minimized or in the process of
580                        // switching, so just try again later
581                        return !FAILED(hr);
582                }
583
584                // DI_BUFFEROVERFLOW we don't do anything with since we still want to
585                // process what's in the buffer
586
587                for(unsigned int i = 0; i < dwElements; i++ )
588                {
589                        keyChanged( didod[ i ].dwOfs, (didod[ i ].dwData & 0x80) != 0);
590                }
591                return true;
592        }
593
594        //-----------------------------------------------------------------------------
595        // Name: readBufferedData()
596        // Desc: Read the input device's state when in buffered mode and display it.
597        //-----------------------------------------------------------------------------
598        bool Win32Input8::readBufferedMouseData()
599        {
600                DIDEVICEOBJECTDATA didod[ DINPUT_BUFFERSIZE ];  // Receives buffered data
601                DWORD              dwElements;
602                HRESULT            hr;
603
604                if( NULL == mlpDIMouse )
605                        return true;
606
607                dwElements = DINPUT_BUFFERSIZE;
608
609        // Try to read the data. Continue normally on success (DI_OK
610        // or DI_BUFFEROVERFLOW) as we have to process the read data
611        // we got.
612                hr = mlpDIMouse->GetDeviceData( sizeof(DIDEVICEOBJECTDATA),
613                                                                                 didod, &dwElements, 0 );
614                if( FAILED(hr) )
615                {
616            // No need to handle DI_BUFFEROVERFLOW in ERROR handling.
617            // So moved it to later.
618            //
619                        // We got an error.
620                        //
621                        // It means that continuous contact with the
622                        // device has been lost, either due to an external
623                        // interruption.
624                        //
625
626                        hr = mlpDIMouse->Acquire();
627                        while( hr == DIERR_INPUTLOST )
628                                hr = mlpDIMouse->Acquire();
629
630                        // hr may be DIERR_OTHERAPPHASPRIO or other errors.  This
631                        // may occur when the app is minimized or in the process of
632                        // switching, so just try again later
633                        return !FAILED(hr);
634                }
635
636                // DI_BUFFEROVERFLOW we don't do anything with since we still want to
637                // process what's in the buffer
638
639                bool xSet = false;
640                bool ySet = false;
641                bool zSet = false;
642/// Redefine FIELD_OFFSET in case of GCC
643#ifdef __GNUC__
644    #undef FIELD_OFFSET
645    #define FIELD_OFFSET offsetof
646#endif // __GNUC__
647
648                for(unsigned int i = 0; i < dwElements; i++ )
649                {
650                        int nMouseCode = -1;            // not set
651
652                        // this will display then scan code of the key
653                        // plus a 'D' - meaning the key was pressed
654                        //   or a 'U' - meaning the key was released
655                        switch( didod [ i ].dwOfs )
656                        {
657                                case DIMOFS_BUTTON0:
658                                        nMouseCode = InputEvent::BUTTON0_MASK;
659                                        break;
660
661                                case DIMOFS_BUTTON1:
662                                        nMouseCode = InputEvent::BUTTON1_MASK;
663                                        break;
664
665                                case DIMOFS_BUTTON2:
666                                        nMouseCode = InputEvent::BUTTON2_MASK;
667                                        break;
668
669                                case DIMOFS_BUTTON3:
670                                        nMouseCode = InputEvent::BUTTON3_MASK;
671                                        break;
672
673                                case DIMOFS_X:
674                                        if (xSet)
675                                        {       // process the last X move since we have a new one
676                                                mouseMoved();
677                                                xSet = false;
678                                        }
679                                        mCursor->addToX(getScaled(didod[i].dwData));
680                                        xSet = true;
681                                        break;
682
683                                case DIMOFS_Y:
684                                        if (ySet)
685                                        {
686                                                mouseMoved();
687                                                ySet = false;
688                                        }
689                                        mCursor->addToY(getScaled(didod[i].dwData));
690                                        ySet = true;
691                                        break;
692
693                                case DIMOFS_Z:
694                                        if (zSet)
695                                        {
696                                                mouseMoved();
697                                                zSet = false;
698                                        }
699                                        mCursor->addToZ(getScaled(didod[i].dwData));
700                                        zSet = true;
701                                        break;
702
703                                default:
704                                        break;
705                        }
706                        if (nMouseCode != -1)
707                        {
708                                triggerMouseButton(nMouseCode, (didod [ i ].dwData & 0x80) != 0);
709                        }
710                        if (xSet && ySet)       // don't create 2 mousemove events for an single X and Y move, just create 1.
711                        {
712                                mouseMoved();
713                                ySet = false;
714                                xSet = false;
715                        }
716
717
718                }
719                if (zSet || xSet || ySet) // check for last moved at end
720                {
721                        mouseMoved();
722                }
723
724                return true;
725        }
726    //-----------------------------------------------------------------------
727
728        Real Win32Input8::getScaled(DWORD dwVal) const
729        {
730                return (Real)((int)dwVal) * mMouseScale;
731        }
732
733    //-----------------------------------------------------------------------
734    bool Win32Input8::isKeyDownImmediate(KeyCode kc) const
735    {
736        return ( mKeyboardBuffer[ kc ] & 0x80 ) != 0;
737    }
738
739    //---------------------------------------------------------------------------------------------
740    long Win32Input8::getMouseRelX() const
741    {
742        return mMouseState.Xrel;
743    }
744
745    //---------------------------------------------------------------------------------------------
746    long Win32Input8::getMouseRelY() const
747    {
748        return mMouseState.Yrel;
749    }
750
751    //---------------------------------------------------------------------------------------------
752    long Win32Input8::getMouseRelZ() const
753    {
754        return mMouseState.Zrel;
755    }
756
757    long Win32Input8::getMouseAbsX() const
758    {
759        return mMouseState.Xabs;
760    }
761
762    long Win32Input8::getMouseAbsY() const
763    {
764        return mMouseState.Yabs;
765    }
766
767    long Win32Input8::getMouseAbsZ() const
768    {
769        return mMouseState.Zabs;
770    }
771
772    //---------------------------------------------------------------------------------------------
773    bool Win32Input8::getMouseButton( uchar button ) const
774    {
775        return mMouseState.isButtonDown( button ) != 0;
776    }
777
778    //---------------------------------------------------------------------------------------------
779    void Win32Input8::getMouseState( MouseState& state ) const
780    {
781        memcpy( &state, &mMouseState, sizeof( MouseState ) );
782    }
783
784    //---------------------------------------------------------------------------------------------
785        long Win32Input8::getKeyModifiers() const
786        {
787                long ret = mModifiers;
788
789                if (isKeyDown(KC_LMENU) || isKeyDown(KC_RMENU))
790                {
791                        ret |= InputEvent::ALT_MASK;
792                }
793                else
794                {
795                        ret &= ~InputEvent::ALT_MASK;
796                }
797
798                if (isKeyDown(KC_LSHIFT) || isKeyDown(KC_RSHIFT))
799                {
800                        ret |= InputEvent::SHIFT_MASK;
801                }
802                else
803                {
804                        ret &= ~InputEvent::SHIFT_MASK;
805                }
806
807                if (isKeyDown(KC_LCONTROL) || isKeyDown(KC_LCONTROL))
808                {
809                        ret |= InputEvent::CTRL_MASK;
810                }
811                else
812                {
813                        ret &= ~InputEvent::CTRL_MASK;
814                }
815
816                return ret;
817        }
818
819} // namespace
820#endif
821#endif
Note: See TracBrowser for help on using the repository browser.