neoGFX - User contributions [en-gb]

Naming Convention

2026-01-05T22:04:43Z

Leigh:

The ''neoGFX'' naming convention is based on the idea that to aid readability of C++ code it is better to encode ''scope'' rather than ''type'' in an identifier name prefix. The idea of encoding scope in identifier names was introduced by the smartphone operating system ''EPOC32'' (later ''Symbian OS'').

The following table lists the various C++ syntactical constructs with their associated convention:

{| class="wikitable" style="margin-left: 0px; margin-right: auto;"
|+ neoGFX Naming Convention
|-
! Construct !! Convention !! Example !! Note
|-
| macro || upper snake case || <code>FOO_BAR</code> || snake_case is used for in-class ''event definition'' macros
|-
| function name || snake case || <code>foo_bar</code>
|-
| struct/class name || snake case || <code>foo_bar</code>
|-
| interface class name || snake case; <code>i_</code> prefix || <code>i_foo_bar</code> || an ''interface class'' does not have any member variables, containing only pure virtual functions and any associated helper functions
|-
| enum class name || snake case || <code>foo_bar</code>
|-
| enum name || snake case; <code>_e</code> suffix || <code>foo_bar_e</code> || C-style enums
|-
| enumerator || upper camel case || <code>FooBar</code>
|-
| function parameter || camel case; <code>a</code> prefix || <code>aFooBar</code> || "a" for ''argument''
|-
| local variable || lower camel case || <code>fooBar</code>
|-
| member variable (class) || camel case; <code>i</code> prefix || <code>iFooBar</code> || "i" for class ''instance'' variable
|-
| member variable (struct) || lower camel case || <code>fooBar</code> || use <code>struct</code> for classes that don't have a ''class invariant''
|-
| variable with static storage duration || camel case; <code>s</code> prefix || <code>sFooBar</code>
|-
| variable with thread local storage duration || camel case; <code>t</code> prefix || <code>tFooBar</code>
|-
| event object || upper camel case || <code>FooBar</code>
|-
| event (virtual) getter function || snake case || <code>foo_bar</code>
|}

Example class:
<pre>
class foo
{
public:
foo(int aValue) : iValue{ aValue }
{
}
public:
int value() const
{
return iValue;
}
void something()
{
thread_local qux tQux;
/* ... code ... */
}
private:
int iValue;
};
</pre>

Naming Convention

2026-01-05T22:03:26Z

Leigh:

The ''neoGFX'' naming convention is based on the idea that to aid readability of C++ code it is better to encode ''scope'' rather than ''type'' in an identifier name prefix. The idea of encoding scope in identifier names was introduced by the smartphone operating system ''Symbian OS''.

The following table lists the various C++ syntactical constructs with their associated convention:

{| class="wikitable" style="margin-left: 0px; margin-right: auto;"
|+ neoGFX Naming Convention
|-
! Construct !! Convention !! Example !! Note
|-
| macro || upper snake case || <code>FOO_BAR</code> || snake_case is used for in-class ''event definition'' macros
|-
| function name || snake case || <code>foo_bar</code>
|-
| struct/class name || snake case || <code>foo_bar</code>
|-
| interface class name || snake case; <code>i_</code> prefix || <code>i_foo_bar</code> || an ''interface class'' does not have any member variables, containing only pure virtual functions and any associated helper functions
|-
| enum class name || snake case || <code>foo_bar</code>
|-
| enum name || snake case; <code>_e</code> suffix || <code>foo_bar_e</code> || C-style enums
|-
| enumerator || upper camel case || <code>FooBar</code>
|-
| function parameter || camel case; <code>a</code> prefix || <code>aFooBar</code> || "a" for ''argument''
|-
| local variable || lower camel case || <code>fooBar</code>
|-
| member variable (class) || camel case; <code>i</code> prefix || <code>iFooBar</code> || "i" for class ''instance'' variable
|-
| member variable (struct) || lower camel case || <code>fooBar</code> || use <code>struct</code> for classes that don't have a ''class invariant''
|-
| variable with static storage duration || camel case; <code>s</code> prefix || <code>sFooBar</code>
|-
| variable with thread local storage duration || camel case; <code>t</code> prefix || <code>tFooBar</code>
|-
| event object || upper camel case || <code>FooBar</code>
|-
| event (virtual) getter function || snake case || <code>foo_bar</code>
|}

Example class:
<pre>
class foo
{
public:
foo(int aValue) : iValue{ aValue }
{
}
public:
int value() const
{
return iValue;
}
void something()
{
thread_local qux tQux;
/* ... code ... */
}
private:
int iValue;
};
</pre>

Naming Convention

2026-01-05T22:02:28Z

Leigh:

The ''neoGFX'' naming convention is based on the idea that to aid readability of C++ code it is better to encode ''scope'' rather than ''type'' in an identifier name prefix. The idea of encoding scope in identifier names was introduced by the smartphone operating system ''Symbian OS''.

The following table lists the various C++ syntactical constructs with their associated convention:

{| class="wikitable" style="margin-left: 0px; margin-right: auto;"
|+ neoGFX Naming Convention
|-
! Construct !! Convention !! Example !! Note
|-
| macro || upper snake case || <code>FOO_BAR</code> || snake_case is used for in-class ''event definition'' macros
|-
| function name || snake case || <code>foo_bar</code>
|-
| struct/class name || snake case || <code>foo_bar</code>
|-
| interface class name || snake case; <code>i_</code> prefix || <code>i_foo_bar</code> || an ''interface class'' does not have any member variables, containing only pure virtual functions and any associated helper functions
|-
| enum class name || snake case || <code>foo_bar</code>
|-
| enum name || snake case; <code>_e</code> suffix || <code>foo_bar_e</code> || C-style enums
|-
| enumerator || upper camel case || <code>FooBar</code>
|-
| function parameter || camel case; <code>a</code> prefix || <code>aFooBar</code> || "a" for ''argument''
|-
| local variable || lower camel case || <code>fooBar</code>
|-
| member variable (class) || camel case; <code>i</code> prefix || <code>iFooBar</code> || "i" for class ''instance'' variable
|-
| member variable (struct) || lower camel case || <code>fooBar</code> || use <code>struct</code> for classes that don't have a ''class invariant''
|-
| variable with static storage duration || camel case; <code>s</code> prefix || <code>sFooBar</code>
|-
| variable with thread local storage duration || camel case; <code>t</code> prefix || <code>tFooBar</code>
|-
| event object || upper camel case || <code>FooBar</code>
|-
| event (virtual) getter function || snake_case || <code>foo_bar</code>
|}

Example class:
<pre>
class foo
{
public:
foo(int aValue) : iValue{ aValue }
{
}
public:
int value() const
{
return iValue;
}
void something()
{
thread_local qux tQux;
/* ... code ... */
}
private:
int iValue;
};
</pre>

Naming Convention

2026-01-05T19:47:34Z

Leigh:

