wrapper/xim/IMdkit/i18nClbk.c

   1 /******************************************************************
   2
   3          Copyright 1994, 1995 by Sun Microsystems, Inc.
   4          Copyright 1993, 1994 by Hewlett-Packard Company
   5
   6 Permission to use, copy, modify, distribute, and sell this software
   7 and its documentation for any purpose is hereby granted without fee,
   8 provided that the above copyright notice appear in all copies and
   9 that both that copyright notice and this permission notice appear
  10 in supporting documentation, and that the name of Sun Microsystems, Inc.
  11 and Hewlett-Packard not be used in advertising or publicity pertaining to
  12 distribution of the software without specific, written prior permission.
  13 Sun Microsystems, Inc. and Hewlett-Packard make no representations about
  14 the suitability of this software for any purpose.  It is provided "as is"
  15 without express or implied warranty.
  16
  17 SUN MICROSYSTEMS INC. AND HEWLETT-PACKARD COMPANY DISCLAIMS ALL
  18 WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED
  19 WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  20 SUN MICROSYSTEMS, INC. AND HEWLETT-PACKARD COMPANY BE LIABLE FOR ANY
  21 SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
  22 RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
  23 CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
  24 IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  25
  26   Author: Hidetoshi Tajima(tajima@Eng.Sun.COM) Sun Microsystems, Inc.
  27
  28     This version tidied and debugged by Steve Underwood May 1999
  29
  30 ******************************************************************/
  31
  32 #include <X11/Xlib.h>
  33 #include "IMdkit.h"
  34 #include "Xi18n.h"
  35 #include "FrameMgr.h"
  36 #include "XimFunc.h"
  37
  38 int _Xi18nGeometryCallback (XIMS ims, IMProtocol *call_data)
  39 {
  40     Xi18n i18n_core = ims->protocol;
  41     FrameMgr fm;
  42     extern XimFrameRec geometry_fr[];
  43     register int total_size;
  44     unsigned char *reply = NULL;
  45     IMGeometryCBStruct *geometry_CB =
  46         (IMGeometryCBStruct *) &call_data->geometry_callback;
  47     CARD16 connect_id = call_data->any.connect_id;
  48
  49     fm = FrameMgrInit (geometry_fr,
  50                        NULL,
  51                        _Xi18nNeedSwap (i18n_core, connect_id));
  52
  53     total_size = FrameMgrGetTotalSize (fm);
  54     reply = (unsigned char *) malloc (total_size);
  55     if (!reply)
  56     {
  57         _Xi18nSendMessage (ims, connect_id, XIM_ERROR, 0, 0, 0);
  58         return False;
  59     }
  60     /*endif*/
  61     memset (reply, 0, total_size);
  62     FrameMgrSetBuffer (fm, reply);
  63
  64     FrameMgrPutToken (fm, connect_id);
  65     FrameMgrPutToken (fm, geometry_CB->icid);
  66
  67     _Xi18nSendMessage (ims,
  68                        connect_id,
  69                        XIM_GEOMETRY,
  70                        0,
  71                        reply,
  72                        total_size);
  73     FrameMgrFree (fm);
  74     XFree (reply);
  75
  76     /* XIM_GEOMETRY is an asyncronous protocol,
  77        so return immediately. */
  78     return True;
  79 }
  80
  81 int _Xi18nPreeditStartCallback (XIMS ims, IMProtocol *call_data)
  82 {
  83     Xi18n i18n_core = ims->protocol;
  84     FrameMgr fm;
  85     extern XimFrameRec preedit_start_fr[];
  86     register int total_size;
  87     unsigned char *reply = NULL;
  88     IMPreeditCBStruct *preedit_CB =
  89         (IMPreeditCBStruct*) &call_data->preedit_callback;
  90     CARD16 connect_id = call_data->any.connect_id;
  91
  92     fm = FrameMgrInit (preedit_start_fr,
  93                        NULL,
  94                        _Xi18nNeedSwap (i18n_core, connect_id));
  95     total_size = FrameMgrGetTotalSize (fm);
  96     reply = (unsigned char *) malloc (total_size);
  97     if (!reply)
  98     {
  99         _Xi18nSendMessage(ims, connect_id, XIM_ERROR, 0, 0, 0);
 100         return False;
 101     }
 102     /*endif*/
 103     memset (reply, 0, total_size);
 104     FrameMgrSetBuffer (fm, reply);
 105
 106     FrameMgrPutToken (fm, connect_id);
 107     FrameMgrPutToken (fm, preedit_CB->icid);
 108
 109     _Xi18nSendMessage (ims,
 110                        connect_id,
 111                        XIM_PREEDIT_START,
 112                        0,
 113                        reply,
 114                        total_size);
 115     FrameMgrFree (fm);
 116     XFree (reply);
 117
 118     return True;
 119 }
 120
 121 int _Xi18nPreeditDrawCallback (XIMS ims, IMProtocol *call_data)
 122 {
 123     Xi18n i18n_core = ims->protocol;
 124     FrameMgr fm;
 125     extern XimFrameRec preedit_draw_fr[];
 126     register int total_size;
 127     unsigned char *reply = NULL;
 128     IMPreeditCBStruct *preedit_CB =
 129         (IMPreeditCBStruct *) &call_data->preedit_callback;
 130     XIMPreeditDrawCallbackStruct *draw =
 131         (XIMPreeditDrawCallbackStruct *) &preedit_CB->todo.draw;
 132     CARD16 connect_id = call_data->any.connect_id;
 133     register int feedback_count;
 134     register int i;
 135     BITMASK32 status = 0x0;
 136
 137     if (draw->text->length == 0)
 138         status = 0x00000001;
 139     else if (draw->text->feedback[0] == 0)
 140         status = 0x00000002;
 141     /*endif*/
 142
 143     fm = FrameMgrInit (preedit_draw_fr,
 144                        NULL,
 145                        _Xi18nNeedSwap (i18n_core, connect_id));
 146
 147     /* set length of preedit string */
 148     FrameMgrSetSize (fm, draw->text->length);
 149
 150     /* set iteration count for list of feedback */
 151     for (i = 0;  draw->text->feedback[i] != 0;  i++)
 152         ;
 153     /*endfor*/
 154     feedback_count = i;
 155     FrameMgrSetIterCount (fm, feedback_count);
 156
 157     total_size = FrameMgrGetTotalSize (fm);
 158     reply = (unsigned char *) malloc (total_size);
 159     if (!reply)
 160     {
 161         _Xi18nSendMessage (ims, connect_id, XIM_ERROR, 0, 0, 0);
 162         return False;
 163     }
 164     /*endif*/
 165     memset (reply, 0, total_size);
 166     FrameMgrSetBuffer (fm, reply);
 167
 168     FrameMgrPutToken (fm, connect_id);
 169     FrameMgrPutToken (fm, preedit_CB->icid);
 170     FrameMgrPutToken (fm, draw->caret);
 171     FrameMgrPutToken (fm, draw->chg_first);
 172     FrameMgrPutToken (fm, draw->chg_length);
 173     FrameMgrPutToken (fm, status);
 174     FrameMgrPutToken (fm, draw->text->length);
 175     FrameMgrPutToken (fm, draw->text->string);
 176     for (i = 0;  i < feedback_count;  i++)
 177         FrameMgrPutToken (fm, draw->text->feedback[i]);
 178     /*endfor*/
 179
 180     _Xi18nSendMessage (ims,
 181                        connect_id,
 182                        XIM_PREEDIT_DRAW,
 183                        0,
 184                        reply,
 185                        total_size);
 186     FrameMgrFree (fm);
 187     XFree (reply);
 188
 189     /* XIM_PREEDIT_DRAW is an asyncronous protocol, so return immediately. */
 190     return True;
 191 }
 192
 193 int _Xi18nPreeditCaretCallback (XIMS ims, IMProtocol *call_data)
 194 {
 195     Xi18n i18n_core = ims->protocol;
 196     FrameMgr fm;
 197     extern XimFrameRec preedit_caret_fr[];
 198     register int total_size;
 199     unsigned char *reply = NULL;
 200     IMPreeditCBStruct *preedit_CB =
 201         (IMPreeditCBStruct*) &call_data->preedit_callback;
 202     XIMPreeditCaretCallbackStruct *caret =
 203         (XIMPreeditCaretCallbackStruct *) &preedit_CB->todo.caret;
 204     CARD16 connect_id = call_data->any.connect_id;
 205
 206     fm = FrameMgrInit (preedit_caret_fr,
 207                        NULL,
 208                        _Xi18nNeedSwap (i18n_core, connect_id));
 209
 210     total_size = FrameMgrGetTotalSize (fm);
 211     reply = (unsigned char *) malloc (total_size);
 212     if (!reply)
 213     {
 214         _Xi18nSendMessage (ims, connect_id, XIM_ERROR, 0, 0, 0);
 215         return False;
 216     }
 217     /*endif*/
 218     memset (reply, 0, total_size);
 219     FrameMgrSetBuffer (fm, reply);
 220
 221     FrameMgrPutToken (fm, connect_id);
 222     FrameMgrPutToken (fm, preedit_CB->icid);
 223     FrameMgrPutToken (fm, caret->position);
 224     FrameMgrPutToken (fm, caret->direction);
 225     FrameMgrPutToken (fm, caret->style);
 226
 227     _Xi18nSendMessage (ims,
 228                        connect_id,
 229                        XIM_PREEDIT_CARET,
 230                        0,
 231                        reply,
 232                        total_size);
 233     FrameMgrFree (fm);
 234     XFree (reply);
 235
 236     return True;
 237 }
 238
 239 int _Xi18nPreeditDoneCallback (XIMS ims, IMProtocol *call_data)
 240 {
 241     Xi18n i18n_core = ims->protocol;
 242     FrameMgr fm;
 243     extern XimFrameRec preedit_done_fr[];
 244     register int total_size;
 245     unsigned char *reply = NULL;
 246     IMPreeditCBStruct *preedit_CB =
 247         (IMPreeditCBStruct *) &call_data->preedit_callback;
 248     CARD16 connect_id = call_data->any.connect_id;
 249
 250     fm = FrameMgrInit (preedit_done_fr,
 251                        NULL,
 252                        _Xi18nNeedSwap (i18n_core, connect_id));
 253
 254     total_size = FrameMgrGetTotalSize (fm);
 255     reply = (unsigned char *) malloc (total_size);
 256     if (!reply)
 257     {
 258         _Xi18nSendMessage (ims, connect_id, XIM_ERROR, 0, 0, 0);
 259         return False;
 260     }
 261     /*endif*/
 262     memset (reply, 0, total_size);
 263     FrameMgrSetBuffer (fm, reply);
 264
 265     FrameMgrPutToken (fm, connect_id);
 266     FrameMgrPutToken (fm, preedit_CB->icid);
 267
 268     _Xi18nSendMessage (ims,
 269                        connect_id,
 270                        XIM_PREEDIT_DONE,
 271                        0,
 272                        reply,
 273                        total_size);
 274     FrameMgrFree (fm);
 275     XFree (reply);
 276
 277     /* XIM_PREEDIT_DONE is an asyncronous protocol, so return immediately. */
 278     return True;
 279 }
 280
 281 int _Xi18nStatusStartCallback (XIMS ims, IMProtocol *call_data)
 282 {
 283     Xi18n i18n_core = ims->protocol;
 284     FrameMgr fm;
 285     extern XimFrameRec status_start_fr[];
 286     register int total_size;
 287     unsigned char *reply = NULL;
 288     IMStatusCBStruct *status_CB =
 289         (IMStatusCBStruct*) &call_data->status_callback;
 290     CARD16 connect_id = call_data->any.connect_id;
 291
 292     fm = FrameMgrInit (status_start_fr,
 293                        NULL,
 294                        _Xi18nNeedSwap (i18n_core, connect_id));
 295     total_size = FrameMgrGetTotalSize (fm);
 296     reply = (unsigned char *) malloc (total_size);
 297     if (!reply)
 298     {
 299         _Xi18nSendMessage (ims, connect_id, XIM_ERROR, 0, 0, 0);
 300         return False;
 301     }
 302     /*endif*/
 303     memset (reply, 0, total_size);
 304     FrameMgrSetBuffer (fm, reply);
 305
 306     FrameMgrPutToken (fm, connect_id);
 307     FrameMgrPutToken (fm, status_CB->icid);
 308
 309     _Xi18nSendMessage (ims,
 310                        connect_id,
 311                        XIM_STATUS_START,
 312                        0,
 313                        reply,
 314                        total_size);
 315     FrameMgrFree (fm);
 316     XFree (reply);
 317
 318     /* XIM_STATUS_START is an asyncronous protocol, so return immediately. */
 319     return True;
 320 }
 321
 322 int _Xi18nStatusDrawCallback (XIMS ims, IMProtocol *call_data)
 323 {
 324     Xi18n i18n_core = ims->protocol;
 325     FrameMgr fm = (FrameMgr)0;
 326     extern XimFrameRec status_draw_text_fr[];
 327     extern XimFrameRec status_draw_bitmap_fr[];
 328     register int total_size = 0;
 329     unsigned char *reply = NULL;
 330     IMStatusCBStruct *status_CB =
 331         (IMStatusCBStruct *) &call_data->status_callback;
 332     XIMStatusDrawCallbackStruct *draw =
 333         (XIMStatusDrawCallbackStruct *) &status_CB->todo.draw;
 334     CARD16 connect_id = call_data->any.connect_id;
 335     register int feedback_count;
 336     register int i;
 337     BITMASK32 status = 0x0;
 338
 339     switch (draw->type)
 340     {
 341     case XIMTextType:
 342         fm = FrameMgrInit (status_draw_text_fr,
 343                            NULL,
 344                            _Xi18nNeedSwap (i18n_core, connect_id));
 345
 346         if (draw->data.text->length == 0)
 347             status = 0x00000001;
 348         else if (draw->data.text->feedback[0] == 0)
 349             status = 0x00000002;
 350         /*endif*/
 351
 352         /* set length of status string */
 353         FrameMgrSetSize(fm, draw->data.text->length);
 354         /* set iteration count for list of feedback */
 355         for (i = 0;  draw->data.text->feedback[i] != 0;  i++)
 356             ;
 357         /*endfor*/
 358         feedback_count = i;
 359         FrameMgrSetIterCount (fm, feedback_count);
 360
 361         total_size = FrameMgrGetTotalSize (fm);
 362         reply = (unsigned char *) malloc (total_size);
 363         if (!reply)
 364         {
 365             _Xi18nSendMessage (ims, connect_id, XIM_ERROR, 0, 0, 0);
 366             return False;
 367         }
 368         /*endif*/
 369         memset (reply, 0, total_size);
 370         FrameMgrSetBuffer (fm, reply);
 371
 372         FrameMgrPutToken (fm, connect_id);
 373         FrameMgrPutToken (fm, status_CB->icid);
 374         FrameMgrPutToken (fm, draw->type);
 375         FrameMgrPutToken (fm, status);
 376         FrameMgrPutToken (fm, draw->data.text->length);
 377         FrameMgrPutToken (fm, draw->data.text->string);
 378         for (i = 0;  i < feedback_count;  i++)
 379             FrameMgrPutToken (fm, draw->data.text->feedback[i]);
 380         /*endfor*/
 381         break;
 382
 383     case XIMBitmapType:
 384         fm = FrameMgrInit (status_draw_bitmap_fr,
 385                            NULL,
 386                            _Xi18nNeedSwap (i18n_core, connect_id));
 387
 388         total_size = FrameMgrGetTotalSize (fm);
 389         reply = (unsigned char *) malloc (total_size);
 390         if (!reply)
 391         {
 392             _Xi18nSendMessage (ims, connect_id, XIM_ERROR, 0, 0, 0);
 393             return False;
 394         }
 395         /*endif*/
 396         memset (reply, 0, total_size);
 397         FrameMgrSetBuffer (fm, reply);
 398
 399         FrameMgrPutToken (fm, connect_id);
 400         FrameMgrPutToken (fm, status_CB->icid);
 401         FrameMgrPutToken (fm, draw->data.bitmap);
 402         break;
 403     }
 404     /*endswitch*/
 405     _Xi18nSendMessage (ims,
 406                        connect_id,
 407                        XIM_STATUS_DRAW,
 408                        0,
 409                        reply,
 410                        total_size);
 411     FrameMgrFree (fm);
 412     XFree (reply);
 413
 414     /* XIM_STATUS_DRAW is an asyncronous protocol, so return immediately. */
 415     return True;
 416 }
 417
 418 int _Xi18nStatusDoneCallback (XIMS ims, IMProtocol *call_data)
 419 {
 420     Xi18n i18n_core = ims->protocol;
 421     FrameMgr fm;
 422     extern XimFrameRec status_done_fr[];
 423     register int total_size;
 424     unsigned char *reply = NULL;
 425     IMStatusCBStruct *status_CB =
 426         (IMStatusCBStruct *) &call_data->status_callback;
 427     CARD16 connect_id = call_data->any.connect_id;
 428
 429     fm = FrameMgrInit (status_done_fr,
 430                        NULL,
 431                        _Xi18nNeedSwap (i18n_core, connect_id));
 432
 433     total_size = FrameMgrGetTotalSize (fm);
 434     reply = (unsigned char *) malloc (total_size);
 435     if (!reply)
 436     {
 437         _Xi18nSendMessage (ims, connect_id, XIM_ERROR, 0, 0, 0);
 438         return False;
 439     }
 440     /*endif*/
 441     memset (reply, 0, total_size);
 442     FrameMgrSetBuffer (fm, reply);
 443
 444     FrameMgrPutToken (fm, connect_id);
 445     FrameMgrPutToken (fm, status_CB->icid);
 446
 447     _Xi18nSendMessage (ims,
 448                        connect_id,
 449                        XIM_STATUS_DONE,
 450                        0,
 451                        reply,
 452                        total_size);
 453     FrameMgrFree (fm);
 454     XFree (reply);
 455
 456     /* XIM_STATUS_DONE is an asyncronous protocol, so return immediately. */
 457     return True;
 458 }
 459
 460 int _Xi18nStringConversionCallback (XIMS ims, IMProtocol *call_data)
 461 {
 462     Xi18n i18n_core = ims->protocol;
 463     FrameMgr fm;
 464     extern XimFrameRec str_conversion_fr[];
 465     register int total_size;
 466     unsigned char *reply = NULL;
 467     IMStrConvCBStruct *call_back =
 468         (IMStrConvCBStruct *) &call_data->strconv_callback;
 469     XIMStringConversionCallbackStruct *strconv =
 470         (XIMStringConversionCallbackStruct *) &call_back->strconv;
 471     CARD16 connect_id = call_data->any.connect_id;
 472
 473     fm = FrameMgrInit (str_conversion_fr,
 474                        NULL,
 475                       _Xi18nNeedSwap (i18n_core, connect_id));
 476
 477     total_size = FrameMgrGetTotalSize (fm);
 478     reply = (unsigned char *) malloc (total_size);
 479     if (!reply)
 480     {
 481         _Xi18nSendMessage (ims, connect_id, XIM_ERROR, 0, 0, 0);
 482         return False;
 483     }
 484     /*endif*/
 485     memset (reply, 0, total_size);
 486     FrameMgrSetBuffer (fm, reply);
 487
 488     FrameMgrPutToken (fm, connect_id);
 489     FrameMgrPutToken (fm, call_back->icid);
 490     FrameMgrPutToken (fm, strconv->position);
 491     FrameMgrPutToken (fm, strconv->direction);
 492     FrameMgrPutToken (fm, strconv->operation);
 493
 494     _Xi18nSendMessage (ims, connect_id,
 495                        XIM_STR_CONVERSION,
 496                        0,
 497                        reply,
 498                        total_size);
 499     FrameMgrFree (fm);
 500     XFree (reply);
 501
 502     /* XIM_STR_CONVERSION is a syncronous protocol,
 503        so should wait here for XIM_STR_CONVERSION_REPLY. */
 504     if (i18n_core->methods.wait (ims,
 505                                  connect_id,
 506                                  XIM_STR_CONVERSION_REPLY,
 507                                  0) == False)
 508     {
 509         return False;
 510     }
 511     /*endif*/
 512     return True;
 513 }