blumia/pineapple-notepad
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

play around with Scintilla and Lexilla

Browse Source
This commit is contained in:
Gary Wang
2024-07-02 23:47:26 +08:00
parent d7c71f41b2
commit 727a2ec214
992 changed files with 281111 additions and 195 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
3rdparty/scintilla550/scintilla/doc/AddSource.txt vendored Normal file
View File

@ -0,0 +1,30 @@
Some of the build files adapt to adding and removing source code files but most
must be modified by hand. Here is a list of directories and the build files that
must be modified or possibly need to be modified.
The Cocoa project.pbxproj file is complex and should be modified with Xcode.
The other build files can be edited manually.
src:
cocoa/ScintillaFramework/ScintillaFramework.xcodeproj/project.pbxproj
gtk/makefile
qt/ScintillaEdit/ScintillaEdit.pro
qt/ScintillaEditBase/ScintillaEditBase.pro
win32/makefile
win32/scintilla.mak
-- possibly:
test/unit/makefile
test/unit/test.mak
cocoa:
cocoa/ScintillaFramework/ScintillaFramework.xcodeproj/project.pbxproj
gtk:
gtk/makefile
qt:
qt/ScintillaEdit/ScintillaEdit.pro
qt/ScintillaEditBase/ScintillaEditBase.pro
win32:
win32/makefile
win32/scintilla.mak

BIN
3rdparty/scintilla550/scintilla/doc/ChangeHistory.png vendored Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 30 KiB

246
3rdparty/scintilla550/scintilla/doc/Design.html vendored Normal file
View File

@ -0,0 +1,246 @@
<?xml version="1.0"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta name="generator" content="HTML Tidy, see www.w3.org" />
<meta name="generator" content="SciTE" />
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>
Scintilla and SciTE
</title>
</head>
<body bgcolor="#FFFFFF" text="#000000">
<table bgcolor="#000000" width="100%" cellspacing="0" cellpadding="0" border="0">
<tr>
<td>
<img src="SciTEIco.png" border="3" height="64" width="64" alt="Scintilla icon" />
</td>
<td>
<a href="index.html" style="color:white;text-decoration:none"><font size="5">Scintilla
Component Design</font></a>
</td>
</tr>
</table>
<h2>
Top level structure
</h2>
<p>
Scintilla consists of three major layers of C++ code
</p>
<ul>
<li>
Portability Library
</li>
<li>
Core Code
</li>
<li>
Platform Events and API
</li>
</ul>
<p>
The primary purpose of this structure is to separate the platform dependent code from the
platform independent core code. This makes it easier to port Scintilla to a new platform and
ensures that most readers of the code do not have to deal with platform details. To minimise
portability problems and avoid code bloat, a conservative subset of C++ is used in Scintilla
with no exception handling, run time type information or use of the standard C++
library and with limited use of templates.
</p>
<p>
The currently supported platforms, Windows, GTK/Linux, Cocoa, Qt, and wxWidgets are fairly similar in
many ways.
Each has windows, menus and bitmaps. These features generally work in similar ways so each
has a way to move a window or draw a red line. Sometimes one platform requires a sequence of
calls rather than a single call. At other times, the differences are more profound. Reading
the Windows clipboard occurs synchronously but reading the GTK clipboard requires a request
call that will be asynchronously answered with a message containing the clipboard data.
The wxWidgets platform is available from the <a href="http://wxwidgets.org/">wxWidgets site</a>
</p>
<br />
<h3>
Portability Library
</h3>
<p>
This is a fairly small and thin layer over the platform's native capabilities.
</p>
<p>
The portability library is defined in Geometry.h and Platform.h and is implemented once for each platform.
PlatWin.cxx defines the Windows variants of the methods and PlatGTK.cxx the GTK variants.
</p>
<p>
Several of the classes here hold platform specific object identifiers and act as proxies to
these platform objects. Most client code can thus manipulate the platform objects without
caring which is the current platform. Sometimes client code needs access to the underlying
object identifiers and this is provided by the GetID method. The underlying types of the
platform specific identifiers are typedefed to common names to allow them to be transferred
around in client code where needed.
</p>
<h4>
Point, PRectangle
</h4>
<p>
These are simple classes provided to hold the commonly used geometric primitives. A
PRectangle follows the Mac / Windows convention of not including its bottom and right sides
instead of including all its sides as is normal in GTK. It is not called Rectangle as this may be
the name of a macro on Windows.
</p>
<h4>
ColourDesired
</h4>
<p>
This is a simple class holding an expected colour. It is internally represented as a single
32 bit integer in BGR format with 8 bits per colour, but also provides a convenient API to fetch
each component separately.
As a platform might not be able to represent the exact desired colour if it doesn't have 24 bit
depth available, it might not actually represent the exact desired colour but select a best fit
that it can actually render.
</p>
<h4>
Font
</h4>
<p>
Font holds a platform specific font identifier - HFONT for Windows, PangoFontDescription* for GTK. It
does not own the identifier and so will not delete the platform font object in its
destructor. Client code should call Destroy at appropriate times.
</p>
<h4>
Surface
</h4>
<p>
Surface is an abstraction over each platform's concept of somewhere that graphical drawing
operations can be done. It may wrap an already created drawing place such as a window or be
used to create a bitmap that can be drawn into and later copied onto another surface. On
Windows it wraps a HDC and possibly a HBITMAP. On GTK it wraps a cairo_surface_t*.
Other platform specific objects are created (and correctly destroyed) whenever
required to perform drawing actions.
</p>
<p>
Drawing operations provided include drawing filled and unfilled polygons, lines, rectangles,
ellipses and text. The height and width of text as well as other details can be measured.
Operations can be clipped to a rectangle. Most of the calls are stateless with all parameters
being passed at each call. The exception to this is line drawing which is performed by
calling MoveTo and then LineTo.
</p>
<h4>
Window
</h4>
<p>
Window acts as a proxy to a platform window allowing operations such as showing, moving,
redrawing, and destroying to be performed. It contains a platform specific window identifier
- HWND for Windows, GtkWidget* for GTK.
</p>
<h4>
ListBox
</h4>
<p>
ListBox is a subclass of Window and acts as a proxy to a platform listbox adding methods for
operations such as adding, retrieving, and selecting items.
</p>
<h4>
Menu
</h4>
<p>
Menu is a small helper class for constructing popup menus. It contains the platform specific
menu identifier - HMENU for Windows, GtkMenu* for GTK. Most of the work in
constructing menus requires access to platform events and so is done in the Platform Events
and API layer.
</p>
<h4>
Platform
</h4>
<p>
The Platform class is used to access the facilities of the platform. System wide parameters
such as double click speed and chrome colour are available from Platform. Utility functions
such as DebugPrintf are also available from Platform.
</p>
<h3>
Core Code
</h3>
<p>
The bulk of Scintilla's code is platform independent. This is made up of the CellBuffer,
ContractionState, Document, Editor, Indicator, LineMarker, Style, ViewStyle, KeyMap,
ScintillaBase, CallTip,
and AutoComplete primary classes.
</p>
<h4>
CellBuffer
</h4>
<p>
A CellBuffer holds text and styling information, the undo stack, the assignment of line
markers to lines, and the fold structure.
</p>
<p>
A cell contains a character byte and its associated style byte. The current state of the
cell buffer is the sequence of cells that make up the text and a sequence of line information
containing the starting position of each line and any markers assigned to each line.
</p>
<p>
The undo stack holds a sequence of actions on the cell buffer. Each action is one of a text
insertion, a text deletion or an undo start action. The start actions are used to group
sequences of text insertions and deletions together so they can be undone together. To
perform an undo operation, each insertion or deletion is undone in reverse sequence.
Similarly, redo reapplies each action to the buffer in sequence. Whenever a character is
inserted in the buffer either directly through a call such as InsertString or through undo or
redo, its styling byte is initially set to zero. Client code is responsible for styling each
character whenever convenient. Styling information is not stored in undo actions.
</p>
<h4>
Document
</h4>
<p>
A document contains a CellBuffer and deals with some higher level abstractions such as
words, DBCS character sequences and line end character sequences. It is responsible for
managing the styling process and for notifying other objects when changes occur to the
document.
</p>
<h4>
Editor
</h4>
<p>
The Editor object is central to Scintilla. It is responsible for displaying a document and
responding to user actions and requests from the container. It uses ContractionState, Indicator,
LineMarker, Style, and ViewStyle objects to display the document and a KeyMap class to
map key presses to functions.
The visibility of each line is kept in the ContractionState which is also responsible for mapping
from display lines to documents lines and vice versa.
</p>
<p>
There may be multiple Editor objects attached to one Document object. Changes to a
document are broadcast to the editors through the DocWatcher mechanism.
</p>
<h4>
ScintillaBase
</h4>
<p>
ScintillaBase is a subclass of Editor and adds extra windowing features including display of
calltips, autocompletion lists and context menus. These features use CallTip and AutoComplete
objects. This class is optional so a lightweight implementation of Scintilla may bypass it if
the added functionality is not required.
</p>
<h3>
Platform Events and API
</h3>
<p>
Each platform uses different mechanisms for receiving events. On Windows, events are
received through messages and COM. On GTK, callback functions are used.
</p>
<p>
For each platform, a class is derived from ScintillaBase (and thus from Editor). This is
ScintillaWin on Windows and ScintillaGTK on GTK. These classes are responsible for
connecting to the platforms event mechanism and also to implement some virtual methods in
Editor and ScintillaBase which are different on the platforms. For example, this layer has to
support this difference between the synchronous Windows clipboard and the asynchronous GTK
clipboard.
</p>
<p>
The external API is defined in this layer as each platform has different preferred styles of
API - messages on Windows and function calls on GTK. This also allows multiple APIs to be
defined on a platform. The currently available API on GTK is similar to the Windows API and
does not follow platform conventions well. A second API could be implemented here that did
follow platform conventions.
</p>
</body>
</html>

57
3rdparty/scintilla550/scintilla/doc/Icons.html vendored Normal file
View File

@ -0,0 +1,57 @@
<?xml version="1.0"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta name="generator" content="HTML Tidy, see www.w3.org" />
<meta name="generator" content="SciTE" />
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>
Scintilla icons
</title>
</head>
<body bgcolor="#FFFFFF" text="#000000">
<table bgcolor="#000000" width="100%" cellspacing="0" cellpadding="0" border="0">
<tr>
<td>
<img src="SciTEIco.png" border="3" height="64" width="64" alt="Scintilla icon" />
</td>
<td>
<a href="index.html" style="color:white;text-decoration:none"><font size="5">Scintilla
and SciTE</font></a>
</td>
</tr>
</table>
<h2>
Icons
</h2>
<p>
These images may be used under the same license as Scintilla.
</p>
<p>
Drawn by Iago Rubio, Philippe Lhoste, and Neil Hodgson.
</p>
<p>
<a href="http://prdownloads.sourceforge.net/scintilla/icons1.zip?download">zip format</a> (70K)
</p>
<table>
<tr>
<td>For autocompletion lists</td>
<td colspan="3">For margin markers</td>
</tr>
<tr>
<td>12x12</td>
<td>16x16</td>
<td>24x24</td>
<td>32x32</td>
</tr>
<tr>
<td valign="top"><img src="12.png" /></td>
<td valign="top"><img src="16.png" /></td>
<td valign="top"><img src="24.png" /></td>
<td valign="top"><img src="32.png" /></td>
</tr>
</table>
</body>
</html>

BIN
3rdparty/scintilla550/scintilla/doc/Indicators.png vendored Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 20 KiB

226
3rdparty/scintilla550/scintilla/doc/Lexer.txt vendored Normal file
View File

