Mercurial > hg > xemacs-beta
annotate src/frame-x.c @ 5167:e374ea766cc1
clean up, rearrange allocation statistics code
-------------------- ChangeLog entries follow: --------------------
src/ChangeLog addition:
2010-03-21 Ben Wing <ben@xemacs.org>
* alloc.c:
* alloc.c (assert_proper_sizing):
* alloc.c (c_readonly):
* alloc.c (malloced_storage_size):
* alloc.c (fixed_type_block_overhead):
* alloc.c (lisp_object_storage_size):
* alloc.c (inc_lrecord_stats):
* alloc.c (dec_lrecord_stats):
* alloc.c (pluralize_word):
* alloc.c (object_memory_usage_stats):
* alloc.c (Fobject_memory_usage):
* alloc.c (compute_memusage_stats_length):
* alloc.c (disksave_object_finalization_1):
* alloc.c (Fgarbage_collect):
* mc-alloc.c:
* mc-alloc.c (mc_alloced_storage_size):
* mc-alloc.h:
No functionality change here. Collect the allocations-statistics
code that was scattered throughout alloc.c into one place. Add
remaining section headings so that all sections have headings
clearly identifying the start of the section and its purpose.
Expose mc_alloced_storage_size() even when not MEMORY_USAGE_STATS;
this fixes build problems and is related to the export of
lisp_object_storage_size() and malloced_storage_size() when
non-MEMORY_USAGE_STATS in the previous change set.
| author | Ben Wing <ben@xemacs.org> |
|---|---|
| date | Sun, 21 Mar 2010 04:41:49 -0500 |
| parents | 7be849cb8828 |
| children | 97eb4942aec8 |
| rev | line source |
|---|---|
| 428 | 1 /* Functions for the X window system. |
| 2 Copyright (C) 1989, 1992-5, 1997 Free Software Foundation, Inc. | |
|
5050
6f2158fa75ed
Fix quick-build, use asserts() in place of ABORT()
Ben Wing <ben@xemacs.org>
parents:
4982
diff
changeset
|
3 Copyright (C) 1995, 1996, 2001, 2002, 2004, 2010 Ben Wing. |
|
5080
5502045ec510
The background-placement face property.
Didier Verna <didier@lrde.epita.fr>
parents:
5050
diff
changeset
|
4 Copyright (C) 2010 Didier Verna |
| 428 | 5 |
| 6 This file is part of XEmacs. | |
| 7 | |
| 8 XEmacs is free software; you can redistribute it and/or modify it | |
| 9 under the terms of the GNU General Public License as published by the | |
| 10 Free Software Foundation; either version 2, or (at your option) any | |
| 11 later version. | |
| 12 | |
| 13 XEmacs is distributed in the hope that it will be useful, but WITHOUT | |
| 14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 16 for more details. | |
| 17 | |
| 18 You should have received a copy of the GNU General Public License | |
| 19 along with XEmacs; see the file COPYING. If not, write to | |
| 20 the Free Software Foundation, Inc., 59 Temple Place - Suite 330, | |
| 21 Boston, MA 02111-1307, USA. */ | |
| 22 | |
| 23 /* Synched up with: Not synched with FSF. */ | |
| 24 | |
| 2367 | 25 /* This file has been Mule-ized, Ben Wing, 10-14-04. */ |
| 26 | |
| 428 | 27 /* Substantially rewritten for XEmacs. */ |
| 28 | |
| 29 #include <config.h> | |
| 30 #include "lisp.h" | |
| 31 | |
| 800 | 32 #include "buffer.h" |
| 872 | 33 #include "device-impl.h" |
| 800 | 34 #include "events.h" |
| 35 #include "extents.h" | |
| 36 #include "faces.h" | |
| 872 | 37 #include "frame-impl.h" |
| 800 | 38 #include "gutter.h" |
| 872 | 39 #include "window.h" |
| 40 | |
| 41 #include "console-x-impl.h" | |
| 800 | 42 #include "glyphs-x.h" |
| 872 | 43 #include "objects-x-impl.h" |
| 800 | 44 #include "scrollbar-x.h" |
| 45 | |
| 428 | 46 #include "xintrinsicp.h" /* CoreP.h needs this */ |
| 47 #include <X11/CoreP.h> /* Numerous places access the fields of | |
| 48 a core widget directly. We could | |
| 49 use XtGetValues(), but ... */ | |
| 50 #include <X11/Shell.h> | |
| 51 #include <X11/ShellP.h> | |
|
4769
5460287a3327
Remove support for pre-X11R5 systems, including systems without Xmu. See
Jerry James <james@xemacs.org>
parents:
4706
diff
changeset
|
52 #include <X11/Xmu/Editres.h> |
| 428 | 53 #include "EmacsManager.h" |
| 54 #include "EmacsFrameP.h" | |
| 55 #include "EmacsShell.h" | |
| 56 #ifdef EXTERNAL_WIDGET | |
| 57 #include "ExternalShell.h" | |
| 58 #endif | |
| 59 | |
| 60 #ifdef HAVE_DRAGNDROP | |
| 61 #include "dragdrop.h" | |
| 62 #endif | |
| 63 | |
| 64 /* Default properties to use when creating frames. */ | |
| 65 Lisp_Object Vdefault_x_frame_plist; | |
| 66 | |
| 2747 | 67 Lisp_Object Qoverride_redirect; |
| 428 | 68 Lisp_Object Qx_resource_name; |
| 69 | |
| 1204 | 70 static const struct memory_description x_frame_data_description_1 [] = { |
| 1346 | 71 { XD_LISP_OBJECT, offsetof (struct x_frame, last_menubar_buffer) }, |
| 1204 | 72 { XD_LISP_OBJECT, offsetof (struct x_frame, icon_pixmap) }, |
| 73 { XD_LISP_OBJECT, offsetof (struct x_frame, icon_pixmap_mask) }, | |
| 74 { XD_END } | |
| 75 }; | |
| 76 | |
| 3092 | 77 #ifdef NEW_GC |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
78 DEFINE_DUMPABLE_INTERNAL_LISP_OBJECT ("x-frame", x_frame, |
|
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
79 0, x_frame_data_description_1, |
|
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
80 Lisp_X_Frame); |
| 3092 | 81 #else /* not NEW_GC */ |
| 1204 | 82 extern const struct sized_memory_description x_frame_data_description; |
| 83 | |
| 84 const struct sized_memory_description x_frame_data_description = { | |
| 85 sizeof (struct x_frame), x_frame_data_description_1 | |
| 86 }; | |
| 3092 | 87 #endif /* not NEW_GC */ |
| 1204 | 88 |
| 428 | 89 EXFUN (Fx_window_id, 1); |
| 90 | |
| 91 | |
| 92 /************************************************************************/ | |
| 93 /* helper functions */ | |
| 94 /************************************************************************/ | |
| 95 | |
| 96 /* Return the Emacs frame-object corresponding to an X window */ | |
| 97 struct frame * | |
| 98 x_window_to_frame (struct device *d, Window wdesc) | |
| 99 { | |
| 100 Lisp_Object tail, frame; | |
| 101 struct frame *f; | |
| 102 | |
| 103 /* This function was previously written to accept only a window argument | |
| 104 (and to loop over all devices looking for a matching window), but | |
| 105 that is incorrect because window ID's are not unique across displays. */ | |
| 106 | |
| 107 for (tail = DEVICE_FRAME_LIST (d); CONSP (tail); tail = XCDR (tail)) | |
| 108 { | |
| 109 frame = XCAR (tail); | |
| 110 if (!FRAMEP (frame)) | |
| 111 continue; | |
| 112 f = XFRAME (frame); | |
| 113 if (FRAME_X_P (f) && XtWindow (FRAME_X_TEXT_WIDGET (f)) == wdesc) | |
| 114 return f; | |
| 115 } | |
| 116 return 0; | |
| 117 } | |
| 118 | |
| 119 /* Like x_window_to_frame but also compares the window with the widget's | |
| 120 windows */ | |
| 121 struct frame * | |
| 122 x_any_window_to_frame (struct device *d, Window wdesc) | |
| 123 { | |
| 124 Widget w; | |
| 125 assert (DEVICE_X_P (d)); | |
| 126 | |
| 127 w = XtWindowToWidget (DEVICE_X_DISPLAY (d), wdesc); | |
| 128 | |
| 129 if (!w) | |
| 130 return 0; | |
| 131 | |
| 132 /* We used to map over all frames here and then map over all widgets | |
| 133 belonging to that frame. However it turns out that this was very fragile | |
| 442 | 134 as it requires our display structures to be in sync _and_ that the |
| 428 | 135 loop is told about every new widget somebody adds. Therefore we |
| 136 now let Xt find it for us (which does a bottom-up search which | |
| 137 could even be faster) */ | |
| 138 return x_any_widget_or_parent_to_frame (d, w); | |
| 139 } | |
| 140 | |
| 141 static struct frame * | |
| 142 x_find_frame_for_window (struct device *d, Window wdesc) | |
| 143 { | |
| 144 Lisp_Object tail, frame; | |
| 145 struct frame *f; | |
| 146 /* This function was previously written to accept only a window argument | |
| 147 (and to loop over all devices looking for a matching window), but | |
| 148 that is incorrect because window ID's are not unique across displays. */ | |
| 149 | |
| 150 for (tail = DEVICE_FRAME_LIST (d); CONSP (tail); tail = XCDR (tail)) | |
| 151 { | |
| 152 frame = XCAR (tail); | |
| 153 f = XFRAME (frame); | |
| 154 /* This frame matches if the window is any of its widgets. */ | |
| 155 if (wdesc == XtWindow (FRAME_X_SHELL_WIDGET (f)) || | |
| 156 wdesc == XtWindow (FRAME_X_CONTAINER_WIDGET (f)) || | |
| 157 wdesc == XtWindow (FRAME_X_TEXT_WIDGET (f))) | |
| 158 return f; | |
| 159 | |
| 160 /* Match if the window is one of the widgets at the top of the frame | |
| 161 (menubar, Energize psheets). */ | |
| 162 | |
| 163 /* Note: Jamie once said | |
| 164 | |
| 165 "Do *not* match if the window is this frame's psheet." | |
| 166 | |
| 167 But this is wrong and will screw up some functions that expect | |
| 168 x_any_window_to_frame() to work as advertised. I think the reason | |
| 169 for this statement is that, in the old (broken) event loop, where | |
| 170 not all events went through XtDispatchEvent(), psheet events | |
| 171 would incorrectly get sucked away by Emacs if this function matched | |
| 172 on psheet widgets. */ | |
| 173 | |
| 174 /* Note: that this called only from | |
| 175 x_any_widget_or_parent_to_frame it is unnecessary to iterate | |
| 176 over the top level widgets. */ | |
| 177 | |
| 178 /* Note: we use to special case scrollbars but this turns out to be a bad idea | |
| 179 because | |
| 180 1. We sometimes get events for _unmapped_ scrollbars and our | |
| 181 callers don't want us to fail. | |
| 182 2. Starting with the 21.2 widget stuff there are now loads of | |
| 183 widgets to check and it is easy to forget adding them in a loop here. | |
| 184 See x_any_window_to_frame | |
| 185 3. We pick up all widgets now anyway. */ | |
| 186 } | |
| 187 | |
| 188 return 0; | |
| 189 } | |
| 190 | |
| 191 struct frame * | |
| 192 x_any_widget_or_parent_to_frame (struct device *d, Widget widget) | |
| 193 { | |
| 194 while (widget) | |
| 195 { | |
| 196 struct frame *f = x_find_frame_for_window (d, XtWindow (widget)); | |
| 197 if (f) | |
| 198 return f; | |
| 199 widget = XtParent (widget); | |
| 200 } | |
| 201 | |
| 202 return 0; | |
| 203 } | |
| 204 | |
| 205 struct frame * | |
| 206 decode_x_frame (Lisp_Object frame) | |
| 207 { | |
| 208 if (NILP (frame)) | |
| 793 | 209 frame = wrap_frame (selected_frame ()); |
| 428 | 210 CHECK_LIVE_FRAME (frame); |
| 211 /* this will also catch dead frames, but putting in the above check | |
| 212 results in a more useful error */ | |
| 213 CHECK_X_FRAME (frame); | |
| 214 return XFRAME (frame); | |
| 215 } | |
| 216 | |
| 217 | |
| 218 /************************************************************************/ | |
| 219 /* window-manager interactions */ | |
| 220 /************************************************************************/ | |
| 221 | |
| 222 #if 0 | |
| 223 /* Not currently used. */ | |
| 224 | |
| 225 void | |
| 226 x_wm_mark_shell_size_user_specified (Widget wmshell) | |
| 227 { | |
|
5050
6f2158fa75ed
Fix quick-build, use asserts() in place of ABORT()
Ben Wing <ben@xemacs.org>
parents:
4982
diff
changeset
|
228 assert (XtIsWMShell (wmshell)); |
| 428 | 229 EmacsShellSetSizeUserSpecified (wmshell); |
| 230 } | |
| 231 | |
| 232 void | |
| 233 x_wm_mark_shell_position_user_specified (Widget wmshell) | |
| 234 { | |
|
5050
6f2158fa75ed
Fix quick-build, use asserts() in place of ABORT()
Ben Wing <ben@xemacs.org>
parents:
4982
diff
changeset
|
235 assert (XtIsWMShell (wmshell)); |
| 428 | 236 EmacsShellSetPositionUserSpecified (wmshell); |
| 237 } | |
| 238 | |
| 239 #endif | |
| 240 | |
| 241 void | |
| 242 x_wm_set_shell_iconic_p (Widget shell, int iconic_p) | |
| 243 { | |
|
5050
6f2158fa75ed
Fix quick-build, use asserts() in place of ABORT()
Ben Wing <ben@xemacs.org>
parents:
4982
diff
changeset
|
244 assert (XtIsWMShell (shell)); |
| 428 | 245 |
| 246 /* Because of questionable logic in Shell.c, this sequence can't work: | |
| 247 | |
| 248 w = XtCreatePopupShell (...); | |
| 249 Xt_SET_VALUE (w, XtNiconic, True); | |
| 250 XtRealizeWidget (w); | |
| 251 | |
| 252 The iconic resource is only consulted at initialization time (when | |
| 253 XtCreatePopupShell is called) instead of at realization time (just | |
| 254 before the window gets created, which would be more sensible) or | |
| 255 at management-time (just before the window gets mapped, which would | |
| 256 be most sensible of all). | |
| 257 | |
| 258 The bug is that Shell's SetValues method doesn't do anything to | |
| 259 w->wm.wm_hints.initial_state until after the widget has been realized. | |
| 260 Calls to XtSetValues are ignored in the window between creation and | |
| 261 realization. This is true of MIT X11R5 patch level 25, at least. | |
| 262 (Apparently some other versions of Xt don't have this bug?) | |
| 263 */ | |
| 264 Xt_SET_VALUE (shell, XtNiconic, iconic_p); | |
| 265 EmacsShellSmashIconicHint (shell, iconic_p); | |
| 266 } | |
| 267 | |
| 268 void | |
| 269 x_wm_set_cell_size (Widget wmshell, int cw, int ch) | |
| 270 { | |
| 271 Arg al [2]; | |
| 272 | |
|
5050
6f2158fa75ed
Fix quick-build, use asserts() in place of ABORT()
Ben Wing <ben@xemacs.org>
parents:
4982
diff
changeset
|
273 assert (XtIsWMShell (wmshell)); |
|
6f2158fa75ed
Fix quick-build, use asserts() in place of ABORT()
Ben Wing <ben@xemacs.org>
parents:
4982
diff
changeset
|
274 assert (cw > 0 && ch > 0); |
| 428 | 275 |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
276 Xt_SET_ARG (al[0], XtNwidthInc, cw); |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
277 Xt_SET_ARG (al[1], XtNheightInc, ch); |
| 428 | 278 XtSetValues (wmshell, al, 2); |
| 279 } | |
| 280 | |
| 281 void | |
| 282 x_wm_set_variable_size (Widget wmshell, int width, int height) | |
| 283 { | |
| 284 Arg al [2]; | |
| 285 | |
|
5050
6f2158fa75ed
Fix quick-build, use asserts() in place of ABORT()
Ben Wing <ben@xemacs.org>
parents:
4982
diff
changeset
|
286 assert (XtIsWMShell (wmshell)); |
| 428 | 287 #ifdef DEBUG_GEOMETRY_MANAGEMENT |
| 288 /* See comment in EmacsShell.c */ | |
| 289 printf ("x_wm_set_variable_size: %d %d\n", width, height); | |
| 290 fflush (stdout); | |
| 291 #endif | |
| 292 | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
293 Xt_SET_ARG (al[0], XtNwidthCells, width); |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
294 Xt_SET_ARG (al[1], XtNheightCells, height); |
| 428 | 295 XtSetValues (wmshell, al, 2); |
| 296 } | |
| 297 | |
| 298 /* If the WM_PROTOCOLS property does not already contain WM_TAKE_FOCUS | |
| 299 and WM_DELETE_WINDOW, then add them. (They may already be present | |
| 300 because of the toolkit (Motif adds them, for example, but Xt doesn't). | |
| 301 */ | |
| 302 static void | |
| 303 x_wm_hack_wm_protocols (Widget widget) | |
| 304 { | |
| 305 Display *dpy = XtDisplay (widget); | |
| 306 struct device *d = get_device_from_display (dpy); | |
| 307 Window w = XtWindow (widget); | |
| 308 int need_delete = 1; | |
| 309 int need_focus = 1; | |
| 310 | |
| 311 assert (XtIsWMShell (widget)); | |
| 312 | |
| 313 { | |
| 1885 | 314 Atom type; |
| 428 | 315 int format = 0; |
| 316 unsigned long nitems = 0; | |
| 317 unsigned long bytes_after; | |
| 2367 | 318 Rawbyte *prop_return = 0; /* semantically a void* */ |
| 428 | 319 |
| 320 if (Success == XGetWindowProperty (dpy, w, DEVICE_XATOM_WM_PROTOCOLS (d), | |
| 321 0, 100, False, XA_ATOM, | |
| 322 &type, &format, &nitems, &bytes_after, | |
| 1885 | 323 &prop_return) |
| 428 | 324 && format == 32 && type == XA_ATOM) |
| 325 while (nitems > 0) | |
| 326 { | |
| 1885 | 327 Atom *atoms = (Atom *) prop_return; |
| 428 | 328 nitems--; |
| 1885 | 329 if (atoms[nitems] == DEVICE_XATOM_WM_DELETE_WINDOW (d)) |
| 428 | 330 need_delete = 0; |
| 1885 | 331 else if (atoms[nitems] == DEVICE_XATOM_WM_TAKE_FOCUS (d)) |
| 428 | 332 need_focus = 0; |
| 333 } | |
| 2367 | 334 if (prop_return) XFree ((CRawbyte *) prop_return); |
| 428 | 335 } |
| 336 { | |
| 337 Atom props [10]; | |
| 338 int count = 0; | |
| 339 if (need_delete) props[count++] = DEVICE_XATOM_WM_DELETE_WINDOW (d); | |
| 340 if (need_focus) props[count++] = DEVICE_XATOM_WM_TAKE_FOCUS (d); | |
| 341 if (count) | |
| 342 XChangeProperty (dpy, w, DEVICE_XATOM_WM_PROTOCOLS (d), XA_ATOM, 32, | |
| 2367 | 343 PropModeAppend, (Rawbyte *) props, count); |
| 428 | 344 } |
| 345 } | |
| 346 | |
| 347 static void | |
| 2367 | 348 x_wm_store_class_hints (Widget shell, Extbyte *frame_name) |
| 428 | 349 { |
| 350 Display *dpy = XtDisplay (shell); | |
| 2367 | 351 Extbyte *app_name, *app_class; |
| 428 | 352 XClassHint classhint; |
| 353 | |
|
5050
6f2158fa75ed
Fix quick-build, use asserts() in place of ABORT()
Ben Wing <ben@xemacs.org>
parents:
4982
diff
changeset
|
354 assert (XtIsWMShell (shell)); |
| 428 | 355 |
| 356 XtGetApplicationNameAndClass (dpy, &app_name, &app_class); | |
| 357 classhint.res_name = frame_name; | |
| 358 classhint.res_class = app_class; | |
| 359 XSetClassHint (dpy, XtWindow (shell), &classhint); | |
| 360 } | |
| 361 | |
| 362 #ifndef HAVE_WMCOMMAND | |
| 2367 | 363 |
| 428 | 364 static void |
| 365 x_wm_maybe_store_wm_command (struct frame *f) | |
| 366 { | |
| 367 Widget w = FRAME_X_SHELL_WIDGET (f); | |
| 368 struct device *d = XDEVICE (FRAME_DEVICE (f)); | |
| 369 | |
|
5050
6f2158fa75ed
Fix quick-build, use asserts() in place of ABORT()
Ben Wing <ben@xemacs.org>
parents:
4982
diff
changeset
|
370 assert (XtIsWMShell (w)); |
| 428 | 371 |
| 372 if (NILP (DEVICE_X_WM_COMMAND_FRAME (d))) | |
| 373 { | |
| 374 int argc; | |
| 2367 | 375 Wexttext **argv; |
| 428 | 376 make_argc_argv (Vcommand_line_args, &argc, &argv); |
| 377 XSetCommand (XtDisplay (w), XtWindow (w), argv, argc); | |
| 378 free_argc_argv (argv); | |
| 793 | 379 DEVICE_X_WM_COMMAND_FRAME (d) = wrap_frame (f); |
| 428 | 380 } |
| 381 } | |
| 382 | |
| 383 /* If we're deleting the frame on which the WM_COMMAND property has been | |
| 384 set, then move that property to another frame so that there is exactly | |
| 385 one frame that has that property set. | |
| 386 */ | |
| 387 static void | |
| 388 x_wm_maybe_move_wm_command (struct frame *f) | |
| 389 { | |
| 390 struct device *d = XDEVICE (FRAME_DEVICE (f)); | |
| 391 | |
| 392 /* There may not be a frame in DEVICE_X_WM_COMMAND_FRAME() | |
| 393 if we C-c'ed at startup at the right time. */ | |
| 394 if (FRAMEP (DEVICE_X_WM_COMMAND_FRAME (d)) | |
| 395 && f == XFRAME (DEVICE_X_WM_COMMAND_FRAME (d))) | |
| 396 { | |
| 397 Lisp_Object rest = DEVICE_FRAME_LIST (d); | |
| 398 DEVICE_X_WM_COMMAND_FRAME (d) = Qnil; | |
| 399 /* find some random other X frame that is not this one, or give up */ | |
| 400 /* skip non-top-level (ExternalClient) frames */ | |
| 401 while (!NILP (rest) && | |
| 402 (f == XFRAME (XCAR (rest)) || | |
| 403 !FRAME_X_TOP_LEVEL_FRAME_P (XFRAME (XCAR (rest))))) | |
| 404 rest = XCDR (rest); | |
| 405 if (NILP (rest)) | |
| 406 return; | |
| 407 f = XFRAME (XCAR (rest)); | |
| 408 | |
| 409 x_wm_maybe_store_wm_command (f); | |
| 410 | |
| 411 } | |
| 412 } | |
| 2367 | 413 |
| 428 | 414 #endif /* !HAVE_WMCOMMAND */ |
| 415 | |
| 593 | 416 int |
| 417 x_frame_window_state (struct frame *f) | |
| 428 | 418 { |
| 419 Atom actual_type; | |
| 420 int actual_format; | |
| 421 unsigned long nitems, bytesafter; | |
| 2367 | 422 Rawbyte *datap = 0; |
| 428 | 423 Widget widget; |
| 593 | 424 int result = -1; |
| 428 | 425 struct device *d = XDEVICE (FRAME_DEVICE (f)); |
| 426 | |
| 427 widget = FRAME_X_SHELL_WIDGET (f); | |
| 428 if (Success == XGetWindowProperty (XtDisplay (widget), XtWindow (widget), | |
| 429 DEVICE_XATOM_WM_STATE (d), 0, 2, False, | |
| 430 DEVICE_XATOM_WM_STATE (d), &actual_type, | |
| 431 &actual_format, &nitems, &bytesafter, | |
| 1885 | 432 &datap) |
| 428 | 433 && datap) |
| 434 { | |
| 1885 | 435 unsigned long *ul_result_ptr = (unsigned long *) datap; |
| 593 | 436 if (nitems <= 2) /* "suggested" by ICCCM version 1 */ |
| 1885 | 437 result = (int) ul_result_ptr[0]; |
| 2367 | 438 XFree ((CRawbyte *) datap); |
| 428 | 439 } |
| 593 | 440 |
| 428 | 441 return result; |
| 442 } | |
| 443 | |
| 593 | 444 static int |
| 445 x_frame_iconified_p (struct frame *f) | |
| 446 { | |
| 447 return x_frame_window_state (f) == IconicState; | |
| 448 } | |
| 449 | |
| 428 | 450 |
| 451 /************************************************************************/ | |
| 452 /* frame properties */ | |
| 453 /************************************************************************/ | |
| 454 | |
| 455 /* Connect the frame-property names (symbols) to the corresponding | |
| 456 X Resource Manager names. The name of a property, as a Lisp symbol, | |
| 793 | 457 has an `x-resource-name' property which is a Lisp string. */ |
| 428 | 458 |
| 459 static void | |
| 460 init_x_prop_symbols (void) | |
| 461 { | |
| 462 #define def(sym, rsrc) \ | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
463 Fput (sym, Qx_resource_name, build_ascstring (rsrc)) |
| 428 | 464 #define defi(sym,rsrc) \ |
| 465 def (sym, rsrc); Fput (sym, Qintegerp, Qt) | |
| 466 | |
| 467 #if 0 /* this interferes with things. #### fix this right */ | |
| 468 def (Qminibuffer, XtNminibuffer); | |
| 469 def (Qunsplittable, XtNunsplittable); | |
| 470 #endif | |
| 471 defi(Qinternal_border_width, XtNinternalBorderWidth); | |
| 472 def (Qscrollbar_placement, XtNscrollBarPlacement); | |
| 473 defi(Qinter_line_space, XtNinterline); | |
| 474 /* font, foreground */ | |
| 475 def (Qiconic, XtNiconic); | |
| 476 def (Qbar_cursor, XtNbarCursor); | |
| 477 def (Qvisual_bell, XtNvisualBell); | |
| 478 defi(Qbell_volume, XtNbellVolume); | |
| 479 def (Qpointer_background, XtNpointerBackground); | |
| 480 def (Qpointer_color, XtNpointerColor); | |
| 481 def (Qtext_pointer, XtNtextPointer); | |
| 482 def (Qspace_pointer, XtNspacePointer); | |
| 483 def (Qmodeline_pointer, XtNmodeLinePointer); | |
| 484 def (Qgc_pointer, XtNgcPointer); | |
| 485 /* geometry, initial_geometry */ | |
| 486 def (Qinitially_unmapped, XtNinitiallyUnmapped); | |
| 487 /* preferred_width, preferred_height */ | |
| 488 def (Quse_backing_store, XtNuseBackingStore); | |
| 489 | |
| 490 /* inherited: */ | |
| 491 | |
| 492 def (Qborder_color, XtNborderColor); | |
| 493 defi(Qborder_width, XtNborderWidth); | |
| 494 defi(Qwidth, XtNwidth); | |
| 495 defi(Qheight, XtNheight); | |
| 496 defi(Qleft, XtNx); | |
| 497 defi(Qtop, XtNy); | |
| 498 | |
| 499 #undef def | |
| 3381 | 500 #undef defi |
| 428 | 501 } |
| 502 | |
| 503 static Lisp_Object | |
| 504 color_to_string (Widget w, unsigned long pixel) | |
| 505 { | |
| 867 | 506 Ibyte buf[255]; |
| 428 | 507 |
| 508 XColor color; | |
| 509 color.pixel = pixel; | |
| 510 XQueryColor (XtDisplay (w), w->core.colormap, &color); | |
| 771 | 511 qxesprintf (buf, "#%04x%04x%04x", color.red, color.green, color.blue); |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
512 return build_istring (buf); |
| 428 | 513 } |
| 514 | |
| 515 static void | |
| 516 x_get_top_level_position (Display *d, Window w, Position *x, Position *y) | |
| 517 { | |
| 518 Window root, parent = w, *children; | |
| 519 unsigned int nchildren; | |
| 520 XWindowAttributes xwa; | |
| 521 | |
| 522 do | |
| 523 { | |
| 524 w = parent; | |
| 525 if (!XQueryTree (d, w, &root, &parent, &children, &nchildren)) | |
| 526 { | |
| 527 *x = 0; | |
| 528 *y = 0; | |
| 529 return; | |
| 530 } | |
| 531 XFree (children); | |
| 532 } | |
| 533 while (root != parent); | |
| 534 XGetWindowAttributes (d, w, &xwa); | |
| 535 *x = xwa.x; | |
| 536 *y = xwa.y; | |
| 537 } | |
| 538 | |
|
5080
5502045ec510
The background-placement face property.
Didier Verna <didier@lrde.epita.fr>
parents:
5050
diff
changeset
|
539 void x_get_frame_text_position (struct frame *f) |
|
5502045ec510
The background-placement face property.
Didier Verna <didier@lrde.epita.fr>
parents:
5050
diff
changeset
|
540 { |
|
5502045ec510
The background-placement face property.
Didier Verna <didier@lrde.epita.fr>
parents:
5050
diff
changeset
|
541 Display *dpy = DEVICE_X_DISPLAY (XDEVICE (FRAME_DEVICE (f))); |
|
5502045ec510
The background-placement face property.
Didier Verna <didier@lrde.epita.fr>
parents:
5050
diff
changeset
|
542 Window window = XtWindow (FRAME_X_TEXT_WIDGET (f)); |
|
5502045ec510
The background-placement face property.
Didier Verna <didier@lrde.epita.fr>
parents:
5050
diff
changeset
|
543 Window root, child; |
|
5502045ec510
The background-placement face property.
Didier Verna <didier@lrde.epita.fr>
parents:
5050
diff
changeset
|
544 int x, y; |
|
5502045ec510
The background-placement face property.
Didier Verna <didier@lrde.epita.fr>
parents:
5050
diff
changeset
|
545 unsigned int width, height, border_width; |
|
5502045ec510
The background-placement face property.
Didier Verna <didier@lrde.epita.fr>
parents:
5050
diff
changeset
|
546 unsigned int depth; |
|
5502045ec510
The background-placement face property.
Didier Verna <didier@lrde.epita.fr>
parents:
5050
diff
changeset
|
547 |
|
5502045ec510
The background-placement face property.
Didier Verna <didier@lrde.epita.fr>
parents:
5050
diff
changeset
|
548 XGetGeometry (dpy, window, &root, &x, &y, &width, &height, &border_width, |
|
5502045ec510
The background-placement face property.
Didier Verna <didier@lrde.epita.fr>
parents:
5050
diff
changeset
|
549 &depth); |
|
5502045ec510
The background-placement face property.
Didier Verna <didier@lrde.epita.fr>
parents:
5050
diff
changeset
|
550 XTranslateCoordinates (dpy, window, root, 0, 0, &x, &y, &child); |
|
5502045ec510
The background-placement face property.
Didier Verna <didier@lrde.epita.fr>
parents:
5050
diff
changeset
|
551 |
|
5502045ec510
The background-placement face property.
Didier Verna <didier@lrde.epita.fr>
parents:
5050
diff
changeset
|
552 FRAME_X_X (f) = x; |
|
5502045ec510
The background-placement face property.
Didier Verna <didier@lrde.epita.fr>
parents:
5050
diff
changeset
|
553 FRAME_X_Y (f) = y; |
|
5502045ec510
The background-placement face property.
Didier Verna <didier@lrde.epita.fr>
parents:
5050
diff
changeset
|
554 } |
|
5502045ec510
The background-placement face property.
Didier Verna <didier@lrde.epita.fr>
parents:
5050
diff
changeset
|
555 |
| 428 | 556 #if 0 |
| 557 static void | |
| 558 x_smash_bastardly_shell_position (Widget shell) | |
| 559 { | |
| 560 /* Naturally those bastards who wrote Xt couldn't be bothered | |
| 561 to learn about race conditions and such. We can't trust | |
| 562 the X and Y values to have any semblance of correctness, | |
| 563 so we smash the right values in place. */ | |
| 564 | |
| 565 /* We might be called before we've actually realized the window (if | |
| 566 we're checking for the minibuffer resource). This will bomb in | |
| 567 that case so we don't bother calling it. */ | |
| 568 if (XtWindow (shell)) | |
| 569 x_get_top_level_position (XtDisplay (shell), XtWindow (shell), | |
| 570 &shell->core.x, &shell->core.y); | |
| 571 } | |
| 572 #endif /* 0 */ | |
| 573 | |
| 574 static Lisp_Object | |
| 575 x_frame_property (struct frame *f, Lisp_Object property) | |
| 576 { | |
| 577 Widget shell = FRAME_X_SHELL_WIDGET (f); | |
| 578 EmacsFrame w = (EmacsFrame) FRAME_X_TEXT_WIDGET (f); | |
| 579 Widget gw = (Widget) w; | |
| 580 | |
| 581 if (EQ (Qleft, property) || EQ (Qtop, property)) | |
| 582 { | |
| 583 Position x, y; | |
| 584 if (!XtWindow(shell)) | |
| 585 return Qzero; | |
| 586 x_get_top_level_position (XtDisplay (shell), XtWindow (shell), &x, &y); | |
| 587 if (EQ (Qleft, property)) return make_int (x); | |
| 588 if (EQ (Qtop, property)) return make_int (y); | |
| 589 } | |
| 590 if (EQ (Qborder_width, property)) | |
| 591 return make_int (w->core.border_width); | |
| 592 if (EQ (Qinternal_border_width, property)) | |
| 593 return make_int (w->emacs_frame.internal_border_width); | |
| 594 if (EQ (Qborder_color, property)) | |
| 595 return color_to_string (gw, w->core.border_pixel); | |
| 596 if (EQ (Qinter_line_space, property)) | |
| 597 return make_int (w->emacs_frame.interline); | |
| 598 if (EQ (Qwindow_id, property)) | |
| 771 | 599 return Fx_window_id (wrap_frame (f)); |
| 428 | 600 |
| 601 return Qunbound; | |
| 602 } | |
| 603 | |
| 604 static int | |
| 2286 | 605 x_internal_frame_property_p (struct frame *UNUSED (f), Lisp_Object property) |
| 428 | 606 { |
| 607 return EQ (property, Qleft) | |
| 608 || EQ (property, Qtop) | |
| 609 || EQ (property, Qborder_width) | |
| 610 || EQ (property, Qinternal_border_width) | |
| 611 || EQ (property, Qborder_color) | |
| 612 || EQ (property, Qinter_line_space) | |
| 613 || EQ (property, Qwindow_id) | |
| 614 || STRINGP (property); | |
| 615 } | |
| 616 | |
| 617 static Lisp_Object | |
| 618 x_frame_properties (struct frame *f) | |
| 619 { | |
| 620 Lisp_Object props = Qnil; | |
| 621 Widget shell = FRAME_X_SHELL_WIDGET (f); | |
| 622 EmacsFrame w = (EmacsFrame) FRAME_X_TEXT_WIDGET (f); | |
| 623 Widget gw = (Widget) w; | |
| 624 Position x, y; | |
| 625 | |
| 771 | 626 props = cons3 (Qwindow_id, Fx_window_id (wrap_frame (f)), props); |
| 428 | 627 props = cons3 (Qinter_line_space, make_int (w->emacs_frame.interline), props); |
| 628 | |
| 629 props = cons3 (Qborder_color, | |
| 630 color_to_string (gw, w->core.border_pixel), props); | |
| 631 props = cons3 (Qinternal_border_width, | |
| 632 make_int (w->emacs_frame.internal_border_width), props); | |
| 633 props = cons3 (Qborder_width, make_int (w->core.border_width), props); | |
| 634 | |
| 635 if (!XtWindow(shell)) | |
| 636 x = y = 0; | |
| 637 else | |
| 638 x_get_top_level_position (XtDisplay (shell), XtWindow (shell), &x, &y); | |
| 639 | |
| 640 props = cons3 (Qtop, make_int (y), props); | |
| 641 props = cons3 (Qleft, make_int (x), props); | |
| 642 | |
| 643 return props; | |
| 644 } | |
| 645 | |
| 646 | |
| 647 /* Functions called only from `x_set_frame_properties' to set | |
| 648 individual properties. */ | |
| 649 | |
| 650 static void | |
| 867 | 651 x_set_frame_text_value (struct frame *f, Ibyte *value, |
| 428 | 652 String Xt_resource_name, |
| 653 String Xt_resource_encoding_name) | |
| 654 { | |
| 655 Atom encoding = XA_STRING; | |
| 656 String new_XtValue = (String) value; | |
| 657 String old_XtValue = NULL; | |
| 658 | |
| 659 #ifdef MULE | |
| 867 | 660 Ibyte *ptr; |
| 428 | 661 /* Optimize for common ASCII case */ |
| 662 for (ptr = value; *ptr; ptr++) | |
| 826 | 663 if (!byte_ascii_p (*ptr)) |
| 428 | 664 { |
| 665 encoding = DEVICE_XATOM_COMPOUND_TEXT (XDEVICE (FRAME_DEVICE (f))); | |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
666 new_XtValue = (String) ITEXT_TO_EXTERNAL (value, Qctext); |
| 428 | 667 break; |
| 668 } | |
| 669 #endif /* MULE */ | |
| 670 | |
| 440 | 671 /* #### Caching is device-independent - belongs in update_frame_title. */ |
| 428 | 672 Xt_GET_VALUE (FRAME_X_SHELL_WIDGET (f), Xt_resource_name, &old_XtValue); |
| 673 if (!old_XtValue || strcmp (new_XtValue, old_XtValue)) | |
| 674 { | |
| 675 Arg al[2]; | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
676 Xt_SET_ARG (al[0], Xt_resource_name, new_XtValue); |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
677 Xt_SET_ARG (al[1], Xt_resource_encoding_name, encoding); |
| 428 | 678 XtSetValues (FRAME_X_SHELL_WIDGET (f), al, 2); |
| 679 } | |
| 680 } | |
| 681 | |
| 682 static void | |
| 867 | 683 x_set_title_from_ibyte (struct frame *f, Ibyte *name) |
| 428 | 684 { |
| 685 x_set_frame_text_value (f, name, XtNtitle, XtNtitleEncoding); | |
| 686 } | |
| 687 | |
| 688 static void | |
| 867 | 689 x_set_icon_name_from_ibyte (struct frame *f, Ibyte *name) |
| 428 | 690 { |
| 691 x_set_frame_text_value (f, name, XtNiconName, XtNiconNameEncoding); | |
| 692 } | |
| 693 | |
| 694 /* Set the initial frame size as specified. This function is used | |
| 695 when the frame's widgets have not yet been realized. In this | |
| 696 case, it is not sufficient just to set the width and height of | |
| 697 the EmacsFrame widget, because they will be ignored when the | |
| 698 widget is realized (instead, the shell's geometry resource is | |
| 699 used). */ | |
| 700 | |
| 701 static void | |
| 702 x_set_initial_frame_size (struct frame *f, int flags, int x, int y, | |
| 647 | 703 int w, int h) |
| 428 | 704 { |
| 2367 | 705 Ascbyte shell_geom[255]; |
| 428 | 706 int xval, yval; |
| 2367 | 707 Ascbyte xsign, ysign; |
| 708 Boolbyte uspos = !!(flags & (XValue | YValue)); | |
| 709 Boolbyte ussize = !!(flags & (WidthValue | HeightValue)); | |
| 710 Ascbyte *temp; | |
| 428 | 711 |
| 712 /* assign the correct size to the EmacsFrame widget ... */ | |
| 713 EmacsFrameSetCharSize (FRAME_X_TEXT_WIDGET (f), w, h); | |
| 714 | |
| 715 /* and also set the WMShell's geometry */ | |
| 716 (flags & XNegative) ? (xval = -x, xsign = '-') : (xval = x, xsign = '+'); | |
| 717 (flags & YNegative) ? (yval = -y, ysign = '-') : (yval = y, ysign = '+'); | |
| 718 | |
| 719 if (uspos && ussize) | |
| 720 sprintf (shell_geom, "=%dx%d%c%d%c%d", w, h, xsign, xval, ysign, yval); | |
| 721 else if (uspos) | |
| 722 sprintf (shell_geom, "=%c%d%c%d", xsign, xval, ysign, yval); | |
| 723 else if (ussize) | |
| 724 sprintf (shell_geom, "=%dx%d", w, h); | |
| 725 | |
| 726 if (uspos || ussize) | |
| 727 { | |
| 2367 | 728 temp = xnew_ascbytes (1 + strlen (shell_geom)); |
| 428 | 729 strcpy (temp, shell_geom); |
| 730 FRAME_X_GEOM_FREE_ME_PLEASE (f) = temp; | |
| 731 } | |
| 732 else | |
| 733 temp = NULL; | |
| 734 | |
| 735 Xt_SET_VALUE (FRAME_X_SHELL_WIDGET (f), XtNgeometry, temp); | |
| 736 } | |
| 737 | |
| 738 /* Report to X that a frame property of frame S is being set or changed. | |
| 739 If the property is not specially recognized, do nothing. | |
| 740 */ | |
| 741 | |
| 742 static void | |
| 743 x_set_frame_properties (struct frame *f, Lisp_Object plist) | |
| 744 { | |
| 745 Position x, y; | |
| 746 Dimension width = 0, height = 0; | |
| 747 Bool width_specified_p = False; | |
| 748 Bool height_specified_p = False; | |
| 749 Bool x_position_specified_p = False; | |
| 750 Bool y_position_specified_p = False; | |
| 751 Bool internal_border_width_specified = False; | |
| 752 Lisp_Object tail; | |
| 3415 | 753 Widget w; |
| 754 | |
| 755 /* We can be called after the X IO error handler has seen a broken pipe on | |
| 756 the relevant display. Don't do anything in that case. */ | |
| 757 if (!FRAME_LIVE_P (f) || DEVICE_X_BEING_DELETED (XDEVICE (FRAME_DEVICE (f)))) | |
| 758 return; | |
| 759 | |
| 760 w = FRAME_X_TEXT_WIDGET (f); | |
| 428 | 761 |
| 762 for (tail = plist; !NILP (tail); tail = Fcdr (Fcdr (tail))) | |
| 763 { | |
| 764 Lisp_Object prop = Fcar (tail); | |
| 765 Lisp_Object val = Fcar (Fcdr (tail)); | |
| 766 | |
| 767 if (STRINGP (prop)) | |
| 768 { | |
| 2367 | 769 const Extbyte *extprop; |
| 428 | 770 |
| 771 if (XSTRING_LENGTH (prop) == 0) | |
| 772 continue; | |
| 773 | |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
774 extprop = LISP_STRING_TO_EXTERNAL (prop, Qxt_widget_arg_encoding); |
| 428 | 775 if (STRINGP (val)) |
| 776 { | |
| 442 | 777 const Extbyte *extval; |
| 665 | 778 Bytecount extvallen; |
| 428 | 779 |
| 2367 | 780 /* !!#### I seriously doubt there is a single external format |
| 781 for the value of a widget argument; it depends on the | |
| 782 semantics of the argument. So use of | |
| 783 Qxt_widget_arg_encoding is totally bogus. --ben */ | |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
784 LISP_STRING_TO_SIZED_EXTERNAL (val, extval, extvallen, |
|
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
785 Qxt_widget_arg_encoding); |
| 428 | 786 XtVaSetValues (w, XtVaTypedArg, extprop, |
| 2367 | 787 /* !!#### Verify this + 1 and document |
| 788 as zero-termination */ | |
| 428 | 789 XtRString, extval, extvallen + 1, |
| 3463 | 790 NULL); |
| 428 | 791 } |
| 792 else | |
| 793 XtVaSetValues (w, XtVaTypedArg, extprop, XtRInt, | |
| 794 XINT (val), sizeof (int), | |
| 3463 | 795 NULL); |
| 428 | 796 } |
| 797 else if (SYMBOLP (prop)) | |
| 798 { | |
| 799 Lisp_Object str = Fget (prop, Qx_resource_name, Qnil); | |
| 800 int int_p = !NILP (Fget (prop, Qintegerp, Qnil)); | |
| 2367 | 801 Extbyte *strext; |
| 428 | 802 |
| 803 if (NILP (prop) || NILP (str)) | |
| 804 { | |
| 805 /* Kludge to handle the font property. */ | |
| 806 if (EQ (prop, Qfont)) | |
| 807 { | |
| 808 /* If the value is not a string we silently ignore it. */ | |
| 809 if (STRINGP (val)) | |
| 810 { | |
| 811 Lisp_Object frm, font_spec; | |
| 812 | |
| 793 | 813 frm = wrap_frame (f); |
| 428 | 814 font_spec = Fget (Fget_face (Qdefault), Qfont, Qnil); |
| 815 | |
| 816 Fadd_spec_to_specifier (font_spec, val, frm, Qnil, Qnil); | |
| 817 update_frame_face_values (f); | |
| 818 } | |
| 819 | |
| 820 continue; | |
| 821 } | |
| 822 else | |
| 823 continue; | |
| 824 } | |
| 825 CHECK_STRING (str); | |
| 826 | |
| 827 /* Kludge the width/height so that we interpret them in characters | |
| 828 instead of pixels. Yuck yuck yuck. */ | |
| 2367 | 829 if (!qxestrcmp_ascii (XSTRING_DATA (str), "width")) |
| 428 | 830 { |
| 831 CHECK_INT (val); | |
| 832 width = XINT (val); | |
| 833 width_specified_p = True; | |
| 834 continue; | |
| 835 } | |
| 2367 | 836 if (!qxestrcmp_ascii (XSTRING_DATA (str), "height")) |
| 428 | 837 { |
| 838 CHECK_INT (val); | |
| 839 height = XINT (val); | |
| 840 height_specified_p = True; | |
| 841 continue; | |
| 842 } | |
| 843 /* Further kludge the x/y. */ | |
| 2367 | 844 if (!qxestrcmp_ascii (XSTRING_DATA (str), "x")) |
| 428 | 845 { |
| 846 CHECK_INT (val); | |
| 847 x = (Position) XINT (val); | |
| 848 x_position_specified_p = True; | |
| 849 continue; | |
| 850 } | |
| 2367 | 851 if (!qxestrcmp_ascii (XSTRING_DATA (str), "y")) |
| 428 | 852 { |
| 853 CHECK_INT (val); | |
| 854 y = (Position) XINT (val); | |
| 855 y_position_specified_p = True; | |
| 856 continue; | |
| 857 } | |
| 858 /* Have you figured out by now that this entire function is | |
| 859 one gigantic kludge? */ | |
| 2367 | 860 if (!qxestrcmp_ascii (XSTRING_DATA (str), "internalBorderWidth")) |
| 428 | 861 { |
| 862 internal_border_width_specified = True; | |
| 863 } | |
| 864 | |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
865 strext = LISP_STRING_TO_EXTERNAL (str, Qxt_widget_arg_encoding); |
| 428 | 866 if (int_p) |
| 867 { | |
| 868 CHECK_INT (val); | |
| 2367 | 869 Xt_SET_VALUE (w, strext, XINT (val)); |
| 428 | 870 } |
| 871 else if (EQ (val, Qt)) | |
| 872 { | |
| 2367 | 873 Xt_SET_VALUE (w, strext, True); /* XtN...*/ |
| 428 | 874 } |
| 875 else if (EQ (val, Qnil)) | |
| 876 { | |
| 2367 | 877 Xt_SET_VALUE (w, strext, False); /* XtN...*/ |
| 428 | 878 } |
| 879 else | |
| 880 { | |
| 2367 | 881 const Extbyte *extval; |
| 882 Bytecount extvallen; | |
| 2372 | 883 CHECK_STRING (val); |
| 2367 | 884 |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
885 LISP_STRING_TO_SIZED_EXTERNAL (val, extval, extvallen, |
|
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
886 Qxt_widget_arg_encoding); |
| 428 | 887 XtVaSetValues (w, XtVaTypedArg, |
| 888 /* XtN... */ | |
| 2367 | 889 strext, |
| 890 /* !!#### Verify this + 1 and document | |
| 891 as zero-termination */ | |
| 892 XtRString, extval, extvallen + 1, | |
| 3463 | 893 NULL); |
| 428 | 894 } |
| 895 | |
| 896 #ifdef HAVE_SCROLLBARS | |
| 2367 | 897 if (!qxestrcmp_ascii (XSTRING_DATA (str), "scrollBarWidth") |
| 898 || !qxestrcmp_ascii (XSTRING_DATA (str), "scrollBarHeight")) | |
| 428 | 899 { |
| 900 x_update_frame_scrollbars (f); | |
| 901 } | |
| 902 #endif /* HAVE_SCROLLBARS */ | |
| 903 } | |
| 904 } | |
| 905 | |
| 906 /* Kludge kludge kludge. We need to deal with the size and position | |
| 907 specially. */ | |
| 908 { | |
| 909 int size_specified_p = width_specified_p || height_specified_p; | |
| 910 int position_specified_p = x_position_specified_p || | |
| 911 y_position_specified_p; | |
| 912 | |
| 913 if (!width_specified_p) | |
| 914 width = FRAME_WIDTH (f); | |
| 915 if (!height_specified_p) | |
| 916 height = FRAME_HEIGHT (f); | |
| 917 | |
| 918 /* Kludge kludge kludge kludge. */ | |
| 919 if (position_specified_p && | |
| 920 (!x_position_specified_p || !y_position_specified_p)) | |
| 921 { | |
| 922 Position dummy; | |
| 923 Widget shell = FRAME_X_SHELL_WIDGET (f); | |
| 924 x_get_top_level_position (XtDisplay (shell), XtWindow (shell), | |
| 925 (x_position_specified_p ? &dummy : &x), | |
| 926 (y_position_specified_p ? &dummy : &y)); | |
| 927 #if 0 | |
| 928 x = (int) (FRAME_X_SHELL_WIDGET (f)->core.x); | |
| 929 y = (int) (FRAME_X_SHELL_WIDGET (f)->core.y); | |
| 930 #endif | |
| 931 } | |
| 932 | |
| 933 if (!f->init_finished) | |
| 934 { | |
| 935 int flags = (size_specified_p ? WidthValue | HeightValue : 0) | | |
| 936 (position_specified_p ? | |
| 937 XValue | YValue | (x < 0 ? XNegative : 0) | (y < 0 ? YNegative : 0) | |
| 938 : 0); | |
| 939 if (size_specified_p | |
| 940 || position_specified_p | |
| 941 || internal_border_width_specified) | |
| 942 x_set_initial_frame_size (f, flags, x, y, width, height); | |
| 943 } | |
| 944 else | |
| 945 { | |
| 946 if (size_specified_p || internal_border_width_specified) | |
| 947 { | |
| 793 | 948 Lisp_Object frame = wrap_frame (f); |
| 949 | |
| 428 | 950 Fset_frame_size (frame, make_int (width), |
| 951 make_int (height), Qnil); | |
| 952 } | |
| 953 if (position_specified_p) | |
| 954 { | |
| 793 | 955 Lisp_Object frame = wrap_frame (f); |
| 956 | |
| 428 | 957 Fset_frame_position (frame, make_int (x), make_int (y)); |
| 958 } | |
| 959 } | |
| 960 } | |
| 961 } | |
| 962 | |
| 963 static int frame_title_format_already_set; | |
| 964 | |
| 965 static void | |
| 966 maybe_set_frame_title_format (Widget shell) | |
| 967 { | |
| 968 | |
| 969 /* Only do this if this is the first X frame we're creating. | |
| 970 | |
| 971 If the *title resource (or -title option) was specified, then | |
| 972 set frame-title-format to its value. | |
| 973 */ | |
| 974 | |
| 975 if (!frame_title_format_already_set) | |
| 976 { | |
| 977 /* No doubt there's a less stupid way to do this. */ | |
| 2367 | 978 Extbyte *results[2]; |
| 979 XtResource resources[2]; | |
| 980 results[0] = results[1] = 0; | |
| 981 resources[0].resource_name = XtNtitle; | |
| 982 resources[0].resource_class = XtCTitle; | |
| 983 resources[0].resource_type = XtRString; | |
| 984 resources[0].resource_size = sizeof (String); | |
| 985 resources[0].resource_offset = 0; | |
| 986 resources[0].default_type = XtRString; | |
| 987 resources[0].default_addr = 0; | |
| 988 resources[1].resource_name = XtNiconName; | |
| 989 resources[1].resource_class = XtCIconName; | |
| 990 resources[1].resource_type = XtRString; | |
| 991 resources[1].resource_size = sizeof (String); | |
| 992 resources[1].resource_offset = sizeof (Extbyte *); | |
| 993 resources[1].default_type = XtRString; | |
| 994 resources[1].default_addr = 0; | |
| 428 | 995 XtGetSubresources (XtParent (shell), (XtPointer) results, |
| 996 shell->core.name, | |
| 997 shell->core.widget_class->core_class.class_name, | |
| 998 resources, XtNumber (resources), 0, 0); | |
| 999 if (results[0]) | |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1000 Vframe_title_format = build_extstring (results[0], Qctext); |
| 428 | 1001 if (results[1]) |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1002 Vframe_icon_title_format = build_extstring (results[1], Qctext); |
| 428 | 1003 } |
| 1004 | |
| 1005 frame_title_format_already_set = 1; | |
| 1006 } | |
| 1007 | |
|
4790
bc4f2511bbea
Remove support for the OffiX drag-and-drop protocol. See xemacs-patches
Jerry James <james@xemacs.org>
parents:
4769
diff
changeset
|
1008 #if defined (HAVE_CDE) |
| 2367 | 1009 |
| 1010 static Extbyte * | |
| 1011 start_drag_internal_1 (Lisp_Object event, Lisp_Object data, | |
| 1012 Lisp_Object encoding, XEvent *x_event, int listp, | |
| 1013 Widget *wid_out, Bytecount *len_out, | |
| 1014 int *num_items_out) | |
| 1015 { | |
| 1016 struct frame *f; | |
| 1017 Widget wid; | |
| 1018 struct device *d; | |
| 1019 struct x_device *xd; | |
| 1020 XWindowAttributes win_attrib; | |
| 1021 int modifier = 0, state = 0; | |
| 1022 Extbyte *dnd_data; | |
| 1023 Lisp_Event *lisp_event; | |
| 1024 | |
| 1025 CHECK_EVENT (event); | |
| 1026 lisp_event = XEVENT (event); | |
| 1027 if (EVENT_TYPE (lisp_event) != button_press_event) | |
| 1028 invalid_argument ("Need button-press event for drag", event); | |
| 1029 f = decode_x_frame (FW_FRAME (EVENT_CHANNEL (lisp_event))); | |
| 1030 wid = FRAME_X_TEXT_WIDGET (f); | |
| 1031 d = XDEVICE (FRAME_DEVICE (f)); | |
| 1032 xd = DEVICE_X_DATA (d); | |
| 1033 *num_items_out = 0; | |
| 1034 | |
| 1035 if (listp) | |
| 1036 { | |
| 1037 DECLARE_EISTRING (ei); | |
| 1038 | |
| 1039 EXTERNAL_LIST_LOOP_2 (elt, data) | |
| 1040 { | |
| 1041 CHECK_STRING (elt); | |
| 1042 eicat_lstr (ei, elt); | |
| 1043 eicat_ch (ei, '\0'); | |
| 1044 (*num_items_out)++; | |
| 1045 } | |
| 1046 eicat_ch (ei, '\0'); | |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
1047 TO_EXTERNAL_FORMAT (DATA, (eidata (ei), eilen (ei)), |
|
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
1048 MALLOC, (dnd_data, *len_out), |
|
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
1049 encoding); |
| 2367 | 1050 } |
| 1051 else | |
| 1052 { | |
| 1053 CHECK_STRING (data); | |
| 1054 LISP_STRING_TO_SIZED_EXTERNAL_MALLOC (data, dnd_data, *len_out, | |
| 1055 encoding); | |
| 1056 *len_out += EXTTEXT_ZTERM_SIZE; | |
| 1057 (*num_items_out)++; | |
| 1058 } | |
| 1059 | |
| 1060 /* not so gross hack that converts an emacs event back to a XEvent */ | |
| 1061 | |
| 1062 x_event->xbutton.type = ButtonPress; | |
| 1063 x_event->xbutton.send_event = False; | |
| 1064 x_event->xbutton.display = XtDisplayOfObject (wid); | |
| 1065 x_event->xbutton.window = XtWindowOfObject (wid); | |
| 1066 x_event->xbutton.root = XRootWindow (x_event->xbutton.display, 0); | |
| 1067 x_event->xbutton.subwindow = 0; | |
| 1068 x_event->xbutton.time = lisp_event->timestamp; | |
| 1069 x_event->xbutton.x = EVENT_BUTTON_X (lisp_event); | |
| 1070 x_event->xbutton.y = EVENT_BUTTON_Y (lisp_event); | |
| 1071 if (Success == XGetWindowAttributes (x_event->xbutton.display, | |
| 1072 x_event->xbutton.window, | |
| 1073 &win_attrib)) | |
| 1074 { | |
| 1075 x_event->xbutton.x_root = win_attrib.x + EVENT_BUTTON_X (lisp_event); | |
| 1076 x_event->xbutton.y_root = win_attrib.y + EVENT_BUTTON_Y (lisp_event); | |
| 1077 } | |
| 1078 else | |
| 1079 { | |
| 1080 x_event->xbutton.x_root = EVENT_BUTTON_X (lisp_event); /* this is wrong */ | |
| 1081 x_event->xbutton.y_root = EVENT_BUTTON_Y (lisp_event); | |
| 1082 } | |
| 1083 | |
| 1084 modifier = EVENT_BUTTON_MODIFIERS (lisp_event); | |
| 1085 if (modifier & XEMACS_MOD_SHIFT) state |= ShiftMask; | |
| 1086 if (modifier & XEMACS_MOD_CONTROL) state |= ControlMask; | |
| 1087 if (modifier & XEMACS_MOD_META) state |= xd->MetaMask; | |
| 1088 if (modifier & XEMACS_MOD_SUPER) state |= xd->SuperMask; | |
| 1089 if (modifier & XEMACS_MOD_HYPER) state |= xd->HyperMask; | |
| 1090 if (modifier & XEMACS_MOD_ALT) state |= xd->AltMask; | |
| 1091 state |= Button1Mask << (EVENT_BUTTON_BUTTON (lisp_event) - 1); | |
| 1092 | |
| 1093 x_event->xbutton.state = state; | |
| 1094 x_event->xbutton.button = EVENT_BUTTON_BUTTON (lisp_event); | |
| 1095 x_event->xbutton.same_screen = True; | |
| 1096 | |
| 1097 *wid_out = wid; | |
| 1098 return dnd_data; | |
| 1099 } | |
| 1100 | |
|
4790
bc4f2511bbea
Remove support for the OffiX drag-and-drop protocol. See xemacs-patches
Jerry James <james@xemacs.org>
parents:
4769
diff
changeset
|
1101 #endif /* defined (HAVE_CDE) */ |
| 2367 | 1102 |
| 428 | 1103 #ifdef HAVE_CDE |
| 1104 #include <Dt/Dt.h> | |
| 1105 #include <Dt/Dnd.h> | |
| 1106 | |
| 1107 static Widget CurrentDragWidget = NULL; | |
| 1108 static XtCallbackRec dnd_convert_cb_rec[2]; | |
| 1109 static XtCallbackRec dnd_destroy_cb_rec[2]; | |
| 1110 static int drag_not_done = 0; | |
| 1111 | |
| 1112 static void | |
| 1113 x_cde_destroy_callback (Widget widget, XtPointer clientData, | |
| 1114 XtPointer callData) | |
| 1115 { | |
| 1116 DtDndDragFinishCallbackStruct *dragFinishInfo = | |
| 2367 | 1117 (DtDndDragFinishCallbackStruct *) callData; |
| 428 | 1118 DtDndContext *dragData = dragFinishInfo->dragData; |
| 1119 int i; | |
| 1120 | |
| 1121 /* free the items */ | |
| 1122 if (callData != NULL && dragData != NULL) | |
| 1123 { | |
| 1124 if (dragData->protocol == DtDND_BUFFER_TRANSFER) | |
| 1125 { | |
| 1126 for (i = 0; i < dragData->numItems; i++) | |
| 1127 { | |
| 2367 | 1128 XtFree ((CRawbyte *) dragData->data.buffers[i].bp); |
| 428 | 1129 if (dragData->data.buffers[i].name) |
| 1130 XtFree(dragData->data.buffers[i].name); | |
| 1131 } | |
| 1132 } | |
| 1133 else | |
| 1134 { | |
| 1135 for (i = 0; i < dragData->numItems; i++) | |
| 1136 XtFree(dragData->data.files[i]); | |
| 1137 } | |
| 1138 } | |
| 1139 | |
| 1140 /* free the data string */ | |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
1141 xfree (clientData); |
| 428 | 1142 |
| 1143 CurrentDragWidget = NULL; | |
| 1144 } | |
| 1145 | |
| 1146 static void | |
| 1147 x_cde_convert_callback (Widget widget, XtPointer clientData, | |
| 1148 XtPointer callData) | |
| 1149 { | |
| 1150 DtDndConvertCallbackStruct *convertInfo = | |
| 1151 (DtDndConvertCallbackStruct *) callData; | |
| 2367 | 1152 Extbyte *textdata = (Extbyte *) clientData; |
| 1153 Extbyte *textptr = NULL; | |
| 428 | 1154 int i; |
| 1155 | |
| 1156 if (convertInfo == NULL) | |
| 1157 { | |
| 1158 return; | |
| 1159 } | |
| 1160 | |
| 1161 if ((convertInfo->dragData->protocol != DtDND_BUFFER_TRANSFER | |
| 1162 && convertInfo->dragData->protocol != DtDND_FILENAME_TRANSFER) || | |
| 1163 (convertInfo->reason != DtCR_DND_CONVERT_DATA)) | |
| 1164 { | |
| 1165 return; | |
| 1166 } | |
| 1167 | |
| 2367 | 1168 for (textptr = textdata, i = 0; |
| 1169 i < convertInfo->dragData->numItems; | |
| 1170 textptr += strlen (textptr) + 1, i++) | |
| 428 | 1171 { |
| 1172 if (convertInfo->dragData->protocol == DtDND_BUFFER_TRANSFER) | |
| 1173 { | |
| 2367 | 1174 convertInfo->dragData->data.buffers[i].bp = XtNewString (textptr); |
| 1175 convertInfo->dragData->data.buffers[i].size = strlen (textptr); | |
| 428 | 1176 convertInfo->dragData->data.buffers[i].name = NULL; |
| 1177 } | |
| 1178 else | |
| 1179 { | |
| 2367 | 1180 convertInfo->dragData->data.files[i] = XtNewString (textptr); |
| 428 | 1181 } |
| 1182 } | |
| 1183 | |
| 1184 convertInfo->status = DtDND_SUCCESS; | |
| 1185 } | |
| 1186 | |
| 1187 static Lisp_Object | |
| 2367 | 1188 abort_current_drag (Lisp_Object arg) |
| 428 | 1189 { |
| 1190 if (CurrentDragWidget && drag_not_done) | |
| 1191 { | |
| 1192 XmDragCancel(CurrentDragWidget); | |
| 1193 CurrentDragWidget = NULL; | |
| 1194 } | |
| 1195 return arg; | |
| 1196 } | |
| 1197 | |
| 1198 DEFUN ("cde-start-drag-internal", Fcde_start_drag_internal, 3, 3, 0, /* | |
| 1199 Start a CDE drag from a buffer. | |
| 1200 First argument is the event that started the drag (must be a | |
| 1201 button-press-event), | |
| 1202 second arg defines if the data should be treated as a buffer or | |
| 1203 a filename transfer (set to nil for buffer transfer), | |
| 1204 and the third argument is a list of data strings. | |
| 1205 WARNING: can only handle plain/text and file: transfers! | |
| 1206 */ | |
| 1207 (event, dragtype, dragdata)) | |
| 1208 { | |
| 2367 | 1209 Extbyte *dnd_data; |
| 1210 XEvent x_event; | |
| 1211 Bytecount dnd_len; | |
| 1212 Widget wid; | |
| 1213 int num_items; | |
| 1214 | |
| 1215 dnd_data = start_drag_internal_1 (event, dragdata, Qdt_dnd_encoding, | |
| 1216 &x_event, 1, | |
| 1217 &wid, &dnd_len, &num_items); | |
| 1218 | |
| 1219 dnd_convert_cb_rec[0].callback = x_cde_convert_callback; | |
| 1220 dnd_convert_cb_rec[0].closure = (XtPointer) dnd_data; | |
| 1221 dnd_convert_cb_rec[1].callback = NULL; | |
| 1222 dnd_convert_cb_rec[1].closure = NULL; | |
| 1223 | |
| 1224 dnd_destroy_cb_rec[0].callback = x_cde_destroy_callback; | |
| 1225 dnd_destroy_cb_rec[0].closure = (XtPointer) dnd_data; | |
| 1226 dnd_destroy_cb_rec[1].callback = NULL; | |
| 1227 dnd_destroy_cb_rec[1].closure = NULL; | |
| 1228 | |
| 1229 CurrentDragWidget = | |
| 1230 DtDndDragStart (wid, &x_event, | |
| 1231 (NILP (dragtype) ? DtDND_BUFFER_TRANSFER : | |
| 1232 DtDND_FILENAME_TRANSFER), | |
| 1233 num_items, | |
| 1234 XmDROP_COPY, | |
| 1235 dnd_convert_cb_rec, | |
| 1236 dnd_destroy_cb_rec, | |
| 1237 NULL, 0); | |
| 1238 | |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
1239 xfree (dnd_data); |
| 2367 | 1240 |
| 1241 return num_items ? Qt : Qnil; | |
| 428 | 1242 } |
| 1243 | |
| 1244 static void | |
| 1245 x_cde_transfer_callback (Widget widget, XtPointer clientData, | |
| 1246 XtPointer callData) | |
| 1247 { | |
| 2367 | 1248 int ii, enqueue = 1; |
| 428 | 1249 Lisp_Object frame = Qnil; |
| 1250 Lisp_Object l_type = Qnil; | |
| 1251 Lisp_Object l_data = Qnil; | |
| 1252 DtDndTransferCallbackStruct *transferInfo = NULL; | |
| 1253 struct gcpro gcpro1, gcpro2, gcpro3; | |
| 1254 | |
| 1255 /* | |
| 1256 this needs to be changed to the new protocol: | |
| 1257 - we need the button, modifier and pointer states to create a | |
| 1258 correct misc_user_event | |
| 1259 - the data must be converted to the new format (URL/MIME) | |
| 1260 */ | |
| 1261 /* return; */ | |
| 1262 | |
| 1263 transferInfo = (DtDndTransferCallbackStruct *) callData; | |
| 1264 if (transferInfo == NULL) | |
| 1265 return; | |
| 1266 | |
| 1267 GCPRO3 (frame, l_type, l_data); | |
| 1268 | |
| 771 | 1269 frame = wrap_frame ((struct frame *) clientData); |
| 428 | 1270 |
| 1271 if (transferInfo->dropData->protocol == DtDND_FILENAME_TRANSFER) | |
| 1272 { | |
| 1273 l_type = Qdragdrop_URL; | |
| 1274 | |
| 1275 for (ii = 0; ii < transferInfo->dropData->numItems; ii++) | |
| 1276 { | |
| 2367 | 1277 Ibyte *fileint; |
| 1278 Ibyte *hurl; | |
| 1279 | |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
1280 fileint = |
|
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
1281 EXTERNAL_TO_ITEXT (transferInfo->dropData->data.files[ii], |
|
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
1282 Qfile_name); |
| 2367 | 1283 |
| 1284 hurl = dnd_url_hexify_string (fileint, "file:"); | |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1285 l_data = Fcons (build_istring (hurl), l_data); |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
1286 xfree (hurl); |
| 428 | 1287 } |
| 1288 } | |
| 1289 else if (transferInfo->dropData->protocol == DtDND_BUFFER_TRANSFER) | |
| 1290 { | |
| 2367 | 1291 int speccount = specpdl_depth (); |
| 1292 | |
| 1293 /* !!#### Problem: all buffers a treated as text/plain!!! | |
| 1294 Not appropriate for intl text. Note that there is a function | |
| 1295 DtDtsBufferToDataType(), but I don't know what the possible | |
| 1296 return values are. | |
| 1297 Solution (?): Also support DtDND_TEXT_TRANSFER (compound text) | |
| 428 | 1298 perhaps implementation of the Motif protocol |
| 1299 (which is the base of CDE) will clear this */ | |
| 1300 l_type = Qdragdrop_MIME; | |
| 2367 | 1301 record_unwind_protect (abort_current_drag, Qnil); |
| 428 | 1302 drag_not_done = 1; |
| 1303 for (ii = 0; ii < transferInfo->dropData->numItems; ii++) | |
| 1304 { | |
| 1305 /* let us forget this name thing for now... */ | |
| 1306 /* filePath = transferInfo->dropData->data.buffers[ii].name; | |
| 1307 path = (filePath == NULL) ? Qnil | |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1308 : build_extstring (filePath, Q???); */ |
| 428 | 1309 /* what, if the data is no text, and how can I tell it? */ |
| 2367 | 1310 l_data = |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
1311 Fcons (list3 (list1 (build_ascstring ("text/plain")), |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
1312 build_ascstring ("8bit"), |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1313 make_extstring |
| 2367 | 1314 (transferInfo->dropData->data.buffers[ii].bp, |
| 1315 transferInfo->dropData->data.buffers[ii].size, | |
| 1316 /* !!#### what goes here? */ | |
| 1317 Qdt_dnd_encoding)), | |
| 1318 l_data); | |
| 428 | 1319 } |
| 1320 drag_not_done = 0; | |
| 771 | 1321 unbind_to (speccount); |
| 428 | 1322 } |
| 1323 else /* the other cases: NOOP_TRANSFER */ | |
| 2367 | 1324 enqueue = 0; |
| 428 | 1325 |
| 1326 /* The Problem: no button and mods from CDE... */ | |
| 1327 if (enqueue) | |
| 2367 | 1328 enqueue_misc_user_event_pos (frame, Qdragdrop_drop_dispatch, |
| 1329 Fcons (l_type, l_data), | |
| 1330 0 /* this is the button */, | |
| 1331 0 /* these are the mods */, | |
| 1332 transferInfo->x, | |
| 1333 transferInfo->y); | |
| 428 | 1334 |
| 1335 UNGCPRO; | |
| 1336 return; | |
| 1337 } | |
| 1338 #endif /* HAVE_CDE */ | |
| 1339 | |
| 1340 | |
| 1341 /************************************************************************/ | |
| 1342 /* widget creation */ | |
| 1343 /************************************************************************/ | |
| 1344 | |
| 1345 /* The widget hierarchy is | |
| 1346 | |
| 1347 argv[0] shell container FRAME-NAME | |
| 1348 ApplicationShell EmacsShell EmacsManager EmacsFrame | |
| 1349 | |
| 1350 We accept geometry specs in this order: | |
| 1351 | |
| 1352 *FRAME-NAME.geometry | |
| 1353 *EmacsFrame.geometry | |
| 1354 Emacs.geometry | |
| 1355 | |
| 1356 Other possibilities for widget hierarchies might be | |
| 1357 | |
| 1358 argv[0] frame container FRAME-NAME | |
| 1359 ApplicationShell EmacsShell EmacsManager EmacsFrame | |
| 1360 or | |
| 1361 argv[0] FRAME-NAME container FRAME-NAME | |
| 1362 ApplicationShell EmacsShell EmacsManager EmacsFrame | |
| 1363 or | |
| 1364 argv[0] FRAME-NAME container emacsTextPane | |
| 1365 ApplicationShell EmacsShell EmacsManager EmacsFrame | |
| 1366 | |
| 1367 #ifdef EXTERNAL_WIDGET | |
| 1368 The ExternalShell widget is simply a replacement for the Shell widget | |
| 1369 which is able to deal with using an externally-supplied window instead | |
| 1370 of always creating its own. | |
| 1371 #endif | |
| 1372 | |
| 1373 */ | |
| 1374 | |
| 1375 #ifdef EXTERNAL_WIDGET | |
| 1376 | |
| 1377 static int | |
| 1378 is_valid_window (Window w, struct device *d) | |
| 1379 { | |
| 1380 XWindowAttributes xwa; | |
| 1381 Display *dpy = DEVICE_X_DISPLAY (d); | |
| 1382 | |
| 1383 expect_x_error (dpy); | |
| 1384 XGetWindowAttributes (dpy, w, &xwa); | |
| 1385 return !x_error_occurred_p (dpy); | |
| 1386 } | |
| 1387 | |
| 1388 #endif /* EXTERNAL_WIDGET */ | |
| 1389 | |
| 1390 /* This sends a synthetic mouse-motion event to the frame, if the mouse | |
| 1391 is over the frame. This ensures that the cursor gets set properly | |
| 1392 before the user moves the mouse for the first time. */ | |
| 1393 | |
| 1394 static void | |
| 2286 | 1395 x_send_synthetic_mouse_event (struct frame *UNUSED (f)) |
| 428 | 1396 { |
| 1397 /* #### write this function. */ | |
| 1398 } | |
| 1399 | |
| 1400 static int | |
| 1401 first_x_frame_p (struct frame *f) | |
| 1402 { | |
| 1403 Lisp_Object rest = DEVICE_FRAME_LIST (XDEVICE (f->device)); | |
| 1404 while (!NILP (rest) && | |
| 1405 (f == XFRAME (XCAR (rest)) || | |
| 1406 !FRAME_X_P (XFRAME (XCAR (rest))))) | |
| 1407 rest = XCDR (rest); | |
| 1408 return NILP (rest); | |
| 1409 } | |
| 1410 | |
| 1411 /* Figure out what size the EmacsFrame widget should initially be, | |
| 1412 and set it. Should be called after the default font has been | |
| 1413 determined but before the widget has been realized. */ | |
| 1414 | |
| 1415 static void | |
| 1416 x_initialize_frame_size (struct frame *f) | |
| 1417 { | |
| 1418 /* Geometry of the AppShell */ | |
| 1419 int app_flags = 0; | |
| 1420 int app_x = 0; | |
| 1421 int app_y = 0; | |
| 1422 unsigned int app_w = 0; | |
| 1423 unsigned int app_h = 0; | |
| 1424 | |
| 1425 /* Geometry of the EmacsFrame */ | |
| 1426 int frame_flags = 0; | |
| 1427 int frame_x = 0; | |
| 1428 int frame_y = 0; | |
| 1429 unsigned int frame_w = 0; | |
| 1430 unsigned int frame_h = 0; | |
| 1431 | |
| 1432 /* Hairily merged geometry */ | |
| 1433 int x = 0; | |
| 1434 int y = 0; | |
| 1435 unsigned int w = 80; | |
| 1436 unsigned int h = 40; | |
| 1437 int flags = 0; | |
| 1438 | |
| 2367 | 1439 Ascbyte *geom = 0, *ew_geom = 0; |
| 428 | 1440 Boolean iconic_p = False, ew_iconic_p = False; |
| 1441 | |
| 1442 Widget wmshell = FRAME_X_SHELL_WIDGET (f); | |
| 1443 /* #### This may not be an ApplicationShell any more, with the 'popup | |
| 1444 frame property. */ | |
| 1445 Widget app_shell = XtParent (wmshell); | |
| 1446 Widget ew = FRAME_X_TEXT_WIDGET (f); | |
| 1447 | |
| 2747 | 1448 /* set the position of the frame's root window now. When the |
| 1449 frame was created, the position was initialized to (0,0). */ | |
| 428 | 1450 { |
| 1451 struct window *win = XWINDOW (f->root_window); | |
| 1452 | |
| 5090 | 1453 WINDOW_LEFT (win) = FRAME_PANED_LEFT_EDGE (f); |
| 1454 WINDOW_TOP (win) = FRAME_PANED_TOP_EDGE (f); | |
| 428 | 1455 |
| 1456 if (!NILP (f->minibuffer_window)) | |
| 1457 { | |
| 1458 win = XWINDOW (f->minibuffer_window); | |
| 5090 | 1459 WINDOW_LEFT (win) = FRAME_PANED_LEFT_EDGE (f); |
| 428 | 1460 } |
| 1461 } | |
| 1462 | |
| 1463 #ifdef EXTERNAL_WIDGET | |
| 1464 /* If we're an external widget, then the size of the frame is predetermined | |
| 1465 (by the client) and is not our decision to make. */ | |
| 1466 if (FRAME_X_EXTERNAL_WINDOW_P (f)) | |
| 1467 return; | |
| 1468 #endif | |
| 1469 | |
| 1470 #if 0 | |
| 1471 /* #### this junk has not been tested; therefore it's | |
| 1472 probably wrong. Doesn't really matter at this point because | |
| 1473 currently all frames are either top-level or external widgets. */ | |
| 1474 | |
| 1475 /* If we're not our own top-level window, then we shouldn't go messing around | |
| 1476 with top-level shells or "Emacs.geometry" or any such stuff. Therefore, | |
| 1477 we do as follows to determine the size of the frame: | |
| 1478 | |
| 1479 1) If a value for the frame's "geometry" resource was specified, then | |
| 1480 use it. (This specifies a size in characters.) | |
| 1481 2) Else, if the "width" and "height" resources were specified, then | |
| 1482 leave them alone. (This is a value in pixels. Sorry, we can't break | |
| 1483 Xt conventions here.) | |
| 1484 3) Else, assume a size of 64x12. (This is somewhat arbitrary, but | |
| 1485 it's unlikely that a size of 80x40 is desirable because we're probably | |
| 1486 inside of a dialog box.) | |
| 1487 | |
| 1488 Set the widget's x, y, height, and width as determined. Don't set the | |
| 1489 top-level container widget, because we don't necessarily know what it | |
| 1490 is. (Assume it is smart and pays attention to our values.) | |
| 1491 */ | |
| 1492 | |
| 1493 if (!FRAME_X_TOP_LEVEL_FRAME_P (f)) | |
| 1494 { | |
| 1495 Xt_GET_VALUE (ew, XtNgeometry, &ew_geom); | |
| 1496 if (ew_geom) | |
| 1497 frame_flags = XParseGeometry (ew_geom, | |
| 1498 &frame_x, &frame_y, | |
| 1499 &frame_w, &frame_h); | |
| 1500 if (! (frame_flags & (WidthValue | HeightValue))) | |
| 1501 { | |
| 1502 Arg al[2]; | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
1503 Xt_SET_ARG (al [0], XtNwidth, &frame_w); |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
1504 Xt_SET_ARG (al [1], XtNheight, &frame_h); |
| 428 | 1505 XtGetValues (ew, al, 2); |
| 1506 if (!frame_w && !frame_h) | |
| 1507 { | |
| 1508 frame_w = 64; | |
| 1509 frame_h = 12; | |
| 1510 frame_flags |= WidthValue | HeightValue; | |
| 1511 } | |
| 1512 } | |
| 1513 if (frame_flags & (WidthValue | HeightValue)) | |
| 1514 EmacsFrameSetCharSize (ew, frame_w, frame_h); | |
| 1515 if (frame_flags & (XValue | YValue)) | |
| 1516 { | |
| 1517 Arg al[2]; | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
1518 Xt_SET_ARG (al [0], XtNwidth, &frame_w); |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
1519 Xt_SET_ARG (al [1], XtNheight, &frame_h); |
| 428 | 1520 XtGetValues (ew, al, 2); |
| 1521 | |
| 1522 if (frame_flags & XNegative) | |
| 1523 frame_x += frame_w; | |
| 1524 if (frame_flags & YNegative) | |
| 1525 frame_y += frame_h; | |
| 1526 | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
1527 Xt_SET_ARG (al [0], XtNx, frame_x); |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
1528 Xt_SET_ARG (al [1], XtNy, frame_y); |
| 428 | 1529 XtSetValues (ew, al, 2); |
| 1530 } | |
| 1531 return; | |
| 1532 } | |
| 1533 #endif | |
| 1534 | |
| 1535 /* OK, we're a top-level shell. */ | |
| 1536 | |
|
5050
6f2158fa75ed
Fix quick-build, use asserts() in place of ABORT()
Ben Wing <ben@xemacs.org>
parents:
4982
diff
changeset
|
1537 assert (XtIsWMShell (wmshell)); |
| 428 | 1538 |
| 1539 /* If the EmacsFrame doesn't have a geometry but the shell does, | |
| 1540 treat that as the geometry of the frame. | |
| 1541 (Is this bogus? I'm not sure.) */ | |
| 1542 | |
| 1543 Xt_GET_VALUE (ew, XtNgeometry, &ew_geom); | |
| 1544 if (!ew_geom) | |
| 1545 { | |
| 1546 Xt_GET_VALUE (wmshell, XtNgeometry, &geom); | |
| 1547 if (geom) | |
| 1548 { | |
| 1549 ew_geom = geom; | |
| 1550 Xt_SET_VALUE (ew, XtNgeometry, ew_geom); | |
| 1551 } | |
| 1552 } | |
| 1553 | |
| 1554 /* If the Shell is iconic, then the EmacsFrame is iconic. | |
| 1555 (Is this bogus? I'm not sure.) */ | |
| 1556 Xt_GET_VALUE (ew, XtNiconic, &ew_iconic_p); | |
| 1557 if (!ew_iconic_p) | |
| 1558 { | |
| 1559 Xt_GET_VALUE (wmshell, XtNiconic, &iconic_p); | |
| 1560 if (iconic_p) | |
| 1561 { | |
| 1562 ew_iconic_p = iconic_p; | |
| 1563 Xt_SET_VALUE (ew, XtNiconic, iconic_p); | |
| 1564 } | |
| 1565 } | |
| 1566 | |
| 1567 Xt_GET_VALUE (app_shell, XtNgeometry, &geom); | |
| 1568 if (geom) | |
| 1569 app_flags = XParseGeometry (geom, &app_x, &app_y, &app_w, &app_h); | |
| 1570 | |
| 1571 if (ew_geom) | |
| 1572 frame_flags = XParseGeometry (ew_geom, | |
| 1573 &frame_x, &frame_y, | |
| 1574 &frame_w, &frame_h); | |
| 1575 | |
| 1576 if (first_x_frame_p (f)) | |
| 1577 { | |
| 1578 /* If this is the first frame created: | |
| 1579 ==================================== | |
| 1580 | |
| 1581 - Use the ApplicationShell's size/position, if specified. | |
| 1582 (This is "Emacs.geometry", or the "-geometry" command line arg.) | |
| 1583 - Else use the EmacsFrame's size/position. | |
| 1584 (This is "*FRAME-NAME.geometry") | |
| 1585 | |
| 1586 - If the AppShell is iconic, the frame should be iconic. | |
| 1587 | |
| 1588 AppShell comes first so that -geometry always applies to the first | |
| 1589 frame created, even if there is an "every frame" entry in the | |
| 1590 resource database. | |
| 1591 */ | |
| 1592 if (app_flags & (XValue | YValue)) | |
| 1593 { | |
| 1594 x = app_x; y = app_y; | |
| 1595 flags |= (app_flags & (XValue | YValue | XNegative | YNegative)); | |
| 1596 } | |
| 1597 else if (frame_flags & (XValue | YValue)) | |
| 1598 { | |
| 1599 x = frame_x; y = frame_y; | |
| 1600 flags |= (frame_flags & (XValue | YValue | XNegative | YNegative)); | |
| 1601 } | |
| 1602 | |
| 1603 if (app_flags & (WidthValue | HeightValue)) | |
| 1604 { | |
| 1605 w = app_w; h = app_h; | |
| 1606 flags |= (app_flags & (WidthValue | HeightValue)); | |
| 1607 } | |
| 1608 else if (frame_flags & (WidthValue | HeightValue)) | |
| 1609 { | |
| 1610 w = frame_w; h = frame_h; | |
| 1611 flags |= (frame_flags & (WidthValue | HeightValue)); | |
| 1612 } | |
| 1613 | |
| 1614 /* If the AppShell is iconic, then the EmacsFrame is iconic. */ | |
| 1615 if (!ew_iconic_p) | |
| 1616 { | |
| 1617 Xt_GET_VALUE (app_shell, XtNiconic, &iconic_p); | |
| 1618 if (iconic_p) | |
| 1619 { | |
| 1620 ew_iconic_p = iconic_p; | |
| 1621 Xt_SET_VALUE (ew, XtNiconic, iconic_p); | |
| 1622 } | |
| 1623 } | |
| 1624 } | |
| 1625 else | |
| 1626 { | |
| 1627 /* If this is not the first frame created: | |
| 1628 ======================================== | |
| 1629 | |
| 1630 - use the EmacsFrame's size/position if specified | |
| 1631 - Otherwise, use the ApplicationShell's size, but not position. | |
| 1632 | |
| 1633 So that means that one can specify the position of the first frame | |
| 1634 with "Emacs.geometry" or `-geometry'; but can only specify the | |
| 1635 position of subsequent frames with "*FRAME-NAME.geometry". | |
| 1636 | |
| 1637 AppShell comes second so that -geometry does not apply to subsequent | |
| 1638 frames when there is an "every frame" entry in the resource db, | |
| 1639 but does apply to the first frame. | |
| 1640 */ | |
| 1641 if (frame_flags & (XValue | YValue)) | |
| 1642 { | |
| 1643 x = frame_x; y = frame_y; | |
| 1644 flags |= (frame_flags & (XValue | YValue | XNegative | YNegative)); | |
| 1645 } | |
| 1646 | |
| 1647 if (frame_flags & (WidthValue | HeightValue)) | |
| 1648 { | |
| 1649 w = frame_w; h = frame_h; | |
| 1650 flags |= (frame_flags & (WidthValue | HeightValue)); | |
| 1651 } | |
| 1652 else if (app_flags & (WidthValue | HeightValue)) | |
| 1653 { | |
| 1654 w = app_w; | |
| 1655 h = app_h; | |
| 1656 flags |= (app_flags & (WidthValue | HeightValue)); | |
| 1657 } | |
| 1658 } | |
| 1659 | |
| 1660 x_set_initial_frame_size (f, flags, x, y, w, h); | |
| 1661 } | |
| 1662 | |
| 1663 static void | |
| 1664 x_get_layout_sizes (struct frame *f, Dimension *topbreadth) | |
| 1665 { | |
| 1666 int i; | |
| 1667 | |
| 1668 /* compute height of all top-area widgets */ | |
| 1669 for (i=0, *topbreadth = 0; i<FRAME_X_NUM_TOP_WIDGETS (f); i++) | |
| 1670 { | |
| 1671 Widget wid = FRAME_X_TOP_WIDGETS (f)[i]; | |
| 1672 if (wid && XtIsManaged (wid)) | |
| 1673 *topbreadth += wid->core.height + 2*wid->core.border_width; | |
| 1674 } | |
| 1675 } | |
| 1676 | |
| 1677 static void | |
| 2286 | 1678 x_layout_widgets (Widget UNUSED (w), XtPointer client_data, |
| 1679 XtPointer call_data) | |
| 428 | 1680 { |
| 1681 struct frame *f = (struct frame *) client_data; | |
| 1682 EmacsManagerResizeStruct *emst = (EmacsManagerResizeStruct *) call_data; | |
| 1683 Dimension width = emst->width; | |
| 1684 Dimension height = emst->height; | |
| 1685 Widget text = FRAME_X_TEXT_WIDGET (f); | |
| 1686 Dimension textbord = text->core.border_width; | |
| 1687 Dimension topbreadth; | |
| 1688 Position text_x = 0, text_y = 0; | |
| 1689 int i; | |
| 1690 | |
| 1691 x_get_layout_sizes (f, &topbreadth); | |
| 1692 | |
| 1693 /* first the menubar and psheets ... */ | |
| 1694 for (i=0; i<FRAME_X_NUM_TOP_WIDGETS (f); i++) | |
| 1695 { | |
| 1696 Widget wid = FRAME_X_TOP_WIDGETS (f)[i]; | |
| 1697 if (wid && XtIsManaged (wid)) | |
| 1698 { | |
| 1699 Dimension bord = wid->core.border_width; | |
| 1700 XtConfigureWidget (wid, 0, text_y, | |
| 1701 width - 2*bord, wid->core.height, | |
| 1702 bord); | |
| 1703 text_y += wid->core.height + 2*bord; | |
| 1704 } | |
| 1705 } | |
| 1706 | |
| 1707 #ifdef HAVE_SCROLLBARS | |
| 1708 f->scrollbar_y_offset = topbreadth + textbord; | |
| 1709 #endif | |
| 1710 | |
| 1711 /* finally the text area */ | |
| 1712 XtConfigureWidget (text, text_x, text_y, | |
| 1713 width - 2*textbord, | |
| 1714 height - text_y - 2*textbord, | |
| 1715 textbord); | |
| 1716 } | |
| 1717 | |
| 1718 static void | |
| 2286 | 1719 x_do_query_geometry (Widget UNUSED (w), XtPointer client_data, |
| 1720 XtPointer call_data) | |
| 428 | 1721 { |
| 1722 struct frame *f = (struct frame *) client_data; | |
| 1723 EmacsManagerQueryGeometryStruct *emst = | |
| 1724 (EmacsManagerQueryGeometryStruct *) call_data; | |
| 1725 Widget text = FRAME_X_TEXT_WIDGET (f); | |
| 1726 Dimension textbord = text->core.border_width; | |
| 1727 Dimension topbreadth; | |
| 1728 XtWidgetGeometry req, repl; | |
| 1729 int mask = emst->request_mode & (CWWidth | CWHeight); | |
| 1730 | |
| 1731 x_get_layout_sizes (f, &topbreadth); | |
| 1732 | |
| 1733 /* Strip away menubar from suggested size, and ask the text widget | |
| 1734 what size it wants to be. */ | |
| 1735 req.request_mode = mask; | |
| 1736 if (mask & CWWidth) | |
| 1737 req.width = emst->proposed_width - 2*textbord; | |
| 1738 if (mask & CWHeight) | |
| 1739 req.height = emst->proposed_height - topbreadth - 2*textbord; | |
| 1740 XtQueryGeometry (text, &req, &repl); | |
| 1741 | |
| 1742 /* Now add the menubar back again */ | |
| 1743 emst->proposed_width = repl.width + 2*textbord; | |
| 1744 emst->proposed_height = repl.height + topbreadth + 2*textbord; | |
| 1745 } | |
| 1746 | |
| 1747 /* Creates the widgets for a frame. | |
| 1748 lisp_window_id is a Lisp description of an X window or Xt | |
| 1749 widget to parse. | |
| 2747 | 1750 parent is a frame to use as the parent. |
| 1751 overridep if non-nil says to set the override-redirect setting. | |
| 428 | 1752 |
| 1753 This function does not create or map the windows. (That is | |
| 1754 done by x_popup_frame().) | |
| 1755 */ | |
| 1756 static void | |
| 1757 x_create_widgets (struct frame *f, Lisp_Object lisp_window_id, | |
| 2747 | 1758 Lisp_Object parent, Lisp_Object overridep) |
| 428 | 1759 { |
| 1760 struct device *d = XDEVICE (f->device); | |
| 1761 Visual *visual = DEVICE_X_VISUAL (d); | |
| 1762 int depth = DEVICE_X_DEPTH (d); | |
| 1763 Colormap cmap = DEVICE_X_COLORMAP (d); | |
| 1764 #ifdef EXTERNAL_WIDGET | |
| 1765 Window window_id = 0; | |
| 1766 #endif | |
| 2367 | 1767 const Extbyte *name; |
| 1768 Arg al[25]; | |
| 428 | 1769 int ac = 0; |
| 1770 Widget text, container, shell; | |
| 1771 Widget parentwid = 0; | |
| 1772 #ifdef HAVE_MENUBARS | |
| 1773 int menubar_visible; | |
| 1774 Widget menubar; | |
| 1775 #endif | |
| 1776 | |
| 1777 if (STRINGP (f->name)) | |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
1778 name = LISP_STRING_TO_EXTERNAL (f->name, Qctext); |
| 428 | 1779 else |
| 1780 name = "emacs"; | |
| 1781 | |
| 1782 /* The widget hierarchy is | |
| 1783 | |
| 1784 argv[0] shell pane FRAME-NAME | |
| 1785 ApplicationShell EmacsShell EmacsManager EmacsFrame | |
| 1786 | |
| 1787 (the type of the shell is ExternalShell if this frame is running | |
| 1788 in another client's window) | |
| 1789 | |
| 1790 However the EmacsShell widget has WM_CLASS of FRAME-NAME/Emacs. | |
| 1791 Normally such shells have name/class shellname/appclass, which in this | |
| 1792 case would be "shell/Emacs" instead of "frame-name/Emacs". We could | |
| 1793 also get around this by naming the shell "frame-name", but that would | |
| 1794 be confusing because the text area (the EmacsFrame widget inferior of | |
| 1795 the shell) is also called that. So we just set the WM_CLASS property. | |
| 1796 */ | |
| 1797 | |
| 1798 #ifndef EXTERNAL_WIDGET | |
| 1799 if (!NILP (lisp_window_id)) | |
| 2367 | 1800 signal_error |
| 1801 (Qunimplemented, | |
| 1802 "support for external widgets was not enabled at compile-time", | |
| 1803 Qunbound); | |
| 428 | 1804 #else |
| 1805 if (!NILP (lisp_window_id)) | |
| 1806 { | |
| 2367 | 1807 Ibyte *string; |
| 428 | 1808 |
| 1809 CHECK_STRING (lisp_window_id); | |
| 2367 | 1810 string = XSTRING_DATA (lisp_window_id); |
| 428 | 1811 if (string[0] == '0' && (string[1] == 'x' || string[1] == 'X')) |
| 2367 | 1812 qxesscanf_ascii_1 (string + 2, "%lxu", &window_id); |
| 428 | 1813 #if 0 |
| 1814 else if (string[0] == 'w') | |
| 1815 { | |
| 2367 | 1816 qxesscanf_ascii (string + 1, "%x", &parent_widget); |
| 428 | 1817 if (parent_widget) |
| 1818 window_id = XtWindow (parent_widget); | |
| 1819 } | |
| 1820 #endif | |
| 1821 else | |
| 2367 | 1822 qxesscanf_ascii_1 (string, "%lu", &window_id); |
| 428 | 1823 if (!is_valid_window (window_id, d)) |
| 563 | 1824 signal_ferror (Qinvalid_argument, "Invalid window %lu", |
| 1825 (unsigned long) window_id); | |
| 428 | 1826 FRAME_X_EXTERNAL_WINDOW_P (f) = 1; |
| 1827 } else | |
| 1828 #endif /* EXTERNAL_WIDGET */ | |
| 1829 FRAME_X_TOP_LEVEL_FRAME_P (f) = 1; | |
| 1830 | |
| 1831 ac = 0; | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
1832 Xt_SET_ARG (al[ac], XtNallowShellResize, True); ac++; |
| 428 | 1833 #ifdef LWLIB_USES_MOTIF |
| 1834 /* Motif sucks beans. Without this in here, it will delete the window | |
| 1835 out from under us when it receives a WM_DESTROY_WINDOW message | |
| 1836 from the WM. */ | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
1837 Xt_SET_ARG (al[ac], XmNdeleteResponse, XmDO_NOTHING); ac++; |
| 428 | 1838 #endif |
| 1839 | |
| 1840 #ifdef EXTERNAL_WIDGET | |
| 1841 if (window_id) | |
| 1842 { | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
1843 Xt_SET_ARG (al[ac], XtNwindow, window_id); ac++; |
| 428 | 1844 } |
| 1845 else | |
| 1846 #endif /* EXTERNAL_WIDGET */ | |
| 1847 { | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
1848 Xt_SET_ARG (al[ac], XtNinput, True); ac++; |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
1849 Xt_SET_ARG (al[ac], XtNminWidthCells, 10); ac++; |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
1850 Xt_SET_ARG (al[ac], XtNminHeightCells, 1); ac++; |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
1851 Xt_SET_ARG (al[ac], XtNvisual, visual); ac++; |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
1852 Xt_SET_ARG (al[ac], XtNdepth, depth); ac++; |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
1853 Xt_SET_ARG (al[ac], XtNcolormap, cmap); ac++; |
| 428 | 1854 } |
| 1855 | |
| 2747 | 1856 if (!NILP (overridep)) |
| 1857 { | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
1858 Xt_SET_ARG (al[ac], XtNoverrideRedirect, True); ac++; |
| 2747 | 1859 } |
| 1860 | |
| 1861 /* #### maybe we should check for FRAMEP instead? */ | |
| 428 | 1862 if (!NILP (parent)) |
| 1863 { | |
| 1864 parentwid = FRAME_X_SHELL_WIDGET (XFRAME (parent)); | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
1865 Xt_SET_ARG (al[ac], XtNtransientFor, parentwid); ac++; |
| 428 | 1866 } |
| 1867 | |
| 1868 shell = XtCreatePopupShell ("shell", | |
| 1869 ( | |
| 1870 #ifdef EXTERNAL_WIDGET | |
| 1871 window_id ? externalShellWidgetClass : | |
| 1872 #endif | |
| 1873 parentwid ? transientEmacsShellWidgetClass : | |
| 1874 topLevelEmacsShellWidgetClass | |
| 1875 ), | |
| 1876 parentwid ? parentwid : | |
| 1877 DEVICE_XT_APP_SHELL (d), | |
| 1878 al, ac); | |
| 1879 FRAME_X_SHELL_WIDGET (f) = shell; | |
| 1880 maybe_set_frame_title_format (shell); | |
| 1881 | |
| 1882 /* Create the manager widget */ | |
| 1883 ac = 0; | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
1884 Xt_SET_ARG (al[ac], XtNvisual, visual); ac++; |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
1885 Xt_SET_ARG (al[ac], XtNdepth, depth); ac++; |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
1886 Xt_SET_ARG (al[ac], XtNcolormap, cmap); ac++; |
| 428 | 1887 |
| 1888 container = XtCreateWidget ("container", | |
| 1889 emacsManagerWidgetClass, shell, al, ac); | |
| 1890 FRAME_X_CONTAINER_WIDGET (f) = container; | |
| 1891 XtAddCallback (container, XtNresizeCallback, x_layout_widgets, | |
| 1892 (XtPointer) f); | |
| 1893 XtAddCallback (container, XtNqueryGeometryCallback, x_do_query_geometry, | |
| 1894 (XtPointer) f); | |
| 1895 | |
| 1896 /* Create the text area */ | |
| 1897 ac = 0; | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
1898 Xt_SET_ARG (al[ac], XtNvisual, visual); ac++; |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
1899 Xt_SET_ARG (al[ac], XtNdepth, depth); ac++; |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
1900 Xt_SET_ARG (al[ac], XtNcolormap, cmap); ac++; |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
1901 Xt_SET_ARG (al[ac], XtNborderWidth, 0); ac++; /* should this be settable? */ |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
1902 Xt_SET_ARG (al[ac], XtNemacsFrame, f); ac++; |
| 428 | 1903 text = XtCreateWidget (name, emacsFrameClass, container, al, ac); |
| 1904 FRAME_X_TEXT_WIDGET (f) = text; | |
| 1905 | |
| 1906 #ifdef HAVE_MENUBARS | |
| 1907 /* Create the initial menubar widget. */ | |
| 1908 menubar_visible = x_initialize_frame_menubar (f); | |
| 1909 FRAME_X_TOP_WIDGETS (f)[0] = menubar = FRAME_X_MENUBAR_WIDGET (f); | |
| 1910 FRAME_X_NUM_TOP_WIDGETS (f) = 1; | |
| 1911 | |
| 1912 if (menubar_visible) | |
| 1913 XtManageChild (menubar); | |
| 1914 #endif /* HAVE_MENUBARS */ | |
| 1915 XtManageChild (text); | |
| 1916 XtManageChild (container); | |
| 1917 } | |
| 1918 | |
| 1919 /* We used to call XtPopup() in x_popup_frame, but that doesn't give | |
| 1920 you control over whether the widget is initially mapped or not | |
| 1921 because XtPopup() makes an unconditional call to XMapRaised(). | |
| 1922 Boy, those Xt designers were clever. | |
| 1923 | |
| 1924 When we first removed it we only kept the XtRealizeWidget call in | |
| 1925 XtPopup. For everything except HP's that was enough. For HP's, | |
| 1926 though, the failure to call the popup callbacks resulted in XEmacs | |
| 1927 not accepting any input. Bizarre but true. Stupid but true. | |
| 1928 | |
| 1929 So, in case there are any other gotchas floating out there along | |
| 1930 the same lines I've duplicated the majority of XtPopup here. It | |
| 1931 assumes no grabs and that the widget is not already popped up, both | |
| 1932 valid assumptions for the one place this is called from. */ | |
| 1933 static void | |
| 1934 xemacs_XtPopup (Widget widget) | |
| 1935 { | |
| 1936 ShellWidget shell_widget = (ShellWidget) widget; | |
| 1937 XtGrabKind call_data = XtGrabNone; | |
| 1938 | |
| 2367 | 1939 XtCallCallbacks (widget, XtNpopupCallback, (XtPointer) &call_data); |
| 428 | 1940 |
| 1941 shell_widget->shell.popped_up = TRUE; | |
| 1942 shell_widget->shell.grab_kind = XtGrabNone; | |
| 1943 shell_widget->shell.spring_loaded = False; | |
| 1944 | |
| 1945 if (shell_widget->shell.create_popup_child_proc != NULL) | |
| 2367 | 1946 (*(shell_widget->shell.create_popup_child_proc)) (widget); |
| 428 | 1947 |
| 1948 /* The XtSetValues below are not in XtPopup menu. We just want to | |
| 1949 make absolutely sure... */ | |
| 1950 Xt_SET_VALUE (widget, XtNmappedWhenManaged, False); | |
| 1951 XtRealizeWidget (widget); | |
| 1952 Xt_SET_VALUE (widget, XtNmappedWhenManaged, True); | |
| 1953 } | |
| 1954 | |
| 1955 /* create the windows for the specified frame and display them. | |
| 1956 Note that the widgets have already been created, and any | |
| 1957 necessary geometry calculations have already been done. */ | |
| 1958 static void | |
| 1959 x_popup_frame (struct frame *f) | |
| 1960 { | |
| 1961 Widget shell_widget = FRAME_X_SHELL_WIDGET (f); | |
| 1962 Widget frame_widget = FRAME_X_TEXT_WIDGET (f); | |
| 1963 struct device *d = XDEVICE (FRAME_DEVICE (f)); | |
| 1964 | |
| 1965 /* Before mapping the window, make sure that the WMShell's notion of | |
| 1966 whether it should be iconified is synchronized with the EmacsFrame's | |
| 1967 notion. | |
| 1968 */ | |
| 1969 if (FRAME_X_TOP_LEVEL_FRAME_P (f)) | |
| 1970 x_wm_set_shell_iconic_p (shell_widget, | |
| 1971 ((EmacsFrame) frame_widget) | |
| 1972 ->emacs_frame.iconic); | |
| 1973 | |
| 1974 xemacs_XtPopup (shell_widget); | |
| 1975 | |
| 1976 if (!((EmacsFrame) frame_widget)->emacs_frame.initially_unmapped) | |
| 1977 XtMapWidget (shell_widget); | |
| 1978 else | |
| 1979 { | |
| 1980 /* We may have set f->visible to 1 in x_init_frame(), so undo | |
| 1981 that now. */ | |
| 1982 FRAME_X_TOTALLY_VISIBLE_P (f) = 0; | |
| 1983 f->visible = 0; | |
| 1984 } | |
| 1985 | |
| 1986 #ifdef EXTERNAL_WIDGET | |
| 1987 if (FRAME_X_EXTERNAL_WINDOW_P (f)) | |
| 1988 ExternalShellReady (shell_widget, XtWindow (frame_widget), KeyPressMask); | |
| 1989 else | |
| 1990 #endif | |
| 1991 if (FRAME_X_TOP_LEVEL_FRAME_P (f)) | |
| 1992 { | |
| 1993 /* tell the window manager about us. */ | |
| 1994 x_wm_store_class_hints (shell_widget, XtName (frame_widget)); | |
| 1995 | |
| 1996 #ifndef HAVE_WMCOMMAND | |
| 1997 x_wm_maybe_store_wm_command (f); | |
| 1998 #endif /* HAVE_WMCOMMAND */ | |
| 1999 | |
| 2000 x_wm_hack_wm_protocols (shell_widget); | |
| 2001 } | |
| 2002 | |
| 2003 #ifdef HAVE_XIM | |
| 2004 XIM_init_frame (f); | |
| 2005 #endif /* HAVE_XIM */ | |
| 2006 | |
| 2007 /* Allow XEmacs to respond to EditRes requests. See the O'Reilly Xt */ | |
| 2008 /* Intrinsics Programming Manual, Motif Edition, Aug 1993, Sect 14.14, */ | |
| 2009 /* pp. 483-493. */ | |
| 2010 XtAddEventHandler (shell_widget, /* the shell widget in question */ | |
| 2011 (EventMask) NoEventMask,/* OR with existing mask */ | |
| 2012 True, /* called on non-maskable events? */ | |
| 2013 (XtEventHandler) _XEditResCheckMessages, /* the handler */ | |
| 2014 NULL); | |
| 2015 | |
| 2016 #ifdef HAVE_CDE | |
| 2017 { | |
| 2018 XtCallbackRec dnd_transfer_cb_rec[2]; | |
| 2019 | |
| 2020 dnd_transfer_cb_rec[0].callback = x_cde_transfer_callback; | |
| 2021 dnd_transfer_cb_rec[0].closure = (XtPointer) f; | |
| 2022 dnd_transfer_cb_rec[1].callback = NULL; | |
| 2023 dnd_transfer_cb_rec[1].closure = NULL; | |
| 2024 | |
| 2025 DtDndVaDropRegister (FRAME_X_TEXT_WIDGET (f), | |
| 2026 DtDND_FILENAME_TRANSFER | DtDND_BUFFER_TRANSFER, | |
| 2027 XmDROP_COPY, dnd_transfer_cb_rec, | |
| 2028 DtNtextIsBuffer, True, | |
| 2029 DtNregisterChildren, True, | |
| 2030 DtNpreserveRegistration, False, | |
| 2031 NULL); | |
| 2032 } | |
| 2033 #endif /* HAVE_CDE */ | |
| 2034 | |
| 2035 /* Do a stupid property change to force the server to generate a | |
| 2036 propertyNotify event so that the event_stream server timestamp will | |
| 2037 be initialized to something relevant to the time we created the window. | |
| 2038 */ | |
| 2039 XChangeProperty (XtDisplay (frame_widget), XtWindow (frame_widget), | |
| 2040 DEVICE_XATOM_WM_PROTOCOLS (d), XA_ATOM, 32, PropModeAppend, | |
| 2367 | 2041 (Rawbyte *) NULL, 0); |
| 428 | 2042 |
| 2043 x_send_synthetic_mouse_event (f); | |
| 2044 } | |
| 2045 | |
| 2046 static void | |
| 2047 allocate_x_frame_struct (struct frame *f) | |
| 2048 { | |
| 2049 /* zero out all slots. */ | |
| 3092 | 2050 #ifdef NEW_GC |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
2051 f->frame_data = XX_FRAME (ALLOC_NORMAL_LISP_OBJECT (x_frame)); |
| 3092 | 2052 #else /* not NEW_GC */ |
| 428 | 2053 f->frame_data = xnew_and_zero (struct x_frame); |
| 3092 | 2054 #endif /* not NEW_GC */ |
| 428 | 2055 |
| 2056 /* yeah, except the lisp ones */ | |
| 1346 | 2057 FRAME_X_LAST_MENUBAR_BUFFER (f) = Qnil; |
| 428 | 2058 FRAME_X_ICON_PIXMAP (f) = Qnil; |
| 2059 FRAME_X_ICON_PIXMAP_MASK (f) = Qnil; | |
| 2060 } | |
| 2061 | |
| 2062 | |
| 2063 /************************************************************************/ | |
| 2064 /* Lisp functions */ | |
| 2065 /************************************************************************/ | |
| 2066 | |
| 2067 static void | |
| 771 | 2068 x_init_frame_1 (struct frame *f, Lisp_Object props, |
| 2286 | 2069 int UNUSED (frame_name_is_defaulted)) |
| 428 | 2070 { |
| 2071 /* This function can GC */ | |
| 2072 Lisp_Object device = FRAME_DEVICE (f); | |
| 2073 Lisp_Object lisp_window_id = Fplist_get (props, Qwindow_id, Qnil); | |
| 2074 Lisp_Object popup = Fplist_get (props, Qpopup, Qnil); | |
| 2747 | 2075 Lisp_Object overridep = Fplist_get (props, Qoverride_redirect, Qnil); |
| 428 | 2076 |
| 2077 if (!NILP (popup)) | |
| 2078 { | |
| 2079 if (EQ (popup, Qt)) | |
| 2080 popup = Fselected_frame (device); | |
| 2081 CHECK_LIVE_FRAME (popup); | |
| 2082 if (!EQ (device, FRAME_DEVICE (XFRAME (popup)))) | |
| 563 | 2083 invalid_argument_2 ("Parent must be on same device as frame", |
| 2084 device, popup); | |
| 428 | 2085 } |
| 2086 | |
| 2087 /* | |
| 2088 * Previously we set this only if NILP (DEVICE_SELECTED_FRAME (d)) | |
| 2089 * to make sure that messages were displayed as soon as possible | |
| 2090 * if we're creating the first frame on a device. But it is | |
| 2091 * better to just set this all the time, so that when a new frame | |
| 2092 * is created that covers the selected frame, echo area status | |
| 2093 * messages can still be seen. f->visible is reset later if the | |
| 2094 * initially-unmapped property is found to be non-nil in the | |
| 2095 * frame properties. | |
| 2096 */ | |
| 2097 f->visible = 1; | |
| 2098 | |
| 2099 allocate_x_frame_struct (f); | |
| 2747 | 2100 x_create_widgets (f, lisp_window_id, popup, overridep); |
| 428 | 2101 } |
| 2102 | |
| 2103 static void | |
| 2286 | 2104 x_init_frame_2 (struct frame *f, Lisp_Object UNUSED (props)) |
| 428 | 2105 { |
| 2106 /* Set up the values of the widget/frame. A case could be made for putting | |
| 2107 this inside of the widget's initialize method. */ | |
| 2108 | |
| 2109 update_frame_face_values (f); | |
| 2110 x_initialize_frame_size (f); | |
| 2111 /* Kyle: | |
| 2112 * update_frame_title() can't be done here, because some of the | |
| 2113 * modeline specs depend on the frame's device having a selected | |
| 2114 * frame, and that may not have been set up yet. The redisplay | |
| 2115 * will update the frame title anyway, so nothing is lost. | |
| 2116 * JV: | |
| 2117 * It turns out it gives problems with FVWMs name based mapping. | |
| 2118 * We'll just need to be careful in the modeline specs. | |
| 2119 */ | |
| 2120 update_frame_title (f); | |
|
4593
3623446b34bc
Set icon resource on frame early enough for openbox to find it.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4528
diff
changeset
|
2121 /* Henry S. Thompson: |
|
3623446b34bc
Set icon resource on frame early enough for openbox to find it.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4528
diff
changeset
|
2122 * Must set icon resource before mapping frame, or some WMs may |
|
3623446b34bc
Set icon resource on frame early enough for openbox to find it.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4528
diff
changeset
|
2123 * lose the icon (openbox). See <f5bhc3efb17@hildegard.inf.ed.ac.uk>. |
|
3623446b34bc
Set icon resource on frame early enough for openbox to find it.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4528
diff
changeset
|
2124 * SJT: |
|
3623446b34bc
Set icon resource on frame early enough for openbox to find it.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4528
diff
changeset
|
2125 * This probably means that the frame-icon library won't work with |
| 4594 | 2126 * that WM. Late breaking news: it *does* work, so possibly the |
| 2127 * problem at initialization is due to a race condition. | |
|
4593
3623446b34bc
Set icon resource on frame early enough for openbox to find it.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4528
diff
changeset
|
2128 */ |
|
3623446b34bc
Set icon resource on frame early enough for openbox to find it.
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4528
diff
changeset
|
2129 update_frame_icon (f); |
| 428 | 2130 } |
| 2131 | |
| 2132 static void | |
| 2133 x_init_frame_3 (struct frame *f) | |
| 2134 { | |
|
5080
5502045ec510
The background-placement face property.
Didier Verna <didier@lrde.epita.fr>
parents:
5050
diff
changeset
|
2135 /* #### NOTE: This whole business of splitting frame initialization into |
|
5502045ec510
The background-placement face property.
Didier Verna <didier@lrde.epita.fr>
parents:
5050
diff
changeset
|
2136 #### different functions is somewhat messy. The latest one seems a good |
|
5502045ec510
The background-placement face property.
Didier Verna <didier@lrde.epita.fr>
parents:
5050
diff
changeset
|
2137 #### place to initialize the edit widget's position because we're sure |
|
5502045ec510
The background-placement face property.
Didier Verna <didier@lrde.epita.fr>
parents:
5050
diff
changeset
|
2138 #### that the frame is now relalized. -- dvl */ |
|
5502045ec510
The background-placement face property.
Didier Verna <didier@lrde.epita.fr>
parents:
5050
diff
changeset
|
2139 |
| 428 | 2140 x_popup_frame (f); |
|
5080
5502045ec510
The background-placement face property.
Didier Verna <didier@lrde.epita.fr>
parents:
5050
diff
changeset
|
2141 x_get_frame_text_position (f); |
| 428 | 2142 } |
| 2143 | |
| 2144 static void | |
| 2145 x_mark_frame (struct frame *f) | |
| 2146 { | |
| 1346 | 2147 mark_object (FRAME_X_LAST_MENUBAR_BUFFER (f)); |
| 428 | 2148 mark_object (FRAME_X_ICON_PIXMAP (f)); |
| 2149 mark_object (FRAME_X_ICON_PIXMAP_MASK (f)); | |
| 2150 } | |
| 2151 | |
| 2152 static void | |
| 2153 x_set_frame_icon (struct frame *f) | |
| 2154 { | |
| 2155 Pixmap x_pixmap, x_mask; | |
| 2156 | |
| 2157 if (IMAGE_INSTANCEP (f->icon) | |
| 2158 && IMAGE_INSTANCE_PIXMAP_TYPE_P (XIMAGE_INSTANCE (f->icon))) | |
| 2159 { | |
| 2160 x_pixmap = XIMAGE_INSTANCE_X_PIXMAP (f->icon); | |
| 2161 x_mask = XIMAGE_INSTANCE_X_MASK (f->icon); | |
| 2162 } | |
| 2163 else | |
| 2164 { | |
| 2165 x_pixmap = 0; | |
| 2166 x_mask = 0; | |
| 2167 } | |
| 2168 | |
| 2169 /* Store the X data into the widget. */ | |
| 2170 { | |
| 2367 | 2171 Arg al[2]; |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
2172 Xt_SET_ARG (al[0], XtNiconPixmap, x_pixmap); |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
2173 Xt_SET_ARG (al[1], XtNiconMask, x_mask); |
| 428 | 2174 XtSetValues (FRAME_X_SHELL_WIDGET (f), al, 2); |
| 2175 } | |
| 2176 } | |
| 2177 | |
| 2178 static void | |
| 2179 x_set_frame_pointer (struct frame *f) | |
| 2180 { | |
| 2181 XDefineCursor (XtDisplay (FRAME_X_TEXT_WIDGET (f)), | |
| 2182 XtWindow (FRAME_X_TEXT_WIDGET (f)), | |
| 2183 XIMAGE_INSTANCE_X_CURSOR (f->pointer)); | |
| 2184 XSync (XtDisplay (FRAME_X_TEXT_WIDGET (f)), 0); | |
| 2185 } | |
| 2186 | |
| 2187 static Lisp_Object | |
| 2188 x_get_frame_parent (struct frame *f) | |
| 2189 { | |
| 2190 Widget parentwid = 0; | |
| 2191 | |
| 2192 Xt_GET_VALUE (FRAME_X_SHELL_WIDGET (f), XtNtransientFor, &parentwid); | |
| 2193 /* find the frame whose wid is parentwid */ | |
| 2194 if (parentwid) | |
| 2195 { | |
| 2196 Lisp_Object frmcons; | |
| 2197 DEVICE_FRAME_LOOP (frmcons, XDEVICE (FRAME_DEVICE (f))) | |
| 2198 { | |
| 2199 Lisp_Object frame = XCAR (frmcons); | |
| 2200 if (FRAME_X_SHELL_WIDGET (XFRAME (frame)) == parentwid) | |
| 2201 return frame; | |
| 2202 } | |
| 2203 } | |
| 2204 return Qnil; | |
| 2205 } | |
| 2206 | |
| 2207 DEFUN ("x-window-id", Fx_window_id, 0, 1, 0, /* | |
| 2208 Get the ID of the X11 window. | |
| 2209 This gives us a chance to manipulate the Emacs window from within a | |
| 2210 different program. Since the ID is an unsigned long, we return it as | |
| 2211 a string. | |
| 2212 */ | |
| 2213 (frame)) | |
| 2214 { | |
| 867 | 2215 Ibyte str[255]; |
| 428 | 2216 struct frame *f = decode_x_frame (frame); |
| 2217 | |
| 771 | 2218 qxesprintf (str, "%lu", XtWindow (FRAME_X_TEXT_WIDGET (f))); |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
2219 return build_istring (str); |
| 428 | 2220 } |
| 2221 | |
| 2222 | |
| 2223 /************************************************************************/ | |
| 2224 /* manipulating the X window */ | |
| 2225 /************************************************************************/ | |
| 2226 | |
| 2227 static void | |
| 2228 x_set_frame_position (struct frame *f, int xoff, int yoff) | |
| 2229 { | |
| 2230 Widget w = FRAME_X_SHELL_WIDGET (f); | |
| 2231 Display *dpy = XtDisplay (w); | |
| 2232 Dimension frame_w = DisplayWidth (dpy, DefaultScreen (dpy)); | |
| 2233 Dimension frame_h = DisplayHeight (dpy, DefaultScreen (dpy)); | |
| 2234 Dimension shell_w, shell_h, shell_bord; | |
| 2235 int win_gravity; | |
| 2367 | 2236 Arg al[3]; |
| 2237 | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
2238 Xt_SET_ARG (al[0], XtNwidth, &shell_w); |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
2239 Xt_SET_ARG (al[1], XtNheight, &shell_h); |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
2240 Xt_SET_ARG (al[2], XtNborderWidth, &shell_bord); |
| 428 | 2241 XtGetValues (w, al, 3); |
| 2242 | |
| 2243 win_gravity = | |
| 2244 xoff >= 0 && yoff >= 0 ? NorthWestGravity : | |
| 2245 xoff >= 0 ? SouthWestGravity : | |
| 2246 yoff >= 0 ? NorthEastGravity : | |
| 2247 SouthEastGravity; | |
| 2248 if (xoff < 0) | |
| 2249 xoff += frame_w - shell_w - 2*shell_bord; | |
| 2250 if (yoff < 0) | |
| 2251 yoff += frame_h - shell_h - 2*shell_bord; | |
| 2252 | |
| 2253 /* Update the hints so that, if this window is currently iconified, it will | |
| 2254 come back at the right place. We can't look at s->visible to determine | |
| 2255 whether it is iconified because it might not be up-to-date yet (the queue | |
| 2256 might not be processed). */ | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
2257 Xt_SET_ARG (al[0], XtNwinGravity, win_gravity); |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
2258 Xt_SET_ARG (al[1], XtNx, xoff); |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
2259 Xt_SET_ARG (al[2], XtNy, yoff); |
| 428 | 2260 XtSetValues (w, al, 3); |
| 2261 | |
| 2262 /* Sometimes you will find that | |
| 2263 | |
| 2264 (set-frame-position (selected-frame) -50 -50) | |
| 2265 | |
| 2266 doesn't put the frame where you expect it to: i.e. it's closer to | |
| 2267 the lower-right corner than it should be, and it appears that the | |
| 2268 size of the WM decorations was not taken into account. This is | |
| 2269 *not* a problem with this function. Both mwm and twm have bugs | |
| 2270 in handling this situation. (mwm ignores the window gravity and | |
| 2271 always assumes NorthWest, except the first time you map the | |
| 2272 window; twm gets things almost right, but forgets to account for | |
| 2273 the border width of the top-level window.) This function does | |
| 2274 what it's supposed to according to the ICCCM, and I'm not about | |
| 2275 to hack around window-manager bugs. */ | |
| 2276 | |
| 2277 #if 0 | |
| 2278 /* This is not necessary under either mwm or twm */ | |
| 2279 x_wm_mark_shell_position_user_specified (w); | |
| 2280 #endif | |
| 2281 } | |
| 2282 | |
| 2283 /* Call this to change the size of frame S's x-window. */ | |
| 2284 | |
| 2285 static void | |
| 2286 x_set_frame_size (struct frame *f, int cols, int rows) | |
| 2287 { | |
| 2288 EmacsFrameSetCharSize (FRAME_X_TEXT_WIDGET (f), cols, rows); | |
| 3381 | 2289 |
| 2290 if (!wedge_metacity) /* cf. EmacsFrameResize */ | |
| 2291 { | |
| 2292 /* Kick the manager so that it knows we've changed size. */ | |
| 2293 XtWidgetGeometry req, repl; | |
| 2294 req.request_mode = 0; | |
| 2295 XtQueryGeometry (FRAME_X_CONTAINER_WIDGET (f), &req, &repl); | |
| 2296 EmacsManagerChangeSize (FRAME_X_CONTAINER_WIDGET (f), | |
| 2297 repl.width, repl.height); | |
| 2298 } | |
| 2299 | |
| 428 | 2300 #if 0 |
| 2301 /* this is not correct. x_set_frame_size() is called from | |
| 2302 Fset_frame_size(), which may or may not have been called | |
| 2303 by the user (e.g. update_EmacsFrame() calls it when the font | |
| 2304 changes). For now, don't bother with getting this right. */ | |
| 2305 x_wm_mark_shell_size_user_specified (FRAME_X_SHELL_WIDGET (f)); | |
| 2306 #endif | |
| 2307 } | |
| 2308 | |
| 2309 static void | |
| 2310 x_set_mouse_position (struct window *w, int x, int y) | |
| 2311 { | |
| 2312 struct frame *f = XFRAME (w->frame); | |
| 2313 | |
| 2314 Display *display = DEVICE_X_DISPLAY (XDEVICE (f->device)); | |
| 2315 XWarpPointer (display, None, XtWindow (FRAME_X_TEXT_WIDGET (f)), | |
| 2316 0, 0, 0, 0, w->pixel_left + x, w->pixel_top + y); | |
| 2317 } | |
| 2318 | |
| 2319 static int | |
| 2320 x_get_mouse_position (struct device *d, Lisp_Object *frame, int *x, int *y) | |
| 2321 { | |
| 2322 Display *display = DEVICE_X_DISPLAY (d); | |
| 2323 Window child_window; | |
| 2324 Window root_window; | |
| 2325 Window win; | |
| 2326 int root_x, root_y; | |
| 2327 int win_x, win_y; | |
| 2328 unsigned int keys_and_buttons; | |
| 2329 struct frame *f; | |
| 2330 | |
| 2331 if (XQueryPointer (display, RootWindow (display, DefaultScreen (display)), | |
| 2332 &root_window, &child_window, &root_x, &root_y, | |
| 2333 &win_x, &win_y, &keys_and_buttons) == False) | |
| 2334 return 0; | |
| 2335 | |
| 2336 if (child_window == None) | |
| 2337 return 0; /* not over any window. */ | |
| 2338 | |
| 2339 while (1) | |
| 2340 { | |
| 2341 win = child_window; | |
| 2342 if (XTranslateCoordinates (display, root_window, win, root_x, root_y, | |
| 2343 &win_x, &win_y, &child_window) == False) | |
| 2344 /* Huh? */ | |
| 2345 return 0; | |
| 2346 | |
| 2347 if (child_window == None) | |
| 2348 break; | |
| 2349 } | |
| 2350 | |
| 2351 /* At this point, win is the innermost window containing the pointer | |
| 2352 and win_x and win_y are the coordinates of that window. */ | |
| 2353 f = x_any_window_to_frame (d, win); | |
| 2354 if (!f) | |
| 2355 return 0; | |
| 793 | 2356 *frame = wrap_frame (f); |
| 428 | 2357 |
| 2358 if (XTranslateCoordinates (display, win, | |
| 2359 XtWindow (FRAME_X_TEXT_WIDGET (f)), | |
| 2360 win_x, win_y, x, y, &child_window) == False) | |
| 2361 /* Huh? */ | |
| 2362 return 0; | |
| 2363 | |
| 2364 return 1; | |
| 2365 } | |
| 2366 | |
| 2268 | 2367 static DECLARE_DOESNT_RETURN (x_cant_notify_wm_error (void)); |
| 2368 | |
| 2369 static DOESNT_RETURN | |
| 2370 x_cant_notify_wm_error () | |
| 428 | 2371 { |
| 563 | 2372 signal_error (Qgui_error, "Can't notify window manager of iconification", Qunbound); |
| 428 | 2373 } |
| 2374 | |
| 2375 /* Raise frame F. */ | |
| 2376 static void | |
| 2377 x_raise_frame_1 (struct frame *f, int force) | |
| 2378 { | |
| 2379 if (FRAME_VISIBLE_P (f) || force) | |
| 2380 { | |
| 2381 Widget bottom_dialog; | |
| 2382 XWindowChanges xwc; | |
| 2383 unsigned int flags; | |
| 2384 Display *display = DEVICE_X_DISPLAY (XDEVICE (f->device)); | |
| 2385 Window emacs_window = XtWindow (FRAME_X_SHELL_WIDGET (f)); | |
| 2386 | |
| 2387 /* first raises all the dialog boxes, then put emacs just below the | |
| 2388 * bottom most dialog box */ | |
| 2389 bottom_dialog = lw_raise_all_pop_up_widgets (); | |
| 2390 if (bottom_dialog && XtWindow (bottom_dialog)) | |
| 2391 { | |
| 2392 xwc.sibling = XtWindow (bottom_dialog); | |
| 2393 xwc.stack_mode = Below; | |
| 2394 flags = CWSibling | CWStackMode; | |
| 2395 } | |
| 2396 else | |
| 2397 { | |
| 2398 xwc.stack_mode = Above; | |
| 2399 flags = CWStackMode; | |
| 2400 } | |
| 2401 | |
| 2402 if (!XReconfigureWMWindow (display, emacs_window, | |
| 2403 DefaultScreen (display), | |
| 2404 flags, &xwc)) | |
| 2405 x_cant_notify_wm_error (); | |
| 2406 } | |
| 2407 } | |
| 2408 | |
| 2409 static void | |
| 2410 x_raise_frame (struct frame *f) | |
| 2411 { | |
| 2412 x_raise_frame_1 (f, 1); | |
| 2413 } | |
| 2414 | |
| 2415 /* Lower frame F. */ | |
| 2416 static void | |
| 2417 x_lower_frame (struct frame *f) | |
| 2418 { | |
| 2419 if (FRAME_VISIBLE_P (f)) | |
| 2420 { | |
| 2421 Display *display = DEVICE_X_DISPLAY (XDEVICE (f->device)); | |
| 2422 XWindowChanges xwc; | |
| 2423 unsigned int flags = CWStackMode; | |
| 2424 | |
| 2425 xwc.stack_mode = Below; | |
| 2426 if (!XReconfigureWMWindow (display, XtWindow (FRAME_X_SHELL_WIDGET (f)), | |
| 2427 DefaultScreen (display), flags, &xwc)) | |
| 2428 x_cant_notify_wm_error (); | |
| 2429 } | |
| 2430 } | |
| 2431 | |
| 442 | 2432 static void |
| 2433 x_enable_frame (struct frame *f) | |
| 2434 { | |
| 2435 XtSetSensitive (FRAME_X_SHELL_WIDGET (f), True); | |
| 2436 } | |
| 2437 | |
| 2438 static void | |
| 2439 x_disable_frame (struct frame *f) | |
| 2440 { | |
| 2441 XtSetSensitive (FRAME_X_SHELL_WIDGET (f), False); | |
| 2442 } | |
| 2443 | |
| 428 | 2444 /* Change from withdrawn state to mapped state. */ |
| 2445 static void | |
| 2446 x_make_frame_visible (struct frame *f) | |
| 2447 { | |
| 2448 Display *display = DEVICE_X_DISPLAY (XDEVICE (f->device)); | |
| 2449 | |
| 2450 if (!FRAME_VISIBLE_P(f)) | |
| 2451 XMapRaised (display, XtWindow (FRAME_X_SHELL_WIDGET (f))); | |
| 2452 else | |
| 2453 x_raise_frame_1 (f, 0); | |
| 2454 } | |
| 2455 | |
| 2456 /* Change from mapped state to withdrawn state. */ | |
| 2457 static void | |
| 2458 x_make_frame_invisible (struct frame *f) | |
| 2459 { | |
| 2460 Display *display = DEVICE_X_DISPLAY (XDEVICE (f->device)); | |
| 2461 | |
| 2462 if (!FRAME_VISIBLE_P(f)) | |
| 2463 return; | |
| 2464 | |
| 2465 if (!XWithdrawWindow (display, | |
| 2466 XtWindow (FRAME_X_SHELL_WIDGET (f)), | |
| 2467 DefaultScreen (display))) | |
| 2468 x_cant_notify_wm_error (); | |
| 2469 } | |
| 2470 | |
| 2471 static int | |
| 2472 x_frame_visible_p (struct frame *f) | |
| 2473 { | |
| 2474 #if 0 | |
| 593 | 2475 |
| 2476 /* #### Ben suggests using x_frame_window_state (f) == NormalState. */ | |
| 2477 | |
| 428 | 2478 Display *display = DEVICE_X_DISPLAY (XDEVICE (f->device)); |
| 2479 XWindowAttributes xwa; | |
| 2480 int result; | |
| 2481 | |
| 2482 /* JV: | |
| 2483 This is bad, very bad :-( | |
| 2484 It is not compatible with our tristate visible and | |
| 2485 it should never ever change the visibility for us, this leads to | |
| 2486 the frame-freeze problem under fvwm because with the pager | |
| 2487 | |
| 2488 Mappedness != Viewability != Visibility != Emacs f->visible | |
| 2489 | |
| 2490 This first unequalness is the reason for the frame freezing problem | |
| 2491 under fvwm (it happens when the frame is another fvwm-page) | |
| 2492 | |
| 2493 The second unequalness happen when it is on the same fvwm-page | |
| 2494 but in an invisible part of the visible screen. | |
| 2495 | |
| 2496 For now we just return the XEmacs internal value --- which might not be up | |
| 2497 to date. Is that a problem? ---. Otherwise we should | |
| 2498 use async visibility like in standard Emacs. | |
| 2499 */ | |
| 2500 | |
| 2501 if (!XGetWindowAttributes (display, | |
| 2502 XtWindow (FRAME_X_SHELL_WIDGET (f)), | |
| 2503 &xwa)) | |
| 2504 result = 0; | |
| 2505 else | |
| 2506 result = xwa.map_state == IsViewable; | |
| 2507 /* In this implementation it should at least be != IsUnmapped | |
| 2508 JV */ | |
| 2509 | |
| 2510 f->visible = result; | |
| 2511 return result; | |
| 2512 #endif /* 0 */ | |
| 2513 | |
| 2514 return f->visible; | |
| 2515 } | |
| 2516 | |
| 2517 static int | |
| 2518 x_frame_totally_visible_p (struct frame *f) | |
| 2519 { | |
| 2520 return FRAME_X_TOTALLY_VISIBLE_P (f); | |
| 2521 } | |
| 2522 | |
| 2523 /* Change window state from mapped to iconified. */ | |
| 2524 static void | |
| 2525 x_iconify_frame (struct frame *f) | |
| 2526 { | |
| 2527 Display *display = DEVICE_X_DISPLAY (XDEVICE (f->device)); | |
| 2528 | |
| 2529 if (!XIconifyWindow (display, | |
| 2530 XtWindow (FRAME_X_SHELL_WIDGET (f)), | |
| 2531 DefaultScreen (display))) | |
| 2532 x_cant_notify_wm_error (); | |
| 2533 | |
| 2534 f->iconified = 1; | |
| 2535 } | |
| 2536 | |
| 2537 /* Sets the X focus to frame f. */ | |
| 2538 static void | |
| 2539 x_focus_on_frame (struct frame *f) | |
| 2540 { | |
| 2541 XWindowAttributes xwa; | |
| 2542 Widget shell_widget; | |
| 2543 int viewable = 0; | |
| 2544 | |
| 2545 assert (FRAME_X_P (f)); | |
| 2546 | |
| 2547 shell_widget = FRAME_X_SHELL_WIDGET (f); | |
| 2548 if (!XtWindow (shell_widget)) | |
| 2549 return; | |
| 2550 | |
| 2551 #ifdef EXTERNAL_WIDGET | |
| 2552 if (FRAME_X_EXTERNAL_WINDOW_P (f)) | |
| 2553 ExternalShellSetFocus (shell_widget); | |
| 2554 #endif /* EXTERNAL_WIDGET */ | |
| 2555 | |
| 2556 /* Do the ICCCM focus change if the window is still visible. | |
| 2557 The s->visible flag might not be up-to-date, because we might | |
| 2558 not have processed magic events recently. So make a server | |
| 2559 round-trip to find out whether it's really mapped right now. | |
| 2560 We grab the server to do this, because that's the only way to | |
| 2561 eliminate the race condition. | |
| 2562 */ | |
| 2563 XGrabServer (XtDisplay (shell_widget)); | |
| 2564 if (XGetWindowAttributes (XtDisplay (shell_widget), | |
| 2565 XtWindow (shell_widget), | |
| 2566 &xwa)) | |
| 2567 /* JV: it is bad to change the visibility like this, so we don't for the | |
| 2568 moment, at least change_frame_visibility should be called | |
| 2569 Note also that under fvwm a frame can be Viewable (and thus Mapped) | |
| 2570 but still X-invisible | |
| 2571 f->visible = xwa.map_state == IsViewable; */ | |
| 2572 viewable = xwa.map_state == IsViewable; | |
| 2573 | |
| 2574 | |
| 2575 if (viewable) | |
| 2576 { | |
| 2577 Window focus; | |
| 2578 int revert_to; | |
| 2579 XGetInputFocus (XtDisplay (shell_widget), &focus, &revert_to); | |
| 2580 /* Don't explicitly set the focus on this window unless the focus | |
| 2581 was on some other window (not PointerRoot). Note that, even when | |
| 2582 running a point-to-type window manager like *twm, there is always | |
| 2583 a focus window; the window manager maintains that based on the | |
| 2584 mouse position. If you set the "NoTitleFocus" option in these | |
| 2585 window managers, then the server itself maintains the focus via | |
| 2586 PointerRoot, and changing that to focus on the window would make | |
| 2587 the window grab the focus. Very bad. | |
| 2588 */ | |
| 2589 if (focus != PointerRoot) | |
| 2590 { | |
| 2591 XSetInputFocus (XtDisplay (shell_widget), | |
| 2592 XtWindow (shell_widget), | |
| 2593 RevertToParent, | |
| 4706 | 2594 CurrentTime); |
| 428 | 2595 XFlush (XtDisplay (shell_widget)); |
| 2596 } | |
| 2597 } | |
| 2598 XUngrabServer (XtDisplay (shell_widget)); | |
| 2599 XFlush (XtDisplay (shell_widget)); /* hey, I'd like to DEBUG this... */ | |
| 2600 } | |
| 2601 | |
| 450 | 2602 /* Destroy the X window of frame F. */ |
| 428 | 2603 static void |
| 2604 x_delete_frame (struct frame *f) | |
| 2605 { | |
| 2606 Display *dpy; | |
| 2607 | |
| 2608 #ifndef HAVE_WMCOMMAND | |
| 2609 if (FRAME_X_TOP_LEVEL_FRAME_P (f)) | |
| 2610 x_wm_maybe_move_wm_command (f); | |
| 2611 #endif /* HAVE_WMCOMMAND */ | |
| 2612 | |
| 2613 #ifdef HAVE_CDE | |
| 2614 DtDndDropUnregister (FRAME_X_TEXT_WIDGET (f)); | |
| 2615 #endif /* HAVE_CDE */ | |
| 2616 | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
2617 #ifdef HAVE_XFT |
| 3094 | 2618 /* If we have an XftDraw structure, we need to free it here. |
| 2619 We can't ever have an XftDraw without a Display, so we are safe | |
| 2620 to free it in here, and we avoid too much playing around with the | |
| 2621 malloc checking hooks this way. */ | |
| 2622 if (FRAME_X_XFTDRAW (f)) | |
| 2623 { | |
| 2624 XftDrawDestroy (FRAME_X_XFTDRAW (f)); | |
| 2625 FRAME_X_XFTDRAW (f) = NULL; | |
| 2626 } | |
| 2627 #endif | |
| 2628 | |
| 2629 | |
| 428 | 2630 assert (FRAME_X_SHELL_WIDGET (f) != 0); |
| 2631 dpy = XtDisplay (FRAME_X_SHELL_WIDGET (f)); | |
| 2632 | |
| 2633 #ifdef EXTERNAL_WIDGET | |
| 1024 | 2634 expect_x_error (dpy); |
| 428 | 2635 /* for obscure reasons having (I think) to do with the internal |
| 2636 window-to-widget hierarchy maintained by Xt, we have to call | |
| 2637 XtUnrealizeWidget() here. Xt can really suck. */ | |
| 2638 if (f->being_deleted) | |
| 2639 XtUnrealizeWidget (FRAME_X_SHELL_WIDGET (f)); | |
| 2640 XtDestroyWidget (FRAME_X_SHELL_WIDGET (f)); | |
| 1024 | 2641 x_error_occurred_p (dpy); |
| 428 | 2642 #else |
| 2643 XtDestroyWidget (FRAME_X_SHELL_WIDGET (f)); | |
| 2644 /* make sure the windows are really gone! */ | |
| 440 | 2645 /* #### Is this REALLY necessary? */ |
| 428 | 2646 XFlush (dpy); |
| 2647 #endif /* EXTERNAL_WIDGET */ | |
| 2648 | |
| 2649 FRAME_X_SHELL_WIDGET (f) = 0; | |
| 2650 | |
| 2651 if (FRAME_X_GEOM_FREE_ME_PLEASE (f)) | |
| 2652 { | |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
2653 xfree (FRAME_X_GEOM_FREE_ME_PLEASE (f)); |
| 428 | 2654 FRAME_X_GEOM_FREE_ME_PLEASE (f) = 0; |
| 2655 } | |
| 2656 | |
| 2657 if (f->frame_data) | |
| 2658 { | |
| 4117 | 2659 #ifndef NEW_GC |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
2660 xfree (f->frame_data); |
| 3092 | 2661 #endif /* not NEW_GC */ |
| 428 | 2662 f->frame_data = 0; |
| 2663 } | |
| 2664 } | |
| 2665 | |
| 2666 static void | |
| 2367 | 2667 x_update_frame_external_traits (struct frame *frm, Lisp_Object name) |
| 428 | 2668 { |
| 2669 Arg al[10]; | |
| 2670 int ac = 0; | |
| 793 | 2671 Lisp_Object frame = wrap_frame (frm); |
| 2672 | |
| 428 | 2673 |
| 2674 if (EQ (name, Qforeground)) | |
| 2675 { | |
| 2676 Lisp_Object color = FACE_FOREGROUND (Vdefault_face, frame); | |
| 2677 XColor fgc; | |
| 2678 | |
| 2679 if (!EQ (color, Vthe_null_color_instance)) | |
| 2680 { | |
| 2681 fgc = COLOR_INSTANCE_X_COLOR (XCOLOR_INSTANCE (color)); | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
2682 Xt_SET_ARG (al[ac], XtNforeground, (void *) fgc.pixel); ac++; |
| 428 | 2683 } |
| 2684 } | |
| 2685 else if (EQ (name, Qbackground)) | |
| 2686 { | |
| 2687 Lisp_Object color = FACE_BACKGROUND (Vdefault_face, frame); | |
| 2688 XColor bgc; | |
| 2689 | |
| 2690 if (!EQ (color, Vthe_null_color_instance)) | |
| 2691 { | |
| 2692 bgc = COLOR_INSTANCE_X_COLOR (XCOLOR_INSTANCE (color)); | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
2693 Xt_SET_ARG (al[ac], XtNbackground, (void *) bgc.pixel); ac++; |
| 428 | 2694 } |
| 2695 | |
| 2696 /* Really crappy way to force the modeline shadows to be | |
| 2697 redrawn. But effective. */ | |
| 2698 MARK_FRAME_WINDOWS_STRUCTURE_CHANGED (frm); | |
| 2699 MARK_FRAME_CHANGED (frm); | |
| 2700 } | |
| 2701 else if (EQ (name, Qfont)) | |
| 2702 { | |
| 2703 Lisp_Object font = FACE_FONT (Vdefault_face, frame, Vcharset_ascii); | |
| 2704 | |
| 3676 | 2705 /* It may be that instantiating the font has deleted the frame (will |
| 2706 happen if the user has specified a charset registry for ASCII that | |
| 2707 isn't available on the server, and our fallback of iso8859-1 isn't | |
| 2708 available; something vanishingly rare.) In that case, return from | |
| 2709 this function without further manipulation of the dead frame. */ | |
| 2710 | |
| 2711 if (!FRAME_LIVE_P(frm)) | |
| 2712 { | |
| 2713 return; | |
| 2714 } | |
| 2715 | |
| 3094 | 2716 /* #### what to do about Xft? I don't think the font is actually used |
| 2717 to compute cell size for computing frame pixel dimensions (see call | |
| 2718 to EmacsFrameRecomputeCellSize() below); where is it used? -- sjt | |
| 2719 What does XtSetValues() do if that resource isn't present? */ | |
| 428 | 2720 if (!EQ (font, Vthe_null_font_instance)) |
| 1746 | 2721 { |
| 3094 | 2722 if (0) |
| 2723 ; | |
|
4916
a6c778975d7d
split USE_XFT into HAVE_XFT/USE_XFT
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
2724 #ifdef HAVE_XFT |
| 3094 | 2725 else if (FONT_INSTANCE_X_XFTFONT (XFONT_INSTANCE (font))) |
| 2726 { | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
2727 Xt_SET_ARG (al[ac], XtNxftFont, |
| 3094 | 2728 (void *) FONT_INSTANCE_X_XFTFONT (XFONT_INSTANCE (font))); |
| 2729 ac++; | |
| 2730 } | |
| 2731 #endif | |
| 2732 else if (FONT_INSTANCE_X_FONT (XFONT_INSTANCE (font))) | |
| 2733 { | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
2734 Xt_SET_ARG (al[ac], XtNfont, |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
2735 (void *) FONT_INSTANCE_X_FONT (XFONT_INSTANCE (font))); |
| 3094 | 2736 ac++; |
| 2737 } | |
| 1746 | 2738 } |
| 428 | 2739 } |
| 2740 else | |
| 2500 | 2741 ABORT (); |
| 428 | 2742 |
| 2743 XtSetValues (FRAME_X_TEXT_WIDGET (frm), al, ac); | |
| 2744 | |
| 2745 #ifdef HAVE_TOOLBARS | |
| 2746 /* Setting the background clears the entire frame area | |
| 2747 including the toolbar so we force an immediate redraw of | |
| 2748 it. */ | |
| 2749 if (EQ (name, Qbackground)) | |
| 2750 MAYBE_DEVMETH (XDEVICE (frm->device), redraw_frame_toolbars, (frm)); | |
| 2751 #endif /* HAVE_TOOLBARS */ | |
| 2752 | |
| 2753 /* Set window manager resize increment hints according to | |
| 2754 the new character size */ | |
| 2755 if (EQ (name, Qfont)) | |
| 2756 EmacsFrameRecomputeCellSize (FRAME_X_TEXT_WIDGET (frm)); | |
| 2757 } | |
| 2758 | |
| 2759 | |
| 2760 /************************************************************************/ | |
| 2761 /* initialization */ | |
| 2762 /************************************************************************/ | |
| 2763 | |
| 2764 void | |
| 2765 syms_of_frame_x (void) | |
| 2766 { | |
| 3092 | 2767 #ifdef NEW_GC |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
parents:
4790
diff
changeset
|
2768 INIT_LISP_OBJECT (x_frame); |
| 3092 | 2769 #endif /* NEW_GC */ |
| 2770 | |
| 2747 | 2771 DEFSYMBOL (Qoverride_redirect); |
| 563 | 2772 DEFSYMBOL (Qx_resource_name); |
| 428 | 2773 |
| 2774 DEFSUBR (Fx_window_id); | |
| 2775 #ifdef HAVE_CDE | |
| 2776 DEFSUBR (Fcde_start_drag_internal); | |
| 2777 #endif | |
| 2778 } | |
| 2779 | |
| 2780 void | |
| 2781 console_type_create_frame_x (void) | |
| 2782 { | |
| 2783 /* frame methods */ | |
| 2784 CONSOLE_HAS_METHOD (x, init_frame_1); | |
| 2785 CONSOLE_HAS_METHOD (x, init_frame_2); | |
| 2786 CONSOLE_HAS_METHOD (x, init_frame_3); | |
| 2787 CONSOLE_HAS_METHOD (x, mark_frame); | |
| 2788 CONSOLE_HAS_METHOD (x, focus_on_frame); | |
| 2789 CONSOLE_HAS_METHOD (x, delete_frame); | |
| 2790 CONSOLE_HAS_METHOD (x, get_mouse_position); | |
| 2791 CONSOLE_HAS_METHOD (x, set_mouse_position); | |
| 2792 CONSOLE_HAS_METHOD (x, raise_frame); | |
| 2793 CONSOLE_HAS_METHOD (x, lower_frame); | |
| 442 | 2794 CONSOLE_HAS_METHOD (x, enable_frame); |
| 2795 CONSOLE_HAS_METHOD (x, disable_frame); | |
| 428 | 2796 CONSOLE_HAS_METHOD (x, make_frame_visible); |
| 2797 CONSOLE_HAS_METHOD (x, make_frame_invisible); | |
| 2798 CONSOLE_HAS_METHOD (x, iconify_frame); | |
| 2799 CONSOLE_HAS_METHOD (x, set_frame_size); | |
| 2800 CONSOLE_HAS_METHOD (x, set_frame_position); | |
| 2801 CONSOLE_HAS_METHOD (x, frame_property); | |
| 2802 CONSOLE_HAS_METHOD (x, internal_frame_property_p); | |
| 2803 CONSOLE_HAS_METHOD (x, frame_properties); | |
| 2804 CONSOLE_HAS_METHOD (x, set_frame_properties); | |
| 867 | 2805 CONSOLE_HAS_METHOD (x, set_title_from_ibyte); |
| 2806 CONSOLE_HAS_METHOD (x, set_icon_name_from_ibyte); | |
| 428 | 2807 CONSOLE_HAS_METHOD (x, frame_visible_p); |
| 2808 CONSOLE_HAS_METHOD (x, frame_totally_visible_p); | |
| 2809 CONSOLE_HAS_METHOD (x, frame_iconified_p); | |
| 2810 CONSOLE_HAS_METHOD (x, set_frame_pointer); | |
| 2811 CONSOLE_HAS_METHOD (x, set_frame_icon); | |
| 2812 CONSOLE_HAS_METHOD (x, get_frame_parent); | |
| 2813 CONSOLE_HAS_METHOD (x, update_frame_external_traits); | |
| 2814 } | |
| 2815 | |
| 2816 void | |
| 2817 vars_of_frame_x (void) | |
| 2818 { | |
| 2819 #ifdef EXTERNAL_WIDGET | |
| 2820 Fprovide (intern ("external-widget")); | |
| 2821 #endif | |
| 2822 | |
| 2823 /* this call uses only safe functions from emacs.c */ | |
| 2824 init_x_prop_symbols (); | |
| 2825 | |
| 2826 DEFVAR_LISP ("default-x-frame-plist", &Vdefault_x_frame_plist /* | |
| 2827 Plist of default frame-creation properties for X frames. | |
| 2828 These override what is specified in the resource database and in | |
| 2829 `default-frame-plist', but are overridden by the arguments to the | |
| 2830 particular call to `make-frame'. | |
| 2831 | |
| 2832 Note: In many cases, properties of a frame are available as specifiers | |
| 2833 instead of through the frame-properties mechanism. | |
| 2834 | |
| 2835 Here is a list of recognized frame properties, other than those | |
| 2836 documented in `set-frame-properties' (they can be queried and | |
| 2837 set at any time, except as otherwise noted): | |
| 2838 | |
| 2839 window-id The X window ID corresponding to the | |
| 2840 frame. May be set only at startup, and | |
| 2841 only if external widget support was | |
| 2842 compiled in; doing so causes the frame | |
| 2843 to be created as an "external widget" | |
| 2844 in another program that uses an existing | |
| 2845 window in the program rather than creating | |
| 2846 a new one. | |
| 2847 initially-unmapped If non-nil, the frame will not be visible | |
| 2848 when it is created. In this case, you | |
| 2849 need to call `make-frame-visible' to make | |
| 2850 the frame appear. | |
| 2851 popup If non-nil, it should be a frame, and this | |
| 2852 frame will be created as a "popup" frame | |
| 2853 whose parent is the given frame. This | |
| 2854 will make the window manager treat the | |
| 2855 frame as a dialog box, which may entail | |
| 2856 doing different things (e.g. not asking | |
| 2857 for positioning, and not iconifying | |
| 2858 separate from its parent). | |
| 2747 | 2859 override-redirect If non-nil, the frame will not be subject to |
| 2860 window-manager control. In particular, it | |
| 2861 will lack decorations, for more attractive | |
| 2862 appearance of balloon help, aka tooltips. | |
| 428 | 2863 inter-line-space Not currently implemented. |
| 2864 toolbar-shadow-thickness Thickness of toolbar shadows. | |
| 2865 background-toolbar-color Color of toolbar background. | |
| 2866 bottom-toolbar-shadow-color Color of bottom shadows on toolbars. | |
| 2867 (*Not* specific to the bottom-toolbar.) | |
| 2868 top-toolbar-shadow-color Color of top shadows on toolbars. | |
| 2869 (*Not* specific to the top-toolbar.) | |
| 2870 internal-border-width Width of internal border around text area. | |
| 2871 border-width Width of external border around text area. | |
| 2872 top Y position (in pixels) of the upper-left | |
| 2873 outermost corner of the frame (i.e. the | |
| 2874 upper-left of the window-manager | |
| 2875 decorations). | |
| 2876 left X position (in pixels) of the upper-left | |
| 2877 outermost corner of the frame (i.e. the | |
| 2878 upper-left of the window-manager | |
| 2879 decorations). | |
| 2880 border-color Color of external border around text area. | |
| 2881 cursor-color Color of text cursor. | |
| 2882 | |
| 2883 See also `default-frame-plist', which specifies properties which apply | |
| 2884 to all frames, not just X frames. | |
| 2885 */ ); | |
| 2886 Vdefault_x_frame_plist = Qnil; | |
| 2887 | |
| 2888 x_console_methods->device_specific_frame_props = &Vdefault_x_frame_plist; | |
| 2889 } |