#------------------------------------------------------------------------
# Scintilla control for Win32::GUI
# by Laurent ROCHER (lrocher@cpan.org)
#------------------------------------------------------------------------
#perl2exe_bundle 'SciLexer.dll'

# This file created by the build process from Scintilla.PL
# change made here will be lost.  Edit Scintilla.PL instead.
# $Id: Scintilla.PL,v 1.5 2006/10/15 14:07:46 robertemay Exp $

package Win32::GUI::Scintilla;

use strict;
use warnings;

use Win32::GUI qw(WS_CLIPCHILDREN WS_TABSTOP WS_VISIBLE WS_HSCROLL WS_VSCROLL);

require DynaLoader;

our @ISA = qw(DynaLoader Win32::GUI::Window);

our $VERSION = "1.90";
our $XS_VERSION = $VERSION;
$VERSION = eval $VERSION;

bootstrap Win32::GUI::Scintilla $XS_VERSION;

#------------------------------------------------------------------------

# Load Scintilla DLL from somewhere on @INC or standard LoadLibrary search
my ($SCILEXER_FILE,$SCILEXER_DLL);
for my $path (@INC) {
    my $lexer_file = $path . '/auto/Win32/GUI/Scintilla/SciLexer.dll';
    if (-f $lexer_file) {
        $SCILEXER_FILE = $lexer_file;
        last;
    }
}

if ($SCILEXER_FILE) {
    $SCILEXER_DLL = Win32::GUI::LoadLibrary($SCILEXER_FILE);
    warn qq(Failed to load SciLexer.dll from "$SCILEXER_FILE") unless $SCILEXER_DLL;
}

unless ($SCILEXER_DLL) {
    warn qq(Final attempt to find SciLexer.dll in PATH);
    $SCILEXER_DLL = Win32::GUI::LoadLibrary('SciLexer');
}

die qq(Failed to load 'SciLexer.dll') unless $SCILEXER_DLL;

Win32::GUI::Scintilla::_Initialise();

END {
  # Free Scintilla DLL
  Win32::GUI::Scintilla::_UnInitialise();
  #Win32::GUI::FreeLibrary($SCILEXER_DLL); 
  #The above line causes some scripts to crash - such as test2.pl in the samples when running under 5.8.7
}

#------------------------------------------------------------------------

#
# Notify event code
#

use constant SCN_STYLENEEDED        => 2000;
use constant SCN_CHARADDED          => 2001;
use constant SCN_SAVEPOINTREACHED   => 2002;
use constant SCN_SAVEPOINTLEFT      => 2003;
use constant SCN_MODIFYATTEMPTRO    => 2004;
use constant SCN_KEY                => 2005;
use constant SCN_DOUBLECLICK        => 2006;
use constant SCN_UPDATEUI           => 2007;
use constant SCN_MODIFIED           => 2008;
use constant SCN_MACRORECORD        => 2009;
use constant SCN_MARGINCLICK        => 2010;
use constant SCN_NEEDSHOWN          => 2011;
use constant SCN_PAINTED            => 2013;
use constant SCN_USERLISTSELECTION  => 2014;
use constant SCN_URIDROPPED         => 2015;
use constant SCN_DWELLSTART         => 2016;
use constant SCN_DWELLEND           => 2017;
use constant SCN_ZOOM               => 2018;
use constant SCN_HOTSPOTCLICK       => 2019;
use constant SCN_HOTSPOTDOUBLECLICK => 2020;
use constant SCN_CALLTIPCLICK       => 2021;

#------------------------------------------------------------------------

#
# New scintilla control
#

sub new {

  my $class  = shift;

  my (%in)   = @_;
  my %out;

  ### Filtering option
  for my $option qw(
        -name -parent
        -left -top -width -height -pos -size
        -pushstyle -addstyle -popstyle -remstyle -notstyle -negstyle
        -exstyle -pushexstyle -addexstyle -popexstyle -remexstyle -notexstyle
        ) {
    $out{$option} = $in{$option} if exists $in{$option};
  }

  ### Default window
  my $constant     = ($Win32::GUI::VERSION < 1.0303 ?
                       Win32::GUI::constant("WIN32__GUI__STATIC",0) :
                       Win32::GUI::_constant("WIN32__GUI__STATIC"));
  $out{-addstyle}  = WS_CLIPCHILDREN;
  $out{-class}     = "Scintilla";

  ### Window style
  $out{-addstyle} |= WS_TABSTOP unless exists $in{-tabstop} && $in{-tabstop} == 0; #Default to -tabstop => 1
  $out{-addstyle} |= WS_VISIBLE unless exists $in{-visible} && $in{-visible} == 0; #Default to -visible => 1
  $out{-addstyle} |= WS_HSCROLL if     exists $in{-hscroll} && $in{-hscroll} == 1;
  $out{-addstyle} |= WS_VSCROLL if     exists $in{-vscroll} && $in{-vscroll} == 1;

  my $self = Win32::GUI->_new($constant, $class, -remstyle => 0xFFFFFFFF, %out);
  if (defined ($self)) {

    # Option Text :
    $self->SetText($in{-text}) if exists $in{-text};
    $self->SetReadOnly($in{-readonly}) if exists $in{-readonly};
  }

  return $self;
}

#
# Win32 shortcut
#

sub Win32::GUI::Window::AddScintilla {
  my $parent  = shift;
  return Win32::GUI::Scintilla->new (-parent => $parent, @_);
}

#------------------------------------------------------------------------
# Miscolous function
#------------------------------------------------------------------------

#
# Clear Scintilla Text
#

sub NewFile {
  my $self = shift;

  $self->ClearAll();
  $self->EmptyUndoBuffer();
  $self->SetSavePoint();
}

#
# Load text file to Scintilla
#

sub LoadFile {
  my ($self, $file) = @_;

  $self->ClearAll();
  $self->Cancel();
  $self->SetUndoCollection(0);

  open F, "<$file" or return 0;
  while ( <F> ) {
    $self->AppendText($_);
  }
  close F;

  $self->SetUndoCollection(1);
  $self->EmptyUndoBuffer();
  $self->SetSavePoint();
  $self->GotoPos(0);

  return 1;
}

#
# Save Scintilla text to file
#

sub SaveFile {
  my ($self, $file) = @_;

  open F, ">$file" or return 0;

  for my $i (0..$self->GetLineCount()) {
    print F $self->GetLine ($i);
  }

  close F;

  $self->SetSavePoint();

  return 1;
}

#
# Help routine for StyleSet
#

sub StyleSetSpec {
  my ($self, $style, $textstyle) = @_;

  foreach my $prop (split (/,/, $textstyle)) {

    my ($key, $value) = split (/:/, $prop);

    $self->StyleSetFore($style, $value) if $key eq 'fore';
    $self->StyleSetBack($style, $value) if $key eq 'back';

    $self->StyleSetFont($style, $value) if $key eq 'face';

    $self->StyleSetSize($style, int ($value) )  if $key eq 'size';

    $self->StyleSetBold($style, 1)      if $key eq 'bold';
    $self->StyleSetBold($style, 0)      if $key eq 'notbold';
    $self->StyleSetItalic($style, 1)    if $key eq 'italic';
    $self->StyleSetItalic($style, 0)    if $key eq 'notitalic';
    $self->StyleSetUnderline($style, 1) if $key eq 'underline';
    $self->StyleSetUnderline($style, 0) if $key eq 'notunderline';
    $self->StyleSetEOLFilled ($style, 1) if $key eq 'eolfilled';
    $self->StyleSetEOLFilled ($style, 0) if $key eq 'noteolfilled';
  }
}

#------------------------------------------------------------------------
# Begin Autogenerate
#------------------------------------------------------------------------