@ -0,0 +1,226 @@
How to write a scintilla lexer
A lexer for a particular language determines how a specified range of
text shall be colored. Writing a lexer is relatively straightforward
because the lexer need only color given text. The harder job of
determining how much text actually needs to be colored is handled by
Scintilla itself, that is, the lexer's caller.
Parameters
The lexer for language LLL has the following prototype:
static void ColouriseLLLDoc (
unsigned int startPos, int length,
int initStyle,
WordList *keywordlists[],
Accessor &styler);
The styler parameter is an Accessor object. The lexer must use this
object to access the text to be colored. The lexer gets the character
at position i using styler.SafeGetCharAt(i);
The startPos and length parameters indicate the range of text to be
recolored; the lexer must determine the proper color for all characters
in positions startPos through startPos+length.
The initStyle parameter indicates the initial state, that is, the state
at the character before startPos. States also indicate the coloring to
be used for a particular range of text.
Note: the character at StartPos is assumed to start a line, so if a
newline terminates the initStyle state the lexer should enter its
default state (or whatever state should follow initStyle).
The keywordlists parameter specifies the keywords that the lexer must
recognize. A WordList class object contains methods that simplify
the recognition of keywords. Present lexers use a helper function
called classifyWordLLL to recognize keywords. These functions show how
to use the keywordlists parameter to recognize keywords. This
documentation will not discuss keywords further.
The lexer code
The task of a lexer can be summarized briefly: for each range r of
characters that are to be colored the same, the lexer should call
styler.ColourTo(i, state)
where i is the position of the last character of the range r. The lexer
should set the state variable to the coloring state of the character at
position i and continue until the entire text has been colored.
Note 1: the styler (Accessor) object remembers the i parameter in the
previous calls to styler.ColourTo, so the single i parameter suffices to
indicate a range of characters.
Note 2: As a side effect of calling styler.ColourTo(i,state), the
coloring states of all characters in the range are remembered so that
Scintilla may set the initStyle parameter correctly on future calls to
the
lexer.
Lexer organization
There are at least two ways to organize the code of each lexer. Present
lexers use what might be called a "character-based" approach: the outer
loop iterates over characters, like this:
lengthDoc = startPos + length ;
for (unsigned int i = startPos; i < lengthDoc; i++) {
chNext = styler.SafeGetCharAt(i + 1);
<< handle special cases >>
switch(state) {
// Handlers examine only ch and chNext.
// Handlers call styler.ColorTo(i,state) if the state changes.
case state_1: << handle ch in state 1 >>
case state_2: << handle ch in state 2 >>
...
case state_n: << handle ch in state n >>
}
chPrev = ch;
}
styler.ColourTo(lengthDoc - 1, state);
An alternative would be to use a "state-based" approach. The outer loop
would iterate over states, like this:
lengthDoc = startPos+lenth ;
for ( unsigned int i = startPos ;; ) {
char ch = styler.SafeGetCharAt(i);
int new_state = 0 ;
switch ( state ) {
// scanners set new_state if they set the next state.
case state_1: << scan to the end of state 1 >> break ;
case state_2: << scan to the end of state 2 >> break ;
case default_state:
<< scan to the next non-default state and set new_state >>
}
styler.ColourTo(i, state);
if ( i >= lengthDoc ) break ;
if ( ! new_state ) {
ch = styler.SafeGetCharAt(i);
<< set state based on ch in the default state >>
}
}
styler.ColourTo(lengthDoc - 1, state);
This approach might seem to be more natural. State scanners are simpler
than character scanners because less needs to be done. For example,
there is no need to test for the start of a C string inside the scanner
for a C comment. Also this way makes it natural to define routines that
could be used by more than one scanner; for example, a scanToEndOfLine
routine.
However, the special cases handled in the main loop in the
character-based approach would have to be handled by each state scanner,
so both approaches have advantages. These special cases are discussed
below.
Special case: Lead characters
Lead bytes are part of DBCS processing for languages such as Japanese
using an encoding such as Shift-JIS. In these encodings, extended
(16-bit) characters are encoded as a lead byte followed by a trail byte.
Lead bytes are rarely of any lexical significance, normally only being
allowed within strings and comments. In such contexts, lexers should
ignore ch if styler.IsLeadByte(ch) returns TRUE.
Note: UTF-8 is simpler than Shift-JIS, so no special handling is
applied for it. All UTF-8 extended characters are >= 128 and none are
lexically significant in programming languages which, so far, use only
characters in ASCII for operators, comment markers, etc.
Special case: Folding
Folding may be performed in the lexer function. It is better to use a
separate folder function as that avoids some troublesome interaction
between styling and folding. The folder function will be run after the
lexer function if folding is enabled. The rest of this section explains
how to perform folding within the lexer function.
During initialization, lexers that support folding set
bool fold = styler.GetPropertyInt("fold");
If folding is enabled in the editor, fold will be TRUE and the lexer
should call:
styler.SetLevel(line, level);
at the end of each line and just before exiting.
The line parameter is simply the count of the number of newlines seen.
It's initial value is styler.GetLine(startPos) and it is incremented
(after calling styler.SetLevel) whenever a newline is seen.
The level parameter is the desired indentation level in the low 12 bits,
along with flag bits in the upper four bits. The indentation level
depends on the language. For C++, it is incremented when the lexer sees
a '{' and decremented when the lexer sees a '}' (outside of strings and
comments, of course).
The following flag bits, defined in Scintilla.h, may be set or cleared
in the flags parameter. The SC_FOLDLEVELWHITEFLAG flag is set if the
lexer considers that the line contains nothing but whitespace. The
SC_FOLDLEVELHEADERFLAG flag indicates that the line is a fold point.
This normally means that the next line has a greater level than present
line. However, the lexer may have some other basis for determining a
fold point. For example, a lexer might create a header line for the
first line of a function definition rather than the last.
The SC_FOLDLEVELNUMBERMASK mask denotes the level number in the low 12
bits of the level param. This mask may be used to isolate either flags
or level numbers.
For example, the C++ lexer contains the following code when a newline is
seen:
if (fold) {
int lev = levelPrev;
// Set the "all whitespace" bit if the line is blank.
if (visChars == 0)
lev |= SC_FOLDLEVELWHITEFLAG;
// Set the "header" bit if needed.
if ((levelCurrent > levelPrev) && (visChars > 0))
lev |= SC_FOLDLEVELHEADERFLAG;
styler.SetLevel(lineCurrent, lev);
// reinitialize the folding vars describing the present line.
lineCurrent++;
visChars = 0; // Number of non-whitespace characters on the line.
levelPrev = levelCurrent;
}
The following code appears in the C++ lexer just before exit:
// Fill in the real level of the next line, keeping the current flags
// as they will be filled in later.
if (fold) {
// Mask off the level number, leaving only the previous flags.
int flagsNext = styler.LevelAt(lineCurrent);
flagsNext &= ~SC_FOLDLEVELNUMBERMASK;
styler.SetLevel(lineCurrent, levelPrev | flagsNext);
}
Don't worry about performance
The writer of a lexer may safely ignore performance considerations: the
cost of redrawing the screen is several orders of magnitude greater than
the cost of function calls, etc. Moreover, Scintilla performs all the
important optimizations; Scintilla ensures that a lexer will be called
only to recolor text that actually needs to be recolored. Finally, it
is not necessary to avoid extra calls to styler.ColourTo: the sytler
object buffers calls to ColourTo to avoid multiple updates of the
screen.
Page contributed by Edward K. Ream

BIN
3rdparty/scintilla550/scintilla/doc/Markers.png vendored Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 24 KiB

70
3rdparty/scintilla550/scintilla/doc/Privacy.html vendored Normal file
View File

@ -0,0 +1,70 @@
<?xml version="1.0"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta name="generator" content="SciTE" />
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>
Privacy Policy
</title>
</head>
<body bgcolor="#FFFFFF" text="#000000">
<table bgcolor="#000000" width="100%" cellspacing="0" cellpadding="0" border="0">
<tr>
<td>
<img src="SciTEIco.png" border="3" height="64" width="64" alt="Scintilla icon" />
</td>
<td>
<a href="index.html" style="color:white;text-decoration:none"><font size="5">Scintilla
and SciTE</font></a>
</td>
</tr>
</table>
<h2>
Privacy Policy for scintilla.org
</h2>
<h3>
Information Collected
</h3>
<p>
Logs are collected to allow analysis of which pages are viewed.
The advertisements collect viewing information through Google Analytics which is
used by Google and advertisers.
No personally identifiable information is collected by scintilla.org.
</p>
<h3>
External Links
</h3>
<p>
Other web sites are linked to from this site.
These web sites have their own privacy policies which may differ significantly to those of scintilla.org.
</p>
<h3>
Cookies
</h3>
<p>
A cookie is a text file placed on the hard drive of a computer by some web pages which is used to remember
when a particular user returns to that site.
The advertisements shown on the main pages may use cookies.
</p>
<h3>
Contact
</h3>
<p>
This web site is the responsibility of Neil Hodgson.
Most queries about the site contents should go to one of the mailing lists mentioned on the main pages.
Queries about the privacy policy may be sent to neilh @ scintilla.org.
</p>
<h3>
Changes to this Policy
</h3>
<p>
This policy may change. If it does then this page will be updated and the date at the bottom will change.
</p>
<p>
This policy was last updated 2 June 2015.
</p>
</body>
</html>

BIN
3rdparty/scintilla550/scintilla/doc/SciBreak.jpg vendored Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 33 KiB

296
3rdparty/scintilla550/scintilla/doc/SciCoding.html vendored Normal file
View File

@ -0,0 +1,296 @@
<?xml version="1.0"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta name="generator" content="SciTE" />
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>
Scintilla and SciTE Code Style Preferences
</title>
<style>
.S0 {
color: #808080;
}
.S1 {
font-family: Comic Sans MS;
color: #007F00;
font-size: 9pt;
}
.S2 {
font-family: Comic Sans MS;
color: #007F00;
font-size: 9pt;
}
.S3 {
font-family: Comic Sans MS;
color: #3F703F;
font-size: 9pt;
}
.S4 {
color: #007F7F;
}
.S5 {
font-weight: bold;
color: #00007F;
}
.S6 {
color: #7F007F;
}
.S7 {
color: #7F007F;
}
.S8 {
color: #804080;
}
.S9 {
color: #7F7F00;
}
.S10 {
font-weight: bold;
color: #000000;
}
.S12 {
font-family: Courier New;
color: #000000;
background: #E0C0E0;
font-size: 10pt;
}
.S13 {
font-family: Courier New;
color: #007F00;
background: #E0FFE0;
font-size: 10pt;
}
.S14 {
font-family: Courier New;
color: #3F7F3F;
background: #E0F0FF;
font-size: 10pt;
}
.S15 {
font-family: Comic Sans MS;
color: #3F703F;
font-size: 9pt;
}
SPAN {
font-family: Verdana;
font-size: 10pt;
}
</style>
</head>
<body bgcolor="#FFFFFF" text="#000000">
<table bgcolor="#000000" width="100%" cellspacing="0" cellpadding="0" border="0">
<tr>
<td>
<img src="SciTEIco.png" border="3" height="64" width="64" alt="Scintilla icon" />
</td>
<td>
<a href="index.html" style="color:white;text-decoration:none"><font size="5">Scintilla
and SciTE</font></a>
</td>
</tr>
</table>
<h2>
Code Style
</h2>
<h3>
Introduction
</h3>
<p>
The source code of Scintilla and SciTE follow my preferences.
Some of these decisions are arbitrary and based on my sense of aesthetics
but its good to have all the code look the same even if its not exactly how
everyone would prefer.
</p>
<p>
Code that does not follow these conventions will be accepted, but will be modified
as time goes by to fit the conventions. Scintilla code follows the conventions more
closely than SciTE except for lexers which are relatively independent modules.
Lexers that are maintained by others are left as they are submitted except that
warnings will be fixed so the whole project can compile cleanly.
</p>
<p>
The <a href="http://astyle.sourceforge.net/">AStyle</a> formatting
program with '--style=attach --indent=force-tab=8 --keep-one-line-blocks
--pad-header --unpad-paren --pad-comma --indent-cases --align-pointer=name --pad-method-prefix
--pad-return-type --pad-param-type --align-method-colon --pad-method-colon=after' arguments formats code in much the right way although
there are a few bugs in AStyle.
</p>
<h3>
Language features
</h3>
<p>
Design goals for Scintilla and SciTE include portability to currently available C++
compilers on diverse platforms with high performance and low resource usage.
Scintilla has stricter portability requirements to SciTE as it may be ported to
low capability platforms.
Scintilla code must build with C++17 which can be checked with "g++ --std=c++17".
SciTE can use C++17 features that are widely available from g++ 7.1, MSVC 2017.6 and Clang 5.0 compilers.
</p>
<p>
To achieve portability, only a subset of C++ features are used.
Exceptions and templates may be used but, since Scintilla can be used from C as well as
C++, exceptions may not be thrown out of Scintilla and all exceptions should be caught
before returning from Scintilla.
A 'Scintilla' name space is used. This helps with name clashes on macOS.
</p>
<p>
The goto statement is not used because of bad memories from my first job
maintaining FORTRAN programs. The union feature is not used as it can lead to
non-type-safe value access.
</p>
<p>
The SCI_METHOD preprocessor definition should be used when implementing
interfaces which include it like ILexer and only there.
</p>
<p>
Headers should always be included in the same order as given by the
scripts/HeaderOrder.txt file.
</p>
<h3>
Casting
</h3>
<p>
Do not use old C style casts like (char *)s. Instead use the most strict form of C++
cast possible like const_cast&lt;char *&gt;(s). Use static_cast and const_cast
where possible rather than reinterpret_cast.
</p>
<p>
The benefit to using the new style casts is that they explicitly detail what evil is
occurring and act as signals that something potentially unsafe is being done.
</p>
<p>
Code that treats const seriously is easier to reason about both for humans
and compilers, so use const parameters and avoid const_cast.
</p>
<h3>
Warnings
</h3>
<p>
To help ensure code is well written and portable, it is compiled with almost all
warnings turned on. This sometimes results in warnings about code that is
completely good (false positives) but changing the code to avoid the warnings
is generally fast and has little impact on readability.
</p>
<p>
Initialise all variables and minimise the scope of variables. If a variable is defined
just before its use then it can't be misused by code before that point.
Use loop declarations that are compatible with both the C++ standard and currently
available compilers.
</p>
<h3>
Allocation
</h3>
<p>
Memory exhaustion can occur in many Scintilla methods.
This should be checked for and handled but once it has happened, it is very difficult to do
anything as Scintilla's data structures may be in an inconsistent state.
Fixed length buffers are often used as these are simple and avoid the need to
worry about memory exhaustion but then require that buffer lengths are
respected.
</p>
<p>
The C++ new and delete operators are preferred over C's malloc and free
as new and delete are type safe.
</p>
<h3>
Bracketing
</h3>
<p>
Start brackets, '{', should be located on the line of the control structure they
start and end brackets, '}', should be at the indented start of a line. When there is
an else clause, this occurs on the same line as the '}'.
This format uses less lines than alternatives, allowing more code to be seen on screen.
Fully bracketed control
structures are preferred because this makes it more likely that modifications will
be correct and it allows Scintilla's folder to work. No braces on returned
expressions as return is a keyword, not a function call.
</p>
<SPAN class=S0></SPAN><SPAN class=S5>bool</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S11>fn</SPAN><SPAN class=S10>(</SPAN><SPAN class=S5>int</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S11>a</SPAN><SPAN class=S10>)</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S10>{</SPAN><SPAN class=S0><BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN class=S5>if</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S10>(</SPAN><SPAN class=S11>a</SPAN><SPAN class=S10>)</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S10>{</SPAN><SPAN class=S0><BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN class=S11>s</SPAN><SPAN class=S10>();</SPAN><SPAN class=S0><BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN class=S11>t</SPAN><SPAN class=S10>();</SPAN><SPAN class=S0><BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN class=S10>}</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S5>else</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S10>{</SPAN><SPAN class=S0><BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN class=S11>u</SPAN><SPAN class=S10>();</SPAN><SPAN class=S0><BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN class=S10>}</SPAN><SPAN class=S0><BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN class=S5>return</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S10>!</SPAN><SPAN class=S11>a</SPAN><SPAN class=S10>;</SPAN><SPAN class=S0><BR>
</SPAN><SPAN class=S10>}</SPAN><SPAN class=S0><BR>
</SPAN> <h3>
Spacing
</h3>
<p>
Spaces on both sides of '=' and comparison operators and no attempt to line up '='.
No space before or after '(', when used in calls, but a space after every ','.
No spaces between tokens in short expressions but may be present in
longer expressions. Space before '{'. No space before ';'.
No space after '*' when used to mean pointer and no space after '[' or ']'.
One space between keywords and '('.
</p>
<SPAN class=S0></SPAN><SPAN class=S5>void</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S11>StoreConditionally</SPAN><SPAN class=S10>(</SPAN><SPAN class=S5>int</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S11>c</SPAN><SPAN class=S10>,</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S5>const</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S5>char</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S10>*</SPAN><SPAN class=S11>s</SPAN><SPAN class=S10>)</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S10>{</SPAN><SPAN class=S0><BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN class=S5>if</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S10>(</SPAN><SPAN class=S11>c</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S10>&amp;&amp;</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S10>(</SPAN><SPAN class=S11>baseSegment</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S10>==</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S11>trustSegment</SPAN><SPAN class=S10>[</SPAN><SPAN class=S6>"html"</SPAN><SPAN class=S10>]))</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S10>{</SPAN><SPAN class=S0><BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN class=S11>baseSegment</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S10>=</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S11>s</SPAN><SPAN class=S10>+</SPAN><SPAN class=S4>1</SPAN><SPAN class=S10>;</SPAN><SPAN class=S0><BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN class=S11>Store</SPAN><SPAN class=S10>(</SPAN><SPAN class=S11>s</SPAN><SPAN class=S10>,</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S11>baseSegment</SPAN><SPAN class=S10>,</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S6>"html"</SPAN><SPAN class=S10>);</SPAN><SPAN class=S0><BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN class=S10>}</SPAN><SPAN class=S0><BR>
</SPAN><SPAN class=S10>}</SPAN>
<h3>
Names
</h3>
<p>
Identifiers use mixed case and no underscores.
Class, function and method names start with an uppercase letter and use
further upper case letters to distinguish words. Variables start with a lower
case letter and use upper case letters to distinguish words.
Loop counters and similar variables can have simple names like 'i'.
Function calls should be differentiated from method calls with an initial '::'
global scope modifier.
</p>
<SPAN class=S0></SPAN><SPAN class=S5>class</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S11>StorageZone</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S10>{</SPAN><SPAN class=S0><BR>
</SPAN><SPAN class=S5>public</SPAN><SPAN class=S10>:</SPAN><SPAN class=S0><BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN class=S5>void</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S11>Store</SPAN><SPAN class=S10>(</SPAN><SPAN class=S5>const</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S5>char</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S10>*</SPAN><SPAN class=S11>s</SPAN><SPAN class=S10>)</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S10>{</SPAN><SPAN class=S0><BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN class=S11>Media</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S10>*</SPAN><SPAN class=S11>mediaStore</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S10>=</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S10>::</SPAN><SPAN class=S11>GetBaseMedia</SPAN><SPAN class=S10>(</SPAN><SPAN class=S11>zoneDefault</SPAN><SPAN class=S10>);</SPAN><SPAN class=S0><BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN class=S5>for</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S10>(</SPAN><SPAN class=S5>int</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S11>i</SPAN><SPAN class=S10>=</SPAN><SPAN class=S11>mediaStore</SPAN><SPAN class=S10>-&gt;</SPAN><SPAN class=S11>cursor</SPAN><SPAN class=S10>;</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S11>mediaStore</SPAN><SPAN class=S10>[</SPAN><SPAN class=S11>i</SPAN><SPAN class=S10>],</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S11>i</SPAN><SPAN class=S10>++)</SPAN><SPAN class=S0>&nbsp;</SPAN><SPAN class=S10>{</SPAN><SPAN class=S0><BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN class=S11>mediaStore</SPAN><SPAN class=S10>-&gt;</SPAN><SPAN class=S11>Persist</SPAN><SPAN class=S10>(</SPAN><SPAN class=S11>s</SPAN><SPAN class=S10>[</SPAN><SPAN class=S11>i</SPAN><SPAN class=S10>]);</SPAN><SPAN class=S0><BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN class=S10>}</SPAN><SPAN class=S0><BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN class=S10>}</SPAN><SPAN class=S0><BR>
</SPAN><SPAN class=S10>};</SPAN>
<h3>
Submitting a lexer
</h3>
<p>Lexers have been moved to the separate <a href="https://www.scintilla.org/Lexilla.html">Lexilla</a> project
which is on GitHub which may have updated instructions.</p>
<p>Add an issue or pull request on the <a href="https://github.com/ScintillaOrg/lexilla">Lexilla project page</a>.</p>
<p>Define all of the lexical states in a modified LexicalStyles.iface.</p>
<p>Ensure there are no warnings under the compiler you use. Warnings from other compilers
will be noted on the feature request.</p>
<p>sc.ch is an int: do not pass this around as a char.</p>
<p>The ctype functions like isalnum and isdigit only work on ASCII (0..127) and may cause
undefined behaviour including crashes if used on other values. Check with IsASCII before calling is*.</p>
<p>Functions, structs and classes in lexers should be in an unnamed namespace (see LexCPP)
or be marked "static" so they will not leak into other lexers.</p>
<p>If you copy from an existing lexer, remove any code that is not needed since it makes it
more difficult to maintain and review.</p>
<p>When modifying an existing lexer, try to maintain as much compatibility as possible.
Do not renumber lexical styles as current client code may be built against the earlier values.</p>
<h4>
Properties
</h4>
<p>
Properties provided by a new lexer should follow the naming conventions
and should include a comment suitable for showing to end users.
The convention is for properties that control styling to be named
lexer.&lt;lexername&gt;.* and those that control folding to be named
fold.&lt;lexername&gt;.*.
Examples are "lexer.python.literals.binary" and "fold.haskell.imports".
</p>
<p>
The properties "fold" and "fold.comment" are generic and can be used by
any lexer.
</p>
<p>
See LexPython for examples of properties in an object lexer and LexHTML for a functional lexer.
</p>
</body>
</html>

