t4k_common.h

Go to the documentation of this file.

//==============================================================================
//
//   t4k_common.h: Contains public headers for the t4k_common library
//
//   Copyright 2009, 2010, 2011.
//   Authors: Brendan Luchen, David Bruce.
//   Project email: <tuxmath-devel@lists.sourceforge.net>
//   Project website: http://tux4kids.alioth.debian.org
//
//   t4k_common.h is part of the t4k_common library.
//
//   t4k_common is free software: you can redistribute it and/or modify
//   it under the terms of the GNU General Public License as published by
//   the Free Software Foundation; either version 3 of the License, or
//   (at your option) any later version.
//
//   t4k_common is distributed in the hope that it will be useful,
//   but WITHOUT ANY WARRANTY; without even the implied warranty of
//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//   GNU General Public License for more details.
//
//   You should have received a copy of the GNU General Public License
//   along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
//==============================================================================
 
//==============================================================================
//
 
#ifndef TUX4KIDS_COMMON_H
#define TUX4KIDS_COMMON_H
 
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <dirent.h>
#include <wchar.h>
#include "SDL.h"
#include "SDL_image.h"
#include "SDL_mixer.h"
 
//TTS Macros
#define DEFAULT_VALUE 30
#define INTERRUPT 0
#define APPEND 1
 
//==============================================================================
// Debugging macros
//
// All macros take a debug mask as their first argument, which should roughly
// indicate what part of the program the debugging info is related to, and
// which can be one of the flags defined below, a program-specific flag, or
// an OR'd combination.
//
// DEBUGVAR prints out the name and value of a string variable
#ifndef DEBUGMSG

