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

   1 /* Define device-object for XEmacs.
   2    Copyright (C) 1994, 1995 Board of Trustees, University of Illinois.
   3    Copyright (C) 1995 Ben Wing
   4    Copyright (C) 1995 Sun Microsystems
   5
   6 This file is part of XEmacs.
   7
   8 XEmacs is free software; you can redistribute it and/or modify it
   9 under the terms of the GNU General Public License as published by the
  10 Free Software Foundation; either version 2, or (at your option) any
  11 later version.
  12
  13 XEmacs is distributed in the hope that it will be useful, but WITHOUT
  14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with XEmacs; see the file COPYING.  If not, write to
  20 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  23 /* Synched up with: Not in FSF. */
  24
  25 /* Written by Chuck Thompson and Ben Wing. */
  26
  27 #ifndef INCLUDED_device_h_
  28 #define INCLUDED_device_h_
  29
  30 #include "console.h"
  31
  32 /* This should really be in redisplay.h but by putting it here we
  33    won't have to ensure that redisplay.h is always included before
  34    this file. */
  35 struct pixel_to_glyph_translation_cache
  36 {
  37   unsigned int valid :1;
  38   struct frame *frame;
  39   int low_x_coord, high_x_coord, col, obj_x;
  40   int low_y_coord, high_y_coord, row, obj_y;
  41   struct window *w;
  42   Bufpos bufpos;
  43   Bufpos closest;
  44   Charcount modeline_closest;
  45   Lisp_Object obj1, obj2;
  46   int retval;
  47 };
  48
  49 #define DEVICE_TYPE_NAME(d) ((d)->devmeths->name)
  50 #define DEVICE_TYPE(d) ((d)->devmeths->symbol)
  51 #define DEVICE_IMPL_FLAG(d, f) CONMETH_IMPL_FLAG ((d)->devmeths, (f))
  52 #define DEVICE_SPECIFIC_FRAME_PROPS(d) \
  53   ((d)->devmeths->device_specific_frame_props)
  54
  55 /******** Accessing / calling a device method *********/
  56
  57 #define HAS_DEVMETH_P(d, m) HAS_CONTYPE_METH_P ((d)->devmeths, m)
  58 #define DEVMETH(d, m, args) CONTYPE_METH ((d)->devmeths, m, args)
  59 #define MAYBE_DEVMETH(d, m, args) MAYBE_CONTYPE_METH ((d)->devmeths, m, args)
  60 #define DEVMETH_OR_GIVEN(d, m, args, given) \
  61   CONTYPE_METH_OR_GIVEN((d)->devmeths, m, args, given)
  62 #define MAYBE_INT_DEVMETH(d, m, args) \
  63   MAYBE_INT_CONTYPE_METH ((d)->devmeths, m, args)
  64 #define MAYBE_LISP_DEVMETH(d, m, args) \
  65   MAYBE_LISP_CONTYPE_METH ((d)->devmeths, m, args)
  66
  67 struct device
  68 {
  69   struct lcrecord_header header;
  70
  71   /* Methods for this device's console.  This can also be retrieved
  72      through device->console, but it's faster this way. */
  73   struct console_methods *devmeths;
  74
  75   /* Name of this device, for resourcing and printing purposes.
  76      If not explicitly given, it's initialized in a device-specific
  77      manner. */
  78   Lisp_Object name;
  79
  80   /* What this device is connected to */
  81   Lisp_Object connection;
  82
  83   /* A canonical name for the connection that is used to determine
  84      whether `make-device' is being called on an existing device. */
  85   Lisp_Object canon_connection;
  86
  87   /* List of frames on this device. */
  88   Lisp_Object frame_list;
  89
  90   /* The console this device is on. */
  91   Lisp_Object console;
  92
  93   /* Frame which is "currently selected".  This is what `selected-frame'
  94      returns and is the default frame for many operations.  This may
  95      not be the same as frame_with_focus; `select-frame' changes the
  96      selected_frame but not the frame_with_focus.  However, eventually
  97      either the two values will be the same, or frame_with_focus will
  98      be nil: right before waiting for an event, the focus is changed
  99      to point to the selected_frame if XEmacs currently has the focus
 100      on this device.  Note that frame_with_focus may be nil (none of the
 101      frames on this device have the window-system focus), but
 102      selected_frame will never be nil if there are any frames on
 103      the device. */
 104   Lisp_Object selected_frame;
 105   /* Frame that currently contains the window-manager focus, or none.
 106      Note that we've split frame_with_focus into two variables.
 107      frame_with_focus_real is the value we use most of the time,
 108      but frame_with_focus_for_hooks is used for running the select-frame-hook
 109      and deselect-frame-hook.  We do this because we split the focus handling
 110      into two parts: one part (deals with drawing the solid/box cursor)
 111      runs as soon as a focus event is received; the other (running the
 112      hooks) runs after any pending sit-for/sleep-for/accept-process-output
 113      calls are done. */
 114   Lisp_Object frame_with_focus_real;
 115   Lisp_Object frame_with_focus_for_hooks;
 116   /* If we have recently issued a request to change the focus as a
 117      result of select-frame having been called, the following variable
 118      records the frame we are trying to focus on.  The reason for this
 119      is that the window manager may not grant our request to change
 120      the focus (so we can't just change frame_with_focus), and we don't
 121      want to keep sending requests again and again to the window manager.
 122      This variable is reset whenever a focus-change event is seen. */
 123   Lisp_Object frame_that_ought_to_have_focus;
 124
 125   /* Color class of this device. */
 126   Lisp_Object device_class;
 127
 128   /* Alist of values for user-defined tags in this device. */
 129   Lisp_Object user_defined_tags;
 130
 131   /* Hash tables for device-specific objects (fonts, colors, etc).
 132      These are key-weak hash tables (or hash tables containing key-weak
 133      hash tables) so that they disappear when the key goes away. */
 134
 135   /* This is a simple key-weak hash table hashing color names to
 136      instances. */
 137   Lisp_Object color_instance_cache;
 138
 139   /* This is a simple key-weak hash table hashing font names to
 140      instances. */
 141   Lisp_Object font_instance_cache;
 142
 143 #ifdef MULE
 144   /* This is a bi-level cache, where the hash table in this slot here
 145      indexes charset objects to key-weak hash tables, which in turn
 146      index font names to more specific font names that match the
 147      given charset's registry.  This speeds up the horrendously
 148      slow XListFonts() operation that needs to be done in order
 149      to determine an appropriate font. */
 150   Lisp_Object charset_font_cache;
 151 #endif
 152
 153   /* This is a bi-level cache, where the hash table in this slot here
 154      indexes image-instance-type masks (there are currently 6
 155      image-instance types and thus 64 possible masks) to key-weak hash
 156      tables like the one for colors. */
 157   Lisp_Object image_instance_cache;
 158
 159   /* A structure of auxiliary data specific to the device type.
 160      struct x_device is used for X window frames; defined in console-x.h
 161      struct tty_device is used to TTY's; defined in console-tty.h */
 162   void *device_data;
 163
 164   /* redisplay flags */
 165   unsigned int buffers_changed :1;
 166   unsigned int clip_changed :1;
 167   unsigned int extents_changed :1;
 168   unsigned int faces_changed :1;
 169   unsigned int frame_changed :1;
 170   unsigned int frame_layout_changed :1; /* The layout of frame
 171                                            elements has changed. */
 172   unsigned int glyphs_changed :1;
 173   unsigned int subwindows_changed :1;
 174   unsigned int subwindows_state_changed :1;
 175   unsigned int icon_changed :1;
 176   unsigned int menubar_changed :1;
 177   unsigned int modeline_changed :1;
 178   unsigned int point_changed :1;
 179   unsigned int size_changed :1;
 180   unsigned int gutter_changed :1;
 181   unsigned int toolbar_changed :1;
 182   unsigned int windows_changed :1;
 183   unsigned int windows_structure_changed :1;
 184
 185   unsigned int locked :1;
 186
 187   /* Cache information about last pixel position translated to a
 188      glyph.  The law of locality applies very heavily here so caching
 189      the value leads to a significant win.  At the moment this is
 190      really X specific but once we have generic mouse support it won't
 191      be. */
 192   struct pixel_to_glyph_translation_cache pixel_to_glyph_cache;
 193
 194   /* Output baud rate of device; used for redisplay decisions.  */
 195   int baud_rate;
 196
 197   /* sound flags */
 198   unsigned int on_console_p :1;
 199   unsigned int connected_to_nas_p :1;
 200
 201
 202   /* File descriptors for input and output.  Much of the time
 203      (but not always) these will be the same.  For an X device,
 204      these both hold the file descriptor of the socket used
 205      to communicate with the X server.  For a TTY device, these
 206      may or may not be the same and point to the terminal that
 207      is used for I/O. */
 208   int infd, outfd;
 209
 210   /* infd and outfd are moved outside HAVE_UNIXOID_EVENT_LOOP conditionals,
 211      because Win32, presumably the first port which does not use select()
 212      polling, DOES have handles for a console device. -- kkm */
 213
 214 #ifdef HAVE_UNIXOID_EVENT_LOOP
 215   /* holds some data necessary for SIGIO control.  Perhaps this should
 216      be inside of device_data; but it is used for both TTY's and X
 217      device.  Perhaps it should be conditionalized on SIGIO; but
 218      this requires including syssignal.h and systty.h. */
 219   int old_fcntl_owner;
 220 #endif
 221 };
 222
 223 DECLARE_LRECORD (device, struct device);
 224 #define XDEVICE(x) XRECORD (x, device, struct device)
 225 #define XSETDEVICE(x, p) XSETRECORD (x, p, device)
 226 #define wrap_device(p) wrap_object (p)
 227 #define DEVICEP(x) RECORDP (x, device)
 228 #define CHECK_DEVICE(x) CHECK_RECORD (x, device)
 229 #define CONCHECK_DEVICE(x) CONCHECK_RECORD (x, device)
 230
 231 #define CHECK_LIVE_DEVICE(x) do {                       \
 232   CHECK_DEVICE (x);                                     \
 233   if (! DEVICE_LIVE_P (XDEVICE (x)))                    \
 234     dead_wrong_type_argument (Qdevice_live_p, (x));     \
 235 } while (0)
 236 #define CONCHECK_LIVE_DEVICE(x) do {                    \
 237   CONCHECK_DEVICE (x);                                  \
 238   if (! DEVICE_LIVE_P (XDEVICE (x)))                    \
 239     x = wrong_type_argument (Qdevice_live_p, (x));      \
 240 } while (0)
 241
 242 #define DEVICE_TYPE_P(d, type)  EQ (DEVICE_TYPE (d), Q##type)
 243
 244 #ifdef ERROR_CHECK_TYPECHECK
 245 INLINE_HEADER struct device *
 246 error_check_device_type (struct device *d, Lisp_Object sym);
 247 INLINE_HEADER struct device *
 248 error_check_device_type (struct device *d, Lisp_Object sym)
 249 {
 250   assert (EQ (DEVICE_TYPE (d), sym));
 251   return d;
 252 }
 253 # define DEVICE_TYPE_DATA(d, type)                      \
 254   ((struct type##_device *) error_check_device_type (d, Q##type)->device_data)
 255 #else
 256 # define DEVICE_TYPE_DATA(d, type)                      \
 257   ((struct type##_device *) (d)->device_data)
 258 #endif
 259
 260 #define CHECK_DEVICE_TYPE(x, type)                      \
 261   do {                                                  \
 262     CHECK_DEVICE (x);                                   \
 263     if (!(DEVICEP (x) && DEVICE_TYPE_P (XDEVICE (x),    \
 264                                          type)))        \
 265       dead_wrong_type_argument                          \
 266         (type##_console_methods->predicate_symbol, x);  \
 267   } while (0)
 268 #define CONCHECK_DEVICE_TYPE(x, type)                   \
 269   do {                                                  \
 270     CONCHECK_DEVICE (x);                                \
 271     if (!(DEVICEP (x) && DEVICE_TYPE_P (XDEVICE (x),    \
 272                                          type)))        \
 273       x = wrong_type_argument                           \
 274         (type##_console_methods->predicate_symbol, x);  \
 275   } while (0)
 276
 277 #define DEVICE_DISPLAY_P(dev)                           \
 278   (DEVICE_LIVE_P (dev) &&                               \
 279     !DEVICE_IMPL_FLAG (dev, XDEVIMPF_IS_A_PRINTER))
 280
 281 #define CHECK_DISPLAY_DEVICE(dev)                       \
 282   do {                                                  \
 283     CHECK_DEVICE (dev);                                 \
 284     if (!(DEVICEP (dev)                                 \
 285           && DEVICE_DISPLAY_P (XDEVICE (dev))))         \
 286       dead_wrong_type_argument (Qdisplay, dev);         \
 287   } while (0)
 288
 289 #define CONCHECK_DISPLAY_DEVICE(dev)                    \
 290   do {                                                  \
 291     CONCHECK_DEVICE (dev);                              \
 292     if (!(DEVICEP (dev)                                 \
 293           && DEVICE_DISPLAY_P (XDEVICE (dev))))         \
 294       wrong_type_argument (Qdisplay, dev);              \
 295   } while (0)
 296
 297 #define DEVICE_PRINTER_P(dev)                           \
 298   (DEVICE_LIVE_P (dev) && !DEVICE_DISPLAY_P (dev))
 299
 300 #define CHECK_PRINTER_DEVICE(dev)                       \
 301   do {                                                  \
 302     CHECK_DEVICE (dev);                                 \
 303     if (!(DEVICEP (dev)                                 \
 304           && DEVICE_PRINTER_P (XDEVICE (dev))))         \
 305       dead_wrong_type_argument (Qprinter, dev);         \
 306   } while (0)
 307
 308 #define CONCHECK_PRINTER_DEVICE(dev)                    \
 309   do {                                                  \
 310     CONCHECK_DEVICE (dev);                              \
 311     if (!(DEVICEP (dev)                                 \
 312           && DEVICE_PRINTER_P (XDEVICE (dev))))         \
 313       wrong_type_argument (Qprinter, dev);              \
 314   } while (0)
 315
 316 /* #### These should be in the device-*.h files but there are
 317    too many places where the abstraction is broken.  Need to
 318    fix. */
 319
 320 #define DEVICE_X_P(dev) CONSOLE_TYPESYM_X_P (DEVICE_TYPE (dev))
 321 #define CHECK_X_DEVICE(z) CHECK_DEVICE_TYPE (z, x)
 322 #define CONCHECK_X_DEVICE(z) CONCHECK_DEVICE_TYPE (z, x)
 323
 324 #define DEVICE_GTK_P(dev) CONSOLE_TYPESYM_GTK_P (DEVICE_TYPE (dev))
 325 #define CHECK_GTK_DEVICE(z) CHECK_DEVICE_TYPE (z, gtk)
 326 #define CONCHECK_GTK_DEVICE(z) CONCHECK_DEVICE_TYPE (z, gtk)
 327
 328 #define DEVICE_MSWINDOWS_P(dev) CONSOLE_TYPESYM_MSWINDOWS_P (DEVICE_TYPE (dev))
 329 #define CHECK_MSWINDOWS_DEVICE(z) CHECK_DEVICE_TYPE (z, mswindows)
 330 #define CONCHECK_MSWINDOWS_DEVICE(z) CONCHECK_DEVICE_TYPE (z, mswindows)
 331
 332 #define DEVICE_TTY_P(dev) CONSOLE_TYPESYM_TTY_P (DEVICE_TYPE (dev))
 333 #define CHECK_TTY_DEVICE(z) CHECK_DEVICE_TYPE (z, tty)
 334 #define CONCHECK_TTY_DEVICE(z) CONCHECK_DEVICE_TYPE (z, tty)
 335
 336 #define DEVICE_STREAM_P(dev) CONSOLE_TYPESYM_STREAM_P (DEVICE_TYPE (dev))
 337 #define CHECK_STREAM_DEVICE(z) CHECK_DEVICE_TYPE (z, stream)
 338 #define CONCHECK_STREAM_DEVICE(z) CONCHECK_DEVICE_TYPE (z, stream)
 339
 340 #define DEVICE_WIN_P(dev) CONSOLE_TYPESYM_WIN_P (DEVICE_TYPE (dev))
 341
 342 EXFUN (Fdevice_console, 1);
 343 EXFUN (Fdevice_name, 1);
 344 EXFUN (Ffind_device, 2);
 345 EXFUN (Fmake_device, 3);
 346 EXFUN (Fselected_device, 1);
 347
 348 extern Lisp_Object Qcreate_device_hook, Qdelete_device_hook, Qgrayscale;
 349 extern Lisp_Object Qinit_post_tty_win, Qmono, Vdefault_x_device, Vdefault_gtk_device;
 350 extern Lisp_Object Vdevice_class_list;
 351
 352 int valid_device_class_p (Lisp_Object class);
 353
 354 #define DEVICE_LIVE_P(d) (!EQ (DEVICE_TYPE (d), Qdead))
 355
 356 #define DEVICE_REDISPLAY_INFO(d) ((d)->redisplay_info)
 357
 358 #define DEVICE_NAME(d) ((d)->name)
 359 #define DEVICE_CLASS(d) ((d)->device_class)
 360 /* Catch people attempting to set this. */
 361 #define DEVICE_SELECTED_FRAME(d) NON_LVALUE ((d)->selected_frame)
 362 #define DEVICE_FRAME_WITH_FOCUS_REAL(d) ((d)->frame_with_focus_real)
 363 #define DEVICE_FRAME_WITH_FOCUS_FOR_HOOKS(d) ((d)->frame_with_focus_for_hooks)
 364 #define DEVICE_FRAME_THAT_OUGHT_TO_HAVE_FOCUS(d)                        \
 365   ((d)->frame_that_ought_to_have_focus)
 366 #define DEVICE_USER_DEFINED_TAGS(d) ((d)->user_defined_tags)
 367 #define DEVICE_FRAME_LIST(d) ((d)->frame_list)
 368 #define DEVICE_CONNECTION(d) ((d)->connection)
 369 #define DEVICE_CANON_CONNECTION(d) ((d)->canon_connection)
 370 #define DEVICE_CONSOLE(d) ((d)->console)
 371 #define DEVICE_BAUD_RATE(d) ((d)->baud_rate)
 372 #define DEVICE_INFD(d) ((d)->infd)
 373 #define DEVICE_OUTFD(d) ((d)->outfd)
 374 #define DEVICE_OLD_FCNTL_OWNER(d) ((d)->old_fcntl_owner)
 375 #define DEVICE_ON_CONSOLE_P(d) ((d)->on_console_p)
 376 #define DEVICE_CONNECTED_TO_NAS_P(d) ((d)->connected_to_nas_p)
 377
 378 #define LOCK_DEVICE(d) ((void) ((d)->locked = 1))
 379 #define UNLOCK_DEVICE(d) ((void) ((d)->locked = 0))
 380
 381 #define INVALIDATE_DEVICE_PIXEL_TO_GLYPH_CACHE(d)                       \
 382   ((void) ((d)->pixel_to_glyph_cache.valid = 0))
 383
 384 #define INVALIDATE_PIXEL_TO_GLYPH_CACHE do {                                    \
 385   Lisp_Object IPTGC_devcons, IPTGC_concons;                                     \
 386   DEVICE_LOOP_NO_BREAK (IPTGC_devcons, IPTGC_concons)                           \
 387     INVALIDATE_DEVICE_PIXEL_TO_GLYPH_CACHE (XDEVICE (XCAR (IPTGC_devcons)));    \
 388 } while (0)
 389
 390 #define MARK_DEVICE_FACES_CHANGED(d)                    \
 391   ((void) (faces_changed = (d)->faces_changed = 1))
 392
 393 #define MARK_DEVICE_GLYPHS_CHANGED(d)                   \
 394   ((void) (glyphs_changed = (d)->glyphs_changed = 1))
 395
 396 #define MARK_DEVICE_SUBWINDOWS_CHANGED(d)                       \
 397   ((void) (subwindows_changed = (d)->subwindows_changed = 1))
 398
 399 #define MARK_DEVICE_SUBWINDOWS_STATE_CHANGED(d)         \
 400   ((void) (subwindows_state_changed = (d)->subwindows_state_changed = 1))
 401
 402 #define MARK_DEVICE_TOOLBARS_CHANGED(d)                 \
 403   ((void) (toolbar_changed = (d)->toolbar_changed = 1))
 404
 405 #define MARK_DEVICE_GUTTERS_CHANGED(d)          \
 406   ((void) (gutter_changed = (d)->gutter_changed = 1))
 407
 408 #define MARK_DEVICE_SIZE_CHANGED(d)                     \
 409   ((void) (size_changed = (d)->size_changed = 1))
 410
 411 #define MARK_DEVICE_FRAMES_FACES_CHANGED(d) do {        \
 412   struct device *mdffc_d = (d);                         \
 413   Lisp_Object frmcons;                                  \
 414   DEVICE_FRAME_LOOP (frmcons, mdffc_d)                  \
 415     XFRAME (XCAR (frmcons))->faces_changed = 1;         \
 416   MARK_DEVICE_FACES_CHANGED (mdffc_d);                  \
 417 } while (0)
 418
 419 #define MARK_DEVICE_FRAMES_GLYPHS_CHANGED(d) do {       \
 420   struct device *mdffc_d = (d);                         \
 421   Lisp_Object frmcons;                                  \
 422   DEVICE_FRAME_LOOP (frmcons, mdffc_d)                  \
 423     XFRAME (XCAR (frmcons))->glyphs_changed = 1;                \
 424   MARK_DEVICE_GLYPHS_CHANGED (mdffc_d);         \
 425 } while (0)
 426
 427 #define MARK_DEVICE_FRAME_CHANGED(d)                    \
 428   ((void) (frame_changed = (d)->frame_changed = 1))
 429
 430 #define MARK_DEVICE_FRAME_LAYOUT_CHANGED(d)                     \
 431   ((void) (frame_layout_changed = (d)->frame_layout_changed = 1))
 432
 433 #define MARK_DEVICE_WINDOWS_CHANGED(d)                  \
 434   ((void) (windows_changed = (d)->windows_changed = 1))
 435
 436 #define MARK_DEVICE_WINDOWS_STRUCTURE_CHANGED(d)        \
 437   ((void) (windows_structure_changed = (d)->windows_structure_changed = 1))
 438
 439 /* #### unify this with DOMAIN_DEVICE once the latter has image instances
 440    expunged from it. */
 441 /* This turns out to be used heavily so we make it a macro to make it
 442    inline.  Also, the majority of the time the object will turn out to
 443    be a window so we move it from being checked last to being checked
 444    first. */
 445 #define DFW_DEVICE(obj)                                 \
 446    (WINDOWP (obj) ? WINDOW_DEVICE (XWINDOW (obj))       \
 447  : (FRAMEP  (obj) ? FRAME_DEVICE (XFRAME (obj))         \
 448  : (DEVICEP (obj) ? obj                                 \
 449  : Qnil)))
 450
 451 /* NO_BREAK means that "break" doesn't do what you think it does!
 452    Use goto instead.  "continue" is OK, though. */
 453 #define DEVICE_LOOP_NO_BREAK(devcons, concons)                  \
 454   CONSOLE_LOOP (concons)                                        \
 455     CONSOLE_DEVICE_LOOP (devcons, XCONSOLE (XCAR (concons)))
 456 #define DEVICE_FRAME_LOOP(frmcons, d) \
 457   LIST_LOOP (frmcons, DEVICE_FRAME_LIST (d))
 458 #define CONSOLE_FRAME_LOOP_NO_BREAK(frmcons, devcons, con) \
 459   CONSOLE_DEVICE_LOOP (devcons, con)                       \
 460     DEVICE_FRAME_LOOP (frmcons, XDEVICE (XCAR (devcons)))
 461
 462 void select_device_1 (Lisp_Object);
 463 struct device *decode_device (Lisp_Object);
 464 void handle_asynch_device_change (void);
 465 void call_critical_lisp_code (struct device *d, Lisp_Object function,
 466                               Lisp_Object object);
 467 void delete_device_internal (struct device *d, int force,
 468                              int called_from_delete_console,
 469                              int from_io_error);
 470 void io_error_delete_device (Lisp_Object device);
 471 Lisp_Object find_nonminibuffer_frame_not_on_device (Lisp_Object device);
 472 void set_device_selected_frame (struct device *d, Lisp_Object frame);
 473 Lisp_Object domain_device_type (Lisp_Object domain);
 474 int window_system_pixelated_geometry (Lisp_Object domain);
 475
 476 #endif /* INCLUDED_device_h_ */