git.chise.org Git - chise/xemacs-chise.git.1/blob - src/console.h

   1 /* Define console object for XEmacs.
   2    Copyright (C) 1996 Ben Wing
   3
   4 This file is part of XEmacs.
   5
   6 XEmacs is free software; you can redistribute it and/or modify it
   7 under the terms of the GNU General Public License as published by the
   8 Free Software Foundation; either version 2, or (at your option) any
   9 later version.
  10
  11 XEmacs is distributed in the hope that it will be useful, but WITHOUT
  12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with XEmacs; see the file COPYING.  If not, write to
  18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21 /* Synched up with: Not in FSF. */
  22
  23 /* Written by Ben Wing. */
  24
  25 #ifndef INCLUDED_console_h_
  26 #define INCLUDED_console_h_
  27
  28 #include "character.h"
  29
  30 /* Devices and consoles are similar entities.  The idea is that
  31    a console represents a physical keyboard/mouse/other-input-source
  32    while a device represents a display where frames appear on.
  33    In the X world, a console is a "Display" while a device is a
  34    "Screen".  Implementationally, it can sometimes get confusing:
  35    under X, multiple devices on a single console are different
  36    "Display" connections to what is in reality the same Display on
  37    the same server.  Because of this, input comes from the device
  38    and not from the console.  This is OK because events are basically
  39    always tagged to a particular X window (i.e. frame),
  40    which exists on only one screen; therefore the event won't be
  41    reported multiple times even if there are multiple devices on
  42    the same physical display.  This is an implementation detail
  43    specific to X consoles (e.g. under NeXTstep or Windows, this
  44    could be different, and input would come directly from the console).
  45 */
  46
  47
  48 /* GCC does not like forward enum declaration. This needs to be
  49    defined here. What a disgust! */
  50
  51 enum device_metrics
  52 {
  53   DM_color_default, DM_color_select, DM_color_balloon, DM_color_3d_face,
  54   DM_color_3d_light, DM_color_3d_dark, DM_color_menu, DM_color_menu_highlight,
  55   DM_color_menu_button, DM_color_menu_disabled, DM_color_toolbar,
  56   DM_color_scrollbar, DM_color_desktop, DM_color_workspace, DM_font_default,
  57   DM_font_menubar, DM_font_dialog, DM_size_cursor, DM_size_scrollbar,
  58   DM_size_menu, DM_size_toolbar, DM_size_toolbar_button,
  59   DM_size_toolbar_border, DM_size_icon, DM_size_icon_small, DM_size_device,
  60   DM_size_workspace, DM_offset_workspace, DM_size_device_mm, DM_device_dpi,
  61   DM_num_bit_planes, DM_num_color_cells, DM_mouse_buttons, DM_swap_buttons,
  62   DM_show_sounds, DM_slow_device, DM_security
  63 };
  64
  65 extern const struct struct_description cted_description;
  66 extern const struct struct_description console_methods_description;
  67
  68
  69 /*
  70  * Constants returned by device_implementation_flags_method
  71  */
  72
  73 /* Set when device uses pixel-based geometry */
  74 #define XDEVIMPF_PIXEL_GEOMETRY         0x00000001L
  75
  76 /* Indicates that the device is a printer */
  77 #define XDEVIMPF_IS_A_PRINTER           0x00000002L
  78
  79 /* Do not automatically redisplay this device */
  80 #define XDEVIMPF_NO_AUTO_REDISPLAY      0x00000004L
  81
  82 /* Do not delete the device when last frame's gone */
  83 #define XDEVIMPF_FRAMELESS_OK           0x00000008L
  84
  85 /* Do not preempt resiaply of frame or device once it starts */
  86 #define XDEVIMPF_DONT_PREEMPT_REDISPLAY 0x00000010L
  87
  88 struct console_methods
  89 {
  90   const char *name;     /* Used by print_console, print_device, print_frame */
  91   Lisp_Object symbol;
  92   Lisp_Object predicate_symbol;
  93   unsigned int flags;   /* Read-only implementation flags, set once upon
  94                            console type creation. INITIALIZE_CONSOLE_TYPE sets
  95                            this member to 0. */
  96
  97   /* console methods */
  98   void (*init_console_method) (struct console *, Lisp_Object props);
  99   void (*mark_console_method) (struct console *);
 100   int (*initially_selected_for_input_method) (struct console *);
 101   void (*delete_console_method) (struct console *);
 102   Lisp_Object (*semi_canonicalize_console_connection_method)
 103     (Lisp_Object connection, Error_behavior errb);
 104   Lisp_Object (*semi_canonicalize_device_connection_method)
 105     (Lisp_Object connection, Error_behavior errb);
 106   Lisp_Object (*canonicalize_console_connection_method)
 107     (Lisp_Object connection, Error_behavior errb);
 108   Lisp_Object (*canonicalize_device_connection_method)
 109     (Lisp_Object connection, Error_behavior errb);
 110   Lisp_Object (*device_to_console_connection_method)
 111     (Lisp_Object connection, Error_behavior errb);
 112
 113   /* device methods */
 114   void (*init_device_method) (struct device *, Lisp_Object props);
 115   void (*finish_init_device_method) (struct device *, Lisp_Object props);
 116   void (*delete_device_method) (struct device *);
 117   void (*mark_device_method) (struct device *);
 118   void (*asynch_device_change_method) (void);
 119   Lisp_Object (*device_system_metrics_method) (struct device *,
 120                                                enum device_metrics);
 121   Lisp_Object (*own_selection_method)(Lisp_Object selection_name,
 122                                       Lisp_Object selection_value,
 123                                       Lisp_Object how_to_add,
 124                                       Lisp_Object selection_type,
 125                           int owned_p);
 126   void (*disown_selection_method)(Lisp_Object selection_name,
 127                                   Lisp_Object timeval);
 128   Lisp_Object (*get_foreign_selection_method) (Lisp_Object selection_symbol,
 129                                                Lisp_Object target_type);
 130   Lisp_Object (*selection_exists_p_method)(Lisp_Object selection_name,
 131                                            Lisp_Object selection_type);
 132   Lisp_Object (*available_selection_types_method)(Lisp_Object selection_name);
 133   Lisp_Object (*register_selection_data_type_method)(Lisp_Object type_name);
 134   Lisp_Object (*selection_data_type_name_method)(Lisp_Object type);
 135
 136   /* frame methods */
 137   Lisp_Object *device_specific_frame_props;
 138   void (*init_frame_1_method) (struct frame *, Lisp_Object properties);
 139   void (*init_frame_2_method) (struct frame *, Lisp_Object properties);
 140   void (*init_frame_3_method) (struct frame *);
 141   void (*after_init_frame_method) (struct frame *, int first_on_device,
 142                                    int first_on_console);
 143   void (*mark_frame_method) (struct frame *);
 144   void (*delete_frame_method) (struct frame *);
 145   void (*focus_on_frame_method) (struct frame *);
 146   void (*raise_frame_method) (struct frame *);
 147   void (*lower_frame_method) (struct frame *);
 148   void (*enable_frame_method) (struct frame *);
 149   void (*disable_frame_method) (struct frame *);
 150   int (*get_mouse_position_method) (struct device *d, Lisp_Object *frame,
 151                                     int *x, int *y);
 152   void (*set_mouse_position_method) (struct window *w, int x, int y);
 153   void (*make_frame_visible_method) (struct frame *f);
 154   void (*make_frame_invisible_method) (struct frame *f);
 155   void (*iconify_frame_method) (struct frame *f);
 156   Lisp_Object (*frame_property_method) (struct frame *f, Lisp_Object prop);
 157   int (*internal_frame_property_p_method) (struct frame *f,
 158                                            Lisp_Object prop);
 159   Lisp_Object (*frame_properties_method) (struct frame *f);
 160   void (*set_frame_properties_method) (struct frame *f, Lisp_Object plist);
 161   void (*set_frame_size_method) (struct frame *f, int width, int height);
 162   void (*set_frame_position_method) (struct frame *f, int xoff, int yoff);
 163   int (*frame_visible_p_method) (struct frame *f);
 164   int (*frame_totally_visible_p_method) (struct frame *f);
 165   int (*frame_iconified_p_method) (struct frame *f);
 166   void (*set_title_from_bufbyte_method) (struct frame *f, Bufbyte *title);
 167   void (*set_icon_name_from_bufbyte_method) (struct frame *f, Bufbyte *title);
 168   void (*set_frame_pointer_method) (struct frame *f);
 169   void (*set_frame_icon_method) (struct frame *f);
 170   void (*popup_menu_method) (Lisp_Object menu, Lisp_Object event);
 171   Lisp_Object (*get_frame_parent_method) (struct frame *f);
 172   void (*update_frame_external_traits_method) (struct frame *f, Lisp_Object name);
 173   int (*frame_size_fixed_p_method) (struct frame *f);
 174   void (*eject_page_method) (struct frame *f);
 175
 176   /* redisplay methods */
 177   int (*left_margin_width_method) (struct window *);
 178   int (*right_margin_width_method) (struct window *);
 179   int (*text_width_method) (struct frame *f, struct face_cachel *cachel,
 180                             const Charc *str, Charcount len);
 181   void (*output_display_block_method) (struct window *, struct display_line *,
 182                                        int, int, int, int, int, int, int);
 183   int (*divider_height_method) (void);
 184   int (*eol_cursor_width_method) (void);
 185   void (*output_vertical_divider_method) (struct window *, int);
 186   void (*clear_to_window_end_method) (struct window *, int, int);
 187   void (*clear_region_method) (Lisp_Object, struct device*, struct frame*, face_index,
 188                                int, int, int, int,
 189                                Lisp_Object, Lisp_Object, Lisp_Object);
 190   void (*clear_frame_method) (struct frame *);
 191   void (*window_output_begin_method) (struct window *);
 192   void (*frame_output_begin_method) (struct frame *);
 193   void (*window_output_end_method) (struct window *);
 194   void (*frame_output_end_method) (struct frame *);
 195   int (*flash_method) (struct device *);
 196   void (*ring_bell_method) (struct device *, int volume, int pitch,
 197                             int duration);
 198   void (*frame_redraw_cursor_method) (struct frame *f);
 199   void (*set_final_cursor_coords_method) (struct frame *, int, int);
 200   void (*bevel_area_method) (struct window *, face_index, int, int, int, int, int,
 201                              int, enum edge_style);
 202   void (*output_pixmap_method) (struct window *w, Lisp_Object image_instance,
 203                                 struct display_box *db, struct display_glyph_area *dga,
 204                                 face_index findex, int cursor_start, int cursor_width,
 205                                 int cursor_height, int offset_bitmap);
 206   void (*output_string_method) (struct window *w, struct display_line *dl,
 207                                 Charc_dynarr *buf, int xpos, int xoffset,
 208                                 int start_pixpos, int width, face_index findex,
 209                                 int cursor, int cursor_start, int cursor_width,
 210                                 int cursor_height);
 211   /* color methods */
 212   int (*initialize_color_instance_method) (Lisp_Color_Instance *,
 213                                            Lisp_Object name,
 214                                            Lisp_Object device,
 215                                            Error_behavior errb);
 216   void (*mark_color_instance_method) (Lisp_Color_Instance *);
 217   void (*print_color_instance_method) (Lisp_Color_Instance *,
 218                                        Lisp_Object printcharfun,
 219                                        int escapeflag);
 220   void (*finalize_color_instance_method) (Lisp_Color_Instance *);
 221   int (*color_instance_equal_method) (Lisp_Color_Instance *,
 222                                       Lisp_Color_Instance *,
 223                                       int depth);
 224   unsigned long (*color_instance_hash_method) (Lisp_Color_Instance *,
 225                                                int depth);
 226   Lisp_Object (*color_instance_rgb_components_method) (Lisp_Color_Instance *);
 227   int (*valid_color_name_p_method) (struct device *, Lisp_Object color);
 228
 229   /* font methods */
 230   int (*initialize_font_instance_method) (Lisp_Font_Instance *,
 231                                           Lisp_Object name,
 232                                           Lisp_Object device,
 233                                           Error_behavior errb);
 234   void (*mark_font_instance_method) (Lisp_Font_Instance *);
 235   void (*print_font_instance_method) (Lisp_Font_Instance *,
 236                                       Lisp_Object printcharfun,
 237                                       int escapeflag);
 238   void (*finalize_font_instance_method) (Lisp_Font_Instance *);
 239   Lisp_Object (*font_instance_truename_method) (Lisp_Font_Instance *,
 240                                                 Error_behavior errb);
 241   Lisp_Object (*font_instance_properties_method) (Lisp_Font_Instance *);
 242   Lisp_Object (*list_fonts_method) (Lisp_Object pattern,
 243                                     Lisp_Object device);
 244   Lisp_Object (*find_charset_font_method) (Lisp_Object device,
 245                                            Lisp_Object font,
 246                                            Lisp_Object charset);
 247   int (*font_spec_matches_charset_method) (struct device *d,
 248                                            Lisp_Object charset,
 249                                            const Bufbyte *nonreloc,
 250                                            Lisp_Object reloc,
 251                                            Bytecount offset,
 252                                            Bytecount length);
 253
 254   /* image methods */
 255   void (*mark_image_instance_method) (Lisp_Image_Instance *);
 256   void (*print_image_instance_method) (Lisp_Image_Instance *,
 257                                        Lisp_Object printcharfun,
 258                                        int escapeflag);
 259   void (*finalize_image_instance_method) (Lisp_Image_Instance *);
 260   void (*unmap_subwindow_method) (Lisp_Image_Instance *);
 261   void (*map_subwindow_method) (Lisp_Image_Instance *, int x, int y,
 262                                 struct display_glyph_area* dga);
 263   void (*resize_subwindow_method) (Lisp_Image_Instance *, int w, int h);
 264   void (*redisplay_subwindow_method) (Lisp_Image_Instance *);
 265   void (*redisplay_widget_method) (Lisp_Image_Instance *);
 266   /* Maybe this should be a specifier. Unfortunately specifiers don't
 267      allow us to represent things at the toolkit level, which is what
 268      is required here. */
 269   int (*widget_border_width_method) (void);
 270   int (*widget_spacing_method) (Lisp_Image_Instance *);
 271   int (*image_instance_equal_method) (Lisp_Image_Instance *,
 272                                       Lisp_Image_Instance *,
 273                                       int depth);
 274   unsigned long (*image_instance_hash_method) (Lisp_Image_Instance *,
 275                                                int depth);
 276   void (*init_image_instance_from_eimage_method) (Lisp_Image_Instance *ii,
 277                                                   int width, int height,
 278                                                   int slices,
 279                                                   unsigned char *eimage,
 280                                                   int dest_mask,
 281                                                   Lisp_Object instantiator,
 282                                                   Lisp_Object domain);
 283   Lisp_Object (*locate_pixmap_file_method) (Lisp_Object file_method);
 284   int (*colorize_image_instance_method) (Lisp_Object image_instance,
 285                                          Lisp_Object fg, Lisp_Object bg);
 286   Lisp_Object image_conversion_list;
 287
 288 #ifdef HAVE_TOOLBARS
 289   /* toolbar methods */
 290   void (*output_frame_toolbars_method) (struct frame *);
 291   void (*clear_frame_toolbars_method) (struct frame *);
 292   void (*initialize_frame_toolbars_method) (struct frame *);
 293   void (*free_frame_toolbars_method) (struct frame *);
 294   void (*output_toolbar_button_method) (struct frame *, Lisp_Object);
 295   void (*redraw_frame_toolbars_method) (struct frame *);
 296   void (*redraw_exposed_toolbars_method) (struct frame *f, int x, int y,
 297                                           int width, int height);
 298 #endif
 299
 300 #ifdef HAVE_SCROLLBARS
 301   /* scrollbar methods */
 302   int (*inhibit_scrollbar_slider_size_change_method) (void);
 303   void (*free_scrollbar_instance_method) (struct scrollbar_instance *);
 304   void (*release_scrollbar_instance_method) (struct scrollbar_instance *);
 305   void (*create_scrollbar_instance_method) (struct frame *, int,
 306                                             struct scrollbar_instance *);
 307   void (*update_scrollbar_instance_values_method) (struct window *,
 308                                                    struct scrollbar_instance *,
 309                                                    int, int, int, int, int,
 310                                                    int, int, int, int, int);
 311   void (*update_scrollbar_instance_status_method) (struct window *, int, int,
 312                                                    struct
 313                                                    scrollbar_instance *);
 314   void (*scrollbar_pointer_changed_in_window_method) (struct window *w);
 315 #ifdef MEMORY_USAGE_STATS
 316   int (*compute_scrollbar_instance_usage_method) (struct device *,
 317                                                   struct scrollbar_instance *,
 318                                                   struct overhead_stats *);
 319 #endif
 320 #endif /* HAVE_SCROLLBARS */
 321
 322 #ifdef HAVE_MENUBARS
 323   /* menubar methods */
 324   void (*update_frame_menubars_method) (struct frame *);
 325   void (*free_frame_menubars_method) (struct frame *);
 326 #endif
 327
 328 #ifdef HAVE_DIALOGS
 329   /* dialog methods */
 330   Lisp_Object (*make_dialog_box_internal_method) (struct frame *,
 331                                                   Lisp_Object type,
 332                                                   Lisp_Object keys);
 333 #endif
 334 };
 335
 336 #define CONMETH_TYPE(meths) ((meths)->symbol)
 337 #define CONMETH_IMPL_FLAG(meths, f) ((meths)->flags & (f))
 338
 339 #define CONSOLE_TYPE_NAME(c) ((c)->conmeths->name)
 340 #define CONSOLE_TYPE(c) ((c)->conmeths->symbol)
 341 #define CONSOLE_IMPL_FLAG(c, f) CONMETH_IMPL_FLAG ((c)->conmeths, (f))
 342
 343 /******** Accessing / calling a console method *********/
 344
 345 #define HAS_CONTYPE_METH_P(meth, m) ((meth)->m##_method)
 346 #define CONTYPE_METH(meth, m, args) (((meth)->m##_method) args)
 347
 348 /* Call a void-returning console method, if it exists */
 349 #define MAYBE_CONTYPE_METH(meth, m, args) do {                  \
 350   struct console_methods *maybe_contype_meth_meth = (meth);     \
 351   if (HAS_CONTYPE_METH_P (maybe_contype_meth_meth, m))          \
 352     CONTYPE_METH (maybe_contype_meth_meth, m, args);            \
 353 } while (0)
 354
 355 /* Call a console method, if it exists; otherwise return
 356    the specified value - meth is multiply evaluated.  */
 357 #define CONTYPE_METH_OR_GIVEN(meth, m, args, given)     \
 358   (HAS_CONTYPE_METH_P (meth, m) ?                       \
 359    CONTYPE_METH (meth, m, args) : (given))
 360
 361 /* Call an int-returning console method, if it exists; otherwise
 362    return 0 */
 363 #define MAYBE_INT_CONTYPE_METH(meth, m, args) \
 364   CONTYPE_METH_OR_GIVEN (meth, m, args, 0)
 365
 366 /* Call an Lisp-Object-returning console method, if it exists;
 367    otherwise return Qnil */
 368 #define MAYBE_LISP_CONTYPE_METH(meth, m, args) \
 369   CONTYPE_METH_OR_GIVEN (meth, m, args, Qnil)
 370
 371 /******** Same functions, operating on a console instead of a
 372           struct console_methods ********/
 373
 374 #define HAS_CONMETH_P(c, m) HAS_CONTYPE_METH_P ((c)->conmeths, m)
 375 #define CONMETH(c, m, args) CONTYPE_METH ((c)->conmeths, m, args)
 376 #define MAYBE_CONMETH(c, m, args) MAYBE_CONTYPE_METH ((c)->conmeths, m, args)
 377 #define CONMETH_OR_GIVEN(c, m, args, given) \
 378   CONTYPE_METH_OR_GIVEN((c)->conmeths, m, args, given)
 379 #define MAYBE_INT_CONMETH(c, m, args) \
 380   MAYBE_INT_CONTYPE_METH ((c)->conmeths, m, args)
 381 #define MAYBE_LISP_CONMETH(c, m, args) \
 382   MAYBE_LISP_CONTYPE_METH ((c)->conmeths, m, args)
 383
 384 /******** Defining new console types ********/
 385
 386 typedef struct console_type_entry console_type_entry;
 387 struct console_type_entry
 388 {
 389   Lisp_Object symbol;
 390   struct console_methods *meths;
 391 };
 392
 393 #define DECLARE_CONSOLE_TYPE(type) \
 394 extern struct console_methods * type##_console_methods
 395
 396 #define DEFINE_CONSOLE_TYPE(type) \
 397 struct console_methods * type##_console_methods
 398
 399 #define INITIALIZE_CONSOLE_TYPE(type, obj_name, pred_sym) do {          \
 400     type##_console_methods = xnew_and_zero (struct console_methods);    \
 401     type##_console_methods->name = obj_name;                            \
 402     type##_console_methods->symbol = Q##type;                           \
 403     defsymbol_nodump (&type##_console_methods->predicate_symbol, pred_sym);     \
 404     add_entry_to_console_type_list (Q##type, type##_console_methods);   \
 405     type##_console_methods->image_conversion_list = Qnil;               \
 406     staticpro_nodump (&type##_console_methods->image_conversion_list);  \
 407     dump_add_root_struct_ptr (&type##_console_methods, &console_methods_description);   \
 408 } while (0)
 409
 410 #define REINITIALIZE_CONSOLE_TYPE(type) do {    \
 411     staticpro_nodump (&type##_console_methods->predicate_symbol);       \
 412     staticpro_nodump (&type##_console_methods->image_conversion_list);  \
 413 } while (0)
 414
 415
 416 /* Declare that console-type TYPE has method M; used in
 417    initialization routines */
 418 #define CONSOLE_HAS_METHOD(type, m) \
 419   (type##_console_methods->m##_method = type##_##m)
 420
 421 /* Declare that console-type TYPE inherits method M
 422    implementation from console-type FROMTYPE */
 423 #define CONSOLE_INHERITS_METHOD(type, fromtype, m) \
 424   (type##_console_methods->m##_method = fromtype##_##m)
 425
 426 /* Define console type implementation flags */
 427 #define CONSOLE_IMPLEMENTATION_FLAGS(type, flg) \
 428   (type##_console_methods->flags = flg)
 429
 430 struct console
 431 {
 432   struct lcrecord_header header;
 433
 434   /* Description of this console's methods.  */
 435   struct console_methods *conmeths;
 436
 437   /* A structure of auxiliary data specific to the console type.
 438      struct x_console is used for X window frames; defined in console-x.h
 439      struct tty_console is used to TTY's; defined in console-tty.h */
 440   void *console_data;
 441
 442   /* Character that causes a quit.  Normally C-g.
 443      #### Should be possible for this not to be ASCII. */
 444   int quit_char;
 445
 446   /* ----- begin partially-completed console localization of
 447            event loop ---- */
 448
 449   int local_var_flags;
 450
 451 #define MARKED_SLOT(x) Lisp_Object x
 452 #include "conslots.h"
 453 #undef MARKED_SLOT
 454
 455   /* Where to store the next keystroke of the macro.
 456      Index into con->kbd_macro_builder. */
 457   int kbd_macro_ptr;
 458
 459   /* The finalized section of the macro starts at kbd_macro_buffer and
 460      ends before this.  This is not the same as kbd_macro_pointer, because
 461      we advance this to kbd_macro_pointer when a key's command is complete.
 462      This way, the keystrokes for "end-kbd-macro" are not included in the
 463      macro.  */
 464   int kbd_macro_end;
 465
 466   /* ----- end partially-completed console localization of event loop ---- */
 467
 468   unsigned int input_enabled :1;
 469 };
 470
 471 DECLARE_LRECORD (console, struct console);
 472 #define XCONSOLE(x) XRECORD (x, console, struct console)
 473 #define XSETCONSOLE(x, p) XSETRECORD (x, p, console)
 474 #define CONSOLEP(x) RECORDP (x, console)
 475 #define CHECK_CONSOLE(x) CHECK_RECORD (x, console)
 476 #define CONCHECK_CONSOLE(x) CONCHECK_RECORD (x, console)
 477
 478 #define CHECK_LIVE_CONSOLE(x) do {                      \
 479   CHECK_CONSOLE (x);                                    \
 480   if (! CONSOLE_LIVE_P (XCONSOLE (x)))                  \
 481     dead_wrong_type_argument (Qconsole_live_p, (x));    \
 482 } while (0)
 483 #define CONCHECK_LIVE_CONSOLE(x) do {                   \
 484   CONCHECK_CONSOLE (x);                                 \
 485   if (! CONSOLE_LIVE_P (XCONSOLE (x)))                  \
 486     x = wrong_type_argument (Qconsole_live_p, (x));     \
 487 } while (0)
 488
 489 #define CONSOLE_TYPE_P(con, type) EQ (CONSOLE_TYPE (con), Q##type)
 490
 491 #ifdef ERROR_CHECK_TYPECHECK
 492 INLINE_HEADER struct console *
 493 error_check_console_type (struct console *con, Lisp_Object sym);
 494 INLINE_HEADER struct console *
 495 error_check_console_type (struct console *con, Lisp_Object sym)
 496 {
 497   assert (EQ (CONSOLE_TYPE (con), sym));
 498   return con;
 499 }
 500 # define CONSOLE_TYPE_DATA(con, type)                   \
 501   (*(struct type##_console **)                          \
 502    &(error_check_console_type (con, Q##type))->console_data)
 503 #else
 504 # define CONSOLE_TYPE_DATA(con, type)                   \
 505   (*(struct type##_console **) &((con)->console_data))
 506 #endif
 507
 508 #define CHECK_CONSOLE_TYPE(x, type) do {                \
 509   CHECK_CONSOLE (x);                                    \
 510   if (! CONSOLE_TYPE_P (XCONSOLE (x), type))            \
 511     dead_wrong_type_argument                            \
 512       (type##_console_methods->predicate_symbol, x);    \
 513 } while (0)
 514 #define CONCHECK_CONSOLE_TYPE(x, type) do {             \
 515   CONCHECK_CONSOLE (x);                                 \
 516   if (!(CONSOLEP (x) &&                                 \
 517         CONSOLE_TYPE_P (XCONSOLE (x), type)))           \
 518     x = wrong_type_argument                             \
 519       (type##_console_methods->predicate_symbol, x);    \
 520 } while (0)
 521
 522 /* #### These should be in the console-*.h files but there are
 523    too many places where the abstraction is broken.  Need to
 524    fix. */
 525
 526 #ifdef HAVE_GTK
 527 #define CONSOLE_TYPESYM_GTK_P(typesym) EQ (typesym, Qgtk)
 528 #else
 529 #define CONSOLE_TYPESYM_GTK_P(typesym) 0
 530 #endif
 531
 532 #ifdef HAVE_X_WINDOWS
 533 #define CONSOLE_TYPESYM_X_P(typesym) EQ (typesym, Qx)
 534 #else
 535 #define CONSOLE_TYPESYM_X_P(typesym) 0
 536 #endif
 537 #ifdef HAVE_TTY
 538 #define CONSOLE_TYPESYM_TTY_P(typesym) EQ (typesym, Qtty)
 539 #else
 540 #define CONSOLE_TYPESYM_TTY_P(typesym) 0
 541 #endif
 542 #ifdef HAVE_MS_WINDOWS
 543 #define CONSOLE_TYPESYM_MSWINDOWS_P(typesym) EQ (typesym, Qmswindows)
 544 #else
 545 #define CONSOLE_TYPESYM_MSWINDOWS_P(typesym) 0
 546 #endif
 547 #define CONSOLE_TYPESYM_STREAM_P(typesym) EQ (typesym, Qstream)
 548
 549 #define CONSOLE_TYPESYM_WIN_P(typesym) \
 550   (CONSOLE_TYPESYM_GTK_P (typesym) || CONSOLE_TYPESYM_X_P (typesym) || CONSOLE_TYPESYM_MSWINDOWS_P (typesym))
 551
 552 #define CONSOLE_X_P(con) CONSOLE_TYPESYM_X_P (CONSOLE_TYPE (con))
 553 #define CHECK_X_CONSOLE(z) CHECK_CONSOLE_TYPE (z, x)
 554 #define CONCHECK_X_CONSOLE(z) CONCHECK_CONSOLE_TYPE (z, x)
 555
 556 #define CONSOLE_GTK_P(con) CONSOLE_TYPESYM_GTK_P (CONSOLE_TYPE (con))
 557 #define CHECK_GTK_CONSOLE(z) CHECK_CONSOLE_TYPE (z, gtk)
 558 #define CONCHECK_GTK_CONSOLE(z) CONCHECK_CONSOLE_TYPE (z, gtk)
 559
 560 #define CONSOLE_TTY_P(con) CONSOLE_TYPESYM_TTY_P (CONSOLE_TYPE (con))
 561 #define CHECK_TTY_CONSOLE(z) CHECK_CONSOLE_TYPE (z, tty)
 562 #define CONCHECK_TTY_CONSOLE(z) CONCHECK_CONSOLE_TYPE (z, tty)
 563
 564 #define CONSOLE_MSWINDOWS_P(con) CONSOLE_TYPESYM_MSWINDOWS_P (CONSOLE_TYPE (con))
 565 #define CHECK_MSWINDOWS_CONSOLE(z) CHECK_CONSOLE_TYPE (z, mswindows)
 566 #define CONCHECK_MSWINDOWS_CONSOLE(z) CONCHECK_CONSOLE_TYPE (z, mswindows)
 567
 568 #define CONSOLE_STREAM_P(con) CONSOLE_TYPESYM_STREAM_P (CONSOLE_TYPE (con))
 569 #define CHECK_STREAM_CONSOLE(z) CHECK_CONSOLE_TYPE (z, stream)
 570 #define CONCHECK_STREAM_CONSOLE(z) CONCHECK_CONSOLE_TYPE (z, stream)
 571
 572 #define CONSOLE_WIN_P(con) CONSOLE_TYPESYM_WIN_P (CONSOLE_TYPE (con))
 573
 574 EXFUN (Fconsole_disable_input, 1);
 575 EXFUN (Fdelete_console, 2);
 576 EXFUN (Fselect_console, 1);
 577 EXFUN (Fselected_console, 0);
 578
 579 extern Lisp_Object Qcreate_console_hook, Qdelete_console_hook;
 580 extern Lisp_Object Vconsole_defaults, Vconsole_type_list, Vselected_console;
 581
 582 /* This structure marks which slots in a console have corresponding
 583    default values in console_defaults.
 584    Each such slot has a nonzero value in this structure.
 585    The value has only one nonzero bit.
 586
 587    When a console has its own local value for a slot,
 588    the bit for that slot (found in the same slot in this structure)
 589    is turned on in the console's local_var_flags slot.
 590
 591    If a slot in this structure is zero, then even though there may
 592    be a DEFVAR_CONSOLE_LOCAL for the slot, there is no default value for it;
 593    and the corresponding slot in console_defaults is not used.  */
 594
 595 extern struct console console_local_flags;
 596
 597 int valid_console_type_p (Lisp_Object type);
 598
 599 #define CONSOLE_LIVE_P(con) (!EQ (CONSOLE_TYPE (con), Qdead))
 600
 601 #define CONSOLE_NAME(con) ((con)->name)
 602 #define CONSOLE_CONNECTION(con) ((con)->connection)
 603 #define CONSOLE_CANON_CONNECTION(con) ((con)->canon_connection)
 604 #define CONSOLE_FUNCTION_KEY_MAP(con) ((con)->function_key_map)
 605 #define CONSOLE_DEVICE_LIST(con) ((con)->device_list)
 606 #define CONSOLE_SELECTED_DEVICE(con) ((con)->selected_device)
 607 #define CONSOLE_SELECTED_FRAME(con) \
 608   DEVICE_SELECTED_FRAME (XDEVICE ((con)->selected_device))
 609 #define CONSOLE_LAST_NONMINIBUF_FRAME(con) NON_LVALUE ((con)->last_nonminibuf_frame)
 610 #define CONSOLE_QUIT_CHAR(con) ((con)->quit_char)
 611
 612 #define CDFW_CONSOLE(obj)                               \
 613    (WINDOWP  (obj) ? WINDOW_CONSOLE (XWINDOW (obj))     \
 614  : (FRAMEP   (obj) ?  FRAME_CONSOLE (XFRAME  (obj))     \
 615  : (DEVICEP  (obj) ? DEVICE_CONSOLE (XDEVICE (obj))     \
 616  : (CONSOLEP (obj) ? obj                                \
 617  : Qnil))))
 618
 619 #define CONSOLE_LOOP(concons) LIST_LOOP (concons, Vconsole_list)
 620 #define CONSOLE_DEVICE_LOOP(devcons, con) \
 621   LIST_LOOP (devcons, CONSOLE_DEVICE_LIST (con))
 622
 623 DECLARE_CONSOLE_TYPE (dead);
 624 extern console_type_entry_dynarr *the_console_type_entry_dynarr;
 625
 626 Lisp_Object create_console (Lisp_Object name, Lisp_Object type,
 627                             Lisp_Object connection, Lisp_Object props);
 628 void select_console_1 (Lisp_Object);
 629 struct console *decode_console (Lisp_Object);
 630 Lisp_Object make_console (struct console *c);
 631 void add_entry_to_console_type_list (Lisp_Object symbol,
 632                                      struct console_methods *type);
 633 struct console_methods *decode_console_type (Lisp_Object type,
 634                                              Error_behavior errb);
 635 void delete_console_internal (struct console *con, int force,
 636                               int from_kill_emacs, int from_io_error);
 637 void io_error_delete_console (Lisp_Object console);
 638 void set_console_last_nonminibuf_frame (struct console *con,
 639                                         Lisp_Object frame);
 640
 641 #endif /* INCLUDED_console_h_ */