#define DEBUGVAR(mask, Expr) \
    if((mask) & (debug_status)) \
{ \
    fprintf(stderr, #Expr ": %s\n", (Expr)); fflush(stderr); \
}

#define DEBUGVARX(mask, Expr) \
    if((mask) & (debug_status)) \
{ \
    fprintf(stderr, #Expr ": %x\n", (Expr)); fflush(stderr); \
}

#define DEBUGVARF(mask, Expr) \
    if((mask) & (debug_status)) \
{ \
    fprintf(stderr, #Expr ": %f\n", (Expr)); fflush(stderr); \
}

#define DEBUGCODE(mask) if((mask) & debug_status)

#define DEBUGMSG(mask, ...) \
    if((mask) & debug_status) \
{ \
    fprintf(stderr, __VA_ARGS__); fflush(stderr); \
}
#endif
 
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
#define rmask 0xff000000 
#define gmask 0x00ff0000 
#define bmask 0x0000ff00 
#define amask 0x000000ff 
#else
#define rmask 0x000000ff 
#define gmask 0x0000ff00 
#define bmask 0x00ff0000 
#define amask 0xff000000 
#endif
 
#ifndef bool
typedef enum
{
    false, 
    true
}
bool;
#endif
 
// These values have to match those used in games.
static const int debug_loaders       = 1 << 0; 
static const int debug_menu          = 1 << 1; 
static const int debug_menu_parser   = 1 << 2; 
static const int debug_sdl           = 1 << 3; 
static const int debug_linewrap      = 1 << 4; 
static const int debug_i18n          = 1 << 5; 
static const int debug_all           = ~0;     
 
extern int debug_status;
 
//Define our color constants:
static const SDL_Color black        = {0x00, 0x00, 0x00, 0xff};
static const SDL_Color gray         = {0x80, 0x80, 0x80, 0xff};
static const SDL_Color dark_blue    = {0x00, 0x00, 0x60, 0xff};
static const SDL_Color red          = {0xff, 0x00, 0x00, 0xff};
static const SDL_Color white        = {0xff, 0xff, 0xff, 0xff};
static const SDL_Color yellow       = {0xff, 0xff, 0x00, 0xff};
static const SDL_Color bright_green = {0x60, 0xff, 0x00, 0xff};

#define START_CUSTOM_DEBUG 6
 
// FIXME: global vars such as screen should be hidden when all games
// are using only getters (such as GetScreen() )
extern SDL_Surface* screen;
extern SDL_Rect menu_rect, stop_rect, prev_rect, next_rect;
extern SDL_Surface *stop_button, *prev_arrow, *next_arrow, *prev_gray, *next_gray;
 
 
#define MAX_SPRITE_FRAMES 15 
 
//==============================================================================
typedef struct
{
    SDL_Surface *frame[MAX_SPRITE_FRAMES];
    SDL_Surface *default_img;
    int num_frames;
    int cur;
}
sprite;
 
//==============================================================================
typedef enum
{
    WIPE_BLINDS_VERT,
    WIPE_BLINDS_HORIZ,
    WIPE_BLINDS_BOX,
    RANDOM_WIPE,
    NUM_WIPES
}
WipeStyle;
 
//==============================================================================
enum
{
    RUN_MAIN_MENU = -3,  
    QUIT          = -2,  
    STOP          = -1   
};
 
//==============================================================================
typedef enum
{
    MF_UNIFORM,   
    MF_BESTFIT,   
    MF_EXACTLY    
}
MFStrategy;
 
// from tk4_loaders.c
#define IMG_REGULAR         0x01
#define IMG_COLORKEY        0x02
#define IMG_ALPHA           0x04
#define IMG_MODES           0x07
 
#define IMG_NOT_REQUIRED    0x10
#define IMG_NO_PNG_FALLBACK 0x20
 
#define MAX_LINES           128 
#define MAX_LINEWIDTH       256 
 
static char wrapped_lines[MAX_LINES][MAX_LINEWIDTH]; 
 
//TODO separate headers for different areas a la SDL?
 
 
//==============================================================================
// Structure used to pass arguments for T4K_Tts_say() 
typedef struct
{
        int mode;
        wchar_t text[10000];
}tts_argument;
 
 
//==============================================================================
//                  Public Definitions in t4k_tts.c
//==============================================================================
int T4K_Tts_init();
int T4K_Tts_set_voice(char voice_name[]);
void T4K_Tts_set_volume(int volume);
void T4K_Tts_set_rate(int rate);
void T4K_Tts_set_pitch(int pitch);
void T4K_Tts_say(int rate,int pitch, int mode, const char* text, ...);
 
 
 
 
//==============================================================================
//                     Public Definitions in t4k_main.c                       
//==============================================================================
 
//==============================================================================
//
//  InitT4KCommon
//
int InitT4KCommon( int debug_flags );
 
//==============================================================================
//
//  CleanupT4KCommon
//
void CleanupT4KCommon( void );
 
//==============================================================================
//  
//  T4K_HandleStdEvents
//
int T4K_HandleStdEvents( const SDL_Event* event );
 
 
//============================================================================== 
//                     Public Definitions in t4k_menu.c
//==============================================================================
 
//==============================================================================
//
//  T4K_SetActivitiesList
//
void T4K_SetActivitiesList( int    num, 
                            char** acts 
                          );
 
//==============================================================================
// 
//  T4K_SetMenuSounds
//
void T4K_SetMenuSounds( char*      mus_path, 
                        Mix_Chunk* click, 
                        Mix_Chunk* hover 
                      );
 
//==============================================================================
//
//  T4K_SetMenuSpritePrefix
//
void T4K_SetMenuSpritePrefix( char* pref );
 
//==============================================================================
// 
//  T4K_SetMenuFontSize
//  
void T4K_SetMenuFontSize( MFStrategy strategy,
                          int        size
                        );
 
//==============================================================================
//
//  T4K_CreateOneLevelMenu
//
void T4K_CreateOneLevelMenu( int     index,
                             int     items,
                             char**  item_names, 
                             char**  sprite_names, 
                             char*   title, 
                             char*   trailer
                            );
 
//============================================================================== 
//
//  T4K_RunMenu
//
int T4K_RunMenu( int    index,
                 bool   return_choice,
                 void   (*draw_background)(),
                 int    (*handle_event)(SDL_Event*), 
                 void   (*handle_animations)(),
                 int    (*handle_activity)(int, int)
               );
 
//==============================================================================
// 
//  T4K_PrerenderMenu
//
void T4K_PrerenderMenu( int index );
 
//============================================================================== 
//
//  T4K_PrerenderAll
// 
void T4K_PrerenderAll( void );
 
//============================================================================== 
//
//  T4K_LoadMenu
//
void T4K_LoadMenu( int         index,
                   const char* file_name
                 );
 
//============================================================================== 
//  
//  T4K_UnloadMenus
//
void T4K_UnloadMenus( void );
 
 
//==============================================================================
//                     Public Definitions in tk4_sdl.c
//==============================================================================
 
//============================================================================== 
//
//  T4K_GetScreen
//
SDL_Surface* T4K_GetScreen( void );
 
 
//============================================================================== 
//
//  T4K_GetResolutions
//
int T4K_GetResolutions( int* win_x,
                        int* win_y,
                        int* full_x,
                        int* full_y
                      );
 
//==============================================================================
// 
//  T4K_DrawButton
//
void T4K_DrawButton( SDL_Rect* target_rect,
                     int       radius,
                     Uint8     r,
                     Uint8     g,
                     Uint8     b,
                     Uint8     a
                   );
 
//============================================================================== 
//
//  T4K_DrawButtonOn
// 
void T4K_DrawButtonOn( SDL_Surface* target,
                       SDL_Rect*    target_rect,
                       int          radius,
                       Uint8        r,
                       Uint8        g,
                       Uint8        b,
                       Uint8        a 
                      );
 
//============================================================================== 
//
//  T4K_CreateButton
//
SDL_Surface* T4K_CreateButton( int    w,
                               int    h,
                               int    radius,
                               Uint8  r,
                               Uint8  g,
                               Uint8  b,
                               Uint8  a 
                              );
 
//==============================================================================
//
//  T4K_RoundCorners
//
void T4K_RoundCorners( SDL_Surface* s,
                       Uint16       radius
                     );
 
//==============================================================================
//
//  T4K_Flip
//
SDL_Surface* T4K_Flip( SDL_Surface* in,
                       int          x,
                       int          y
                     );
 
//==============================================================================
//
//  T4K_Blend
//
SDL_Surface* T4K_Blend( SDL_Surface* S1,
                        SDL_Surface* S2,
                        float        gamma
                      );
 
//==============================================================================
//
//  T4K_FreeSurfaceArray
//
void T4K_FreeSurfaceArray( SDL_Surface** surfs, 
                           int           length
                         );
 
//==============================================================================
// 
//  T4K_inRect
//
int T4K_inRect( SDL_Rect r,
                int      x,
                int      y
              );
 
//==============================================================================
// 
//  T4K_SetRect
//
void T4K_SetRect( SDL_Rect*    rect,
                  const float* pos
                );
 
//==============================================================================
// 
//  T4K_UpdateRect
//
void T4K_UpdateRect( SDL_Surface* surf,
                     SDL_Rect*    rect
                   );
 
//==============================================================================
//
//  T4K_DarkenScreen
//
void T4K_DarkenScreen( Uint8 bits );
 
//==============================================================================
//
//  T4K_ChangeWindowSize
//
void T4K_ChangeWindowSize( int new_res_x,
                           int new_res_y
                         );
 
//==============================================================================
// 
//  T4K_SwitchScreenMode
//
void T4K_SwitchScreenMode( void );
 
//==============================================================================
//
typedef void (*ResSwitchCallback)(int resx, int resy);
 
//==============================================================================
// 
//  T4K_OnResolutionSwitch
//
void T4K_OnResolutionSwitch( ResSwitchCallback callback );
 
//==============================================================================
// 
//  T4K_WaitForEvent
//
SDL_EventType T4K_WaitForEvent( SDL_EventMask events );
 
//==============================================================================
//
//  T4K_zoom
//
SDL_Surface* T4K_zoom( SDL_Surface* src,
                       int          new_w,
                       int          new_h
                     );
 
//==============================================================================
// 
//  T4K_TransWipe
//
int T4K_TransWipe( const SDL_Surface* newbkg,
                   WipeStyle          type,
                   int                segments,
                   int                duration
                 );
 
//==============================================================================
// 
//  T4K_InitBlitQueue
//
void T4K_InitBlitQueue( void );
 
//==============================================================================
//
//  T4K_ResetBlitQueue
// 
void T4K_ResetBlitQueue( void );
 
//==============================================================================
// 
//  T4K_AddRect
//
int T4K_AddRect( SDL_Rect* src,
                 SDL_Rect* dst
               );
 
//==============================================================================
//
//  T4K_DrawSprite
//
int T4K_DrawSprite( sprite* gfx,
                    int     x,
                    int     y
                  );
 
//==============================================================================
//
//  T4K_DrawObject
//
int T4K_DrawObject( SDL_Surface* surf,
                    int          x,
                    int          y
                  );
 
//==============================================================================
//
//  T4K_UpdateScreen
//
void T4K_UpdateScreen( int* frame );
 
//==============================================================================
//
//  T4K_EraseSprite
//
int T4K_EraseSprite( sprite*      img,
                     SDL_Surface* curr_bkgd,
                     int          x,
                     int          y
                   );
 
//==============================================================================
//
//  T4K_EraseObject
//
int T4K_EraseObject( SDL_Surface* surf,
                     SDL_Surface* curr_bkgd,
                     int          x,
                     int          y
                   );
 
//==============================================================================
// 
//  T4K_SetFontName
//
void T4K_SetFontName( const char* name );
 
//==============================================================================
// 
//  T4K_AskFontName
// 
const char* T4K_AskFontName( void );
 
//==============================================================================
//
//  T4K_Setup_SDL_Text
//
int T4K_Setup_SDL_Text( void );
 
//==============================================================================
// 
//  T4K_Cleanup_SDL_Text
// 
void T4K_Cleanup_SDL_Text( void );
 
//==============================================================================
// 
//  T4K_BlackOutline
// 
SDL_Surface* T4K_BlackOutline( const char* t,
                               int         size,
                               const SDL_Color*  c
                             );
 
//==============================================================================
// 
//  T4K_SimpleText
//
SDL_Surface* T4K_SimpleText( const char*      t,
                             int              size,
                             const SDL_Color* col
                           );
 
//==============================================================================
//
//  T4K_SimpleTextWithOffset
//
SDL_Surface* T4K_SimpleTextWithOffset( const char*       t,
                                       int               size,
                                       const SDL_Color*  col,
                                       int*              glyph_offset
                                     );
 
//==============================================================================
//  T4K_CharsForWidth
//
int T4K_CharsForWidth( int fontsize,
                       int pixel_width
                     );
 
//==============================================================================
//                  Public Definitions in t4k_loaders.c
//==============================================================================
 
//==============================================================================
// 
//  T4K_AddDataPrefix
// 
void T4K_AddDataPrefix( const char* path );
 
//==============================================================================
//
//  T4K_CheckFile
//
int T4K_CheckFile( const char* file );
 
//==============================================================================
// 
//  T4K_RemoveSlash
//
char* T4K_RemoveSlash( char *path );
 
//==============================================================================
// 
//  T4K_LoadImage
//
SDL_Surface* T4K_LoadImage( const char* file_name,
                            int         mode
                          );
 
//==============================================================================
// 
//  T4K_LoadScaledImage
//
SDL_Surface* T4K_LoadScaledImage( const char* file_name,
                                  int         mode,
                                  int         width,
                                  int         height
                                );
 
//==============================================================================
// 
//  T4K_LoadImageOfBoundingBox
//
SDL_Surface* T4K_LoadImageOfBoundingBox( const char* file_name,
                                         int         mode,
                                         int         max_width,
                                         int         max_height
                                       );
 
//=============================================================================
// 
//  T4K_LoadBkgd
//
SDL_Surface* T4K_LoadBkgd( const char* file_name,
        int         width,
        int         height
        );
 
//=============================================================================
//
//  T4K_LoadBothBkgds
//
int T4K_LoadBothBkgds( const char*   file_name,
                       SDL_Surface** fs_bkgd,
                       SDL_Surface** win_bkgd
                     );
 
//==============================================================================
//
//  T4K_LoadSprite
//
sprite* T4K_LoadSprite( const char* name,
                        int         mode
                      );
 
//==============================================================================
//
//  T4K_LoadScaledSprite 
// 
sprite* T4K_LoadScaledSprite( const char* name,
                              int         mode,
                              int         width,
                              int         height
                            );
 
//==============================================================================
// 
//  T4K_LoadSpriteOfBoundingBox
//
sprite* T4K_LoadSpriteOfBoundingBox( const char* name,
                                     int         mode,
                                     int         max_width,
                                     int max_height
                                   );
 
//==============================================================================
// 
//  T4K_FlipSprite
// 
sprite* T4K_FlipSprite( sprite* in,
                        int     X,
                        int     Y 
                      );
 
//==============================================================================
//
//  T4K_FreeSprite
//
void T4K_FreeSprite( sprite* gfx );
 
//==============================================================================
// 
//  T4K_NextFrame
//
void T4K_NextFrame( sprite* s );
 
//==============================================================================
// 
//  T4K_LoadSound
//
Mix_Chunk* T4K_LoadSound( char* datafile );
 
//==============================================================================
// 
//  T4K_LoadMusic
//
Mix_Music* T4K_LoadMusic( char *datafile );
 
 
//==============================================================================
//                  Public Definitions from t4k_audio.c
//==============================================================================
 
const static int T4K_AUDIO_PLAY_ONCE    =  0;
const static int T4K_AUDIO_LOOP_FOREVER = -1;
 
//==============================================================================
// 
//  T4K_PlaySound
//
void T4K_PlaySound( Mix_Chunk* sound );
 
//==============================================================================
// 
//  T4K_PlaySoundLoop
//
void T4K_PlaySoundLoop( Mix_Chunk* sound,
                        int        loops
                      );
 
//==============================================================================
// 
//  T4K_AudioHaltChannel
//
void T4K_AudioHaltChannel( int channel );
 
//==============================================================================
//
//  T4K_AudioMusicLoad
//
void T4K_AudioMusicLoad( char* music_path,
                         int   loops
                       );
 
//==============================================================================
// 
//  T4K_AudioMusicUnload
//
void T4K_AudioMusicUnload( void );
 
//==============================================================================
// 
//  T4K_IsPlayingMusic
//
bool T4K_IsPlayingMusic( void );
 
//==============================================================================
// 
//  T4K_AudioMusicPlay
//
void T4K_AudioMusicPlay( Mix_Music* musicData,
                         int        loops
                       );
 
//==============================================================================
// 
//  T4K_AudioEnable
//
void T4K_AudioEnable( bool enabled );
 
//==============================================================================
//
//  T4K_AudioToggle
//
void T4K_AudioToggle( void );
 
 
//=============================================================================
//                      Public Definitions for t4k_linewrap.c
//=============================================================================
 
//=============================================================================
//
//  T4K_LineWrap
//
int T4K_LineWrap( const char* input,
                  char        str_list[MAX_LINES][MAX_LINEWIDTH],
                  int         width,
                  int         max_lines,
                  int         max_width
                );
 
//=============================================================================
//
//  T4K_LineWrapInsBreaks
//
int T4K_LineWrapInsBreaks( const char* input,
                           char*       output,
                           int         width,
                           int         max_lines,
                           int         max_width
                         );
 
//=============================================================================
//
//  T4K_LineWrapList
//
void T4K_LineWrapList( const char input[MAX_LINES][MAX_LINEWIDTH],
                       char       str_list[MAX_LINES][MAX_LINEWIDTH],
                       int        width,
                       int        max_lines,
                       int        max_width
                     );
 
 
//=============================================================================
//                      Public Definitions for t4k_throttle.c
//=============================================================================
 
 
//=============================================================================
//
//  T4K_Throttle
//
void T4K_Throttle( int     loop_msec,
                   Uint32* last_t
                 );
 
 
//=============================================================================
//                      Public Definitions for t4k_convert_utf.c
//=============================================================================
 
 
//=============================================================================
//
//  T4K_ConvertFromUTF8
//
int T4K_ConvertFromUTF8( wchar_t*    wide_word, 
                         const char* UTF8_word, 
                         int         max_length
                       );
 
//=============================================================================
//
//  T4K_ConvertToUTF8
//
int T4K_ConvertToUTF8( const wchar_t* wide_word, 
                       char*          UTF8_word, 
                       int            max_length
                     );
 
 
//=============================================================================
//                      Public Definitions for t4k_replacements.c
//=============================================================================
 
//==============================================================================
//
//  T4K_alphasort
//
int T4K_alphasort( const struct dirent** d1,
                   const struct dirent** d2
                 );
 
//==============================================================================
//
//  T4K_scandir
//
int T4K_scandir( const char*      dirname,
                 struct dirent*** namelist,
                 int (*sdfilter)(struct dirent *),
                 int (*dcomp)(const void *, const void *)
               );
 
#endif /* TUX4KIDS_COMMON_H */