The ''neoGFX'' naming convention is based on the idea that to aid readability of C++ code it is better to encode ''scope'' rather than ''type'' in an identifier name prefix. The idea of encoding scope in identifier names was introduced by the smartphone operating system ''Symbian OS''.

The following table lists the various C++ syntactical constructs with their associated convention:

{| class="wikitable" style="margin-left: 0px; margin-right: auto;"
|+ neoGFX Naming Convention
|-
! Construct !! Convention !! Example !! Note
|-
| macro || UPPER_SNAKE_CASE || <code>FOO_BAR</code> || snake_case is used for in-class ''event definition'' macros
|-
| function name || snake_case || <code>foo_bar</code>
|-
| struct/class name || snake_case || <code>foo_bar</code>
|-
| interface class name || snake_case; <code>i_</code> prefix || <code>i_foo_bar</code> || an ''interface class'' does not have any member variables, containing only pure virtual functions and any associated helper functions
|-
| enum class name || snake_case || <code>foo_bar</code>
|-
| enum name || snake_case; <code>_e</code> suffix || <code>foo_bar_e</code> || C-style enums
|-
| enumerator || UpperCamelCase || <code>FooBar</code>
|-
| function parameter || CamelCase; <code>a</code> prefix || <code>aFooBar</code> || "a" for ''argument''
|-
| local variable || lowerCamelCase || <code>fooBar</code>
|-
| member variable (class) || CamelCase; <code>i</code> prefix || <code>iFooBar</code> || "i" for class ''instance'' variable
|-
| member variable (struct) || lowerCamelCase || <code>fooBar</code> || use <code>struct</code> for classes that don't have a ''class invariant''
|-
| variable with static storage duration || CamelCase; <code>s</code> prefix || <code>sFooBar</code>
|-
| variable with thread local storage duration || CamelCase; <code>t</code> prefix || <code>tFooBar</code>
|-
| event object || UpperCamelCase || <code>FooBar</code>
|-
| event (virtual) getter function || snake_case || <code>foo_bar</code>
|}

Example class:
<pre>
class foo
{
public:
foo(int aValue) : iValue{ aValue }
{
}
public:
int value() const
{
return iValue;
}
void something()
{
thread_local qux tQux;
/* ... code ... */
}
private:
int iValue;
};
</pre>

Naming Convention

2026-01-05T19:43:33Z

Leigh:

The ''neoGFX'' naming convention is based on the idea that to aid readability of C++ code it is better to encode ''scope'' rather than ''type'' in an identifier name prefix. The idea of encoding scope in identifier names was introduced by the smartphone operating system ''Symbian OS''.

The following table lists the various C++ syntactical constructs with their associated convention:

{| class="wikitable" style="margin-left: 0px; margin-right: auto;"
|+ neoGFX Naming Convention
|-
! Construct !! Convention !! Example !! Note
|-
| macro || UPPER_SNAKE_CASE || <code>MY_MACRO</code> || snake_case is used for in-class ''event definition'' macros
|-
| function name || snake_case || <code>my_function</code>
|-
| struct/class name || snake_case || <code>my_class</code>
|-
| interface class name || snake_case; <code>i_</code> prefix || <code>i_my_interface</code> || an ''interface class'' does not have any member variables, containing only pure virtual functions and any associated helper functions
|-
| enum class name || snake_case || <code>my_enum</code>
|-
| enum name || snake_case; <code>_e</code> suffix || <code>my_enum_e</code> || C-style enums
|-
| enumerator || UpperCamelCase || <code>MyEnumerator</code>
|-
| function parameter || CamelCase; <code>a</code> prefix || <code>aMyVariable</code> || "a" for ''argument''
|-
| local variable || lowerCamelCase || <code>myVariable</code>
|-
| member variable (class) || CamelCase; <code>i</code> prefix || <code>iMyVariable</code> || "i" for class ''instance'' variable
|-
| member variable (struct) || lowerCamelCase || <code>myVariable</code> || use <code>struct</code> for classes that don't have a ''class invariant''
|-
| variable with static storage duration || CamelCase; <code>s</code> prefix || <code>sMyVariable</code>
|-
| variable with thread local storage duration || CamelCase; <code>t</code> prefix || <code>tMyVariable</code>
|-
| event object || UpperCamelCase || <code>MyEvent</code>
|-
| event (virtual) getter function || snake_case || <code>my_event</code>
|}

Example class:
<pre>
class foo
{
public:
foo(int aValue) : iValue{ aValue }
{
}
public:
int value() const
{
return iValue;
}
void something()
{
thread_local qux tQux;
/* ... code ... */
}
private:
int iValue;
};
</pre>

Main Page

2024-05-05T17:44:57Z

Leigh:

neoGFX C++ Application/Game Engine and Development Platform -- Coming Soon

== Introduction ==
neoGFX is a C++ app/game engine and development platform targeted at app and game developers that wish to leverage modern GPUs for performant application user interfaces and game graphics.

== Features ==
* clean modern C++20 design including full exception safety supporting various widget allocation patterns (stack, member variable or free store);
* use of standard non-proprietary C++ data types including using standard string classes (UTF-8 encoding) and containers from the C++ standard library and Boost where possible;
* simple, easy to use multi-threaded event system (an improvement over traditional signals and slots);
* no baggage: neoGFX primarily contains only the GUI and graphics related functionality needed for creating apps and games;
* full library of widgets and layout managers specifiable in RJSON (Relaxed JSON) using the included GUI designer tool;
* CSS3 style sheet support with support for custom skins;
* scripting engine, ''neos'', that will be able to support a wide range of scripting languages (on release: ''neoscript'' and ''Lua'');
* sub-pixel text rendering;
* simple window style for specifying that a window is "nested" rather than being a separate native desktop window;
* "text_edit" widget supports multiple fonts, text colours (with optional gradient effects), colour emojis and rendering text in columns;
* "Green" and "Turbo" modes to optimize CPU power consumption, fight #ClimateChange!
* GPU shader rendered CSS3 compliant gradients with optional gaussian smoothing;
* MVC (model-view-controller) related classes supporting robust and fast app design;
* optional MDI support utilizing "nested" windows;
* 2D, 2.5D and 3D game support: sprites, objects and physics;
* Pure ECS (Entity-component-system) usable by both games and apps;
* flexible asset management: texture images (e.g PNGs) can be stored in .zip archives which can be optionally embedded inside the program binary accessible using simple URLs;
* support for OpenGL and Vulkan.

== Featured Pages ==
* '''[[Naming Convention]]'''
* '''[[Event System]]'''

Main Page

2024-05-05T17:44:19Z

Leigh: /* Features */

neoGFX C++ Application/Game Engine and Development Platform -- Coming Soon

== Introduction ==
neoGFX is a C++ app/game engine and development platform targeted at app and game developers that wish to leverage modern GPUs for performant application user interfaces and game graphics.

