WindowController.c File Reference

#include <assert.h>
#include <Objectively/String.h>
#include "Log.h"
#include "WindowController.h"

Go to the source code of this file.

Macros
#define	_Class   _WindowController

Functions
Class *	_WindowController (void)
static void	dealloc (Object *self)
static void	debug (WindowController *self)
static View *	eventTarget (const WindowController *self, const SDL_Event *event)
static View *	firstResponder (const WindowController *self, const SDL_Event *event)
static void	initialize (Class *clazz)
static WindowController *	initWithWindow (WindowController *self, SDL_Window *window)
static void	render (WindowController *self)
static void	respondToEvent (WindowController *self, const SDL_Event *event)
static void	setRenderer (WindowController *self, Renderer *renderer)
static void	setSoundStage (WindowController *self, SoundStage *soundStage)
static void	setTheme (WindowController *self, Theme *theme)
static void	setViewController (WindowController *self, ViewController *viewController)
static void	setWindow (WindowController *self, SDL_Window *window)
static void	toggleDebugger (WindowController *self)
static WindowController *	windowController (SDL_Window *window)

Macro Definition Documentation

_Class

#define _Class   _WindowController

Definition at line 31 of file WindowController.c.

Function Documentation

_WindowController()

Class * _WindowController

(

void

)

Definition at line 380 of file WindowController.c.

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

dealloc()

static void dealloc ( Object *  self )

static

See also

Object::dealloc(Object *)

Definition at line 38 of file WindowController.c.

                                  {
 
    WindowController *this = (WindowController *) self;
 
    release(this->debugViewController);
    release(this->renderer);
    release(this->viewController);
 
    super(Object, self, dealloc);
}

debug()

static void debug ( WindowController *  self )

static

Definition at line 55 of file WindowController.c.

                                          {
 
    if (self->viewController && self->debugViewController) {
 
        ViewController *debugViewController = (ViewController *) self->debugViewController;
 
        SDL_Point point = MakePoint(0, 0);
        SDL_GetMouseState(&point.x, &point.y);
 
        View *view = $(self->viewController->view, hitTest, &point);
        if (view) {
            $(self->debugViewController, debug, view, self->renderer);
        }
 
        $(debugViewController->view, applyThemeIfNeeded, self->theme);
        $(debugViewController->view, layoutIfNeeded);
        $(debugViewController->view, draw, self->renderer);
    }
}

eventTarget()

static View * eventTarget ( const WindowController *  self, const SDL_Event *  event  )

static

Definition at line 79 of file WindowController.c.

                                                                               {
 
    SDL_Point point;
 
    if (event->type == SDL_MOUSEBUTTONDOWN || event->type == SDL_MOUSEBUTTONUP) {
        point = MakePoint(event->button.x, event->button.y);
    } else if (event->type == SDL_MOUSEMOTION) {
        point = MakePoint(event->motion.x, event->motion.y);
    } else if (event->type == SDL_MOUSEWHEEL) {
        SDL_GetMouseState(&point.x, &point.y);
    } else {
        return NULL;
    }
 
    return $(self->viewController->view, hitTest, &point);
}

firstResponder()

static View * firstResponder ( const WindowController *  self, const SDL_Event *  event  )

static

Definition at line 100 of file WindowController.c.

                                                                                  {
    return $$(View, firstResponder, self->window) ?: $(self, eventTarget, event);
}

initialize()

static void initialize ( Class *  clazz )

static

See also

Class::initialize(Class *)

Definition at line 357 of file WindowController.c.

                                     {
 
    ((ObjectInterface *) clazz->interface)->dealloc = dealloc;
 
    ((WindowControllerInterface *) clazz->interface)->debug = debug;
    ((WindowControllerInterface *) clazz->interface)->eventTarget = eventTarget;
    ((WindowControllerInterface *) clazz->interface)->firstResponder = firstResponder;
    ((WindowControllerInterface *) clazz->interface)->initWithWindow = initWithWindow;
    ((WindowControllerInterface *) clazz->interface)->render = render;
    ((WindowControllerInterface *) clazz->interface)->respondToEvent = respondToEvent;
    ((WindowControllerInterface *) clazz->interface)->setRenderer = setRenderer;
    ((WindowControllerInterface *) clazz->interface)->setSoundStage = setSoundStage;
    ((WindowControllerInterface *) clazz->interface)->setTheme = setTheme;
    ((WindowControllerInterface *) clazz->interface)->setViewController = setViewController;
    ((WindowControllerInterface *) clazz->interface)->setWindow = setWindow;
    ((WindowControllerInterface *) clazz->interface)->toggleDebugger = toggleDebugger;
    ((WindowControllerInterface *) clazz->interface)->windowController = windowController;
}

initWithWindow()

static WindowController * initWithWindow ( WindowController *  self, SDL_Window *  window  )

static

Definition at line 108 of file WindowController.c.

                                                                                    {
 
    self = (WindowController *) super(Object, self, init);
    if (self) {
        $(self, setWindow, window);
        $(self, setViewController, NULL);
        $(self, setSoundStage, NULL);
        $(self, setRenderer, NULL);
        $(self, setTheme, NULL);
    }
 
    return self;
}

render()

static void render ( WindowController *  self )

static

Definition at line 126 of file WindowController.c.

                                           {
 
    assert(self->renderer);
 
    $(self->renderer, beginFrame);
 
    $(self->viewController->view, applyThemeIfNeeded, self->theme);
    $(self->viewController->view, layoutIfNeeded);
 
    $(self->viewController->view, draw, self->renderer);
 
    $(self, debug);
 
    $(self->renderer, endFrame);
}

respondToEvent()

