WindowController Struct Reference

A WindowController manages a ViewController and its descendants within an SDL_Window. More...

#include <WindowController.h>

Inheritance diagram for WindowController:

Public Member Functions
Class *	_WindowController (void)
	The WindowController archetype.
void	debug (WindowController *self)
	Debugs the current frame.
WindowController *	initWithDevice (WindowController *self, RenderDevice *device)
	Initializes this WindowController with the given RenderDevice.
View *	keyResponder (const WindowController *self)
Array *	keyResponders (const WindowController *self)
View *	nextKeyResponder (const WindowController *self, View *keyResponder)
	Finds the next available keyResponder from the given keyResponder.
View *	previousKeyResponder (const WindowController *self, View *keyResponder)
	Finds the previous available keyResponder from the given keyResponder.
void	render (WindowController *self)
	Renders the ViewController's View into the RenderDevice's current frame.
void	renderTo (WindowController *self, CommandBuffer *commands, Framebuffer *framebuffer)
	Renders the ViewController's View into the given Framebuffer.
void	respondToEvent (WindowController *self, const SDL_Event *event)
	Responds to the given event.
void	setTheme (WindowController *self, Theme *theme)
	Sets this WindowController's Theme.
void	setViewController (WindowController *self, ViewController *viewController)
	Sets this WindowController's ViewController.
void	setWindow (WindowController *self, SDL_Window *window)
	Sets this WindowController's window.
void	toggleDebugger (WindowController *self)
	Toggles the debugger tools.
View *	touchResponder (const WindowController *self)
View *	touchResponder (const WindowController *self, const SDL_Event *event)
WindowController *	windowController (SDL_Window *window)

Data Fields
DebugViewController *	debugViewController
	The DebugViewController.
Object	object
	The superclass.
Renderer *	renderer
	The Renderer.
Theme *	theme
	The Theme.
ViewController *	viewController
	The ViewController.
SDL_Window *	window
	The window.

Protected Attributes
WindowControllerInterface *	interface [0]
	The interface type.

Detailed Description

A WindowController manages a ViewController and its descendants within an SDL_Window.

Definition at line 45 of file WindowController.h.

Member Function Documentation

_WindowController()

Class * _WindowController

(

void

)

The WindowController archetype.

Returns

The WindowController Class.

Definition at line 578 of file WindowController.c.

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

debug()

void debug

(

WindowController *

self

)

Debugs the current frame.

Parameters

self	The WindowController.

Definition at line 77 of file WindowController.c.

                                          {
 
  if (self->viewController && self->debugViewController) {
 
    ViewController *debugViewController = (ViewController *) self->debugViewController;
 
    float mx, my;
    SDL_GetMouseState(&mx, &my);
    SDL_Point point = MakePoint(mx, my);
 
    View *view = $(self->viewController->view, hitTest, &point);
    if (view) {
      $(self->debugViewController, debug, view, self->renderer);
    }
 
    $(debugViewController->view, applyThemeIfNeeded, self->theme);
    $(debugViewController->view, layoutIfNeeded);
 
    MVC_InvalidateRenderFrames();
 
    $(debugViewController->view, draw, self->renderer);
  }
}

initWithDevice()

WindowController * initWithDevice	(	WindowController *	self,
		RenderDevice *	device
	)

Initializes this WindowController with the given RenderDevice.

Parameters

self	The WindowController.
device	The RenderDevice.

Returns

The initialized WindowController, or NULL on error.

Definition at line 135 of file WindowController.c.

                                                                                      {
 
  assert(device);
 
  self = (WindowController *) super(Object, self, init);
  if (self) {
    self->renderer = $(alloc(Renderer), initWithDevice, device);
    assert(self->renderer);
 
    $(self, setWindow, device->window);
    $(self, setViewController, NULL);
    $(self, setTheme, NULL);
 
    $(self->renderer, renderDeviceDidReset);
    $(self->viewController, renderDeviceDidReset);
    $(self->theme, renderDeviceDidReset);
  }
 
  return self;
}

keyResponder()

View * keyResponder

(

const WindowController *

self

)

Parameters

self	The WindowController.

Returns

The key responder or NULL.