== Features ==
* clean modern C++20 design including full exception safety supporting various widget allocation patterns (stack, member variable or free store);
* use of standard non-proprietary C++ data types including using standard string classes (UTF-8 encoding) and containers from the C++ standard library and Boost where possible;
* simple, easy to use multi-threaded event system (an improvement over traditional signals and slots);
* no baggage: neoGFX primarily contains only the GUI and graphics related functionality needed for creating apps and games;
* full library of widgets and layout managers specifiable in RJSON (Relaxed JSON) using the included GUI designer tool;
* CSS3 style sheet support with support for custom skins;
* scripting engine, ''neos'', that will be able to support a wide range of scripting languages (on release: ''neoscript'' and ''Lua'');
* sub-pixel text rendering;
* simple window style for specifying that a window is "nested" rather than being a separate native desktop window;
* "text_edit" widget supports multiple fonts, text colours (with optional gradient effects), colour emojis and rendering text in columns;
* "Green" and "Turbo" modes to optimize CPU power consumption, fight #ClimateChange!
* GPU shader rendered CSS3 compliant gradients with optional gaussian smoothing;
* MVC (model-view-controller) related classes supporting robust and fast app design;
* optional MDI support utilizing "nested" windows;
* 2D, 2.5D and 3D game support: sprites, objects and physics;
* Pure ECS (Entity-component-system) usable by both games and apps;
* flexible asset management: texture images (e.g PNGs) can be stored in .zip archives which can be optionally embedded inside the program binary accessible using simple URLs;
* support for OpenGL, DirectX and Vulkan.

== Featured Pages ==
* '''[[Naming Convention]]'''
* '''[[Event System]]'''

Naming Convention

2024-05-05T15:06:02Z

Leigh:

The ''neoGFX'' naming convention is based on the idea that to aid readability of C++ code it is better to encode ''scope'' rather than ''type'' in an identifier name prefix. The idea of encoding scope in identifier names was introduced by the smartphone operating system ''Symbian OS''.

The following table lists the various C++ syntactical constructs with their associated convention:

{| class="wikitable" style="margin-left: 0px; margin-right: auto;"
|+ neoGFX Naming Convention
|-
! Construct !! Convention !! Example !! Note
|-
| macro || UPPER_SNAKE_CASE || <code>MY_MACRO</code> || snake_case is used for in-class ''event definition'' macros
|-
| function name || snake_case || <code>my_function</code>
|-
| struct/class name || snake_case || <code>my_class</code>
|-
| interface class name || snake_case; <code>i_</code> prefix || <code>i_my_interface</code> || an ''interface class'' does not have any member variables, containing only pure virtual functions and any associated helper functions
|-
| enum class name || snake_case || <code>my_enum</code>
|-
| enum name || snake_case; <code>_e</code> suffix || <code>my_enum_e</code> || C-style enums
|-
| enumerator || UpperCamelCase || <code>MyEnumerator</code>
|-
| function parameter || CamelCase; <code>a</code> prefix || <code>myVariable</code> || "a" for ''argument''
|-
| local variable || lowerCamelCase || <code>myVariable</code>
|-
| member variable (class) || CamelCase; <code>i</code> prefix || <code>iMyVariable</code> || "i" for class ''instance'' variable
|-
| member variable (struct) || lowerCamelCase || <code>myVariable</code> || use <code>struct</code> for classes that don't have a ''class invariant''
|-
| variable with static storage duration || CamelCase; <code>s</code> prefix || <code>sMyVariable</code>
|-
| variable with thread local storage duration || CamelCase; <code>t</code> prefix || <code>tMyVariable</code>
|-
| event object || UpperCamelCase || <code>MyEvent</code>
|-
| event (virtual) getter function || snake_case || <code>my_event</code>
|}

Example class:
<pre>
class foo
{
public:
foo(int aValue) : iValue{ aValue }
{
}
public:
int value() const
{
return iValue;
}
void something()
{
thread_local qux tQux;
/* ... code ... */
}
private:
int iValue;
};
</pre>

Naming Convention

2024-05-05T15:04:57Z

Leigh:

The ''neoGFX'' naming convention is based on the idea that to aid readability of C++ code it is better to encode ''scope'' rather than ''type'' in an identifier name prefix. The idea of encoding scope in identifier names was introduced by the smartphone operating system ''Symbian OS''.

The following table lists the various C++ syntactical constructs with their associated convention:

{| class="wikitable" style="margin-left: 0px; margin-right: auto;"
|+ neoGFX Naming Convention
|-
! Construct !! Convention !! Example !! Note
|-
| macro || UPPER_SNAKE_CASE || <code>MY_MACRO</code> || snake_case is used for in-class ''event definition'' macros
|-
| function name || snake_case || <code>my_function</code>
|-
| struct/class name || snake_case || <code>my_class</code>
|-
| interface class name || snake_case; <code>i_</code> prefix || <code>i_my_interface</code> || an ''interface class'' does not have any member variables, containing only pure virtual functions and any associated helper functions
|-
| enum class name || snake_case || <code>my_enum</code>
|-
| enum name || snake_case; <code>_e</code> suffix || <code>my_enum_e</code>
|-
| enumerator || UpperCamelCase || <code>MyEnumerator</code>
|-
| function parameter || CamelCase; <code>a</code> prefix || <code>myVariable</code> || "a" for ''argument''
|-
| local variable || lowerCamelCase || <code>myVariable</code>
|-
| member variable (class) || CamelCase; <code>i</code> prefix || <code>iMyVariable</code> || "i" for class ''instance'' variable
|-
| member variable (struct) || lowerCamelCase || <code>myVariable</code> || use <code>struct</code> for classes that don't have a ''class invariant''
|-
| variable with static storage duration || CamelCase; <code>s</code> prefix || <code>sMyVariable</code>
|-
| variable with thread local storage duration || CamelCase; <code>t</code> prefix || <code>tMyVariable</code>
|-
| event object || UpperCamelCase || <code>MyEvent</code>
|-
| event (virtual) getter function || snake_case || <code>my_event</code>
|}

Example class:
<pre>
class foo
{
public:
foo(int aValue) : iValue{ aValue }
{
}
public:
int value() const
{
return iValue;
}
void something()
{
thread_local qux tQux;
/* ... code ... */
}
private:
int iValue;
};
</pre>

Naming Convention

2024-05-05T15:04:08Z

Leigh:

The ''neoGFX'' naming convention is based on the idea that to aid readability it is better to encode ''scope'' rather than ''type'' in an identifier name prefix. The idea of encoding scope in identifier names was introduced by the smartphone operating system ''Symbian OS''.

The following table lists the various C++ syntactical constructs with their associated convention:

