Mercurial > hg > xemacs-beta
annotate src/sound.c @ 4952:19a72041c5ed
Mule-izing, various fixes related to char * arguments
-------------------- ChangeLog entries follow: --------------------
modules/ChangeLog addition:
2010-01-26 Ben Wing <ben@xemacs.org>
* postgresql/postgresql.c:
* postgresql/postgresql.c (CHECK_LIVE_CONNECTION):
* postgresql/postgresql.c (print_pgresult):
* postgresql/postgresql.c (Fpq_conn_defaults):
* postgresql/postgresql.c (Fpq_connectdb):
* postgresql/postgresql.c (Fpq_connect_start):
* postgresql/postgresql.c (Fpq_result_status):
* postgresql/postgresql.c (Fpq_res_status):
Mule-ize large parts of it.
2010-01-26 Ben Wing <ben@xemacs.org>
* ldap/eldap.c (print_ldap):
* ldap/eldap.c (allocate_ldap):
Use write_ascstring().
src/ChangeLog addition:
2010-01-26 Ben Wing <ben@xemacs.org>
* alloc.c:
* alloc.c (build_ascstring):
* alloc.c (build_msg_cistring):
* alloc.c (staticpro_1):
* alloc.c (staticpro_name):
* alloc.c (staticpro_nodump_1):
* alloc.c (staticpro_nodump_name):
* alloc.c (unstaticpro_nodump_1):
* alloc.c (mcpro_1):
* alloc.c (mcpro_name):
* alloc.c (object_memory_usage_stats):
* alloc.c (common_init_alloc_early):
* alloc.c (init_alloc_once_early):
* buffer.c (print_buffer):
* buffer.c (vars_of_buffer):
* buffer.c (common_init_complex_vars_of_buffer):
* buffer.c (init_initial_directory):
* bytecode.c (invalid_byte_code):
* bytecode.c (print_compiled_function):
* bytecode.c (mark_compiled_function):
* chartab.c (print_table_entry):
* chartab.c (print_char_table):
* config.h.in:
* console-gtk.c:
* console-gtk.c (gtk_device_to_console_connection):
* console-gtk.c (gtk_semi_canonicalize_console_connection):
* console-gtk.c (gtk_canonicalize_console_connection):
* console-gtk.c (gtk_semi_canonicalize_device_connection):
* console-gtk.c (gtk_canonicalize_device_connection):
* console-stream.c (stream_init_frame_1):
* console-stream.c (vars_of_console_stream):
* console-stream.c (init_console_stream):
* console-x.c (x_semi_canonicalize_console_connection):
* console-x.c (x_semi_canonicalize_device_connection):
* console-x.c (x_canonicalize_device_connection):
* console-x.h:
* data.c (eq_with_ebola_notice):
* data.c (Fsubr_interactive):
* data.c (Fnumber_to_string):
* data.c (digit_to_number):
* device-gtk.c (gtk_init_device):
* device-msw.c (print_devmode):
* device-x.c (x_event_name):
* dialog-msw.c (handle_directory_dialog_box):
* dialog-msw.c (handle_file_dialog_box):
* dialog-msw.c (vars_of_dialog_mswindows):
* doc.c (weird_doc):
* doc.c (Fsnarf_documentation):
* doc.c (vars_of_doc):
* dumper.c (pdump):
* dynarr.c:
* dynarr.c (Dynarr_realloc):
* editfns.c (Fuser_real_login_name):
* editfns.c (get_home_directory):
* elhash.c (print_hash_table_data):
* elhash.c (print_hash_table):
* emacs.c (main_1):
* emacs.c (vars_of_emacs):
* emodules.c:
* emodules.c (_emodules_list):
* emodules.c (Fload_module):
* emodules.c (Funload_module):
* emodules.c (Flist_modules):
* emodules.c (find_make_module):
* emodules.c (attempt_module_delete):
* emodules.c (emodules_load):
* emodules.c (emodules_doc_subr):
* emodules.c (emodules_doc_sym):
* emodules.c (syms_of_module):
* emodules.c (vars_of_module):
* emodules.h:
* eval.c (print_subr):
* eval.c (signal_call_debugger):
* eval.c (build_error_data):
* eval.c (signal_error):
* eval.c (maybe_signal_error):
* eval.c (signal_continuable_error):
* eval.c (maybe_signal_continuable_error):
* eval.c (signal_error_2):
* eval.c (maybe_signal_error_2):
* eval.c (signal_continuable_error_2):
* eval.c (maybe_signal_continuable_error_2):
* eval.c (signal_ferror):
* eval.c (maybe_signal_ferror):
* eval.c (signal_continuable_ferror):
* eval.c (maybe_signal_continuable_ferror):
* eval.c (signal_ferror_with_frob):
* eval.c (maybe_signal_ferror_with_frob):
* eval.c (signal_continuable_ferror_with_frob):
* eval.c (maybe_signal_continuable_ferror_with_frob):
* eval.c (syntax_error):
* eval.c (syntax_error_2):
* eval.c (maybe_syntax_error):
* eval.c (sferror):
* eval.c (sferror_2):
* eval.c (maybe_sferror):
* eval.c (invalid_argument):
* eval.c (invalid_argument_2):
* eval.c (maybe_invalid_argument):
* eval.c (invalid_constant):
* eval.c (invalid_constant_2):
* eval.c (maybe_invalid_constant):
* eval.c (invalid_operation):
* eval.c (invalid_operation_2):
* eval.c (maybe_invalid_operation):
* eval.c (invalid_change):
* eval.c (invalid_change_2):
* eval.c (maybe_invalid_change):
* eval.c (invalid_state):
* eval.c (invalid_state_2):
* eval.c (maybe_invalid_state):
* eval.c (wtaerror):
* eval.c (stack_overflow):
* eval.c (out_of_memory):
* eval.c (print_multiple_value):
* eval.c (issue_call_trapping_problems_warning):
* eval.c (backtrace_specials):
* eval.c (backtrace_unevalled_args):
* eval.c (Fbacktrace):
* eval.c (warn_when_safe):
* event-Xt.c (modwarn):
* event-Xt.c (modbarf):
* event-Xt.c (check_modifier):
* event-Xt.c (store_modifier):
* event-Xt.c (emacs_Xt_format_magic_event):
* event-Xt.c (describe_event):
* event-gtk.c (dragndrop_data_received):
* event-gtk.c (store_modifier):
* event-gtk.c (gtk_reset_modifier_mapping):
* event-msw.c (dde_eval_string):
* event-msw.c (Fdde_alloc_advise_item):
* event-msw.c (mswindows_dde_callback):
* event-msw.c (FROB):
* event-msw.c (emacs_mswindows_format_magic_event):
* event-stream.c (external_debugging_print_event):
* event-stream.c (execute_help_form):
* event-stream.c (vars_of_event_stream):
* events.c (print_event_1):
* events.c (print_event):
* events.c (event_equal):
* extents.c (print_extent_1):
* extents.c (print_extent):
* extents.c (vars_of_extents):
* faces.c (print_face):
* faces.c (complex_vars_of_faces):
* file-coding.c:
* file-coding.c (print_coding_system):
* file-coding.c (print_coding_system_in_print_method):
* file-coding.c (default_query_method):
* file-coding.c (find_coding_system):
* file-coding.c (make_coding_system_1):
* file-coding.c (chain_print):
* file-coding.c (undecided_print):
* file-coding.c (gzip_print):
* file-coding.c (vars_of_file_coding):
* file-coding.c (complex_vars_of_file_coding):
* fileio.c:
* fileio.c (report_file_type_error):
* fileio.c (report_error_with_errno):
* fileio.c (report_file_error):
* fileio.c (barf_or_query_if_file_exists):
* fileio.c (vars_of_fileio):
* floatfns.c (matherr):
* fns.c (print_bit_vector):
* fns.c (Fmapconcat):
* fns.c (add_suffix_to_symbol):
* fns.c (add_prefix_to_symbol):
* frame-gtk.c:
* frame-gtk.c (Fgtk_window_id):
* frame-x.c (def):
* frame-x.c (x_cde_transfer_callback):
* frame.c:
* frame.c (Fmake_frame):
* gc.c (show_gc_cursor_and_message):
* gc.c (vars_of_gc):
* glyphs-eimage.c (png_instantiate):
* glyphs-eimage.c (tiff_instantiate):
* glyphs-gtk.c (gtk_print_image_instance):
* glyphs-msw.c (mswindows_print_image_instance):
* glyphs-x.c (x_print_image_instance):
* glyphs-x.c (update_widget_face):
* glyphs.c (make_string_from_file):
* glyphs.c (print_image_instance):
* glyphs.c (signal_image_error):
* glyphs.c (signal_image_error_2):
* glyphs.c (signal_double_image_error):
* glyphs.c (signal_double_image_error_2):
* glyphs.c (xbm_mask_file_munging):
* glyphs.c (pixmap_to_lisp_data):
* glyphs.h:
* gui.c (gui_item_display_flush_left):
* hpplay.c (player_error_internal):
* hpplay.c (myHandler):
* intl-win32.c:
* intl-win32.c (langcode_to_lang):
* intl-win32.c (sublangcode_to_lang):
* intl-win32.c (Fmswindows_get_locale_info):
* intl-win32.c (lcid_to_locale_mule_or_no):
* intl-win32.c (mswindows_multibyte_to_unicode_print):
* intl-win32.c (complex_vars_of_intl_win32):
* keymap.c:
* keymap.c (print_keymap):
* keymap.c (ensure_meta_prefix_char_keymapp):
* keymap.c (Fkey_description):
* keymap.c (Ftext_char_description):
* lisp.h:
* lisp.h (struct):
* lisp.h (DECLARE_INLINE_HEADER):
* lread.c (Fload_internal):
* lread.c (locate_file):
* lread.c (read_escape):
* lread.c (read_raw_string):
* lread.c (read1):
* lread.c (read_list):
* lread.c (read_compiled_function):
* lread.c (init_lread):
* lrecord.h:
* marker.c (print_marker):
* marker.c (marker_equal):
* menubar-msw.c (displayable_menu_item):
* menubar-x.c (command_builder_operate_menu_accelerator):
* menubar.c (vars_of_menubar):
* minibuf.c (reinit_complex_vars_of_minibuf):
* minibuf.c (complex_vars_of_minibuf):
* mule-charset.c (Fmake_charset):
* mule-charset.c (complex_vars_of_mule_charset):
* mule-coding.c (iso2022_print):
* mule-coding.c (fixed_width_query):
* number.c (bignum_print):
* number.c (ratio_print):
* number.c (bigfloat_print):
* number.c (bigfloat_finalize):
* objects-msw.c:
* objects-msw.c (mswindows_color_to_string):
* objects-msw.c (mswindows_color_list):
* objects-tty.c:
* objects-tty.c (tty_font_list):
* objects-tty.c (tty_find_charset_font):
* objects-xlike-inc.c (xft_find_charset_font):
* objects-xlike-inc.c (endif):
* print.c:
* print.c (write_istring):
* print.c (write_ascstring):
* print.c (Fterpri):
* print.c (Fprint):
* print.c (print_error_message):
* print.c (print_vector_internal):
* print.c (print_cons):
* print.c (print_string):
* print.c (printing_unreadable_object):
* print.c (print_internal):
* print.c (print_float):
* print.c (print_symbol):
* process-nt.c (mswindows_report_winsock_error):
* process-nt.c (nt_canonicalize_host_name):
* process-unix.c (unix_canonicalize_host_name):
* process.c (print_process):
* process.c (report_process_error):
* process.c (report_network_error):
* process.c (make_process_internal):
* process.c (Fstart_process_internal):
* process.c (status_message):
* process.c (putenv_internal):
* process.c (vars_of_process):
* process.h:
* profile.c (vars_of_profile):
* rangetab.c (print_range_table):
* realpath.c (vars_of_realpath):
* redisplay.c (vars_of_redisplay):
* search.c (wordify):
* search.c (Freplace_match):
* sheap.c (sheap_adjust_h):
* sound.c (report_sound_error):
* sound.c (Fplay_sound_file):
* specifier.c (print_specifier):
* symbols.c (Fsubr_name):
* symbols.c (do_symval_forwarding):
* symbols.c (set_default_buffer_slot_variable):
* symbols.c (set_default_console_slot_variable):
* symbols.c (store_symval_forwarding):
* symbols.c (default_value):
* symbols.c (defsymbol_massage_name_1):
* symbols.c (defsymbol_massage_name_nodump):
* symbols.c (defsymbol_massage_name):
* symbols.c (defsymbol_massage_multiword_predicate_nodump):
* symbols.c (defsymbol_massage_multiword_predicate):
* symbols.c (defsymbol_nodump):
* symbols.c (defsymbol):
* symbols.c (defkeyword):
* symbols.c (defkeyword_massage_name):
* symbols.c (check_module_subr):
* symbols.c (deferror_1):
* symbols.c (deferror):
* symbols.c (deferror_massage_name):
* symbols.c (deferror_massage_name_and_message):
* symbols.c (defvar_magic):
* symeval.h:
* symeval.h (DEFVAR_SYMVAL_FWD):
* sysdep.c:
* sysdep.c (init_system_name):
* sysdll.c:
* sysdll.c (MAYBE_PREPEND_UNDERSCORE):
* sysdll.c (dll_function):
* sysdll.c (dll_variable):
* sysdll.c (dll_error):
* sysdll.c (dll_open):
* sysdll.c (dll_close):
* sysdll.c (image_for_address):
* sysdll.c (my_find_image):
* sysdll.c (search_linked_libs):
* sysdll.h:
* sysfile.h:
* sysfile.h (DEFAULT_DIRECTORY_FALLBACK):
* syswindows.h:
* tests.c (DFC_CHECK_LENGTH):
* tests.c (DFC_CHECK_CONTENT):
* tests.c (Ftest_hash_tables):
* text.c (vars_of_text):
* text.h:
* tooltalk.c (tt_opnum_string):
* tooltalk.c (tt_message_arg_ival_string):
* tooltalk.c (Ftooltalk_default_procid):
* tooltalk.c (Ftooltalk_default_session):
* tooltalk.c (init_tooltalk):
* tooltalk.c (vars_of_tooltalk):
* ui-gtk.c (Fdll_load):
* ui-gtk.c (type_to_marshaller_type):
* ui-gtk.c (Fgtk_import_function_internal):
* ui-gtk.c (emacs_gtk_object_printer):
* ui-gtk.c (emacs_gtk_boxed_printer):
* unicode.c (unicode_to_ichar):
* unicode.c (unicode_print):
* unicode.c (unicode_query):
* unicode.c (vars_of_unicode):
* unicode.c (complex_vars_of_unicode):
* win32.c:
* win32.c (mswindows_report_process_error):
* window.c (print_window):
* xemacs.def.in.in:
BASIC IDEA: Further fixing up uses of char * and CIbyte *
to reflect their actual semantics; Mule-izing some code;
redoing of the not-yet-working code to handle message translation.
Clean up code to handle message-translation (not yet working).
Create separate versions of build_msg_string() for working with
Ibyte *, CIbyte *, and Ascbyte * arguments. Assert that Ascbyte *
arguments are pure-ASCII. Make build_msg_string() be the same
as build_msg_ascstring(). Create same three versions of GETTEXT()
and DEFER_GETTEXT(). Also create build_defer_string() and
variants for the equivalent of DEFER_GETTEXT() when building a
string. Remove old CGETTEXT(). Clean up code where GETTEXT(),
DEFER_GETTEXT(), build_msg_string(), etc. was being called and
introduce some new calls to build_msg_string(), etc. Remove
GETTEXT() from calls to weird_doc() -- we assume that the
message snarfer knows about weird_doc(). Remove uses of
DEFER_GETTEXT() from error messages in sysdep.c and instead use
special comments /* @@@begin-snarf@@@ */ and /* @@@end-snarf@@@ */
that the message snarfer presumably knows about.
Create build_ascstring() and use it in many instances in place
of build_string(). The purpose of having Ascbyte * variants is
to make the code more self-documenting in terms of what sort of
semantics is expected for char * strings. In fact in the process
of looking for uses of build_string(), much improperly Mule-ized
was discovered.
Mule-ize a lot of code as described in previous paragraph,
e.g. in sysdep.c.
Make the error functions take Ascbyte * strings and fix up a
couple of places where non-pure-ASCII strings were being passed in
(file-coding.c, mule-coding.c, unicode.c). (It's debatable whether
we really need to make the error functions work this way. It
helps catch places where code is written in a way that message
translation won't work, but we may well never implement message
translation.)
Make staticpro() and friends take Ascbyte * strings instead of
raw char * strings. Create a const_Ascbyte_ptr dynarr type
to describe what's held by staticpro_names[] and friends,
create pdump descriptions for const_Ascbyte_ptr dynarrs, and
use them in place of specially-crafted staticpro descriptions.
Mule-ize certain other functions (e.g. x_event_name) by correcting
raw use of char * to Ascbyte *, Rawbyte * or another such type,
and raw use of char[] buffers to another type (usually Ascbyte[]).
Change many uses of write_c_string() to write_msg_string(),
write_ascstring(), etc.
Mule-ize emodules.c, emodules.h, sysdll.h.
Fix some un-Mule-ized code in intl-win32.c.
A comment in event-Xt.c and the limitations of the message
snarfer (make-msgfile or whatever) is presumably incorrect --
it should be smart enough to handle function calls spread over
more than one line. Clean up code in event-Xt.c that was
written awkwardly for this reason.
In config.h.in, instead of NEED_ERROR_CHECK_TYPES_INLINES,
create a more general XEMACS_DEFS_NEEDS_INLINE_DECLS to
indicate when inlined functions need to be declared in
xemacs.defs.in.in, and make use of it in xemacs.defs.in.in.
We need to do this because postgresql.c now calls qxestrdup(),
which is an inline function.
Make nconc2() and other such functions MODULE_API and put
them in xemacs.defs.in.in since postgresql.c now uses them.
Clean up indentation in lread.c and a few other places.
In text.h, document ASSERT_ASCTEXT_ASCII() and
ASSERT_ASCTEXT_ASCII_LEN(), group together the stand-in
encodings and add some more for DLL symbols, function and
variable names, etc.
| author | Ben Wing <ben@xemacs.org> |
|---|---|
| date | Tue, 26 Jan 2010 23:22:30 -0600 |
| parents | fb73a2046d3e |
| children | 4aebb0131297 |
| rev | line source |
|---|---|
| 428 | 1 /* Sound functions. |
| 2 Copyright (C) 1992, 1993, 1994 Lucid Inc. | |
| 3 Copyright (C) 1994, 1995 Free Software Foundation, Inc. | |
| 2526 | 4 Copyright (C) 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 | |
| 563 | 25 /* This file Mule-ized by Ben Wing, 5-15-01. */ |
| 26 | |
| 428 | 27 /* Originally written by Jamie Zawinski. |
| 28 Hacked on quite a bit by various others. */ | |
| 29 | |
| 30 #include <config.h> | |
| 31 #include <time.h> | |
| 32 #include "lisp.h" | |
| 33 | |
| 34 #include "buffer.h" | |
| 35 #ifdef HAVE_X_WINDOWS | |
| 872 | 36 #include "console-x-impl.h" |
| 428 | 37 #endif |
| 872 | 38 #include "device-impl.h" |
| 428 | 39 #include "redisplay.h" |
| 563 | 40 #include "sound.h" |
| 41 | |
| 428 | 42 #include "sysdep.h" |
| 43 | |
| 442 | 44 #include "sysfile.h" |
| 428 | 45 |
| 46 #ifdef HAVE_NATIVE_SOUND | |
| 442 | 47 # include "sysproc.h" |
| 428 | 48 #endif |
| 49 | |
| 872 | 50 #ifdef WIN32_NATIVE |
| 51 #include "syswindows.h" | |
| 52 #endif | |
| 53 | |
| 3072 | 54 #ifdef HAVE_NAS_SOUND |
| 55 #define USED_IF_HAVE_NAS(decl) decl | |
| 56 #else | |
| 57 #define USED_IF_HAVE_NAS(decl) UNUSED (decl) | |
| 58 #endif | |
| 59 | |
| 60 #if defined(HAVE_NATIVE_SOUND) || defined(HAVE_NAS_SOUND) | |
| 61 #define USED_IF_HAVE_NATIVE_OR_NAS(decl) decl | |
| 62 #else | |
| 63 #define USED_IF_HAVE_NATIVE_OR_NAS(decl) UNUSED (decl) | |
| 64 #endif | |
| 65 | |
| 66 #if defined(HAVE_NATIVE_SOUND) || defined(HAVE_NAS_SOUND) \ | |
|
4343
fb73a2046d3e
Fix unused parameter warnings when compiling with ALSA sound support.
Jerry James <james@xemacs.org>
parents:
3731
diff
changeset
|
67 || defined(HAVE_ALSA_SOUND) || defined(HAVE_ESD_SOUND) |
| 3072 | 68 #define USED_IF_HAVE_ANY(decl) decl |
| 69 #else | |
| 70 #define USED_IF_HAVE_ANY(decl) UNUSED (decl) | |
| 71 #endif | |
| 72 | |
| 3308 | 73 #ifdef HAVE_ALSA_SOUND |
| 74 extern int alsa_play_sound_file (const Extbyte *file, int vol); | |
| 75 extern int alsa_play_sound_data (const Binbyte *data, int length, int vol); | |
| 76 # define DEVICE_CONNECTED_TO_ALSA_P(x) 1 /* #### better check */ | |
| 77 #endif | |
| 78 | |
| 428 | 79 #ifdef HAVE_ESD_SOUND |
| 563 | 80 extern int esd_play_sound_file (Extbyte *file, int vol); |
| 2367 | 81 extern int esd_play_sound_data (Binbyte *data, size_t length, int vol); |
| 563 | 82 # define DEVICE_CONNECTED_TO_ESD_P(x) 1 /* #### better check */ |
| 428 | 83 #endif |
| 84 | |
| 3308 | 85 #ifdef HAVE_NAS_SOUND |
| 86 extern int nas_play_sound_file (Extbyte *name, int volume); | |
| 87 extern int nas_play_sound_data (Binbyte *data, int length, int volume); | |
| 88 extern int nas_wait_for_sounds (void); | |
| 89 extern Extbyte *nas_init_play (Display *); | |
| 90 #endif | |
| 91 | |
| 458 | 92 Fixnum bell_volume; |
| 93 Fixnum bell_inhibit_time; | |
| 428 | 94 Lisp_Object Vsound_alist; |
| 95 Lisp_Object Vsynchronous_sounds; | |
| 96 Lisp_Object Vnative_sound_only_on_console; | |
| 97 Lisp_Object Q_volume, Q_pitch, Q_duration, Q_sound; | |
| 563 | 98 Lisp_Object Qsound_error; |
| 428 | 99 |
| 563 | 100 DOESNT_RETURN |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4343
diff
changeset
|
101 report_sound_error (const Ascbyte *reason, Lisp_Object data) |
| 563 | 102 { |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4343
diff
changeset
|
103 report_error_with_errno (Qsound_error, reason, data); |
| 563 | 104 } |
| 428 | 105 |
| 106 DEFUN ("play-sound-file", Fplay_sound_file, 1, 3, "fSound file name: ", /* | |
| 107 Play the named sound file on DEVICE's speaker at the specified volume | |
| 108 \(0-100, default specified by the `bell-volume' variable). | |
| 109 On Unix machines the sound file must be in the Sun/NeXT U-LAW format | |
| 110 except under Linux where WAV files are also supported. On Microsoft | |
| 111 Windows the sound file must be in WAV format. | |
| 112 DEVICE defaults to the selected device. | |
| 113 */ | |
| 3072 | 114 (file, volume, USED_IF_HAVE_ANY (device))) |
| 428 | 115 { |
| 116 /* This function can call lisp */ | |
| 117 int vol; | |
| 3308 | 118 #if defined (HAVE_NATIVE_SOUND) || defined (HAVE_ALSA_SOUND) || \ |
| 119 defined (HAVE_NAS_SOUND) || defined (HAVE_ESD_SOUND) | |
| 428 | 120 struct device *d = decode_device (device); |
| 121 #endif | |
| 122 struct gcpro gcpro1; | |
| 123 | |
| 124 CHECK_STRING (file); | |
| 125 if (NILP (volume)) | |
| 126 vol = bell_volume; | |
| 127 else | |
| 128 { | |
| 129 CHECK_INT (volume); | |
| 130 vol = XINT (volume); | |
| 131 } | |
| 132 | |
| 133 GCPRO1 (file); | |
| 134 while (1) | |
| 135 { | |
| 136 file = Fexpand_file_name (file, Qnil); | |
| 137 if (!NILP(Ffile_readable_p (file))) | |
| 138 break; | |
| 139 else | |
| 140 { | |
| 141 /* #### This is crockish. It might be a better idea to try | |
| 142 to open the file, and use report_file_error() if it | |
| 143 fails. --hniksic */ | |
| 144 if (NILP (Ffile_exists_p (file))) | |
| 145 file = | |
| 563 | 146 signal_continuable_error (Qfile_error, |
| 147 "File does not exist", file); | |
| 428 | 148 else |
| 149 file = | |
| 563 | 150 signal_continuable_error (Qfile_error, |
| 151 "File is unreadable", file); | |
| 428 | 152 } |
| 153 } | |
| 154 UNGCPRO; | |
| 155 | |
| 3308 | 156 #ifdef HAVE_ALSA_SOUND |
| 157 if (DEVICE_CONNECTED_TO_ALSA_P (d)) | |
| 158 { | |
| 159 Extbyte *fileext; | |
| 160 | |
| 161 LISP_STRING_TO_EXTERNAL (file, fileext, Qfile_name); | |
| 162 /* #### ALSA code should allow specification of a device. */ | |
| 163 if (alsa_play_sound_file (fileext, vol)) | |
| 164 return Qnil; | |
| 165 } | |
| 166 #endif | |
| 167 | |
| 428 | 168 #ifdef HAVE_NAS_SOUND |
| 169 if (DEVICE_CONNECTED_TO_NAS_P (d)) | |
| 170 { | |
| 563 | 171 Extbyte *fileext; |
| 428 | 172 |
| 442 | 173 LISP_STRING_TO_EXTERNAL (file, fileext, Qfile_name); |
| 428 | 174 /* #### NAS code should allow specification of a device. */ |
| 175 if (nas_play_sound_file (fileext, vol)) | |
| 176 return Qnil; | |
| 177 } | |
| 178 #endif /* HAVE_NAS_SOUND */ | |
| 179 | |
| 180 #ifdef HAVE_ESD_SOUND | |
| 181 if (DEVICE_CONNECTED_TO_ESD_P (d)) | |
| 182 { | |
| 563 | 183 Extbyte *fileext; |
| 442 | 184 int result; |
| 428 | 185 |
| 442 | 186 LISP_STRING_TO_EXTERNAL (file, fileext, Qfile_name); |
| 187 | |
| 188 /* #### ESD uses alarm(). But why should we also stop SIGIO? */ | |
| 189 stop_interrupts (); | |
| 190 result = esd_play_sound_file (fileext, vol); | |
| 191 start_interrupts (); | |
| 192 if (result) | |
| 428 | 193 return Qnil; |
| 194 } | |
| 195 #endif /* HAVE_ESD_SOUND */ | |
| 196 | |
| 197 #ifdef HAVE_NATIVE_SOUND | |
| 198 if (NILP (Vnative_sound_only_on_console) || DEVICE_ON_CONSOLE_P (d)) | |
| 199 { | |
| 2526 | 200 #ifdef WIN32_ANY |
| 201 nt_play_sound_file (file, vol); | |
| 202 #else | |
| 563 | 203 Extbyte *fileext; |
| 2526 | 204 LISP_PATHNAME_CONVERT_OUT (file, fileext); |
| 428 | 205 /* The sound code doesn't like getting SIGIO interrupts. |
| 206 Unix sucks! */ | |
| 207 stop_interrupts (); | |
| 563 | 208 play_sound_file (fileext, vol); |
| 428 | 209 start_interrupts (); |
| 2526 | 210 #endif /* WIN32_NATIVE */ |
| 428 | 211 QUIT; |
| 212 } | |
| 213 #endif /* HAVE_NATIVE_SOUND */ | |
| 214 | |
| 215 return Qnil; | |
| 216 } | |
| 217 | |
| 218 static void | |
| 219 parse_sound_alist_elt (Lisp_Object elt, | |
| 220 Lisp_Object *volume, | |
| 221 Lisp_Object *pitch, | |
| 222 Lisp_Object *duration, | |
| 223 Lisp_Object *sound) | |
| 224 { | |
| 225 *volume = Qnil; | |
| 226 *pitch = Qnil; | |
| 227 *duration = Qnil; | |
| 228 *sound = Qnil; | |
| 229 if (! CONSP (elt)) | |
| 230 return; | |
| 231 | |
| 232 /* The things we do for backward compatibility... | |
| 233 I wish I had just forced this to be a plist to begin with. | |
| 234 */ | |
| 235 | |
| 236 if (SYMBOLP (elt) || STRINGP (elt)) /* ( name . <sound> ) */ | |
| 237 { | |
| 238 *sound = elt; | |
| 239 } | |
| 240 else if (!CONSP (elt)) | |
| 241 { | |
| 242 return; | |
| 243 } | |
| 244 else if (NILP (XCDR (elt)) && /* ( name <sound> ) */ | |
| 245 (SYMBOLP (XCAR (elt)) || | |
| 246 STRINGP (XCAR (elt)))) | |
| 247 { | |
| 248 *sound = XCAR (elt); | |
| 249 } | |
| 250 else if (INT_OR_FLOATP (XCAR (elt)) && /* ( name <vol> . <sound> ) */ | |
| 251 (SYMBOLP (XCDR (elt)) || | |
| 252 STRINGP (XCDR (elt)))) | |
| 253 { | |
| 254 *volume = XCAR (elt); | |
| 255 *sound = XCDR (elt); | |
| 256 } | |
| 257 else if (INT_OR_FLOATP (XCAR (elt)) && /* ( name <vol> <sound> ) */ | |
| 258 CONSP (XCDR (elt)) && | |
| 259 NILP (XCDR (XCDR (elt))) && | |
| 260 (SYMBOLP (XCAR (XCDR (elt))) || | |
| 261 STRINGP (XCAR (XCDR (elt))))) | |
| 262 { | |
| 263 *volume = XCAR (elt); | |
| 264 *sound = XCAR (XCDR (elt)); | |
| 265 } | |
| 266 else if ((SYMBOLP (XCAR (elt)) || /* ( name <sound> . <vol> ) */ | |
| 267 STRINGP (XCAR (elt))) && | |
| 268 INT_OR_FLOATP (XCDR (elt))) | |
| 269 { | |
| 270 *sound = XCAR (elt); | |
| 271 *volume = XCDR (elt); | |
| 272 } | |
| 273 #if 0 /* this one is ambiguous with the plist form */ | |
| 274 else if ((SYMBOLP (XCAR (elt)) || /* ( name <sound> <vol> ) */ | |
| 275 STRINGP (XCAR (elt))) && | |
| 276 CONSP (XCDR (elt)) && | |
| 277 NILP (XCDR (XCDR (elt))) && | |
| 278 INT_OR_FLOATP (XCAR (XCDR (elt)))) | |
| 279 { | |
| 280 *sound = XCAR (elt); | |
| 281 *volume = XCAR (XCDR (elt)); | |
| 282 } | |
| 283 #endif /* 0 */ | |
| 284 else /* ( name [ keyword <value> ]* ) */ | |
| 285 { | |
| 286 while (CONSP (elt)) | |
| 287 { | |
| 288 Lisp_Object key, val; | |
| 289 key = XCAR (elt); | |
| 290 val = XCDR (elt); | |
| 291 if (!CONSP (val)) | |
| 292 return; | |
| 293 elt = XCDR (val); | |
| 294 val = XCAR (val); | |
| 295 if (EQ (key, Q_volume)) | |
| 296 { | |
| 297 if (INT_OR_FLOATP (val)) *volume = val; | |
| 298 } | |
| 299 else if (EQ (key, Q_pitch)) | |
| 300 { | |
| 301 if (INT_OR_FLOATP (val)) *pitch = val; | |
| 302 if (NILP (*sound)) *sound = Qt; | |
| 303 } | |
| 304 else if (EQ (key, Q_duration)) | |
| 305 { | |
| 306 if (INT_OR_FLOATP (val)) *duration = val; | |
| 307 if (NILP (*sound)) *sound = Qt; | |
| 308 } | |
| 309 else if (EQ (key, Q_sound)) | |
| 310 { | |
| 311 if (SYMBOLP (val) || STRINGP (val)) *sound = val; | |
| 312 } | |
| 313 } | |
| 314 } | |
| 315 } | |
| 316 | |
| 317 DEFUN ("play-sound", Fplay_sound, 1, 3, 0, /* | |
| 318 Play a sound of the provided type. | |
| 793 | 319 |
| 320 SOUND can a symbol, specifying a sound to be looked up in `sound-alist' | |
| 321 \(generally, either the symbol directly maps to a sound or is an "abstract" | |
| 322 symbol that maps to another symbol and is used to specify the sound that is | |
| 323 played when a particular behavior occurs. `ding' lists the built-in | |
| 324 abstract sounds and their intended purpose. | |
| 325 | |
| 326 SOUND can also be a string, which directly encodes the sound data to be played. | |
| 327 | |
| 328 If SOUND is nil, the abstract sound `default' will be used. | |
| 329 | |
| 330 VOLUME controls the volume (max is around 150? not sure). | |
| 331 | |
| 332 DEVICE is the device to play the sound on (defaults to the selected device). | |
| 609 | 333 |
| 334 If the sound cannot be played in any other way, the standard "bell" will sound. | |
| 428 | 335 */ |
| 336 (sound, volume, device)) | |
| 337 { | |
| 338 int looking_for_default = 0; | |
| 339 /* variable `sound' is anything that can be a cdr in sound-alist */ | |
| 340 Lisp_Object new_volume, pitch, duration, data; | |
| 341 int loop_count = 0; | |
| 342 int vol, pit, dur; | |
| 343 struct device *d = decode_device (device); | |
| 344 | |
| 345 /* NOTE! You'd better not signal an error in here. */ | |
| 346 | |
| 347 | |
| 348 try_it_again: | |
| 349 while (1) | |
| 350 { | |
| 351 if (SYMBOLP (sound)) | |
| 352 sound = Fcdr (Fassq (sound, Vsound_alist)); | |
| 353 parse_sound_alist_elt (sound, &new_volume, &pitch, &duration, &data); | |
| 354 sound = data; | |
| 355 if (NILP (volume)) volume = new_volume; | |
| 356 if (EQ (sound, Qt) || EQ (sound, Qnil) || STRINGP (sound)) | |
| 357 break; | |
| 358 if (loop_count++ > 500) /* much bogosity has occurred */ | |
| 359 break; | |
| 360 } | |
| 361 | |
| 362 if (NILP (sound) && !looking_for_default) | |
| 363 { | |
| 364 looking_for_default = 1; | |
| 365 loop_count = 0; | |
| 366 sound = Qdefault; | |
| 367 goto try_it_again; | |
| 368 } | |
| 369 | |
| 370 | |
| 371 vol = (INT_OR_FLOATP (volume) ? (int) XFLOATINT (volume) : bell_volume); | |
| 372 pit = (INT_OR_FLOATP (pitch) ? (int) XFLOATINT (pitch) : -1); | |
| 373 dur = (INT_OR_FLOATP (duration) ? (int) XFLOATINT (duration) : -1); | |
| 374 | |
| 3308 | 375 /* If the sound is a string, and we're connected to ALSA, NAS, or ESD, do |
| 376 that. Else if the sound is a string, and we're on console, play it | |
| 377 natively. Else just beep. | |
| 428 | 378 */ |
| 3308 | 379 #ifdef HAVE_ALSA_SOUND |
| 380 if (DEVICE_CONNECTED_TO_ALSA_P (d) && STRINGP (sound)) | |
| 381 { | |
| 382 Binbyte *soundext; | |
| 383 Bytecount soundextlen; | |
| 384 | |
| 385 TO_EXTERNAL_FORMAT (LISP_STRING, sound, | |
| 386 ALLOCA, (soundext, soundextlen), | |
| 387 Qbinary); | |
| 388 if (alsa_play_sound_data (soundext, soundextlen, vol)) | |
| 389 return Qnil; | |
| 390 } | |
| 391 #endif /* HAVE_ALSA_SOUND */ | |
| 392 | |
| 428 | 393 #ifdef HAVE_NAS_SOUND |
| 394 if (DEVICE_CONNECTED_TO_NAS_P (d) && STRINGP (sound)) | |
| 395 { | |
| 2367 | 396 Binbyte *soundext; |
| 665 | 397 Bytecount soundextlen; |
| 428 | 398 |
| 440 | 399 TO_EXTERNAL_FORMAT (LISP_STRING, sound, |
| 400 ALLOCA, (soundext, soundextlen), | |
| 401 Qbinary); | |
| 563 | 402 if (nas_play_sound_data (soundext, soundextlen, vol)) |
| 428 | 403 return Qnil; |
| 404 } | |
| 405 #endif /* HAVE_NAS_SOUND */ | |
| 406 | |
| 407 #ifdef HAVE_ESD_SOUND | |
| 408 if (DEVICE_CONNECTED_TO_ESD_P (d) && STRINGP (sound)) | |
| 409 { | |
| 2367 | 410 Binbyte *soundext; |
| 665 | 411 Bytecount soundextlen; |
| 442 | 412 int succes; |
| 428 | 413 |
| 440 | 414 TO_EXTERNAL_FORMAT (LISP_STRING, sound, ALLOCA, (soundext, soundextlen), |
| 415 Qbinary); | |
| 442 | 416 |
| 417 /* #### ESD uses alarm(). But why should we also stop SIGIO? */ | |
| 418 stop_interrupts (); | |
| 563 | 419 succes = esd_play_sound_data (soundext, soundextlen, vol); |
| 442 | 420 start_interrupts (); |
| 421 QUIT; | |
| 422 if(succes) | |
| 423 return Qnil; | |
| 428 | 424 } |
| 425 #endif /* HAVE_ESD_SOUND */ | |
| 426 | |
| 427 #ifdef HAVE_NATIVE_SOUND | |
| 428 if ((NILP (Vnative_sound_only_on_console) || DEVICE_ON_CONSOLE_P (d)) | |
| 429 && STRINGP (sound)) | |
| 430 { | |
| 2367 | 431 Binbyte *soundext; |
| 665 | 432 Bytecount soundextlen; |
| 442 | 433 int succes; |
| 428 | 434 |
| 440 | 435 TO_EXTERNAL_FORMAT (LISP_STRING, sound, |
| 436 ALLOCA, (soundext, soundextlen), | |
| 437 Qbinary); | |
| 428 | 438 /* The sound code doesn't like getting SIGIO interrupts. Unix sucks! */ |
| 439 stop_interrupts (); | |
| 563 | 440 succes = play_sound_data (soundext, soundextlen, vol); |
| 428 | 441 start_interrupts (); |
| 442 QUIT; | |
| 442 | 443 if (succes) |
| 444 return Qnil; | |
| 428 | 445 } |
| 446 #endif /* HAVE_NATIVE_SOUND */ | |
| 447 | |
| 448 DEVMETH (d, ring_bell, (d, vol, pit, dur)); | |
| 449 return Qnil; | |
| 450 } | |
| 451 | |
| 452 DEFUN ("device-sound-enabled-p", Fdevice_sound_enabled_p, 0, 1, 0, /* | |
| 453 Return t if DEVICE is able to play sound. Defaults to selected device. | |
| 454 */ | |
| 3072 | 455 (USED_IF_HAVE_NATIVE_OR_NAS (device))) |
| 428 | 456 { |
| 3308 | 457 #ifdef HAVE_ALSA_SOUND |
| 458 if (DEVICE_CONNECTED_TO_ALSA_P (decode_device (device))) | |
| 459 return Qt; | |
| 460 #endif | |
| 428 | 461 #ifdef HAVE_NAS_SOUND |
| 462 if (DEVICE_CONNECTED_TO_NAS_P (decode_device (device))) | |
| 463 return Qt; | |
| 464 #endif | |
| 465 #ifdef HAVE_NATIVE_SOUND | |
| 466 if (DEVICE_ON_CONSOLE_P (decode_device (device))) | |
| 467 return Qt; | |
| 468 #endif | |
| 469 return Qnil; | |
| 470 } | |
| 471 | |
| 472 DEFUN ("ding", Fding, 0, 3, 0, /* | |
| 473 Beep, or flash the frame. | |
| 793 | 474 |
| 475 \(See `visible-bell'; setting this makes the frame flash instead of | |
| 476 beeping.) Also, unless NO-TERMINATE is given, terminate any keyboard macro | |
| 477 currently executing. SOUND specifies the sound to make and DEVICE the | |
| 478 device to make it on (defaults to the selected device). | |
| 479 | |
| 480 SOUND is either a string (raw data to be played directly), a symbol, or | |
| 481 `nil' (equivalent to the symbol `default'). Sound symbols are looked up in | |
| 482 `sound-alist', and resolve either to strings of data or to other symbols. | |
| 483 Sound symbols that map directly to data should be considered named sounds; | |
| 484 sound symbols that map to other sounds should be considered abstract | |
| 485 sounds, and are used when a particular behavior or state occurs. | |
| 486 | |
| 2757 | 487 Remember that the sound symbol is the *second* argument to `ding', not the |
| 793 | 488 first. |
| 489 | |
| 490 The following abstract sounds are used by XEmacs itself: | |
| 491 | |
| 492 alarm when a package wants to remind the user | |
| 493 auto-save-error when an auto-save does not succeed | |
| 494 buffer-bound when you attempt to move off the end of a buffer | |
| 495 command-error any uncaught error (i.e. any error that the user | |
| 496 sees) except those handled by undefined-click, | |
| 497 undefined-key, buffer-bound, or read-only | |
| 498 default used when nothing else is appropriate. | |
| 499 isearch-failed unable to locate search text during incremental search | |
| 500 isearch-quit when you delete chars past the beginning of the search | |
| 501 text in isearch | |
| 502 no-completion during completing-read | |
| 503 quit when C-g is typed | |
| 504 read-only when you try to modify a read-only buffer | |
| 505 ready when a compile or other time-consuming task is done | |
| 506 undefined-click when you use an undefined mouse-click combination | |
| 507 undefined-key when you type a key that is undefined | |
| 508 warp XEmacs has changed the selected-window or frame | |
| 509 asynchronously -- e.g. a debugger breakpoint is hit | |
| 510 in an asynchronous process filter | |
| 511 y-or-n-p when you type something other than 'y' or 'n' | |
| 512 yes-or-no-p when you type something other than 'yes' or 'no' | |
| 513 | |
| 514 Other lisp packages may use other beep types, but these are the ones that | |
| 515 the C kernel of Emacs uses. | |
| 516 | |
| 428 | 517 */ |
| 793 | 518 (no_terminate, sound, device)) |
| 428 | 519 { |
| 430 | 520 static time_t last_bell_time; |
| 521 static struct device *last_bell_device; | |
| 428 | 522 time_t now; |
| 523 struct device *d = decode_device (device); | |
| 524 | |
| 793 | 525 device = wrap_device (d); |
| 428 | 526 now = time (0); |
| 527 | |
| 793 | 528 if (NILP (no_terminate) && !NILP (Vexecuting_macro)) |
| 428 | 529 /* Stop executing a keyboard macro. */ |
| 563 | 530 invalid_operation ("Keyboard macro terminated by a command ringing the bell", Qunbound); |
| 428 | 531 |
| 532 if (d == last_bell_device && now-last_bell_time < bell_inhibit_time) | |
| 533 return Qnil; | |
| 442 | 534 else if (!NILP (Vvisible_bell) && DEVMETH (d, flash, (d))) |
| 428 | 535 ; |
| 536 else | |
| 537 Fplay_sound (sound, Qnil, device); | |
| 538 | |
| 539 last_bell_time = now; | |
| 540 last_bell_device = d; | |
| 541 return Qnil; | |
| 542 } | |
| 543 | |
| 544 DEFUN ("wait-for-sounds", Fwait_for_sounds, 0, 1, 0, /* | |
| 545 Wait for all sounds to finish playing on DEVICE. | |
| 546 */ | |
| 2294 | 547 (USED_IF_HAVE_NAS (device))) |
| 428 | 548 { |
| 549 #ifdef HAVE_NAS_SOUND | |
| 550 struct device *d = decode_device (device); | |
| 551 if (DEVICE_CONNECTED_TO_NAS_P (d)) | |
| 552 { | |
| 553 /* #### somebody fix this to be device-dependent. */ | |
| 554 nas_wait_for_sounds (); | |
| 555 } | |
| 556 #endif | |
| 557 return Qnil; | |
| 558 } | |
| 559 | |
| 560 DEFUN ("connected-to-nas-p", Fconnected_to_nas_p, 0, 1, 0, /* | |
| 561 Return t if connected to NAS server for sounds on DEVICE. | |
| 562 */ | |
| 2294 | 563 (USED_IF_HAVE_NAS (device))) |
| 428 | 564 { |
| 565 #ifdef HAVE_NAS_SOUND | |
| 566 return DEVICE_CONNECTED_TO_NAS_P (decode_device (device)) ? Qt : Qnil; | |
| 567 #else | |
| 568 return Qnil; | |
| 569 #endif | |
| 570 } | |
| 571 #ifdef HAVE_NAS_SOUND | |
| 572 | |
| 573 static void | |
| 574 init_nas_sound (struct device *d) | |
| 575 { | |
| 576 #ifdef HAVE_X_WINDOWS | |
| 577 if (DEVICE_X_P (d)) | |
| 578 { | |
| 563 | 579 Extbyte *err_message = nas_init_play (DEVICE_X_DISPLAY (d)); |
| 442 | 580 DEVICE_CONNECTED_TO_NAS_P (d) = !err_message; |
| 428 | 581 /* Print out the message? */ |
| 582 } | |
| 583 #endif /* HAVE_X_WINDOWS */ | |
| 584 } | |
| 585 | |
| 586 #endif /* HAVE_NAS_SOUND */ | |
| 587 | |
| 588 #ifdef HAVE_NATIVE_SOUND | |
| 589 | |
| 590 static void | |
| 591 init_native_sound (struct device *d) | |
| 592 { | |
| 3731 | 593 if (!(DEVICE_X_P(d) || DEVICE_GTK_P(d))) |
| 428 | 594 DEVICE_ON_CONSOLE_P (d) = 1; |
| 595 #ifdef HAVE_X_WINDOWS | |
| 596 else | |
| 597 { | |
| 598 /* When running on a machine with native sound support, we cannot use | |
| 599 digitized sounds as beeps unless emacs is running on the same machine | |
| 600 that $DISPLAY points to, and $DISPLAY points to frame 0 of that | |
| 601 machine. | |
| 602 */ | |
| 603 | |
| 604 Display *display = DEVICE_X_DISPLAY (d); | |
| 563 | 605 Extbyte *dpy = DisplayString (display); |
| 606 Extbyte *tail = strchr (dpy, ':'); | |
| 428 | 607 if (! tail || |
| 608 strncmp (tail, ":0", 2)) | |
| 609 DEVICE_ON_CONSOLE_P (d) = 0; | |
| 610 else | |
| 611 { | |
| 563 | 612 Extbyte dpyname[255], localname[255]; |
| 428 | 613 |
| 614 /* some systems can't handle SIGIO or SIGALARM in gethostbyname. */ | |
| 615 stop_interrupts (); | |
| 616 strncpy (dpyname, dpy, tail-dpy); | |
| 617 dpyname [tail-dpy] = 0; | |
| 618 if (!*dpyname || | |
| 619 !strcmp (dpyname, "unix") || | |
| 620 !strcmp (dpyname, "localhost")) | |
| 621 DEVICE_ON_CONSOLE_P (d) = 1; | |
| 622 else if (gethostname (localname, sizeof (localname))) | |
| 623 DEVICE_ON_CONSOLE_P (d) = 0; /* can't find hostname? */ | |
| 624 else | |
| 625 { | |
| 626 /* We have to call gethostbyname() on the result of gethostname() | |
| 627 because the two aren't guaranteed to be the same name for the | |
| 628 same host: on some losing systems, one is a FQDN and the other | |
| 629 is not. Here in the wide wonderful world of Unix it's rocket | |
| 630 science to obtain the local hostname in a portable fashion. | |
| 631 | |
| 632 And don't forget, gethostbyname() reuses the structure it | |
| 633 returns, so we have to copy the fucker before calling it | |
| 634 again. | |
| 635 | |
| 636 Thank you master, may I have another. | |
| 637 */ | |
| 638 struct hostent *h = gethostbyname (dpyname); | |
| 639 if (!h) | |
| 640 DEVICE_ON_CONSOLE_P (d) = 0; | |
| 641 else | |
| 642 { | |
| 3504 | 643 Extbyte *hn = alloca_array (Extbyte, strlen (h->h_name) + 1); |
| 428 | 644 struct hostent *l; |
| 645 strcpy (hn, h->h_name); | |
| 646 l = gethostbyname (localname); | |
| 647 DEVICE_ON_CONSOLE_P (d) = (l && !(strcmp (l->h_name, hn))); | |
| 648 } | |
| 649 } | |
| 650 start_interrupts (); | |
| 651 } | |
| 652 } | |
| 653 #endif /* HAVE_X_WINDOWS */ | |
| 654 } | |
| 655 | |
| 656 #endif /* HAVE_NATIVE_SOUND */ | |
| 657 | |
| 658 void | |
| 3072 | 659 init_device_sound (struct device * USED_IF_HAVE_NATIVE_OR_NAS (d)) |
| 428 | 660 { |
| 661 #ifdef HAVE_NAS_SOUND | |
| 662 init_nas_sound (d); | |
| 663 #endif | |
| 664 | |
| 665 #ifdef HAVE_NATIVE_SOUND | |
| 666 init_native_sound (d); | |
| 667 #endif | |
| 668 } | |
| 669 | |
| 670 void | |
| 671 syms_of_sound (void) | |
| 672 { | |
| 563 | 673 DEFKEYWORD (Q_volume); |
| 674 DEFKEYWORD (Q_pitch); | |
| 675 DEFKEYWORD (Q_duration); | |
| 676 DEFKEYWORD (Q_sound); | |
| 428 | 677 |
| 563 | 678 DEFERROR_STANDARD (Qsound_error, Qio_error); |
| 428 | 679 |
| 680 DEFSUBR (Fplay_sound_file); | |
| 681 DEFSUBR (Fplay_sound); | |
| 682 DEFSUBR (Fding); | |
| 683 DEFSUBR (Fwait_for_sounds); | |
| 684 DEFSUBR (Fconnected_to_nas_p); | |
| 685 DEFSUBR (Fdevice_sound_enabled_p); | |
| 686 } | |
| 687 | |
| 688 | |
| 689 void | |
| 690 vars_of_sound (void) | |
| 691 { | |
| 3308 | 692 #ifdef HAVE_ALSA_SOUND |
| 693 Fprovide (intern ("alsa-sound")); | |
| 694 #endif | |
| 428 | 695 #ifdef HAVE_NATIVE_SOUND |
| 696 Fprovide (intern ("native-sound")); | |
| 697 #endif | |
| 698 #ifdef HAVE_NAS_SOUND | |
| 699 Fprovide (intern ("nas-sound")); | |
| 700 #endif | |
| 432 | 701 #ifdef HAVE_ESD_SOUND |
| 702 Fprovide (intern ("esd-sound")); | |
| 703 #endif | |
| 428 | 704 |
| 705 DEFVAR_INT ("bell-volume", &bell_volume /* | |
| 706 *How loud to be, from 0 to 100. | |
| 707 */ ); | |
| 708 bell_volume = 50; | |
| 709 | |
| 710 DEFVAR_INT ("bell-inhibit-time", &bell_inhibit_time /* | |
| 711 *Don't ring the bell on the same device more than once within this many seconds. | |
| 712 */ ); | |
| 713 bell_inhibit_time = 0; | |
| 714 | |
| 715 DEFVAR_LISP ("sound-alist", &Vsound_alist /* | |
| 716 An alist associating names with sounds. | |
| 717 When `beep' or `ding' is called with one of the name symbols, the associated | |
| 718 sound will be generated instead of the standard beep. | |
| 719 | |
| 720 Each element of `sound-alist' is a list describing a sound. | |
| 721 The first element of the list is the name of the sound being defined. | |
| 722 Subsequent elements of the list are alternating keyword/value pairs: | |
| 723 | |
| 724 Keyword: Value: | |
| 725 ------- ----- | |
| 726 sound A string of raw sound data, or the name of another sound to | |
| 727 play. The symbol `t' here means use the default X beep. | |
| 728 volume An integer from 0-100, defaulting to `bell-volume' | |
| 729 pitch If using the default X beep, the pitch (Hz) to generate. | |
| 730 duration If using the default X beep, the duration (milliseconds). | |
| 731 | |
| 732 For compatibility, elements of `sound-alist' may also be: | |
| 733 | |
| 734 ( sound-name . <sound> ) | |
| 735 ( sound-name <volume> <sound> ) | |
| 736 | |
| 737 You should probably add things to this list by calling the function | |
| 738 load-sound-file. | |
| 739 | |
| 740 Caveats: | |
| 741 - XEmacs must be built with sound support for your system. Not all | |
| 742 systems support sound. | |
| 743 | |
| 744 - The pitch, duration, and volume options are available everywhere, but | |
| 745 many X servers ignore the `pitch' option. | |
| 746 | |
| 793 | 747 Sound symbols that map directly to data should be considered named sounds; |
| 748 sound symbols that map to other sounds should be considered abstract | |
| 749 sounds, and are used when a particular behavior or state occurs. See | |
| 750 `ding' for a list of the standard abstract sounds. | |
| 428 | 751 */ ); |
| 752 Vsound_alist = Qnil; | |
| 753 | |
| 754 DEFVAR_LISP ("synchronous-sounds", &Vsynchronous_sounds /* | |
| 755 Play sounds synchronously, if non-nil. | |
| 756 Only applies if NAS is used and supports asynchronous playing | |
| 757 of sounds. Otherwise, sounds are always played synchronously. | |
| 758 */ ); | |
| 759 Vsynchronous_sounds = Qnil; | |
| 760 | |
| 761 DEFVAR_LISP ("native-sound-only-on-console", &Vnative_sound_only_on_console /* | |
| 762 Non-nil value means play sounds only if XEmacs is running | |
| 763 on the system console. | |
| 442 | 764 Nil means always play sounds, even if running on a non-console tty |
| 428 | 765 or a secondary X display. |
| 766 | |
| 767 This variable only applies to native sound support. | |
| 768 */ ); | |
| 769 Vnative_sound_only_on_console = Qt; | |
| 770 | |
| 771 #if defined (HAVE_NATIVE_SOUND) && defined (hp9000s800) | |
| 772 { | |
| 773 void vars_of_hpplay (void); | |
| 774 vars_of_hpplay (); | |
| 775 } | |
| 776 #endif | |
| 777 } |