Definition at line 105 of file WindowController.c.

                                                        {
  return SDL_GetPointerProperty(SDL_GetWindowProperties(self->window), "keyResponder", NULL);
}

keyResponders()

Array * keyResponders

(

const WindowController *

self

)

Parameters

self	The WindowController.

Returns

An Array of all first responders in the WindowController's View hierarchy.

Definition at line 123 of file WindowController.c.

                                                          {
 
  Array *array = (Array *) $(alloc(Array), init);
  $(self->viewController->view, enumerateDescendants, enumerateKeyResponders, array);
 
  return array;
}

nextKeyResponder()

View * nextKeyResponder	(	const WindowController *	self,
		View *	keyResponder
	)

Finds the next available keyResponder from the given keyResponder.

Parameters

self	The WindowController.
keyResponder	The current keyResponder.

Returns

The next keyResponder, or NULL.

Definition at line 196 of file WindowController.c.

                                                                                {
 
  View *next = NULL;
 
  Array *array = $(self, keyResponders);
 
  if (array->count) {
    if (keyResponder && $(array, containsObject, keyResponder)) {
      const ssize_t index = $(array, indexOfObject, keyResponder);
      next = $(array, objectAtIndex, (index + 1) % array->count);
    } else {
      next = $(array, firstObject);
    }
  }
 
  release(array);
  return next;
}

previousKeyResponder()

View * previousKeyResponder	(	const WindowController *	self,
		View *	keyResponder
	)

Finds the previous available keyResponder from the given keyResponder.

Parameters

self	The WindowController.
keyResponder	The current keyResponder.

Returns

The previous keyResponder, or NULL.

Definition at line 219 of file WindowController.c.

                                                                                    {
 
  View *prev = NULL;
 
  Array *array = $(self, keyResponders);
 
  if (array->count) {
    if (keyResponder && $(array, containsObject, keyResponder)) {
      const ssize_t index = $(array, indexOfObject, keyResponder);
      prev = $(array, objectAtIndex, (index + array->count - 1) % array->count);
    } else {
      prev = $(array, firstObject);
    }
  }
 
  release(array);
  return prev;
}

render()

void render

(

WindowController *

self

)

Renders the ViewController's View into the RenderDevice's current frame.

Convenience over renderTo for the common case of rendering the UI into the device's own current command buffer and framebuffer. Equivalent to $(self, renderTo, device->commands, device->framebuffer).

Parameters

self	The WindowController.

Definition at line 160 of file WindowController.c.

                                           {
 
  assert(self->renderer);
 
  const RenderDevice *device = self->renderer->device;
  $(self, renderTo, device->commands, device->framebuffer);
}

renderTo()

void renderTo	(	WindowController *	self,
		CommandBuffer *	commands,
		Framebuffer *	framebuffer
	)

Renders the ViewController's View into the given Framebuffer.

The caller owns commands and is responsible for submitting it after this returns. The UI is composited over whatever is already in the Framebuffer's color texture (SDL_GPU_LOADOP_LOAD), so render your scene into the Framebuffer first.

Parameters

self	The WindowController.
commands	The frame's CommandBuffer.
framebuffer	The Framebuffer to render the UI into.

Definition at line 172 of file WindowController.c.

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

respondToEvent()

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

Responds to the given event.

Remarks

Exposure MUST NOT reset render device resources. It fires on every frame on some platforms, where resetting leaks a generation of GPU resources per frame. Only the view hierarchy's resources depend on the window, through its pixel density, so only a change in pixel density resets them. The renderer's own resources are created with the device.

Window events for another window MUST be ignored, or a window being torn down releases the resources of the controller that replaced it.

Parameters

self	The WindowController.
event	The event.

Remarks

Your application should call this method for each event that the View hierarchy is expected to respond to. The event will be dispatched to WindowController::keyResponder, which is the first of:

• The View that has claimed key responder status for the window via View::becomeKeyResponder
• The inner-most descendant in the View hierarchy that received the event, according to View::hitTest
• This WindowController's ViewController

By default, the event is passed up the View hierarchy by View::respondToEvent. Subclasses of View, such as Control, may stop event propagation if an event has been captured.