{| class="wikitable" style="margin-left: 0px; margin-right: auto;"
|+ neoGFX Naming Convention
|-
! Construct !! Convention !! Example !! Note
|-
| macro || UPPER_SNAKE_CASE || <code>MY_MACRO</code> || snake_case is used for in-class ''event definition'' macros
|-
| function name || snake_case || <code>my_function</code>
|-
| struct/class name || snake_case || <code>my_class</code>
|-
| interface class name || snake_case; <code>i_</code> prefix || <code>i_my_interface</code> || an ''interface class'' does not have any member variables, containing only pure virtual functions and any associated helper functions
|-
| enum class name || snake_case || <code>my_enum</code>
|-
| enum name || snake_case; <code>_e</code> suffix || <code>my_enum_e</code>
|-
| enumerator || UpperCamelCase || <code>MyEnumerator</code>
|-
| function parameter || CamelCase; <code>a</code> prefix || <code>myVariable</code> || "a" for ''argument''
|-
| local variable || lowerCamelCase || <code>myVariable</code>
|-
| member variable (class) || CamelCase; <code>i</code> prefix || <code>iMyVariable</code> || "i" for class ''instance'' variable
|-
| member variable (struct) || lowerCamelCase || <code>myVariable</code> || use <code>struct</code> for classes that don't have a ''class invariant''
|-
| variable with static storage duration || CamelCase; <code>s</code> prefix || <code>sMyVariable</code>
|-
| variable with thread local storage duration || CamelCase; <code>t</code> prefix || <code>tMyVariable</code>
|-
| event object || UpperCamelCase || <code>MyEvent</code>
|-
| event (virtual) getter function || snake_case || <code>my_event</code>
|}

Example class:
<pre>
class foo
{
public:
foo(int aValue) : iValue{ aValue }
{
}
public:
int value() const
{
return iValue;
}
void something()
{
thread_local qux tQux;
/* ... code ... */
}
private:
int iValue;
};
</pre>

Naming Convention

2024-05-05T15:03:17Z

Leigh:

The ''neoGFX'' naming convention is based on the idea that to aid readability it is better to encode ''scope'' rather than ''type'' in an identifier name prefix. The idea of encoding scope in identifier names was introduced by the smartphone operating system ''Symbian OS''.

The following table lists the various C++ syntactical constructs with their associated convention:

{| class="wikitable" style="margin-left: 0px; margin-right: auto;"
|+ neoGFX Naming Convention
|-
! Construct !! Convention !! Example !! Note
|-
| macro || UPPER_SNAKE_CASE || <code>MY_MACRO</code> || snake_case is used for in-class ''event definition'' macros
|-
| function name || snake_case || <code>my_function</code>
|-
| struct/class name || snake_case || <code>my_class</code>
|-
| interface class name || snake_case; <code>i_</code> prefix || <code>i_my_interface</code> || an ''interface class'' does not have any member variables, containing only pure virtual functions and any associated helper functions
|-
| enum class name || snake_case || <code>my_enum</code>
|-
| enum name || snake_case; <code>_e</code> suffix || <code>my_enum_e</code>
|-
| enumerator || UpperCamelCase || <code>MyEnumerator</code>
|-
| function parameter || CamelCase; <code>a</code> prefix || <code>myVariable</code> || "a" for ''argument''
|-
| local variable || lowerCamelCase || <code>myVariable</code>
|-
| member variable (class) || CamelCase; <code>i</code> prefix || <code>iMyVariable</code> || "i" for class ''instance'' variable
|-
| member variable (struct) || lowerCamelCase || <code>myVariable</code> || use <code>struct</code> for classes that don't have a ''class invariant''
|-
| variable with static storage duration || CamelCase; <code>s</code> prefix || <code>sMyVariable</code>
|-
| variable with thread local storage duration || CamelCase; <code>t</code> prefix || <code>tMyVariable</code>
|-
| event object || UpperCamelCase || <code>MyEvent</code>
|-
| event (virtual) function || snake_case || <code>my_event</code>
|}

Example class:
<pre>
class foo
{
public:
foo(int aValue) : iValue{ aValue }
{
}
public:
int value() const
{
return iValue;
}
void something()
{
thread_local qux tQux;
/* ... code ... */
}
private:
int iValue;
};
</pre>

Main Page

2024-05-05T15:03:02Z

Leigh: /* Featured Pages */

neoGFX C++ Application/Game Engine and Development Platform -- Coming Soon

== Introduction ==
neoGFX is a C++ app/game engine and development platform targeted at app and game developers that wish to leverage modern GPUs for performant application user interfaces and game graphics.

== Features ==
* clean modern C++20 design including full exception safety supporting various widget allocation patterns (stack, member variable or free store);
* use of standard non-proprietary C++ data types including using standard string classes (UTF-8 encoding) and containers from the C++ standard library and Boost where possible;
* simple, easy to use multi-threaded event system (an improvement over traditional signals and slots);
* no baggage: neoGFX primarily contains only the GUI and graphics related functionality needed for creating apps and games;
* full library of widgets and layout managers specifiable in RJSON (Relaxed JSON) using the included GUI designer tool;
* CSS3 style sheet support with support for custom skins;
* scripting engine, neos, that will be able to support a wide range of scripting languages (on release: neoscript, JavaScript and Lua);
* sub-pixel text rendering;
* simple window style for specifying that a window is "nested" rather than being a separate native desktop window;
* "text_edit" widget supports multiple fonts, text colours (with optional gradient effects), colour emojis and rendering text in columns;
* "Green" and "Turbo" modes to optimize CPU power consumption, fight #ClimateChange!
* GPU shader rendered CSS3 compliant gradients with optional gaussian smoothing;
* MVC (model-view-controller) related classes supporting robust and fast app design;
* optional MDI support utilizing "nested" windows;
* 2D, 2.5D and 3D game support: sprites, objects and physics;
* Pure ECS (Entity-component-system) usable by both games and apps;
* flexible asset management: texture images (e.g PNGs) can be stored in .zip archives which can be optionally embedded inside the program binary accessible using simple URLs;
* support for OpenGL, DirectX and Vulkan.

== Featured Pages ==
* '''[[Naming Convention]]'''
* '''[[Event System]]'''

Naming Convention

2024-05-05T15:02:40Z

Leigh: Created page with "The neoGFX naming convention is based on the idea that to aid readability it is better to encode ''scope'' rather than ''type'' in an identifier name prefix. The idea of encoding scope in identifier names was introduced by the smartphone operating system ''Symbian OS''. The following table lists the various C++ syntactical constructs with their associated convention: {| class="wikitable" style="margin-left: 0px; margin-right: auto;" |+ neoGFX Naming Convention |- ! Co..."

The neoGFX naming convention is based on the idea that to aid readability it is better to encode ''scope'' rather than ''type'' in an identifier name prefix. The idea of encoding scope in identifier names was introduced by the smartphone operating system ''Symbian OS''.

The following table lists the various C++ syntactical constructs with their associated convention:

