EKeyboard Class Reference

Inheritance diagram for EKeyboard:

Collaboration diagram for EKeyboard:

Public Member Functions
	EKeyboard (std::function< void(char)> typeAction)
void	render (Element *parent)
	display the current state of the display More...
bool	process (InputEvents *event)
	process any input that is received for this element More...
void	updateSize ()
void	just_type (const char input)
bool	listenForPhysicalKeys (InputEvents *e)
const std::string &	getTextInput ()
int	rowCount ()
int	rowLength (int row)
void	type (int y, int x)
void	generateEKeyboard ()
void	backspace ()
Public Member Functions inherited from Element
virtual bool	process (InputEvents *event)
	process any input that is received for this element More...
virtual void	render (Element *parent)
	display the current state of the display More...
bool	onTouchDown (InputEvents *event)
bool	onTouchDrag (InputEvents *event)
bool	onTouchUp (InputEvents *event)
void	hide ()
void	unhide ()
void	renderBackground (bool fill=true)
void	append (Element *element)
void	remove (Element *element)
void	removeAll (bool moveToTrash=false)
void	position (int x, int y)
	position the element More...
void	recalcPosition (Element *parent)
CST_Rect	getBounds ()
CST_Renderer *	getRenderer ()
void	wipeAll (bool delSelf=false)
Element *	child (Element *child)
Element *	setPosition (int x, int y)
Element *	setAction (std::function< void()> func)
Element *	centerHorizontallyIn (Element *parent)
Element *	centerVerticallyIn (Element *parent)
Element *	centerIn (Element *parent)
Element *	setAbsolute (bool isAbs)
Element *	constrain (int flags, int padding=0)
Element *	animate (int durationIn, std::function< void(float)> onStep, std::function< void()> onFinish)
Element *	moveToFront ()
Element *	setTouchable (bool touchable)
void	screenshot (std::string path)
	Take a screenshot of this element and its children, and save it to the given path. More...

Public Attributes
std::string	textInput
std::function< void(char)>	typeAction = NULL
const char *	lower_keys = "`1234567890-=qwertyuiop[]\\asdfghjkl;'zxcvbnm,./"
const char *	upper_keys = "~!@#$\%^&*()_+QWERTYUIOP{}|ASDFGHJKL:\"ZXCVBNM<>?"
int	breaks [4] = { 13, 13, 11, 10 }
std::vector< std::string * >	rows
const CST_Keycode	usbKeys [KEYCODE_COUNT]
bool	shiftOn = false
bool	capsOn = false
int	mode = 0
int	curRow = -1
int	index = -1
int	keyWidth = 0
int	padding = 0
int	textSize = 0
int	dPos = 0
int	dHeight = 0
int	sPos = 0
int	enterPos = 0
int	enterHeight = 0
int	dWidth = 0
int	sWidth = 0
int	enterWidth = 0
int	kXPad = 0
int	kXOff = 0
int	yYOff = 0
int	kYPad = 0
int	ySpacing = 0
bool	hasRoundedKeys = false
CST_Font *	roundKeyFont = NULL
bool	touchMode = false
bool	immersiveMode = false
bool	preventEnterAndTab = false
bool	storeOwnText = false
bool	isTouchDrag = false
Public Attributes inherited from Element
std::function< void()>	action = NULL
	the action to call (from binded callback) on touch or button selection https://stackoverflow.com/questions/14189440/c-class-member-callback-simple-examples More...
std::function< void(InputEvents *event)>	actionWithEvents = NULL
std::vector< Element * >	elements
	visible GUI child elements of this element More...
float	scale = 1.0f
bool	touchable = false
	whether or not this element can be touched (highlights bounds) More...
bool	dragging = false
	whether or not this element is currently being dragged More...
bool	needsRedraw = false
	whether or not this element needs the screen redrawn next time it's processed More...
int	futureRedrawCounter = 0
	whether this element needs a redraw for the next X redraws (decreases each time) (0 is no redraws) More...
int	lastMouseY = 0
	the last Y, X coordinate of the mouse (from a drag probably) More...
