src/window.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2008-2009 by Andrzej Rybczak                            *
   3  *   electricityispower@gmail.com                                          *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.              *
  19  ***************************************************************************/
  20
  21 #include <cstring>
  22 #include <cstdlib>
  23
  24 #ifdef WIN32
  25 # include <winsock.h>
  26 #else
  27 # include <sys/select.h>
  28 #endif
  29
  30 #include "error.h"
  31 #include "window.h"
  32
  33 using namespace NCurses;
  34
  35 void NCurses::InitScreen(GNUC_UNUSED const char *window_title, bool enable_colors)
  36 {
  37         const int ColorsTable[] =
  38         {
  39                 COLOR_BLACK, COLOR_RED, COLOR_GREEN, COLOR_YELLOW,
  40                 COLOR_BLUE, COLOR_MAGENTA, COLOR_CYAN, COLOR_WHITE
  41         };
  42 #       ifdef XCURSES
  43         Xinitscr(1, const_cast<char **>(&window_title));
  44 #       else
  45         initscr();
  46 #       endif // XCURSES
  47         if (has_colors() && enable_colors)
  48         {
  49                 start_color();
  50                 use_default_colors();
  51                 int num = 1;
  52 #               ifdef USE_PDCURSES
  53                 int i = 0;
  54 #               else
  55                 int i = -1;
  56 #               endif // USE_PDCURSES
  57                 for (; i < 8; ++i)
  58                         for (int j = 0; j < 8; ++j)
  59                                 init_pair(num++, ColorsTable[j], i < 0 ? i : ColorsTable[i]);
  60         }
  61         noecho();
  62         cbreak();
  63         curs_set(0);
  64 }
  65
  66 void NCurses::DestroyScreen()
  67 {
  68         curs_set(1);
  69         endwin();
  70 }
  71
  72 Window::Window(size_t startx,
  73                 size_t starty,
  74                 size_t width,
  75                 size_t height,
  76                 const std::string &title,
  77                 Color color,
  78                 Border border)
  79                 : itsWindow(0),
  80                 itsWinBorder(0),
  81                 itsStartX(startx),
  82                 itsStartY(starty),
  83                 itsWidth(width),
  84                 itsHeight(height),
  85                 itsWindowTimeout(-1),
  86                 itsColor(color),
  87                 itsBgColor(clDefault),
  88                 itsBaseColor(color),
  89                 itsBaseBgColor(clDefault),
  90                 itsBorder(border),
  91                 itsGetStringHelper(0),
  92                 itsX(0),
  93                 itsY(0),
  94                 itsTitle(title),
  95                 itsHistory(0),
  96                 itsBoldCounter(0),
  97                 itsUnderlineCounter(0),
  98                 itsReverseCounter(0),
  99                 itsAltCharsetCounter(0)
 100 {
 101         if (itsStartX > size_t(COLS)
 102         ||  itsStartY > size_t(LINES)
 103         ||  itsWidth+itsStartX > size_t(COLS)
 104         ||  itsHeight+itsStartY > size_t(LINES))
 105                 FatalError("Constructed window is bigger than terminal size!");
 106
 107         if (itsBorder != brNone)
 108         {
 109                 itsWinBorder = newpad(itsHeight, itsWidth);
 110                 wattron(itsWinBorder, COLOR_PAIR(itsBorder));
 111                 box(itsWinBorder, 0, 0);
 112                 itsStartX++;
 113                 itsStartY++;
 114                 itsWidth -= 2;
 115                 itsHeight -= 2;
 116         }
 117         if (!itsTitle.empty())
 118         {
 119                 itsStartY += 2;
 120                 itsHeight -= 2;
 121         }
 122
 123         itsWindow = newpad(itsHeight, itsWidth);
 124
 125         SetColor(itsColor);
 126         keypad(itsWindow, 1);
 127 }
 128
 129 Window::Window(const Window &w) : itsWindow(dupwin(w.itsWindow)),
 130                                 itsWinBorder(dupwin(w.itsWinBorder)),
 131                                 itsStartX(w.itsStartX),
 132                                 itsStartY(w.itsStartY),
 133                                 itsWidth(w.itsWidth),
 134                                 itsHeight(w.itsHeight),
 135                                 itsWindowTimeout(w.itsWindowTimeout),
 136                                 itsColor(w.itsColor),
 137                                 itsBgColor(w.itsBgColor),
 138                                 itsBaseColor(w.itsBaseColor),
 139                                 itsBaseBgColor(w.itsBaseBgColor),
 140                                 itsBorder(w.itsBorder),
 141                                 itsGetStringHelper(w.itsGetStringHelper),
 142                                 itsX(w.itsX),
 143                                 itsY(w.itsY),
 144                                 itsTitle(w.itsTitle),
 145                                 itsColors(w.itsColors),
 146                                 itsHistory(w.itsHistory),
 147                                 itsBoldCounter(w.itsBoldCounter),
 148                                 itsUnderlineCounter(w.itsUnderlineCounter),
 149                                 itsReverseCounter(w.itsReverseCounter),
 150                                 itsAltCharsetCounter(w.itsAltCharsetCounter)
 151 {
 152 }
 153
 154 Window::~Window()
 155 {
 156         delwin(itsWindow);
 157         delwin(itsWinBorder);
 158         delete itsHistory;
 159 }
 160
 161 void Window::SetColor(Color fg, Color bg)
 162 {
 163         if (fg == clDefault)
 164                 fg = itsBaseColor;
 165
 166         if (fg != clDefault)
 167                 wattron(itsWindow, COLOR_PAIR(bg*8+fg));
 168         else
 169                 wattroff(itsWindow, COLOR_PAIR(itsColor));
 170         itsColor = fg;
 171         itsBgColor = bg;
 172 }
 173
 174 void Window::SetBaseColor(Color fg, Color bg)
 175 {
 176         itsBaseColor = fg;
 177         itsBaseBgColor = bg;
 178 }
 179
 180 void Window::SetBorder(Border border)
 181 {
 182         if (border == brNone && itsBorder != brNone)
 183         {
 184                 delwin(itsWinBorder);
 185                 itsStartX--;
 186                 itsStartY--;
 187                 itsHeight += 2;
 188                 itsWidth += 2;
 189                 Recreate(itsWidth, itsHeight);
 190         }
 191         else if (border != brNone && itsBorder == brNone)
 192         {
 193                 itsWinBorder = newpad(itsHeight, itsWidth);
 194                 wattron(itsWinBorder, COLOR_PAIR(border));
 195                 box(itsWinBorder,0,0);
 196                 itsStartX++;
 197                 itsStartY++;
 198                 itsHeight -= 2;
 199                 itsWidth -= 2;
 200                 Recreate(itsWidth, itsHeight);
 201         }
 202         else
 203         {
 204                 wattron(itsWinBorder,COLOR_PAIR(border));
 205                 box(itsWinBorder, 0, 0);
 206         }
 207         itsBorder = border;
 208 }
 209
 210 void Window::SetTitle(const std::string &new_title)
 211 {
 212         if (itsTitle == new_title)
 213         {
 214                 return;
 215         }
 216         else if (!new_title.empty() && itsTitle.empty())
 217         {
 218                 itsStartY += 2;
 219                 itsHeight -= 2;
 220                 Recreate(itsWidth, itsHeight);
 221         }
 222         else if (new_title.empty() && !itsTitle.empty())
 223         {
 224                 itsStartY -= 2;
 225                 itsHeight += 2;
 226                 Recreate(itsWidth, itsHeight);
 227         }
 228         itsTitle = new_title;
 229 }
 230
 231 void Window::CreateHistory()
 232 {
 233         if (!itsHistory)
 234                 itsHistory = new std::deque<std::wstring>;
 235 }
 236
 237 void Window::DeleteHistory()
 238 {
 239         delete itsHistory;
 240         itsHistory = 0;
 241 }
 242
 243 void Window::Recreate(size_t width, size_t height)
 244 {
 245         delwin(itsWindow);
 246         itsWindow = newpad(height, width);
 247         SetTimeout(itsWindowTimeout);
 248         SetColor(itsColor, itsBgColor);
 249         keypad(itsWindow, 1);
 250 }
 251
 252 void Window::MoveTo(size_t new_x, size_t new_y)
 253 {
 254         itsStartX = new_x;
 255         itsStartY = new_y;
 256         if (itsBorder != brNone)
 257         {
 258                 itsStartX++;
 259                 itsStartY++;
 260         }
 261         if (!itsTitle.empty())
 262                 itsStartY += 2;
 263 }
 264
 265 void Window::AdjustDimensions(size_t width, size_t height)
 266 {
 267         if (itsBorder != brNone)
 268         {
 269                 delwin(itsWinBorder);
 270                 itsWinBorder = newpad(height, width);
 271                 wattron(itsWinBorder, COLOR_PAIR(itsBorder));
 272                 box(itsWinBorder, 0, 0);
 273                 width -= 2;
 274                 height -= 2;
 275         }
 276         if (!itsTitle.empty())
 277                 height -= 2;
 278         itsHeight = height;
 279         itsWidth = width;
 280 }
 281
 282 void Window::Resize(size_t new_width, size_t new_height)
 283 {
 284         AdjustDimensions(new_width, new_height);
 285         Recreate(itsWidth, itsHeight);
 286 }
 287
 288 void Window::ShowBorder() const
 289 {
 290         if (itsBorder != brNone)
 291         {
 292                 refresh();
 293                 prefresh(itsWinBorder, 0, 0, GetStartY(), GetStartX(), itsStartY+itsHeight, itsStartX+itsWidth);
 294         }
 295         if (!itsTitle.empty())
 296         {
 297                 if (itsBorder != brNone)
 298                         attron(COLOR_PAIR(itsBorder));
 299                 else
 300                         attron(COLOR_PAIR(itsBaseColor));
 301                 mvhline(itsStartY-1, itsStartX, 0, itsWidth);
 302                 attron(A_BOLD);
 303                 mvhline(itsStartY-2, itsStartX, 32, itsWidth); // clear title line
 304                 mvaddstr(itsStartY-2, itsStartX, itsTitle.c_str());
 305                 attroff(COLOR_PAIR(itsBorder) | A_BOLD);
 306         }
 307         refresh();
 308 }
 309
 310 void Window::Display()
 311 {
 312         ShowBorder();
 313         Refresh();
 314 }
 315
 316 void Window::Refresh()
 317 {
 318         prefresh(itsWindow, 0, 0, itsStartY, itsStartX, itsStartY+itsHeight-1, itsStartX+itsWidth-1);
 319 }
 320
 321 void Window::Clear(bool refresh)
 322 {
 323         werase(itsWindow);
 324         if (refresh)
 325                 Window::Refresh();
 326 }
 327
 328 void Window::Hide(char ch) const
 329 {
 330         for (size_t i = 0; i < GetHeight(); ++i)
 331                 mvhline(i+GetStartY(), GetStartX(), ch, GetWidth());
 332         refresh();
 333 }
 334
 335 void Window::Bold(bool bold_state) const
 336 {
 337         (bold_state ? wattron : wattroff)(itsWindow, A_BOLD);
 338 }
 339
 340 void Window::Underline(bool underline_state) const
 341 {
 342         (underline_state ? wattron : wattroff)(itsWindow, A_UNDERLINE);
 343 }
 344
 345 void Window::Reverse(bool reverse_state) const
 346 {
 347         (reverse_state ? wattron : wattroff)(itsWindow, A_REVERSE);
 348 }
 349
 350 void Window::AltCharset(bool altcharset_state) const
 351 {
 352         (altcharset_state ? wattron : wattroff)(itsWindow, A_ALTCHARSET);
 353 }
 354
 355 void Window::SetTimeout(int timeout)
 356 {
 357         itsWindowTimeout = timeout;
 358         wtimeout(itsWindow, timeout);
 359 }
 360
 361 void Window::AddFDCallback(int fd, void (*callback)())
 362 {
 363         itsFDs.push_back(std::make_pair(fd, callback));
 364 }
 365
 366 void Window::ClearFDCallbacksList()
 367 {
 368         itsFDs.clear();
 369 }
 370
 371 bool Window::FDCallbacksListEmpty() const
 372 {
 373         return itsFDs.empty();
 374 }
 375
 376 void Window::ReadKey(int &read_key) const
 377 {
 378         // in pdcurses polling stdin doesn't work, so we can't poll
 379         // both stdin and other file descriptors in one select. the
 380         // workaround is to set the timeout of select to 0, poll
 381         // other file descriptors and then wait for stdin input with
 382         // the given timeout. unfortunately, this results in delays
 383         // since ncmpcpp doesn't see that data arrived while waiting
 384         // for input from stdin, but it seems there is no better option.
 385
 386         fd_set fdset;
 387         FD_ZERO(&fdset);
 388 #       if !defined(USE_PDCURSES)
 389         FD_SET(STDIN_FILENO, &fdset);
 390         timeval timeout = { itsWindowTimeout/1000, (itsWindowTimeout%1000)*1000 };
 391 #       else
 392         timeval timeout = { 0, 0 };
 393 #       endif
 394
 395         int fd_max = STDIN_FILENO;
 396         for (FDCallbacks::const_iterator it = itsFDs.begin(); it != itsFDs.end(); ++it)
 397         {
 398                 if (it->first > fd_max)
 399                         fd_max = it->first;
 400                 FD_SET(it->first, &fdset);
 401         }
 402
 403         if (select(fd_max+1, &fdset, 0, 0, &timeout) > 0)
 404         {
 405 #               if !defined(USE_PDCURSES)
 406                 read_key = FD_ISSET(STDIN_FILENO, &fdset) ? wgetch(itsWindow) : ERR;
 407 #               endif // !USE_PDCURSES
 408                 for (FDCallbacks::const_iterator it = itsFDs.begin(); it != itsFDs.end(); ++it)
 409                         if (FD_ISSET(it->first, &fdset))
 410                                 it->second();
 411         }
 412 #       if !defined(USE_PDCURSES)
 413         else
 414                 read_key = ERR;
 415 #       else
 416         read_key = wgetch(itsWindow);
 417 #       endif
 418 }
 419
 420 void Window::ReadKey() const
 421 {
 422         wgetch(itsWindow);
 423 }
 424
 425 std::string Window::GetString(const std::string &base, size_t length, size_t width, bool encrypted) const
 426 {
 427         int input;
 428         size_t beginning, maxbeginning, minx, x, real_x, y, maxx, real_maxx;
 429
 430         getyx(itsWindow, y, x);
 431         minx = real_maxx = maxx = real_x = x;
 432
 433         width--;
 434         if (width == size_t(-1))
 435                 width = itsWidth-x-1;
 436
 437         curs_set(1);
 438
 439         std::wstring wbase = ToWString(base);
 440         std::wstring *tmp = &wbase;
 441         size_t history_offset = itsHistory && !encrypted ? itsHistory->size() : -1;
 442
 443         std::string tmp_in;
 444         wchar_t wc_in;
 445         bool gotoend = 1;
 446         bool block_scrolling = 0;
 447
 448         // disable scrolling if wide chars are used
 449         for (std::wstring::const_iterator it = tmp->begin(); it != tmp->end(); ++it)
 450                 if (wcwidth(*it) > 1)
 451                         block_scrolling = 1;
 452
 453         beginning = -1;
 454
 455         do
 456         {
 457                 if (tmp->empty())
 458                         block_scrolling = 0;
 459
 460                 maxbeginning = block_scrolling ? 0 : (tmp->length() < width ? 0 : tmp->length()-width);
 461                 maxx = minx + (Length(*tmp) < width ? Length(*tmp) : width);
 462
 463                 real_maxx = minx + (tmp->length() < width ? tmp->length() : width);
 464
 465                 if (beginning > maxbeginning)
 466                         beginning = maxbeginning;
 467
 468                 if (gotoend)
 469                 {
 470                         size_t real_real_maxx = minx;
 471                         size_t biggest_x = minx+width;
 472
 473                         if (block_scrolling && maxx >= biggest_x)
 474                         {
 475                                 size_t i = 0;
 476                                 for (std::wstring::const_iterator it = tmp->begin(); i < width; ++it, ++real_real_maxx)
 477                                         i += wcwidth(*it);
 478                         }
 479                         else
 480                                 real_real_maxx = real_maxx;
 481
 482                         real_x = real_real_maxx;
 483                         x = block_scrolling ? (maxx > biggest_x ? biggest_x : maxx) : maxx;
 484                         beginning = maxbeginning;
 485                         gotoend = 0;
 486                 }
 487
 488                 mvwhline(itsWindow, y, minx, 32, width+1);
 489
 490                 if (!encrypted)
 491                         mvwprintw(itsWindow, y, minx, "%ls", tmp->substr(beginning, width+1).c_str());
 492                 else
 493                         mvwhline(itsWindow, y, minx, '*', maxx-minx);
 494
 495                 if (itsGetStringHelper)
 496                         itsGetStringHelper(*tmp);
 497
 498                 wmove(itsWindow, y, x);
 499                 prefresh(itsWindow, 0, 0, itsStartY, itsStartX, itsStartY+itsHeight-1, itsStartX+itsWidth-1);
 500                 ReadKey(input);
 501
 502                 // these key codes are special and should be ignored
 503                 if ((input < 10 || (input > 10 && input != 21 && input < 32))
 504 #               ifdef USE_PDCURSES
 505                 &&   input != KEY_BACKSPACE)
 506 #               else
 507                 )
 508 #               endif // USE_PDCURSES
 509                         continue;
 510
 511                 switch (input)
 512                 {
 513                         case ERR:
 514                         case KEY_MOUSE:
 515                                 break;
 516                         case KEY_UP:
 517                                 if (itsHistory && !encrypted && history_offset > 0)
 518                                 {
 519                                         do
 520                                                 tmp = &(*itsHistory)[--history_offset];
 521                                         while (tmp->empty() && history_offset);
 522                                         gotoend = 1;
 523                                 }
 524                                 break;
 525                         case KEY_DOWN:
 526                                 if (itsHistory && !encrypted && itsHistory->size() > 0)
 527                                 {
 528                                         if (history_offset < itsHistory->size()-1)
 529                                         {
 530                                                 do
 531                                                         tmp = &(*itsHistory)[++history_offset];
 532                                                 while (tmp->empty() && history_offset < itsHistory->size()-1);
 533                                         }
 534                                         else if (history_offset == itsHistory->size()-1)
 535                                         {
 536                                                 tmp = &wbase;
 537                                                 history_offset++;
 538                                         }
 539                                         gotoend = 1;
 540                                 }
 541                                 break;
 542                         case KEY_RIGHT:
 543                         {
 544                                 if (x < maxx)
 545                                 {
 546                                         real_x++;
 547                                         x += wcwidth((*tmp)[beginning+real_x-minx-1]);
 548                                 }
 549                                 else if (beginning < maxbeginning)
 550                                         beginning++;
 551                                 break;
 552                         }
 553                         case KEY_BACKSPACE: case 127:
 554                         {
 555                                 if (x <= minx && !beginning)
 556                                         break;
 557                         }
 558                         case KEY_LEFT:
 559                         {
 560                                 if (x > minx)
 561                                 {
 562                                         real_x--;
 563                                         x -= wcwidth((*tmp)[beginning+real_x-minx]);
 564                                 }
 565                                 else if (beginning > 0)
 566                                         beginning--;
 567                                 if (input != KEY_BACKSPACE && input != 127)
 568                                         break; // backspace = left & delete.
 569                         }
 570                         case KEY_DC:
 571                         {
 572                                 if ((real_x-minx)+beginning == tmp->length())
 573                                         break;
 574                                 tmp->erase(tmp->begin()+(real_x-minx)+beginning);
 575                                 if (beginning && beginning == maxbeginning && real_x < maxx)
 576                                 {
 577                                         real_x++;
 578                                         x++;
 579                                 }
 580                                 break;
 581                         }
 582                         case KEY_HOME:
 583                         {
 584                                 real_x = x = minx;
 585                                 beginning = 0;
 586                                 break;
 587                         }
 588                         case KEY_END:
 589                         {
 590                                 gotoend = 1;
 591                                 break;
 592                         }
 593                         case 10:
 594                                 break;
 595                         case 21: // CTRL+U
 596                                 tmp->clear();
 597                                 real_maxx = maxx = real_x = x = minx;
 598                                 maxbeginning = beginning = 0;
 599                                 break;
 600                         default:
 601                         {
 602                                 if (tmp->length() >= length)
 603                                         break;
 604
 605                                 tmp_in += input;
 606                                 if (int(mbrtowc(&wc_in, tmp_in.c_str(), MB_CUR_MAX, 0)) < 0)
 607                                         break;
 608
 609                                 if (wcwidth(wc_in) > 1)
 610                                         block_scrolling = 1;
 611
 612                                 if ((real_x-minx)+beginning >= tmp->length())
 613                                 {
 614                                         tmp->push_back(wc_in);
 615                                         if (!beginning)
 616                                         {
 617                                                 real_x++;
 618                                                 x += wcwidth(wc_in);
 619                                         }
 620                                         beginning++;
 621                                         gotoend = 1;
 622                                 }
 623                                 else
 624                                 {
 625                                         tmp->insert(tmp->begin()+(real_x-minx)+beginning, wc_in);
 626                                         if (x < maxx)
 627                                         {
 628                                                 real_x++;
 629                                                 x += wcwidth(wc_in);
 630                                         }
 631                                         else if (beginning < maxbeginning)
 632                                                 beginning++;
 633                                 }
 634                                 tmp_in.clear();
 635                         }
 636                 }
 637         }
 638         while (input != 10);
 639         curs_set(0);
 640
 641         if (itsHistory && !encrypted)
 642         {
 643                 size_t old_size = itsHistory->size();
 644                 if (!tmp->empty() && (itsHistory->empty() || itsHistory->back() != *tmp))
 645                         itsHistory->push_back(*tmp);
 646                 if (old_size > 1 && history_offset < old_size)
 647                 {
 648                         std::deque<std::wstring>::iterator it = itsHistory->begin()+history_offset;
 649                         wbase = *it;
 650                         tmp = &wbase;
 651                         itsHistory->erase(it);
 652                 }
 653         }
 654
 655         return ToString(*tmp);
 656 }
 657
 658 void Window::GetXY(int &x, int &y)
 659 {
 660         getyx(itsWindow, y, x);
 661         itsX = x;
 662         itsY = y;
 663 }
 664
 665 void Window::GotoXY(int x, int y)
 666 {
 667         wmove(itsWindow, y, x);
 668         itsX = x;
 669         itsY = y;
 670 }
 671
 672  int Window::X() const
 673 {
 674         return itsX;
 675 }
 676
 677 int Window::Y() const
 678 {
 679         return itsY;
 680 }
 681
 682 bool Window::hasCoords(int &x, int &y)
 683 {
 684 #       ifndef USE_PDCURSES
 685         return wmouse_trafo(itsWindow, &y, &x, 0);
 686 #       else
 687         // wmouse_trafo is broken in pdcurses, use our own implementation
 688         size_t u_x = x, u_y = y;
 689         if (u_x >= itsStartX && u_x < itsStartX+itsWidth
 690         &&  u_y >= itsStartY && u_y < itsStartY+itsHeight)
 691         {
 692                 x -= itsStartX;
 693                 y -= itsStartY;
 694                 return true;
 695         }
 696         return false;
 697 #       endif
 698 }
 699
 700 size_t Window::GetWidth() const
 701 {
 702         if (itsBorder != brNone)
 703                 return itsWidth+2;
 704         else
 705                 return itsWidth;
 706 }
 707
 708 size_t Window::GetHeight() const
 709 {
 710         size_t height = itsHeight;
 711         if (itsBorder != brNone)
 712                 height += 2;
 713         if (!itsTitle.empty())
 714                 height += 2;
 715         return height;
 716 }
 717
 718 size_t Window::GetStartX() const
 719 {
 720         if (itsBorder != brNone)
 721                 return itsStartX-1;
 722         else
 723                 return itsStartX;
 724 }
 725
 726 size_t Window::GetStartY() const
 727 {
 728         size_t starty = itsStartY;
 729         if (itsBorder != brNone)
 730                 starty--;
 731         if (!itsTitle.empty())
 732                 starty -= 2;
 733         return starty;
 734 }
 735
 736 const std::string &Window::GetTitle() const
 737 {
 738         return itsTitle;
 739 }
 740
 741 Color Window::GetColor() const
 742 {
 743         return itsColor;
 744 }
 745
 746 Border Window::GetBorder() const
 747 {
 748         return itsBorder;
 749 }
 750
 751 void Window::Scroll(Where where)
 752 {
 753         idlok(itsWindow, 1);
 754         scrollok(itsWindow, 1);
 755         switch (where)
 756         {
 757                 case wUp:
 758                         wscrl(itsWindow, 1);
 759                         break;
 760                 case wDown:
 761                         wscrl(itsWindow, -1);
 762                         break;
 763                 case wPageUp:
 764                         wscrl(itsWindow, itsWidth);
 765                         break;
 766                 case wPageDown:
 767                         wscrl(itsWindow, -itsWidth);
 768                         break;
 769                 default:
 770                         break;
 771         }
 772         idlok(itsWindow, 0);
 773         scrollok(itsWindow, 0);
 774 }
 775
 776
 777 Window &Window::operator<<(Colors colors)
 778 {
 779         if (colors.fg == clEnd || colors.bg == clEnd)
 780         {
 781                 *this << clEnd;
 782                 return *this;
 783         }
 784         itsColors.push(colors);
 785         SetColor(colors.fg, colors.bg);
 786         return *this;
 787 }
 788
 789 Window &Window::operator<<(Color color)
 790 {
 791         switch (color)
 792         {
 793                 case clDefault:
 794                         while (!itsColors.empty())
 795                                 itsColors.pop();
 796                         SetColor(itsBaseColor, itsBaseBgColor);
 797                         break;
 798                 case clEnd:
 799                         if (!itsColors.empty())
 800                                 itsColors.pop();
 801                         if (!itsColors.empty())
 802                                 SetColor(itsColors.top().fg, itsColors.top().bg);
 803                         else
 804                                 SetColor(itsBaseColor, itsBaseBgColor);
 805                         break;
 806                 default:
 807                         itsColors.push(Colors(color, clDefault));
 808                         SetColor(itsColors.top().fg, itsColors.top().bg);
 809         }
 810         return *this;
 811 }
 812
 813 Window &Window::operator<<(Format format)
 814 {
 815         switch (format)
 816         {
 817                 case fmtNone:
 818                         Bold((itsBoldCounter = 0));
 819                         Reverse((itsReverseCounter = 0));
 820                         AltCharset((itsAltCharsetCounter = 0));
 821                         break;
 822                 case fmtBold:
 823                         Bold(++itsBoldCounter);
 824                         break;
 825                 case fmtBoldEnd:
 826                         if (--itsBoldCounter <= 0)
 827                                 Bold((itsBoldCounter = 0));
 828                         break;
 829                 case fmtUnderline:
 830                         Underline(++itsUnderlineCounter);
 831                         break;
 832                 case fmtUnderlineEnd:
 833                         if (--itsUnderlineCounter <= 0)
 834                                 Underline((itsUnderlineCounter = 0));
 835                         break;
 836                 case fmtReverse:
 837                         Reverse(++itsReverseCounter);
 838                         break;
 839                 case fmtReverseEnd:
 840                         if (--itsReverseCounter <= 0)
 841                                 Reverse((itsReverseCounter = 0));
 842                         break;
 843                 case fmtAltCharset:
 844                         AltCharset(++itsAltCharsetCounter);
 845                         break;
 846                 case fmtAltCharsetEnd:
 847                         if (--itsAltCharsetCounter <= 0)
 848                                 AltCharset((itsAltCharsetCounter = 0));
 849                         break;
 850         }
 851         return *this;
 852 }
 853
 854 Window &Window::operator<<(int (*f)(WINDOW *))
 855 {
 856         f(itsWindow);
 857         return *this;
 858 }
 859
 860 Window &Window::operator<<(XY coords)
 861 {
 862         GotoXY(coords.x, coords.y);
 863         return *this;
 864 }
 865
 866 Window &Window::operator<<(const char *s)
 867 {
 868         wprintw(itsWindow, "%s", s);
 869         return *this;
 870 }
 871
 872 Window &Window::operator<<(char c)
 873 {
 874         wprintw(itsWindow, "%c", c);
 875         return *this;
 876 }
 877
 878 Window &Window::operator<<(const wchar_t *ws)
 879 {
 880         wprintw(itsWindow, "%ls", ws);
 881         return *this;
 882 }
 883
 884 Window &Window::operator<<(wchar_t wc)
 885 {
 886         wprintw(itsWindow, "%lc", wc);
 887         return *this;
 888 }
 889
 890 Window &Window::operator<<(int i)
 891 {
 892         wprintw(itsWindow, "%d", i);
 893         return *this;
 894 }
 895
 896 Window &Window::operator<<(double d)
 897 {
 898         wprintw(itsWindow, "%f", d);
 899         return *this;
 900 }
 901
 902 Window &Window::operator<<(const std::string &s)
 903 {
 904         for (std::string::const_iterator it = s.begin(); it != s.end(); ++it)
 905                 wprintw(itsWindow, "%c", *it);
 906         return *this;
 907 }
 908
 909 Window &Window::operator<<(const std::wstring &ws)
 910 {
 911         for (std::wstring::const_iterator it = ws.begin(); it != ws.end(); ++it)
 912                 wprintw(itsWindow, "%lc", *it);
 913         return *this;
 914 }
 915
 916 Window &Window::operator<<(size_t s)
 917 {
 918         wprintw(itsWindow, "%zu", s);
 919         return *this;
 920 }
 921
 922 std::string ToString(const std::wstring &ws)
 923 {
 924         std::string result;
 925         char s[MB_CUR_MAX];
 926         for (size_t i = 0; i < ws.length(); ++i)
 927         {
 928                 int n = wcrtomb(s, ws[i], 0);
 929                 if (n > 0)
 930                         result.append(s, n);
 931         }
 932         return result;
 933 }
 934
 935 std::wstring ToWString(const std::string &s)
 936 {
 937         std::wstring result;
 938         wchar_t *ws = new wchar_t[s.length()];
 939         const char *c_s = s.c_str();
 940         int n = mbsrtowcs(ws, &c_s, s.length(), 0);
 941         if (n > 0)
 942                 result.append(ws, n);
 943         delete [] ws;
 944         return result;
 945 }
 946
 947 size_t Window::Length(const std::wstring &ws)
 948 {
 949         size_t length = 0;
 950         for (std::wstring::const_iterator it = ws.begin(); it != ws.end(); ++it)
 951                 length += wcwidth(*it);
 952         return length;
 953 }
 954