{| class="wikitable" style="margin-left: 0px; margin-right: auto;"
|+ neoGFX Naming Convention
|-
! Construct !! Convention !! Example !! Note
|-
| macro || UPPER_SNAKE_CASE || <code>MY_MACRO</code> || snake_case is used for in-class ''event definition'' macros
|-
| function name || snake_case || <code>my_function</code>
|-
| struct/class name || snake_case || <code>my_class</code>
|-
| interface class name || snake_case; <code>i_</code> prefix || <code>i_my_interface</code> || an ''interface class'' does not have any member variables, containing only pure virtual functions and any associated helper functions
|-
| enum class name || snake_case || <code>my_enum</code>
|-
| enum name || snake_case; <code>_e</code> suffix || <code>my_enum_e</code>
|-
| enumerator || UpperCamelCase || <code>MyEnumerator</code>
|-
| function parameter || CamelCase; <code>a</code> prefix || <code>myVariable</code> || "a" for ''argument''
|-
| local variable || lowerCamelCase || <code>myVariable</code>
|-
| member variable (class) || CamelCase; <code>i</code> prefix || <code>iMyVariable</code> || "i" for class ''instance'' variable
|-
| member variable (struct) || lowerCamelCase || <code>myVariable</code> || use <code>struct</code> for classes that don't have a ''class invariant''
|-
| variable with static storage duration || CamelCase; <code>s</code> prefix || <code>sMyVariable</code>
|-
| variable with thread local storage duration || CamelCase; <code>t</code> prefix || <code>tMyVariable</code>
|-
| event object || UpperCamelCase || <code>MyEvent</code>
|-
| event (virtual) function || snake_case || <code>my_event</code>
|}

Example class:
<pre>
class foo
{
public:
foo(int aValue) : iValue{ aValue }
{
}
public:
int value() const
{
return iValue;
}
void something()
{
thread_local qux tQux;
/* ... code ... */
}
private:
int iValue;
};
</pre>

Event System

2024-05-04T21:53:14Z

Leigh:

The ''neoGFX'' event system is a modern, simple improvement over traditional signals and slots.

To create an event handler simply use a lambda expression thus:

<code>
button1.clicked([](){ /* ... code ... */ });
</code>

If automatic event handler de-registration (traditional role of a "slot") is wanted:

<code>
neogfx::sink s;
s += button1.clicked([](){ /* ... code ... */ });
</code>

When 's' is destroyed any associated event registrations are de-registered automatically. Sink objects can be on the stack, member variables or the more traditional slot-like base class sub-object.

The event system is fully multi-threaded. If you want to handle the event in the same thread that is emitting the event rather than the thread that created the event handler then one simply uses the ''thread snake'', <nowiki>~~~~</nowiki>, which has the nice side effect of making it obvious that the lambda is being executed in a thread that may be different to that which is running the surrounding code:

<pre>
/* ... code ... */
~~~~machine.started([](){ /* ... code ... */ });
/* ... code ... */
</pre>

For defining events and triggering them:

<pre>
class foo
{
public:
define_event(OurEvent, our_event, int)
public:
void something()
{
// Using event object directly
OurEvent.trigger(42); // by default a synchronous trigger
OurEvent.sync_trigger(42); // synchronous trigger
OurEvent.async_trigger(42); // asynchronous trigger
// Using event (virtual) function
our_event().trigger(42); // by default a synchronous trigger
our_event().sync_trigger(42); // synchronous trigger
our_event().async_trigger(42); // asynchronous trigger
}
};

class i_xyzzy // an interface (abstract base) class
{
public:
declare_event(our_event, int)
public:
virtual ~i_xyzzy() = default;
public:
virtual void qux() = 0;
/* ... other interface methods or helper functions ... */
};

class xyzzy : public i_xyzzy // a concrete class implementing the above interface
{
public:
define_declared_event(OurEvent, our_event, int)
public:
void qux() final {}
/* ... code ... */
};
</pre>

Event System

2024-05-04T19:02:32Z

Leigh:

The ''neoGFX'' event system is a modern, simple improvement over traditional signals and slots.

To create an event handler simply use a lambda expression thus:

<code>
button1.clicked([](){ /* ... code ... */ });
</code>

If automatic event handler de-registration (traditional role of a "slot") is wanted:

<code>
neogfx::sink s;
s += button1.clicked([](){ /* ... code ... */ });
</code>

When 's' is destroyed any associated event registrations are de-registered automatically. Sink objects can be on the stack, member variables or the more traditional slot-like base class sub-object.

The event system is fully multi-threaded. If you want to handle the event in the same thread that is emitting the event rather than the thread that created the event handler then one simply uses the ''thread snake'', <nowiki>~~~~</nowiki>, which has the nice side effect of making it obvious that the lambda is being executed in a thread that may be different to that which is running the surrounding code:

<pre>
/* ... code ... */
~~~~machine.started([](){ /* ... code ... */ });
/* ... code ... */
</pre>

For defining events and triggering them:

<pre>
class foo
{
public:
define_event(OurEvent, our_event, int)
public:
void something()
{
// Using event object directly
OurEvent.trigger(42); // by default a synchronous trigger
OurEvent.sync_trigger(42); // synchronous trigger
OurEvent.async_trigger(42); // asynchronous trigger
// Using event (virtual) function
our_event().trigger(42); // by default a synchronous trigger
our_event().sync_trigger(42); // synchronous trigger
our_event().async_trigger(42); // asynchronous trigger
}
};

class i_xyzzy // an interface (abstract base) class
{
public:
declare_event(our_event, int)
public:
virtual ~i_frumple() = default;
public:
virtual void qux() = 0;
/* ... code ... */
};

class xyzzy : public i_xyzzy // a concrete class implementing the above interface
{
public:
define_declared_event(OurEvent, our_event, int)
public:
void qux() final {}
/* ... code ... */
};
</pre>

Event System

2024-05-04T19:01:50Z

Leigh:

The ''neoGFX'' event system is a modern, simple improvement over traditional signals and slots.

To create an event handler simply use a lambda expression thus:

<code>
button1.clicked([](){ /* ... code ... */ });
</code>

If automatic event handler de-registration (traditional role of a "slot") is wanted:

<code>
neogfx::sink s;
s += button1.clicked([](){ /* ... code ... */ });
</code>

When 's' is destroyed any associated event registrations are de-registered automatically. Sink objects can be on the stack, member variables or the more traditional slot-like base class sub-object.

The event system is fully multi-threaded. If you want to handle the event in the same thread that is emitting the event rather than the thread that created the event handler then one simply uses the ''thread snake'', <nowiki>~~~~</nowiki>, which has the nice side effect of making it obvious that the lambda is being executed in a thread that may be different to that which is running the surrounding code:

<pre>
/* ... code ... */
~~~~machine.started([](){ /* ... code ... */ });
/* ... code ... */
</pre>

For defining events and triggering them:

<pre>
class foo
{
public:
define_event(OurEvent, our_event, int)
public:
void something()
{
// Using event object directly
OurEvent.trigger(42); // by default a synchronous trigger
OurEvent.sync_trigger(42); // synchronous trigger
OurEvent.async_trigger(42); // asynchronous trigger
// Using event (virtual) function
our_event().trigger(42); // by default a synchronous trigger
our_event().sync_trigger(42); // synchronous trigger
our_event().async_trigger(42); // asynchronous trigger
}
};

class i_xyzzy // an interface (abstract base) class
{
public:
declare_event(our_event, int)
public:
virtual ~i_frumple() = default;
public:
virtual void qux() = 0;
/* ... code ... */
};

