Class: SDL2::Window

Inherits:
Object
  • Object
show all
Defined in:
video.c,
video.c

Overview

This class represents a window.

If you want to create graphical application using Ruby/SDL, first you need to create a window.

All of methods/class methods are available only after initializing video subsystem by init.

Defined Under Namespace

Modules: Flags

Constant Summary

POS_CENTERED =

Indicate that you don’t care what the window position is

INT2NUM(SDL_WINDOWPOS_CENTERED)
POS_UNDEFINED =

Indicate that the window position should be centered

INT2NUM(SDL_WINDOWPOS_UNDEFINED)

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.all_windows ⇒ Hash<Integer => SDL2::Window>

Get all windows under SDL.

Returns:



394
395
396
397
 
# File 'video.c', line 394

static VALUE Window_s_all_windows(VALUE self)
{
    return rb_hash_dup(hash_windowid_to_window);
}

.create(title, x, y, w, h, flags) ⇒ SDL2::Window

Create a window with the specified position (x,y), dimensions (w,h) and flags.

Parameters:

  • x (Integer) —

    the x position of the left-top of the window

  • y (Integer) —

    the y position of the left-top of the window

  • w (Integer) —

    the width of the window

  • h (Integer) —

    the height of the window

  • flags (Integer) —

    0, or one or more Flags OR’d together

Returns:



371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
 
# File 'video.c', line 371

static VALUE Window_s_create(VALUE self, VALUE title, VALUE x, VALUE y, VALUE w, VALUE h,
                             VALUE flags)
{
    SDL_Window* window;
    VALUE win;
    title = rb_str_export_to_enc(title, rb_utf8_encoding());
    window = SDL_CreateWindow(StringValueCStr(title),
                              NUM2INT(x), NUM2INT(y), NUM2INT(w), NUM2INT(h),
                              NUM2UINT(flags));
    if (window == NULL)
        HANDLE_ERROR(-1);

    win = Window_new(window);
    rb_hash_aset(hash_windowid_to_window, UINT2NUM(SDL_GetWindowID(window)), win);
    return win;
}

.find_by_id(id) ⇒ SDL2::Window?

Get the window from ID.

Parameters:

  • id (Integer) —

    the window id you want to find

Returns:

  • (SDL2::Window) —

    the window associated with id

  • (nil) —

    when no window is associated with id



408
409
410
411
 
# File 'video.c', line 408

static VALUE Window_s_find_by_id(VALUE self, VALUE id)
{
    return rb_hash_aref(hash_windowid_to_window, id);
}

Instance Method Details

#bordered ⇒ Boolean

Return true if the window is bordered

Returns:

  • (Boolean)

See Also:



753
754
755
756
 
# File 'video.c', line 753

static VALUE Window_bordered(VALUE self)
{
    return INT2BOOL(!(SDL_GetWindowFlags(Get_SDL_Window(self)) & SDL_WINDOW_BORDERLESS));
}

#bordered=(bordered) ⇒ bordered

Set the border state of the window.

Parameters:

  • bordered (Boolean) —

    true for bordered window, anad false for borderless window

Returns:

See Also:



769
770
771
772
773
 
# File 'video.c', line 769

static VALUE Window_set_bordered(VALUE self, VALUE bordered)
{
    SDL_SetWindowBordered(Get_SDL_Window(self), RTEST(bordered));
    return bordered;
}

#brightness ⇒ Float

Get the brightness (gamma correction) of the window.

Returns:

  • (Float) —

    the brightness

See Also:



508
509
510
511
 
# File 'video.c', line 508

static VALUE Window_brightness(VALUE self)
{
    return DBL2NUM(SDL_GetWindowBrightness(Get_SDL_Window(self)));
}

#brightness=(brightness) ⇒ brightness

Set the brightness (gamma correction) of the window.

Parameters:

  • brightness (Float) —

    the brightness, 0.0 means complete dark and 1.0 means normal brightness.

Returns:

See Also:



523
524
525
526
527
 
# File 'video.c', line 523

static VALUE Window_set_brightness(VALUE self, VALUE brightness)
{
    HANDLE_ERROR(SDL_SetWindowBrightness(Get_SDL_Window(self), NUM2DBL(brightness)));
    return brightness;
}

#create_renderer(index, flags) ⇒ SDL2::Renderer

Create a 2D rendering context for a window.

Parameters:

  • index (Integer) —

    the index of the rendering driver to initialize, or -1 to initialize the first one supporting the requested flags

  • flags (Integer) —

    0, or one or more Flags OR’d together

Returns:



