noham/archived-Reclass
1
0
Fork 0
mirror of https://github.com/NohamR/Reclass.git synced 2026-05-10 19:59:21 +00:00
Code Issues Packages Projects Releases Wiki Activity

Convert QScintilla to git submodule

Browse Source 
Replace vendored QScintilla source files with a submodule pointing to
https://github.com/brCreate/QScintilla.git. Removes 765 tracked files
from the repo in favor of the submodule reference.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
sysadmin
2026-02-06 06:55:28 -07:00
parent 44e4d88f58
commit e1dc53d84d
767 changed files with 4 additions and 467822 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
.gitmodules vendored Normal file
View File

@@ -0,0 +1,3 @@
[submodule "third_party/qscintilla"]
path = third_party/qscintilla
url = https://github.com/brCreate/QScintilla.git

1
third_party/qscintilla vendored Submodule

Submodule third_party/qscintilla added at 6608e9a434

6853
third_party/qscintilla/ChangeLog vendored
View File

File diff suppressed because it is too large Load Diff

674
third_party/qscintilla/LICENSE vendored
View File

@@ -1,674 +0,0 @@
GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The GNU General Public License is a free, copyleft license for
software and other kinds of works.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users. We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors. You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.
To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights. Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received. You must make sure that they, too, receive
or can get the source code. And you must show them these terms so they
know their rights.
Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.
For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software. For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.
Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so. This is fundamentally incompatible with the aim of
protecting users' freedom to change the software. The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable. Therefore, we
have designed this version of the GPL to prohibit the practice for those
products. If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.
Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary. To prevent this, the GPL assures that
patents cannot be used to render the program non-free.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU General Public License.
"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy. The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
1. Source Code.
The "source code" for a work means the preferred form of the work
for making modifications to it. "Object code" means any non-source
form of a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
The Corresponding Source for a work in source code form is that
same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force. You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright. Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under
the conditions stated below. Sublicensing is not allowed; section 10
makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
b) The work must carry prominent notices stating that it is
released under this License and any conditions added under section
7. This requirement modifies the requirement in section 4 to
"keep intact all notices".
c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided
you inform other peers where the object code and Corresponding
Source of the work are being offered to the general public at no
charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling. In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage. For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product. A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source. The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed. Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or
requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or
authors of the material; or
e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions of
it) with contractual assumptions of liability to the recipient, for
any liability that these contractual assumptions directly impose on
those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term. If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or
run a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all. For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
13. Use with the GNU Affero General Public License.
Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work. The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation. If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.
If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Also add information on how to contact you by electronic and paper mail.
If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:
<program> Copyright (C) <year> <name of author>
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
<http://www.gnu.org/licenses/>.
The GNU General Public License does not permit incorporating your program
into proprietary programs. If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with
the library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License. But first, please read
<http://www.gnu.org/philosophy/why-not-lgpl.html>.

604
third_party/qscintilla/NEWS vendored
View File

@@ -1,604 +0,0 @@
v2.14.1 7th June 2023
- Bug fixes.
v2.14.0 24th April 2023
- Added the QsciLexerAsm, QsciLexerMASM and QsciLexerNASM classes.
- Added the QsciLexerHex, QsciLexerIntelHex, QsciLexerSRec and
QsciLexerTekHex classes.
- Bug fixes.
v2.13.4 6th December 2022
- Added the .api files for Python v3.10 and v3.11.
- Bug fixes.
v2.13.3 25th April 2022
- Bug fixes.
v2.13.2 15th March 2022
- Bug fixes that only affect iOS.
v2.13.1 12th October 2021
- Documented how to build for multiple architectures on macOS.
- Bug fixes.
v2.13.0 13th June 2021
- Added the QsciPrinter::printRange() overload that uses a supplied QPainter
to render the pages.
- Improved the appearence of the auto-completion popup.
- Bug fixes.
v2.12.1 4th March 2021
- Packaging bug fixes.
v2.12.0 23rd February 2021
- Added support for Qt6.
- Removed support for Qt4 and Qt5 earlier than v5.11.0.
- sdists are now provided.
v2.11.6 23rd November 2020
- Added the --qsci-translations-dir option to sip-wheel.
- Added the .api file for Python v3.9.
- Build system changes.
- Bug fixes.
v2.11.5 10th June 2020
- The bundled .api files are now included in Python wheels if the
QScintilla.api file is enabled.
- Bug fixes.
v2.11.4 19th December 2019
- An administrative release with no code changes.
v2.11.3 3rd November 2019
- Added support for SIP v5.
- On macOS the install name of the C++ library is now relative to @rpath.
v2.11.2 26th June 2019
- Added QsciScintilla::findMatchingBrace().
- QsciScintiila::clear() is no longer undoable and instead clears the undo
history.
- Added support for building with WASM.
- Added the .api file for Python v3.8.
- Bug fixes.
v2.11.1 14th February 2019
- There is a small (but potentially incompatible) change to the signature of
a QsciScintillaBase::SendScintilla() overload which may require an explicit
cast to be added.
- Bug fixes.
v2.11 10th February 2019
- Based on Scintilla v3.10.1.
- Added setCaretLineFrameWidth() to QsciScintilla.
- The findFirst() and findFirstInSelection() methods of QsciScintilla now
support Cxx11 regular expressions.
- Added cancelFind() to QsciScintilla.
- Added GradientIndicator and CentreGradientIndicator to
QsciScintilla::IndicatorStyle.
- Added WrapIndentDeeplyIndented to QsciScintilla::WrapIndentMode.
- Added ReverseLines to QsciCommand::Command.
- Deprecated QsciLexer::styleBitsNeeded().
- Added the AddingPatchAdded, RemovingPatchAdded, AddingPatchRemoved and
RemovingPatchRemoved styles to QsciLexerDiff.
- Added the DoubleQuotedFString, SingleQuotedFString,
TripleSingleQuotedFString and TripleDoubleQuotedFString styles to
QsciLexerPython.
- Added SCLEX_INDENT, SCLEX_MAXIMA and SCLEX_STATA to QsciScintillaBase.
- Added SCI_SETACCESSIBILITY, SCI_GETACCESSIBILITY, SCI_GETCARETLINEFRAME,
SCI_SETCARETLINEFRAME, SCI_SETCOMMANDEVENTS, SCI_GETCOMMANDEVENTS,
SCI_LINEREVERSE and SCI_GETMOVEEXTENDSSELECTION to QsciScintillaBase.
- Added SCI_GETLINECHARACTERINDEX, SCI_ALLOCATELINECHARACTERINDEX,
SCI_RELEASELINECHARACTERINDEX, SCI_LINEFROMINDEXPOSITION,
SCI_INDEXPOSITIONFROMLINE, SCI_COUNTCODEUNITS and
SCI_POSITIONRELATIVECODEUNITS to QsciScintillaBase.
- Added SC_LINECHARACTERINDEX_NONE, SC_LINECHARACTERINDEX_UTF32 and
SC_LINECHARACTERINDEX_UTF16 to QsciScintillaBase.
- Added SCI_GETNAMEDSTYLES, SCI_NAMEOFSTYLE, SCI_TAGSOFSTYLE and
SCI_DESCRIPTIONOFSTYLE to QsciScintillaBase.
- Added the SCN_AUTOCSELECTIONCHANGE and SCN_URIDROPPED() signals to
QsciScintillaBase.
- Added the overloaded SCN_USERLISTSELECTION() signal to QsciScintillaBase.
- Added INDIC_GRADIENT and INDIC_GRADIENTCENTRE to QsciScintillaBase.
- Added SC_PRINT_SCREENCOLOURS to QsciScintillaBase.
- Added SC_WRAPINDENT_DEEPINDENT to QsciScintillaBase.
- Added SCI_GETDOCUMENTOPTIONS, SC_DOCUMENTOPTION_DEFAULT,
SC_DOCUMENTOPTION_STYLES_NONE and SC_DOCUMENTOPTION_TEXT_LARGE to
QsciScintillaBase.
v2.10.8 1st October 2018
- Bug fixes.
v2.10.7 2nd July 2018
- Bug fixes.
v2.10.6 24th June 2018
- A pseudo-release to create a version number for updated Python wheels.
v2.10.5 23rd June 2018
- Added the QsciLexerEDIFACT class.
- Added setStyle() to QsciStyle.
- Control-wheel scroll will now zoom in and out of the document.
- Buffered drawing is now disabled by default.
- The Python bindings create a PEP 376 .dist-info directory on installation
that provides version information for dependent packages and allows pip to
uninstall.
- Added the --no-dist-info option to the Python bindings' configure.py.
- Bug fixes.
v2.10.4 10th April 2018
- Bug fixes.
v2.10.3 26th February 2018
- Added accessibility support.
- Added the API file for Python v3.7.
v2.10.2 23rd November 2017
- Added setScrollWidth() , scrollWidth, setScrollWidthTracking() and
scrollWidthTracking() to QsciScintilla.
- Bug fixes.
v2.10.1 3rd July 2017
- Changed the default font on macOS to Menlo 12pt.
- Added previously internal lexer methods to the Python bindings.
v2.10 20th February 2017
- Based on Scintilla v3.7.2.
- Added the QsciLexerJSON class.
- Added the QsciLexerMarkdown class.
- Added replaceHorizontalScrollBar() and replaceVerticalScrollBar() to
QsciScintillaBase.
- Added bytes() and a corresponding text() overload to QsciScintilla.
- Added EdgeMultipleLines to QsciScintilla::EdgeMode.
- Added addEdgeColumn() and clearEdgeColumns() to QsciScintilla.
- Added the marginRightClicked() signal to QsciScintilla.
- Added SymbolMarginColor to QsciScintilla::MarginType.
- Added setMarginBackgroundColor() and marginBackgroundColor() to
QsciScintilla.
- Added setMargins() and margins() to QsciScintilla.
- Added TriangleIndicator and TriangleCharacterIndicator to
QsciScintilla::IndicatorStyle.
- Added WsVisibleOnlyInIndent to QsciScintilla::WhitespaceVisibility.
- Added TabDrawMode, setTabDrawMode() and tabDrawMode() to QsciScintilla.
- Added InstanceProperty to QsciLexerCoffeeScript.
- Added EDGE_MULTILINE to QsciScintillaBase.
- Added INDIC_POINT and INDIC_POINTCHARACTER to QsciScintillaBase.
- Added SC_AC_FILLUP, SC_AC_DOUBLECLICK, SC_AC_TAB, SC_AC_NEWLINE and
SC_AC_COMMAND to QsciScintillaBase.
- Added SC_CASE_CAMEL to QsciScintillaBase.
- Added SC_CHARSET_CYRILLIC and SC_CHARSET_OEM866 to QsciScintillaBase.
- Added SC_FOLDDISPLAYTEXT_HIDDEN, SC_FOLDDISPLAYTEXT_STANDARD and
SC_FOLDDISPLAYTEXT_BOXED to QsciScintillaBase.
- Added SC_IDLESTYLING_NONE, SC_IDLESTYLING_TOVISIBLE,
SC_IDLESTYLING_AFTERVISIBLE and SC_IDLESTYLING_ALL to QsciScintillaBase.
- Added SC_MARGIN_COLOUR to QsciScintillaBase.
- Added SC_POPUP_NEVER, SC_POPUP_ALL and SC_POPUP_TEXT to QsciScintillaBase.
- Added SCI_FOLDDISPLAYTEXTSETSTYLE and SCI_TOGGLEFOLDSHOWTEXT to
QsciScintillaBase.
- Added SCI_GETIDLESTYLING and SCI_SETIDLESTYLING to QsciScintillaBase.
- Added SCI_GETMARGINBACKN and SCI_SETMARGINBACKN to QsciScintillaBase.
- Added SCI_GETMARGINS and SCI_SETMARGINS to QsciScintillaBase.
- Added SCI_GETMOUSEWHEELCAPTURES and SCI_SETMOUSEWHEELCAPTURES to
QsciScintillaBase.
- Added SCI_GETTABDRAWMODE and SCI_SETTABDRAWMODE to QsciScintillaBase.
- Added SCI_ISRANGEWORD to QsciScintillaBase.
- Added SCI_MULTIEDGEADDLINE and SCI_MULTIEDGECLEARALL to QsciScintillaBase.
- Added SCI_MULTIPLESELECTADDNEXT and SCI_MULTIPLESELECTADDEACH to
QsciScintillaBase.
- Added SCI_TARGETWHOLEDOCUMENT to QsciScintillaBase.
- Added SCLEX_JSON and SCLEX_EDIFACT to QsciScintillaBase.
- Added SCTD_LONGARROW and SCTD_STRIKEOUT to QsciScintillaBase.
- Added SCVS_NOWRAPLINESTART to QsciScintillaBase.
- Added SCWS_VISIBLEONLYININDENT to QsciScintillaBase.
- Added STYLE_FOLDDISPLAYTEXT to QsciScintillaBase.
- Added the SCN_AUTOCCOMPLETED() signal to QsciScintillaBase.
- Added the overloaded SCN_AUTOCSELECTION() and SCN_USERLISTSELECTION()
signals to QsciScintillaBase.
- Added the SCN_MARGINRIGHTCLICK() signal to QsciScintillaBase.
- Renamed SCI_GETTARGETRANGE to SCI_GETTARGETTEXT in QsciScintillaBase.
- Removed SCI_GETKEYSUNICODE and SCI_SETKEYSUNICODE to QsciScintillaBase.
- The autoCompletionFillups(), autoCompletionWordSeparators(), blockEnd(),
blockLookback(), blockStart(), blockStartKeyword(), braceStyle(),
caseSensitive(), indentationGuideView() and defaultStyle() methods of
QsciLexer are no longer marked as internal and are exposed to Python so
that they may be used by QsciLexerCustom sub-classes.
- The name of the library has been changed to include the major version
number of the version of Qt it is built against (ie. 4 or 5).
v2.9.4 25th December 2016
- Added the .api file for Python v3.6.
- Bug fixes.
v2.9.3 25th July 2016
- Bug fixes.
v2.9.2 18th April 2016
- Added support for a PEP 484 stub file for the Python extension module.
v2.9.1 24th October 2015
- Added the .api file for Python v3.5.
- Bug fixes.
v2.9 20th April 2015
- Based on Scintilla v3.5.4.
- Added UserLiteral, InactiveUserLiteral, TaskMarker, InactiveTaskMarker,
EscapeSequence, InactiveEscapeSequence, setHighlightBackQuotedStrings(),
highlightBackQuotedStrings(), setHighlightEscapeSequences(),
highlightEscapeSequences(), setVerbatimStringEscapeSequencesAllowed() and
verbatimStringEscapeSequencesAllowed() to QsciLexerCPP.
- Added CommentKeyword, DeclareInputPort, DeclareOutputPort,
DeclareInputOutputPort, PortConnection and the inactive versions of all
styles to QsciLexerVerilog.
- Added CommentBlock to QsciLexerVHDL.
- Added AnnotationIndented to QsciScintilla::AnnotationDisplay.
- Added FullBoxIndicator, ThickCompositionIndicator, ThinCompositionIndicator
and TextColorIndicator to QsciScintilla::IndicatorStyle.
- Added setIndicatorHoverForegroundColor() and setIndicatorHoverStyle() to
QsciScintilla.
- Added Bookmark to QsciScintilla::MarkerSymbol.
- Added WrapWhitespace to QsciScintilla::WrapMode.
- Added SCLEX_AS, SCLEX_BIBTEX, SCLEX_DMAP, SCLEX_DMIS, SCLEX_IHEX,
SCLEX_REGISTRY, SCLEX_SREC and SCLEX_TEHEX to QsciScintillaBase.
- Added SCI_CHANGEINSERTION to QsciScintillaBase.
- Added SCI_CLEARTABSTOPS, SCI_ADDTABSTOP and SCI_GETNEXTTABSTOP to
QsciScintillaBase.
- Added SCI_GETIMEINTERACTION, SCI_SETIMEINTERACTION, SC_IME_WINDOWED and
SC_IME_INLINE to QsciScintillaBase.
- Added SC_MARK_BOOKMARK to QsciScintillaBase.
- Added INDIC_COMPOSITIONTHIN, INDIC_FULLBOX, INDIC_TEXTFORE, INDIC_IME,
INDIC_IME_MAX, SC_INDICVALUEBIT, SC_INDICVALUEMASK,
SC_INDICFLAG_VALUEBEFORE, SCI_INDICSETHOVERSTYLE, SCI_INDICGETHOVERSTYLE,
SCI_INDICSETHOVERFORE, SCI_INDICGETHOVERFORE, SCI_INDICSETFLAGS and
SCI_INDICGETFLAGS to QsciScintillaBase.
- Added SCI_SETTARGETRANGE and SCI_GETTARGETRANGE to QsciScintillaBase.
- Added SCFIND_CXX11REGEX to QsciScintillaBase.
- Added SCI_CALLTIPSETPOSSTART to QsciScintillaBase.
- Added SC_FOLDFLAG_LINESTATE to QsciScintillaBase.
- Added SC_WRAP_WHITESPACE to QsciScintillaBase.
- Added SC_PHASES_ONE, SC_PHASES_TWO, SC_PHASES_MULTIPLE, SCI_GETPHASESDRAW
and SCI_SETPHASESDRAW to QsciScintillaBase.
- Added SC_STATUS_OK, SC_STATUS_FAILURE, SC_STATUS_BADALLOC,
SC_STATUS_WARN_START and SC_STATUS_WARNREGEX to QsciScintillaBase.
- Added SC_MULTIAUTOC_ONCE, SC_MULTIAUTOC_EACH, SCI_AUTOCSETMULTI and
SCI_AUTOCGETMULTI to QsciScintillaBase.
- Added ANNOTATION_INDENTED to QsciScintillaBase.
- Added SCI_DROPSELECTIONN to QsciScintillaBase.
- Added SC_TECHNOLOGY_DIRECTWRITERETAIN and SC_TECHNOLOGY_DIRECTWRITEDC to
QsciScintillaBase.
- Added SC_LINE_END_TYPE_DEFAULT, SC_LINE_END_TYPE_UNICODE,
SCI_GETLINEENDTYPESSUPPORTED, SCI_SETLINEENDTYPESALLOWED,
SCI_GETLINEENDTYPESALLOWED and SCI_GETLINEENDTYPESACTIVE to
QsciScintillaBase.
- Added SCI_ALLOCATESUBSTYLES, SCI_GETSUBSTYLESSTART, SCI_GETSUBSTYLESLENGTH,
SCI_GETSTYLEFROMSUBSTYLE, SCI_GETPRIMARYSTYLEFROMSTYLE, SCI_FREESUBSTYLES,
SCI_SETIDENTIFIERS, SCI_DISTANCETOSECONDARYSTYLES and SCI_GETSUBSTYLEBASES
to QsciScintillaBase.
- Added SC_MOD_INSERTCHECK and SC_MOD_CHANGETABSTOPS to QsciScintillaBase.
- Qt v3 and PyQt v3 are no longer supported.
v2.8.4 11th September 2014
- Added setHotspotForegroundColor(), resetHotspotForegroundColor(),
setHotspotBackgroundColor(), resetHotspotBackgroundColor(),
setHotspotUnderline() and setHotspotWrap() to QsciScintilla.
- Added SCI_SETHOTSPOTSINGLELINE to QsciScintillaBase.
- Bug fixes.
v2.8.3 3rd July 2014
- Added the QsciLexerCoffeeScript class.
- Font sizes are now handled as floating point values rather than integers.
- Bug fixes.
v2.8.2 26th May 2014
- Added the QsciLexerAVS class.
- Added the QsciLexerPO class.
- Added the --sysroot, --no-sip-files and --no-qsci-api options to the Python
bindings' configure.py.
- Cross-compilation (specifically to iOS and Android) is now supported.
- configure.py has been refactored and relicensed so that it can be used as a
template for wrapping other bindings.
- Bug fixes.
v2.8.1 14th March 2014
- Added support for iOS and Android.
- Added support for retina displays.
- A qscintilla2.prf file is installed so that application .pro files only
need to add CONFIG += qscintilla2.
- Updated the keywords recognised by the Octave lexer.
- Bug fixes.
v2.8 9th November 2013
- Based on Scintilla v3.3.6.
- Added the SCN_FOCUSIN() and SCN_FOCUSOUT() signals to QsciScintillaBase.
- Added PreProcessorCommentLineDoc and InactivePreProcessorCommentLineDoc to
QsciLexerCPP.
- Added SCLEX_LITERATEHASKELL, SCLEX_KVIRC, SCLEX_RUST and SCLEX_STTXT to
QsciScintillaBase.
- Added ThickCompositionIndicator to QsciScintilla::IndicatorStyle.
- Added INDIC_COMPOSITIONTHICK to QsciScintillaBase.
- Added SC_FOLDACTION_CONTRACT, SC_FOLDACTION_EXPAND and SC_FOLDACTION_TOGGLE
to QsciScintillaBase.
- Added SCI_FOLDLINE, SCI_FOLDCHILDREN, SCI_EXPANDCHILDREN and SCI_FOLDALL to
QsciScintillaBase.
- Added SC_AUTOMATICFOLD_SHOW, SC_AUTOMATICFOLD_CLICK and
SC_AUTOMATICFOLD_CHANGE to QsciScintillaBase.
- Added SCI_SETAUTOMATICFOLD and SCI_GETAUTOMATICFOLD to QsciScintillaBase.
- Added SC_ORDER_PRESORTED, SC_ORDER_PERFORMSORT and SC_ORDER_CUSTOM to
QsciScintillaBase.
- Added SCI_AUTOCSETORDER and SCI_AUTOCGETORDER to QsciScintillaBase.
- Added SCI_POSITIONRELATIVE to QsciScintillaBase.
- Added SCI_RELEASEALLEXTENDEDSTYLES and SCI_ALLOCATEEXTENDEDSTYLES to
QsciScintillaBase.
- Added SCI_SCROLLRANGE to QsciScintillaBase.
- Added SCI_SETCARETLINEVISIBLEALWAYS and SCI_GETCARETLINEVISIBLEALWAYS to
QsciScintillaBase.
- Added SCI_SETMOUSESELECTIONRECTANGULARSWITCH and
SCI_GETMOUSESELECTIONRECTANGULARSWITCH to QsciScintillaBase.
- Added SCI_SETREPRESENTATION, SCI_GETREPRESENTATION and
SCI_CLEARREPRESENTATION to QsciScintillaBase.
- Input methods are now properly supported.
v2.7.2 16th June 2013
- The build script for the Python bindings now has a --pyqt argument for
specifying PyQt4 or PyQt5.
- The default EOL mode on OS/X is now EolUnix.
- Bug fixes.
v2.7.1 1st March 2013
- Added support for the final release of Qt v5.
- The build script for the Python bindings should now work with SIP v5.
- Bug fixes.
v2.7 8th December 2012
- Based on Scintilla v3.2.3.
- Added support for Qt v5-rc1.
- Added HashQuotedString, InactiveHashQuotedString, PreProcessorComment,
InactivePreProcessorComment, setHighlightHashQuotedStrings() and
highlightHashQuotedStrings() to QsciLexerCpp.
- Added Variable, setHSSLanguage(), HSSLanguage(), setLessLanguage(),
LessLanguage(), setSCCSLanguage() and SCCSLanguage() to QsciLexerCSS.
- Added setOverwriteMode() and overwriteMode() to QsciScintilla.
- Added wordAtLineIndex() to QsciScintilla.
- Added findFirstInSelection() to QsciScintilla.
- Added CallTipsPosition, callTipsPosition() and setCallTipsPosition() to
QsciScintilla.
- Added WrapFlagInMargin to QsciScintilla::WrapVisualFlag.
- Added SquigglePixmapIndicator to QsciScintilla::IndicatorStyle.
- The weight of a font (rather than whether it is just bold or not) is now
respected.
- Added SCLEX_AVS, SCLEX_COFFEESCRIPT, SCLEX_ECL, SCLEX_OSCRIPT,
SCLEX_TCMD and SCLEX_VISUALPROLOG to QsciScintillaBase.
- Added SC_CASEINSENSITIVEBEHAVIOUR_IGNORECASE and
SC_CASEINSENSITIVEBEHAVIOUR_RESPECTCASE to QsciScintillaBase.
- Added SC_FONT_SIZE_MULTIPLIER to QsciScintillaBase.
- Added SC_WEIGHT_NORMAL, SC_WEIGHT_SEMIBOLD and SC_WEIGHT_BOLD to
QsciScintillaBase.
- Added SC_WRAPVISUALFLAG_MARGIN to QsciScintillaBase.
- Added INDIC_SQUIGGLEPIXMAP to QsciScintillaBase.
- Added SCI_AUTOCSETCASEINSENSITIVEBEHAVIOUR,
SCI_AUTOCGETCASEINSENSITIVEBEHAVIOUR, SCI_CALLTIPSETPOSITION,
SCI_COUNTCHARACTERS, SCI_CREATELOADER, SCI_DELETERANGE,
SCI_FINDINDICATORFLASH, SCI_FINDINDICATORHIDE, SCI_FINDINDICATORSHOW,
SCI_GETALLLINESVISIBLE, SCI_GETGAPPOSITION, SCI_GETPUNCTUATIONCHARS,
SCI_GETRANGEPOINTER, SCI_GETSELECTIONEMPTY, SCI_GETTECHNOLOGY,
SCI_GETWHITESPACECHARS, SCI_GETWORDCHARS, SCI_RGBAIMAGESETSCALE,
SCI_SETPUNCTUATIONCHARS, SCI_SETTECHNOLOGY, SCI_STYLESETSIZEFRACTIONAL,
SCI_STYLEGETSIZEFRACTIONAL, SCI_STYLESETWEIGHT and SCI_STYLEGETWEIGHT to
QsciScintillaBase.
- Removed SCI_GETUSEPALETTE and SCI_SETUSEPALETTE from QsciScintillaBase.
- Bug fixes.
v2.6.2 20th June 2012
- Added support for Qt v5-alpha.
- QsciLexer::wordCharacters() is now part of the public API.
- Bug fixes.
v2.6.1 10th February 2012
- Support SCI_NAMESPACE to enable all internal Scintilla classes to be put
into the Scintilla namespace.
- APIs now allow for spaces between the end of a word and the opening
parenthesis.
- Building against Qt v3 is fixed.
v2.6 11th November 2011
- Based on Scintilla v2.29.
- Added Command, command() and execute() to QsciCommand.
- Added boundTo() and find() to QsciCommandSet.
- Added createStandardContextMenu() to QsciScintilla.
- Added StraightBoxIndicator, DashesIndicator, DotsIndicator,
SquiggleLowIndicator and DotBoxIndicator to QsciScintilla::IndicatorStyle.
- Added markerDefine() to QsciScintilla.
- Added MoNone, MoSublineSelect, marginOptions() and setMarginOptions() to
QsciScintilla.
- Added registerImage() to QsciScintilla.
- Added setIndicatorOutlineColor() to QsciScintilla.
- Added setMatchedBraceIndicator(), resetMatchedBraceIndicator(),
setUnmatchedBraceIndicator() and resetUnmatchedBraceIndicator() to
QsciScintilla.
- Added highlightTripleQuotedStrings() and setHighlightTripleQuotedStrings()
to QsciLexerCpp.
- Added Label to QsciLexerLua.
- Added DoubleQuotedStringVar, Translation, RegexVar, SubstitutionVar,
BackticksVar, DoubleQuotedHereDocumentVar, BacktickHereDocumentVar,
QuotedStringQQVar, QuotedStringQXVar, QuotedStringQRVar, setFoldAtElse()
and foldAtElse() to QsciLexerPerl.
- Added highlightSubidentifiers() and setHighlightSubidentifiers() to
QsciLexerPython.
- Added INDIC_STRAIGHTBOX, INDIC_DASH, INDIC_DOTS, INDIC_SQUIGGLELOW and
INDIC_DOTBOX to QsciScintillaBase.
- Added SC_MARGINOPTION_NONE and SC_MARGINOPTION_SUBLINESELECT to
QsciScintillaBase.
- Added SC_MARK_RGBAIMAGE to QsciScintillaBase.
- Added SCI_BRACEBADLIGHTINDICATOR, SCI_BRACEHIGHLIGHTINDICATOR,
SCI_GETIDENTIFIER, SCI_GETMARGINOPTIONS, SCI_INDICGETOUTLINEALPHA,
SCI_INDICSETOUTLINEALPHA, SCI_MARKERDEFINERGBAIMAGE,
SCI_MARKERENABLEHIGHLIGHT, SCI_MARKERSETBACKSELECTED,
SCI_MOVESELECTEDLINESDOWN, SCI_MOVESELECTEDLINESUP, SCI_REGISTERRGBAIMAGE,
SCI_RGBAIMAGESETHEIGHT, SCI_RGBAIMAGESETWIDTH, SCI_SCROLLTOEND,
SCI_SCROLLTOSTART, SCI_SETEMPTYSELECTION, SCI_SETIDENTIFIER and
SCI_SETMARGINOPTIONS to QsciScintillaBase.
v2.5.1 17th April 2011
- Added QsciLexerMatlab and QsciLexerOctave.
v2.5 29th March 2011
- Based on Scintilla v2.25.
- Rectangular selections are now fully supported and compatible with SciTE.
- The signature of the fromMimeData() and toMimeData() methods of
QsciScintillaBase have changed incompatibly in order to support rectangular
selections.
- Added QsciScintilla::setAutoCompletionUseSingle() to replace the now
deprecated setAutoCompletionShowSingle().
- Added QsciScintilla::autoCompletionUseSingle() to replace the now
deprecated autoCompletionShowSingle().
- QsciScintilla::setAutoCompletionCaseSensitivity() is no longer ignored if a
lexer has been set.
- Added FullRectangle, LeftRectangle and Underline to the
QsciScintilla::MarkerSymbol enum.
- Added setExtraAscent(), extraAscent(), setExtraDescent() and extraDescent()
to QsciScintilla.
- Added setWhitespaceSize() and whitespaceSize() to QsciScintilla.
- Added replaceSelectedText() to QsciScintilla.
- Added setWhitespaceBackgroundColor() and setWhitespaceForegroundColor() to
QsciScintilla.
- Added setWrapIndentMode() and wrapIndentMode() to QsciScintilla.
- Added setFirstVisibleLine() to QsciScintilla.
- Added setContractedFolds() and contractedFolds() to QsciScintilla.
- Added the SCN_HOTSPOTRELEASECLICK() signal to QsciScintillaBase.
- The signature of the QsciScintillaBase::SCN_UPDATEUI() signal has changed.
- Added the RawString and inactive styles to QsciLexerCPP.
- Added MediaRule to QsciLexerCSS.
- Added BackquoteString, RawString, KeywordSet5, KeywordSet6 and KeywordSet7
to QsciLexerD.
- Added setDjangoTemplates(), djangoTemplates(), setMakoTemplates() and
makoTemplates() to QsciLexerHTML.
- Added KeywordSet5, KeywordSet6, KeywordSet7 and KeywordSet8 to
QsciLexerLua.
- Added setInitialSpaces() and initialSpaces() to QsciLexerProperties.
- Added setFoldCompact(), foldCompact(), setStringsOverNewlineAllowed() and
stringsOverNewlineAllowed() to QsciLexerPython.
- Added setFoldComments(), foldComments(), setFoldCompact() and foldCompact()
to QsciLexerRuby.
- Added setFoldComments() and foldComments(), and removed setFoldCompact()
and foldCompact() from QsciLexerTCL.
- Added setFoldComments(), foldComments(), setFoldCompact(), foldCompact(),
setProcessComments(), processComments(), setProcessIf(), and processIf() to
QsciLexerTeX.
- Added QuotedIdentifier, setDottedWords(), dottedWords(), setFoldAtElse(),
foldAtElse(), setFoldOnlyBegin(), foldOnlyBegin(), setHashComments(),
hashComments(), setQuotedIdentifiers() and quotedIdentifiers() to
QsciLexerSQL.
- The Python bindings now allow optional arguments to be specified as keyword
arguments.
- The Python bindings will now build using the protected-is-public hack if
possible.
v2.4.6 23rd December 2010
- Added support for indicators to the high-level API, i.e. added the
IndicatorStyle enum, the clearIndicatorRange(), fillIndicatorRange(),
indicatorDefine(), indicatorDrawUnder(), setIndicatorDrawUnder() and
setIndicatorForegroundColor methods, and the indicatorClicked() and
indicatorReleased() signals to QsciScintilla.
- Added support for the Key style in QsciLexerProperties.
- Added an API file for Python v2.7.
- Added the --no-timestamp command line option to the Python bindings'
configure.py.
v2.4.5 31st August 2010
- A bug fix release.
v2.4.4 12th July 2010
- Added the canInsertFromMimeData(), fromMimeData() and toMimeData() methods
to QsciScintillaBase.
- QsciScintilla::markerDefine() now allows existing markers to be redefined.
v2.4.3 17th March 2010
- Added clearFolds() to QsciScintilla.
v2.4.2 20th January 2010
- Updated Spanish translations from Jaime Seuma.
- Fixed compilation problems with Qt v3 and Qt v4 prior to v4.5.
v2.4.1 14th January 2010
- Added the QsciLexerSpice and QsciLexerVerilog classes.
- Significant performance improvements when handling long lines.
- The Python bindings include automatically generated docstrings by default.
- Added an API file for Python v3.
v2.4 5th June 2009
- Based on Scintilla v1.78.
- Added the QsciLexerCustom, QsciStyle and QsciStyledText classes.
- Added annotate(), annotation(), clearAnnotations(), setAnnotationDisplay()
and annotationDisplay() to QsciScintilla.
- Added setMarginText(), clearMarginText(), setMarginType() and marginType()
to QsciScintilla.
- Added QsciLexer::lexerId() so that container lexers can be implemented.
- Added editor() and styleBitsNeeded() to QsciLexer.
- Added setDollarsAllowed() and dollarsAllowed() to QsciLexerCPP.
- Added setFoldScriptComments(), foldScriptComments(),
setFoldScriptHeredocs() and foldScriptHeredocs() to QsciLexerHTML.
- Added setSmartHighlighting() and smartHighlighting() to QsciLexerPascal.
(Note that the Scintilla Pascal lexer has changed so that any saved colour
and font settings will not be properly restored.)
- Added setFoldPackages(), foldPackages(), setFoldPODBlocks() and
foldPODBlocks() to QsciLexerPerl.
- Added setV2UnicodeAllowed(), v2UnicodeAllowed(), setV3BinaryOctalAllowed(),
v3BinaryOctalAllowed(), setV3BytesAllowed and v3BytesAllowed() to
QsciLexerPython.
- Added setScriptsStyled() and scriptsStyled() to QsciLexerXML.
- Added Spanish translations from Jaime Seuma.
v2.3.2 17th November 2008
- A bug fix release.
v2.3.1 6th November 2008
- Based on Scintilla v1.77.
- Added the read() and write() methods to QsciScintilla to allow a file to be
read and written while minimising the conversions.
- Added the positionFromLineIndex() and lineIndexFromPosition() methods to
QsciScintilla to convert between a Scintilla character address and a
QScintilla character address.
- Added QsciScintilla::wordAtPoint() to return the word at the given screen
coordinates.
- QSciScintilla::setSelection() now allows the carat to be left at either the
start or the end of the selection.
- 'with' is now treated as a keyword by the Python lexer.
v2.3 20th September 2008
- Based on Scintilla v1.76.
- The new QsciAbstractAPIs class allows applications to replace the default
implementation of the language APIs used for auto-completion lists and call
tips.
- Added QsciScintilla::apiContext() to allow applications to determine the
context used for auto-completion and call tips.
- Added the QsciLexerFortran, QsciLexerFortran77, QsciLexerPascal,
QsciLexerPostScript, QsciLexerTCL, QsciLexerXML and QsciLexerYAML classes.
- QsciScintilla::setFolding() will now accept an optional margin number.
v2.2 27th February 2008
- Based on Scintilla v1.75.
- A lexer's default colour, paper and font are now written to and read from
the settings.
- Windows64 is now supported.
- The signature of the QsciScintillaBase::SCN_MACRORECORD() signal has
changed slightly.
- Changed the licensing to match the current Qt licenses, including GPL v3.
v2.1 1st June 2007
- A slightly revised API, incompatible with QScintilla v2.0.
- Lexers now remember their style settings. A lexer no longer has to be the
current lexer when changing a style's color, end-of-line fill, font or
paper.
- The color(), eolFill(), font() and paper() methods of QsciLexer now return
the current values for a style rather than the default values.
- The setDefaultColor(), setDefaultFont() and setDefaultPaper() methods of
QsciLexer are no longer slots and no longer virtual.
- The defaultColor(), defaultFont() and defaultPaper() methods of QsciLexer
are no longer virtual.
- The color(), eolFill(), font() and paper() methods of all QsciLexer derived
classes (except for QsciLexer itself) have been renamed defaultColor(),
defaultEolFill(), defaultFont() and defaultPaper() respectively.
v2.0 26th May 2007
- A revised API, incompatible with QScintilla v1.
- Hugely improved autocompletion and call tips support.
- Supports both Qt v3 and Qt v4.
- Includes Python bindings.