class xyzzy : public i_xyzzy // a concrete class implementing the interface i_frumple
{
public:
define_declared_event(OurEvent, our_event, int)
public:
void qux() final {}
/* ... code ... */
};
</pre>

Event System

2024-05-04T19:01:38Z

Leigh:

The ''neoGFX'' event system is a modern, simple improvement over traditional signals and slots.

To create an event handler simply use a lambda expression thus:

<code>
button1.clicked([](){ /* ... code ... */ });
</code>

If automatic event handler de-registration (traditional role of a "slot") is wanted:

<code>
neoGFX::sink s;
s += button1.clicked([](){ /* ... code ... */ });
</code>

When 's' is destroyed any associated event registrations are de-registered automatically. Sink objects can be on the stack, member variables or the more traditional slot-like base class sub-object.

The event system is fully multi-threaded. If you want to handle the event in the same thread that is emitting the event rather than the thread that created the event handler then one simply uses the ''thread snake'', <nowiki>~~~~</nowiki>, which has the nice side effect of making it obvious that the lambda is being executed in a thread that may be different to that which is running the surrounding code:

<pre>
/* ... code ... */
~~~~machine.started([](){ /* ... code ... */ });
/* ... code ... */
</pre>

For defining events and triggering them:

<pre>
class foo
{
public:
define_event(OurEvent, our_event, int)
public:
void something()
{
// Using event object directly
OurEvent.trigger(42); // by default a synchronous trigger
OurEvent.sync_trigger(42); // synchronous trigger
OurEvent.async_trigger(42); // asynchronous trigger
// Using event (virtual) function
our_event().trigger(42); // by default a synchronous trigger
our_event().sync_trigger(42); // synchronous trigger
our_event().async_trigger(42); // asynchronous trigger
}
};

class i_xyzzy // an interface (abstract base) class
{
public:
declare_event(our_event, int)
public:
virtual ~i_frumple() = default;
public:
virtual void qux() = 0;
/* ... code ... */
};

class xyzzy : public i_xyzzy // a concrete class implementing the interface i_frumple
{
public:
define_declared_event(OurEvent, our_event, int)
public:
void qux() final {}
/* ... code ... */
};
</pre>

Event System

2024-05-04T18:59:34Z

Leigh:

The ''neoGFX'' event system is a modern, simple improvement over traditional signals and slots.

To create an event handler simply use a lambda expression thus:

<code>
button1.clicked([](){ /* ... code ... */ });
</code>

If automatic event handler de-registration (traditional role of a "slot") is wanted:

<code>
neoGFX::sink s;
s += button1.clicked([](){ /* ... code ... */ });
</code>

When 's' is destroyed any associated event registrations are de-registered automatically. Sink objects can be on the stack, member variables or the more traditional slot-like base class sub-object.

The event system is fully multi-threaded. If you want to handle the event in the same thread that is emitting the event rather than the thread that created the event handler then one simply uses the ''thread snake'', <nowiki>~~~~</nowiki>, which has the nice side effect of making it obvious that the lambda is being executed in a thread that may be different to that which is running the surrounding code:

<pre>
/* ... code ... */
~~~~machine.started([](){ /* ... code ... */ });
/* ... code ... */
</pre>

For defining events and triggering them:

<pre>
class foo
{
public:
define_event(OurEvent, our_event, int)
public:
void something()
{
// Using event object directly
OurEvent.trigger(42); // by default a synchronous trigger
OurEvent.sync_trigger(42); // synchronous trigger
OurEvent.async_trigger(42); // asynchronous trigger
// Using event (virtual) function
our_event().trigger(42); // by default a synchronous trigger
our_event().sync_trigger(42); // synchronous trigger
our_event().async_trigger(42); // asynchronous trigger
}
};

class i_xyzzy // an interface (abstract base) class
{
public:
declare_event(our_event, int)
public:
virtual ~i_frumple() = default;
public:
/* ... code ... */
};

class xyzzy : public i_xyzzy // a concrete class implementing the interface i_frumple
{
public:
define_declared_event(OurEvent, our_event, int)
public:
/* ... code ... */
};
</pre>

Event System

2024-05-04T18:44:12Z

Leigh:

Main Page

2024-05-04T18:43:51Z

Leigh: /* Featured Pages */

neoGFX C++ Application/Game Engine and Development Platform -- Coming Soon

== Introduction ==
neoGFX is a C++ app/game engine and development platform targeted at app and game developers that wish to leverage modern GPUs for performant application user interfaces and game graphics.

== Features ==
* clean modern C++20 design including full exception safety supporting various widget allocation patterns (stack, member variable or free store);
* use of standard non-proprietary C++ data types including using standard string classes (UTF-8 encoding) and containers from the C++ standard library and Boost where possible;
* simple, easy to use multi-threaded event system (an improvement over traditional signals and slots);
* no baggage: neoGFX primarily contains only the GUI and graphics related functionality needed for creating apps and games;
* full library of widgets and layout managers specifiable in RJSON (Relaxed JSON) using the included GUI designer tool;
* CSS3 style sheet support with support for custom skins;
* scripting engine, neos, that will be able to support a wide range of scripting languages (on release: neoscript, JavaScript and Lua);
* sub-pixel text rendering;
* simple window style for specifying that a window is "nested" rather than being a separate native desktop window;
* "text_edit" widget supports multiple fonts, text colours (with optional gradient effects), colour emojis and rendering text in columns;
* "Green" and "Turbo" modes to optimize CPU power consumption, fight #ClimateChange!
* GPU shader rendered CSS3 compliant gradients with optional gaussian smoothing;
* MVC (model-view-controller) related classes supporting robust and fast app design;
* optional MDI support utilizing "nested" windows;
* 2D, 2.5D and 3D game support: sprites, objects and physics;
* Pure ECS (Entity-component-system) usable by both games and apps;
* flexible asset management: texture images (e.g PNGs) can be stored in .zip archives which can be optionally embedded inside the program binary accessible using simple URLs;
* support for OpenGL, DirectX and Vulkan.

== Featured Pages ==
* '''[[Event System]]'''

Main Page

2024-05-04T18:43:18Z

Leigh:

neoGFX C++ Application/Game Engine and Development Platform -- Coming Soon

== Introduction ==
neoGFX is a C++ app/game engine and development platform targeted at app and game developers that wish to leverage modern GPUs for performant application user interfaces and game graphics.

