← Back to branch summary

~ubuntu-branches/ubuntu/wily/freerdp/wily-proposed

« back to all changes in this revision

Viewing changes to dfb/dfb_keyboard.c

  • Committer: Package Import Robot
  • Author(s): Martin Pitt, Jeremy Bicha, Jean-Louis Dupond, Martin Pitt
  • Date: 2012-01-31 10:02:14 UTC
  • mfrom: (1.1.6)
  • Revision ID: package-import@ubuntu.com-20120131100214-jaok3uwvni7sqxth
Tags: 1.0.0-0git1
http://bugs.debian.org/647498
Upload current Debian packaging git to get this rolling for precise.

[ Jeremy Bicha ]
* New upstream release. Closes: #647498.
* Updated symbols and bumped soname
* debian/control:
  - Added new build dependencies
  - Bump Standards-Version to 3.9.2
* debian/source/format: Set to 3.0 (quilt)
* debian/rules: Turn on strict symbols checking
* debian/watch: Watch github

[ Jean-Louis Dupond ]
* debian/control: Updated homepage
* debian/copyright: Reflect upstream switch to the Apache license

[ Martin Pitt ]
* debian/libfreerdp0.symbols: Fix version number, should
  be 1.0~beta5, not 1.0-beta5.
* debian/control: Add libavcodec-dev build dependency, upstream build system
  checks for that. Thanks Jean-Louis Dupond!

Show diffs side-by-side

added added

removed removed

Lines of Context:
dfb/dfb_keyboard.c
1
 
/* -*- c-basic-offset: 8 -*-
2
 
   FreeRDP: A Remote Desktop Protocol client.
3
 
   DirectFB UI Keyboard Handling
4
 
 
5
 
   Copyright (C) Marc-Andre Moreau <marcandre.moreau@gmail.com> 2010
6
 
 
7
 
   This program is free software; you can redistribute it and/or modify
8
 
   it under the terms of the GNU General Public License as published by
9
 
   the Free Software Foundation; either version 2 of the License, or
10
 
   (at your option) any later version.
11
 
 
12
 
   This program is distributed in the hope that it will be useful,
13
 
   but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
 
   GNU General Public License for more details.
16
 
 
17
 
   You should have received a copy of the GNU General Public License
18
 
   along with this program; if not, write to the Free Software
19
 
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20
 
*/
21
 
 
22
 
#include <stdio.h>
23
 
#include <stdlib.h>
24
 
#include <string.h>
25
 
#include "libfreerdpkbd/keyboard.h"
26
 
#include <freerdp/freerdp.h>
27
 
#include <freerdp/kbd.h>
28
 
#include "dfb_event.h"
29
 
 
30
 
unsigned char keymap[256];
31
 
        
32
 
void
33
 
dfb_kb_init(void)
34
 