use constant INVALID_POSITION => -1 ;
# Define start of Scintilla messages to be greater than all Windows edit (EM_*) messages
# as many EM_ messages can be used although that use is deprecated.
use constant SCI_START => 2000 ;
use constant SCI_OPTIONAL_START => 3000 ;
use constant SCI_LEXER_START => 4000 ;
# Add text to the document at current position.
# AddText(text)
sub AddText {
  my ($self, $text) = @_;
  my $length = length $text;
  return $self->SendMessageNP (2001, $length, $text);
}
# Add array of cells to document.
# AddStyledText(styledtext)
sub AddStyledText {
  my ($self, $text) = @_;
  my $length = length $text;
  return $self->SendMessageNP (2002, $length, $text);
}
# Insert string at a position.
sub InsertText {
  my ($self, $pos, $text) = @_;
  return $self->SendMessageNP (2003, $pos, $text);
}
# Delete all text in the document.
sub ClearAll {
  my $self = shift;
  return $self->SendMessage (2004, 0, 0);
}
# Set all style bytes to 0, remove all folding information.
sub ClearDocumentStyle {
  my $self = shift;
  return $self->SendMessage (2005, 0, 0);
}
# Returns the number of characters in the document.
sub GetLength {
  my $self = shift;
  return $self->SendMessage (2006, 0, 0);
}
# Returns the character byte at the position.
sub GetCharAt {
  my ($self, $pos) = @_;
  return chr $self->SendMessage (2007, $pos, 0);
}
# Returns the position of the caret.
sub GetCurrentPos {
  my $self = shift;
  return $self->SendMessage (2008, 0, 0);
}
# Returns the position of the opposite end of the selection to the caret.
sub GetAnchor {
  my $self = shift;
  return $self->SendMessage (2009, 0, 0);
}
# Returns the style byte at the position.
sub GetStyleAt {
  my ($self, $pos) = @_;
  return $self->SendMessage (2010, $pos, 0);
}
# Redoes the next action on the undo history.
sub Redo {
  my $self = shift;
  return $self->SendMessage (2011, 0, 0);
}
# Choose between collecting actions into the undo
# history and discarding them.
sub SetUndoCollection {
  my ($self, $collectUndo) = @_;
  return $self->SendMessage (2012, $collectUndo, 0);
}
# Select all the text in the document.
sub SelectAll {
  my $self = shift;
  return $self->SendMessage (2013, 0, 0);
}
# Remember the current position in the undo history as the position
# at which the document was saved.
sub SetSavePoint {
  my $self = shift;
  return $self->SendMessage (2014, 0, 0);
}
# Retrieve a buffer of cells.
# Returns the number of bytes in the buffer not including terminating NULs.
sub GetStyledText {
  my $self = shift;
  my $start = shift || 0;
  my $end = shift || $self->GetLength();

  return undef if $start >= $end;

  my $text = " " x (($end - $start + 1)*2);
  my $textrange = pack("LLp", $start, $end, $text);
  $self->SendMessageNP (2015, 0, $textrange);
  return $text;
}
# Are there any redoable actions in the undo history?
sub CanRedo {
  my $self = shift;
  return $self->SendMessage (2016, 0, 0);
}
# Retrieve the line number at which a particular marker is located.
sub MarkerLineFromHandle {
  my ($self, $handle) = @_;
  return $self->SendMessage (2017, $handle, 0);
}
# Delete a marker.
sub MarkerDeleteHandle {
  my ($self, $handle) = @_;
  return $self->SendMessage (2018, $handle, 0);
}
# Is undo history being collected?
sub GetUndoCollection {
  my $self = shift;
  return $self->SendMessage (2019, 0, 0);
}
use constant SCWS_INVISIBLE => 0 ;
use constant SCWS_VISIBLEALWAYS => 1 ;
use constant SCWS_VISIBLEAFTERINDENT => 2 ;
# Are white space characters currently visible?
# Returns one of SCWS_* constants.
sub GetViewWS {
  my $self = shift;
  return $self->SendMessage (2020, 0, 0);
}
# Make white space characters invisible, always visible or visible outside indentation.
sub SetViewWS {
  my ($self, $viewWS) = @_;
  return $self->SendMessage (2021, $viewWS, 0);
}
# Find the position from a point within the window.
sub PositionFromPoint {
  my ($self, $x, $y) = @_;
  return $self->SendMessage (2022, $x, $y);
}
# Find the position from a point within the window but return
# INVALID_POSITION if not close to text.
sub PositionFromPointClose {
  my ($self, $x, $y) = @_;
  return $self->SendMessage (2023, $x, $y);
}
# Set caret to start of a line and ensure it is visible.
sub GotoLine {
  my ($self, $line) = @_;
  return $self->SendMessage (2024, $line, 0);
}
# Set caret to a position and ensure it is visible.
sub GotoPos {
  my ($self, $pos) = @_;
  return $self->SendMessage (2025, $pos, 0);
}
# Set the selection anchor to a position. The anchor is the opposite
# end of the selection from the caret.
sub SetAnchor {
  my ($self, $posAnchor) = @_;
  return $self->SendMessage (2026, $posAnchor, 0);
}
# Retrieve the text of the line containing the caret.
# Returns the index of the caret on the line.
# GetCurline () : Return curent line Text
sub GetCurLine {
  my ($self) = @_;
  my $line   = $self->GetLineFromPosition ($self->GetCurrentPos());
  my $lenght = $self->LineLength($line);
  my $text   = " " x ($lenght+1);

  if ($self->SendMessageNP (2027, $lenght, $text)) {
    return $text;
  } else {
    return undef;
  }
}
# Retrieve the position of the last correctly styled character.
sub GetEndStyled {
  my $self = shift;
  return $self->SendMessage (2028, 0, 0);
}
use constant SC_EOL_CRLF => 0 ;
use constant SC_EOL_CR => 1 ;
use constant SC_EOL_LF => 2 ;
# Convert all line endings in the document to one mode.
sub ConvertEOLs {
  my ($self, $eolMode) = @_;
  return $self->SendMessage (2029, $eolMode, 0);
}
# Retrieve the current end of line mode - one of CRLF, CR, or LF.
sub GetEOLMode {
  my $self = shift;
  return $self->SendMessage (2030, 0, 0);
}
# Set the current end of line mode.
sub SetEOLMode {
  my ($self, $eolMode) = @_;
  return $self->SendMessage (2031, $eolMode, 0);
}
# Set the current styling position to pos and the styling mask to mask.
# The styling mask can be used to protect some bits in each styling byte from modification.
sub StartStyling {
  my ($self, $pos, $mask) = @_;
  return $self->SendMessage (2032, $pos, $mask);
}
# Change style from current styling position for length characters to a style
# and move the current styling position to after this newly styled segment.
sub SetStyling {
  my ($self, $length, $style) = @_;
  return $self->SendMessage (2033, $length, $style);
}
# Is drawing done first into a buffer or direct to the screen?
sub GetBufferedDraw {
  my $self = shift;
  return $self->SendMessage (2034, 0, 0);
}
# If drawing is buffered then each line of text is drawn into a bitmap buffer
# before drawing it to the screen to avoid flicker.
sub SetBufferedDraw {
  my ($self, $buffered) = @_;
  return $self->SendMessage (2035, $buffered, 0);
}
# Change the visible size of a tab to be a multiple of the width of a space character.
sub SetTabWidth {
  my ($self, $tabWidth) = @_;
  return $self->SendMessage (2036, $tabWidth, 0);
}
# Retrieve the visible size of a tab.
sub GetTabWidth {
  my $self = shift;
  return $self->SendMessage (2121, 0, 0);
}
# The SC_CP_UTF8 value can be used to enter Unicode mode.
# This is the same value as CP_UTF8 in Windows
use constant SC_CP_UTF8 => 65001 ;
# The SC_CP_DBCS value can be used to indicate a DBCS mode for GTK+.
use constant SC_CP_DBCS => 1 ;
# Set the code page used to interpret the bytes of the document as characters.
# The SC_CP_UTF8 value can be used to enter Unicode mode.
sub SetCodePage {
  my ($self, $codePage) = @_;
  return $self->SendMessage (2037, $codePage, 0);
}
# In palette mode, Scintilla uses the environment's palette calls to display
# more colours. This may lead to ugly displays.
sub SetUsePalette {
  my ($self, $usePalette) = @_;
  return $self->SendMessage (2039, $usePalette, 0);
}
use constant MARKER_MAX => 31 ;
use constant SC_MARK_CIRCLE => 0 ;
use constant SC_MARK_ROUNDRECT => 1 ;
use constant SC_MARK_ARROW => 2 ;
use constant SC_MARK_SMALLRECT => 3 ;
use constant SC_MARK_SHORTARROW => 4 ;
use constant SC_MARK_EMPTY => 5 ;
use constant SC_MARK_ARROWDOWN => 6 ;
use constant SC_MARK_MINUS => 7 ;
use constant SC_MARK_PLUS => 8 ;
# Shapes used for outlining column.
use constant SC_MARK_VLINE => 9 ;
use constant SC_MARK_LCORNER => 10 ;
use constant SC_MARK_TCORNER => 11 ;
use constant SC_MARK_BOXPLUS => 12 ;
use constant SC_MARK_BOXPLUSCONNECTED => 13 ;
use constant SC_MARK_BOXMINUS => 14 ;
use constant SC_MARK_BOXMINUSCONNECTED => 15 ;
use constant SC_MARK_LCORNERCURVE => 16 ;
use constant SC_MARK_TCORNERCURVE => 17 ;
use constant SC_MARK_CIRCLEPLUS => 18 ;
use constant SC_MARK_CIRCLEPLUSCONNECTED => 19 ;
use constant SC_MARK_CIRCLEMINUS => 20 ;
use constant SC_MARK_CIRCLEMINUSCONNECTED => 21 ;
# Invisible mark that only sets the line background color.
use constant SC_MARK_BACKGROUND => 22 ;
use constant SC_MARK_DOTDOTDOT => 23 ;
use constant SC_MARK_ARROWS => 24 ;
use constant SC_MARK_PIXMAP => 25 ;
use constant SC_MARK_FULLRECT => 26 ;
use constant SC_MARK_CHARACTER => 10000 ;
# Markers used for outlining column.
use constant SC_MARKNUM_FOLDEREND => 25 ;
use constant SC_MARKNUM_FOLDEROPENMID => 26 ;
use constant SC_MARKNUM_FOLDERMIDTAIL => 27 ;
use constant SC_MARKNUM_FOLDERTAIL => 28 ;
use constant SC_MARKNUM_FOLDERSUB => 29 ;
use constant SC_MARKNUM_FOLDER => 30 ;
use constant SC_MARKNUM_FOLDEROPEN => 31 ;
use constant SC_MASK_FOLDERS => 0xFE000000 ;
# Set the symbol used for a particular marker number.
sub MarkerDefine {
  my ($self, $markerNumber, $markerSymbol) = @_;
  return $self->SendMessage (2040, $markerNumber, $markerSymbol);
}
# Set the foreground colour used for a particular marker number.
sub MarkerSetFore {
  my ($self, $markerNumber, $fore) = @_;
  $fore =~ s/.(..)(..)(..)/$3$2$1/;
  return $self->SendMessage (2041, $markerNumber, int hex $fore);
}
# Set the background colour used for a particular marker number.
sub MarkerSetBack {
  my ($self, $markerNumber, $back) = @_;
  $back =~ s/.(..)(..)(..)/$3$2$1/;
  return $self->SendMessage (2042, $markerNumber, int hex $back);
}
# Add a marker to a line, returning an ID which can be used to find or delete the marker.
sub MarkerAdd {
  my ($self, $line, $markerNumber) = @_;
  return $self->SendMessage (2043, $line, $markerNumber);
}
# Delete a marker from a line.
sub MarkerDelete {
  my ($self, $line, $markerNumber) = @_;
  return $self->SendMessage (2044, $line, $markerNumber);
}
# Delete all markers with a particular number from all lines.
sub MarkerDeleteAll {
  my ($self, $markerNumber) = @_;
  return $self->SendMessage (2045, $markerNumber, 0);
}
# Get a bit mask of all the markers set on a line.
sub MarkerGet {
  my ($self, $line) = @_;
  return $self->SendMessage (2046, $line, 0);
}
# Find the next line after lineStart that includes a marker in mask.
sub MarkerNext {
  my ($self, $lineStart, $markerMask) = @_;
  return $self->SendMessage (2047, $lineStart, $markerMask);
}
# Find the previous line before lineStart that includes a marker in mask.
sub MarkerPrevious {
  my ($self, $lineStart, $markerMask) = @_;
  return $self->SendMessage (2048, $lineStart, $markerMask);
}
# Define a marker from a pixmap.
sub MarkerDefinePixmap {
  my ($self, $markerNumber, $pixmap) = @_;
  return $self->SendMessageNP (2049, $markerNumber, $pixmap);
}
# Add a set of markers to a line.
sub MarkerAddSet {
  my ($self, $line, $set) = @_;
  return $self->SendMessage (2466, $line, $set);
}
use constant SC_MARGIN_SYMBOL => 0 ;
use constant SC_MARGIN_NUMBER => 1 ;
# Set a margin to be either numeric or symbolic.
sub SetMarginTypeN {
  my ($self, $margin, $marginType) = @_;
  return $self->SendMessage (2240, $margin, $marginType);
}
# Retrieve the type of a margin.
sub GetMarginTypeN {
  my ($self, $margin) = @_;
  return $self->SendMessage (2241, $margin, 0);
}
# Set the width of a margin to a width expressed in pixels.
sub SetMarginWidthN {
  my ($self, $margin, $pixelWidth) = @_;
  return $self->SendMessage (2242, $margin, $pixelWidth);
}
# Retrieve the width of a margin in pixels.
sub GetMarginWidthN {
  my ($self, $margin) = @_;
  return $self->SendMessage (2243, $margin, 0);
}
# Set a mask that determines which markers are displayed in a margin.
sub SetMarginMaskN {
  my ($self, $margin, $mask) = @_;
  return $self->SendMessage (2244, $margin, $mask);
}
# Retrieve the marker mask of a margin.
sub GetMarginMaskN {
  my ($self, $margin) = @_;
  return $self->SendMessage (2245, $margin, 0);
}
# Make a margin sensitive or insensitive to mouse clicks.
sub SetMarginSensitiveN {
  my ($self, $margin, $sensitive) = @_;
  return $self->SendMessage (2246, $margin, $sensitive);
}
# Retrieve the mouse click sensitivity of a margin.
sub GetMarginSensitiveN {
  my ($self, $margin) = @_;
  return $self->SendMessage (2247, $margin, 0);
}
# Styles in range 32..38 are predefined for parts of the UI and are not used as normal styles.
# Style 39 is for future use.
use constant STYLE_DEFAULT => 32 ;
use constant STYLE_LINENUMBER => 33 ;
use constant STYLE_BRACELIGHT => 34 ;
use constant STYLE_BRACEBAD => 35 ;
use constant STYLE_CONTROLCHAR => 36 ;
use constant STYLE_INDENTGUIDE => 37 ;
use constant STYLE_CALLTIP => 38 ;
use constant STYLE_LASTPREDEFINED => 39 ;
use constant STYLE_MAX => 127 ;
# Character set identifiers are used in StyleSetCharacterSet.
# The values are the same as the Windows *_CHARSET values.
use constant SC_CHARSET_ANSI => 0 ;
use constant SC_CHARSET_DEFAULT => 1 ;
use constant SC_CHARSET_BALTIC => 186 ;
use constant SC_CHARSET_CHINESEBIG5 => 136 ;
use constant SC_CHARSET_EASTEUROPE => 238 ;
use constant SC_CHARSET_GB2312 => 134 ;
use constant SC_CHARSET_GREEK => 161 ;
use constant SC_CHARSET_HANGUL => 129 ;
use constant SC_CHARSET_MAC => 77 ;
use constant SC_CHARSET_OEM => 255 ;
use constant SC_CHARSET_RUSSIAN => 204 ;
use constant SC_CHARSET_CYRILLIC => 1251 ;
use constant SC_CHARSET_SHIFTJIS => 128 ;
use constant SC_CHARSET_SYMBOL => 2 ;
use constant SC_CHARSET_TURKISH => 162 ;
use constant SC_CHARSET_JOHAB => 130 ;
use constant SC_CHARSET_HEBREW => 177 ;
use constant SC_CHARSET_ARABIC => 178 ;
use constant SC_CHARSET_VIETNAMESE => 163 ;
use constant SC_CHARSET_THAI => 222 ;
use constant SC_CHARSET_8859_15 => 1000 ;
# Clear all the styles and make equivalent to the global default style.
sub StyleClearAll {
  my $self = shift;
  return $self->SendMessage (2050, 0, 0);
}
# Set the foreground colour of a style.
sub StyleSetFore {
  my ($self, $style, $fore) = @_;
  $fore =~ s/.(..)(..)(..)/$3$2$1/;
  return $self->SendMessage (2051, $style, int hex $fore);
}
# Set the background colour of a style.
sub StyleSetBack {
  my ($self, $style, $back) = @_;
  $back =~ s/.(..)(..)(..)/$3$2$1/;
  return $self->SendMessage (2052, $style, int hex $back);
}
# Set a style to be bold or not.
sub StyleSetBold {
  my ($self, $style, $bold) = @_;
  return $self->SendMessage (2053, $style, $bold);
}
# Set a style to be italic or not.
sub StyleSetItalic {
  my ($self, $style, $italic) = @_;
  return $self->SendMessage (2054, $style, $italic);
}
# Set the size of characters of a style.
sub StyleSetSize {
  my ($self, $style, $sizePoints) = @_;
  return $self->SendMessage (2055, $style, $sizePoints);
}
# Set the font of a style.
sub StyleSetFont {
  my ($self, $style, $fontName) = @_;
  return $self->SendMessageNP (2056, $style, $fontName);
}
# Set a style to have its end of line filled or not.
sub StyleSetEOLFilled {
  my ($self, $style, $filled) = @_;
  return $self->SendMessage (2057, $style, $filled);
}
# Reset the default style to its state at startup
sub StyleResetDefault {
  my $self = shift;
  return $self->SendMessage (2058, 0, 0);
}
# Set a style to be underlined or not.
sub StyleSetUnderline {
  my ($self, $style, $underline) = @_;
  return $self->SendMessage (2059, $style, $underline);
}
use constant SC_CASE_MIXED => 0 ;
use constant SC_CASE_UPPER => 1 ;
use constant SC_CASE_LOWER => 2 ;
# Set a style to be mixed case, or to force upper or lower case.
sub StyleSetCase {
  my ($self, $style, $caseForce) = @_;
  return $self->SendMessage (2060, $style, $caseForce);
}
# Set the character set of the font in a style.
sub StyleSetCharacterSet {
  my ($self, $style, $characterSet) = @_;
  return $self->SendMessage (2066, $style, $characterSet);
}
# Set a style to be a hotspot or not.
sub StyleSetHotSpot {
  my ($self, $style, $hotspot) = @_;
  return $self->SendMessage (2409, $style, $hotspot);
}
# Set the foreground colour of the selection and whether to use this setting.
sub SetSelFore {
  my ($self, $useSetting, $fore) = @_;
  $fore =~ s/.(..)(..)(..)/$3$2$1/;
  return $self->SendMessage (2067, $useSetting, int hex $fore);
}
# Set the background colour of the selection and whether to use this setting.
sub SetSelBack {
  my ($self, $useSetting, $back) = @_;
  $back =~ s/.(..)(..)(..)/$3$2$1/;
  return $self->SendMessage (2068, $useSetting, int hex $back);
}
# Set the foreground colour of the caret.
sub SetCaretFore {
  my ($self, $fore) = @_;
  $fore =~ s/.(..)(..)(..)/$3$2$1/;
  return $self->SendMessage (2069, int hex $fore, 0);
}
# When key+modifier combination km is pressed perform msg.
sub AssignCmdKey {
  my ($self, $key, $modifiers, $msg) = @_;
  my $param = pack ('ss', $key, $modifiers);
  return $self->SendMessage (2070, $param, $msg);
}
# When key+modifier combination km is pressed do nothing.
sub ClearCmdKey {
  my ($self, $key, $modifiers) = @_;
  my $param = pack ('ss', $key, $modifiers);
  return $self->SendMessage (2071, $param, 0);
}
# Drop all key mappings.
sub ClearAllCmdKeys {
  my $self = shift;
  return $self->SendMessage (2072, 0, 0);
}
# Set the styles for a segment of the document.
sub SetStylingEx {
  my ($self, $length, $styles) = @_;
  return $self->SendMessageNP (2073, $length, $styles);
}
# Set a style to be visible or not.
sub StyleSetVisible {
  my ($self, $style, $visible) = @_;
  return $self->SendMessage (2074, $style, $visible);
}
# Get the time in milliseconds that the caret is on and off.
sub GetCaretPeriod {
  my $self = shift;
  return $self->SendMessage (2075, 0, 0);
}
# Get the time in milliseconds that the caret is on and off. 0 = steady on.
sub SetCaretPeriod {
  my ($self, $periodMilliseconds) = @_;
  return $self->SendMessage (2076, $periodMilliseconds, 0);
}
# Set the set of characters making up words for when moving or selecting by word.
# First sets deaults like SetCharsDefault.
sub SetWordChars {
  my ($self, $characters) = @_;
  return $self->SendMessageNP (2077, 0, $characters);
}
# Start a sequence of actions that is undone and redone as a unit.
# May be nested.
sub BeginUndoAction {
  my $self = shift;
  return $self->SendMessage (2078, 0, 0);
}
# End a sequence of actions that is undone and redone as a unit.
sub EndUndoAction {
  my $self = shift;
  return $self->SendMessage (2079, 0, 0);
}
use constant INDIC_MAX => 7 ;
use constant INDIC_PLAIN => 0 ;
use constant INDIC_SQUIGGLE => 1 ;
use constant INDIC_TT => 2 ;
use constant INDIC_DIAGONAL => 3 ;
use constant INDIC_STRIKE => 4 ;
use constant INDIC_HIDDEN => 5 ;
use constant INDIC_BOX => 6 ;
use constant INDIC_ROUNDBOX => 7 ;
use constant INDIC0_MASK => 0x20 ;
use constant INDIC1_MASK => 0x40 ;
use constant INDIC2_MASK => 0x80 ;
use constant INDICS_MASK => 0xE0 ;
# Set an indicator to plain, squiggle or TT.
sub IndicSetStyle {
  my ($self, $indic, $style) = @_;
  return $self->SendMessage (2080, $indic, $style);
}
# Retrieve the style of an indicator.
sub IndicGetStyle {
  my ($self, $indic) = @_;
  return $self->SendMessage (2081, $indic, 0);
}
# Set the foreground colour of an indicator.
sub IndicSetFore {
  my ($self, $indic, $fore) = @_;
  $fore =~ s/.(..)(..)(..)/$3$2$1/;
  return $self->SendMessage (2082, $indic, int hex $fore);
}
# Retrieve the foreground colour of an indicator.
sub IndicGetFore {
  my ($self, $indic) = @_;
  my $colour = $self->SendMessage (2083, $indic, 0);
  $colour = sprintf ('#%x', $colour);
  $colour =~ s/(.)(..)(..)(..)/$1$4$3$2/;
  return $colour;
}# Set the foreground colour of all whitespace and whether to use this setting.
sub SetWhitespaceFore {
  my ($self, $useSetting, $fore) = @_;
  $fore =~ s/.(..)(..)(..)/$3$2$1/;
  return $self->SendMessage (2084, $useSetting, int hex $fore);
}
# Set the background colour of all whitespace and whether to use this setting.
sub SetWhitespaceBack {
  my ($self, $useSetting, $back) = @_;
  $back =~ s/.(..)(..)(..)/$3$2$1/;
  return $self->SendMessage (2085, $useSetting, int hex $back);
}
# Divide each styling byte into lexical class bits (default: 5) and indicator
# bits (default: 3). If a lexer requires more than 32 lexical states, then this
# is used to expand the possible states.
sub SetStyleBits {
  my ($self, $bits) = @_;
  return $self->SendMessage (2090, $bits, 0);
}
# Retrieve number of bits in style bytes used to hold the lexical state.
sub GetStyleBits {
  my $self = shift;
  return $self->SendMessage (2091, 0, 0);
}
# Used to hold extra styling information for each line.
sub SetLineState {
  my ($self, $line, $state) = @_;
  return $self->SendMessage (2092, $line, $state);
}
# Retrieve the extra styling information for a line.
sub GetLineState {
  my ($self, $line) = @_;
  return $self->SendMessage (2093, $line, 0);
}
# Retrieve the last line number that has line state.
sub GetMaxLineState {
  my $self = shift;
  return $self->SendMessage (2094, 0, 0);
}
# Is the background of the line containing the caret in a different colour?
sub GetCaretLineVisible {
  my $self = shift;
  return $self->SendMessage (2095, 0, 0);
}
# Display the background of the line containing the caret in a different colour.
sub SetCaretLineVisible {
  my ($self, $show) = @_;
  return $self->SendMessage (2096, $show, 0);
}
# Get the colour of the background of the line containing the caret.
sub GetCaretLineBack {
  my $self = shift;
  my $colour = $self->SendMessage (2097, 0, 0);
  $colour = sprintf ('#%x', $colour);
  $colour =~ s/(.)(..)(..)(..)/$1$4$3$2/;
  return $colour;
}
# Set the colour of the background of the line containing the caret.
sub SetCaretLineBack {
  my ($self, $back) = @_;
  $back =~ s/.(..)(..)(..)/$3$2$1/;
  return $self->SendMessage (2098, int hex $back, 0);
}
# Set a style to be changeable or not (read only).
# Experimental feature, currently buggy.
sub StyleSetChangeable {
  my ($self, $style, $changeable) = @_;
  return $self->SendMessage (2099, $style, $changeable);
}
# Display a auto-completion list.
# The lenEntered parameter indicates how many characters before
# the caret should be used to provide context.
sub AutoCShow {
  my ($self, $lenEntered, $itemList) = @_;
  return $self->SendMessageNP (2100, $lenEntered, $itemList);
}
# Remove the auto-completion list from the screen.
sub AutoCCancel {
  my $self = shift;
  return $self->SendMessage (2101, 0, 0);
}
# Is there an auto-completion list visible?
sub AutoCActive {
  my $self = shift;
  return $self->SendMessage (2102, 0, 0);
}
# Retrieve the position of the caret when the auto-completion list was displayed.
sub AutoCPosStart {
  my $self = shift;
  return $self->SendMessage (2103, 0, 0);
}
# User has selected an item so remove the list and insert the selection.
sub AutoCComplete {
  my $self = shift;
  return $self->SendMessage (2104, 0, 0);
}
# Define a set of character that when typed cancel the auto-completion list.
sub AutoCStops {
  my ($self, $characterSet) = @_;
  return $self->SendMessageNP (2105, 0, $characterSet);
}
# Change the separator character in the string setting up an auto-completion list.
# Default is space but can be changed if items contain space.
sub AutoCSetSeparator {
  my ($self, $separatorCharacter) = @_;
  return $self->SendMessage (2106, $separatorCharacter, 0);
}
# Retrieve the auto-completion list separator character.
sub AutoCGetSeparator {
  my $self = shift;
  return $self->SendMessage (2107, 0, 0);
}
# Select the item in the auto-completion list that starts with a string.
sub AutoCSelect {
  my ($self, $text) = @_;
  return $self->SendMessageNP (2108, 0, $text);
}
# Should the auto-completion list be cancelled if the user backspaces to a
# position before where the box was created.
sub AutoCSetCancelAtStart {
  my ($self, $cancel) = @_;
  return $self->SendMessage (2110, $cancel, 0);
}
# Retrieve whether auto-completion cancelled by backspacing before start.
sub AutoCGetCancelAtStart {
  my $self = shift;
  return $self->SendMessage (2111, 0, 0);
}
# Define a set of characters that when typed will cause the autocompletion to
# choose the selected item.
sub AutoCSetFillUps {
  my ($self, $characterSet) = @_;
  return $self->SendMessageNP (2112, 0, $characterSet);
}
# Should a single item auto-completion list automatically choose the item.
sub AutoCSetChooseSingle {
  my ($self, $chooseSingle) = @_;
  return $self->SendMessage (2113, $chooseSingle, 0);
}
# Retrieve whether a single item auto-completion list automatically choose the item.
sub AutoCGetChooseSingle {
  my $self = shift;
  return $self->SendMessage (2114, 0, 0);
}
# Set whether case is significant when performing auto-completion searches.
sub AutoCSetIgnoreCase {
  my ($self, $ignoreCase) = @_;
  return $self->SendMessage (2115, $ignoreCase, 0);
}
# Retrieve state of ignore case flag.
sub AutoCGetIgnoreCase {
  my $self = shift;
  return $self->SendMessage (2116, 0, 0);
}
# Display a list of strings and send notification when user chooses one.
sub UserListShow {
  my ($self, $listType, $itemList) = @_;
  return $self->SendMessageNP (2117, $listType, $itemList);
}
# Set whether or not autocompletion is hidden automatically when nothing matches.
sub AutoCSetAutoHide {
  my ($self, $autoHide) = @_;
  return $self->SendMessage (2118, $autoHide, 0);
}
# Retrieve whether or not autocompletion is hidden automatically when nothing matches.
sub AutoCGetAutoHide {
  my $self = shift;
  return $self->SendMessage (2119, 0, 0);
}
# Set whether or not autocompletion deletes any word characters
# after the inserted text upon completion.
sub AutoCSetDropRestOfWord {
  my ($self, $dropRestOfWord) = @_;
  return $self->SendMessage (2270, $dropRestOfWord, 0);
}
# Retrieve whether or not autocompletion deletes any word characters
# after the inserted text upon completion.
sub AutoCGetDropRestOfWord {
  my $self = shift;
  return $self->SendMessage (2271, 0, 0);
}
# Register an XPM image for use in autocompletion lists.
sub RegisterImage {
  my ($self, $type, $xpmData) = @_;
  return $self->SendMessageNP (2405, $type, $xpmData);
}
# Clear all the registered XPM images.
sub ClearRegisteredImages {
  my $self = shift;
  return $self->SendMessage (2408, 0, 0);
}
# Retrieve the auto-completion list type-separator character.
sub AutoCGetTypeSeparator {
  my $self = shift;
  return $self->SendMessage (2285, 0, 0);
}
# Change the type-separator character in the string setting up an auto-completion list.
# Default is '?' but can be changed if items contain '?'.
sub AutoCSetTypeSeparator {
  my ($self, $separatorCharacter) = @_;
  return $self->SendMessage (2286, $separatorCharacter, 0);
}
# Set the maximum width, in characters, of auto-completion and user lists.
# Set to 0 to autosize to fit longest item, which is the default.
sub AutoCSetMaxWidth {
  my ($self, $characterCount) = @_;
  return $self->SendMessage (2208, $characterCount, 0);
}
# Get the maximum width, in characters, of auto-completion and user lists.
sub AutoCGetMaxWidth {
  my $self = shift;
  return $self->SendMessage (2209, 0, 0);
}
# Set the maximum height, in rows, of auto-completion and user lists.
# The default is 5 rows.
sub AutoCSetMaxHeight {
  my ($self, $rowCount) = @_;
  return $self->SendMessage (2210, $rowCount, 0);
}
# Set the maximum height, in rows, of auto-completion and user lists.
sub AutoCGetMaxHeight {
  my $self = shift;
  return $self->SendMessage (2211, 0, 0);
}
# Set the number of spaces used for one level of indentation.
sub SetIndent {
  my ($self, $indentSize) = @_;
  return $self->SendMessage (2122, $indentSize, 0);
}
# Retrieve indentation size.
sub GetIndent {
  my $self = shift;
  return $self->SendMessage (2123, 0, 0);
}
# Indentation will only use space characters if useTabs is false, otherwise
# it will use a combination of tabs and spaces.
sub SetUseTabs {
  my ($self, $useTabs) = @_;
  return $self->SendMessage (2124, $useTabs, 0);
}
# Retrieve whether tabs will be used in indentation.
sub GetUseTabs {
  my $self = shift;
  return $self->SendMessage (2125, 0, 0);
}
# Change the indentation of a line to a number of columns.
sub SetLineIndentation {
  my ($self, $line, $indentSize) = @_;
  return $self->SendMessage (2126, $line, $indentSize);
}
# Retrieve the number of columns that a line is indented.
sub GetLineIndentation {
  my ($self, $line) = @_;
  return $self->SendMessage (2127, $line, 0);
}
# Retrieve the position before the first non indentation character on a line.
sub GetLineIndentPosition {
  my ($self, $line) = @_;
  return $self->SendMessage (2128, $line, 0);
}
# Retrieve the column number of a position, taking tab width into account.
sub GetColumn {
  my ($self, $pos) = @_;
  return $self->SendMessage (2129, $pos, 0);
}
# Show or hide the horizontal scroll bar.
sub SetHScrollBar {
  my ($self, $show) = @_;
  return $self->SendMessage (2130, $show, 0);
}
# Is the horizontal scroll bar visible?
sub GetHScrollBar {
  my $self = shift;
  return $self->SendMessage (2131, 0, 0);
}
# Show or hide indentation guides.
sub SetIndentationGuides {
  my ($self, $show) = @_;
  return $self->SendMessage (2132, $show, 0);
}
# Are the indentation guides visible?
sub GetIndentationGuides {
  my $self = shift;
  return $self->SendMessage (2133, 0, 0);
}
# Set the highlighted indentation guide column.
# 0 = no highlighted guide.
sub SetHighlightGuide {
  my ($self, $column) = @_;
  return $self->SendMessage (2134, $column, 0);
}
# Get the highlighted indentation guide column.
sub GetHighlightGuide {
  my $self = shift;
  return $self->SendMessage (2135, 0, 0);
}
# Get the position after the last visible characters on a line.
sub GetLineEndPosition {
  my ($self, $line) = @_;
  return $self->SendMessage (2136, $line, 0);
}
# Get the code page used to interpret the bytes of the document as characters.
sub GetCodePage {
  my $self = shift;
  return $self->SendMessage (2137, 0, 0);
}
# Get the foreground colour of the caret.
sub GetCaretFore {
  my $self = shift;
  my $colour = $self->SendMessage (2138, 0, 0);
  $colour = sprintf ('#%x', $colour);
  $colour =~ s/(.)(..)(..)(..)/$1$4$3$2/;
  return $colour;
}
# In palette mode?
sub GetUsePalette {
  my $self = shift;
  return $self->SendMessage (2139, 0, 0);
}
# In read-only mode?
sub GetReadOnly {
  my $self = shift;
  return $self->SendMessage (2140, 0, 0);
}
# Sets the position of the caret.
sub SetCurrentPos {
  my ($self, $pos) = @_;
  return $self->SendMessage (2141, $pos, 0);
}
# Sets the position that starts the selection - this becomes the anchor.
sub SetSelectionStart {
  my ($self, $pos) = @_;
  return $self->SendMessage (2142, $pos, 0);
}
# Returns the position at the start of the selection.
sub GetSelectionStart {
  my $self = shift;
  return $self->SendMessage (2143, 0, 0);
}
# Sets the position that ends the selection - this becomes the currentPosition.
sub SetSelectionEnd {
  my ($self, $pos) = @_;
  return $self->SendMessage (2144, $pos, 0);
}
# Returns the position at the end of the selection.
sub GetSelectionEnd {
  my $self = shift;
  return $self->SendMessage (2145, 0, 0);
}
# Sets the print magnification added to the point size of each style for printing.
sub SetPrintMagnification {
  my ($self, $magnification) = @_;
  return $self->SendMessage (2146, $magnification, 0);
}
# Returns the print magnification.
sub GetPrintMagnification {
  my $self = shift;
  return $self->SendMessage (2147, 0, 0);
}
# PrintColourMode - use same colours as screen.
use constant SC_PRINT_NORMAL => 0 ;
# PrintColourMode - invert the light value of each style for printing.
use constant SC_PRINT_INVERTLIGHT => 1 ;
# PrintColourMode - force black text on white background for printing.
use constant SC_PRINT_BLACKONWHITE => 2 ;
# PrintColourMode - text stays coloured, but all background is forced to be white for printing.
use constant SC_PRINT_COLOURONWHITE => 3 ;
# PrintColourMode - only the default-background is forced to be white for printing.
use constant SC_PRINT_COLOURONWHITEDEFAULTBG => 4 ;
# Modify colours when printing for clearer printed text.
sub SetPrintColourMode {
  my ($self, $mode) = @_;
  return $self->SendMessage (2148, $mode, 0);
}
# Returns the print colour mode.
sub GetPrintColourMode {
  my $self = shift;
  return $self->SendMessage (2149, 0, 0);
}
use constant SCFIND_WHOLEWORD => 2 ;
use constant SCFIND_MATCHCASE => 4 ;
use constant SCFIND_WORDSTART => 0x00100000 ;
use constant SCFIND_REGEXP => 0x00200000 ;
use constant SCFIND_POSIX => 0x00400000 ;
# Find some text in the document.
# FindText (textToFind, start=0, end=GetLength(), flag = SCFIND_WHOLEWORD)
sub FindText {
  my $self       = shift;
  my $text       = shift;
  my $start      = shift || 0;
  my $end        = shift || $self->GetLength();
  my $flag       = shift || SCFIND_WHOLEWORD;

  return undef if $start >= $end;

  my $texttofind =  pack("LLpLL", $start, $end, $text, 0, 0);
  my $pos = $self->SendMessageNP (2150, $flag, $texttofind);
  return $pos unless defined wantarray;
  my @res = unpack("LLpLL", $texttofind);
  return ($res[3], $res[4]); # pos , lenght
}
# On Windows, will draw the document into a display context such as a printer.
# FormatRange (start=0, end=GetLength(), draw=1)
sub FormatRange {
  my $self       = shift;
  my $start      = shift || 0;
  my $end        = shift || $self->GetLength();
  my $draw       = shift || 1;
  return undef if $start >= $end;

  my $formatrange = pack("LL", $start, $end);
  return $self->SendMessageNP (2151, $draw, $formatrange);
}
# Retrieve the display line at the top of the display.
sub GetFirstVisibleLine {
  my $self = shift;
  return $self->SendMessage (2152, 0, 0);
}
# Retrieve the contents of a line.
# Returns the length of the line.
# Getline (line)
sub GetLine {
  my ($self, $line)  = @_;
  my $lenght = $self->LineLength($line);
  my $text   = " " x ($lenght + 1);

  if ($self->SendMessageNP (2153, $line, $text)) {
    return $text;
  } else {
    return undef;
  }
}
# Returns the number of lines in the document. There is always at least one.
sub GetLineCount {
  my $self = shift;
  return $self->SendMessage (2154, 0, 0);
}
# Sets the size in pixels of the left margin.
sub SetMarginLeft {
  my ($self, $pixelWidth) = @_;
  return $self->SendMessage (2155, 0, $pixelWidth);
}
# Returns the size in pixels of the left margin.
sub GetMarginLeft {
  my $self = shift;
  return $self->SendMessage (2156, 0, 0);
}
# Sets the size in pixels of the right margin.
sub SetMarginRight {
  my ($self, $pixelWidth) = @_;
  return $self->SendMessage (2157, 0, $pixelWidth);
}
# Returns the size in pixels of the right margin.
sub GetMarginRight {
  my $self = shift;
  return $self->SendMessage (2158, 0, 0);
}
# Is the document different from when it was last saved?
sub GetModify {
  my $self = shift;
  return $self->SendMessage (2159, 0, 0);
}
# Select a range of text.
sub SetSel {
  my ($self, $start, $end) = @_;
  return $self->SendMessage (2160, $start, $end);
}
# Retrieve the selected text.
# Return the length of the text.
# GetSelText() : Return selected text
sub GetSelText {
  my $self  = shift;
  my $start = $self->GetSelectionStart();
  my $end   = $self->GetSelectionEnd();

  return undef if $start >= $end;
  my $text   = " " x ($end - $start + 1);

  $self->SendMessageNP (2161, 0, $text);
  return $text;
}
# Retrieve a range of text.
# Return the length of the text.
sub GetTextRange {
  my $self = shift;
  my $start = shift || 0;
  my $end = shift || $self->GetLength();

  return undef if $start >= $end;

  my $text = " " x ($end - $start + 1);
  my $textrange = pack("LLp", $start, $end, $text);
  $self->SendMessageNP (2162, 0, $textrange);
  return $text;
}
# Draw the selection in normal style or with selection highlighted.
sub HideSelection {
  my ($self, $normal) = @_;
  return $self->SendMessage (2163, $normal, 0);
}
# Retrieve the x value of the point in the window where a position is displayed.
sub PointXFromPosition {
  my ($self, $pos) = @_;
  return $self->SendMessage (2164, 0, $pos);
}
# Retrieve the y value of the point in the window where a position is displayed.
sub PointYFromPosition {
  my ($self, $pos) = @_;
  return $self->SendMessage (2165, 0, $pos);
}
# Retrieve the line containing a position.
sub LineFromPosition {
  my ($self, $pos) = @_;
  return $self->SendMessage (2166, $pos, 0);
}
# Retrieve the position at the start of a line.
sub PositionFromLine {
  my ($self, $line) = @_;
  return $self->SendMessage (2167, $line, 0);
}
# Scroll horizontally and vertically.
sub LineScroll {
  my ($self, $columns, $lines) = @_;
  return $self->SendMessage (2168, $columns, $lines);
}
# Ensure the caret is visible.
sub ScrollCaret {
  my $self = shift;
  return $self->SendMessage (2169, 0, 0);
}
# Replace the selected text with the argument text.
sub ReplaceSel {
  my ($self, $text) = @_;
  return $self->SendMessageNP (2170, 0, $text);
}
# Set to read only or read write.
sub SetReadOnly {
  my ($self, $readOnly) = @_;
  return $self->SendMessage (2171, $readOnly, 0);
}
# Null operation.
sub Null {
  my $self = shift;
  return $self->SendMessage (2172, 0, 0);
}
# Will a paste succeed?
sub CanPaste {
  my $self = shift;
  return $self->SendMessage (2173, 0, 0);
}
# Are there any undoable actions in the undo history?
sub CanUndo {
  my $self = shift;
  return $self->SendMessage (2174, 0, 0);
}
# Delete the undo history.
sub EmptyUndoBuffer {
  my $self = shift;
  return $self->SendMessage (2175, 0, 0);
}
# Undo one action in the undo history.
sub Undo {
  my $self = shift;
  return $self->SendMessage (2176, 0, 0);
}
# Cut the selection to the clipboard.
sub Cut {
  my $self = shift;
  return $self->SendMessage (2177, 0, 0);
}
# Copy the selection to the clipboard.
sub Copy {
  my $self = shift;
  return $self->SendMessage (2178, 0, 0);
}
# Paste the contents of the clipboard into the document replacing the selection.
sub Paste {
  my $self = shift;
  return $self->SendMessage (2179, 0, 0);
}
# Clear the selection.
sub Clear {
  my $self = shift;
  return $self->SendMessage (2180, 0, 0);
}
# Replace the contents of the document with the argument text.
sub SetText {
  my ($self, $text) = @_;
  return $self->SendMessageNP (2181, 0, $text);
}
# Retrieve all the text in the document.
# Returns number of characters retrieved.
# GetText() : Return all text
sub GetText {
  my $self   = shift;
  my $lenght = $self->GetTextLength() + 1;
  my $text   = " " x ($lenght+1);

  if ($self->SendMessageNP (2182, $lenght, $text)) {
    return $text;
  } else {
    return undef;
  }
}
# Retrieve the number of characters in the document.
sub GetTextLength {
  my $self = shift;
  return $self->SendMessage (2183, 0, 0);
}
# Retrieve a pointer to a function that processes messages for this Scintilla.
sub GetDirectFunction {
  my $self = shift;
  return $self->SendMessage (2184, 0, 0);
}
# Retrieve a pointer value to use as the first argument when calling
# the function returned by GetDirectFunction.
sub GetDirectPointer {
  my $self = shift;
  return $self->SendMessage (2185, 0, 0);
}
# Set to overtype (true) or insert mode.
sub SetOvertype {
  my ($self, $overtype) = @_;
  return $self->SendMessage (2186, $overtype, 0);
}
# Returns true if overtype mode is active otherwise false is returned.
sub GetOvertype {
  my $self = shift;
  return $self->SendMessage (2187, 0, 0);
}
# Set the width of the insert mode caret.
sub SetCaretWidth {
  my ($self, $pixelWidth) = @_;
  return $self->SendMessage (2188, $pixelWidth, 0);
}
# Returns the width of the insert mode caret.
sub GetCaretWidth {
  my $self = shift;
  return $self->SendMessage (2189, 0, 0);
}
# Sets the position that starts the target which is used for updating the
# document without affecting the scroll position.
sub SetTargetStart {
  my ($self, $pos) = @_;
  return $self->SendMessage (2190, $pos, 0);
}
# Get the position that starts the target.
sub GetTargetStart {
  my $self = shift;
  return $self->SendMessage (2191, 0, 0);
}
# Sets the position that ends the target which is used for updating the
# document without affecting the scroll position.
sub SetTargetEnd {
  my ($self, $pos) = @_;
  return $self->SendMessage (2192, $pos, 0);
}
# Get the position that ends the target.
sub GetTargetEnd {
  my $self = shift;
  return $self->SendMessage (2193, 0, 0);
}
# Replace the target text with the argument text.
# Text is counted so it can contain NULs.
# Returns the length of the replacement text.
# ReplaceTarget(text)
sub ReplaceTarget {
  my ($self, $text) = @_;
  my $length = length $text;
  return $self->SendMessageNP (2194, $length, $text);
}
# Replace the target text with the argument text after \d processing.
# Text is counted so it can contain NULs.
# Looks for \d where d is between 1 and 9 and replaces these with the strings
# matched in the last search operation which were surrounded by \( and \).
# Returns the length of the replacement text including any change
# caused by processing the \d patterns.
# ReplaceTargetRE(text)
sub ReplaceTargetRE {
  my ($self, $text) = @_;
  my $length = length $text;
  return $self->SendMessageNP (2195, $length, $text);
}
# Search for a counted string in the target and set the target to the found
# range. Text is counted so it can contain NULs.
# Returns length of range or -1 for failure in which case target is not moved.
# SearchInTarget(text)
sub SearchInTarget {
  my ($self, $text) = @_;
  my $length = length $text;
  return $self->SendMessageNP (2197, $length, $text);
}
# Set the search flags used by SearchInTarget.
sub SetSearchFlags {
  my ($self, $flags) = @_;
  return $self->SendMessage (2198, $flags, 0);
}
# Get the search flags used by SearchInTarget.
sub GetSearchFlags {
  my $self = shift;
  return $self->SendMessage (2199, 0, 0);
}
# Show a call tip containing a definition near position pos.
sub CallTipShow {
  my ($self, $pos, $definition) = @_;
  return $self->SendMessageNP (2200, $pos, $definition);
}
# Remove the call tip from the screen.
sub CallTipCancel {
  my $self = shift;
  return $self->SendMessage (2201, 0, 0);
}
# Is there an active call tip?
sub CallTipActive {
  my $self = shift;
  return $self->SendMessage (2202, 0, 0);
}
# Retrieve the position where the caret was before displaying the call tip.
sub CallTipPosStart {
  my $self = shift;
  return $self->SendMessage (2203, 0, 0);
}
# Highlight a segment of the definition.
sub CallTipSetHlt {
  my ($self, $start, $end) = @_;
  return $self->SendMessage (2204, $start, $end);
}
# Set the background colour for the call tip.
sub CallTipSetBack {
  my ($self, $back) = @_;
  $back =~ s/.(..)(..)(..)/$3$2$1/;
  return $self->SendMessage (2205, int hex $back, 0);
}
# Set the foreground colour for the call tip.
sub CallTipSetFore {
  my ($self, $fore) = @_;
  $fore =~ s/.(..)(..)(..)/$3$2$1/;
  return $self->SendMessage (2206, int hex $fore, 0);
}
# Set the foreground colour for the highlighted part of the call tip.
sub CallTipSetForeHlt {
  my ($self, $fore) = @_;
  $fore =~ s/.(..)(..)(..)/$3$2$1/;
  return $self->SendMessage (2207, int hex $fore, 0);
}
# Enable use of STYLE_CALLTIP and set call tip tab size in pixels.
sub CallTipUseStyle {
  my ($self, $tabSize) = @_;
  return $self->SendMessage (2212, $tabSize, 0);
}
# Find the display line of a document line taking hidden lines into account.
sub VisibleFromDocLine {
  my ($self, $line) = @_;
  return $self->SendMessage (2220, $line, 0);
}
# Find the document line of a display line taking hidden lines into account.
sub DocLineFromVisible {
  my ($self, $lineDisplay) = @_;
  return $self->SendMessage (2221, $lineDisplay, 0);
}
# The number of display lines needed to wrap a document line
sub WrapCount {
  my ($self, $line) = @_;
  return $self->SendMessage (2235, $line, 0);
}
use constant SC_FOLDLEVELBASE => 0x400 ;
use constant SC_FOLDLEVELWHITEFLAG => 0x1000 ;
use constant SC_FOLDLEVELHEADERFLAG => 0x2000 ;
use constant SC_FOLDLEVELBOXHEADERFLAG => 0x4000 ;
use constant SC_FOLDLEVELBOXFOOTERFLAG => 0x8000 ;
use constant SC_FOLDLEVELCONTRACTED => 0x10000 ;
use constant SC_FOLDLEVELUNINDENT => 0x20000 ;
use constant SC_FOLDLEVELNUMBERMASK => 0x0FFF ;
# Set the fold level of a line.
# This encodes an integer level along with flags indicating whether the
# line is a header and whether it is effectively white space.
sub SetFoldLevel {
  my ($self, $line, $level) = @_;
  return $self->SendMessage (2222, $line, $level);
}
# Retrieve the fold level of a line.
sub GetFoldLevel {
  my ($self, $line) = @_;
  return $self->SendMessage (2223, $line, 0);
}
# Find the last child line of a header line.
sub GetLastChild {
  my ($self, $line, $level) = @_;
  return $self->SendMessage (2224, $line, $level);
}
# Find the parent line of a child line.
sub GetFoldParent {
  my ($self, $line) = @_;
  return $self->SendMessage (2225, $line, 0);
}
# Make a range of lines visible.
sub ShowLines {
  my ($self, $lineStart, $lineEnd) = @_;
  return $self->SendMessage (2226, $lineStart, $lineEnd);
}
# Make a range of lines invisible.
sub HideLines {
  my ($self, $lineStart, $lineEnd) = @_;
  return $self->SendMessage (2227, $lineStart, $lineEnd);
}
# Is a line visible?
sub GetLineVisible {
  my ($self, $line) = @_;
  return $self->SendMessage (2228, $line, 0);
}
# Show the children of a header line.
sub SetFoldExpanded {
  my ($self, $line, $expanded) = @_;
  return $self->SendMessage (2229, $line, $expanded);
}
# Is a header line expanded?
sub GetFoldExpanded {
  my ($self, $line) = @_;
  return $self->SendMessage (2230, $line, 0);
}
# Switch a header line between expanded and contracted.
sub ToggleFold {
  my ($self, $line) = @_;
  return $self->SendMessage (2231, $line, 0);
}
# Ensure a particular line is visible by expanding any header line hiding it.
sub EnsureVisible {
  my ($self, $line) = @_;
  return $self->SendMessage (2232, $line, 0);
}
use constant SC_FOLDFLAG_LINEBEFORE_EXPANDED => 0x0002 ;
use constant SC_FOLDFLAG_LINEBEFORE_CONTRACTED => 0x0004 ;
use constant SC_FOLDFLAG_LINEAFTER_EXPANDED => 0x0008 ;
use constant SC_FOLDFLAG_LINEAFTER_CONTRACTED => 0x0010 ;
use constant SC_FOLDFLAG_LEVELNUMBERS => 0x0040 ;
use constant SC_FOLDFLAG_BOX => 0x0001 ;
# Set some style options for folding.
sub SetFoldFlags {
  my ($self, $flags) = @_;
  return $self->SendMessage (2233, $flags, 0);
}
# Ensure a particular line is visible by expanding any header line hiding it.
# Use the currently set visibility policy to determine which range to display.
sub EnsureVisibleEnforcePolicy {
  my ($self, $line) = @_;
  return $self->SendMessage (2234, $line, 0);
}
# Sets whether a tab pressed when caret is within indentation indents.
sub SetTabIndents {
  my ($self, $tabIndents) = @_;
  return $self->SendMessage (2260, $tabIndents, 0);
}
# Does a tab pressed when caret is within indentation indent?
sub GetTabIndents {
  my $self = shift;
  return $self->SendMessage (2261, 0, 0);
}
# Sets whether a backspace pressed when caret is within indentation unindents.
sub SetBackSpaceUnIndents {
  my ($self, $bsUnIndents) = @_;
  return $self->SendMessage (2262, $bsUnIndents, 0);
}
# Does a backspace pressed when caret is within indentation unindent?
sub GetBackSpaceUnIndents {
  my $self = shift;
  return $self->SendMessage (2263, 0, 0);
}
use constant SC_TIME_FOREVER => 10000000 ;
# Sets the time the mouse must sit still to generate a mouse dwell event.
sub SetMouseDwellTime {
  my ($self, $periodMilliseconds) = @_;
  return $self->SendMessage (2264, $periodMilliseconds, 0);
}
# Retrieve the time the mouse must sit still to generate a mouse dwell event.
sub GetMouseDwellTime {
  my $self = shift;
  return $self->SendMessage (2265, 0, 0);
}
# Get position of start of word.
sub WordStartPosition {
  my ($self, $pos, $onlyWordCharacters) = @_;
  return $self->SendMessage (2266, $pos, $onlyWordCharacters);
}
# Get position of end of word.
sub WordEndPosition {
  my ($self, $pos, $onlyWordCharacters) = @_;
  return $self->SendMessage (2267, $pos, $onlyWordCharacters);
}
use constant SC_WRAP_NONE => 0 ;
use constant SC_WRAP_WORD => 1 ;
use constant SC_WRAP_CHAR => 2 ;
# Sets whether text is word wrapped.
sub SetWrapMode {
  my ($self, $mode) = @_;
  return $self->SendMessage (2268, $mode, 0);
}
# Retrieve whether text is word wrapped.
sub GetWrapMode {
  my $self = shift;
  return $self->SendMessage (2269, 0, 0);
}
use constant SC_WRAPVISUALFLAG_NONE => 0x0000 ;
use constant SC_WRAPVISUALFLAG_END => 0x0001 ;
use constant SC_WRAPVISUALFLAG_START => 0x0002 ;
# Set the display mode of visual flags for wrapped lines.
sub SetWrapVisualFlags {
  my ($self, $wrapVisualFlags) = @_;
  return $self->SendMessage (2460, $wrapVisualFlags, 0);
}
# Retrive the display mode of visual flags for wrapped lines.
sub GetWrapVisualFlags {
  my $self = shift;
  return $self->SendMessage (2461, 0, 0);
}
use constant SC_WRAPVISUALFLAGLOC_DEFAULT => 0x0000 ;
use constant SC_WRAPVISUALFLAGLOC_END_BY_TEXT => 0x0001 ;
use constant SC_WRAPVISUALFLAGLOC_START_BY_TEXT => 0x0002 ;
# Set the location of visual flags for wrapped lines.
sub SetWrapVisualFlagsLocation {
  my ($self, $wrapVisualFlagsLocation) = @_;
  return $self->SendMessage (2462, $wrapVisualFlagsLocation, 0);
}
# Retrive the location of visual flags for wrapped lines.
sub GetWrapVisualFlagsLocation {
  my $self = shift;
  return $self->SendMessage (2463, 0, 0);
}
# Set the start indent for wrapped lines.
sub SetWrapStartIndent {
  my ($self, $indent) = @_;
  return $self->SendMessage (2464, $indent, 0);
}
# Retrive the start indent for wrapped lines.
sub GetWrapStartIndent {
  my $self = shift;
  return $self->SendMessage (2465, 0, 0);
}
use constant SC_CACHE_NONE => 0 ;
use constant SC_CACHE_CARET => 1 ;
use constant SC_CACHE_PAGE => 2 ;
use constant SC_CACHE_DOCUMENT => 3 ;
# Sets the degree of caching of layout information.
sub SetLayoutCache {
  my ($self, $mode) = @_;
  return $self->SendMessage (2272, $mode, 0);
}
# Retrieve the degree of caching of layout information.
sub GetLayoutCache {
  my $self = shift;
  return $self->SendMessage (2273, 0, 0);
}
# Sets the document width assumed for scrolling.
sub SetScrollWidth {
  my ($self, $pixelWidth) = @_;
  return $self->SendMessage (2274, $pixelWidth, 0);
}
# Retrieve the document width assumed for scrolling.
sub GetScrollWidth {
  my $self = shift;
  return $self->SendMessage (2275, 0, 0);
}
# Measure the pixel width of some text in a particular style.
# NUL terminated text argument.
# Does not handle tab or control characters.
sub TextWidth {
  my ($self, $style, $text) = @_;
  return $self->SendMessageNP (2276, $style, $text);
}
# Sets the scroll range so that maximum scroll position has
# the last line at the bottom of the view (default).
# Setting this to false allows scrolling one page below the last line.
sub SetEndAtLastLine {
  my ($self, $endAtLastLine) = @_;
  return $self->SendMessage (2277, $endAtLastLine, 0);
}
# Retrieve whether the maximum scroll position has the last
# line at the bottom of the view.
sub GetEndAtLastLine {
  my $self = shift;
  return $self->SendMessage (2278, 0, 0);
}
# Retrieve the height of a particular line of text in pixels.
sub TextHeight {
  my ($self, $line) = @_;
  return $self->SendMessage (2279, $line, 0);
}
# Show or hide the vertical scroll bar.
sub SetVScrollBar {
  my ($self, $show) = @_;
  return $self->SendMessage (2280, $show, 0);
}
# Is the vertical scroll bar visible?
sub GetVScrollBar {
  my $self = shift;
  return $self->SendMessage (2281, 0, 0);
}
# Append a string to the end of the document without changing the selection.
# AppendText(text)
sub AppendText {
  my ($self, $text) = @_;
  my $length = length $text;
  return $self->SendMessageNP (2282, $length, $text);
}
# Is drawing done in two phases with backgrounds drawn before faoregrounds?
sub GetTwoPhaseDraw {
  my $self = shift;
  return $self->SendMessage (2283, 0, 0);
}
# In twoPhaseDraw mode, drawing is performed in two phases, first the background
# and then the foreground. This avoids chopping off characters that overlap the next run.
sub SetTwoPhaseDraw {
  my ($self, $twoPhase) = @_;
  return $self->SendMessage (2284, $twoPhase, 0);
}
# Make the target range start and end be the same as the selection range start and end.
sub TargetFromSelection {
  my $self = shift;
  return $self->SendMessage (2287, 0, 0);
}
# Join the lines in the target.
sub LinesJoin {
  my $self = shift;
  return $self->SendMessage (2288, 0, 0);
}
# Split the lines in the target into lines that are less wide than pixelWidth
# where possible.
sub LinesSplit {
  my ($self, $pixelWidth) = @_;
  return $self->SendMessage (2289, $pixelWidth, 0);
}
# Set the colours used as a chequerboard pattern in the fold margin
sub SetFoldMarginColour {
  my ($self, $useSetting, $back) = @_;
  $back =~ s/.(..)(..)(..)/$3$2$1/;
  return $self->SendMessage (2290, $useSetting, int hex $back);
}
sub SetFoldMarginHiColour {
  my ($self, $useSetting, $fore) = @_;
  $fore =~ s/.(..)(..)(..)/$3$2$1/;
  return $self->SendMessage (2291, $useSetting, int hex $fore);
}
# Move caret down one line.
sub LineDown {
  my $self = shift;
  return $self->SendMessage (2300, 0, 0);
}
# Move caret down one line extending selection to new caret position.
sub LineDownExtend {
  my $self = shift;
  return $self->SendMessage (2301, 0, 0);
}
# Move caret up one line.
sub LineUp {
  my $self = shift;
  return $self->SendMessage (2302, 0, 0);
}
# Move caret up one line extending selection to new caret position.
sub LineUpExtend {
  my $self = shift;
  return $self->SendMessage (2303, 0, 0);
}
# Move caret left one character.
sub CharLeft {
  my $self = shift;
  return $self->SendMessage (2304, 0, 0);
}
# Move caret left one character extending selection to new caret position.
sub CharLeftExtend {
  my $self = shift;
  return $self->SendMessage (2305, 0, 0);
}
# Move caret right one character.
sub CharRight {
  my $self = shift;
  return $self->SendMessage (2306, 0, 0);
}
# Move caret right one character extending selection to new caret position.
sub CharRightExtend {
  my $self = shift;
  return $self->SendMessage (2307, 0, 0);
}
# Move caret left one word.
sub WordLeft {
  my $self = shift;
  return $self->SendMessage (2308, 0, 0);
}
# Move caret left one word extending selection to new caret position.
sub WordLeftExtend {
  my $self = shift;
  return $self->SendMessage (2309, 0, 0);
}
# Move caret right one word.
sub WordRight {
  my $self = shift;
  return $self->SendMessage (2310, 0, 0);
}
# Move caret right one word extending selection to new caret position.
sub WordRightExtend {
  my $self = shift;
  return $self->SendMessage (2311, 0, 0);
}
# Move caret to first position on line.
sub Home {
  my $self = shift;
  return $self->SendMessage (2312, 0, 0);
}
# Move caret to first position on line extending selection to new caret position.
sub HomeExtend {
  my $self = shift;
  return $self->SendMessage (2313, 0, 0);
}
# Move caret to last position on line.
sub LineEnd {
  my $self = shift;
  return $self->SendMessage (2314, 0, 0);
}
# Move caret to last position on line extending selection to new caret position.
sub LineEndExtend {
  my $self = shift;
  return $self->SendMessage (2315, 0, 0);
}
# Move caret to first position in document.
sub DocumentStart {
  my $self = shift;
  return $self->SendMessage (2316, 0, 0);
}
# Move caret to first position in document extending selection to new caret position.
sub DocumentStartExtend {
  my $self = shift;
  return $self->SendMessage (2317, 0, 0);
}
# Move caret to last position in document.
sub DocumentEnd {
  my $self = shift;
  return $self->SendMessage (2318, 0, 0);
}
# Move caret to last position in document extending selection to new caret position.
sub DocumentEndExtend {
  my $self = shift;
  return $self->SendMessage (2319, 0, 0);
}
# Move caret one page up.
sub PageUp {
  my $self = shift;
  return $self->SendMessage (2320, 0, 0);
}
# Move caret one page up extending selection to new caret position.
sub PageUpExtend {
  my $self = shift;
  return $self->SendMessage (2321, 0, 0);
}
# Move caret one page down.
sub PageDown {
  my $self = shift;
  return $self->SendMessage (2322, 0, 0);
}
# Move caret one page down extending selection to new caret position.
sub PageDownExtend {
  my $self = shift;
  return $self->SendMessage (2323, 0, 0);
}
# Switch from insert to overtype mode or the reverse.
sub EditToggleOvertype {
  my $self = shift;
  return $self->SendMessage (2324, 0, 0);
}
# Cancel any modes such as call tip or auto-completion list display.
sub Cancel {
  my $self = shift;
  return $self->SendMessage (2325, 0, 0);
}
# Delete the selection or if no selection, the character before the caret.
sub DeleteBack {
  my $self = shift;
  return $self->SendMessage (2326, 0, 0);
}
# If selection is empty or all on one line replace the selection with a tab character.
# If more than one line selected, indent the lines.
sub Tab {
  my $self = shift;
  return $self->SendMessage (2327, 0, 0);
}
# Dedent the selected lines.
sub BackTab {
  my $self = shift;
  return $self->SendMessage (2328, 0, 0);
}
# Insert a new line, may use a CRLF, CR or LF depending on EOL mode.
sub NewLine {
  my $self = shift;
  return $self->SendMessage (2329, 0, 0);
}
# Insert a Form Feed character.
sub FormFeed {
  my $self = shift;
  return $self->SendMessage (2330, 0, 0);
}
# Move caret to before first visible character on line.
# If already there move to first character on line.
sub VCHome {
  my $self = shift;
  return $self->SendMessage (2331, 0, 0);
}
# Like VCHome but extending selection to new caret position.
sub VCHomeExtend {
  my $self = shift;
  return $self->SendMessage (2332, 0, 0);
}
# Magnify the displayed text by increasing the sizes by 1 point.
sub ZoomIn {
  my $self = shift;
  return $self->SendMessage (2333, 0, 0);
}
# Make the displayed text smaller by decreasing the sizes by 1 point.
sub ZoomOut {
  my $self = shift;
  return $self->SendMessage (2334, 0, 0);
}
# Delete the word to the left of the caret.
sub DelWordLeft {
  my $self = shift;
  return $self->SendMessage (2335, 0, 0);
}
# Delete the word to the right of the caret.
sub DelWordRight {
  my $self = shift;
  return $self->SendMessage (2336, 0, 0);
}
# Cut the line containing the caret.
sub LineCut {
  my $self = shift;
  return $self->SendMessage (2337, 0, 0);
}
# Delete the line containing the caret.
sub LineDelete {
  my $self = shift;
  return $self->SendMessage (2338, 0, 0);
}
# Switch the current line with the previous.
sub LineTranspose {
  my $self = shift;
  return $self->SendMessage (2339, 0, 0);
}
# Duplicate the current line.
sub LineDuplicate {
  my $self = shift;
  return $self->SendMessage (2404, 0, 0);
}
# Transform the selection to lower case.
sub LowerCase {
  my $self = shift;
  return $self->SendMessage (2340, 0, 0);
}
# Transform the selection to upper case.
sub UpperCase {
  my $self = shift;
  return $self->SendMessage (2341, 0, 0);
}
# Scroll the document down, keeping the caret visible.
sub LineScrollDown {
  my $self = shift;
  return $self->SendMessage (2342, 0, 0);
}
# Scroll the document up, keeping the caret visible.
sub LineScrollUp {
  my $self = shift;
  return $self->SendMessage (2343, 0, 0);
}
# Delete the selection or if no selection, the character before the caret.
# Will not delete the character before at the start of a line.
sub DeleteBackNotLine {
  my $self = shift;
  return $self->SendMessage (2344, 0, 0);
}
# Move caret to first position on display line.
sub HomeDisplay {
  my $self = shift;
  return $self->SendMessage (2345, 0, 0);
}
# Move caret to first position on display line extending selection to
# new caret position.
sub HomeDisplayExtend {
  my $self = shift;
  return $self->SendMessage (2346, 0, 0);
}
# Move caret to last position on display line.
sub LineEndDisplay {
  my $self = shift;
  return $self->SendMessage (2347, 0, 0);
}
# Move caret to last position on display line extending selection to new
# caret position.
sub LineEndDisplayExtend {
  my $self = shift;
  return $self->SendMessage (2348, 0, 0);
}
# These are like their namesakes Home(Extend)?, LineEnd(Extend)?, VCHome(Extend)?
# except they behave differently when word-wrap is enabled:
# They go first to the start / end of the display line, like (Home|LineEnd)Display
# The difference is that, the cursor is already at the point, it goes on to the start
# or end of the document line, as appropriate for (Home|LineEnd|VCHome)(Extend)?.
sub HomeWrap {
  my $self = shift;
  return $self->SendMessage (2349, 0, 0);
}
sub HomeWrapExtend {
  my $self = shift;
  return $self->SendMessage (2450, 0, 0);
}
sub LineEndWrap {
  my $self = shift;
  return $self->SendMessage (2451, 0, 0);
}
sub LineEndWrapExtend {
  my $self = shift;
  return $self->SendMessage (2452, 0, 0);
}
sub VCHomeWrap {
  my $self = shift;
  return $self->SendMessage (2453, 0, 0);
}
sub VCHomeWrapExtend {
  my $self = shift;
  return $self->SendMessage (2454, 0, 0);
}
# Copy the line containing the caret.
sub LineCopy {
  my $self = shift;
  return $self->SendMessage (2455, 0, 0);
}
# Move the caret inside current view if it's not there already.
sub MoveCaretInsideView {
  my $self = shift;
  return $self->SendMessage (2401, 0, 0);
}
# How many characters are on a line, not including end of line characters?
sub LineLength {
  my ($self, $line) = @_;
  return $self->SendMessage (2350, $line, 0);
}
# Highlight the characters at two positions.
sub BraceHighlight {
  my ($self, $pos1, $pos2) = @_;
  return $self->SendMessage (2351, $pos1, $pos2);
}
# Highlight the character at a position indicating there is no matching brace.
sub BraceBadLight {
  my ($self, $pos) = @_;
  return $self->SendMessage (2352, $pos, 0);
}
# Find the position of a matching brace or INVALID_POSITION if no match.
sub BraceMatch {
  my ($self, $pos) = @_;
  return $self->SendMessage (2353, $pos, 0);
}
# Are the end of line characters visible?
sub GetViewEOL {
  my $self = shift;
  return $self->SendMessage (2355, 0, 0);
}
# Make the end of line characters visible or invisible.
sub SetViewEOL {
  my ($self, $visible) = @_;
  return $self->SendMessage (2356, $visible, 0);
}
# Retrieve a pointer to the document object.
sub GetDocPointer {
  my $self = shift;
  return $self->SendMessage (2357, 0, 0);
}
# Change the document object used.
sub SetDocPointer {
  my ($self, $pointer) = @_;
  return $self->SendMessage (2358, 0, $pointer);
}
# Set which document modification events are sent to the container.
sub SetModEventMask {
  my ($self, $mask) = @_;
  return $self->SendMessage (2359, $mask, 0);
}
use constant EDGE_NONE => 0 ;
use constant EDGE_LINE => 1 ;
use constant EDGE_BACKGROUND => 2 ;
# Retrieve the column number which text should be kept within.
sub GetEdgeColumn {
  my $self = shift;
  return $self->SendMessage (2360, 0, 0);
}
# Set the column number of the edge.
# If text goes past the edge then it is highlighted.
sub SetEdgeColumn {
  my ($self, $column) = @_;
  return $self->SendMessage (2361, $column, 0);
}
# Retrieve the edge highlight mode.
sub GetEdgeMode {
  my $self = shift;
  return $self->SendMessage (2362, 0, 0);
}
# The edge may be displayed by a line (EDGE_LINE) or by highlighting text that
# goes beyond it (EDGE_BACKGROUND) or not displayed at all (EDGE_NONE).
sub SetEdgeMode {
  my ($self, $mode) = @_;
  return $self->SendMessage (2363, $mode, 0);
}
# Retrieve the colour used in edge indication.
sub GetEdgeColour {
  my $self = shift;
  my $colour = $self->SendMessage (2364, 0, 0);
  $colour = sprintf ('#%x', $colour);
  $colour =~ s/(.)(..)(..)(..)/$1$4$3$2/;
  return $colour;
}
# Change the colour used in edge indication.
sub SetEdgeColour {
  my ($self, $edgeColour) = @_;
  $edgeColour =~ s/.(..)(..)(..)/$3$2$1/;
  return $self->SendMessage (2365, int hex $edgeColour, 0);
}
# Sets the current caret position to be the search anchor.
sub SearchAnchor {
  my $self = shift;
  return $self->SendMessage (2366, 0, 0);
}
# Find some text starting at the search anchor.
# Does not ensure the selection is visible.
sub SearchNext {
  my ($self, $flags, $text) = @_;
  return $self->SendMessageNP (2367, $flags, $text);
}
# Find some text starting at the search anchor and moving backwards.
# Does not ensure the selection is visible.
sub SearchPrev {
  my ($self, $flags, $text) = @_;
  return $self->SendMessageNP (2368, $flags, $text);
}
# Retrieves the number of lines completely visible.
sub LinesOnScreen {
  my $self = shift;
  return $self->SendMessage (2370, 0, 0);
}
# Set whether a pop up menu is displayed automatically when the user presses
# the wrong mouse button.
sub UsePopUp {
  my ($self, $allowPopUp) = @_;
  return $self->SendMessage (2371, $allowPopUp, 0);
}
# Is the selection rectangular? The alternative is the more common stream selection.
sub SelectionIsRectangle {
  my $self = shift;
  return $self->SendMessage (2372, 0, 0);
}
# Set the zoom level. This number of points is added to the size of all fonts.
# It may be positive to magnify or negative to reduce.
sub SetZoom {
  my ($self, $zoom) = @_;
  return $self->SendMessage (2373, $zoom, 0);
}
# Retrieve the zoom level.
sub GetZoom {
  my $self = shift;
  return $self->SendMessage (2374, 0, 0);
}
# Create a new document object.
# Starts with reference count of 1 and not selected into editor.
sub CreateDocument {
  my $self = shift;
  return $self->SendMessage (2375, 0, 0);
}
# Extend life of document.
sub AddRefDocument {
  my ($self, $doc) = @_;
  return $self->SendMessage (2376, 0, $doc);
}
# Release a reference to the document, deleting document if it fades to black.
sub ReleaseDocument {
  my ($self, $doc) = @_;
  return $self->SendMessage (2377, 0, $doc);
}
# Get which document modification events are sent to the container.
sub GetModEventMask {
  my $self = shift;
  return $self->SendMessage (2378, 0, 0);
}
# Change internal focus flag.
sub SetFocus {
  my ($self, $focus) = @_;
  return $self->SendMessage (2380, $focus, 0);
}
# Get internal focus flag.
sub GetFocus {
  my $self = shift;
  return $self->SendMessage (2381, 0, 0);
}
# Change error status - 0 = OK.
sub SetStatus {
  my ($self, $statusCode) = @_;
  return $self->SendMessage (2382, $statusCode, 0);
}
# Get error status.
sub GetStatus {
  my $self = shift;
  return $self->SendMessage (2383, 0, 0);
}
# Set whether the mouse is captured when its button is pressed.
sub SetMouseDownCaptures {
  my ($self, $captures) = @_;
  return $self->SendMessage (2384, $captures, 0);
}
# Get whether mouse gets captured.
sub GetMouseDownCaptures {
  my $self = shift;
  return $self->SendMessage (2385, 0, 0);
}
use constant SC_CURSORNORMAL => -1 ;
use constant SC_CURSORWAIT => 4 ;
# Sets the cursor to one of the SC_CURSOR* values.
sub SetCursor {
  my ($self, $cursorType) = @_;
  return $self->SendMessage (2386, $cursorType, 0);
}
# Get cursor type.
sub GetCursor {
  my $self = shift;
  return $self->SendMessage (2387, 0, 0);
}
# Change the way control characters are displayed:
# If symbol is < 32, keep the drawn way, else, use the given character.
sub SetControlCharSymbol {
  my ($self, $symbol) = @_;
  return $self->SendMessage (2388, $symbol, 0);
}
# Get the way control characters are displayed.
sub GetControlCharSymbol {
  my $self = shift;
  return $self->SendMessage (2389, 0, 0);
}
# Move to the previous change in capitalisation.
sub WordPartLeft {
  my $self = shift;
  return $self->SendMessage (2390, 0, 0);
}
# Move to the previous change in capitalisation extending selection
# to new caret position.
sub WordPartLeftExtend {
  my $self = shift;
  return $self->SendMessage (2391, 0, 0);
}
# Move to the change next in capitalisation.
sub WordPartRight {
  my $self = shift;
  return $self->SendMessage (2392, 0, 0);
}
# Move to the next change in capitalisation extending selection
# to new caret position.
sub WordPartRightExtend {
  my $self = shift;
  return $self->SendMessage (2393, 0, 0);
}
# Constants for use with SetVisiblePolicy, similar to SetCaretPolicy.
use constant VISIBLE_SLOP => 0x01 ;
use constant VISIBLE_STRICT => 0x04 ;
# Set the way the display area is determined when a particular line
# is to be moved to by Find, FindNext, GotoLine, etc.
sub SetVisiblePolicy {
  my ($self, $visiblePolicy, $visibleSlop) = @_;
  return $self->SendMessage (2394, $visiblePolicy, $visibleSlop);
}
# Delete back from the current position to the start of the line.
sub DelLineLeft {
  my $self = shift;
  return $self->SendMessage (2395, 0, 0);
}
# Delete forwards from the current position to the end of the line.
sub DelLineRight {
  my $self = shift;
  return $self->SendMessage (2396, 0, 0);
}
# Get and Set the xOffset (ie, horizonal scroll position).
sub SetXOffset {
  my ($self, $newOffset) = @_;
  return $self->SendMessage (2397, $newOffset, 0);
}
sub GetXOffset {
  my $self = shift;
  return $self->SendMessage (2398, 0, 0);
}
# Set the last x chosen value to be the caret x position.
sub ChooseCaretX {
  my $self = shift;
  return $self->SendMessage (2399, 0, 0);
}
# Set the focus to this Scintilla widget.
sub GrabFocus {
  my $self = shift;
  return $self->SendMessage (2400, 0, 0);
}
# Caret policy, used by SetXCaretPolicy and SetYCaretPolicy.
# If CARET_SLOP is set, we can define a slop value: caretSlop.
# This value defines an unwanted zone (UZ) where the caret is... unwanted.
# This zone is defined as a number of pixels near the vertical margins,
# and as a number of lines near the horizontal margins.
# By keeping the caret away from the edges, it is seen within its context,
# so it is likely that the identifier that the caret is on can be completely seen,
# and that the current line is seen with some of the lines following it which are
# often dependent on that line.
use constant CARET_SLOP => 0x01 ;
# If CARET_STRICT is set, the policy is enforced... strictly.
# The caret is centred on the display if slop is not set,
# and cannot go in the UZ if slop is set.
use constant CARET_STRICT => 0x04 ;
# If CARET_JUMPS is set, the display is moved more energetically
# so the caret can move in the same direction longer before the policy is applied again.
use constant CARET_JUMPS => 0x10 ;
# If CARET_EVEN is not set, instead of having symmetrical UZs,
# the left and bottom UZs are extended up to right and top UZs respectively.
# This way, we favour the displaying of useful information: the begining of lines,
# where most code reside, and the lines after the caret, eg. the body of a function.
use constant CARET_EVEN => 0x08 ;
# Set the way the caret is kept visible when going sideway.
# The exclusion zone is given in pixels.
sub SetXCaretPolicy {
  my ($self, $caretPolicy, $caretSlop) = @_;
  return $self->SendMessage (2402, $caretPolicy, $caretSlop);
}
# Set the way the line the caret is on is kept visible.
# The exclusion zone is given in lines.
sub SetYCaretPolicy {
  my ($self, $caretPolicy, $caretSlop) = @_;
  return $self->SendMessage (2403, $caretPolicy, $caretSlop);
}
# Set printing to line wrapped (SC_WRAP_WORD) or not line wrapped (SC_WRAP_NONE).
sub SetPrintWrapMode {
  my ($self, $mode) = @_;
  return $self->SendMessage (2406, $mode, 0);
}
# Is printing line wrapped?
sub GetPrintWrapMode {
  my $self = shift;
  return $self->SendMessage (2407, 0, 0);
}
# Set a fore colour for active hotspots.
sub SetHotspotActiveFore {
  my ($self, $useSetting, $fore) = @_;
  $fore =~ s/.(..)(..)(..)/$3$2$1/;
  return $self->SendMessage (2410, $useSetting, int hex $fore);
}
# Set a back colour for active hotspots.
sub SetHotspotActiveBack {
  my ($self, $useSetting, $back) = @_;
  $back =~ s/.(..)(..)(..)/$3$2$1/;
  return $self->SendMessage (2411, $useSetting, int hex $back);
}
# Enable / Disable underlining active hotspots.
sub SetHotspotActiveUnderline {
  my ($self, $underline) = @_;
  return $self->SendMessage (2412, $underline, 0);
}
# Limit hotspots to single line so hotspots on two lines don't merge.
sub SetHotspotSingleLine {
  my ($self, $singleLine) = @_;
  return $self->SendMessage (2421, $singleLine, 0);
}
# Move caret between paragraphs (delimited by empty lines).
sub ParaDown {
  my $self = shift;
  return $self->SendMessage (2413, 0, 0);
}
sub ParaDownExtend {
  my $self = shift;
  return $self->SendMessage (2414, 0, 0);
}
sub ParaUp {
  my $self = shift;
  return $self->SendMessage (2415, 0, 0);
}
sub ParaUpExtend {
  my $self = shift;
  return $self->SendMessage (2416, 0, 0);
}
# Given a valid document position, return the previous position taking code
# page into account. Returns 0 if passed 0.
sub PositionBefore {
  my ($self, $pos) = @_;
  return $self->SendMessage (2417, $pos, 0);
}
# Given a valid document position, return the next position taking code
# page into account. Maximum value returned is the last position in the document.
sub PositionAfter {
  my ($self, $pos) = @_;
  return $self->SendMessage (2418, $pos, 0);
}
# Copy a range of text to the clipboard. Positions are clipped into the document.
sub CopyRange {
  my ($self, $start, $end) = @_;
  return $self->SendMessage (2419, $start, $end);
}
# Copy argument text to the clipboard.
# CopyText(text)
sub CopyText {
  my ($self, $text) = @_;
  my $length = length $text;
  return $self->SendMessageNP (2420, $length, $text);
}
use constant SC_SEL_STREAM => 0 ;
use constant SC_SEL_RECTANGLE => 1 ;
use constant SC_SEL_LINES => 2 ;
# Set the selection mode to stream (SC_SEL_STREAM) or rectangular (SC_SEL_RECTANGLE) or
# by lines (SC_SEL_LINES).
sub SetSelectionMode {
  my ($self, $mode) = @_;
  return $self->SendMessage (2422, $mode, 0);
}
# Get the mode of the current selection.
sub GetSelectionMode {
  my $self = shift;
  return $self->SendMessage (2423, 0, 0);
}
# Retrieve the position of the start of the selection at the given line (INVALID_POSITION if no selection on this line).
sub GetLineSelStartPosition {
  my ($self, $line) = @_;
  return $self->SendMessage (2424, $line, 0);
}
# Retrieve the position of the end of the selection at the given line (INVALID_POSITION if no selection on this line).
sub GetLineSelEndPosition {
  my ($self, $line) = @_;
  return $self->SendMessage (2425, $line, 0);
}
# Move caret down one line, extending rectangular selection to new caret position.
sub LineDownRectExtend {
  my $self = shift;
  return $self->SendMessage (2426, 0, 0);
}
# Move caret up one line, extending rectangular selection to new caret position.
sub LineUpRectExtend {
  my $self = shift;
  return $self->SendMessage (2427, 0, 0);
}
# Move caret left one character, extending rectangular selection to new caret position.
sub CharLeftRectExtend {
  my $self = shift;
  return $self->SendMessage (2428, 0, 0);
}
# Move caret right one character, extending rectangular selection to new caret position.
sub CharRightRectExtend {
  my $self = shift;
  return $self->SendMessage (2429, 0, 0);
}
# Move caret to first position on line, extending rectangular selection to new caret position.
sub HomeRectExtend {
  my $self = shift;
  return $self->SendMessage (2430, 0, 0);
}
# Move caret to before first visible character on line.
# If already there move to first character on line.
# In either case, extend rectangular selection to new caret position.
sub VCHomeRectExtend {
  my $self = shift;
  return $self->SendMessage (2431, 0, 0);
}
# Move caret to last position on line, extending rectangular selection to new caret position.
sub LineEndRectExtend {
  my $self = shift;
  return $self->SendMessage (2432, 0, 0);
}
# Move caret one page up, extending rectangular selection to new caret position.
sub PageUpRectExtend {
  my $self = shift;
  return $self->SendMessage (2433, 0, 0);
}
# Move caret one page down, extending rectangular selection to new caret position.
sub PageDownRectExtend {
  my $self = shift;
  return $self->SendMessage (2434, 0, 0);
}
# Move caret to top of page, or one page up if already at top of page.
sub StutteredPageUp {
  my $self = shift;
  return $self->SendMessage (2435, 0, 0);
}
# Move caret to top of page, or one page up if already at top of page, extending selection to new caret position.
sub StutteredPageUpExtend {
  my $self = shift;
  return $self->SendMessage (2436, 0, 0);
}
# Move caret to bottom of page, or one page down if already at bottom of page.
sub StutteredPageDown {
  my $self = shift;
  return $self->SendMessage (2437, 0, 0);
}
# Move caret to bottom of page, or one page down if already at bottom of page, extending selection to new caret position.
sub StutteredPageDownExtend {
  my $self = shift;
  return $self->SendMessage (2438, 0, 0);
}
# Move caret left one word, position cursor at end of word.
sub WordLeftEnd {
  my $self = shift;
  return $self->SendMessage (2439, 0, 0);
}
# Move caret left one word, position cursor at end of word, extending selection to new caret position.
sub WordLeftEndExtend {
  my $self = shift;
  return $self->SendMessage (2440, 0, 0);
}
# Move caret right one word, position cursor at end of word.
sub WordRightEnd {
  my $self = shift;
  return $self->SendMessage (2441, 0, 0);
}
# Move caret right one word, position cursor at end of word, extending selection to new caret position.
sub WordRightEndExtend {
  my $self = shift;
  return $self->SendMessage (2442, 0, 0);
}
# Set the set of characters making up whitespace for when moving or selecting by word.
# Should be called after SetWordChars.
sub SetWhitespaceChars {
  my ($self, $characters) = @_;
  return $self->SendMessageNP (2443, 0, $characters);
}
# Reset the set of characters for whitespace and word characters to the defaults.
sub SetCharsDefault {
  my $self = shift;
  return $self->SendMessage (2444, 0, 0);
}
# Get currently selected item position in the auto-completion list
sub AutoCGetCurrent {
  my $self = shift;
  return $self->SendMessage (2445, 0, 0);
}
# Enlarge the document to a particular size of text bytes.
sub Allocate {
  my ($self, $bytes) = @_;
  return $self->SendMessage (2446, $bytes, 0);
}
# Returns the target converted to UTF8.
# Return the length in bytes.
# TargetAsUTF8() :
# Returns the target converted to UTF8.
sub TargetAsUTF8 {
  my $self  = shift;
  my $len   = $self->SendMessage(2447,0,0);
  my $text   = " " x $len;

  $self->SendMessageNP (2447, 0, $text);
  return $text;
}
# Set the length of the utf8 argument for calling EncodedFromUTF8.
# Set to -1 and the string will be measured to the first nul.
sub SetLengthForEncode {
  my ($self, $bytes) = @_;
  return $self->SendMessage (2448, $bytes, 0);
}
# Translates a UTF8 string into the document encoding.
# Return the length of the result in bytes.
# On error return 0.
# EncodedFromUTF8() :
# Translates a UTF8 string into the document encoding.
# Return the length of the result in bytes.
# On error return 0.
sub EncodedFromUTF8 {
  my ($self, $src)  = @_;
  my $len   = $self->SendMessagePN(2449,$src,0);
  my $text   = " " x $len;

  if($self->SendMessagePP (2449, $src, $text)) {
    return $text;
  }
  else {
    return undef;
  }
}
# Find the position of a column on a line taking into account tabs and
# multi-byte characters. If beyond end of line, return line end position.
sub FindColumn {
  my ($self, $line, $column) = @_;
  return $self->SendMessage (2456, $line, $column);
}
# Can the caret preferred x position only be changed by explicit movement commands?
sub GetCaretSticky {
  my $self = shift;
  return $self->SendMessage (2457, 0, 0);
}
# Stop the caret preferred x position changing when the user types.
sub SetCaretSticky {
  my ($self, $useCaretStickyBehaviour) = @_;
  return $self->SendMessage (2458, $useCaretStickyBehaviour, 0);
}
# Switch between sticky and non-sticky: meant to be bound to a key.
sub ToggleCaretSticky {
  my $self = shift;
  return $self->SendMessage (2459, 0, 0);
}
# Enable/Disable convert-on-paste for line endings
sub SetPasteConvertEndings {
  my ($self, $convert) = @_;
  return $self->SendMessage (2467, $convert, 0);
}
# Get convert-on-paste setting
sub GetPasteConvertEndings {
  my $self = shift;
  return $self->SendMessage (2468, 0, 0);
}
# Duplicate the selection. If selection empty duplicate the line containing the caret.
sub SelectionDuplicate {
  my $self = shift;
  return $self->SendMessage (2469, 0, 0);
}
use constant SC_ALPHA_TRANSPARENT => 0 ;
use constant SC_ALPHA_OPAQUE => 255 ;
use constant SC_ALPHA_NOALPHA => 256 ;
# Set background alpha of the caret line.
sub SetCaretLineBackAlpha {
  my ($self, $alpha) = @_;
  return $self->SendMessage (2470, $alpha, 0);
}
# Get the background alpha of the caret line.
sub GetCaretLineBackAlpha {
  my $self = shift;
  return $self->SendMessage (2471, 0, 0);
}
# Start notifying the container of all key presses and commands.
sub StartRecord {
  my $self = shift;
  return $self->SendMessage (3001, 0, 0);
}
# Stop notifying the container of all key presses and commands.
sub StopRecord {
  my $self = shift;
  return $self->SendMessage (3002, 0, 0);
}
# Set the lexing language of the document.
sub SetLexer {
  my ($self, $lexer) = @_;
  return $self->SendMessage (4001, $lexer, 0);
}
# Retrieve the lexing language of the document.
sub GetLexer {
  my $self = shift;
  return $self->SendMessage (4002, 0, 0);
}
# Colourise a segment of the document using the current lexing language.
sub Colourise {
  my ($self, $start, $end) = @_;
  return $self->SendMessage (4003, $start, $end);
}
# Set up a value that may be used by a lexer for some optional feature.
sub SetProperty {
  my ($self, $key, $value) = @_;
  return $self->SendMessagePP (4004, $key, $value);
}
# Maximum value of keywordSet parameter of SetKeyWords.
use constant KEYWORDSET_MAX => 8 ;
# Set up the key words used by the lexer.
sub SetKeyWords {
  my ($self, $keywordSet, $keyWords) = @_;
  return $self->SendMessageNP (4005, $keywordSet, $keyWords);
}
# Set the lexing language of the document based on string name.
sub SetLexerLanguage {
  my ($self, $language) = @_;
  return $self->SendMessageNP (4006, 0, $language);
}
# Load a lexer library (dll / so).
sub LoadLexerLibrary {
  my ($self, $path) = @_;
  return $self->SendMessageNP (4007, 0, $path);
}
# Retrieve a "property" value previously set with SetProperty.
# GetProperty(): Retrieve a "property" value previously set with SetProperty.
# GetPropertyExpanded() with "$()" variable replacement on returned buffer.
sub GetProperty {
  my ($self, $key)   = @_;
  my $len = $self->SendMessagePN(4008, $key, 0);
  my $text   = " " x $len;

  $self->SendMessagePP (4008, $key, $text);
  return $text;
}
# Retrieve a "property" value previously set with SetProperty,
# with "$()" variable replacement on returned buffer.
# GetProperty(): Retrieve a "property" value previously set with SetProperty.
# GetPropertyExpanded() with "$()" variable replacement on returned buffer.
sub GetPropertyExpanded {
  my ($self, $key)   = @_;
  my $len = $self->SendMessagePN(4009, $key, 0);
  my $text   = " " x $len;

  $self->SendMessagePP (4009, $key, $text);
  return $text;
}
# Retrieve a "property" value previously set with SetProperty,
# interpreted as an int AFTER any "$()" variable replacement.
sub GetPropertyInt {
  my ($self, $key) = @_;
  return $self->SendMessagePP (4010, $key, '');
}
# Retrieve the number of bits the current lexer needs for styling.
sub GetStyleBitsNeeded {
  my $self = shift;
  return $self->SendMessage (4011, 0, 0);
}
# Notifications
# Type of modification and the action which caused the modification.
# These are defined as a bit mask to make it easy to specify which notifications are wanted.
# One bit is set from each of SC_MOD_* and SC_PERFORMED_*.
use constant SC_MOD_INSERTTEXT => 0x1 ;
use constant SC_MOD_DELETETEXT => 0x2 ;
use constant SC_MOD_CHANGESTYLE => 0x4 ;
use constant SC_MOD_CHANGEFOLD => 0x8 ;
use constant SC_PERFORMED_USER => 0x10 ;
use constant SC_PERFORMED_UNDO => 0x20 ;
use constant SC_PERFORMED_REDO => 0x40 ;
use constant SC_MULTISTEPUNDOREDO => 0x80 ;
use constant SC_LASTSTEPINUNDOREDO => 0x100 ;
use constant SC_MOD_CHANGEMARKER => 0x200 ;
use constant SC_MOD_BEFOREINSERT => 0x400 ;
use constant SC_MOD_BEFOREDELETE => 0x800 ;
use constant SC_MULTILINEUNDOREDO => 0x1000 ;
use constant SC_MODEVENTMASKALL => 0x1FFF ;
# For compatibility, these go through the COMMAND notification rather than NOTIFY
# and should have had exactly the same values as the EN_* constants.
# Unfortunately the SETFOCUS and KILLFOCUS are flipped over from EN_*
# As clients depend on these constants, this will not be changed.
use constant SCEN_CHANGE => 768 ;
use constant SCEN_SETFOCUS => 512 ;
use constant SCEN_KILLFOCUS => 256 ;
# Symbolic key codes and modifier flags.
# ASCII and other printable characters below 256.
# Extended keys above 300.
use constant SCK_DOWN => 300 ;
use constant SCK_UP => 301 ;
use constant SCK_LEFT => 302 ;
use constant SCK_RIGHT => 303 ;
use constant SCK_HOME => 304 ;
use constant SCK_END => 305 ;
use constant SCK_PRIOR => 306 ;
use constant SCK_NEXT => 307 ;
use constant SCK_DELETE => 308 ;
use constant SCK_INSERT => 309 ;
use constant SCK_ESCAPE => 7 ;
use constant SCK_BACK => 8 ;
use constant SCK_TAB => 9 ;
use constant SCK_RETURN => 13 ;
use constant SCK_ADD => 310 ;
use constant SCK_SUBTRACT => 311 ;
use constant SCK_DIVIDE => 312 ;
use constant SCMOD_NORM => 0 ;
use constant SCMOD_SHIFT => 1 ;
use constant SCMOD_CTRL => 2 ;
use constant SCMOD_ALT => 4 ;
# For SciLexer.h
use constant SCLEX_CONTAINER => 0 ;
use constant SCLEX_NULL => 1 ;
use constant SCLEX_PYTHON => 2 ;
use constant SCLEX_CPP => 3 ;
use constant SCLEX_HTML => 4 ;
use constant SCLEX_XML => 5 ;
use constant SCLEX_PERL => 6 ;
use constant SCLEX_SQL => 7 ;
use constant SCLEX_VB => 8 ;
use constant SCLEX_PROPERTIES => 9 ;
use constant SCLEX_ERRORLIST => 10 ;
use constant SCLEX_MAKEFILE => 11 ;
use constant SCLEX_BATCH => 12 ;
use constant SCLEX_XCODE => 13 ;
use constant SCLEX_LATEX => 14 ;
use constant SCLEX_LUA => 15 ;
use constant SCLEX_DIFF => 16 ;
use constant SCLEX_CONF => 17 ;
use constant SCLEX_PASCAL => 18 ;
use constant SCLEX_AVE => 19 ;
use constant SCLEX_ADA => 20 ;
use constant SCLEX_LISP => 21 ;
use constant SCLEX_RUBY => 22 ;
use constant SCLEX_EIFFEL => 23 ;
use constant SCLEX_EIFFELKW => 24 ;
use constant SCLEX_TCL => 25 ;
use constant SCLEX_NNCRONTAB => 26 ;
use constant SCLEX_BULLANT => 27 ;
use constant SCLEX_VBSCRIPT => 28 ;
use constant SCLEX_BAAN => 31 ;
use constant SCLEX_MATLAB => 32 ;
use constant SCLEX_SCRIPTOL => 33 ;
use constant SCLEX_ASM => 34 ;
use constant SCLEX_CPPNOCASE => 35 ;
use constant SCLEX_FORTRAN => 36 ;
use constant SCLEX_F77 => 37 ;
use constant SCLEX_CSS => 38 ;
use constant SCLEX_POV => 39 ;
use constant SCLEX_LOUT => 40 ;
use constant SCLEX_ESCRIPT => 41 ;
use constant SCLEX_PS => 42 ;
use constant SCLEX_NSIS => 43 ;
use constant SCLEX_MMIXAL => 44 ;
use constant SCLEX_CLW => 45 ;
use constant SCLEX_CLWNOCASE => 46 ;
use constant SCLEX_LOT => 47 ;
use constant SCLEX_YAML => 48 ;
use constant SCLEX_TEX => 49 ;
use constant SCLEX_METAPOST => 50 ;
use constant SCLEX_POWERBASIC => 51 ;
use constant SCLEX_FORTH => 52 ;
use constant SCLEX_ERLANG => 53 ;
use constant SCLEX_OCTAVE => 54 ;
use constant SCLEX_MSSQL => 55 ;
use constant SCLEX_VERILOG => 56 ;
use constant SCLEX_KIX => 57 ;
use constant SCLEX_GUI4CLI => 58 ;
use constant SCLEX_SPECMAN => 59 ;
use constant SCLEX_AU3 => 60 ;
use constant SCLEX_APDL => 61 ;
use constant SCLEX_BASH => 62 ;
use constant SCLEX_ASN1 => 63 ;
use constant SCLEX_VHDL => 64 ;
use constant SCLEX_CAML => 65 ;
use constant SCLEX_BLITZBASIC => 66 ;
use constant SCLEX_PUREBASIC => 67 ;
use constant SCLEX_HASKELL => 68 ;
use constant SCLEX_PHPSCRIPT => 69 ;
use constant SCLEX_TADS3 => 70 ;
use constant SCLEX_REBOL => 71 ;
use constant SCLEX_SMALLTALK => 72 ;
use constant SCLEX_FLAGSHIP => 73 ;
use constant SCLEX_CSOUND => 74 ;
use constant SCLEX_FREEBASIC => 75 ;
use constant SCLEX_INNOSETUP => 76 ;
use constant SCLEX_OPAL => 77 ;
# When a lexer specifies its language as SCLEX_AUTOMATIC it receives a
# value assigned in sequence from SCLEX_AUTOMATIC+1.
use constant SCLEX_AUTOMATIC => 1000 ;
# Lexical states for SCLEX_PYTHON
# Python=SCLEX_PYTHON SCE_P_
use constant SCE_P_DEFAULT => 0 ;
use constant SCE_P_COMMENTLINE => 1 ;
use constant SCE_P_NUMBER => 2 ;
use constant SCE_P_STRING => 3 ;
use constant SCE_P_CHARACTER => 4 ;
use constant SCE_P_WORD => 5 ;
use constant SCE_P_TRIPLE => 6 ;
use constant SCE_P_TRIPLEDOUBLE => 7 ;
use constant SCE_P_CLASSNAME => 8 ;
use constant SCE_P_DEFNAME => 9 ;
use constant SCE_P_OPERATOR => 10 ;
use constant SCE_P_IDENTIFIER => 11 ;
use constant SCE_P_COMMENTBLOCK => 12 ;
use constant SCE_P_STRINGEOL => 13 ;
use constant SCE_P_WORD2 => 14 ;
use constant SCE_P_DECORATOR => 15 ;
# Lexical states for SCLEX_CPP
# Cpp=SCLEX_CPP SCE_C_
# Pascal=SCLEX_PASCAL SCE_C_
# BullAnt=SCLEX_BULLANT SCE_C_
use constant SCE_C_DEFAULT => 0 ;
use constant SCE_C_COMMENT => 1 ;
use constant SCE_C_COMMENTLINE => 2 ;
use constant SCE_C_COMMENTDOC => 3 ;
use constant SCE_C_NUMBER => 4 ;
use constant SCE_C_WORD => 5 ;
use constant SCE_C_STRING => 6 ;
use constant SCE_C_CHARACTER => 7 ;
use constant SCE_C_UUID => 8 ;
use constant SCE_C_PREPROCESSOR => 9 ;
use constant SCE_C_OPERATOR => 10 ;
use constant SCE_C_IDENTIFIER => 11 ;
use constant SCE_C_STRINGEOL => 12 ;
use constant SCE_C_VERBATIM => 13 ;
use constant SCE_C_REGEX => 14 ;
use constant SCE_C_COMMENTLINEDOC => 15 ;
use constant SCE_C_WORD2 => 16 ;
use constant SCE_C_COMMENTDOCKEYWORD => 17 ;
use constant SCE_C_COMMENTDOCKEYWORDERROR => 18 ;
use constant SCE_C_GLOBALCLASS => 19 ;
# Lexical states for SCLEX_TCL
# TCL=SCLEX_TCL SCE_TCL_
use constant SCE_TCL_DEFAULT => 0 ;
use constant SCE_TCL_COMMENT => 1 ;
use constant SCE_TCL_COMMENTLINE => 2 ;
use constant SCE_TCL_NUMBER => 3 ;
use constant SCE_TCL_WORD_IN_QUOTE => 4 ;
use constant SCE_TCL_IN_QUOTE => 5 ;
use constant SCE_TCL_OPERATOR => 6 ;
use constant SCE_TCL_IDENTIFIER => 7 ;
use constant SCE_TCL_SUBSTITUTION => 8 ;
use constant SCE_TCL_SUB_BRACE => 9 ;
use constant SCE_TCL_MODIFIER => 10 ;
use constant SCE_TCL_EXPAND => 11 ;
use constant SCE_TCL_WORD => 12 ;
use constant SCE_TCL_WORD2 => 13 ;
use constant SCE_TCL_WORD3 => 14 ;
use constant SCE_TCL_WORD4 => 15 ;
use constant SCE_TCL_WORD5 => 16 ;
use constant SCE_TCL_WORD6 => 17 ;
use constant SCE_TCL_WORD7 => 18 ;
use constant SCE_TCL_WORD8 => 19 ;
# Lexical states for SCLEX_HTML, SCLEX_XML
# HTML=SCLEX_HTML SCE_H
# XML=SCLEX_XML SCE_H
# ASP=SCLEX_ASP SCE_H
# PHP=SCLEX_PHP SCE_H
use constant SCE_H_DEFAULT => 0 ;
use constant SCE_H_TAG => 1 ;
use constant SCE_H_TAGUNKNOWN => 2 ;
use constant SCE_H_ATTRIBUTE => 3 ;
use constant SCE_H_ATTRIBUTEUNKNOWN => 4 ;
use constant SCE_H_NUMBER => 5 ;
use constant SCE_H_DOUBLESTRING => 6 ;
use constant SCE_H_SINGLESTRING => 7 ;
use constant SCE_H_OTHER => 8 ;
use constant SCE_H_COMMENT => 9 ;
use constant SCE_H_ENTITY => 10 ;
# XML and ASP
use constant SCE_H_TAGEND => 11 ;
use constant SCE_H_XMLSTART => 12 ;
use constant SCE_H_XMLEND => 13 ;
use constant SCE_H_SCRIPT => 14 ;
use constant SCE_H_ASP => 15 ;
use constant SCE_H_ASPAT => 16 ;
use constant SCE_H_CDATA => 17 ;
use constant SCE_H_QUESTION => 18 ;
# More HTML
use constant SCE_H_VALUE => 19 ;
# X-Code
use constant SCE_H_XCCOMMENT => 20 ;
# SGML
use constant SCE_H_SGML_DEFAULT => 21 ;
use constant SCE_H_SGML_COMMAND => 22 ;
use constant SCE_H_SGML_1ST_PARAM => 23 ;
use constant SCE_H_SGML_DOUBLESTRING => 24 ;
use constant SCE_H_SGML_SIMPLESTRING => 25 ;
use constant SCE_H_SGML_ERROR => 26 ;
use constant SCE_H_SGML_SPECIAL => 27 ;
use constant SCE_H_SGML_ENTITY => 28 ;
use constant SCE_H_SGML_COMMENT => 29 ;
use constant SCE_H_SGML_1ST_PARAM_COMMENT => 30 ;
use constant SCE_H_SGML_BLOCK_DEFAULT => 31 ;
# Embedded Javascript
use constant SCE_HJ_START => 40 ;
use constant SCE_HJ_DEFAULT => 41 ;
use constant SCE_HJ_COMMENT => 42 ;
use constant SCE_HJ_COMMENTLINE => 43 ;
use constant SCE_HJ_COMMENTDOC => 44 ;
use constant SCE_HJ_NUMBER => 45 ;
use constant SCE_HJ_WORD => 46 ;
use constant SCE_HJ_KEYWORD => 47 ;
use constant SCE_HJ_DOUBLESTRING => 48 ;
use constant SCE_HJ_SINGLESTRING => 49 ;
use constant SCE_HJ_SYMBOLS => 50 ;
use constant SCE_HJ_STRINGEOL => 51 ;
use constant SCE_HJ_REGEX => 52 ;
# ASP Javascript
use constant SCE_HJA_START => 55 ;
use constant SCE_HJA_DEFAULT => 56 ;
use constant SCE_HJA_COMMENT => 57 ;
use constant SCE_HJA_COMMENTLINE => 58 ;
use constant SCE_HJA_COMMENTDOC => 59 ;
use constant SCE_HJA_NUMBER => 60 ;
use constant SCE_HJA_WORD => 61 ;
use constant SCE_HJA_KEYWORD => 62 ;
use constant SCE_HJA_DOUBLESTRING => 63 ;
use constant SCE_HJA_SINGLESTRING => 64 ;
use constant SCE_HJA_SYMBOLS => 65 ;
use constant SCE_HJA_STRINGEOL => 66 ;
use constant SCE_HJA_REGEX => 67 ;
# Embedded VBScript
use constant SCE_HB_START => 70 ;
use constant SCE_HB_DEFAULT => 71 ;
use constant SCE_HB_COMMENTLINE => 72 ;
use constant SCE_HB_NUMBER => 73 ;
use constant SCE_HB_WORD => 74 ;
use constant SCE_HB_STRING => 75 ;
use constant SCE_HB_IDENTIFIER => 76 ;
use constant SCE_HB_STRINGEOL => 77 ;
# ASP VBScript
use constant SCE_HBA_START => 80 ;
use constant SCE_HBA_DEFAULT => 81 ;
use constant SCE_HBA_COMMENTLINE => 82 ;
use constant SCE_HBA_NUMBER => 83 ;
use constant SCE_HBA_WORD => 84 ;
use constant SCE_HBA_STRING => 85 ;
use constant SCE_HBA_IDENTIFIER => 86 ;
use constant SCE_HBA_STRINGEOL => 87 ;
# Embedded Python
use constant SCE_HP_START => 90 ;
use constant SCE_HP_DEFAULT => 91 ;
use constant SCE_HP_COMMENTLINE => 92 ;
use constant SCE_HP_NUMBER => 93 ;
use constant SCE_HP_STRING => 94 ;
use constant SCE_HP_CHARACTER => 95 ;
use constant SCE_HP_WORD => 96 ;
use constant SCE_HP_TRIPLE => 97 ;
use constant SCE_HP_TRIPLEDOUBLE => 98 ;
use constant SCE_HP_CLASSNAME => 99 ;
use constant SCE_HP_DEFNAME => 100 ;
use constant SCE_HP_OPERATOR => 101 ;
use constant SCE_HP_IDENTIFIER => 102 ;
# PHP
use constant SCE_HPHP_COMPLEX_VARIABLE => 104 ;
# ASP Python
use constant SCE_HPA_START => 105 ;
use constant SCE_HPA_DEFAULT => 106 ;
use constant SCE_HPA_COMMENTLINE => 107 ;
use constant SCE_HPA_NUMBER => 108 ;
use constant SCE_HPA_STRING => 109 ;
use constant SCE_HPA_CHARACTER => 110 ;
use constant SCE_HPA_WORD => 111 ;
use constant SCE_HPA_TRIPLE => 112 ;
use constant SCE_HPA_TRIPLEDOUBLE => 113 ;
use constant SCE_HPA_CLASSNAME => 114 ;
use constant SCE_HPA_DEFNAME => 115 ;
use constant SCE_HPA_OPERATOR => 116 ;
use constant SCE_HPA_IDENTIFIER => 117 ;
# PHP
use constant SCE_HPHP_DEFAULT => 118 ;
use constant SCE_HPHP_HSTRING => 119 ;
use constant SCE_HPHP_SIMPLESTRING => 120 ;
use constant SCE_HPHP_WORD => 121 ;
use constant SCE_HPHP_NUMBER => 122 ;
use constant SCE_HPHP_VARIABLE => 123 ;
use constant SCE_HPHP_COMMENT => 124 ;
use constant SCE_HPHP_COMMENTLINE => 125 ;
use constant SCE_HPHP_HSTRING_VARIABLE => 126 ;
use constant SCE_HPHP_OPERATOR => 127 ;
# Lexical states for SCLEX_PERL
# Perl=SCLEX_PERL SCE_PL_
use constant SCE_PL_DEFAULT => 0 ;
use constant SCE_PL_ERROR => 1 ;
use constant SCE_PL_COMMENTLINE => 2 ;
use constant SCE_PL_POD => 3 ;
use constant SCE_PL_NUMBER => 4 ;
use constant SCE_PL_WORD => 5 ;
use constant SCE_PL_STRING => 6 ;
use constant SCE_PL_CHARACTER => 7 ;
use constant SCE_PL_PUNCTUATION => 8 ;
use constant SCE_PL_PREPROCESSOR => 9 ;
use constant SCE_PL_OPERATOR => 10 ;
use constant SCE_PL_IDENTIFIER => 11 ;
use constant SCE_PL_SCALAR => 12 ;
use constant SCE_PL_ARRAY => 13 ;
use constant SCE_PL_HASH => 14 ;
use constant SCE_PL_SYMBOLTABLE => 15 ;
use constant SCE_PL_VARIABLE_INDEXER => 16 ;
use constant SCE_PL_REGEX => 17 ;
use constant SCE_PL_REGSUBST => 18 ;
use constant SCE_PL_LONGQUOTE => 19 ;
use constant SCE_PL_BACKTICKS => 20 ;
use constant SCE_PL_DATASECTION => 21 ;
use constant SCE_PL_HERE_DELIM => 22 ;
use constant SCE_PL_HERE_Q => 23 ;
use constant SCE_PL_HERE_QQ => 24 ;
use constant SCE_PL_HERE_QX => 25 ;
use constant SCE_PL_STRING_Q => 26 ;
use constant SCE_PL_STRING_QQ => 27 ;
use constant SCE_PL_STRING_QX => 28 ;
use constant SCE_PL_STRING_QR => 29 ;
use constant SCE_PL_STRING_QW => 30 ;
use constant SCE_PL_POD_VERB => 31 ;
# Lexical states for SCLEX_RUBY
# Ruby=SCLEX_RUBY SCE_RB_
use constant SCE_RB_DEFAULT => 0 ;
use constant SCE_RB_ERROR => 1 ;
use constant SCE_RB_COMMENTLINE => 2 ;
use constant SCE_RB_POD => 3 ;
use constant SCE_RB_NUMBER => 4 ;
use constant SCE_RB_WORD => 5 ;
use constant SCE_RB_STRING => 6 ;
use constant SCE_RB_CHARACTER => 7 ;
use constant SCE_RB_CLASSNAME => 8 ;
use constant SCE_RB_DEFNAME => 9 ;
use constant SCE_RB_OPERATOR => 10 ;
use constant SCE_RB_IDENTIFIER => 11 ;
use constant SCE_RB_REGEX => 12 ;
use constant SCE_RB_GLOBAL => 13 ;
use constant SCE_RB_SYMBOL => 14 ;
use constant SCE_RB_MODULE_NAME => 15 ;
use constant SCE_RB_INSTANCE_VAR => 16 ;
use constant SCE_RB_CLASS_VAR => 17 ;
use constant SCE_RB_BACKTICKS => 18 ;
use constant SCE_RB_DATASECTION => 19 ;
use constant SCE_RB_HERE_DELIM => 20 ;
use constant SCE_RB_HERE_Q => 21 ;
use constant SCE_RB_HERE_QQ => 22 ;
use constant SCE_RB_HERE_QX => 23 ;
use constant SCE_RB_STRING_Q => 24 ;
use constant SCE_RB_STRING_QQ => 25 ;
use constant SCE_RB_STRING_QX => 26 ;
use constant SCE_RB_STRING_QR => 27 ;
use constant SCE_RB_STRING_QW => 28 ;
use constant SCE_RB_WORD_DEMOTED => 29 ;
use constant SCE_RB_STDIN => 30 ;
use constant SCE_RB_STDOUT => 31 ;
use constant SCE_RB_STDERR => 40 ;
use constant SCE_RB_UPPER_BOUND => 41 ;
# Lexical states for SCLEX_VB, SCLEX_VBSCRIPT, SCLEX_POWERBASIC
# VB=SCLEX_VB SCE_B_
# VBScript=SCLEX_VBSCRIPT SCE_B_
# PowerBasic=SCLEX_POWERBASIC SCE_B_
use constant SCE_B_DEFAULT => 0 ;
use constant SCE_B_COMMENT => 1 ;
use constant SCE_B_NUMBER => 2 ;
use constant SCE_B_KEYWORD => 3 ;
use constant SCE_B_STRING => 4 ;
use constant SCE_B_PREPROCESSOR => 5 ;
use constant SCE_B_OPERATOR => 6 ;
use constant SCE_B_IDENTIFIER => 7 ;
use constant SCE_B_DATE => 8 ;
use constant SCE_B_STRINGEOL => 9 ;
use constant SCE_B_KEYWORD2 => 10 ;
use constant SCE_B_KEYWORD3 => 11 ;
use constant SCE_B_KEYWORD4 => 12 ;
use constant SCE_B_CONSTANT => 13 ;
use constant SCE_B_ASM => 14 ;
use constant SCE_B_LABEL => 15 ;
use constant SCE_B_ERROR => 16 ;
use constant SCE_B_HEXNUMBER => 17 ;
use constant SCE_B_BINNUMBER => 18 ;
# Lexical states for SCLEX_PROPERTIES
# Properties=SCLEX_PROPERTIES SCE_PROPS_
use constant SCE_PROPS_DEFAULT => 0 ;
use constant SCE_PROPS_COMMENT => 1 ;
use constant SCE_PROPS_SECTION => 2 ;
use constant SCE_PROPS_ASSIGNMENT => 3 ;
use constant SCE_PROPS_DEFVAL => 4 ;
use constant SCE_PROPS_KEY => 5 ;
# Lexical states for SCLEX_LATEX
# LaTeX=SCLEX_LATEX SCE_L_
use constant SCE_L_DEFAULT => 0 ;
use constant SCE_L_COMMAND => 1 ;
use constant SCE_L_TAG => 2 ;
use constant SCE_L_MATH => 3 ;
use constant SCE_L_COMMENT => 4 ;
# Lexical states for SCLEX_LUA
# Lua=SCLEX_LUA SCE_LUA_
use constant SCE_LUA_DEFAULT => 0 ;
use constant SCE_LUA_COMMENT => 1 ;
use constant SCE_LUA_COMMENTLINE => 2 ;
use constant SCE_LUA_COMMENTDOC => 3 ;
use constant SCE_LUA_NUMBER => 4 ;
use constant SCE_LUA_WORD => 5 ;
use constant SCE_LUA_STRING => 6 ;
use constant SCE_LUA_CHARACTER => 7 ;
use constant SCE_LUA_LITERALSTRING => 8 ;
use constant SCE_LUA_PREPROCESSOR => 9 ;
use constant SCE_LUA_OPERATOR => 10 ;
use constant SCE_LUA_IDENTIFIER => 11 ;
use constant SCE_LUA_STRINGEOL => 12 ;
use constant SCE_LUA_WORD2 => 13 ;
use constant SCE_LUA_WORD3 => 14 ;
use constant SCE_LUA_WORD4 => 15 ;
use constant SCE_LUA_WORD5 => 16 ;
use constant SCE_LUA_WORD6 => 17 ;
use constant SCE_LUA_WORD7 => 18 ;
use constant SCE_LUA_WORD8 => 19 ;
# Lexical states for SCLEX_ERRORLIST
# ErrorList=SCLEX_ERRORLIST SCE_ERR_
use constant SCE_ERR_DEFAULT => 0 ;
use constant SCE_ERR_PYTHON => 1 ;
use constant SCE_ERR_GCC => 2 ;
use constant SCE_ERR_MS => 3 ;
use constant SCE_ERR_CMD => 4 ;
use constant SCE_ERR_BORLAND => 5 ;
use constant SCE_ERR_PERL => 6 ;
use constant SCE_ERR_NET => 7 ;
use constant SCE_ERR_LUA => 8 ;
use constant SCE_ERR_CTAG => 9 ;
use constant SCE_ERR_DIFF_CHANGED => 10 ;
use constant SCE_ERR_DIFF_ADDITION => 11 ;
use constant SCE_ERR_DIFF_DELETION => 12 ;
use constant SCE_ERR_DIFF_MESSAGE => 13 ;
use constant SCE_ERR_PHP => 14 ;
use constant SCE_ERR_ELF => 15 ;
use constant SCE_ERR_IFC => 16 ;
use constant SCE_ERR_IFORT => 17 ;
use constant SCE_ERR_ABSF => 18 ;
use constant SCE_ERR_TIDY => 19 ;
use constant SCE_ERR_JAVA_STACK => 20 ;
# Lexical states for SCLEX_BATCH
# Batch=SCLEX_BATCH SCE_BAT_
use constant SCE_BAT_DEFAULT => 0 ;
use constant SCE_BAT_COMMENT => 1 ;
use constant SCE_BAT_WORD => 2 ;
use constant SCE_BAT_LABEL => 3 ;
use constant SCE_BAT_HIDE => 4 ;
use constant SCE_BAT_COMMAND => 5 ;
use constant SCE_BAT_IDENTIFIER => 6 ;
use constant SCE_BAT_OPERATOR => 7 ;
# Lexical states for SCLEX_MAKEFILE
# MakeFile=SCLEX_MAKEFILE SCE_MAKE_
use constant SCE_MAKE_DEFAULT => 0 ;
use constant SCE_MAKE_COMMENT => 1 ;
use constant SCE_MAKE_PREPROCESSOR => 2 ;
use constant SCE_MAKE_IDENTIFIER => 3 ;
use constant SCE_MAKE_OPERATOR => 4 ;
use constant SCE_MAKE_TARGET => 5 ;
use constant SCE_MAKE_IDEOL => 9 ;
# Lexical states for SCLEX_DIFF
# Diff=SCLEX_DIFF SCE_DIFF_
use constant SCE_DIFF_DEFAULT => 0 ;
use constant SCE_DIFF_COMMENT => 1 ;
use constant SCE_DIFF_COMMAND => 2 ;
use constant SCE_DIFF_HEADER => 3 ;
use constant SCE_DIFF_POSITION => 4 ;
use constant SCE_DIFF_DELETED => 5 ;
use constant SCE_DIFF_ADDED => 6 ;
# Lexical states for SCLEX_CONF (Apache Configuration Files Lexer)
# Conf=SCLEX_CONF SCE_CONF_
use constant SCE_CONF_DEFAULT => 0 ;
use constant SCE_CONF_COMMENT => 1 ;
use constant SCE_CONF_NUMBER => 2 ;
use constant SCE_CONF_IDENTIFIER => 3 ;
use constant SCE_CONF_EXTENSION => 4 ;
use constant SCE_CONF_PARAMETER => 5 ;
use constant SCE_CONF_STRING => 6 ;
use constant SCE_CONF_OPERATOR => 7 ;
use constant SCE_CONF_IP => 8 ;
use constant SCE_CONF_DIRECTIVE => 9 ;
# Lexical states for SCLEX_AVE, Avenue
# Avenue=SCLEX_AVE SCE_AVE_
use constant SCE_AVE_DEFAULT => 0 ;
use constant SCE_AVE_COMMENT => 1 ;
use constant SCE_AVE_NUMBER => 2 ;
use constant SCE_AVE_WORD => 3 ;
use constant SCE_AVE_STRING => 6 ;
use constant SCE_AVE_ENUM => 7 ;
use constant SCE_AVE_STRINGEOL => 8 ;
use constant SCE_AVE_IDENTIFIER => 9 ;
use constant SCE_AVE_OPERATOR => 10 ;
use constant SCE_AVE_WORD1 => 11 ;
use constant SCE_AVE_WORD2 => 12 ;
use constant SCE_AVE_WORD3 => 13 ;
use constant SCE_AVE_WORD4 => 14 ;
use constant SCE_AVE_WORD5 => 15 ;
use constant SCE_AVE_WORD6 => 16 ;
# Lexical states for SCLEX_ADA
# Ada=SCLEX_ADA SCE_ADA_
use constant SCE_ADA_DEFAULT => 0 ;
use constant SCE_ADA_WORD => 1 ;
use constant SCE_ADA_IDENTIFIER => 2 ;
use constant SCE_ADA_NUMBER => 3 ;
use constant SCE_ADA_DELIMITER => 4 ;
use constant SCE_ADA_CHARACTER => 5 ;
use constant SCE_ADA_CHARACTEREOL => 6 ;
use constant SCE_ADA_STRING => 7 ;
use constant SCE_ADA_STRINGEOL => 8 ;
use constant SCE_ADA_LABEL => 9 ;
use constant SCE_ADA_COMMENTLINE => 10 ;
use constant SCE_ADA_ILLEGAL => 11 ;
# Lexical states for SCLEX_BAAN
# Baan=SCLEX_BAAN SCE_BAAN_
use constant SCE_BAAN_DEFAULT => 0 ;
use constant SCE_BAAN_COMMENT => 1 ;
use constant SCE_BAAN_COMMENTDOC => 2 ;
use constant SCE_BAAN_NUMBER => 3 ;
use constant SCE_BAAN_WORD => 4 ;
use constant SCE_BAAN_STRING => 5 ;
use constant SCE_BAAN_PREPROCESSOR => 6 ;
use constant SCE_BAAN_OPERATOR => 7 ;
use constant SCE_BAAN_IDENTIFIER => 8 ;
use constant SCE_BAAN_STRINGEOL => 9 ;
use constant SCE_BAAN_WORD2 => 10 ;
# Lexical states for SCLEX_LISP
# Lisp=SCLEX_LISP SCE_LISP_
use constant SCE_LISP_DEFAULT => 0 ;
use constant SCE_LISP_COMMENT => 1 ;
use constant SCE_LISP_NUMBER => 2 ;
use constant SCE_LISP_KEYWORD => 3 ;
use constant SCE_LISP_KEYWORD_KW => 4 ;
use constant SCE_LISP_SYMBOL => 5 ;
use constant SCE_LISP_STRING => 6 ;
use constant SCE_LISP_STRINGEOL => 8 ;
use constant SCE_LISP_IDENTIFIER => 9 ;
use constant SCE_LISP_OPERATOR => 10 ;
use constant SCE_LISP_SPECIAL => 11 ;
use constant SCE_LISP_MULTI_COMMENT => 12 ;
# Lexical states for SCLEX_EIFFEL and SCLEX_EIFFELKW
# Eiffel=SCLEX_EIFFEL SCE_EIFFEL_
# EiffelKW=SCLEX_EIFFELKW SCE_EIFFEL_
use constant SCE_EIFFEL_DEFAULT => 0 ;
use constant SCE_EIFFEL_COMMENTLINE => 1 ;
use constant SCE_EIFFEL_NUMBER => 2 ;
use constant SCE_EIFFEL_WORD => 3 ;
use constant SCE_EIFFEL_STRING => 4 ;
use constant SCE_EIFFEL_CHARACTER => 5 ;
use constant SCE_EIFFEL_OPERATOR => 6 ;
use constant SCE_EIFFEL_IDENTIFIER => 7 ;
use constant SCE_EIFFEL_STRINGEOL => 8 ;
# Lexical states for SCLEX_NNCRONTAB (nnCron crontab Lexer)
# NNCronTab=SCLEX_NNCRONTAB SCE_NNCRONTAB_
use constant SCE_NNCRONTAB_DEFAULT => 0 ;
use constant SCE_NNCRONTAB_COMMENT => 1 ;
use constant SCE_NNCRONTAB_TASK => 2 ;
use constant SCE_NNCRONTAB_SECTION => 3 ;
use constant SCE_NNCRONTAB_KEYWORD => 4 ;
use constant SCE_NNCRONTAB_MODIFIER => 5 ;
use constant SCE_NNCRONTAB_ASTERISK => 6 ;
use constant SCE_NNCRONTAB_NUMBER => 7 ;
use constant SCE_NNCRONTAB_STRING => 8 ;
use constant SCE_NNCRONTAB_ENVIRONMENT => 9 ;
use constant SCE_NNCRONTAB_IDENTIFIER => 10 ;
# Lexical states for SCLEX_FORTH (Forth Lexer)
# Forth=SCLEX_FORTH SCE_FORTH_
use constant SCE_FORTH_DEFAULT => 0 ;
use constant SCE_FORTH_COMMENT => 1 ;
use constant SCE_FORTH_COMMENT_ML => 2 ;
use constant SCE_FORTH_IDENTIFIER => 3 ;
use constant SCE_FORTH_CONTROL => 4 ;
use constant SCE_FORTH_KEYWORD => 5 ;
use constant SCE_FORTH_DEFWORD => 6 ;
use constant SCE_FORTH_PREWORD1 => 7 ;
use constant SCE_FORTH_PREWORD2 => 8 ;
use constant SCE_FORTH_NUMBER => 9 ;
use constant SCE_FORTH_STRING => 10 ;
use constant SCE_FORTH_LOCALE => 11 ;
# Lexical states for SCLEX_MATLAB
# MatLab=SCLEX_MATLAB SCE_MATLAB_
use constant SCE_MATLAB_DEFAULT => 0 ;
use constant SCE_MATLAB_COMMENT => 1 ;
use constant SCE_MATLAB_COMMAND => 2 ;
use constant SCE_MATLAB_NUMBER => 3 ;
use constant SCE_MATLAB_KEYWORD => 4 ;
# single quoted string
use constant SCE_MATLAB_STRING => 5 ;
use constant SCE_MATLAB_OPERATOR => 6 ;
use constant SCE_MATLAB_IDENTIFIER => 7 ;
use constant SCE_MATLAB_DOUBLEQUOTESTRING => 8 ;
# Lexical states for SCLEX_SCRIPTOL
# Sol=SCLEX_SCRIPTOL SCE_SCRIPTOL_
use constant SCE_SCRIPTOL_DEFAULT => 0 ;
use constant SCE_SCRIPTOL_WHITE => 1 ;
use constant SCE_SCRIPTOL_COMMENTLINE => 2 ;
use constant SCE_SCRIPTOL_PERSISTENT => 3 ;
use constant SCE_SCRIPTOL_CSTYLE => 4 ;
use constant SCE_SCRIPTOL_COMMENTBLOCK => 5 ;
use constant SCE_SCRIPTOL_NUMBER => 6 ;
use constant SCE_SCRIPTOL_STRING => 7 ;
use constant SCE_SCRIPTOL_CHARACTER => 8 ;
use constant SCE_SCRIPTOL_STRINGEOL => 9 ;
use constant SCE_SCRIPTOL_KEYWORD => 10 ;
use constant SCE_SCRIPTOL_OPERATOR => 11 ;
use constant SCE_SCRIPTOL_IDENTIFIER => 12 ;
use constant SCE_SCRIPTOL_TRIPLE => 13 ;
use constant SCE_SCRIPTOL_CLASSNAME => 14 ;
use constant SCE_SCRIPTOL_PREPROCESSOR => 15 ;
# Lexical states for SCLEX_ASM
# Asm=SCLEX_ASM SCE_ASM_
use constant SCE_ASM_DEFAULT => 0 ;
use constant SCE_ASM_COMMENT => 1 ;
use constant SCE_ASM_NUMBER => 2 ;
use constant SCE_ASM_STRING => 3 ;
use constant SCE_ASM_OPERATOR => 4 ;
use constant SCE_ASM_IDENTIFIER => 5 ;
use constant SCE_ASM_CPUINSTRUCTION => 6 ;
use constant SCE_ASM_MATHINSTRUCTION => 7 ;
use constant SCE_ASM_REGISTER => 8 ;
use constant SCE_ASM_DIRECTIVE => 9 ;
use constant SCE_ASM_DIRECTIVEOPERAND => 10 ;
use constant SCE_ASM_COMMENTBLOCK => 11 ;
use constant SCE_ASM_CHARACTER => 12 ;
use constant SCE_ASM_STRINGEOL => 13 ;
use constant SCE_ASM_EXTINSTRUCTION => 14 ;
# Lexical states for SCLEX_FORTRAN
# Fortran=SCLEX_FORTRAN SCE_F_
# F77=SCLEX_F77 SCE_F_
use constant SCE_F_DEFAULT => 0 ;
use constant SCE_F_COMMENT => 1 ;
use constant SCE_F_NUMBER => 2 ;
use constant SCE_F_STRING1 => 3 ;
use constant SCE_F_STRING2 => 4 ;
use constant SCE_F_STRINGEOL => 5 ;
use constant SCE_F_OPERATOR => 6 ;
use constant SCE_F_IDENTIFIER => 7 ;
use constant SCE_F_WORD => 8 ;
use constant SCE_F_WORD2 => 9 ;
use constant SCE_F_WORD3 => 10 ;
use constant SCE_F_PREPROCESSOR => 11 ;
use constant SCE_F_OPERATOR2 => 12 ;
use constant SCE_F_LABEL => 13 ;
use constant SCE_F_CONTINUATION => 14 ;
# Lexical states for SCLEX_CSS
# CSS=SCLEX_CSS SCE_CSS_
use constant SCE_CSS_DEFAULT => 0 ;
use constant SCE_CSS_TAG => 1 ;
use constant SCE_CSS_CLASS => 2 ;
use constant SCE_CSS_PSEUDOCLASS => 3 ;
use constant SCE_CSS_UNKNOWN_PSEUDOCLASS => 4 ;
use constant SCE_CSS_OPERATOR => 5 ;
use constant SCE_CSS_IDENTIFIER => 6 ;
use constant SCE_CSS_UNKNOWN_IDENTIFIER => 7 ;
use constant SCE_CSS_VALUE => 8 ;
use constant SCE_CSS_COMMENT => 9 ;
use constant SCE_CSS_ID => 10 ;
use constant SCE_CSS_IMPORTANT => 11 ;
use constant SCE_CSS_DIRECTIVE => 12 ;
use constant SCE_CSS_DOUBLESTRING => 13 ;
use constant SCE_CSS_SINGLESTRING => 14 ;
use constant SCE_CSS_IDENTIFIER2 => 15 ;
use constant SCE_CSS_ATTRIBUTE => 16 ;
# Lexical states for SCLEX_POV
# POV=SCLEX_POV SCE_POV_
use constant SCE_POV_DEFAULT => 0 ;
use constant SCE_POV_COMMENT => 1 ;
use constant SCE_POV_COMMENTLINE => 2 ;
use constant SCE_POV_NUMBER => 3 ;
use constant SCE_POV_OPERATOR => 4 ;
use constant SCE_POV_IDENTIFIER => 5 ;
use constant SCE_POV_STRING => 6 ;
use constant SCE_POV_STRINGEOL => 7 ;
use constant SCE_POV_DIRECTIVE => 8 ;
use constant SCE_POV_BADDIRECTIVE => 9 ;
use constant SCE_POV_WORD2 => 10 ;
use constant SCE_POV_WORD3 => 11 ;
use constant SCE_POV_WORD4 => 12 ;
use constant SCE_POV_WORD5 => 13 ;
use constant SCE_POV_WORD6 => 14 ;
use constant SCE_POV_WORD7 => 15 ;
use constant SCE_POV_WORD8 => 16 ;
# Lexical states for SCLEX_LOUT
# LOUT=SCLEX_LOUT SCE_LOUT_
use constant SCE_LOUT_DEFAULT => 0 ;
use constant SCE_LOUT_COMMENT => 1 ;
use constant SCE_LOUT_NUMBER => 2 ;
use constant SCE_LOUT_WORD => 3 ;
use constant SCE_LOUT_WORD2 => 4 ;
use constant SCE_LOUT_WORD3 => 5 ;
use constant SCE_LOUT_WORD4 => 6 ;
use constant SCE_LOUT_STRING => 7 ;
use constant SCE_LOUT_OPERATOR => 8 ;
use constant SCE_LOUT_IDENTIFIER => 9 ;
use constant SCE_LOUT_STRINGEOL => 10 ;
# Lexical states for SCLEX_ESCRIPT
# ESCRIPT=SCLEX_ESCRIPT SCE_ESCRIPT_
use constant SCE_ESCRIPT_DEFAULT => 0 ;
use constant SCE_ESCRIPT_COMMENT => 1 ;
use constant SCE_ESCRIPT_COMMENTLINE => 2 ;
use constant SCE_ESCRIPT_COMMENTDOC => 3 ;
use constant SCE_ESCRIPT_NUMBER => 4 ;
use constant SCE_ESCRIPT_WORD => 5 ;
use constant SCE_ESCRIPT_STRING => 6 ;
use constant SCE_ESCRIPT_OPERATOR => 7 ;
use constant SCE_ESCRIPT_IDENTIFIER => 8 ;
use constant SCE_ESCRIPT_BRACE => 9 ;
use constant SCE_ESCRIPT_WORD2 => 10 ;
use constant SCE_ESCRIPT_WORD3 => 11 ;
# Lexical states for SCLEX_PS
# PS=SCLEX_PS SCE_PS_
use constant SCE_PS_DEFAULT => 0 ;
use constant SCE_PS_COMMENT => 1 ;
use constant SCE_PS_DSC_COMMENT => 2 ;
use constant SCE_PS_DSC_VALUE => 3 ;
use constant SCE_PS_NUMBER => 4 ;
use constant SCE_PS_NAME => 5 ;
use constant SCE_PS_KEYWORD => 6 ;
use constant SCE_PS_LITERAL => 7 ;
use constant SCE_PS_IMMEVAL => 8 ;
use constant SCE_PS_PAREN_ARRAY => 9 ;
use constant SCE_PS_PAREN_DICT => 10 ;
use constant SCE_PS_PAREN_PROC => 11 ;
use constant SCE_PS_TEXT => 12 ;
use constant SCE_PS_HEXSTRING => 13 ;
use constant SCE_PS_BASE85STRING => 14 ;
use constant SCE_PS_BADSTRINGCHAR => 15 ;
# Lexical states for SCLEX_NSIS
# NSIS=SCLEX_NSIS SCE_NSIS_
use constant SCE_NSIS_DEFAULT => 0 ;
use constant SCE_NSIS_COMMENT => 1 ;
use constant SCE_NSIS_STRINGDQ => 2 ;
use constant SCE_NSIS_STRINGLQ => 3 ;
use constant SCE_NSIS_STRINGRQ => 4 ;
use constant SCE_NSIS_FUNCTION => 5 ;
use constant SCE_NSIS_VARIABLE => 6 ;
use constant SCE_NSIS_LABEL => 7 ;
use constant SCE_NSIS_USERDEFINED => 8 ;
use constant SCE_NSIS_SECTIONDEF => 9 ;
use constant SCE_NSIS_SUBSECTIONDEF => 10 ;
use constant SCE_NSIS_IFDEFINEDEF => 11 ;
use constant SCE_NSIS_MACRODEF => 12 ;
use constant SCE_NSIS_STRINGVAR => 13 ;
use constant SCE_NSIS_NUMBER => 14 ;
use constant SCE_NSIS_SECTIONGROUP => 15 ;
use constant SCE_NSIS_PAGEEX => 16 ;
use constant SCE_NSIS_FUNCTIONDEF => 17 ;
use constant SCE_NSIS_COMMENTBOX => 18 ;
# Lexical states for SCLEX_MMIXAL
# MMIXAL=SCLEX_MMIXAL SCE_MMIXAL_
use constant SCE_MMIXAL_LEADWS => 0 ;
use constant SCE_MMIXAL_COMMENT => 1 ;
use constant SCE_MMIXAL_LABEL => 2 ;
use constant SCE_MMIXAL_OPCODE => 3 ;
use constant SCE_MMIXAL_OPCODE_PRE => 4 ;
use constant SCE_MMIXAL_OPCODE_VALID => 5 ;
use constant SCE_MMIXAL_OPCODE_UNKNOWN => 6 ;
use constant SCE_MMIXAL_OPCODE_POST => 7 ;
use constant SCE_MMIXAL_OPERANDS => 8 ;
use constant SCE_MMIXAL_NUMBER => 9 ;
use constant SCE_MMIXAL_REF => 10 ;
use constant SCE_MMIXAL_CHAR => 11 ;
use constant SCE_MMIXAL_STRING => 12 ;
use constant SCE_MMIXAL_REGISTER => 13 ;
use constant SCE_MMIXAL_HEX => 14 ;
use constant SCE_MMIXAL_OPERATOR => 15 ;
use constant SCE_MMIXAL_SYMBOL => 16 ;
use constant SCE_MMIXAL_INCLUDE => 17 ;
# Lexical states for SCLEX_CLW
# Clarion=SCLEX_CLW SCE_CLW_
use constant SCE_CLW_DEFAULT => 0 ;
use constant SCE_CLW_LABEL => 1 ;
use constant SCE_CLW_COMMENT => 2 ;
use constant SCE_CLW_STRING => 3 ;
use constant SCE_CLW_USER_IDENTIFIER => 4 ;
use constant SCE_CLW_INTEGER_CONSTANT => 5 ;
use constant SCE_CLW_REAL_CONSTANT => 6 ;
use constant SCE_CLW_PICTURE_STRING => 7 ;
use constant SCE_CLW_KEYWORD => 8 ;
use constant SCE_CLW_COMPILER_DIRECTIVE => 9 ;
use constant SCE_CLW_RUNTIME_EXPRESSIONS => 10 ;
use constant SCE_CLW_BUILTIN_PROCEDURES_FUNCTION => 11 ;
use constant SCE_CLW_STRUCTURE_DATA_TYPE => 12 ;
use constant SCE_CLW_ATTRIBUTE => 13 ;
use constant SCE_CLW_STANDARD_EQUATE => 14 ;
use constant SCE_CLW_ERROR => 15 ;
use constant SCE_CLW_DEPRECATED => 16 ;
# Lexical states for SCLEX_LOT
# LOT=SCLEX_LOT SCE_LOT_
use constant SCE_LOT_DEFAULT => 0 ;
use constant SCE_LOT_HEADER => 1 ;
use constant SCE_LOT_BREAK => 2 ;
use constant SCE_LOT_SET => 3 ;
use constant SCE_LOT_PASS => 4 ;
use constant SCE_LOT_FAIL => 5 ;
use constant SCE_LOT_ABORT => 6 ;
# Lexical states for SCLEX_YAML
# YAML=SCLEX_YAML SCE_YAML_
use constant SCE_YAML_DEFAULT => 0 ;
use constant SCE_YAML_COMMENT => 1 ;
use constant SCE_YAML_IDENTIFIER => 2 ;
use constant SCE_YAML_KEYWORD => 3 ;
use constant SCE_YAML_NUMBER => 4 ;
use constant SCE_YAML_REFERENCE => 5 ;
use constant SCE_YAML_DOCUMENT => 6 ;
use constant SCE_YAML_TEXT => 7 ;
use constant SCE_YAML_ERROR => 8 ;
# Lexical states for SCLEX_TEX
# TeX=SCLEX_TEX SCE_TEX_
use constant SCE_TEX_DEFAULT => 0 ;
use constant SCE_TEX_SPECIAL => 1 ;
use constant SCE_TEX_GROUP => 2 ;
use constant SCE_TEX_SYMBOL => 3 ;
use constant SCE_TEX_COMMAND => 4 ;
use constant SCE_TEX_TEXT => 5 ;
# Metapost=SCLEX_METAPOST SCE_METAPOST_
use constant SCE_METAPOST_DEFAULT => 0 ;
use constant SCE_METAPOST_SPECIAL => 1 ;
use constant SCE_METAPOST_GROUP => 2 ;
use constant SCE_METAPOST_SYMBOL => 3 ;
use constant SCE_METAPOST_COMMAND => 4 ;
use constant SCE_METAPOST_TEXT => 5 ;
use constant SCE_METAPOST_EXTRA => 6 ;
# Lexical states for SCLEX_ERLANG
# Erlang=SCLEX_ERLANG SCE_ERLANG_
use constant SCE_ERLANG_DEFAULT => 0 ;
use constant SCE_ERLANG_COMMENT => 1 ;
use constant SCE_ERLANG_VARIABLE => 2 ;
use constant SCE_ERLANG_NUMBER => 3 ;
use constant SCE_ERLANG_KEYWORD => 4 ;
use constant SCE_ERLANG_STRING => 5 ;
use constant SCE_ERLANG_OPERATOR => 6 ;
use constant SCE_ERLANG_ATOM => 7 ;
use constant SCE_ERLANG_FUNCTION_NAME => 8 ;
use constant SCE_ERLANG_CHARACTER => 9 ;
use constant SCE_ERLANG_MACRO => 10 ;
use constant SCE_ERLANG_RECORD => 11 ;
use constant SCE_ERLANG_SEPARATOR => 12 ;
use constant SCE_ERLANG_NODE_NAME => 13 ;
use constant SCE_ERLANG_UNKNOWN => 31 ;
# Lexical states for SCLEX_OCTAVE are identical to MatLab
# Octave=SCLEX_OCTAVE SCE_MATLAB_
# Lexical states for SCLEX_MSSQL
# MSSQL=SCLEX_MSSQL SCE_MSSQL_
use constant SCE_MSSQL_DEFAULT => 0 ;
use constant SCE_MSSQL_COMMENT => 1 ;
use constant SCE_MSSQL_LINE_COMMENT => 2 ;
use constant SCE_MSSQL_NUMBER => 3 ;
use constant SCE_MSSQL_STRING => 4 ;
use constant SCE_MSSQL_OPERATOR => 5 ;
use constant SCE_MSSQL_IDENTIFIER => 6 ;
use constant SCE_MSSQL_VARIABLE => 7 ;
use constant SCE_MSSQL_COLUMN_NAME => 8 ;
use constant SCE_MSSQL_STATEMENT => 9 ;
use constant SCE_MSSQL_DATATYPE => 10 ;
use constant SCE_MSSQL_SYSTABLE => 11 ;
use constant SCE_MSSQL_GLOBAL_VARIABLE => 12 ;
use constant SCE_MSSQL_FUNCTION => 13 ;
use constant SCE_MSSQL_STORED_PROCEDURE => 14 ;
use constant SCE_MSSQL_DEFAULT_PREF_DATATYPE => 15 ;
use constant SCE_MSSQL_COLUMN_NAME_2 => 16 ;
# Lexical states for SCLEX_VERILOG
# Verilog=SCLEX_VERILOG SCE_V_
use constant SCE_V_DEFAULT => 0 ;
use constant SCE_V_COMMENT => 1 ;
use constant SCE_V_COMMENTLINE => 2 ;
use constant SCE_V_COMMENTLINEBANG => 3 ;
use constant SCE_V_NUMBER => 4 ;
use constant SCE_V_WORD => 5 ;
use constant SCE_V_STRING => 6 ;
use constant SCE_V_WORD2 => 7 ;
use constant SCE_V_WORD3 => 8 ;
use constant SCE_V_PREPROCESSOR => 9 ;
use constant SCE_V_OPERATOR => 10 ;
use constant SCE_V_IDENTIFIER => 11 ;
use constant SCE_V_STRINGEOL => 12 ;
use constant SCE_V_USER => 19 ;
# Lexical states for SCLEX_KIX
# Kix=SCLEX_KIX SCE_KIX_
use constant SCE_KIX_DEFAULT => 0 ;
use constant SCE_KIX_COMMENT => 1 ;
use constant SCE_KIX_STRING1 => 2 ;
use constant SCE_KIX_STRING2 => 3 ;
use constant SCE_KIX_NUMBER => 4 ;
use constant SCE_KIX_VAR => 5 ;
use constant SCE_KIX_MACRO => 6 ;
use constant SCE_KIX_KEYWORD => 7 ;
use constant SCE_KIX_FUNCTIONS => 8 ;
use constant SCE_KIX_OPERATOR => 9 ;
use constant SCE_KIX_IDENTIFIER => 31 ;
# Lexical states for SCLEX_GUI4CLI
use constant SCE_GC_DEFAULT => 0 ;
use constant SCE_GC_COMMENTLINE => 1 ;
use constant SCE_GC_COMMENTBLOCK => 2 ;
use constant SCE_GC_GLOBAL => 3 ;
use constant SCE_GC_EVENT => 4 ;
use constant SCE_GC_ATTRIBUTE => 5 ;
use constant SCE_GC_CONTROL => 6 ;
use constant SCE_GC_COMMAND => 7 ;
use constant SCE_GC_STRING => 8 ;
use constant SCE_GC_OPERATOR => 9 ;
# Lexical states for SCLEX_SPECMAN
# Specman=SCLEX_SPECMAN SCE_SN_
use constant SCE_SN_DEFAULT => 0 ;
use constant SCE_SN_CODE => 1 ;
use constant SCE_SN_COMMENTLINE => 2 ;
use constant SCE_SN_COMMENTLINEBANG => 3 ;
use constant SCE_SN_NUMBER => 4 ;
use constant SCE_SN_WORD => 5 ;
use constant SCE_SN_STRING => 6 ;
use constant SCE_SN_WORD2 => 7 ;
use constant SCE_SN_WORD3 => 8 ;
use constant SCE_SN_PREPROCESSOR => 9 ;
use constant SCE_SN_OPERATOR => 10 ;
use constant SCE_SN_IDENTIFIER => 11 ;
use constant SCE_SN_STRINGEOL => 12 ;
use constant SCE_SN_REGEXTAG => 13 ;
use constant SCE_SN_SIGNAL => 14 ;
use constant SCE_SN_USER => 19 ;
# Lexical states for SCLEX_AU3
# Au3=SCLEX_AU3 SCE_AU3_
use constant SCE_AU3_DEFAULT => 0 ;
use constant SCE_AU3_COMMENT => 1 ;
use constant SCE_AU3_COMMENTBLOCK => 2 ;
use constant SCE_AU3_NUMBER => 3 ;
use constant SCE_AU3_FUNCTION => 4 ;
use constant SCE_AU3_KEYWORD => 5 ;
use constant SCE_AU3_MACRO => 6 ;
use constant SCE_AU3_STRING => 7 ;
use constant SCE_AU3_OPERATOR => 8 ;
use constant SCE_AU3_VARIABLE => 9 ;
use constant SCE_AU3_SENT => 10 ;
use constant SCE_AU3_PREPROCESSOR => 11 ;
use constant SCE_AU3_SPECIAL => 12 ;
use constant SCE_AU3_EXPAND => 13 ;
use constant SCE_AU3_COMOBJ => 14 ;
# Lexical states for SCLEX_APDL
# APDL=SCLEX_APDL SCE_APDL_
use constant SCE_APDL_DEFAULT => 0 ;
use constant SCE_APDL_COMMENT => 1 ;
use constant SCE_APDL_COMMENTBLOCK => 2 ;
use constant SCE_APDL_NUMBER => 3 ;
use constant SCE_APDL_STRING => 4 ;
use constant SCE_APDL_OPERATOR => 5 ;
use constant SCE_APDL_WORD => 6 ;
use constant SCE_APDL_PROCESSOR => 7 ;
use constant SCE_APDL_COMMAND => 8 ;
use constant SCE_APDL_SLASHCOMMAND => 9 ;
use constant SCE_APDL_STARCOMMAND => 10 ;
use constant SCE_APDL_ARGUMENT => 11 ;
use constant SCE_APDL_FUNCTION => 12 ;
# Lexical states for SCLEX_BASH
# Bash=SCLEX_BASH SCE_SH_
use constant SCE_SH_DEFAULT => 0 ;
use constant SCE_SH_ERROR => 1 ;
use constant SCE_SH_COMMENTLINE => 2 ;
use constant SCE_SH_NUMBER => 3 ;
use constant SCE_SH_WORD => 4 ;
use constant SCE_SH_STRING => 5 ;
use constant SCE_SH_CHARACTER => 6 ;
use constant SCE_SH_OPERATOR => 7 ;
use constant SCE_SH_IDENTIFIER => 8 ;
use constant SCE_SH_SCALAR => 9 ;
use constant SCE_SH_PARAM => 10 ;
use constant SCE_SH_BACKTICKS => 11 ;
use constant SCE_SH_HERE_DELIM => 12 ;
use constant SCE_SH_HERE_Q => 13 ;
# Lexical states for SCLEX_ASN1
# Asn1=SCLEX_ASN1 SCE_ASN1_
use constant SCE_ASN1_DEFAULT => 0 ;
use constant SCE_ASN1_COMMENT => 1 ;
use constant SCE_ASN1_IDENTIFIER => 2 ;
use constant SCE_ASN1_STRING => 3 ;
use constant SCE_ASN1_OID => 4 ;
use constant SCE_ASN1_SCALAR => 5 ;
use constant SCE_ASN1_KEYWORD => 6 ;
use constant SCE_ASN1_ATTRIBUTE => 7 ;
use constant SCE_ASN1_DESCRIPTOR => 8 ;
use constant SCE_ASN1_TYPE => 9 ;
use constant SCE_ASN1_OPERATOR => 10 ;
# Lexical states for SCLEX_VHDL
# VHDL=SCLEX_VHDL SCE_VHDL_
use constant SCE_VHDL_DEFAULT => 0 ;
use constant SCE_VHDL_COMMENT => 1 ;
use constant SCE_VHDL_COMMENTLINEBANG => 2 ;
use constant SCE_VHDL_NUMBER => 3 ;
use constant SCE_VHDL_STRING => 4 ;
use constant SCE_VHDL_OPERATOR => 5 ;
use constant SCE_VHDL_IDENTIFIER => 6 ;
use constant SCE_VHDL_STRINGEOL => 7 ;
use constant SCE_VHDL_KEYWORD => 8 ;
use constant SCE_VHDL_STDOPERATOR => 9 ;
use constant SCE_VHDL_ATTRIBUTE => 10 ;
use constant SCE_VHDL_STDFUNCTION => 11 ;
use constant SCE_VHDL_STDPACKAGE => 12 ;
use constant SCE_VHDL_STDTYPE => 13 ;
use constant SCE_VHDL_USERWORD => 14 ;
# Lexical states for SCLEX_CAML
# Caml=SCLEX_CAML SCE_CAML_
use constant SCE_CAML_DEFAULT => 0 ;
use constant SCE_CAML_IDENTIFIER => 1 ;
use constant SCE_CAML_TAGNAME => 2 ;
use constant SCE_CAML_KEYWORD => 3 ;
use constant SCE_CAML_KEYWORD2 => 4 ;
use constant SCE_CAML_KEYWORD3 => 5 ;
use constant SCE_CAML_LINENUM => 6 ;
use constant SCE_CAML_OPERATOR => 7 ;
use constant SCE_CAML_NUMBER => 8 ;
use constant SCE_CAML_CHAR => 9 ;
use constant SCE_CAML_STRING => 11 ;
use constant SCE_CAML_COMMENT => 12 ;
use constant SCE_CAML_COMMENT1 => 13 ;
use constant SCE_CAML_COMMENT2 => 14 ;
use constant SCE_CAML_COMMENT3 => 15 ;
# Lexical states for SCLEX_HASKELL
# Haskell=SCLEX_HASKELL SCE_HA_
use constant SCE_HA_DEFAULT => 0 ;
use constant SCE_HA_IDENTIFIER => 1 ;
use constant SCE_HA_KEYWORD => 2 ;
use constant SCE_HA_NUMBER => 3 ;
use constant SCE_HA_STRING => 4 ;
use constant SCE_HA_CHARACTER => 5 ;
use constant SCE_HA_CLASS => 6 ;
use constant SCE_HA_MODULE => 7 ;
use constant SCE_HA_CAPITAL => 8 ;
use constant SCE_HA_DATA => 9 ;
use constant SCE_HA_IMPORT => 10 ;
use constant SCE_HA_OPERATOR => 11 ;
use constant SCE_HA_INSTANCE => 12 ;
use constant SCE_HA_COMMENTLINE => 13 ;
use constant SCE_HA_COMMENTBLOCK => 14 ;
use constant SCE_HA_COMMENTBLOCK2 => 15 ;
use constant SCE_HA_COMMENTBLOCK3 => 16 ;
# Lexical states of SCLEX_TADS3
# TADS3=SCLEX_TADS3 SCE_T3_
use constant SCE_T3_DEFAULT => 0 ;
use constant SCE_T3_X_DEFAULT => 1 ;
use constant SCE_T3_PREPROCESSOR => 2 ;
use constant SCE_T3_BLOCK_COMMENT => 3 ;
use constant SCE_T3_LINE_COMMENT => 4 ;
use constant SCE_T3_OPERATOR => 5 ;
use constant SCE_T3_KEYWORD => 6 ;
use constant SCE_T3_NUMBER => 7 ;
use constant SCE_T3_IDENTIFIER => 8 ;
use constant SCE_T3_S_STRING => 9 ;
use constant SCE_T3_D_STRING => 10 ;
use constant SCE_T3_X_STRING => 11 ;
use constant SCE_T3_LIB_DIRECTIVE => 12 ;
use constant SCE_T3_MSG_PARAM => 13 ;
use constant SCE_T3_HTML_TAG => 14 ;
use constant SCE_T3_HTML_DEFAULT => 15 ;
use constant SCE_T3_HTML_STRING => 16 ;
use constant SCE_T3_USER1 => 17 ;
use constant SCE_T3_USER2 => 18 ;
use constant SCE_T3_USER3 => 19 ;
# Lexical states for SCLEX_REBOL
# Rebol=SCLEX_REBOL SCE_REBOL_
use constant SCE_REBOL_DEFAULT => 0 ;
use constant SCE_REBOL_COMMENTLINE => 1 ;
use constant SCE_REBOL_COMMENTBLOCK => 2 ;
use constant SCE_REBOL_PREFACE => 3 ;
use constant SCE_REBOL_OPERATOR => 4 ;
use constant SCE_REBOL_CHARACTER => 5 ;
use constant SCE_REBOL_QUOTEDSTRING => 6 ;
use constant SCE_REBOL_BRACEDSTRING => 7 ;
use constant SCE_REBOL_NUMBER => 8 ;
use constant SCE_REBOL_PAIR => 9 ;
use constant SCE_REBOL_TUPLE => 10 ;
use constant SCE_REBOL_BINARY => 11 ;
use constant SCE_REBOL_MONEY => 12 ;
use constant SCE_REBOL_ISSUE => 13 ;
use constant SCE_REBOL_TAG => 14 ;
use constant SCE_REBOL_FILE => 15 ;
use constant SCE_REBOL_EMAIL => 16 ;
use constant SCE_REBOL_URL => 17 ;
use constant SCE_REBOL_DATE => 18 ;
use constant SCE_REBOL_TIME => 19 ;
use constant SCE_REBOL_IDENTIFIER => 20 ;
use constant SCE_REBOL_WORD => 21 ;
use constant SCE_REBOL_WORD2 => 22 ;
use constant SCE_REBOL_WORD3 => 23 ;
use constant SCE_REBOL_WORD4 => 24 ;
use constant SCE_REBOL_WORD5 => 25 ;
use constant SCE_REBOL_WORD6 => 26 ;
use constant SCE_REBOL_WORD7 => 27 ;
use constant SCE_REBOL_WORD8 => 28 ;
# Lexical states for SCLEX_SQL
# SQL=SCLEX_SQL SCE_SQL_
use constant SCE_SQL_DEFAULT => 0 ;
use constant SCE_SQL_COMMENT => 1 ;
use constant SCE_SQL_COMMENTLINE => 2 ;
use constant SCE_SQL_COMMENTDOC => 3 ;
use constant SCE_SQL_NUMBER => 4 ;
use constant SCE_SQL_WORD => 5 ;
use constant SCE_SQL_STRING => 6 ;
use constant SCE_SQL_CHARACTER => 7 ;
use constant SCE_SQL_SQLPLUS => 8 ;
use constant SCE_SQL_SQLPLUS_PROMPT => 9 ;
use constant SCE_SQL_OPERATOR => 10 ;
use constant SCE_SQL_IDENTIFIER => 11 ;
use constant SCE_SQL_SQLPLUS_COMMENT => 13 ;
use constant SCE_SQL_COMMENTLINEDOC => 15 ;
use constant SCE_SQL_WORD2 => 16 ;
use constant SCE_SQL_COMMENTDOCKEYWORD => 17 ;
use constant SCE_SQL_COMMENTDOCKEYWORDERROR => 18 ;
use constant SCE_SQL_USER1 => 19 ;
use constant SCE_SQL_USER2 => 20 ;
use constant SCE_SQL_USER3 => 21 ;
use constant SCE_SQL_USER4 => 22 ;
use constant SCE_SQL_QUOTEDIDENTIFIER => 23 ;
# Lexical states for SCLEX_SMALLTALK
# Smalltalk=SCLEX_SMALLTALK SCE_ST_
use constant SCE_ST_DEFAULT => 0 ;
use constant SCE_ST_STRING => 1 ;
use constant SCE_ST_NUMBER => 2 ;
use constant SCE_ST_COMMENT => 3 ;
use constant SCE_ST_SYMBOL => 4 ;
use constant SCE_ST_BINARY => 5 ;
use constant SCE_ST_BOOL => 6 ;
use constant SCE_ST_SELF => 7 ;
use constant SCE_ST_SUPER => 8 ;
use constant SCE_ST_NIL => 9 ;
use constant SCE_ST_GLOBAL => 10 ;
use constant SCE_ST_RETURN => 11 ;
use constant SCE_ST_SPECIAL => 12 ;
use constant SCE_ST_KWSEND => 13 ;
use constant SCE_ST_ASSIGN => 14 ;
use constant SCE_ST_CHARACTER => 15 ;
use constant SCE_ST_SPEC_SEL => 16 ;
# Lexical states for SCLEX_FLAGSHIP (clipper)
# FlagShip=SCLEX_FLAGSHIP SCE_B_
use constant SCE_FS_DEFAULT => 0 ;
use constant SCE_FS_COMMENT => 1 ;
use constant SCE_FS_COMMENTLINE => 2 ;
use constant SCE_FS_COMMENTDOC => 3 ;
use constant SCE_FS_COMMENTLINEDOC => 4 ;
use constant SCE_FS_COMMENTDOCKEYWORD => 5 ;
use constant SCE_FS_COMMENTDOCKEYWORDERROR => 6 ;
use constant SCE_FS_KEYWORD => 7 ;
use constant SCE_FS_KEYWORD2 => 8 ;
use constant SCE_FS_KEYWORD3 => 9 ;
use constant SCE_FS_KEYWORD4 => 10 ;
use constant SCE_FS_NUMBER => 11 ;
use constant SCE_FS_STRING => 12 ;
use constant SCE_FS_PREPROCESSOR => 13 ;
use constant SCE_FS_OPERATOR => 14 ;
use constant SCE_FS_IDENTIFIER => 15 ;
use constant SCE_FS_DATE => 16 ;
use constant SCE_FS_STRINGEOL => 17 ;
use constant SCE_FS_CONSTANT => 18 ;
use constant SCE_FS_ASM => 19 ;
use constant SCE_FS_LABEL => 20 ;
use constant SCE_FS_ERROR => 21 ;
use constant SCE_FS_HEXNUMBER => 22 ;
use constant SCE_FS_BINNUMBER => 23 ;
# Lexical states for SCLEX_CSOUND
# Csound=SCLEX_CSOUND SCE_CSOUND_
use constant SCE_CSOUND_DEFAULT => 0 ;
use constant SCE_CSOUND_COMMENT => 1 ;
use constant SCE_CSOUND_NUMBER => 2 ;
use constant SCE_CSOUND_OPERATOR => 3 ;
use constant SCE_CSOUND_INSTR => 4 ;
use constant SCE_CSOUND_IDENTIFIER => 5 ;
use constant SCE_CSOUND_OPCODE => 6 ;
use constant SCE_CSOUND_HEADERSTMT => 7 ;
use constant SCE_CSOUND_USERKEYWORD => 8 ;
use constant SCE_CSOUND_COMMENTBLOCK => 9 ;
use constant SCE_CSOUND_PARAM => 10 ;
use constant SCE_CSOUND_ARATE_VAR => 11 ;
use constant SCE_CSOUND_KRATE_VAR => 12 ;
use constant SCE_CSOUND_IRATE_VAR => 13 ;
use constant SCE_CSOUND_GLOBAL_VAR => 14 ;
use constant SCE_CSOUND_STRINGEOL => 15 ;
# Lexical states for SCLEX_INNOSETUP
# Inno=SCLEX_INNOSETUP SCE_INNO_
use constant SCE_INNO_DEFAULT => 0 ;
use constant SCE_INNO_COMMENT => 1 ;
use constant SCE_INNO_KEYWORD => 2 ;
use constant SCE_INNO_PARAMETER => 3 ;
use constant SCE_INNO_SECTION => 4 ;
use constant SCE_INNO_PREPROC => 5 ;
use constant SCE_INNO_PREPROC_INLINE => 6 ;
use constant SCE_INNO_COMMENT_PASCAL => 7 ;
use constant SCE_INNO_KEYWORD_PASCAL => 8 ;
use constant SCE_INNO_KEYWORD_USER => 9 ;
use constant SCE_INNO_STRING_DOUBLE => 10 ;
use constant SCE_INNO_STRING_SINGLE => 11 ;
use constant SCE_INNO_IDENTIFIER => 12 ;
# Lexical states for SCLEX_OPAL
# Opal=SCLEX_OPAL SCE_OPAL_
use constant SCE_OPAL_SPACE => 0 ;
use constant SCE_OPAL_COMMENT_BLOCK => 1 ;
use constant SCE_OPAL_COMMENT_LINE => 2 ;
use constant SCE_OPAL_INTEGER => 3 ;
use constant SCE_OPAL_KEYWORD => 4 ;
use constant SCE_OPAL_SORT => 5 ;
use constant SCE_OPAL_STRING => 6 ;
use constant SCE_OPAL_PAR => 7 ;
use constant SCE_OPAL_BOOL_CONST => 8 ;
use constant SCE_OPAL_DEFAULT => 32 ;
# Events
# GTK+ Specific to work around focus and accelerator problems:
# CARET_POLICY changed in 1.47
sub SetCaretPolicy {
  my ($self, $caretPolicy, $caretSlop) = @_;
  return $self->SendMessage (2369, $caretPolicy, $caretSlop);
}
use constant CARET_CENTER => 0x02 ;
use constant CARET_XEVEN => 0x08 ;
use constant CARET_XJUMPS => 0x10 ;
# The old name for SCN_UPDATEUI
use constant SCN_CHECKBRACE => 2007 ;
# SCLEX_HTML should be used in preference to these.
use constant SCLEX_ASP => 29 ;
use constant SCLEX_PHP => 30 ;

