← Back to branch summary

~ubuntu-branches/ubuntu/trusty/scim-bridge/trusty

« back to all changes in this revision

Viewing changes to client-common/scim-bridge-client-messenger.c

  • Committer: Bazaar Package Importer
  • Author(s): Hou ZhengPeng
  • Date: 2006-04-02 18:07:30 UTC
  • Revision ID: james.westby@ubuntu.com-20060402180730-x4zlfe8odh4yzcld
Tags: upstream-0.1.3
Import upstream version 0.1.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
client-common/scim-bridge-client-messenger.c
 
1
#include <assert.h>
 
2
#include <errno.h>
 
3
#include <fcntl.h>
 
4
#include <pthread.h>
 
5
#include <stdlib.h>
 
6
#include <string.h>
 
7
#include <unistd.h>
 
8
#include <malloc.h>
 
9
 
 
10
#include <sys/socket.h>
 
11
#include <sys/stat.h>
 
12
#include <sys/types.h>
 
13
#include <sys/un.h>
 
14
 
 
15
#include "scim-bridge-client-kernel-protected.h"
 
16
#include "scim-bridge-client-messenger.h"
 
17
#include "scim-bridge-exception.h"
 
18
#include "scim-bridge-environment.h"
 
19
#include "scim-bridge-keyevent.h"
 
20
#include "scim-bridge-message.h"
 
21
#include "scim-bridge-messenger.h"
 
22
#include "scim-bridge-output.h"
 
23
#include "scim-bridge-string.h"
 
24
 
 
25
/* Private static variables */
 
26
static const int CONNECTION_TRY_MAX_COUNT = 3;
 
27
 
 
28
/* Private variables */
 
29
static int input_fd;
 
30
static int output_fd;
 
31
 
 
32
static ScimBridgeMessengerID messenger_id = -1;
 
33
 
 
34
static pthread_t messenger_thread;
 
35
 
 
36
/* Private functions */
 
37
static int launch_agent ();
 
38
static int open_connection (ScimBridgeException *except);
 
39
static int start_thread (ScimBridgeException *except);
 
40
static void *run_thread ();
 
41
 
 
42
static int received_message_unknown (ScimBridgeException *except, ScimBridgeMessageCode code);
 
43
static int received_message_commit (ScimBridgeException *except);
 
44
static int received_message_update_preedit (ScimBridgeException *except);
 
45
static int received_message_set_preedit_string (ScimBridgeException *except);
 
46
static int received_message_set_preedit_attributes (ScimBridgeException *except);
 
47
static int received_message_set_preedit_cursor_position (ScimBridgeException *except);
 
48
static int received_message_set_preedit_shown (ScimBridgeException *except);
 
49
static int received_message_forward_keyevent (ScimBridgeException *except);
 
50
static int received_message_beep (ScimBridgeException *except);
 
51
static int received_message_get_surrounding_string (ScimBridgeException *except);
 
52
static int received_message_delete_surrounding_string (ScimBridgeException *except);
 
53
 
 
54
/* Implementations */
 
55
int scim_bridge_client_initialize_messenger (ScimBridgeException *except)
 
56
{
 
57
    input_fd = -1;
 
58
    output_fd = -1;
 
59
 
 
60
    int retry_count;
 
61
    for (retry_count = 0; retry_count < CONNECTION_TRY_MAX_COUNT; ++retry_count) {
 
62
        if (open_connection (except)) {
 
63
            if (retry_count == 0) {
 
64
                launch_agent ();
 
65
            } else {
 
66
                usleep (100);
 
67
            }
 
68
        } else {
 
69
            break;
 
70
        }
 
71
    }
 
72
    if (input_fd < 0 || output_fd < 0) return -1;
 
73
 
 
74
    if (scim_bridge_initialize_messenger (except, &messenger_id, input_fd, output_fd))
 
75
        return -1;
 
76
 
 
77
    return start_thread (except);
 
78
}
 