== Features ==
* clean modern C++20 design including full exception safety supporting various widget allocation patterns (stack, member variable or free store);
* use of standard non-proprietary C++ data types including using standard string classes (UTF-8 encoding) and containers from the C++ standard library and Boost where possible;
* simple, easy to use multi-threaded event system (an improvement over traditional signals and slots);
* no baggage: neoGFX primarily contains only the GUI and graphics related functionality needed for creating apps and games;
* full library of widgets and layout managers specifiable in RJSON (Relaxed JSON) using the included GUI designer tool;
* CSS3 style sheet support with support for custom skins;
* scripting engine, neos, that will be able to support a wide range of scripting languages (on release: neoscript, JavaScript and Lua);
* sub-pixel text rendering;
* simple window style for specifying that a window is "nested" rather than being a separate native desktop window;
* "text_edit" widget supports multiple fonts, text colours (with optional gradient effects), colour emojis and rendering text in columns;
* "Green" and "Turbo" modes to optimize CPU power consumption, fight #ClimateChange!
* GPU shader rendered CSS3 compliant gradients with optional gaussian smoothing;
* MVC (model-view-controller) related classes supporting robust and fast app design;
* optional MDI support utilizing "nested" windows;
* 2D, 2.5D and 3D game support: sprites, objects and physics;
* Pure ECS (Entity-component-system) usable by both games and apps;
* flexible asset management: texture images (e.g PNGs) can be stored in .zip archives which can be optionally embedded inside the program binary accessible using simple URLs;
* support for OpenGL, DirectX and Vulkan.

== Featured Pages ==
* [[Event System]]

Main Page

2024-05-04T18:42:52Z

Leigh:

neoGFX C++ Application/Game Engine and Development Platform -- Coming Soon

== Introduction ==
neoGFX is a C++ app/game engine and development platform targeted at app and game developers that wish to leverage modern GPUs for performant application user interfaces and game graphics.

== Features ==
* clean modern C++20 design including full exception safety supporting various widget allocation patterns (stack, member variable or free store);
* use of standard non-proprietary C++ data types including using standard string classes (UTF-8 encoding) and containers from the C++ standard library and Boost where possible;
* simple, easy to use multi-threaded event system (an improvement over traditional signals and slots);
* no baggage: neoGFX primarily contains only the GUI and graphics related functionality needed for creating apps and games;
* full library of widgets and layout managers specifiable in RJSON (Relaxed JSON) using the included GUI designer tool;
* CSS3 style sheet support with support for custom skins;
* scripting engine, neos, that will be able to support a wide range of scripting languages (on release: neoscript, JavaScript and Lua);
* sub-pixel text rendering;
* simple window style for specifying that a window is "nested" rather than being a separate native desktop window;
* "text_edit" widget supports multiple fonts, text colours (with optional gradient effects), colour emojis and rendering text in columns;
* "Green" and "Turbo" modes to optimize CPU power consumption, fight #ClimateChange!
* GPU shader rendered CSS3 compliant gradients with optional gaussian smoothing;
* MVC (model-view-controller) related classes supporting robust and fast app design;
* optional MDI support utilizing "nested" windows;
* 2D, 2.5D and 3D game support: sprites, objects and physics;
* Pure ECS (Entity-component-system) usable by both games and apps;
* flexible asset management: texture images (e.g PNGs) can be stored in .zip archives which can be optionally embedded inside the program binary accessible using simple URLs;
* support for OpenGL, DirectX and Vulkan.

== Featured Pages ==
[[Event System]]

Event System

2024-05-04T18:38:55Z

Leigh:

The ''neoGFX'' event system is a modern, simple, improvement over traditional signals and slots.

To create an event handler simply use a lambda expression thus:

<code>
button1.clicked([](){ /* ... code ... */ });
</code>

If automatic event handler de-registration (traditional role of a "slot") is wanted:

<code>
neoGFX::sink s;
s += button1.clicked([](){ /* ... code ... */ });
</code>

When 's' is destroyed any associated event registrations are de-registered automatically. Sink objects can be on the stack, member variables or the more traditional slot-like base class sub-object.

The event system is fully multi-threaded. If you want to handle the event in the same thread that is emitting the event rather than the thread that created the event handler then one simply uses the ''thread snake'', <nowiki>~~~~</nowiki>, which has the nice side effect of making it obvious that the lambda is being executed in a thread that may be different to that which is running the surrounding code:

<pre>
/* ... code ... */
~~~~machine.started([](){ /* ... code ... */ });
/* ... code ... */
</pre>

For defining events and triggering them:

<pre>
class foo
{
public:
neoGFX::event<int> wibble;
public:
void something()
{
wibble.trigger(42); // by default a synchronous trigger
wibble.sync_trigger(42); // synchronous trigger
wibble.async_trigger(42); // asynchronous trigger
}
};
</pre>

Event System

2024-05-04T18:38:36Z

Leigh:

Event System

2024-05-04T18:37:55Z

Leigh: Leigh moved page NeoGFX Event System to Event System without leaving a redirect

The ''neoGFX'' event system is both modern and simple and is an improvement over traditional signals and slots.

To create an event handler simply use a lambda expression thus:

<code>
button1.clicked([](){ /* ... code ... */ });
</code>

If automatic event handler de-registration (traditional role of a "slot") is wanted:

<code>
neoGFX::sink s;
s += button1.clicked([](){ /* ... code ... */ });
</code>

When 's' is destroyed any associated event registrations are de-registered automatically. Sink objects can be on the stack, member variables or the more traditional slot-like base class sub-object.

The event system is fully multi-threaded. If you want to handle the event in the same thread that is emitting the event rather than the thread that created the event handler then one simply uses the ''thread snake'', <nowiki>~~~~</nowiki>, which has the nice side effect of making it obvious that the lambda is being executed in a thread that may be different to that which is running the surrounding code:

<pre>
/* ... code ... */
~~~~machine.started([](){ /* ... code ... */ });
/* ... code ... */
</pre>

For defining events and triggering them:

<pre>
class foo
{
public:
neoGFX::event<int> wibble;
public:
void something()
{
wibble.trigger(42); // by default a synchronous trigger
wibble.sync_trigger(42); // synchronous trigger
wibble.async_trigger(42); // asynchronous trigger
}
};
</pre>

Event System

2024-05-04T18:37:37Z

Leigh:

Event System

2024-05-04T18:37:03Z

Leigh:

The neoGFX event system is both modern and simple and is an improvement over traditional signals and slots.

To create an event handler simply use a lambda expression thus:

<code>
button1.clicked([](){ /* ... code ... */ });
</code>

If automatic event handler de-registration (traditional role of a "slot") is wanted:

<code>
neoGFX::sink s;
s += button1.clicked([](){ /* ... code ... */ });
</code>

When 's' is destroyed any associated event registrations are de-registered automatically. Sink objects can be on the stack, member variables or the more traditional slot-like base class sub-object.

The event system is fully multi-threaded. If you want to handle the event in the same thread that is emitting the event rather than the thread that created the event handler then one simply uses the ''thread snake'', <nowiki>~~~~</nowiki>, which has the nice side effect of making it obvious that the lambda is being executed in a thread that may be different to that which is running the surrounding code:

<pre>
/* ... code ... */
~~~~machine.started([](){ /* ... code ... */ });
/* ... code ... */
</pre>

For defining events and triggering them:

<pre>
class foo
{
public:
neoGFX::event<int> wibble;
public:
void something()
{
wibble.trigger(42); // by default a synchronous trigger
wibble.sync_trigger(42); // synchronous trigger
wibble.async_trigger(42); // asynchronous trigger
}
};
</pre>

Event System