443
444
445
446
447
448
449
450
451
452
453
454
455
 
# File 'video.c', line 443

static VALUE Window_create_renderer(VALUE self, VALUE index, VALUE flags)
{
    SDL_Renderer* sdl_renderer;
    VALUE renderer;
    sdl_renderer = SDL_CreateRenderer(Get_SDL_Window(self), NUM2INT(index), NUM2UINT(flags));

    if (sdl_renderer == NULL)
        HANDLE_ERROR(-1);

    renderer = Renderer_new(sdl_renderer, Get_Window(self));
    rb_iv_set(self, "renderer", renderer);
    return renderer;
}

#debug_info ⇒ Hash

Returns (GC) debug information

Returns:

  • (Hash) —

    (GC) debug information



933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
 
# File 'video.c', line 933

static VALUE Window_debug_info(VALUE self)
{
    Window* w = Get_Window(self);
    VALUE info = rb_hash_new();
    int num_active_renderers = 0;
    int i;
    rb_hash_aset(info, rb_str_new2("destroy?"), INT2BOOL(w->window == NULL));
    rb_hash_aset(info, rb_str_new2("max_renderers"), INT2NUM(w->max_renderers));
    rb_hash_aset(info, rb_str_new2("num_renderers"), INT2NUM(w->num_renderers));
    for (i=0; i<w->num_renderers; ++i)
        if (w->renderers[i]->renderer)
            ++num_active_renderers;
    rb_hash_aset(info, rb_str_new2("num_active_renderers"), INT2NUM(num_active_renderers));

    return info;
}

#destroy ⇒ void

This method returns an undefined value.

Destroy window.

You cannot call almost all methods after calling this method. The exception is #destroy?.



427
428
429
430
431
 
# File 'video.c', line 427

static VALUE Window_destroy(VALUE self)
{
    Window_destroy_internal(Get_Window(self));
    return Qnil;
}

#destroy? ⇒ Boolean

Return true if the window is already destroyed.

Returns:

  • (Boolean)

#display ⇒ SDL2::Display

Get the display associated with the window.

Returns:



496
497
498
499
500
 
# File 'video.c', line 496

static VALUE Window_display(VALUE self)
{
    int display_index = HANDLE_ERROR(SDL_GetWindowDisplayIndex(Get_SDL_Window(self)));
    return Display_new(display_index);
}

#display_mode ⇒ SDL2::Window::Mode

Get information about the window.

Returns:

  • (SDL2::Window::Mode) 


484
485
486
487
488
489
 
# File 'video.c', line 484

static VALUE Window_display_mode(VALUE self)
{
    SDL_DisplayMode mode;
    HANDLE_ERROR(SDL_GetWindowDisplayMode(Get_SDL_Window(self), &mode));
    return DisplayMode_new(&mode);
}

#flags ⇒ Integer

Get the Window flag masks of the window.

Returns:

  • (Integer) —

    flags

See Also:



535
536
537
538
 
# File 'video.c', line 535

static VALUE Window_flags(VALUE self)
{
    return UINT2NUM(SDL_GetWindowFlags(Get_SDL_Window(self)));
}

#fullscreen_mode ⇒ Integer

Get the fullscreen stete of the window

Returns:

See Also:



872
873
874
875
876
 
# File 'video.c', line 872

static VALUE Window_fullscreen_mode(VALUE self)
{
    Uint32 flags = SDL_GetWindowFlags(Get_SDL_Window(self));
    return UINT2NUM(flags & (SDL_WINDOW_FULLSCREEN|SDL_WINDOW_FULLSCREEN_DESKTOP));
}

#fullscreen_mode=(flag) ⇒ flag

Set the fullscreen state of the window

Parameters:

  • flag (Integer) —

    0 for window mode, SDL2::Window::Flags::FULLSCREEN for fullscreen mode, and Flags::Window::FULLSCREEN_DESKTOP for fullscreen at the current desktop resolution.

Returns:

  • (flag)

See Also:



889
890
891
892
893
 
# File 'video.c', line 889

static VALUE Window_set_fullscreen_mode(VALUE self, VALUE flags)
{
    HANDLE_ERROR(SDL_SetWindowFullscreen(Get_SDL_Window(self), NUM2UINT(flags)));
    return flags;
}

#gamma_ramp ⇒ Array<Array<Integer>>

Get the gamma ramp for a window

Returns:

  • (Array<Array<Integer>>) —

    the gamma ramp, return value is red, green, and blue gamma tables and each gamma table has 256 Integers of 0-65535.



557
558
559
560
561
562
563
564
565
 