79
 
 
80
 
 
81
int scim_bridge_client_finalize_messenger (ScimBridgeException *except)
 
82
{
 
83
    if (input_fd > 0 && output_fd > 0) {
 
84
        input_fd = -1;
 
85
        output_fd = -1;
 
86
    }
 
87
 
 
88
    if (messenger_id >= 0) {
 
89
        scim_bridge_finalize_messenger (except, messenger_id);
 
90
        messenger_id = -1;
 
91
    }
 
92
 
 
93
    return 0;
 
94
}
 
95
 
 
96
 
 
97
/* Helper functions */
 
98
int launch_agent ()
 
99
{
 
100
    scim_bridge_pdebugln (SCIM_BRIDGE_DEBUG_CLIENT, 1, "Invoking the agent...");
 
101
    if (system ("scim-bridge-agent")) {
 
102
        scim_bridge_perrorln ("Failed to invoking the agent: %s", strerror (errno));
 
103
 
 
104
        return -1;
 
105
    }
 
106
    return 0;
 
107
}
 
108
 
 
109
 
 
110
int open_connection (ScimBridgeException *except)
 
111
{
 
112
    int output_socket_fd = socket (PF_UNIX, SOCK_STREAM, 0);
 
113
    if (output_socket_fd < 0) {
 
114
        scim_bridge_exception_set_errno (except, errno);
 
115
        scim_bridge_exception_set_message (except, "Failed to create the output socket");
 
116
        return -1;
 
117
    }
 
118
 
 
119
    struct sockaddr_un output_socket_addr;
 
120
    memset (&output_socket_addr, 0, sizeof (struct sockaddr_un));
 
121
    output_socket_addr.sun_family = AF_UNIX;
 
122
    strcpy (output_socket_addr.sun_path, scim_bridge_environment_get_client_to_agent_socket_path ());
 
123
 
 
124
    if (connect (output_socket_fd, (struct sockaddr*)&output_socket_addr, sizeof (struct sockaddr_un)) != 0) {
 
125
        scim_bridge_exception_set_errno (except, errno);
 
126
        scim_bridge_exception_set_message (except, "Failed to open the output socket");
 
127
        return -1;
 
128
    }
 
129
 
 
130
    int input_socket_fd = socket (PF_UNIX, SOCK_STREAM, 0);
 
131
    if (input_socket_fd < 0) {
 
132
        scim_bridge_exception_set_errno (except, errno);
 
133
        scim_bridge_exception_set_message (except, "Failed to create the input socket");
 
134
        return -1;
 
135
    }
 
136
 
 
137
    struct sockaddr_un input_socket_addr;
 
138
    memset (&input_socket_addr, 0, sizeof (struct sockaddr_un));
 
139
    input_socket_addr.sun_family = AF_UNIX;
 
140
    strcpy (input_socket_addr.sun_path, scim_bridge_environment_get_agent_to_client_socket_path ());
 
141
 
 
142
    if (connect (input_socket_fd, (struct sockaddr*)&input_socket_addr, sizeof (struct sockaddr_un)) != 0) {
 
143
        scim_bridge_exception_set_errno (except, errno);
 
144
        scim_bridge_exception_set_message (except, "Failed to open the input socket");
 
145
        return -1;
 
146
    }
 
147
 
 
148
    input_fd = input_socket_fd;
 
149
    output_fd = output_socket_fd;
 
150
 
 
151
    return 0;
 
152
}
 
153
 
 
154
 
 
155
int start_thread (ScimBridgeException *except)
 
156
{
 
157
    if (pthread_create (&messenger_thread, NULL, &run_thread, NULL) || pthread_detach (messenger_thread)) {
 
158
        scim_bridge_exception_set_errno (except, errno);
 
159
        scim_bridge_exception_set_message (except, "Failed to create new thread");
 
160
        return -1;
 
161
    }
 
162
 
 
163
    return 0;
 
164
}
 
