PageRenderTime 111ms CodeModel.GetById 2ms app.highlight 99ms RepoModel.GetById 1ms app.codeStats 0ms

/libgxim/gximprotocol10.c

https://bitbucket.org/tagoh/libgxim
C | 2304 lines | 1902 code | 315 blank | 87 comment | 103 complexity | ac0a6a7fcfec031a91c1c6c2107b1687 MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   1/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2/* 
   3 * gximprotocol10.c
   4 * Copyright (C) 2008-2011 Akira TAGOH
   5 * 
   6 * Authors:
   7 *   Akira TAGOH  <akira@tagoh.org>
   8 * 
   9 * This library is free software; you can redistribute it and/or
  10 * modify it under the terms of the GNU Lesser General Public
  11 * License as published by the Free Software Foundation; either
  12 * version 2 of the License, or (at your option) any later version.
  13 * 
  14 * This library is distributed in the hope that it will be useful,
  15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17 * Lesser General Public License for more details.
  18 * 
  19 * You should have received a copy of the GNU Lesser General Public
  20 * License along with this library; if not, write to the
  21 * Free Software Foundation, Inc., 51 Franklin Street, Fifth
  22 * Floor, Boston, MA  02110-1301  USA
  23 */
  24#ifdef HAVE_CONFIG_H
  25#include "config.h"
  26#endif
  27
  28#ifdef HAVE_STRING_H
  29#include <string.h>
  30#endif
  31#include <gdk/gdkkeysyms.h>
  32#include <gio/gio.h>
  33#include "gximattr.h"
  34#include "gximconnection.h"
  35#include "gximsrvconn.h"
  36#include "gximmarshal.h"
  37#include "gximmessages.h"
  38#include "gximmisc.h"
  39#include "gximprotocol.h"
  40#include "gximprotocol10.h"
  41
  42#define PROTO_ERROR(_m_,_n_)			(g_xim_protocol_raise_parser_error(proto, G_ ## _m_, (_n_), 0, 0))
  43#define PROTO_ERROR_IM(_m_,_n_,_imid_)		(g_xim_protocol_raise_parser_error(proto, G_ ##_m_, (_n_), (_imid_), 0))
  44#define PROTO_ERROR_IMIC(_m_,_n_,_imid_,_icid_)	(g_xim_protocol_raise_parser_error(proto, G_ ##_m_, (_n_), (_imid_), (_icid_)))
  45#define SIG_NOIMPL(_s_)				(g_xim_protocol10_closure_signal_no_impl(proto, #_s_, G_XIM_EMASK_NO_VALID_ID, 0, 0))
  46#define SIG_NOIMPL_IM(_s_,_imid_)		(g_xim_protocol10_closure_signal_no_impl(proto, #_s_, G_XIM_EMASK_VALID_IMID, (_imid_), 0))
  47#define SIG_NOIMPL_IMIC(_s_,_imid_,_icid_)	(g_xim_protocol10_closure_signal_no_impl(proto, #_s_, G_XIM_EMASK_VALID_IMID|G_XIM_EMASK_VALID_ICID, (_imid_), (_icid_)))
  48#define MSG_NOIMPL(_s_)				(g_xim_messages_error(G_XIM_PROTOCOL_GET_IFACE (proto)->message, "No implementation or an error occurred in %s", #_s_))
  49#define MSG_NOIMPL_IM(_s_,_imid_)		(g_xim_messages_error(G_XIM_PROTOCOL_GET_IFACE (proto)->message, "No implementation or an error occurred in %s [imid: %d]", #_s_, (_imid_)))
  50#define MSG_NOIMPL_IMIC(_s_,_imid_,_icid_)	(g_xim_messages_error(G_XIM_PROTOCOL_GET_IFACE (proto)->message, "No implementation or an error occurred in %s [imid: %d, icid: %d]", #_s_, (_imid_), (_icid_)))
  51
  52
  53/*
  54 * Private functions
  55 */
  56static gboolean
  57g_xim_protocol10_closure_XIM_CONNECT(GXimProtocolClosure  *closure,
  58				     GXimProtocol         *proto,
  59				     GDataInputStream     *stream,
  60				     GError              **error,
  61				     gpointer              user_data)
  62{
  63	guint8 b;
  64	guint16 major = 0, minor = 0;
  65	GSList *list = NULL;
  66	gboolean retval = FALSE;
  67
  68	if (g_xim_protocol_read_format(proto, stream, NULL, error, 6,
  69				       G_XIM_TYPE_BYTE, &b,
  70				       G_XIM_TYPE_PADDING, 1,
  71				       G_XIM_TYPE_WORD, &major,
  72				       G_XIM_TYPE_WORD, &minor,
  73				       G_XIM_TYPE_MARKER_N_ITEMS_2, G_XIM_TYPE_LIST_OF_STRING,
  74				       G_XIM_TYPE_LIST_OF_STRING, &list)) {
  75		retval = g_xim_protocol_closure_emit_signal(closure, proto,
  76							    major, minor, list);
  77	} else {
  78		/* better handling error */
  79		PROTO_ERROR (XIM_CONNECT, 0);
  80	}
  81
  82	g_slist_foreach(list, (GFunc)g_xim_string_free, NULL);
  83	g_slist_free(list);
  84
  85	return retval;
  86}
  87
  88static gboolean
  89g_xim_protocol10_closure_XIM_CONNECT_REPLY(GXimProtocolClosure  *closure,
  90					   GXimProtocol         *proto,
  91					   GDataInputStream     *stream,
  92					   GError              **error,
  93					   gpointer              user_data)
  94{
  95	guint16 major, minor;
  96	gboolean retval = FALSE;
  97
  98	if (g_xim_protocol_read_format(proto, stream, NULL, error, 2,
  99				       G_XIM_TYPE_WORD, &major,
 100				       G_XIM_TYPE_WORD, &minor)) {
 101		retval = g_xim_protocol_closure_emit_signal(closure, proto,
 102							    major, minor);
 103	} else {
 104		/* better handling error */
 105		PROTO_ERROR (XIM_CONNECT_REPLY, 0);
 106	}
 107
 108	return retval;
 109}
 110
 111static gboolean
 112g_xim_protocol10_closure_XIM_DISCONNECT(GXimProtocolClosure  *closure,
 113					GXimProtocol         *proto,
 114					GDataInputStream     *stream,
 115					GError              **error,
 116					gpointer              user_data)
 117{
 118	gboolean retval = FALSE;
 119
 120	retval = g_xim_protocol_closure_emit_signal(closure, proto);
 121
 122	return retval;
 123}
 124
 125static gboolean
 126g_xim_protocol10_closure_XIM_DISCONNECT_REPLY(GXimProtocolClosure  *closure,
 127					      GXimProtocol         *proto,
 128					      GDataInputStream     *stream,
 129					      GError              **error,
 130					      gpointer              user_data)
 131{
 132	GXimProtocolPrivate *priv;
 133	gboolean retval = FALSE;
 134
 135	priv = g_xim_protocol_get_private(proto);
 136
 137	retval = g_xim_protocol_closure_emit_signal(closure, proto);
 138
 139	priv->is_disconnected = TRUE;
 140
 141	return retval;
 142}
 143
 144static gboolean
 145g_xim_protocol10_closure_XIM_AUTH_REQUIRED(GXimProtocolClosure  *closure,
 146					   GXimProtocol         *proto,
 147					   GDataInputStream     *stream,
 148					   GError              **error,
 149					   gpointer              user_data)
 150{
 151	gboolean retval = FALSE;
 152
 153	/* XXX */
 154	PROTO_ERROR (XIM_AUTH_REQUIRED, 0);
 155
 156	return retval;
 157}
 158
 159static gboolean
 160g_xim_protocol10_closure_XIM_AUTH_REPLY(GXimProtocolClosure  *closure,
 161					GXimProtocol         *proto,
 162					GDataInputStream     *stream,
 163					GError              **error,
 164					gpointer              user_data)
 165{
 166	gboolean retval = FALSE;
 167
 168	/* XXX */
 169	PROTO_ERROR (XIM_AUTH_REPLY, 0);
 170
 171	return retval;
 172}
 173
 174static gboolean
 175g_xim_protocol10_closure_XIM_AUTH_NEXT(GXimProtocolClosure  *closure,
 176				       GXimProtocol         *proto,
 177				       GDataInputStream     *stream,
 178				       GError              **error,
 179				       gpointer              user_data)
 180{
 181	gboolean retval = FALSE;
 182
 183	/* XXX */
 184	PROTO_ERROR (XIM_AUTH_NEXT, 0);
 185
 186	return retval;
 187}
 188
 189static gboolean
 190g_xim_protocol10_closure_XIM_AUTH_SETUP(GXimProtocolClosure  *closure,
 191					GXimProtocol         *proto,
 192					GDataInputStream     *stream,
 193					GError              **error,
 194					gpointer              user_data)
 195{
 196	gboolean retval = FALSE;
 197
 198	/* XXX */
 199	PROTO_ERROR (XIM_AUTH_SETUP, 0);
 200
 201	return retval;
 202}
 203
 204static gboolean
 205g_xim_protocol10_closure_XIM_AUTH_NG(GXimProtocolClosure  *closure,
 206				     GXimProtocol         *proto,
 207				     GDataInputStream     *stream,
 208				     GError              **error,
 209				     gpointer              user_data)
 210{
 211	gboolean retval = FALSE;
 212
 213	retval = g_xim_protocol_closure_emit_signal(closure, proto);
 214
 215	return retval;
 216}
 217
 218static gboolean
 219g_xim_protocol10_closure_XIM_ERROR(GXimProtocolClosure  *closure,
 220				   GXimProtocol         *proto,
 221				   GDataInputStream     *stream,
 222				   GError              **error,
 223				   gpointer              user_data)
 224{
 225	gboolean retval = FALSE;
 226	guint16 imid, icid, flag, detail;
 227	GXimErrorCode error_code = 0;
 228	gchar *error_message = NULL;
 229
 230	if (g_xim_protocol_read_format(proto, stream, NULL, error, 8,
 231				       G_XIM_TYPE_WORD, &imid,
 232				       G_XIM_TYPE_WORD, &icid,
 233				       G_XIM_TYPE_WORD, &flag,
 234				       G_XIM_TYPE_WORD, &error_code,
 235				       G_XIM_TYPE_MARKER_N_BYTES_2, G_XIM_TYPE_CHAR,
 236				       G_XIM_TYPE_WORD, &detail,
 237				       G_XIM_TYPE_CHAR, &error_message,
 238				       G_XIM_TYPE_AUTO_PADDING, 0)) {
 239		retval = g_xim_protocol_closure_emit_signal(closure, proto,
 240							    imid, icid, flag, error_code, detail, error_message);
 241	}
 242	g_free(error_message);
 243
 244	return retval;
 245}
 246
 247static gboolean
 248g_xim_protocol10_closure_XIM_OPEN(GXimProtocolClosure  *closure,
 249				  GXimProtocol         *proto,
 250				  GDataInputStream     *stream,
 251				  GError              **error,
 252				  gpointer              user_data)
 253{
 254	GXimStr *locale = NULL;
 255	gboolean retval = FALSE;
 256
 257	if (g_xim_protocol_read_format(proto, stream, NULL, error, 2,
 258				       G_XIM_TYPE_STR, &locale,
 259				       G_XIM_TYPE_AUTO_PADDING, 0)) {
 260		retval = g_xim_protocol_closure_emit_signal(closure, proto,
 261							    locale);
 262	} else {
 263		/* better handling error */
 264		PROTO_ERROR (XIM_OPEN, 0);
 265	}
 266
 267	g_xim_str_free(locale);
 268
 269	return retval;
 270}
 271
 272static gboolean
 273g_xim_protocol10_closure_XIM_OPEN_REPLY(GXimProtocolClosure  *closure,
 274					GXimProtocol         *proto,
 275					GDataInputStream     *stream,
 276					GError              **error,
 277					gpointer              user_data)
 278{
 279	GSList *imlist = NULL, *iclist = NULL, *l;
 280	GXimAttr *imattr = NULL, *icattr = NULL;
 281	guint16 imid = 0;
 282	gboolean retval = FALSE;
 283
 284	if (g_xim_protocol_read_format(proto, stream, NULL, error, 6,
 285				       G_XIM_TYPE_WORD, &imid,
 286				       G_XIM_TYPE_MARKER_N_BYTES_2, G_XIM_TYPE_LIST_OF_IMATTR,
 287				       G_XIM_TYPE_LIST_OF_IMATTR, &imlist,
 288				       G_XIM_TYPE_MARKER_N_BYTES_2, G_XIM_TYPE_LIST_OF_ICATTR,
 289				       G_XIM_TYPE_PADDING, 2,
 290				       G_XIM_TYPE_LIST_OF_ICATTR, &iclist)) {
 291		imattr = g_object_new(G_TYPE_XIM_IM_ATTR, NULL);
 292		icattr = g_object_new(G_TYPE_XIM_IC_ATTR, NULL);
 293		for (l = imlist; l != NULL; l = g_slist_next(l)) {
 294			g_xim_attr_set_raw_attr(imattr, l->data);
 295			g_xim_raw_attr_free(l->data);
 296		}
 297		for (l = iclist; l != NULL; l = g_slist_next(l)) {
 298			g_xim_attr_set_raw_attr(icattr, l->data);
 299			g_xim_raw_attr_free(l->data);
 300		}
 301		g_slist_free(imlist);
 302		g_slist_free(iclist);
 303
 304		retval = g_xim_protocol_closure_emit_signal(closure, proto,
 305							    imid, imattr, icattr);
 306	} else {
 307		/* better handling error */
 308		PROTO_ERROR_IM (XIM_OPEN_REPLY, 0, imid);
 309	}
 310
 311	if (imattr)
 312		g_object_unref(imattr);
 313	if (icattr)
 314		g_object_unref(icattr);
 315
 316	return retval;
 317}
 318
 319static gboolean
 320g_xim_protocol10_closure_XIM_CLOSE(GXimProtocolClosure  *closure,
 321				   GXimProtocol         *proto,
 322				   GDataInputStream     *stream,
 323				   GError              **error,
 324				   gpointer              user_data)
 325{
 326	gboolean retval = FALSE;
 327	guint16 imid = 0;
 328
 329	if (g_xim_protocol_read_format(proto, stream, NULL, error, 2,
 330				       G_XIM_TYPE_WORD, &imid,
 331				       G_XIM_TYPE_PADDING, 2)) {
 332		retval = g_xim_protocol_closure_emit_signal(closure, proto,
 333							    imid);
 334	} else {
 335		/* better handling error */
 336		PROTO_ERROR_IM (XIM_CLOSE, 0, imid);
 337	}
 338
 339	return retval;
 340}
 341
 342static gboolean
 343g_xim_protocol10_closure_XIM_CLOSE_REPLY(GXimProtocolClosure  *closure,
 344					 GXimProtocol         *proto,
 345					 GDataInputStream     *stream,
 346					 GError              **error,
 347					 gpointer              user_data)
 348{
 349	gboolean retval = FALSE;
 350	guint16 imid = 0;
 351
 352	if (g_xim_protocol_read_format(proto, stream, NULL, error, 2,
 353				       G_XIM_TYPE_WORD, &imid,
 354				       G_XIM_TYPE_PADDING, 2)) {
 355		retval = g_xim_protocol_closure_emit_signal(closure, proto,
 356							    imid);
 357	} else {
 358		/* better handling error */
 359		PROTO_ERROR_IM (XIM_CLOSE_REPLY, 0, imid);
 360	}
 361
 362	return retval;
 363}
 364
 365static gboolean
 366g_xim_protocol10_closure_XIM_REGISTER_TRIGGERKEYS(GXimProtocolClosure  *closure,
 367						  GXimProtocol         *proto,
 368						  GDataInputStream     *stream,
 369						  GError              **error,
 370						  gpointer              user_data)
 371{
 372	gboolean retval = FALSE;
 373	guint16 imid;
 374	GSList *onkeys = NULL, *offkeys = NULL;
 375
 376	if (g_xim_protocol_read_format(proto, stream, NULL, error, 4,
 377				       G_XIM_TYPE_WORD, &imid,
 378				       G_XIM_TYPE_PADDING, 2,
 379				       G_XIM_TYPE_MARKER_N_BYTES_4, G_XIM_TYPE_LIST_OF_HOTKEY_TRIGGER,
 380				       G_XIM_TYPE_LIST_OF_HOTKEY_TRIGGER, &onkeys)) {
 381		/* check the off-keys list separately.
 382		 * some IMs sends XIM_REGISTER_TRIGGERKEYS without
 383		 * the off-keys list.
 384		 */
 385		g_xim_protocol_read_format(proto, stream, NULL, error, 2,
 386					   G_XIM_TYPE_MARKER_N_BYTES_4, G_XIM_TYPE_LIST_OF_HOTKEY_TRIGGER,
 387					   G_XIM_TYPE_LIST_OF_HOTKEY_TRIGGER, &offkeys);
 388		if (*error) {
 389			g_xim_messages_warning(G_XIM_PROTOCOL_GET_IFACE (proto)->message,
 390					       "No off-keys received in XIM_REGISTER_TRIGGERKEYS:\n  %s",
 391					       (*error)->message);
 392			g_clear_error(error);
 393		}
 394		retval = g_xim_protocol_closure_emit_signal(closure, proto,
 395							    imid, onkeys, offkeys);
 396	}
 397	g_slist_foreach(onkeys, (GFunc)g_xim_hotkey_trigger_free, NULL);
 398	g_slist_foreach(offkeys, (GFunc)g_xim_hotkey_trigger_free, NULL);
 399	g_slist_free(onkeys);
 400	g_slist_free(offkeys);
 401
 402	return retval;
 403}
 404
 405static gboolean
 406g_xim_protocol10_closure_XIM_TRIGGER_NOTIFY(GXimProtocolClosure  *closure,
 407					    GXimProtocol         *proto,
 408					    GDataInputStream     *stream,
 409					    GError              **error,
 410					    gpointer              user_data)
 411{
 412	gboolean retval = FALSE;
 413	guint16 imid = 0, icid = 0;
 414	guint32 flag, index_, mask;
 415
 416	if (g_xim_protocol_read_format(proto, stream, NULL, error, 5,
 417				       G_XIM_TYPE_WORD, &imid,
 418				       G_XIM_TYPE_WORD, &icid,
 419				       G_XIM_TYPE_LONG, &flag,
 420				       G_XIM_TYPE_LONG, &index_,
 421				       G_XIM_TYPE_LONG, &mask)) {
 422		retval = g_xim_protocol_closure_emit_signal(closure, proto,
 423							    imid, icid, flag, index_, mask);
 424	} else {
 425		/* better handling error */
 426		PROTO_ERROR_IMIC (XIM_TRIGGER_NOTIFY, 0, imid, icid);
 427	}
 428
 429	return retval;
 430}
 431
 432static gboolean
 433g_xim_protocol10_closure_XIM_TRIGGER_NOTIFY_REPLY(GXimProtocolClosure  *closure,
 434						  GXimProtocol         *proto,
 435						  GDataInputStream     *stream,
 436						  GError              **error,
 437						  gpointer              user_data)
 438{
 439	gboolean retval = FALSE;
 440	guint16 imid = 0, icid = 0;
 441
 442	if (g_xim_protocol_read_format(proto, stream, NULL, error, 2,
 443				       G_XIM_TYPE_WORD, &imid,
 444				       G_XIM_TYPE_WORD, &icid)) {
 445		retval = g_xim_protocol_closure_emit_signal(closure, proto,
 446							    imid, icid);
 447	} else {
 448		/* better handling error */
 449		PROTO_ERROR_IMIC (XIM_TRIGGER_NOTIFY_REPLY, 0, imid, icid);
 450	}
 451
 452	return retval;
 453}
 454
 455static gboolean
 456g_xim_protocol10_closure_XIM_SET_EVENT_MASK(GXimProtocolClosure  *closure,
 457					    GXimProtocol         *proto,
 458					    GDataInputStream     *stream,
 459					    GError              **error,
 460					    gpointer              user_data)
 461{
 462	gboolean retval = FALSE;
 463	guint16 imid, icid;
 464	guint32 forward_mask, sync_mask;
 465
 466	if (g_xim_protocol_read_format(proto, stream, NULL, error, 4,
 467				       G_XIM_TYPE_WORD, &imid,
 468				       G_XIM_TYPE_WORD, &icid,
 469				       G_XIM_TYPE_LONG, &forward_mask,
 470				       G_XIM_TYPE_LONG, &sync_mask)) {
 471		retval = g_xim_protocol_closure_emit_signal(closure, proto,
 472							    imid, icid, forward_mask, sync_mask);
 473	}
 474
 475	return retval;
 476}
 477
 478static gboolean
 479g_xim_protocol10_closure_XIM_ENCODING_NEGOTIATION(GXimProtocolClosure  *closure,
 480						  GXimProtocol         *proto,
 481						  GDataInputStream     *stream,
 482						  GError              **error,
 483						  gpointer              user_data)
 484{
 485	gboolean retval = FALSE;
 486	GSList *list = NULL, *enclist = NULL;
 487	guint16 imid = 0;
 488
 489	if (g_xim_protocol_read_format(proto, stream, NULL, error, 7,
 490				       G_XIM_TYPE_WORD, &imid,
 491				       G_XIM_TYPE_MARKER_N_BYTES_2, G_XIM_TYPE_LIST_OF_STR,
 492				       G_XIM_TYPE_LIST_OF_STR, &list,
 493				       G_XIM_TYPE_AUTO_PADDING, 0,
 494				       G_XIM_TYPE_MARKER_N_BYTES_2, G_XIM_TYPE_LIST_OF_ENCODINGINFO,
 495				       G_XIM_TYPE_PADDING, 2,
 496				       G_XIM_TYPE_LIST_OF_ENCODINGINFO, &enclist)) {
 497		retval = g_xim_protocol_closure_emit_signal(closure, proto,
 498							    imid, list, enclist);
 499	} else {
 500		/* better handling error */
 501		PROTO_ERROR_IM (XIM_ENCODING_NEGOTIATION, 0, imid);
 502	}
 503
 504	g_slist_foreach(list,
 505			(GFunc)g_xim_str_free,
 506			NULL);
 507	g_slist_foreach(enclist,
 508			(GFunc)g_xim_encodinginfo_free,
 509			NULL);
 510	g_slist_free(list);
 511	g_slist_free(enclist);
 512
 513	return retval;
 514}
 515
 516static gboolean
 517g_xim_protocol10_closure_XIM_ENCODING_NEGOTIATION_REPLY(GXimProtocolClosure  *closure,
 518							GXimProtocol         *proto,
 519							GDataInputStream     *stream,
 520							GError              **error,
 521							gpointer              user_data)
 522{
 523	gboolean retval = FALSE;
 524	guint16 imid = 0, category;
 525	gint16 index_;
 526
 527	if (g_xim_protocol_read_format(proto, stream, NULL, error, 4,
 528				       G_XIM_TYPE_WORD, &imid,
 529				       G_XIM_TYPE_WORD, &category,
 530				       G_XIM_TYPE_WORD, &index_,
 531				       G_XIM_TYPE_PADDING, 2)) {
 532		retval = g_xim_protocol_closure_emit_signal(closure, proto,
 533							    imid, category, index_);
 534	} else {
 535		/* better handling error */
 536		PROTO_ERROR_IM (XIM_ENCODING_NEGOTIATION_REPLY, 0, imid);
 537	}
 538
 539	return retval;
 540}
 541
 542static gboolean
 543g_xim_protocol10_closure_XIM_QUERY_EXTENSION(GXimProtocolClosure  *closure,
 544					     GXimProtocol         *proto,
 545					     GDataInputStream     *stream,
 546					     GError              **error,
 547					     gpointer              user_data)
 548{
 549	gboolean retval = FALSE;
 550	GSList *list = NULL;
 551	guint16 imid = 0;
 552
 553	if (g_xim_protocol_read_format(proto, stream, NULL, error, 4,
 554				       G_XIM_TYPE_WORD, &imid,
 555				       G_XIM_TYPE_MARKER_N_BYTES_2, G_XIM_TYPE_LIST_OF_STR,
 556				       G_XIM_TYPE_LIST_OF_STR, &list,
 557				       G_XIM_TYPE_AUTO_PADDING, 0)) {
 558		retval = g_xim_protocol_closure_emit_signal(closure, proto,
 559							    imid, list);
 560	} else {
 561		/* better handling error */
 562		PROTO_ERROR_IM (XIM_QUERY_EXTENSION, 0, imid);
 563	}
 564
 565	g_slist_foreach(list,
 566			(GFunc)g_xim_str_free,
 567			NULL);
 568	g_slist_free(list);
 569
 570	return retval;
 571}
 572
 573static gboolean
 574g_xim_protocol10_closure_XIM_QUERY_EXTENSION_REPLY(GXimProtocolClosure  *closure,
 575						   GXimProtocol         *proto,
 576						   GDataInputStream     *stream,
 577						   GError              **error,
 578						   gpointer              user_data)
 579{
 580	gboolean retval = FALSE;
 581	GSList *list = NULL;
 582	guint16 imid;
 583
 584	if (!g_xim_protocol_read_format(proto, stream, NULL, error, 1,
 585					G_XIM_TYPE_WORD, &imid)) {
 586		/* XXX: There may be no way of recoverying from here */
 587		return FALSE;
 588	}
 589	g_xim_protocol_read_format(proto, stream, NULL, error, 2,
 590				   G_XIM_TYPE_MARKER_N_BYTES_2, G_XIM_TYPE_LIST_OF_EXT,
 591				   G_XIM_TYPE_LIST_OF_EXT, &list);
 592	if (*error) {
 593		/* deal with it as warning really, because we can
 594		 * recover it.
 595		 */
 596		g_xim_messages_warning(G_XIM_PROTOCOL_GET_IFACE (proto)->message,
 597				       "%s", (*error)->message);
 598		g_clear_error(error);
 599	}
 600	/* ignore an error. we could just send the null list */
 601	retval = g_xim_protocol_closure_emit_signal(closure, proto,
 602						    imid, list);
 603
 604	g_slist_foreach(list,
 605			(GFunc)g_xim_ext_free,
 606			NULL);
 607	g_slist_free(list);
 608
 609	return retval;
 610}
 611
 612static gboolean
 613g_xim_protocol10_closure_XIM_SET_IM_VALUES(GXimProtocolClosure  *closure,
 614					   GXimProtocol         *proto,
 615					   GDataInputStream     *stream,
 616					   GError              **error,
 617					   gpointer              user_data)
 618{
 619	gboolean retval = FALSE;
 620	guint16 imid = 0;
 621	GSList *list = NULL;
 622
 623	if (g_xim_protocol_read_format(proto, stream, NULL, error, 3,
 624				       G_XIM_TYPE_WORD, &imid,
 625				       G_XIM_TYPE_MARKER_N_BYTES_2, G_XIM_TYPE_LIST_OF_IMATTRIBUTE,
 626				       G_XIM_TYPE_LIST_OF_IMATTRIBUTE, &list)) {
 627		retval = g_xim_protocol_closure_emit_signal(closure, proto,
 628							    imid, list);
 629	} else {
 630		/* better handling error */
 631		PROTO_ERROR_IM (XIM_SET_IM_VALUES, 0, imid);
 632	}
 633
 634	g_slist_foreach(list,
 635			(GFunc)g_xim_attribute_free,
 636			NULL);
 637	g_slist_free(list);
 638
 639	return retval;
 640}
 641
 642static gboolean
 643g_xim_protocol10_closure_XIM_SET_IM_VALUES_REPLY(GXimProtocolClosure  *closure,
 644						 GXimProtocol         *proto,
 645						 GDataInputStream     *stream,
 646						 GError              **error,
 647						 gpointer              user_data)
 648{
 649	gboolean retval = FALSE;
 650	guint16 imid = 0;
 651
 652	if (g_xim_protocol_read_format(proto, stream, NULL, error, 2,
 653				       G_XIM_TYPE_WORD, &imid,
 654				       G_XIM_TYPE_PADDING, 2)) {
 655		retval = g_xim_protocol_closure_emit_signal(closure, proto,
 656							    imid);
 657	} else {
 658		/* better handling error */
 659		PROTO_ERROR_IM (XIM_SET_IM_VALUES_REPLY, 0, imid);
 660	}
 661
 662	return retval;
 663}
 664
 665static gboolean
 666g_xim_protocol10_closure_XIM_GET_IM_VALUES(GXimProtocolClosure  *closure,
 667					   GXimProtocol         *proto,
 668					   GDataInputStream     *stream,
 669					   GError              **error,
 670					   gpointer              user_data)
 671{
 672	gboolean retval = FALSE;
 673	GSList *list = NULL;
 674	guint16 imid = 0;
 675
 676	if (g_xim_protocol_read_format(proto, stream, NULL, error, 4,
 677				       G_XIM_TYPE_WORD, &imid,
 678				       G_XIM_TYPE_MARKER_N_BYTES_2, G_XIM_TYPE_LIST_OF_CARD16,
 679				       G_XIM_TYPE_LIST_OF_CARD16, &list,
 680				       G_XIM_TYPE_AUTO_PADDING, 0)) {
 681		retval = g_xim_protocol_closure_emit_signal(closure, proto,
 682							    imid, list);
 683	} else {
 684		/* better handling error */
 685		PROTO_ERROR_IM (XIM_GET_IM_VALUES, 0, imid);
 686	}
 687
 688	g_slist_free(list);
 689
 690	return retval;
 691}
 692
 693static gboolean
 694g_xim_protocol10_closure_XIM_GET_IM_VALUES_REPLY(GXimProtocolClosure  *closure,
 695						 GXimProtocol         *proto,
 696						 GDataInputStream     *stream,
 697						 GError              **error,
 698						 gpointer              user_data)
 699{
 700	gboolean retval = FALSE;
 701	GSList *list = NULL;
 702	guint16 imid;
 703	GError *err = NULL;
 704
 705	if (!g_xim_protocol_read_format(proto, stream, NULL, error, 1,
 706					G_XIM_TYPE_WORD, &imid)) {
 707		/* XXX: There may be no way of recovering from here. */
 708		return FALSE;
 709	}
 710	g_xim_protocol_read_format(proto, stream, NULL, &err, 2,
 711				   G_XIM_TYPE_MARKER_N_BYTES_2, G_XIM_TYPE_LIST_OF_IMATTRIBUTE,
 712				   G_XIM_TYPE_LIST_OF_IMATTRIBUTE, &list);
 713	if (err) {
 714		/* deal with it as warning really, because we can
 715		 * recover it.
 716		 */
 717		g_xim_messages_warning(G_XIM_PROTOCOL_GET_IFACE (proto)->message,
 718				       "%s", err->message);
 719		g_error_free(err);
 720	}
 721	/* ignore an error. we could just send the null list */
 722	retval = g_xim_protocol_closure_emit_signal(closure, proto,
 723						    imid, list);
 724
 725	g_slist_foreach(list, (GFunc)g_xim_attribute_free, NULL);
 726	g_slist_free(list);
 727
 728	return retval;
 729}
 730
 731static gboolean
 732g_xim_protocol10_closure_XIM_CREATE_IC(GXimProtocolClosure  *closure,
 733				       GXimProtocol         *proto,
 734				       GDataInputStream     *stream,
 735				       GError              **error,
 736				       gpointer              user_data)
 737{
 738	gboolean retval = FALSE;
 739	GSList *list = NULL;
 740	guint16 imid;
 741
 742	if (!g_xim_protocol_read_format(proto, stream, NULL, error, 1,
 743				       G_XIM_TYPE_WORD, &imid))
 744		return FALSE;
 745
 746	g_xim_protocol_read_format(proto, stream, NULL, error, 2,
 747				   G_XIM_TYPE_MARKER_N_BYTES_2, G_XIM_TYPE_LIST_OF_ICATTRIBUTE,
 748				   G_XIM_TYPE_LIST_OF_ICATTRIBUTE, &list);
 749	/* deal with all of errors as warnings to give aid to
 750	 * the attributes retrieved successfully.
 751	 */
 752	/* XXX: or should we just send back the error? */
 753	if (*error) {
 754		g_xim_messages_warning(G_XIM_PROTOCOL_GET_IFACE (proto)->message,
 755				       "%s", (*error)->message);
 756		g_clear_error(error);
 757	}
 758	retval = g_xim_protocol_closure_emit_signal(closure, proto,
 759						    imid, list);
 760
 761	g_slist_foreach(list, (GFunc)g_xim_attribute_free, NULL);
 762	g_slist_free(list);
 763
 764	return retval;
 765}
 766
 767static gboolean
 768g_xim_protocol10_closure_XIM_CREATE_IC_REPLY(GXimProtocolClosure  *closure,
 769					     GXimProtocol         *proto,
 770					     GDataInputStream     *stream,
 771					     GError              **error,
 772					     gpointer              user_data)
 773{
 774	gboolean retval = FALSE;
 775	guint16 imid = 0, icid = 0;
 776
 777	if (g_xim_protocol_read_format(proto, stream, NULL, error, 2,
 778				       G_XIM_TYPE_WORD, &imid,
 779				       G_XIM_TYPE_WORD, &icid)) {
 780		retval = g_xim_protocol_closure_emit_signal(closure, proto,
 781							    imid, icid);
 782	} else {
 783		/* better handling error */
 784		PROTO_ERROR_IMIC (XIM_CREATE_IC_REPLY, 0, imid, icid);
 785	}
 786
 787	return retval;
 788}
 789
 790static gboolean
 791g_xim_protocol10_closure_XIM_DESTROY_IC(GXimProtocolClosure  *closure,
 792					GXimProtocol         *proto,
 793					GDataInputStream     *stream,
 794					GError              **error,
 795					gpointer              user_data)
 796{
 797	gboolean retval = FALSE;
 798	guint16 imid = 0, icid = 0;
 799
 800	if (g_xim_protocol_read_format(proto, stream, NULL, error, 2,
 801				       G_XIM_TYPE_WORD, &imid,
 802				       G_XIM_TYPE_WORD, &icid)) {
 803		retval = g_xim_protocol_closure_emit_signal(closure, proto,
 804							    imid, icid);
 805	} else {
 806		/* better handling error */
 807		PROTO_ERROR_IMIC (XIM_DESTROY_IC, 0, imid, icid);
 808	}
 809
 810	return retval;
 811}
 812
 813static gboolean
 814g_xim_protocol10_closure_XIM_DESTROY_IC_REPLY(GXimProtocolClosure  *closure,
 815					      GXimProtocol         *proto,
 816					      GDataInputStream     *stream,
 817					      GError              **error,
 818					      gpointer              user_data)
 819{
 820	gboolean retval = FALSE;
 821	guint16 imid = 0, icid = 0;
 822
 823	if (g_xim_protocol_read_format(proto, stream, NULL, error, 2,
 824				       G_XIM_TYPE_WORD, &imid,
 825				       G_XIM_TYPE_WORD, &icid)) {
 826		retval = g_xim_protocol_closure_emit_signal(closure, proto,
 827							    imid, icid);
 828	} else {
 829		/* better handling error */
 830		PROTO_ERROR_IMIC (XIM_DESTROY_IC_REPLY, 0, imid, icid);
 831	}
 832
 833	return retval;
 834}
 835
 836static gboolean
 837g_xim_protocol10_closure_XIM_SET_IC_VALUES(GXimProtocolClosure  *closure,
 838					   GXimProtocol         *proto,
 839					   GDataInputStream     *stream,
 840					   GError              **error,
 841					   gpointer              user_data)
 842{
 843	gboolean retval = FALSE;
 844	guint16 imid = 0, icid = 0;
 845	GSList *list = NULL;
 846
 847	if (g_xim_protocol_read_format(proto, stream, NULL, error, 5,
 848				       G_XIM_TYPE_WORD, &imid,
 849				       G_XIM_TYPE_WORD, &icid,
 850				       G_XIM_TYPE_MARKER_N_BYTES_2, G_XIM_TYPE_LIST_OF_ICATTRIBUTE,
 851				       G_XIM_TYPE_PADDING, 2,
 852				       G_XIM_TYPE_LIST_OF_ICATTRIBUTE, &list)) {
 853		retval = g_xim_protocol_closure_emit_signal(closure, proto,
 854							    imid, icid, list);
 855	} else {
 856		/* better handling error */
 857		PROTO_ERROR_IMIC (XIM_SET_IC_VALUES, 0, imid, icid);
 858	}
 859
 860	g_slist_foreach(list,
 861			(GFunc)g_xim_attribute_free,
 862			NULL);
 863	g_slist_free(list);
 864
 865	return retval;
 866}
 867
 868static gboolean
 869g_xim_protocol10_closure_XIM_SET_IC_VALUES_REPLY(GXimProtocolClosure  *closure,
 870						 GXimProtocol         *proto,
 871						 GDataInputStream     *stream,
 872						 GError              **error,
 873						 gpointer              user_data)
 874{
 875	gboolean retval = FALSE;
 876	guint16 imid = 0, icid = 0;
 877
 878	if (g_xim_protocol_read_format(proto, stream, NULL, error, 2,
 879				       G_XIM_TYPE_WORD, &imid,
 880				       G_XIM_TYPE_WORD, &icid)) {
 881		retval = g_xim_protocol_closure_emit_signal(closure, proto,
 882							    imid, icid);
 883	} else {
 884		/* better handling error */
 885		PROTO_ERROR_IMIC (XIM_SET_IC_VALUES_REPLY, 0, imid, icid);
 886	}
 887
 888	return retval;
 889}
 890
 891static gboolean
 892g_xim_protocol10_closure_XIM_GET_IC_VALUES(GXimProtocolClosure  *closure,
 893					   GXimProtocol         *proto,
 894					   GDataInputStream     *stream,
 895					   GError              **error,
 896					   gpointer              user_data)
 897{
 898	gboolean retval = FALSE;
 899	guint16 imid = 0, icid = 0;
 900	GSList *list = NULL;
 901
 902	if (g_xim_protocol_read_format(proto, stream, NULL, error, 5,
 903				       G_XIM_TYPE_WORD, &imid,
 904				       G_XIM_TYPE_WORD, &icid,
 905				       G_XIM_TYPE_MARKER_N_BYTES_2, G_XIM_TYPE_LIST_OF_CARD16,
 906				       G_XIM_TYPE_LIST_OF_CARD16, &list,
 907				       G_XIM_TYPE_AUTO_PADDING, 2)) {
 908		retval = g_xim_protocol_closure_emit_signal(closure, proto,
 909							    imid, icid, list);
 910	} else {
 911		/* better handling error */
 912		PROTO_ERROR_IMIC (XIM_GET_IC_VALUES, 0, imid, icid);
 913	}
 914
 915	g_slist_free(list);
 916
 917	return retval;
 918}
 919
 920static gboolean
 921g_xim_protocol10_closure_XIM_GET_IC_VALUES_REPLY(GXimProtocolClosure  *closure,
 922						 GXimProtocol         *proto,
 923						 GDataInputStream     *stream,
 924						 GError              **error,
 925						 gpointer              user_data)
 926{
 927	gboolean retval = FALSE;
 928	guint16 imid = 0, icid = 0;
 929	GSList *list = NULL;
 930
 931	if (g_xim_protocol_read_format(proto, stream, NULL, error, 5,
 932				       G_XIM_TYPE_WORD, &imid,
 933				       G_XIM_TYPE_WORD, &icid,
 934				       G_XIM_TYPE_MARKER_N_BYTES_2, G_XIM_TYPE_LIST_OF_ICATTRIBUTE,
 935				       G_XIM_TYPE_PADDING, 2,
 936				       G_XIM_TYPE_LIST_OF_ICATTRIBUTE, &list)) {
 937		retval = g_xim_protocol_closure_emit_signal(closure, proto,
 938							    imid, icid, list);
 939	} else {
 940		/* better handling error */
 941		PROTO_ERROR_IMIC (XIM_GET_IC_VALUES_REPLY, 0, imid, icid);
 942	}
 943
 944	g_slist_foreach(list, (GFunc)g_xim_attribute_free, NULL);
 945	g_slist_free(list);
 946
 947	return retval;
 948}
 949
 950static gboolean
 951g_xim_protocol10_closure_XIM_SET_IC_FOCUS(GXimProtocolClosure  *closure,
 952					  GXimProtocol         *proto,
 953					  GDataInputStream     *stream,
 954					  GError              **error,
 955					  gpointer              user_data)
 956{
 957	gboolean retval = FALSE;
 958	guint16 imid, icid;
 959
 960	if (g_xim_protocol_read_format(proto, stream, NULL, error, 2,
 961				       G_XIM_TYPE_WORD, &imid,
 962				       G_XIM_TYPE_WORD, &icid)) {
 963		retval = g_xim_protocol_closure_emit_signal(closure, proto,
 964							    imid, icid);
 965	}
 966
 967	return retval;
 968}
 969
 970static gboolean
 971g_xim_protocol10_closure_XIM_UNSET_IC_FOCUS(GXimProtocolClosure  *closure,
 972					    GXimProtocol         *proto,
 973					    GDataInputStream     *stream,
 974					    GError              **error,
 975					    gpointer              user_data)
 976{
 977	gboolean retval = FALSE;
 978	guint16 imid, icid;
 979
 980	if (g_xim_protocol_read_format(proto, stream, NULL, error, 2,
 981				       G_XIM_TYPE_WORD, &imid,
 982				       G_XIM_TYPE_WORD, &icid)) {
 983		retval = g_xim_protocol_closure_emit_signal(closure, proto,
 984							    imid, icid);
 985	}
 986
 987	return retval;
 988}
 989
 990static gboolean
 991g_xim_protocol10_closure_XIM_FORWARD_EVENT(GXimProtocolClosure  *closure,
 992					   GXimProtocol         *proto,
 993					   GDataInputStream     *stream,
 994					   GError              **error,
 995					   gpointer              user_data)
 996{
 997	gboolean retval = FALSE;
 998	guint16 imid = 0, icid = 0, flag = 0;
 999	GdkEvent *event = NULL;
1000
1001	if (g_xim_protocol_read_format(proto, stream, NULL, error, 4,
1002				       G_XIM_TYPE_WORD, &imid,
1003				       G_XIM_TYPE_WORD, &icid,
1004				       G_XIM_TYPE_WORD, &flag,
1005				       G_XIM_TYPE_GDKEVENT, &event)) {
1006		retval = g_xim_protocol_closure_emit_signal(closure, proto,
1007							    imid, icid, flag, event);
1008	} else {
1009		/* better handling error */
1010		if (flag & G_XIM_Event_Synchronous)
1011			g_xim_connection_cmd_sync_reply(G_XIM_CONNECTION (proto), imid, icid);
1012
1013		retval = g_xim_connection_cmd_forward_event(G_XIM_CONNECTION (proto), imid, icid, flag & ~G_XIM_Event_Synchronous, event);
1014	}
1015	if (event)
1016		gdk_event_free(event);
1017
1018	return retval;
1019}
1020
1021static gboolean
1022g_xim_protocol10_closure_XIM_SYNC(GXimProtocolClosure  *closure,
1023				  GXimProtocol         *proto,
1024				  GDataInputStream     *stream,
1025				  GError              **error,
1026				  gpointer              user_data)
1027{
1028	gboolean retval = FALSE;
1029	guint16 imid = 0, icid = 0;
1030
1031	if (g_xim_protocol_read_format(proto, stream, NULL, error, 2,
1032				       G_XIM_TYPE_WORD, &imid,
1033				       G_XIM_TYPE_WORD, &icid)) {
1034		retval = g_xim_protocol_closure_emit_signal(closure, proto,
1035							    imid, icid);
1036	} else {
1037		/* better handling error */
1038		PROTO_ERROR_IMIC (XIM_SYNC, 0, imid, icid);
1039	}
1040
1041	return retval;
1042}
1043
1044static gboolean
1045g_xim_protocol10_closure_XIM_SYNC_REPLY(GXimProtocolClosure  *closure,
1046					GXimProtocol         *proto,
1047					GDataInputStream     *stream,
1048					GError              **error,
1049					gpointer              user_data)
1050{
1051	gboolean retval = FALSE;
1052	guint16 imid, icid;
1053
1054	if (g_xim_protocol_read_format(proto, stream, NULL, error, 2,
1055				       G_XIM_TYPE_WORD, &imid,
1056				       G_XIM_TYPE_WORD, &icid)) {
1057		retval = g_xim_protocol_closure_emit_signal(closure, proto,
1058							    imid, icid);
1059	}
1060
1061	return retval;
1062}
1063
1064static gboolean
1065g_xim_protocol10_closure_XIM_COMMIT(GXimProtocolClosure  *closure,
1066				    GXimProtocol         *proto,
1067				    GDataInputStream     *stream,
1068				    GError              **error,
1069				    gpointer              user_data)
1070{
1071	gboolean retval = FALSE;
1072	guint16 imid = 0, icid = 0, flag = 0;
1073	gint padding = 0;
1074	guint32 keysym = GDK_KEY_VoidSymbol;
1075	GString *string = NULL;
1076
1077	if (!g_xim_protocol_read_format(proto, stream, NULL, error, 3,
1078					G_XIM_TYPE_WORD, &imid,
1079					G_XIM_TYPE_WORD, &icid,
1080					G_XIM_TYPE_WORD, &flag))
1081		goto fail;
1082
1083	if (flag & G_XIM_XLookupKeySym) {
1084		if (!g_xim_protocol_read_format(proto, stream, NULL, error, 2,
1085						G_XIM_TYPE_PADDING, 2,
1086						G_XIM_TYPE_LONG, &keysym))
1087			goto fail;
1088		padding += 2;
1089	}
1090	if (flag & G_XIM_XLookupChars) {
1091		if (!g_xim_protocol_read_format(proto, stream, NULL, error, 2,
1092						G_XIM_TYPE_GSTRING, &string,
1093						G_XIM_TYPE_AUTO_PADDING, padding))
1094			goto fail;
1095	}
1096	retval = g_xim_protocol_closure_emit_signal(closure, proto,
1097						    imid, icid, flag, keysym, string);
1098	if (string)
1099		g_string_free(string, TRUE);
1100
1101	return retval;
1102  fail:
1103	if (string)
1104		g_string_free(string, TRUE);
1105
1106	if (flag & G_XIM_XLookupSynchronous)
1107		return g_xim_connection_cmd_sync_reply(G_XIM_CONNECTION (proto), imid, icid);
1108
1109	return FALSE;
1110}
1111
1112static gboolean
1113g_xim_protocol10_closure_XIM_RESET_IC(GXimProtocolClosure  *closure,
1114				      GXimProtocol         *proto,
1115				      GDataInputStream     *stream,
1116				      GError              **error,
1117				      gpointer              user_data)
1118{
1119	gboolean retval = FALSE;
1120	guint16 imid = 0, icid = 0;
1121
1122	if (g_xim_protocol_read_format(proto, stream, NULL, error, 2,
1123				       G_XIM_TYPE_WORD, &imid,
1124				       G_XIM_TYPE_WORD, &icid)) {
1125		retval = g_xim_protocol_closure_emit_signal(closure, proto,
1126							    imid, icid);
1127	} else {
1128		/* better handling error */
1129		PROTO_ERROR_IMIC (XIM_RESET_IC, 0, imid, icid);
1130	}
1131
1132	return retval;
1133}
1134
1135static gboolean
1136g_xim_protocol10_closure_XIM_RESET_IC_REPLY(GXimProtocolClosure  *closure,
1137					    GXimProtocol         *proto,
1138					    GDataInputStream     *stream,
1139					    GError              **error,
1140					    gpointer              user_data)
1141{
1142	gboolean retval = FALSE;
1143	guint16 imid = 0, icid = 0;
1144	GString *string = NULL;
1145
1146	if (g_xim_protocol_read_format(proto, stream, NULL, error, 5,
1147				       G_XIM_TYPE_WORD, &imid,
1148				       G_XIM_TYPE_WORD, &icid,
1149				       G_XIM_TYPE_MARKER_N_BYTES_2, G_XIM_TYPE_LIST_OF_BYTE,
1150				       G_XIM_TYPE_LIST_OF_BYTE, &string,
1151				       G_XIM_TYPE_AUTO_PADDING, 2)) {
1152		retval = g_xim_protocol_closure_emit_signal(closure, proto,
1153							    imid, icid, string);
1154	} else {
1155		/* better handling error */
1156		PROTO_ERROR_IMIC (XIM_RESET_IC_REPLY, 0, imid, icid);
1157	}
1158	g_string_free(string, TRUE);
1159
1160	return retval;
1161}
1162
1163static gboolean
1164g_xim_protocol10_closure_XIM_GEOMETRY(GXimProtocolClosure  *closure,
1165				      GXimProtocol         *proto,
1166				      GDataInputStream     *stream,
1167				      GError              **error,
1168				      gpointer              user_data)
1169{
1170	gboolean retval = FALSE;
1171	guint16 imid, icid;
1172
1173	if (g_xim_protocol_read_format(proto, stream, NULL, error, 2,
1174				       G_XIM_TYPE_WORD, &imid,
1175				       G_XIM_TYPE_WORD, &icid)) {
1176		retval = g_xim_protocol_closure_emit_signal(closure, proto,
1177							    imid, icid);
1178	}
1179
1180	return retval;
1181}
1182
1183static gboolean
1184g_xim_protocol10_closure_XIM_STR_CONVERSION(GXimProtocolClosure  *closure,
1185					    GXimProtocol         *proto,
1186					    GDataInputStream     *stream,
1187					    GError              **error,
1188					    gpointer              user_data)
1189{
1190	gboolean retval = FALSE;
1191	guint16 imid = 0, icid = 0;
1192
1193	/* XXX */
1194	g_xim_protocol_read_format(proto, stream, NULL, error, 2,
1195				   G_XIM_TYPE_WORD, &imid,
1196				   G_XIM_TYPE_WORD, &icid);
1197	PROTO_ERROR_IMIC (XIM_STR_CONVERSION, 0, imid, icid);
1198
1199	return retval;
1200}
1201
1202static gboolean
1203g_xim_protocol10_closure_XIM_STR_CONVERSION_REPLY(GXimProtocolClosure  *closure,
1204						  GXimProtocol         *proto,
1205						  GDataInputStream     *stream,
1206						  GError              **error,
1207						  gpointer              user_data)
1208{
1209	gboolean retval = FALSE;
1210
1211	/* XXX */
1212	return retval;
1213}
1214
1215static gboolean
1216g_xim_protocol10_closure_XIM_PREEDIT_START(GXimProtocolClosure  *closure,
1217					   GXimProtocol         *proto,
1218					   GDataInputStream     *stream,
1219					   GError              **error,
1220					   gpointer              user_data)
1221{
1222	gboolean retval = FALSE;
1223	guint16 imid = 0, icid = 0;
1224
1225	if (g_xim_protocol_read_format(proto, stream, NULL, error, 2,
1226				       G_XIM_TYPE_WORD, &imid,
1227				       G_XIM_TYPE_WORD, &icid)) {
1228		retval = g_xim_protocol_closure_emit_signal(closure, proto,
1229							    imid, icid);
1230	} else {
1231		/* better handling error */
1232		/* XXX: should we send back PREEDIT_START_REPLY with an error in the return value? */
1233		PROTO_ERROR_IMIC (XIM_PREEDIT_START, 0, imid, icid);
1234	}
1235
1236	return retval;
1237}
1238
1239static gboolean
1240g_xim_protocol10_closure_XIM_PREEDIT_START_REPLY(GXimProtocolClosure  *closure,
1241						 GXimProtocol         *proto,
1242						 GDataInputStream     *stream,
1243						 GError              **error,
1244						 gpointer              user_data)
1245{
1246	gboolean retval = FALSE;
1247	guint16 imid, icid;
1248	gint32 ret;
1249
1250	if (g_xim_protocol_read_format(proto, stream, NULL, error, 3,
1251				       G_XIM_TYPE_WORD, &imid,
1252				       G_XIM_TYPE_WORD, &icid,
1253				       G_XIM_TYPE_LONG, &ret)) {
1254		retval = g_xim_protocol_closure_emit_signal(closure, proto,
1255							    imid, icid, ret);
1256	}
1257
1258	return retval;
1259}
1260
1261static gboolean
1262g_xim_protocol10_closure_XIM_PREEDIT_DRAW(GXimProtocolClosure  *closure,
1263					  GXimProtocol         *proto,
1264					  GDataInputStream     *stream,
1265					  GError              **error,
1266					  gpointer              user_data)
1267{
1268	gboolean retval = FALSE;
1269	guint16 imid, icid;
1270	GXimPreeditDraw *draw;
1271
1272	if (g_xim_protocol_read_format(proto, stream, NULL, error, 3,
1273				       G_XIM_TYPE_WORD, &imid,
1274				       G_XIM_TYPE_WORD, &icid,
1275				       G_XIM_TYPE_PREEDIT_DRAW, &draw)) {
1276		retval = g_xim_protocol_closure_emit_signal(closure, proto,
1277							    imid, icid, draw);
1278	}
1279	g_xim_preedit_draw_free(draw);
1280
1281	return retval;
1282}
1283
1284static gboolean
1285g_xim_protocol10_closure_XIM_PREEDIT_CARET(GXimProtocolClosure  *closure,
1286					   GXimProtocol         *proto,
1287					   GDataInputStream     *stream,
1288					   GError              **error,
1289					   gpointer              user_data)
1290{
1291	gboolean retval = FALSE;
1292	guint16 imid = 0, icid = 0;
1293	GXimPreeditCaret *caret;
1294
1295	if (g_xim_protocol_read_format(proto, stream, NULL, error, 3,
1296				       G_XIM_TYPE_WORD, &imid,
1297				       G_XIM_TYPE_WORD, &icid,
1298				       G_XIM_TYPE_PREEDIT_CARET, &caret)) {
1299		retval = g_xim_protocol_closure_emit_signal(closure, proto,
1300							    imid, icid, caret);
1301	} else {
1302		/* better handling error */
1303		/* XXX: should we send back PREEDIT_CARET_REPLY with an error in the return value? */
1304		PROTO_ERROR_IMIC (XIM_PREEDIT_CARET, 0, imid, icid);
1305	}
1306	g_xim_preedit_caret_free(caret);
1307
1308	return retval;
1309}
1310
1311static gboolean
1312g_xim_protocol10_closure_XIM_PREEDIT_CARET_REPLY(GXimProtocolClosure  *closure,
1313						 GXimProtocol         *proto,
1314						 GDataInputStream     *stream,
1315						 GError              **error,
1316						 gpointer              user_data)
1317{
1318	gboolean retval = FALSE;
1319	guint16 imid, icid;
1320	guint32 position;
1321
1322	if (g_xim_protocol_read_format(proto, stream, NULL, error, 3,
1323				       G_XIM_TYPE_WORD, &imid,
1324				       G_XIM_TYPE_WORD, &icid,
1325				       G_XIM_TYPE_LONG, &position)) {
1326		retval = g_xim_protocol_closure_emit_signal(closure, proto,
1327							    imid, icid, position);
1328	}
1329
1330	/* XXX */
1331	return retval;
1332}
1333
1334static gboolean
1335g_xim_protocol10_closure_XIM_PREEDIT_DONE(GXimProtocolClosure  *closure,
1336					  GXimProtocol         *proto,
1337					  GDataInputStream     *stream,
1338					  GError              **error,
1339					  gpointer              user_data)
1340{
1341	gboolean retval = FALSE;
1342	guint16 imid, icid;
1343
1344	if (g_xim_protocol_read_format(proto, stream, NULL, error, 2,
1345				       G_XIM_TYPE_WORD, &imid,
1346				       G_XIM_TYPE_WORD, &icid)) {
1347		retval = g_xim_protocol_closure_emit_signal(closure, proto,
1348							    imid, icid);
1349	}
1350
1351	return retval;
1352}
1353
1354static gboolean
1355g_xim_protocol10_closure_XIM_STATUS_START(GXimProtocolClosure  *closure,
1356					  GXimProtocol         *proto,
1357					  GDataInputStream     *stream,
1358					  GError              **error,
1359					  gpointer              user_data)
1360{
1361	gboolean retval = FALSE;
1362	guint16 imid, icid;
1363
1364	if (g_xim_protocol_read_format(proto, stream, NULL, error, 2,
1365				       G_XIM_TYPE_WORD, &imid,
1366				       G_XIM_TYPE_WORD, &icid)) {
1367		retval = g_xim_protocol_closure_emit_signal(closure, proto,
1368							    imid, icid);
1369	}
1370
1371	return retval;
1372}
1373
1374static gboolean
1375g_xim_protocol10_closure_XIM_STATUS_DRAW(GXimProtocolClosure  *closure,
1376					 GXimProtocol         *proto,
1377					 GDataInputStream     *stream,
1378					 GError              **error,
1379					 gpointer              user_data)
1380{
1381	gboolean retval = FALSE;
1382	guint16 imid, icid;
1383	GXimStatusDraw *draw;
1384
1385	if (g_xim_protocol_read_format(proto, stream, NULL, error, 3,
1386				       G_XIM_TYPE_WORD, &imid,
1387				       G_XIM_TYPE_WORD, &icid,
1388				       G_XIM_TYPE_STATUS_DRAW, &draw)) {
1389		retval = g_xim_protocol_closure_emit_signal(closure, proto,
1390							    imid, icid, draw);
1391	}
1392	g_xim_status_draw_free(draw);
1393
1394	return retval;
1395}
1396
1397static gboolean
1398g_xim_protocol10_closure_XIM_STATUS_DONE(GXimProtocolClosure  *closure,
1399					 GXimProtocol         *proto,
1400					 GDataInputStream     *stream,
1401					 GError              **error,
1402					 gpointer              user_data)
1403{
1404	gboolean retval = FALSE;
1405	guint16 imid, icid;
1406
1407	if (g_xim_protocol_read_format(proto, stream, NULL, error, 2,
1408				       G_XIM_TYPE_WORD, &imid,
1409				       G_XIM_TYPE_WORD, &icid)) {
1410		retval = g_xim_protocol_closure_emit_signal(closure, proto,
1411							    imid, icid);
1412	}
1413
1414	return retval;
1415}
1416
1417static gboolean
1418g_xim_protocol10_closure_XIM_PREEDITSTATE(GXimProtocolClosure  *closure,
1419					  GXimProtocol         *proto,
1420					  GDataInputStream     *stream,
1421					  GError              **error,
1422					  gpointer              user_data)
1423{
1424	gboolean retval = FALSE;
1425
1426	/* XXX */
1427	return retval;
1428}
1429
1430static void
1431gxim_marshal_FIXME(GClosure     *closure,
1432		   GValue       *return_value,
1433		   guint         n_param_values,
1434		   const GValue *param_values,
1435		   gpointer      invocation_hint,
1436		   gpointer      marshal_data)
1437{
1438	g_warning("FIXME");
1439}
1440
1441static void
1442g_xim_protocol10_closure_signal_no_impl(GXimProtocol  *proto,
1443					const gchar   *func,
1444					GXimErrorMask  flag,
1445					guint16        imid,
1446					guint16        icid)
1447{
1448	GXimProtocolIface *iface;
1449	static const gchar message[] = "Not yet implemented or any errors occurred";
1450	static size_t len = 0;
1451
1452	iface = G_XIM_PROTOCOL_GET_IFACE (proto);
1453	if (len == 0)
1454		len = strlen(message);
1455
1456	g_xim_messages_bug(iface->message, "No real implementation of `%s' or any errors occurred.", func);
1457	g_xim_connection_cmd_error(G_XIM_CONNECTION (proto), imid, icid, flag,
1458				   G_XIM_ERR_BadSomething, 0, message);
1459}
1460
1461static gboolean
1462g_xim_protocol10_closure_signal_XIM_CONNECT(GXimProtocol *proto,
1463					    guint16       major_version,
1464					    guint16       minor_version,
1465					    const GSList *list)
1466{
1467	return g_xim_connection_cmd_auth_ng(G_XIM_CONNECTION (proto));
1468}
1469
1470static gboolean
1471g_xim_protocol10_closure_signal_XIM_CONNECT_REPLY(GXimProtocol *proto,
1472						  guint16       major_version,
1473						  guint16       minor_version)
1474{
1475	MSG_NOIMPL(XIM_CONNECT_REPLY);
1476
1477	return TRUE;
1478}
1479
1480static gboolean
1481g_xim_protocol10_closure_signal_XIM_DISCONNECT(GXimProtocol *proto)
1482{
1483	SIG_NOIMPL(XIM_DISCONNECT);
1484
1485	return TRUE;
1486}
1487
1488static gboolean
1489g_xim_protocol10_closure_signal_XIM_DISCONNECT_REPLY(GXimProtocol *proto)
1490{
1491	MSG_NOIMPL(XIM_DISCONNECT_REPLY);
1492
1493	return TRUE;
1494}
1495
1496static gboolean
1497g_xim_protocol10_closure_signal_XIM_AUTH_REQUIRED(GXimProtocol *proto,
1498						  const gchar  *auth_data,
1499						  gsize         length)
1500{
1501	return g_xim_connection_cmd_auth_ng(G_XIM_CONNECTION (proto));
1502}
1503
1504static gboolean
1505g_xim_protocol10_closure_signal_XIM_AUTH_REPLY(GXimProtocol *proto,
1506					       const gchar  *auth_data,
1507					       gsize         length)
1508{
1509	return g_xim_connection_cmd_auth_ng(G_XIM_CONNECTION (proto));
1510}
1511
1512static gboolean
1513g_xim_protocol10_closure_signal_XIM_AUTH_NEXT(GXimProtocol *proto,
1514					      const gchar  *auth_data,
1515					      gsize         length)
1516{
1517	return g_xim_connection_cmd_auth_ng(G_XIM_CONNECTION (proto));
1518}
1519
1520static gboolean
1521g_xim_protocol10_closure_signal_XIM_AUTH_SETUP(GXimProtocol *proto,
1522					       const GSList *list)
1523{
1524	return g_xim_connection_cmd_auth_ng(G_XIM_CONNECTION (proto));
1525}
1526
1527static gboolean
1528g_xim_protocol10_closure_signal_XIM_AUTH_NG(GXimProtocol *proto)
1529{
1530	MSG_NOIMPL(XIM_AUTH_NG);
1531
1532	return TRUE;
1533}
1534
1535static gboolean
1536g_xim_protocol10_closure_signal_XIM_ERROR(GXimProtocol  *proto,
1537					  guint16        imid,
1538					  guint16        icid,
1539					  GXimErrorMask  flag,
1540					  GXimErrorCode  error_code,
1541					  guint16        detail,
1542					  const gchar   *error_message)
1543{
1544	gchar *simid, *sicid;
1545
1546	if (flag & G_XIM_EMASK_VALID_IMID)
1547		simid = g_strdup_printf("imid: %d, ", imid);
1548	else
1549		simid = g_strdup("");
1550	if (flag & G_XIM_EMASK_VALID_ICID)
1551		sicid = g_strdup_printf("icid: %d, ", icid);
1552	else
1553		sicid = g_strdup("");
1554	g_xim_messages_error(G_XIM_PROTOCOL_GET_IFACE (proto)->message,
1555			     "Received an error: %s%s error_code: %d, detail: %d, message: %s",
1556			     simid, sicid, error_code, detail, error_message);
1557	g_free(simid);
1558	g_free(sicid);
1559
1560	return TRUE;
1561}
1562
1563static gboolean
1564g_xim_protocol10_closure_signal_XIM_OPEN(GXimProtocol  *proto,
1565					 const GXimStr *locale)
1566{
1567	SIG_NOIMPL(XIM_OPEN);
1568
1569	return TRUE;
1570}
1571
1572static gboolean
1573g_xim_protocol10_closure_signal_XIM_OPEN_REPLY(GXimProtocol *proto,
1574					       guint16       imid,
1575					       GXimIMAttr   *imattr,
1576					       GXimICAttr   *icattr)
1577{
1578	MSG_NOIMPL_IM(XIM_OPEN_REPLY, imid);
1579
1580	return TRUE;
1581}
1582
1583static gboolean
1584g_xim_protocol10_closure_signal_XIM_CLOSE(GXimProtocol *proto,
1585					  guint16       imid)
1586{
1587	SIG_NOIMPL_IM(XIM_CLOSE, imid);
1588
1589	return TRUE;
1590}
1591
1592static gboolean
1593g_xim_protocol10_closure_signal_XIM_CLOSE_REPLY(GXimProtocol *proto,
1594						guint16       imid)
1595{
1596	MSG_NOIMPL_IM(XIM_CLOSE_REPLY, imid);
1597
1598	return TRUE;
1599}
1600
1601static gboolean
1602g_xim_protocol10_closure_signal_XIM_REGISTER_TRIGGERKEYS(GXimProtocol *proto,
1603							 guint16       imid,
1604							 const GSList *onkeys,
1605							 const GSList *offkeys)
1606{
1607	MSG_NOIMPL_IM(XIM_REGISTER_TRIGGERKEYS, imid);
1608
1609	return TRUE;
1610}
1611
1612static gboolean
1613g_xim_protocol10_closure_signal_XIM_TRIGGER_NOTIFY(GXimProtocol *proto,
1614						   guint16       imid,
1615						   guint16       icid,
1616						   guint32       flag,
1617						   guint32       index_,
1618						   guint32       mask)
1619{
1620	SIG_NOIMPL_IMIC(XIM_TRIGGER_NOTIFY, imid, icid);
1621
1622	return TRUE;
1623}
1624
1625static gboolean
1626g_xim_protocol10_closure_signal_XIM_TRIGGER_NOTIFY_REPLY(GXimProtocol *proto,
1627							 guint16       imid,
1628							 guint16       icid)
1629{
1630	MSG_NOIMPL_IMIC(XIM_TRIGGER_NOTIFY_REPLY, imid, icid);
1631
1632	return TRUE;
1633}
1634
1635static gboolean
1636g_xim_protocol10_closure_signal_XIM_SET_EVENT_MASK(GXimProtocol *proto,
1637						   guint16       imid,
1638						   guint16       icid,
1639						   guint32       forward_event_mask,
1640						   guint32       synchronous_event_mask)
1641{
1642	MSG_NOIMPL_IMIC(XIM_SET_EVENT_MASK, imid, icid);
1643
1644	return TRUE;
1645}
1646
1647static gboolean
1648g_xim_protocol10_closure_signal_XIM_ENCODING_NEGOTIATION(GXimProtocol *proto,
1649							 guint16       imid,
1650							 const GSList *encodings,
1651							 const GSList *details)
1652{
1653	SIG_NOIMPL_IM(XIM_ENCODING_NEGOTIATION, imid);
1654
1655	return TRUE;
1656}
1657
1658static gboolean
1659g_xim_protocol10_closure_signal_XIM_ENCODING_NEGOTIATION_REPLY(GXimProtocol *proto,
1660							       guint16       imid,
1661							       guint16       category,
1662							       gint16        index_)
1663{
1664	MSG_NOIMPL_IM(XIM_ENCODING_NEGOTIATION_REPLY, imid);
1665
1666	return TRUE;
1667}
1668
1669static gboolean
1670g_xim_protocol10_closure_signal_XIM_QUERY_EXTENSION(GXimProtocol *proto,
1671						    guint16       imid,
1672						    const GSList *extensions)
1673{
1674	SIG_NOIMPL_IM(XIM_QUERY_EXTENSION, imid);
1675
1676	return TRUE;
1677}
1678
1679static gboolean
1680g_xim_protocol10_closure_signal_XIM_QUERY_EXTENSION_REPLY(GXimProtocol *proto,
1681							  guint16       imid,
1682							  const GSList *extensions)
1683{
1684	MSG_NOIMPL_IM(XIM_QUERY_EXTENSION_REPLY, imid);
1685
1686	return TRUE;
1687}
1688
1689static gboolean
1690g_xim_protocol10_closure_signal_XIM_SET_IM_VALUES(GXimProtocol *proto,
1691						  guint16       imid,
1692						  const GSList *attributes)
1693{
1694	SIG_NOIMPL_IM(XIM_SET_IM_VALUES, imid);
1695
1696	return TRUE;
1697}
1698
1699static gboolean
1700g_xim_protocol10_closure_signal_XIM_SET_IM_VALUES_REPLY(GXimProtocol *proto,
1701							guint16       imid)
1702{
1703	MSG_NOIMPL_IM(XIM_SET_IM_VALUES_REPLY, imid);
1704
1705	return TRUE;
1706}
1707
1708static gboolean
1709g_xim_protocol10_closure_signal_XIM_GET_IM_VALUES(GXimProtocol *proto,
1710						  guint16       imid,
1711						  const GSList *attr_id)
1712{
1713	SIG_NOIMPL_IM(XIM_GET_IM_VALUES, imid);
1714
1715	return TRUE;
1716}
1717
1718static gboolean
1719g_xim_protocol10_closure_signal_XIM_GET_IM_VALUES_REPLY(GXimProtocol *proto,
1720							guint16       imid,
1721							const GSList *attributes)
1722{
1723	MSG_NOIMPL_IM(XIM_GET_IM_VALUES_REPLY, imid);
1724
1725	return TRUE;
1726}
1727
1728static gboolean
1729g_xim_protocol10_closure_signal_XIM_CREATE_IC(GXimProtocol *proto,
1730					      guint16       imid,
1731					      const GSList *attributes)
1732{
1733	SIG_NOIMPL_IM(XIM_CREATE_IC, imid);
1734
1735	return TRUE;
1736}
1737
1738static gboolean
1739g_xim_protocol10_closure_signal_XIM_CREATE_IC_REPLY(GXimProtocol *proto,
1740						    guint16       imid,
1741						    guint16       icid)
1742{
1743	MSG_NOIMPL_IMIC(XIM_CREATE_IC_REPLY, imid, icid);
1744
1745	return TRUE;
1746}
1747
1748static gboolean
1749g_xim_protocol10_closure_signal_XIM_DESTROY_IC(GXimProtocol *proto,
1750					       guint16       imid,
1751					       guint16       icid)
1752{
1753	MSG_NOIMPL_IMIC(XIM_DESTROY_IC, imid, icid);
1754
1755	if (!G_IS_XIM_SERVER_CONNECTION (proto)) {
1756		g_xim_messages_error(G_XIM_PROTOCOL_GET_IFACE (proto)->message,
1757				     "Non-server connection received XIM_DESTROY_IC [imid: %d, icid: %d]",
1758				     imid, icid);
1759		return FALSE;
1760	}
1761
1762	return g_xim_server_connection_cmd_destroy_ic_reply(G_XIM_SERVER_CONNECTION (proto), imid, icid);
1763}
1764
1765static gboolean
1766g_xim_protocol10_closure_signal_XIM_DESTROY_IC_REPLY(GXimProtocol *proto,
1767						     guint16       imid,
1768						     guint16       icid)
1769{
1770	MSG_NOIMPL_IMIC(XIM_DESTROY_IC_REPLY, imid, icid);
1771
1772	return TRUE;
1773}
1774
1775static gboolean
1776g_xim_protocol10_closure_signal_XIM_SET_IC_VALUES(GXimProtocol *proto,
1777						  guint16       imid,
1778						  guint16       icid,
1779						  const GSList *attributes)
1780{
1781	SIG_NOIMPL_IMIC(XIM_SET_IC_VALUES, imid, icid);
1782
1783	return TRUE;
1784}
1785
1786static gboolean
1787g_xim_protocol10_closure_signal_XIM_SET_IC_VALUES_REPLY(GXimProtocol *proto,
1788							guint16       imid,
1789							guint16       icid)
1790{
1791	MSG_NOIMPL_IMIC(XIM_SET_IC_VALUES_REPLY, imid, icid);
1792
1793	return TRUE;
1794}
1795
1796static gboolean
1797g_xim_protocol10_closure_signal_XIM_GET_IC_VALUES(GXimProtocol *proto,
1798						  guint16       imid,
1799						  guint16       icid,
1800						  const GSList *att

Large files files are truncated, but you can click here to view the full file