static void respondToEvent ( WindowController *  self, const SDL_Event *  event  )

static

Definition at line 146 of file WindowController.c.

                                                                           {
 
    if (event->type == SDL_USEREVENT && event->user.type == MVC_NOTIFICATION_EVENT) {
        $(self->viewController, handleNotification, &(const Notification) {
            .name = event->user.code,
            .sender = event->user.data1,
            .data = event->user.data2
        });
    } else {
 
        if (event->type == SDL_WINDOWEVENT) {
            switch (event->window.event) {
                case SDL_WINDOWEVENT_EXPOSED:
                    $(self, setWindow, SDL_GL_GetCurrentWindow());
                    $(self->renderer, renderDeviceDidReset);
                    $(self->viewController->view, renderDeviceDidReset);
                    $(self->viewController->view, updateBindings);
                    break;
                case SDL_WINDOWEVENT_CLOSE:
                    $(self->renderer, renderDeviceWillReset);
                    $(self->viewController->view, renderDeviceWillReset);
                    break;
                default:
                    break;
            }
        }
 
        View *firstResponder = $(self, firstResponder, event);
        if (firstResponder) {
 
            switch (event->type) {
                case SDL_MOUSEMOTION:
                    break;
                default: {
                    String *desc = $((Object *) firstResponder, description);
                    MVC_LogMessage(SDL_LOG_PRIORITY_DEBUG, "%d -> %s\n", event->type, desc->chars);
                    release(desc);
                }
            }
 
            $(firstResponder, respondToEvent, event);
        }
 
        if (event->type == SDL_KEYUP) {
            if (event->key.keysym.sym == SDLK_d) {
                if (event->key.keysym.mod & KMOD_CTRL) {
                    $(self, toggleDebugger);
                }
            }
        }
    }
}

setRenderer()

static void setRenderer ( WindowController *  self, Renderer *  renderer  )

static

Definition at line 203 of file WindowController.c.

                                                                    {
 
    if (self->renderer != renderer || self->renderer == NULL) {
 
        release(self->renderer);
 
        if (renderer) {
            self->renderer = retain(renderer);
        } else {
            self->renderer = $(alloc(Renderer), init);
        }
 
        $(self->viewController->view, renderDeviceDidReset);
    }
}

setSoundStage()

static void setSoundStage ( WindowController *  self, SoundStage *  soundStage  )

static

Definition at line 223 of file WindowController.c.

                                                                          {
 
    if (self->soundStage != soundStage || self->soundStage == NULL) {
 
        release(self->soundStage);
 
        if (soundStage) {
            self->soundStage = retain(soundStage);
        } else {
            self->soundStage = $(alloc(SoundStage), init);
        }
    }
}

setTheme()

static void setTheme ( WindowController *  self, Theme *  theme  )

static

Definition at line 241 of file WindowController.c.

                                                           {
 
    if (self->theme != theme || self->theme == NULL) {
 
        release(self->theme);
 
        if (theme) {
            self->theme = retain(theme);
        } else {
            self->theme = $(alloc(Theme), init);
        }
    }
 
    $(self->viewController->view, invalidateStyle);
}

setViewController()

static void setViewController ( WindowController *  self, ViewController *  viewController  )

static

Definition at line 261 of file WindowController.c.

                                                                                      {
 
    if (self->viewController != viewController || self->viewController == NULL) {
 
        if (self->viewController) {
            $(self->viewController, viewWillDisappear);
            $(self->viewController->view, moveToWindow, NULL);
            $(self->viewController, viewDidDisappear);
        }
 
        release(self->viewController);
 
        if (viewController) {
            self->viewController = retain(viewController);
        } else {
            self->viewController = $(alloc(ViewController), init);
        }
 
        $(self->viewController, loadViewIfNeeded);
 
        $(self->viewController, viewWillAppear);
        $(self->viewController->view, moveToWindow, self->window);
        $(self->viewController, viewDidAppear);
    }
}

setWindow()

static void setWindow ( WindowController *  self, SDL_Window *  window  )

static

Definition at line 291 of file WindowController.c.

                                                                  {
 
    self->window = window;
    assert(self->window);
 
    const Uint32 flags = SDL_GetWindowFlags(self->window);
    assert(flags & SDL_WINDOW_OPENGL);
 
    SDL_SetWindowData(self->window, "windowController", self);
    assert(SDL_GetWindowData(self->window, "windowController") == self);
 
    if (self->viewController) {
        $(self->viewController->view, moveToWindow, self->window);
    }
 
    if (self->debugViewController) {
        $(self->debugViewController->viewController.view, moveToWindow, self->window);
    }
}

toggleDebugger()

static void toggleDebugger ( WindowController *  self )

static

Definition at line 315 of file WindowController.c.

                                                   {
 
    if (self->debugViewController == NULL) {
 
        self->debugViewController = $(alloc(DebugViewController), init);
        assert(self->debugViewController);
 
        ViewController *debugViewController = (ViewController *) self->debugViewController;
 
        $(debugViewController, loadView);
        $(debugViewController, viewWillAppear);
        $(debugViewController->view, moveToWindow, self->window);
        $(debugViewController, viewDidAppear);
 
        if (self->viewController) {
            $(self->viewController->view, addClassName, "debug");
        }
    } else {
        self->debugViewController = release(self->debugViewController);
 
        if (self->viewController) {
            $(self->viewController->view, removeClassName, "debug");
        }
    }
}

windowController()

static WindowController * windowController ( SDL_Window *  window )

static

Definition at line 345 of file WindowController.c.

                                                              {
 
    assert(window);
 
    return SDL_GetWindowData(window, "windowController");
}