165
 
 
166
 
 
167
void *run_thread ()
 
168
{
 
169
    scim_bridge_pdebugln (SCIM_BRIDGE_DEBUG_CLIENT | SCIM_BRIDGE_DEBUG_MESSENGER, 1, "run_messenger");
 
170
 
 
171
    int connection_broken = 0;
 
172
    ScimBridgeException except;
 
173
    scim_bridge_exception_initialize (&except);
 
174
    while (!connection_broken && input_fd > 0 && output_fd > 0) {
 
175
        if (scim_bridge_messenger_open_input (&except, messenger_id)) {
 
176
            connection_broken = 1;
 
177
            break;
 
178
        }
 
179
 
 
180
        ScimBridgeMessageCode code;
 
181
        if (scim_bridge_messenger_read_input (&except, messenger_id, &code, sizeof (code))) {
 
182
            connection_broken = 1;
 
183
            break;
 
184
        }
 
185
        switch (code) {
 
186
            case SCIM_BRIDGE_MESSAGE_COMMIT:
 
187
                if (received_message_commit (&except)) connection_broken = 1;
 
188
                break;
 
189
            case SCIM_BRIDGE_MESSAGE_SET_PREEDIT_STRING:
 
190
                if (received_message_set_preedit_string (&except)) connection_broken = 1;
 
191
                break;
 
192
            case SCIM_BRIDGE_MESSAGE_SET_PREEDIT_ATTRIBUTES:
 
193
                if (received_message_set_preedit_attributes (&except)) connection_broken = 1;
 
194
                break;
 
195
            case SCIM_BRIDGE_MESSAGE_SET_PREEDIT_CURSOR_POSITION:
 
196
                if (received_message_set_preedit_cursor_position (&except)) connection_broken = 1;
 
197
                break;
 
198
            case SCIM_BRIDGE_MESSAGE_SET_PREEDIT_SHOWN:
 
199
                if (received_message_set_preedit_shown (&except)) connection_broken = 1;
 
200
                break;
 
201
            case SCIM_BRIDGE_MESSAGE_UPDATE_PREEDIT:
 
202
                if (received_message_update_preedit (&except)) connection_broken = 1;
 
203
                break;
 
204
            case SCIM_BRIDGE_MESSAGE_FORWARD_KEYEVENT:
 
205
                if (received_message_forward_keyevent (&except)) connection_broken = 1;
 
206
                break;
 
207
            case SCIM_BRIDGE_MESSAGE_BEEP:
 
208
                if (received_message_beep (&except)) connection_broken = 1;
 
209
                break;
 
210
            case SCIM_BRIDGE_MESSAGE_GET_SURROUNDING_STRING:
 
211
                if (received_message_get_surrounding_string (&except)) connection_broken = 1;
 
212
                break;
 
213
            case SCIM_BRIDGE_MESSAGE_DELETE_SURROUNDING_STRING:
 
214
                if (received_message_delete_surrounding_string (&except)) connection_broken = 1;
 
215
                break;
 
216
            default:
 
217
                if (received_message_unknown (&except, code)) {
 
218
                    connection_broken = 1;
 
219
                }
 
220
        }
 
221
 
 
222
    }
 
223
 
 
224
    if (input_fd > 0 || output_fd > 0) {
 
225
        scim_bridge_client_kernel_exception_occured (&except);
 
226
    } else {
 
227
        scim_bridge_client_kernel_cleanup (&except);
 
228
    }
 
229
    scim_bridge_exception_finalize (&except);
 
230
 
 
231
    return NULL;
 
232
}
 
233
 
 
234
 
 
235
/* Received message handler */
 
236
 
 
237
int received_message_unknown (ScimBridgeException *except, ScimBridgeMessageCode code)
 
