You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
865 lines
17 KiB
865 lines
17 KiB
/*************************************************************************** |
|
* Copyright (C) 2008 by Andrzej Rybczak * |
|
* electricityispower@gmail.com * |
|
* * |
|
* This program is free software; you can redistribute it and/or modify * |
|
* it under the terms of the GNU General Public License as published by * |
|
* the Free Software Foundation; either version 2 of the License, or * |
|
* (at your option) any later version. * |
|
* * |
|
* This program is distributed in the hope that it will be useful, * |
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of * |
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * |
|
* GNU General Public License for more details. * |
|
* * |
|
* You should have received a copy of the GNU General Public License * |
|
* along with this program; if not, write to the * |
|
* Free Software Foundation, Inc., * |
|
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * |
|
***************************************************************************/ |
|
|
|
#include "window.h" |
|
|
|
Window::Window(int startx, int starty, int width, int height, const string &title, Color color, Border border) : itsWindow(0), itsWinBorder(0), itsGetStringHelper(0), itsStartX(startx), itsStartY(starty), itsWidth(width), itsHeight(height), itsWindowTimeout(-1), BBEnabled(1), AutoRefreshEnabled(1), itsTitle(title), itsColor(color), itsBaseColor(color), itsBgColor(clDefault), itsBaseBgColor(clDefault), itsBorder(border) |
|
{ |
|
if (itsStartX < 0) itsStartX = 0; |
|
if (itsStartY < 0) itsStartY = 0; |
|
|
|
if (itsBorder != brNone) |
|
{ |
|
itsWinBorder = newpad(itsHeight, itsWidth); |
|
wattron(itsWinBorder,COLOR_PAIR(itsBorder)); |
|
box(itsWinBorder,0,0); |
|
itsStartX++; |
|
itsStartY++; |
|
itsWidth -= 2; |
|
itsHeight -= 2; |
|
} |
|
if (!itsTitle.empty()) |
|
{ |
|
itsStartY += 2; |
|
itsHeight -= 2; |
|
} |
|
|
|
if (itsWidth > 0 && itsHeight > 0) |
|
itsWindow = newwin(itsHeight, itsWidth, itsStartY, itsStartX); |
|
else |
|
itsWindow = newwin(0, 0, 0, 0); |
|
|
|
SetColor(itsColor); |
|
} |
|
|
|
Window::Window(const Window &w) |
|
{ |
|
itsWindow = dupwin(w.itsWindow); |
|
itsWinBorder = dupwin(w.itsWinBorder); |
|
itsGetStringHelper = w.itsGetStringHelper; |
|
itsStartX = w.itsStartX; |
|
itsStartY = w.itsStartY; |
|
itsWidth = w.itsWidth; |
|
itsHeight = w.itsHeight; |
|
BBEnabled = w.BBEnabled; |
|
AutoRefreshEnabled = w.AutoRefreshEnabled; |
|
itsTitle = w.itsTitle; |
|
itsColors = w.itsColors; |
|
itsColor = w.itsColor; |
|
itsBaseColor = w.itsBaseColor; |
|
itsBgColor = w.itsBgColor; |
|
itsBaseBgColor = w.itsBaseBgColor; |
|
itsBorder = w.itsBorder; |
|
} |
|
|
|
Window::~Window() |
|
{ |
|
delwin(itsWindow); |
|
delwin(itsWinBorder); |
|
} |
|
|
|
void Window::SetColor(Color col, Color background) |
|
{ |
|
if (col != clDefault) |
|
wattron(itsWindow,COLOR_PAIR(background*8+col)); |
|
else |
|
wattroff(itsWindow,COLOR_PAIR(itsColor)); |
|
itsColor = col; |
|
itsBgColor = background; |
|
} |
|
|
|
void Window::SetBaseColor(Color col, Color background) |
|
{ |
|
itsBaseColor = col; |
|
itsBaseBgColor = background; |
|
} |
|
|
|
void Window::SetBorder(Border border) |
|
{ |
|
if (border == brNone && itsBorder != brNone) |
|
{ |
|
delwin(itsWinBorder); |
|
itsStartX--; |
|
itsStartY--; |
|
itsHeight += 2; |
|
itsWidth += 2; |
|
Recreate(); |
|
} |
|
else if (border != brNone && itsBorder == brNone) |
|
{ |
|
itsWinBorder = newpad(itsHeight,itsWidth); |
|
wattron(itsWinBorder,COLOR_PAIR(border)); |
|
box(itsWinBorder,0,0); |
|
itsStartX++; |
|
itsStartY++; |
|
itsHeight -= 2; |
|
itsWidth -= 2; |
|
Recreate(); |
|
} |
|
else |
|
{ |
|
wattron(itsWinBorder,COLOR_PAIR(border)); |
|
box(itsWinBorder,0,0); |
|
} |
|
itsBorder = border; |
|
} |
|
|
|
void Window::SetTitle(const string &newtitle) |
|
{ |
|
if (itsTitle == newtitle) |
|
{ |
|
return; |
|
} |
|
else if (!newtitle.empty() && itsTitle.empty()) |
|
{ |
|
itsStartY += 2; |
|
itsHeight -= 2; |
|
Recreate(); |
|
} |
|
else if (newtitle.empty() && !itsTitle.empty()) |
|
{ |
|
itsStartY -= 2; |
|
itsHeight += 2; |
|
Recreate(); |
|
} |
|
itsTitle = newtitle; |
|
} |
|
|
|
void Window::Recreate() |
|
{ |
|
delwin(itsWindow); |
|
itsWindow = newwin(itsHeight, itsWidth, itsStartY, itsStartX); |
|
SetTimeout(itsWindowTimeout); |
|
SetColor(itsColor, itsBgColor); |
|
} |
|
|
|
void Window::MoveTo(int newx, int newy) |
|
{ |
|
if (newx < 0 || newy < 0 || (newx == itsStartX && newy == itsStartY)) |
|
return; |
|
else |
|
{ |
|
itsStartX = newx; |
|
itsStartY = newy; |
|
if (itsBorder != brNone) |
|
{ |
|
itsStartX++; |
|
itsStartY++; |
|
} |
|
if (!itsTitle.empty()) |
|
itsStartY += 2; |
|
mvwin(itsWindow, itsStartY, itsStartX); |
|
} |
|
} |
|
|
|
void Window::Resize(int width, int height) |
|
{ |
|
if (itsBorder != brNone) |
|
{ |
|
delwin(itsWinBorder); |
|
itsWinBorder = newpad(height, width); |
|
wattron(itsWinBorder,COLOR_PAIR(itsBorder)); |
|
box(itsWinBorder,0,0); |
|
width -= 2; |
|
height -= 2; |
|
} |
|
if (!itsTitle.empty()) |
|
height -= 2; |
|
|
|
if (height > 0 && width > 0 && wresize(itsWindow, height, width) == OK) |
|
{ |
|
itsHeight = height; |
|
itsWidth = width; |
|
} |
|
} |
|
|
|
void Window::ShowBorder() const |
|
{ |
|
if (itsBorder != brNone) |
|
{ |
|
refresh(); |
|
prefresh(itsWinBorder,0,0,GetStartY(),GetStartX(),itsStartY+itsHeight,itsStartX+itsWidth); |
|
} |
|
if (!itsTitle.empty()) |
|
{ |
|
if (itsBorder != brNone) |
|
attron(COLOR_PAIR(itsBorder)); |
|
else |
|
attron(COLOR_PAIR(itsBaseColor)); |
|
mvhline(itsStartY-1, itsStartX, 0, itsWidth); |
|
attron(A_BOLD); |
|
mvhline(itsStartY-2, itsStartX, 32, itsWidth); // clear title line |
|
mvaddstr(itsStartY-2, itsStartX, itsTitle.c_str()); |
|
attroff(COLOR_PAIR(itsBorder) | A_BOLD); |
|
} |
|
refresh(); |
|
} |
|
|
|
void Window::Display(bool stub) |
|
{ |
|
ShowBorder(); |
|
Refresh(stub); |
|
} |
|
|
|
void Window::Refresh(bool stub) |
|
{ |
|
wrefresh(itsWindow); |
|
} |
|
|
|
void Window::Clear(bool stub) |
|
{ |
|
werase(itsWindow); |
|
wrefresh(itsWindow); |
|
} |
|
|
|
void Window::Hide(char x) const |
|
{ |
|
for (int i = 0; i < GetHeight(); i++) |
|
mvhline(i+GetStartY(), GetStartX(), x, GetWidth()); |
|
refresh(); |
|
} |
|
|
|
void Window::Bold(bool bold) const |
|
{ |
|
bold ? wattron(itsWindow, A_BOLD) : wattroff(itsWindow, A_BOLD); |
|
} |
|
|
|
void Window::Reverse(bool reverse) const |
|
{ |
|
reverse ? wattron(itsWindow, A_REVERSE) : wattroff(itsWindow, A_REVERSE); |
|
} |
|
|
|
void Window::AltCharset(bool alt) const |
|
{ |
|
alt ? wattron(itsWindow, A_ALTCHARSET) : wattroff(itsWindow, A_ALTCHARSET); |
|
} |
|
|
|
void Window::Delay(bool delay) const |
|
{ |
|
nodelay(itsWindow, !delay); |
|
} |
|
|
|
void Window::SetTimeout(int timeout) |
|
{ |
|
itsWindowTimeout = timeout; |
|
wtimeout(itsWindow, timeout); |
|
} |
|
|
|
void Window::ReadKey(int &input) const |
|
{ |
|
keypad(itsWindow, TRUE); input = wgetch(itsWindow); keypad(itsWindow, FALSE); |
|
} |
|
|
|
void Window::ReadKey() const |
|
{ |
|
wgetch(itsWindow); |
|
} |
|
|
|
void Window::Write(int limit, const string &str, bool clrtoeol) |
|
{ |
|
if (BBEnabled) |
|
{ |
|
bool collect = false; |
|
string color, tmp; |
|
for (string::const_iterator it = str.begin(); it != str.end() && limit > 0; it++) |
|
{ |
|
if (*it == '[' && (*(it+1) == '.' || *(it+1) == '/')) |
|
collect = 1; |
|
|
|
if (!collect) |
|
{ |
|
tmp += *it; |
|
limit--; |
|
} |
|
|
|
if (collect) |
|
{ |
|
if (*it != '[') |
|
{ |
|
color += *it; |
|
if (color.length() > 10) collect = 0; // longest bbcode is 10 chars long |
|
} |
|
else |
|
{ |
|
limit -= color.length(); |
|
tmp += color; |
|
color = *it; |
|
} |
|
} |
|
|
|
if (*it == ']' || it+1 == str.end()) |
|
collect = 0; |
|
|
|
if (!collect && !color.empty()) |
|
{ |
|
waddstr(itsWindow,tmp.c_str()); |
|
tmp.clear(); |
|
|
|
if (isdigit(color[2])) |
|
{ |
|
int x, y; |
|
getyx(itsWindow, y, x); |
|
Coordinates coords = IntoCoordinates(color); |
|
wmove(itsWindow, coords.second == -1 ? y : coords.second, coords.first); |
|
limit -= coords.first-x; |
|
} |
|
else if (IsValidColor(color)) |
|
{ |
|
ColorPair colors = IntoColor(color); |
|
SetColor(colors.first, colors.second); |
|
} |
|
else |
|
{ |
|
limit -= color.length(); |
|
tmp += limit > 0 ? color : color.substr(0, color.length()+limit); |
|
} |
|
color.clear(); |
|
} |
|
} |
|
if (!tmp.empty()) waddstr(itsWindow,tmp.c_str()); |
|
} |
|
else |
|
waddstr(itsWindow,str.c_str()); |
|
|
|
if (clrtoeol) |
|
wclrtoeol(itsWindow); |
|
if (AutoRefreshEnabled) |
|
wrefresh(itsWindow); |
|
} |
|
|
|
#ifdef UTF8_ENABLED |
|
void Window::Write(int limit, const wstring &str, bool clrtoeol) |
|
{ |
|
if (BBEnabled) |
|
{ |
|
bool collect = false; |
|
wstring color, tmp; |
|
for (wstring::const_iterator it = str.begin(); it != str.end() && limit > 0; it++) |
|
{ |
|
if (*it == '[' && (*(it+1) == '.' || *(it+1) == '/')) |
|
collect = 1; |
|
|
|
if (!collect) |
|
{ |
|
tmp += *it; |
|
limit--; |
|
} |
|
|
|
if (collect) |
|
{ |
|
if (*it != '[') |
|
{ |
|
color += *it; |
|
if (color.length() > 10) collect = 0; // longest bbcode is 10 chars long |
|
} |
|
else |
|
{ |
|
limit -= color.length(); |
|
tmp += color; |
|
color = *it; |
|
} |
|
} |
|
|
|
if (*it == ']' || it+1 == str.end()) |
|
collect = 0; |
|
|
|
if (!collect && !color.empty()) |
|
{ |
|
waddwstr(itsWindow,tmp.c_str()); |
|
tmp.clear(); |
|
|
|
if (isdigit(color[2])) |
|
{ |
|
int x, y; |
|
getyx(itsWindow, y, x); |
|
Coordinates coords = IntoCoordinates(ToString(color)); |
|
wmove(itsWindow, coords.second == -1 ? y : coords.second, coords.first); |
|
limit -= coords.first-x; |
|
} |
|
else if (IsValidColor(ToString(color))) |
|
{ |
|
ColorPair colors = IntoColor(ToString(color)); |
|
SetColor(colors.first, colors.second); |
|
} |
|
else |
|
{ |
|
limit -= color.length(); |
|
tmp += limit > 0 ? color : color.substr(0, color.length()+limit); |
|
} |
|
color.clear(); |
|
} |
|
} |
|
if (!tmp.empty()) waddwstr(itsWindow,tmp.c_str()); |
|
} |
|
else |
|
waddwstr(itsWindow,str.c_str()); |
|
|
|
if (clrtoeol) |
|
wclrtoeol(itsWindow); |
|
if (AutoRefreshEnabled) |
|
wrefresh(itsWindow); |
|
} |
|
|
|
void Window::WriteXY(int x, int y, int limit, const wstring &str, bool cleartoeol) |
|
{ |
|
wmove(itsWindow,y,x); |
|
Write(limit, str, cleartoeol); |
|
} |
|
#endif |
|
|
|
void Window::WriteXY(int x, int y, int limit, const string &str, bool cleartoeol) |
|
{ |
|
wmove(itsWindow,y,x); |
|
Write(limit, str, cleartoeol); |
|
} |
|
|
|
string Window::GetString(const string &base, unsigned int length, int width) const |
|
{ |
|
int input, beginning, maxbeginning, minx, x, y, maxx; |
|
getyx(itsWindow,y,x); |
|
minx = maxx = x; |
|
|
|
width--; |
|
if (width == -1) |
|
width = itsWidth-x-1; |
|
if (width < 0) |
|
return ""; |
|
|
|
curs_set(1); |
|
keypad(itsWindow, 1); |
|
wstring tmp = ToWString(base); |
|
|
|
string tmp_in; |
|
wchar_t wc_in; |
|
|
|
maxbeginning = beginning = tmp.length() < width ? 0 : tmp.length()-width; |
|
maxx += tmp.length() < width ? tmp.length() : width; |
|
x = maxx; |
|
|
|
do |
|
{ |
|
maxbeginning = tmp.length() < width ? 0 : tmp.length()-width; |
|
maxx = minx + (tmp.length() < width ? tmp.length() : width); |
|
|
|
if (beginning > maxbeginning) |
|
beginning = maxbeginning; |
|
|
|
mvwhline(itsWindow, y, minx, 32, width+1); |
|
mvwprintw(itsWindow, y, minx, "%ls", tmp.substr(beginning, width+1).c_str()); |
|
|
|
if (itsGetStringHelper) |
|
itsGetStringHelper(); |
|
|
|
wmove(itsWindow,y,x); |
|
input = wgetch(itsWindow); |
|
|
|
switch (input) |
|
{ |
|
case ERR: |
|
continue; |
|
case KEY_UP: |
|
case KEY_DOWN: |
|
break; |
|
case KEY_RIGHT: |
|
{ |
|
if (x < maxx) |
|
x++; |
|
else if (beginning < maxbeginning) |
|
beginning++; |
|
break; |
|
} |
|
case KEY_BACKSPACE: case 127: |
|
{ |
|
if (x <= minx && !beginning) |
|
break; |
|
} |
|
case KEY_LEFT: |
|
{ |
|
if (x > minx) |
|
x--; |
|
else if (beginning > 0) |
|
beginning--; |
|
if (input != KEY_BACKSPACE && input != 127) |
|
break; // backspace = left & delete. |
|
} |
|
case KEY_DC: |
|
{ |
|
if ((x-minx)+beginning == tmp.length()) |
|
break; |
|
tmp.erase(tmp.begin()+(x-minx)+beginning); |
|
if (beginning && beginning == maxbeginning && x < maxx) |
|
x++; |
|
break; |
|
} |
|
case KEY_HOME: |
|
{ |
|
x = minx; |
|
beginning = 0; |
|
break; |
|
} |
|
case KEY_END: |
|
{ |
|
x = maxx; |
|
beginning = maxbeginning; |
|
break; |
|
} |
|
case 10: |
|
break; |
|
default: |
|
{ |
|
if (tmp.length() >= length) |
|
break; |
|
|
|
tmp_in += input; |
|
if (mbtowc(&wc_in, tmp_in.c_str(), MB_CUR_MAX) < 0) |
|
break; |
|
|
|
if ((x-minx)+beginning >= tmp.length()) |
|
{ |
|
tmp.push_back(wc_in); |
|
if (!beginning) |
|
x++; |
|
beginning++; |
|
} |
|
else |
|
{ |
|
tmp.insert(tmp.begin()+(x-minx)+beginning, wc_in); |
|
if (x < maxx) |
|
x++; |
|
else if (beginning < maxbeginning) |
|
beginning++; |
|
} |
|
tmp_in.clear(); |
|
} |
|
} |
|
} |
|
while (input != 10); |
|
keypad(itsWindow, 0); |
|
curs_set(0); |
|
return ToString(tmp); |
|
} |
|
|
|
void Window::Scrollable(bool scrollable) const |
|
{ |
|
scrollok(itsWindow, scrollable); |
|
idlok(itsWindow, scrollable); |
|
} |
|
|
|
void Window::GetXY(int &x, int &y) const |
|
{ |
|
getyx(itsWindow, y, x); |
|
} |
|
|
|
void Window::GotoXY(int x, int y) const |
|
{ |
|
wmove(itsWindow, y, x); |
|
} |
|
|
|
int Window::GetWidth() const |
|
{ |
|
if (itsBorder != brNone) |
|
return itsWidth+2; |
|
else |
|
return itsWidth; |
|
} |
|
|
|
int Window::GetHeight() const |
|
{ |
|
int height = itsHeight; |
|
if (itsBorder != brNone) |
|
height += 2; |
|
if (!itsTitle.empty()) |
|
height += 2; |
|
return height; |
|
} |
|
|
|
int Window::GetStartX() const |
|
{ |
|
if (itsBorder != brNone) |
|
return itsStartX-1; |
|
else |
|
return itsStartX; |
|
} |
|
|
|
int Window::GetStartY() const |
|
{ |
|
int starty = itsStartY; |
|
if (itsBorder != brNone) |
|
starty--; |
|
if (!itsTitle.empty()) |
|
starty -= 2; |
|
return starty; |
|
} |
|
|
|
string Window::GetTitle() const |
|
{ |
|
return itsTitle; |
|
} |
|
|
|
Color Window::GetColor() const |
|
{ |
|
return itsColor; |
|
} |
|
|
|
Border Window::GetBorder() const |
|
{ |
|
return itsBorder; |
|
} |
|
|
|
void Window::EnableColors() |
|
{ |
|
if (has_colors()) |
|
{ |
|
start_color(); |
|
use_default_colors(); |
|
int num = 1; |
|
for (int i = -1; i < 8; i++) |
|
for (int j = 0; j < 8; j++) |
|
init_pair(num++, j, i); |
|
} |
|
} |
|
|
|
Window * Window::EmptyClone() const |
|
{ |
|
return new Window(GetStartX(),GetStartY(),GetWidth(),GetHeight(),itsTitle,itsBaseColor,itsBorder); |
|
} |
|
|
|
char * ToString(const wchar_t *ws) |
|
{ |
|
string s; |
|
for (int i = 0; i < wcslen(ws); i++) |
|
{ |
|
char *c = new char[MB_CUR_MAX+1](); |
|
if (wctomb(c, ws[i]) > 0) |
|
s += c; |
|
delete [] c; |
|
} |
|
char *result = strdup(s.c_str()); |
|
return result; |
|
} |
|
|
|
wchar_t * ToWString(const char *s) |
|
{ |
|
wchar_t *ws = new wchar_t[strlen(s)+1](); |
|
mbstowcs(ws, s, strlen(s)); |
|
return ws; |
|
} |
|
|
|
string ToString(const wstring &ws) |
|
{ |
|
string s; |
|
for (wstring::const_iterator it = ws.begin(); it != ws.end(); it++) |
|
{ |
|
char *c = new char[MB_CUR_MAX+1](); |
|
if (wctomb(c, *it) > 0) |
|
s += c; |
|
delete [] c; |
|
} |
|
return s; |
|
} |
|
|
|
wstring ToWString(const string &s) |
|
{ |
|
wchar_t *ws = new wchar_t[s.length()+1](); |
|
mbstowcs(ws, s.c_str(), s.length()); |
|
wstring result = ws; |
|
delete [] ws; |
|
return result; |
|
} |
|
|
|
Coordinates Window::IntoCoordinates(const string &s) |
|
{ |
|
Coordinates result; |
|
unsigned int sep = s.find(","); |
|
if (sep != string::npos) |
|
{ |
|
result.first = atoi(s.substr(2, sep-2).c_str()); |
|
result.second = atoi(s.substr(sep+1).c_str()); |
|
} |
|
else |
|
{ |
|
result.first = atoi(s.substr(2).c_str()); |
|
result.second = -1; |
|
} |
|
return result; |
|
} |
|
|
|
string Window::OmitBBCodes(const string &str) |
|
{ |
|
bool collect = false; |
|
string tmp, color, result; |
|
for (string::const_iterator it = str.begin(); it != str.end(); it++) |
|
{ |
|
if (*it == '[' && (*(it+1) == '.' || *(it+1) == '/')) |
|
collect = 1; |
|
|
|
if (!collect) |
|
tmp += *it; |
|
else |
|
{ |
|
if (*it != '[') |
|
color += *it; |
|
else |
|
{ |
|
tmp += color; |
|
color = *it; |
|
} |
|
} |
|
|
|
if (*it == ']' || it+1 == str.end()) |
|
collect = 0; |
|
|
|
if (!collect && !color.empty()) |
|
{ |
|
result += tmp; |
|
tmp.clear(); |
|
if (!IsValidColor(color)) |
|
tmp += color; |
|
color.clear(); |
|
} |
|
} |
|
if (!tmp.empty()) result += tmp; |
|
return result; |
|
} |
|
|
|
int Window::RealLength(const string &str) |
|
{ |
|
if (str.empty()) |
|
return 0; |
|
|
|
bool collect = false; |
|
int length = 0; |
|
|
|
#ifdef UTF8_ENABLED |
|
wstring str2 = ToWString(str); |
|
wstring tmp; |
|
#else |
|
const string &str2 = str; |
|
string tmp; |
|
#endif |
|
|
|
for (int i = 0; i < str2.length(); i++, length++) |
|
{ |
|
if (str2[i] == '[' && (str2[i+1] == '.' || str2[i+1] == '/')) |
|
collect = 1; |
|
|
|
if (collect) |
|
{ |
|
if (str2[i] != '[') |
|
tmp += str2[i]; |
|
else |
|
tmp = str2[i]; |
|
} |
|
|
|
if (str2[i] == ']') |
|
collect = 0; |
|
|
|
if (!collect && !tmp.empty()) |
|
{ |
|
if (isdigit(tmp[2]) || IsValidColor(TO_STRING(tmp))) |
|
length -= tmp.length(); |
|
tmp.clear(); |
|
} |
|
} |
|
return length; |
|
} |
|
|
|
/*int CountBBCodes(const string &str) |
|
{ |
|
if (str.empty()) |
|
return 0; |
|
bool collect = false; |
|
int length = 0; |
|
string color; |
|
for (string::const_iterator it = str.begin(); it != str.end(); it++) |
|
{ |
|
if (*it != '[' && !collect); |
|
else |
|
collect = 1; |
|
|
|
if (collect) |
|
{ |
|
if (*it != '[') |
|
{ |
|
color += *it; |
|
length++; |
|
} |
|
else |
|
{ |
|
length -= color.length(); |
|
length++; |
|
color = *it; |
|
} |
|
} |
|
|
|
if (*it == ']' || it+1 == str.end()) |
|
collect = 0; |
|
|
|
if (!collect) |
|
{ |
|
if (!IsValidColor(color)) |
|
length -= color.length(); |
|
color.clear(); |
|
} |
|
} |
|
return length; |
|
} |
|
|
|
int CountBBCodes(const wstring &str) |
|
{ |
|
if (str.empty()) |
|
return 0; |
|
bool collect = false; |
|
int length = 0; |
|
wstring color; |
|
for (wstring::const_iterator it = str.begin(); it != str.end(); it++) |
|
{ |
|
if (*it != '[' && !collect); |
|
else |
|
collect = 1; |
|
|
|
if (collect) |
|
{ |
|
if (*it != '[') |
|
{ |
|
color += *it; |
|
length++; |
|
} |
|
else |
|
{ |
|
length -= color.length(); |
|
length++; |
|
color = *it; |
|
} |
|
} |
|
|
|
if (*it == ']' || it+1 == str.end()) |
|
collect = 0; |
|
|
|
if (!collect) |
|
{ |
|
if (!IsValidColor(ToString(color))) |
|
length -= color.length(); |
|
color.clear(); |
|
} |
|
} |
|
return length; |
|
}*/ |
|
|
|
|