#------------------------------------------------------------------------
# End Autogenerate
#------------------------------------------------------------------------

# Code Here because need constant

#------------------------------------------------------------------------
# BraceHighEvent Management
#------------------------------------------------------------------------

sub BraceHighEvent {

  my $self   = shift;
  my $braces = shift || "[]{}()";

  my $braceAtCaret = -1;
  my $braceOpposite = -1;
  my $caretPos = $self->GetCurrentPos();

  if ($caretPos > 0) {
    my $charBefore  = $self->GetCharAt($caretPos - 1);
    $braceAtCaret = $caretPos - 1 if (index ($braces, $charBefore) >= 0 );
  }

  if ($braceAtCaret < 0)
  {
    my $charAfter  = $self->GetCharAt($caretPos);
    my $styleAfter = $self->GetCharAt($caretPos);

    $braceAtCaret = $caretPos if (index ($braces, $charAfter) >= 0);
  }

  $braceOpposite = $self->BraceMatch($braceAtCaret) if ($braceAtCaret >= 0);

  if ($braceAtCaret != -1  and $braceOpposite == -1) {
    $self->BraceBadLight($braceAtCaret);
  }
  else {
    $self->BraceHighlight($braceAtCaret, $braceOpposite);
  }
}

#------------------------------------------------------------------------
# Folder Management
#------------------------------------------------------------------------