238
{
 
239
    scim_bridge_perrorln ("Unknown message received: %d", code);
 
240
    scim_bridge_exception_set_errno (except, EBADRQC);
 
241
    scim_bridge_exception_set_message (except, "Unknwon message received");
 
242
 
 
243
    if (scim_bridge_messenger_close_input (except, messenger_id))
 
244
        return -1;
 
245
 
 
246
    return -1;
 
247
}
 
248
 
 
249
 
 
250
int received_message_commit (ScimBridgeException *except)
 
251
{
 
252
    scim_bridge_pdebugln (SCIM_BRIDGE_DEBUG_CLIENT | SCIM_BRIDGE_DEBUG_MESSENGER, 3, "Received 'Commit' message");
 
253
 
 
254
    ScimBridgeIMContextID id;
 
255
    if (scim_bridge_messenger_read_input (except, messenger_id, &id, sizeof (id)))
 
256
        return -1;
 
257
 
 
258
    scim_bridge_client_kernel_commit (id);
 
259
 
 
260
    if (scim_bridge_messenger_close_input (except, messenger_id))
 
261
        return -1;
 
262
 
 
263
    return 0;
 
264
}
 
265
 
 
266
 
 
267
int received_message_set_preedit_shown (ScimBridgeException *except)
 
268
{
 
269
    scim_bridge_pdebugln (SCIM_BRIDGE_DEBUG_CLIENT | SCIM_BRIDGE_DEBUG_MESSENGER, 3, "Received 'Set preedit shown' message");
 
270
 
 
271
    ScimBridgeIMContextID id;
 
272
    if (scim_bridge_messenger_read_input (except, messenger_id, &id, sizeof (id)))
 
273
        return -1;
 
274
 
 
275
    int shown;
 
276
    if (scim_bridge_messenger_read_input (except, messenger_id, &shown, sizeof (shown)))
 
277
        return -1;
 
278
 
 
279
    scim_bridge_client_kernel_set_preedit_shown (id, shown);
 
280
 
 
281
    if (scim_bridge_messenger_close_input (except, messenger_id))
 
282
        return -1;
 
283
 
 
284
    return 0;
 
285
}
 
286
 
 
287
 
 
288
int received_message_set_preedit_string (ScimBridgeException *except)
 
289
{
 
290
    scim_bridge_pdebugln (SCIM_BRIDGE_DEBUG_CLIENT | SCIM_BRIDGE_DEBUG_MESSENGER, 3, "Received 'Set preedit string' message");
 
291
 
 
292
    ScimBridgeIMContextID id;
 
293
    if (scim_bridge_messenger_read_input (except, messenger_id, &id, sizeof (id)))
 
294
        return -1;
 
295
 
 
296
    size_t wstr_len;
 
297
    if (scim_bridge_messenger_read_input (except, messenger_id, &wstr_len, sizeof (wstr_len)))
 
298
        return -1;
 
299
 
 
300
    ucs4_t *wstr;
 
301
    wstr = malloc (sizeof (ucs4_t) * (wstr_len + 1));
 
302
    if (scim_bridge_messenger_read_input (except, messenger_id, wstr, sizeof (ucs4_t) * (wstr_len + 1)))
 
303
        return -1;
 
304
 
 
305
    scim_bridge_client_kernel_set_preedit_string (id, wstr, wstr_len);
 
306
 
 
307
    if (scim_bridge_messenger_close_input (except, messenger_id))
 
308
        return -1;
 
309
    return 0;
 
310
}
 
311
 
 
312
 
 
313
int received_message_set_preedit_attributes (ScimBridgeException *except)
 