# File 'video.c', line 557

static VALUE Window_gamma_ramp(VALUE self)
{
    Uint16 r[256], g[256], b[256];
    HANDLE_ERROR(SDL_GetWindowGammaRamp(Get_SDL_Window(self), r, g, b));
    return rb_ary_new3(3,
                       gamma_table_to_Array(r),
                       gamma_table_to_Array(g),
                       gamma_table_to_Array(b));
}

#gl_drawable_size ⇒ [Integer, Integer]

Get the size of the drawable region.

Returns:

  • ([Integer, Integer]) —

    the width and height of the region



901
902
903
904
905
906
 
# File 'video.c', line 901

static VALUE Window_gl_drawable_size(VALUE self)
{
    int w, h;
    SDL_GL_GetDrawableSize(Get_SDL_Window(self), &w, &h);
    return rb_ary_new3(2, INT2NUM(w), INT2NUM(h));
}

#gl_swap ⇒ nil

Swap the OpenGL buffers for the window, if double buffering is supported.

Returns:

  • (nil) 


915
916
917
918
919
 
# File 'video.c', line 915

static VALUE Window_gl_swap(VALUE self)
{
    SDL_GL_SwapWindow(Get_SDL_Window(self));
    return Qnil;
}

#hide ⇒ nil

Hide the window.

Returns:

  • (nil)

See Also:



811
812
813
814
 
# File 'video.c', line 811

static VALUE Window_hide(VALUE self)
{
    SDL_HideWindow(Get_SDL_Window(self)); return Qnil;
};

#icon=(icon) ⇒ icon

Set the window icon.

Parameters:

Returns:

  • (icon) 


575
576
577
578
579
 
# File 'video.c', line 575

static VALUE Window_set_icon(VALUE self, VALUE icon)
{
    SDL_SetWindowIcon(Get_SDL_Window(self), Get_SDL_Surface(icon));
    return icon;
}

#input_is_grabbed=(grabbed) ⇒ grabbed

Set the window’s input grab mode.

Parameters:

  • grabbed (Boolean) —

    true to grub input, and false to release input

Returns:

  • (grabbed)

See Also:



600
601
602
603
604
 
# File 'video.c', line 600

static VALUE Window_set_input_is_grabbed(VALUE self, VALUE grabbed)
{
    SDL_SetWindowGrab(Get_SDL_Window(self), RTEST(grabbed));
    return grabbed;
}

#input_is_grabbed? ⇒ Boolean

Return true if the input is grabbed to the window.

Returns:

  • (Boolean)

See Also:



586
587
588
589
 
# File 'video.c', line 586

static VALUE Window_input_is_grabbed_p(VALUE self)
{
    return INT2BOOL(SDL_GetWindowGrab(Get_SDL_Window(self)));
}

#inspect ⇒ String

Returns inspection string

Returns:

  • (String) —

    inspection string



922
923
924
925
926
927
928
929
930
 
# File 'video.c', line 922

static VALUE Window_inspect(VALUE self)
{
    Window* w = Get_Window(self);
    if (w->window)
        return rb_sprintf("<%s:%p window_id=%d>",
                          rb_obj_classname(self), (void*)self, SDL_GetWindowID(w->window));
    else
        return rb_sprintf("<%s:%p (destroyed)>", rb_obj_classname(self), (void*)self);
}

#maximize ⇒ nil

Maximize the window.

Returns:

  • (nil)

See Also:



823
824
825
826
 
# File 'video.c', line 823

static VALUE Window_maximize(VALUE self)
{
    SDL_MaximizeWindow(Get_SDL_Window(self)); return Qnil;
};

#maximum_size ⇒ Integer

Get the maximum size of the window’s client area.

Returns:

  • (Integer, Integer) —

    maximum width and maximum height.

See Also:



629
630
631
632
 
# File 'video.c', line 629

static VALUE Window_maximum_size(VALUE self)
{
    return Window_get_int_int(SDL_GetWindowMaximumSize, self);
}

#maximum_size=(size) ⇒ size

Set the maximum size of the window’s client area.

Parameters:

  • size ([Integer, Integer]) —

    maximum width and maximum height, the both must be positive.

Returns:

See Also:



645
646
647
648
 
# File 'video.c', line 645

static VALUE Window_set_maximum_size(VALUE self, VALUE max_size)
{
    return Window_set_int_int(SDL_SetWindowMaximumSize, self, max_size);
}

#minimize ⇒ nil

Minimize the window.

Returns:

  • (nil)

See Also:



835
836
837
838
 
# File 'video.c', line 835

