ui_base.H

Go to the documentation of this file.

/*
 *  This file is part of the Home2L project.
 *
 *  (C) 2015-2024 Gundolf Kiefer
 *
 *  Home2L 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.
 *
 *  Home2L 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 Home2L. If not, see <https://www.gnu.org/licenses/>.
 *
 */
 
 
#ifndef _UI_BASE_
#define _UI_BASE_
 
 
#include <SDL.h>
#include <SDL_ttf.h>
 
#include "env.H"
 
 
 
 
 
// *************************** Screen resolution *******************************
 
 
#define UI_RES_X 1024   
#define UI_RES_Y 600    
 
 
 
 
 
// *************************** General *****************************************
 
 
 
 
extern SDL_Renderer *uiSdlRenderer;   
 
 
void UiInit (const char *windowTitle = "Home2L");
void UiDone ();
 
static inline SDL_Renderer *UiGetSdlRenderer () { return uiSdlRenderer; }
 
void UiGetWindowSize (int *w, int *h);
 
#if ANDROID == 0
 
void UiSetWindowSize (int w, int h);
 
bool UiGetWindowFullScreen ();
void UiSetWindowFullScreen (bool _fullScreen);
void UiToggleWindowFullScreen ();
 
bool UiGetWindowResizable ();
void UiSetWindowResizable (bool _resizable);
void UiToggleWindowResizable ();
 
 
#endif // ANDROID == 0
 
 
 
 
 
 
 
// *************************** Events ******************************************
 
 
 
 
enum EUserEvent {
  evMainThreadCallback = 0,
  evSystemModeChanged,    // (int) data1 = new mode, (int) data2 = previous mode
  evEND
};
 
 
void UiIterate (bool noWait = false);
static inline void UiIterateNoWait () { UiIterate (true); }
 
 
void UiQuit ();       
bool UiIsClosed ();   
 
void UiPushUserEvent (EUserEvent code, void *data1 = NULL, void *data2 = NULL);
 
static inline void MainThreadCallback (void (*func) (void *), void *data = NULL) { UiPushUserEvent (evMainThreadCallback, (void *) func, data); }
 
 
 
 
 
 
 
// *************************** SDL audio ***************************************
 
 
 
 
#define AUDIO_FOREVER -1    
 
 
void AudioStart (const char *fileName, int repetitions = 1, TTicks repetitionGap = 0);
void AudioStop ();
 
bool AudioIsPlaying ();
 
 
 
 
 
 
 
// *************************** SDL_Color helpers *******************************
 
 
 
 
#define SELECTED_SDL_PIXELFORMAT SDL_PIXELFORMAT_ARGB8888
 
 
#if SELECTED_SDL_PIXELFORMAT==SDL_PIXELFORMAT_ARGB8888
 
 
struct TColor {
  Uint8 b : 8;
  Uint8 g : 8;
  Uint8 r : 8;
  Uint8 a : 8;
};  //  __attribute__((packed))__
 
 
#define COL_MASK_R 0x00FF0000     
#define COL_MASK_G 0x0000FF00     
#define COL_MASK_B 0x000000FF     
#define COL_MASK_A 0xFF000000     
#define COL_MASK_RGB (COL_MASK_R | COL_MASK_G | COL_MASK_B)     
 
 
static inline TColor ToColor (Uint8 r, Uint8 g, Uint8 b, Uint8 a = 255) {
  TColor ret;
  ret.r = r; ret.g = g; ret.b = b; ret.a = a;
  return ret;
}
 
 
static inline TColor ToColor (Uint32 val) {
  union { Uint32 i; TColor c; } ret;
  ret.i = val;
  return ret.c;
  //TColor ret;
  //memcpy (&ret, &val, sizeof (TColor));
  //return ret;
}
 
 
static inline Uint32 ToUint32 (TColor color) {
  union { Uint32 i; TColor c; } ret;
  ret.c = color;
  return ret.i;
}
 
 
static inline Uint32 ToUint32 (Uint8 r, Uint8 g, Uint8 b, Uint8 a = 255) {
  return ToUint32 (ToColor (r, g, b, a));
}
 
 
static inline TColor ToColor (SDL_Color sdlCol) {
  TColor ret;
  ret.r = sdlCol.r; ret.g = sdlCol.g; ret.b = sdlCol.b; ret.a = sdlCol.a;
  return ret;
}
 
 
static inline bool operator == (const TColor &col1, const TColor &col2) { return ToUint32 (col1) == ToUint32 (col2); }
static inline bool operator != (const TColor &col1, const TColor &col2) { return ToUint32 (col1) != ToUint32 (col2); }
 
 
static inline SDL_Color ToSDL_Color (TColor color) {
  SDL_Color ret = { .r = color.r, .g = color.g, .b = color.b, .a = color.a };
  return ret;
}
 
 
#endif
 
 
TColor ColorSum (TColor col1, TColor col2);
TColor ColorBrighter (TColor color, int d);
static inline TColor ColorDarker (TColor color, int d) { return ColorBrighter (color, -d); }
TColor ColorScale (TColor color, int factor);
TColor ColorBlend (TColor color0, TColor color1, int weight1);
 
 
 
 
 