314
{
 
315
    scim_bridge_pdebugln (SCIM_BRIDGE_DEBUG_CLIENT | SCIM_BRIDGE_DEBUG_MESSENGER, 3, "Received 'Set preedit attributes' message");
 
316
 
 
317
    ScimBridgeIMContextID id;
 
318
    if (scim_bridge_messenger_read_input (except, messenger_id, &id, sizeof (id)))
 
319
        return -1;
 
320
 
 
321
    size_t attr_count;
 
322
    if (scim_bridge_messenger_read_input (except, messenger_id, &attr_count, sizeof (attr_count)))
 
323
        return -1;
 
324
 
 
325
    ScimBridgeAttribute *attrs;
 
326
    if (attr_count != 0) attrs = malloc (sizeof (ScimBridgeAttribute) * attr_count);
 
327
    else attrs = NULL;
 
328
    if (scim_bridge_messenger_read_input (except, messenger_id, attrs, sizeof (ScimBridgeAttribute) * (attr_count)))
 
329
        return -1;
 
330
 
 
331
    scim_bridge_client_kernel_set_preedit_attributes (id, attrs, attr_count);
 
332
 
 
333
    if (scim_bridge_messenger_close_input (except, messenger_id))
 
334
        return -1;
 
335
    return 0;
 
336
}
 
337
 
 
338
 
 
339
int received_message_set_preedit_cursor_position (ScimBridgeException *except)
 
340
{
 
341
    scim_bridge_pdebugln (SCIM_BRIDGE_DEBUG_CLIENT | SCIM_BRIDGE_DEBUG_MESSENGER, 3, "Received 'Set preedit cursor position' message");
 
342
 
 
343
    ScimBridgeIMContextID id;
 
344
    if (scim_bridge_messenger_read_input (except, messenger_id, &id, sizeof (id)))
 
345
        return -1;
 
346
 
 
347
    int cur_pos;
 
348
    if (scim_bridge_messenger_read_input (except, messenger_id, &cur_pos, sizeof (cur_pos)))
 
349
        return -1;
 
350
 
 
351
    if (scim_bridge_messenger_close_input (except, messenger_id))
 
352
        return -1;
 
353
 
 
354
    scim_bridge_client_kernel_set_preedit_cursor_position (id, cur_pos);
 
355
    return 0;
 
356
}
 
357
 
 
358
 
 
359
int received_message_update_preedit (ScimBridgeException *except)
 
360
{
 
361
    scim_bridge_pdebugln (SCIM_BRIDGE_DEBUG_CLIENT | SCIM_BRIDGE_DEBUG_MESSENGER, 3, "Received 'Update preedit' message");
 
362
 
 
363
    ScimBridgeIMContextID id;
 
364
    if (scim_bridge_messenger_read_input (except, messenger_id, &id, sizeof (id)))
 
365
        return -1;
 
366
 
 
367
    scim_bridge_client_kernel_update_preedit (id);
 
368
 
 
369
    if (scim_bridge_messenger_close_input (except, messenger_id))
 
370
        return -1;
 
371
 
 
372
    return 0;
 
373
}
 
374
 
 
375
 
 
376
int received_message_forward_keyevent (ScimBridgeException *except)
 
377
{
 
378
    scim_bridge_pdebugln (SCIM_BRIDGE_DEBUG_CLIENT | SCIM_BRIDGE_DEBUG_MESSENGER, 3, "Received 'forward keyevent' message");
 
379
 
 
380
    ScimBridgeIMContextID id;
 
381
    if (scim_bridge_messenger_read_input (except, messenger_id, &id, sizeof (id)))
 
382
        return -1;
 
383
 
 
384
    ScimBridgeKeyEvent keyevent;
 
385
    if (scim_bridge_messenger_read_input (except, messenger_id, &keyevent, sizeof (ScimBridgeKeyEvent)))
 
386
        return -1;
 
387
 
 
388
    scim_bridge_client_kernel_forward_keyevent (id, &keyevent);
 
389
 
 
390
    if (scim_bridge_messenger_close_input (except, messenger_id))
 
391
        return -1;
 
392
 
 
393
    return 0;
 
394
}
 
395
 
 
396
 
 
397
int received_message_beep (ScimBridgeException *except)
 
