~ubuntu-branches/ubuntu/wily/qtbase-opensource-src/wily

} else if (text.length() == 1 && text.unicode()->unicode() > 0x1f && text.unicode()->unicode() != 0x7f && !(keysym >= XK_dead_grave && keysym <= XK_dead_horn)) {

860

code = text.unicode()->toUpper().unicode();

861

} else {

862

// any other keys

863

code = translateKeySym(keysym);

864

865

if (code == Qt::Key_Tab && (modifiers & Qt::ShiftModifier)) {

866

// map shift+tab to shift+backtab, QShortcutMap knows about it

867

// and will handle it.

868

code = Qt::Key_Backtab;

869

text = QString();

870

}

871

}

872

873

return text;

874

}

875

876

QXcbKeyboard::QXcbKeyboard(QXcbConnection *connection)

877

: QXcbObject(connection)

878

, m_autorepeat_code(0)

879

{

880

m_key_symbols = xcb_key_symbols_alloc(xcb_connection());

881

setupModifiers();

882

}

883

884

QXcbKeyboard::~QXcbKeyboard()

885

{

886

xcb_key_symbols_free(m_key_symbols);

887

}

888

889

void QXcbKeyboard::setupModifiers()

890

{

891

m_alt_mask = 0;

892

m_super_mask = 0;

893

m_hyper_mask = 0;

894

m_meta_mask = 0;

895

m_mode_switch_mask = 0;

896

m_num_lock_mask = 0;

897

m_caps_lock_mask = 0;

898

899

xcb_generic_error_t *error = 0;

900

xcb_connection_t *conn = xcb_connection();

901

xcb_get_modifier_mapping_cookie_t modMapCookie = xcb_get_modifier_mapping(conn);

902

xcb_get_modifier_mapping_reply_t *modMapReply =

903

xcb_get_modifier_mapping_reply(conn, modMapCookie, &error);

904

if (error) {

905

qWarning("QXcbKeyboard: failed to get modifier mapping");

906

free(error);

907

return;

908

}

909

910

// for Alt and Meta L and R are the same

911

static const xcb_keysym_t symbols[] = {

912

XK_Alt_L, XK_Meta_L, XK_Super_L, XK_Super_R,

913

XK_Hyper_L, XK_Hyper_R, XK_Num_Lock, XK_Mode_switch, XK_Caps_Lock,

914

};

915

static const size_t numSymbols = sizeof symbols / sizeof *symbols;

916

917

// Figure out the modifier mapping, ICCCM 6.6

918

xcb_keycode_t* modKeyCodes[numSymbols];

919

for (size_t i = 0; i < numSymbols; ++i)

920

modKeyCodes[i] = xcb_key_symbols_get_keycode(m_key_symbols, symbols[i]);

921

922

xcb_keycode_t *modMap = xcb_get_modifier_mapping_keycodes(modMapReply);

923

const int w = modMapReply->keycodes_per_modifier;

924

for (size_t i = 0; i < numSymbols; ++i) {

925

for (int bit = 0; bit < 8; ++bit) {

926

uint mask = 1 << bit;

927

for (int x = 0; x < w; ++x) {

928

xcb_keycode_t keyCode = modMap[x + bit * w];

929

xcb_keycode_t *itk = modKeyCodes[i];

930

while (itk && *itk != XCB_NO_SYMBOL)

931

if (*itk++ == keyCode)

932

setMask(symbols[i], mask);

933

}

934

}

935

}

936

937

for (size_t i = 0; i < numSymbols; ++i)

938

free(modKeyCodes[i]);

939

free(modMapReply);

940

}

941

942

void QXcbKeyboard::setMask(uint sym, uint mask)

943

{

944

if (m_alt_mask == 0

945

&& m_meta_mask != mask

946

&& m_super_mask != mask

947

&& m_hyper_mask != mask

948

&& (sym == XK_Alt_L || sym == XK_Alt_R))

949

m_alt_mask = mask;

950

951

if (m_meta_mask == 0

952

&& m_alt_mask != mask

953

&& m_super_mask != mask

954

&& m_hyper_mask != mask

955

&& (sym == XK_Meta_L || sym == XK_Meta_R))

956

m_meta_mask = mask;

957

958

if (m_super_mask == 0

959

&& m_alt_mask != mask

960

&& m_meta_mask != mask

961

&& m_hyper_mask != mask

962

&& (sym == XK_Super_L || sym == XK_Super_R))

963

m_super_mask = mask;

964

965

if (m_hyper_mask == 0

966

&& m_alt_mask != mask

967

&& m_meta_mask != mask

968

&& m_super_mask != mask

969

&& (sym == XK_Hyper_L || sym == XK_Hyper_R))

970

m_hyper_mask = mask;

971

972

if (m_mode_switch_mask == 0

973

&& m_alt_mask != mask

974

&& m_meta_mask != mask

975

&& m_super_mask != mask

976

&& m_hyper_mask != mask

977

&& sym == XK_Mode_switch)

978

m_mode_switch_mask = mask;

979

980

if (m_num_lock_mask == 0 && sym == XK_Num_Lock)

981

m_num_lock_mask = mask;

982

983

if (m_caps_lock_mask == 0 && sym == XK_Caps_Lock)

984

m_caps_lock_mask = mask;

985

}

