ui_widgets.H

Go to the documentation of this file.

/*
 *  This file is part of the Home2L project.
 *
 *  (C) 2015-2021 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_WIDGETS_
#define _UI_WIDGETS_
 
 
#include "ui_screen.H"
 
 
 
 
 
// *****************************************************************************
// *                                                                           *
// *                         Useful widget extensions                          *
// *                                                                           *
// *****************************************************************************
 
 
 
 
 
 
 
// *************************** CModalWidget ************************************
 
 
class CModalWidget: public virtual CWidget {
  public:
 
    int Run (CScreen *_screen);  
 
    virtual void Start (CScreen *_screen);  
    bool IsRunning ();                      
    virtual void Stop ();                   
 
    int GetStatus () { return status; }     
    void SetStatus (int _status) { status = _status; }    
 
    void SetNoCancelArea (SDL_Rect _rNoCancel) { rNoCancel = _rNoCancel; }
    void RemoveNoCancelArea () { SetNoCancelArea (RectScreen ()); }
 
    virtual bool HandleEvent (SDL_Event *ev);     
 
  protected:
    SDL_Rect rNoCancel;
    int status;
};
 
 
 
 
 
// *************************** CCursorWidget ***********************************
 
 
class CCursorWidget: public virtual CWidget {
  public:
    CCursorWidget () { ClearCursor (); cbHandleEvent = NULL; }
 
    void SetCursorFormat (TColor _cursorColor = ToColor (0xff, 0xff, 0xff, 0x20), SDL_BlendMode _blendMode = SDL_BLENDMODE_BLEND) { cursorColor = _cursorColor; blendMode = _blendMode; }
 
    void SetCursor (SDL_Rect _cursorArea) { cursorArea = _cursorArea; }
    void ClearCursor () { cursorArea.w = cursorArea.h = 0; }
 
    void SetCbHandleEvent (bool (*_cbHandleEvent) (SDL_Event *, void *), void *_data = NULL) { cbHandleEvent = _cbHandleEvent; cbHandleEventData = _data; }
 
    virtual void Render (SDL_Renderer *ren);
    virtual bool HandleEvent (SDL_Event *ev);
 
  protected:
    SDL_Rect cursorArea;
    TColor cursorColor;
    SDL_BlendMode blendMode;
    bool (*cbHandleEvent) (SDL_Event *, void *);
    void *cbHandleEventData;
};
 
 
 
 
 
 
 
 
// *****************************************************************************
// *                                                                           *
// *                               The widgets                                 *
// *                                                                           *
// *****************************************************************************
 
 
 
 
 
// *************************** CButton *****************************************
 
 
 
 
#define BUTTON_DEFAULT_FONT FontGet (fntNormal, 24) 
#define BUTTON_LABEL_BORDER 8                       
 
 
typedef void FCbButtonPushed (class CButton *button, bool longPush, void *data);
 
 
#define BUTTON_TRAMPOLINE(CB_NAME, CLASS_NAME, METHOD_NAME)             \
  void CB_NAME (class CButton *button, bool longPush, void *data) {     \
    ((CLASS_NAME *) data)->METHOD_NAME (button, longPush);              \
  }
 
 
void CbActivateScreen (class CButton *, bool, void *screen);
 
 
class CButton: public CWidget {
  public:
    CButton () { Init (); }
    virtual ~CButton () { Done (); }
    void Init ();
    void Done ();
 
    void Set (SDL_Rect _area, TColor _color = GREY);
    void Set (SDL_Rect _area, TColor _color, SDL_Surface *_icon);
    void Set (SDL_Rect _area, TColor _color, const char *text, TColor textColor = WHITE, TTF_Font *font = NULL);
    void Set (SDL_Rect _area, TColor _color, SDL_Surface *_icon, const char *text, TColor textColor = WHITE, TTF_Font *font = NULL);
 
 
    void SetArea (SDL_Rect _area);
 
    void SetColor (TColor _colNorm) { SetColor (_colNorm, _colNorm); }
    void SetColor (TColor _colNorm, TColor _colDown);
 
    void SetLabel (SDL_Surface *_icon, SDL_Rect *srcRect = NULL, bool takeOwnership = false);
    void SetLabel (const char *text, TColor textColor = WHITE, TTF_Font *font = NULL);
    void SetLabel (SDL_Surface *_icon, const char *text, TColor textColor = WHITE, TTF_Font *font = NULL);
    void SetLabel (TColor color, const char *iconName, const char *text = NULL, TTF_Font *font = NULL)
      { SetLabel (iconName ? IconGet (iconName, color) : NULL, text, color, font); }
    void ClearLabel () { SetLabel ((SDL_Surface *) NULL); }
    void SetLabelAlignment (int _hAlign = 0, int _vAlign = 0) { hAlign = _hAlign; vAlign = _vAlign; ChangedSurface (); }
 
    void SetHotkey (SDL_Keycode _hotkey) { hotkey = _hotkey; }
 
 
    virtual void OnPushed (bool longPush);
    void SetCbPushed (FCbButtonPushed *cb, void *_data = NULL) { cbPushed = cb; cbPushedData = _data; }
    void *GetCbPushedData () { return cbPushedData; }
 
    virtual SDL_Surface *GetSurface ();
    virtual bool HandleEvent (SDL_Event *ev);
 
  protected:
    SDL_Surface *surfLabel;
    bool surfLabelIsOwned;
    TColor colNorm, colDown;
    int hAlign, vAlign;
    bool isDown, changed;
 
    FCbButtonPushed *cbPushed;
    void *cbPushedData;
 
    SDL_Keycode hotkey;
 
    void ChangedSurface () { changed = true; CWidget::ChangedSurface (); }
};
 
 
 
#define FLATBUTTON_COL_UP   BLACK
#define FLATBUTTON_COL_DOWN ToColor (0x60, 0x00, 0x00)
//~ #define FLATBUTTON_COL_DOWN LIGHT_BROWN // DARK_YELLOW
 
 
class CFlatButton: public CButton {
  public:
    CFlatButton () { SetColor (FLATBUTTON_COL_UP, FLATBUTTON_COL_DOWN); }
 
    virtual SDL_Surface *GetSurface ();
};
 
 
 
 
 
// ***** Creating main button bars *****
 
 
typedef struct {
  int layoutWidth;              
  TColor color;                 
  const char *iconName;         
  const char *text;             
  FCbButtonPushed *cbPushed;    
  SDL_Keycode hotkey;           
} TButtonDescriptor;
 
 
CButton *CreateMainButtonBar (int buttons, TButtonDescriptor *descTable, CScreen *screen);
 
 
 
 
 
 
 
// *************************** CListbox ****************************************
 
 
 
 
#define LISTBOX_ITEM_BORDER 4     
 
 
enum EListboxMode {
  lmReadOnly,       
  lmActivate,       
  lmSelectSingle,   
  lmSelectAny       
};
 
 
typedef void FCbListboxPushed (class CListbox *, int idx, bool longPush, void *data);
 
 
#define LISTBOX_TRAMPOLINE(CB_NAME, CLASS_NAME, METHOD_NAME)                      \
  void CB_NAME (class CListbox *listbox, int idx, bool longPush, void *data) {    \
    ((CLASS_NAME *) data)->METHOD_NAME (listbox, idx, longPush);                  \
  }
 
 
class CListboxItem {
  public:
    CListboxItem () { text = NULL; iconName = NULL; iconSurf = NULL; isSelected = isSpecial = false; data = NULL; changed = true; }
 
    bool IsSelected () { return isSelected; }
 
    void SetLabel (const char *_text, const char *_iconName = NULL) { text = _text; iconName = _iconName; iconSurf = NULL; }
    void SetLabel (const char *_text, SDL_Surface *_iconSurf) { text = _text; iconName = NULL; iconSurf = _iconSurf; }
 
    bool isSpecial;   
    void *data;       
 
  protected:
    friend class CListbox;
 
    const char *text;
    const char *iconName;
    SDL_Surface *iconSurf;
 
    bool isSelected;
    bool changed;       
};
 
 
class CListbox: public CCanvas {
  public:
    CListbox ();
    ~CListbox ();
 
    void SetMode (EListboxMode _mode, int _itemHeight, int _itemGap = 1);
    void SetFormat (TTF_Font *_font, int _hAlign = -1, TColor colGrid = BLACK,
                    TColor _colLabel = WHITE, TColor _colBack = DARK_DARK_GREY,
                    TColor _colLabelSelected = WHITE, TColor _colBackSelected = GREY,
                    TColor _colLabelSpecial = WHITE, TColor _colBackSpecial = DARK_GREY);
    void SetArea (SDL_Rect _area) { CCanvas::SetArea (_area); ChangedSetup (); }
 
    void Clear () { SetItems (0); }
    void SetItems (int _items);
    int GetItems () { return items; }
 
    void SetItem (int idx, const char *_text, const char *_iconName = NULL, bool _isSpecial = false, void *data = NULL);
    void SetItem (int idx, const char *_text, SDL_Surface *_iconSurf, bool _isSpecial = false, void *data = NULL);
    CListboxItem *GetItem (int idx) { return &itemArr[idx]; }
 
    int GetItemHeight () { return itemHeight; }
    int GetItemLabelWidth (int idx);
    SDL_Rect GetItemRect (int idx);
 
    void ScrollTo (int idx, int vAlign = -1) { CCanvas::ScrollTo (GetItemRect (idx), 0, vAlign); Changed (); }
    void ScrollIn (int idx) { CCanvas::ScrollIn (GetItemRect (idx)); Changed (); }
 
    void SelectItem (int idx, bool _isSelected = true);   
    void SelectAll (bool _isSelected = true);             
    void SelectNone () { SelectAll (false); }             
 
    bool MouseDown () { return downIdx >= 0; }
 
    bool ItemIsSelected (int idx) { return itemArr[idx].isSelected; }
    int GetSelectedItem () { return selectedItem; }       // 'lmSelectSingle' only
 
    virtual void OnPushed (int idx, bool longPush) { if (cbPushed) cbPushed (this, idx, longPush, cbPushedData); }
    void SetCbPushed (FCbListboxPushed *_cbPushed, void *_data = NULL) { cbPushed = _cbPushed; cbPushedData = _data; }
 
    void ChangedItems (int idx, int num = 1);    
 
    virtual void Render (SDL_Renderer *ren);
    virtual bool HandleEvent (SDL_Event *ev);
 
  protected:
    CListboxItem *itemArr;
    int items;
    CWidget **pool;
    int poolSize, *poolIdx;
    int selectedItem, downIdx, downSelectedItem;
    bool noLongPush;
    bool changed;
 
    // Configuration options...
    EListboxMode mode;
    int itemGap, itemHeight;
    FCbListboxPushed *cbPushed;
    void *cbPushedData;
 
    // Infos for 'RenderItem' only...
    TTF_Font *font;
    int hAlign;
    TColor colLabel, colBack, colLabelSelected, colBackSelected, colLabelSpecial, colBackSpecial;
 
    virtual SDL_Surface *RenderItem (CListboxItem *item, int idx, SDL_Surface *surf);
 
    void ChangedSetup () { InvalidatePool (); Changed (); }
    void Changed () { changed = true; CCanvas::Changed (); }
 
  private:
 
    // Helpers...
    void InvalidatePool ();   // called if something general changed (e.g. colors, area)
    void UpdatePool ();       // update pool before rendering
};
 
 
 
 
 
 
 
// *************************** CMenu *******************************************
 
 
 
 
#define MENU_DEFAULT_FONT FontGet (fntNormal, 20) 
#define MENU_DEFAULT_COLOR DARK_GREY              
 
 
class CMenu: public CListbox, public CModalWidget {
  public:
    CMenu () { texFrame = NULL; }
    ~CMenu () { TextureFree (&texFrame); }
 
    void Setup (SDL_Rect _rContainer, int _hAlign = -1, int _vAlign = -1,  // The exact geometry is determined in 'Start'
                TColor color = MENU_DEFAULT_COLOR, TTF_Font *_font = NULL);
 
    void SetItems (const char *_itemStr);    
    void SetItems (int _items) { CListbox::SetItems (_items); }
    void SetItem (int idx, const char *_text, SDL_Surface *_surfIcon = NULL, bool _isSpecial = false, void *data = NULL) { CListbox::SetItem (idx, _text, _surfIcon, _isSpecial, data); }
 
    int Run (CScreen *_screen, const char *_itemStr) { SetItems (_itemStr); return Run (_screen); }
    int Run (CScreen *_screen) { return CModalWidget::Run (_screen); }
    virtual void Start (CScreen *_screen);
 
    bool GetStatusLongPush () { return hadLongPush; }
 
    SDL_Rect *GetArea () { return &rFrame; }   // Note: Is different from 'CWidget::area', which here only contains the canvas part of the menu
 
    virtual void Render (SDL_Renderer *ren);
    virtual bool HandleEvent (SDL_Event *ev);
    virtual void OnPushed (int idx, bool longPush);
 
  protected:
    SDL_Rect rContainer, rFrame;
    int hAlign, vAlign;
    CString itemStr;
    SDL_Texture *texFrame;
    bool hadLongPush;
};
 
 
// Easy-to-use function(s)...
int RunMenu (const char *_itemStr, SDL_Rect _rContainer, int _hAlign = -1, int _vAlign = -1,
             TColor color = MENU_DEFAULT_COLOR, TTF_Font *_font = NULL,
             bool *retLongPush = NULL);
 
 
 
 
 
 
 
// *************************** Message Box *************************************
 
 
 
 
#define MSGBOX_DEFAULT_FONT FontGet (fntNormal, 24)   
#define MSGBOX_TITLE_FONT FontGet (fntBold, 32)       
 
#define MSGBOX_COLOR DARK_GREY                        
 
#define MSGBOX_SPACE_X 32                             
#define MSGBOX_SPACE_Y 32                             
#define MSGBOX_BUTTON_MINWIDTH 160                        
 
 
 
enum EMessageButtonId {
  mbiCancel = 0,
  mbiOk,
  mbiNo,
  mbiYes,
  mbiEND
};
 
 
#define mbmCancel ((int) (1 << mbiCancel))    
#define mbmOk ((int) (1 << mbiOk))            
#define mbmNo ((int) (1 << mbiNo))            
#define mbmYes ((int) (1 << mbiYes))          
 
#define mbmOkCancel (mbmOk | mbmCancel)       
#define mbmYesNoCancel (mbmYes | mbmNo | mbmCancel)   
#define mbmNone ((int) 0)                     
 
 
class CMessageBox: public CModalWidget {
  public:
    CMessageBox () { buttons = 0; buttonArr = NULL; screenHasKeyboard = false; }
    ~CMessageBox () { Stop (); SurfaceFree (&surface); }
 
    void Setup (const char *title, int contentW, int contentH, int _buttons, CButton **_buttonArr, TColor color = MSGBOX_COLOR, int titleHAlign = 0);
      // TBD: FIX this: replace int "int contentW, int contentH" by "SDL_Surface *content"!!!
    CButton *GetStdButton (EMessageButtonId buttonId);
 
    void Setup (const char *title, int contentW, int contentH, int buttonMask, TColor color = MSGBOX_COLOR);
      // TBD: FIX this: replace int "int contentW, int contentH" by "SDL_Surface *content"!!!
 
    void Setup (const char *title, const char *text, SDL_Surface *icon = NULL, int buttonMask = mbmOk, int hAlign = 0, TTF_Font *font = NULL);
 
    SDL_Rect *ContentArea () { return &rContent; }
 
    int GetChoice () { return GetStatus (); }
 
    virtual void Start (CScreen *_screen);
    virtual void Stop ();
    virtual void OnButtonPushed (CButton *button, bool);
 
  protected:
    CButton stdButtons[mbiEND], **buttonArr, *stdButtonArr[mbiEND];
    SDL_Rect rContent;
    int buttons;
    bool screenHasKeyboard;
};
 
 
int RunMessageBox (const char *title, const char *text, int buttonMask = mbmOk, SDL_Surface *icon = NULL, int hAlign = 0, TTF_Font *font = NULL);
 
int RunInfoBox (const char *text, SDL_Surface *icon = NULL, int hAlign = 0, TTF_Font *font = NULL);
int RunInfoBox (const char *title, const char *text, SDL_Surface *icon = NULL, int hAlign = 0, TTF_Font *font = NULL);
int RunWarnBox (const char *text, SDL_Surface *icon = NULL, int hAlign = 0, TTF_Font *font = NULL);
int RunWarnBox (const char *title, const char *text, SDL_Surface *icon = NULL, int hAlign = 0, TTF_Font *font = NULL);
int RunErrorBox (const char *text, SDL_Surface *icon = NULL, int hAlign = 0, TTF_Font *font = NULL);
int RunErrorBox (const char *title, const char *text, SDL_Surface *icon = NULL, int hAlign = 0, TTF_Font *font = NULL);
 
int RunSureBox (const char *text, SDL_Surface *icon = NULL, int hAlign = 0, TTF_Font *font = NULL);
int RunSureBox (const char *title, const char *text, SDL_Surface *icon = NULL, int hAlign = 0, TTF_Font *font = NULL);
int RunQueryBox (const char *text, SDL_Surface *icon = NULL, int hAlign = 0, TTF_Font *font = NULL);
int RunQueryBox (const char *title, const char *text, SDL_Surface *icon = NULL, int hAlign = 0, TTF_Font *font = NULL);
 
 
CMessageBox *StartMessageBox (const char *title, const char *text, SDL_Surface *icon = NULL, int buttonMask = mbmOk, int hAlign = 0, TTF_Font *font = NULL);
static inline void IterateMessageBox () { UiIterate (); }
static inline int GetMessageBoxStatus (CMessageBox *msgBox) { return msgBox->GetStatus (); }
void StopMessageBox (CMessageBox *msgBox);
 
 
 
 
 
 
 
// *************************** CInputLine **************************************
 
 
 
 
#define INPUTLINE_FONTSIZE 24
#define INPUTLINE_UNDOS 32
#define INPUTLINE_MAXLEN 512
  // The maximum length must be selected such that the rendered string does not exceed the
  // maximum texture width of currently 16384 pixels [2022-11-04].
 
class CInputLine: public CCanvas {
  public:
    CInputLine () { font = NULL; inputLen = 0; mark0 = markD = 0; suggPos = -1; cbSuggCheck = NULL; suggData = NULL; undoFirst = redoFirst = NULL; surfMain = NULL; changedContent = changedMark = false; }
    ~CInputLine () { SurfaceFree (&surfMain); ClearHistory (); }
 
    void Setup (int fontSize = INPUTLINE_FONTSIZE);
    void SetInput (const char *_inputStr = NULL, int _mark0 = 0, int _markD = 0);
    void ClearHistory ();   
 
    void GetInput (CString *ret) { ret->SetFromIso8859 (input.Get ()); }
    bool InputModified ();      
 
    int GetMark0 () { return mark0; }    
    int GetMarkD () { return markD; }
    void SetMark (int _mark0, int _markD = 0);
    void MoveMark (int _mark0);         
 
    void InsChar (char c);
    void InsText (const char *txt, int chars = -1);
    void DelMarked ();
    void DelChar (int pos);
 
    CString *GetInput () { return &input; }
    void ChangedInput ();   
 
    void ClipboardCopy ();
    void ClipboardCut () { ClipboardCopy (); DelMarked (); }
    void ClipboardPaste ();
 
    void Undo ();
    void Redo ();
 
    void SetSuggestion (int _suggPos, const char *_suggText, int _suggMark0 = -1, int _suggMarkD = 0);    // '_suggText' must be in ISO 8859
    void ClearSuggestion () { SetSuggestion (-1, NULL); }
    void ApplySuggestion ();
    virtual void CheckSuggestion () { if (cbSuggCheck) cbSuggCheck (this, suggData); }    // called when
    void SetCbCheckSuggestion (void (*_cbSuggCheck) (CInputLine *, void *), void *_suggData) { cbSuggCheck = _cbSuggCheck; suggData = _suggData; }
 
    virtual void Render (SDL_Renderer *ren);
    virtual bool HandleEvent (SDL_Event *ev);
 
  protected:
    TTF_Font *font;
    int charWidth;
    CString input;    // ISO 8859
    int inputLen;
    int mark0, markD;     // 'markD' may also be negative; 'mark0' is always the cursor position
    class CUndoState *undoFirst, *redoFirst;
 
    int suggPos, suggMark0, suggMarkD;        // 'suggPos < 0' => no suggestion
    CString suggText; // ISO 8859
    void (*cbSuggCheck) (CInputLine *, void *);
    void *suggData;
 
    CCursorWidget wdgMain;
    SDL_Surface *surfMain;
 
    bool changedContent, changedMark;
 
    // Undoing/Redoing...
    void ClearStateList (class CUndoState **pList);
    void PushInput ();
    void PushMark ();
    void SetState (class CUndoState *s);
 
    // Change management...
    // ChangedInput (): see above
    void ChangedContent () { changedContent = true; Changed (); }   // input or suggestion
    void ChangedMark ();
 
    // Helpers...
    int GetCharOfMouseEvent (SDL_Event *ev);
};
 
 
class CInputScreen: public CScreen {
  public:
    CInputScreen () {}
    ~CInputScreen ();
 
    void Setup (const char *label, const char *inputPreset, TColor color = GREY, int userBtns = 0, CButton **userBtnList = NULL, const int *userBtnWidth = NULL);
 
    CInputLine *InputLine () { return &wdgInput; }
    void SetInput (const char *_inputStr=NULL, int _mark0=0, int _markD=0) { wdgInput.SetInput (_inputStr, _mark0, _markD); }
    void GetInput (CString *ret) { wdgInput.GetInput (ret); }
    bool InputModified () { return wdgInput.InputModified (); }
 
  protected:
    CWidget wdgLabel;
    CInputLine wdgInput;
    CButton btnBack, btnUndo, btnRedo, btnCut, btnCopy, btnPaste, btnOk;
 
    virtual void Commit () { Return (); }
    virtual void Cancel () { Return (); }
    virtual void OnUserButtonPushed (CButton *btn, bool longPush) {}
 
  private:
    friend void CbInputScreenOnButtonPushed (CButton *, bool, void *);
 
    void OnButtonPushed (CButton *btn, bool longPush);
};
 
 
 
 
 
 
 
// *************************** CSlider *****************************************
 
 
 
 
#define SLIDER_WIDTH 48           
#define SLIDER_BAR_HEIGHT 16      
 
 
#define SLIDER_TRAMPOLINE(CB_NAME, CLASS_NAME, METHOD_NAME)                   \
  void CB_NAME (class CSlider *slider, int val, int lastVal, void *data) {    \
    ((CLASS_NAME *) data)->METHOD_NAME (slider, val, lastVal);                \
  }
 
 
class CSlider: public CWidget {
  public:
    CSlider ();
    virtual ~CSlider ();
 
    void SetFormat (TColor _colSlider, TColor _colBarLower, TColor _colBarUpper, TColor _colBack = TRANSPARENT, int _sliderW = SLIDER_WIDTH, int _barH = SLIDER_BAR_HEIGHT);
    void SetArea (SDL_Rect _area);
    void SetInterval (int _val0, int _val1, bool _continuousUpdate = true);
 
    int GetValue () { return val; }
    void SetValue (int _val, bool callOnValueChanged = false);
 
    virtual void OnValueChanged (int val, int lastVal);
    void SetCbValueChanged (void (*_cbValueChanged) (class CSlider *, int, int, void *), void *_data = NULL) { cbValueChanged = _cbValueChanged; cbValueChangedData = _data; }
 
    virtual SDL_Surface *GetSurface ();
    virtual bool HandleEvent (SDL_Event *ev);
 
  protected:
    int sliderW, barH;
    TColor colSlider, colBarLower, colBarUpper, colBack;
    bool continuousUpdate, isDown, redraw;
 
    int val0, val1, val;
    int slider0, downX;    // X position of slider and of last "touch down" event
 
    void (*cbValueChanged) (class CSlider *, int, int, void *);
    void *cbValueChangedData;
 
    void ChangedSurface () { redraw = true; CWidget::ChangedSurface (); }
    void Changed () { redraw = true; CWidget::Changed (); }
 
    // Helpers...
    void SetSlider0 (int _slider0, bool updateVal);
};
 
 
 
 
 
 
#endif