398
{
 
399
    scim_bridge_pdebugln (SCIM_BRIDGE_DEBUG_CLIENT | SCIM_BRIDGE_DEBUG_MESSENGER, 3, "Received 'beep' message");
 
400
 
 
401
    ScimBridgeIMContextID id;
 
402
    if (scim_bridge_messenger_read_input (except, messenger_id, &id, sizeof (id)))
 
403
        return -1;
 
404
 
 
405
    if (scim_bridge_messenger_close_input (except, messenger_id))
 
406
        return -1;
 
407
 
 
408
    scim_bridge_client_kernel_beep (id);
 
409
 
 
410
    return 0;
 
411
}
 
412
 
 
413
 
 
414
int received_message_get_surrounding_string (ScimBridgeException *except)
 
415
{
 
416
    scim_bridge_pdebugln (SCIM_BRIDGE_DEBUG_CLIENT | SCIM_BRIDGE_DEBUG_MESSENGER, 3, "Received 'Get surrounding text' message");
 
417
 
 
418
    ScimBridgeIMContextID id;
 
419
    if (scim_bridge_messenger_read_input (except, messenger_id, &id, sizeof (id)))
 
420
        return -1;
 
421
 
 
422
    size_t buffer_length;
 
423
    if (scim_bridge_messenger_read_input (except, messenger_id, &buffer_length, sizeof (buffer_length)))
 
424
        return -1;
 
425
 
 
426
    ucs4_t wstr[buffer_length + 1];
 
427
    wstr[0] = L'\0';
 
428
 
 
429
    size_t wstr_len;
 
430
    int cursor_position;
 
431
    scim_bridge_client_kernel_get_surrounding_string (id, wstr, buffer_length, &wstr_len, &cursor_position);
 
432
 
 
433
    if (scim_bridge_messenger_write_input (except, messenger_id, &wstr_len, sizeof (wstr_len)))
 
434
        return -1;
 
435
 
 
436
    if (scim_bridge_messenger_write_input (except, messenger_id, wstr, sizeof (ucs4_t) * (wstr_len + 1)))
 
437
        return -1;
 
438
 
 
439
    if (scim_bridge_messenger_write_input (except, messenger_id, &cursor_position, sizeof (cursor_position)))
 
440
        return -1;
 
441
 
 
442
    if (scim_bridge_messenger_close_input (except, messenger_id))
 
443
        return -1;
 
444
 
 
445
    return 0;
 
446
}
 
447
 
 
448
 
 
449
int received_message_delete_surrounding_string (ScimBridgeException *except)
 
450
{
 
451
    scim_bridge_pdebugln (SCIM_BRIDGE_DEBUG_MESSENGER, 3, "Received 'Delete surrounding text' message");
 
452
 
 
453
    ScimBridgeIMContextID id;
 
454
    if (scim_bridge_messenger_read_input (except, messenger_id, &id, sizeof (id)))
 
455
        return -1;
 
456
 
 
457
    size_t offset;
 
458
    if (scim_bridge_messenger_read_input (except, messenger_id, &offset, sizeof (offset)))
 
459
        return -1;
 
460
 
 
461
    size_t length;
 
462
    if (scim_bridge_messenger_read_input (except, messenger_id, &length, sizeof (length)))
 
463
        return -1;
 
464
 
 
465
    int retval;
 
466
    scim_bridge_client_kernel_delete_surrounding_string (id, offset, length, &retval);
 
467
 
 
468
    if (scim_bridge_messenger_write_input (except, messenger_id, &retval, sizeof (retval)))
 
469
        return -1;
 
470
 
 
471
    if (scim_bridge_messenger_close_input (except, messenger_id))
 
472
        return -1;
 
473
 
 
474
    return 0;
 
475
}
 
476
 
 
477
 
 
478
/* Remote functions */
 
479
int scim_bridge_client_call_alloc_imcontext (ScimBridgeException *except, ScimBridgeIMContextID id, ScimBridgeIMContextID *opponent_id)
 