986

987

// #define XCB_KEYBOARD_DEBUG

988

989

class KeyChecker

990

{

991

public:

992

KeyChecker(xcb_window_t window, xcb_keycode_t code, xcb_timestamp_t time)

993

: m_window(window)

994

, m_code(code)

995

, m_time(time)

996

, m_error(false)

997

, m_release(true)

998

{

999

}

1000

1001

bool checkEvent(xcb_generic_event_t *ev)

1002

{

1003

if (m_error || !ev)

1004

return false;

1005

1006

int type = ev->response_type & ~0x80;

1007

if (type != XCB_KEY_PRESS && type != XCB_KEY_RELEASE)

1008

return false;

1009

1010

xcb_key_press_event_t *event = (xcb_key_press_event_t *)ev;

1011

1012

if (event->event != m_window || event->detail != m_code) {

1013

m_error = true;

1014

return false;

1015

}

1016

1017

if (type == XCB_KEY_PRESS) {

1018

m_error = !m_release || event->time - m_time > 10;

1019

return !m_error;

1020

}

1021

1022

if (m_release) {

1023

m_error = true;

1024

return false;

1025

}

1026

1027

m_release = true;

1028

m_time = event->time;

1029

1030

return false;

1031

}

1032

1033

bool release() const { return m_release; }

1034

xcb_timestamp_t time() const { return m_time; }

1035

1036

private:

1037

xcb_window_t m_window;

1038

xcb_keycode_t m_code;

1039

xcb_timestamp_t m_time;

1040

1041

bool m_error;

1042

bool m_release;

1043

};

1044

1045

void QXcbKeyboard::handleKeyEvent(QWindow *window, QEvent::Type type, xcb_keycode_t code,

1046

quint16 state, xcb_timestamp_t time)

1047