#define WHITE         ToColor (0xff, 0xff, 0xff)
#define LIGHT_GREY    ToColor (0xc0, 0xc0, 0xc0)
#define GREY          ToColor (0x80, 0x80, 0x80)
#define DARK_GREY     ToColor (0x40, 0x40, 0x40)
#define DARK_DARK_GREY ToColor (0x20, 0x20, 0x20)
#define BLACK         ToColor (0x00, 0x00, 0x00)
 
#define RED           ToColor (0xff, 0x00, 0x00)
#define GREEN         ToColor (0x00, 0xff, 0x00)
#define BLUE          ToColor (0x00, 0x00, 0xff)
#define CYAN          ToColor (0x00, 0xff, 0xff)
#define MAGENTA       ToColor (0xff, 0x00, 0xff)
#define YELLOW        ToColor (0xff, 0xff, 0x00)
 
#define DARK_RED      ToColor (0x80, 0x00, 0x00)
#define DARK_GREEN    ToColor (0x00, 0x80, 0x00)
#define DARK_BLUE     ToColor (0x00, 0x00, 0x80)
#define DARK_CYAN     ToColor (0x00, 0x80, 0x80)
#define DARK_MAGENTA  ToColor (0x80, 0x00, 0x80)
#define DARK_YELLOW   ToColor (0x80, 0x80, 0x00)
 
#define LIGHT_RED     ToColor (0xff, 0x80, 0x80)
#define LIGHT_GREEN   ToColor (0x80, 0xff, 0x80)
#define LIGHT_BLUE    ToColor (0x80, 0x80, 0xff)
#define LIGHT_CYAN    ToColor (0x80, 0xff, 0xff)
#define LIGHT_MAGENTA ToColor (0xff, 0x80, 0xff)
#define LIGHT_YELLOW  ToColor (0xff, 0xff, 0x80)
 
#define BROWN         ToColor (0x80, 0x40, 0x00)
#define LIGHT_BROWN   ToColor (0xc0, 0x80, 0x40)
 
#define ORANGE        ToColor (0xc0, 0x40, 0x00)
 
#define TRANSPARENT   ToColor (0x00, 0x00, 0x00, 0x00)
 
 
 
 
 
 
// *************************** SDL_Rect helpers ********************************
 
 
 
 
static inline SDL_Rect Rect (int x, int y, int w, int h) {
  SDL_Rect ret = { .x = x, .y = y, .w = w, .h = h };
  return ret;
}
 
 
static inline SDL_Rect Rect (int w, int h) {
  SDL_Rect ret = { .x = 0, .y = 0, .w = w, .h = h };
  return ret;
}
 
 
static inline SDL_Rect Rect (SDL_Surface *surf) {
  SDL_Rect ret = { .x = 0, .y = 0, .w = surf->w, .h = surf->h };
  return ret;
}
 
 
static inline SDL_Rect Rect (SDL_Texture *tex) {
  SDL_Rect ret;
  ret.x = ret.y = 0;
  SDL_QueryTexture (tex, NULL, NULL, &ret.w, &ret.h);
  return ret;
}
 
 
static inline SDL_Rect RectScreen () { return Rect (0, 0, UI_RES_X, UI_RES_Y); }
 
 
static inline void RectMove (SDL_Rect *rect, int dx, int dy) {
  rect->x += dx;
  rect->y += dy;
}
 
 
static inline void RectGrow (SDL_Rect *rect, int dx, int dy) {
  rect->x -= dx;
  rect->y -= dy;
  rect->w += 2 * dx;
  rect->h += 2 * dy;
}
 
 
void RectAlign (SDL_Rect *rect, SDL_Rect container, int hAlign = -1, int vAlign = -1);
 
 
static inline void RectCenter (SDL_Rect *rect, SDL_Rect container) { RectAlign (rect, container, 0, 0); }
 
 
static inline bool RectContains (SDL_Rect *rect, int x, int y) {
  return x >= rect->x && x < rect->x+rect->w && y >= rect->y && y < rect->y+rect->h;
}
 
 
 
 
 
 
 
