MAME SVN History

199869 Revisions

r36358 Tuesday 10th March, 2015 at 07:05:28 UTC by Miodrag Milanović
update 3rdparty libs

[3rdparty/bgfx]	README.md
[3rdparty/bgfx/3rdparty/ib-compress]	writebitstream.h
[3rdparty/bgfx/3rdparty/ocornut-imgui]	imconfig.h imgui.cpp imgui.h
[3rdparty/bgfx/examples/common/entry]	entry.cpp entry.h entry_android.cpp entry_asmjs.cpp entry_ios.mm entry_nacl.cpp entry_osx.mm entry_p.h entry_qnx.cpp entry_sdl.cpp entry_windows.cpp entry_winrt.cpp entry_x11.cpp
[3rdparty/bgfx/examples/common/imgui]	ocornut_imgui.cpp
[3rdparty/bgfx/scripts]	bgfx.lua
[3rdparty/bx/include/bx]	handlealloc.h
[3rdparty/genie]	README.md
[3rdparty/genie/src/actions/make]	make_cpp.lua
[3rdparty/genie/src/host]	premake.c scripts.c
[3rdparty/mongoose]	mongoose.c
[3rdparty/mongoose/docs]	API.md
[3rdparty/mongoose/examples/multi_threaded_server]	Makefile
[3rdparty/mongoose/examples/proxy_server]	Makefile
[3rdparty/mongoose/examples/web_server]	Makefile web_server.c
[3rdparty/mongoose/examples/web_server/certs]	cert.pem*
[3rdparty/mongoose/examples/websocket_ssl_proxy]	Makefile

trunk/3rdparty/bgfx/3rdparty/ib-compress/writebitstream.h
r244869	r244870
34	34	#define WBS_INLINE __forceinline
35	35	#else
36	36	#define WBS_INLINE inline
37		#endif
	37	#endif
38	38
39		// Very simple bitstream for writing that will grow to accomodate written bits.
	39	// Very simple bitstream for writing that will grow to accomodate written bits.
40	40	class WriteBitstream
41	41	{
42	42	public:
43	43
44		// Construct the bit stream with an initial buffer capacity - should be a multiple of 8 and > 0
	44	// Construct the bit stream with an initial buffer capacity - should be a multiple of 8 and > 0
45	45	WriteBitstream( size_t initialBufferCapacity = 16 )
46	46	{
47	47	m_bufferCursor =
r244869	r244870
66	66	// Write a V int to the stream.
67	67	void WriteVInt( uint32_t value );
68	68
69		// Get the size in bytes
	69	// Get the size in bytes
70	70	size_t ByteSize() const { return ( m_size + 7 ) >> 3; }
71	71
72	72	// Finish writing by flushing the buffer.
r244869	r244870
80	80	// If we need to grow the buffer.
81	81	void GrowBuffer();
82	82
83		// Not copyable
	83	// Not copyable
84	84	WriteBitstream( const WriteBitstream& );
85	85
86	86	// Not assignable
r244869	r244870
96	96
97	97	WBS_INLINE void WriteBitstream::Write( uint32_t value, uint32_t bitCount )
98	98	{
99		m_bitBuffer \|= ( static_cast<uint64_t>( value ) << ( 64 - m_bitsLeft ) ) & ( m_bitsLeft == 0 ? 0 : 0xFFFFFFFFFFFFFFFF );
	99	m_bitBuffer \|= ( static_cast<uint64_t>( value ) << ( 64 - m_bitsLeft ) ) & ( m_bitsLeft == 0 ? 0 : UINT64_C(0xFFFFFFFFFFFFFFFF) );
100	100
101	101	if ( bitCount > m_bitsLeft )
102	102	{
r244869	r244870
175	175	m_bufferEnd = m_buffer + newBufferSize;
176	176	}
177	177
178		#endif // -- WRITE_BIT_STREAM_H__
		No newline at end of file
	178	#endif // -- WRITE_BIT_STREAM_H__

trunk/3rdparty/bgfx/3rdparty/ocornut-imgui/imconfig.h
r244869	r244870
14	14	//---- Define assertion handler. Defaults to calling assert().
15	15	//#define IM_ASSERT(_EXPR) MyAssert(_EXPR)
16	16
17		//---- Don't implement default clipboard handlers for Windows (so as not to link with OpenClipboard() and others Win32 functions)
	17	//---- Define attributes of all API symbols declarations, e.g. for DLL under Windows.
	18	//#define IMGUI_API __declspec( dllexport )
	19	//#define IMGUI_API __declspec( dllimport )
	20
	21	//---- Don't implement default handlers for Windows (so as not to link with OpenClipboard() and others Win32 functions)
18	22	//#define IMGUI_DISABLE_WIN32_DEFAULT_CLIPBOARD_FUNCS
	23	//#define IMGUI_DISABLE_WIN32_DEFAULT_IME_FUNCS
19	24
20	25	//---- Include imgui_user.inl at the end of imgui.cpp so you can include code that extends ImGui using its private data/functions.
21	26	//#define IMGUI_INCLUDE_IMGUI_USER_INL
r244869	r244870
36	41
37	42	//---- Freely implement extra functions within the ImGui:: namespace.
38	43	//---- Declare helpers or widgets implemented in imgui_user.inl or elsewhere, so end-user doesn't need to include multiple files.
39		//---- e.g. you can create variants of the ImGui::Value() helper for your low-level math types.
	44	//---- e.g. you can create variants of the ImGui::Value() helper for your low-level math types, or your own widgets/helpers.
40	45	/*
41	46	namespace ImGui
42	47	{

trunk/3rdparty/bgfx/3rdparty/ocornut-imgui/imgui.cpp
r244869	r244870
1		// ImGui library v1.3~~2 wip~~
	1	// ImGui library v1.35
2	2	// See ImGui::ShowTestWindow() for sample code.
3	3	// Read 'Programmer guide' below for notes on how to setup ImGui in your codebase.
4	4	// Get latest version at https://github.com/ocornut/imgui
r244869	r244870
9	9	Index
10	10	- MISSION STATEMENT
11	11	- END-USER GUIDE
12		- PROGRAMMER GUIDE
13		- API BREAKING CHANGES
14		- TROUBLESHOOTING & FREQUENTLY ASKED QUESTIONS
	12	- PROGRAMMER GUIDE (read me!)
	13	- API BREAKING CHANGES (read me when you update!)
	14	- FREQUENTLY ASKED QUESTIONS (FAQ) & TROUBLESHOOTING (read me!)
15	15	- ISSUES & TODO-LIST
16	16	- CODE
17	17	- SAMPLE CODE
r244869	r244870
27	27	- minimize screen real-estate usage
28	28	- minimize setup and maintenance
29	29	- minimize state storage on user side
30		- portable, minimize dependencies, run on target (consoles, etc.)
	30	- portable, minimize dependencies, run on target (consoles, phones, etc.)
31	31	- efficient runtime (NB- we do allocate when "growing" content - creating a window / opening a tree node for the first time, etc. - but a typical frame won't allocate anything)
32		- read about immediate-mode ~~GUI~~ principles @ http://mollyrocket.com/861, http://mollyrocket.com/forums/index.html
	32	- read about immediate-mode gui principles @ http://mollyrocket.com/861, http://mollyrocket.com/forums/index.html
33	33
34	34	Designed for developers and content-creators, not the typical end-user! Some of the weaknesses includes:
35	35	- doesn't look fancy, doesn't animate
36	36	- limited layout features, intricate layouts are typically crafted in code
37		- occasionally use statically sized buffers for string manipulations - won't crash, but some long text may be clipped
	37	- occasionally uses statically sized buffers for string manipulations - won't crash, but some long text may be clipped. functions like ImGui::TextUnformatted() don't have such restriction.
38	38
39	39
40	40	END-USER GUIDE
r244869	r244870
63	63	PROGRAMMER GUIDE
64	64	================
65	65
66		- your code creates the UI, if your code doesn't run the UI is gone! == dynamic UI, no construction step, less data retention on your side, no state duplication, less sync, less errors.
67		- call and read ImGui::ShowTestWindow() for user-side sample code
	66	- read the FAQ below this section!
	67	- your code creates the UI, if your code doesn't run the UI is gone! == very dynamic UI, no construction/destructions steps, less data retention on your side, no state duplication, less sync, less bugs.
	68	- call and read ImGui::ShowTestWindow() for sample code demonstrating most features.
68	69	- see examples/ folder for standalone sample applications.
69	70	- customization: use the style editor or PushStyleColor/PushStyleVar to tweak the look of the interface (e.g. if you want a more compact UI or a different color scheme).
70	71
71
72	72	- getting started:
73	73	- initialisation: call ImGui::GetIO() and fill the 'Settings' data.
74	74	- every frame:
r244869	r244870
96	96	// TODO: store your texture pointer/identifier in 'io.Fonts->TexID'
97	97
98	98	// Application main loop
99		~~for~~ (;;)
	99	while (true)
100	100	{
101	101	// 1) get low-level input
102	102	// e.g. on Win32, GetKeyboardState(), or poll your events, etc.
r244869	r244870
129	129	Occasionally introducing changes that are breaking the API. The breakage are generally minor and easy to fix.
130	130	Here is a change-log of API breaking changes, if you are using one of the functions listed, expect to have to fix some code.
131	131
	132	- 2015/03/08 (1.35) - renamed style.ScrollBarWidth to style.ScrollbarWidth
	133	- 2015/02/27 (1.34) - renamed OpenNextNode(bool) to SetNextTreeNodeOpened(bool, ImGuiSetCond), kept inline redirection function.
	134	- 2015/02/27 (1.34) - renamed ImGuiSetCondition_* to ImGuiSetCond_*, and _FirstUseThisSession becomes _Once.
	135	- 2015/02/11 (1.32) - changed text input callback ImGuiTextEditCallback return type from void-->int. reserved for future use, return 0 for now.
132	136	- 2015/02/10 (1.32) - renamed GetItemWidth() to CalcItemWidth() to clarify its evolving behavior
133	137	- 2015/02/08 (1.31) - renamed GetTextLineSpacing() to GetTextLineHeightWithSpacing()
134	138	- 2015/02/01 (1.31) - removed IO.MemReallocFn (unused)
r244869	r244870
164	168	- 2014/08/28 (1.09) - changed the behavior of IO.PixelCenterOffset following various rendering fixes
165	169
166	170
167		TROUBLESHOOTING & FREQUENTLY ASKED QUESTIONS
168		============================================
	171	FREQUENTLY ASKED QUESTIONS (FAQ) & TROUBLESHOOTING
	172	==================================================
169	173
170	174	If text or lines are blurry when integrating ImGui in your engine:
	175
171	176	- in your Render function, try translating your projection matrix by (0.5f,0.5f) or (0.375f,0.375f)
172	177
173		If you are confused about the meaning or use of ID in ImGui:
174		- many widgets requires state to be carried over multiple frames (most typically ImGui often wants remember what is the "active" widget).
175		to do so they need an unique ID. unique ID are typically derived from a string label, an indice or a pointer.
176		when you call Button("OK") the button shows "OK" and also use "OK" as an ID.
	178	A primer on the meaning and use of ID in ImGui:
	179
	180	- widgets require state to be carried over multiple frames (most typically ImGui often needs to remember what is the "active" widget).
	181	to do so they need an unique ID. unique ID are typically derived from a string label, an integer index or a pointer.
	182
	183	Button("OK"); // Label = "OK", ID = hash of "OK"
	184	Button("Cancel"); // Label = "Cancel", ID = hash of "Cancel"
	185
177	186	- ID are uniquely scoped within Windows so no conflict can happen if you have two buttons called "OK" in two different Windows.
178		within a same Window, use PushID() / PopID() to easily create scopes and avoid ID conflicts.
179		so if you have a loop creating "multiple" items, you can use PushID() / PopID() with the index of each item, or their pointer, etc.
180		some functions like TreeNode() implicitly creates a scope for you by calling PushID()
181		- when dealing with trees, ID are important because you want to preserve the opened/closed state of tree nodes.
182		depending on your use cases you may want to use strings, indices or pointers as ID. experiment and see what makes more sense!
183		e.g. When displaying a single object that may change over time, using a static string as ID will preserve your node open/closed state when the targeted object change
184		e.g. When displaying a list of objects, using indices or pointers as ID will preserve the node open/closed state per object
185		- when passing a label you can optionally specify extra unique ID information within the same string using "##". This helps solving the simpler collision cases.
186		e.g. "Label" display "Label" and uses "Label" as ID
187		e.g. "Label##Foobar" display "Label" and uses "Label##Foobar" as ID
188		e.g. "##Foobar" display an empty label and uses "##Foobar" as ID
189		- read articles about immediate-mode ui principles (see web links) to understand the requirement and use of ID.
190	187
	188	- when passing a label you can optionally specify extra unique ID information within string itself. This helps solving the simpler collision cases.
	189	use "##" to pass a complement to the ID that won't be visible to the end-user:
	190
	191	Button("Play##0"); // Label = "Play", ID = hash of "Play##0"
	192	Button("Play##1"); // Label = "Play", ID = hash of "Play##1" (different from above)
	193
	194	use "###" to pass a label that isn't part of ID. You can use that to change labels while preserving a constant ID.
	195
	196	Button("Hello###ID"; // Label = "Hello", ID = hash of "ID"
	197	Button("World###ID"; // Label = "World", ID = hash of "ID" (same as above)
	198
	199	- use PushID() / PopID() to create scopes and avoid ID conflicts within the same Window:
	200
	201	Button("Click"); // Label = "Click", ID = hash of "Click"
	202	PushID("node");
	203	Button("Click"); // Label = "Click", ID = hash of "node" and "Click"
	204	for (int i = 0; i < 100; i++)
	205	{
	206	PushID(i);
	207	Button("Click"); // Label = "Click", ID = hash of "node" and i and "label"
	208	PopID();
	209	}
	210	PopID();
	211	PushID(my_ptr);
	212	Button("Click"); // Label = "Click", ID = hash of ptr and "Click"
	213	PopID();
	214
	215	so if you have a loop creating multiple items, you can use PushID() / PopID() with the index of each item, or their pointer, etc.
	216	some functions like TreeNode() implicitly creates a scope for you by calling PushID().
	217
	218	- when working with trees, ID are used to preserve the opened/closed state of tree nodes.
	219	depending on your use cases you may want to use strings, indices or pointers as ID.
	220	e.g. when displaying a single object that may change over time (1-1 relationship), using a static string as ID will preserve your node open/closed state when the targeted object change.
	221	e.g. when displaying a list of objects, using indices or pointers as ID will preserve the node open/closed state differently. experiment and see what makes more sense!
	222
191	223	If you want to load a different font than the default (ProggyClean.ttf, size 13)
192	224
193	225	io.Fonts->AddFontFromFileTTF("myfontfile.ttf", size_in_pixels);
r244869	r244870
204	236
205	237	io.Fonts->AddFontFromFileTTF("myfontfile.ttf", size_in_pixels, io.Fonts->GetGlyphRangesJapanese()); // Load Japanese characters
206	238	io.Fonts->GetTexDataAsRGBA32() or GetTexDataAsAlpha8()
	239	io.ImeWindowHandle = MY_HWND; // To input using Microsoft IME, give ImGui the hwnd of your application
207	240
208		If you want to input Japanese/Chinese/Korean in the text input widget:
209
210		- when loading the font, pass a range that contains the characters you need, e.g.: io.Fonts->GetGlyphRangesJapanese()
211		- to have the Microsoft IME cursor appears at the right location in the screen, setup a handler for the io.ImeSetInputScreenPosFn function:
212
213		#include <Windows.h>
214		#include <Imm.h>
215		static void ImImpl_ImeSetInputScreenPosFn(int x, int y)
216		{
217		// Notify OS Input Method Editor of text input position
218		HWND hwnd = glfwGetWin32Window(window);
219		if (HIMC himc = ImmGetContext(hwnd))
220		{
221		COMPOSITIONFORM cf;
222		cf.ptCurrentPos.x = x;
223		cf.ptCurrentPos.y = y;
224		cf.dwStyle = CFS_FORCE_POSITION;
225		ImmSetCompositionWindow(himc, &cf);
226		}
227		}
228
229		// Set pointer to handler in ImGuiIO structure
230		io.ImeSetInputScreenPosFn = ImImpl_ImeSetInputScreenPosFn;
231
232	241	- tip: the construct 'IMGUI_ONCE_UPON_A_FRAME { ... }' will run the block of code only once a frame. You can use it to quickly add custom UI in the middle of a deep nested inner loop in your code.
233	242	- tip: you can create widgets without a Begin()/End() block, they will go in an implicit window called "Debug"
234	243	- tip: you can call Begin() multiple times with the same name during the same frame, it will keep appending to the same window.
r244869	r244870
254	263	- main: IsItemHovered() returns true even if mouse is active on another widget (e.g. dragging outside of sliders). Maybe not a sensible default? Add parameter or alternate function?
255	264	- main: IsItemHovered() make it more consistent for various type of widgets, widgets with multiple components, etc. also effectively IsHovered() region sometimes differs from hot region, e.g tree nodes
256	265	- main: IsItemHovered() info stored in a stack? so that 'if TreeNode() { Text; TreePop; } if IsHovered' return the hover state of the TreeNode?
257		- scrollbar: use relative mouse movement when first-clicking inside of scroll grab box.
258		- scrollbar: make the grab visible and a minimum size for long scroll regions
259	266	!- input number: very large int not reliably supported because of int<>float conversions.
260	267	- input number: optional range min/max for Input*() functions
261	268	- input number: holding [-]/[+] buttons could increase the step speed non-linearly (or user-controlled)
r244869	r244870
268	275	- columns: declare column set (each column: fixed size, %, fill, distribute default size among fills)
269	276	- columns: columns header to act as button (~sort op) and allow resize/reorder
270	277	- columns: user specify columns size
	278	- columns: tree node example, removing the last NextColumn() makes a padding difference (it should not)
271	279	- combo: turn child handling code into pop up helper
272	280	- combo: contents should extends to fit label if combo widget is small
273	281	- listbox: multiple selection
r244869	r244870
281	289	- plot: add a helper e.g. Plot(char* label, float value, float time_span=2.0f) that stores values and Plot them for you - probably another function name. and/or automatically allow to plot ANY displayed value (more reliance on stable ID)
282	290	- file selection widget -> build the tool in our codebase to improve model-dialog idioms
283	291	- slider: allow using the [-]/[+] buttons used by InputFloat()/InputInt()
284		- slider: initial absolute click is imprecise. change to relative movement slider? hide mouse cursor, allow more precise input using less screen-space.
285		- text edit: clean up the mess caused by converting UTF-8 <> wchar. the code is rather ineficient right now.
	292	- slider: initial absolute click is imprecise. change to relative movement slider? hide mouse cursor, allow more precise input using less screen-space. same as scrollbar.
	293	- text edit: clean up the mess caused by converting UTF-8 <> wchar. the code is rather inefficient right now.
286	294	- text edit: centered text for slider as input text so it matches typical positioning.
287	295	- text edit: flag to disable live update of the user buffer.
288	296	- text edit: field resize behavior - field could stretch when being edited? hover tooltip shows more text?
r244869	r244870
293	301	! style: store rounded corners in texture to use 1 quad per corner (filled and wireframe). so rounding have minor cost.
294	302	- style: checkbox: padding for "active" color should be a multiplier of the
295	303	- style: colorbox not always square?
	304	- text: simple markup language for color change?
296	305	- log: LogButtons() options for specifying depth and/or hiding depth slider
297	306	- log: have more control over the log scope (e.g. stop logging when leaving current tree node scope)
298	307	- log: be able to right-click and log a window or tree-node into tty/file/clipboard / generalized context menu?
r244869	r244870
340	349	#pragma clang diagnostic ignored "-Wformat-nonliteral" // warning : format string is not a string literal // passing non-literal to vsnformat(). yes, user passing incorrect format strings can crash the code.
341	350	#pragma clang diagnostic ignored "-Wexit-time-destructors" // warning : declaration requires an exit-time destructor // exit-time destruction order is undefined. if MemFree() leads to users code that has been disabled before exit it might cause problems. ImGui coding style welcomes static/globals.
342	351	#pragma clang diagnostic ignored "-Wglobal-constructors" // warning : declaration requires a global destructor // similar to above, not sure what the exact difference it.
343		#pragma clang diagnostic ignored "-Wsign-conversion" // warning : implicit conversion chanjges signedness //
344		#elif defined(__GNUC__)
345		#pragma GCC diagnostic ignored "-Wtype-limits"
346		#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
347		#pragma GCC diagnostic ignored "-Wunused-function"
	352	#pragma clang diagnostic ignored "-Wsign-conversion" // warning : implicit conversion changes signedness //
348	353	#endif
	354	#ifdef __GNUC__
	355	#pragma GCC diagnostic ignored "-Wunused-function" // warning: 'xxxx' defined but not used
	356	#endif
349	357
350	358	//-------------------------------------------------------------------------
351	359	// STB libraries implementation
r244869	r244870
384	392	#endif
385	393	#include "stb_truetype.h"
386	394
387		#define STB_TEXTEDIT_STRING ImGuiTextEditState
388		#define STB_TEXTEDIT_CHARTYPE ImWchar
	395	#define STB_TEXTEDIT_STRING ImGuiTextEditState
	396	#define STB_TEXTEDIT_CHARTYPE ImWchar
389	397	#include "stb_textedit.h"
390	398
391	399	#ifdef __clang__
r244869	r244870
401	409	// Forward Declarations
402	410	//-------------------------------------------------------------------------
403	411
	412	struct ImGuiColMod;
	413	struct ImGuiStyleMod;
404	414	struct ImGuiAabb;
	415	struct ImGuiDrawContext;
	416	struct ImGuiTextEditState;
	417	struct ImGuiIniData;
	418	struct ImGuiState;
	419	struct ImGuiWindow;
405	420
406	421	static bool ButtonBehaviour(const ImGuiAabb& bb, const ImGuiID& id, bool* out_hovered, bool* out_held, bool allow_key_modifiers, bool repeat = false, bool pressed_on_click = false);
407	422	static void LogText(const ImVec2& ref_pos, const char* text, const char* text_end = NULL);
r244869	r244870
413	428	static void RenderCollapseTriangle(ImVec2 p_min, bool opened, float scale = 1.0f, bool shadow = false);
414	429
415	430	static void SetFont(ImFont* font);
416		static bool ItemAdd(const ImGuiAabb& aabb, const ImGuiID* id);
	431	static bool ItemAdd(const ImGuiAabb& bb, const ImGuiID* id);
417	432	static void ItemSize(ImVec2 size, ImVec2* adjust_start_offset = NULL);
418		static void ItemSize(const ImGuiAabb& aabb, ImVec2* adjust_start_offset = NULL);
	433	static void ItemSize(const ImGuiAabb& bb, ImVec2* adjust_start_offset = NULL);
419	434	static void PushColumnClipRect(int column_index = -1);
420		static bool IsClipped(const ImGuiAabb& aabb);
	435	static bool IsClipped(const ImGuiAabb& bb);
421	436
422		static bool IsMouseHoveringBox(const ImGuiAabb& box);
	437	static bool IsMouseHoveringBox(const ImGuiAabb& bb);
423	438	static bool IsKeyPressedMap(ImGuiKey key, bool repeat = true);
424	439
	440	static void Scrollbar(ImGuiWindow* window);
425	441	static bool CloseWindowButton(bool* p_opened = NULL);
426	442	static void FocusWindow(ImGuiWindow* window);
427	443	static ImGuiWindow* FindHoveredWindow(ImVec2 pos, bool excluding_childs);
r244869	r244870
436	452	static size_t ImFormatStringV(char* buf, size_t buf_size, const char* fmt, va_list args);
437	453
438	454	// Helpers: Misc
439		static ImU32 Im~~Crc32~~(const void* data, size_t data_size, ImU32 seed);
	455	static ImU32 ImHash(const void* data, size_t data_size, ImU32 seed);
440	456	static bool ImLoadFileToMemory(const char* filename, const char* file_open_mode, void** out_file_data, size_t* out_file_size, size_t padding_bytes = 0);
441		static int ImUpperPowerOfTwo(int v) { v--; v \|= v >> 1; v \|= v >> 2; v \|= v >> 4; v \|= v >> 8; v \|= v >> 16; v++; return v; }
	457	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; }
	458	static inline bool ImCharIsSpace(int c) { return c == ' ' \|\| c == '\t' \|\| c == 0x3000; }
442	459
443	460	// Helpers: UTF-8 <> wchar
444	461	static int ImTextCharToUtf8(char* buf, size_t buf_size, unsigned int in_char); // return output UTF-8 bytes count
445	462	static ptrdiff_t ImTextStrToUtf8(char* buf, size_t buf_size, const ImWchar* in_text, const ImWchar* in_text_end); // return output UTF-8 bytes count
446	463	static int ImTextCharFromUtf8(unsigned int* out_char, const char* in_text, const char* in_text_end); // return input UTF-8 bytes count
447		static ptrdiff_t ImTextStrFromUtf8(ImWchar* buf, size_t buf_size, const char* in_text, const char* in_text_end); // return input UTF-8 bytes count
	464	static ptrdiff_t ImTextStrFromUtf8(ImWchar* buf, size_t buf_size, const char* in_text, const char* in_text_end, const char** in_remaining = NULL); // return input UTF-8 bytes count
448	465	static int ImTextCountCharsFromUtf8(const char* in_text, const char* in_text_end); // return number of UTF-8 code-points (NOT bytes count)
449		static int ImTextCountUtf8BytesFrom~~Wcha~~r(const ImWchar* in_text, const ImWchar* in_text_end); // return number of bytes to express string as UTF-8 code-points
	466	static int ImTextCountUtf8BytesFromStr(const ImWchar* in_text, const ImWchar* in_text_end); // return number of bytes to express string as UTF-8 code-points
450	467
451	468	//-----------------------------------------------------------------------------
452	469	// Platform dependent default implementations
r244869	r244870
454	471
455	472	static const char* GetClipboardTextFn_DefaultImpl();
456	473	static void SetClipboardTextFn_DefaultImpl(const char* text);
	474	static void ImeSetInputScreenPosFn_DefaultImpl(int x, int y);
457	475
458	476	//-----------------------------------------------------------------------------
459	477	// Texture Atlas data
r244869	r244870
486	504	WindowFillAlphaDefault = 0.70f; // Default alpha of window background, if not specified in ImGui::Begin()
487	505	TreeNodeSpacing = 22.0f; // Horizontal spacing when entering a tree node
488	506	ColumnsMinSpacing = 6.0f; // Minimum horizontal spacing between two columns
489		ScrollBarWidth = 16.0f; // Width of the vertical scroll bar
	507	ScrollbarWidth = 16.0f; // Width of the vertical scrollbar
	508	GrabMinSize = 10.0f; // Minimum width/height of a slider or scrollbar grab
490	509
491	510	Colors[ImGuiCol_Text] = ImVec4(0.90f, 0.90f, 0.90f, 1.00f);
492	511	Colors[ImGuiCol_WindowBg] = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);
r244869	r244870
529	548	Colors[ImGuiCol_TooltipBg] = ImVec4(0.05f, 0.05f, 0.10f, 0.90f);
530	549	}
531	550
532		// Statically allocated font atlas. This is merely a maneuver to keep its definition at the bottom of the .H file.
533		// Because we cannot new() at this point (before users may define IO.MemAllocFn)
	551	// Statically allocated font atlas. This is merely a maneuver to keep ImFontAtlas definition at the bottom of the .h file (otherwise it'd be inside ImGuiIO)
	552	// Also we wouldn't be able to new() one at this point, before users may define IO.MemAllocFn.
534	553	static ImFontAtlas GDefaultFontAtlas;
535	554
536	555	ImGuiIO::ImGuiIO()
r244869	r244870
557	576	MemFreeFn = free;
558	577	GetClipboardTextFn = GetClipboardTextFn_DefaultImpl; // Platform dependent default implementations
559	578	SetClipboardTextFn = SetClipboardTextFn_DefaultImpl;
560		ImeSetInputScreenPosFn = ~~NULL~~;
	579	ImeSetInputScreenPosFn = ImeSetInputScreenPosFn_DefaultImpl;
561	580	}
562	581
563	582	// Pass in translated ASCII characters for text input.
564	583	// - with glfw you can get those from the callback set in glfwSetCharCallback()
565		// - on Windows you can get those using ToAscii+keyboard state, or via the VM_CHAR message
	584	// - on Windows you can get those using ToAscii+keyboard state, or via the WM_CHAR message
566	585	void ImGuiIO::AddInputCharacter(ImWchar c)
567	586	{
568	587	const size_t n = ImStrlenW(InputCharacters);
r244869	r244870
588	607	#define IM_INT_MAX 2147483647
589	608	#endif
590	609
591		// Play it nice with Windows users. Notepad in 2014 still doesn't display text data with Unix-style \n.
	610	// Play it nice with Windows users. Notepad in 2015 still doesn't display text data with Unix-style \n.
592	611	#ifdef _MSC_VER
593	612	#define STR_NEWLINE "\r\n"
594	613	#else
r244869	r244870
647	666	static size_t ImStrlenW(const ImWchar* str)
648	667	{
649	668	size_t n = 0;
650		while (*str++)
651		n++;
	669	while (*str++) n++;
652	670	return n;
653	671	}
654	672
r244869	r244870
675	693	}
676	694
677	695	// Pass data_size==0 for zero-terminated string
678		static ImU32 ImCrc32(const void* data, size_t data_size, ImU32 seed = 0)
	696	// Try to replace with FNV1a hash?
	697	static ImU32 ImHash(const void* data, size_t data_size, ImU32 seed = 0)
679	698	{
680	699	static ImU32 crc32_lut[256] = { 0 };
681	700	if (!crc32_lut[1])
r244869	r244870
689	708	crc32_lut[i] = crc;
690	709	}
691	710	}
692		ImU32 crc = ~seed;
	711
	712	seed = ~seed;
	713	ImU32 crc = seed;
693	714	const unsigned char* current = (const unsigned char*)data;
694	715
695	716	if (data_size > 0)
r244869	r244870
702	723	{
703	724	// Zero-terminated string
704	725	while (unsigned char c = *current++)
	726	{
	727	// We support a syntax of "label###id" where only "###id" is included in the hash, and only "label" gets displayed.
	728	// Because this syntax is rarely used we are optimizing for the common case.
	729	// - If we reach ### in the string we discard the hash so far and reset to the seed.
	730	// - We don't do 'current += 2; continue;' after handling ### to keep the code smaller.
	731	if (c == '#' && current[0] == '#' && current[1] == '#')
	732	crc = seed;
	733
705	734	crc = (crc >> 8) ^ crc32_lut[(crc & 0xFF) ^ c];
	735	}
706	736	}
707	737	return ~crc;
708	738	}
r244869	r244870
841	871	ImVec2 PreviousValue;
842	872	};
843	873
844		struct ImGuiAabb // 2D axis aligned bounding-box
	874	struct ImGuiAabb // 2D axis aligned bounding-box
845	875	{
846	876	ImVec2 Min;
847	877	ImVec2 Max;
r244869	r244870
887	917	ImVector<float> TextWrapPos;
888	918	ImGuiColorEditMode ColorEditMode;
889	919	ImGuiStorage* StateStorage;
890		int OpenNextNode; // FIXME: Reformulate this feature like SetNextWindowCollapsed() API
891	920
892	921	float ColumnsStartX; // Start position from left of window (increased by TreePush/TreePop, etc.)
893	922	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.
r244869	r244870
898	927	float ColumnsCellMaxY;
899	928	bool ColumnsShowBorders;
900	929	ImGuiID ColumnsSetID;
	930	ImVector<float> ColumnsOffsetsT; // Columns offset normalized 0.0 (far left) -> 1.0 (far right)
901	931
902	932	ImGuiDrawContext()
903	933	{
r244869	r244870
909	939	LastItemAabb = ImGuiAabb(0.0f,0.0f,0.0f,0.0f);
910	940	LastItemHovered = false;
911	941	StateStorage = NULL;
912		OpenNextNode = -1;
913	942
914	943	ColumnsStartX = 0.0f;
915	944	ColumnsOffsetX = 0.0f;
r244869	r244870
925	954	// Internal state of the currently focused/edited text input box
926	955	struct ImGuiTextEditState
927	956	{
	957	ImGuiID Id; // widget id owning the text state
928	958	ImWchar Text[1024]; // edit buffer, we need to persist but can't guarantee the persistence of the user-provided buffer. so we copy into own buffer.
929		char InitialText[1024*3+1]; // backup of end-user buffer at the time of focus (in UTF-8, unconverted)
930		size_t BufSize; // end-user buffer size, <= 1024 (or increase above)
	959	char InitialText[1024*4+1]; // backup of end-user buffer at the time of focus (in UTF-8, unaltered)
	960	int CurLenA, CurLenW; // we need to maintain our buffer length in both UTF-8 and wchar format.
	961	size_t BufSizeA; // end-user buffer size, <= 1024 (or increase above)
931	962	float Width; // widget width
932	963	float ScrollX;
933	964	STB_TexteditState StbState;
934	965	float CursorAnim;
935		ImVec2 ~~Las~~tCursorPos; // Cursor position in screen space to be used by IME callback.
	966	ImVec2 InputCursorScreenPos; // Cursor position in screen space to be used by IME callback.
936	967	bool SelectedAllMouseLock;
937	968	ImFont* Font;
938	969	float FontSize;
r244869	r244870
954	985	static void RenderTextScrolledClipped(ImFont* font, float font_size, const char* text, ImVec2 pos_base, float width, float scroll_x);
955	986	};
956	987
	988	// Data saved in imgui.ini file
957	989	struct ImGuiIniData
958	990	{
959	991	char* Name;
	992	ImGuiID ID;
960	993	ImVec2 Pos;
961	994	ImVec2 Size;
962	995	bool Collapsed;
r244869	r244870
965	998	~ImGuiIniData() { if (Name) { ImGui::MemFree(Name); Name = NULL; } }
966	999	};
967	1000
	1001	// Main state for ImGui
968	1002	struct ImGuiState
969	1003	{
970	1004	bool Initialized;
r244869	r244870
987	1021	ImGuiID ActiveId;
988	1022	ImGuiID ActiveIdPreviousFrame;
989	1023	bool ActiveIdIsAlive;
	1024	bool ActiveIdIsFocusedOnly; // Set only by active widget. Denote focus but no active interaction.
	1025	ImGuiWindow* MovedWindow; // Track the child window we clicked on to move a window. Only valid if ActiveID is the "#MOVE" identifier of a window.
990	1026	float SettingsDirtyTimer;
991	1027	ImVector<ImGuiIniData*> Settings;
992	1028	ImVector<ImGuiColMod> ColorModifiers;
993	1029	ImVector<ImGuiStyleMod> StyleModifiers;
994	1030	ImVector<ImFont*> FontStack;
	1031
995	1032	ImVec2 SetNextWindowPosVal;
996		ImGuiSetCond~~ition~~ SetNextWindowPosCond;
	1033	ImGuiSetCond SetNextWindowPosCond;
997	1034	ImVec2 SetNextWindowSizeVal;
998		ImGuiSetCond~~ition~~ SetNextWindowSizeCond;
	1035	ImGuiSetCond SetNextWindowSizeCond;
999	1036	bool SetNextWindowCollapsedVal;
1000		ImGuiSetCondition SetNextWindowCollapsedCond;
	1037	ImGuiSetCond SetNextWindowCollapsedCond;
	1038	bool SetNextWindowFocus;
	1039	bool SetNextTreeNodeOpenedVal;
	1040	ImGuiSetCond SetNextTreeNodeOpenedCond;
1001	1041
1002	1042	// Render
1003	1043	ImVector<ImDrawList*> RenderDrawLists;
r244869	r244870
1008	1048	ImGuiID SliderAsInputTextId;
1009	1049	ImGuiStorage ColorEditModeStorage; // for user selection
1010	1050	ImGuiID ActiveComboID;
	1051	float ScrollbarClickDeltaToGrabCenter; // distance between mouse and center of grab box, normalized in parent space
1011	1052	char Tooltip[1024];
1012	1053	char* PrivateClipboard; // if no custom clipboard handler is defined
1013	1054
r244869	r244870
1018	1059	int LogStartDepth;
1019	1060	int LogAutoExpandMaxDepth;
1020	1061
	1062	// Misc
	1063	float FramerateSecPerFrame[120]; // calculate estimate of framerate for user
	1064	int FramerateSecPerFrameIdx;
	1065	float FramerateSecPerFrameAccum;
	1066
1021	1067	ImGuiState()
1022	1068	{
1023	1069	Initialized = false;
	1070	Font = NULL;
	1071	FontSize = 0.0f;
	1072	FontTexUvWhitePixel = ImVec2(0.0f, 0.0f);
	1073
1024	1074	Time = 0.0f;
1025	1075	FrameCount = 0;
1026	1076	FrameCountRendered = -1;
r244869	r244870
1028	1078	FocusedWindow = NULL;
1029	1079	HoveredWindow = NULL;
1030	1080	HoveredRootWindow = NULL;
	1081	HoveredId = 0;
	1082	ActiveId = 0;
	1083	ActiveIdPreviousFrame = 0;
1031	1084	ActiveIdIsAlive = false;
	1085	ActiveIdIsFocusedOnly = false;
	1086	MovedWindow = NULL;
1032	1087	SettingsDirtyTimer = 0.0f;
	1088
1033	1089	SetNextWindowPosVal = ImVec2(0.0f, 0.0f);
1034	1090	SetNextWindowPosCond = 0;
1035	1091	SetNextWindowSizeVal = ImVec2(0.0f, 0.0f);
1036	1092	SetNextWindowSizeCond = 0;
1037	1093	SetNextWindowCollapsedVal = false;
1038	1094	SetNextWindowCollapsedCond = 0;
	1095	SetNextWindowFocus = false;
	1096	SetNextTreeNodeOpenedVal = false;
	1097	SetNextTreeNodeOpenedCond = 0;
	1098
1039	1099	SliderAsInputTextId = 0;
1040	1100	ActiveComboID = 0;
	1101	ScrollbarClickDeltaToGrabCenter = 0.0f;
1041	1102	memset(Tooltip, 0, sizeof(Tooltip));
1042	1103	PrivateClipboard = NULL;
	1104
1043	1105	LogEnabled = false;
1044	1106	LogFile = NULL;
	1107	LogClipboard = NULL;
1045	1108	LogStartDepth = 0;
1046	1109	LogAutoExpandMaxDepth = 2;
1047		LogClipboard = NULL;
	1110
	1111	memset(FramerateSecPerFrame, 0, sizeof(FramerateSecPerFrame));
	1112	FramerateSecPerFrameIdx = 0;
	1113	FramerateSecPerFrameAccum = 0.0f;
1048	1114	}
1049	1115	};
1050	1116
r244869	r244870
1060	1126	ImVec2 Pos; // Position rounded-up to nearest pixel
1061	1127	ImVec2 Size; // Current size (==SizeFull or collapsed title bar size)
1062	1128	ImVec2 SizeFull; // Size when non collapsed
1063		ImVec2 SizeContentsFit; // Size of contents (extents reach by the drawing cursor) - may not fit within Size.
	1129	ImVec2 SizeContents; // Size of contents (== extents reach of the drawing cursor) from previous frame
	1130	ImVec2 SizeContentsCurrent; // Size of contents, currently extending
1064	1131	float ScrollY;
1065	1132	float NextScrollY;
1066	1133	bool ScrollbarY;
r244869	r244870
1070	1137	bool SkipItems; // == Visible && !Collapsed
1071	1138	int AutoFitFrames;
1072	1139	bool AutoFitOnlyGrows;
1073		int SetWindowPosAllowFlags; // bit ImGuiSetCondition_*** specify if SetWindowPos() call is allowed with this particular flag.
1074		int SetWindowSizeAllowFlags; // bit ImGuiSetCondition_*** specify if SetWindowSize() call is allowed with this particular flag.
1075		int SetWindowCollapsedAllowFlags; // bit ImGuiSetCondition_*** specify if SetWindowCollapsed() call is allowed with this particular flag.
	1140	int SetWindowPosAllowFlags; // bit ImGuiSetCond_*** specify if SetWindowPos() call is allowed with this particular flag.
	1141	int SetWindowSizeAllowFlags; // bit ImGuiSetCond_*** specify if SetWindowSize() call is allowed with this particular flag.
	1142	int SetWindowCollapsedAllowFlags; // bit ImGuiSetCond_*** specify if SetWindowCollapsed() call is allowed with this particular flag.
1076	1143
1077	1144	ImGuiDrawContext DC;
1078	1145	ImVector<ImGuiID> IDStack;
1079	1146	ImVector<ImVec4> ClipRectStack; // Scissoring / clipping rectangle. x1, y1, x2, y2.
	1147	ImGuiAabb ClippedAabb; // = ClipRectStack.front() after setup in Begin()
1080	1148	int LastFrameDrawn;
1081	1149	float ItemWidthDefault;
1082	1150	ImGuiStorage StateStorage;
r244869	r244870
1109	1177	ImVec2 CursorPos() const { return DC.CursorPos; }
1110	1178	float TitleBarHeight() const { return (Flags & ImGuiWindowFlags_NoTitleBar) ? 0 : FontSize() + GImGui->Style.FramePadding.y * 2.0f; }
1111	1179	ImGuiAabb TitleBarAabb() const { return ImGuiAabb(Pos, Pos + ImVec2(SizeFull.x, TitleBarHeight())); }
1112		ImVec2 WindowPadding() const { return ((Flags & ImGuiWindowFlags_ChildWindow) && !(Flags & ImGuiWindowFlags_ShowBorders)) ? ImVec2(1,1) : GImGui->Style.WindowPadding; }
	1180	ImVec2 WindowPadding() const { return ((Flags & ImGuiWindowFlags_ChildWindow) && !(Flags & ImGuiWindowFlags_ShowBorders)) ? ImVec2(0,0) : GImGui->Style.WindowPadding; }
1113	1181	ImU32 Color(ImGuiCol idx, float a=1.f) const { ImVec4 c = GImGui->Style.Colors[idx]; c.w = GImGui->Style.Alpha a; return ImGui::ColorConvertFloat4ToU32(c); }
1114	1182	ImU32 Color(const ImVec4& col) const { ImVec4 c = col; c.w *= GImGui->Style.Alpha; return ImGui::ColorConvertFloat4ToU32(c); }
1115	1183	};
1116	1184
1117		static ImGuiWindow* GetCurrentWindow()
	1185	static inline ImGuiWindow* GetCurrentWindow()
1118	1186	{
1119	1187	ImGuiState& g = *GImGui;
1120	1188	IM_ASSERT(g.CurrentWindow != NULL); // ImGui::NewFrame() hasn't been called yet?
r244869	r244870
1122	1190	return g.CurrentWindow;
1123	1191	}
1124	1192
	1193	static inline ImGuiWindow* GetParentWindow()
	1194	{
	1195	ImGuiState& g = *GImGui;
	1196	IM_ASSERT(g.CurrentWindowStack.size() >= 2);
	1197	return g.CurrentWindowStack[g.CurrentWindowStack.size() - 2];
	1198	}
	1199
1125	1200	static void SetActiveId(ImGuiID id)
1126	1201	{
1127	1202	ImGuiState& g = *GImGui;
1128	1203	g.ActiveId = id;
	1204	g.ActiveIdIsFocusedOnly = false;
1129	1205	}
1130	1206
1131	1207	static void RegisterAliveId(const ImGuiID& id)
r244869	r244870
1251	1327	//-----------------------------------------------------------------------------
1252	1328
1253	1329	// Helper: Parse and apply text filters. In format "aaaaa[,bbbb][,ccccc]"
1254		ImGuiTextFilter::ImGuiTextFilter()
	1330	ImGuiTextFilter::ImGuiTextFilter(const char* default_filter)
1255	1331	{
1256		InputBuf[0] = 0;
1257		CountGrep = 0;
	1332	if (default_filter)
	1333	{
	1334	ImFormatString(InputBuf, IM_ARRAYSIZE(InputBuf), "%s", default_filter);
	1335	Build();
	1336	}
	1337	else
	1338	{
	1339	InputBuf[0] = 0;
	1340	CountGrep = 0;
	1341	}
1258	1342	}
1259	1343
1260	1344	void ImGuiTextFilter::Draw(const char* label, float width)
1261	1345	{
1262		ImGuiWindow* window = GetCurrentWindow();
1263		if (width < 0.0f)
1264		{
1265		ImVec2 label_size = ImGui::CalcTextSize(label, NULL, true);
1266		width = ImMax(window->Pos.x + ImGui::GetContentRegionMax().x - window->DC.CursorPos.x - (label_size.x + GImGui->Style.ItemSpacing.x*4), 10.0f);
1267		}
1268		ImGui::PushItemWidth(width);
	1346	if (width > 0.0f)
	1347	ImGui::PushItemWidth(width);
1269	1348	ImGui::InputText(label, InputBuf, IM_ARRAYSIZE(InputBuf));
1270		ImGui::PopItemWidth();
	1349	if (width > 0.0f)
	1350	ImGui::PopItemWidth();
1271	1351	Build();
1272	1352	}
1273	1353
r244869	r244870
1383	1463	ImGuiWindow::ImGuiWindow(const char* name)
1384	1464	{
1385	1465	Name = ImStrdup(name);
1386		ID = ~~Get~~ID(name);
	1466	ID = ImHash(name, 0);
1387	1467	IDStack.push_back(ID);
1388	1468
	1469	Flags = 0;
1389	1470	PosFloat = Pos = ImVec2(0.0f, 0.0f);
1390	1471	Size = SizeFull = ImVec2(0.0f, 0.0f);
1391		SizeContentsFit = ImVec2(0.0f, 0.0f);
	1472	SizeContents = SizeContentsCurrent = ImVec2(0.0f, 0.0f);
1392	1473	ScrollY = 0.0f;
1393	1474	NextScrollY = 0.0f;
1394	1475	ScrollbarY = false;
r244869	r244870
1398	1479	SkipItems = false;
1399	1480	AutoFitFrames = -1;
1400	1481	AutoFitOnlyGrows = false;
1401		SetWindowPosAllowFlags = SetWindowSizeAllowFlags = SetWindowCollapsedAllowFlags = ImGuiSetCond~~ition~~_Always \| ImGuiSetCond~~ition~~_~~FirstUseThisSessio~~n \| ImGuiSetCond~~ition~~_FirstUseEver;
	1482	SetWindowPosAllowFlags = SetWindowSizeAllowFlags = SetWindowCollapsedAllowFlags = ImGuiSetCond_Always \| ImGuiSetCond_Once \| ImGuiSetCond_FirstUseEver;
1402	1483
1403	1484	LastFrameDrawn = -1;
1404	1485	ItemWidthDefault = 0.0f;
r244869	r244870
1412	1493
1413	1494	DrawList = (ImDrawList*)ImGui::MemAlloc(sizeof(ImDrawList));
1414	1495	new(DrawList) ImDrawList();
	1496	RootWindow = NULL;
1415	1497
1416	1498	FocusIdxAllCounter = FocusIdxTabCounter = -1;
1417	1499	FocusIdxAllRequestCurrent = FocusIdxTabRequestCurrent = IM_INT_MAX;
r244869	r244870
1429	1511
1430	1512	ImGuiID ImGuiWindow::GetID(const char* str)
1431	1513	{
1432		const ImGuiID seed = IDStack.empty() ? 0 : IDStack.back();
1433		const ImGuiID id = ImCrc32(str, 0, seed);
	1514	ImGuiID seed = IDStack.back();
	1515	const ImGuiID id = ImHash(str, 0, seed);
1434	1516	RegisterAliveId(id);
1435	1517	return id;
1436	1518	}
1437	1519
1438	1520	ImGuiID ImGuiWindow::GetID(const void* ptr)
1439	1521	{
1440		const ImGuiID seed = IDStack.empty() ? 0 : IDStack.back();
1441		const ImGuiID id = ImCrc32(&ptr, sizeof(void*), seed);
	1522	ImGuiID seed = IDStack.back();
	1523	const ImGuiID id = ImHash(&ptr, sizeof(void*), seed);
1442	1524	RegisterAliveId(id);
1443	1525	return id;
1444	1526	}
r244869	r244870
1510	1592	static ImGuiIniData* FindWindowSettings(const char* name)
1511	1593	{
1512	1594	ImGuiState& g = *GImGui;
	1595	ImGuiID id = ImHash(name, 0);
1513	1596	for (size_t i = 0; i != g.Settings.size(); i++)
1514	1597	{
1515	1598	ImGuiIniData* ini = g.Settings[i];
1516		if (~~ImStr~~i~~cmp(i~~ni->~~Name,~~ ~~name)~~ == 0)
	1599	if (ini->ID == id)
1517	1600	return ini;
1518	1601	}
1519	1602	return NULL;
r244869	r244870
1524	1607	ImGuiIniData* ini = (ImGuiIniData*)ImGui::MemAlloc(sizeof(ImGuiIniData));
1525	1608	new(ini) ImGuiIniData();
1526	1609	ini->Name = ImStrdup(name);
	1610	ini->ID = ImHash(name, 0);
1527	1611	ini->Collapsed = false;
1528	1612	ini->Pos = ImVec2(FLT_MAX,FLT_MAX);
1529	1613	ini->Size = ImVec2(0,0);
r244869	r244870
1608	1692	const ImGuiIniData* settings = g.Settings[i];
1609	1693	if (settings->Pos.x == FLT_MAX)
1610	1694	continue;
1611		fprintf(f, "[%s]\n", settings->Name);
	1695	const char* name = settings->Name;
	1696	if (const char* p = strstr(name, "###")) // Skip to the "###" marker if any. We don't skip past to match the behavior of GetID()
	1697	name = p;
	1698	fprintf(f, "[%s]\n", name);
1612	1699	fprintf(f, "Pos=%d,%d\n", (int)settings->Pos.x, (int)settings->Pos.y);
1613	1700	fprintf(f, "Size=%d,%d\n", (int)settings->Size.x, (int)settings->Size.y);
1614	1701	fprintf(f, "Collapsed=%d\n", settings->Collapsed);
r244869	r244870
1715	1802	for (size_t i = 0; i < IM_ARRAYSIZE(g.IO.KeysDown); i++)
1716	1803	g.IO.KeysDownTime[i] = g.IO.KeysDown[i] ? (g.IO.KeysDownTime[i] < 0.0f ? 0.0f : g.IO.KeysDownTime[i] + g.IO.DeltaTime) : -1.0f;
1717	1804
	1805	// Calculate frame-rate for the user, as a purely luxurious feature
	1806	g.FramerateSecPerFrameAccum += g.IO.DeltaTime - g.FramerateSecPerFrame[g.FramerateSecPerFrameIdx];
	1807	g.FramerateSecPerFrame[g.FramerateSecPerFrameIdx] = g.IO.DeltaTime;
	1808	g.FramerateSecPerFrameIdx = (g.FramerateSecPerFrameIdx + 1) % IM_ARRAYSIZE(g.FramerateSecPerFrame);
	1809	g.IO.Framerate = 1.0f / (g.FramerateSecPerFrameAccum / (float)IM_ARRAYSIZE(g.FramerateSecPerFrame));
	1810
1718	1811	// Clear reference to active widget if the widget isn't alive anymore
1719	1812	g.HoveredId = 0;
1720	1813	if (!g.ActiveIdIsAlive && g.ActiveIdPreviousFrame == g.ActiveId && g.ActiveId != 0)
1721	1814	SetActiveId(0);
1722	1815	g.ActiveIdPreviousFrame = g.ActiveId;
1723	1816	g.ActiveIdIsAlive = false;
	1817	if (!g.ActiveId)
	1818	g.MovedWindow = NULL;
1724	1819
1725	1820	// Delay saving settings so we don't spam disk too much
1726	1821	if (g.SettingsDirtyTimer > 0.0f)
r244869	r244870
1795	1890	}
1796	1891
1797	1892	// Mark all windows as not visible
1798		// Clear root windows at this point.
1799	1893	for (size_t i = 0; i != g.Windows.size(); i++)
1800	1894	{
1801	1895	ImGuiWindow* window = g.Windows[i];
1802	1896	window->Visible = false;
1803	1897	window->Accessed = false;
1804		window->RootWindow = NULL;
1805	1898	}
1806	1899
1807	1900	// No window should be open at the beginning of the frame.
r244869	r244870
1809	1902	g.CurrentWindowStack.resize(0);
1810	1903
1811	1904	// Create implicit window - we will only render it if the user has added something to it.
1812		ImGui::Begin("Debug", NULL, ImVec2(400,400)~~, -1.0f, ImGuiWindowFlags_NoSavedSettings~~);
	1905	ImGui::Begin("Debug", NULL, ImVec2(400,400));
1813	1906	}
1814	1907
1815	1908	// NB: behaviour of ImGui after Shutdown() is not tested/guaranteed at the moment. This function is merely here to free heap allocations.
r244869	r244870
1932	2025	g.CurrentWindow->Visible = false;
1933	2026	ImGui::End();
1934	2027
1935		// Select window for move/focus when we're done with all our widgets (we ~~only con~~sider ~~non-c~~h~~ild~~ windows here)
	2028	// Select window for move/focus when we're done with all our widgets (we use the root window ID here)
1936	2029	if (g.ActiveId == 0 && g.HoveredId == 0 && g.HoveredRootWindow != NULL && g.IO.MouseClicked[0])
	2030	{
	2031	IM_ASSERT(g.MovedWindow == NULL);
	2032	g.MovedWindow = g.HoveredWindow;
1937	2033	SetActiveId(g.HoveredRootWindow->GetID("#MOVE"));
	2034	}
1938	2035
1939	2036	// Sort the window list so that all child windows are after their parent
1940	2037	// We cannot do that on FocusWindow() because childs may not exist yet
r244869	r244870
2010	2107	static const char* FindTextDisplayEnd(const char* text, const char* text_end = NULL)
2011	2108	{
2012	2109	const char* text_display_end = text;
2013		while ((!text_end \|\| text_display_end < text_end) && *text_display_end != '\0' && (text_display_end[0] != '#' \|\| text_display_end[1] != '#'))
	2110	if (!text_end)
	2111	text_end = (const char*)-1;
	2112	while (text_display_end < text_end && *text_display_end != '\0' && (text_display_end[0] != '#' \|\| text_display_end[1] != '#'))
2014	2113	text_display_end++;
2015	2114	return text_display_end;
2016	2115	}
r244869	r244870
2217	2316
2218	2317	if (shadow && (window->Flags & ImGuiWindowFlags_ShowBorders) != 0)
2219	2318	window->DrawList->AddTriangleFilled(a+ImVec2(2,2), b+ImVec2(2,2), c+ImVec2(2,2), window->Color(ImGuiCol_BorderShadow));
2220		window->DrawList->AddTriangleFilled(a, b, c, window->Color(ImGuiCol_~~Bord~~er));
	2319	window->DrawList->AddTriangleFilled(a, b, c, window->Color(ImGuiCol_Text));
2221	2320	}
2222	2321
2223	2322	// Calculate text size. Text can be multi-line. Optionally ignore text after a ## marker.
r244869	r244870
2294	2393	continue;
2295	2394	if (excluding_childs && (window->Flags & ImGuiWindowFlags_ChildWindow) != 0)
2296	2395	continue;
2297		ImGuiAabb bb(window->Pos - g.Style.TouchExtraPadding, window->Pos + window->Size + g.Style.TouchExtraPadding);
	2396
	2397	// Using the clipped AABB so a child window will typically be clipped by its parent.
	2398	ImGuiAabb bb(window->ClippedAabb.Min - g.Style.TouchExtraPadding, window->ClippedAabb.Max + g.Style.TouchExtraPadding);
2298	2399	if (bb.Contains(pos))
2299	2400	return window;
2300	2401	}
r244869	r244870
2304	2405	// Test if mouse cursor is hovering given aabb
2305	2406	// NB- Box is clipped by our current clip setting
2306	2407	// NB- Expand the aabb to be generous on imprecise inputs systems (g.Style.TouchExtraPadding)
2307		static bool IsMouseHoveringBox(const ImGuiAabb& box)
	2408	static bool IsMouseHoveringBox(const ImGuiAabb& bb)
2308	2409	{
2309	2410	ImGuiState& g = *GImGui;
2310	2411	ImGuiWindow* window = GetCurrentWindow();
2311	2412
2312	2413	// Clip
2313		ImGuiAabb box_clipped = box;
	2414	ImGuiAabb box_clipped = bb;
2314	2415	if (!window->ClipRectStack.empty())
2315	2416	{
2316	2417	const ImVec4 clip_rect = window->ClipRectStack.back();
r244869	r244870
2417	2518	return false;
2418	2519	}
2419	2520
	2521	bool ImGui::IsAnyItemActive()
	2522	{
	2523	ImGuiState& g = *GImGui;
	2524	return g.ActiveId != 0;
	2525	}
	2526
2420	2527	ImVec2 ImGui::GetItemBoxMin()
2421	2528	{
2422	2529	ImGuiWindow* window = GetCurrentWindow();
r244869	r244870
2467	2574	ImGui::End();
2468	2575	}
2469	2576
2470		void ImGui::BeginChild(~~ImGuiID~~ id, ImVec2 size, bool border, ImGuiWindowFlags extra_flags)
	2577	bool ImGui::BeginChild(const char* str_id, const ImVec2& size_arg, bool border, ImGuiWindowFlags extra_flags)
2471	2578	{
2472		char str_id[32];
2473		ImFormatString(str_id, IM_ARRAYSIZE(str_id), "child_%x", id);
2474		ImGui::BeginChild(str_id, size, border, extra_flags);
2475		}
2476
2477		void ImGui::BeginChild(const char* str_id, ImVec2 size, bool border, ImGuiWindowFlags extra_flags)
2478		{
2479	2579	ImGuiState& g = *GImGui;
2480	2580	ImGuiWindow* window = GetCurrentWindow();
2481	2581
r244869	r244870
2483	2583
2484	2584	const ImVec2 content_max = window->Pos + ImGui::GetContentRegionMax();
2485	2585	const ImVec2 cursor_pos = window->Pos + ImGui::GetCursorPos();
	2586	ImVec2 size = size_arg;
2486	2587	if (size.x <= 0.0f)
2487	2588	{
2488	2589	if (size.x == 0.0f)
r244869	r244870
2503	2604	ImFormatString(title, IM_ARRAYSIZE(title), "%s.%s", window->Name, str_id);
2504	2605
2505	2606	const float alpha = 1.0f;
2506		ImGui::Begin(title, NULL, size, alpha, flags);
	2607	bool ret = ImGui::Begin(title, NULL, size, alpha, flags);
2507	2608
2508	2609	if (!(window->Flags & ImGuiWindowFlags_ShowBorders))
2509	2610	g.CurrentWindow->Flags &= ~ImGuiWindowFlags_ShowBorders;
	2611
	2612	return ret;
2510	2613	}
2511	2614
	2615	bool ImGui::BeginChild(ImGuiID id, const ImVec2& size, bool border, ImGuiWindowFlags extra_flags)
	2616	{
	2617	char str_id[32];
	2618	ImFormatString(str_id, IM_ARRAYSIZE(str_id), "child_%x", id);
	2619	bool ret = ImGui::BeginChild(str_id, size, border, extra_flags);
	2620	return ret;
	2621	}
	2622
2512	2623	void ImGui::EndChild()
2513	2624	{
2514	2625	ImGuiWindow* window = GetCurrentWindow();
r244869	r244870
2528	2639	sz.y = 0;
2529	2640
2530	2641	ImGui::End();
	2642
	2643	window = GetCurrentWindow();
	2644	ImGuiAabb bb(window->DC.CursorPos, window->DC.CursorPos + sz);
2531	2645	ItemSize(sz);
	2646	ItemAdd(bb, NULL);
2532	2647	}
2533	2648	}
2534	2649
r244869	r244870
2551	2666
2552	2667	static ImGuiWindow* FindWindowByName(const char* name)
2553	2668	{
2554		// FIXME-OPT: Co~~nside~~r ~~optimizing this (~~e~~.g.~~ sorted hashes to ~~window~~ pointers)
	2669	// FIXME-OPT: Store sorted hashes -> pointers.
2555	2670	ImGuiState& g = *GImGui;
2556		for (size_t i = 0; i != g.Windows.size(); i++)
2557		if (strcmp(g.Windows[i]->Name, name) == 0)
	2671	ImGuiID id = ImHash(name, 0);
	2672	for (size_t i = 0; i < g.Windows.size(); i++)
	2673	if (g.Windows[i]->ID == id)
2558	2674	return g.Windows[i];
2559	2675	return NULL;
2560	2676	}
r244869	r244870
2587	2703	}
2588	2704	else
2589	2705	{
2590		window->SetWindowPosAllowFlags &= ~ImGuiSetCondition_FirstUseEver;
2591		window->SetWindowSizeAllowFlags &= ~ImGuiSetCondition_FirstUseEver;
2592		window->SetWindowCollapsedAllowFlags &= ~ImGuiSetCondition_FirstUseEver;
	2706	window->SetWindowPosAllowFlags &= ~ImGuiSetCond_FirstUseEver;
	2707	window->SetWindowSizeAllowFlags &= ~ImGuiSetCond_FirstUseEver;
	2708	window->SetWindowCollapsedAllowFlags &= ~ImGuiSetCond_FirstUseEver;
2593	2709	}
2594	2710
2595	2711	if (settings->Pos.x != FLT_MAX)
r244869	r244870
2608	2724	}
2609	2725
2610	2726	// Push a new ImGui window to add widgets to.
2611		// - A default window called "Debug" is automatically stacked at the beginning of every frame.
2612		// - This can be called multiple times during the frame with the same window name to append content to the same window.
2613		// - The window name is used as a unique identifier to preserve window information across frames (and save rudimentary information to the .ini file). Note that you can use ## to append unique data that isn't displayed, e.g. "My window##1" will use "My window##1" as unique window ID but display "My window" to the user.
	2727	// - 'size' for a regular window denote the initial size for first-time creation (no saved data) and isn't that useful. Use SetNextWindowSize() prior to calling Begin() for more flexible window manipulation.
	2728	// - A default window called "Debug" is automatically stacked at the beginning of every frame so you can use widgets without explicitly calling a Begin/End pair.
	2729	// - Begin/End can be called multiple times during the frame with the same window name to append content.
	2730	// - The window name is used as a unique identifier to preserve window information across frames (and save rudimentary information to the .ini file).
	2731	// You can use the "##" or "###" markers to use the same label with different id, or same id with different label. See documentation at the top of this file.
2614	2732	// - Return false when window is collapsed, so you can early out in your code. You always need to call ImGui::End() even if false is returned.
2615	2733	// - Passing 'bool* p_opened' displays a Close button on the upper-right corner of the window, the pointed value will be set to false when the button is pressed.
2616		// - Passing non-zero 'size' is roughly equivalent to calling SetNextWindowSize(size, ImGuiSetCondition_FirstUseEver) prior to calling Begin().
2617		bool ImGui::Begin(const char* name, bool* p_opened, ImVec2 size, float fill_alpha, ImGuiWindowFlags flags)
	2734	// - Passing non-zero 'size' is roughly equivalent to calling SetNextWindowSize(size, ImGuiSetCond_FirstUseEver) prior to calling Begin().
	2735	bool ImGui::Begin(const char* name, bool* p_opened, const ImVec2& size, float bg_alpha, ImGuiWindowFlags flags)
2618	2736	{
2619	2737	ImGuiState& g = *GImGui;
2620	2738	const ImGuiStyle& style = g.Style;
r244869	r244870
2651	2769	ImGui::SetWindowCollapsed(g.SetNextWindowCollapsedVal, g.SetNextWindowCollapsedCond);
2652	2770	g.SetNextWindowCollapsedCond = 0;
2653	2771	}
	2772	if (g.SetNextWindowFocus)
	2773	{
	2774	ImGui::SetWindowFocus();
	2775	g.SetNextWindowFocus = false;
	2776	}
2654	2777
2655	2778	// Find parent
2656	2779	ImGuiWindow* parent_window = (flags & ImGuiWindowFlags_ChildWindow) != 0 ? g.CurrentWindowStack[g.CurrentWindowStack.size()-2] : NULL;
2657	2780
2658		// ~~Fin~~d root (if we are a child window)
	2781	// Update known root window (if we are a child window, otherwise window == window->RootWindow)
2659	2782	size_t root_idx = g.CurrentWindowStack.size() - 1;
2660	2783	while (root_idx > 0)
2661	2784	{
r244869	r244870
2666	2789	window->RootWindow = g.CurrentWindowStack[root_idx];
2667	2790
2668	2791	// Default alpha
2669		if (fill_alpha < 0.0f)
2670		fill_alpha = style.WindowFillAlphaDefault;
	2792	if (bg_alpha < 0.0f)
	2793	bg_alpha = style.WindowFillAlphaDefault;
2671	2794
2672	2795	// When reusing window again multiple times a frame, just append content (don't need to setup again)
2673	2796	const int current_frame = ImGui::GetFrameCount();
r244869	r244870
2684	2807	window->LastFrameDrawn = current_frame;
2685	2808	window->ClipRectStack.resize(0);
2686	2809
	2810	// Reset contents size for auto-fitting
	2811	window->SizeContents = window->SizeContentsCurrent;
	2812	window->SizeContentsCurrent = ImVec2(0.0f, 0.0f);
	2813
2687	2814	if (flags & ImGuiWindowFlags_ChildWindow)
2688	2815	{
2689	2816	parent_window->DC.ChildWindows.push_back(window);
r244869	r244870
2706	2833	// Setup and draw window
2707	2834	if (first_begin_of_the_frame)
2708	2835	{
2709		// Seed ID stack with our window pointer
2710		window->IDStack.resize(0);
2711		ImGui::PushID(window);
	2836	// Reset ID stack
	2837	window->IDStack.resize(1);
2712	2838
2713		// Move window (at the beginning of the frame to avoid input lag or sheering)
	2839	// Move window (at the beginning of the frame to avoid input lag or sheering). Only valid for root windows.
2714	2840	const ImGuiID move_id = window->GetID("#MOVE");
2715	2841	RegisterAliveId(move_id);
2716	2842	if (g.ActiveId == move_id)
r244869	r244870
2723	2849	if (!(window->Flags & ImGuiWindowFlags_NoSavedSettings))
2724	2850	MarkSettingsDirty();
2725	2851	}
2726		FocusWindow(window);
	2852	IM_ASSERT(g.MovedWindow != NULL);
	2853	FocusWindow(g.MovedWindow);
2727	2854	}
2728	2855	else
2729	2856	{
2730	2857	SetActiveId(0);
	2858	g.MovedWindow = NULL; // Not strictly necessary but doing it for sanity.
2731	2859	}
2732	2860	}
2733	2861
r244869	r244870
2777	2905	window->ScrollY = window->NextScrollY;
2778	2906	window->ScrollY = ImMax(window->ScrollY, 0.0f);
2779	2907	if (!window->Collapsed && !window->SkipItems)
2780		window->ScrollY = ImMin(window->ScrollY, ImMax(0.0f, ~~(float)~~window->SizeContents~~Fit~~.y - window->SizeFull.y));
	2908	window->ScrollY = ImMin(window->ScrollY, ImMax(0.0f, window->SizeContents.y - window->SizeFull.y));
2781	2909	window->NextScrollY = window->ScrollY;
2782	2910
2783	2911	// At this point we don't have a clipping rectangle setup yet, so we can test and draw in title bar
r244869	r244870
2817	2945	if ((window->Flags & ImGuiWindowFlags_Tooltip) != 0)
2818	2946	{
2819	2947	// Tooltip always resize. We keep the spacing symmetric on both axises for aesthetic purpose.
2820		const ImVec2 size_auto_fit = window->SizeContents~~Fit~~ + style.WindowPadding - ImVec2(0.0f, style.ItemSpacing.y);
	2948	const ImVec2 size_auto_fit = window->SizeContents + style.WindowPadding - ImVec2(0.0f, style.ItemSpacing.y);
2821	2949	window->SizeFull = size_auto_fit;
2822	2950	}
2823	2951	else
2824	2952	{
2825		const ImVec2 size_auto_fit = ImClamp(window->SizeContents~~Fit~~ + style.AutoFitPadding, style.WindowMinSize, ImMax(style.WindowMinSize, g.IO.DisplaySize - style.AutoFitPadding));
	2953	const ImVec2 size_auto_fit = ImClamp(window->SizeContents + style.AutoFitPadding, style.WindowMinSize, ImMax(style.WindowMinSize, g.IO.DisplaySize - style.AutoFitPadding));
2826	2954	if ((window->Flags & ImGuiWindowFlags_AlwaysAutoResize) != 0)
2827	2955	{
2828	2956	// Don't continuously mark settings as dirty, the size of the window doesn't need to be stored.
r244869	r244870
2842	2970	{
2843	2971	// Manual resize grip
2844	2972	const ImGuiAabb resize_aabb(window->Aabb().GetBR()-ImVec2(18,18), window->Aabb().GetBR());
2845		const ImGuiID resize_id = window->GetID("##RESIZE");
	2973	const ImGuiID resize_id = window->GetID("#RESIZE");
2846	2974	bool hovered, held;
2847	2975	ButtonBehaviour(resize_aabb, resize_id, &hovered, &held, true);
2848	2976	resize_col = window->Color(held ? ImGuiCol_ResizeGripActive : hovered ? ImGuiCol_ResizeGripHovered : ImGuiCol_ResizeGrip);
r244869	r244870
2870	2998	}
2871	2999
2872	3000	// Scrollbar
2873		window->ScrollbarY = (window->SizeContents~~Fit~~.y > window->Size.y) && !(window->Flags & ImGuiWindowFlags_NoScrollbar);
	3001	window->ScrollbarY = (window->SizeContents.y > window->Size.y) && !(window->Flags & ImGuiWindowFlags_NoScrollbar);
2874	3002
2875	3003	// Window background
2876		if (~~fill~~_alpha > 0.0f)
	3004	if (bg_alpha > 0.0f)
2877	3005	{
2878	3006	if ((window->Flags & ImGuiWindowFlags_ComboBox) != 0)
2879		window->DrawList->AddRectFilled(window->Pos, window->Pos+window->Size, window->Color(ImGuiCol_ComboBg, ~~fill~~_alpha), window_rounding);
	3007	window->DrawList->AddRectFilled(window->Pos, window->Pos+window->Size, window->Color(ImGuiCol_ComboBg, bg_alpha), window_rounding);
2880	3008	else if ((window->Flags & ImGuiWindowFlags_Tooltip) != 0)
2881		window->DrawList->AddRectFilled(window->Pos, window->Pos+window->Size, window->Color(ImGuiCol_TooltipBg, ~~fill~~_alpha), window_rounding);
	3009	window->DrawList->AddRectFilled(window->Pos, window->Pos+window->Size, window->Color(ImGuiCol_TooltipBg, bg_alpha), window_rounding);
2882	3010	else if ((window->Flags & ImGuiWindowFlags_ChildWindow) != 0)
2883		window->DrawList->AddRectFilled(window->Pos, window->Pos+window->Size-ImVec2(window->ScrollbarY?style.ScrollBarWidth:0.0f,0.0f), window->Color(ImGuiCol_ChildWindowBg, ~~fill~~_alpha), window_rounding, window->ScrollbarY ? (1\|8) : (0xF));
	3011	window->DrawList->AddRectFilled(window->Pos, window->Pos+window->Size-ImVec2(window->ScrollbarY?style.ScrollbarWidth:0.0f,0.0f), window->Color(ImGuiCol_ChildWindowBg, bg_alpha), window_rounding, window->ScrollbarY ? (1\|8) : (0xF));
2884	3012	else
2885		window->DrawList->AddRectFilled(window->Pos, window->Pos+window->Size, window->Color(ImGuiCol_WindowBg, ~~fill~~_alpha), window_rounding);
	3013	window->DrawList->AddRectFilled(window->Pos, window->Pos+window->Size, window->Color(ImGuiCol_WindowBg, bg_alpha), window_rounding);
2886	3014	}
2887	3015
2888	3016	// Title bar
r244869	r244870
2900	3028
2901	3029	// Scrollbar
2902	3030	if (window->ScrollbarY)
2903		{
2904		ImGuiAabb scrollbar_bb(window->Aabb().Max.x - style.ScrollBarWidth, title_bar_aabb.Max.y+1, window->Aabb().Max.x, window->Aabb().Max.y-1);
2905		//window->DrawList->AddLine(scrollbar_bb.GetTL(), scrollbar_bb.GetBL(), g.Colors[ImGuiCol_Border]);
2906		window->DrawList->AddRectFilled(scrollbar_bb.Min, scrollbar_bb.Max, window->Color(ImGuiCol_ScrollbarBg));
2907		scrollbar_bb.Expand(ImVec2(-3,-3));
	3031	Scrollbar(window);
2908	3032
2909		const float grab_size_y_norm = ImSaturate(window->Size.y / ImMax(window->SizeContentsFit.y, window->Size.y));
2910		const float grab_size_y = scrollbar_bb.GetHeight() * grab_size_y_norm;
2911
2912		// Handle input right away (none of the code above is relying on scrolling position)
2913		bool held = false;
2914		bool hovered = false;
2915		if (grab_size_y_norm < 1.0f)
2916		{
2917		const ImGuiID scrollbar_id = window->GetID("#SCROLLY");
2918		ButtonBehaviour(scrollbar_bb, scrollbar_id, &hovered, &held, true);
2919		if (held)
2920		{
2921		g.HoveredId = scrollbar_id;
2922		const float pos_y_norm = ImSaturate((g.IO.MousePos.y - (scrollbar_bb.Min.y + grab_size_y0.5f)) / (scrollbar_bb.GetHeight() - grab_size_y)) (1.0f - grab_size_y_norm);
2923		window->ScrollY = (float)(int)(pos_y_norm * window->SizeContentsFit.y);
2924		window->NextScrollY = window->ScrollY;
2925		}
2926		}
2927
2928		// Normalized height of the grab
2929		const float pos_y_norm = ImSaturate(window->ScrollY / ImMax(0.0f, window->SizeContentsFit.y));
2930		const ImU32 grab_col = window->Color(held ? ImGuiCol_ScrollbarGrabActive : hovered ? ImGuiCol_ScrollbarGrabHovered : ImGuiCol_ScrollbarGrab);
2931		window->DrawList->AddRectFilled(
2932		ImVec2(scrollbar_bb.Min.x, ImLerp(scrollbar_bb.Min.y, scrollbar_bb.Max.y, pos_y_norm)),
2933		ImVec2(scrollbar_bb.Max.x, ImLerp(scrollbar_bb.Min.y, scrollbar_bb.Max.y, pos_y_norm + grab_size_y_norm)), grab_col);
2934		}
2935
2936	3033	// Render resize grip
2937	3034	// (after the input handling so we don't have a frame of latency)
2938	3035	if (!(window->Flags & ImGuiWindowFlags_NoResize))
r244869	r244870
2975	3072	window->DC.ColumnsCellMinY = window->DC.ColumnsCellMaxY = window->DC.ColumnsStartPos.y;
2976	3073	window->DC.TreeDepth = 0;
2977	3074	window->DC.StateStorage = &window->StateStorage;
2978		window->DC.OpenNextNode = -1;
2979	3075
2980		// Reset contents size for auto-fitting
2981		window->SizeContentsFit = ImVec2(0.0f, 0.0f);
2982	3076	if (window->AutoFitFrames > 0)
2983	3077	window->AutoFitFrames--;
2984	3078
r244869	r244870
2999	3093	const ImVec2 text_max = window->Pos + ImVec2(window->Size.x - (p_opened ? (title_bar_aabb.GetHeight()-3) : style.FramePadding.x), style.FramePadding.y*2 + text_size.y);
3000	3094	RenderTextClipped(text_min, name, NULL, &text_size, text_max);
3001	3095	}
	3096
	3097	// Save clipped aabb so we can access it in constant-time in FindHoveredWindow()
	3098	window->ClippedAabb = window->Aabb();
	3099	window->ClippedAabb.Clip(window->ClipRectStack.front());
3002	3100	}
3003	3101
3004	3102	// Inner clipping rectangle
r244869	r244870
3006	3104	const ImGuiAabb title_bar_aabb = window->TitleBarAabb();
3007	3105	ImVec4 clip_rect(title_bar_aabb.Min.x+0.5f+window->WindowPadding().x0.5f, title_bar_aabb.Max.y+0.5f, window->Aabb().Max.x+0.5f-window->WindowPadding().x0.5f, window->Aabb().Max.y-1.5f);
3008	3106	if (window->ScrollbarY)
3009		clip_rect.z -= style.ScrollBarWidth;
	3107	clip_rect.z -= style.ScrollbarWidth;
3010	3108	PushClipRect(clip_rect);
3011	3109
3012	3110	// Clear 'accessed' flag last thing
r244869	r244870
3018	3116	if (flags & ImGuiWindowFlags_ChildWindow)
3019	3117	{
3020	3118	IM_ASSERT((flags & ImGuiWindowFlags_NoTitleBar) != 0);
	3119	window->Collapsed = parent_window && parent_window->Collapsed;
	3120
3021	3121	const ImVec4 clip_rect_t = window->ClipRectStack.back();
3022		window->Collapsed = (clip_rect_t.x >= clip_rect_t.z \|\| clip_rect_t.y >= clip_rect_t.w);
	3122	window->Collapsed \|= (clip_rect_t.x >= clip_rect_t.z \|\| clip_rect_t.y >= clip_rect_t.w);
3023	3123
3024	3124	// We also hide the window from rendering because we've already added its border to the command list.
3025	3125	// (we could perform the check earlier in the function but it is simpler at this point)
r244869	r244870
3049	3149	ImGui::LogFinish();
3050	3150
3051	3151	// Pop
3052		// NB: we don't clear 'window->RootWindow' yet, it will be u~~sed~~ then clea~~red~~ in Ne~~wFrame~~()
	3152	// NB: we don't clear 'window->RootWindow'. The pointer is allowed to live until the next call to Begin().
3053	3153	g.CurrentWindowStack.pop_back();
3054	3154	g.CurrentWindow = g.CurrentWindowStack.empty() ? NULL : g.CurrentWindowStack.back();
3055	3155	}
3056	3156
	3157	// Vertical scrollbar
	3158	// The entire piece of code below is rather confusing because:
	3159	// - We handle absolute seeking (when first clicking outside the grab) and relative manipulation (afterward or when clicking inside the grab)
	3160	// - We store values as ratio and in a form that allows the window content to change while we are holding on a scrollbar
	3161	static void Scrollbar(ImGuiWindow* window)
	3162	{
	3163	ImGuiState& g = *GImGui;
	3164	const ImGuiStyle& style = g.Style;
	3165	const ImGuiID id = window->GetID("#SCROLLY");
	3166
	3167	// Render background
	3168	ImGuiAabb bb(window->Aabb().Max.x - style.ScrollbarWidth, window->Pos.y + window->TitleBarHeight()+1, window->Aabb().Max.x, window->Aabb().Max.y-1);
	3169	window->DrawList->AddRectFilled(bb.Min, bb.Max, window->Color(ImGuiCol_ScrollbarBg));
	3170	bb.Expand(ImVec2(-3,-3));
	3171	const float scrollbar_height = bb.GetHeight();
	3172
	3173	// The grabable box size generally represent the amount visible (vs the total scrollable amount)
	3174	// But we maintain a minimum size in pixel to allow for the user to still aim inside.
	3175	const float grab_h_pixels = ImMax(style.GrabMinSize, scrollbar_height * ImSaturate(window->Size.y / ImMax(window->SizeContents.y, window->Size.y)));
	3176	const float grab_h_norm = grab_h_pixels / scrollbar_height;
	3177
	3178	// Handle input right away. None of the code of Begin() is relying on scrolling position before calling Scrollbar().
	3179	bool held = false;
	3180	bool hovered = false;
	3181	const bool previously_held = (g.ActiveId == id);
	3182	ButtonBehaviour(bb, id, &hovered, &held, true);
	3183
	3184	const float scroll_max = ImMax(1.0f, window->SizeContents.y - window->Size.y);
	3185	float scroll_ratio = ImSaturate(window->ScrollY / scroll_max);
	3186	float grab_y_norm = scroll_ratio * (scrollbar_height - grab_h_pixels) / scrollbar_height;
	3187	if (held)
	3188	{
	3189	const float clicked_y_norm = ImSaturate((g.IO.MousePos.y - bb.Min.y) / scrollbar_height); // Click position in scrollbar space (0.0f->1.0f)
	3190	g.HoveredId = id;
	3191
	3192	bool seek_absolute = false;
	3193	if (!previously_held)
	3194	{
	3195	// On initial click calculate the distance between mouse and the center of the grab
	3196	if (clicked_y_norm >= grab_y_norm && clicked_y_norm <= grab_y_norm + grab_h_norm)
	3197	{
	3198	g.ScrollbarClickDeltaToGrabCenter = clicked_y_norm - grab_y_norm - grab_h_norm*0.5f;
	3199	}
	3200	else
	3201	{
	3202	seek_absolute = true;
	3203	g.ScrollbarClickDeltaToGrabCenter = 0;
	3204	}
	3205	}
	3206
	3207	// Apply scroll
	3208	const float scroll_y_norm = ImSaturate((clicked_y_norm - g.ScrollbarClickDeltaToGrabCenter - grab_h_norm*0.5f) / (1.0f - grab_h_norm));
	3209	window->ScrollY = (float)(int)(0.5f + scroll_y_norm * (window->SizeContents.y - window->Size.y));
	3210	window->NextScrollY = window->ScrollY;
	3211
	3212	// Update values for rendering
	3213	scroll_ratio = ImSaturate(window->ScrollY / scroll_max);
	3214	grab_y_norm = scroll_ratio * (scrollbar_height - grab_h_pixels) / scrollbar_height;
	3215
	3216	// Update distance to grab now that we have seeked and saturated
	3217	if (seek_absolute)
	3218	g.ScrollbarClickDeltaToGrabCenter = clicked_y_norm - grab_y_norm - grab_h_norm*0.5f;
	3219	}
	3220
	3221	// Render
	3222	const ImU32 grab_col = window->Color(held ? ImGuiCol_ScrollbarGrabActive : hovered ? ImGuiCol_ScrollbarGrabHovered : ImGuiCol_ScrollbarGrab);
	3223	window->DrawList->AddRectFilled(ImVec2(bb.Min.x, ImLerp(bb.Min.y, bb.Max.y, grab_y_norm)), ImVec2(bb.Max.x, ImLerp(bb.Min.y, bb.Max.y, grab_y_norm) + grab_h_pixels), grab_col);
	3224	}
	3225
3057	3226	// Moving window to front of display (which happens to be back of our sorted list)
3058	3227	static void FocusWindow(ImGuiWindow* window)
3059	3228	{
3060	3229	ImGuiState& g = *GImGui;
	3230
	3231	// Always mark the window we passed as focused. This is used for keyboard interactions such as tabbing.
3061	3232	g.FocusedWindow = window;
3062	3233
	3234	// And move its root window to the top of the pile
	3235	if (window->RootWindow)
	3236	window = window->RootWindow;
	3237
3063	3238	if (g.Windows.back() == window)
3064	3239	return;
3065	3240
r244869	r244870
3109	3284	g.Font = font;
3110	3285	g.FontSize = g.IO.FontGlobalScale * g.Font->FontSize * g.Font->Scale;
3111	3286	g.FontTexUvWhitePixel = g.Font->ContainerAtlas->TexUvWhitePixel;
3112		g.Font->FallbackGlyph = NULL;
3113		g.Font->FallbackGlyph = g.Font->FindGlyph(g.Font->FallbackChar);
3114	3287	}
3115	3288
3116	3289	void ImGui::PushFont(ImFont* font)
r244869	r244870
3228	3401	ImGuiState& g = *GImGui;
3229	3402
3230	3403	ImVec2* pvar = GetStyleVarVec2Addr(idx);
3231		IM_ASSERT(pvar != NULL); // Called function with wrong-type? Varialble is not a ImVec2.
	3404	IM_ASSERT(pvar != NULL); // Called function with wrong-type? Variable is not a ImVec2.
3232	3405	ImGuiStyleMod backup;
3233	3406	backup.Var = idx;
3234	3407	backup.PreviousValue = *pvar;
r244869	r244870
3320	3493	return window->Pos;
3321	3494	}
3322	3495
3323		void ~~ImGui::~~SetWindowPos(const ImVec2& pos, ImGuiSetCond~~ition~~ cond)
	3496	static void SetWindowPos(ImGuiWindow* window, const ImVec2& pos, ImGuiSetCond cond)
3324	3497	{
3325		ImGuiWindow* window = GetCurrentWindow();
3326
3327	3498	// Test condition (NB: bit 0 is always true) and clear flags for next time
3328	3499	if (cond && (window->SetWindowPosAllowFlags & cond) == 0)
3329	3500	return;
3330		window->SetWindowPosAllowFlags &= ~(ImGuiSetCond~~ition~~_~~FirstUseThisSessio~~n \| ImGuiSetCond~~ition~~_FirstUseEver);
	3501	window->SetWindowPosAllowFlags &= ~(ImGuiSetCond_Once \| ImGuiSetCond_FirstUseEver);
3331	3502
3332	3503	// Set
3333	3504	const ImVec2 old_pos = window->Pos;
r244869	r244870
3336	3507	window->DC.CursorPos += (window->Pos - old_pos); // As we happen to move the window while it is being appended to (which is a bad idea - will smear) let's at least offset the cursor
3337	3508	}
3338	3509
	3510	void ImGui::SetWindowPos(const ImVec2& pos, ImGuiSetCond cond)
	3511	{
	3512	ImGuiWindow* window = GetCurrentWindow();
	3513	SetWindowPos(window, pos, cond);
	3514	}
	3515
	3516	void ImGui::SetWindowPos(const char* name, const ImVec2& pos, ImGuiSetCond cond)
	3517	{
	3518	ImGuiWindow* window = FindWindowByName(name);
	3519	if (window)
	3520	SetWindowPos(window, pos, cond);
	3521	}
	3522
3339	3523	ImVec2 ImGui::GetWindowSize()
3340	3524	{
3341	3525	ImGuiWindow* window = GetCurrentWindow();
3342	3526	return window->Size;
3343	3527	}
3344	3528
3345		void ~~ImGui::~~SetWindowSize(const ImVec2& size, ImGuiSetCond~~ition~~ cond)
	3529	static void SetWindowSize(ImGuiWindow* window, const ImVec2& size, ImGuiSetCond cond)
3346	3530	{
3347		ImGuiWindow* window = GetCurrentWindow();
3348
3349	3531	// Test condition (NB: bit 0 is always true) and clear flags for next time
3350	3532	if (cond && (window->SetWindowSizeAllowFlags & cond) == 0)
3351	3533	return;
3352		window->SetWindowSizeAllowFlags &= ~(ImGuiSetCond~~ition~~_~~FirstUseThisSessio~~n \| ImGuiSetCond~~ition~~_FirstUseEver);
	3534	window->SetWindowSizeAllowFlags &= ~(ImGuiSetCond_Once \| ImGuiSetCond_FirstUseEver);
3353	3535
3354	3536	// Set
3355	3537	if (ImLengthSqr(size) > 0.00001f)
r244869	r244870
3365	3547	}
3366	3548	}
3367	3549
3368		void ImGui::SetWindow~~Collaps~~ed(bool c~~ollap~~sed, ImGuiSetCond~~ition~~ cond)
	3550	void ImGui::SetWindowSize(const ImVec2& size, ImGuiSetCond cond)
3369	3551	{
3370	3552	ImGuiWindow* window = GetCurrentWindow();
	3553	SetWindowSize(window, size, cond);
	3554	}
3371	3555
	3556	void ImGui::SetWindowSize(const char* name, const ImVec2& size, ImGuiSetCond cond)
	3557	{
	3558	ImGuiWindow* window = FindWindowByName(name);
	3559	if (window)
	3560	SetWindowSize(window, size, cond);
	3561	}
	3562
	3563	static void SetWindowCollapsed(ImGuiWindow* window, bool collapsed, ImGuiSetCond cond)
	3564	{
3372	3565	// Test condition (NB: bit 0 is always true) and clear flags for next time
3373	3566	if (cond && (window->SetWindowCollapsedAllowFlags & cond) == 0)
3374	3567	return;
3375		window->SetWindowCollapsedAllowFlags &= ~(ImGuiSetCond~~ition~~_~~FirstUseThisSessio~~n \| ImGuiSetCond~~ition~~_FirstUseEver);
	3568	window->SetWindowCollapsedAllowFlags &= ~(ImGuiSetCond_Once \| ImGuiSetCond_FirstUseEver);
3376	3569
3377	3570	// Set
3378	3571	window->Collapsed = collapsed;
3379	3572	}
3380	3573
3381		void ImGui::Set~~Next~~WindowPos(co~~nst~~ ~~ImVe~~c~~2& p~~os, ImGuiSetCond~~ition~~ cond)
	3574	void ImGui::SetWindowCollapsed(bool collapsed, ImGuiSetCond cond)
3382	3575	{
	3576	ImGuiWindow* window = GetCurrentWindow();
	3577	SetWindowCollapsed(window, collapsed, cond);
	3578	}
	3579
	3580	bool ImGui::GetWindowCollapsed()
	3581	{
	3582	ImGuiWindow* window = GetCurrentWindow();
	3583	return window->Collapsed;
	3584	}
	3585
	3586	void ImGui::SetWindowCollapsed(const char* name, bool collapsed, ImGuiSetCond cond)
	3587	{
	3588	ImGuiWindow* window = FindWindowByName(name);
	3589	if (window)
	3590	SetWindowCollapsed(window, collapsed, cond);
	3591	}
	3592
	3593	void ImGui::SetWindowFocus()
	3594	{
	3595	ImGuiWindow* window = GetCurrentWindow();
	3596	FocusWindow(window);
	3597	}
	3598
	3599	void ImGui::SetWindowFocus(const char* name)
	3600	{
	3601	ImGuiWindow* window = FindWindowByName(name);
	3602	if (window)
	3603	FocusWindow(window);
	3604	}
	3605
	3606	void ImGui::SetNextWindowPos(const ImVec2& pos, ImGuiSetCond cond)
	3607	{
3383	3608	ImGuiState& g = *GImGui;
3384	3609	g.SetNextWindowPosVal = pos;
3385		g.SetNextWindowPosCond = cond ? cond : ImGuiSetCond~~ition~~_Always;
	3610	g.SetNextWindowPosCond = cond ? cond : ImGuiSetCond_Always;
3386	3611	}
3387	3612
3388		void ImGui::SetNextWindowSize(const ImVec2& size, ImGuiSetCond~~ition~~ cond)
	3613	void ImGui::SetNextWindowSize(const ImVec2& size, ImGuiSetCond cond)
3389	3614	{
3390	3615	ImGuiState& g = *GImGui;
3391	3616	g.SetNextWindowSizeVal = size;
3392		g.SetNextWindowSizeCond = cond ? cond : ImGuiSetCond~~ition~~_Always;
	3617	g.SetNextWindowSizeCond = cond ? cond : ImGuiSetCond_Always;
3393	3618	}
3394	3619
3395		void ImGui::SetNextWindowCollapsed(bool collapsed, ImGuiSetCond~~ition~~ cond)
	3620	void ImGui::SetNextWindowCollapsed(bool collapsed, ImGuiSetCond cond)
3396	3621	{
3397	3622	ImGuiState& g = *GImGui;
3398	3623	g.SetNextWindowCollapsedVal = collapsed;
3399		g.SetNextWindowCollapsedCond = cond ? cond : ImGuiSetCond~~ition~~_Always;
	3624	g.SetNextWindowCollapsedCond = cond ? cond : ImGuiSetCond_Always;
3400	3625	}
3401	3626
	3627	void ImGui::SetNextWindowFocus()
	3628	{
	3629	ImGuiState& g = *GImGui;
	3630	g.SetNextWindowFocus = true;
	3631	}
	3632
3402	3633	ImVec2 ImGui::GetContentRegionMax()
3403	3634	{
3404	3635	ImGuiWindow* window = GetCurrentWindow();
3405		ImVec2 mx = window->Size - window->WindowPadding();
	3636	ImVec2 window_padding = window->WindowPadding();
	3637	ImVec2 mx = window->Size - window_padding;
3406	3638	if (window->DC.ColumnsCount != 1)
3407	3639	{
3408	3640	mx.x = ImGui::GetColumnOffset(window->DC.ColumnsCurrent + 1);
3409		mx.x -= ~~GImGu~~i~~->Style.Wi~~ndowPadding.x;
	3641	mx.x -= window_padding.x;
3410	3642	}
3411	3643	else
3412	3644	{
3413	3645	if (window->ScrollbarY)
3414		mx.x -= GImGui->Style.ScrollBarWidth;
	3646	mx.x -= GImGui->Style.ScrollbarWidth;
3415	3647	}
3416	3648	return mx;
3417	3649	}
r244869	r244870
3427	3659	ImGuiWindow* window = GetCurrentWindow();
3428	3660	ImVec2 m = window->Size - window->WindowPadding();
3429	3661	if (window->ScrollbarY)
3430		m.x -= GImGui->Style.ScrollBarWidth;
	3662	m.x -= GImGui->Style.ScrollbarWidth;
3431	3663	return m;
3432	3664	}
3433	3665
r244869	r244870
3490	3722	{
3491	3723	ImGuiWindow* window = GetCurrentWindow();
3492	3724	window->DC.CursorPos = window->Pos + pos;
3493		window->SizeContentsFit = ImMax(window->SizeContentsFit, pos + ImVec2(0.0f, window->ScrollY));
	3725	window->SizeContentsCurrent = ImMax(window->SizeContentsCurrent, pos + ImVec2(0.0f, window->ScrollY));
3494	3726	}
3495	3727
3496	3728	void ImGui::SetCursorPosX(float x)
3497	3729	{
3498	3730	ImGuiWindow* window = GetCurrentWindow();
3499	3731	window->DC.CursorPos.x = window->Pos.x + x;
3500		window->SizeContentsFit.x = ImMax(window->SizeContentsFit.x, x);
	3732	window->SizeContentsCurrent.x = ImMax(window->SizeContentsCurrent.x, x);
3501	3733	}
3502	3734
3503	3735	void ImGui::SetCursorPosY(float y)
3504	3736	{
3505	3737	ImGuiWindow* window = GetCurrentWindow();
3506	3738	window->DC.CursorPos.y = window->Pos.y + y;
3507		window->SizeContentsFit.y = ImMax(window->SizeContentsFit.y, y + window->ScrollY);
	3739	window->SizeContentsCurrent.y = ImMax(window->SizeContentsCurrent.y, y + window->ScrollY);
3508	3740	}
3509	3741
3510	3742	ImVec2 ImGui::GetCursorScreenPos()
r244869	r244870
3519	3751	window->DC.CursorPos = screen_pos;
3520	3752	}
3521	3753
	3754	float ImGui::GetScrollPosY()
	3755	{
	3756	ImGuiWindow* window = GetCurrentWindow();
	3757	return window->ScrollY;
	3758	}
	3759
	3760	float ImGui::GetScrollMaxY()
	3761	{
	3762	ImGuiWindow* window = GetCurrentWindow();
	3763	return window->SizeContents.y - window->SizeFull.y;
	3764	}
	3765
3522	3766	void ImGui::SetScrollPosHere()
3523	3767	{
3524	3768	ImGuiWindow* window = GetCurrentWindow();
r244869	r244870
3720	3964	const char* value_text_begin = &buf[0];
3721	3965	const char* value_text_end = value_text_begin + ImFormatStringV(buf, IM_ARRAYSIZE(buf), fmt, args);
3722	3966
3723		const ImVec2 text_size = CalcTextSize(label, NULL, true);
3724		const ImGuiAabb value_bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(w + style.FramePadding.x*2, text_size.y));
3725		const ImGuiAabb bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(w + style.FramePadding.x*2 + (text_size.x > 0.0f ? style.ItemInnerSpacing.x : 0.0f), 0.0f) + text_size);
	3967	const ImVec2 label_size = CalcTextSize(label, NULL, true);
	3968	const ImGuiAabb value_bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(w + style.FramePadding.x*2, label_size.y));
	3969	const ImGuiAabb bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(w + style.FramePadding.x*2 + (label_size.x > 0.0f ? style.ItemInnerSpacing.x : 0.0f), 0.0f) + label_size);
3726	3970	ItemSize(bb);
3727	3971	if (!ItemAdd(value_bb, NULL))
3728	3972	return;
r244869	r244870
3746	3990	if (g.HoveredId == 0)
3747	3991	{
3748	3992	ImGuiWindow* window = GetCurrentWindow();
3749		const bool hovered = (g.HoveredRootWindow == window->RootWindow) && (g.ActiveId == 0 \|\| g.ActiveId == id) && IsMouseHoveringBox(bb);
3750		return hovered;
	3993	if (g.HoveredRootWindow == window->RootWindow)
	3994	{
	3995	bool hovered = (g.ActiveId == 0 \|\| g.ActiveId == id \|\| g.ActiveIdIsFocusedOnly) && IsMouseHoveringBox(bb);
	3996	return hovered;
	3997	}
3751	3998	}
3752	3999	return false;
3753	4000	}
r244869	r244870
3814	4061
3815	4062	const ImGuiStyle& style = g.Style;
3816	4063	const ImGuiID id = window->GetID(label);
3817		const ImVec2 text_size = CalcTextSize(label, NULL, true);
	4064	const ImVec2 label_size = CalcTextSize(label, NULL, true);
3818	4065
3819		const ImVec2 size(size_arg.x != 0.0f ? size_arg.x : text_size.x, size_arg.y != 0.0f ? size_arg.y : text_size.y);
	4066	const ImVec2 size(size_arg.x != 0.0f ? size_arg.x : label_size.x, size_arg.y != 0.0f ? size_arg.y : label_size.y);
3820	4067	const ImGuiAabb bb(window->DC.CursorPos, window->DC.CursorPos + size + style.FramePadding*2.0f);
3821	4068	ItemSize(bb);
3822	4069	if (!ItemAdd(bb, &id))
r244869	r244870
3829	4076	const ImU32 col = window->Color((hovered && held) ? ImGuiCol_ButtonActive : hovered ? ImGuiCol_ButtonHovered : ImGuiCol_Button);
3830	4077	RenderFrame(bb.Min, bb.Max, col, true, style.FrameRounding);
3831	4078
3832		const ImVec2 off = ImVec2(ImMax(0.0f, size.x - text_size.x) * 0.5f, ImMax(0.0f, size.y - text_size.y) * 0.5f); // Center (only applies if we explicitly gave a size bigger than the text size, which isn't the common path)
3833		RenderTextClipped(bb.Min + style.FramePadding + off, label, NULL, &text_size, bb.Max); // Render clip (only applies if we explicitly gave a size smaller than the text size, which isn't the commmon path)
	4079	const ImVec2 off = ImVec2(ImMax(0.0f, size.x - label_size.x) * 0.5f, ImMax(0.0f, size.y - label_size.y) * 0.5f); // Center (only applies if we explicitly gave a size bigger than the text size, which isn't the common path)
	4080	RenderTextClipped(bb.Min + style.FramePadding + off, label, NULL, &label_size, bb.Max); // Render clip (only applies if we explicitly gave a size smaller than the text size, which isn't the commmon path)
3834	4081
3835	4082	return pressed;
3836	4083	}
r244869	r244870
3845	4092
3846	4093	const ImGuiStyle& style = g.Style;
3847	4094	const ImGuiID id = window->GetID(label);
3848		const ImVec2 text_size = CalcTextSize(label, NULL, true);
	4095	const ImVec2 label_size = CalcTextSize(label, NULL, true);
3849	4096
3850		const ImGuiAabb bb(window->DC.CursorPos, window->DC.CursorPos + text_size + ImVec2(style.FramePadding.x*2,0));
	4097	const ImGuiAabb bb(window->DC.CursorPos, window->DC.CursorPos + label_size + ImVec2(style.FramePadding.x*2,0));
3851	4098	ItemSize(bb);
3852	4099	if (!ItemAdd(bb, &id))
3853	4100	return false;
r244869	r244870
3888	4135	{
3889	4136	ImGuiWindow* window = GetCurrentWindow();
3890	4137
3891		const ImGuiID id = window->GetID("##CLOSE");
	4138	const ImGuiID id = window->GetID("#CLOSE");
3892	4139	const float size = window->TitleBarHeight() - 4.0f;
3893	4140	const ImGuiAabb bb(window->Aabb().GetTR() + ImVec2(-3.0f-size,2.0f), window->Aabb().GetTR() + ImVec2(-3.0f,2.0f+size));
3894	4141
r244869	r244870
4082	4329	LogToClipboard(g.LogAutoExpandMaxDepth);
4083	4330	}
4084	4331
4085		bool ImGui::CollapsingHeader(const char* label, const char* str_id, ~~const~~ bool display_frame, ~~const~~ bool default_open)
	4332	bool ImGui::CollapsingHeader(const char* label, const char* str_id, bool display_frame, bool default_open)
4086	4333	{
4087	4334	ImGuiState& g = *GImGui;
4088	4335	ImGuiWindow* window = GetCurrentWindow();
r244869	r244870
4098	4345	label = str_id;
4099	4346	const ImGuiID id = window->GetID(str_id);
4100	4347
4101		// We only write to the tree storage if the user clicks
	4348	// We only write to the tree storage if the user clicks (or explicitely use SetNextTreeNode*** functions)
4102	4349	ImGuiStorage* storage = window->DC.StateStorage;
4103	4350	bool opened;
4104		if (~~window->DC~~.OpenNextNode != -1)
	4351	if (g.SetNextTreeNodeOpenedCond != 0)
4105	4352	{
4106		opened = window->DC.OpenNextNode > 0;
4107		storage->SetInt(id, opened);
4108		window->DC.OpenNextNode = -1;
	4353	if (g.SetNextTreeNodeOpenedCond & ImGuiSetCond_Always)
	4354	{
	4355	opened = g.SetNextTreeNodeOpenedVal;
	4356	storage->SetInt(id, opened);
	4357	}
	4358	else
	4359	{
	4360	// We treat ImGuiSetCondition_Once and ImGuiSetCondition_FirstUseEver the same because tree node state are not saved persistently.
	4361	const int stored_value = storage->GetInt(id, -1);
	4362	if (stored_value == -1)
	4363	{
	4364	opened = g.SetNextTreeNodeOpenedVal;
	4365	storage->SetInt(id, opened);
	4366	}
	4367	else
	4368	{
	4369	opened = stored_value != 0;
	4370	}
	4371	}
	4372	g.SetNextTreeNodeOpenedCond = 0;
4109	4373	}
4110	4374	else
4111	4375	{
r244869	r244870
4114	4378
4115	4379	// Framed header expand a little outside the default padding
4116	4380	const ImVec2 window_padding = window->WindowPadding();
4117		const ImVec2 text_size = CalcTextSize(label, NULL, true);
	4381	const ImVec2 label_size = CalcTextSize(label, NULL, true);
4118	4382	const ImVec2 pos_min = window->DC.CursorPos;
4119	4383	const ImVec2 pos_max = window->Pos + GetContentRegionMax();
4120		ImGuiAabb bb = ImGuiAabb(pos_min, ImVec2(pos_max.x, pos_min.y + text_size.y));
	4384	ImGuiAabb bb = ImGuiAabb(pos_min, ImVec2(pos_max.x, pos_min.y + label_size.y));
4121	4385	if (display_frame)
4122	4386	{
4123	4387	bb.Min.x -= window_padding.x*0.5f - 1;
r244869	r244870
4125	4389	bb.Max.y += style.FramePadding.y * 2;
4126	4390	}
4127	4391
4128		const ImGuiAabb text_bb(bb.Min, bb.Min + ImVec2(window->FontSize() + style.FramePadding.x22,0) + text_size);
	4392	const ImGuiAabb text_bb(bb.Min, bb.Min + ImVec2(window->FontSize() + style.FramePadding.x22,0) + label_size);
4129	4393	ItemSize(ImVec2(text_bb.GetSize().x, bb.GetSize().y)); // NB: we don't provide our width so that it doesn't get feed back into AutoFit
4130	4394
4131	4395	// When logging is enabled, if automatically expand tree nodes (but NOT collapsing headers.. seems like sensible behaviour).
4132	4396	// NB- If we are above max depth we still allow manually opened nodes to be logged.
4133		if (!display_frame)
4134		if (g.LogEnabled && window->DC.TreeDepth < g.LogAutoExpandMaxDepth)
4135		opened = true;
	4397	if (g.LogEnabled && !display_frame && window->DC.TreeDepth < g.LogAutoExpandMaxDepth)
	4398	opened = true;
4136	4399
4137	4400	if (!ItemAdd(bb, &id))
4138	4401	return opened;
r244869	r244870
4179	4442	return opened;
4180	4443	}
4181	4444
	4445	void ImGui::Bullet()
	4446	{
	4447	ImGuiState& g = *GImGui;
	4448	ImGuiWindow* window = GetCurrentWindow();
	4449	if (window->SkipItems)
	4450	return;
	4451
	4452	const ImGuiStyle& style = g.Style;
	4453	const float line_height = window->FontSize();
	4454	const ImGuiAabb bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(line_height, line_height));
	4455	ItemSize(bb);
	4456	if (!ItemAdd(bb, NULL))
	4457	return;
	4458
	4459	// Render
	4460	const float bullet_size = line_height*0.15f;
	4461	window->DrawList->AddCircleFilled(bb.Min + ImVec2(style.FramePadding.x + line_height0.5f, line_height0.5f), bullet_size, window->Color(ImGuiCol_Text));
	4462
	4463	// Stay on same line
	4464	ImGui::SameLine(0, -1);
	4465	}
	4466
4182	4467	// Text with a little bullet aligned to the typical tree node.
4183	4468	void ImGui::BulletTextV(const char* fmt, va_list args)
4184	4469	{
r244869	r244870
4187	4472	if (window->SkipItems)
4188	4473	return;
4189	4474
4190		const ImGuiStyle& style = g.Style;
4191
4192	4475	static char buf[1024];
4193	4476	const char* text_begin = buf;
4194	4477	const char* text_end = text_begin + ImFormatStringV(buf, IM_ARRAYSIZE(buf), fmt, args);
4195	4478
	4479	const ImGuiStyle& style = g.Style;
4196	4480	const float line_height = window->FontSize();
4197		const ImVec2 text_size = CalcTextSize(text_begin, text_end, true);
4198		const ImGuiAabb bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(line_height + (text_size.x > 0.0f ? (style.FramePadding.x*2) : 0.0f),0) + text_size); // Empty text doesn't add padding
	4481	const ImVec2 label_size = CalcTextSize(text_begin, text_end, true);
	4482	const ImGuiAabb bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(line_height + (label_size.x > 0.0f ? (style.FramePadding.x*2) : 0.0f),0) + label_size); // Empty text doesn't add padding
4199	4483	ItemSize(bb);
4200	4484	if (!ItemAdd(bb, NULL))
4201	4485	return;
r244869	r244870
4275	4559	return TreeNode(str_label_id, "%s", str_label_id);
4276	4560	}
4277	4561
4278		void ImGui::OpenNextNode(bool open)
	4562	void ImGui::SetNextTreeNodeOpened(bool opened, ImGuiSetCond cond)
4279	4563	{
4280		ImGuiWindow* window = GetCurrentWindow();
4281		window->DC.OpenNextNode = open ? 1 : 0;
	4564	ImGuiState& g = *GImGui;
	4565	g.SetNextTreeNodeOpenedVal = opened;
	4566	g.SetNextTreeNodeOpenedCond = cond ? cond : ImGuiSetCond_Always;
4282	4567	}
4283	4568
4284	4569	void ImGui::PushID(const char* str_id)
r244869	r244870
4322	4607	// NB: only call right after InputText because we are using its InitialValue storage
4323	4608	static void ApplyNumericalTextInput(const char* buf, float *v)
4324	4609	{
4325		while (buf ~~== ' ' \|\| buf == '\t'~~)
	4610	while (ImCharIsSpace(*buf))
4326	4611	buf++;
4327	4612
4328	4613	// We don't support '-' op because it would conflict with inputing negative value.
r244869	r244870
4331	4616	if (op == '+' \|\| op == '*' \|\| op == '/')
4332	4617	{
4333	4618	buf++;
4334		while (buf ~~== ' ' \|\| buf == '\t'~~)
	4619	while (ImCharIsSpace(*buf))
4335	4620	buf++;
4336	4621	}
4337	4622	else
r244869	r244870
4395	4680	}
4396	4681	}
4397	4682
4398		const ImVec2 text_size = CalcTextSize(label, NULL, true);
4399		const ImGuiAabb frame_bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(w, text_size.y) + style.FramePadding*2.0f);
	4683	const ImVec2 label_size = CalcTextSize(label, NULL, true);
	4684	const ImGuiAabb frame_bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(w, label_size.y) + style.FramePadding*2.0f);
4400	4685	const ImGuiAabb slider_bb(frame_bb.Min + style.FramePadding, frame_bb.Max - style.FramePadding);
4401		const ImGuiAabb bb(frame_bb.Min, frame_bb.Max + ImVec2(text_size.x > 0.0f ? style.ItemInnerSpacing.x + text_size.x : 0.0f, 0.0f));
	4686	const ImGuiAabb bb(frame_bb.Min, frame_bb.Max + ImVec2(label_size.x > 0.0f ? style.ItemInnerSpacing.x + label_size.x : 0.0f, 0.0f));
4402	4687
4403	4688	// NB- we don't call ItemSize() yet becausae we may turn into a text edit box later in the function
4404	4689	if (!ItemAdd(slider_bb, &id))
r244869	r244870
4414	4699	const float grab_size_in_units = 1.0f; // In 'v' units. Probably needs to be parametrized, based on a 'v_step' value? decimal precision?
4415	4700	float grab_size_in_pixels;
4416	4701	if (decimal_precision > 0 \|\| is_unbound)
4417		grab_size_in_pixels = 10.0f;
	4702	grab_size_in_pixels = style.GrabMinSize;
4418	4703	else
4419		grab_size_in_pixels = ImMax(grab_size_in_units * (w / (v_max-v_min+1.0f)), 8.0f); // Integer sliders
	4704	grab_size_in_pixels = ImMax(grab_size_in_units * (w / (v_max-v_min+1.0f)), style.GrabMinSize); // Integer sliders
4420	4705	const float slider_effective_w = slider_bb.GetWidth() - grab_size_in_pixels;
4421	4706	const float slider_effective_x1 = slider_bb.Min.x + grab_size_in_pixels*0.5f;
4422	4707	const float slider_effective_x2 = slider_bb.Max.x - grab_size_in_pixels*0.5f;
r244869	r244870
4471	4756	if (g.SliderAsInputTextId == 0)
4472	4757	{
4473	4758	// First frame
4474		IM_ASSERT(g.ActiveId == id); // InputText ID ~~shoul~~d match the Slider ID (else we'd need to store them both which is also possible)
	4759	IM_ASSERT(g.ActiveId == id); // InputText ID expected to match the Slider ID (else we'd need to store them both, which is also possible)
4475	4760	g.SliderAsInputTextId = g.ActiveId;
4476		SetActiveId(id);
4477	4761	g.HoveredId = id;
4478	4762	}
4479		else
	4763	else if (g.ActiveId != g.SliderAsInputTextId)
4480	4764	{
4481		if (g.ActiveId == g.SliderAsInputTextId)
4482		SetActiveId(id);
4483		else
4484		{
4485		SetActiveId(0);
4486		g.SliderAsInputTextId = 0;
4487		}
	4765	// Release
	4766	g.SliderAsInputTextId = 0;
4488	4767	}
4489	4768	if (value_changed)
4490	4769	{
r244869	r244870
4579	4858
4580	4859	// Draw value using user-provided display format so user can add prefix/suffix/decorations to the value.
4581	4860	char value_buf[64];
4582		ImFormatString(value_buf, IM_ARRAYSIZE(value_buf), display_format, *v);
4583		RenderText(ImVec2(slider_bb.GetCenter().x-CalcTextSize(value_buf, NULL, true).x*0.5f, frame_bb.Min.y + style.FramePadding.y), value_buf);
	4861	char* value_buf_end = value_buf + ImFormatString(value_buf, IM_ARRAYSIZE(value_buf), display_format, *v);
	4862	const ImVec2 value_text_size = CalcTextSize(value_buf, value_buf_end, true);
	4863	RenderTextClipped(ImVec2(ImMax(frame_bb.Min.x + style.FramePadding.x, slider_bb.GetCenter().x - value_text_size.x*0.5f), frame_bb.Min.y + style.FramePadding.y), value_buf, value_buf_end, &value_text_size, frame_bb.Max);
4584	4864
4585	4865	RenderText(ImVec2(frame_bb.Max.x + style.ItemInnerSpacing.x, slider_bb.Min.y), label);
4586	4866
r244869	r244870
4721	5001
4722	5002	const ImGuiStyle& style = g.Style;
4723	5003
4724		const ImVec2 text_size = ImGui::CalcTextSize(label, NULL, true);
	5004	const ImVec2 label_size = ImGui::CalcTextSize(label, NULL, true);
4725	5005	if (graph_size.x == 0.0f)
4726	5006	graph_size.x = ImGui::CalcItemWidth();
4727	5007	if (graph_size.y == 0.0f)
4728		graph_size.y = text_size.y;
	5008	graph_size.y = label_size.y;
4729	5009
4730	5010	const ImGuiAabb frame_bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(graph_size.x, graph_size.y) + style.FramePadding*2.0f);
4731	5011	const ImGuiAabb graph_bb(frame_bb.Min + style.FramePadding, frame_bb.Max - style.FramePadding);
4732		const ImGuiAabb bb(frame_bb.Min, frame_bb.Max + ImVec2(text_size.x > 0.0f ? style.ItemInnerSpacing.x + text_size.x : 0.0f, 0));
	5012	const ImGuiAabb bb(frame_bb.Min, frame_bb.Max + ImVec2(label_size.x > 0.0f ? style.ItemInnerSpacing.x + label_size.x : 0.0f, 0));
4733	5013	ItemSize(bb);
4734	5014	if (!ItemAdd(bb, NULL))
4735	5015	return;
r244869	r244870
4854	5134
4855	5135	const ImGuiStyle& style = g.Style;
4856	5136	const ImGuiID id = window->GetID(label);
4857		const ImVec2 text_size = CalcTextSize(label, NULL, true);
	5137	const ImVec2 label_size = CalcTextSize(label, NULL, true);
4858	5138
4859		const ImGuiAabb check_bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(text_size.y + style.FramePadding.y2, text_size.y + style.FramePadding.y2));
	5139	const ImGuiAabb check_bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(label_size.y + style.FramePadding.y2, label_size.y + style.FramePadding.y2));
4860	5140	ItemSize(check_bb);
4861	5141
4862	5142	ImGuiAabb total_bb = check_bb;
4863		if (text_size.x > 0)
	5143	if (label_size.x > 0)
4864	5144	SameLine(0, (int)style.ItemInnerSpacing.x);
4865		const ImGuiAabb text_bb(window->DC.CursorPos + ImVec2(0,style.FramePadding.y), window->DC.CursorPos + ImVec2(0,style.FramePadding.y) + text_size);
4866		if (text_size.x > 0)
	5145	const ImGuiAabb text_bb(window->DC.CursorPos + ImVec2(0,style.FramePadding.y), window->DC.CursorPos + ImVec2(0,style.FramePadding.y) + label_size);
	5146	if (label_size.x > 0)
4867	5147	{
4868	5148	ItemSize(ImVec2(text_bb.GetWidth(), check_bb.GetHeight()));
4869	5149	total_bb = ImGuiAabb(ImMin(check_bb.Min, text_bb.Min), ImMax(check_bb.Max, text_bb.Max));
r244869	r244870
4912	5192
4913	5193	const ImGuiStyle& style = g.Style;
4914	5194	const ImGuiID id = window->GetID(label);
	5195	const ImVec2 label_size = CalcTextSize(label, NULL, true);
4915	5196
4916		const ImVec2 text_size = CalcTextSize(label, NULL, true);
4917
4918		const ImGuiAabb check_bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(text_size.y + style.FramePadding.y2-1, text_size.y + style.FramePadding.y2-1));
	5197	const ImGuiAabb check_bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(label_size.y + style.FramePadding.y2-1, label_size.y + style.FramePadding.y2-1));
4919	5198	ItemSize(check_bb);
4920	5199
4921	5200	ImGuiAabb total_bb = check_bb;
4922		if (text_size.x > 0)
	5201	if (label_size.x > 0)
4923	5202	SameLine(0, (int)style.ItemInnerSpacing.x);
4924		const ImGuiAabb text_bb(window->DC.CursorPos + ImVec2(0, style.FramePadding.y), window->DC.CursorPos + ImVec2(0, style.FramePadding.y) + text_size);
4925		if (text_size.x > 0)
	5203	const ImGuiAabb text_bb(window->DC.CursorPos + ImVec2(0, style.FramePadding.y), window->DC.CursorPos + ImVec2(0, style.FramePadding.y) + label_size);
	5204	if (label_size.x > 0)
4926	5205	{
4927	5206	ItemSize(ImVec2(text_bb.GetWidth(), check_bb.GetHeight()));
4928	5207	total_bb.Add(text_bb);
r244869	r244870
4988	5267	r->num_chars = (int)(text_remaining - (obj->Text + line_start_idx));
4989	5268	}
4990	5269
4991		static bool is_white(unsigned int c) { return c==0 \|\| c==' ' \|\| c=='\t' \|\| c=='\r' \|\| c=='\n'; }
4992	5270	static bool is_separator(unsigned int c) { return c==',' \|\| c==';' \|\| c=='(' \|\| c==')' \|\| c=='{' \|\| c=='}' \|\| c=='[' \|\| c==']' \|\| c=='\|'; }
4993		#define STB_TEXTEDIT_IS_SPACE(CH) ( is_white((unsigned int)CH) \|\| is_separator((unsigned int)CH) )
4994		static void STB_TEXTEDIT_DELETECHARS(STB_TEXTEDIT_STRING* obj, int pos, int n) { ImWchar* dst = obj->Text+pos; const ImWchar* src = obj->Text+pos+n; while (ImWchar c = src++) dst++ = c; *dst = '\0'; }
	5271	#define STB_TEXTEDIT_IS_SPACE(CH) ( ImCharIsSpace((unsigned int)CH) \|\| is_separator((unsigned int)CH) )
	5272	static void STB_TEXTEDIT_DELETECHARS(STB_TEXTEDIT_STRING* obj, int pos, int n)
	5273	{
	5274	ImWchar* dst = obj->Text + pos;
	5275
	5276	// We maintain our buffer length in both UTF-8 and wchar formats
	5277	obj->CurLenA -= ImTextCountUtf8BytesFromStr(dst, dst + n);
	5278	obj->CurLenW -= n;
	5279
	5280	// Offset remaining text
	5281	const ImWchar* src = obj->Text + pos + n;
	5282	while (ImWchar c = *src++)
	5283	*dst++ = c;
	5284	*dst = '\0';
	5285	}
	5286
4995	5287	static bool STB_TEXTEDIT_INSERTCHARS(STB_TEXTEDIT_STRING* obj, int pos, const ImWchar* new_text, int new_text_len)
4996	5288	{
4997		const size_t text_len = ImStrlenW(obj->Text);
4998		if ((size_t)new_text_len + text_len + 1 >= obj->BufSize)
	5289	const size_t text_len = obj->CurLenW;
	5290	if ((size_t)new_text_len + text_len + 1 > IM_ARRAYSIZE(obj->Text))
4999	5291	return false;
5000	5292
	5293	const int new_text_len_utf8 = ImTextCountUtf8BytesFromStr(new_text, new_text + new_text_len);
	5294	if ((size_t)new_text_len_utf8 + obj->CurLenA + 1 > obj->BufSizeA)
	5295	return false;
	5296
5001	5297	if (pos != (int)text_len)
5002	5298	memmove(obj->Text + (size_t)pos + new_text_len, obj->Text + (size_t)pos, (text_len - (size_t)pos) * sizeof(ImWchar));
5003	5299	memcpy(obj->Text + (size_t)pos, new_text, (size_t)new_text_len * sizeof(ImWchar));
5004		obj->Text[text_len + (size_t)new_text_len] = '\0';
5005	5300
	5301	obj->CurLenW += new_text_len;
	5302	obj->CurLenA += new_text_len_utf8;
	5303	obj->Text[obj->CurLenW] = '\0';
	5304
5006	5305	return true;
5007	5306	}
5008	5307
r244869	r244870
5096	5395	const char* text_start = GetTextPointerClippedA(font, font_size, buf, scroll_x, NULL);
5097	5396	const char* text_end = GetTextPointerClippedA(font, font_size, text_start, width, &text_size);
5098	5397
	5398	// We need to test for the possibility of malformed UTF-8 (instead of just text_end[0] != 0)
	5399	unsigned int text_end_char = 0;
	5400	ImTextCharFromUtf8(&text_end_char, text_end, NULL);
	5401
5099	5402	// Draw a little clip symbol if we've got text on either left or right of the box
5100	5403	const char symbol_c = '~';
5101	5404	const float symbol_w = font_size*0.40f; // FIXME: compute correct width
5102	5405	const float clip_begin = (text_start > buf && text_start < text_end) ? symbol_w : 0.0f;
5103		const float clip_end = (text_end~~[0]~~ != '\0' && text_end > text_start) ? symbol_w : 0.0f;
	5406	const float clip_end = (text_end_char != 0 && text_end > text_start) ? symbol_w : 0.0f;
5104	5407
5105	5408	// Draw text
5106	5409	RenderText(pos+ImVec2(clip_begin,0), text_start+(clip_begin>0.0f?1:0), text_end-(clip_end>0.0f?1:0), false);
r244869	r244870
5122	5425
5123	5426	const ImGuiStyle& style = g.Style;
5124	5427	const float w = ImGui::CalcItemWidth();
5125		const ImVec2 text_size = CalcTextSize(label, NULL, true);
5126		const ImGuiAabb frame_bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(w, text_size.y) + style.FramePadding*2.0f);
	5428	const ImVec2 label_size = CalcTextSize(label, NULL, true);
	5429	const ImGuiAabb frame_bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(w, label_size.y) + style.FramePadding*2.0f);
5127	5430
5128	5431	ImGui::PushID(label);
5129	5432	const float button_sz = window->FontSize();
r244869	r244870
5163	5466
5164	5467	ImGui::PopID();
5165	5468
5166		if (text_size.x > 0)
	5469	if (label_size.x > 0)
5167	5470	{
5168	5471	ImGui::SameLine(0, (int)style.ItemInnerSpacing.x);
5169		ItemSize(text_size);
	5472	ItemSize(label_size);
5170	5473	RenderText(ImVec2(frame_bb.Max.x + style.ItemInnerSpacing.x, frame_bb.Min.y + style.FramePadding.y), label);
5171	5474	}
5172	5475
r244869	r244870
5222	5525	SelectionStart = SelectionEnd = CursorPos;
5223	5526	}
5224	5527
5225		static bool InputTextFilterCharacter(ImWchar c, ImGuiInputTextFlags flags)
	5528	// Return false to discard a character.
	5529	static bool InputTextFilterCharacter(unsigned int* p_char, ImGuiInputTextFlags flags, ImGuiTextEditCallback callback, void* user_data)
5226	5530	{
	5531	unsigned int c = *p_char;
	5532
5227	5533	if (c < 128 && c != ' ' && !isprint((int)(c & 0xFF)))
5228		return ~~tru~~e;
	5534	return false;
5229	5535
5230	5536	if (c >= 0xE000 && c <= 0xF8FF) // Filter private Unicode range. I don't imagine anybody would want to input them. GLFW on OSX seems to send private characters for special keys like arrow keys.
5231		return ~~tru~~e;
	5537	return false;
5232	5538
5233		if (flags & ImGuiInputTextFlags_CharsDecimal)
5234		if (!(c >= '0' && c <= '9') && (c != '.') && (c != '-') && (c != '+') && (c != '*') && (c != '/'))
5235		return true;
	5539	if (flags & (ImGuiInputTextFlags_CharsDecimal \| ImGuiInputTextFlags_CharsHexadecimal \| ImGuiInputTextFlags_CharsUppercase \| ImGuiInputTextFlags_CharsNoBlank))
	5540	{
	5541	if (flags & ImGuiInputTextFlags_CharsDecimal)
	5542	if (!(c >= '0' && c <= '9') && (c != '.') && (c != '-') && (c != '+') && (c != '*') && (c != '/'))
	5543	return false;
5236	5544
5237		if (flags & ImGuiInputTextFlags_CharsHexadecimal)
5238		if (!(c >= '0' && c <= '9') && !(c >= 'a' && c <= 'f') && !(c >= 'A' && c <= 'F'))
5239		return true;
	5545	if (flags & ImGuiInputTextFlags_CharsHexadecimal)
	5546	if (!(c >= '0' && c <= '9') && !(c >= 'a' && c <= 'f') && !(c >= 'A' && c <= 'F'))
	5547	return false;
5240	5548
5241		return false;
	5549	if (flags & ImGuiInputTextFlags_CharsUppercase)
	5550	if (c >= 'a' && c <= 'z')
	5551	*p_char = (c += (unsigned int)('A'-'a'));
	5552
	5553	if (flags & ImGuiInputTextFlags_CharsNoBlank)
	5554	if (ImCharIsSpace(c))
	5555	return false;
	5556	}
	5557
	5558	if (flags & ImGuiInputTextFlags_CallbackCharFilter)
	5559	{
	5560	ImGuiTextEditCallbackData callback_data;
	5561	memset(&callback_data, 0, sizeof(ImGuiTextEditCallbackData));
	5562	callback_data.EventFlag = ImGuiInputTextFlags_CallbackCharFilter;
	5563	callback_data.EventChar = c;
	5564	callback_data.Flags = flags;
	5565	callback_data.UserData = user_data;
	5566	if (callback(&callback_data) != 0)
	5567	return false;
	5568	*p_char = callback_data.EventChar;
	5569	if (!callback_data.EventChar)
	5570	return false;
	5571	}
	5572
	5573	return true;
5242	5574	}
5243	5575
5244	5576	// Edit a string of text
5245		bool ImGui::InputText(const char* label, char* buf, size_t buf_size, ImGuiInputTextFlags flags, ~~void (callback)(~~ImGuiTextEditCallbackData), void* user_data)
	5577	bool ImGui::InputText(const char* label, char* buf, size_t buf_size, ImGuiInputTextFlags flags, ImGuiTextEditCallback callback, void* user_data)
5246	5578	{
5247	5579	ImGuiState& g = *GImGui;
5248	5580	ImGuiWindow* window = GetCurrentWindow();
r244869	r244870
5255	5587	const ImGuiID id = window->GetID(label);
5256	5588	const float w = ImGui::CalcItemWidth();
5257	5589
5258		const ImVec2 text_size = CalcTextSize(label, NULL, true);
5259		const ImGuiAabb frame_bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(w, text_size.y) + style.FramePadding*2.0f);
5260		const ImGuiAabb bb(frame_bb.Min, frame_bb.Max + ImVec2(text_size.x > 0.0f ? (style.ItemInnerSpacing.x + text_size.x) : 0.0f, 0.0f));
	5590	const ImVec2 label_size = CalcTextSize(label, NULL, true);
	5591	const ImGuiAabb frame_bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(w, label_size.y) + style.FramePadding*2.0f);
	5592	const ImGuiAabb bb(frame_bb.Min, frame_bb.Max + ImVec2(label_size.x > 0.0f ? (style.ItemInnerSpacing.x + label_size.x) : 0.0f, 0.0f));
5261	5593	ItemSize(bb);
5262	5594	if (!ItemAdd(frame_bb, &id))
5263	5595	return false;
r244869	r244870
5267	5599
5268	5600	const bool is_ctrl_down = io.KeyCtrl;
5269	5601	const bool is_shift_down = io.KeyShift;
5270		const bool tab_focus_requested = window->FocusItemRegister(g.ActiveId == id, (flags & ImGuiInputTextFlags_CallbackCompletion) == 0); // Using completion callback disable keyboard tabbing
5271		//const bool align_center = (bool)(flags & ImGuiInputTextFlags_AlignCenter); // FIXME: Unsupported
	5602	const bool focus_requested = window->FocusItemRegister(g.ActiveId == id, (flags & ImGuiInputTextFlags_CallbackCompletion) == 0); // Using completion callback disable keyboard tabbing
	5603	const bool focus_requested_by_code = focus_requested && (window->FocusIdxAllCounter == window->FocusIdxAllRequestCurrent);
	5604	const bool focus_requested_by_tab = focus_requested && !focus_requested_by_code;
5272	5605
5273	5606	const bool hovered = IsHovered(frame_bb, id);
5274	5607	if (hovered)
5275	5608	g.HoveredId = id;
	5609	const bool user_clicked = hovered && io.MouseClicked[0];
5276	5610
5277	5611	bool select_all = (g.ActiveId != id) && (flags & ImGuiInputTextFlags_AutoSelectAll) != 0;
5278		if (~~tab_~~focus_requested \|\| ~~(hovered && io.Mo~~useClicked~~[0])~~)
	5612	if (focus_requested \|\| user_clicked)
5279	5613	{
5280	5614	if (g.ActiveId != id)
5281	5615	{
5282	5616	// Start edition
5283	5617	// Take a copy of the initial buffer value (both in original UTF-8 format and converted to wchar)
	5618	// From the moment we focused we are ignoring the content of 'buf'
5284	5619	ImFormatString(edit_state.InitialText, IM_ARRAYSIZE(edit_state.InitialText), "%s", buf);
5285		ImTextStrFromUtf8(edit_state.Text, IM_ARRAYSIZE(edit_state.Text), buf, NULL);
5286		edit_state.ScrollX = 0.0f;
	5620	const char* buf_end = NULL;
	5621	edit_state.CurLenW = ImTextStrFromUtf8(edit_state.Text, IM_ARRAYSIZE(edit_state.Text), buf, NULL, &buf_end);
	5622	edit_state.CurLenA = buf_end - buf; // We can't get the result from ImFormatString() above because it is not UTF-8 aware. Here we'll cut off malformed UTF-8.
5287	5623	edit_state.Width = w;
5288		~~stb_t~~e~~xte~~dit_~~initialize_~~state~~(&edi~~t_s~~tate.~~S~~tbStat~~e, ~~tru~~e);
	5624	edit_state.InputCursorScreenPos = ImVec2(-1.f,-1.f);
5289	5625	edit_state.CursorAnimReset();
5290		edit_state.LastCursorPos = ImVec2(-1.f,-1.f);
5291	5626
5292		if (tab_focus_requested \|\| is_ctrl_down)
	5627	if (edit_state.Id != id)
	5628	{
	5629	edit_state.Id = id;
	5630	edit_state.ScrollX = 0.0f;
	5631	stb_textedit_initialize_state(&edit_state.StbState, true);
	5632	if (focus_requested_by_code)
	5633	select_all = true;
	5634	}
	5635	else
	5636	{
	5637	// Recycle existing cursor/selection/undo stack but clamp position
	5638	// Note a single mouse click will override the cursor/position immediately by calling stb_textedit_click handler.
	5639	edit_state.StbState.cursor = ImMin(edit_state.StbState.cursor, edit_state.CurLenW);
	5640	edit_state.StbState.select_start = ImMin(edit_state.StbState.select_start, edit_state.CurLenW);
	5641	edit_state.StbState.select_end = ImMin(edit_state.StbState.select_end, edit_state.CurLenW);
	5642	}
	5643	if (focus_requested_by_tab \|\| (user_clicked && is_ctrl_down))
5293	5644	select_all = true;
5294	5645	}
5295	5646	SetActiveId(id);
r244869	r244870
5304	5655	}
5305	5656	}
5306	5657
	5658	// Although we are active we don't prevent mouse from hovering other elements unless we are interacting right now with the widget.
	5659	// Down the line we should have a cleaner concept of focused vs active in the library.
	5660	if (g.ActiveId == id)
	5661	g.ActiveIdIsFocusedOnly = !io.MouseDown[0];
	5662
5307	5663	bool value_changed = false;
5308	5664	bool cancel_edit = false;
5309	5665	bool enter_pressed = false;
r244869	r244870
5311	5667	if (g.ActiveId == id)
5312	5668	{
5313	5669	// Edit in progress
5314		edit_state.BufSize = buf_size ~~< IM_ARRAYSIZE(edit_state.Text) ? buf_size : IM_ARRAYSIZE(edit_state.Text)~~;
	5670	edit_state.BufSizeA = buf_size;
5315	5671	edit_state.Font = window->Font();
5316	5672	edit_state.FontSize = window->FontSize();
5317	5673
r244869	r244870
5343	5699	// Process text input (before we check for Return because using some IME will effectively send a Return?)
5344	5700	for (int n = 0; n < IM_ARRAYSIZE(g.IO.InputCharacters) && g.IO.InputCharacters[n]; n++)
5345	5701	{
5346		const ~~ImW~~c~~har~~ c = g.IO.InputCharacters[n];
	5702	unsigned int c = (unsigned int)g.IO.InputCharacters[n];
5347	5703	if (c)
5348	5704	{
5349	5705	// Insert character if they pass filtering
5350		if (InputTextFilterCharacter(c, flags))
	5706	if (!InputTextFilterCharacter(&c, flags, callback, user_data))
5351	5707	continue;
5352		edit_state.OnKeyPressed(c);
	5708	edit_state.OnKeyPressed((int)c);
5353	5709	}
5354	5710	}
5355	5711
r244869	r244870
5379	5735	if (g.IO.SetClipboardTextFn)
5380	5736	{
5381	5737	const int ib = edit_state.HasSelection() ? ImMin(edit_state.StbState.select_start, edit_state.StbState.select_end) : 0;
5382		const int ie = edit_state.HasSelection() ? ImMax(edit_state.StbState.select_start, edit_state.StbState.select_end) : ~~(int)ImStrl~~e~~nW(e~~dit_state.Te~~xt)~~;
	5738	const int ie = edit_state.HasSelection() ? ImMax(edit_state.StbState.select_start, edit_state.StbState.select_end) : edit_state.CurLenW;
5383	5739	ImTextStrToUtf8(text_tmp_utf8, IM_ARRAYSIZE(text_tmp_utf8), edit_state.Text+ib, edit_state.Text+ie);
5384	5740	g.IO.SetClipboardTextFn(text_tmp_utf8);
5385	5741	}
r244869	r244870
5395	5751	if (const char* clipboard = g.IO.GetClipboardTextFn())
5396	5752	{
5397	5753	// Remove new-line from pasted buffer
5398		size_t clipboard_len = strlen(clipboard);
	5754	const size_t clipboard_len = strlen(clipboard);
5399	5755	ImWchar* clipboard_filtered = (ImWchar)ImGui::MemAlloc((clipboard_len+1) sizeof(ImWchar));
5400	5756	int clipboard_filtered_len = 0;
5401	5757	for (const char* s = clipboard; *s; )
5402	5758	{
5403	5759	unsigned int c;
5404		const int bytes_count = ImTextCharFromUtf8(&c, s, NULL);
5405		if (bytes_count <= 0)
	5760	s += ImTextCharFromUtf8(&c, s, NULL);
	5761	if (c == 0)
5406	5762	break;
5407		s += bytes_count;
5408	5763	if (c >= 0x10000)
5409	5764	continue;
5410		if (InputTextFilterCharacter(~~(ImW~~c~~har)c~~, flags))
	5765	if (!InputTextFilterCharacter(&c, flags, callback, user_data))
5411	5766	continue;
5412	5767	clipboard_filtered[clipboard_filtered_len++] = (ImWchar)c;
5413	5768	}
r244869	r244870
5442	5797	IM_ASSERT(callback != NULL);
5443	5798
5444	5799	// The reason we specify the usage semantic (Completion/History) is that Completion needs to disable keyboard TABBING at the moment.
	5800	ImGuiInputTextFlags event_flag = 0;
5445	5801	ImGuiKey event_key = ImGuiKey_COUNT;
5446	5802	if ((flags & ImGuiInputTextFlags_CallbackCompletion) != 0 && IsKeyPressedMap(ImGuiKey_Tab))
	5803	{
	5804	event_flag = ImGuiInputTextFlags_CallbackCompletion;
5447	5805	event_key = ImGuiKey_Tab;
	5806	}
5448	5807	else if ((flags & ImGuiInputTextFlags_CallbackHistory) != 0 && IsKeyPressedMap(ImGuiKey_UpArrow))
	5808	{
	5809	event_flag = ImGuiInputTextFlags_CallbackHistory;
5449	5810	event_key = ImGuiKey_UpArrow;
	5811	}
5450	5812	else if ((flags & ImGuiInputTextFlags_CallbackHistory) != 0 && IsKeyPressedMap(ImGuiKey_DownArrow))
	5813	{
	5814	event_flag = ImGuiInputTextFlags_CallbackHistory;
5451	5815	event_key = ImGuiKey_DownArrow;
	5816	}
5452	5817
5453	5818	if (event_key != ImGuiKey_COUNT \|\| (flags & ImGuiInputTextFlags_CallbackAlways) != 0)
5454	5819	{
5455	5820	ImGuiTextEditCallbackData callback_data;
	5821	callback_data.EventFlag = event_flag;
5456	5822	callback_data.EventKey = event_key;
5457	5823	callback_data.Buf = text_tmp_utf8;
5458		callback_data.BufSize = edit_state.BufSize;
	5824	callback_data.BufSize = edit_state.BufSizeA;
5459	5825	callback_data.BufDirty = false;
5460	5826	callback_data.Flags = flags;
5461	5827	callback_data.UserData = user_data;
5462	5828
5463	5829	// We have to convert from position from wchar to UTF-8 positions
5464		const int utf8_cursor_pos = callback_data.CursorPos = ImTextCountUtf8BytesFromWchar(edit_state.Text, edit_state.Text + edit_state.StbState.cursor);
5465		const int utf8_selection_start = callback_data.SelectionStart = ImTextCountUtf8BytesFromWchar(edit_state.Text, edit_state.Text + edit_state.StbState.select_start);
5466		const int utf8_selection_end = callback_data.SelectionEnd = ImTextCountUtf8BytesFromWchar(edit_state.Text, edit_state.Text + edit_state.StbState.select_end);
	5830	const int utf8_cursor_pos = callback_data.CursorPos = ImTextCountUtf8BytesFromStr(edit_state.Text, edit_state.Text + edit_state.StbState.cursor);
	5831	const int utf8_selection_start = callback_data.SelectionStart = ImTextCountUtf8BytesFromStr(edit_state.Text, edit_state.Text + edit_state.StbState.select_start);
	5832	const int utf8_selection_end = callback_data.SelectionEnd = ImTextCountUtf8BytesFromStr(edit_state.Text, edit_state.Text + edit_state.StbState.select_end);
5467	5833
5468	5834	// Call user code
5469	5835	callback(&callback_data);
5470	5836
5471	5837	// Read back what user may have modified
5472	5838	IM_ASSERT(callback_data.Buf == text_tmp_utf8); // Invalid to modify those fields
5473		IM_ASSERT(callback_data.BufSize == edit_state.BufSize);
	5839	IM_ASSERT(callback_data.BufSize == edit_state.BufSizeA);
5474	5840	IM_ASSERT(callback_data.Flags == flags);
5475	5841	if (callback_data.CursorPos != utf8_cursor_pos) edit_state.StbState.cursor = ImTextCountCharsFromUtf8(callback_data.Buf, callback_data.Buf + callback_data.CursorPos);
5476	5842	if (callback_data.SelectionStart != utf8_selection_start) edit_state.StbState.select_start = ImTextCountCharsFromUtf8(callback_data.Buf, callback_data.Buf + callback_data.SelectionStart);
r244869	r244870
5509	5875	}
5510	5876	}
5511	5877
5512		// FIXME: 'align_center' unsupported
5513	5878	ImGuiTextEditState::RenderTextScrolledClipped(window->Font(), window->FontSize(), buf, frame_bb.Min + style.FramePadding, w, (g.ActiveId == id) ? edit_state.ScrollX : 0.0f);
5514	5879
5515	5880	if (g.ActiveId == id)
r244869	r244870
5520	5885	if (g.InputTextState.CursorIsVisible())
5521	5886	window->DrawList->AddRect(cursor_pos - font_off_up + ImVec2(0,2), cursor_pos + font_off_dn - ImVec2(0,3), window->Color(ImGuiCol_Text));
5522	5887
5523		// Notify OS of text input position
5524		if (io.ImeSetInputScreenPosFn && ImLengthSqr(edit_state.LastCursorPos - cursor_pos) > 0.0001f)
	5888	// Notify OS of text input position for advanced IME
	5889	if (io.ImeSetInputScreenPosFn && ImLengthSqr(edit_state.InputCursorScreenPos - cursor_pos) > 0.0001f)
5525	5890	io.ImeSetInputScreenPosFn((int)cursor_pos.x - 1, (int)(cursor_pos.y - window->FontSize())); // -1 x offset so that Windows IME can cover our cursor. Bit of an extra nicety.
5526	5891
5527		edit_state.~~Las~~tCursorPos = cursor_pos;
	5892	edit_state.InputCursorScreenPos = cursor_pos;
5528	5893	}
5529	5894
5530		RenderText(ImVec2(frame_bb.Max.x + style.ItemInnerSpacing.x, frame_bb.Min.y + style.FramePadding.y), label);
	5895	if (label_size.x > 0)
	5896	RenderText(ImVec2(frame_bb.Max.x + style.ItemInnerSpacing.x, frame_bb.Min.y + style.FramePadding.y), label);
5531	5897
5532	5898	if ((flags & ImGuiInputTextFlags_EnterReturnsTrue) != 0)
5533	5899	return enter_pressed;
r244869	r244870
5646	6012	const ImGuiID id = window->GetID(label);
5647	6013	const float w = ImGui::CalcItemWidth();
5648	6014
5649		const ImVec2 text_size = CalcTextSize(label, NULL, true);
5650		const ImGuiAabb frame_bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(w, text_size.y) + style.FramePadding*2.0f);
5651		ItemSize(frame_bb);
	6015	const ImVec2 label_size = CalcTextSize(label, NULL, true);
	6016	const ImGuiAabb frame_bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(w, label_size.y) + style.FramePadding*2.0f);
	6017	const ImGuiAabb bb(frame_bb.Min, frame_bb.Max + ImVec2(style.ItemInnerSpacing.x + label_size.x,0));
	6018	ItemSize(bb);
5652	6019	if (!ItemAdd(frame_bb, &id))
5653	6020	return false;
5654	6021
5655		const ImGuiAabb bb(frame_bb.Min, frame_bb.Max + ImVec2(style.ItemInnerSpacing.x + text_size.x,0));
5656	6022	const float arrow_size = (window->FontSize() + style.FramePadding.x * 2.0f);
5657	6023	const bool hovered = IsHovered(frame_bb, id);
5658	6024
r244869	r244870
5669	6035	RenderTextClipped(frame_bb.Min + style.FramePadding, item_text, NULL, NULL, value_bb.Max);
5670	6036	}
5671	6037
5672		// Empty text doesn't add padding
5673		if (text_size.x > 0)
5674		{
5675		ImGui::SameLine(0, (int)style.ItemInnerSpacing.x);
5676		ImGui::TextUnformatted(label, FindTextDisplayEnd(label));
5677		}
	6038	if (label_size.x > 0)
	6039	RenderText(ImVec2(frame_bb.Max.x + style.ItemInnerSpacing.x, frame_bb.Min.y + style.FramePadding.y), label);
5678	6040
5679	6041	ImGui::PushID((int)id);
5680	6042	bool menu_toggled = false;
r244869	r244870
5698	6060
5699	6061	const ImVec2 backup_pos = ImGui::GetCursorPos();
5700	6062	const float popup_off_x = 0.0f;//style.ItemInnerSpacing.x;
5701		const float popup_height = (text_size.y + style.ItemSpacing.y) * ImMin(items_count, height_in_items) + style.WindowPadding.y;
	6063	const float popup_height = (label_size.y + style.ItemSpacing.y) * ImMin(items_count, height_in_items) + style.WindowPadding.y;
5702	6064	const ImGuiAabb popup_aabb(ImVec2(frame_bb.Min.x+popup_off_x, frame_bb.Max.y), ImVec2(frame_bb.Max.x+popup_off_x, frame_bb.Max.y + popup_height));
5703	6065	ImGui::SetCursorPos(popup_aabb.Min - window->Pos);
5704	6066
r244869	r244870
5752	6114
5753	6115	const ImGuiStyle& style = g.Style;
5754	6116	const ImGuiID id = window->GetID(label);
5755		const ImVec2 text_size = CalcTextSize(label, NULL, true);
	6117	const ImVec2 label_size = CalcTextSize(label, NULL, true);
5756	6118
5757	6119	const float w = window->Pos.x + ImGui::GetContentRegionMax().x - window->DC.CursorPos.x;
5758		const ImVec2 size(size_arg.x != 0.0f ? size_arg.x : w, size_arg.y != 0.0f ? size_arg.y : text_size.y);
	6120	const ImVec2 size(size_arg.x != 0.0f ? size_arg.x : w, size_arg.y != 0.0f ? size_arg.y : label_size.y);
5759	6121	const ImGuiAabb bb(window->DC.CursorPos, window->DC.CursorPos + size);
5760	6122	ItemSize(bb);
5761	6123
r244869	r244870
5783	6145	}
5784	6146
5785	6147	//const ImVec2 off = ImVec2(ImMax(0.0f, size.x - text_size.x) * 0.5f, ImMax(0.0f, size.y - text_size.y) * 0.5f);
5786		RenderTextClipped(bb.Min, label, NULL, &text_size, bb_with_spacing.Max);
	6148	RenderTextClipped(bb.Min, label, NULL, &label_size, bb_with_spacing.Max);
5787	6149
5788	6150	return pressed;
5789	6151	}
r244869	r244870
5803	6165	bool ImGui::ListBoxHeader(const char* label, const ImVec2& size_arg)
5804	6166	{
5805	6167	ImGuiWindow* window = GetCurrentWindow();
5806		if (window->SkipItems)
5807		return false;
5808	6168
5809	6169	const ImGuiStyle& style = ImGui::GetStyle();
5810	6170	const ImGuiID id = ImGui::GetID(label);
r244869	r244870
5816	6176	size.y = (size_arg.y != 0.0f) ? size_arg.y : ImGui::GetTextLineHeightWithSpacing() * 7.4f + style.ItemSpacing.y;
5817	6177	const ImVec2 frame_size = ImVec2(size.x, ImMax(size.y, label_size.y));
5818	6178	const ImGuiAabb frame_bb(window->DC.CursorPos, window->DC.CursorPos + frame_size);
	6179	const ImGuiAabb bb(frame_bb.Min, frame_bb.Max + ImVec2(label_size.x > 0.0f ? style.ItemInnerSpacing.x + label_size.x : 0.0f, 0.0f));
	6180	window->DC.LastItemAabb = bb;
5819	6181
5820	6182	if (label_size.x > 0)
5821	6183	RenderText(ImVec2(frame_bb.Max.x + style.ItemInnerSpacing.x, frame_bb.Min.y + style.FramePadding.y), label);
r244869	r244870
5842	6204
5843	6205	void ImGui::ListBoxFooter()
5844	6206	{
	6207	ImGuiWindow* parent_window = GetParentWindow();
	6208	const ImGuiAabb bb = parent_window->DC.LastItemAabb;
	6209
5845	6210	ImGui::EndChildFrame();
	6211
	6212	parent_window->DC.CursorPos = bb.Min;
	6213	ItemSize(bb, NULL);
5846	6214	}
5847	6215
5848	6216	bool ImGui::ListBox(const char* label, int* current_item, const char** items, int items_count, int height_items)
r244869	r244870
5853	6221
5854	6222	bool ImGui::ListBox(const char* label, int* current_item, bool (items_getter)(void, int, const char*), void data, int items_count, int height_in_items)
5855	6223	{
	6224	ImGuiWindow* window = GetCurrentWindow();
	6225	if (window->SkipItems)
	6226	return false;
	6227
5856	6228	if (!ImGui::ListBoxHeader(label, items_count, height_in_items))
5857	6229	return false;
5858	6230
r244869	r244870
5886	6258	return false;
5887	6259
5888	6260	const ImGuiStyle& style = g.Style;
5889		const ImGuiID id = window->GetID("##colorbutton");
	6261	const ImGuiID id = window->GetID("#colorbutton");
5890	6262	const float square_size = window->FontSize();
5891	6263	const ImGuiAabb bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(square_size + style.FramePadding.x2, square_size + (small_height ? 0 : style.FramePadding.y2)));
5892	6264	ItemSize(bb);
r244869	r244870
6006	6378	value_changed \|= ImGui::InputText("##Text", buf, IM_ARRAYSIZE(buf), ImGuiInputTextFlags_CharsHexadecimal);
6007	6379	ImGui::PopItemWidth();
6008	6380	char* p = buf;
6009		while (p == '#' \|\| p ~~== ' ' \|\|~~ *p ~~== '\t'~~)
	6381	while (p == '#' \|\| ImCharIsSpace(p))
6010	6382	p++;
6011	6383
6012	6384	// Treat at unsigned (%X is unsigned)
r244869	r244870
6094	6466	window->DrawList->AddLine(bb.Min, bb.Max, window->Color(ImGuiCol_Border));
6095	6467
6096	6468	if (window->DC.ColumnsCount > 1)
	6469	{
6097	6470	PushColumnClipRect();
	6471	window->DC.ColumnsCellMinY = window->DC.CursorPos.y;
	6472	}
6098	6473	}
6099	6474
6100	6475	// A little vertical spacing.
r244869	r244870
6123	6498	window->DC.CursorPosPrevLine = ImVec2(window->DC.CursorPos.x + size.x, window->DC.CursorPos.y);
6124	6499	window->DC.CursorPos = ImVec2((float)(int)(window->Pos.x + window->DC.ColumnsStartX + window->DC.ColumnsOffsetX), (float)(int)(window->DC.CursorPos.y + line_height + g.Style.ItemSpacing.y));
6125	6500
6126		window->SizeContentsFit = ImMax(window->SizeContentsFit, ImVec2(window->DC.CursorPosPrevLine.x, window->DC.CursorPos.y) - window->Pos + ~~ImVec2(0.0f,~~ window->~~Scr~~o~~llY~~));
	6501	window->SizeContentsCurrent = ImMax(window->SizeContentsCurrent, ImVec2(window->DC.CursorPosPrevLine.x - window->Pos.x, window->DC.CursorPos.y + window->ScrollY - window->Pos.y));
6127	6502
6128	6503	window->DC.PrevLineHeight = line_height;
6129	6504	window->DC.CurrentLineHeight = 0.0f;
6130	6505	}
6131	6506
6132		static void ItemSize(const ImGuiAabb& aabb, ImVec2* adjust_start_offset)
	6507	static void ItemSize(const ImGuiAabb& bb, ImVec2* adjust_start_offset)
6133	6508	{
6134		ItemSize(aabb.GetSize(), adjust_start_offset);
	6509	ItemSize(bb.GetSize(), adjust_start_offset);
6135	6510	}
6136	6511
6137	6512	static bool IsClipped(const ImGuiAabb& bb)
r244869	r244870
6160	6535	window->DC.LastItemHovered = false;
6161	6536	return false;
6162	6537	}
6163		window->DC.LastItemHovered = IsMouseHoveringBox(bb); // this is a sensible default but widgets are free to override it after calling ItemAdd()
	6538
	6539	// This is a sensible default, but widgets are free to override it after calling ItemAdd()
	6540	const bool hovered = IsMouseHoveringBox(bb);
	6541	//const bool hovered = (g.ActiveId == 0 \|\| (id && g.ActiveId == *id) \|\| g.ActiveIdIsFocusedOnly) && IsMouseHoveringBox(bb); // matching the behaviour of IsHovered(), not always what the user wants?
	6542	window->DC.LastItemHovered = hovered;
6164	6543	return true;
6165	6544	}
6166	6545
r244869	r244870
6225	6604	}
6226	6605	}
6227	6606
6228		// FIMXE-OPT: This is called too often. We need to cache offset for active columns set.
	6607	int ImGui::GetColumnIndex()
	6608	{
	6609	ImGuiWindow* window = GetCurrentWindow();
	6610	return window->DC.ColumnsCurrent;
	6611	}
	6612
	6613	int ImGui::GetColumnsCount()
	6614	{
	6615	ImGuiWindow* window = GetCurrentWindow();
	6616	return window->DC.ColumnsCount;
	6617	}
	6618
6229	6619	float ImGui::GetColumnOffset(int column_index)
6230	6620	{
6231	6621	ImGuiState& g = *GImGui;
r244869	r244870
6233	6623	if (column_index < 0)
6234	6624	column_index = window->DC.ColumnsCurrent;
6235	6625
6236		const ImGuiID column_id = window->DC.ColumnsSetID + ImGuiID(column_index);
6237		RegisterAliveId(column_id);
6238		const float default_t = column_index / (float)window->DC.ColumnsCount;
6239		const float t = window->StateStorage.GetFloat(column_id, default_t); // Cheaply store our floating point value inside the integer (could store an union into the map?)
	6626	// Read from cache
	6627	IM_ASSERT(column_index < (int)window->DC.ColumnsOffsetsT.size());
	6628	const float t = window->DC.ColumnsOffsetsT[column_index];
6240	6629
6241		const float offset = window->DC.ColumnsStartX + t * (window->Size.x - g.Style.ScrollBarWidth - window->DC.ColumnsStartX);
	6630	const float min_x = window->DC.ColumnsStartX;
	6631	const float max_x = window->Size.x - (g.Style.ScrollbarWidth);// - window->WindowPadding().x;
	6632	const float offset = min_x + t * (max_x - min_x);
6242	6633	return offset;
6243	6634	}
6244	6635
r244869	r244870
6249	6640	if (column_index < 0)
6250	6641	column_index = window->DC.ColumnsCurrent;
6251	6642
	6643	IM_ASSERT(column_index < (int)window->DC.ColumnsOffsetsT.size());
6252	6644	const ImGuiID column_id = window->DC.ColumnsSetID + ImGuiID(column_index);
6253		const float t = (offset - window->DC.ColumnsStartX) / (window->Size.x - g.Style.ScrollBarWidth - window->DC.ColumnsStartX);
6254		window->StateStorage.SetFloat(column_id, t);
	6645
	6646	const float min_x = window->DC.ColumnsStartX;
	6647	const float max_x = window->Size.x - (g.Style.ScrollbarWidth);// - window->WindowPadding().x;
	6648	const float t = (offset - min_x) / (max_x - min_x);
	6649	window->DC.StateStorage->SetFloat(column_id, t);
	6650	window->DC.ColumnsOffsetsT[column_index] = t;
6255	6651	}
6256	6652
6257	6653	float ImGui::GetColumnWidth(int column_index)
r244869	r244870
6279	6675	{
6280	6676	ImGuiState& g = *GImGui;
6281	6677	ImGuiWindow* window = GetCurrentWindow();
6282		if (window->SkipItems)
6283		return;
6284	6678
6285	6679	if (window->DC.ColumnsCount != 1)
6286	6680	{
r244869	r244870
6294	6688	}
6295	6689
6296	6690	// Draw columns borders and handle resize at the time of "closing" a columns set
6297		if (window->DC.ColumnsCount != columns_count && window->DC.ColumnsCount != 1 && window->DC.ColumnsShowBorders)
	6691	if (window->DC.ColumnsCount != columns_count && window->DC.ColumnsCount != 1 && window->DC.ColumnsShowBorders && !window->SkipItems)
6298	6692	{
6299	6693	const float y1 = window->DC.ColumnsStartPos.y;
6300	6694	const float y2 = window->DC.CursorPos.y;
r244869	r244870
6338	6732
6339	6733	if (window->DC.ColumnsCount != 1)
6340	6734	{
	6735	// Cache column offsets
	6736	window->DC.ColumnsOffsetsT.resize((size_t)columns_count + 1);
	6737	for (int column_index = 0; column_index < columns_count + 1; column_index++)
	6738	{
	6739	const ImGuiID column_id = window->DC.ColumnsSetID + ImGuiID(column_index);
	6740	RegisterAliveId(column_id);
	6741	const float default_t = column_index / (float)window->DC.ColumnsCount;
	6742	const float t = window->DC.StateStorage->GetFloat(column_id, default_t); // Cheaply store our floating point value inside the integer (could store an union into the map?)
	6743	window->DC.ColumnsOffsetsT[column_index] = t;
	6744	}
	6745
6341	6746	PushColumnClipRect();
6342	6747	ImGui::PushItemWidth(ImGui::GetColumnWidth() * 0.65f);
6343	6748	}
	6749	else
	6750	{
	6751	window->DC.ColumnsOffsetsT.resize(2);
	6752	window->DC.ColumnsOffsetsT[0] = 0.0f;
	6753	window->DC.ColumnsOffsetsT[1] = 1.0f;
	6754	}
6344	6755	}
6345	6756
6346	6757	void ImGui::TreePush(const char* str_id)
r244869	r244870
7146	7557	TexUvWhitePixel = ImVec2((TexExtraDataPos.x + 0.5f) / TexWidth, (TexExtraDataPos.y + 0.5f) / TexHeight);
7147	7558
7148	7559	// Draw a mouse cursor into texture
7149		// Because our font uses an alpha te~~xture~~, we have to spread the cursor in 2 parts (black/white) which will be rendered separately.
	7560	// Because our font uses a single color channel, we have to spread the cursor in 2 layers (black/white) which will be rendered separately.
7150	7561	const char cursor_pixels[] =
7151	7562	{
7152	7563	"X "
r244869	r244870
7195	7606	DisplayOffset = ImVec2(-0.5f, 0.5f);
7196	7607	ContainerAtlas = NULL;
7197	7608	Glyphs.clear();
	7609	FallbackGlyph = NULL;
	7610	FallbackXAdvance = 0.0f;
	7611	IndexXAdvance.clear();
7198	7612	IndexLookup.clear();
7199		FallbackGlyph = NULL;
7200	7613	}
7201	7614
7202	7615	// Retrieve list of range (2 int per range, values are inclusive)
r244869	r244870
7215	7628	static const ImWchar ranges[] =
7216	7629	{
7217	7630	0x0020, 0x00FF, // Basic Latin + Latin Supplement
7218		0x3040, 0x309F, // Hiragana, Katakana
	7631	0x3000, 0x30FF, // Punctuations, Hiragana, Katakana
	7632	0x31F0, 0x31FF, // Katakana Phonetic Extensions
7219	7633	0xFF00, 0xFFEF, // Half-width characters
7220	7634	0x4e00, 0x9FAF, // CJK Ideograms
7221	7635	0,
r244869	r244870
7263	7677	109,2,18,23,0,0,9,61,3,0,28,41,77,27,19,17,81,5,2,14,5,83,57,252,14,154,263,14,20,8,13,6,57,39,38,
7264	7678	};
7265	7679	static int ranges_unpacked = false;
7266		static ImWchar ranges[6 + ~~1 +~~ IM_ARRAYSIZE(offsets_from_0x4E00)*2] =
	7680	static ImWchar ranges[8 + IM_ARRAYSIZE(offsets_from_0x4E00)*2 + 1] =
7267	7681	{
7268	7682	0x0020, 0x00FF, // Basic Latin + Latin Supplement
7269		0x3040, 0x309F, // Hiragana, Katakana
	7683	0x3000, 0x30FF, // Punctuations, Hiragana, Katakana
	7684	0x31F0, 0x31FF, // Katakana Phonetic Extensions
7270	7685	0xFF00, 0xFFEF, // Half-width characters
7271		0,
7272	7686	};
7273	7687	if (!ranges_unpacked)
7274	7688	{
7275	7689	// Unpack
7276	7690	int codepoint = 0x4e00;
7277		ImWchar* dst = &ranges[6];
	7691	ImWchar* dst = &ranges[8];
7278	7692	for (int n = 0; n < IM_ARRAYSIZE(offsets_from_0x4E00); n++, dst += 2)
7279	7693	dst[0] = dst[1] = (ImWchar)(codepoint += (offsets_from_0x4E00[n] + 1));
7280	7694	dst[0] = 0;
r244869	r244870
7289	7703	for (size_t i = 0; i != Glyphs.size(); i++)
7290	7704	max_codepoint = ImMax(max_codepoint, (int)Glyphs[i].Codepoint);
7291	7705
	7706	IndexXAdvance.clear();
	7707	IndexXAdvance.resize((size_t)max_codepoint + 1);
7292	7708	IndexLookup.clear();
7293	7709	IndexLookup.resize((size_t)max_codepoint + 1);
7294		for (size_t i = 0; i < IndexLookup.size(); i++)
	7710	for (size_t i = 0; i < (size_t)max_codepoint + 1; i++)
	7711	{
	7712	IndexXAdvance[i] = -1.0f;
7295	7713	IndexLookup[i] = -1;
	7714	}
7296	7715	for (size_t i = 0; i < Glyphs.size(); i++)
7297		IndexLookup[(int)Glyphs[i].Codepoint] = (int)i;
	7716	{
	7717	const size_t codepoint = (int)Glyphs[i].Codepoint;
	7718	IndexXAdvance[codepoint] = Glyphs[i].XAdvance;
	7719	IndexLookup[codepoint] = (int)i;
	7720	}
7298	7721
7299	7722	// Create a glyph to handle TAB
7300	7723	// FIXME: Needs proper TAB handling but it needs to be contextualized (can arbitrary say that each string starts at "column 0"
7301		if (~~const ImFont::Glyph* space_glyph =~~ FindGlyph((unsigned short)' '))
	7724	if (FindGlyph((unsigned short)' '))
7302	7725	{
7303		Glyphs.resize(Glyphs.size() + 1);
	7726	if (Glyphs.back().Codepoint != '\t') // So we can call this function multiple times
	7727	Glyphs.resize(Glyphs.size() + 1);
7304	7728	ImFont::Glyph& tab_glyph = Glyphs.back();
7305		tab_glyph = *~~space_g~~lyph;
	7729	tab_glyph = *FindGlyph((unsigned short)' ');
7306	7730	tab_glyph.Codepoint = '\t';
7307	7731	tab_glyph.XAdvance *= 4;
7308		IndexLookup[(int)tab_glyph.Codepoint] = (int)(Glyphs.size()-1);
	7732	IndexXAdvance[(size_t)tab_glyph.Codepoint] = (float)tab_glyph.XAdvance;
	7733	IndexLookup[(size_t)tab_glyph.Codepoint] = (int)(Glyphs.size()-1);
7309	7734	}
	7735
	7736	FallbackGlyph = NULL;
	7737	FallbackGlyph = FindGlyph(FallbackChar);
	7738	FallbackXAdvance = FallbackGlyph ? FallbackGlyph->XAdvance : 0.0f;
	7739	for (size_t i = 0; i < (size_t)max_codepoint + 1; i++)
	7740	if (IndexXAdvance[i] < 0.0f)
	7741	IndexXAdvance[i] = FallbackXAdvance;
7310	7742	}
7311	7743
	7744	void ImFont::SetFallbackChar(ImWchar c)
	7745	{
	7746	FallbackChar = c;
	7747	BuildLookupTable();
	7748	}
	7749
7312	7750	const ImFont::Glyph* ImFont::FindGlyph(unsigned short c) const
7313	7751	{
7314	7752	if (c < (int)IndexLookup.size())
r244869	r244870
7322	7760
7323	7761	// Convert UTF-8 to 32-bits character, process single character input.
7324	7762	// Based on stb_from_utf8() from github.com/nothings/stb/
	7763	// We handle UTF-8 decoding error by skipping forward.
7325	7764	static int ImTextCharFromUtf8(unsigned int* out_char, const char* in_text, const char* in_text_end)
7326	7765	{
7327		if (*in_text != 0)
	7766	unsigned int c = (unsigned int)-1;
	7767	const unsigned char* str = (const unsigned char*)in_text;
	7768	if (!(*str & 0x80))
7328	7769	{
7329		unsigned int c = (unsigned int)-1;
7330		const unsigned char* str = (const unsigned char*)in_text;
7331		if (!(*str & 0x80))
7332		{
7333		c = (unsigned int)(*str++);
7334		*out_char = c;
7335		return 1;
7336		}
7337		if ((*str & 0xe0) == 0xc0)
7338		{
7339		if (in_text_end && in_text_end - (const char*)str < 2) return -1;
7340		if (*str < 0xc2) return -1;
7341		c = (unsigned int)((*str++ & 0x1f) << 6);
7342		if ((*str & 0xc0) != 0x80) return -1;
7343		c += (*str++ & 0x3f);
7344		*out_char = c;
7345		return 2;
7346		}
7347		if ((*str & 0xf0) == 0xe0)
7348		{
7349		if (in_text_end && in_text_end - (const char*)str < 3) return -1;
7350		if (*str == 0xe0 && (str[1] < 0xa0 \|\| str[1] > 0xbf)) return -1;
7351		if (*str == 0xed && str[1] > 0x9f) return -1; // str[1] < 0x80 is checked below
7352		c = (unsigned int)((*str++ & 0x0f) << 12);
7353		if ((*str & 0xc0) != 0x80) return -1;
7354		c += (unsigned int)((*str++ & 0x3f) << 6);
7355		if ((*str & 0xc0) != 0x80) return -1;
7356		c += (*str++ & 0x3f);
7357		*out_char = c;
7358		return 3;
7359		}
7360		if ((*str & 0xf8) == 0xf0)
7361		{
7362		if (in_text_end && in_text_end - (const char*)str < 4) return -1;
7363		if (*str > 0xf4) return -1;
7364		if (*str == 0xf0 && (str[1] < 0x90 \|\| str[1] > 0xbf)) return -1;
7365		if (*str == 0xf4 && str[1] > 0x8f) return -1; // str[1] < 0x80 is checked below
7366		c = (unsigned int)((*str++ & 0x07) << 18);
7367		if ((*str & 0xc0) != 0x80) return -1;
7368		c += (unsigned int)((*str++ & 0x3f) << 12);
7369		if ((*str & 0xc0) != 0x80) return -1;
7370		c += (unsigned int)((*str++ & 0x3f) << 6);
7371		if ((*str & 0xc0) != 0x80) return -1;
7372		c += (*str++ & 0x3f);
7373		// utf-8 encodings of values used in surrogate pairs are invalid
7374		if ((c & 0xFFFFF800) == 0xD800) return -1;
7375		*out_char = c;
7376		return 4;
7377		}
	7770	c = (unsigned int)(*str++);
	7771	*out_char = c;
	7772	return 1;
7378	7773	}
	7774	if ((*str & 0xe0) == 0xc0)
	7775	{
	7776	*out_char = 0;
	7777	if (in_text_end && in_text_end - (const char*)str < 2) return 0;
	7778	if (*str < 0xc2) return 0;
	7779	c = (unsigned int)((*str++ & 0x1f) << 6);
	7780	if ((*str & 0xc0) != 0x80) return 0;
	7781	c += (*str++ & 0x3f);
	7782	*out_char = c;
	7783	return 2;
	7784	}
	7785	if ((*str & 0xf0) == 0xe0)
	7786	{
	7787	*out_char = 0;
	7788	if (in_text_end && in_text_end - (const char*)str < 3) return 0;
	7789	if (*str == 0xe0 && (str[1] < 0xa0 \|\| str[1] > 0xbf)) return 0;
	7790	if (*str == 0xed && str[1] > 0x9f) return 0; // str[1] < 0x80 is checked below
	7791	c = (unsigned int)((*str++ & 0x0f) << 12);
	7792	if ((*str & 0xc0) != 0x80) return 0;
	7793	c += (unsigned int)((*str++ & 0x3f) << 6);
	7794	if ((*str & 0xc0) != 0x80) return 0;
	7795	c += (*str++ & 0x3f);
	7796	*out_char = c;
	7797	return 3;
	7798	}
	7799	if ((*str & 0xf8) == 0xf0)
	7800	{
	7801	*out_char = 0;
	7802	if (in_text_end && in_text_end - (const char*)str < 4) return 0;
	7803	if (*str > 0xf4) return 0;
	7804	if (*str == 0xf0 && (str[1] < 0x90 \|\| str[1] > 0xbf)) return 0;
	7805	if (*str == 0xf4 && str[1] > 0x8f) return 0; // str[1] < 0x80 is checked below
	7806	c = (unsigned int)((*str++ & 0x07) << 18);
	7807	if ((*str & 0xc0) != 0x80) return 0;
	7808	c += (unsigned int)((*str++ & 0x3f) << 12);
	7809	if ((*str & 0xc0) != 0x80) return 0;
	7810	c += (unsigned int)((*str++ & 0x3f) << 6);
	7811	if ((*str & 0xc0) != 0x80) return 0;
	7812	c += (*str++ & 0x3f);
	7813	// utf-8 encodings of values used in surrogate pairs are invalid
	7814	if ((c & 0xFFFFF800) == 0xD800) return 0;
	7815	*out_char = c;
	7816	return 4;
	7817	}
7379	7818	*out_char = 0;
7380	7819	return 0;
7381	7820	}
7382	7821
7383		static ptrdiff_t ImTextStrFromUtf8(ImWchar* buf, size_t buf_size, const char* in_text, const char* in_text_end)
	7822	static ptrdiff_t ImTextStrFromUtf8(ImWchar* buf, size_t buf_size, const char* in_text, const char* in_text_end, const char** in_text_remaining)
7384	7823	{
7385	7824	ImWchar* buf_out = buf;
7386	7825	ImWchar* buf_end = buf + buf_size;
r244869	r244870
7388	7827	{
7389	7828	unsigned int c;
7390	7829	in_text += ImTextCharFromUtf8(&c, in_text, in_text_end);
	7830	if (c == 0)
	7831	break;
7391	7832	if (c < 0x10000) // FIXME: Losing characters that don't fit in 2 bytes
7392	7833	*buf_out++ = (ImWchar)c;
7393	7834	}
7394	7835	*buf_out = 0;
	7836	if (in_text_remaining)
	7837	*in_text_remaining = in_text;
7395	7838	return buf_out - buf;
7396	7839	}
7397	7840
r244869	r244870
7402	7845	{
7403	7846	unsigned int c;
7404	7847	in_text += ImTextCharFromUtf8(&c, in_text, in_text_end);
	7848	if (c == 0)
	7849	break;
7405	7850	if (c < 0x10000)
7406	7851	char_count++;
7407	7852	}
r244869	r244870
7466	7911	return buf_out - buf;
7467	7912	}
7468	7913
7469		static int ImTextCountUtf8BytesFrom~~Wcha~~r(const ImWchar* in_text, const ImWchar* in_text_end)
	7914	static int ImTextCountUtf8BytesFromStr(const ImWchar* in_text, const ImWchar* in_text_end)
7470	7915	{
7471	7916	int bytes_count = 0;
7472	7917	while ((!in_text_end \|\| in_text < in_text_end) && *in_text)
r244869	r244870
7506	7951	const char* s = text;
7507	7952	while (s < text_end)
7508	7953	{
7509		unsigned int c;
7510		const int bytes_count = ImTextCharFromUtf8(&c, s, text_end);
7511		const char* next_s = s + (bytes_count > 0 ? bytes_count : 1);
	7954	unsigned int c = (unsigned int)*s;
	7955	const char* next_s;
	7956	if (c < 0x80)
	7957	next_s = s + 1;
	7958	else
	7959	next_s = s + ImTextCharFromUtf8(&c, s, text_end);
	7960	if (c == 0)
	7961	break;
7512	7962
7513	7963	if (c == '\n')
7514	7964	{
r244869	r244870
7518	7968	continue;
7519	7969	}
7520	7970
7521		float char_width = 0.0f;
7522		if (const Glyph* glyph = FindGlyph((unsigned short)c))
7523		char_width = glyph->XAdvance * scale;
7524
7525		if (c == ' ' \|\| c == '\t')
	7971	const float char_width = ((size_t)c < IndexXAdvance.size()) ? IndexXAdvance[(size_t)c] * scale : FallbackXAdvance;
	7972	if (ImCharIsSpace(c))
7526	7973	{
7527	7974	if (inside_word)
7528	7975	{
r244869	r244870
7604	8051	while (s < text_end)
7605	8052	{
7606	8053	const char c = *s;
7607		if (c ~~== ' ' \|\|~~ c ~~== '\t'~~) { s++; } else if (c == '\n') { s++; break; } else { break; }
	8054	if (ImCharIsSpace(c)) { s++; } else if (c == '\n') { s++; break; } else { break; }
7608	8055	}
7609	8056	continue;
7610	8057	}
7611	8058	}
7612	8059
7613	8060	// Decode and advance source (handle unlikely UTF-8 decoding failure by skipping to the next byte)
7614		unsigned int c;
7615		const int bytes_count = ImTextCharFromUtf8(&c, s, text_end);
7616		s += bytes_count > 0 ? bytes_count : 1;
	8061	unsigned int c = (unsigned int)*s;
	8062	if (c < 0x80)
	8063	{
	8064	s += 1;
	8065	}
	8066	else
	8067	{
	8068	s += ImTextCharFromUtf8(&c, s, text_end);
	8069	if (c == 0)
	8070	break;
	8071	}
7617	8072
7618	8073	if (c == '\n')
7619	8074	{
r244869	r244870
7623	8078	continue;
7624	8079	}
7625	8080
7626		float char_width = 0.0f;
7627		if (const Glyph* glyph = FindGlyph((unsigned short)c))
7628		char_width = glyph->XAdvance * scale;
7629
	8081	const float char_width = ((size_t)c < IndexXAdvance.size()) ? IndexXAdvance[(size_t)c] * scale : FallbackXAdvance;
7630	8082	if (line_width + char_width >= max_width)
7631	8083	break;
7632	8084
r244869	r244870
7670	8122	continue;
7671	8123	}
7672	8124
7673		float char_width = 0.0f;
7674		if (const Glyph* glyph = FindGlyph((unsigned short)c))
7675		char_width = glyph->XAdvance * scale;
7676
	8125	const float char_width = ((size_t)c < IndexXAdvance.size()) ? IndexXAdvance[(size_t)c] * scale : FallbackXAdvance;
7677	8126	if (line_width + char_width >= max_width)
7678	8127	break;
7679	8128
r244869	r244870
7740	8189	while (s < text_end)
7741	8190	{
7742	8191	const char c = *s;
7743		if (c ~~== ' ' \|\|~~ c ~~== '\t'~~) { s++; } else if (c == '\n') { s++; break; } else { break; }
	8192	if (ImCharIsSpace(c)) { s++; } else if (c == '\n') { s++; break; } else { break; }
7744	8193	}
7745	8194	continue;
7746	8195	}
7747	8196	}
7748	8197
7749	8198	// Decode and advance source (handle unlikely UTF-8 decoding failure by skipping to the next byte)
7750		unsigned int c;
7751		const int bytes_count = ImTextCharFromUtf8(&c, s, text_end);
7752		s += bytes_count > 0 ? bytes_count : 1;
	8199	unsigned int c = (unsigned int)*s;
	8200	if (c < 0x80)
	8201	{
	8202	s += 1;
	8203	}
	8204	else
	8205	{
	8206	s += ImTextCharFromUtf8(&c, s, text_end);
	8207	if (c == 0)
	8208	break;
	8209	}
7753	8210
7754	8211	if (c == '\n')
7755	8212	{
r244869	r244870
7831	8288
7832	8289	#if defined(_MSC_VER) && !defined(IMGUI_DISABLE_WIN32_DEFAULT_CLIPBOARD_FUNCS)
7833	8290
	8291	#ifndef _WINDOWS_
7834	8292	#define WIN32_LEAN_AND_MEAN
7835	8293	#include <windows.h>
	8294	#endif
7836	8295
7837	8296	// Win32 API clipboard implementation
7838		static const char* GetClipboardTextFn_DefaultImpl()
	8297	static const char* GetClipboardTextFn_DefaultImpl()
7839	8298	{
7840	8299	static char* buf_local = NULL;
7841	8300	if (buf_local)
r244869	r244870
7845	8304	}
7846	8305	if (!OpenClipboard(NULL))
7847	8306	return NULL;
7848		HANDLE buf_handle = GetClipboardData(CF_TEXT);
7849		if (buf_handle == NULL)
	8307	HANDLE wbuf_handle = GetClipboardData(CF_UNICODETEXT);
	8308	if (wbuf_handle == NULL)
7850	8309	return NULL;
7851		if (char* buf_global = (char*)GlobalLock(buf_handle))
7852		buf_local = ImStrdup(buf_global);
7853		GlobalUnlock(buf_handle);
	8310	if (ImWchar* wbuf_global = (ImWchar*)GlobalLock(wbuf_handle))
	8311	{
	8312	int buf_len = ImTextCountUtf8BytesFromStr(wbuf_global, NULL) + 1;
	8313	buf_local = (char)ImGui::MemAlloc(buf_len sizeof(char));
	8314	ImTextStrToUtf8(buf_local, buf_len, wbuf_global, NULL);
	8315	}
	8316	GlobalUnlock(wbuf_handle);
7854	8317	CloseClipboard();
7855	8318	return buf_local;
7856	8319	}
r244869	r244870
7860	8323	{
7861	8324	if (!OpenClipboard(NULL))
7862	8325	return;
7863		const char* text_end = text + strlen(text);
7864		const int buf_length = (int)(text_end - text) + 1;
7865		HGLOBAL buf_handle = GlobalAlloc(GMEM_MOVEABLE, (SIZE_T)buf_length * sizeof(char));
7866		if (buf_handle == NULL)
	8326
	8327	const int wbuf_length = ImTextCountCharsFromUtf8(text, NULL) + 1;
	8328	HGLOBAL wbuf_handle = GlobalAlloc(GMEM_MOVEABLE, (SIZE_T)wbuf_length * sizeof(ImWchar));
	8329	if (wbuf_handle == NULL)
7867	8330	return;
7868		char* buf_global = (char *)GlobalLock(buf_handle);
7869		memcpy(buf_global, text, (size_t)(text_end - text));
7870		buf_global[text_end - text] = 0;
7871		GlobalUnlock(buf_handle);
	8331	ImWchar* wbuf_global = (ImWchar*)GlobalLock(wbuf_handle);
	8332	ImTextStrFromUtf8(wbuf_global, wbuf_length, text, NULL);
	8333	GlobalUnlock(wbuf_handle);
7872	8334	EmptyClipboard();
7873		SetClipboardData(CF_TEXT, buf_handle);
	8335	SetClipboardData(CF_UNICODETEXT, wbuf_handle);
7874	8336	CloseClipboard();
7875	8337	}
7876	8338
7877	8339	#else
7878	8340
7879	8341	// Local ImGui-only clipboard implementation, if user hasn't defined better clipboard handlers
7880		static const char* GetClipboardTextFn_DefaultImpl()
	8342	static const char* GetClipboardTextFn_DefaultImpl()
7881	8343	{
7882	8344	return GImGui->PrivateClipboard;
7883	8345	}
r244869	r244870
7899	8361
7900	8362	#endif
7901	8363
	8364	#if defined(_MSC_VER) && !defined(IMGUI_DISABLE_WIN32_DEFAULT_IME_FUNCS)
	8365
	8366	#ifndef _WINDOWS_
	8367	#define WIN32_LEAN_AND_MEAN
	8368	#include <windows.h>
	8369	#endif
	8370	#include <Imm.h>
	8371	#pragma comment(lib, "imm32")
	8372
	8373	static void ImeSetInputScreenPosFn_DefaultImpl(int x, int y)
	8374	{
	8375	// Notify OS Input Method Editor of text input position
	8376	if (HWND hwnd = (HWND)GImGui->IO.ImeWindowHandle)
	8377	if (HIMC himc = ImmGetContext(hwnd))
	8378	{
	8379	COMPOSITIONFORM cf;
	8380	cf.ptCurrentPos.x = x;
	8381	cf.ptCurrentPos.y = y;
	8382	cf.dwStyle = CFS_FORCE_POSITION;
	8383	ImmSetCompositionWindow(himc, &cf);
	8384	}
	8385	}
	8386
	8387	#else
	8388
	8389	static void ImeSetInputScreenPosFn_DefaultImpl(int x, int y)
	8390	{
	8391	}
	8392
	8393	#endif
	8394
7902	8395	//-----------------------------------------------------------------------------
7903	8396	// HELP
7904	8397	//-----------------------------------------------------------------------------
r244869	r244870
7957	8450	ImGui::SliderFloat2("ItemInnerSpacing", (float*)&style.ItemInnerSpacing, 0.0f, 20.0f, "%.0f");
7958	8451	ImGui::SliderFloat2("TouchExtraPadding", (float*)&style.TouchExtraPadding, 0.0f, 10.0f, "%.0f");
7959	8452	ImGui::SliderFloat("TreeNodeSpacing", &style.TreeNodeSpacing, 0.0f, 20.0f, "%.0f");
7960		ImGui::SliderFloat("ScrollBarWidth", &style.ScrollBarWidth, 0.0f, 20.0f, "%.0f");
	8453	ImGui::SliderFloat("ScrollBarWidth", &style.ScrollbarWidth, 1.0f, 20.0f, "%.0f");
	8454	ImGui::SliderFloat("GrabMinSize", &style.GrabMinSize, 1.0f, 20.0f, "%.0f");
7961	8455	ImGui::TreePop();
7962	8456	}
7963	8457
r244869	r244870
8028	8522	static void ShowExampleAppLongText(bool* opened);
8029	8523	static void ShowExampleAppAutoResize(bool* opened);
8030	8524	static void ShowExampleAppFixedOverlay(bool* opened);
	8525	static void ShowExampleAppManipulatingWindowTitle(bool* opened);
8031	8526	static void ShowExampleAppCustomRendering(bool* opened);
8032	8527
8033	8528	// Demonstrate ImGui features (unfortunately this makes this function a little bloated!)
8034	8529	void ImGui::ShowTestWindow(bool* opened)
8035	8530	{
	8531	// Examples apps
	8532	static bool show_app_console = false;
	8533	static bool show_app_long_text = false;
	8534	static bool show_app_auto_resize = false;
	8535	static bool show_app_fixed_overlay = false;
	8536	static bool show_app_custom_rendering = false;
	8537	static bool show_app_manipulating_window_title = false;
	8538	if (show_app_console)
	8539	ShowExampleAppConsole(&show_app_console);
	8540	if (show_app_long_text)
	8541	ShowExampleAppLongText(&show_app_long_text);
	8542	if (show_app_auto_resize)
	8543	ShowExampleAppAutoResize(&show_app_auto_resize);
	8544	if (show_app_fixed_overlay)
	8545	ShowExampleAppFixedOverlay(&show_app_fixed_overlay);
	8546	if (show_app_manipulating_window_title)
	8547	ShowExampleAppManipulatingWindowTitle(&show_app_manipulating_window_title);
	8548	if (show_app_custom_rendering)
	8549	ShowExampleAppCustomRendering(&show_app_custom_rendering);
	8550
8036	8551	static bool no_titlebar = false;
8037	8552	static bool no_border = true;
8038	8553	static bool no_resize = false;
8039	8554	static bool no_move = false;
8040	8555	static bool no_scrollbar = false;
8041	8556	static bool no_collapse = false;
8042		static float ~~fill~~_alpha = 0.65f;
	8557	static float bg_alpha = 0.65f;
8043	8558
8044	8559	// Demonstrate the various window flags. Typically you would just use the default.
8045	8560	ImGuiWindowFlags window_flags = 0;
r244869	r244870
8049	8564	if (no_move) window_flags \|= ImGuiWindowFlags_NoMove;
8050	8565	if (no_scrollbar) window_flags \|= ImGuiWindowFlags_NoScrollbar;
8051	8566	if (no_collapse) window_flags \|= ImGuiWindowFlags_NoCollapse;
8052		if (!ImGui::Begin("ImGui Test", opened, ImVec2(550,680), ~~fill~~_alpha, window_flags))
	8567	if (!ImGui::Begin("ImGui Test", opened, ImVec2(550,680), bg_alpha, window_flags))
8053	8568	{
8054	8569	// Early out if the window is collapsed, as an optimization.
8055	8570	ImGui::End();
8056	8571	return;
8057	8572	}
8058		ImGui::PushItemWidth(ImGui::GetWindowWidth() * 0.65f);
8059	8573
	8574	ImGui::PushItemWidth(ImGui::GetWindowWidth() * 0.65f); // 2/3 of the space for widget and 1/3 for labels
	8575	//ImGui::PushItemWidth(-140); // Right align, keep 140 pixels for labels
	8576
8060	8577	ImGui::Text("ImGui says hello.");
8061	8578	//ImGui::Text("MousePos (%g, %g)", ImGui::GetIO().MousePos.x, ImGui::GetIO().MousePos.y);
8062	8579	//ImGui::Text("MouseWheel %d", ImGui::GetIO().MouseWheel);
r244869	r244870
8078	8595	ImGui::Checkbox("no move", &no_move); ImGui::SameLine(150);
8079	8596	ImGui::Checkbox("no scrollbar", &no_scrollbar); ImGui::SameLine(300);
8080	8597	ImGui::Checkbox("no collapse", &no_collapse);
8081		ImGui::SliderFloat("~~fill~~ alpha", &~~fill~~_alpha, 0.0f, 1.0f);
	8598	ImGui::SliderFloat("bg alpha", &bg_alpha, 0.0f, 1.0f);
8082	8599
8083	8600	if (ImGui::TreeNode("Style"))
8084	8601	{
r244869	r244870
8149	8666	{
8150	8667	ImGui::BulletText("Bullet point 1");
8151	8668	ImGui::BulletText("Bullet point 2\nOn multiple lines");
8152		ImGui::BulletText("Bullet point 3");
	8669	ImGui::Bullet(); ImGui::Text("Bullet point 3 (two calls)");
	8670	ImGui::Bullet(); ImGui::SmallButton("Button 1");
	8671	ImGui::Bullet(); ImGui::SmallButton("Button 2");
8153	8672	ImGui::TreePop();
8154	8673	}
8155	8674
r244869	r244870
8291	8810	ImGui::TreePop();
8292	8811	}
8293	8812
	8813	if (ImGui::TreeNode("Filtered Text Input"))
	8814	{
	8815	static char buf1[64] = ""; ImGui::InputText("default", buf1, 64);
	8816	static char buf2[64] = ""; ImGui::InputText("decimal", buf2, 64, ImGuiInputTextFlags_CharsDecimal);
	8817	static char buf3[64] = ""; ImGui::InputText("hexadecimal", buf3, 64, ImGuiInputTextFlags_CharsHexadecimal \| ImGuiInputTextFlags_CharsUppercase);
	8818	static char buf4[64] = ""; ImGui::InputText("uppercase", buf4, 64, ImGuiInputTextFlags_CharsUppercase);
	8819	static char buf5[64] = ""; ImGui::InputText("no blank", buf5, 64, ImGuiInputTextFlags_CharsNoBlank);
	8820	struct TextFilters { static int FilterImGuiLetters(ImGuiTextEditCallbackData* data) { if (data->EventChar < 256 && strchr("imgui", (char)data->EventChar)) return 0; return 1; } };
	8821	static char buf6[64] = ""; ImGui::InputText("\"imgui\" letters", buf6, 64, ImGuiInputTextFlags_CallbackCharFilter, TextFilters::FilterImGuiLetters);
	8822	ImGui::TreePop();
	8823	}
	8824
8294	8825	static bool check = true;
8295	8826	ImGui::Checkbox("checkbox", &check);
8296	8827
r244869	r244870
8392	8923	static int listbox_item_current = 1;
8393	8924	ImGui::ListBox("listbox\n(single select)", &listbox_item_current, listbox_items, IM_ARRAYSIZE(listbox_items), 4);
8394	8925
	8926	//static int listbox_item_current2 = 2;
8395	8927	//ImGui::PushItemWidth(-1);
8396	8928	//ImGui::ListBox("##listbox2", &listbox_item_current2, listbox_items, IM_ARRAYSIZE(listbox_items), 4);
8397	8929	//ImGui::PopItemWidth();
r244869	r244870
8455	8987	ImGui::SameLine();
8456	8988	ImGui::Checkbox("Rich", &c4);
8457	8989
8458		// ~~Slide~~rFloat
	8990	// Various
8459	8991	static float f0=1.0f, f1=2.0f, f2=3.0f;
8460	8992	ImGui::PushItemWidth(80);
	8993	const char* items[] = { "AAAA", "BBBB", "CCCC", "DDDD" };
	8994	static int item = -1;
	8995	ImGui::Combo("Combo", &item, items, IM_ARRAYSIZE(items));
	8996	ImGui::SameLine();
8461	8997	ImGui::SliderFloat("X", &f0, 0.0f,5.0f);
8462	8998	ImGui::SameLine();
8463	8999	ImGui::SliderFloat("Y", &f1, 0.0f,5.0f);
8464	9000	ImGui::SameLine();
8465	9001	ImGui::SliderFloat("Z", &f2, 0.0f,5.0f);
	9002	ImGui::PopItemWidth();
	9003
	9004	ImGui::PushItemWidth(80);
	9005	ImGui::Text("Lists:");
	9006	static int selection[4] = { 0, 1, 2, 3 };
	9007	for (int i = 0; i < 4; i++)
	9008	{
	9009	if (i > 0) ImGui::SameLine();
	9010	ImGui::PushID(i);
	9011	ImGui::ListBox("", &selection[i], items, IM_ARRAYSIZE(items));
	9012	ImGui::PopID();
	9013	//if (ImGui::IsItemHovered()) ImGui::SetTooltip("ListBox %d hovered", i);
	9014	}
	9015	ImGui::PopItemWidth();
8466	9016	}
8467	9017
8468	9018	if (ImGui::CollapsingHeader("Child regions"))
r244869	r244870
8505	9055
8506	9056	if (ImGui::CollapsingHeader("Columns"))
8507	9057	{
8508		ImGui::Columns(4, "data", true);
	9058	// Basic columns
	9059	ImGui::Text("Basic:");
	9060	ImGui::Columns(4, "mycolumns");
8509	9061	ImGui::Text("ID"); ImGui::NextColumn();
8510	9062	ImGui::Text("Name"); ImGui::NextColumn();
8511	9063	ImGui::Text("Path"); ImGui::NextColumn();
8512	9064	ImGui::Text("Flags"); ImGui::NextColumn();
8513	9065	ImGui::Separator();
	9066	const char* names[3] = { "Robert", "Stephanie", "C64" };
	9067	const char* paths[3] = { "/path/robert", "/path/stephanie", "/path/computer" };
	9068	for (int i = 0; i < 3; i++)
	9069	{
	9070	ImGui::Text("%04d", i); ImGui::NextColumn();
	9071	ImGui::Text(names[i]); ImGui::NextColumn();
	9072	ImGui::Text(paths[i]); ImGui::NextColumn();
	9073	ImGui::Text("...."); ImGui::NextColumn();
	9074	}
	9075	ImGui::Columns(1);
8514	9076
8515		ImGui::Text("0000"); ImGui::NextColumn();
8516		ImGui::Text("Robert"); ImGui::NextColumn();
8517		ImGui::Text("/path/robert"); ImGui::NextColumn();
8518		ImGui::Text("...."); ImGui::NextColumn();
	9077	ImGui::Separator();
	9078	ImGui::Spacing();
8519	9079
8520		ImGui::Text("0001"); ImGui::NextColumn();
8521		ImGui::Text("Stephanie"); ImGui::NextColumn();
8522		ImGui::Text("/path/stephanie"); ImGui::NextColumn();
8523		ImGui::Text("line 1"); ImGui::Text("line 2"); ImGui::NextColumn(); // two lines, two items
8524
8525		ImGui::Text("0002"); ImGui::NextColumn();
8526		ImGui::Text("C64"); ImGui::NextColumn();
8527		ImGui::Text("/path/computer"); ImGui::NextColumn();
8528		ImGui::Text("...."); ImGui::NextColumn();
	9080	// Scrolling columns
	9081	/*
	9082	ImGui::Text("Scrolling:");
	9083	ImGui::BeginChild("##header", ImVec2(0, ImGui::GetTextLineHeightWithSpacing()+ImGui::GetStyle().ItemSpacing.y));
	9084	ImGui::Columns(3);
	9085	ImGui::Text("ID"); ImGui::NextColumn();
	9086	ImGui::Text("Name"); ImGui::NextColumn();
	9087	ImGui::Text("Path"); ImGui::NextColumn();
8529	9088	ImGui::Columns(1);
	9089	ImGui::Separator();
	9090	ImGui::EndChild();
	9091	ImGui::BeginChild("##scrollingregion", ImVec2(0, 60));
	9092	ImGui::Columns(3);
	9093	for (int i = 0; i < 10; i++)
	9094	{
	9095	ImGui::Text("%04d", i); ImGui::NextColumn();
	9096	ImGui::Text("Foobar"); ImGui::NextColumn();
	9097	ImGui::Text("/path/foobar/%04d/", i); ImGui::NextColumn();
	9098	}
	9099	ImGui::Columns(1);
	9100	ImGui::EndChild();
8530	9101
8531	9102	ImGui::Separator();
	9103	ImGui::Spacing();
	9104	*/
8532	9105
	9106	// Create multiple items in a same cell before switching to next column
	9107	ImGui::Text("Mixed items:");
8533	9108	ImGui::Columns(3, "mixed");
	9109	ImGui::Separator();
8534	9110
8535		// Create multiple items in a same cell because switching to next column
8536	9111	static int e = 0;
8537	9112	ImGui::Text("Hello");
8538	9113	ImGui::Button("Banana");
r244869	r244870
8542	9117	ImGui::Text("ImGui");
8543	9118	ImGui::Button("Apple");
8544	9119	ImGui::RadioButton("radio b", &e, 1);
	9120	static float foo = 1.0f;
	9121	ImGui::InputFloat("red", &foo, 0.05f, 0, 3);
8545	9122	ImGui::Text("An extra line here.");
8546	9123	ImGui::NextColumn();
8547	9124
8548	9125	ImGui::Text("World!");
8549	9126	ImGui::Button("Corniflower");
8550	9127	ImGui::RadioButton("radio c", &e, 2);
	9128	static float bar = 1.0f;
	9129	ImGui::InputFloat("blue", &bar, 0.05f, 0, 3);
8551	9130	ImGui::NextColumn();
8552	9131
8553	9132	if (ImGui::CollapsingHeader("Category A")) ImGui::Text("Blah blah blah"); ImGui::NextColumn();
8554	9133	if (ImGui::CollapsingHeader("Category B")) ImGui::Text("Blah blah blah"); ImGui::NextColumn();
8555	9134	if (ImGui::CollapsingHeader("Category C")) ImGui::Text("Blah blah blah"); ImGui::NextColumn();
8556
8557	9135	ImGui::Columns(1);
8558	9136
8559	9137	ImGui::Separator();
	9138	ImGui::Spacing();
8560	9139
8561		ImGui::Columns(2, "multiple components");
8562		static float foo = 1.0f;
8563		ImGui::InputFloat("red", &foo, 0.05f, 0, 3); ImGui::NextColumn();
8564		static float bar = 1.0f;
8565		ImGui::InputFloat("blue", &bar, 0.05f, 0, 3); ImGui::NextColumn();
	9140	// Tree items
	9141	ImGui::Text("Tree items:");
	9142	ImGui::Columns(2, "tree items");
	9143	ImGui::Separator();
	9144	if (ImGui::TreeNode("Hello")) { ImGui::BulletText("World"); ImGui::TreePop(); } ImGui::NextColumn();
	9145	if (ImGui::TreeNode("Bonjour")) { ImGui::BulletText("Monde"); ImGui::TreePop(); } ImGui::NextColumn();
8566	9146	ImGui::Columns(1);
8567	9147
8568	9148	ImGui::Separator();
	9149	ImGui::Spacing();
8569	9150
8570		ImGui::Columns(2, "tree items");
8571		if (ImGui::TreeNode("Hello")) { ImGui::BulletText("World"); ImGui::TreePop(); } ImGui::NextColumn();
8572		if (ImGui::TreeNode("Bonjour")) { ImGui::BulletText("Monde"); ImGui::TreePop(); }
8573		ImGui::Columns(1);
	9151	// Word-wrapping
	9152	ImGui::Text("Word-wrapping:");
	9153	ImGui::Columns(2, "word-wrapping");
8574	9154	ImGui::Separator();
8575
8576		ImGui::Columns(2, "word wrapping");
8577	9155	ImGui::TextWrapped("The quick brown fox jumps over the lazy dog.");
8578	9156	ImGui::Text("Hello Left");
8579	9157	ImGui::NextColumn();
r244869	r244870
8582	9160	ImGui::Columns(1);
8583	9161
8584	9162	ImGui::Separator();
	9163	ImGui::Spacing();
8585	9164
8586	9165	if (ImGui::TreeNode("Inside a tree.."))
8587	9166	{
8588	9167	if (ImGui::TreeNode("node 1 (with borders)"))
8589	9168	{
8590	9169	ImGui::Columns(4);
8591		ImGui::Text("aaa"); ImGui::NextColumn();
8592		ImGui::Text("bbb"); ImGui::NextColumn();
8593		ImGui::Text("ccc"); ImGui::NextColumn();
8594		ImGui::Text("ddd"); ImGui::NextColumn();
8595		ImGui::Text("eee"); ImGui::NextColumn();
8596		ImGui::Text("fff"); ImGui::NextColumn();
8597		ImGui::Text("ggg"); ImGui::NextColumn();
8598		ImGui::Text("hhh"); ImGui::NextColumn();
	9170	for (int i = 0; i < 8; i++)
	9171	{
	9172	ImGui::Text("%c%c%c", 'a'+i, 'a'+i, 'a'+i);
	9173	ImGui::NextColumn();
	9174	}
8599	9175	ImGui::Columns(1);
8600	9176	ImGui::TreePop();
8601	9177	}
8602	9178	if (ImGui::TreeNode("node 2 (without borders)"))
8603	9179	{
8604	9180	ImGui::Columns(4, NULL, false);
8605		ImGui::Text("aaa"); ImGui::NextColumn();
8606		ImGui::Text("bbb"); ImGui::NextColumn();
8607		ImGui::Text("ccc"); ImGui::NextColumn();
8608		ImGui::Text("ddd"); ImGui::NextColumn();
8609		ImGui::Text("eee"); ImGui::NextColumn();
8610		ImGui::Text("fff"); ImGui::NextColumn();
8611		ImGui::Text("ggg"); ImGui::NextColumn();
8612		ImGui::Text("hhh"); ImGui::NextColumn();
	9181	for (int i = 0; i < 8; i++)
	9182	{
	9183	ImGui::Text("%c%c%c", 'a'+i, 'a'+i, 'a'+i);
	9184	ImGui::NextColumn();
	9185	}
8613	9186	ImGui::Columns(1);
8614	9187	ImGui::TreePop();
8615	9188	}
r244869	r244870
8674	9247	ImGui::Text("Item with focus: %d", has_focus);
8675	9248	else
8676	9249	ImGui::Text("Item with focus: <none>");
	9250	ImGui::TextWrapped("Cursor & selection are preserved when refocusing last used item in code.");
8677	9251	ImGui::TreePop();
8678	9252	}
8679	9253	}
8680	9254
8681		static bool show_app_console = false;
8682		static bool show_app_long_text = false;
8683		static bool show_app_auto_resize = false;
8684		static bool show_app_fixed_overlay = false;
8685		static bool show_app_custom_rendering = false;
8686	9255	if (ImGui::CollapsingHeader("App Examples"))
8687	9256	{
8688	9257	ImGui::Checkbox("Console", &show_app_console);
8689	9258	ImGui::Checkbox("Long text display", &show_app_long_text);
8690	9259	ImGui::Checkbox("Auto-resizing window", &show_app_auto_resize);
8691	9260	ImGui::Checkbox("Simple overlay", &show_app_fixed_overlay);
	9261	ImGui::Checkbox("Manipulating window title", &show_app_manipulating_window_title);
8692	9262	ImGui::Checkbox("Custom rendering", &show_app_custom_rendering);
8693	9263	}
8694		if (show_app_console)
8695		ShowExampleAppConsole(&show_app_console);
8696		if (show_app_long_text)
8697		ShowExampleAppLongText(&show_app_long_text);
8698		if (show_app_auto_resize)
8699		ShowExampleAppAutoResize(&show_app_auto_resize);
8700		if (show_app_fixed_overlay)
8701		ShowExampleAppFixedOverlay(&show_app_fixed_overlay);
8702		if (show_app_custom_rendering)
8703		ShowExampleAppCustomRendering(&show_app_custom_rendering);
8704	9264
8705	9265	ImGui::End();
8706	9266	}
r244869	r244870
8738	9298	ImGui::End();
8739	9299	}
8740	9300
	9301	static void ShowExampleAppManipulatingWindowTitle(bool* /opened/)
	9302	{
	9303	// By default, Windows are uniquely identified by their title.
	9304	// You can use the "##" and "###" markers to manipulate the display/ID. Read FAQ at the top of this file!
	9305
	9306	// Using "##" to display same title but have unique identifier.
	9307	ImGui::SetNextWindowPos(ImVec2(100,100), ImGuiSetCond_FirstUseEver);
	9308	ImGui::Begin("Same title as another window##1");
	9309	ImGui::Text("This is window 1.\nMy title is the same as window 2, but my identifier is unique.");
	9310	ImGui::End();
	9311
	9312	ImGui::SetNextWindowPos(ImVec2(100,200), ImGuiSetCond_FirstUseEver);
	9313	ImGui::Begin("Same title as another window##2");
	9314	ImGui::Text("This is window 2.\nMy title is the same as window 1, but my identifier is unique.");
	9315	ImGui::End();
	9316
	9317	// Using "###" to display a changing title but keep a static identifier "MyWindow"
	9318	char buf[128];
	9319	ImFormatString(buf, IM_ARRAYSIZE(buf), "Animated title %c %d###MyWindow", "\|/-\\"[(int)(ImGui::GetTime()/0.25f)&3], rand());
	9320	ImGui::SetNextWindowPos(ImVec2(100,300), ImGuiSetCond_FirstUseEver);
	9321	ImGui::Begin(buf);
	9322	ImGui::Text("This window has a changing title.");
	9323	ImGui::End();
	9324	}
	9325
8741	9326	static void ShowExampleAppCustomRendering(bool* opened)
8742	9327	{
	9328	ImGui::SetNextWindowSize(ImVec2(300,350), ImGuiSetCond_FirstUseEver);
8743	9329	if (!ImGui::Begin("Example: Custom Rendering", opened))
8744	9330	{
8745	9331	ImGui::End();
r244869	r244870
8754	9340	static ImVector<ImVec2> points;
8755	9341	static bool adding_line = false;
8756	9342	if (ImGui::Button("Clear")) points.clear();
8757		if (points.size() > 2) { ImGui::SameLine(); if (ImGui::Button("Undo")) points.pop_back(); }
	9343	if (points.size() >= 2) { ImGui::SameLine(); if (ImGui::Button("Undo")) { points.pop_back(); points.pop_back(); } }
8758	9344	ImGui::Text("Left-click and drag to add lines");
8759	9345	ImGui::Text("Right-click to undo");
8760	9346
r244869	r244870
8860	9446	if (ImGui::SmallButton("Add Dummy Text")) { AddLog("%d some text", Items.size()); AddLog("some more text"); AddLog("display very important message here!"); } ImGui::SameLine();
8861	9447	if (ImGui::SmallButton("Add Dummy Error")) AddLog("[error] something went wrong"); ImGui::SameLine();
8862	9448	if (ImGui::SmallButton("Clear")) ClearLog();
	9449	//static float t = 0.0f; if (ImGui::GetTime() - t > 0.02f) { t = ImGui::GetTime(); AddLog("Spam %f", t); }
	9450
8863	9451	ImGui::Separator();
8864	9452
8865	9453	ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0,0));
r244869	r244870
8945	9533	}
8946	9534	}
8947	9535
8948		static void TextEditCallbackStub(ImGuiTextEditCallbackData* data)
	9536	static int TextEditCallbackStub(ImGuiTextEditCallbackData* data)
8949	9537	{
8950	9538	ExampleAppConsole* console = (ExampleAppConsole*)data->UserData;
8951		console->TextEditCallback(data);
	9539	return console->TextEditCallback(data);
8952	9540	}
8953	9541
8954		void TextEditCallback(ImGuiTextEditCallbackData* data)
	9542	int TextEditCallback(ImGuiTextEditCallbackData* data)
8955	9543	{
8956	9544	//AddLog("cursor: %d, selection: %d-%d", data->CursorPos, data->SelectionStart, data->SelectionEnd);
8957		switch (data->Event~~Key~~)
	9545	switch (data->EventFlag)
8958	9546	{
8959		case ImGuiKey_Tab:
	9547	case ImGuiInputTextFlags_CallbackCompletion:
8960	9548	{
8961	9549	// Example of TEXT COMPLETION
8962	9550
r244869	r244870
8966	9554	while (word_start > data->Buf)
8967	9555	{
8968	9556	const char c = word_start[-1];
8969		if (c ~~== ' ' \|\|~~ c ~~== '\t'~~ \|\| c == ',' \|\| c == ';')
	9557	if (ImCharIsSpace(c) \|\| c == ',' \|\| c == ';')
8970	9558	break;
8971	9559	word_start--;
8972	9560	}
r244869	r244870
9021	9609
9022	9610	break;
9023	9611	}
9024		case ImGuiKey_UpArrow:
9025		case ImGuiKey_DownArrow:
	9612	case ImGuiInputTextFlags_CallbackHistory:
9026	9613	{
9027	9614	// Example of HISTORY
9028	9615	const int prev_history_pos = HistoryPos;
r244869	r244870
9049	9636	}
9050	9637	}
9051	9638	}
	9639	return 0;
9052	9640	}
9053	9641	};
9054	9642

trunk/3rdparty/bgfx/3rdparty/ocornut-imgui/imgui.h
r244869	r244870
1		// ImGui library v1.3~~2 wip~~
	1	// ImGui library v1.35
2	2	// See .cpp file for documentation.
3	3	// See ImGui::ShowTestWindow() for sample code.
4	4	// Read 'Programmer guide' in .cpp for notes on how to setup ImGui in your codebase.
r244869	r244870
6	6
7	7	#pragma once
8	8
9		struct ImDrawCmd;
10		struct ImDrawList;
11		struct ImFont;
12		struct ImFontAtlas;
13		struct ImGuiAabb;
14		struct ImGuiIO;
15		struct ImGuiStorage;
16		struct ImGuiStyle;
17		struct ImGuiWindow;
18
19		#include "imconfig.h"
	9	#include "imconfig.h" // User-editable configuration file
20	10	#include <float.h> // FLT_MAX
21	11	#include <stdarg.h> // va_list
22	12	#include <stddef.h> // ptrdiff_t
23	13	#include <stdlib.h> // NULL, malloc
24	14	#include <string.h> // memset, memmove
25	15
	16	// Define assertion handler.
26	17	#ifndef IM_ASSERT
27	18	#include <assert.h>
28	19	#define IM_ASSERT(_EXPR) assert(_EXPR)
29	20	#endif
30	21
	22	// Define attributes of all API symbols declarations, e.g. for DLL under Windows.
31	23	#ifndef IMGUI_API
32	24	#define IMGUI_API
33	25	#endif
34	26
	27	// Forward declarations
	28	struct ImDrawCmd;
	29	struct ImDrawList;
	30	struct ImFont;
	31	struct ImFontAtlas;
	32	struct ImGuiIO;
	33	struct ImGuiStorage;
	34	struct ImGuiStyle;
	35
35	36	typedef unsigned int ImU32;
36	37	typedef unsigned short ImWchar; // character for display
37	38	typedef void* ImTextureID; // user data to refer to a texture (e.g. store your texture handle/id)
r244869	r244870
41	42	typedef int ImGuiKey; // enum ImGuiKey_
42	43	typedef int ImGuiColorEditMode; // enum ImGuiColorEditMode_
43	44	typedef int ImGuiWindowFlags; // enum ImGuiWindowFlags_
44		typedef int ImGuiSetCond~~ition~~; // enum ImGuiSetCondition_
	45	typedef int ImGuiSetCond; // enum ImGuiSetCondition_
45	46	typedef int ImGuiInputTextFlags; // enum ImGuiInputTextFlags_
46		struct ImGuiTextEditCallbackData; // for advanced uses of InputText()
	47	struct ImGuiTextEditCallbackData; // for advanced uses of InputText()
	48	typedef int (ImGuiTextEditCallback)(ImGuiTextEditCallbackData data);
47	49
48	50	struct ImVec2
49	51	{
r244869	r244870
74	76	IMGUI_API void MemFree(void* ptr);
75	77	}
76	78
77		// std::vector<> like class to avoid dragging dependencies (also: windows implementation of STL with debug enabled is absurdly slow, so let's bypass it so our code runs fast in debug).
	79	// std::vector<> like class to avoid dragging dependencies (also: windows implementation of STL with debug enabled is absurdly slow, so let's bypass it so our code runs fast in debug).
78	80	// Use '#define ImVector std::vector' if you want to use the STL type or your own type.
79	81	// Our implementation does NOT call c++ constructors! because the data types we use don't need them (but that could be added as well). Only provide the minimum functionalities we need.
80	82	#ifndef ImVector
r244869	r244870
115	117	inline void swap(ImVector<T>& rhs) { const size_t rhs_size = rhs.Size; rhs.Size = Size; Size = rhs_size; const size_t rhs_cap = rhs.Capacity; rhs.Capacity = Capacity; Capacity = rhs_cap; value_type* rhs_data = rhs.Data; rhs.Data = Data; Data = rhs_data; }
116	118
117	119	inline void resize(size_t new_size) { if (new_size > Capacity) reserve(new_size); Size = new_size; }
118		inline void reserve(size_t new_capacity)
119		{
	120	inline void reserve(size_t new_capacity)
	121	{
120	122	if (new_capacity <= Capacity) return;
121	123	T* new_data = (value_type)ImGui::MemAlloc(new_capacity sizeof(value_type));
122	124	memcpy(new_data, Data, Size * sizeof(value_type));
123	125	ImGui::MemFree(Data);
124	126	Data = new_data;
125		Capacity = new_capacity;
	127	Capacity = new_capacity;
126	128	}
127	129
128	130	inline void push_back(const value_type& v) { if (Size == Capacity) reserve(Capacity ? Capacity * 2 : 4); Data[Size++] = v; }
r244869	r244870
141	143	// - struct ImDrawList // Draw command list
142	144	// - struct ImFont // TTF font loader, bake glyphs into bitmap
143	145
144		// ImGui End-user API
	146	// ImGui end-user API
145	147	// In a namespace so that user can add extra functions (e.g. Value() helpers for your vector or common types)
146	148	namespace ImGui
147	149	{
r244869	r244870
156	158	IMGUI_API void ShowTestWindow(bool* open = NULL);
157	159
158	160	// Window
159		IMGUI_API bool Begin(const char* name = "Debug", bool* p_opened = NULL, ImVec2 size = ImVec2(0,0), float fill_alpha = -1.0f, ImGuiWindowFlags flags = 0);// return false when window is collapsed, so you can early out in your code. passing 'bool* p_opened' displays a Close button on the upper-right corner of the window, the pointed value will be set to false when the button is pressed.
	161	// See implementation in .cpp for details
	162	IMGUI_API bool Begin(const char* name = "Debug", bool* p_opened = NULL, const ImVec2& initial_size = ImVec2(0,0), float bg_alpha = -1.0f, ImGuiWindowFlags flags = 0); // return false when window is collapsed, so you can early out in your code. passing 'bool* p_opened' displays a Close button on the upper-right corner of the window, the pointed value will be set to false when the button is pressed.
160	163	IMGUI_API void End();
161		IMGUI_API void BeginChild(const char* str_id, ImVec2 size = ImVec2(0,0), bool border = false, ImGuiWindowFlags extra_flags = 0); // size==0.0f: use remaining window size, size<0.0f: use remaining window size minus abs(size). on each axis.
162		IMGUI_API void BeginChild(ImGuiID id, ImVec2 size = ImVec2(0,0), bool border = false, ImGuiWindowFlags extra_flags = 0); // "
	164	IMGUI_API bool BeginChild(const char* str_id, const ImVec2& size = ImVec2(0,0), bool border = false, ImGuiWindowFlags extra_flags = 0); // size==0.0f: use remaining window size, size<0.0f: use remaining window size minus abs(size). on each axis.
	165	IMGUI_API bool BeginChild(ImGuiID id, const ImVec2& size = ImVec2(0,0), bool border = false, ImGuiWindowFlags extra_flags = 0); // "
163	166	IMGUI_API void EndChild();
164	167	IMGUI_API bool GetWindowIsFocused();
165	168	IMGUI_API ImVec2 GetContentRegionMax(); // window or current column boundaries, in windows coordinates
r244869	r244870
173	176	IMGUI_API ImVec2 GetWindowSize(); // get current window position.
174	177	IMGUI_API float GetWindowWidth();
175	178	IMGUI_API bool GetWindowCollapsed();
176		IMGUI_API void SetNextWindowPos(const ImVec2& pos, ImGuiSetCondition cond = 0); // set next window position - call before Begin().
177		IMGUI_API void SetNextWindowSize(const ImVec2& size, ImGuiSetCondition cond = 0); // set next window size. set to ImVec2(0,0) to force an auto-fit.
178		IMGUI_API void SetNextWindowCollapsed(bool collapsed, ImGuiSetCondition cond = 0); // set next window collapsed state.
179		IMGUI_API void SetWindowPos(const ImVec2& pos, ImGuiSetCondition cond = 0); // set current window position - call within Begin()/End(). may incur tearing.
180		IMGUI_API void SetWindowSize(const ImVec2& size, ImGuiSetCondition cond = 0); // set current window size. set to ImVec2(0,0) to force an auto-fit. may incur tearing.
181		IMGUI_API void SetWindowCollapsed(bool collapsed, ImGuiSetCondition cond = 0); // set current window collapsed state.
182	179
	180	IMGUI_API void SetNextWindowPos(const ImVec2& pos, ImGuiSetCond cond = 0); // set next window position - call before Begin().
	181	IMGUI_API void SetNextWindowSize(const ImVec2& size, ImGuiSetCond cond = 0); // set next window size. set to ImVec2(0,0) to force an auto-fit.
	182	IMGUI_API void SetNextWindowCollapsed(bool collapsed, ImGuiSetCond cond = 0); // set next window collapsed state.
	183	IMGUI_API void SetNextWindowFocus(); // set next window to be focused / front-most
	184	IMGUI_API void SetWindowPos(const ImVec2& pos, ImGuiSetCond cond = 0); // set current window position - call within Begin()/End(). may incur tearing.
	185	IMGUI_API void SetWindowSize(const ImVec2& size, ImGuiSetCond cond = 0); // set current window size. set to ImVec2(0,0) to force an auto-fit. may incur tearing.
	186	IMGUI_API void SetWindowCollapsed(bool collapsed, ImGuiSetCond cond = 0); // set current window collapsed state.
	187	IMGUI_API void SetWindowFocus(); // set current window to be focused / front-most
	188	IMGUI_API void SetWindowPos(const char* name, const ImVec2& pos, ImGuiSetCond cond = 0); // set named window position - call within Begin()/End(). may incur tearing.
	189	IMGUI_API void SetWindowSize(const char* name, const ImVec2& size, ImGuiSetCond cond = 0); // set named window size. set to ImVec2(0,0) to force an auto-fit. may incur tearing.
	190	IMGUI_API void SetWindowCollapsed(const char* name, bool collapsed, ImGuiSetCond cond = 0); // set named window collapsed state.
	191	IMGUI_API void SetWindowFocus(const char* name); // set named window to be focused / front-most
	192
	193	IMGUI_API float GetScrollPosY(); // get scrolling position (0..GetScrollMaxY())
	194	IMGUI_API float GetScrollMaxY(); // get maximum scrolling position == ContentSize.Y - WindowSize.Y
183	195	IMGUI_API void SetScrollPosHere(); // adjust scrolling position to center into the current cursor position.
184	196	IMGUI_API void SetKeyboardFocusHere(int offset = 0); // focus keyboard on the next widget. Use positive 'offset' to access sub components of a multiple component widget.
185	197	IMGUI_API void SetStateStorage(ImGuiStorage* tree); // replace tree state storage with our own (if you want to manipulate it yourself, typically clear subsection of it).
r244869	r244870
215	227	IMGUI_API void Spacing();
216	228	IMGUI_API void Columns(int count = 1, const char* id = NULL, bool border=true); // setup number of columns
217	229	IMGUI_API void NextColumn(); // next column
218		IMGUI_API float GetColumnOffset(int column_index = -1);
219		IMGUI_API void SetColumnOffset(int column_index, float offset);
220		IMGUI_API float GetColumnWidth(int column_index = -1);
	230	IMGUI_API int GetColumnIndex(); // get current column index
	231	IMGUI_API float GetColumnOffset(int column_index = -1); // get position of column line (in pixels, from the left side of the contents region). pass -1 to use current column, otherwise 0..GetcolumnsCount() inclusive. column 0 is usually 0.0f and not resizable unless you call this.
	232	IMGUI_API void SetColumnOffset(int column_index, float offset_x); // set position of column line (in pixels, from the left side of the contents region). pass -1 to use current column.
	233	IMGUI_API float GetColumnWidth(int column_index = -1); // column width (== GetColumnOffset(GetColumnIndex()+1) - GetColumnOffset(GetColumnOffset())
	234	IMGUI_API int GetColumnsCount(); // number of columns (what was passed to Columns())
221	235	IMGUI_API ImVec2 GetCursorPos(); // cursor position is relative to window position
222	236	IMGUI_API float GetCursorPosX(); // "
223	237	IMGUI_API float GetCursorPosY(); // "
r244869	r244870
231	245	IMGUI_API float GetTextLineHeightWithSpacing(); // spacing (in pixels) between 2 consecutive lines of text == GetWindowFontSize() + GetStyle().ItemSpacing.y
232	246
233	247	// ID scopes
234		// If you are creating repeated widgets in a loop you most likely want to push a unique identifier so ImGui can differentiate them.
235		// You can also use ## within your widget name to distinguish them from each others (see 'Programmer Guide')
	248	// If you are creating widgets in a loop you most likely want to push a unique identifier so ImGui can differentiate them.
	249	// You can also use "##extra" within your widget name to distinguish them from each others (see 'Programmer Guide')
236	250	IMGUI_API void PushID(const char* str_id); // push identifier into the ID stack. IDs are hash of the entire stack!
237	251	IMGUI_API void PushID(const void* ptr_id);
238	252	IMGUI_API void PushID(const int int_id);
r244869	r244870
248	262	IMGUI_API void TextWrapped(const char* fmt, ...); // shortcut for PushTextWrapPos(0.0f); Text(fmt, ...); PopTextWrapPos();
249	263	IMGUI_API void TextWrappedV(const char* fmt, va_list args);
250	264	IMGUI_API void TextUnformatted(const char* text, const char* text_end = NULL); // doesn't require null terminated string if 'text_end' is specified. no copy done to any bounded stack buffer, recommended for long chunks of text.
251		IMGUI_API void LabelText(const char* label, const char* fmt, ...); // display text+label aligned the same way as value+label widgets
	265	IMGUI_API void LabelText(const char* label, const char* fmt, ...); // display text+label aligned the same way as value+label widgets
252	266	IMGUI_API void LabelTextV(const char* label, const char* fmt, va_list args);
	267	IMGUI_API void Bullet();
253	268	IMGUI_API void BulletText(const char* fmt, ...);
254	269	IMGUI_API void BulletTextV(const char* fmt, va_list args);
255	270	IMGUI_API bool Button(const char* label, const ImVec2& size = ImVec2(0,0), bool repeat_when_held = false);
r244869	r244870
257	272	IMGUI_API bool InvisibleButton(const char* str_id, const ImVec2& size);
258	273	IMGUI_API void Image(ImTextureID user_texture_id, const ImVec2& size, const ImVec2& uv0 = ImVec2(0,0), const ImVec2& uv1 = ImVec2(1,1), const ImVec4& tint_col = ImVec4(1,1,1,1), const ImVec4& border_col = ImVec4(0,0,0,0));
259	274	IMGUI_API bool ImageButton(ImTextureID user_texture_id, const ImVec2& size, const ImVec2& uv0 = ImVec2(0,0), const ImVec2& uv1 = ImVec2(1,1), int frame_padding = -1, const ImVec4& bg_col = ImVec4(0,0,0,1), const ImVec4& tint_col = ImVec4(1,1,1,1)); // <0 frame_padding uses default frame padding settings. 0 for no paddnig.
260		IMGUI_API bool CollapsingHeader(const char* label, const char* str_id = NULL, ~~const~~ bool display_frame = true, ~~const~~ bool default_open = false);
	275	IMGUI_API bool CollapsingHeader(const char* label, const char* str_id = NULL, bool display_frame = true, bool default_open = false);
261	276	IMGUI_API bool SliderFloat(const char* label, float* v, float v_min, float v_max, const char* display_format = "%.3f", float power = 1.0f); // adjust display_format to decorate the value with a prefix or a suffix. Use power!=1.0 for logarithmic sliders.
262	277	IMGUI_API bool SliderFloat2(const char* label, float v[2], float v_min, float v_max, const char* display_format = "%.3f", float power = 1.0f);
263	278	IMGUI_API bool SliderFloat3(const char* label, float v[3], float v_min, float v_max, const char* display_format = "%.3f", float power = 1.0f);
r244869	r244870
275	290	IMGUI_API bool CheckboxFlags(const char* label, unsigned int* flags, unsigned int flags_value);
276	291	IMGUI_API bool RadioButton(const char* label, bool active);
277	292	IMGUI_API bool RadioButton(const char* label, int* v, int v_button);
278		IMGUI_API bool InputText(const char* label, char* buf, size_t buf_size, ImGuiInputTextFlags flags = 0, ~~void (callback)(~~ImGuiTextEditCallbackData) = NULL, void* user_data = NULL);
	293	IMGUI_API bool InputText(const char* label, char* buf, size_t buf_size, ImGuiInputTextFlags flags = 0, ImGuiTextEditCallback callback = NULL, void* user_data = NULL);
279	294	IMGUI_API bool InputFloat(const char* label, float* v, float step = 0.0f, float step_fast = 0.0f, int decimal_precision = -1, ImGuiInputTextFlags extra_flags = 0);
280	295	IMGUI_API bool InputFloat2(const char* label, float v[2], int decimal_precision = -1);
281	296	IMGUI_API bool InputFloat3(const char* label, float v[3], int decimal_precision = -1);
r244869	r244870
288	303	IMGUI_API bool ColorEdit3(const char* label, float col[3]);
289	304	IMGUI_API bool ColorEdit4(const char* label, float col[4], bool show_alpha = true);
290	305	IMGUI_API void ColorEditMode(ImGuiColorEditMode mode);
	306
	307	// Trees
291	308	IMGUI_API bool TreeNode(const char* str_label_id); // if returning 'true' the node is open and the user is responsible for calling TreePop
292	309	IMGUI_API bool TreeNode(const char* str_id, const char* fmt, ...); // "
293	310	IMGUI_API bool TreeNode(const void* ptr_id, const char* fmt, ...); // "
r244869	r244870
296	313	IMGUI_API void TreePush(const char* str_id = NULL); // already called by TreeNode(), but you can call Push/Pop yourself for layouting purpose
297	314	IMGUI_API void TreePush(const void* ptr_id = NULL); // "
298	315	IMGUI_API void TreePop();
299		IMGUI_API void OpenNextNode(bool open); // ~~force open/clo~~se the next TreeNode or Co~~lla~~psingHeader
	316	IMGUI_API void SetNextTreeNodeOpened(bool opened, ImGuiSetCond cond = 0); // set next tree node to be opened.
300	317
301	318	// Selectable / Lists
302	319	IMGUI_API bool Selectable(const char* label, bool selected, const ImVec2& size = ImVec2(0,0));
r244869	r244870
326	343	// Utilities
327	344	IMGUI_API bool IsItemHovered(); // was the last item hovered by mouse?
328	345	IMGUI_API bool IsItemActive(); // was the last item active? (e.g. button being held, text field being edited- items that don't interact will always return false)
	346	IMGUI_API bool IsAnyItemActive(); //
329	347	IMGUI_API ImVec2 GetItemBoxMin(); // get bounding box of last item
330	348	IMGUI_API ImVec2 GetItemBoxMax(); // get bounding box of last item
331	349	IMGUI_API bool IsClipped(const ImVec2& item_size); // to perform coarse clipping on user's side (as an optimization)
r244869	r244870
357	375
358	376	// Obsolete (will be removed)
359	377	IMGUI_API void GetDefaultFontData(const void** fnt_data, unsigned int* fnt_size, const void** png_data, unsigned int* png_size);
	378	static inline void OpenNextNode(bool open) { ImGui::SetNextTreeNodeOpened(open, 0); }
360	379
361	380	} // namespace ImGui
362	381
r244869	r244870
367	386	ImGuiWindowFlags_NoTitleBar = 1 << 0, // Disable title-bar
368	387	ImGuiWindowFlags_NoResize = 1 << 1, // Disable user resizing with the lower-right grip
369	388	ImGuiWindowFlags_NoMove = 1 << 2, // Disable user moving the window
370		ImGuiWindowFlags_NoScrollbar = 1 << 3, // Disable scroll bar (window can still scroll with mouse or programatically)
	389	ImGuiWindowFlags_NoScrollbar = 1 << 3, // Disable scrollbar (window can still scroll with mouse or programatically)
371	390	ImGuiWindowFlags_NoScrollWithMouse = 1 << 4, // Disable user scrolling with mouse wheel
372	391	ImGuiWindowFlags_NoCollapse = 1 << 5, // Disable user collapsing window by double-clicking on it
373	392	ImGuiWindowFlags_AlwaysAutoResize = 1 << 6, // Resize every window to its content every frame
r244869	r244870
387	406	// Default: 0
388	407	ImGuiInputTextFlags_CharsDecimal = 1 << 0, // Allow 0123456789.+-*/
389	408	ImGuiInputTextFlags_CharsHexadecimal = 1 << 1, // Allow 0123456789ABCDEFabcdef
390		ImGuiInputTextFlags_AutoSelectAll = 1 << 2, // Select entire text when first taking focus
391		ImGuiInputTextFlags_EnterReturnsTrue = 1 << 3, // Return 'true' when Enter is pressed (as opposed to when the value was modified)
392		ImGuiInputTextFlags_CallbackCompletion = 1 << 4, // Call user function on pressing TAB (for completion handling)
393		ImGuiInputTextFlags_CallbackHistory = 1 << 5, // Call user function on pressing Up/Down arrows (for history handling)
394		ImGuiInputTextFlags_CallbackAlways = 1 << 6 // Call user function every time
395		//ImGuiInputTextFlags_AlignCenter = 1 << 6,
	409	ImGuiInputTextFlags_CharsUppercase = 1 << 2, // Turn a..z into A..Z
	410	ImGuiInputTextFlags_CharsNoBlank = 1 << 3, // Filter out spaces, tabs
	411	ImGuiInputTextFlags_AutoSelectAll = 1 << 4, // Select entire text when first taking mouse focus
	412	ImGuiInputTextFlags_EnterReturnsTrue = 1 << 5, // Return 'true' when Enter is pressed (as opposed to when the value was modified)
	413	ImGuiInputTextFlags_CallbackCompletion = 1 << 6, // Call user function on pressing TAB (for completion handling)
	414	ImGuiInputTextFlags_CallbackHistory = 1 << 7, // Call user function on pressing Up/Down arrows (for history handling)
	415	ImGuiInputTextFlags_CallbackAlways = 1 << 8, // Call user function every time
	416	ImGuiInputTextFlags_CallbackCharFilter = 1 << 9 // Call user function to filter character. Modify data->EventChar to replace/filter input, or return 1 to discard character.
396	417	};
397	418
398	419	// User fill ImGuiIO.KeyMap[] array with indices into the ImGuiIO.KeysDown[512] array
r244869	r244870
488	509	ImGuiColorEditMode_HEX = 2
489	510	};
490	511
491		// Condition flags for ImGui::SetWindow*() and SetNextWindow*() functions
492		// Those functions treat 0 as a shortcut to ImGuiSetCondition_Always
493		enum ImGuiSetCondition_
	512	// Condition flags for ImGui::SetWindow*(), SetNextWindow(), SetNextTreeNode**() functions
	513	// All those functions treat 0 as a shortcut to ImGuiSetCond_Always
	514	enum ImGuiSetCond_
494	515	{
495		ImGuiSetCondition_Always = 1 << 0, // Set the variable
496		ImGuiSetCondition_FirstUseThisSession = 1 << 1, // Only set the variable on the first call for this window (once per session)
497		ImGuiSetCondition_FirstUseEver = 1 << 2 // Only set the variable if the window doesn't exist in the .ini file
	516	ImGuiSetCond_Always = 1 << 0, // Set the variable
	517	ImGuiSetCond_Once = 1 << 1, // Only set the variable on the first call per runtime session
	518	ImGuiSetCond_FirstUseEver = 1 << 2 // Only set the variable if the window doesn't exist in the .ini file
498	519	};
499	520
500	521	struct ImGuiStyle
r244869	r244870
513	534	float WindowFillAlphaDefault; // Default alpha of window background, if not specified in ImGui::Begin()
514	535	float TreeNodeSpacing; // Horizontal spacing when entering a tree node
515	536	float ColumnsMinSpacing; // Minimum horizontal spacing between two columns
516		float ScrollBarWidth; // Width of the vertical scroll bar
	537	float ScrollbarWidth; // Width of the vertical scrollbar
	538	float GrabMinSize; // Minimum width/height of a slider or scrollbar grab
517	539	ImVec4 Colors[ImGuiCol_COUNT];
518	540
519	541	IMGUI_API ImGuiStyle();
r244869	r244870
529	551
530	552	ImVec2 DisplaySize; // <unset> // Display size, in pixels. For clamping windows positions.
531	553	float DeltaTime; // = 1.0f/60.0f // Time elapsed since last frame, in seconds.
532		float IniSavingRate; // = 5.0f // Maximum time between saving .ini file, in seconds.
	554	float IniSavingRate; // = 5.0f // Maximum time between saving positions/sizes to .ini file, in seconds.
533	555	const char* IniFilename; // = "imgui.ini" // Path to .ini file. NULL to disable .ini saving.
534	556	const char* LogFilename; // = "imgui_log.txt" // Path to .log file (default parameter to ImGui::LogToFile when no file is specified).
535	557	float MouseDoubleClickTime; // = 0.30f // Time for a double-click, in seconds.
r244869	r244870
547	569	// User Functions
548	570	//------------------------------------------------------------------
549	571
550		// REQUIRED: rendering function.
	572	// REQUIRED: rendering function.
551	573	// See example code if you are unsure of how to implement this.
552		void (RenderDrawListsFn)(ImDrawList* const draw_lists, int count);
	574	void (RenderDrawListsFn)(ImDrawList* const draw_lists, int count);
553	575
554		// Optional: access OS clipboard (default to use native Win32 clipboard on Windows, otherwise use a ImGui private clipboard)
555		// Override to access OS clipboard on other architectures.
	576	// Optional: access OS clipboard
	577	// (default to use native Win32 clipboard on Windows, otherwise uses a private clipboard. Override to access OS clipboard on other architectures)
556	578	const char* (*GetClipboardTextFn)();
557	579	void (SetClipboardTextFn)(const char text);
558	580
559		// Optional: override memory allocations (default to posix malloc/free). MemFreeFn() may be called with a NULL pointer.
	581	// Optional: override memory allocations. MemFreeFn() may be called with a NULL pointer.
	582	// (default to posix malloc/free)
560	583	void* (*MemAllocFn)(size_t sz);
561	584	void (MemFreeFn)(void ptr);
562	585
563		// Optional: notify OS Input Method Editor of the screen position of your cursor for text input position (e.g. when using Japanese/Chinese inputs in Windows)
	586	// Optional: notify OS Input Method Editor of the screen position of your cursor for text input position (e.g. when using Japanese/Chinese IME in Windows)
	587	// (default to use native imm32 api on Windows)
564	588	void (*ImeSetInputScreenPosFn)(int x, int y);
	589	void* ImeWindowHandle; // (Windows) Set this to your HWND to get automatic IME cursor positioning.
565	590
566	591	//------------------------------------------------------------------
567	592	// Input - Fill before calling NewFrame()
568	593	//------------------------------------------------------------------
569	594
570	595	ImVec2 MousePos; // Mouse position, in pixels (set to -1,-1 if no mouse / on another screen, etc.)
571		bool MouseDown[5]; // Mouse buttons. ImGui itself only uses button 0 (left button) but you can use others as storage for convenience.
572		float MouseWheel; // Mouse wheel: 1 unit scrolls about 5 lines text.
	596	bool MouseDown[5]; // Mouse buttons. ImGui itself only uses button 0 (left button). Others buttons allows to track if mouse is being used by your application + available to user as a convenience via IsMouse** API.
	597	float MouseWheel; // Mouse wheel: 1 unit scrolls about 5 lines text.
573	598	bool MouseDrawCursor; // Request ImGui to draw a mouse cursor for you (if you are on a platform without a mouse cursor).
574	599	bool KeyCtrl; // Keyboard modifier pressed: Control
575	600	bool KeyShift; // Keyboard modifier pressed: Shift
576		bool KeysDown[512]; // Keyboard keys that are pressed (in whatever order u~~ser~~ naturally has access to keyboard data)
	601	bool KeysDown[512]; // Keyboard keys that are pressed (in whatever storage order you naturally have access to keyboard data)
577	602	ImWchar InputCharacters[16+1]; // List of characters input (translated by user from keypress+keyboard state). Fill using AddInputCharacter() helper.
578	603
579	604	// Function
r244869	r244870
585	610
586	611	bool WantCaptureMouse; // Mouse is hovering a window or widget is active (= ImGui will use your mouse input)
587	612	bool WantCaptureKeyboard; // Widget is active (= ImGui will use your keyboard input)
	613	float Framerate; // Framerate estimation, in frame per second. Rolling average estimation based on IO.DeltaTime over 120 frames
588	614
589	615	//------------------------------------------------------------------
590	616	// [Internal] ImGui will maintain those fields for you
591	617	//------------------------------------------------------------------
592	618
593		ImVec2 MousePosPrev; //
	619	ImVec2 MousePosPrev; // Previous mouse position
594	620	ImVec2 MouseDelta; // Mouse delta. Note that this is zero if either current or previous position are negative to allow mouse enabling/disabling.
595	621	bool MouseClicked[5]; // Mouse button went from !Down to Down
596	622	ImVec2 MouseClickedPos[5]; // Position at time of clicking
r244869	r244870
646	672	ImVector<TextRange> Filters;
647	673	int CountGrep;
648	674
649		ImGuiTextFilter();
	675	ImGuiTextFilter(const char* default_filter = "");
650	676	void Clear() { InputBuf[0] = 0; Build(); }
651	677	void Draw(const char* label = "Filter (inc,-exc)", float width = -1.0f); // Helper calling InputText+Build
652	678	bool PassFilter(const char* val) const;
r244869	r244870
680	706	// - You want to store custom debug data easily without adding or editing structures in your code.
681	707	struct ImGuiStorage
682	708	{
683		struct Pair
684		{
685		ImGuiID key;
686		union { int val_i; float val_f; void* val_p; };
687		Pair(ImGuiID _key, int _val_i) { key = _key; val_i = _val_i; }
688		Pair(ImGuiID _key, float _val_f) { key = _key; val_f = _val_f; }
689		Pair(ImGuiID _key, void* _val_p) { key = _key; val_p = _val_p; }
	709	struct Pair
	710	{
	711	ImGuiID key;
	712	union { int val_i; float val_f; void* val_p; };
	713	Pair(ImGuiID _key, int _val_i) { key = _key; val_i = _val_i; }
	714	Pair(ImGuiID _key, float _val_f) { key = _key; val_f = _val_f; }
	715	Pair(ImGuiID _key, void* _val_p) { key = _key; val_p = _val_p; }
690	716	};
691	717	ImVector<Pair> Data;
692	718
r244869	r244870
701	727	IMGUI_API void* GetVoidPtr(ImGuiID key) const; // default_val is NULL
702	728	IMGUI_API void SetVoidPtr(ImGuiID key, void* val);
703	729
704		// - Get***Ref() functions finds pair, insert on demand if missing, return pointer. Useful if you intend to do Get+Set.
	730	// - Get***Ref() functions finds pair, insert on demand if missing, return pointer. Useful if you intend to do Get+Set.
705	731	// - References are only valid until a new value is added to the storage. Calling a Set*() function or a Get*Ref() function invalidates the pointer.
706	732	// - A typical use case where this is convenient:
707	733	// float* pvar = ImGui::GetFloatRef(key); ImGui::SliderFloat("var", pvar, 0, 100.0f); some_var += *pvar;
r244869	r244870
716	742	// Shared state of InputText(), passed to callback when a ImGuiInputTextFlags_Callback* flag is used.
717	743	struct ImGuiTextEditCallbackData
718	744	{
719		ImGuiKey EventKey; // Key pressed (Up/Down/TAB) // Read-only
720		char* Buf; // Current text // Read-write (pointed data only)
721		size_t BufSize; // // Read-only
722		bool BufDirty; // Set if you modify Buf directly // Write
723		ImGuiInputTextFlags Flags; // What user passed to InputText() // Read-only
724		int CursorPos; // // Read-write
725		int SelectionStart; // // Read-write (== to SelectionEnd when no selection)
726		int SelectionEnd; // // Read-write
727		void* UserData; // What user passed to InputText()
	745	ImGuiInputTextFlags EventFlag; // One of ImGuiInputTextFlags_Callback* // Read-only
	746	ImGuiInputTextFlags Flags; // What user passed to InputText() // Read-only
	747	void* UserData; // What user passed to InputText() // Read-only
728	748
	749	// CharFilter event:
	750	ImWchar EventChar; // Character input // Read-write (replace character or set to zero)
	751
	752	// Completion,History,Always events:
	753	ImGuiKey EventKey; // Key pressed (Up/Down/TAB) // Read-only
	754	char* Buf; // Current text // Read-write (pointed data only)
	755	size_t BufSize; // // Read-only
	756	bool BufDirty; // Set if you modify Buf directly // Write
	757	int CursorPos; // // Read-write
	758	int SelectionStart; // // Read-write (== to SelectionEnd when no selection)
	759	int SelectionEnd; // // Read-write
	760
729	761	// NB: calling those function loses selection.
730	762	void DeleteChars(int pos, int bytes_count);
731	763	void InsertChars(int pos, const char* text, const char* text_end = NULL);
r244869	r244870
740	772	ImColor(int r, int g, int b, int a = 255) { Value.x = (float)r / 255.0f; Value.y = (float)g / 255.0f; Value.z = (float)b / 255.0f; Value.w = (float)a / 255.0f; }
741	773	ImColor(float r, float g, float b, float a = 1.0f) { Value.x = r; Value.y = g; Value.z = b; Value.w = a; }
742	774	ImColor(const ImVec4& col) { Value = col; }
743
744	775	operator ImU32() const { return ImGui::ColorConvertFloat4ToU32(Value); }
745	776	operator ImVec4() const { return Value; }
746	777
r244869	r244870
763	794	// It is up to you to decide if your rendering loop or the callback should be responsible for backup/restoring rendering state.
764	795	typedef void (ImDrawCallback)(const ImDrawList parent_list, const ImDrawCmd* cmd);
765	796
766		// Typically, 1 command = 1 gpu draw call
	797	// Typically, 1 command = 1 gpu draw call (unless command is a callback)
767	798	struct ImDrawCmd
768	799	{
769	800	unsigned int vtx_count; // Number of vertices (multiple of 3) to be drawn as triangles. The vertices are stored in the callee ImDrawList's vtx_buffer[] array.
r244869	r244870
802	833
803	834	// [Internal to ImGui]
804	835	ImVector<ImVec4> clip_rect_stack; // [Internal]
805		ImVector<ImTextureID> texture_id_stack; // [Internal]
	836	ImVector<ImTextureID> texture_id_stack; // [Internal]
806	837	ImDrawVert* vtx_write; // [Internal] point within vtx_buffer after each add command (to avoid using the ImVector<> operators too much)
807	838
808	839	ImDrawList() { Clear(); }
r244869	r244870
812	843	IMGUI_API void PushTextureID(const ImTextureID& texture_id);
813	844	IMGUI_API void PopTextureID();
814	845
815		// Primitives
	846	// Primitives
816	847	IMGUI_API void AddLine(const ImVec2& a, const ImVec2& b, ImU32 col);
817	848	IMGUI_API void AddRect(const ImVec2& a, const ImVec2& b, ImU32 col, float rounding = 0.0f, int rounding_corners=0x0F);
818	849	IMGUI_API void AddRectFilled(const ImVec2& a, const ImVec2& b, ImU32 col, float rounding = 0.0f, int rounding_corners=0x0F);
r244869	r244870
897	928	float FontSize; // <user set> // Height of characters, set during loading (don't change after loading)
898	929	float Scale; // = 1.0f // Base font scale, multiplied by the per-window font scale which you can adjust with SetFontScale()
899	930	ImVec2 DisplayOffset; // = (0.0f,0.0f) // Offset font rendering by xx pixels
900		ImWchar FallbackChar; // = '?' // Replacement glyph if one isn't found.
	931	ImWchar FallbackChar; // = '?' // Replacement glyph if one isn't found. Only set via SetFallbackChar()
901	932
902	933	// Members: Runtime data
903	934	struct Glyph
r244869	r244870
910	941	};
911	942	ImFontAtlas* ContainerAtlas; // What we has been loaded into
912	943	ImVector<Glyph> Glyphs;
	944	const Glyph* FallbackGlyph; // == FindGlyph(FontFallbackChar)
	945	float FallbackXAdvance; //
	946	ImVector<float> IndexXAdvance; // Glyphs->XAdvance directly indexable (for CalcTextSize functions which are often bottleneck in large UI)
913	947	ImVector<int> IndexLookup; // Index glyphs by Unicode code-point
914		const Glyph* FallbackGlyph; // == FindGlyph(FontFallbackChar)
915	948
916	949	// Methods
917	950	IMGUI_API ImFont();
r244869	r244870
919	952	IMGUI_API void Clear();
920	953	IMGUI_API void BuildLookupTable();
921	954	IMGUI_API const Glyph* FindGlyph(unsigned short c) const;
	955	IMGUI_API void SetFallbackChar(ImWchar c);
922	956	IMGUI_API bool IsLoaded() const { return ContainerAtlas != NULL; }
923	957
924	958	// 'max_width' stops rendering after a certain width (could be turned into a 2d size). FLT_MAX to disable.

trunk/3rdparty/bgfx/README.md
r244869	r244870
73	73	focusing on racing games.
74	74	![ios](http://www.dogbytegames.com/bgfx/offroadlegends2_bgfx_ipad2.jpg)
75	75
	76	https://github.com/andr3wmac/Torque6 Torque 6 is an MIT licensed 3D engine
	77	loosely based on Torque2D. Being neither Torque2D or Torque3D it is the 6th
	78	derivative of the original Torque Engine.
	79
	80	https://github.com/cgbystrom/twinkle GPU-accelerated UI framework powered by
	81	JavaScript for desktop/mobile apps. Idea is to combine the fast workflow and
	82	deployment model of web with the performance of native code and GPU acceleration.
	83
76	84	Examples
77	85	--------
78	86

trunk/3rdparty/bgfx/examples/common/entry/entry.cpp
r244869	r244870
34	34	}
35	35	#endif // ENTRY_CONFIG_IMPLEMENT_DEFAULT_ALLOCATOR
36	36
	37	char keyToAscii(Key::Enum _key, uint8_t _modifiers)
	38	{
	39	const bool isAscii = (Key::Key0 <= _key && _key <= Key::KeyZ)
	40	\|\| (Key::Esc <= _key && _key <= Key::Minus);
	41	if (!isAscii)
	42	{
	43	return '\0';
	44	}
	45
	46	const bool isNumber = (Key::Key0 <= _key && _key <= Key::Key9);
	47	if (isNumber)
	48	{
	49	return '0' + (_key - Key::Key0);
	50	}
	51
	52	const bool isChar = (Key::KeyA <= _key && _key <= Key::KeyZ);
	53	if (isChar)
	54	{
	55	enum { ShiftMask = Modifier::LeftShift\|Modifier::RightShift };
	56
	57	const bool shift = !!(_modifiers&ShiftMask);
	58	return (shift ? 'A' : 'a') + (_key - Key::KeyA);
	59	}
	60
	61	switch (_key)
	62	{
	63	case Key::Esc: { return 0x1b; } break;
	64	case Key::Return: { return 0x0d; } break;
	65	case Key::Tab: { return 0x09; } break;
	66	case Key::Space: { return 0xa0; } break;
	67	case Key::Backspace: { return 0x08; } break;
	68	case Key::Plus: { return 0x2b; } break;
	69	case Key::Minus: { return 0x2d; } break;
	70	default: { return '\0'; } break;
	71	}
	72	}
	73
37	74	bool setOrToggle(uint32_t& _flags, const char* _name, uint32_t _bit, int _first, int _argc, char const* const* _argv)
38	75	{
39	76	if (0 == strcmp(_argv[_first], _name) )

trunk/3rdparty/bgfx/examples/common/entry/entry.h
r244869	r244870
211	211	void setWindowSize(WindowHandle _handle, uint32_t _width, uint32_t _height);
212	212	void setWindowTitle(WindowHandle _handle, const char* _title);
213	213	void toggleWindowFrame(WindowHandle _handle);
	214	void toggleFullscreen(WindowHandle _handle);
214	215	void setMouseLock(WindowHandle _handle, bool _lock);
215	216
216	217	struct WindowState

trunk/3rdparty/bgfx/examples/common/entry/entry_android.cpp
r244869	r244870
440	440	BX_UNUSED(_handle);
441	441	}
442	442
	443	void toggleFullscreen(WindowHandle _handle)
	444	{
	445	BX_UNUSED(_handle);
	446	}
	447
443	448	void setMouseLock(WindowHandle _handle, bool _lock)
444	449	{
445	450	BX_UNUSED(_handle, _lock);

trunk/3rdparty/bgfx/examples/common/entry/entry_asmjs.cpp
r244869	r244870
59	59	BX_UNUSED(_handle);
60	60	}
61	61
	62	void toggleFullscreen(WindowHandle _handle)
	63	{
	64	BX_UNUSED(_handle);
	65	}
	66
62	67	void setMouseLock(WindowHandle _handle, bool _lock)
63	68	{
64	69	BX_UNUSED(_handle, _lock);

trunk/3rdparty/bgfx/examples/common/entry/entry_ios.mm
r244869	r244870
126	126	BX_UNUSED(_handle);
127	127	}
128	128
	129	void toggleFullscreen(WindowHandle _handle)
	130	{
	131	BX_UNUSED(_handle);
	132	}
	133
129	134	void setMouseLock(WindowHandle _handle, bool _lock)
130	135	{
131	136	BX_UNUSED(_handle, _lock);

trunk/3rdparty/bgfx/examples/common/entry/entry_nacl.cpp
r244869	r244870
94	94	BX_UNUSED(_handle);
95	95	}
96	96
	97	void toggleFullscreen(WindowHandle _handle)
	98	{
	99	BX_UNUSED(_handle);
	100	}
	101
97	102	void setMouseLock(WindowHandle _handle, bool _lock)
98	103	{
99	104	BX_UNUSED(_handle, _lock);

trunk/3rdparty/bgfx/examples/common/entry/entry_osx.mm
r244869	r244870
81	81	, m_mx(0)
82	82	, m_my(0)
83	83	, m_scroll(0)
	84	, m_style(0)
84	85	, m_exit(false)
	86	, m_fullscreen(false)
85	87	{
86	88	s_translateKey[27] = Key::Esc;
87	89	s_translateKey[13] = Key::Return;
r244869	r244870
138	140	NSWindow* window = m_window[handle.idx];
139	141	NSRect originalFrame = [window frame];
140	142	NSPoint location = [window mouseLocationOutsideOfEventStream];
141		NSRect adjustFrame = [~~NSW~~indow contentRectForFrameRect: originalFrame ~~styleMask: NSTitledWindowMask~~];
	143	NSRect adjustFrame = [window contentRectForFrameRect: originalFrame];
142	144
143	145	int x = location.x;
144	146	int y = (int)adjustFrame.size.height - (int)location.y;
r244869	r244870
246	248	case NSLeftMouseDown:
247	249	{
248	250	// TODO: remove!
249		// ~~Shift~~ + Left Mouse Button acts as middle! This just a temporary solution!
	251	// Command + Left Mouse Button acts as middle! This just a temporary solution!
250	252	// This is becase the average OSX user doesn't have middle mouse click.
251		MouseButton::Enum mb = ([event modifierFlags] & NS~~Shift~~KeyMask) ? MouseButton::Middle : MouseButton::Left;
	253	MouseButton::Enum mb = ([event modifierFlags] & NSCommandKeyMask) ? MouseButton::Middle : MouseButton::Left;
252	254	m_eventQueue.postMouseEvent(s_defaultWindow, m_mx, m_my, m_scroll, mb, true);
253	255	break;
254	256	}
r244869	r244870
306	308	{
307	309	m_eventQueue.postExitEvent();
308	310	}
309		else if ( (Key::Key0 <= key && key <= Key::KeyZ)
310		\|\| (Key::Esc <= key && key <= Key::Minus) )
311		{
312		m_eventQueue.postCharEvent(s_defaultWindow, 1, pressedChar);
313		return false;
314		}
315	311	else
316	312	{
317		m_eventQueue.postKeyEvent(s_defaultWindow, key, modifiers, true);
318		return false;
	313	enum { ShiftMask = Modifier::LeftShift\|Modifier::RightShift };
	314	const bool nonShiftModifiers = (0 != (modifiers&(~ShiftMask) ) );
	315	const bool isCharPressed = (Key::Key0 <= key && key <= Key::KeyZ) \|\| (Key::Esc <= key && key <= Key::Minus);
	316	const bool isText = isCharPressed && !nonShiftModifiers;
	317	if (isText)
	318	{
	319	m_eventQueue.postCharEvent(s_defaultWindow, 1, pressedChar);
	320	return false;
	321	}
	322	else
	323	{
	324	m_eventQueue.postKeyEvent(s_defaultWindow, key, modifiers, true);
	325	return false;
	326	}
319	327	}
320	328	}
321	329
r244869	r244870
354	362	WindowHandle handle = { 0 };
355	363	NSWindow* window = m_window[handle.idx];
356	364	NSRect originalFrame = [window frame];
357		NSRect rect = [~~NSW~~indow contentRectForFrameRect: originalFrame ~~styleMask: NSTitledWindowMask~~];
	365	NSRect rect = [window contentRectForFrameRect: originalFrame];
358	366	uint32_t width = uint32_t(rect.size.width);
359	367	uint32_t height = uint32_t(rect.size.height);
360	368	m_eventQueue.postSizeEvent(handle, width, height);
r244869	r244870
398	406	[menubar addItem:appMenuItem];
399	407	[NSApp setMainMenu:menubar];
400	408
	409	m_style = 0
	410	\| NSTitledWindowMask
	411	\| NSClosableWindowMask
	412	\| NSMiniaturizableWindowMask
	413	\| NSResizableWindowMask
	414	;
	415
	416	NSRect screenRect = [[NSScreen mainScreen] frame];
	417	const float centerX = (screenRect.size.width - (float)ENTRY_DEFAULT_WIDTH )*0.5f;
	418	const float centerY = (screenRect.size.height - (float)ENTRY_DEFAULT_HEIGHT)*0.5f;
	419
401	420	m_windowAlloc.alloc();
402		NSRect rect = NSMakeRect(0, 0, ENTRY_DEFAULT_WIDTH, ENTRY_DEFAULT_HEIGHT);
	421	NSRect rect = NSMakeRect(centerX, centerY, (float)ENTRY_DEFAULT_WIDTH, (float)ENTRY_DEFAULT_HEIGHT);
403	422	NSWindow* window = [[NSWindow alloc]
404	423	initWithContentRect:rect
405		styleMask:0
406		\|NSTitledWindowMask
407		\|NSClosableWindowMask
408		\|NSMiniaturizableWindowMask
409		\|NSResizableWindowMask
	424	styleMask:m_style
410	425	backing:NSBackingStoreBuffered defer:NO
411	426	];
412	427	NSString* appName = [[NSProcessInfo processInfo] processName];
413	428	[window setTitle:appName];
414		[window cascadeTopLeftFromPoint:NSMakePoint(20,20)];
415	429	[window makeKeyAndOrderFront:window];
416	430	[window setAcceptsMouseMovedEvents:YES];
417	431	[window setBackgroundColor:[NSColor blackColor]];
418	432	[[Window sharedDelegate] windowCreated:window];
419	433
420	434	m_window[0] = window;
	435	m_windowFrame = [window frame];
421	436
422	437	bgfx::osxSetNSWindow(window);
423	438
r244869	r244870
448	463	return 0;
449	464	}
450	465
	466	bool isValid(WindowHandle _handle)
	467	{
	468	return m_windowAlloc.isValid(_handle.idx);
	469	}
	470
451	471	EventQueue m_eventQueue;
452	472
453	473	bx::HandleAllocT<ENTRY_CONFIG_MAX_WINDOWS> m_windowAlloc;
454	474	NSWindow* m_window[ENTRY_CONFIG_MAX_WINDOWS];
	475	NSRect m_windowFrame;
455	476
456	477	float m_scrollf;
457	478	int32_t m_mx;
458	479	int32_t m_my;
459	480	int32_t m_scroll;
	481	int32_t m_style;
460	482	bool m_exit;
	483	bool m_fullscreen;
461	484	};
462	485
463	486	static Context s_ctx;
r244869	r244870
486	509
487	510	void destroyWindow(WindowHandle _handle)
488	511	{
489		BX_UNUSED(_handle);
	512	if (s_ctx.isValid(_handle) )
	513	{
	514	dispatch_async(dispatch_get_main_queue()
	515	, ^{
	516	[s_ctx.m_window[_handle.idx] performClose: nil];
	517	});
	518	}
490	519	}
491	520
492	521	void setWindowPos(WindowHandle _handle, int32_t _x, int32_t _y)
493	522	{
494		BX_UNUSED(_handle, _x, _y);
	523	if (s_ctx.isValid(_handle) )
	524	{
	525	NSWindow* window = s_ctx.m_window[_handle.idx];
	526	NSScreen* screen = [window screen];
	527
	528	NSRect screenRect = [screen frame];
	529	CGFloat menuBarHeight = [[[NSApplication sharedApplication] mainMenu] menuBarHeight];
	530
	531	NSPoint position = { float(_x), screenRect.size.height - menuBarHeight - float(_y) };
	532
	533	dispatch_async(dispatch_get_main_queue()
	534	, ^{
	535	[window setFrameTopLeftPoint: position];
	536	});
	537	}
495	538	}
496	539
497	540	void setWindowSize(WindowHandle _handle, uint32_t _width, uint32_t _height)
498	541	{
499		BX_UNUSED(_handle, _width, _height);
	542	if (s_ctx.isValid(_handle) )
	543	{
	544	NSSize size = { float(_width), float(_height) };
	545	dispatch_async(dispatch_get_main_queue()
	546	, ^{
	547	[s_ctx.m_window[_handle.idx] setContentSize: size];
	548	});
	549	}
500	550	}
501	551
502	552	void setWindowTitle(WindowHandle _handle, const char* _title)
503	553	{
504		BX_UNUSED(_handle, _title);
	554	if (s_ctx.isValid(_handle) )
	555	{
	556	NSString* title = [[NSString alloc] initWithCString:_title encoding:1];
	557	dispatch_async(dispatch_get_main_queue()
	558	, ^{
	559	[s_ctx.m_window[_handle.idx] setTitle: title];
	560	});
	561	[title release];
	562	}
505	563	}
506	564
507	565	void toggleWindowFrame(WindowHandle _handle)
508	566	{
509		BX_UNUSED(_handle);
	567	if (s_ctx.isValid(_handle) )
	568	{
	569	s_ctx.m_style ^= NSTitledWindowMask;
	570	dispatch_async(dispatch_get_main_queue()
	571	, ^{
	572	[s_ctx.m_window[_handle.idx] setStyleMask: s_ctx.m_style];
	573	});
	574	}
510	575	}
511	576
	577	void toggleFullscreen(WindowHandle _handle)
	578	{
	579	if (s_ctx.isValid(_handle) )
	580	{
	581	NSWindow* window = s_ctx.m_window[_handle.idx];
	582	NSScreen* screen = [window screen];
	583	NSRect screenRect = [screen frame];
	584
	585	if (!s_ctx.m_fullscreen)
	586	{
	587	[NSMenu setMenuBarVisible: false];
	588	s_ctx.m_style &= ~NSTitledWindowMask;
	589	dispatch_async(dispatch_get_main_queue()
	590	, ^{
	591	[window setStyleMask: s_ctx.m_style];
	592	[window setFrame:screenRect display:YES];
	593	});
	594
	595	s_ctx.m_fullscreen = true;
	596	}
	597	else
	598	{
	599	[NSMenu setMenuBarVisible: true];
	600	s_ctx.m_style \|= NSTitledWindowMask;
	601	dispatch_async(dispatch_get_main_queue()
	602	, ^{
	603	[window setStyleMask: s_ctx.m_style];
	604	[window setFrame:s_ctx.m_windowFrame display:YES];
	605	});
	606
	607	s_ctx.m_fullscreen = false;
	608	}
	609	}
	610	}
	611
512	612	void setMouseLock(WindowHandle _handle, bool _lock)
513	613	{
514	614	BX_UNUSED(_handle, _lock);
r244869	r244870
610	710	using namespace entry;
611	711	s_ctx.windowDidResize();
612	712	}
	713
613	714	@end
614	715
615	716	int main(int _argc, char** _argv)

trunk/3rdparty/bgfx/examples/common/entry/entry_p.h
r244869	r244870
56	56
57	57	int main(int _argc, char** _argv);
58	58
	59	char keyToAscii(Key::Enum _key, uint8_t _modifiers);
	60
59	61	struct Event
60	62	{
61	63	enum Enum

trunk/3rdparty/bgfx/examples/common/entry/entry_qnx.cpp
r244869	r244870
59	59	BX_UNUSED(_handle);
60	60	}
61	61
	62	void toggleFullscreen(WindowHandle _handle)
	63	{
	64	BX_UNUSED(_handle);
	65	}
	66
62	67	void setMouseLock(WindowHandle _handle, bool _lock)
63	68	{
64	69	BX_UNUSED(_handle, _lock);

trunk/3rdparty/bgfx/examples/common/entry/entry_sdl.cpp
r244869	r244870
179	179	SDL_USER_WINDOW_SET_POS,
180	180	SDL_USER_WINDOW_SET_SIZE,
181	181	SDL_USER_WINDOW_TOGGLE_FRAME,
	182	SDL_USER_WINDOW_TOGGLE_FULL_SCREEN,
182	183	SDL_USER_WINDOW_MOUSE_LOCK,
183	184	};
184	185
r244869	r244870
191	192	union { void* p; WindowHandle h; } cast;
192	193	cast.h = _handle;
193	194	uev.data1 = cast.p;
194
	195
195	196	uev.data2 = _msg;
196	197	uev.code = _code;
197	198	SDL_PushEvent(&event);
r244869	r244870
211	212	, m_height(ENTRY_DEFAULT_HEIGHT)
212	213	, m_aspectRatio(16.0f/9.0f)
213	214	, m_mouseLock(false)
	215	, m_fullscreen(false)
214	216	{
215	217	memset(s_translateKey, 0, sizeof(s_translateKey) );
216	218	initTranslateKey(SDL_SCANCODE_ESCAPE, Key::Esc);
r244869	r244870
410	412	break;
411	413
412	414	case SDL_KEYDOWN:
	415	{
	416	const SDL_KeyboardEvent& kev = event.key;
	417	WindowHandle handle = findHandle(kev.windowID);
	418	if (isValid(handle) )
	419	{
	420	uint8_t modifiers = translateKeyModifiers(kev.keysym.mod);
	421	Key::Enum key = translateKey(kev.keysym.scancode);
	422
	423	const uint8_t shiftMask = Modifier::LeftShift\|Modifier::RightShift;
	424	const bool nonShiftModifiers = (0 != (modifiers&(~shiftMask) ) );
	425	const bool isCharPressed = (Key::Key0 <= key && key <= Key::KeyZ) \|\| (Key::Esc <= key && key <= Key::Minus);
	426	const bool isText = isCharPressed && !nonShiftModifiers;
	427
	428	if (isText)
	429	{
	430	uint8_t pressedChar[4];
	431	pressedChar[0] = keyToAscii(key, modifiers);
	432	m_eventQueue.postCharEvent(handle, 1, pressedChar);
	433	}
	434	else
	435	{
	436	m_eventQueue.postKeyEvent(handle, key, modifiers, kev.state == SDL_PRESSED);
	437	}
	438	}
	439	}
	440	break;
413	441	case SDL_KEYUP:
414	442	{
415	443	const SDL_KeyboardEvent& kev = event.key;
r244869	r244870
615	643	}
616	644	break;
617	645
	646	case SDL_USER_WINDOW_TOGGLE_FULL_SCREEN:
	647	{
	648	WindowHandle handle = getWindowHandle(uev);
	649	m_fullscreen = !m_fullscreen;
	650	SDL_SetWindowFullscreen(m_window[handle.idx], m_fullscreen ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0);
	651	}
	652	break;
	653
618	654	case SDL_USER_WINDOW_MOUSE_LOCK:
619	655	{
620	656	SDL_SetRelativeMouseMode(!!uev.code ? SDL_TRUE : SDL_FALSE);
r244869	r244870
669	705	m_width = _width;
670	706	m_height = _height;
671	707
672		if (m_width < m_height)
673		{
674		float aspectRatio = 1.0f/m_aspectRatio;
675		m_width = bx::uint32_max(ENTRY_DEFAULT_WIDTH/4, m_width);
676		m_height = uint32_t(float(m_width)*aspectRatio);
677		}
678		else
679		{
680		float aspectRatio = m_aspectRatio;
681		m_height = bx::uint32_max(ENTRY_DEFAULT_HEIGHT/4, m_height);
682		m_width = uint32_t(float(m_height)*aspectRatio);
683		}
684
685	708	SDL_SetWindowSize(m_window[_handle.idx], m_width, m_height);
686	709	m_eventQueue.postSizeEvent(_handle, m_width, m_height);
687	710	}
r244869	r244870
723	746	int32_t m_mx;
724	747	int32_t m_my;
725	748	bool m_mouseLock;
	749	bool m_fullscreen;
726	750	};
727	751
728	752	static Context s_ctx;
r244869	r244870
805	829	sdlPostEvent(SDL_USER_WINDOW_TOGGLE_FRAME, _handle);
806	830	}
807	831
	832	void toggleFullscreen(WindowHandle _handle)
	833	{
	834	sdlPostEvent(SDL_USER_WINDOW_TOGGLE_FULL_SCREEN, _handle);
	835	}
	836
808	837	void setMouseLock(WindowHandle _handle, bool _lock)
809	838	{
810	839	sdlPostEvent(SDL_USER_WINDOW_MOUSE_LOCK, _handle, NULL, _lock);

trunk/3rdparty/bgfx/examples/common/entry/entry_windows.cpp
r244869	r244870
1067	1067	PostMessage(s_ctx.m_hwnd[0], WM_USER_WINDOW_TOGGLE_FRAME, _handle.idx, 0);
1068	1068	}
1069	1069
	1070	void toggleFullscreen(WindowHandle _handle)
	1071	{
	1072	BX_UNUSED(_handle);
	1073	}
	1074
1070	1075	void setMouseLock(WindowHandle _handle, bool _lock)
1071	1076	{
1072	1077	PostMessage(s_ctx.m_hwnd[0], WM_USER_WINDOW_MOUSE_LOCK, _handle.idx, _lock);

trunk/3rdparty/bgfx/examples/common/entry/entry_winrt.cpp
r244869	r244870
175	175	BX_UNUSED(_handle);
176	176	}
177	177
	178	void toggleFullscreen(WindowHandle _handle)
	179	{
	180	BX_UNUSED(_handle);
	181	}
	182
178	183	void setMouseLock(WindowHandle _handle, bool _lock)
179	184	{
180	185	BX_UNUSED(_handle, _lock);

trunk/3rdparty/bgfx/examples/common/entry/entry_x11.cpp
r244869	r244870
664	664	BX_UNUSED(_handle);
665	665	}
666	666
	667	void toggleFullscreen(WindowHandle _handle)
	668	{
	669	BX_UNUSED(_handle);
	670	}
	671
667	672	void setMouseLock(WindowHandle _handle, bool _lock)
668	673	{
669	674	BX_UNUSED(_handle, _lock);

trunk/3rdparty/bgfx/examples/common/imgui/ocornut_imgui.cpp
r244869	r244870
165	165
166	166	ImGui::NewFrame();
167	167
168		// ImGui::ShowTestWindow();
	168	ImGui::ShowTestWindow();
169	169	}
170	170
171	171	void endFrame()

trunk/3rdparty/bgfx/scripts/bgfx.lua
r244869	r244870
46	46	}
47	47	end
48	48
	49	if (_OPTIONS["vs"] == "vs2012-xp")
	50	or (_OPTIONS["vs"] == "vs2013-xp") then
	51	configuration { "vs201*" }
	52	includedirs {
	53	"$(DXSDK_DIR)/include",
	54	}
	55	end
	56
49	57	configuration { "Debug" }
50	58	defines {
51	59	"BGFX_CONFIG_DEBUG=1",
r244869	r244870
62	70	"$(DXSDK_DIR)/include",
63	71	}
64	72
65		if (_OPTIONS["vs"] == "vs2012-xp") or (_OPTIONS["vs"] == "vs2013-xp") then
66		configuration { "vs201*" }
67		includedirs {
68		"$(DXSDK_DIR)/include",
69		}
70		end
71
72	73	configuration { "winphone8*"}
73	74	linkoptions {
74	75	"/ignore:4264" -- LNK4264: archiving object file compiled with /ZW into a static library; note that when authoring Windows Runtime types it is not recommended to link with a static library that contains Windows Runtime metadata

trunk/3rdparty/bx/include/bx/handlealloc.h
r244869	r244870
66	66	return invalid;
67	67	}
68	68
	69	bool isValid(uint16_t _handle)
	70	{
	71	uint16_t* sparse = &m_handles[MaxHandlesT];
	72	uint16_t index = sparse[_handle];
	73
	74	return (index < m_numHandles && m_handles[index] == _handle);
	75	}
	76
69	77	void free(uint16_t _handle)
70	78	{
71	79	BX_CHECK(0 < m_numHandles, "Freeing invalid handle %d.", _handle);
r244869	r244870
139	147	return invalid;
140	148	}
141	149
	150	bool isValid(uint16_t _handle)
	151	{
	152	uint16_t* sparse = &m_handles[m_maxHandles];
	153	uint16_t index = sparse[_handle];
	154
	155	return (index < m_numHandles && m_handles[index] == _handle);
	156	}
	157
142	158	void free(uint16_t _handle)
143	159	{
144	160	uint16_t* sparse = &m_handles[m_maxHandles];

trunk/3rdparty/genie/README.md
r244869	r244870
14	14	Download (stable)
15	15	-----------------
16	16
17		version ~~197~~ (commit ~~2b34cf0f0831d2~~65~~b274~~d8e1~~1a2~~4bf6320d73~~d6e~~)
	17	version 206 (commit e65d8143b1186496b9da03c6461a25402a2ee873)
18	18
19	19	Linux:
20	20	https://github.com/bkaradzic/bx/raw/master/tools/bin/linux/genie
r244869	r244870
96	96	confusion for users who are not familiar with Premake, and they just need to
97	97	use Premake to generate project files for project they are interested in.
98	98
99		I've been using Premake for [a while](https://carbongames.com/2011/08/Premake/),
	99	I've been using Premake for [a while](https://web.archive.org/web/20120119020903/http://carbongames.com/2011/08/Premake),
100	100	I really like it's simplicity, and that it does one thing really well.
101	101
102	102	I was considering replacing Premake with other build systems that also could

trunk/3rdparty/genie/src/actions/make/make_cpp.lua
r244869	r244870
5	5	--
6	6
7	7	premake.make.cpp = { }
	8	premake.make.undefine = { }
8	9	local cpp = premake.make.cpp
9	10	local make = premake.make
10	11
r244869	r244870
173	174	_p(' config=%s', _MAKE.esc(premake.getconfigname(prj.solution.configurations[1], platforms[1], true)))
174	175	_p('endif')
175	176	_p('')
176
	177	for _, variable in ipairs(premake.make.undefine) do
	178	_p('override undefine '.. variable)
	179	end
	180	_p('')
177	181	_p('ifndef verbose')
178	182	_p(' SILENT = @')
179	183	_p('endif')

trunk/3rdparty/genie/src/host/premake.c
r244869	r244870
359	359	}
360	360	}
361	361
	362	/* set error handler to get tracebacks in built-in scripts */
	363	lua_getglobal(L, "debug");
	364	lua_getfield(L, -1, "traceback");
	365	lua_remove(L, -2);
	366	int ehpos = lua_gettop(L);
	367
362	368	/* hand off control to the scripts */
363	369	lua_getglobal(L, "_premake_main");
364		if (lua_pcall(L, 0, 1, 0) != OKAY)
	370	if (lua_pcall(L, 0, 1, ehpos) != OKAY)
365	371	{
366	372	printf(ERROR_MESSAGE, lua_tostring(L, -1));
367	373	return !OKAY;

trunk/3rdparty/genie/src/host/scripts.c
r244869	r244870
179	179	"ative(sln.location, prj.location)), _MAKE.esc(_MAKE.getmakefilename(prj, true)))\n_p('')\nend\n_p('clean:')\nfor _ ,prj in ipairs(sln.projects) do\n_p('\\t@${MAKE} --no-print-directory -C %s -f %s clean', _MAKE.esc(path.getrelative(sln.location, prj.location)), _MAKE.esc(_MAKE.getmakefilename(prj, true)))\nend\n_p('')\n_p('help:')\n_p(1,'@echo \"Usage: make [config=name] [target]\"')\n_p(1,'@echo \"\"')\n_p(1,'@echo \"CONFIGURATIONS:\"')\nlocal cfgpairs = { }\nfor _, platform in ipairs(platforms) do\nfor _, cfgname in ipairs(sln.configurations) do\n_p(1,'@echo \" %s\"', premake.getconfigname(cfgname, platform, true))\nend\nend\n_p(1,'@echo \"\"')\n_p(1,'@echo \"TARGETS:\"')\n_p(1,'@echo \" all (default)\"')\n_p(1,'@echo \" clean\"')\nfor _, prj in ipairs(sln.projects) do\n_p(1,'@echo \" %s\"', prj.name)\nend\n_p(1,'@echo \"\"')\n_p(1,'@echo \"For more information, see http://industriousone.com/premake/quick-start\"')\nend\n",
180	180
181	181	/* actions/make/make_cpp.lua */
182		"premake.make.cpp = { }\nlocal cpp = premake.make.cpp\nlocal make = premake.make\nfunction premake.make_cpp(prj)\nlocal cc = premake.gettool(prj)\nlocal platforms = premake.filterplatforms(prj.solution, cc.platforms, \"Native\")\npremake.gmake_cpp_header(prj, cc, platforms)\nfor _, platform in ipairs(platforms) do\nfor cfg in premake.eachconfig(prj, platform) do\npremake.gmake_cpp_config(prj, cfg, cc)\nend\nend\nlocal objdirs = {}\nfor _, file in ipairs(prj.files) do\nif path.iscppfile(file) then\nobjdirs[_MAKE.esc(path.getdirectory(path.trimdots(file)))] = 1\nend\nend\n_p('OBJDIRS := \\\\')\n_p('\\t$(OBJDIR) \\\\')\nfor dir, _ in pairs(objdirs) do\n_p('\\t$(OBJDIR)/%s \\\\', dir)\nend\n_p('')\n_p('RESOURCES := \\\\')\nfor _, file in ipairs(prj.files) do\nif path.isresourcefile(file) then\n_p('\\t$(OBJDIR)/%s.res \\\\', _MAKE.esc(path.getbasename(file)))\nend\nend\n_p('')\n_p('.PHONY: clean prebuild prelink')\n_p('')\nif os.is(\"MacOSX\") and prj.kind == \"WindowedApp\" then\n_p('all: $(TARGETDIR) $(OBJDIRS) pr"
183		"ebuild prelink $(TARGET) $(dir $(TARGETDIR))PkgInfo $(dir $(TARGETDIR))Info.plist')\nelse\n_p('all: $(TARGETDIR) $(OBJDIRS) prebuild prelink $(TARGET)')\nend\n_p('\\t@:')\n_p('')\nif (prj.kind == \"StaticLib\" and prj.options.ArchiveSplit) then\n_p('define max_args')\n_p('\\t$(eval _args:=)')\n_p('\\t$(foreach obj,$3,$(eval _args+=$(obj))$(if $(word $2,$(_args)),$1$(_args)$(EOL)$(eval _args:=)))')\n_p('\\t$(if $(_args),$1$(_args))')\n_p('endef')\n_p('')\n_p('define EOL')\n_p('')\n_p('')\n_p('endef')\n_p('')\nend\n_p('$(TARGET): $(GCH) $(OBJECTS) $(LDDEPS) $(RESOURCES)')\nif prj.kind == \"StaticLib\" then\nif prj.msgarchiving then\n_p('\\t@echo ' .. prj.msgarchiving)\nelse\n_p('\\t@echo Archiving %s', prj.name)\nend\nif (not prj.archivesplit_size) then \nprj.archivesplit_size=200\nend\nif (not prj.options.ArchiveSplit) then\n_p('\\t$(SILENT) $(LINKCMD) $(OBJECTS)')\nelse\n_p('\\t@$(call max_args,$(LINKCMD),'.. prj.archivesplit_size ..',$(OBJECTS))')\nend\nelse\nif prj.msglinking then\n_p('\\t@echo ' .. prj.msgl"
184		"inking)\nelse\n_p('\\t@echo Linking %s', prj.name)\nend\n_p('\\t$(SILENT) $(LINKCMD)')\nend\n_p('\\t$(POSTBUILDCMDS)')\n_p('')\n_p('$(TARGETDIR):')\npremake.make_mkdirrule(\"$(TARGETDIR)\")\n_p('$(OBJDIRS):')\nif (not prj.solution.messageskip) or (not table.contains(prj.solution.messageskip, \"SkipCreatingMessage\")) then\n_p('\\t@echo Creating $(OBJDIR)')\nend\n_p('\\t-$(call MKDIR,$(OBJDIR))')\nfor dir, _ in pairs(objdirs) do\n_p('\\t-$(call MKDIR,$(OBJDIR)/%s)', dir)\nend\n_p('')\nif os.is(\"MacOSX\") and prj.kind == \"WindowedApp\" then\n_p('$(dir $(TARGETDIR))PkgInfo:')\n_p('$(dir $(TARGETDIR))Info.plist:')\n_p('')\nend\n_p('clean:')\nif (not prj.solution.messageskip) or (not table.contains(prj.solution.messageskip, \"SkipCleaningMessage\")) then\n_p('\\t@echo Cleaning %s', prj.name)\nend\n_p('ifeq (posix,$(SHELLTYPE))')\n_p('\\t$(SILENT) rm -f $(TARGET)')\n_p('\\t$(SILENT) rm -rf $(OBJDIR)')\n_p('else')\n_p('\\t$(SILENT) if exist $(subst /,\\\\\\\\,$(TARGET)) del $(subst /,\\\\\\\\,$(TARGET))')\n_p('\\t"
185		"$(SILENT) if exist $(subst /,\\\\\\\\,$(OBJDIR)) rmdir /s /q $(subst /,\\\\\\\\,$(OBJDIR))')\n_p('endif')\n_p('')\n_p('prebuild:')\n_p('\\t$(PREBUILDCMDS)')\n_p('')\n_p('prelink:')\n_p('\\t$(PRELINKCMDS)')\n_p('')\ncpp.pchrules(prj)\ncpp.fileRules(prj)\n_p('-include $(OBJECTS:%%.o=%%.d)')\n_p('ifneq (,$(PCH))')\n_p(' -include $(OBJDIR)/$(notdir $(PCH)).d')\n_p('endif')\nend\nfunction premake.gmake_cpp_header(prj, cc, platforms)\n_p('# %s project makefile autogenerated by GENie', premake.action.current().shortname)\n_p('ifndef config')\n_p(' config=%s', _MAKE.esc(premake.getconfigname(prj.solution.configurations[1], platforms[1], true)))\n_p('endif')\n_p('')\n_p('ifndef verbose')\n_p(' SILENT = @')\n_p('endif')\n_p('')\n_p('SHELLTYPE := msdos')\n_p('ifeq (,$(ComSpec)$(COMSPEC))')\n_p(' SHELLTYPE := posix')\n_p('endif')\n_p('ifeq (/bin,$(findstring /bin,$(SHELL)))')\n_p(' SHELLTYPE := posix')\n_p('endif')\n_p('')\n_p('ifeq (posix,$(SHELLTYPE))')\n_p(' MKDIR = $(SILENT) mkdir -p \"$(1)\"')\n_p(' COPY = $("
186		"SILENT) cp -fR \"$(1)\" \"$(2)\"')\n_p('else')\n_p(' MKDIR = $(SILENT) mkdir \"$(subst /,\\\\\\\\,$(1))\" 2> nul \|\| exit 0')\n_p(' COPY = $(SILENT) copy /Y \"$(subst /,\\\\\\\\,$(1))\" \"$(subst /,\\\\\\\\,$(2))\"')\n_p('endif')\n_p('')\n_p('CC = %s', cc.cc)\n_p('CXX = %s', cc.cxx)\n_p('AR = %s', cc.ar)\n_p('')\n_p('ifndef RESCOMP')\n_p(' ifdef WINDRES')\n_p(' RESCOMP = $(WINDRES)')\n_p(' else')\n_p(' RESCOMP = windres')\n_p(' endif')\n_p('endif')\n_p('')\nend\nfunction premake.gmake_cpp_config(prj, cfg, cc)\n_p('ifeq ($(config),%s)', _MAKE.esc(cfg.shortname))\ncpp.platformtools(cfg, cc)\n_p(' OBJDIR = %s', _MAKE.esc(cfg.objectsdir))\n_p(' TARGETDIR = %s', _MAKE.esc(cfg.buildtarget.directory))\n_p(' TARGET = $(TARGETDIR)/%s', _MAKE.esc(cfg.buildtarget.name))\n_p(' DEFINES +=%s', make.list(cc.getdefines(cfg.defines)))\n_p(' INCLUDES +=%s', make.list(cc.getincludedirs(cfg.includedirs)))\ncpp.pchconfig(cfg)\ncpp.flags(cfg, cc)\ncpp.linker(cfg, cc)\n_p(' OBJECTS := \\\\')\nfor _, fi"
187		"le in ipairs(prj.files) do\nif path.iscppfile(file) then\nlocal excluded = false\nfor _, exclude in ipairs(cfg.excludes) do\nexcluded = (exclude == file)\nif (excluded) then break end\nend\nif excluded == false then\n_p('\\t$(OBJDIR)/%s.o \\\\'\n, _MAKE.esc(path.trimdots(path.removeext(file)))\n)\nend\nend\nend\n_p('')\n_p(' define PREBUILDCMDS')\nif #cfg.prebuildcommands > 0 then\n_p('\\t@echo Running pre-build commands')\n_p('\\t%s', table.implode(cfg.prebuildcommands, \"\", \"\", \"\\n\\t\"))\nend\n_p(' endef')\n_p(' define PRELINKCMDS')\nif #cfg.prelinkcommands > 0 then\n_p('\\t@echo Running pre-link commands')\n_p('\\t%s', table.implode(cfg.prelinkcommands, \"\", \"\", \"\\n\\t\"))\nend\n_p(' endef')\n_p(' define POSTBUILDCMDS')\nif #cfg.postbuildcommands > 0 then\n_p('\\t@echo Running post-build commands')\n_p('\\t%s', table.implode(cfg.postbuildcommands, \"\", \"\", \"\\n\\t\"))\nend\n_p(' endef')\nmake.settings(cfg, cc)\n_p('endif')\n_p('')\nend\nfunction cpp.platformtools(cfg, cc)\nlocal platfor"
188		"m = cc.platforms[cfg.platform]\nif platform.cc then\n_p(' CC = %s', platform.cc)\nend\nif platform.cxx then\n_p(' CXX = %s', platform.cxx)\nend\nif platform.ar then\n_p(' AR = %s', platform.ar)\nend\nend\nfunction cpp.flags(cfg, cc)\nif cfg.pchheader and not cfg.flags.NoPCH then\n_p(' FORCE_INCLUDE += -include $(OBJDIR)/$(notdir $(PCH))')\nend\nif #cfg.forcedincludes > 0 then\n_p(' FORCE_INCLUDE += -include %s'\n,premake.esc(table.concat(cfg.forcedincludes, \";\")))\nend\n_p(' ALL_CPPFLAGS += $(CPPFLAGS) %s $(DEFINES) $(INCLUDES)', table.concat(cc.getcppflags(cfg), \" \"))\n_p(' ALL_CFLAGS += $(CFLAGS) $(ALL_CPPFLAGS) $(ARCH)%s', make.list(table.join(cc.getcflags(cfg), cfg.buildoptions, cfg.buildoptions_c)))\n_p(' ALL_CXXFLAGS += $(CXXFLAGS) $(CFLAGS) $(ALL_CPPFLAGS) $(ARCH)%s', make.list(table.join(cc.getcxxflags(cfg), cfg.buildoptions, cfg.buildoptions_cpp)))\n_p(' ALL_OBJCFLAGS += $(CXXFLAGS) $(CFLAGS) $(ALL_CPPFLAGS) $(ARCH)%s', make.list(table.join(cc.getcxxflags(cfg),"
189		" cfg.buildoptions, cfg.buildoptions_objc)))\n_p(' ALL_RESFLAGS += $(RESFLAGS) $(DEFINES) $(INCLUDES)%s',\n make.list(table.join(cc.getdefines(cfg.resdefines),\n cc.getincludedirs(cfg.resincludedirs), cfg.resoptions)))\nend\nfunction cpp.linker(cfg, cc)\n_p(' ALL_LDFLAGS += $(LDFLAGS)%s', make.list(table.join(cc.getlibdirflags(cfg), cc.getldflags(cfg), cfg.linkoptions)))\n_p(' LDDEPS +=%s', make.list(_MAKE.esc(premake.getlinks(cfg, \"siblings\", \"fullpath\"))))\n_p(' LIBS += $(LDDEPS)%s', make.list(cc.getlinkflags(cfg)))\nif cfg.kind == \"StaticLib\" then\nif cfg.platform:startswith(\"Universal\") then\n_p(' LINKCMD = libtool -o $(TARGET)')\nelse\nif cc.llvm then\n_p(' LINKCMD = $(AR) rcs $(TARGET)')\nelse\n_p(' LINKCMD = $(AR) -rcs $(TARGET)')\nend\nend\nelse\nlocal tool = iif(cfg.language == \"C\", \"CC\", \"CXX\")\n_p(' LINKCMD = $(%s) -o $(TARGET) $(OBJECTS) $(RESOURCES) $(ARCH) $(ALL_LDFLAGS) $(LIBS)', tool)\nend\nend\nfunction cpp.pchco"
190		"nfig(cfg)\nif not cfg.pchheader or cfg.flags.NoPCH then\nreturn\nend\nlocal pch = cfg.pchheader\nfor _, incdir in ipairs(cfg.includedirs) do\nlocal abspath = path.getabsolute(path.join(cfg.project.location, incdir))\nlocal testname = path.join(abspath, pch)\nif os.isfile(testname) then\npch = path.getrelative(cfg.location, testname)\nbreak\nend\nend\n_p(' PCH = %s', _MAKE.esc(pch))\n_p(' GCH = $(OBJDIR)/$(notdir $(PCH)).gch')\nend\nfunction cpp.pchrules(prj)\n_p('ifneq (,$(PCH))')\n_p('$(GCH): $(PCH)')\n_p('\\t@echo $(notdir $<)')\nlocal cmd = iif(prj.language == \"C\", \"$(CC) -x c-header $(ALL_CFLAGS)\", \"$(CXX) -x c++-header $(ALL_CXXFLAGS)\")\n_p('\\t$(SILENT) %s -MMD -MP $(DEFINES) $(INCLUDES) -o \"$@\" -MF \"$(@:%%.gch=%%.d)\" -c \"$<\"', cmd)\n_p('endif')\n_p('')\nend\nfunction cpp.fileRules(prj)\nfor _, file in ipairs(prj.files or {}) do\nif path.iscppfile(file) then\n_p('$(OBJDIR)/%s.o: %s'\n, _MAKE.esc(path.trimdots(path.removeext(file)))\n, _MAKE.esc(file)\n)\nif (path.isobjcfile(fi"
191		"le) and prj.msgcompile_objc) then\n_p('\\t@echo ' .. prj.msgcompile_objc)\nelseif prj.msgcompile then\n_p('\\t@echo ' .. prj.msgcompile)\nelse\n_p('\\t@echo $(notdir $<)')\nend\nif (path.isobjcfile(file)) then\n_p('\\t$(SILENT) $(CXX) $(ALL_OBJCFLAGS) $(FORCE_INCLUDE) -o \"$@\" -MF $(@:%%.o=%%.d) -c \"$<\"')\nelse\ncpp.buildcommand(path.iscfile(file) and not prj.options.ForceCPP, \"o\")\nend\n_p('')\nelseif (path.getextension(file) == \".rc\") then\n_p('$(OBJDIR)/%s.res: %s', _MAKE.esc(path.getbasename(file)), _MAKE.esc(file))\nif prj.msgresource then\n_p('\\t@echo ' .. prj.msgresource)\nelse\n_p('\\t@echo $(notdir $<)')\nend\n_p('\\t$(SILENT) $(RESCOMP) $< -O coff -o \"$@\" $(ALL_RESFLAGS)')\n_p('')\nend\nend\nend\nfunction cpp.buildcommand(iscfile, objext)\nlocal flags = iif(iscfile, '$(CC) $(ALL_CFLAGS)', '$(CXX) $(ALL_CXXFLAGS)')\n_p('\\t$(SILENT) %s $(FORCE_INCLUDE) -o \"$@\" -MF $(@:%%.%s=%%.d) -c \"$<\"', flags, objext)\nend\n",
	182	"premake.make.cpp = { }\npremake.make.undefine = { }\nlocal cpp = premake.make.cpp\nlocal make = premake.make\nfunction premake.make_cpp(prj)\nlocal cc = premake.gettool(prj)\nlocal platforms = premake.filterplatforms(prj.solution, cc.platforms, \"Native\")\npremake.gmake_cpp_header(prj, cc, platforms)\nfor _, platform in ipairs(platforms) do\nfor cfg in premake.eachconfig(prj, platform) do\npremake.gmake_cpp_config(prj, cfg, cc)\nend\nend\nlocal objdirs = {}\nfor _, file in ipairs(prj.files) do\nif path.iscppfile(file) then\nobjdirs[_MAKE.esc(path.getdirectory(path.trimdots(file)))] = 1\nend\nend\n_p('OBJDIRS := \\\\')\n_p('\\t$(OBJDIR) \\\\')\nfor dir, _ in pairs(objdirs) do\n_p('\\t$(OBJDIR)/%s \\\\', dir)\nend\n_p('')\n_p('RESOURCES := \\\\')\nfor _, file in ipairs(prj.files) do\nif path.isresourcefile(file) then\n_p('\\t$(OBJDIR)/%s.res \\\\', _MAKE.esc(path.getbasename(file)))\nend\nend\n_p('')\n_p('.PHONY: clean prebuild prelink')\n_p('')\nif os.is(\"MacOSX\") and prj.kind == \"WindowedApp\" then\n_p('al"
	183	"l: $(TARGETDIR) $(OBJDIRS) prebuild prelink $(TARGET) $(dir $(TARGETDIR))PkgInfo $(dir $(TARGETDIR))Info.plist')\nelse\n_p('all: $(TARGETDIR) $(OBJDIRS) prebuild prelink $(TARGET)')\nend\n_p('\\t@:')\n_p('')\nif (prj.kind == \"StaticLib\" and prj.options.ArchiveSplit) then\n_p('define max_args')\n_p('\\t$(eval _args:=)')\n_p('\\t$(foreach obj,$3,$(eval _args+=$(obj))$(if $(word $2,$(_args)),$1$(_args)$(EOL)$(eval _args:=)))')\n_p('\\t$(if $(_args),$1$(_args))')\n_p('endef')\n_p('')\n_p('define EOL')\n_p('')\n_p('')\n_p('endef')\n_p('')\nend\n_p('$(TARGET): $(GCH) $(OBJECTS) $(LDDEPS) $(RESOURCES)')\nif prj.kind == \"StaticLib\" then\nif prj.msgarchiving then\n_p('\\t@echo ' .. prj.msgarchiving)\nelse\n_p('\\t@echo Archiving %s', prj.name)\nend\nif (not prj.archivesplit_size) then \nprj.archivesplit_size=200\nend\nif (not prj.options.ArchiveSplit) then\n_p('\\t$(SILENT) $(LINKCMD) $(OBJECTS)')\nelse\n_p('\\t@$(call max_args,$(LINKCMD),'.. prj.archivesplit_size ..',$(OBJECTS))')\nend\nelse\nif prj.msglinking the"
	184	"n\n_p('\\t@echo ' .. prj.msglinking)\nelse\n_p('\\t@echo Linking %s', prj.name)\nend\n_p('\\t$(SILENT) $(LINKCMD)')\nend\n_p('\\t$(POSTBUILDCMDS)')\n_p('')\n_p('$(TARGETDIR):')\npremake.make_mkdirrule(\"$(TARGETDIR)\")\n_p('$(OBJDIRS):')\nif (not prj.solution.messageskip) or (not table.contains(prj.solution.messageskip, \"SkipCreatingMessage\")) then\n_p('\\t@echo Creating $(OBJDIR)')\nend\n_p('\\t-$(call MKDIR,$(OBJDIR))')\nfor dir, _ in pairs(objdirs) do\n_p('\\t-$(call MKDIR,$(OBJDIR)/%s)', dir)\nend\n_p('')\nif os.is(\"MacOSX\") and prj.kind == \"WindowedApp\" then\n_p('$(dir $(TARGETDIR))PkgInfo:')\n_p('$(dir $(TARGETDIR))Info.plist:')\n_p('')\nend\n_p('clean:')\nif (not prj.solution.messageskip) or (not table.contains(prj.solution.messageskip, \"SkipCleaningMessage\")) then\n_p('\\t@echo Cleaning %s', prj.name)\nend\n_p('ifeq (posix,$(SHELLTYPE))')\n_p('\\t$(SILENT) rm -f $(TARGET)')\n_p('\\t$(SILENT) rm -rf $(OBJDIR)')\n_p('else')\n_p('\\t$(SILENT) if exist $(subst /,\\\\\\\\,$(TARGET)) del $(subst /,"
	185	"\\\\\\\\,$(TARGET))')\n_p('\\t$(SILENT) if exist $(subst /,\\\\\\\\,$(OBJDIR)) rmdir /s /q $(subst /,\\\\\\\\,$(OBJDIR))')\n_p('endif')\n_p('')\n_p('prebuild:')\n_p('\\t$(PREBUILDCMDS)')\n_p('')\n_p('prelink:')\n_p('\\t$(PRELINKCMDS)')\n_p('')\ncpp.pchrules(prj)\ncpp.fileRules(prj)\n_p('-include $(OBJECTS:%%.o=%%.d)')\n_p('ifneq (,$(PCH))')\n_p(' -include $(OBJDIR)/$(notdir $(PCH)).d')\n_p('endif')\nend\nfunction premake.gmake_cpp_header(prj, cc, platforms)\n_p('# %s project makefile autogenerated by GENie', premake.action.current().shortname)\n_p('ifndef config')\n_p(' config=%s', _MAKE.esc(premake.getconfigname(prj.solution.configurations[1], platforms[1], true)))\n_p('endif')\n_p('')\nfor _, variable in ipairs(premake.make.undefine) do\n_p('override undefine '.. variable)\nend\n_p('')\n_p('ifndef verbose')\n_p(' SILENT = @')\n_p('endif')\n_p('')\n_p('SHELLTYPE := msdos')\n_p('ifeq (,$(ComSpec)$(COMSPEC))')\n_p(' SHELLTYPE := posix')\n_p('endif')\n_p('ifeq (/bin,$(findstring /bin,$(SHELL)))')\n_p(' SHEL"
	186	"LTYPE := posix')\n_p('endif')\n_p('')\n_p('ifeq (posix,$(SHELLTYPE))')\n_p(' MKDIR = $(SILENT) mkdir -p \"$(1)\"')\n_p(' COPY = $(SILENT) cp -fR \"$(1)\" \"$(2)\"')\n_p('else')\n_p(' MKDIR = $(SILENT) mkdir \"$(subst /,\\\\\\\\,$(1))\" 2> nul \|\| exit 0')\n_p(' COPY = $(SILENT) copy /Y \"$(subst /,\\\\\\\\,$(1))\" \"$(subst /,\\\\\\\\,$(2))\"')\n_p('endif')\n_p('')\n_p('CC = %s', cc.cc)\n_p('CXX = %s', cc.cxx)\n_p('AR = %s', cc.ar)\n_p('')\n_p('ifndef RESCOMP')\n_p(' ifdef WINDRES')\n_p(' RESCOMP = $(WINDRES)')\n_p(' else')\n_p(' RESCOMP = windres')\n_p(' endif')\n_p('endif')\n_p('')\nend\nfunction premake.gmake_cpp_config(prj, cfg, cc)\n_p('ifeq ($(config),%s)', _MAKE.esc(cfg.shortname))\ncpp.platformtools(cfg, cc)\n_p(' OBJDIR = %s', _MAKE.esc(cfg.objectsdir))\n_p(' TARGETDIR = %s', _MAKE.esc(cfg.buildtarget.directory))\n_p(' TARGET = $(TARGETDIR)/%s', _MAKE.esc(cfg.buildtarget.name))\n_p(' DEFINES +=%s', make.list(cc.getdefines(cfg.defines)))\n_p(' INCLUDES +=%s', make.list("
	187	"cc.getincludedirs(cfg.includedirs)))\ncpp.pchconfig(cfg)\ncpp.flags(cfg, cc)\ncpp.linker(cfg, cc)\n_p(' OBJECTS := \\\\')\nfor _, file in ipairs(prj.files) do\nif path.iscppfile(file) then\nlocal excluded = false\nfor _, exclude in ipairs(cfg.excludes) do\nexcluded = (exclude == file)\nif (excluded) then break end\nend\nif excluded == false then\n_p('\\t$(OBJDIR)/%s.o \\\\'\n, _MAKE.esc(path.trimdots(path.removeext(file)))\n)\nend\nend\nend\n_p('')\n_p(' define PREBUILDCMDS')\nif #cfg.prebuildcommands > 0 then\n_p('\\t@echo Running pre-build commands')\n_p('\\t%s', table.implode(cfg.prebuildcommands, \"\", \"\", \"\\n\\t\"))\nend\n_p(' endef')\n_p(' define PRELINKCMDS')\nif #cfg.prelinkcommands > 0 then\n_p('\\t@echo Running pre-link commands')\n_p('\\t%s', table.implode(cfg.prelinkcommands, \"\", \"\", \"\\n\\t\"))\nend\n_p(' endef')\n_p(' define POSTBUILDCMDS')\nif #cfg.postbuildcommands > 0 then\n_p('\\t@echo Running post-build commands')\n_p('\\t%s', table.implode(cfg.postbuildcommands, \"\", \"\", "
	188	"\"\\n\\t\"))\nend\n_p(' endef')\nmake.settings(cfg, cc)\n_p('endif')\n_p('')\nend\nfunction cpp.platformtools(cfg, cc)\nlocal platform = cc.platforms[cfg.platform]\nif platform.cc then\n_p(' CC = %s', platform.cc)\nend\nif platform.cxx then\n_p(' CXX = %s', platform.cxx)\nend\nif platform.ar then\n_p(' AR = %s', platform.ar)\nend\nend\nfunction cpp.flags(cfg, cc)\nif cfg.pchheader and not cfg.flags.NoPCH then\n_p(' FORCE_INCLUDE += -include $(OBJDIR)/$(notdir $(PCH))')\nend\nif #cfg.forcedincludes > 0 then\n_p(' FORCE_INCLUDE += -include %s'\n,premake.esc(table.concat(cfg.forcedincludes, \";\")))\nend\n_p(' ALL_CPPFLAGS += $(CPPFLAGS) %s $(DEFINES) $(INCLUDES)', table.concat(cc.getcppflags(cfg), \" \"))\n_p(' ALL_CFLAGS += $(CFLAGS) $(ALL_CPPFLAGS) $(ARCH)%s', make.list(table.join(cc.getcflags(cfg), cfg.buildoptions, cfg.buildoptions_c)))\n_p(' ALL_CXXFLAGS += $(CXXFLAGS) $(CFLAGS) $(ALL_CPPFLAGS) $(ARCH)%s', make.list(table.join(cc.getcxxflags(cfg), cfg.buildoptions, cfg.b"
	189	"uildoptions_cpp)))\n_p(' ALL_OBJCFLAGS += $(CXXFLAGS) $(CFLAGS) $(ALL_CPPFLAGS) $(ARCH)%s', make.list(table.join(cc.getcxxflags(cfg), cfg.buildoptions, cfg.buildoptions_objc)))\n_p(' ALL_RESFLAGS += $(RESFLAGS) $(DEFINES) $(INCLUDES)%s',\n make.list(table.join(cc.getdefines(cfg.resdefines),\n cc.getincludedirs(cfg.resincludedirs), cfg.resoptions)))\nend\nfunction cpp.linker(cfg, cc)\n_p(' ALL_LDFLAGS += $(LDFLAGS)%s', make.list(table.join(cc.getlibdirflags(cfg), cc.getldflags(cfg), cfg.linkoptions)))\n_p(' LDDEPS +=%s', make.list(_MAKE.esc(premake.getlinks(cfg, \"siblings\", \"fullpath\"))))\n_p(' LIBS += $(LDDEPS)%s', make.list(cc.getlinkflags(cfg)))\nif cfg.kind == \"StaticLib\" then\nif cfg.platform:startswith(\"Universal\") then\n_p(' LINKCMD = libtool -o $(TARGET)')\nelse\nif cc.llvm then\n_p(' LINKCMD = $(AR) rcs $(TARGET)')\nelse\n_p(' LINKCMD = $(AR) -rcs $(TARGET)')\nend\nend\nelse\nlocal tool = iif(cfg.language == \"C\", \"CC\", \"CXX"
	190	"\")\n_p(' LINKCMD = $(%s) -o $(TARGET) $(OBJECTS) $(RESOURCES) $(ARCH) $(ALL_LDFLAGS) $(LIBS)', tool)\nend\nend\nfunction cpp.pchconfig(cfg)\nif not cfg.pchheader or cfg.flags.NoPCH then\nreturn\nend\nlocal pch = cfg.pchheader\nfor _, incdir in ipairs(cfg.includedirs) do\nlocal abspath = path.getabsolute(path.join(cfg.project.location, incdir))\nlocal testname = path.join(abspath, pch)\nif os.isfile(testname) then\npch = path.getrelative(cfg.location, testname)\nbreak\nend\nend\n_p(' PCH = %s', _MAKE.esc(pch))\n_p(' GCH = $(OBJDIR)/$(notdir $(PCH)).gch')\nend\nfunction cpp.pchrules(prj)\n_p('ifneq (,$(PCH))')\n_p('$(GCH): $(PCH)')\n_p('\\t@echo $(notdir $<)')\nlocal cmd = iif(prj.language == \"C\", \"$(CC) -x c-header $(ALL_CFLAGS)\", \"$(CXX) -x c++-header $(ALL_CXXFLAGS)\")\n_p('\\t$(SILENT) %s -MMD -MP $(DEFINES) $(INCLUDES) -o \"$@\" -MF \"$(@:%%.gch=%%.d)\" -c \"$<\"', cmd)\n_p('endif')\n_p('')\nend\nfunction cpp.fileRules(prj)\nfor _, file in ipairs(prj.files or {}) do\nif path.iscppf"
	191	"ile(file) then\n_p('$(OBJDIR)/%s.o: %s'\n, _MAKE.esc(path.trimdots(path.removeext(file)))\n, _MAKE.esc(file)\n)\nif (path.isobjcfile(file) and prj.msgcompile_objc) then\n_p('\\t@echo ' .. prj.msgcompile_objc)\nelseif prj.msgcompile then\n_p('\\t@echo ' .. prj.msgcompile)\nelse\n_p('\\t@echo $(notdir $<)')\nend\nif (path.isobjcfile(file)) then\n_p('\\t$(SILENT) $(CXX) $(ALL_OBJCFLAGS) $(FORCE_INCLUDE) -o \"$@\" -MF $(@:%%.o=%%.d) -c \"$<\"')\nelse\ncpp.buildcommand(path.iscfile(file) and not prj.options.ForceCPP, \"o\")\nend\n_p('')\nelseif (path.getextension(file) == \".rc\") then\n_p('$(OBJDIR)/%s.res: %s', _MAKE.esc(path.getbasename(file)), _MAKE.esc(file))\nif prj.msgresource then\n_p('\\t@echo ' .. prj.msgresource)\nelse\n_p('\\t@echo $(notdir $<)')\nend\n_p('\\t$(SILENT) $(RESCOMP) $< -O coff -o \"$@\" $(ALL_RESFLAGS)')\n_p('')\nend\nend\nend\nfunction cpp.buildcommand(iscfile, objext)\nlocal flags = iif(iscfile, '$(CC) $(ALL_CFLAGS)', '$(CXX) $(ALL_CXXFLAGS)')\n_p('\\t$(SILENT) %s $(FORCE_INCLUDE) -o \"$"
	192	"@\" -MF $(@:%%.%s=%%.d) -c \"$<\"', flags, objext)\nend\n",
192	193
193	194	/* actions/make/make_csharp.lua */
194	195	"local function getresourcefilename(cfg, fname)\nif path.getextension(fname) == \".resx\" then\n local name = cfg.buildtarget.basename .. \".\"\n local dir = path.getdirectory(fname)\n if dir ~= \".\" then \nname = name .. path.translate(dir, \".\") .. \".\"\nend\nreturn \"$(OBJDIR)/\" .. _MAKE.esc(name .. path.getbasename(fname)) .. \".resources\"\nelse\nreturn fname\nend\nend\nfunction premake.make_csharp(prj)\nlocal csc = premake.dotnet\nlocal cfglibs = { }\nlocal cfgpairs = { }\nlocal anycfg\nfor cfg in premake.eachconfig(prj) do\nanycfg = cfg\ncfglibs[cfg] = premake.getlinks(cfg, \"siblings\", \"fullpath\")\ncfgpairs[cfg] = { }\nfor _, fname in ipairs(cfglibs[cfg]) do\nif path.getdirectory(fname) ~= cfg.buildtarget.directory then\ncfgpairs[cfg][\"$(TARGETDIR)/\" .. _MAKE.esc(path.getname(fname))] = _MAKE.esc(fname)\nend\nend\nend\nlocal sources = {}\nlocal embedded = { }\nlocal copypairs = { }\nfor fcfg in premake.project.eachfile(prj) do\nlocal action = csc.getbuildaction(fcfg)\nif action == \"Co"

trunk/3rdparty/mongoose/docs/API.md
r244869	r244870
183	183	is used, no calls to `mg_send` or `mg_printf` functions must be made, and
184	184	event handler must return `MG_MORE`.
185	185
186		int mg_websocket_write(struct mg_connection* conn, int opcode,
187		const char *data, size_t data_len);
	186	size_t mg_websocket_write(struct mg_connection* conn, int opcode,
	187	const char *data, size_t data_len);
	188	size_t mg_websocket_printf(struct mg_connection* conn, int opcode,
	189	const char *fmt, ...);
188	190
189		Similar to `mg_write()`, but wraps the data into a websocket frame with a
190		given websocket `opcode`.
191	191
	192	Similar to `mg_write()` and `mg_printf()`, but wraps the data into a
	193	websocket frame with a given websocket `opcode`.
	194
192	195	const char mg_get_header(const struct mg_connection , const char *name);
193	196
194	197	Get the value of particular HTTP header. This is a helper function.

trunk/3rdparty/mongoose/examples/multi_threaded_server/Makefile
r244869	r244870
2	2	# All rights reserved
3	3
4	4	PROG = multi_threaded_server
5		CFLAGS = -W -Wall -I../.. -pthread -g -O0 $(CFLAGS_EXTRA)
	5	CFLAGS = -W -Wall -I../.. -pthread -g -O0 -DMONGOOSE_ENABLE_THREADS $(CFLAGS_EXTRA)
6	6	SOURCES = $(PROG).c ../../mongoose.c
7	7
8	8	$(PROG): $(SOURCES)

trunk/3rdparty/mongoose/examples/proxy_server/Makefile
r244869	r244870
3	3
4	4	PROG = proxy_server
5	5	FLAGS = -I../.. -DNS_ENABLE_SSL
6		CFLAGS = -W -Wall -g -O0 -pthread -lssl $(FLAGS) $(CFLAGS_EXTRA)
	6	CFLAGS = -W -Wall -g -O0 -pthread -lssl -DMONGOOSE_ENABLE_THREADS $(FLAGS) $(CFLAGS_EXTRA)
7	7	SOURCES = $(PROG).c ../../mongoose.c
8	8
9	9	unix: $(SOURCES)

trunk/3rdparty/mongoose/examples/web_server/Makefile
r244869	r244870
2	2	# All rights reserved
3	3
4	4	PROG = web_server
5		CFLAGS = -W -Wall -I../.. -pthread -g -O0 $(CFLAGS_EXTRA)
	5	CFLAGS = -W -Wall -I../.. -pthread -g -O0 -DMONGOOSE_ENABLE_THREADS $(CFLAGS_EXTRA)
6	6	SOURCES = $(PROG).c ../../mongoose.c
	7	OPENSSL_FLAGS = -DNS_ENABLE_SSL -lssl
7	8
	9	# PolarSSL paths and flags
	10	POLARSSL_PATH = /usr/local
	11	POLARSSLCOMPAT_PATH = ./../../../polar
	12	SOURCES_POLAR = $(SOURCES) $(POLARSSLCOMPAT_PATH)/polarssl_compat.c
	13	INCDIR_POLAR = -I$(POLARSSLCOMPAT_PATH) -I$(POLARSSL_PATH)/include
	14	LDFLAGS_POLAR = -L$(POLARSSL_PATH)/lib -lmbedtls
	15	CFLAGS_POLAR = $(CFLAGS) $(INCDIR_POLAR) -DNS_ENABLE_SSL
	16	#
	17
8	18	$(PROG): $(SOURCES)
9	19	$(CC) -o $(PROG) $(SOURCES) $(CFLAGS)
10	20
	21	openssl:
	22	$(CC) -o $(PROG) $(SOURCES) $(CFLAGS) $(OPENSSL_FLAGS)
	23
	24	polarssl:
	25	$(CC) -o $(PROG) $(SOURCES_POLAR) $(LDFLAGS_POLAR) $(CFLAGS_POLAR)
	26
11	27	clean:
12	28	rm -rf $(PROG) .exe .dSYM .obj .exp .o .lib

trunk/3rdparty/mongoose/examples/web_server/certs/cert.pem
r0	r244870
	1	-----BEGIN CERTIFICATE-----
	2	MIIC+zCCAeOgAwIBAgIJAPhB8jbL+G82MA0GCSqGSIb3DQEBCwUAMBQxEjAQBgNV
	3	BAMMCTEyNy4wLjAuMTAeFw0xNTAzMDYxMjQzMzNaFw0yNTAzMDMxMjQzMzNaMBQx
	4	EjAQBgNVBAMMCTEyNy4wLjAuMTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC
	5	ggEBALi3b3daMgzUEROKob1Caf68i+//cTRkPdBJv2cOBak21CdQzY0Nvx73GLzf
	6	5TKB347BCHNbYRKGJXDbYdmFp20/WeBHkY7RS3Ad2Q5lzyx66u9PxNx7hJIiqBgF
	7	58VU+E3o/I+o8QNIoOT+wtCiq3Nwkp+zGBJmS32rzMEV9bcKxSzMrkfRhF+XAREd
	8	DwM9vfPg6WRb/b+vv06uvVwcw390RprLautGfBdaRddVYkIAKJGRRTqZAvTRFW1J
	9	FcIVOxlN+iA7qP7xjr3tUP78qMmlu0MXsHrUR2cgfveZK2sdUW5G804yHsU5sC8l
	10	FbtLKMEOyLsk2bEIScOXgum7g2sCAwEAAaNQME4wHQYDVR0OBBYEFHtLzUqAsXkH
	11	Il8S5sMhJuVhRJLdMB8GA1UdIwQYMBaAFHtLzUqAsXkHIl8S5sMhJuVhRJLdMAwG
	12	A1UdEwQFMAMBAf8wDQYJKoZIhvcNAQELBQADggEBAEzHc0AOr+qs0OFvWMfcSMi7
	13	O/aYlLS6f7Sos+lli69+61EcmCTJVarVeAVUsAoqmzBKDbeOpAK1hGX6/GGcXjR2
	14	BmuU0hUKyX9l1lwdMKU45BayH/riElwnvAyj2GxKoPpdIjlHns4SAITOCUx9NfpM
	15	agd7kjolton0ZQ5DI/2a43PkqHv1lY4Dp60wJlxit9U68bsGOycCJ/BsAyrPROb2
	16	D1MkpMBIdfHc8uxRywM3/l9buFX8yrrMUGOYKgfjDwdzbj0iwIixoGpHL7IfeBtu
	17	dvGO/g2rEhbtAP+xIgOR3GvzqjZh30er3no7zjDMn65tTME18Aq3tBQY7vPDKms=
	18	-----END CERTIFICATE-----
	19	-----BEGIN PRIVATE KEY-----
	20	MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQC4t293WjIM1BET
	21	iqG9Qmn+vIvv/3E0ZD3QSb9nDgWpNtQnUM2NDb8e9xi83+Uygd+OwQhzW2EShiVw
	22	22HZhadtP1ngR5GO0UtwHdkOZc8seurvT8Tce4SSIqgYBefFVPhN6PyPqPEDSKDk
	23	/sLQoqtzcJKfsxgSZkt9q8zBFfW3CsUszK5H0YRflwERHQ8DPb3z4OlkW/2/r79O
	24	rr1cHMN/dEaay2rrRnwXWkXXVWJCACiRkUU6mQL00RVtSRXCFTsZTfogO6j+8Y69
	25	7VD+/KjJpbtDF7B61EdnIH73mStrHVFuRvNOMh7FObAvJRW7SyjBDsi7JNmxCEnD
	26	l4Lpu4NrAgMBAAECggEAaFuqbAHXOQwuwZ2XFzgIblTTsrncmT7w9VZU/sIbTKif
	27	X771AnX7vmDX5w2PjeN2DE7emV3NEAwd5w7qz1wFZWFfQ6jrgYaZWjRixxGZ5IVl
	28	aeLlU7OtCGrwEPJ1KTWCO3IgDoHh+Hr1+6o7Imhk+QlmrTcfqHWGvO9s9MGVWt2S
	29	RLAnSTFiOe5brdJnmlqq1sKZmnLmpydBaPUOYpZGAgRasrjdMZB+lZOazd1x23/5
	30	GAcm0rDREMnO9b2Jt+TNEZHT6d5KpVoExztZEZj8QCLXoic/SpFIqHGtpNlQXa+d
	31	BVqgQbIYjO8ldldxZ8YIyJDVF+9e/uBBwu6jBIIsEQKBgQDspEHCyyuh4LG+7BbZ
	32	eXlsfCxPTM6K9w31ZwHAwRtAuGqrOrE+pFJG9CEsFZbAI1aOGmZZdjexuSMcOlXl
	33	TIVJTQHoFtoGEsanYEXO4O1t02Ab/DCYSpXusXUraRBRPpsTC77Sh5mxLUNd23d9
	34	NhnDBuwChAmC+IYexjkXeqPYFwKBgQDH08PEd+2PVo4MD8UVKUlEcgoyCr6ESiyp
	35	HfYyhhfd5x3DbZLoKCkunDfBs/hakQk8DA2nn4tl4ZjfmzXmX0EBx+E5YTdYshW7
	36	ZcjN5x64B5PEOAR/NZA6agNlp3XGXXXgX+gnN6pgE49eVU22nZ4G+QBKD6NcCviB
	37	LBPUxMbvzQKBgHgZYRqonGtaqzsXfP1AjmSFnMNeWtDiU95BOf2Gw/sT3WcrsXr2
	38	UJ+cFR3XkxvOk4YpVdp/igKT0ILqBGAMdvTdtWMB/gLpEpMt5B/7veRoS7XIRy1z
	39	ZSawP6QZfWOOX4vKAT29/j2SmEcRNFKC245EfBFGy8EBuqfxuFX3MyJfAoGBAJ0y
	40	tjsErVmpma1baosvI3g4zlR3p1CimWehLmCopHXorr1iocMIdP0535L+ZU258y3N
	41	vaA0HpFTW9PsYgaMwLMJ7uAY3lVkIzx84e849i2HqHMgLkl0dbW+WFXL2xblxylv
	42	yU2wuNNED/EB4lTawcpycAvTKYvrBXt4lVE4S9exAoGAGl6vZV3zyw4jpIw4uDfk
	43	LTPYUrghFDDGKExyeOnC/W9pqR2veqzfBz02C3jqwhewoqgAcnNc2sg0rJmM+6Oz
	44	Z2mmGZTHO9xR++7+W7e8AkQBbS6TB8a+7yNcM4USLP+b9sX5N+8gFhFs9tG7j/no
	45	G44qLsJ/yve7/QsOA37uEMs=
	46	-----END PRIVATE KEY-----

trunk/3rdparty/mongoose/examples/web_server/web_server.c
r244869	r244870
71	71	static char s_config_file[PATH_MAX]; // Set by process_command_line_arguments
72	72	static struct mg_server *server; // Set by start_mongoose()
73	73	static const char *s_default_document_root = ".";
	74	#ifndef NS_ENABLE_SSL
74	75	static const char *s_default_listening_port = "8080";
	76	#else
	77	static const char *s_default_listening_port = "ssl://8443:certs/cert.pem";
	78	#endif
	79
75	80	static char **s_argv = { NULL };
76	81
77	82	static void set_options(char *argv[]);

trunk/3rdparty/mongoose/examples/websocket_ssl_proxy/Makefile
r244869	r244870
2	2	# All rights reserved
3	3
4	4	PROG = ws_ssl
5		CFLAGS = -W -Wall -I../.. -I. -pthread -g -O0 $(CFLAGS_EXTRA)
	5	CFLAGS = -W -Wall -I../.. -I. -pthread -g -O0 -DMONGOOSE_ENABLE_THREADS -DNS_ENABLE_SSL -DSSL_WRAPPER_USE_AS_LIBRARY $(CFLAGS_EXTRA)
	6	LDFLAGS = -lssl
6	7	SOURCES = ws_ssl.c ../../mongoose.c ssl_wrapper.c
7	8
	9	# PolarSSL paths and flags
	10	POLARSSL_PATH = /usr/local
	11	POLARSSLCOMPAT_PATH = ./../../../polar
	12	SOURCES_POLAR = $(SOURCES) $(POLARSSLCOMPAT_PATH)/polarssl_compat.c
	13	INCDIR_POLAR = -I$(POLARSSLCOMPAT_PATH) -I$(POLARSSL_PATH)/include
	14	LDFLAGS_POLAR = -L$(POLARSSL_PATH)/lib -lmbedtls
	15	CFLAGS_POLAR = $(CFLAGS) $(INCDIR_POLAR)
	16	#
	17
8	18	all: $(PROG)
9	19
10	20	$(PROG): $(SOURCES)
11		$(CC) -o $(PROG) $(SOURCES) \
12		-DNS_ENABLE_SSL -DSSL_WRAPPER_USE_AS_LIBRARY -lssl $(CFLAGS)
	21	$(CC) -o $(PROG) $(SOURCES) $(LDFLAGS) $(CFLAGS)
13	22
	23	polarssl: $(SOURCES_POLAR)
	24	$(CC) -o $(PROG) $(SOURCES_POLAR) $(LDFLAGS_POLAR) $(CFLAGS_POLAR)
	25
14	26	clean:
15	27	rm -rf $(PROG) .exe .dSYM .obj .exp .o .lib

trunk/3rdparty/mongoose/mongoose.c
r244869	r244870
1486	1486	};
1487	1487
1488	1488	#define MG_HEADERS_SENT NSF_USER_1
1489		#define MG_LONG_RUNNING NSF_USER_2
	1489	#define MG_USING_CHUNKED_API NSF_USER_2
1490	1490	#define MG_CGI_CONN NSF_USER_3
1491	1491	#define MG_PROXY_CONN NSF_USER_4
1492	1492	#define MG_PROXY_DONT_PARSE NSF_USER_5
r244869	r244870
2716	2716	}
2717	2717
2718	2718	void mg_send_status(struct mg_connection *c, int status) {
	2719	struct connection *conn = MG_CONN_2_CONN(c);
2719	2720	if (c->status_code == 0) {
2720	2721	c->status_code = status;
2721	2722	mg_printf(c, "HTTP/1.1 %d %s\r\n", status, status_code_to_str(status));
2722	2723	}
	2724	conn->ns_conn->flags \|= MG_USING_CHUNKED_API;
2723	2725	}
2724	2726
2725	2727	void mg_send_header(struct mg_connection c, const char name, const char *v) {
	2728	struct connection *conn = MG_CONN_2_CONN(c);
2726	2729	if (c->status_code == 0) {
2727	2730	c->status_code = 200;
2728	2731	mg_printf(c, "HTTP/1.1 %d %s\r\n", 200, status_code_to_str(200));
2729	2732	}
2730	2733	mg_printf(c, "%s: %s\r\n", name, v);
	2734	conn->ns_conn->flags \|= MG_USING_CHUNKED_API;
2731	2735	}
2732	2736
2733	2737	static void terminate_headers(struct mg_connection *c) {
r244869	r244870
3109	3113	int result;
3110	3114	conn->mg_conn.content = conn->ns_conn->recv_iobuf.buf;
3111	3115	if ((result = call_user(conn, MG_REQUEST)) == MG_TRUE) {
3112		if (conn->ns_conn->flags & MG_HEADERS_SENT) {
	3116	if (conn->ns_conn->flags & MG_USING_CHUNKED_API) {
	3117	terminate_headers(&conn->mg_conn);
3113	3118	write_terminating_chunk(conn);
3114	3119	}
3115	3120	close_local_endpoint(conn);
r244869	r244870
4875	4880	conn->cl = conn->num_bytes_recv = conn->request_len = 0;
4876	4881	conn->ns_conn->flags &= ~(NSF_FINISHED_SENDING_DATA \|
4877	4882	NSF_BUFFER_BUT_DONT_SEND \| NSF_CLOSE_IMMEDIATELY \|
4878		MG_HEADERS_SENT \| MG_LONG_RUNNING);
	4883	MG_HEADERS_SENT \| MG_USING_CHUNKED_API);
4879	4884
4880	4885	// Do not memset() the whole structure, as some of the fields
4881	4886	// (IP addresses & ports, server_param) must survive. Nullify the rest.

https://github.com/mamedev/mame/commit/1ecbc8f95f9b2cdcaeddf7f8594b93d805aa75fa

199869 Revisions