{
35
 
        memset(keymap, 0, sizeof(keymap));
36
 
 
37
 
        /* Map DirectFB keycodes to Virtual Key Codes */
38
 
        
39
 
        keymap[DIKI_A - DIKI_UNKNOWN] = VK_KEY_A;
40
 
        keymap[DIKI_B - DIKI_UNKNOWN] = VK_KEY_B;
41
 
        keymap[DIKI_C - DIKI_UNKNOWN] = VK_KEY_C;
42
 
        keymap[DIKI_D - DIKI_UNKNOWN] = VK_KEY_D;
43
 
        keymap[DIKI_E - DIKI_UNKNOWN] = VK_KEY_E;
44
 
        keymap[DIKI_F - DIKI_UNKNOWN] = VK_KEY_F;
45
 
        keymap[DIKI_G - DIKI_UNKNOWN] = VK_KEY_G;
46
 
        keymap[DIKI_H - DIKI_UNKNOWN] = VK_KEY_H;
47
 
        keymap[DIKI_I - DIKI_UNKNOWN] = VK_KEY_I;
48
 
        keymap[DIKI_J - DIKI_UNKNOWN] = VK_KEY_J;
49
 
        keymap[DIKI_K - DIKI_UNKNOWN] = VK_KEY_K;
50
 
        keymap[DIKI_L - DIKI_UNKNOWN] = VK_KEY_L;
51
 
        keymap[DIKI_M - DIKI_UNKNOWN] = VK_KEY_M;
52
 
        keymap[DIKI_N - DIKI_UNKNOWN] = VK_KEY_N;
53
 
        keymap[DIKI_O - DIKI_UNKNOWN] = VK_KEY_O;
54
 
        keymap[DIKI_P - DIKI_UNKNOWN] = VK_KEY_P;
55
 
        keymap[DIKI_Q - DIKI_UNKNOWN] = VK_KEY_Q;
56
 
        keymap[DIKI_R - DIKI_UNKNOWN] = VK_KEY_R;
57
 
        keymap[DIKI_S - DIKI_UNKNOWN] = VK_KEY_S;
58
 
        keymap[DIKI_T - DIKI_UNKNOWN] = VK_KEY_T;
59
 
        keymap[DIKI_U - DIKI_UNKNOWN] = VK_KEY_U;
60
 
        keymap[DIKI_V - DIKI_UNKNOWN] = VK_KEY_V;
61
 
        keymap[DIKI_W - DIKI_UNKNOWN] = VK_KEY_W;
62
 
        keymap[DIKI_X - DIKI_UNKNOWN] = VK_KEY_X;
63
 
        keymap[DIKI_Y - DIKI_UNKNOWN] = VK_KEY_Y;
64
 
        keymap[DIKI_Z - DIKI_UNKNOWN] = VK_KEY_Z;
65
 
 
66
 
        keymap[DIKI_0 - DIKI_UNKNOWN] = VK_KEY_0;
67
 
        keymap[DIKI_1 - DIKI_UNKNOWN] = VK_KEY_1;
68
 
        keymap[DIKI_2 - DIKI_UNKNOWN] = VK_KEY_2;
69
 
        keymap[DIKI_3 - DIKI_UNKNOWN] = VK_KEY_3;
70
 
        keymap[DIKI_4 - DIKI_UNKNOWN] = VK_KEY_4;
71
 
        keymap[DIKI_5 - DIKI_UNKNOWN] = VK_KEY_5;
72
 
        keymap[DIKI_6 - DIKI_UNKNOWN] = VK_KEY_6;
73
 
        keymap[DIKI_7 - DIKI_UNKNOWN] = VK_KEY_7;
74
 
        keymap[DIKI_8 - DIKI_UNKNOWN] = VK_KEY_8;
75
 
        keymap[DIKI_9 - DIKI_UNKNOWN] = VK_KEY_9;
76
 
        
77
 
        keymap[DIKI_F1 - DIKI_UNKNOWN] = VK_F1;
78
 
        keymap[DIKI_F2 - DIKI_UNKNOWN] = VK_F2;
79
 
        keymap[DIKI_F3 - DIKI_UNKNOWN] = VK_F3;
80
 
        keymap[DIKI_F4 - DIKI_UNKNOWN] = VK_F4;
81
 
        keymap[DIKI_F5 - DIKI_UNKNOWN] = VK_F5;
82
 
        keymap[DIKI_F6 - DIKI_UNKNOWN] = VK_F6;
83
 
        keymap[DIKI_F7 - DIKI_UNKNOWN] = VK_F7;
84
 
        keymap[DIKI_F8 - DIKI_UNKNOWN] = VK_F8;
85
 
        keymap[DIKI_F9 - DIKI_UNKNOWN] = VK_F9;
86
 
        keymap[DIKI_F10 - DIKI_UNKNOWN] = VK_F10;
87
 
        keymap[DIKI_F11 - DIKI_UNKNOWN] = VK_F11;
88
 
        keymap[DIKI_F12 - DIKI_UNKNOWN] = VK_F12;
89
 
 
90
 
        keymap[DIKI_COMMA - DIKI_UNKNOWN] = VK_OEM_COMMA;
91
 
        keymap[DIKI_PERIOD - DIKI_UNKNOWN] = VK_OEM_PERIOD;
92
 
        keymap[DIKI_MINUS_SIGN - DIKI_UNKNOWN] = VK_OEM_MINUS;
93
 
        keymap[DIKI_EQUALS_SIGN - DIKI_UNKNOWN] = VK_OEM_PLUS;
94
 
 
95
 
        keymap[DIKI_ESCAPE - DIKI_UNKNOWN] = VK_ESCAPE;
96
 
        keymap[DIKI_LEFT - DIKI_UNKNOWN] = VK_LEFT;
97
 
        keymap[DIKI_RIGHT - DIKI_UNKNOWN] = VK_RIGHT;
98
 
        keymap[DIKI_UP - DIKI_UNKNOWN] = VK_UP;
99
 
        keymap[DIKI_DOWN - DIKI_UNKNOWN] = VK_DOWN;
100
 
        keymap[DIKI_CONTROL_L - DIKI_UNKNOWN] = VK_LCONTROL;
101
 
        keymap[DIKI_CONTROL_R - DIKI_UNKNOWN] = VK_RCONTROL;
102
 
        keymap[DIKI_SHIFT_L - DIKI_UNKNOWN] = VK_LSHIFT;
103
 
        keymap[DIKI_SHIFT_R - DIKI_UNKNOWN] = VK_RSHIFT;
104
 
        keymap[DIKI_ALT_L - DIKI_UNKNOWN] = VK_LMENU;
105
 
        keymap[DIKI_ALT_R - DIKI_UNKNOWN] = VK_RMENU;
106
 
        keymap[DIKI_TAB - DIKI_UNKNOWN] = VK_TAB;
107
 
        keymap[DIKI_ENTER - DIKI_UNKNOWN] = VK_RETURN;
108
 
        keymap[DIKI_SPACE - DIKI_UNKNOWN] = VK_SPACE;
109
 
        keymap[DIKI_BACKSPACE - DIKI_UNKNOWN] = VK_BACK;
110
 
        keymap[DIKI_INSERT - DIKI_UNKNOWN] = VK_INSERT;
111
 
        keymap[DIKI_DELETE - DIKI_UNKNOWN] = VK_DELETE;
112
 
        keymap[DIKI_HOME - DIKI_UNKNOWN] = VK_HOME;
113
 
        keymap[DIKI_END - DIKI_UNKNOWN] = VK_END;
114
 
        keymap[DIKI_PAGE_UP - DIKI_UNKNOWN] = VK_PRIOR;
115
 
        keymap[DIKI_PAGE_DOWN - DIKI_UNKNOWN] = VK_NEXT;
116
 
        keymap[DIKI_CAPS_LOCK - DIKI_UNKNOWN] = VK_CAPITAL;
117
 
        keymap[DIKI_NUM_LOCK - DIKI_UNKNOWN] = VK_NUMLOCK;
118
 
        keymap[DIKI_SCROLL_LOCK - DIKI_UNKNOWN] = VK_SCROLL;
119
 
        keymap[DIKI_PRINT - DIKI_UNKNOWN] = VK_PRINT;
120
 
        keymap[DIKI_PAUSE - DIKI_UNKNOWN] = VK_PAUSE;
121
 
        keymap[DIKI_KP_DIV - DIKI_UNKNOWN] = VK_DIVIDE;
122
 
        keymap[DIKI_KP_MULT - DIKI_UNKNOWN] = VK_MULTIPLY;
123
 
        keymap[DIKI_KP_MINUS - DIKI_UNKNOWN] = VK_SUBTRACT;
124
 
        keymap[DIKI_KP_PLUS - DIKI_UNKNOWN] = VK_ADD;
125
 
        keymap[DIKI_KP_ENTER - DIKI_UNKNOWN] = VK_RETURN;
126
 
}
127
 
 
128
 
void
129
 
dfb_kb_send_key(rdpInst * inst, int flags, uint8 keycode)
130
 
{
131
 
        int scancode = freerdp_kbd_get_scancode_by_virtualkey(keymap[keycode]);
132
 
        inst->rdp_send_input(inst, RDP_INPUT_SCANCODE, flags, scancode, 0);
133
 
}
134
 
 
135
 
int
136
 
dfb_kb_get_toggle_keys_state(rdpInst * inst)
137
 
{
138
 
        return 0;
139
 
}
140
 
 
141
 
void
142
 
dfb_kb_focus_in(rdpInst * inst)
143
 
{
144
 
 
145
 
}
146