Definition at line 248 of file WindowController.c.

                                                                           {
 
  if (event->type >= SDL_EVENT_WINDOW_FIRST && event->type <= SDL_EVENT_WINDOW_LAST) {
    if (event->window.windowID != SDL_GetWindowID(self->window)) {
      return;
    }
  }
 
  SDL_SetPointerProperty(SDL_GetWindowProperties(self->window), "event", (ident) event);
 
  switch (event->type) {
    case SDL_EVENT_WINDOW_MOVED:
    case SDL_EVENT_WINDOW_RESIZED:
    case SDL_EVENT_WINDOW_MAXIMIZED:
    case SDL_EVENT_WINDOW_RESTORED:
    case SDL_EVENT_WINDOW_SAFE_AREA_CHANGED:
      $(self, setWindow, self->window);
      break;
    case SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED:
    case SDL_EVENT_WINDOW_DISPLAY_CHANGED:
    case SDL_EVENT_WINDOW_DISPLAY_SCALE_CHANGED: {
      $(self, setWindow, self->window);
 
      $(self->viewController, renderDeviceWillReset);
      $(self->viewController, renderDeviceDidReset);
      $(self->viewController->view, updateBindings, NULL);
      $(self->theme, renderDeviceWillReset);
      $(self->theme, renderDeviceDidReset);
 
      if (self->debugViewController) {
        ViewController *debugViewController = (ViewController *) self->debugViewController;
        $(debugViewController, renderDeviceWillReset);
        $(debugViewController, renderDeviceDidReset);
        $(debugViewController->view, updateBindings, NULL);
      }
    }
      break;
    case SDL_EVENT_WINDOW_DESTROYED:
    case SDL_EVENT_WINDOW_CLOSE_REQUESTED:
      $(self->renderer, renderDeviceWillReset);
      $(self->viewController, renderDeviceWillReset);
      $(self->theme, renderDeviceWillReset);
      break;
    default:
      break;
  }
 
  if (event->type == SDL_EVENT_MOUSE_MOTION) {
    $(self->viewController->view, enumerateVisible, mouseMotion_enumerate, (ident) event);
  }
 
  View *keyResponder = $(self, keyResponder), *touchResponder = $(self, touchResponder);
  
  View *touchTarget = $(self, touchTarget, event);
  
  switch (event->type) {
    case SDL_EVENT_KEY_UP:
    case SDL_EVENT_KEY_DOWN:
    case SDL_EVENT_TEXT_INPUT:
      if (keyResponder) {
        $(keyResponder, respondToEvent, event);
      } else {
        $(self->viewController, respondToEvent, event);
      }
      break;
    case SDL_EVENT_MOUSE_BUTTON_DOWN:
      if (touchTarget) {
        $(touchTarget, becomeTouchResponder);
        $(touchTarget, respondToEvent, event);
      } else if (touchResponder) {
        $(touchResponder, respondToEvent, event);
        $(touchResponder, resignTouchResponder);
      } else {
        $(self->viewController, respondToEvent, event);
      }
      
      touchResponder = $(self, touchResponder);
      if (touchResponder && keyResponder && touchResponder != keyResponder) {
        $(keyResponder, resignKeyResponder);
      }
      break;
    case SDL_EVENT_MOUSE_BUTTON_UP:
      if (touchResponder) {
        $(touchResponder, respondToEvent, event);
      } else if (touchTarget) {
        $(touchTarget, respondToEvent, event);
      } else {
        $(self->viewController, respondToEvent, event);
      }
      break;
    case SDL_EVENT_MOUSE_MOTION:
    case SDL_EVENT_MOUSE_WHEEL:
      if (touchResponder) {
        $(touchResponder, respondToEvent, event);
      } else if (touchTarget) {
        $(touchTarget, respondToEvent, event);
      } else {
        $(self->viewController, respondToEvent, event);
      }
      break;
    default:
      $(self->viewController, respondToEvent, event);
      break;
  }
 
  if (event->type == SDL_EVENT_KEY_DOWN) {
    if (event->key.key == SDLK_TAB || event->key.key == SDLK_KP_TAB) {
 
      View *current = $(self, keyResponder);
 
      // An editing TextView that is still the key responder kept Tab to auto-complete
      const bool consumed = current && current == keyResponder &&
        $((Object *) current, isKindOfClass, _TextView()) &&
        ((TextView *) current)->isEditable &&
        !$((Control *) current, isDisabled);
 
      if (!consumed) {
        if (event->key.mod & SDL_KMOD_SHIFT) {
          keyResponder = $(self, previousKeyResponder, keyResponder);
        } else {
          keyResponder = $(self, nextKeyResponder, keyResponder);
        }
 
        if (keyResponder) {
          $(keyResponder, becomeKeyResponder);
        }
      }
    }
 
    if (event->key.key == SDLK_D) {
      if (event->key.mod & SDL_KMOD_CTRL) {
        $(self, toggleDebugger);
      }
    }
  }
 
  SDL_SetPointerProperty(SDL_GetWindowProperties(self->window), "event", NULL);
}

