00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #include "katetextline.h"
00024
00025 #include <qregexp.h>
00026 #include <kglobal.h>
00027
00028 KateTextLine::KateTextLine ()
00029 : m_flags(KateTextLine::flagVisible)
00030 {
00031 }
00032
00033 KateTextLine::~KateTextLine()
00034 {
00035 }
00036
00037 void KateTextLine::insertText (uint pos, uint insLen, const QChar *insText, uchar *insAttribs)
00038 {
00039
00040 if (insLen == 0)
00041 return;
00042
00043
00044 uint oldTextLen = m_text.length();
00045 m_text.insert (pos, insText, insLen);
00046 uint textLen = m_text.length();
00047
00048
00049 m_attributes.resize (textLen);
00050
00051
00052 if (pos >= oldTextLen)
00053 {
00054 for (uint z = oldTextLen; z < pos; z++)
00055 m_attributes[z] = 0;
00056 }
00057
00058 else if (oldTextLen > 0)
00059 {
00060 for (int z = oldTextLen -1; z >= (int) pos; z--)
00061 m_attributes[z+insLen] = m_attributes[z];
00062 }
00063
00064
00065 for (uint z = 0; z < insLen; z++)
00066 {
00067 if (insAttribs == 0)
00068 m_attributes[z+pos] = 0;
00069 else
00070 m_attributes[z+pos] = insAttribs[z];
00071 }
00072 }
00073
00074 void KateTextLine::removeText (uint pos, uint delLen)
00075 {
00076
00077 if (delLen == 0)
00078 return;
00079
00080 uint textLen = m_text.length();
00081
00082 if (textLen == 0)
00083 return;
00084
00085 if (pos >= textLen)
00086 return;
00087
00088 if ((pos + delLen) > textLen)
00089 delLen = textLen - pos;
00090
00091
00092 for (uint z = pos; z < textLen - delLen; z++)
00093 m_attributes[z] = m_attributes[z+delLen];
00094
00095 m_text.remove (pos, delLen);
00096 m_attributes.resize (m_text.length ());
00097 }
00098
00099 void KateTextLine::truncate(uint newLen)
00100 {
00101 if (newLen < m_text.length())
00102 {
00103 m_text.truncate (newLen);
00104 m_attributes.truncate (newLen);
00105 }
00106 }
00107
00108 int KateTextLine::nextNonSpaceChar(uint pos) const
00109 {
00110 for(int i = pos; i < (int)m_text.length(); i++)
00111 {
00112 if(!m_text[i].isSpace())
00113 return i;
00114 }
00115
00116 return -1;
00117 }
00118
00119 int KateTextLine::previousNonSpaceChar(uint pos) const
00120 {
00121 if (pos >= m_text.length())
00122 pos = m_text.length() - 1;
00123
00124 for(int i = pos; i >= 0; i--)
00125 {
00126 if(!m_text[i].isSpace())
00127 return i;
00128 }
00129
00130 return -1;
00131 }
00132
00133 int KateTextLine::firstChar() const
00134 {
00135 return nextNonSpaceChar(0);
00136 }
00137
00138 int KateTextLine::lastChar() const
00139 {
00140 return previousNonSpaceChar(m_text.length() - 1);
00141 }
00142
00143 const QChar *KateTextLine::firstNonSpace() const
00144 {
00145 int first = firstChar();
00146 return (first > -1) ? ((QChar*)m_text.unicode())+first : m_text.unicode();
00147 }
00148
00149 uint KateTextLine::indentDepth (uint tabwidth) const
00150 {
00151 uint d = 0;
00152
00153 for(uint i = 0; i < m_text.length(); i++)
00154 {
00155 if(m_text[i].isSpace())
00156 {
00157 if (m_text[i] == QChar('\t'))
00158 d += tabwidth - (d % tabwidth);
00159 else
00160 d++;
00161 }
00162 else
00163 return d;
00164 }
00165
00166 return d;
00167 }
00168
00169 bool KateTextLine::stringAtPos(uint pos, const QString& match) const
00170 {
00171 return (m_text.mid(pos, match.length()) == match);
00172 }
00173
00174 bool KateTextLine::startingWith(const QString& match) const
00175 {
00176 return (m_text.left(match.length()) == match);
00177 }
00178
00179 bool KateTextLine::endingWith(const QString& match) const
00180 {
00181 return (m_text.right(match.length()) == match);
00182 }
00183
00184 int KateTextLine::cursorX(uint pos, uint tabChars) const
00185 {
00186 uint x = 0;
00187 uint z;
00188 for ( z = 0; z < kMin (pos, m_text.length()); z++)
00189 {
00190 if (m_text[z] == QChar('\t'))
00191 x += tabChars - (x % tabChars);
00192 else
00193 x++;
00194 }
00195
00196 return x;
00197 }
00198
00199 void KateTextLine::setAttribs(uchar attribute, uint start, uint end)
00200 {
00201 if (end > m_attributes.size())
00202 end = m_attributes.size();
00203
00204 for (uint z = start; z < end; z++)
00205 m_attributes[z] = attribute;
00206 }
00207
00208 bool KateTextLine::searchText (uint startCol, const QString &text, uint *foundAtCol, uint *matchLen, bool casesensitive, bool backwards)
00209 {
00210 int index;
00211
00212 if (backwards)
00213 index = m_text.findRev (text, startCol, casesensitive);
00214 else
00215 index = m_text.find (text, startCol, casesensitive);
00216
00217 if (index > -1)
00218 {
00219 (*foundAtCol) = index;
00220 (*matchLen)=text.length();
00221 return true;
00222 }
00223
00224 return false;
00225 }
00226
00227 bool KateTextLine::searchText (uint startCol, const QRegExp ®exp, uint *foundAtCol, uint *matchLen, bool backwards)
00228 {
00229 int index;
00230
00231 if (backwards)
00232 index = regexp.searchRev (m_text, startCol);
00233 else
00234 index = regexp.search (m_text, startCol);
00235
00236 if (index > -1)
00237 {
00238 (*foundAtCol) = index;
00239 (*matchLen)=regexp.matchedLength();
00240 return true;
00241 }
00242
00243 return false;
00244 }
00245
00246 char *KateTextLine::dump (char *buf, bool withHighlighting) const
00247 {
00248 uint l = m_text.length();
00249 char f = m_flags;
00250
00251 if (!withHighlighting)
00252 f = f | KateTextLine::flagNoOtherData;
00253
00254 memcpy(buf, (char *) &f, 1);
00255 buf += 1;
00256
00257 memcpy(buf, &l, sizeof(uint));
00258 buf += sizeof(uint);
00259
00260 memcpy(buf, (char *) m_text.unicode(), sizeof(QChar)*l);
00261 buf += sizeof(QChar) * l;
00262
00263 if (!withHighlighting)
00264 return buf;
00265
00266 memcpy(buf, (char *)m_attributes.data(), sizeof(uchar) * l);
00267 buf += sizeof (uchar) * l;
00268
00269 uint lctx = m_ctx.size();
00270 uint lfold = m_foldingList.size();
00271 uint lind = m_indentationDepth.size();
00272
00273 memcpy(buf, &lctx, sizeof(uint));
00274 buf += sizeof(uint);
00275
00276 memcpy(buf, &lfold, sizeof(uint));
00277 buf += sizeof(uint);
00278
00279 memcpy(buf, &lind, sizeof(uint));
00280 buf += sizeof(uint);
00281
00282 memcpy(buf, (char *)m_ctx.data(), sizeof(short) * lctx);
00283 buf += sizeof (short) * lctx;
00284
00285 memcpy(buf, (char *)m_foldingList.data(), lfold);
00286 buf += sizeof (signed char) * lfold;
00287
00288 memcpy(buf, (char *)m_indentationDepth.data(), sizeof(unsigned short) * lind);
00289 buf += sizeof (unsigned short) * lind;
00290
00291 return buf;
00292 }
00293
00294 char *KateTextLine::restore (char *buf)
00295 {
00296 uint l = 0;
00297 char f = 0;
00298
00299 memcpy((char *) &f, buf, 1);
00300 buf += 1;
00301
00302
00303 memcpy((char *) &l, buf, sizeof(uint));
00304 buf += sizeof(uint);
00305
00306
00307 m_text.setUnicode ((QChar *) buf, l);
00308 buf += sizeof(QChar) * l;
00309
00310
00311 if (f & KateTextLine::flagNoOtherData)
00312 {
00313 m_flags = KateTextLine::flagVisible;
00314
00315 if (f & KateTextLine::flagAutoWrapped)
00316 m_flags = m_flags | KateTextLine::flagAutoWrapped;
00317
00318
00319 m_attributes.fill (0, l);
00320
00321 return buf;
00322 }
00323 else
00324 m_flags = f;
00325
00326 m_attributes.duplicate ((uchar *) buf, l);
00327 buf += sizeof(uchar) * l;
00328
00329 uint lctx = 0;
00330 uint lfold = 0;
00331 uint lind = 0;
00332
00333 memcpy((char *) &lctx, buf, sizeof(uint));
00334 buf += sizeof(uint);
00335
00336 memcpy((char *) &lfold, buf, sizeof(uint));
00337 buf += sizeof(uint);
00338
00339 memcpy((char *) &lind, buf, sizeof(uint));
00340 buf += sizeof(uint);
00341
00342 m_ctx.duplicate ((short *) buf, lctx);
00343 buf += sizeof(short) * lctx;
00344
00345 m_foldingList.duplicate ((signed char *) buf, lfold);
00346 buf += lfold;
00347
00348 m_indentationDepth.duplicate ((unsigned short *) buf, lind);
00349 buf += sizeof(unsigned short) * lind;
00350
00351 return buf;
00352 }
00353
00354