View.h

Go to the documentation of this file.

/*
 * ObjectivelyMVC: Object oriented MVC framework for OpenGL, SDL2 and GNU C.
 * Copyright (C) 2014 Jay Dolan <jay@jaydolan.com>
 *
 * This software is provided 'as-is', without any express or implied
 * warranty. In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 * claim that you wrote the original software. If you use this software
 * in a product, an acknowledgment in the product documentation would be
 * appreciated but is not required.
 *
 * 2. Altered source versions must be plainly marked as such, and must not be
 * misrepresented as being the original software.
 *
 * 3. This notice may not be removed or altered from any source distribution.
 */
 
#pragma once
 
#include <Objectively/Data.h>
#include <Objectively/Enum.h>
#include <Objectively/MutableDictionary.h>
#include <Objectively/MutableArray.h>
#include <Objectively/MutableSet.h>
#include <Objectively/Resource.h>
 
#include <ObjectivelyMVC/Colors.h>
#include <ObjectivelyMVC/Renderer.h>
#include <ObjectivelyMVC/Theme.h>
#include <ObjectivelyMVC/View+JSON.h>
 
#define ViewAlignmentMaskTop      0x1
#define ViewAlignmentMaskMiddle   0x2
#define ViewAlignmentMaskBottom   0x4
#define ViewAlignmentMaskLeft     0x8
#define ViewAlignmentMaskCenter   0x10
#define ViewAlignmentMaskRight    0x20
#define ViewAlignmentMaskInternal 0x100
 
#define ViewAlignmentMaskVertical \
    (ViewAlignmentMaskTop | ViewAlignmentMaskMiddle | ViewAlignmentMaskBottom)
 
#define ViewAlignmentMaskHorizontal \
    (ViewAlignmentMaskLeft | ViewAlignmentMaskCenter | ViewAlignmentMaskRight)
 
typedef enum {
    ViewAlignmentNone,
    ViewAlignmentTop = ViewAlignmentMaskTop,
    ViewAlignmentMiddle = ViewAlignmentMaskMiddle,
    ViewAlignmentBottom = ViewAlignmentMaskBottom,
    ViewAlignmentLeft = ViewAlignmentMaskLeft,
    ViewAlignmentCenter = ViewAlignmentMaskCenter,
    ViewAlignmentRight = ViewAlignmentMaskRight,
    ViewAlignmentTopLeft = (ViewAlignmentMaskTop | ViewAlignmentMaskLeft),
    ViewAlignmentTopCenter = (ViewAlignmentMaskTop | ViewAlignmentMaskCenter),
    ViewAlignmentTopRight = (ViewAlignmentMaskTop | ViewAlignmentMaskRight),
    ViewAlignmentMiddleLeft = (ViewAlignmentMaskMiddle | ViewAlignmentMaskLeft),
    ViewAlignmentMiddleCenter = (ViewAlignmentMaskMiddle | ViewAlignmentMaskCenter),
    ViewAlignmentMiddleRight = (ViewAlignmentMaskMiddle | ViewAlignmentMaskRight),
    ViewAlignmentBottomLeft = (ViewAlignmentMaskBottom | ViewAlignmentMaskLeft),
    ViewAlignmentBottomCenter = (ViewAlignmentMaskBottom | ViewAlignmentMaskCenter),
    ViewAlignmentBottomRight = (ViewAlignmentMaskBottom | ViewAlignmentMaskRight),
    ViewAlignmentInternal = ViewAlignmentMaskInternal
} ViewAlignment;
 
OBJECTIVELYMVC_EXPORT const EnumName ViewAlignmentNames[];
 
typedef enum {
    ViewAutoresizingNone = 0,
    ViewAutoresizingWidth = 0x1,
    ViewAutoresizingHeight = 0x2,
    ViewAutoresizingFill = 0x3,
    ViewAutoresizingFit = 0x4,
    ViewAutoresizingContain = 0x8
} ViewAutoresizing;
 
OBJECTIVELYMVC_EXPORT const EnumName ViewAutoresizingNames[];
 
typedef struct {
    int top, right, bottom, left;
} ViewPadding;
 
#define MakePadding(top, right, bottom, left) \
    (ViewPadding) { (top), (right), (bottom), (left) }
 
#define AddPadding(a, b) \
    MakePadding(a.top + b.top, a.right + b.right, a.bottom + b.bottom, a.left + b.left)
 
typedef enum {
    ViewPositionBefore = -1,
    ViewPositionAfter = 1
} ViewPosition;
 
typedef struct ViewInterface ViewInterface;
 
struct View {
 
    Object object;
 
    ViewInterface *interface;
 
    ViewAlignment alignment;
 
    int autoresizingMask;
 
    SDL_Color backgroundColor;
 
    SDL_Color borderColor;
 
    int borderWidth;
 
    MutableSet *classNames;
 
    _Bool clipsSubviews;
 
    Style *computedStyle;
 
    SDL_Rect frame;
 
    _Bool hidden;
 
    char *identifier;
 
    SDL_Size maxSize;
 
    SDL_Size minSize;
 
    _Bool needsApplyTheme;
 
    _Bool needsLayout;
 
    View *nextResponder;
 
    ViewPadding padding;
 
    Style *style;
 
    Stylesheet *stylesheet;
 
    MutableArray *subviews;
 
    View *superview;
 
    ViewController *viewController;
 
    MutableArray *warnings;
 
    SDL_Window *window;
};
 
struct ViewInterface {
 
    ObjectInterface parentInterface;
 
    _Bool (*acceptsFirstResponder)(const View *self);
 