setTheme()

void setTheme	(	WindowController *	self,
		Theme *	theme
	)

Sets this WindowController's Theme.

Parameters

self	The WindowController.
theme	The Theme.

Definition at line 391 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()

void setViewController	(	WindowController *	self,
		ViewController *	viewController
	)

Sets this WindowController's ViewController.

Parameters

self	The WindowController.
viewController	The ViewController.

Definition at line 411 of file WindowController.c.

                                                                                      {
 
  if (self->viewController != viewController || self->viewController == NULL) {
 
    SDL_SetPointerProperty(SDL_GetWindowProperties(self->window), "keyResponder", 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()

void setWindow	(	WindowController *	self,
		SDL_Window *	window
	)

Sets this WindowController's window.

Parameters

self	The WindowController.
window	The window.

Definition at line 443 of file WindowController.c.

                                                                  {
 
  assert(window);
 
  self->window = window;
 
  SDL_PropertiesID properties = SDL_GetWindowProperties(self->window);
  
  SDL_SetPointerProperty(properties, "windowController", self);
  SDL_SetPointerProperty(properties, "keyResponder", NULL);
  SDL_SetPointerProperty(properties, "touchResponder", NULL);
 
  if (self->renderer) {
    $(self->renderer->device, setWindow, self->window);
  }
 
  if (self->viewController) {
    $(self->viewController->view, moveToWindow, self->window);
  }
 
  if (self->debugViewController) {
    $(self->debugViewController->viewController.view, moveToWindow, self->window);
  }
}

toggleDebugger()

void toggleDebugger

(

WindowController *

self

)

Toggles the debugger tools.

Parameters

self	The WindowViewController.

Definition at line 472 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");
    }
  }
}

touchResponder() [1/2]

View * touchResponder

(

const WindowController *

self

)

Parameters

self	The WindowController.

Returns

The touch responder or NULL.

See also

View::hitTest(const View *, const SDL_Point *)

Definition at line 502 of file WindowController.c.

                                                          {
  return SDL_GetPointerProperty(SDL_GetWindowProperties(self->window), "touchResponder", NULL);
}

touchResponder() [2/2]

View * touchResponder	(	const WindowController *	self,
		const SDL_Event *	event
	)

windowController()

WindowController * windowController

(

SDL_Window *

window

)

Parameters

window

The window.

Returns

The WindowController bound to the given window.

Definition at line 540 of file WindowController.c.

                                                              {
 
  assert(window);
 
  return SDL_GetPointerProperty(SDL_GetWindowProperties(window), "windowController", NULL);
}

Field Documentation

debugViewController

DebugViewController* WindowController::debugViewController

The DebugViewController.

Definition at line 61 of file WindowController.h.

interface

WindowControllerInterface* WindowController::interface[0]

protected

The interface type.

Definition at line 56 of file WindowController.h.

object

Object WindowController::object

The superclass.

Definition at line 50 of file WindowController.h.

renderer

Renderer* WindowController::renderer

The Renderer.

Definition at line 66 of file WindowController.h.

theme

Theme* WindowController::theme

The Theme.

Definition at line 71 of file WindowController.h.

viewController

ViewController* WindowController::viewController

The ViewController.

Definition at line 76 of file WindowController.h.

window

SDL_Window* WindowController::window

The window.

Definition at line 81 of file WindowController.h.

---

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

• Sources/ObjectivelyMVC/WindowController.h
• Sources/ObjectivelyMVC/WindowController.c