This file is indexed.

/usr/include/cegui-0.8.7/CEGUI/RendererModules/Irrlicht/EventPusher.h is in libcegui-mk2-dev 0.8.7-1.3+b2.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
/***********************************************************************
    created:    12/22/2004
    author:     Thomas Suter
*************************************************************************/
/***************************************************************************
 *   Copyright (C) 2004 - 2009 Paul D Turner & The CEGUI Development Team
 *
 *   Permission is hereby granted, free of charge, to any person obtaining
 *   a copy of this software and associated documentation files (the
 *   "Software"), to deal in the Software without restriction, including
 *   without limitation the rights to use, copy, modify, merge, publish,
 *   distribute, sublicense, and/or sell copies of the Software, and to
 *   permit persons to whom the Software is furnished to do so, subject to
 *   the following conditions:
 *
 *   The above copyright notice and this permission notice shall be
 *   included in all copies or substantial portions of the Software.
 *
 *   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 *   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 *   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 *   IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 *   OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 *   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 *   OTHER DEALINGS IN THE SOFTWARE.
 ***************************************************************************/
#ifndef CCEGUIEVENTPUSHER_H_INCLUDED
#define CCEGUIEVENTPUSHER_H_INCLUDED

#include "../../CEGUI.h"
#include <irrlicht.h>

namespace CEGUI
{
using namespace irr;

class IrrlichtEventPusher
{
    gui::ICursorControl* d_cursorctrl;

public :
    IrrlichtEventPusher(irr::gui::ICursorControl* ctrl) :
        d_cursorctrl(ctrl)
    {
        initCodes();
    };

    virtual ~IrrlichtEventPusher(){};

    bool OnEvent(const SEvent& event)
    {
        switch (event.EventType)
        {
        case EET_KEY_INPUT_EVENT :
            if (event.KeyInput.PressedDown)
                return OnKeyDown(event.KeyInput.Key, event.KeyInput.Char, event.KeyInput.Control, event.KeyInput.Shift);
            else
                return OnKeyUp(event.KeyInput.Key, event.KeyInput.Char, event.KeyInput.Control, event.KeyInput.Shift);
            break;

        case EET_MOUSE_INPUT_EVENT :
            return OnMouse(event.MouseInput.X, event.MouseInput.Y, event.MouseInput.Wheel, event.MouseInput.Event);
            break;

        default:
            break;
        }

        return false;
    }

    bool OnKeyDown(EKEY_CODE key, wchar_t wch, bool /*ctrl*/, bool /*shift*/)
    {
        bool handled = false;
        CEGUI::GUIContext& cegui = CEGUI::System::getSingleton().getDefaultGUIContext();
        handled = cegui.injectKeyDown(getKeyCode(key));
        handled = cegui.injectChar(wch) || handled;
        return handled;
    }

    bool OnKeyUp(EKEY_CODE key, wchar_t /*wch*/, bool /*ctrl*/, bool /*shift*/)
    {
        bool handled = false;
        CEGUI::GUIContext& cegui = CEGUI::System::getSingleton().getDefaultGUIContext();
        handled = cegui.injectKeyUp(getKeyCode(key));
        return handled;
    }

