Mercurial > hg > xemacs-beta
annotate src/device-x.c @ 4981:4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
-------------------- ChangeLog entries follow: --------------------
modules/ChangeLog addition:
2010-02-05 Ben Wing <ben@xemacs.org>
* postgresql/postgresql.c:
* postgresql/postgresql.c (CHECK_LIVE_CONNECTION):
* postgresql/postgresql.c (Fpq_connectdb):
* postgresql/postgresql.c (Fpq_connect_start):
* postgresql/postgresql.c (Fpq_lo_import):
* postgresql/postgresql.c (Fpq_lo_export):
* ldap/eldap.c (Fldap_open):
* ldap/eldap.c (Fldap_search_basic):
* ldap/eldap.c (Fldap_add):
* ldap/eldap.c (Fldap_modify):
* ldap/eldap.c (Fldap_delete):
* canna/canna_api.c (Fcanna_initialize):
* canna/canna_api.c (Fcanna_store_yomi):
* canna/canna_api.c (Fcanna_parse):
* canna/canna_api.c (Fcanna_henkan_begin):
EXTERNAL_TO_C_STRING returns its argument instead of storing it
in a parameter, and is renamed to EXTERNAL_TO_ITEXT. Similar
things happen to related macros. See entry in src/ChangeLog.
More Mule-izing of postgresql.c. Extract out common code
between `pq-connectdb' and `pq-connect-start'. Fix places
that signal an error string using a formatted string to instead
follow the standard and have a fixed reason followed by the
particular error message stored as one of the frobs.
src/ChangeLog addition:
2010-02-05 Ben Wing <ben@xemacs.org>
* console-msw.c (write_string_to_mswindows_debugging_output):
* console-msw.c (Fmswindows_message_box):
* console-x.c (x_perhaps_init_unseen_key_defaults):
* console.c:
* database.c (dbm_get):
* database.c (dbm_put):
* database.c (dbm_remove):
* database.c (berkdb_get):
* database.c (berkdb_put):
* database.c (berkdb_remove):
* database.c (Fopen_database):
* device-gtk.c (gtk_init_device):
* device-msw.c (msprinter_init_device_internal):
* device-msw.c (msprinter_default_printer):
* device-msw.c (msprinter_init_device):
* device-msw.c (sync_printer_with_devmode):
* device-msw.c (Fmsprinter_select_settings):
* device-x.c (sanity_check_geometry_resource):
* device-x.c (Dynarr_add_validified_lisp_string):
* device-x.c (x_init_device):
* device-x.c (Fx_put_resource):
* device-x.c (Fx_valid_keysym_name_p):
* device-x.c (Fx_set_font_path):
* dialog-msw.c (push_lisp_string_as_unicode):
* dialog-msw.c (handle_directory_dialog_box):
* dialog-msw.c (handle_file_dialog_box):
* dialog-x.c (dbox_descriptor_to_widget_value):
* editfns.c (Fformat_time_string):
* editfns.c (Fencode_time):
* editfns.c (Fset_time_zone_rule):
* emacs.c (make_argc_argv):
* emacs.c (Fdump_emacs):
* emodules.c (emodules_load):
* eval.c:
* eval.c (maybe_signal_error_1):
* event-msw.c (Fdde_alloc_advise_item):
* event-msw.c (mswindows_dde_callback):
* event-msw.c (mswindows_wnd_proc):
* fileio.c (report_error_with_errno):
* fileio.c (Fsysnetunam):
* fileio.c (Fdo_auto_save):
* font-mgr.c (extract_fcapi_string):
* font-mgr.c (Ffc_config_app_font_add_file):
* font-mgr.c (Ffc_config_app_font_add_dir):
* font-mgr.c (Ffc_config_filename):
* frame-gtk.c (gtk_set_frame_text_value):
* frame-gtk.c (gtk_create_widgets):
* frame-msw.c (mswindows_init_frame_1):
* frame-msw.c (mswindows_set_title_from_ibyte):
* frame-msw.c (msprinter_init_frame_3):
* frame-x.c (x_set_frame_text_value):
* frame-x.c (x_set_frame_properties):
* frame-x.c (start_drag_internal_1):
* frame-x.c (x_cde_transfer_callback):
* frame-x.c (x_create_widgets):
* glyphs-eimage.c (my_jpeg_output_message):
* glyphs-eimage.c (jpeg_instantiate):
* glyphs-eimage.c (gif_instantiate):
* glyphs-eimage.c (png_instantiate):
* glyphs-eimage.c (tiff_instantiate):
* glyphs-gtk.c (xbm_instantiate_1):
* glyphs-gtk.c (gtk_xbm_instantiate):
* glyphs-gtk.c (gtk_xpm_instantiate):
* glyphs-gtk.c (gtk_xface_instantiate):
* glyphs-gtk.c (cursor_font_instantiate):
* glyphs-gtk.c (gtk_redisplay_widget):
* glyphs-gtk.c (gtk_widget_instantiate_1):
* glyphs-gtk.c (gtk_add_tab_item):
* glyphs-msw.c (mswindows_xpm_instantiate):
* glyphs-msw.c (bmp_instantiate):
* glyphs-msw.c (mswindows_resource_instantiate):
* glyphs-msw.c (xbm_instantiate_1):
* glyphs-msw.c (mswindows_xbm_instantiate):
* glyphs-msw.c (mswindows_xface_instantiate):
* glyphs-msw.c (mswindows_redisplay_widget):
* glyphs-msw.c (mswindows_widget_instantiate):
* glyphs-msw.c (add_tree_item):
* glyphs-msw.c (add_tab_item):
* glyphs-msw.c (mswindows_combo_box_instantiate):
* glyphs-msw.c (mswindows_widget_query_string_geometry):
* glyphs-x.c (x_locate_pixmap_file):
* glyphs-x.c (xbm_instantiate_1):
* glyphs-x.c (x_xbm_instantiate):
* glyphs-x.c (extract_xpm_color_names):
* glyphs-x.c (x_xpm_instantiate):
* glyphs-x.c (x_xface_instantiate):
* glyphs-x.c (autodetect_instantiate):
* glyphs-x.c (safe_XLoadFont):
* glyphs-x.c (cursor_font_instantiate):
* glyphs-x.c (x_redisplay_widget):
* glyphs-x.c (Fchange_subwindow_property):
* glyphs-x.c (x_widget_instantiate):
* glyphs-x.c (x_tab_control_redisplay):
* glyphs.c (pixmap_to_lisp_data):
* gui-x.c (menu_separator_style_and_to_external):
* gui-x.c (add_accel_and_to_external):
* gui-x.c (button_item_to_widget_value):
* hpplay.c (player_error_internal):
* hpplay.c (play_sound_file):
* hpplay.c (play_sound_data):
* intl.c (Fset_current_locale):
* lisp.h:
* menubar-gtk.c (gtk_xemacs_set_accel_keys):
* menubar-msw.c (populate_menu_add_item):
* menubar-msw.c (populate_or_checksum_helper):
* menubar-x.c (menu_item_descriptor_to_widget_value_1):
* nt.c (init_user_info):
* nt.c (get_long_basename):
* nt.c (nt_get_resource):
* nt.c (init_mswindows_environment):
* nt.c (get_cached_volume_information):
* nt.c (mswindows_readdir):
* nt.c (read_unc_volume):
* nt.c (mswindows_stat):
* nt.c (mswindows_getdcwd):
* nt.c (mswindows_executable_type):
* nt.c (Fmswindows_short_file_name):
* ntplay.c (nt_play_sound_file):
* objects-gtk.c:
* objects-gtk.c (gtk_valid_color_name_p):
* objects-gtk.c (gtk_initialize_font_instance):
* objects-gtk.c (gtk_font_list):
* objects-msw.c (font_enum_callback_2):
* objects-msw.c (parse_font_spec):
* objects-x.c (x_parse_nearest_color):
* objects-x.c (x_valid_color_name_p):
* objects-x.c (x_initialize_font_instance):
* objects-x.c (x_font_instance_truename):
* objects-x.c (x_font_list):
* objects-xlike-inc.c (XFUN):
* objects-xlike-inc.c (xft_find_charset_font):
* process-nt.c (mswindows_report_winsock_error):
* process-nt.c (nt_create_process):
* process-nt.c (get_internet_address):
* process-nt.c (nt_open_network_stream):
* process-unix.c:
* process-unix.c (allocate_pty):
* process-unix.c (get_internet_address):
* process-unix.c (unix_canonicalize_host_name):
* process-unix.c (unix_open_network_stream):
* realpath.c:
* select-common.h (lisp_data_to_selection_data):
* select-gtk.c (symbol_to_gtk_atom):
* select-gtk.c (atom_to_symbol):
* select-msw.c (symbol_to_ms_cf):
* select-msw.c (mswindows_register_selection_data_type):
* select-x.c (symbol_to_x_atom):
* select-x.c (x_atom_to_symbol):
* select-x.c (hack_motif_clipboard_selection):
* select-x.c (Fx_store_cutbuffer_internal):
* sound.c (Fplay_sound_file):
* sound.c (Fplay_sound):
* sound.h (sound_perror):
* sysdep.c:
* sysdep.c (qxe_allocating_getcwd):
* sysdep.c (qxe_execve):
* sysdep.c (copy_in_passwd):
* sysdep.c (qxe_getpwnam):
* sysdep.c (qxe_ctime):
* sysdll.c (dll_open):
* sysdll.c (dll_function):
* sysdll.c (dll_variable):
* sysdll.c (search_linked_libs):
* sysdll.c (dll_error):
* sysfile.h:
* sysfile.h (PATHNAME_CONVERT_OUT_TSTR):
* sysfile.h (PATHNAME_CONVERT_OUT_UTF_8):
* sysfile.h (PATHNAME_CONVERT_OUT):
* sysfile.h (LISP_PATHNAME_CONVERT_OUT):
* syswindows.h (ITEXT_TO_TSTR):
* syswindows.h (LOCAL_FILE_FORMAT_TO_TSTR):
* syswindows.h (TSTR_TO_LOCAL_FILE_FORMAT):
* syswindows.h (LOCAL_FILE_FORMAT_TO_INTERNAL_MSWIN):
* syswindows.h (LISP_LOCAL_FILE_FORMAT_MAYBE_URL_TO_TSTR):
* text.h:
* text.h (eicpy_ext_len):
* text.h (enum new_dfc_src_type):
* text.h (EXTERNAL_TO_ITEXT):
* text.h (GET_STRERROR):
* tooltalk.c (check_status):
* tooltalk.c (Fadd_tooltalk_message_arg):
* tooltalk.c (Fadd_tooltalk_pattern_attribute):
* tooltalk.c (Fadd_tooltalk_pattern_arg):
* win32.c (tstr_to_local_file_format):
* win32.c (mswindows_lisp_error_1):
* win32.c (mswindows_report_process_error):
* win32.c (Fmswindows_shell_execute):
* win32.c (mswindows_read_link_1):
Changes involving external/internal format conversion,
mostly code cleanup and renaming.
1. Eliminate the previous macros like LISP_STRING_TO_EXTERNAL
that stored its result in a parameter. The new version of
LISP_STRING_TO_EXTERNAL returns its result through the
return value, same as the previous NEW_LISP_STRING_TO_EXTERNAL.
Use the new-style macros throughout the code.
2. Rename C_STRING_TO_EXTERNAL and friends to ITEXT_TO_EXTERNAL,
in keeping with overall naming rationalization involving
Itext and related types.
Macros involved in previous two:
EXTERNAL_TO_C_STRING -> EXTERNAL_TO_ITEXT
EXTERNAL_TO_C_STRING_MALLOC -> EXTERNAL_TO_ITEXT_MALLOC
SIZED_EXTERNAL_TO_C_STRING -> SIZED_EXTERNAL_TO_ITEXT
SIZED_EXTERNAL_TO_C_STRING_MALLOC -> SIZED_EXTERNAL_TO_ITEXT_MALLOC
C_STRING_TO_EXTERNAL -> ITEXT_TO_EXTERNAL
C_STRING_TO_EXTERNAL_MALLOC -> ITEXT_TO_EXTERNAL_MALLOC
LISP_STRING_TO_EXTERNAL
LISP_STRING_TO_EXTERNAL_MALLOC
LISP_STRING_TO_TSTR
C_STRING_TO_TSTR -> ITEXT_TO_TSTR
TSTR_TO_C_STRING -> TSTR_TO_ITEXT
The following four still return their values through parameters,
since they have more than one value to return:
C_STRING_TO_SIZED_EXTERNAL -> ITEXT_TO_SIZED_EXTERNAL
LISP_STRING_TO_SIZED_EXTERNAL
C_STRING_TO_SIZED_EXTERNAL_MALLOC -> ITEXT_TO_SIZED_EXTERNAL_MALLOC
LISP_STRING_TO_SIZED_EXTERNAL_MALLOC
Sometimes additional casts had to be inserted, since the old
macros played strange games and completely defeated the type system
of the store params.
3. Rewrite many places where direct calls to TO_EXTERNAL_FORMAT
occurred with calls to one of the convenience macros listed above,
or to make_extstring().
4. Eliminate SIZED_C_STRING macros (they were hardly used, anyway)
and use a direct call to TO_EXTERNAL_FORMAT or TO_INTERNAL_FORMAT.
4. Use LISP_PATHNAME_CONVERT_OUT in many places instead of something
like LISP_STRING_TO_EXTERNAL(..., Qfile_name).
5. Eliminate some temporary variables that are no longer necessary
now that we return a value rather than storing it into a variable.
6. Some Mule-izing in database.c.
7. Error functions:
-- A bit of code cleanup in maybe_signal_error_1.
-- Eliminate report_file_type_error; it's just an alias for
signal_error_2 with params in a different order.
-- Fix some places in the hostname-handling code that directly
inserted externally-retrieved error strings into the
supposed ASCII "reason" param instead of doing the right thing
and sticking text descriptive of what was going on in "reason"
and putting the external message in a frob.
8. Use Ascbyte instead of CIbyte in process-unix.c and maybe one
or two other places.
9. Some code cleanup in copy_in_passwd() in sysdep.c.
10. Fix a real bug due to accidental variable shadowing in
tstr_to_local_file_format() in win32.c.
| author | Ben Wing <ben@xemacs.org> |
|---|---|
| date | Fri, 05 Feb 2010 11:02:24 -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)); |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
268 app_name_int = EXTERNAL_TO_ITEXT (app_name, codesys); |
|
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
269 app_class_int = EXTERNAL_TO_ITEXT (app_class, codesys); |
|
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
270 value_addr_int = EXTERNAL_TO_ITEXT (value.addr, codesys); |
| 771 | 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 | |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
392 LISP_STRING_TO_SIZED_EXTERNAL (str, data, len, Qbinary); |
| 771 | 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 | |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
627 disp_name = LISP_STRING_TO_EXTERNAL (display, 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) | |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
651 app_class = LISP_STRING_TO_EXTERNAL (Vx_emacs_application_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 { | |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
700 LISP_PATHNAME_CONVERT_OUT (Vx_app_defaults_directory, data_dir); |
| 2367 | 701 path = alloca_extbytes (strlen (data_dir) + strlen (locale) + 7); |
| 3644 | 702 format = "%s%s/Emacs"; |
| 428 | 703 } |
| 704 else if (STRINGP (Vdata_directory) && XSTRING_LENGTH (Vdata_directory) > 0) | |
| 705 { | |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
706 LISP_PATHNAME_CONVERT_OUT (Vdata_directory, data_dir); |
| 2367 | 707 path = alloca_extbytes (strlen (data_dir) + 13 + strlen (locale) + 7); |
| 3644 | 708 format = "%sapp-defaults/%s/Emacs"; |
| 428 | 709 } |
|
4404
80e07b006f9c
Prevent access to uninitialized variables in x_init_device.
Jerry James <james@xemacs.org>
parents:
4117
diff
changeset
|
710 else |
|
80e07b006f9c
Prevent access to uninitialized variables in x_init_device.
Jerry James <james@xemacs.org>
parents:
4117
diff
changeset
|
711 { |
|
80e07b006f9c
Prevent access to uninitialized variables in x_init_device.
Jerry James <james@xemacs.org>
parents:
4117
diff
changeset
|
712 goto no_data_directory; |
|
80e07b006f9c
Prevent access to uninitialized variables in x_init_device.
Jerry James <james@xemacs.org>
parents:
4117
diff
changeset
|
713 } |
| 3644 | 714 |
| 715 /* | |
| 716 * The general form for $LANG is <language>_<country>.<encoding>. Try | |
| 717 * that form, <language>_<country> and <language> and load for first | |
| 718 * app-defaults file found. | |
| 719 */ | |
| 720 | |
| 721 sprintf (path, format, data_dir, locale); | |
| 722 if (!access (path, R_OK)) | |
| 723 XrmCombineFileDatabase (path, &db, False); | |
| 724 | |
| 725 if ((locale_end = strchr(locale, '.'))) { | |
| 726 *locale_end = '\0'; | |
| 727 sprintf (path, format, data_dir, locale); | |
| 728 | |
| 729 if (!access (path, R_OK)) | |
| 730 XrmCombineFileDatabase (path, &db, False); | |
| 731 } | |
| 732 | |
| 733 if ((locale_end = strchr(locale, '_'))) { | |
| 734 *locale_end = '\0'; | |
| 735 sprintf (path, format, data_dir, locale); | |
| 736 | |
| 737 if (!access (path, R_OK)) | |
| 738 XrmCombineFileDatabase (path, &db, False); | |
| 739 } | |
| 740 | |
|
4404
80e07b006f9c
Prevent access to uninitialized variables in x_init_device.
Jerry James <james@xemacs.org>
parents:
4117
diff
changeset
|
741 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
|
742 { |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
743 /* 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
|
744 Extbyte *temp = (Extbyte *) locale; |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
745 xfree (temp, Extbyte*); |
|
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
746 } |
| 428 | 747 } |
| 748 #endif /* MULE */ | |
| 749 | |
| 750 if (NILP (DEVICE_NAME (d))) | |
| 751 DEVICE_NAME (d) = display; | |
| 752 | |
| 753 /* We're going to modify the string in-place, so be a nice XEmacs */ | |
| 754 DEVICE_NAME (d) = Fcopy_sequence (DEVICE_NAME (d)); | |
| 755 /* colons and periods can't appear in individual elements of resource | |
| 756 strings */ | |
| 757 | |
| 758 XtGetApplicationNameAndClass (dpy, (char **) &app_name, (char **) &app_class); | |
| 759 /* search for a matching visual if requested by the user, or setup the display default */ | |
| 760 { | |
| 761 int resource_name_length = max (sizeof (".emacsVisual"), | |
| 762 sizeof (".privateColormap")); | |
| 763 char *buf1 = alloca_array (char, strlen (app_name) + resource_name_length); | |
| 764 char *buf2 = alloca_array (char, strlen (app_class) + resource_name_length); | |
| 765 char *type; | |
| 766 XrmValue value; | |
| 767 | |
| 768 sprintf (buf1, "%s.emacsVisual", app_name); | |
| 769 sprintf (buf2, "%s.EmacsVisual", app_class); | |
| 770 if (XrmGetResource (XtDatabase (dpy), buf1, buf2, &type, &value) == True) | |
| 771 { | |
| 772 int cnt = 0; | |
| 773 int vis_class = PseudoColor; | |
| 774 XVisualInfo vinfo; | |
| 775 char *str = (char*) value.addr; | |
| 776 | |
| 777 #define CHECK_VIS_CLASS(visual_class) \ | |
| 778 else if (memcmp (str, #visual_class, sizeof (#visual_class) - 1) == 0) \ | |
| 779 cnt = sizeof (#visual_class) - 1, vis_class = visual_class | |
| 780 | |
| 781 if (1) | |
| 782 ; | |
| 783 CHECK_VIS_CLASS (StaticGray); | |
| 784 CHECK_VIS_CLASS (StaticColor); | |
| 785 CHECK_VIS_CLASS (TrueColor); | |
| 786 CHECK_VIS_CLASS (GrayScale); | |
| 787 CHECK_VIS_CLASS (PseudoColor); | |
| 788 CHECK_VIS_CLASS (DirectColor); | |
| 789 | |
| 790 if (cnt) | |
| 791 { | |
| 792 depth = atoi (str + cnt); | |
| 793 if (depth == 0) | |
| 794 { | |
| 771 | 795 stderr_out ("Invalid Depth specification in %s... " |
| 796 "ignoring...\n", str); | |
| 428 | 797 } |
| 798 else | |
| 799 { | |
| 800 if (XMatchVisualInfo (dpy, screen, depth, vis_class, &vinfo)) | |
| 801 { | |
| 802 visual = vinfo.visual; | |
| 803 } | |
| 804 else | |
| 805 { | |
| 771 | 806 stderr_out ("Can't match the requested visual %s... " |
| 807 "using defaults\n", str); | |
| 428 | 808 } |
| 809 } | |
| 810 } | |
| 811 else | |
| 812 { | |
| 771 | 813 stderr_out ("Invalid Visual specification in %s... " |
| 814 "ignoring.\n", str); | |
| 428 | 815 } |
| 816 } | |
| 817 if (visual == NULL) | |
| 818 { | |
| 819 /* | |
| 820 visual = DefaultVisual(dpy, screen); | |
| 821 depth = DefaultDepth(dpy, screen); | |
| 822 */ | |
| 823 visual = x_try_best_visual (dpy, screen); | |
| 824 depth = x_get_visual_depth (dpy, visual); | |
| 825 best_visual_found = (visual != DefaultVisual (dpy, screen)); | |
| 826 } | |
| 827 | |
| 828 /* If we've got the same visual as the default and it's PseudoColor, | |
| 829 check to see if the user specified that we need a private colormap */ | |
| 830 if (visual == DefaultVisual (dpy, screen)) | |
| 831 { | |
| 832 sprintf (buf1, "%s.privateColormap", app_name); | |
| 833 sprintf (buf2, "%s.PrivateColormap", app_class); | |
| 1204 | 834 if ((visual->X_CLASSFIELD == PseudoColor) && |
| 771 | 835 (XrmGetResource (XtDatabase (dpy), buf1, buf2, &type, &value) |
| 836 == True)) | |
| 837 cmap = XCopyColormapAndFree (dpy, DefaultColormap (dpy, screen)); | |
| 428 | 838 else |
| 771 | 839 cmap = DefaultColormap (dpy, screen); |
| 428 | 840 } |
| 841 else | |
| 842 { | |
| 843 if ( best_visual_found ) | |
| 771 | 844 cmap = XCreateColormap (dpy, RootWindow (dpy, screen), visual, |
| 845 AllocNone); | |
| 428 | 846 else |
| 847 { | |
| 771 | 848 /* We have to create a matching colormap anyway... #### |
| 849 think about using standard colormaps (need the Xmu | |
| 850 libs?) */ | |
| 851 cmap = XCreateColormap (dpy, RootWindow (dpy, screen), visual, | |
| 852 AllocNone); | |
| 853 XInstallColormap (dpy, cmap); | |
| 428 | 854 } |
| 855 } | |
| 856 } | |
| 857 | |
| 858 DEVICE_X_VISUAL (d) = visual; | |
| 859 DEVICE_X_COLORMAP (d) = cmap; | |
| 860 DEVICE_X_DEPTH (d) = depth; | |
| 861 validify_resource_component ((char *) XSTRING_DATA (DEVICE_NAME (d)), | |
| 862 XSTRING_LENGTH (DEVICE_NAME (d))); | |
| 863 | |
| 2007 | 864 /* #### If we're going to implement X session management, this would |
| 865 be the place. Make sure it doesn't conflict with GNOME. */ | |
| 428 | 866 { |
| 867 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
|
868 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
|
869 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
|
870 Xt_SET_ARG (al[2], XtNcolormap, cmap); |
| 428 | 871 |
| 872 app_shell = XtAppCreateShell (NULL, app_class, | |
| 873 applicationShellWidgetClass, | |
| 874 dpy, al, countof (al)); | |
| 875 } | |
| 876 | |
| 877 DEVICE_XT_APP_SHELL (d) = app_shell; | |
| 878 | |
| 879 #ifdef HAVE_XIM | |
| 880 XIM_init_device(d); | |
| 881 #endif /* HAVE_XIM */ | |
| 882 | |
| 883 /* Realize the app_shell so that its window exists for GC creation purposes, | |
| 884 and set it to the size of the root window for child placement purposes */ | |
| 885 { | |
| 886 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
|
887 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
|
888 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
|
889 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
|
890 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
|
891 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
|
892 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
|
893 HeightOfScreen (ScreenOfDisplay (dpy, screen))); |
| 428 | 894 XtSetValues (app_shell, al, countof (al)); |
| 895 XtRealizeWidget (app_shell); | |
| 896 } | |
| 897 | |
| 898 #ifdef HAVE_WMCOMMAND | |
| 899 { | |
| 900 int new_argc; | |
| 442 | 901 Extbyte **new_argv; |
| 428 | 902 make_argc_argv (Vcommand_line_args, &new_argc, &new_argv); |
| 442 | 903 XSetCommand (XtDisplay (app_shell), XtWindow (app_shell), |
| 904 (char **) new_argv, new_argc); | |
| 428 | 905 free_argc_argv (new_argv); |
| 906 } | |
| 907 #endif /* HAVE_WMCOMMAND */ | |
| 908 | |
| 909 Vx_initial_argv_list = make_arg_list (argc, argv); | |
| 910 free_argc_argv (argv); | |
| 911 | |
| 912 DEVICE_X_WM_COMMAND_FRAME (d) = Qnil; | |
| 913 | |
| 914 sanity_check_geometry_resource (dpy); | |
| 915 | |
| 916 /* In event-Xt.c */ | |
| 917 x_init_modifier_mapping (d); | |
| 918 | |
| 919 DEVICE_INFD (d) = DEVICE_OUTFD (d) = ConnectionNumber (dpy); | |
| 920 init_baud_rate (d); | |
| 921 init_one_device (d); | |
| 922 | |
| 771 | 923 DEVICE_X_GC_CACHE (d) = make_gc_cache (dpy, XtWindow (app_shell)); |
| 428 | 924 DEVICE_X_GRAY_PIXMAP (d) = None; |
| 925 Xatoms_of_device_x (d); | |
| 440 | 926 Xatoms_of_select_x (d); |
| 428 | 927 Xatoms_of_objects_x (d); |
| 928 x_init_device_class (d); | |
| 929 } | |
| 930 | |
| 931 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
|
932 x_finish_init_device (struct device *d, Lisp_Object UNUSED (props)) |
| 428 | 933 { |
|
4477
e34711681f30
Don't determine whether to call general device-type code at startup,
Aidan Kehoe <kehoea@parhasard.net>
parents:
4404
diff
changeset
|
934 call1 (Qmake_device_late_x_entry_point, wrap_device (d)); |
| 428 | 935 } |
| 936 | |
| 937 static void | |
| 938 x_mark_device (struct device *d) | |
| 939 { | |
| 940 mark_object (DEVICE_X_WM_COMMAND_FRAME (d)); | |
| 941 mark_object (DEVICE_X_DATA (d)->x_keysym_map_hash_table); | |
| 942 } | |
| 943 | |
| 944 | |
| 945 /************************************************************************/ | |
| 946 /* closing an X connection */ | |
| 947 /************************************************************************/ | |
| 948 | |
| 4117 | 949 #ifndef NEW_GC |
| 428 | 950 static void |
| 951 free_x_device_struct (struct device *d) | |
| 952 { | |
| 1726 | 953 xfree (d->device_data, void *); |
| 4117 | 954 } |
| 3092 | 955 #endif /* not NEW_GC */ |
| 428 | 956 |
| 957 static void | |
| 958 x_delete_device (struct device *d) | |
| 959 { | |
| 960 Display *display; | |
| 961 #ifdef FREE_CHECKING | |
| 962 extern void (*__free_hook) (void *); | |
| 963 int checking_free; | |
| 964 #endif | |
| 965 | |
| 966 display = DEVICE_X_DISPLAY (d); | |
| 967 | |
| 968 if (display) | |
| 969 { | |
| 970 #ifdef FREE_CHECKING | |
| 971 checking_free = (__free_hook != 0); | |
| 972 | |
| 973 /* Disable strict free checking, to avoid bug in X library */ | |
| 974 if (checking_free) | |
| 975 disable_strict_free_check (); | |
| 976 #endif | |
| 977 | |
| 978 free_gc_cache (DEVICE_X_GC_CACHE (d)); | |
| 979 if (DEVICE_X_DATA (d)->x_modifier_keymap) | |
| 980 XFreeModifiermap (DEVICE_X_DATA (d)->x_modifier_keymap); | |
| 981 if (DEVICE_X_DATA (d)->x_keysym_map) | |
| 982 XFree ((char *) DEVICE_X_DATA (d)->x_keysym_map); | |
| 983 | |
| 984 if (DEVICE_XT_APP_SHELL (d)) | |
| 985 { | |
| 986 XtDestroyWidget (DEVICE_XT_APP_SHELL (d)); | |
| 987 DEVICE_XT_APP_SHELL (d) = NULL; | |
| 988 } | |
| 989 | |
| 990 XtCloseDisplay (display); | |
| 991 DEVICE_X_DISPLAY (d) = 0; | |
| 992 #ifdef FREE_CHECKING | |
| 993 if (checking_free) | |
| 994 enable_strict_free_check (); | |
| 995 #endif | |
| 996 } | |
| 997 | |
| 4117 | 998 #ifndef NEW_GC |
| 428 | 999 free_x_device_struct (d); |
| 4117 | 1000 #endif /* not NEW_GC */ |
| 428 | 1001 } |
| 1002 | |
| 1003 | |
| 1004 /************************************************************************/ | |
| 1005 /* handle X errors */ | |
| 1006 /************************************************************************/ | |
| 1007 | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4834
diff
changeset
|
1008 const Ascbyte * |
| 428 | 1009 x_event_name (int event_type) |
| 1010 { | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4834
diff
changeset
|
1011 static const Ascbyte *events[] = |
| 428 | 1012 { |
| 1013 "0: ERROR!", | |
| 1014 "1: REPLY", | |
| 1015 "KeyPress", | |
| 1016 "KeyRelease", | |
| 1017 "ButtonPress", | |
| 1018 "ButtonRelease", | |
| 1019 "MotionNotify", | |
| 1020 "EnterNotify", | |
| 1021 "LeaveNotify", | |
| 1022 "FocusIn", | |
| 1023 "FocusOut", | |
| 1024 "KeymapNotify", | |
| 1025 "Expose", | |
| 1026 "GraphicsExpose", | |
| 1027 "NoExpose", | |
| 1028 "VisibilityNotify", | |
| 1029 "CreateNotify", | |
| 1030 "DestroyNotify", | |
| 1031 "UnmapNotify", | |
| 1032 "MapNotify", | |
| 1033 "MapRequest", | |
| 1034 "ReparentNotify", | |
| 1035 "ConfigureNotify", | |
| 1036 "ConfigureRequest", | |
| 1037 "GravityNotify", | |
| 1038 "ResizeRequest", | |
| 1039 "CirculateNotify", | |
| 1040 "CirculateRequest", | |
| 1041 "PropertyNotify", | |
| 1042 "SelectionClear", | |
| 1043 "SelectionRequest", | |
| 1044 "SelectionNotify", | |
| 1045 "ColormapNotify", | |
| 1046 "ClientMessage", | |
| 1047 "MappingNotify", | |
| 1048 "LASTEvent" | |
| 1049 }; | |
| 1050 | |
| 1051 if (event_type < 0 || event_type >= countof (events)) | |
| 1052 return NULL; | |
| 1053 return events [event_type]; | |
| 1054 } | |
| 1055 | |
| 1056 /* Handling errors. | |
| 1057 | |
| 1058 If an X error occurs which we are not expecting, we have no alternative | |
| 1059 but to print it to stderr. It would be nice to stuff it into a pop-up | |
| 1060 buffer, or to print it in the minibuffer, but that's not possible, because | |
| 1061 one is not allowed to do any I/O on the display connection from an error | |
| 1062 handler. The guts of Xlib expect these functions to either return or exit. | |
| 1063 | |
| 1064 However, there are occasions when we might expect an error to reasonably | |
| 1065 occur. The interface to this is as follows: | |
| 1066 | |
| 1067 Before calling some X routine which may error, call | |
| 1068 expect_x_error (dpy); | |
| 1069 | |
| 1070 Just after calling the X routine, call either: | |
| 1071 | |
| 1072 x_error_occurred_p (dpy); | |
| 1073 | |
| 1074 to ask whether an error happened (and was ignored), or: | |
| 1075 | |
| 1076 signal_if_x_error (dpy, resumable_p); | |
| 1077 | |
| 1078 which will call Fsignal() with args appropriate to the X error, if there | |
| 1079 was one. (Resumable_p is whether the debugger should be allowed to | |
| 1080 continue from the call to signal.) | |
| 1081 | |
| 1082 You must call one of these two routines immediately after calling the X | |
| 1083 routine; think of them as bookends like BLOCK_INPUT and UNBLOCK_INPUT. | |
| 1084 */ | |
| 1085 | |
| 1086 static int error_expected; | |
| 1087 static int error_occurred; | |
| 1088 static XErrorEvent last_error; | |
| 1089 | |
| 1090 /* OVERKILL! */ | |
| 1091 | |
| 1092 #ifdef EXTERNAL_WIDGET | |
| 1093 static Lisp_Object | |
| 1094 x_error_handler_do_enqueue (Lisp_Object frame) | |
| 1095 { | |
| 1096 enqueue_magic_eval_event (io_error_delete_frame, frame); | |
| 1097 return Qt; | |
| 1098 } | |
| 1099 | |
| 1100 static Lisp_Object | |
| 2333 | 1101 x_error_handler_error (Lisp_Object UNUSED (data), Lisp_Object UNUSED (dummy)) |
| 428 | 1102 { |
| 1103 return Qnil; | |
| 1104 } | |
| 1105 #endif /* EXTERNAL_WIDGET */ | |
| 1106 | |
| 1107 int | |
| 1108 x_error_handler (Display *disp, XErrorEvent *event) | |
| 1109 { | |
| 1110 if (error_expected) | |
| 1111 { | |
| 1112 error_expected = 0; | |
| 1113 error_occurred = 1; | |
| 1114 last_error = *event; | |
| 1115 } | |
| 1116 else | |
| 1117 { | |
| 853 | 1118 int depth; |
| 1119 | |
| 428 | 1120 #ifdef EXTERNAL_WIDGET |
| 1121 struct frame *f; | |
| 1122 struct device *d = get_device_from_display (disp); | |
| 1123 | |
| 1124 if ((event->error_code == BadWindow || | |
| 1125 event->error_code == BadDrawable) | |
| 1126 && ((f = x_any_window_to_frame (d, event->resourceid)) != 0)) | |
| 1127 { | |
| 1128 Lisp_Object frame; | |
| 1129 | |
| 1130 /* one of the windows comprising one of our frames has died. | |
| 1131 This occurs particularly with ExternalShell frames when the | |
| 1132 client that owns the ExternalShell's window dies. | |
| 1133 | |
| 1134 We cannot do any I/O on the display connection so we need | |
| 1135 to enqueue an eval event so that the deletion happens | |
| 1136 later. | |
| 1137 | |
| 1138 Furthermore, we need to trap any errors (out-of-memory) that | |
| 1139 may occur when Fenqueue_eval_event is called. | |
| 1140 */ | |
| 1141 | |
| 1142 if (f->being_deleted) | |
| 1143 return 0; | |
| 793 | 1144 frame = wrap_frame (f); |
| 428 | 1145 if (!NILP (condition_case_1 (Qerror, x_error_handler_do_enqueue, |
| 1146 frame, x_error_handler_error, Qnil))) | |
| 1147 { | |
| 1148 f->being_deleted = 1; | |
| 1149 f->visible = 0; | |
| 1150 } | |
| 1151 return 0; | |
| 1152 } | |
| 1153 #endif /* EXTERNAL_WIDGET */ | |
| 1154 | |
| 853 | 1155 /* #### this should issue a warning instead of outputting to stderr */ |
| 1156 depth = begin_dont_check_for_quit (); | |
| 2007 | 1157 #if 0 |
| 1158 /* This ends up calling X, which isn't allowed in an X error handler | |
| 1159 */ | |
| 428 | 1160 stderr_out ("\n%s: ", |
| 1161 (STRINGP (Vinvocation_name) | |
| 1162 ? (char *) XSTRING_DATA (Vinvocation_name) | |
| 1163 : "xemacs")); | |
| 2007 | 1164 #endif |
| 428 | 1165 XmuPrintDefaultErrorMessage (disp, event, stderr); |
| 853 | 1166 unbind_to (depth); |
| 428 | 1167 } |
| 1168 return 0; | |
| 1169 } | |
| 1170 | |
| 1171 void | |
| 1172 expect_x_error (Display *dpy) | |
| 1173 { | |
| 1174 assert (!error_expected); | |
| 1175 XSync (dpy, 0); /* handle pending errors before setting flag */ | |
| 1176 error_expected = 1; | |
| 1177 error_occurred = 0; | |
| 1178 } | |
| 1179 | |
| 1180 int | |
| 1181 x_error_occurred_p (Display *dpy) | |
| 1182 { | |
| 1183 int val; | |
| 1184 XSync (dpy, 0); /* handle pending errors before setting flag */ | |
| 1185 val = error_occurred; | |
| 1186 error_expected = 0; | |
| 1187 error_occurred = 0; | |
| 1188 return val; | |
| 1189 } | |
| 1190 | |
| 1191 int | |
| 1192 signal_if_x_error (Display *dpy, int resumable_p) | |
| 1193 { | |
| 771 | 1194 Extbyte buf[1024]; |
| 867 | 1195 Ibyte num[100]; |
| 428 | 1196 Lisp_Object data; |
| 1197 if (! x_error_occurred_p (dpy)) | |
| 1198 return 0; | |
| 1199 data = Qnil; | |
| 771 | 1200 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
|
1201 data = Fcons (build_istring (num), data); |
| 771 | 1202 qxesprintf (num, "%d", last_error.request_code); |
| 1203 XGetErrorDatabaseText (last_error.display, "XRequest", (char *) num, "", | |
| 1204 buf, sizeof (buf)); | |
| 1205 if (*buf) | |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1206 data = Fcons (build_extstring (buf, Qx_error_message_encoding), data); |
| 771 | 1207 else |
| 1208 { | |
| 1209 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
|
1210 data = Fcons (build_istring (num), data); |
| 771 | 1211 } |
| 428 | 1212 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
|
1213 data = Fcons (build_extstring (buf, Qx_error_message_encoding), data); |
| 428 | 1214 again: |
| 1215 Fsignal (Qx_error, data); | |
| 1216 if (! resumable_p) goto again; | |
| 1217 return 1; | |
| 1218 } | |
| 1219 | |
| 1220 int | |
| 1221 x_IO_error_handler (Display *disp) | |
| 1222 { | |
| 1223 /* This function can GC */ | |
| 1224 Lisp_Object dev; | |
| 1225 struct device *d = get_device_from_display_1 (disp); | |
| 1226 | |
| 756 | 1227 if (!d) |
| 1228 d = device_being_initialized; | |
| 1229 | |
| 428 | 1230 assert (d != NULL); |
| 793 | 1231 dev = wrap_device (d); |
| 428 | 1232 |
| 1233 if (NILP (find_nonminibuffer_frame_not_on_device (dev))) | |
| 1234 { | |
| 853 | 1235 int depth = begin_dont_check_for_quit (); |
| 428 | 1236 /* We're going down. */ |
| 867 | 1237 Ibyte *errmess; |
| 771 | 1238 GET_STRERROR (errmess, errno); |
| 1239 stderr_out ("\n%s: Fatal I/O Error %d (%s) on display " | |
| 1240 "connection \"%s\"\n", | |
| 1241 (STRINGP (Vinvocation_name) ? | |
| 1242 (char *) XSTRING_DATA (Vinvocation_name) : "xemacs"), | |
| 1243 errno, errmess, DisplayString (disp)); | |
| 1244 stderr_out (" after %lu requests (%lu known processed) with %d " | |
| 1245 "events remaining.\n", | |
| 1246 NextRequest (disp) - 1, LastKnownRequestProcessed (disp), | |
| 1247 QLength (disp)); | |
| 428 | 1248 /* assert (!_Xdebug); */ |
| 853 | 1249 unbind_to (depth); |
| 428 | 1250 } |
| 1251 else | |
| 1252 { | |
| 867 | 1253 Ibyte *errmess; |
| 771 | 1254 GET_STRERROR (errmess, errno); |
| 428 | 1255 warn_when_safe |
| 1256 (Qx, Qcritical, | |
| 1257 "I/O Error %d (%s) on display connection\n" | |
| 2116 | 1258 " \"%s\" after %lu requests (%lu known processed)\n" |
| 428 | 1259 " with %d events remaining.\n" |
| 1260 " Throwing to top level.\n", | |
| 771 | 1261 errno, errmess, DisplayString (disp), |
| 428 | 1262 NextRequest (disp) - 1, LastKnownRequestProcessed (disp), |
| 1263 QLength (disp)); | |
| 1264 } | |
| 1265 | |
| 1266 /* According to X specs, we should not return from this function, or | |
| 1267 Xlib might just decide to exit(). So we mark the offending | |
| 1268 console for deletion and throw to top level. */ | |
| 1269 if (d) | |
| 3466 | 1270 { |
| 1271 enqueue_magic_eval_event (io_error_delete_device, dev); | |
| 1272 DEVICE_X_BEING_DELETED (d) = 1; | |
| 1273 } | |
|
4677
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4548
diff
changeset
|
1274 |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4548
diff
changeset
|
1275 throw_or_bomb_out (Qtop_level, Qnil, 0, Qnil, Qnil); |
| 428 | 1276 |
| 2268 | 1277 RETURN_NOT_REACHED (0); |
| 428 | 1278 } |
| 1279 | |
| 1280 DEFUN ("x-debug-mode", Fx_debug_mode, 1, 2, 0, /* | |
| 1281 With a true arg, make the connection to the X server synchronous. | |
| 1282 With false, make it asynchronous. Synchronous connections are much slower, | |
| 1283 but are useful for debugging. (If you get X errors, make the connection | |
| 1284 synchronous, and use a debugger to set a breakpoint on `x_error_handler'. | |
| 1285 Your backtrace of the C stack will now be useful. In asynchronous mode, | |
| 1286 the stack above `x_error_handler' isn't helpful because of buffering.) | |
| 1287 If DEVICE is not specified, the selected device is assumed. | |
| 1288 | |
| 1289 Calling this function is the same as calling the C function `XSynchronize', | |
| 1290 or starting the program with the `-sync' command line argument. | |
| 1291 */ | |
| 1292 (arg, device)) | |
| 1293 { | |
| 1294 struct device *d = decode_x_device (device); | |
| 1295 | |
| 1296 XSynchronize (DEVICE_X_DISPLAY (d), !NILP (arg)); | |
| 1297 | |
| 1298 if (!NILP (arg)) | |
| 1299 message ("X connection is synchronous"); | |
| 1300 else | |
| 1301 message ("X connection is asynchronous"); | |
| 1302 | |
| 1303 return arg; | |
| 1304 } | |
| 1305 | |
| 1306 | |
| 1307 /************************************************************************/ | |
| 1308 /* X resources */ | |
| 1309 /************************************************************************/ | |
| 1310 | |
| 1311 #if 0 /* bah humbug. The whole "widget == resource" stuff is such | |
| 1312 a crock of shit that I'm just going to ignore it all. */ | |
| 1313 | |
| 1314 /* If widget is NULL, we are retrieving device or global face data. */ | |
| 1315 | |
| 1316 static void | |
| 1317 construct_name_list (Display *display, Widget widget, char *fake_name, | |
| 1204 | 1318 char *fake_class, char *name, char *class_) |
| 428 | 1319 { |
| 1320 char *stack [100][2]; | |
| 2552 | 1321 Widget this_widget; |
| 428 | 1322 int count = 0; |
| 1323 char *name_tail, *class_tail; | |
| 1324 | |
| 1325 if (widget) | |
| 1326 { | |
| 2552 | 1327 for (this_widget = widget; this_widget; |
| 1328 this_widget = XtParent (this_widget)) | |
| 428 | 1329 { |
| 2552 | 1330 stack [count][0] = this_widget->core.name; |
| 1331 stack [count][1] = XtClass (this_widget)->core_class.class_name; | |
| 428 | 1332 count++; |
| 1333 } | |
| 1334 count--; | |
| 1335 } | |
| 1336 else if (fake_name && fake_class) | |
| 1337 { | |
| 1338 stack [count][0] = fake_name; | |
| 1339 stack [count][1] = fake_class; | |
| 1340 count++; | |
| 1341 } | |
| 1342 | |
| 1343 /* The root widget is an application shell; resource lookups use the | |
| 1344 specified application name and application class in preference to | |
| 1345 the name/class of that widget (which is argv[0] / "ApplicationShell"). | |
| 1346 Generally the app name and class will be argv[0] / "Emacs" but | |
| 1347 the former can be set via the -name command-line option, and the | |
| 1348 latter can be set by changing `x-emacs-application-class' in | |
| 1349 lisp/term/x-win.el. | |
| 1350 */ | |
| 1351 XtGetApplicationNameAndClass (display, | |
| 1352 &stack [count][0], | |
| 1353 &stack [count][1]); | |
| 1354 | |
| 1355 name [0] = 0; | |
| 1204 | 1356 class_ [0] = 0; |
| 428 | 1357 |
| 1358 name_tail = name; | |
| 1204 | 1359 class_tail = class_; |
| 428 | 1360 for (; count >= 0; count--) |
| 1361 { | |
| 1362 strcat (name_tail, stack [count][0]); | |
| 1363 for (; *name_tail; name_tail++) | |
| 1364 if (*name_tail == '.') *name_tail = '_'; | |
| 1365 strcat (name_tail, "."); | |
| 1366 name_tail++; | |
| 1367 | |
| 1368 strcat (class_tail, stack [count][1]); | |
| 1369 for (; *class_tail; class_tail++) | |
| 1370 if (*class_tail == '.') *class_tail = '_'; | |
| 1371 strcat (class_tail, "."); | |
| 1372 class_tail++; | |
| 1373 } | |
| 1374 } | |
| 1375 | |
| 1376 #endif /* 0 */ | |
| 1377 | |
| 771 | 1378 static Extbyte_dynarr *name_Extbyte_dynarr; |
| 1379 static Extbyte_dynarr *class_Extbyte_dynarr; | |
| 428 | 1380 |
| 1381 /* Given a locale and device specification from x-get-resource or | |
| 1382 x-get-resource-prefix, return the resource prefix and display to | |
| 1383 fetch the resource on. */ | |
| 1384 | |
| 1385 static void | |
| 1386 x_get_resource_prefix (Lisp_Object locale, Lisp_Object device, | |
| 771 | 1387 Display **display_out, Extbyte_dynarr *name, |
| 1204 | 1388 Extbyte_dynarr *class_) |
| 428 | 1389 { |
| 1390 if (NILP (locale)) | |
| 1391 locale = Qglobal; | |
| 1392 if (NILP (Fvalid_specifier_locale_p (locale))) | |
| 563 | 1393 invalid_argument ("Invalid locale", locale); |
| 428 | 1394 if (WINDOWP (locale)) |
| 1395 /* #### I can't come up with any coherent way of naming windows. | |
| 1396 By relative position? That seems tricky because windows | |
| 1397 can change position, be split, etc. By order of creation? | |
| 1398 That seems less than useful. */ | |
| 563 | 1399 signal_error (Qunimplemented, |
| 1400 "Windows currently can't be resourced", locale); | |
| 428 | 1401 |
| 1402 if (!NILP (device) && !DEVICEP (device)) | |
| 1403 CHECK_DEVICE (device); | |
| 1404 if (DEVICEP (device) && !DEVICE_X_P (XDEVICE (device))) | |
| 1405 device = Qnil; | |
| 1406 if (NILP (device)) | |
| 1407 { | |
| 1408 device = DFW_DEVICE (locale); | |
| 1409 if (DEVICEP (device) && !DEVICE_X_P (XDEVICE (device))) | |
| 1410 device = Qnil; | |
| 1411 if (NILP (device)) | |
| 872 | 1412 device = get_default_device (Qx); |
| 428 | 1413 if (NILP (device)) |
| 1414 { | |
| 1415 *display_out = 0; | |
| 1416 return; | |
| 1417 } | |
| 1418 } | |
| 1419 | |
| 1420 *display_out = DEVICE_X_DISPLAY (XDEVICE (device)); | |
| 1421 | |
| 1422 { | |
| 771 | 1423 Extbyte *appname, *appclass; |
| 428 | 1424 int name_len, class_len; |
| 1425 XtGetApplicationNameAndClass (*display_out, &appname, &appclass); | |
| 1426 name_len = strlen (appname); | |
| 1427 class_len = strlen (appclass); | |
| 771 | 1428 Dynarr_add_many (name, appname, name_len); |
| 1204 | 1429 Dynarr_add_many (class_, appclass, class_len); |
| 4967 | 1430 validify_resource_component (Dynarr_begin (name), name_len); |
| 1431 validify_resource_component (Dynarr_begin (class_), class_len); | |
| 428 | 1432 } |
| 1433 | |
| 1434 if (EQ (locale, Qglobal)) | |
| 1435 return; | |
| 1436 if (BUFFERP (locale)) | |
| 1437 { | |
| 1438 Dynarr_add_literal_string (name, ".buffer."); | |
| 1439 /* we know buffer is live; otherwise we got an error above. */ | |
| 1440 Dynarr_add_validified_lisp_string (name, Fbuffer_name (locale)); | |
| 1204 | 1441 Dynarr_add_literal_string (class_, ".EmacsLocaleType.EmacsBuffer"); |
| 428 | 1442 } |
| 1443 else if (FRAMEP (locale)) | |
| 1444 { | |
| 1445 Dynarr_add_literal_string (name, ".frame."); | |
| 1446 /* we know frame is live; otherwise we got an error above. */ | |
| 1447 Dynarr_add_validified_lisp_string (name, Fframe_name (locale)); | |
| 1204 | 1448 Dynarr_add_literal_string (class_, ".EmacsLocaleType.EmacsFrame"); |
| 428 | 1449 } |
| 1450 else | |
| 1451 { | |
| 1452 assert (DEVICEP (locale)); | |
| 1453 Dynarr_add_literal_string (name, ".device."); | |
| 1454 /* we know device is live; otherwise we got an error above. */ | |
| 1455 Dynarr_add_validified_lisp_string (name, Fdevice_name (locale)); | |
| 1204 | 1456 Dynarr_add_literal_string (class_, ".EmacsLocaleType.EmacsDevice"); |
| 428 | 1457 } |
| 1458 return; | |
| 1459 } | |
| 1460 | |
| 1461 DEFUN ("x-get-resource", Fx_get_resource, 3, 6, 0, /* | |
| 1462 Retrieve an X resource from the resource manager. | |
| 1463 | |
| 1464 The first arg is the name of the resource to retrieve, such as "font". | |
| 1465 The second arg is the class of the resource to retrieve, such as "Font". | |
| 3025 | 1466 The third arg must be one of the symbols `string', `integer', `natnum', or |
| 1467 `boolean', specifying the type of object that the database is searched for. | |
| 428 | 1468 The fourth arg is the locale to search for the resources on, and can |
| 3025 | 1469 currently be a buffer, a frame, a device, or `global'. If omitted, it |
| 1470 defaults to `global'. | |
| 428 | 1471 The fifth arg is the device to search for the resources on. (The resource |
| 1472 database for a particular device is constructed by combining non-device- | |
| 1473 specific resources such as any command-line resources specified and any | |
| 1474 app-defaults files found [or the fallback resources supplied by XEmacs, | |
| 1475 if no app-defaults file is found] with device-specific resources such as | |
| 1476 those supplied using xrdb.) If omitted, it defaults to the device of | |
| 1477 LOCALE, if a device can be derived (i.e. if LOCALE is a frame or device), | |
| 1478 and otherwise defaults to the value of `default-x-device'. | |
| 1479 The sixth arg NOERROR, if non-nil, means do not signal an error if a | |
| 1480 bogus resource specification was retrieved (e.g. if a non-integer was | |
| 1481 given when an integer was requested). In this case, a warning is issued | |
| 442 | 1482 instead, unless NOERROR is t, in which case no warning is issued. |
| 428 | 1483 |
| 1484 The resource names passed to this function are looked up relative to the | |
| 1485 locale. | |
| 1486 | |
| 1487 If you want to search for a subresource, you just need to specify the | |
| 1488 resource levels in NAME and CLASS. For example, NAME could be | |
| 1489 "modeline.attributeFont", and CLASS "Face.AttributeFont". | |
| 1490 | |
| 1491 Specifically, | |
| 1492 | |
| 1493 1) If LOCALE is a buffer, a call | |
| 1494 | |
| 1495 (x-get-resource "foreground" "Foreground" 'string SOME-BUFFER) | |
| 1496 | |
| 1497 is an interface to a C call something like | |
| 1498 | |
| 1499 XrmGetResource (db, "xemacs.buffer.BUFFER-NAME.foreground", | |
| 1500 "Emacs.EmacsLocaleType.EmacsBuffer.Foreground", | |
| 1501 "String"); | |
| 1502 | |
| 1503 2) If LOCALE is a frame, a call | |
| 1504 | |
| 1505 (x-get-resource "foreground" "Foreground" 'string SOME-FRAME) | |
| 1506 | |
| 1507 is an interface to a C call something like | |
| 1508 | |
| 1509 XrmGetResource (db, "xemacs.frame.FRAME-NAME.foreground", | |
| 1510 "Emacs.EmacsLocaleType.EmacsFrame.Foreground", | |
| 1511 "String"); | |
| 1512 | |
| 1513 3) If LOCALE is a device, a call | |
| 1514 | |
| 1515 (x-get-resource "foreground" "Foreground" 'string SOME-DEVICE) | |
| 1516 | |
| 1517 is an interface to a C call something like | |
| 1518 | |
| 1519 XrmGetResource (db, "xemacs.device.DEVICE-NAME.foreground", | |
| 1520 "Emacs.EmacsLocaleType.EmacsDevice.Foreground", | |
| 1521 "String"); | |
| 1522 | |
| 3025 | 1523 4) If LOCALE is `global', a call |
| 428 | 1524 |
| 1525 (x-get-resource "foreground" "Foreground" 'string 'global) | |
| 1526 | |
| 1527 is an interface to a C call something like | |
| 1528 | |
| 1529 XrmGetResource (db, "xemacs.foreground", | |
| 1530 "Emacs.Foreground", | |
| 1531 "String"); | |
| 1532 | |
| 3025 | 1533 Note that for `global', no prefix is added other than that of the |
| 428 | 1534 application itself; thus, you can use this locale to retrieve |
| 1535 arbitrary application resources, if you really want to. | |
| 1536 | |
| 1537 The returned value of this function is nil if the queried resource is not | |
| 1538 found. If the third arg is `string', a string is returned, and if it is | |
| 1539 `integer', an integer is returned. If the third arg is `boolean', then the | |
| 1540 returned value is the list (t) for true, (nil) for false, and is nil to | |
| 430 | 1541 mean ``unspecified''. |
| 428 | 1542 */ |
| 1204 | 1543 (name, class_, type, locale, device, noerror)) |
| 428 | 1544 { |
| 771 | 1545 Extbyte *name_string, *class_string; |
| 1546 Extbyte *raw_result; | |
| 428 | 1547 XrmDatabase db; |
| 1548 Display *display; | |
| 578 | 1549 Error_Behavior errb = decode_error_behavior_flag (noerror); |
| 771 | 1550 Lisp_Object codesys; |
| 428 | 1551 |
| 1552 CHECK_STRING (name); | |
| 1204 | 1553 CHECK_STRING (class_); |
| 428 | 1554 CHECK_SYMBOL (type); |
| 1555 | |
| 771 | 1556 Dynarr_reset (name_Extbyte_dynarr); |
| 1557 Dynarr_reset (class_Extbyte_dynarr); | |
| 428 | 1558 |
| 1559 x_get_resource_prefix (locale, device, &display, | |
| 771 | 1560 name_Extbyte_dynarr, class_Extbyte_dynarr); |
| 428 | 1561 if (!display) |
| 1562 return Qnil; | |
| 1563 | |
| 1564 db = XtDatabase (display); | |
| 771 | 1565 codesys = coding_system_of_xrm_database (db); |
| 1566 Dynarr_add (name_Extbyte_dynarr, '.'); | |
| 1567 Dynarr_add_lisp_string (name_Extbyte_dynarr, name, Qbinary); | |
| 1568 Dynarr_add (class_Extbyte_dynarr, '.'); | |
| 1204 | 1569 Dynarr_add_lisp_string (class_Extbyte_dynarr, class_, Qbinary); |
| 771 | 1570 Dynarr_add (name_Extbyte_dynarr, '\0'); |
| 1571 Dynarr_add (class_Extbyte_dynarr, '\0'); | |
| 428 | 1572 |
| 4967 | 1573 name_string = Dynarr_begin (name_Extbyte_dynarr); |
| 1574 class_string = Dynarr_begin (class_Extbyte_dynarr); | |
| 428 | 1575 |
| 1576 { | |
| 1577 XrmValue xrm_value; | |
| 1578 XrmName namelist[100]; | |
| 1579 XrmClass classlist[100]; | |
| 1580 XrmName *namerest = namelist; | |
| 1581 XrmClass *classrest = classlist; | |
| 1582 XrmRepresentation xrm_type; | |
| 1583 XrmRepresentation string_quark; | |
| 1584 int result; | |
| 1585 XrmStringToNameList (name_string, namelist); | |
| 1586 XrmStringToClassList (class_string, classlist); | |
| 1587 string_quark = XrmStringToQuark ("String"); | |
| 1588 | |
| 1589 /* ensure that they have the same length */ | |
| 1590 while (namerest[0] && classrest[0]) | |
| 1591 namerest++, classrest++; | |
| 1592 if (namerest[0] || classrest[0]) | |
| 563 | 1593 { |
| 1594 maybe_signal_error_2 | |
| 1595 (Qstructure_formation_error, | |
| 1204 | 1596 "class list and name list must be the same length", name, class_, |
| 563 | 1597 Qresource, errb); |
| 1598 return Qnil; | |
| 1599 } | |
| 428 | 1600 result = XrmQGetResource (db, namelist, classlist, &xrm_type, &xrm_value); |
| 1601 | |
| 1602 if (result != True || xrm_type != string_quark) | |
| 1603 return Qnil; | |
| 771 | 1604 raw_result = (Extbyte *) xrm_value.addr; |
| 428 | 1605 } |
| 1606 | |
| 1607 if (EQ (type, Qstring)) | |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1608 return build_extstring (raw_result, codesys); |
| 428 | 1609 else if (EQ (type, Qboolean)) |
| 1610 { | |
| 771 | 1611 if (!strcasecmp (raw_result, "off") || |
| 1612 !strcasecmp (raw_result, "false") || | |
| 1613 !strcasecmp (raw_result, "no")) | |
| 428 | 1614 return Fcons (Qnil, Qnil); |
| 771 | 1615 if (!strcasecmp (raw_result, "on") || |
| 1616 !strcasecmp (raw_result, "true") || | |
| 1617 !strcasecmp (raw_result, "yes")) | |
| 428 | 1618 return Fcons (Qt, Qnil); |
| 563 | 1619 return maybe_signal_continuable_error_2 |
| 1620 (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
|
1621 build_extstring (name_string, Qbinary), |
|
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1622 build_extstring (raw_result, codesys), Qresource, |
| 563 | 1623 errb); |
| 428 | 1624 } |
| 1625 else if (EQ (type, Qinteger) || EQ (type, Qnatnum)) | |
| 1626 { | |
| 1627 int i; | |
| 1628 char c; | |
| 1629 if (1 != sscanf (raw_result, "%d%c", &i, &c)) | |
| 563 | 1630 return maybe_signal_continuable_error_2 |
| 1631 (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
|
1632 build_extstring (name_string, Qbinary), |
|
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1633 build_extstring (raw_result, codesys), Qresource, |
| 563 | 1634 errb); |
| 428 | 1635 else if (EQ (type, Qnatnum) && i < 0) |
| 563 | 1636 return maybe_signal_continuable_error_2 |
| 1637 (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
|
1638 make_int (i), build_extstring (name_string, Qbinary), |
| 771 | 1639 Qresource, errb); |
| 428 | 1640 else |
| 1641 return make_int (i); | |
| 1642 } | |
| 1643 else | |
| 1644 { | |
| 1645 return maybe_signal_continuable_error | |
| 563 | 1646 (Qwrong_type_argument, "Should be string, integer, natnum or boolean", |
| 1647 type, Qresource, errb); | |
| 428 | 1648 } |
| 1649 } | |
| 1650 | |
| 1651 DEFUN ("x-get-resource-prefix", Fx_get_resource_prefix, 1, 2, 0, /* | |
| 1652 Return the resource prefix for LOCALE on DEVICE. | |
| 1653 The resource prefix is the strings used to prefix resources if | |
| 1654 the LOCALE and DEVICE arguments were passed to `x-get-resource'. | |
| 1655 The returned value is a cons of a name prefix and a class prefix. | |
| 1656 For example, if LOCALE is a frame, the returned value might be | |
| 1657 \("xemacs.frame.FRAME-NAME" . "Emacs.EmacsLocaleType.EmacsFrame"). | |
| 1658 If no valid X device for resourcing can be obtained, this function | |
| 1659 returns nil. (In such a case, `x-get-resource' would always return nil.) | |
| 1660 */ | |
| 1661 (locale, device)) | |
| 1662 { | |
| 1663 Display *display; | |
| 1664 | |
| 771 | 1665 Dynarr_reset (name_Extbyte_dynarr ); |
| 1666 Dynarr_reset (class_Extbyte_dynarr); | |
| 428 | 1667 |
| 1668 x_get_resource_prefix (locale, device, &display, | |
| 771 | 1669 name_Extbyte_dynarr, class_Extbyte_dynarr); |
| 428 | 1670 if (!display) |
| 1671 return Qnil; | |
| 1672 | |
| 4967 | 1673 return Fcons (make_string ((Ibyte *) Dynarr_begin (name_Extbyte_dynarr), |
| 771 | 1674 Dynarr_length (name_Extbyte_dynarr)), |
| 4967 | 1675 make_string ((Ibyte *) Dynarr_begin (class_Extbyte_dynarr), |
| 771 | 1676 Dynarr_length (class_Extbyte_dynarr))); |
| 428 | 1677 } |
| 1678 | |
| 1679 DEFUN ("x-put-resource", Fx_put_resource, 1, 2, 0, /* | |
| 1680 Add a resource to the resource database for DEVICE. | |
| 1681 RESOURCE-LINE specifies the resource to add and should be a | |
| 1682 standard resource specification. | |
| 1683 */ | |
| 1684 (resource_line, device)) | |
| 1685 { | |
| 1686 struct device *d = decode_device (device); | |
| 1687 | |
| 1688 if (DEVICE_X_P (d)) | |
| 1689 { | |
| 1690 XrmDatabase db = XtDatabase (DEVICE_X_DISPLAY (d)); | |
| 771 | 1691 Extbyte *str, *colon_pos; |
| 1692 | |
| 1693 CHECK_STRING (resource_line); | |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
1694 str = LISP_STRING_TO_EXTERNAL (resource_line, |
|
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
1695 coding_system_of_xrm_database (db)); |
| 771 | 1696 if (!(colon_pos = strchr (str, ':')) || strchr (str, '\n')) |
| 1697 invalid: | |
| 1698 syntax_error ("Invalid resource line", resource_line); | |
| 1699 if ((int) | |
| 1700 strspn (str, | |
| 1701 /* Only the following chars are allowed before the colon */ | |
| 1702 " \t.*?abcdefghijklmnopqrstuvwxyz" | |
| 1703 "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-") | |
| 1704 != colon_pos - str) | |
| 1705 goto invalid; | |
| 1706 | |
| 428 | 1707 XrmPutLineResource (&db, str); |
| 1708 } | |
| 1709 | |
| 1710 return Qnil; | |
| 1711 } | |
| 1712 | |
| 1713 | |
| 1714 /************************************************************************/ | |
| 1715 /* display information functions */ | |
| 1716 /************************************************************************/ | |
| 1717 | |
| 1718 DEFUN ("default-x-device", Fdefault_x_device, 0, 0, 0, /* | |
| 1719 Return the default X device for resourcing. | |
| 1720 This is the first-created X device that still exists. | |
| 872 | 1721 See also `default-device'. |
| 428 | 1722 */ |
| 1723 ()) | |
| 1724 { | |
| 872 | 1725 return get_default_device (Qx); |
| 428 | 1726 } |
| 1727 | |
| 1728 DEFUN ("x-display-visual-class", Fx_display_visual_class, 0, 1, 0, /* | |
| 1729 Return the visual class of the X display DEVICE is using. | |
| 1730 This can be altered from the default at startup using the XResource "EmacsVisual". | |
| 1731 The returned value will be one of the symbols `static-gray', `gray-scale', | |
| 1732 `static-color', `pseudo-color', `true-color', or `direct-color'. | |
| 1733 */ | |
| 1734 (device)) | |
| 1735 { | |
| 1736 Visual *vis = DEVICE_X_VISUAL (decode_x_device (device)); | |
| 1204 | 1737 switch (vis->X_CLASSFIELD) |
| 428 | 1738 { |
| 1739 case StaticGray: return intern ("static-gray"); | |
| 1740 case GrayScale: return intern ("gray-scale"); | |
| 1741 case StaticColor: return intern ("static-color"); | |
| 1742 case PseudoColor: return intern ("pseudo-color"); | |
| 1743 case TrueColor: return intern ("true-color"); | |
| 1744 case DirectColor: return intern ("direct-color"); | |
| 1745 default: | |
| 563 | 1746 invalid_state ("display has an unknown visual class", Qunbound); |
| 428 | 1747 return Qnil; /* suppress compiler warning */ |
| 1748 } | |
| 1749 } | |
| 1750 | |
| 1751 DEFUN ("x-display-visual-depth", Fx_display_visual_depth, 0, 1, 0, /* | |
| 1752 Return the bitplane depth of the visual the X display DEVICE is using. | |
| 1753 */ | |
| 1754 (device)) | |
| 1755 { | |
| 1756 return make_int (DEVICE_X_DEPTH (decode_x_device (device))); | |
| 1757 } | |
| 1758 | |
| 1759 static Lisp_Object | |
| 1760 x_device_system_metrics (struct device *d, | |
| 1761 enum device_metrics m) | |
| 1762 { | |
| 1763 Display *dpy = DEVICE_X_DISPLAY (d); | |
| 1764 | |
| 1765 switch (m) | |
| 1766 { | |
| 1767 case DM_size_device: | |
| 1768 return Fcons (make_int (DisplayWidth (dpy, DefaultScreen (dpy))), | |
| 1769 make_int (DisplayHeight (dpy, DefaultScreen (dpy)))); | |
| 1770 case DM_size_device_mm: | |
| 1771 return Fcons (make_int (DisplayWidthMM (dpy, DefaultScreen (dpy))), | |
| 1772 make_int (DisplayHeightMM (dpy, DefaultScreen (dpy)))); | |
| 1773 case DM_num_bit_planes: | |
| 1774 return make_int (DisplayPlanes (dpy, DefaultScreen (dpy))); | |
| 1775 case DM_num_color_cells: | |
| 1776 return make_int (DisplayCells (dpy, DefaultScreen (dpy))); | |
| 1942 | 1777 case DM_num_screens: |
| 1778 return make_int (ScreenCount (dpy)); | |
| 1779 case DM_backing_store: | |
| 1780 switch (DoesBackingStore (DefaultScreenOfDisplay (dpy))) | |
| 1781 { | |
| 1782 case Always: | |
| 1783 return intern ("always"); | |
| 1784 case WhenMapped: | |
| 1785 return intern ("when-mapped"); | |
| 1786 default: | |
| 1787 return intern ("not-useful"); | |
| 1788 } | |
| 1789 case DM_save_under: | |
| 1790 return (DoesSaveUnders (DefaultScreenOfDisplay (dpy)) == True) | |
| 1791 ? Qt : Qnil; | |
| 428 | 1792 default: /* No such device metric property for X devices */ |
| 1793 return Qunbound; | |
| 1794 } | |
| 1795 } | |
| 1796 | |
| 1797 DEFUN ("x-server-vendor", Fx_server_vendor, 0, 1, 0, /* | |
| 1798 Return the vendor ID string of the X server DEVICE is on. | |
| 1799 Return the empty string if the vendor ID string cannot be determined. | |
| 1800 */ | |
| 1801 (device)) | |
| 1802 { | |
| 1803 Display *dpy = get_x_display (device); | |
| 2367 | 1804 Extbyte *vendor = ServerVendor (dpy); |
| 428 | 1805 |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
1806 return build_extstring (vendor ? vendor : "", Qx_hpc_encoding); |
| 428 | 1807 } |
| 1808 | |
| 1809 DEFUN ("x-server-version", Fx_server_version, 0, 1, 0, /* | |
| 1810 Return the version numbers of the X server DEVICE is on. | |
| 1811 The returned value is a list of three integers: the major and minor | |
| 1812 version numbers of the X Protocol in use, and the vendor-specific release | |
| 1813 number. See also `x-server-vendor'. | |
| 1814 */ | |
| 1815 (device)) | |
| 1816 { | |
| 1817 Display *dpy = get_x_display (device); | |
| 1818 | |
| 1819 return list3 (make_int (ProtocolVersion (dpy)), | |
| 1820 make_int (ProtocolRevision (dpy)), | |
| 1821 make_int (VendorRelease (dpy))); | |
| 1822 } | |
| 1823 | |
| 1824 DEFUN ("x-valid-keysym-name-p", Fx_valid_keysym_name_p, 1, 1, 0, /* | |
| 1825 Return true if KEYSYM names a keysym that the X library knows about. | |
| 1826 Valid keysyms are listed in the files /usr/include/X11/keysymdef.h and in | |
| 1827 /usr/lib/X11/XKeysymDB, or whatever the equivalents are on your system. | |
| 1828 */ | |
| 1829 (keysym)) | |
| 1830 { | |
| 2367 | 1831 const Extbyte *keysym_ext; |
| 428 | 1832 |
| 1833 CHECK_STRING (keysym); | |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
1834 keysym_ext = LISP_STRING_TO_EXTERNAL (keysym, Qctext); |
| 428 | 1835 |
| 1836 return XStringToKeysym (keysym_ext) ? Qt : Qnil; | |
| 1837 } | |
| 1838 | |
| 1839 DEFUN ("x-keysym-hash-table", Fx_keysym_hash_table, 0, 1, 0, /* | |
| 440 | 1840 Return a hash table containing a key for all keysyms on DEVICE. |
| 1841 DEVICE must be an X11 display device. See `x-keysym-on-keyboard-p'. | |
| 428 | 1842 */ |
| 1843 (device)) | |
| 1844 { | |
| 1845 struct device *d = decode_device (device); | |
| 1846 if (!DEVICE_X_P (d)) | |
| 563 | 1847 gui_error ("Not an X device", device); |
| 428 | 1848 |
| 1849 return DEVICE_X_DATA (d)->x_keysym_map_hash_table; | |
| 1850 } | |
| 1851 | |
| 1852 DEFUN ("x-keysym-on-keyboard-sans-modifiers-p", Fx_keysym_on_keyboard_sans_modifiers_p, | |
| 1853 1, 2, 0, /* | |
| 1854 Return true if KEYSYM names a key on the keyboard of DEVICE. | |
| 1855 More precisely, return true if pressing a physical key | |
| 1856 on the keyboard of DEVICE without any modifier keys generates KEYSYM. | |
| 1857 Valid keysyms are listed in the files /usr/include/X11/keysymdef.h and in | |
| 1858 /usr/lib/X11/XKeysymDB, or whatever the equivalents are on your system. | |
| 1859 The keysym name can be provided in two forms: | |
| 1860 - if keysym is a string, it must be the name as known to X windows. | |
| 1861 - if keysym is a symbol, it must be the name as known to XEmacs. | |
| 1862 The two names differ in capitalization and underscoring. | |
| 1863 */ | |
| 1864 (keysym, device)) | |
| 1865 { | |
| 1866 struct device *d = decode_device (device); | |
| 1867 if (!DEVICE_X_P (d)) | |
| 563 | 1868 gui_error ("Not an X device", device); |
| 428 | 1869 |
| 1870 return (EQ (Qsans_modifiers, | |
| 1871 Fgethash (keysym, DEVICE_X_KEYSYM_MAP_HASH_TABLE (d), Qnil)) ? | |
| 1872 Qt : Qnil); | |
| 1873 } | |
| 1874 | |
| 1875 | |
| 1876 DEFUN ("x-keysym-on-keyboard-p", Fx_keysym_on_keyboard_p, 1, 2, 0, /* | |
| 1877 Return true if KEYSYM names a key on the keyboard of DEVICE. | |
| 1878 More precisely, return true if some keystroke (possibly including modifiers) | |
| 1879 on the keyboard of DEVICE keys generates KEYSYM. | |
| 1880 Valid keysyms are listed in the files /usr/include/X11/keysymdef.h and in | |
| 1881 /usr/lib/X11/XKeysymDB, or whatever the equivalents are on your system. | |
| 1882 The keysym name can be provided in two forms: | |
| 1883 - if keysym is a string, it must be the name as known to X windows. | |
| 1884 - if keysym is a symbol, it must be the name as known to XEmacs. | |
| 1885 The two names differ in capitalization and underscoring. | |
| 2828 | 1886 |
| 1887 This function is not entirely trustworthy, in that Xlib compose processing | |
| 1888 can produce keysyms that XEmacs will not have seen when it examined the | |
| 1889 keysyms available on startup. So pressing `dead-diaeresis' and then 'a' may | |
| 1890 pass `adiaeresis' to XEmacs, or (in some implementations) even `U00E4', | |
| 1891 where `(x-keysym-on-keyboard-p 'adiaeresis)' and `(x-keysym-on-keyboard-p | |
| 1892 'U00E4)' would both have returned nil. Subsequent to XEmacs seeing a keysym | |
| 1893 it was previously unaware of, the predicate will take note of it, though. | |
| 428 | 1894 */ |
| 1895 (keysym, device)) | |
| 1896 { | |
| 1897 struct device *d = decode_device (device); | |
| 1898 if (!DEVICE_X_P (d)) | |
| 563 | 1899 gui_error ("Not an X device", device); |
| 428 | 1900 |
| 1901 return (NILP (Fgethash (keysym, DEVICE_X_KEYSYM_MAP_HASH_TABLE (d), Qnil)) ? | |
| 1902 Qnil : Qt); | |
| 1903 } | |
| 1904 | |
| 1905 | |
| 1906 /************************************************************************/ | |
| 1907 /* grabs and ungrabs */ | |
| 1908 /************************************************************************/ | |
| 1909 | |
| 1910 DEFUN ("x-grab-pointer", Fx_grab_pointer, 0, 3, 0, /* | |
| 1911 Grab the pointer and restrict it to its current window. | |
| 1912 If optional DEVICE argument is nil, the default device will be used. | |
| 1913 If optional CURSOR argument is non-nil, change the pointer shape to that | |
| 1914 until `x-ungrab-pointer' is called (it should be an object returned by the | |
| 1915 `make-cursor-glyph' function). | |
| 1916 If the second optional argument IGNORE-KEYBOARD is non-nil, ignore all | |
| 1917 keyboard events during the grab. | |
| 1918 Returns t if the grab is successful, nil otherwise. | |
| 1919 */ | |
| 1920 (device, cursor, ignore_keyboard)) | |
| 1921 { | |
| 1922 Window w; | |
| 1923 int pointer_mode, result; | |
| 1924 struct device *d = decode_x_device (device); | |
| 1925 | |
| 1926 if (!NILP (cursor)) | |
| 1927 { | |
| 1928 CHECK_POINTER_GLYPH (cursor); | |
| 1929 cursor = glyph_image_instance (cursor, device, ERROR_ME, 0); | |
| 1930 } | |
| 1931 | |
| 1932 if (!NILP (ignore_keyboard)) | |
| 1933 pointer_mode = GrabModeSync; | |
| 1934 else | |
| 1935 pointer_mode = GrabModeAsync; | |
| 1936 | |
| 1937 w = XtWindow (FRAME_X_TEXT_WIDGET (device_selected_frame (d))); | |
| 1938 | |
| 1939 /* #### Possibly this needs to gcpro the cursor somehow, but it doesn't | |
| 1940 seem to cause a problem if XFreeCursor is called on a cursor in use | |
| 1941 in a grab; I suppose the X server counts the grab as a reference | |
| 1942 and doesn't free it until it exits? */ | |
| 1943 result = XGrabPointer (DEVICE_X_DISPLAY (d), w, | |
| 1944 False, | |
| 1945 ButtonMotionMask | | |
| 1946 ButtonPressMask | | |
| 1947 ButtonReleaseMask | | |
| 1948 PointerMotionHintMask, | |
| 1949 GrabModeAsync, /* Keep pointer events flowing */ | |
| 1950 pointer_mode, /* Stall keyboard events */ | |
| 1951 w, /* Stay in this window */ | |
| 1952 (NILP (cursor) ? 0 | |
| 1953 : XIMAGE_INSTANCE_X_CURSOR (cursor)), | |
| 1954 CurrentTime); | |
| 1955 return (result == GrabSuccess) ? Qt : Qnil; | |
| 1956 } | |
| 1957 | |
| 1958 DEFUN ("x-ungrab-pointer", Fx_ungrab_pointer, 0, 1, 0, /* | |
| 1959 Release a pointer grab made with `x-grab-pointer'. | |
| 1960 If optional first arg DEVICE is nil the default device is used. | |
| 1961 If it is t the pointer will be released on all X devices. | |
| 1962 */ | |
| 1963 (device)) | |
| 1964 { | |
| 1965 if (!EQ (device, Qt)) | |
| 1966 { | |
| 1967 Display *dpy = get_x_display (device); | |
| 1968 XUngrabPointer (dpy, CurrentTime); | |
| 1969 } | |
| 1970 else | |
| 1971 { | |
| 1972 Lisp_Object devcons, concons; | |
| 1973 | |
| 1974 DEVICE_LOOP_NO_BREAK (devcons, concons) | |
| 1975 { | |
| 1976 struct device *d = XDEVICE (XCAR (devcons)); | |
| 1977 | |
| 1978 if (DEVICE_X_P (d)) | |
| 1979 XUngrabPointer (DEVICE_X_DISPLAY (d), CurrentTime); | |
| 1980 } | |
| 1981 } | |
| 1982 | |
| 1983 return Qnil; | |
| 1984 } | |
| 1985 | |
| 1986 DEFUN ("x-grab-keyboard", Fx_grab_keyboard, 0, 1, 0, /* | |
| 1987 Grab the keyboard on the given device (defaulting to the selected one). | |
| 1988 So long as the keyboard is grabbed, all keyboard events will be delivered | |
| 1989 to emacs -- it is not possible for other X clients to eavesdrop on them. | |
| 1990 Ungrab the keyboard with `x-ungrab-keyboard' (use an unwind-protect). | |
| 1991 Returns t if the grab is successful, nil otherwise. | |
| 1992 */ | |
| 1993 (device)) | |
| 1994 { | |
| 1995 struct device *d = decode_x_device (device); | |
| 1996 Window w = XtWindow (FRAME_X_TEXT_WIDGET (device_selected_frame (d))); | |
| 1997 Display *dpy = DEVICE_X_DISPLAY (d); | |
| 1998 Status status; | |
| 1999 XSync (dpy, False); | |
| 2000 status = XGrabKeyboard (dpy, w, True, | |
| 2001 /* I don't really understand sync-vs-async | |
| 2002 grabs, but this is what xterm does. */ | |
| 2003 GrabModeAsync, GrabModeAsync, | |
| 2004 /* Use the timestamp of the last user action | |
| 2005 read by emacs proper; xterm uses CurrentTime | |
| 2006 but there's a comment that says "wrong"... | |
| 2007 (Despite the name this is the time of the | |
| 2008 last key or mouse event.) */ | |
| 2009 DEVICE_X_MOUSE_TIMESTAMP (d)); | |
| 2010 if (status == GrabSuccess) | |
| 2011 { | |
| 2012 /* The XUngrabKeyboard should generate a FocusIn back to this | |
| 2013 window but it doesn't unless we explicitly set focus to the | |
| 2014 window first (which should already have it. The net result | |
| 2015 is that without this call when x-ungrab-keyboard is called | |
| 2016 the selected frame ends up not having focus. */ | |
| 2017 XSetInputFocus (dpy, w, RevertToParent, DEVICE_X_MOUSE_TIMESTAMP (d)); | |
| 2018 return Qt; | |
| 2019 } | |
| 2020 else | |
| 2021 return Qnil; | |
| 2022 } | |
| 2023 | |
| 2024 DEFUN ("x-ungrab-keyboard", Fx_ungrab_keyboard, 0, 1, 0, /* | |
| 2025 Release a keyboard grab made with `x-grab-keyboard'. | |
| 2026 */ | |
| 2027 (device)) | |
| 2028 { | |
| 2029 Display *dpy = get_x_display (device); | |
| 2030 XUngrabKeyboard (dpy, CurrentTime); | |
| 2031 return Qnil; | |
| 2032 } | |
| 2033 | |
| 2034 DEFUN ("x-get-font-path", Fx_get_font_path, 0, 1, 0, /* | |
| 2035 Get the X Server's font path. | |
| 2036 | |
| 2037 See also `x-set-font-path'. | |
| 2038 */ | |
| 2039 (device)) | |
| 2040 { | |
| 2041 Display *dpy = get_x_display (device); | |
| 2042 int ndirs_return; | |
| 2367 | 2043 const Extbyte **directories = |
| 2044 (const Extbyte **) XGetFontPath (dpy, &ndirs_return); | |
| 428 | 2045 Lisp_Object font_path = Qnil; |
| 2046 | |
| 2047 if (!directories) | |
| 563 | 2048 gui_error ("Can't get X font path", device); |
| 428 | 2049 |
| 2050 while (ndirs_return--) | |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
2051 font_path = Fcons (build_extstring (directories[ndirs_return], |
| 440 | 2052 Qfile_name), |
| 2053 font_path); | |
| 428 | 2054 |
|
4548
b0d2ace4aed1
Call XFreeFontPath appropriately in #'x-get-font-path.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4528
diff
changeset
|
2055 XFreeFontPath ((char **)directories); |
|
b0d2ace4aed1
Call XFreeFontPath appropriately in #'x-get-font-path.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4528
diff
changeset
|
2056 |
| 428 | 2057 return font_path; |
| 2058 } | |
| 2059 | |
| 2060 DEFUN ("x-set-font-path", Fx_set_font_path, 1, 2, 0, /* | |
| 2061 Set the X Server's font path to FONT-PATH. | |
| 2062 | |
| 2063 There is only one font path per server, not one per client. Use this | |
| 2064 sparingly. It uncaches all of the X server's font information. | |
| 2065 | |
| 2066 Font directories should end in the path separator and should contain | |
| 2067 a file called fonts.dir usually created with the program mkfontdir. | |
| 2068 | |
| 2069 Setting the FONT-PATH to nil tells the X server to use the default | |
| 2070 font path. | |
| 2071 | |
| 2072 See also `x-get-font-path'. | |
| 2073 */ | |
| 2074 (font_path, device)) | |
| 2075 { | |
| 2076 Display *dpy = get_x_display (device); | |
| 2367 | 2077 Extbyte **directories; |
| 428 | 2078 int i=0,ndirs=0; |
| 2079 | |
| 2367 | 2080 { |
| 2081 EXTERNAL_LIST_LOOP_2 (path_entry, font_path) | |
| 2082 { | |
| 2083 CHECK_STRING (path_entry); | |
| 2084 ndirs++; | |
| 2085 } | |
| 2086 } | |
| 428 | 2087 |
| 2367 | 2088 directories = alloca_array (Extbyte *, ndirs); |
| 428 | 2089 |
| 2367 | 2090 { |
| 2091 EXTERNAL_LIST_LOOP_2 (path_entry, font_path) | |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
2092 LISP_PATHNAME_CONVERT_OUT (path_entry, directories[i++]); |
| 2367 | 2093 } |
| 428 | 2094 |
| 2095 expect_x_error (dpy); | |
| 2367 | 2096 XSetFontPath (dpy, directories, ndirs); |
| 428 | 2097 signal_if_x_error (dpy, 1/*resumable_p*/); |
| 2098 | |
| 2099 return Qnil; | |
| 2100 } | |
| 2101 | |
| 2102 | |
| 2103 /************************************************************************/ | |
| 2104 /* initialization */ | |
| 2105 /************************************************************************/ | |
| 2106 | |
| 2107 void | |
| 2108 syms_of_device_x (void) | |
| 2109 { | |
| 3092 | 2110 #ifdef NEW_GC |
| 2111 INIT_LRECORD_IMPLEMENTATION (x_device); | |
| 2112 #endif /* NEW_GC */ | |
| 2113 | |
| 428 | 2114 DEFSUBR (Fx_debug_mode); |
| 2115 DEFSUBR (Fx_get_resource); | |
| 2116 DEFSUBR (Fx_get_resource_prefix); | |
| 2117 DEFSUBR (Fx_put_resource); | |
| 2118 | |
| 2119 DEFSUBR (Fdefault_x_device); | |
| 2120 DEFSUBR (Fx_display_visual_class); | |
| 2121 DEFSUBR (Fx_display_visual_depth); | |
| 2122 DEFSUBR (Fx_server_vendor); | |
| 2123 DEFSUBR (Fx_server_version); | |
| 2124 DEFSUBR (Fx_valid_keysym_name_p); | |
| 2125 DEFSUBR (Fx_keysym_hash_table); | |
| 2126 DEFSUBR (Fx_keysym_on_keyboard_p); | |
| 2127 DEFSUBR (Fx_keysym_on_keyboard_sans_modifiers_p); | |
| 2128 | |
| 2129 DEFSUBR (Fx_grab_pointer); | |
| 2130 DEFSUBR (Fx_ungrab_pointer); | |
| 2131 DEFSUBR (Fx_grab_keyboard); | |
| 2132 DEFSUBR (Fx_ungrab_keyboard); | |
| 2133 | |
| 2134 DEFSUBR (Fx_get_font_path); | |
| 2135 DEFSUBR (Fx_set_font_path); | |
| 2136 | |
| 563 | 2137 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
|
2138 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
|
2139 DEFSYMBOL (Qmake_device_late_x_entry_point); |
| 771 | 2140 |
| 2141 #ifdef MULE | |
| 2142 DEFSYMBOL (Qget_coding_system_from_locale); | |
| 2143 #endif | |
| 428 | 2144 } |
| 2145 | |
| 2146 void | |
| 2147 reinit_console_type_create_device_x (void) | |
| 2148 { | |
| 2149 /* Initialize variables to speed up X resource interactions */ | |
| 2367 | 2150 const Ascbyte *valid_resource_chars = |
| 428 | 2151 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"; |
| 2152 while (*valid_resource_chars) | |
| 2153 valid_resource_char_p[(unsigned int) (*valid_resource_chars++)] = 1; | |
| 2154 | |
| 771 | 2155 name_Extbyte_dynarr = Dynarr_new (Extbyte); |
| 2156 class_Extbyte_dynarr = Dynarr_new (Extbyte); | |
| 428 | 2157 } |
| 2158 | |
| 2159 void | |
| 2160 console_type_create_device_x (void) | |
| 2161 { | |
| 2162 reinit_console_type_create_device_x (); | |
| 2163 CONSOLE_HAS_METHOD (x, init_device); | |
| 2164 CONSOLE_HAS_METHOD (x, finish_init_device); | |
| 2165 CONSOLE_HAS_METHOD (x, mark_device); | |
| 2166 CONSOLE_HAS_METHOD (x, delete_device); | |
| 2167 CONSOLE_HAS_METHOD (x, device_system_metrics); | |
| 2168 } | |
| 2169 | |
| 2170 void | |
| 2171 reinit_vars_of_device_x (void) | |
| 2172 { | |
| 2173 error_expected = 0; | |
| 2174 error_occurred = 0; | |
| 2175 | |
| 2176 in_resource_setting = 0; | |
| 2177 } | |
| 2178 | |
| 2179 void | |
| 2180 vars_of_device_x (void) | |
| 2181 { | |
| 2182 DEFVAR_LISP ("x-emacs-application-class", &Vx_emacs_application_class /* | |
| 2183 The X application class of the XEmacs process. | |
| 2184 This controls, among other things, the name of the `app-defaults' file | |
| 2185 that XEmacs will use. For changes to this variable to take effect, they | |
| 2186 must be made before the connection to the X server is initialized, that is, | |
| 2187 this variable may only be changed before emacs is dumped, or by setting it | |
| 2188 in the file lisp/term/x-win.el. | |
| 2189 | |
| 2681 | 2190 If this variable is nil on startup, the application uses `XEmacs'. Versions |
| 2191 previous to 21.5.21 examined the resource database and used `XEmacs' if any | |
| 2192 resources beginning with that string existed, and `Emacs' otherwise, for | |
| 2828 | 2193 greater backward compatibility. However, this has always tended to conflict |
| 2681 | 2194 with GNU Emacs, so this behavior is deprecated--in the short term, you can |
| 2195 restore it in a post-21.5.21 XEmacs by setting the | |
| 2196 USE_EMACS_AS_DEFAULT_APPLICATION_CLASS environment variable to some value, | |
| 2197 but in the medium and long term, you should migrate your X resources. | |
| 428 | 2198 */ ); |
| 2199 Vx_emacs_application_class = Qnil; | |
| 2200 | |
| 2201 DEFVAR_LISP ("x-initial-argv-list", &Vx_initial_argv_list /* | |
| 2202 You don't want to know. | |
| 2203 This is used during startup to communicate the remaining arguments in | |
| 2204 `command-line-args-left' to the C code, which passes the args to | |
| 2205 the X initialization code, which removes some args, and then the | |
| 2206 args are placed back into `x-initial-arg-list' and thence into | |
| 2207 `command-line-args-left'. Perhaps `command-line-args-left' should | |
| 2208 just reside in C. | |
| 2209 */ ); | |
| 2210 Vx_initial_argv_list = Qnil; | |
| 2211 | |
| 2212 DEFVAR_LISP ("x-app-defaults-directory", &Vx_app_defaults_directory /* | |
| 2213 Used by the Lisp code to communicate to the low level X initialization | |
| 2214 where the localized init files are. | |
| 2215 */ ); | |
| 2216 Vx_app_defaults_directory = Qnil; | |
| 2217 | |
| 2218 Fprovide (Qx); | |
| 2219 } |