2017-12-29 03:13:22 +03:00
// dear imgui, v1.54 WIP
2015-12-25 02:38:10 +03:00
// (internals)
2015-08-08 19:56:09 +03:00
2015-12-25 02:38:10 +03:00
// You may use this file to debug, understand or extend ImGui features but we don't provide any guarantee of forward compatibility!
2017-11-11 09:59:36 +03:00
// Set:
2015-08-08 19:56:09 +03:00
// #define IMGUI_DEFINE_MATH_OPERATORS
2017-11-11 09:59:36 +03:00
// To implement maths operators for ImVec2 (disabled by default to not collide with using IM_VEC2_CLASS_EXTRA along with your own math types+operators)
2015-08-08 19:56:09 +03:00
# pragma once
2015-08-13 09:58:39 +03:00
# ifndef IMGUI_VERSION
# error Must include imgui.h before imgui_internal.h
# endif
2015-08-08 19:56:09 +03:00
# include <stdio.h> // FILE*
2016-06-01 08:53:46 +03:00
# include <math.h> // sqrtf, fabsf, fmodf, powf, floorf, ceilf, cosf, sinf
2015-08-08 19:56:09 +03:00
2015-09-23 08:54:04 +03:00
# ifdef _MSC_VER
# pragma warning (push)
# pragma warning (disable: 4251) // class 'xxx' needs to have dll-interface to be used by clients of struct 'xxx' // when IMGUI_API is set to__declspec(dllexport)
# endif
2016-05-30 20:56:21 +03:00
# ifdef __clang__
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wunused-function" // for stb_textedit.h
# pragma clang diagnostic ignored "-Wmissing-prototypes" // for stb_textedit.h
# pragma clang diagnostic ignored "-Wold-style-cast"
# endif
2015-08-08 19:56:09 +03:00
//-----------------------------------------------------------------------------
// Forward Declarations
//-----------------------------------------------------------------------------
struct ImRect ;
struct ImGuiColMod ;
struct ImGuiStyleMod ;
struct ImGuiGroupData ;
2018-01-03 20:23:33 +03:00
struct ImGuiMenuColumns ;
2015-08-08 19:56:09 +03:00
struct ImGuiDrawContext ;
struct ImGuiTextEditState ;
struct ImGuiMouseCursorData ;
struct ImGuiPopupRef ;
struct ImGuiWindow ;
2017-11-29 09:48:51 +03:00
struct ImGuiWindowSettings ;
2015-08-08 19:56:09 +03:00
2017-10-27 19:12:58 +03:00
typedef int ImGuiLayoutType ; // enum: horizontal or vertical // enum ImGuiLayoutType_
typedef int ImGuiButtonFlags ; // flags: for ButtonEx(), ButtonBehavior() // enum ImGuiButtonFlags_
typedef int ImGuiItemFlags ; // flags: for PushItemFlag() // enum ImGuiItemFlags_
typedef int ImGuiSeparatorFlags ; // flags: for Separator() - internal // enum ImGuiSeparatorFlags_
typedef int ImGuiSliderFlags ; // flags: for SliderBehavior() // enum ImGuiSliderFlags_
2015-08-08 19:56:09 +03:00
//-------------------------------------------------------------------------
// STB libraries
//-------------------------------------------------------------------------
namespace ImGuiStb
{
# undef STB_TEXTEDIT_STRING
# undef STB_TEXTEDIT_CHARTYPE
# define STB_TEXTEDIT_STRING ImGuiTextEditState
# define STB_TEXTEDIT_CHARTYPE ImWchar
# define STB_TEXTEDIT_GETWIDTH_NEWLINE -1.0f
# include "stb_textedit.h"
} // namespace ImGuiStb
//-----------------------------------------------------------------------------
// Context
//-----------------------------------------------------------------------------
2016-11-13 04:14:45 +03:00
# ifndef GImGui
extern IMGUI_API ImGuiContext * GImGui ; // Current implicit ImGui context pointer
# endif
2015-08-08 19:56:09 +03:00
//-----------------------------------------------------------------------------
// Helpers
//-----------------------------------------------------------------------------
2017-12-29 22:21:43 +03:00
# define IM_PI 3.14159265358979323846f
2015-08-08 19:56:09 +03:00
// Helpers: UTF-8 <> wchar
2015-09-12 08:40:55 +03:00
IMGUI_API int ImTextStrToUtf8 ( char * buf , int buf_size , const ImWchar * in_text , const ImWchar * in_text_end ) ; // return output UTF-8 bytes count
IMGUI_API int ImTextCharFromUtf8 ( unsigned int * out_char , const char * in_text , const char * in_text_end ) ; // return input UTF-8 bytes count
IMGUI_API int ImTextStrFromUtf8 ( ImWchar * buf , int buf_size , const char * in_text , const char * in_text_end , const char * * in_remaining = NULL ) ; // return input UTF-8 bytes count
IMGUI_API int ImTextCountCharsFromUtf8 ( const char * in_text , const char * in_text_end ) ; // return number of UTF-8 code-points (NOT bytes count)
IMGUI_API int ImTextCountUtf8BytesFromStr ( const ImWchar * in_text , const ImWchar * in_text_end ) ; // return number of bytes to express string as UTF-8 code-points
2015-08-08 19:56:09 +03:00
// Helpers: Misc
2015-09-12 08:40:55 +03:00
IMGUI_API ImU32 ImHash ( const void * data , int data_size , ImU32 seed = 0 ) ; // Pass data_size==0 for zero-terminated strings
2017-01-15 00:47:47 +03:00
IMGUI_API void * ImFileLoadToMemory ( const char * filename , const char * file_open_mode , int * out_file_size = NULL , int padding_bytes = 0 ) ;
2017-08-08 19:11:10 +03:00
IMGUI_API FILE * ImFileOpen ( const char * filename , const char * file_open_mode ) ;
2015-09-12 08:40:55 +03:00
static inline bool ImCharIsSpace ( int c ) { return c = = ' ' | | c = = ' \t ' | | c = = 0x3000 ; }
2017-08-08 19:11:10 +03:00
static inline bool ImIsPowerOfTwo ( int v ) { return v ! = 0 & & ( v & ( v - 1 ) ) = = 0 ; }
2015-09-12 08:40:55 +03:00
static inline int ImUpperPowerOfTwo ( int v ) { v - - ; v | = v > > 1 ; v | = v > > 2 ; v | = v > > 4 ; v | = v > > 8 ; v | = v > > 16 ; v + + ; return v ; }
2015-08-08 19:56:09 +03:00
2017-08-08 19:11:10 +03:00
// Helpers: Geometry
IMGUI_API ImVec2 ImLineClosestPoint ( const ImVec2 & a , const ImVec2 & b , const ImVec2 & p ) ;
IMGUI_API bool ImTriangleContainsPoint ( const ImVec2 & a , const ImVec2 & b , const ImVec2 & c , const ImVec2 & p ) ;
IMGUI_API ImVec2 ImTriangleClosestPoint ( const ImVec2 & a , const ImVec2 & b , const ImVec2 & c , const ImVec2 & p ) ;
IMGUI_API void ImTriangleBarycentricCoords ( const ImVec2 & a , const ImVec2 & b , const ImVec2 & c , const ImVec2 & p , float & out_u , float & out_v , float & out_w ) ;
2015-08-08 19:56:09 +03:00
// Helpers: String
2015-09-12 08:40:55 +03:00
IMGUI_API int ImStricmp ( const char * str1 , const char * str2 ) ;
2017-12-23 23:05:41 +03:00
IMGUI_API int ImStrnicmp ( const char * str1 , const char * str2 , size_t count ) ;
IMGUI_API void ImStrncpy ( char * dst , const char * src , size_t count ) ;
2015-09-12 08:40:55 +03:00
IMGUI_API char * ImStrdup ( const char * str ) ;
2017-11-28 19:13:21 +03:00
IMGUI_API char * ImStrchrRange ( const char * str_begin , const char * str_end , char c ) ;
2015-09-12 08:40:55 +03:00
IMGUI_API int ImStrlenW ( const ImWchar * str ) ;
IMGUI_API const ImWchar * ImStrbolW ( const ImWchar * buf_mid_line , const ImWchar * buf_begin ) ; // Find beginning-of-line
IMGUI_API const char * ImStristr ( const char * haystack , const char * haystack_end , const char * needle , const char * needle_end ) ;
2017-12-23 23:05:41 +03:00
IMGUI_API int ImFormatString ( char * buf , size_t buf_size , const char * fmt , . . . ) IM_FMTARGS ( 3 ) ;
IMGUI_API int ImFormatStringV ( char * buf , size_t buf_size , const char * fmt , va_list args ) IM_FMTLIST ( 3 ) ;
2015-08-08 19:56:09 +03:00
// Helpers: Math
// We are keeping those not leaking to the user by default, in the case the user has implicit cast operators between ImVec2 and its own types (when IM_VEC2_CLASS_EXTRA is defined)
# ifdef IMGUI_DEFINE_MATH_OPERATORS
static inline ImVec2 operator * ( const ImVec2 & lhs , const float rhs ) { return ImVec2 ( lhs . x * rhs , lhs . y * rhs ) ; }
static inline ImVec2 operator / ( const ImVec2 & lhs , const float rhs ) { return ImVec2 ( lhs . x / rhs , lhs . y / rhs ) ; }
static inline ImVec2 operator + ( const ImVec2 & lhs , const ImVec2 & rhs ) { return ImVec2 ( lhs . x + rhs . x , lhs . y + rhs . y ) ; }
static inline ImVec2 operator - ( const ImVec2 & lhs , const ImVec2 & rhs ) { return ImVec2 ( lhs . x - rhs . x , lhs . y - rhs . y ) ; }
static inline ImVec2 operator * ( const ImVec2 & lhs , const ImVec2 & rhs ) { return ImVec2 ( lhs . x * rhs . x , lhs . y * rhs . y ) ; }
static inline ImVec2 operator / ( const ImVec2 & lhs , const ImVec2 & rhs ) { return ImVec2 ( lhs . x / rhs . x , lhs . y / rhs . y ) ; }
static inline ImVec2 & operator + = ( ImVec2 & lhs , const ImVec2 & rhs ) { lhs . x + = rhs . x ; lhs . y + = rhs . y ; return lhs ; }
static inline ImVec2 & operator - = ( ImVec2 & lhs , const ImVec2 & rhs ) { lhs . x - = rhs . x ; lhs . y - = rhs . y ; return lhs ; }
static inline ImVec2 & operator * = ( ImVec2 & lhs , const float rhs ) { lhs . x * = rhs ; lhs . y * = rhs ; return lhs ; }
static inline ImVec2 & operator / = ( ImVec2 & lhs , const float rhs ) { lhs . x / = rhs ; lhs . y / = rhs ; return lhs ; }
2017-10-27 19:12:58 +03:00
static inline ImVec4 operator + ( const ImVec4 & lhs , const ImVec4 & rhs ) { return ImVec4 ( lhs . x + rhs . x , lhs . y + rhs . y , lhs . z + rhs . z , lhs . w + rhs . w ) ; }
2015-11-17 07:32:11 +03:00
static inline ImVec4 operator - ( const ImVec4 & lhs , const ImVec4 & rhs ) { return ImVec4 ( lhs . x - rhs . x , lhs . y - rhs . y , lhs . z - rhs . z , lhs . w - rhs . w ) ; }
2017-10-27 19:12:58 +03:00
static inline ImVec4 operator * ( const ImVec4 & lhs , const ImVec4 & rhs ) { return ImVec4 ( lhs . x * rhs . x , lhs . y * rhs . y , lhs . z * rhs . z , lhs . w * rhs . w ) ; }
2015-08-08 19:56:09 +03:00
# endif
static inline int ImMin ( int lhs , int rhs ) { return lhs < rhs ? lhs : rhs ; }
static inline int ImMax ( int lhs , int rhs ) { return lhs > = rhs ? lhs : rhs ; }
static inline float ImMin ( float lhs , float rhs ) { return lhs < rhs ? lhs : rhs ; }
static inline float ImMax ( float lhs , float rhs ) { return lhs > = rhs ? lhs : rhs ; }
static inline ImVec2 ImMin ( const ImVec2 & lhs , const ImVec2 & rhs ) { return ImVec2 ( ImMin ( lhs . x , rhs . x ) , ImMin ( lhs . y , rhs . y ) ) ; }
static inline ImVec2 ImMax ( const ImVec2 & lhs , const ImVec2 & rhs ) { return ImVec2 ( ImMax ( lhs . x , rhs . x ) , ImMax ( lhs . y , rhs . y ) ) ; }
static inline int ImClamp ( int v , int mn , int mx ) { return ( v < mn ) ? mn : ( v > mx ) ? mx : v ; }
static inline float ImClamp ( float v , float mn , float mx ) { return ( v < mn ) ? mn : ( v > mx ) ? mx : v ; }
static inline ImVec2 ImClamp ( const ImVec2 & f , const ImVec2 & mn , ImVec2 mx ) { return ImVec2 ( ImClamp ( f . x , mn . x , mx . x ) , ImClamp ( f . y , mn . y , mx . y ) ) ; }
static inline float ImSaturate ( float f ) { return ( f < 0.0f ) ? 0.0f : ( f > 1.0f ) ? 1.0f : f ; }
2017-10-19 07:31:01 +03:00
static inline void ImSwap ( int & a , int & b ) { int tmp = a ; a = b ; b = tmp ; }
2017-08-30 06:01:38 +03:00
static inline void ImSwap ( float & a , float & b ) { float tmp = a ; a = b ; b = tmp ; }
2017-08-08 19:11:10 +03:00
static inline int ImLerp ( int a , int b , float t ) { return ( int ) ( a + ( b - a ) * t ) ; }
2015-08-08 19:56:09 +03:00
static inline float ImLerp ( float a , float b , float t ) { return a + ( b - a ) * t ; }
2017-08-08 19:11:10 +03:00
static inline ImVec2 ImLerp ( const ImVec2 & a , const ImVec2 & b , float t ) { return ImVec2 ( a . x + ( b . x - a . x ) * t , a . y + ( b . y - a . y ) * t ) ; }
2015-08-08 19:56:09 +03:00
static inline ImVec2 ImLerp ( const ImVec2 & a , const ImVec2 & b , const ImVec2 & t ) { return ImVec2 ( a . x + ( b . x - a . x ) * t . x , a . y + ( b . y - a . y ) * t . y ) ; }
2017-10-24 07:49:57 +03:00
static inline ImVec4 ImLerp ( const ImVec4 & a , const ImVec4 & b , float t ) { return ImVec4 ( a . x + ( b . x - a . x ) * t , a . y + ( b . y - a . y ) * t , a . z + ( b . z - a . z ) * t , a . w + ( b . w - a . w ) * t ) ; }
2015-08-08 19:56:09 +03:00
static inline float ImLengthSqr ( const ImVec2 & lhs ) { return lhs . x * lhs . x + lhs . y * lhs . y ; }
static inline float ImLengthSqr ( const ImVec4 & lhs ) { return lhs . x * lhs . x + lhs . y * lhs . y + lhs . z * lhs . z + lhs . w * lhs . w ; }
static inline float ImInvLength ( const ImVec2 & lhs , float fail_value ) { float d = lhs . x * lhs . x + lhs . y * lhs . y ; if ( d > 0.0f ) return 1.0f / sqrtf ( d ) ; return fail_value ; }
2016-05-02 02:46:36 +03:00
static inline float ImFloor ( float f ) { return ( float ) ( int ) f ; }
2017-08-08 19:11:10 +03:00
static inline ImVec2 ImFloor ( const ImVec2 & v ) { return ImVec2 ( ( float ) ( int ) v . x , ( float ) ( int ) v . y ) ; }
static inline float ImDot ( const ImVec2 & a , const ImVec2 & b ) { return a . x * b . x + a . y * b . y ; }
static inline ImVec2 ImRotate ( const ImVec2 & v , float cos_a , float sin_a ) { return ImVec2 ( v . x * cos_a - v . y * sin_a , v . x * sin_a + v . y * cos_a ) ; }
2017-10-20 08:00:45 +03:00
static inline float ImLinearSweep ( float current , float target , float speed ) { if ( current < target ) return ImMin ( current + speed , target ) ; if ( current > target ) return ImMax ( current - speed , target ) ; return current ; }
2017-11-20 19:29:10 +03:00
static inline ImVec2 ImMul ( const ImVec2 & lhs , const ImVec2 & rhs ) { return ImVec2 ( lhs . x * rhs . x , lhs . y * rhs . y ) ; }
2015-08-08 19:56:09 +03:00
2016-01-27 08:13:13 +03:00
// We call C++ constructor on own allocated memory via the placement "new(ptr) Type()" syntax.
// Defining a custom placement new() with a dummy parameter allows us to bypass including <new> which on some platforms complains when user has disabled exceptions.
2017-12-23 23:05:41 +03:00
struct ImNewPlacementDummy { } ;
inline void * operator new ( size_t , ImNewPlacementDummy , void * ptr ) { return ptr ; }
inline void operator delete ( void * , ImNewPlacementDummy , void * ) { } // This is only required so we can use the symetrical new()
2017-12-25 00:46:50 +03:00
# define IM_PLACEMENT_NEW(_PTR) new(ImNewPlacementDummy(), _PTR)
# define IM_NEW(_TYPE) new(ImNewPlacementDummy(), ImGui::MemAlloc(sizeof(_TYPE))) _TYPE
template < typename T > void IM_DELETE ( T * & p ) { if ( p ) { p - > ~ T ( ) ; ImGui : : MemFree ( p ) ; p = NULL ; } }
2016-01-27 08:13:13 +03:00
2015-08-08 19:56:09 +03:00
//-----------------------------------------------------------------------------
// Types
//-----------------------------------------------------------------------------
2017-12-14 06:13:37 +03:00
// Internal Drag and Drop payload types. String starting with '_' are reserved for Dear ImGui.
# define IMGUI_PAYLOAD_TYPE_DOCKABLE "_IMDOCK" // ImGuiWindow* // [Internal] Docking/tabs
2015-08-08 19:56:09 +03:00
enum ImGuiButtonFlags_
{
2016-03-09 01:27:49 +03:00
ImGuiButtonFlags_Repeat = 1 < < 0 , // hold to repeat
2017-09-29 07:51:20 +03:00
ImGuiButtonFlags_PressedOnClickRelease = 1 < < 1 , // return true on click + release on same item [DEFAULT if no PressedOn* flag is set]
ImGuiButtonFlags_PressedOnClick = 1 < < 2 , // return true on click (default requires click+release)
ImGuiButtonFlags_PressedOnRelease = 1 < < 3 , // return true on release (default requires click+release)
ImGuiButtonFlags_PressedOnDoubleClick = 1 < < 4 , // return true on double-click (default requires click+release)
2017-12-12 19:54:29 +03:00
ImGuiButtonFlags_FlattenChildren = 1 < < 5 , // allow interactions even if a child window is overlapping
ImGuiButtonFlags_AllowItemOverlap = 1 < < 6 , // require previous frame HoveredId to either match id or be null before being usable, use along with SetItemAllowOverlap()
ImGuiButtonFlags_DontClosePopups = 1 < < 7 , // disable automatically closing parent popup on press // [UNUSED]
ImGuiButtonFlags_Disabled = 1 < < 8 , // disable interactions
2017-12-14 06:13:37 +03:00
ImGuiButtonFlags_AlignTextBaseLine = 1 < < 9 , // vertically align button to match text baseline - ButtonEx() only // FIXME: Should be removed and handled by SmallButton(), not possible currently because of DC.CursorPosPrevLine
2017-12-12 19:54:29 +03:00
ImGuiButtonFlags_NoKeyModifiers = 1 < < 10 , // disable interaction if a key modifier is held
2017-12-14 06:13:37 +03:00
ImGuiButtonFlags_NoHoldingActiveID = 1 < < 11 , // don't set ActiveId while holding the mouse (ImGuiButtonFlags_PressedOnClick only)
ImGuiButtonFlags_PressedOnDragDropHold = 1 < < 12 // press when held into while we are drag and dropping another item (used by e.g. tree nodes, collapsing headers)
2015-08-30 03:00:23 +03:00
} ;
2015-10-31 20:48:25 +03:00
enum ImGuiSliderFlags_
{
2015-12-30 05:45:16 +03:00
ImGuiSliderFlags_Vertical = 1 < < 0
2015-10-31 20:48:25 +03:00
} ;
2017-08-20 20:25:00 +03:00
enum ImGuiColumnsFlags_
{
// Default: 0
ImGuiColumnsFlags_NoBorder = 1 < < 0 , // Disable column dividers
ImGuiColumnsFlags_NoResize = 1 < < 1 , // Disable resizing columns when clicking on the dividers
ImGuiColumnsFlags_NoPreserveWidths = 1 < < 2 , // Disable column width preservation when adjusting columns
2017-11-17 06:06:08 +03:00
ImGuiColumnsFlags_NoForceWithinWindow = 1 < < 3 , // Disable forcing columns to fit within window
2017-12-14 06:13:37 +03:00
ImGuiColumnsFlags_GrowParentContentsSize = 1 < < 4 // (WIP) Restore pre-1.51 behavior of extending the parent window contents size but _without affecting the columns width at all_. Will eventually remove.
2017-08-20 20:25:00 +03:00
} ;
2015-08-08 19:56:09 +03:00
enum ImGuiSelectableFlagsPrivate_
{
// NB: need to be in sync with last value of ImGuiSelectableFlags_
2017-12-14 06:13:37 +03:00
ImGuiSelectableFlags_Menu = 1 < < 3 , // -> PressedOnClick
ImGuiSelectableFlags_MenuItem = 1 < < 4 , // -> PressedOnRelease
2016-03-09 01:27:49 +03:00
ImGuiSelectableFlags_Disabled = 1 < < 5 ,
ImGuiSelectableFlags_DrawFillAvailWidth = 1 < < 6
2015-08-08 19:56:09 +03:00
} ;
2017-09-28 05:42:53 +03:00
enum ImGuiSeparatorFlags_
{
ImGuiSeparatorFlags_Horizontal = 1 < < 0 , // Axis default to current layout type, so generally Horizontal unless e.g. in a menu bar
ImGuiSeparatorFlags_Vertical = 1 < < 1
} ;
2015-08-08 19:56:09 +03:00
// FIXME: this is in development, not exposed/functional as a generic feature yet.
enum ImGuiLayoutType_
{
ImGuiLayoutType_Vertical ,
ImGuiLayoutType_Horizontal
} ;
2017-11-22 07:01:05 +03:00
enum ImGuiAxis
{
ImGuiAxis_None = - 1 ,
ImGuiAxis_X = 0 ,
2017-12-23 23:05:41 +03:00
ImGuiAxis_Y = 1
2017-11-22 07:01:05 +03:00
} ;
2015-08-08 19:56:09 +03:00
enum ImGuiPlotType
{
ImGuiPlotType_Lines ,
ImGuiPlotType_Histogram
} ;
enum ImGuiDataType
{
ImGuiDataType_Int ,
2016-09-26 05:41:51 +03:00
ImGuiDataType_Float ,
2017-09-18 19:21:06 +03:00
ImGuiDataType_Float2
2015-08-08 19:56:09 +03:00
} ;
2017-08-08 19:11:10 +03:00
enum ImGuiDir
{
ImGuiDir_None = - 1 ,
ImGuiDir_Left = 0 ,
ImGuiDir_Right = 1 ,
ImGuiDir_Up = 2 ,
2017-12-08 06:00:53 +03:00
ImGuiDir_Down = 3 ,
ImGuiDir_Count_
2017-08-08 19:11:10 +03:00
} ;
2015-08-08 19:56:09 +03:00
// 2D axis aligned bounding-box
// NB: we can't rely on ImVec2 math operators being available here
2015-09-12 08:40:55 +03:00
struct IMGUI_API ImRect
2015-08-08 19:56:09 +03:00
{
2015-12-04 05:33:57 +03:00
ImVec2 Min ; // Upper-left
ImVec2 Max ; // Lower-right
2015-08-08 19:56:09 +03:00
ImRect ( ) : Min ( FLT_MAX , FLT_MAX ) , Max ( - FLT_MAX , - FLT_MAX ) { }
ImRect ( const ImVec2 & min , const ImVec2 & max ) : Min ( min ) , Max ( max ) { }
ImRect ( const ImVec4 & v ) : Min ( v . x , v . y ) , Max ( v . z , v . w ) { }
ImRect ( float x1 , float y1 , float x2 , float y2 ) : Min ( x1 , y1 ) , Max ( x2 , y2 ) { }
2017-12-29 22:21:43 +03:00
ImVec2 GetCenter ( ) const { return ImVec2 ( ( Min . x + Max . x ) * 0.5f , ( Min . y + Max . y ) * 0.5f ) ; }
ImVec2 GetSize ( ) const { return ImVec2 ( Max . x - Min . x , Max . y - Min . y ) ; }
float GetWidth ( ) const { return Max . x - Min . x ; }
float GetHeight ( ) const { return Max . y - Min . y ; }
ImVec2 GetTL ( ) const { return Min ; } // Top-left
ImVec2 GetTR ( ) const { return ImVec2 ( Max . x , Min . y ) ; } // Top-right
ImVec2 GetBL ( ) const { return ImVec2 ( Min . x , Max . y ) ; } // Bottom-left
ImVec2 GetBR ( ) const { return Max ; } // Bottom-right
bool Contains ( const ImVec2 & p ) const { return p . x > = Min . x & & p . y > = Min . y & & p . x < Max . x & & p . y < Max . y ; }
bool Contains ( const ImRect & r ) const { return r . Min . x > = Min . x & & r . Min . y > = Min . y & & r . Max . x < Max . x & & r . Max . y < Max . y ; }
bool Overlaps ( const ImRect & r ) const { return r . Min . y < Max . y & & r . Max . y > Min . y & & r . Min . x < Max . x & & r . Max . x > Min . x ; }
void Add ( const ImVec2 & p ) { if ( Min . x > p . x ) Min . x = p . x ; if ( Min . y > p . y ) Min . y = p . y ; if ( Max . x < p . x ) Max . x = p . x ; if ( Max . y < p . y ) Max . y = p . y ; }
void Add ( const ImRect & r ) { if ( Min . x > r . Min . x ) Min . x = r . Min . x ; if ( Min . y > r . Min . y ) Min . y = r . Min . y ; if ( Max . x < r . Max . x ) Max . x = r . Max . x ; if ( Max . y < r . Max . y ) Max . y = r . Max . y ; }
void Expand ( const float amount ) { Min . x - = amount ; Min . y - = amount ; Max . x + = amount ; Max . y + = amount ; }
void Expand ( const ImVec2 & amount ) { Min . x - = amount . x ; Min . y - = amount . y ; Max . x + = amount . x ; Max . y + = amount . y ; }
void Translate ( const ImVec2 & v ) { Min . x + = v . x ; Min . y + = v . y ; Max . x + = v . x ; Max . y + = v . y ; }
void ClipWith ( const ImRect & r ) { if ( Min . x < r . Min . x ) Min . x = r . Min . x ; if ( Min . y < r . Min . y ) Min . y = r . Min . y ; if ( Max . x > r . Max . x ) Max . x = r . Max . x ; if ( Max . y > r . Max . y ) Max . y = r . Max . y ; }
void Floor ( ) { Min . x = ( float ) ( int ) Min . x ; Min . y = ( float ) ( int ) Min . y ; Max . x = ( float ) ( int ) Max . x ; Max . y = ( float ) ( int ) Max . y ; }
void FixInverted ( ) { if ( Min . x > Max . x ) ImSwap ( Min . x , Max . x ) ; if ( Min . y > Max . y ) ImSwap ( Min . y , Max . y ) ; }
bool IsFinite ( ) const { return Min . x ! = FLT_MAX ; }
2015-08-08 19:56:09 +03:00
} ;
// Stacked color modifier, backup of modified data so we can restore it
struct ImGuiColMod
{
2015-12-04 05:33:57 +03:00
ImGuiCol Col ;
2016-09-26 05:41:51 +03:00
ImVec4 BackupValue ;
2015-08-08 19:56:09 +03:00
} ;
2016-09-26 05:41:51 +03:00
// Stacked style modifier, backup of modified data so we can restore it. Data type inferred from the variable.
2015-08-08 19:56:09 +03:00
struct ImGuiStyleMod
{
2016-09-26 05:41:51 +03:00
ImGuiStyleVar VarIdx ;
union { int BackupInt [ 2 ] ; float BackupFloat [ 2 ] ; } ;
ImGuiStyleMod ( ImGuiStyleVar idx , int v ) { VarIdx = idx ; BackupInt [ 0 ] = v ; }
ImGuiStyleMod ( ImGuiStyleVar idx , float v ) { VarIdx = idx ; BackupFloat [ 0 ] = v ; }
ImGuiStyleMod ( ImGuiStyleVar idx , ImVec2 v ) { VarIdx = idx ; BackupFloat [ 0 ] = v . x ; BackupFloat [ 1 ] = v . y ; }
2015-08-08 19:56:09 +03:00
} ;
// Stacked data for BeginGroup()/EndGroup()
struct ImGuiGroupData
{
2015-12-04 05:33:57 +03:00
ImVec2 BackupCursorPos ;
ImVec2 BackupCursorMaxPos ;
float BackupIndentX ;
2016-09-15 08:00:42 +03:00
float BackupGroupOffsetX ;
2015-12-04 05:33:57 +03:00
float BackupCurrentLineHeight ;
float BackupCurrentLineTextBaseOffset ;
float BackupLogLinePosY ;
2016-09-26 05:41:51 +03:00
bool BackupActiveIdIsAlive ;
2015-12-04 05:33:57 +03:00
bool AdvanceCursor ;
2015-08-08 19:56:09 +03:00
} ;
2016-05-08 20:16:37 +03:00
// Simple column measurement currently used for MenuItem() only. This is very short-sighted/throw-away code and NOT a generic helper.
2018-01-03 20:23:33 +03:00
struct IMGUI_API ImGuiMenuColumns
2015-08-08 19:56:09 +03:00
{
2015-12-04 05:33:57 +03:00
int Count ;
float Spacing ;
float Width , NextWidth ;
2018-01-03 20:23:33 +03:00
float Pos [ 4 ] , NextWidths [ 4 ] ;
2015-08-08 19:56:09 +03:00
2018-01-03 20:23:33 +03:00
ImGuiMenuColumns ( ) ;
2016-05-08 20:16:37 +03:00
void Update ( int count , float spacing , bool clear ) ;
float DeclColumns ( float w0 , float w1 , float w2 ) ;
float CalcExtraSpace ( float avail_w ) ;
2015-08-08 19:56:09 +03:00
} ;
// Internal state of the currently focused/edited text input box
2015-09-12 08:40:55 +03:00
struct IMGUI_API ImGuiTextEditState
2015-08-08 19:56:09 +03:00
{
2015-10-20 04:12:08 +03:00
ImGuiID Id ; // widget id owning the text state
ImVector < ImWchar > Text ; // edit buffer, we need to persist but can't guarantee the persistence of the user-provided buffer. so we copy into own buffer.
ImVector < char > InitialText ; // backup of end-user buffer at the time of focus (in UTF-8, unaltered)
2015-08-08 19:56:09 +03:00
ImVector < char > TempTextBuffer ;
2015-10-20 04:12:08 +03:00
int CurLenA , CurLenW ; // we need to maintain our buffer length in both UTF-8 and wchar format.
int BufSizeA ; // end-user buffer size
2015-08-08 19:56:09 +03:00
float ScrollX ;
ImGuiStb : : STB_TexteditState StbState ;
float CursorAnim ;
bool CursorFollow ;
bool SelectedAllMouseLock ;
2015-10-20 04:12:08 +03:00
ImGuiTextEditState ( ) { memset ( this , 0 , sizeof ( * this ) ) ; }
void CursorAnimReset ( ) { CursorAnim = - 0.30f ; } // After a user-input the cursor stays on for a while without blinking
void CursorClamp ( ) { StbState . cursor = ImMin ( StbState . cursor , CurLenW ) ; StbState . select_start = ImMin ( StbState . select_start , CurLenW ) ; StbState . select_end = ImMin ( StbState . select_end , CurLenW ) ; }
bool HasSelection ( ) const { return StbState . select_start ! = StbState . select_end ; }
void ClearSelection ( ) { StbState . select_start = StbState . select_end = StbState . cursor ; }
void SelectAll ( ) { StbState . select_start = 0 ; StbState . select_end = CurLenW ; StbState . cursor = StbState . select_end ; StbState . has_preferred_x = false ; }
2015-08-08 19:56:09 +03:00
void OnKeyPressed ( int key ) ;
} ;
// Data saved in imgui.ini file
2017-11-29 09:48:51 +03:00
struct ImGuiWindowSettings
2015-08-08 19:56:09 +03:00
{
2015-12-04 05:33:57 +03:00
char * Name ;
2016-06-13 08:18:03 +03:00
ImGuiID Id ;
2015-12-04 05:33:57 +03:00
ImVec2 Pos ;
ImVec2 Size ;
bool Collapsed ;
2017-11-28 19:13:21 +03:00
2017-11-29 09:48:51 +03:00
ImGuiWindowSettings ( ) { Name = NULL ; Id = 0 ; Pos = Size = ImVec2 ( 0 , 0 ) ; Collapsed = false ; }
2017-11-28 19:13:21 +03:00
} ;
struct ImGuiSettingsHandler
{
const char * TypeName ; // Short description stored in .ini file. Disallowed characters: '[' ']'
ImGuiID TypeHash ; // == ImHash(TypeName, 0, 0)
2017-11-29 09:48:51 +03:00
void * ( * ReadOpenFn ) ( ImGuiContext & ctx , const char * name ) ;
2017-11-28 19:13:21 +03:00
void ( * ReadLineFn ) ( ImGuiContext & ctx , void * entry , const char * line ) ;
void ( * WriteAllFn ) ( ImGuiContext & ctx , ImGuiTextBuffer * out_buf ) ;
2015-08-08 19:56:09 +03:00
} ;
// Mouse cursor data (used when io.MouseDrawCursor is set)
struct ImGuiMouseCursorData
{
ImGuiMouseCursor Type ;
ImVec2 HotOffset ;
ImVec2 Size ;
ImVec2 TexUvMin [ 2 ] ;
ImVec2 TexUvMax [ 2 ] ;
} ;
// Storage for current popup stack
struct ImGuiPopupRef
{
2017-12-14 06:13:37 +03:00
ImGuiID PopupId ; // Set on OpenPopup()
ImGuiWindow * Window ; // Resolved on BeginPopup() - may stay unresolved if user never calls OpenPopup()
ImGuiWindow * ParentWindow ; // Set on OpenPopup()
ImGuiID ParentMenuSet ; // Set on OpenPopup()
ImVec2 MousePosOnOpen ; // Copy of mouse position at the time of opening popup
2015-08-08 19:56:09 +03:00
2016-06-13 08:18:03 +03:00
ImGuiPopupRef ( ImGuiID id , ImGuiWindow * parent_window , ImGuiID parent_menu_set , const ImVec2 & mouse_pos ) { PopupId = id ; Window = NULL ; ParentWindow = parent_window ; ParentMenuSet = parent_menu_set ; MousePosOnOpen = mouse_pos ; }
2015-08-08 19:56:09 +03:00
} ;
2017-12-14 06:13:37 +03:00
struct ImGuiColumnData
{
float OffsetNorm ; // Column start offset, normalized 0.0 (far left) -> 1.0 (far right)
float OffsetNormBeforeResize ;
2017-12-16 06:21:48 +03:00
ImGuiColumnsFlags Flags ; // Not exposed
2017-12-14 06:13:37 +03:00
ImRect ClipRect ;
2017-12-16 06:21:48 +03:00
ImGuiColumnData ( ) { OffsetNorm = OffsetNormBeforeResize = 0.0f ; Flags = 0 ; }
2017-12-14 06:13:37 +03:00
} ;
struct ImGuiColumnsSet
{
ImGuiID ID ;
ImGuiColumnsFlags Flags ;
bool IsFirstFrame ;
bool IsBeingResized ;
int Current ;
int Count ;
float MinX , MaxX ;
float StartPosY ;
float StartMaxPosX ; // Backup of CursorMaxPos
float CellMinY , CellMaxY ;
ImVector < ImGuiColumnData > Columns ;
ImGuiColumnsSet ( ) { Clear ( ) ; }
void Clear ( )
{
ID = 0 ;
Flags = 0 ;
IsFirstFrame = false ;
IsBeingResized = false ;
Current = 0 ;
Count = 1 ;
MinX = MaxX = 0.0f ;
StartPosY = 0.0f ;
StartMaxPosX = 0.0f ;
CellMinY = CellMaxY = 0.0f ;
Columns . clear ( ) ;
}
} ;
2017-12-23 23:05:41 +03:00
struct ImDrawListSharedData
{
ImVec2 TexUvWhitePixel ; // UV of white pixel in the atlas
ImFont * Font ; // Current/default font (optional, for simplified AddText overload)
float FontSize ; // Current/default font size (optional, for simplified AddText overload)
float CurveTessellationTol ;
ImVec4 ClipRectFullscreen ; // Value for PushClipRectFullscreen()
// Const data
// FIXME: Bake rounded corners fill/borders in atlas
ImVec2 CircleVtx12 [ 12 ] ;
ImDrawListSharedData ( ) ;
} ;
2018-01-03 20:23:33 +03:00
// Storage for SetNexWindow** functions
struct ImGuiNextWindowData
{
ImGuiCond PosCond ;
ImGuiCond SizeCond ;
ImGuiCond ContentSizeCond ;
ImGuiCond CollapsedCond ;
ImGuiCond SizeConstraintCond ;
ImGuiCond FocusCond ;
ImVec2 PosVal ;
ImVec2 PosPivotVal ;
ImVec2 SizeVal ;
ImVec2 ContentSizeVal ;
bool CollapsedVal ;
ImRect SizeConstraintRect ; // Valid if 'SetNextWindowSizeConstraint' is true
ImGuiSizeCallback SizeCallback ;
void * SizeCallbackUserData ;
ImGuiNextWindowData ( )
{
PosCond = SizeCond = ContentSizeCond = CollapsedCond = SizeConstraintCond = FocusCond = 0 ;
PosVal = PosPivotVal = SizeVal = ImVec2 ( 0.0f , 0.0f ) ;
ContentSizeVal = ImVec2 ( 0.0f , 0.0f ) ;
CollapsedVal = false ;
SizeConstraintRect = ImRect ( ) ;
SizeCallback = NULL ;
SizeCallbackUserData = NULL ;
}
void Clear ( )
{
PosCond = SizeCond = ContentSizeCond = CollapsedCond = SizeConstraintCond = FocusCond = 0 ;
}
} ;
2015-08-08 19:56:09 +03:00
// Main state for ImGui
2016-05-08 20:16:37 +03:00
struct ImGuiContext
2015-08-08 19:56:09 +03:00
{
bool Initialized ;
ImGuiIO IO ;
ImGuiStyle Style ;
ImFont * Font ; // (Shortcut) == FontStack.empty() ? IO.Font : FontStack.back()
2017-08-24 07:13:33 +03:00
float FontSize ; // (Shortcut) == FontBaseSize * g.CurrentWindow->FontWindowScale == window->FontSize(). Text height for current window.
float FontBaseSize ; // (Shortcut) == IO.FontGlobalScale * Font->Scale * Font->FontSize. Base text height.
2017-12-23 23:05:41 +03:00
ImDrawListSharedData DrawListSharedData ;
2015-08-08 19:56:09 +03:00
float Time ;
int FrameCount ;
2015-09-18 07:30:49 +03:00
int FrameCountEnded ;
2015-08-08 19:56:09 +03:00
int FrameCountRendered ;
ImVector < ImGuiWindow * > Windows ;
ImVector < ImGuiWindow * > WindowsSortBuffer ;
ImVector < ImGuiWindow * > CurrentWindowStack ;
2017-11-11 09:59:36 +03:00
ImGuiStorage WindowsById ;
2017-12-14 06:13:37 +03:00
int WindowsActiveCount ;
2017-08-24 07:13:33 +03:00
ImGuiWindow * CurrentWindow ; // Being drawn into
ImGuiWindow * NavWindow ; // Nav/focused window for navigation
2015-08-08 19:56:09 +03:00
ImGuiWindow * HoveredWindow ; // Will catch mouse inputs
ImGuiWindow * HoveredRootWindow ; // Will catch mouse inputs (for focus/move only)
ImGuiID HoveredId ; // Hovered widget
2015-12-04 05:33:57 +03:00
bool HoveredIdAllowOverlap ;
2015-08-08 19:56:09 +03:00
ImGuiID HoveredIdPreviousFrame ;
2017-10-31 19:25:06 +03:00
float HoveredIdTimer ;
2015-08-08 19:56:09 +03:00
ImGuiID ActiveId ; // Active widget
ImGuiID ActiveIdPreviousFrame ;
2017-10-31 19:25:06 +03:00
float ActiveIdTimer ;
2017-08-24 07:13:33 +03:00
bool ActiveIdIsAlive ; // Active widget has been seen this frame
2015-08-08 19:56:09 +03:00
bool ActiveIdIsJustActivated ; // Set at the time of activation for one frame
2017-08-24 07:13:33 +03:00
bool ActiveIdAllowOverlap ; // Active widget allows another widget to steal active id (generally for overlapping widgets, but not always)
2016-05-22 00:54:06 +03:00
ImVec2 ActiveIdClickOffset ; // Clicked offset from upper-left corner, if applicable (currently only set by ButtonBehavior)
2015-08-08 19:56:09 +03:00
ImGuiWindow * ActiveIdWindow ;
2017-10-27 19:12:58 +03:00
ImGuiWindow * MovingWindow ; // Track the child window we clicked on to move a window.
ImGuiID MovingWindowMoveId ; // == MovingWindow->MoveId
2015-08-08 19:56:09 +03:00
ImVector < ImGuiColMod > ColorModifiers ; // Stack for PushStyleColor()/PopStyleColor()
ImVector < ImGuiStyleMod > StyleModifiers ; // Stack for PushStyleVar()/PopStyleVar()
ImVector < ImFont * > FontStack ; // Stack for PushFont()/PopFont()
2016-05-04 05:29:37 +03:00
ImVector < ImGuiPopupRef > OpenPopupStack ; // Which popups are open (persistent)
2015-08-08 19:56:09 +03:00
ImVector < ImGuiPopupRef > CurrentPopupStack ; // Which level of BeginPopup() we are in (reset every frame)
2018-01-03 20:23:33 +03:00
ImGuiNextWindowData NextWindowData ; // Storage for SetNextWindow** functions
bool NextTreeNodeOpenVal ; // Storage for SetNextTreeNode** functions
ImGuiCond NextTreeNodeOpenCond ;
2015-08-08 19:56:09 +03:00
// Render
2015-09-12 08:40:55 +03:00
ImDrawData RenderDrawData ; // Main ImDrawData instance to pass render information to the user
2015-08-08 19:56:09 +03:00
ImVector < ImDrawList * > RenderDrawLists [ 3 ] ;
float ModalWindowDarkeningRatio ;
ImDrawList OverlayDrawList ; // Optional software render of mouse cursors, if io.MouseDrawCursor is set + a few debug overlays
ImGuiMouseCursor MouseCursor ;
ImGuiMouseCursorData MouseCursorData [ ImGuiMouseCursor_Count_ ] ;
2017-12-14 06:13:37 +03:00
// Drag and Drop
bool DragDropActive ;
ImGuiDragDropFlags DragDropSourceFlags ;
int DragDropMouseButton ;
ImGuiPayload DragDropPayload ;
ImRect DragDropTargetRect ;
ImGuiID DragDropTargetId ;
float DragDropAcceptIdCurrRectSurface ;
ImGuiID DragDropAcceptIdCurr ; // Target item id (set at the time of accepting the payload)
ImGuiID DragDropAcceptIdPrev ; // Target item id from previous frame (we need to store this to allow for overlapping drag and drop targets)
int DragDropAcceptFrameCount ; // Last time a target expressed a desire to accept the source
ImVector < unsigned char > DragDropPayloadBufHeap ; // We don't expose the ImVector<> directly
unsigned char DragDropPayloadBufLocal [ 8 ] ;
2015-08-08 19:56:09 +03:00
// Widget state
ImGuiTextEditState InputTextState ;
2015-11-22 06:54:18 +03:00
ImFont InputTextPasswordFont ;
2015-08-08 19:56:09 +03:00
ImGuiID ScalarAsInputTextId ; // Temporary text input when CTRL+clicking on a slider, etc.
2017-08-08 19:11:10 +03:00
ImGuiColorEditFlags ColorEditOptions ; // Store user options for color edit widgets
ImVec4 ColorPickerRef ;
2015-08-08 19:56:09 +03:00
float DragCurrentValue ; // Currently dragged value, always float, not rounded by end-user precision settings
ImVec2 DragLastMouseDelta ;
float DragSpeedDefaultRatio ; // If speed == 0.0f, uses (max-min) * DragSpeedDefaultRatio
float DragSpeedScaleSlow ;
float DragSpeedScaleFast ;
2016-05-08 20:16:37 +03:00
ImVec2 ScrollbarClickDeltaToGrabCenter ; // Distance between mouse and center of grab box, normalized in parent space. Use storage?
2017-07-21 08:41:33 +03:00
int TooltipOverrideCount ;
2017-08-24 07:13:33 +03:00
ImVector < char > PrivateClipboard ; // If no custom clipboard handler is defined
2015-12-04 05:33:57 +03:00
ImVec2 OsImePosRequest , OsImePosSet ; // Cursor position request & last passed to the OS Input Method Editor
2015-08-08 19:56:09 +03:00
2017-11-28 19:13:21 +03:00
// Settings
float SettingsDirtyTimer ; // Save .ini Settings on disk when time reaches zero
2017-11-29 09:48:51 +03:00
ImVector < ImGuiWindowSettings > SettingsWindows ; // .ini settings for ImGuiWindow
2017-11-28 19:13:21 +03:00
ImVector < ImGuiSettingsHandler > SettingsHandlers ; // List of .ini settings handlers
2015-08-08 19:56:09 +03:00
// Logging
bool LogEnabled ;
2015-08-26 06:44:36 +03:00
FILE * LogFile ; // If != NULL log to stdout/ file
2015-08-08 19:56:09 +03:00
ImGuiTextBuffer * LogClipboard ; // Else log to clipboard. This is pointer so our GImGui static constructor doesn't call heap allocators.
int LogStartDepth ;
int LogAutoExpandMaxDepth ;
// Misc
float FramerateSecPerFrame [ 120 ] ; // calculate estimate of framerate for user
int FramerateSecPerFrameIdx ;
float FramerateSecPerFrameAccum ;
2017-09-07 05:04:41 +03:00
int WantCaptureMouseNextFrame ; // explicit capture via CaptureInputs() sets those flags
int WantCaptureKeyboardNextFrame ;
int WantTextInputNextFrame ;
2015-08-08 19:56:09 +03:00
char TempBuffer [ 1024 * 3 + 1 ] ; // temporary text buffer
2017-12-23 23:05:41 +03:00
ImGuiContext ( ) : OverlayDrawList ( NULL )
2015-08-08 19:56:09 +03:00
{
Initialized = false ;
Font = NULL ;
FontSize = FontBaseSize = 0.0f ;
Time = 0.0f ;
FrameCount = 0 ;
2015-09-18 07:30:49 +03:00
FrameCountEnded = FrameCountRendered = - 1 ;
2017-12-14 06:13:37 +03:00
WindowsActiveCount = 0 ;
2015-08-08 19:56:09 +03:00
CurrentWindow = NULL ;
2017-08-24 07:13:33 +03:00
NavWindow = NULL ;
2015-08-08 19:56:09 +03:00
HoveredWindow = NULL ;
HoveredRootWindow = NULL ;
HoveredId = 0 ;
2015-12-04 05:33:57 +03:00
HoveredIdAllowOverlap = false ;
2015-08-08 19:56:09 +03:00
HoveredIdPreviousFrame = 0 ;
2017-10-31 19:25:06 +03:00
HoveredIdTimer = 0.0f ;
2015-08-08 19:56:09 +03:00
ActiveId = 0 ;
ActiveIdPreviousFrame = 0 ;
2017-10-31 19:25:06 +03:00
ActiveIdTimer = 0.0f ;
2015-08-08 19:56:09 +03:00
ActiveIdIsAlive = false ;
ActiveIdIsJustActivated = false ;
2015-12-04 05:33:57 +03:00
ActiveIdAllowOverlap = false ;
2016-05-22 00:54:06 +03:00
ActiveIdClickOffset = ImVec2 ( - 1 , - 1 ) ;
2015-08-08 19:56:09 +03:00
ActiveIdWindow = NULL ;
2017-10-27 19:12:58 +03:00
MovingWindow = NULL ;
MovingWindowMoveId = 0 ;
2015-08-08 19:56:09 +03:00
2018-01-03 20:23:33 +03:00
NextTreeNodeOpenVal = false ;
NextTreeNodeOpenCond = 0 ;
2015-08-08 19:56:09 +03:00
2017-12-14 06:13:37 +03:00
DragDropActive = false ;
DragDropSourceFlags = 0 ;
DragDropMouseButton = - 1 ;
DragDropTargetId = 0 ;
DragDropAcceptIdPrev = DragDropAcceptIdCurr = 0 ;
DragDropAcceptFrameCount = - 1 ;
memset ( DragDropPayloadBufLocal , 0 , sizeof ( DragDropPayloadBufLocal ) ) ;
2015-08-08 19:56:09 +03:00
ScalarAsInputTextId = 0 ;
2017-08-08 19:11:10 +03:00
ColorEditOptions = ImGuiColorEditFlags__OptionsDefault ;
2015-08-08 19:56:09 +03:00
DragCurrentValue = 0.0f ;
DragLastMouseDelta = ImVec2 ( 0.0f , 0.0f ) ;
2016-06-26 02:30:09 +03:00
DragSpeedDefaultRatio = 1.0f / 100.0f ;
2017-08-30 06:01:38 +03:00
DragSpeedScaleSlow = 1.0f / 100.0f ;
2015-08-08 19:56:09 +03:00
DragSpeedScaleFast = 10.0f ;
2015-09-01 23:34:54 +03:00
ScrollbarClickDeltaToGrabCenter = ImVec2 ( 0.0f , 0.0f ) ;
2017-07-21 08:41:33 +03:00
TooltipOverrideCount = 0 ;
2015-12-04 05:33:57 +03:00
OsImePosRequest = OsImePosSet = ImVec2 ( - 1.0f , - 1.0f ) ;
2015-08-08 19:56:09 +03:00
ModalWindowDarkeningRatio = 0.0f ;
2017-12-23 23:05:41 +03:00
OverlayDrawList . _Data = & DrawListSharedData ;
2015-08-08 19:56:09 +03:00
OverlayDrawList . _OwnerName = " ##Overlay " ; // Give it a name for debugging
MouseCursor = ImGuiMouseCursor_Arrow ;
2016-01-04 00:20:15 +03:00
memset ( MouseCursorData , 0 , sizeof ( MouseCursorData ) ) ;
2015-08-08 19:56:09 +03:00
2017-11-28 19:13:21 +03:00
SettingsDirtyTimer = 0.0f ;
2015-08-08 19:56:09 +03:00
LogEnabled = false ;
LogFile = NULL ;
LogClipboard = NULL ;
LogStartDepth = 0 ;
LogAutoExpandMaxDepth = 2 ;
memset ( FramerateSecPerFrame , 0 , sizeof ( FramerateSecPerFrame ) ) ;
FramerateSecPerFrameIdx = 0 ;
FramerateSecPerFrameAccum = 0.0f ;
2017-09-07 05:04:41 +03:00
WantCaptureMouseNextFrame = WantCaptureKeyboardNextFrame = WantTextInputNextFrame = - 1 ;
2016-01-04 00:20:15 +03:00
memset ( TempBuffer , 0 , sizeof ( TempBuffer ) ) ;
2015-08-08 19:56:09 +03:00
}
} ;
2017-09-07 05:04:41 +03:00
// Transient per-window flags, reset at the beginning of the frame. For child window, inherited from parent on first Begin().
enum ImGuiItemFlags_
{
ImGuiItemFlags_AllowKeyboardFocus = 1 < < 0 , // true
ImGuiItemFlags_ButtonRepeat = 1 < < 1 , // false // Button() will return true multiple times based on io.KeyRepeatDelay and io.KeyRepeatRate settings.
2017-10-26 03:57:09 +03:00
ImGuiItemFlags_Disabled = 1 < < 2 , // false // FIXME-WIP: Disable interactions but doesn't affect visuals. Should be: grey out and disable interactions with widgets that affect data + view widgets (WIP)
//ImGuiItemFlags_NoNav = 1 << 3, // false
//ImGuiItemFlags_NoNavDefaultFocus = 1 << 4, // false
ImGuiItemFlags_SelectableDontClosePopup = 1 < < 5 , // false // MenuItem/Selectable() automatically closes current Popup window
2017-09-29 07:51:20 +03:00
ImGuiItemFlags_Default_ = ImGuiItemFlags_AllowKeyboardFocus
2017-09-07 05:04:41 +03:00
} ;
2015-08-08 19:56:09 +03:00
// Transient per-window data, reset at the beginning of the frame
// FIXME: That's theory, in practice the delimitation between ImGuiWindow and ImGuiDrawContext is quite tenuous and could be reconsidered.
2015-09-23 08:54:04 +03:00
struct IMGUI_API ImGuiDrawContext
2015-08-08 19:56:09 +03:00
{
ImVec2 CursorPos ;
ImVec2 CursorPosPrevLine ;
ImVec2 CursorStartPos ;
2017-12-11 04:19:51 +03:00
ImVec2 CursorMaxPos ; // Used to implicitly calculate the size of our contents, always growing during the frame. Turned into window->SizeContents at the beginning of next frame
2015-08-08 19:56:09 +03:00
float CurrentLineHeight ;
float CurrentLineTextBaseOffset ;
float PrevLineHeight ;
float PrevLineTextBaseOffset ;
float LogLinePosY ;
int TreeDepth ;
2016-06-13 08:18:03 +03:00
ImGuiID LastItemId ;
2015-08-08 19:56:09 +03:00
ImRect LastItemRect ;
2017-09-29 07:51:20 +03:00
bool LastItemRectHoveredRect ;
2015-08-08 19:56:09 +03:00
bool MenuBarAppending ;
float MenuBarOffsetX ;
ImVector < ImGuiWindow * > ChildWindows ;
ImGuiStorage * StateStorage ;
ImGuiLayoutType LayoutType ;
// We store the current settings outside of the vectors to increase memory locality (reduce cache misses). The vectors are rarely modified. Also it allows us to not heap allocate for short-lived windows which are not using those settings.
2017-09-07 05:04:41 +03:00
ImGuiItemFlags ItemFlags ; // == ItemFlagsStack.back() [empty == ImGuiItemFlags_Default]
2015-08-08 19:56:09 +03:00
float ItemWidth ; // == ItemWidthStack.back(). 0.0: default, >0.0: width in pixels, <0.0: align xx pixels to the right of window
float TextWrapPos ; // == TextWrapPosStack.back() [empty == -1.0f]
2017-09-07 05:04:41 +03:00
ImVector < ImGuiItemFlags > ItemFlagsStack ;
2015-08-08 19:56:09 +03:00
ImVector < float > ItemWidthStack ;
ImVector < float > TextWrapPosStack ;
ImVector < ImGuiGroupData > GroupStack ;
int StackSizesBackup [ 6 ] ; // Store size of various stacks for asserting
2015-11-29 04:58:18 +03:00
float IndentX ; // Indentation / start position from left of window (increased by TreePush/TreePop, etc.)
2016-07-31 07:39:51 +03:00
float GroupOffsetX ;
2015-08-08 19:56:09 +03:00
float ColumnsOffsetX ; // Offset to the current column (if ColumnsCurrent > 0). FIXME: This and the above should be a stack to allow use cases like Tree->Column->Tree. Need revamp columns API.
2017-12-14 06:13:37 +03:00
ImGuiColumnsSet * ColumnsSet ; // Current columns set
2015-08-08 19:56:09 +03:00
ImGuiDrawContext ( )
{
CursorPos = CursorPosPrevLine = CursorStartPos = CursorMaxPos = ImVec2 ( 0.0f , 0.0f ) ;
CurrentLineHeight = PrevLineHeight = 0.0f ;
CurrentLineTextBaseOffset = PrevLineTextBaseOffset = 0.0f ;
LogLinePosY = - 1.0f ;
TreeDepth = 0 ;
2016-06-13 08:18:03 +03:00
LastItemId = 0 ;
2017-09-29 07:51:20 +03:00
LastItemRect = ImRect ( ) ;
LastItemRectHoveredRect = false ;
2015-08-08 19:56:09 +03:00
MenuBarAppending = false ;
MenuBarOffsetX = 0.0f ;
StateStorage = NULL ;
LayoutType = ImGuiLayoutType_Vertical ;
ItemWidth = 0.0f ;
2017-09-07 05:04:41 +03:00
ItemFlags = ImGuiItemFlags_Default_ ;
2015-08-08 19:56:09 +03:00
TextWrapPos = - 1.0f ;
memset ( StackSizesBackup , 0 , sizeof ( StackSizesBackup ) ) ;
2015-11-29 04:58:18 +03:00
IndentX = 0.0f ;
2016-11-13 04:14:45 +03:00
GroupOffsetX = 0.0f ;
2015-08-08 19:56:09 +03:00
ColumnsOffsetX = 0.0f ;
2017-12-14 06:13:37 +03:00
ColumnsSet = NULL ;
2015-08-08 19:56:09 +03:00
}
} ;
// Windows data
2015-09-12 08:40:55 +03:00
struct IMGUI_API ImGuiWindow
2015-08-08 19:56:09 +03:00
{
char * Name ;
2016-04-20 01:47:14 +03:00
ImGuiID ID ; // == ImHash(Name)
ImGuiWindowFlags Flags ; // See enum ImGuiWindowFlags_
2015-08-08 19:56:09 +03:00
ImVec2 PosFloat ;
ImVec2 Pos ; // Position rounded-up to nearest pixel
ImVec2 Size ; // Current size (==SizeFull or collapsed title bar size)
ImVec2 SizeFull ; // Size when non collapsed
2017-12-07 06:31:03 +03:00
ImVec2 SizeFullAtLastBegin ; // Copy of SizeFull at the end of Begin. This is the reference value we'll use on the next frame to decide if we need scrollbars.
2017-12-11 04:19:51 +03:00
ImVec2 SizeContents ; // Size of contents (== extents reach of the drawing cursor) from previous frame. Include decoration, window title, border, menu, etc.
2015-09-01 23:34:54 +03:00
ImVec2 SizeContentsExplicit ; // Size of contents explicitly set by the user via SetNextWindowContentSize()
2016-05-29 19:17:23 +03:00
ImRect ContentsRegionRect ; // Maximum visible content position in window coordinates. ~~ (SizeContentsExplicit ? SizeContentsExplicit : Size - ScrollbarSizes) - CursorStartPos, per axis
2017-11-20 19:29:10 +03:00
ImVec2 WindowPadding ; // Window padding at the time of begin.
float WindowRounding ; // Window rounding at the time of begin.
float WindowBorderSize ; // Window border size at the time of begin.
2016-06-13 08:18:03 +03:00
ImGuiID MoveId ; // == window->GetID("#MOVE")
2015-09-01 23:34:54 +03:00
ImVec2 Scroll ;
ImVec2 ScrollTarget ; // target scroll position. stored as cursor position with scrolling canceled out, so the highest point is always 0.0f. (FLT_MAX for no change)
ImVec2 ScrollTargetCenterRatio ; // 0.0f = scroll so that target position is at top, 0.5f = scroll so that target position is centered
bool ScrollbarX , ScrollbarY ;
2016-01-25 02:22:22 +03:00
ImVec2 ScrollbarSizes ;
2015-08-08 19:56:09 +03:00
bool Active ; // Set to true on Begin()
bool WasActive ;
2017-11-20 19:29:10 +03:00
bool WriteAccessed ; // Set to true when any widget access the current window
2015-08-08 19:56:09 +03:00
bool Collapsed ; // Set when collapsing window to become only title-bar
2017-09-02 05:05:25 +03:00
bool SkipItems ; // Set when items can safely be all clipped (e.g. window not visible or collapsed)
bool Appearing ; // Set during the frame where the window is appearing (or re-appearing)
2017-11-17 06:06:08 +03:00
bool CloseButton ; // Set when the window has a close button (p_open != NULL)
2017-12-14 06:13:37 +03:00
int BeginOrderWithinParent ; // Order within immediate parent window, if we are a child window. Otherwise 0.
int BeginOrderWithinContext ; // Order within entire imgui context. This is mostly used for debugging submission order related issues.
2015-08-08 19:56:09 +03:00
int BeginCount ; // Number of Begin() during the current frame (generally 0 or 1, 1+ if appending via multiple Begin/End pairs)
2016-06-13 08:18:03 +03:00
ImGuiID PopupId ; // ID in the popup stack when this window is used as a popup/menu (because we use generic Name/ID for recycling)
2015-08-08 19:56:09 +03:00
int AutoFitFramesX , AutoFitFramesY ;
bool AutoFitOnlyGrows ;
2017-08-24 07:13:33 +03:00
int AutoFitChildAxises ;
2017-12-08 06:00:53 +03:00
ImGuiDir AutoPosLastDirection ;
2015-08-08 19:56:09 +03:00
int HiddenFrames ;
2017-08-13 04:22:03 +03:00
ImGuiCond SetWindowPosAllowFlags ; // store condition flags for next SetWindowPos() call.
ImGuiCond SetWindowSizeAllowFlags ; // store condition flags for next SetWindowSize() call.
ImGuiCond SetWindowCollapsedAllowFlags ; // store condition flags for next SetWindowCollapsed() call.
2017-09-26 06:59:25 +03:00
ImVec2 SetWindowPosVal ; // store window position when using a non-zero Pivot (position set needs to be processed when we know the window size)
ImVec2 SetWindowPosPivot ; // store window pivot for positioning. ImVec2(0,0) when positioning from top-left corner; ImVec2(0.5f,0.5f) for centering; ImVec2(1,1) for bottom right.
2015-08-08 19:56:09 +03:00
ImGuiDrawContext DC ; // Temporary per-window data, reset at the beginning of the frame
ImVector < ImGuiID > IDStack ; // ID stack. ID are hashes seeded with the value at the top of the stack
ImRect ClipRect ; // = DrawList->clip_rect_stack.back(). Scissoring / clipping rectangle. x1, y1, x2, y2.
2016-05-07 10:37:02 +03:00
ImRect WindowRectClipped ; // = WindowRect just after setup in Begin(). == window->Rect() for root window.
2017-10-27 19:12:58 +03:00
ImRect InnerRect ;
2015-10-20 04:12:08 +03:00
int LastFrameActive ;
2015-08-08 19:56:09 +03:00
float ItemWidthDefault ;
2018-01-03 20:23:33 +03:00
ImGuiMenuColumns MenuColumns ; // Simplified columns storage for menu items
2015-08-08 19:56:09 +03:00
ImGuiStorage StateStorage ;
2017-12-14 06:13:37 +03:00
ImVector < ImGuiColumnsSet > ColumnsStorage ;
2015-08-08 19:56:09 +03:00
float FontWindowScale ; // Scale multiplier per-window
ImDrawList * DrawList ;
2017-12-14 06:13:37 +03:00
ImGuiWindow * ParentWindow ; // If we are a child _or_ popup window, this is pointing to our parent. Otherwise NULL.
2017-08-30 06:01:38 +03:00
ImGuiWindow * RootWindow ; // Generally point to ourself. If we are a child window, this is pointing to the first non-child parent window.
ImGuiWindow * RootNonPopupWindow ; // Generally point to ourself. Used to display TitleBgActive color and for selecting which window to use for NavWindowing
2016-06-26 02:30:09 +03:00
// Navigation / Focus
2015-08-08 19:56:09 +03:00
int FocusIdxAllCounter ; // Start at -1 and increase as assigned via FocusItemRegister()
int FocusIdxTabCounter ; // (same, but only count widgets which you can Tab through)
int FocusIdxAllRequestCurrent ; // Item being requested for focus
int FocusIdxTabRequestCurrent ; // Tab-able item being requested for focus
int FocusIdxAllRequestNext ; // Item being requested for focus, for next update (relies on layout to be stable between the frame pressing TAB and the next frame)
int FocusIdxTabRequestNext ; // "
public :
2017-12-23 23:05:41 +03:00
ImGuiWindow ( ImGuiContext * context , const char * name ) ;
2015-08-08 19:56:09 +03:00
~ ImGuiWindow ( ) ;
ImGuiID GetID ( const char * str , const char * str_end = NULL ) ;
ImGuiID GetID ( const void * ptr ) ;
2016-07-13 08:28:49 +03:00
ImGuiID GetIDNoKeepAlive ( const char * str , const char * str_end = NULL ) ;
2017-12-14 06:13:37 +03:00
ImGuiID GetIDFromRectangle ( const ImRect & r_abs ) ;
2015-08-08 19:56:09 +03:00
2017-11-22 21:20:18 +03:00
// We don't use g.FontSize because the window may be != g.CurrentWidow.
2015-08-08 19:56:09 +03:00
ImRect Rect ( ) const { return ImRect ( Pos . x , Pos . y , Pos . x + Size . x , Pos . y + Size . y ) ; }
float CalcFontSize ( ) const { return GImGui - > FontBaseSize * FontWindowScale ; }
float TitleBarHeight ( ) const { return ( Flags & ImGuiWindowFlags_NoTitleBar ) ? 0.0f : CalcFontSize ( ) + GImGui - > Style . FramePadding . y * 2.0f ; }
ImRect TitleBarRect ( ) const { return ImRect ( Pos , ImVec2 ( Pos . x + SizeFull . x , Pos . y + TitleBarHeight ( ) ) ) ; }
float MenuBarHeight ( ) const { return ( Flags & ImGuiWindowFlags_MenuBar ) ? CalcFontSize ( ) + GImGui - > Style . FramePadding . y * 2.0f : 0.0f ; }
ImRect MenuBarRect ( ) const { float y1 = Pos . y + TitleBarHeight ( ) ; return ImRect ( Pos . x , y1 , Pos . x + SizeFull . x , y1 + MenuBarHeight ( ) ) ; }
} ;
2017-10-19 07:31:01 +03:00
// Backup and restore just enough data to be able to use IsItemHovered() on item A after another B in the same window has overwritten the data.
struct ImGuiItemHoveredDataBackup
{
ImGuiID LastItemId ;
ImRect LastItemRect ;
bool LastItemRectHoveredRect ;
2017-12-14 06:13:37 +03:00
ImGuiItemHoveredDataBackup ( ) { Backup ( ) ; }
void Backup ( ) { ImGuiWindow * window = GImGui - > CurrentWindow ; LastItemId = window - > DC . LastItemId ; LastItemRect = window - > DC . LastItemRect ; LastItemRectHoveredRect = window - > DC . LastItemRectHoveredRect ; }
void Restore ( ) const { ImGuiWindow * window = GImGui - > CurrentWindow ; window - > DC . LastItemId = LastItemId ; window - > DC . LastItemRect = LastItemRect ; window - > DC . LastItemRectHoveredRect = LastItemRectHoveredRect ; }
2017-10-19 07:31:01 +03:00
} ;
2015-08-08 19:56:09 +03:00
//-----------------------------------------------------------------------------
// Internal API
// No guarantee of forward compatibility here.
//-----------------------------------------------------------------------------
namespace ImGui
{
2015-09-18 07:30:49 +03:00
// We should always have a CurrentWindow in the stack (there is an implicit "Debug" window)
// If this ever crash because g.CurrentWindow is NULL it means that either
// - ImGui::NewFrame() has never been called, which is illegal.
// - You are calling ImGui functions after ImGui::Render() and before the next ImGui::NewFrame(), which is also illegal.
2016-05-08 20:16:37 +03:00
inline ImGuiWindow * GetCurrentWindowRead ( ) { ImGuiContext & g = * GImGui ; return g . CurrentWindow ; }
2017-11-20 19:29:10 +03:00
inline ImGuiWindow * GetCurrentWindow ( ) { ImGuiContext & g = * GImGui ; g . CurrentWindow - > WriteAccessed = true ; return g . CurrentWindow ; }
2016-02-20 20:30:25 +03:00
IMGUI_API ImGuiWindow * FindWindowByName ( const char * name ) ;
2015-08-08 19:56:09 +03:00
IMGUI_API void FocusWindow ( ImGuiWindow * window ) ;
2017-11-17 06:06:08 +03:00
IMGUI_API void BringWindowToFront ( ImGuiWindow * window ) ;
IMGUI_API void BringWindowToBack ( ImGuiWindow * window ) ;
2017-12-12 19:54:29 +03:00
IMGUI_API bool IsWindowChildOf ( ImGuiWindow * window , ImGuiWindow * potential_parent ) ;
2015-08-08 19:56:09 +03:00
2017-08-27 00:50:38 +03:00
IMGUI_API void Initialize ( ) ;
2016-04-04 02:40:03 +03:00
2017-11-29 09:48:51 +03:00
IMGUI_API void MarkIniSettingsDirty ( ) ;
IMGUI_API ImGuiSettingsHandler * FindSettingsHandler ( ImGuiID type_id ) ;
IMGUI_API ImGuiWindowSettings * FindWindowSettings ( ImGuiID id ) ;
2017-11-28 19:13:21 +03:00
2015-08-08 19:56:09 +03:00
IMGUI_API void SetActiveID ( ImGuiID id , ImGuiWindow * window ) ;
2017-08-20 20:25:00 +03:00
IMGUI_API void ClearActiveID ( ) ;
2015-10-07 08:11:30 +03:00
IMGUI_API void SetHoveredID ( ImGuiID id ) ;
2015-08-08 19:56:09 +03:00
IMGUI_API void KeepAliveID ( ImGuiID id ) ;
IMGUI_API void ItemSize ( const ImVec2 & size , float text_offset_y = 0.0f ) ;
IMGUI_API void ItemSize ( const ImRect & bb , float text_offset_y = 0.0f ) ;
2017-10-07 08:05:53 +03:00
IMGUI_API bool ItemAdd ( const ImRect & bb , ImGuiID id ) ;
2017-09-28 05:42:53 +03:00
IMGUI_API bool ItemHoverable ( const ImRect & bb , ImGuiID id ) ;
2017-10-07 08:05:53 +03:00
IMGUI_API bool IsClippedEx ( const ImRect & bb , ImGuiID id , bool clip_even_when_logged ) ;
2017-08-30 06:01:38 +03:00
IMGUI_API bool FocusableItemRegister ( ImGuiWindow * window , ImGuiID id , bool tab_stop = true ) ; // Return true if focus is requested
2015-08-08 19:56:09 +03:00
IMGUI_API void FocusableItemUnregister ( ImGuiWindow * window ) ;
IMGUI_API ImVec2 CalcItemSize ( ImVec2 size , float default_x , float default_y ) ;
IMGUI_API float CalcWrapWidthForPos ( const ImVec2 & pos , float wrap_pos_x ) ;
2017-09-26 06:59:25 +03:00
IMGUI_API void PushMultiItemsWidths ( int components , float width_full = 0.0f ) ;
2017-09-07 05:04:41 +03:00
IMGUI_API void PushItemFlag ( ImGuiItemFlags option , bool enabled ) ;
IMGUI_API void PopItemFlag ( ) ;
2015-08-08 19:56:09 +03:00
2017-08-18 08:04:22 +03:00
IMGUI_API void OpenPopupEx ( ImGuiID id , bool reopen_existing ) ;
2017-09-26 06:59:25 +03:00
IMGUI_API void ClosePopup ( ImGuiID id ) ;
2017-08-18 08:04:22 +03:00
IMGUI_API bool IsPopupOpen ( ImGuiID id ) ;
2017-09-26 06:59:25 +03:00
IMGUI_API bool BeginPopupEx ( ImGuiID id , ImGuiWindowFlags extra_flags ) ;
2017-10-27 19:12:58 +03:00
IMGUI_API void BeginTooltipEx ( ImGuiWindowFlags extra_flags , bool override_previous_tooltip = true ) ;
2015-12-25 02:38:10 +03:00
2017-08-30 06:01:38 +03:00
IMGUI_API int CalcTypematicPressedRepeatAmount ( float t , float t_prev , float repeat_delay , float repeat_rate ) ;
2017-10-14 21:04:45 +03:00
IMGUI_API void Scrollbar ( ImGuiLayoutType direction ) ;
2017-09-29 07:51:20 +03:00
IMGUI_API void VerticalSeparator ( ) ; // Vertical separator, for menu bars (use current line height). not exposed because it is misleading what it doesn't have an effect on regular layout.
2017-11-22 07:01:05 +03:00
IMGUI_API bool SplitterBehavior ( ImGuiID id , const ImRect & bb , ImGuiAxis axis , float * size1 , float * size2 , float min_size1 , float min_size2 , float hover_extend = 0.0f ) ;
2017-09-29 07:51:20 +03:00
2017-12-14 06:13:37 +03:00
IMGUI_API bool BeginDragDropTargetCustom ( const ImRect & bb , ImGuiID id ) ;
IMGUI_API void ClearDragDrop ( ) ;
IMGUI_API bool IsDragDropPayloadBeingAccepted ( ) ;
2017-09-02 05:05:25 +03:00
// FIXME-WIP: New Columns API
2017-12-14 06:13:37 +03:00
IMGUI_API void BeginColumns ( const char * str_id , int count , ImGuiColumnsFlags flags = 0 ) ; // setup number of columns. use an identifier to distinguish multiple column sets. close with EndColumns().
IMGUI_API void EndColumns ( ) ; // close columns
2017-08-20 20:25:00 +03:00
IMGUI_API void PushColumnClipRect ( int column_index = - 1 ) ;
2017-08-08 19:11:10 +03:00
// NB: All position are in absolute pixels coordinates (never using window coordinates internally)
// AVOID USING OUTSIDE OF IMGUI.CPP! NOT FOR PUBLIC CONSUMPTION. THOSE FUNCTIONS ARE A MESS. THEIR SIGNATURE AND BEHAVIOR WILL CHANGE, THEY NEED TO BE REFACTORED INTO SOMETHING DECENT.
2015-08-08 19:56:09 +03:00
IMGUI_API void RenderText ( ImVec2 pos , const char * text , const char * text_end = NULL , bool hide_text_after_hash = true ) ;
IMGUI_API void RenderTextWrapped ( ImVec2 pos , const char * text , const char * text_end , float wrap_width ) ;
2016-09-26 05:41:51 +03:00
IMGUI_API void RenderTextClipped ( const ImVec2 & pos_min , const ImVec2 & pos_max , const char * text , const char * text_end , const ImVec2 * text_size_if_known , const ImVec2 & align = ImVec2 ( 0 , 0 ) , const ImRect * clip_rect = NULL ) ;
2015-08-08 19:56:09 +03:00
IMGUI_API void RenderFrame ( ImVec2 p_min , ImVec2 p_max , ImU32 fill_col , bool border = true , float rounding = 0.0f ) ;
2017-08-08 19:11:10 +03:00
IMGUI_API void RenderFrameBorder ( ImVec2 p_min , ImVec2 p_max , float rounding = 0.0f ) ;
IMGUI_API void RenderColorRectWithAlphaCheckerboard ( ImVec2 p_min , ImVec2 p_max , ImU32 fill_col , float grid_step , ImVec2 grid_off , float rounding = 0.0f , int rounding_corners_flags = ~ 0 ) ;
2017-10-19 07:31:01 +03:00
IMGUI_API void RenderTriangle ( ImVec2 pos , ImGuiDir dir , float scale = 1.0f ) ;
2016-05-02 02:46:36 +03:00
IMGUI_API void RenderBullet ( ImVec2 pos ) ;
2017-10-19 07:31:01 +03:00
IMGUI_API void RenderCheckMark ( ImVec2 pos , ImU32 col , float sz ) ;
2017-08-30 06:01:38 +03:00
IMGUI_API void RenderRectFilledRangeH ( ImDrawList * draw_list , const ImRect & rect , ImU32 col , float x_start_norm , float x_end_norm , float rounding ) ;
2016-03-22 00:42:21 +03:00
IMGUI_API const char * FindRenderedTextEnd ( const char * text , const char * text_end = NULL ) ; // Find the optional ## from which we stop displaying text.
2015-08-08 19:56:09 +03:00
2015-10-31 20:48:25 +03:00
IMGUI_API bool ButtonBehavior ( const ImRect & bb , ImGuiID id , bool * out_hovered , bool * out_held , ImGuiButtonFlags flags = 0 ) ;
2015-08-08 19:56:09 +03:00
IMGUI_API bool ButtonEx ( const char * label , const ImVec2 & size_arg = ImVec2 ( 0 , 0 ) , ImGuiButtonFlags flags = 0 ) ;
2016-04-21 17:46:03 +03:00
IMGUI_API bool CloseButton ( ImGuiID id , const ImVec2 & pos , float radius ) ;
2017-11-14 07:42:10 +03:00
IMGUI_API bool ArrowButton ( ImGuiID id , ImGuiDir dir , ImVec2 padding , ImGuiButtonFlags flags = 0 ) ;
2015-08-08 19:56:09 +03:00
2015-10-31 20:48:25 +03:00
IMGUI_API bool SliderBehavior ( const ImRect & frame_bb , ImGuiID id , float * v , float v_min , float v_max , float power , int decimal_precision , ImGuiSliderFlags flags = 0 ) ;
2015-08-08 19:56:09 +03:00
IMGUI_API bool SliderFloatN ( const char * label , float * v , int components , float v_min , float v_max , const char * display_format , float power ) ;
IMGUI_API bool SliderIntN ( const char * label , int * v , int components , int v_min , int v_max , const char * display_format ) ;
IMGUI_API bool DragBehavior ( const ImRect & frame_bb , ImGuiID id , float * v , float v_speed , float v_min , float v_max , int decimal_precision , float power ) ;
IMGUI_API bool DragFloatN ( const char * label , float * v , int components , float v_speed , float v_min , float v_max , const char * display_format , float power ) ;
IMGUI_API bool DragIntN ( const char * label , int * v , int components , float v_speed , int v_min , int v_max , const char * display_format ) ;
IMGUI_API bool InputTextEx ( const char * label , char * buf , int buf_size , const ImVec2 & size_arg , ImGuiInputTextFlags flags , ImGuiTextEditCallback callback = NULL , void * user_data = NULL ) ;
IMGUI_API bool InputFloatN ( const char * label , float * v , int components , int decimal_precision , ImGuiInputTextFlags extra_flags ) ;
IMGUI_API bool InputIntN ( const char * label , int * v , int components , ImGuiInputTextFlags extra_flags ) ;
IMGUI_API bool InputScalarEx ( const char * label , ImGuiDataType data_type , void * data_ptr , void * step_ptr , void * step_fast_ptr , const char * scalar_format , ImGuiInputTextFlags extra_flags ) ;
IMGUI_API bool InputScalarAsWidgetReplacement ( const ImRect & aabb , const char * label , ImGuiDataType data_type , void * data_ptr , ImGuiID id , int decimal_precision ) ;
2017-09-28 05:42:53 +03:00
IMGUI_API void ColorTooltip ( const char * text , const float * col , ImGuiColorEditFlags flags ) ;
IMGUI_API void ColorEditOptionsPopup ( const float * col , ImGuiColorEditFlags flags ) ;
2017-08-08 19:11:10 +03:00
2016-05-02 02:46:36 +03:00
IMGUI_API bool TreeNodeBehavior ( ImGuiID id , ImGuiTreeNodeFlags flags , const char * label , const char * label_end = NULL ) ;
2016-05-04 05:29:37 +03:00
IMGUI_API bool TreeNodeBehaviorIsOpen ( ImGuiID id , ImGuiTreeNodeFlags flags = 0 ) ; // Consume previous SetNextTreeNodeOpened() data, if any. May return true when logging
2016-05-02 02:46:36 +03:00
IMGUI_API void TreePushRawID ( ImGuiID id ) ;
2015-08-30 03:00:23 +03:00
2015-08-08 19:56:09 +03:00
IMGUI_API void PlotEx ( ImGuiPlotType plot_type , const char * label , float ( * values_getter ) ( void * data , int idx ) , void * data , int values_count , int values_offset , const char * overlay_text , float scale_min , float scale_max , ImVec2 graph_size ) ;
IMGUI_API int ParseFormatPrecision ( const char * fmt , int default_value ) ;
IMGUI_API float RoundScalar ( float value , int decimal_precision ) ;
2017-10-20 08:00:45 +03:00
// Shade functions
IMGUI_API void ShadeVertsLinearColorGradientKeepAlpha ( ImDrawVert * vert_start , ImDrawVert * vert_end , ImVec2 gradient_p0 , ImVec2 gradient_p1 , ImU32 col0 , ImU32 col1 ) ;
IMGUI_API void ShadeVertsLinearAlphaGradientForLeftToRightText ( ImDrawVert * vert_start , ImDrawVert * vert_end , float gradient_p0_x , float gradient_p1_x ) ;
2017-11-20 19:29:10 +03:00
IMGUI_API void ShadeVertsLinearUV ( ImDrawVert * vert_start , ImDrawVert * vert_end , const ImVec2 & a , const ImVec2 & b , const ImVec2 & uv_a , const ImVec2 & uv_b , bool clamp ) ;
2017-10-20 08:00:45 +03:00
2016-05-30 20:56:21 +03:00
} // namespace ImGui
2017-08-18 08:04:22 +03:00
// ImFontAtlas internals
IMGUI_API bool ImFontAtlasBuildWithStbTruetype ( ImFontAtlas * atlas ) ;
IMGUI_API void ImFontAtlasBuildRegisterDefaultCustomRects ( ImFontAtlas * atlas ) ;
IMGUI_API void ImFontAtlasBuildSetupFont ( ImFontAtlas * atlas , ImFont * font , ImFontConfig * font_config , float ascent , float descent ) ;
IMGUI_API void ImFontAtlasBuildPackCustomRects ( ImFontAtlas * atlas , void * spc ) ;
2017-09-28 05:42:53 +03:00
IMGUI_API void ImFontAtlasBuildFinish ( ImFontAtlas * atlas ) ;
2017-08-27 00:50:38 +03:00
IMGUI_API void ImFontAtlasBuildMultiplyCalcLookupTable ( unsigned char out_table [ 256 ] , float in_multiply_factor ) ;
IMGUI_API void ImFontAtlasBuildMultiplyRectAlpha8 ( const unsigned char table [ 256 ] , unsigned char * pixels , int x , int y , int w , int h , int stride ) ;
2017-08-18 08:04:22 +03:00
2016-05-30 20:56:21 +03:00
# ifdef __clang__
# pragma clang diagnostic pop
# endif
2015-08-08 19:56:09 +03:00
2015-09-23 08:54:04 +03:00
# ifdef _MSC_VER
# pragma warning (pop)
# endif