int	lastMouseX = 0
bool	hasBackground = false
rgb	backgroundColor = {0, 0, 0}
bool	isAbsolute = false
Element *	parent = NULL
	the parent element (can sometimes be null if it isn't set) More...
bool	hidden = false
	whether this element should skip rendering or not More...
bool	isProtected = false
int	elasticCounter = 0
	how much time is left in an elastic-type flick/scroll set by the last distance traveled in a scroll, and counts down every frame More...
int	width = 0
	width and height of this element (must be manually set, isn't usually calculated (but is in some cases, like text or images)) More...
int	height = 0
int	x = 0
int	y = 0
int	xAbs = 0
int	yAbs = 0
double	angle = 0
	rotation angle in degrees More...
int	xOff = 0
int	yOff = 0
std::vector< Constraint * >	constraints
std::vector< Animation * >	animations
bool	useColorMask = false
	whether or not to overlay a color mask on top of this element More...
CST_Color	maskColor = {0,0,0,0}
	The color to overlay on top. More...

Additional Inherited Members
Public Types inherited from Element
typedef Element	super

Detailed Description

Definition at line 7 of file EKeyboard.hpp.

Constructor & Destructor Documentation

EKeyboard() [1/2]

EKeyboard::EKeyboard

(

)

Definition at line 5 of file EKeyboard.cpp.

                     : EKeyboard::EKeyboard(NULL)
{
    storeOwnText = true;
}

EKeyboard() [2/2]

EKeyboard::EKeyboard

(

std::function< void(char)>

typeAction

)

Definition at line 10 of file EKeyboard.cpp.

{
    this->x = 30;
    this->y = SCREEN_HEIGHT - 420;
 
    this->width = SCREEN_WIDTH - 380;
 
    this->typeAction = typeAction;
 
    curRow = index = -1;
    this->isAbsolute = true;
 
    // position the EKeyboard based on this x and y
    updateSize();
}

~EKeyboard()

EKeyboard::~EKeyboard

(

)

Definition at line 633 of file EKeyboard.cpp.

{
    InputEvents::bypassKeyEvents = false;
}

Member Function Documentation

backspace()

void EKeyboard::backspace

(

)

Definition at line 609 of file EKeyboard.cpp.

{
    if (storeOwnText) {
        // manage our own internal string
        if (!textInput.empty())
            textInput.pop_back();
        // call out to the typing callback TODO: use a separate callback (see below)
        typeAction('\b'); // not great
        return;
    }
 
    // TODO: use a backspace callback instead of hardcoding a B button event
    // (B is used by vgedit to manage external backspaces)
    SDL_Event sdlevent;
    sdlevent.type = SDL_JOYBUTTONDOWN;
    sdlevent.jbutton.button = SDL_B;
    SDL_PushEvent(&sdlevent);
}

generateEKeyboard()

void EKeyboard::generateEKeyboard

(

)

Definition at line 563 of file EKeyboard.cpp.

{
    int count = 0;
    string keys;
 
    if (mode == 0)
        keys = string((shiftOn || capsOn) ? upper_keys : lower_keys);
    else
    {
        // depending on the mode, grab a bunch of characters from unicode starting from
        // upside exclamation mark (U+00A1) and onward https://unicode-table.com/en/
        // TODO: don't hardcode amount here, or hardcode a better one
        int offset = 47 * (mode - 1) + 0x00a1;
        char chars[47 + (mode == 2)];
        for (int x = 0; x < 47 + (mode == 2); x++)
        {
            chars[x] = offset + x;
        }
 
        keys = string(chars);
    }
 
    breaks[3] += (mode == 2); // one more key for bottom row of mode 2
 
    for (int& end : breaks)
    {
        auto roundedOffset = (hasRoundedKeys && count == 0) ? 1 : 0;
        string* row = new string(keys.substr(count + roundedOffset, end - roundedOffset));
        for (int x = 1; x < (int)row->size(); x += 2)
        {
            row->insert(row->begin() + x, ' ');
        }
 
        rows.push_back(row);
        count += end;
    }
 
    if (hasRoundedKeys && roundKeyFont == NULL) {
        // load the round key font
        roundKeyFont = CST_CreateFont();
        auto fontPath = RAMFS "res/lightsans.ttf";
        auto renderer = getRenderer();
        CST_LoadFont(roundKeyFont, renderer, fontPath, 40, CST_MakeColor(0,0,0,255), TTF_STYLE_NORMAL);
    }
}

getTextInput()

const std::string & EKeyboard::getTextInput

(

)

Definition at line 628 of file EKeyboard.cpp.

{
    return textInput;
}

just_type()

void EKeyboard::just_type

(

const char

input

)

Definition at line 547 of file EKeyboard.cpp.

{
    if (preventEnterAndTab && (input == '\n' || input == '\t'))
        return;
 
    // store our own string if we need to
    if (storeOwnText)
        textInput.push_back(input);
 
    // call the underlying type action, if present
    if (typeAction != NULL) {
        typeAction(input);
        return;
    }
}

listenForPhysicalKeys()

bool EKeyboard::listenForPhysicalKeys

(

InputEvents *

e

)

Definition at line 354 of file EKeyboard.cpp.

{
    int curBreak = 0;
    int offset = 0;
 
    auto keyCode = e->keyCode;
    auto mod = e->mod;
 
    // special keys
    if (keyCode == SDLK_LSHIFT || keyCode == SDLK_RSHIFT || keyCode == SDLK_CAPSLOCK) {
        shiftOn = true;
        updateSize();
        return true;
    }
 
    if (keyCode == SDLK_TAB) {
        just_type('\t');
        return true;
    }
    if (keyCode == SDLK_SPACE) {
        just_type(' ');
        return true;
    }
    if (keyCode == SDLK_RETURN && !preventEnterAndTab) {
        just_type('\n');
        return true;
    }
 
    // alt key will toggle the keyboard, but still allow inputs
    if (keyCode == SDLK_LALT || keyCode == SDLK_RALT) {
        immersiveMode = !immersiveMode;
        return true;
    }
 
    // primary typing loop, handles all the keycodes on our keyboard
    auto roundedOffset = hasRoundedKeys ? 1 : 0;
    for (int x=roundedOffset; x<KEYCODE_COUNT; x++)
    {
        int xx = x - offset;
        int topRowOffset = curBreak == 0 ? roundedOffset : 0;
 
        if (keyCode == usbKeys[x])
        {
            // we got a key down for this code, type our current position
            // and update cursor
            type(curBreak, xx - topRowOffset);
            curRow = curBreak;
            index = xx - topRowOffset;
            return true;
        }
 
        if (xx + 1 >= breaks[curBreak]) {
            curBreak++;
            offset = x + 1;
        }
    }
 
    // below are progammatic invocations of certain features we expect to be there
    // in vgedit
    // TODO: either make these callbacks or internal calls rather than going through SDL event engine
 
    if (keyCode == SDLK_BACKSPACE) {
        // programatically invoke the B button event
        backspace();
        return true;
    }
 
    if (keyCode == SDLK_RETURN && preventEnterAndTab) {
        // if don't allow enter, let's consider RETURN as submitting the type action (hardcoded to X button)
        // TODO: make it its own callback
        SDL_Event sdlevent;
        sdlevent.type = SDL_JOYBUTTONDOWN;
        sdlevent.jbutton.button = SDL_X;
        SDL_PushEvent(&sdlevent);
        return true;
    }
 
    if (keyCode == SDLK_ESCAPE) {
        // dismiss keyboard, also programmatically
        SDL_Event sdlevent;
        sdlevent.type = SDL_JOYBUTTONDOWN;
        sdlevent.jbutton.button = SDL_Y;
        SDL_PushEvent(&sdlevent);
        return true;
    }
 
    return false;
}

process()

bool EKeyboard::process ( InputEvents *  event )

virtual

process any input that is received for this element

Reimplemented from Element.

Definition at line 153 of file EKeyboard.cpp.

{
    InputEvents::bypassKeyEvents = false;
 
    // don't do anything if we're hidden, or there's a sidebar and it's active
    if (hidden)
        return false;
 
    // our keyboard will be processing its own key events (not button events)
    InputEvents::bypassKeyEvents = true;
 
    if (event->type == SDL_KEYDOWN)
        return listenForPhysicalKeys(event);
    if (event->type == SDL_KEYUP && (event->keyCode == SDLK_LSHIFT ||
                                     event->keyCode == SDLK_RSHIFT ||
                                     event->keyCode == SDLK_CAPSLOCK)) {
        shiftOn = false;
        updateSize();
        return true;
    }
 
    // immersive view doesn't use any keyboard touch events
    if (immersiveMode) return false;
 
    if (event->isTouchDown())
    {
        curRow = index = -1;
        touchMode = true;
        isTouchDrag = false;
    }
 
    if (event->isKeyDown())
        touchMode = false;
    
    bool ret = false;
    
    // only set touch drag if a selection hasn't been made
    auto prevTouchDrag = isTouchDrag;
    isTouchDrag = (event->isTouchDrag() && (!touchMode || (curRow < 0 && index < 0))) || isTouchDrag;
    if (prevTouchDrag != isTouchDrag && isTouchDrag) {
        // started a drag event, play vibrate
        CST_LowRumble(event, 200);
        ret = true;
    }
 
    if (!touchMode && !isTouchDrag)
    {
        if (curRow < 0 && index < 0)
        {
            // switched into EKeyboard, set to 0 and return
            curRow = 1;
            index = 0;
            return true;
        }
 
        if (event->isKeyDown())
        {
            int lastRow = curRow;
            curRow += (event->held(DOWN_BUTTON) - event->held(UP_BUTTON));
            index += (event->held(RIGHT_BUTTON) - event->held(LEFT_BUTTON));
 
            if (curRow < 0) curRow = 0;
            if (index < 0) index = 0;
            if (curRow >= rowCount() + 1) curRow = rowCount(); // +1 for bottom "row" (tab, space, enter)
            if (curRow == rowCount())
            {
                // go to space key if last index is in the middle of row
                if (lastRow < curRow && index > 0 && index < rowLength(lastRow))
                {
                    index = 1;
                }
 
                // tab key
                if (index < 0) index = 0;
 
                // enter key
                if (index > 2) index = 2;
            }
            else
            {
                if (index > rowLength(curRow))
                    index = rowLength(curRow);
 
                if (lastRow == rowCount()) {
                    switch (index)
                    {
                        case 0: //tab
                            index = 0;
                            break;
                        case 1: // space
                            // go to middle of current row
                            index = rowLength(curRow) / 2;
                            break;
                        case 2: // enter
                            // go to end of current row
                            index = rowLength(curRow);
                            break;
                        default:
                            break;
                    }
                }
            }
 
            if (event->held(A_BUTTON))
            {
                // space bar and enter key
                if (curRow >= rowCount())
                {
                    switch (index)
                    {
                        case 0:
                            just_type('\t');
                            break;
                        case 1:
                            just_type(' ');
                            break;
                        case 2:
                            just_type('\n');
                            break;
                        default:
                            break;
                    }
                    return true;
                }
 
                type(curRow, index);
            }
 
            // updateView();
            return true;
        }
 
        return false;
    }
 
    int extWidth = width + 305;
 
    if ((event->isTouchDown() || event->isTouchDrag()) && event->touchIn(this->x, this->y, extWidth, height + 200))
    {
        for (int y = 0; y < rowCount(); y++)
            for (int x = 0; x < rowLength(y) + 1; x++) {
                auto xStart = this->x + kXPad + x * kXOff + y * yYOff;
                auto yStart = this->y + kYPad + y * ySpacing;
                if (event->touchIn(xStart, yStart, keyWidth, keyWidth))
                {
                    ret |= true;
                    curRow = y;
                    index = x;
                }
            }
        return true;
    }
 
    if (event->isTouchUp())
    {
        // only proceed if we've been touchdown'd
        // reset current row and info
        curRow = -1;
        index = -1;
 
        if (event->touchIn(this->x, this->y, extWidth, height + 200))
        {
 
            for (int y = 0; y < rowCount(); y++)
                for (int x = 0; x < rowLength(y) + 1; x++)
                    if (event->touchIn(this->x + kXPad + x * kXOff + y * yYOff, this->y + kYPad + y * ySpacing, keyWidth, keyWidth))
                    {
                        ret |= true;
                        type(y, x);
                    }
 
            if (event->touchIn(this->x + dPos, this->y + enterHeight, enterWidth, textSize))
            {
                ret |= true;
                just_type('\t');
            }
 
            if (event->touchIn(this->x + sPos, this->y + dHeight, sWidth, textSize))
            {
                ret |= true;
                just_type(' ');
            }
 
            if (event->touchIn(this->x + enterPos, this->y + enterHeight, enterWidth, textSize))
            {
                ret |= true;
                just_type('\n');
            }
 
            // if (ret)
            //  updateView();
 
            return ret;
        }
 
        return false;
    }
 
    return false;
}

References InputEvents::held(), Element::hidden, InputEvents::touchIn(), and Element::width.

render()

void EKeyboard::render ( Element *  parent )

virtual

display the current state of the display

Reimplemented from Element.

Definition at line 26 of file EKeyboard.cpp.

{
    if (hidden || immersiveMode)
        return;
 
    CST_Rect dimens = { this->x, this->y, this->width + 305, this->height + 140 };
 
    auto renderer = getRenderer();
 
    CST_SetDrawColor(renderer, { 0xf9, 0xf9, 0xf9, 0xFF });
    if (hasRoundedKeys) {
        CST_SetDrawColor(renderer, { 0xdd, 0xdd, 0xdd, 0xFF });
 
        // rounded keys keyboard is full screen width
        dimens.x = 0;
        dimens.y -= 15;
        dimens.w = RootDisplay::screenWidth;
    }
 
    CST_FillRect(renderer, &dimens);
 
    for (int y = 0; y < rowCount(); y++)
        for (int x = 0; x < rowLength(y) + 1; x++)
        {
            CST_Rect dimens2 = { this->x + kXPad + x * kXOff + y * yYOff, this->y + kYPad + y * ySpacing, keyWidth, keyWidth };
            if (this->hasRoundedKeys) {
                CST_roundedBoxRGBA(renderer, dimens2.x, dimens2.y, dimens2.x + dimens2.w, dimens2.y + dimens2.h, 20, 0xee, 0xee, 0xee, 0xff);
            } else {
                CST_SetDrawColor(renderer, { 0xf4, 0xf4, 0xf4, 0xff });
                CST_FillRect(renderer, &dimens2);
            }
 
            // draw the letters with fontcache, for rounded keys
            if (hasRoundedKeys) {
                char curChar = rows[y]->at(x*2);
                auto curCharStr = std::string(1, curChar);
                int fHeight = CST_GetFontHeight(roundKeyFont, curCharStr.c_str());
                int fWidth = CST_GetFontWidth(roundKeyFont, curCharStr.c_str());
                CST_DrawFont(
                    roundKeyFont,
                    renderer,
                    dimens2.x + dimens2.w/2 - fWidth/2,
                    dimens2.y + dimens2.h/2 - fHeight/2,
                    curCharStr.c_str()
                );
            }
        }
 
    CST_Rect dimensSpace = { this->x + sPos, this->y + dHeight, sWidth, textSize };
    CST_Rect dimensEnter = { this->x + enterPos, this->y + enterHeight, enterWidth, (int)(1.5 * textSize) };
    CST_Rect dimensTab = { this->x + dPos, this->y + enterHeight, enterWidth, (int)(1.5 * textSize) };
 
    // if there's a highlighted piece set, color it in
    if (curRow >= 0 || index >= 0)
    {
        CST_Rect dimens2 = { this->x + kXPad + index * kXOff + curRow * yYOff, this->y + kYPad + curRow * ySpacing, keyWidth, keyWidth };
 
        if (curRow >= rowCount())
        {
            switch (index)
            {
                case 0:
                    dimens2 = dimensTab;
                    break;
                case 1:
                    // if we're on SPACE, expand the dimens width of the highlighted button
                    dimens2 = dimensSpace;
                    break;
                case 2:
                    // if we're on ENTER, expand the dimens width of the highlighted button
                    dimens2 = dimensEnter;
                    break;
                default:
                    break;
            }
        }
 
        // draw the currently selected tile if these index things are set
        if (touchMode && !isTouchDrag)
        {
            if (hasRoundedKeys) {
                CST_roundedBoxRGBA(renderer, dimens2.x, dimens2.y, dimens2.x + dimens2.w, dimens2.y + dimens2.h, 20, 0xad, 0xd8, 0xe6, 0x90);
                CST_roundedRectangleRGBA(renderer, dimens2.x, dimens2.y, dimens2.x + dimens2.w, dimens2.y + dimens2.h, 20, 0x66, 0x7c, 0x89, 0xff);
            } else {
                CST_SetDrawColor(renderer, { 0xad, 0xd8, 0xe6, 0x90 }); // TODO: matches the DEEP_HIGHLIGHT color
                CST_FillRect(renderer, &dimens2);
            }
        }
        else if (hasRoundedKeys) {
            CST_roundedBoxRGBA(renderer, dimens2.x, dimens2.y, dimens2.x + dimens2.w, dimens2.y + dimens2.h, 20, 0xad, 0xd8, 0xe6, 0x90);
            CST_roundedRectangleRGBA(renderer, dimens2.x, dimens2.y, dimens2.x + dimens2.w, dimens2.y + dimens2.h, 20, 0x66, 0x7c, 0x89, 0xff);
        }
        else {
            CST_SetDrawColor(renderer, { 0xff, 0xff, 0xff, 0xff }); // TODO: matches the DEEP_HIGHLIGHT color
            CST_FillRect(renderer, &dimens2);
 
            // border
            for (int z = 4; z >= 0; z--)
            {
                dimens2.x--;
                dimens2.y--;
                dimens2.w += 2;
                dimens2.h += 2;
 
                CST_SetDrawColor(renderer, { 0x66 - z * 10, 0x7c + z * 20, 0x89 + z * 10, 0xFF });
                CST_DrawRect(renderer, &dimens2);
            }
        }
    }
 
    if (hasRoundedKeys) {
        CST_roundedBoxRGBA(renderer, dimensSpace.x, dimensSpace.y, dimensSpace.x + dimensSpace.w, dimensSpace.y + dimensSpace.h, 20, 0xee, 0xee, 0xee, 0xff);
        CST_roundedBoxRGBA(renderer, dimensEnter.x, dimensEnter.y, dimensEnter.x + dimensEnter.w, dimensEnter.y + dimensEnter.h, 20, 0xee, 0xee, 0xee, 0xff);
        CST_roundedBoxRGBA(renderer, dimensTab.x, dimensTab.y, dimensTab.x + dimensTab.w, dimensTab.y + dimensTab.h, 20, 0xee, 0xee, 0xee, 0xff);
    } else {
        CST_SetDrawColor(renderer, { 0xf4, 0xf4, 0xf4, 0xff });
        CST_FillRect(renderer, &dimensSpace);
 
        if (!preventEnterAndTab) {
            CST_FillRect(renderer, &dimensEnter);
            CST_FillRect(renderer, &dimensTab);
        }
    }
 
    super::render(this);
}

References Element::hidden, Element::render(), and Element::width.

rowCount()

int EKeyboard::rowCount ( )

inline

Definition at line 48 of file EKeyboard.hpp.

                          {
        return (int)rows.size();
    }

rowLength()

int EKeyboard::rowLength ( int  row )

inline

Definition at line 52 of file EKeyboard.hpp.

                                  {
        return (int)rows[row]->size() / 2;
    }

type()

void EKeyboard::type	(	int	y,
		int	x
	)

Definition at line 540 of file EKeyboard.cpp.

{
    const char input = (*(rows[y]))[x * 2];
    just_type(input);
}

updateSize()

void EKeyboard::updateSize

(

)

Definition at line 443 of file EKeyboard.cpp.

{
    this->elements.clear();
    rows.clear();
 
    this->height = (304 / 900.0) * width;
 
    // set up lots of scaling variables based on the width/height
 
    this->keyWidth = (int)(0.08 * width);
    this->padding = keyWidth / 2.0;
 
    // these field variables are for displaying the QWERTY keys (touching and displaying)
    kXPad = (int)((23 / 400.0) * width);
    kXOff = (int)((36.5 / 400.0) * width) + (900.0 / width) * ( 900.0 != width); // when scaling, adjust our key x offset TODO: probably a guesstimate
    yYOff = (int)((22 / 400.0) * width);
    kYPad = (int)((17 / 135.0) * height);
    ySpacing = (int)((33 / 400.0) * width);
 
    if (hasRoundedKeys) {
        // different positioning for round keyboard
        // TODO: something else
        kXOff = (int)((38 / 400.0) * width) + (900.0 / width) * ( 900.0 != width); // when scaling, adjust our key x offset TODO: probably a guesstimate
        yYOff = (int)((10 / 400.0) * width);
        kYPad = (int)((0 / 135.0) * height);
        ySpacing = (int)((37 / 400.0) * width);
    }
 
    // these local variables position only the text, and has nothing to do with the
    // touch. They should likely be based on the above field variables so those
    // can change quickly
    int kXPad = (int)((30 / 400.0) * width);
    int kXOff = (int)((22 / 400.0) * width);
#ifdef __WIIU__
    // cheeky positioning hack because wiiu screen dimensions are different
    // to properly fix, the above comments would need to be addressed
    int kYPad = (int)((14 / 400.0) * width);
#endif
    int kYOff = (int)((33 / 400.0) * width);
 
    this->textSize = 0.9375 * keyWidth;
 
    // delete, space and enter key dimensions
    dPos = (int)((13 / 400.0) * width);
    dHeight = (int)((85 / 135.0) * height) + 145;
    sPos = (int)((150 / 400.0) * width);
    enterPos = dPos + 1000;
    enterHeight = dHeight - 34;
 
    dWidth = (int)(1.4125 * textSize);
    sWidth = (int)(7.5 * textSize);
    enterWidth = (int)(2.25 * textSize);
 
    // set up the keys vector based on the current EKeyboard selection
    generateEKeyboard();
 
    CST_Color gray = { 0x52, 0x52, 0x52, 0xff };
 
    int targetHeight = -1;
 
    // go through and draw each of the three rows at the right position
    if (!hasRoundedKeys) {
        for (int x = 0; x < rowCount(); x++)
        {
            TextElement* rowText = new TextElement(rows[x]->c_str(), textSize, &gray, ICON);
            // rowText->customFontPath = RAMFS "res/lightsans.ttf";
            if (targetHeight < 0) {
                targetHeight = rowText->height;
            }
            rowText->update(true);
            rowText->position(kXPad + x * kXOff, kYPad + x * kYOff + targetHeight/2 - rowText->height/2);
            this->elements.push_back(rowText);
        }
    }
 
    // text for space, enter, and symbols
    CST_Color grayish = { 0x55, 0x55, 0x55, 0xff };
    TextElement* spaceText = new TextElement("space", 30, &grayish);
    CST_Rect d4 = { this->x + sPos, this->y + dHeight, sWidth, textSize }; // todo: extract out hardcoded rects like this
    spaceText->position(d4.x + d4.w / 2 - spaceText->width / 2 - 15, 345);
    this->elements.push_back(spaceText);
 
    if (!preventEnterAndTab)
    {
        TextElement* enterText = new TextElement("enter", 30, &grayish);
        CST_Rect d3 = { this->x + enterPos, this->y + enterHeight, enterWidth, textSize }; // todo: extract out hardcoded rects like this
        enterText->position(d3.x + d3.w / 2 - enterText->width / 2 - 30, 327);
        this->elements.push_back(enterText);
 
        TextElement* symText = new TextElement(hasRoundedKeys ? "shift" : "tab", 30, &grayish);
        CST_Rect d5 = { this->x + dPos, this->y + enterHeight, enterWidth, textSize }; // todo: extract out hardcoded rects like this
        symText->position(d5.x + d5.w / 2 - symText->width / 2 - 30, 327);
        this->elements.push_back(symText);
    }
}

Member Data Documentation

breaks

int EKeyboard::breaks[4] = { 13, 13, 11, 10 }

Definition at line 34 of file EKeyboard.hpp.

capsOn

bool EKeyboard::capsOn = false

Definition at line 57 of file EKeyboard.hpp.

curRow

int EKeyboard::curRow = -1

Definition at line 61 of file EKeyboard.hpp.

dHeight

int EKeyboard::dHeight = 0

Definition at line 74 of file EKeyboard.hpp.

dPos

int EKeyboard::dPos = 0

Definition at line 73 of file EKeyboard.hpp.

dWidth

int EKeyboard::dWidth = 0

Definition at line 78 of file EKeyboard.hpp.

enterHeight

int EKeyboard::enterHeight = 0

Definition at line 77 of file EKeyboard.hpp.

enterPos

int EKeyboard::enterPos = 0

Definition at line 76 of file EKeyboard.hpp.

enterWidth

int EKeyboard::enterWidth = 0

Definition at line 80 of file EKeyboard.hpp.

hasRoundedKeys

bool EKeyboard::hasRoundedKeys = false

Definition at line 90 of file EKeyboard.hpp.

immersiveMode

bool EKeyboard::immersiveMode = false

Definition at line 94 of file EKeyboard.hpp.

index

int EKeyboard::index = -1

Definition at line 62 of file EKeyboard.hpp.

isTouchDrag

bool EKeyboard::isTouchDrag = false

Definition at line 100 of file EKeyboard.hpp.

keyWidth

int EKeyboard::keyWidth = 0

Definition at line 68 of file EKeyboard.hpp.

kXOff

int EKeyboard::kXOff = 0

Definition at line 84 of file EKeyboard.hpp.

kXPad

int EKeyboard::kXPad = 0

Definition at line 83 of file EKeyboard.hpp.

kYPad

int EKeyboard::kYPad = 0

Definition at line 86 of file EKeyboard.hpp.

lower_keys

const char* EKeyboard::lower_keys = "`1234567890-=qwertyuiop[]\\asdfghjkl;'zxcvbnm,./"

Definition at line 32 of file EKeyboard.hpp.

mode

int EKeyboard::mode = 0

Definition at line 58 of file EKeyboard.hpp.

padding

int EKeyboard::padding = 0

Definition at line 69 of file EKeyboard.hpp.

preventEnterAndTab

bool EKeyboard::preventEnterAndTab = false

Definition at line 97 of file EKeyboard.hpp.

roundKeyFont

CST_Font* EKeyboard::roundKeyFont = NULL

Definition at line 91 of file EKeyboard.hpp.

rows

std::vector<std::string*> EKeyboard::rows

Definition at line 39 of file EKeyboard.hpp.

shiftOn

bool EKeyboard::shiftOn = false

Definition at line 56 of file EKeyboard.hpp.

sPos

int EKeyboard::sPos = 0

Definition at line 75 of file EKeyboard.hpp.

storeOwnText

bool EKeyboard::storeOwnText = false

Definition at line 98 of file EKeyboard.hpp.

sWidth

int EKeyboard::sWidth = 0

Definition at line 79 of file EKeyboard.hpp.

textInput

std::string EKeyboard::textInput

Definition at line 24 of file EKeyboard.hpp.

textSize

int EKeyboard::textSize = 0

Definition at line 70 of file EKeyboard.hpp.

touchMode

bool EKeyboard::touchMode = false

Definition at line 93 of file EKeyboard.hpp.

typeAction

std::function<void(char)> EKeyboard::typeAction = NULL

Definition at line 28 of file EKeyboard.hpp.

upper_keys

const char* EKeyboard::upper_keys = "~!@#$\%^&*()_+QWERTYUIOP{}|ASDFGHJKL:\"ZXCVBNM<>?"

Definition at line 33 of file EKeyboard.hpp.

usbKeys

const CST_Keycode EKeyboard::usbKeys[KEYCODE_COUNT]

Initial value:

= {
        SDLK_BACKQUOTE, SDLK_1, SDLK_2, SDLK_3, SDLK_4, SDLK_5, SDLK_6, SDLK_7, SDLK_8, SDLK_9, SDLK_0, SDLK_MINUS, SDLK_EQUALS,
         SDLK_q, SDLK_w, SDLK_e, SDLK_r, SDLK_t, SDLK_y, SDLK_u, SDLK_i, SDLK_o, SDLK_p, SDLK_LEFTBRACKET, SDLK_RIGHTBRACKET, SDLK_BACKSLASH,
          SDLK_a, SDLK_s, SDLK_d, SDLK_f, SDLK_g, SDLK_h, SDLK_j, SDLK_k, SDLK_l, SDLK_SEMICOLON, SDLK_QUOTE,
           SDLK_z, SDLK_x, SDLK_c, SDLK_v, SDLK_b, SDLK_n, SDLK_m, SDLK_COMMA, SDLK_PERIOD, SDLK_SLASH
    }

Definition at line 41 of file EKeyboard.hpp.

ySpacing

int EKeyboard::ySpacing = 0

Definition at line 87 of file EKeyboard.hpp.

yYOff

int EKeyboard::yYOff = 0

Definition at line 85 of file EKeyboard.hpp.

---

The documentation for this class was generated from the following files:

• src/EKeyboard.hpp
• src/EKeyboard.cpp