50
third_party/qscintilla/Python/README vendored
View File

@@ -1,50 +0,0 @@
QScintilla - Python Bindings for the QScintilla Programmers Editor Widget
=========================================================================
QScintilla is a port to Qt of the Scintilla programmers editor widget. It
supports the traditional low-level Scintilla API and implements a high-level
API covering such things as auto-completion, code folding and lexer
configuration.
These Python bindings implement a single extension module that sits on top of
PyQt5 and wraps both the low-level and high-level APIs.
Author
------
QScintilla is copyright (c) Riverbank Computing Limited. Its homepage is
https://www.riverbankcomputing.com/software/qscintilla/.
Support may be obtained from the QScintilla mailing list at
https://www.riverbankcomputing.com/mailman/listinfo/qscintilla/.
License
-------
QScintilla is released under the GPL v3 license and under a commercial license
that allows for the development of proprietary applications.
Documentation
-------------
The documentation for the latest release can be found
`here <https://www.riverbankcomputing.com/static/Docs/QScintilla/>`__.
Installation
------------
The GPL version of QScintilla can be installed from PyPI::
pip install QScintilla
The wheels include a statically linked copy of the QScintilla C++ library.
``pip`` will also build and install the bindings from the sdist package but
Qt's ``qmake`` tool must be on ``PATH``.
The ``sip-install`` tool will also install the bindings from the sdist package
but will allow you to configure many aspects of the installation.

22
third_party/qscintilla/Python/config-tests/cfgtest_Qsci.cpp vendored
View File

@@ -1,22 +0,0 @@
#include <QCoreApplication>
#include <QFile>
#include <QTextStream>
#include <Qsci/qsciglobal.h>
int main(int argc, char **argv)
{
QCoreApplication app(argc, argv);
QFile outf(argv[1]);
if (!outf.open(QIODevice::WriteOnly|QIODevice::Truncate|QIODevice::Text))
return 1;
QTextStream out(&outf);
out << QSCINTILLA_VERSION << '\n';
out << QSCINTILLA_VERSION_STR << '\n';
return 0;
}

212
third_party/qscintilla/Python/project.py vendored
View File

@@ -1,212 +0,0 @@
# This is the build script for the QScintilla Python bindings.
#
# Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
#
# This file is part of QScintilla.
#
# This file may be used under the terms of the GNU General Public License
# version 3.0 as published by the Free Software Foundation and appearing in
# the file LICENSE included in the packaging of this file. Please review the
# following information to ensure the GNU General Public License version 3.0
# requirements will be met: http://www.gnu.org/copyleft/gpl.html.
#
# If you do not wish to use this file under the terms of the GPL version 3.0
# then you may purchase a commercial license. For more information contact
# info@riverbankcomputing.com.
#
# This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
# WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
import os
from pyqtbuild import PyQtBindings, PyQtProject
from sipbuild import Option
class QScintilla(PyQtProject):
""" The QScintilla project. """
def __init__(self):
""" Initialise the project. """
super().__init__()
self.bindings_factories = [Qsci]
# If there is a 'src' subdirectory then we are part of an sdist rather
# than a full source distribution. If part of an sdist then the
# QScintilla source is compiled along with the bindings. Otherwise an
# external (ie. already built) QScintilla library is used (which may be
# static or dynamic).
self.qsci_external_lib = not os.path.isdir('src')
def apply_user_defaults(self, tool):
""" Set default values for user options that haven't been set yet. """
super().apply_user_defaults(tool)
if not self.qsci_external_lib:
# If a directory to install the .api files was given then add the
# bundled .api files as well.
if self.api_dir:
self.wheel_includes.append(
('qsci/api/python/*.api', self.api_dir))
if self.qsci_translations_dir:
self.wheel_includes.append(
('src/*.qm', self.qsci_translations_dir))
def get_options(self):
""" Return the list of configurable options. """
options = super().get_options()
# The directory within the wheel to install the translation files to.
options.append(
Option('qsci_translations_dir',
help="the QScintilla translation files will be installed in DIR",
metavar="DIR", tools=['wheel']))
return options
class Qsci(PyQtBindings):
""" The Qsci bindings. """
def __init__(self, project):
""" Initialise the bindings. """
if project.qsci_external_lib:
qmake_CONFIG = ['qscintilla2']
else:
qmake_CONFIG = []
super().__init__(project, 'Qsci', qmake_CONFIG=qmake_CONFIG)
def apply_user_defaults(self, tool):
""" Set default values for user options that haven't been set yet. """
project = self.project
qt6 = (project.builder.qt_version >= 0x060000)
# Set the name of the .sip file now that we know the Qt version number.
self.sip_file = 'qscimod6.sip' if qt6 else 'qscimod5.sip'
if self.project.qsci_external_lib:
if self.qsci_features_dir is not None:
os.environ['QMAKEFEATURES'] = os.path.abspath(
self.qsci_features_dir)
if self.qsci_include_dir is not None:
self.include_dirs.append(
os.path.abspath(self.qsci_include_dir))
if self.qsci_library_dir is not None:
self.library_dirs.append(
os.path.abspath(self.qsci_library_dir))
else:
# We configure CONFIG and QT textually because it's too late to
# update qmake_CONFIG and qmake_QT.
self.builder_settings.append('QT += widgets')
if project.py_platform != 'ios':
self.builder_settings.append('QT += printsupport')
if project.py_platform in ('darwin', 'ios') and not qt6:
self.builder_settings.append('QT += macextras')
self.builder_settings.append(
'CONFIG += warn_off thread exceptions')
self.define_macros.extend(
['SCINTILLA_QT', 'SCI_LEXER',
'INCLUDE_DEPRECATED_FEATURES'])
self._add_internal_lib_sources()
super().apply_user_defaults(tool)
def get_options(self):
""" Return the list of configurable options. """
options = super().get_options()
if self.project.qsci_external_lib:
# The directory containing the features file.
options.append(
Option('qsci_features_dir',
help="the qscintilla2.prf features file is in DIR",
metavar="DIR"))
# The directory containing the include directory.
options.append(
Option('qsci_include_dir',
help="the Qsci include file directory is in DIR",
metavar="DIR"))
# The directory containing the library.
options.append(
Option('qsci_library_dir',
help="the QScintilla library is in DIR",
metavar="DIR"))
return options
def handle_test_output(self, test_output):
""" Handle the output from the external test program and return True if
the bindings are buildable.
"""
project = self.project
installed_version = int(test_output[0])
installed_version_str = test_output[1]
if project.version != installed_version:
project.progress(
"QScintilla v{0} is required but QScintilla v{1} is "
"installed.".format(project.version_str,
installed_version_str))
return False
return True
def is_buildable(self):
""" Return True if the bindings are buildable. """
# We need to check the compatibility of an external QScintilla library.
if self.project.qsci_external_lib:
return super().is_buildable()
return True
def _add_dir_sources(self, dname):
""" Add the headers and sources from a particular directory. """
for fn in os.listdir(dname):
# Skip the printer support on iOS.
if self.project.py_platform == 'ios' and fn.startswith('qsciprinter.'):
continue
if fn.endswith('.h'):
self.headers.append(os.path.join(dname, fn))
elif fn.endswith('.cpp'):
self.sources.append(os.path.join(dname, fn))
def _add_internal_lib_sources(self):
""" Add to the lists of include directories, header files and source
files to build the QScintilla library.
"""
include_dirs = ['src']
for dn in ('include', 'lexers', 'lexlib', 'src'):
include_dirs.append(os.path.join('scintilla', dn))
self._add_dir_sources(os.path.join('src', 'Qsci'))
for dn in include_dirs:
self._add_dir_sources(dn)
self.include_dirs.extend(include_dirs)