# Folder Event call
# If Shift and Control are pressed, open or close all folder
# Otherwise
#  if shift is pressed, Toggle 1 level of current folder
#  else if control is pressed, expand all subfolder of current folder
#  else Toggle current folder
sub FolderEvent {

  my $self  = shift;
  my (%evt) = @_;

  if ($evt{-shift} and $evt{-control}) {
    $self->FolderAll();
  }
  else {
    my $lineClicked = $self->LineFromPosition($evt{-position});

    if ($self->GetFoldLevel($lineClicked) & Win32::GUI::Scintilla::SC_FOLDLEVELHEADERFLAG) {
       if ($evt{-shift}) {
           $self->SetFoldExpanded($lineClicked, 1);
           $self->FolderExpand($lineClicked, 1, 1, 1);
       }
       elsif ($evt{-control}) {
           if ($self->GetFoldExpanded($lineClicked)) {
               $self->SetFoldExpanded($lineClicked, 0);
               $self->FolderExpand($lineClicked, 0, 1, 0);
           }
           else {
               $self->SetFoldExpanded($lineClicked, 1);
               $self->FolderExpand($lineClicked, 1, 1, 100);
           }
       }
       else {
          $self->ToggleFold($lineClicked);
       }
     }
  }
}

# Open All Folder
sub FolderAll {

  my $self = shift;
  my $lineCount = $self->GetLineCount();
  my $expanding = 1;
  my $lineNum;

  # find out if we are folding or unfolding
  for $lineNum (1..$lineCount) {
    if ($self->GetFoldLevel($lineNum) & Win32::GUI::Scintilla::SC_FOLDLEVELHEADERFLAG) {
      $expanding = not $self->GetFoldExpanded($lineNum);
      last;
    }
  }

  $lineNum = 0;
  while ($lineNum < $lineCount) {
    my $level = $self->GetFoldLevel($lineNum);
    if (($level & Win32::GUI::Scintilla::SC_FOLDLEVELHEADERFLAG) and
        ($level & Win32::GUI::Scintilla::SC_FOLDLEVELNUMBERMASK) == Win32::GUI::Scintilla::SC_FOLDLEVELBASE) {

      if ($expanding) {
        $self->SetFoldExpanded($lineNum, 1);
        $lineNum = $self->FolderExpand($lineNum, 1);
        $lineNum--;
      }
      else {
        my $lastChild = $self->GetLastChild($lineNum, -1);
        $self->SetFoldExpanded($lineNum, 0);
        $self->HideLines($lineNum+1, $lastChild) if ($lastChild > $lineNum);
      }
    }
    $lineNum++;
  }
}

