Mercurial > hg > xemacs-beta
annotate src/device-x.c @ 4976:16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
-------------------- ChangeLog entries follow: --------------------
src/ChangeLog addition:
2010-02-04 Ben Wing <ben@xemacs.org>
* alloc.c (release_breathing_space):
* alloc.c (resize_string):
* alloc.c (sweep_lcrecords_1):
* alloc.c (SWEEP_FIXED_TYPE_BLOCK_1):
* alloc.c (ADDITIONAL_FREE_compiled_function):
* alloc.c (compact_string_chars):
* alloc.c (ADDITIONAL_FREE_string):
* alloc.c (sweep_strings):
* alloca.c (xemacs_c_alloca):
* alsaplay.c (alsa_play_sound_file):
* buffer.c (init_initial_directory):
* buffer.h:
* buffer.h (BUFFER_FREE):
* console-stream.c (stream_delete_console):
* console-tty.c (free_tty_console_struct):
* data.c (Fnumber_to_string):
* device-gtk.c (gtk_init_device):
* device-gtk.c (free_gtk_device_struct):
* device-gtk.c (gtk_delete_device):
* device-msw.c (mswindows_delete_device):
* device-msw.c (msprinter_delete_device):
* device-tty.c (free_tty_device_struct):
* device-tty.c (tty_delete_device):
* device-x.c (x_init_device):
* device-x.c (free_x_device_struct):
* device-x.c (x_delete_device):
* dialog-msw.c (handle_directory_dialog_box):
* dialog-x.c (dbox_descriptor_to_widget_value):
* dired-msw.c (Fmswindows_insert_directory):
* dired.c (free_user_cache):
* dired.c (user_name_completion_unwind):
* doc.c (unparesseuxify_doc_string):
* doc.c (Fsubstitute_command_keys):
* doprnt.c (emacs_doprnt_1):
* dumper.c (pdump_load_finish):
* dumper.c (pdump_file_free):
* dumper.c (pdump_file_unmap):
* dynarr.c:
* dynarr.c (Dynarr_free):
* editfns.c (uncache_home_directory):
* editfns.c (Fset_time_zone_rule):
* elhash.c:
* elhash.c (pdump_reorganize_hash_table):
* elhash.c (maphash_unwind):
* emacs.c (make_arg_list_1):
* emacs.c (free_argc_argv):
* emacs.c (sort_args):
* emacs.c (Frunning_temacs_p):
* emodules.c (attempt_module_delete):
* eval.c (free_pointer):
* event-Xt.c (unselect_filedesc):
* event-Xt.c (emacs_Xt_select_process):
* event-gtk.c (unselect_filedesc):
* event-gtk.c (dragndrop_data_received):
* event-msw.c (winsock_closer):
* event-msw.c (mswindows_dde_callback):
* event-msw.c (mswindows_wnd_proc):
* event-stream.c (finalize_command_builder):
* event-stream.c (free_command_builder):
* extents.c (free_gap_array):
* extents.c (free_extent_list):
* extents.c (free_soe):
* extents.c (extent_fragment_delete):
* extents.c (extent_priority_sort_function):
* file-coding.c (make_coding_system_1):
* file-coding.c (coding_finalizer):
* file-coding.c (set_coding_stream_coding_system):
* file-coding.c (chain_finalize_coding_stream_1):
* file-coding.c (chain_finalize):
* file-coding.c (free_detection_state):
* file-coding.c (coding_category_symbol_to_id):
* fileio.c:
* fileio.c (Ffile_name_directory):
* fileio.c (if):
* fileio.c (Ffile_symlink_p):
* filelock.c (FREE_LOCK_INFO):
* filelock.c (current_lock_owner):
* font-mgr.c (Ffc_name_unparse):
* font-mgr.c (Ffc_pattern_duplicate):
* frame-gtk.c (gtk_delete_frame):
* frame-msw.c (mswindows_delete_frame):
* frame-msw.c (msprinter_delete_frame):
* frame-x.c (x_cde_destroy_callback):
* frame-x.c (Fcde_start_drag_internal):
* frame-x.c (x_cde_transfer_callback):
* frame-x.c (x_delete_frame):
* frame.c (update_frame_title):
* frame.c (Fset_frame_pointer):
* gc.c (register_for_finalization):
* gccache-gtk.c (free_gc_cache):
* gccache-gtk.c (gc_cache_lookup):
* gccache-x.c (free_gc_cache):
* gccache-x.c (gc_cache_lookup):
* glyphs-eimage.c:
* glyphs-eimage.c (jpeg_instantiate_unwind):
* glyphs-eimage.c (gif_instantiate_unwind):
* glyphs-eimage.c (png_instantiate_unwind):
* glyphs-eimage.c (png_instantiate):
* glyphs-eimage.c (tiff_instantiate_unwind):
* glyphs-gtk.c (convert_EImage_to_GDKImage):
* glyphs-gtk.c (gtk_finalize_image_instance):
* glyphs-gtk.c (gtk_init_image_instance_from_eimage):
* glyphs-gtk.c (gtk_xpm_instantiate):
* glyphs-msw.c (convert_EImage_to_DIBitmap):
* glyphs-msw.c (mswindows_init_image_instance_from_eimage):
* glyphs-msw.c (mswindows_initialize_image_instance_mask):
* glyphs-msw.c (xpm_to_eimage):
* glyphs-msw.c (mswindows_xpm_instantiate):
* glyphs-msw.c (xbm_create_bitmap_from_data):
* glyphs-msw.c (mswindows_finalize_image_instance):
* glyphs-x.c (convert_EImage_to_XImage):
* glyphs-x.c (x_finalize_image_instance):
* glyphs-x.c (x_init_image_instance_from_eimage):
* glyphs-x.c (x_xpm_instantiate):
* gui-x.c (free_popup_widget_value_tree):
* hash.c (free_hash_table):
* hash.c (grow_hash_table):
* hash.c (pregrow_hash_table_if_necessary):
* imgproc.c (build_EImage_quantable):
* insdel.c (uninit_buffer_text):
* intl-win32.c (convert_multibyte_to_internal_malloc):
* intl.c:
* intl.c (Fset_current_locale):
* keymap.c:
* keymap.c (where_is_recursive_mapper):
* keymap.c (where_is_internal):
* lisp.h:
* lisp.h (xfree):
* lstream.c (Lstream_close):
* lstream.c (resizing_buffer_closer):
* mule-coding.c:
* mule-coding.c (iso2022_finalize_detection_state):
* nt.c:
* nt.c (mswindows_get_long_filename):
* nt.c (nt_get_resource):
* nt.c (init_mswindows_environment):
* nt.c (get_cached_volume_information):
* nt.c (mswindows_opendir):
* nt.c (mswindows_closedir):
* nt.c (mswindows_readdir):
* nt.c (mswindows_stat):
* nt.c (mswindows_getdcwd):
* nt.c (Fmswindows_long_file_name):
* ntplay.c (nt_play_sound_file):
* ntplay.c (play_sound_data_1):
* number-gmp.c (gmp_free):
* number-gmp.c (init_number_gmp):
* number-mp.c (bignum_to_string):
* number-mp.c (BIGNUM_TO_TYPE):
* number.c (bignum_print):
* number.c (bignum_convfree):
* number.c (ratio_print):
* number.c (bigfloat_print):
* number.c (bigfloat_finalize):
* objects-gtk.c (gtk_finalize_color_instance):
* objects-gtk.c (gtk_finalize_font_instance):
* objects-msw.c (mswindows_finalize_color_instance):
* objects-msw.c (mswindows_finalize_font_instance):
* objects-tty.c (tty_finalize_color_instance):
* objects-tty.c (tty_finalize_font_instance):
* objects-tty.c (tty_font_list):
* objects-x.c (x_finalize_color_instance):
* objects-x.c (x_finalize_font_instance):
* process.c:
* process.c (finalize_process):
* realpath.c:
* redisplay.c (add_propagation_runes):
* regex.c:
* regex.c (xfree):
* regex.c (REGEX_FREE_STACK):
* regex.c (FREE_STACK_RETURN):
* regex.c (regex_compile):
* regex.c (regexec):
* regex.c (regfree):
* scrollbar-gtk.c (gtk_free_scrollbar_instance):
* scrollbar-gtk.c (gtk_release_scrollbar_instance):
* scrollbar-msw.c (mswindows_free_scrollbar_instance):
* scrollbar-msw.c (unshow_that_mofo):
* scrollbar-x.c (x_free_scrollbar_instance):
* scrollbar-x.c (x_release_scrollbar_instance):
* select-gtk.c (emacs_gtk_selection_handle):
* select-msw.c (mswindows_own_selection):
* select-x.c:
* select-x.c (x_handle_selection_request):
* select-x.c (unexpect_property_change):
* select-x.c (x_handle_property_notify):
* select-x.c (receive_incremental_selection):
* select-x.c (x_get_window_property_as_lisp_data):
* select-x.c (Fx_get_cutbuffer_internal):
* specifier.c (finalize_specifier):
* syntax.c (uninit_buffer_syntax_cache):
* sysdep.c (qxe_allocating_getcwd):
* sysdep.c (qxe_lstat):
* sysdep.c (copy_in_passwd):
* sysdep.c (qxe_ctime):
* sysdep.c (closedir):
* sysdep.c (DIRSIZ):
* termcap.c (tgetent):
* termcap.c (tprint):
* tests.c (Ftest_data_format_conversion):
* text.c (new_dfc_convert_copy_data):
* text.h (eifree):
* text.h (eito_alloca):
* text.h (eito_external):
* toolbar-msw.c (mswindows_output_toolbar):
* ui-gtk.c (CONVERT_RETVAL):
* ui-gtk.c (__allocate_object_storage):
* unicode.c (free_from_unicode_table):
* unicode.c (free_to_unicode_table):
* unicode.c (free_charset_unicode_tables):
* win32.c (mswindows_read_link_1):
Rename: xfree(VAL, TYPE)->xfree(VAL)
Command used:
gr 'xfree *\((.*),.*\);' 'xfree (\1);' *.[ch]
Followed by grepping for 'xfree.*,' and fixing anything left.
Rationale: Having to specify the TYPE argument is annoying and
error-prone. It was originally put in to work around warnings
due to strict aliasing but years and years ago I rewrote it
in a way that doesn't use the TYPE argument at all and no one
has complained since then. (And anyway, XEmacs is far from
ever being in compliance with strict aliasing and would require
far-reaching changes to get that way.)
| author | Ben Wing <ben@xemacs.org> |
|---|---|
| date | Thu, 04 Feb 2010 07:28:14 -0600 |
| parents | cbe181529c34 |
| children | 3c3c1d139863 |
| rev | line source |
|---|---|
| 428 | 1 /* Device functions for X windows. |
| 2 Copyright (C) 1994, 1995 Board of Trustees, University of Illinois. | |
| 3 Copyright (C) 1994, 1995 Free Software Foundation, Inc. | |
| 2367 | 4 Copyright (C) 2001, 2002, 2004 Ben Wing. |
| 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 in FSF. */ | |
| 24 | |
| 442 | 25 /* 7-8-00 !!#### This file needs definite Mule review. */ |
| 26 | |
| 428 | 27 /* Original authors: Jamie Zawinski and the FSF */ |
| 28 /* Rewritten by Ben Wing and Chuck Thompson. */ | |
| 29 | |
| 30 #include <config.h> | |
| 31 #include "lisp.h" | |
| 32 | |
| 33 #include "buffer.h" | |
| 872 | 34 #include "device-impl.h" |
| 428 | 35 #include "elhash.h" |
| 36 #include "events.h" | |
| 37 #include "faces.h" | |
| 3707 | 38 #include "file-coding.h" |
| 872 | 39 #include "frame-impl.h" |
| 2684 | 40 #include "process.h" /* for egetenv */ |
| 428 | 41 #include "redisplay.h" |
| 42 #include "sysdep.h" | |
| 43 #include "window.h" | |
| 44 | |
| 872 | 45 #include "console-x-impl.h" |
| 800 | 46 #include "glyphs-x.h" |
| 47 #include "objects-x.h" | |
| 48 | |
| 428 | 49 #include "sysfile.h" |
| 50 #include "systime.h" | |
| 51 | |
| 800 | 52 #include "xintrinsicp.h" /* CoreP.h needs this */ |
| 53 #include <X11/CoreP.h> /* Numerous places access the fields of | |
| 54 a core widget directly. We could | |
| 55 use XtGetValues(), but ... */ | |
| 4917 | 56 #include "gccache-x.h" |
| 800 | 57 #include <X11/Shell.h> |
|
4769
5460287a3327
Remove support for pre-X11R5 systems, including systems without Xmu. See
Jerry James <james@xemacs.org>
parents:
4677
diff
changeset
|
58 #include <X11/Xmu/Error.h> |
| 800 | 59 |
| 442 | 60 #if defined(HAVE_SHLIB) && defined(LWLIB_USES_ATHENA) && !defined(HAVE_ATHENA_3D) |
| 440 | 61 #include "sysdll.h" |
| 442 | 62 #endif /* HAVE_SHLIB and LWLIB_USES_ATHENA and not HAVE_ATHENA_3D */ |
| 440 | 63 |
|
4477
e34711681f30
Don't determine whether to call general device-type code at startup,
Aidan Kehoe <kehoea@parhasard.net>
parents:
4404
diff
changeset
|
64 Lisp_Object Vx_app_defaults_directory; |
| 771 | 65 #ifdef MULE |
| 66 Lisp_Object Qget_coding_system_from_locale; | |
| 428 | 67 #endif |
| 68 | |
| 69 /* Qdisplay in general.c */ | |
| 70 Lisp_Object Qx_error; | |
|
4477
e34711681f30
Don't determine whether to call general device-type code at startup,
Aidan Kehoe <kehoea@parhasard.net>
parents:
4404
diff
changeset
|
71 Lisp_Object Qmake_device_early_x_entry_point, Qmake_device_late_x_entry_point; |
| 428 | 72 |
| 73 /* The application class of Emacs. */ | |
| 74 Lisp_Object Vx_emacs_application_class; | |
| 75 | |
| 76 Lisp_Object Vx_initial_argv_list; /* #### ugh! */ | |
| 77 | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
78 /* Shut up G++ 4.3. */ |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
79 #define Xrm_ODR(option,resource,type,default) \ |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
80 { (String) option, (String) resource, type, default } |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
81 |
| 428 | 82 static XrmOptionDescRec emacs_options[] = |
| 83 { | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
84 Xrm_ODR ("-geometry", ".geometry", XrmoptionSepArg, NULL), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
85 Xrm_ODR ("-iconic", ".iconic", XrmoptionNoArg, (String) "yes"), |
| 428 | 86 |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
87 Xrm_ODR ("-internal-border-width", "*EmacsFrame.internalBorderWidth", XrmoptionSepArg, NULL), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
88 Xrm_ODR ("-ib", "*EmacsFrame.internalBorderWidth", XrmoptionSepArg, NULL), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
89 Xrm_ODR ("-scrollbar-width", "*EmacsFrame.scrollBarWidth", XrmoptionSepArg, NULL), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
90 Xrm_ODR ("-scrollbar-height", "*EmacsFrame.scrollBarHeight", XrmoptionSepArg, NULL), |
| 428 | 91 |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
92 Xrm_ODR ("-privatecolormap", ".privateColormap", XrmoptionNoArg, (String) "yes"), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
93 Xrm_ODR ("-visual", ".EmacsVisual", XrmoptionSepArg, NULL), |
| 428 | 94 |
| 95 /* #### Beware! If the type of the shell changes, update this. */ | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
96 Xrm_ODR ("-T", "*TopLevelEmacsShell.title", XrmoptionSepArg, NULL), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
97 Xrm_ODR ("-wn", "*TopLevelEmacsShell.title", XrmoptionSepArg, NULL), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
98 Xrm_ODR ("-title", "*TopLevelEmacsShell.title", XrmoptionSepArg, NULL), |
| 428 | 99 |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
100 Xrm_ODR ("-iconname", "*TopLevelEmacsShell.iconName", XrmoptionSepArg, NULL), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
101 Xrm_ODR ("-in", "*TopLevelEmacsShell.iconName", XrmoptionSepArg, NULL), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
102 Xrm_ODR ("-mc", "*pointerColor", XrmoptionSepArg, NULL), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
103 Xrm_ODR ("-cr", "*cursorColor", XrmoptionSepArg, NULL), |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
104 Xrm_ODR ("-fontset", "*FontSet", XrmoptionSepArg, NULL), |
| 428 | 105 }; |
| 106 | |
| 1204 | 107 static const struct memory_description x_device_data_description_1 [] = { |
| 108 { XD_LISP_OBJECT, offsetof (struct x_device, x_keysym_map_hash_table) }, | |
| 109 { XD_LISP_OBJECT, offsetof (struct x_device, WM_COMMAND_frame) }, | |
| 110 { XD_END } | |
| 111 }; | |
| 112 | |
| 3092 | 113 #ifdef NEW_GC |
| 114 DEFINE_LRECORD_IMPLEMENTATION ("x-device", x_device, | |
| 115 1, /*dumpable-flag*/ | |
| 116 0, 0, 0, 0, 0, | |
| 117 x_device_data_description_1, | |
| 118 Lisp_X_Device); | |
| 119 #else /* not NEW_GC */ | |
| 1204 | 120 extern const struct sized_memory_description x_device_data_description; |
| 121 | |
| 122 const struct sized_memory_description x_device_data_description = { | |
| 123 sizeof (struct x_device), x_device_data_description_1 | |
| 124 }; | |
| 3092 | 125 #endif /* not NEW_GC */ |
| 1204 | 126 |
| 428 | 127 /* Functions to synchronize mirroring resources and specifiers */ |
| 128 int in_resource_setting; | |
| 129 | |
| 130 /************************************************************************/ | |
| 131 /* helper functions */ | |
| 132 /************************************************************************/ | |
| 133 | |
| 134 /* JH 97/11/25 removed the static declaration because I need it during setup in event-Xt... */ | |
| 135 struct device * get_device_from_display_1 (Display *dpy); | |
| 136 struct device * | |
| 137 get_device_from_display_1 (Display *dpy) | |
| 138 { | |
| 139 Lisp_Object devcons, concons; | |
| 140 | |
| 141 DEVICE_LOOP_NO_BREAK (devcons, concons) | |
| 142 { | |
| 143 struct device *d = XDEVICE (XCAR (devcons)); | |
| 144 if (DEVICE_X_P (d) && DEVICE_X_DISPLAY (d) == dpy) | |
| 145 return d; | |
| 146 } | |
| 147 | |
| 148 return 0; | |
| 149 } | |
| 150 | |
| 151 struct device * | |
| 152 get_device_from_display (Display *dpy) | |
| 153 { | |
| 154 struct device *d = get_device_from_display_1 (dpy); | |
| 155 | |
| 156 #if !defined(INFODOCK) | |
| 157 # define FALLBACK_RESOURCE_NAME "xemacs" | |
| 158 # else | |
| 159 # define FALLBACK_RESOURCE_NAME "infodock" | |
| 160 #endif | |
| 161 | |
| 853 | 162 if (!d) |
| 163 { | |
| 164 /* This isn't one of our displays. Let's crash? */ | |
| 165 stderr_out | |
| 166 ("\n%s: Fatal X Condition. Asked about display we don't own: \"%s\"\n", | |
| 167 (STRINGP (Vinvocation_name) ? | |
| 168 (char *) XSTRING_DATA (Vinvocation_name) : FALLBACK_RESOURCE_NAME), | |
| 169 DisplayString (dpy) ? DisplayString (dpy) : "???"); | |
| 2500 | 170 ABORT(); |
| 853 | 171 } |
| 428 | 172 |
| 173 #undef FALLBACK_RESOURCE_NAME | |
| 174 | |
| 175 return d; | |
| 176 } | |
| 177 | |
| 178 struct device * | |
| 179 decode_x_device (Lisp_Object device) | |
| 180 { | |
| 793 | 181 device = wrap_device (decode_device (device)); |
| 428 | 182 CHECK_X_DEVICE (device); |
| 183 return XDEVICE (device); | |
| 184 } | |
| 185 | |
| 186 static Display * | |
| 187 get_x_display (Lisp_Object device) | |
| 188 { | |
| 189 return DEVICE_X_DISPLAY (decode_x_device (device)); | |
| 190 } | |
| 191 | |
| 771 | 192 static Lisp_Object |
| 2333 | 193 coding_system_of_xrm_database (XrmDatabase USED_IF_MULE (db)) |
| 771 | 194 { |
| 195 #ifdef MULE | |
| 3707 | 196 const Extbyte *locale; |
| 197 Lisp_Object localestr; | |
| 198 static XrmDatabase last_xrm_db; | |
| 199 | |
| 200 /* This will always be zero, nil or an actual coding system object, so no | |
| 201 need to worry about GCPROing it--it'll be protected from garbage | |
| 202 collection by means of Vcoding_system_hash_table in file-coding.c. */ | |
| 203 static Lisp_Object last_coding_system; | |
| 204 | |
| 205 if (db == last_xrm_db) | |
| 206 { | |
| 207 return last_coding_system; | |
| 208 } | |
| 209 | |
| 210 last_xrm_db = db; | |
| 211 | |
| 212 locale = XrmLocaleOfDatabase (db); | |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
213 localestr = build_extstring (locale, Qbinary); |
| 3707 | 214 last_coding_system = call1 (Qget_coding_system_from_locale, localestr); |
| 215 | |
| 216 return last_coding_system; | |
| 771 | 217 #else |
| 218 return Qbinary; | |
| 219 #endif | |
| 220 } | |
| 221 | |
| 428 | 222 |
| 223 /************************************************************************/ | |
| 224 /* initializing an X connection */ | |
| 225 /************************************************************************/ | |
| 226 | |
| 756 | 227 static struct device *device_being_initialized = NULL; |
| 228 | |
| 428 | 229 static void |
| 230 allocate_x_device_struct (struct device *d) | |
| 231 { | |
| 3092 | 232 #ifdef NEW_GC |
| 233 d->device_data = alloc_lrecord_type (struct x_device, &lrecord_x_device); | |
| 234 #else /* not NEW_GC */ | |
| 428 | 235 d->device_data = xnew_and_zero (struct x_device); |
| 3092 | 236 #endif /* not NEW_GC */ |
| 428 | 237 } |
| 238 | |
| 239 static void | |
| 240 Xatoms_of_device_x (struct device *d) | |
| 241 { | |
| 242 Display *D = DEVICE_X_DISPLAY (d); | |
| 243 | |
| 244 DEVICE_XATOM_WM_PROTOCOLS (d) = XInternAtom (D, "WM_PROTOCOLS", False); | |
| 245 DEVICE_XATOM_WM_DELETE_WINDOW(d) = XInternAtom (D, "WM_DELETE_WINDOW",False); | |
| 246 DEVICE_XATOM_WM_SAVE_YOURSELF(d) = XInternAtom (D, "WM_SAVE_YOURSELF",False); | |
| 247 DEVICE_XATOM_WM_TAKE_FOCUS (d) = XInternAtom (D, "WM_TAKE_FOCUS", False); | |
| 248 DEVICE_XATOM_WM_STATE (d) = XInternAtom (D, "WM_STATE", False); | |
| 249 } | |
| 250 | |
| 251 static void | |
| 252 sanity_check_geometry_resource (Display *dpy) | |
| 253 { | |
| 771 | 254 Extbyte *app_name, *app_class, *s; |
| 255 Extbyte buf1 [255], buf2 [255]; | |
| 256 Extbyte *type; | |
| 428 | 257 XrmValue value; |
| 258 XtGetApplicationNameAndClass (dpy, &app_name, &app_class); | |
| 259 strcpy (buf1, app_name); | |
| 260 strcpy (buf2, app_class); | |
| 261 for (s = buf1; *s; s++) if (*s == '.') *s = '_'; | |
| 262 strcat (buf1, "._no_._such_._resource_.geometry"); | |
| 263 strcat (buf2, "._no_._such_._resource_.Geometry"); | |
| 264 if (XrmGetResource (XtDatabase (dpy), buf1, buf2, &type, &value) == True) | |
| 265 { | |
| 867 | 266 Ibyte *app_name_int, *app_class_int, *value_addr_int; |
| 771 | 267 Lisp_Object codesys = coding_system_of_xrm_database (XtDatabase (dpy)); |
| 268 EXTERNAL_TO_C_STRING (app_name, app_name_int, codesys); | |
| 269 EXTERNAL_TO_C_STRING (app_class, app_class_int, codesys); | |
| 270 EXTERNAL_TO_C_STRING (value.addr, value_addr_int, codesys); | |
| 271 | |
| 428 | 272 warn_when_safe (Qgeometry, Qerror, |
| 273 "\n" | |
| 274 "Apparently \"%s*geometry: %s\" or \"%s*geometry: %s\" was\n" | |
| 275 "specified in the resource database. Specifying \"*geometry\" will make\n" | |
| 276 "XEmacs (and most other X programs) malfunction in obscure ways. (i.e.\n" | |
| 277 "the Xt or Xm libraries will probably crash, which is a very bad thing.)\n" | |
| 278 "You should always use \".geometry\" or \"*EmacsFrame.geometry\" instead.\n", | |
| 771 | 279 app_name_int, value_addr_int, |
| 280 app_class_int, value_addr_int); | |
| 428 | 281 suppress_early_error_handler_backtrace = 1; |
| 563 | 282 syntax_error ("Invalid geometry resource", Qunbound); |
| 428 | 283 } |
| 284 } | |
| 285 | |
| 286 static void | |
| 287 x_init_device_class (struct device *d) | |
| 288 { | |
| 289 if (DEVICE_X_DEPTH(d) > 2) | |
| 290 { | |
| 1204 | 291 switch (DEVICE_X_VISUAL(d)->X_CLASSFIELD) |
| 428 | 292 { |
| 293 case StaticGray: | |
| 294 case GrayScale: | |
| 295 DEVICE_CLASS (d) = Qgrayscale; | |
| 296 break; | |
| 297 default: | |
| 298 DEVICE_CLASS (d) = Qcolor; | |
| 299 } | |
| 300 } | |
| 301 else | |
| 302 DEVICE_CLASS (d) = Qmono; | |
| 303 } | |
| 304 | |
| 305 /* | |
| 306 * Figure out what application name to use for xemacs | |
| 307 * | |
| 308 * Since we have decomposed XtOpenDisplay into XOpenDisplay and | |
| 309 * XtDisplayInitialize, we no longer get this for free. | |
| 310 * | |
| 311 * If there is a `-name' argument in argv, use that. | |
| 312 * Otherwise use the last component of argv[0]. | |
| 313 * | |
| 314 * I have removed the gratuitous use of getenv("RESOURCE_NAME") | |
| 315 * which was in X11R5, but left the matching of any prefix of `-name'. | |
| 316 * Finally, if all else fails, return `xemacs', as it is more | |
| 317 * appropriate (X11R5 returns `main'). | |
| 318 */ | |
| 442 | 319 static Extbyte * |
| 320 compute_x_app_name (int argc, Extbyte **argv) | |
| 428 | 321 { |
| 322 int i; | |
| 442 | 323 Extbyte *ptr; |
| 428 | 324 |
| 325 for (i = 1; i < argc - 1; i++) | |
| 326 if (!strncmp(argv[i], "-name", max (2, strlen (argv[1])))) | |
| 327 return argv[i+1]; | |
| 328 | |
| 329 if (argc > 0 && argv[0] && *argv[0]) | |
| 330 return (ptr = strrchr (argv[0], '/')) ? ++ptr : argv[0]; | |
| 331 | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
332 return (Extbyte *) "xemacs"; /* shut up g++ 4.3 */ |
| 428 | 333 } |
| 334 | |
| 335 /* | |
| 336 * This function figures out whether the user has any resources of the | |
| 337 * form "XEmacs.foo" or "XEmacs*foo". | |
| 338 * | |
| 339 * Currently we only consult the display's global resources; to look | |
| 340 * for screen specific resources, we would need to also consult: | |
| 341 * xdefs = XScreenResourceString(ScreenOfDisplay(dpy, scrno)); | |
| 342 */ | |
| 343 static int | |
| 344 have_xemacs_resources_in_xrdb (Display *dpy) | |
| 345 { | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
346 const char *xdefs, *key; |
| 428 | 347 int len; |
| 348 | |
| 349 #ifdef INFODOCK | |
| 350 key = "InfoDock"; | |
| 351 #else | |
| 352 key = "XEmacs"; | |
| 353 #endif | |
| 354 len = strlen (key); | |
| 355 | |
| 356 if (!dpy) | |
| 357 return 0; | |
| 358 | |
| 359 xdefs = XResourceManagerString (dpy); /* don't free - owned by X */ | |
| 360 while (xdefs && *xdefs) | |
| 361 { | |
| 362 if (strncmp (xdefs, key, len) == 0 && | |
| 363 (xdefs[len] == '*' || xdefs[len] == '.')) | |
| 364 return 1; | |
| 365 | |
| 366 while (*xdefs && *xdefs++ != '\n') /* find start of next entry.. */ | |
| 367 ; | |
| 368 } | |
| 369 | |
| 370 return 0; | |
| 371 } | |
| 372 | |
| 373 /* Only the characters [-_A-Za-z0-9] are allowed in the individual | |
| 374 components of a resource. Convert invalid characters to `-' */ | |
| 375 | |
| 376 static char valid_resource_char_p[256]; | |
| 377 | |
| 378 static void | |
| 771 | 379 validify_resource_component (Extbyte *str, Bytecount len) |
| 428 | 380 { |
| 381 for (; len; len--, str++) | |
| 382 if (!valid_resource_char_p[(unsigned char) (*str)]) | |
| 383 *str = '-'; | |
| 384 } | |
| 385 | |
| 386 static void | |
| 771 | 387 Dynarr_add_validified_lisp_string (Extbyte_dynarr *cda, Lisp_Object str) |
| 428 | 388 { |
| 771 | 389 Bytecount len; |
| 390 Extbyte *data; | |
| 391 | |
| 392 TO_EXTERNAL_FORMAT (LISP_STRING, str, ALLOCA, (data, len), Qbinary); | |
| 393 Dynarr_add_many (cda, data, len); | |
| 394 validify_resource_component (Dynarr_atp (cda, Dynarr_length (cda) - len), | |
| 395 len); | |
| 428 | 396 } |
| 397 | |
| 398 #if 0 | |
| 399 /* compare visual info for qsorting */ | |
| 400 static int | |
| 401 x_comp_visual_info (const void *elem1, const void *elem2) | |
| 402 { | |
| 403 XVisualInfo *left, *right; | |
| 404 | |
| 405 left = (XVisualInfo *)elem1; | |
| 406 right = (XVisualInfo *)elem2; | |
| 407 | |
| 408 if ( left == NULL ) | |
| 409 return -1; | |
| 410 if ( right == NULL ) | |
| 411 return 1; | |
| 412 | |
| 771 | 413 if ( left->depth > right->depth ) |
| 428 | 414 return 1; |
| 771 | 415 else if ( left->depth == right->depth ) |
| 416 { | |
| 417 if ( left->colormap_size > right->colormap_size ) | |
| 418 return 1; | |
| 1204 | 419 if ( left->X_CLASSFIELD > right->X_CLASSFIELD ) |
| 771 | 420 return 1; |
| 1204 | 421 else if ( left->X_CLASSFIELD < right->X_CLASSFIELD ) |
| 771 | 422 return -1; |
| 423 else | |
| 424 return 0; | |
| 425 } | |
| 426 else | |
| 428 | 427 return -1; |
| 428 } | |
| 429 #endif /* if 0 */ | |
| 430 | |
| 431 #define XXX_IMAGE_LIBRARY_IS_SOMEWHAT_BROKEN | |
| 432 static Visual * | |
| 433 x_try_best_visual_class (Screen *screen, int scrnum, int visual_class) | |
| 434 { | |
| 435 Display *dpy = DisplayOfScreen (screen); | |
| 436 XVisualInfo vi_in; | |
| 437 XVisualInfo *vi_out = NULL; | |
| 438 int out_count; | |
| 439 | |
| 1204 | 440 vi_in.X_CLASSFIELD = visual_class; |
| 428 | 441 vi_in.screen = scrnum; |
| 442 vi_out = XGetVisualInfo (dpy, (VisualClassMask | VisualScreenMask), | |
| 443 &vi_in, &out_count); | |
| 444 if ( vi_out ) | |
| 445 { | |
| 446 int i, best; | |
| 447 Visual *visual; | |
| 448 for (i = 0, best = 0; i < out_count; i++) | |
| 449 /* It's better if it's deeper, or if it's the same depth with | |
| 450 more cells (does that ever happen? Well, it could...) | |
| 451 NOTE: don't allow pseudo color to get larger than 8! */ | |
| 452 if (((vi_out [i].depth > vi_out [best].depth) || | |
| 453 ((vi_out [i].depth == vi_out [best].depth) && | |
| 454 (vi_out [i].colormap_size > vi_out [best].colormap_size))) | |
| 455 #ifdef XXX_IMAGE_LIBRARY_IS_SOMEWHAT_BROKEN | |
| 456 /* For now, the image library doesn't like PseudoColor visuals | |
| 457 of depths other than 1 or 8. Depths greater than 8 only occur | |
| 458 on machines which have TrueColor anyway, so probably we'll end | |
| 459 up using that (it is the one that `Best' would pick) but if a | |
| 460 PseudoColor visual is explicitly specified, pick the 8 bit one. | |
| 461 */ | |
| 462 && (visual_class != PseudoColor || | |
| 463 vi_out [i].depth == 1 || | |
| 464 vi_out [i].depth == 8) | |
| 465 #endif | |
| 466 | |
| 467 /* SGI has 30-bit deep visuals. Ignore them. | |
| 468 (We only have 24-bit data anyway.) | |
| 469 */ | |
| 470 && (vi_out [i].depth <= 24) | |
| 471 ) | |
| 472 best = i; | |
| 473 visual = vi_out[best].visual; | |
| 474 XFree ((char *) vi_out); | |
| 475 return visual; | |
| 476 } | |
| 477 else | |
| 478 return 0; | |
| 479 } | |
| 480 | |
| 481 static int | |
| 482 x_get_visual_depth (Display *dpy, Visual *visual) | |
| 483 { | |
| 484 XVisualInfo vi_in; | |
| 485 XVisualInfo *vi_out; | |
| 486 int out_count, d; | |
| 487 | |
| 488 vi_in.visualid = XVisualIDFromVisual (visual); | |
| 489 vi_out = XGetVisualInfo (dpy, /*VisualScreenMask|*/VisualIDMask, | |
| 490 &vi_in, &out_count); | |
| 2500 | 491 if (! vi_out) ABORT (); |
| 428 | 492 d = vi_out [0].depth; |
| 493 XFree ((char *) vi_out); | |
| 494 return d; | |
| 495 } | |
| 496 | |
| 497 static Visual * | |
| 498 x_try_best_visual (Display *dpy, int scrnum) | |
| 499 { | |
| 500 Visual *visual = NULL; | |
| 501 Screen *screen = ScreenOfDisplay (dpy, scrnum); | |
| 502 if ((visual = x_try_best_visual_class (screen, scrnum, TrueColor)) | |
| 503 && x_get_visual_depth (dpy, visual) >= 16 ) | |
| 504 return visual; | |
| 505 if ((visual = x_try_best_visual_class (screen, scrnum, PseudoColor))) | |
| 506 return visual; | |
| 507 if ((visual = x_try_best_visual_class (screen, scrnum, TrueColor))) | |
| 508 return visual; | |
| 509 #ifdef DIRECTCOLOR_WORKS | |
| 510 if ((visual = x_try_best_visual_class (screen, scrnum, DirectColor))) | |
| 511 return visual; | |
| 512 #endif | |
| 513 | |
| 514 visual = DefaultVisualOfScreen (screen); | |
| 515 if ( x_get_visual_depth (dpy, visual) >= 8 ) | |
| 516 return visual; | |
| 517 | |
| 518 if ((visual = x_try_best_visual_class (screen, scrnum, StaticGray))) | |
| 519 return visual; | |
| 520 if ((visual = x_try_best_visual_class (screen, scrnum, GrayScale))) | |
| 521 return visual; | |
| 522 return DefaultVisualOfScreen (screen); | |
| 523 } | |
| 524 | |
| 525 | |
| 526 static void | |
| 2286 | 527 x_init_device (struct device *d, Lisp_Object UNUSED (props)) |
| 428 | 528 { |
| 2367 | 529 /* !!#### */ |
| 428 | 530 Lisp_Object display; |
| 531 Display *dpy; | |
| 532 Widget app_shell; | |
| 533 int argc; | |
| 442 | 534 Extbyte **argv; |
| 535 const char *app_class; | |
| 536 const char *app_name; | |
| 537 const char *disp_name; | |
| 428 | 538 Visual *visual = NULL; |
| 539 int depth = 8; /* shut up the compiler */ | |
| 540 Colormap cmap; | |
| 541 int screen; | |
| 542 /* */ | |
| 543 int best_visual_found = 0; | |
| 544 | |
|
4477
e34711681f30
Don't determine whether to call general device-type code at startup,
Aidan Kehoe <kehoea@parhasard.net>
parents:
4404
diff
changeset
|
545 /* Run the elisp side of the X device initialization, allowing it to set |
|
e34711681f30
Don't determine whether to call general device-type code at startup,
Aidan Kehoe <kehoea@parhasard.net>
parents:
4404
diff
changeset
|
546 x-emacs-application-class and x-app-defaults-directory. */ |
|
e34711681f30
Don't determine whether to call general device-type code at startup,
Aidan Kehoe <kehoea@parhasard.net>
parents:
4404
diff
changeset
|
547 call0 (Qmake_device_early_x_entry_point); |
|
e34711681f30
Don't determine whether to call general device-type code at startup,
Aidan Kehoe <kehoea@parhasard.net>
parents:
4404
diff
changeset
|
548 |
| 442 | 549 #if defined(HAVE_SHLIB) && defined(LWLIB_USES_ATHENA) && !defined(HAVE_ATHENA_3D) |
| 440 | 550 /* |
| 551 * In order to avoid the lossage with flat Athena widgets dynamically | |
| 552 * linking to one of the ThreeD variants, using the dynamic symbol helpers | |
| 553 * to look for symbols that shouldn't be there and refusing to run if they | |
| 554 * are seems a less toxic idea than having XEmacs crash when we try and | |
| 555 * use a subclass of a widget that has changed size. | |
| 556 * | |
| 557 * It's ugly, I know, and not going to work everywhere. It seems better to | |
| 558 * do our damnedest to try and tell the user what to expect rather than | |
| 559 * simply blow up though. | |
| 560 * | |
| 561 * All the ThreeD variants I have access to define the following function | |
| 562 * symbols in the shared library. The flat Xaw library does not define them: | |
| 563 * | |
| 564 * Xaw3dComputeBottomShadowRGB | |
| 565 * Xaw3dComputeTopShadowRGB | |
| 566 * | |
| 567 * So far only Linux has shown this problem. This seems to be portable to | |
| 568 * all the distributions (certainly all the ones I checked - Debian and | |
| 569 * Redhat) | |
| 570 * | |
| 571 * This will only work, sadly, with dlopen() -- the other dynamic linkers | |
| 572 * are simply not capable of doing what is needed. :/ | |
| 573 */ | |
| 574 | |
| 575 { | |
| 576 /* Get a dll handle to the main process. */ | |
| 1706 | 577 dll_handle xaw_dll_handle = dll_open (Qnil); |
| 440 | 578 |
| 579 /* Did that fail? If so, continue without error. | |
| 580 * We could die here but, well, that's unfriendly and all -- plus I feel | |
| 581 * better about some crashing somewhere rather than preventing a perfectly | |
| 582 * good configuration working just because dll_open failed. | |
| 583 */ | |
| 584 if (xaw_dll_handle != NULL) | |
| 585 { | |
| 586 /* Look for the Xaw3d function */ | |
| 587 dll_func xaw_function_handle = | |
|
4956
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
588 dll_function (xaw_dll_handle, |
|
3461165c79be
fix compile errors due to mismatched string pointer types
Ben Wing <ben@xemacs.org>
parents:
4953
diff
changeset
|
589 (const Ibyte *) "Xaw3dComputeTopShadowRGB"); |
| 440 | 590 |
| 591 /* If we found it, warn the user in big, nasty, unfriendly letters */ | |
| 592 if (xaw_function_handle != NULL) | |
| 593 { | |
| 793 | 594 warn_when_safe (Qdevice, Qcritical, "\n" |
| 440 | 595 "It seems that XEmacs is built dynamically linked to the flat Athena widget\n" |
| 596 "library but it finds a 3D Athena variant with the same name at runtime.\n" | |
| 597 "\n" | |
| 598 "This WILL cause your XEmacs process to dump core at some point.\n" | |
| 599 "You should not continue to use this binary without resolving this issue.\n" | |
| 600 "\n" | |
| 601 "This can be solved with the xaw-wrappers package under Debian\n" | |
| 602 "(register XEmacs as incompatible with all 3d widget sets, see\n" | |
| 603 "update-xaw-wrappers(8) and .../doc/xaw-wrappers/README.packagers). It\n" | |
| 604 "can be verified by checking the runtime path in /etc/ld.so.conf and by\n" | |
| 605 "using `ldd /path/to/xemacs' under other Linux distributions. One\n" | |
| 606 "solution is to use LD_PRELOAD or LD_LIBRARY_PATH to force ld.so to\n" | |
| 607 "load the flat Athena widget library instead of the aliased 3D widget\n" | |
| 608 "library (see ld.so(8) for use of these environment variables).\n\n" | |
| 609 ); | |
| 610 | |
| 611 } | |
| 612 | |
| 613 /* Otherwise release the handle to the library | |
| 614 * No error catch here; I can't think of a way to recover anyhow. | |
| 615 */ | |
| 616 dll_close (xaw_dll_handle); | |
| 617 } | |
| 618 } | |
| 442 | 619 #endif /* HAVE_SHLIB and LWLIB_USES_ATHENA and not HAVE_ATHENA_3D */ |
| 440 | 620 |
| 428 | 621 display = DEVICE_CONNECTION (d); |
| 622 | |
| 623 allocate_x_device_struct (d); | |
| 624 | |
| 625 make_argc_argv (Vx_initial_argv_list, &argc, &argv); | |
| 626 | |
| 442 | 627 LISP_STRING_TO_EXTERNAL (display, disp_name, Qctext); |
| 428 | 628 |
| 629 /* | |
| 630 * Break apart the old XtOpenDisplay call into XOpenDisplay and | |
| 631 * XtDisplayInitialize so we can figure out whether there | |
| 632 * are any XEmacs resources in the resource database before | |
| 633 * we initialize Xt. This is so we can automagically support | |
| 634 * both `Emacs' and `XEmacs' application classes. | |
| 635 */ | |
| 636 slow_down_interrupts (); | |
| 637 /* May not be needed but XtOpenDisplay could not deal with signals here. */ | |
| 756 | 638 device_being_initialized = d; |
| 428 | 639 dpy = DEVICE_X_DISPLAY (d) = XOpenDisplay (disp_name); |
| 756 | 640 device_being_initialized = NULL; |
| 428 | 641 speed_up_interrupts (); |
| 642 | |
| 643 if (dpy == 0) | |
| 644 { | |
| 645 suppress_early_error_handler_backtrace = 1; | |
| 563 | 646 gui_error ("X server not responding\n", display); |
| 428 | 647 } |
| 648 | |
| 649 if (STRINGP (Vx_emacs_application_class) && | |
| 650 XSTRING_LENGTH (Vx_emacs_application_class) > 0) | |
| 442 | 651 LISP_STRING_TO_EXTERNAL (Vx_emacs_application_class, app_class, Qctext); |
| 428 | 652 else |
| 653 { | |
| 2681 | 654 if (egetenv ("USE_EMACS_AS_DEFAULT_APPLICATION_CLASS")) |
| 655 { | |
| 656 app_class = (NILP (Vx_emacs_application_class) && | |
| 657 have_xemacs_resources_in_xrdb (dpy)) | |
| 428 | 658 #ifdef INFODOCK |
| 2681 | 659 ? "InfoDock" |
| 428 | 660 #else |
| 2681 | 661 ? "XEmacs" |
| 428 | 662 #endif |
| 2681 | 663 : "Emacs"; |
| 664 } | |
| 665 else | |
| 666 { | |
| 667 app_class = "XEmacs"; | |
| 668 } | |
| 669 | |
| 428 | 670 /* need to update Vx_emacs_application_class: */ |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
671 Vx_emacs_application_class = build_cistring (app_class); |
| 428 | 672 } |
| 673 | |
| 674 slow_down_interrupts (); | |
| 675 /* May not be needed but XtOpenDisplay could not deal with signals here. | |
| 676 Yuck. */ | |
| 677 XtDisplayInitialize (Xt_app_con, dpy, compute_x_app_name (argc, argv), | |
| 678 app_class, emacs_options, | |
| 442 | 679 XtNumber (emacs_options), &argc, (char **) argv); |
| 428 | 680 speed_up_interrupts (); |
| 681 | |
| 682 screen = DefaultScreen (dpy); | |
| 683 | |
| 684 #ifdef MULE | |
| 685 { | |
| 686 /* Read in locale-specific resources from | |
| 687 data-directory/app-defaults/$LANG/Emacs. | |
| 688 This is in addition to the standard app-defaults files, and | |
| 689 does not override resources defined elsewhere */ | |
| 771 | 690 const Extbyte *data_dir; |
| 691 Extbyte *path; | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
692 const Extbyte *format; |
| 428 | 693 XrmDatabase db = XtDatabase (dpy); /* #### XtScreenDatabase(dpy) ? */ |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
694 const Extbyte *locale = xstrdup (XrmLocaleOfDatabase (db)); |
| 3644 | 695 Extbyte *locale_end; |
| 428 | 696 |
| 697 if (STRINGP (Vx_app_defaults_directory) && | |
| 698 XSTRING_LENGTH (Vx_app_defaults_directory) > 0) | |
| 699 { | |
| 771 | 700 LISP_STRING_TO_EXTERNAL (Vx_app_defaults_directory, data_dir, |
| 701 Qfile_name); | |
| 2367 | 702 path = alloca_extbytes (strlen (data_dir) + strlen (locale) + 7); |
| 3644 | 703 format = "%s%s/Emacs"; |
| 428 | 704 } |
| 705 else if (STRINGP (Vdata_directory) && XSTRING_LENGTH (Vdata_directory) > 0) | |
| 706 { | |
| 442 | 707 LISP_STRING_TO_EXTERNAL (Vdata_directory, data_dir, Qfile_name); |
| 2367 | 708 path = alloca_extbytes (strlen (data_dir) + 13 + strlen (locale) + 7); |
| 3644 | 709 format = "%sapp-defaults/%s/Emacs"; |
| 428 | 710 } |
|
4404
80e07b006f9c
Prevent access to uninitialized variables in x_init_device.
Jerry James <james@xemacs.org>
parents:
4117
diff
changeset
|
711 else |
|
80e07b006f9c
Prevent access to uninitialized variables in x_init_device.
Jerry James <james@xemacs.org>
parents:
4117
diff
changeset
|
712 { |
|
80e07b006f9c
Prevent access to uninitialized variables in x_init_device.
Jerry James <james@xemacs.org>
parents:
4117
diff
changeset
|
713 goto no_data_directory; |
|
80e07b006f9c
Prevent access to uninitialized variables in x_init_device.
Jerry James <james@xemacs.org>
parents:
4117
diff
changeset
|
714 } |
| 3644 | 715 |
| 716 /* | |
| 717 * The general form for $LANG is <language>_<country>.<encoding>. Try | |
| 718 * that form, <language>_<country> and <language> and load for first | |
| 719 * app-defaults file found. | |
| 720 */ | |
| 721 | |
| 722 sprintf (path, format, data_dir, locale); | |
| 723 if (!access (path, R_OK)) | |
| 724 XrmCombineFileDatabase (path, &db, False); | |
| 725 | |
| 726 if ((locale_end = strchr(locale, '.'))) { | |
| 727 *locale_end = '\0'; | |
| 728 sprintf (path, format, data_dir, locale); | |
| 729 | |
| 730 if (!access (path, R_OK)) | |
| 731 XrmCombineFileDatabase (path, &db, False); | |
| 732 } | |
| 733 | |
| 734 if ((locale_end = strchr(locale, '_'))) { | |
| 735 *locale_end = '\0'; | |
| 736 sprintf (path, format, data_dir, locale); | |
| 737 | |
| 738 if (!access (path, R_OK)) | |
| 739 XrmCombineFileDatabase (path, &db, False); | |
| 740 } | |
| 741 | |
|
4404
80e07b006f9c
Prevent access to uninitialized variables in x_init_device.
Jerry James <james@xemacs.org>
parents:
4117
diff
changeset
|
742 no_data_directory: |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
743 { |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
744 /* Cast off const for G++ 4.3. */ |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
745 Extbyte *temp = (Extbyte *) locale; |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
746 xfree (temp); |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
747 } |
| 428 | 748 } |
| 749 #endif /* MULE */ | |
| 750 | |
| 751 if (NILP (DEVICE_NAME (d))) | |
| 752 DEVICE_NAME (d) = display; | |
| 753 | |
| 754 /* We're going to modify the string in-place, so be a nice XEmacs */ | |
| 755 DEVICE_NAME (d) = Fcopy_sequence (DEVICE_NAME (d)); | |
| 756 /* colons and periods can't appear in individual elements of resource | |
| 757 strings */ | |
| 758 | |
| 759 XtGetApplicationNameAndClass (dpy, (char **) &app_name, (char **) &app_class); | |
| 760 /* search for a matching visual if requested by the user, or setup the display default */ | |
| 761 { | |
| 762 int resource_name_length = max (sizeof (".emacsVisual"), | |
| 763 sizeof (".privateColormap")); | |
| 764 char *buf1 = alloca_array (char, strlen (app_name) + resource_name_length); | |
| 765 char *buf2 = alloca_array (char, strlen (app_class) + resource_name_length); | |
| 766 char *type; | |
| 767 XrmValue value; | |
| 768 | |
| 769 sprintf (buf1, "%s.emacsVisual", app_name); | |
| 770 sprintf (buf2, "%s.EmacsVisual", app_class); | |
| 771 if (XrmGetResource (XtDatabase (dpy), buf1, buf2, &type, &value) == True) | |
| 772 { | |
| 773 int cnt = 0; | |
| 774 int vis_class = PseudoColor; | |
| 775 XVisualInfo vinfo; | |
| 776 char *str = (char*) value.addr; | |
| 777 | |
| 778 #define CHECK_VIS_CLASS(visual_class) \ | |
| 779 else if (memcmp (str, #visual_class, sizeof (#visual_class) - 1) == 0) \ | |
| 780 cnt = sizeof (#visual_class) - 1, vis_class = visual_class | |
| 781 | |
| 782 if (1) | |
| 783 ; | |
| 784 CHECK_VIS_CLASS (StaticGray); | |
| 785 CHECK_VIS_CLASS (StaticColor); | |
| 786 CHECK_VIS_CLASS (TrueColor); | |
| 787 CHECK_VIS_CLASS (GrayScale); | |
| 788 CHECK_VIS_CLASS (PseudoColor); | |
| 789 CHECK_VIS_CLASS (DirectColor); | |
| 790 | |
| 791 if (cnt) | |
| 792 { | |
| 793 depth = atoi (str + cnt); | |
| 794 if (depth == 0) | |
| 795 { | |
| 771 | 796 stderr_out ("Invalid Depth specification in %s... " |
| 797 "ignoring...\n", str); | |
| 428 | 798 } |
| 799 else | |
| 800 { | |
| 801 if (XMatchVisualInfo (dpy, screen, depth, vis_class, &vinfo)) | |
| 802 { | |
| 803 visual = vinfo.visual; | |
| 804 } | |
| 805 else | |
| 806 { | |
| 771 | 807 stderr_out ("Can't match the requested visual %s... " |
| 808 "using defaults\n", str); | |
| 428 | 809 } |
| 810 } | |
| 811 } | |
| 812 else | |
| 813 { | |
| 771 | 814 stderr_out ("Invalid Visual specification in %s... " |
| 815 "ignoring.\n", str); | |
| 428 | 816 } |
| 817 } | |
| 818 if (visual == NULL) | |
| 819 { | |
| 820 /* | |
| 821 visual = DefaultVisual(dpy, screen); | |
| 822 depth = DefaultDepth(dpy, screen); | |
| 823 */ | |
| 824 visual = x_try_best_visual (dpy, screen); | |
| 825 depth = x_get_visual_depth (dpy, visual); | |
| 826 best_visual_found = (visual != DefaultVisual (dpy, screen)); | |
| 827 } | |
| 828 | |
| 829 /* If we've got the same visual as the default and it's PseudoColor, | |
| 830 check to see if the user specified that we need a private colormap */ | |
| 831 if (visual == DefaultVisual (dpy, screen)) | |
| 832 { | |
| 833 sprintf (buf1, "%s.privateColormap", app_name); | |
| 834 sprintf (buf2, "%s.PrivateColormap", app_class); | |
| 1204 | 835 if ((visual->X_CLASSFIELD == PseudoColor) && |
| 771 | 836 (XrmGetResource (XtDatabase (dpy), buf1, buf2, &type, &value) |
| 837 == True)) | |
| 838 cmap = XCopyColormapAndFree (dpy, DefaultColormap (dpy, screen)); | |
| 428 | 839 else |
| 771 | 840 cmap = DefaultColormap (dpy, screen); |
| 428 | 841 } |
| 842 else | |
| 843 { | |
| 844 if ( best_visual_found ) | |
| 771 | 845 cmap = XCreateColormap (dpy, RootWindow (dpy, screen), visual, |
| 846 AllocNone); | |
| 428 | 847 else |
| 848 { | |
| 771 | 849 /* We have to create a matching colormap anyway... #### |
| 850 think about using standard colormaps (need the Xmu | |
| 851 libs?) */ | |
| 852 cmap = XCreateColormap (dpy, RootWindow (dpy, screen), visual, | |
| 853 AllocNone); | |
| 854 XInstallColormap (dpy, cmap); | |
| 428 | 855 } |
| 856 } | |
| 857 } | |
| 858 | |
| 859 DEVICE_X_VISUAL (d) = visual; | |
| 860 DEVICE_X_COLORMAP (d) = cmap; | |
| 861 DEVICE_X_DEPTH (d) = depth; | |
| 862 validify_resource_component ((char *) XSTRING_DATA (DEVICE_NAME (d)), | |
| 863 XSTRING_LENGTH (DEVICE_NAME (d))); | |
| 864 | |
| 2007 | 865 /* #### If we're going to implement X session management, this would |
| 866 be the place. Make sure it doesn't conflict with GNOME. */ | |
| 428 | 867 { |
| 868 Arg al[3]; | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
869 Xt_SET_ARG (al[0], XtNvisual, visual); |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
870 Xt_SET_ARG (al[1], XtNdepth, depth); |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
871 Xt_SET_ARG (al[2], XtNcolormap, cmap); |
| 428 | 872 |
| 873 app_shell = XtAppCreateShell (NULL, app_class, | |
| 874 applicationShellWidgetClass, | |
| 875 dpy, al, countof (al)); | |
| 876 } | |
| 877 | |
| 878 DEVICE_XT_APP_SHELL (d) = app_shell; | |
| 879 | |
| 880 #ifdef HAVE_XIM | |
| 881 XIM_init_device(d); | |
| 882 #endif /* HAVE_XIM */ | |
| 883 | |
| 884 /* Realize the app_shell so that its window exists for GC creation purposes, | |
| 885 and set it to the size of the root window for child placement purposes */ | |
| 886 { | |
| 887 Arg al[5]; | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
888 Xt_SET_ARG (al[0], XtNmappedWhenManaged, False); |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
889 Xt_SET_ARG (al[1], XtNx, 0); |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
890 Xt_SET_ARG (al[2], XtNy, 0); |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
891 Xt_SET_ARG (al[3], XtNwidth, |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
892 WidthOfScreen (ScreenOfDisplay (dpy, screen))); |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
893 Xt_SET_ARG (al[4], XtNheight, |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
894 HeightOfScreen (ScreenOfDisplay (dpy, screen))); |
| 428 | 895 XtSetValues (app_shell, al, countof (al)); |
| 896 XtRealizeWidget (app_shell); | |
| 897 } | |
| 898 | |
| 899 #ifdef HAVE_WMCOMMAND | |
| 900 { | |
| 901 int new_argc; | |
| 442 | 902 Extbyte **new_argv; |
| 428 | 903 make_argc_argv (Vcommand_line_args, &new_argc, &new_argv); |
| 442 | 904 XSetCommand (XtDisplay (app_shell), XtWindow (app_shell), |
| 905 (char **) new_argv, new_argc); | |
| 428 | 906 free_argc_argv (new_argv); |
| 907 } | |
| 908 #endif /* HAVE_WMCOMMAND */ | |
| 909 | |
| 910 Vx_initial_argv_list = make_arg_list (argc, argv); | |
| 911 free_argc_argv (argv); | |
| 912 | |
| 913 DEVICE_X_WM_COMMAND_FRAME (d) = Qnil; | |
| 914 | |
| 915 sanity_check_geometry_resource (dpy); | |
| 916 | |
| 917 /* In event-Xt.c */ | |
| 918 x_init_modifier_mapping (d); | |
| 919 | |
| 920 DEVICE_INFD (d) = DEVICE_OUTFD (d) = ConnectionNumber (dpy); | |
| 921 init_baud_rate (d); | |
| 922 init_one_device (d); | |
| 923 | |
| 771 | 924 DEVICE_X_GC_CACHE (d) = make_gc_cache (dpy, XtWindow (app_shell)); |
| 428 | 925 DEVICE_X_GRAY_PIXMAP (d) = None; |
| 926 Xatoms_of_device_x (d); | |
| 440 | 927 Xatoms_of_select_x (d); |
| 428 | 928 Xatoms_of_objects_x (d); |
| 929 x_init_device_class (d); | |
| 930 } | |
| 931 | |
| 932 static void | |
|
4477
e34711681f30
Don't determine whether to call general device-type code at startup,
Aidan Kehoe <kehoea@parhasard.net>
parents:
4404
diff
changeset
|
933 x_finish_init_device (struct device *d, Lisp_Object UNUSED (props)) |
| 428 | 934 { |
|
4477
e34711681f30
Don't determine whether to call general device-type code at startup,
Aidan Kehoe <kehoea@parhasard.net>
parents:
4404
diff
changeset
|
935 call1 (Qmake_device_late_x_entry_point, wrap_device (d)); |
| 428 | 936 } |
| 937 | |
| 938 static void | |
| 939 x_mark_device (struct device *d) | |
| 940 { | |
| 941 mark_object (DEVICE_X_WM_COMMAND_FRAME (d)); | |
| 942 mark_object (DEVICE_X_DATA (d)->x_keysym_map_hash_table); | |
| 943 } | |
| 944 | |
| 945 | |
| 946 /************************************************************************/ | |
| 947 /* closing an X connection */ | |
| 948 /************************************************************************/ | |
| 949 | |
| 4117 | 950 #ifndef NEW_GC |
| 428 | 951 static void |
| 952 free_x_device_struct (struct device *d) | |
| 953 { | |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
954 xfree (d->device_data); |
| 4117 | 955 } |
| 3092 | 956 #endif /* not NEW_GC */ |
| 428 | 957 |
| 958 static void | |
| 959 x_delete_device (struct device *d) | |
| 960 { | |
| 961 Display *display; | |
| 962 #ifdef FREE_CHECKING | |
| 963 extern void (*__free_hook) (void *); | |
| 964 int checking_free; | |
| 965 #endif | |
| 966 | |
| 967 display = DEVICE_X_DISPLAY (d); | |
| 968 | |
| 969 if (display) | |
| 970 { | |
| 971 #ifdef FREE_CHECKING | |
| 972 checking_free = (__free_hook != 0); | |
| 973 | |
| 974 /* Disable strict free checking, to avoid bug in X library */ | |
| 975 if (checking_free) | |
| 976 disable_strict_free_check (); | |
| 977 #endif | |
| 978 | |
| 979 free_gc_cache (DEVICE_X_GC_CACHE (d)); | |
| 980 if (DEVICE_X_DATA (d)->x_modifier_keymap) | |
| 981 XFreeModifiermap (DEVICE_X_DATA (d)->x_modifier_keymap); | |
| 982 if (DEVICE_X_DATA (d)->x_keysym_map) | |
| 983 XFree ((char *) DEVICE_X_DATA (d)->x_keysym_map); | |
| 984 | |
| 985 if (DEVICE_XT_APP_SHELL (d)) | |
| 986 { | |
| 987 XtDestroyWidget (DEVICE_XT_APP_SHELL (d)); | |
| 988 DEVICE_XT_APP_SHELL (d) = NULL; | |
| 989 } | |
| 990 | |
| 991 XtCloseDisplay (display); | |
| 992 DEVICE_X_DISPLAY (d) = 0; | |
| 993 #ifdef FREE_CHECKING | |
| 994 if (checking_free) | |
| 995 enable_strict_free_check (); | |
| 996 #endif | |
| 997 } | |
| 998 | |
| 4117 | 999 #ifndef NEW_GC |
| 428 | 1000 free_x_device_struct (d); |
| 4117 | 1001 #endif /* not NEW_GC */ |
| 428 | 1002 } |
| 1003 | |
| 1004 | |
| 1005 /************************************************************************/ | |
| 1006 /* handle X errors */ | |
| 1007 /************************************************************************/ | |
| 1008 | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4834
diff
changeset
|
1009 const Ascbyte * |
| 428 | 1010 x_event_name (int event_type) |
| 1011 { | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4834
diff
changeset
|
1012 static const Ascbyte *events[] = |
| 428 | 1013 { |
| 1014 "0: ERROR!", | |
| 1015 "1: REPLY", | |
| 1016 "KeyPress", | |
| 1017 "KeyRelease", | |
| 1018 "ButtonPress", | |
| 1019 "ButtonRelease", | |
| 1020 "MotionNotify", | |
| 1021 "EnterNotify", | |
| 1022 "LeaveNotify", | |
| 1023 "FocusIn", | |
| 1024 "FocusOut", | |
| 1025 "KeymapNotify", | |
| 1026 "Expose", | |
| 1027 "GraphicsExpose", | |
| 1028 "NoExpose", | |
| 1029 "VisibilityNotify", | |
| 1030 "CreateNotify", | |
| 1031 "DestroyNotify", | |
| 1032 "UnmapNotify", | |
| 1033 "MapNotify", | |
| 1034 "MapRequest", | |
| 1035 "ReparentNotify", | |
| 1036 "ConfigureNotify", | |
| 1037 "ConfigureRequest", | |
| 1038 "GravityNotify", | |
| 1039 "ResizeRequest", | |
| 1040 "CirculateNotify", | |
| 1041 "CirculateRequest", | |
| 1042 "PropertyNotify", | |
| 1043 "SelectionClear", | |
| 1044 "SelectionRequest", | |
| 1045 "SelectionNotify", | |
| 1046 "ColormapNotify", | |
| 1047 "ClientMessage", | |
| 1048 "MappingNotify", | |
| 1049 "LASTEvent" | |
| 1050 }; | |
| 1051 | |
| 1052 if (event_type < 0 || event_type >= countof (events)) | |
| 1053 return NULL; | |
| 1054 return events [event_type]; | |
| 1055 } | |
| 1056 | |
| 1057 /* Handling errors. | |
| 1058 | |
| 1059 If an X error occurs which we are not expecting, we have no alternative | |
| 1060 but to print it to stderr. It would be nice to stuff it into a pop-up | |
| 1061 buffer, or to print it in the minibuffer, but that's not possible, because | |
| 1062 one is not allowed to do any I/O on the display connection from an error | |
| 1063 handler. The guts of Xlib expect these functions to either return or exit. | |
| 1064 | |
| 1065 However, there are occasions when we might expect an error to reasonably | |
| 1066 occur. The interface to this is as follows: | |
| 1067 | |
| 1068 Before calling some X routine which may error, call | |
| 1069 expect_x_error (dpy); | |
| 1070 | |
| 1071 Just after calling the X routine, call either: | |
| 1072 | |
| 1073 x_error_occurred_p (dpy); | |
| 1074 | |
| 1075 to ask whether an error happened (and was ignored), or: | |
| 1076 | |
| 1077 signal_if_x_error (dpy, resumable_p); | |
| 1078 | |
| 1079 which will call Fsignal() with args appropriate to the X error, if there | |
| 1080 was one. (Resumable_p is whether the debugger should be allowed to | |
| 1081 continue from the call to signal.) | |
| 1082 | |
| 1083 You must call one of these two routines immediately after calling the X | |
| 1084 routine; think of them as bookends like BLOCK_INPUT and UNBLOCK_INPUT. | |
| 1085 */ | |
| 1086 | |
| 1087 static int error_expected; | |
| 1088 static int error_occurred; | |
| 1089 static XErrorEvent last_error; | |
| 1090 | |
| 1091 /* OVERKILL! */ | |
| 1092 | |
| 1093 #ifdef EXTERNAL_WIDGET | |
| 1094 static Lisp_Object | |
| 1095 x_error_handler_do_enqueue (Lisp_Object frame) | |
| 1096 { | |
| 1097 enqueue_magic_eval_event (io_error_delete_frame, frame); | |
| 1098 return Qt; | |
| 1099 } | |
| 1100 | |
| 1101 static Lisp_Object | |
| 2333 | 1102 x_error_handler_error (Lisp_Object UNUSED (data), Lisp_Object UNUSED (dummy)) |
| 428 | 1103 { |
| 1104 return Qnil; | |
| 1105 } | |
| 1106 #endif /* EXTERNAL_WIDGET */ | |
| 1107 | |
| 1108 int | |
| 1109 x_error_handler (Display *disp, XErrorEvent *event) | |
| 1110 { | |
| 1111 if (error_expected) | |
| 1112 { | |
| 1113 error_expected = 0; | |
| 1114 error_occurred = 1; | |
| 1115 last_error = *event; | |
| 1116 } | |
| 1117 else | |
| 1118 { | |
| 853 | 1119 int depth; |
| 1120 | |
| 428 | 1121 #ifdef EXTERNAL_WIDGET |
| 1122 struct frame *f; | |
| 1123 struct device *d = get_device_from_display (disp); | |
| 1124 | |
| 1125 if ((event->error_code == BadWindow || | |
| 1126 event->error_code == BadDrawable) | |
| 1127 && ((f = x_any_window_to_frame (d, event->resourceid)) != 0)) | |
| 1128 { | |
| 1129 Lisp_Object frame; | |
| 1130 | |
| 1131 /* one of the windows comprising one of our frames has died. | |
| 1132 This occurs particularly with ExternalShell frames when the | |
| 1133 client that owns the ExternalShell's window dies. | |
| 1134 | |
| 1135 We cannot do any I/O on the display connection so we need | |
| 1136 to enqueue an eval event so that the deletion happens | |
| 1137 later. | |
| 1138 | |
| 1139 Furthermore, we need to trap any errors (out-of-memory) that | |
| 1140 may occur when Fenqueue_eval_event is called. | |
| 1141 */ | |
| 1142 | |
| 1143 if (f->being_deleted) | |
| 1144 return 0; | |
| 793 | 1145 frame = wrap_frame (f); |
| 428 | 1146 if (!NILP (condition_case_1 (Qerror, x_error_handler_do_enqueue, |
| 1147 frame, x_error_handler_error, Qnil))) | |
| 1148 { | |
| 1149 f->being_deleted = 1; | |
| 1150 f->visible = 0; | |
| 1151 } | |
| 1152 return 0; | |
| 1153 } | |
| 1154 #endif /* EXTERNAL_WIDGET */ | |
| 1155 | |
| 853 | 1156 /* #### this should issue a warning instead of outputting to stderr */ |
| 1157 depth = begin_dont_check_for_quit (); | |
| 2007 | 1158 #if 0 |
| 1159 /* This ends up calling X, which isn't allowed in an X error handler | |
| 1160 */ | |
| 428 | 1161 stderr_out ("\n%s: ", |
| 1162 (STRINGP (Vinvocation_name) | |
| 1163 ? (char *) XSTRING_DATA (Vinvocation_name) | |
| 1164 : "xemacs")); | |
| 2007 | 1165 #endif |
| 428 | 1166 XmuPrintDefaultErrorMessage (disp, event, stderr); |
| 853 | 1167 unbind_to (depth); |
| 428 | 1168 } |
| 1169 return 0; | |
| 1170 } | |
| 1171 | |
| 1172 void | |
| 1173 expect_x_error (Display *dpy) | |
| 1174 { | |
| 1175 assert (!error_expected); | |
| 1176 XSync (dpy, 0); /* handle pending errors before setting flag */ | |
| 1177 error_expected = 1; | |
| 1178 error_occurred = 0; | |
| 1179 } | |
| 1180 | |
| 1181 int | |
| 1182 x_error_occurred_p (Display *dpy) | |
| 1183 { | |
| 1184 int val; | |
| 1185 XSync (dpy, 0); /* handle pending errors before setting flag */ | |
| 1186 val = error_occurred; | |
| 1187 error_expected = 0; | |
| 1188 error_occurred = 0; | |
| 1189 return val; | |
| 1190 } | |
| 1191 | |
| 1192 int | |
| 1193 signal_if_x_error (Display *dpy, int resumable_p) | |
| 1194 { | |
| 771 | 1195 Extbyte buf[1024]; |
| 867 | 1196 Ibyte num[100]; |
| 428 | 1197 Lisp_Object data; |
| 1198 if (! x_error_occurred_p (dpy)) | |
| 1199 return 0; | |
| 1200 data = Qnil; | |
| 771 | 1201 qxesprintf (num, "0x%X", (unsigned int) last_error.resourceid); |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1202 data = Fcons (build_istring (num), data); |
| 771 | 1203 qxesprintf (num, "%d", last_error.request_code); |
| 1204 XGetErrorDatabaseText (last_error.display, "XRequest", (char *) num, "", | |
| 1205 buf, sizeof (buf)); | |
| 1206 if (*buf) | |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1207 data = Fcons (build_extstring (buf, Qx_error_message_encoding), data); |
| 771 | 1208 else |
| 1209 { | |
| 1210 qxesprintf (num, "Request-%d", last_error.request_code); | |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1211 data = Fcons (build_istring (num), data); |
| 771 | 1212 } |
| 428 | 1213 XGetErrorText (last_error.display, last_error.error_code, buf, sizeof (buf)); |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1214 data = Fcons (build_extstring (buf, Qx_error_message_encoding), data); |
| 428 | 1215 again: |
| 1216 Fsignal (Qx_error, data); | |
| 1217 if (! resumable_p) goto again; | |
| 1218 return 1; | |
| 1219 } | |
| 1220 | |
| 1221 int | |
| 1222 x_IO_error_handler (Display *disp) | |
| 1223 { | |
| 1224 /* This function can GC */ | |
| 1225 Lisp_Object dev; | |
| 1226 struct device *d = get_device_from_display_1 (disp); | |
| 1227 | |
| 756 | 1228 if (!d) |
| 1229 d = device_being_initialized; | |
| 1230 | |
| 428 | 1231 assert (d != NULL); |
| 793 | 1232 dev = wrap_device (d); |
| 428 | 1233 |
| 1234 if (NILP (find_nonminibuffer_frame_not_on_device (dev))) | |
| 1235 { | |
| 853 | 1236 int depth = begin_dont_check_for_quit (); |
| 428 | 1237 /* We're going down. */ |
| 867 | 1238 Ibyte *errmess; |
| 771 | 1239 GET_STRERROR (errmess, errno); |
| 1240 stderr_out ("\n%s: Fatal I/O Error %d (%s) on display " | |
| 1241 "connection \"%s\"\n", | |
| 1242 (STRINGP (Vinvocation_name) ? | |
| 1243 (char *) XSTRING_DATA (Vinvocation_name) : "xemacs"), | |
| 1244 errno, errmess, DisplayString (disp)); | |
| 1245 stderr_out (" after %lu requests (%lu known processed) with %d " | |
| 1246 "events remaining.\n", | |
| 1247 NextRequest (disp) - 1, LastKnownRequestProcessed (disp), | |
| 1248 QLength (disp)); | |
| 428 | 1249 /* assert (!_Xdebug); */ |
| 853 | 1250 unbind_to (depth); |
| 428 | 1251 } |
| 1252 else | |
| 1253 { | |
| 867 | 1254 Ibyte *errmess; |
| 771 | 1255 GET_STRERROR (errmess, errno); |
| 428 | 1256 warn_when_safe |
| 1257 (Qx, Qcritical, | |
| 1258 "I/O Error %d (%s) on display connection\n" | |
| 2116 | 1259 " \"%s\" after %lu requests (%lu known processed)\n" |
| 428 | 1260 " with %d events remaining.\n" |
| 1261 " Throwing to top level.\n", | |
| 771 | 1262 errno, errmess, DisplayString (disp), |
| 428 | 1263 NextRequest (disp) - 1, LastKnownRequestProcessed (disp), |
| 1264 QLength (disp)); | |
| 1265 } | |
| 1266 | |
| 1267 /* According to X specs, we should not return from this function, or | |
| 1268 Xlib might just decide to exit(). So we mark the offending | |
| 1269 console for deletion and throw to top level. */ | |
| 1270 if (d) | |
| 3466 | 1271 { |
| 1272 enqueue_magic_eval_event (io_error_delete_device, dev); | |
| 1273 DEVICE_X_BEING_DELETED (d) = 1; | |
| 1274 } | |
|
4677
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4548
diff
changeset
|
1275 |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4548
diff
changeset
|
1276 throw_or_bomb_out (Qtop_level, Qnil, 0, Qnil, Qnil); |
| 428 | 1277 |
| 2268 | 1278 RETURN_NOT_REACHED (0); |
| 428 | 1279 } |
| 1280 | |
| 1281 DEFUN ("x-debug-mode", Fx_debug_mode, 1, 2, 0, /* | |
| 1282 With a true arg, make the connection to the X server synchronous. | |
| 1283 With false, make it asynchronous. Synchronous connections are much slower, | |
| 1284 but are useful for debugging. (If you get X errors, make the connection | |
| 1285 synchronous, and use a debugger to set a breakpoint on `x_error_handler'. | |
| 1286 Your backtrace of the C stack will now be useful. In asynchronous mode, | |
| 1287 the stack above `x_error_handler' isn't helpful because of buffering.) | |
| 1288 If DEVICE is not specified, the selected device is assumed. | |
| 1289 | |
| 1290 Calling this function is the same as calling the C function `XSynchronize', | |
| 1291 or starting the program with the `-sync' command line argument. | |
| 1292 */ | |
| 1293 (arg, device)) | |
| 1294 { | |
| 1295 struct device *d = decode_x_device (device); | |
| 1296 | |
| 1297 XSynchronize (DEVICE_X_DISPLAY (d), !NILP (arg)); | |
| 1298 | |
| 1299 if (!NILP (arg)) | |
| 1300 message ("X connection is synchronous"); | |
| 1301 else | |
| 1302 message ("X connection is asynchronous"); | |
| 1303 | |
| 1304 return arg; | |
| 1305 } | |
| 1306 | |
| 1307 | |
| 1308 /************************************************************************/ | |
| 1309 /* X resources */ | |
| 1310 /************************************************************************/ | |
| 1311 | |
| 1312 #if 0 /* bah humbug. The whole "widget == resource" stuff is such | |
| 1313 a crock of shit that I'm just going to ignore it all. */ | |
| 1314 | |
| 1315 /* If widget is NULL, we are retrieving device or global face data. */ | |
| 1316 | |
| 1317 static void | |
| 1318 construct_name_list (Display *display, Widget widget, char *fake_name, | |
| 1204 | 1319 char *fake_class, char *name, char *class_) |
| 428 | 1320 { |
| 1321 char *stack [100][2]; | |
| 2552 | 1322 Widget this_widget; |
| 428 | 1323 int count = 0; |
| 1324 char *name_tail, *class_tail; | |
| 1325 | |
| 1326 if (widget) | |
| 1327 { | |
| 2552 | 1328 for (this_widget = widget; this_widget; |
| 1329 this_widget = XtParent (this_widget)) | |
| 428 | 1330 { |
| 2552 | 1331 stack [count][0] = this_widget->core.name; |
| 1332 stack [count][1] = XtClass (this_widget)->core_class.class_name; | |
| 428 | 1333 count++; |
| 1334 } | |
| 1335 count--; | |
| 1336 } | |
| 1337 else if (fake_name && fake_class) | |
| 1338 { | |
| 1339 stack [count][0] = fake_name; | |
| 1340 stack [count][1] = fake_class; | |
| 1341 count++; | |
| 1342 } | |
| 1343 | |
| 1344 /* The root widget is an application shell; resource lookups use the | |
| 1345 specified application name and application class in preference to | |
| 1346 the name/class of that widget (which is argv[0] / "ApplicationShell"). | |
| 1347 Generally the app name and class will be argv[0] / "Emacs" but | |
| 1348 the former can be set via the -name command-line option, and the | |
| 1349 latter can be set by changing `x-emacs-application-class' in | |
| 1350 lisp/term/x-win.el. | |
| 1351 */ | |
| 1352 XtGetApplicationNameAndClass (display, | |
| 1353 &stack [count][0], | |
| 1354 &stack [count][1]); | |
| 1355 | |
| 1356 name [0] = 0; | |
| 1204 | 1357 class_ [0] = 0; |
| 428 | 1358 |
| 1359 name_tail = name; | |
| 1204 | 1360 class_tail = class_; |
| 428 | 1361 for (; count >= 0; count--) |
| 1362 { | |
| 1363 strcat (name_tail, stack [count][0]); | |
| 1364 for (; *name_tail; name_tail++) | |
| 1365 if (*name_tail == '.') *name_tail = '_'; | |
| 1366 strcat (name_tail, "."); | |
| 1367 name_tail++; | |
| 1368 | |
| 1369 strcat (class_tail, stack [count][1]); | |
| 1370 for (; *class_tail; class_tail++) | |
| 1371 if (*class_tail == '.') *class_tail = '_'; | |
| 1372 strcat (class_tail, "."); | |
| 1373 class_tail++; | |
| 1374 } | |
| 1375 } | |
| 1376 | |
| 1377 #endif /* 0 */ | |
| 1378 | |
| 771 | 1379 static Extbyte_dynarr *name_Extbyte_dynarr; |
| 1380 static Extbyte_dynarr *class_Extbyte_dynarr; | |
| 428 | 1381 |
| 1382 /* Given a locale and device specification from x-get-resource or | |
| 1383 x-get-resource-prefix, return the resource prefix and display to | |
| 1384 fetch the resource on. */ | |
| 1385 | |
| 1386 static void | |
| 1387 x_get_resource_prefix (Lisp_Object locale, Lisp_Object device, | |
| 771 | 1388 Display **display_out, Extbyte_dynarr *name, |
| 1204 | 1389 Extbyte_dynarr *class_) |
| 428 | 1390 { |
| 1391 if (NILP (locale)) | |
| 1392 locale = Qglobal; | |
| 1393 if (NILP (Fvalid_specifier_locale_p (locale))) | |
| 563 | 1394 invalid_argument ("Invalid locale", locale); |
| 428 | 1395 if (WINDOWP (locale)) |
| 1396 /* #### I can't come up with any coherent way of naming windows. | |
| 1397 By relative position? That seems tricky because windows | |
| 1398 can change position, be split, etc. By order of creation? | |
| 1399 That seems less than useful. */ | |
| 563 | 1400 signal_error (Qunimplemented, |
| 1401 "Windows currently can't be resourced", locale); | |
| 428 | 1402 |
| 1403 if (!NILP (device) && !DEVICEP (device)) | |
| 1404 CHECK_DEVICE (device); | |
| 1405 if (DEVICEP (device) && !DEVICE_X_P (XDEVICE (device))) | |
| 1406 device = Qnil; | |
| 1407 if (NILP (device)) | |
| 1408 { | |
| 1409 device = DFW_DEVICE (locale); | |
| 1410 if (DEVICEP (device) && !DEVICE_X_P (XDEVICE (device))) | |
| 1411 device = Qnil; | |
| 1412 if (NILP (device)) | |
| 872 | 1413 device = get_default_device (Qx); |
| 428 | 1414 if (NILP (device)) |
| 1415 { | |
| 1416 *display_out = 0; | |
| 1417 return; | |
| 1418 } | |
| 1419 } | |
| 1420 | |
| 1421 *display_out = DEVICE_X_DISPLAY (XDEVICE (device)); | |
| 1422 | |
| 1423 { | |
| 771 | 1424 Extbyte *appname, *appclass; |
| 428 | 1425 int name_len, class_len; |
| 1426 XtGetApplicationNameAndClass (*display_out, &appname, &appclass); | |
| 1427 name_len = strlen (appname); | |
| 1428 class_len = strlen (appclass); | |
| 771 | 1429 Dynarr_add_many (name, appname, name_len); |
| 1204 | 1430 Dynarr_add_many (class_, appclass, class_len); |
| 4967 | 1431 validify_resource_component (Dynarr_begin (name), name_len); |
| 1432 validify_resource_component (Dynarr_begin (class_), class_len); | |
| 428 | 1433 } |
| 1434 | |
| 1435 if (EQ (locale, Qglobal)) | |
| 1436 return; | |
| 1437 if (BUFFERP (locale)) | |
| 1438 { | |
| 1439 Dynarr_add_literal_string (name, ".buffer."); | |
| 1440 /* we know buffer is live; otherwise we got an error above. */ | |
| 1441 Dynarr_add_validified_lisp_string (name, Fbuffer_name (locale)); | |
| 1204 | 1442 Dynarr_add_literal_string (class_, ".EmacsLocaleType.EmacsBuffer"); |
| 428 | 1443 } |
| 1444 else if (FRAMEP (locale)) | |
| 1445 { | |
| 1446 Dynarr_add_literal_string (name, ".frame."); | |
| 1447 /* we know frame is live; otherwise we got an error above. */ | |
| 1448 Dynarr_add_validified_lisp_string (name, Fframe_name (locale)); | |
| 1204 | 1449 Dynarr_add_literal_string (class_, ".EmacsLocaleType.EmacsFrame"); |
| 428 | 1450 } |
| 1451 else | |
| 1452 { | |
| 1453 assert (DEVICEP (locale)); | |
| 1454 Dynarr_add_literal_string (name, ".device."); | |
| 1455 /* we know device is live; otherwise we got an error above. */ | |
| 1456 Dynarr_add_validified_lisp_string (name, Fdevice_name (locale)); | |
| 1204 | 1457 Dynarr_add_literal_string (class_, ".EmacsLocaleType.EmacsDevice"); |
| 428 | 1458 } |
| 1459 return; | |
| 1460 } | |
| 1461 | |
| 1462 DEFUN ("x-get-resource", Fx_get_resource, 3, 6, 0, /* | |
| 1463 Retrieve an X resource from the resource manager. | |
| 1464 | |
| 1465 The first arg is the name of the resource to retrieve, such as "font". | |
| 1466 The second arg is the class of the resource to retrieve, such as "Font". | |
| 3025 | 1467 The third arg must be one of the symbols `string', `integer', `natnum', or |
| 1468 `boolean', specifying the type of object that the database is searched for. | |
| 428 | 1469 The fourth arg is the locale to search for the resources on, and can |
| 3025 | 1470 currently be a buffer, a frame, a device, or `global'. If omitted, it |
| 1471 defaults to `global'. | |
| 428 | 1472 The fifth arg is the device to search for the resources on. (The resource |
| 1473 database for a particular device is constructed by combining non-device- | |
| 1474 specific resources such as any command-line resources specified and any | |
| 1475 app-defaults files found [or the fallback resources supplied by XEmacs, | |
| 1476 if no app-defaults file is found] with device-specific resources such as | |
| 1477 those supplied using xrdb.) If omitted, it defaults to the device of | |
| 1478 LOCALE, if a device can be derived (i.e. if LOCALE is a frame or device), | |
| 1479 and otherwise defaults to the value of `default-x-device'. | |
| 1480 The sixth arg NOERROR, if non-nil, means do not signal an error if a | |
| 1481 bogus resource specification was retrieved (e.g. if a non-integer was | |
| 1482 given when an integer was requested). In this case, a warning is issued | |
| 442 | 1483 instead, unless NOERROR is t, in which case no warning is issued. |
| 428 | 1484 |
| 1485 The resource names passed to this function are looked up relative to the | |
| 1486 locale. | |
| 1487 | |
| 1488 If you want to search for a subresource, you just need to specify the | |
| 1489 resource levels in NAME and CLASS. For example, NAME could be | |
| 1490 "modeline.attributeFont", and CLASS "Face.AttributeFont". | |
| 1491 | |
| 1492 Specifically, | |
| 1493 | |
| 1494 1) If LOCALE is a buffer, a call | |
| 1495 | |
| 1496 (x-get-resource "foreground" "Foreground" 'string SOME-BUFFER) | |
| 1497 | |
| 1498 is an interface to a C call something like | |
| 1499 | |
| 1500 XrmGetResource (db, "xemacs.buffer.BUFFER-NAME.foreground", | |
| 1501 "Emacs.EmacsLocaleType.EmacsBuffer.Foreground", | |
| 1502 "String"); | |
| 1503 | |
| 1504 2) If LOCALE is a frame, a call | |
| 1505 | |
| 1506 (x-get-resource "foreground" "Foreground" 'string SOME-FRAME) | |
| 1507 | |
| 1508 is an interface to a C call something like | |
| 1509 | |
| 1510 XrmGetResource (db, "xemacs.frame.FRAME-NAME.foreground", | |
| 1511 "Emacs.EmacsLocaleType.EmacsFrame.Foreground", | |
| 1512 "String"); | |
| 1513 | |
| 1514 3) If LOCALE is a device, a call | |
| 1515 | |
| 1516 (x-get-resource "foreground" "Foreground" 'string SOME-DEVICE) | |
| 1517 | |
| 1518 is an interface to a C call something like | |
| 1519 | |
| 1520 XrmGetResource (db, "xemacs.device.DEVICE-NAME.foreground", | |
| 1521 "Emacs.EmacsLocaleType.EmacsDevice.Foreground", | |
| 1522 "String"); | |
| 1523 | |
| 3025 | 1524 4) If LOCALE is `global', a call |
| 428 | 1525 |
| 1526 (x-get-resource "foreground" "Foreground" 'string 'global) | |
| 1527 | |
| 1528 is an interface to a C call something like | |
| 1529 | |
| 1530 XrmGetResource (db, "xemacs.foreground", | |
| 1531 "Emacs.Foreground", | |
| 1532 "String"); | |
| 1533 | |
| 3025 | 1534 Note that for `global', no prefix is added other than that of the |
| 428 | 1535 application itself; thus, you can use this locale to retrieve |
| 1536 arbitrary application resources, if you really want to. | |
| 1537 | |
| 1538 The returned value of this function is nil if the queried resource is not | |
| 1539 found. If the third arg is `string', a string is returned, and if it is | |
| 1540 `integer', an integer is returned. If the third arg is `boolean', then the | |
| 1541 returned value is the list (t) for true, (nil) for false, and is nil to | |
| 430 | 1542 mean ``unspecified''. |
| 428 | 1543 */ |
| 1204 | 1544 (name, class_, type, locale, device, noerror)) |
| 428 | 1545 { |
| 771 | 1546 Extbyte *name_string, *class_string; |
| 1547 Extbyte *raw_result; | |
| 428 | 1548 XrmDatabase db; |
| 1549 Display *display; | |
| 578 | 1550 Error_Behavior errb = decode_error_behavior_flag (noerror); |
| 771 | 1551 Lisp_Object codesys; |
| 428 | 1552 |
| 1553 CHECK_STRING (name); | |
| 1204 | 1554 CHECK_STRING (class_); |
| 428 | 1555 CHECK_SYMBOL (type); |
| 1556 | |
| 771 | 1557 Dynarr_reset (name_Extbyte_dynarr); |
| 1558 Dynarr_reset (class_Extbyte_dynarr); | |
| 428 | 1559 |
| 1560 x_get_resource_prefix (locale, device, &display, | |
| 771 | 1561 name_Extbyte_dynarr, class_Extbyte_dynarr); |
| 428 | 1562 if (!display) |
| 1563 return Qnil; | |
| 1564 | |
| 1565 db = XtDatabase (display); | |
| 771 | 1566 codesys = coding_system_of_xrm_database (db); |
| 1567 Dynarr_add (name_Extbyte_dynarr, '.'); | |
| 1568 Dynarr_add_lisp_string (name_Extbyte_dynarr, name, Qbinary); | |
| 1569 Dynarr_add (class_Extbyte_dynarr, '.'); | |
| 1204 | 1570 Dynarr_add_lisp_string (class_Extbyte_dynarr, class_, Qbinary); |
| 771 | 1571 Dynarr_add (name_Extbyte_dynarr, '\0'); |
| 1572 Dynarr_add (class_Extbyte_dynarr, '\0'); | |
| 428 | 1573 |
| 4967 | 1574 name_string = Dynarr_begin (name_Extbyte_dynarr); |
| 1575 class_string = Dynarr_begin (class_Extbyte_dynarr); | |
| 428 | 1576 |
| 1577 { | |
| 1578 XrmValue xrm_value; | |
| 1579 XrmName namelist[100]; | |
| 1580 XrmClass classlist[100]; | |
| 1581 XrmName *namerest = namelist; | |
| 1582 XrmClass *classrest = classlist; | |
| 1583 XrmRepresentation xrm_type; | |
| 1584 XrmRepresentation string_quark; | |
| 1585 int result; | |
| 1586 XrmStringToNameList (name_string, namelist); | |
| 1587 XrmStringToClassList (class_string, classlist); | |
| 1588 string_quark = XrmStringToQuark ("String"); | |
| 1589 | |
| 1590 /* ensure that they have the same length */ | |
| 1591 while (namerest[0] && classrest[0]) | |
| 1592 namerest++, classrest++; | |
| 1593 if (namerest[0] || classrest[0]) | |
| 563 | 1594 { |
| 1595 maybe_signal_error_2 | |
| 1596 (Qstructure_formation_error, | |
| 1204 | 1597 "class list and name list must be the same length", name, class_, |
| 563 | 1598 Qresource, errb); |
| 1599 return Qnil; | |
| 1600 } | |
| 428 | 1601 result = XrmQGetResource (db, namelist, classlist, &xrm_type, &xrm_value); |
| 1602 | |
| 1603 if (result != True || xrm_type != string_quark) | |
| 1604 return Qnil; | |
| 771 | 1605 raw_result = (Extbyte *) xrm_value.addr; |
| 428 | 1606 } |
| 1607 | |
| 1608 if (EQ (type, Qstring)) | |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1609 return build_extstring (raw_result, codesys); |
| 428 | 1610 else if (EQ (type, Qboolean)) |
| 1611 { | |
| 771 | 1612 if (!strcasecmp (raw_result, "off") || |
| 1613 !strcasecmp (raw_result, "false") || | |
| 1614 !strcasecmp (raw_result, "no")) | |
| 428 | 1615 return Fcons (Qnil, Qnil); |
| 771 | 1616 if (!strcasecmp (raw_result, "on") || |
| 1617 !strcasecmp (raw_result, "true") || | |
| 1618 !strcasecmp (raw_result, "yes")) | |
| 428 | 1619 return Fcons (Qt, Qnil); |
| 563 | 1620 return maybe_signal_continuable_error_2 |
| 1621 (Qinvalid_operation, "Can't convert to a Boolean", | |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1622 build_extstring (name_string, Qbinary), |
|
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1623 build_extstring (raw_result, codesys), Qresource, |
| 563 | 1624 errb); |
| 428 | 1625 } |
| 1626 else if (EQ (type, Qinteger) || EQ (type, Qnatnum)) | |
| 1627 { | |
| 1628 int i; | |
| 1629 char c; | |
| 1630 if (1 != sscanf (raw_result, "%d%c", &i, &c)) | |
| 563 | 1631 return maybe_signal_continuable_error_2 |
| 1632 (Qinvalid_operation, "Can't convert to an integer", | |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1633 build_extstring (name_string, Qbinary), |
|
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1634 build_extstring (raw_result, codesys), Qresource, |
| 563 | 1635 errb); |
| 428 | 1636 else if (EQ (type, Qnatnum) && i < 0) |
| 563 | 1637 return maybe_signal_continuable_error_2 |
| 1638 (Qinvalid_argument, "Invalid numerical value for resource", | |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1639 make_int (i), build_extstring (name_string, Qbinary), |
| 771 | 1640 Qresource, errb); |
| 428 | 1641 else |
| 1642 return make_int (i); | |
| 1643 } | |
| 1644 else | |
| 1645 { | |
| 1646 return maybe_signal_continuable_error | |
| 563 | 1647 (Qwrong_type_argument, "Should be string, integer, natnum or boolean", |
| 1648 type, Qresource, errb); | |
| 428 | 1649 } |
| 1650 } | |
| 1651 | |
| 1652 DEFUN ("x-get-resource-prefix", Fx_get_resource_prefix, 1, 2, 0, /* | |
| 1653 Return the resource prefix for LOCALE on DEVICE. | |
| 1654 The resource prefix is the strings used to prefix resources if | |
| 1655 the LOCALE and DEVICE arguments were passed to `x-get-resource'. | |
| 1656 The returned value is a cons of a name prefix and a class prefix. | |
| 1657 For example, if LOCALE is a frame, the returned value might be | |
| 1658 \("xemacs.frame.FRAME-NAME" . "Emacs.EmacsLocaleType.EmacsFrame"). | |
| 1659 If no valid X device for resourcing can be obtained, this function | |
| 1660 returns nil. (In such a case, `x-get-resource' would always return nil.) | |
| 1661 */ | |
| 1662 (locale, device)) | |
| 1663 { | |
| 1664 Display *display; | |
| 1665 | |
| 771 | 1666 Dynarr_reset (name_Extbyte_dynarr ); |
| 1667 Dynarr_reset (class_Extbyte_dynarr); | |
| 428 | 1668 |
| 1669 x_get_resource_prefix (locale, device, &display, | |
| 771 | 1670 name_Extbyte_dynarr, class_Extbyte_dynarr); |
| 428 | 1671 if (!display) |
| 1672 return Qnil; | |
| 1673 | |
| 4967 | 1674 return Fcons (make_string ((Ibyte *) Dynarr_begin (name_Extbyte_dynarr), |
| 771 | 1675 Dynarr_length (name_Extbyte_dynarr)), |
| 4967 | 1676 make_string ((Ibyte *) Dynarr_begin (class_Extbyte_dynarr), |
| 771 | 1677 Dynarr_length (class_Extbyte_dynarr))); |
| 428 | 1678 } |
| 1679 | |
| 1680 DEFUN ("x-put-resource", Fx_put_resource, 1, 2, 0, /* | |
| 1681 Add a resource to the resource database for DEVICE. | |
| 1682 RESOURCE-LINE specifies the resource to add and should be a | |
| 1683 standard resource specification. | |
| 1684 */ | |
| 1685 (resource_line, device)) | |
| 1686 { | |
| 1687 struct device *d = decode_device (device); | |
| 1688 | |
| 1689 if (DEVICE_X_P (d)) | |
| 1690 { | |
| 1691 XrmDatabase db = XtDatabase (DEVICE_X_DISPLAY (d)); | |
| 771 | 1692 Extbyte *str, *colon_pos; |
| 1693 | |
| 1694 CHECK_STRING (resource_line); | |
| 1695 LISP_STRING_TO_EXTERNAL (resource_line, str, | |
| 1696 coding_system_of_xrm_database (db)); | |
| 1697 if (!(colon_pos = strchr (str, ':')) || strchr (str, '\n')) | |
| 1698 invalid: | |
| 1699 syntax_error ("Invalid resource line", resource_line); | |
| 1700 if ((int) | |
| 1701 strspn (str, | |
| 1702 /* Only the following chars are allowed before the colon */ | |
| 1703 " \t.*?abcdefghijklmnopqrstuvwxyz" | |
| 1704 "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-") | |
| 1705 != colon_pos - str) | |
| 1706 goto invalid; | |
| 1707 | |
| 428 | 1708 XrmPutLineResource (&db, str); |
| 1709 } | |
| 1710 | |
| 1711 return Qnil; | |
| 1712 } | |
| 1713 | |
| 1714 | |
| 1715 /************************************************************************/ | |
| 1716 /* display information functions */ | |
| 1717 /************************************************************************/ | |
| 1718 | |
| 1719 DEFUN ("default-x-device", Fdefault_x_device, 0, 0, 0, /* | |
| 1720 Return the default X device for resourcing. | |
| 1721 This is the first-created X device that still exists. | |
| 872 | 1722 See also `default-device'. |
| 428 | 1723 */ |
| 1724 ()) | |
| 1725 { | |
| 872 | 1726 return get_default_device (Qx); |
| 428 | 1727 } |
| 1728 | |
| 1729 DEFUN ("x-display-visual-class", Fx_display_visual_class, 0, 1, 0, /* | |
| 1730 Return the visual class of the X display DEVICE is using. | |
| 1731 This can be altered from the default at startup using the XResource "EmacsVisual". | |
| 1732 The returned value will be one of the symbols `static-gray', `gray-scale', | |
| 1733 `static-color', `pseudo-color', `true-color', or `direct-color'. | |
| 1734 */ | |
| 1735 (device)) | |
| 1736 { | |
| 1737 Visual *vis = DEVICE_X_VISUAL (decode_x_device (device)); | |
| 1204 | 1738 switch (vis->X_CLASSFIELD) |
| 428 | 1739 { |
| 1740 case StaticGray: return intern ("static-gray"); | |
| 1741 case GrayScale: return intern ("gray-scale"); | |
| 1742 case StaticColor: return intern ("static-color"); | |
| 1743 case PseudoColor: return intern ("pseudo-color"); | |
| 1744 case TrueColor: return intern ("true-color"); | |
| 1745 case DirectColor: return intern ("direct-color"); | |
| 1746 default: | |
| 563 | 1747 invalid_state ("display has an unknown visual class", Qunbound); |
| 428 | 1748 return Qnil; /* suppress compiler warning */ |
| 1749 } | |
| 1750 } | |
| 1751 | |
| 1752 DEFUN ("x-display-visual-depth", Fx_display_visual_depth, 0, 1, 0, /* | |
| 1753 Return the bitplane depth of the visual the X display DEVICE is using. | |
| 1754 */ | |
| 1755 (device)) | |
| 1756 { | |
| 1757 return make_int (DEVICE_X_DEPTH (decode_x_device (device))); | |
| 1758 } | |
| 1759 | |
| 1760 static Lisp_Object | |
| 1761 x_device_system_metrics (struct device *d, | |
| 1762 enum device_metrics m) | |
| 1763 { | |
| 1764 Display *dpy = DEVICE_X_DISPLAY (d); | |
| 1765 | |
| 1766 switch (m) | |
| 1767 { | |
| 1768 case DM_size_device: | |
| 1769 return Fcons (make_int (DisplayWidth (dpy, DefaultScreen (dpy))), | |
| 1770 make_int (DisplayHeight (dpy, DefaultScreen (dpy)))); | |
| 1771 case DM_size_device_mm: | |
| 1772 return Fcons (make_int (DisplayWidthMM (dpy, DefaultScreen (dpy))), | |
| 1773 make_int (DisplayHeightMM (dpy, DefaultScreen (dpy)))); | |
| 1774 case DM_num_bit_planes: | |
| 1775 return make_int (DisplayPlanes (dpy, DefaultScreen (dpy))); | |
| 1776 case DM_num_color_cells: | |
| 1777 return make_int (DisplayCells (dpy, DefaultScreen (dpy))); | |
| 1942 | 1778 case DM_num_screens: |
| 1779 return make_int (ScreenCount (dpy)); | |
| 1780 case DM_backing_store: | |
| 1781 switch (DoesBackingStore (DefaultScreenOfDisplay (dpy))) | |
| 1782 { | |
| 1783 case Always: | |
| 1784 return intern ("always"); | |
| 1785 case WhenMapped: | |
| 1786 return intern ("when-mapped"); | |
| 1787 default: | |
| 1788 return intern ("not-useful"); | |
| 1789 } | |
| 1790 case DM_save_under: | |
| 1791 return (DoesSaveUnders (DefaultScreenOfDisplay (dpy)) == True) | |
| 1792 ? Qt : Qnil; | |
| 428 | 1793 default: /* No such device metric property for X devices */ |
| 1794 return Qunbound; | |
| 1795 } | |
| 1796 } | |
| 1797 | |
| 1798 DEFUN ("x-server-vendor", Fx_server_vendor, 0, 1, 0, /* | |
| 1799 Return the vendor ID string of the X server DEVICE is on. | |
| 1800 Return the empty string if the vendor ID string cannot be determined. | |
| 1801 */ | |
| 1802 (device)) | |
| 1803 { | |
| 1804 Display *dpy = get_x_display (device); | |
| 2367 | 1805 Extbyte *vendor = ServerVendor (dpy); |
| 428 | 1806 |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1807 return build_extstring (vendor ? vendor : "", Qx_hpc_encoding); |
| 428 | 1808 } |
| 1809 | |
| 1810 DEFUN ("x-server-version", Fx_server_version, 0, 1, 0, /* | |
| 1811 Return the version numbers of the X server DEVICE is on. | |
| 1812 The returned value is a list of three integers: the major and minor | |
| 1813 version numbers of the X Protocol in use, and the vendor-specific release | |
| 1814 number. See also `x-server-vendor'. | |
| 1815 */ | |
| 1816 (device)) | |
| 1817 { | |
| 1818 Display *dpy = get_x_display (device); | |
| 1819 | |
| 1820 return list3 (make_int (ProtocolVersion (dpy)), | |
| 1821 make_int (ProtocolRevision (dpy)), | |
| 1822 make_int (VendorRelease (dpy))); | |
| 1823 } | |
| 1824 | |
| 1825 DEFUN ("x-valid-keysym-name-p", Fx_valid_keysym_name_p, 1, 1, 0, /* | |
| 1826 Return true if KEYSYM names a keysym that the X library knows about. | |
| 1827 Valid keysyms are listed in the files /usr/include/X11/keysymdef.h and in | |
| 1828 /usr/lib/X11/XKeysymDB, or whatever the equivalents are on your system. | |
| 1829 */ | |
| 1830 (keysym)) | |
| 1831 { | |
| 2367 | 1832 const Extbyte *keysym_ext; |
| 428 | 1833 |
| 1834 CHECK_STRING (keysym); | |
| 442 | 1835 LISP_STRING_TO_EXTERNAL (keysym, keysym_ext, Qctext); |
| 428 | 1836 |
| 1837 return XStringToKeysym (keysym_ext) ? Qt : Qnil; | |
| 1838 } | |
| 1839 | |
| 1840 DEFUN ("x-keysym-hash-table", Fx_keysym_hash_table, 0, 1, 0, /* | |
| 440 | 1841 Return a hash table containing a key for all keysyms on DEVICE. |
| 1842 DEVICE must be an X11 display device. See `x-keysym-on-keyboard-p'. | |
| 428 | 1843 */ |
| 1844 (device)) | |
| 1845 { | |
| 1846 struct device *d = decode_device (device); | |
| 1847 if (!DEVICE_X_P (d)) | |
| 563 | 1848 gui_error ("Not an X device", device); |
| 428 | 1849 |
| 1850 return DEVICE_X_DATA (d)->x_keysym_map_hash_table; | |
| 1851 } | |
| 1852 | |
| 1853 DEFUN ("x-keysym-on-keyboard-sans-modifiers-p", Fx_keysym_on_keyboard_sans_modifiers_p, | |
| 1854 1, 2, 0, /* | |
| 1855 Return true if KEYSYM names a key on the keyboard of DEVICE. | |
| 1856 More precisely, return true if pressing a physical key | |
| 1857 on the keyboard of DEVICE without any modifier keys generates KEYSYM. | |
| 1858 Valid keysyms are listed in the files /usr/include/X11/keysymdef.h and in | |
| 1859 /usr/lib/X11/XKeysymDB, or whatever the equivalents are on your system. | |
| 1860 The keysym name can be provided in two forms: | |
| 1861 - if keysym is a string, it must be the name as known to X windows. | |
| 1862 - if keysym is a symbol, it must be the name as known to XEmacs. | |
| 1863 The two names differ in capitalization and underscoring. | |
| 1864 */ | |
| 1865 (keysym, device)) | |
| 1866 { | |
| 1867 struct device *d = decode_device (device); | |
| 1868 if (!DEVICE_X_P (d)) | |
| 563 | 1869 gui_error ("Not an X device", device); |
| 428 | 1870 |
| 1871 return (EQ (Qsans_modifiers, | |
| 1872 Fgethash (keysym, DEVICE_X_KEYSYM_MAP_HASH_TABLE (d), Qnil)) ? | |
| 1873 Qt : Qnil); | |
| 1874 } | |
| 1875 | |
| 1876 | |
| 1877 DEFUN ("x-keysym-on-keyboard-p", Fx_keysym_on_keyboard_p, 1, 2, 0, /* | |
| 1878 Return true if KEYSYM names a key on the keyboard of DEVICE. | |
| 1879 More precisely, return true if some keystroke (possibly including modifiers) | |
| 1880 on the keyboard of DEVICE keys generates KEYSYM. | |
| 1881 Valid keysyms are listed in the files /usr/include/X11/keysymdef.h and in | |
| 1882 /usr/lib/X11/XKeysymDB, or whatever the equivalents are on your system. | |
| 1883 The keysym name can be provided in two forms: | |
| 1884 - if keysym is a string, it must be the name as known to X windows. | |
| 1885 - if keysym is a symbol, it must be the name as known to XEmacs. | |
| 1886 The two names differ in capitalization and underscoring. | |
| 2828 | 1887 |
| 1888 This function is not entirely trustworthy, in that Xlib compose processing | |
| 1889 can produce keysyms that XEmacs will not have seen when it examined the | |
| 1890 keysyms available on startup. So pressing `dead-diaeresis' and then 'a' may | |
| 1891 pass `adiaeresis' to XEmacs, or (in some implementations) even `U00E4', | |
| 1892 where `(x-keysym-on-keyboard-p 'adiaeresis)' and `(x-keysym-on-keyboard-p | |
| 1893 'U00E4)' would both have returned nil. Subsequent to XEmacs seeing a keysym | |
| 1894 it was previously unaware of, the predicate will take note of it, though. | |
| 428 | 1895 */ |
| 1896 (keysym, device)) | |
| 1897 { | |
| 1898 struct device *d = decode_device (device); | |
| 1899 if (!DEVICE_X_P (d)) | |
| 563 | 1900 gui_error ("Not an X device", device); |
| 428 | 1901 |
| 1902 return (NILP (Fgethash (keysym, DEVICE_X_KEYSYM_MAP_HASH_TABLE (d), Qnil)) ? | |
| 1903 Qnil : Qt); | |
| 1904 } | |
| 1905 | |
| 1906 | |
| 1907 /************************************************************************/ | |
| 1908 /* grabs and ungrabs */ | |
| 1909 /************************************************************************/ | |
| 1910 | |
| 1911 DEFUN ("x-grab-pointer", Fx_grab_pointer, 0, 3, 0, /* | |
| 1912 Grab the pointer and restrict it to its current window. | |
| 1913 If optional DEVICE argument is nil, the default device will be used. | |
| 1914 If optional CURSOR argument is non-nil, change the pointer shape to that | |
| 1915 until `x-ungrab-pointer' is called (it should be an object returned by the | |
| 1916 `make-cursor-glyph' function). | |
| 1917 If the second optional argument IGNORE-KEYBOARD is non-nil, ignore all | |
| 1918 keyboard events during the grab. | |
| 1919 Returns t if the grab is successful, nil otherwise. | |
| 1920 */ | |
| 1921 (device, cursor, ignore_keyboard)) | |
| 1922 { | |
| 1923 Window w; | |
| 1924 int pointer_mode, result; | |
| 1925 struct device *d = decode_x_device (device); | |
| 1926 | |
| 1927 if (!NILP (cursor)) | |
| 1928 { | |
| 1929 CHECK_POINTER_GLYPH (cursor); | |
| 1930 cursor = glyph_image_instance (cursor, device, ERROR_ME, 0); | |
| 1931 } | |
| 1932 | |
| 1933 if (!NILP (ignore_keyboard)) | |
| 1934 pointer_mode = GrabModeSync; | |
| 1935 else | |
| 1936 pointer_mode = GrabModeAsync; | |
| 1937 | |
| 1938 w = XtWindow (FRAME_X_TEXT_WIDGET (device_selected_frame (d))); | |
| 1939 | |
| 1940 /* #### Possibly this needs to gcpro the cursor somehow, but it doesn't | |
| 1941 seem to cause a problem if XFreeCursor is called on a cursor in use | |
| 1942 in a grab; I suppose the X server counts the grab as a reference | |
| 1943 and doesn't free it until it exits? */ | |
| 1944 result = XGrabPointer (DEVICE_X_DISPLAY (d), w, | |
| 1945 False, | |
| 1946 ButtonMotionMask | | |
| 1947 ButtonPressMask | | |
| 1948 ButtonReleaseMask | | |
| 1949 PointerMotionHintMask, | |
| 1950 GrabModeAsync, /* Keep pointer events flowing */ | |
| 1951 pointer_mode, /* Stall keyboard events */ | |
| 1952 w, /* Stay in this window */ | |
| 1953 (NILP (cursor) ? 0 | |
| 1954 : XIMAGE_INSTANCE_X_CURSOR (cursor)), | |
| 1955 CurrentTime); | |
| 1956 return (result == GrabSuccess) ? Qt : Qnil; | |
| 1957 } | |
| 1958 | |
| 1959 DEFUN ("x-ungrab-pointer", Fx_ungrab_pointer, 0, 1, 0, /* | |
| 1960 Release a pointer grab made with `x-grab-pointer'. | |
| 1961 If optional first arg DEVICE is nil the default device is used. | |
| 1962 If it is t the pointer will be released on all X devices. | |
| 1963 */ | |
| 1964 (device)) | |
| 1965 { | |
| 1966 if (!EQ (device, Qt)) | |
| 1967 { | |
| 1968 Display *dpy = get_x_display (device); | |
| 1969 XUngrabPointer (dpy, CurrentTime); | |
| 1970 } | |
| 1971 else | |
| 1972 { | |
| 1973 Lisp_Object devcons, concons; | |
| 1974 | |
| 1975 DEVICE_LOOP_NO_BREAK (devcons, concons) | |
| 1976 { | |
| 1977 struct device *d = XDEVICE (XCAR (devcons)); | |
| 1978 | |
| 1979 if (DEVICE_X_P (d)) | |
| 1980 XUngrabPointer (DEVICE_X_DISPLAY (d), CurrentTime); | |
| 1981 } | |
| 1982 } | |
| 1983 | |
| 1984 return Qnil; | |
| 1985 } | |
| 1986 | |
| 1987 DEFUN ("x-grab-keyboard", Fx_grab_keyboard, 0, 1, 0, /* | |
| 1988 Grab the keyboard on the given device (defaulting to the selected one). | |
| 1989 So long as the keyboard is grabbed, all keyboard events will be delivered | |
| 1990 to emacs -- it is not possible for other X clients to eavesdrop on them. | |
| 1991 Ungrab the keyboard with `x-ungrab-keyboard' (use an unwind-protect). | |
| 1992 Returns t if the grab is successful, nil otherwise. | |
| 1993 */ | |
| 1994 (device)) | |
| 1995 { | |
| 1996 struct device *d = decode_x_device (device); | |
| 1997 Window w = XtWindow (FRAME_X_TEXT_WIDGET (device_selected_frame (d))); | |
| 1998 Display *dpy = DEVICE_X_DISPLAY (d); | |
| 1999 Status status; | |
| 2000 XSync (dpy, False); | |
| 2001 status = XGrabKeyboard (dpy, w, True, | |
| 2002 /* I don't really understand sync-vs-async | |
| 2003 grabs, but this is what xterm does. */ | |
| 2004 GrabModeAsync, GrabModeAsync, | |
| 2005 /* Use the timestamp of the last user action | |
| 2006 read by emacs proper; xterm uses CurrentTime | |
| 2007 but there's a comment that says "wrong"... | |
| 2008 (Despite the name this is the time of the | |
| 2009 last key or mouse event.) */ | |
| 2010 DEVICE_X_MOUSE_TIMESTAMP (d)); | |
| 2011 if (status == GrabSuccess) | |
| 2012 { | |
| 2013 /* The XUngrabKeyboard should generate a FocusIn back to this | |
| 2014 window but it doesn't unless we explicitly set focus to the | |
| 2015 window first (which should already have it. The net result | |
| 2016 is that without this call when x-ungrab-keyboard is called | |
| 2017 the selected frame ends up not having focus. */ | |
| 2018 XSetInputFocus (dpy, w, RevertToParent, DEVICE_X_MOUSE_TIMESTAMP (d)); | |
| 2019 return Qt; | |
| 2020 } | |
| 2021 else | |
| 2022 return Qnil; | |
| 2023 } | |
| 2024 | |
| 2025 DEFUN ("x-ungrab-keyboard", Fx_ungrab_keyboard, 0, 1, 0, /* | |
| 2026 Release a keyboard grab made with `x-grab-keyboard'. | |
| 2027 */ | |
| 2028 (device)) | |
| 2029 { | |
| 2030 Display *dpy = get_x_display (device); | |
| 2031 XUngrabKeyboard (dpy, CurrentTime); | |
| 2032 return Qnil; | |
| 2033 } | |
| 2034 | |
| 2035 DEFUN ("x-get-font-path", Fx_get_font_path, 0, 1, 0, /* | |
| 2036 Get the X Server's font path. | |
| 2037 | |
| 2038 See also `x-set-font-path'. | |
| 2039 */ | |
| 2040 (device)) | |
| 2041 { | |
| 2042 Display *dpy = get_x_display (device); | |
| 2043 int ndirs_return; | |
| 2367 | 2044 const Extbyte **directories = |
| 2045 (const Extbyte **) XGetFontPath (dpy, &ndirs_return); | |
| 428 | 2046 Lisp_Object font_path = Qnil; |
| 2047 | |
| 2048 if (!directories) | |
| 563 | 2049 gui_error ("Can't get X font path", device); |
| 428 | 2050 |
| 2051 while (ndirs_return--) | |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
2052 font_path = Fcons (build_extstring (directories[ndirs_return], |
| 440 | 2053 Qfile_name), |
| 2054 font_path); | |
| 428 | 2055 |
|
4548
b0d2ace4aed1
Call XFreeFontPath appropriately in #'x-get-font-path.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4528
diff
changeset
|
2056 XFreeFontPath ((char **)directories); |
|
b0d2ace4aed1
Call XFreeFontPath appropriately in #'x-get-font-path.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4528
diff
changeset
|
2057 |
| 428 | 2058 return font_path; |
| 2059 } | |
| 2060 | |
| 2061 DEFUN ("x-set-font-path", Fx_set_font_path, 1, 2, 0, /* | |
| 2062 Set the X Server's font path to FONT-PATH. | |
| 2063 | |
| 2064 There is only one font path per server, not one per client. Use this | |
| 2065 sparingly. It uncaches all of the X server's font information. | |
| 2066 | |
| 2067 Font directories should end in the path separator and should contain | |
| 2068 a file called fonts.dir usually created with the program mkfontdir. | |
| 2069 | |
| 2070 Setting the FONT-PATH to nil tells the X server to use the default | |
| 2071 font path. | |
| 2072 | |
| 2073 See also `x-get-font-path'. | |
| 2074 */ | |
| 2075 (font_path, device)) | |
| 2076 { | |
| 2077 Display *dpy = get_x_display (device); | |
| 2367 | 2078 Extbyte **directories; |
| 428 | 2079 int i=0,ndirs=0; |
| 2080 | |
| 2367 | 2081 { |
| 2082 EXTERNAL_LIST_LOOP_2 (path_entry, font_path) | |
| 2083 { | |
| 2084 CHECK_STRING (path_entry); | |
| 2085 ndirs++; | |
| 2086 } | |
| 2087 } | |
| 428 | 2088 |
| 2367 | 2089 directories = alloca_array (Extbyte *, ndirs); |
| 428 | 2090 |
| 2367 | 2091 { |
| 2092 EXTERNAL_LIST_LOOP_2 (path_entry, font_path) | |
| 2093 { | |
| 2094 LISP_STRING_TO_EXTERNAL (path_entry, directories[i++], | |
| 2095 Qfile_name); | |
| 2096 } | |
| 2097 } | |
| 428 | 2098 |
| 2099 expect_x_error (dpy); | |
| 2367 | 2100 XSetFontPath (dpy, directories, ndirs); |
| 428 | 2101 signal_if_x_error (dpy, 1/*resumable_p*/); |
| 2102 | |
| 2103 return Qnil; | |
| 2104 } | |
| 2105 | |
| 2106 | |
| 2107 /************************************************************************/ | |
| 2108 /* initialization */ | |
| 2109 /************************************************************************/ | |
| 2110 | |
| 2111 void | |
| 2112 syms_of_device_x (void) | |
| 2113 { | |
| 3092 | 2114 #ifdef NEW_GC |
| 2115 INIT_LRECORD_IMPLEMENTATION (x_device); | |
| 2116 #endif /* NEW_GC */ | |
| 2117 | |
| 428 | 2118 DEFSUBR (Fx_debug_mode); |
| 2119 DEFSUBR (Fx_get_resource); | |
| 2120 DEFSUBR (Fx_get_resource_prefix); | |
| 2121 DEFSUBR (Fx_put_resource); | |
| 2122 | |
| 2123 DEFSUBR (Fdefault_x_device); | |
| 2124 DEFSUBR (Fx_display_visual_class); | |
| 2125 DEFSUBR (Fx_display_visual_depth); | |
| 2126 DEFSUBR (Fx_server_vendor); | |
| 2127 DEFSUBR (Fx_server_version); | |
| 2128 DEFSUBR (Fx_valid_keysym_name_p); | |
| 2129 DEFSUBR (Fx_keysym_hash_table); | |
| 2130 DEFSUBR (Fx_keysym_on_keyboard_p); | |
| 2131 DEFSUBR (Fx_keysym_on_keyboard_sans_modifiers_p); | |
| 2132 | |
| 2133 DEFSUBR (Fx_grab_pointer); | |
| 2134 DEFSUBR (Fx_ungrab_pointer); | |
| 2135 DEFSUBR (Fx_grab_keyboard); | |
| 2136 DEFSUBR (Fx_ungrab_keyboard); | |
| 2137 | |
| 2138 DEFSUBR (Fx_get_font_path); | |
| 2139 DEFSUBR (Fx_set_font_path); | |
| 2140 | |
| 563 | 2141 DEFSYMBOL (Qx_error); |
|
4477
e34711681f30
Don't determine whether to call general device-type code at startup,
Aidan Kehoe <kehoea@parhasard.net>
parents:
4404
diff
changeset
|
2142 DEFSYMBOL (Qmake_device_early_x_entry_point); |
|
e34711681f30
Don't determine whether to call general device-type code at startup,
Aidan Kehoe <kehoea@parhasard.net>
parents:
4404
diff
changeset
|
2143 DEFSYMBOL (Qmake_device_late_x_entry_point); |
| 771 | 2144 |
| 2145 #ifdef MULE | |
| 2146 DEFSYMBOL (Qget_coding_system_from_locale); | |
| 2147 #endif | |
| 428 | 2148 } |
| 2149 | |
| 2150 void | |
| 2151 reinit_console_type_create_device_x (void) | |
| 2152 { | |
| 2153 /* Initialize variables to speed up X resource interactions */ | |
| 2367 | 2154 const Ascbyte *valid_resource_chars = |
| 428 | 2155 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"; |
| 2156 while (*valid_resource_chars) | |
| 2157 valid_resource_char_p[(unsigned int) (*valid_resource_chars++)] = 1; | |
| 2158 | |
| 771 | 2159 name_Extbyte_dynarr = Dynarr_new (Extbyte); |
| 2160 class_Extbyte_dynarr = Dynarr_new (Extbyte); | |
| 428 | 2161 } |
| 2162 | |
| 2163 void | |
| 2164 console_type_create_device_x (void) | |
| 2165 { | |
| 2166 reinit_console_type_create_device_x (); | |
| 2167 CONSOLE_HAS_METHOD (x, init_device); | |
| 2168 CONSOLE_HAS_METHOD (x, finish_init_device); | |
| 2169 CONSOLE_HAS_METHOD (x, mark_device); | |
| 2170 CONSOLE_HAS_METHOD (x, delete_device); | |
| 2171 CONSOLE_HAS_METHOD (x, device_system_metrics); | |
| 2172 } | |
| 2173 | |
| 2174 void | |
| 2175 reinit_vars_of_device_x (void) | |
| 2176 { | |
| 2177 error_expected = 0; | |
| 2178 error_occurred = 0; | |
| 2179 | |
| 2180 in_resource_setting = 0; | |
| 2181 } | |
| 2182 | |
| 2183 void | |
| 2184 vars_of_device_x (void) | |
| 2185 { | |
| 2186 DEFVAR_LISP ("x-emacs-application-class", &Vx_emacs_application_class /* | |
| 2187 The X application class of the XEmacs process. | |
| 2188 This controls, among other things, the name of the `app-defaults' file | |
| 2189 that XEmacs will use. For changes to this variable to take effect, they | |
| 2190 must be made before the connection to the X server is initialized, that is, | |
| 2191 this variable may only be changed before emacs is dumped, or by setting it | |
| 2192 in the file lisp/term/x-win.el. | |
| 2193 | |
| 2681 | 2194 If this variable is nil on startup, the application uses `XEmacs'. Versions |
| 2195 previous to 21.5.21 examined the resource database and used `XEmacs' if any | |
| 2196 resources beginning with that string existed, and `Emacs' otherwise, for | |
| 2828 | 2197 greater backward compatibility. However, this has always tended to conflict |
| 2681 | 2198 with GNU Emacs, so this behavior is deprecated--in the short term, you can |
| 2199 restore it in a post-21.5.21 XEmacs by setting the | |
| 2200 USE_EMACS_AS_DEFAULT_APPLICATION_CLASS environment variable to some value, | |
| 2201 but in the medium and long term, you should migrate your X resources. | |
| 428 | 2202 */ ); |
| 2203 Vx_emacs_application_class = Qnil; | |
| 2204 | |
| 2205 DEFVAR_LISP ("x-initial-argv-list", &Vx_initial_argv_list /* | |
| 2206 You don't want to know. | |
| 2207 This is used during startup to communicate the remaining arguments in | |
| 2208 `command-line-args-left' to the C code, which passes the args to | |
| 2209 the X initialization code, which removes some args, and then the | |
| 2210 args are placed back into `x-initial-arg-list' and thence into | |
| 2211 `command-line-args-left'. Perhaps `command-line-args-left' should | |
| 2212 just reside in C. | |
| 2213 */ ); | |
| 2214 Vx_initial_argv_list = Qnil; | |
| 2215 | |
| 2216 DEFVAR_LISP ("x-app-defaults-directory", &Vx_app_defaults_directory /* | |
| 2217 Used by the Lisp code to communicate to the low level X initialization | |
| 2218 where the localized init files are. | |
| 2219 */ ); | |
| 2220 Vx_app_defaults_directory = Qnil; | |
| 2221 | |
| 2222 Fprovide (Qx); | |
| 2223 } |