16
third_party/qscintilla/Python/pyproject-qt5.toml vendored
View File

@@ -1,16 +0,0 @@
# Specify the build system.
[build-system]
requires = ["sip >=6.0.2, <7", "PyQt-builder >=1.6, <2"]
build-backend = "sipbuild.api"
# Specify the PEP 566 metadata for the project.
[tool.sip.metadata]
name = "QScintilla"
version = "2.14.1"
summary = "Python bindings for the QScintilla programmers editor widget"
home-page = "https://www.riverbankcomputing.com/software/qscintilla/"
author = "Riverbank Computing Limited"
author-email = "info@riverbankcomputing.com"
license = "GPL v3"
description-file = "README"
requires-dist = "PyQt5 (>=5.15.4)"

16
third_party/qscintilla/Python/pyproject-qt6.toml vendored
View File

@@ -1,16 +0,0 @@
# Specify the build system.
[build-system]
requires = ["sip >=6.0.2, <7", "PyQt-builder >=1.6, <2"]
build-backend = "sipbuild.api"
# Specify the PEP 566 metadata for the project.
[tool.sip.metadata]
name = "PyQt6-QScintilla"
version = "2.14.1"
summary = "Python bindings for the QScintilla programmers editor widget"
home-page = "https://www.riverbankcomputing.com/software/qscintilla/"
author = "Riverbank Computing Limited"
author-email = "info@riverbankcomputing.com"
license = "GPL v3"
description-file = "README"
requires-dist = "PyQt6 (>=6.0.3)"

42
third_party/qscintilla/Python/sip/qsciabstractapis.sip vendored
View File

@@ -1,42 +0,0 @@
// This is the SIP interface definition for QsciAbstractAPIs.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciAbstractAPIs : QObject
{
%TypeHeaderCode
#include <Qsci/qsciabstractapis.h>
%End
public:
QsciAbstractAPIs(QsciLexer *lexer /TransferThis/);
virtual ~QsciAbstractAPIs();
QsciLexer *lexer() const;
virtual void updateAutoCompletionList(const QStringList &context,
QStringList &list /In, Out/) = 0;
virtual void autoCompletionSelected(const QString &selection);
virtual QStringList callTips(const QStringList &context, int commas,
QsciScintilla::CallTipsStyle style, QList<int> &shifts) = 0;
private:
QsciAbstractAPIs(const QsciAbstractAPIs &);
};

58
third_party/qscintilla/Python/sip/qsciapis.sip vendored
View File

@@ -1,58 +0,0 @@
// This is the SIP interface definition for QsciAPIs.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciAPIs : QsciAbstractAPIs
{
%TypeHeaderCode
#include <Qsci/qsciapis.h>
%End
public:
QsciAPIs(QsciLexer *lexer /TransferThis/);
virtual ~QsciAPIs();
void add(const QString &entry);
void clear();
bool load(const QString &fname);
void remove(const QString &entry);
void prepare();
void cancelPreparation();
QString defaultPreparedName() const;
bool isPrepared(const QString &filename = QString()) const;
bool loadPrepared(const QString &filename = QString());
bool savePrepared(const QString &filename = QString()) const;
virtual bool event(QEvent *e);
QStringList installedAPIFiles() const;
virtual void updateAutoCompletionList(const QStringList &context,
QStringList &list /In, Out/);
virtual void autoCompletionSelected(const QString &selection);
virtual QStringList callTips(const QStringList &context, int commas,
QsciScintilla::CallTipsStyle style, QList<int> &shifts);
signals:
void apiPreparationCancelled();
void apiPreparationStarted();
void apiPreparationFinished();
private:
QsciAPIs(const QsciAPIs &);
};

143
third_party/qscintilla/Python/sip/qscicommand.sip vendored
View File

@@ -1,143 +0,0 @@
// This is the SIP interface definition for QsciCommand.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciCommand
{
%TypeHeaderCode
#include <Qsci/qscicommand.h>
%End
public:
enum Command {
LineDown,
LineDownExtend,
LineDownRectExtend,
LineScrollDown,
LineUp,
LineUpExtend,
LineUpRectExtend,
LineScrollUp,
ScrollToStart,
ScrollToEnd,
VerticalCentreCaret,
ParaDown,
ParaDownExtend,
ParaUp,
ParaUpExtend,
CharLeft,
CharLeftExtend,
CharLeftRectExtend,
CharRight,
CharRightExtend,
CharRightRectExtend,
WordLeft,
WordLeftExtend,
WordRight,
WordRightExtend,
WordLeftEnd,
WordLeftEndExtend,
WordRightEnd,
WordRightEndExtend,
WordPartLeft,
WordPartLeftExtend,
WordPartRight,
WordPartRightExtend,
Home,
HomeExtend,
HomeRectExtend,
HomeDisplay,
HomeDisplayExtend,
HomeWrap,
HomeWrapExtend,
VCHome,
VCHomeExtend,
VCHomeRectExtend,
VCHomeWrap,
VCHomeWrapExtend,
LineEnd,
LineEndExtend,
LineEndRectExtend,
LineEndDisplay,
LineEndDisplayExtend,
LineEndWrap,
LineEndWrapExtend,
DocumentStart,
DocumentStartExtend,
DocumentEnd,
DocumentEndExtend,
PageUp,
PageUpExtend,
PageUpRectExtend,
PageDown,
PageDownExtend,
PageDownRectExtend,
StutteredPageUp,
StutteredPageUpExtend,
StutteredPageDown,
StutteredPageDownExtend,
Delete,
DeleteBack,
DeleteBackNotLine,
DeleteWordLeft,
DeleteWordRight,
DeleteWordRightEnd,
DeleteLineLeft,
DeleteLineRight,
LineDelete,
LineCut,
LineCopy,
LineTranspose,
LineDuplicate,
SelectAll,
MoveSelectedLinesUp,
MoveSelectedLinesDown,
SelectionDuplicate,
SelectionLowerCase,
SelectionUpperCase,
SelectionCut,
SelectionCopy,
Paste,
EditToggleOvertype,
Newline,
Formfeed,
Tab,
Backtab,
Cancel,
Undo,
Redo,
ZoomIn,
ZoomOut,
ReverseLines,
};
Command command() const;
void execute();
void setKey(int key);
void setAlternateKey(int altkey);
int key() const;
int alternateKey() const;
static bool validKey(int key);
QString description() const;
private:
QsciCommand(QsciScintilla *qs, Command cmd, int key, int altkey,
const char *desc);
QsciCommand(const QsciCommand &);
};

44
third_party/qscintilla/Python/sip/qscicommandset.sip vendored
View File

@@ -1,44 +0,0 @@
// This is the SIP interface definition for the QsciCommandSet.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciCommandSet
{
%TypeHeaderCode
#include <Qsci/qscicommandset.h>
%End
public:
bool readSettings(QSettings &qs, const char *prefix = "/Scintilla");
bool writeSettings(QSettings &qs, const char *prefix = "/Scintilla");
QList<QsciCommand *> &commands();
void clearKeys();
void clearAlternateKeys();
QsciCommand *boundTo(int key) const;
QsciCommand *find(QsciCommand::Command command) const;
private:
QsciCommandSet(QsciScintilla *qs);
~QsciCommandSet();
QsciCommandSet(const QsciCommandSet &);
};

32
third_party/qscintilla/Python/sip/qscidocument.sip vendored
View File

@@ -1,32 +0,0 @@
// This is the SIP interface definition for QsciDocument.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciDocument
{
%TypeHeaderCode
#include <Qsci/qscidocument.h>
%End
public:
QsciDocument();
virtual ~QsciDocument();
QsciDocument(const QsciDocument &);
};

90
third_party/qscintilla/Python/sip/qscilexer.sip vendored
View File