{

1048

Q_XCB_NOOP(connection());

1049

#ifdef XCB_KEYBOARD_DEBUG

1050

printf("key code: %d, state: %d, syms: ", code, state);

1051

for (int i = 0; i <= 5; ++i) {

1052

printf("%d ", xcb_key_symbols_get_keysym(m_key_symbols, code, i));

1053

}

1054

printf("\n");

1055

#endif

1056

1057

QByteArray chars;

1058

xcb_keysym_t sym = lookupString(window, state, code, type, &chars);

1059

QPlatformInputContext *inputContext = QGuiApplicationPrivate::platformIntegration()->inputContext();

1060

QMetaMethod method;

1061

1062

if (inputContext) {

1063

int methodIndex = inputContext->metaObject()->indexOfMethod("x11FilterEvent(uint,uint,uint,bool)");

1064

if (methodIndex != -1)

1065

method = inputContext->metaObject()->method(methodIndex);

1066

}

1067

1068

if (method.isValid()) {

1069

bool retval = false;

1070

method.invoke(inputContext, Qt::DirectConnection,

1071

Q_RETURN_ARG(bool, retval),

1072

Q_ARG(uint, sym),

1073

Q_ARG(uint, code),

1074

Q_ARG(uint, state),

1075

Q_ARG(bool, type == QEvent::KeyPress));

1076

if (retval)

1077

return;

1078

}

1079

1080

Qt::KeyboardModifiers modifiers;

1081

int qtcode = 0;

1082

int count = chars.count();

1083

QString string = translateKeySym(sym, state, qtcode, modifiers, chars, count);

1084

1085

bool isAutoRepeat = false;

1086

1087

if (type == QEvent::KeyPress) {

1088

if (m_autorepeat_code == code) {

1089

isAutoRepeat = true;

1090

m_autorepeat_code = 0;

1091

}

1092

} else {

1093

// look ahead for auto-repeat

1094

KeyChecker checker(((QXcbWindow *)window->handle())->xcb_window(), code, time);

1095

xcb_generic_event_t *event = connection()->checkEvent(checker);

1096

if (event) {

1097

isAutoRepeat = true;

1098

free(event);

1099

}

1100

m_autorepeat_code = isAutoRepeat ? code : 0;

1101

}

1102

1103

bool filtered = false;

1104

if (inputContext) {

1105

QKeyEvent event(type, qtcode, modifiers, code, sym, state, string.left(count), isAutoRepeat, count);

1106

event.setTimestamp(time);

1107

filtered = inputContext->filterEvent(&event);

1108

}

1109

1110

if (!filtered) {

1111

if (type == QEvent::KeyPress && qtcode == Qt::Key_Menu) {

1112

const QPoint globalPos = window->screen()->handle()->cursor()->pos();

1113

const QPoint pos = window->mapFromGlobal(globalPos);

1114

QWindowSystemInterface::handleContextMenuEvent(window, false, pos, globalPos, modifiers);

1115

}

1116

QWindowSystemInterface::handleExtendedKeyEvent(window, time, type, qtcode, modifiers,

1117

code, sym, state, string.left(count), isAutoRepeat);

1118

}

1119

1120

if (isAutoRepeat && type == QEvent::KeyRelease) {

1121

// since we removed it from the event queue using checkEvent we need to send the key press here

1122

filtered = false;

1123

if (method.isValid()) {

1124

method.invoke(inputContext, Qt::DirectConnection,

1125

Q_RETURN_ARG(bool, filtered),

1126

Q_ARG(uint, sym),

1127

Q_ARG(uint, code),

1128

Q_ARG(uint, state),

1129

Q_ARG(bool, true));

1130

}

1131

1132

if (!filtered && inputContext) {

1133

QKeyEvent event(QEvent::KeyPress, qtcode, modifiers, code, sym, state, string.left(count), isAutoRepeat, count);

1134

event.setTimestamp(time);

1135

filtered = inputContext->filterEvent(&event);

1136

}

1137

if (!filtered)

1138

QWindowSystemInterface::handleExtendedKeyEvent(window, time, QEvent::KeyPress, qtcode, modifiers,

1139

code, sym, state, string.left(count), isAutoRepeat);

1140

}

1141

}

1142

1143

xcb_keysym_t QXcbKeyboard::lookupString(QWindow *window, uint state, xcb_keycode_t code,

1144

QEvent::Type type, QByteArray *chars)

1145

{

1146

#ifdef XCB_USE_XLIB

1147

xcb_window_t xWindow = static_cast<QXcbWindow *>(window->handle())->xcb_window();

1148

xcb_window_t root = connection()->screens().at(0)->root();

1149

void *xDisplay = connection()->xlib_display();

1150

int xType = (type == QEvent::KeyRelease ? 3 : 2);

1151

return q_XLookupString(xDisplay, xWindow, root, state, code, xType, chars);

1152

#else

1153

1154

// No XLookupString available. The following is really incomplete...

1155

1156

int col = state & XCB_MOD_MASK_SHIFT ? 1 : 0;

1157

const int altGrOffset = 4;

1158

if (state & 128)

1159

col += altGrOffset;

1160

xcb_keysym_t sym = xcb_key_symbols_get_keysym(m_key_symbols, code, col);

1161

if (sym == XCB_NO_SYMBOL)

1162

sym = xcb_key_symbols_get_keysym(m_key_symbols, code, col ^ 0x1);

1163

if (state & XCB_MOD_MASK_LOCK && sym <= 0x7f && isprint(sym)) {

1164

if (isupper(sym))

1165

sym = tolower(sym);

1166

else

1167

sym = toupper(sym);

1168

}

1169

return sym;

1170

1171

#endif

1172

}

1173

1174

void QXcbKeyboard::handleKeyPressEvent(QXcbWindow *window, const xcb_key_press_event_t *event)

1175

{

1176

window->updateNetWmUserTime(event->time);

1177

handleKeyEvent(window->window(), QEvent::KeyPress, event->detail, event->state, event->time);

1178

}

1179

1180

void QXcbKeyboard::handleKeyReleaseEvent(QXcbWindow *window, const xcb_key_release_event_t *event)

1181

{

1182

handleKeyEvent(window->window(), QEvent::KeyRelease, event->detail, event->state, event->time);

1183

}

1184

1185

void QXcbKeyboard::handleMappingNotifyEvent(const xcb_mapping_notify_event_t *event)

1186

{

1187

xcb_refresh_keyboard_mapping(m_key_symbols, const_cast<xcb_mapping_notify_event_t *>(event));

1188

setupModifiers();

1189

}

1190

1191

QT_END_NAMESPACE

Older »