TextView.c File Reference

#include <assert.h>
#include <string.h>
#include <Objectively/String.h>
#include "TextView.h"

Go to the source code of this file.

Macros
#define	_Class   _TextView

Functions
Class *	_TextView (void)
static void	applyStyle (View *self, const Style *style)
static void	awakeWithDictionary (View *self, const Dictionary *dictionary)
static _Bool	captureEvent (Control *self, const SDL_Event *event)
static void	dealloc (Object *self)
static View *	init (View *self)
static void	initialize (Class *clazz)
static TextView *	initWithFrame (TextView *self, const SDL_Rect *frame)
static void	layoutSubviews (View *self)
static void	render (View *self, Renderer *renderer)
static void	setDefaultText (TextView *self, const char *defaultText)

Macro Definition Documentation

_Class

#define _Class   _TextView

Definition at line 31 of file TextView.c.

Function Documentation

_TextView()

Class * _TextView

(

void

)

Definition at line 386 of file TextView.c.

                       {
    static Class *clazz;
    static Once once;
 
    do_once(&once, {
        clazz = _initialize(&(const ClassDef) {
            .name = "TextView",
            .superclass = _Control(),
            .instanceSize = sizeof(TextView),
            .interfaceOffset = offsetof(TextView, interface),
            .interfaceSize = sizeof(TextViewInterface),
            .initialize = initialize,
        });
    });
 
    return clazz;
}

applyStyle()

static void applyStyle ( View *  self, const Style *  style  )

static

Definition at line 57 of file TextView.c.

                                                       {
 
    super(View, self, applyStyle, style);
 
    TextView *this = (TextView *) self;
 
    const Inlet inlets[] = MakeInlets(
        MakeInlet("editable", InletTypeBool, &this->isEditable, NULL)
    );
 
    $(self, bind, inlets, style->attributes);
}

awakeWithDictionary()

static void awakeWithDictionary ( View *  self, const Dictionary *  dictionary  )

static

See also

View::awakeWithDictionary(View *, const Dictionary *)

Definition at line 73 of file TextView.c.

                                                                          {
 
    super(View, self, awakeWithDictionary, dictionary);
 
    TextView *this = (TextView *) self;
 
    const Inlet inlets[] = MakeInlets(
        MakeInlet("defaultText", InletTypeCharacters, &this->defaultText, NULL)
    );
 
    $(self, bind, inlets, dictionary);
}

captureEvent()

static _Bool captureEvent ( Control *  self, const SDL_Event *  event  )

static

See also

Control::captureEvent(Control *, const SDL_Event *)

Definition at line 162 of file TextView.c.

                                                                 {
 
    _Bool didEdit = false, didCaptureEvent = false;
 
    TextView *this = (TextView *) self;
    if (this->isEditable) {
        if (event->type == SDL_MOUSEBUTTONDOWN) {
            if ($((View *) self, didReceiveEvent, event)) {
                if ((self->state & ControlStateFocused) == 0) {
                    self->state |= ControlStateFocused;
                    SDL_StartTextInput();
                    if (this->delegate.didBeginEditing) {
                        this->delegate.didBeginEditing(this);
                    }
                }
                didCaptureEvent = true;
            } else {
                if (self->state & ControlStateFocused) {
                    self->state &= ~ControlStateFocused;
                    SDL_StopTextInput();
                    if (this->delegate.didEndEditing) {
                        this->delegate.didEndEditing(this);
                    }
                    didCaptureEvent = true;
                }
            }
        } else if (event->type == SDL_TEXTINPUT) {
            if (self->state & ControlStateFocused) {
                if (this->position == this->attributedText->string.length) {
                    $(this->attributedText, appendCharacters, event->text.text);
                } else {
                    $(this->attributedText, insertCharactersAtIndex, event->text.text, this->position);
                }
                this->position += strlen(event->text.text);
                didEdit = didCaptureEvent = true;
            }
        } else if (event->type == SDL_KEYDOWN) {
            if (self->state & ControlStateFocused) {
                didCaptureEvent = true;
 
                const char *chars = this->attributedText->string.chars;
                const size_t len = this->attributedText->string.length;
 
                switch (event->key.keysym.sym) {
 
                    case SDLK_ESCAPE:
                    case SDLK_KP_ENTER:
                    case SDLK_KP_TAB:
                    case SDLK_RETURN:
                    case SDLK_TAB:
                        self->state &= ~ControlStateFocused;
                        SDL_StopTextInput();
                        if (this->delegate.didEndEditing) {
                            this->delegate.didEndEditing(this);
                        }
                        break;
 
                    case SDLK_BACKSPACE:
                    case SDLK_KP_BACKSPACE:
                        if (this->position > 0) {
                            const Range range = { .location = this->position - 1, .length = 1 };
                            $(this->attributedText, deleteCharactersInRange, range);
                            this->position--;
                            didEdit = true;
                        }
                        break;
 
                    case SDLK_DELETE:
                        if (this->position < len) {
                            const Range range = { .location = this->position, .length = 1 };
                            $(this->attributedText, deleteCharactersInRange, range);
                            didEdit = true;
                        }
                        break;
 
                    case SDLK_LEFT:
                        if (SDL_GetModState() & KMOD_CTRL) {
                            while (this->position > 0 && chars[this->position] == ' ') {
                                this->position--;
                            }
                            while (this->position > 0 && chars[this->position] != ' ') {
                                this->position--;
                            }
                        } else if (this->position > 0) {
                            this->position--;
                        }
                        break;
 
                    case SDLK_RIGHT:
                        if (SDL_GetModState() & KMOD_CTRL) {
                            while (this->position < len && chars[this->position] == ' ') {
                                this->position++;
                            }
                            while (this->position < len && chars[this->position] != ' ') {
                                this->position++;
                            }
                            if (this->position < len) {
                                this->position++;
                            }
                        } else if (this->position < len) {
                            this->position++;
                        }
                        break;
 
                    case SDLK_HOME:
                        this->position = 0;
                        break;
 
                    case SDLK_END:
                        this->position = len;
                        break;
 
                    case SDLK_a:
                        if (SDL_GetModState() & KMOD_CTRL) {
                            this->position = 0;
                        }
                        break;
                    case SDLK_e:
                        if (SDL_GetModState() & KMOD_CTRL) {
                            this->position = len;
                        }
                        break;
 
                    case SDLK_v:
                        if ((SDL_GetModState() & (KMOD_CTRL | KMOD_GUI)) && SDL_HasClipboardText()) {
                            const char *text = SDL_GetClipboardText();
                            if (this->position == len) {
                                $(this->attributedText, appendCharacters, text);
                            } else {
                                $(this->attributedText, insertCharactersAtIndex, text, this->position);
                            }
                            this->position += strlen(text);
                            didEdit = true;
                        }
                        break;
 
                    default:
                        break;
                }
            }
        }
 
        if (didEdit) {
            self->view.needsLayout = true;
            if (this->delegate.didEdit) {
                this->delegate.didEdit(this);
            }
        }
    }
 
    return didCaptureEvent;
}

