Mirrors/eepp
1
0
Fork 0
mirror of https://github.com/SpartanJ/eepp.git synced 2026-08-13 04:42:12 +03:00
Code Issues Packages Projects Releases Wiki Activity

Minor fixes and refactor.

Browse Source
This commit is contained in:
Martín Lucas Golini
2023-07-08 02:16:35 -03:00
parent dbfedc5b58
commit c1dfb83ed6
31 changed files with 2781 additions and 2109 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
README.md
View File

@@ -366,7 +366,7 @@ Note: Please use a modern browser with good WebGL and WASM support (Chrome/ium 7
## How to build it
The library has only one external dependency. You will only need **SDL2** library with the headers
installed. Also **premake4** or **premake5** is needed to generate the Makefiles or project
installed. Also **premake5** or **premake4** is needed to generate the Makefiles or project
files to build the library. I will assume that you know what you are doing and
skip the basics.
@@ -381,16 +381,16 @@ need to add the parameter `--without-mojoal` to any `premake` call
In a Ubuntu system it would be something like ( also you will need gcc but it
will be installed anyways ):
`sudo apt-get install premake4 libsdl2-2.0-0 libsdl2-dev libopenal1 libopenal-dev`
`sudo apt-get install premake5 libsdl2-2.0-0 libsdl2-dev libopenal1 libopenal-dev`
Clone the repository and run on the repository root directory:
`premake4 gmake`
or if you have premake5 installed you can run:
`premake5 gmake2`
or if you have premake4 installed you can run:
`premake4 gmake`
Then just build the library:
`make -C make/linux`
@@ -402,7 +402,7 @@ That's it. That will build the whole project.
You have two options: build with [Visual Studio](https://visualstudio.microsoft.com/)
or with [MinGW](https://sourceforge.net/projects/mingw-w64/).
To be able to build the project with any of these options first you will need to
generate the project files with [premake4 or premake5](https://premake.github.io/download.html).
generate the project files with [premake4 or premake5](https://premake.github.io/download).
Then you will need to add the binary file to any of the executable paths defined
in `PATH` ( or add one, or use it from a local path ). Also you will need to
install the prebuild binaries and development libraries of [SDL2](http://libsdl.org/download-2.0.php)
@@ -437,9 +437,9 @@ _VS2022 Community Edition_ the path usually is:
#### MinGW
`premake4.exe gmake`
`premake5.exe gmake2`
Then just build the project located in `make/windows/` with `mingw32-make.exe`
Then just build the project located in `make/windows/` with `mingw32-make.exe` or `mingw64-make.exe` (depending on your target architecture)
or any equivalent:
`mingw32-make.exe -C make\windows`

81
bin/assets/colorschemes/colorschemes.conf
View File

@@ -40,6 +40,48 @@ function = #00dc7f,shadow
link = #6ae0f9,shadow
link_hover = transparent,shadow,underline
[onedark]
background = #282c34
text = #e1e1e6
caret = #93DDFA
selection = #394484
line_highlight = #2d303d
line_number = #525259
line_number2 = #83838f
gutter_background = #282c34
whitespace = #394484
line_break_column = #54575b99
matching_bracket = #FFFFFF33
matching_selection = #3e596e
matching_search = #181b1e
suggestion = #e1e1e6,#1d1f27
suggestion_selected = #ffffff,#222533
suggestion_scrollbar = #3daee9
error = red
warning = yellow
notice = #8abdff
selection_region = #39448477
minimap_background = #282c34AA
minimap_visible_area = #FFFFFF1A
minimap_current_line = #FFFFFF0A
minimap_hover = #FFFFFF1A
minimap_selection = #8abdff80
minimap_highlight = #FFFF0080
normal = #aab2c0
symbol = #aab2c0
comment = #5c6370
keyword = #d372e3
keyword2 = #f6c976
keyword3 = #ff7285
number = #edba54
literal = #f1fa8c
string = #9bdc7c
operator = #a4b2c0
function = #46aff5
link = #46aff5
link_hover = transparent,shadow,underline
[lite]
background = #2e2e32
text = #e1e1e6
@@ -62,6 +104,7 @@ symbol = #e1e1e6
comment = #676b6f
keyword = #E58AC9
keyword2 = #F77483
keyword3 = #FFA94D
number = #FFA94D
literal = #FFA94D
string = #f7c95c
@@ -85,6 +128,7 @@ symbol = #efdab9
comment = #615d5f
keyword = #d36e2d
keyword2 = #ef6179
keyword3 = #ffd152
number = #ffd152
literal = #ffd152
string = #ffd152
@@ -106,6 +150,7 @@ symbol = #181818
comment = #22a21f
keyword = #fb6620
keyword2 = #fc1785
keyword3 = #1586d2
number = #1586d2
literal = #1586d2
string = #1586d2
@@ -156,6 +201,7 @@ symbol = #ebdbb2
comment = #928374
keyword = #fb4934
keyword2 = #83a598
keyword3 = #d3869b
number = #d3869b
literal = #d3869b
string = #b8bb26
@@ -177,6 +223,7 @@ symbol = #d4be98
comment = #a9b665
keyword = #e86861
keyword2 = #e78a4e
keyword3 = #d3869b
number = #d3869b
literal = #d3869b
string = #d8a657
@@ -200,6 +247,7 @@ symbol = #71a9d7
comment = #5c6370
keyword = #98c875
keyword2 = #ffffff
keyword3 = #a3b2cf
number = #ffffff
literal = #ea5964
string = #ea5964
@@ -222,6 +270,7 @@ symbol = #a0a0a0
comment = #404040
keyword = #f0f0f0
keyword2 = #f0f0f0
keyword3 = #f0f0f0
number = #f0f0f0
literal = #f0f0f0
string = #f0f0f0
@@ -243,6 +292,7 @@ symbol = #F8F8F2
comment = #75715E
keyword = #F92672
keyword2 = #66DAEF
keyword3 = #AE81FF
number = #AE81FF
literal = #AE81FF
string = #E6DB74
@@ -264,6 +314,7 @@ symbol = #f5faff
comment = #6272a4
keyword = #ff79c6
keyword2 = #8be9fd
keyword3 = #bd93f9
number = #bd93f9
literal = #bd93f9
string = #f1fa8c
@@ -285,6 +336,7 @@ symbol = #24292e
comment = #6a737d
keyword = #d73a49
keyword2 = #d73a49
keyword3 = #005cc5
number = #005cc5
literal = #005cc5
string = #032f62
@@ -313,6 +365,7 @@ symbol = #657b83
comment = #93a1a1
keyword = #859900
keyword2 = #268bd2
keyword3 = #d33682
number = #d33682
literal = #2aa198
string = #2aa198
@@ -341,6 +394,7 @@ symbol = #00ff7f
comment = #6c71c4
keyword = #6c71c4
keyword2 = #6c71c4
keyword3 = #00ff7f
number = #00ff7f
literal = #1586d2
string = #f7f97d
@@ -362,6 +416,7 @@ symbol = #a0a0a0
comment = #404040
keyword = #dfdfdf
keyword2 = #dfdfdf
keyword3 = #dfdfdf
number = #dfdfdf
literal = #dfdfdf
string = #dfdfdf
@@ -369,8 +424,8 @@ operator = #01A870
function = #01A870
[vscode dark]
background = #1E1E1E
text = #D4D4D4
background = #1F1F1F
text = #cccccc
caret = #FFFFFF
accent = #76BCFF
selection = #264F78
@@ -378,16 +433,17 @@ line_number = #707070
line_number2 = #A0A0A0
line_highlight = #333A40
normal = #D4D4D4
symbol = #D4D4D4
comment = #6A9955
keyword = #569CD6
keyword2 = #C586C0
normal = #cccccc
symbol = #cccccc
comment = #6a9955
keyword = #C586C0
keyword2 = #4CC1A9
keyword3 = #99D7F8
number = #B5CEA8
literal = #569CD6
literal = #CE9178
string = #CE9178
operator = #8590A5
function = #DCDCAA
operator = #DA70D6
function = #D1D1A2
[zenburn]
background = #404040
@@ -404,6 +460,7 @@ symbol = #dcdccc
comment = #7f9f7f
keyword = #f0dfaf
keyword2 = #dfdfbf
keyword3 = #8cd0d3
number = #8cd0d3
literal = #dfaf8f
string = #cc9393
@@ -425,6 +482,7 @@ symbol = #D8DEE9
comment = #4C566A
keyword = #81A1C1
keyword2 = #81A1C1
keyword3 = #B48EAD
number = #B48EAD
literal = #81A1C1
string = #A3BE8C
@@ -448,6 +506,7 @@ symbol = #97e1f1
comment = #676b6f
keyword = #E58AC9
keyword2 = #F77483
keyword3 = #FFA94D
number = #FFA94D
literal = #ee6666
string = #f7c95c
@@ -469,6 +528,7 @@ symbol = #181818
comment = #43cdbd
keyword = #5f7dcd
keyword2 = #9c53c6
keyword3 = #3daee9
number = #3daee9
literal = #3daee9
string = #3daee9
@@ -497,6 +557,7 @@ symbol = #4c4f82
comment = #93a1a1
keyword = #d33682
keyword2 = #6c71c4
keyword3 = #859900
number = #859900
literal = #b58900
string = #cb4b16

306
include/eepp/system/time.hpp
View File

@@ -7,9 +7,6 @@
namespace EE { namespace System {
/* Based on the SFML2 implementation ( not the same, this version uses doubles for seconds and
* milliseconds ) */
/** Represents a time value */
class EE_API Time {
public:
@@ -19,22 +16,22 @@ class EE_API Time {
/** @brief Default constructor
** Sets the time value to zero. */
Time();
constexpr Time();
/** @brief Return the time value as a number of seconds
** @return Time in seconds
** @see AsMilliseconds, AsMicroseconds */
double asSeconds() const;
constexpr double asSeconds() const;
/** @brief Return the time value as a number of milliseconds
** @return Time in milliseconds
** @see AsSeconds, AsMicroseconds */
double asMilliseconds() const;
constexpr double asMilliseconds() const;
/** @brief Return the time value as a number of microseconds
** @return Time in microseconds
** @see asSeconds, asMilliseconds */
Int64 asMicroseconds() const;
constexpr Int64 asMicroseconds() const;
static const Time Zero; ///< Predefined "zero" time value
@@ -42,228 +39,155 @@ class EE_API Time {
std::string toString() const;
private:
friend EE_API Time Minutes( double );
friend EE_API Time Seconds( double );
friend EE_API Time Milliseconds( double );
friend EE_API Time Microseconds( Int64 );
friend EE_API constexpr Time Minutes( double );
friend EE_API constexpr Time Seconds( double );
friend EE_API constexpr Time Milliseconds( double );
friend EE_API constexpr Time Microseconds( Int64 );
/** @brief Construct from a number of microseconds
** This function is internal. To construct time values,
** use Seconds, Milliseconds or Microseconds instead.
** @param microseconds Number of microseconds */
explicit Time( Int64 microseconds );
constexpr explicit Time( Int64 microseconds );
Int64 mMicroseconds; ///< Time value stored as microseconds
};
/// @relates EE::System::Time
/// @brief Construct a time value from a number of minutes
/// @param amount Number of minutes
/// @return Time value constructed from the amount of seconds
/// @see Milliseconds, Microseconds
EE_API Time Minutes( double amount );
constexpr Time::Time() : mMicroseconds( 0 ) {}
/// @relates EE::System::Time
/// @brief Construct a time value from a number of seconds
/// @param amount Number of seconds
/// @return Time value constructed from the amount of seconds
/// @see Milliseconds, Microseconds
EE_API Time Seconds( double amount );
constexpr Time::Time( Int64 Microseconds ) : mMicroseconds( Microseconds ) {}
/// @relates EE::System::Time
/// @brief Construct a time value from a number of milliseconds
/// @param amount Number of milliseconds
/// @return Time value constructed from the amount of milliseconds
/// @see Seconds, Microseconds
EE_API Time Milliseconds( double amount );
constexpr double Time::asSeconds() const {
return mMicroseconds / 1000000.0;
}
/// @relates EE::System::Time
/// @brief Construct a time value from a number of microseconds
/// @param amount Number of microseconds
/// @return Time value constructed from the amount of microseconds
/// @see Seconds, Milliseconds
EE_API Time Microseconds( Int64 amount );
constexpr double Time::asMilliseconds() const {
return mMicroseconds / 1000.0;
}
/// @relates EE::System::Time
/// @brief Overload of == operator to compare two time values
/// @param left Left operand (a time)
/// @param right Right operand (a time)
/// @return True if both time values are equal
EE_API bool operator==( Time left, Time right );
constexpr Int64 Time::asMicroseconds() const {
return mMicroseconds;
}
/// @relates EE::System::Time
/// @brief Overload of != operator to compare two time values
/// @param left Left operand (a time)
/// @param right Right operand (a time)
/// @return True if both time values are different
EE_API bool operator!=( Time left, Time right );
constexpr Time Minutes( double amount ) {
return Time( static_cast<Int64>( amount * 1000000 * 60 ) );
}
/// @relates EE::System::Time
/// @brief Overload of < operator to compare two time values
/// @param left Left operand (a time)
/// @param right Right operand (a time)
/// @return True if @a left is lesser than @a right
EE_API bool operator<( Time left, Time right );
constexpr Time Seconds( double amount ) {
return Time( static_cast<Int64>( amount * 1000000 ) );
}
/// @relates EE::System::Time
/// @brief Overload of > operator to compare two time values
/// @param left Left operand (a time)
/// @param right Right operand (a time)
/// @return True if @a left is greater than @a right
EE_API bool operator>( Time left, Time right );
constexpr Time Milliseconds( double amount ) {
return Time( static_cast<Int64>( amount * 1000 ) );
}
/// @relates EE::System::Time
/// @brief Overload of <= operator to compare two time values
/// @param left Left operand (a time)
/// @param right Right operand (a time)
/// @return True if @a left is lesser or equal than @a right
EE_API bool operator<=( Time left, Time right );
constexpr Time Microseconds( Int64 amount ) {
return Time( amount );
}
/// @relates EE::System::Time
/// @brief Overload of >= operator to compare two time values
/// @param left Left operand (a time)
/// @param right Right operand (a time)
/// @return True if @a left is greater or equal than @a right
EE_API bool operator>=( Time left, Time right );
constexpr bool operator==( Time left, Time right ) {
return left.asMicroseconds() == right.asMicroseconds();
}
/// @relates EE::System::Time
/// @brief Overload of unary - operator to negate a time value
/// @param right Right operand (a time)
/// @return Opposite of the time value
EE_API Time operator-( Time right );
constexpr bool operator!=( Time left, Time right ) {
return left.asMicroseconds() != right.asMicroseconds();
}
/// @relates EE::System::Time
/// @brief Overload of binary + operator to add two time values
/// @param left Left operand (a time)
/// @param right Right operand (a time)
/// @return Sum of the two times values
EE_API Time operator+( Time left, Time right );
constexpr bool operator<( Time left, Time right ) {
return left.asMicroseconds() < right.asMicroseconds();
}
/// @relates EE::System::Time
/// @brief Overload of binary += operator to add/assign two time values
/// @param left Left operand (a time)
/// @param right Right operand (a time)
/// @return Sum of the two times values
EE_API Time& operator+=( Time& left, Time right );
constexpr bool operator>( Time left, Time right ) {
return left.asMicroseconds() > right.asMicroseconds();
}
/// @relates EE::System::Time
/// @brief Overload of binary - operator to subtract two time values
/// @param left Left operand (a time)
/// @param right Right operand (a time)
/// @return Difference of the two times values
EE_API Time operator-( Time left, Time right );
constexpr bool operator<=( Time left, Time right ) {
return left.asMicroseconds() <= right.asMicroseconds();
}
/// @relates EE::System::Time
/// @brief Overload of binary -= operator to subtract/assign two time values
/// @param left Left operand (a time)
/// @param right Right operand (a time)
/// @return Difference of the two times values
EE_API Time& operator-=( Time& left, Time right );
constexpr bool operator>=( Time left, Time right ) {
return left.asMicroseconds() >= right.asMicroseconds();
}
/// @relates EE::System::Time
/// @brief Overload of binary * operator to scale a time value
/// @param left Left operand (a time)
/// @param right Right operand (a number)
/// @return @a left multiplied by @a right
EE_API Time operator*( Time left, Time right );
constexpr Time operator-( Time right ) {
return Microseconds( -right.asMicroseconds() );
}
/// @relates EE::System::Time
/// @brief Overload of binary * operator to scale a time value
/// @param left Left operand (a time)
/// @param right Right operand (a number)
/// @return @a left multiplied by @a right
EE_API Time operator*( Time left, double right );
constexpr Time operator+( Time left, Time right ) {
return Microseconds( left.asMicroseconds() + right.asMicroseconds() );
}
/// @relates EE::System::Time
/// @brief Overload of binary * operator to scale a time value
/// @param left Left operand (a number)
/// @param right Right operand (a time)
/// @return @a left multiplied by @a right
EE_API Time operator*( double left, Time right );
constexpr Time& operator+=( Time& left, Time right ) {
return left = left + right;
}
/// @relates EE::System::Time
/// @brief Overload of binary * operator to scale a time value
/// @param left Left operand (a number)
/// @param right Right operand (a time)
/// @return @a left multiplied by @a right
EE_API Time operator*( Int64 left, Time right );
constexpr Time operator-( Time left, Time right ) {
return Microseconds( left.asMicroseconds() - right.asMicroseconds() );
}
/// @relates EE::System::Time
/// @brief Overload of binary * operator to scale a time value
/// @param left Left operand (a time)
/// @param right Right operand (a number)
/// @return @a left multiplied by @a right
EE_API Time operator*( Time left, Int64 right );
constexpr Time& operator-=( Time& left, Time right ) {
return left = left - right;
}
/// @relates EE::System::Time
/// @brief Overload of binary *= operator to scale/assign a time value
/// @param left Left operand (a time)
/// @param right Right operand (a number)
/// @return @a left multiplied by @a right
EE_API Time& operator*=( Time& left, double right );
constexpr Time operator*( Time left, Time right ) {
return Microseconds( left.asMicroseconds() * right.asMicroseconds() );
}
/// @relates EE::System::Time
/// @brief Overload of binary *= operator to scale/assign a time value
/// @param left Left operand (a time)
/// @param right Right operand (a number)
/// @return @a left multiplied by @a right
EE_API Time& operator*=( Time& left, Int64 right );
constexpr Time operator*( Time left, double right ) {
return Seconds( left.asSeconds() * right );
}
/// @relates EE::System::Time
/// @brief Overload of binary *= operator to scale/assign a time value
/// @param left Left operand (a time)
/// @param right Right operand (a time)
/// @return @a left multiplied by @a right
EE_API Time& operator*=( Time& left, Time right );
constexpr Time operator*( double left, Time right ) {
return right * left;
}
/// @relates EE::System::Time
/// @brief Overload of binary / operator to scale a time value
/// @param left Left operand (a time)
/// @param right Right operand (a time)
/// @return @a left divided by @a right
EE_API Time operator/( Time left, Time right );
constexpr Time operator*( Time left, Int64 right ) {
return Microseconds( left.asMicroseconds() * right );
}
/// @relates EE::System::Time
/// @brief Overload of binary / operator to scale a time value
/// @param left Left operand (a time)
/// @param right Right operand (a number)
/// @return @a left divided by @a right
EE_API Time operator/( Time left, double right );
constexpr Time operator*( Int64 left, Time right ) {
return right * left;
}
/// @relates EE::System::Time
/// @brief Overload of binary / operator to scale a time value
/// @param left Left operand (a time)
/// @param right Right operand (a number)
/// @return @a left divided by @a right
EE_API Time operator/( Time left, Int64 right );
constexpr Time& operator*=( Time& left, Time right ) {
return left = left * right;
}
/// @relates EE::System::Time
/// @brief Overload of binary /= operator to scale/assign a time value
/// @param left Left operand (a time)
/// @param right Right operand (a number)
/// @return @a left divided by @a right
EE_API Time& operator/=( Time& left, Int64 right );
constexpr Time& operator*=( Time& left, double right ) {
return left = left * right;
}
/// @relates EE::System::Time
/// @brief Overload of binary /= operator to scale/assign a time value
/// @param left Left operand (a time)
/// @param right Right operand (a time)
/// @return @a left divided by @a right
EE_API Time& operator/=( Time& left, Time right );
constexpr Time& operator*=( Time& left, Int64 right ) {
return left = left * right;
}
/// @relates EE::System::Time
/// @brief Overload of binary % operator to compute remainder of a time value
/// @param left Left operand (a time)
/// @param right Right operand (a time)
/// @return @a left modulo @a right
EE_API Time operator%( Time left, Time right );
constexpr Time operator/( Time left, Time right ) {
return Microseconds( left.asMicroseconds() / right.asMicroseconds() );
}
/// @relates EE::System::Time
/// @brief Overload of binary %= operator to compute/assign remainder of a time value
/// @param left Left operand (a time)
/// @param right Right operand (a time)
/// @return @a left modulo @a right
EE_API Time& operator%=( Time& left, Time right );
constexpr Time operator/( Time left, double right ) {
return Seconds( left.asSeconds() / right );
}
constexpr Time operator/( Time left, Int64 right ) {
return Microseconds( left.asMicroseconds() / right );
}
constexpr Time& operator/=( Time& left, Time right ) {
return left = left / right;
}
constexpr Time& operator/=( Time& left, Int64 right ) {
return left = left / right;
}
constexpr Time operator%( Time left, Time right ) {
return Microseconds( left.asMicroseconds() % right.asMicroseconds() );
}
constexpr Time& operator%=( Time& left, Time right ) {
return left = left % right;
}
}} // namespace EE::System

2
include/eepp/ui/doc/syntaxdefinition.hpp
View File

@@ -36,6 +36,8 @@ class EE_API SyntaxDefinition {
const std::string& getLanguageName() const;
std::string getLanguageNameForFileSystem() const;
const String::HashType& getLanguageId() const;
const std::vector<std::string>& getFiles() const;

1
include/eepp/ui/uicodeeditor.hpp
View File

@@ -696,6 +696,7 @@ class EE_API UICodeEditor : public UIWidget, public TextDocument::Client {
Float mLongestLineWidth{ 0 };
Time mFindLongestLineWidthUpdateFrequency;
Clock mLongestLineWidthLastUpdate;
Clock mLastActivity;
TextSearchParams mHighlightWord;
TextRanges mHighlightWordCache;
Mutex mHighlightWordCacheMutex;

35
projects/linux/ee.files
View File

@@ -620,6 +620,27 @@
../../src/eepp/graphics/vertexbuffervbo.cpp
../../src/eepp/graphics/view.cpp
../../src/eepp/main/eepp_main.cpp
../../src/eepp/ui/doc/languages/batchscript.cpp
../../src/eepp/ui/doc/languages/batchscript.hpp
../../src/eepp/ui/doc/languages/css.cpp
../../src/eepp/ui/doc/languages/css.hpp
../../src/eepp/ui/doc/languages/d.cpp
../../src/eepp/ui/doc/languages/d.hpp
../../src/eepp/ui/doc/languages/htaccess.hpp
../../src/eepp/ui/doc/languages/objeck.hpp
../../src/eepp/ui/doc/languages/odin.cpp
../../src/eepp/ui/doc/languages/odin.hpp
../../src/eepp/ui/doc/languages/pascal.hpp
../../src/eepp/ui/doc/languages/perl.cpp
../../src/eepp/ui/doc/languages/perl.hpp
../../src/eepp/ui/doc/languages/pico-8.hpp
../../src/eepp/ui/doc/languages/postgresql.hpp
../../src/eepp/ui/doc/languages/rust.hpp
../../src/eepp/ui/doc/languages/sass.cpp
../../src/eepp/ui/doc/languages/solidity.cpp
../../src/eepp/ui/doc/languages/solidity.hpp
../../src/eepp/ui/doc/languages/sql.hpp
../../src/eepp/ui/doc/languages/x86assembly.hpp
../../src/modules/maps/src/eepp/maps/gameobject.cpp
../../src/modules/maps/src/eepp/maps/gameobjectobject.cpp
../../src/modules/maps/src/eepp/maps/gameobjectpolygon.cpp
@@ -833,13 +854,27 @@
../../src/eepp/ui/css/stylesheetvariable.cpp
../../src/eepp/ui/css/timingfunction.cpp
../../src/eepp/ui/css/transitiondefinition.cpp
../../src/eepp/ui/doc/languages/glsl.cpp
../../src/eepp/ui/doc/languages/glsl.hpp
../../src/eepp/ui/doc/languages/hlsl.cpp
../../src/eepp/ui/doc/languages/hlsl.hpp
../../src/eepp/ui/doc/languages/htaccess.cpp
../../src/eepp/ui/doc/languages/htaccess.hpp
../../src/eepp/ui/doc/languages/objeck.cpp
../../src/eepp/ui/doc/languages/objeck.hpp
../../src/eepp/ui/doc/languages/pascal.cpp
../../src/eepp/ui/doc/languages/pascal.hpp
../../src/eepp/ui/doc/languages/pico-8.cpp
../../src/eepp/ui/doc/languages/pico-8.hpp
../../src/eepp/ui/doc/languages/postgresql.cpp
../../src/eepp/ui/doc/languages/rust.cpp
../../src/eepp/ui/doc/languages/sass.hpp
../../src/eepp/ui/doc/languages/sql.cpp
../../src/eepp/ui/doc/languages/swift.cpp
../../src/eepp/ui/doc/languages/swift.hpp
../../src/eepp/ui/doc/languages/vb.cpp
../../src/eepp/ui/doc/languages/vb.hpp
../../src/eepp/ui/doc/languages/x86assembly.cpp
../../src/eepp/ui/doc/syntaxcolorscheme.cpp
../../src/eepp/ui/doc/syntaxdefinition.cpp
../../src/eepp/ui/doc/syntaxdefinitionmanager.cpp

136
src/eepp/system/time.cpp
View File

@@ -58,22 +58,6 @@ Time Time::fromString( const std::string& str ) {
return time;
}
Time::Time() : mMicroseconds( 0 ) {}
double Time::asSeconds() const {
return mMicroseconds / 1000000.0;
}
double Time::asMilliseconds() const {
return mMicroseconds / 1000.0;
}
Int64 Time::asMicroseconds() const {
return mMicroseconds;
}
Time::Time( Int64 Microseconds ) : mMicroseconds( Microseconds ) {}
std::string Time::toString() const {
Uint64 totalSeconds = asSeconds();
@@ -101,124 +85,4 @@ std::string Time::toString() const {
}
}
Time Minutes( double amount ) {
return Time( static_cast<Int64>( amount * 1000000 * 60 ) );
}
Time Seconds( double amount ) {
return Time( static_cast<Int64>( amount * 1000000 ) );
}
Time Milliseconds( double amount ) {
return Time( static_cast<Int64>( amount * 1000 ) );
}
Time Microseconds( Int64 amount ) {
return Time( amount );
}
bool operator==( Time left, Time right ) {
return left.asMicroseconds() == right.asMicroseconds();
}
bool operator!=( Time left, Time right ) {
return left.asMicroseconds() != right.asMicroseconds();
}
bool operator<( Time left, Time right ) {
return left.asMicroseconds() < right.asMicroseconds();
}
bool operator>( Time left, Time right ) {
return left.asMicroseconds() > right.asMicroseconds();
}
bool operator<=( Time left, Time right ) {
return left.asMicroseconds() <= right.asMicroseconds();
}
bool operator>=( Time left, Time right ) {
return left.asMicroseconds() >= right.asMicroseconds();
}
Time operator-( Time right ) {
return Microseconds( -right.asMicroseconds() );
}
Time operator+( Time left, Time right ) {
return Microseconds( left.asMicroseconds() + right.asMicroseconds() );
}
Time& operator+=( Time& left, Time right ) {
return left = left + right;
}
Time operator-( Time left, Time right ) {
return Microseconds( left.asMicroseconds() - right.asMicroseconds() );
}
Time& operator-=( Time& left, Time right ) {
return left = left - right;
}
Time operator*( Time left, Time right ) {
return Microseconds( left.asMicroseconds() * right.asMicroseconds() );
}
Time operator*( Time left, double right ) {
return Seconds( left.asSeconds() * right );
}
Time operator*( double left, Time right ) {
return right * left;
}
Time operator*( Time left, Int64 right ) {
return Microseconds( left.asMicroseconds() * right );
}
Time operator*( Int64 left, Time right ) {
return right * left;
}
Time& operator*=( Time& left, Time right ) {
return left = left * right;
}
Time& operator*=( Time& left, double right ) {
return left = left * right;
}
Time& operator*=( Time& left, Int64 right ) {
return left = left * right;
}
Time operator/( Time left, Time right ) {
return Microseconds( left.asMicroseconds() / right.asMicroseconds() );
}
Time operator/( Time left, double right ) {
return Seconds( left.asSeconds() / right );
}
Time operator/( Time left, Int64 right ) {
return Microseconds( left.asMicroseconds() / right );
}
Time& operator/=( Time& left, Time right ) {
return left = left / right;
}
Time& operator/=( Time& left, Int64 right ) {
return left = left / right;
}
Time operator%( Time left, Time right ) {
return Microseconds( left.asMicroseconds() % right.asMicroseconds() );
}
Time& operator%=( Time& left, Time right ) {
return left = left % right;
}
}} // namespace EE::System

148
src/eepp/ui/doc/languages/batchscript.cpp Normal file
View File

@@ -0,0 +1,148 @@
#include <eepp/ui/doc/languages/batchscript.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
namespace EE { namespace UI { namespace Doc { namespace Language {
void addBatchScript() {
SyntaxDefinitionManager::instance()->add(
{ "Batch Script",
{ "%.bat$", "%.cmd$" },
{
{ { "@echo off\n" }, "keyword" },
{ { "@echo on\n" }, "keyword" },
{ { "rem.-\n" }, "comment" },
{ { "REM.-\n" }, "comment" },
{ { "%s*:[%w%-]+" }, "symbol" },
{ { "%:%:.-\n" }, "comment" },
{ { "%%%w+%%" }, "symbol" },
{ { "%%%%?~?[%w:]+" }, "symbol" },
{ { "[!=()%>&%^/\\@]" }, "operator" },
{ { "-?%.?%d+f?" }, "number" },
{ { "\"", "\"", "\\" }, "string" },
{ { "[%a_][%w_]*" }, "normal" },
{ { ":eof" }, "keyword" },
},
{
{ "IF", "keyword" },
{ "if", "keyword" },
{ "FORFILES", "function" },
{ "CON", "keyword" },
{ "forfiles", "function" },
{ "cd", "function" },
{ "choice", "function" },
{ "command", "function" },
{ "shift", "function" },
{ "CMD", "function" },
{ "attrib", "function" },
{ "EXIT", "function" },
{ "for", "keyword" },
{ "com1", "keyword" },
{ "else", "keyword" },
{ "setlocal", "function" },
{ "in", "keyword" },
{ "SORT", "function" },
{ "FINDSTR", "function" },
{ "RMDIR", "function" },
{ "COMMAND", "function" },
{ "COM4", "keyword" },
{ "ren", "function" },
{ "ATTRIB", "function" },
{ "move", "function" },
{ "cmd", "function" },
{ "XCOPY", "function" },
{ "xcopy", "function" },
{ "COPY", "function" },
{ "findstr", "function" },
{ "ENDLOCAL", "function" },
{ "MOVE", "function" },
{ "ERRORLEVEL", "keyword" },
{ "copy", "function" },
{ "rmdir", "function" },
{ "RD", "function" },
{ "DEFINED", "keyword" },
{ "ECHO", "function" },
{ "DEL", "function" },
{ "echo", "function" },
{ "ENABLEDELAYEDEXPANSION", "function" },
{ "type", "function" },
{ "enabledelayedexpansion", "function" },
{ "TYPE", "function" },
{ "pause", "function" },
{ "set", "function" },
{ "CD", "function" },
{ "SETLOCAL", "function" },
{ "FIND", "function" },
{ "gtr", "keyword" },
{ "lpt1", "keyword" },
{ "chdir", "function" },
{ "LSS", "keyword" },
{ "lss", "keyword" },
{ "goto", "keyword" },
{ "GEQ", "keyword" },
{ "NEQ", "keyword" },
{ "LPT1", "keyword" },
{ "geq", "keyword" },
{ "defined", "keyword" },
{ "prn", "keyword" },
{ "del", "function" },
{ "VERIFY", "keyword" },
{ "verify", "keyword" },
{ "exist", "keyword" },
{ "DO", "keyword" },
{ "CALL", "keyword" },
{ "com4", "keyword" },
{ "EQU", "keyword" },
{ "COM1", "keyword" },
{ "GOTO", "keyword" },
{ "EXIST", "keyword" },
{ "SHIFT", "function" },
{ "equ", "keyword" },
{ "GTR", "keyword" },
{ "COM2", "keyword" },
{ "NUL", "keyword" },
{ "PRN", "keyword" },
{ "MD", "function" },
{ "COM3", "keyword" },
{ "LEQ", "keyword" },
{ "com2", "keyword" },
{ "nul", "keyword" },
{ "errorlevel", "keyword" },
{ "do", "keyword" },
{ "FOR", "keyword" },
{ "NOT", "keyword" },
{ "com3", "keyword" },
{ "call", "keyword" },
{ "not", "keyword" },
{ "ELSIF", "keyword" },
{ "ELSE", "keyword" },
{ "leq", "keyword" },
{ "exit", "function" },
{ "CHOICE", "function" },
{ "IN", "keyword" },
{ "cmdextversion", "keyword" },
{ "PAUSE", "function" },
{ "sort", "function" },
{ "CMDEXTVERSION", "keyword" },
{ "MKDIR", "function" },
{ "mkdir", "function" },
{ "CHDIR", "function" },
{ "rd", "function" },
{ "elsif", "keyword" },
{ "find", "function" },
{ "md", "function" },
{ "SET", "function" },
{ "endlocal", "function" },
{ "REN", "function" },
{ "neq", "keyword" },
{ "con", "keyword" },
},
"rem",
{},
"bat" } );
}
}}}} // namespace EE::UI::Doc::Language

10
src/eepp/ui/doc/languages/batchscript.hpp Normal file
View File

@@ -0,0 +1,10 @@
#ifndef EE_UI_DOC_Batchscript
#define EE_UI_DOC_Batchscript
namespace EE { namespace UI { namespace Doc { namespace Language {
extern void addBatchScript();
}}}}
#endif

275
src/eepp/ui/doc/languages/css.cpp Normal file
View File

@@ -0,0 +1,275 @@
#include <eepp/ui/doc/languages/css.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
namespace EE { namespace UI { namespace Doc { namespace Language {
void addCSS() {
SyntaxDefinitionManager::instance()->add(
{ "CSS",
{ "%.css$" },
{
{ { "\\." }, "normal" },
{ { "//.-\n" }, "comment" },
{ { "/%*", "%*/" }, "comment" },
{ { "\"", "\"", "\\" }, "string" },
{ { "'", "'", "\\" }, "string" },
{ { "^%s*#[%a%_%-][%w%_%-]*" }, "keyword2" },
{ { ",%s*#[%a%_%-][%w%_%-]*" }, "keyword2" },
{ { "#%x%x%x%x?%x?%x?%x?%x?" }, "string" },
{ { "#[%a%_%-][%w%_%-]*" }, "keyword2" },
{ { "%-%-%a[%w%-%_]*" }, "keyword2" },
{ { "-?%d+[%d%.]*p[xt]" }, "number" },
{ { "-?%d+[%d%.]*deg" }, "number" },
{ { "-?%d+[%d%.]*" }, "number" },
{ { "@[%a][%w%_%-]*" }, "keyword2" },
{ { "%.[%a%_%-][%w%_%-]*" }, "keyword2" },
{ { "(:)(hover)" }, { "normal", "operator", "literal" } },
{ { "(:)(focus%-within)" }, { "normal", "operator", "literal" } },
{ { "(:)(focus)" }, { "normal", "operator", "literal" } },
{ { "(:)(selected)" }, { "normal", "operator", "literal" } },
{ { "(:)(pressed)" }, { "normal", "operator", "literal" } },
{ { "(:)(disabled)" }, { "normal", "operator", "literal" } },
{ { "(:)(checked)" }, { "normal", "operator", "literal" } },
{ { "(:)(root)" }, { "normal", "operator", "link" } },
{ { "(%a+)(%()" }, { "normal", "function", "normal" } },
{ { "[%a][%w-]*%s*%f[:]" }, "keyword" },
{ { "[{}:>~!]" }, "operator" },
{ { "[%a_][%w_]*" }, "symbol" },
},
{
{ "orange", "literal" },
{ "tabwidget", "keyword" },
{ "olivedrab", "literal" },
{ "olive", "literal" },
{ "navajowhite", "literal" },
{ "mistyrose", "literal" },
{ "midnightblue", "literal" },
{ "darkseagreen", "literal" },
{ "mediumseagreen", "literal" },
{ "lavenderblush", "literal" },
{ "mediumaquamarine", "literal" },
{ "limegreen", "literal" },
{ "mediumspringgreen", "literal" },
{ "lightgreen", "literal" },
{ "lime", "literal" },
{ "mediumorchid", "literal" },
{ "gray", "literal" },
{ "black", "literal" },
{ "lightyellow", "literal" },
{ "mediumblue", "literal" },
{ "lightslategray", "literal" },
{ "lightseagreen", "literal" },
{ "tableview", "keyword" },
{ "input", "keyword" },
{ "lightpink", "literal" },
{ "lightslategrey", "literal" },
{ "lightgrey", "literal" },
{ "lightgoldenrodyellow", "literal" },
{ "lightblue", "literal" },
{ "lemonchiffon", "literal" },
{ "lawngreen", "literal" },
{ "mintcream", "literal" },
{ "pushbutton", "keyword" },
{ "khaki", "literal" },
{ "ivory", "literal" },
{ "moccasin", "literal" },
{ "indigo", "literal" },
{ "transparent", "literal" },
{ "oldlace", "literal" },
{ "indianred", "literal" },
{ "hotpink", "literal" },
{ "sizenwse", "literal" },
{ "honeydew", "literal" },
{ "false", "literal" },
{ "grey", "literal" },
{ "green", "literal" },
{ "cornflowerblue", "literal" },
{ "steelblue", "literal" },
{ "mediumturquoise", "literal" },
{ "lightgray", "literal" },
{ "goldenrod", "literal" },
{ "greenyellow", "literal" },
{ "saddlebrown", "literal" },
{ "lightcyan", "literal" },
{ "rlay", "keyword" },
{ "gainsboro", "literal" },
{ "hslider", "keyword" },
{ "fuchsia", "literal" },
{ "forestgreen", "literal" },
{ "palegoldenrod", "literal" },
{ "maroon", "literal" },
{ "floralwhite", "literal" },
{ "dodgerblue", "literal" },
{ "mediumvioletred", "literal" },
{ "dimgray", "literal" },
{ "peru", "literal" },
{ "deepskyblue", "literal" },
{ "textureregion", "keyword" },
{ "blue", "literal" },
{ "bisque", "literal" },
{ "slategray", "literal" },
{ "treeview", "keyword" },
{ "scrollbar", "keyword" },
{ "sizewe", "literal" },
{ "none", "literal" },
{ "image", "keyword" },
{ "checkbox", "keyword" },
{ "lavender", "literal" },
{ "cornsilk", "literal" },
{ "textinput", "keyword" },
{ "blueviolet", "literal" },
{ "skyblue", "literal" },
{ "darkslateblue", "literal" },
{ "lightsalmon", "literal" },
{ "a", "keyword" },
{ "widgettable", "keyword" },
{ "beige", "literal" },
{ "darkgray", "literal" },
{ "crimson", "literal" },
{ "menucheckbox", "keyword" },
{ "hscrollbar", "keyword" },
{ "dimgrey", "literal" },
{ "sizeall", "literal" },
{ "aliceblue", "literal" },
{ "progressbar", "keyword" },
{ "lightskyblue", "literal" },
{ "blanchedalmond", "literal" },
{ "darkslategray", "literal" },
{ "mediumpurple", "literal" },
{ "tomato", "literal" },
{ "paleturquoise", "literal" },
{ "darkturquoise", "literal" },
{ "powderblue", "literal" },
{ "codeeditor", "keyword" },
{ "wheat", "literal" },
{ "seashell", "literal" },
{ "hbox", "keyword" },
{ "sienna", "literal" },
{ "salmon", "literal" },
{ "menubar", "keyword" },
{ "silver", "literal" },
{ "tan", "literal" },
{ "thistle", "literal" },
{ "sandybrown", "literal" },
{ "turquoise", "literal" },
{ "azure", "literal" },
{ "plum", "literal" },
{ "vslider", "keyword" },
{ "waitarrow", "literal" },
{ "textview", "keyword" },
{ "springgreen", "literal" },
{ "widgettablerow", "keyword" },
{ "vscrollbar", "keyword" },
{ "wait", "literal" },
{ "relativelayout", "keyword" },
{ "palevioletred", "literal" },
{ "spinbox", "keyword" },
{ "darkblue", "literal" },
{ "linearlayout", "keyword" },
{ "chartreuse", "literal" },
{ "teal", "literal" },
{ "darkorchid", "literal" },
{ "seagreen", "literal" },
{ "listview", "keyword" },
{ "red", "literal" },
{ "selectbutton", "keyword" },
{ "viewpagerhorizontal", "keyword" },
{ "vbox", "keyword" },
{ "slategrey", "literal" },
{ "gridlayout", "keyword" },
{ "listbox", "keyword" },
{ "peachpuff", "literal" },
{ "coral", "literal" },
{ "stacklayout", "keyword" },
{ "center", "literal" },
{ "lightcoral", "literal" },
{ "rosybrown", "literal" },
{ "viewpager", "keyword" },
{ "tab", "keyword" },
{ "inputpassword", "keyword" },
{ "window", "keyword" },
{ "tooltip", "keyword" },
{ "scrollview", "keyword" },
{ "stackwidget", "keyword" },
{ "textedit", "keyword" },
{ "loader", "keyword" },
{ "combobox", "keyword" },
{ "radiobutton", "keyword" },
{ "dropdownlist", "keyword" },
{ "splitter", "keyword" },
{ "snow", "literal" },
{ "palegreen", "literal" },
{ "anchor", "keyword" },
{ "royalblue", "literal" },
{ "slider", "keyword" },
{ "violet", "literal" },
{ "whitesmoke", "literal" },
{ "white", "literal" },
{ "darksalmon", "literal" },
{ "pink", "literal" },
{ "slateblue", "literal" },
{ "darkred", "literal" },
{ "lightsteelblue", "literal" },
{ "darkolivegreen", "literal" },
{ "darkviolet", "literal" },
{ "yellowgreen", "literal" },
{ "widget", "keyword" },
{ "linen", "literal" },
{ "darkgrey", "literal" },
{ "menuradiobutton", "keyword" },
{ "crosshair", "literal" },
{ "darkcyan", "literal" },
{ "sprite", "keyword" },
{ "navy", "literal" },
{ "darkmagenta", "literal" },
{ "burlywood", "literal" },
{ "menuseparator", "keyword" },
{ "firebrick", "literal" },
{ "orchid", "literal" },
{ "chocolate", "literal" },
{ "darkgreen", "literal" },
{ "aquamarine", "literal" },
{ "ghostwhite", "literal" },
{ "arrow", "literal" },
{ "antiquewhite", "literal" },
{ "deeppink", "literal" },
{ "yellow", "literal" },
{ "console", "keyword" },
{ "cadetblue", "literal" },
{ "touchdraggable", "keyword" },
{ "gold", "literal" },
{ "darkkhaki", "literal" },
{ "viewpagervertical", "keyword" },
{ "mediumslateblue", "literal" },
{ "aqua", "literal" },
{ "brown", "literal" },
{ "cyan", "literal" },
{ "darkgoldenrod", "literal" },
{ "papayawhip", "literal" },
{ "hand", "literal" },
{ "purple", "literal" },
{ "tv", "keyword" },
{ "sizenesw", "literal" },
{ "darkslategrey", "literal" },
{ "button", "keyword" },
{ "nocursor", "literal" },
{ "orangered", "literal" },
{ "ibeam", "literal" },
{ "darkorange", "literal" },
{ "true", "literal" },
{ "sizens", "literal" },
{ "magenta", "literal" },
{ "textinputpassword", "keyword" },
{ "important", "literal" },
},
"",
{}
} );
}
}}}} // namespace EE::UI::Doc::Language

10
src/eepp/ui/doc/languages/css.hpp Normal file
View File

@@ -0,0 +1,10 @@
#ifndef EE_UI_DOC_Css
#define EE_UI_DOC_Css
namespace EE { namespace UI { namespace Doc { namespace Language {
extern void addCSS();
}}}}
#endif

148
src/eepp/ui/doc/languages/d.cpp Normal file
View File

@@ -0,0 +1,148 @@
#include <eepp/ui/doc/languages/d.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
namespace EE { namespace UI { namespace Doc { namespace Language {
void addD() {
SyntaxDefinitionManager::instance()->add(
{ "D",
{ "%.d$", "%.di$" },
{
{ { "//.-\n" }, "comment" },
{ { "/%*", "%*/" }, "comment" },
{ { "/%+", "%+/" }, "comment" },
{ { "`", "`", "\\" }, "string" },
{ { "\"", "\"", "\\" }, "string" },
{ { "'", "'", "\\" }, "string" },
{ { "-?0x%x+" }, "number" },
{ { "-?%d+[%d%.eE]*f?" }, "number" },
{ { "-?%.?%d+f?" }, "number" },
{ { "[%+%-=/%*%^%%<>!~|&%$]+" }, "operator" },
{ { "[%a_][%w_]*!" }, "function" },
{ { "[%a_][%w_]*" }, "symbol" },
{ { "@safe" }, "keyword" },
{ { "@trusted" }, "keyword" },
{ { "@nogc" }, "keyword" },
},
{
{ "new", "keyword" },
{ "invariant", "keyword" },
{ "static", "keyword" },
{ "module", "keyword" },
{ "mixin", "keyword" },
{ "interface", "keyword" },
{ "catch", "keyword" },
{ "macro", "keyword" },
{ "package", "keyword" },
{ "ireal", "keyword2" },
{ "foreach", "keyword" },
{ "int", "keyword2" },
{ "immutable", "keyword" },
{ "final", "keyword" },
{ "ifloat", "keyword2" },
{ "lazy", "keyword" },
{ "do", "keyword" },
{ "goto", "keyword" },
{ "__parameters", "keyword" },
{ "function", "keyword" },
{ "delegate", "keyword" },
{ "import", "keyword" },
{ "long", "keyword2" },
{ "continue", "keyword" },
{ "idouble", "keyword2" },
{ "ref", "keyword" },
{ "for", "keyword" },
{ "float", "keyword2" },
{ "version", "keyword" },
{ "finally", "keyword" },
{ "if", "keyword" },
{ "extern", "keyword" },
{ "in", "keyword" },
{ "break", "keyword" },
{ "else", "keyword" },
{ "__vector", "keyword" },
{ "false", "literal" },
{ "export", "keyword" },
{ "byte", "keyword2" },
{ "enum", "keyword" },
{ "cast", "keyword" },
{ "case", "keyword" },
{ "auto", "keyword" },
{ "null", "literal" },
{ "__MODULE__", "keyword" },
{ "asm", "keyword" },
{ "double", "keyword2" },
{ "default", "keyword" },
{ "inout", "keyword" },
{ "pragma", "keyword" },
{ "while", "keyword" },
{ "protected", "keyword" },
{ "pure", "keyword" },
{ "scope", "keyword" },
{ "override", "keyword" },
{ "shared", "keyword" },
{ "real", "keyword2" },
{ "short", "keyword2" },
{ "struct", "keyword" },
{ "uint", "keyword2" },
{ "return", "keyword" },
{ "super", "keyword" },
{ "throw", "keyword" },
{ "__traits", "keyword" },
{ "ubyte", "keyword2" },
{ "true", "literal" },
{ "__FUNCTION__", "keyword" },
{ "this", "keyword" },
{ "__FILE_FULL_PATH__", "keyword" },
{ "void", "keyword" },
{ "__FILE__", "keyword" },
{ "switch", "keyword" },
{ "ucent", "keyword2" },
{ "ushort", "keyword2" },
{ "with", "keyword" },
{ "typeof", "keyword" },
{ "typeid", "keyword" },
{ "ulong", "keyword2" },
{ "out", "keyword" },
{ "nothrow", "keyword" },
{ "char", "keyword2" },
{ "synchronized", "keyword" },
{ "debug", "keyword" },
{ "assert", "keyword" },
{ "foreach_reverse", "keyword" },
{ "unittest", "keyword" },
{ "dchar", "keyword2" },
{ "__PRETTY_FUNCTION__", "keyword" },
{ "class", "keyword" },
{ "cent", "keyword2" },
{ "align", "keyword" },
{ "__LINE__", "keyword" },
{ "cdouble", "keyword2" },
{ "abstract", "keyword" },
{ "__gshared", "keyword" },
{ "alias", "keyword" },
{ "deprecated", "keyword" },
{ "body", "keyword" },
{ "wchar", "keyword2" },
{ "template", "keyword" },
{ "is", "keyword" },
{ "private", "keyword" },
{ "creal", "keyword2" },
{ "cfloat", "keyword2" },
{ "try", "keyword" },
{ "bool", "keyword2" },
{ "public", "keyword" },
{ "union", "keyword" },
{ "const", "keyword" },
},
"//",
{}
} );
}
}}}} // namespace EE::UI::Doc::Language

10
src/eepp/ui/doc/languages/d.hpp Normal file
View File

@@ -0,0 +1,10 @@
#ifndef EE_UI_DOC_D
#define EE_UI_DOC_D
namespace EE { namespace UI { namespace Doc { namespace Language {
extern void addD();
}}}}
#endif

373
src/eepp/ui/doc/languages/glsl.cpp Normal file
View File

@@ -0,0 +1,373 @@
#include <eepp/ui/doc/languages/glsl.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
namespace EE { namespace UI { namespace Doc { namespace Language {
void addGLSL() {
SyntaxDefinitionManager::instance()->add(
{ "GLSL",
{ "%.glsl$", "%.frag$", "%.vert$", "%.fs$", "%.vs$" },
{
{ { "//.-\n" }, "comment" },
{ { "/%*", "%*/" }, "comment" },
{ { "#", "[^\\]\n" }, "comment" },
{ { "\"", "\"", "\\" }, "string" },
{ { "'", "'", "\\" }, "string" },
{ { "-?0x%x+" }, "number" },
{ { "-?%d+[%d%.eE]*f?" }, "number" },
{ { "-?%.?%d+f?" }, "number" },
{ { "[%+%-=/%*%^%%<>!~|&]" }, "operator" },
{ { "ivec[2-4]" }, "keyword2" },
{ { "bvec[2-4]" }, "keyword2" },
{ { "uvec[2-4]" }, "keyword2" },
{ { "vec[2-4]" }, "keyword2" },
{ { "dmat[2-4]x[2-4]" }, "keyword2" },
{ { "dmat[2-4]" }, "keyword2" },
{ { "mat[2-4]x[2-4]" }, "keyword2" },
{ { "mat[2-4]" }, "keyword2" },
{ { "[%a_][%w_]*%f[(]" }, "function" },
{ { "[%a_][%w_]*" }, "symbol" },
},
{
{ "atomicExchange", "keyword" },
{ "atomicXor", "keyword" },
{ "imageAtomicMax", "keyword" },
{ "atomicAnd", "keyword" },
{ "step", "keyword" },
{ "uimage2DArray", "keyword2" },
{ "atomicMax", "keyword" },
{ "atomicCounterCompSwap", "keyword" },
{ "atomicCounterExchange", "keyword" },
{ "atomicCounterXor", "keyword" },
{ "atomicMin", "keyword" },
{ "atomicCounterMax", "keyword" },
{ "utexture2DMSArray", "keyword" },
{ "atomicCounterMin", "keyword" },
{ "atomicCounterSubtract", "keyword" },
{ "textureProjGradOffset", "keyword" },
{ "textureGather", "keyword" },
{ "utextureBuffer", "keyword" },
{ "textureProjGrad", "keyword" },
{ "textureGrad", "keyword" },
{ "sampler2DMS", "keyword2" },
{ "textureProjLodOffset", "keyword" },
{ "textureProjLod", "keyword" },
{ "textureLodOffset", "keyword" },
{ "dFdy", "keyword" },
{ "textureOffset", "keyword" },
{ "textureProj", "keyword" },
{ "uaddCarry", "keyword" },
{ "patch", "keyword" },
{ "textureLod", "keyword" },
{ "imageSize", "keyword" },
{ "texture", "keyword" },
{ "sample", "keyword" },
{ "textureQueryLod", "keyword" },
{ "bitCount", "keyword" },
{ "bitfieldExtract", "keyword" },
{ "umulExtended", "keyword" },
{ "memoryBarrierImage", "keyword" },
{ "usubBorrow", "keyword" },
{ "atomicCounterAdd", "keyword" },
{ "interpolateAtOffset", "keyword" },
{ "not", "keyword" },
{ "bitfieldReverse", "keyword" },
{ "textureGatherOffset", "keyword" },
{ "equal", "keyword" },
{ "greaterThanEqual", "keyword" },
{ "greaterThan", "keyword" },
{ "lessThanEqual", "keyword" },
{ "isampler1D", "keyword2" },
{ "atomicCompSwap", "keyword" },
{ "lessThan", "keyword" },
{ "determinant", "keyword" },
{ "imageAtomicAdd", "keyword" },
{ "isampler1DArray", "keyword2" },
{ "matrixCompMult", "keyword" },
{ "floatBitsToInt", "keyword" },
{ "refract", "keyword" },
{ "imageAtomicMin", "keyword" },
{ "faceforward", "keyword" },
{ "ftransform", "keyword" },
{ "sqrt", "keyword" },
{ "cross", "keyword" },
{ "abs", "keyword" },
{ "packDouble2x32", "keyword" },
{ "unpackSnorm4x8", "keyword" },
{ "utexture1DArray", "keyword" },
{ "unpackUnorm4x8", "keyword" },
{ "texture1DArray", "keyword" },
{ "packUnorm2x16", "keyword" },
{ "frexp", "keyword" },
{ "fma", "keyword" },
{ "isnan", "keyword" },
{ "mix", "keyword" },
{ "exp2", "keyword" },
{ "isampler3D", "keyword2" },
{ "false", "literal" },
{ "sampler2DMSArray", "keyword2" },
{ "packHalf2x16", "keyword" },
{ "sampler2DArrayShadow", "keyword2" },
{ "lowp", "keyword" },
{ "length", "keyword" },
{ "imageLoad", "keyword" },
{ "imulExtended", "keyword" },
{ "smooth", "keyword" },
{ "sampler1DShadow", "keyword2" },
{ "utexture2DArray", "keyword" },
{ "isampler2D", "keyword2" },
{ "iimage1D", "keyword2" },
{ "uimageCubeArray", "keyword2" },
{ "memoryBarrierAtomicCounter", "keyword" },
{ "utexture2DMS", "keyword" },
{ "tanh", "keyword" },
{ "atomicCounterAnd", "keyword" },
{ "invariant", "keyword" },
{ "layout", "keyword" },
{ "imageStore", "keyword" },
{ "sampler2DRectShadow", "keyword2" },
{ "fwidth", "keyword" },
{ "volatile", "keyword" },
{ "imageBuffer", "keyword2" },
{ "usampler1DArray", "keyword2" },
{ "usampler2DArray", "keyword2" },
{ "utextureCubeArray", "keyword" },
{ "findLSB", "keyword" },
{ "texelFetch", "keyword" },
{ "dot", "keyword" },
{ "atomicOr", "keyword" },
{ "isinf", "keyword" },
{ "imageCube", "keyword2" },
{ "true", "literal" },
{ "texture1D", "keyword" },
{ "inverse", "keyword" },
{ "dFdyFine", "keyword" },
{ "memoryBarrierShared", "keyword" },
{ "atomicCounterOr", "keyword" },
{ "usampler1D", "keyword2" },
{ "uniform", "keyword" },
{ "image1DArray", "keyword2" },
{ "writeonly", "keyword" },
{ "itexture2DRect", "keyword" },
{ "precision", "keyword" },
{ "imageSamples", "keyword" },
{ "isampler2DMSArray", "keyword2" },
{ "dFdx", "keyword" },
{ "image1D", "keyword2" },
{ "atomicCounterIncrement", "keyword" },
{ "image2D", "keyword2" },
{ "image2DArray", "keyword2" },
{ "any", "keyword" },
{ "uimageCube", "keyword2" },
{ "iimage2DArray", "keyword2" },
{ "memoryBarrierBuffer", "keyword" },
{ "allInvocationsEqual", "keyword" },
{ "sampler3D", "keyword2" },
{ "subpassLoad", "keyword" },
{ "itexture2D", "keyword" },
{ "image2DMS", "keyword2" },
{ "itexture1DArray", "keyword" },
{ "centroid", "keyword" },
{ "dFdyCoarse", "keyword" },
{ "texture2DArray", "keyword" },
{ "iimage2DRect", "keyword2" },
{ "utexture2D", "keyword" },
{ "texture3D", "keyword" },
{ "itextureCube", "keyword" },
{ "degrees", "keyword" },
{ "texture2DMS", "keyword" },
{ "itexture2DMS", "keyword" },
{ "iimage2DMS", "keyword2" },
{ "isubpassInput", "keyword2" },
{ "imageAtomicXor", "keyword" },
{ "samplerShadow", "keyword2" },
{ "iimage2D", "keyword2" },
{ "usampler3D", "keyword2" },
{ "itexture2DMSArray", "keyword" },
{ "sin", "keyword" },
{ "utexture2DRect", "keyword" },
{ "do", "keyword" },
{ "groupMemoryBarrier", "keyword" },
{ "image3D", "keyword2" },
{ "usubpassInput", "keyword2" },
{ "isampler2DMS", "keyword2" },
{ "samplerBuffer", "keyword2" },
{ "texture2DRect", "keyword" },
{ "while", "keyword" },
{ "memoryBarrier", "keyword" },
{ "samplerCubeArrayShadow", "keyword2" },
{ "outerProduct", "keyword" },
{ "interpolateAtCentroid", "keyword" },
{ "subpassInput", "keyword2" },
{ "noperspective", "keyword" },
{ "textureBuffer", "keyword" },
{ "EmitVertex", "keyword" },
{ "usubpassInputMS", "keyword2" },
{ "iimageCubeArray", "keyword2" },
{ "interpolateAtSample", "keyword" },
{ "const", "keyword" },
{ "uimage2DMSArray", "keyword2" },
{ "uimage1D", "keyword2" },
{ "texture2D", "keyword" },
{ "subpassInputMS", "keyword2" },
{ "textureGatherOffsets", "keyword" },
{ "EmitStreamVertex", "keyword" },
{ "precise", "keyword" },
{ "uimage2DRect", "keyword2" },
{ "textureCube", "keyword" },
{ "uimage2DMS", "keyword2" },
{ "EndPrimitive", "keyword" },
{ "utexture3D", "keyword" },
{ "utextureCube", "keyword" },
{ "fwidthCoarse", "keyword" },
{ "varying", "keyword" },
{ "itexture1D", "keyword" },
{ "dFdxCoarse", "keyword" },
{ "imageCubeArray", "keyword2" },
{ "image2DMSArray", "keyword2" },
{ "dFdxFine", "keyword" },
{ "EndStreamPrimitive", "keyword" },
{ "imageAtomicExchange", "keyword" },
{ "imageAtomicAnd", "keyword" },
{ "imageAtomicOr", "keyword" },
{ "allInvocations", "keyword" },
{ "imageAtomicCompSwap", "keyword" },
{ "highp", "keyword" },
{ "fwidthFine", "keyword" },
{ "cos", "keyword" },
{ "texture2DMSArray", "keyword" },
{ "radians", "keyword" },
{ "itexture3D", "keyword" },
{ "modf", "keyword" },
{ "unpackDouble2x32", "keyword" },
{ "usampler2DMSArray", "keyword2" },
{ "acos", "keyword" },
{ "smoothstep", "keyword" },
{ "atomicCounterDecrement", "keyword" },
{ "iimageCube", "keyword2" },
{ "uimage3D", "keyword2" },
{ "samplerCube", "keyword2" },
{ "mod", "keyword" },
{ "clamp", "keyword" },
{ "isubpassInputMS", "keyword2" },
{ "textureGradOffset", "keyword" },
{ "asin", "keyword" },
{ "attribute", "keyword" },
{ "sampler2DArray", "keyword2" },
{ "image2DRect", "keyword2" },
{ "notEqual", "keyword" },
{ "log2", "keyword" },
{ "readonly", "keyword" },
{ "uimageBuffer", "keyword2" },
{ "floatBitsToUint", "keyword" },
{ "itextureBuffer", "keyword" },
{ "iimage3D", "keyword2" },
{ "packUnorm4x8", "keyword" },
{ "inout", "keyword" },
{ "return", "keyword" },
{ "uimage1DArray", "keyword2" },
{ "min", "keyword" },
{ "samplerCubeArray", "keyword2" },
{ "texelFetchOffset", "keyword" },
{ "sampler", "keyword2" },
{ "float", "keyword2" },
{ "uintBitsToFloat", "keyword" },
{ "int", "keyword2" },
{ "mediump", "keyword" },
{ "subroutine", "keyword" },
{ "distance", "keyword" },
{ "reflect", "keyword" },
{ "usampler2D", "keyword2" },
{ "all", "keyword" },
{ "intBitsToFloat", "keyword" },
{ "out", "keyword" },
{ "double", "keyword2" },
{ "usamplerBuffer", "keyword2" },
{ "atomicCounter", "keyword" },
{ "if", "keyword" },
{ "tan", "keyword" },
{ "continue", "keyword" },
{ "in", "keyword" },
{ "atan", "keyword" },
{ "else", "keyword" },
{ "switch", "keyword" },
{ "bool", "keyword2" },
{ "anyInvocation", "keyword" },
{ "usampler2DRect", "keyword2" },
{ "packSnorm2x16", "keyword" },
{ "textureProjOffset", "keyword" },
{ "usamplerCube", "keyword2" },
{ "atomicAdd", "keyword" },
{ "shared", "keyword" },
{ "textureSamples", "keyword" },
{ "iimageBuffer", "keyword2" },
{ "iimage1DArray", "keyword2" },
{ "inversesqrt", "keyword" },
{ "itexture2DArray", "keyword" },
{ "barrier", "keyword" },
{ "textureCubeArray", "keyword" },
{ "usampler2DMS", "keyword2" },
{ "atomic_uint", "keyword2" },
{ "itextureCubeArray", "keyword" },
{ "fract", "keyword" },
{ "flat", "keyword" },
{ "samplerCubeShadow", "keyword2" },
{ "sampler1DArrayShadow", "keyword2" },
{ "isampler2DRect", "keyword2" },
{ "ldexp", "keyword" },
{ "for", "keyword" },
{ "normalize", "keyword" },
{ "buffer", "keyword" },
{ "sampler1DArray", "keyword2" },
{ "sampler2DRect", "keyword2" },
{ "void", "keyword" },
{ "acosh", "keyword" },
{ "sign", "keyword" },
{ "packSnorm4x8", "keyword" },
{ "case", "keyword" },
{ "bitfieldInsert", "keyword" },
{ "isamplerCube", "keyword2" },
{ "unpackHalf2x16", "keyword" },
{ "isampler2DArray", "keyword2" },
{ "uimage2D", "keyword2" },
{ "unpackSnorm2x16", "keyword" },
{ "default", "keyword" },
{ "transpose", "keyword" },
{ "findMSB", "keyword" },
{ "coherent", "keyword" },
{ "exp", "keyword" },
{ "utexture1D", "keyword" },
{ "sampler1D", "keyword2" },
{ "struct", "keyword" },
{ "uint", "keyword2" },
{ "NULL", "literal" },
{ "unpackUnorm2x16", "keyword" },
{ "break", "keyword" },
{ "textureQueryLevels", "keyword" },
{ "sampler2DShadow", "keyword2" },
{ "sinh", "keyword" },
{ "isamplerBuffer", "keyword2" },
{ "sampler2D", "keyword2" },
{ "iimage2DMSArray", "keyword2" },
{ "cosh", "keyword" },
{ "asinh", "keyword" },
{ "pow", "keyword" },
{ "floor", "keyword" },
{ "trunc", "keyword" },
{ "textureSize", "keyword" },
{ "round", "keyword" },
{ "roundEven", "keyword" },
{ "max", "keyword" },
{ "ceil", "keyword" },
},
"//",
{}
} );
}
}}}} // namespace EE::UI::Doc::Language

10
src/eepp/ui/doc/languages/glsl.hpp Normal file
View File

@@ -0,0 +1,10 @@
#ifndef EE_UI_DOC_Glsl
#define EE_UI_DOC_Glsl
namespace EE { namespace UI { namespace Doc { namespace Language {
extern void addGLSL();
}}}}
#endif

147
src/eepp/ui/doc/languages/odin.cpp Normal file
View File

@@ -0,0 +1,147 @@
#include <eepp/ui/doc/languages/odin.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
namespace EE { namespace UI { namespace Doc { namespace Language {
void addOdin() {
SyntaxDefinitionManager::instance()->add(
{ "Odin",
{ "%.odin$" },
{
{ { "//.-\n" }, "comment" },
{ { "/%*", "%*/" }, "comment" },
{ { "\"", "\"", "\\" }, "string" },
{ { "'", "'", "\\" }, "string" },
{ { "`", "`" }, "string" },
{ { "0b[01_]+" }, "number" },
{ { "0o[0-7_]+" }, "number" },
{ { "0[dz][%d_]+" }, "number" },
{ { "0x[%da-fA-F_]+" }, "number" },
{ { "-?%d+[%d%._e]*i?" }, "number" },
{ { "[<>~=+-*/]=" }, "operator" },
{ { "[%+%-=/%*%^%%<>!~|&:]" }, "operator" },
{ { "%$[%a_][%w_]*" }, "operator" },
{ { "[%a_][%w_]*%f[(]" }, "function" },
{ { "[#@][%a_][%w_]*" }, "keyword2" },
{ { "[#@]%b()" }, "keyword2" },
{ { "[%a_][%w_]*" }, "symbol" },
},
{
{ "typeid", "keyword2" },
{ "i64be", "keyword2" },
{ "conj", "keyword2" },
{ "i32le", "keyword2" },
{ "rawptr", "keyword2" },
{ "real", "keyword2" },
{ "typeid_of", "keyword2" },
{ "type_info_of", "keyword2" },
{ "offset_of", "keyword2" },
{ "i64le", "keyword2" },
{ "align_of", "keyword2" },
{ "f32", "keyword2" },
{ "min", "keyword2" },
{ "u64", "keyword2" },
{ "cap", "keyword2" },
{ "cstring", "keyword2" },
{ "len", "keyword2" },
{ "byte", "keyword2" },
{ "transmute", "keyword2" },
{ "proc", "keyword" },
{ "any", "keyword2" },
{ "clamp", "keyword2" },
{ "auto_cast", "keyword2" },
{ "uintptr", "keyword2" },
{ "u16le", "keyword2" },
{ "complex", "keyword2" },
{ "const", "keyword" },
{ "union", "keyword" },
{ "u32", "keyword2" },
{ "opaque", "keyword" },
{ "type_info_base", "keyword2" },
{ "defer", "keyword" },
{ "max", "keyword2" },
{ "do", "keyword" },
{ "for", "keyword" },
{ "macro", "keyword" },
{ "package", "keyword" },
{ "bit_set", "keyword" },
{ "switch", "keyword" },
{ "no_inline", "keyword" },
{ "quaternion256", "keyword2" },
{ "if", "keyword" },
{ "case", "keyword" },
{ "foreign", "keyword" },
{ "not_in", "keyword" },
{ "inline", "keyword" },
{ "import", "keyword" },
{ "u8", "keyword2" },
{ "nil", "literal" },
{ "i16", "keyword2" },
{ "swizzle", "keyword2" },
{ "u16", "keyword2" },
{ "false", "literal" },
{ "f16", "keyword2" },
{ "distinct", "keyword" },
{ "rune", "keyword2" },
{ "i16le", "keyword2" },
{ "b64", "keyword2" },
{ "i128le", "keyword2" },
{ "quaternion128", "keyword2" },
{ "u16be", "keyword2" },
{ "i32be", "keyword2" },
{ "u128be", "keyword2" },
{ "i16be", "keyword2" },
{ "u32be", "keyword2" },
{ "complex64", "keyword2" },
{ "b8", "keyword2" },
{ "b32", "keyword2" },
{ "i32", "keyword2" },
{ "assert", "keyword2" },
{ "complex128", "keyword2" },
{ "complex32", "keyword2" },
{ "return", "keyword" },
{ "u128", "keyword2" },
{ "b128", "keyword2" },
{ "i128be", "keyword2" },
{ "i8", "keyword2" },
{ "int", "keyword2" },
{ "i64", "keyword2" },
{ "bool", "keyword2" },
{ "imag", "keyword2" },
{ "u64be", "keyword2" },
{ "true", "literal" },
{ "context", "keyword" },
{ "dynamic", "keyword" },
{ "string", "keyword2" },
{ "i128", "keyword2" },
{ "when", "keyword" },
{ "u32le", "keyword2" },
{ "size_of", "keyword2" },
{ "u64le", "keyword2" },
{ "type_of", "keyword2" },
{ "using", "keyword" },
{ "map", "keyword" },
{ "uint", "keyword2" },
{ "struct", "keyword" },
{ "cast", "keyword2" },
{ "enum", "keyword" },
{ "abs", "keyword2" },
{ "f64", "keyword2" },
{ "u128le", "keyword2" },
{ "continue", "keyword" },
{ "fallthrough", "keyword" },
{ "in", "keyword" },
{ "break", "keyword" },
{ "else", "keyword" },
},
"//",
{}
} );
}
}}}} // namespace EE::UI::Doc::Language

10
src/eepp/ui/doc/languages/odin.hpp Normal file
View File

@@ -0,0 +1,10 @@
#ifndef EE_UI_DOC_Odin
#define EE_UI_DOC_Odin
namespace EE { namespace UI { namespace Doc { namespace Language {
extern void addOdin();
}}}}
#endif

269
src/eepp/ui/doc/languages/perl.cpp Normal file
View File

@@ -0,0 +1,269 @@
#include <eepp/ui/doc/languages/perl.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
namespace EE { namespace UI { namespace Doc { namespace Language {
void addPerl() {
SyntaxDefinitionManager::instance()->add(
{ "Perl",
{ "%.pm$", "%.pl$" },
{
{ { "%#.-\n" }, "comment" },
{ { "\"", "\"", "\\" }, "string" },
{ { "'", "'", "\\" }, "string" },
{ { "-?%d+[%d%.eE]*" }, "number" },
{ { "-?%.?%d+" }, "number" },
{ { "[%a_][%w_]*%f[(]" }, "function" },
{ { "[%@%$%*]+[%a_][%w_]*" }, "keyword2" },
{ { "%--[%a_][%w_]*" }, "symbol" },
},
{
{ "atan2", "keyword" },
{ "endhostent", "keyword" },
{ "sysread", "keyword" },
{ "last", "keyword" },
{ "alarm", "keyword" },
{ "getpwnam", "keyword" },
{ "syscall", "keyword" },
{ "prototype", "keyword" },
{ "abs", "keyword" },
{ "umask", "keyword" },
{ "symlink", "keyword" },
{ "dbmclose", "keyword" },
{ "printf", "keyword" },
{ "endpwent", "keyword" },
{ "substr", "keyword" },
{ "print", "keyword" },
{ "sysseek", "keyword" },
{ "caller", "keyword" },
{ "sysopen", "keyword" },
{ "getlogin", "keyword" },
{ "-d", "keyword" },
{ "-x", "keyword" },
{ "chmod", "keyword" },
{ "getpgrp", "keyword" },
{ "study", "keyword" },
{ "pos", "keyword" },
{ "gethostent", "keyword" },
{ "sort", "keyword" },
{ "state", "keyword" },
{ "pop", "keyword" },
{ "seekdir", "keyword" },
{ "gethostbyname", "keyword" },
{ "getc", "keyword" },
{ "-W", "keyword" },
{ "-w", "keyword" },
{ "eof$", "keyword" },
{ "pack", "keyword" },
{ "-u", "keyword" },
{ "sprintf", "keyword" },
{ "AUTOLOAD", "keyword" },
{ "die", "keyword" },
{ "-t", "keyword" },
{ "ord", "keyword" },
{ "-T", "keyword" },
{ "-M", "keyword" },
{ "split", "keyword" },
{ "-s", "keyword" },
{ "lcfirst", "keyword" },
{ "open", "keyword" },
{ "getpeername", "keyword" },
{ "quotemeta", "keyword" },
{ "srand", "keyword" },
{ "-S", "keyword" },
{ "oct", "keyword" },
{ "format", "keyword" },
{ "-b", "keyword" },
{ "socketpair", "keyword" },
{ "getgrent", "keyword" },
{ "-R", "keyword" },
{ "not", "keyword" },
{ "-e", "keyword" },
{ "-r", "keyword" },
{ "lstat", "keyword" },
{ "pipe", "keyword" },
{ "flock", "keyword" },
{ "endprotoent", "keyword" },
{ "-X", "keyword" },
{ "system", "keyword" },
{ "select", "keyword" },
{ "localtime", "keyword" },
{ "index", "keyword" },
{ "getnetbyaddr", "keyword" },
{ "next", "keyword" },
{ "local", "keyword" },
{ "fork", "keyword" },
{ "length", "keyword" },
{ "getnetbyname", "keyword" },
{ "setpwent", "keyword" },
{ "shift", "keyword" },
{ "map", "keyword" },
{ "readline", "keyword" },
{ "-k", "keyword" },
{ "splice", "keyword" },
{ "setpgrp", "keyword" },
{ "setprotoent", "keyword" },
{ "endservent", "keyword" },
{ "UNITCHECK", "keyword" },
{ "-c", "keyword" },
{ "-f", "keyword" },
{ "keys", "keyword" },
{ "kill", "keyword" },
{ "lc", "keyword" },
{ "msgsnd", "keyword" },
{ "dump", "keyword" },
{ "-l", "keyword" },
{ "-z", "keyword" },
{ "syswrite", "keyword" },
{ "shutdown", "keyword" },
{ "bind", "keyword" },
{ "CHECK", "keyword" },
{ "setnetent", "keyword" },
{ "sqrt", "keyword" },
{ "setsockopt", "keyword" },
{ "getnetent", "keyword" },
{ "-p", "keyword" },
{ "BEGIN", "keyword" },
{ "waitpid", "keyword" },
{ "-B", "keyword" },
{ "scalar", "keyword" },
{ "gethostbyaddr", "keyword" },
{ "bless", "keyword" },
{ "getprotobyname", "keyword" },
{ "tie", "keyword" },
{ "say", "keyword" },
{ "each", "keyword" },
{ "telldir", "keyword" },
{ "recv", "keyword" },
{ "chr", "keyword" },
{ "getpwuid", "keyword" },
{ "getservbyname", "keyword" },
{ "return", "keyword" },
{ "rename", "keyword" },
{ "getservbyport", "keyword" },
{ "unshift", "keyword" },
{ "truncate", "keyword" },
{ "getservent", "keyword" },
{ "ucfirst", "keyword" },
{ "rindex", "keyword" },
{ "time", "keyword" },
{ "chdir", "keyword" },
{ "chown", "keyword" },
{ "unlink", "keyword" },
{ "getpwent", "keyword" },
{ "undef", "keyword" },
{ "cos", "keyword" },
{ "utime", "keyword" },
{ "END", "keyword" },
{ "unpack", "keyword" },
{ "untie", "keyword" },
{ "semop", "keyword" },
{ "setgrent", "keyword" },
{ "getsockname", "keyword" },
{ "ioctl", "keyword" },
{ "getprotoent", "keyword" },
{ "times", "keyword" },
{ "defined", "keyword" },
{ "opendir", "keyword" },
{ "use", "keyword" },
{ "readpipe", "keyword" },
{ "chomp", "keyword" },
{ "sub", "keyword" },
{ "rmdir", "keyword" },
{ "delete", "keyword" },
{ "gmtime", "keyword" },
{ "connect", "keyword" },
{ "join", "keyword" },
{ "grep", "keyword" },
{ "DESTROY", "keyword" },
{ "read", "keyword" },
{ "sethostent", "keyword" },
{ "fileno", "keyword" },
{ "redo", "keyword" },
{ "hex", "keyword" },
{ "int", "keyword" },
{ "ref", "keyword" },
{ "INIT", "keyword" },
{ "semget", "keyword" },
{ "close", "keyword" },
{ "SUPER", "keyword" },
{ "reset", "keyword" },
{ "warn", "keyword" },
{ "glob", "keyword" },
{ "closedir", "keyword" },
{ "goto", "keyword" },
{ "rewinddir", "keyword" },
{ "tied", "keyword" },
{ "push", "keyword" },
{ "getsockopt", "keyword" },
{ "readlink", "keyword" },
{ "require", "keyword" },
{ "getprotobynumber", "keyword" },
{ "crypt", "keyword" },
{ "tell", "keyword" },
{ "exists", "keyword" },
{ "getgrgid", "keyword" },
{ "getpriority", "keyword" },
{ "send", "keyword" },
{ "rand", "keyword" },
{ "chroot", "keyword" },
{ "seek", "keyword" },
{ "sleep", "keyword" },
{ "shmctl", "keyword" },
{ "sin", "keyword" },
{ "semctl", "keyword" },
{ "exit", "keyword" },
{ "getppid", "keyword" },
{ "-O", "keyword" },
{ "shmget", "keyword" },
{ "accept", "keyword" },
{ "my", "keyword" },
{ "shmwrite", "keyword" },
{ "uc", "keyword" },
{ "setpriority", "keyword" },
{ "write", "keyword" },
{ "vec", "keyword" },
{ "-A", "keyword" },
{ "getgrnam", "keyword" },
{ "exec", "keyword" },
{ "-o", "keyword" },
{ "msgctl", "keyword" },
{ "msgget", "keyword" },
{ "mkdir", "keyword" },
{ "eval", "keyword" },
{ "wait", "keyword" },
{ "fcntl", "keyword" },
{ "-g", "keyword" },
{ "values", "keyword" },
{ "binmode", "keyword" },
{ "reverse", "keyword" },
{ "msgrcv", "keyword" },
{ "socket", "keyword" },
{ "link", "keyword" },
{ "setservent", "keyword" },
{ "wantarray", "keyword" },
{ "dbmopen", "keyword" },
{ "shmread", "keyword" },
{ "endnetent", "keyword" },
{ "readdir", "keyword" },
{ "-C", "keyword" },
{ "package", "keyword" },
{ "endgrent", "keyword" },
{ "our", "keyword" },
{ "stat", "keyword" },
{ "chop", "keyword" },
{ "listen", "keyword" },
{ "log", "keyword" },
{ "formline", "keyword" },
},
"#",
{ "^#!.*[ /]perl" }
} );
}
}}}} // namespace EE::UI::Doc::Language

10
src/eepp/ui/doc/languages/perl.hpp Normal file
View File

@@ -0,0 +1,10 @@
#ifndef EE_UI_DOC_Perl
#define EE_UI_DOC_Perl
namespace EE { namespace UI { namespace Doc { namespace Language {
extern void addPerl();
}}}}
#endif

224
src/eepp/ui/doc/languages/sass.cpp Normal file
View File

@@ -0,0 +1,224 @@
#include <eepp/ui/doc/languages/sass.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
namespace EE { namespace UI { namespace Doc { namespace Language {
void addSass() {
SyntaxDefinitionManager::instance()->add(
{ "Sass",
{ "%.sass$", "%.scss$" },
{
{ { "/[/%*].-\n" }, "comment" },
{ { "\"", "\"", "\\" }, "string" },
{ { "'", "'", "\\" }, "string" },
{ { "$%w+" }, "keyword" },
{ { "@%w+" }, "literal" },
{ { "&" }, "keyword2" },
{ { "[:%/%*%-]" }, "operator" },
{ { "[%a][%w-]*%s*%f[:]" }, "keyword2" },
{ { "-?%d+[%d%.]*p[xt]" }, "number" },
{ { "-?%d+[%d%.]*deg" }, "number" },
{ { "-?%d+[%d%.]*[s%%]" }, "number" },
{ { "-?%d+[%d%.]*" }, "number" },
{ { "^%s*#[%a%_%-][%w%_%-]*" }, "keyword2" },
{ { ",%s*#[%a%_%-][%w%_%-]*" }, "keyword2" },
{ { "#%x%x?%x?%x?%x?%x?%x?%x?" }, "string" },
{ { "#[%a%_%-][%w%_%-]*" }, "keyword2" },
{ { "%-%-%a[%w%-%_]*" }, "keyword2" },
{ { "-?%d+[%d%.]*p[xt]" }, "number" },
{ { "-?%d+[%d%.]*deg" }, "number" },
{ { "-?%d+[%d%.]*" }, "number" },
{ { "@[%a][%w%_%-]*" }, "keyword2" },
{ { "%.[%a%_%-][%w%_%-]*" }, "keyword2" },
{ { "(:)(hover)" }, { "normal", "operator", "literal" } },
{ { "(:)(focus%-within)" }, { "normal", "operator", "literal" } },
{ { "(:)(focus)" }, { "normal", "operator", "literal" } },
{ { "(:)(selected)" }, { "normal", "operator", "literal" } },
{ { "(:)(pressed)" }, { "normal", "operator", "literal" } },
{ { "(:)(disabled)" }, { "normal", "operator", "literal" } },
{ { "(:)(checked)" }, { "normal", "operator", "literal" } },
{ { "(:)(root)" }, { "normal", "operator", "link" } },
{ { "(%a+)(%()" }, { "normal", "function", "normal" } },
{ { "[%a][%w-]*%s*%f[:]" }, "keyword" },
{ { "[{}:>~!]" }, "operator" },
{ { "[#,]%w+" }, "function" },
{ { "[%a_][%w_]*" }, "symbol" },
},
{
{ "orange", "literal" },
{ "olivedrab", "literal" },
{ "olive", "literal" },
{ "navajowhite", "literal" },
{ "mistyrose", "literal" },
{ "midnightblue", "literal" },
{ "darkseagreen", "literal" },
{ "mediumseagreen", "literal" },
{ "lavenderblush", "literal" },
{ "mediumaquamarine", "literal" },
{ "limegreen", "literal" },
{ "mediumspringgreen", "literal" },
{ "lightgreen", "literal" },
{ "lime", "literal" },
{ "mediumorchid", "literal" },
{ "gray", "literal" },
{ "black", "literal" },
{ "lightyellow", "literal" },
{ "mediumblue", "literal" },
{ "lightslategray", "literal" },
{ "lightseagreen", "literal" },
{ "lightpink", "literal" },
{ "lightslategrey", "literal" },
{ "lightgrey", "literal" },
{ "lightgoldenrodyellow", "literal" },
{ "lightblue", "literal" },
{ "lemonchiffon", "literal" },
{ "lawngreen", "literal" },
{ "mintcream", "literal" },
{ "khaki", "literal" },
{ "ivory", "literal" },
{ "moccasin", "literal" },
{ "indigo", "literal" },
{ "transparent", "literal" },
{ "oldlace", "literal" },
{ "indianred", "literal" },
{ "hotpink", "literal" },
{ "sizenwse", "literal" },
{ "wait", "literal" },
{ "deeppink", "literal" },
{ "antiquewhite", "literal" },
{ "crosshair", "literal" },
{ "arrow", "literal" },
{ "coral", "literal" },
{ "peachpuff", "literal" },
{ "darkgreen", "literal" },
{ "firebrick", "literal" },
{ "burlywood", "literal" },
{ "darkblue", "literal" },
{ "darkcyan", "literal" },
{ "darkturquoise", "literal" },
{ "paleturquoise", "literal" },
{ "whitesmoke", "literal" },
{ "sienna", "literal" },
{ "tan", "literal" },
{ "grey", "literal" },
{ "darkolivegreen", "literal" },
{ "slategrey", "literal" },
{ "springgreen", "literal" },
{ "gold", "literal" },
{ "darkgrey", "literal" },
{ "darkviolet", "literal" },
{ "yellowgreen", "literal" },
{ "linen", "literal" },
{ "white", "literal" },
{ "dodgerblue", "literal" },
{ "thistle", "literal" },
{ "sandybrown", "literal" },
{ "tomato", "literal" },
{ "violet", "literal" },
{ "palevioletred", "literal" },
{ "chartreuse", "literal" },
{ "turquoise", "literal" },
{ "azure", "literal" },
{ "lightsteelblue", "literal" },
{ "seashell", "literal" },
{ "navy", "literal" },
{ "darkmagenta", "literal" },
{ "silver", "literal" },
{ "teal", "literal" },
{ "darkorchid", "literal" },
{ "seagreen", "literal" },
{ "wheat", "literal" },
{ "darkred", "literal" },
{ "slateblue", "literal" },
{ "red", "literal" },
{ "orchid", "literal" },
{ "salmon", "literal" },
{ "lightcoral", "literal" },
{ "center", "literal" },
{ "royalblue", "literal" },
{ "snow", "literal" },
{ "palegreen", "literal" },
{ "greenyellow", "literal" },
{ "saddlebrown", "literal" },
{ "goldenrod", "literal" },
{ "plum", "literal" },
{ "cornsilk", "literal" },
{ "lavender", "literal" },
{ "rosybrown", "literal" },
{ "waitarrow", "literal" },
{ "powderblue", "literal" },
{ "darkslateblue", "literal" },
{ "chocolate", "literal" },
{ "cadetblue", "literal" },
{ "yellow", "literal" },
{ "ghostwhite", "literal" },
{ "aquamarine", "literal" },
{ "darkslategray", "literal" },
{ "mediumpurple", "literal" },
{ "darksalmon", "literal" },
{ "pink", "literal" },
{ "darkkhaki", "literal" },
{ "mediumslateblue", "literal" },
{ "cyan", "literal" },
{ "hand", "literal" },
{ "purple", "literal" },
{ "brown", "literal" },
{ "aqua", "literal" },
{ "sizenesw", "literal" },
{ "papayawhip", "literal" },
{ "darkgoldenrod", "literal" },
{ "darkslategrey", "literal" },
{ "nocursor", "literal" },
{ "blue", "literal" },
{ "slategray", "literal" },
{ "bisque", "literal" },
{ "orangered", "literal" },
{ "ibeam", "literal" },
{ "darkorange", "literal" },
{ "true", "literal" },
{ "sizens", "literal" },
{ "magenta", "literal" },
{ "important", "literal" },
{ "blanchedalmond", "literal" },
{ "lightskyblue", "literal" },
{ "aliceblue", "literal" },
{ "sizeall", "literal" },
{ "dimgrey", "literal" },
{ "crimson", "literal" },
{ "darkgray", "literal" },
{ "beige", "literal" },
{ "lightsalmon", "literal" },
{ "skyblue", "literal" },
{ "blueviolet", "literal" },
{ "none", "literal" },
{ "sizewe", "literal" },
{ "deepskyblue", "literal" },
{ "peru", "literal" },
{ "dimgray", "literal" },
{ "mediumvioletred", "literal" },
{ "floralwhite", "literal" },
{ "maroon", "literal" },
{ "palegoldenrod", "literal" },
{ "forestgreen", "literal" },
{ "fuchsia", "literal" },
{ "gainsboro", "literal" },
{ "lightcyan", "literal" },
{ "lightgray", "literal" },
{ "mediumturquoise", "literal" },
{ "cornflowerblue", "literal" },
{ "steelblue", "literal" },
{ "green", "literal" },
{ "false", "literal" },
{ "honeydew", "literal" },
},
"//",
{}
} );
}
}}}} // namespace EE::UI::Doc::Language

10
src/eepp/ui/doc/languages/sass.hpp Normal file
View File

@@ -0,0 +1,10 @@
#ifndef EE_UI_DOC_Sass
#define EE_UI_DOC_Sass
namespace EE { namespace UI { namespace Doc { namespace Language {
extern void addSass();
}}}}
#endif

153
src/eepp/ui/doc/languages/solidity.cpp Normal file
View File

@@ -0,0 +1,153 @@
#include <eepp/ui/doc/languages/solidity.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
namespace EE { namespace UI { namespace Doc { namespace Language {
void addSolidity() {
SyntaxDefinitionManager::instance()->add(
{ "Solidity",
{ "%.sol$" },
{
{ { "//.-\n" }, "comment" },
{ { "/%*", "%*/" }, "comment" },
{ { "\"\"\"", "\"\"\"" }, "string" },
{ { "\"", "\"", "\\" }, "string" },
{ { "-?0x%x+" }, "number" },
{ { "-?%d+[%d%.eE]*f?" }, "number" },
{ { "-?%.?%d+f?" }, "number" },
{ { "[%+%-=/%*%^%%<>!~|&]" }, "operator" },
{ { "[%a_][%w_]*%f[(]" }, "function" },
{ { "[%a_][%w_]*" }, "symbol" },
},
{
{ "interface", "keyword" },
{ "bytes3", "keyword2" },
{ "blockhash", "keyword2" },
{ "uint64", "keyword2" },
{ "ecrecover", "keyword2" },
{ "new", "keyword" },
{ "ripemd160", "keyword2" },
{ "sha3", "keyword2" },
{ "byte", "keyword2" },
{ "bytes32", "keyword2" },
{ "suicide", "keyword2" },
{ "virtual", "keyword2" },
{ "revert", "keyword2" },
{ "bytes30", "keyword2" },
{ "msg", "keyword2" },
{ "bytes15", "keyword2" },
{ "enum", "keyword" },
{ "payable", "keyword2" },
{ "assembly", "keyword" },
{ "super", "keyword2" },
{ "library", "keyword" },
{ "private", "keyword2" },
{ "is", "keyword" },
{ "now", "keyword2" },
{ "throw", "keyword" },
{ "bytes18", "keyword2" },
{ "contract", "keyword" },
{ "view", "keyword2" },
{ "bytes14", "keyword2" },
{ "let", "keyword" },
{ "external", "keyword2" },
{ "return", "keyword" },
{ "mulmod", "keyword2" },
{ "modifier", "keyword" },
{ "bytes12", "keyword2" },
{ "uint256", "keyword2" },
{ "assert", "keyword2" },
{ "tx", "keyword2" },
{ "require", "keyword" },
{ "bytes8", "keyword2" },
{ "uint32", "keyword2" },
{ "returns", "keyword" },
{ "do", "keyword" },
{ "sha256", "keyword2" },
{ "while", "keyword" },
{ "bytes23", "keyword2" },
{ "function", "keyword" },
{ "memory", "keyword2" },
{ "event", "keyword" },
{ "else", "keyword" },
{ "break", "keyword" },
{ "for", "keyword" },
{ "address", "keyword2" },
{ "bytes4", "keyword2" },
{ "abstract", "keyword" },
{ "gasleft", "keyword2" },
{ "keccak256", "keyword2" },
{ "bytes25", "keyword2" },
{ "bytes28", "keyword2" },
{ "this", "keyword2" },
{ "bytes10", "keyword2" },
{ "protected", "keyword" },
{ "uint8", "keyword2" },
{ "delete", "keyword" },
{ "indexed", "keyword2" },
{ "bytes11", "keyword2" },
{ "bytes17", "keyword2" },
{ "bytes21", "keyword2" },
{ "bytes5", "keyword2" },
{ "bytes26", "keyword2" },
{ "bytes16", "keyword2" },
{ "string", "keyword2" },
{ "bytes31", "keyword2" },
{ "emit", "keyword" },
{ "int32", "keyword2" },
{ "bytes19", "keyword2" },
{ "bytes27", "keyword2" },
{ "int16", "keyword2" },
{ "int8", "keyword2" },
{ "bytes13", "keyword2" },
{ "bytes22", "keyword2" },
{ "hash", "keyword2" },
{ "bytes7", "keyword2" },
{ "pragma", "keyword2" },
{ "int128", "keyword2" },
{ "bytes29", "keyword2" },
{ "int256", "keyword2" },
{ "bytes", "keyword2" },
{ "int64", "keyword2" },
{ "uint16", "keyword2" },
{ "int", "keyword2" },
{ "uint", "keyword2" },
{ "bytes24", "keyword2" },
{ "struct", "keyword" },
{ "uint128", "keyword2" },
{ "bytes2", "keyword2" },
{ "bytes6", "keyword2" },
{ "bytes1", "keyword2" },
{ "override", "keyword2" },
{ "constructor", "keyword" },
{ "using", "keyword" },
{ "nonpayable", "keyword2" },
{ "mapping", "keyword2" },
{ "inherited", "keyword2" },
{ "bytes9", "keyword2" },
{ "pure", "keyword2" },
{ "selfdestruct", "keyword2" },
{ "immutable", "keyword2" },
{ "constant", "keyword2" },
{ "bytes20", "keyword2" },
{ "addmod", "keyword2" },
{ "internal", "keyword2" },
{ "bool", "keyword2" },
{ "public", "keyword2" },
{ "block", "keyword2" },
{ "storage", "keyword2" },
{ "calldata", "keyword2" },
{ "if", "keyword" },
{ "continue", "keyword" },
},
"",
{}
} );
}
}}}} // namespace EE::UI::Doc::Language

10
src/eepp/ui/doc/languages/solidity.hpp Normal file
View File

@@ -0,0 +1,10 @@
#ifndef EE_UI_DOC_Solidity
#define EE_UI_DOC_Solidity
namespace EE { namespace UI { namespace Doc { namespace Language {
extern void addSolidity();
}}}}
#endif

408
src/eepp/ui/doc/languages/sql.cpp Normal file
View File

@@ -0,0 +1,408 @@
#include <eepp/ui/doc/languages/sql.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
namespace EE { namespace UI { namespace Doc { namespace Language {
void addSQL() {
SyntaxDefinitionManager::instance()->add(
{ "SQL",
{ "%.sql$", "%.psql$" },
{
{ { "%-%-.-\n" }, "comment" },
{ { "/%*", "%*/" }, "comment" },
{ { "'", "'", "\\" }, "string" },
{ { "-?%d+[%d%.eE]*f?" }, "number" },
{ { "-?%.?%d+f?" }, "number" },
{ { "[%+%-=/%*%%<>!~|&@%?$#]" }, "operator" },
{ { "[%a_][%w_]*%f[(]" }, "function" },
{ { "[%a_][%w_]*" }, "symbol" },
},
{
{ "SERIAL8", "keyword2" },
{ "INT8RANGE", "keyword2" },
{ "INT8", "keyword2" },
{ "bigint", "keyword2" },
{ "VARBIT", "keyword2" },
{ "recursive", "keyword" },
{ "on", "keyword" },
{ "foreign", "keyword" },
{ "ENUM", "keyword" },
{ "VARIADIC", "keyword" },
{ "serial8", "keyword2" },
{ "DOMAIN", "keyword" },
{ "INT4RANGE", "keyword2" },
{ "OPERATOR", "keyword" },
{ "EVENT", "keyword" },
{ "INDEX", "keyword" },
{ "DATERANGE", "keyword2" },
{ "event", "keyword" },
{ "path", "keyword2" },
{ "CURRENT_TIMESTAMP", "literal" },
{ "RAISE", "keyword" },
{ "LOOP", "keyword" },
{ "loop", "keyword" },
{ "BEGIN", "keyword" },
{ "NOTICE", "keyword" },
{ "EXECUTE", "keyword" },
{ "execute", "keyword" },
{ "raise", "keyword" },
{ "alter", "keyword" },
{ "macaddr", "keyword2" },
{ "ROW", "keyword" },
{ "CASE", "keyword" },
{ "FALSE", "literal" },
{ "row", "keyword" },
{ "BEFORE", "keyword" },
{ "trigger", "keyword" },
{ "FOR", "keyword" },
{ "for", "keyword" },
{ "collation", "keyword" },
{ "UNION", "keyword" },
{ "circle", "keyword2" },
{ "some", "keyword" },
{ "PRECEDING", "keyword" },
{ "left", "keyword" },
{ "varbit", "keyword2" },
{ "SELECT", "keyword" },
{ "EACH", "keyword" },
{ "enum", "keyword" },
{ "preceding", "keyword" },
{ "BETWEEN", "keyword" },
{ "exists", "keyword" },
{ "DESC", "keyword" },
{ "between", "keyword" },
{ "end", "keyword" },
{ "ELSE", "keyword" },
{ "WHEN", "keyword" },
{ "ALSO", "keyword" },
{ "DISTINCT", "keyword" },
{ "END", "keyword" },
{ "varchar", "keyword2" },
{ "when", "keyword" },
{ "CIDR", "keyword2" },
{ "notice", "keyword" },
{ "then", "keyword" },
{ "SET", "keyword" },
{ "uuid", "keyword2" },
{ "FOREIGN", "keyword" },
{ "UNKNOWN", "keyword" },
{ "unknown", "keyword" },
{ "int8", "keyword2" },
{ "NOTNULL", "keyword" },
{ "notnull", "keyword" },
{ "isnull", "keyword" },
{ "date", "keyword2" },
{ "DECLARE", "keyword" },
{ "INTO", "keyword" },
{ "ROWS", "keyword" },
{ "extension", "keyword" },
{ "ALL", "keyword" },
{ "ANY", "keyword" },
{ "content", "keyword" },
{ "ON", "keyword" },
{ "case", "keyword" },
{ "XMLPARSE", "keyword" },
{ "in", "keyword" },
{ "DOCUMENT", "keyword" },
{ "PROCEDURE", "keyword" },
{ "following", "keyword" },
{ "DROP", "keyword" },
{ "document", "keyword" },
{ "type", "keyword" },
{ "TO", "keyword" },
{ "EXCLUDE", "keyword" },
{ "option", "keyword" },
{ "else", "keyword" },
{ "UPDATE", "keyword" },
{ "tsrange", "keyword2" },
{ "xmlparse", "keyword" },
{ "without", "keyword" },
{ "zone", "keyword" },
{ "sequence", "keyword" },
{ "ALTER", "keyword" },
{ "precision", "keyword2" },
{ "INSTEAD", "keyword" },
{ "partition", "keyword" },
{ "THEN", "keyword" },
{ "ZONE", "keyword" },
{ "MONEY", "keyword2" },
{ "instead", "keyword" },
{ "TYPE", "keyword" },
{ "also", "keyword" },
{ "set", "keyword" },
{ "EXISTS", "keyword" },
{ "PRECISION", "keyword2" },
{ "txid_snapshot", "keyword2" },
{ "returning", "keyword" },
{ "ARRAY", "keyword" },
{ "any", "keyword" },
{ "DECIMAL", "keyword2" },
{ "bigserial", "keyword2" },
{ "INNER", "keyword" },
{ "drop", "keyword" },
{ "full", "keyword" },
{ "FULL", "keyword" },
{ "NATURAL", "keyword" },
{ "MACADDR", "keyword2" },
{ "INTEGER", "keyword2" },
{ "inner", "keyword" },
{ "RIGHT", "keyword" },
{ "CHECK", "keyword" },
{ "jsonb", "keyword2" },
{ "EXTENSION", "keyword" },
{ "AND", "keyword" },
{ "SETOF", "keyword" },
{ "PARTITION", "keyword" },
{ "line", "keyword2" },
{ "SERIAL4", "keyword2" },
{ "AS", "keyword" },
{ "LIKE", "keyword" },
{ "GROUP", "keyword" },
{ "ORDINALITY", "keyword" },
{ "RETURNS", "keyword" },
{ "sql", "keyword" },
{ "LATERAL", "keyword" },
{ "NUMERIC", "keyword2" },
{ "int4", "keyword2" },
{ "FUNCTION", "keyword" },
{ "references", "keyword" },
{ "BOX", "keyword2" },
{ "intersect", "keyword" },
{ "CURRENT_DATE", "literal" },
{ "AT", "keyword" },
{ "ASC", "keyword" },
{ "current_timestamp", "literal" },
{ "NULLS", "keyword" },
{ "first", "keyword" },
{ "BOOLEAN", "keyword2" },
{ "bytea", "keyword2" },
{ "BOOL", "keyword2" },
{ "BIGSERIAL", "keyword2" },
{ "json", "keyword2" },
{ "LAST", "keyword" },
{ "localtimestamp", "literal" },
{ "character", "keyword2" },
{ "LEFT", "keyword" },
{ "BYTEA", "keyword2" },
{ "serial", "keyword2" },
{ "time", "keyword2" },
{ "operator", "keyword" },
{ "CHARACTER", "keyword2" },
{ "char", "keyword2" },
{ "float8", "keyword2" },
{ "CHAR", "keyword2" },
{ "EXCEPT", "keyword" },
{ "INT4", "keyword2" },
{ "view", "keyword" },
{ "TSRANGE", "keyword2" },
{ "CIRCLE", "keyword2" },
{ "INT2", "keyword2" },
{ "daterange", "keyword2" },
{ "TIMEZ", "keyword2" },
{ "SERIAL", "keyword2" },
{ "INSERT", "keyword" },
{ "timestampz", "keyword2" },
{ "TSQUERY", "keyword2" },
{ "point", "keyword2" },
{ "pg_lsn", "keyword2" },
{ "unnest", "keyword" },
{ "begin", "keyword" },
{ "decimal", "keyword2" },
{ "LOCALTIME", "literal" },
{ "TIME", "keyword2" },
{ "UNNEST", "keyword" },
{ "tsquery", "keyword2" },
{ "current_time", "literal" },
{ "xmlserialize", "keyword" },
{ "JSON", "keyword2" },
{ "returns", "keyword" },
{ "TSVECTOR", "keyword2" },
{ "TXID_SNAPSHOT", "keyword2" },
{ "lseg", "keyword2" },
{ "int8range", "keyword2" },
{ "localtime", "literal" },
{ "index", "keyword" },
{ "serial4", "keyword2" },
{ "check", "keyword" },
{ "INET", "keyword2" },
{ "smallserial", "keyword2" },
{ "into", "keyword" },
{ "PRIMARY", "keyword" },
{ "UNBOUNDED", "keyword" },
{ "or", "keyword" },
{ "FOLLOWING", "keyword" },
{ "INTERSECT", "keyword" },
{ "SERIAL2", "keyword2" },
{ "false", "literal" },
{ "smallint", "keyword2" },
{ "union", "keyword" },
{ "TIMESTAMPZ", "keyword2" },
{ "float4", "keyword2" },
{ "desc", "keyword" },
{ "tstzrange", "keyword2" },
{ "current_date", "literal" },
{ "KEY", "keyword" },
{ "DOUBLE", "keyword2" },
{ "PG_LSN", "keyword2" },
{ "DATE", "keyword2" },
{ "TRIGGER", "keyword" },
{ "asc", "keyword" },
{ "numrange", "keyword2" },
{ "RECURSIVE", "keyword" },
{ "bit", "keyword2" },
{ "SQL", "keyword" },
{ "SMALLINT", "keyword2" },
{ "TABLE", "keyword" },
{ "tsvector", "keyword2" },
{ "language", "keyword" },
{ "distinct", "keyword" },
{ "LSEG", "keyword2" },
{ "int2", "keyword2" },
{ "as", "keyword" },
{ "OFFSET", "keyword" },
{ "REAL", "keyword2" },
{ "JSONB", "keyword2" },
{ "TRUE", "literal" },
{ "int4range", "keyword2" },
{ "real", "keyword2" },
{ "cidr", "keyword2" },
{ "polygon", "keyword2" },
{ "null", "keyword" },
{ "CONTENT", "keyword" },
{ "rows", "keyword" },
{ "WITH", "keyword" },
{ "LANGUAGE", "keyword" },
{ "POINT", "keyword2" },
{ "BIT", "keyword2" },
{ "ORDER", "keyword" },
{ "numeric", "keyword2" },
{ "unbounded", "keyword" },
{ "SMALLSERIAL", "keyword2" },
{ "timez", "keyword2" },
{ "money", "keyword2" },
{ "lateral", "keyword" },
{ "LINE", "keyword2" },
{ "FIRST", "keyword" },
{ "join", "keyword" },
{ "bool", "keyword2" },
{ "INT", "keyword2" },
{ "inet", "keyword2" },
{ "timestamp", "keyword2" },
{ "FLOAT4", "keyword2" },
{ "FLOAT8", "keyword2" },
{ "all", "keyword" },
{ "RETURNING", "keyword" },
{ "int", "keyword2" },
{ "box", "keyword2" },
{ "cross", "keyword" },
{ "IN", "keyword" },
{ "ordinality", "keyword" },
{ "TIMEZONE", "keyword" },
{ "INTERVAL", "keyword2" },
{ "each", "keyword" },
{ "boolean", "keyword2" },
{ "TSTZRANGE", "keyword2" },
{ "serial2", "keyword2" },
{ "ONLY", "keyword" },
{ "JOIN", "keyword" },
{ "default", "keyword" },
{ "function", "keyword" },
{ "NOT", "keyword" },
{ "NUMRANGE", "keyword2" },
{ "WHERE", "keyword" },
{ "SOME", "keyword" },
{ "VARCHAR", "keyword2" },
{ "XML", "keyword2" },
{ "primary", "keyword" },
{ "delete", "keyword" },
{ "variadic", "keyword" },
{ "not", "keyword" },
{ "DELETE", "keyword" },
{ "declare", "keyword" },
{ "XMLSERIALIZE", "keyword" },
{ "OR", "keyword" },
{ "natural", "keyword" },
{ "interval", "keyword2" },
{ "using", "keyword" },
{ "before", "keyword" },
{ "except", "keyword" },
{ "owned", "keyword" },
{ "values", "keyword" },
{ "exclude", "keyword" },
{ "timezone", "keyword" },
{ "CONSTRAINT", "keyword" },
{ "double", "keyword2" },
{ "OWNED", "keyword" },
{ "UNIQUE", "keyword" },
{ "text", "keyword2" },
{ "LIMIT", "keyword" },
{ "constraint", "keyword" },
{ "NULL", "keyword" },
{ "update", "keyword" },
{ "select", "keyword" },
{ "REFERENCES", "keyword" },
{ "only", "keyword" },
{ "TEXT", "keyword2" },
{ "to", "keyword" },
{ "like", "keyword" },
{ "nulls", "keyword" },
{ "UUID", "keyword2" },
{ "at", "keyword" },
{ "HAVING", "keyword" },
{ "from", "keyword" },
{ "insert", "keyword" },
{ "table", "keyword" },
{ "setof", "keyword" },
{ "true", "literal" },
{ "key", "keyword" },
{ "DEFAULT", "keyword" },
{ "VIEW", "keyword" },
{ "OUTER", "keyword" },
{ "CREATE", "keyword" },
{ "and", "keyword" },
{ "right", "keyword" },
{ "FROM", "keyword" },
{ "create", "keyword" },
{ "unique", "keyword" },
{ "COLLATION", "keyword" },
{ "order", "keyword" },
{ "outer", "keyword" },
{ "xml", "keyword2" },
{ "SEQUENCE", "keyword" },
{ "last", "keyword" },
{ "BY", "keyword" },
{ "where", "keyword" },
{ "WITHOUT", "keyword" },
{ "procedure", "keyword" },
{ "POLYGON", "keyword2" },
{ "group", "keyword" },
{ "LOCALTIMESTAMP", "literal" },
{ "VALUES", "keyword" },
{ "CROSS", "keyword" },
{ "OPTION", "keyword" },
{ "PATH", "keyword2" },
{ "ISNULL", "keyword" },
{ "with", "keyword" },
{ "by", "keyword" },
{ "USING", "keyword" },
{ "having", "keyword" },
{ "domain", "keyword" },
{ "offset", "keyword" },
{ "TIMESTAMP", "keyword2" },
{ "limit", "keyword" },
{ "BIGINT", "keyword2" },
{ "CURRENT_TIME", "literal" },
{ "integer", "keyword2" },
{ "array", "keyword" },
},
"--",
{}
} );
}
}}}} // namespace EE::UI::Doc::Language

10
src/eepp/ui/doc/languages/sql.hpp Normal file
View File

@@ -0,0 +1,10 @@
#ifndef EE_UI_DOC_Sql
#define EE_UI_DOC_Sql
namespace EE { namespace UI { namespace Doc { namespace Language {
extern void addSQL();
}}}}
#endif

230
src/eepp/ui/doc/languages/swift.cpp Normal file
View File

@@ -0,0 +1,230 @@
#include <eepp/ui/doc/languages/swift.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
namespace EE { namespace UI { namespace Doc { namespace Language {
void addSwift() {
SyntaxDefinitionManager::instance()->add(
{ "Swift",
{ "%.swift$" },
{
{ { "//.-\n" }, "comment" },
{ { "/%*", "%*/" }, "comment" },
{ { "\"\"\"", "\"\"\"" }, "string" },
{ { "\"", "\"", "\\" }, "string" },
{ { "-?0x%x+" }, "number" },
{ { "-?%d+[%d%.eE]*f?" }, "number" },
{ { "-?%.?%d+f?" }, "number" },
{ { "[%+%-=/%*%^%%<>!~|&]" }, "operator" },
{ { "[%a_][%w_]*%f[(]" }, "function" },
{ { "[%a_][%w_]*[?!]?" }, "symbol" },
},
{
{ "encodeBitsAsWords", "keyword2" },
{ "postfix", "keyword" },
{ "open", "keyword" },
{ "debugPrintln", "keyword2" },
{ "debugPrint", "keyword2" },
{ "convenience", "keyword" },
{ "count", "keyword2" },
{ "contains", "keyword2" },
{ "#imageLiteral", "keyword" },
{ "enumerate", "keyword2" },
{ "c", "keyword2" },
{ "bridgeToObjectiveCUnconditional", "keyword2" },
{ "try?", "keyword" },
{ "assertionFailure", "keyword2" },
{ "withUnsafePointers", "keyword2" },
{ "Void", "keyword2" },
{ "assert", "keyword2" },
{ "in", "keyword" },
{ "anyGenerator", "keyword2" },
{ "fatalError", "keyword2" },
{ "alignofValue", "keyword2" },
{ "bridgeToObjectiveC", "keyword2" },
{ "alignof", "keyword2" },
{ "willSet", "keyword" },
{ "where", "keyword" },
{ "weak", "keyword" },
{ "typealias", "keyword" },
{ "isBridgedToObjectiveC", "keyword2" },
{ "isUniquelyReferenced", "keyword2" },
{ "underestimateCount", "keyword2" },
{ "try!", "keyword" },
{ "as!", "keyword" },
{ "none", "keyword" },
{ "maxElement", "keyword2" },
{ "throws", "keyword" },
{ "associatedtype", "keyword" },
{ "throw", "keyword" },
{ "lazy", "keyword" },
{ "switch", "keyword" },
{ "super", "keyword" },
{ "struct", "keyword" },
{ "static", "keyword" },
{ "unsafeReflect", "keyword2" },
{ "dropLast", "keyword2" },
{ "Self", "keyword" },
{ "fallthrough", "keyword" },
{ "unowned", "keyword" },
{ "__FILE__", "keyword" },
{ "right", "keyword" },
{ "required", "keyword" },
{ "nonmutating", "keyword" },
{ "try", "keyword" },
{ "withExtendedLifetime", "keyword2" },
{ "public", "keyword" },
{ "final", "keyword" },
{ "Protocol", "keyword" },
{ "guard", "keyword" },
{ "operator", "keyword" },
{ "let", "keyword" },
{ "extension", "keyword" },
{ "posix", "keyword2" },
{ "precedence", "keyword" },
{ "case", "keyword" },
{ "left", "keyword" },
{ "filter", "keyword2" },
{ "min", "keyword2" },
{ "countElements", "keyword2" },
{ "unsafeBitCast", "keyword2" },
{ "do", "keyword" },
{ "max", "keyword2" },
{ "dynamicType", "keyword" },
{ "reverse", "keyword2" },
{ "while", "keyword" },
{ "init", "keyword" },
{ "func", "keyword" },
{ "abs", "keyword2" },
{ "sizeof", "keyword2" },
{ "true", "keyword" },
{ "default", "keyword" },
{ "dynamic", "keyword" },
{ "var", "keyword" },
{ "#sourceLocation", "keyword" },
{ "indices", "keyword2" },
{ "isUniquelyReferencedNonObjC", "keyword2" },
{ "getBridgedObjectiveCType", "keyword2" },
{ "precondition", "keyword2" },
{ "getVaList", "keyword2" },
{ "get", "keyword" },
{ "Double", "keyword2" },
{ "join", "keyword2" },
{ "startsWith", "keyword2" },
{ "Bool", "keyword2" },
{ "associativity", "keyword" },
{ "self", "keyword" },
{ "prefix", "keyword" },
{ "sort", "keyword2" },
{ "lexicographicalCompare", "keyword2" },
{ "insertionSort", "keyword2" },
{ "__LINE__", "keyword" },
{ "Array", "keyword2" },
{ "stride", "keyword2" },
{ "unsafeDowncast", "keyword2" },
{ "strideof", "keyword2" },
{ "continue", "keyword" },
{ "sizeofValue", "keyword2" },
{ "swap", "keyword2" },
{ "withUnsafeMutablePointer", "keyword2" },
{ "Type", "keyword" },
{ "find", "keyword2" },
{ "zip", "keyword2" },
{ "preconditionFailure", "keyword2" },
{ "enum", "keyword" },
{ "withObjectAtPlusZero", "keyword2" },
{ "strideofValue", "keyword2" },
{ "transcode", "keyword2" },
{ "withUnsafePointerToObject", "keyword2" },
{ "overlaps", "keyword2" },
{ "split", "keyword2" },
{ "withUnsafePointer", "keyword2" },
{ "internal", "keyword" },
{ "reinterpretCast", "keyword2" },
{ "reduce", "keyword2" },
{ "toString", "keyword2" },
{ "readLine", "keyword2" },
{ "as", "keyword" },
{ "deinit", "keyword" },
{ "break", "keyword" },
{ "optional", "keyword" },
{ "withVaList", "keyword2" },
{ "quickSort", "keyword2" },
{ "unsafeAddressOf", "keyword2" },
{ "fileprivate", "keyword" },
{ "bridgeFromObjectiveCUnconditional", "keyword2" },
{ "if", "keyword" },
{ "isBridgedVerbatimToObjectiveC", "keyword2" },
{ "String", "keyword2" },
{ "print", "keyword2" },
{ "roundUpToAlignment", "keyword2" },
{ "catch", "keyword" },
{ "equal", "keyword2" },
{ "Optional", "keyword2" },
{ "map", "keyword2" },
{ "println", "keyword2" },
{ "as?", "keyword" },
{ "didSet", "keyword" },
{ "defer", "keyword" },
{ "inout", "keyword" },
{ "is", "keyword" },
{ "Int", "keyword2" },
{ "minElement", "keyword2" },
{ "private", "keyword" },
{ "countLeadingZeros", "keyword2" },
{ "bridgeFromObjectiveC", "keyword2" },
{ "nil", "keyword" },
{ "rethrows", "keyword" },
{ "withUnsafeMutablePointers", "keyword2" },
{ "compactMap", "keyword2" },
{ "unsafeUnwrap", "keyword2" },
{ "#if", "keyword" },
{ "#column", "keyword" },
{ "protocol", "keyword" },
{ "#file", "keyword" },
{ "indirect", "keyword" },
{ "numericCast", "keyword2" },
{ "#elseif", "keyword" },
{ "infix", "keyword" },
{ "override", "keyword" },
{ "#else", "keyword" },
{ "dropFirst", "keyword2" },
{ "subscript", "keyword" },
{ "#line", "keyword" },
{ "for", "keyword" },
{ "import", "keyword" },
{ "false", "keyword" },
{ "#fileLiteral", "keyword" },
{ "advance", "keyword2" },
{ "partition", "keyword2" },
{ "__FUNCTION__", "keyword" },
{ "#endif", "keyword" },
{ "repeat", "keyword" },
{ "#selector", "keyword" },
{ "#available", "keyword" },
{ "mutating", "keyword" },
{ "#colorLiteral", "keyword" },
{ "class", "keyword" },
{ "dump", "keyword2" },
{ "#function", "keyword" },
{ "__COLUMN__", "keyword" },
{ "set", "keyword" },
{ "Any", "keyword" },
{ "return", "keyword" },
{ "distance", "keyword2" },
{ "reflect", "keyword2" },
{ "else", "keyword" },
{ "Float", "keyword2" },
{ "_", "keyword" },
},
"//",
{}
} );
}
}}}} // namespace EE::UI::Doc::Language

10
src/eepp/ui/doc/languages/swift.hpp Normal file
View File

@@ -0,0 +1,10 @@
#ifndef EE_UI_DOC_Swift
#define EE_UI_DOC_Swift
namespace EE { namespace UI { namespace Doc { namespace Language {
extern void addSwift();
}}}}
#endif

13
src/eepp/ui/doc/syntaxdefinition.cpp
View File

@@ -170,6 +170,19 @@ const std::string& SyntaxDefinition::getLanguageName() const {
return mLanguageName;
}
std::string SyntaxDefinition::getLanguageNameForFileSystem() const {
std::string lang( mLanguageName );
String::replaceAll( lang, " ", "" );
String::replaceAll( lang, ".", "" );
String::replaceAll( lang, "!", "" );
String::replaceAll( lang, "[", "" );
String::replaceAll( lang, "]", "" );
String::replaceAll( lang, "+", "p" );
String::replaceAll( lang, "#", "sharp" );
String::toLowerInPlace( lang );
return lang;
}
const String::HashType& SyntaxDefinition::getLanguageId() const {
return mLanguageId;
}

1752
src/eepp/ui/doc/syntaxdefinitionmanager.cpp
View File

File diff suppressed because it is too large Load Diff

34
src/eepp/ui/uicodeeditor.cpp
View File

@@ -261,11 +261,11 @@ void UICodeEditor::draw() {
}
if ( !mLocked && mHighlightCurrentLine ) {
for ( const auto& cursor : mDoc->getSelections() ) {
for ( const auto& sel : mDoc->getSelections() ) {
primitives.setColor( Color( mCurrentLineBackgroundColor ).blendAlpha( mAlpha ) );
primitives.drawRectangle(
Rectf( Vector2f( startScroll.x + mScroll.x,
startScroll.y + cursor.start().line() * lineHeight ),
startScroll.y + sel.start().line() * lineHeight ),
Sizef( mSize.getWidth(), lineHeight ) ) );
}
}
@@ -335,8 +335,8 @@ void UICodeEditor::draw() {
if ( mPluginsGutterSpace > 0 ) {
Float curGutterPos = 0.f;
for ( auto& plugin : mPluginGutterSpaces ) {
for ( unsigned long i = lineRange.first; i <= lineRange.second; i++ ) {
plugin.plugin->drawGutter( this, i,
for ( unsigned long gi = lineRange.first; gi <= lineRange.second; gi++ ) {
plugin.plugin->drawGutter( this, gi,
{ screenStart.x + curGutterPos, curScroll.y },
lineHeight, plugin.space, charSize );
}
@@ -345,8 +345,8 @@ void UICodeEditor::draw() {
}
}
for ( const auto& cursor : mDoc->getSelections() )
drawCursor( startScroll, lineHeight, cursor.start() );
for ( const auto& sel : mDoc->getSelections() )
drawCursor( startScroll, lineHeight, sel.start() );
if ( mShowLineNumber ) {
drawLineNumbers( lineRange, startScroll,
@@ -368,7 +368,12 @@ void UICodeEditor::draw() {
}
void UICodeEditor::scheduledUpdate( const Time& ) {
if ( hasFocus() && getUISceneNode()->getWindow()->hasFocus() ) {
if ( mLastActivity.getElapsedTime() > Seconds(60) ) {
if (!mCursorVisible) {
mCursorVisible = true;
invalidateDraw();
}
} else if ( hasFocus() && getUISceneNode()->getWindow()->hasFocus() ) {
if ( mBlinkTime != Time::Zero && mBlinkTimer.getElapsedTime() > mBlinkTime ) {
mCursorVisible = !mCursorVisible;
mBlinkTimer.restart();
@@ -855,6 +860,7 @@ Uint32 UICodeEditor::onFocus() {
}
for ( auto& plugin : mPlugins )
plugin->onFocus( this );
mLastActivity.restart();
return UIWidget::onFocus();
}
@@ -870,10 +876,13 @@ Uint32 UICodeEditor::onFocusLoss() {
mDoc->setActiveClient( nullptr );
for ( auto& plugin : mPlugins )
plugin->onFocusLoss( this );
mLastActivity.restart();
return UIWidget::onFocusLoss();
}
Uint32 UICodeEditor::onTextInput( const TextInputEvent& event ) {
mLastActivity.restart();
if ( mLocked || NULL == mFont )
return 0;
Input* input = getUISceneNode()->getWindow()->getInput();
@@ -898,6 +907,8 @@ Uint32 UICodeEditor::onTextInput( const TextInputEvent& event ) {
}
Uint32 UICodeEditor::onKeyDown( const KeyEvent& event ) {
mLastActivity.restart();
if ( NULL == mFont || mUISceneNode->getUIEventDispatcher()->justGainedFocus() )
return 0;
@@ -918,6 +929,7 @@ Uint32 UICodeEditor::onKeyDown( const KeyEvent& event ) {
}
Uint32 UICodeEditor::onKeyUp( const KeyEvent& event ) {
mLastActivity.restart();
for ( auto& plugin : mPlugins )
if ( plugin->onKeyUp( this, event ) )
return 1;
@@ -1087,6 +1099,7 @@ Int64 UICodeEditor::calculateMinimapClickedLine( const Vector2i& position ) {
}
Uint32 UICodeEditor::onMouseDown( const Vector2i& position, const Uint32& flags ) {
mLastActivity.restart();
for ( auto& plugin : mPlugins )
if ( plugin->onMouseDown( this, position, flags ) )
return UIWidget::onMouseDown( position, flags );
@@ -1188,6 +1201,7 @@ void UICodeEditor::updateMipmapHover( const Vector2f& position ) {
}
Uint32 UICodeEditor::onMouseMove( const Vector2i& position, const Uint32& flags ) {
mLastActivity.restart();
for ( auto& plugin : mPlugins )
if ( plugin->onMouseMove( this, position, flags ) )
return UIWidget::onMouseMove( position, flags );
@@ -1226,6 +1240,7 @@ Uint32 UICodeEditor::onMouseMove( const Vector2i& position, const Uint32& flags
}
Uint32 UICodeEditor::onMouseUp( const Vector2i& position, const Uint32& flags ) {
mLastActivity.restart();
for ( auto& plugin : mPlugins )
if ( plugin->onMouseUp( this, position, flags ) )
return UIWidget::onMouseUp( position, flags );
@@ -1271,6 +1286,7 @@ Uint32 UICodeEditor::onMouseUp( const Vector2i& position, const Uint32& flags )
}
Uint32 UICodeEditor::onMouseClick( const Vector2i& position, const Uint32& flags ) {
mLastActivity.restart();
for ( auto& plugin : mPlugins )
if ( plugin->onMouseClick( this, position, flags ) )
return UIWidget::onMouseClick( position, flags );
@@ -1307,6 +1323,7 @@ Uint32 UICodeEditor::onMouseClick( const Vector2i& position, const Uint32& flags
}
Uint32 UICodeEditor::onMouseDoubleClick( const Vector2i& position, const Uint32& flags ) {
mLastActivity.restart();
for ( auto& plugin : mPlugins )
if ( plugin->onMouseDoubleClick( this, position, flags ) )
return UIWidget::onMouseDoubleClick( position, flags );
@@ -1329,6 +1346,7 @@ Uint32 UICodeEditor::onMouseDoubleClick( const Vector2i& position, const Uint32&
}
Uint32 UICodeEditor::onMouseOver( const Vector2i& position, const Uint32& flags ) {
mLastActivity.restart();
for ( auto& plugin : mPlugins )
if ( plugin->onMouseOver( this, position, flags ) )
return UIWidget::onMouseOver( position, flags );
@@ -1338,6 +1356,7 @@ Uint32 UICodeEditor::onMouseOver( const Vector2i& position, const Uint32& flags
}
Uint32 UICodeEditor::onMouseLeave( const Vector2i& position, const Uint32& flags ) {
mLastActivity.restart();
if ( mMinimapHover ) {
mMinimapHover = false;
invalidateDraw();
@@ -3206,6 +3225,7 @@ void UICodeEditor::registerKeybindings() {
}
void UICodeEditor::onCursorPosChange() {
mLastActivity.restart();
sendCommonEvent( Event::OnCursorPosChange );
invalidateDraw();
}

37
src/tools/ecode/ecode.cpp
View File

@@ -3503,26 +3503,23 @@ EE_MAIN_FUNC int main( int argc, char* argv[] ) {
if ( convertLangPath && !convertLangPath.Get().empty() ) {
Sys::windowAttachConsole();
IOStreamFile sfile( convertLangPath.Get() );
if ( sfile.isOpen() ) {
std::vector<std::string> adedLangs;
if ( SyntaxDefinitionManager::instance()->loadFromStream( sfile, &adedLangs ) ) {
for ( const auto& lang : adedLangs ) {
const auto& def =
SyntaxDefinitionManager::instance()->getByLanguageName( lang );
auto code = SyntaxDefinitionManager::toCPP( def );
if ( convertLangOutput && !convertLangOutput.Get().empty() &&
FileSystem::isDirectory( convertLangOutput.Get() ) ) {
std::string output( convertLangOutput.Get() );
FileSystem::dirAddSlashAtEnd( output );
FileSystem::fileWrite( output + String::toLower( def.getLanguageName() ) +
".hpp",
code.first );
FileSystem::fileWrite( output + String::toLower( def.getLanguageName() ) +
".cpp",
code.second );
} else {
std::cout << code.first << code.second << "\n";
}
if ( !sfile.isOpen() )
return EXIT_FAILURE;
std::vector<std::string> adedLangs;
if ( SyntaxDefinitionManager::instance()->loadFromStream( sfile, &adedLangs ) ) {
for ( const auto& lang : adedLangs ) {
const auto& def =
SyntaxDefinitionManager::instance()->getByLanguageName( lang );
auto code = SyntaxDefinitionManager::toCPP( def );
if ( convertLangOutput && !convertLangOutput.Get().empty() &&
FileSystem::isDirectory( convertLangOutput.Get() ) ) {
std::string output( convertLangOutput.Get() );
FileSystem::dirAddSlashAtEnd( output );
std::string fileName( def.getLanguageNameForFileSystem() );
FileSystem::fileWrite( output + fileName + ".hpp", code.first );
FileSystem::fileWrite( output + fileName + ".cpp", code.second );
} else {
std::cout << code.first << code.second << "\n";
}
}
}