@@ -1,90 +0,0 @@
// This is the SIP interface definition for QsciLexer.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexer : QObject
{
%TypeHeaderCode
#include <Qsci/qscilexer.h>
%End
public:
QsciLexer(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexer();
virtual const char *language() const = 0;
virtual const char *lexer() const;
virtual int lexerId() const;
QsciAbstractAPIs *apis() const;
virtual const char *autoCompletionFillups() const /Encoding="None"/;
virtual QStringList autoCompletionWordSeparators() const;
int autoIndentStyle();
virtual const char *blockEnd(int *style = 0) const /Encoding="None"/;
virtual int blockLookback() const;
virtual const char *blockStart(int *style = 0) const /Encoding="None"/;
virtual const char *blockStartKeyword(int *style = 0) const /Encoding="None"/;
virtual int braceStyle() const;
virtual bool caseSensitive() const;
virtual QColor color(int style) const;
virtual bool eolFill(int style) const;
virtual QFont font(int style) const;
virtual int indentationGuideView() const;
virtual const char *keywords(int set) const;
virtual QString description(int style) const = 0;
virtual QColor paper(int style) const;
QColor defaultColor() const;
virtual QColor defaultColor(int style) const;
virtual bool defaultEolFill(int style) const;
QFont defaultFont() const;
virtual QFont defaultFont(int style) const;
QColor defaultPaper() const;
virtual QColor defaultPaper(int style) const;
virtual int defaultStyle() const;
QsciScintilla *editor() const;
virtual void refreshProperties();
void setAPIs(QsciAbstractAPIs *apis);
void setDefaultColor(const QColor &c);
void setDefaultFont(const QFont &f);
void setDefaultPaper(const QColor &c);
virtual int styleBitsNeeded() const;
virtual const char *wordCharacters() const;
bool readSettings(QSettings &qs, const char *prefix = "/Scintilla");
bool writeSettings(QSettings &qs, const char *prefix = "/Scintilla") const;
public slots:
virtual void setAutoIndentStyle(int autoindentstyle);
virtual void setColor(const QColor &c, int style = -1);
virtual void setEolFill(bool eolfill, int style = -1);
virtual void setFont(const QFont &f, int style = -1);
virtual void setPaper(const QColor &c, int style = -1);
signals:
void colorChanged(const QColor &c, int style);
void eolFillChanged(bool eolfilled, int style);
void fontChanged(const QFont &f, int style);
void paperChanged(const QColor &c, int style);
void propertyChanged(const char *prop, const char *val);
protected:
virtual bool readProperties(QSettings &qs, const QString &prefix);
virtual bool writeProperties(QSettings &qs, const QString &prefix) const;
private:
QsciLexer(const QsciLexer &);
};

74
third_party/qscintilla/Python/sip/qscilexerasm.sip vendored
View File

@@ -1,74 +0,0 @@
// This is the SIP interface definition for QsciLexerAsm.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerAsm : QsciLexer
{
%TypeHeaderCode
#include <Qsci/qscilexerasm.h>
%End
public:
enum {
Default,
Comment,
Number,
DoubleQuotedString,
Operator,
Identifier,
CPUInstruction,
FPUInstruction,
Register,
Directive,
DirectiveOperand,
BlockComment,
SingleQuotedString,
UnclosedString,
ExtendedInstruction,
CommentDirective,
};
QsciLexerAsm(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerAsm();
QColor defaultColor(int style) const;
bool defaultEolFill(int style) const;
QFont defaultFont(int style) const;
QColor defaultPaper(int style) const;
const char *keywords(int set) const;
QString description(int style) const;
void refreshProperties();
bool foldComments() const;
bool foldCompact() const;
QChar commentDelimiter() const;
bool foldSyntaxBased() const;
public slots:
virtual void setFoldComments(bool fold);
virtual void setFoldCompact(bool fold);
virtual void setCommentDelimiter(QChar delimeter);
virtual void setFoldSyntaxBased(bool syntax_based);
protected:
bool readProperties(QSettings &qs, const QString &prefix);
bool writeProperties(QSettings &qs, const QString &prefix) const;
private:
QsciLexerAsm(const QsciLexerAsm &);
};

73
third_party/qscintilla/Python/sip/qscilexeravs.sip vendored
View File

@@ -1,73 +0,0 @@
// This is the SIP interface definition for QsciLexerAVS.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerAVS : QsciLexer
{
%TypeHeaderCode
#include <Qsci/qscilexeravs.h>
%End
public:
enum {
Default,
BlockComment,
NestedBlockComment,
LineComment,
Number,
Operator,
Identifier,
String,
TripleString,
Keyword,
Filter,
Plugin,
Function,
ClipProperty,
KeywordSet6
};
QsciLexerAVS(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerAVS();
const char *language() const;
const char *lexer() const;
QColor defaultColor(int style) const;
QFont defaultFont(int style) const;
const char *keywords(int set) const;
QString description(int style) const;
const char *wordCharacters() const;
int braceStyle() const;
void refreshProperties();
bool foldComments() const;
bool foldCompact() const;
public slots:
virtual void setFoldComments(bool fold);
virtual void setFoldCompact(bool fold);
protected:
bool readProperties(QSettings &qs, const QString &prefix);
bool writeProperties(QSettings &qs, const QString &prefix) const;
private:
QsciLexerAVS(const QsciLexerAVS &);
};

74
third_party/qscintilla/Python/sip/qscilexerbash.sip vendored
View File

@@ -1,74 +0,0 @@
// This is the SIP interface definition for QsciLexerBash.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerBash : QsciLexer
{
%TypeHeaderCode
#include <Qsci/qscilexerbash.h>
%End
public:
enum {
Default,
Error,
Comment,
Number,
Keyword,
DoubleQuotedString,
SingleQuotedString,
Operator,
Identifier,
Scalar,
ParameterExpansion,
Backticks,
HereDocumentDelimiter,
SingleQuotedHereDocument
};
QsciLexerBash(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerBash();
const char *language() const;
const char *lexer() const;
QColor defaultColor(int style) const;
bool defaultEolFill(int style) const;
QFont defaultFont(int style) const;
QColor defaultPaper(int style) const;
const char *keywords(int set) const;
QString description(int style) const;
const char *wordCharacters() const;
int braceStyle() const;
void refreshProperties();
bool foldComments() const;
bool foldCompact() const;
public slots:
virtual void setFoldComments(bool fold);
virtual void setFoldCompact(bool fold);
protected:
bool readProperties(QSettings &qs, const QString &prefix);
bool writeProperties(QSettings &qs, const QString &prefix) const;
private:
QsciLexerBash(const QsciLexerBash &);
};

56
third_party/qscintilla/Python/sip/qscilexerbatch.sip vendored
View File

@@ -1,56 +0,0 @@
// This is the SIP interface definition for QsciLexerBatch.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerBatch : QsciLexer
{
%TypeHeaderCode
#include <Qsci/qscilexerbatch.h>
%End
public:
enum {
Default,
Comment,
Keyword,
Label,
HideCommandChar,
ExternalCommand,
Variable,
Operator
};
QsciLexerBatch(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerBatch();
const char *language() const;
const char *lexer() const;
QColor defaultColor(int style) const;
bool defaultEolFill(int style) const;
QFont defaultFont(int style) const;
QColor defaultPaper(int style) const;
const char *keywords(int set) const;
QString description(int style) const;
const char *wordCharacters() const;
bool caseSensitive() const;
private:
QsciLexerBatch(const QsciLexerBatch &);
};

69
third_party/qscintilla/Python/sip/qscilexercmake.sip vendored
View File

@@ -1,69 +0,0 @@
// This is the SIP interface definition for QsciLexerCMake.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerCMake : QsciLexer
{
%TypeHeaderCode
#include <Qsci/qscilexercmake.h>
%End
public:
enum {
Default,
Comment,
String,
StringLeftQuote,
StringRightQuote,
Function,
Variable,
Label,
KeywordSet3,
BlockWhile,
BlockForeach,
BlockIf,
BlockMacro,
StringVariable,
Number
};
QsciLexerCMake(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerCMake();
const char *language() const;
const char *lexer() const;
QColor defaultColor(int style) const;
QFont defaultFont(int style) const;
QColor defaultPaper(int style) const;
const char *keywords(int set) const;
QString description(int style) const;
void refreshProperties();
bool foldAtElse() const;
public slots:
virtual void setFoldAtElse(bool fold);
protected:
bool readProperties(QSettings &qs, const QString &prefix);
bool writeProperties(QSettings &qs, const QString &prefix) const;
private:
QsciLexerCMake(const QsciLexerCMake &);
};

90
third_party/qscintilla/Python/sip/qscilexercoffeescript.sip vendored
View File

@@ -1,90 +0,0 @@
// This is the SIP interface definition for QsciLexerCoffeeScript.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerCoffeeScript : QsciLexer
{
%TypeHeaderCode
#include <Qsci/qscilexercoffeescript.h>
%End
public:
enum {
Default,
Comment,
CommentLine,
CommentDoc,
Number,
Keyword,
DoubleQuotedString,
SingleQuotedString,
UUID,
PreProcessor,
Operator,
Identifier,
UnclosedString,
VerbatimString,
Regex,
CommentLineDoc,
KeywordSet2,
CommentDocKeyword,
CommentDocKeywordError,
GlobalClass,
CommentBlock,
BlockRegex,
BlockRegexComment,
InstanceProperty,
};
QsciLexerCoffeeScript(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerCoffeeScript();
const char *language() const;
const char *lexer() const;
QColor defaultColor(int style) const;
bool defaultEolFill(int style) const;
QFont defaultFont(int style) const;
QColor defaultPaper(int style) const;
const char *keywords(int set) const;
QString description(int style) const;
const char *wordCharacters() const;
QStringList autoCompletionWordSeparators() const;
const char *blockEnd(int *style = 0) const /Encoding="None"/;
const char *blockStart(int *style = 0) const /Encoding="None"/;
const char *blockStartKeyword(int *style = 0) const /Encoding="None"/;
int braceStyle() const;
void refreshProperties();
bool dollarsAllowed() const;
void setDollarsAllowed(bool allowed);
bool foldComments() const;
void setFoldComments(bool fold);
bool foldCompact() const;
void setFoldCompact(bool fold);
bool stylePreprocessor() const;
void setStylePreprocessor(bool style);
protected:
bool readProperties(QSettings &qs, const QString &prefix);
bool writeProperties(QSettings &qs, const QString &prefix) const;
private:
QsciLexerCoffeeScript(const QsciLexerCoffeeScript &);
};

138
third_party/qscintilla/Python/sip/qscilexercpp.sip vendored
View File

@@ -1,138 +0,0 @@
// This is the SIP interface definition for QsciLexerCPP.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerCPP : QsciLexer
{
%TypeHeaderCode
#include <Qsci/qscilexercpp.h>
%End
public:
enum {
Default,
InactiveDefault,
Comment,
InactiveComment,
CommentLine,
InactiveCommentLine,
CommentDoc,
InactiveCommentDoc,
Number,
InactiveNumber,
Keyword,
InactiveKeyword,
DoubleQuotedString,
InactiveDoubleQuotedString,
SingleQuotedString,
InactiveSingleQuotedString,
UUID,
InactiveUUID,
PreProcessor,
InactivePreProcessor,
Operator,
InactiveOperator,
Identifier,
InactiveIdentifier,
UnclosedString,
InactiveUnclosedString,
VerbatimString,
InactiveVerbatimString,
Regex,
InactiveRegex,
CommentLineDoc,
InactiveCommentLineDoc,
KeywordSet2,
InactiveKeywordSet2,
CommentDocKeyword,
InactiveCommentDocKeyword,
CommentDocKeywordError,
InactiveCommentDocKeywordError,
GlobalClass,
InactiveGlobalClass,
RawString,
InactiveRawString,
TripleQuotedVerbatimString,
InactiveTripleQuotedVerbatimString,
HashQuotedString,
InactiveHashQuotedString,
PreProcessorComment,
InactivePreProcessorComment,
PreProcessorCommentLineDoc,
InactivePreProcessorCommentLineDoc,
UserLiteral,
InactiveUserLiteral,
TaskMarker,
InactiveTaskMarker,
EscapeSequence,
InactiveEscapeSequence,
};
QsciLexerCPP(QObject *parent /TransferThis/ = 0,
bool caseInsensitiveKeywords = false);
const char *language() const;
const char *lexer() const;
QColor defaultColor(int style) const;
bool defaultEolFill(int style) const;
QFont defaultFont(int style) const;
QColor defaultPaper(int style) const;
const char *keywords(int set) const;
QString description(int style) const;
const char *wordCharacters() const;
QStringList autoCompletionWordSeparators() const;
const char *blockEnd(int *style = 0) const /Encoding="None"/;
const char *blockStart(int *style = 0) const /Encoding="None"/;
const char *blockStartKeyword(int *style = 0) const /Encoding="None"/;
int braceStyle() const;
void refreshProperties();
bool foldAtElse() const;
bool foldComments() const;
bool foldCompact() const;
bool foldPreprocessor() const;
bool stylePreprocessor() const;
void setDollarsAllowed(bool allowed);
bool dollarsAllowed() const;
void setHighlightTripleQuotedStrings(bool enable);
bool highlightTripleQuotedStrings() const;
void setHighlightHashQuotedStrings(bool enable);
bool highlightHashQuotedStrings() const;
void setHighlightBackQuotedStrings(bool enabled);
bool highlightBackQuotedStrings() const;
void setHighlightEscapeSequences(bool enabled);
bool highlightEscapeSequences() const;
void setVerbatimStringEscapeSequencesAllowed(bool allowed);
bool verbatimStringEscapeSequencesAllowed() const;
public slots:
virtual void setFoldAtElse(bool fold);
virtual void setFoldComments(bool fold);
virtual void setFoldCompact(bool fold);
virtual void setFoldPreprocessor(bool fold);
virtual void setStylePreprocessor(bool style);
protected:
bool readProperties(QSettings &qs, const QString &prefix);
bool writeProperties(QSettings &qs, const QString &prefix) const;
private:
QsciLexerCPP(const QsciLexerCPP &);
};

41
third_party/qscintilla/Python/sip/qscilexercsharp.sip vendored
View File

@@ -1,41 +0,0 @@
// This is the SIP interface definition for QsciLexerCSharp.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerCSharp : QsciLexerCPP
{
%TypeHeaderCode
#include <Qsci/qscilexercsharp.h>
%End
public:
QsciLexerCSharp(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerCSharp();
const char *language() const;
QColor defaultColor(int style) const;
bool defaultEolFill(int style) const;
QFont defaultFont(int style) const;
QColor defaultPaper(int style) const;
const char *keywords(int set) const;
QString description(int style) const;
private:
QsciLexerCSharp(const QsciLexerCSharp &);
};

88
third_party/qscintilla/Python/sip/qscilexercss.sip vendored
View File

@@ -1,88 +0,0 @@
// This is the SIP interface definition for QsciLexerCSS.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerCSS : QsciLexer
{
%TypeHeaderCode
#include <Qsci/qscilexercss.h>
%End
public:
enum {
Default,
Tag,
ClassSelector,
PseudoClass,
UnknownPseudoClass,
Operator,
CSS1Property,
UnknownProperty,
Value,
Comment,
IDSelector,
Important,
AtRule,
DoubleQuotedString,
SingleQuotedString,
CSS2Property,
Attribute,
CSS3Property,
PseudoElement,
ExtendedCSSProperty,
ExtendedPseudoClass,
ExtendedPseudoElement,
MediaRule,
Variable,
};
QsciLexerCSS(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerCSS();
const char *language() const;
const char *lexer() const;
QColor defaultColor(int style) const;
QFont defaultFont(int style) const;
const char *keywords(int set) const;
QString description(int style) const;
const char *wordCharacters() const;
const char *blockEnd(int *style = 0) const /Encoding="None"/;
void refreshProperties();
bool foldComments() const;
bool foldCompact() const;
void setHSSLanguage(bool enable);
bool HSSLanguage() const;
void setLessLanguage(bool enable);
bool LessLanguage() const;
void setSCSSLanguage(bool enable);
bool SCSSLanguage() const;
public slots:
virtual void setFoldComments(bool fold);
virtual void setFoldCompact(bool fold);
protected:
bool readProperties(QSettings &qs, const QString &prefix);
bool writeProperties(QSettings &qs, const QString &prefix) const;
private:
QsciLexerCSS(const QsciLexerCSS &);
};

42
third_party/qscintilla/Python/sip/qscilexercustom.sip vendored
View File

@@ -1,42 +0,0 @@
// This is the SIP interface definition for QsciLexerCustom.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerCustom : QsciLexer
{
%TypeHeaderCode
#include <Qsci/qscilexercustom.h>
%End
public:
QsciLexerCustom(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerCustom();
virtual void setEditor(QsciScintilla *editor);
virtual int styleBitsNeeded() const;
void setStyling(int length, int style);
void setStyling(int length, const QsciStyle &style);
void startStyling(int pos, int styleBits = 0);
virtual void styleText(int start, int end) = 0;
private:
QsciLexerCustom(const QsciLexerCustom &);
};

88
third_party/qscintilla/Python/sip/qscilexerd.sip vendored
View File

@@ -1,88 +0,0 @@
// This is the SIP interface definition for QsciLexerD.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerD : QsciLexer
{
%TypeHeaderCode
#include <Qsci/qscilexerd.h>
%End
public:
enum {
Default,
Comment,
CommentLine,
CommentDoc,
CommentNested,
Number,
Keyword,
KeywordSecondary,
KeywordDoc,
Typedefs,
String,
UnclosedString,
Character,
Operator,
Identifier,
CommentLineDoc,
CommentDocKeyword,
CommentDocKeywordError,
BackquoteString,
RawString,
KeywordSet5,
KeywordSet6,
KeywordSet7,
};
QsciLexerD(QObject *parent /TransferThis/ = 0);
const char *language() const;
const char *lexer() const;
QColor defaultColor(int style) const;
bool defaultEolFill(int style) const;
QFont defaultFont(int style) const;
QColor defaultPaper(int style) const;
const char *keywords(int set) const;
QString description(int style) const;
const char *wordCharacters() const;
QStringList autoCompletionWordSeparators() const;
const char *blockEnd(int *style = 0) const /Encoding="None"/;
const char *blockStart(int *style = 0) const /Encoding="None"/;
const char *blockStartKeyword(int *style = 0) const /Encoding="None"/;
int braceStyle() const;
void refreshProperties();
bool foldAtElse() const;
bool foldComments() const;
bool foldCompact() const;
public slots:
virtual void setFoldAtElse(bool fold);
virtual void setFoldComments(bool fold);
virtual void setFoldCompact(bool fold);
protected:
bool readProperties(QSettings &qs, const QString &prefix);
bool writeProperties(QSettings &qs, const QString &prefix) const;
private:
QsciLexerD(const QsciLexerD &);
};

54
third_party/qscintilla/Python/sip/qscilexerdiff.sip vendored
View File

@@ -1,54 +0,0 @@
// This is the SIP interface definition for QsciLexerDiff.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerDiff : QsciLexer
{
%TypeHeaderCode
#include <Qsci/qscilexerdiff.h>
%End
public:
enum {
Default,
Comment,
Command,
Header,
Position,
LineRemoved,
LineAdded,
LineChanged,
AddingPatchAdded,
RemovingPatchAdded,
AddingPatchRemoved,
RemovingPatchRemoved,
};
QsciLexerDiff(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerDiff();
const char *language() const;
const char *lexer() const;
QColor defaultColor(int style) const;
QString description(int style) const;
const char *wordCharacters() const;
private:
QsciLexerDiff(const QsciLexerDiff &);
};

50
third_party/qscintilla/Python/sip/qscilexeredifact.sip vendored
View File

@@ -1,50 +0,0 @@
// This is the SIP interface definition for QsciLexerEDIFACT.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerEDIFACT : QsciLexer
{
%TypeHeaderCode
#include <Qsci/qscilexeredifact.h>
%End
public:
enum {
Default,
SegmentStart,
SegmentEnd,
ElementSeparator,
CompositeSeparator,
ReleaseSeparator,
UNASegmentHeader,
UNHSegmentHeader,
BadSegment
};
QsciLexerEDIFACT(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerEDIFACT();
const char *language() const;
const char *lexer() const;
QColor defaultColor(int style) const;
QString description(int style) const;
private:
QsciLexerEDIFACT(const QsciLexerEDIFACT &);
};

36
third_party/qscintilla/Python/sip/qscilexerfortran.sip vendored
View File

@@ -1,36 +0,0 @@
// This is the SIP interface definition for QsciLexerFortran.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerFortran : QsciLexerFortran77
{
%TypeHeaderCode
#include <Qsci/qscilexerfortran.h>
%End
public:
QsciLexerFortran(QObject *parent /TransferThis/ = 0);
const char *language() const;
const char *lexer() const;
const char *keywords(int set) const;
private:
QsciLexerFortran(const QsciLexerFortran &);
};

71
third_party/qscintilla/Python/sip/qscilexerfortran77.sip vendored
View File

@@ -1,71 +0,0 @@
// This is the SIP interface definition for QsciLexerFortran77.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerFortran77 : QsciLexer
{
%TypeHeaderCode
#include <Qsci/qscilexerfortran77.h>
%End
public:
enum {
Default,
Comment,
Number,
SingleQuotedString,
DoubleQuotedString,
UnclosedString,
Operator,
Identifier,
Keyword,
IntrinsicFunction,
ExtendedFunction,
PreProcessor,
DottedOperator,
Label,
Continuation,
};
QsciLexerFortran77(QObject *parent /TransferThis/ = 0);
const char *language() const;
const char *lexer() const;
QColor defaultColor(int style) const;
bool defaultEolFill(int style) const;
QFont defaultFont(int style) const;
QColor defaultPaper(int style) const;
const char *keywords(int set) const;
QString description(int style) const;
int braceStyle() const;
void refreshProperties();
bool foldCompact() const;
public slots:
virtual void setFoldCompact(bool fold);
protected:
bool readProperties(QSettings &qs, const QString &prefix);
bool writeProperties(QSettings &qs, const QString &prefix) const;
private:
QsciLexerFortran77(const QsciLexerFortran77 &);
};

58
third_party/qscintilla/Python/sip/qscilexerhex.sip vendored
View File

@@ -1,58 +0,0 @@
// This is the SIP interface definition for QsciLexerHex.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerHex : QsciLexer
{
%TypeHeaderCode
#include <Qsci/qscilexerhex.h>
%End
public:
enum {
Default,
RecordStart,
RecordType,
UnknownRecordType,
ByteCount,
IncorrectByteCount,
NoAddress,
DataAddress,
RecordCount,
StartAddress,
ExtendedAddress,
OddData,
EvenData,
UnknownData,
Checksum,
IncorrectChecksum,
TrailingGarbage,
};
QsciLexerHex(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerHex();
QColor defaultColor(int style) const;
QFont defaultFont(int style) const;
QColor defaultPaper(int style) const;
QString description(int style) const;
private:
QsciLexerHex(const QsciLexerHex &);
};

181
third_party/qscintilla/Python/sip/qscilexerhtml.sip vendored
View File

@@ -1,181 +0,0 @@
// This is the SIP interface definition for QsciLexerHTML.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerHTML : QsciLexer
{
%TypeHeaderCode
#include <Qsci/qscilexerhtml.h>
%End
public:
enum {
Default,
Tag,
UnknownTag,
Attribute,
UnknownAttribute,
HTMLNumber,
HTMLDoubleQuotedString,
HTMLSingleQuotedString,
OtherInTag,
HTMLComment,
Entity,
XMLTagEnd,
XMLStart,
XMLEnd,
Script,
ASPAtStart,
ASPStart,
CDATA,
PHPStart,
HTMLValue,
ASPXCComment,
SGMLDefault,
SGMLCommand,
SGMLParameter,
SGMLDoubleQuotedString,
SGMLSingleQuotedString,
SGMLError,
SGMLSpecial,
SGMLEntity,
SGMLComment,
SGMLParameterComment,
SGMLBlockDefault,
JavaScriptStart,
JavaScriptDefault,
JavaScriptComment,
JavaScriptCommentLine,
JavaScriptCommentDoc,
JavaScriptNumber,
JavaScriptWord,
JavaScriptKeyword,
JavaScriptDoubleQuotedString,
JavaScriptSingleQuotedString,
JavaScriptSymbol,
JavaScriptUnclosedString,
JavaScriptRegex,
ASPJavaScriptStart,
ASPJavaScriptDefault,
ASPJavaScriptComment,
ASPJavaScriptCommentLine,
ASPJavaScriptCommentDoc,
ASPJavaScriptNumber,
ASPJavaScriptWord,
ASPJavaScriptKeyword,
ASPJavaScriptDoubleQuotedString,
ASPJavaScriptSingleQuotedString,
ASPJavaScriptSymbol,
ASPJavaScriptUnclosedString,
ASPJavaScriptRegex,
VBScriptStart,
VBScriptDefault,
VBScriptComment,
VBScriptNumber,
VBScriptKeyword,
VBScriptString,
VBScriptIdentifier,
VBScriptUnclosedString,
ASPVBScriptStart,
ASPVBScriptDefault,
ASPVBScriptComment,
ASPVBScriptNumber,
ASPVBScriptKeyword,
ASPVBScriptString,
ASPVBScriptIdentifier,
ASPVBScriptUnclosedString,
PythonStart,
PythonDefault,
PythonComment,
PythonNumber,
PythonDoubleQuotedString,
PythonSingleQuotedString,
PythonKeyword,
PythonTripleSingleQuotedString,
PythonTripleDoubleQuotedString,
PythonClassName,
PythonFunctionMethodName,
PythonOperator,
PythonIdentifier,
ASPPythonStart,
ASPPythonDefault,
ASPPythonComment,
ASPPythonNumber,
ASPPythonDoubleQuotedString,
ASPPythonSingleQuotedString,
ASPPythonKeyword,
ASPPythonTripleSingleQuotedString,
ASPPythonTripleDoubleQuotedString,
ASPPythonClassName,
ASPPythonFunctionMethodName,
ASPPythonOperator,
ASPPythonIdentifier,
PHPDefault,
PHPDoubleQuotedString,
PHPSingleQuotedString,
PHPKeyword,
PHPNumber,
PHPVariable,
PHPComment,
PHPCommentLine,
PHPDoubleQuotedVariable,
PHPOperator
};
QsciLexerHTML(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerHTML();
const char *language() const;
const char *lexer() const;
QColor defaultColor(int style) const;
bool defaultEolFill(int style) const;
QFont defaultFont(int style) const;
QColor defaultPaper(int style) const;
const char *keywords(int set) const;
QString description(int style) const;
const char *wordCharacters() const;
const char *autoCompletionFillups() const /Encoding="None"/;
bool caseSensitive() const;
void refreshProperties();
bool caseSensitiveTags() const;
void setDjangoTemplates(bool enable);
bool djangoTemplates() const;
bool foldCompact() const;
bool foldPreprocessor() const;
void setFoldScriptComments(bool fold);
bool foldScriptComments() const;
void setFoldScriptHeredocs(bool fold);
bool foldScriptHeredocs() const;
void setMakoTemplates(bool enable);
bool makoTemplates() const;
public slots:
virtual void setFoldCompact(bool fold);
virtual void setFoldPreprocessor(bool fold);
virtual void setCaseSensitiveTags(bool sens);
protected:
bool readProperties(QSettings &qs, const QString &prefix);
bool writeProperties(QSettings &qs, const QString &prefix) const;
private:
QsciLexerHTML(const QsciLexerHTML &);
};

38
third_party/qscintilla/Python/sip/qscilexeridl.sip vendored
View File

@@ -1,38 +0,0 @@
// This is the SIP interface definition for QsciLexerIDL.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerIDL : QsciLexerCPP
{
%TypeHeaderCode
#include <Qsci/qscilexeridl.h>
%End
public:
QsciLexerIDL(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerIDL();
const char *language() const;
QColor defaultColor(int style) const;
const char *keywords(int set) const;
QString description(int style) const;
private:
QsciLexerIDL(const QsciLexerIDL &);
};

37
third_party/qscintilla/Python/sip/qscilexerintelhex.sip vendored
View File

@@ -1,37 +0,0 @@
// This is the SIP interface definition for QsciLexerIntelHex.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerIntelHex : QsciLexerHex
{
%TypeHeaderCode
#include <Qsci/qscilexerintelhex.h>
%End
public:
QsciLexerIntelHex(QObject *parent = 0);
virtual ~QsciLexerIntelHex();
const char *language() const;
const char *lexer() const;
QString description(int style) const;
private:
QsciLexerIntelHex(const QsciLexerIntelHex &);
};

36
third_party/qscintilla/Python/sip/qscilexerjava.sip vendored
View File

@@ -1,36 +0,0 @@
// This is the SIP interface definition for QsciLexerJava.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerJava : QsciLexerCPP
{
%TypeHeaderCode
#include <Qsci/qscilexerjava.h>
%End
public:
QsciLexerJava(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerJava();
const char *language() const;
const char *keywords(int set) const;
private:
QsciLexerJava(const QsciLexerJava &);
};

41
third_party/qscintilla/Python/sip/qscilexerjavascript.sip vendored
View File

@@ -1,41 +0,0 @@
// This is the SIP interface definition for QsciLexerJavaScript.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerJavaScript : QsciLexerCPP
{
%TypeHeaderCode
#include <Qsci/qscilexerjavascript.h>
%End
public:
QsciLexerJavaScript(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerJavaScript();
const char *language() const;
QColor defaultColor(int style) const;
bool defaultEolFill(int style) const;
QFont defaultFont(int style) const;
QColor defaultPaper(int style) const;
const char *keywords(int set) const;
QString description(int style) const;
private:
QsciLexerJavaScript(const QsciLexerJavaScript &);
};

71
third_party/qscintilla/Python/sip/qscilexerjson.sip vendored
View File

@@ -1,71 +0,0 @@
// This is the SIP interface definition for QsciLexerJSON.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerJSON : QsciLexer
{
%TypeHeaderCode
#include <Qsci/qscilexerjson.h>
%End
public:
enum {
Default,
Number,
String,
UnclosedString,
Property,
EscapeSequence,
CommentLine,
CommentBlock,
Operator,
IRI,
IRICompact,
Keyword,
KeywordLD,
Error,
};
QsciLexerJSON(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerJSON();
const char *language() const;
const char *lexer() const;
QColor defaultColor(int style) const;
bool defaultEolFill(int style) const;
QFont defaultFont(int style) const;
QColor defaultPaper(int style) const;
const char *keywords(int set) const;
QString description(int style) const;
void refreshProperties();
void setHighlightComments(bool highlight);
bool highlightComments() const;
void setHighlightEscapeSequences(bool highlight);
bool highlightEscapeSequences() const;
void setFoldCompact(bool fold);
bool foldCompact() const;
protected:
bool readProperties(QSettings &qs,const QString &prefix);
bool writeProperties(QSettings &qs,const QString &prefix) const;
private:
QsciLexerJSON(const QsciLexerJSON &);
};

79
third_party/qscintilla/Python/sip/qscilexerlua.sip vendored
View File

@@ -1,79 +0,0 @@
// This is the SIP interface definition for QsciLexerLua.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerLua : QsciLexer
{
%TypeHeaderCode
#include <Qsci/qscilexerlua.h>
%End
public:
enum {
Default,
Comment,
LineComment,
Number,
Keyword,
String,
Character,
LiteralString,
Preprocessor,
Operator,
Identifier,
UnclosedString,
BasicFunctions,
StringTableMathsFunctions,
CoroutinesIOSystemFacilities,
KeywordSet5,
KeywordSet6,
KeywordSet7,
KeywordSet8,
Label,
};
QsciLexerLua(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerLua();
const char *language() const;
const char *lexer() const;
QColor defaultColor(int style) const;
bool defaultEolFill(int style) const;
QFont defaultFont(int style) const;
QColor defaultPaper(int style) const;
const char *keywords(int set) const;
QString description(int style) const;
QStringList autoCompletionWordSeparators() const;
const char *blockStart(int *style = 0) const /Encoding="None"/;
int braceStyle() const;
void refreshProperties();
bool foldCompact() const;
public slots:
virtual void setFoldCompact(bool fold);
protected:
bool readProperties(QSettings &qs, const QString &prefix);
bool writeProperties(QSettings &qs, const QString &prefix) const;
private:
QsciLexerLua(const QsciLexerLua &);
};

52
third_party/qscintilla/Python/sip/qscilexermakefile.sip vendored
View File

@@ -1,52 +0,0 @@
// This is the SIP interface definition for QsciLexerMakefile.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerMakefile : QsciLexer
{
%TypeHeaderCode
#include <Qsci/qscilexermakefile.h>
%End
public:
enum {
Default,
Comment,
Preprocessor,
Variable,
Operator,
Target,
Error
};
QsciLexerMakefile(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerMakefile();
const char *language() const;
const char *lexer() const;
QColor defaultColor(int style) const;
bool defaultEolFill(int style) const;
QFont defaultFont(int style) const;
QColor defaultPaper(int style) const;
QString description(int style) const;
const char *wordCharacters() const;
private:
QsciLexerMakefile(const QsciLexerMakefile &);
};

65
third_party/qscintilla/Python/sip/qscilexermarkdown.sip vendored
View File

@@ -1,65 +0,0 @@
// This is the SIP interface definition for QsciLexerMarkdown.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerMarkdown : QsciLexer
{
%TypeHeaderCode
#include <Qsci/qscilexermarkdown.h>
%End
public:
enum {
Default,
Special,
StrongEmphasisAsterisks,
StrongEmphasisUnderscores,
EmphasisAsterisks,
EmphasisUnderscores,
Header1,
Header2,
Header3,
Header4,
Header5,
Header6,
Prechar,
UnorderedListItem,
OrderedListItem,
BlockQuote,
StrikeOut,
HorizontalRule,
Link,
CodeBackticks,
CodeDoubleBackticks,
CodeBlock,
};
QsciLexerMarkdown(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerMarkdown();
const char *language() const;
const char *lexer() const;
QColor defaultColor(int style) const;
QFont defaultFont(int style) const;
QColor defaultPaper(int style) const;
QString description(int style) const;
private:
QsciLexerMarkdown(const QsciLexerMarkdown &);
};

36
third_party/qscintilla/Python/sip/qscilexermasm.sip vendored
View File

@@ -1,36 +0,0 @@
// This is the SIP interface definition for QsciLexerMASM.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerMASM : QsciLexerAsm
{
%TypeHeaderCode
#include <Qsci/qscilexermasm.h>
%End
public:
QsciLexerMASM(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerMASM();
const char *language() const;
const char *lexer() const;
private:
QsciLexerMASM(const QsciLexerMASM &);
};

52
third_party/qscintilla/Python/sip/qscilexermatlab.sip vendored
View File

@@ -1,52 +0,0 @@
// This is the SIP interface definition for QsciLexerMatlab.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerMatlab : QsciLexer
{
%TypeHeaderCode
#include <Qsci/qscilexermatlab.h>
%End
public:
enum {
Default,
Comment,
Command,
Number,
Keyword,
SingleQuotedString,
Operator,
Identifier,
DoubleQuotedString
};
QsciLexerMatlab(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerMatlab();
const char *language() const;
const char *lexer() const;
QColor defaultColor(int style) const;
QFont defaultFont(int style) const;
const char *keywords(int set) const;
QString description(int style) const;
private:
QsciLexerMatlab(const QsciLexerMatlab &);
};

36
third_party/qscintilla/Python/sip/qscilexernasm.sip vendored
View File

@@ -1,36 +0,0 @@
// This is the SIP interface definition for QsciLexerNASM.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerNASM : QsciLexerAsm
{
%TypeHeaderCode
#include <Qsci/qscilexernasm.h>
%End
public:
QsciLexerNASM(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerNASM();
const char *language() const;
const char *lexer() const;
private:
QsciLexerNASM(const QsciLexerNASM &);
};

37
third_party/qscintilla/Python/sip/qscilexeroctave.sip vendored
View File

@@ -1,37 +0,0 @@
// This is the SIP interface definition for QsciLexerOctave.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerOctave : QsciLexerMatlab
{
%TypeHeaderCode
#include <Qsci/qscilexeroctave.h>
%End
public:
QsciLexerOctave(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerOctave();
const char *language() const;
const char *lexer() const;
const char *keywords(int set) const;
private:
QsciLexerOctave(const QsciLexerOctave &);
};

82
third_party/qscintilla/Python/sip/qscilexerpascal.sip vendored
View File

@@ -1,82 +0,0 @@
// This is the SIP interface definition for QsciLexerPascal.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerPascal : QsciLexer
{
%TypeHeaderCode
#include <Qsci/qscilexerpascal.h>
%End
public:
enum {
Default,
Identifier,
Comment,
CommentParenthesis,
CommentLine,
PreProcessor,
PreProcessorParenthesis,
Number,
HexNumber,
Keyword,
SingleQuotedString,
UnclosedString,
Character,
Operator,
Asm,
};
QsciLexerPascal(QObject *parent /TransferThis/ = 0);
const char *language() const;
const char *lexer() const;
QColor defaultColor(int style) const;
bool defaultEolFill(int style) const;
QFont defaultFont(int style) const;
QColor defaultPaper(int style) const;
const char *keywords(int set) const;
QString description(int style) const;
QStringList autoCompletionWordSeparators() const;
const char *blockEnd(int *style = 0) const /Encoding="None"/;
const char *blockStart(int *style = 0) const /Encoding="None"/;
const char *blockStartKeyword(int *style = 0) const /Encoding="None"/;
int braceStyle() const;
void refreshProperties();
bool foldComments() const;
bool foldCompact() const;
bool foldPreprocessor() const;
void setSmartHighlighting(bool enabled);
bool smartHighlighting() const;
public slots:
virtual void setFoldComments(bool fold);
virtual void setFoldCompact(bool fold);
virtual void setFoldPreprocessor(bool fold);
protected:
bool readProperties(QSettings &qs, const QString &prefix);
bool writeProperties(QSettings &qs, const QString &prefix) const;
private:
QsciLexerPascal(const QsciLexerPascal &);
};

111
third_party/qscintilla/Python/sip/qscilexerperl.sip vendored
View File

@@ -1,111 +0,0 @@
// This is the SIP interface definition for QsciLexerPerl.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerPerl : QsciLexer
{
%TypeHeaderCode
#include <Qsci/qscilexerperl.h>
%End
public:
enum {
Default,
Error,
Comment,
POD,
Number,
Keyword,
DoubleQuotedString,
SingleQuotedString,
Operator,
Identifier,
Scalar,
Array,
Hash,
SymbolTable,
Regex,
Substitution,
Backticks,
DataSection,
HereDocumentDelimiter,
SingleQuotedHereDocument,
DoubleQuotedHereDocument,
BacktickHereDocument,
QuotedStringQ,
QuotedStringQQ,
QuotedStringQX,
QuotedStringQR,
QuotedStringQW,
PODVerbatim,
SubroutinePrototype,
FormatIdentifier,
FormatBody,
DoubleQuotedStringVar,
Translation,
RegexVar,
SubstitutionVar,
BackticksVar,
DoubleQuotedHereDocumentVar,
BacktickHereDocumentVar,
QuotedStringQQVar,
QuotedStringQXVar,
QuotedStringQRVar,
};
QsciLexerPerl(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerPerl();
const char *language() const;
const char *lexer() const;
QColor defaultColor(int style) const;
bool defaultEolFill(int style) const;
QFont defaultFont(int style) const;
QColor defaultPaper(int style) const;
const char *keywords(int set) const;
QString description(int style) const;
const char *wordCharacters() const;
QStringList autoCompletionWordSeparators() const;
const char *blockEnd(int *style = 0) const /Encoding="None"/;
const char *blockStart(int *style = 0) const /Encoding="None"/;
int braceStyle() const;
void refreshProperties();
bool foldComments() const;
bool foldCompact() const;
void setFoldAtElse(bool fold);
bool foldAtElse() const;
void setFoldPackages(bool fold);
bool foldPackages() const;
void setFoldPODBlocks(bool fold);
bool foldPODBlocks() const;
public slots:
virtual void setFoldComments(bool fold);
virtual void setFoldCompact(bool fold);
protected:
bool readProperties(QSettings &qs, const QString &prefix);
bool writeProperties(QSettings &qs, const QString &prefix) const;
private:
QsciLexerPerl(const QsciLexerPerl &);
};

69
third_party/qscintilla/Python/sip/qscilexerpo.sip vendored
View File

@@ -1,69 +0,0 @@
// This is the SIP interface definition for QsciLexerPO.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerPO : QsciLexer
{
%TypeHeaderCode
#include <Qsci/qscilexerpo.h>
%End
public:
enum {
Default,
Comment,
MessageId,
MessageIdText,
MessageString,
MessageStringText,
MessageContext,
MessageContextText,
Fuzzy,
ProgrammerComment,
Reference,
Flags,
MessageIdTextEOL,
MessageStringTextEOL,
MessageContextTextEOL
};
QsciLexerPO(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerPO();
const char *language() const;
const char *lexer() const;
QColor defaultColor(int style) const;
QFont defaultFont(int style) const;
QString description(int style) const;
void refreshProperties();
bool foldComments() const;
bool foldCompact() const;
public slots:
virtual void setFoldComments(bool fold);
virtual void setFoldCompact(bool fold);
protected:
bool readProperties(QSettings &qs, const QString &prefix);
bool writeProperties(QSettings &qs, const QString &prefix) const;
private:
QsciLexerPO(const QsciLexerPO &);
};

78
third_party/qscintilla/Python/sip/qscilexerpostscript.sip vendored
View File

@@ -1,78 +0,0 @@
// This is the SIP interface definition for QsciLexerPostScript.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerPostScript : QsciLexer
{
%TypeHeaderCode
#include <Qsci/qscilexerpostscript.h>
%End
public:
enum {
Default,
Comment,
DSCComment,
DSCCommentValue,
Number,
Name,
Keyword,
Literal,
ImmediateEvalLiteral,
ArrayParenthesis,
DictionaryParenthesis,
ProcedureParenthesis,
Text,
HexString,
Base85String,
BadStringCharacter
};
QsciLexerPostScript(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerPostScript();
const char *language() const;
const char *lexer() const;
QColor defaultColor(int style) const;
QFont defaultFont(int style) const;
QColor defaultPaper(int style) const;
const char *keywords(int set) const;
QString description(int style) const;
int braceStyle() const;
void refreshProperties();
bool tokenize() const;
int level() const;
bool foldCompact() const;
bool foldAtElse() const;
public slots:
virtual void setTokenize(bool tokenize);
virtual void setLevel(int level);
virtual void setFoldCompact(bool fold);
virtual void setFoldAtElse(bool fold);
protected:
bool readProperties(QSettings &qs, const QString &prefix);
bool writeProperties(QSettings &qs, const QString &prefix) const;
private:
QsciLexerPostScript(const QsciLexerPostScript &);
};

79
third_party/qscintilla/Python/sip/qscilexerpov.sip vendored
View File

@@ -1,79 +0,0 @@
// This is the SIP interface definition for QsciLexerPOV.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerPOV : QsciLexer
{
%TypeHeaderCode
#include <Qsci/qscilexerpov.h>
%End
public:
enum {
Default,
Comment,
CommentLine,
Number,
Operator,
Identifier,
String,
UnclosedString,
Directive,
BadDirective,
ObjectsCSGAppearance,
TypesModifiersItems,
PredefinedIdentifiers,
PredefinedFunctions,
KeywordSet6,
KeywordSet7,
KeywordSet8
};
QsciLexerPOV(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerPOV();
const char *language() const;
const char *lexer() const;
QColor defaultColor(int style) const;
bool defaultEolFill(int style) const;
QFont defaultFont(int style) const;
QColor defaultPaper(int style) const;
const char *keywords(int set) const;
QString description(int style) const;
const char *wordCharacters() const;
int braceStyle() const;
void refreshProperties();
bool foldComments() const;
bool foldCompact() const;
bool foldDirectives() const;
public slots:
virtual void setFoldComments(bool fold);
virtual void setFoldCompact(bool fold);
virtual void setFoldDirectives(bool fold);
protected:
bool readProperties(QSettings &qs, const QString &prefix);
bool writeProperties(QSettings &qs, const QString &prefix) const;
private:
QsciLexerPOV(const QsciLexerPOV &);
};

63
third_party/qscintilla/Python/sip/qscilexerproperties.sip vendored
View File

@@ -1,63 +0,0 @@
// This is the SIP interface definition for QsciLexerProperties.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerProperties : QsciLexer
{
%TypeHeaderCode
#include <Qsci/qscilexerproperties.h>
%End
public:
enum {
Default,
Comment,
Section,
Assignment,
DefaultValue,
Key
};
QsciLexerProperties(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerProperties();
const char *language() const;
const char *lexer() const;
QColor defaultColor(int style) const;
bool defaultEolFill(int style) const;
QFont defaultFont(int style) const;
QColor defaultPaper(int style) const;
QString description(int style) const;
const char *wordCharacters() const;
void refreshProperties();
bool foldCompact() const;
void setInitialSpaces(bool enable);
bool initialSpaces() const;
public slots:
virtual void setFoldCompact(bool fold);
protected:
bool readProperties(QSettings &qs, const QString &prefix);
bool writeProperties(QSettings &qs, const QString &prefix) const;
private:
QsciLexerProperties(const QsciLexerProperties &);
};

105
third_party/qscintilla/Python/sip/qscilexerpython.sip vendored
View File

@@ -1,105 +0,0 @@
// This is the SIP interface definition for QsciLexerPython.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerPython : QsciLexer
{
%TypeHeaderCode
#include <Qsci/qscilexerpython.h>
%End
public:
enum {
Default,
Comment,
Number,
DoubleQuotedString,
SingleQuotedString,
Keyword,
TripleSingleQuotedString,
TripleDoubleQuotedString,
ClassName,
FunctionMethodName,
Operator,
Identifier,
CommentBlock,
UnclosedString,
HighlightedIdentifier,
Decorator,
DoubleQuotedFString,
SingleQuotedFString,
TripleSingleQuotedFString,
TripleDoubleQuotedFString,
};
enum IndentationWarning {
NoWarning,
Inconsistent,
TabsAfterSpaces,
Spaces,
Tabs
};
QsciLexerPython(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerPython();
const char *language() const;
const char *lexer() const;
QColor defaultColor(int style) const;
bool defaultEolFill(int style) const;
QFont defaultFont(int style) const;
QColor defaultPaper(int style) const;
const char *keywords(int set) const;
QString description(int style) const;
QStringList autoCompletionWordSeparators() const;
int blockLookback() const;
const char *blockStart(int *style = 0) const /Encoding="None"/;
int braceStyle() const;
int indentationGuideView() const;
void refreshProperties();
bool foldComments() const;
void setFoldCompact(bool fold);
bool foldCompact() const;
bool foldQuotes() const;
QsciLexerPython::IndentationWarning indentationWarning() const;
void setHighlightSubidentifiers(bool enabled);
bool highlightSubidentifiers() const;
void setStringsOverNewlineAllowed(bool allowed);
bool stringsOverNewlineAllowed() const;
void setV2UnicodeAllowed(bool allowed);
bool v2UnicodeAllowed() const;
void setV3BinaryOctalAllowed(bool allowed);
bool v3BinaryOctalAllowed() const;
void setV3BytesAllowed(bool allowed);
bool v3BytesAllowed() const;
public slots:
virtual void setFoldComments(bool fold);
virtual void setFoldQuotes(bool fold);
virtual void setIndentationWarning(QsciLexerPython::IndentationWarning warn);
protected:
bool readProperties(QSettings &qs, const QString &prefix);
bool writeProperties(QSettings &qs, const QString &prefix) const;
private:
QsciLexerPython(const QsciLexerPython &);
};

91
third_party/qscintilla/Python/sip/qscilexerruby.sip vendored
View File

@@ -1,91 +0,0 @@
// This is the SIP interface definition for QsciLexerRuby.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerRuby : QsciLexer
{
%TypeHeaderCode
#include <Qsci/qscilexerruby.h>
%End
public:
enum {
Default,
Error,
Comment,
POD,
Number,
Keyword,
DoubleQuotedString,
SingleQuotedString,
ClassName,
FunctionMethodName,
Operator,
Identifier,
Regex,
Global,
Symbol,
ModuleName,
InstanceVariable,
ClassVariable,
Backticks,
DataSection,
HereDocumentDelimiter,
HereDocument,
PercentStringq,
PercentStringQ,
PercentStringx,
PercentStringr,
PercentStringw,
DemotedKeyword,
Stdin,
Stdout,
Stderr
};
QsciLexerRuby(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerRuby();
const char *language() const;
const char *lexer() const;
QColor defaultColor(int style) const;
bool defaultEolFill(int style) const;
QFont defaultFont(int style) const;
QColor defaultPaper(int style) const;
const char *keywords(int) const;
QString description(int style) const;
const char *blockEnd(int *style = 0) const /Encoding="None"/;
const char *blockStart(int *style = 0) const /Encoding="None"/;
const char *blockStartKeyword(int *style = 0) const /Encoding="None"/;
int braceStyle() const;
void refreshProperties();
void setFoldComments(bool fold);
bool foldComments() const;
void setFoldCompact(bool fold);
bool foldCompact() const;
protected:
bool readProperties(QSettings &qs, const QString &prefix);
bool writeProperties(QSettings &qs, const QString &prefix) const;
private:
QsciLexerRuby(const QsciLexerRuby &);
};

54
third_party/qscintilla/Python/sip/qscilexerspice.sip vendored
View File

@@ -1,54 +0,0 @@
// This is the SIP interface definition for QsciLexerSpice.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerSpice : QsciLexer
{
%TypeHeaderCode
#include <Qsci/qscilexerspice.h>
%End
public:
enum {
Default,
Identifier,
Command,
Function,
Parameter,
Number,
Delimiter,
Value,
Comment
};
QsciLexerSpice(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerSpice();
const char *language() const;
const char *lexer() const;
const char *keywords(int set) const;
QColor defaultColor(int style) const;
QFont defaultFont(int style) const;
QString description(int style) const;
int braceStyle() const;
private:
QsciLexerSpice(const QsciLexerSpice &);
};

93
third_party/qscintilla/Python/sip/qscilexersql.sip vendored
View File

@@ -1,93 +0,0 @@
// This is the SIP interface definition for QsciLexerSQL.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerSQL : QsciLexer
{
%TypeHeaderCode
#include <Qsci/qscilexersql.h>
%End
public:
enum {
Default,
Comment,
CommentLine,
CommentDoc,
Number,
Keyword,
DoubleQuotedString,
SingleQuotedString,
PlusKeyword,
PlusPrompt,
Operator,
Identifier,
PlusComment,
CommentLineHash,
CommentDocKeyword,
CommentDocKeywordError,
KeywordSet5,
KeywordSet6,
KeywordSet7,
KeywordSet8,
QuotedIdentifier,
QuotedOperator,
};
QsciLexerSQL(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerSQL();
const char *language() const;
const char *lexer() const;
QColor defaultColor(int style) const;
bool defaultEolFill(int style) const;
QFont defaultFont(int style) const;
QColor defaultPaper(int style) const;
const char *keywords(int set) const;
QString description(int style) const;
int braceStyle() const;
void refreshProperties();
bool backslashEscapes() const;
void setDottedWords(bool enable);
bool dottedWords() const;
void setFoldAtElse(bool fold);
bool foldAtElse() const;
bool foldComments() const;
bool foldCompact() const;
void setFoldOnlyBegin(bool fold);
bool foldOnlyBegin() const;
void setHashComments(bool enable);
bool hashComments() const;
void setQuotedIdentifiers(bool enable);
bool quotedIdentifiers() const;
public slots:
virtual void setBackslashEscapes(bool enable);
virtual void setFoldComments(bool fold);
virtual void setFoldCompact(bool fold);
protected:
bool readProperties(QSettings &qs, const QString &prefix);
bool writeProperties(QSettings &qs, const QString &prefix) const;
private:
QsciLexerSQL(const QsciLexerSQL &);
};

37
third_party/qscintilla/Python/sip/qscilexersrec.sip vendored
View File

@@ -1,37 +0,0 @@
// This is the SIP interface definition for QsciLexerSRec.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerSRec : QsciLexerHex
{
%TypeHeaderCode
#include <Qsci/qscilexersrec.h>
%End
public:
QsciLexerSRec(QObject *parent = 0);
virtual ~QsciLexerSRec();
const char *language() const;
const char *lexer() const;
QString description(int style) const;
private:
QsciLexerSRec(const QsciLexerSRec &);
};

77
third_party/qscintilla/Python/sip/qscilexertcl.sip vendored
View File

@@ -1,77 +0,0 @@
// This is the SIP interface definition for QsciLexerTCL.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerTCL : QsciLexer
{
%TypeHeaderCode
#include <Qsci/qscilexertcl.h>
%End
public:
enum {
Default,
Comment,
CommentLine,
Number,
QuotedKeyword,
QuotedString,
Operator,
Identifier,
Substitution,
SubstitutionBrace,
Modifier,
ExpandKeyword,
TCLKeyword,
TkKeyword,
ITCLKeyword,
TkCommand,
KeywordSet6,
KeywordSet7,
KeywordSet8,
KeywordSet9,
CommentBox,
CommentBlock
};
QsciLexerTCL(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerTCL();
const char *language() const;
const char *lexer() const;
QColor defaultColor(int style) const;
bool defaultEolFill(int style) const;
QFont defaultFont(int style) const;
QColor defaultPaper(int style) const;
const char *keywords(int set) const;
QString description(int style) const;
int braceStyle() const;
void refreshProperties();
void setFoldComments(bool fold);
bool foldComments() const;
protected:
bool readProperties(QSettings &qs, const QString &prefix);
bool writeProperties(QSettings &qs, const QString &prefix) const;
private:
QsciLexerTCL(const QsciLexerTCL &);
};

37
third_party/qscintilla/Python/sip/qscilexertekhex.sip vendored
View File

@@ -1,37 +0,0 @@
// This is the SIP interface definition for QsciLexerTekHex.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerTekHex : QsciLexerHex
{
%TypeHeaderCode
#include <Qsci/qscilexertekhex.h>
%End
public:
QsciLexerTekHex(QObject *parent = 0);
virtual ~QsciLexerTekHex();
const char *language() const;
const char *lexer() const;
QString description(int style) const;
private:
QsciLexerTekHex(const QsciLexerTekHex &);
};

63
third_party/qscintilla/Python/sip/qscilexertex.sip vendored
View File

@@ -1,63 +0,0 @@
// This is the SIP interface definition for QsciLexerTeX.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerTeX : QsciLexer
{
%TypeHeaderCode
#include <Qsci/qscilexertex.h>
%End
public:
enum {
Default,
Special,
Group,
Symbol,
Command,
Text
};
QsciLexerTeX(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerTeX();
const char *language() const;
const char *lexer() const;
QColor defaultColor(int style) const;
const char *keywords(int set) const;
QString description(int style) const;
const char *wordCharacters() const;
void refreshProperties();
void setFoldComments(bool fold);
bool foldComments() const;
void setFoldCompact(bool fold);
bool foldCompact() const;
void setProcessComments(bool enable);
bool processComments() const;
void setProcessIf(bool enable);
bool processIf() const;
protected:
bool readProperties(QSettings &qs, const QString &prefix);
bool writeProperties(QSettings &qs, const QString &prefix) const;
private:
QsciLexerTeX(const QsciLexerTeX &);
};

106
third_party/qscintilla/Python/sip/qscilexerverilog.sip vendored
View File

@@ -1,106 +0,0 @@
// This is the SIP interface definition for QsciLexerVerilog.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerVerilog : QsciLexer
{
%TypeHeaderCode
#include <Qsci/qscilexerverilog.h>
%End
public:
enum {
Default,
InactiveDefault,
Comment,
InactiveComment,
CommentLine,
InactiveCommentLine,
CommentBang,
InactiveCommentBang,
Number,
InactiveNumber,
Keyword,
InactiveKeyword,
String,
InactiveString,
KeywordSet2,
InactiveKeywordSet2,
SystemTask,
InactiveSystemTask,
Preprocessor,
InactivePreprocessor,
Operator,
InactiveOperator,
Identifier,
InactiveIdentifier,
UnclosedString,
InactiveUnclosedString,
UserKeywordSet,
InactiveUserKeywordSet,
CommentKeyword,
InactiveCommentKeyword,
DeclareInputPort,
InactiveDeclareInputPort,
DeclareOutputPort,
InactiveDeclareOutputPort,
DeclareInputOutputPort,
InactiveDeclareInputOutputPort,
PortConnection,
InactivePortConnection,
};
QsciLexerVerilog(QObject *parent /TransferThis/ = 0);
const char *language() const;
const char *lexer() const;
QColor defaultColor(int style) const;
bool defaultEolFill(int style) const;
QFont defaultFont(int style) const;
QColor defaultPaper(int style) const;
const char *keywords(int set) const;
QString description(int style) const;
const char *wordCharacters() const;
int braceStyle() const;
void refreshProperties();
void setFoldAtElse(bool fold);
bool foldAtElse() const;
void setFoldComments(bool fold);
bool foldComments() const;
void setFoldCompact(bool fold);
bool foldCompact() const;
void setFoldPreprocessor(bool fold);
bool foldPreprocessor() const;
void setFoldAtModule(bool fold);
bool foldAtModule() const;
protected:
bool readProperties(QSettings &qs, const QString &prefix);
bool writeProperties(QSettings &qs, const QString &prefix) const;
private:
QsciLexerVerilog(const QsciLexerVerilog &);
};

81
third_party/qscintilla/Python/sip/qscilexervhdl.sip vendored
View File

@@ -1,81 +0,0 @@
// This is the SIP interface definition for QsciLexerVHDL.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerVHDL : QsciLexer
{
%TypeHeaderCode
#include <Qsci/qscilexervhdl.h>
%End
public:
enum {
Default,
Comment,
CommentLine,
Number,
String,
Operator,
Identifier,
UnclosedString,
Keyword,
StandardOperator,
Attribute,
StandardFunction,
StandardPackage,
StandardType,
KeywordSet7,
CommentBlock
};
QsciLexerVHDL(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerVHDL();
const char *language() const;
const char *lexer() const;
QColor defaultColor(int style) const;
bool defaultEolFill(int style) const;
QFont defaultFont(int style) const;
QColor defaultPaper(int style) const;
const char *keywords(int set) const;
QString description(int style) const;
int braceStyle() const;
void refreshProperties();
bool foldComments() const;
bool foldCompact() const;
bool foldAtElse() const;
bool foldAtBegin() const;
bool foldAtParenthesis() const;
public slots:
virtual void setFoldComments(bool fold);
virtual void setFoldCompact(bool fold);
virtual void setFoldAtElse(bool fold);
virtual void setFoldAtBegin(bool fold);
virtual void setFoldAtParenthesis(bool fold);
protected:
bool readProperties(QSettings &qs, const QString &prefix);
bool writeProperties(QSettings &qs, const QString &prefix) const;
private:
QsciLexerVHDL(const QsciLexerVHDL &);
};

49
third_party/qscintilla/Python/sip/qscilexerxml.sip vendored
View File

@@ -1,49 +0,0 @@
// This is the SIP interface definition for QsciLexerXML.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerXML : QsciLexerHTML
{
%TypeHeaderCode
#include <Qsci/qscilexerxml.h>
%End
public:
QsciLexerXML(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerXML();
const char *language() const;
const char *lexer() const;
QColor defaultColor(int style) const;
bool defaultEolFill(int style) const;
QFont defaultFont(int style) const;
QColor defaultPaper(int style) const;
const char *keywords(int set) const;
void refreshProperties();
void setScriptsStyled(bool styled);
bool scriptsStyled() const;
protected:
bool readProperties(QSettings &qs, const QString &prefix);
bool writeProperties(QSettings &qs, const QString &prefix) const;
private:
QsciLexerXML(const QsciLexerXML &);
};

65
third_party/qscintilla/Python/sip/qscilexeryaml.sip vendored
View File

@@ -1,65 +0,0 @@
// This is the SIP interface definition for QsciLexerYAML.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciLexerYAML : QsciLexer
{
%TypeHeaderCode
#include <Qsci/qscilexeryaml.h>
%End
public:
enum {
Default,
Comment,
Identifier,
Keyword,
Number,
Reference,
DocumentDelimiter,
TextBlockMarker,
SyntaxErrorMarker,
Operator
};
QsciLexerYAML(QObject *parent /TransferThis/ = 0);
virtual ~QsciLexerYAML();
const char *language() const;
const char *lexer() const;
QColor defaultColor(int style) const;
bool defaultEolFill(int style) const;
QFont defaultFont(int style) const;
QColor defaultPaper(int style) const;
const char *keywords(int set) const;
QString description(int style) const;
void refreshProperties();
bool foldComments() const;
public slots:
virtual void setFoldComments(bool fold);
protected:
bool readProperties(QSettings &qs, const QString &prefix);
bool writeProperties(QSettings &qs, const QString &prefix) const;
private:
QsciLexerYAML(const QsciLexerYAML &);
};

44
third_party/qscintilla/Python/sip/qscimacro.sip vendored
View File

@@ -1,44 +0,0 @@
// This is the SIP interface definition for QsciMacro.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciMacro : QObject
{
%TypeHeaderCode
#include <Qsci/qscimacro.h>
%End
public:
QsciMacro(QsciScintilla *parent /TransferThis/);
QsciMacro(const QString &asc, QsciScintilla *parent /TransferThis/);
virtual ~QsciMacro();
void clear();
bool load(const QString &asc);
QString save() const;
public slots:
virtual void play();
virtual void startRecording();
virtual void endRecording();
private:
QsciMacro(const QsciMacro &);
};

23
third_party/qscintilla/Python/sip/qscimod5.sip vendored
View File

@@ -1,23 +0,0 @@
// This is the SIP interface definition for the Qsci module of PyQt5.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
%Module(name=PyQt5.Qsci, keyword_arguments="Optional", use_limited_api=True)
%Include qscimodcommon.sip

23
third_party/qscintilla/Python/sip/qscimod6.sip vendored
View File

@@ -1,23 +0,0 @@
// This is the SIP interface definition for the Qsci module of PyQt6.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
%Module(name=PyQt6.Qsci, keyword_arguments="Optional", use_limited_api=True)
%Include qscimodcommon.sip

112
third_party/qscintilla/Python/sip/qscimodcommon.sip vendored
View File

@@ -1,112 +0,0 @@
// This is the SIP interface definition for the parts of the Qsci module common
// to PyQt5 and PyQt6.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
%Copying
Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
This file is part of QScintilla.
This file may be used under the terms of the GNU General Public License
version 3.0 as published by the Free Software Foundation and appearing in
the file LICENSE included in the packaging of this file. Please review the
following information to ensure the GNU General Public License version 3.0
requirements will be met: http://www.gnu.org/copyleft/gpl.html.
If you do not wish to use this file under the terms of the GPL version 3.0
then you may purchase a commercial license. For more information contact
info@riverbankcomputing.com.
This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
%End
%Import QtCore/QtCoremod.sip
%Import QtGui/QtGuimod.sip
%Import QtWidgets/QtWidgetsmod.sip
%If (PyQt_Printer)
%Import QtPrintSupport/QtPrintSupportmod.sip
%End
const int QSCINTILLA_VERSION;
const char *QSCINTILLA_VERSION_STR;
%Include qsciscintillabase.sip
%Include qsciscintilla.sip
%Include qsciabstractapis.sip
%Include qsciapis.sip
%Include qscicommand.sip
%Include qscicommandset.sip
%Include qscidocument.sip
%Include qscilexer.sip
%Include qscilexerasm.sip
%Include qscilexeravs.sip
%Include qscilexerbash.sip
%Include qscilexerbatch.sip
%Include qscilexercmake.sip
%Include qscilexercoffeescript.sip
%Include qscilexercpp.sip
%Include qscilexercsharp.sip
%Include qscilexercss.sip
%Include qscilexercustom.sip
%Include qscilexerd.sip
%Include qscilexerdiff.sip
%Include qscilexerfortran.sip
%Include qscilexerfortran77.sip
%Include qscilexerhex.sip
%Include qscilexerhtml.sip
%Include qscilexeridl.sip
%Include qscilexerintelhex.sip
%Include qscilexerjava.sip
%Include qscilexerjavascript.sip
%Include qscilexerjson.sip
%Include qscilexerlua.sip
%Include qscilexermakefile.sip
%Include qscilexermarkdown.sip
%Include qscilexermasm.sip
%Include qscilexermatlab.sip
%Include qscilexernasm.sip
%Include qscilexeroctave.sip
%Include qscilexerpascal.sip
%Include qscilexerperl.sip
%Include qscilexerpostscript.sip
%Include qscilexerpo.sip
%Include qscilexerpov.sip
%Include qscilexerproperties.sip
%Include qscilexerpython.sip
%Include qscilexerruby.sip
%Include qscilexerspice.sip
%Include qscilexersql.sip
%Include qscilexersrec.sip
%Include qscilexertcl.sip
%Include qscilexertekhex.sip
%Include qscilexertex.sip
%Include qscilexerverilog.sip
%Include qscilexervhdl.sip
%Include qscilexerxml.sip
%Include qscilexeryaml.sip
%Include qscimacro.sip
%Include qsciprinter.sip
%Include qscistyle.sip
%Include qscistyledtext.sip

47
third_party/qscintilla/Python/sip/qsciprinter.sip vendored
View File

@@ -1,47 +0,0 @@
// This is the SIP interface definition for QsciPrinter.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
%If (PyQt_Printer)
class QsciPrinter : QPrinter
{
%TypeHeaderCode
#include <Qsci/qsciprinter.h>
%End
public:
QsciPrinter(QPrinter::PrinterMode mode = QPrinter::ScreenResolution);
virtual ~QsciPrinter();
virtual void formatPage(QPainter &painter, bool drawing, QRect &area,
int pagenr);
int magnification() const;
virtual void setMagnification(int magnification);
virtual int printRange(QsciScintillaBase *qsb, QPainter &painter,
int from = -1, int to = -1);
virtual int printRange(QsciScintillaBase *qsb, int from = -1, int to = -1);
QsciScintilla::WrapMode wrapMode() const;
virtual void setWrapMode(QsciScintilla::WrapMode);
private:
QsciPrinter(const QsciPrinter &);
};
%End

557
third_party/qscintilla/Python/sip/qsciscintilla.sip vendored
View File

@@ -1,557 +0,0 @@
// This is the SIP interface definition for QsciScintilla.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciScintilla : QsciScintillaBase
{
%TypeHeaderCode
#include <Qsci/qsciscintilla.h>
%End
public:
enum {
AiMaintain,
AiOpening,
AiClosing
};
enum AnnotationDisplay {
AnnotationHidden,
AnnotationStandard,
AnnotationBoxed,
AnnotationIndented,
};
enum AutoCompletionSource {
AcsNone,
AcsAll,
AcsDocument,
AcsAPIs
};
enum AutoCompletionUseSingle {
AcusNever,
AcusExplicit,
AcusAlways
};
enum BraceMatch {
NoBraceMatch,
StrictBraceMatch,
SloppyBraceMatch
};
enum CallTipsPosition {
CallTipsBelowText,
CallTipsAboveText,
};
enum CallTipsStyle {
CallTipsNone,
CallTipsNoContext,
CallTipsNoAutoCompletionContext,
CallTipsContext
};
enum EdgeMode {
EdgeNone,
EdgeLine,
EdgeBackground,
EdgeMultipleLines,
};
enum EolMode {
EolWindows,
EolUnix,
EolMac
};
enum FoldStyle {
NoFoldStyle,
PlainFoldStyle,
CircledFoldStyle,
BoxedFoldStyle,
CircledTreeFoldStyle,
BoxedTreeFoldStyle
};
enum IndicatorStyle {
PlainIndicator,
SquiggleIndicator,
TTIndicator,
DiagonalIndicator,
StrikeIndicator,
HiddenIndicator,
BoxIndicator,
RoundBoxIndicator,
StraightBoxIndicator,
FullBoxIndicator,
DashesIndicator,
DotsIndicator,
SquiggleLowIndicator,
DotBoxIndicator,
SquigglePixmapIndicator,
ThickCompositionIndicator,
ThinCompositionIndicator,
TextColorIndicator,
TriangleIndicator,
TriangleCharacterIndicator,
GradientIndicator,
CentreGradientIndicator,
};
enum {
MoNone,
MoSublineSelect,
};
enum MarginType {
SymbolMargin,
SymbolMarginDefaultForegroundColor,
SymbolMarginDefaultBackgroundColor,
NumberMargin,
TextMargin,
TextMarginRightJustified,
SymbolMarginColor,
};
enum MarkerSymbol {
Circle,
Rectangle,
RightTriangle,
SmallRectangle,
RightArrow,
Invisible,
DownTriangle,
Minus,
Plus,
VerticalLine,
BottomLeftCorner,
LeftSideSplitter,
BoxedPlus,
BoxedPlusConnected,
BoxedMinus,
BoxedMinusConnected,
RoundedBottomLeftCorner,
LeftSideRoundedSplitter,
CircledPlus,
CircledPlusConnected,
CircledMinus,
CircledMinusConnected,
Background,
ThreeDots,
ThreeRightArrows,
FullRectangle,
LeftRectangle,
Underline,
Bookmark
};
enum TabDrawMode {
TabLongArrow,
TabStrikeOut,
};
enum WhitespaceVisibility {
WsInvisible,
WsVisible,
WsVisibleAfterIndent,
WsVisibleOnlyInIndent,
};
enum WrapMode {
WrapNone,
WrapWord,
WrapCharacter,
WrapWhitespace,
};
enum WrapVisualFlag {
WrapFlagNone,
WrapFlagByText,
WrapFlagByBorder,
WrapFlagInMargin,
};
enum WrapIndentMode {
WrapIndentFixed,
WrapIndentSame,
WrapIndentIndented,
WrapIndentDeeplyIndented,
};
QsciScintilla(QWidget *parent /TransferThis/ = 0);
virtual ~QsciScintilla();
virtual QStringList apiContext(int pos, int &context_start,
int &last_word_start);
void annotate(int line, const QString &text, int style);
void annotate(int line, const QString &text, const QsciStyle &style);
void annotate(int line, const QsciStyledText &text);
void annotate(int line, const QList<QsciStyledText> &text);
QString annotation(int line) const;
AnnotationDisplay annotationDisplay() const;
void clearAnnotations(int line = -1);
bool autoCompletionCaseSensitivity() const;
bool autoCompletionFillupsEnabled() const;
bool autoCompletionReplaceWord() const;
bool autoCompletionShowSingle() const;
AutoCompletionSource autoCompletionSource() const;
int autoCompletionThreshold() const;
AutoCompletionUseSingle autoCompletionUseSingle() const;
bool autoIndent() const;
bool backspaceUnindents() const;
void beginUndoAction();
BraceMatch braceMatching() const;
QByteArray bytes(int start, int end) const;
CallTipsPosition callTipsPosition() const;
CallTipsStyle callTipsStyle() const;
int callTipsVisible() const;
void cancelFind();
void cancelList();
bool caseSensitive() const;
void clearRegisteredImages();
QColor color() const;
QList<int> contractedFolds() const;
void convertEols(EolMode mode);
QMenu *createStandardContextMenu() /Factory/;
QsciDocument document() const;
void endUndoAction();
QColor edgeColor() const;
int edgeColumn() const;
EdgeMode edgeMode() const;
EolMode eolMode() const;
bool eolVisibility() const;
int extraAscent() const;
int extraDescent() const;
virtual bool findFirst(const QString &expr, bool re, bool cs, bool wo,
bool wrap, bool forward = true, int line = -1, int index = -1,
bool show = true, bool posix = false, bool cxx11 = false);
virtual bool findFirstInSelection(const QString &expr, bool re, bool cs,
bool wo, bool forward = true, bool show = true,
bool posix = false, bool cxx11 = false);
virtual bool findNext();
bool findMatchingBrace(long &brace, long &other, BraceMatch mode);
int firstVisibleLine() const;
FoldStyle folding() const;
void getCursorPosition(int *line, int *index) const;
void getSelection(int *lineFrom, int *indexFrom, int *lineTo,
int *indexTo) const;
bool hasSelectedText() const;
int indentation(int line) const;
bool indentationGuides() const;
bool indentationsUseTabs() const;
int indentationWidth() const;
void clearIndicatorRange(int lineFrom, int indexFrom, int lineTo,
int indexTo, int indicatorNumber);
void fillIndicatorRange(int lineFrom, int indexFrom, int lineTo,
int indexTo, int indicatorNumber);
int indicatorDefine(IndicatorStyle style, int indicatorNumber = -1);
bool indicatorDrawUnder(int indicatorNumber) const;
bool isCallTipActive() const;
bool isListActive() const;
bool isModified() const;
bool isReadOnly() const;
bool isRedoAvailable() const;
bool isUndoAvailable() const;
bool isUtf8() const;
bool isWordCharacter(char ch) const;
int lineAt(const QPoint &pos) const;
void lineIndexFromPosition(int position, int *line, int *index) const;
int lineLength(int line) const;
int lines() const;
int length() const;
QsciLexer *lexer() const;
QColor marginBackgroundColor(int margin) const;
bool marginLineNumbers(int margin) const;
int marginMarkerMask(int margin) const;
int marginOptions() const;
bool marginSensitivity(int margin) const;
MarginType marginType(int margin) const;
int marginWidth(int margin) const;
int margins() const;
int markerDefine(MarkerSymbol sym, int markerNumber = -1);
int markerDefine(char ch, int markerNumber = -1);
int markerDefine(const QPixmap &pm, int markerNumber = -1);
int markerDefine(const QImage &im, int markerNumber = -1);
int markerAdd(int linenr, int markerNumber);
unsigned markersAtLine(int linenr) const;
void markerDelete(int linenr, int markerNumber = -1);
void markerDeleteAll(int markerNumber = -1);
void markerDeleteHandle(int mhandle);
int markerLine(int mhandle) const;
int markerFindNext(int linenr, unsigned mask) const;
int markerFindPrevious(int linenr, unsigned mask) const;
bool overwriteMode() const;
QColor paper() const;
int positionFromLineIndex(int line, int index) const;
bool read(QIODevice *io) /ReleaseGIL/;
virtual void recolor(int start = 0, int end = -1);
void registerImage(int id, const QPixmap &pm);
void registerImage(int id, const QImage &im);
virtual void replace(const QString &replaceStr);
void resetFoldMarginColors();
void resetHotspotBackgroundColor();
void resetHotspotForegroundColor();
int scrollWidth() const;
void setScrollWidth(int pixelWidth);
bool scrollWidthTracking() const;
void setScrollWidthTracking(bool enabled);
void setFoldMarginColors(const QColor &fore, const QColor &back);
void setAnnotationDisplay(AnnotationDisplay display);
void setAutoCompletionFillupsEnabled(bool enabled);
void setAutoCompletionFillups(const char *fillups);
void setAutoCompletionWordSeparators(const QStringList &separators);
void setCallTipsBackgroundColor(const QColor &col);
void setCallTipsForegroundColor(const QColor &col);
void setCallTipsHighlightColor(const QColor &col);
void setCallTipsPosition(CallTipsPosition position);
void setCallTipsStyle(CallTipsStyle style);
void setCallTipsVisible(int nr);
void setContractedFolds(const QList<int> &folds);
void setDocument(const QsciDocument &document);
void addEdgeColumn(int colnr, const QColor &col);
void clearEdgeColumns();
void setEdgeColor(const QColor &col);
void setEdgeColumn(int colnr);
void setEdgeMode(EdgeMode mode);
void setFirstVisibleLine(int linenr);
void setFont(const QFont &f);
void setHotspotBackgroundColor(const QColor &col);
void setHotspotForegroundColor(const QColor &col);
void setHotspotUnderline(bool enable);
void setHotspotWrap(bool enable);
void setIndicatorDrawUnder(bool under, int indicatorNumber = -1);
void setIndicatorForegroundColor(const QColor &col,
int indicatorNumber = -1);
void setIndicatorHoverForegroundColor(const QColor &col,
int indicatorNumber = -1);
void setIndicatorHoverStyle(IndicatorStyle style,
int indicatorNumber = -1);
void setIndicatorOutlineColor(const QColor &col, int indicatorNumber = -1);
void setMarginBackgroundColor(int margin, const QColor &col);
void setMarginOptions(int options);
void setMarginText(int line, const QString &text, int style);
void setMarginText(int line, const QString &text, const QsciStyle &style);
void setMarginText(int line, const QsciStyledText &text);
void setMarginText(int line, const QList<QsciStyledText> &text);
void setMarginType(int margin, MarginType type);
void clearMarginText(int line = -1);
void setMargins(int margins);
void setMarkerBackgroundColor(const QColor &col, int markerNumber = -1);
void setMarkerForegroundColor(const QColor &col, int markerNumber = -1);
void setMatchedBraceBackgroundColor(const QColor &col);
void setMatchedBraceForegroundColor(const QColor &col);
void setMatchedBraceIndicator(int indicatorNumber);
void resetMatchedBraceIndicator();
void setUnmatchedBraceBackgroundColor(const QColor &col);
void setUnmatchedBraceForegroundColor(const QColor &col);
void setUnmatchedBraceIndicator(int indicatorNumber);
void resetUnmatchedBraceIndicator();
void setWrapVisualFlags(WrapVisualFlag endFlag,
WrapVisualFlag startFlag = QsciScintilla::WrapFlagNone,
int indent = 0);
QString selectedText() const;
bool selectionToEol() const;
void setSelectionToEol(bool filled);
void setExtraAscent(int extra);
void setExtraDescent(int extra);
void setOverwriteMode(bool overwrite);
void setWhitespaceBackgroundColor(const QColor &col);
void setWhitespaceForegroundColor(const QColor &col);
void setWhitespaceSize(int size);
void setWrapIndentMode(WrapIndentMode mode);
void showUserList(int id, const QStringList &list);
QsciCommandSet *standardCommands() const;
void setTabDrawMode(TabDrawMode mode);
TabDrawMode tabDrawMode() const;
bool tabIndents() const;
int tabWidth() const;
QString text() const;
QString text(int line) const;
QString text(int start, int end) const;
int textHeight(int linenr) const;
int whitespaceSize() const;
WhitespaceVisibility whitespaceVisibility() const;
QString wordAtLineIndex(int line, int index) const;
QString wordAtPoint(const QPoint &point) const;
const char *wordCharacters() const;
WrapMode wrapMode() const;
WrapIndentMode wrapIndentMode() const;
bool write(QIODevice *io) const /ReleaseGIL/;
public slots:
virtual void append(const QString &text);
virtual void autoCompleteFromAll();
virtual void autoCompleteFromAPIs();
virtual void autoCompleteFromDocument();
virtual void callTip();
virtual void clear();
virtual void copy();
virtual void cut();
virtual void ensureCursorVisible();
virtual void ensureLineVisible(int line);
virtual void foldAll(bool children = false);
virtual void foldLine(int line);
virtual void indent(int line);
virtual void insert(const QString &text);
virtual void insertAt(const QString &text, int line, int index);
virtual void moveToMatchingBrace();
virtual void paste();
virtual void redo();
virtual void removeSelectedText();
virtual void replaceSelectedText(const QString &text);
virtual void resetSelectionBackgroundColor();
virtual void resetSelectionForegroundColor();
virtual void selectAll(bool select = true);
virtual void selectToMatchingBrace();
virtual void setAutoCompletionCaseSensitivity(bool cs);
virtual void setAutoCompletionReplaceWord(bool replace);
virtual void setAutoCompletionShowSingle(bool single);
virtual void setAutoCompletionSource(AutoCompletionSource source);
virtual void setAutoCompletionThreshold(int thresh);
virtual void setAutoCompletionUseSingle(AutoCompletionUseSingle single);
virtual void setAutoIndent(bool autoindent);
virtual void setBraceMatching(BraceMatch bm);
virtual void setBackspaceUnindents(bool unindent);
virtual void setCaretForegroundColor(const QColor &col);
virtual void setCaretLineBackgroundColor(const QColor &col);
virtual void setCaretLineFrameWidth(int width);
virtual void setCaretLineVisible(bool enable);
virtual void setCaretWidth(int width);
virtual void setColor(const QColor &col);
virtual void setCursorPosition(int line, int index);
virtual void setEolMode(EolMode mode);
virtual void setEolVisibility(bool visible);
virtual void setFolding(FoldStyle fold, int margin=2);
void clearFolds();
virtual void setIndentation(int line, int indentation);
virtual void setIndentationGuides(bool enable);
virtual void setIndentationGuidesBackgroundColor(const QColor &col);
virtual void setIndentationGuidesForegroundColor(const QColor &col);
virtual void setIndentationsUseTabs(bool tabs);
virtual void setIndentationWidth(int width);
virtual void setLexer(QsciLexer *lexer = 0);
virtual void setMarginsBackgroundColor(const QColor &col);
virtual void setMarginsFont(const QFont &f);
virtual void setMarginsForegroundColor(const QColor &col);
virtual void setMarginLineNumbers(int margin, bool lnrs);
virtual void setMarginMarkerMask(int margin, int mask);
virtual void setMarginSensitivity(int margin, bool sens);
virtual void setMarginWidth(int margin, int width);
virtual void setMarginWidth(int margin, const QString &s);
virtual void setModified(bool m);
virtual void setPaper(const QColor &c);
virtual void setReadOnly(bool ro);
virtual void setSelection(int lineFrom, int indexFrom, int lineTo,
int indexTo);
virtual void setSelectionBackgroundColor(const QColor &col);
virtual void setSelectionForegroundColor(const QColor &col);
virtual void setTabIndents(bool indent);
virtual void setTabWidth(int width);
virtual void setText(const QString &text);
virtual void setUtf8(bool cp);
virtual void setWhitespaceVisibility(WhitespaceVisibility mode);
virtual void setWrapMode(WrapMode mode);
virtual void undo();
virtual void unindent(int line);
virtual void zoomIn(int range);
virtual void zoomIn();
virtual void zoomOut(int range);
virtual void zoomOut();
virtual void zoomTo(int size);
signals:
void cursorPositionChanged(int line, int index);
void copyAvailable(bool yes);
void indicatorClicked(int line, int index, Qt::KeyboardModifiers state);
void indicatorReleased(int line, int index, Qt::KeyboardModifiers state);
void linesChanged();
void marginClicked(int margin, int line, Qt::KeyboardModifiers state);
void marginRightClicked(int margin, int line, Qt::KeyboardModifiers state);
void modificationAttempted();
void modificationChanged(bool m);
void selectionChanged();
void textChanged();
void userListActivated(int id, const QString &string);
protected:
virtual bool event(QEvent *event);
virtual void changeEvent(QEvent *event);
virtual void contextMenuEvent(QContextMenuEvent *event);
virtual void wheelEvent(QWheelEvent *event);
private:
QsciScintilla(const QsciScintilla &);
};

1611
third_party/qscintilla/Python/sip/qsciscintillabase.sip vendored
View File

File diff suppressed because it is too large Load Diff

69
third_party/qscintilla/Python/sip/qscistyle.sip vendored
View File

@@ -1,69 +0,0 @@
// This is the SIP interface definition for QsciStyle.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciStyle
{
%TypeHeaderCode
#include <Qsci/qscistyle.h>
%End
public:
enum TextCase {
OriginalCase,
UpperCase,
LowerCase
};
QsciStyle(int style = -1);
QsciStyle(int style, const QString &description, const QColor &color,
const QColor &paper, const QFont &font, bool eolFill = false);
void setStyle(int style);
int style() const;
void setDescription(const QString &description);
QString description() const;
void setColor(const QColor &color);
QColor color() const;
void setPaper(const QColor &paper);
QColor paper() const;
void setFont(const QFont &font);
QFont font() const;
void setEolFill(bool fill);
bool eolFill() const;
void setTextCase(TextCase text_case);
TextCase textCase() const;
void setVisible(bool visible);
bool visible() const;
void setChangeable(bool changeable);
bool changeable() const;
void setHotspot(bool hotspot);
bool hotspot() const;
void refresh();
};

33
third_party/qscintilla/Python/sip/qscistyledtext.sip vendored
View File

@@ -1,33 +0,0 @@
// This is the SIP interface definition for QsciStyledText.
//
// Copyright (c) 2023 Riverbank Computing Limited <info@riverbankcomputing.com>
//
// This file is part of QScintilla.
//
// This file may be used under the terms of the GNU General Public License
// version 3.0 as published by the Free Software Foundation and appearing in
// the file LICENSE included in the packaging of this file. Please review the
// following information to ensure the GNU General Public License version 3.0
// requirements will be met: http://www.gnu.org/copyleft/gpl.html.
//
// If you do not wish to use this file under the terms of the GPL version 3.0
// then you may purchase a commercial license. For more information contact
// info@riverbankcomputing.com.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
class QsciStyledText
{
%TypeHeaderCode
#include <Qsci/qscistyledtext.h>
%End
public:
QsciStyledText(const QString &text, int style);
QsciStyledText(const QString &text, const QsciStyle &style);
const QString &text();
int style() const;
};

22
third_party/qscintilla/designer/designer.pro vendored
View File

@@ -1,22 +0,0 @@
# This is the qmake file for the QScintilla plugin for Qt Designer.
TEMPLATE = lib
TARGET = qscintillaplugin
# Comment this in to build a dynamic library supporting multiple architectures
# on macOS.
#QMAKE_APPLE_DEVICE_ARCHS = x86_64 arm64
CONFIG += plugin qscintilla2
QT += designer
# Work around QTBUG-39300.
CONFIG -= android_install
HEADERS = qscintillaplugin.h
SOURCES = qscintillaplugin.cpp
target.path = $$[QT_INSTALL_PLUGINS]/designer
INSTALLS += target

167
third_party/qscintilla/designer/qscintillaplugin.cpp vendored
View File

@@ -1,167 +0,0 @@
// This implements the QScintilla plugin for Qt Designer.
#include "qscintillaplugin.h"
#include <QtPlugin>
#include <Qsci/qsciscintilla.h>
static const char *qscintilla_pixmap[] = {
"22 22 35 1",
"m c #000000",
"n c #000033",
"p c #003300",
"r c #003333",
"v c #330000",
"o c #330033",
"l c #333300",
"h c #333333",
"c c #333366",
"d c #336666",
"u c #336699",
"E c #3366cc",
"k c #663333",
"i c #663366",
"b c #666666",
"e c #666699",
"A c #6666cc",
"G c #669966",
"f c #669999",
"j c #6699cc",
"y c #6699ff",
"t c #996666",
"a c #999999",
"g c #9999cc",
"s c #9999ff",
"C c #99cc99",
"x c #99cccc",
"w c #99ccff",
"F c #cc99ff",
"q c #cccccc",
"# c #ccccff",
"B c #ccffcc",
"z c #ccffff",
"D c #ffffcc",
". c none",
"........#abcda........",
"......abefghdidcf.....",
".....cadhfaehjheck....",
"....leh.m.ncbehjddo...",
"...depn.hqhqhr#mccch..",
"..bb.hcaeh.hqersjhjcd.",
".tcm.uqn.hc.uvwxhuygha",
".feh.n.hb.hhzemcwhmuAm",
"Bgehghqqme.eo#wlnysbnj",
"awhdAzn.engjepswhmuyuj",
"bCh#m.de.jpqwbmcwemlcz",
"hcb#xh.nd#qrbswfehwzbm",
"bd#d.A#zor#qmgbzwgjgws",
"ajbcuqhqzchwwbemewchmr",
"Dcn#cwmhgwehgsxbmhEjAc",
".uanauFrhbgeahAAbcbuhh",
".bohdAegcccfbbebuucmhe",
"..briuauAediddeclchhh.",
"...hcbhjccdecbceccch..",
"....nhcmeccdccephcp...",
".....crbhchhhrhhck....",
"......tcmdhohhcnG....."
};
QScintillaPlugin::QScintillaPlugin(QObject *parent)
: QObject(parent), initialized(false)
{
}
QScintillaPlugin::~QScintillaPlugin()
{
}
void QScintillaPlugin::initialize(QDesignerFormEditorInterface * /* core */)
{
initialized = true;
}
bool QScintillaPlugin::isInitialized() const
{
return initialized;
}
QWidget *QScintillaPlugin::createWidget(QWidget *parent)
{
return new QsciScintilla(parent);
}
QString QScintillaPlugin::name() const
{
return "QsciScintilla";
}
QString QScintillaPlugin::group() const
{
return "Input Widgets";
}
QIcon QScintillaPlugin::icon() const
{
return QIcon(QPixmap(qscintilla_pixmap));
}
QString QScintillaPlugin::toolTip() const
{
return "QScintilla Programmer's Editor";
}
QString QScintillaPlugin::whatsThis() const
{
return "A port to Qt of the Scintilla programmer's editor";
}
bool QScintillaPlugin::isContainer() const
{
return false;
}
QString QScintillaPlugin::domXml() const
{
return "<widget class=\"QsciScintilla\" name=\"textEdit\">\n"
" <property name=\"geometry\">\n"
" <rect>\n"
" <x>0</x>\n"
" <y>0</y>\n"
" <width>400</width>\n"
" <height>200</height>\n"
" </rect>\n"
" </property>\n"
" <property name=\"toolTip\" >\n"
" <string></string>\n"
" </property>\n"
" <property name=\"whatsThis\" >\n"
" <string></string>\n"
" </property>\n"
"</widget>\n";
}
QString QScintillaPlugin::includeFile() const
{
return "Qsci/qsciscintilla.h";
}
#if QT_VERSION < 0x050000
Q_EXPORT_PLUGIN2(qscintillaplugin, QScintillaPlugin)
#endif

38
third_party/qscintilla/designer/qscintillaplugin.h vendored
View File

@@ -1,38 +0,0 @@
// This defines the QScintilla plugin for Qt Designer.
#ifndef _QSCINTILLAPLUGIN_H
#define _QSCINTILLAPLUGIN_H
#include <QtDesigner>
class QScintillaPlugin : public QObject, public QDesignerCustomWidgetInterface
{
Q_OBJECT
#if QT_VERSION >= 0x050000
Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QDesignerCustomWidgetInterface")
#endif
Q_INTERFACES(QDesignerCustomWidgetInterface)
public:
QScintillaPlugin(QObject *parent = 0);
virtual ~QScintillaPlugin();
bool isContainer() const;
bool isInitialized() const;
QIcon icon() const;
QString domXml() const;
QString group() const;
QString includeFile() const;
QString name() const;
QString toolTip() const;
QString whatsThis() const;
QWidget *createWidget(QWidget *parent);
void initialize(QDesignerFormEditorInterface *core);
private:
bool initialized;
};
#endif

204
third_party/qscintilla/doc/README.doc vendored
View File

@@ -1,204 +0,0 @@
/*! \mainpage QScintilla - a Port to Qt v5 and Qt v6 of Scintilla
<h2>Introduction</h2>
<a href="http://www.riverbankcomputing.com/software/qscintilla/">QScintilla</a>
is a port to Qt of the <a href="http://www.scintilla.org/">Scintilla</a>
editing component.
As well as features found in standard text editing components, Scintilla
includes features especially useful when editing and debugging source code:
<ul>
<li>syntax styling with support for over 70 languages
<li>error indicators
<li>code completion
<li>call tips
<li>code folding
<li>margins can contain markers like those used in debuggers to indicate
breakpoints and the current line.
<li>recordable macros
<li>multiple views
<li>printing.
</ul>
QScintilla is a port or Scintilla to the Qt GUI toolkit from
<a href="http://www.qt.io">The Qt Company</a> and runs on any operating system
supported by Qt (eg. Windows, Linux, macOS, iOS and Android). QScintilla works
with Qt v5 and v6.
QScintilla also includes language bindings for
<a href="https://www.python.org">Python</a>. These require that
<a href="https://www.riverbankcomputing.com/software/pyqt/">PyQt</a> v5 or v6
is also installed.
This version of QScintilla is based on Scintilla v3.10.1.
<h2>Licensing</h2>
QScintilla is available under the
<a href="http://www.gnu.org/licenses/gpl.html">GNU General Public License v3</a>
and the Riverbank Commercial License.
The commercial license allows closed source applications using QScintilla to be
developed and distributed. At the moment the commercial version of QScintilla
is bundled with, but packaged separately from, the commercial version of
<a href="http://www.riverbankcomputing.com/software/pyqt/">PyQt</a>.
The Scintilla code within QScintilla is released under the following license:
<pre>
License for Scintilla and SciTE
Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation.
NEIL HODGSON DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS, IN NO EVENT SHALL NEIL HODGSON BE LIABLE FOR ANY
SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE
OR PERFORMANCE OF THIS SOFTWARE.
</pre>
<h2>Installation</h2>
As supplied QScintilla will be built as a shared library/DLL and installed in
the same directories as the Qt libraries and include files.
If you wish to build a static version of the library then pass
<tt>CONFIG+=staticlib</tt> on the <tt>qmake</tt> command line.
On macOS, if you wish to build a dynamic version of the library that supports
both <tt>x86_64</tt> and <tt>arm64</tt> architectures then edit the file
<tt>qscintilla.pro</tt> in the <tt>src</tt> directory and comment in the
definition of <tt>QMAKE_APPLE_DEVICE_ARCHS</tt>. Similar changes can be made
to the <tt>.pro</tt> files for the Designer plugin and the example application.
If you want to make more significant changes to the configuration then edit the
file <tt>qscintilla.pro</tt> in the <tt>src</tt> directory.
If you do make changes, specifically to the names of the installation
directories or the name of the library, then you may also need to update the
<tt>src/features/qscintilla2.prf</tt> file.
See your <tt>qmake</tt> documentation for more details.
To build and install QScintilla, run:
<pre>
cd src
qmake
make
make install
</pre>
If you have multiple versions of Qt installed then make sure you use the
correct version of <tt>qmake</tt>.
The underlying Scintilla code may support additional compile-time options.
These can be configured by passing appropriate arguments to <tt>qmake</tt>.
For example, if you have an old C++ compiler that does not have a working
<tt>std::regex</tt> then invoke <tt>qmake</tt> as follows:
<pre>
qmake DEFINES+=NO_CXX11_REGEX=1
</pre>
<h3>Installation on Windows</h3>
Before compiling QScintilla on Windows you should remove the <tt>Qsci</tt>
directory containing the QScintilla header files from any previous
installation. This is because the <tt>Makefile</tt> generated by
<tt>qmake</tt> will find these older header files instead of the new ones.
Depending on the compiler you are using you may need to run <tt>nmake</tt>
rather than <tt>make</tt>.
If you have built a Windows DLL then you probably also want to run:
<pre>
copy %%QTDIR%\\lib\\qscintilla2.dll %%QTDIR%\\bin
</pre>
<h2>Integration with <tt>qmake</tt></h2>
To configure <tt>qmake</tt> to find your QScintilla installation, add the
following line to your application's <tt>.pro</tt> file:
<pre>
CONFIG += qscintilla2
</pre>
<h2>Qt Designer Plugin</h2>
QScintilla includes an optional plugin for Qt Designer that allows QScintilla
instances to be included in GUI designs just like any other Qt widget.
To build the plugin on all platforms, make sure QScintilla is installed and
then run (as root or administrator):
<pre>
cd designer
qmake
make
make install
</pre>
On Windows (and depending on the compiler you are using) you may need to run
<tt>nmake</tt> rather than <tt>make</tt>.
<h2>Example Application</h2>
The example application provided is a port of the standard Qt
<tt>application</tt> example with the QsciScintilla class being used instead of
Qt's QTextEdit class.
The example does not demonstrate all of the extra features of QScintilla.
To build the example, run:
<pre>
cd example
qmake
make
</pre>
On Windows (and depending on the compiler you are using) you may need to run
<tt>nmake</tt> rather than <tt>make</tt>.
<h2>Python Bindings</h2>
The Python bindings are in the <tt>Python</tt> sub-directory. You must have
either PyQt5 or PyQt6 already installed and PyQt-builder. QScintilla must also
already be built and installed.
The <tt>Python</tt> sub-directory contains a <tt>pyproject-qt5.toml</tt> file
and a <tt>pyproject-qt6.toml</tt> file. If you are building for PyQt5 and Qt
v5 then you must copy the <tt>pyproject-qt5.toml</tt> file to
<tt>pyproject.toml</tt>. If instead you are building for PyQt6 and Qt v6 then
you must copy the <tt>pyproject-qt6.toml</tt> file to <tt>pyproject.toml</tt>.
To build and install the bindings, run:
<pre>
cd Python
sip-install
</pre>
*/

246
third_party/qscintilla/doc/Scintilla/Design.html vendored
View File

@@ -1,246 +0,0 @@
<?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 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 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
third_party/qscintilla/doc/Scintilla/Icons.html vendored
View File

@@ -1,57 +0,0 @@
<?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>

2608
third_party/qscintilla/doc/Scintilla/LPegLexer.html vendored
View File

File diff suppressed because it is too large Load Diff

226
third_party/qscintilla/doc/Scintilla/Lexer.txt vendored
View File

@@ -1,226 +0,0 @@
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

70
third_party/qscintilla/doc/Scintilla/Privacy.html vendored
View File

@@ -1,70 +0,0 @@
<?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
third_party/qscintilla/doc/Scintilla/SciBreak.jpg vendored
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 33 KiB

294
third_party/qscintilla/doc/Scintilla/SciCoding.html vendored
View File

@@ -1,294 +0,0 @@
<?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 '-taOHUKk3 -M8' 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++03 which can be checked with "g++ --std=gnu++03".
SciTE can use C++11 features that are widely available from g++ 4.6, MSVC 2012 and clang 3.4 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.
Run-time type information adds to memory use so is turned off.
A 'Scintilla' name space is used. This helps with name clashes on OS X.
</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>Add a public feature request to the <a href="https://sourceforge.net/tracker/?group_id=2439&atid=352439">Feature Request Tracker</a>.</p>
<p>Send all the modified and new files as full text (not patches) in an archive (.zip or .tgz).</p>
<p>Define all of the lexical states in a modified Scintilla.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
third_party/qscintilla/doc/Scintilla/SciRest.jpg vendored
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 16 KiB

BIN
third_party/qscintilla/doc/Scintilla/SciTEIco.png vendored
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 9.9 KiB

BIN
third_party/qscintilla/doc/Scintilla/SciWord.jpg vendored
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 6.0 KiB

8483
third_party/qscintilla/doc/Scintilla/ScintillaDoc.html vendored
View File

File diff suppressed because it is too large Load Diff

71
third_party/qscintilla/doc/Scintilla/ScintillaDownload.html vendored
View File

@@ -1,71 +0,0 @@
<?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/scintilla3101.zip">
Windows</a>&nbsp;&nbsp;
<a href="https://www.scintilla.org/scintilla3101.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 3.10.1
</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/scintilla3101.zip">zip format</a> (1600K) commonly used on Windows</li>
<li><a href="https://www.scintilla.org/scintilla3101.tgz">tgz format</a> (1400K) 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 SciLexer.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>

12065
third_party/qscintilla/doc/Scintilla/ScintillaHistory.html vendored
View File

File diff suppressed because it is too large Load Diff

533
third_party/qscintilla/doc/Scintilla/ScintillaRelated.html vendored
View File

@@ -1,533 +0,0 @@
<?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="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/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="http://foicica.com/textadept/">Textadept</a>
is a ridiculously extensible cross-platform text editor for programmers written (mostly) in
Lua using LPeg to handle the lexers.
</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>

128
third_party/qscintilla/doc/Scintilla/ScintillaToDo.html vendored
View File

@@ -1,128 +0,0 @@
<?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 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>
<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 Bugs
</h3>
<p>
Automatic scrolling when text dragged near edge of window.
</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
third_party/qscintilla/doc/Scintilla/ScintillaUsage.html vendored
View File

@@ -1,376 +0,0 @@
<?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>

142
third_party/qscintilla/doc/Scintilla/Steps.html vendored
View File

@@ -1,142 +0,0 @@
<!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
third_party/qscintilla/doc/Scintilla/StyleMetadata.html vendored
View File

@@ -1,204 +0,0 @@
<?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
third_party/qscintilla/doc/Scintilla/annotations.png vendored
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 33 KiB

192
third_party/qscintilla/doc/Scintilla/index.html vendored
View File

@@ -1,192 +0,0 @@
<?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="20180212" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<style type="text/css">
#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="256">
<img src="SciWord.jpg" height="78" width="256" alt="Scintilla" />
</td>
<td width="40%" align="left">
<font color="#FFCC99" size="4"> A free source code editing component for Win32,
GTK+, and OS X</font>
</td>
<td width="40%" align="right">
<font color="#FFCC99" size="3"> Release version 3.10.1<br />
Site last modified February 12 2018</font>
</td>
<td width="20%">
&nbsp;
</td>
</tr>
</table>
<table bgcolor="#000000" width="100%" cellspacing="0" cellpadding="0" border="0">
<tr>
<td width="100%" style="background: url(https://www.scintilla.org/SciBreak.jpg) no-repeat;height:150px;">
&nbsp;
</td>
</tr>
</table>
<ul id="versionlist">
<li>Version 3.7.5 adds a Reverse Selected Lines command.
MSVC 2013 is no longer supported.</li>
<li>Version 3.7.4 restores performance on GTK+.
C++11 now required to build and Windows NT 4 is no longer supported.</li>
<li>Version 3.7.3 fixes problems with GTK+ on Wayland.</li>
<li>Version 3.7.2 fixes some crashes on GTK+ and Cocoa, commonly at destruction.</li>
<li>Version 3.7.1 supports accessibility on GTK+ and Cocoa.
The Scintilla namespace is not exposed in Scintilla.h and some deprecated APIs were removed.</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="https://www.scintilla.org/ScintillaDoc.html">Documentation</a></li>
<li><a href="https://www.scintilla.org/ScintillaToDo.html">Bugs</a></li>
<li id="remote3"><a href="https://www.scintilla.org/SciTE.html">SciTE</a></li>
<li><a href="https://www.scintilla.org/ScintillaHistory.html">History</a></li>
<li><a href="https://www.scintilla.org/ScintillaRelated.html">Related</a></li>
<li id="remote4"><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';
}
//--></script>
<p>
<a href="https://www.scintilla.org/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>
<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, OS X, and Linux compatible operating
systems with GTK+. They have been run on Windows XP, Windows 7, OS X 10.7+, and on Ubuntu 14.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="https://www.scintilla.org/ScintillaRelated.html">Related sites.</a>
</p>
<p>
<a href="https://www.scintilla.org/ScintillaToDo.html">Bugs and To Do list.</a>
</p>
<p>
<a href="https://www.scintilla.org/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>
The <a href="https://scintilla.sourceforge.io/LongTermDownload.html">LongTerm3</a>
branch of Scintilla avoids using features from C++14 or later in order to support older systems.
</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>.
Messages sent to my personal email address that could have been sent to the list
may receive no response.
<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
third_party/qscintilla/doc/Scintilla/styledmargin.png vendored
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 17 KiB

115
third_party/qscintilla/doc/html/annotated.html vendored
View File

@@ -1,115 +0,0 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<meta http-equiv="X-UA-Compatible" content="IE=9"/>
<meta name="generator" content="Doxygen 1.8.20"/>
<meta name="viewport" content="width=device-width, initial-scale=1"/>
<title>QScintilla: Class List</title>
<link href="tabs.css" rel="stylesheet" type="text/css"/>
<script type="text/javascript" src="jquery.js"></script>
<script type="text/javascript" src="dynsections.js"></script>
<link href="doxygen.css" rel="stylesheet" type="text/css" />
</head>
<body>
<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
<div id="titlearea">
<table cellspacing="0" cellpadding="0">
<tbody>
<tr style="height: 56px;">
<td id="projectalign" style="padding-left: 0.5em;">
<div id="projectname">QScintilla
&#160;<span id="projectnumber">2.14.1</span>
</div>
</td>
</tr>
</tbody>
</table>
</div>
<!-- end header part -->
<!-- Generated by Doxygen 1.8.20 -->
<script type="text/javascript" src="menudata.js"></script>
<script type="text/javascript" src="menu.js"></script>
<script type="text/javascript">
/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
$(function() {
initMenu('',false,false,'search.php','Search');
});
/* @license-end */</script>
<div id="main-nav"></div>
</div><!-- top -->
<div class="header">
<div class="headertitle">
<div class="title">Class List</div> </div>
</div><!--header-->
<div class="contents">
<div class="textblock">Here are the classes, structs, unions and interfaces with brief descriptions:</div><div class="directory">
<table class="directory">
<tr id="row_0_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciAbstractAPIs.html" target="_self">QsciAbstractAPIs</a></td><td class="desc">Interface to the textual API information used in call tips and for auto-completion. A sub-class will provide the actual implementation of the interface </td></tr>
<tr id="row_1_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciAPIs.html" target="_self">QsciAPIs</a></td><td class="desc">Provies an implementation of the textual API information used in call tips and for auto-completion </td></tr>
<tr id="row_2_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciCommand.html" target="_self">QsciCommand</a></td><td class="desc">Internal editor command that may have one or two keys bound to it </td></tr>
<tr id="row_3_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciCommandSet.html" target="_self">QsciCommandSet</a></td><td class="desc">Set of all internal editor commands that may have keys bound </td></tr>
<tr id="row_4_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciDocument.html" target="_self">QsciDocument</a></td><td class="desc">Document to be edited </td></tr>
<tr id="row_5_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexer.html" target="_self">QsciLexer</a></td><td class="desc">Abstract class used as a base for language lexers </td></tr>
<tr id="row_6_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerAsm.html" target="_self">QsciLexerAsm</a></td><td class="desc">The abstract <a class="el" href="classQsciLexerAsm.html" title="The abstract QsciLexerAsm class encapsulates the Scintilla Asm lexer.">QsciLexerAsm</a> class encapsulates the Scintilla Asm lexer </td></tr>
<tr id="row_7_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerAVS.html" target="_self">QsciLexerAVS</a></td><td class="desc">Encapsulates the Scintilla AVS lexer </td></tr>
<tr id="row_8_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerBash.html" target="_self">QsciLexerBash</a></td><td class="desc">Encapsulates the Scintilla Bash lexer </td></tr>
<tr id="row_9_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerBatch.html" target="_self">QsciLexerBatch</a></td><td class="desc">Encapsulates the Scintilla batch file lexer </td></tr>
<tr id="row_10_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerCMake.html" target="_self">QsciLexerCMake</a></td><td class="desc">Encapsulates the Scintilla CMake lexer </td></tr>
<tr id="row_11_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerCoffeeScript.html" target="_self">QsciLexerCoffeeScript</a></td><td class="desc">Encapsulates the Scintilla CoffeeScript lexer </td></tr>
<tr id="row_12_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerCPP.html" target="_self">QsciLexerCPP</a></td><td class="desc">Encapsulates the Scintilla C++ lexer </td></tr>
<tr id="row_13_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerCSharp.html" target="_self">QsciLexerCSharp</a></td><td class="desc">Encapsulates the Scintilla C# lexer </td></tr>
<tr id="row_14_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerCSS.html" target="_self">QsciLexerCSS</a></td><td class="desc">Encapsulates the Scintilla CSS lexer </td></tr>
<tr id="row_15_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerCustom.html" target="_self">QsciLexerCustom</a></td><td class="desc">Abstract class used as a base for new language lexers </td></tr>
<tr id="row_16_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerD.html" target="_self">QsciLexerD</a></td><td class="desc">Encapsulates the Scintilla D lexer </td></tr>
<tr id="row_17_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerDiff.html" target="_self">QsciLexerDiff</a></td><td class="desc">Encapsulates the Scintilla Diff lexer </td></tr>
<tr id="row_18_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerEDIFACT.html" target="_self">QsciLexerEDIFACT</a></td><td class="desc">Encapsulates the Scintilla EDIFACT lexer </td></tr>
<tr id="row_19_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerFortran.html" target="_self">QsciLexerFortran</a></td><td class="desc">Encapsulates the Scintilla Fortran lexer </td></tr>
<tr id="row_20_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerFortran77.html" target="_self">QsciLexerFortran77</a></td><td class="desc">Encapsulates the Scintilla Fortran77 lexer </td></tr>
<tr id="row_21_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerHex.html" target="_self">QsciLexerHex</a></td><td class="desc">The abstract <a class="el" href="classQsciLexerHex.html" title="The abstract QsciLexerHex class encapsulates the Scintilla Hex lexer.">QsciLexerHex</a> class encapsulates the Scintilla Hex lexer </td></tr>
<tr id="row_22_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerHTML.html" target="_self">QsciLexerHTML</a></td><td class="desc">Encapsulates the Scintilla HTML lexer </td></tr>
<tr id="row_23_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerIDL.html" target="_self">QsciLexerIDL</a></td><td class="desc">Encapsulates the Scintilla IDL lexer </td></tr>
<tr id="row_24_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerIntelHex.html" target="_self">QsciLexerIntelHex</a></td><td class="desc">Encapsulates the Scintilla Intel Hex lexer </td></tr>
<tr id="row_25_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerJava.html" target="_self">QsciLexerJava</a></td><td class="desc">Encapsulates the Scintilla Java lexer </td></tr>
<tr id="row_26_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerJavaScript.html" target="_self">QsciLexerJavaScript</a></td><td class="desc">Encapsulates the Scintilla JavaScript lexer </td></tr>
<tr id="row_27_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerJSON.html" target="_self">QsciLexerJSON</a></td><td class="desc">Encapsulates the Scintilla JSON lexer </td></tr>
<tr id="row_28_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerLua.html" target="_self">QsciLexerLua</a></td><td class="desc">Encapsulates the Scintilla Lua lexer </td></tr>
<tr id="row_29_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerMakefile.html" target="_self">QsciLexerMakefile</a></td><td class="desc">Encapsulates the Scintilla Makefile lexer </td></tr>
<tr id="row_30_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerMarkdown.html" target="_self">QsciLexerMarkdown</a></td><td class="desc">Encapsulates the Scintilla Markdown lexer </td></tr>
<tr id="row_31_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerMASM.html" target="_self">QsciLexerMASM</a></td><td class="desc">Encapsulates the Scintilla MASM lexer </td></tr>
<tr id="row_32_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerMatlab.html" target="_self">QsciLexerMatlab</a></td><td class="desc">Encapsulates the Scintilla Matlab file lexer </td></tr>
<tr id="row_33_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerNASM.html" target="_self">QsciLexerNASM</a></td><td class="desc">Encapsulates the Scintilla NASM lexer </td></tr>
<tr id="row_34_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerOctave.html" target="_self">QsciLexerOctave</a></td><td class="desc">Encapsulates the Scintilla Octave file lexer </td></tr>
<tr id="row_35_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerPascal.html" target="_self">QsciLexerPascal</a></td><td class="desc">Encapsulates the Scintilla Pascal lexer </td></tr>
<tr id="row_36_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerPerl.html" target="_self">QsciLexerPerl</a></td><td class="desc">Encapsulates the Scintilla Perl lexer </td></tr>
<tr id="row_37_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerPO.html" target="_self">QsciLexerPO</a></td><td class="desc">Encapsulates the Scintilla PO lexer </td></tr>
<tr id="row_38_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerPostScript.html" target="_self">QsciLexerPostScript</a></td><td class="desc">Encapsulates the Scintilla PostScript lexer </td></tr>
<tr id="row_39_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerPOV.html" target="_self">QsciLexerPOV</a></td><td class="desc">Encapsulates the Scintilla POV lexer </td></tr>
<tr id="row_40_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerProperties.html" target="_self">QsciLexerProperties</a></td><td class="desc">Encapsulates the Scintilla Properties lexer </td></tr>
<tr id="row_41_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerPython.html" target="_self">QsciLexerPython</a></td><td class="desc">Encapsulates the Scintilla Python lexer </td></tr>
<tr id="row_42_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerRuby.html" target="_self">QsciLexerRuby</a></td><td class="desc">Encapsulates the Scintilla Ruby lexer </td></tr>
<tr id="row_43_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerSpice.html" target="_self">QsciLexerSpice</a></td><td class="desc">Encapsulates the Scintilla Spice lexer </td></tr>
<tr id="row_44_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerSQL.html" target="_self">QsciLexerSQL</a></td><td class="desc">Encapsulates the Scintilla SQL lexer </td></tr>
<tr id="row_45_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerSRec.html" target="_self">QsciLexerSRec</a></td><td class="desc">Encapsulates the Scintilla S-Record lexer </td></tr>
<tr id="row_46_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerTCL.html" target="_self">QsciLexerTCL</a></td><td class="desc">Encapsulates the Scintilla TCL lexer </td></tr>
<tr id="row_47_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerTekHex.html" target="_self">QsciLexerTekHex</a></td><td class="desc">Encapsulates the Scintilla Tektronix Hex lexer </td></tr>
<tr id="row_48_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerTeX.html" target="_self">QsciLexerTeX</a></td><td class="desc">Encapsulates the Scintilla TeX lexer </td></tr>
<tr id="row_49_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerVerilog.html" target="_self">QsciLexerVerilog</a></td><td class="desc">Encapsulates the Scintilla Verilog lexer </td></tr>
<tr id="row_50_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerVHDL.html" target="_self">QsciLexerVHDL</a></td><td class="desc">Encapsulates the Scintilla VHDL lexer </td></tr>
<tr id="row_51_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerXML.html" target="_self">QsciLexerXML</a></td><td class="desc">Encapsulates the Scintilla XML lexer </td></tr>
<tr id="row_52_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciLexerYAML.html" target="_self">QsciLexerYAML</a></td><td class="desc">Encapsulates the Scintilla YAML lexer </td></tr>
<tr id="row_53_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciMacro.html" target="_self">QsciMacro</a></td><td class="desc">Sequence of recordable editor commands </td></tr>
<tr id="row_54_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciPrinter.html" target="_self">QsciPrinter</a></td><td class="desc">Sub-class of the Qt QPrinter class that is able to print the text of a Scintilla document </td></tr>
<tr id="row_55_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciScintilla.html" target="_self">QsciScintilla</a></td><td class="desc">Implements a higher level, more Qt-like, API to the Scintilla editor widget </td></tr>
<tr id="row_56_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciScintillaBase.html" target="_self">QsciScintillaBase</a></td><td class="desc">Implements the Scintilla editor widget and its low-level API </td></tr>
<tr id="row_57_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciStyle.html" target="_self">QsciStyle</a></td><td class="desc">Encapsulates all the attributes of a style </td></tr>
<tr id="row_58_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="classQsciStyledText.html" target="_self">QsciStyledText</a></td><td class="desc">Container for a piece of text and the style used to display the text </td></tr>
</table>
</div><!-- directory -->
</div><!-- contents -->
<!-- start footer part -->
<hr class="footer"/><address class="footer"><small>
Generated by&#160;<a href="http://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.8.20
</small></address>
</body>
</html>

BIN
third_party/qscintilla/doc/html/bc_s.png vendored
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 676 B

BIN
third_party/qscintilla/doc/html/bdwn.png vendored
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 147 B

Some files were not shown because too many files have changed in this diff Show More