// *************************** Surface helpers *********************************
 
 
 
 
#define ORIENT(FLIPH, ROT) (((FLIPH) ? 4 : 0) | ((ROT) & 3))
#define ORIENT_WITH_FLIPV(FLIPH, ROT) (((FLIPH) ? 0 : 4) | (((ROT) + 2) & 3))
 
#define ORIENT_FLIPH(ORI) (((ORI) & 4) ? true : false)
#define ORIENT_ROT(ORI) ((ORI) & 3)
 
 
#if SELECTED_SDL_PIXELFORMAT==SDL_PIXELFORMAT_ARGB8888
 
static inline SDL_Surface *CreateSurface (int w, int h) { return SDL_CreateRGBSurfaceWithFormat (0, w, h, 32, SELECTED_SDL_PIXELFORMAT); }
static inline SDL_Surface *CreateSurface (SDL_Rect r) { return CreateSurface (r.w, r.h); }
static inline SDL_Surface *CreateSurface (SDL_Rect *r) { return CreateSurface (r->w, r->h); }
 
static inline SDL_Surface *CreateSurfaceFrom (int w, int h, void *_pixels, int _pitch) { return SDL_CreateRGBSurfaceFrom (_pixels, w, h, 32, _pitch, COL_MASK_R, COL_MASK_G, COL_MASK_B, COL_MASK_A); }
 
#endif
 
 
static inline SDL_Surface *SurfaceSet (SDL_Surface **pSurf, SDL_Surface *newSurf) { if (*pSurf) SDL_FreeSurface (*pSurf); *pSurf = newSurf; return newSurf; }
static inline void SurfaceFree (SDL_Surface **pSurf) { SurfaceSet (pSurf, NULL); }
static inline void SurfaceFree (SDL_Surface *surf) { SDL_FreeSurface (surf); }
 
static inline SDL_Surface *SurfaceDup (SDL_Surface *src) { return SDL_ConvertSurface (src, src->format, 0); }
 
void SurfaceNormalize (SDL_Surface **pSurf);
 
void SurfaceRecolor (SDL_Surface *surf, TColor color);
SDL_Surface *SurfaceGetOpaqueCopy (SDL_Surface *surf, TColor backColor);
void SurfaceMakeTransparentMono (SDL_Surface *surf, Uint8 opaqueLevel = 0xff);
 
void SurfaceBlit (SDL_Surface *src, SDL_Rect *srcRect, SDL_Surface *dst, SDL_Rect *dstRect = NULL, int hAlign = 0, int vAlign = 0, SDL_BlendMode blendMode = SDL_BLENDMODE_NONE);
static inline void SurfaceFill (SDL_Surface *surf, TColor col) { SDL_FillRect (surf, NULL, ToUint32 (col)); }
static inline void SurfaceFillRect (SDL_Surface *surf, SDL_Rect r, TColor col) { SDL_FillRect (surf, &r, ToUint32 (col)); }
static inline void SurfaceFillRect (SDL_Surface *surf, SDL_Rect *r, TColor col) { SDL_FillRect (surf, r, ToUint32 (col)); }
 
SDL_Surface *SurfaceGetScaledDownCopy (SDL_Surface *surf, int factor, bool preserveThinLines = false);
SDL_Surface *SurfaceGetFlippedAndRotatedCopy (SDL_Surface *surf, int orient);
 
SDL_Surface *SurfaceReadBmp (const char *fileName);
 
 
 
// ********** CNetpbmReader **********
 
 
#define NETPBM_IDLE -3      
#define NETPBM_ERROR -2     
#define NETPBM_SUCCESS -1   
 
 
class CNetpbmReader {
  public:
    CNetpbmReader () { surf = NULL; state = NETPBM_IDLE; }
    ~CNetpbmReader () { Clear (); }
 
    void Clear ();                  
    void Put (const char *line);    
 
