/***************************************************************************/
/*
* Portions Copyright (c) 1999 GMRS Software GmbH
* Carl-von-Linde-Str. 38, D-85716 Unterschleissheim, http://www.gmrs.de
* All rights reserved.
*
* Author: Arno Unkrig <arno@unkrig.de>
*/
/* 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 in the file COPYING for more details.
*/
/***************************************************************************/
/*
* Changes to version 1.2.2 were made by Martin Bayer <mbayer@zedat.fu-berlin.de>
* Dates and reasons of modifications:
* Thu Oct 4 21:21:10 CEST 2001: ported to g++ 3.0
* Wed Jul 2 21:59:41 CEST 2003: ported to g++ 3.3
*/
/***************************************************************************/
#ifndef __Area_h_INCLUDED__ /* { */
#define __Area_h_INCLUDED__
/* ------------------------------------------------------------------------- */
#include <sys/types.h>
#include <string>
#include <istream>
#ifdef BOOL_DEFINITION
BOOL_DEFINITION
#undef BOOL_DEFINITION
#endif
using std::string;
using std::ostream;
/* ------------------------------------------------------------------------- */
struct Cell {
char character;
char attribute;
enum { NONE = 0, UNDERLINE = 1, BOLD = 2, STRIKETHROUGH = 4 };
void clear() { character = ' '; attribute = NONE; }
};
/* ------------------------------------------------------------------------- */
class Line {
public:
typedef size_t size_type;
Line(size_type l = 0);
Line(const char *);
Line(const string &);
~Line();
size_type length() const { return length_; }
bool empty() const { return length_ == 0; }
const Cell &operator[](size_type x) const { return cells_[x]; }
Cell &operator[](size_type x) { return cells_[x]; }
const Cell *cells() const { return cells_; }
void resize(size_type l);
void enlarge(size_type l) { if (l > length_) resize(l); }
void insert(const Line &, size_type x);
void insert(const char *, size_type x);
void insert(const string &, size_type x);
void append(char c );
void append(const Line &l);
void append(const char *p);
const Line &operator+=(char c ) { append(c); return *this; }
const Line &operator+=(const Line &l) { append(l); return *this; }
const Line &operator+=(const char *p) { append(p); return *this; }
void add_attribute(char addition);
private:
Line(const Line &);
const Line &operator=(const Line &);
size_type length_;
Cell *cells_;
friend class Area;
};
/* ------------------------------------------------------------------------- */
class Area {
public:
typedef size_t size_type;
enum {
LEFT, CENTER, RIGHT,
TOP, MIDDLE, BOTTOM
};
Area();
Area(size_type w, size_type h = 0, char = ' ', char = Cell::NONE);
Area(const char *);
Area(const string &);
Area(const Line &);
~Area();
size_type width() const { return width_; }
size_type height() const { return height_; }
const Cell *operator[](size_type y) const { return cells_[y]; }
Cell *operator[](size_type y) { return cells_[y]; }
const Area &operator>>=(size_type rs);
void resize(size_type w, size_type h);
void enlarge(size_type w, size_type h);
void insert(const Line &l, size_type x, size_type y)
{ insert(l.cells_, l.length_, x, y); }
void insert(const Area &, size_type x, size_type y);
void insert(
const Area &,
size_type x,
size_type y,
size_type w,
size_type h,
int halign,
int valign
);
void insert(const Cell &, size_type x, size_type y);
void insert(const Cell *, size_type count, size_type x, size_type y);
void insert(char, size_type x, size_type y);
void insert(const string &, size_type x, size_type y);
void prepend(int n); // Prepend blank lines at top
void append(int n) // Append blank lines at bottom
{ enlarge(width(), height() + n); }
const Area &operator+=(const Area &); // Append at bottom!
const Area &operator+=(int n) { append(n); return *this; }
void fill(const Cell &, size_type x, size_type y, size_type w, size_type h);
void fill(char, size_type x, size_type y, size_type w, size_type h);
void add_attribute(char addition); // ...but not to left and right free areas
void add_attribute(
char addition,
size_type x,
size_type y,
size_type w,
size_type h
);
static bool use_backspaces; // "true" by default.
private:
Area(const Area &);
const Area &operator=(const Area &);
size_type width_;
size_type height_;
Cell **cells_;
friend ostream &operator<<(ostream &, const Area &);
};
/* ------------------------------------------------------------------------- */
#endif /* } */
/* ------------------------------------------------------------------------- */