home2l/home2l-api_c/ui__widgets_8H_source.html

/*

 *  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_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

CButton
Push-button widget.
Definition: ui_widgets.H:214

CButton::SetLabel
void SetLabel(SDL_Surface *_icon, SDL_Rect *srcRect=NULL, bool takeOwnership=false)
Set '_icon' as the button label.

CButton::SetLabel
void SetLabel(const char *text, TColor textColor=WHITE, TTF_Font *font=NULL)
Set a text-only label.

CButton::SetLabelAlignment
void SetLabelAlignment(int _hAlign=0, int _vAlign=0)
Set/change label alignment.
Definition: ui_widgets.H:259

CButton::HandleEvent
virtual bool HandleEvent(SDL_Event *ev)
Handle an event and return 'true' if the event was consumed and is to be ignored by later widgets.

CButton::ClearLabel
void ClearLabel()
Remove label.
Definition: ui_widgets.H:257

CButton::GetSurface
virtual SDL_Surface * GetSurface()
Get an up-to-date surface or 'NULL' if none is available.

CButton::SetHotkey
void SetHotkey(SDL_Keycode _hotkey)
Set hotkey which activates the button callback.
Definition: ui_widgets.H:262

CCanvas
Canvas widget.
Definition: ui_screen.H:213

CCanvas::ScrollTo
void ScrollTo(SDL_Rect r, int hAlign=0, int vAlign=-1)
Scroll such that 'r' is aligned according to '[vh]Align' (-1 = left/up, 0 = center,...

CCanvas::ScrollIn
void ScrollIn(SDL_Rect r)
Scroll just enough to get 'r' fully visible.

CCursorWidget
Widget with an additional rectangular cursor.
Definition: ui_widgets.H:125

CCursorWidget::Render
virtual void Render(SDL_Renderer *ren)
Render this widget.

CCursorWidget::HandleEvent
virtual bool HandleEvent(SDL_Event *ev)
Handle an event and return 'true' if the event was consumed and is to be ignored by later widgets.

CFlatButton
Flat Push-button widget.
Definition: ui_widgets.H:310

CFlatButton::GetSurface
virtual SDL_Surface * GetSurface()
Get an up-to-date surface or 'NULL' if none is available.

CInputLine
Input line widget.
Definition: ui_widgets.H:793

CInputLine::InputModified
bool InputModified()
Return if anything may have changed.

CInputLine::GetMark0
int GetMark0()
Return the cursor position.
Definition: ui_widgets.H:815

CInputLine::GetInput
CString * GetInput()
Return string (ISO 8859!) that may be modified arbitrarily, followed by a call to ChangedInput().
Definition: ui_widgets.H:825

CInputLine::ClearHistory
void ClearHistory()
Clear the undo & redo history.

CInputLine::Render
virtual void Render(SDL_Renderer *ren)
Render this widget.

CInputLine::ChangedInput
void ChangedInput()
To be called if the imput string was changed.

CInputLine::SetInput
void SetInput(const char *_inputStr=NULL, int _mark0=0, int _markD=0)
Set the input contents; implicitly calls 'ClearHistory' afterwards.

CInputLine::MoveMark
void MoveMark(int _mark0)
Set 'mark0' while leaving 'mark0 + markD' constant.

CInputLine::GetInput
void GetInput(CString *ret)
Retrieve the current string.
Definition: ui_widgets.H:808

CInputLine::HandleEvent
virtual bool HandleEvent(SDL_Event *ev)
Handle wiping/scrolling events, if virtual area is wider (higher) than physical area.

CInputScreen
Screen with an input line widget.
Definition: ui_widgets.H:899

CInputScreen::Cancel
virtual void Cancel()
Definition: ui_widgets.H:938

CInputScreen::OnUserButtonPushed
virtual void OnUserButtonPushed(CButton *btn, bool longPush)
Called on push of any user button.
Definition: ui_widgets.H:941

CInputScreen::Setup
void Setup(const char *label, const char *inputPreset, TColor color=GREY, int userBtns=0, CButton **userBtnList=NULL, const int *userBtnWidth=NULL)

CInputScreen::Commit
virtual void Commit()
Called on push of the "OK" button. May call Return() on success or not to continue editing.
Definition: ui_widgets.H:936

CInputScreen::SetInput
void SetInput(const char *_inputStr=NULL, int _mark0=0, int _markD=0)
see CInputLine::SetInput ().
Definition: ui_widgets.H:921

CInputScreen::InputModified
bool InputModified()
see CInputLine::InputModified ().
Definition: ui_widgets.H:925

CInputScreen::GetInput
void GetInput(CString *ret)
see CInputLine::GetInput ().
Definition: ui_widgets.H:923

CListboxItem
Listbox item.
Definition: ui_widgets.H:397

CListboxItem::changed
bool changed
If set, item will be re-rendered at next occasion.
Definition: ui_widgets.H:421

CListboxItem::SetLabel
void SetLabel(const char *_text, const char *_iconName=NULL)
Set label with a text and icon, both are optional. The icon is recolored as the text.
Definition: ui_widgets.H:403

CListboxItem::data
void * data
Reference to optional user data.
Definition: ui_widgets.H:411

CListboxItem::isSpecial
bool isSpecial
Item is special, e.g. a head line.
Definition: ui_widgets.H:410

CListbox
Listbox widget.
Definition: ui_widgets.H:427

CListbox::GetItemRect
SDL_Rect GetItemRect(int idx)
Get the area of an item.

CListbox::MouseDown
bool MouseDown()
Determine whether the listbox is currently dragged by the mouse. In this case, calling a Select....
Definition: ui_widgets.H:472

CListbox::SelectItem
void SelectItem(int idx, bool _isSelected=true)
(De-)Select item (for 'lmSelectSingle', 'lmSelectAny')

CListbox::ChangedItems
void ChangedItems(int idx, int num=1)
Must be called if items changed and SetItem() was not called.

CListbox::Render
virtual void Render(SDL_Renderer *ren)
Render this widget.

CListbox::SelectAll
void SelectAll(bool _isSelected=true)
Select all items (for 'lmSelectAny')

CListbox::SetFormat
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)
Except 'colGrid', all parameters set here are only read in 'RenderItem' & can be ommited (or re-inter...

CListbox::RenderItem
virtual SDL_Surface * RenderItem(CListboxItem *item, int idx, SDL_Surface *surf)
Render a list box item to an SDL surface and return it.

CListbox::SetMode
void SetMode(EListboxMode _mode, int _itemHeight, int _itemGap=1)
'itemHeight' == 0 indicates variable-height items (Note: presently much worse performance than fixed-...

CListbox::SelectNone
void SelectNone()
Deselect all items (for 'lmSelectSingle', 'lmSelectAny')
Definition: ui_widgets.H:470

CListbox::HandleEvent
virtual bool HandleEvent(SDL_Event *ev)
Handle wiping/scrolling events, if virtual area is wider (higher) than physical area.

CListbox::GetItemLabelWidth
int GetItemLabelWidth(int idx)
Retrieve the label (net) width of an item (e.g. to optimize geometry).

CMenu
Menu widget.
Definition: ui_widgets.H:565

CMenu::SetItems
void SetItems(const char *_itemStr)
Set a list of items separated by '|'.

CMenu::Start
virtual void Start(CScreen *_screen)
Just start the modal widget.

CMenu::Render
virtual void Render(SDL_Renderer *ren)
Render this widget.

CMenu::GetStatusLongPush
bool GetStatusLongPush()
Return whether the push was a long push.
Definition: ui_widgets.H:595

CMenu::HandleEvent
virtual bool HandleEvent(SDL_Event *ev)
Handle event: must always be called last.

CMessageBox
Message box widget.
Definition: ui_widgets.H:683

CMessageBox::GetChoice
int GetChoice()
Return the number of the button pushed, numbered from right to left; the rightmost button (typically ...
Definition: ui_widgets.H:717

CMessageBox::GetStdButton
CButton * GetStdButton(EMessageButtonId buttonId)
Initialize and return a standard button to be used by the previous method.

CMessageBox::Setup
void Setup(const char *title, int contentW, int contentH, int _buttons, CButton **_buttonArr, TColor color=MSGBOX_COLOR, int titleHAlign=0)
The most flexible way.

CMessageBox::Stop
virtual void Stop()
Remove widget from screen (e.g. useful for inactivity timeout).

CMessageBox::Start
virtual void Start(CScreen *_screen)
Just start the modal widget.

CModalWidget
Widget that can pop up on a screen, such as a menu or a message box.
Definition: ui_widgets.H:77

CModalWidget::SetStatus
void SetStatus(int _status)
Set a status code.
Definition: ui_widgets.H:92

CModalWidget::IsRunning
bool IsRunning()
Must be invoked regularly (in each UI iteration), if Run() is not used.

CModalWidget::Stop
virtual void Stop()
Remove widget from screen (e.g. useful for inactivity timeout).

CModalWidget::Start
virtual void Start(CScreen *_screen)
Just start the modal widget.

CModalWidget::SetNoCancelArea
void SetNoCancelArea(SDL_Rect _rNoCancel)
Set the no-cancel area.
Definition: ui_widgets.H:97

CModalWidget::GetStatus
int GetStatus()
Get status: -2: running, -1: cancelled (e.g. by touching outside), >= 0: success, user-defined code s...
Definition: ui_widgets.H:91

CModalWidget::HandleEvent
virtual bool HandleEvent(SDL_Event *ev)
Handle event: must always be called last.

CModalWidget::Run
int Run(CScreen *_screen)
Run the widget until it is cancelled or a status >= 0 is set; return status.

CScreen
Screen object.
Definition: ui_screen.H:293

CScreen::Return
void Return()
Let Run() return at next occasion.
Definition: ui_screen.H:338

CSlider
Slider widget.
Definition: ui_widgets.H:996

CSlider::SetValue
void SetValue(int _val, bool callOnValueChanged=false)
Set the current value; The passed value will be clipped to the allowed range.

CSlider::SetInterval
void SetInterval(int _val0, int _val1, bool _continuousUpdate=true)
Set the logical range of values; Possible values for 'val' are then '_val0 <= val <= _val1'.

CSlider::HandleEvent
virtual bool HandleEvent(SDL_Event *ev)
Handle an event and return 'true' if the event was consumed and is to be ignored by later widgets.

CSlider::GetSurface
virtual SDL_Surface * GetSurface()
Get an up-to-date surface or 'NULL' if none is available.

CString
Dynamically allocated string.
Definition: base.H:635

CString::SetFromIso8859
void SetFromIso8859(const char *iso8859str)
'this' will be a (normal) UTF-8 string, the source is expected to be ISO-8859

CString::Get
char * Get() const
Get the C string. Unless explicitely set by 'SetC', this will never return NULL or an invalid pointer...
Definition: base.H:687

CWidget
Base class for all widgets.
Definition: ui_screen.H:94

CWidget::ChangedSurface
void ChangedSurface()
Mark (only) the surface as changed to trigger a redrawing at next occasion.
Definition: ui_screen.H:185

CWidget::Changed
void Changed()
Anything may have changed: Trigger a redrawing at next occasion.

RectScreen
static SDL_Rect RectScreen()
Rectangle representing the whole UI screen.
Definition: ui_base.H:355

UiIterate
void UiIterate(bool noWait=false)

IconGet
SDL_Surface * IconGet(const char *name, TColor color=WHITE, TColor bgColor=TRANSPARENT, int scaleDown=1, int orient=0, bool preserveThinLines=false)
Get a reference to an icon from the application's 'etc/icons/' or 'share/icons/' folder.

CbActivateScreen
void CbActivateScreen(class CButton *, bool, void *screen)
Convenience callback for all sort of "Jump-to-screen" buttons (including home). 'data' must point to ...

CreateMainButtonBar
CButton * CreateMainButtonBar(int buttons, TButtonDescriptor *descTable, CScreen *screen)
Create a dynamic array of CButton objects for a main button bar. 'screen' is passed as the user data ...

FCbButtonPushed
void FCbButtonPushed(class CButton *button, bool longPush, void *data)
Function prototype for CButton callbacks.
Definition: ui_widgets.H:177

FCbListboxPushed
void FCbListboxPushed(class CListbox *, int idx, bool longPush, void *data)
Callback prototype for CListbox push events.
Definition: ui_widgets.H:367

EListboxMode
EListboxMode
List box mode.
Definition: ui_widgets.H:359

lmSelectAny
@ lmSelectAny
Items are arbitrarily selectable (activation callback can be defined, too).
Definition: ui_widgets.H:363

lmActivate
@ lmActivate
Items act like push-buttons, activation callback can be defined.
Definition: ui_widgets.H:361

lmReadOnly
@ lmReadOnly
Listbox is read-only, no selection & interaction.
Definition: ui_widgets.H:360

lmSelectSingle
@ lmSelectSingle
Items are exclusivly selectable (activation callback can be defined, too).
Definition: ui_widgets.H:362

RunMenu
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)
Run a menu with a single function call.

MENU_DEFAULT_COLOR
#define MENU_DEFAULT_COLOR
Default color for menus.
Definition: ui_widgets.H:560

RunSureBox
int RunSureBox(const char *title, const char *text, SDL_Surface *icon=NULL, int hAlign=0, TTF_Font *font=NULL)
Run an "Are you sure?" box. Returns 1 if sure and <= 0 otherwise.

RunQueryBox
int RunQueryBox(const char *title, const char *text, SDL_Surface *icon=NULL, int hAlign=0, TTF_Font *font=NULL)
Run a "Yes/No/Cancel" query box. Returns 2 on "yes", 1 on "no" and 0 otherwise.

RunMessageBox
int RunMessageBox(const char *title, const char *text, int buttonMask=mbmOk, SDL_Surface *icon=NULL, int hAlign=0, TTF_Font *font=NULL)
Run an arbitray message box.

RunWarnBox
int RunWarnBox(const char *title, const char *text, SDL_Surface *icon=NULL, int hAlign=0, TTF_Font *font=NULL)
Run an warning box with an "OK" button.

MSGBOX_COLOR
#define MSGBOX_COLOR
Default color for message boxes.
Definition: ui_widgets.H:651

mbmOk
#define mbmOk
Bit mask to select an "OK" button.
Definition: ui_widgets.H:670

EMessageButtonId
EMessageButtonId
IDs for standard buttons.
Definition: ui_widgets.H:660

RunErrorBox
int RunErrorBox(const char *title, const char *text, SDL_Surface *icon=NULL, int hAlign=0, TTF_Font *font=NULL)
Run an error box with an "OK" button.

RunInfoBox
int RunInfoBox(const char *title, const char *text, SDL_Surface *icon=NULL, int hAlign=0, TTF_Font *font=NULL)
Run an info box with an "OK" button.

SLIDER_WIDTH
#define SLIDER_WIDTH
Default width of a slider.
Definition: ui_widgets.H:966

SLIDER_BAR_HEIGHT
#define SLIDER_BAR_HEIGHT
Default height of a slider bar.
Definition: ui_widgets.H:967

TButtonDescriptor
Descriptor for a button on the main button bar.
Definition: ui_widgets.H:325

ui_screen.H