480
{
 
481
    scim_bridge_pdebugln (SCIM_BRIDGE_DEBUG_CLIENT | SCIM_BRIDGE_DEBUG_MESSENGER, 3, "Sending 'alloc imcontext' message...");
 
482
 
 
483
    if (scim_bridge_messenger_open_output (except, messenger_id))
 
484
        return -1;
 
485
 
 
486
    const ScimBridgeMessageCode code = SCIM_BRIDGE_MESSAGE_ALLOC_IMCONTEXT;
 
487
    if (scim_bridge_messenger_write_output (except, messenger_id, &code, sizeof (code)))
 
488
        return -1;
 
489
 
 
490
    if (scim_bridge_messenger_write_output (except, messenger_id, &id, sizeof (id)))
 
491
        return -1;
 
492
 
 
493
    if (scim_bridge_messenger_read_output (except, messenger_id, opponent_id, sizeof (*opponent_id)))
 
494
        return -1;
 
495
 
 
496
    if (scim_bridge_messenger_close_output (except, messenger_id))
 
497
        return -1;
 
498
 
 
499
    return 0;
 
500
}
 
501
 
 
502
 
 
503
int scim_bridge_client_call_free_imcontext (ScimBridgeException *except, ScimBridgeIMContextID opponent_id)
 
504
{
 
505
    scim_bridge_pdebugln (SCIM_BRIDGE_DEBUG_CLIENT | SCIM_BRIDGE_DEBUG_MESSENGER, 3, "Sending 'free imcontext' message...");
 
506
 
 
507
    if (scim_bridge_messenger_open_output (except, messenger_id))
 
508
        return -1;
 
509
 
 
510
    const ScimBridgeMessageCode code = SCIM_BRIDGE_MESSAGE_FREE_IMCONTEXT;
 
511
    if (scim_bridge_messenger_write_output (except, messenger_id, &code, sizeof (code)))
 
512
        return -1;
 
513
 
 
514
    if (scim_bridge_messenger_write_output (except, messenger_id, &opponent_id, sizeof (opponent_id)))
 
515
        return -1;
 
516
 
 
517
    if (scim_bridge_messenger_close_output (except, messenger_id))
 
518
        return -1;
 
519
 
 
520
    return 0;
 
521
}
 
522
 
 
523
 
 
524
int scim_bridge_client_call_reset_imcontext (ScimBridgeException *except, ScimBridgeIMContextID opponent_id)
 
525
{
 
526
    scim_bridge_pdebugln (SCIM_BRIDGE_DEBUG_CLIENT | SCIM_BRIDGE_DEBUG_MESSENGER, 3, "Sending 'reset imcontext' message...");
 
527
 
 
528
    if (scim_bridge_messenger_open_output (except, messenger_id))
 
529
        return -1;
 
530
 
 
531
    const ScimBridgeMessageCode code = SCIM_BRIDGE_MESSAGE_RESET_IMCONTEXT;
 
532
    if (scim_bridge_messenger_write_output (except, messenger_id, &code, sizeof (code)))
 
533
        return -1;
 
534
 
 
535
    if (scim_bridge_messenger_write_output (except, messenger_id, &opponent_id, sizeof (opponent_id)))
 
536
        return -1;
 
537
 
 
538
    if (scim_bridge_messenger_close_output (except, messenger_id))
 
539
        return -1;
 
540
 
 
541
    return 0;
 
542
}
 
543
 
 
544
 
 
545
int scim_bridge_client_call_cursor_location_changed (ScimBridgeException *except, ScimBridgeIMContextID opponent_id, int cursor_x, int cursor_y)
 