    bool OnMouse(s32 x, s32 y, f32 w, EMOUSE_INPUT_EVENT e)
    {
        using namespace irr;
        bool handled = false;

        switch (e)
        {
            //! Left mouse button was pressed down.
        case EMIE_LMOUSE_PRESSED_DOWN:
            handled = CEGUI::System::getSingleton().getDefaultGUIContext().injectMouseButtonDown(CEGUI::LeftButton);
            break;
            //! Right mouse button was pressed down.
        case EMIE_RMOUSE_PRESSED_DOWN:
            handled = CEGUI::System::getSingleton().getDefaultGUIContext().injectMouseButtonDown(CEGUI::RightButton);
            break;
            //! Middle mouse button was pressed down.
        case EMIE_MMOUSE_PRESSED_DOWN:
            handled = CEGUI::System::getSingleton().getDefaultGUIContext().injectMouseButtonDown(CEGUI::MiddleButton);
            break;
            //! Left mouse button was left up.
        case EMIE_LMOUSE_LEFT_UP:
            handled = CEGUI::System::getSingleton().getDefaultGUIContext().injectMouseButtonUp(CEGUI::LeftButton);
            break;
            //! Right mouse button was left up.
        case EMIE_RMOUSE_LEFT_UP:
            handled = CEGUI::System::getSingleton().getDefaultGUIContext().injectMouseButtonUp(CEGUI::RightButton);
            break;
            //! Middle mouse button was left up.
        case EMIE_MMOUSE_LEFT_UP:
            handled = CEGUI::System::getSingleton().getDefaultGUIContext().injectMouseButtonUp(CEGUI::MiddleButton);
            break;
            //! The mouse cursor changed its position.
        case EMIE_MOUSE_MOVED:
            handled = CEGUI::System::getSingleton().getDefaultGUIContext().injectMousePosition(
                        static_cast<float>(x), static_cast<float>(y));
            break;
            //! The mouse wheel was moved. Use Wheel value in event data to find out
            //! in what direction and how fast.
        case EMIE_MOUSE_WHEEL:
            handled = CEGUI::System::getSingleton().getDefaultGUIContext().injectMouseWheelChange(w);
            break;
        default:
            break;
        }
        return handled;

    }

    /*! translate the irrlicht keycode to cegui keycode
    \param kc
    the irrlicht keycode

    \return
    the cegui keycode
    */
    CEGUI::Key::Scan getKeyCode(irr::EKEY_CODE kc) const
    {
        return irr2ceCODE[kc];
    }

protected:
    CEGUI::Key::Scan irr2ceCODE[irr::KEY_KEY_CODES_COUNT];