# Expand folder
sub FolderExpand {
  my $self     = shift;
  my $line     = shift;
  my $doExpand = shift;
  my $force    = shift || 0;
  my $visLevels= shift || 0;
  my $level    = shift || -1;

  my $lastChild = $self->GetLastChild($line, $level);
  $line++;
  while ($line <= $lastChild) {
      if ($force) {
          if ($visLevels > 0) {
              $self->ShowLines($line, $line);
          }
          else {
              $self->HideLines($line, $line);
          }
      }
      else {
          $self->ShowLines($line, $line) if ($doExpand);
      }

      $level = $self->GetFoldLevel($line) if ($level == -1);

      if ($level & Win32::GUI::Scintilla::SC_FOLDLEVELHEADERFLAG) {
          if ($force) {
              if ($visLevels > 1) {
                  $self->SetFoldExpanded($line, 1);
              }
              else {
                  $self->SetFoldExpanded($line, 0);
              }
              $line = $self->FolderExpand($line, $doExpand, $force, $visLevels-1);
          }
          else {
              if ($doExpand and $self->GetFoldExpanded($line)) {
                  $line = $self->FolderExpand($line, 1, $force, $visLevels-1);
              }
              else {
                  $line = $self->FolderExpand($line, 0, $force, $visLevels-1);
              }
          }
      }
      else {
          $line ++;
      }
  }

  return $line;
}