BIN
3rdparty/scintilla550/scintilla/doc/SciRest.jpg vendored Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 16 KiB

BIN
3rdparty/scintilla550/scintilla/doc/SciTEIco.png vendored Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 9.5 KiB

BIN
3rdparty/scintilla550/scintilla/doc/SciWord.jpg vendored Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 6.0 KiB

225
3rdparty/scintilla550/scintilla/doc/Scintilla5Migration.html vendored Normal file
View File

@ -0,0 +1,225 @@
<?xml version="1.0"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta name="generator"
content="HTML Tidy for Windows (vers 1st August 2002), see www.w3.org" />
<meta name="generator" content="SciTE" />
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<title>Migration to Scintilla 5.x.</title>
<style type="text/css">
<!--
/*<![CDATA[*/
CODE { font-weight: bold; font-family: Menlo,Consolas,Bitstream Vera Sans Mono,Courier New,monospace; }
CODE.example { background: #EBFFF7;}
CODE.windows { background: #E7F0FF;}
CODE.unix { background: #FFFFD7;}
A:visited { color: blue; }
A:hover { text-decoration: underline ! important; }
A.message { text-decoration: none; font-weight: bold; font-family: Menlo,Consolas,Bitstream Vera Sans Mono,Courier New,monospace; }
A.seealso { text-decoration: none; font-weight: bold; font-family: Menlo,Consolas,Bitstream Vera Sans Mono,Courier New,monospace; }
A.toc { text-decoration: none; }
A.jump { text-decoration: none; }
LI.message { text-decoration: none; font-weight: bold; font-family: Menlo,Consolas,Bitstream Vera Sans Mono,Courier New,monospace; }
H2 { background: #E0EAFF; }
table {
border: 0px;
border-collapse: collapse;
}
div.console {
font-family: Menlo,Consolas,Bitstream Vera Sans Mono,Courier New,monospace;
color: #008000;
font-weight: bold;
background: #F7FCF7;
border: 1px solid #C0D7C0;
margin: 0.3em 3em;
padding: 0.3em 0.6em;
}
span.console {
font-family: Menlo,Consolas,Bitstream Vera Sans Mono,Courier New,monospace;
color: #008000;
font-weight: bold;
background: #F7FCF7;
border: 1px solid #C0D7C0;
margin: 0.1em 0em;
padding: 0.1em 0.3em;
}
.name {
color: #B08000;
}
/*]]>*/
-->
</style>
</head>
<body bgcolor="#FFFFFF" text="#000000">
<table bgcolor="#000000" width="100%" cellspacing="0" cellpadding="0" border="0"
summary="Banner">
<tr>
<td><img src="SciTEIco.png" border="3" height="64" width="64" alt="Lexilla icon" /></td>
<td><a href="index.html"
style="color:white;text-decoration:none;font-size:200%">Scintilla</a></td>
</tr>
</table>
<h1>Migrating Applications to Scintilla 5 with Lexilla.</h1>
<h2>Introduction</h2>
<p>With Scintilla 5.0, all lexers were moved from Scintilla into the Lexilla library
which is a <a href="https://www.scintilla.org/Lexilla.html">separate project</a>.
Lexilla may be either a static library
that is linked into an application or a shared library that is loaded at runtime.</p>
<p>Lexilla has its own <a href="LexillaDoc.html">documentation</a>.</p>
<h2>Basics</h2>
<p>With Scintilla 4.x, it was most common for applications to set a lexer either by lexer name or lexer ID (<span class="name">SCLEX_...</span>) by calling
<code>SCI_SETLEXERLANGUAGE("&lt;name&gt;")</code> or <code>SCI_SETLEXER(SCLEX_*)</code>.</p>
<p>With Scintilla 5, the normal technique is to call Lexilla's <span class="name">CreateLexer</span> function
with a lexer name, then apply the result with
Scintilla's <span class="name">SCI_SETILEXER</span> method:<br />
<code>ILexer5 *pLexer = CreateLexer("&lt;name&gt;")<br />
SCI_SETILEXER(pLexer)</code></p>
<p>Lexer names are now strongly preferred to lexer IDs and applications should switch where possible.
Some lexers will not have lexer IDs but all will have names.</p>
<p>Applications may be written in C++ or C; may contain a statically linked Lexilla library or load a Lexilla
shared library; and may use the raw Lexilla API or the LexillaAccess C++ helper module.</p>
<h2>From C++: LexillaAccess</h2>
<p>The easiest technique is to implement in C++ using LexillaAccess and load a Lexilla shared library.</p>
<p>LexillaAccess simplifies use of Lexilla, hides operating system differences, and allows loading
multiple libraries that support the Lexilla protocol.
It is defined in lexilla/access/LexillaAccess.h and the source code is in lexilla/access/LexillaAccess.cxx.
Add these to the build dependencies of the project or build file.</p>
<p>Both SciTE and TestLexers (used to test Lexilla) in lexilla/test use LexillaAccess.
TestLexers is much simpler than SciTE so can be a good example to examine.</p>
<h3>Building</h3>
<p>Header files for lexers and for using Lexilla will be included so build files will need to reference these new locations.
LexillaAccess.cxx should be added to the set of source files.
In make, for example, this may appear similar to:</p>
<code class="example">
LEXILLA_DIR ?= $(srcdir)/../../lexilla<br />
INCLUDES += -I $(LEXILLA_DIR)/include -I $(LEXILLA_DIR)/access<br />
SOURCES += $(LEXILLA_DIR)/access/LexillaAccess.cxx<br />
</code>
<h3>Steps in code</h3>
<p>Set the directory to search for Lexilla when full paths aren't provided.
This may be a known good system or user directory or the directory of the application
depending on the operating system conventions.</p>
<code class="example">
std::string homeDirectory = "/Users/Me/bin";<br />
Lexilla::SetDefaultDirectory(homeDirectory);<br />
</code>
<p>Load Lexilla or another library that implements the Lexilla protocol.
The name "." means the standard name and extension (liblexilla.so / liblexilla.dylib / lexilla.dll)
in the default directory so is often a good choice. Names without extensions have the operating system's preferred
shared library extension added.
A full path can also be used.
Multiple libraries can be loaded at once by listing them separated by ';'.
Something like one of these lines:</p>
<code class="example">
Lexilla::Load(".");<br />
Lexilla::Load("lexilla;lexpeg;XMLexers");<br />
Lexilla::Load("/usr/lib/liblexilla.so;/home/aardvark/bin/libpeg.so");<br />
</code>
<p>Choose the name of the lexer to use. This may be determined from the file extension or some other mechanism.</p>
<code class="example">
std::string lexerName = "cpp";<br />
</code>
<p>Create a lexer and apply it to a Scintilla instance.</p>
<code class="example">
Scintilla::ILexer5 *pLexer = Lexilla::MakeLexer(lexerName);<br />
CallScintilla(scintilla, SCI_SETILEXER, 0, pLexer);<br />
</code>
<p>Some applications may use integer lexer IDs from SciLexer.h with an "SCLEX_" prefix like
<span class="name">SCLEX_CPP</span>.
These can be converted to a name with NameFromID before passing to MakeLexer.</p>
<code class="example">
Scintilla::ILexer5 *pLexer = Lexilla::MakeLexer(Lexilla::NameFromID(SCLEX_CPP));<br />
</code>
<h2>From C: Lexilla.h and system APIs</h2>
<p>Applications written in C or C++ can use the raw Lexilla API which is defined in lexilla/include/Lexilla.h.
Since the ILexer interface is difficult to define for C, C applications should treat the result of CreateLexer as a
<code>void*</code> that is simply passed through to Scintilla.
If there is a need to call methods on the lexer
before passing it to Scintilla then it would be best to use some C++ code although it may be possible
for a sufficiently motivated developer to call methods on the lexer from C.</p>
<p>There is an example for using Lexilla from C in examples/CheckLexilla.</p>
<h3>Steps in code</h3>
<p>Include the system header for loading shared objects.
This depends on the operating system: &lt;windows.h&gt; for <code class="windows">Windows</code> or
&lt;dlfcn.h&gt; for <code class="unix">Unix</code>.</p>
<code class="windows">#include &lt;windows.h&gt;<br /></code>
<code class="unix">#include &lt;dlfcn.h&gt;<br /></code>
<p>Define a path to the Lexilla shared library.
This may be a known good system or user directory or the directory of the application
depending on the operating system conventions.</p>
<code class="example">
#include "Lexilla.h"<br />
char szLexillaPath[] = "../../bin/" LEXILLA_LIB LEXILLA_EXTENSION;<br />
</code>
<p>Load Lexilla using the appropriate operating system function: either LoadLibrary on Windows or
dlopen on Unix.</p>
<code class="windows">HMODULE lexillaLibrary = LoadLibrary(szLexillaPath);<br /></code>
<code class="unix">void *lexillaLibrary = dlopen(szLexillaPath, RTLD_LAZY);<br /></code>
<p>Find the CreateLexer function inside the shared library using either GetProcAddress on Windows or
dlsym on Unix.</p>
<code class="windows">FARPROC fun = GetProcAddress(lexillaLibrary, LEXILLA_CREATELEXER);<br /></code>
<code class="unix">void *fun = dlsym(lexillaLibrary, LEXILLA_CREATELEXER);<br /></code>
<p>Cast this to the correct type.</p>
<code class="example">CreateLexerFn lexerCreate = (CreateLexerFn)(fun);<br /></code>
<p>Choose the name of the lexer to use. This may be determined from the file extension or some other mechanism.</p>
<code class="example">char lexerName[] = "cpp";<br /></code>
<p>Create a lexer and apply it to a Scintilla instance.</p>
<code class="example">
void *pLexer = lexerCreate(lexerName);<br />
CallScintilla(scintilla, SCI_SETILEXER, 0, pLexer);<br />
</code>
<p>If the application uses integer lexer IDs then find the <span class="name">LEXILLA_LEXERNAMEFROMID</span>
function, cast to <span class="name">LexerNameFromIDFn</span> then call with the ID before using the result to call
<span class="name">CreateLexer</span>.</p>
<code class="windows">FARPROC funName = GetProcAddress(lexillaLibrary, LEXILLA_LEXERNAMEFROMID);<br /></code>
<code class="unix">void *funName = dlsym(lexillaLibrary, LEXILLA_LEXERNAMEFROMID);<br /></code>
<code class="example">LexerNameFromIDFn lexerNameFromID = (LexerNameFromIDFn)(funName);<br /></code>
<code class="example">const char *name = lexerNameFromID(lexerID);<br /></code>
<h2>Static linking</h2>
<p>Lexilla may be linked directly into an application or built into a static library that is then
linked into the application, then there is no need to load a shared library and
<span class="name">CreateLexer</span> can be directly called.</p>
<p>It is possible to link Lexilla into an application and then dynamically load other
shared libraries that implement the Lexilla protocol.
SciTE on Windows implements this as an option when built with STATIC_BUILD defined.</p>
</body>
</html>

10231
3rdparty/scintilla550/scintilla/doc/ScintillaDoc.html vendored Normal file
View File

File diff suppressed because it is too large Load Diff

71
3rdparty/scintilla550/scintilla/doc/ScintillaDownload.html vendored Normal file
View File

@ -0,0 +1,71 @@
<?xml version="1.0"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta name="generator" content="HTML Tidy, see www.w3.org" />
<meta name="generator" content="SciTE" />
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>
Download Scintilla
</title>
</head>
<body bgcolor="#FFFFFF" text="#000000">
<table bgcolor="#000000" width="100%" cellspacing="0" cellpadding="0" border="0">
<tr>
<td>
<img src="SciTEIco.png" border="3" height="64" width="64" alt="Scintilla icon" />
</td>
<td>
<a href="index.html" style="color:white;text-decoration:none"><font size="5">Download
Scintilla</font></a>
</td>
</tr>
</table>
<table bgcolor="#CCCCCC" width="100%" cellspacing="0" cellpadding="8" border="0">
<tr>
<td>
<font size="4"> <a href="https://www.scintilla.org/scintilla550.zip">
Windows</a>&nbsp;&nbsp;
<a href="https://www.scintilla.org/scintilla550.tgz">
GTK/Linux</a>&nbsp;&nbsp;
</font>
</td>
</tr>
</table>
<h2>
Download.
</h2>
<p>
The <a href="License.txt">license</a> for using Scintilla or SciTE is similar to that of Python
containing very few restrictions.
</p>
<h3>
Release 5.5.0
</h3>
<h4>
Source Code
</h4>
The source code package contains all of the source code for Scintilla but no binary
executable code and is available in
<ul>
<li><a href="https://www.scintilla.org/scintilla550.zip">zip format</a> (1.8M) commonly used on Windows</li>
<li><a href="https://www.scintilla.org/scintilla550.tgz">tgz format</a> (1.7M) commonly used on Linux and compatible operating systems</li>
</ul>
Instructions for building on both Windows and Linux are included in the readme file.
<h4>
Windows Executable Code
</h4>
There is no download available containing only the Scintilla DLL.
However, it is included in the <a href="SciTEDownload.html">SciTE
executable full download</a> as Scintilla.DLL.
<p>
<a href="SciTEDownload.html">SciTE</a> is a good demonstration of Scintilla.
</p>
<p>
Previous versions can be downloaded from the <a href="ScintillaHistory.html">history
page</a>.
</p>
</body>
</html>

14143
3rdparty/scintilla550/scintilla/doc/ScintillaHistory.html vendored Normal file
View File

File diff suppressed because it is too large Load Diff

BIN
3rdparty/scintilla550/scintilla/doc/ScintillaLogo.png vendored Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 192 KiB

BIN
3rdparty/scintilla550/scintilla/doc/ScintillaLogo2x.png vendored Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 211 KiB

569
3rdparty/scintilla550/scintilla/doc/ScintillaRelated.html vendored Normal file
View File

@ -0,0 +1,569 @@
<?xml version="1.0"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta name="generator" content="HTML Tidy, see www.w3.org" />
<meta name="generator" content="SciTE" />
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>
Scintilla and SciTE Related Sites
</title>
</head>
<body bgcolor="#FFFFFF" text="#000000">
<table bgcolor="#000000" width="100%" cellspacing="0" cellpadding="0" border="0">
<tr>
<td>
<img src="SciTEIco.png" border="3" height="64" width="64" alt="Scintilla icon" />
</td>
<td>
<a href="index.html" style="color:white;text-decoration:none"><font size="5">Scintilla
and SciTE</font></a>
</td>
</tr>
</table>
<h2>
Related Sites
</h2>
<h3>
Ports and Bindings of Scintilla
</h3>
<p>
<a href="https://github.com/mneuroth/SciTEQt">SciTEQt</a>
is a port of the SciTE editor to the Qt QML/Quick platform.
</p>
<p>
<a href="https://orbitalquark.github.io/scinterm">Scinterm</a>
is an implementation of Scintilla for the ncurses platform.
</p>
<p>
<a href="http://www.morphos-team.net/releasenotes/3.0">Scintilla.mcc</a>
is a port to MorphOS.
</p>
<p>
<a href="https://metacpan.org/pod/Wx::Scintilla">Wx::Scintilla</a>
is a Perl Binding for Scintilla on wxWidgets.
</p>
<p>
<a href="http://codebrainz.github.com/GtkScintilla/">GtkScintilla</a>
is a GTK+ widget which enables easily adding a powerful
source code editor to your applications. Harnessing the abilities
of the Scintilla editing component, GtkScintilla adds a familiar
GTK+/GObject API, making the widget comfortable to use in
these programs, using all the typical GObject conventions.
</p>
<p>
<a href="http://www.mewsoft.com/forums/source-code-editor-activex-control-released-scintilla-activex-wrapper-control&amp;action=ViewTopic&amp;Topic=1494&amp;Forum=1&amp;Page=1&amp;Period=0a&amp;Lang=English">Editawy</a>
is an ActiveX Control wrapper that support all Scintilla functions and additional high level functions.
</p>
<p>
<a href="http://sourceforge.net/projects/jintilla/">Jintilla</a>
is a JNI wrapper that allows Scintilla to be used in Java with
both SWT and AWT.
</p>
<p>
<a href="http://delphisci.sourceforge.net/">Delphi Scintilla Interface Components</a>
is a FREE collection of components that makes it easy to use the
Scintilla source code editing control from within Delphi and C++ Builder.
</p>
<p>
<a href="http://wxcode.sourceforge.net/showcomp.php?name=wxStEdit">wxStEdit</a>
is a library and sample program that provides extra features over wxStyledTextControl.
</p>
<p>
<a href="http://www.naughter.com/scintilla.html">CScintillaCtrl, CScintillaView &amp; CScintillaDoc</a>
are freeware MFC classes to encapsulate Scintilla.
</p>
<p>
<a href="http://sourceforge.net/projects/scide/">ScintillaNet
</a> is an encapsulation of Scintilla for use within the .NET framework.
</p>
<p>
<a href="https://riverbankcomputing.com/software/qscintilla/intro">QScintilla
</a> is a port of Scintilla to the Qt platform. It has a similar license to Qt: GPL for use in
free software and commercial for use in close-source applications.
</p>
<p>
<a href="http://www.adapower.com/gwindows/">
GWindows</a> is a Win32 RAD GUI Framework for Ada 95 that
includes a binding of Scintilla.
</p>
<p>
<a href="http://scintilla.cvs.sourceforge.net/viewvc/scintilla/ScintillaVB/">ScintillaVB</a>
is an ActiveX control written in VB that encapsulates Scintilla.
</p>
<p>
<a href="http://savannah.nongnu.org/projects/fxscintilla/">FXScintilla
</a> is a port of Scintilla to the FOX platform. FXRuby includes Ruby
bindings for FXScintilla.
</p>
<p>
<a href="http://www.pnotepad.org/scintilla/">Delphi wrapper</a> for
Scintilla which is also usable from Borland C++ Builder.
</p>
<p>
The wxStyledTextCtrl editor component in the
<a href="http://www.wxwidgets.org/">wxWidgets</a> cross platform toolkit is based on Scintilla.<br />
A Python binding for wxStyledTextCtrl is part of <a href="http://wxpython.org/">wxPython</a>.
</p>
<p>
<a href="http://sourceforge.net/projects/moleskine/">gtkscintilla</a>
is an alternative GTK class implementation for scintilla.
This implementation acts more like a Gtk+ object, with many methods rather
than just scintilla_send_message() and is available as a shared library.
This implementation works with GTK 1.x.
</p>
<p>
<a href="http://sourceforge.net/projects/moleskine/">gtkscintilla2</a>
is an alternative GTK class implementation for scintilla
similar to the above, but for GTK 2.x.
</p>
<p>
<a href="http://sourceforge.net/projects/moleskine/">pygtkscintilla</a>
is a Python binding for gtk1.x scintilla that uses
gtkscintilla instead of the default GTK class.
</p>
<p>
<a href="http://scintilla.cvs.sourceforge.net/viewvc/scintilla/scintillactrl/">ScintillaCtrl</a>
is an unmaintained ActiveX control wrapper for Scintilla.
</p>
<h3>
Projects using Scintilla
</h3>
<p>
<a href="https://github.com/dail8859/NotepadNext">Notepad Next</a>
is a cross-platform reimplementation of Notepad++.
</p>
<p>
<a href="https://github.com/dolphinsmalltalk/Dolphin">Dolphin Smalltalk</a>
is an implementation of the Smalltalk language for Windows.
</p>
<p>
<a href="https://github.com/simdsoft/x-studio/blob/master/README_EN.md">x-studio</a>
is a powerful and very lightweight developer IDE that supports Lua debugging.
</p>
<p>
<a href="https://sourceforge.net/projects/autogui/">Adventure IDE</a>
is a general-purpose IDE and lightweight text editor for Windows.
</p>
<p>
<a href="https://www.javacardos.com/tools">JCIDE</a>
is an IDE designed specifically for the Java Card programming language.
</p>
<p>
<a href="http://www.microissuer.com/?p=176">Snooper</a>
is an IDE for the smart card industry.
</p>
<p>
<a href="https://github.com/martinrotter/textilosaurus">Textilosaurus</a>
is simple cross-platform UTF-8 text editor based on Qt and Scintilla.
</p>
<p>
<a href="http://stefanstools.sourceforge.net/BowPad.html">BowPad</a>
is a small and fast text editor with a modern ribbon user interface (Windows7 or later).
</p>
<p>
<a href="http://studio.zerobrane.com">ZeroBrane Studio Lua IDE</a>
is a lightweight Lua IDE with code completion, syntax highlighting, live
coding, remote debugger, and code analyzer (Windows, OSX, and Linux).
</p>
<p>
<a href="http://www.xml-buddy.com/">XML Validator Buddy</a>
is an XML/JSON editor and XML validator for Windows.
</p>
<p>
<a href="http://sciteco.sf.net/">SciTECO</a>
is an advanced TECO dialect and interactive screen editor based on Scintilla.
</p>
<p>
<a href="http://www.qgis.org/">Quantum GIS</a>
is a user friendly Open Source Geographic Information System (GIS).
</p>
<p>
<a href="https://gitorious.org/qgrinui">QGrinUI</a>
searches for a regex within all relevant files in a directory and shows matches using
SciTE through the director interface.
</p>
<p>
<a href="https://orbitalquark.github.io/textadept">Textadept</a>
is a remarkably extensible cross-platform text editor for programmers written (mostly) in
Lua using LPeg to handle the lexers.
</p>
<p>
<a href="https://orbitalquark.github.io/scintillua">Scintillua</a>
is an external Scintilla lexer that uses Lua LPeg lexers for lexing.
</p>
<p>
<a href="http://www.morphos-team.net/releasenotes/3.0">Scribble</a>
is a text editor included in MorphOS.
</p>
<p>
<a href="http://mysqlworkbench.org/">MySQL Workbench</a>
is a cross-platform, visual database design, sql coding and administration tool.
</p>
<p>
<a href="http://liveditor.com/index.php">LIVEditor</a>
is for web front end coders editing html/css/js code.
</p>
<p>
<a href="http://padre.perlide.org/">Padre</a>
is a wxWidgets-based Perl IDE.
</p>
<p>
<a href="http://www.manoscoder.gr/wintools/viewtopic.php?f=20&t=84">CoderStudio</a>
is an IDE for plain C and Assembly programming similar to Visual Studio.
</p>
<p>
<a href="http://www.sparxsystems.com/products/ea/index.html">Enterprise Architect</a>
is a UML 2.1 analysis and design tool.
</p>
<p>
<a href="https://launchpad.net/codeassistor">The CodeAssistor Editor</a>
is a small and simple source code editor for MacOSX, Windows, and GTK/Linux.
</p>
<p>
<a href="http://www.topwizprogramming.com/freecode_pbeditor.html">PBEditor</a>
is a text editor for PowerBuilder.
</p>
<p>
<a href="https://www.cryptool.org/en/">CrypTool</a>
is an application for applying and analyzing cryptographic algorithms.
</p>
<p>
<a href="http://code.google.com/p/fxite/">FXiTe</a>
is an advanced cross-platform text editor built with the Fox GUI toolkit
and the FXScintilla text widget.
</p>
<p>
<a href="http://www.jabaco.org/">Jabaco</a>
is a simple programming language with a Visual Basic like syntax.
</p>
<p>
<a href="http://www.daansystems.com/lispide/">LispIDE</a>
is a basic Lisp editor for Windows 2000, XP and Vista.
</p>
<p>
<a href="https://www.assembla.com/wiki/show/FileWorkbench">File Workbench:</a>
a file manager / text editor environment with Squirrel scripting.
</p>
<p>
<a href="http://kephra.sf.net">Kephra</a>
is a free, easy and comfortable cross-platform editor written in Perl.
</p>
<p>
<a href="http://universalindent.sourceforge.net/">UniversalIndentGUI</a>
is a cross platform GUI for several code formatters, beautifiers and indenters
like GreatCode, AStyle (Artistic Styler), GNU Indent, BCPP and so on.
</p>
<p>
<a href="http://elementaryreports.com/">Elementary Reports</a>
is designed to reduce the time to compose detailed and professional primary school reports.
</p>
<p>
<a href="http://stepaheadsoftware.com/products/vcw/vcw.htm">Visual Classworks</a>
Visual class modeling and coding in C++ via 'live'
UML style class diagrams.
</p>
<p>
<a href="http://stepaheadsoftware.com/products/javelin/javelin.htm">Javelin</a>
Visual Class modeling and coding in Java via 'live' UML style
class diagrams.
</p>
<p>
The <a href="http://www.adobe.com/devnet/bridge.html">ExtendScript Toolkit</a>
is a development and debugging tool for JavaScript
scripts included with Adobe CS3 Suites.
</p>
<p>
<a href="https://tortoisesvn.net/">TortoiseSVN</a>
is a Windows GUI client for the Subversion source control software.
</p>
<p>
<a href="http://www.geany.org/">Geany</a>
is a small and fast GTK2 based IDE, which has only a few dependencies from other packages.
</p>
<p>
<a href="http://www.elliecomputing.com/products/merge_overview.asp">ECMerge</a>
is a commercial graphical and batch diff / merge tool for Windows, Linux and Solaris
(aiming to target all major platforms).
</p>
<p>
<a href="http://pype.sourceforge.net/">PyPE</a>
is an editor written in Python with the wxPython GUI toolkit.
</p>
<p>
<a href="http://home.mweb.co.za/sd/sdonovan/sciboo.html">Sciboo</a>
is an editor based on ScintillaNET.
</p>
<p>
<a href="https://sourceforge.net/projects/tsct/">The Scite Config Tool</a>
is a graphical user interface for changing SciTE properties files.
</p>
<p>
<a href="http://totalcmd.net/plugring/SciLister.html">Scintilla Lister</a>
is a plugin for Total Commander allowing viewing all documents with syntax highlighting
inside Total Commander.
</p>
<p>
<a href="http://chscite.sourceforge.net">ChSciTE</a>
is a free IDE for C/C++ interpreter Ch. It runs cross platform.
Ch is for cross-platform scripting, shell
programming, 2D/3D plotting, numerical computing, and embedded
scripting.
</p>
<p>
<a href="http://codeblocks.org/">
Code::Blocks</a> is an open source, cross platform free C++ IDE.
</p>
<p>
<a href="https://notepad-plus-plus.org/">
Notepad++</a> is a free source code editor under Windows.
</p>
<p>
<a href="http://gubed.mccabe.nu/">
Gubed</a> is a cross platform program to debug PHP scripts.
</p>
<p>
<a href="http://www.lesser-software.com/lswdnl.htm">
LSW DotNet-Lab</a> is a development environment for the .NET platform.
</p>
<p>
<a href="https://github.com/dtrebilco/glintercept">
GLIntercept</a> is an OpenGL function call interceptor that uses SciTE as a
run-time shader editor.
</p>
<p>
<a href="http://wxguide.sourceforge.net/indexedit.html">
wyoEditor</a> is "A nice editor with a well designed and consistent look and feel".
</p>
<p>
<a href="http://www.flos-freeware.ch/notepad2.html">
Notepad2</a> is "Yet another Notepad replacement".
</p>
<p>
<a href="http://pycrash.sourceforge.net/index.php?type=3">
PyCrash Viewer</a> can examine crash dumps of Python programs.
</p>
<p>
<a href="http://www.cabletest.com/en/featured_products_MPT2.aspx">
MPT series Wire Analyzers</a> use Scintilla and SciTE.
</p>
<p>
<a href="http://www.mygenerationsoftware.com">MyGeneration</a>
is a .NET based code generator.
</p>
<p>
<a href="http://cssed.sourceforge.net">CSSED</a>
is a tiny GTK2 CSS editor.
</p>
<p>
<a href="http://wxghostscript.sourceforge.net/">
IdePS</a>
is a free Integrated Development Environment for PostScript
</p>
<p>
<a href="http://cute.sourceforge.net/">
CUTE</a>
is a user-friendly source code editor easily extended using Python.
</p>
<p>
<a href="http://www.spaceblue.com/products/venis/index.html">
Venis IX</a>,
the Visual Environment for NSIS (Nullsoft Scriptable Install System).
</p>
<p>
<a href="http://eric-ide.python-projects.org/">Eric3</a>
is a Python IDE written using PyQt and QScintilla.
</p>
<p>
<a href="http://www.computersciencelab.com/CppIde.htm">CPPIDE</a>
is part of some commercial high-school oriented programming course software.
</p>
<p>
<a href="http://www.blazingtools.com/is.html">Instant Source</a>
is a commercial tool for looking at the HTML on web sites.
</p>
<p>
<a href="http://www.codejoin.com/radon/">RAD.On++</a>
is a free C++ Rapid Application Developer for Win32.
</p>
<p>
<a href="http://wxbasic.sourceforge.net/">wxBasic</a> is an open source
Basic interpreter that uses the wxWidgets toolkit. A small IDE is under construction.
</p>
<p>
<a href="http://visual-mingw.sourceforge.net/">Visual MinGW</a> is an
IDE for the MinGW compiler system.This runs on Windows with gcc.
</p>
<p>
The <a href="http://archaeopteryx.com/">Wing IDE</a> is a
complete integrated development environment for the Python programming
language.
Available on Intel based Linux and Windows and on MacOS X through XDarwin.
</p>
<p>
<a href="http://www.spheredev.org/">Sphere</a>
is 2D RPG engine with a development environment.
</p>
<p>
<a href="http://gaiacrtn.free.fr/practical-ruby/index.html">Practical Ruby</a>
is an IDE for Ruby on Windows.
</p>
<p>
<a href="http://www.gnuenterprise.org/">GNUe</a>
is a suite of tools and applications for solving the needs of the enterprise.
</p>
<p>
<a href="http://silvercity.sourceforge.net/">SilverCity</a>
is a lexing package that can provide lexical analysis for over 20 programming
and markup languages.
</p>
<p>
<a href="http://hapdebugger.sourceforge.net/">HAP Python Remote Debugger</a>
is a Python debugger that can run on one Windows machine debugging a Python program running
on either the same or another machine.
</p>
<p>
<a href="http://sourceforge.net/projects/pycrust/">PyCrust</a> is an interactive
Python shell based on wxPython.
</p>
<p>
<a href="http://www.activestate.com/Products/Komodo/">Komodo</a>
is a cross-platform multi-language development environment built
as an application of Mozilla.
</p>
<p>
<a href="http://llt.chez-alice.fr/">Filerx</a>
is a project manager for SciTE on Windows.
Open source and includes an implementation of SciTE's Director interface so
will be of interest to others wanting to control SciTE.
</p>
<p>
<a href="http://anjuta.org/">Anjuta</a>
is an open source C/C++ IDE for Linux/GNOME.
</p>
<p>
A <a href="https://www.burgaud.com">version of SciTE for Win32</a> enhanced
with a tab control to allow easy movement between buffers.
Go to the "Goodies" area on this site.
</p>
<p>
<a href="http://suneido.com">
Suneido</a> is an integrated application platform currently available for Win32 that includes an
object-oriented language, client-server database, and user interface and reporting frameworks.
</p>
<p>
<a href="http://www.allitis.com/agast/home.html">
Agast</a> is an authoring system for adventure games which includes
a customised version of SciTE.
</p>
<p>
<a href="http://boa-constructor.sourceforge.net/">Boa Constructor</a> is a RAD GUI
Building IDE for the wxWidgets cross platform platform. Written using wxPython with the
wxStyledTextCtrl used as its editor.
</p>
<p>
<a href="https://www.python.org/download/windows/">PythonWin</a>, a Win32 IDE for Python, uses
Scintilla for both its editing and interactive windows.
</p>
<h3>
Editing Components
</h3>
<p>
<a href="https://codemirror.net/">CodeMirror</a>
is a versatile text editor implemented in JavaScript for the browser.
</p>
<p>
<a href="http://www.soft-gems.net/index.php/controls/unicodeeditor-formerly-unicode-syntax-editor">UniCodeEditor</a>
is a Unicode aware syntax editor control for Delphi and C++ Builder.
</p>
<p>
<a href="https://wiki.gnome.org/Projects/GtkSourceView">GtkSourceView</a>
is a text widget that extends the standard GTK+ 2.x text widget and improves it
by implementing syntax highlighting and other features typical of a source editor.
</p>
<p>
<a href="http://aeditor.rubyforge.org/">AEditor</a>
is a free source code editing component implemented in Ruby.
</p>
<p>
<a href="http://www.actiprosoftware.com/products/controls/wpf/syntaxeditor">SyntaxEditor</a>
is a commercial native .Net source code editing component.
</p>
<p>
<a href="http://jedit.sourceforge.net/">jEdit</a> is a good Open Source syntax colouring
editor written in and for Java.
</p>
<p>
<a href="http://www.gtk.org/">GTK+</a>, the GIMP Toolkit, contains a rich text editing
widget.<br />
<a href="https://wiki.gnome.org/Apps/Gedit">Gedit</a> is an editor for GTK+/GNOME.<br />
<!--
<a href="http://www.daimi.au.dk/~mailund/gtk.html">GtkEditor</a> is a source code editing
widget based on the GTK+ text widget.<br />
<a href="http://gide.gdev.net/">gIDE</a> is an IDE based on GTK+.<br />
<a href="http://www.bahnhof.se/~mikeh/linux_software.html">GtkExText</a> is a source code
oriented text widget for GTK+.
-->
</p>
<p>
<a href="http://www.codeguru.com/">CodeGuru</a> has source code for several Win32 MFC based
editors.
</p>
<a href="http://sourceforge.net/projects/synedit/">SynEdit</a> is a Win32 edit control written
in Delphi.
<p>
<a href="http://www.tetradyne.com/srcvwax.htm">SourceView</a> is a commercial editing
component for Win32.
</p>
<h3>
Documents
</h3>
<p>
<a href="http://www.finseth.com/craft/">The Craft of Text Editing</a>
describes how EMACS works, <i>Craig A. Finseth</i>
</p>
<p>
<a href="http://www.cs.cmu.edu/~wjh/papers/byte.html">Data Structures in a Bit-Mapped Text
Editor</a>, <i>Wilfred J. Hanson</i>, Byte January 1987
</p>
<p>
Text Editors: Algorithms and Architectures, <i>Ray Vald&eacute;s</i>, Dr. Dobbs Journal
April 1993
</p>
<p>
Macintosh User Interface Guidelines and TextEdit chapters of Inside Macintosh
</p>
<h3>
Development Tools
</h3>
<p>
Scintilla and SciTE were developed using the
<a href="http://www.mingw.org/">Mingw version of GCC</a>.
</p>
<p>
<a href="http://astyle.sourceforge.net/">AStyle</a> is a source code formatter for C++ and
Java code. SciTE has an Indent command defined for .cxx files that uses AStyle.
</p>
<p>
<a href="http://winmerge.org/">WinMerge</a> is an interactive diff / merge
for Windows. I prefer code submissions in the form of source files rather than diffs and then run
WinMerge over the files to work out how to merge.
</p>
<p>
<a href="https://www.python.org">Python</a> is my favourite programming language. Scintilla
was started after I tried to improve the editor built into <a
href="https://www.python.org/download/windows/">PythonWin</a>, but was frustrated by the limitations of
the Windows Richedit control which PythonWin used.
</p>
<p>
<a href="http://www.cse.yorku.ca/~oz/">regex</a> is a public domain
implementation of regular expression pattern matching used in Scintilla.
</p>
<p>
Inspirational coding soundscapes by <a href="http://www.davidbridie.com/">David Bridie</a>.
</p>
</body>
</html>

140
3rdparty/scintilla550/scintilla/doc/ScintillaToDo.html vendored Normal file
View File

@ -0,0 +1,140 @@
<?xml version="1.0"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta name="generator" content="HTML Tidy, see www.w3.org" />
<meta name="generator" content="SciTE" />
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<style type="text/css">
#menu {
margin: 0;
padding: .5em 0;
list-style-type: none;
font-size: larger;
background: #CCCCCC;
}
#menu li {
margin: 0;
padding: 0 .5em;
display: inline;
}
</style>
<title>
Scintilla and SciTE To Do
</title>
</head>
<body bgcolor="#FFFFFF" text="#000000">
<table bgcolor="#000000" width="100%" cellspacing="0" cellpadding="0" border="0">
<tr>
<td>
<img src="SciTEIco.png" border="3" height="64" width="64" alt="Scintilla icon" />
</td>
<td>
<a href="index.html" style="color:white;text-decoration:none"><font size="5">Scintilla
and SciTE</font></a>
</td>
</tr>
</table>
<ul id="menu">
<li><a href="https://sourceforge.net/p/scintilla/bugs/">Bugs</a></li>
<li><a href="https://sourceforge.net/p/scintilla/feature-requests/">Feature Requests</a></li>
</ul>
<h2>
Bugs and To Do List
</h2>
<h3>
Feedback
</h3>
<p>
Issues can be reported on the <a href="https://sourceforge.net/p/scintilla/bugs/">Bug Tracker</a>
and features requested on the <a href="https://sourceforge.net/p/scintilla/feature-requests/">Feature Request Tracker</a>.
</p>
<h3>
Scintilla To Do
</h3>
<p>
Folding for languages that don't have it yet and good folding for languages
that inherited poor folding from another languages folding code.
</p>
<p>
Simple pattern based styling.
</p>
<p>
Different height lines based upon tallest text on the line rather than on the tallest style
possible.
</p>
<p>
Composition of lexing for mixed languages (such as ASP+ over COBOL) by
combining lexers.
</p>
<p>
Stream folding which could be used to fold up the contents of HTML elements.
</p>
<p>
Printing of highlight lines and folding margin.
</p>
<p>
Flow diagrams inside editor similar to
GRASP.
</p>
<p>
More lexers for other languages.
</p>
<h3>
SciTE To Do
</h3>
<p>
Good regular expression support through a plugin.
</p>
<p>
Allow file name based selection on all properties rather than just a chosen few.
</p>
<p>
Opening from and saving to FTP servers.
</p>
<p>
Setting to fold away comments upon opening.
</p>
<p>
User defined fold ranges.
</p>
<p>
Silent mode that does not display any message boxes.
</p>
<h3>
Features I am unlikely to do
</h3>
<p>
These are features I don't like or don't think are important enough to work on.
Implementations are welcome from others though.
</p>
<p>
Mouse wheel panning (press the mouse wheel and then move the mouse) on
Windows.
</p>
<p>
Adding options to the save dialog to save in a particular encoding or with a
chosen line ending.
</p>
<h3>
Directions
</h3>
<p>
The main point of this development is Scintilla, and this is where most effort will
go. SciTE will get new features, but only when they make my life easier - I am
not intending to make it grow up to be a huge full-function IDE like Visual
Cafe. The lines I've currently decided not to step over in SciTE are any sort of
project facility and any configuration dialogs. SciTE for Windows now has a
Director interface for communicating with a separate project manager
application.
</p>
<p>
If you are interested in contributing code, do not feel any need to make it cross
platform.
Just code it for your platform and I'll either reimplement for the other platform or
ensure that there is no effect on the other platform.
</p>
</body>
</html>

376
3rdparty/scintilla550/scintilla/doc/ScintillaUsage.html vendored Normal file
View File

@ -0,0 +1,376 @@
<?xml version="1.0"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta name="generator" content="HTML Tidy, see www.w3.org" />
<meta name="generator" content="SciTE" />
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>
Scintilla Usage Notes
</title>
<style type="text/css">
SPAN {
font-family: Verdana, Arial, Helvetica;
font-size: 9pt;
}
.S0 {
color: #808080;
font-family: Verdana, Arial, Helvetica;
}
.S1 {
font-family: Comic Sans MS, Times New Roman, Times;
color: #007F00;
font-size: 8pt;
}
.S2 {
font-family: Comic Sans MS, Times New Roman, Times;
color: #007F00;
font-size: 8pt;
}
.S3 {
font-family: Verdana, Arial, Helvetica;
color: #7F7F7F;
}
.S4 {
font-family: Verdana, Arial, Helvetica;
color: #007F7F;
}
.S5 {
color: #00007F;
font-weight: bold;
font-family: Verdana, Arial, Helvetica;
}
.S6 {
color: #7F007F;
font-family: Courier New, Courier;
}
.S7 {
color: #7F007F;
font-family: Courier New, Courier;
}
.S8 {
color: #007F7F;
}
.S9 {
color: #7F7F00;
}
.S10 {
font-weight: bold;
}
</style>
</head>
<body bgcolor="#FFFFFF" text="#000000">
<table bgcolor="#000000" width="100%" cellspacing="0" cellpadding="0" border="0">
<tr>
<td>
<img src="SciTEIco.png" border="3" height="64" width="64" alt="Scintilla icon" />
</td>
<td>
<a href="index.html" style="color:white;text-decoration:none"><font size="5">Scintilla
Usage Notes</font></a>
</td>
</tr>
</table>
<h2>
Implementing Auto-Indent
</h2>
<p>
The key idea is to use the SCN_CHARADDED notification to add indentation after a newline.
</p>
<p>
The lParam on the notification is a pointer to a SCNotification structure whose ch member
specifies the character added. If a newline was added, the previous line can be retrieved and
the same indentation can be added to the new line.
</p>
<p>
Here is the relevant portion of code from SciTE: (SciTE.cxx SciTEWindow::CharAdded)
</p>
<span class='S5'>if</span><span class='S0'>&nbsp;</span> <span class='S10'>(</span><span
class='S11'>ch</span><span class='S0'>&nbsp;</span> <span class='S10'>==</span><span
class='S0'>&nbsp;</span> <span class='S7'>'\r'</span><span class='S0'>&nbsp;</span> <span
class='S10'>||</span><span class='S0'>&nbsp;</span> <span class='S11'>ch</span><span
class='S0'>&nbsp;</span> <span class='S10'>==</span><span class='S0'>&nbsp;</span> <span
class='S7'>'\n'</span><span class='S10'>)</span><span class='S0'>&nbsp;</span> <span
class='S10'>{</span><span class='S0'><br />
&nbsp;&nbsp;&nbsp;&nbsp;</span> <span class='S5'>char</span><span class='S0'>&nbsp;</span>
<span class='S11'>linebuf</span><span class='S10'>[</span><span class='S4'>1000</span><span
class='S10'>];</span><span class='S0'><br />
&nbsp;&nbsp;&nbsp;&nbsp;</span> <span class='S5'>int</span><span class='S0'>&nbsp;</span>
<span class='S11'>curLine</span><span class='S0'>&nbsp;</span> <span class='S10'>=</span><span
class='S0'>&nbsp;</span> <span class='S11'>GetCurrentLineNumber</span><span
class='S10'>();</span><span class='S0'><br />
&nbsp;&nbsp;&nbsp;&nbsp;</span> <span class='S5'>int</span><span class='S0'>&nbsp;</span>
<span class='S11'>lineLength</span><span class='S0'>&nbsp;</span> <span class='S10'>
=</span><span class='S0'>&nbsp;</span> <span class='S11'>SendEditor</span><span
class='S10'>(</span><span class='S11'>SCI_LINELENGTH</span><span class='S10'>,</span><span
class='S0'>&nbsp;</span> <span class='S11'>curLine</span><span class='S10'>);</span><span
class='S0'><br />
&nbsp;&nbsp;&nbsp;&nbsp;</span> <span class='S2'>
//Platform::DebugPrintf("[CR]&nbsp;%d&nbsp;len&nbsp;=&nbsp;%d\n",&nbsp;curLine,&nbsp;lineLength);</span><span
class='S0'><br />
&nbsp;&nbsp;&nbsp;&nbsp;</span> <span class='S5'>if</span><span class='S0'>&nbsp;</span> <span
class='S10'>(</span><span class='S11'>curLine</span><span class='S0'>&nbsp;</span> <span
class='S10'>&gt;</span><span class='S0'>&nbsp;</span> <span class='S4'>0</span><span
class='S0'>&nbsp;</span> <span class='S10'>&amp;&amp;</span><span class='S0'>&nbsp;</span>
<span class='S11'>lineLength</span><span class='S0'>&nbsp;</span> <span class='S10'>
&lt;=</span><span class='S0'>&nbsp;</span> <span class='S4'>2</span><span
class='S10'>)</span><span class='S0'>&nbsp;</span> <span class='S10'>{</span><span
class='S0'><br />
&nbsp;&nbsp;&nbsp;&nbsp;</span> <span class='S5'>int</span><span class='S0'>&nbsp;</span>
<span class='S11'>prevLineLength</span><span class='S0'>&nbsp;</span> <span class='S10'>
=</span><span class='S0'>&nbsp;</span> <span class='S11'>SendEditor</span><span
class='S10'>(</span><span class='S11'>SCI_LINELENGTH</span><span class='S10'>,</span><span
class='S0'>&nbsp;</span> <span class='S11'>curLine</span><span class='S0'>&nbsp;</span> <span
class='S10'>-</span><span class='S0'>&nbsp;</span> <span class='S4'>1</span><span
class='S10'>);</span><span class='S0'><br />
&nbsp;&nbsp;&nbsp;&nbsp;</span> <span class='S5'>if</span><span class='S0'>&nbsp;</span> <span
class='S10'>(</span><span class='S11'>prevLineLength</span><span class='S0'>&nbsp;</span> <span
class='S10'>&lt;</span><span class='S0'>&nbsp;</span> <span class='S5'>sizeof</span><span
class='S10'>(</span><span class='S11'>linebuf</span><span class='S10'>))</span><span
class='S0'>&nbsp;</span> <span class='S10'>{</span><span class='S0'><br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span> <span class='S11'>WORD</span><span
class='S0'>&nbsp;</span> <span class='S11'>buflen</span><span class='S0'>&nbsp;</span> <span
class='S10'>=</span><span class='S0'>&nbsp;</span> <span class='S5'>sizeof</span><span
class='S10'>(</span><span class='S11'>linebuf</span><span class='S10'>);</span><span
class='S0'><br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span> <span class='S11'>memcpy</span><span
class='S10'>(</span><span class='S11'>linebuf</span><span class='S10'>,</span><span
class='S0'>&nbsp;</span> <span class='S10'>&amp;</span><span class='S11'>buflen</span><span
class='S10'>,</span><span class='S0'>&nbsp;</span> <span class='S5'>sizeof</span><span
class='S10'>(</span><span class='S11'>buflen</span><span class='S10'>));</span><span
class='S0'><br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span> <span class='S11'>
SendEditor</span><span class='S10'>(</span><span class='S11'>EM_GETLINE</span><span
class='S10'>,</span><span class='S0'>&nbsp;</span> <span class='S11'>curLine</span><span
class='S0'>&nbsp;</span> <span class='S10'>-</span><span class='S0'>&nbsp;</span> <span
class='S4'>1</span><span class='S10'>,</span><span class='S0'><br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span>
<span class='S5'>reinterpret_cast</span><span class='S10'>&lt;</span><span
class='S11'>LPARAM</span><span class='S10'>&gt;(</span><span class='S5'>static_cast</span><span
class='S10'>&lt;</span><span class='S5'>char</span><span class='S0'>&nbsp;</span> <span
class='S10'>*&gt;(</span><span class='S11'>linebuf</span><span class='S10'>)));</span><span
class='S0'><br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span> <span class='S11'>linebuf</span><span
class='S10'>[</span><span class='S11'>prevLineLength</span><span class='S10'>]</span><span
class='S0'>&nbsp;</span> <span class='S10'>=</span><span class='S0'>&nbsp;</span> <span
class='S7'>'\0'</span><span class='S10'>;</span><span class='S0'><br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span> <span class='S5'>for</span><span
class='S0'>&nbsp;</span> <span class='S10'>(</span><span class='S5'>int</span><span
class='S0'>&nbsp;</span> <span class='S11'>pos</span><span class='S0'>&nbsp;</span> <span
class='S10'>=</span><span class='S0'>&nbsp;</span> <span class='S4'>0</span><span
class='S10'>;</span><span class='S0'>&nbsp;</span> <span class='S11'>linebuf</span><span
class='S10'>[</span><span class='S11'>pos</span><span class='S10'>];</span><span
class='S0'>&nbsp;</span> <span class='S11'>pos</span><span class='S10'>++)</span><span
class='S0'>&nbsp;</span> <span class='S10'>{</span><span class='S0'><br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span> <span
class='S5'>if</span><span class='S0'>&nbsp;</span> <span class='S10'>(</span><span
class='S11'>linebuf</span><span class='S10'>[</span><span class='S11'>pos</span><span
class='S10'>]</span><span class='S0'>&nbsp;</span> <span class='S10'>!=</span><span
class='S0'>&nbsp;</span> <span class='S7'>'&nbsp;'</span><span class='S0'>&nbsp;</span> <span
class='S10'>&amp;&amp;</span><span class='S0'>&nbsp;</span> <span class='S11'>
linebuf</span><span class='S10'>[</span><span class='S11'>pos</span><span
class='S10'>]</span><span class='S0'>&nbsp;</span> <span class='S10'>!=</span><span
class='S0'>&nbsp;</span> <span class='S7'>'\t'</span><span class='S10'>)</span><span
class='S0'><br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span>
<span class='S11'>linebuf</span><span class='S10'>[</span><span class='S11'>pos</span><span
class='S10'>]</span><span class='S0'>&nbsp;</span> <span class='S10'>=</span><span
class='S0'>&nbsp;</span> <span class='S7'>'\0'</span><span class='S10'>;</span><span
class='S0'><br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span> <span class='S10'>}</span><span
class='S0'><br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span> <span class='S11'>
SendEditor</span><span class='S10'>(</span><span class='S11'>EM_REPLACESEL</span><span
class='S10'>,</span><span class='S0'>&nbsp;</span> <span class='S4'>0</span><span
class='S10'>,</span><span class='S0'>&nbsp;</span> <span class='S5'>
reinterpret_cast</span><span class='S10'>&lt;</span><span class='S11'>LPARAM</span><span
class='S10'>&gt;(</span><span class='S5'>static_cast</span><span class='S10'>&lt;</span><span
class='S5'>char</span><span class='S0'>&nbsp;</span> <span class='S10'>*&gt;(</span><span
class='S11'>linebuf</span><span class='S10'>)));</span><span class='S0'><br />
&nbsp;&nbsp;&nbsp;&nbsp;</span> <span class='S10'>}</span><span class='S0'><br />
</span> <span class='S10'>}</span><br />
<p style="margin-bottom: 0in">
Of course, fancier handling could be implemented. For example, if the previous line was the
start of a control construct, the next line could be automatically indented one tab further.
(Assuming that is your indenting style.)
</p>
<h2>
Implementing Syntax Styling
</h2>
<p>
Syntax styling is handled by the SCN_STYLENEEDED notification. Scintilla keeps track of the
end of the styled text - this is retrieved with SCI_GETENDSTYLED. In response to the
SCN_STYLENEEDED notification, you should apply styles to the text from ENDSTYLED to the
position specified by the notification.
</p>
<p>
Here is the relevant portion of code from SciTE: (SciTE.cxx)
</p>
<span class='S5'>void</span><span class='S0'>&nbsp;</span> <span class='S11'>
SciTEWindow</span><span class='S10'>::</span><span class='S11'>Notify</span><span
class='S10'>(</span><span class='S11'>SCNotification</span><span class='S0'>&nbsp;</span> <span
class='S10'>*</span><span class='S11'>notification</span><span class='S10'>)</span><span
class='S0'>&nbsp;</span> <span class='S10'>{</span><span class='S0'><br />
&nbsp;&nbsp;&nbsp;&nbsp;</span> <span class='S5'>switch</span><span class='S0'>&nbsp;</span>
<span class='S10'>(</span><span class='S11'>notification</span><span
class='S10'>-&gt;</span><span class='S11'>nmhdr.code</span><span class='S10'>)</span><span
class='S0'>&nbsp;</span> <span class='S10'>{</span><span class='S0'><br />
&nbsp;&nbsp;&nbsp;&nbsp;</span> <span class='S5'>case</span><span class='S0'>&nbsp;</span>
<span class='S11'>SCN_STYLENEEDED</span><span class='S10'>:</span><span
class='S0'>&nbsp;</span> <span class='S10'>{</span><span class='S0'><br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span> <span
class='S5'>if</span><span class='S0'>&nbsp;</span> <span class='S10'>(</span><span
class='S11'>notification</span><span class='S10'>-&gt;</span><span
class='S11'>nmhdr.idFrom</span><span class='S0'>&nbsp;</span> <span class='S10'>==</span><span
class='S0'>&nbsp;</span> <span class='S11'>IDM_SRCWIN</span><span class='S10'>)</span><span
class='S0'>&nbsp;</span> <span class='S10'>{</span><span class='S0'><br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span>
<span class='S5'>int</span><span class='S0'>&nbsp;</span> <span class='S11'>
endStyled</span><span class='S0'>&nbsp;</span> <span class='S10'>=</span><span
class='S0'>&nbsp;</span> <span class='S11'>SendEditor</span><span class='S10'>(</span><span
class='S11'>SCI_GETENDSTYLED</span><span class='S10'>);</span><span class='S0'><br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span>
<span class='S5'>int</span><span class='S0'>&nbsp;</span> <span class='S11'>
lineEndStyled</span><span class='S0'>&nbsp;</span> <span class='S10'>=</span><span
class='S0'>&nbsp;</span> <span class='S11'>SendEditor</span><span class='S10'>(</span><span
class='S11'>EM_LINEFROMCHAR</span><span class='S10'>,</span><span class='S0'>&nbsp;</span>
<span class='S11'>endStyled</span><span class='S10'>);</span><span class='S0'><br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span>
<span class='S11'>endStyled</span><span class='S0'>&nbsp;</span> <span class='S10'>
=</span><span class='S0'>&nbsp;</span> <span class='S11'>SendEditor</span><span
class='S10'>(</span><span class='S11'>EM_LINEINDEX</span><span class='S10'>,</span><span
class='S0'>&nbsp;</span> <span class='S11'>lineEndStyled</span><span class='S10'>);</span><span
class='S0'><br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span>
<span class='S11'>Colourise</span><span class='S10'>(</span><span
class='S11'>endStyled</span><span class='S10'>,</span><span class='S0'>&nbsp;</span> <span
class='S11'>notification</span><span class='S10'>-&gt;</span><span
class='S11'>position</span><span class='S10'>);</span><br />
<p>
Colourize(start, end) retrieves the specified range of text and then calls ColourizeDoc in
keywords.cxx. It starts the process by calling:
</p>
&nbsp;&nbsp;&nbsp;&nbsp;<span class='S11'>SendMessage</span><span class='S10'>(</span><span
class='S11'>hwnd</span><span class='S10'>,</span><span class='S0'>&nbsp;</span> <span
class='S11'>SCI_STARTSTYLING</span><span class='S10'>,</span><span class='S0'>&nbsp;</span>
<span class='S11'>startPos</span><span class='S10'>,</span><span class='S0'>&nbsp;</span> <span
class='S4'>31</span><span class='S10'>);</span><br />
<p>
and then for each token of the text, calling:
</p>
&nbsp;&nbsp;&nbsp;&nbsp;<span class='S11'>SendMessage</span><span class='S10'>(</span><span
class='S11'>hwnd</span><span class='S10'>,</span><span class='S0'>&nbsp;</span> <span
class='S11'>SCI_SETSTYLING</span><span class='S10'>,</span><span class='S0'>&nbsp;</span> <span
class='S11'>length</span><span class='S10'>,</span><span class='S0'>&nbsp;</span> <span
class='S11'>style</span><span class='S10'>);</span><br />
<p>
where style is a number from 0 to 31 whose appearance has been defined using the
SCI_STYLESET... messages.
</p>
<h2>
Implementing Calltips
</h2>
<p>
Again, the SCN_CHARADDED notification is used to catch when an opening parenthesis is added.
The preceding word can then be retrieved from the current line:
</p>
&nbsp;&nbsp;&nbsp;&nbsp;<span class='S5'>char</span><span class='S0'>&nbsp;</span> <span
class='S11'>linebuf</span><span class='S10'>[</span><span class='S4'>1000</span><span
class='S10'>];</span><span class='S0'><br />
</span> &nbsp;&nbsp;&nbsp;&nbsp;<span class='S5'>int</span><span class='S0'>&nbsp;</span> <span
class='S11'>current</span><span class='S0'>&nbsp;</span> <span class='S10'>=</span><span
class='S0'>&nbsp;</span> <span class='S11'>SendEditor</span><span class='S10'>(</span><span
class='S11'>SCI_GETCURLINE</span><span class='S10'>,</span><span class='S0'>&nbsp;</span> <span
class='S5'>sizeof</span><span class='S10'>(</span><span class='S11'>linebuf</span><span
class='S10'>),</span><span class='S0'><br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span> <span class='S5'>
reinterpret_cast</span><span class='S10'>&lt;</span><span class='S11'>LPARAM</span><span
class='S10'>&gt;(</span><span class='S5'>static_cast</span><span class='S10'>&lt;</span><span
class='S5'>char</span><span class='S0'>&nbsp;</span> <span class='S10'>*&gt;(</span><span
class='S11'>linebuf</span><span class='S10'>)));</span><span class='S0'><br />
</span> &nbsp;&nbsp;&nbsp;&nbsp;<span class='S5'>int</span><span class='S0'>&nbsp;</span> <span
class='S11'>pos</span><span class='S0'>&nbsp;</span> <span class='S10'>=</span><span
class='S0'>&nbsp;</span> <span class='S11'>SendEditor</span><span class='S10'>(</span><span
class='S11'>SCI_GETCURRENTPOS</span><span class='S10'>);</span><span class='S0'><br />
<br />
</span> &nbsp;&nbsp;&nbsp;&nbsp;<span class='S5'>int</span><span class='S0'>&nbsp;</span> <span
class='S11'>startword</span><span class='S0'>&nbsp;</span> <span class='S10'>=</span><span
class='S0'>&nbsp;</span> <span class='S11'>current</span><span class='S0'>&nbsp;</span> <span
class='S10'>-</span><span class='S0'>&nbsp;</span> <span class='S4'>1</span><span
class='S10'>;</span><span class='S0'><br />
</span> &nbsp;&nbsp;&nbsp;&nbsp;<span class='S5'>while</span><span class='S0'>&nbsp;</span>
<span class='S10'>(</span><span class='S11'>startword</span><span class='S0'>&nbsp;</span>
<span class='S10'>&gt;</span><span class='S0'>&nbsp;</span> <span class='S4'>0</span><span
class='S0'>&nbsp;</span> <span class='S10'>&amp;&amp;</span><span class='S0'>&nbsp;</span>
<span class='S11'>isalpha</span><span class='S10'>(</span><span class='S11'>linebuf</span><span
class='S10'>[</span><span class='S11'>startword</span><span class='S0'>&nbsp;</span> <span
class='S10'>-</span><span class='S0'>&nbsp;</span> <span class='S4'>1</span><span
class='S10'>]))</span><span class='S0'><br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span> <span class='S11'>
startword</span><span class='S10'>--;</span><span class='S0'><br />
</span> &nbsp;&nbsp;&nbsp;&nbsp;<span class='S11'>linebuf</span><span class='S10'>[</span><span
class='S11'>current</span><span class='S0'>&nbsp;</span> <span class='S10'>-</span><span
class='S0'>&nbsp;</span> <span class='S4'>1</span><span class='S10'>]</span><span
class='S0'>&nbsp;</span> <span class='S10'>=</span><span class='S0'>&nbsp;</span> <span
class='S7'>'\0'</span><span class='S10'>;</span><span class='S0'><br />
</span> &nbsp;&nbsp;&nbsp;&nbsp;<span class='S5'>char</span><span class='S10'>*</span><span
class='S0'>&nbsp;</span> <span class='S11'>word</span><span class='S0'>&nbsp;</span> <span
class='S10'>=</span><span class='S0'>&nbsp;</span> <span class='S11'>linebuf</span><span
class='S0'>&nbsp;</span> <span class='S10'>+</span><span class='S0'>&nbsp;</span> <span
class='S11'>startword</span><span class='S10'>;</span><br />
<p>
Then if a calltip is available it can be displayed. The calltip appears immediately below
the position specified. The calltip can be multiple lines separated by newlines (\n).
</p>
&nbsp;&nbsp;&nbsp;&nbsp;<span class='S11'>pos</span><span class='S0'>&nbsp;</span> <span
class='S10'>=</span><span class='S0'>&nbsp;</span> <span class='S11'>SendMessage</span><span
class='S10'>(</span><span class='S11'>hwnd</span><span class='S10'>,</span><span
class='S0'>&nbsp;</span> <span class='S11'>SCI_GETCURRENTPOS</span><span
class='S10'>,</span><span class='S0'>&nbsp;</span> <span class='S4'>0</span><span
class='S10'>,</span><span class='S0'>&nbsp;</span> <span class='S4'>0</span><span
class='S10'>);</span><span class='S0'><br />
</span> &nbsp;&nbsp;&nbsp;&nbsp;<span class='S11'>SendMessageText</span><span
class='S10'>(</span><span class='S11'>hwnd</span><span class='S10'>,</span><span
class='S0'>&nbsp;</span> <span class='S11'>SCI_CALLTIPSHOW</span><span
class='S10'>,</span><span class='S0'>&nbsp;</span> <span class='S11'>pos</span><span
class='S0'>&nbsp;</span> <span class='S10'>-</span><span class='S0'>&nbsp;</span> <span
class='S11'>wordLen</span><span class='S0'>&nbsp;</span> <span class='S10'>-</span><span
class='S0'>&nbsp;</span> <span class='S4'>1</span><span class='S10'>,</span><span
class='S0'>&nbsp;</span> <span class='S11'>calltip</span><span class='S10'>);</span><br />
<p>
The calltip can be removed when a closing parenthesis is entered:
</p>
&nbsp;&nbsp;&nbsp;&nbsp;<span class='S5'>if</span><span class='S0'>&nbsp;</span> <span
class='S10'>(</span><span class='S11'>SendMessage</span><span class='S10'>(</span><span
class='S11'>hwnd</span><span class='S10'>,</span><span class='S0'>&nbsp;</span> <span
class='S11'>SCI_CALLTIPACTIVE</span><span class='S10'>,</span><span class='S0'>&nbsp;</span>
<span class='S4'>0</span><span class='S10'>,</span><span class='S0'>&nbsp;</span> <span
class='S4'>0</span><span class='S10'>))</span><span class='S0'><br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span> <span class='S11'>
SendMessage</span><span class='S10'>(</span><span class='S11'>hwnd</span><span
class='S10'>,</span><span class='S0'>&nbsp;</span> <span class='S11'>
SCI_CALLTIPCANCEL</span><span class='S10'>,</span><span class='S0'>&nbsp;</span> <span
class='S4'>0</span><span class='S10'>,</span><span class='S0'>&nbsp;</span> <span class='S4'>
0</span><span class='S10'>);</span><br />
<p>
Obviously, it is up the application to look after supplying the appropriate calltip text.
</p>
<p>
SciTE goes one step further, counting the commas between arguments and highlighting the
corresponding part of the calltip. This code is in ContinueCallTip.
</p>
<p>
<i>Page contributed by Andrew McKinlay.</i>
</p>
</body>
</html>

BIN
3rdparty/scintilla550/scintilla/doc/StadiumVariants.png vendored Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 23 KiB

142
3rdparty/scintilla550/scintilla/doc/Steps.html vendored Normal file
View File

@ -0,0 +1,142 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN" "http://www.w3.org/TR/REC-html40/strict.dtd">
<html><head><meta content="text/html; charset=iso-8859-1" http-equiv="Content-Type"><title>How to use the Scintilla Edit Control in windows?</title></head><body bgcolor="#ffffff">
<p><h2>How to use the Scintilla Edit Control in windows?</h2>
<p>
This should be a little step by step explanation how to use Scintilla in the windows environment.
</p>
</p>
<p><h2>How to create Scintilla Edit Control?</h2>
<p>
First of all, load the Scintilla DLL with something like:
</p>
<pre>
hmod = LoadLibrary(&quot;SciLexer.DLL&quot;);
if (hmod==NULL)
{
MessageBox(hwndParent,
&quot;The Scintilla DLL could not be loaded.&quot;,
&quot;Error loading Scintilla&quot;,
MB_OK | MB_ICONERROR);
}
</pre>
<p>
If the DLL was loaded successfully, then the DLL has registered (yes, by itself) a new
window class. The new class called &quot;Scintilla&quot; is the new scintilla edit control.
</p>
<p>
Now you can use this new control just like any other windows control.
</p>
<pre>
hwndScintilla = CreateWindowEx(0,
&quot;Scintilla&quot;,&quot;&quot;, WS_CHILD | WS_VISIBLE | WS_TABSTOP | WS_CLIPCHILDREN,
10,10,500,400,hwndParent,(HMENU)GuiID, hInstance,NULL);
</pre>
<p>
Note the new window class name: &quot;Scintilla&quot;. By reaching this point you actually included
a Scintilla Edit Control to your windows program.
</p>
</p>
<p><h2>How to control the Scintilla Edit Control?</h2>
<p>
You can control Scintilla by sending commands to the Edit Control.
There a 2 ways of doing this. A simple and fast way.
</p>
<p><h3>The simple way to control Scintilla</h3>
<p>
The simple way is just like with any other windows control. You can send messages to the
Scintilla Edit Control and receive notifications from the control. (Note that the notifications
are sent to the parent window of the Scintilla Edit Control.)
</p>
<p>
The Scintilla Edit Control knows a special message for each command.
To send commands to the Scintilla Edit Control you can use the SendMessage function.
</p>
<pre>
SendMessage(hwndScintilla,sci_command,wparam,lparam);
</pre>
<p>
like:
</p>
<pre>
SendMessage(hwndScintilla,SCI_CREATEDOCUMENT, 0, 0);
</pre>
<p>
Some of the commands will return a value and unused parameters should be set to NULL.
</p>
</p>
<p><h3>The fast way to control Scintilla</h3>
<p>
The fast way of controlling the Scintilla Edit Control is to call message handling function by yourself.
You can retrieve a pointer to the message handling function of the Scintilla Edit Control and
call it directly to execute a command. This way is much more faster than the SendMessage() way.
</p>
<p>
1st you have to use the SCI_GETDIRECTFUNCTION and SCI_GETDIRECTPOINTER commands to
retrieve the pointer to the function and a pointer which must be the first parameter when calling the retrieved
function pointer.
You have to do this with the SendMessage way :)
</p>
<p>
The whole thing has to look like this:
</p>
<pre>
int (*fn)(void*,int,int,int);
void * ptr;
int canundo;
fn = (int (__cdecl *)(void *,int,int,int))SendMessage(
hwndScintilla,SCI_GETDIRECTFUNCTION,0,0);
ptr = (void *)SendMessage(hwndScintilla,SCI_GETDIRECTPOINTER,0,0);
canundo = fn(ptr,SCI_CANUNDO,0,0);
</pre>
<p>
with &quot;fn&quot; as the function pointer to the message handling function of the Scintilla Control
and &quot;ptr&quot; as the pointer that must be used as 1st parameter.
The next parameters are the Scintilla Command with its two (optional) parameters.
</p>
</p>
<p><h3>How will I receive notifications?</h3>
<p>
Whenever an event occurs where Scintilla wants to inform you about something, the Scintilla Edit Control
will send notification to the parent window. This is done by a WM_NOTITY message.
When receiving that message, you have to look in the xxx struct for the actual message.
</p>
<p>
So in Scintillas parent window message handling function you have to include some code like this:
</p>
<pre>
NMHDR *lpnmhdr;
[...]
case WM_NOTIFY:
lpnmhdr = (LPNMHDR) lParam;
if(lpnmhdr-&gt;hwndFrom==hwndScintilla)
{
switch(lpnmhdr-&gt;code)
{
case SCN_CHARADDED:
/* Hey, Scintilla just told me that a new */
/* character was added to the Edit Control.*/
/* Now i do something cool with that char. */
break;
}
}
break;
</pre>
</p>
</p>
<p>
<i>Page contributed by Holger Schmidt.</i>
</p>
</body></html>

204
3rdparty/scintilla550/scintilla/doc/StyleMetadata.html vendored Normal file
View File

@ -0,0 +1,204 @@
<?xml version="1.0"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta name="generator" content="HTML Tidy, see www.w3.org" />
<meta name="generator" content="SciTE" />
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>
Scintilla Style Metadata
</title>
<style type="text/css">
<!--
/*<![CDATA[*/
CODE { font-weight: bold; font-family: Menlo,Consolas,Bitstream Vera Sans Mono,Courier New,monospace; }
/*]]>*/
-->
</style>
</head>
<body bgcolor="#FFFFFF" text="#000000">
<table bgcolor="#000000" width="100%" cellspacing="0" cellpadding="0" border="0">
<tr>
<td>
<img src="SciTEIco.png" border="3" height="64" width="64" alt="Scintilla icon" />
</td>
<td>
<a href="index.html" style="color:white;text-decoration:none"><font size="5">Scintilla</font></a>
</td>
</tr>
</table>
<h2>
Language Types
</h2>
<p>
Scintilla contains lexers for various types of languages:
<ul>
<li>Programming languages like C++, Java, and Python.</li>
<li>Assembler languages are low-level programming languages which may additionally include instructions and registers.</li>
<li>Markup languages like HTML, TeX, and Markdown.</li>
<li>Data languages like EDIFACT and YAML.</li>
</ul>
</p>
<p>
Some languages can be used in different ways. JavaScript is a programming language but also
the basis of JSON data files. Similarly,
<a href="https://en.wikipedia.org/wiki/S-expression">Lisp s expressions</a> can be used for both source code and data.
</p>
<p>
Each language type has common elements such as identifiers in programming languages.
These common elements should be identified so that languages can be displayed with common
styles for these elements.
Style tags are used for this purpose in Scintilla.
</p>
<h2>
Style Tags
</h2>
<p>
Every style has a list of tags where a tag is a lower-case word containing only the common ASCII letters 'a'-'z'
such as "comment" or "operator".
</p>
<p>
Tags are ordered from most important to least important.
</p>
<p>
While applications may assign visual attributes for tag lists in many different ways, one reasonable technique is to
apply tag-specific attributes in reverse order so that earlier and more important tags override less important tags.
For example, the tag list <code>"error comment documentation keyword"</code> with
a set of tag attributes <br />
<code>{ comment=fore:green,back:very-light-green,font:Serif documentation=fore:light-green error=strikethrough keyword=bold }</code><br />
could be rendered as <br />
<code>bold,fore:light-green,back:very-light-green,font:Serif,strikethrough</code>.
</p>
<p>
Alternative renderings could check for multi-tag combinations like
<code>{ comment.documentation=fore:light-green comment.line=dark-green comment=green }.</code>
</p>
<p>
Commonly, a tag list will contain an optional embedded language; optional statuses; a base type; and a set of type modifiers:<br />
<code>embedded-language? status* base-type modifiers*</code>
</p>
<h3>Embedded language</h3>
<p>
The embedded language may be a source <code>(client | server)</code> followed by a language name
<code>(javascript | php | python | basic)</code>.
This may be extended in the future with other programming languages and style-definition languages like CSS.
</p>
<h3>Status</h3>
<p>
The statuses may be <code>(error | unused | predefined | inactive)</code>.<br />
The <code>error</code> status is used for lexical statuses that indicate errors in the source code such as unterminated quoted strings.<br />
The <code>unused</code> status may indicate a gap in the lexical states, possibly because an old lexical class is no longer used or an upcoming lexical class may fill that position.<br />
The <code>predefined</code> status indicates a style in the range 32.39 that is used for non-lexical purposes in Scintilla.<br />
The <code>inactive</code> status is used for text that is not currently interpreted such as C++ code that is contained within a '#if 0' preprocessor block.
</p>
<h3>Basic Types</h3>
<p>
The basic types for programming languages are <code>(default | operator | keyword | identifier | literal | comment | preprocessor | label)</code>.<br />
The <code>default</code> type is commonly used for spaces and tabs between tokens although it may cover other characters in some languages.
</p>
<p>
Assembler languages add <code>(instruction | register)</code>. to the basic types from programming languages.<br />
</p>
<p>
The basic types for markup languages are <code>(default | tag | attribute | comment | preprocessor)</code>.<br />
</p>
<p>
The basic types for data languages are <code>(default | key | data | comment)</code>.<br />
</p>
<h3>Comments</h3>
<p>
Programming languages may differentiate between line and stream comments and treat documentation comments as distinct from other comments.
Documentation comments may be marked up with documentation keywords.<br />
The additional attributes commonly used are <code>(line | documentation | keyword | taskmarker)</code>.
</p>
<h3>Literals</h3>
<p>
Programming and assembler languages contain a rich set of literals including numbers like <code>7</code> and <code>3.89e23</code>; <code>"string\n"</code>; and <code>nullptr</code>
and differentiating between these is often wanted.<br />
The common literal types are <code>(numeric | boolean | string | regex | date | time | uuid | nil | compound)</code>.<br />
Numeric literal types are subdivided into <code>(integer | real)</code>.<br />
String literal types may add (perhaps multiple) further attributes from <code> (heredoc | character | escapesequence | interpolated | multiline | raw)</code>.<br />
</p>
<p>
An escape sequence within an interpolated heredoc may thus be <code>literal string heredoc escapesequence</code>.
</p>
<h3>
List of known tags
</h3>
<table>
<tr><td><code>attribute</code></td><td>Markup attribute</td></tr>
<tr><td><code>basic</code></td><td>Embedded Basic</td></tr>
<tr><td><code>boolean</code></td><td>True or false literal</td></tr>
<tr><td><code>character</code></td><td>Single character literal as opposed to a string literal</td></tr>
<tr><td><code>client</code></td><td>Script executed on client</td></tr>
<tr><td><code>comment</code></td><td>The standard comment type in a language: may be stream or line</td></tr>
<tr><td><code>compound</code></td><td>Literal containing multiple subliterals such as a tuple or complex number</td></tr>
<tr><td><code>data</code></td><td>A value in a data file</td></tr>
<tr><td><code>date</code></td><td>Literal representing a data such as '19/November/1975'</td></tr>
<tr><td><code>default</code></td><td>Starting state commonly also used for white space</td></tr>
<tr><td><code>documentation</code></td><td>Comment that can be extracted into documentation</td></tr>
<tr><td><code>error</code></td><td>State indicating an invalid or erroneous element</td></tr>
<tr><td><code>escapesequence</code></td><td>Parts of a string that are not literal such as '\t' for tab in C</td></tr>
<tr><td><code>heredoc</code></td><td>Lengthy text literal marked by a word at both ends</td></tr>
<tr><td><code>identifier</code></td><td>Name that identifies an object or class of object</td></tr>
<tr><td><code>inactive</code></td><td>Code that is not currently interpreted</td></tr>
<tr><td><code>instruction</code></td><td>Mnemonic in assembler languages like 'addc'</td></tr>
<tr><td><code>integer</code></td><td>Numeric literal with no fraction or exponent like '738'</td></tr>
<tr><td><code>interpolated</code></td><td>String that can contain expressions</td></tr>
<tr><td><code>javascript</code></td><td>Embedded Javascript</td></tr>
<tr><td><code>key</code></td><td>Element which allows finding associated data</td></tr>
<tr><td><code>keyword</code></td><td>Reserved word with special meaning like 'while'</td></tr>
<tr><td><code>label</code></td><td>Destination for jumps in programming and assembler languages</td></tr>
<tr><td><code>line</code></td><td>Differentiates between stream comments and line comments in languages that have both</td></tr>
<tr><td><code>literal</code></td><td>Fixed value in source code</td></tr>
<tr><td><code>multiline</code></td><td>Differentiates between single line and multiline elements, commonly strings</td></tr>
<tr><td><code>nil</code></td><td>Literal for the null pointer such as nullptr in C++ or NULL in C</td></tr>
<tr><td><code>numeric</code></td><td>Literal number like '16'</td></tr>
<tr><td><code>operator</code></td><td>Punctuation character such as '&amp;' or '['</td></tr>
<tr><td><code>php</code></td><td>Embedded PHP</td></tr>
<tr><td><code>predefined</code></td><td>Style in the range 32.39 that is used for non-lexical purposes</td></tr>
<tr><td><code>preprocessor</code></td><td>Element that is recognized in an early stage of translation</td></tr>
<tr><td><code>python</code></td><td>Embedded Python</td></tr>
<tr><td><code>raw</code></td><td>String type that avoids interpretation: may be used for regular expressions in languages without a specific regex type</td></tr>
<tr><td><code>real</code></td><td>Numeric literal which may have a fraction or exponent like '3.84e-15'</td></tr>
<tr><td><code>regex</code></td><td>Regular expression literal like '^[a-z]+'</td></tr>
<tr><td><code>register</code></td><td>CPU register in assembler languages</td></tr>
<tr><td><code>server</code></td><td>Script executed on server</td></tr>
<tr><td><code>string</code></td><td>Sequence of characters</td></tr>
<tr><td><code>tag</code></td><td>Markup tag like '&lt;br /&gt;'</td></tr>
<tr><td><code>taskmarker</code></td><td>Word in comment that marks future work like 'FIXME'</td></tr>
<tr><td><code>time</code></td><td>Literal representing a time such as '9:34:31'</td></tr>
<tr><td><code>unused</code></td><td>Style that is not currently used</td></tr>
<tr><td><code>uuid</code></td><td>Universally unique identifier often used in interface definition files which may look like '{098f2470-bae0-11cd-b579-08002b30bfeb}'</td></tr>
</table>
<h2>
Extension
</h2>
<p>
Each element in this scheme may be extended in the future. This may be done by revising this document to provide a common approach to new features.
Individual lexers may also choose to expose unique language features through new tags.
</p>
<h2>
Translation
</h2>
<p>
Tags could be exposed directly in user interfaces or configuration languages.
However, an application may also translate these to match its naming schema.
Capitalization and punctuation could be different (like <code>Here-Doc</code> instead of <code>heredoc</code>),
terminology changed ("constant" instead of "literal"),
or human language changed from English to Chinese or Spanish.
</p>
<p>
Starting from a common set of tags makes these modifications tractable.
</p>
<h2>
Open issues
</h2>
<p>
The C++ lexer (for example) has inactive states and dynamically allocated substyles.
These should be exposed through the metadata mechanism but are not currently.
</p>
</body>
</html>

BIN
3rdparty/scintilla550/scintilla/doc/annotations.png vendored Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 25 KiB

BIN
3rdparty/scintilla550/scintilla/doc/eolannotation.png vendored Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 21 KiB

196
3rdparty/scintilla550/scintilla/doc/index.html vendored Normal file
View File

@ -0,0 +1,196 @@
<?xml version="1.0"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta name="generator" content="HTML Tidy, see www.w3.org" />
<meta name="generator" content="SciTE" />
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<meta name="keywords" content="Scintilla, SciTE, Editing Component, Text Editor" />
<meta name="Description"
content="www.scintilla.org is the home of the Scintilla editing component and SciTE text editor application." />
<meta name="Date.Modified" content="20240423" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<style type="text/css">
.logo {
background: url(https://www.scintilla.org/ScintillaLogo.png) no-repeat;
background-image: image-set(
url(https://www.scintilla.org/ScintillaLogo.png) 1x,
url(https://www.scintilla.org/ScintillaLogo2x.png) 2x );
height:150px;
}
#versionlist {
margin: 0;
padding: .5em;
list-style-type: none;
color: #FFCC99;
background: #000000;
}
#versionlist li {
margin-bottom: .5em;
}
#menu {
margin: 0;
padding: .5em 0;
list-style-type: none;
font-size: larger;
background: #CCCCCC;
}
#menu li {
margin: 0;
padding: 0 .5em;
display: inline;
}
</style>
<script type="text/javascript">
function IsRemote() {
var loc = '' + window.location;
return (loc.indexOf('http:')) != -1 || (loc.indexOf('https:') != -1);
}
</script>
<title>
Scintilla and SciTE
</title>
</head>
<body bgcolor="#FFFFFF" text="#000000">
<table bgcolor="#000000" width="100%" cellspacing="0" cellpadding="0" border="0">
<tr>
<td width="40%" align="left">
<font color="#FFCC99" size="4"> A free source code editing component for Win32,
GTK, and macOS</font>
</td>
<td width="40%" align="right">
<font color="#FFCC99" size="3"> Release version 5.5.0<br />
Site last modified April 23 2024</font>
</td>
<td width="20%">
&nbsp;
</td>
</tr>
</table>
<table bgcolor="#000000" width="100%" cellspacing="0" cellpadding="0" border="0">
<tr>
<td width="100%" class="logo">
&nbsp;
</td>
</tr>
</table>
<ul id="versionlist">
<li>Version 5.5.0 fixes adds elements for inactive additional selections.</li>
<li>Version 5.4.3 fixes a redo bug.</li>
<li>Version 5.4.2 can save and restore undo history.</li>
<li>Version 5.4.1 adds IDocumentEditable interface to allow efficient interaction with document objects.</li>
<li>Version 5.4.0 fixes crashes on macOS 12 and older when built with Xcode 15.0.</li>
</ul>
<ul id="menu">
<li id="remote1"><a href="https://www.scintilla.org/SciTEImage.html">Screenshot</a></li>
<li id="remote2"><a href="https://www.scintilla.org/ScintillaDownload.html">Download</a></li>
<li><a href="ScintillaDoc.html">Documentation</a></li>
<li><a href="ScintillaToDo.html">Bugs</a></li>
<li id="remote3"><a href="https://www.scintilla.org/Lexilla.html">Lexilla</a></li>
<li id="remote4"><a href="https://www.scintilla.org/SciTE.html">SciTE</a></li>
<li><a href="ScintillaHistory.html">History</a></li>
<li><a href="ScintillaRelated.html">Related</a></li>
<li id="remote5"><a href="https://www.scintilla.org/Privacy.html">Privacy</a></li>
</ul>
<script type="text/javascript" language="JavaScript"><!--
if (!IsRemote()) { //if NOT remote...
document.getElementById('remote1').style.display='none';
document.getElementById('remote2').style.display='none';
document.getElementById('remote3').style.display='none';
document.getElementById('remote4').style.display='none';
document.getElementById('remote5').style.display='none';
}
//--></script>
<p>
<a href="ScintillaDoc.html">Scintilla</a> is a free source code editing component.
It comes with complete source code and a <a href="https://www.scintilla.org/License.txt">license</a> that
permits use in any free project or commercial product.
</p>
<p>
As well as features found in standard text editing components, Scintilla includes features
especially useful when editing and debugging source code.
These include support for syntax styling, error indicators, code completion and call tips.
The selection margin can contain markers like those used in debuggers to indicate
breakpoints and the current line. Styling choices are more open than with many editors,
allowing the use of proportional fonts, bold and italics, multiple foreground and background
colours and multiple fonts.
</p>
<p>
Current development occurs on the default branch as 5.* which requires a recent
C++ compiler that supports C++17.
</p>
<p>
<a href="https://www.scintilla.org/Lexilla.html">Lexilla</a> is a library of lexers that can
be used with Scintilla.
</p>
<p>
<a href="https://www.scintilla.org/SciTE.html">SciTE</a> is a SCIntilla based Text Editor. Originally built to
demonstrate Scintilla, it has grown to be a generally useful editor with facilities for
building and running programs. It is best used for jobs with simple configurations - I use it
for building test and demonstration programs as well as SciTE and Scintilla, themselves.
</p>
<p>
Development of Scintilla started as an effort to improve the text editor in PythonWin. After
being frustrated by problems in the Richedit control used by PythonWin, it looked like the
best way forward was to write a new edit control. The biggest problem with Richedit and other
similar controls is that they treat styling changes as important persistent changes to the
document so they are saved into the undo stack and set the document's dirty flag. For source
code, styling should not be persisted as it can be mechanically recreated.
</p>
<p>
Scintilla and SciTE are currently available for Intel Win32, macOS, and Linux compatible operating
systems with GTK. They have been run on Windows XP, Windows 7, macOS 10.9+, and on Ubuntu 18.04
with GTK 2.24. <a href="https://www.scintilla.org/SciTEImage.html">Here is a screenshot of
SciTE.</a><br />
</p>
<p>
You can <a href="https://www.scintilla.org/ScintillaDownload.html">download Scintilla.</a>
</p>
<p>
The source code can be downloaded via Mercurial at the Source Forge
<a href="https://sourceforge.net/projects/scintilla/">Scintilla project page</a>.
</p>
<p>
<a href="ScintillaRelated.html">Related sites.</a>
</p>
<p>
<a href="ScintillaToDo.html">Bugs and To Do list.</a>
</p>
<p>
<a href="ScintillaHistory.html">History and contribution credits.</a>
</p>
<p>
<a href="https://www.scintilla.org/Icons.html">Icons that can be used with Scintilla.</a>
</p>
<p>
Questions and comments about Scintilla should be directed to the
<a href="https://groups.google.com/forum/#!forum/scintilla-interest">scintilla-interest</a>
mailing list,
which is for discussion of Scintilla and related projects, their bugs and future features.
This is a low traffic list, averaging less than 20 messages per week.
To avoid spam, only list members can write to the list.
New versions of Scintilla are announced on scintilla-interest and may also be received by SourceForge
members by clicking on the Monitor column icon for "scintilla" on
<a href="https://sourceforge.net/project/showfiles.php?group_id=2439">the downloads page</a>.
<br />
</p>
There is a <a href="https://sourceforge.net/projects/scintilla/">Scintilla project page</a>
hosted on
<script type="text/javascript" language="JavaScript">
<!--
if (IsRemote()) {
document.write('<a href="https://sourceforge.net/projects/scintilla/">');
document.write('<img src="https://sflogo.sourceforge.net/sflogo.php?group_id=2439&amp;type=8" width="80" height="15" alt="Get Scintilla at SourceForge.net. Fast, secure and Free Open Source software downloads" /></a> ');
} else {
document.write('<a href="https://sourceforge.net/projects/scintilla/">SourceForge<\/a>');
}
//-->
</script>
<noscript>
<a href="https://sourceforge.net/projects/scintilla/">
<img src="https://sflogo.sourceforge.net/sflogo.php?group_id=2439&amp;type=8" width="80" height="15" alt="Get Scintilla at SourceForge.net. Fast, secure and Free Open Source software downloads" /></a>
</noscript>
</body>
</html>

BIN
3rdparty/scintilla550/scintilla/doc/styledmargin.png vendored Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 14 KiB