dealloc()

static void dealloc ( Object *  self )

static

See also

Object::dealloc(Object *)

Definition at line 38 of file TextView.c.

                                  {
 
    TextView *this = (TextView *) self;
 
    free(this->defaultText);
 
    release(this->text);
 
    release(this->attributedText);
 
    super(Object, self, dealloc);
}

init()

static View * init ( View *  self )

static

See also

View::init(View *)

Definition at line 89 of file TextView.c.

                              {
    return (View *) $((TextView *) self, initWithFrame, NULL);
}

initialize()

static void initialize ( Class *  clazz )

static

See also

Class::initialize(Class *)

Definition at line 366 of file TextView.c.

                                     {
 
    ((ObjectInterface *) clazz->interface)->dealloc = dealloc;
 
    ((ViewInterface *) clazz->interface)->applyStyle = applyStyle;
    ((ViewInterface *) clazz->interface)->awakeWithDictionary = awakeWithDictionary;
    ((ViewInterface *) clazz->interface)->init = init;
    ((ViewInterface *) clazz->interface)->layoutSubviews = layoutSubviews;
    ((ViewInterface *) clazz->interface)->render = render;
 
    ((ControlInterface *) clazz->interface)->captureEvent = captureEvent;
 
    ((TextViewInterface *) clazz->interface)->initWithFrame = initWithFrame;
    ((TextViewInterface *) clazz->interface)->setDefaultText = setDefaultText;
}

initWithFrame()

static TextView * initWithFrame ( TextView *  self, const SDL_Rect *  frame  )

static

Definition at line 321 of file TextView.c.

                                                                      {
 
    self = (TextView *) super(Control, self, initWithFrame, frame);
    if (self) {
        self->attributedText = $$(MutableString, string);
        assert(self->attributedText);
 
        self->isEditable = true;
 
        self->text = $(alloc(Text), initWithText, NULL, NULL);
        assert(self->text);
 
        $((View *) self, addSubview, (View *) self->text);
 
        self->control.view.clipsSubviews = true;
    }
 
    return self;
}

layoutSubviews()

static void layoutSubviews ( View *  self )

static

See also

View::layoutSubviews(View *)

Definition at line 96 of file TextView.c.

                                       {
 
    TextView *this = (TextView *) self;
 
    const char *text = this->attributedText->string.chars;
 
    if (text == NULL || strlen(text) == 0) {
        if ($((Control *) this, isFocused) == false) {
            text = this->defaultText;
        }
    }
 
    if (text == NULL) {
        $(this->text, setText, NULL);
    } else {
        if (this->text->text) {
            if (strcmp(text, this->text->text)) {
                $(this->text, setText, text);
            }
        } else {
            $(this->text, setText, text);
        }
    }
 
    super(View, self, layoutSubviews);
}

render()

static void render ( View *  self, Renderer *  renderer  )

static

See also

View::render(View *, Renderer *)

Definition at line 126 of file TextView.c.

                                                   {
 
    super(View, self, render, renderer);
 
    TextView *this = (TextView *) self;
 
    if ($((Control *) this, isFocused)) {
        const char *text = this->text->text ?: "";
 
        int w, h;
        if (this->position == strlen(text)) {
            $(this->text->font, sizeCharacters, text, &w, &h);
        } else {
            char *chars = calloc(this->position + 1, sizeof(char));
            strncpy(chars, text, this->position);
 
            $(this->text->font, sizeCharacters, chars, &w, &h);
            free(chars);
        }
 
        SDL_Rect frame = $((View *) this->text, renderFrame);
 
        const SDL_Point points[] = {
            { frame.x + w, frame.y },
            { frame.x + w, frame.y + h }
        };
 
        $(renderer, drawLine, points);
    }
}

setDefaultText()

static void setDefaultText ( TextView *  self, const char *  defaultText  )

static

Definition at line 345 of file TextView.c.

                                                                    {
 
    if (strcmp(self->defaultText ?: "", defaultText ?: "")) {
 
        free(self->defaultText);
 
        if (defaultText) {
            self->defaultText = strdup(defaultText);
        } else {
            self->defaultText = NULL;
        }
 
        self->control.view.needsLayout = true;
    }
}