Salastil/ncmpcpp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

put classes related to ncurses into NCurses namespace

Browse Source
This commit is contained in:
Andrzej Rybczak
2009-03-05 17:43:13 +01:00
parent 8f092d5490
commit ea973b6b4a
10 changed files with 445 additions and 429 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/menu.cpp
View File

@@ -20,6 +20,8 @@
#include "menu.h" #include "menu.h"
using namespace NCurses;
void List::SelectCurrent() void List::SelectCurrent()
{ {
if (Empty()) if (Empty())

102
src/menu.h
View File

@@ -25,8 +25,10 @@
#include "strbuffer.h" #include "strbuffer.h"
#include "misc.h" #include "misc.h"
class List namespace NCurses
{ {
class List
{
public: public:
class InvalidItem { }; class InvalidItem { };
@@ -55,13 +57,10 @@ class List
virtual std::string GetOption(size_t) = 0; virtual std::string GetOption(size_t) = 0;
virtual bool isFiltered() = 0; virtual bool isFiltered() = 0;
//virtual void ShowAll() = 0; };
//virtual void ShowFiltered() = 0;
}; template <class T> class Menu : public Window, public List
{
template <class T> class Menu : public Window, public List
{
typedef void (*ItemDisplayer) (const T &, void *, Menu<T> *); typedef void (*ItemDisplayer) (const T &, void *, Menu<T> *);
typedef std::string (*GetStringFunction) (const T &, void *); typedef std::string (*GetStringFunction) (const T &, void *);
@@ -170,9 +169,12 @@ template <class T> class Menu : public Window, public List
Buffer *itsSelectedPrefix; Buffer *itsSelectedPrefix;
Buffer *itsSelectedSuffix; Buffer *itsSelectedSuffix;
}; };
template <class T> Menu<T>::Menu(size_t startx, template <> std::string Menu<std::string>::GetOption(size_t pos);
}
template <class T> NCurses::Menu<T>::Menu(size_t startx,
size_t starty, size_t starty,
size_t width, size_t width,
size_t height, size_t height,
@@ -194,7 +196,7 @@ template <class T> Menu<T>::Menu(size_t startx,
{ {
} }
template <class T> Menu<T>::Menu(const Menu &m) : Window(m) template <class T> NCurses::Menu<T>::Menu(const Menu &m) : Window(m)
{ {
itsOptions = m.itsOptions; itsOptions = m.itsOptions;
itsItemDisplayer = m.itsItemDisplayer; itsItemDisplayer = m.itsItemDisplayer;
@@ -205,18 +207,18 @@ template <class T> Menu<T>::Menu(const Menu &m) : Window(m)
highlightEnabled = m.highlightEnabled; highlightEnabled = m.highlightEnabled;
} }
template <class T> Menu<T>::~Menu() template <class T> NCurses::Menu<T>::~Menu()
{ {
for (option_iterator it = itsOptions.begin(); it != itsOptions.end(); it++) for (option_iterator it = itsOptions.begin(); it != itsOptions.end(); it++)
delete *it; delete *it;
} }
template <class T> void Menu<T>::Reserve(size_t size) template <class T> void NCurses::Menu<T>::Reserve(size_t size)
{ {
itsOptions.reserve(size); itsOptions.reserve(size);
} }
template <class T> void Menu<T>::ResizeBuffer(size_t size) template <class T> void NCurses::Menu<T>::ResizeBuffer(size_t size)
{ {
itsOptions.resize(size); itsOptions.resize(size);
for (size_t i = 0; i < size; i++) for (size_t i = 0; i < size; i++)
@@ -224,27 +226,27 @@ template <class T> void Menu<T>::ResizeBuffer(size_t size)
itsOptions[i] = new Option(); itsOptions[i] = new Option();
} }
template <class T> void Menu<T>::AddOption(const T &item, bool is_bold, bool is_static) template <class T> void NCurses::Menu<T>::AddOption(const T &item, bool is_bold, bool is_static)
{ {
itsOptions.push_back(new Option(item, is_bold, is_static)); itsOptions.push_back(new Option(item, is_bold, is_static));
} }
template <class T> void Menu<T>::AddSeparator() template <class T> void NCurses::Menu<T>::AddSeparator()
{ {
itsOptions.push_back(0); itsOptions.push_back(0);
} }
template <class T> void Menu<T>::InsertOption(size_t pos, const T &item, bool is_bold, bool is_static) template <class T> void NCurses::Menu<T>::InsertOption(size_t pos, const T &item, bool is_bold, bool is_static)
{ {
itsOptions.insert(itsOptions.begin()+pos, new Option(item, is_bold, is_static)); itsOptions.insert(itsOptions.begin()+pos, new Option(item, is_bold, is_static));
} }
template <class T> void Menu<T>::InsertSeparator(size_t pos) template <class T> void NCurses::Menu<T>::InsertSeparator(size_t pos)
{ {
itsOptions.insert(itsOptions.begin()+pos, 0); itsOptions.insert(itsOptions.begin()+pos, 0);
} }
template <class T> void Menu<T>::DeleteOption(size_t pos) template <class T> void NCurses::Menu<T>::DeleteOption(size_t pos)
{ {
if (itsOptions.empty()) if (itsOptions.empty())
return; return;
@@ -266,13 +268,13 @@ template <class T> void Menu<T>::DeleteOption(size_t pos)
Window::Clear(); Window::Clear();
} }
template <class T> void Menu<T>::IntoSeparator(size_t pos) template <class T> void NCurses::Menu<T>::IntoSeparator(size_t pos)
{ {
delete itsOptions.at(pos); delete itsOptions.at(pos);
itsOptions[pos] = 0; itsOptions[pos] = 0;
} }
template <class T> void Menu<T>::BoldOption(int index, bool bold) template <class T> void NCurses::Menu<T>::BoldOption(int index, bool bold)
{ {
if (!itsOptions.at(index)) if (!itsOptions.at(index))
return; return;
@@ -280,12 +282,12 @@ template <class T> void Menu<T>::BoldOption(int index, bool bold)
} }
template <class T> template <class T>
void Menu<T>::Swap(size_t one, size_t two) void NCurses::Menu<T>::Swap(size_t one, size_t two)
{ {
std::swap(itsOptions.at(one), itsOptions.at(two)); std::swap(itsOptions.at(one), itsOptions.at(two));
} }
template <class T> void Menu<T>::Refresh() template <class T> void NCurses::Menu<T>::Refresh()
{ {
if (itsOptionsPtr->empty()) if (itsOptionsPtr->empty())
{ {
@@ -348,7 +350,7 @@ template <class T> void Menu<T>::Refresh()
Window::Refresh(); Window::Refresh();
} }
template <class T> void Menu<T>::Scroll(Where where) template <class T> void NCurses::Menu<T>::Scroll(Where where)
{ {
if (itsOptionsPtr->empty()) if (itsOptionsPtr->empty())
return; return;
@@ -454,13 +456,13 @@ template <class T> void Menu<T>::Scroll(Where where)
} }
} }
template <class T> void Menu<T>::Reset() template <class T> void NCurses::Menu<T>::Reset()
{ {
itsHighlight = 0; itsHighlight = 0;
itsBeginning = 0; itsBeginning = 0;
} }
template <class T> void Menu<T>::Clear(bool clrscr) template <class T> void NCurses::Menu<T>::Clear(bool clrscr)
{ {
for (option_iterator it = itsOptions.begin(); it != itsOptions.end(); it++) for (option_iterator it = itsOptions.begin(); it != itsOptions.end(); it++)
delete *it; delete *it;
@@ -473,7 +475,7 @@ template <class T> void Menu<T>::Clear(bool clrscr)
Window::Clear(); Window::Clear();
} }
template <class T> bool Menu<T>::isBold(int id) template <class T> bool NCurses::Menu<T>::isBold(int id)
{ {
id = id == -1 ? itsHighlight : id; id = id == -1 ? itsHighlight : id;
if (!itsOptionsPtr->at(id)) if (!itsOptionsPtr->at(id))
@@ -481,21 +483,21 @@ template <class T> bool Menu<T>::isBold(int id)
return (*itsOptionsPtr)[id]->isBold; return (*itsOptionsPtr)[id]->isBold;
} }
template <class T> void Menu<T>::Select(int id, bool value) template <class T> void NCurses::Menu<T>::Select(int id, bool value)
{ {
if (!itsOptionsPtr->at(id)) if (!itsOptionsPtr->at(id))
return; return;
(*itsOptionsPtr)[id]->isSelected = value; (*itsOptionsPtr)[id]->isSelected = value;
} }
template <class T> void Menu<T>::Static(int id, bool value) template <class T> void NCurses::Menu<T>::Static(int id, bool value)
{ {
if (!itsOptionsPtr->at(id)) if (!itsOptionsPtr->at(id))
return; return;
(*itsOptionsPtr)[id]->isStatic = value; (*itsOptionsPtr)[id]->isStatic = value;
} }
template <class T> bool Menu<T>::isSelected(int id) const template <class T> bool NCurses::Menu<T>::isSelected(int id) const
{ {
id = id == -1 ? itsHighlight : id; id = id == -1 ? itsHighlight : id;
if (!itsOptionsPtr->at(id)) if (!itsOptionsPtr->at(id))
@@ -503,7 +505,7 @@ template <class T> bool Menu<T>::isSelected(int id) const
return (*itsOptionsPtr)[id]->isSelected; return (*itsOptionsPtr)[id]->isSelected;
} }
template <class T> bool Menu<T>::isStatic(int id) const template <class T> bool NCurses::Menu<T>::isStatic(int id) const
{ {
id = id == -1 ? itsHighlight : id; id = id == -1 ? itsHighlight : id;
if (!itsOptionsPtr->at(id)) if (!itsOptionsPtr->at(id))
@@ -511,7 +513,7 @@ template <class T> bool Menu<T>::isStatic(int id) const
return (*itsOptionsPtr)[id]->isStatic; return (*itsOptionsPtr)[id]->isStatic;
} }
template <class T> bool Menu<T>::hasSelected() const template <class T> bool NCurses::Menu<T>::hasSelected() const
{ {
for (option_const_iterator it = itsOptionsPtr->begin(); it != itsOptionsPtr->end(); it++) for (option_const_iterator it = itsOptionsPtr->begin(); it != itsOptionsPtr->end(); it++)
if (*it && (*it)->isSelected) if (*it && (*it)->isSelected)
@@ -519,30 +521,30 @@ template <class T> bool Menu<T>::hasSelected() const
return false; return false;
} }
template <class T> void Menu<T>::GetSelected(std::vector<size_t> &v) const template <class T> void NCurses::Menu<T>::GetSelected(std::vector<size_t> &v) const
{ {
for (size_t i = 0; i < itsOptionsPtr->size(); i++) for (size_t i = 0; i < itsOptionsPtr->size(); i++)
if ((*itsOptionsPtr)[i]->isSelected) if ((*itsOptionsPtr)[i]->isSelected)
v.push_back(i); v.push_back(i);
} }
template <class T> void Menu<T>::Highlight(size_t pos) template <class T> void NCurses::Menu<T>::Highlight(size_t pos)
{ {
itsHighlight = pos; itsHighlight = pos;
itsBeginning = pos-itsHeight/2; itsBeginning = pos-itsHeight/2;
} }
template <class T> size_t Menu<T>::Size() const template <class T> size_t NCurses::Menu<T>::Size() const
{ {
return itsOptionsPtr->size(); return itsOptionsPtr->size();
} }
template <class T> size_t Menu<T>::Choice() const template <class T> size_t NCurses::Menu<T>::Choice() const
{ {
return itsHighlight; return itsHighlight;
} }
template <class T> size_t Menu<T>::RealChoice() const template <class T> size_t NCurses::Menu<T>::RealChoice() const
{ {
size_t result = 0; size_t result = 0;
for (option_const_iterator it = itsOptionsPtr->begin(); it != itsOptionsPtr->begin()+itsHighlight; it++) for (option_const_iterator it = itsOptionsPtr->begin(); it != itsOptionsPtr->begin()+itsHighlight; it++)
@@ -551,7 +553,7 @@ template <class T> size_t Menu<T>::RealChoice() const
return result; return result;
} }
template <class T> void Menu<T>::ApplyFilter(const std::string &filter, size_t beginning, bool case_sensitive) template <class T> void NCurses::Menu<T>::ApplyFilter(const std::string &filter, size_t beginning, bool case_sensitive)
{ {
if (filter == itsFilter) if (filter == itsFilter)
return; return;
@@ -585,12 +587,12 @@ template <class T> void Menu<T>::ApplyFilter(const std::string &filter, size_t b
Window::Clear(); Window::Clear();
} }
template <class T> const std::string &Menu<T>::GetFilter() template <class T> const std::string &NCurses::Menu<T>::GetFilter()
{ {
return itsFilter; return itsFilter;
} }
template <class T> std::string Menu<T>::GetOption(size_t pos) template <class T> std::string NCurses::Menu<T>::GetOption(size_t pos)
{ {
if (itsOptionsPtr->at(pos) && itsGetStringFunction) if (itsOptionsPtr->at(pos) && itsGetStringFunction)
return itsGetStringFunction((*itsOptionsPtr)[pos]->Item, itsGetStringFunctionUserData); return itsGetStringFunction((*itsOptionsPtr)[pos]->Item, itsGetStringFunctionUserData);
@@ -598,67 +600,65 @@ template <class T> std::string Menu<T>::GetOption(size_t pos)
return ""; return "";
} }
template <> std::string Menu<std::string>::GetOption(size_t pos); template <class T> T &NCurses::Menu<T>::Back()
template <class T> T &Menu<T>::Back()
{ {
if (!itsOptionsPtr->back()) if (!itsOptionsPtr->back())
throw InvalidItem(); throw InvalidItem();
return itsOptionsPtr->back()->Item; return itsOptionsPtr->back()->Item;
} }
template <class T> const T &Menu<T>::Back() const template <class T> const T &NCurses::Menu<T>::Back() const
{ {
if (!itsOptionsPtr->back()) if (!itsOptionsPtr->back())
throw InvalidItem(); throw InvalidItem();
return itsOptionsPtr->back()->Item; return itsOptionsPtr->back()->Item;
} }
template <class T> T &Menu<T>::Current() template <class T> T &NCurses::Menu<T>::Current()
{ {
if (!itsOptionsPtr->at(itsHighlight)) if (!itsOptionsPtr->at(itsHighlight))
throw InvalidItem(); throw InvalidItem();
return (*itsOptionsPtr)[itsHighlight]->Item; return (*itsOptionsPtr)[itsHighlight]->Item;
} }
template <class T> const T &Menu<T>::Current() const template <class T> const T &NCurses::Menu<T>::Current() const
{ {
if (!itsOptionsPtr->at(itsHighlight)) if (!itsOptionsPtr->at(itsHighlight))
throw InvalidItem(); throw InvalidItem();
return (*itsOptionsPtr)[itsHighlight]->Item; return (*itsOptionsPtr)[itsHighlight]->Item;
} }
template <class T> T &Menu<T>::at(size_t i) template <class T> T &NCurses::Menu<T>::at(size_t i)
{ {
if (!itsOptionsPtr->at(i)) if (!itsOptionsPtr->at(i))
throw InvalidItem(); throw InvalidItem();
return (*itsOptionsPtr)[i]->Item; return (*itsOptionsPtr)[i]->Item;
} }
template <class T> const T &Menu<T>::at(size_t i) const template <class T> const T &NCurses::Menu<T>::at(size_t i) const
{ {
if (!itsOptions->at(i)) if (!itsOptions->at(i))
throw InvalidItem(); throw InvalidItem();
return (*itsOptionsPtr)[i]->Item; return (*itsOptionsPtr)[i]->Item;
} }
template <class T> const T &Menu<T>::operator[](size_t i) const template <class T> const T &NCurses::Menu<T>::operator[](size_t i) const
{ {
if (!(*itsOptionsPtr)[i]) if (!(*itsOptionsPtr)[i])
throw InvalidItem(); throw InvalidItem();
return (*itsOptionsPtr)[i]->Item; return (*itsOptionsPtr)[i]->Item;
} }
template <class T> T &Menu<T>::operator[](size_t i) template <class T> T &NCurses::Menu<T>::operator[](size_t i)
{ {
if (!(*itsOptionsPtr)[i]) if (!(*itsOptionsPtr)[i])
throw InvalidItem(); throw InvalidItem();
return (*itsOptionsPtr)[i]->Item; return (*itsOptionsPtr)[i]->Item;
} }
template <class T> Menu<T> *Menu<T>::EmptyClone() const template <class T> NCurses::Menu<T> *NCurses::Menu<T>::EmptyClone() const
{ {
return new Menu<T>(GetStartX(), GetStartY(), GetWidth(), GetHeight(), itsTitle, itsBaseColor, itsBorder); return new NCurses::Menu<T>(GetStartX(), GetStartY(), GetWidth(), GetHeight(), itsTitle, itsBaseColor, itsBorder);
} }
#endif #endif

40
src/misc.cpp
View File

@@ -76,52 +76,52 @@ std::string IntoStr(mpd_TagItems tag) // this is only for left column's title in
} }
} }
std::string IntoStr(Color color) std::string IntoStr(NCurses::Color color)
{ {
std::string result; std::string result;
if (color == clDefault) if (color == NCurses::clDefault)
result = "default"; result = "default";
else if (color == clBlack) else if (color == NCurses::clBlack)
result = "black"; result = "black";
else if (color == clRed) else if (color == NCurses::clRed)
result = "red"; result = "red";
else if (color == clGreen) else if (color == NCurses::clGreen)
result = "green"; result = "green";
else if (color == clYellow) else if (color == NCurses::clYellow)
result = "yellow"; result = "yellow";
else if (color == clBlue) else if (color == NCurses::clBlue)
result = "blue"; result = "blue";
else if (color == clMagenta) else if (color == NCurses::clMagenta)
result = "magenta"; result = "magenta";
else if (color == clCyan) else if (color == NCurses::clCyan)
result = "cyan"; result = "cyan";
else if (color == clWhite) else if (color == NCurses::clWhite)
result = "white"; result = "white";
return result; return result;
} }
Color IntoColor(const std::string &color) NCurses::Color IntoColor(const std::string &color)
{ {
Color result = clDefault; NCurses::Color result = NCurses::clDefault;
if (color == "black") if (color == "black")
result = clBlack; result = NCurses::clBlack;
else if (color == "red") else if (color == "red")
result = clRed; result = NCurses::clRed;
else if (color == "green") else if (color == "green")
result = clGreen; result = NCurses::clGreen;
else if (color == "yellow") else if (color == "yellow")
result = clYellow; result = NCurses::clYellow;
else if (color == "blue") else if (color == "blue")
result = clBlue; result = NCurses::clBlue;
else if (color == "magenta") else if (color == "magenta")
result = clMagenta; result = NCurses::clMagenta;
else if (color == "cyan") else if (color == "cyan")
result = clCyan; result = NCurses::clCyan;
else if (color == "white") else if (color == "white")
result = clWhite; result = NCurses::clWhite;
return result; return result;
} }

4
src/misc.h
View File

@@ -34,9 +34,9 @@ std::string IntoStr(int);
std::string IntoStr(mpd_TagItems); std::string IntoStr(mpd_TagItems);
std::string IntoStr(Color); std::string IntoStr(NCurses::Color);
Color IntoColor(const std::string &); NCurses::Color IntoColor(const std::string &);
mpd_TagItems IntoTagItem(char); mpd_TagItems IntoTagItem(char);

2
src/ncmpcpp.h
View File

@@ -33,6 +33,8 @@
vFoundPositions.clear(); \ vFoundPositions.clear(); \
} while (0) } while (0)
using namespace NCurses;
typedef std::pair<std::string, std::string> string_pair; typedef std::pair<std::string, std::string> string_pair;
const int ncmpcpp_window_timeout = 500; const int ncmpcpp_window_timeout = 500;

1
src/scrollpad.cpp
View File

@@ -20,6 +20,7 @@
#include "scrollpad.h" #include "scrollpad.h"
using namespace NCurses;
using std::string; using std::string;
Scrollpad::Scrollpad(size_t startx, Scrollpad::Scrollpad(size_t startx,

7
src/scrollpad.h
View File

@@ -24,8 +24,10 @@
#include "window.h" #include "window.h"
#include "strbuffer.h" #include "strbuffer.h"
class Scrollpad: public Window namespace NCurses
{ {
class Scrollpad: public Window
{
public: public:
Scrollpad(size_t, size_t, size_t, size_t, const std::string &, Color, Border); Scrollpad(size_t, size_t, size_t, size_t, const std::string &, Color, Border);
Scrollpad(const Scrollpad &); Scrollpad(const Scrollpad &);
@@ -66,7 +68,8 @@ class Scrollpad: public Window
int itsBeginning; int itsBeginning;
size_t itsRealHeight; size_t itsRealHeight;
}; };
}
#endif #endif

41
src/strbuffer.h
View File

@@ -26,8 +26,10 @@
#include <sstream> #include <sstream>
#include <list> #include <list>
template <class C> class basic_buffer namespace NCurses
{ {
template <class C> class basic_buffer
{
struct FormatPos struct FormatPos
{ {
size_t Position; size_t Position;
@@ -63,17 +65,18 @@ template <class C> class basic_buffer
basic_buffer<C> &operator<<(const basic_buffer<C> &buf); basic_buffer<C> &operator<<(const basic_buffer<C> &buf);
friend Window &operator<< <>(Window &, const basic_buffer<C> &); friend Window &operator<< <>(Window &, const basic_buffer<C> &);
}; };
typedef basic_buffer<char> Buffer; typedef basic_buffer<char> Buffer;
typedef basic_buffer<wchar_t> WBuffer; typedef basic_buffer<wchar_t> WBuffer;
}
template <class C> std::basic_string<C> basic_buffer<C>::Str() const template <class C> std::basic_string<C> NCurses::basic_buffer<C>::Str() const
{ {
return itsString.str(); return itsString.str();
} }
template <class C> void basic_buffer<C>::SetFormatting(short vb, const std::basic_string<C> &s, short ve, bool for_each) template <class C> void NCurses::basic_buffer<C>::SetFormatting(short vb, const std::basic_string<C> &s, short ve, bool for_each)
{ {
std::basic_string<C> base = itsString.str(); std::basic_string<C> base = itsString.str();
FormatPos fp; FormatPos fp;
@@ -92,24 +95,24 @@ template <class C> void basic_buffer<C>::SetFormatting(short vb, const std::basi
} }
} }
template <class C> void basic_buffer<C>::SetTemp(std::basic_string<C> *tmp) template <class C> void NCurses::basic_buffer<C>::SetTemp(std::basic_string<C> *tmp)
{ {
itsTempString = tmp; itsTempString = tmp;
} }
template <class C> void basic_buffer<C>::Clear() template <class C> void NCurses::basic_buffer<C>::Clear()
{ {
itsString.str(std::basic_string<C>()); itsString.str(std::basic_string<C>());
itsFormat.clear(); itsFormat.clear();
} }
template <class C> basic_buffer<C> &basic_buffer<C>::operator<<(std::ostream &(*os)(std::ostream&)) template <class C> NCurses::basic_buffer<C> &NCurses::basic_buffer<C>::operator<<(std::ostream &(*os)(std::ostream&))
{ {
itsString << os; itsString << os;
return *this; return *this;
} }
template <class C> basic_buffer<C> &basic_buffer<C>::operator<<(const Color &color) template <class C> NCurses::basic_buffer<C> &NCurses::basic_buffer<C>::operator<<(const Color &color)
{ {
FormatPos f; FormatPos f;
f.Position = itsString.str().length(); f.Position = itsString.str().length();
@@ -118,24 +121,24 @@ template <class C> basic_buffer<C> &basic_buffer<C>::operator<<(const Color &col
return *this; return *this;
} }
template <class C> basic_buffer<C> &basic_buffer<C>::operator<<(const Format &f) template <class C> NCurses::basic_buffer<C> &NCurses::basic_buffer<C>::operator<<(const Format &f)
{ {
return operator<<(Color(f)); return operator<<(Color(f));
} }
template <class C> basic_buffer<C> &basic_buffer<C>::operator<<(const basic_buffer<C> &buf) template <class C> NCurses::basic_buffer<C> &NCurses::basic_buffer<C>::operator<<(const NCurses::basic_buffer<C> &buf)
{ {
size_t len = itsString.str().length(); size_t len = itsString.str().length();
itsString << buf.itsString.str(); itsString << buf.itsString.str();
std::list<FormatPos> tmp = buf.itsFormat; std::list<FormatPos> tmp = buf.itsFormat;
if (len) if (len)
for (typename std::list<typename basic_buffer<C>::FormatPos>::iterator it = tmp.begin(); it != tmp.end(); it++) for (typename std::list<typename NCurses::basic_buffer<C>::FormatPos>::iterator it = tmp.begin(); it != tmp.end(); it++)
it->Position += len; it->Position += len;
itsFormat.merge(tmp); itsFormat.merge(tmp);
return *this; return *this;
} }
template <class C> Window &operator<<(Window &w, const basic_buffer<C> &buf) template <class C> NCurses::Window &operator<<(NCurses::Window &w, const NCurses::basic_buffer<C> &buf)
{ {
const std::basic_string<C> &s = buf.itsTempString ? *buf.itsTempString : buf.itsString.str(); const std::basic_string<C> &s = buf.itsTempString ? *buf.itsTempString : buf.itsString.str();
if (buf.itsFormat.empty()) if (buf.itsFormat.empty())
@@ -145,8 +148,8 @@ template <class C> Window &operator<<(Window &w, const basic_buffer<C> &buf)
else else
{ {
std::basic_string<C> tmp; std::basic_string<C> tmp;
typename std::list<typename basic_buffer<C>::FormatPos>::const_iterator b = buf.itsFormat.begin(); typename std::list<typename NCurses::basic_buffer<C>::FormatPos>::const_iterator b = buf.itsFormat.begin();
typename std::list<typename basic_buffer<C>::FormatPos>::const_iterator e = buf.itsFormat.end(); typename std::list<typename NCurses::basic_buffer<C>::FormatPos>::const_iterator e = buf.itsFormat.end();
for (size_t i = 0; i < s.length() || b != e; i++) for (size_t i = 0; i < s.length() || b != e; i++)
{ {
while (b != e && i == b->Position) while (b != e && i == b->Position)
@@ -156,10 +159,10 @@ template <class C> Window &operator<<(Window &w, const basic_buffer<C> &buf)
w << tmp; w << tmp;
tmp.clear(); tmp.clear();
} }
if (b->Value < fmtNone) if (b->Value < NCurses::fmtNone)
w << Color(b->Value); w << NCurses::Color(b->Value);
else else
w << Format(b->Value); w << NCurses::Format(b->Value);
b++; b++;
} }
if (i < s.length()) if (i < s.length())

6
src/window.cpp
View File

@@ -23,10 +23,12 @@
#include "window.h" #include "window.h"
using namespace NCurses;
using std::string; using std::string;
using std::wstring; using std::wstring;
void InitScreen(bool enable_colors) void NCurses::InitScreen(bool enable_colors)
{ {
setlocale(LC_ALL, ""); setlocale(LC_ALL, "");
initscr(); initscr();
@@ -44,7 +46,7 @@ void InitScreen(bool enable_colors)
curs_set(0); curs_set(0);
} }
void DestroyScreen() void NCurses::DestroyScreen()
{ {
curs_set(1); curs_set(1);
endwin(); endwin();

55
src/window.h
View File

@@ -41,37 +41,39 @@
# define TO_WSTRING(x) x # define TO_WSTRING(x) x
#endif #endif
enum Color { clDefault, clBlack, clRed, clGreen, clYellow, clBlue, clMagenta, clCyan, clWhite, clEnd };
enum Format { fmtNone = 100, fmtBold, fmtBoldEnd, fmtReverse, fmtReverseEnd, fmtAltCharset, fmtAltCharsetEnd };
enum Border { brNone, brBlack, brRed, brGreen, brYellow, brBlue, brMagenta, brCyan, brWhite };
enum Where { wUp, wDown, wPageUp, wPageDown, wHome, wEnd };
typedef void (*GetStringHelper)(const std::wstring &);
void InitScreen(bool);
void DestroyScreen();
struct Colors
{
Colors(Color one, Color two = clDefault) : fg(one), bg(two) { }
Color fg;
Color bg;
};
struct XY
{
XY(int xx, int yy) : x(xx), y(yy) { }
int x;
int y;
};
char *ToString(const wchar_t *); char *ToString(const wchar_t *);
wchar_t *ToWString(const char *); wchar_t *ToWString(const char *);
std::string ToString(const std::wstring &); std::string ToString(const std::wstring &);
std::wstring ToWString(const std::string &); std::wstring ToWString(const std::string &);
class Window namespace NCurses
{ {
enum Color { clDefault, clBlack, clRed, clGreen, clYellow, clBlue, clMagenta, clCyan, clWhite, clEnd };
enum Format { fmtNone = 100, fmtBold, fmtBoldEnd, fmtReverse, fmtReverseEnd, fmtAltCharset, fmtAltCharsetEnd };
enum Border { brNone, brBlack, brRed, brGreen, brYellow, brBlue, brMagenta, brCyan, brWhite };
enum Where { wUp, wDown, wPageUp, wPageDown, wHome, wEnd };
typedef void (*GetStringHelper)(const std::wstring &);
void InitScreen(bool);
void DestroyScreen();
struct Colors
{
Colors(Color one, Color two = clDefault) : fg(one), bg(two) { }
Color fg;
Color bg;
};
struct XY
{
XY(int xx, int yy) : x(xx), y(yy) { }
int x;
int y;
};
class Window
{
public: public:
Window(size_t, size_t, size_t, size_t, const std::string &, Color, Border); Window(size_t, size_t, size_t, size_t, const std::string &, Color, Border);
Window(const Window &); Window(const Window &);
@@ -175,6 +177,7 @@ class Window
Color itsBaseBgColor; Color itsBaseBgColor;
Border itsBorder; Border itsBorder;
}; };
}
#endif #endif