<ul><li><a href="#NAME">NAME</a></li>
<li><a href="#CATEGORY">CATEGORY</a></li>
<li><a href="#SYNOPSIS">SYNOPSIS</a></li>
-<li><a href="#METHODS">METHODS</a>
+<li><a href="#Core_Functions">Core Functions</a>
<ul><li><a href="#get_video_surface">get_video_surface</a></li>
<li><a href="#get_video_info">get_video_info</a></li>
<li><a href="#video_driver_name">video_driver_name</a></li>
<ul><li><a href="#List_of_avalaibles_flags">List of avalaibles flags</a></li>
</ul>
</li>
+<li><a href="#convert_surface_surface_format_flags">convert_surface(surface,format,flags)</a></li>
+<li><a href="#display_format">display_format</a></li>
+<li><a href="#display_format_alpha">display_format_alpha</a></li>
+<li><a href="#load_BMP_filename">load_BMP(filename)</a></li>
+<li><a href="#save_BMP_surface_filename">save_BMP(surface,filename)</a></li>
+<li><a href="#set_color_key_surface_flag_key">set_color_key(surface,flag,key)</a></li>
+<li><a href="#set_alpha_surface_flag_key">set_alpha(surface,flag,key)</a></li>
+<li><a href="#fill_rect_dest_dest_rect_pixel">fill_rect(dest,dest_rect,pixel)</a></li>
+</ul>
+</li>
+<li><a href="#Surface_locking_and_unlocking">Surface locking and unlocking</a>
+<ul><li><a href="#lock_surface_surface">lock_surface(surface)</a></li>
+<li><a href="#unlock_surface_surface">unlock_surface(surface)</a></li>
+<li><a href="#MUSTLOCK_surface">MUSTLOCK(surface)</a></li>
+</ul>
+</li>
+<li><a href="#Screen_Updating_Functions">Screen Updating Functions</a>
+<ul><li><a href="#set_clip_rect_surface_rect">set_clip_rect(surface,rect)</a></li>
+<li><a href="#get_clip_rect_surface_rect">get_clip_rect(surface,rect)</a></li>
+<li><a href="#blit_surface_src_src_rect_dest_dest_">blit_surface(src,src_rect,dest,dest_rect)</a></li>
<li><a href="#update_rect_surface_x_y_width_height">update_rect(surface,x,y,width,height)</a></li>
<li><a href="#update_rects_surface_rects">update_rects(surface,rects) </a></li>
<li><a href="#flip_surface">flip(surface)</a></li>
-<li><a href="#set_colors_surface_start_colors">set_colors(surface,start,colors)</a></li>
+</ul>
+</li>
+<li><a href="#Palette_Color_and_Pixel_Functions">Palette, Color and Pixel Functions</a>
+<ul><li><a href="#set_colors_surface_start_colors">set_colors(surface,start,colors)</a></li>
<li><a href="#set_palette_surface_flags_start_colo">set_palette(surface,flags,start,colors)</a></li>
<li><a href="#set_gamma_r_g_b">set_gamma(r,g,b)</a></li>
-<li><a href="#get_gamma_ramp_rt_gt_bt_to_be_coded">get_gamma_ramp(rt,gt,bt) * to be coded</a></li>
+<li><a href="#get_gamma_ramp_rt_gt_bt">get_gamma_ramp(rt,gt,bt)</a></li>
<li><a href="#set_gamma_ramp_rt_gt_bt">set_gamma_ramp(rt,gt,bt)</a></li>
<li><a href="#map_RGB_pixel_format_r_g_b">map_RGB(pixel_format,r,g,b)</a></li>
<li><a href="#map_RGBA_pixel_format_r_g_b_a">map_RGBA(pixel_format,r,g,b,a)</a></li>
<li><a href="#get_RGB_pixel_format_pixel">get_RGB(pixel_format,pixel)</a></li>
<li><a href="#get_RGBA_pixel_format_pixel">get_RGBA(pixel_format,pixel)</a></li>
-<li><a href="#create_RGB_surface_from">create_RGB_surface_from ***</a></li>
-<li><a href="#lock_surface_surface">lock_surface(surface)</a></li>
-<li><a href="#unlock_surface_surface">unlock_surface(surface)</a></li>
-<li><a href="#convert_surface_surface_format_flags">convert_surface(surface,format,flags)</a></li>
-<li><a href="#display_format">display_format</a></li>
-<li><a href="#display_format_alpha">display_format_alpha</a></li>
-<li><a href="#load_BMP_filename">load_BMP(filename)</a></li>
-<li><a href="#save_BMP_surface_filename">save_BMP(surface,filename)</a></li>
-<li><a href="#set_color_key_surface_flag_key">set_color_key(surface,flag,key)</a></li>
-<li><a href="#set_alpha_surface_flag_key">set_alpha(surface,flag,key)</a></li>
-<li><a href="#set_clip_rect_surface_rect">set_clip_rect(surface,rect)</a></li>
-<li><a href="#get_clip_rect_surface_rect">get_clip_rect(surface,rect)</a></li>
-<li><a href="#blit_surface_src_src_rect_dest_dest_">blit_surface(src,src_rect,dest,dest_rect)</a></li>
-<li><a href="#fill_rect_dest_dest_rect_pixel">fill_rect(dest,dest_rect,pixel)</a></li>
-<li><a href="#GL_load_library_path">GL_load_library(path)</a></li>
+</ul>
+</li>
+<li><a href="#GL_Methods">GL Methods</a>
+<ul><li><a href="#GL_load_library_path">GL_load_library(path)</a></li>
<li><a href="#GL_get_proc_address_proc">GL_get_proc_address(proc)</a></li>
<li><a href="#GL_get_attribute_attr">GL_get_attribute(attr)</a></li>
<li><a href="#GL_set_attribute_attr_value">GL_set_attribute(attr,value)</a></li>
<li><a href="#GL_swap_buffers">GL_swap_buffers</a></li>
<li><a href="#GL_attr_to_be_coded">GL_attr *** to be coded</a></li>
-<li><a href="#lock_YUV_overlay_overlay">lock_YUV_overlay(overlay)</a></li>
+</ul>
+</li>
+<li><a href="#Video_Overlay_Functions">Video Overlay Functions</a>
+<ul><li><a href="#lock_YUV_overlay_overlay">lock_YUV_overlay(overlay)</a></li>
<li><a href="#unlock_YUV_overlay_overlay">unlock_YUV_overlay(overlay)</a></li>
<li><a href="#display_YUV_overlay_overlay_dstrect">display_YUV_overlay(overlay,dstrect)</a></li>
</ul>
</li>
+<li><a href="#Window_Management_Functions">Window Management Functions</a>
+<ul><li><a href="#wm_set_caption_title_icon">wm_set_caption(title,icon)</a></li>
+<li><a href="#wm_get_caption">wm_get_caption()</a></li>
+<li><a href="#wm_set_icon_icon">wm_set_icon(icon)</a></li>
+<li><a href="#wm_grab_input_mode">wm_grab_input(mode)</a></li>
+<li><a href="#wm_iconify_window">wm_iconify_window()</a></li>
+<li><a href="#wm_toggle_fullscreen_surface">wm_toggle_fullscreen(surface)</a></li>
+</ul>
+</li>
<li><a href="#SEE_ALSO">SEE ALSO</a>
<ul><li><a href="#Category_Objects">Category Objects</a>
</li>
</ul>
</li>
</ul><hr />
-<!-- INDEX END -->
+<!-- INDEX END --><a href="assets/Video.png" target="_blank"><img src="assets/Video.png" style="height: 160px" alt="Video.png"/></a><hr />
<h1 id="NAME">NAME</h1><p><a href="#TOP" class="toplink">Top</a></p>
<div id="NAME_CONTENT">
</pre>
</div>
-<h1 id="METHODS">METHODS</h1><p><a href="#TOP" class="toplink">Top</a></p>
-<div id="METHODS_CONTENT">
+<h1 id="Core_Functions">Core Functions</h1><p><a href="#TOP" class="toplink">Top</a></p>
+<div id="Core_Functions_CONTENT">
</div>
<h2 id="get_video_surface">get_video_surface</h2>
each call to <a href="#set_video_mode_width_height_bpp_flag">SDL::Video::set_video_mode</a>, for example for a multiplatform application). </p>
</div>
-<h2 id="update_rect_surface_x_y_width_height">update_rect(surface,x,y,width,height)</h2>
-<div id="update_rect_surface_x_y_width_height-2">
-<pre> update_rect( $surface, $left, $top, $width, $height );
-
-</pre>
-<p>Makes sure the given area is updated on the given screen.
-The rectangle must be confined within the screen boundaries because there's no clipping.
-update_rect doesn't returns any value.</p>
-<p><strong>Note</strong>: This function should not be called while screen is locked by <a href="#lock_surface_surface">SDL::Video::lock_surface</a></p>
-<p><strong>Note2</strong>: If <code>x</code>, <code>y</code>, <code>width</code> and <code>height</code> are all equal to 0, <code>update_rect</code> will update the entire screen. </p>
-<p>For an example see <a href="#SYNOPSIS">SYNOPSIS</a></p>
-
-</div>
-<h2 id="update_rects_surface_rects">update_rects(surface,rects) </h2>
-<div id="update_rects_surface_rects_CONTENT">
-<pre> update_rects( $surface, @rects );
-
-</pre>
-<p>Makes sure the given list of rectangles is updated on the given screen.
-The rectangle must be confined within the screen boundaries because there's no clipping.
-<code>update_rects</code> doesn't returns any value.</p>
-<p><strong>Note</strong>: This function should not be called while screen is locked by <a href="#lock_surface_surface">SDL::Video::lock_surface</a>.</p>
-<p>Example:</p>
-<pre> use SDL;
- use SDL::Video;
- use SDL::Surface;
- use SDL::Rect;
-
- # the size of the window box or the screen resolution if fullscreen
- my $screen_width = 800;
- my $screen_height = 600;
-
- SDL::init(SDL_INIT_VIDEO);
-
- # setting video mode
- my $screen_surface = SDL::Video::set_video_mode($screen_width, $screen_height, 32, SDL_SWSURFACE);
-
- # drawing the whole screen blue
- my $mapped_color = SDL::Video::map_RGB($screen_surface->format(), 0, 0, 255); # blue
- SDL::Video::fill_rect($screen_surface,
- SDL::Rect->new(0, 0, $screen_width, $screen_height),
- $mapped_color);
-
- my @rects = ();
- push(@rects, SDL::Rect->new(200, 0, 400, 600));
- push(@rects, SDL::Rect->new( 0, 150, 800, 300));
-
- # updating parts of the screen (should look like a cross)
- SDL::Video::update_rects($screen_surface, @rects);
-
- sleep(2);
-
- SDL::quit();
-
-</pre>
-
-</div>
-<h2 id="flip_surface">flip(surface)</h2>
-<div id="flip_surface_CONTENT">
-<p>On hardware that supports double-buffering, this function sets up a flip and returns.
-The hardware will wait for vertical retrace, and then swap video buffers before the next video surface blit or lock will return.
-On hardware that doesn't support double-buffering or if SDL_SWSURFACE was set, this is equivalent to calling SDL::update_rect(screen, 0, 0, 0, 0)</p>
-<p>A software screen surface is also updated automatically when parts of a SDL window are redrawn, caused by overlapping windows or by
-restoring from an iconified state. As a result there is no proper double buffer behavior in windowed mode for a software screen, in
-contrast to a full screen software mode.</p>
-<p>The SDL_DOUBLEBUF flag must have been passed to SDL::set_video_mode, when setting the video mode for this function to perform hardware
-flipping.
-flip returns 0 on success or -1 on error.</p>
-<p>Note : If you want to swap the buffers of an initialized OpenGL context, use the function SDL::gl_swap_buffers instead. </p>
-
-</div>
-<h2 id="set_colors_surface_start_colors">set_colors(surface,start,colors)</h2>
-<div id="set_colors_surface_start_colors_CONT">
-<p>Sets a portion of the colormap for the given 8-bit surface. </p>
-<p>When surface is the surface associated with the current display, the display colormap will be updated with the requested colors.
-If SDL_HWPALETTE was set in SDL::set_video_mode flags, SDL::set_colors will always return 1, and the palette is guaranteed to be set the
-way you desire, even if the window colormap has to be warped or run under emulation.
-The color components of a SDL::Color structure are 8-bits in size, giving you a total of 2563 = 16777216 colors.
-Palettized (8-bit) screen surfaces with the SDL_HWPALETTE flag have two palettes, a logical palette that is used for mapping blits to/from
-the surface and a physical palette (that determines how the hardware will map the colors to the display).
-SDL::SetColors modifies both palettes (if present), and is equivalent to calling SDL::SetPalette with the flags set to
-(SDL_LOGPAL | SDL_PHYSPAL). </p>
-<p>If surface is not a palettized surface, this function does nothing, returning 0.
-If all of the colors were set as passed to SDL::set_colors, it will return 1.
-If not all the color entries were set exactly as given, it will return 0, and you should look at the surface palette to determine the
-actual color palette.</p>
-
-</div>
-<h2 id="set_palette_surface_flags_start_colo">set_palette(surface,flags,start,colors)</h2>
-<div id="set_palette_surface_flags_start_colo-2">
-<p>Sets a portion of the palette for the given 8-bit surface.</p>
-<p>Palettized (8-bit) screen surfaces with the SDL_HWPALETTE flag have two palettes, a logical palette that is used for mapping blits to/from
-the surface and a physical palette (that determines how the hardware will map the colors to the display).
-Non screen surfaces have a logical palette only. SDL::blit_surface always uses the logical palette when blitting surfaces (if it has to
-convert between surface pixel formats). Because of this, it is often useful to modify only one or the other palette to achieve various
-special color effects (e.g., screen fading, color flashes, screen dimming).</p>
-<p>This function can modify either the logical or physical palette by specifying SDL_LOGPAL or SDL_PHYSPAL the in the flags parameter.</p>
-<p>When surface is the surface associated with the current display, the display colormap will be updated with the requested colors.
-If SDL_HWPALETTE was set in SDL::set_video_mode flags, SDL::set_palette will always return 1, and the palette is guaranteed to be set the
-way you desire, even if the window colormap has to be warped or run under emulation.
-The color components of a SDL::Color structure are 8-bits in size, giving you a total of 2563 = 16777216 colors. </p>
-<p>If surface is not a palettized surface, this function does nothing, returning 0. If all of the colors were set as passed to SDL_SetPalette,
-it will return 1. If not all the color entries were set exactly as given, it will return 0, and you should look at the surface palette
-to determine the actual color palette.</p>
-
-</div>
-<h2 id="set_gamma_r_g_b">set_gamma(r,g,b)</h2>
-<div id="set_gamma_r_g_b_CONTENT">
-<p>Sets the "gamma function" for the display of each color component. Gamma controls the brightness/contrast of colors displayed on the screen.
-A gamma value of 1.0 is identity (i.e., no adjustment is made).</p>
-<p>This function adjusts the gamma based on the "gamma function" parameter, you can directly specify lookup tables for gamma adjustment
-with SDL::set_gamma_ramp.</p>
-<p>Not all display hardware is able to change gamma.
-SDL::set_gamma returns -1 on error.</p>
-<p>Warning: Under Linux (X.org Gnome and Xfce), gamma settings affects the entire display (including the desktop)! </p>
-
-</div>
-<h2 id="get_gamma_ramp_rt_gt_bt_to_be_coded">get_gamma_ramp(rt,gt,bt) * to be coded</h2>
-<div id="get_gamma_ramp_rt_gt_bt_to_be_coded_">
-<p>Gets the gamma translation lookup tables currently used by the display. Each table is an array of 256 Uint16 values.
-SDL::get_gamma_ramp returns -1 on error.</p>
-
-</div>
-<h2 id="set_gamma_ramp_rt_gt_bt">set_gamma_ramp(rt,gt,bt)</h2>
-<div id="set_gamma_ramp_rt_gt_bt_CONTENT">
-<p>Sets the gamma lookup tables for the display for each color component. Each table is an array of 256 Uint16 values, representing a
-mapping between the input and output for that channel.
-The input is the index into the array, and the output is the 16-bit gamma value at that index, scaled to the output color precision.
-You may pass NULL to any of the channels to leave them unchanged.</p>
-<p>This function adjusts the gamma based on lookup tables, you can also have the gamma calculated based on a "gamma function" parameter
-with SDL::set_gamma.</p>
-<p>Not all display hardware is able to change gamma.
-SDL::set_gamma_ramp returns -1 on error.</p>
-
-</div>
-<h2 id="map_RGB_pixel_format_r_g_b">map_RGB(pixel_format,r,g,b)</h2>
-<div id="map_RGB_pixel_format_r_g_b_CONTENT">
-<p>Maps the RGB color value to the specified SDL::pixel_format and returns the pixel value as a 32-bit int.
-If the format has a palette (8-bit) the index of the closest matching color in the palette will be returned.
-If the specified pixel format has an alpha component it will be returned as all 1 bits (fully opaque). </p>
-<p>SDL::map_RGP returns a pixel value best approximating the given RGB color value for a given pixel format.
-If the SDL::pixel_format's bpp (color depth) is less than 32-bpp then the unused upper bits of the return value can safely be ignored
-(e.g., with a 16-bpp format the return value can be assigned to a Uint16, and similarly a Uint8 for an 8-bpp format).</p>
-
-</div>
-<h2 id="map_RGBA_pixel_format_r_g_b_a">map_RGBA(pixel_format,r,g,b,a)</h2>
-<div id="map_RGBA_pixel_format_r_g_b_a_CONTEN">
-<p>Maps the RGBA color value to the specified SDL::pixel_format and returns the pixel value as a 32-bit int.
-If the format has a palette (8-bit) the index of the closest matching color in the palette will be returned.
-If the specified pixel format has no alpha component the alpha value will be ignored (as it will be in formats with a palette). </p>
-<p>A pixel value best approximating the given RGBA color value for a given pixel format.
-If the pixel format bpp (color depth) is less than 32-bpp then the unused upper bits of the return value can safely be ignored (e.g.,
-with a 16-bpp format the return value can be assigned to a Uint16, and similarly a Uint8 for an 8-bpp format).</p>
-
-</div>
-<h2 id="get_RGB_pixel_format_pixel">get_RGB(pixel_format,pixel)</h2>
-<div id="get_RGB_pixel_format_pixel_CONTENT">
-<p>Returns RGB values from a pixel in the specified pixel format.
-This function uses the entire 8-bit [0..255] range when converting color components from pixel formats with less than 8-bits per RGB
-component (e.g., a completely white pixel in 16-bit RGB565 format would return [0xff, 0xff, 0xff] not [0xf8, 0xfc, 0xf8]).</p>
-
-</div>
-<h2 id="get_RGBA_pixel_format_pixel">get_RGBA(pixel_format,pixel)</h2>
-<div id="get_RGBA_pixel_format_pixel_CONTENT">
-<p>Gets RGBA values from a pixel in the specified pixel format.
-This function uses the entire 8-bit [0..255] range when converting color components from pixel formats with less than 8-bits per RGB
-component (e.g., a completely white pixel in 16-bit RGB565 format would return [0xff, 0xff, 0xff] not [0xf8, 0xfc, 0xf8]).</p>
-<p>If the surface has no alpha component, the alpha will be returned as 0xff (100% opaque). </p>
-
-</div>
-<h2 id="create_RGB_surface_from">create_RGB_surface_from ***</h2>
-<div id="create_RGB_surface_from_CONTENT">
-<p>Creates an empty SDL::Surface from pixel data
-Allocate an empty surface (must be called after SDL::set_video_mode)
-If bitsPerPixel is 8 an empty palette is allocated for the surface, otherwise a 'packed-pixel' SDL::pixel_format is created using the
-[RGBA]mask's provided (see SDL::pixel_format). The flags specifies the type of surface that should be created, it is an OR'd combination
-of the following possible values. </p>
-<dl>
- <dt>SDL_SWSURFACE</dt>
- <dd>
- <p>SDL will create the surface in system memory.
-This improves the performance of pixel level access, however you may not be able to take advantage of some types of hardware blitting.</p>
- </dd>
- <dt>SDL_HWSURFACE</dt>
- <dd>
- <p>SDL will attempt to create the surface in video memory.
-This will allow SDL to take advantage of Video->Video blits (which are often accelerated).</p>
- </dd>
- <dt>SDL_SRCCOLORKEY</dt>
- <dd>
- <p>This flag turns on color keying for blits from this surface.
-If SDL_HWSURFACE is also specified and color keyed blits are hardware-accelerated, then SDL will attempt to place the surface in video memory.
-If the screen is a hardware surface and color keyed blits are hardware-accelerated then the SDL_HWSURFACE flag will be set.
-Use SDL_SetColorKey to set or clear this flag after surface creation.</p>
- </dd>
- <dt>SDL_SRCALPHA</dt>
- <dd>
- <p>This flag turns on alpha-blending for blits from this surface.
-If SDL_HWSURFACE is also specified and alpha-blending blits are hardware-accelerated,
-then the surface will be placed in video memory if possible.
-If the screen is a hardware surface and alpha-blending blits are hardware-accelerated then the SDL_HWSURFACE flag will be set.
-Use SDL_SetAlpha to set or clear this flag after surface creation.</p>
- </dd>
-</dl>
-
-
-
-
-<p>[RGBA]mask are the bitmasks used to extract that colour from a pixel.
-For instance, Rmask being FF000000 means the red data is stored in the most significant byte.
-Using zeros for the RGB masks sets a default value, based on the depth. (e.g. SDL::create_RGB_surface(flags,w,h,32,0,0,0,0);).
-However, using zero for the Amask results in an Amask of 0.
-It returns a SDL::Surface on success or undef on error.
-Notes: If an alpha-channel is specified (that is, if Amask is nonzero), then the SDL_SRCALPHA flag is automatically set.
-You may remove this flag by calling SDL::set_alpha after surface creation.
-Also, if the SDL_HWSURFACE flag is set on the returned surface, its format might not match the requested format. </p>
-<p>Notes: Sometimes specifying an Alpha mask value could cause strange results.
-This can be worked around by setting the Amask parameter to 0, but still including the SDL_SRCALPHA flag, and then using SDL::set_alpha,
-also with the SDL_SRCALPHA flag. </p>
-
-</div>
-<h2 id="lock_surface_surface">lock_surface(surface)</h2>
-<div id="lock_surface_surface_CONTENT">
-<p>SDL::lock_surface sets up the given SDL::surface for directly accessing the pixels.
-Between calls to SDL::lock_surface and SDL::unlock_surface, you can write to and read from surface->pixels, using the pixel format stored
-in surface->format.
-Once you are done accessing the surface, you should use SDL::unlock_surface to release the lock.</p>
-<p>Not all surfaces require locking. If SDL::MUSTLOCK(surface) evaluates to 0, then reading and writing pixels to the surface can be performed
-at any time, and the pixel format of the surface will not change.
-No operating system or library calls should be made between the lock/unlock pairs, as critical system locks may be held during this time.
-SDL::lock_surface returns 0 on success or -1 on error.</p>
-<p>Note : Since SDL 1.1.8, the surface locks are recursive. This means that you can lock a surface multiple times, but each lock must have
-a matching unlock.</p>
-
-</div>
-<h2 id="unlock_surface_surface">unlock_surface(surface)</h2>
-<div id="unlock_surface_surface_CONTENT">
-<p>Surfaces that were previously locked using SDL::lock_surface must be unlocked with SDL::unlock_surface. Surfaces should be unlocked as
-soon as possible.
-SDL::unlock_surface doesn't return anything.</p>
-<p>Note : Since 1.1.8, the surface locks are recursive. See <code>SDL::lock_surface</code> for more information. </p>
-
-</div>
<h2 id="convert_surface_surface_format_flags">convert_surface(surface,format,flags)</h2>
<div id="convert_surface_surface_format_flags-2">
<p>Creates a new SDL::surface of the specified SDL::pixel_format, and then copies and maps the given surface to it.
-
-
-
</div>
<h2 id="save_BMP_surface_filename">save_BMP(surface,filename)</h2>
<div id="save_BMP_surface_filename_CONTENT">
<p>SDL::set_alpha returns 0 on success or -1 on error.</p>
</div>
+<h2 id="fill_rect_dest_dest_rect_pixel">fill_rect(dest,dest_rect,pixel)</h2>
+<div id="fill_rect_dest_dest_rect_pixel_CONTE">
+<p>This function performs a fast fill of the given SDL::rectangle with the given SDL::pixel_format. If dstrect is NULL, the whole surface
+will be filled with color.</p>
+<p>The color should be a pixel of the format used by the surface, and can be generated by the SDL::MapRGB or SDL::map_RGBA functions.
+If the color value contains an alpha value then the destination is simply "filled" with that alpha information, no blending takes place.</p>
+<p>If there is a clip rectangle set on the destination (set via SDL::set_clip_rect), then this function will clip based on the intersection
+of the clip rectangle and the dstrect rectangle, and the dstrect rectangle will be modified to represent the area actually filled.</p>
+<p>If you call this on the video surface (ie: the value of SDL::get_video_surface()) you may have to update the video surface to see the
+result. This can happen if you are using a shadowed surface that is not double buffered in Windows XP using build 1.2.9. </p>
+<p>SDL::fill_rect returns 0 on success or -1 on error.</p>
+
+</div>
+<h1 id="Surface_locking_and_unlocking">Surface locking and unlocking</h1><p><a href="#TOP" class="toplink">Top</a></p>
+<div id="Surface_locking_and_unlocking_CONTEN">
+
+</div>
+<h2 id="lock_surface_surface">lock_surface(surface)</h2>
+<div id="lock_surface_surface_CONTENT">
+<pre> int SDL::Video::lock_surface( $surface );
+
+</pre>
+<p><code>SDL::Video::lock_surface</code> sets up the given <a href="/SDL-Surface.html">SDL::Surface</a> for directly accessing the pixels.
+Between calls to SDL::lock_surface and SDL::unlock_surface, you can write to ( <code>surface-</code>set_pixels>) and read from ( <code>surface-</code>get_pixels> ),
+using the pixel format stored in <code>surface-</code>format>.
+Once you are done accessing the surface, you should use <code>SDL::Video::unlock_surface</code> to release the lock.</p>
+<p>Not all surfaces require locking. If <code>SDL::Video::MUSTLOCK(surface)</code> evaluates to <code>0</code>, then reading and writing pixels to the surface can
+be performed at any time, and the pixel format of the surface will not change.
+No operating system or library calls should be made between the lock/unlock pairs, as critical system locks may be held during this time.
+<code>SDL::Video::lock_surface</code> returns <code>0</code> on success or <code>-1</code> on error.</p>
+<p><strong>Note</strong>: Since SDL 1.1.8, the surface locks are recursive. This means that you can lock a surface multiple times, but each lock must have
+a matching unlock.</p>
+<pre> use SDL;
+ use SDL::Video;
+ use SDL::Surface;
+
+ SDL::init(SDL_INIT_VIDEO);
+
+ my $screen_surface = SDL::Video::set_video_mode(640, 480, 16, SDL_HWSURFACE);
+
+ if(SDL::Video::MUSTLOCK($screen_surface))
+ {
+ print( "the surface must be locked\n" );
+
+ if(0 == SDL::Video::lock_surface($screen_surface))
+ {
+ print( "lock succesful\n" );
+ }
+ else
+ {
+ print( "error while locking surface" );
+ }
+
+ # pixel manipulation goes here
+
+ SDL::Video::unlock_surface($screen_surface); # unlock_surface returns nothing
+ }
+ else
+ {
+ print( "the surface need not to be locked" );
+ }
+
+ SDL::quit();
+
+</pre>
+
+</div>
+<h2 id="unlock_surface_surface">unlock_surface(surface)</h2>
+<div id="unlock_surface_surface_CONTENT">
+<pre> void SDL::Video::unlock_surface( $surface );
+
+</pre>
+<p>Surfaces that were previously locked using <code>SDL::Video::lock_surface</code> must be unlocked with <code>SDL::Video::unlock_surface</code>. Surfaces should
+be unlocked as soon as possible.
+<code>SDL::Video::unlock_surface</code> doesn't return anything.</p>
+<p><strong>Note</strong>: Since 1.1.8, the surface locks are recursive. See <code>SDL::Video::lock_surface</code> for more information. </p>
+
+</div>
+<h2 id="MUSTLOCK_surface">MUSTLOCK(surface)</h2>
+<div id="MUSTLOCK_surface_CONTENT">
+<pre> int SDL::Video::MUSTLOCK( $surface );
+
+</pre>
+<p><code>MUSTLOCK</code> returns <code>0</code> if the surface does not have to be locked during pixel operations, otherwise <code>1</code>.</p>
+
+</div>
+<h1 id="Screen_Updating_Functions">Screen Updating Functions</h1><p><a href="#TOP" class="toplink">Top</a></p>
+<div id="Screen_Updating_Functions_CONTENT">
+
+</div>
<h2 id="set_clip_rect_surface_rect">set_clip_rect(surface,rect)</h2>
<div id="set_clip_rect_surface_rect_CONTENT">
<p>Sets the clipping rectangle for the given SDL::surface. When this surface is the destination of a blit, only the area within the clip
SDL::blit_surface doesn't returns anything.</p>
</div>
-<h2 id="fill_rect_dest_dest_rect_pixel">fill_rect(dest,dest_rect,pixel)</h2>
-<div id="fill_rect_dest_dest_rect_pixel_CONTE">
-<p>This function performs a fast fill of the given SDL::rectangle with the given SDL::pixel_format. If dstrect is NULL, the whole surface
-will be filled with color.</p>
-<p>The color should be a pixel of the format used by the surface, and can be generated by the SDL::MapRGB or SDL::map_RGBA functions.
-If the color value contains an alpha value then the destination is simply "filled" with that alpha information, no blending takes place.</p>
-<p>If there is a clip rectangle set on the destination (set via SDL::set_clip_rect), then this function will clip based on the intersection
-of the clip rectangle and the dstrect rectangle, and the dstrect rectangle will be modified to represent the area actually filled.</p>
-<p>If you call this on the video surface (ie: the value of SDL::get_video_surface()) you may have to update the video surface to see the
-result. This can happen if you are using a shadowed surface that is not double buffered in Windows XP using build 1.2.9. </p>
-<p>SDL::fill_rect returns 0 on success or -1 on error.</p>
+<h2 id="update_rect_surface_x_y_width_height">update_rect(surface,x,y,width,height)</h2>
+<div id="update_rect_surface_x_y_width_height-2">
+<pre> update_rect( $surface, $left, $top, $width, $height );
+
+</pre>
+<p>Makes sure the given area is updated on the given screen.
+The rectangle must be confined within the screen boundaries because there's no clipping.
+update_rect doesn't returns any value.</p>
+<p><strong>Note</strong>: This function should not be called while screen is locked by <a href="#lock_surface_surface">SDL::Video::lock_surface</a></p>
+<p><strong>Note2</strong>: If <code>x</code>, <code>y</code>, <code>width</code> and <code>height</code> are all equal to 0, <code>update_rect</code> will update the entire screen. </p>
+<p>For an example see <a href="#SYNOPSIS">SYNOPSIS</a></p>
+
+</div>
+<h2 id="update_rects_surface_rects">update_rects(surface,rects) </h2>
+<div id="update_rects_surface_rects_CONTENT">
+<pre> update_rects( $surface, @rects );
+
+</pre>
+<p>Makes sure the given list of rectangles is updated on the given screen.
+The rectangle must be confined within the screen boundaries because there's no clipping.
+<code>update_rects</code> doesn't returns any value.</p>
+<p><strong>Note</strong>: This function should not be called while screen is locked by <a href="#lock_surface_surface">SDL::Video::lock_surface</a>.</p>
+<p>Example:</p>
+<pre> use SDL;
+ use SDL::Video;
+ use SDL::Surface;
+ use SDL::Rect;
+
+ # the size of the window box or the screen resolution if fullscreen
+ my $screen_width = 800;
+ my $screen_height = 600;
+
+ SDL::init(SDL_INIT_VIDEO);
+
+ # setting video mode
+ my $screen_surface = SDL::Video::set_video_mode($screen_width, $screen_height, 32, SDL_SWSURFACE);
+
+ # drawing the whole screen blue
+ my $mapped_color = SDL::Video::map_RGB($screen_surface->format(), 0, 0, 255); # blue
+ SDL::Video::fill_rect($screen_surface,
+ SDL::Rect->new(0, 0, $screen_width, $screen_height),
+ $mapped_color);
+
+ my @rects = ();
+ push(@rects, SDL::Rect->new(200, 0, 400, 600));
+ push(@rects, SDL::Rect->new( 0, 150, 800, 300));
+
+ # updating parts of the screen (should look like a cross)
+ SDL::Video::update_rects($screen_surface, @rects);
+
+ sleep(2);
+
+ SDL::quit();
+
+</pre>
+
+</div>
+<h2 id="flip_surface">flip(surface)</h2>
+<div id="flip_surface_CONTENT">
+<pre> $flip = SDL::Video::flip( $screen_surface );
+
+</pre>
+<p>On hardware that supports double-buffering, this function sets up a flip and returns.
+The hardware will wait for vertical retrace, and then swap video buffers before the next video surface blit or lock will return.
+On hardware that doesn't support double-buffering or if <code>SDL_SWSURFACE</code> was set, this is equivalent to calling
+<code>SDL::Video::update_rect( $screen, 0, 0, 0, 0 )</code>.</p>
+<p>A software screen surface is also updated automatically when parts of a SDL window are redrawn, caused by overlapping windows or by
+restoring from an iconified state. As a result there is no proper double buffer behavior in windowed mode for a software screen, in
+contrast to a full screen software mode.</p>
+<p>The <code>SDL_DOUBLEBUF</code> flag must have been passed to <code>SDL::Video::set_video_mode</code>, when setting the video mode for this function to
+perform hardware flipping.</p>
+<p><code>flip</code> returns <code>0</code> on success or <code>-1</code> on error.</p>
+<p><strong>Note</strong>: If you want to swap the buffers of an initialized OpenGL context, use the function <code>SDL::Video::GL_swap_buffers</code> instead. </p>
+<p>Example:</p>
+<pre> use SDL;
+ use SDL::Video;
+ use SDL::Surface;
+
+ # the size of the window box or the screen resolution if fullscreen
+ my $screen_width = 800;
+ my $screen_height = 600;
+
+ SDL::init(SDL_INIT_VIDEO);
+
+ # setting video mode
+ my $screen_surface = SDL::Video::set_video_mode($screen_width, $screen_height, 32, SDL_DOUBLEBUF|SDL_FULLSCREEN);
+
+ # do some video operations here
+
+ # doing page flipping
+ unless( SDL::Video::flip($screen_surface) == 0 )
+ {
+ printf( STDERR "failed to swap buffers: %s\n", SDL::get_error() );
+ }
+
+ SDL::quit();
+
+</pre>
+
+</div>
+<h1 id="Palette_Color_and_Pixel_Functions">Palette, Color and Pixel Functions</h1><p><a href="#TOP" class="toplink">Top</a></p>
+<div id="Palette_Color_and_Pixel_Functions_CO">
+
+</div>
+<h2 id="set_colors_surface_start_colors">set_colors(surface,start,colors)</h2>
+<div id="set_colors_surface_start_colors_CONT">
+<pre> $set_colors = SDL::Video::set_colors( $surface, $start, $color1, $color2, ... )
+
+</pre>
+<p>Sets a portion of the colormap for the given 8-bit surface. </p>
+<p>When surface is the surface associated with the current display, the display colormap will be updated with the requested colors.
+If <code>SDL_HWPALETTE</code> was set in <code>SDL::Video::set_video_mode</code> flags, <code>SDL::Video::set_colors</code> will always return 1, and the palette is
+guaranteed to be set the way you desire, even if the window colormap has to be warped or run under emulation.
+The color components of a <a href="/SDL-Color.html">SDL::Color</a> structure are 8-bits in size, giving you a total of 2563 = 16777216 colors.
+Palettized (8-bit) screen surfaces with the <code>SDL_HWPALETTE</code> flag have two palettes, a logical palette that is used for mapping blits to/from
+the surface and a physical palette (that determines how the hardware will map the colors to the display).
+<code>SDL::Video::set_colors</code> modifies both palettes (if present), and is equivalent to calling <code>SDL::Video::set_palette</code> with the flags set to
+( <code>SDL_LOGPAL | SDL_PHYSPAL</code> ). </p>
+<p>If <code>surface</code> is not a palettized surface, this function does nothing, returning 0.
+If all of the colors were set as passed to <code>SDL::Video::set_colors</code>, it will return 1.
+If not all the color entries were set exactly as given, it will return 0, and you should look at the surface palette to determine the
+actual color palette.</p>
+
+</div>
+<h2 id="set_palette_surface_flags_start_colo">set_palette(surface,flags,start,colors)</h2>
+<div id="set_palette_surface_flags_start_colo-2">
+<pre> $set_palette = set_palette( $surface, $flags, $start, $color1, $color2, ... );
+
+</pre>
+<p>Sets a portion of the palette for the given 8-bit surface.</p>
+<p>Palettized (8-bit) screen surfaces with the <code>SDL_HWPALETTE</code> flag have two palettes, a logical palette that is used for mapping blits to/from
+the surface and a physical palette (that determines how the hardware will map the colors to the display).
+Non screen surfaces have a logical palette only. <code>SDL::Video::blit</code> always uses the logical palette when blitting surfaces (if it has to
+convert between surface pixel formats). Because of this, it is often useful to modify only one or the other palette to achieve various
+special color effects (e.g., screen fading, color flashes, screen dimming).</p>
+<p>This function can modify either the logical or physical palette by specifying <code>SDL_LOGPAL</code> or <code>SDL_PHYSPAL</code> the in the flags parameter.</p>
+<p>When surface is the surface associated with the current display, the display colormap will be updated with the requested colors.
+If <code>SDL_HWPALETTE</code> was set in <code>SDL::Video::set_video_mode</code> flags, <code>SDL::Video::set_palette</code> will always return 1, and the palette is
+guaranteed to be set the way you desire, even if the window colormap has to be warped or run under emulation.
+The color components of a <code>SDL::Color</code> structure are 8-bits in size, giving you a total of 2563 = 16777216 colors. </p>
+<p>If <code>surface</code> is not a palettized surface, this function does nothing, returning <code>0</code>. If all of the colors were set as passed to <code>set_palette</code>,
+it will return <code>1</code>. If not all the color entries were set exactly as given, it will return <code>0</code>, and you should look at the surface palette
+to determine the actual color palette.</p>
+
+</div>
+<h2 id="set_gamma_r_g_b">set_gamma(r,g,b)</h2>
+<div id="set_gamma_r_g_b_CONTENT">
+<pre> $set_gamma = SDL::Video::set_gamma( $red_gamma, $green_gamma, $blue_gamma );
+
+</pre>
+<p>Sets the "gamma function" for the display of each color component. Gamma controls the brightness/contrast of colors displayed on the screen.
+A gamma value of 1.0 is identity (i.e., no adjustment is made).</p>
+<p>This function adjusts the gamma based on the "gamma function" parameter, you can directly specify lookup tables for gamma adjustment
+with SDL::set_gamma_ramp.</p>
+<p><strong>Note</strong>: Not all display hardware is able to change gamma.</p>
+<p><code>SDL::Video::set_gamma</code> returns <code>-1</code> on error.</p>
+<p><strong>Warning</strong>: Under Linux (X.org Gnome and Xfce), gamma settings affects the entire display (including the desktop)! </p>
+<p>Example:</p>
+<pre> use SDL;
+ use SDL::Video;
+ use SDL::Surface;
+ use SDL::Rect;
+ use Time::HiRes qw( usleep );
+
+ # the size of the window box or the screen resolution if fullscreen
+ my $screen_width = 800;
+ my $screen_height = 600;
+
+ SDL::init(SDL_INIT_VIDEO);
+
+ # setting video mode
+ my $screen_surface = SDL::Video::set_video_mode($screen_width, $screen_height, 32, SDL_SWSURFACE);
+
+ # drawing something somewhere
+ my $mapped_color = SDL::Video::map_RGB($screen_surface->format(), 128, 128, 128); # gray
+ SDL::Video::fill_rect($screen_surface,
+ SDL::Rect->new($screen_width / 4, $screen_height / 4, $screen_width / 2, $screen_height / 2),
+ $mapped_color);
+
+ # update the whole screen
+ SDL::Video::update_rect($screen_surface, 0, 0, $screen_width, $screen_height);
+
+ usleep(500000);
+
+ for(1..20)
+ {
+ SDL::Video::set_gamma( 1 - $_ / 20, 1, 1 );
+ usleep(40000);
+ }
+
+ for(1..20)
+ {
+ SDL::Video::set_gamma( $_ / 20, 1, 1 );
+ usleep(40000);
+ }
+
+ SDL::Video::set_gamma( 1, 1, 1 );
+
+ usleep(500000);
+
+ SDL::quit();
+
+</pre>
+
+</div>
+<h2 id="get_gamma_ramp_rt_gt_bt">get_gamma_ramp(rt,gt,bt)</h2>
+<div id="get_gamma_ramp_rt_gt_bt_CONTENT">
+<pre> $get_gamma_ramp = SDL::Video::get_gamma_ramp( \@red_table, \@green_table, \@blue_table );
+
+</pre>
+<p>Gets the gamma translation lookup tables currently used by the display. Each table is an array of 256 Uint16 values.
+SDL::get_gamma_ramp returns -1 on error.</p>
+<pre> use SDL;
+ use SDL::Video;
+
+ SDL::init(SDL_INIT_VIDEO);
+
+ my (@red, @green, @blue);
+
+ my $ret = SDL::Video::get_gamma_ramp( \@red, \@green, \@blue );
+
+ if( -1 == $ret )
+ {
+ print( "an error occoured" );
+ }
+ else
+ {
+ printf( "for gamma = 1.0: red=0x%04X, green=0x%04X, blue=0x%04X\n", $red[255], $green[255], $blue[255] );
+ printf( "for gamma = 0.5: red=0x%04X, green=0x%04X, blue=0x%04X\n", $red[127], $green[127], $blue[127] );
+ printf( "for gamma = 0.0: red=0x%04X, green=0x%04X, blue=0x%04X\n", $red[0], $green[0], $blue[0] );
+ }
+
+ SDL::quit();
+
+</pre>
+
+</div>
+<h2 id="set_gamma_ramp_rt_gt_bt">set_gamma_ramp(rt,gt,bt)</h2>
+<div id="set_gamma_ramp_rt_gt_bt_CONTENT">
+<pre> $set_gamma_ramp = SDL::Video::set_gamma_ramp( \@red_table, \@green_table, \@blue_table );
+
+</pre>
+<p>Sets the gamma lookup tables for the display for each color component. Each table is an array ref of 256 Uint16 values, representing a
+mapping between the input and output for that channel.
+The input is the index into the array, and the output is the 16-bit gamma value at that index, scaled to the output color precision.
+You may pass NULL to any of the channels to leave them unchanged.</p>
+<p>This function adjusts the gamma based on lookup tables, you can also have the gamma calculated based on a "gamma function" parameter
+with <code>SDL::Video::set_gamma</code>.</p>
+<p>Not all display hardware is able to change gamma.
+<code>SDL::Video::set_gamma_ramp</code> returns <code>-1</code> on error (or if gamma adjustment is not supported).</p>
+<p>Example:</p>
+<pre> use SDL;
+ use SDL::Video;
+
+ SDL::init(SDL_INIT_VIDEO);
+
+ my (@red, @green, @blue);
+
+ my $ret = SDL::Video::get_gamma_ramp( \@red, \@green, \@blue );
+
+ $red[127] = 0xFF00;
+
+ $ret = SDL::Video::set_gamma_ramp( \@red, \@green, \@blue );
+
+ $ret = SDL::Video::get_gamma_ramp( \@red, \@green, \@blue );
+
+ if( -1 == $ret )
+ {
+ print( "an error occoured" );
+ }
+ else
+ {
+ printf( "for gamma = 1.0: red=0x%04X, green=0x%04X, blue=0x%04X\n", $red[255], $green[255], $blue[255] );
+ printf( "for gamma = 0.5: red=0x%04X, green=0x%04X, blue=0x%04X\n", $red[127], $green[127], $blue[127] );
+ printf( "for gamma = 0.0: red=0x%04X, green=0x%04X, blue=0x%04X\n", $red[0], $green[0], $blue[0] );
+ }
+
+ SDL::quit();
+
+</pre>
+
+</div>
+<h2 id="map_RGB_pixel_format_r_g_b">map_RGB(pixel_format,r,g,b)</h2>
+<div id="map_RGB_pixel_format_r_g_b_CONTENT">
+<pre> $pixel = SDL::Video::map_RGB( $pixel_format, $r, $g, $b );
+
+</pre>
+<p>Maps the RGB color value to the specified <a href="/SDL-PixelFormat.html">SDL::PixelFormat</a> and returns the pixel value as a 32-bit int.
+If the format has a palette (8-bit) the index of the closest matching color in the palette will be returned.
+If the specified pixel format has an alpha component it will be returned as all 1 bits (fully opaque). </p>
+<p><code>SDL::Video::map_RGB</code> returns a pixel value best approximating the given RGB color value for a given pixel format.
+If the <a href="/SDL-PixelFormat.html">SDL::PixelFormat</a>'s bpp (color depth) is less than 32-bpp then the unused upper bits of the return value can safely be ignored
+(e.g., with a 16-bpp format the return value can be assigned to a Uint16, and similarly a Uint8 for an 8-bpp format).</p>
+<pre> use SDL;
+ use SDL::Video;
+ use SDL::PixelFormat;
+ use SDL::Surface;
+
+ SDL::init(SDL_INIT_VIDEO);
+
+ my $screen_surface = SDL::Video::set_video_mode(640, 480, 16, SDL_SWSURFACE);
+ # ^-- 16 bits per pixel
+
+ $r = 0x9C;
+ $g = 0xDC;
+ $b = 0x67;
+
+ printf( "for 24bpp it is: 0x%02X 0x%02X 0x%02X\n", $r, $g, $b);
+
+ my $_16bit = SDL::Video::map_RGB( $screen_surface->format, $r, $g, $b );
+
+ # 16bpp is 5 bits red, 6 bits green and 5 bits blue
+ # we will obtain the values for each color and calculating them back to 24/32bit color system
+ ($r, $g, $b) = @{ SDL::Video::get_RGB( $screen_surface->format, $_16bit ) };
+
+ printf( "for 16bpp it is: 0x%02X 0x%02X 0x%02X\n", $r, $g, $b );
+
+ # so color #9CDC67 becomes #9CDF63
+
+ SDL::quit();
+
+</pre>
+
+</div>
+<h2 id="map_RGBA_pixel_format_r_g_b_a">map_RGBA(pixel_format,r,g,b,a)</h2>
+<div id="map_RGBA_pixel_format_r_g_b_a_CONTEN">
+<pre> $pixel = SDL::Video::map_RGB( $pixel_format, $r, $g, $b, $a );
+
+</pre>
+<p>Maps the RGBA color value to the specified <a href="/SDL-PixelFormat.html">SDL::PixelFormat</a> and returns the pixel value as a 32-bit int.
+If the format has a palette (8-bit) the index of the closest matching color in the palette will be returned.
+If the specified pixel format has no alpha component the alpha value will be ignored (as it will be in formats with a palette). </p>
+<p>A pixel value best approximating the given RGBA color value for a given pixel format.
+If the pixel format bpp (color depth) is less than 32-bpp then the unused upper bits of the return value can safely be ignored (e.g.,
+with a 16-bpp format the return value can be assigned to a Uint16, and similarly a Uint8 for an 8-bpp format).</p>
+
+</div>
+<h2 id="get_RGB_pixel_format_pixel">get_RGB(pixel_format,pixel)</h2>
+<div id="get_RGB_pixel_format_pixel_CONTENT">
+<pre> $rgb_array_ref = SDL::Video::get_RGB( $pixel_format, $pixel );
+
+</pre>
+<p>Returns RGB values from a pixel in the specified pixel format. The pixel is an integer (e.g. 16bit RGB565, 24/32bit RGB888).
+This function uses the entire 8-bit [0..255] range when converting color components from pixel formats with less than 8-bits per RGB
+component (e.g., a completely white pixel in 16-bit RGB565 format would return [0xff, 0xff, 0xff] not [0xf8, 0xfc, 0xf8]).</p>
+<p>For an example see <code>SDL::Video::map_RGB</code>.</p>
+
+</div>
+<h2 id="get_RGBA_pixel_format_pixel">get_RGBA(pixel_format,pixel)</h2>
+<div id="get_RGBA_pixel_format_pixel_CONTENT">
+<pre> $rgba_array_ref = SDL::Video::get_RGBA( $pixel_format, $pixel );
+
+</pre>
+<p>Gets RGBA values from a pixel in the specified pixel format.
+This function uses the entire 8-bit [0..255] range when converting color components from pixel formats with less than 8-bits per RGB
+component (e.g., a completely white pixel in 16-bit RGB565 format would return [0xff, 0xff, 0xff] not [0xf8, 0xfc, 0xf8]).</p>
+<p>If the surface has no alpha component, the alpha will be returned as 0xff (100% opaque). </p>
+
+</div>
+<h1 id="GL_Methods">GL Methods</h1><p><a href="#TOP" class="toplink">Top</a></p>
+<div id="GL_Methods_CONTENT">
</div>
<h2 id="GL_load_library_path">GL_load_library(path)</h2>
</div>
+<h1 id="Video_Overlay_Functions">Video Overlay Functions</h1><p><a href="#TOP" class="toplink">Top</a></p>
+<div id="Video_Overlay_Functions_CONTENT">
+<p>see <a href="/SDL-Overlay.html">SDL::Overlay</a> </p>
+
+</div>
<h2 id="lock_YUV_overlay_overlay">lock_YUV_overlay(overlay)</h2>
<div id="lock_YUV_overlay_overlay_CONTENT">
<p>Much the same as <code>SDL::lock_surface</code>, SDL::lock_YUV_overlay locks the overlay for direct access to pixel data.
The overlay is scaled (independently in x and y dimensions) to the size specified by dstrect, and is optimized for 2x scaling</p>
<p>It returns 0 on success or -1 on error.</p>
+</div>
+<h1 id="Window_Management_Functions">Window Management Functions</h1><p><a href="#TOP" class="toplink">Top</a></p>
+<div id="Window_Management_Functions_CONTENT">
+</div>
+<h2 id="wm_set_caption_title_icon">wm_set_caption(title,icon)</h2>
+<div id="wm_set_caption_title_icon_CONTENT">
+</div>
+<h2 id="wm_get_caption">wm_get_caption()</h2>
+<div id="wm_get_caption_CONTENT">
+
+</div>
+<h2 id="wm_set_icon_icon">wm_set_icon(icon)</h2>
+<div id="wm_set_icon_icon_CONTENT">
+
+</div>
+<h2 id="wm_grab_input_mode">wm_grab_input(mode)</h2>
+<div id="wm_grab_input_mode_CONTENT">
+
+</div>
+<h2 id="wm_iconify_window">wm_iconify_window()</h2>
+<div id="wm_iconify_window_CONTENT">
+</div>
+<h2 id="wm_toggle_fullscreen_surface">wm_toggle_fullscreen(surface)</h2>
+<div id="wm_toggle_fullscreen_surface_CONTENT">
</div>
<h1 id="SEE_ALSO">SEE ALSO</h1><p><a href="#TOP" class="toplink">Top</a></p>
projects / sdlgit/SDL-Site.git / blobdiff