#------------------------------------------------------------------------
# Find Management
#------------------------------------------------------------------------

sub FindAndSelect {

  my $self = shift;
  my $text = shift;
  my $flag = shift || Win32::GUI::Scintilla::SCFIND_WHOLEWORD;
  my $direction = shift || 1;
  my $wrap = shift || 1;

  my ($start, $end);

  # Set Search target
  if ($direction >= 0) {
    $start = $self->GetSelectionEnd ();
    $end   = $self->GetLength();
  }
  else {
    $start = $self->GetSelectionStart() - 1;
    $end   = 0;
  }

  $self->SetTargetStart ($start);
  $self->SetTargetEnd   ($end);
  $self->SetSearchFlags  ($flag);

  # Find text
  my $pos = $self->SearchInTarget($text);

  # Not found and Wrap mode
  if ($pos == -1 and $wrap == 1)
  {
    # New search target
    if ($direction >= 0) {
     $start = 0;
     $end = $self->GetLength();
    }
    else {
     $start = $self->GetLength();
     $end = 0;
    }

    $self->SetTargetStart ($start);
    $self->SetTargetEnd   ($end);

    # Find Text
    $pos = $self->SearchInTarget($text);
  }

  # Select and visible
  unless ($pos == -1)
  {
    # GetTarget
    $start = $self->GetTargetStart();
    $end   = $self->GetTargetEnd();

    # Ensure range visible
    my ($lstart, $lend);
    if ($start <= $end)
    {
      $lstart = $self->LineFromPosition($start);
      $lend   = $self->LineFromPosition($end);
    }
    else
    {
      $lstart = $self->LineFromPosition($end);
      $lend   = $self->LineFromPosition($start);
    }

    for my $i ($lstart .. $lend)
    {
      $self->EnsureVisible ($i);
    }

    # Select Target
    $self->SetSel ($start, $end);
  }
  else
  {
    $self->SetSelectionStart ($self->GetSelectionEnd());
  }

  return $pos;
}

1; # End of Scintilla.pm
__END__