    void initCodes()
    {
        using namespace irr;
        memset(irr2ceCODE, Key::Unknown, KEY_KEY_CODES_COUNT);

        irr2ceCODE[KEY_LBUTTON   ] = Key::Unknown;  // Left mouse button
        irr2ceCODE[KEY_RBUTTON   ] = Key::Unknown;  // Right mouse button
        irr2ceCODE[KEY_CANCEL    ] = Key::Unknown;  // Control-break processing
        irr2ceCODE[KEY_MBUTTON   ] = Key::Unknown;  // Middle mouse button (three-button mouse)
        irr2ceCODE[KEY_XBUTTON1  ] = Key::Unknown;  // Windows 2000/XP: X1 mouse button
        irr2ceCODE[KEY_XBUTTON2  ] = Key::Unknown;  // Windows 2000/XP: X2 mouse button
        irr2ceCODE[KEY_BACK      ] = Key::Backspace; //0x08;  // BACKSPACE key
        irr2ceCODE[KEY_TAB       ] = Key::Tab; //0x09;  // TAB key
        irr2ceCODE[KEY_CLEAR     ] = Key::Unknown;  // CLEAR key
        irr2ceCODE[KEY_RETURN    ] = Key::Return; //0x0D;  // ENTER key
        irr2ceCODE[KEY_SHIFT     ] = Key::LeftShift;  // SHIFT key
        irr2ceCODE[KEY_CONTROL   ] = Key::LeftControl;   // CTRL key
        irr2ceCODE[KEY_MENU      ] = Key::LeftAlt;  // ALT key
        irr2ceCODE[KEY_PAUSE     ] = Key::Pause;   // PAUSE key
        irr2ceCODE[KEY_CAPITAL   ] = Key::Capital;  // CAPS LOCK key
        irr2ceCODE[KEY_KANA      ] = Key::Kana;  // IME Kana mode
        irr2ceCODE[KEY_HANGUEL   ] = Key::Unknown;  // IME Hanguel mode
        irr2ceCODE[KEY_HANGUL    ] = Key::Unknown;  // IME Hangul mode
        irr2ceCODE[KEY_JUNJA     ] = Key::Unknown;  // IME Junja mode
        irr2ceCODE[KEY_FINAL     ] = Key::Unknown;  // IME final mode
        irr2ceCODE[KEY_HANJA     ] = Key::Unknown;  // IME Hanja mode
        irr2ceCODE[KEY_KANJI     ] = Key::Unknown;  // IME Kanji mode
        irr2ceCODE[KEY_ESCAPE    ] = Key::Escape;  // ESC key
        irr2ceCODE[KEY_CONVERT   ] = Key::Convert;  // IME convert
        irr2ceCODE[KEY_NONCONVERT] = Key::NoConvert;  // IME nonconvert
        irr2ceCODE[KEY_ACCEPT    ] = Key::Unknown;  // IME accept
        irr2ceCODE[KEY_MODECHANGE] = Key::Unknown;  // IME mode change request
        irr2ceCODE[KEY_SPACE     ] = Key::Space;  // SPACEBAR
        irr2ceCODE[KEY_PRIOR     ] = Key::PageUp;  // PAGE UP key
        irr2ceCODE[KEY_NEXT      ] = Key::PageDown;  // PAGE DOWN key
        irr2ceCODE[KEY_END       ] = Key::End;  // END key
        irr2ceCODE[KEY_HOME      ] = Key::Home;  // HOME key
        irr2ceCODE[KEY_LEFT      ] = Key::ArrowLeft;  // LEFT ARROW key
        irr2ceCODE[KEY_UP        ] = Key::ArrowUp;  // UP ARROW key
        irr2ceCODE[KEY_RIGHT     ] = Key::ArrowRight;  // RIGHT ARROW key
        irr2ceCODE[KEY_DOWN      ] = Key::ArrowDown;  // DOWN ARROW key
        irr2ceCODE[KEY_SELECT    ] = Key::Unknown;  // SELECT key
        irr2ceCODE[KEY_PRINT     ] = Key::SysRq;  // PRINT key
        irr2ceCODE[KEY_EXECUT    ] = Key::Unknown;  // EXECUTE key
        irr2ceCODE[KEY_SNAPSHOT  ] = Key::Unknown;  // PRINT SCREEN key
        irr2ceCODE[KEY_INSERT    ] = Key::Insert;//0x2D;  // INS key
        irr2ceCODE[KEY_DELETE    ] = Key::Delete;//0x2E;  // DEL key
        irr2ceCODE[KEY_HELP      ] = Key::Unknown;  // HELP key
        irr2ceCODE[KEY_KEY_0     ] = Key::Zero;   // 0 key
        irr2ceCODE[KEY_KEY_1     ] = Key::One;    // 1 key
        irr2ceCODE[KEY_KEY_2     ] = Key::Two;    // 2 key
        irr2ceCODE[KEY_KEY_3     ] = Key::Three;  // 3 key
        irr2ceCODE[KEY_KEY_4     ] = Key::Four;   // 4 key
        irr2ceCODE[KEY_KEY_5     ] = Key::Five;   // 5 key
        irr2ceCODE[KEY_KEY_6     ] = Key::Six;    // 6 key
        irr2ceCODE[KEY_KEY_7     ] = Key::Seven;  // 7 key
        irr2ceCODE[KEY_KEY_8     ] = Key::Eight;  // 8 key
        irr2ceCODE[KEY_KEY_9     ] = Key::Nine;   // 9 key
        irr2ceCODE[KEY_KEY_A     ] = Key::A;  // A key
        irr2ceCODE[KEY_KEY_B     ] = Key::B;  // B key
        irr2ceCODE[KEY_KEY_C     ] = Key::C;  // C key
        irr2ceCODE[KEY_KEY_D     ] = Key::D;  // D key
        irr2ceCODE[KEY_KEY_E     ] = Key::E;  // E key
        irr2ceCODE[KEY_KEY_F     ] = Key::F;  // F key
        irr2ceCODE[KEY_KEY_G     ] = Key::G;  // G key
        irr2ceCODE[KEY_KEY_H     ] = Key::H;  // H key
        irr2ceCODE[KEY_KEY_I     ] = Key::I;  // I key
        irr2ceCODE[KEY_KEY_J     ] = Key::J;  // J key
        irr2ceCODE[KEY_KEY_K     ] = Key::K;  // K key
        irr2ceCODE[KEY_KEY_L     ] = Key::L;  // L key
        irr2ceCODE[KEY_KEY_M     ] = Key::M;  // M key
        irr2ceCODE[KEY_KEY_N     ] = Key::N;  // N key
        irr2ceCODE[KEY_KEY_O     ] = Key::O;  // O key
        irr2ceCODE[KEY_KEY_P     ] = Key::P;  // P key
        irr2ceCODE[KEY_KEY_Q     ] = Key::Q;  // Q key
        irr2ceCODE[KEY_KEY_R     ] = Key::R;  // R key
        irr2ceCODE[KEY_KEY_S     ] = Key::S;  // S key
        irr2ceCODE[KEY_KEY_T     ] = Key::T;  // T key
        irr2ceCODE[KEY_KEY_U     ] = Key::U;  // U key
        irr2ceCODE[KEY_KEY_V     ] = Key::V;  // V key
        irr2ceCODE[KEY_KEY_W     ] = Key::W;  // W key
        irr2ceCODE[KEY_KEY_X     ] = Key::X;  // X key
        irr2ceCODE[KEY_KEY_Y     ] = Key::Y;  // Y key
        irr2ceCODE[KEY_KEY_Z     ] = Key::Z;  // Z key
        irr2ceCODE[KEY_LWIN      ] = Key::LeftWindows;  // Left Windows key (Microsoft� Natural� keyboard)
        irr2ceCODE[KEY_RWIN      ] = Key::RightWindows;  // Right Windows key (Natural keyboard)
        irr2ceCODE[KEY_APPS      ] = Key::AppMenu;  //Applications key (Natural keyboard)
        irr2ceCODE[KEY_SLEEP     ] = Key::Sleep;  // Computer Sleep key
        irr2ceCODE[KEY_NUMPAD0   ] = Key::Numpad0;  // Numeric keypad 0 key
        irr2ceCODE[KEY_NUMPAD1   ] = Key::Numpad1;  // Numeric keypad 1 key
        irr2ceCODE[KEY_NUMPAD2   ] = Key::Numpad2;  // Numeric keypad 2 key
        irr2ceCODE[KEY_NUMPAD3   ] = Key::Numpad3;  // Numeric keypad 3 key
        irr2ceCODE[KEY_NUMPAD4   ] = Key::Numpad4;  // Numeric keypad 4 key
        irr2ceCODE[KEY_NUMPAD5   ] = Key::Numpad5;  // Numeric keypad 5 key
        irr2ceCODE[KEY_NUMPAD6   ] = Key::Numpad6;  // Numeric keypad 6 key
        irr2ceCODE[KEY_NUMPAD7   ] = Key::Numpad7;  // Numeric keypad 7 key
        irr2ceCODE[KEY_NUMPAD8   ] = Key::Numpad8;  // Numeric keypad 8 key
        irr2ceCODE[KEY_NUMPAD9   ] = Key::Numpad9;  // Numeric keypad 9 key
        irr2ceCODE[KEY_MULTIPLY  ] = Key::Multiply;  // Multiply key
        irr2ceCODE[KEY_ADD       ] = Key::Add;  // Add key
        irr2ceCODE[KEY_SEPARATOR ] = Key::Unknown;  // Separator key
        irr2ceCODE[KEY_SUBTRACT  ] = Key::Subtract;  // Subtract key
        irr2ceCODE[KEY_DECIMAL   ] = Key::Decimal;  // Decimal key
        irr2ceCODE[KEY_DIVIDE    ] = Key::Divide;  // Divide key
        irr2ceCODE[KEY_F1        ] = Key::F1;   // F1 key
        irr2ceCODE[KEY_F2        ] = Key::F2;   // F2 key
        irr2ceCODE[KEY_F3        ] = Key::F3;   // F3 key
        irr2ceCODE[KEY_F4        ] = Key::F4;   // F4 key
        irr2ceCODE[KEY_F5        ] = Key::F5;   // F5 key
        irr2ceCODE[KEY_F6        ] = Key::F6;   // F6 key
        irr2ceCODE[KEY_F7        ] = Key::F7;   // F7 key
        irr2ceCODE[KEY_F8        ] = Key::F8;   // F8 key
        irr2ceCODE[KEY_F9        ] = Key::F9;   // F9 key
        irr2ceCODE[KEY_F10       ] = Key::F10;  // F10 key
        irr2ceCODE[KEY_F11       ] = Key::F11;  // F11 key
        irr2ceCODE[KEY_F12       ] = Key::F12;  // F12 key
        irr2ceCODE[KEY_F13       ] = Key::F13;  // F13 key
        irr2ceCODE[KEY_F14       ] = Key::F14;  // F14 key
        irr2ceCODE[KEY_F15       ] = Key::F15;  // F15 key
        irr2ceCODE[KEY_F16       ] = Key::Unknown;  // F16 key
        irr2ceCODE[KEY_F17       ] = Key::Unknown;  // F17 key
        irr2ceCODE[KEY_F18       ] = Key::Unknown;  // F18 key
        irr2ceCODE[KEY_F19       ] = Key::Unknown;  // F19 key
        irr2ceCODE[KEY_F20       ] = Key::Unknown;  // F20 key
        irr2ceCODE[KEY_F21       ] = Key::Unknown;  // F21 key
        irr2ceCODE[KEY_F22       ] = Key::Unknown;  // F22 key
        irr2ceCODE[KEY_F23       ] = Key::Unknown;  // F23 key
        irr2ceCODE[KEY_F24       ] = Key::Unknown;  // F24 key
        irr2ceCODE[KEY_NUMLOCK   ] = Key::NumLock;  // NUM LOCK key
        irr2ceCODE[KEY_SCROLL    ] = Key::ScrollLock;  // SCROLL LOCK key
        irr2ceCODE[KEY_LSHIFT    ] = Key::LeftShift;  // Left SHIFT key
        irr2ceCODE[KEY_RSHIFT    ] = Key::RightShift;  // Right SHIFT key
        irr2ceCODE[KEY_LCONTROL  ] = Key::LeftControl;  // Left CONTROL key
        irr2ceCODE[KEY_RCONTROL  ] = Key::RightControl;  // Right CONTROL key
        irr2ceCODE[KEY_LMENU     ] = Key::LeftAlt;  // Left MENU key
        irr2ceCODE[KEY_RMENU     ] = Key::RightAlt;  // Right MENU key
        irr2ceCODE[KEY_COMMA     ] = Key::Comma;//0xBC;  // Comma Key  (;)
        irr2ceCODE[KEY_PLUS      ] = Key::Add;  // Plus Key   (+)
        irr2ceCODE[KEY_MINUS     ] = Key::Minus;  // Minus Key  (-)
        irr2ceCODE[KEY_PERIOD    ] = Key::Period;//0xBE;  // Period Key (.)
        irr2ceCODE[KEY_ATTN      ] = Key::Unknown;  // Attn key
        irr2ceCODE[KEY_CRSEL     ] = Key::Unknown;  // CrSel key
        irr2ceCODE[KEY_EXSEL     ] = Key::Unknown;  // ExSel key
        irr2ceCODE[KEY_EREOF     ] = Key::Unknown;  // Erase EOF key
        irr2ceCODE[KEY_PLAY      ] = Key::Unknown;  // Play key
        irr2ceCODE[KEY_ZOOM      ] = Key::Unknown;  // Zoom key
        irr2ceCODE[KEY_PA1       ] = Key::Unknown;  // PA1 key
        irr2ceCODE[KEY_OEM_CLEAR ] = Key::Unknown;  // Clear key
    }

};

}

#endif