static VALUE Window_minimize(VALUE self)
{
    SDL_MinimizeWindow(Get_SDL_Window(self)); return Qnil;
};

#minimum_size ⇒ Integer

Get the minimum size of the window’s client area.

Returns:

  • (Integer, Integer) —

    minimum width and minimum height.

See Also:



657
658
659
660
 
# File 'video.c', line 657

static VALUE Window_minimum_size(VALUE self)
{
    return Window_get_int_int(SDL_GetWindowMinimumSize, self);
}

#minimum_size=(size) ⇒ size

Set the minimum size of the window’s client area.

Parameters:

  • size ([Integer, Integer]) —

    minimum width and minimum height, the both must be positive.

Returns:

See Also:



673
674
675
676
 
# File 'video.c', line 673

static VALUE Window_set_minimum_size(VALUE self, VALUE min_size)
{
    return Window_set_int_int(SDL_SetWindowMinimumSize, self, min_size);
}

#position ⇒ Integer

Get the position of the window.

Returns:

  • (Integer, Integer) —

    the x position and the y position

See Also:



685
686
687
688
 
# File 'video.c', line 685

static VALUE Window_position(VALUE self)
{
    return Window_get_int_int(SDL_GetWindowPosition, self);
}

#position=(xy) ⇒ size

Set the position of the window

Parameters:

Returns:

See Also:



702
703
704
705
 
# File 'video.c', line 702

static VALUE Window_set_position(VALUE self, VALUE xy)
{
    return Window_set_int_int(SDL_SetWindowPosition, self, xy);
}

#raise ⇒ nil

Raise the window above other windows and set the input focus.

Returns:

  • (nil) 


845
846
847
848
 
# File 'video.c', line 845

static VALUE Window_raise(VALUE self)
{
    SDL_RaiseWindow(Get_SDL_Window(self)); return Qnil;
};

#renderer ⇒ SDL2::Renderer?

Return the renderer associate with the window

Returns:

  • (SDL2::Renderer) —

    the associated renderer

  • (nil) —

    if no renderer is created yet



464
465
466
467
 
# File 'video.c', line 464

static VALUE Window_renderer(VALUE self)
{
    return rb_iv_get(self, "renderer");
}

#restore ⇒ nil

Restore the size and position of a minimized or maixmized window.

Returns:

  • (nil)

See Also:



857
858
859
860
 
# File 'video.c', line 857

static VALUE Window_restore(VALUE self)
{
    SDL_RestoreWindow(Get_SDL_Window(self)); return Qnil;
};

#show ⇒ nil

Show the window.

Returns:

  • (nil)

See Also:



800
801
802
803
 
# File 'video.c', line 800

static VALUE Window_show(VALUE self)
{
    SDL_ShowWindow(Get_SDL_Window(self)); return Qnil;
};

#size ⇒ [Integer, Integer]

Get the size of the window.

Returns:

  • ([Integer, Integer]) —

    the width and the height

See Also:



714
715
716
717
 
# File 'video.c', line 714

static VALUE Window_size(VALUE self)
{
    return Window_get_int_int(SDL_GetWindowSize, self);
}

#size=(size) ⇒ size

Set the size of the window.

Parameters:

  • wh ([Integer, Integer]) —

    new width and new height

Returns:

See Also:



729
730
731
732
 
# File 'video.c', line 729

static VALUE Window_set_size(VALUE self, VALUE size)
{
    return Window_set_int_int(SDL_SetWindowSize, self, size);
}

#title ⇒ String

Get the title of the window

Returns:

  • (String) —

    the title, in UTF-8 encoding

See Also:



741
742
743
744
 
# File 'video.c', line 741

static VALUE Window_title(VALUE self)
{
    return utf8str_new_cstr(SDL_GetWindowTitle(Get_SDL_Window(self)));
}

#title=(title) ⇒ title

Set the title of the window.

Parameters:

  • title (String) —

    the title

Returns:

See Also:



784
785
786
787
788
789
 
# File 'video.c', line 784

static VALUE Window_set_title(VALUE self, VALUE title)
{
    title = rb_str_export_to_enc(title, rb_utf8_encoding());
    SDL_SetWindowTitle(Get_SDL_Window(self), StringValueCStr(title));
    return Qnil;
}

#window_id ⇒ Integer

Get the numeric ID of the window.

Returns:

  • (Integer) 


474
475
476
477
 
# File 'video.c', line 474

static VALUE Window_window_id(VALUE self)
{
    return UINT2NUM(SDL_GetWindowID(Get_SDL_Window(self)));
}