View.h

Go to the documentation of this file.

/*
 * ObjectivelyMVC: Object oriented MVC framework for SDL3 and 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/Dictionary.h>
#include <Objectively/Array.h>
#include <Objectively/Set.h>
#include <Objectively/Resource.h>
 
#include <ObjectivelyMVC/Colors.h>
#include <ObjectivelyMVC/Renderer.h>
#include <ObjectivelyMVC/Theme.h>
#include <ObjectivelyMVC/View+JSON.h>
#include <ObjectivelyMVC/Warning.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)
 
#define ViewAlignmentMaskAny \
  (ViewAlignmentMaskHorizontal | ViewAlignmentMaskVertical)
 
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[];
 
#define ClampSize(size, min, max) \
  clamp((size), (min), (max) ? (max) : INT32_MAX)
 
typedef enum {
  ViewPointerEventsAuto,
  ViewPointerEventsNone
} ViewPointerEvents;
 
OBJECTIVELYMVC_EXPORT const EnumName ViewPointerEventsNames[];
 
typedef enum {
  ViewVisibilityUnspecified,
  ViewVisibilityVisible,
  ViewVisibilityHidden
} ViewVisibility;
 
 
OBJECTIVELYMVC_EXPORT const EnumName ViewVisibilityNames[];
 
typedef struct {
  enum {
    ViewConstraintEqual,
 
    ViewConstraintMax,
 
    ViewConstraintUnspecified
  } mode;
 
  int value;
} ViewConstraint;
 
#define MakeConstraint(mode, value) \
  (ViewConstraint) { (mode), (value) }
 
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 struct {
  int topLeft, topRight, bottomRight, bottomLeft;
} ViewCornerCut;
 
#define MakeCornerCut(topLeft, topRight, bottomRight, bottomLeft) \
  (ViewCornerCut) { (topLeft), (topRight), (bottomRight), (bottomLeft) }
 
#define CornerCutIsEmpty(cut) \
  ((cut).topLeft == 0 && (cut).topRight == 0 && (cut).bottomRight == 0 && (cut).bottomLeft == 0)
 
typedef enum {
  ViewPositionBefore = -1,
  ViewPositionAfter = 1
} ViewPosition;
 
typedef struct ViewInterface ViewInterface;
 
struct View {
 
  Object object;
 
  ViewInterface *interface[0];
 
  ViewAlignment alignment;
 
  int autoresizingMask;
 
  SDL_Color backgroundColor;
 
  int backgroundGradientAngle;
 
  SDL_Color backgroundGradientColor;
 
  SDL_Color borderColor;
 
  int borderRadius;
 
  int borderWidth;
 
  Set *classNames;
 
  struct {
    SDL_Rect frame;
    unsigned generation;
  } clippingFrameCache;
 
  bool clipsSubviews;
 
  Style *computedStyle;
 
  ViewCornerCut cornerCut;
 
  SDL_Rect frame;
 
  char *identifier;
 
  SDL_Size maxSize;
 
  SDL_Size minSize;
 
  bool needsApplyTheme;
 
  bool needsApplyStyle;
 
  bool needsApplyThemeSubviews;
 
  bool needsLayout;
 
  bool needsLayoutSubviews;
 
  View *nextResponder;
 
  ViewPadding padding;
 
  ViewPointerEvents pointerEvents;
 
  struct {
    SDL_Rect frame;
    unsigned generation;
  } renderFrameCache;
 
  Style *style;
 
  bool stretch;
 
  Stylesheet *stylesheet;
 
  Array *subviews;
 
  View *superview;
 
  ViewController *viewController;
 
  ViewVisibility visibility;
 
  Array *warnings;
 
  SDL_Window *window;
};
 
struct ViewInterface {
 
  ObjectInterface parentInterface;
 
  bool (*acceptsKeyResponder)(const View *self);
 
  bool (*acceptsTouchResponder)(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 (*becomeKeyResponder)(View *self);
 
  void (*becomeTouchResponder)(View *self);
 
  bool (*bind)(View *self, const Inlet *inlets, const Dictionary *dictionary);
 
  SDL_Rect (*bounds)(const View *self);
 
  void (*bringSubviewToFront)(View *self, View *subview);
 
  void (*clearWarnings)(const View *self, WarningType level);
 
  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 (*emitViewEvent)(View *self, ViewEvent code, ident data);
 
  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);
 
  void (*enumerateVisible)(View *self, ViewEnumerator enumerator, ident data);
 
  bool (*hasClassName)(const View *self, const char *className);
 
  bool (*hasOverflow)(const View *self);
 
  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 (*isKeyResponder)(const View *self);
 
  bool (*isTouchResponder)(const View *self);
 
  bool (*isVisible)(const View *self);
 
  void (*layoutIfNeeded)(View *self);
 
  void (*layoutSubviews)(View *self);
 
  void (*layoutWithConstraint)(View *self, ViewConstraint width, ViewConstraint height);
 
  void (*layoutWithSize)(View *self, const SDL_Size *size);
 
  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 (*resignKeyResponder)(View *self);
 
  void (*resignTouchResponder)(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);
 
  View *(*selectFirst)(View *self, const char *rule);
 
  void (*setVisibility)(View *self, ViewVisibility visibility);
 
  void (*setNeedsApplyTheme)(View *self);
 
  void (*setNeedsLayout)(View *self);
 
  SDL_Size (*size)(const View *self);
 
  SDL_Size (*sizeThatContains)(const View *self);
 
  SDL_Size (*sizeThatFits)(const View *self);
 
  SDL_Size (*sizeThatFills)(const View *self);
 
  SDL_Size (*sizeThatSatisfies)(View *self, ViewConstraint width, ViewConstraint height);
 
  void (*sizeToContain)(View *self);
 
  void (*sizeToFill)(View *self);
 
  void (*sizeToFit)(View *self);
 
  void (*sizeToSatisfy)(View *self, ViewConstraint width, ViewConstraint height);
 
  View *(*subviewWithIdentifier)(const View *self, const char *identifier);
 
  void (*updateBindings)(View *self, ident data);
 
  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, WarningType level, const char *fmt, ...);
 
  void (*willMoveToWindow)(View *self, SDL_Window *window);
};
 
OBJECTIVELYMVC_EXPORT Class *_View(void);
 
OBJECTIVELYMVC_EXPORT void MVC_InvalidateRenderFrames(void);