Mercurial > hg > xemacs-beta
annotate src/input-method-xlib.c @ 5090:0ca81354c4c7
Further frame-geometry cleanups
-------------------- ChangeLog entries follow: --------------------
man/ChangeLog addition:
2010-03-03 Ben Wing <ben@xemacs.org>
* internals/internals.texi (Intro to Window and Frame Geometry):
* internals/internals.texi (The Paned Area):
* internals/internals.texi (The Displayable Area):
Update to make note of e.g. the fact that the bottom gutter is
actually above the minibuffer.
src/ChangeLog addition:
2010-03-03 Ben Wing <ben@xemacs.org>
* emacs.c:
* emacs.c (assert_equal_failed):
* lisp.h:
* lisp.h (assert_equal):
New fun assert_equal, asserting that two values == each other, and
printing out both values upon failure.
* frame-gtk.c (gtk_initialize_frame_size):
* frame-impl.h:
* frame-impl.h (FRAME_TOP_INTERNAL_BORDER_START):
* frame-impl.h (FRAME_BOTTOM_INTERNAL_BORDER_START):
* frame-impl.h (FRAME_LEFT_INTERNAL_BORDER_START):
* frame-impl.h (FRAME_PANED_TOP_EDGE):
* frame-impl.h (FRAME_NONPANED_SIZE):
* frame-x.c (x_initialize_frame_size):
* frame.c:
* gutter.c (get_gutter_coords):
* gutter.c (calculate_gutter_size):
* gutter.h:
* gutter.h (WINDOW_REAL_TOP_GUTTER_BOUNDS):
* gutter.h (FRAME_TOP_GUTTER_BOUNDS):
* input-method-xlib.c:
* input-method-xlib.c (XIM_SetGeometry):
* redisplay-output.c (clear_left_border):
* redisplay-output.c (clear_right_border):
* redisplay-output.c (redisplay_output_pixmap):
* redisplay-output.c (redisplay_clear_region):
* redisplay-output.c (redisplay_clear_top_of_window):
* redisplay-output.c (redisplay_clear_to_window_end):
* redisplay-xlike-inc.c (XLIKE_clear_frame):
* redisplay.c:
* redisplay.c (UPDATE_CACHE_RETURN):
* redisplay.c (pixel_to_glyph_translation):
* toolbar.c (update_frame_toolbars_geometry):
* window.c (Fwindow_pixel_edges):
Get rid of some redundant macros. Consistently use the
FRAME_TOP_*_START, FRAME_RIGHT_*_END, etc. format. Rename
FRAME_*_BORDER_* to FRAME_*_INTERNAL_BORDER_*. Comment out
FRAME_BOTTOM_* for gutters and the paned area due to the
uncertainty over where the paned area actually begins. (Eventually
we should probably move the gutters outside the minibuffer so that
the paned area is contiguous.) Use FRAME_PANED_* more often in the
code to make things clearer.
Update the diagram to show that the bottom gutter is inside the
minibuffer (!) and that there are "junk boxes" when you have left
and/or right gutters (dead boxes that are mistakenly left uncleared,
unlike the corresponding scrollbar dead boxes). Update the text
appropriately to cover the bottom gutter position, etc.
Rewrite gutter-geometry code to use the FRAME_*_GUTTER_* in place of
equivalent expressions referencing other frame elements, to make the
code more portable in case we move around the gutter location.
Cleanup FRAME_*_GUTTER_BOUNDS() in gutter.h.
Add some #### GEOM! comments where I think code is incorrect --
typically, it wasn't fixed up properly when the gutter was added.
Some cosmetic changes.
| author | Ben Wing <ben@xemacs.org> |
|---|---|
| date | Wed, 03 Mar 2010 05:07:47 -0600 |
| parents | 3a87551bfeb5 |
| children | 308d34e9f07d |
| rev | line source |
|---|---|
| 428 | 1 /* Various functions for X11R5+ input methods, using the Xlib interface. |
| 2 Copyright (C) 1996 Sun Microsystems. | |
| 5090 | 3 Copyright (C) 2002, 2010 Ben Wing. |
| 428 | 4 |
| 5 This file is part of XEmacs. | |
| 6 | |
| 7 XEmacs is free software; you can redistribute it and/or modify it | |
| 8 under the terms of the GNU General Public License as published by the | |
| 9 Free Software Foundation; either version 2, or (at your option) any | |
| 10 later version. | |
| 11 | |
| 12 XEmacs is distributed in the hope that it will be useful, but WITHOUT | |
| 13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 15 for more details. | |
| 16 | |
| 17 You should have received a copy of the GNU General Public License | |
| 18 along with XEmacs; see the file COPYING. If not, write to | |
| 19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330, | |
| 20 Boston, MA 02111-1307, USA. */ | |
| 21 | |
| 22 /* Synched up with: Not in FSF. */ | |
| 23 | |
| 24 /* Written by Martin Buchholz. */ | |
| 25 | |
| 26 /* This file implements an interface to X input methods, available | |
| 27 with X11R5 and above. See O'Reilly, Xlib programmer's guide, | |
| 28 and X11 R6 release guide chapters on internationalized input, | |
| 29 for further details */ | |
| 30 | |
| 31 /* | |
| 32 Policy: | |
| 33 | |
| 34 The XIM is of the device, by the device, for the device. | |
| 35 The XIC is of each frame, by each frame, for each frame. | |
| 36 The exceptions are: | |
| 37 1. Activate XICs on poor frames when the XIM is back. | |
| 444 | 38 2. Deactivate all the XICs when the XIM goes down. |
| 428 | 39 |
| 444 | 40 Implementation: |
| 428 | 41 |
| 42 - Register a callback for an XIM when the X device is being initialized. | |
| 43 XIM_init_device (d) { XRegisterIMInstantiateCallback (); } | |
| 44 The "XRegisterIMInstantiateCallback" is called when an XIM become | |
| 45 available on the X display. | |
| 46 | |
| 47 - Catch the XIC when the frame is being initialized if XIM was available. | |
| 48 XIM_init_frame (f) { ... XCreateIC (); ... } | |
| 49 | |
| 50 - Release the XIC when the frame is being closed. | |
| 51 XIM_delete_frame (f) { ... FRAME_X_XIC (f) = NULL; ... } | |
| 52 "XIM_delete_frame" is a "DestroyCallback" function declared in | |
| 53 XIM_init_frame (); | |
| 54 | |
| 55 - Release all the XICs when the XIM was down accidentally. | |
| 56 In IMDestroyCallback: | |
| 57 DEVICE_FRAME_LOOP (...) { FRAME_X_XIC (f) = NULL; } | |
| 58 | |
| 444 | 59 - Re-enable XIC for all the frames which don't have XIC when the XIM |
| 428 | 60 is back. |
| 61 In IMInstantiateCallback: | |
| 62 DEVICE_FRAME_LOOP (...) { XIM_init_frame (f); } | |
| 63 | |
| 64 | |
| 65 Note: | |
| 66 | |
| 67 - Currently, we don't use XDestroyIC because of _XimProtoCloseIM | |
| 68 (internally registered as im->methods->close) does "Xfree (ic)". | |
| 69 | |
| 70 */ | |
| 71 | |
| 72 #include <config.h> | |
| 73 #include "lisp.h" | |
| 872 | 74 |
| 75 #include "buffer.h" | |
| 76 #include "device-impl.h" | |
| 77 #include "events.h" | |
| 78 #include "frame-impl.h" | |
| 79 #include "window-impl.h" | |
| 80 | |
| 81 #include "console-x-impl.h" | |
| 82 #include "EmacsFrame.h" | |
| 83 | |
| 428 | 84 #include <X11/Xlocale.h> /* More portable than <locale.h> ? */ |
| 444 | 85 #include <X11/Xlib.h> |
| 428 | 86 |
| 448 | 87 #if !defined (XIM_XLIB) && !defined (USE_XFONTSET) |
| 88 #error neither XIM_XLIB nor USE_XFONTSET is defined?? | |
| 428 | 89 #endif |
| 90 | |
| 771 | 91 #ifdef XIM_XLIB /* XIM_XLIB specific */ |
| 428 | 92 |
| 93 /* Get/Set IC values for just one attribute */ | |
| 94 #ifdef DEBUG_XEMACS | |
| 95 #define XIC_Value(Get_Set, xic, name, attr, value) \ | |
| 96 do { \ | |
| 97 char *bad_arg; \ | |
| 98 XVaNestedList list = XVaCreateNestedList (0, attr, value, NULL); \ | |
| 99 if ((bad_arg = X##Get_Set##ICValues (xic, name, list, NULL)) != NULL) \ | |
| 100 stderr_out ("X" #Get_Set "ICValues " "bad Arg: %s\n", bad_arg); \ | |
| 101 XFree (list); \ | |
| 102 } while (0) | |
| 103 #else /* ! DEBUG_XEMACS */ | |
| 104 #define XIC_Value(Get_Set, xic, name, attr, value) \ | |
| 105 do { \ | |
| 106 XVaNestedList list = XVaCreateNestedList (0, attr, value, NULL); \ | |
| 107 X##Get_Set##ICValues (xic, name, list, NULL); \ | |
| 108 XFree (list); \ | |
| 109 } while (0) | |
| 110 #endif /* DEBUG_XEMACS */ | |
| 111 | |
| 112 static char DefaultXIMStyles[] = | |
| 113 "XIMPreeditPosition|XIMStatusArea\n" | |
| 114 "XIMPreeditPosition|XIMStatusNone\n" | |
| 115 "XIMPreeditPosition|XIMStatusNothing\n" | |
| 116 "XIMPreeditNothing|XIMStatusArea\n" | |
| 117 "XIMPreeditNothing|XIMStatusNothing\n" | |
| 118 "XIMPreeditNothing|XIMStatusNone\n" | |
| 119 "XIMPreeditNone|XIMStatusArea\n" | |
| 120 "XIMPreeditNone|XIMStatusNothing\n" | |
| 121 "XIMPreeditNone|XIMStatusNone"; | |
| 122 | |
| 123 static XIMStyle best_style (XIMStyles *user, XIMStyles *xim); | |
| 771 | 124 |
| 448 | 125 #endif /* XIM_XLIB only */ |
| 428 | 126 |
| 444 | 127 /* This function is documented, but no prototype in the header files */ |
| 128 EXTERN_C char * XSetIMValues(XIM, ...); | |
| 442 | 129 |
| 448 | 130 #ifdef XIM_XLIB /* starting XIM specific codes */ |
| 131 | |
| 444 | 132 /* Callbacks for IM are supported from X11R6 or later. */ |
| 133 #ifdef HAVE_XREGISTERIMINSTANTIATECALLBACK | |
| 134 | |
| 135 static Boolean xim_initted = False; | |
| 136 | |
| 428 | 137 /* Called from when XIM is destroying. |
| 138 Clear all the XIC when the XIM was destroying... */ | |
| 139 static void | |
| 2286 | 140 IMDestroyCallback (XIM UNUSED (im), XPointer client_data, |
| 141 XPointer UNUSED (call_data)) | |
| 428 | 142 { |
| 143 struct device *d = (struct device *)client_data; | |
| 144 Lisp_Object tail; | |
| 145 | |
| 146 DEVICE_FRAME_LOOP (tail, d) | |
| 147 { | |
| 148 struct frame *target_frame = XFRAME (XCAR (tail)); | |
| 149 if (FRAME_X_P (target_frame) && FRAME_X_XIC (target_frame)) | |
| 150 { | |
| 151 /* XDestroyIC (FRAME_X_XIC (target_frame)); */ | |
| 152 FRAME_X_XIC (target_frame) = NULL; | |
| 153 } | |
| 154 } | |
| 155 | |
| 156 DEVICE_X_XIM (d) = NULL; | |
| 157 xim_initted = False; | |
| 158 return; | |
| 159 } | |
| 160 | |
| 161 /* This is registered in XIM_init_device (when DEVICE is initializing). | |
| 162 This activates XIM when XIM becomes available. */ | |
| 163 static void | |
| 2286 | 164 IMInstantiateCallback (Display *dpy, XPointer client_data, |
| 165 XPointer UNUSED (call_data)) | |
| 428 | 166 { |
| 167 struct device *d = (struct device *)client_data; | |
| 168 XIM xim; | |
| 1204 | 169 char *name, *class_; |
| 428 | 170 XIMCallback ximcallback; |
| 171 Lisp_Object tail; | |
| 172 | |
| 173 /* if no xim is presented, initialize xim ... */ | |
| 174 if ( xim_initted == False ) | |
| 175 { | |
| 176 xim_initted = True; | |
| 1204 | 177 XtGetApplicationNameAndClass (dpy, &name, &class_); |
| 178 DEVICE_X_XIM (d) = xim = XOpenIM (dpy, XtDatabase (dpy), name, class_); | |
| 428 | 179 |
| 180 /* destroy callback for im */ | |
| 444 | 181 ximcallback.callback = (XIMProc) IMDestroyCallback; |
| 428 | 182 ximcallback.client_data = (XPointer) d; |
| 183 XSetIMValues (xim, XNDestroyCallback, &ximcallback, NULL); | |
| 184 } | |
| 185 | |
| 186 /* activate XIC on all the X frames... */ | |
| 187 DEVICE_FRAME_LOOP (tail, d) | |
| 188 { | |
| 189 struct frame *target_frame = XFRAME (XCAR (tail)); | |
| 190 if (FRAME_X_P (target_frame) && !FRAME_X_XIC (target_frame)) | |
| 191 { | |
| 192 XIM_init_frame (target_frame); | |
| 193 } | |
| 194 } | |
| 195 return; | |
| 196 } | |
| 444 | 197 #endif /* HAVE_XREGISTERIMINSTANTIATECALLBACK */ |
| 428 | 198 |
| 199 /* Initialize XIM for X device. | |
| 200 Register the use of XIM using XRegisterIMInstantiateCallback. */ | |
| 201 void | |
| 202 XIM_init_device (struct device *d) | |
| 203 { | |
| 444 | 204 #ifdef HAVE_XREGISTERIMINSTANTIATECALLBACK /* X11R6+ */ |
| 428 | 205 DEVICE_X_XIM (d) = NULL; |
| 206 XRegisterIMInstantiateCallback (DEVICE_X_DISPLAY (d), NULL, NULL, NULL, | |
| 444 | 207 #ifdef XREGISTERIMINSTANTIATECALLBACK_NONSTANDARD_PROTOTYPE |
| 442 | 208 /* The sixth parameter is of type |
| 209 XPointer in XFree86 but (XPointer *) | |
| 210 on most other X11's. */ | |
| 444 | 211 (XIDProc) IMInstantiateCallback, |
| 212 (XPointer) d | |
| 213 #else /* X Consortium prototype */ | |
| 214 (XIMProc) IMInstantiateCallback, | |
| 215 (XPointer *) d | |
| 216 #endif /* XREGISTERIMINSTANTIATECALLBACK_NONSTANDARD_PROTOTYPE */ | |
| 217 ); | |
| 428 | 218 return; |
| 444 | 219 #else /* pre-X11R6 */ |
| 428 | 220 Display *dpy = DEVICE_X_DISPLAY (d); |
| 1204 | 221 char *name, *class_; |
| 428 | 222 XIM xim; |
| 223 | |
| 1204 | 224 XtGetApplicationNameAndClass (dpy, &name, &class_); |
| 225 DEVICE_X_XIM (d) = xim = XOpenIM (dpy, XtDatabase (dpy), name, class_); | |
| 428 | 226 if (xim == NULL) |
| 227 { | |
| 793 | 228 warn_when_safe |
| 229 (Qxintl, Qerror, | |
| 230 "Can't initialize XIM: XOpenIM() failed, no input server available"); | |
| 428 | 231 return; |
| 232 } | |
| 233 else | |
| 234 { | |
| 235 XGetIMValues (xim, XNQueryInputStyle, &DEVICE_X_XIM_STYLES (d), NULL); | |
| 236 return; | |
| 237 } | |
| 444 | 238 #endif /* HAVE_XREGISTERIMINSTANTIATECALLBACK */ |
| 428 | 239 } |
| 240 | |
| 241 | |
| 242 /* | |
| 243 * For the frames | |
| 244 */ | |
| 245 | |
| 246 /* Callback for the deleting frame. */ | |
| 247 static void | |
| 2286 | 248 XIM_delete_frame (Widget UNUSED (w), XtPointer client_data, |
| 249 XtPointer UNUSED (call_data)) | |
| 428 | 250 { |
| 251 struct frame *f = (struct frame *) client_data; | |
| 252 struct device *d = XDEVICE (FRAME_DEVICE (f)); | |
| 253 | |
| 254 if (DEVICE_X_XIM (d)) | |
| 255 { | |
| 256 if (FRAME_X_XIC (f)) | |
| 257 { | |
| 258 XDestroyIC (FRAME_X_XIC (f)); | |
| 259 FRAME_X_XIC (f) = NULL; | |
| 260 } | |
| 261 } | |
| 262 return; | |
| 263 } | |
| 264 | |
| 265 /* Initialize XIC for new frame. | |
| 266 Create an X input context (XIC) for this frame. */ | |
| 267 void | |
| 268 XIM_init_frame (struct frame *f) | |
| 269 { | |
| 270 struct device *d = XDEVICE (FRAME_DEVICE (f)); | |
| 271 XIM xim; | |
| 272 Widget w = FRAME_X_TEXT_WIDGET (f); | |
| 273 Window win = XtWindow (w); | |
| 274 XRectangle p_area = {0,0,1,1}, s_area = {0,0,1,1}; | |
| 275 XPoint spot = {0,0}; | |
| 276 XIMStyle style; | |
| 277 XVaNestedList p_list, s_list; | |
| 278 typedef struct | |
| 279 { | |
| 280 XIMStyles styles; | |
| 281 XFontSet fontset; | |
| 282 Pixel fg; | |
| 283 Pixel bg; | |
| 284 char *inputmethod; | |
| 285 } xic_vars_t; | |
| 286 xic_vars_t xic_vars; | |
| 287 XIC xic; | |
| 288 | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
289 #define res(name, class_, representation, field, default_value) \ |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
290 Xt_RESOURCE (name, class_, representation, xic_vars.field, \ |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
291 XtOffsetOf(xic_vars_t, field), XtRString, default_value) |
| 428 | 292 |
| 293 static XtResource resources[] = | |
| 294 { | |
| 295 /* name class represent'n field default value */ | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
296 res(XtNximStyles, XtCXimStyles, XtRXimStyles, styles, DefaultXIMStyles), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
297 res(XtNfontSet, XtCFontSet, XtRFontSet, fontset, XtDefaultFontSet), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
298 res(XtNximForeground, XtCForeground, XtRPixel, fg, XtDefaultForeground), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
299 res(XtNximBackground, XtCBackground, XtRPixel, bg, XtDefaultBackground) |
| 428 | 300 }; |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
301 #undef res |
| 428 | 302 |
| 303 xim = DEVICE_X_XIM (d); | |
| 304 | |
| 305 if (!xim) | |
| 306 { | |
| 307 return; | |
| 308 } | |
| 309 | |
| 310 w = FRAME_X_TEXT_WIDGET (f); | |
| 311 | |
| 312 /* | |
| 313 * initialize XIC | |
| 314 */ | |
| 315 if (FRAME_X_XIC (f)) return; | |
| 316 XtGetApplicationResources (w, &xic_vars, | |
| 317 resources, XtNumber (resources), | |
| 318 NULL, 0); | |
| 319 if (!xic_vars.fontset) | |
| 320 { | |
| 793 | 321 warn_when_safe |
| 322 (Qxintl, Qerror, | |
| 323 "Can't initialize XIM: Can't get fontset resource for Input Method"); | |
| 428 | 324 FRAME_X_XIC (f) = NULL; |
| 325 return; | |
| 326 } | |
| 327 | |
| 328 /* construct xic */ | |
| 329 XGetIMValues (xim, XNQueryInputStyle, &DEVICE_X_XIM_STYLES(d), NULL); | |
| 330 FRAME_X_XIC_STYLE (f) = style = | |
| 331 best_style (&xic_vars.styles, (XIMStyles *)DEVICE_X_XIM_STYLES(d)); | |
| 332 | |
| 333 p_list = XVaCreateNestedList (0, | |
| 334 XNArea, &p_area, | |
| 335 XNSpotLocation, &spot, | |
| 336 XNForeground, xic_vars.fg, | |
| 337 XNBackground, xic_vars.bg, | |
| 338 XNFontSet, xic_vars.fontset, | |
| 339 NULL); | |
| 340 | |
| 341 s_list = XVaCreateNestedList (0, | |
| 342 XNArea, &s_area, | |
| 343 XNForeground, xic_vars.fg, | |
| 344 XNBackground, xic_vars.bg, | |
| 345 XNFontSet, xic_vars.fontset, | |
| 346 NULL); | |
| 347 | |
| 348 FRAME_X_XIC (f) = xic = | |
| 349 XCreateIC (xim, | |
| 350 XNInputStyle, style, | |
| 351 XNClientWindow, win, | |
| 352 XNFocusWindow, win, | |
| 353 XNPreeditAttributes, p_list, | |
| 354 XNStatusAttributes, s_list, | |
| 355 NULL); | |
| 356 XFree (p_list); | |
| 357 XFree (s_list); | |
| 358 | |
| 359 if (!xic) | |
| 360 { | |
| 793 | 361 warn_when_safe (Qxintl, Qerror, |
| 362 "Can't initialize XIM: XCreateIC failed"); | |
| 428 | 363 return; |
| 364 } | |
| 365 | |
| 366 if (style & XIMPreeditPosition) | |
| 367 { | |
| 368 XPoint *frame_spot = &(FRAME_X_XIC_SPOT(f)); | |
| 369 frame_spot->x = frame_spot->y = -1; | |
| 370 } | |
| 371 | |
| 372 XIM_SetGeometry (f); | |
| 373 | |
| 374 XSetICFocus (xic); | |
| 375 | |
| 444 | 376 #ifdef HAVE_XREGISTERIMINSTANTIATECALLBACK |
| 428 | 377 /* when frame is going to be destroyed (closed) */ |
| 793 | 378 XtAddCallback (FRAME_X_TEXT_WIDGET (f), XNDestroyCallback, |
| 379 XIM_delete_frame, (XtPointer)f ); | |
| 428 | 380 #endif |
| 381 } | |
| 382 | |
| 383 | |
| 384 void | |
| 385 XIM_SetGeometry (struct frame *f) | |
| 386 { | |
| 3462 | 387 XIC xic; |
| 388 XIMStyle style; | |
| 428 | 389 XRectangle area; |
| 390 | |
| 3462 | 391 if (!f) |
| 428 | 392 return; |
| 393 | |
| 3462 | 394 xic = FRAME_X_XIC (f); |
| 395 if (!xic) | |
| 396 return; | |
| 397 | |
| 398 style = FRAME_X_XIC_STYLE (f); | |
| 428 | 399 if (style & XIMStatusArea) |
| 400 { | |
| 401 /* Place Status Area in bottom right corner */ | |
| 402 /* Negotiate geometry of status area */ | |
| 403 /* See O'Reilly Xlib XIM chapter (but beware, it's buggy) */ | |
| 404 XRectangle *needed; | |
| 405 | |
| 406 /* If input method has existing status area, use its current size */ | |
| 407 /* The following at least works for Sun's htt */ | |
| 408 area.x = area.y = area.width = area.height = 0; | |
| 409 XIC_Value (Set, xic, XNStatusAttributes, XNAreaNeeded, &area); | |
| 410 XIC_Value (Get, xic, XNStatusAttributes, XNAreaNeeded, &needed); | |
| 411 if (needed->width == 0) /* Use XNArea instead of XNAreaNeeded */ | |
| 412 XIC_Value (Get, xic, XNStatusAttributes, XNArea, &needed); | |
| 413 | |
| 5090 | 414 /* #### This will partially cover the gutter if there is a bottom |
| 415 gutter. Perhaps what was intended was FRAME_PANED_RIGHT_EDGE() | |
| 416 and FRAME_PANED_BOTTOM_EDGE()? That will actually place itself | |
| 417 in the paned area (covering the right edge of the minibuffer) | |
| 418 in all circumstances. */ | |
| 428 | 419 area.width = needed->width; |
| 420 area.height = needed->height; | |
| 5090 | 421 area.x = FRAME_RIGHT_INTERNAL_BORDER_START (f) - area.width; |
| 422 area.y = FRAME_BOTTOM_INTERNAL_BORDER_START (f) - area.height; | |
| 428 | 423 |
| 424 #ifdef DEBUG_XIM | |
| 425 stderr_out ("Putting StatusArea in x=%d y=%d w=%d h=%d\n", | |
| 426 area.x, area.y, area.width, area.height); | |
| 427 #endif /* DEBUG_XIM */ | |
| 428 | |
| 429 XIC_Value (Set, xic, XNStatusAttributes, XNArea, &area); | |
| 430 } | |
| 431 | |
| 432 if (style & XIMPreeditPosition) | |
| 433 { | |
| 434 /* Set Preedit Area to whole frame size (sans border) */ | |
| 435 /* We include the border because Preedit window might be larger | |
| 436 than display line at edge. #### FIX: we should adjust to make | |
| 437 sure that there is always room for the spot sub-window */ | |
| 5090 | 438 area.x = FRAME_LEFT_INTERNAL_BORDER_START (f); |
| 439 area.y = FRAME_TOP_INTERNAL_BORDER_START (f); | |
| 440 area.width = FRAME_RIGHT_INTERNAL_BORDER_END (f) - area.x; | |
| 441 area.height = FRAME_BOTTOM_INTERNAL_BORDER_END (f) - area.y; | |
| 428 | 442 XIC_Value(Set, xic, XNPreeditAttributes, XNArea, &area); |
| 443 } | |
| 444 | |
| 445 #ifdef DEBUG_XIM | |
| 446 describe_XIC (xic); | |
| 447 #endif | |
| 448 } | |
| 449 | |
| 450 void | |
| 451 XIM_SetSpotLocation (struct frame *f, int x, int y) | |
| 452 { | |
| 453 XIC xic = FRAME_X_XIC (f); | |
| 454 XPoint *spot = &(FRAME_X_XIC_SPOT (f)); | |
| 455 | |
| 456 /* Only care if we have a valid XIC using Over the Spot in | |
| 457 * a different location */ | |
| 458 if (!xic || | |
| 459 !(FRAME_X_XIC_STYLE (f) & XIMPreeditPosition) || | |
| 460 (spot->x == (short) x && | |
| 461 spot->y == (short) y)) | |
| 462 return; | |
| 463 | |
| 464 spot->x = (short) x; | |
| 465 spot->y = (short) y; | |
| 466 | |
| 440 | 467 /* #### FIX: Must make sure spot fits within Preedit Area */ |
| 428 | 468 XIC_Value (Set, xic, XNPreeditAttributes, XNSpotLocation, spot); |
| 469 #ifdef DEBUG_XIM | |
| 470 stderr_out ("Spot: %d %d\n", spot->x, spot->y); | |
| 471 #endif | |
| 472 } | |
| 473 | |
| 474 void | |
| 475 XIM_focus_event (struct frame *f, int in_p) | |
| 476 { | |
| 477 if (FRAME_X_XIC (f) /* && FRAME_X_XIM_REGISTERED(f) */) | |
| 478 (in_p ? XSetICFocus : XUnsetICFocus) (FRAME_X_XIC (f)); | |
| 479 } | |
| 480 | |
| 481 #if 0 | |
| 482 #define XIM_Composed_Text_BUFSIZE 64 | |
| 483 typedef struct XIM_Composed_Text | |
| 484 { | |
| 485 int size; | |
| 486 wchar_t data [XIM_Composed_Text_BUFSIZE]; | |
| 487 } XIM_Composed_Text; | |
| 488 | |
| 489 static XIM_Composed_Text composed_input_buf = {XIM_Composed_Text_BUFSIZE, {0}}; | |
| 490 Window main_window; | |
| 491 | |
| 492 /* get_XIM_input -- Process results of input method composition. | |
| 493 | |
| 494 This function copies the results of the input method composition to | |
| 495 composed_input_buf. Then for each character, a custom event of type | |
| 496 wc_atom is sent with the character as its data. | |
| 497 | |
| 498 It is probably more efficient to copy the composition results to some | |
| 499 allocated memory and send a single event pointing to that memory. | |
| 500 That would cut down on the event processing as well as allow quick | |
| 501 insertion into the buffer of the whole string. It might require some | |
| 502 care, though, to avoid fragmenting memory through the allocation and | |
| 503 freeing of many small chunks. Maybe the existing system for | |
| 504 (single-byte) string allocation can be used, multiplying the length by | |
| 505 sizeof (wchar_t) to get the right size. | |
| 506 */ | |
| 507 void | |
| 508 get_XIM_input (XKeyPressedEvent *x_key_event, XIC ic, Display *dpy) | |
| 509 { | |
| 510 KeySym keysym; | |
| 511 Status status; | |
| 512 int len; | |
| 513 int i; | |
| 514 XClientMessageEvent new_event; | |
| 515 | |
| 516 retry: | |
| 517 len = XwcLookupString (ic, x_key_event, composed_input_buf.data, | |
| 518 composed_input_buf.size, &keysym, &status); | |
| 519 switch (status) | |
| 520 { | |
| 521 case XBufferOverflow: | |
| 522 /* GROW_WC_STRING (&composed_input_buf, 32); mrb */ | |
| 523 goto retry; | |
| 524 case XLookupChars: | |
| 525 break; | |
| 526 default: | |
| 2500 | 527 ABORT (); |
| 428 | 528 } |
| 529 | |
| 530 new_event.type = ClientMessage; | |
| 531 new_event.display = x_key_event->display; | |
| 532 new_event.window = x_key_event->window; | |
| 533 new_event.message_type = wc_atom; | |
| 534 new_event.format = 32; /* 32-bit wide data */ | |
| 535 new_event.data.l[2] = new_event.data.l[3] = new_event.data.l[4] = 0L; | |
| 536 new_event.data.l[0] = x_key_event->time; | |
| 537 for (i = 0; i < len; i++) | |
| 538 { | |
| 539 new_event.data.l[1] = ((wchar_t *) composed_input_buf.data)[i]; | |
| 540 XSendEvent (display, main_window, False, 0L, (XEvent *) &new_event); | |
| 541 } | |
| 542 } | |
| 543 #endif /* 0 */ | |
| 544 | |
| 545 /* ============================================================== */ | |
| 546 /* X input method style determination */ | |
| 547 /* ============================================================== */ | |
| 548 | |
| 549 #if 0 | |
| 550 #define done(type, value) \ | |
| 551 if (toVal->addr != NULL) { \ | |
| 552 if (toVal->size < sizeof(type)) { \ | |
| 553 toVal->size = sizeof(type); \ | |
| 554 return False; \ | |
| 555 } \ | |
| 556 *(type*)toVal->addr = (value); \ | |
| 557 } else { \ | |
| 558 static type static_val; \ | |
| 559 static_val = (value); \ | |
| 560 toVal->addr = (XPointer)&static_val; \ | |
| 561 } \ | |
| 562 toVal->size = sizeof(type); \ | |
| 563 return True /* Caller supplies `;' */ | |
| 564 #endif /* 0 */ | |
| 565 | |
| 566 /* | |
| 567 * This is a standard Xt type converter, except that the caller MUST | |
| 568 * supply a proper non-NULL toVal XIMStyles structure that we will | |
| 569 * fill in. | |
| 570 * | |
| 571 * fromVal points to a string like | |
| 572 * | |
| 573 "XIMPreeditPosition|XIMStatusArea, | |
| 574 XIMPreeditPosition|XIMStatusNothing | |
| 575 XIMPreeditNothing|XIMStatusNothing" | |
| 576 * | |
| 577 * This is converted in the obvious way to a XIMStyles structure. | |
| 578 * | |
| 579 * mrb: #### Fix this to handle Motif-style specifications for | |
| 580 * XIMStyles as well: overTheSpot, rootWindow, none */ | |
| 581 | |
| 582 /* XtTypeConverter */ | |
| 583 Boolean | |
| 584 EmacsXtCvtStringToXIMStyles ( | |
| 585 Display *dpy, | |
| 586 XrmValuePtr args, | |
| 587 Cardinal *num_args, | |
| 588 XrmValuePtr fromVal, | |
| 589 XrmValuePtr toVal, | |
| 590 XtPointer *converter_data) | |
| 591 { | |
| 592 #define STYLE_INFO(style) { style, #style, sizeof(#style) } | |
| 593 static struct XIMStyleInfo | |
| 594 { | |
| 442 | 595 const XIMStyle style; |
| 596 const char * const name; | |
| 597 const int namelen; | |
| 428 | 598 } emacs_XIMStyleInfo[] = { |
| 599 STYLE_INFO (XIMPreeditPosition|XIMStatusArea), | |
| 600 STYLE_INFO (XIMPreeditPosition|XIMStatusNothing), | |
| 601 STYLE_INFO (XIMPreeditPosition|XIMStatusNone), | |
| 602 STYLE_INFO (XIMPreeditNothing|XIMStatusArea), | |
| 603 STYLE_INFO (XIMPreeditNothing|XIMStatusNothing), | |
| 604 STYLE_INFO (XIMPreeditNothing|XIMStatusNone), | |
| 605 STYLE_INFO (XIMPreeditNone|XIMStatusArea), | |
| 606 STYLE_INFO (XIMPreeditNone|XIMStatusNothing), | |
| 607 STYLE_INFO (XIMPreeditNone|XIMStatusNone) | |
| 608 }; | |
| 609 #undef STYLE_INFO | |
| 610 | |
| 611 char *s = (char *) fromVal->addr; | |
| 612 char *end = s + fromVal->size; | |
| 442 | 613 XIMStyles * const p = (XIMStyles *) toVal->addr; |
| 614 const char * const delimiter = " \t\n\r:;," ; | |
| 615 const int max_styles = XtNumber(emacs_XIMStyleInfo); | |
| 428 | 616 int i; |
| 617 char *c; | |
| 618 | |
| 619 #ifdef DEBUG_XIM | |
| 620 stderr_out ("EmacsCvtStringToXIMStyles called with size=%d, string=\"%s\"\n", | |
| 621 fromVal->size, (char *) fromVal->addr); | |
| 622 #endif /* DEBUG_XIM */ | |
| 623 | |
| 624 if (*num_args != 0) | |
| 625 { | |
| 626 XtAppContext the_app_con = XtDisplayToApplicationContext (dpy); | |
| 627 XtAppWarningMsg(the_app_con, "wrongParameters", "cvtStringToXIMStyle", | |
| 628 "XtToolkitError", | |
| 629 "String to XIMStyle conversion requires exactly 0 parameters", | |
| 630 (String *)NULL, (Cardinal *)NULL); | |
| 631 return False; | |
| 632 } | |
| 633 | |
| 634 #ifdef DEBUG_XEMACS | |
| 635 /* Make sure caller is giving us good data */ | |
| 636 assert (fromVal->addr != NULL); | |
| 637 assert (fromVal->size == strlen(fromVal->addr)+1); | |
| 638 assert (toVal->addr != NULL); | |
| 639 assert (toVal->size == sizeof(XIMStyles)); | |
| 640 #endif /* DEBUG_XEMACS */ | |
| 641 | |
| 642 p->count_styles = 0; | |
| 643 p->supported_styles = xnew_array (XIMStyle, max_styles); | |
| 644 | |
| 645 /* | |
| 646 * The following routine assumes that the style name resource is | |
| 647 * identical with the programmatic name of style. For example, | |
| 648 * "XIMPreeditPosition|XIMStatusArea" means the | |
| 649 * XIMPreeditPosition|XIMStatusArea value is specified. If the | |
| 650 * style name is changed, such as "OverTheSpot|imDisplaysInClient", | |
| 651 * the parsing logic below should be modified as well. */ | |
| 652 | |
| 653 if ((c = strtok(s, delimiter)) == NULL) | |
| 654 c = end; | |
| 655 | |
| 656 while (c < end) | |
| 657 { | |
| 658 for(i=0 ; i<max_styles ; i++) | |
| 659 { | |
| 660 struct XIMStyleInfo *rec = emacs_XIMStyleInfo + i; | |
| 661 if(!strncmp(c, rec->name, rec->namelen - 1)) { | |
| 662 p->supported_styles[p->count_styles] = rec->style; | |
| 663 p->count_styles++; | |
| 664 break; | |
| 665 } | |
| 666 } | |
| 667 if((c = strtok(NULL, delimiter)) == NULL) { | |
| 668 break ; | |
| 669 } | |
| 670 } | |
| 671 | |
| 672 if (p->count_styles == 0) | |
| 673 { /* No valid styles? */ | |
| 2367 | 674 /* !!#### */ |
| 675 char *buf = (char *) ALLOCA (strlen (fromVal->addr) | |
| 676 + strlen (DefaultXIMStyles) | |
| 677 + 100); | |
| 428 | 678 XrmValue new_from; |
| 679 XtAppContext the_app_con = XtDisplayToApplicationContext (dpy); | |
| 680 | |
| 681 sprintf(buf, "Cannot convert string \"%s\" to type XIMStyles.\n" | |
| 682 "Using default string \"%s\" instead.\n", | |
| 683 fromVal->addr, DefaultXIMStyles); | |
| 684 XtAppWarningMsg(the_app_con, "wrongParameters", "cvtStringToXIMStyle", | |
| 685 "XtToolkitError", | |
| 686 buf, (String *)NULL, (Cardinal *)NULL); | |
| 687 new_from.addr = DefaultXIMStyles; | |
| 688 new_from.size = sizeof(DefaultXIMStyles); | |
| 689 return EmacsXtCvtStringToXIMStyles (dpy, args, num_args, | |
| 690 &new_from, toVal, converter_data); | |
| 691 } | |
| 692 XREALLOC_ARRAY (p->supported_styles, XIMStyle, p->count_styles); | |
| 693 *converter_data = (char *) True; | |
| 694 return True; | |
| 695 } | |
| 696 | |
| 697 /* XtDestructor */ | |
| 698 void | |
| 699 EmacsFreeXIMStyles ( | |
| 700 XtAppContext app, | |
| 701 XrmValuePtr toVal, | |
| 702 XtPointer converter_data, | |
| 2286 | 703 XrmValuePtr UNUSED (args), |
| 428 | 704 Cardinal *num_args) |
| 705 { | |
| 706 #ifdef DEBUG_XIM | |
| 707 stderr_out ("Converter data: %x\n", converter_data); | |
| 708 stderr_out ("EmacsFreeXIMStyles called\n"); | |
| 709 #endif /* DEBUG_XIM */ | |
| 710 | |
| 711 if (*num_args != 0) | |
| 712 { | |
| 713 XtAppWarningMsg(app, "wrongParameters","freeXIMStyles","XtToolkitError", | |
| 714 "Freeing an XIMStyles requires that zero arguments be passwd", | |
| 715 (String *)NULL, (Cardinal *)NULL); | |
| 716 return; | |
| 717 } | |
| 718 | |
| 719 if (converter_data) | |
| 720 { | |
| 4123 | 721 Boolean free_p = (Boolean) (EMACS_INT) converter_data; |
| 428 | 722 XIMStyles *styles = (XIMStyles *) toVal->addr; |
| 723 if (free_p) | |
| 724 XFree ( styles->supported_styles ); | |
| 725 } | |
| 726 } | |
| 727 | |
| 728 #if 0 | |
| 729 /* O'Reilly XLib Programming Manual, pg. 371 */ | |
| 730 /* Much nicer implementation than O'Reilly */ | |
| 731 /* Choose the more `complicated', hence nicer, XIM input style */ | |
| 732 static XIMStyle | |
| 733 BetterStyle (XIMStyle s, XIMStyle t) | |
| 734 { | |
| 735 #define CHECK_XIMStyle_BIT(bit) \ | |
| 736 if ((s ^ t) & bit) { return (s & bit) ? s : t; } | |
| 737 | |
| 738 CHECK_XIMStyle_BIT (XIMPreeditCallbacks); | |
| 739 CHECK_XIMStyle_BIT (XIMPreeditPosition); | |
| 740 CHECK_XIMStyle_BIT (XIMPreeditArea); | |
| 741 CHECK_XIMStyle_BIT (XIMPreeditNothing); | |
| 742 CHECK_XIMStyle_BIT (XIMStatusCallbacks); | |
| 743 CHECK_XIMStyle_BIT (XIMStatusArea); | |
| 744 CHECK_XIMStyle_BIT (XIMStatusNothing); | |
| 745 #undef CHECK_XIMStyle_BIT | |
| 746 return s ? s : t ; | |
| 747 } | |
| 748 #endif /* 0 */ | |
| 749 | |
| 750 /* Choose the best style, given: | |
| 751 * - user preferences (already checked to be supported by XEmacs) | |
| 752 * - styles supported by the input method */ | |
| 753 #define DEFAULTStyle (XIMPreeditNothing|XIMStatusNothing) | |
| 754 static XIMStyle | |
| 755 best_style (XIMStyles *user, XIMStyles *xim) | |
| 756 { | |
| 757 REGISTER int i, j; | |
| 758 for (i=0 ; i<user->count_styles ; i++) | |
| 759 { | |
| 760 for (j=0 ; j<xim->count_styles ; j++) | |
| 761 { | |
| 762 if (user->supported_styles[i] == xim->supported_styles[j]) | |
| 763 return user->supported_styles[i]; | |
| 764 } | |
| 765 } | |
| 766 return DEFAULTStyle; /* Default Style */ | |
| 767 } | |
| 768 | |
| 769 /* These lisp-callable functions will be sealed until xim-leim is needed. | |
| 770 Oct 22 1999 - kazz */ | |
| 771 #if 0 | |
| 772 /* | |
| 773 * External callable function for XIM | |
| 774 */ | |
| 775 DEFUN ("x-open-xim", Fx_open_xim, 1, 1, 0, /* | |
| 776 Open the XIC on the frame if XIM is available. | |
| 777 Commonly, use this as \(x-open-xim \(selected-frame)). | |
| 778 If the frame is not on X device, return signal. | |
| 779 If XIC is created successfully return t. If not return nil. | |
| 780 */ | |
| 781 (frame)) | |
| 782 { | |
| 783 struct frame *f; | |
| 784 | |
| 785 CHECK_LIVE_FRAME (frame); | |
| 786 f = XFRAME (frame); | |
| 787 if (!FRAME_X_P (f)) | |
| 563 | 788 invalid_argument ("This frame is not on X device", frame); |
| 428 | 789 |
| 790 XIM_init_frame (f); | |
| 791 return FRAME_X_XIC (f) ? Qt : Qnil; | |
| 792 } | |
| 793 | |
| 794 DEFUN ("x-close-xim", Fx_close_xim, 1, 1, 0, /* | |
| 795 Close the XIC on the frame if it exists. | |
| 796 Commonly, use this as \(x-close-xim \(selected-frame)). | |
| 797 If the frame is not on X device, return signal. | |
| 798 Otherwise, it destroys the XIC if it exists, then returns t anyway. | |
| 799 */ | |
| 800 (frame)) | |
| 801 { | |
| 802 struct frame *f; | |
| 803 struct device *d; | |
| 804 | |
| 805 CHECK_LIVE_FRAME (frame); | |
| 806 f = XFRAME (frame); | |
| 807 if (!FRAME_X_P (f)) | |
| 563 | 808 invalid_argument ("This frame is not on X device", frame); |
| 428 | 809 |
| 810 d = XDEVICE (FRAME_DEVICE (f)); | |
| 811 if (DEVICE_X_XIM (d)) { | |
| 812 /* XDestroyIC (FRAME_X_XIC (XFRAME (f))); */ | |
| 813 FRAME_X_XIC (XFRAME (f)) = NULL; | |
| 814 } | |
| 815 return Qt; | |
| 816 } | |
| 817 #endif /* if 0 */ | |
| 818 | |
| 819 void | |
| 820 syms_of_input_method_xlib (void) | |
| 821 { | |
| 822 #if 0 /* see above */ | |
| 823 DEFSUBR (Fx_open_xim); | |
| 824 DEFSUBR (Fx_close_xim); | |
| 825 #endif | |
| 826 } | |
| 827 | |
| 828 void | |
| 829 vars_of_input_method_xlib (void) | |
| 830 { | |
| 831 Fprovide (intern ("xim")); | |
| 832 } | |
| 833 | |
| 834 | |
| 835 /* ====================================================================== */ | |
| 836 /* Internal Debugging Routines */ | |
| 837 /* ====================================================================== */ | |
| 838 #ifdef DEBUG_XEMACS | |
| 839 | |
| 840 void | |
| 841 describe_XIM (XIM xim) | |
| 842 { | |
| 843 XIMStyles *styles; | |
| 844 | |
| 845 /* Print locale of XIM */ | |
| 846 stderr_out ("\nXIM Locale of IM: %s\n", XLocaleOfIM(xim)); | |
| 847 | |
| 848 /* List supported input method styles */ | |
| 849 XGetIMValues(xim, XNQueryInputStyle, &styles, NULL); | |
| 850 | |
| 851 stderr_out ("\n%d input style(s) supported by input method.\n", | |
| 852 styles->count_styles); | |
| 853 | |
| 854 #ifdef DEBUG_XIM | |
| 855 { | |
| 856 int i; | |
| 857 for (i=0; i < styles->count_styles; i++) | |
| 858 describe_XIMStyle (styles->supported_styles[i]); | |
| 859 } | |
| 860 #endif /* DEBUG_XIM */ | |
| 861 XFree(styles); | |
| 862 } | |
| 863 | |
| 864 void | |
| 865 describe_XFontSet (XFontSet fontset) | |
| 866 { | |
| 867 XFontStruct **font_struct_list; | |
| 868 char **font_name_list; | |
| 869 int count, i; | |
| 870 | |
| 871 if (fontset == NULL) | |
| 872 { | |
| 873 stderr_out ("NULL\n"); | |
| 874 return; | |
| 875 } | |
| 876 | |
| 877 count = XFontsOfFontSet (fontset, &font_struct_list, &font_name_list); | |
| 878 stderr_out ( "%d font(s) available:\n", count); | |
| 879 for (i=0 ; i < count ; i++) | |
| 880 stderr_out ("Font: %s\n", *(font_name_list+i)); | |
| 881 } | |
| 882 | |
| 883 void | |
| 884 describe_Status (Status status) | |
| 885 { | |
| 886 #define DESCRIBE_STATUS(value) \ | |
| 887 if (status == value) stderr_out ("Status: " #value "\n") | |
| 888 | |
| 889 DESCRIBE_STATUS (XBufferOverflow); | |
| 890 DESCRIBE_STATUS (XLookupNone); | |
| 891 DESCRIBE_STATUS (XLookupKeySym); | |
| 892 DESCRIBE_STATUS (XLookupBoth); | |
| 893 DESCRIBE_STATUS (XLookupChars); | |
| 894 #undef DESCRIBE_STATUS | |
| 895 } | |
| 896 | |
| 897 void | |
| 898 describe_Window (Window win) | |
| 899 { | |
| 900 char xwincmd[128]; | |
| 901 sprintf (xwincmd, "xwininfo -id 0x%x >&2; xwininfo -events -id 0x%x >&2", | |
| 902 (int) win, (int) win); | |
|
4710
3a87551bfeb5
Fixes for a number of minor warnings issued by gcc. See xemacs-patches message
Jerry James <james@xemacs.org>
parents:
4528
diff
changeset
|
903 if (system (xwincmd) == -1) |
|
3a87551bfeb5
Fixes for a number of minor warnings issued by gcc. See xemacs-patches message
Jerry James <james@xemacs.org>
parents:
4528
diff
changeset
|
904 stderr_out ("Unable to execute xwininfo\n"); |
| 428 | 905 } |
| 906 | |
| 907 void | |
| 908 describe_XIC (XIC xic) | |
| 909 { | |
| 910 XIMStyle style; | |
| 911 Window client_win=0, focus_win=0; | |
| 912 char *resourceName = NULL; | |
| 913 char *resourceClass = NULL; | |
| 914 char *bad_arg = NULL; | |
| 915 unsigned long filter_mask = NoEventMask; | |
| 916 XVaNestedList p_list, s_list; | |
| 917 XFontSet p_fontset = NULL, s_fontset = NULL; | |
| 918 Pixel p_fg=0, p_bg = 0, s_fg=0, s_bg = 0; | |
| 919 XRectangle *p_area = NULL, *s_area = NULL; | |
| 920 XRectangle *p_needed = NULL, *s_needed = NULL; | |
| 921 XPoint *p_spot = NULL; | |
| 922 | |
| 923 /* Check for valid input context and method */ | |
| 924 if (!xic) | |
| 925 stderr_out ("Input method is NULL\n"); | |
| 926 | |
| 927 if (!XIMOfIC(xic)) | |
| 928 stderr_out ("XIMOfIC() returns NULL\n"); | |
| 929 | |
| 930 /* Print out Input Context Attributes */ | |
| 931 p_list = XVaCreateNestedList (0, | |
| 932 XNFontSet, &p_fontset, | |
| 933 XNArea, &p_area, | |
| 934 XNAreaNeeded, &p_needed, | |
| 935 XNSpotLocation, &p_spot, | |
| 936 XNForeground, &p_fg, | |
| 937 XNBackground, &p_bg, | |
| 938 NULL); | |
| 939 | |
| 940 s_list = XVaCreateNestedList (0, | |
| 941 XNFontSet, &s_fontset, | |
| 942 XNArea, &s_area, | |
| 943 XNAreaNeeded, &s_needed, | |
| 944 XNForeground, &s_fg, | |
| 945 XNBackground, &s_bg, | |
| 946 NULL); | |
| 947 | |
| 948 bad_arg = XGetICValues(xic, | |
| 949 XNInputStyle, &style, | |
| 950 XNFilterEvents, &filter_mask, | |
| 951 XNClientWindow, &client_win, | |
| 952 XNFocusWindow, &focus_win, | |
| 953 XNResourceName, &resourceName, | |
| 954 XNResourceClass, &resourceClass, | |
| 955 XNPreeditAttributes, p_list, | |
| 956 XNStatusAttributes, s_list, | |
| 957 NULL); | |
| 958 XFree(p_list); | |
| 959 XFree(s_list); | |
| 960 | |
| 961 if (bad_arg != NULL) | |
| 962 stderr_out ("Couldn't get IC value: %s\n", bad_arg); | |
| 963 | |
| 964 stderr_out ("\nInput method context attributes:\n"); | |
| 965 stderr_out ("Style: "); describe_XIMStyle (style); | |
| 966 stderr_out ("Client window: %lx\n", (unsigned long int)client_win); | |
| 967 stderr_out ("Focus window: %lx\n", (unsigned long int)focus_win); | |
| 968 stderr_out ("Preedit:\n"); | |
| 969 describe_XRectangle (" Area", p_area); | |
| 970 describe_XRectangle (" Area needed", p_needed); | |
| 971 stderr_out (" foreground: %lx\n", (unsigned long int)p_fg); | |
| 972 stderr_out (" background: %lx\n", (unsigned long int)p_bg); | |
| 973 stderr_out (" fontset: "); describe_XFontSet (p_fontset); | |
| 974 stderr_out ("Status:\n"); | |
| 975 describe_XRectangle (" Area", s_area); | |
| 976 describe_XRectangle (" Area needed", s_needed); | |
| 977 stderr_out (" foreground: %lx\n", (unsigned long int)s_fg); | |
| 978 stderr_out (" background: %lx\n", (unsigned long int)s_bg); | |
| 979 stderr_out (" fontset: \n"); describe_XFontSet (s_fontset); | |
| 980 stderr_out ("XNResourceName: %s\n", resourceName ? resourceName : "NULL"); | |
| 981 stderr_out ("XNResourceClass: %s\n", resourceClass ? resourceClass : "NULL"); | |
| 982 stderr_out ("XNFilterEvents: "); describe_event_mask (filter_mask); | |
| 983 } | |
| 984 | |
| 985 void | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
986 describe_XRectangle (const char *name, XRectangle *r) |
| 428 | 987 { |
| 988 if (r == NULL) | |
| 989 stderr_out ("%s: NULL\n", name); | |
| 990 else | |
| 991 stderr_out ("%s: x=%d y=%d w=%d h=%d\n", | |
| 992 name, r->x, r->y, r->width, r->height); | |
| 993 } | |
| 994 | |
| 995 /* Print out elements of Event mask */ | |
| 996 /* Defines from X11/X.h */ | |
| 997 void | |
| 998 describe_event_mask (unsigned long mask) | |
| 999 { | |
| 1000 #define DESCRIBE_EVENT_MASK(bit) if ((bit) & mask) stderr_out (#bit " ") | |
| 1001 DESCRIBE_EVENT_MASK (NoEventMask); | |
| 1002 DESCRIBE_EVENT_MASK (KeyPressMask); | |
| 1003 DESCRIBE_EVENT_MASK (KeyReleaseMask); | |
| 1004 DESCRIBE_EVENT_MASK (ButtonPressMask); | |
| 1005 DESCRIBE_EVENT_MASK (ButtonReleaseMask); | |
| 1006 DESCRIBE_EVENT_MASK (EnterWindowMask); | |
| 1007 DESCRIBE_EVENT_MASK (LeaveWindowMask); | |
| 1008 DESCRIBE_EVENT_MASK (PointerMotionMask); | |
| 1009 DESCRIBE_EVENT_MASK (PointerMotionHintMask); | |
| 1010 DESCRIBE_EVENT_MASK (Button1MotionMask); | |
| 1011 DESCRIBE_EVENT_MASK (Button2MotionMask); | |
| 1012 DESCRIBE_EVENT_MASK (Button3MotionMask); | |
| 1013 DESCRIBE_EVENT_MASK (Button4MotionMask); | |
| 1014 DESCRIBE_EVENT_MASK (Button5MotionMask); | |
| 1015 DESCRIBE_EVENT_MASK (ButtonMotionMask); | |
| 1016 DESCRIBE_EVENT_MASK (KeymapStateMask); | |
| 1017 DESCRIBE_EVENT_MASK (ExposureMask); | |
| 1018 DESCRIBE_EVENT_MASK (VisibilityChangeMask); | |
| 1019 DESCRIBE_EVENT_MASK (StructureNotifyMask); | |
| 1020 DESCRIBE_EVENT_MASK (ResizeRedirectMask); | |
| 1021 DESCRIBE_EVENT_MASK (SubstructureNotifyMask); | |
| 1022 DESCRIBE_EVENT_MASK (SubstructureRedirectMask); | |
| 1023 DESCRIBE_EVENT_MASK (FocusChangeMask); | |
| 1024 DESCRIBE_EVENT_MASK (PropertyChangeMask); | |
| 1025 DESCRIBE_EVENT_MASK (ColormapChangeMask); | |
| 1026 DESCRIBE_EVENT_MASK (OwnerGrabButtonMask); | |
| 1027 #undef DESCRIBE_EVENT_MASK | |
| 1028 stderr_out("\n"); | |
| 1029 } | |
| 1030 | |
| 1031 void | |
| 1032 describe_XIMStyle (XIMStyle style) | |
| 1033 { | |
| 1034 #define DESCRIBE_STYLE(bit) \ | |
| 1035 if (bit & style) \ | |
| 1036 stderr_out (#bit " "); | |
| 1037 | |
| 1038 DESCRIBE_STYLE (XIMPreeditArea); | |
| 1039 DESCRIBE_STYLE (XIMPreeditCallbacks); | |
| 1040 DESCRIBE_STYLE (XIMPreeditPosition); | |
| 1041 DESCRIBE_STYLE (XIMPreeditNothing); | |
| 1042 DESCRIBE_STYLE (XIMPreeditNone); | |
| 1043 DESCRIBE_STYLE (XIMStatusArea); | |
| 1044 DESCRIBE_STYLE (XIMStatusCallbacks); | |
| 1045 DESCRIBE_STYLE (XIMStatusNothing); | |
| 1046 DESCRIBE_STYLE (XIMStatusNone); | |
| 1047 #undef DESCRIBE_STYLE | |
| 1048 stderr_out("\n"); | |
| 1049 } | |
| 1050 | |
| 1051 void | |
| 1052 describe_XIMStyles (XIMStyles *p) | |
| 1053 { | |
| 1054 int i; | |
| 1055 stderr_out ("%d Style(s):\n", p->count_styles); | |
| 1056 for (i=0; i<p->count_styles ; i++) | |
| 1057 { | |
| 1058 describe_XIMStyle (p->supported_styles[i]); | |
| 1059 } | |
| 1060 } | |
| 1061 | |
| 1062 #endif /* DEBUG_XEMACS */ | |
| 1063 | |
| 1064 /* Random cruft follows */ | |
| 1065 | |
| 1066 #if 0 | |
| 1067 static void | |
| 1068 Unit_Test (struct frame *f, char * s) | |
| 1069 /* mrb unit testing */ | |
| 1070 { | |
| 1071 XrmValue fromVal, toVal; | |
| 1072 | |
| 1073 fromVal.addr = s; | |
| 1074 fromVal.size = strlen (s); | |
| 1075 toVal.addr = (XtPointer) &user_preferred_XIMStyles; | |
| 1076 toVal.size = sizeof (XIMStyles); | |
| 1077 | |
| 1078 if (XtConvertAndStore (FRAME_X_TEXT_WIDGET (f), XtRString, &fromVal, | |
| 1079 XtRXimStyles, &toVal) != False) | |
| 1080 { | |
| 1081 stderr_out ("Unit_Test: fromVal.addr=0x%x\n",fromVal.addr); | |
| 1082 stderr_out ("Unit_Test: fromVal.size=%d\n", fromVal.size); | |
| 1083 stderr_out ("Unit_Test: toVal.addr=0x%x\n", toVal.addr); | |
| 1084 stderr_out ("Unit_Test: toVal.size=%d\n", toVal.size); | |
| 1085 describe_XIMStyles ((XIMStyles *) toVal.addr); | |
| 1086 } | |
| 1087 } | |
| 1088 #endif | |
| 448 | 1089 #endif /* XIM_XLIB only */ |
| 428 | 1090 |
| 1091 #if 0 | |
| 1092 /* Get a fontset for IM to use */ | |
| 1093 void | |
| 1094 x_init_fontset (struct device *d) | |
| 1095 { | |
| 1096 Display *dpy = DEVICE_X_DISPLAY (d); | |
| 1097 XFontSet fontset; | |
| 1098 char ** missing_charsets; | |
| 1099 int num_missing_charsets; | |
| 1100 char * default_string; | |
| 1101 /* char * font_set_string = "-dt-interface user-medium-r-normal-s*-*-*-*-*-*-*-*-*";*/ | |
| 1102 char * font_set_string = "-dt-interface user-medium-r-normal-s*-*-*-*-*-*-*-*-*, -misc-fixed-medium-r-normal--14-130-75-75-c-70-jisx0201.1976-0,-misc-fixed-medium-r-normal--14-130-75-75-c-140-jisx0208.1983-0, -misc-fixed-medium-r-normal--14-130-75-75-c-70-jisx0201.1976-0" ; | |
| 1103 | |
| 1104 DEVICE_X_FONTSET (d) = fontset = | |
| 1105 XCreateFontSet (dpy, | |
| 1106 font_set_string, | |
| 1107 &missing_charsets, | |
| 1108 &num_missing_charsets, | |
| 1109 &default_string); | |
| 1110 | |
| 1111 if (fontset == NULL) | |
| 1112 { | |
| 1113 stderr_out ("Unable to create fontset from string:\n%s\n", font_set_string); | |
| 1114 return; | |
| 1115 } | |
| 1116 if (num_missing_charsets > 0) | |
| 1117 { | |
| 1118 int i; | |
| 1119 stderr_out ("\nMissing charsets for fontset %s:\n", font_set_string); | |
| 1120 for (i=0; i < num_missing_charsets; i++) | |
| 1121 { | |
| 1122 stderr_out ("%s\n", missing_charsets[i]); | |
| 1123 } | |
| 1124 XFreeStringList (missing_charsets); | |
| 1125 stderr_out ("Default string: %s\n", default_string); | |
| 1126 } | |
| 1127 | |
| 1128 #ifdef DEBUG_XIM | |
| 1129 describe_XFontSet (fontset); | |
| 1130 #endif | |
| 1131 } | |
| 1132 #endif /* 0 */ |