DarkCat09/FallSimulator
1
0
Fork 0
Code Issues Pull requests Projects Releases 2 Packages Wiki Activity
FallSimulator/lib/TXLib.h
Андрей 5fbb88820b
Add files via upload 
Михаил, помогите пожалуйста! Опять у меня ничего не получается...
Я немножко изменил именно игру. Затем решил разбить код на библиотеки.
Попробуйте скомпилировать, если Вам интересно...

Вылезает ошибка (только в самих библиотеках) - "#include nested too deeply" (или что-то подобное).
На русском звучит как - "include вложены слишком глубоко". Шо делать?..
2019-12-07 14:47:15 +03:00

8499 lines
359 KiB
C++
Raw Blame History

//=================================================================================================================
// [These sections are for folding control in Code::Blocks]
//{ [Best viewed with "Fold all on file open" option enabled] [best screen width is 115 chars]
//=================================================================================================================
//!
//! @file TXLib.h
//! @brief Áèáëèîòåêà Òóïîãî Õóäîæíèêà (The Dumb Artist Library, TX Library, TXLib).
//!
//! $Version: 00172a, Revision: 104 $
//! $Copyright: (C) Ded (Ilya Dedinsky, http://txlib.ru) <mail@txlib.ru> $
//! $Date: 2014-08-09 16:37:26 +0400 $
//!
//! TX Library - êîìïàêòíàÿ áèáëèîòåêà äâóìåðíîé ãðàôèêè äëÿ Win32 íà Ñ++.
//! Ýòî íåáîëüøàÿ "ïåñî÷íèöà" äëÿ íà÷èíàþùèõ ðåàëèçîâàíà ñ öåëüþ ïîìî÷ü èì â èçó÷åíèè
//! ïðîñòåéøèõ ïðèíöèïîâ ïðîãðàììèðîâàíèÿ. Äîêóìåíòàöèÿ íà ðóññêîì ÿçûêå.
//!
//! Ôèëîñîôèÿ<sup><a href=#Refs><small>1</small></a></sup> TX Library - îáëåã÷èòü ïåðâûå øàãè
//! â ïðîãðàììèðîâàíèè è ïîäòîëêíóòü ê òâîð÷åñòâó è ñàìîñòîÿòåëüíîñòè.
//!
//! TX Library is a tiny 2D graphics library for Win32 written in C++. This is a small
//! sandbox for the very beginners to help them to learn basic programming principles.
//! The documentation is currently in Russian.
//!
//! Îôèöèàëüíûé ñàéò áèáëèîòåêè: <a href=http://txlib.ru>txlib.ru.</a>
//!
//! Ñì. òàêæå <a href=http://txlib.sourceforge.net>ñòðàíèöó ïðîåêòà íà SourceForge.</a>
//!
//! @warning <b>Ýòî àëüôà-âåðñèÿ. Äëÿ èñïîëüçîâàíèÿ òðåáóåòñÿ ñîãëàñîâàíèå ñ àâòîðîì áèáëèîòåêè.</b> @nn
//! Ïðàâèëà èñïîëüçîâàíèÿ ìàòåðèàëîâ áèáëèîòåêè è ñàéòà ñì. íà <a href=http://txlib.ru>
//! îôèöèàëüíîì ñàéòå.</a>
//!
//! @par Òðåêåðû íà SourceForge:
//! - <a href=https://sourceforge.net/tracker/?func=add&group_id=213688&atid=1026710> <b>Ñîîáùèòü îá îøèáêå </b></a>
//! - <a href=https://sourceforge.net/tracker/?func=add&group_id=213688&atid=1026713> <b>Ïðåäëîæèòü óëó÷øåíèå</b></a>
//!
//! @par Ëèòåðàòóðà <a name=Refs>
//! -# <a href=http://storage.ded32.net.ru/Materials/ConferencePseudoScientific-2003.pdf>
//! Ñàëüíèêîâ Â.Í., Èëüèí Â.Â., Øàðêî Ô.Ñ., Ìèòèíà Í.Â., Áåëàÿ È.Â., Èíäóêàåâ À.Ê., Äåäèíñêèé È.Ð.
//! Ñòðóêòóðà è äèíàìèêà ïîâåäåí÷åñêèõ ðåàêöèé â óñëîâèÿõ èíôîðìàöèîííîé ïåðåãðóçêè. <i>Batman
//! Proceedings in Sheep Philosophy,</i> 2003, Vol. 22. pp. 23-24.</a>
//!
// $Copyright: (C) Ded (Ilya Dedinsky, http://txlib.ru) <mail@txlib.ru> $
//-----------------------------------------------------------------------------------------------------------------
//!
//! @defgroup Drawing Ðèñîâàíèå
//! @defgroup Mouse Ïîääåðæêà ìûøè
//! @defgroup Dialogs Äèàëîãîâûå îêíà
//! @defgroup Misc Ðàçíîå
//! @defgroup Service Ñëóæåáíîå
//! @defgroup Technical Òåõíè÷åñêèå äåòàëè
//}
//=================================================================================================================
#if !defined (__TXLIB_H_INCLUDED) // <<<<<<<<< The code is here, unfold it <<<<<<<<<<<<<<<<<<<<<<<<<
#define __TXLIB_H_INCLUDED
//-----------------------------------------------------------------------------------------------------------------
//{ Version information
//-----------------------------------------------------------------------------------------------------------------
//! @cond INTERNAL
#define _TX_V_FROM_CVS(_1,file,ver,rev,date,auth,_2) "TXLib [Ver: " #ver ", Rev: " #rev "]"
#define _TX_A_FROM_CVS(_1,file,ver,rev,date,auth,_2) "Copyright (C) " auth
#define _TX_v_FROM_CVS(_1,file,ver,rev,date,auth,_2) ((0x##ver << 16) | 0x##rev)
//! @endcond
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Technical
//! @brief Òåêóùàÿ âåðñèÿ áèáëèîòåêè.
//!
//! @code
//! #define _TX_VERSION "TXLib [Version: 1.72a, Revision 50]" (ïðèìåð)
//! #define _TX_AUTHOR "Copyright (C) Ded (Ilya Dedinsky, http://txlib.ru)"
//! @endcode
//! Ýòè êîíñòàíòû àâòîìàòè÷åñêè îáíîâëÿþòñÿ ïðè èçìåíåíèè âåðñèè.
//!
//! @see txVersion()
//!
//! @hideinitializer
//}----------------------------------------------------------------------------------------------------------------
//! @{
#define _TX_VERSION _TX_V_FROM_CVS ($VersionInfo: , TXLib.h, 00172a, 104, 2014-08-09 16:37:26 +0400, "Ded (Ilya Dedinsky, http://txlib.ru) <mail@txlib.ru>", $)
#define _TX_AUTHOR _TX_A_FROM_CVS ($VersionInfo: , TXLib.h, 00172a, 104, 2014-08-09 16:37:26 +0400, "Ded (Ilya Dedinsky, http://txlib.ru) <mail@txlib.ru>", $)
//! @}
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Technical
//! @brief Âåðñèÿ áèáëèîòåêè â öåëî÷èñëåííîì ôîðìàòå.
//!
//! Ôîðìàò: ñòàðøåå ñëîâî - íîìåð âåðñèè, ìëàäøåå - íîìåð ðåâèçèè, â äâîè÷íî-äåñÿòè÷íîì ôîðìàòå.
//! Íàïðèìåð, @c 0x172a0050 - âåðñèÿ @c 0.172a, ðåâèçèÿ @c 50.
//!
//! Ýòà êîíñòàíòà àâòîìàòè÷åñêè îáíîâëÿåòñÿ ïðè èçìåíåíèè âåðñèè.
//!
//! @see txVersion()
//! @usage @code
//! #if !(defined (_TX_VER) && (_TX_VER >= 0x172a0000))
//! #error Must use TXLib.h version >= 1.72 to compile this.
//! #endif
//! @endcode
//!
//! @hideinitializer
//}----------------------------------------------------------------------------------------------------------------
#define _TX_VER _TX_v_FROM_CVS ($VersionInfo: , TXLib.h, 00172a, 104, 2014-08-09 16:37:26 +0400, "Ded (Ilya Dedinsky, http://txlib.ru) <mail@txlib.ru>", $)
//}
//-----------------------------------------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------
//{ Compiler- and platform-specific
//! @name Àäàïòàöèÿ ê êîìïèëÿòîðàì è ïëàòôîðìàì
//-----------------------------------------------------------------------------------------------------------------
//! @{ @cond INTERNAL
#if !defined (__cplusplus)
#ifdef __GNUC__
#error
#error --------------------------------------------------------------------------------------------------------
#endif
#error TXLib.h: Must use C++ to compile TXLib.h.
#error
#error CHECK source file EXTENSION. Maybe it is ".C". It must be ".CPP".
#error If your file is named, for example, "Untitled.C", go to menu [File], then
#error then [Save As] and rename it to "Untitled.CPP". Please do NOT use spaces.
#error --------------------------------------------------------------------------------------------------------
#error
#endif
#if !defined (WIN32) && !defined (__WIN32__) && !defined(_WIN32) && !defined(_WIN32_WINNT)
#ifdef __GNUC__
#error
#error --------------------------------------------------------------------------------------------------------
#endif
#error TXLib.h: Windows (MSVC/Win32 or GCC/MinGW) is the only supported system, sorry.
#error
#error In Linux or iOS, you should write your own TXLib and share it with your friends,
#error or use wine.
#error --------------------------------------------------------------------------------------------------------
#error
#endif
#if defined (UNICODE) || defined (_UNICODE)
#ifdef __GNUC__
#warning TXLib.h: Disabling the UNICODE
#endif
#undef UNICODE // Burn Unicode, burn
#undef _UNICODE
#if defined (_WINDOWS_H) || defined (_INC_WINDOWS) || defined (_WINDOWS_) || defined (__WINDOWS__)
#ifdef __GNUC__
#error
#error --------------------------------------------------------------------------------------------------------
#endif
#error TXLib.h: Should include "TXLib.h" BEFORE or INSTEAD of <Windows.h> in UNICODE mode.
#error
#error REARRANGE your #include directives, or DISABLE the UNICODE mode.
#error --------------------------------------------------------------------------------------------------------
#error
#endif
#endif
#if defined (__STRICT_ANSI__) // Try to extend strict ANSI rules
#ifdef __GNUC__
#warning TXLib.h: Trying to extend strict ANSI compatibility
#endif
#undef __STRICT_ANSI__
#define __STRICT_ANSI__UNDEFINED
#if defined (_STRING_H_) || defined (_INC_STRING) || defined (_STDIO_H_) || defined (_INC_STDIO)
#ifdef __GNUC__
#error
#error --------------------------------------------------------------------------------------------------------
#endif
#error TXLib.h: Should include "TXLib.h" BEFORE <string.h> or <stdio.h> in Strict ANSI mode.
#error
#error REARRANGE your #include directives, or DISABLE ANSI-compliancy.
#error --------------------------------------------------------------------------------------------------------
#error
#endif
#endif
#if defined (__GNUC__)
#define _GCC_VER ( __GNUC__*100 + __GNUC_MINOR__*10 + __GNUC_PATCHLEVEL__ )
#if defined (_GCC_VER) && (_GCC_VER >= 420)
#if (_GCC_VER >= 460)
#pragma GCC diagnostic push
#endif
#pragma GCC optimize ("no-strict-aliasing")
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#pragma GCC diagnostic ignored "-Wshadow"
#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
#pragma GCC diagnostic ignored "-Wunreachable-code"
#pragma GCC diagnostic ignored "-Wold-style-cast"
#pragma GCC diagnostic ignored "-Wunused-label" // Just for fun in _txCanvas_OnCmdAbout()
#pragma GCC diagnostic ignored "-Winline"
#define _TX_THREAD __thread
#else
#define _TX_THREAD
#endif
#define _TX_CHECK_FORMAT( at ) __attribute__ (( format (printf, (at), (at)+1) ))
template <typename T>
inline T _txNOP (T value) { return value; } // To suppress performance warnings in assert etc
// From MinGW\include\float.h which is replaced by MinGW\lib\gcc\i686-pc-mingw32\x.x.x\include\float.h
extern "C" unsigned int __cdecl _controlfp (unsigned int unNew, unsigned int unMask);
extern "C" void __cdecl _fpreset (void);
#else
#define _TX_CHECK_FORMAT( at )
#define _txNOP( value ) ( value )
#endif
#if defined (_MSC_VER)
#pragma warning (push, 4) // Set maximum warning level
#pragma warning (disable: 4127) // conditional expression is constant
#pragma warning (disable: 4351) // new behavior: elements of array will be default initialized
#pragma warning (disable: 4702) // unreachable code
#define _TX_THREAD __declspec (thread)
#endif
#if defined (_MSC_VER) && (_MSC_VER == 1200) // MSVC 6 (1998)
#define _MSC_VER_6 // Flag the bad dog
#pragma warning (disable: 4511) // copy constructor could not be generated
#pragma warning (disable: 4512) // assignment operator could not be generated
#pragma warning (disable: 4514) // unreferenced inline function has been removed
#pragma warning (disable: 4663) // C++ language change: to explicitly specialize class template
#pragma warning (disable: 4710) // function not inlined
#pragma warning (disable: 4786) // identifier was truncated to '255' characters in the debug information
#if !defined (WINVER)
#define WINVER 0x0400 // MSVC 6: Defaults to Windows 95
#endif
#if !defined (NDEBUG)
#define _CRTDBG_MAP_ALLOC 1 // Set debug mode heap allocation
#endif
#endif
#if defined (_MSC_VER) && (_MSC_VER >= 1400) // MSVC 8 (2005) or greater
#pragma warning (disable: 26135) // missing locking annotation
#pragma warning (disable: 28125) // the function must be called from within a try/except block
#pragma warning (disable: 28159) // consider using another function instead
#pragma setlocale ("russian") // Set source file encoding, see also _TX_CP
#if !defined (NDEBUG)
#pragma check_stack (on) // Turn on stack probes at runtime
#pragma strict_gs_check (push, on) // Detects stack buffer overruns
#endif
#define _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES 1
#define _TX_TRUNCATE , _TRUNCATE
#else
#define strcpy_s strcpy // MSVC prior to 8 (2005) versions and GCC
#define strncpy_s strncpy // do NOT have secure variants of these
#define strncat_s strncat // functions, so use insecure ones.
#define wcsncpy_s wcsncpy // ...
#define _snprintf_s _snprintf //
#define _vsnprintf_s _vsnprintf //
#define strerror_s( buf, code ) ( strncpy ((buf), strerror (code), sizeof(buf)-1) )
#define ctime_s( buf, sizeof_buf, time ) ( strncpy ((buf), ctime (time), (sizeof_buf)-1) )
#define getenv_s( sz, buf, sizeof_buf, name ) ( (void)(sz), strncpy ((buf), getenv (name), (sizeof_buf)-1) )
#define strtok_s( buf, delim, ctx ) ( (void)(ctx), strtok ((buf), (delim)) )
#if !( defined (_GCC_VER) && (_GCC_VER == 471) && defined (__x86_64__) ) // GCC 4.7.1 x64 already has it
#define _controlfp_s( oldCtl, newCtl, mask ) ( *(oldCtl) = _controlfp (newCtl, mask), 0 )
#endif
#define _TX_TRUNCATE
#endif
#if defined (__INTEL_COMPILER)
#pragma warning (disable: 174) // remark: expression has no effect
#pragma warning (disable: 304) // remark: access control not specified ("public" by default)
#pragma warning (disable: 522) // remark: function "..." redeclared "inline" after being called
#pragma warning (disable: 981) // remark: operands are evaluated in unspecified order
#pragma warning (disable: 1684) // conversion from pointer to same-sized integral type (potential portability problem)
#endif
#if !defined (WINVER)
#define WINVER 0x0500 // Defaults to Windows 2000
#define WINDOWS_ENABLE_CPLUSPLUS // Allow use of type-limit macros in <basetsd.h>,
#endif // they allowed by default if WINVER >= 0x0600.
#if !defined (_WIN32_WINNT)
#define _WIN32_WINNT WINVER // Defaults to the same as WINVER
#endif
#if !defined (_WIN32_IE)
#define _WIN32_IE WINVER // Defaults to the same as WINVER
#endif
#define _USE_MATH_DEFINES // math.h's M_PI etc.
//! @} @endcond
//}
//-----------------------------------------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------
//{ The Includes
//-----------------------------------------------------------------------------------------------------------------
#ifdef _MSC_VER_6
#pragma warning (push, 3) // MSVC 6: At level 4, some std headers emit warnings O_o
#endif
//-----------------------------------------------------------------------------------------------------------------
#include <assert.h>
#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <io.h>
#include <fcntl.h>
#include <direct.h>
#include <process.h>
#include <signal.h>
#include <locale.h>
#include <time.h>
#include <float.h>
#include <math.h>
#include <map>
#include <vector>
#include <string>
#include <iostream>
#include <algorithm>
#include <exception>
#include <stdexcept>
#include <conio.h>
#include <windows.h>
#include <tlhelp32.h>
#include <shellapi.h>
#include <shlobj.h>
#if defined (_MSC_VER)
#include <crtdbg.h>
#endif
//-----------------------------------------------------------------------------------------------------------------
#ifdef _MSC_VER_6
#pragma warning (pop) // MSVC 6: Restore max level
#endif
#ifdef __STRICT_ANSI__UNDEFINED
#define __STRICT_ANSI__ // Redefine back
#endif
//}
//-----------------------------------------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------
//{ The namespaces
//-----------------------------------------------------------------------------------------------------------------
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Technical
//! @brief Àíîíèìíîå ïðîñòðàíñòâî èìåí äëÿ çàùèòû îò êîíôëèêòîâ ïðè ñáîðêå ìíîãîôàéëîâîãî ïðîåêòà.
//}----------------------------------------------------------------------------------------------------------------
#ifdef FOR_DOXYGEN_ONLY
namespace { namespace TX { }}
#endif
//}
//-----------------------------------------------------------------------------------------------------------------
/*! @cond INTERNAL */
namespace { namespace TX { // <<<<<<<<< The main code is here, unfold it <<<<<<<<<<<<<<<<<<<<
/*! @endcond */
//=================================================================================================================
//{ TXLIB INTERFACE
// Èíòåðôåéñ áèáëèîòåêè
//=================================================================================================================
//=================================================================================================================
//{ Initialization
//! @name Èíèöèàëèçàöèÿ áèáëèîòåêè
//=================================================================================================================
//! @{
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Ñîçäàíèå îêíà ðèñîâàíèÿ
//!
//! @param sizeX Ðàçìåð îêíà ïî ãîðèçîíòàëè (â ïèêñåëÿõ)
//! @param sizeY Ðàçìåð îêíà ïî âåðòèêàëè (â ïèêñåëÿõ)
//! @param centered Öåíòðèðîâàíèå îêíà íà äèñïëåå
//!
//! @return Äåñêðèïòîð (ñèñòåìíûé íîìåð) îêíà TXLib. Åñëè îêíî íå ñîçäàíî, âîçâðàùàåòñÿ NULL.
//!
//! @note Óñòàíàâëèâàþòñÿ ïàðàìåòðû ðèñîâàíèÿ ïî óìîë÷àíèþ, ñì. ôóíêöèþ txSetDefaults().
//!
//! @warning Åñëè èñïîëüçóåòñÿ ìíîãîôàéëîâûé ïðîåêò (ñ ðàçäåëüíîé êîìïèëÿöèåé), òî ãðàôè÷åñêèå ôóíêöèè TXLib,
//! âûçâàííûå èç ôàéëà ïðîåêòà, áóäóò ðàáîòàòü òîëüêî ñ òåì îêíîì, êîòîðîå ñîçäàíî <b>â ýòîì æå ôàéëå</b>
//! ïðîåêòà. Åñëè ïðîåêò ñîñòîèò, ñêàæåì, èç ôàéëîâ @c main.cpp è @c game.cpp, è â ôàéëå @c main.cpp
//! ñîçäàåòñÿ ãðàôè÷åñêîå îêíî, òî ôóíêöèè èç @c game.cpp íå ñìîãóò ðèñîâàòü â íåì. (Îäíàêî @c game.cpp
//! ñìîæåò ñîçäàòü ñâîå ñîáñòâåííîå îêíî.) @n
//! Åñëè òàêîé ïðîãðàììå íóæíî îäíî îêíî, òî â ïðîåêò ñëåäóåò âêëþ÷èòü ôàéë, îòâåòñòâåííûé çà ðèñîâàíèå,
//! ñêàæåì, @c graphics.cpp, è âûâîäèòü ãðàôèêó òîëüêî ÷åðåç ôóíêöèè ýòîãî ôàéëà. Òàêîé ôàéë (èëè
//! áèáëèîòåêó) â áîëüøèõ ïðîåêòàõ ÷àñòî íàçûâàþò ãðàôè÷åñêèì äâèæêîì. @nn
//! Òî æå êàñàåòñÿ è èñïîëüçîâàíèÿ TXLib â @b DLL.
//!
//! @note Âñïîìîãàòåëüíûå îêíà ìîãóò ñîçäàâàòüñÿ ïî îäíîìó íà êàæäûé ôàéë ìíîãîôàéëîâîãî ïðîåêòà èëè çàãðóæåííóþ
//! DLL. Äëÿ çàêðûòèÿ âñïîìîãàòåëüíûõ îêîí èñïîëüçóåòñÿ txDestroyWindow(). Äëÿ çàêðûòèÿ ãëàâíîãî íàäî
//! âûéòè èç main().
//!
//! @warning Îäíîâðåìåííîå ñîçäàíèå íåñêîëüêèõ îêîí íå ïîòîêîáåçîïàñíî (not thread-safe). @nn
//! Ìíîãîîêîííàÿ ïðîãðàìà íà TXLib òîðìîçèò, äà è îäíîîêîííàÿ òîæå íå îòëè÷àåòñÿ âûñîêîé ñêîðîñòüþ. ×òîáû
//! èçáàâèòüñÿ îò ýòîãî, áðîñüòå TXLib è èñïîëüçóéòå äðóãèå îêîííûå áèáëèîòåêè (<a href=http://qt-project.org>Qt</a>,
//! <a href=http://wxwidgets.org>wxWidgets</a>, <a href=http://gtk.org>GTK+</a> è ò.ä., ñì. òàêæå <a href=http://libsdl.org>
//! SDL</a>, <a href=http://opengl.org>OpenGL</a> è ò.ï.) èëè íàïèøèòå ñâîþ. Ïîìíèòå, ÷òî öåëü TXLib -
//! îáëåã÷èòü ïåðâûå øàãè, íî ïîòîì ñòàòü íåíóæíîé.
//!
//! @see txOK(), txWindow(), txDC(), _txWindowStyle, _txConsoleMode, _txConsoleFont, _txCursorBlinkInterval,
//! _txWindowUpdateInterval, _TX_NOINIT, _TX_ALLOW_TRACE, TX_TRACE
//!
//! @usage @code
//! txCreateWindow ( 800, 600); // Îêíî 800õ600, öåíòðèðîâàíî
//! txCreateWindow (1024, 768, false); // Îêíî 1024õ768, íå öåíòðèðîâàíî
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
HWND txCreateWindow (double sizeX, double sizeY, bool centered = true);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Óñòàíîâêà ïàðàìåòðîâ ðèñîâàíèÿ ïî óìîë÷àíèþ.
//!
//! @return Åñëè îïåðàöèÿ áûëà óñïåøíà - true, èíà÷å - false.
//!
//! @par Ïàðàìåòðû ïî óìîë÷àíèþ:
//! - Ëèíèè - öâåò áåëûé (TX_WHITE), òîëùèíà 1
//! - Çàëèâêà - öâåò áåëûé (TX_WHITE)
//! - Øðèôò - Ñèñòåìíûé øðèôò, öâåò áåëûé (TX_WHITE)
//! - Ðàñòðîâàÿ îïåðàöèÿ - êîïèðîâàíèå öâåòà (R2_COPYPEN)
//!
//! @see txSetColor(), txGetColor(), txSetFillColor(), txGetFillColor(), txColors, RGB(), txSelectFont(), txSetROP2()
//!
//! @usage @code
//! txSetDefaults();
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
bool txSetDefaults();
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Ïðîâåðêà ïðàâèëüíîñòè ðàáîòû áèáëèîòåêè
//!
//! @return Ñîñòîÿíèå áèáëèîòåêè: true - áèáëèîòåêà â ïîðÿäêå, false - íå â ïîðÿäêå.
//!
//! "Áèáëèîòåêà íå â ïîðÿäêå" îçíà÷àåò, ÷òî åå âíóòðåííèå äàííûå íåâåðíû. Ñàìàÿ ïðîñòàÿ ïðè÷èíà -
//! íå îòêðûòî îêíî, îäíàêî ìîãóò áûòü è äðóãèå ïðîáëåìû.
//!
//! @see txCreateWindow()
//!
//! @usage @code
//! txCreateWindow (800, 600);
//! if (!txOK())
//! {
//! txMessageBox ("Íå ñìîãëà ñîçäàòü îêíî", "Èçâèíèòå", MB_ICONSTOP);
//! return;
//! }
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
inline bool txOK();
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Âîçâðàùàåò ðàçìåð îêíà ðèñîâàíèÿ â âèäå ñòðóêòóðû POINT.
//!
//! @return Ðàçìåð îêíà ðèñîâàíèÿ â âèäå ñòðóêòóðû POINT, ñîäåðæàùåé êîìïîíåíòû @c x è @c y.
//!
//! @see txGetExtentX(), txGetExtentY()
//!
//! @usage @code
//! POINT size = txGetExtent();
//!
//! txLine (0, 0, size.x, size.y);
//! txLine (0, size.y, size.x, 0);
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
POINT txGetExtent();
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Âîçâðàùàåò øèðèíó îêíà ðèñîâàíèÿ.
//!
//! @return Øèðèíà îêíà ðèñîâàíèÿ.
//!
//! @see txGetExtent(), txGetExtentY()
//!
//! @usage @code
//! txSetTextAlign (TA_CENTER);
//! txTextOut (txGetExtentX() / 2, 100, "Oh, oh, you're in the [army]middle now");
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
int txGetExtentX();
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Âîçâðàùàåò âûñîòó îêíà ðèñîâàíèÿ.
//!
//! @return Âûñîòà îêíà ðèñîâàíèÿ.
//!
//! @see txGetExtent(), txGetExtentX()
//!
//! @usage @code
//! void DrawHouse (int height);
//! ...
//! DrawHouse (txGetExtentY() / 2);
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
int txGetExtentY();
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Âîçâðàùàåò äåñêðèïòîð êîíòåêñòà ðèñîâàíèÿ õîëñòà
//!
//! @return Äåñêðèïòîð (ñèñòåìíûé íîìåð, handler) êîíòåêñòà ðèñîâàíèÿ (device context, DC) õîëñòà (HDC).
//!
//! @note HDC âîçâðàùàåòñÿ â âèäå ññûëêè, ÷òî ïîçâîëÿåò ïîäìåíèòü åãî. Ïåðåä ïîäìåíîé íàäî ñîõðàíèòü ñòàðûé
//! äåñêðèïòîð èëè îñâîáîäèòü åãî ñ ïîìîùüþ txDeleteDC(). Äî ïîäìåíû ðèñîâàíèå äîëæíî áûòü çàáëîêèðîâàíî
//! ñ ïîìîùüþ txLock() è ïîñëå ïîäìåíû ðàçáëîêèðîâàíî ñ ïîìîùüþ txUnlock().
//!
//! @see txWindow(), txLock(), txUnlock(), txGDI()
//!
//! @usage @code
//! txBitBlt (txDC(), 0, 0, 100, 100, txDC(), 0, 0);
//! txBitBlt (txDC(), 100, 0, 100, 100, txDC(), 0, 0);
//! txBitBlt (txDC(), 0, 100, 100, 100, txDC(), 0, 0);
//! txBitBlt (txDC(), 100, 100, 100, 100, txDC(), 0, 0);
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
inline HDC& txDC();
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Âîçâðàùàåò äåñêðèïòîð îêíà õîëñòà
//!
//! @return Äåñêðèïòîð (ñèñòåìíûé íîìåð, handler) îêíà õîëñòà
//!
//! @see txDC(), txLock(), txUnlock(), txGDI()
//!
//! @usage @code
//! SetWindowText (txWindow(), "Íîâûå çàãîëîâêè - òåïåðü è â âàøèõ îêíàõ!");
//! txMessageBox ("Ðàñïèøèòåñü", "Ïîëó÷èòå", MB_ICONINFORMATION);
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
inline HWND txWindow();
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Technical
//! @brief Âîçâðàùàåò ñòðîêó ñ èíôîðìàöèåé î òåêóùåé âåðñèè áèáëèîòåêè.
//!
//! @return Ñòðîêà ñ èíôîðìàöèåé î òåêóùåé âåðñèè áèáëèîòåêè.
//!
//! @usage @code
//! printf ("I personally love %s\n", txVersion());
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
inline const char* txVersion();
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Technical
//! @brief Âîçâðàùàåò íîìåð âåðñèè áèáëèîòåêè.
//!
//! @return Íîìåð âåðñèè áèáëèîòåêè.
//!
//! @usage @code
//! printf ("My magic number is %x\n", txVersionNumber());
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
inline unsigned txVersionNumber();
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Technical
//! @brief Âîçâðàùàåò èìÿ èñïîëíÿåìîãî ôàéëà èëè èçíà÷àëüíûé çàãîëîâîê îêíà TXLib.
//!
//! @param fileNameOnly Âîçâðàòèòü òîëüêî ïîëíîå èìÿ èñïîëíÿåìîãî ôàéëà, ïîëó÷åííîãî ÷åðåç Win32 ôóíêöèþ
//! GetFileModuleName (NULL, ...).
//!
//! @return fileNameOnly = true: Èìÿ èñïîëíÿåìîãî ôàéëà @n
//! fileNameOnly = false: Èçíà÷àëüíûé çàãîëîâîê îêíà TXLib
//!
//! @note Âîçâðàùàåòñÿ @b ñòàòè÷åñêàÿ ñòðîêà.
//!
//! @see txWindow(), txVersion(), txVersionNumber()
//!
//! @usage @code
//! printf ("Ñìîòðèòå íà çàãîëîâîê îêíà!");
//!
//! for (int done = 0; done <= 100; done++)
//! {
//! char title [1024] = "";
//! sprintf (title, "%s - [%-10.*s] %d%%", txGetModuleFileName (false), done/10, "||||||||||", done);
//!
//! SetWindowText (txWindow(), title);
//! txSleep (50);
//! }
//!
//! txMessageBox ("Âîò òàêîé âîò progress bar", "TXLib forever)");
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
const char* txGetModuleFileName (bool fileNameOnly = true);
//! @}
//}
//=================================================================================================================
//=================================================================================================================
//{ Setting the parameters
//! @name Óñòàíîâêà öâåòîâ è ðåæèìîâ ðèñîâàíèÿ
//=================================================================================================================
//! @{
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Íàçâàíèÿ ïðåäîïðåäåëåííûõ öâåòîâ.
//!
//! Ñì. TX_BLACK, TX_BLUE è äðóãèå öâåòà â ñïèñêå âûøå.
//!
//! Åñëè êîìó-òî ýòè öâåòà íå íðàâÿòñÿ (÷òî íåóäèâèòåëüíî), âñåãäà ìîæíî ñäåëàòü ñâîè ñ ïîìîùüþ RGB().
//! Ñì. ïðèìåð íèæå.
//!
//! @see txSetColor(), txSetFillColor(), txGetColor(), txGetFillColor(), txGetPixel(), RGB()
//!
//! @usage @code
//! #include "TXLib.h"
//!
//! const COLORREF MY_DEEP_ROMANTIC_BLUE = RGB ( 0, 0, 129),
//! MY_SHINING_MOONLIGHT = RGB (128, 255, 64);
//! ...
//!
//! txSetColor (TX_RED);
//! txSetFillColor (TX_NULL);
//!
//! txSetFillColor (MY_DEEP_ROMANTIC_BLUE); // À.È. Êóèíäæè, "Ëóííàÿ íî÷ü íà Äíåïðå"
//! txSetColor (MY_SHINING_MOONLIGHT); // http://tanais.info/art/pic/kuindzhi1.html
//! @endcode
//!
//! @hideinitializer
//}----------------------------------------------------------------------------------------------------------------
const COLORREF
#ifdef FOR_DOXYGEN_ONLY
enum txColors {
#endif
TX_BLACK = RGB ( 0, 0, 0), //!< ×åðíûé öâåò.
TX_BLUE = RGB ( 0, 0, 128), //!< Òåìíî-ñèíèé öâåò. <i>Ïëîõî âèäåí.</i>
TX_GREEN = RGB ( 0, 128, 0), //!< Çåëåíûé öâåò.
TX_CYAN = RGB ( 0, 128, 128), //!< Áèðþçîâûé öâåò.
TX_RED = RGB (128, 0, 0), //!< Òåìíî-êðàñíûé öâåò. <i>Ñëèøêîì òåìíûé.</i>
TX_MAGENTA = RGB (128, 0, 128), //!< Òåìíî-ìàëèíîâûé öâåò.
TX_BROWN = RGB (128, 128, 0), //!< Êîðè÷íåâûé öâåò. <i>Íåêðàñèâûé. Do it yourself with RGB().</i>
TX_ORANGE = RGB (255, 128, 0), //!< Îðàíæåâûé öâåò.
TX_GRAY = RGB (160, 160, 160), //!< Ñåðûé öâåò.
TX_DARKGRAY = RGB (128, 128, 128), //!< Òåìíî-ñåðûé öâåò.
TX_LIGHTGRAY = RGB (192, 192, 192), //!< Ñâåòëî-ñåðûé öâåò.
TX_LIGHTBLUE = RGB ( 0, 0, 255), //!< Ñâåòëî-ñèíèé öâåò.
TX_LIGHTGREEN = RGB ( 0, 255, 128), //!< Ñâåòëî-çåëåíûé öâåò.
TX_LIGHTCYAN = RGB ( 0, 255, 255), //!< Ñâåòëî-áèðþçîâûé öâåò.
TX_LIGHTRED = RGB (255, 0, 128), //!< Ñâåòëî-êðàñíûé öâåò. <i>Íå ñàìîãî ëó÷øåãî îòòåíêà.</i>
TX_LIGHTMAGENTA = RGB (255, 0, 255), //!< Ñâåòëî-ìàëèíîâûé öâåò. <i>Åùå ìåíåå ëó÷øåãî îòòåíêà.</i>
TX_PINK = RGB (255, 128, 255), //!< Ðîçîâûé ãëàìóðíûé :)
TX_YELLOW = RGB (255, 255, 128), //!< Æåëòûé öâåò.
TX_WHITE = RGB (255, 255, 255), //!< Áåëûé öâåò.
TX_TRANSPARENT = 0xFFFFFFFF, //!< Ïðîçðà÷íûé öâåò. <i>Îòêëþ÷àåò ðèñîâàíèå.</i>
TX_NULL = TX_TRANSPARENT, //!< Ïðîçðà÷íûé öâåò. <i>Îòêëþ÷àåò ðèñîâàíèå.</i>
// Öâåòîâûå êàíàëû (êîìïîíåíòû) - ñì. txExtractColor(), txRGB2HSL(), txHSL2RGB()
TX_HUE = 0x04000000, //!< Öâåòîâîé òîí öâåòà â ìîäåëè HSL
TX_SATURATION = 0x05000000, //!< Íàñûùåííîñòü öâåòà â ìîäåëè HSL
TX_LIGHTNESS = 0x06000000; //!< Ñâåòëîòà öâåòà â ìîäåëè HSL
#ifdef FOR_DOXYGEN_ONLY
};
#endif
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Ñîçäàåò (ñìåøèâàåò) öâåò èç òðåõ áàçîâûõ öâåòîâ (êîìïîíåíò).
//!
//! @param red Êîëè÷åñòâî êðàñíîãî öâåòà â èíòåðâàëå [0; 255]
//! @param green Êîëè÷åñòâî çåëåíîãî öâåòà â èíòåðâàëå [0; 255]
//! @param blue Êîëè÷åñòâî ñèíåãî öâåòà â èíòåðâàëå [0; 255]
//!
//! @return Ñîçäàííûé öâåò â ôîðìàòå COLORREF.
//!
//! @see txSetColor(), txGetColor(), txSetFillColor(), txGetFillColor(), txColors, RGB(), txExtractColor(),
//! txRGB2HSL(), txHSL2RGB()
//!
//! @usage @code
//! txSetColor (RGB (255, 128, 0)); // Êðàñíûé + ïîëîâèíà çåëåíîãî = îðàíæåâûé
//!
//! int red = 20, green = 200, blue = 20;
//! COLORREF color = RGB (red, green, blue);
//! txSetFillColor (color);
//!
//! const COLORREF SKY_COLOR = RGB (0, 128, 255); // Ñîçäàåì êîíñòàíòó äëÿ íîâîãî öâåòà
//!
//! ...
//! txSetFillColor (SKY_COLOR); // Èñïîëüçóåì åå
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
#ifdef FOR_DOXYGEN_ONLY
COLORREF RGB (int red, int green, int blue);
#endif
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Óñòàíàâëèâàåò òåêóùèé öâåò è òîëùèíó ëèíèé, öâåò òåêñòà.
//!
//! @param color Öâåò ëèíèé è òåêñòà, ñì. txColors, RGB()
//! @param thickness Òîëùèíà ëèíèé
//!
//! @return Åñëè îïåðàöèÿ áûëà óñïåøíà - true, èíà÷å - false.
//!
//! @see txColor(), txGetColor(), txFillColor(), txGetFillColor(), txColors, RGB()
//!
//! @usage @code
//! txSetColor (TX_RED);
//! txSetColor (RGB (255, 128, 0), 5);
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
bool txSetColor (COLORREF color, double thickness = 1);
//! @cond INTERNAL
#define txSetColour txSetColor
//! @endcond
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Óñòàíàâëèâàåò òåêóùèé öâåò ëèíèé è òåêñòà.
//!
//! @param red Êîëè÷åñòâî êðàñíîãî öâåòà â èíòåðâàëå [0; 1]
//! @param green Êîëè÷åñòâî çåëåíîãî öâåòà â èíòåðâàëå [0; 1]
//! @param blue Êîëè÷åñòâî ñèíåãî öâåòà â èíòåðâàëå [0; 1]
//!
//! @return Åñëè îïåðàöèÿ áûëà óñïåøíà - true, èíà÷å - false.
//!
//! @see txSetColor(), txGetColor(), txSetFillColor(), txGetFillColor()
//!
//! @usage @code
//! txColor (1.0, 1.0, 0.0); // Êðàñíûé + çåëåíûé = æåëòûé
//! txColor (1.0, 0.5, 0.25); // Íå÷òî îðàíæåâîå
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
bool txColor (double red, double green, double blue);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Âîçâðàùàåò òåêóùèé öâåò ëèíèé è òåêñòà.
//!
//! @return Òåêóùèé öâåò ëèíèé è òåêñòà, ñì. txColors, RGB()
//!
//! @see txSetColor(), txGetColor(), txSetFillColor(), txGetFillColor(), txColors, RGB()
//!
//! @usage @code
//! COLORREF color = txGetColor();
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
COLORREF txGetColor();
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Óñòàíàâëèâàåò òåêóùèé öâåò çàïîëíåíèÿ ôèãóð.
//!
//! @param color Öâåò çàïîëíåíèÿ, ñì. txColors, RGB()
//!
//! @return Åñëè îïåðàöèÿ áûëà óñïåøíà - true, èíà÷å - false.
//!
//! @see txFillColor(), txGetFillColor(), txColor(), txGetColor(), txColors, RGB()
//!
//! @usage @code
//! txSetFillColor (TX_RED);
//! txSetFillColor (RGB (255, 128, 0));
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
bool txSetFillColor (COLORREF color);
//! @cond INTERNAL
#define txSetFillColour txSetFillColor
//! @endcond
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Óñòàíàâëèâàåò òåêóùèé öâåò çàïîëíåíèÿ ôèãóð.
//!
//! @param red Êîëè÷åñòâî êðàñíîãî öâåòà â èíòåðâàëå [0; 1]
//! @param green Êîëè÷åñòâî çåëåíîãî öâåòà â èíòåðâàëå [0; 1]
//! @param blue Êîëè÷åñòâî ñèíåãî öâåòà â èíòåðâàëå [0; 1]
//!
//! @return Åñëè îïåðàöèÿ áûëà óñïåøíà - true, èíà÷å - false.
//!
//! @see txSetFillColor(), txGetFillColor(), txSetColor(), txGetColor()
//!
//! @usage @code
//! txFillColor (1.0, 0.5, 0.25);
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
bool txFillColor (double red, double green, double blue);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Âîçâðàùàåò òåêóùèé öâåò çàïîëíåíèÿ ôèãóð.
//!
//! @return Òåêóùèé öâåò çàïîëíåíèÿ ôèãóð, ñì. txColors, RGB()
//!
//! @see txSetFillColor(), txGetFillColor(), txSetColor(), txGetColor(), txColors, RGB()
//!
//! @usage @code
//! COLORREF color = txGetFillColor();
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
COLORREF txGetFillColor();
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Óñòàíàâëèâàåò ðåæèì âçàèìîäåéñòâèÿ öâåòîâ ïðè ðèñîâàíèè.
//!
//! Ïðè ðèñîâàíèè ãðàôè÷åñêàÿ áèáëèîòåêà ìîæåò íå ïðîñòî êðàñèòü ïèêñåëè íà ýêðàíå, à ñìåøèâàòü öâåòà
//! ýêðàíà è òåêóùèå öâåòà ëèíèé è çàïîëíåíèÿ.
//!
//! @param mode Ðåæèì ñìåøèâàíèÿ öâåòîâ
//!
//! @return Ïðåäûäóùèé ðåæèì âçàèìîäåéñòâèÿ öâåòîâ, ñì. txColors, RGB()
//!
//! @title Ðåæèìû âçàèìîäåéñòâèÿ öâåòîâ:
//! @table @tr R2_COPYPEN @td Ïèêñåëè = öâåòà êèñòè (ñàìûé íîðìàëüíûé ðåæèì :)
//! @tr R2_NOTCOPYPEN @td Ïèêñåëè = ~êèñòü
//! @tbr
//! @tr R2_BLACK @td Ïèêñåëè = ÷åðíûé öâåò (öâåò êèñòè èãíîðèðóåòñÿ)
//! @tr R2_WHITE @td Ïèêñåëè = áåëûé öâåò (öâåò êèñòè èãíîðèðóåòñÿ)
//! @tr R2_NOT @td Ïèêñåëè = ~ïèêñåëè (öâåò êèñòè èãíîðèðóåòñÿ)
//! @tbr
//! @tr R2_XORPEN @td Ïèêñåëè = ïèêñåëè ^ êèñòü (óäîáíûé ðåæèì, cì. ïðèìåð íèæå)
//! @tr R2_NOTXORPEN @td Ïèêñåëè = ~ (ïèêñåëè ^ êèñòü)
//! @tbr
//! @tr R2_MASKPEN @td Ïèêñåëè = ïèêñåëè & êèñòü
//! @tr R2_NOTMASKPEN @td Ïèêñåëè = ~ (ïèêñåëè & êèñòü)
//! @tr R2_MASKNOTPEN @td Ïèêñåëè = ïèêñåëè & ~êèñòü
//! @tr R2_MASKPENNOT @td Ïèêñåëè = ~ïèêñåëè & êèñòü
//! @tbr
//! @tr R2_MERGEPEN @td Ïèêñåëè = ïèêñåëè | êèñòü
//! @tr R2_NOTMERGEPEN @td Ïèêñåëè = ~ (ïèêñåëè | êèñòü)
//! @tr R2_MERGENOTPEN @td Ïèêñåëè = ïèêñåëè | ~êèñòü
//! @tr R2_MERGEPENNOT @td Ïèêñåëè = ~ïèêñåëè | êèñòü
//! @tbr
//! @tr R2_NOP @td Ïèêñåëè âîîáùå íå èçìåíÿþòñÿ.
//! @endtable
//!
//! @see txSetColor(), txGetColor(), txSetFillColor(), txGetFillColor(), txColors, RGB(),
//! txLine(), txRectangle(), txPolygon(), txEllipse(), txCircle(), txArc(), txPie(), txChord()
//!
//! @usage @code
//! txSetColor (TX_WHITE, 5); // Ïðè ðèñîâàíèè áåëûì öâåòîì â ðåæèìå
//! txSetROP2 (R2_XORPEN); // R2_XORPEN öâåòà íà ýêðàíå èíâåðòèðóþòñÿ
//!
//! txLine (100, 100, 200, 200); // Ðèñóåì ïåðâûé ðàç - ëèíèÿ ïîÿâëÿåòñÿ
//! txSleep (1000);
//! txLine (100, 100, 200, 200); // Ðèñóåì âòîðîé ðàç - ëèíèÿ èñ÷åçàåò (íåìíîãî óëè÷íîé ìàãèè)
//!
//! txSetROP2 (R2_COPYPEN); // Âîññòàíàâëèâàåì íîðìàëüíûé ðåæèì
//! txLine (100, 100, 200, 200); // Ðèñóåì ïåðâûé ðàç - ëèíèÿ ïîÿâëÿåòñÿ
//!
//! txLine (100, 100, 200, 200); // Ðèñóåì ïåðâûé ðàç - ëèíèÿ îñòàåòñÿ, êòî áû ìîã ïîäóìàòü
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
bool txSetROP2 (int mode = R2_COPYPEN);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Èçâëåêàåò öâåòîâóþ êîìïîíåíòó (öâåòîâîé êàíàë) èç ñìåøàííîãî öâåòà.
//!
//! @param color Ñìåøàííûé öâåò
//! @param component Èçâëåêàåìàÿ êîìïîíåíòà, ñì. txColors
//!
//! @return Öâåòîâàÿ êîìïîíåíòà, ñì. txColors
//!
//! @see txSetColor(), txGetColor(), txSetFillColor(), txGetFillColor(), txColors, RGB(), txExtractColor(),
//! txRGB2HSL(), txHSL2RGB()
//!
//! @usage @code
//! int red = txExtractColor (color, TX_RED);
//! int lightness = txExtractColor (TX_BLUE, TX_LIGHTNESS);
//!
//! Äðóãèå ïðèìåðû ñì. â ôóíêöèÿõ AppearText(), AppearEarth() Ïðèìåðà 5 ("Öèêëû").
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
int txExtractColor (COLORREF color, COLORREF component);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Ïðåîáðàçóåò öâåò èç ôîðìàòà RGB â ôîðìàò HSL.
//!
//! @param rgbColor Ïðåîáðàçóåìûé öâåò â ôîðìàòå @strike ÅÃÝ @endstrike RGB
//!
//! @return Ñîçäàííûé öâåò â âèäå COLORREF.
//!
//! Ôîðìàò @b RGB îïðåäåëÿåòñÿ êàê
//!
//! - Êðàñíàÿ êîìïîíåíòà öâåòà (Red), îò 0 äî 255.
//! - Çåëåíàÿ êîìïîíåíòà öâåòà (Green), îò 0 äî 255.
//! - Ñèíÿÿ êîìïîíåíòà öâåòà (Blue), îò 0 äî 255.
//!
//! Ôîðìàò @b HSL îïðåäåëÿåòñÿ êàê
//!
//! - Öâåòîâîé òîí (Hue), îò 0 äî 255 <b>(íå äî 360).</b>
//! - Íàñûùåííîñòü (Saturation), îò 0 äî 255.
//! - Ñâåòëîòà (Lightness), îò 0 äî 255.
//!
//! @see txSetColor(), txGetColor(), txSetFillColor(), txGetFillColor(), txColors, RGB(), txExtractColor(),
//! txRGB2HSL(), txHSL2RGB()
//!
//! @usage @code
//! COLORREF hslColor = txRGB2HSL (TX_RED);
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
COLORREF txRGB2HSL (COLORREF rgbColor);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Ïðåîáðàçóåò öâåò èç ôîðìàòà HSL â ôîðìàò RGB.
//!
//! @param hslColor Ïðåîáðàçóåìûé öâåò â ôîðìàòå HSL
//!
//! @return Ñîçäàííûé öâåò â âèäå COLORREF.
//!
//! Ôîðìàò @b RGB îïðåäåëÿåòñÿ êàê
//!
//! - Êðàñíàÿ êîìïîíåíòà öâåòà (Red), îò 0 äî 255.
//! - Çåëåíàÿ êîìïîíåíòà öâåòà (Green), îò 0 äî 255.
//! - Ñèíÿÿ êîìïîíåíòà öâåòà (Blue), îò 0 äî 255.
//!
//! Ôîðìàò @b HSL îïðåäåëÿåòñÿ êàê
//!
//! - Öâåòîâîé òîí (Hue), îò 0 äî 255 <b>(íå äî 360).</b>
//! - Íàñûùåííîñòü (Saturation), îò 0 äî 255.
//! - Ñâåòëîòà (Lightness), îò 0 äî 255.
//!
//! @see txSetColor(), txGetColor(), txSetFillColor(), txGetFillColor(), txColors, RGB(), txExtractColor(),
//! txRGB2HSL(), txHSL2RGB()
//!
//! @usage @code
//! int hue = 10, saturation = 128, lightness = 128;
//! COLORREF hslColor = RGB (hue, saturation, lightness);
//! txSetColor (txHSL2RGB (hslColor));
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
COLORREF txHSL2RGB (COLORREF hslColor);
//! @}
//}
//=================================================================================================================
//=================================================================================================================
//{ Drawing
//! @name Ðèñîâàíèå ôèãóð
//=================================================================================================================
//! @{
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Ñòèðàåò õîëñò òåêóùèì öâåòîì çàïîëíåíèÿ.
//!
//! @return Åñëè îïåðàöèÿ áûëà óñïåøíà - true, èíà÷å - false.
//!
//! @see txSetFillColor(), txFillColor(), txGetFillColor(), txColors, RGB()
//!
//! @usage @code
//! txClear();
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
bool txClear();
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Ðèñóåò ïèêñåëü (òî÷êó íà ýêðàíå).
//!
//! @param x Õ-êîîðäèíàòà òî÷êè
//! @param y Y-êîîðäèíàòà òî÷êè
//! @param color Öâåò òî÷êè, ñì. txColors, RGB()
//!
//! @return Åñëè îïåðàöèÿ áûëà óñïåøíà - true, èíà÷å - false.
//!
//! @see txPixel(), txGetPixel(), txColors, RGB()
//!
//! @usage @code
//! txSetPixel (100, 100, TX_RED);
//! txSetPixel (100, 100, RGB (255, 128, 0));
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
inline bool txSetPixel (double x, double y, COLORREF color);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Ðèñóåò ïèêñåëü (òî÷êó íà ýêðàíå).
//!
//! @param x Õ-êîîðäèíàòà òî÷êè
//! @param y Y-êîîðäèíàòà òî÷êè
//! @param red Êîëè÷åñòâî êðàñíîãî öâåòà â èíòåðâàëå [0; 1]
//! @param green Êîëè÷åñòâî çåëåíîãî öâåòà â èíòåðâàëå [0; 1]
//! @param blue Êîëè÷åñòâî ñèíåãî öâåòà â èíòåðâàëå [0; 1]
//!
//! @return Åñëè îïåðàöèÿ áûëà óñïåøíà - true, èíà÷å - false.
//!
//! @see txSetPixel(), txGetPixel()
//!
//! @usage @code
//! txSetPixel (100, 100, 1.0, 0.5, 0.25);
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
inline bool txPixel (double x, double y, double red, double green, double blue);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Âîçâðàùàåò òåêóùèé öâåò òî÷êè (ïèêñåëÿ) íà ýêðàíå.
//!
//! @param x Õ-êîîðäèíàòà òî÷êè
//! @param y Y-êîîðäèíàòà òî÷êè
//!
//! @return Òåêóùèé öâåò ïèêñåëÿ, ñì. txColors, RGB()
//!
//! @see txSetPixel(), txPixel(), txColors, RGB()
//!
//! @usage @code
//! COLORREF color = txGetPixel (100, 200);
//!
//! if (txGetPixel (x, y) == TX_RED)
//! CarCrash (x, y); // Mess with the red - die like the rest
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
inline COLORREF txGetPixel (double x, double y);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Ðèñóåò ëèíèþ.
//!
//! @param x0 X-êîîðäèíàòà íà÷àëüíîé òî÷êè
//! @param y0 Y-êîîðäèíàòà íà÷àëüíîé òî÷êè
//! @param x1 X-êîîðäèíàòà êîíå÷íîé òî÷êè
//! @param y1 Y-êîîðäèíàòà êîíå÷íîé òî÷êè
//!
//! @return Åñëè îïåðàöèÿ áûëà óñïåøíà - true, èíà÷å - false.
//!
//! Öâåò è òîëùèíà ëèíèè çàäàåòñÿ ôóíêöèåé txSetColor().
//!
//! @see txSetColor(), txGetColor(), txSetFillColor(), txGetFillColor(), txColors, RGB(),
//! txLine(), txRectangle(), txPolygon(), txEllipse(), txCircle(), txArc(), txPie(), txChord()
//!
//! @usage @code
//! txLine (100, 200, 400, 500);
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
bool txLine (double x0, double y0, double x1, double y1);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Ðèñóåò ïðÿìîóãîëüíèê.
//!
//! @param x0 X-êîîðäèíàòà âåðõíåãî ëåâîãî óãëà
//! @param y0 Y-êîîðäèíàòà âåðõíåãî ëåâîãî óãëà
//! @param x1 X-êîîðäèíàòà íèæíåãî ïðàâîãî óãëà
//! @param y1 Y-êîîðäèíàòà íèæíåãî ïðàâîãî óãëà
//!
//! @return Åñëè îïåðàöèÿ áûëà óñïåøíà - true, èíà÷å - false.
//!
//! Öâåò è òîëùèíà ëèíèé çàäàåòñÿ ôóíêöèåé txSetColor(), öâåò çàïîëíåíèÿ - txSetFillColor().
//!
//! @see txSetColor(), txGetColor(), txSetFillColor(), txGetFillColor(), txColors, RGB(),
//! txLine(), txRectangle(), txPolygon(), txEllipse(), txCircle(), txArc(), txPie(), txChord()
//!
//! @usage @code
//! txRectangle (100, 200, 400, 500);
//!
//! Win32::RoundRect (txDC(), 100, 200, 400, 500, 30, 30); // È òàêîå åñòü. Ñì. RoundRect â MSDN.com
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
bool txRectangle (double x0, double y0, double x1, double y1);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Ðèñóåò ëîìàíóþ ëèíèþ èëè ìíîãîóãîëüíèê.
//!
//! @param points Ìàññèâ ñòðóêòóð POINT ñ êîîðäèíàòàìè òî÷åê
//! @param numPoints Êîëè÷åñòâî òî÷åê â ìàññèâå
//!
//! @return Åñëè îïåðàöèÿ áûëà óñïåøíà - true, èíà÷å - false.
//!
//! Öâåò è òîëùèíà ëèíèé çàäàåòñÿ ôóíêöèåé txSetColor(), öâåò çàïîëíåíèÿ - txSetFillColor().
//!
//! @see txSetColor(), txGetColor(), txSetFillColor(), txGetFillColor(), txColors, RGB(),
//! txLine(), txRectangle(), txPolygon(), txEllipse(), txCircle(), txArc(), txPie(), txChord()
//!
//! @usage @code
//! POINT star[5] = {{150, 300}, {200, 100}, {250, 300}, {100, 200}, {300, 200}};
//! txPolygon (star, 5); // ß êðèâàÿ çâåçäî÷êà
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
bool txPolygon (const POINT points[], int numPoints);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Ðèñóåò ýëëèïñ.
//!
//! @param x0 X-êîîðäèíàòà âåðõíåãî ëåâîãî óãëà ïðÿìîóãîëüíèêà, îïèñàííîãî âîêðóã ýëëèïñà
//! @param y0 Y-êîîðäèíàòà âåðõíåãî ëåâîãî óãëà îïèñàííîãî ïðÿìîóãîëüíèêà
//! @param x1 X-êîîðäèíàòà íèæíåãî ïðàâîãî óãëà îïèñàííîãî ïðÿìîóãîëüíèêà
//! @param y1 Y-êîîðäèíàòà íèæíåãî ïðàâîãî óãëà îïèñàííîãî ïðÿìîóãîëüíèêà
//!
//! @return Åñëè îïåðàöèÿ áûëà óñïåøíà - true, èíà÷å - false.
//!
//! Öâåò è òîëùèíà ëèíèé çàäàåòñÿ ôóíêöèåé txSetColor(), öâåò çàïîëíåíèÿ - txSetFillColor().
//!
//! @see txSetColor(), txGetColor(), txSetFillColor(), txGetFillColor(), txColors, RGB(),
//! txLine(), txRectangle(), txPolygon(), txEllipse(), txCircle(), txArc(), txPie(), txChord()
//!
//! @usage @code
//! txEllipse (100, 100, 300, 200);
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
bool txEllipse (double x0, double y0, double x1, double y1);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Ðèñóåò îêðóæíîñòü èëè êðóã.
//!
//! @param x Õ-êîîðäèíàòà öåíòðà
//! @param y Y-êîîðäèíàòà öåíòðà
//! @param r Ðàäèóñ
//!
//! @return Åñëè îïåðàöèÿ áûëà óñïåøíà - true, èíà÷å - false.
//!
//! Öâåò è òîëùèíà ëèíèé çàäàåòñÿ ôóíêöèåé txSetColor(), öâåò çàïîëíåíèÿ - txSetFillColor().
//!
//! @see txSetColor(), txGetColor(), txSetFillColor(), txGetFillColor(), txColors, RGB(),
//! txLine(), txRectangle(), txPolygon(), txEllipse(), txCircle(), txArc(), txPie(), txChord()
//!
//! @usage @code
//! txCircle (100, 100, 10);
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
bool txCircle (double x, double y, double r);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Ðèñóåò äóãó ýëëèïñà.
//!
//! @param x0 X-êîîðäèíàòà âåðõíåãî ëåâîãî óãëà ïðÿìîóãîëüíèêà, îïèñàííîãî âîêðóã ýëëèïñà, ñîäåðæàùåãî äóãó (ñì. txEllipse)
//! @param y0 Y-êîîðäèíàòà âåðõíåãî ëåâîãî óãëà ïðÿìîóãîëüíèêà
//! @param x1 X-êîîðäèíàòà íèæíåãî ïðàâîãî óãëà ïðÿìîóãîëüíèêà
//! @param y1 Y-êîîðäèíàòà íèæíåãî ïðàâîãî óãëà ïðÿìîóãîëüíèêà
//! @param startAngle Óãîë ìåæäó íàïðàâëåíèåì îñè OX è íà÷àëîì äóãè (â ãðàäóñàõ)
//! @param totalAngle Âåëè÷èíà äóãè (â ãðàäóñàõ)
//!
//! @return Åñëè îïåðàöèÿ áûëà óñïåøíà - true, èíà÷å - false.
//!
//! Öâåò è òîëùèíà ëèíèé çàäàåòñÿ ôóíêöèåé txSetColor(), öâåò çàïîëíåíèÿ - txSetFillColor().
//!
//! @see txSetColor(), txGetColor(), txSetFillColor(), txGetFillColor(), txColors, RGB(),
//! txLine(), txRectangle(), txPolygon(), txEllipse(), txCircle(), txArc(), txPie(), txChord()
//!
//! @usage @code
//! txArc (100, 100, 300, 200, 45, 270);
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
bool txArc (double x0, double y0, double x1, double y1, double startAngle, double totalAngle);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Ðèñóåò ñåêòîð ýëëèïñà.
//!
//! @param x0 X-êîîðäèíàòà âåðõíåãî ëåâîãî óãëà ïðÿìîóãîëüíèêà, îïèñàííîãî âîêðóã ýëëèïñà, ñîäåðæàùåãî äóãó (ñì. txEllipse)
//! @param y0 Y-êîîðäèíàòà âåðõíåãî ëåâîãî óãëà ïðÿìîóãîëüíèêà
//! @param x1 X-êîîðäèíàòà íèæíåãî ïðàâîãî óãëà ïðÿìîóãîëüíèêà
//! @param y1 Y-êîîðäèíàòà íèæíåãî ïðàâîãî óãëà ïðÿìîóãîëüíèêà
//! @param startAngle Óãîë ìåæäó íàïðàâëåíèåì îñè OX è íà÷àëîì ñåêòîðà (â ãðàäóñàõ)
//! @param totalAngle Âåëè÷èíà ñåêòîðà (â ãðàäóñàõ)
//!
//! @return Åñëè îïåðàöèÿ áûëà óñïåøíà - true, èíà÷å - false.
//!
//! Öâåò è òîëùèíà ëèíèé çàäàåòñÿ ôóíêöèåé txSetColor(), öâåò çàïîëíåíèÿ - txSetFillColor().
//!
//! @see txSetColor(), txGetColor(), txSetFillColor(), txGetFillColor(), txColors, RGB(),
//! txLine(), txRectangle(), txPolygon(), txEllipse(), txCircle(), txArc(), txPie(), txChord()
//!
//! @usage @code
//! txPie (100, 100, 300, 200, 0, 180); // Enter Pacman
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
bool txPie (double x0, double y0, double x1, double y1, double startAngle, double totalAngle);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Ðèñóåò õîðäó ýëëèïñà.
//!
//! @param x0 X-êîîðäèíàòà âåðõíåãî ëåâîãî óãëà ïðÿìîóãîëüíèêà, îïèñàííîãî âîêðóã ýëëèïñà, ñîäåðæàùåãî äóãó (ñì. txEllipse)
//! @param y0 Y-êîîðäèíàòà âåðõíåãî ëåâîãî óãëà ïðÿìîóãîëüíèêà
//! @param x1 X-êîîðäèíàòà íèæíåãî ïðàâîãî óãëà ïðÿìîóãîëüíèêà
//! @param y1 Y-êîîðäèíàòà íèæíåãî ïðàâîãî óãëà ïðÿìîóãîëüíèêà
//! @param startAngle Óãîë ìåæäó íàïðàâëåíèåì îñè OX è íà÷àëîì õîðäû (â ãðàäóñàõ)
//! @param totalAngle Âåëè÷èíà õîðäû (â ãðàäóñàõ)
//!
//! @return Åñëè îïåðàöèÿ áûëà óñïåøíà - true, èíà÷å - false.
//!
//! Öâåò è òîëùèíà ëèíèé çàäàåòñÿ ôóíêöèåé txSetColor(), öâåò çàïîëíåíèÿ - txSetFillColor().
//!
//! @see txSetColor(), txGetColor(), txSetFillColor(), txGetFillColor(), txColors, RGB(),
//! txLine(), txRectangle(), txPolygon(), txEllipse(), txCircle(), txArc(), txPie(), txChord()
//!
//! @usage @code
//! txChord (100, 100, 300, 200, 45, 270);
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
bool txChord (double x0, double y0, double x1, double y1, double startAngle, double totalAngle);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Çàëèâàåò ïðîèçâîëüíûé êîíòóð òåêóùèì öâåòîì çàïîëíåíèÿ.
//!
//! @param x Õ-êîîðäèíàòà òî÷êè íà÷àëà çàëèâêè
//! @param y Y-êîîðäèíàòà òî÷êè íà÷àëà çàëèâêè
//! @param color Öâåò çàëèâàåìîé îáëàñòè (TX_TRANSPARENT - àâòîîïðåäåëåíèå)
//! @param mode Ðåæèì çàëèâêè (FLOODFILLSURFACE - çàëèâêà îäíîðîäíîãî ôîíà)
//!
//! @return Åñëè îïåðàöèÿ áûëà óñïåøíà - true, èíà÷å - false.
//!
//! Öâåò çàïîëíåíèÿ çàäàåòñÿ ôóíêöèåé txSetFillColor(). Íå ðåêîìåíäóåòñÿ äëÿ ïðèìåíåíèÿ - ðàáîòàåò
//! äîâîëüíî ìåäëåííî.
//!
//! @title Ðåæèìû çàëèâêè: @table
//! @tr FLOODFILLSURFACE @td - Çàëèâàòü îáëàñòü, óêàçàííóþ öâåòîì color.
//! @tr FLOODFILLBORDER @td - Çàëèâàòü äî ãðàíèöû, óêàçàííîé öâåòîì color.
//! @endtable
//!
//! @see txSetFillColor(), txGetFillColor(), txColors, RGB(),
//! txLine(), txRectangle(), txPolygon(), txEllipse(), txCircle(), txArc(), txPie(), txChord()
//!
//! @usage @code
//! txSetFillColor (TX_PINK);
//! txLine (100, 200, 150, 100);
//! txLine (150, 100, 200, 200);
//! txLine (200, 200, 100, 200);
//! txFloodFill (150, 150);
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
bool txFloodFill (double x, double y, COLORREF color = TX_TRANSPARENT, DWORD mode = FLOODFILLSURFACE);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Ôóíêöèÿ, êîòîðàÿ äîëæíà áû ðèñîâàòü òðåóãîëüíèê.
//!
//! @param x1 Õ-êîîðäèíàòà 1 òî÷êè
//! @param y1 Y-êîîðäèíàòà 1 òî÷êè
//! @param x2 Õ-êîîðäèíàòà 2 òî÷êè
//! @param y2 Y-êîîðäèíàòà 2 òî÷êè
//! @param x3 Õ-êîîðäèíàòà 3 òî÷êè
//! @param y3 Y-êîîðäèíàòà 3 òî÷êè
//!
//! @return Åñëè îïåðàöèÿ áûëà áû óñïåøíà - true, èíà÷å - false.
//!
//! @see txSetFillColor(), txGetFillColor(), txColors, RGB(),
//! txLine(), txRectangle(), txPolygon(), txEllipse(), txCircle(), txArc(), txPie(), txChord()
//!
//! @par Ñì. òàêæå:
//! @ref Tutor_Params "Ïðèìåð ñ ôóíêöèÿìè ñ ïàðàìåòðàìè"
//}----------------------------------------------------------------------------------------------------------------
bool txTriangle (double x1, double y1, double x2, double y2, double x3, double y3)
{
(void)x1; (void)y1; (void)x2; (void)y2; (void)x3; (void)y3;
MessageBox (txWindow(),
"Ýòà ôóíêöèÿ íå ðåàëèçîâàíà â áèáëèîòåêå, ïîòîìó ÷òî âû ñàìè ëåãêî ìîæåòå ðåàëèçîâàòü åå\n"
"êàê ôóíêöèþ ñ ïàðàìåòðàìè, èñïîëüçóÿ txPolygon(). Ñì. \"Ïðèìåð ñ ôóíêöèÿìè ñ ïàðàìåòðàìè\". ",
"TXLib ñîîáùàåò", MB_ICONINFORMATION);
return false;
}
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Ðèñóåò ÷åëîâå÷êà.
//!
//! @param x Õ-êîîðäèíàòà ÷åëîâå÷êà
//! @param y Y-êîîðäèíàòà ÷åëîâå÷êà
//! @param sizeX Øèðèíà ÷åëîâå÷êà
//! @param sizeY Âûñîòà ÷åëîâå÷êà (òàêæå îïðåäåëÿåò ðàçìåð ãîëîâû)
//! @param color Öâåò ÷åëîâå÷êà
//! @param handL Âûñîòà ïîäúåìà ëåâîé ðóêè (îòíîñèòåëüíî âûñîòû ÷åëîâå÷êà)
//! @param handR Âûñîòà ïîäúåìà ïðàâîé ðóêè (îòíîñèòåëüíî âûñîòû ÷åëîâå÷êà)
//! @param twist Ñìåùåíèå @a ñïèíû (îòíîñèòåëüíî øèðèíû ÷åëîâå÷êà)
//! @param head Âûñîòà @a ïîäúåìà ãîëîâû (îòíîñèòåëüíî âûñîòû ÷åëîâå÷êà)
//! @param eyes Âåëè÷èíà ãëàç (îòíîñèòåëüíî ðàçìåðà ãîëîâû)
//! @param wink Ìîðãàíèå ãëàç (0 - îáà îòêðûòû, -1 - çàêðûò ëåâûé, +1 - çàêðûò ïðàâûé)
//! @param crazy Ñìåùåíèå ãëàç ïî âåðòèêàëè (îòíîñèòåëüíî ðàçìåðà ãîëîâû)
//! @param smile Óëûáêà (îòíîñèòåëüíî ðàçìåðà ãîëîâû)
//! @param hair Äëèíà âîëîñ (îòíîñèòåëüíî ðàçìåðà ãîëîâû)
//! @param wind Âåòåð, ðàçâåâàþùèé âîëîñû (îòíîñèòåëüíî ðàçìåðà ãîëîâû)
//!
//! @see txSetFillColor(), txColors, RGB(), txLine(), txCircle()
//!
//! @usage @code
//! txCreateWindow (800, 600);
//!
//! //-----------+---+----+-----+-----+----------+-----+-----+-----+----+----+----+-----+-----+----+-----
//! // | x | y |sizeX|sizeY| color |handL|handR|twist|head|eyes|wink|crazy|smile|hair|wind
//! //-----------+---+----+-----+-----+----------+-----+-----+-----+----+----+----+-----+-----+----+-----
//! // | | | | | | | | | | | | | | |
//! txDrawMan (125, 250, 200, 200, TX_WHITE, 0, 0, 0, 0, 0.8, 0, 0, 1.0, 0, 0);
//! txDrawMan (325, 250, 100, 200, TX_YELLOW, 0, 0, 0, 0, 0.8, 0, 0, -1.0, 2, 0);
//! txDrawMan (525, 250, 200, 100, TX_ORANGE, 0, 0, 0, 0, 1.0, 0, -1, 0.3, 1, 0);
//! txDrawMan (725, 250, 100, 100, TX_LIGHTRED, 0, 0, 0, 0, 1.0, 0, 1, -0.3, 3, 0);
//!
//! txDrawMan (125, 550, 200, 200, TX_WHITE, 0.3, 0.3, 0, 0, 0.8, -1, 1, 0.5, 2, -1);
//! txDrawMan (325, 550, 100, 200, TX_YELLOW, -0.5, -0.5, 0, 0.1, 0.8, 1, 0, -0.5, 3, 5);
//! txDrawMan (525, 550, 200, 100, TX_ORANGE, -0.5, 0.3, 0.2, 0, 0.8, -1, 1, 0.0, 10, -5);
//! txDrawMan (725, 550, 100, 100, TX_LIGHTRED, 0.3, -0.5, -0.4, 0, 0.8, 1, -1, 0.0, 1, 1);
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
void txDrawMan (int x, int y, int sizeX, int sizeY, COLORREF color, double handL, double handR, double twist,
double head, double eyes, double wink, double crazy, double smile, double hair, double wind);
//! @}
//}
//=================================================================================================================
//=================================================================================================================
//{ Drawing text
//! @name Ðàáîòà ñ òåêñòîì
//=================================================================================================================
//! @{
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Ðèñóåò òåêñò.
//!
//! @param x Õ-êîîðäèíàòà íà÷àëüíîé òî÷êè òåêñòà
//! @param y Y-êîîðäèíàòà íà÷àëüíîé òî÷êè òåêñòà
//! @param text Òåêñòîâàÿ ñòðîêà
//!
//! @return Åñëè îïåðàöèÿ áûëà óñïåøíà - true, èíà÷å - false.
//!
//! Öâåò òåêñòà çàäàåòñÿ ôóíêöèåé txSetColor(), âûðàâíèâàíèå - txSetTextAlign().
//!
//! @see txSetColor(), txGetColor(), txSetFillColor(), txGetFillColor(), txColors, RGB(),
//! txSelectFont(), txSetTextAign(), txGetTextExtent(), txGetTextExtentX(), txGetTextExtentY()
//!
//! @usage @code
//! txTextOut (100, 100, "Çäåñü ìîãëà áû áûòü Âàøà ðåêëàìà.");
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
bool txTextOut (double x, double y, const char text[]);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Ðèñóåò òåêñò, ðàçìåùåííûé â ïðÿìîóãîëüíîé îáëàñòè.
//!
//! @param x0 X-êîîðäèíàòà âåðõíåãî ëåâîãî óãëà îáëàñòè
//! @param y0 Y-êîîðäèíàòà âåðõíåãî ëåâîãî óãëà îáëàñòè
//! @param x1 X-êîîðäèíàòà íèæíåãî ïðàâîãî óãëà îáëàñòè
//! @param y1 Y-êîîðäèíàòà íèæíåãî ïðàâîãî óãëà îáëàñòè
//! @param text Òåêñòîâàÿ ñòðîêà
//! @param format Ôëàãè ôîðìàòèðîâàíèÿ òåêñòà
//!
//! @return Åñëè îïåðàöèÿ áûëà óñïåøíà - true, èíà÷å - false.
//!
//! Öâåò òåêñòà çàäàåòñÿ ôóíêöèåé txSetColor(), âûðàâíèâàíèå - txSetTextAlign().
//!
//! @note Íå âûâîäèò íè÷åãî, åñëè êîîðäèíàòû èäóò â íåâåðíîì ïîðÿäêå (åñëè x0 > x1 èëè y0 > y1).
//!
//! Ôëàãè ôîðìàòèðîâàíèÿ òåêñòà ñì. â MSDN (http://msdn.com), èñêàòü "DrawText Function (Windows)":
//! http://msdn.microsoft.com/en-us/library/dd162498%28VS.85%29.aspx.
//!
//! <b>Àâòîìàòè÷åñêèé ïåðåíîñ</b> òåêñòà íà íåñêîëüêî ñòðîê âêëþ÷àåòñÿ, åñëè òåêñò ñîñòîèò èç íåñêîëüêèõ
//! ñòðîê (åñòü õîòÿ áû îäèí ñèìâîë íîâîé ñòðîêè @b @c \\n).
//!
//! Åñëè íàäî îòôîðìàòèðîâàòü òåêñò íå ïî öåíòðó, à ïî ëåâîìó èëè ïðàâîìó êðàþ, òî íå çàáóäüòå óêàçàòü
//! îñòàëüíûå ôëàãè ôîðìàòèðîâàíèÿ, åñëè îíè íóæíû: @c DT_VCENTER (âåðòèêàëüíîå öåíòðèðîâàíèå) @c |
//! @c DT_WORDBREAK (ïåðåíîñ ïî ñëîâàì) @c | @c DT_WORD_ELLIPSIS (ñòàâèòü ìíîãîòî÷èå â êîíöå, åñëè òåêñò
//! íå óìåùàåòñÿ). Ñì. çíà÷åíèå ôëàãîâ ïî óìîë÷àíèþ.
//!
//! @see txSetColor(), txGetColor(), txSetFillColor(), txGetFillColor(), txColors, RGB(),
//! txTextOut(), txSelectFont(), txGetTextExtent(), txGetTextExtentX(), txGetTextExtentY()
//!
//! @usage @code
//! txSetColor (TX_BLACK);
//! txSetFillColor (TX_DARKGRAY); Win32::RoundRect (txDC(), 105, 105, 205, 255, 30, 30);
//! txSetFillColor (TX_WHITE); Win32::RoundRect (txDC(), 100, 100, 200, 250, 30, 30);
//!
//! txSelectFont ("Arial", 20, 0, FW_BOLD);
//! txDrawText (100, 100, 200, 250, "I hate it when I'm studying "
//! "and a Velociraptor throws bananas on me.\n");
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
bool txDrawText (double x0, double y0, double x1, double y1, const char text[],
unsigned format = DT_CENTER | DT_VCENTER | DT_WORDBREAK | DT_WORD_ELLIPSIS);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Âûáèðàåò òåêóùèé øðèôò.
//!
//! @param name Íàçâàíèå øðèôòà
//! @param sizeY Âûñîòà áóêâ (ðàçìåð ïî Y)
//! @param sizeX Øèðèíà áóêâ
//! @param bold Æèðíîñòü øðèôòà (îò 0 äî 1000)
//! @param italic Êóðñèâ
//! @param underline Ïîä÷åðêèâàíèå
//! @param strikeout Çà÷åðêèâàíèå
//! @param angle Óãîë ïîâîðîòà òåêñòà (â ãðàäóñàõ)
//!
//! @return Âñåãäà true. Åñëè øðèôò íå áûë íàéäåí, òî óñòàíàâëèâàåòñÿ ñèñòåìíûé øðèôò Windows
//! @c (SYSTEM_FIXED_FONT, ñì. MSDN). Ñóùåñòâîâàíèå øðèôòà ìîæíî ïðîâåðèòü ôóíêöèåé txFontExist.
//!
//! @see txTextOut(), txFontExist()
//!
//! @usage @code
//! txSelectFont ("Comic Sans MS", 40);
//! txTextOut (100, 100, "È çäåñü ìîãëà áû áûòü Âàøà ðåêëàìà.");
//! txSelectFont ("Comic Sans MS", 40, 10, false, true, false, true, 15);
//! txTextOut (100, 200, "Íî åå ïî÷åìó-òî íåò.");
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
bool txSelectFont (const char name[], double sizeY,
double sizeX = -1,
int bold = FW_DONTCARE,
bool italic = false,
bool underline = false,
bool strikeout = false,
double angle = 0);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Âû÷èñëÿåò ðàçìåðû òåêñòîâîé íàäïèñè.
//!
//! @param text Òåêñòîâàÿ ñòðîêà
//!
//! @return Ðàçìåðû íàäïèñè â ñòðóêòóðå SIZE.
//!
//! @see txTextOut(), txSelectFont(), txGetTextExtent(), txGetTextExtentX(), txGetTextExtentY()
//!
//! @usage @code
//! SIZE size = txGetTextExtent (text);
//! txTextOut (100 + size.cx / 2, 200 + size.cy / 2, text);
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
SIZE txGetTextExtent (const char text[]);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Âû÷èñëÿåò øèðèíó òåêñòîâîé íàäïèñè.
//!
//! @param text Òåêñòîâàÿ ñòðîêà
//!
//! @return Øèðèíà íàäïèñè.
//!
//! @see txTextOut(), txSelectFont(), txGetTextExtent(), txGetTextExtentX(), txGetTextExtentY()
//!
//! @usage @code
//! txTextOut (100 + txGetTextExtentX (text) / 2, 200 + txGetTextExtentY (text) / 2, text);
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
int txGetTextExtentX (const char text[]);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Âû÷èñëÿåò âûñîòó òåêñòîâîé íàäïèñè.
//!
//! @param text Òåêñòîâàÿ ñòðîêà
//!
//! @return Âûñîòà íàäïèñè.
//!
//! @see txTextOut(), txSelectFont(), txGetTextExtent(), txGetTextExtentX(), txGetTextExtentY()
//!
//! @usage @code
//! txTextOut (100 + txGetTextExtentX (text) / 2, 200 + txGetTextExtentY (text) / 2, text);
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
int txGetTextExtentY (const char text[]);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Óñòàíàâëèâàåò òåêóùåå âûðàâíèâàíèå òåêñòà.
//!
//! @param align Ôëàãè âûðàâíèâàíèÿ
//!
//! @return Ïðåäûäóùåå ñîñòîÿíèå âûðàâíèâàíèÿ òåêñòà.
//!
//! @title Ôëàãè âûðàâíèâàíèÿ: @table
//! @tr TA_BASELINE @td Òî÷êà (X,Y) îïðåäåëÿåò áàçîâóþ ëèíèþ òåêñòà.
//! @tr TA_BOTTOM @td Òî÷êà (X,Y) îïðåäåëÿåò íèæíþþ ñòîðîíó îïèñàííîãî ïðÿìîóãîëüíèêà (òåêñò ëåæèò âûøå ýòîé òî÷êè).
//! @tr TA_TOP @td Òî÷êà (X,Y) îïðåäåëÿåò âåðõíþþ ñòîðîíó îïèñàííîãî ïðÿìîóãîëüíèêà (òåêñò ëåæèò íèæå ýòîé òî÷êè).
//! @tbr
//! @tr TA_CENTER @td Òåêñò áóäåò âûðîâíåí ïî ãîðèçîíòàëè îòíîñèòåëüíî òî÷êè (X,Y).
//! @tr TA_LEFT @td Òî÷êà (X,Y) îïðåäåëÿåò ëåâóþ ñòîðîíó îïèñàííîãî ïðÿìîóãîëüíèêà (òåêñò ëåæèò ïðàâåå ýòîé òî÷êè).
//! @tr TA_RIGHT @td Òî÷êà (X,Y) îïðåäåëÿåò ïðàâóþ ñòîðîíó îïèñàííîãî ïðÿìîóãîëüíèêà (òåêñò ëåæèò ëåâåå ýòîé òî÷êè).
//! @endtable
//!
//! @see txTextOut(), txSelectFont(), txGetTextExtent(), txGetTextExtentX(), txGetTextExtentY()
//!
//! @usage @code
//! txSetTextAlign (TA_RIGHT);
//! txTextOut (700, 100, "×òîáû äîñòóï áûë ëåãîê è áûñòð,");
//! txTextOut (700, 150, "Ïåðåìåííóþ êëàäè â ðåãèñòð.");
//! txSetTextAlign();
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
unsigned txSetTextAlign (unsigned align = TA_CENTER | TA_BASELINE);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Èùåò øðèôò ïî åãî íàçâàíèþ.
//!
//! @param name Íàçâàíèå øðèôòà
//!
//! @return Èíôîðìàöèÿ î øðèôòå â ñòðóêòóðå LOGFONT. Åñëè øðèôò íå íàéäåí, âîçâðàùàåò NULL.
//!
//! @see txTextOut(), txSelectFont()
//!
//! @usage @code
//! if (txFontExist ("Comic Sans MS")) txSelectFont ("Comic Sans MS", 30);
//! else txSelectFont ("Times New Roman", 30);
//!
//! txTextOut (100, 100, "Êîìèê ëè Ñàíñ?");
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
LOGFONT* txFontExist (const char name[]);
//! @}
//}
//=================================================================================================================
//=================================================================================================================
//{ Drawing to memory DC and image loading
//! @name Ðèñîâàíèå â ïàìÿòè (íà "âèðòóàëüíîì õîëñòå") è çàãðóçêà èçîáðàæåíèé
//=================================================================================================================
//! @{
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Ñîçäàåò äîïîëíèòåëüíûé õîëñò (êîíòåêñò ðèñîâàíèÿ, Device Context, DC) â ïàìÿòè.
//!
//! @param sizeX Øèðèíà õîëñòà
//! @param sizeY Âûñîòà õîëñòà
//! @param bitmap Bitmap to be associated with DC
//!
//! @return Äåñêðèïòîð (ñèñòåìíûé íîìåð, âûäàííûé Windows) ñîçäàííîãî õîëñòà (êîíòåêñòà ðèñîâàíèÿ).
//!
//! @warning Ñîçäàííûé êîíòåêñò çàòåì áóäåò íóæíî @b îáÿçàòåëüíî óäàëèòü ïðè ïîìîùè txDeleteDC(). @n
//! <small>When the program will be shutting down, TXLib will try to delete DCs which were not deleted,
//! but this is not guaranteed.</small>
//!
//! @see txCreateWindow(), txCreateCompatibleDC(), txLoadImage(), txDeleteDC()
//!
//! @usage @code
//! HDC save = txCreateCompatibleDC (100, 100);
//!
//! txBitBlt (save, 0, 0, 100, 100, txDC(), 0, 0); // Ñîõðàíÿåì ôîí
//!
//! txTextOut (20, 20, "Boo!");
//! txSleep (2000);
//!
//! txBitBlt (txDC(), 0, 0, 100, 100, save, 0, 0); // Òåêñò èñ÷åçàåò
//!
//! txDeleteDC (save);
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
HDC txCreateCompatibleDC (double sizeX, double sizeY, HBITMAP bitmap = NULL);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Çàãðóæàåò èç ôàéëà èçîáðàæåíèå â ôîðìàòå BMP. Äåëàåò ýòî äîâîëüíî ìåäëåííî.
//!
//! @param filename Èìÿ ôàéëà ñ èçîáðàæåíèåì â ôîðìàòå BMP
//! @param imageFlags Òèï çàãðóæàåìîãî èçîáðàæåíèÿ, ñì. íèæå
//! @param loadFlags Ôëàãè çàãðóçêè èçîáðàæåíèÿ, ñì. íèæå
//!
//! @return Äåñêðèïòîð ñîçäàííîãî êîíòåêñòà ðèñîâàíèÿ â ïàìÿòè, ñ çàãðóæåííûì èçîáðàæåíèåì.
//! Åñëè èçîáðàæåíèå íå çàãðóæåíî (íå íàéäåí ôàéë, íåâåðíûé ôîðìàò ôàéëà è ò.ä.), òî NULL.
//!
//! @warning Èçîáðàæåíèå çàãðóæàåòñÿ â ñîçäàâàåìûé êîíòåêñò ðèñîâàíèÿ â ïàìÿòè ("âèðòóàëüíûé õîëñò"), êîòîðûé çàòåì
//! áóäåò íóæíî <b>îáÿçàòåëüíî óäàëèòü</b> ïðè ïîìîùè txDeleteDC(). @n
//! <small>When the program will be shutting down, TXLib will try to delete DCs which were not deleted,
//! but this is not guaranteed.</small>
//!
//! @note Èçîáðàæåíèÿ ïîääåðæèâàþòñÿ <b>òîëüêî â ôîðìàòå BMP.</b> Åñëè âçÿòü ôàéë äðóãîãî ôîðìàòà, íàïðèìåð JPG,
//! è ïåðåèìåíîâàòü åãî ñî ñìåíîé ðàñøèðåíèÿ íà BMP, òî îò ýòîãî ôîðìàò íå èçìåíèòñÿ. Òàêîå èçîáðàæåíèå
//! çàãðóæåíî íå áóäåò.
//!
//! Åñëè ôóíêöèÿ âåðíóëà NULL, òî íàäî ïðåæäå âñåãî <b>ïðîâåðèòü íàëè÷èå ôàéëà èçîáðàæåíèÿ</b> ïî
//! óêàçàííîìó â ïðîãðàììå ïóòè è ôîðìàò ôàéëà. Åñëè ïóòü ê ôàéëó íå óêàçàí (èëè óêàçàí êàê íåïîëíûé),
//! òî ïóòü îòñ÷èòûâàåòñÿ îò òåêóùåé ïàïêè ïðîãðàììû, êîòîðàÿ ìîæåò íå ñîâïàäàòü òåêóùåé ïàïêîé ñðåäû
//! ïðîãðàììèðîâàíèÿ. Òåêóùóþ ïàïêó ïðîãðàììû ìîæíî ïîñìîòðåòü ïî êîìàíäå About â ñèñòåìíîì ìåíþ
//! (îíà óêàçàíà òàì êàê "Run from").
//!
//! @note <b>Íå íàäî ÷àñòî çàãðóæàòü</b> îäíî è òî æå èçîáðàæåíèå, îñîáåííî â öèêëå. Îò ýòîãî ïðîãðàììà íà÷èíàåò
//! òîðìîçèòü! @n
//! @note Çàãðóçèòå îäèí ðàç @a ïåðåä öèêëîì, ïîòîì èñïîëüçóéòå ìíîãî ðàç. Ïîñìîòðèòå, êàê ýòî ñäåëàíî â ïðèìåðå
//! TX\Examples\Tennis\Tennis.cpp.
//!
//! @title Òèïû èçîáðàæåíèé:
//! @table @tr IMAGE_BITMAP @td Çàãðóæàåò ðèñóíîê â ôîðìàòå BMP
//! @tr IMAGE_CURSOR @td Çàãðóæàåò êóðñîð
//! @tr IMAGE_ICON @td Çàãðóæàåò èêîíêó
//! @endtable
//!
//! @title Ôëàãè çàãðóçêè:
//! @table @tr LR_CREATEDIBSECTION @td Ñîçäàåò DIB (device-indepandent bitmap), óäîáíóþ äëÿ ïðÿìîãî äîñòóïà ê äàííûì
//! @tr LR_LOADFROMFILE @td Çàãðóæàåò èç ôàéëà (åñëè ýòîò ôëàã íå óêàçàí, òî çàãðóæàåò èç ðåñóðñà)
//! @tr Îñòàëüíûå ôëàãè çàãðóçêè @td ñì. íà MSDN.com, ïîèñê "LoadImage function".
//! @endtable
//!
//! @see txCreateWindow(), txCreateCompatibleDC(), txLoadImage(), txDeleteDC(), txBitBlt(), txAlphaBlend(), txTransparentBlt()
//!
//! @usage Ïðèìåð èñïîëüçîâàíèÿ ñì. â ôàéëå TX\Examples\Tennis\Tennis.cpp.
//! @code
//! HDC background_FromTXLibHelp = txLoadImage ("Resources\\Images\\Background.bmp");
//!
//! if (!background_FromTXLibHelp)
//! txMessageBox ("Íå ìîãó çàãðóçèòü ôîí èç Background.bmp", "Äà, ÿ ñêîïèðîâàë ýòî èç ïðèìåðà");
//!
//! // Íå íàäî ÷àñòî çàãðóæàòü îäíî è òî æå èçîáðàæåíèå, îñîáåííî â öèêëå - ïðîãðàììà áóäåò òîðìîçèòü!
//! // Çàãðóçèòå îäèí ðàç ïåðåä öèêëîì, ïîòîì èñïîëüçóéòå ìíîãî ðàç.
//! // Ïîñìîòðèòå, êàê ñäåëàíî â ïðèìåðå TX\Examples\Tennis\Tennis.cpp.
//!
//! txBitBlt (txDC(), 0, 0, 800, 600, background_FromTXLibHelp, 0, 0);
//!
//! ...
//! txDeleteDC (background_FromTXLibHelp);
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
HDC txLoadImage (const char filename[], unsigned imageFlags = IMAGE_BITMAP, unsigned loadFlags = LR_LOADFROMFILE);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Óíè÷òîæàåò õîëñò (êîíòåêñò ðèñîâàíèÿ, DC) â ïàìÿòè.
//!
//! @param dc Êîíòåêñò ðèñîâàíèÿ äëÿ óíè÷òîæåíèÿ. @n
//! Åñëè ïåðåäàí óêàçàòåëü, òî ïîñëå óíè÷òîæåíèÿ ïî óêàçàòåëþ çàïèñûâàåòñÿ NULL.
//!
//! @return Åñëè îïåðàöèÿ áûëà óñïåøíà - true, èíà÷å - false.
//!
//! @see txCreateWindow(), txCreateCompatibleDC(), txLoadImage(), txDeleteDC()
//!
//! @usage Ïðèìåð èñïîëüçîâàíèÿ ñì. â ôàéëå TX\Examples\Tennis\Tennis.cpp.
//! @code
//! HDC background_FromTXLibHelp = txLoadImage ("Resources\\Images\\Background.bmp");
//!
//! if (!background_FromTXLibHelp)
//! txMessageBox ("Íå ìîãó çàãðóçèòü ôîí èç Background.bmp, è ÿ ñêîïèðîâàë ýòî èç ïðèìåðà.", "Oh, not now");
//!
//! // Ñì. âàæíûé êîììåíòàðèé â ïðèìåðå ê ôóíêöèè txLoadImage!
//!
//! txBitBlt (txDC(), 0, 0, 800, 600, background_FromTXLibHelp, 0, 0);
//!
//! ...
//! txDeleteDC (background_FromTXLibHelp);
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
//@ {
bool txDeleteDC (HDC dc);
//! @cond INTERNAL
bool txDeleteDC (HDC* dc);
//! @endcond
//@ }
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Êîïèðóåò èçîáðàæåíèå ñ îäíîãî õîëñòà (êîíòåêñòà ðèñîâàíèÿ, DC) íà äðóãîé.
//!
//! @param dest Êîíòåêñò íàçíà÷åíèÿ (êóäà êîïèðîâàòü)
//! @param xDest Õ-êîîðäèíàòà âåðõíåãî ëåâîãî óãëà èçîáðàæåíèÿ-ïðèåìíèêà
//! @param yDest Y-êîîðäèíàòà âåðõíåãî ëåâîãî óãëà èçîáðàæåíèÿ-ïðèåìíèêà
//! @param width Øèðèíà êîïèðóåìîãî èçîáðàæåíèÿ
//! @param height Âûñîòà êîïèðóåìîãî èçîáðàæåíèÿ
//! @param src Êîíòåêñò èñòî÷íèêà (îòêóäà êîïèðîâàòü)
//! @param xSrc Õ-êîîðäèíàòà âåðõíåãî ëåâîãî óãëà èçîáðàæåíèÿ-èñòî÷íèêà
//! @param ySrc Y-êîîðäèíàòà âåðõíåãî ëåâîãî óãëà èçîáðàæåíèÿ-èñòî÷íèêà
//! @param rOp Ðàñòðîâàÿ îïåðàöèÿ êîïèðîâàíèÿ
//!
//! @return Åñëè îïåðàöèÿ áûëà óñïåøíà - true, èíà÷å - false.
//!
//! @warning Åñëè êîíòåêñòû íàçíà÷åíèÿ èëè èñòî÷íèêà ðàâíû NULL, òî îíè íå ñóùåñòâóþò è êîïèðîâàíèå âûçîâåò îøèáêó.
//! Íàèáîëåå ÷àñòàÿ ïðè÷èíà - îøèáêà ïðè çàãðóçêå ôàéëà èçîáðàæåíèÿ è îòñóòñòâèå ïðîâåðêè íà ýòó îøèáêó.
//! Ïðèìåð ñ ïðîâåðêîé íà ïðàâèëüíîñòü çàãðóçêè ñì. íèæå.
//!
//! @title Ðåæèìû êîïèðîâàíèÿ:
//! @table @tr SRCCOPY @td Ïðîñòî êîïèðóåò :) - ñàìûé ðàñïðîñòðàíåííûé ðåæèì
//! @tbr
//! @tr BLACKNESS @td Çàïîëíÿåò õîëñò-ïðèåìíèê ÷åðíûì öâåòîì (õîëñò-èñòî÷íèê èãíîðèðóåòñÿ).
//! @tr WHITENESS @td Çàïîëíÿåò õîëñò-ïðèåìíèê áåëûì öâåòîì (õîëñò-èñòî÷íèê èãíîðèðóåòñÿ).
//! @tr DSTINVERT @td Èíâåðòèðóåò öâåòà íà õîëñòå-ïðèåìíèêå (õîëñò-èñòî÷íèê èãíîðèðóåòñÿ).
//! @tr PATCOPY @td Êîïèðóåò öâåò òåêóùåé êèñòè õîëñòà-ïðèåìíèêà.
//! @tbr
//! @tr MERGECOPY @td Ïðèåìíèê = ïðèåìíèê & öâåò òåêóùåé êèñòè èñòî÷íèêà.
//! @tr MERGEPAINT @td Ïðèåìíèê = ~ ïðèåìíèê | èñòî÷íèê
//! @tr NOTSRCCOPY @td Ïðèåìíèê = ~ èñòî÷íèê
//! @tr NOTSRCERASE @td Ïðèåìíèê = ~ (ïðèåìíèê | èñòî÷íèê)
//! @tr PATINVERT @td Ïðèåìíèê = êèñòü ïðèåìíèêà ^ ïðèåìíèê
//! @tr PATPAINT @td Ïðèåìíèê = (êèñòü ïðèåìíèêà | ~èñòî÷íèê) | ïðèåìíèê
//! @tr SRCAND @td Ïðèåìíèê = ïðèåìíèê & èñòî÷íèê
//! @tr SRCERASE @td Ïðèåìíèê = ~ïðèåìíèê & èñòî÷íèê
//! @tr SRCINVERT @td Ïðèåìíèê = ïðèåìíèê ^ èñòî÷íèê
//! @tr SRCPAINT @td Ïðèåìíèê = ïðèåìíèê | èñòî÷íèê
//! @endtable
//!
//! @see txAlphaBlend(), txTransparentBlt(), txSetColor(), txGetColor(), txSetFillColor(), txGetFillColor(), txColors, RGB()
//!
//! @usage Ïðèìåð èñïîëüçîâàíèÿ ñì. â ôàéëå TX\Examples\Tennis\Tennis.cpp.
//! @code
//! HDC background_FromTXLibHelp = txLoadImage ("Resources\\Images\\Background.bmp");
//!
//! if (!background_FromTXLibHelp)
//! ("Íå ìîãó ôîí èç çàãðóçèòü Background.bmp, è äà, ÿ âçÿë ýòîò êîä èç ïðèìåðà.", "Once again :(");
//!
//! // Ñì. âàæíûé êîììåíòàðèé â ïðèìåðå ê ôóíêöèè txLoadImage!
//!
//! txBitBlt (txDC(), 0, 0, 800, 600, background_FromTXLibHelp, 0, 0);
//!
//! ...
//! txDeleteDC (background_FromTXLibHelp);
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
bool txBitBlt (HDC dest, double xDest, double yDest, double width, double height,
HDC src, double xSrc = 0, double ySrc = 0, DWORD rOp = SRCCOPY);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Êîïèðóåò èçîáðàæåíèå ñ îäíîãî õîëñòà (êîíòåêñòà ðèñîâàíèÿ, DC) íà äðóãîé
//! ñ ó÷åòîì ïðîçðà÷íîñòè.
//!
//! @param dest Êîíòåêñò íàçíà÷åíèÿ (êóäà êîïèðîâàòü)
//! @param xDest Õ-êîîðäèíàòà âåðõíåãî ëåâîãî óãëà èçîáðàæåíèÿ-ïðèåìíèêà
//! @param yDest Y-êîîðäèíàòà âåðõíåãî ëåâîãî óãëà èçîáðàæåíèÿ-ïðèåìíèêà
//! @param width Øèðèíà êîïèðóåìîãî èçîáðàæåíèÿ, íåîòðèöàòåëüíàÿ
//! @param height Âûñîòà êîïèðóåìîãî èçîáðàæåíèÿ, íåîòðèöàòåëüíàÿ
//! @param src Êîíòåêñò èñòî÷íèêà (îòêóäà êîïèðîâàòü)
//! @param xSrc Õ-êîîðäèíàòà âåðõíåãî ëåâîãî óãëà èçîáðàæåíèÿ-èñòî÷íèêà
//! @param ySrc Y-êîîðäèíàòà âåðõíåãî ëåâîãî óãëà èçîáðàæåíèÿ-èñòî÷íèêà
//! @param transColor Öâåò, êîòîðûé áóäåò ñ÷èòàòüñÿ ïðîçðà÷íûì
//!
//! @return Åñëè îïåðàöèÿ áûëà óñïåøíà - true, èíà÷å - false.
//!
//! @warning Åñëè êîíòåêñòû íàçíà÷åíèÿ èëè èñòî÷íèêà ðàâíû NULL, òî îíè íå ñóùåñòâóþò è êîïèðîâàíèå âûçîâåò îøèáêó.
//! Íàèáîëåå ÷àñòàÿ ïðè÷èíà - îøèáêà ïðè çàãðóçêå ôàéëà èçîáðàæåíèÿ è îòñóòñòâèå ïðîâåðêè íà ýòó îøèáêó.
//! Ïðèìåð ñ ïðîâåðêîé íà ïðàâèëüíîñòü çàãðóçêè ñì. íèæå.
//!
//! Ñòàíäàðòíàÿ ôóíêöèÿ TransparentBlt èç Win32 API ìîæåò ìàñøòàáèðîâàòü èçîáðàæåíèå. Â txTransparentBlt
//! ýòî óáðàíî äëÿ óïðîùåíèÿ èñïîëüçîâàíèÿ. If you need image scaling, use original function
//! TransparentBlt and don't mess with stupid TX-based tools. (See implementation of txTransparentBlt
//! in TXLib.h).
//!
//! @note Åñëè TransparentBlt íå ðàáîòàåò, èñïîëüçóéòå ôóíêöèþ AlphaBlend, îíà âîîáùå ëó÷øå.
//!
//! @see txBitBlt(), txTransparentBlt(), txLoadImage(), txCreateCompatibleDC()
//!
//! @usage Ïðèìåð èñïîëüçîâàíèÿ ñì. â ôàéëå TX\Examples\Tennis\Tennis.cpp.
//! @code
//! HDC superman_FromTXLibHelp = txLoadImage ("Resources\\Images\\Superman.bmp");
//!
//! if (!superman_FromTXLibHelp)
//! txMessageBox ("Cannot load superman, all the monsters will succeed (I copied them from TXLib Help)", "Sorry");
//!
//! // Ñì. âàæíûé êîììåíòàðèé â ïðèìåðå ê ôóíêöèè txLoadImage!
//!
//! txTransparentBlt (txDC(), 0, 0, 800, 600, superman_FromTXLibHelp, 0, 0);
//!
//! // À ìîæíî è òàê:
//! Win32::TransparentBlt (txDC(), 0, 0, 800, 600, superman_FromTXLibHelp, 0, 0, 80, 60, -1); // 10-êðàòíîå óâåëè÷åíèå
//! // Ïîçíàé ìîùü Win32 GDI, îòêàçàâøèñü îò TXLib'à! :) ñì. TransparentBlt â MSDN.com.
//!
//! ...
//! txDeleteDC (superman_FromTXLibHelp); // So pity :( But he was only a copy from TXLib Help.
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
bool txTransparentBlt (HDC dest, double xDest, double yDest, double width, double height,
HDC src, double xSrc = 0, double ySrc = 0, COLORREF transColor = TX_BLACK);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Êîïèðóåò èçîáðàæåíèå ñ îäíîãî õîëñòà (êîíòåêñòà ðèñîâàíèÿ, DC) íà äðóãîé
//! ñ ó÷åòîì ïðîçðà÷íîñòè.
//!
//! @param dest Êîíòåêñò íàçíà÷åíèÿ (êóäà êîïèðîâàòü)
//! @param xDest Õ-êîîðäèíàòà âåðõíåãî ëåâîãî óãëà èçîáðàæåíèÿ-ïðèåìíèêà
//! @param yDest Y-êîîðäèíàòà âåðõíåãî ëåâîãî óãëà èçîáðàæåíèÿ-ïðèåìíèêà
//! @param width Øèðèíà êîïèðóåìîãî èçîáðàæåíèÿ, íåîòðèöàòåëüíàÿ
//! @param height Âûñîòà êîïèðóåìîãî èçîáðàæåíèÿ, íåîòðèöàòåëüíàÿ
//! @param src Êîíòåêñò èñòî÷íèêà (îòêóäà êîïèðîâàòü). Äîëæåí èìåòü 32-áèòîâûé ôîðìàò è àëüôà-êàíàë (ñì. íèæå).
//! @param xSrc Õ-êîîðäèíàòà âåðõíåãî ëåâîãî óãëà èçîáðàæåíèÿ-èñòî÷íèêà, äîëæíà áûòü â ïðåäåëàõ ðàçìåðà èñòî÷íèêà.
//! @param ySrc Y-êîîðäèíàòà âåðõíåãî ëåâîãî óãëà èçîáðàæåíèÿ-èñòî÷íèêà, äîëæíà áûòü â ïðåäåëàõ ðàçìåðà èñòî÷íèêà.
//! @param alpha Îáùàÿ ïðîçðà÷íîñòü èçîáðàæåíèÿ, â äîïîëíåíèå ê àëüôà-êàíàëó (0 - âñå ïðîçðà÷íî, 1 - èñïîëüçîâàòü òîëüêî àëüôà-êàíàë).
//!
//! @return Åñëè îïåðàöèÿ áûëà óñïåøíà - true, èíà÷å - false.
//!
//! @warning Åñëè êîíòåêñòû íàçíà÷åíèÿ èëè èñòî÷íèêà ðàâíû NULL, òî îíè íå ñóùåñòâóþò è êîïèðîâàíèå âûçîâåò îøèáêó.
//! Íàèáîëåå ÷àñòàÿ ïðè÷èíà - îøèáêà ïðè çàãðóçêå ôàéëà èçîáðàæåíèÿ è îòñóòñòâèå ïðîâåðêè íà ýòó îøèáêó.
//! Ïðèìåð ñ ïðîâåðêîé íà ïðàâèëüíîñòü çàãðóçêè ñì. íèæå.
//!
//! Èçîáðàæåíèå-èñòî÷íèê è èçîáðàæåíèå-ïðèåìíèê íå ìîãóò íàëàãàòüñÿ äðóã íà äðóãà.
//!
//! @note Èçîáðàæåíèå äîëæíî áûòü çàãðóæåíî ñ ïîìîùüþ txLoadImage() è èìåòü <b>32-áèòîâûé RGBA-ôîðìàò.</b>
//! Äîïîëíèòåëüíûé êàíàë <b>(A, àëüôà-êàíàë)</b> ýòîãî ôîðìàòà îòâå÷àåò çà ïðîçðà÷íîñòü ó÷àñòêîâ
//! èçîáðàæåíèÿ. 24-áèòîâûé ôîðìàò (TrueColor RGB) ôóíêöèÿ txAlphaBlend íå ïîääåðæèâàåò.
//!
//! Àëüôà-êàíàë ìîæíî ñäåëàòü, íàïðèìåð, â Adobe Photoshop, êîìàíäîé "Íîâûé êàíàë (New Channel)" â ïàëèòðå
//! êàíàëîâ (Channels). ×åðíûé öâåò â àëüôà-êàíàëå ñîîòâåòñòâóåò ïîëíîé ïðîçðà÷íîñòè, áåëûé - ïîëíîé
//! íåïðîçðà÷íîñòè. <b>Ïðè ýòîì â ïðîçðà÷íûõ îáëàñòÿõ ñàìî èçîáðàæåíèå (â êàíàëàõ R, G, B) äîëæíî áûòü
//! ÷åðíûì, è ÷åì ïðîçðà÷íåå, òåì ÷åðíåå.</b> Ñì. èçîáðàæåíèå ñ àëüôà-êàíàëîì â ïðèìåðå
//! TX\Examples\Tennis\Tennis.cpp (ôàéë ñ òåííèñíîé ðàêåòêîé: TX\Examples\Tennis\Resources\Images\Racket.bmp).
//!
//! Ñòðîãî ãîâîðÿ, íàäî äîìíîæèòü êàíàëû R,G,B íà àëüôà-êàíàë: <tt>R,G,B *= A</tt>. Ïîëó÷èòñÿ âîò ÷òî:
//!
//! - Åñëè çíà÷åíèå àëüôà-êàíàëà äëÿ íåêîòîðîãî ïèêñåëÿ ðàâíî 0 (ïîëíàÿ ïðîçðà÷íîñòü), òîãäà çíà÷åíèÿ
//! êàíàëîâ R,G,B äëÿ ýòîãî ïèêñåëÿ òàêæå ñòàíóò 0 (ýòî ÷åðíûé öâåò).
//! - Åñëè çíà÷åíèå àëüôà-êàíàëà äëÿ íåêîòîðîãî ïèêñåëÿ ðàâíî 255 (ïîëíàÿ íåïðîçðà÷íîñòü), òîãäà çíà÷åíèÿ
//! êàíàëîâ R,G,B äëÿ ýòîãî ïèêñåëÿ íå èçìåíÿòñÿ.
//! - Äëÿ äðóãèõ çíà÷åíèé àëüôà-êàíàëà, ïèêñåëè èçîáðàæåíèÿ ñòàíóò òåìíåå.
//!
//! Â Photoshop ýòî ìîæíî ñäåëàòü êîìàíäîé <b>Image @d Apply Image</b> ñ ïàðàìåòðàìè:
//! @table @tr Source: @td <i>Èìÿ ôàéëà ñ êàðòèíêîé</i>
//! @tr Layer: @td Background
//! @tr @b Channel: @td <b> Alpha 1</b>
//! @tr Blending: @td Multiply
//! @tr Opacity: @td 100%
//! @endtable
//!
//! @note Ñòàíäàðòíàÿ ôóíêöèÿ AlphaBlend èç Win32 API ìîæåò ìàñøòàáèðîâàòü èçîáðàæåíèå. Â txAlphaBlend ýòî
//! óáðàíî äëÿ óïðîùåíèÿ èñïîëüçîâàíèÿ. If you still need image scaling, use original function AlphaBlend
//! and don't mess with stupid TX-based tools. (See implementation of txAlphaBlend in TXLib.h).
//!
//! @see txBitBlt(), txTransparentBlt(), txLoadImage(), txCreateCompatibleDC()
//!
//! @usage Ïðèìåð èñïîëüçîâàíèÿ ñì. â ôàéëå TX\Examples\Tennis\Tennis.cpp.
//! @code
//! HDC batman_FromTXLibHelp = txLoadImage ("Resources\\Images\\Batman.bmp");
//!
//! if (!batman_FromTXLibHelp)
//! txMessageBox ("Call to Batman failed because I copied it from TXLib Help", "Do save yourself");
//!
//! // Ñì. âàæíûé êîììåíòàðèé â ïðèìåðå ê ôóíêöèè txLoadImage!
//!
//! txAlphaBlend (txDC(), 0, 0, 800, 600, batman_FromTXLibHelp, 0, 0);
//!
//! ...
//! txDeleteDC (batman_FromTXLibHelp); // Don't worry, batman will return in "Batman returns" movie, later...
//! ...
//!
//! return batman_FromTXLibHelp; // ...and there he comes -- in TXLib copy form
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
bool txAlphaBlend (HDC dest, double xDest, double yDest, double width, double height,
HDC src, double xSrc = 0, double ySrc = 0, double alpha = 1.0);
//! @}
//}
//=================================================================================================================
//{ Utility functions
//! @name Âñïîìîãàòåëüíûå ôóíêöèè
//=================================================================================================================
//! @{
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Çàäåðæèâàåò âûïîëíåíèå ïðîãðàììû íà îïðåäåëåííîå âðåìÿ.
//!
//! @param time Çàäåðæêà â ìèëëèñåêóíäàõ.
//!
//! @return Çàäåðæêà â ìèëëèñåêóíäàõ, ïðîèçîøåäøàÿ â äåéñòâèòåëüíîñòè.
//!
//! @note <b>Ïåðåä íà÷àëîì çàäåðæêè èçîáðàæåíèå â îêíå îáÿçàòåëüíî îáíîâèòñÿ,</b> äàæå åñëè ðèñîâàíèå
//! çàáëîêèðîâàíî ÷åðåç txBegin().
//!
//! @see txBegin(), txEnd(), txUpdateWindow()
//!
//! @usage @code
//! txSleep (500); // ÏÏ: Ïîñïàòü Ïîëñåêóíäû
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
double txSleep (double time);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Áëîêèðóåò îáíîâëåíèå èçîáðàæåíèÿ îêíà, âî èçáåæàíèå ìèãàíèÿ.
//!
//! Äëÿ ñíÿòèÿ áëîêèðîâêè èñïîëüçóåòñÿ ôóíêöèÿ txEnd().
//!
//! Åñëè â ïðîãðàììå òðåáóåòñÿ çàäåðæêà, òî èñïîëüçóéòå ôóíêöèþ txSleep(), òàê êàê îíà àâòîìàòè÷åñêè
//! îáíîâëÿåò èçîáðàæåíèå, íåçàâèñèìî îò ñîñòîÿíèÿ áëîêèðîâêè.
//!
//! @warning Èçáåãàéòå áëîêèðîâàíèÿ íà äîëãîå âðåìÿ. Ýòî ìîæåò ïðèâåñòè ê äåôåêòàì èçîáðàæåíèÿ â îêíå.
//!
//! @note Åñëè íàæàòà êëàâèøà Alt+PrintScreen, òî áëîêèðîâêà âðåìåííî îòìåíÿåòñÿ.
//!
//! @return Çíà÷åíèå ñ÷åò÷èêà áëîêèðîâêè (åñëè 0, òî ðèñîâàíèå ðàçáëîêèðîâàíî).
//!
//! @see txEnd(), txSleep(), txUpdateWindow(), txTextCursor()
//!
//! @usage @code
//! txBegin(); // Çäåñü èçîáðàæåíèå "çàìåðçíåò"
//! txSetFillColor (TX_WHITE);
//! txClear(); // Ýòî âûçâàëî áû ìèãàíèå áåç txBegin()
//! txSetFillColor (TX_RED);
//! txRectangle (100, 100, 200, 200);
//! txEnd(); // Çäåñü ìû ñðàçó óâèäèì îêîí÷àòåëüíûé ðèñóíîê
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
inline int txBegin();
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Ðàçáëîêèðóåò îáíîâëåíèå îêíà, çàáëîêèðîâàííîå ôóíêöèåé txBegin().
//!
//! @warning Åñëè txBegin() âûçûâàëàñü íåñêîëüêî ðàç, òî äëÿ ñíÿòèÿ áëîêèðîâêè òðåáóåòñÿ ñòîëüêî æå ðàç âûçâàòü
//! txEnd().
//!
//! @note Åñëè íàæàòà êëàâèøà Alt+PrintScreen, òî áëîêèðîâêà âðåìåííî îòìåíÿåòñÿ.
//!
//! @return Çíà÷åíèå ñ÷åò÷èêà áëîêèðîâêè (åñëè 0, òî ðèñîâàíèå ðàçáëîêèðîâàíî).
//!
//! @see txBegin(), txSleep(), txUpdateWindow(), txTextCursor()
//!
//! @usage @code
//! txBegin(); // Çäåñü èçîáðàæåíèå "çàìåðçíåò"
//! txSetFillColor (TX_WHITE);
//! txClear(); // Ýòî âûçâàëî áû ìèãàíèå áåç txBegin()
//! txSetFillColor (TX_RED);
//! txRectangle (100, 100, 200, 200);
//! txEnd(); // Çäåñü ìû ñðàçó óâèäèì îêîí÷àòåëüíûé ðèñóíîê
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
inline int txEnd();
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Service
//! @brief Ðàçðåøàåò èëè çàïðåùàåò àâòîìàòè÷åñêîå îáíîâëåíèå èçîáðàæåíèÿ â îêíå.
//!
//! @param update Ðåæèì îáíîâëåíèÿ (true - ðàçðåøèòü, false - çàïðåòèòü).
//!
//! @return Ïðåäûäóùåå ñîñòîÿíèå ðåæèìà îáíîâëåíèÿ.
//!
//!  îòëè÷èå îò txBegin() è txEnd(), êîòîðûå ïîääåðæèâàþò âëîæåííûå âûçîâû è ðàáîòàþò êàê "ñêîáêè äëÿ
//! çàìåðçàíèÿ êàðòèíêè", txUpdateWindow() ïîçâîëÿåò ÿâíî óñòàíîâèòü èëè ñíÿòü áëîêèðîâêó àâòîìàòè÷åñêîãî
//! îáíîâëåíèÿ.
//!
//! Áîëåå ïîëíóþ èíôîðìàöèþ î áëîêèðîâêå ñì. â ôóíêöèÿõ txBegin(), txEnd() è txSleep().
//!
//! @see txBegin(), txEnd(), txSleep(), txUpdateWindow(), txTextCursor(), txLock(), txUnlock(), txGDI()
//!
//! @usage @code
//! txUpdateWindow (false);
//! ...
//! txUpdateWindow();
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
inline int txUpdateWindow (int update = true);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Service
//! @brief Óñòàíàâëèâàåò òåêóùèé îáúåêò GDI.
//!
//! @param obj Äåñêðèïòîð îáúåêòà GDI
//!
//! @return Åñëè îïåðàöèÿ áûëà óñïåøíà - true, èíà÷å - false.
//!
//! @see txSetColor(), txGetColor(), txSetFillColor(), txGetFillColor(), txColors, RGB(), txSelectFont()
//!
//! @usage @code
//! HPEN pen = CreatePen (PS_DASH, 1, RGB (255, 128, 0));
//! txSelectObject (pen);
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
bool txSelectObject (HGDIOBJ obj);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Service
//! @brief Äåëàåò íå÷òî èíîãäà óäîáíîå. Ñì. íàçâàíèå ôóíêöèè.
//!
//! @return Åñëè îïåðàöèÿ áûëà óñïåøíà - true, èíà÷å - false.
//!
//! Ó ýòîé ôóíêöèè åñòü ñèíîíèì ñ ïðîñòûì ïîíÿòíûì íàçâàíèåì, ïîèùèòå åãî â ôàéëå áèáëèîòåêè, îêîëî
//! @a îïðåäåëåíèÿ ýòîé ôóíêöèè. Èëè ìîæíî @strike ñêîïèðîâàòü @endstrike íàáðàòü ýòî êèëîìåòðîâîå èìÿ
//! è ïîñìîòðåòü, ÷òî ïîëó÷èòñÿ.
//!
//! @see txCreateWindow(), txSleep()
//!
//! @usage @code
//! int main()
//! {
//! txCreateWindow (800, 600);
//!
//! txSetTextAlign (TA_CENTER);
//! txTextOut (txGetExtentX()/2, txGetExtentY()/2, "Press any key to exit!");
//! @endcode
//
// +--<<< Ýòî òåêñò ïîìîùè, êîòîðûé âû óæå ÷èòàëè. Èùèòå äàëüøå! Æìèòå [F3] èëè "Íàéòè äàëåå"
// |
// v
// txIDontWantToHaveAPauseAfterMyProgramBeforeTheWindowWillClose_AndIWillNotBeAskingWhereIsMyPicture();
//! @code txIDontWantToHaveAPauseAfterMyProgramBeforeTheWindowWillClose_AndIWillNotBeAskingWhereIsMyPicture();
//! return 0;
//! }
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
// +--<<< Ýòî _ïðîòîòèï_ ôóíêöèè, à íàäî íàéòè åå _îïðåäåëåíèå_. Èùèòå äàëüøå! Æìèòå [F3] èëè "Íàéòè äàëåå"
// |
// v
bool txIDontWantToHaveAPauseAfterMyProgramBeforeTheWindowWillClose_AndIWillNotBeAskingWhereIsMyPicture();
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Óíè÷òîæàåò îêíî TXLib.
//!
//! @return Åñëè îïåðàöèÿ áûëà óñïåøíà - true, èíà÷å - false.
//!
//! @warning Åñëè óíè÷òîæàåòñÿ ãëàâíîå îêíî TXLib, ôóíêöèÿ main() ïðåðûâàåòñÿ è ïðîãðàììà àâòîìàòè÷åñêè çàâåðøàåòñÿ.
//! Ïðè ýòîì @b íå ãàðàíòèðóåòñÿ ïðàâèëüíîå çàâåðøåíèå ïðîãðàììû, ïîýòîìó òàê äåëàòü @b íå ðåêîìåíäóåòñÿ.
//!
//! @see txCreateWindow()
//!
//! @usage @code
//! txDestroyWindow(); // Farewell to the world
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
bool txDestroyWindow();
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Îöåíèâàåò ñêîðîñòü ðàáîòû êîìïüþòåðà.
//!
//! @return Ñêîðîñòü ðàáîòû (ãðàôè÷åñêèõ îïåðàöèé) â óñëîâíûõ åäèíèöàõ.
//!
//! @see txSleep()
//!
//! @usage @code
//! if (txQueryPerformance() < 1) printf ("Õî÷åòñÿ íîâûé êîìïüþòåð");
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
double txQueryPerformance();
//! @}
//}
//=================================================================================================================
//{ Mouse functions
//! @name Ðàáîòà ñ ìûøüþ
//=================================================================================================================
//! @{
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Mouse
//! @brief Âîçâðàùàåò ïîçèöèþ Ìûøè!
//!
//! @return Ïîçèöèÿ ìûøè êàê ñòðóêòóðà POINT.
//!
//! @see txMouseX(), txMouseY(), txMousePos(), txMouseButtons()
//!
//! @usage @code
//! RECT area = { 100, 100, 110, 110 };
//!
//! while (txMouseButtons() != 1)
//! {
//! if (In (txMousePos(), area)) txTextOut (100, 100, "What are you doing here?!");
//! txSleep (0);
//! }
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
inline POINT txMousePos();
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Mouse
//! @brief Âîçâðàùàåò Õ-Êîîðäèíàòó Ìûøè!
//!
//! @return Õ-êîîðäèíàòà ìûøè.
//!
//! @see txMouseX(), txMouseY(), txMousePos(), txMouseButtons()
//!
//! @usage @code
//! while (txMouseButtons() != 1)
//! {
//! txCircle (txMouseX(), txMouseY(), 20);
//! txSleep (0);
//! }
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
inline int txMouseX();
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Mouse
//! @brief Âîçâðàùàåò Y-Êîîðäèíàòó Ìûøè!
//!
//! @return Y-êîîðäèíàòà ìûøè.
//!
//! @see txMouseX(), txMouseY(), txMousePos(), txMouseButtons()
//!
//! @usage @code
//! while (txMouseButtons() != 1)
//! {
//! txCircle (txMouseX(), txMouseY(), 20);
//! txSleep (0);
//! }
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
inline int txMouseY();
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Mouse
//! @brief Âîçâðàùàåò ñîñòîÿíèå Êíîïîê Ìûøè!
//!
//! @return Ñîñòîÿíèå Êíîïîê Ìûøè!
//!
//!  âîçâðàùàåìîì çíà÷åíèè âûñòàâëåííûé â åäèíèöó 1-é (ìëàäøèé) áèò îçíà÷àåò íàæàòóþ ëåâóþ Êíîïêó Ìûøè,
//! 2-é - ïðàâóþ. @n
//! Íàïðèìåð, âîçâðàùåííîå ÷èñëî 3 (äâîè÷íîå 11) îçíà÷àåò îäíîâðåìåííîå íàæàòèå ëåâîé è ïðàâîé Êíîïîê.
//!
//! @see txMouseX(), txMouseY(), txMousePos(), txMouseButtons()
//!
//! @usage @code
//! while (txMouseButtons() != 3)
//! {
//! if (txMouseButtons() & 1) txCircle (txMouseX(), txMouseY(), 20);
//! if (txMouseButtons() & 2) txLine (txMouseX(), txMouseY(), 0, 0);
//! txSleep (0);
//! }
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
inline int txMouseButtons();
//! @}
//}
//=================================================================================================================
//=================================================================================================================
//{ Console functions
//! @name Ôóíêöèè êîíñîëè
//=================================================================================================================
//! @{
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Óñòàíàâëèâàåò öâåòîâûå àòðèáóòû êîíñîëè.
//!
//! @param colors Öâåòîâûå àòðèáóòû êîíñîëè.
//!
//! @return Åñëè îïåðàöèÿ áûëà óñïåøíà - true, èíà÷å - false.
//!
//! @b Àòðèáóòû - ýòî öâåò òåêñòà (colorText) è öâåò ôîíà (colorBackground), îáúåäèíåííûå âìåñòå: @nn
//! <tt>colors = colorText + colorBackground * 16</tt> @nn
//! ëèáî @nn
//! <tt>colors = colorText | (colorBackground \<\< 4)</tt> @nn
//! Öâåòà àòðèáóòîâ @b íå èìåþò íèêàêîãî îòíîøåíèÿ ê öâåòàì ðèñîâàíèÿ, çàäàâàåìûìè @ref txColors "TX_..."
//! êîíñòàíòàìè, RGB(), txSetColor(), txColor(), txSetFillColor(), txFillColor() è ò.ä. Çíà÷åíèÿ öâåòîâ
//! ñì. íèæå.
//!
//! @title Çíà÷åíèÿ öâåòîâ àòðèáóòîâ
//! @table @tr Dec @td @c Hex @td @td Dec @td @c Hex @td
//! @tbr
//! @tr 0 = @td @c 0x0 @td = ×åðíûé, @td 8 = @td @c 0x8 @td = Òåìíî-ñåðûé,
//! @tr 1 = @td @c 0x1 @td = Ñèíèé, @td 9 = @td @c 0x9 @td = Ñâåòëî-ñèíèé,
//! @tr 2 = @td @c 0x2 @td = Çåëåíûé, @td 10 = @td @c 0xA @td = Ñâåòëî-çåëåíûé,
//! @tr 3 = @td @c 0x3 @td = Ñèíå-çåëåíûé, @td 11 = @td @c 0xB @td = Ñâåòëî-ñèíå-çåëåíûé,
//! @tr 4 = @td @c 0x4 @td = Êðàñíûé, @td 12 = @td @c 0xC @td = Ñâåòëî-êðàñíûé,
//! @tr 5 = @td @c 0x5 @td = Ìàëèíîâûé, @td 13 = @td @c 0xD @td = Ñâåòëî-ìàëèíîâûé,
//! @tr 6 = @td @c 0x6 @td = Òåìíî-æåëòûé, @td 14 = @td @c 0xE @td = Æåëòûé,
//! @tr 7 = @td @c 0x7 @td = Ñåðûé, @td 15 = @td @c 0xF @td = Áåëûé.
//! @endtable
//!
//!  øåñòíàäöàòèðè÷íîé ñèñòåìå ñ÷èñëåíèÿ àòðèáóòû çàäàâàòü ìîæíî ïðîùå: åñëè íóæåí, ñêàæåì, æåëòûé öâåò
//! íà ñèíåì ôîíå, òî åãî êîä áóäåò @c 0x1e (ñòàðøàÿ öèôðà - ñòàðøèå 4 áèòà - ýòî öâåò ôîíà, ìëàäøàÿ
//! öèôðà - ìëàäøèå 4 áèòà - ýòî öâåò òåêñòà).
//!
//! @see txTextCursor(), txGetConsoleAttr(), txSetConsoleCursorPos(), txGetConsoleCursorPos(),
//! txGetConsoleFontSize(), txClearConsole()
//!
//! @usage @code
//! txSetConsoleAttr (0x1E);
//! printf ("À â íåáå 0x1 åñòü ãîðîä 0xE"); // (c) Á. Ãðåáåíùèêîâ
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
bool txSetConsoleAttr (unsigned colors = 0x07);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Âîçâðàùàåò òåêóùèå öâåòîâûå àòðèáóòû êîíñîëè.
//!
//! @return Òåêóùèå öâåòîâûå àòðèáóòû êîíñîëè. Ñì. txSetConsoleAttr().
//!
//! @see txTextCursor(), txSetConsoleAttr(), txSetConsoleCursorPos(), txGetConsoleCursorPos(),
//! txGetConsoleFontSize(), txClearConsole()
//!
//! @usage @code
//! unsigned attr = txGetConsoleAttr();
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
unsigned txGetConsoleAttr();
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Ñòèðàåò òåêñò êîíñîëè.
//!
//! @return Åñëè îïåðàöèÿ áûëà óñïåøíà - true, èíà÷å - false.
//!
//! Ïðè ñòèðàíèè èñïîëüçóþòñÿ òåêóùèå àòðèáóòû (öâåòà òåêñòà è ôîíà) êîíñîëè.
//!
//! @see txTextCursor(), txSetConsoleAttr(), txGetConsoleAttr(), txGetConsoleCursorPos(),
//! txGetConsoleFontSize(), txClearConsole()
//!
//! @usage @code
//! txClearConsole(); // Íó âîò è âñå, äðóæîê
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
bool txClearConsole();
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Óñòàíàâëèâàåò ïîçèöèþ ìèãàþùåãî êóðñîðà êîíñîëè.
//!
//! @param x X-êîîðäèíàòà êóðñîðà â ïèêñåëÿõ.
//! @param y Y-êîîðäèíàòà êóðñîðà â ïèêñåëÿõ.
//!
//! @return Ïðåäûäóùåå ïîëîæåíèå ìèãàþùåãî êóðñîðà â ñòðóêòóðå POINT.
//!
//! @note Íåëüçÿ óñòàíîâèòü ñîâñåì ëþáóþ ïîçèöèþ. Òåêñò â êîíñîëè ðàñïîëîæåí ïî ïðÿìîóãîëüíîé ñåòêå, ðàçìåð
//! êîòîðîé çàâèñèò îò ðàçìåðîâ øðèôòà êîíñîëè. Óñòàíàâëèâàåìàÿ ïîçèöèÿ îêðóãëÿåòñÿ, ÷òîáû êóðñîð ïîïàë
//! â ÿ÷åéêó ñåòêè. Ñì. ïðèìåð ê ôóíêöèè txGetConsoleFontSize().
//!
//! @see txTextCursor(), txSetConsoleAttr(), txGetConsoleAttr(), txGetConsoleCursorPos(),
//! txGetConsoleFontSize(), txClearConsole()
//!
//! @usage @code
//! txSetConsoleCursorPos (txGetExtentX(), txGetExtentY()); // Öåíòð Âñåëåííîé
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
POINT txSetConsoleCursorPos (double x, double y);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Âîçâðàùàåò ïîçèöèþ ìèãàþùåãî êóðñîðà êîíñîëè.
//!
//! @return Ïîëîæåíèå ìèãàþùåãî êóðñîðà â ñòðóêòóðå POINT.
//!
//! @see txTextCursor(), txSetConsoleAttr(), txGetConsoleAttr(), txSetConsoleCursorPos(),
//! txGetConsoleFontSize(), txClearConsole()
//!
//! @usage @code
//! POINT pos = txGetConsoleCursorPos();
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
POINT txGetConsoleCursorPos();
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Âîçâðàùàåò ðàçìåðû øðèôòà êîíñîëè.
//!
//! @return Ðàçìåðû øðèôòà êîíñîëè â ïèêñåëÿõ, â ñòðóêòóðå POINT.
//!
//! @see txTextCursor(), txSetConsoleAttr(), txGetConsoleAttr(), txSetConsoleCursorPos(),
//! txGetConsoleFontSize(), txClearConsole()
//!
//! @usage @code
//! POINT size = txGetConsoleFontSize();
//! txSetConsoleCursorPos (5 * size.x, 10 * size.y); // À òåïåðü ìèãàé òàì
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
POINT txGetConsoleFontSize();
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Drawing
//! @brief Çàïðåùàåò èëè ðàçðåøàåò ðèñîâàíèå ìèãàþùåãî êóðñîðà â îêíå.
//!
//! @param blink false - çàïðåòèòü ìèãàþùèé êóðñîð
//!
//! @return Ïðåäûäóùåå çíà÷åíèå ñîñòîÿíèÿ êóðñîðà.
//!
//! @see txSetConsoleAttr(), txGetConsoleAttr(), txSetConsoleCursorPos(), txGetConsoleCursorPos(),
//! txGetConsoleFontSize(), txClearConsole(), txCreateWindow(), txUpdateWindow(), txLock(), txUnlock(), txGDI()
//!
//! @usage @code
//! txTextCursor (false);
//! ...
//! txTextCursor();
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
bool txTextCursor (bool blink = true);
//! @}
//}
//=================================================================================================================
//=================================================================================================================
//{ Other staff not related to drawing
//! @name Äðóãèå ïîëåçíûå ôóíêöèè, íå ñâÿçàííûå ñ ðèñîâàíèåì
//=================================================================================================================
//! @{
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief Âîñïðîèçâîäèò çâóêîâîé ôàéë.
//!
//! @param filename Èìÿ çâóêîâîãî ôàéëà. Åñëè NULL - îñòàíàâëèâàåò çâóê.
//! @param mode Ðåæèì âîñïðîèçâåäåíèÿ
//!
//! @return Åñëè îïåðàöèÿ áûëà óñïåøíà - true, èíà÷å - false.
//!
//! @title Ðåæèìû âîñïðîèçâåäåíèÿ: @table
//! @tr SND_ASYNC @td Çâóê ïðîèãðûâàåòñÿ îäíîâðåìåííî ñ ðàáîòîé ïðîãðàììû. @n
//! ×òîáû îòìåíèòü çâó÷àíèå, âûçîâèòå txPlaySound (NULL).
//! @tr SND_SYNC @td Âûïîëíåíèå ïðîãðàììû ïðèîñòàíàâëèâàåòñÿ äî îêîí÷àíèÿ âîñïðîèçâåäåíèÿ çâóêà.
//! @tr SND_LOOP @td Çàöèêëèâàòü çâóê ïðè âîñïðîèçâåäåíèè. @n
//! ×òîáû îòìåíèòü çâó÷àíèå, âûçîâèòå txPlaySound (NULL).
//! @tbr
//! @tr SND_NODEFAULT @td Íå èñïîëüçîâàòü çâóê ïî óìîë÷àíèþ, åñëè íåëüçÿ ïðîèãðàòü óêàçàííûé çâóêîâîé ôàéë.
//! @tr SND_NOSTOP @td Åñëè êàêîé-ëèáî çâóê óæå ïðîèãðûâàåòñÿ, íå îñòàíàâëèâàòü åãî äëÿ çàïóñêà óêàçàííîãî çâóêà.
//! @tr SND_APPLICATION @td Ïðîèãðûâàòü çâóê, èñïîëüçóÿ ïðîãðàììó, çàðåãèñòðèðîâàííóþ äëÿ äàííîãî òèïà çâóêîâûõ ôàéëîâ.
//! @endtable
//!
//! @note Ïîääåðæèâàþòñÿ òîëüêî ôàéëû â ôîðìàòå WAV. Îñòàëüíûå ôîðìàòû (MP3 è äð.) íàäî ïåðåêîäèðîâàòü.
//! Ïåðåèìåíîâàíèå ñî ñìåíîé ðàñøèðåíèÿ íå ïîìîæåò, êàê è â ñëó÷àå ñ ôîðìàòîì êàðòèíîê â txLoadImage().
//!
//! @usage @code
//! txPlaySound ("tada.wav"); // So happy that this always exists
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
bool txPlaySound (const char filename[] = NULL, DWORD mode = SND_ASYNC);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief Âûâîäèò ñîîáùåíèå â îêíå ñ ïîìîùüþ ôóíêöèè MessageBox.
//!
//! @param text Òåêñò ñîîáùåíèÿ
//! @param header Çàãîëîâîê ñîîáùåíèÿ
//! @param flags Ôëàãè îòîáðàæåíèÿ ñîîáùåíèÿ
//!
//! @return Çíà÷åíèå, âîçâðàùàåìîå ôóíêöèåé MessageBox.
//!
//! @warning Òåêñò íå äîëæåí ïðåâûøàòü _TX_BIGBUFSIZE ñèìâîëîâ, à çàãîëîâîê @d _TX_BIGBUFSIZE ñèìâîëîâ, èíà÷å îíè
//! îáðåçàþòñÿ.
//!
//! @note Âìåñòî <tt><b>txMessageBox (text, header, flags)</b></tt> ìîæíî èñïîëüçîâàòü ñòàíäàðòíóþ ôóíêöèþ Win32
//! <tt><b>MessageBox (txWindow(), text, header, flags)</b></tt>. Îòëè÷èÿ txMessageBox â òîì, ÷òî îíà
//! àâòîìàòè÷åñêè ïîäñòàâëÿåò îêíî-ðîäèòåëü, è â òîì, ÷òî ïðè âûâîäå â îêíî ñòðî÷êè ïåðåâîäÿòñÿ â ôîðìàò
//! UNICODE. Ýòî âàæíî ëèøü â òîì ñëó÷àå, êîãäà <i>â ðåãèîíàëüíûõ íàñòðîéêàõ êîíòðîëüíîé ïàíåëè Windows
//! íåâåðíî óñòàíîâëåíà êîäîâàÿ ñòðàíèöà äëÿ ïðîãðàìì, íå ïîääåðæèâàþùèõ UNICODE.</i>  îñòàëüíûõ ñëó÷àÿõ
//! íóæäû â @c txMessageBox íåò.
//!
//! @see TX_ERROR(), TX_DEBUG_ERROR(), txOutputDebugPrintf(), txNotifyIcon()
//!
//! @usage @code
//! if (txMessageBox ("Ïîëó÷èëîñü?", "Ïðî÷òè ìåíÿ", MB_YESNO) == IDYES)
//! {
//! MessageBox (txWindow(), "Õâàòèò è îáû÷íîãî MessageBox()", "Win32 ñîîáùàåò", 0);
//! }
//! else
//! txMessageBox ("Ñïàñàåì îò êðàêîçÿáë âìåñòî ðóññêèõ áóêâ. Ãàðàíòèÿ. Íåäîðîãî.");
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
unsigned txMessageBox (const char* text, const char* header = "TXLib ñîîáùàåò", unsigned flags = 0);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief Âûâîäèò âñïëûâàþùåå ñîîáùåíèå â ñèñòåìíîì òðåå.
//!
//! @param flags Ôëàãè ñîîáùåíèÿ
//! @param title Çàãîëîâîê ñîîáùåíèÿ
//! @param format Ñòðîêà äëÿ ïå÷àòè, êàê â printf().
//!
//! @title Ôëàãè ñîîáùåíèÿ:
//! @table @tr @c NIIF_INFO @td Èíôîðìàöèÿ
//! @tr @c NIIF_WARNING @td Ïðåäóïðåæäåíèå
//! @tr @c NIIF_ERROR @td Ñîîáùåíèå îá îøèáêå
//! @endtable
//!
//! @return Óäàëîñü ëè îòîáðàçèòü ñîîáùåíèå.
//!
//! Ôóíêöèÿ ôîðìèðóåò ñîîáùåíèå ïî ïðàâèëàì printf() è âûâîäèò âî âñïëûâàþùåì îêíå.
//!
//! @warning
//! - Ýòà ôóíêöèÿ òðåáóåò, ÷òîáû ïðè êîìïèëÿöèè êîíñòàíòà âåðñèè Internet Explorer @c (_WIN32_IE) áûëà
//! çàäàíà íå íèæå 0x0500. Äëÿ ýòîãî íàäî ëèáî <b>âêëþ÷èòü TXLib.h âìåñòî @c windows.h èëè ïåðåä íèì.</b>
//! Ëèáî íàäî ñàìîñòîÿòåëüíî îïðåäåëèòü @c (\#define) ýòó êîíñòàíòó.
//! <small>Ñ âåðñèåé Internet Explorer ýòî ñâÿçàíî ïîòîìó, ÷òî ïðè åãî óñòàíîâêå â Windows îáíîâëÿþòñÿ
//! ìíîãèå êîìïîíåíòû (íàïðèìåð, @c shell32.dll è @c comctl32.dll), êîòîðûå âëèÿþò íà ôóíêöèîíàëüíîñòü
//! ñèñòåìû íåçàâèñèìî îò èñïîëüçîâàíèÿ áðàóçåðà). Ñàì Internet Explorer â îòîáðàæåíèè ñîîáùåíèÿ
//! íå ó÷àñòâóåò.</small>
//! - Ñîîáùåíèå íå äîëæíî ïðåâûøàòü _TX_BUFSIZE ñèìâîëîâ, èíà÷å îíî îáðåçàåòñÿ.
//!
//! @see TX_ERROR(), TX_DEBUG_ERROR(), txOutputDebugPrintf(), txMessageBox()
//!
//! @usage @code
//! int hours = 3, minutes = 10;
//! const char station[] = "Þìó";
//! ...
//! txNotifyIcon (NIIF_INFO, "Óâàæàåìûå ïàññàæèðû",
//! "Ïîåçä íà %s îòïðàâëÿåòñÿ â %d:%d.", station, hours, minutes);
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
bool txNotifyIcon (unsigned flags, const char title[], const char format[], ...) _TX_CHECK_FORMAT (3);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief Âûâîäèò ñîîáùåíèå â îòëàä÷èêå.
//!
//! @param format Ñòðîêà äëÿ ïå÷àòè, êàê â printf().
//!
//! @return Êîëè÷åñòâî íàïå÷àòàííûõ ñèìâîëîâ.
//!
//! Ôóíêöèÿ ôîðìèðóåò ñîîáùåíèå ïî ïðàâèëàì printf() è ïåðåäàåò åãî â OutputDebugString(). Åå âûâîä ìîæíî
//! ïåðåõâàòèòü îòëàä÷èêîì èëè óòèëèòàìè-ëîããåðàìè, íàïðèìåð,
//! <a href=http://technet.microsoft.com/ru-ru/sysinternals/bb896647%28en-us%29.aspx>DbgView</a>.
//! Åñëè ýòîãî íå ñäåëàòü, è íå çàäàòü ïåðâûé ñèìâîë @c '\\a' (ñì. íèæå), òî î ñîîáùåíèè íèêòî íå óçíàåò. :(
//! @note
//! - Åñëè ïåðâûé ñèìâîë â ñòðîêå @c '\\a', òî ñîîáùåíèå òàêæå äóáëèðóåòñÿ txMessageBox().
//! - Åñëè ïåðâûé èëè âòîðîé ñèìâîë â ñòðîêå @c '\\f', òî ñîîáùåíèå òàêæå äóáëèðóåòñÿ printf().
//!
//! @warning Ñîîáùåíèå íå äîëæíî ïðåâûøàòü _TX_BIGBUFSIZE ñèìâîëîâ, èíà÷å îíî îáðåçàåòñÿ.
//!
//! @see TX_ERROR(), TX_DEBUG_ERROR(), txNotifyIcon(), txMessageBox()
//!
//! @usage @code
//! int x = 42;
//! ...
//! txOutputDebugPrintf ("Íèêòî íå óçíàåò, ÷òî %d.", x);
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
int txOutputDebugPrintf (const char format[], ...) _TX_CHECK_FORMAT (1);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief Âû÷èñëåíèå ðàçìåðà ìàññèâà â ýëåìåíòàõ
//!
//! @param arr Èìÿ ìàññèâà
//!
//! @return Ðàçìåð ìàññèâà â ýëåìåíòàõ (íå â áàéòàõ).
//!
//! Ìàêðîñ sizearr() âû÷èñëÿåò ðàçìåð ìàññèâà â ýëåìåíòàõ, ïðîâåðÿÿ, ìîæíî ëè åãî ïðàâèëüíî âû÷èñëèòü ïðè
//! êîìïèëÿöèè.
//!
//! Ìàêðîñ SIZEARR() ïðîñòî äåëèò ðàçìåð âñåãî ìàññèâà â áàéòàõ íà ðàçìåð åãî ýëåìåíòà, ïîëó÷àåòñÿ ðàçìåð
//! ìàññèâà â ýëåìåíòàõ.
//! Îí <b>íå ïðîâåðÿåò,</b> ìîæíî ëè åãî ïðàâèëüíî âû÷èñëèòü, è ïðè íåïðàâèëüíîì èñïîëüçîâàíèè ìîæåò
//! âûäàòü <b>íåâåðíûé ðàçìåð.</b>
//!
//! @warning SIZEARR() âûäàåò íåâåðíûé ðàçìåð, åñëè îïðåäåëåíèå ìàññèâà âìåñòå ñ åãî ðàçìåðîì, èçâåñòíûì ïðè
//! êîìïèëÿöèè, íåäîñòóïíî â ìåñòå èñïîëüçîâàíèÿ SIZEARR(). Ñì. ïðèìåð íèæå.
//!
//! @note  Microsoft Visual Studio 6 ìàêðîñ sizearr() íåäîñòóïåí - ó åå êîìïèëÿòîðà íåäîñòàòî÷íî ñèë, ÷òîáû
//! ñêîìïèëèðîâàòü åãî. :(
//!
//! @usage @code
//! void test()
//! {
//! // Ðàçìåð ýòîãî ìàññèâà, õîòü è íå óêàçàí, íî ìîæåò áûòü àâòîìàòè÷åñêè îïðåäåëåí
//! // êîìïèëÿòîðîì ïðè êîìïèëÿöèè ïðîãðàììû. Îí ðàâåí 4 (÷åòûðå ñòðóêòóðû POINT).
//!
//! POINT coord[] = { {110, 110}, {120, 120}, {130, 110}, {140, 120} };
//!
//! // Çäåñü ðàçìåð ìàññèâà èçâåñòåí ïðè êîìïèëÿöèè, ò.ê. îí áûë îïðåäåëåí òóò æå.
//!
//! for (int i = 0; i < sizearr (coord) - 1; i++)
//! txLine (coord[i].x, coord[i].y, coord[i+1].x, coord[i+1].y);
//!
//! DrawLines1 (coord); // Ïîïûòêà ïåðåäàòü ìàññèâ áåç ïåðåäà÷è ðàçìåðà.
//! DrawLines2 (coord, sizearr (coord)); // Ïðàâèëüíàÿ ïåðåäà÷à ðàçìåðà ìàññèâà.
//!
//! DrawLines3 (coord); // Â ïðèíöèïå, ìîæíî è òàê, íî òóò ÂÎÄßÒÑß ØÀÁËÎÍÛ.
//! }
//!
//! // Ôóíêöèè DrawLines1 è DrawLines2 îïðåäåëåíû òàê:
//!
//! void DrawLines1 (const POINT coord[])
//! {
//! // Ìàññèâû â Ñè ïåðåäàþòñÿ êàê óêàçàòåëè íà íà÷àëî ìàññèâà. Ïîýòîìó:
//! // 1) sizearr çäåñü âûäàñò îøèáêó êîìïèëÿöèè, è åå ëåãêî áóäåò íàéòè.
//! // 2) SIZEARR çäåñü íåâåðíî ïîñ÷èòàåò ðàçìåð, ÷òî íàìíîãî õóæå,
//! // ò.ê. îí áóäåò ðàâåí sizeof (POINT*) / sizeof (POINT) == 4/8 == 0.
//!
//! for (int i = 0; i < sizearr (coord) - 1; i++)
//! txLine (coord[i].x, coord[i].y, coord[i+1].x, coord[i+1].y);
//! }
//!
//! void DrawLines2 (const POINT coord[], int n)
//! {
//! // Çäåñü ðàçìåð ïðèõîäèò êàê ïàðàìåòð n, òàê ÷òî âñå ïðîñòî.
//!
//! for (int i = 0; i < n - 1; i++)
//! txLine (coord[i].x, coord[i].y, coord[i+1].x, coord[i+1].y);
//! }
//!
//! // HIC SVNT TEMPLATES
//!
//! template <int size>
//! void DrawLines3 (const POINT (&coord) [size])
//! {
//! for (int i = 0; i < size - 1; i++)
//! txLine (coord[i].x, coord[i].y, coord[i+1].x, coord[i+1].y);
//! }
//! @endcode
//!
//! @hideinitializer
//}----------------------------------------------------------------------------------------------------------------
//! @{
#ifndef _MSC_VER_6
#define sizearr( arr ) ( sizeof (get_size_of_an_array_with_unknown_or_nonconst_size_ (arr)) )
//! @cond INTERNAL
// See explanation here: http://blogs.msdn.com/b/the1/archive/2004/05/07/128242.aspx
template <typename T, int N> char (&get_size_of_an_array_with_unknown_or_nonconst_size_ (T (&) [N])) [N]; // ;)
//! @endcond
#endif
//! Çàìåíà ìàêðîñó sizearr() äëÿ ðàáîòû â Microsoft Visual Studio 6
#define SIZEARR( arr ) ( sizeof (arr) / sizeof (0[arr]) )
//! @}
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief Ïðîâåðêà, íàõîäèòñÿ ëè ïàðàìåòð õ âíóòðè çàìêíóòîãî èíòåðâàëà [a; b]
//!
//! @param x Ïðîâåðÿåìûé ïàðàìåòð
//! @param a Ëåâàÿ ãðàíèöà (âêëþ÷èòåëüíî)
//! @param b Ïðàâàÿ ãðàíèöà (âêëþ÷èòåëüíî)
//!
//! @return Åñëè a <= x && x <= b, òî èñòèíà, åñëè íåò - ëîæü
//!
//! @usage @code
//! while (txMouseButtons() != 1)
//! {
//! if (In (txMouseX(), 110, 120)) txTextOut (100, 100, "Meet the wall!");
//! txSleep (0);
//! }
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
template <typename T>
inline bool In (T x, T a, T b);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief Ïðîâåðêà, íàõîäèòñÿ ëè òî÷êà pt âíóòðè ïðÿìîóãîëüíèêà rect
//!
//! @param pt Ïðîâåðÿåìàÿ òî÷êà â âèäå <tt> POINT {x, y} </tt>
//! @param rect Ïðÿìîóãîëüíèê â âèäå <tt> RECT {left, top, right, bottom} </tt>
//!
//! @return Ðåçóëüòàò ïðîâåðêè
//!
//! Óäîáíî äëÿ ðåàëèçàöèè ýêðàííûõ êíîïîê, íàæèìàåìûõ êóðñîðîì ìûøè.
//!
//! @usage @code
//! RECT button = { 100, 100, 150, 120 };
//!
//! txSetFillColor (TX_LIGHTGRAY);
//! txRectangle (button.left, button.top, button.right, button.bottom);
//!
//! txSetTextAlign();
//! txSetFillColor (TX_WHITE);
//! txTextOut (125, 115, "Cookie");
//!
//! for (;;)
//! {
//! if (In (txMousePos(), button))
//! {
//! txSetFillColor (TX_TRANSPARENT);
//! txRectangle (button.left, button.top, button.right, button.bottom);
//!
//! if (txMouseButtons())
//! {
//! txSetFillColor (TX_DARKGRAY);
//! txRectangle (button.left, button.top, button.right, button.bottom);
//!
//! txSetFillColor (TX_WHITE);
//! txTextOut (125, 115, "You got cookie");
//!
//! break;
//! }
//! }
//!
//! txSleep (0);
//! }
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
//! @{
inline bool In (const POINT& pt, const RECT& rect);
inline bool In (const COORD& pt, const SMALL_RECT& rect);
//! @}
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief Ãåíåðàòîð ñëó÷àéíûõ ÷èñåë
//!
//! @param range Ïðàâàÿ ãðàíèöà äèàïàçîíà (@b íå âêëþ÷àÿ ñàìó ãðàíèöó).
//!
//! @return Ñëó÷àéíîå öåëîå ÷èñëî â äèàïàçîíå [0; range).
//!
//! Âû åùå ïîìíèòå, ÷òî îçíà÷àþò ðàçíûå ñêîáî÷êè â îáîçíà÷åíèè èíòåðâàëîâ? :)
//!
//! @usage @code
//! char message[100] = "Maybe...";
//! sprintf ("You SUDDENLY got %d bucks now. But note that tax rate is $%d.", random (100), 100);
//! txMessageBox (message, "Lottery");
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
inline int random (int range);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief Ãåíåðàòîð ñëó÷àéíûõ ÷èñåë
//!
//! @param left Ëåâàÿ ãðàíèöà äèàïàçîíà (@b âêëþ÷àÿ ñàìó ãðàíèöó).
//! @param right Ïðàâàÿ ãðàíèöà äèàïàçîíà (@b âêëþ÷àÿ ñàìó ãðàíèöó).
//!
//! @return Ñëó÷àéíîå öåëîå ÷èñëî â äèàïàçîíå [left; right].
//!
//! Âû âñå åùå ïîìíèòå, ÷òî îçíà÷àþò ðàçíûå ñêîáî÷êè â îáîçíà÷åíèè èíòåðâàëîâ? :)
//!
//! @usage @code
//! int money = random (-100, +100);
//! if (money < 0)
//! {
//! char message[100] = "Maybe...";
//! sprintf ("Ïðîèãðàëè â ëîòåðåþ? Îòäàéòå äîëã â %d ðóáëåé", -money);
//! txMessageBox (message, "Áûñòðî!");
//! }
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
inline double random (double left, double right);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief Âîçâðàùàåò ìàêñèìàëüíîå èç äâóõ ÷èñåë
//!
//! @param a Îäíî èç ÷èñåë :)
//! @param b Äðóãîå èç ÷èñåë :)
//!
//! @return Ìàêñèìàëüíîå èç äâóõ ÷èñåë a è b
//!
//! @see MIN()
//!
//! @usage @code
//! if (MAX (3, 7) != 7) printf ("Your CPU is broken, throw it away.");
//! @endcode
//!
//! @hideinitializer
//}----------------------------------------------------------------------------------------------------------------
#define MAX( a, b ) ( (a) > (b) ? (a) : (b) )
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief Âîçâðàùàåò ìèíèìàëüíîå èç äâóõ ÷èñåë
//!
//! @param a Îäíî èç ÷èñåë :)
//! @param b Äðóãîå èç ÷èñåë :)
//!
//! @return Ìèíèìàëüíîå èç äâóõ ÷èñåë a è b
//!
//! @see MAX()
//!
//! @usage @code
//! if (MIN (3, 7) != 3) printf ("Your CPU is still broken, throw it away twice.");
//! @endcode
//!
//! @hideinitializer
//}----------------------------------------------------------------------------------------------------------------
#define MIN( a, b ) ( (a) < (b) ? (a) : (b) )
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief Îêðóãëÿåò ÷èñëî äî öåëîãî
//!
//! @param x ×èñëî
//!
//! @return Îêðóãëåííîå ÷èñëî, ïðåîáðàçîâàííîå â òèï @c int
//!
//! @usage @code
//! double weight = 5.5; // 5.5 kilos is the weight of Maru in 2012.
//! int Maru = ROUND (weight); // Should use ROUND() because Maru is so round.
//! @endcode
//!
//! @hideinitializer
//}----------------------------------------------------------------------------------------------------------------
#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L // C99 case
#define ROUND( x ) ( (int) round (x) )
#else
#define ROUND( x ) ( (int) floor ((x) + 0.5) )
#endif
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief ×èñëî Ïè
//!
//! @usage @code
//! if (txPI == 1) txMessageBox ("Âû ïîïàëè â äðóãóþ Âñåëåííóþ.", "Ïîçäðàâëÿåì", MB_ICONSTOP);
//! @endcode
//!
//! @hideinitializer
//}----------------------------------------------------------------------------------------------------------------
const double txPI = asin (1.0) * 2;
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief <i>Î÷åíü óäîáíîå</i> âîçâåäåíèå ÷èñëà â êâàäðàò.
//!
//! @param x ×èñëî äëÿ âîçâåäåíèÿ â íåãî
//!
//! @return Êâàäðàò, ïîëó÷åííûé ïóòåì âîçâåäåíèÿ â íåãî ÷èñëà, çàäàííîãî äëÿ âîçâåäåíèÿ â êâàäðàò
//!
//! @note Ýòî ïðèìåð, êàê <b> íå íàäî </b> ïèñàòü êîä: txSqr() @d ôóíêöèÿ ñ "ìåäâåæüåé óñëóãîé". Èíîãäà âñòðå÷àþòñÿ
//! òå, êòî ëþáèò ïå÷àòàòü â ôóíêöèè ðåçóëüòàò åå âû÷èñëåíèé <small> (íå äàííûå äëÿ îòëàäêè, à èìåííî ðåçóëüòàò),
//! </small> âìåñòî òîãî, ÷òîáû ïðîñòî âîçâðàùàòü åãî òóäà, ãäå ýòó ôóíêöèþ âûçûâàëè. Ïóñòü ýòè ëþäè âîñïîëüçóþòñÿ
//! ïðèâåäåííîé txSqr() äëÿ êàêîãî-íèáóäü íóæíîãî äåëà, îñîáåííî â öèêëå. Ïðèìåð, êîíå÷íî, íåñêîëüêî ïðåóâåëè÷åí.
//! Ñì. â èñõîäíîì òåêñòå êîä ýòîé íàâÿç÷èâîé ðàäîñòè.
//!
//! @usage @code
//! printf ("\n" "Ðàäèóñ\t\t" "Ïëîùàäü êðóãà\n\n");
//!
//! for (double r = 100; r > 0; r--)
//! {
//! printf ("%6.2lf...", r);
//!
//! double square = M_PI * txSqr (r); // Íàäîëãî çàïîìíèì ýòó ïëîùàäü!
//! printf ("\b\b\b \t");
//!
//! printf ("%-.2lf\n", square);
//! }
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
inline
double txSqr (double x)
{
double sqr = pow (sqrt (x) * sqrt (x), sqrt (4.0)); // Áóðíàÿ âû÷èñëèòåëüíàÿ äåÿòåëüíîñòü
char str[1024] = "";
_snprintf_s (str, sizeof (str), "Âîçâåäåíèå äàëî %g!" "!!" "!!" " Âû ðàäû???? ", sqr);
txMessageBox (str, "Ïîëó÷åí ÎÒÂÅÒ!" "!!", MB_ICONEXCLAMATION | MB_YESNO) != IDNO ||
(
txMessageBox ("Æàëü...", "À ÿ òàê ñòàðàëàñü", MB_ICONINFORMATION),
txMessageBox ("Óéäó ÿ îò âàñ ", "Çëûå âû...", MB_ICONSTOP),
exit (EXIT_FAILURE), 0
);
txNotifyIcon (1, NULL, "\n%s\n", "Âûñøàÿ ìàòåìàòèêà! \0" // À êàê ýòî ðàáîòàåò, à?
"Ñ óìà ñîéòè... \0" //
"à ÊÝÏ ïîäòâåðæäàåò \0" // è êòî ýòî áóäåò
"Ãëàâíîå - îò÷èòàòüñÿ\0" // ïîääåðæèâàòü?..
"Íåâåðîÿòíî, íî ôàêò \0"
"Êòî áû ìîã ïîäóìàòü?\0" + GetTickCount() % 6 * 21);
return sqr; // Âñå æå âåðíåì çíà÷åíèå. Ìû æå íå çâåðè
}
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief Îáíóëèòåëü òèïîâ, íå èìåþùèõ êîíñòðóêòîðîâ
//!
//! @param type Èìÿ òèïà
//!
//! @return Çíà÷åíèå òèïà @p type, ïîêîìïîíåíòíî èíèöèàëèçèðîâàííîå ïî óìîë÷àíèþ (äëÿ âñòðîåííûõ òèïîâ - íóëåì).
//!
//! @usage @code
//! void f (POINT p);
//! ...
//!
//! POINT z = {}; f (z); // Òàê áåç ZERO
//!
//! f (ZERO (POINT)); // Òàê ñ ZERO
//! @endcode
//!
//! @hideinitializer
//}----------------------------------------------------------------------------------------------------------------
#define ZERO( type ) zero <type> ()
//! @cond INTERNAL
template <typename T> inline T zero();
//! @endcond
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief Àâòîìàòè÷åñêèé âûçîâ ôóíêöèè ïðè çàâåðøåíèè äðóãîé ôóíêöèè (àíàëîã @c __finally)
//!
//! @param param_t Òèï ïàðàìåòðà àâòîìàòè÷åñêè âûçûâàåìîé ôóíêöèè
//! @param param Èìÿ ïàðàìåòðà àâòîìàòè÷åñêè âûçûâàåìîé ôóíêöèè
//! @param func Òåëî àâòîìàòè÷åñêè âûçûâàåìîé ôóíêöèè (ôèãóðíûå ñêîáêè íå îáÿçàòåëüíû)
//!
//! @par Ìàêðîñ <tt>TX_AUTO_FUNC (param_t, param, func)</tt>
//! @note
//! - Äëÿ àâòîìàòè÷åñêè âûçûâàåìîé ôóíêöèè äîïóñêàåòñÿ òîëüêî @a îäèí ïàðàìåòð.
//! - Åãî òèï @c param_t è èìÿ @c param äîëæíû ñîîòâåòñòâîâàòü îïðåäåëåíèþ ïåðåìåííîé, äîñòóïíîé â òåêóùåé
//! îáëàñòè âèäèìîñòè.
//! Ïàðàìåòð âûçûâàåìîé ôóíêöèè áóäåò ñâÿçàí ñ ýòîé ïåðåìåííîé ÷åðåç ññûëêó.
//! - Ñèíîíèì: TX_FINALLY
//!
//! @warning  Microsoft Visual Studio 6 è 2003 â îòëàäî÷íîé êîíôèãóðàöèè (Debug) ýòîò ìàêðîñ ðàáîòàòü íå áóäåò,
//! ñì. <a href="http://support.microsoft.com/kb/199057">MS KB Article 199057</a>. Ìîæíî îáõîäèòüñÿ
//! ìàêðîñîì @c _TX_AUTO_FUNC, ñì. åãî îïðåäåëåíèå â èñõîäíîì òåêñòå ðÿäîì ñ îïðåäåëåíèåì @c TX_AUTO_FUNC.
//!
//! @par Ìàêðîñ <tt>tx_auto_func (func)</tt>
//! @note
//! - @a Âñå ïåðåìåííûå âûçûâàåìîé ôóíêöèè ñâÿçûâàþòñÿ ñ ïåðåìåííûìè âíåøíåé ôóíêöèè ïî ññûëêå.
//! - Èõ íàçâàíèÿ è òèïû @a íå óêàçûâàþòñÿ. Óêàçûâàåòñÿ òîëüêî òåëî âûçûâàåìîé ôóíêöèè.
//! - Ýòà ôîðìà èñïîëüçóåò ëÿìáäà-ôóíêöèè @c C++0x, ïîýòîìó ïðè êîìïèëÿöèè òðåáóåòñÿ <i>MSVS 2010</i>
//! èëè <i>GCC íå íèæå âåðñèè 4.5 ñ êëþ÷îì êîìïèëÿöèè @c -std=c++0x èëè @c -std=c++11.</i>
//! - Ñèíîíèì: tx_finally
//!
//! @see txAutoLock
//!
//! @usage @code
//! void f1()
//! {
//! int x = 1;
//! TX_AUTO_FUNC (int, x, $(x)); // Will be printed at return
//!
//! FILE* f = fopen (__FILE__".o.txt", "w"); // Will be closed at return
//! TX_AUTO_FUNC (FILE*, f, fclose (f));
//!
//! fprintf (f, "start: x = %d\n", x); // Do some job
//! x = 2; // Do some job
//! }
//!
//! void f2() // Do the same. For C++0x only
//! {
//! int x = 1;
//! tx_auto_func ($(x)); // More simple usage
//!
//! FILE* f = fopen (__FILE__".o.txt", "w");
//! tx_auto_func (fclose (f)); // More simple usage
//!
//! fprintf (f, "start: x = %d\n", x);
//! x = 2;
//! }
//! @endcode
//!
//! @hideinitializer
//}----------------------------------------------------------------------------------------------------------------
//! @{
//{ C++03 version
#define TX_AUTO_FUNC( param_t, param, func ) \
_TX_AUTO_FUNC( __LINE__, param_t, param, func )
#define _TX_AUTO_FUNC( n, param_t, param, func ) \
_TX_AUTO_FUN2( n, param_t, param, func )
#define _TX_AUTO_FUN2( n, param_t, param, func ) \
struct _TX_AUTO_FUNC_##n \
{ \
typedef _TX_AUTO_FUNC_##n this_t; \
param_t& param; \
\
_TX_AUTO_FUNC_##n (param_t& __p) : param (__p) { } \
~_TX_AUTO_FUNC_##n () { func; } \
\
private: this_t& operator= (const this_t&) { return *this; } \
} \
_TX_AUTO_FUNC_##n (param)
//}
//{ C++0x version, use MSVS 2010 or GCC v.4.5+ and -std=c++0x in command line
#define tx_auto_func( func ) _tx_auto_fun1 ( __LINE__, func )
#define _tx_auto_fun1( n, func ) _tx_auto_fun2 ( n, func )
#define _tx_auto_fun2( n, func ) auto _tx_auto_func_##n = _tx_auto_func ([&]() { func; })
template <typename T>
struct _tx_auto_func_
{
typedef _tx_auto_func_ this_t;
T func_;
_tx_auto_func_ (T func) : func_ (func) {}
~_tx_auto_func_ () { func_(); }
private: this_t& operator= (const this_t&) { return *this; }
};
template <typename T>
_tx_auto_func_<T> _tx_auto_func (T func)
{
return _tx_auto_func_ <T> (func);
}
//}
//{ Compatibility
#define TX_FINALLY( param_t, param, func ) TX_AUTO_FUNC (param_t, param, func)
#define tx_finally( func ) tx_auto_func (func)
//}
//! @}
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief Çàìåíà ñòàíäàðòíîãî ìàêðîñà assert(), ñ âûäà÷åé ñîîáùåíèÿ ÷åðåç txMessageBox(), êîíñîëü è
//! OutputDebugString().
//!
//! @param cond Óñëîâèå äëÿ ïðîâåðêè
//!
//! @return Íå îïðåäåëåíî
//!
//! Åñëè óñëîâèå, ïðîâåðÿåìîå assert(), èñòèííî, òî ìàêðîñ íè÷åãî íå äåëàåò. @n
//! Åñëè óñëîâèå îêàçûâàåòñÿ ëîæíî, òî âûâîäèòñÿ äèàãíîñòè÷åñêîå ñîîáùåíèå è ïðîãðàììà àâàðèéíî
//! çàâåðøàåòñÿ.
//!
//! @warning <b>Ïðè êîìïèëÿöèè â ðåæèìå Release (èëè åñëè îïðåäåëåí NDEBUG) assert ïðåâðàùàåòñÿ â ïóñòîé îïåðàòîð.</b> @n
//! Íå íàäî ïîìåùàòü â assert() äåéñòâèÿ, êîòîðûå âàæíû äëÿ ðàáîòû àëãîðèìà!
//!
//! @note Åñëè óñëîâèå @c cond ìîæåò áûòü âû÷èñëåíî óæå âî âðåìÿ êîìïèëÿöèè êàê ëîæíîå, êîìïèëÿòîð ìîæåò
//! ïðåäóïðåäèòü îá ýòîì (êàê î äåëåíèè íà 0).
//! @note <small>See: <a href=http://lars-lab.jpl.nasa.gov/JPL_Coding_Standard_C.pdf> "JPL Institutional Coding
//! Standard for the C Programming Language", Jet Propulsion Laboratory, California Institute of
//! Technology, JPL DOCID D-60411, Ver. 1.0, March 3, 2009</a>, page 15.</small>
//!
//! @see asserted, verified, verify(), TX_ERROR(), TX_DEBUG_ERROR(), txOutputDebugPrintf(), txMessageBox(),
//! txNotifyIcon(), __TX_FILELINE__, __TX_FUNCTION__
//!
//! @usage @code
//! assert (0 <= i && i < ARRAY_SIZE);
//!
//! FILE* input = fopen ("a.txt", "r");
//! assert (input);
//!
//! // Ýòîò âûçîâ fgets() ÍÅ áóäåò âûïîëíåí â ðåæèìå Release:
//! assert (fgets (str, sizeof (str) - 1, input));
//!
//! // Çäåñü âñå áóäåò ïðàâèëüíî:
//! bool ok = (fclose (input) == 0);
//! assert (ok);
//! @endcode
//!
//! @hideinitializer
//}----------------------------------------------------------------------------------------------------------------
#if !defined (NDEBUG)
#undef assert
#define assert( cond ) _txNOP ( !(cond)? (TX_ERROR ("\a" "ÂÍÅÇÀÏÍÎ: Ëîãè÷åñêàÿ îøèáêà: " \
"Íåâåðíî, ÷òî \"%s\"." TX_COMMA #cond), \
0/(int)!!(cond)) : 1 )
#else
#undef assert
#define assert( cond ) ((void) 1)
#endif
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief Âûâîäèò äèàãíîñòè÷åñêîå ñîîáùåíèå â ñëó÷àå íóëåâîãî èëè ëîæíîãî ðåçóëüòàòà.
//!
//! @return Âñåãäà 0
//!
//! Ñóôôèêñíàÿ ôîðìà ìàêðîñà assert(), íå òåðÿþùàÿ â ðåæèìå Release èñïîëíåíèÿ ïðåäèêàòà.
//!
//! @note <b>Ïðåäïîëàãàåòñÿ, ÷òî îïåðàöèÿ â ñëó÷àå íåóñïåõà âîçâðàùàåò 0 èëè false.</b> @n@n
//! <b>Ïðè êîìïèëÿöèè â ðåæèìå Release (èëè åñëè îïðåäåëåí NDEBUG) asserted ïðåâðàùàåòñÿ â ïóñòîå ìåñòî.</b>
//!
//! @see assert(), verify(), verified, TX_ERROR(), TX_DEBUG_ERROR(), txOutputDebugPrintf(), txMessageBox(),
//! txNotifyIcon(), __TX_FILELINE__, __TX_FUNCTION__
//!
//! @usage @code
//! FILE* input = fopen ("a.txt", "r"); assert (input);
//!
//! // Ýòîò âûçîâ fgets() áóäåò âûïîëíåí â ëþáîì ñëó÷àå:
//! fgets (str, sizeof (str) - 1, input) asserted;
//!
//! // Ýòîò âûçîâ fgets() ÍÅ áóäåò âûïîëíåí â ðåæèìå Release:
//! assert (fgets (str, sizeof (str) - 1, input));
//!
//! (fclose (input) != 0) asserted;
//! @endcode
//!
//! @hideinitializer
//}----------------------------------------------------------------------------------------------------------------
#if !defined (NDEBUG)
#define asserted || TX_ERROR ("\a" "Îáíàðóæåí íóëåâîé èëè ëîæíûé ðåçóëüòàò.")
#else
#define asserted || _txNOP (0)
#endif
#define verified asserted //!< For compatibility with assert macro
//! @cond INTERNAL
#define TX_NEEDED asserted //!< For compatibility with earlier releases
//! @endcond
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief Âûïîëíÿåò êîìàíäó (âû÷èñëÿåò âûðàæåíèå) è ïðîâåðÿåò ðåçóëüòàò.
//!
//! @param expr Êîìàíäà (âûðàæåíèå)
//!
//! @return 1, åñëè âûðàæåíèå @p expr èñòèííî, èíà÷å 0.
//!
//! Åñëè óñëîâèå, ïðîâåðÿåìîå verify(), èñòèííî, òî ìàêðîñ íè÷åãî íå äåëàåò. @n
//! Åñëè óñëîâèå îêàçûâàåòñÿ ëîæíî, òî âûâîäèòñÿ äèàãíîñòè÷åñêîå ñîîáùåíèå è ïðîãðàììà àâàðèéíî
//! çàâåðøàåòñÿ.
//!
//! @note Äåéñòâèå ìàêðîñà àíàëîãè÷íî assert(), íî ïðè êîìïèëÿöèè â ðåæèìå Release (èëè åñëè îïðåäåëåí NDEBUG)
//! verify @b íå ïðåâðàùàåòñÿ â ïóñòîé îïåðàòîð.
//!
//! @see verified, assert(), asserted, TX_ERROR(), TX_DEBUG_ERROR(), txOutputDebugPrintf(), txMessageBox(),
//! txNotifyIcon(), __TX_FILELINE__, __TX_FUNCTION__
//!
//! @usage @code
//! FILE* input = verify (fopen ("a.txt", "r"));
//!
//! // Ýòîò âûçîâ fgets() ÁÓÄÅÒ âûïîëíåí â ðåæèìå Release:
//! verify (fgets (str, sizeof (str) - 1, input));
//!
//! // Çäåñü âñå òîæå áóäåò ïðàâèëüíî:
//! verify (fclose (input) == 0);
//! @endcode
//!
//! @hideinitializer
//}----------------------------------------------------------------------------------------------------------------
#if !defined (NDEBUG)
#undef verify
#define verify assert
#else
#undef verify
#define verify( expr ) ( expr )
#endif
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief Âûâîäèò ðàçâåðíóòîå äèàãíîñòè÷åñêîå ñîîáùåíèå.
//!
//! @param msg Ñîîáùåíèå ñ ïðîèçâîëüíûì êîëè÷åñòâîì ïàðàìåòðîâ â ñòèëå ôóíêöèè @c printf().
//!
//! @note @c GCC â ðåæèìå ñòðîãîãî ñîîòâåòñòâèÿ ñòàíäàðòó ANSI (ñ êëþ÷îì êîìàíäíîé ñòðîêè <tt>-ansi</tt>) è
//! Microsoft Visual Studio âåðñèé 6 è 2003 íå ïîääåðæèâàþò ìàêðîñû ñ ïåðåìåííûì ÷èñëîì ïàðàìåòðîâ.
//! Ïîýòîìó, åñëè ïàðàìåòðîâ íåñêîëüêî, îíè ðàçäåëÿþòñÿ @b _ (@ref _ "ñèìâîëîì ïîä÷åðêèâàíèÿ",
//! ïåðåîïðåäåëåííûì â çàïÿòóþ) èëè ñèìâîëîì TX_COMMA, âìåñòî íàñòîÿùåé çàïÿòîé, òàê êàê TX_ERROR @d ìàêðîñ. @n
//! Åñëè â ïðîåêòå èñïîëüçóþòñÿ áèáëèîòåêè <a href=http://boost.org><tt>boost</tt></a>, òî èõ íàäî âêëþ÷àòü
//! @b äî @c TXLib.h è âìåñòî ñèìâîëà ïîä÷åðêèâàíèÿ ïîëüçîâàòüñÿ TX_COMMA, òàê êàê @c boost èñïîëüçóåò
//! ñèìâîë ïîä÷åðêèâàíèÿ êàê ñâîé ñîáñòâåííûé ñëóæåáíûé ìàêðîñ â ìîäóëå @c boost::preprocessor, @strike
//! ãäå òâîðèòñÿ äåôàéíîâûé àäÚ. @endstrike
//!
//! @return Âñåãäà false
//!
//! @see _, TX_COMMA, assert(), asserted, verify(), verified, TX_DEBUG_ERROR(), txOutputDebugPrintf(),
//! txMessageBox(), txNotifyIcon(), __TX_FILELINE__, __TX_FUNCTION__
//!
//! @usage @code
//! TX_ERROR ("Íå ñìîã ïðî÷èòàòü 'Âîéíó è ìèð'. Îòìàçêà %d: íå íàøåë '%s'", reasonNum, fileName);
//! @endcode
//!
//! @hideinitializer
//}----------------------------------------------------------------------------------------------------------------
// Variadic macros not supported in Strict ANSI mode and in MSVC prior to MSVC 8 (2005)
#if defined (__STRICT_ANSI__) || defined (_MSC_VER) && (_MSC_VER < 1400)
#define TX_ERROR( msg ) _txError (__FILE__, __LINE__, __TX_FUNCTION__, msg)
#else
#define TX_ERROR( ... ) _txError (__FILE__, __LINE__, __TX_FUNCTION__, __VA_ARGS__)
#endif
//! @cond INTERNAL
#define TX_THROW TX_ERROR //!< For compatibility with earlier releases
//! @endcond
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief Âûâîäèò ðàçâåðíóòîå äèàãíîñòè÷åñêîå ñîîáùåíèå â îòëàäî÷íîì ðåæèìå.
//!
//! Îïèñàíèå ñì. â TX_ERROR.
//!
//! @note  ðåæèìå Release ýòîò ìàêðîñ íå âûâîäèò íè÷åãî.
//!
//! @see _, TX_COMMA, assert(), asserted, verify(), verified, TX_ERROR(), txOutputDebugPrintf(),
//! txMessageBox(), txNotifyIcon(), __TX_FILELINE__, __TX_FUNCTION__
//!
//! @usage @code
//! TX_DEBUG_ERROR ("Òàê è íå ñìîã ïðî÷èòàòü 'Âîéíó è ìèð'. Îòìàçêà %d: ïîòåðÿë '%s'", reasonNum, fileName);
//! @endcode
//!
//! @hideinitializer
//}----------------------------------------------------------------------------------------------------------------
#if !defined (NDEBUG)
#define TX_DEBUG_ERROR TX_ERROR
#else
#define TX_DEBUG_ERROR(m) ((void) 0)
#endif
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief Ðàñïå÷àòûâàåò äàìï îáëàñòè ïàìÿòè â êîíñîëè.
//!
//! @param address Àäðåñ íà÷àëà ðàñïå÷àòêè.
//! @param name Íàçâàíèå ðàñïå÷àòêè (óñåêàåòñÿ äî 8 ñèìâîëîâ).
//!
//! @note Ðàñïå÷àòûâàåòñÿ îáëàñòü ïàìÿòè ðàçìåðîì 256 áàéò. @nn
//! Ïîñëå ðàñïå÷àòêè àòðèáóòû êîíñîëè ñáðàñûâàþòñÿ â 0x07 (ñâåòëî-ñåðûé íà ÷åðíîì).
//!
//! @see TX_ERROR(), TX_DEBUG_ERROR()
//!
//! @usage @code
//! const char text[] = "Êàæäîìó ëåêòîðó - â ïîðòôåëü ïî âåêòîðó";
//! txDump (text);
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
void txDump (const void* address, const char name[] = "txDump()");
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief Ìàêðîñ, ïîçâîëÿþùèé ïåðåäàòü ïåðåìåííîå ÷èñëî ïàðàìåòðîâ â êàêîé-ëèáî äðóãîé ìàêðîñ.
//!
//! @note <b>Ñèìâîë ïîä÷åðêèâàíèÿ è ñèìâîë TX_COMMA ïðîñòî ïåðåîïðåäåëÿþòñÿ â çàïÿòóþ.</b>
//!
//! @see TX_ERROR(), TX_DEBUG_ERROR()
//!
//! @usage @code
//! TX_ERROR ("Ñëèøêîì óìíûé àáçàö: ðîìàí 'Âîéíà è ìèð', ôàéë '%s', ñòðîêà %d" _ fileName _ lineNum);
//! @endcode
//!
//! @hideinitializer
//}----------------------------------------------------------------------------------------------------------------
//! @{
#define _ ,
#define TX_COMMA , //!< Ñèíîíèì ìàêðîñà _ (@ref _ "ñèìâîë ïîä÷åðêèâàíèÿ")
//! @}
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief Èìÿ è âåðñèÿ òåêóùåãî êîìïèëÿòîðà
//! @hideinitializer
//}----------------------------------------------------------------------------------------------------------------
#if defined (__GNUC__)
#define __TX_COMPILER__ "GNU g++ " TX_PREPROCESS (__GNUC__) "." \
TX_PREPROCESS (__GNUC_MINOR__) "." \
TX_PREPROCESS (__GNUC_PATCHLEVEL__) \
", std=" TX_PREPROCESS (__cplusplus)
#elif defined (_MSC_VER)
#define __TX_COMPILER__ "MSVS " TX_PREPROCESS (_MSC_VER) \
", std=" TX_PREPROCESS (__cplusplus)
#elif defined (__INTEL_COMPILER)
#define __TX_COMPILER__ "Intel C++ " TX_PREPROCESS (__INTEL_COMPILER) \
", std=" TX_PREPROCESS (__cplusplus)
#else
#define __TX_COMPILER__ "Unknown C++, std=" TX_PREPROCESS (__cplusplus)
#endif
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief Ìàêðîñ, ðàñêðûâàþùèéñÿ â èìÿ ôàéëà è íîìåð ñòðîêè ôàéëà, ãäå îí âñòðåòèëñÿ.
//! @hideinitializer
//}----------------------------------------------------------------------------------------------------------------
#define __TX_FILELINE__ __FILE__ " (" TX_PREPROCESS (__LINE__) ")"
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief Èìÿ òåêóùåé ôóíêöèè
//!
//! @warning Åñëè îïðåäåëåíèå èìåíè ôóíêöèè íå ïîääåðæèâàåòñÿ êîìïèëÿòîðîì, òî __TX_FUNCTION__ ðàñêðûâàåòñÿ â èìÿ
//! èñõîäíîãî ôàéëà è íîìåð ñòðîêè.
//!
//! @hideinitializer
//}----------------------------------------------------------------------------------------------------------------
#if defined (__GNUC__)
#define __TX_FUNCTION__ __PRETTY_FUNCTION__
#elif defined (__FUNCSIG__)
#define __TX_FUNCTION__ __FUNCSIG__
#elif defined (__FUNCTION__)
#define __TX_FUNCTION__ __FUNCTION__
#elif defined (__INTEL_COMPILER) && (__INTEL_COMPILER >= 600)
#define __TX_FUNCTION__ __FUNCTION__
#elif defined (__BORLANDC__) && (__BORLANDC__ >= 0x550)
#define __TX_FUNCTION__ __FUNC__
#elif defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901)
#define __TX_FUNCTION__ __func__
#elif defined (__PYTHON__)
#error No Python. No. Using parseltongue languages can lead you to Slytherin.
#else
#define __TX_FUNCTION__ "(" __TX_FILELINE__ ")"
#endif
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief Èìÿ ðåæèìà ñáîðêè
//! @hideinitializer
//}----------------------------------------------------------------------------------------------------------------
#if !defined (NDEBUG) && defined (_DEBUG)
#define _TX_BUILDMODE "DEBUG"
#elif !defined (NDEBUG) && !defined (_DEBUG)
#define _TX_BUILDMODE "Debug"
#elif defined (NDEBUG)
#define _TX_BUILDMODE "Release"
#endif
//! @{ @cond INTERNAL
#define TX_PREPROCESS( sym ) _TX_QUOTE (sym)
#define _TX_QUOTE( sym ) #sym
//! @endcond
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief Èìÿ ìîäóëÿ TXLib, âõîäèò â äèàãíîñòè÷åñêèå ñîîáùåíèÿ.
//!
//! @note Ìîæíî ïåðåîïðåäåëÿòü äî âêëþ÷åíèÿ ôàéëà TXLib.h.
//!
//! @hideinitializer
//}----------------------------------------------------------------------------------------------------------------
#if !defined (_TX_MODULE)
#define _TX_MODULE "TXLib"
#endif
//! @}
//}
//=================================================================================================================
//=================================================================================================================
//{ Back-hole (I hope, not an ass-hole:) of the library)
//! @name Î÷åíü ñëóæåáíûå ôóíêöèè
//=================================================================================================================
//! @{
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Service
//! @brief Óñòàíàâëèâàåò àëüòåðíàòèâíóþ ôóíêöèþ îáðàáîòêè îêîííûõ ñîîáùåíèé Windows (îêîííóþ ôóíêöèþ) äëÿ îêíà
//! TXLib.
//!
//! @param wndProc Íîâàÿ îêîííàÿ ôóíêöèÿ îêíà TXLib. @n
//! Åñëè NULL, òî òåêóùàÿ îêîííàÿ ôóíêöèÿ óäàëÿåòñÿ è óñòàíàâëèâàåòñÿ ñòàíäàðòíàÿ.
//!
//! @return Àäðåñ ïðåäûäóùåé îêîííîé ôóíêöèè äëÿ îêíà TXLib.
//!
//! Çàäàííàÿ îêîííàÿ ôóíêöèÿ áóäåò âûçûâàòüñÿ @b äî îáðàáîòêè ñîáûòèÿ ñðåäñòâàìè TXLib.
//! Îíà äîëæíà áûòü ôóíêöèåé ñî ñëåäóþùèì ïðîòîòèïîì:
//! @code
//! LRESULT CALLBACK NewWndProc (HWND window, UINT message, WPARAM wParam, LPARAM lParam);
//! @endcode
//!
//! @warning Îêîííàÿ ôóíêöèÿ áóäåò âûçûâàòüñÿ èç âñïîìîãàòåëüíîãî (âòîðîãî) ïîòîêà, ñîçäàâàåìîãî @ref
//! txCreateWindow(). Ýòî @b íå òîò æå ñàìûé ïîòîê, â êîòîðîì âûïîëíÿåòñÿ main(). Â ñâÿçè ñ ýòèì áóäüòå
//! âíèìàòåëüíû ïðè ðàáîòå ñ ãëîáàëüíûìè ïåðåìåííûìè èëè èõ àíàëîãàìè, ò.ê. ìîæåò âîçíèêíóòü "ãîíêà
//! ïîòîêîâ" (race condition).
//!
//! @warning Åñëè îêîííàÿ ôóíêöèÿ âåðíåò çíà÷åíèå, íå ðàâíîå 0, òî ñòàíäàðòíàÿ îáðàáîòêà ñîîáùåíèé ñðåäñòâàìè TXLib
//! @b íå áóäåò ïðîèçâåäåíà. Èç-çà ýòîãî, âîçìîæíî, îêíî äàæå íå ñìîæåò íîðìàëüíî çàêðûòüñÿ. Ïðèäåòñÿ
//! çàâåðøàòü ïðîãðàììó ñ ïîìîùüþ Alt-Ctrl-Del èç äèñïåò÷åðà çàäà÷, èëè èç áîëåå ïðîäâèíóòîãî äèñïåò÷åðà
//! <a href=http://technet.microsoft.com/en-us/sysinternals/bb896653.aspx> Process Explorer</a>. Åñëè Âû
//! áåðåòå íà ñåáÿ îáðàáîòêó îêîííûõ ñîîáùåíèé, äåëàéòå åå ïî ïðàâèëàì Win32 (ñì. MSDN), âêëþ÷àÿ âûçîâ
//! DefWindowProc().
//!
//! @note Ïîëíîñòüþ ïîìåíÿòü îêîííóþ ôóíêöèþ ìîæíî ñ ïîìîùüþ ôóíêöèé SetWindowLong èëè SetWindowLongPtr:
//! @code
//! WNDPROC OldWndProc = (WNDPROC) SetWindowLongPtr (txWindow(), GWL_WNDPROC, (LONG_PTR) NewWndProc);
//! @endcode
//! Ïðè ýòîì íàäî îáÿçàòåëüíî âñåãäà âûçûâàòü ñòàðóþ îêîííóþ ôóíêöèþ ñ ïîìîùüþ CallWindowProc, (ñì. MSDN),
//! èíà÷å ïîñëåäñòâèÿ áóäóò òàêèìè æå ïëà÷åâíûìè, êàê îïèñàíû âûøå.
//!
//! @see txCreateWindow(), txDialog, txInputBox()
//!
//! @usage @code
//! LRESULT CALLBACK MyWndProc (HWND window, UINT message, WPARAM wParam, LPARAM lParam);
//!
//! int main()
//! {
//! txCreateWindow (GetSystemMetrics (SM_CXSCREEN) / 4, GetSystemMetrics (SM_CYSCREEN) / 4);
//!
//! txSetWindowsHook (MyWndProc);
//!
//! txDrawText (0, 0, txGetExtentX(), txGetExtentY(), "MOV txWindow, eax [please]");
//!
//! return 0;
//! }
//!
//! LRESULT CALLBACK MyWndProc (HWND window, UINT message, WPARAM wParam, LPARAM lParam)
//! {
//! if (message == WM_MOVE) txMessageBox (" I like to MOVe it, MOVe it", "TXLib 2 Real", MB_ICONINFORMATION);
//!
//! static int i = 0;
//! if (i++ % 10 == 0) printf ("\b" "%c", "-\\|/" [i/10 % 4]); // Ïððîïïïåëëëëåðððð
//!
//! return 0; // Ïðîäîëæèòü îáðàáîòêó ñîîáùåíèÿ ñðåäñòâàìè TXLib
//! }
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
WNDPROC txSetWindowsHook (WNDPROC wndProc = NULL);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Service
//! @brief Áëîêèðîâêà õîëñòà (êîíòåêñòà ðèñîâàíèÿ).
//!
//! @param wait Îæèäàòü êîíöà ïåðåðèñîâêè îêíà âñïîìîãàòåëüíûì ïîòîêîì
//!
//! @return Ñîñòîÿíèå áëîêèðîâêè
//!
//! Ïåðåä âûçîâîì ëþáûõ ôóíêöèé Win32 GDI íåîáõîäèìî çàáëîêèðîâàòü õîëñò ôóíêöèåé txLock() è çàòåì
//! ðàçáëîêèðîâàòü ñ ïîìîùüþ txUnlock(). Ýòî ñâÿçàíî ñ òåì, ÷òî îáíîâëåíèå ñîäåðæèìîãî îêíà (äëÿ òåõ, êòî
//! çíàåò Win32: îáðàáîòêà ñîîáùåíèÿ WM_PAINT) â áèáëèîòåêå TXLib ïðîèñõîäèò â îòäåëüíîì âñïîìîãàòåëüíîì
//! ïîòîêå. Íàäîëãî áëîêèðîâàòü åãî íåëüçÿ - ïðè çàáëîêèðîâàííîì ïîòîêå îêíî íå îáíîâëÿåòñÿ.
//!
//! txLock() èñïîëüçóåò EnterCriticalSection(), è ôèçè÷åñêè ïðèîñòàíàâëèâàåò ïîòîê, îáíîâëÿþùèé îêíî, òàê
//! ÷òî íàäîëãî áëîêèðîâàòü íåëüçÿ. Èíà÷å òîðìîçèòñÿ îáðàáîòêà îêîííûõ ñîîáùåíèé, îêíî ïåðåñòàåò
//! ðåàãèðîâàòü íà äåéñòâèÿ ïîëüçîâàòåëÿ è ïåðåðèñîâûâàòüñÿ. Íåëüçÿ òàêæå âûçûâàòü txSleep() èëè Sleep()
//! ïðè çàáëîêèðîâàííîì ïîòîêå.
//!
//! txLock() / txUnlock() - ýòî íèçêîóðîâíåâûé ìåõàíèçì. Îí îòëè÷àåòñÿ îò áîëåå ïðîñòîãî âûñîêîóðîâíåâîãî
//! ìåõàíèçìà txBegin() / txEnd() / txUpdateWindow(), êîòîðûé íå ïðèîñòàíàâëèâàåò ïîòîê, à ïðîñòî
//! îòêëþ÷àåò ïðèíóäèòåëüíîå ïîñòîÿííîå îáíîâëåíèå îêíà.
//!
//! @see txDC(), txLock(), txUnlock(), txGDI()
//!
//! @usage Ñì. èñõîäíûé òåêñò ôóíêöèé _txCanvas_OnPAINT() è _txConsole_Draw() â TXLib.h.
//}----------------------------------------------------------------------------------------------------------------
bool txLock (bool wait = true);
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Service
//! @brief Ðàçáëîêèðîâêà õîëñòà
//!
//! @return Ñîñòîÿíèå áëîêèðîâêè (âñåãäà false).
//!
//! Áîëåå ïîäðîáíî ñì. â îïèñàíèè txLock().
//!
//! @see txDC(), txLock(), txGDI()
//!
//! @usage Ñì. èñõîäíûé òåêñò ôóíêöèé _txCanvas_OnPAINT() è _txConsole_Draw() â TXLib.h.
//}----------------------------------------------------------------------------------------------------------------
//! @{
bool txUnlock();
//! @cond INTERNAL
template <typename T> inline T txUnlock (T value);
//! @endcond
//! @}
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Service
//! @brief Âûçîâ ôóíêöèè Win32 GDI ñ àâòîìàòè÷åñêîé áëîêèðîâêîé è ðàçáëîêèðîâêîé.
//!
//! @param command Êîìàíäà GDI (âîçìîæíî, âîçâðàùàþùàÿ çíà÷åíèå)
//!
//! @return Çíà÷åíèå, âîçâðàùàåìîå âûçûâàåìîé ôóíêöèåé GDI. Åñëè ñèñòåìà ðèñîâàíèÿ íå ãîòîâà, âîçâðàùàåòñÿ
//! çíà÷åíèå false.
//!
//! @note Åñëè ñèñòåìà ðèñîâàíèÿ íå ãîòîâà (txDC() âîçâðàùàåò NULL), òî êîìàíäà GDI íå âûïîëíÿåòñÿ, à txGDI()
//! âîçâðàùàåò çíà÷åíèå false. @n
//!
//! @note Åñëè â âûçîâå ôóíêöèè GDI èñïîëüçóþòñÿ çàïÿòûå, òî èñïîëüçóéòå äâîéíûå ñêîáêè, ÷òîáû ïîëó÷èëñÿ îäèí
//! ïàðàìåòð, òàê êàê txGDI() âñå-òàêè ìàêðîñ.
//!
//! @see txDC(), txLock(), txUnlock()
//!
//! @usage @code
//! txGDI (( Rectangle (txDC(), x1, y1, x2, y2) )); // Íå çàáóäüòå ïðî äâå ((ÄÂÅ)) ñêîáêè
//! @endcode
//!
//! @hideinitializer
//}----------------------------------------------------------------------------------------------------------------
#define txGDI( command ) txUnlock ( (txLock(), (command)) )
//! @}
//}
//=================================================================================================================
//=================================================================================================================
//{ Tune-up constants and variables
//! @name Íàñòðîå÷íûå êîíñòàíòû è ïåðåìåííûå
//=================================================================================================================
//! @{
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Technical
//! @brief Çàïðåò ðàííåé èíèöèàëèçàöèè TXLib
//!
//! Åñëè êîíñòàíòà îïðåäåëåíà ñ ïîìîùüþ \#define @a äî âêëþ÷åíèÿ TXLib.h â ïðîãðàììó, ðàííÿÿ èíèöèàëèçàöèÿ
//! (äî çàïóñêà ôóíêöèè @c main) @b íå ïðîâîäèòñÿ.
//!
//! @note Ðàííÿÿ èíèöèàëèçàöèÿ âêëþ÷àåò:
//! - Îòêðûòèå îêíà êîíñîëè,
//! - Óñòàíîâêó êîäîâîé ñòðàíèöû _TX_CP (1251) êîíñîëè äëÿ ïîääåðæêè ðóññêîãî ÿçûêà,
//! - Óñòàíîâêó ðóññêîé ëîêàëè ñòàíäàðòíîé áèáëèîòåêè,
//! - Ïåðåèíèöèàëèçàöèÿ áèáëèîòåê stdio è iostream íà ñëó÷àé, åñëè ïðèëîæåíèå íå ñêîìïîíîâàíî êàê êîíñîëüíîå
//! è áèáëèîòåêè îñòàëèñü íåèíèöèàëèçèðîâàíû,
//! - Ïåðåõâàò ñèñòåìíûõ ñèãíàëîâ (äåëåíèå íà 0, îáðàùåíèå ïî íåâåðíîìó àäðåñó è ò.ä.),
//! - Ïåðåõâàò íåîáðàáîòàííûõ èñêëþ÷åíèé,
//! - Ñìåíà çàãîëîâêà êîíñîëüíîãî îêíà,
//! - Óñòàíîâêà ðåæèìà ïàóçû ïî çàâåðøåíèè ïðîãðàììû, ÷òîáû îêíî çàêðûâàëîñü íå ñðàçó,
//! - Ïîäàâëåíèå ïàóçû ïðè çàïóñêå èç ñðåä ïðîãðàììèðîâàíèÿ, çàñòàâëÿþùåé íàæèìàòü íà êëàâèøó äâà ðàçà. @nn
//!
//! @note Åñëè ðàííÿÿ èíèöèàëèçàöèÿ çàïðåùåíà, íî â EXE-ôàéëå ñîçäàåòñÿ îêíî TXLib ñ ïîìîùüþ txCreateWindow(),
//! òî áèáëèîòåêà âñå ðàâíî áóäåò èíèöèàëèçèðîâàíà. Â @b DLL ðàííÿÿ èíèöèàëèçàöèÿ íèêîãäà @b íå ïðîâîäèòñÿ. @nn
//!
//! @note Ðàííÿÿ èíèöèàëèçàöèÿ íå ïîòîêîáåçîïàñíà (not thread-safe).
//!
//! @see txCreateWindow(), _TX_ALLOW_KILL_PARENT, _TX_WAITABLE_PARENTS, _txConsoleMode
//!
//! @usage @code
//! #define _TX_NOINIT
//! #include "TXLib.h"
//! @endcode
//!
//! @hideinitializer
//}----------------------------------------------------------------------------------------------------------------
#if defined (_TX_NOINIT)
#undef _TX_NOINIT
#define _TX_NOINIT 1
#else
#define _TX_NOINIT 0
#endif
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Technical
//! @brief Ðåæèì îòîáðàæåíèÿ êîíñîëüíîãî îêíà. Äîïóñòèìû ëþáûå ôëàãè ôóíêöèè ShowWindow.
//!
//! Ïî óìîë÷àíèþ: @c SW_HIDE @d Ñêðûâàòü êîíñîëüíîå îêíî.
//!
//! @note Ïåðåìåííàÿ óñòàíàâëèâàåòñÿ @b äî îòêðûòèÿ îêíà áèáëèîòåêè.
//!
//! @see _TX_NOINIT
//!
//! @usage @code
//! _txConsoleMode = SW_HIDE; // Âñåãäà ñêðûâàòü êîíñîëüíîå îêíî
//! txCreateWindow (800, 600);
//!
//! _txConsoleMode = SW_SHOW; // Âñåãäà ïîêàçûâàòü êîíñîëüíîå îêíî
//! txCreateWindow (800, 600);
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
unsigned _txConsoleMode = SW_HIDE;
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Technical
//! @brief Ñòèëü ãðàôè÷åñêîãî îêíà áèáëèîòåêè.
//!
//! @note
//! - Ïåðåìåííàÿ óñòàíàâëèâàåòñÿ @b äî îòêðûòèÿ îêíà áèáëèîòåêè.
//!
//! @usage @code
//! _txWindowStyle &= ~WS_CAPTION; // FullScreen: îêíî áåç çàãîëîâêà, ðàçìåðîì ñ ýêðàí
//! txCreateWindow (GetSystemMetrics (SM_CXSCREEN), GetSystemMetrics (SM_CYSCREEN));
//!
//! printf ("Çàêðîéòå ìåíÿ ÷åðåç Alt+F4\n");
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
unsigned _txWindowStyle = WS_POPUP | WS_BORDER | WS_CAPTION | WS_SYSMENU;
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Technical
//! @brief Øðèôò êîíñîëè
//! @note Ïåðåìåííàÿ óñòàíàâëèâàåòñÿ @b äî îòêðûòèÿ îêíà áèáëèîòåêè.
//}----------------------------------------------------------------------------------------------------------------
const char* _txConsoleFont = "Lucida Console";
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Technical
//! @brief Èíòåðâàë ìèãàíèÿ êóðñîðà êîíñîëè (ìñ)
//}----------------------------------------------------------------------------------------------------------------
unsigned _txCursorBlinkInterval = 500;
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Technical
//! @brief Èíòåðâàë îáíîâëåíèÿ õîëñòà (ìñ)
//! @note Ïåðåìåííàÿ óñòàíàâëèâàåòñÿ @b äî îòêðûòèÿ îêíà áèáëèîòåêè.
//}----------------------------------------------------------------------------------------------------------------
int _txWindowUpdateInterval = 25;
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Technical
//! @brief Òàéìàóò îïåðàöèé îæèäàíèÿ (ìñ)
//}----------------------------------------------------------------------------------------------------------------
#if !defined (TX_TRACE)
const int _TX_TIMEOUT = 1000
#else
const int _TX_TIMEOUT = 5000
#endif
#if defined (_TX_USE_DEVPARTNER)
* 10
#endif
;
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Technical
//! @brief Ðàçìåðû âíóòðåííèõ ñòàòè÷åñêèõ ñòðîêîâûõ áóôåðîâ TXLib
//}----------------------------------------------------------------------------------------------------------------
const unsigned _TX_BUFSIZE = 1024;
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Technical
//! @brief Ðàçìåðû âíóòðåííèõ ñòàòè÷åñêèõ ñòðîêîâûõ áóôåðîâ TXLib
//}----------------------------------------------------------------------------------------------------------------
const unsigned _TX_BIGBUFSIZE = 2048;
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Technical
//! @brief Ñïèñîê çàïóñêàþùèõ ïðîãðàìì, êîòîðûå æäóò íàæàòèÿ êëàâèøè ïîñëå çàâåðøåíèÿ ïðîöåññà TXLib.
//!
//! Åñëè ïðîãðàììà ïåðå÷èñëåíà â ñïèñêå è TXLib çàïóùåíà èç íåå, òî ïðè çàâåðøåíèè TXLib óêàçàííàÿ
//! ïðîãðàììà áóäåò çàêðûòà. (Ýòî ïðîèçîéäåò, åñëè íå îòêðûòî ãðàôè÷åñêîå îêíî TXLib, à åñòü òîëüêî îêíî
//! êîíñîëè.)
//!
//! Ïðîãðàììû ðàçäåëÿþòñÿ ïðîáåëîì èëè çàïÿòîé. Äîïóñêàåòñÿ óêàçàíèå ðîäèòåëÿ çàïóñêàþùåé ïðîãðàììû, ïîñëå
//! äâîåòî÷èÿ.
//!
//! Ìîæåò çàäàâàòüñÿ ïåðåä âêëþ÷åíèåì TXLib.h â ïðîãðàììó.
//!
//! @see _TX_ALLOW_KILL_PARENT, _TX_NOINIT
//}----------------------------------------------------------------------------------------------------------------
// TX_VEGETABLE_PRINTERS
#if !defined (_TX_WAITABLE_PARENTS)
#define _TX_WAITABLE_PARENTS "cmd.exe:devenv.exe, " /* MSVS 2003-2010 */ \
"vcspawn.exe:msdev.exe, " /* MSVS 6 */ \
"cb_console_runner.exe:codeblocks.exe, " /* CodeBlocks 8-10 */ \
"cmd.exe:console_runner.exe, " /* CodeBlocks 1 */ \
"starter.exe:eclipse.exe, " /* Eclipse 4 */ \
"starter.exe:javaw.exe, " /* Eclipse 3 */ \
"consolepauser.exe:devcpp.exe" /* Dev-Cpp */
#endif
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Technical
//! @brief Ðàçðåøàòü ïðèíóäèòåëüíîå çàâåðøåíèå âûçûâàþùèõ ïðîãðàìì, æäóùèõ íàæàòèÿ êëàâèø ïîñëå çàâåðøåíèÿ TXLib.
//!
//! Èíà÷å îòìåíÿåòñÿ ñîáñòâåííàÿ ïàóçà äî íàæàòèÿ êëàâèøè, âñòðîåííàÿ â TXLib, è ïóñòü òîãäà ïàóçó äåëàåò
//! âûçûâàþùèé ïðîöåññ.
//!
//! Ñïèñîê âûçûâàþùèõ ïðîãðàìì, êîòîðûå ìîãóò äåëàòü òàêóþ ïàóçó, çàäàåòñÿ â _TX_WAITABLE_PARENTS.
//!
//! Ìîæåò çàäàâàòüñÿ ïåðåä âêëþ÷åíèåì TXLib.h â ïðîãðàììó.
//!
//! Ñì. òàêæå îïðåäåëåíèå ýòîé êîíñòàíòû â ôàéëå TXLib.h.
//!
//! @see _TX_WAITABLE_PARENTS, _TX_NOINIT
//!
//! @usage @code
//! #define _TX_ALLOW_KILL_PARENT false
//! #include "TXLib.h"
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
#if !defined (_TX_ALLOW_KILL_PARENT) // DISCLAIMER: ß íå ïðèçûâàþ ê óáèéñòâó ðîäèòåëåé!
#define _TX_ALLOW_KILL_PARENT true // Ýòî òåõíè÷åñêèé òåðìèí.
#endif // ã-äàì þðèñòàì ïðèâåò.
//! @}
//}
//=================================================================================================================
//=================================================================================================================
//{ Internal diagnostics
//! @name Âíóòðåííÿÿ äèàãíîñòèêà
//=================================================================================================================
//! @{
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Technical
//! @brief Âêëþ÷àåò/îòêëþ÷àåò âíóòðåííþþ òðàññèðîâêó èñïîëíåíèÿ êîäà áèáëèîòåêè.
//!
//! Òðàññèðîâêà èäåò ÷åðåç ìàêðîñ TX_TRACE, êîòîðûé ïîäñòàâëÿåòñÿ ïåðåä êàæäûì îïåðàòîðîì (statement).
//! Ïî óìîë÷àíèþ òðàññèðîâêà âûêëþ÷åíà.
//!
//! Ïî óìîë÷àíèþ òðàññèðîâêà âåäåòñÿ ÷åðåç ôóíêöèþ OutputDebugString(), åå âûâîä ìîæíî ïåðåõâàòèòü
//! óòèëèòàìè-ëîããåðàìè, íàïðèìåð, <a href=http://technet.microsoft.com/ru-ru/sysinternals/bb896647%28en-us%29.aspx>
//! DbgView</a>. Ýòî ìîæíî èçìåíèòü, ïåðåîïðåäåëèâ ìàêðîñ TX_TRACE äî âêëþ÷åíèÿ TXLib.h â ïðîãðàììó.
//!
//! @warning Òðàññèðîâêà @b î÷åíü òîðìîçèò âûïîëíåíèå ïðîãðàììû, îñîáåííî ïðè îòëàäêå â Microsoft Visual Studio.
//!  ýòîì ñëó÷àå ëó÷øå ïîëüçîâàòüñÿ DbgView (ñì. âûøå) è çàïóñêàòü îòëàæèâàåìóþ ïðîãðàììó îòäåëüíî,
//! à íå èç-ïîä îòëàä÷èêà Visual Studio.
//!
//! _TX_ALLOW_TRACE è TX_TRACE çàäàþòñÿ ïåðåä âêëþ÷åíèåì TXLib.h â ïðîãðàììó.
//!
//! @usage @code
//! #define _TX_ALLOW_TRACE // Äëÿ ïðîñìîòðà òðàññû çàïóñòèòü DbgView
//! #include "TXLib.h"
//! @endcode
//!
//! @hideinitializer
//}----------------------------------------------------------------------------------------------------------------
//! @{
#ifdef FOR_DOXYGEN_ONLY
#define _TX_ALLOW_TRACE
#endif
#if defined (_TX_ALLOW_TRACE)
#undef $
#define $ { _txFile = __FILE__; _txLine = __LINE__; _txFunc = __TX_FUNCTION__; TX_TRACE; }
#undef $1
#define $1 _txFuncEntry __txFuncEntry; $
#elif defined (_DEBUG)
#undef $
#define $ { _txFile = __FILE__; _txLine = __LINE__; _txFunc = __TX_FUNCTION__; }
#undef $1
#define $1 _txFuncEntry __txFuncEntry; $
#else
#undef $
#define $ ;
#undef $1
#define $1 ;
#endif
//! @}
//{----------------------------------------------------------------------------------------------------------------
//! @cond _OFF
extern int _txInitialized;
extern unsigned volatile _txMainThreadId;
extern unsigned volatile _txCanvas_ThreadId;
extern bool _txConsole;
extern bool _txMain;
extern bool _txIsDll;
extern bool volatile _txRunning;
extern bool volatile _txExit;
extern bool volatile _txAllowTrace;
extern const char* volatile _txFile;
extern int volatile _txLine;
extern const char* volatile _txFunc;
extern _TX_THREAD int volatile _txInTX;
//! @endcond
//! @cond INTERNAL
struct _txFuncEntry
{
_txFuncEntry() { _txInTX++; }
~_txFuncEntry() { _txInTX--; }
};
//! @endcond
//}----------------------------------------------------------------------------------------------------------------
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Technical
//! @brief Òðàññèðóåò èñïîëíåíèå êîäà ÷åðåç OutputDebugString().
//!
//! Ïî óìîë÷àíèþ òðàññèðîâêà âåäåòñÿ ÷åðåç ôóíêöèþ OutputDebugString(), åå âûâîä ìîæíî ïåðåõâàòèòü
//! óòèëèòàìè-ëîããåðàìè, íàïðèìåð, <a href=http://technet.microsoft.com/ru-ru/sysinternals/bb896647%28en-us%29.aspx>
//! DbgView</a>. Äëÿ "ðàñêðàñêè" ëîãà åñòü ôàéë <tt>TX\Dev\DbgView.ini,</tt> åãî íàäî çàãðóçèòü â DbgView
//! ÷åðåç ìåíþ Edit/Filter/Load (Ctrl+L).
//!
//! Ñ ïîìîùüþ TX_TRACE ìîæíî òðàññèðîâàòü êîä ñàìîé áèáëèîòåêè TXLib. Äëÿ ýòîãî íàäî ðàçðåøèòü òðàññèðîâêó
//! TXLib, îïðåäåëèâ ìàêðîñ _TX_ALLOW_TRACE ïåðåä âêëþ÷åíèåì ôàéëà TXLib.h â ïðîãðàììó. Ïî óìîë÷àíèþ
//! òðàññèðîâêà TXLib âûêëþ÷åíà.
//!
//! TX_TRACE ìîæíî ïåðåîïðåäåëèòü â ñâîé êîä. Òîãäà, åñëè òðàññèðîâêà áèáëèîòåêè ðàçðåøåíà, îí áóäåò
//! âûçûâàòüñÿ ïî÷òè ïåðåä êàæäîé èñïîëíÿåìîé ñòðîêîé TXLib. Ìîæåò áûòü, ýòî êîìó-íèáóäü áóäåò èíòåðåñíî.
//!
//! @usage @code
//! int main()
//! {
//! ...
//! TX_TRACE // ×åðåç DbgView óâèäèì èìÿ ôàéëà è íîìåð âûïîëíÿåìîé ñòðîêè
//! ...
//! }
//! @endcode
//! @code
//! #define TX_TRACE printf (__TX_FILELINE__ "\n");
//! #include "TXLib.h"
//! @endcode
//!
//! @hideinitializer
//}----------------------------------------------------------------------------------------------------------------
//! @{
#ifdef FOR_DOXYGEN_ONLY
#define TX_TRACE
#endif
#if !defined (TX_TRACE)
#define TX_TRACE if (_txAllowTrace) _txTrace (__FILE__, __LINE__, __TX_FUNCTION__);
#endif
//! @}
//{----------------------------------------------------------------------------------------------------------------
//! @cond INTERNAL
void _txTrace (const char file[], int line, const char func[], const char msg[] = NULL, ...);
void _txTrace (const char file[], int line, const char func[], const char msg[] /* = NULL */, ...)
{
unsigned id = GetCurrentThreadId();
const char marks[2][2][3] = {{"uU", "cC"}, {"mM", "??"}};
char mark = marks [id == _txMainThreadId] [id == _txCanvas_ThreadId] [(_txInTX > 0)];
char msgStr[_TX_BUFSIZE] = "";
if (msg)
{
va_list arg; va_start (arg, msg);
_vsnprintf_s (msgStr, sizeof (msgStr) - 1 _TX_TRUNCATE, msg, arg);
va_end (arg);
}
txOutputDebugPrintf ("%s - %p %c%c%c%c%c%c [%c] - %s (%d) " "|%*s%s" "%s%s\n",
_TX_VERSION, (void*) &_txInitialized,
"cC"[_txConsole], "mM"[_txMain], "dD"[_txIsDll], "rR"[_txRunning], "eE"[_txExit], "tT"[_txAllowTrace],
mark, (file? file : "(NULL file)"), line, (_txInTX - 1) * 2, "", (func? func : ""),
(*msgStr? ": " : ""), msgStr);
}
//! @endcond
//}----------------------------------------------------------------------------------------------------------------
//=================================================================================================================
//{ Sweet critical section blocking: txAutoLock class
//=================================================================================================================
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Service
//! @brief Êëàññ äëÿ àâòîìàòè÷åñêîé áëîêèðîâêè è ðàçáëîêèðîâêè êðèòè÷åñêîé ñåêöèè.
//!
//! Íà÷èíàÿ ñ <a href=http://progbook.ru/2008/08/03/sovremennoe-proektirovanie-na-c-andrejj.html>
//! Àëåêñàíäðåñêó,</a> åãî ïèøóò âñå è îí ïðîñò, êàê ïðîáêà: â êîíñòðóêòîðå @d EnterCriticalSection(),
//! â äåñòðóêòîðå @d LeaveCriticalSection(). Ýòî @c RAII â ÷èñòîì âèäå: âû íèêîãäà íå çàáóäåòå ðàçáëî÷èòü
//! ñåêöèþ and your thread show will always go on.
//!
//! Íåêîòîðûå äîáàâëåíèÿ: åñòü âîçîæíîñòü âûçâàòü TryEnterCriticalSection(), è, åñëè îíà íå çàáëî÷èëà
//! ñåêöèþ, äåñòðóêòîð åå íå ðàçáëî÷èâàåò. Åñòü îïåðàòîð äëÿ ïðîâåðêè, çàáëî÷èëàñü ëè ñåêöèÿ èëè íåò
//! (ñì. êîíñòðóêòîðû êëàññà è îïåðàòîð @c bool).
//!
//! @note Êëàññ íå èíèöèàëèçèðóåò è íå óäàëÿåò êðèòè÷åñêóþ ñåêöèþ. Òîëüêî ñèíõðîíèçèðóåò. Îñòàëüíîå ñàìè-ñàìè :)
//!
//! @see txLock(), txUnlock(), txGDI()
//}----------------------------------------------------------------------------------------------------------------
//! @cond _OFF
extern CRITICAL_SECTION _txCanvas_LockBackBuf;
//! @endcond
class txAutoLock
{
public:
//{----------------------------------------------------------------------------------------------------------------
//! @brief Êîíñòðóêòîð, áëîêèðóåò êðèòè÷åñêóþ ñåêöèþ
//!
//! @param cs Êðèòè÷åñêàÿ ñåêöèÿ äëÿ áëîêèðîâêè
//! @param mandatory Åñëè @c true, òî áëîêèðîâàòü îáÿçàòåëüíî (EnterCriticalSection). @n
//! Åñëè @c false, òî òîëüêî ïûòàòüñÿ áëîêèðîâàòü (TryEnterCriticalSection).
//! @usage @code
//! CRITICAL_SECTION cs = {}; // This is not a Counter Strike
//!
//! void foo()
//! {
//! txAutoLock lock (&cs); // Çäåñü âûçîâåòñÿ EnterCriticalSection()
//! ...
//! } // à çäåñü LeaveCriticalsection()
//!
//! void bar()
//! {
//! txAutoLock lock (&cs, false); // TryEnterCriticalSection()
//! if (!lock) return; // íó íå ñìîãëà
//! ...
//! }
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
txAutoLock (CRITICAL_SECTION* cs, bool mandatory = true) :
cs_ (cs)
{
$1 if (!cs_) return;
if (mandatory) { $ EnterCriticalSection (cs_); }
else { $ TryEnterCriticalSection (cs_)? 0 : (cs_ = NULL); }
}
//{----------------------------------------------------------------------------------------------------------------
//! @brief Êîíñòðóêòîð äëÿ áëîêèðîâêè õîëñòà TXLib
//!
//! @param mandatory Åñëè @c true, òî áëîêèðîâàòü @b îáÿçàòåëüíî, êàê â @ref txLock (true). @n
//! Åñëè @c false, òî òîëüêî @b ïûòàòüñÿ áëîêèðîâàòü, êàê â @ref txLock (false).
//! @usage @code
//! void foobar()
//! {
//! txAutoLock lock; // Çäåñü âûçîâåòñÿ txLock()
//! ...
//! } // à çäåñü txUnlock()
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
txAutoLock (bool mandatory = true) :
cs_ (NULL)
{
$1 new (this) txAutoLock (&_txCanvas_LockBackBuf, mandatory);
}
//{----------------------------------------------------------------------------------------------------------------
//! @brief Äåñòðóêòîð, ðàçáëîêèðóåò ñåêöèþ
//}----------------------------------------------------------------------------------------------------------------
~txAutoLock()
{
$1 if (!cs_) return;
$ LeaveCriticalSection (cs_); cs_ = NULL;
}
//{----------------------------------------------------------------------------------------------------------------
//! @brief Ïîçâîëÿåò ïðîâåðèòü, çàáëîêèðîâàëàñü ñåêöèÿ èëè íåò
//! @usage Ñì. â txAutoLock::AutoLock (CRITICAL_SECTION&, bool)
//}----------------------------------------------------------------------------------------------------------------
operator bool () const
{
$1 return (cs_ != NULL);
}
//{----------------------------------------------------------------------------------------------------------------
//! Áëîêèðóåìàÿ êðèòè÷åñêàÿ ñåêöèÿ
//}----------------------------------------------------------------------------------------------------------------
// private:
CRITICAL_SECTION* cs_;
//{----------------------------------------------------------------------------------------------------------------
//! Òàêîé âîò êîïèðàéò.
//}----------------------------------------------------------------------------------------------------------------
//! @{
private:
txAutoLock (const txAutoLock&);
txAutoLock& operator = (const txAutoLock&);
//! @}
};
//}
//=================================================================================================================
//! @}
//}
//=================================================================================================================
//=================================================================================================================
//{ Dialogs: txDialog class
//! @name Ðàáîòà ñ äèàëîãîâûìè îêíàìè. Êëàññ txDialog
//=================================================================================================================
//! @{
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Dialogs
//! @brief Áàçîâûé êëàññ äëÿ äèàëîãîâûõ îêîí.
//!
//! Äëÿ ñîçäàíèÿ ñâîåãî äèàëîãîâîãî îêíà íóæíî:
//! -# Óíàñëåäîâàòü ñâîé êëàññ èç ýòîãî áàçîâîãî êëàññà;
//! -# Çàäàòü ñîñòàâ è ðàñïîëîæåíèå ýëåìåíòîâ óïðàâëåíèÿ (êîíòðîëîâ) ôóíêöèåé txDialog::setLayout(), èëè
//! óêàçàòü êàðòó ðàñïîëîæåíèÿ ïðè ïîêàçå äèàëîãîâîãî îêíà ôóíêöèåé txDialog::dialogBox();
//! -# Ïåðåîïðåäåëèòü â ñâîåì êëàññå ôóíêöèþ txDialog::dialogProc() äëÿ îáðàáîòêè ñîáûòèé äèàëîãîâîãî
//! îêíà èëè ïîñòðîèòü êàðòó ðåàêöèé íà êîìàíäû ñ ïîìîùüþ ìàêðîñîâ TX_BEGIN_MESSAGE_MAP(),
//! TX_END_MESSAGE_MAP, TX_COMMAND_MAP.
//!
//! @see txDialog::setLayout(), txDialog::dialogProc(), txDialog::Layout, TX_BEGIN_MESSAGE_MAP(),
//! TX_END_MESSAGE_MAP, TX_COMMAND_MAP
//!
//! @usage @code
//! Cì. ðåàëèçàöèþ ôóíêöèè txInputBox().
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
struct txDialog
{
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Dialogs
//! @brief Êîíñòàíòû äëÿ çàäàíèÿ òèïà êîíòðîëà.
//!
//! Âìåñòî êîíñòàíò ìîæíî èñïîëüçîâàòü íàçâàíèÿ îêîííûõ êëàññîâ, ïðåîáðàçîâàííûå ê òèïó txDialog::CONTROL.
//!
//! @see txDialog::Layout, txDialog::setLayout()
//!
//! @usage @code
//! Cì. ðåàëèçàöèþ ôóíêöèè txInputBox().
//! @endcode
//!
//! @hideinitializer
//}----------------------------------------------------------------------------------------------------------------
public:
enum CONTROL
{
DIALOG = 0x00000000, //!< Íà÷àëî îïèñàíèÿ äèàëîãà
BUTTON = 0xFFFF0080, //!< Êíîïêà
EDIT = 0xFFFF0081, //!< Ðåäàêòèðóåìûé òåêñò
STATIC = 0xFFFF0082, //!< Íåðåäàêòèðóåìûé ýëåìåíò (òåêñò, êàðòèíêà è ò.ä.)
LISTBOX = 0xFFFF0083, //!< Ñïèñîê ñ ïðîêðóòêîé
SCROLLBAR = 0xFFFF0084, //!< Ïîëîñà ïðîêðóòêè
COMBOBOX = 0xFFFF0085, //!< Êîìáèíèðîâàííûé ñïèñîê
END = 0x00000000 //!< Êîíåö îïèñàíèÿ äèàëîãà
};
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Dialogs
//! @brief Êëàññ äëÿ îïèñàíèÿ ýëåìåíòà äèàëîãîâîãî îêíà (êîíòðîëà)
//!
//! Ìàññèâ òàêèõ ñòðóêòóð çàäàåò îïèñàíèå ìàêåòà äèàëîãîâîãî îêíà. Ýòî îïèñàíèå ïîõîæå íà çàäàíèå äèàëîãà
//! â ðåñóðñíîì ñêðèïòå (.rc):
//!
//! - Íóëåâîé ýëåìåíò îïèñûâàåò äèàëîãîâîå îêíî â öåëîì
//! - Îñòàëüíûå ýëåìåíòû îïèñûâàþò êîíòðîëû (ïîðÿäîê çàäàíèÿ ïàðàìåòðîâ êîíòðîëà ïîõîæ íà ïîðÿäîê
//! ïàðàìåòðîâ â ðåñóðñíîì ñêðèïòå)
//! - Ïîñëåäíèé ýëåìåíò - txDialog::END èëè {NULL}
//!
//! @see txDialog::setLayout(), txDialog::dialogBox(), txDialog::dialogProc()
//!
//! @usage @code
//! Cì. ðåàëèçàöèþ ôóíêöèè txInputBox().
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
public:
struct Layout
{
CONTROL wndclass; //!< Òèï êîíòðîëà
const char* caption; //!< Íàçâàíèå èëè òåêñò
WORD id; //!< Èäåíòèôèêàòîð êîíòðîëà
short x; //!< Êîîðäèíàòà âåðõíåãî ëåâîãî óãëà
short y; //!< Êîîðäèíàòà íèæíåãî ïðàâîãî óãëà
short sx; //!< Ðàçìåð ïî X
short sy; //!< Ðàçìåð ïî Y
DWORD style; //!< Ñòèëü êîíòðîëà
const char* font; //!< Øðèôò äèàëîãîâîãî îêíà
WORD fontsize; //!< Ðàçìåð øðèôòà äèàëîãîâîãî îêíà
};
//{----------------------------------------------------------------------------------------------------------------
//! @brief Êîíñòðóêòîð.
//!
//! @see txDialog::txDialog (const txDialog::Layout*)
//!
//! @usage @code
//! Cì. ðåàëèçàöèþ ôóíêöèè txInputBox().
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
public:
txDialog();
//{----------------------------------------------------------------------------------------------------------------
//! @brief Êîíñòðóêòîð.
//!
//! @param layout Ìàêåò äèàëîãîâîãî îêíà
//!
//! @see txDialog::Layout, txDialog::setLayout()
//!
//! @usage @code
//! Cì. ðåàëèçàöèþ ôóíêöèè txInputBox().
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
txDialog (const Layout* layout);
//{----------------------------------------------------------------------------------------------------------------
//! @brief Äåñòðóêòîð.
//}----------------------------------------------------------------------------------------------------------------
virtual ~txDialog() {};
//{----------------------------------------------------------------------------------------------------------------
//! @brief Óñòàíàâëèâàåò òåêóùèé ìàêåò äèàëîãîâîãî îêíà.
//!
//! @param layout Ìàêåò äèàëîãîâîãî îêíà
//!
//! @return Ïðåäûäóùèé ìàêåò.
//!
//! @see txDialog::Layout, txDialog::txDialog (const txDialog::Layout*), txDialog::dialogBox()
//!
//! @usage @code
//! Cì. ðåàëèçàöèþ ôóíêöèè txInputBox().
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
const Layout* setLayout (const Layout *layout);
//{----------------------------------------------------------------------------------------------------------------
//! @brief Ôóíêöèÿ îáðàáîòêè ñîîáùåíèé äèàëîãîâîãî îêíà.
//!
//! @param _wnd Äåñêðèïòîð
//! @param _msg Íîìåð ñîîáùåíèÿ
//! @param _wParam 1-é ïàðàìåòð ñîîáùåíèÿ (WORD)
//! @param _lParam 2-é ïàðàìåòð ñîîáùåíèÿ (DWORD)
//!
//! @return  áîëüøèíñòâå ñëó÷àåâ false, äåòàëüíåå ñì. DialogProc â <a href=msdn.com>MSDN</a>.
//!
//! Ýòó ôóíêöèþ íàäî ïåðåîïðåäåëèòü äëÿ îáðàáîòêè ñîáûòèé îêíà, èëè ïîñòðîèòü åå ñ ïîìîùüþ ìàêðîñîâ
//! TX_BEGIN_MESSAGE_MAP(), TX_END_MESSAGE_MAP, TX_COMMAND_MAP.
//!
//! @see txDialog::dialogBox(), TX_BEGIN_MESSAGE_MAP(), TX_END_MESSAGE_MAP, TX_COMMAND_MAP
//!
//! @usage @code
//! Cì. ðåàëèçàöèþ ôóíêöèè txInputBox().
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
virtual int dialogProc (HWND _wnd, UINT _msg, WPARAM _wParam, LPARAM _lParam);
//{----------------------------------------------------------------------------------------------------------------
//! @brief Çàïóñêàåò äèàëîãîâîå îêíî.
//!
//! @param layout Ìàêåò äèàëîãîâîãî îêíà. @n
//! Åñëè íå óêàçàí - èñïîëüçóåòñÿ çíà÷åíèå, çàäàííîå txDialog::setLayout() èëè êîíñòðóêòîðîì
//! txDialog::txDialog (const txDialog::Layout*).
//! @param bufsize Ðàçìåð áóôåðà äëÿ ñîçäàíèÿ øàáëîíà äèàëîãà (åñëè íå óêàçàí - ðàçìåð ïî óìîë÷àíèþ)
//!
//! @return Çíà÷åíèå, óêàçàííîå â ôóíêöèè EndDialog(). @n
//! Ïî óìîë÷àíèþ - àäðåñ îáúåêòà <i>(this),</i> äëÿ êîòîðîãî áûëà çàïóùåíà txDialog::dialogBox().
//!
//! @see txDialog::dialogProc(), txDialog::setLayout(), txDialog::Layout, txDialog
//!
//! @usage @code
//! Cì. ðåàëèçàöèþ ôóíêöèè txInputBox().
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
INT_PTR dialogBox (const Layout* layout = NULL, size_t bufsize = 0);
//{----------------------------------------------------------------------------------------------------------------
//! @brief Çàïóñêàåò äèàëîãîâîå îêíî.
//!
//! @param resource Èäåíòèôèêàòîð äèàëîãîâîãî ðåñóðñà
//!
//! @return Çíà÷åíèå, óêàçàííîå â ôóíêöèè EndDialog(). @n
//! Ïî óìîë÷àíèþ - àäðåñ îáúåêòà <i>(this),</i> äëÿ êîòîðîãî áûëà çàïóùåíà txDialog::dialogBox().
//!
//! @see txDialog::dialogProc()
//!
//! @usage @code
//! Cì. ðåàëèçàöèþ ôóíêöèè txInputBox().
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
INT_PTR dialogBox (WORD resource);
//{----------------------------------------------------------------------------------------------------------------
//! @brief Çàêðûòûå êîíñòðóêòîð êîïèðîâàíèÿ è îïåðàòîð ïðèñâàèâàíèÿ.
//}----------------------------------------------------------------------------------------------------------------
private:
txDialog (const txDialog&);
txDialog& operator = (const txDialog&);
//{----------------------------------------------------------------------------------------------------------------
//! Íàñòîÿùàÿ äèàëîãîâàÿ ôóíêöèÿ (íå txDialog::dialogProc(), ò.ê. ôóíêöèÿ îêíà in32 äîëæíà áûòü ñòàòè÷åñêîé).
//}----------------------------------------------------------------------------------------------------------------
private:
static ptrdiff_t CALLBACK dialogProc__ (HWND wnd, UINT msg, WPARAM wParam, LPARAM lParam);
//{----------------------------------------------------------------------------------------------------------------
//! Òåêóùèé ìàêåò äèàëîãà.
//}----------------------------------------------------------------------------------------------------------------
private:
const Layout* layout_;
};
//! @}
//}
//=================================================================================================================
//=================================================================================================================
//{ Dialogs: Message Map macros
//! @name Ìàêðîñû äëÿ ïîñòðîåíèÿ ñòàòè÷åñêîé êàðòû ñîîáùåíèé (Message Map)
//=================================================================================================================
//! @{
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief Çàãîëîâîê êàðòû ñîîáùåíèé (Message Map).
//!
//! @see TX_BEGIN_MESSAGE_MAP(), TX_END_MESSAGE_MAP, TX_HANDLE(), TX_COMMAND_MAP, txDialog::dialogProc(), txDialog
//!
//! @usage @code
//! Cì. ðåàëèçàöèþ ôóíêöèè txInputBox().
//! @endcode
//!
//! @hideinitializer
//}----------------------------------------------------------------------------------------------------------------
#define TX_BEGIN_MESSAGE_MAP() \
virtual int dialogProc (HWND _wnd, UINT _msg, WPARAM _wParam, LPARAM _lParam) \
{ \
(void)_wnd; (void)_msg; (void)_wParam; (void)_lParam; \
\
switch (_msg) \
{ \
case WM_NULL:
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief Çàãîëîâîê îáðàáîò÷èêà ñîîáùåíèÿ (Message handler) êàðòû ñîîáùåíèé.
//!
//! @param id Èäåíòèôèêàòîð ñîîáùåíèÿ
//!
//! @see TX_BEGIN_MESSAGE_MAP(), TX_END_MESSAGE_MAP, TX_HANDLE(), TX_COMMAND_MAP, txDialog::dialogProc(), txDialog
//!
//! @usage @code
//! Cì. ðåàëèçàöèþ ôóíêöèè txInputBox().
//! @endcode
//!
//! @hideinitializer
//}----------------------------------------------------------------------------------------------------------------
#define TX_HANDLE( id ) \
break; \
case (id):
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief Íà÷àëî êàðòû êîìàíä (Command map) â êàðòå ñîîáùåíèé.
//!
//! @see TX_BEGIN_MESSAGE_MAP(), TX_END_MESSAGE_MAP, TX_HANDLE(), TX_COMMAND_MAP, txDialog::dialogProc(), txDialog
//!
//! @usage @code
//! Cì. ðåàëèçàöèþ ôóíêöèè txInputBox().
//! @endcode
//!
//! @hideinitializer
//}----------------------------------------------------------------------------------------------------------------
#define TX_COMMAND_MAP \
default: break; \
} \
\
if (_msg == WM_COMMAND) switch (LOWORD (_wParam)) \
{ \
case 0:
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief Çàâåðøèòåëü êàðòû ñîîáùåíèé.
//!
//! @see TX_BEGIN_MESSAGE_MAP(), TX_END_MESSAGE_MAP, TX_HANDLE(), TX_COMMAND_MAP, txDialog::dialogProc(), txDialog
//!
//! @usage @code
//! Cì. ðåàëèçàöèþ ôóíêöèè txInputBox().
//! @endcode
//!
//! @hideinitializer
//}----------------------------------------------------------------------------------------------------------------
#define TX_END_MESSAGE_MAP \
default: break; \
} \
\
return FALSE; \
}
//! @}
//}
//=================================================================================================================
//=================================================================================================================
//{ Dialogs: txDialog example: txInputBox()
//! @name Ïðèìåð èñïîëüçîâàíèÿ êëàññà äèàëîãà: ôóíêöèÿ txInputBox()
//=================================================================================================================
//! @{
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Dialogs
//! @brief Ââîä ñòðîêè â îòäåëüíîì îêíå.
//!
//! @param text Òåêñò ñ âîïðîñîì
//! @param caption Çàãîëîâîê îêíà
//! @param input Çíà÷åíèå ñòðîêè ïî óìîë÷àíèþ
//!
//! @return Ââåäåííàÿ ñòðîêà (ñòàòè÷åñêàÿ ïåðåìåííàÿ ôóíêöèè).
//!
//! @warning Âîçâðàùàåìàÿ ñòðîêà - ñòàòè÷åñêàÿ, è îáíîâëÿåòñÿ ïðè êàæäîì âûçîâå ôóíêöèè. Åñëè txInputBox() áóäåò
//! âûçûâàòüñÿ íåñêîëüêî ðàç, òî äëÿ ñîõðàíåíèÿ ñòðîêè åå íåîáõîäèìî êîïèðîâàòü â äðóãóþ ñòðîêó ïðè ïîìîùè
//! <i>strcpy()</i>.
//!
//! @see txDialog, TX_BEGIN_MESSAGE_MAP, TX_BEGIN_COMMAND_MAP, TX_HANDLE, TX_END_MESSAGE_MAP
//!
//! @usage @code
//! const char* name = txInputBox ("So what's ur name?!?!", "System", "Sorry I'm Vasya Pupkin");
//! txMessageBox (name, "Aaand nooowww.. the winner iiis...");
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
const char* txInputBox (const char* text = NULL, const char* caption = NULL, const char* input = NULL);
const char* txInputBox (const char* text, const char* caption, const char* input)
{
//-------------------------------------------------------------------------------------------------------------
// Åñëè íå óêàçàíû ïàðàìåòðû, ïðèõîäèòñÿ èñïîëüçîâàòü õîòü êàêèå-òî íàäïèñè.
// txGetModuleFileName() - èìÿ EXE-ôàéëà, íà ñëó÷àé, åñëè êîå-êòî ïîëåíèëñÿ çàäàòü íàçâàíèå.
//-------------------------------------------------------------------------------------------------------------
if (!text) text = "Ââåäèòå ñòðîêó:";
if (!caption) caption = txGetModuleFileName (false);
if (!input) input = "";
//-------------------------------------------------------------------------------------------------------------
// Èäåíòèôèêàòîðû ýëåìåíòîâ äèàëîãà. Îíè òðåáóþòñÿ â GetDlgItemText().
// Åñëè äèàëîã ñòðîèòñÿ íå âðó÷íóþ, à ðåäàêòîðîì ðåñóðñîâ, òî îíè çàäàþòñÿ â íåì àâòîìàòè÷åñêè.
// Ó íàñ æå òóò - õàðäêîð ñòàéë, ê ñîæàëåíèþ. Ïðè÷èíà â òîì, ÷òî ó ðàçíûõ ñðåä ïðîãðàììèðîâàíèÿ
// ðàçíûå ðåäàêòîðû ðåñóðñîâ è ñèñòåìû ñáîðêè. Ïîýòîìó äëÿ íåçàâèñèìîñòè îò íèõ âñå áóäåò
// ñòðîèòüñÿ íà ýòàïå âûïîëíåíèÿ, äèíàìè÷åñêè. Âû åùå ãëÿíüòå, êàê ýòî ðåàëèçîâàíî â
// txDialog::dialogBox() è ôóíêöèÿõ _tx_DLGTEMPLATE_()... Î_î
//-------------------------------------------------------------------------------------------------------------
#define ID_TEXT_ 101
#define ID_INPUT_ 102
//-------------------------------------------------------------------------------------------------------------
// Çàäàíèå ìàêåòà (âèäà) äèàëîãà â âèäå ìàññèâà ñòðóêòóð.
// Ñ ïîìîùüþ îñîáîãî ïîðÿäêà ïîëåé â ñòðóêòóðå txDialog::Layout è êîíñòàíò èç êëàññà
// txDialog ýòîò ìàññèâ ñòàíîâèòñÿ ïîõîæ íà îïèñàíèå ðåñóðñà äèàëîãà â .rc - ôàéëå.
// Ñì. îïèñàíèå ñèíòàêñèñà rc-ôàéëà â äîêóìåíòàöèè ïî Win32 (MSDN, http://msdn.com).
//-------------------------------------------------------------------------------------------------------------
txDialog::Layout layout[] =
//----------------------+----------+-----------+-----------------+---------------------------------------------
// Òèï ýëåìåíòà | Èìÿ | Èäåíòè- | Êîîðäèíàòû | Ôëàãè ýëåìåíòîâ
// äèàëîãà | ýëåìåíòà | ôèêàòîð |-----------------| (ñì. îïèñàíèå ýëåìåíòîâ
// | | ýëåìåíòà | X | Y |Øèð.|Âûñ.| îêîí äèàëîãà â MSDN)
//----------------------+----------+-----------+---+---+----+----+---------------------------------------------
// | | | | | | |
{{ txDialog::DIALOG, caption, 0, 0, 0, 240, 85 },
{ txDialog::STATIC, text, ID_TEXT_, 10, 10, 150, 40, SS_LEFT },
{ txDialog::EDIT, input, ID_INPUT_, 10, 60, 220, 15, ES_LEFT | WS_BORDER | ES_AUTOHSCROLL | WS_TABSTOP },
{ txDialog::BUTTON, "&OK", IDOK, 180, 10, 50, 15, BS_DEFPUSHBUTTON | WS_TABSTOP },
{ txDialog::BUTTON, "&Cancel", IDCANCEL, 180, 30, 50, 15, BS_PUSHBUTTON | WS_TABSTOP },
{ txDialog::END }};
//-------------------------------------------------------------------------------------------------------------
// Êëàññ äèàëîãà äëÿ InputBox. Âíóòðåííèé, ò.ê. çà÷åì åìó áûòü âíåøíèì.
// Íóæåí â îñíîâíîì äëÿ çàäàíèÿ ñòðîêè ââîäà (str) è îêîííîé ôóíêöèè äèàëîãîâîãî îêíà,
// òðåáóåìîé Win32 (îíà ïîñòðîåíà ìàêðîñàìè TX_BEGIN_MESSAGE_MAP è äðóãèìè). Ìîæíî íå äåëàòü
// âíóòðåííåãî êëàññà, íî òîãäà îêîííóþ ôóíêöèþ ïðèäåòñÿ ïèñàòü â ãëîáàëüíîé îáëàñòè âèäèìîñòè,
// è str îáúÿâëÿòü ãëîáàëüíî òîæå (èëè ïåðåäàâàòü åå àäðåñ ÷åðåç DialogBoxParam è çàïèñûâàòü
// åãî â êëàññ âî âðåìÿ îáðàáîòêè WM_INITDIALOG).
//-------------------------------------------------------------------------------------------------------------
struct inputDlg : txDialog
{
char str [1024];
//---------------------------------------------------------------------------------------------------------
inputDlg() :
str() // Îáíóëåíèå âñåé ñòðîêè. Íå ðàáîòàåò íà ñòàðûõ
{ // êîìïèëÿòîðàõ, ïîýòîìó åùå ðàç:
memset (str, 0, sizeof (str)); // Îáíóëåíèå âñåé ñòðîêè
}
//---------------------------------------------------------------------------------------------------------
TX_BEGIN_MESSAGE_MAP() // Êàðòà ñîîáùåíèé. Íà ñàìîì äåëå ýòî íà÷àëî îêîííîé ôóíêöèè.
TX_COMMAND_MAP // Çäåñü îáðàáàòûâàþòñÿ WM_COMMAND. Íà ñàìîì äåëå ýòî switch.
//-------------------------------------------------------------------------------------------------
// Ïðè íàæàòèè êíîïêè OK êîïèðóåì ñòðîêó èç ïîëÿ ââîäà â íàøó ïåðåìåííóþ str,
// ò.ê. ïîñëå çàêðûòèÿ äèàëîãà ñòðîêà ââîäà óìðåò è òåêñò óæå èç íåå ïîëó÷èòü.
// Ýòîò ìàêðîñ íà ñàìîì äåëå ïðåâðàùàåòñÿ â case èç îïåðàòîðà switch.
// _wnd - ýòî ïàðàìåòð îêîííîé ôóíêöèè, ñì. îïðåäåëåíèå ìàêðîñà TX_BEGIN_MESSAGE_MAP().
//-------------------------------------------------------------------------------------------------
TX_HANDLE (IDOK) GetDlgItemText (_wnd, ID_INPUT_, str, sizeof (str) - 1);
TX_END_MESSAGE_MAP
//---------------------------------------------------------------------------------------------------------
// Êîíåö âíóòðåííåãî êëàññà äèàëîãà
//---------------------------------------------------------------------------------------------------------
};
//-------------------------------------------------------------------------------------------------------------
// Óáèðàåì äåôàéíû, ÷òîáû ïîòîì íå ìåøàëè.
// Îò ýòîãî îíè ïîëó÷àþòñÿ "ëîêàëüíîãî äåéñòâèÿ", êàê áóäòî ó íèõ áûëà áû îáëàñòü âèäèìîñòè -
// ôóíêöèÿ. Íà ñàìîì äåëå ýòî ñäåëàíî âðó÷íóþ ÷åðåç #undef. ×òîáû ïîä÷åðêíóòü èõ ëîêàëüíóþ
// ïðèðîäó, ó íèõ èìåíà çàêàí÷èâàþòñÿ íà _. Òàêèå äåéôàéíû ïîòîì íå ïåðåêîñÿ÷àò âåñü êîä ïîñëå
// òîãî êàê, ôàêòè÷åñêè, ñòàëè óæå íå íóæíû.
//-------------------------------------------------------------------------------------------------------------
#undef ID_TEXT_
#undef ID_INPUT_
//-------------------------------------------------------------------------------------------------------------
// Ýòî ñòàòè÷åñêèé îáúåêò, ïîòîìó ÷òî ñòðîêà â íåì äîëæíà æèòü ïîñëå çàâåðøåíèÿ ôóíêöèè.
//-------------------------------------------------------------------------------------------------------------
static inputDlg dlg;
//-------------------------------------------------------------------------------------------------------------
// Ïåðåäàåì layout è çàïóñêàåì îêíî äèàëîãà
//-------------------------------------------------------------------------------------------------------------
dlg.dialogBox (layout);
//-------------------------------------------------------------------------------------------------------------
// Âîçâðàùàåì àäðåñ ñòðîêè èç ñòàòè÷åñêîãî îáúåêòà. Òàê ìîæíî äåëàòü, ïîòîìó ÷òî ñòàòè÷åñêèé
// îáúåêò íå óìðåò ïðè âûõîäå èç ôóíêöèè è ñòðîêà â íåì, ñîîòâåòñòâåííî, òîæå. Àäðåñ
// íåñòàòè÷åñêèõ ïåðåìåííûõ ïåðåäàâàòü ñèíòàêñè÷åñêè ìîæíî, íî âåäåò ê ñåðüåçíûì îøèáêàì.
//-------------------------------------------------------------------------------------------------------------
return dlg.str;
}
//! @}
//}
//=================================================================================================================
//}
//=================================================================================================================
//=================================================================================================================
//{ TXLIB IMPLEMENTATION
// Ðåàëèçàöèÿ ôóíêöèé áèáëèîòåêè
//=================================================================================================================
//! @cond INTERNAL
//=================================================================================================================
//{ [Internal] Function prototypes, macros and constants
// Ïðîòîòèïû âíóòðåííèõ ôóíêöèé, ìàêðîñû è êîíñòàíòû
//=================================================================================================================
const int _TX_CP = 1251; // Èíôîðìàöèÿ î ëîêàëè
const char _TX_LC_CTYPE[] = "Russian";
const wchar_t _TX_LC_CTYPE_W[] = L"Russian_Russia.ACP";
const int _TX_IDM_ABOUT = 40000; // Èäåíòèôèêàòîðû ñèñòåìíîãî ìåíþ îêíà
const int _TX_IDM_CONSOLE = 40001;
//-----------------------------------------------------------------------------------------------------------------
int _txInitialize();
void _txCleanup();
HWND _txCanvas_CreateWindow (SIZE* size);
inline bool _txCanvas_OK();
bool _txCanvas_OnCREATE (HWND wnd);
bool _txCanvas_OnDESTROY (HWND wnd);
bool _txCanvas_OnCLOSE (HWND);
bool _txCanvas_OnPAINT (HWND wnd);
bool _txCanvas_OnKEYDOWN (HWND wnd, WPARAM vk, LPARAM info);
bool _txCanvas_OnCHAR (HWND wnd, WPARAM ch, LPARAM info);
bool _txCanvas_OnTIMER (HWND wnd, WPARAM id);
bool _txCanvas_OnMOUSEMOVE (HWND wnd, WPARAM buttons, LPARAM coords);
bool _txCanvas_OnCmdCONSOLE (HWND wnd, WPARAM cmd);
bool _txCanvas_OnCmdABOUT (HWND wnd, WPARAM cmd);
unsigned WINAPI _txCanvas_ThreadProc (void* data);
LRESULT CALLBACK _txCanvas_WndProc (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar);
int _txCanvas_SetRefreshLock (int count);
HDC _txBuffer_Create (HWND wnd, const POINT* size = NULL, HBITMAP bmap = NULL);
bool _txBuffer_Delete (HDC* dc);
bool _txBuffer_Select (HGDIOBJ obj, HDC dc = txDC());
HWND _txConsole_Attach();
bool _txConsole_OK();
bool _txConsole_Detach (bool activate);
bool _txConsole_Draw (HDC dc);
bool _txConsole_SetUnicodeFont();
int _txSetFinishedText (HWND wnd);
void _txPauseBeforeTermination (HWND canvas);
bool _txIsParentWaitable (DWORD* parentPID = NULL);
PROCESSENTRY32* _txFindProcess (unsigned pid = GetCurrentProcessId());
bool _txKillProcess (DWORD pid);
PROC _txSetProcAddress (HMODULE module, const char* dllName, const char* funcName, PROC newFunc);
bool _txInDll();
int _txGetInput();
void _tx_cexit();
bool _txCreateShortcut (const char shortcutName[],
const char fileToLink[], const char args[] = NULL, const char workDir[] = NULL,
const char description[] = NULL, int cmdShow = SW_SHOWNORMAL,
const char iconFile[] = NULL, int iconIndex = 0, int fontSize = 0,
COORD bufSize = ZERO (COORD), COORD wndSize = ZERO (COORD), COORD wndOrg = ZERO (COORD));
void* _tx_DLGTEMPLATE_Create (void* globalMem, size_t bufsize, DWORD style, DWORD exStyle,
WORD controls, short x, short y, short cx, short cy,
const char caption[], const char font[], WORD fontsize,
HANDLE menu);
void* _tx_DLGTEMPLATE_Add (void* dlgTemplatePtr, size_t bufsize, DWORD style, DWORD exStyle,
short x, short y, short cx, short cy,
WORD id, const char wclass[], const char caption[]);
const char* _txError (const char file[] = NULL, int line = 0, const char func[] = NULL,
const char msg[] = NULL, ...) _TX_CHECK_FORMAT (4);
HICON _txCreateTXIcon (int size);
void _txOnSignal (int signal = 0, int fpe = 0);
void _txOnTerminate();
void _txOnUnexpected();
FARPROC _txDllImport (const char dllFileName[], const char funcName[], bool required = true);
//-----------------------------------------------------------------------------------------------------------------
// These are macros for __FILE__ and __LINE__ to work properly.
#if !defined (NDEBUG)
#define _TX_IF_ARGUMENT_FAILED( cond ) if (!assert (cond) && (SetLastErrorEx (ERROR_BAD_ARGUMENTS, 0), 1))
#define _TX_IF_TXWINDOW_FAILED if ( !txOK() && (SetLastErrorEx (ERROR_INVALID_DATA, 0), 1) && \
(TX_ERROR ("\a" "Îêíî ðèñîâàíèÿ íå ñîçäàíî èëè íå â ïîðÿäêå"), 1))
#else
#define _TX_IF_ARGUMENT_FAILED( cond ) if (! (cond) && (SetLastErrorEx (ERROR_BAD_ARGUMENTS, 0), 1))
#define _TX_IF_TXWINDOW_FAILED if ( !txOK() && (SetLastErrorEx (ERROR_INVALID_DATA, 0), 1))
#endif
// Take action in debug configuration only.
// Definition ({ expr; }) would be better, but some old dinosaurs (yes it is MSVC 6) reject it. So sad. :'(
#if !defined (NDEBUG)
#define _TX_ON_DEBUG( code ) { code; }
#else
#define _TX_ON_DEBUG( code ) ;
#endif
// This is a macro because cond is an expression and not always a function. Lack of lambdas in pre-C++0x.
#define _txWaitFor( cond, time ) { for (DWORD _t = GetTickCount() + (time); \
!(cond) && GetTickCount() < _t; \
Sleep (_txWindowUpdateInterval)) ; \
if (!(cond)) \
_txTrace (__FILE__, __LINE__, "WARNING: Timeout: " #cond "."); }
//}
//=================================================================================================================
//=================================================================================================================
//{ [Internal] DLL functions import
//! @name Èìïîðò âíåøíèõ áèáëèîòåê
//=================================================================================================================
//! @{
FARPROC _txDllImport (const char dllFileName[], const char funcName[], bool required /*= true*/)
{
_TX_IF_ARGUMENT_FAILED (!(dllFileName && !*dllFileName)) return NULL;
_TX_IF_ARGUMENT_FAILED ( funcName && *funcName) return NULL;
HMODULE dll = GetModuleHandle (dllFileName);
if (!dll && dllFileName) dll = LoadLibrary (dllFileName);
if (!dll && required) TX_ERROR ("\a" "Cannot load library \"%s\"" _ dllFileName);
if (!dll) return NULL;
FARPROC addr = GetProcAddress (dll, funcName);
if (!addr && required) TX_ERROR ("\a" "Cannot import \"%s\" from library \"%s\"" _ funcName _ dllFileName);
return addr;
}
//-----------------------------------------------------------------------------------------------------------------
// Import helpers
// Ìàëàÿ ìåõàíèçàöèÿ
//-----------------------------------------------------------------------------------------------------------------
#define _TX_DLLIMPORT( lib, retval, name, params ) \
retval (WINAPI* name) params = (retval (WINAPI*) params) _txDllImport (lib ".dll", #name, true)
#define _TX_DLLIMPORT_OPT( lib, retval, name, params ) \
retval (WINAPI* name) params = (retval (WINAPI*) params) _txDllImport (lib ".dll", #name, false)
//-----------------------------------------------------------------------------------------------------------------
// Some IDEs don't link with these libs by default in console projects, so do sunrise by hand. :(
//{ <tears>
namespace Win32 {
#ifdef _MSC_VER_6
struct CONSOLE_FONT_INFO;
#endif
struct NT_CONSOLE_PROPS;
struct CONSOLE_FONT_INFOEX;
_TX_DLLIMPORT ("GDI32", HDC, CreateCompatibleDC, (HDC dc));
_TX_DLLIMPORT ("GDI32", HBITMAP, CreateCompatibleBitmap, (HDC dc, int width, int height));
_TX_DLLIMPORT ("GDI32", HGDIOBJ, GetStockObject, (int object));
_TX_DLLIMPORT ("GDI32", HGDIOBJ, SelectObject, (HDC dc, HGDIOBJ object));
_TX_DLLIMPORT ("GDI32", HGDIOBJ, GetCurrentObject, (HDC dc, unsigned objectType));
_TX_DLLIMPORT ("GDI32", int, GetObjectA, (HGDIOBJ obj, int bufsize, void* buffer));
_TX_DLLIMPORT ("GDI32", DWORD, GetObjectType, (HGDIOBJ object));
_TX_DLLIMPORT ("GDI32", BOOL, DeleteDC, (HDC dc));
_TX_DLLIMPORT ("GDI32", BOOL, DeleteObject, (HGDIOBJ object));
_TX_DLLIMPORT ("GDI32", COLORREF, SetTextColor, (HDC dc, COLORREF color));
_TX_DLLIMPORT ("GDI32", COLORREF, SetBkColor, (HDC dc, COLORREF color));
_TX_DLLIMPORT ("GDI32", int, SetBkMode, (HDC dc, int bkMode));
_TX_DLLIMPORT ("GDI32", HFONT, CreateFontA, (int height, int width, int escapement, int orientation,
int weight, DWORD italic, DWORD underline, DWORD strikeout,
DWORD charSet, DWORD outputPrec, DWORD clipPrec,
DWORD quality, DWORD pitchAndFamily, const char face[]));
_TX_DLLIMPORT ("GDI32", int, EnumFontFamiliesExA, (HDC dc, LPLOGFONT logFont, FONTENUMPROC enumProc,
LPARAM lParam, DWORD reserved));
_TX_DLLIMPORT ("GDI32", COLORREF, SetPixel, (HDC dc, int x, int y, COLORREF color));
_TX_DLLIMPORT ("GDI32", COLORREF, GetPixel, (HDC dc, int x, int y));
_TX_DLLIMPORT ("GDI32", HPEN, CreatePen, (int penStyle, int width, COLORREF color));
_TX_DLLIMPORT ("GDI32", HBRUSH, CreateSolidBrush, (COLORREF color));
_TX_DLLIMPORT ("GDI32", BOOL, MoveToEx, (HDC dc, int x, int y, POINT* point));
_TX_DLLIMPORT ("GDI32", BOOL, LineTo, (HDC dc, int x, int y));
_TX_DLLIMPORT ("GDI32", BOOL, Polygon, (HDC dc, const POINT points[], int count));
_TX_DLLIMPORT ("GDI32", BOOL, Rectangle, (HDC dc, int x0, int y0, int x1, int y1));
_TX_DLLIMPORT ("GDI32", BOOL, RoundRect, (HDC dc, int x0, int y0, int x1, int y1, int sizeX, int sizeY));
_TX_DLLIMPORT ("GDI32", BOOL, Ellipse, (HDC dc, int x0, int y0, int x1, int y1));
_TX_DLLIMPORT ("GDI32", BOOL, Arc, (HDC dc, int x0, int y0, int x1, int y1,
int xStart, int yStart, int xEnd, int yEnd));
_TX_DLLIMPORT ("GDI32", BOOL, Pie, (HDC dc, int x0, int y0, int x1, int y1,
int xStart, int yStart, int xEnd, int yEnd));
_TX_DLLIMPORT ("GDI32", BOOL, Chord, (HDC dc, int x0, int y0, int x1, int y1,
int xStart, int yStart, int xEnd, int yEnd));
_TX_DLLIMPORT ("GDI32", BOOL, TextOutA, (HDC dc, int x, int y, const char string[], int length));
_TX_DLLIMPORT ("GDI32", UINT, SetTextAlign, (HDC dc, unsigned mode));
_TX_DLLIMPORT ("GDI32", BOOL, GetTextExtentPoint32A, (HDC dc, const char string[], int length, SIZE* size));
_TX_DLLIMPORT ("GDI32", BOOL, ExtFloodFill, (HDC dc, int x, int y, COLORREF color, unsigned type));
_TX_DLLIMPORT ("GDI32", BOOL, BitBlt, (HDC dest, int xDest, int yDest, int width, int height,
HDC src, int xSrc, int ySrc, DWORD rOp));
_TX_DLLIMPORT ("GDI32", int, SetDIBitsToDevice, (HDC dc, int xDest, int yDest, DWORD width, DWORD height,
int xSrc, int ySrc, unsigned startLine, unsigned numLines,
const void* data, const BITMAPINFO* info, unsigned colorUse));
_TX_DLLIMPORT ("GDI32", int, GetDIBits, (HDC hdc, HBITMAP hbmp, unsigned uStartScan, unsigned cScanLines,
void* lpvBits, BITMAPINFO* lpbi, unsigned usage));
_TX_DLLIMPORT ("GDI32", BOOL, PatBlt, (HDC dc, int x0, int y0, int width, int height, DWORD rOp));
_TX_DLLIMPORT ("GDI32", int, SetROP2, (HDC dc, int mode));
_TX_DLLIMPORT ("GDI32", HRGN, CreateRectRgn, (int x0, int y0, int x1, int y1));
_TX_DLLIMPORT ("GDI32", BOOL, GetBitmapDimensionEx, (HBITMAP bitmap, SIZE* dimensions));
_TX_DLLIMPORT ("User32", int, DrawTextA, (HDC dc, const char text[], int length, RECT* rect, unsigned format));
_TX_DLLIMPORT ("User32", HANDLE, LoadImageA, (HINSTANCE inst, const char name[], unsigned type,
int sizex, int sizey, unsigned mode));
_TX_DLLIMPORT_OPT ("User32", BOOL, IsHungAppWindow, (HWND wnd));
_TX_DLLIMPORT_OPT ("User32", HWND, GhostWindowFromHungWindow,(HWND wnd));
_TX_DLLIMPORT ("WinMM", BOOL, PlaySound, (const char sound[], HMODULE mod, DWORD mode));
_TX_DLLIMPORT_OPT ("MSImg32", BOOL, TransparentBlt, (HDC dest, int destX, int destY, int destWidth, int destHeight,
HDC src, int srcX, int srcY, int srcWidth, int srcHeight,
unsigned transparentColor));
_TX_DLLIMPORT_OPT ("MSImg32", BOOL, AlphaBlend, (HDC dest, int destX, int destY, int destWidth, int destHeight,
HDC src, int srcX, int srcY, int srcWidth, int srcHeight,
BLENDFUNCTION blending));
_TX_DLLIMPORT ("Kernel32", HWND, GetConsoleWindow, (void));
_TX_DLLIMPORT_OPT ("Kernel32", BOOL, SetConsoleFont, (HANDLE con, DWORD fontIndex));
_TX_DLLIMPORT_OPT ("Kernel32", BOOL, GetConsoleFontInfo, (HANDLE con, bool fullScr, DWORD nFonts, CONSOLE_FONT_INFO* info));
_TX_DLLIMPORT_OPT ("Kernel32", DWORD, GetNumberOfConsoleFonts, (void));
_TX_DLLIMPORT_OPT ("Kernel32", BOOL, GetCurrentConsoleFont, (HANDLE con, bool maxWnd, CONSOLE_FONT_INFO* curFont));
_TX_DLLIMPORT_OPT ("Kernel32", BOOL, GetCurrentConsoleFontEx, (HANDLE con, bool maxWnd, CONSOLE_FONT_INFOEX* curFont));
_TX_DLLIMPORT_OPT ("Kernel32", BOOL, SetCurrentConsoleFontEx, (HANDLE con, bool maxWnd, CONSOLE_FONT_INFOEX* curFont));
_TX_DLLIMPORT ("OLE32", HRESULT, CoInitialize, (void*));
_TX_DLLIMPORT ("OLE32", HRESULT, CoCreateInstance, (REFCLSID clsid, LPUNKNOWN, DWORD, REFIID iid, PVOID* value));
_TX_DLLIMPORT ("OLE32", void, CoUninitialize, (void));
_TX_DLLIMPORT ("Shell32", HINSTANCE,ShellExecuteA, (HWND wnd, const char operation[], const char file[],
const char parameters[], const char directory[], int showCmd));
_TX_DLLIMPORT_OPT ("NTDLL", char*, wine_get_version, (void));
_TX_DLLIMPORT_OPT ("MSVCRT", void, _cexit, (void));
//-----------------------------------------------------------------------------------------------------------------
// Another issue, some of structs, consts and interfaces aren't defined in MinGW some ealry headers.
// Copied from Windows SDK 7.0a.
#ifndef AC_SRC_ALPHA
#define AC_SRC_ALPHA 0x01
#endif
#ifndef SMTO_ERRORONEXIT
#define SMTO_ERRORONEXIT 0x0020
#endif
#ifndef NT_CONSOLE_PROPS_SIG
#define NT_CONSOLE_PROPS_SIG 0xA0000002
#endif
#ifndef NIIF_INFO
#define NIIF_INFO 0x00000001
#define NIIF_WARNING 0x00000002
#define NIIF_ERROR 0x00000003
#endif
#ifndef NIF_INFO
#define NIF_STATE 0x00000008
#define NIF_INFO 0x00000010
#endif
#pragma pack (push, 1)
#ifdef _MSC_VER_6
struct CONSOLE_FONT_INFO
{
DWORD nFont;
COORD dwFontSize;
};
struct NOTIFYICONDATA
{
DWORD cbSize;
HWND hWnd;
UINT uID;
UINT uFlags;
UINT uCallbackMessage;
HICON hIcon;
CHAR szTip[128];
DWORD dwState;
DWORD dwStateMask;
CHAR szInfo[256];
union {
UINT uTimeout;
UINT uVersion;
} u;
CHAR szInfoTitle[64];
DWORD dwInfoFlags;
};
#endif
struct CONSOLE_FONT_INFOEX
{
ULONG cbSize;
DWORD nFont;
COORD dwFontSize;
UINT FontFamily;
UINT FontWeight;
WCHAR FaceName[LF_FACESIZE];
};
struct DATABLOCK_HEADER
{
DWORD cbSize;
DWORD dwSignature;
};
struct NT_CONSOLE_PROPS
{
DATABLOCK_HEADER dbh;
WORD wFillAttribute;
WORD wPopupFillAttribute;
COORD dwScreenBufferSize;
COORD dwWindowSize;
COORD dwWindowOrigin;
DWORD nFont;
DWORD nInputBufferSize;
COORD dwFontSize;
UINT uFontFamily;
UINT uFontWeight;
WCHAR FaceName[LF_FACESIZE];
UINT uCursorSize;
BOOL bFullScreen;
BOOL bQuickEdit;
BOOL bInsertMode;
BOOL bAutoPosition;
UINT uHistoryBufferSize;
UINT uNumberOfHistoryBuffers;
BOOL bHistoryNoDup;
COLORREF ColorTable[16];
};
#pragma pack (pop)
#undef INTERFACE
#define INTERFACE IShellLinkDataList
DECLARE_INTERFACE_ (IShellLinkDataList, IUnknown)
{
// *** IUnknown methods ***
STDMETHOD (QueryInterface) (THIS_ REFIID iid, void** value) PURE;
STDMETHOD_(ULONG, AddRef) (THIS) PURE;
STDMETHOD_(ULONG, Release) (THIS) PURE;
// *** IShellLinkDataList methods ***
STDMETHOD (AddDataBlock) (THIS_ void* dataBlock) PURE;
STDMETHOD (CopyDataBlock) (THIS_ DWORD sig, void** dataBlock) PURE;
STDMETHOD (RemoveDataBlock) (THIS_ DWORD sig) PURE;
STDMETHOD (GetFlags) (THIS_ DWORD* flags) PURE;
STDMETHOD (SetFlags) (THIS_ DWORD flags) PURE;
protected:
virtual ~IShellLinkDataList();
};
const GUID IID_IShellLink = {0x000214ee, 0x0000, 0x0000, {0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};
const GUID IID_IShellLinkDataList = {0x45e2b4ae, 0xb1c3, 0x11d0, {0xb9,0x2f,0x00,0xa0,0xc9,0x03,0x12,0xe1}};
const GUID IID_IPersistFile = {0x0000010b, 0x0000, 0x0000, {0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};
#undef INTERFACE
} // namespace Win32
#ifdef _MSC_VER_6
using namespace Win32;
#endif
//} </tears>
//! @}
//}
//=================================================================================================================
//=================================================================================================================
//{ [Internal] Global data
//! @name Ãëîáàëüíûå äàííûå
//
// Äàííûå íå óïàêîâàíû â ñòðóêòóðó èëè êëàññ, äëÿ òîãî, ÷òîáû ýòî ñäåëàëè Âû ñàìè :)
//
// Åñëè âû ïèøåòå ñâîþ áèáëèîòåêó è èñïîëüçóåòå TXLib.h êàê ïðèìåðó, íå ñëåäóéòå åìó è íå äåëàéòå òàê æå.
// Çäåñü ýòî ñäåëàíî òîëüêî â îáðàçîâàòåëüíûõ öåëÿõ.
//
// Áóäüòå ïðàêòè÷íåå, ñäåëàéòå ñòðóêòóðó è ãëîáàëüíóþ ôóíêöèþ äëÿ äîñòóïà ê íåé.
//=================================================================================================================
//! @{
int _txInitialized = _TX_NOINIT || _txInitialize();
unsigned volatile _txMainThreadId = 0; // ID ïîòîêà, ãäå âûïîëíÿåòñÿ main()
unsigned volatile _txCanvas_ThreadId = 0; // ID ïîòîêà, âëàäåþùåãî îêíîì õîëñòà TXLib
HANDLE volatile _txCanvas_Thread = NULL; // Äåêñðèïòîð ýòîãî ïîòîêà
HWND volatile _txCanvas_Window = NULL; // Äåñêðèïòîð îêíà õîëñòà TXLib
UINT _txCanvas_RefreshTimer = 0; // Timer to redraw TXLib window
int volatile _txCanvas_RefreshLock = 0; // Blocks auto on-timer canvas update, see txBegin/txEnd
HDC _txCanvas_BackBuf[2] = {NULL, // [0] Main working TXLib memory DC, where user picture lies
NULL}; // [1] Image ready for auto-refresh, see txCanvas_OnPAINT()
CRITICAL_SECTION _txCanvas_LockBackBuf = {0,-1}; // Prevent simultaneous access to back buffer, see txLock()
std::vector<HDC>* _txCanvas_UserDCs = NULL; // List of DCs allocated, for auto-free
bool volatile _txConsole_IsBlinking = true; // To blink or not to blink, that is the question.
bool _txConsole = false; // Only first TXLib module in app owns it
bool _txMain = false; // First TXLib wnd opened (closing it terminates program)
bool _txIsDll = false; // TXLib module is in DLL
bool volatile _txRunning = false; // main() is still running
bool volatile _txExit = false; // exit() is active
bool volatile _txAllowTrace = true; // Internal TX trace is active
POINT _txMousePos = {0}; // Ask Captn Obviouos about it. See txCanvas_OnMOUSE()
int _txMouseButtons = 0;
WNDPROC volatile _txAltWndProc = NULL; // Àëüòåðíàòèâíàÿ îêîííàÿ ôóíêöèÿ. Ñì. txSetWindowsHook().
const char* volatile _txFile = NULL; // Current execution point tracking, see $ macro
int volatile _txLine = 0;
const char* volatile _txFunc = NULL;
_TX_THREAD int volatile _txInTX = 0; // We are inside one of TXLib's functions
//! @}
//}
//=================================================================================================================
//=================================================================================================================
//{ TXLib engine init/check/cleanup
//! @name Èíèöèàëèçàöèÿ/ïðîâåðêà/çàâåðøåíèå TXLib
//=================================================================================================================
//! @{
//-----------------------------------------------------------------------------------------------------------------
//{ Early initialization
//-----------------------------------------------------------------------------------------------------------------
int _txInitialize()
{
#if defined (_TX_ALLOC_BREAK) && defined (_MSC_VER)
_CrtSetBreakAlloc (_TX_ALLOC_BREAK);
#endif
_TX_ON_DEBUG (OutputDebugString ("\n");
OutputDebugString (_TX_VERSION " - The Dumb Artist Library, " _TX_AUTHOR ": \"" __FILE__ "\" "
"compiled " __DATE__ " " __TIME__ ", " _TX_BUILDMODE " mode, module: " _TX_MODULE "\n");
OutputDebugString ("\n"));
_txMainThreadId = GetCurrentThreadId();
$1 _txIsDll = _txInDll();
$ if (!_txIsDll)
{
$ _txConsole = ! FindAtom ("_txConsole"); // Not a thread-safe
$ (void) AddAtom ("_txConsole");
}
$ if (_txConsole)
{
$ _txOnSignal();
$ SetErrorMode (SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX);
#if defined (_MSC_VER)
$ _CrtSetDbgFlag (_CRTDBG_ALLOC_MEM_DF | _CRTDBG_CHECK_ALWAYS_DF | _CRTDBG_LEAK_CHECK_DF);
$ _CrtSetReportMode (_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
$ _CrtSetReportMode (_CRT_ERROR, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG | _CRTDBG_MODE_WNDW);
$ _CrtSetReportMode (_CRT_ASSERT, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG | _CRTDBG_MODE_WNDW);
$ _CrtSetReportFile (_CRT_WARN, _CRTDBG_FILE_STDERR);
$ _CrtSetReportFile (_CRT_ERROR, _CRTDBG_FILE_STDERR);
$ _CrtSetReportFile (_CRT_ASSERT, _CRTDBG_FILE_STDERR);
#endif
#ifndef _MSC_VER_6
$ std::set_unexpected (_txOnUnexpected);
$ std::set_terminate (_txOnTerminate);
#endif
$ HWND console = _txConsole_Attach();
$ SetWindowTextA (console, txGetModuleFileName (false));
}
$ InitializeCriticalSection (&_txCanvas_LockBackBuf);
$ _txCanvas_UserDCs = new std::vector <HDC>;
#if defined (_GCC_VER)
$ _txSetProcAddress (GetModuleHandle (NULL), "MSVCRT.DLL", "_cexit", (PROC) _tx_cexit); // See _tx_cexit()
#endif
$ atexit (_txCleanup);
$ (void) Win32::SetDIBitsToDevice; // Just to suppress "defined but not used" warning
$ (void) Win32::GetDIBits;
$ (void) Win32::RoundRect;
$ (void) Win32::CreateRectRgn;
$ (void) Win32::GetBitmapDimensionEx;
$ (void) Win32::GetConsoleFontInfo;
$ if (_txConsole)
{
$ txSetConsoleAttr (0x07);
$ SetLastError (0);
$ unsigned old87 = 0, new87 = 0x0008001C; // _EM_INVALID | _EM_DENORMAL | _EM_ZERODIVIDE | _EM_OVERFLOW
$ if (_controlfp_s (&old87, 0, 0) == 0)
{ $ (void) _controlfp_s (&old87, old87 & ~new87, 0x0008001F /* _MCW_EM */); }
}
$ return 1;
}
//}
//-----------------------------------------------------------------------------------------------------------------
HWND txCreateWindow (double sizeX, double sizeY, bool centered /*= true*/)
{
$1 if (!_txInitialized) _txInitialized = _txInitialize();
$ if (txWindow())
{
$ SetLastErrorEx (ERROR_INVALID_DATA, 0);
$ _TX_ON_DEBUG (TX_ERROR ("\a" "Îêíî ðèñîâàíèÿ óæå ñîçäàíî"));
$ return txWindow();
}
$ if (!_txIsDll)
{
$ _txMain = ! FindAtom ("_txMain"); // Not a thread-safe
$ (void) AddAtom ("_txMain");
}
$ if (_txWindowUpdateInterval < 10) { $ _txWindowUpdateInterval = 10; }
$ _txRunning = false;
// Store the size
$ static SIZE size = { ROUND (sizeX), ROUND (sizeY) };
$ if (centered) { size.cx *= -1; size.cy *= -1; }
// In Thread, where REAL creation lies...
#if !( defined (_MSC_VER) && (_MSC_VER < 1400) && !defined (_MT) )
$ unsigned id = 0;
$ _txCanvas_Thread = (HANDLE) _beginthreadex (NULL, 0, _txCanvas_ThreadProc, &size, 0, &id);
#else
$ DWORD id = 0;
$ _txCanvas_Thread = CreateThread (NULL, 0, (PTHREAD_START_ROUTINE)_txCanvas_ThreadProc, &size, 0, &id);
#endif
$ if (!_txCanvas_Thread) return TX_DEBUG_ERROR ("\a" "Cannot start canvas thread."), (HWND)NULL;
$ _txWaitFor (_txRunning, 30*_TX_TIMEOUT);
$ if (!_txRunning) return TX_DEBUG_ERROR ("\a" "Cannot create canvas window."),(HWND)NULL;
$ if (!txOK()) return TX_DEBUG_ERROR ("\a" "Canvas window is not OK."), (HWND)NULL;
$ Sleep (100);
$ errno = _doserrno = 0;
$ SetLastError (0);
$ return txWindow();
}
//-----------------------------------------------------------------------------------------------------------------
bool txSetDefaults()
{
$1 _TX_IF_TXWINDOW_FAILED return false;
$ txUpdateWindow (false);
$ txAutoLock _lock;
$ RECT r = {0};
$ GetClientRect (_txCanvas_Window, &r) asserted;
$ SIZE szCanvas = { r.right - r.left, r.bottom - r.top };
$ GetClientRect (Win32::GetConsoleWindow(), &r) asserted;
$ SIZE szCon = { r.right - r.left, r.bottom - r.top };
$ HANDLE out = GetStdHandle (STD_OUTPUT_HANDLE);
$ CONSOLE_SCREEN_BUFFER_INFO con = {{80, 25}, {0}, 0, {0, 0, 80-1, 25-1}, {80, 25}};
$ GetConsoleScreenBufferInfo (out, &con);
$ SIZE szTxt = { (short) (con.srWindow.Right - con.srWindow.Left + 1),
(short) (con.srWindow.Bottom - con.srWindow.Top + 1) };
//{ Set defaults for graphics layer
$ _txBuffer_Select (Win32::GetStockObject (WHITE_PEN), txDC()) asserted;
$ _txBuffer_Select (Win32::GetStockObject (WHITE_BRUSH), txDC()) asserted;
$ _txBuffer_Select (Win32::CreateFont (szCon.cy/szTxt.cy, szCon.cx/szTxt.cx,
0, 0, FW_REGULAR, FALSE, FALSE, FALSE,
RUSSIAN_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
DEFAULT_QUALITY, DEFAULT_PITCH, _txConsoleFont),
txDC()) asserted;
$ (Win32::SetTextColor (txDC(), TX_WHITE) != CLR_INVALID) asserted;
$ Win32::SetBkMode (txDC(), TRANSPARENT) asserted;
$ Win32::SetROP2 (txDC(), R2_COPYPEN) asserted;
//}
//{ Set defaults for console layer
$ HGDIOBJ font = txFontExist (_txConsoleFont)?
Win32::CreateFont ((int) (1.0 * szCanvas.cy/szTxt.cy), (int) (1.0 * szCanvas.cx/szTxt.cx),
0, 0, FW_REGULAR, FALSE, FALSE, FALSE,
RUSSIAN_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
DEFAULT_QUALITY, FIXED_PITCH, _txConsoleFont)
:
Win32::GetStockObject (SYSTEM_FIXED_FONT);
$ _txBuffer_Select (font, _txCanvas_BackBuf[1]) asserted;
//}
//{ Scroll the console for text to go above top of window and don't mix with graphics
$ if (con.dwCursorPosition.X) _putch ('\n');
$ short delta = (short) (con.dwCursorPosition.Y - con.srWindow.Top);
$ con.srWindow.Top = (short) (con.srWindow.Top + delta);
$ con.srWindow.Bottom = (short) (con.srWindow.Bottom + delta);
$ SMALL_RECT src = {0, 0, (short) (con.dwSize.X - 1), (short) (con.dwSize.Y - 1) };
$ CHAR_INFO fill = {{' '}, 0x07}; // Fill with spaces, light-gray on black
$ COORD dest = {0, (short) -delta}; // New UL-corner of src, scroll up
$ con.dwCursorPosition.X = 0;
$ con.dwCursorPosition.Y = (short) (con.dwCursorPosition.Y - delta);
$ (con.srWindow.Bottom < con.dwSize.Y && // Move the "window"
SetConsoleWindowInfo (out, true, &con.srWindow))
||
(ScrollConsoleScreenBuffer (out, &src, NULL, dest, &fill), // Or scroll the buffer
SetConsoleCursorPosition (out, con.dwCursorPosition));
//}
$ txUpdateWindow (true);
return true;
}
//-----------------------------------------------------------------------------------------------------------------
inline bool txOK()
{
$1 return _txCanvas_OK();
}
//-----------------------------------------------------------------------------------------------------------------
// In GCC, implicit std(MSVCRT.dll)::_cexit() call before _txCleanup leads to hands in _cexit handlers chain.
// So redefining std::_cexit(). Do it dynamically via PE Import Table hook to avoid duplicate symbols in linking
// serveral modules including TXLib.h. See _txSetProcAddress() call in _txInitialize().
#if defined (_GCC_VER)
void _tx_cexit()
{
$1 _txCleanup();
if (Win32::_cexit) { $ Win32::_cexit(); }
$ return;
}
#endif
//-----------------------------------------------------------------------------------------------------------------
void _txCleanup()
{
$1 if (!_txInitialized) return;
else _txInitialized = false;
$ txSleep (_txWindowUpdateInterval);
$ _txRunning = false;
$ _txConsole_IsBlinking = false;
$ HWND canvas = txWindow();
$ HWND console = Win32::GetConsoleWindow();
$ unsigned thread = GetCurrentThreadId();
$ HWND wnd = (canvas)? canvas : console;
$ bool externTerm = (thread != _txMainThreadId &&
thread != _txCanvas_ThreadId);
$ DWORD parent = 0;
$ bool waitableParent = !externTerm && _txIsParentWaitable (&parent);
$ if (_txConsole)
{
$ if (_txMain) txSetConsoleAttr (0x07);
$ if (console) EnableWindow (console, true);
}
$ if (_txMain && !externTerm && wnd != NULL)
{ $ _txSetFinishedText (wnd); }
$ if ((canvas? _txMain : _txConsole && !waitableParent) && !_txExit &&
thread == _txMainThreadId)
{
$ if (wnd)
{
$ ShowWindow (wnd, SW_SHOW);
$ EnableWindow (wnd, true);
$ SetForegroundWindow (wnd);
$ BringWindowToTop (wnd);
$ RedrawWindow (wnd, NULL, NULL, RDW_INVALIDATE | RDW_INTERNALPAINT | RDW_UPDATENOW);
}
$ if (console)
{ $ _txPauseBeforeTermination (canvas); }
}
$ if (txWindow())
{ $ SendNotifyMessage (txWindow(), WM_DESTROY, 0, 0); }
$ _txWaitFor (!txWindow(), 5*_TX_TIMEOUT);
$ if (!txWindow())
{ $ DeleteCriticalSection (&_txCanvas_LockBackBuf); _txCanvas_LockBackBuf = ZERO (CRITICAL_SECTION); }
$ if (_txCanvas_Thread)
{ $ CloseHandle (_txCanvas_Thread) asserted; _txCanvas_Thread = NULL; }
$ delete _txCanvas_UserDCs; _txCanvas_UserDCs = NULL;
$ if (_txMain && canvas && waitableParent && _txNOP (_TX_ALLOW_KILL_PARENT))
{ $ waitableParent |= !_txKillProcess (parent); }
$ if (_txMain && _txConsole)
{ $ _txConsole_Detach (waitableParent && !externTerm); }
_TX_ON_DEBUG (OutputDebugString ("\n");
OutputDebugString (_TX_VERSION " - FINISHED: " _TX_MODULE "\n");
OutputDebugString ("\n"));
}
//-----------------------------------------------------------------------------------------------------------------
int _txSetFinishedText (HWND wnd)
{
struct tools
{
static LRESULT getWindowText (HWND window, wchar_t text[], int size)
{
$1 memset (text, 0, size * sizeof (*text));
$ return SendMessageTimeoutW (window, WM_GETTEXT, (WPARAM) size, (LPARAM) text, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL);
}
static LRESULT setWindowText (HWND window, wchar_t text[])
{
$1 return SendMessageTimeoutW (window, WM_SETTEXT, 0, (LPARAM) text, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL);
}
};
$1 static wchar_t title [_TX_BUFSIZE+15] = L"TXLib";
$ tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$ unsigned len = (unsigned) wcslen (title); if (len >= _TX_BUFSIZE) len = _TX_BUFSIZE-1;
$ MultiByteToWideChar (_TX_CP, 0, " [ÇÀÂÅÐØÅÍÎ]", -1, title + len, _TX_BUFSIZE - len);
$ tools::setWindowText (wnd, title);
$ tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$ if (len <= _TX_BUFSIZE-1-2 && title [len+2] == /* 'Ç' */ (wchar_t) 0x0417) return 0;
$ MultiByteToWideChar (_TX_CP, 0, " [FINISHED]", -1, title + len, _TX_BUFSIZE - len);
$ tools::setWindowText (wnd, title);
$ tools::getWindowText (wnd, title, _TX_BUFSIZE-1);
$ if (len <= _TX_BUFSIZE-1-2 && title [len+2] == /* 'F' */ (wchar_t) 0x0046) return 1;
$ return 2;
}
//-----------------------------------------------------------------------------------------------------------------
void _txPauseBeforeTermination (HWND canvas)
{
$1 while (_kbhit()) (void)_getch();
$ CONSOLE_SCREEN_BUFFER_INFO con = {{0}};
$ bool kbRedir = !GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con);
$ bool kbWait = (_txGetInput() == EOF);
$ bool wine = !!Win32::wine_get_version;
$ if (kbWait && !canvas && !kbRedir && !wine)
{
$ printf ("\n" "[Íàæìèòå ëþáóþ êëàâèøó äëÿ çàâåðøåíèÿ]");
}
$ for (int i = 1; ; i++)
{
$ Sleep (_txWindowUpdateInterval);
if (!kbWait || (kbRedir && !canvas)) { $ break; } // No need to run and hide
if (!wine && _txGetInput() != EOF) { $ break; } // Somebody hit something.
if (canvas && !_txCanvas_ThreadId) { $ break; } // There was a window, and now there is not.
if (!Win32::GetConsoleWindow()) { $ break; } // Console was destroyed
if (Win32::GhostWindowFromHungWindow && Win32::GhostWindowFromHungWindow (canvas))
{ $ TX_ERROR ("Ïðèëîæåíèå çàâèñëî è áóäåò çàêðûòî."); break; }
if (canvas && Win32::IsHungAppWindow && Win32::IsHungAppWindow (canvas))
{ $ _txTrace (__FILE__, __LINE__, "WARNING: Ïðèëîæåíèå çàâèñëî è áóäåò çàêðûòî."); break; }
if (canvas && !SendMessageTimeout (canvas, WM_NULL, 0,0, SMTO_BLOCK | SMTO_ABORTIFHUNG, _TX_TIMEOUT, NULL))
{ $ _txTrace (__FILE__, __LINE__, "WARNING: Ïðèëîæåíèå íå îòâå÷àåò è áóäåò çàêðûòî."); break; }
if (!wine && !(i % 100500))
{ $ printf ("\r" "[Òàê íàæìèòå æå êàêóþ-íèáóäü êëàâèøó äëÿ ìîåãî çàâåðøåíèÿ]"); }
}
$ while (!wine && _kbhit()) (void)_getch();
$ printf ("\n");
}
//-----------------------------------------------------------------------------------------------------------------
int _txGetInput()
{
$1 HANDLE con = GetStdHandle (STD_INPUT_HANDLE);
$ DWORD nchars = 0;
$ if (GetConsoleMode (con, &nchars) == 0 &&
PeekNamedPipe (con, NULL, 0, NULL, &nchars, NULL))
{
$ return (nchars)? fgetc (stdin) : EOF;
}
$ if (_kbhit())
{
$ return _getch();
}
#if defined (_MSC_VER) && (_MSC_VER < 1700)
$ if (fseek (stdin, 1, SEEK_CUR) != EOF)
{
$ (void) fseek (stdin, -1, SEEK_CUR);
$ return fgetc (stdin); // This causes blocking in MSVC 2011 beta
}
#endif
$ return EOF;
}
//-----------------------------------------------------------------------------------------------------------------
bool _txIsParentWaitable (DWORD* parentPID /*= NULL*/)
{
$1 PROCESSENTRY32* info = _txFindProcess();
$ if (!info) return false;
$ info = _txFindProcess (info->th32ParentProcessID);
$ if (!info) return false;
$ char parent [MAX_PATH] = "";
$ strncpy_s (parent, info->szExeFile, sizeof (parent) - 1);
$ if (parentPID) *parentPID = info->th32ProcessID;
$ info = _txFindProcess (info->th32ParentProcessID); // info: grandparent
$ char list[_TX_BUFSIZE] = _TX_WAITABLE_PARENTS;
$ char* ctx = NULL;
$ for (char* p = strtok_s (list, ", ", &ctx); p; p = strtok_s (NULL, ", ", &ctx))
{
$ char* gp = strchr (p, ':');
$ if (gp)
{
$ *gp++ = 0;
$ if (_stricmp (p, parent) != 0) { continue; }
$ if (info) if (_stricmp (gp, info->szExeFile) == 0) // Was &&, but OMG MSVC /analyze..
{ $ return true; }
}
else
{
$ if (_stricmp (p, parent) == 0)
{ $ return true; }
}
}
$ return false;
}
//-----------------------------------------------------------------------------------------------------------------
PROCESSENTRY32* _txFindProcess (unsigned pid /*= GetCurrentProcessId()*/)
{
$1 static PROCESSENTRY32 info = { sizeof (info) };
$ if (!pid) return &info;
$ HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPPROCESS, 0);
$ assert (sshot); if (!sshot) return NULL;
$ for (bool ok = !!Process32First (sshot, &info); ok; ok = !!Process32Next (sshot, &info))
if (info.th32ProcessID == pid) break;
$ CloseHandle (sshot);
$ return &info;
}
//-----------------------------------------------------------------------------------------------------------------
bool _txInDll()
{
$1 MODULEENTRY32 mod = { sizeof (mod) };
$ HANDLE sshot = CreateToolhelp32Snapshot (TH32CS_SNAPMODULE, 0);
$ assert (sshot); if (!sshot) return false;
$ bool inDll = false;
$ for (bool ok = !!Module32First (sshot, &mod); ok; ok = !!Module32Next (sshot, &mod))
{
$ if (!mod.modBaseAddr) continue;
$ IMAGE_DOS_HEADER* dosHdr = (IMAGE_DOS_HEADER*) mod.modBaseAddr;
$ IMAGE_NT_HEADERS* ntHdr = (IMAGE_NT_HEADERS*) (mod.modBaseAddr + dosHdr->e_lfanew);
$ inDll = (dosHdr->e_magic == IMAGE_DOS_SIGNATURE &&
ntHdr->Signature == IMAGE_NT_SIGNATURE &&
(ntHdr->FileHeader.Characteristics & IMAGE_FILE_DLL) != 0);
$ if (In ((BYTE*)(ptrdiff_t)_txInDll, mod.modBaseAddr, mod.modBaseAddr + mod.modBaseSize)) break;
}
$ CloseHandle (sshot);
$ return inDll;
}
//-----------------------------------------------------------------------------------------------------------------
// You are here, little hacker?
bool _txKillProcess (DWORD pid)
{
$1 _TX_IF_ARGUMENT_FAILED (pid) return false;
$ HANDLE token = INVALID_HANDLE_VALUE;
$ OpenProcessToken (GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &token) asserted;
$ LUID luid = {0};
$ LookupPrivilegeValue (NULL, SE_DEBUG_NAME, &luid) asserted;
$ TOKEN_PRIVILEGES priv = { 1, {{{ luid.LowPart, luid.HighPart}, SE_PRIVILEGE_ENABLED }}};
$ TOKEN_PRIVILEGES old = {0};
$ DWORD oldSz = 0;
$ AdjustTokenPrivileges (token, false, &priv, sizeof (priv), &old, &oldSz) asserted;
$ HANDLE proc = OpenProcess (PROCESS_ALL_ACCESS, 0, pid);
$ if (!proc) return false;
$ bool ok = !!TerminateProcess (proc, 0);
$ CloseHandle (proc);
$ return ok;
}
//-----------------------------------------------------------------------------------------------------------------
// TXLib continues to hack the reality to make your life better, sweeter and easier
PROC _txSetProcAddress (HMODULE module, const char* dllName, const char* funcName, PROC newFunc)
{
$1 _TX_IF_ARGUMENT_FAILED (module) return NULL;
$ _TX_IF_ARGUMENT_FAILED (dllName) return NULL;
$ _TX_IF_ARGUMENT_FAILED (newFunc) return NULL;
$ HMODULE dll = GetModuleHandle (dllName);
$ if (!dll) return NULL;
$ PROC oldFunc = GetProcAddress (dll, funcName);
$ if (!oldFunc) return NULL;
#define RVA_( type, addr ) ( (type) ((ptrdiff_t) module + (ptrdiff_t) (addr)) )
$ IMAGE_DOS_HEADER* dosHdr = RVA_ (IMAGE_DOS_HEADER*, 0);
$ IMAGE_NT_HEADERS* ntHdr = RVA_ (IMAGE_NT_HEADERS*, dosHdr->e_lfanew);
$ if (dosHdr->e_magic != IMAGE_DOS_SIGNATURE ||
ntHdr ->Signature != IMAGE_NT_SIGNATURE) return NULL;
$ DWORD impOffset = ntHdr->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress;
$ IMAGE_IMPORT_DESCRIPTOR* desc = RVA_ (IMAGE_IMPORT_DESCRIPTOR*, impOffset);
$ if (desc == (IMAGE_IMPORT_DESCRIPTOR*) ntHdr) return NULL;
$ IMAGE_THUNK_DATA* thunk = NULL;
$ bool found = false;
for (; desc->Name; desc++)
{
$ if (_stricmp (RVA_ (const char*, desc->Name), dllName) != 0) continue;
$ for (thunk = RVA_ (IMAGE_THUNK_DATA*, desc->FirstThunk); thunk->u1.Function; thunk++)
if ((ptrdiff_t) thunk->u1.Function == (ptrdiff_t) oldFunc) { found = true; break; }
$ if (found) break;
}
$ if (!found) return NULL;
$ *(PROC*)& thunk->u1.Function = newFunc; // In different MS-SDKs this field has different types (DWORD/DWORD*/etc)
$ return oldFunc;
#undef RVA_
}
//! @}
//}
//=================================================================================================================
//=================================================================================================================
//{ [Internal] TXLib window functions (_txCanvas...)
//! @name Ôóíêöèè îêíà TXLib (_txCanvas...)
//=================================================================================================================
//{
#if defined (_MSC_VER_6) || defined (_GCC_VER) && (_GCC_VER <= 345)
#define SetClassLong_ SetClassLong
#define GCL_HICON_ GCL_HICON
#define GCL_HICONSM_ GCL_HICONSM
#define GCL_HCURSOR_ GCL_HCURSOR
#else
#define SetClassLong_ SetClassLongPtr
#define GCL_HICON_ GCLP_HICON
#define GCL_HICONSM_ GCLP_HICONSM
#define GCL_HCURSOR_ GCLP_HCURSOR
#endif
//}
unsigned WINAPI _txCanvas_ThreadProc (void* data)
{
$1 _txCanvas_ThreadId = GetCurrentThreadId();
$ _TX_IF_ARGUMENT_FAILED (data) return false;
$ HWND wnd = _txCanvas_CreateWindow ((SIZE*) data);
$ if (!txWindow()) return TX_DEBUG_ERROR ("\a" "Cannot create canvas"), 0;
$ HICON icon32 = LoadIcon (GetModuleHandle (NULL), "_TX_ICON");
$ HICON icon16 = LoadIcon (GetModuleHandle (NULL), "_TX_ICONSM");
$ HCURSOR cursor = LoadCursor (GetModuleHandle (NULL), "_TX_CURSOR");
$ SetClassLong_ (wnd, GCL_HICON_, (DWORD)(ptrdiff_t) (icon32? icon32 : _txCreateTXIcon (32)));
$ SetClassLong_ (wnd, GCL_HICONSM_, (DWORD)(ptrdiff_t) (icon16? icon16 : _txCreateTXIcon (16)));
$ SetClassLong_ (wnd, GCL_HCURSOR_, (DWORD)(ptrdiff_t) (cursor? cursor : LoadCursor (NULL, IDC_ARROW)));
$ HACCEL accel = LoadAccelerators (NULL, "_TX_ACCELERATORS");
_TX_ON_DEBUG (OutputDebugString (_TX_VERSION " - STARTED: " _TX_MODULE "\n"));
$ _txRunning = true;
$ ShowWindow (wnd, SW_SHOW);
$ SetForegroundWindow (wnd);
$ UpdateWindow (wnd);
$ MSG msg = {0};
$ while (GetMessage (&msg, NULL, 0, 0))
{
$ if (!msg.hwnd) continue;
$ if (accel != NULL && TranslateAccelerator (wnd, accel, &msg)) continue;
$ TranslateMessage (&msg);
$ DispatchMessage (&msg);
$ Sleep (0);
}
$ if (icon16) DestroyIcon (icon16); // If Explorer is displaying Tray Notification, these
$ if (icon32) DestroyIcon (icon32); // calls will possibly fail, and we'll get resource leak.
$ LeaveCriticalSection (&_txCanvas_LockBackBuf);
$ if (_txRunning && _txMain) // Main window is destroyed but main() is still running.
{ // No chances for good termination, so use exit().
$ exit ((int) msg.wParam);
}
_TX_ON_DEBUG (OutputDebugString (_TX_VERSION " - STOPPED: " _TX_MODULE "\n"));
$ _txCanvas_ThreadId = 0;
$ return true;
}
//{
#undef SetClassLong
#undef GCL_HICON_
#undef GCL_HICONSM_
#undef GCL_HCURSOR_
//}
//-----------------------------------------------------------------------------------------------------------------
HWND _txCanvas_CreateWindow (SIZE* size)
{
$1 _TX_IF_ARGUMENT_FAILED (size) return NULL;
$ static char className[_TX_BUFSIZE] = "";
$ _snprintf_s (className, sizeof (className) - 1 _TX_TRUNCATE,
"/*---[TXLib]-------------------------- "
_TX_VERSION " " __FILE__ " WndClass %08X "
"--------------------------[TXLib]---*/", (int) GetTickCount());
$ WNDCLASSEX wc = { sizeof (wc) };
$ wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
$ wc.lpfnWndProc = _txCanvas_WndProc;
$ wc.hCursor = LoadCursor (NULL, IDC_ARROW);
$ wc.hbrBackground = (HBRUSH) Win32::GetStockObject (HOLLOW_BRUSH);
$ wc.lpszClassName = className;
$ ATOM wndclass = RegisterClassEx (&wc);
$ if (!wndclass) return TX_DEBUG_ERROR ("RegisterClass (\"%s\") failed" _ className), (HWND) NULL;
$ int centered = false;
$ if (size->cx < 0 && size->cy < 0) { size->cx *= -1; size->cy *= -1; centered = true; }
$ SIZE scr = { GetSystemMetrics (SM_CXSCREEN), GetSystemMetrics (SM_CYSCREEN) };
$ RECT r = { 0, 0, size->cx, size->cy }; AdjustWindowRect (&r, _txWindowStyle, false);
$ SIZE sz = { r.right - r.left, r.bottom - r.top };
$ HWND wnd = CreateWindowEx (WS_EX_APPWINDOW, className, txGetModuleFileName (false), _txWindowStyle,
centered? scr.cx/2 - sz.cx/2 : CW_USEDEFAULT,
centered? scr.cy/2 - sz.cy/2 : CW_USEDEFAULT,
sz.cx, sz.cy, NULL, NULL, NULL, NULL);
$ if (!wnd || !txWindow()) return TX_DEBUG_ERROR ("Cannot create canvas: CreateWindowEx (\"%s\") failed" _ className), (HWND) NULL;
$ HMENU menu = GetSystemMenu (txWindow(), false);
$ if (!menu) return txWindow();
$ AppendMenu (menu, MF_SEPARATOR, 0, NULL) asserted;
$ AppendMenu (menu, MF_STRING, _TX_IDM_CONSOLE, "Show &Console") asserted;
$ AppendMenu (menu, MF_STRING, _TX_IDM_ABOUT, "&About...") asserted;
$ HWND console = Win32::GetConsoleWindow();
$ DWORD proc = 0;
$ GetWindowThreadProcessId (console, &proc);
$ if (console && (proc == GetCurrentProcessId() || _txIsParentWaitable()))
{ $ ShowWindow (console, _txConsoleMode); }
$ CheckMenuItem (menu, _TX_IDM_CONSOLE, (console? (IsWindowVisible (console)? MF_CHECKED : 0) : MF_DISABLED));
$ return txWindow();
}
//-----------------------------------------------------------------------------------------------------------------
inline bool _txCanvas_OK()
{
$1 return _txCanvas_ThreadId &&
_txCanvas_Window &&
_txCanvas_BackBuf[0] &&
_txCanvas_BackBuf[1];
}
//-----------------------------------------------------------------------------------------------------------------
int _txCanvas_SetRefreshLock (int count)
{
$1 int oldCount = _txCanvas_RefreshLock;
$ _txCanvas_RefreshLock = count;
$ HWND wnd = txWindow();
$ if ((_txCanvas_RefreshLock <= 0 || oldCount <= 0) && wnd)
{ $ RedrawWindow (wnd, NULL, NULL, RDW_INVALIDATE | RDW_INTERNALPAINT | RDW_UPDATENOW); }
$ return oldCount;
}
//-----------------------------------------------------------------------------------------------------------------
HICON _txCreateTXIcon (int size)
{
$1 _TX_IF_ARGUMENT_FAILED (size == 32 || size == 16) return NULL;
$ const char image32 [32*32+1] =
"00000000000000000000000000000000""0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0""0F0000000000000000000000000000F0""0F0000000000000000000000000000F0"
"0F0000000000000099999999999900F0""0F0000000000000090300333330900F0""0F0000000990000090000000000900F0""0F00000099990000900BB000000900F0"
"0F0000039999000090B00090900900F0""0F0000009999000090B00999990900F0""0F00000009903799900BB090900900F0""0F000000009BB70090000010000900F0"
"0F0000000B90000090000000000900F0""0F000000B0B0000099999999999900F0""0F00007B30B0000090000000000000F0""0F00007300B0000090000000000000F0"
"0F00000000B3000090000000000000F0""0F0000000B0B000090000000000000F0""0F000000B303B00090000000000000F0""0F000003B000B00090000000000000F0"
"0F00003B00003B0090000000000000F0""0F0000300000030090000000000000F0""0F0000000448888888888844000000F0""0F00004886E6E6E60E66E6EEEE4400F0"
"0F4488866E0E60E00660E06E66EEE4F0""0F868806E06E06E666E66E00E06EE6F0""0F08606E66E0066000E006E66E00E6F0""0F8666E006600E00006600E006E00EF0"
"0F000E066888888888888888606660F0""0F66EEE6EE000E00000E00086EEEE6F0""0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0""00000000000000000000000000000000";
$ const char image16 [16*16+1] =
"0000000000000000""0000000999999990""0009000900000090""0099900909973090""0059700909009390""0009799909973090""0099000900000090""0959330999999990"
"0709500900000000""0095930900000000""0090393900000000""0790073900000000""0900000900000000""000EE6E6E6E6E000""0EE6E6E6E6E6EEE0""0000000000000000";
$ const COLORREF pal['F'-'0'+1] = { 0x000000, 0x002b2b, 0x555500, 0x005555, 0x808000, 0x008080, 0xaaaa00, 0x00aaaa, 0xd5d500, 0x00d5d5, 0,0,0,0,0,0,0,
0xffff00, 0x00ffff, 0xffffaa, 0xaaffff, 0xd5d500, 0xffffff };
$ const char* image = (size == 32)? image32 : image16;
$ POINT sz = { size, size };
$ HDC dcMask = _txBuffer_Create (txWindow(), &sz); assert (dcMask);
$ HDC dcColor = _txBuffer_Create (txWindow(), &sz); assert (dcColor);
$ for (int i = 0; i < size*size; i++)
{
assert (In (image[i], '0', '9') || In (image[i], 'A', 'F'));
Win32::SetPixel (dcColor, i % size, i / size, pal [image[i] - '0']);
}
$ ICONINFO info = { true, 0, 0, (HBITMAP) Win32::GetCurrentObject (dcMask, OBJ_BITMAP),
(HBITMAP) Win32::GetCurrentObject (dcColor, OBJ_BITMAP) };
$ HICON icon = CreateIconIndirect (&info);
$ assert (icon);
$ _txBuffer_Delete (&dcMask) asserted;
$ _txBuffer_Delete (&dcColor) asserted;
$ return icon;
}
//! @}
//}
//=================================================================================================================
//=================================================================================================================
//{ [Internal] Main window event handlers (_txCanvas_On...)
//! @name Ñîáûòèÿ îñíîâíîãî îêíà (_txCanvas_On...)
//=================================================================================================================
//! @{
LRESULT CALLBACK _txCanvas_WndProc (HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar)
{
#ifdef _TX_ALLOW_TRACE
_txInTX++;
if (_txAllowTrace) _txTrace (__FILE__, __LINE__, __TX_FUNCTION__,
"%*s" "0x%X <- 0x%03X (0x%08X, 0x%08lX)", 12 - _txInTX*2, "", wnd, msg, wpar, lpar);
_txInTX--;
#endif
$1 if (msg == WM_KEYDOWN && wpar == VK_F12 &&
GetKeyState (VK_SHIFT) && GetKeyState (VK_CONTROL) && GetKeyState (VK_MENU))
{
$ _txCanvas_OnCmdABOUT (wnd, wpar);
$ return DefWindowProc (wnd, msg, wpar, lpar);
}
WNDPROC altWndProc = _txAltWndProc; // Cache to prevent change from main thread
if (altWndProc)
{
$ LRESULT res = altWndProc (wnd, msg, wpar, lpar);
$ if (res) return res;
}
switch (msg)
{
case WM_CREATE: $ _txCanvas_OnCREATE (wnd); return 0;
case WM_CLOSE: $ if (_txCanvas_OnCLOSE (wnd)) break; else return 0;
case WM_DESTROY: $ _txCanvas_OnDESTROY (wnd); return 0;
case WM_PAINT: $ _txCanvas_OnPAINT (wnd); return 0;
case WM_TIMER: $ _txCanvas_OnTIMER (wnd, wpar); return 0;
case WM_KEYDOWN: $ _txCanvas_OnKEYDOWN (wnd, wpar, lpar); return 0;
case WM_CHAR: $ _txCanvas_OnCHAR (wnd, wpar, lpar); return 0;
case WM_LBUTTONUP:
case WM_LBUTTONDOWN:
case WM_RBUTTONUP:
case WM_RBUTTONDOWN:
case WM_MBUTTONUP:
case WM_MBUTTONDOWN:
case WM_MOUSEMOVE: $ _txCanvas_OnMOUSEMOVE (wnd, wpar, lpar); return 0;
default: break;
}
if (msg == WM_SYSCOMMAND) switch (wpar)
{
case _TX_IDM_ABOUT: $ _txCanvas_OnCmdABOUT (wnd, wpar); return 0;
case _TX_IDM_CONSOLE: $ _txCanvas_OnCmdCONSOLE (wnd, wpar); return 0;
default: break;
}
$ return DefWindowProc (wnd, msg, wpar, lpar);
}
//-----------------------------------------------------------------------------------------------------------------
bool _txCanvas_OnCREATE (HWND wnd)
{
$1 _TX_IF_ARGUMENT_FAILED (wnd) return false;
$ _txCanvas_BackBuf[0] = _txBuffer_Create (wnd); assert (_txCanvas_BackBuf[0]);
$ _txCanvas_BackBuf[1] = _txBuffer_Create (wnd); assert (_txCanvas_BackBuf[1]);
$ SetTimer (wnd, _txCanvas_RefreshTimer, _txWindowUpdateInterval, NULL) asserted;
$ _txCanvas_Window = wnd;
$ txSetDefaults();
$ return true;
}
//-----------------------------------------------------------------------------------------------------------------
bool _txCanvas_OnDESTROY (HWND wnd)
{
$1 _TX_IF_ARGUMENT_FAILED (wnd) return false;
// Èíèöèèðóåì îñòàíîâêó öèêëà ñîîáùåíèé
$ PostQuitMessage (_txRunning? WM_DESTROY : EXIT_SUCCESS);
$ if (!_txCanvas_Window) return false;
// Indicate that we are about to manually terminate
$ _txExit = true;
// Lock GDI resources
$ bool locked = false;
$ _txWaitFor ((locked = txLock (false), locked), _TX_TIMEOUT);
$ if (!locked) TX_DEBUG_ERROR ("Cannot lock GDI to free resources");
// Îñâîáîæäàåì ïîëüçîâàòåëüñêèå ðåñóðñû
$ if (_txCanvas_UserDCs && _txCanvas_UserDCs->size())
{
$ txNotifyIcon (NIIF_ERROR, NULL, "Âû çàáûëè îñâîáîäèòü %d HDC.", (int) _txCanvas_UserDCs->size());
$ Sleep (_TX_TIMEOUT);
$ for (size_t i = 0; i < _txCanvas_UserDCs->size(); i++) _txBuffer_Delete (&_txCanvas_UserDCs->at (i));
$ _txCanvas_UserDCs->clear();
}
// Îñâîáîæäàåì ðåñóðñû, ñâÿçàííûå ñ îêíîì
$ if (_txCanvas_RefreshTimer) KillTimer (wnd, _txCanvas_RefreshTimer) asserted;
$ if (_txCanvas_BackBuf[1]) _txBuffer_Delete (&_txCanvas_BackBuf[1]) asserted;
$ if (_txCanvas_BackBuf[0]) _txBuffer_Delete (&_txCanvas_BackBuf[0]) asserted;
$ txUnlock();
// Indicate that we are destroyed
$ _txCanvas_Window = NULL;
$ return true;
}
//-----------------------------------------------------------------------------------------------------------------
bool _txCanvas_OnCLOSE (HWND wnd)
{
$1 _TX_IF_ARGUMENT_FAILED (wnd && _txCanvas_OK()) return false;
$ if (_txMain && _txRunning &&
txMessageBox ("Ôóíêöèÿ main() íå çàâåðøåíà. Ïðîãðàììà âñå åùå ðàáîòàåò. Ïðåðâàòü àâàðèéíî? \n\n"
"Ëó÷øå ïîäîæäàòü, êîãäà main() çàâåðøèòñÿ - ýòî îòîáðàæàåòñÿ â çàãîëîâêå îêíà.",
txGetModuleFileName (false), MB_OKCANCEL | MB_ICONSTOP) != IDOK) return false;
$ return true;
}
//-----------------------------------------------------------------------------------------------------------------
bool _txCanvas_OnTIMER (HWND wnd, WPARAM)
{
$1 _TX_IF_ARGUMENT_FAILED (wnd) return false;
$ if (_txCanvas_RefreshLock > 0 || !_txRunning) return false;
$ InvalidateRect (wnd, NULL, false) asserted;
$ UpdateWindow (wnd) asserted;
$ return true;
}
//-----------------------------------------------------------------------------------------------------------------
bool _txCanvas_OnPAINT (HWND wnd)
{
$1 _TX_IF_ARGUMENT_FAILED (wnd && _txCanvas_OK()) return false;
$ bool forceRedraw = GetAsyncKeyState (VK_MENU) && GetAsyncKeyState (VK_CONTROL) &&
GetAsyncKeyState (VK_SHIFT) && GetAsyncKeyState (VK_SNAPSHOT);
$ PAINTSTRUCT ps = {0};
$ HDC dc = BeginPaint (wnd, &ps);
$ if (!dc) return false;
$ RECT r = {0};
$ GetClientRect (wnd, &r) asserted;
$ POINT size = { r.right - r.left, r.bottom - r.top };
$ if ((_txCanvas_RefreshLock <= 0 || forceRedraw) &&
txLock (false))
{
$ Win32::BitBlt (_txCanvas_BackBuf[1], 0, 0, size.x, size.y, txDC(), 0, 0, SRCCOPY);
$ _txConsole_Draw (_txCanvas_BackBuf[1]);
$ txUnlock();
}
// Magic 100500 value is used to completely block screen refresh.
// Since no value can be 100500 or above, this condition is always true and the refresh cannot be blocked IRL.
// Do not use 100501 because it may lead to errors on some compilers and possible may crash the compilers
// themselves.
// Yes guys, with all your software installed. :(
$ if (_txCanvas_RefreshLock != 100500)
{ $ Win32::BitBlt (dc, 0, 0, size.x, size.y, _txCanvas_BackBuf[1], 0, 0, SRCCOPY); }
$ EndPaint (wnd, &ps) asserted;
$ return true;
}
//-----------------------------------------------------------------------------------------------------------------
bool _txCanvas_OnKEYDOWN (HWND, WPARAM vk, LPARAM info)
{
$1 INPUT_RECORD evt = {0};
$ evt.EventType = KEY_EVENT;
$ evt.Event.KeyEvent.bKeyDown = true;
$ evt.Event.KeyEvent.wRepeatCount = 1;
$ evt.Event.KeyEvent.uChar.AsciiChar = (unsigned char) MapVirtualKey ((WORD) vk, 2); // 2 == MAPVK_VK_TO_CHAR
$ evt.Event.KeyEvent.wVirtualScanCode = (unsigned char) (info >> 16);
$ evt.Event.KeyEvent.wVirtualKeyCode = (WORD) vk;
$ evt.Event.KeyEvent.dwControlKeyState = (info & (1 << 24))? ENHANCED_KEY : 0;
$ if (evt.Event.KeyEvent.uChar.AsciiChar) return false; // Let TranslateMessage() and WM_CHAR do the job
$ DWORD written = 0;
$ WriteConsoleInput (GetStdHandle (STD_INPUT_HANDLE), &evt, 1, &written);
$ return false;
}
//-----------------------------------------------------------------------------------------------------------------
bool _txCanvas_OnCHAR (HWND, WPARAM ch, LPARAM info)
{
$1 INPUT_RECORD evt = {0};
$ evt.EventType = KEY_EVENT;
$ evt.Event.KeyEvent.bKeyDown = true;
$ evt.Event.KeyEvent.wRepeatCount = 1;
$ evt.Event.KeyEvent.uChar.AsciiChar = (unsigned char) (ch);
$ evt.Event.KeyEvent.wVirtualScanCode = (unsigned char) (info >> 16);
$ evt.Event.KeyEvent.wVirtualKeyCode = (WORD) MapVirtualKey ((WORD) (info >> 16), 3); // 3 == MAPVK_VSC_TO_VK_EX
$ evt.Event.KeyEvent.dwControlKeyState = 0;
$ DWORD written = 0;
$ WriteConsoleInput (GetStdHandle (STD_INPUT_HANDLE), &evt, 1, &written);
$ return true;
}
//-----------------------------------------------------------------------------------------------------------------
bool _txCanvas_OnMOUSEMOVE (HWND, WPARAM buttons, LPARAM coords)
{
$1 _TX_IF_ARGUMENT_FAILED (_txCanvas_OK()) return false;
$ _txMousePos.x = LOWORD (coords);
$ _txMousePos.y = HIWORD (coords);
$ _txMouseButtons = (int) buttons;
$ return true;
}
//-----------------------------------------------------------------------------------------------------------------
bool _txCanvas_OnCmdCONSOLE (HWND wnd, WPARAM cmd)
{
$1 _TX_IF_ARGUMENT_FAILED (wnd) return false;
$ HWND console = Win32::GetConsoleWindow();
$ if (!console) return false;
$ bool visible = !!IsWindowVisible (console);
$ ShowWindow (console, visible? SW_HIDE : SW_SHOW);
$ visible = !!IsWindowVisible (console);
$ CheckMenuItem (GetSystemMenu (wnd, false), (int) cmd, visible? MF_CHECKED : MF_UNCHECKED);
$ return true;
}
//-----------------------------------------------------------------------------------------------------------------
bool _txCanvas_OnCmdABOUT (HWND, WPARAM)
{
$1 //{ Overriding the missing names, if the set is uncomplete
#if defined (__MODULE)
#define ABOUT_NAME_ __MODULE
#else
#define ABOUT_NAME_ "TXLib"
#endif
#if defined (__MODULE) || defined (__VERSION) || defined (__DESCRIPTION) || defined (__AUTHOR)
#ifndef __MODULE
#define __MODULE "TXLib" "\n" "#define __MODULE to set the name.\n"
#endif
#ifndef __VERSION
#define __VERSION "(0.000000000)." "\n" "#define __VERSION to set the string value.\n"
#endif
#ifndef __DESCRIPTION
#define __DESCRIPTION "(Äà, ìíå ëåíü çàäàòü îïèñàíèå)." "\n" "#define __DESCRIPTION to override project role.\n"
#endif
#ifndef __AUTHOR
#define __AUTHOR "(Íåïîíÿòíî êòî)." "\n" "#define __AUTHOR to override this name."
#endif
#endif
//}
$ time_t timeT = time (NULL) - clock()/CLOCKS_PER_SEC;
$ char timeS[32] = "";
$ ctime_s (timeS, sizeof (timeS), &timeT);
$ static char text[_TX_BUFSIZE] = "";
$ char cwd [MAX_PATH] = "";
$ _snprintf_s (text, sizeof (text) - 1 _TX_TRUNCATE,
"Application:\n"
#if defined (__MODULE) || defined (__VERSION) || defined (__DESCRIPTION) || defined (__AUTHOR)
__MODULE " version " __VERSION "\n" __DESCRIPTION "\n" "Copyright (c) " __AUTHOR "\n"
#else
"Çäåñü ìîãëà áû áûòü Âàøà ðåêëàìà :)\n"
"#define __MODULE to \"your program name\" before including TXLib.h to use this billboard...\n"
#endif
"\n" "Developed with:\n\n"
"The Dumb Artist Library (TX Library) - " _TX_VERSION "\n" _TX_AUTHOR "\n"
"See license on: http://txlib.ru\n\n"
"TXLib file:" "\t" __FILE__ "\n"
"Compiled:" "\t" __DATE__ " " __TIME__ ", " _TX_BUILDMODE ", " __TX_COMPILER__ "\n"
"Started:" "\t" "%.6s %.4s %.8s\n\n"
"Run file:" "\t" "%s\n"
"Directory:" "\t" "%s",
timeS + 4, timeS + 20, timeS + 11, // These offsets are ANSI standardized
txGetModuleFileName(),
_getcwd (cwd, sizeof (cwd) - 1));
$ txMessageBox (text, "About " ABOUT_NAME_, MB_ICONINFORMATION);
// And a bit of HTTP-code in C++ function:
goto http;
http://txlib.ru // See valuable refs here :)
$ return true;
#undef ABOUT_NAME_
}
//! @}
//}
//=================================================================================================================
//=================================================================================================================
//{ [Internal] Console-support functions (_txConsole...)
//! @name Ôóíêöèè êîíñîëüíîãî îêíà (_txConsole...)
//=================================================================================================================
//! @{
HWND _txConsole_Attach()
{
$1 HWND console = Win32::GetConsoleWindow();
$ if (!console)
{
$ FreeConsole();
$ AllocConsole();
}
$ console = Win32::GetConsoleWindow();
$ if (!console) return NULL;
// Linux::Wine v1.2.2+ compatibility.
// Beer compatibility will be added in future versions.
// Ìèíçäðàâ ÐÔ ïðåäóïðåæäàåò: ÷ðåçìåðíîå óïîòðåáëåíèå wine âðåäèò Âàøåìó çäîðîâüþ.
$ if (Win32::wine_get_version)
{
$ Win32::GetNumberOfConsoleFonts = NULL;
$ Win32::GetCurrentConsoleFont = NULL;
$ Win32::SetConsoleFont = NULL;
}
// Óñòàíàâëèâàåì ðóññêóþ êîäîâóþ ñòðàíèöó äëÿ êîíñîëè Windows
$ SetConsoleCP (_TX_CP); // 1251
$ SetConsoleOutputCP (_TX_CP); // 1251
// Óñòàíàâëèâàåì ðóññêóþ êîäîâóþ ñòðàíèöó äëÿ ñòàíäàðòíîé áèáëèîòåêè, èíà÷å íå áóäóò ðàáîòàòü Unicode-âåðñèè
// ôóíêöèé (wprintf, ...). Åñëè êîìïèëèòå ñ ïîìîùüþ gcc è ñîáèðàåòåñü èñïîëüçîâàòü L"unicode-ñòðîêè" ñ ðóññêèì
// ÿçûêîì, óêàæèòå îïöèè â êîìàíäíîé ñòðîêå êîìïèëÿòîðà g++: -finput-charset=CP1251 -fexec-charset=CP1251.
$ setlocale (LC_CTYPE, _TX_LC_CTYPE); // "Russian"
$ if (!Win32::wine_get_version) _wsetlocale (LC_CTYPE, _TX_LC_CTYPE_W); // L"Russian_Russia.ACP"
$ static bool done = false;
$ if (done) return console;
// Âïå÷àòëèòåëüíûì ëó÷øå ñþäà íå ñìîòðåòü.
$ if (!Win32::wine_get_version)
{ $ _txConsole_SetUnicodeFont(); }
#ifndef _CONSOLE
// Ïåðåîòêðûâàåì çàíîâî <s>Àìåðèêó</s> ïîòîêè ââîäà-âûâîäà, åñëè subsystem != console
$ *stdin = *_fdopen (_open_osfhandle ((DWORD)(ptrdiff_t) GetStdHandle (STD_INPUT_HANDLE), _O_TEXT), "r");
$ fflush (stdout); *stdout = *_fdopen (_open_osfhandle ((DWORD)(ptrdiff_t) GetStdHandle (STD_OUTPUT_HANDLE), _O_TEXT), "w");
$ fflush (stderr); *stderr = *_fdopen (_open_osfhandle ((DWORD)(ptrdiff_t) GetStdHandle (STD_ERROR_HANDLE), _O_TEXT), "w");
$ setvbuf (stdin, NULL, _IONBF, 0);
$ setvbuf (stdout, NULL, _IONBF, 0);
$ setvbuf (stderr, NULL, _IONBF, 0);
$ std::ios::sync_with_stdio();
#endif
// That's all, folks
$ done = true;
$ return console;
}
//-----------------------------------------------------------------------------------------------------------------
inline bool _txConsole_OK()
{
$1 return Win32::GetConsoleWindow() != NULL;
}
//-----------------------------------------------------------------------------------------------------------------
bool _txConsole_Detach (bool activate)
{
$1 HWND console = Win32::GetConsoleWindow();
$ if (!console) return false;
$ EnableWindow (console, true);
$ ShowWindow (console, SW_SHOW);
$ if (activate)
{
$ SetForegroundWindow (console);
$ BringWindowToTop (console);
}
$ return !!FreeConsole();
}
//-----------------------------------------------------------------------------------------------------------------
bool _txConsole_Draw (HDC dc)
{
$1 _TX_IF_ARGUMENT_FAILED (dc) return false;
$ HANDLE out = GetStdHandle (STD_OUTPUT_HANDLE);
$ CONSOLE_SCREEN_BUFFER_INFO con = {{0}};
$ BOOL ok = GetConsoleScreenBufferInfo (out, &con);
$ if (!ok) return false;
$ POINT size = { con.srWindow.Right - con.srWindow.Left + 1,
con.srWindow.Bottom - con.srWindow.Top + 1 };
$ SIZE fontSz = { 12, 16 };
$ Win32::GetTextExtentPoint32 (dc, "W", 1, &fontSz) asserted;
$ COLORREF pal [16] = { 0x000000, 0x800000, 0x008000, 0x808000, 0x000080, 0x800080, 0x008080, 0xC0C0C0,
0x808080, 0xFF0000, 0x00FF00, 0xFFFF00, 0x0000FF, 0xFF00FF, 0x00FFFF, 0xFFFFFF };
$ for (int y = 0; y < size.y; y++)
{
static char chr [_TX_BUFSIZE + 1] = ""; // [con.dwSize.X + 1]; maybe will be truncated
static WORD atr [_TX_BUFSIZE + 1] = {0}; // [con.dwSize.X + 1]; maybe will be truncated
COORD coord = { (short) (con.srWindow.Left), (short) (y + con.srWindow.Top) };
DWORD read = 0;
if (!ReadConsoleOutputCharacter (out, chr, SIZEARR (chr) - 1, coord, &read)) continue;
if (!ReadConsoleOutputAttribute (out, atr, SIZEARR (atr) - 1, coord, &read)) continue;
for (int x = 0, xEnd = size.x; x < size.x; x = xEnd)
{
Win32::SetTextColor (dc, pal [ atr[x] & 0x0F]);
Win32::SetBkColor (dc, pal [(atr[x] >> 4) & 0x0F]);
Win32::SetBkMode (dc, (atr[x] & 0xF0)? OPAQUE : TRANSPARENT);
for (xEnd = x+1; atr[xEnd] == atr[x] && xEnd < size.x; xEnd++) ;
Win32::TextOut (dc, ROUND (fontSz.cx * (x + con.srWindow.Left)),
ROUND (fontSz.cy * y), chr + x, xEnd - x) asserted;
}
}
$ Win32::SetTextColor (dc, pal [ con.wAttributes & 0x0F]);
$ Win32::SetBkColor (dc, pal [(con.wAttributes >> 4) & 0x0F]);
$ Win32::SetBkMode (dc, TRANSPARENT);
$ if (_txConsole_IsBlinking &&
In (con.dwCursorPosition, con.srWindow) &&
GetTickCount() % _txCursorBlinkInterval*2 > _txCursorBlinkInterval &&
GetForegroundWindow() == txWindow())
{
$ Win32::TextOut (dc, ROUND (fontSz.cx * (con.dwCursorPosition.X - con.srWindow.Left)),
ROUND (fontSz.cy * (con.dwCursorPosition.Y - con.srWindow.Top)) + 1,
"_", 1) asserted;
}
$ return true;
}
//-----------------------------------------------------------------------------------------------------------------
//{ Welcome to the Duck Side! Together we will rule the Bathroom!
//-----------------------------------------------------------------------------------------------------------------
bool _txConsole_SetUnicodeFont()
{
// Íà÷èíàÿ ñ Âèñòû âñå õîðîøî...
$1 if (Win32::GetCurrentConsoleFontEx && Win32::SetCurrentConsoleFontEx)
{
$ HANDLE out = GetStdHandle (STD_OUTPUT_HANDLE);
$ Win32::CONSOLE_FONT_INFOEX info = { sizeof (info) };
$ if (!Win32::GetCurrentConsoleFontEx (out, false, &info)) return false;
$ info.FontFamily = 0x36; // Unicode fixed-pitch
$ if (!*info.FaceName) info.dwFontSize.Y = (SHORT) (info.dwFontSize.Y + 2); // Terminal font is too small
$ wcsncpy_s (info.FaceName, L"Lucida Console", SIZEARR (info.FaceName));
$ return !!Win32::SetCurrentConsoleFontEx (out, false, &info);
}
// ...à äî ýòîãî âñå íå òàê ñëàäêî
$ const unsigned uniFont = 10; // The Internet and W2K sources know this magic number
$ const unsigned uniSize = 20; // Size of the font desired, should be > max of Raster Fonts
$ bool ok = true;
// Force Windows to use Unicode font by creating and run the console shortcut tuned to use that font.
$ HANDLE out = GetStdHandle (STD_OUTPUT_HANDLE);
$ if (Win32::GetNumberOfConsoleFonts && Win32::GetNumberOfConsoleFonts() <= uniFont)
{
$ HRESULT init = Win32::CoInitialize (NULL);
$ size_t sz = 0;
$ char link [MAX_PATH] = "";
$ getenv_s (&sz, link, sizeof (link) - 1, "TEMP");
$ strncat_s (link, "\\~txLink.lnk", sizeof (link) - 1);
$ char comspec [MAX_PATH] = "";
$ getenv_s (&sz, comspec, sizeof (comspec), "COMSPEC");
$ (void) _unlink (link);
$ _txCreateShortcut (link, comspec, "/c exit", NULL, NULL, SW_SHOWMINNOACTIVE, NULL, 0, uniSize) asserted;
$ ok = (Win32::ShellExecuteA (NULL, NULL, link, NULL, NULL, SW_SHOWMINNOACTIVE) > (void*)32); // Sic!
if (ok) { $ _txWaitFor (FindWindow (NULL, "~txLink"), _TX_TIMEOUT); }
$ (void) _unlink (link);
$ if (init == S_OK) Win32::CoUninitialize();
}
// If Unicode font is not already set, do set it.
$ CONSOLE_FONT_INFO cur = {0};
if (Win32::GetCurrentConsoleFont) { $ Win32::GetCurrentConsoleFont (out, false, &cur); }
$ ok &= (cur.nFont >= uniFont);
if (!ok) { $ ok &= Win32::SetConsoleFont && Win32::SetConsoleFont (out, uniFont); }
$ HWND console = Win32::GetConsoleWindow();
$ InvalidateRect (console, NULL, false);
$ UpdateWindow (console);
$ return ok;
}
//-----------------------------------------------------------------------------------------------------------------
//{ The nightmare helpers
#define _TX_TRY { goto __tx_try; } __tx_try: { int __tx_error = S_OK; (void)__tx_error;
#define _TX_CHECKED( cmd ) { if (FAILED (__tx_error = (cmd))) goto __tx_catch; }
#define _TX_FAIL { __tx_error = E_FAIL; goto __tx_catch; }
#define _TX_RETRY { __tx_error = S_OK; goto __tx_try; }
#define _TX_OK ( SUCCEEDED (__tx_error) )
#define _TX_CATCH goto __tx_finally; __tx_catch:
#define _TX_RETURN goto __tx_finally;
#define _TX_FINALLY __tx_finally:
#define _TX_ENDTRY }
//}
//-----------------------------------------------------------------------------------------------------------------
// Ìàëî íå ïîêàæåòñÿ
bool _txCreateShortcut (const char shortcutName[],
const char fileToLink[], const char args[] /*= NULL*/, const char workDir[] /*= NULL*/,
const char description[] /*= NULL*/, int cmdShow /*= SW_SHOWNORMAL*/, const char iconFile[] /*= NULL*/, int iconIndex /*= 0*/,
int fontSize /*= 0*/, COORD bufSize /*= ZERO (COORD)*/, COORD wndSize /*= ZERO (COORD)*/, COORD wndOrg /*=ZERO (COORD)*/)
{
$1 _TX_IF_ARGUMENT_FAILED (shortcutName && *shortcutName) return false;
$ _TX_IF_ARGUMENT_FAILED (fileToLink && *fileToLink) return false;
$ IShellLink* shellLink = NULL;
$ Win32::IShellLinkDataList* dataList = NULL;
$ IPersistFile* file = NULL;
$ HRESULT init = Win32::CoInitialize (NULL);
_TX_TRY
{
$ _TX_CHECKED (Win32::CoCreateInstance (CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, Win32::IID_IShellLink, (void**) &shellLink));
$ if (!shellLink) _TX_FAIL;
$ shellLink->SetPath (fileToLink);
$ shellLink->SetArguments (args);
$ shellLink->SetWorkingDirectory (workDir);
$ shellLink->SetDescription (description);
$ shellLink->SetShowCmd (cmdShow);
$ shellLink->SetIconLocation (iconFile, iconIndex);
$ _TX_CHECKED (shellLink->QueryInterface (Win32::IID_IShellLinkDataList, (void**) &dataList));
$ if (!dataList) _TX_FAIL;
$ Win32::NT_CONSOLE_PROPS props =
{{sizeof (props), NT_CONSOLE_PROPS_SIG},
0x07, 0xF5, // wFillAttribute, wPopupFillAttribute
{bufSize.X, bufSize.Y}, // dwScreenBufferSize
{wndSize.X, wndSize.Y}, // dwWindowSize
{wndOrg.X, wndOrg.Y}, // dwWindowOrigin
0, // nFont
0, // nInputBufferSize
{0, (short) fontSize}, // dwFontSize
0x36, 400, L"Lucida Console", // uFontFamily, uFontWeight, FaceName. We're dancing for this!
15, // uCursorSize
0, 1, 1, 0, // bFullScreen, bQuickEdit, bInsertMode, bAutoPosition
50, 4, 0, // uHistoryBufferSize, uNumberOfHistoryBuffers, bHistoryNoDup
{0x000000, 0x800000, 0x008000, 0x808000, 0x000080, 0x800080, 0x008080, 0xC0C0C0,
0x808080, 0xFF0000, 0x00FF00, 0xFFFF00, 0x0000FF, 0xFF00FF, 0x00FFFF, 0xFFFFFF}
};
$ _TX_CHECKED (dataList->AddDataBlock (&props));
$ _TX_CHECKED (shellLink->QueryInterface (Win32::IID_IPersistFile, (void**) &file));
$ if (!file) _TX_FAIL;
$ wchar_t wName[MAX_PATH] = L"";
$ MultiByteToWideChar (_TX_CP, 0, shortcutName, -1, wName, MAX_PATH) || ZeroMemory (wName, sizeof (wName));
$ _TX_CHECKED (file->Save (wName, true));
}
$ _TX_CATCH
$ _TX_FINALLY
$ if (file) file ->Release();
$ if (dataList) dataList ->Release();
$ if (shellLink) shellLink->Release();
$ if (init == S_OK) Win32::CoUninitialize();
$ return _TX_OK;
_TX_ENDTRY
}
//}
//-----------------------------------------------------------------------------------------------------------------
//! @}
//}
//=================================================================================================================
//=================================================================================================================
//{ [Internal] Memory DC functions (_txBuffer...)
//! @name Ôóíêöèè "âèðòóàëüíîãî õîëñòà" (ãðàôè÷åñêîãî áóôåðà, _txBuffer...)
//=================================================================================================================
//! @{
HDC _txBuffer_Create (HWND wnd, const POINT* size, HBITMAP bitmap)
{
$1 txAutoLock _lock;
$ HDC wndDC = GetDC (wnd);
$ if (!wndDC) return NULL;
$ RECT r = {0};
$ if (wnd) GetClientRect (wnd, &r) asserted;
$ POINT sz = { r.right - r.left, r.bottom - r.top };
$ if (!size) size = &sz;
$ HDC dc = Win32::CreateCompatibleDC (wndDC);
$ if (!dc) TX_DEBUG_ERROR ("Cannot create buffer: CreateCompatibleDC() failed");
$ HBITMAP bmap = bitmap? bitmap : Win32::CreateCompatibleBitmap (wndDC, size->x, size->y);
$ if (!bmap) TX_DEBUG_ERROR ("Cannot create buffer: CreateCompatibleBitmap() failed");
$ Win32::SelectObject (dc, bmap) asserted;
$ if (!bitmap) Win32::PatBlt (dc, 0, 0, size->x, size->y, BLACKNESS) asserted;
$ ReleaseDC (wnd, wndDC) asserted;
$ return dc;
}
//-----------------------------------------------------------------------------------------------------------------
bool _txBuffer_Delete (HDC* dc)
{
$1 _TX_IF_ARGUMENT_FAILED (dc) return false;
$ if (!*dc) return false;
$ if (!Win32::GetObjectType (Win32::GetCurrentObject (*dc, OBJ_BITMAP))) return false;
$ txAutoLock _lock;
$ _txBuffer_Select (Win32::GetStockObject (NULL_PEN), *dc) asserted;
$ _txBuffer_Select (Win32::GetStockObject (NULL_BRUSH), *dc) asserted;
$ _txBuffer_Select (Win32::GetStockObject (SYSTEM_FONT), *dc) asserted;
$ _txBuffer_Select (Win32::CreateCompatibleBitmap (*dc, 0, 0), *dc) asserted;
$ Win32::DeleteObject (Win32::GetCurrentObject (*dc, OBJ_BITMAP)) asserted;
$ Win32::DeleteDC (*dc) asserted;
$ *dc = NULL;
$ return true;
}
//-----------------------------------------------------------------------------------------------------------------
bool _txBuffer_Select (HGDIOBJ obj, HDC dc /*= txDC()*/)
{
$1 _TX_IF_ARGUMENT_FAILED (obj) return false;
$ _TX_IF_ARGUMENT_FAILED (dc) return false;
$ if (!Win32::GetObjectType (obj)) TX_DEBUG_ERROR ("Invalid GDI object type");
$ txAutoLock _lock;
$ obj = Win32::SelectObject (dc, obj);
$ if (obj) Win32::DeleteObject (obj) asserted;
$ return obj != NULL;
}
//! @}
//}
//=================================================================================================================
//=================================================================================================================
//{ Diagnostics
//! @name Äèàãíîñòèêà
//=================================================================================================================
//! @{
void _txOnSignal (int sig/* = 0*/, int fpe/* = 0*/)
{
if (!sig && !fpe)
{
$1 signal (SIGSEGV, (void(*)(int))_txOnSignal) != SIG_ERR asserted;
$ signal (SIGFPE, (void(*)(int))_txOnSignal) != SIG_ERR asserted;
$ signal (SIGABRT, (void(*)(int))_txOnSignal) != SIG_ERR asserted;
$ signal (SIGILL, (void(*)(int))_txOnSignal) != SIG_ERR asserted;
$ signal (SIGTERM, (void(*)(int))_txOnSignal) != SIG_ERR asserted;
$ return;
}
const char* sSig = ": Íåèçâåñòíûé òèï ñèãíàëà";
const char* sFPE = ": Íåèçâåñòíûé òèï èñêëþ÷åíèÿ";
#define GET_DESCR_( str, code, descr ) case (code): { (str) = #code ": " descr; break; }
switch (sig)
{
GET_DESCR_ (sSig, SIGSEGV, "Äîñòóï ïî íåâåðíîìó óêàçàòåëþ. Ñòàâüòå àññåðòû!")
GET_DESCR_ (sSig, SIGILL, "Ïîïûòêà âûïîëíèòü íåäîïóñòèìóþ îïåðàöèþ. Ïðîâåðüòå óêàçàòåëè íà ôóíêöèè.")
GET_DESCR_ (sSig, SIGABRT, "Àâàðèéíîå çàâåðøåíèå ïðîãðàììû, âûçâàíà ôóíêöèÿ abort().")
GET_DESCR_ (sSig, SIGTERM, "Ïîëó÷åí ñèãíàë ïðèíóäèòåëüíîãî çàâåðøåíèÿ ïðîãðàììû.")
GET_DESCR_ (sSig, SIGFPE, "Ãðóáàÿ îøèáêà â âû÷èñëåíèÿõ, äåëåíèå íà 0 èëè ÷òî-íèáóäü åùå")
default: break;
}
if (sig == SIGFPE) switch (fpe)
{
GET_DESCR_ (sFPE, 0x81 /* _FPE_INVALID */, "Ðåçóëüòàò íåâåðåí")
GET_DESCR_ (sFPE, 0x82 /* _FPE_DENORMAL */, "Äåíîðìàëèçàöèÿ")
GET_DESCR_ (sFPE, 0x83 /* _FPE_ZERODIVIDE */, "Äåëåíèå íà íîëü")
GET_DESCR_ (sFPE, 0x84 /* _FPE_OVERFLOW */, "Ðåçóëüòàò ñëèøêîì áîëüøîé")
GET_DESCR_ (sFPE, 0x85 /* _FPE_UNDERFLOW */, "Ðåçóëüòàò ñëèøêîì ìàëåíüêèé")
GET_DESCR_ (sFPE, 0x86 /* _FPE_INEXACT */, "Íåòî÷íûé ðåçóëüòàò")
GET_DESCR_ (sFPE, 0x87 /* _FPE_UNEMULATED */, "Îïåðàöèÿ íå ïîääåðæèâàåòñÿ")
GET_DESCR_ (sFPE, 0x88 /* _FPE_SQRTNEG */, "Êâàäðàòíûé êîðåíü èç îòðèöàòåëüíîãî ÷èñëà")
GET_DESCR_ (sFPE, 0x8A /* _FPE_STACKOVERFLOW */, "Ïåðåïîëíåíèå ñòåêà ñîïðîöåññîðà")
GET_DESCR_ (sFPE, 0x8B /* _FPE_STACKUNDERFLOW */, "Â ñòåêå ñîïðîöåññîðà íå õâàòàåò äàííûõ")
GET_DESCR_ (sFPE, 0x8C /* _FPE_EXPLICITGEN */, "ßâíûé âûçîâ èñêëþ÷åíèÿ")
default: break;
}
#undef GET_DESCR_
_fpreset();
if (sig == SIGFPE && fpe)
_txError (NULL, 0, NULL, "signal (%d, 0x%02X): %s, %s." _ sig _ fpe _ sSig _ sFPE);
else
_txError (NULL, 0, NULL, "signal (%d): %s" _ sig _ sSig);
_txExit = true;
_txCleanup();
}
//-----------------------------------------------------------------------------------------------------------------
void _txOnUnexpected()
{
_txError (NULL, 0, NULL,
"std::unexpected(): Íåîáðàáîòàííîå èñêëþ÷åíèå. Ïðîâåðüòå ñâîè catch-áëîêè. Ïåðåõâàòèòå catch (...). \n\n"
"Åñëè âû (çðÿ) èñïîëüçóåòå ñïåöèôèêàöèþ èñêëþ÷åíèé äëÿ ôóíêöèé, ïðîâåðüòå, íå íàðóøåíà ëè îíà.");
}
//-----------------------------------------------------------------------------------------------------------------
void _txOnTerminate()
{
_txError (NULL, 0, NULL,
"std::terminate(): Ïðîãðàììà áóäåò çàâåðøåíà èç-çà íåïåðåõâà÷åííîãî èñêëþ÷åíèÿ â ôóíêöèè main() èëè â äåñòðóêòîðå. \n\n"
"Èñïîëüçóéòå try/catch áëîêè, ïåðåõâàòûâàéòå catch (...), ðàçáèðàéòåñü, â ÷åì äåëî.");
}
//-----------------------------------------------------------------------------------------------------------------
const char* _txError (const char file[] /*= NULL*/, int line /*= 0*/, const char func[] /*= NULL*/,
const char msg [] /*= NULL*/, ...)
{
va_list arg; va_start (arg, msg);
static int nCalls = 0; nCalls++;
DWORD winerr = GetLastError();
int crterr = errno;
int doserr = _doserrno;
unsigned threadId = GetCurrentThreadId();
bool isFatal = (msg && *msg == '\a')? (msg++, true) : false;
bool fmtOnly = (msg && *msg == '\f')? (msg++, true) : false;
static char what[_TX_BIGBUFSIZE] = "";
static char str [_TX_BIGBUFSIZE] = "";
char *s = what;
#define SZARG_(n) sizeof (what) - 1 - (n) - (s-what) _TX_TRUNCATE
s += _snprintf_s (s, SZARG_(1), "TXLib ñîîáùàåò:\n\n");
s += _snprintf_s (s, SZARG_(1), "Ïðîãðàììà: %s, ", txGetModuleFileName());
if (file) s += _snprintf_s (s, SZARG_(1), "ôàéë: %s, ", file);
if (line) s += _snprintf_s (s, SZARG_(1), "ñòðîêà: %d, ", line);
if (func) s += _snprintf_s (s, SZARG_(1), "ôóíêöèÿ: %s.", func);
s += _snprintf_s (s, SZARG_(1), "\n\n");
if (msg) s += _snprintf_s (s, SZARG_(1), "%s: ", (file || line || func)? "Ñîîáùåíèå" : "ÂÍÅÇÀÏÍÎ"),
s += _vsnprintf_s (s, SZARG_(1), msg, arg),
s += _snprintf_s (s, SZARG_(1), "\n\n");
s += _snprintf_s (s, SZARG_(1), "#%d: %s, Instance: 0x%p, Flags: %c%c%c%c%c%c, Thread: 0x%08X%s",
nCalls, _TX_VERSION, (void*) &_txInitialized,
"cC"[_txConsole], "mM"[_txMain], "dD"[_txIsDll], "rR"[_txRunning], "eE"[_txExit], "tT"[_txAllowTrace],
threadId,
(threadId == _txMainThreadId)? " (Main)" :
(threadId == _txCanvas_ThreadId)? " (Canvas)" : "");
if (winerr) s += _snprintf_s (s, SZARG_(0), ", GetLastError(): %lu (", winerr),
s += FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, winerr, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
s, (DWORD) (sizeof (what) - (s-what)), NULL) - 2,
s -= (s[-1] == '.')? 1 : 0,
s += _snprintf_s (s, SZARG_(1), ")");
if (crterr) s += _snprintf_s (s, SZARG_(1), ", errno: %d (%s)", crterr, (strerror_s (str, crterr), str));
if (doserr) s += _snprintf_s (s, SZARG_(1), ", _doserrno: %d (%s)", doserr, (strerror_s (str, doserr), str));
s += _snprintf_s (s, SZARG_(1), ". %s\n", std::uncaught_exception()? "std::uncaught_exception(): true." : "");
if (_txInTX > 0 && !(_txLine == line && file && _stricmp (_txFile, file) == 0))
s += _snprintf_s (s, SZARG_(1), "From: %s (%d) %s.\n", _txFile, _txLine, _txFunc);
#undef SZARG_
va_end (arg);
struct tools
{
static char* compressSpaces (char* dest, const char* src)
{
char* dst = dest;
for (char last = ' '; *src; src++)
if (isspace ((unsigned char)(*src))) { if (last != ' ') *dst++ = last = ' '; }
else *dst++ = last = *src;
if (dst > dest && dst[-1] == ' ') dst--;
*dst++ = '\n'; *dst++ = 0;
return dest;
}
static char* replace (char* dest, const char* src, char find, char repl)
{
size_t i = 0;
for (; src[i]; i++) dest[i] = (src[i] == find)? repl : src[i];
dest[i] = 0;
return dest;
}
};
$ txOutputDebugPrintf ("%s - %s", _TX_VERSION, tools::compressSpaces (str, what));
if (fmtOnly) return what;
tools::replace (str, what, '\v', ' ');
printf ("\n" "--------------------------------------------------\n"
"%s"
"--------------------------------------------------\n", str);
tools::replace (str, what, '\v', '\n');
txMessageBox (str, isFatal? "Ôàòàëüíàÿ îøèáêà" : "Îøèáêà â ïðîãðàììå", MB_ICONSTOP | MB_TOPMOST | MB_SYSTEMMODAL);
if (!isFatal) return what;
if (!IsDebuggerPresent()) exit (EXIT_FAILURE);
// vvvvvvvvvvvvvvvvvv
DebugBreak(); //>>> Âû â îòëàä÷èêå. Åñòü øàíñ ïîñìîòðåòü ïåðåìåííûå è ðàçîáðàòüñÿ.
// ^^^^^^^^^^^^^^^^^^
return what; //>>> Óõîäèòå èç ôóíêöèè ïîøàãîâîé îòëàäêîé (F10/F11). Ñëåäèòå çà ñòåêîì âûçîâîâ (Alt+7).
}
//-----------------------------------------------------------------------------------------------------------------
int txOutputDebugPrintf (const char format[], ...)
{
if (!format) return 0;
bool msgbox = (*format == '\a')? (format++, true) : false;
bool print = (*format == '\f')? (format++, true) : false;
char str[_TX_BIGBUFSIZE] = "";
va_list arg; va_start (arg, format);
int n = _vsnprintf_s (str, sizeof (str) - 1 _TX_TRUNCATE, format, arg);
va_end (arg);
OutputDebugString (str);
if (print)
fprintf (stderr, "%s", str);
if (msgbox)
txMessageBox (str, "Îêàçûâàåòñÿ, ÷òî", MB_ICONEXCLAMATION | MB_TOPMOST);
return n;
}
//-----------------------------------------------------------------------------------------------------------------
unsigned txMessageBox (const char* text, const char* header, unsigned flags /*= 0*/)
{
static wchar_t textW [_TX_BIGBUFSIZE * sizeof (wchar_t)] = L"[NULL text]";
static wchar_t headerW [_TX_BUFSIZE * sizeof (wchar_t)] = L"[NULL header]";
if (text) MultiByteToWideChar (_TX_CP, 0, text, -1, textW, SIZEARR (textW)) || memset (textW, 0, sizeof (textW));
if (header) MultiByteToWideChar (_TX_CP, 0, header, -1, headerW, SIZEARR (headerW)) || memset (headerW, 0, sizeof (headerW));
HWND wnd = _txCanvas_Window;
return MessageBoxW ((wnd? wnd : Win32::GetConsoleWindow()), textW, headerW, flags | MB_SETFOREGROUND | MB_TOPMOST);
}
//-----------------------------------------------------------------------------------------------------------------
const char* txGetModuleFileName (bool fileNameOnly /*= true*/)
{
static char name[MAX_PATH] = "";
if (!*name) GetModuleFileName (NULL, name, sizeof (name) - 1) || strcpy_s (name, "");
assert (*name);
if (fileNameOnly) return name;
static char fullName[MAX_PATH] = "";
strncpy_s (fullName, name, sizeof (fullName) - 1);
char* title = strrchr (fullName, '\\'); if (!title) title = fullName;
char* ext = strrchr (fullName, '.'); if (!ext) ext = fullName + strlen (fullName);
size_t sz = sizeof (fullName) - (ext - fullName) - 1;
#if defined (_CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES) && _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES
strncpy_s (ext, sz, " - TXLib", sz);
#else
strncpy (ext, " - TXLib", sz);
#endif
return title + 1;
}
//-----------------------------------------------------------------------------------------------------------------
bool txNotifyIcon (unsigned flags, const char title[], const char format[], ...)
{
$1 _TX_IF_ARGUMENT_FAILED (format) return false;
$ va_list arg; va_start (arg, format);
$ bool ok = true;
#if defined (_WIN32_IE) && (_WIN32_IE >= 0x0500)
$ NOTIFYICONDATA nid = { sizeof (nid) };
$ nid.uFlags = NIF_ICON | NIF_TIP | NIF_INFO;
$ nid.hWnd = NULL;
$ nid.uID = 1;
$ nid.hIcon = _txCreateTXIcon (16); assert (nid.hIcon);
$ strncpy_s (nid.szTip, "TXLib Information", sizeof (nid.szTip));
$ strncpy_s (nid.szInfoTitle, (title? title : "TXLib ñîîáùàåò"), sizeof (nid.szInfoTitle) - 1);
$ _vsnprintf_s (nid.szInfo, sizeof (nid.szInfo) _TX_TRUNCATE, format, arg);
$ nid.dwInfoFlags = flags;
$ txOutputDebugPrintf (_TX_VERSION " - Icon notification: %s: %s\n", nid.szInfoTitle, nid.szInfo);
$ ok &= !!Shell_NotifyIcon (NIM_ADD, (::NOTIFYICONDATA*) &nid);
$ ok &= !!Shell_NotifyIcon (NIM_MODIFY, (::NOTIFYICONDATA*) &nid);
$ if (nid.hIcon) DestroyIcon (nid.hIcon) asserted;
#else
$ char nid_szInfo[_TX_BUFSIZE] = "";
$ _vsnprintf_s (nid_szInfo, sizeof (nid_szInfo) _TX_TRUNCATE, format, arg);
$ txOutputDebugPrintf (_TX_VERSION " - Icon notification (NOT displayed): %s: %s\n", title, nid_szInfo);
$ ok = false;
$ (void)flags; (void)title;
#endif
$ va_end (arg);
$ return ok;
}
//! @}
//}
//=================================================================================================================
//=================================================================================================================
//{ TXLib API implementation
// Ðåàëèçàöèÿ TXLib API
//=================================================================================================================
inline const char* txVersion()
{
return _TX_VERSION;
}
//-----------------------------------------------------------------------------------------------------------------
inline unsigned txVersionNumber()
{
return _TX_VER;
}
//-----------------------------------------------------------------------------------------------------------------
POINT txGetExtent()
{
$1 _TX_IF_TXWINDOW_FAILED return ZERO (POINT);
$ RECT r = {0};
$ GetClientRect (txWindow(), &r);
$ POINT size = { r.right - r.left, r.bottom - r.top };
$ return size;
}
//-----------------------------------------------------------------------------------------------------------------
int txGetExtentX()
{
$1 return txGetExtent().x;
}
//-----------------------------------------------------------------------------------------------------------------
int txGetExtentY()
{
$1 return txGetExtent().y;
}
//-----------------------------------------------------------------------------------------------------------------
inline HDC& txDC()
{
$1 return _txCanvas_BackBuf[0];
}
//-----------------------------------------------------------------------------------------------------------------
inline HWND txWindow()
{
$1 return _txCanvas_Window;
}
//-----------------------------------------------------------------------------------------------------------------
bool txDestroyWindow()
{
$1 if (!txWindow()) return false;
$ if (SendNotifyMessage (txWindow(), (_txMain? WM_CLOSE : WM_DESTROY), 0, 0) == 0) return false;
$ if (_txMain)
{
$ txNotifyIcon (NIIF_WARNING, NULL, "\n" "Î÷åíü, î÷åíü ïëîõî çàâåðøàòü ïðîãðàììó ÷åðåç txDestroyWindow(). \n\n"
"Âîçâðàùàéòåñü ÷åðåç main(), òàì âàì áóäóò ðàäû.\n");
$ Sleep (_TX_TIMEOUT);
}
$ _txWaitFor (!_txCanvas_Window, _TX_TIMEOUT);
$ return _txCanvas_Window == NULL;
}
//-----------------------------------------------------------------------------------------------------------------
bool txSetColor (COLORREF color, double thickness /*= 1*/)
{
$1 _TX_IF_TXWINDOW_FAILED return false;
$ return _txBuffer_Select (Win32::CreatePen ((color == TX_TRANSPARENT? PS_NULL : PS_SOLID), ROUND (thickness), color))
&&
txGDI ((Win32::SetTextColor (txDC(), color)));
}
//-----------------------------------------------------------------------------------------------------------------
bool txColor (double red, double green, double blue)
{
$1 if (red > 1) red = 1; if (red < 0) red = 0;
$ if (green > 1) green = 1; if (green < 0) green = 0;
$ if (blue > 1) blue = 1; if (blue < 0) blue = 0;
$ return txSetColor (RGB (ROUND (red * 255), ROUND (green * 255), ROUND (blue * 255)));
}
//-----------------------------------------------------------------------------------------------------------------
COLORREF txGetColor()
{
$1 _TX_IF_TXWINDOW_FAILED return CLR_INVALID;
$ HGDIOBJ obj = txGDI ((Win32::GetCurrentObject (txDC(), OBJ_PEN)));
$ assert (obj); if (!obj) return CLR_INVALID;
$ union { EXTLOGPEN extLogPen; LOGPEN LogPen; } buf = {{0}};
$ int size = Win32::GetObject (obj, 0, NULL);
$ Win32::GetObject (obj, sizeof (buf), &buf) asserted;
$ return (size == sizeof (LOGPEN))? buf.LogPen.lopnColor : buf.extLogPen.elpColor;
}
//-----------------------------------------------------------------------------------------------------------------
bool txSetFillColor (COLORREF color)
{
$1 _TX_IF_TXWINDOW_FAILED return false;
$ return _txBuffer_Select ((color == TX_TRANSPARENT)? Win32::GetStockObject (HOLLOW_BRUSH) :
Win32::CreateSolidBrush (color));
}
//-----------------------------------------------------------------------------------------------------------------
bool txFillColor (double red, double green, double blue)
{
$1 if (red > 1) red = 1; if (red < 0) red = 0;
$ if (green > 1) green = 1; if (green < 0) green = 0;
$ if (blue > 1) blue = 1; if (blue < 0) blue = 0;
$ return txSetFillColor (RGB (ROUND (red * 255), ROUND (green * 255), ROUND (blue * 255)));
}
//-----------------------------------------------------------------------------------------------------------------
COLORREF txGetFillColor()
{
$1 _TX_IF_TXWINDOW_FAILED return CLR_INVALID;
$ HGDIOBJ obj = txGDI ((Win32::GetCurrentObject (txDC(), OBJ_BRUSH)));
$ assert (obj); if (!obj) return CLR_INVALID;
$ LOGBRUSH buf = {0};
$ txGDI ((Win32::GetObject (obj, sizeof (buf), &buf))) asserted;
$ return buf.lbColor;
}
//-----------------------------------------------------------------------------------------------------------------
bool txSetROP2 (int mode /*= R2_COPYPEN*/)
{
$1 _TX_IF_TXWINDOW_FAILED return false;
$ return txGDI (!!(Win32::SetROP2 (txDC(), mode)));
}
//-----------------------------------------------------------------------------------------------------------------
bool txClear()
{
$1 _TX_IF_TXWINDOW_FAILED return false;
$ POINT size = txGetExtent();
$ return txGDI (!!(Win32::PatBlt (txDC(), 0, 0, size.x, size.y, PATCOPY)));
}
//-----------------------------------------------------------------------------------------------------------------
inline bool txSetPixel (double x, double y, COLORREF color)
{
$1 _TX_IF_TXWINDOW_FAILED return false;
$ txGDI ((Win32::SetPixel (txDC(), ROUND (x), ROUND (y), color)));
$ return true;
}
//-----------------------------------------------------------------------------------------------------------------
inline bool txPixel (double x, double y, double red, double green, double blue)
{
$1 if (red > 1) red = 1; if (red < 0) red = 0;
$ if (green > 1) green = 1; if (green < 0) green = 0;
$ if (blue > 1) blue = 1; if (blue < 0) blue = 0;
$ return txSetPixel (x, y, RGB (ROUND (red * 255), ROUND (green * 255), ROUND (blue * 255)));
}
//-----------------------------------------------------------------------------------------------------------------
inline COLORREF txGetPixel (double x, double y)
{
$1 _TX_IF_TXWINDOW_FAILED return CLR_INVALID;
$ return txGDI ((Win32::GetPixel (txDC(), ROUND (x), ROUND (y))));
}
//-----------------------------------------------------------------------------------------------------------------
bool txLine (double x0, double y0, double x1, double y1)
{
$1 _TX_IF_TXWINDOW_FAILED return false;
$ txGDI ((Win32::MoveToEx (txDC(), ROUND (x0), ROUND (y0), NULL))) asserted;
$ txGDI ((Win32::LineTo (txDC(), ROUND (x1), ROUND (y1) ))) asserted;
$ return true;
}
//-----------------------------------------------------------------------------------------------------------------
bool txRectangle (double x0, double y0, double x1, double y1)
{
$1 _TX_IF_TXWINDOW_FAILED return false;
$ txGDI ((Win32::Rectangle (txDC(), ROUND (x0), ROUND (y0), ROUND (x1), ROUND (y1)))) asserted;
$ return true;
}
//-----------------------------------------------------------------------------------------------------------------
bool txPolygon (const POINT points[], int numPoints)
{
$1 _TX_IF_TXWINDOW_FAILED return false;
$ _TX_IF_ARGUMENT_FAILED (points) return false;
$ return txGDI (!!(Win32::Polygon (txDC(), points, numPoints)));
}
//-----------------------------------------------------------------------------------------------------------------
bool txEllipse (double x0, double y0, double x1, double y1)
{
$1 _TX_IF_TXWINDOW_FAILED return false;
$ txGDI ((Win32::Ellipse (txDC(), ROUND (x0), ROUND (y0), ROUND (x1), ROUND (y1)))) asserted;
$ return true;
}
//-----------------------------------------------------------------------------------------------------------------
bool txCircle (double x, double y, double r)
{
$1 return txEllipse (x-r, y-r, x+r, y+r);
}
//-----------------------------------------------------------------------------------------------------------------
bool txArc (double x0, double y0, double x1, double y1, double startAngle, double totalAngle)
{
$1 _TX_IF_TXWINDOW_FAILED return false;
$ POINT center = { ROUND ((x0 + x1) /2), ROUND ((y0 + y1) /2) };
$ double start = startAngle * txPI/180,
end = (startAngle + totalAngle) * txPI/180;
$ return txGDI (!!(Win32::Arc (txDC(), ROUND (x0), ROUND (y0), ROUND (x1), ROUND (y1),
ROUND (center.x + 1E3*cos (start)), ROUND (center.y - 1E3*sin (start)),
ROUND (center.x + 1E3*cos (end)), ROUND (center.y - 1E3*sin (end)))));
}
//-----------------------------------------------------------------------------------------------------------------
bool txPie (double x0, double y0, double x1, double y1, double startAngle, double totalAngle)
{
$1 _TX_IF_TXWINDOW_FAILED return false;
$ POINT center = { ROUND ((x0 + x1) /2), ROUND ((y0 + y1) /2) };
$ double start = startAngle * txPI/180,
end = (startAngle + totalAngle) * txPI/180;
$ return txGDI (!!(Win32::Pie (txDC(), ROUND (x0), ROUND (y0), ROUND (x1), ROUND (y1),
ROUND (center.x + 1E3*cos (start)), ROUND (center.y - 1E3*sin (start)),
ROUND (center.x + 1E3*cos (end)), ROUND (center.y - 1E3*sin (end)))));
}
//-----------------------------------------------------------------------------------------------------------------
bool txChord (double x0, double y0, double x1, double y1, double startAngle, double totalAngle)
{
$1 _TX_IF_TXWINDOW_FAILED return false;
$ POINT center = { ROUND ((x0 + x1) /2), ROUND ((y0 + y1) /2) };
$ double start = startAngle * txPI/180,
end = (startAngle + totalAngle) * txPI/180;
$ return txGDI (!!(Win32::Chord (txDC(), ROUND (x0), ROUND (y0), ROUND (x1), ROUND (y1),
ROUND (center.x + 1E3*cos (start)), ROUND (center.y - 1E3*sin (start)),
ROUND (center.x + 1E3*cos (end)), ROUND (center.y - 1E3*sin (end)))));
}
//-----------------------------------------------------------------------------------------------------------------
bool txFloodFill (double x, double y,
COLORREF color /*= TX_TRANSPARENT*/, DWORD mode /*= FLOODFILLSURFACE*/)
{
$1 _TX_IF_TXWINDOW_FAILED return false;
$ if (color == TX_TRANSPARENT) color = txGetPixel (x, y);
$ return txGDI (!!(Win32::ExtFloodFill (txDC(), ROUND (x), ROUND (y), color, mode)));
}
//-----------------------------------------------------------------------------------------------------------------
bool txTextOut (double x, double y, const char text[])
{
$1 _TX_IF_TXWINDOW_FAILED return false;
$ _TX_IF_ARGUMENT_FAILED (text) return false;
$ int len = (int) strlen (text);
$ txGDI (!!(Win32::TextOut (txDC(), ROUND (x), ROUND (y), text, len))) asserted;
$ SIZE size = {0};
$ txGDI ((Win32::GetTextExtentPoint32 (txDC(), text, len, &size))) asserted;
$ RECT r = { ROUND (x), ROUND (y), ROUND (x + size.cx), ROUND (y + size.cy) };
$ InvalidateRect (txWindow(), &r, false) asserted;
$ return true;
}
//-----------------------------------------------------------------------------------------------------------------
bool txDrawText (double x0, double y0, double x1, double y1, const char text[],
unsigned format /*= DT_CENTER | DT_VCENTER | DT_WORDBREAK | DT_WORD_ELLIPSIS*/)
{
$1 _TX_IF_TXWINDOW_FAILED return false;
$ _TX_IF_ARGUMENT_FAILED (text) return false;
$ RECT r = { ROUND (x0), ROUND (y0), ROUND (x1), ROUND (y1) };
$ if (!strchr (text, '\n')) format |= DT_SINGLELINE;
$ unsigned prev = txSetTextAlign (TA_LEFT | TA_TOP | TA_NOUPDATECP);
if (Win32::DrawText) { $ txGDI ((Win32::DrawText (txDC(), text, -1, &r, format))) asserted; }
$ txSetTextAlign (prev);
$ return true;
}
//-----------------------------------------------------------------------------------------------------------------
bool txSelectFont (const char name[], double sizeY,
double sizeX /*= -1*/,
int bold /*= FW_DONTCARE*/,
bool italic /*= false*/,
bool underline /*= false*/,
bool strikeout /*= false*/,
double angle /*= 0*/)
{
$1 _TX_IF_TXWINDOW_FAILED return false;
$ _TX_IF_ARGUMENT_FAILED (name) return false;
$ _txBuffer_Select (txFontExist (name)?
Win32::CreateFont (ROUND (sizeY), ROUND ((sizeX >= 0)? sizeX : sizeY/3),
ROUND (angle*10), 0, bold, italic, underline, strikeout,
RUSSIAN_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
DEFAULT_QUALITY, FIXED_PITCH, name)
:
Win32::GetStockObject (SYSTEM_FIXED_FONT));
$ return true;
}
//-----------------------------------------------------------------------------------------------------------------
SIZE txGetTextExtent (const char text[])
{
$1 SIZE size = {0};
$ _TX_IF_TXWINDOW_FAILED return size;
$ _TX_IF_ARGUMENT_FAILED (text) return size;
$ txGDI ((Win32::GetTextExtentPoint32 (txDC(), text, (int) strlen (text), &size))) asserted;
$ return size;
}
//-----------------------------------------------------------------------------------------------------------------
int txGetTextExtentX (const char text[])
{
$1 return txGetTextExtent (text) .cx;
}
//-----------------------------------------------------------------------------------------------------------------
int txGetTextExtentY (const char text[])
{
$1 return txGetTextExtent (text) .cy;
}
//-----------------------------------------------------------------------------------------------------------------
unsigned txSetTextAlign (unsigned align /*= TA_CENTER | TA_BASELINE*/)
{
$1 _TX_IF_TXWINDOW_FAILED return 0;
$ return txGDI ((Win32::SetTextAlign (txDC(), align)));
}
//-----------------------------------------------------------------------------------------------------------------
LOGFONT* txFontExist (const char name[])
{
$1 _TX_IF_TXWINDOW_FAILED return NULL;
$ _TX_IF_ARGUMENT_FAILED (name) return NULL;
$ static LOGFONT font = {0};
$ font.lfCharSet = DEFAULT_CHARSET;
$ strncpy_s (font.lfFaceName, name, sizeof (font.lfFaceName) - 1);
$ struct tools
{
static int CALLBACK enumFonts (const LOGFONT* fnt, const TEXTMETRIC*, DWORD, LPARAM data)
{
$ _TX_IF_ARGUMENT_FAILED (fnt) return 0;
$ _TX_IF_ARGUMENT_FAILED (data) return 0;
#ifndef __STRICT_ANSI__
$ return _strnicmp (fnt->lfFaceName, ((LOGFONT*)data)->lfFaceName, LF_FACESIZE);
#else
$ return strncmp (fnt->lfFaceName, ((LOGFONT*)data)->lfFaceName, LF_FACESIZE);
#endif
}
};
$ return txGDI ((Win32::EnumFontFamiliesEx (txDC(), &font, tools::enumFonts, (LPARAM) &font, 0))) == 0? &font : NULL;
}
//-----------------------------------------------------------------------------------------------------------------
bool txSelectObject (HGDIOBJ obj)
{
$1 _TX_IF_TXWINDOW_FAILED return false;
$ _TX_IF_ARGUMENT_FAILED (obj) return false;
$ return _txBuffer_Select (obj);
}
//-----------------------------------------------------------------------------------------------------------------
HDC txCreateCompatibleDC (double sizeX, double sizeY, HBITMAP bitmap /*= NULL*/)
{
$1 _TX_IF_TXWINDOW_FAILED return NULL;
$ POINT size = { ROUND (sizeX), ROUND (sizeY) };
$ HDC dc = _txBuffer_Create (txWindow(), &size, bitmap);
$ assert (dc); if (!dc) return NULL;
$ if (!_txCanvas_UserDCs) return dc;
$ txAutoLock _lock;
$ _txCanvas_UserDCs->push_back (dc);
$ if (_txCanvas_UserDCs->size() >= _TX_BUFSIZE)
{ $ txNotifyIcon (NIIF_WARNING, NULL, "Âû çàãðóçèëè óæå %d HDC, ñèñòåìå ìîæåò ñòàòü ïëîõî.", (int) _txCanvas_UserDCs->size()); }
$ return dc;
}
//-----------------------------------------------------------------------------------------------------------------
HDC txLoadImage (const char filename[], unsigned imageFlags /*= IMAGE_BITMAP*/, unsigned loadFlags /*= LR_LOADFROMFILE*/)
{
$1 _TX_IF_TXWINDOW_FAILED return NULL;
$ _TX_IF_ARGUMENT_FAILED (filename && *filename) return NULL;
$ HBITMAP image = (HBITMAP) Win32::LoadImage ((loadFlags & LR_LOADFROMFILE)? NULL : GetModuleHandle (NULL),
filename, imageFlags, 0, 0, loadFlags);
$ if (!image) return NULL;
$ HDC dc = txCreateCompatibleDC (0, 0, image);
$ if (!(loadFlags & LR_LOADFROMFILE)) return dc;
$ static std::map <std::string, unsigned> loadTimes;
$ std::string file = filename;
$ unsigned time = GetTickCount();
$ if ((long) (time - loadTimes [file]) < _TX_TIMEOUT)
{ $ txNotifyIcon (NIIF_WARNING, NULL, "Âû çàãðóæàåòå \"%s\" ñëèøêîì ÷àñòî, ïðîãðàììà áóäåò òîðìîçèòü.", filename); }
$ loadTimes [file] = time;
$ return dc;
}
//-----------------------------------------------------------------------------------------------------------------
bool txDeleteDC (HDC* pdc)
{
$1 _TX_IF_TXWINDOW_FAILED return false;
$ _TX_IF_ARGUMENT_FAILED (pdc) return false;
$ HDC dc = *pdc;
$ bool ok = _txBuffer_Delete (pdc);
$ if (!ok) return false;
$ if (!_txCanvas_UserDCs) return ok;
$ txAutoLock _lock;
$ std::vector <HDC> ::iterator i = std::find (_txCanvas_UserDCs->begin(), _txCanvas_UserDCs->end(), dc);
$ if (i != _txCanvas_UserDCs->end()) { std::swap (*i, _txCanvas_UserDCs->back()); _txCanvas_UserDCs->pop_back(); }
$ return ok;
}
//-----------------------------------------------------------------------------------------------------------------
bool txDeleteDC (HDC dc)
{
$1 _TX_IF_TXWINDOW_FAILED return false;
$ return txDeleteDC (&dc);
}
//-----------------------------------------------------------------------------------------------------------------
bool txBitBlt (HDC dest, double xDest, double yDest, double width, double height,
HDC src, double xSrc /*= 0*/, double ySrc /*= 0*/, DWORD rOp /*= SRCCOPY*/)
{
$1 _TX_IF_TXWINDOW_FAILED return false;
$ _TX_IF_ARGUMENT_FAILED (dest) return false;
$ _TX_IF_ARGUMENT_FAILED (src) return false;
$ return txGDI (!!(Win32::BitBlt (dest, ROUND (xDest), ROUND (yDest), ROUND (width), ROUND (height),
src, ROUND (xSrc), ROUND (ySrc), rOp)));
}
//-----------------------------------------------------------------------------------------------------------------
bool txTransparentBlt (HDC dest, double xDest, double yDest, double width, double height,
HDC src, double xSrc /*= 0*/, double ySrc /*= 0*/, COLORREF transColor /*= TX_BLACK*/)
{
$1 _TX_IF_TXWINDOW_FAILED return false;
$ _TX_IF_ARGUMENT_FAILED (dest) return false;
$ _TX_IF_ARGUMENT_FAILED (src) return false;
$ return (Win32::TransparentBlt)?
txGDI (!!(Win32::TransparentBlt (dest, ROUND (xDest), ROUND (yDest), ROUND (width), ROUND (height),
src, ROUND (xSrc), ROUND (ySrc), ROUND (width), ROUND (height), transColor)))
:
txGDI (!!(Win32::BitBlt (dest, ROUND (xDest), ROUND (yDest), ROUND (width), ROUND (height),
src, ROUND (xSrc), ROUND (ySrc), SRCCOPY))), false;
}
//-----------------------------------------------------------------------------------------------------------------
bool txAlphaBlend (HDC dest, double xDest, double yDest, double width, double height,
HDC src, double xSrc /*= 0*/, double ySrc /*= 0*/, double alpha /*= 1.0*/)
{
$1 _TX_IF_TXWINDOW_FAILED return false;
$ _TX_IF_ARGUMENT_FAILED (dest) return false;
$ _TX_IF_ARGUMENT_FAILED (src) return false;
$ if (alpha < 0) alpha = 0;
$ if (alpha > 1) alpha = 1;
$ BLENDFUNCTION blend = { AC_SRC_OVER, 0, (BYTE) ROUND (alpha * 255), AC_SRC_ALPHA };
$ return (Win32::AlphaBlend)?
txGDI (!!(Win32::AlphaBlend (dest, ROUND (xDest), ROUND (yDest), ROUND (width), ROUND (height),
src, ROUND (xSrc), ROUND (ySrc), ROUND (width), ROUND (height), blend)))
:
txGDI (!!(Win32::BitBlt (dest, ROUND (xDest), ROUND (yDest), ROUND (width), ROUND (height),
src, ROUND (xSrc), ROUND (ySrc), SRCCOPY))), false;
}
//-----------------------------------------------------------------------------------------------------------------
inline int txUpdateWindow (int update /*= true*/)
{
$1 return _txCanvas_SetRefreshLock (update >= 0? !update : -update);
}
//-----------------------------------------------------------------------------------------------------------------
inline int txBegin()
{
$1 _txCanvas_SetRefreshLock (_txCanvas_RefreshLock + 1);
$ return _txCanvas_RefreshLock;
}
//-----------------------------------------------------------------------------------------------------------------
inline int txEnd()
{
$1 _txCanvas_SetRefreshLock (_txCanvas_RefreshLock - 1);
$ return _txCanvas_RefreshLock;
}
//-----------------------------------------------------------------------------------------------------------------
double txSleep (double time)
{
$1 LARGE_INTEGER start = {{0}};
$ QueryPerformanceCounter (&start) asserted;
$ LARGE_INTEGER freq = {{0}};
$ QueryPerformanceFrequency (&freq) asserted;
$ int lock = _txCanvas_RefreshLock;
$ _txCanvas_RefreshLock = 0;
$ HWND wnd = txWindow();
if (wnd) { $ RedrawWindow (wnd, NULL, NULL, RDW_INVALIDATE | RDW_INTERNALPAINT | RDW_UPDATENOW) asserted; }
$ Sleep (ROUND (time));
$ _txCanvas_RefreshLock = lock;
$ LARGE_INTEGER stop = {{0}};
$ QueryPerformanceCounter (&stop) asserted;
$ return 1000.0 * (double) (stop.QuadPart - start.QuadPart) / (double) freq.QuadPart;
}
//-----------------------------------------------------------------------------------------------------------------
bool txLock (bool wait /*= true*/)
{
$1 if (_txCanvas_RefreshLock <= 0 || _txExit) Sleep (0);
$ if (wait) { $ return EnterCriticalSection (&_txCanvas_LockBackBuf), true; }
else { $ return !!TryEnterCriticalSection (&_txCanvas_LockBackBuf); }
}
//-----------------------------------------------------------------------------------------------------------------
bool txUnlock()
{
$1 LeaveCriticalSection (&_txCanvas_LockBackBuf);
$ if (_txCanvas_RefreshLock <= 0 || _txExit) Sleep (0);
$ return false;
}
//-----------------------------------------------------------------------------------------------------------------
template <typename T>
inline T txUnlock (T value)
{
$1 txUnlock();
$ return value;
}
//-----------------------------------------------------------------------------------------------------------------
inline POINT txMousePos()
{
$1 _TX_IF_TXWINDOW_FAILED return ZERO (POINT);
$ return _txMousePos;
}
//-----------------------------------------------------------------------------------------------------------------
inline int txMouseX()
{
$1 return _txMousePos.x;
}
//-----------------------------------------------------------------------------------------------------------------
inline int txMouseY()
{
$1 return _txMousePos.y;
}
//-----------------------------------------------------------------------------------------------------------------
inline int txMouseButtons()
{
$1 _TX_IF_TXWINDOW_FAILED return 0;
$ return _txMouseButtons;
}
//-----------------------------------------------------------------------------------------------------------------
bool txSetConsoleAttr (unsigned color /*= 0x07*/)
{
$1 return !!SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), (WORD) color);
}
//-----------------------------------------------------------------------------------------------------------------
unsigned txGetConsoleAttr()
{
$1 CONSOLE_SCREEN_BUFFER_INFO con = {{0}};
$ GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con);
$ return con.wAttributes;
}
//-----------------------------------------------------------------------------------------------------------------
POINT txSetConsoleCursorPos (double x, double y)
{
$1 POINT fontSz = txGetConsoleFontSize();
$ CONSOLE_SCREEN_BUFFER_INFO con = {{0}};
$ GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con) asserted;
$ COORD pos = { (short) ROUND (1.0 * x / fontSz.x + con.srWindow.Left),
(short) ROUND (1.0 * y / fontSz.y + con.srWindow.Top ) };
$ SetConsoleCursorPosition (GetStdHandle (STD_OUTPUT_HANDLE), pos) asserted;
$ POINT prev = { ROUND (1.0 * (con.dwCursorPosition.X - con.srWindow.Left) / fontSz.x),
ROUND (1.0 * (con.dwCursorPosition.Y - con.srWindow.Top ) / fontSz.y) };
$ return prev;
}
//-----------------------------------------------------------------------------------------------------------------
POINT txGetConsoleCursorPos()
{
$1 POINT fontSz = txGetConsoleFontSize();
$ CONSOLE_SCREEN_BUFFER_INFO con = {{0}};
$ GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &con) asserted;
$ POINT pos = { ROUND (1.0 * (con.dwCursorPosition.X - con.srWindow.Left) / fontSz.x),
ROUND (1.0 * (con.dwCursorPosition.Y - con.srWindow.Top ) / fontSz.y) };
$ return pos;
}
//-----------------------------------------------------------------------------------------------------------------
bool txClearConsole()
{
$1 HANDLE out = GetStdHandle (STD_OUTPUT_HANDLE);
$ CONSOLE_SCREEN_BUFFER_INFO con = {{0}};
$ GetConsoleScreenBufferInfo (out, &con) asserted;
$ COORD start = {con.srWindow.Left, con.srWindow.Top};
$ DWORD len = (con.srWindow.Right - con.srWindow.Left + 1) *
(con.srWindow.Bottom - con.srWindow.Top + 1);
$ DWORD written = 0;
$ FillConsoleOutputCharacter (out, 0x20 /*' '*/, len, start, &written) asserted;
$ FillConsoleOutputAttribute (out, con.wAttributes, len, start, &written) asserted;
$ SetConsoleCursorPosition (GetStdHandle (STD_OUTPUT_HANDLE), start) asserted;
$ return written == len;
}
//-----------------------------------------------------------------------------------------------------------------
POINT txGetConsoleFontSize()
{
$1 CONSOLE_FONT_INFO font = {0, {8, 16}};
$ if (Win32::GetCurrentConsoleFont)
{ $ Win32::GetCurrentConsoleFont (GetStdHandle (STD_OUTPUT_HANDLE), false, &font) asserted; }
$ SIZE size = { font.dwFontSize.X, font.dwFontSize.Y };
$ txGDI (Win32::GetTextExtentPoint32 (_txCanvas_BackBuf[1], "W", 1, &size));
$ POINT sizeFont = { size.cx, size.cy };
$ return sizeFont;
}
//-----------------------------------------------------------------------------------------------------------------
bool txTextCursor (bool blink /*= true*/)
{
$1 bool old = _txConsole_IsBlinking;
$ _txConsole_IsBlinking = blink;
$ return old;
}
//-----------------------------------------------------------------------------------------------------------------
bool txPlaySound (const char filename[] /*= NULL*/, DWORD mode /*= SND_ASYNC*/)
{
$1 _TX_IF_ARGUMENT_FAILED (!(filename && !*filename)) return false;
$ mode |= SND_FILENAME | SND_NODEFAULT | SND_NOWAIT;
$ if (mode & SND_LOOP) mode = (mode & ~SND_SYNC) | SND_ASYNC;
$ if (!filename) mode = SND_PURGE;
$ return !!Win32::PlaySound (filename, NULL, mode);
}
//-----------------------------------------------------------------------------------------------------------------
// +--<<< Ýòî âðÿä ëè èìååò îòíîøåíèå ê òîìó, ÷òî âû èùåòå :)
// V Ïîëåçíî ñìîòðåòü íå òîëüêî ââåðõ, íî è âíèç
WNDPROC txSetWindowsHook (WNDPROC wndProc /*= NULL*/)
{
$1 WNDPROC old = _txAltWndProc; _txAltWndProc = wndProc;
$ return old;
}
//-----------------------------------------------------------------------------------------------------------------
// +--<<< À ýòî, íàêîíåö, èñêîìîå îïðåäåëåíèå ýòîé ôóíêöèè.
// | Ñìîòðèòå ïî ñòîðîíàì! Íóæíàÿ âàì ôóíêöèÿ ãäå-òî ðÿäîì.
// |
// v
bool txIDontWantToHaveAPauseAfterMyProgramBeforeTheWindowWillClose_AndIWillNotBeAskingWhereIsMyPicture()
{
$1 txMessageBox ("Ýòî çàïëàíèðîâàííàÿ îøèáêà. Òàêîå áûâàåò. Âû õîòåëè âûçâàòü:\n\n"
"txIDontWantToHaveAPauseAfterMyProgramBeforeTheWindowWillClose_AndIWillNotBeAskingWhereIsMyPicture()\n\n"
"Õîòü âû äîëãî [êîïèðîâàëè]íàáèðàëè ýòî èìÿ, íà ñàìîì äåëå ýòà ôóíêöèÿ íå ðåàëèçîâàíà. "
"Åñòü äðóãàÿ ôóíêöèÿ, êîòîðàÿ óáèðàåò àâòî-ïàóçó â êîíöå ïðîãðàììû, íî â õåëïå ïðî íåå íå íàïèñàíî.\n\n"
"Íî íå âñå òàê ïëîõî. Îïðåäåëåíèå íóæíîé ôóíêöèè åñòü â èñõîäíûõ òåêñòàõ TXLib.h, îíî ëåæèò ðÿäîì "
"ñ îïðåäåëåíèåì òîé ôóíêöèè ñ äëèííûì íàçâàíèåì, êîòîðóþ âû ñåé÷àñ âûçâàëè.\n\n"
"Íàæìèòå â ðåäàêòîðå Ctrl+O, íàéäèòå è îòêðîéòå ôàéë TXLib.h (îí ëåæèò â ïàïêå, êóäà âû "
"óñòàíîâèëè TXLib), çàòåì íàæìèòå Ctrl+F è èùèòå \"txIDontWant\". Óäà÷è!\n\n",
"Íå ïîëó÷èëîñü", MB_ICONSTOP);
// The truth is out there... (C++files)
$ return false;
}
//-----------------------------------------------------------------------------------------------------------------
// Bingo! Now you are learned to use the Sources, Luke. And may the Source be with you.
inline bool txDisableAutoPause()
{
$1 _txExit = true;
$ return true;
}
//-----------------------------------------------------------------------------------------------------------------
void txDrawMan (int x, int y, int sizeX, int sizeY, COLORREF color, double handL, double handR, double twist,
double head, double eyes, double wink, double crazy, double smile, double hair, double wind)
{
$1 const char msg[] = "\0/À ÿ - ÷åëîâå÷åê èç áèáëèîòåêè!\0/Ìåíÿ îáúÿñíÿëè íà óðîêå!\0/Íàïèøè ìåíÿ ñàì!\0/";
static unsigned count = GetTickCount(), L = 0;
$ COLORREF lineColor = txGetColor();
COLORREF fillColor = txGetFillColor();
$ txSetColor (TX_DARKGRAY);
txSetFillColor (TX_TRANSPARENT);
$ txRectangle (x - sizeX/2, y - sizeY, x + sizeX/2, y);
txCircle (x, y, 4);
$ txSetColor (color);
txSetFillColor (color);
$ txLine (x + twist * sizeX, y - 0.35 * sizeY, x, y - 0.7 * sizeY);
$ txLine (x, y - 0.7 * sizeY, x - sizeX/2, y - (0.7 + handL) * sizeY);
txLine (x, y - 0.7 * sizeY, x + sizeX/2, y - (0.7 + handR) * sizeY);
$ txLine (x + twist * sizeX, y - 0.35 * sizeY, x - sizeX/2, y);
txLine (x + twist * sizeX, y - 0.35 * sizeY, x + sizeX/2, y);
$ txCircle (x, y - (0.85 + head) * sizeY, 0.15 * sizeY);
$ txLine (x, y - (1 + head) * sizeY, x + wind/10 * sizeX, y - (1 + head + hair/10) * sizeY);
txLine (x, y - (1 + head) * sizeY, x + (wind/10 - 0.1) * sizeX, y - (1 + head + hair/10) * sizeY);
txLine (x, y - (1 + head) * sizeY, x + (wind/10 + 0.1) * sizeX, y - (1 + head + hair/10) * sizeY);
$ txSetColor (~color & 0xFFFFFF);
txSetFillColor (~color & 0xFFFFFF);
$ txLine (x, y - (0.8 + head - 0.05 * smile/2) * sizeY, x - 0.05 * sizeY, y - (0.8 + head + 0.05 * smile/2) * sizeY),
txLine (x, y - (0.8 + head - 0.05 * smile/2) * sizeY, x + 0.05 * sizeY, y - (0.8 + head + 0.05 * smile/2) * sizeY),
txNotifyIcon (4, (const char*)!! (L+'L')[msg], "\n%s\n", msg + (count++ % 3)["\"<"]);
$ txCircle (x - 0.05 * sizeY, y - (0.9 + head - 0.02 * crazy) * sizeY, eyes * (1 + 0.5*wink) * 0.02 * sizeY),
txCircle (x + 0.05 * sizeY, y - (0.9 + head + 0.02 * crazy) * sizeY, eyes * (1 - 0.5*wink) * 0.02 * sizeY),
Sleep (1000 + count%2);
$ txSetColor (lineColor);
txSetFillColor (fillColor);
}
//-----------------------------------------------------------------------------------------------------------------
void txDump (const void* address, const char name[] /*= "txDump()"*/)
{
const unsigned char* p = (const unsigned char*) address;
int x = 0;
txSetConsoleAttr (0x0F);
printf ("\n%8.8s ", name? name : "");
txSetConsoleAttr (0x0E);
for (x = 0; x < 16; x++) printf ("%02X ", x);
for (x = 0; x < 16; x++) printf ("%X", x);
for (int y = 0; y < 16; y++, p += 16)
{
txSetConsoleAttr (0x0E);
printf ("\n" "%8p ", p);
for (x = 0; x < 16; x++) { txSetConsoleAttr (0x0A + x/4%2); printf ("%02X ", p[x]); }
for (x = 0; x < 16; x++) { txSetConsoleAttr (0x0A + x/4%2); printf ("%c", isprint (p[x])? p[x] : '.'); }
}
txSetConsoleAttr (0x07);
printf ("\n");
}
//-----------------------------------------------------------------------------------------------------------------
double txQueryPerformance()
{
$1 int maxTime = 500;
$ int maxSamples = 100;
$ POINT size = {500, 500};
$ HDC dc = _txBuffer_Create (txWindow(), &size, NULL);
$ assert (dc); if (!dc) return -1;
$ DWORD mask = (DWORD) SetThreadAffinityMask (GetCurrentThread(), 1);
$ assert (mask);
$ LARGE_INTEGER freq = {{0}};
$ QueryPerformanceFrequency (&freq) asserted;
$ LARGE_INTEGER start = {{0}};
$ QueryPerformanceCounter (&start) asserted;
$ int samples = 0;
$ while (samples++ < maxSamples)
{
$ LARGE_INTEGER cur = {{0}};
$ QueryPerformanceCounter (&cur) asserted;
$ double t = 1000.0 * (double) (cur.QuadPart - start.QuadPart) / (double) freq.QuadPart;
$ if (t > maxTime) break;
// Draw test scene
$ for (int y = 0; y < size.y; y += 10)
for (int x = 0; x < size.x; x += 10) Win32::TextOut (dc, x, y, "*", 1);
$ Win32::Ellipse (dc, 0, 0, size.x, size.y);
$ Win32::ExtFloodFill (dc, size.x/2, size.y/2, TX_TRANSPARENT, FLOODFILLSURFACE);
$ txBitBlt (dc, size.x/2, 0, size.x/2, size.y/2, dc, 0, 0) asserted;
$ txBitBlt (dc, size.x/2, size.y/2, size.x/2, size.y/2, dc, 0, size.y/2) asserted;
$ txBitBlt (dc, 0, size.y/2, size.x/2, size.y/2, dc, 0, 0) asserted;
$ txBitBlt (dc, size.x/2, size.y/2, size.x/2, size.y/2, dc, size.x/2, 0) asserted;
}
$ mask = (DWORD) SetThreadAffinityMask (GetCurrentThread(), mask);
$ assert (mask);
$ _txBuffer_Delete (&dc);
$ return 15.0 * samples / sqrt (1.0 * size.x * size.y);
}
//-----------------------------------------------------------------------------------------------------------------
int txExtractColor (COLORREF color, COLORREF component)
{
$1 switch (component)
{
case TX_RED:
case TX_HUE: $ return (color >> 0) & 0xFF;
case TX_GREEN:
case TX_SATURATION: $ return (color >> 8) & 0xFF;
case TX_BLUE:
case TX_LIGHTNESS: $ return (color >> 16) & 0xFF;
default: $ return CLR_INVALID;
}
}
//-----------------------------------------------------------------------------------------------------------------
COLORREF txRGB2HSL (COLORREF rgbColor)
{
$1 int r = txExtractColor (rgbColor, TX_RED),
g = txExtractColor (rgbColor, TX_GREEN),
b = txExtractColor (rgbColor, TX_BLUE);
$ double m1 = MAX (MAX (r, g), b) / 255.0,
m2 = MIN (MIN (r, g), b) / 255.0,
dm = m1 - m2,
sm = m1 + m2,
ir = r / 255.0,
ig = g / 255.0,
ib = b / 255.0,
ih = 0,
is = 0,
il = sm / 2;
$ const double prec = 0.001;
$ if (fabs (dm) < prec)
{
$ is = dm / ((sm <= 1)? sm : (2-sm));
$ double cr = (m1 - ir) / dm,
cg = (m1 - ig) / dm,
cb = (m1 - ib) / dm;
$ if (fabs (ir - m1) < prec) ih = cb - cg;
$ if (fabs (ig - m1) < prec) ih = 2 + cr - cb;
$ if (fabs (ib - m1) < prec) ih = 4 + cg - cr;
}
$ ih = (ih >= 0)? ih*60 : ih*60 + 360;
$ return RGB (ROUND (ih / 360 * 255), ROUND (is * 255), ROUND (il * 255));
}
//-----------------------------------------------------------------------------------------------------------------
COLORREF txHSL2RGB (COLORREF hslColor)
{
$1 struct xRGB
{
static double calc (double h, double m1, double m2)
{
$ if (h < 0) h += 360;
$ if (h > 360) h -= 360;
$ return (h < 60)? m1 + (m2-m1) * h / 60 :
(h < 180)? m2 :
(h < 240)? m1 + (m2-m1) * (240-h) / 60 :
m1;
}
};
$ int h = txExtractColor (hslColor, TX_HUE),
s = txExtractColor (hslColor, TX_SATURATION),
l = txExtractColor (hslColor, TX_LIGHTNESS);
$ double ih = h / 255.0 * 360.0,
il = l / 100.0,
is = s / 100.0,
m2 = (il <= 0.5)? il * (1 + is) : il + is - il * is,
m1 = 2 * il - m2,
ir = s? xRGB::calc (ih + 120, m1, m2) : il,
ig = s? xRGB::calc (ih, m1, m2) : il,
ib = s? xRGB::calc (ih - 120, m1, m2) : il;
$ return RGB (ROUND (ir * 255), ROUND (ig * 255), ROUND (ib * 255));
}
//-----------------------------------------------------------------------------------------------------------------
template <typename T>
inline bool In (T x, T a, T b)
{
return a <= x && x <= b;
}
//-----------------------------------------------------------------------------------------------------------------
inline bool In (const POINT& pt, const RECT& rect)
{
_TX_IF_ARGUMENT_FAILED (&pt) return 0;
_TX_IF_ARGUMENT_FAILED (&rect) return 0;
return In (pt.x, rect.left, rect.right) &&
In (pt.y, rect.top, rect.bottom);
}
//-----------------------------------------------------------------------------------------------------------------
inline bool In (const COORD& pt, const SMALL_RECT& rect)
{
_TX_IF_ARGUMENT_FAILED (&pt) return 0;
_TX_IF_ARGUMENT_FAILED (&rect) return 0;
return In (pt.X, rect.Left, rect.Right) &&
In (pt.Y, rect.Top, rect.Bottom);
}
//-----------------------------------------------------------------------------------------------------------------
inline int random (int range)
{
return rand() % range;
}
//-----------------------------------------------------------------------------------------------------------------
inline double random (double left, double right)
{
return left + (right - left) * ((double) rand() / RAND_MAX);
}
//-----------------------------------------------------------------------------------------------------------------
template <typename T>
inline T zero()
#ifdef _MSC_VER_6
{ T __zero = {0}; return __zero; }
#else
{ T __zero = { }; return __zero; }
#endif
//}
//=================================================================================================================
//=================================================================================================================
//{ txDialog methods implementation
// Ðåàëèçàöèÿ ìåòîäîâ êëàññà txDialog
//=================================================================================================================
txDialog::txDialog () :
layout_ (NULL)
{$1}
//-----------------------------------------------------------------------------------------------------------------
txDialog::txDialog (const Layout* layout) :
layout_ (layout)
{$1}
//-----------------------------------------------------------------------------------------------------------------
const txDialog::Layout* txDialog::setLayout (const Layout* layout)
{
$1 return std::swap (layout_, layout), layout;
}
//-----------------------------------------------------------------------------------------------------------------
INT_PTR txDialog::dialogBox (WORD resourceID)
{
$1 const char* resName = (char*)(ptrdiff_t) resourceID;
$ if (!FindResource (NULL, resName, RT_DIALOG)) return TX_DEBUG_ERROR ("Íå íàéäåí ðåñóðñ äèàëîãà %d" _ resourceID), 0;
$ return DialogBoxParam (NULL, resName, NULL, dialogProc__, (LPARAM) this);
}
//-----------------------------------------------------------------------------------------------------------------
INT_PTR txDialog::dialogBox (const txDialog::Layout* layout /*= NULL*/, size_t bufsize /*= 0*/)
{
$1 if (!layout) layout = layout_;
$ if (!layout) return TX_DEBUG_ERROR ("Íå óñòàíîâëåí äèíàìè÷åñêèé øàáëîí äèàëîãà"), 0;
$ if (!bufsize) bufsize = 1024;
$ DLGTEMPLATE* tmpl = (DLGTEMPLATE*) GlobalAlloc (GPTR, bufsize);
$ if (!tmpl) return TX_DEBUG_ERROR ("GlobalAlloc(): Íåò ïàìÿòè äëÿ øàáëîíà äèàëîãà"), 0;
$ const Layout* dlg = &layout[0];
$ const Layout def = { DIALOG, NULL, 0, 0,0,0,0, WS_CAPTION | WS_SYSMENU | DS_MODALFRAME | DS_CENTER, "MS Shell Dlg", 8 };
$ void* ptr = _tx_DLGTEMPLATE_Create (tmpl, bufsize,
(dlg->style? dlg->style : def.style) | DS_SETFONT, 0, 0,
dlg->x, dlg->y, dlg->sx, dlg->sy,
dlg->caption? dlg->caption : def.caption,
dlg->font? dlg->font : def.font,
dlg->fontsize? dlg->fontsize : def.fontsize, NULL);
$ WORD i = 0;
$ for (i = 1; layout[i].wndclass != END; ++i)
{
$ const Layout* item = &layout[i];
$ ptr = _tx_DLGTEMPLATE_Add (ptr, bufsize - ((char*)ptr - (char*)tmpl),
item->style | WS_VISIBLE, 0, item->x, item->y, item->sx, item->sy,
item->id, (const char*) item->wndclass, item->caption);
}
$ tmpl->cdit = (unsigned short) (i-1);
$ INT_PTR res = DialogBoxIndirectParam (NULL, tmpl, NULL, dialogProc__, (LPARAM) this);
$ GlobalFree (tmpl);
$ return res;
}
//-----------------------------------------------------------------------------------------------------------------
int txDialog::dialogProc (HWND, UINT, WPARAM, LPARAM)
{
$1 return FALSE;
}
//-----------------------------------------------------------------------------------------------------------------
ptrdiff_t CALLBACK txDialog::dialogProc__ (HWND wnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
$1 static txDialog* this__ = NULL;
$ if (msg == WM_INITDIALOG) this__ = (txDialog*) lParam;
$ if (!this__) return FALSE;
$ switch (msg)
{
case WM_INITDIALOG: $ SetForegroundWindow (wnd); break;
case WM_COMMAND: $ switch (LOWORD (wParam))
{
case IDOK:
case IDCANCEL: $ SetForegroundWindow (txWindow());
$ EndDialog (wnd, (INT_PTR) this__); break;
default: $ break;
}
default: $ break;
}
$ return this__-> dialogProc (wnd, msg, wParam, lParam);
}
//-----------------------------------------------------------------------------------------------------------------
void* _tx_DLGTEMPLATE_Create (void* globalMem, size_t bufsize, DWORD style, DWORD exStyle,
WORD controls, short x, short y, short cx, short cy,
const char caption[], const char font[], WORD fontsize, HANDLE menu)
{
$1 _TX_IF_ARGUMENT_FAILED (globalMem) return NULL;
$ WORD* pw = (WORD*) globalMem;
$ DLGTEMPLATE* tmpl = ((DLGTEMPLATE*&) pw)++;
$ tmpl->style = style;
$ tmpl->dwExtendedStyle = exStyle;
$ tmpl->cdit = controls;
$ tmpl->x = x;
$ tmpl->y = y;
$ tmpl->cx = cx;
$ tmpl->cy = cy;
$ *pw++ = (WORD)(ptrdiff_t) NULL;
$ *pw++ = (WORD)(ptrdiff_t) menu;
$ if (caption)
{
$ pw += MultiByteToWideChar (_TX_CP, 0, caption? caption : "", -1, (wchar_t*) pw,
(int) (bufsize? bufsize - ((char*)pw - (char*)globalMem) : 0xFFFF));
}
$ if (style & DS_SETFONT)
{
$ *pw++ = fontsize;
$ pw += MultiByteToWideChar (_TX_CP, 0, font? font : "", -1, (wchar_t*) pw,
(int) (bufsize? bufsize - ((char*)pw - (char*)globalMem) : 0xFFFF));
}
$ return pw;
}
//-----------------------------------------------------------------------------------------------------------------
void* _tx_DLGTEMPLATE_Add (void* dlgTemplatePtr, size_t bufsize, DWORD style, DWORD exStyle,
short x, short y, short cx, short cy,
WORD id, const char wclass[], const char caption[])
{
$1 _TX_IF_ARGUMENT_FAILED (dlgTemplatePtr) return NULL;
$ WORD* pw = (LPWORD) dlgTemplatePtr; // Force align at word boundary
$ (ULONG&) pw += 3;
$ (ULONG&) pw >>= 2;
$ (ULONG&) pw <<= 2;
$ DLGITEMTEMPLATE* tmpl = ((DLGITEMTEMPLATE*&) pw)++;
$ tmpl->style = style;
$ tmpl->dwExtendedStyle = exStyle;
$ tmpl->x = x;
$ tmpl->y = y;
$ tmpl->cx = cx;
$ tmpl->cy = cy;
$ tmpl->id = id;
$ if (HIWORD (wclass) == 0xFFFF)
{
$ *pw++ = (WORD) (HIWORD ((ptrdiff_t) wclass));
$ *pw++ = (WORD) (LOWORD ((ptrdiff_t) wclass));
}
else if (wclass)
{
$ pw += MultiByteToWideChar (_TX_CP, 0, const_cast <char*> (wclass), -1, (wchar_t*) pw,
(int) (bufsize? bufsize - ((char*)pw - (char*)dlgTemplatePtr) : 0xFFFF));
}
else
{
$ *pw++ = 0;
}
$ if (caption)
{
$ pw += MultiByteToWideChar (_TX_CP, 0, caption, -1, (wchar_t*) pw,
(int) (bufsize? bufsize - ((char*)pw - (char*)dlgTemplatePtr) : 0xFFFF));
}
else
{
$ *pw++ = 0;
}
$ *pw++ = 0;
$ return pw;
}
//}
//=================================================================================================================
//=================================================================================================================
//{ Cleaning up the utility macros
// Î÷èñòêà ñëóæåáíûõ ìàêðîñîâ
//=================================================================================================================
#undef $
//}
//=================================================================================================================
//! @endcond
//}
//=================================================================================================================
/*! @cond INTERNAL */
} } // namespace TX, anonymous namespace
/*! @endcond */
//-----------------------------------------------------------------------------------------------------------------
//{ Easy using of TX:: and some of std::
//-----------------------------------------------------------------------------------------------------------------
using namespace TX; // Allow easy usage of TXLib functions
using ::std::cin; // Predefined usings to avoid "using namespace std"
using ::std::cout;
using ::std::cerr;
using ::std::string;
//}
//-----------------------------------------------------------------------------------------------------------------
//=================================================================================================================
//{ [Experimental] Debugging macros
//! @name Ýêñïåðèìåíòàëüíûå îòëàäî÷íûå ìàêðîñû
//=================================================================================================================
//{----------------------------------------------------------------------------------------------------------------
//! @ingroup Misc
//! @brief Îòëàäî÷íàÿ ïå÷àòü ïåðåìåííîé âî âðåìÿ âû÷èñëåíèÿ âûðàæåíèÿ èëè ó÷àñòêà êîäà
//! âî âðåìÿ åãî âûïîëíåíèÿ
//!
//! @warning Ýòè ìàêðîñû ìîãóò èçìåíèòüñÿ â áóäóùèõ âåðñèÿõ.
//!
//! @title Íàçíà÷åíèå: @table
//! @tr <tt> $ (x) </tt> @td Ïå÷àòü èìåíè è çíà÷åíèÿ ïåðåìåííîé @c x âíóòðè âûðàæåíèÿ.
//! @tr <tt> $_(x) </tt> @td Ïå÷àòü òîëüêî çíà÷åíèÿ ïåðåìåííîé @c x âíóòðè âûðàæåíèÿ.
//! @tbr
//! @tr <tt> $$ (expr) </tt> @td Ïå÷àòü âûðàæåíèÿ, åãî âû÷èñëåíèå, ïå÷àòü è âîçâðàò çíà÷åíèÿ. @n
//! Åñëè âûðàæåíèå ñîäåðæèò îïåðàòîð "çàïÿòàÿ", íå âçÿòûé â ñêîáêè,
//! íåîáõîäèìî îêðóæàòü expr åùå îäíîé ïàðîé ñêîáîê.
//! @tr <tt> $$_(expr) </tt> @td Òî æå, ÷òî è <tt>$$(expr),</tt> íî âòîðàÿ ïå÷àòü èäåò áåç íîâîé ñòðîêè.
//! @tbr
//! @tr <tt> $$$ (expr) </tt> @td Òî æå, ÷òî è <tt>$$(expr),</tt> íî äëÿ îïåðàòîðîâ èëè áëîêîâ êîäà (áåç âîçâðàòà çíà÷åíèÿ).
//! @tr <tt> $$$_(expr) </tt> @td Òî æå, ÷òî è <tt>$$$(expr),</tt> íî âòîðàÿ ïå÷àòü èäåò áåç íîâîé ñòðîêè.
//! @tbr
//! @tr <tt> $$$$ </tt> @td Ïå÷àòü ìåñòîïîëîæåíèÿ â êîäå.
//! @tr <tt> $$$$_ </tt> @td Ïå÷àòü ìåñòîïîëîæåíèÿ â êîäå (òîëüêî èìÿ ôóíêöèè).
//! @tr <tt> $n </tt> @td Ïåðåâîä ñòðîêè (ïå÷àòü @c '\\n').
//! @endtable
//!
//! @title Óñòàíîâêà àòðèáóòîâ ñèìâîëîâ êîíñîëè: @table
//! @tr @c $d @td Ñâåòëî-ñåðûé öâåò @td @td @c $T @td Ïðîçðà÷íûé öâåò
//! @tr @c $b @td Ñâåòëî-ñèíèé öâåò @td @td @c $B @td Òåìíî-ñèíèé öâåò
//! @tr @c $g @td Ñâåòëî-çåëåíûé öâåò @td @td @c $G @td Òåìíî-çåëåíûé öâåò
//! @tr @c $c @td Ñâåòëî-áèðþçîâûé öâåò @td @td @c $C @td Òåìíî-áèðþçîâûé öâåò
//! @tr @c $r @td Ñâåòëî-êðàñíûé öâåò @td @td @c $R @td Òåìíî-êðàñíûé öâåò
//! @tr @c $m @td Ñâåòëî-ìàëèíîâûé öâåò @td @td @c $M @td Òåìíî-ìàëèíîâûé öâåò
//! @tr @c $y @td Æåëòûé öâåò @td @td @c $Y @td Òåìíî-æåëòûé öâåò
//! @tr @c $t @td Áåëûé öâåò @td @td @c $D @td Òåìíî-ñåðûé öâåò
//! @endtable
//! @title @table
//! @tr @c $a @td Assertion @td Ñâåòëî-çåëåíûé íà çåëåíîì @td
//! @td @c $A @td Assertion bold @td Æåëòûé íà çåëåíîì @td
//! @tr @c $i @td Information @td Ñâåòëî-ñèíèé íà ñèíåì @td
//! @td @c $I @td Information bold @td Æåëòûé íà ñèíåì @td
//! @tr @c $w @td Warning @td Ñâåòëî-ìàëèíîâûé íà ìàëèíîâîì @td
//! @td @c $W @td Warning bold @td Æåëòûé íà ìàëèíîâîì @td
//! @tr @c $e @td Error @td Ñâåòëî-êðàñíûé íà êðàñíîì @td
//! @td @c $E @td Error bold @td Æåëòûé íà êðàñíîì @td
//! @tr @c $f @td Fatal @td ×åðíûé íà ñâåòëî-êðàñíîì @td
//! @td @c $F @td Fatal bold @td Ìàëèíîâûé íà ñâåòëî-êðàñíîì @td
//! @tr @c $l @td Location @td ×åðíûé íà òåìíî-ñåðîì @td
//! @td @c $L @td Location bold @td Ñâåòëî-ñåðûé íà òåìíî-ñåðîì @td
//! @endtable
//! @title @table
//! @tr @c $s @td Çàïîìíèòü àòðèáóòû. Ïðè âûõîäå èç áëîêà êîäà àòðèáóòû âîññòàíàâëèâàþòñÿ.
//! @endtable
//!
//! @see assert(), asserted, __TX_FILELINE__, __TX_FUNCTION__, TX_ERROR
//!
//! @usage @code
//! $g // green
//! int x = 5;
//! int y = $(x) + 1;
//! $$( x = $(y) + 2 );
//!
//! $r // red
//! double xy = $$( pow (x, y) );
//!
//! $$$$
//! double h = $$(( $(x) = x*x, y = y*y, sqrt ($(x+y)) ));
//!
//! $$( txCreateWindow (800, 600) );
//!
//! $d // default color
//! $$$( if ($(xy) < $(h)) { $s return $(h); } )
//!
//! $$$$
//! @endcode
//}----------------------------------------------------------------------------------------------------------------
#ifndef __TX_DEBUG_MACROS
#define __TX_DEBUG_MACROS ("Ãðóïïà îòëàäî÷íûõ $-ìàêðîñîâ")
//! @cond INTERNAL
#define $_(var) _txDump (var)
#define $(var) ( _txDump ((var), "[" #var " = ", "] ") )
#define $$(cmd) ( std::cerr << "\n[" __TX_FILELINE__ ": " #cmd "]\n", \
_txDump ((cmd),"\n[" __TX_FILELINE__ ": " #cmd ": ", ", DONE]\n") )
#define $$_(cmd) ( std::cerr << "\n[" __TX_FILELINE__ ": " #cmd "]\n", \
_txDump ((cmd), "[" __TX_FILELINE__ ": " #cmd ": ", ", DONE]\n") )
#define $$$(cmd) { std::cerr << "\n[" __TX_FILELINE__ ": " #cmd "]\n"; \
_txDumpSuffix ("\n[" __TX_FILELINE__ ": " #cmd " DONE]\n"); { cmd; } }
#define $$$_(cmd) { std::cerr << "\n[" __TX_FILELINE__ ": " #cmd "]\n"; \
_txDumpSuffix ( "[" __TX_FILELINE__ ": " #cmd " DONE]\n"); { cmd; } }
#define $$$$ { txOutputDebugPrintf ("\f\n"); \
{ $s $l txOutputDebugPrintf ("\f" "[%s (%d) %s]", __FILE__, __LINE__, __TX_FUNCTION__); } txOutputDebugPrintf ("\f\n"); }
#define $$$$_ { txOutputDebugPrintf ("\f\n"); \
{ $s $l txOutputDebugPrintf ("\f" "[%s]", __func__); } txOutputDebugPrintf ("\f\n"); }
#define $n std::cerr << "\n";
#define $s _txSaveConsoleAttr __txSaveConsoleAttr;
#define $T txSetConsoleAttr (0x00);
#define $B txSetConsoleAttr (0x01);
#define $G txSetConsoleAttr (0x02);
#define $C txSetConsoleAttr (0x03);
#define $R txSetConsoleAttr (0x04);
#define $M txSetConsoleAttr (0x05);
#define $Y txSetConsoleAttr (0x06);
#define $d txSetConsoleAttr (0x07);
#define $D txSetConsoleAttr (0x08);
#define $b txSetConsoleAttr (0x09);
#define $g txSetConsoleAttr (0x0a);
#define $c txSetConsoleAttr (0x0b);
#define $r txSetConsoleAttr (0x0c);
#define $m txSetConsoleAttr (0x0d);
#define $y txSetConsoleAttr (0x0e);
#define $t txSetConsoleAttr (0x0f);
#define $i txSetConsoleAttr (0x1b);
#define $I txSetConsoleAttr (0x1e);
#define $a txSetConsoleAttr (0x2a);
#define $A txSetConsoleAttr (0x2e);
#define $e txSetConsoleAttr (0x4f);
#define $E txSetConsoleAttr (0x4e);
#define $w txSetConsoleAttr (0x5d);
#define $W txSetConsoleAttr (0x5e);
#define $f txSetConsoleAttr (0xc0);
#define $F txSetConsoleAttr (0xc5);
#define $l txSetConsoleAttr (0x80);
#define $L txSetConsoleAttr (0x87);
//-----------------------------------------------------------------------------------------------------------------
#if !defined (_MSC_VER_6)
template <typename T> inline
const T& _txDump (const T& value, const char* prefix = "", const char* suffix = "")
{
std::cerr << prefix << value << suffix;
return value;
}
#endif
template <typename T> inline
T& _txDump ( T& value, const char* prefix = "", const char* suffix = "")
{
std::cerr << prefix << value << suffix;
return value;
}
struct _txDumpSuffix
{
const char* suffix_;
inline _txDumpSuffix (const char* suffix = "") : suffix_ (suffix) {}
inline ~_txDumpSuffix() { std::cerr << suffix_; }
_txDumpSuffix (const _txDumpSuffix&);
_txDumpSuffix& operator = (const _txDumpSuffix&);
};
struct _txSaveConsoleAttr
{
unsigned attr_;
inline _txSaveConsoleAttr() : attr_ (txGetConsoleAttr ()) {}
inline _txSaveConsoleAttr (WORD attr) : attr_ (txGetConsoleAttr ()) { txSetConsoleAttr (attr); }
inline ~_txSaveConsoleAttr() { txSetConsoleAttr (attr_); }
};
//! @endcond
#endif
//}
//=================================================================================================================
//-----------------------------------------------------------------------------------------------------------------
//{ Compiler- and platform-specific
// Àäàïòàöèÿ ê êîìïèëÿòîðàì è ïëàòôîðìàì
//-----------------------------------------------------------------------------------------------------------------
//! @cond INTERNAL
#if defined (_GCC_VER) && (_GCC_VER >= 420)
#pragma GCC optimize ("strict-aliasing")
#if (_GCC_VER >= 460)
#pragma GCC diagnostic pop
#else
#pragma GCC diagnostic warning "-Wstrict-aliasing"
#pragma GCC diagnostic warning "-Wshadow"
#endif
// Still block this warnings to avoid reporting about "= {0}" or "= {}" init style,
// and old style cast used in Windows.h RGB() macro.
#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
#pragma GCC diagnostic ignored "-Wold-style-cast"
// These warnings really occur at end of compilation, so block them too.
#pragma GCC diagnostic ignored "-Wunreachable-code"
#pragma GCC diagnostic ignored "-Wunused-label"
#pragma GCC diagnostic ignored "-Winline"
#endif
//-----------------------------------------------------------------------------------------------------------------
#if defined (_MSC_VER)
#pragma warning (default: 4127) // conditional expression is constant
#pragma warning (default: 4351) // new behavior: elements of array will be default initialized
#pragma warning (default: 4511) // copy constructor could not be generated
#pragma warning (default: 4512) // assignment operator could not be generated
#pragma warning (default: 4663) // C++ language change: to explicitly specialize class template
#pragma warning (default: 4702) // unreachable code
#if (_MSC_VER >= 1400) // MSVC 8 (2005) or greater
#pragma warning (default: 26135) // missing locking annotation
#pragma warning (default: 28125) // the function must be called from within a try/except block
#pragma warning (default: 28159) // consider using another function instead
#endif
// This warning really occur at end of compilation, so still block it.
#pragma warning (disable: 4514) // unreferenced inline function has been removed
#pragma warning (disable: 4710) // function not inlined
#pragma warning (disable: 4786) // identifier was truncated to '255' characters in the debug information
#endif
#if defined (__INTEL_COMPILER)
#pragma warning (default: 174) // remark: expression has no effect
#pragma warning (default: 304) // remark: access control not specified ("public" by default)
#pragma warning (default: 522) // remark: function redeclared "inline" after being called
#pragma warning (default: 981) // remark: operands are evaluated in unspecified order
#pragma warning (default: 1684) // conversion from pointer to same-sized integral type (potential portability problem)
#endif
//! @endcond
//}
//-----------------------------------------------------------------------------------------------------------------
#endif // __TXLIB_H_INCLUDED
//=================================================================================================================
// EOF
//=================================================================================================================
Reference in a new issue View git blame Copy permalink