    void (*addClassName)(View *self, const char *className);
 
    void (*addSubview)(View *self, View *subview);
 
    void (*addSubviewRelativeTo)(View *self, View *subview, View *other, ViewPosition position);
 
    View *(*ancestorWithIdentifier)(const View *self, const char *identifier);
 
    void (*applyStyle)(View *self, const Style *style);
 
    void (*applyTheme)(View *self, const Theme *theme);
 
    void (*applyThemeIfNeeded)(View *self, const Theme *theme);
 
    void (*attachStylesheet)(View *self, SDL_Window *window);
 
    void (*awakeWithCharacters)(View *self, const char *chars);
 
    void (*awakeWithData)(View *self, const Data *data);
 
    void (*awakeWithDictionary)(View *self, const Dictionary *dictionary);
 
    void (*awakeWithResource)(View *self, const Resource *resource);
 
    void (*awakeWithResourceName)(View *self, const char *name);
 
    void (*becomeFirstResponder)(View *self);
 
    _Bool (*bind)(View *self, const Inlet *inlets, const Dictionary *dictionary);
 
    SDL_Rect (*bounds)(const View *self);
 
    void (*bringSubviewToFront)(View *self, View *subview);
 
    SDL_Rect (*clippingFrame)(const View *self);
 
    _Bool (*containsPoint)(const View *self, const SDL_Point *point);
 
    int (*depth)(const View *self);
 
    View *(*descendantWithIdentifier)(const View *self, const char *identifier);
 
    void (*detachStylesheet)(View *self, SDL_Window *window);
 
    void (*didMoveToWindow)(View *self, SDL_Window *window);
 
    _Bool (*didReceiveEvent)(const View *self, const SDL_Event *event);
 
    void (*draw)(View *self, Renderer *renderer);
 
    void (*enumerate)(View *self, ViewEnumerator enumerator, ident data);
 
    void (*enumerateAdjacent)(const View *self, ViewEnumerator enumerator, ident data);
 
    void (*enumerateAncestors)(const View *self, ViewEnumerator enumerator, ident data);
 
    void (*enumerateDescendants)(const View *self, ViewEnumerator enumerator, ident data);
 
    void (*enumerateSelection)(View *self, const char *rule, ViewEnumerator enumerator, ident data);
 
    void (*enumerateSiblings)(const View *self, ViewEnumerator enumerator, ident data);
 
    void (*enumerateSubviews)(const View *self, ViewEnumerator enumerator, ident data);
 
    void (*enumerateSuperview)(const View *self, ViewEnumerator enumerator, ident data);
 
    View *(*firstResponder)(SDL_Window *window);
 
    _Bool (*hasClassName)(const View *self, const char *className);
 
    View *(*hitTest)(const View *self, const SDL_Point *point);
 
    View *(*init)(View *self);
 
    View *(*initWithFrame)(View *self, const SDL_Rect *frame);
 
    void (*invalidateStyle)(View *self);
 
    _Bool (*isContainer)(const View *self);
 
    _Bool (*isDescendantOfView)(const View *self, const View *view);
 
    _Bool (*isFirstResponder)(const View *self);
 
    _Bool (*isVisible)(const View *self);
 
    void (*layoutIfNeeded)(View *self);
 
    void (*layoutSubviews)(View *self);
 
    _Bool (*matchesSelector)(const View *self, const SimpleSelector *simpleSelector);
 
    void (*moveToWindow)(View *self, SDL_Window *window);
 
    String *(*path)(const View *self);
 
    void (*removeAllClassNames)(View *self);
 
    void (*removeAllSubviews)(View *self);
 
    void (*removeClassName)(View *self, const char *className);
 
    void (*removeFromSuperview)(View *self);
 
    void (*removeSubview)(View *self, View *subview);
 
    void (*render)(View *self, Renderer *renderer);
 
    void (*renderDeviceDidReset)(View *self);
 
    void (*renderDeviceWillReset)(View *self);
 
    SDL_Rect (*renderFrame)(const View *self);
 
    void (*replaceSubview)(View *self, View *subview, View *replacement);
 
    void (*resignFirstResponder)(View *self);
 
    void (*resize)(View *self, const SDL_Size *size);
 
    void (*resolve)(View *self, Outlet *outlets);
 
    void (*respondToEvent)(View *self, const SDL_Event *event);
 
    Set *(*select)(View *self, const char *rule);
 
    void (*setFirstResponder)(SDL_Window *window, View *view);
 
    SDL_Size (*size)(const View *self);
 
    SDL_Size (*sizeThatContains)(const View *self);
 
    SDL_Size (*sizeThatFits)(const View *self);
 
    void (*sizeToContain)(View *self);
 
    void (*sizeToFit)(View *self);
 
    View *(*subviewWithIdentifier)(const View *self, const char *identifier);
 
    void (*updateBindings)(View *self);
 
    SDL_Rect (*viewport)(const View *self);
 
    View *(*viewWithCharacters)(const char *chars, Outlet *outlets);
 
    View *(*viewWithData)(const Data *data, Outlet *outlets);
 
    View *(*viewWithDictionary)(const Dictionary *dictionary, Outlet *outlets);
 
    View *(*viewWithResource)(const Resource *resource, Outlet *outlets);
 
    View *(*viewWithResourceName)(const char *name, Outlet *outlets);
 
    Array *(*visibleSubviews)(const View *self);
 
    void (*warn)(View *self, const char *fmt, ...);
 
    void (*willMoveToWindow)(View *self, SDL_Window *window);
};
 
OBJECTIVELYMVC_EXPORT Class *_View(void);