scintilla/WindowAccessor.cxx

   1 // Scintilla source code edit control
   2 /** @file WindowAccessor.cxx
   3  ** Rapid easy access to contents of a Scintilla.
   4  **/
   5 // Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
   6 // The License.txt file describes the conditions under which this software may be distributed.
   7
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include <ctype.h>
  11 #include <stdio.h>
  12
  13 #include "Platform.h"
  14
  15 #include "PropSet.h"
  16 #include "Accessor.h"
  17 #include "WindowAccessor.h"
  18 #include "Scintilla.h"
  19
  20 WindowAccessor::~WindowAccessor() {
  21 }
  22
  23 bool WindowAccessor::InternalIsLeadByte(char ch) {
  24         if (SC_CP_UTF8 == codePage)
  25                 // For lexing, all characters >= 0x80 are treated the
  26                 // same so none is considered a lead byte.
  27                 return false;
  28         else
  29                 return Platform::IsDBCSLeadByte(codePage, ch);
  30 }
  31
  32 void WindowAccessor::Fill(int position) {
  33         if (lenDoc == -1)
  34                 lenDoc = Platform::SendScintilla(id, SCI_GETTEXTLENGTH, 0, 0);
  35         startPos = position - slopSize;
  36         if (startPos + bufferSize > lenDoc)
  37                 startPos = lenDoc - bufferSize;
  38         if (startPos < 0)
  39                 startPos = 0;
  40         endPos = startPos + bufferSize;
  41         if (endPos > lenDoc)
  42                 endPos = lenDoc;
  43
  44         TextRange tr = {{startPos, endPos}, buf};
  45         Platform::SendScintillaPointer(id, SCI_GETTEXTRANGE, 0, &tr);
  46 }
  47
  48 bool WindowAccessor::Match(int pos, const char *s) {
  49         for (int i=0; *s; i++) {
  50                 if (*s != SafeGetCharAt(pos+i))
  51                         return false;
  52                 s++;
  53         }
  54         return true;
  55 }
  56
  57 char WindowAccessor::StyleAt(int position) {
  58         return static_cast<char>(Platform::SendScintilla(
  59                 id, SCI_GETSTYLEAT, position, 0));
  60 }
  61
  62 int WindowAccessor::GetLine(int position) {
  63         return Platform::SendScintilla(id, SCI_LINEFROMPOSITION, position, 0);
  64 }
  65
  66 int WindowAccessor::LineStart(int line) {
  67         return Platform::SendScintilla(id, SCI_POSITIONFROMLINE, line, 0);
  68 }
  69
  70 int WindowAccessor::LevelAt(int line) {
  71         return Platform::SendScintilla(id, SCI_GETFOLDLEVEL, line, 0);
  72 }
  73
  74 int WindowAccessor::Length() {
  75         if (lenDoc == -1)
  76                 lenDoc = Platform::SendScintilla(id, SCI_GETTEXTLENGTH, 0, 0);
  77         return lenDoc;
  78 }
  79
  80 int WindowAccessor::GetLineState(int line) {
  81         return Platform::SendScintilla(id, SCI_GETLINESTATE, line);
  82 }
  83
  84 int WindowAccessor::SetLineState(int line, int state) {
  85         return Platform::SendScintilla(id, SCI_SETLINESTATE, line, state);
  86 }
  87
  88 void WindowAccessor::StartAt(unsigned int start, char chMask) {
  89         Platform::SendScintilla(id, SCI_STARTSTYLING, start, chMask);
  90 }
  91
  92 void WindowAccessor::StartSegment(unsigned int pos) {
  93         startSeg = pos;
  94 }
  95
  96 void WindowAccessor::ColourTo(unsigned int pos, int chAttr) {
  97         // Only perform styling if non empty range
  98         if (pos != startSeg - 1) {
  99                 if (pos < startSeg) {
 100                         Platform::DebugPrintf("Bad colour positions %d - %d\n", startSeg, pos);
 101                 }
 102
 103                 if (validLen + (pos - startSeg + 1) >= bufferSize)
 104                         Flush();
 105                 if (validLen + (pos - startSeg + 1) >= bufferSize) {
 106                         // Too big for buffer so send directly
 107                         Platform::SendScintilla(id, SCI_SETSTYLING, pos - startSeg + 1, chAttr);
 108                 } else {
 109                         if (chAttr != chWhile)
 110                                 chFlags = 0;
 111                         chAttr |= chFlags;
 112                         for (unsigned int i = startSeg; i <= pos; i++) {
 113                                 styleBuf[validLen++] = static_cast<char>(chAttr);
 114                         }
 115                 }
 116         }
 117         startSeg = pos+1;
 118 }
 119
 120 void WindowAccessor::SetLevel(int line, int level) {
 121         Platform::SendScintilla(id, SCI_SETFOLDLEVEL, line, level);
 122 }
 123
 124 void WindowAccessor::Flush() {
 125         startPos = extremePosition;
 126         lenDoc = -1;
 127         if (validLen > 0) {
 128                 Platform::SendScintillaPointer(id, SCI_SETSTYLINGEX, validLen,
 129                         styleBuf);
 130                 validLen = 0;
 131         }
 132 }
 133
 134 int WindowAccessor::IndentAmount(int line, int *flags, PFNIsCommentLeader pfnIsCommentLeader) {
 135         int end = Length();
 136         int spaceFlags = 0;
 137
 138         // Determines the indentation level of the current line and also checks for consistent
 139         // indentation compared to the previous line.
 140         // Indentation is judged consistent when the indentation whitespace of each line lines
 141         // the same or the indentation of one line is a prefix of the other.
 142
 143         int pos = LineStart(line);
 144         char ch = (*this)[pos];
 145         int indent = 0;
 146         bool inPrevPrefix = line > 0;
 147         int posPrev = inPrevPrefix ? LineStart(line-1) : 0;
 148         while ((ch == ' ' || ch == '\t') && (pos < end)) {
 149                 if (inPrevPrefix) {
 150                         char chPrev = (*this)[posPrev++];
 151                         if (chPrev == ' ' || chPrev == '\t') {
 152                                 if (chPrev != ch)
 153                                         spaceFlags |= wsInconsistent;
 154                         } else {
 155                                 inPrevPrefix = false;
 156                         }
 157                 }
 158                 if (ch == ' ') {
 159                         spaceFlags |= wsSpace;
 160                         indent++;
 161                 } else {        // Tab
 162                         spaceFlags |= wsTab;
 163                         if (spaceFlags & wsSpace)
 164                                 spaceFlags |= wsSpaceTab;
 165                         indent = (indent / 8 + 1) * 8;
 166                 }
 167                 ch = (*this)[++pos];
 168         }
 169
 170         *flags = spaceFlags;
 171         indent += SC_FOLDLEVELBASE;
 172         // if completely empty line or the start of a comment...
 173         if (isspace(ch) || (pfnIsCommentLeader && (*pfnIsCommentLeader)(*this, pos, end-pos)) )
 174                 return indent | SC_FOLDLEVELWHITEFLAG;
 175         else
 176                 return indent;
 177 }
 178