Mercurial > hg > xemacs-beta
annotate src/frame-msw.c @ 5127:a9c41067dd88 ben-lisp-object
more cleanups, terminology clarification, lots of doc work
-------------------- ChangeLog entries follow: --------------------
man/ChangeLog addition:
2010-03-05 Ben Wing <ben@xemacs.org>
* internals/internals.texi (Introduction to Allocation):
* internals/internals.texi (Integers and Characters):
* internals/internals.texi (Allocation from Frob Blocks):
* internals/internals.texi (lrecords):
* internals/internals.texi (Low-level allocation):
Rewrite section on allocation of Lisp objects to reflect the new
reality. Remove references to nonexistent XSETINT and XSETCHAR.
modules/ChangeLog addition:
2010-03-05 Ben Wing <ben@xemacs.org>
* postgresql/postgresql.c (allocate_pgconn):
* postgresql/postgresql.c (allocate_pgresult):
* postgresql/postgresql.h (struct Lisp_PGconn):
* postgresql/postgresql.h (struct Lisp_PGresult):
* ldap/eldap.c (allocate_ldap):
* ldap/eldap.h (struct Lisp_LDAP):
Same changes as in src/ dir. See large log there in ChangeLog,
but basically:
ALLOC_LISP_OBJECT -> ALLOC_NORMAL_LISP_OBJECT
LISP_OBJECT_HEADER -> NORMAL_LISP_OBJECT_HEADER
../hlo/src/ChangeLog addition:
2010-03-05 Ben Wing <ben@xemacs.org>
* alloc.c:
* alloc.c (old_alloc_sized_lcrecord):
* alloc.c (very_old_free_lcrecord):
* alloc.c (copy_lisp_object):
* alloc.c (zero_sized_lisp_object):
* alloc.c (zero_nonsized_lisp_object):
* alloc.c (lisp_object_storage_size):
* alloc.c (free_normal_lisp_object):
* alloc.c (FREE_FIXED_TYPE_WHEN_NOT_IN_GC):
* alloc.c (ALLOC_FROB_BLOCK_LISP_OBJECT):
* alloc.c (Fcons):
* alloc.c (noseeum_cons):
* alloc.c (make_float):
* alloc.c (make_bignum):
* alloc.c (make_bignum_bg):
* alloc.c (make_ratio):
* alloc.c (make_ratio_bg):
* alloc.c (make_ratio_rt):
* alloc.c (make_bigfloat):
* alloc.c (make_bigfloat_bf):
* alloc.c (size_vector):
* alloc.c (make_compiled_function):
* alloc.c (Fmake_symbol):
* alloc.c (allocate_extent):
* alloc.c (allocate_event):
* alloc.c (make_key_data):
* alloc.c (make_button_data):
* alloc.c (make_motion_data):
* alloc.c (make_process_data):
* alloc.c (make_timeout_data):
* alloc.c (make_magic_data):
* alloc.c (make_magic_eval_data):
* alloc.c (make_eval_data):
* alloc.c (make_misc_user_data):
* alloc.c (Fmake_marker):
* alloc.c (noseeum_make_marker):
* alloc.c (size_string_direct_data):
* alloc.c (make_uninit_string):
* alloc.c (make_string_nocopy):
* alloc.c (mark_lcrecord_list):
* alloc.c (alloc_managed_lcrecord):
* alloc.c (free_managed_lcrecord):
* alloc.c (sweep_lcrecords_1):
* alloc.c (malloced_storage_size):
* buffer.c (allocate_buffer):
* buffer.c (compute_buffer_usage):
* buffer.c (DEFVAR_BUFFER_LOCAL_1):
* buffer.c (nuke_all_buffer_slots):
* buffer.c (common_init_complex_vars_of_buffer):
* buffer.h (struct buffer_text):
* buffer.h (struct buffer):
* bytecode.c:
* bytecode.c (make_compiled_function_args):
* bytecode.c (size_compiled_function_args):
* bytecode.h (struct compiled_function_args):
* casetab.c (allocate_case_table):
* casetab.h (struct Lisp_Case_Table):
* charset.h (struct Lisp_Charset):
* chartab.c (fill_char_table):
* chartab.c (Fmake_char_table):
* chartab.c (make_char_table_entry):
* chartab.c (copy_char_table_entry):
* chartab.c (Fcopy_char_table):
* chartab.c (put_char_table):
* chartab.h (struct Lisp_Char_Table_Entry):
* chartab.h (struct Lisp_Char_Table):
* console-gtk-impl.h (struct gtk_device):
* console-gtk-impl.h (struct gtk_frame):
* console-impl.h (struct console):
* console-msw-impl.h (struct Lisp_Devmode):
* console-msw-impl.h (struct mswindows_device):
* console-msw-impl.h (struct msprinter_device):
* console-msw-impl.h (struct mswindows_frame):
* console-msw-impl.h (struct mswindows_dialog_id):
* console-stream-impl.h (struct stream_console):
* console-stream.c (stream_init_console):
* console-tty-impl.h (struct tty_console):
* console-tty-impl.h (struct tty_device):
* console-tty.c (allocate_tty_console_struct):
* console-x-impl.h (struct x_device):
* console-x-impl.h (struct x_frame):
* console.c (allocate_console):
* console.c (nuke_all_console_slots):
* console.c (DEFVAR_CONSOLE_LOCAL_1):
* console.c (common_init_complex_vars_of_console):
* data.c (make_weak_list):
* data.c (make_weak_box):
* data.c (make_ephemeron):
* database.c:
* database.c (struct Lisp_Database):
* database.c (allocate_database):
* database.c (finalize_database):
* device-gtk.c (allocate_gtk_device_struct):
* device-impl.h (struct device):
* device-msw.c:
* device-msw.c (mswindows_init_device):
* device-msw.c (msprinter_init_device):
* device-msw.c (finalize_devmode):
* device-msw.c (allocate_devmode):
* device-tty.c (allocate_tty_device_struct):
* device-x.c (allocate_x_device_struct):
* device.c:
* device.c (nuke_all_device_slots):
* device.c (allocate_device):
* dialog-msw.c (handle_question_dialog_box):
* elhash.c:
* elhash.c (struct Lisp_Hash_Table):
* elhash.c (finalize_hash_table):
* elhash.c (make_general_lisp_hash_table):
* elhash.c (Fcopy_hash_table):
* elhash.h (htentry):
* emacs.c (main_1):
* eval.c:
* eval.c (size_multiple_value):
* event-stream.c (finalize_command_builder):
* event-stream.c (allocate_command_builder):
* event-stream.c (free_command_builder):
* event-stream.c (event_stream_generate_wakeup):
* event-stream.c (event_stream_resignal_wakeup):
* event-stream.c (event_stream_disable_wakeup):
* event-stream.c (event_stream_wakeup_pending_p):
* events.h (struct Lisp_Timeout):
* events.h (struct command_builder):
* extents-impl.h:
* extents-impl.h (struct extent_auxiliary):
* extents-impl.h (struct extent_info):
* extents-impl.h (set_extent_no_chase_aux_field):
* extents-impl.h (set_extent_no_chase_normal_field):
* extents.c:
* extents.c (gap_array_marker):
* extents.c (gap_array):
* extents.c (extent_list_marker):
* extents.c (extent_list):
* extents.c (stack_of_extents):
* extents.c (gap_array_make_marker):
* extents.c (extent_list_make_marker):
* extents.c (allocate_extent_list):
* extents.c (SLOT):
* extents.c (mark_extent_auxiliary):
* extents.c (allocate_extent_auxiliary):
* extents.c (attach_extent_auxiliary):
* extents.c (size_gap_array):
* extents.c (finalize_extent_info):
* extents.c (allocate_extent_info):
* extents.c (uninit_buffer_extents):
* extents.c (allocate_soe):
* extents.c (copy_extent):
* extents.c (vars_of_extents):
* extents.h:
* faces.c (allocate_face):
* faces.h (struct Lisp_Face):
* faces.h (struct face_cachel):
* file-coding.c:
* file-coding.c (finalize_coding_system):
* file-coding.c (sizeof_coding_system):
* file-coding.c (Fcopy_coding_system):
* file-coding.h (struct Lisp_Coding_System):
* file-coding.h (MARKED_SLOT):
* fns.c (size_bit_vector):
* font-mgr.c:
* font-mgr.c (finalize_fc_pattern):
* font-mgr.c (print_fc_pattern):
* font-mgr.c (Ffc_pattern_p):
* font-mgr.c (Ffc_pattern_create):
* font-mgr.c (Ffc_name_parse):
* font-mgr.c (Ffc_name_unparse):
* font-mgr.c (Ffc_pattern_duplicate):
* font-mgr.c (Ffc_pattern_add):
* font-mgr.c (Ffc_pattern_del):
* font-mgr.c (Ffc_pattern_get):
* font-mgr.c (fc_config_create_using):
* font-mgr.c (fc_strlist_to_lisp_using):
* font-mgr.c (fontset_to_list):
* font-mgr.c (Ffc_config_p):
* font-mgr.c (Ffc_config_up_to_date):
* font-mgr.c (Ffc_config_build_fonts):
* font-mgr.c (Ffc_config_get_cache):
* font-mgr.c (Ffc_config_get_fonts):
* font-mgr.c (Ffc_config_set_current):
* font-mgr.c (Ffc_config_get_blanks):
* font-mgr.c (Ffc_config_get_rescan_interval):
* font-mgr.c (Ffc_config_set_rescan_interval):
* font-mgr.c (Ffc_config_app_font_add_file):
* font-mgr.c (Ffc_config_app_font_add_dir):
* font-mgr.c (Ffc_config_app_font_clear):
* font-mgr.c (size):
* font-mgr.c (Ffc_config_substitute):
* font-mgr.c (Ffc_font_render_prepare):
* font-mgr.c (Ffc_font_match):
* font-mgr.c (Ffc_font_sort):
* font-mgr.c (finalize_fc_config):
* font-mgr.c (print_fc_config):
* font-mgr.h:
* font-mgr.h (struct fc_pattern):
* font-mgr.h (XFC_PATTERN):
* font-mgr.h (struct fc_config):
* font-mgr.h (XFC_CONFIG):
* frame-gtk.c (allocate_gtk_frame_struct):
* frame-impl.h (struct frame):
* frame-msw.c (mswindows_init_frame_1):
* frame-x.c (allocate_x_frame_struct):
* frame.c (nuke_all_frame_slots):
* frame.c (allocate_frame_core):
* gc.c:
* gc.c (GC_CHECK_NOT_FREE):
* glyphs.c (finalize_image_instance):
* glyphs.c (allocate_image_instance):
* glyphs.c (Fcolorize_image_instance):
* glyphs.c (allocate_glyph):
* glyphs.c (unmap_subwindow_instance_cache_mapper):
* glyphs.c (register_ignored_expose):
* glyphs.h (struct Lisp_Image_Instance):
* glyphs.h (struct Lisp_Glyph):
* glyphs.h (struct glyph_cachel):
* glyphs.h (struct expose_ignore):
* gui.c (allocate_gui_item):
* gui.h (struct Lisp_Gui_Item):
* keymap.c (struct Lisp_Keymap):
* keymap.c (make_keymap):
* lisp.h:
* lisp.h (struct Lisp_String_Direct_Data):
* lisp.h (struct Lisp_String_Indirect_Data):
* lisp.h (struct Lisp_Vector):
* lisp.h (struct Lisp_Bit_Vector):
* lisp.h (DECLARE_INLINE_LISP_BIT_VECTOR):
* lisp.h (struct weak_box):
* lisp.h (struct ephemeron):
* lisp.h (struct weak_list):
* lrecord.h:
* lrecord.h (struct lrecord_implementation):
* lrecord.h (MC_ALLOC_CALL_FINALIZER):
* lrecord.h (struct lcrecord_list):
* lstream.c (finalize_lstream):
* lstream.c (sizeof_lstream):
* lstream.c (Lstream_new):
* lstream.c (Lstream_delete):
* lstream.h (struct lstream):
* marker.c:
* marker.c (finalize_marker):
* marker.c (compute_buffer_marker_usage):
* mule-charset.c:
* mule-charset.c (make_charset):
* mule-charset.c (compute_charset_usage):
* objects-impl.h (struct Lisp_Color_Instance):
* objects-impl.h (struct Lisp_Font_Instance):
* objects-tty-impl.h (struct tty_color_instance_data):
* objects-tty-impl.h (struct tty_font_instance_data):
* objects-tty.c (tty_initialize_color_instance):
* objects-tty.c (tty_initialize_font_instance):
* objects.c (finalize_color_instance):
* objects.c (Fmake_color_instance):
* objects.c (finalize_font_instance):
* objects.c (Fmake_font_instance):
* objects.c (reinit_vars_of_objects):
* opaque.c:
* opaque.c (sizeof_opaque):
* opaque.c (make_opaque_ptr):
* opaque.c (free_opaque_ptr):
* opaque.h:
* opaque.h (Lisp_Opaque):
* opaque.h (Lisp_Opaque_Ptr):
* print.c (printing_unreadable_lcrecord):
* print.c (external_object_printer):
* print.c (debug_p4):
* process.c (finalize_process):
* process.c (make_process_internal):
* procimpl.h (struct Lisp_Process):
* rangetab.c (Fmake_range_table):
* rangetab.c (Fcopy_range_table):
* rangetab.h (struct Lisp_Range_Table):
* scrollbar.c:
* scrollbar.c (create_scrollbar_instance):
* scrollbar.c (compute_scrollbar_instance_usage):
* scrollbar.h (struct scrollbar_instance):
* specifier.c (finalize_specifier):
* specifier.c (sizeof_specifier):
* specifier.c (set_specifier_caching):
* specifier.h (struct Lisp_Specifier):
* specifier.h (struct specifier_caching):
* symeval.h:
* symeval.h (SYMBOL_VALUE_MAGIC_P):
* symeval.h (DEFVAR_SYMVAL_FWD):
* symsinit.h:
* syntax.c (init_buffer_syntax_cache):
* syntax.h (struct syntax_cache):
* toolbar.c:
* toolbar.c (allocate_toolbar_button):
* toolbar.c (update_toolbar_button):
* toolbar.h (struct toolbar_button):
* tooltalk.c (struct Lisp_Tooltalk_Message):
* tooltalk.c (make_tooltalk_message):
* tooltalk.c (struct Lisp_Tooltalk_Pattern):
* tooltalk.c (make_tooltalk_pattern):
* ui-gtk.c:
* ui-gtk.c (allocate_ffi_data):
* ui-gtk.c (emacs_gtk_object_finalizer):
* ui-gtk.c (allocate_emacs_gtk_object_data):
* ui-gtk.c (allocate_emacs_gtk_boxed_data):
* ui-gtk.h:
* window-impl.h (struct window):
* window-impl.h (struct window_mirror):
* window.c (finalize_window):
* window.c (allocate_window):
* window.c (new_window_mirror):
* window.c (mark_window_as_deleted):
* window.c (make_dummy_parent):
* window.c (compute_window_mirror_usage):
* window.c (compute_window_usage):
Overall point of this change and previous ones in this repository:
(1) Introduce new, clearer terminology: everything other than int
or char is a "record" object, which comes in two types: "normal
objects" and "frob-block objects". Fix up all places that
referred to frob-block objects as "simple", "basic", etc.
(2) Provide an advertised interface for doing operations on Lisp
objects, including creating new types, that is clean and
consistent in its naming, uses the above-referenced terms and
avoids referencing "lrecords", "old lcrecords", etc., which should
hide under the surface.
(3) Make the size_in_bytes and finalizer methods take a
Lisp_Object rather than a void * for consistency with other methods.
(4) Separate finalizer method into finalizer and disksaver, so
that normal finalize methods don't have to worry about disksaving.
Other specifics:
(1) Renaming:
LISP_OBJECT_HEADER -> NORMAL_LISP_OBJECT_HEADER
ALLOC_LISP_OBJECT -> ALLOC_NORMAL_LISP_OBJECT
implementation->basic_p -> implementation->frob_block_p
ALLOCATE_FIXED_TYPE_AND_SET_IMPL -> ALLOC_FROB_BLOCK_LISP_OBJECT
*FCCONFIG*, wrap_fcconfig -> *FC_CONFIG*, wrap_fc_config
*FCPATTERN*, wrap_fcpattern -> *FC_PATTERN*, wrap_fc_pattern
(the last two changes make the naming of these macros consistent
with the naming of all other macros, since the objects are named
fc-config and fc-pattern with a hyphen)
(2) Lots of documentation fixes in lrecord.h.
(3) Eliminate macros for copying, freeing, zeroing objects, getting
their storage size. Instead, new functions:
zero_sized_lisp_object()
zero_nonsized_lisp_object()
lisp_object_storage_size()
free_normal_lisp_object()
(copy_lisp_object() already exists)
LISP_OBJECT_FROB_BLOCK_P() (actually a macro)
Eliminated:
free_lrecord()
zero_lrecord()
copy_lrecord()
copy_sized_lrecord()
old_copy_lcrecord()
old_copy_sized_lcrecord()
old_zero_lcrecord()
old_zero_sized_lcrecord()
LISP_OBJECT_STORAGE_SIZE()
COPY_SIZED_LISP_OBJECT()
COPY_SIZED_LCRECORD()
COPY_LISP_OBJECT()
ZERO_LISP_OBJECT()
FREE_LISP_OBJECT()
(4) Catch the remaining places where lrecord stuff was used directly
and use the advertised interface, e.g. alloc_sized_lrecord() ->
ALLOC_SIZED_LISP_OBJECT().
(5) Make certain statically-declared pseudo-objects
(buffer_local_flags, console_local_flags) have their lheader
initialized correctly, so things like copy_lisp_object() can work
on them. Make extent_auxiliary_defaults a proper heap object
Vextent_auxiliary_defaults, and make extent auxiliaries dumpable
so that this object can be dumped. allocate_extent_auxiliary()
now just creates the object, and attach_extent_auxiliary()
creates an extent auxiliary and attaches to an extent, like the
old allocate_extent_auxiliary().
(6) Create EXTENT_AUXILIARY_SLOTS macro, similar to the foo-slots.h
files but in a macro instead of a file. The purpose is to avoid
duplication when iterating over all the slots in an extent auxiliary.
Use it.
(7) In lstream.c, don't zero out object after allocation because
allocation routines take care of this.
(8) In marker.c, fix a mistake in computing marker overhead.
(9) In print.c, clean up printing_unreadable_lcrecord(),
external_object_printer() to avoid lots of ifdef NEW_GC's.
(10) Separate toolbar-button allocation into a separate
allocate_toolbar_button() function for use in the example code
in lrecord.h.
| author | Ben Wing <ben@xemacs.org> |
|---|---|
| date | Fri, 05 Mar 2010 04:08:17 -0600 |
| parents | 2a462149bd6a |
| children | 71ee43b8a74d |
| rev | line source |
|---|---|
| 428 | 1 /* Functions for the mswindows window system. |
| 2 Copyright (C) 1989, 1992, 1993, 1994, 1995 Free Software Foundation, Inc. | |
| 5043 | 3 Copyright (C) 1995, 1996, 2001, 2002, 2010 Ben Wing. |
| 428 | 4 |
| 5 This file is part of XEmacs. | |
| 6 | |
| 7 XEmacs is free software; you can redistribute it and/or modify it | |
| 8 under the terms of the GNU General Public License as published by the | |
| 9 Free Software Foundation; either version 2, or (at your option) any | |
| 10 later version. | |
| 11 | |
| 12 XEmacs is distributed in the hope that it will be useful, but WITHOUT | |
| 13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 15 for more details. | |
| 16 | |
| 17 You should have received a copy of the GNU General Public License | |
| 18 along with XEmacs; see the file COPYING. If not, write to | |
| 19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330, | |
| 20 Boston, MA 02111-1307, USA. */ | |
| 21 | |
| 22 /* Synched up with: Not synched with FSF. */ | |
| 23 | |
| 771 | 24 /* This file Mule-ized, 8-14-2000. */ |
| 25 | |
| 428 | 26 /* Authorship: |
| 27 | |
| 28 Ultimately based on FSF. | |
| 29 Substantially rewritten for XEmacs by Ben Wing. | |
| 30 Rewritten for mswindows by Jonathan Harris, November 1997 for 21.0. | |
| 31 Graphics features added and frame resizing fiddled with by Andy Piper. | |
| 32 */ | |
| 33 | |
| 34 #include <config.h> | |
| 35 #include "lisp.h" | |
| 36 | |
| 37 #include "buffer.h" | |
| 872 | 38 #include "device-impl.h" |
| 428 | 39 #include "elhash.h" |
| 40 #include "events.h" | |
| 41 #include "faces.h" | |
| 872 | 42 #include "frame-impl.h" |
| 428 | 43 #include "redisplay.h" |
| 44 #include "window.h" | |
| 45 | |
| 872 | 46 #include "console-msw-impl.h" |
| 800 | 47 #include "glyphs-msw.h" |
| 48 | |
| 428 | 49 #define MSWINDOWS_FRAME_STYLE (WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_OVERLAPPEDWINDOW) |
| 50 #define MSWINDOWS_POPUP_STYLE (WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_POPUP \ | |
| 51 | WS_CAPTION | WS_BORDER | WS_SYSMENU | WS_MINIMIZEBOX) | |
| 52 | |
| 53 #define MSWINDOWS_FRAME_EXSTYLE WS_EX_OVERLAPPEDWINDOW | |
| 54 #define MSWINDOWS_POPUP_EXSTYLE WS_EX_PALETTEWINDOW | |
| 55 | |
| 56 /* Default popup left top corner offset from the same | |
| 57 corner of the parent frame, in pixel */ | |
| 58 #define POPUP_OFFSET 30 | |
| 59 | |
| 60 /* Default popup size, in characters */ | |
| 61 #define POPUP_WIDTH 30 | |
| 62 #define POPUP_HEIGHT 10 | |
| 63 | |
| 793 | 64 /* Default regular frame size, in characters; if too big, it will get |
| 65 shrunk to the workspace size */ | |
| 428 | 66 #define DEFAULT_FRAME_WIDTH 80 |
| 793 | 67 #define DEFAULT_FRAME_HEIGHT 50 |
| 428 | 68 |
| 69 #ifdef HAVE_MENUBARS | |
| 70 #define ADJR_MENUFLAG TRUE | |
| 71 #else | |
| 72 #define ADJR_MENUFLAG FALSE | |
| 73 #endif | |
| 74 | |
| 75 /* Default properties to use when creating frames. */ | |
| 76 Lisp_Object Vdefault_mswindows_frame_plist; | |
| 440 | 77 Lisp_Object Vdefault_msprinter_frame_plist; |
| 428 | 78 Lisp_Object Vmswindows_use_system_frame_size_defaults; |
| 79 | |
| 80 /* This does not need to be GC protected, as it holds a | |
| 81 frame Lisp_Object already protected by Fmake_frame */ | |
| 82 Lisp_Object Vmswindows_frame_being_created; | |
| 83 | |
| 1204 | 84 static const struct memory_description mswindows_frame_data_description_1 [] = { |
| 85 #ifdef HAVE_TOOLBARS | |
| 86 { XD_LISP_OBJECT, offsetof (struct mswindows_frame, toolbar_hash_table) }, | |
| 87 #endif | |
| 88 { XD_LISP_OBJECT, offsetof (struct mswindows_frame, menu_hash_table) }, | |
| 89 { XD_LISP_OBJECT, offsetof (struct mswindows_frame, widget_hash_table1) }, | |
| 90 { XD_LISP_OBJECT, offsetof (struct mswindows_frame, widget_hash_table2) }, | |
| 91 { XD_LISP_OBJECT, offsetof (struct mswindows_frame, widget_hash_table3) }, | |
| 92 { XD_END } | |
| 93 }; | |
| 94 | |
| 3092 | 95 #ifdef NEW_GC |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
parents:
4139
diff
changeset
|
96 DEFINE_DUMPABLE_INTERNAL_LISP_OBJECT ("mswindows-frame", mswindows_frame, |
|
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
parents:
4139
diff
changeset
|
97 0, mswindows_frame_data_description_1, |
|
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
parents:
4139
diff
changeset
|
98 Lisp_Mswindows_Frame); |
| 3092 | 99 #else /* not NEW_GC */ |
| 1204 | 100 extern const struct sized_memory_description mswindows_frame_data_description; |
| 101 | |
| 102 const struct sized_memory_description mswindows_frame_data_description = { | |
| 103 sizeof (struct mswindows_frame), mswindows_frame_data_description_1 | |
| 104 }; | |
| 3092 | 105 #endif /* not NEW_GC */ |
| 1204 | 106 |
| 440 | 107 /*---------------------------------------------------------------------*/ |
| 108 /*----- DISPLAY FRAME -----*/ | |
| 109 /*---------------------------------------------------------------------*/ | |
| 110 | |
| 3022 | 111 static struct frame * |
| 112 decode_mswindows_frame (Lisp_Object frame) | |
| 113 { | |
| 114 if (NILP (frame)) | |
| 115 frame = wrap_frame (selected_frame ()); | |
| 116 CHECK_LIVE_FRAME (frame); | |
| 117 /* this will also catch dead frames, but putting in the above check | |
| 118 results in a more useful error */ | |
| 119 CHECK_MSWINDOWS_FRAME (frame); | |
| 120 return XFRAME (frame); | |
| 121 } | |
| 122 | |
| 442 | 123 HWND |
| 124 mswindows_get_selected_frame_hwnd (void) | |
| 125 { | |
| 126 Lisp_Object frame, device; | |
| 127 | |
| 128 device = Ffind_device (Qnil, Qmswindows); | |
| 129 if (NILP (device)) | |
| 130 return NULL; | |
| 131 frame = DEVICE_SELECTED_FRAME (XDEVICE (device)); | |
| 132 if (NILP (frame)) | |
| 133 return NULL; | |
| 134 | |
| 135 return FRAME_MSWINDOWS_HANDLE (XFRAME (frame)); | |
| 136 } | |
| 137 | |
| 428 | 138 static void |
| 771 | 139 mswindows_init_frame_1 (struct frame *f, Lisp_Object props, |
| 2286 | 140 int UNUSED (frame_name_is_defaulted)) |
| 428 | 141 { |
| 142 Lisp_Object initially_unmapped; | |
| 143 Lisp_Object name, height, width, popup, top, left; | |
| 144 Lisp_Object frame_obj = Qnil; | |
| 145 RECT rect; | |
| 146 XEMACS_RECT_WH rect_default; | |
| 147 DWORD style, exstyle; | |
| 148 HWND hwnd, hwnd_parent; | |
| 149 | |
| 150 /* Pick up relevant properties */ | |
| 151 initially_unmapped = Fplist_get (props, Qinitially_unmapped, Qnil); | |
| 152 name = Fplist_get (props, Qname, Qnil); | |
| 442 | 153 |
| 428 | 154 popup = Fplist_get (props, Qpopup, Qnil); |
| 155 if (EQ (popup, Qt)) | |
| 156 popup = Fselected_frame (Qnil); | |
| 157 | |
| 158 left = Fplist_get (props, Qleft, Qnil); | |
| 159 if (!NILP (left)) | |
| 160 CHECK_INT (left); | |
| 161 | |
| 162 top = Fplist_get (props, Qtop, Qnil); | |
| 163 if (!NILP (top)) | |
| 164 CHECK_INT (top); | |
| 165 | |
| 166 width = Fplist_get (props, Qwidth, Qnil); | |
| 167 if (!NILP (width)) | |
| 168 CHECK_INT (width); | |
| 169 | |
| 170 height = Fplist_get (props, Qheight, Qnil); | |
| 171 if (!NILP (height)) | |
| 172 CHECK_INT (height); | |
| 173 | |
| 3092 | 174 #ifdef NEW_GC |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
175 f->frame_data = XMSWINDOWS_FRAME (ALLOC_NORMAL_LISP_OBJECT (mswindows_frame)); |
| 3092 | 176 #else /* not NEW_GC */ |
| 428 | 177 f->frame_data = xnew_and_zero (struct mswindows_frame); |
| 3092 | 178 #endif /* not NEW_GC */ |
| 428 | 179 FRAME_MSWINDOWS_TARGET_RECT (f) = xnew_and_zero (XEMACS_RECT_WH); |
| 180 | |
| 181 FRAME_MSWINDOWS_TARGET_RECT (f)->left = NILP (left) ? -1 : abs (XINT (left)); | |
| 182 FRAME_MSWINDOWS_TARGET_RECT (f)->top = NILP (top) ? -1 : abs (XINT (top)); | |
| 442 | 183 FRAME_MSWINDOWS_TARGET_RECT (f)->width = NILP (width) ? -1 : |
| 428 | 184 abs (XINT (width)); |
| 442 | 185 FRAME_MSWINDOWS_TARGET_RECT (f)->height = NILP (height) ? -1 : |
| 428 | 186 abs (XINT (height)); |
| 442 | 187 |
| 428 | 188 /* Misc frame stuff */ |
| 771 | 189 FRAME_MSWINDOWS_MENU_HASH_TABLE (f) = Qnil; |
| 428 | 190 #ifdef HAVE_TOOLBARS |
| 1130 | 191 /* EQ not EQUAL or we will get QUIT crashes, see below. */ |
| 771 | 192 FRAME_MSWINDOWS_TOOLBAR_HASH_TABLE (f) = |
| 1130 | 193 make_lisp_hash_table (50, HASH_TABLE_NON_WEAK, HASH_TABLE_EQ); |
| 428 | 194 #endif |
|
4906
6ef8256a020a
implement equalp in C, fix case-folding, add equal() method for keymaps
Ben Wing <ben@xemacs.org>
parents:
4139
diff
changeset
|
195 /* hashtable of instantiated glyphs on the frame. [[ Make them EQ because |
| 1123 | 196 we only use ints as keys. Otherwise we run into stickiness in |
| 197 redisplay because internal_equal() can QUIT. See | |
|
4906
6ef8256a020a
implement equalp in C, fix case-folding, add equal() method for keymaps
Ben Wing <ben@xemacs.org>
parents:
4139
diff
changeset
|
198 enter_redisplay_critical_section(). ]] -- probably not true any more, |
|
6ef8256a020a
implement equalp in C, fix case-folding, add equal() method for keymaps
Ben Wing <ben@xemacs.org>
parents:
4139
diff
changeset
|
199 now that we have internal_equal_trapping_problems(). --ben */ |
| 442 | 200 FRAME_MSWINDOWS_WIDGET_HASH_TABLE1 (f) = |
| 853 | 201 make_lisp_hash_table (50, HASH_TABLE_VALUE_WEAK, HASH_TABLE_EQ); |
| 442 | 202 FRAME_MSWINDOWS_WIDGET_HASH_TABLE2 (f) = |
| 853 | 203 make_lisp_hash_table (50, HASH_TABLE_VALUE_WEAK, HASH_TABLE_EQ); |
| 442 | 204 FRAME_MSWINDOWS_WIDGET_HASH_TABLE3 (f) = |
| 853 | 205 make_lisp_hash_table (50, HASH_TABLE_VALUE_WEAK, HASH_TABLE_EQ); |
| 428 | 206 /* Will initialize these in WM_SIZE handler. We cannot do it now, |
| 207 because we do not know what is CW_USEDEFAULT height and width */ | |
| 208 FRAME_WIDTH (f) = 0; | |
| 209 FRAME_HEIGHT (f) = 0; | |
| 210 FRAME_PIXWIDTH (f) = 0; | |
| 211 FRAME_PIXHEIGHT (f) = 0; | |
| 212 | |
| 213 if (NILP (popup)) | |
| 214 { | |
| 215 style = MSWINDOWS_FRAME_STYLE; | |
| 216 exstyle = MSWINDOWS_FRAME_EXSTYLE; | |
| 217 hwnd_parent = NULL; | |
| 218 | |
| 219 rect_default.left = rect_default.top = CW_USEDEFAULT; | |
| 220 rect_default.width = rect_default.height = CW_USEDEFAULT; | |
| 221 } | |
| 222 else | |
| 223 { | |
| 224 style = MSWINDOWS_POPUP_STYLE; | |
| 225 exstyle = MSWINDOWS_POPUP_EXSTYLE; | |
| 226 | |
| 227 CHECK_MSWINDOWS_FRAME (popup); | |
| 228 hwnd_parent = FRAME_MSWINDOWS_HANDLE (XFRAME (popup)); | |
| 229 assert (IsWindow (hwnd_parent)); | |
| 230 | |
| 231 /* We cannot use CW_USEDEFAULT when creating a popup window. | |
| 232 So by default, we offset the new popup 30 pixels right | |
| 233 and down from its parent, and give it size of 30x10 characters. | |
| 234 These dimensions look adequate on both high and low res monitors */ | |
| 235 GetWindowRect (hwnd_parent, &rect); | |
| 236 rect_default.left = rect.left + POPUP_OFFSET; | |
| 237 rect_default.top = rect.top + POPUP_OFFSET; | |
| 5043 | 238 char_to_pixel_size (f, POPUP_WIDTH, POPUP_HEIGHT, |
| 428 | 239 &rect_default.width, &rect_default.height); |
| 442 | 240 FRAME_MSWINDOWS_POPUP (f) = 1; |
| 428 | 241 } |
| 242 | |
| 771 | 243 AdjustWindowRectEx (&rect, style, ADJR_MENUFLAG, exstyle); |
| 428 | 244 |
| 793 | 245 frame_obj = wrap_frame (f); |
| 428 | 246 |
| 247 Vmswindows_frame_being_created = frame_obj; | |
| 771 | 248 { |
| 249 const Extbyte *nameext = 0; | |
| 428 | 250 |
| 771 | 251 if (STRINGP (f->name)) |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4962
diff
changeset
|
252 nameext = LISP_STRING_TO_TSTR (f->name); |
| 771 | 253 else if (STRINGP (name)) |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4962
diff
changeset
|
254 nameext = LISP_STRING_TO_TSTR (name); |
| 771 | 255 else |
| 256 nameext = XETEXT (XEMACS_CLASS); | |
| 257 hwnd = qxeCreateWindowEx (exstyle, | |
| 258 XETEXT (XEMACS_CLASS), | |
| 259 nameext, | |
| 260 style, | |
| 261 rect_default.left, rect_default.top, | |
| 262 rect_default.width, rect_default.height, | |
| 263 hwnd_parent, NULL, NULL, NULL); | |
| 264 } | |
| 428 | 265 |
| 266 Vmswindows_frame_being_created = Qnil; | |
| 267 | |
| 268 if (hwnd == NULL) | |
| 442 | 269 invalid_operation ("System call to create frame failed", |
| 270 STRINGP (f->name) ? f->name : | |
| 271 STRINGP (name) ? name : | |
| 272 Qunbound); | |
| 771 | 273 |
| 274 FRAME_MSWINDOWS_HANDLE (f) = hwnd; | |
| 428 | 275 |
| 5013 | 276 qxeSetWindowLong (hwnd, XWL_FRAMEOBJ, (LONG)STORE_LISP_IN_VOID (frame_obj)); |
| 771 | 277 FRAME_MSWINDOWS_DC (f) = GetDC (hwnd); |
| 278 SetTextAlign (FRAME_MSWINDOWS_DC (f), TA_BASELINE | TA_LEFT | TA_NOUPDATECP); | |
| 442 | 279 |
| 771 | 280 #ifdef HAVE_DIALOGS |
| 442 | 281 if (FRAME_MSWINDOWS_POPUP (f)) |
| 282 mswindows_register_popup_frame (frame_obj); | |
| 771 | 283 #endif /* HAVE_DIALOGS */ |
| 428 | 284 } |
| 285 | |
| 286 static void | |
| 2286 | 287 mswindows_init_frame_2 (struct frame *f, Lisp_Object UNUSED (props)) |
| 428 | 288 { |
| 289 if (NILP (Vmswindows_use_system_frame_size_defaults)) | |
| 290 { | |
| 291 /* I don't think anything can set the frame size before this | |
| 292 since we don't have X resources. This may change if we look | |
| 293 at the registry. Even so these values can get overridden | |
| 294 later.*/ | |
| 442 | 295 XEMACS_RECT_WH dest = { -1, -1, DEFAULT_FRAME_WIDTH, |
| 428 | 296 DEFAULT_FRAME_HEIGHT }; |
| 297 mswindows_size_frame_internal (f, &dest); | |
| 298 } | |
| 299 } | |
| 300 | |
| 301 /* Called after frame's properties are set */ | |
| 302 static void | |
| 303 mswindows_init_frame_3 (struct frame *f) | |
| 304 { | |
| 4139 | 305 /* Don't do this earlier or we get a WM_PAINT before the frame is ready. */ |
| 306 ShowWindow (FRAME_MSWINDOWS_HANDLE(f), SW_SHOWNORMAL); | |
| 307 #ifdef CYGWIN | |
| 308 /* The SW_x parameter in the first call that an app makes to ShowWindow is | |
| 309 * ignored, and the parameter specified in the caller's STARTUPINFO is | |
| 310 * substituted instead. That parameter is SW_HIDE if we were started by | |
| 311 * runemacs, so call this twice. #### runemacs is evil. To see why this | |
| 312 * second call was restored, see the threads referenced by | |
| 313 * 20a807210611011157j57ea2b22ue892f4dfcb6aade8@mail.gmail.com and | |
| 314 * 20a807210708181345m7ac94ff2m43337be71e853d95@mail.gmail.com . */ | |
| 315 ShowWindow (FRAME_MSWINDOWS_HANDLE(f), SW_SHOWNORMAL); | |
| 316 #endif | |
| 317 SetForegroundWindow (FRAME_MSWINDOWS_HANDLE(f)); | |
| 318 DragAcceptFiles (FRAME_MSWINDOWS_HANDLE(f), TRUE); | |
| 428 | 319 } |
| 320 | |
| 321 static void | |
| 2286 | 322 mswindows_after_init_frame (struct frame *UNUSED (f), |
| 323 int UNUSED (first_on_device), int first_on_console) | |
| 428 | 324 { |
| 325 /* Windows, unlike X, is very synchronous. After the initial | |
| 442 | 326 frame is created, it will never be displayed, except for |
| 428 | 327 hollow border, unless we start pumping messages. Load progress |
| 328 messages show in the bottom of the hollow frame, which is ugly. | |
| 329 We redisplay the initial frame here, so modeline and root window | |
| 330 background show. | |
| 331 */ | |
| 332 if (first_on_console) | |
| 333 redisplay (); | |
| 334 } | |
| 335 | |
| 336 static void | |
| 337 mswindows_mark_frame (struct frame *f) | |
| 338 { | |
| 339 mark_object (FRAME_MSWINDOWS_MENU_HASH_TABLE (f)); | |
| 340 #ifdef HAVE_TOOLBARS | |
| 341 mark_object (FRAME_MSWINDOWS_TOOLBAR_HASH_TABLE (f)); | |
| 342 #endif | |
| 442 | 343 mark_object (FRAME_MSWINDOWS_WIDGET_HASH_TABLE1 (f)); |
| 344 mark_object (FRAME_MSWINDOWS_WIDGET_HASH_TABLE2 (f)); | |
| 345 mark_object (FRAME_MSWINDOWS_WIDGET_HASH_TABLE3 (f)); | |
| 428 | 346 } |
| 347 | |
| 348 static void | |
| 349 mswindows_focus_on_frame (struct frame *f) | |
| 350 { | |
| 771 | 351 SetForegroundWindow (FRAME_MSWINDOWS_HANDLE (f)); |
| 428 | 352 } |
| 353 | |
| 354 static void | |
| 355 mswindows_delete_frame (struct frame *f) | |
| 356 { | |
| 357 if (f->frame_data) | |
| 358 { | |
| 771 | 359 #ifdef HAVE_DIALOGS |
| 360 mswindows_unregister_popup_frame (wrap_frame (f)); | |
| 361 #endif | |
| 362 ReleaseDC (FRAME_MSWINDOWS_HANDLE (f), FRAME_MSWINDOWS_DC (f)); | |
| 363 DestroyWindow (FRAME_MSWINDOWS_HANDLE (f)); | |
| 4117 | 364 #ifndef NEW_GC |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4962
diff
changeset
|
365 xfree (f->frame_data); |
| 3092 | 366 #endif /* not NEW_GC */ |
| 428 | 367 } |
| 368 f->frame_data = 0; | |
| 369 } | |
| 370 | |
| 371 static void | |
| 372 mswindows_set_frame_size (struct frame *f, int width, int height) | |
| 373 { | |
| 374 RECT rect; | |
| 5043 | 375 int pwidth, pheight; |
| 376 | |
| 377 change_frame_size (f, width, height, 0); | |
| 378 frame_unit_to_pixel_size (f, width, height, &pwidth, &pheight); | |
| 1395 | 379 |
| 428 | 380 rect.left = rect.top = 0; |
| 5043 | 381 rect.right = pwidth; |
| 382 rect.bottom = pheight; | |
| 1395 | 383 |
| 1318 | 384 /* This can call Lisp, because it runs the window procedure, which can |
| 385 call redisplay() */ | |
| 428 | 386 AdjustWindowRectEx (&rect, |
| 771 | 387 qxeGetWindowLong (FRAME_MSWINDOWS_HANDLE (f), GWL_STYLE), |
| 388 GetMenu (FRAME_MSWINDOWS_HANDLE (f)) != NULL, | |
| 389 qxeGetWindowLong (FRAME_MSWINDOWS_HANDLE (f), GWL_EXSTYLE)); | |
| 428 | 390 |
| 2872 | 391 if (IsIconic (FRAME_MSWINDOWS_HANDLE (f))) |
| 771 | 392 ShowWindow (FRAME_MSWINDOWS_HANDLE (f), SW_RESTORE); |
| 428 | 393 |
| 771 | 394 SetWindowPos (FRAME_MSWINDOWS_HANDLE (f), NULL, |
| 428 | 395 0, 0, rect.right-rect.left, rect.bottom-rect.top, |
| 396 SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSENDCHANGING | SWP_NOMOVE); | |
| 397 } | |
| 398 | |
| 399 static void | |
| 400 mswindows_set_frame_position (struct frame *f, int xoff, int yoff) | |
| 401 { | |
| 771 | 402 SetWindowPos (FRAME_MSWINDOWS_HANDLE (f), NULL, |
| 428 | 403 xoff, yoff, 0, 0, |
| 404 SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSENDCHANGING | SWP_NOSIZE); | |
| 405 } | |
| 406 | |
| 407 static void | |
| 442 | 408 mswindows_make_frame_visible (struct frame *f) |
| 428 | 409 { |
| 771 | 410 if (!FRAME_VISIBLE_P (f)) |
| 411 ShowWindow (FRAME_MSWINDOWS_HANDLE (f), SW_RESTORE); | |
| 428 | 412 else |
| 771 | 413 ShowWindow (FRAME_MSWINDOWS_HANDLE (f), SW_SHOW); |
| 414 SetActiveWindow (FRAME_MSWINDOWS_HANDLE (f)); | |
| 428 | 415 f->visible = 1; |
| 416 f->iconified = 0; | |
| 417 } | |
| 418 | |
| 419 static void | |
| 442 | 420 mswindows_make_frame_invisible (struct frame *f) |
| 428 | 421 { |
| 771 | 422 if (!FRAME_VISIBLE_P (f)) |
| 428 | 423 return; |
| 424 | |
| 771 | 425 ShowWindow (FRAME_MSWINDOWS_HANDLE (f), SW_HIDE); |
| 428 | 426 f->visible = 0; |
| 427 } | |
| 428 | |
| 429 static int | |
| 430 mswindows_frame_totally_visible_p (struct frame *f) | |
| 431 { | |
| 432 RECT rc_me, rc_other, rc_temp; | |
| 771 | 433 HWND hwnd = FRAME_MSWINDOWS_HANDLE (f); |
| 428 | 434 |
| 435 /* We test against not a whole window rectangle, only against its | |
| 436 client part. So, if non-client are is covered and client area is | |
| 437 not, we return true. */ | |
| 438 GetClientRect (hwnd, &rc_me); | |
| 2367 | 439 MapWindowPoints (hwnd, HWND_DESKTOP, (LPPOINT) (void *) (&rc_me), 2); |
| 428 | 440 |
| 441 /* First see if we're off the desktop */ | |
| 771 | 442 GetWindowRect (GetDesktopWindow (), &rc_other); |
| 443 UnionRect (&rc_temp, &rc_me, &rc_other); | |
| 428 | 444 if (!EqualRect (&rc_temp, &rc_other)) |
| 445 return 0; | |
| 442 | 446 |
| 428 | 447 /* Then see if any window above us obscures us */ |
| 448 while ((hwnd = GetWindow (hwnd, GW_HWNDPREV)) != NULL) | |
| 449 if (IsWindowVisible (hwnd)) | |
| 450 { | |
| 451 GetWindowRect (hwnd, &rc_other); | |
| 771 | 452 if (IntersectRect (&rc_temp, &rc_me, &rc_other)) |
| 428 | 453 return 0; |
| 454 } | |
| 455 | |
| 456 return 1; | |
| 457 } | |
| 458 | |
| 459 static int | |
| 460 mswindows_frame_visible_p (struct frame *f) | |
| 461 { | |
| 771 | 462 return IsWindowVisible (FRAME_MSWINDOWS_HANDLE (f)) |
| 463 && !IsIconic (FRAME_MSWINDOWS_HANDLE (f)); | |
| 428 | 464 } |
| 465 | |
| 466 | |
| 467 static void | |
| 468 mswindows_iconify_frame (struct frame *f) | |
| 469 { | |
| 771 | 470 ShowWindow (FRAME_MSWINDOWS_HANDLE (f), SW_MINIMIZE); |
| 428 | 471 f->visible = 0; |
| 472 f->iconified = 1; | |
| 473 } | |
| 474 | |
| 475 static int | |
| 476 mswindows_frame_iconified_p (struct frame *f) | |
| 477 { | |
| 771 | 478 return IsIconic (FRAME_MSWINDOWS_HANDLE (f)); |
| 428 | 479 } |
| 480 | |
| 481 static void | |
| 482 mswindows_set_frame_icon (struct frame *f) | |
| 483 { | |
| 484 if (IMAGE_INSTANCEP (f->icon) | |
| 485 && IMAGE_INSTANCE_PIXMAP_TYPE_P (XIMAGE_INSTANCE (f->icon))) | |
| 486 { | |
| 487 if (!XIMAGE_INSTANCE_MSWINDOWS_ICON (f->icon)) | |
| 488 { | |
| 442 | 489 mswindows_initialize_image_instance_icon (XIMAGE_INSTANCE (f->icon), |
| 428 | 490 FALSE); |
| 491 } | |
| 442 | 492 |
| 771 | 493 qxeSetClassLong (FRAME_MSWINDOWS_HANDLE (f), GCL_HICON, |
| 494 (LONG) XIMAGE_INSTANCE_MSWINDOWS_ICON (f->icon)); | |
| 428 | 495 } |
| 496 } | |
| 497 | |
| 498 static void | |
| 499 mswindows_set_frame_pointer (struct frame *f) | |
| 500 { | |
| 501 if (IMAGE_INSTANCEP (f->pointer) | |
| 502 && IMAGE_INSTANCE_TYPE (XIMAGE_INSTANCE (f->pointer)) == IMAGE_POINTER) | |
| 503 { | |
| 771 | 504 qxeSetClassLong (FRAME_MSWINDOWS_HANDLE (f), GCL_HCURSOR, |
| 505 (LONG) XIMAGE_INSTANCE_MSWINDOWS_ICON (f->pointer)); | |
| 428 | 506 /* we only have to do this because GC doesn't cause a mouse |
| 507 event and doesn't give time to event processing even if it | |
| 508 did. */ | |
| 509 SetCursor (XIMAGE_INSTANCE_MSWINDOWS_ICON (f->pointer)); | |
| 510 } | |
| 511 } | |
| 512 | |
| 513 static void | |
| 514 mswindows_set_mouse_position (struct window *w, int x, int y) | |
| 515 { | |
| 516 struct frame *f = XFRAME (w->frame); | |
| 517 POINT pt; | |
| 518 | |
| 519 pt.x = w->pixel_left + x; | |
| 520 pt.y = w->pixel_top + y; | |
| 771 | 521 ClientToScreen (FRAME_MSWINDOWS_HANDLE (f), &pt); |
| 428 | 522 SetCursorPos (pt.x, pt.y); |
| 523 } | |
| 524 | |
| 525 static int | |
| 2286 | 526 mswindows_get_mouse_position (struct device *UNUSED (d), Lisp_Object *frame, |
| 527 int *x, int *y) | |
| 428 | 528 { |
| 529 POINT pt; | |
| 530 HWND hwnd; | |
| 531 | |
| 532 GetCursorPos (&pt); | |
| 533 | |
| 534 /* What's under cursor? */ | |
| 535 hwnd = WindowFromPoint (pt); | |
| 536 if (hwnd == NULL) | |
| 537 return 0; | |
| 538 | |
| 539 /* Get grandest parent of the window */ | |
| 540 { | |
| 541 HWND hwnd_parent; | |
| 542 while ((hwnd_parent = GetParent (hwnd)) != NULL) | |
| 543 hwnd = hwnd_parent; | |
| 544 } | |
| 545 | |
| 546 /* Make sure it belongs to us */ | |
| 547 if (GetWindowThreadProcessId (hwnd, NULL) != GetCurrentThreadId ()) | |
| 548 return 0; | |
| 549 | |
| 550 /* And that the window is an XEmacs frame */ | |
| 771 | 551 if (!mswindows_window_is_xemacs (hwnd)) |
| 552 return 0; | |
| 428 | 553 |
| 554 /* Yippie! */ | |
| 555 ScreenToClient (hwnd, &pt); | |
| 5013 | 556 *frame = GET_LISP_FROM_VOID ((void *) qxeGetWindowLong (hwnd, XWL_FRAMEOBJ)); |
| 428 | 557 *x = pt.x; |
| 558 *y = pt.y; | |
| 559 return 1; | |
| 560 } | |
| 561 | |
| 562 static void | |
| 563 mswindows_raise_frame (struct frame *f) | |
| 564 { | |
| 771 | 565 BringWindowToTop (FRAME_MSWINDOWS_HANDLE (f)); |
| 428 | 566 } |
| 567 | |
| 568 static void | |
| 569 mswindows_lower_frame (struct frame *f) | |
| 570 { | |
| 771 | 571 SetWindowPos (FRAME_MSWINDOWS_HANDLE (f), HWND_BOTTOM, 0, 0, 0, 0, |
| 428 | 572 SWP_NOSIZE | SWP_NOMOVE | SWP_NOSENDCHANGING); |
| 573 } | |
| 574 | |
| 575 static void | |
| 442 | 576 mswindows_enable_frame (struct frame *f) |
| 577 { | |
| 578 EnableWindow (FRAME_MSWINDOWS_HANDLE (f), TRUE); | |
| 579 } | |
| 580 | |
| 581 static void | |
| 582 mswindows_disable_frame (struct frame *f) | |
| 583 { | |
| 584 EnableWindow (FRAME_MSWINDOWS_HANDLE (f), FALSE); | |
| 585 } | |
| 586 | |
| 587 static void | |
| 867 | 588 mswindows_set_title_from_ibyte (struct frame *f, Ibyte *title) |
| 428 | 589 { |
| 771 | 590 unsigned int new_checksum = hash_string (title, qxestrlen (title)); |
| 593 | 591 if (new_checksum != FRAME_MSWINDOWS_TITLE_CHECKSUM (f)) |
| 428 | 592 { |
| 593 | 593 Extbyte *title_ext; |
| 594 | |
| 595 FRAME_MSWINDOWS_TITLE_CHECKSUM (f) = new_checksum; | |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4962
diff
changeset
|
596 title_ext = ITEXT_TO_TSTR (title); |
| 771 | 597 qxeSetWindowText (FRAME_MSWINDOWS_HANDLE (f), title_ext); |
| 428 | 598 } |
| 599 } | |
| 600 | |
| 601 static Lisp_Object | |
| 3022 | 602 mswindows_window_id (Lisp_Object frame) |
| 603 { | |
| 604 Ibyte str[255]; | |
| 605 struct frame *f = decode_mswindows_frame (frame); | |
| 606 | |
| 3023 | 607 qxesprintf (str, "%lu", (unsigned long) FRAME_MSWINDOWS_HANDLE (f)); |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4139
diff
changeset
|
608 return build_istring (str); |
| 3022 | 609 } |
| 610 | |
| 611 static Lisp_Object | |
| 428 | 612 mswindows_frame_property (struct frame *f, Lisp_Object property) |
| 613 { | |
| 614 if (EQ (Qleft, property) || EQ (Qtop, property)) | |
| 615 { | |
| 616 RECT rc; | |
| 771 | 617 GetWindowRect (FRAME_MSWINDOWS_HANDLE (f), &rc); |
| 428 | 618 return make_int (EQ (Qtop, property) ? rc.top : rc.left); |
| 619 } | |
| 3022 | 620 if (EQ (Qwindow_id, property)) |
| 621 return mswindows_window_id (wrap_frame (f)); | |
| 622 | |
| 428 | 623 return Qunbound; |
| 624 } | |
| 625 | |
| 626 static int | |
| 2286 | 627 mswindows_internal_frame_property_p (struct frame *UNUSED (f), |
| 628 Lisp_Object property) | |
| 428 | 629 { |
| 630 return EQ (property, Qleft) | |
| 3022 | 631 || EQ (property, Qtop) |
| 632 || EQ (property, Qwindow_id); | |
| 428 | 633 /* #### frame-x.c has also this. Why? |
| 634 || STRINGP (property); | |
| 635 */ | |
| 636 } | |
| 637 | |
| 638 static Lisp_Object | |
| 639 mswindows_frame_properties (struct frame *f) | |
| 640 { | |
| 641 Lisp_Object props = Qnil; | |
| 642 RECT rc; | |
| 771 | 643 GetWindowRect (FRAME_MSWINDOWS_HANDLE (f), &rc); |
| 428 | 644 |
| 645 props = cons3 (Qtop, make_int (rc.top), props); | |
| 646 props = cons3 (Qleft, make_int (rc.left), props); | |
| 3022 | 647 props = cons3 (Qwindow_id, mswindows_window_id (wrap_frame (f)), props); |
| 428 | 648 |
| 649 return props; | |
| 650 } | |
| 651 | |
| 652 static void | |
| 653 mswindows_set_frame_properties (struct frame *f, Lisp_Object plist) | |
| 654 { | |
| 655 int x=-1, y=-1; | |
| 656 int width = -1, height = -1; | |
| 657 BOOL width_specified_p = FALSE; | |
| 658 BOOL height_specified_p = FALSE; | |
| 659 BOOL x_specified_p = FALSE; | |
| 660 BOOL y_specified_p = FALSE; | |
| 661 Lisp_Object tail; | |
| 662 | |
| 663 /* Extract the properties from plist */ | |
| 664 for (tail = plist; !NILP (tail); tail = Fcdr (Fcdr (tail))) | |
| 665 { | |
| 666 Lisp_Object prop = Fcar (tail); | |
| 667 Lisp_Object val = Fcar (Fcdr (tail)); | |
| 668 | |
| 669 if (SYMBOLP (prop)) | |
| 670 { | |
| 671 /* Kludge to handle the font property. */ | |
| 672 if (EQ (prop, Qfont)) | |
| 673 { | |
| 674 /* If the value is not a string we silently ignore it. */ | |
| 675 if (STRINGP (val)) | |
| 676 { | |
| 677 Lisp_Object frm, font_spec; | |
| 442 | 678 |
| 793 | 679 frm = wrap_frame (f); |
| 428 | 680 font_spec = Fget (Fget_face (Qdefault), Qfont, Qnil); |
| 681 | |
| 682 Fadd_spec_to_specifier (font_spec, val, frm, Qnil, Qnil); | |
| 683 update_frame_face_values (f); | |
| 684 } | |
| 685 } | |
| 686 else if (EQ (prop, Qwidth)) | |
| 687 { | |
| 688 CHECK_INT (val); | |
| 689 width = XINT (val); | |
| 690 width_specified_p = TRUE; | |
| 691 } | |
| 692 else if (EQ (prop, Qheight)) | |
| 693 { | |
| 694 CHECK_INT (val); | |
| 695 height = XINT (val); | |
| 696 height_specified_p = TRUE; | |
| 697 } | |
| 698 else if (EQ (prop, Qleft)) | |
| 699 { | |
| 700 CHECK_INT (val); | |
| 701 x = XINT (val); | |
| 702 x_specified_p = TRUE; | |
| 703 } | |
| 704 else if (EQ (prop, Qtop)) | |
| 705 { | |
| 706 CHECK_INT (val); | |
| 707 y = XINT (val); | |
| 708 y_specified_p = TRUE; | |
| 709 } | |
| 710 } | |
| 711 } | |
| 712 | |
| 713 /* Now we've extracted the properties, apply them. | |
| 714 Do not apply geometric properties during frame creation. This | |
| 442 | 715 is excessive anyways, and this loses because WM_SIZE has not |
| 428 | 716 been sent yet, so frame width and height fields are not initialized. |
| 442 | 717 |
| 428 | 718 unfortunately WM_SIZE loses as well since the resize is only |
| 719 applied once and the first time WM_SIZE is applied not everything | |
| 720 is initialised in the frame (toolbars for instance). enabling | |
| 721 this always makes no visible difference and fixes a whole host of | |
| 722 bugs (and is more consistent with X) so I am going to reenable it. | |
| 723 --andyp */ | |
| 724 if ( FRAME_PIXWIDTH (f) && FRAME_PIXHEIGHT (f) | |
| 440 | 725 && (width_specified_p || height_specified_p |
| 726 || x_specified_p || y_specified_p)) | |
| 428 | 727 { |
| 728 XEMACS_RECT_WH dest = { x, y, width, height }; | |
| 729 | |
| 730 mswindows_size_frame_internal (f, &dest); | |
| 731 } | |
| 732 } | |
| 733 | |
| 506 | 734 void |
| 771 | 735 mswindows_size_frame_internal (struct frame *f, XEMACS_RECT_WH *dest) |
| 428 | 736 { |
| 442 | 737 RECT rect, ws_rect; |
| 428 | 738 int pixel_width, pixel_height; |
| 739 int size_p = (dest->width >=0 || dest->height >=0); | |
| 740 int move_p = (dest->top >=0 || dest->left >=0); | |
| 5043 | 741 char_to_pixel_size (f, dest->width, dest->height, &pixel_width, |
| 506 | 742 &pixel_height); |
| 442 | 743 |
| 428 | 744 if (dest->width < 0) |
| 745 pixel_width = FRAME_PIXWIDTH (f); | |
| 746 if (dest->height < 0) | |
| 747 pixel_height = FRAME_PIXHEIGHT (f); | |
| 748 | |
| 771 | 749 GetWindowRect (FRAME_MSWINDOWS_HANDLE (f), &rect); |
| 428 | 750 if (dest->left < 0) |
| 751 dest->left = rect.left; | |
| 752 if (dest->top < 0) | |
| 753 dest->top = rect.top; | |
| 442 | 754 |
| 428 | 755 rect.left = rect.top = 0; |
| 756 rect.right = pixel_width; | |
| 757 rect.bottom = pixel_height; | |
| 758 | |
| 759 AdjustWindowRectEx (&rect, | |
| 771 | 760 qxeGetWindowLong (FRAME_MSWINDOWS_HANDLE (f), GWL_STYLE), |
| 761 GetMenu (FRAME_MSWINDOWS_HANDLE (f)) != NULL, | |
| 762 qxeGetWindowLong (FRAME_MSWINDOWS_HANDLE (f), GWL_EXSTYLE)); | |
| 428 | 763 |
| 442 | 764 /* resize and move the window so that it fits in the workspace. This is |
| 428 | 765 not restrictive since this will happen later anyway in WM_SIZE. We |
| 766 have to do this after adjusting the rect to account for menubar | |
| 767 etc. */ | |
| 442 | 768 mswindows_get_workspace_coords (&ws_rect); |
| 428 | 769 pixel_width = rect.right - rect.left; |
| 770 pixel_height = rect.bottom - rect.top; | |
| 442 | 771 if (pixel_width > ws_rect.right - ws_rect.left) |
| 428 | 772 { |
| 442 | 773 pixel_width = ws_rect.right - ws_rect.left; |
| 428 | 774 size_p=1; |
| 775 } | |
| 442 | 776 if (pixel_height > ws_rect.bottom - ws_rect.top) |
| 428 | 777 { |
| 442 | 778 pixel_height = ws_rect.bottom - ws_rect.top; |
| 428 | 779 size_p=1; |
| 780 } | |
| 781 | |
| 442 | 782 /* adjust position so window is in workspace */ |
| 783 if (dest->left + pixel_width > ws_rect.right) | |
| 428 | 784 { |
| 442 | 785 dest->left = ws_rect.right - pixel_width; |
| 428 | 786 move_p=1; |
| 787 } | |
| 442 | 788 if (dest->left < ws_rect.left) |
| 428 | 789 { |
| 442 | 790 dest->left = ws_rect.left; |
| 428 | 791 move_p=1; |
| 792 } | |
| 793 | |
| 442 | 794 if (dest->top + pixel_height > ws_rect.bottom) |
| 795 { | |
| 796 dest->top = ws_rect.bottom - pixel_height; | |
| 797 move_p=1; | |
| 798 } | |
| 799 if (dest->top < ws_rect.top) | |
| 800 { | |
| 801 dest->top = ws_rect.top; | |
| 802 move_p=1; | |
| 803 } | |
| 804 | |
| 771 | 805 if (IsIconic (FRAME_MSWINDOWS_HANDLE (f)) |
| 806 || IsZoomed (FRAME_MSWINDOWS_HANDLE (f))) | |
| 807 ShowWindow (FRAME_MSWINDOWS_HANDLE (f), SW_RESTORE); | |
| 428 | 808 |
| 771 | 809 SetWindowPos (FRAME_MSWINDOWS_HANDLE (f), NULL, |
| 428 | 810 dest->left, dest->top, pixel_width, pixel_height, |
| 811 SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSENDCHANGING | |
| 812 | (size_p ? 0 : SWP_NOSIZE) | |
| 813 | (move_p ? 0 : SWP_NOMOVE)); | |
| 814 } | |
| 815 | |
| 816 static Lisp_Object | |
| 817 mswindows_get_frame_parent (struct frame *f) | |
| 818 { | |
| 771 | 819 HWND hwnd = FRAME_MSWINDOWS_HANDLE (f); |
| 428 | 820 hwnd = GetParent (hwnd); |
| 821 if (hwnd) | |
| 822 { | |
| 823 Lisp_Object parent; | |
| 5013 | 824 parent = GET_LISP_FROM_VOID ((void *) qxeGetWindowLong (hwnd, XWL_FRAMEOBJ)); |
| 428 | 825 assert (FRAME_MSWINDOWS_P (XFRAME (parent))); |
| 826 return parent; | |
| 827 } | |
| 828 else | |
| 829 return Qnil; | |
| 830 } | |
| 831 | |
| 832 static void | |
| 2286 | 833 mswindows_update_frame_external_traits (struct frame *UNUSED (frm), |
| 834 Lisp_Object UNUSED (name)) | |
| 428 | 835 { |
| 836 } | |
| 837 | |
| 838 static int | |
| 839 mswindows_frame_size_fixed_p (struct frame *f) | |
| 840 { | |
| 841 /* Frame size cannot change if the frame is maximized */ | |
| 842 return IsZoomed (FRAME_MSWINDOWS_HANDLE (f)); | |
| 843 } | |
| 844 | |
| 440 | 845 /*---------------------------------------------------------------------*/ |
| 846 /*----- PRINTER FRAME -----*/ | |
| 847 /*---------------------------------------------------------------------*/ | |
| 848 | |
| 442 | 849 /* |
| 850 * With some driver/os combination (I discovered this with HP drivers | |
| 851 * under W2K), DC geometry is reset upon StartDoc and EndPage | |
| 852 * calls. This is called every time one of these calls is made. | |
| 853 */ | |
| 854 static void | |
| 855 apply_dc_geometry (struct frame* f) | |
| 856 { | |
| 857 HDC hdc = DEVICE_MSPRINTER_HDC (XDEVICE (FRAME_DEVICE (f))); | |
| 858 SetTextAlign (hdc, TA_BASELINE | TA_LEFT | TA_NOUPDATECP); | |
| 859 SetViewportOrgEx (hdc, FRAME_MSPRINTER_PIXLEFT(f), | |
| 860 FRAME_MSPRINTER_PIXTOP(f), NULL); | |
| 861 } | |
| 862 | |
| 863 void | |
| 864 msprinter_start_page (struct frame *f) | |
| 865 { | |
| 866 if (!FRAME_MSPRINTER_PAGE_STARTED (f)) | |
| 867 { | |
| 868 FRAME_MSPRINTER_PAGE_STARTED (f) = 1; | |
| 869 StartPage (DEVICE_MSPRINTER_HDC (XDEVICE (FRAME_DEVICE (f)))); | |
| 870 apply_dc_geometry (f); | |
| 871 } | |
| 872 } | |
| 440 | 873 |
| 874 static void | |
| 875 error_frame_unsizable (struct frame *f) | |
| 876 { | |
| 793 | 877 Lisp_Object frame = wrap_frame (f); |
| 878 | |
| 442 | 879 invalid_change ("Cannot resize frame (margins) after print job has started.", |
| 880 frame); | |
| 440 | 881 } |
| 882 | |
| 883 static void | |
| 884 maybe_error_if_job_active (struct frame *f) | |
| 885 { | |
| 886 if (FRAME_MSPRINTER_JOB_STARTED (f)) | |
| 887 error_frame_unsizable (f); | |
| 888 } | |
| 889 | |
| 890 static void | |
| 2286 | 891 msprinter_init_frame_1 (struct frame *f, Lisp_Object UNUSED (props), |
| 892 int UNUSED (frame_name_is_defaulted)) | |
| 440 | 893 { |
| 894 /* Make sure this is the only frame on device. Windows printer can | |
| 895 handle only one job at a time. */ | |
| 896 if (!NILP (DEVICE_FRAME_LIST (XDEVICE (FRAME_DEVICE (f))))) | |
| 442 | 897 invalid_operation ("Only one frame (print job) at a time is allowed on " |
| 898 "this printer device", FRAME_DEVICE (f)); | |
| 440 | 899 |
| 900 f->frame_data = xnew_and_zero (struct msprinter_frame); | |
| 901 | |
| 506 | 902 FRAME_MSPRINTER_TOP_MARGIN (f) = |
| 903 mswindows_get_default_margin (Qtop_margin); | |
| 904 FRAME_MSPRINTER_BOTTOM_MARGIN (f) = | |
| 905 mswindows_get_default_margin (Qbottom_margin); | |
| 906 FRAME_MSPRINTER_LEFT_MARGIN (f) = | |
| 907 mswindows_get_default_margin (Qleft_margin); | |
| 908 FRAME_MSPRINTER_RIGHT_MARGIN (f) = | |
| 909 mswindows_get_default_margin (Qright_margin); | |
| 440 | 910 |
| 911 /* Negative for "uinspecified" */ | |
| 506 | 912 FRAME_MSPRINTER_CHARWIDTH (f) = -1; |
| 913 FRAME_MSPRINTER_CHARHEIGHT (f) = -1; | |
| 440 | 914 } |
| 915 | |
| 916 static void | |
| 917 msprinter_init_frame_3 (struct frame *f) | |
| 918 { | |
| 771 | 919 DOCINFOW di; |
| 440 | 920 struct device *device = XDEVICE (FRAME_DEVICE (f)); |
| 921 int frame_left, frame_top, frame_width, frame_height; | |
| 903 | 922 |
| 442 | 923 /* DC might be recreated in msprinter_apply_devmode, |
| 924 so do not initialize until now */ | |
| 903 | 925 HDC hdc = DEVICE_MSPRINTER_HDC (device); |
| 926 int logpixelsx = GetDeviceCaps (hdc, LOGPIXELSX); | |
| 927 int logpixelsy = GetDeviceCaps (hdc, LOGPIXELSY); | |
| 928 int physicaloffsetx = GetDeviceCaps (hdc, PHYSICALOFFSETX); | |
| 929 int physicaloffsety = GetDeviceCaps (hdc, PHYSICALOFFSETY); | |
| 930 int physicalheight = GetDeviceCaps (hdc, PHYSICALHEIGHT); | |
| 931 int physicalwidth = GetDeviceCaps (hdc, PHYSICALWIDTH); | |
| 440 | 932 |
| 903 | 933 /* Compute geometry properties. |
| 934 Conversion is from TWIPS -> inches -> pixels. */ | |
| 935 frame_left = MulDiv (logpixelsx, FRAME_MSPRINTER_LEFT_MARGIN(f), 1440) | |
| 936 - physicaloffsetx; | |
| 937 | |
| 771 | 938 if (FRAME_MSPRINTER_CHARWIDTH (f) > 0) |
| 440 | 939 { |
| 5043 | 940 char_to_pixel_size (f, FRAME_MSPRINTER_CHARWIDTH (f), 0, |
| 440 | 941 &frame_width, NULL); |
| 903 | 942 FRAME_MSPRINTER_RIGHT_MARGIN(f) = |
| 943 MulDiv (physicalwidth - (frame_left + frame_width), 1440, | |
| 944 logpixelsx); | |
| 442 | 945 } |
| 440 | 946 else |
| 903 | 947 frame_width = physicalwidth - frame_left |
| 948 - MulDiv (logpixelsx, FRAME_MSPRINTER_RIGHT_MARGIN(f), 1440) | |
| 949 - physicaloffsetx; | |
| 440 | 950 |
| 903 | 951 frame_top = MulDiv (logpixelsy, FRAME_MSPRINTER_TOP_MARGIN(f), 1440) |
| 952 - physicaloffsety; | |
| 440 | 953 |
| 771 | 954 if (FRAME_MSPRINTER_CHARHEIGHT (f) > 0) |
| 440 | 955 { |
| 5043 | 956 char_to_pixel_size (f, 0, FRAME_MSPRINTER_CHARHEIGHT (f), |
| 440 | 957 NULL, &frame_height); |
| 958 | |
| 903 | 959 FRAME_MSPRINTER_BOTTOM_MARGIN(f) = |
| 960 MulDiv (physicalheight - (frame_top + frame_height), 1440, | |
| 961 logpixelsy); | |
| 442 | 962 } |
| 440 | 963 else |
| 903 | 964 frame_height = physicalheight - frame_top |
| 965 - MulDiv (logpixelsy, FRAME_MSPRINTER_BOTTOM_MARGIN(f), 1440) | |
| 966 - physicaloffsety; | |
| 440 | 967 |
| 968 /* Geometry sanity checks */ | |
| 969 if (!frame_pixsize_valid_p (f, frame_width, frame_height)) | |
| 442 | 970 invalid_operation ("Area inside print margins has shrunk to naught", |
| 971 STRINGP (f->name) ? f->name : Qunbound); | |
| 440 | 972 |
| 973 if (frame_left < 0 | |
| 974 || frame_top < 0 | |
| 975 || frame_left + frame_width > GetDeviceCaps (hdc, HORZRES) | |
| 976 || frame_top + frame_height > GetDeviceCaps (hdc, VERTRES)) | |
| 546 | 977 invalid_operation ("Print area is outside of the printer's " |
| 442 | 978 "hardware printable area", |
| 979 STRINGP (f->name) ? f->name : Qunbound); | |
| 440 | 980 |
| 981 /* Apply XEmacs frame geometry and layout windows */ | |
| 982 { | |
| 983 int rows, columns; | |
| 771 | 984 FRAME_PIXWIDTH (f) = frame_width; |
| 985 FRAME_PIXHEIGHT (f) = frame_height; | |
| 5043 | 986 pixel_to_frame_unit_size (f, frame_width, frame_height, &columns, &rows); |
| 987 change_frame_size (f, columns, rows, 0); | |
| 440 | 988 } |
| 989 | |
| 442 | 990 FRAME_MSPRINTER_PIXLEFT(f) = frame_left; |
| 991 FRAME_MSPRINTER_PIXTOP(f) = frame_top; | |
| 440 | 992 |
| 993 /* Start print job */ | |
| 994 di.cbSize = sizeof (di); | |
| 771 | 995 { |
| 996 const Extbyte *nameext; | |
| 997 | |
| 998 if (STRINGP (f->name)) | |
|
4981
4aebb0131297
Cleanups/renaming of EXTERNAL_TO_C_STRING and friends
Ben Wing <ben@xemacs.org>
parents:
4962
diff
changeset
|
999 nameext = LISP_STRING_TO_TSTR (f->name); |
| 771 | 1000 else |
| 1001 nameext = XETEXT ("XEmacs print document"); | |
| 1002 di.lpszDocName = (XELPTSTR) nameext; | |
| 1003 } | |
| 440 | 1004 di.lpszOutput = NULL; |
| 1005 di.lpszDatatype = NULL; | |
| 1006 di.fwType = 0; | |
| 1007 | |
| 771 | 1008 if (qxeStartDoc (hdc, &di) <= 0) |
| 442 | 1009 invalid_operation ("Cannot start print job", |
| 1010 STRINGP (f->name) ? f->name : Qunbound); | |
| 1011 | |
| 1012 apply_dc_geometry (f); | |
| 440 | 1013 |
| 1014 /* Finish frame setup */ | |
| 1015 FRAME_MSPRINTER_JOB_STARTED (f) = 1; | |
| 771 | 1016 FRAME_VISIBLE_P (f) = 0; |
| 440 | 1017 } |
| 1018 | |
| 1019 static void | |
| 2286 | 1020 msprinter_mark_frame (struct frame *UNUSED (f)) |
| 440 | 1021 { |
| 1022 } | |
| 1023 | |
| 1024 static void | |
| 1025 msprinter_delete_frame (struct frame *f) | |
| 1026 { | |
| 1027 if (f->frame_data) | |
| 1028 { | |
| 442 | 1029 HDC hdc = DEVICE_MSPRINTER_HDC (XDEVICE (FRAME_DEVICE (f))); |
| 1030 if (FRAME_MSPRINTER_PAGE_STARTED (f)) | |
| 1031 EndPage (hdc); | |
| 440 | 1032 if (FRAME_MSPRINTER_JOB_STARTED (f)) |
| 442 | 1033 EndDoc (hdc); |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4962
diff
changeset
|
1034 xfree (f->frame_data); |
| 440 | 1035 } |
| 1036 | |
| 1037 f->frame_data = 0; | |
| 1038 } | |
| 1039 | |
| 1040 static Lisp_Object | |
| 1041 msprinter_frame_property (struct frame *f, Lisp_Object property) | |
| 1042 { | |
| 1043 if (EQ (Qleft_margin, property)) | |
| 771 | 1044 return make_int (FRAME_MSPRINTER_LEFT_MARGIN (f)); |
| 440 | 1045 else if (EQ (Qtop_margin, property)) |
| 771 | 1046 return make_int (FRAME_MSPRINTER_TOP_MARGIN (f)); |
| 440 | 1047 if (EQ (Qright_margin, property)) |
| 771 | 1048 return make_int (FRAME_MSPRINTER_RIGHT_MARGIN (f)); |
| 440 | 1049 else if (EQ (Qbottom_margin, property)) |
| 771 | 1050 return make_int (FRAME_MSPRINTER_BOTTOM_MARGIN (f)); |
| 440 | 1051 else |
| 1052 return Qunbound; | |
| 1053 } | |
| 1054 | |
| 1055 static int | |
| 2286 | 1056 msprinter_internal_frame_property_p (struct frame *UNUSED (f), |
| 1057 Lisp_Object property) | |
| 440 | 1058 { |
| 1059 return (EQ (Qleft_margin, property) || EQ (Qtop_margin, property) || | |
| 442 | 1060 EQ (Qright_margin, property) || EQ (Qbottom_margin, property)); |
| 440 | 1061 } |
| 1062 | |
| 1063 static Lisp_Object | |
| 1064 msprinter_frame_properties (struct frame *f) | |
| 1065 { | |
| 1066 Lisp_Object props = Qnil; | |
| 1067 props = cons3 (Qbottom_margin, | |
| 771 | 1068 make_int (FRAME_MSPRINTER_BOTTOM_MARGIN (f)), props); |
| 440 | 1069 props = cons3 (Qright_margin, |
| 771 | 1070 make_int (FRAME_MSPRINTER_RIGHT_MARGIN (f)), props); |
| 440 | 1071 props = cons3 (Qtop_margin, |
| 771 | 1072 make_int (FRAME_MSPRINTER_TOP_MARGIN (f)), props); |
| 440 | 1073 props = cons3 (Qleft_margin, |
| 771 | 1074 make_int (FRAME_MSPRINTER_LEFT_MARGIN (f)), props); |
| 440 | 1075 return props; |
| 1076 } | |
| 1077 | |
| 1078 static void | |
| 1079 msprinter_set_frame_properties (struct frame *f, Lisp_Object plist) | |
| 1080 { | |
| 1081 Lisp_Object tail; | |
| 1082 | |
| 1083 /* Extract the properties from plist */ | |
| 1084 for (tail = plist; !NILP (tail); tail = Fcdr (Fcdr (tail))) | |
| 1085 { | |
| 1086 Lisp_Object prop = Fcar (tail); | |
| 1087 Lisp_Object val = Fcar (Fcdr (tail)); | |
| 1088 | |
| 1089 if (SYMBOLP (prop)) | |
| 1090 { | |
| 1091 if (EQ (prop, Qwidth)) | |
| 1092 { | |
| 1093 maybe_error_if_job_active (f); | |
| 1094 if (!NILP (val)) | |
| 1095 { | |
| 1096 CHECK_NATNUM (val); | |
| 771 | 1097 FRAME_MSPRINTER_CHARWIDTH (f) = XINT (val); |
| 440 | 1098 } |
| 1099 } | |
| 1100 if (EQ (prop, Qheight)) | |
| 1101 { | |
| 1102 maybe_error_if_job_active (f); | |
| 1103 if (!NILP (val)) | |
| 1104 { | |
| 1105 CHECK_NATNUM (val); | |
| 771 | 1106 FRAME_MSPRINTER_CHARHEIGHT (f) = XINT (val); |
| 440 | 1107 } |
| 1108 } | |
| 1109 else if (EQ (prop, Qleft_margin)) | |
| 1110 { | |
| 1111 maybe_error_if_job_active (f); | |
| 1112 CHECK_NATNUM (val); | |
| 771 | 1113 FRAME_MSPRINTER_LEFT_MARGIN (f) = XINT (val); |
| 440 | 1114 } |
| 1115 else if (EQ (prop, Qtop_margin)) | |
| 1116 { | |
| 1117 maybe_error_if_job_active (f); | |
| 1118 CHECK_NATNUM (val); | |
| 771 | 1119 FRAME_MSPRINTER_TOP_MARGIN (f) = XINT (val); |
| 440 | 1120 } |
| 1121 else if (EQ (prop, Qright_margin)) | |
| 1122 { | |
| 1123 maybe_error_if_job_active (f); | |
| 1124 CHECK_NATNUM (val); | |
| 771 | 1125 FRAME_MSPRINTER_RIGHT_MARGIN (f) = XINT (val); |
| 440 | 1126 } |
| 1127 else if (EQ (prop, Qbottom_margin)) | |
| 1128 { | |
| 1129 maybe_error_if_job_active (f); | |
| 1130 CHECK_NATNUM (val); | |
| 771 | 1131 FRAME_MSPRINTER_BOTTOM_MARGIN (f) = XINT (val); |
| 440 | 1132 } |
| 1133 } | |
| 1134 } | |
| 1135 } | |
| 1136 | |
| 1137 static void | |
| 2286 | 1138 msprinter_set_frame_size (struct frame *f, int UNUSED (width), |
| 1139 int UNUSED (height)) | |
| 440 | 1140 { |
| 1141 /* We're absolutely unsizeable */ | |
| 1142 error_frame_unsizable (f); | |
| 1143 } | |
| 1144 | |
| 442 | 1145 static void |
| 1146 msprinter_eject_page (struct frame *f) | |
| 1147 { | |
| 1148 /* #### Should we eject empty pages? */ | |
| 1149 if (FRAME_MSPRINTER_PAGE_STARTED (f)) | |
| 1150 { | |
| 1151 FRAME_MSPRINTER_PAGE_STARTED (f) = 0; | |
| 1152 EndPage (DEVICE_MSPRINTER_HDC (XDEVICE (FRAME_DEVICE (f)))); | |
| 1153 apply_dc_geometry (f); | |
| 1154 } | |
| 1155 } | |
| 1156 | |
| 1157 | |
| 428 | 1158 void |
| 1159 console_type_create_frame_mswindows (void) | |
| 1160 { | |
| 440 | 1161 /* Display frames */ |
| 428 | 1162 CONSOLE_HAS_METHOD (mswindows, init_frame_1); |
| 442 | 1163 CONSOLE_HAS_METHOD (mswindows, init_frame_2); |
| 428 | 1164 CONSOLE_HAS_METHOD (mswindows, init_frame_3); |
| 1165 CONSOLE_HAS_METHOD (mswindows, after_init_frame); | |
| 1166 CONSOLE_HAS_METHOD (mswindows, mark_frame); | |
| 1167 CONSOLE_HAS_METHOD (mswindows, focus_on_frame); | |
| 1168 CONSOLE_HAS_METHOD (mswindows, delete_frame); | |
| 1169 CONSOLE_HAS_METHOD (mswindows, get_mouse_position); | |
| 1170 CONSOLE_HAS_METHOD (mswindows, set_mouse_position); | |
| 1171 CONSOLE_HAS_METHOD (mswindows, raise_frame); | |
| 1172 CONSOLE_HAS_METHOD (mswindows, lower_frame); | |
| 442 | 1173 CONSOLE_HAS_METHOD (mswindows, enable_frame); |
| 1174 CONSOLE_HAS_METHOD (mswindows, disable_frame); | |
| 428 | 1175 CONSOLE_HAS_METHOD (mswindows, make_frame_visible); |
| 1176 CONSOLE_HAS_METHOD (mswindows, make_frame_invisible); | |
| 1177 CONSOLE_HAS_METHOD (mswindows, iconify_frame); | |
| 1178 CONSOLE_HAS_METHOD (mswindows, set_frame_size); | |
| 1179 CONSOLE_HAS_METHOD (mswindows, set_frame_position); | |
| 1180 CONSOLE_HAS_METHOD (mswindows, frame_property); | |
| 1181 CONSOLE_HAS_METHOD (mswindows, internal_frame_property_p); | |
| 1182 CONSOLE_HAS_METHOD (mswindows, frame_properties); | |
| 1183 CONSOLE_HAS_METHOD (mswindows, set_frame_properties); | |
| 867 | 1184 CONSOLE_HAS_METHOD (mswindows, set_title_from_ibyte); |
| 1185 /* CONSOLE_HAS_METHOD (mswindows, set_icon_name_from_ibyte); */ | |
| 428 | 1186 CONSOLE_HAS_METHOD (mswindows, frame_visible_p); |
| 1187 CONSOLE_HAS_METHOD (mswindows, frame_totally_visible_p); | |
| 1188 CONSOLE_HAS_METHOD (mswindows, frame_iconified_p); | |
| 442 | 1189 CONSOLE_HAS_METHOD (mswindows, set_frame_pointer); |
| 1190 CONSOLE_HAS_METHOD (mswindows, set_frame_icon); | |
| 428 | 1191 CONSOLE_HAS_METHOD (mswindows, get_frame_parent); |
| 1192 CONSOLE_HAS_METHOD (mswindows, update_frame_external_traits); | |
| 1193 CONSOLE_HAS_METHOD (mswindows, frame_size_fixed_p); | |
| 440 | 1194 |
| 1195 /* Printer frames, aka print jobs */ | |
| 1196 CONSOLE_HAS_METHOD (msprinter, init_frame_1); | |
| 1197 CONSOLE_HAS_METHOD (msprinter, init_frame_3); | |
| 1198 CONSOLE_HAS_METHOD (msprinter, mark_frame); | |
| 1199 CONSOLE_HAS_METHOD (msprinter, delete_frame); | |
| 1200 CONSOLE_HAS_METHOD (msprinter, frame_property); | |
| 1201 CONSOLE_HAS_METHOD (msprinter, internal_frame_property_p); | |
| 1202 CONSOLE_HAS_METHOD (msprinter, frame_properties); | |
| 1203 CONSOLE_HAS_METHOD (msprinter, set_frame_properties); | |
| 1204 CONSOLE_HAS_METHOD (msprinter, set_frame_size); | |
| 442 | 1205 CONSOLE_HAS_METHOD (msprinter, eject_page); |
| 428 | 1206 } |
| 1207 | |
| 1208 void | |
| 1209 syms_of_frame_mswindows (void) | |
| 1210 { | |
| 3092 | 1211 #ifdef NEW_GC |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
parents:
4139
diff
changeset
|
1212 INIT_LISP_OBJECT (mswindows_frame); |
| 3092 | 1213 #endif /* NEW_GC */ |
| 428 | 1214 } |
| 1215 | |
| 1216 void | |
| 1217 reinit_vars_of_frame_mswindows (void) | |
| 1218 { | |
| 1219 /* Needn't staticpro -- see comment above. */ | |
| 1220 Vmswindows_frame_being_created = Qnil; | |
| 1221 } | |
| 1222 | |
| 1223 void | |
| 1224 vars_of_frame_mswindows (void) | |
| 1225 { | |
| 1226 DEFVAR_LISP ("mswindows-use-system-frame-size-defaults", &Vmswindows_use_system_frame_size_defaults /* | |
| 1227 Controls whether to use system or XEmacs defaults for frame size. | |
| 442 | 1228 If nil then reasonable defaults are used for initial frame sizes. If t |
| 428 | 1229 then the system will choose default sizes for the frame. |
| 1230 */ ); | |
| 1231 Vmswindows_use_system_frame_size_defaults = Qnil; | |
| 442 | 1232 |
| 428 | 1233 DEFVAR_LISP ("default-mswindows-frame-plist", &Vdefault_mswindows_frame_plist /* |
| 1234 Plist of default frame-creation properties for mswindows frames. | |
| 1235 These override what is specified in `default-frame-plist', but are | |
| 1236 overridden by the arguments to the particular call to `make-frame'. | |
| 1237 | |
| 1238 Note: In many cases, properties of a frame are available as specifiers | |
| 1239 instead of through the frame-properties mechanism. | |
| 1240 | |
| 1241 Here is a list of recognized frame properties, other than those | |
| 1242 documented in `set-frame-properties' (they can be queried and | |
| 1243 set at any time, except as otherwise noted): | |
| 1244 | |
| 1245 initially-unmapped If non-nil, the frame will not be visible | |
| 1246 when it is created. In this case, you | |
| 1247 need to call `make-frame-visible' to make | |
| 1248 the frame appear. | |
| 1249 popup If non-nil, it should be a frame, and this | |
| 1250 frame will be created as a "popup" frame | |
| 1251 whose parent is the given frame. This | |
| 1252 will make the window manager treat the | |
| 1253 frame as a dialog box, which may entail | |
| 1254 doing different things (e.g. not asking | |
| 1255 for positioning, and not iconifying | |
| 1256 separate from its parent). | |
| 1257 top Y position (in pixels) of the upper-left | |
| 1258 outermost corner of the frame (i.e. the | |
| 1259 upper-left of the window-manager | |
| 1260 decorations). | |
| 1261 left X position (in pixels) of the upper-left | |
| 1262 outermost corner of the frame (i.e. the | |
| 1263 upper-left of the window-manager | |
| 1264 decorations). | |
| 3022 | 1265 window-id Window handle (HWND) of the frame. |
| 1266 Cannot be set. | |
| 428 | 1267 |
| 1268 See also `default-frame-plist', which specifies properties which apply | |
| 1269 to all frames, not just mswindows frames. | |
| 1270 */ ); | |
| 1271 Vdefault_mswindows_frame_plist = Qnil; | |
| 1272 | |
| 1273 mswindows_console_methods->device_specific_frame_props = | |
| 1274 &Vdefault_mswindows_frame_plist; | |
| 440 | 1275 |
| 1276 DEFVAR_LISP ("default-msprinter-frame-plist", &Vdefault_msprinter_frame_plist /* | |
| 1277 Plist of default frame-creation properties for msprinter print job frames. | |
| 1278 These override what is specified in `default-frame-plist', but are | |
| 1279 overridden by the arguments to the particular call to `make-frame'. | |
| 1280 | |
| 1281 Note: In many cases, properties of a frame are available as specifiers | |
| 1282 instead of through the frame-properties mechanism. | |
| 1283 | |
| 1284 Here is a list of recognized frame properties, other than those | |
| 1285 documented in `set-frame-properties' (they can be queried and | |
| 1286 set at any time, except as otherwise noted): | |
| 1287 | |
| 1288 left-margin Margin of the page, in twips. Twip is a | |
| 1289 top-margin typographical unit of measurement, | |
| 1290 right-margin equal to 1/1440 of an inch, or 1/20 of a | |
| 1291 bottom-margin point, and roughly equal to 7/400 of a | |
| 506 | 1292 millimeter. If not specified, the left |
| 1293 and right margins default to 1 inch | |
| 1294 (25.4 mm) and the top and bottom margins | |
| 1295 to 0.5 inch (12.7 mm). | |
| 440 | 1296 |
| 1297 MARGINS NOTE. right-margin and bottom-margin are overridden by | |
| 1298 the height and width properties. If you want to specify size | |
| 1299 of the printable area in character, as with the rest of XEmacs, | |
| 1300 use these properties. If height and/or width are nil, then | |
| 1301 corresponding margin setting is taken into account. If you | |
| 1302 specify height and/or width in `default-frame-plist', but still | |
| 1303 want to specify right/bottom margins, set height/width in this | |
| 1304 plist to nil, as in this example: | |
| 1305 | |
| 506 | 1306 (setq default-frame-plist '(height 55 width 80) |
| 1307 default-msprinter-frame-plist '(height nil width nil)) | |
| 440 | 1308 |
| 1309 See also `default-frame-plist', which specifies properties which apply | |
| 1310 to all frames, not just mswindows frames. | |
| 1311 */ ); | |
| 1312 Vdefault_msprinter_frame_plist = Qnil; | |
| 1313 | |
| 1314 msprinter_console_methods->device_specific_frame_props = | |
| 1315 &Vdefault_msprinter_frame_plist; | |
| 428 | 1316 } |