2024-05-04T18:35:25Z

Leigh:

{{lowercase title}}

The neoGFX event system is both modern and simple and is an improvement over traditional signals and slots.

To create an event handler simply use a lambda expression thus:

<code>
button1.clicked([](){ /* ... code ... */ });
</code>

If automatic event handler de-registration (traditional role of a "slot") is wanted:

<code>
neoGFX::sink s;
s += button1.clicked([](){ /* ... code ... */ });
</code>

When 's' is destroyed any associated event registrations are de-registered automatically. Sink objects can be on the stack, member variables or the more traditional slot-like base class sub-object.

The event system is fully multi-threaded. If you want to handle the event in the same thread that is emitting the event rather than the thread that created the event handler then one simply uses the ''thread snake'', <nowiki>~~~~</nowiki>, which has the nice side effect of making it obvious that the lambda is being executed in a thread that may be different to that which is running the surrounding code:

<pre>
/* ... code ... */
~~~~machine.started([](){ /* ... code ... */ });
/* ... code ... */
</pre>

For defining events and triggering them:

<pre>
class foo
{
public:
neoGFX::event<int> wibble;
public:
void something()
{
wibble.trigger(42); // by default a synchronous trigger
wibble.sync_trigger(42); // synchronous trigger
wibble.async_trigger(42); // asynchronous trigger
}
};
</pre>

Event System

2024-05-04T18:34:10Z

Leigh: /* neoGFX Event System */

Event System

2024-05-04T18:33:43Z

Leigh: Leigh moved page EventSystem to NeoGFX Event System without leaving a redirect

== neoGFX Event System ==

The neoGFX event system is both modern and simple and is an improvement over traditional signals and slots.

To create an event handler simply use a lambda expression thus:

<code>
button1.clicked([](){ /* ... code ... */ });
</code>

If automatic event handler de-registration (traditional role of a "slot") is wanted:

<code>
neoGFX::sink s;
s += button1.clicked([](){ /* ... code ... */ });
</code>

When 's' is destroyed any associated event registrations are de-registered automatically. Sink objects can be on the stack, member variables or the more traditional slot-like base class sub-object.

The event system is fully multi-threaded. If you want to handle the event in the same thread that is emitting the event rather than the thread that created the event handler then one simply uses the ''thread snake'', <nowiki>~~~~</nowiki>, which has the nice side effect of making it obvious that the lambda is being executed in a thread that may be different to that which is running the surrounding code:

<pre>
/* ... code ... */
~~~~machine.started([](){ /* ... code ... */ });
/* ... code ... */
</pre>

For defining events and triggering them:

<pre>
class foo
{
public:
neoGFX::event<int> wibble;
public:
void something()
{
wibble.trigger(42); // by default a synchronous trigger
wibble.sync_trigger(42); // synchronous trigger
wibble.async_trigger(42); // asynchronous trigger
}
};
</pre>

Event System

2024-05-04T18:32:43Z

Leigh: Created page with "== neoGFX Event System == The neoGFX event system is both modern and simple and is an improvement over traditional signals and slots. To create an event handler simply use a lambda expression thus: <code> button1.clicked([](){ /* ... code ... */ }); </code> If automatic event handler de-registration (traditional role of a "slot") is wanted: <code> neoGFX::sink s; s += button1.clicked([](){ /* ... code ... */ }); </code> When 's' is destroyed any associated event re..."

Main Page

2023-10-29T11:08:56Z

Leigh:

neoGFX C++ Application/Game Engine and Development Platform -- Coming Soon

== Introduction ==
neoGFX is a C++ app/game engine and development platform targeted at app and game developers that wish to leverage modern GPUs for performant application user interfaces and game graphics.

== Features ==
* clean modern C++20 design including full exception safety supporting various widget allocation patterns (stack, member variable or free store);
* use of standard non-proprietary C++ data types including using standard string classes (UTF-8 encoding) and containers from the C++ standard library and Boost where possible;
* simple, easy to use multi-threaded event system (an improvement over traditional signals and slots);
* no baggage: neoGFX primarily contains only the GUI and graphics related functionality needed for creating apps and games;
* full library of widgets and layout managers specifiable in RJSON (Relaxed JSON) using the included GUI designer tool;
* CSS3 style sheet support with support for custom skins;
* scripting engine, neos, that will be able to support a wide range of scripting languages (on release: neoscript, JavaScript and Lua);
* sub-pixel text rendering;
* simple window style for specifying that a window is "nested" rather than being a separate native desktop window;
* "text_edit" widget supports multiple fonts, text colours (with optional gradient effects), colour emojis and rendering text in columns;
* "Green" and "Turbo" modes to optimize CPU power consumption, fight #ClimateChange!
* GPU shader rendered CSS3 compliant gradients with optional gaussian smoothing;
* MVC (model-view-controller) related classes supporting robust and fast app design;
* optional MDI support utilizing "nested" windows;
* 2D, 2.5D and 3D game support: sprites, objects and physics;
* Pure ECS (Entity-component-system) usable by both games and apps;
* flexible asset management: texture images (e.g PNGs) can be stored in .zip archives which can be optionally embedded inside the program binary accessible using simple URLs;
* support for OpenGL, DirectX and Vulkan.

Main Page

2023-10-29T11:08:15Z

Leigh:

neoGFX C++ Application/Game Engine and Development Platform -- Coming Soon

== Introduction ==
neoGFX is a C++ app/game engine and development platform targeted at app and game developers that wish to leverage modern GPUs for performant application user interfaces and game graphics.

== Features ==
* clean modern C++20 design including full exception safety supporting various widget allocation patterns (stack, member variable or free store);
* use of standard non-proprietary C++ data types including using standard string classes (UTF-8 encoding) and containers from the C++ standard library and Boost where possible;
* simple, easy to use multi-threaded event system (an improvement over traditional signals and slots);
* no baggage: neoGFX primarily contains only the GUI and graphics related functionality needed for creating apps and games;
* full library of widgets and layout managers specifiable in RJSON (Relaxed JSON) using the included GUI designer tool;
* CSS3 style sheet support with support for custom skins;
* scripting engine, neos, that will be able to support a wide range of scripting languages (on release: neoscript, JavaScript and Lua);
* sub-pixel text rendering;
* simple window style for specifying that a window is "nested" rather than being a separate native desktop window;
* "text_edit" widget supports multiple fonts, text colours (with optional gradient effects), colour emojis and rendering text in columns;
* "Green" and "Turbo" modes to optimize CPU power consumption, fight #ClimateChange!
* GPU shader rendered CSS3 compliant gradients with optional gaussian smoothing;
* MVC (model-view-controller) related classes supporting robust and fast app design;
* optional MDI support utilizing "nested" windows;
* 2D, 2.5D and 3D game support: sprites, objects and physics;
* Pure ECS (Entity-component-system) usable by both games and apps;
* flexible asset management: texture images (e.g PNGs) can be stored in .zip archives which can be optionally embedded inside the program binary accessible using simple URLs;
* support for OpenGL and Vulkan.