546
{
 
547
    scim_bridge_pdebugln (SCIM_BRIDGE_DEBUG_CLIENT | SCIM_BRIDGE_DEBUG_MESSENGER, 3, "Sending 'cursor location changed' message");
 
548
 
 
549
    if (scim_bridge_messenger_open_output (except, messenger_id))
 
550
        return -1;
 
551
 
 
552
    const ScimBridgeMessageCode code = SCIM_BRIDGE_MESSAGE_CURSOR_LOCATION_CHANGED;
 
553
    if (scim_bridge_messenger_write_output (except, messenger_id, &code, sizeof (code)))
 
554
        return -1;
 
555
 
 
556
    if (scim_bridge_messenger_write_output (except, messenger_id, &opponent_id, sizeof (opponent_id)))
 
557
        return -1;
 
558
 
 
559
    if (scim_bridge_messenger_write_output (except, messenger_id, &cursor_x, sizeof (cursor_x)))
 
560
        return -1;
 
561
 
 
562
    if (scim_bridge_messenger_write_output (except, messenger_id, &cursor_y, sizeof (cursor_y)))
 
563
        return -1;
 
564
 
 
565
    if (scim_bridge_messenger_close_output (except, messenger_id))
 
566
        return -1;
 
567
 
 
568
    return 0;
 
569
}
 
570
 
 
571
 
 
572
int scim_bridge_client_call_focus_changed (ScimBridgeException *except, ScimBridgeIMContextID opponent_id, int focus_in)
 
573
{
 
574
    scim_bridge_pdebugln (SCIM_BRIDGE_DEBUG_CLIENT | SCIM_BRIDGE_DEBUG_MESSENGER, 3, "Sending 'focus changed' message...");
 
575
 
 
576
    if (scim_bridge_messenger_open_output (except, messenger_id))
 
577
        return -1;
 
578
 
 
579
    const ScimBridgeMessageCode code = SCIM_BRIDGE_MESSAGE_FOCUS_CHANGED;
 
580
    if (scim_bridge_messenger_write_output (except, messenger_id, &code, sizeof (code)))
 
581
        return -1;
 
582
 
 
583
    if (scim_bridge_messenger_write_output (except, messenger_id, &opponent_id, sizeof (opponent_id)))
 
584
        return -1;
 
585
 
 
586
    if (scim_bridge_messenger_write_output (except, messenger_id, &focus_in, sizeof (focus_in)))
 
587
        return -1;
 
588
 
 
589
    if (scim_bridge_messenger_close_output (except, messenger_id))
 
590
        return -1;
 
591
 
 
592
    return 0;
 
593
}
 
594
 
 
595
 
 
596
int scim_bridge_client_call_keyevent_occured (ScimBridgeException *except, ScimBridgeIMContextID opponent_id, const ScimBridgeKeyEvent *keyevent, int *consumed)
 
597
{
 
598
    scim_bridge_pdebugln (SCIM_BRIDGE_DEBUG_CLIENT | SCIM_BRIDGE_DEBUG_MESSENGER, 3, "Sending 'keyevent occured' message...");
 
599
 
 
600
    if (scim_bridge_messenger_open_output (except, messenger_id))
 
601
        return -1;
 
602
 
 
603
    const ScimBridgeMessageCode code = SCIM_BRIDGE_MESSAGE_KEYEVENT_OCCURED;
 
604
    if (scim_bridge_messenger_write_output (except, messenger_id, &code, sizeof (code)))
 
605
        return -1;
 
606
 
 
607
    if (scim_bridge_messenger_write_output (except, messenger_id, &opponent_id, sizeof (opponent_id)))
 
608
        return -1;
 
609
 
 
610
    if (scim_bridge_messenger_write_output (except, messenger_id, keyevent, sizeof (ScimBridgeKeyEvent)))
 
611
        return -1;
 
612
 
 
613
    if (scim_bridge_messenger_read_output (except, messenger_id, consumed, sizeof (*consumed)))
 
614
        return -1;
 
615
 
 
616
    if (scim_bridge_messenger_close_output (except, messenger_id))
 
617
        return -1;
 
618
 
 
619
    return 0;
 
620
}