lib/mnit_linux/sdl.nit

   1 # This file is part of NIT ( http://www.nitlanguage.org ).
   2 #
   3 # Copyright 2011-2013 Alexis Laferrière <alexis.laf@xymus.net>
   4 #
   5 # Licensed under the Apache License, Version 2.0 (the "License");
   6 # you may not use this file except in compliance with the License.
   7 # You may obtain a copy of the License at
   8 #
   9 #     http://www.apache.org/licenses/LICENSE-2.0
  10 #
  11 # Unless required by applicable law or agreed to in writing, software
  12 # distributed under the License is distributed on an "AS IS" BASIS,
  13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 # See the License for the specific language governing permissions and
  15 # limitations under the License.
  16
  17 # SDL display support (used in Linux for windows and inputes only)
  18 module sdl
  19
  20 import mnit # for
  21 # import display
  22 # mport input_events
  23
  24 in "C header" `{
  25 #include <unistd.h>
  26 #include <SDL/SDL.h>
  27 #include <SDL/SDL_syswm.h>
  28 #include <SDL/SDL_image.h>
  29 #include <SDL/SDL_ttf.h>
  30 `}
  31
  32 # Represent a screen surface
  33 extern SDLDisplay in "C" `{SDL_Surface *`}
  34         super Display
  35
  36         redef type I: SDLImage
  37
  38         # Initialize a surface with width and height
  39         new ( w, h: Int) is extern `{
  40                 SDL_Init(SDL_INIT_VIDEO);
  41
  42                 if(TTF_Init()==-1) {
  43                         printf("TTF_Init: %s\n", TTF_GetError());
  44                         exit(2);
  45                 }
  46
  47                 /* ignores mousemotion for performance reasons */
  48                 SDL_EventState( SDL_MOUSEMOTION, SDL_IGNORE );
  49
  50                 return SDL_SetVideoMode( w, h, 24, SDL_HWSURFACE );
  51         `}
  52
  53         # Destroy the surface
  54         fun destroy is extern `{
  55         if ( SDL_WasInit( SDL_INIT_VIDEO ) )
  56                 SDL_Quit();
  57
  58         if ( TTF_WasInit() )
  59                 TTF_Quit();
  60         `}
  61
  62         redef fun finish is extern `{ SDL_Flip( recv ); `}
  63
  64         # Clear the entire window with given RGB color (integer values)
  65         fun clear_int( r, g, b: Int ) is extern `{
  66                 SDL_FillRect( recv, NULL, SDL_MapRGB(recv->format,r,g,b) );
  67         `}
  68
  69         redef fun width: Int is extern `{ return recv->w; `}
  70         redef fun height: Int is extern `{ return recv->h; `}
  71
  72         # Fill a rectangle with given color
  73         fun fill_rect( rect: SDLRectangle, r, g, b: Int ) is extern `{
  74                 SDL_FillRect( recv, rect,  SDL_MapRGB(recv->format,r,g,b) );
  75         `}
  76
  77         redef fun clear( r, g, b: Float ) is extern `{
  78                 Uint8 ri, gi, bi;
  79                 ri = (Uint8)r*255;
  80                 gi = (Uint8)g*255;
  81                 bi = (Uint8)b*255;
  82                 SDL_FillRect( recv, NULL, SDL_MapRGB(recv->format,ri,gi,bi) );
  83         `}
  84
  85         fun events: Sequence[ IE ]
  86         do
  87                 var new_event: nullable Object = null
  88                 var events = new List[ IE ]
  89                 loop
  90                         new_event = poll_event
  91                         if new_event != null then # new_event isa Event then #
  92                                 events.add( new_event )
  93                         else
  94                                 break
  95                         end
  96                 end
  97                 return events
  98         end
  99
 100         private fun poll_event: nullable IE is extern import SDLKeyEvent, SDLMouseButtonEvent, SDLMouseMotionEvent, SDLQuitEvent, NativeString::to_s, SDLMouseButtonEvent as (nullable IE), SDLMouseMotionEvent as (nullable IE), SDLKeyEvent as (nullable IE), SDLQuitEvent as (nullable IE) `{
 101                 SDL_Event event;
 102
 103                 SDL_PumpEvents();
 104
 105                 if ( SDL_PollEvent(&event) )
 106                 {
 107                         switch (event.type ) {
 108                                 case SDL_KEYDOWN:
 109                                 case SDL_KEYUP:
 110         #ifdef DEBUG
 111                                         printf("The \"%s\" key was pressed!\n",
 112                                                    SDL_GetKeyName(event.key.keysym.sym));
 113         #endif
 114
 115                                         return SDLKeyEvent_as_nullable_InputEvent(
 116                                                         new_SDLKeyEvent( NativeString_to_s(
 117                                                                 SDL_GetKeyName(event.key.keysym.sym) ),
 118                                                                 event.type==SDL_KEYDOWN ) );
 119
 120                                 case SDL_MOUSEMOTION:
 121         #ifdef DEBUG
 122                                         printf("Mouse moved by %d,%d to (%d,%d)\n",
 123                                                    event.motion.xrel, event.motion.yrel,
 124                                                    event.motion.x, event.motion.y);
 125         #endif
 126
 127                                         return SDLMouseMotionEvent_as_nullable_InputEvent(
 128                                                         new_SDLMouseMotionEvent( event.motion.x, event.motion.y,
 129                                                                 event.motion.xrel, event.motion.yrel ) );
 130
 131                                 case SDL_MOUSEBUTTONDOWN:
 132                                 case SDL_MOUSEBUTTONUP:
 133         #ifdef DEBUG
 134                                         printf("Mouse button \"%d\" pressed at (%d,%d)\n",
 135                                                    event.button.button, event.button.x, event.button.y);
 136         #endif
 137                                         return SDLMouseButtonEvent_as_nullable_InputEvent(
 138                                                         new_SDLMouseButtonEvent( event.button.x, event.button.y,
 139                                                                 event.button.button, event.type == SDL_MOUSEBUTTONDOWN ) );
 140
 141                                 case SDL_QUIT:
 142         #ifdef DEBUG
 143                                         printf("Quit event\n");
 144         #endif
 145                                         return SDLQuitEvent_as_nullable_InputEvent( new_SDLQuitEvent() );
 146                         }
 147                 }
 148
 149                 return null_InputEvent();
 150         `}
 151
 152         # Set the position of the cursor to x,y
 153         fun warp_mouse( x,y: Int ) `{ SDL_WarpMouse( x, y ); `}
 154
 155         # Show or hide the cursor
 156         fun show_cursor( show: Bool ) `{ SDL_ShowCursor( show ); `}
 157 end
 158
 159 # Basic Drawing figures
 160 extern SDLDrawable in "C" `{SDL_Surface*`}
 161         super Drawable
 162
 163         redef type I: SDLImage
 164
 165         redef fun blit( img, x, y ) is extern `{
 166                 SDL_Rect dst;
 167                 dst.x = x;
 168                 dst.y = y;
 169                 dst.w = 0;
 170                 dst.h = 0;
 171
 172                 SDL_BlitSurface( img, NULL, recv, &dst );
 173         `}
 174
 175         redef fun blit_centered( img, x, y )
 176         do
 177                 x = x - img.width / 2
 178                 y = y - img.height / 2
 179                 blit( img, x, y )
 180         end
 181 end
 182
 183 # A drawable Image
 184 extern SDLImage in "C" `{SDL_Surface*`} # TODO remove
 185         super DrawableImage
 186         super SDLDrawable
 187
 188         # Import image from a file
 189         new from_file( path: String ) is extern import String::to_cstring `{
 190                 SDL_Surface *image = IMG_Load( String_to_cstring( path ) );
 191                 return image;
 192         `}
 193
 194
 195         new partial( original: Image, clip: SDLRectangle ) is extern `{
 196                 return NULL;
 197         `}
 198
 199         # Copy of an existing SDLImage
 200         new copy_of( image: SDLImage ) is extern `{
 201                 SDL_Surface *new_image = SDL_CreateRGBSurface( image->flags, image->w, image->h, 24,
 202                                                           0, 0, 0, 0 );
 203
 204                 SDL_Rect dst;
 205                 dst.x = 0;
 206                 dst.y = 0;
 207                 dst.w = image->w;
 208                 dst.h = image->h;
 209                 SDL_BlitSurface( image, NULL, new_image, &dst );
 210
 211                 return new_image;
 212         `}
 213
 214         # Save the image into the specified file
 215         fun save_to_file( path: String ) is extern import String::to_cstring `{ `}
 216
 217         # Destroy the image and free the memory
 218         redef fun destroy is extern `{ SDL_FreeSurface( recv ); `}
 219
 220         redef fun width: Int is extern `{ return recv->w; `}
 221         redef fun height: Int is extern `{ return recv->h; `}
 222
 223         fun is_ok: Bool do return true # TODO
 224 end
 225
 226 extern SDLRectangle in "C" `{SDL_Rect*`}
 227         new ( x: Int, y: Int, w: Int, h: Int ) is extern `{
 228                 SDL_Rect *rect = malloc( sizeof( SDL_Rect ) );
 229                 rect->x = (Sint16)x;
 230                 rect->y = (Sint16)y;
 231                 rect->w = (Uint16)w;
 232                 rect->h = (Uint16)h;
 233                 return rect;
 234         `}
 235
 236         fun x=( v: Int ) is extern `{ recv->x = (Sint16)v; `}
 237         fun x: Int is extern `{ return recv->x; `}
 238
 239         fun y=( v: Int ) is extern `{ recv->y = (Sint16)v; `}
 240         fun y: Int is extern `{ return recv->y; `}
 241
 242         fun w=( v: Int ) is extern `{ recv->w = (Uint16)v; `}
 243         fun w: Int is extern `{ return recv->w; `}
 244
 245         fun h=( v: Int ) is extern `{ recv->h = (Uint16)v; `}
 246         fun h: Int is extern `{ return recv->h; `}
 247
 248         fun destroy is extern `{ `}
 249 end
 250
 251 interface SDLInputEvent
 252         super InputEvent
 253 end
 254
 255 class SDLMouseEvent
 256         super PointerEvent
 257         super SDLInputEvent
 258
 259         redef var x: Float
 260         redef var y: Float
 261
 262         private init ( x, y: Float )
 263         do
 264                 self.x = x
 265                 self.y = y
 266         end
 267 end
 268
 269 class SDLMouseButtonEvent
 270         super SDLMouseEvent
 271
 272         var button: Int
 273
 274         redef var pressed: Bool
 275         redef fun depressed: Bool do return not pressed
 276
 277         init ( x, y: Float, button: Int, pressed: Bool )
 278         do
 279                 super( x, y )
 280
 281                 self.button = button
 282                 self.pressed = pressed
 283         end
 284
 285         redef fun to_s
 286         do
 287                 if pressed then
 288                         return "MouseButtonEvent button {button} down at {x}, {y}"
 289                 else
 290                         return "MouseButtonEvent button {button} up at {x}, {y}"
 291                 end
 292         end
 293 end
 294
 295 class SDLMouseMotionEvent
 296         super SDLMouseEvent
 297
 298         var rel_x: Float
 299         var rel_y: Float
 300
 301         init ( x, y, rel_x, rel_y: Float )
 302         do
 303                 super( x, y )
 304
 305                 self.rel_x = rel_x
 306                 self.rel_y = rel_y
 307         end
 308
 309         redef fun to_s do return "MouseMotionEvent at {x}, {y}"
 310 end
 311
 312 class SDLKeyEvent
 313         super KeyEvent
 314         super SDLInputEvent
 315
 316         var key_name: String
 317         var down: Bool
 318
 319         init ( key_name: String, down: Bool )
 320         do
 321                 self.key_name = key_name
 322                 self.down = down
 323         end
 324
 325         redef fun to_c: nullable Char
 326         do
 327                 if key_name.length == 1 then return key_name.first
 328                 return null
 329         end
 330
 331         redef fun to_s
 332         do
 333                 if down then
 334                         return "KeyboardEvent key {key_name} down"
 335                 else
 336                         return "KeyboardEvent key {key_name} up"
 337                 end
 338         end
 339
 340         redef fun is_down do return down
 341
 342         redef fun is_arrow_up do return key_name == "up"
 343         redef fun is_arrow_left do return key_name == "left"
 344         redef fun is_arrow_down do return key_name == "down"
 345         redef fun is_arrow_right do return key_name == "right"
 346 end
 347
 348 class SDLQuitEvent
 349         super SDLInputEvent
 350         super QuitEvent
 351 end
 352
 353 redef class Int
 354         fun delay is extern `{ SDL_Delay( recv ); `}
 355 end
 356
 357 extern SDLFont in "C" `{TTF_Font *`}
 358         new ( name: String, points: Int ) is extern import String::to_cstring `{
 359         char * cname = String_to_cstring( name );
 360
 361         TTF_Font *font = TTF_OpenFont( cname, (int)points);
 362         if(!font) {
 363                 printf("TTF_OpenFont: %s\n", TTF_GetError());
 364                 exit( 1 );
 365         }
 366
 367         return font;
 368         `}
 369
 370         fun destroy is extern `{ TTF_CloseFont( recv ); `}
 371
 372         fun render( text: String, r, g, b: Int ): SDLImage is extern import String::to_cstring `{
 373                 SDL_Color color;
 374                 SDL_Surface *text_surface;
 375                 char *ctext;
 376
 377                 color.r = r;
 378                 color.g = g;
 379                 color.b = b;
 380
 381                 ctext = String_to_cstring( text );
 382                 if( !(text_surface=TTF_RenderText_Blended( recv, ctext, color )) )
 383                 {
 384                         fprintf( stderr, "SDL TFF error: %s\n", TTF_GetError() );
 385                         exit( 1 );
 386                 }
 387                 else
 388                         return text_surface;
 389         `}
 390
 391         # TODO reactivate fun below when updating libsdl_ttf to 2.0.10 or above
 392         #fun outline: Int is extern # TODO check to make inline/nitside only
 393         #fun outline=( v: Int ) is extern
 394
 395         #fun kerning: Bool is extern
 396         #fun kerning=( v: Bool ) is extern
 397
 398         # Maximum pixel height of all glyphs of this font.
 399         fun height: Int is extern `{
 400                 return TTF_FontHeight( recv );
 401         `}
 402
 403         fun ascent: Int is extern `{
 404                 return TTF_FontAscent( recv );
 405         `}
 406
 407         fun descent: Int is extern `{
 408                 return TTF_FontDescent( recv );
 409         `}
 410
 411         # Get the recommended pixel height of a rendered line of text of the loaded font. This is usually larger than the Font::height.
 412         fun line_skip: Int is extern `{
 413                 return TTF_FontLineSkip( recv );
 414         `}
 415
 416         fun is_fixed_width: Bool is extern `{
 417                 return TTF_FontFaceIsFixedWidth( recv );
 418         `}
 419         fun family_name: nullable String is extern import String::to_cstring, String as nullable `{
 420                 char *fn = TTF_FontFaceFamilyName( recv );
 421
 422                 if ( fn == NULL )
 423                         return null_String();
 424                 else
 425                         return String_as_nullable( NativeString_to_s( fn ) );
 426         `}
 427         fun style_name: nullable String is extern import String::to_cstring, String as nullable `{
 428                 char *sn = TTF_FontFaceStyleName( recv );
 429
 430                 if ( sn == NULL )
 431                         return null_String();
 432                 else
 433                         return String_as_nullable( NativeString_to_s( sn ) );
 434         `}
 435
 436         fun width_of( text: String ): Int is extern import NativeString::to_s `{
 437                 char *ctext = String_to_cstring( text );
 438                 int w;
 439                 if ( TTF_SizeText( recv, ctext, &w, NULL ) )
 440                 {
 441                         fprintf( stderr, "SDL TFF error: %s\n", TTF_GetError() );
 442                         exit( 1 );
 443                 }
 444                 else
 445                         return w;
 446         `}
 447 end