    int State () { return state; }
    bool Running () { return state >= 0; }
    bool Error () { return state == NETPBM_ERROR; }
    bool Success () { return state == NETPBM_SUCCESS; }
 
    SDL_Surface *Surface () { return Success () ? surf : NULL; }
 
    bool ReadFile (const char *fileName);
    bool ReadStream (int fd);
    bool ReadShell (CShell *shell);
 
  protected:
    SDL_Surface *surf;
    int format;             // 2 or 3 (the number behind the 'P')
    int w, h;
    int state;              // Number of words read (1 => 'Pn' was just read; < 0: no reading in progress)
};
 
 
 
 
 
 
 
// *************************** Texture helpers *********************************
 
 
 
 
static inline SDL_Texture *CreateTexture (SDL_Surface *surf) { return SDL_CreateTextureFromSurface (uiSdlRenderer, surf); }
 
static inline void TextureSet (SDL_Texture **pTex, SDL_Texture *newTex) { if (*pTex) SDL_DestroyTexture (*pTex); *pTex = newTex; }
static inline void TextureFree (SDL_Texture **pTex) { TextureSet (pTex, NULL); }
 
static inline void TextureRender (SDL_Texture *tex, SDL_Rect *srcRect = NULL, SDL_Rect *dstRect = NULL) { SDL_RenderCopy (uiSdlRenderer, tex, srcRect, dstRect); }
 
 
 
 
 
 
 
// *************************** Icon handling ***********************************
 
 
 
 
SDL_Surface *IconGet (const char *name, TColor color = WHITE, TColor bgColor = TRANSPARENT, int scaleDown = 1, int orient = 0, bool preserveThinLines = false);
 
 
 
 
 
 
 
// *************************** Font handling ***********************************
 
 
 
 
enum EFontStyle {
  fntNormal = 0,      
  fntBold,            
  fntItalic,          
  fntBoldItalic,      
  fntLight,           
  fntMono,            
  fntMonoBold,        
  fntMonoItalic,      
  fntMonoBoldItalic,  
  fntEND
};
 
 
TTF_Font *FontGet (EFontStyle style, int size);
 
SDL_Surface *FontRenderText (TTF_Font *font, const char *text, TColor color);
SDL_Surface *FontRenderText (TTF_Font *font, const char *text, TColor color, TColor bgColor);
 
static inline int FontGetLineSkip (TTF_Font *font) { return TTF_FontLineSkip (font); }
 
static inline int FontGetHeight (TTF_Font *font) { return TTF_FontHeight (font); }
int FontGetWidth (TTF_Font *font, const char *text, int textLen = -1);
 
 
 
 
 
 
 
// *************************** Complex text formatting *************************
 
 
 
 
class CTextFormat {
  public:
    CTextFormat () { font = NULL; }
    CTextFormat (TTF_Font *_font, TColor _color, TColor _bgColor = TRANSPARENT,
                 int _hAlign = -1, int _vAlign = -1,
                 int _hSpace = 0, int _vSpace = 0,
                 int _maxWidth = 0, int _maxHeigth = 0) {
      font = _font; color = _color; bgColor = _bgColor;
      hAlign = _hAlign; vAlign = _vAlign;
      hSpace = _hSpace; vSpace = _vSpace;
      maxWidth = _maxWidth;
      maxHeight = _maxHeigth;
    }
 
    // Parameters ...
    TTF_Font *font;           
    TColor color, bgColor;    
    int hAlign, vAlign;       
    int vSpace, hSpace;       
    int maxWidth, maxHeight;  
};
 
 
class CTextSet {
  public:
    CTextSet () { surface = NULL; firstItem = NULL; height = 0; }
    ~CTextSet () { Clear (); }
 
    void Clear ();
    void AddLines (const char *text, CTextFormat fmt, bool *retAbbreviated = NULL);
    int GetHeight ();
 
    SDL_Surface *Render (SDL_Surface *dst = NULL, SDL_Rect *dstRect = NULL);
 
  protected:
    SDL_Surface *surface;
    class CTextItem *firstItem;
    int height;
};
 
 
// Easy-to-use function(s)...
SDL_Surface *TextRender (const char *text, CTextFormat fmt, SDL_Surface *dst = NULL, SDL_Rect *dstRect = NULL, bool *retAbbreviated = NULL);
 
 
 
 
 
 
 
#endif