PageRenderTime 52ms CodeModel.GetById 18ms app.highlight 15ms RepoModel.GetById 1ms app.codeStats 1ms

/src/wrappers/gdk/library/gdk_screen.e

http://github.com/tybor/Liberty
Specman e | 916 lines | 141 code | 291 blank | 484 comment | 2 complexity | 1a80e260d6dd01f02e29e0d5c1e2ea0d MD5 | raw file
  1indexing
  2	description: "GdkScreen -- Object representing a physical screen."
  3	copyright: "[
  4					Copyright (C) 2006 Paolo Redaelli, GTK+ team
  5					
  6					This library is free software; you can redistribute it and/or
  7					modify it under the terms of the GNU Lesser General Public License
  8					as published by the Free Software Foundation; either version 2.1 of
  9					the License, or (at your option) any later version.
 10					
 11					This library is distributed in the hopeOA that it will be useful, but
 12					WITHOUT ANY WARRANTY; without even the implied warranty of
 13					MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 14					Lesser General Public License for more details.
 15
 16					You should have received a copy of the GNU Lesser General Public
 17					License along with this library; if not, write to the Free Software
 18					Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 19					02110-1301 USA
 20			]"
 21
 22			-- GdkScreen objects are the GDK representation of a physical
 23			-- screen. It is used throughout GDK and GTK+ to specify
 24			-- which screen the top level windows are to be displayed
 25			-- on. It is also used to query the screen specification and
 26			-- default settings such as the default colormap
 27			-- (`default_colormap'), the screen width (`width'), etc.
 28			
 29			-- Note that a screen may consist of multiple monitors which
 30			-- are merged to form a large screen area.
 31
 32class GDK_SCREEN
 33
 34inherit G_OBJECT 
 35
 36insert
 37	EXCEPTIONS
 38		undefine copy, is_equal end
 39	
 40creation make, from_external_pointer
 41
 42feature {} -- Creation
 43	make is
 44			-- the default screen for the default display. (See
 45			-- `GDK_DISPLAY.default')
 46		
 47			-- Note: if there is no default display then a
 48			-- "NoDefaultDisplay" exception is raised.
 49		do
 50			from_external_pointer(gdk_screen_get_default)
 51		end
 52
 53feature
 54	--	default_colormap: GDK_COLORMAP is
 55			-- the default colormap for screen.
 56-- 		do
 57-- 			create Result.from_external_pointer
 58-- 			(gdk_screen_get_default_colormap(handle))
 59-- 		end
 60
 61-- 	set_default_colormap (a_colormap: GDK_COLORMAP)
 62
 63--  void        gdk_screen_set_default_colormap (GdkScreen *screen,
 64--                                               GdkColormap *colormap);
 65
 66--    Sets the default colormap for screen.
 67
 68--    screen :   a GdkScreen
 69--    colormap : a GdkColormap
 70
 71--    Since 2.2
 72
 73--    --------------------------------------------------------------------------
 74
 75--   gdk_screen_get_system_colormap ()
 76
 77--  GdkColormap* gdk_screen_get_system_colormap (GdkScreen *screen);
 78
 79--    Gets the system's default colormap for screen
 80
 81--    screen :  a GdkScreen
 82--    Returns : the default colormap for screen.
 83
 84--    Since 2.2
 85
 86--    --------------------------------------------------------------------------
 87
 88--   gdk_screen_get_system_visual ()
 89
 90--  GdkVisual*  gdk_screen_get_system_visual    (GdkScreen *screen);
 91
 92--    Get the system's default visual for screen. This is the visual for the
 93--    root window of the display. The return value should not be freed.
 94
 95--    screen :  a GdkScreen.
 96--    Returns : the system visual
 97
 98--    Since 2.2
 99
100--    --------------------------------------------------------------------------
101
102--   gdk_screen_get_rgb_colormap ()
103
104--  GdkColormap* gdk_screen_get_rgb_colormap    (GdkScreen *screen);
105
106--    Gets the preferred colormap for rendering image data on screen. Not a very
107--    useful function; historically, GDK could only render RGB image data to one
108--    colormap and visual, but in the current version it can render to any
109--    colormap and visual. So there's no need to call this function.
110
111--    screen :  a GdkScreen.
112--    Returns : the preferred colormap
113
114--    Since 2.2
115
116--    --------------------------------------------------------------------------
117
118--   gdk_screen_get_rgb_visual ()
119
120--  GdkVisual*  gdk_screen_get_rgb_visual       (GdkScreen *screen);
121
122--    Gets a "preferred visual" chosen by GdkRGB for rendering image data on
123--    screen. In previous versions of GDK, this was the only visual GdkRGB could
124--    use for rendering. In current versions, it's simply the visual GdkRGB
125--    would have chosen as the optimal one in those previous versions. GdkRGB
126--    can now render to drawables with any visual.
127
128--    screen :  a GdkScreen
129--    Returns : The GdkVisual chosen by GdkRGB.
130
131--    Since 2.2
132
133--    --------------------------------------------------------------------------
134
135--   gdk_screen_get_rgba_colormap ()
136
137--  GdkColormap* gdk_screen_get_rgba_colormap   (GdkScreen *screen);
138
139--    Gets a colormap to use for creating windows or pixmaps with an alpha
140--    channel. The windowing system on which GTK+ is running may not support
141--    this capability, in which case NULL will be returned. Even if a non-NULL
142--    value is returned, its possible that the window's alpha channel won't be
143--    honored when displaying the window on the screen: in particular, for X an
144--    appropriate windowing manager and compositing manager must be running to
145--    provide appropriate display.
146
147--    screen :  a GdkScreen.
148--    Returns : a colormap to use for windows with an alpha channel or NULL if
149--              the capability is not available.
150
151--    Since 2.8
152
153--    --------------------------------------------------------------------------
154
155--   gdk_screen_get_rgba_visual ()
156
157--  GdkVisual*  gdk_screen_get_rgba_visual      (GdkScreen *screen);
158
159--    Gets a visual to use for creating windows or pixmaps with an alpha
160--    channel. See the docs for gdk_screen_get_rgba_colormap() for caveats.
161
162--    screen :  a GdkScreen
163--    Returns : a visual to use for windows with an alpha channel or NULL if the
164--              capability is not available.
165
166--    Since 2.8
167
168--    --------------------------------------------------------------------------
169
170--   gdk_screen_is_composited ()
171
172--  gboolean    gdk_screen_is_composited        (GdkScreen *screen);
173
174--    Returns whether windows with an RGBA visual can reasonably be expected to
175--    have their alpha channel drawn correctly on the screen.
176
177--    On X11 this function returns whether a compositing manager is compositing
178--    screen.
179
180--    screen :  a GdkScreen
181--    Returns : Whether windows with RGBA visuals can reasonably be expected to
182--              have their alpha channels drawn correctly on the screen.
183
184--    Since 2.10
185
186--    --------------------------------------------------------------------------
187
188--   gdk_screen_get_root_window ()
189
190--  GdkWindow*  gdk_screen_get_root_window      (GdkScreen *screen);
191
192--    Gets the root window of screen.
193
194--    screen :  a GdkScreen
195--    Returns : the root window
196
197--    Since 2.2
198
199--    --------------------------------------------------------------------------
200
201--   gdk_screen_get_display ()
202
203--  GdkDisplay* gdk_screen_get_display          (GdkScreen *screen);
204
205--    Gets the display to which the screen belongs.
206
207--    screen :  a GdkScreen
208--    Returns : the display to which screen belongs
209
210--    Since 2.2
211
212--    --------------------------------------------------------------------------
213
214--   gdk_screen_get_number ()
215
216--  gint        gdk_screen_get_number           (GdkScreen *screen);
217
218--    Gets the index of screen among the screens in the display to which it
219--    belongs. (See gdk_screen_get_display())
220
221--    screen :  a GdkScreen
222--    Returns : the index
223
224--    Since 2.2
225
226--    --------------------------------------------------------------------------
227
228--   gdk_screen_get_width ()
229
230--  gint        gdk_screen_get_width            (GdkScreen *screen);
231
232--    Gets the width of screen in pixels
233
234--    screen :  a GdkScreen
235--    Returns : the width of screen in pixels.
236
237--    Since 2.2
238
239--    --------------------------------------------------------------------------
240
241--   gdk_screen_get_height ()
242
243--  gint        gdk_screen_get_height           (GdkScreen *screen);
244
245--    Gets the height of screen in pixels
246
247--    screen :  a GdkScreen
248--    Returns : the height of screen in pixels.
249
250--    Since 2.2
251
252--    --------------------------------------------------------------------------
253
254--   gdk_screen_get_width_mm ()
255
256--  gint        gdk_screen_get_width_mm         (GdkScreen *screen);
257
258--    Gets the width of screen in millimeters. Note that on some X servers this
259--    value will not be correct.
260
261--    screen :  a GdkScreen
262--    Returns : the width of screen in millimeters.
263
264--    Since 2.2
265
266--    --------------------------------------------------------------------------
267
268--   gdk_screen_get_height_mm ()
269
270--  gint        gdk_screen_get_height_mm        (GdkScreen *screen);
271
272--    Returns the height of screen in millimeters. Note that on some X servers
273--    this value will not be correct.
274
275--    screen :  a GdkScreen
276--    Returns : the heigth of screen in millimeters.
277
278--    Since 2.2
279
280--    --------------------------------------------------------------------------
281
282--   gdk_screen_list_visuals ()
283
284--  GList*      gdk_screen_list_visuals         (GdkScreen *screen);
285
286--    Lists the available visuals for the specified screen. A visual describes a
287--    hardware image data format. For example, a visual might support 24-bit
288--    color, or 8-bit color, and might expect pixels to be in a certain format.
289
290--    Call g_list_free() on the return value when you're finished with it.
291
292--    screen :  the relevant GdkScreen.
293--    Returns : a list of visuals; the list must be freed, but not its contents
294
295--    Since 2.2
296
297--    --------------------------------------------------------------------------
298
299--   gdk_screen_get_toplevel_windows ()
300
301--  GList*      gdk_screen_get_toplevel_windows (GdkScreen *screen);
302
303--    Obtains a list of all toplevel windows known to GDK on the screen screen.
304--    A toplevel window is a child of the root window (see
305--    gdk_get_default_root_window()).
306
307--    The returned list should be freed with g_list_free(), but its elements
308--    need not be freed.
309
310--    screen :  The GdkScreen where the toplevels are located.
311--    Returns : list of toplevel windows, free with g_list_free()
312
313--    Since 2.2
314
315--    --------------------------------------------------------------------------
316
317--   gdk_screen_make_display_name ()
318
319--  gchar*      gdk_screen_make_display_name    (GdkScreen *screen);
320
321--    Determines the name to pass to gdk_display_open() to get a GdkDisplay with
322--    this screen as the default screen.
323
324--    screen :  a GdkScreen
325--    Returns : a newly allocated string, free with g_free()
326
327--    Since 2.2
328
329--    --------------------------------------------------------------------------
330
331--   gdk_screen_get_n_monitors ()
332
333--  gint        gdk_screen_get_n_monitors       (GdkScreen *screen);
334
335--    Returns the number of monitors which screen consists of.
336
337--    screen :  a GdkScreen.
338--    Returns : number of monitors which screen consists of.
339
340--    Since 2.2
341
342--    --------------------------------------------------------------------------
343
344--   gdk_screen_get_monitor_geometry ()
345
346--  void        gdk_screen_get_monitor_geometry (GdkScreen *screen,
347--                                               gint monitor_num,
348--                                               GdkRectangle *dest);
349
350--    Retrieves the GdkRectangle representing the size and position of the
351--    individual monitor within the entire screen area.
352
353--    Note that the size of the entire screen area can be retrieved via
354--    gdk_screen_get_width() and gdk_screen_get_height().
355
356--    screen :      a GdkScreen.
357--    monitor_num : the monitor number.
358--    dest :        a GdkRectangle to be filled with the monitor geometry
359
360--    Since 2.2
361
362--    --------------------------------------------------------------------------
363
364--   gdk_screen_get_monitor_at_point ()
365
366--  gint        gdk_screen_get_monitor_at_point (GdkScreen *screen,
367--                                               gint x,
368--                                               gint y);
369
370--    Returns the monitor number in which the point (x,y) is located.
371
372--    screen :  a GdkScreen.
373--    x :       the x coordinate in the virtual screen.
374--    y :       the y coordinate in the virtual screen.
375--    Returns : the monitor number in which the point (x,y) lies, or a monitor
376--              close to (x,y) if the point is not in any monitor.
377
378--    Since 2.2
379
380--    --------------------------------------------------------------------------
381
382--   gdk_screen_get_monitor_at_window ()
383
384--  gint        gdk_screen_get_monitor_at_window
385--                                              (GdkScreen *screen,
386--                                               GdkWindow *window);
387
388--    Returns the number of the monitor in which the largest area of the
389--    bounding rectangle of window resides.
390
391--    screen :  a GdkScreen.
392--    window :  a GdkWindow
393--    Returns : the monitor number in which most of window is located, or if
394--              window does not intersect any monitors, a monitor, close to
395--              window.
396
397--    Since 2.2
398
399--    --------------------------------------------------------------------------
400
401--   gdk_screen_broadcast_client_message ()
402
403--  void        gdk_screen_broadcast_client_message
404--                                              (GdkScreen *screen,
405--                                               GdkEvent *event);
406
407--    On X11, sends an X ClientMessage event to all toplevel windows on screen.
408
409--    Toplevel windows are determined by checking for the WM_STATE property, as
410--    described in the Inter-Client Communication Conventions Manual (ICCCM). If
411--    no windows are found with the WM_STATE property set, the message is sent
412--    to all children of the root window.
413
414--    On Windows, broadcasts a message registered with the name
415--    GDK_WIN32_CLIENT_MESSAGE to all top-level windows. The amount of data is
416--    limited to one long, i.e. four bytes.
417
418--    screen : the GdkScreen where the event will be broadcasted.
419--    event :  the GdkEvent.
420
421--    Since 2.2
422
423--    --------------------------------------------------------------------------
424
425--   gdk_screen_get_setting ()
426
427--  gboolean    gdk_screen_get_setting          (GdkScreen *screen,
428--                                               const gchar *name,
429--                                               GValue *value);
430
431--    Retrieves a desktop-wide setting such as double-click time for the
432--    GdkScreen screen.
433
434--    FIXME needs a list of valid settings here, or a link to more information.
435
436--    screen :  the GdkScreen where the setting is located
437--    name :    the name of the setting
438--    value :   location to store the value of the setting
439--    Returns : TRUE if the setting existed and a value was stored in value,
440--              FALSE otherwise.
441
442--    Since 2.2
443
444--    --------------------------------------------------------------------------
445
446--   gdk_screen_get_font_options ()
447
448--  const cairo_font_options_t* gdk_screen_get_font_options
449--                                              (GdkScreen *screen);
450
451--    Gets any options previously set with gdk_screen_set_font_options().
452
453--    screen :  a GdkScreen
454--    Returns : the current font options, or NULL if no default font options
455--              have been set.
456
457--    Since 2.10
458
459--    --------------------------------------------------------------------------
460
461--   gdk_screen_set_font_options ()
462
463--  void        gdk_screen_set_font_options     (GdkScreen *screen,
464--                                               const cairo_font_options_t *options);
465
466--    Sets the default font options for the screen. These options will be set on
467--    any PangoContext's newly created with gdk_pango_context_get_for_screen().
468--    Changing the default set of font options does not affect contexts that
469--    have already been created.
470
471--    screen :  a GdkScreen
472--    options : a cairo_font_options_t, or NULL to unset any previously set
473--              default font options.
474
475--    Since 2.10
476
477--    --------------------------------------------------------------------------
478
479--   gdk_screen_get_resolution ()
480
481--  gdouble     gdk_screen_get_resolution       (GdkScreen *screen);
482
483--    Gets the resolution for font handling on the screen; see
484--    gdk_screen_set_resolution() for full details.
485
486--    screen :  a GdkScreen
487--    Returns : the current resolution, or -1 if no resolution has been set.
488
489--    Since 2.10
490
491--    --------------------------------------------------------------------------
492
493--   gdk_screen_set_resolution ()
494
495--  void        gdk_screen_set_resolution       (GdkScreen *screen,
496--                                               gdouble dpi);
497
498--    Sets the resolution for font handling on the screen. This is a scale
499--    factor between points specified in a PangoFontDescription and cairo units.
500--    The default value is 96, meaning that a 10 point font will be 13 units
501--    high. (10 * 96. / 72. = 13.3).
502
503--    screen : a GdkScreen
504--    dpi :    the resolution in "dots per inch". (Physical inches aren't
505--             actually involved; the terminology is conventional.)
506
507--    Since 2.10
508
509--    --------------------------------------------------------------------------
510
511--   gdk_screen_get_active_window ()
512
513--  GdkWindow*  gdk_screen_get_active_window    (GdkScreen *screen);
514
515--    Returns the screen's currently active window.
516
517--    On X11, this is done by inspecting the _NET_ACTIVE_WINDOW property on the
518--    root window, as described in the Extended Window Manager Hints. If there
519--    is no currently currently active window, or the window manager does not
520--    support the _NET_ACTIVE_WINDOW hint, this function returns NULL.
521
522--    On other platforms, this function may return NULL, depending on whether it
523--    is implementable on that platform.
524
525--    The returned window should be unrefed using g_object_unref() when no
526--    longer needed.
527
528--    screen :  a GdkScreen
529--    Returns : the currently active window, or NULL.
530
531--    Since 2.10
532
533--    --------------------------------------------------------------------------
534
535--   gdk_screen_get_window_stack ()
536
537--  GList*      gdk_screen_get_window_stack     (GdkScreen *screen);
538
539--    Returns a GList of GdkWindows representing the current window stack.
540
541--    On X11, this is done by inspecting the _NET_CLIENT_LIST_STACKING property
542--    on the root window, as described in the Extended Window Manager Hints. If
543--    the window manager does not support the _NET_CLIENT_LIST_STACKING hint,
544--    this function returns NULL.
545
546--    On other platforms, this function may return NULL, depending on whether it
547--    is implementable on that platform.
548
549--    The returned list is newly allocated and owns references to the windows it
550--    contains, so it should be freed using g_list_free() and its windows
551--    unrefed using g_object_unref() when no longer needed.
552
553--    screen :  a GdkScreen
554--    Returns : a list of GdkWindows for the current window stack, or NULL.
555
556--    Since 2.10
557
558--    --------------------------------------------------------------------------
559
560--   gdk_spawn_on_screen ()
561
562--  gboolean    gdk_spawn_on_screen             (GdkScreen *screen,
563--                                               const gchar *working_directory,
564--                                               gchar **argv,
565--                                               gchar **envp,
566--                                               GSpawnFlags flags,
567--                                               GSpawnChildSetupFunc child_setup,
568--                                               gpointer user_data,
569--                                               gint *child_pid,
570--                                               GError **error);
571
572--    Like g_spawn_async(), except the child process is spawned in such an
573--    environment that on calling gdk_display_open() it would be returned a
574--    GdkDisplay with screen as the default screen.
575
576--    This is useful for applications which wish to launch an application on a
577--    specific screen.
578
579--    screen :            a GdkScreen
580--    working_directory : child's current working directory, or NULL to inherit
581--                        parent's
582--    argv :              child's argument vector
583--    envp :              child's environment, or NULL to inherit parent's
584--    flags :             flags from GSpawnFlags
585--    child_setup :       function to run in the child just before exec()
586--    user_data :         user data for child_setup
587--    child_pid :         return location for child process ID, or NULL
588--    error :             return location for error
589--    Returns :           TRUE on success, FALSE if error is set
590
591--    Since 2.4
592
593--    --------------------------------------------------------------------------
594
595--   gdk_spawn_on_screen_with_pipes ()
596
597--  gboolean    gdk_spawn_on_screen_with_pipes  (GdkScreen *screen,
598--                                               const gchar *working_directory,
599--                                               gchar **argv,
600--                                               gchar **envp,
601--                                               GSpawnFlags flags,
602--                                               GSpawnChildSetupFunc child_setup,
603--                                               gpointer user_data,
604--                                               gint *child_pid,
605--                                               gint *standard_input,
606--                                               gint *standard_output,
607--                                               gint *standard_error,
608--                                               GError **error);
609
610--    Like g_spawn_async_with_pipes(), except the child process is spawned in
611--    such an environment that on calling gdk_display_open() it would be
612--    returned a GdkDisplay with screen as the default screen.
613
614--    This is useful for applications which wish to launch an application on a
615--    specific screen.
616
617--    screen :            a GdkScreen
618--    working_directory : child's current working directory, or NULL to inherit
619--                        parent's
620--    argv :              child's argument vector
621--    envp :              child's environment, or NULL to inherit parent's
622--    flags :             flags from GSpawnFlags
623--    child_setup :       function to run in the child just before exec()
624--    user_data :         user data for child_setup
625--    child_pid :         return location for child process ID, or NULL
626--    standard_input :    return location for file descriptor to write to
627--                        child's stdin, or NULL
628--    standard_output :   return location for file descriptor to read child's
629--                        stdout, or NULL
630--    standard_error :    return location for file descriptor to read child's
631--                        stderr, or NULL
632--    error :             return location for error
633--    Returns :           TRUE on success, FALSE if an error was set
634
635--    Since 2.4
636
637--    --------------------------------------------------------------------------
638
639--   gdk_spawn_command_line_on_screen ()
640
641--  gboolean    gdk_spawn_command_line_on_screen
642--                                              (GdkScreen *screen,
643--                                               const gchar *command_line,
644--                                               GError **error);
645
646--    Like g_spawn_command_line_async(), except the child process is spawned in
647--    such an environment that on calling gdk_display_open() it would be
648--    returned a GdkDisplay with screen as the default screen.
649
650--    This is useful for applications which wish to launch an application on a
651--    specific screen.
652
653--    screen :       a GdkScreen
654--    command_line : a command line
655--    error :        return location for errors
656--    Returns :      TRUE on success, FALSE if error is set.
657
658--    Since 2.4
659-- Properties
660
661
662--    "font-options"         gpointer              : Read / Write
663--    "resolution"           gdouble               : Read / Write
664
665
666
667-- Property Details
668
669--   The "font-options" property
670
671--    "font-options"         gpointer              : Read / Write
672
673--    The default font options for the screen.
674
675--    --------------------------------------------------------------------------
676
677--   The "resolution" property
678
679--    "resolution"           gdouble               : Read / Write
680
681--    The resolution for fonts on the screen.
682
683--    Default value: -1
684
685-- Signals
686
687
688--  "composited-changed"
689--              void        user_function      (GdkScreen *screen,
690--                                              gpointer   user_data)      : Run last
691--  "size-changed"
692--              void        user_function      (GdkScreen *screen,
693--                                              gpointer   user_data)      : Run last
694
695
696-- Signal Details
697
698--   The "composited-changed" signal
699
700--  void        user_function                  (GdkScreen *screen,
701--                                              gpointer   user_data)      : Run last
702
703--    The ::composited_changed signal is emitted when the composited status of
704--    the screen changes
705
706--    screen :    the object on which the signal is emitted
707--    user_data : user data set when the signal handler was connected.
708
709--    Since 2.10
710
711--    --------------------------------------------------------------------------
712
713--   The "size-changed" signal
714
715--  void        user_function                  (GdkScreen *screen,
716--                                              gpointer   user_data)      : Run last
717
718--    The ::size_changed signal is emitted when the pixel width or height of a
719--    screen changes.
720
721--    screen :    the object on which the signal is emitted
722--    user_data : user data set when the signal handler was connected.
723
724
725feature 
726	struct_size: INTEGER is
727		external "C inline use <gdk/gdk.h>"
728		alias "sizeof(GdkScreen)"
729		end
730
731feature {} -- External calls
732	 gdk_screen_get_default: POINTER is
733			--  GdkScreen* gdk_screen_get_default (void);
734		external "C use <gtk/gtk.h>"
735		end
736
737	 gdk_screen_get_default_colormap (a_screen: POINTER): POINTER is
738			--  GdkColormap* gdk_screen_get_default_colormap (GdkScreen *screen);
739		external "C use <gtk/gtk.h>"
740		end
741
742	 gdk_screen_set_default_colormap (a_screen, a_colormap: POINTER) is
743			--  void gdk_screen_set_default_colormap (GdkScreen *screen, GdkColormap *colormap);
744		external "C use <gtk/gtk.h>"
745		end
746
747	 gdk_screen_get_system_colormap (a_screen: POINTER): POINTER is
748			--  GdkColormap* gdk_screen_get_system_colormap (GdkScreen *screen);
749		external "C use <gtk/gtk.h>"
750		end
751
752	 gdk_screen_get_system_visual (a_screen: POINTER): POINTER is
753			--  GdkVisual* gdk_screen_get_system_visual (GdkScreen *screen);
754		external "C use <gtk/gtk.h>"
755		end
756
757	 gdk_screen_get_rgb_colormap (a_screen: POINTER): POINTER is
758			--  GdkColormap* gdk_screen_get_rgb_colormap (GdkScreen *screen);
759		external "C use <gtk/gtk.h>"
760		end
761
762	 gdk_screen_get_rgb_visual (a_screen: POINTER): POINTER is
763			--  GdkVisual* gdk_screen_get_rgb_visual (GdkScreen *screen);
764		external "C use <gtk/gtk.h>"
765		end
766
767	 gdk_screen_get_rgba_colormap (a_screen: POINTER): POINTER is
768			--  GdkColormap* gdk_screen_get_rgba_colormap (GdkScreen *screen);
769		external "C use <gtk/gtk.h>"
770		end
771
772	 gdk_screen_get_rgba_visual (a_screen: POINTER): POINTER is
773			--  GdkVisual* gdk_screen_get_rgba_visual (GdkScreen *screen);
774		external "C use <gtk/gtk.h>"
775		end
776
777	 gdk_screen_is_composited (a_screen: POINTER): INTEGER is
778			--  gboolean gdk_screen_is_composited (GdkScreen *screen);
779		external "C use <gtk/gtk.h>"
780		end
781
782	 gdk_screen_get_root_window (a_screen: POINTER): POINTER is
783			--  GdkWindow* gdk_screen_get_root_window (GdkScreen *screen);
784		external "C use <gtk/gtk.h>"
785		end
786
787	 gdk_screen_get_display (a_screen: POINTER): POINTER is
788			--  GdkDisplay* gdk_screen_get_display (GdkScreen *screen);
789		external "C use <gtk/gtk.h>"
790		end
791
792	 gdk_screen_get_number (a_screen: POINTER): INTEGER is
793			--  gint gdk_screen_get_number (GdkScreen *screen);
794		external "C use <gtk/gtk.h>"
795		end
796
797	 gdk_screen_get_width (a_screen: POINTER): INTEGER is
798			--  gint gdk_screen_get_width (GdkScreen *screen);
799		external "C use <gtk/gtk.h>"
800		end
801
802	 gdk_screen_get_height (a_screen: POINTER): INTEGER is
803			--  gint gdk_screen_get_height (GdkScreen *screen);
804		external "C use <gtk/gtk.h>"
805		end
806
807	 gdk_screen_get_width_mm (a_screen: POINTER): INTEGER is
808			--  gint gdk_screen_get_width_mm (GdkScreen *screen);
809		external "C use <gtk/gtk.h>"
810		end
811
812	 gdk_screen_get_height_mm (a_screen: POINTER): INTEGER is
813			--  gint gdk_screen_get_height_mm (GdkScreen *screen);
814		external "C use <gtk/gtk.h>"
815		end
816
817	 gdk_screen_list_visuals (a_screen: POINTER): POINTER is
818			--  GList* gdk_screen_list_visuals (GdkScreen *screen);
819		external "C use <gtk/gtk.h>"
820		end
821
822	 gdk_screen_get_toplevel_windows (a_screen: POINTER): POINTER is
823			--  GList* gdk_screen_get_toplevel_windows (GdkScreen *screen);
824		external "C use <gtk/gtk.h>"
825		end
826
827	 gdk_screen_make_display_name (a_screen: POINTER): POINTER is
828			--  gchar* gdk_screen_make_display_name (GdkScreen *screen);
829		external "C use <gtk/gtk.h>"
830		end
831
832	 gdk_screen_get_n_monitors (a_screen: POINTER): INTEGER is
833			--  gint gdk_screen_get_n_monitors (GdkScreen *screen);
834		external "C use <gtk/gtk.h>"
835		end
836
837	 gdk_screen_get_monitor_geometry (a_screen: POINTER; a_monitor_num: INTEGER; a_dest: POINTER) is
838			--  void gdk_screen_get_monitor_geometry (a_screen: POINTER, gint monitor_num, a_dest: POINTER);
839		external "C use <gtk/gtk.h>"
840		end
841
842	 gdk_screen_get_monitor_at_point (a_screen: POINTER; an_x, an_y: INTEGER): INTEGER is
843			--  gint gdk_screen_get_monitor_at_point (a_screen: POINTER, gint x, gint y);
844		external "C use <gtk/gtk.h>"
845		end
846
847	 gdk_screen_get_monitor_at_window (a_screen, a_window: POINTER): INTEGER is
848			--  gint gdk_screen_get_monitor_at_window (GdkScreen *screen, GdkWindow *window);
849		external "C use <gtk/gtk.h>"
850		end
851
852	 gdk_screen_broadcast_client_message (a_screen, a_event: POINTER) is
853			--  void gdk_screen_broadcast_client_message (GdkScreen *screen, GdkEvent *event);
854		external "C use <gtk/gtk.h>"
855		end
856
857	 gdk_screen_get_setting (a_screen, a_name, a_value: POINTER): INTEGER is
858			--  gboolean gdk_screen_get_setting (GdkScreen *screen, const gchar *name, GValue *value);
859		external "C use <gtk/gtk.h>"
860		end
861
862	gdk_screen_get_font_options (a_screen: POINTER): POINTER is
863			--  const cairo_font_options_t* gdk_screen_get_font_options (GdkScreen *screen);
864		external "C use <gtk/gtk.h>"
865		end
866
867	 gdk_screen_set_font_options (a_screen, some_options: POINTER) is
868			--  void gdk_screen_set_font_options (GdkScreen *screen, const cairo_font_options_t *options);
869		external "C use <gtk/gtk.h>"
870		end
871
872	 gdk_screen_get_resolution (a_screen: POINTER): REAL is
873			--  gdouble gdk_screen_get_resolution (GdkScreen *screen);
874		external "C use <gtk/gtk.h>"
875		end
876
877	 gdk_screen_set_resolution (a_screen: POINTER; some_dpi: REAL) is
878			--  void gdk_screen_set_resolution (GdkScreen *screen, gdouble dpi);
879		external "C use <gtk/gtk.h>"
880		end
881
882	 gdk_screen_get_active_window (a_screen: POINTER): POINTER is
883			--  GdkWindow* gdk_screen_get_active_window (GdkScreen *screen);
884		external "C use <gtk/gtk.h>"
885		end
886
887	 gdk_screen_get_window_stack (a_screen: POINTER): POINTER is
888			--  GList* gdk_screen_get_window_stack (GdkScreen *screen);
889		external "C use <gtk/gtk.h>"
890		end
891
892
893	gdk_spawn_on_screen (a_screen, a_working_directory, an_argv, an_envp: POINTER; some_flags: INTEGER; a_child_setup_function, some_data, a_child_pid, an_error: POINTER): INTEGER is
894			-- gboolean gdk_spawn_on_screen (GdkScreen *screen, const
895			-- gchar *working_directory, gchar **argv, gchar **envp,
896			-- GSpawnFlags flags, GSpawnChildSetupFunc child_setup,
897			-- gpointer user_data, gint *child_pid, GError **error);
898		external "C use <gtk/gtk.h>"
899		end
900
901	gdk_spawn_on_screen_with_pipes (a_screen, a_working_directory, an_argv, an_envp: POINTER; some_flags: INTEGER; a_gspawn_child_setup_func, some_data, a_child_pid, a_standard_input, a_standard_output, a_standard_error, an_error: POINTER): INTEGER is
902			-- gboolean gdk_spawn_on_screen_with_pipes (GdkScreen
903			-- *screen, const gchar *working_directory, gchar **argv,
904			-- gchar **envp, GSpawnFlags flags, GSpawnChildSetupFunc
905			-- child_setup, gpointer user_data, gint *child_pid, gint
906			-- *standard_input, gint *standard_output, gint
907			-- *standard_error, GError **error);
908		external "C use <gtk/gtk.h>"
909		end
910
911	gdk_spawn_command_line_on_screen (a_screen, a_command_line, a_error: POINTER): INTEGER is
912			-- gboolean gdk_spawn_command_line_on_screen (GdkScreen
913			-- *screen, const gchar *command_line, GError **error);
914		external "C use <gtk/gtk.h>"
915		end
916end -- class GDK_SCREEN