Mercurial > hg > xemacs-beta
annotate src/device-msw.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 | a98ca4640147 |
| children | 304aebb79cd3 |
| rev | line source |
|---|---|
| 428 | 1 /* device functions for mswindows. |
| 2 Copyright (C) 1994, 1995 Board of Trustees, University of Illinois. | |
| 3 Copyright (C) 1994, 1995 Free Software Foundation, Inc. | |
| 771 | 4 Copyright (C) 2000, 2001, 2002 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 | |
| 771 | 25 /* This file Mule-ized 8-11-2000. */ |
| 26 | |
| 428 | 27 /* Authorship: |
| 28 | |
| 29 Original authors: Jamie Zawinski and the FSF | |
| 30 Rewritten by Ben Wing and Chuck Thompson. | |
| 31 Rewritten for mswindows by Jonathan Harris, November 1997 for 21.0. | |
| 510 | 32 Print support added by Kirill Katsnelson, July 2000. |
| 428 | 33 */ |
| 34 | |
| 771 | 35 #define NEED_MSWINDOWS_COMMCTRL |
| 36 #define NEED_MSWINDOWS_OBJBASE /* for CoInitialize */ | |
| 428 | 37 |
| 38 #include <config.h> | |
| 39 #include "lisp.h" | |
| 40 | |
| 872 | 41 #include "device-impl.h" |
| 800 | 42 #include "events.h" |
| 43 #include "faces.h" | |
| 44 #include "frame.h" | |
| 45 | |
| 872 | 46 #include "console-msw-impl.h" |
| 428 | 47 #include "console-stream.h" |
| 442 | 48 #include "objects-msw.h" |
| 800 | 49 |
| 428 | 50 #include "sysdep.h" |
| 51 | |
| 52 /* win32 DDE management library globals */ | |
| 53 #ifdef HAVE_DRAGNDROP | |
| 54 DWORD mswindows_dde_mlid; | |
| 657 | 55 int mswindows_dde_enable; |
| 428 | 56 HSZ mswindows_dde_service; |
| 57 HSZ mswindows_dde_topic_system; | |
| 903 | 58 HSZ mswindows_dde_topic_eval; |
| 59 HSZ mswindows_dde_item_result; | |
| 428 | 60 HSZ mswindows_dde_item_open; |
| 61 #endif | |
| 62 | |
|
4477
e34711681f30
Don't determine whether to call general device-type code at startup,
Aidan Kehoe <kehoea@parhasard.net>
parents:
4117
diff
changeset
|
63 Lisp_Object Qmake_device_early_mswindows_entry_point, |
|
e34711681f30
Don't determine whether to call general device-type code at startup,
Aidan Kehoe <kehoea@parhasard.net>
parents:
4117
diff
changeset
|
64 Qmake_device_late_mswindows_entry_point; |
| 442 | 65 Lisp_Object Qdevmodep; |
| 428 | 66 |
| 510 | 67 static Lisp_Object Q_allow_selection; |
| 68 static Lisp_Object Q_allow_pages; | |
| 69 static Lisp_Object Q_selected_page_button; | |
| 70 static Lisp_Object Qselected_page_button; | |
| 71 | |
| 1204 | 72 static const struct memory_description mswindows_device_data_description_1 [] = { |
| 73 { XD_LISP_OBJECT, offsetof (struct mswindows_device, fontlist) }, | |
| 74 { XD_END } | |
| 75 }; | |
| 76 | |
| 3092 | 77 #ifdef NEW_GC |
| 78 DEFINE_LRECORD_IMPLEMENTATION ("mswindows-device", mswindows_device, | |
| 79 1, /*dumpable-flag*/ | |
| 80 0, 0, 0, 0, 0, | |
| 81 mswindows_device_data_description_1, | |
| 82 Lisp_Mswindows_Device); | |
| 83 #else /* not NEW_GC */ | |
| 1204 | 84 extern const struct sized_memory_description mswindows_device_data_description; |
| 85 | |
| 86 const struct sized_memory_description mswindows_device_data_description = { | |
| 87 sizeof (struct mswindows_device), mswindows_device_data_description_1 | |
| 88 }; | |
| 3092 | 89 #endif /* not NEW_GC */ |
| 1204 | 90 |
| 1346 | 91 static const struct memory_description msprinter_device_data_description_1 [] = { |
| 92 { XD_LISP_OBJECT, offsetof (struct msprinter_device, name) }, | |
| 93 { XD_LISP_OBJECT, offsetof (struct msprinter_device, devmode) }, | |
| 94 { XD_LISP_OBJECT, offsetof (struct msprinter_device, fontlist) }, | |
| 95 { XD_END } | |
| 96 }; | |
| 97 | |
| 3092 | 98 #ifdef NEW_GC |
| 99 DEFINE_LRECORD_IMPLEMENTATION ("msprinter-device", msprinter_device, | |
| 100 1, /*dumpable-flag*/ | |
| 101 0, 0, 0, 0, 0, | |
| 102 msprinter_device_data_description_1, | |
| 103 Lisp_Msprinter_Device); | |
| 104 #else /* not NEW_GC */ | |
| 1346 | 105 extern const struct sized_memory_description msprinter_device_data_description; |
| 106 | |
| 107 const struct sized_memory_description msprinter_device_data_description = { | |
| 108 sizeof (struct msprinter_device), msprinter_device_data_description_1 | |
| 109 }; | |
| 3092 | 110 #endif /* not NEW_GC */ |
| 1346 | 111 |
| 771 | 112 static Lisp_Object allocate_devmode (DEVMODEW *src_devmode, int do_copy, |
| 113 Lisp_Object src_name, struct device *d); | |
| 428 | 114 |
| 115 /************************************************************************/ | |
| 116 /* helpers */ | |
| 117 /************************************************************************/ | |
| 118 | |
| 119 static Lisp_Object | |
| 440 | 120 build_syscolor_string (int idx) |
| 428 | 121 { |
| 442 | 122 return (idx < 0 ? Qnil : mswindows_color_to_string (GetSysColor (idx))); |
| 428 | 123 } |
| 124 | |
| 125 static Lisp_Object | |
| 126 build_syscolor_cons (int index1, int index2) | |
| 127 { | |
| 128 Lisp_Object color1, color2; | |
| 129 struct gcpro gcpro1; | |
| 130 GCPRO1 (color1); | |
| 131 color1 = build_syscolor_string (index1); | |
| 132 color2 = build_syscolor_string (index2); | |
| 133 RETURN_UNGCPRO (Fcons (color1, color2)); | |
| 134 } | |
| 135 | |
| 136 static Lisp_Object | |
| 137 build_sysmetrics_cons (int index1, int index2) | |
| 138 { | |
| 139 return Fcons (index1 < 0 ? Qnil : make_int (GetSystemMetrics (index1)), | |
| 140 index2 < 0 ? Qnil : make_int (GetSystemMetrics (index2))); | |
| 141 } | |
| 142 | |
| 440 | 143 static Lisp_Object |
| 144 build_devicecaps_cons (HDC hdc, int index1, int index2) | |
| 145 { | |
| 146 return Fcons (index1 < 0 ? Qnil : make_int (GetDeviceCaps (hdc, index1)), | |
| 147 index2 < 0 ? Qnil : make_int (GetDeviceCaps (hdc, index2))); | |
| 148 } | |
| 149 | |
| 428 | 150 |
| 151 /************************************************************************/ | |
| 440 | 152 /* display methods */ |
| 428 | 153 /************************************************************************/ |
| 154 | |
| 155 static void | |
| 2286 | 156 mswindows_init_device (struct device *d, Lisp_Object UNUSED (props)) |
| 428 | 157 { |
| 158 HDC hdc; | |
| 771 | 159 WNDCLASSEXW wc; |
| 428 | 160 |
|
4477
e34711681f30
Don't determine whether to call general device-type code at startup,
Aidan Kehoe <kehoea@parhasard.net>
parents:
4117
diff
changeset
|
161 call0 (Qmake_device_early_mswindows_entry_point); |
|
e34711681f30
Don't determine whether to call general device-type code at startup,
Aidan Kehoe <kehoea@parhasard.net>
parents:
4117
diff
changeset
|
162 |
| 428 | 163 DEVICE_CLASS (d) = Qcolor; |
| 164 DEVICE_INFD (d) = DEVICE_OUTFD (d) = -1; | |
| 165 init_baud_rate (d); | |
| 166 init_one_device (d); | |
| 167 | |
| 3092 | 168 #ifdef NEW_GC |
| 169 d->device_data = alloc_lrecord_type (struct mswindows_device, | |
| 170 &lrecord_mswindows_device); | |
| 171 #else /* not NEW_GC */ | |
| 428 | 172 d->device_data = xnew_and_zero (struct mswindows_device); |
| 3092 | 173 #endif /* not NEW_GC */ |
| 428 | 174 hdc = CreateCompatibleDC (NULL); |
| 771 | 175 assert (hdc != NULL); |
| 176 DEVICE_MSWINDOWS_HCDC (d) = hdc; | |
| 440 | 177 DEVICE_MSWINDOWS_FONTLIST (d) = mswindows_enumerate_fonts (hdc); |
| 442 | 178 DEVICE_MSWINDOWS_UPDATE_TICK (d) = GetTickCount (); |
| 428 | 179 |
| 180 /* Register the main window class */ | |
| 771 | 181 wc.cbSize = sizeof (wc); |
| 428 | 182 wc.style = CS_OWNDC; /* One DC per window */ |
| 183 wc.lpfnWndProc = (WNDPROC) mswindows_wnd_proc; | |
| 184 wc.cbClsExtra = 0; | |
| 185 wc.cbWndExtra = MSWINDOWS_WINDOW_EXTRA_BYTES; | |
| 186 /* This must match whatever is passed to CreateWIndowEx, NULL is ok | |
| 187 for this. */ | |
| 771 | 188 wc.hInstance = NULL; |
| 189 wc.hIcon = qxeLoadIcon (qxeGetModuleHandle (NULL), XETEXT (XEMACS_CLASS)); | |
| 190 wc.hCursor = qxeLoadCursor (NULL, IDC_ARROW); | |
| 428 | 191 /* Background brush is only used during sizing, when XEmacs cannot |
| 192 take over */ | |
| 771 | 193 wc.hbrBackground = (HBRUSH) (COLOR_APPWORKSPACE + 1); |
| 428 | 194 wc.lpszMenuName = NULL; |
| 195 | |
| 771 | 196 wc.lpszClassName = (XELPTSTR) XETEXT (XEMACS_CLASS); |
| 197 wc.hIconSm = (HICON) qxeLoadImage (qxeGetModuleHandle (NULL), | |
| 198 XETEXT (XEMACS_CLASS), | |
| 199 IMAGE_ICON, 16, 16, 0); | |
| 200 qxeRegisterClassEx (&wc); | |
| 428 | 201 |
| 202 #ifdef HAVE_WIDGETS | |
| 203 xzero (wc); | |
| 204 /* Register the main window class */ | |
| 771 | 205 wc.cbSize = sizeof (wc); |
| 428 | 206 wc.lpfnWndProc = (WNDPROC) mswindows_control_wnd_proc; |
| 771 | 207 wc.lpszClassName = (XELPTSTR) XETEXT (XEMACS_CONTROL_CLASS); |
| 428 | 208 wc.hInstance = NULL; |
| 771 | 209 qxeRegisterClassEx (&wc); |
| 428 | 210 #endif |
| 211 | |
| 440 | 212 #if defined (HAVE_TOOLBARS) || defined (HAVE_WIDGETS) |
| 428 | 213 InitCommonControls (); |
| 214 #endif | |
| 215 } | |
| 216 | |
| 657 | 217 #ifdef HAVE_DRAGNDROP |
| 428 | 218 static void |
| 771 | 219 mswindows_init_dde (void) |
| 428 | 220 { |
| 221 /* Initialize DDE management library and our related globals. We execute a | |
| 771 | 222 * dde Open ("file") by simulating a drop, so this depends on dnd support. */ |
| 442 | 223 |
| 428 | 224 mswindows_dde_mlid = 0; |
| 659 | 225 mswindows_dde_enable = 0; |
| 771 | 226 qxeDdeInitialize (&mswindows_dde_mlid, (PFNCALLBACK)mswindows_dde_callback, |
| 903 | 227 APPCMD_FILTERINITS|CBF_FAIL_SELFCONNECTIONS| |
| 228 CBF_FAIL_POKES|CBF_SKIP_ALLNOTIFICATIONS, | |
| 771 | 229 0); |
| 230 | |
| 231 mswindows_dde_service = | |
| 232 qxeDdeCreateStringHandle (mswindows_dde_mlid, | |
| 233 XETEXT (XEMACS_CLASS), | |
| 234 XEUNICODE_P ? CP_WINUNICODE : CP_WINANSI); | |
| 235 /* The following strings we Unicode-ize ourselves: | |
| 236 -- SZDDESYS_TOPIC is system-provided | |
| 903 | 237 -- MSWINDOWS_DDE_TOPIC_EVAL is defined by us |
| 238 -- MSWINDOWS_DDE_ITEM_RESULT is defined by us | |
| 771 | 239 -- MSWINDOWS_DDE_ITEM_OPEN is used in internal-format comparisons |
| 240 */ | |
| 241 mswindows_dde_topic_system = | |
| 242 qxeDdeCreateStringHandle (mswindows_dde_mlid, | |
| 243 XETEXT (SZDDESYS_TOPIC), | |
| 244 XEUNICODE_P ? CP_WINUNICODE : CP_WINANSI); | |
| 903 | 245 mswindows_dde_topic_eval = |
| 246 qxeDdeCreateStringHandle (mswindows_dde_mlid, | |
| 247 XETEXT (MSWINDOWS_DDE_TOPIC_EVAL), | |
| 248 XEUNICODE_P ? CP_WINUNICODE : CP_WINANSI); | |
| 249 mswindows_dde_item_result = | |
| 250 qxeDdeCreateStringHandle (mswindows_dde_mlid, | |
| 251 XETEXT (MSWINDOWS_DDE_ITEM_RESULT), | |
| 252 XEUNICODE_P ? CP_WINUNICODE : CP_WINANSI); | |
| 771 | 253 mswindows_dde_item_open = |
| 254 qxeDdeCreateStringHandle (mswindows_dde_mlid, | |
| 255 XETEXT (MSWINDOWS_DDE_ITEM_OPEN), | |
| 256 XEUNICODE_P ? CP_WINUNICODE : CP_WINANSI); | |
| 428 | 257 DdeNameService (mswindows_dde_mlid, mswindows_dde_service, 0L, DNS_REGISTER); |
| 657 | 258 } |
| 771 | 259 #endif /* HAVE_DRAGNDROP */ |
| 657 | 260 |
| 261 void | |
| 771 | 262 init_mswindows_dde_very_early (void) |
| 657 | 263 { |
| 771 | 264 #if !defined (NO_CYGWIN_COM_SUPPORT) |
| 265 /* Needed by SHBrowseForFolder, so do it always */ | |
| 266 CoInitialize (NULL); | |
| 267 #endif | |
| 268 | |
| 657 | 269 #ifdef HAVE_DRAGNDROP |
| 270 /* Initializing dde when the device is created is too late - the | |
| 271 client will give up waiting. Instead we initialize here and tell | |
| 272 the client we're too busy until the rest of initialization has | |
| 273 happened. */ | |
| 771 | 274 mswindows_init_dde (); |
| 657 | 275 #endif |
| 276 } | |
| 277 | |
| 278 static void | |
|
4477
e34711681f30
Don't determine whether to call general device-type code at startup,
Aidan Kehoe <kehoea@parhasard.net>
parents:
4117
diff
changeset
|
279 mswindows_finish_init_device (struct device *d, |
| 2286 | 280 Lisp_Object UNUSED (props)) |
| 657 | 281 { |
| 282 #ifdef HAVE_DRAGNDROP | |
| 283 /* Tell pending clients we are ready. */ | |
| 284 mswindows_dde_enable = 1; | |
| 428 | 285 #endif |
|
4477
e34711681f30
Don't determine whether to call general device-type code at startup,
Aidan Kehoe <kehoea@parhasard.net>
parents:
4117
diff
changeset
|
286 call1 (Qmake_device_late_mswindows_entry_point, wrap_device(d)); |
| 428 | 287 } |
| 288 | |
| 289 static void | |
| 290 mswindows_delete_device (struct device *d) | |
| 291 { | |
| 292 #ifdef HAVE_DRAGNDROP | |
| 442 | 293 DdeNameService (mswindows_dde_mlid, 0L, 0L, DNS_UNREGISTER); |
| 903 | 294 DdeFreeStringHandle (mswindows_dde_mlid, mswindows_dde_item_result); |
| 442 | 295 DdeFreeStringHandle (mswindows_dde_mlid, mswindows_dde_item_open); |
| 296 DdeFreeStringHandle (mswindows_dde_mlid, mswindows_dde_topic_system); | |
| 903 | 297 DdeFreeStringHandle (mswindows_dde_mlid, mswindows_dde_topic_eval); |
| 442 | 298 DdeFreeStringHandle (mswindows_dde_mlid, mswindows_dde_service); |
| 428 | 299 DdeUninitialize (mswindows_dde_mlid); |
| 442 | 300 |
| 771 | 301 # if !defined (NO_CYGWIN_COM_SUPPORT) |
| 442 | 302 CoUninitialize (); |
| 303 # endif | |
| 428 | 304 #endif |
| 305 | |
| 771 | 306 DeleteDC (DEVICE_MSWINDOWS_HCDC (d)); |
| 4117 | 307 #ifndef NEW_GC |
| 1726 | 308 xfree (d->device_data, void *); |
| 3092 | 309 #endif /* not NEW_GC */ |
| 442 | 310 } |
| 311 | |
| 312 void | |
| 313 mswindows_get_workspace_coords (RECT *rc) | |
| 314 { | |
| 771 | 315 qxeSystemParametersInfo (SPI_GETWORKAREA, 0, rc, 0); |
| 428 | 316 } |
| 317 | |
| 440 | 318 static void |
| 319 mswindows_mark_device (struct device *d) | |
| 320 { | |
| 321 mark_object (DEVICE_MSWINDOWS_FONTLIST (d)); | |
| 322 } | |
| 323 | |
| 428 | 324 static Lisp_Object |
| 325 mswindows_device_system_metrics (struct device *d, | |
| 326 enum device_metrics m) | |
| 327 { | |
| 442 | 328 const HDC hdc = DEVICE_MSWINDOWS_HCDC(d); |
| 329 | |
| 428 | 330 switch (m) |
| 331 { | |
| 332 case DM_size_device: | |
| 442 | 333 return Fcons (make_int (GetDeviceCaps (hdc, HORZRES)), |
| 334 make_int (GetDeviceCaps (hdc, VERTRES))); | |
| 428 | 335 break; |
| 440 | 336 case DM_device_dpi: |
| 442 | 337 return Fcons (make_int (GetDeviceCaps (hdc, LOGPIXELSX)), |
| 338 make_int (GetDeviceCaps (hdc, LOGPIXELSY))); | |
| 440 | 339 break; |
| 428 | 340 case DM_size_device_mm: |
| 442 | 341 return Fcons (make_int (GetDeviceCaps (hdc, HORZSIZE)), |
| 342 make_int (GetDeviceCaps (hdc, VERTSIZE))); | |
| 428 | 343 break; |
| 344 case DM_num_bit_planes: | |
| 345 /* this is what X means by bitplanes therefore we ought to be | |
| 346 consistent. num planes is always 1 under mswindows and | |
| 347 therefore useless */ | |
| 442 | 348 return make_int (GetDeviceCaps (hdc, BITSPIXEL)); |
| 428 | 349 break; |
| 350 case DM_num_color_cells: | |
| 442 | 351 /* #### SIZEPALETTE only valid if RC_PALETTE bit set in RASTERCAPS, |
| 352 what should we return for a non-palette-based device? */ | |
| 353 return make_int (GetDeviceCaps (hdc, SIZEPALETTE)); | |
| 428 | 354 break; |
| 355 | |
| 356 /*** Colors ***/ | |
| 442 | 357 #define FROB(met, fore, back) \ |
| 428 | 358 case DM_##met: \ |
| 442 | 359 return build_syscolor_cons (fore, back); |
| 360 | |
| 361 FROB (color_default, COLOR_WINDOWTEXT, COLOR_WINDOW); | |
| 362 FROB (color_select, COLOR_HIGHLIGHTTEXT, COLOR_HIGHLIGHT); | |
| 363 FROB (color_balloon, COLOR_INFOTEXT, COLOR_INFOBK); | |
| 364 FROB (color_3d_face, COLOR_BTNTEXT, COLOR_BTNFACE); | |
| 365 FROB (color_3d_light, COLOR_3DHILIGHT, COLOR_3DLIGHT); | |
| 366 FROB (color_3d_dark, COLOR_3DDKSHADOW, COLOR_3DSHADOW); | |
| 367 FROB (color_menu, COLOR_MENUTEXT, COLOR_MENU); | |
| 368 FROB (color_menu_highlight, COLOR_HIGHLIGHTTEXT, COLOR_HIGHLIGHT); | |
| 369 FROB (color_menu_button, COLOR_MENUTEXT, COLOR_MENU); | |
| 370 FROB (color_menu_disabled, COLOR_GRAYTEXT, COLOR_MENU); | |
| 371 FROB (color_toolbar, COLOR_BTNTEXT, COLOR_BTNFACE); | |
| 372 FROB (color_scrollbar, COLOR_CAPTIONTEXT, COLOR_SCROLLBAR); | |
| 428 | 373 FROB (color_desktop, -1, COLOR_DESKTOP); |
| 374 FROB (color_workspace, -1, COLOR_APPWORKSPACE); | |
| 375 #undef FROB | |
| 376 | |
| 377 /*** Sizes ***/ | |
| 378 #define FROB(met, index1, index2) \ | |
| 379 case DM_##met: \ | |
| 380 return build_sysmetrics_cons (index1, index2); | |
| 381 | |
| 382 FROB (size_cursor, SM_CXCURSOR, SM_CYCURSOR); | |
| 383 FROB (size_scrollbar, SM_CXVSCROLL, SM_CYHSCROLL); | |
| 384 FROB (size_menu, -1, SM_CYMENU); | |
| 385 FROB (size_icon, SM_CXICON, SM_CYICON); | |
| 386 FROB (size_icon_small, SM_CXSMICON, SM_CYSMICON); | |
| 387 #undef FROB | |
| 388 | |
| 389 case DM_size_workspace: | |
| 390 { | |
| 391 RECT rc; | |
| 442 | 392 mswindows_get_workspace_coords (&rc); |
| 428 | 393 return Fcons (make_int (rc.right - rc.left), |
| 394 make_int (rc.bottom - rc.top)); | |
| 395 } | |
| 442 | 396 |
| 397 case DM_offset_workspace: | |
| 398 { | |
| 399 RECT rc; | |
| 400 mswindows_get_workspace_coords (&rc); | |
| 401 return Fcons (make_int (rc.left), make_int (rc.top)); | |
| 402 } | |
| 403 | |
| 428 | 404 /* |
| 405 case DM_size_toolbar: | |
| 406 case DM_size_toolbar_button: | |
| 407 case DM_size_toolbar_border: | |
| 408 */ | |
| 409 | |
| 410 /*** Features ***/ | |
| 411 #define FROB(met, index) \ | |
| 412 case DM_##met: \ | |
| 413 return make_int (GetSystemMetrics (index)); | |
| 414 | |
| 415 FROB (mouse_buttons, SM_CMOUSEBUTTONS); | |
| 416 FROB (swap_buttons, SM_SWAPBUTTON); | |
| 417 FROB (show_sounds, SM_SHOWSOUNDS); | |
| 418 FROB (slow_device, SM_SLOWMACHINE); | |
| 419 FROB (security, SM_SECURE); | |
| 420 #undef FROB | |
| 421 | |
| 422 } | |
| 423 | |
| 424 /* Do not know such property */ | |
| 425 return Qunbound; | |
| 426 } | |
| 427 | |
| 428 | |
| 429 /************************************************************************/ | |
| 442 | 430 /* printer helpers */ |
| 440 | 431 /************************************************************************/ |
| 432 | |
| 433 static void | |
| 434 signal_open_printer_error (struct device *d) | |
| 435 { | |
| 442 | 436 invalid_operation ("Failed to open printer", DEVICE_CONNECTION (d)); |
| 437 } | |
| 438 | |
| 439 | |
| 440 /* Helper function */ | |
| 441 static int | |
| 771 | 442 msprinter_init_device_internal (struct device *d, Lisp_Object printer_name) |
| 442 | 443 { |
| 771 | 444 Extbyte *printer_ext; |
| 445 HDC hdc; | |
| 442 | 446 |
| 771 | 447 DEVICE_MSPRINTER_NAME (d) = printer_name; |
| 448 | |
| 449 LISP_STRING_TO_TSTR (printer_name, printer_ext); | |
| 450 | |
| 451 if (!qxeOpenPrinter (printer_ext, &DEVICE_MSPRINTER_HPRINTER (d), NULL)) | |
| 442 | 452 { |
| 453 DEVICE_MSPRINTER_HPRINTER (d) = NULL; | |
| 454 return 0; | |
| 455 } | |
| 456 | |
| 771 | 457 DEVICE_MSPRINTER_HDC (d) = qxeCreateDC (XETEXT ("WINSPOOL"), printer_ext, |
| 458 NULL, NULL); | |
| 442 | 459 if (DEVICE_MSPRINTER_HDC (d) == NULL) |
| 460 return 0; | |
| 461 | |
| 771 | 462 hdc = CreateCompatibleDC (DEVICE_MSPRINTER_HDC (d)); |
| 463 DEVICE_MSPRINTER_HCDC (d) = hdc; | |
| 464 DEVICE_MSPRINTER_FONTLIST (d) = mswindows_enumerate_fonts (hdc); | |
| 442 | 465 |
| 466 DEVICE_CLASS (d) = (GetDeviceCaps (DEVICE_MSPRINTER_HDC (d), BITSPIXEL) | |
| 467 * GetDeviceCaps (DEVICE_MSPRINTER_HDC (d), PLANES) | |
| 468 > 1) ? Qcolor : Qmono; | |
| 469 return 1; | |
| 440 | 470 } |
| 471 | |
| 472 static void | |
| 442 | 473 msprinter_delete_device_internal (struct device *d) |
| 474 { | |
| 475 if (DEVICE_MSPRINTER_HPRINTER (d)) | |
| 476 ClosePrinter (DEVICE_MSPRINTER_HPRINTER (d)); | |
| 477 if (DEVICE_MSPRINTER_HDC (d)) | |
| 478 DeleteDC (DEVICE_MSPRINTER_HDC (d)); | |
| 479 if (DEVICE_MSPRINTER_HCDC (d)) | |
| 480 DeleteDC (DEVICE_MSPRINTER_HCDC (d)); | |
| 481 | |
| 482 DEVICE_MSPRINTER_FONTLIST (d) = Qnil; | |
| 483 } | |
| 484 | |
| 485 static int | |
| 771 | 486 msprinter_reinit_device (struct device *d, Lisp_Object devname) |
| 442 | 487 { |
| 488 msprinter_delete_device_internal (d); | |
| 489 return msprinter_init_device_internal (d, devname); | |
| 490 } | |
| 491 | |
| 492 Lisp_Object | |
| 493 msprinter_default_printer (void) | |
| 494 { | |
| 495 Extbyte name[666]; | |
| 867 | 496 Ibyte *nameint; |
| 442 | 497 |
| 771 | 498 if (qxeGetProfileString (XETEXT ("windows"), XETEXT ("device"), NULL, name, |
| 499 sizeof (name) / XETCHAR_SIZE) <= 0) | |
| 442 | 500 return Qnil; |
| 771 | 501 TSTR_TO_C_STRING (name, nameint); |
| 442 | 502 |
| 771 | 503 if (nameint[0] == '\0') |
| 442 | 504 return Qnil; |
| 505 | |
| 771 | 506 /* this is destructive, but that's ok because the string is either in |
| 851 | 507 name[] or ALLOCA ()ed */ |
| 771 | 508 qxestrtok (nameint, ","); |
| 509 | |
| 510 return build_intstring (nameint); | |
| 442 | 511 } |
| 512 | |
| 513 | |
| 514 /************************************************************************/ | |
| 515 /* printer methods */ | |
| 516 /************************************************************************/ | |
| 517 | |
| 518 static void | |
| 2286 | 519 msprinter_init_device (struct device *d, Lisp_Object UNUSED (props)) |
| 440 | 520 { |
| 771 | 521 DEVMODEW *pdm; |
| 647 | 522 LONG dm_size; |
| 771 | 523 Extbyte *printer_name; |
| 440 | 524 |
| 3092 | 525 #ifdef NEW_GC |
| 526 d->device_data = alloc_lrecord_type (struct msprinter_device, | |
| 527 &lrecord_msprinter_device); | |
| 528 #else /* not NEW_GC */ | |
| 440 | 529 d->device_data = xnew_and_zero (struct msprinter_device); |
| 3092 | 530 #endif /* not NEW_GC */ |
| 440 | 531 |
| 442 | 532 DEVICE_INFD (d) = DEVICE_OUTFD (d) = -1; |
| 771 | 533 DEVICE_MSPRINTER_DEVMODE (d) = Qnil; |
| 534 DEVICE_MSPRINTER_NAME (d) = Qnil; | |
| 440 | 535 |
| 2367 | 536 #if 0 /* #### deleted in new ikeyama ws */ |
| 771 | 537 /* We do not use printer font list as we do with the display |
| 538 device. Rather, we allow GDI to pick the closest match to the | |
| 440 | 539 display font. */ |
| 540 DEVICE_MSPRINTER_FONTLIST (d) = Qnil; | |
| 771 | 541 #endif /* 0 */ |
| 440 | 542 |
| 442 | 543 CHECK_STRING (DEVICE_CONNECTION (d)); |
| 544 | |
| 771 | 545 if (!msprinter_init_device_internal (d, DEVICE_CONNECTION (d))) |
| 442 | 546 signal_open_printer_error (d); |
| 547 | |
| 771 | 548 LISP_STRING_TO_TSTR (DEVICE_CONNECTION (d), printer_name); |
| 442 | 549 /* Determine DEVMODE size and store the default DEVMODE */ |
| 771 | 550 dm_size = qxeDocumentProperties (NULL, DEVICE_MSPRINTER_HPRINTER (d), |
| 551 printer_name, NULL, NULL, 0); | |
| 442 | 552 if (dm_size <= 0) |
| 553 signal_open_printer_error (d); | |
| 554 | |
| 771 | 555 pdm = (DEVMODEW *) xmalloc (dm_size); |
| 556 if (qxeDocumentProperties (NULL, DEVICE_MSPRINTER_HPRINTER(d), | |
| 557 printer_name, pdm, | |
| 558 NULL, DM_OUT_BUFFER) < 0) | |
| 552 | 559 signal_open_printer_error (d); |
| 442 | 560 |
| 561 assert (DEVMODE_SIZE (pdm) <= dm_size); | |
| 562 | |
| 771 | 563 DEVICE_MSPRINTER_DEVMODE (d) = |
| 564 allocate_devmode (pdm, 0, DEVICE_CONNECTION (d), d); | |
| 442 | 565 } |
| 566 | |
| 567 static void | |
| 568 msprinter_delete_device (struct device *d) | |
| 569 { | |
| 570 if (d->device_data) | |
| 571 { | |
| 572 msprinter_delete_device_internal (d); | |
| 573 | |
| 574 /* Disassociate the selected devmode with the device */ | |
| 575 if (!NILP (DEVICE_MSPRINTER_DEVMODE (d))) | |
| 576 { | |
| 577 XDEVMODE (DEVICE_MSPRINTER_DEVMODE (d))->device = Qnil; | |
| 578 DEVICE_MSPRINTER_DEVMODE (d) = Qnil; | |
| 579 } | |
| 580 | |
| 4117 | 581 #ifndef NEW_GC |
| 1726 | 582 xfree (d->device_data, void *); |
| 3092 | 583 #endif /* not NEW_GC */ |
| 442 | 584 } |
| 440 | 585 } |
| 586 | |
| 587 static Lisp_Object | |
| 588 msprinter_device_system_metrics (struct device *d, | |
| 589 enum device_metrics m) | |
| 590 { | |
| 591 switch (m) | |
| 592 { | |
| 593 /* Device sizes - pixel and mm */ | |
| 594 #define FROB(met, index1, index2) \ | |
| 595 case DM_##met: \ | |
| 596 return build_devicecaps_cons \ | |
| 771 | 597 (DEVICE_MSPRINTER_HDC (d), index1, index2); |
| 440 | 598 |
| 599 FROB (size_device, PHYSICALWIDTH, PHYSICALHEIGHT); | |
| 600 FROB (size_device_mm, HORZSIZE, VERTSIZE); | |
| 601 FROB (size_workspace, HORZRES, VERTRES); | |
| 602 FROB (offset_workspace, PHYSICALOFFSETX, PHYSICALOFFSETY); | |
| 603 FROB (device_dpi, LOGPIXELSX, LOGPIXELSY); | |
| 604 #undef FROB | |
| 605 | |
| 606 case DM_num_bit_planes: | |
| 607 /* this is what X means by bitplanes therefore we ought to be | |
| 608 consistent. num planes is always 1 under mswindows and | |
| 609 therefore useless */ | |
| 771 | 610 return make_int (GetDeviceCaps (DEVICE_MSPRINTER_HDC (d), BITSPIXEL)); |
| 440 | 611 |
| 442 | 612 case DM_num_color_cells: /* Printers are non-palette devices */ |
| 440 | 613 case DM_slow_device: /* Animation would be a really bad idea */ |
| 614 case DM_security: /* Not provided by windows */ | |
| 615 return Qzero; | |
| 616 } | |
| 617 | |
| 618 /* Do not know such property */ | |
| 619 return Qunbound; | |
| 620 } | |
| 621 | |
| 622 static void | |
| 623 msprinter_mark_device (struct device *d) | |
| 624 { | |
| 625 mark_object (DEVICE_MSPRINTER_FONTLIST (d)); | |
| 442 | 626 mark_object (DEVICE_MSPRINTER_DEVMODE (d)); |
| 771 | 627 mark_object (DEVICE_MSPRINTER_NAME (d)); |
| 440 | 628 } |
| 629 | |
| 630 | |
| 631 /************************************************************************/ | |
| 442 | 632 /* printer Lisp subroutines */ |
| 440 | 633 /************************************************************************/ |
| 634 | |
| 442 | 635 static void |
| 636 global_free_2_maybe (HGLOBAL hg1, HGLOBAL hg2) | |
| 637 { | |
| 638 if (hg1 != NULL) | |
| 639 GlobalFree (hg1); | |
| 640 if (hg2 != NULL) | |
| 641 GlobalFree (hg2); | |
| 642 } | |
| 643 | |
| 644 static HGLOBAL | |
| 645 devmode_to_hglobal (Lisp_Devmode *ldm) | |
| 646 { | |
| 647 HGLOBAL hg = GlobalAlloc (GHND, XDEVMODE_SIZE (ldm)); | |
| 648 memcpy (GlobalLock (hg), ldm->devmode, XDEVMODE_SIZE (ldm)); | |
| 649 GlobalUnlock (hg); | |
| 650 return hg; | |
| 651 } | |
| 652 | |
| 653 /* Returns 0 if the printer has been deleted due to a fatal I/O error, | |
| 654 1 otherwise. */ | |
| 655 static int | |
| 771 | 656 sync_printer_with_devmode (struct device* d, DEVMODEW* devmode_in, |
| 657 DEVMODEW* devmode_out, Lisp_Object devname) | |
| 440 | 658 { |
| 442 | 659 /* Change connection if the device changed */ |
| 771 | 660 if (!NILP (devname) |
| 661 && lisp_strcasecmp (devname, DEVICE_MSPRINTER_NAME (d)) != 0) | |
| 442 | 662 { |
| 771 | 663 Lisp_Object new_connection = devname; |
| 442 | 664 |
| 665 DEVICE_CONNECTION (d) = Qnil; | |
| 666 if (!NILP (Ffind_device (new_connection, Qmsprinter))) | |
| 667 { | |
| 668 /* We are in trouble - second msprinter for the same device. | |
| 669 Nothing wrong on the Windows side, just forge a unique | |
| 670 connection name. Use the memory address of d as a unique | |
| 671 suffix. */ | |
| 867 | 672 Ibyte new_connext[20]; |
| 771 | 673 |
| 674 qxesprintf (new_connext, ":%X", d->header.uid); | |
| 675 new_connection = concat2 (devname, build_intstring (new_connext)); | |
| 442 | 676 } |
| 677 DEVICE_CONNECTION (d) = new_connection; | |
| 678 | |
| 679 /* Reinitialize printer. The device can pop off in process */ | |
| 680 if (!msprinter_reinit_device (d, devname)) | |
| 681 { | |
| 682 /* Kaboom! */ | |
| 683 delete_device_internal (d, 1, 0, 1); | |
| 684 return 0; | |
| 685 } | |
| 686 } | |
| 771 | 687 { |
| 688 Extbyte *nameext; | |
| 442 | 689 |
| 771 | 690 LISP_STRING_TO_TSTR (DEVICE_MSPRINTER_NAME (d), nameext); |
| 691 | |
| 692 /* Apply the new devmode to the printer */ | |
| 693 qxeDocumentProperties (NULL, DEVICE_MSPRINTER_HPRINTER (d), | |
| 694 nameext, devmode_out, devmode_in, | |
| 695 DM_IN_BUFFER | DM_OUT_BUFFER); | |
| 440 | 696 |
| 771 | 697 /* #### ResetDC fails sometimes, Bill only knows why. |
| 698 The solution below looks more like a workaround to me, | |
| 699 although it might be fine. --kkm */ | |
| 700 if (qxeResetDC (DEVICE_MSPRINTER_HDC (d), devmode_out) == NULL) | |
| 701 { | |
| 702 DeleteDC (DEVICE_MSPRINTER_HDC (d)); | |
| 703 DEVICE_MSPRINTER_HDC (d) = | |
| 704 qxeCreateDC (XETEXT ("WINSPOOL"), nameext, NULL, | |
| 705 devmode_out); | |
| 706 } | |
| 707 } | |
| 708 | |
| 442 | 709 return 1; |
| 710 } | |
| 711 | |
| 712 static void | |
| 713 handle_devmode_changes (Lisp_Devmode *ldm, HGLOBAL hDevNames, HGLOBAL hDevMode) | |
| 714 { | |
| 771 | 715 DEVNAMES *devnames = (DEVNAMES *) GlobalLock (hDevNames); |
| 716 Extbyte *new_name = | |
| 717 devnames ? | |
| 718 (Extbyte *) devnames + XETCHAR_SIZE * devnames->wDeviceOffset : NULL; | |
| 719 DEVMODEW *devmode = (DEVMODEW *) GlobalLock (hDevMode); | |
| 442 | 720 |
| 721 /* Size and name may have changed */ | |
| 771 | 722 ldm->devmode = (DEVMODEW *) xrealloc (ldm->devmode, DEVMODE_SIZE (devmode)); |
| 442 | 723 if (new_name) |
| 771 | 724 ldm->printer_name = build_tstr_string (new_name); |
| 440 | 725 |
| 442 | 726 if (!NILP (ldm->device)) |
| 727 { | |
| 728 /* Apply the new devmode to the printer and get a compete one back */ | |
| 729 struct device *d = XDEVICE (ldm->device); | |
| 771 | 730 if (!sync_printer_with_devmode (d, devmode, ldm->devmode, |
| 731 new_name ? ldm->printer_name : Qnil)) | |
| 442 | 732 { |
| 733 global_free_2_maybe (hDevNames, hDevMode); | |
| 771 | 734 signal_error |
| 735 (Qio_error, | |
| 736 "Printer device initialization I/O error, device deleted", | |
| 737 ldm->device); | |
| 442 | 738 } |
| 739 } | |
| 740 else | |
| 741 { | |
| 742 /* Just copy the devmode structure */ | |
| 743 memcpy (ldm->devmode, devmode, DEVMODE_SIZE (devmode)); | |
| 744 } | |
| 745 } | |
| 440 | 746 |
| 442 | 747 static void |
| 748 ensure_not_printing (struct device *d) | |
| 749 { | |
| 750 if (!NILP (DEVICE_FRAME_LIST (d))) | |
| 751 { | |
| 793 | 752 Lisp_Object device = wrap_device (d); |
| 753 | |
| 442 | 754 invalid_operation ("Cannot change settings while print job is active", |
| 755 device); | |
| 756 } | |
| 757 } | |
| 758 | |
| 759 static Lisp_Devmode * | |
| 760 decode_devmode (Lisp_Object dev) | |
| 761 { | |
| 762 if (DEVMODEP (dev)) | |
| 763 return XDEVMODE (dev); | |
| 764 else | |
| 765 { | |
| 766 ensure_not_printing (XDEVICE (dev)); | |
| 767 return XDEVMODE (DEVICE_MSPRINTER_DEVMODE (XDEVICE (dev))); | |
| 768 } | |
| 440 | 769 } |
| 770 | |
| 771 /* | |
| 442 | 772 * DEV can be either a printer or devmode |
| 440 | 773 */ |
| 442 | 774 static Lisp_Object |
| 510 | 775 print_dialog_worker (Lisp_Object dev, DWORD flags) |
| 442 | 776 { |
| 777 Lisp_Devmode *ldm = decode_devmode (dev); | |
| 771 | 778 PRINTDLGW pd; |
| 442 | 779 |
| 780 memset (&pd, 0, sizeof (pd)); | |
| 781 pd.lStructSize = sizeof (pd); | |
| 782 pd.hwndOwner = mswindows_get_selected_frame_hwnd (); | |
| 783 pd.hDevMode = devmode_to_hglobal (ldm); | |
| 510 | 784 pd.Flags = flags | PD_USEDEVMODECOPIESANDCOLLATE; |
| 442 | 785 pd.nMinPage = 0; |
| 786 pd.nMaxPage = 0xFFFF; | |
| 787 | |
| 771 | 788 if (!qxePrintDlg (&pd)) |
| 442 | 789 { |
| 790 global_free_2_maybe (pd.hDevNames, pd.hDevMode); | |
| 791 return Qnil; | |
| 792 } | |
| 793 | |
| 794 handle_devmode_changes (ldm, pd.hDevNames, pd.hDevMode); | |
| 795 | |
| 796 /* Finally, build the resulting plist */ | |
| 797 { | |
| 798 Lisp_Object result = Qnil; | |
| 799 struct gcpro gcpro1; | |
| 800 GCPRO1 (result); | |
| 801 | |
| 802 /* Do consing in reverse order. | |
| 803 Number of copies */ | |
| 510 | 804 result = Fcons (Qcopies, Fcons (make_int (pd.nCopies), result)); |
| 442 | 805 |
| 806 /* Page range */ | |
| 510 | 807 if (pd.Flags & PD_PAGENUMS) |
| 442 | 808 { |
| 809 result = Fcons (Qto_page, Fcons (make_int (pd.nToPage), result)); | |
| 810 result = Fcons (Qfrom_page, Fcons (make_int (pd.nFromPage), result)); | |
| 510 | 811 result = Fcons (Qselected_page_button, Fcons (Qpages, result)); |
| 442 | 812 } |
| 510 | 813 else if (pd.Flags & PD_SELECTION) |
| 814 result = Fcons (Qselected_page_button, Fcons (Qselection, result)); | |
| 815 else | |
| 816 result = Fcons (Qselected_page_button, Fcons (Qall, result)); | |
| 442 | 817 |
| 818 /* Device name */ | |
| 771 | 819 result = Fcons (Qname, Fcons (ldm->printer_name, result)); |
| 442 | 820 UNGCPRO; |
| 821 | |
| 822 global_free_2_maybe (pd.hDevNames, pd.hDevMode); | |
| 823 return result; | |
| 824 } | |
| 825 } | |
| 826 | |
| 827 Lisp_Object | |
| 2286 | 828 mswindows_handle_print_dialog_box (struct frame *UNUSED (f), Lisp_Object keys) |
| 442 | 829 { |
| 830 Lisp_Object device = Qunbound, settings = Qunbound; | |
| 510 | 831 DWORD flags = PD_NOSELECTION; |
| 442 | 832 |
| 833 { | |
| 834 EXTERNAL_PROPERTY_LIST_LOOP_3 (key, value, keys) | |
| 835 { | |
| 836 if (EQ (key, Q_device)) | |
| 837 { | |
| 838 device = wrap_device (decode_device (value)); | |
| 839 CHECK_MSPRINTER_DEVICE (device); | |
| 840 } | |
| 841 else if (EQ (key, Q_printer_settings)) | |
| 842 { | |
| 843 CHECK_DEVMODE (value); | |
| 844 settings = value; | |
| 845 } | |
| 510 | 846 else if (EQ (key, Q_allow_pages)) |
| 847 { | |
| 848 if (NILP (value)) | |
| 849 flags |= PD_NOPAGENUMS; | |
| 850 } | |
| 851 else if (EQ (key, Q_allow_selection)) | |
| 442 | 852 { |
| 510 | 853 if (!NILP (value)) |
| 854 flags &= ~PD_NOSELECTION; | |
| 442 | 855 } |
| 510 | 856 else if (EQ (key, Q_selected_page_button)) |
| 442 | 857 { |
| 510 | 858 if (EQ (value, Qselection)) |
| 859 flags |= PD_SELECTION; | |
| 860 else if (EQ (value, Qpages)) | |
| 861 flags |= PD_PAGENUMS; | |
| 862 else if (!EQ (value, Qall)) | |
| 563 | 863 invalid_constant ("for :selected-page-button", value); |
| 442 | 864 } |
| 865 else | |
| 563 | 866 invalid_constant ("Unrecognized print-dialog keyword", key); |
| 442 | 867 } |
| 868 } | |
| 869 | |
| 870 if ((UNBOUNDP (device) && UNBOUNDP (settings)) || | |
| 871 (!UNBOUNDP (device) && !UNBOUNDP (settings))) | |
| 563 | 872 sferror ("Exactly one of :device and :printer-settings must be given", |
| 442 | 873 keys); |
| 874 | |
| 510 | 875 return print_dialog_worker (!UNBOUNDP (device) ? device : settings, flags); |
| 442 | 876 } |
| 877 | |
| 506 | 878 int |
| 879 mswindows_get_default_margin (Lisp_Object prop) | |
| 880 { | |
| 881 if (EQ (prop, Qleft_margin)) return 1440; | |
| 882 if (EQ (prop, Qright_margin)) return 1440; | |
| 883 if (EQ (prop, Qtop_margin)) return 720; | |
| 884 if (EQ (prop, Qbottom_margin)) return 720; | |
| 2500 | 885 ABORT (); |
| 506 | 886 return 0; |
| 887 } | |
| 888 | |
| 442 | 889 static int |
| 798 | 890 plist_get_margin (Lisp_Object plist, Lisp_Object prop, int mm_p) |
| 442 | 891 { |
| 506 | 892 Lisp_Object val = |
| 893 Fplist_get (plist, prop, make_int (mswindows_get_default_margin (prop))); | |
| 442 | 894 if (!INTP (val)) |
| 895 invalid_argument ("Margin value must be an integer", val); | |
| 896 | |
| 798 | 897 return MulDiv (XINT (val), mm_p ? 254 : 100, 144); |
| 442 | 898 } |
| 899 | |
| 900 static Lisp_Object | |
| 901 plist_set_margin (Lisp_Object plist, Lisp_Object prop, int margin, int mm_p) | |
| 902 { | |
| 798 | 903 Lisp_Object val = make_int (MulDiv (margin, 144, mm_p ? 254 : 100)); |
| 442 | 904 return Fcons (prop, Fcons (val, plist)); |
| 905 } | |
| 906 | |
| 907 Lisp_Object | |
| 2286 | 908 mswindows_handle_page_setup_dialog_box (struct frame *UNUSED (f), |
| 909 Lisp_Object keys) | |
| 442 | 910 { |
| 911 Lisp_Object device = Qunbound, settings = Qunbound; | |
| 912 Lisp_Object plist = Qnil; | |
| 913 | |
| 914 { | |
| 915 EXTERNAL_PROPERTY_LIST_LOOP_3 (key, value, keys) | |
| 916 { | |
| 917 if (EQ (key, Q_device)) | |
| 918 { | |
| 919 device = wrap_device (decode_device (value)); | |
| 920 CHECK_MSPRINTER_DEVICE (device); | |
| 921 } | |
| 922 else if (EQ (key, Q_printer_settings)) | |
| 923 { | |
| 924 CHECK_DEVMODE (value); | |
| 925 settings = value; | |
| 926 } | |
| 927 else if (EQ (key, Q_properties)) | |
| 928 { | |
| 929 CHECK_LIST (value); | |
| 930 plist = value; | |
| 931 } | |
| 932 else | |
| 563 | 933 invalid_constant ("Unrecognized page-setup dialog keyword", key); |
| 442 | 934 } |
| 935 } | |
| 936 | |
| 937 if ((UNBOUNDP (device) && UNBOUNDP (settings)) || | |
| 938 (!UNBOUNDP (device) && !UNBOUNDP (settings))) | |
| 563 | 939 sferror ("Exactly one of :device and :printer-settings must be given", |
| 800 | 940 keys); |
| 442 | 941 |
| 942 if (UNBOUNDP (device)) | |
| 943 device = settings; | |
| 944 | |
| 945 { | |
| 946 Lisp_Devmode *ldm = decode_devmode (device); | |
| 771 | 947 PAGESETUPDLGW pd; |
| 853 | 948 Extbyte measure[2 * MAX_XETCHAR_SIZE]; |
| 850 | 949 int data; |
| 798 | 950 |
| 850 | 951 qxeGetLocaleInfo (LOCALE_USER_DEFAULT, LOCALE_IMEASURE, |
| 853 | 952 measure, sizeof (measure) / XETCHAR_SIZE); |
| 2421 | 953 data = qxetcscmp (measure, XETEXT ("0")); |
| 442 | 954 |
| 955 memset (&pd, 0, sizeof (pd)); | |
| 956 pd.lStructSize = sizeof (pd); | |
| 957 pd.hwndOwner = mswindows_get_selected_frame_hwnd (); | |
| 958 pd.Flags = PSD_MARGINS; | |
| 798 | 959 pd.rtMargin.left = plist_get_margin (plist, Qleft_margin, !data); |
| 960 pd.rtMargin.top = plist_get_margin (plist, Qtop_margin, !data); | |
| 961 pd.rtMargin.right = plist_get_margin (plist, Qright_margin, !data); | |
| 962 pd.rtMargin.bottom = plist_get_margin (plist, Qbottom_margin, !data); | |
| 442 | 963 pd.hDevMode = devmode_to_hglobal (ldm); |
| 964 | |
| 771 | 965 if (!qxePageSetupDlg (&pd)) |
| 442 | 966 { |
| 967 global_free_2_maybe (pd.hDevNames, pd.hDevMode); | |
| 968 return Qnil; | |
| 969 } | |
| 970 | |
| 971 if (pd.hDevMode) | |
| 972 handle_devmode_changes (ldm, pd.hDevNames, pd.hDevMode); | |
| 973 | |
| 974 /* Finally, build the resulting plist */ | |
| 975 { | |
| 976 Lisp_Object result = Qnil; | |
| 977 int mm_p = pd.Flags & PSD_INHUNDREDTHSOFMILLIMETERS; | |
| 978 result = plist_set_margin (result, Qbottom_margin, pd.rtMargin.bottom, | |
| 979 mm_p); | |
| 980 result = plist_set_margin (result, Qright_margin, pd.rtMargin.right, | |
| 981 mm_p); | |
| 982 result = plist_set_margin (result, Qtop_margin, pd.rtMargin.top, mm_p); | |
| 983 result = plist_set_margin (result, Qleft_margin, pd.rtMargin.left, mm_p); | |
| 984 return result; | |
| 985 } | |
| 986 } | |
| 987 } | |
| 988 | |
| 989 DEFUN ("msprinter-get-settings", Fmsprinter_get_settings, 1, 1, 0, /* | |
| 990 Return the settings object currently used by DEVICE. | |
| 991 The object returned is not a copy, but rather a pointer to the | |
| 992 original one. Use `msprinter-settings-copy' to create a copy of it. | |
| 993 */ | |
| 994 (device)) | |
| 995 { | |
| 996 struct device *d = decode_device (device); | |
| 793 | 997 device = wrap_device (d); |
| 442 | 998 CHECK_MSPRINTER_DEVICE (device); |
| 999 return DEVICE_MSPRINTER_DEVMODE (d); | |
| 1000 } | |
| 1001 | |
| 1002 DEFUN ("msprinter-select-settings", Fmsprinter_select_settings, 2, 2, 0, /* | |
| 1003 Select SETTINGS object into a DEVICE. | |
| 1004 The settings from the settings object are immediately applied to the | |
| 1005 printer, possibly changing even the target printer itself, and all | |
| 1006 future changes are applied synchronously to the printer device and the | |
| 1007 selected printer object, until a different settings object is selected | |
| 1008 into the same printer. | |
| 1009 | |
| 1010 A settings object can be selected to no more than one printer at a time. | |
| 1011 | |
| 1012 If the supplied settings object is not specialized, it is specialized | |
| 1013 for the printer immediately upon selection. The object can be | |
| 1014 despecialized after it is unselected by calling the function | |
| 1015 `msprinter-settings-despecialize'. | |
| 1016 | |
| 1017 Return value is the previously selected settings object. | |
| 1018 */ | |
| 1019 (device, settings)) | |
| 440 | 1020 { |
| 442 | 1021 Lisp_Devmode *ldm; |
| 1022 struct device *d = decode_device (device); | |
| 1023 | |
| 1024 struct gcpro gcpro1; | |
| 1025 GCPRO1 (settings); | |
| 1026 | |
| 793 | 1027 device = wrap_device (d); |
| 442 | 1028 CHECK_MSPRINTER_DEVICE (device); |
| 1029 CHECK_DEVMODE (settings); | |
| 1030 ldm = XDEVMODE (settings); | |
| 1031 | |
| 1032 if (!NILP (ldm->device)) | |
| 1033 invalid_operation ("The object is currently selected into a device", | |
| 1034 settings); | |
| 1035 | |
| 1036 /* If the object being selected is de-specialized, then its | |
| 1037 size is perhaps not enough to receive the new devmode. We can ask | |
| 1038 for printer's devmode size here, because despecialized settings | |
| 1039 cannot force switching to a different printer, as they supply no | |
| 1040 printer name at all. */ | |
| 771 | 1041 if (NILP (ldm->printer_name)) |
| 442 | 1042 { |
| 771 | 1043 Extbyte *nameext; |
| 1044 LONG dm_size; | |
| 1045 | |
| 1046 LISP_STRING_TO_TSTR (DEVICE_MSPRINTER_NAME (d), nameext); | |
| 1047 dm_size = qxeDocumentProperties (NULL, DEVICE_MSPRINTER_HPRINTER (d), | |
| 1048 nameext, NULL, NULL, 0); | |
| 442 | 1049 if (dm_size <= 0) |
| 563 | 1050 signal_error (Qio_error, |
| 1051 "Unable to specialize settings, printer error", | |
| 1052 device); | |
| 442 | 1053 |
| 1054 assert (XDEVMODE_SIZE (ldm) <= dm_size); | |
| 771 | 1055 ldm->devmode = (DEVMODEW *) xrealloc (ldm->devmode, dm_size); |
| 442 | 1056 } |
| 1057 | |
| 1058 /* If we bail out on signal here, no damage is done, except that | |
| 1059 the storage for the DEVMODE structure might be reallocated to | |
| 1060 hold a larger one - not a big deal */ | |
| 1061 if (!sync_printer_with_devmode (d, ldm->devmode, ldm->devmode, | |
| 1062 ldm->printer_name)) | |
| 563 | 1063 signal_error (Qio_error, |
| 1064 "Printer device initialization I/O error, device deleted", | |
| 771 | 1065 device); |
| 442 | 1066 |
| 771 | 1067 if (NILP (ldm->printer_name )) |
| 1068 ldm->printer_name = DEVICE_MSPRINTER_NAME (d); | |
| 442 | 1069 |
| 1070 { | |
| 1071 Lisp_Object old_mode = DEVICE_MSPRINTER_DEVMODE (d); | |
| 1072 ldm->device = device; | |
| 1073 XDEVMODE (old_mode)->device = Qnil; | |
| 1074 DEVICE_MSPRINTER_DEVMODE (d) = settings; | |
| 1075 UNGCPRO; | |
| 1076 return old_mode; | |
| 1077 } | |
| 1078 } | |
| 1079 | |
| 1080 DEFUN ("msprinter-apply-settings", Fmsprinter_apply_settings, 2, 2, 0, /* | |
| 3025 | 1081 Apply settings from a SETTINGS object to a `msprinter' DEVICE. |
| 442 | 1082 The settings from the settings object are immediately applied to the |
| 1083 printer, possibly changing even the target printer itself. The SETTING | |
| 1084 object is not modified, unlike `msprinter-select-settings', and the | |
| 1085 supplied object is not changed. The changes are immediately recorded | |
| 1086 into the settings object which is currently selected into the printer | |
| 1087 device. | |
| 1088 | |
| 1089 Return value is the currently selected settings object. | |
| 1090 */ | |
| 1091 (device, settings)) | |
| 1092 { | |
| 1093 Lisp_Devmode *ldm_current, *ldm_new; | |
| 1094 struct device *d = decode_device (device); | |
| 1095 | |
| 1096 struct gcpro gcpro1; | |
| 1097 GCPRO1 (settings); | |
| 1098 | |
| 793 | 1099 device = wrap_device (d); |
| 442 | 1100 CHECK_MSPRINTER_DEVICE (device); |
| 1101 CHECK_DEVMODE (settings); | |
| 1102 ldm_new = XDEVMODE (settings); | |
| 1103 ldm_current = XDEVMODE (DEVICE_MSPRINTER_DEVMODE (d)); | |
| 1104 | |
| 1105 /* If the supplied devmode is not specialized, then the current | |
| 1106 devmode size will always be sufficient, as the printer does | |
| 1107 not change. If it is specialized, we must reallocate the current | |
| 1108 devmode storage to match with the supplied one, as it has the right | |
| 1109 size for the new printer, if it is going to change. The correct | |
| 1110 way is to use the largest of the two though, to keep the old | |
| 1111 contents unchanged in case of preliminary exit. | |
| 1112 */ | |
| 771 | 1113 if (!NILP (ldm_new->printer_name)) |
| 442 | 1114 ldm_current->devmode = |
| 771 | 1115 (DEVMODEW*) xrealloc (ldm_current->devmode, |
| 442 | 1116 max (XDEVMODE_SIZE (ldm_new), |
| 1117 XDEVMODE_SIZE (ldm_current))); | |
| 1118 | |
| 1119 if (!sync_printer_with_devmode (d, ldm_new->devmode, | |
| 1120 ldm_current->devmode, | |
| 1121 ldm_new->printer_name)) | |
| 771 | 1122 signal_error |
| 1123 (Qio_error, | |
| 1124 "Printer device initialization I/O error, device deleted", device); | |
| 1125 | |
| 1126 if (!NILP (ldm_new->printer_name)) | |
| 1127 ldm_current->printer_name = ldm_new->printer_name; | |
| 442 | 1128 |
| 446 | 1129 UNGCPRO; |
| 442 | 1130 return DEVICE_MSPRINTER_DEVMODE (d); |
| 1131 } | |
| 1132 | |
| 1133 /************************************************************************/ | |
| 1134 /* devmode */ | |
| 1135 /************************************************************************/ | |
| 1136 | |
| 1204 | 1137 static const struct memory_description devmode_description[] = { |
| 934 | 1138 { XD_LISP_OBJECT, offsetof (struct Lisp_Devmode, printer_name) }, |
| 964 | 1139 { XD_LISP_OBJECT, offsetof (struct Lisp_Devmode, device) }, |
| 934 | 1140 { XD_END } |
| 1141 }; | |
| 1142 | |
| 771 | 1143 static Lisp_Object |
| 1144 mark_devmode (Lisp_Object obj) | |
| 1145 { | |
| 1146 Lisp_Devmode *data = XDEVMODE (obj); | |
| 1147 mark_object (data->printer_name); | |
| 1148 return data->device; | |
| 1149 } | |
| 1150 | |
| 442 | 1151 static void |
| 1152 print_devmode (Lisp_Object obj, Lisp_Object printcharfun, | |
| 2286 | 1153 int UNUSED (escapeflag)) |
| 442 | 1154 { |
| 1155 Lisp_Devmode *dm = XDEVMODE (obj); | |
| 1156 if (print_readably) | |
| 4846 | 1157 printing_unreadable_lcrecord (obj, 0); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4846
diff
changeset
|
1158 write_ascstring (printcharfun, "#<msprinter-settings"); |
| 771 | 1159 if (!NILP (dm->printer_name)) |
| 800 | 1160 write_fmt_string_lisp (printcharfun, " for %S", 1, dm->printer_name); |
| 442 | 1161 if (!NILP (dm->device)) |
| 800 | 1162 write_fmt_string_lisp (printcharfun, " (currently on %s)", 1, dm->device); |
| 1163 write_fmt_string (printcharfun, " 0x%x>", dm->header.uid); | |
| 442 | 1164 } |
| 1165 | |
| 1166 static void | |
| 1167 finalize_devmode (void *header, int for_disksave) | |
| 1168 { | |
| 1169 Lisp_Devmode *dm = (Lisp_Devmode *) header; | |
| 1170 | |
| 1171 if (for_disksave) | |
| 1172 { | |
| 793 | 1173 Lisp_Object devmode = wrap_devmode (dm); |
| 1174 | |
| 442 | 1175 invalid_operation |
| 1176 ("Cannot dump XEmacs containing an msprinter-settings object", | |
| 1177 devmode); | |
| 1178 } | |
| 1179 | |
| 1180 assert (NILP (dm->device)); | |
| 1181 } | |
| 1182 | |
| 1183 static int | |
| 2286 | 1184 equal_devmode (Lisp_Object obj1, Lisp_Object obj2, int UNUSED (depth)) |
| 442 | 1185 { |
| 1186 Lisp_Devmode *dm1 = XDEVMODE (obj1); | |
| 1187 Lisp_Devmode *dm2 = XDEVMODE (obj2); | |
| 440 | 1188 |
| 442 | 1189 if ((dm1->devmode != NULL) != (dm1->devmode != NULL)) |
| 1190 return 0; | |
| 1191 if (dm1->devmode == NULL) | |
| 1192 return 1; | |
| 1193 if (memcmp (dm1->devmode, dm2->devmode, XDEVMODE_SIZE (dm1)) != 0) | |
| 1194 return 0; | |
| 771 | 1195 if (NILP (dm1->printer_name) || NILP (dm2->printer_name)) |
| 442 | 1196 return 1; |
| 771 | 1197 return lisp_strcasecmp (dm1->printer_name, dm2->printer_name) == 0; |
| 442 | 1198 } |
| 1199 | |
| 665 | 1200 static Hashcode |
| 442 | 1201 hash_devmode (Lisp_Object obj, int depth) |
| 1202 { | |
| 1203 Lisp_Devmode *dm = XDEVMODE (obj); | |
| 1204 | |
| 1205 return HASH3 (XDEVMODE_SIZE (dm), | |
| 1206 dm->devmode ? memory_hash (dm->devmode, XDEVMODE_SIZE (dm)) | |
| 1207 : 0, | |
| 771 | 1208 internal_hash (dm->printer_name, depth + 1)); |
| 442 | 1209 } |
| 1210 | |
| 934 | 1211 DEFINE_LRECORD_IMPLEMENTATION ("msprinter-settings", devmode, |
| 964 | 1212 0, /*dumpable-flag*/ |
| 934 | 1213 mark_devmode, print_devmode, finalize_devmode, |
| 1214 equal_devmode, hash_devmode, | |
| 1215 devmode_description, | |
| 1216 Lisp_Devmode); | |
| 1217 | |
| 442 | 1218 static Lisp_Object |
| 771 | 1219 allocate_devmode (DEVMODEW* src_devmode, int do_copy, |
| 1220 Lisp_Object src_name, struct device *d) | |
| 442 | 1221 { |
| 1222 Lisp_Devmode *dm; | |
| 1223 | |
| 3017 | 1224 dm = ALLOC_LCRECORD_TYPE (Lisp_Devmode, &lrecord_devmode); |
| 442 | 1225 |
| 1226 if (d) | |
| 793 | 1227 dm->device = wrap_device (d); |
| 442 | 1228 else |
| 1229 dm->device = Qnil; | |
| 1230 | |
| 771 | 1231 dm->printer_name = src_name; |
| 442 | 1232 |
| 1233 if (src_devmode != NULL && do_copy) | |
| 1234 { | |
| 771 | 1235 dm->devmode = (DEVMODEW*) xmalloc (DEVMODE_SIZE (src_devmode)); |
| 442 | 1236 memcpy (dm->devmode, src_devmode, DEVMODE_SIZE (src_devmode)); |
| 1237 } | |
| 1238 else | |
| 1239 { | |
| 1240 dm->devmode = src_devmode; | |
| 1241 } | |
| 1242 | |
| 793 | 1243 return wrap_devmode (dm); |
| 442 | 1244 } |
| 1245 | |
| 1246 DEFUN ("msprinter-settings-copy", Fmsprinter_settings_copy, 1, 1, 0, /* | |
| 1247 Create and returns an exact copy of a printer settings object. | |
| 1248 */ | |
| 1249 (settings)) | |
| 1250 { | |
| 1251 Lisp_Devmode *dm; | |
| 1252 | |
| 1253 CHECK_DEVMODE (settings); | |
| 1254 dm = XDEVMODE (settings); | |
| 1255 | |
| 1256 return allocate_devmode (dm->devmode, 1, dm->printer_name, NULL); | |
| 1257 } | |
| 1258 | |
| 1259 DEFUN ("msprinter-settings-despecialize", Fmsprinter_settings_despecialize, 1, 1, 0, /* | |
| 1260 Erase printer-specific settings from a printer settings object. | |
| 1261 */ | |
| 1262 (settings)) | |
| 1263 { | |
| 1264 Lisp_Devmode *ldm; | |
| 771 | 1265 DEVMODEW *dm; |
| 442 | 1266 |
| 1267 CHECK_DEVMODE (settings); | |
| 1268 ldm = XDEVMODE (settings); | |
| 1269 | |
| 1270 if (!NILP (ldm->device)) | |
| 1271 invalid_operation ("The object is currently selected into a device", | |
| 1272 settings); | |
| 1273 | |
| 1274 dm = ldm->devmode; | |
| 1275 | |
| 1276 /* #### TODO. Either remove references to device specific bins, | |
| 1277 paper sizes etc, or signal an error of they are present. */ | |
| 440 | 1278 |
| 442 | 1279 dm->dmDriverExtra = 0; |
| 1280 dm->dmDeviceName[0] = '\0'; | |
| 1281 | |
| 771 | 1282 ldm->printer_name = Qnil; |
| 442 | 1283 |
| 1284 return Qnil; | |
| 1285 } | |
| 1286 | |
| 1287 DEFUN ("mswindows-get-default-printer", Fmswindows_get_default_printer, 0, 0, 0, /* | |
| 1288 Return name of the default printer, as string, on nil if there is no default. | |
| 1289 */ | |
| 1290 ()) | |
| 1291 { | |
| 1292 return msprinter_default_printer (); | |
| 1293 } | |
| 1294 | |
| 1295 static void | |
| 1296 signal_enum_printer_error (void) | |
| 1297 { | |
| 1298 invalid_operation ("Error enumerating printers", make_int (GetLastError ())); | |
| 1299 } | |
| 1300 | |
| 1301 DEFUN ("mswindows-printer-list", Fmswindows_printer_list, 0, 0, 0, /* | |
| 1302 Return a list of string names of installed printers. | |
| 1303 If there is a default printer, it is returned as the first element of | |
| 1304 the list. If there is no default printer, the first element of the | |
| 1305 list will be nil. The rest of elements are guaranteed to have string | |
| 1306 values. Return value is nil if there are no printers installed. | |
| 1307 */ | |
| 1308 ()) | |
| 1309 { | |
| 1310 int have_nt, ok; | |
| 1311 BYTE *data_buf, dummy_byte; | |
| 665 | 1312 Bytecount enum_entry_size; |
| 442 | 1313 DWORD enum_flags, enum_level, bytes_needed, num_printers; |
| 1314 struct gcpro gcpro1, gcpro2; | |
| 1315 Lisp_Object result = Qnil, def_printer = Qnil; | |
| 1316 | |
| 1317 /* Determine OS flavor, to use the fastest enumeration method available */ | |
| 771 | 1318 have_nt = !mswindows_windows9x_p; |
| 442 | 1319 enum_flags = PRINTER_ENUM_LOCAL | (have_nt ? PRINTER_ENUM_CONNECTIONS : 0); |
| 1320 enum_level = have_nt ? 4 : 5; | |
| 771 | 1321 enum_entry_size = (have_nt ? sizeof (PRINTER_INFO_4) : |
| 1322 sizeof (PRINTER_INFO_5)); | |
| 442 | 1323 |
| 1324 /* Allocate memory for printer enum structure */ | |
| 771 | 1325 ok = qxeEnumPrinters (enum_flags, NULL, enum_level, &dummy_byte, 1, |
| 1326 &bytes_needed, &num_printers); | |
| 442 | 1327 if (ok) |
| 1328 /* No printers, if just 1 byte is enough */ | |
| 1329 return Qnil; | |
| 1330 | |
| 1331 if (GetLastError () != ERROR_INSUFFICIENT_BUFFER) | |
| 1332 signal_enum_printer_error (); | |
| 1333 | |
| 2367 | 1334 data_buf = alloca_array (BYTE, bytes_needed); |
| 771 | 1335 ok = qxeEnumPrinters (enum_flags, NULL, enum_level, data_buf, bytes_needed, |
| 1336 &bytes_needed, &num_printers); | |
| 442 | 1337 if (!ok) |
| 1338 signal_enum_printer_error (); | |
| 1339 | |
| 1340 if (num_printers == 0) | |
| 1341 /* Strange but... */ | |
| 1342 return Qnil; | |
| 1343 | |
| 1344 GCPRO2 (result, def_printer); | |
| 1345 | |
| 1346 while (num_printers--) | |
| 1347 { | |
| 771 | 1348 Extbyte *printer_name; |
| 442 | 1349 if (have_nt) |
| 1350 { | |
| 771 | 1351 PRINTER_INFO_4 *info = (PRINTER_INFO_4 *) data_buf; |
| 1352 printer_name = (Extbyte *) info->pPrinterName; | |
| 442 | 1353 } |
| 1354 else | |
| 1355 { | |
| 771 | 1356 PRINTER_INFO_5 *info = (PRINTER_INFO_5 *) data_buf; |
| 1357 printer_name = (Extbyte *) info->pPrinterName; | |
| 442 | 1358 } |
| 1359 data_buf += enum_entry_size; | |
| 1360 | |
| 771 | 1361 result = Fcons (build_tstr_string (printer_name), result); |
| 442 | 1362 } |
| 1363 | |
| 1364 def_printer = msprinter_default_printer (); | |
| 1365 result = Fdelete (def_printer, result); | |
| 1366 result = Fcons (def_printer, result); | |
| 1367 | |
| 1368 RETURN_UNGCPRO (result); | |
| 440 | 1369 } |
| 1370 | |
| 1371 | |
| 1372 /************************************************************************/ | |
| 428 | 1373 /* initialization */ |
| 1374 /************************************************************************/ | |
| 1375 | |
| 1376 void | |
| 1377 syms_of_device_mswindows (void) | |
| 1378 { | |
| 442 | 1379 INIT_LRECORD_IMPLEMENTATION (devmode); |
| 1380 | |
| 3092 | 1381 #ifdef NEW_GC |
| 1382 INIT_LRECORD_IMPLEMENTATION (mswindows_device); | |
| 1383 INIT_LRECORD_IMPLEMENTATION (msprinter_device); | |
| 1384 #endif /* NEW_GC */ | |
| 1385 | |
| 442 | 1386 DEFSUBR (Fmsprinter_get_settings); |
| 1387 DEFSUBR (Fmsprinter_select_settings); | |
| 1388 DEFSUBR (Fmsprinter_apply_settings); | |
| 1389 DEFSUBR (Fmsprinter_settings_copy); | |
| 1390 DEFSUBR (Fmsprinter_settings_despecialize); | |
| 1391 DEFSUBR (Fmswindows_get_default_printer); | |
| 1392 DEFSUBR (Fmswindows_printer_list); | |
| 1393 | |
| 510 | 1394 DEFKEYWORD (Q_allow_selection); |
| 1395 DEFKEYWORD (Q_allow_pages); | |
| 1396 DEFKEYWORD (Q_selected_page_button); | |
| 1397 DEFSYMBOL (Qselected_page_button); | |
| 1398 | |
|
4477
e34711681f30
Don't determine whether to call general device-type code at startup,
Aidan Kehoe <kehoea@parhasard.net>
parents:
4117
diff
changeset
|
1399 DEFSYMBOL (Qmake_device_early_mswindows_entry_point); |
|
e34711681f30
Don't determine whether to call general device-type code at startup,
Aidan Kehoe <kehoea@parhasard.net>
parents:
4117
diff
changeset
|
1400 DEFSYMBOL ( Qmake_device_late_mswindows_entry_point); |
| 428 | 1401 } |
| 1402 | |
| 1403 void | |
| 1404 console_type_create_device_mswindows (void) | |
| 1405 { | |
| 1406 CONSOLE_HAS_METHOD (mswindows, init_device); | |
| 1407 CONSOLE_HAS_METHOD (mswindows, finish_init_device); | |
| 440 | 1408 CONSOLE_HAS_METHOD (mswindows, mark_device); |
| 428 | 1409 CONSOLE_HAS_METHOD (mswindows, delete_device); |
| 1410 CONSOLE_HAS_METHOD (mswindows, device_system_metrics); | |
| 545 | 1411 CONSOLE_IMPLEMENTATION_FLAGS (mswindows, XDEVIMPF_PIXEL_GEOMETRY); |
| 440 | 1412 |
| 1413 CONSOLE_HAS_METHOD (msprinter, init_device); | |
| 1414 CONSOLE_HAS_METHOD (msprinter, mark_device); | |
| 1415 CONSOLE_HAS_METHOD (msprinter, delete_device); | |
| 1416 CONSOLE_HAS_METHOD (msprinter, device_system_metrics); | |
| 545 | 1417 CONSOLE_IMPLEMENTATION_FLAGS (msprinter, (XDEVIMPF_PIXEL_GEOMETRY |
| 1418 | XDEVIMPF_IS_A_PRINTER | |
| 1419 | XDEVIMPF_NO_AUTO_REDISPLAY | |
| 1420 | XDEVIMPF_DONT_PREEMPT_REDISPLAY | |
| 1421 | XDEVIMPF_FRAMELESS_OK)); | |
| 428 | 1422 } |
| 1423 | |
| 440 | 1424 |
| 428 | 1425 void |
| 1426 vars_of_device_mswindows (void) | |
| 1427 { | |
| 1428 } |