include/romlib.h

/* $Id: romlib.h,v 1.4 2006-06-06 19:37:14 roma Exp $ 

        Report Object Management Library

        Version 2.0
*/

#include <extern.h>
#include <stdio.h>
#include <windows.h>
#include <xole.h>

#ifndef _ROMLIB_
#define _ROMLIB_

#ifdef _ROMLIB_WX_
#else
#include "win32/point.h"
#endif

#ifdef _ROMLIB_XML_
typedef XERCES_CPP_NAMESPACE::DOMDocument       rom_XMLDocument;
typedef XERCES_CPP_NAMESPACE::DOMElement        rom_XMLElement;
#endif

enum rom_PaperSize 
{ 
        rom_PAPER_SIZE_UNKNOWN = -1, 
        rom_PAPER_SIZE_A3, 
        rom_PAPER_SIZE_A4 
};

_EXTERN_        int rom_GetStandardPaperWidth(rom_PaperSize _size);

_EXTERN_        int rom_GetStandardPaperHeight(rom_PaperSize _size);

enum rom_PaperOrientation 
{ 
        rom_PAPER_ORIENTATION_UNKNOWN = -1, 
        rom_PAPER_ORIENTATION_PORTRAIT, 
        rom_PAPER_ORIENTATION_LANDSCAPE 
};

enum rom_BrushStyle
{
        rom_BRUSH_SOLID         = 0,
        rom_BRUSH_DIAGONAL      = 1,
        rom_BRUSH_CROSS         = 2,
        rom_BRUSH_DIAGCROSS     = 3,
        rom_BRUSH_FDIAGONAL     = 4,
        rom_BRUSH_HORIZONTAL= 5,
        rom_BRUSH_VERTICAL      = 6,
        rom_BRUSH_NONE          = 7,
        rom_BRUSH_STOP,
};

enum rom_PenStyle
{
        rom_PEN_NONE            = 0,
        rom_PEN_SOLID_0,
        rom_PEN_SOLID_1,
        rom_PEN_SOLID_2,
        rom_PEN_SOLID_3,
        rom_PEN_DOT,
        rom_PEN_DASH,
        rom_PEN_STOP,
};

_EXTERN_ int rom_GetPenWidth(rom_PenStyle _style);
_EXTERN_ int rom_GetPenImage(rom_PenStyle _style);
_EXTERN_ rom_PenStyle rom_GetPenStyle(int _width, int _image);

enum rom_TextOrientation
{       
        rom_TEXT_HORIZONTAL     = 0,
        rom_TEXT_UP                     = 1,
        rom_TEXT_DOWN           = 2,
        rom_TEXT_VERTICAL       = 3
};

enum rom_TextHAlignment
{
        rom_LEFT        = 0,    
        rom_RIGHT       = 1,    
        rom_HCENTER     = 2,    
};

enum rom_TextVAlignment
{
        rom_TOP         = 0,    
        rom_BOTTOM      = 1,    
        rom_VCENTER     = 2,    
        rom_WRAP        = 3,    
};

enum rom_FontCharset
{
        rom_CHARSET_ANSI                = ANSI_CHARSET,
        rom_CHARSET_BALTIC              = BALTIC_CHARSET,
        rom_CHARSET_CHINESEBIG5 = CHINESEBIG5_CHARSET,
        rom_CHARSET_DEFAULT             = DEFAULT_CHARSET,
        rom_CHARSET_EASTEUROPE  = EASTEUROPE_CHARSET,
        rom_CHARSET_GB2312              = GB2312_CHARSET,
        rom_CHARSET_GREEK               = GREEK_CHARSET,
        rom_CHARSET_HANGUL              = HANGUL_CHARSET,
        rom_CHARSET_MAC                 = MAC_CHARSET,
        rom_CHARSET_OEM                 = OEM_CHARSET,
        rom_CHARSET_RUSSIAN             = RUSSIAN_CHARSET,
        rom_CHARSET_SHIFTJIS    = SHIFTJIS_CHARSET,
        rom_CHARSET_SYMBOL              = SYMBOL_CHARSET,
        rom_CHARSET_TURKISH             = TURKISH_CHARSET,
        rom_CHARSET_VIETNAMESE  = VIETNAMESE_CHARSET,    
};

enum rom_FontWeight
{

        rom_WEIGHT_DONTCARE             = FW_DONTCARE, 
        rom_WEIGHT_THIN                 = FW_THIN, 
        rom_WEIGHT_EXTRALIGHT   = FW_EXTRALIGHT, 
        rom_WEIGHT_ULTRALIGHT   = FW_ULTRALIGHT, 
        rom_WEIGHT_LIGHT                = FW_LIGHT, 
        rom_WEIGHT_NORMAL               = FW_NORMAL, 
        rom_WEIGHT_REGULAR              = FW_REGULAR, 
        rom_WEIGHT_MEDIUM               = FW_MEDIUM, 
        rom_WEIGHT_SEMIBOLD             = FW_SEMIBOLD, 
        rom_WEIGHT_DEMIBOLD             = FW_DEMIBOLD, 
        rom_WEIGHT_BOLD                 = FW_BOLD, 
        rom_WEIGHT_EXTRABOLD    = FW_EXTRABOLD, 
        rom_WEIGHT_ULTRABOLD    = FW_ULTRABOLD, 
        rom_WEIGHT_HEAVY                = FW_HEAVY, 
        rom_WEIGHT_BLACK                = FW_BLACK, 
};

enum rom_DuplexMode
{
        rom_DUPLEX_NONE                 = DMDUP_SIMPLEX,
        rom_DUPLEX_SHORT_EDGE   = DMDUP_HORIZONTAL,
        rom_DUPLEX_LONG_EDGE    = DMDUP_VERTICAL,
        rom_DUPLEX_DRIVER               = 0
};

class _EXTERN_ rom_String
/*
        Цепочка символов
*/
{
        char* Buf;      // динамический буфер под цепочку

public:

        ~rom_String();  

        rom_String();
        /*
                Создание пустой цепочки
        */

        rom_String(const char* _s);
        /*
                Создание дубликата строки
        */

        rom_String(int _c);
        /*
                Создание дубликата символа
        */

        rom_String(const rom_String& _s);
        /*
                Создание дубликата цепочки
        */

        int CompareI(const char* _s);
        /*
                Сравнение без учета регистра
        */

        const char* CStr() const;
        /*
                Возвращает ссылку на буфер (не должен меняться).
        */

        void Format(const char* _fmt, ...);
        /*
                Присвоение строки по формату (предельная длина органичена 8192).
        */

        void Assign(const char* _s);
        /*
                Присвоение строки.
        */

        void Assign(const rom_String& _s);
        /*
                Присвоение цепочки.
        */

        void Assign(const char* _s, int _len);
        /*
                Присвоение цепочки заданной длины.
        */

        rom_String& operator =(const char* _s);
        /*
                Операторный вариант присвоения
        */

        rom_String& operator =(const rom_String& _s);
        /*
                Опареторный вариант присвоения
        */

        int operator[](int _i) const;
        /*
                Доступ к отдельному символу
        */

        int Delete(int _i, int _l);
        /*
                Удаление указанного количества символов _l, начиная
                с заданной позиции _i.
        */

        int Insert(int _i, const char* _s);
        /*
                Вставка строки _s в указанную позицию цепочки.
        */

        int GetLength() const;
        /*
                Возвращает длину строки.
        */

        rom_String SubStr(int _i, int _l) const;
        /*
                Возвращает подстроку от _i длиной _l.
        */

        BOOL IsEmpty() const;

        void Empty();

        void ToUpper();
};

class rom_DC;
class rom_DCPrinter;

#ifdef _ROMLIB_WX_
#else

/*class _EXTERN_ rom_Point:public POINT
{
public:

        rom_Point(){}

        rom_Point(const rom_Point& _pt);

        rom_Point(int _x, int _y);

        rom_Point(POINT _pt);
};*/

class _EXTERN_ rom_Rect:public RECT
{
public:

        rom_Rect(){::SetRectEmpty(this);}

        rom_Rect(const rom_Rect& _rc, int _h, int _v);

        rom_Rect(const rom_Rect& _rc);

        rom_Rect(int _left, int _top, int _right, int _bottom);

        rom_Rect(const RECT& _rc);
                
        rom_Point GetLeftTop() const;

        rom_Point GetLeftBottom() const;

        rom_Point GetRightTop() const;

        rom_Point GetRightBottom() const;

        bool Contains(const rom_Point& _pt) const;

        int Width() const;

        int Height() const;

        operator LPCRECT(){return this;}
};

_EXTERN_ rom_Rect operator+(const rom_Rect& _rc, const rom_Point& _pt);

_EXTERN_ rom_Rect operator-(const rom_Rect& _rc, const rom_Point& _pt);

_EXTERN_ rom_Rect operator+(const rom_Rect& _rc1, const rom_Rect& _rc2);

class _EXTERN_ rom_Colour
{
public:

        rom_Colour(const rom_Colour& _c):m_Colour(_c.m_Colour){}

        rom_Colour(int _c):m_Colour((COLORREF)_c){}

        rom_Colour(int _r, int _g, int _b):m_Colour(RGB(_r, _g, _b)){}

        rom_Colour():m_Colour(RGB(0, 0, 0)){}

        operator int() const throw(){return (int)m_Colour;}

private:

        COLORREF        m_Colour;

};

class _EXTERN_ rom_Brush
{
public:

        rom_Brush(rom_BrushStyle _style, const rom_Colour& _colour);

        ~rom_Brush();

        operator HBRUSH() const throw(){return m_hBrush;}

private:

        HBRUSH m_hBrush;

};

class _EXTERN_ rom_Pen
{
public:

        rom_Pen(rom_PenStyle _style, const rom_Colour& _colour);

        rom_Pen(rom_PenStyle _style, const rom_Colour& _colour, int _width);

        ~rom_Pen();

        operator HPEN() const throw(){return m_hPen;}

private:

        HPEN m_hPen;

};

class rom_RepFrameRectangle;

class _EXTERN_ rom_Font
{
public:

        rom_Font
                (
                        const char*                     _name,
                        rom_FontCharset         _charset,
                        int                                     _height,
                        rom_FontWeight          _weight,
                        bool                            _italic,
                        bool                            _strikeout,
                        bool                            _underline,
                        rom_TextOrientation _orient
                );

        rom_Font(const rom_RepFrameRectangle& _r);

        ~rom_Font();

        operator HFONT() const{return m_hFont;}

private:

        HFONT m_hFont;

        void  Create
                (
                        const char*                     _name,
                        rom_FontCharset         _charset,
                        int                                     _height,
                        rom_FontWeight          _weight,
                        bool                            _italic,
                        bool                            _strikeout,
                        bool                            _underline,
                        rom_TextOrientation _orient
                );

};

class _EXTERN_ rom_DC
{
public:

        rom_DC():DC(NULL){}

        rom_DC(HDC _hdc):DC(_hdc){}

        ~rom_DC(){}

        bool IsOk() const{return DC != NULL;}

        int GetLogPixelsX() const;

        int GetLogPixelsY() const;

        rom_Point OffsetViewportOrg(int _x, int _y);

        rom_Point OffsetViewportOrg(const rom_Point& _p);
        
        rom_Point SetViewportOrg(const rom_Point& _org);

        bool RectVisible(const rom_Rect& _rc) const;

        void FillRect(const rom_Rect& _rc, const rom_Brush& _brush);

        void DrawLine(const rom_Point& _pt1, const rom_Point& _pt2, const rom_Pen& _pen);

        void FrameRect(const rom_Rect& _rc, const rom_Brush& _brush);   

        int MMVToPix(int _mm) const;

        int MMHToPix(int _mm) const;

        rom_Point MMToPix(const rom_Point&_pt) const;

        rom_Rect  MMToPix(const rom_Rect& _rc) const;

        int PixToMMH(int _v) const;

        int PixToMMV(int _v) const;

        rom_Point PixToMM(const rom_Point& _pt) const;

        rom_Rect PixToMM(const rom_Rect& _rc) const;

        void DrawText
                (       
                        const char*                             _text, 
                        const rom_Rect&                 _rc, 
                        rom_TextHAlignment              _halign,
                        rom_TextVAlignment              _valign,
                        rom_TextOrientation             _orient,
                        const rom_Colour&               _colour,
                        const rom_Font&                 _font
                );

        void DrawBitmap
                (
                        const char*     _file,
                        const rom_Rect& _rc,
                        bool _stretch
                );

        void DrawCircle
                (
                        const rom_Rect& _rc,
                        const rom_Pen& _pen
                );

        operator HDC() throw(){return DC;}

protected:

        HDC DC;

        static int LogPixelsSx;

        static int LogPixelsSy;
};

class _EXTERN_ rom_DCAuto:public rom_DC
{
public:

        rom_DCAuto(HDC _dc):rom_DC(_dc){}

        rom_DCAuto(){}

        ~rom_DCAuto()
        {
                if(DC)
                        DeleteDC(DC);
        }

};

class _EXTERN_ rom_Printer
{
        friend class rom_DCPrinter;

        char* m_PrinterName;
        char* m_DriverName;
        char* m_PortName;
        HGLOBAL m_hPrinterMode;

        void Detach();

        HGLOBAL GetPrinterMode() const;

protected:

        void Attach(const char* _name);

        void AttachDefault();

        static HGLOBAL GetPrinterInfo
                (
                        const char* _name,
                        char** _driver,
                        char** _port
                );

public:

        rom_Printer():m_hPrinterMode(NULL), m_PrinterName(NULL), m_DriverName(NULL), m_PortName(NULL)
        {
                AttachDefault();
        }


        rom_Printer(rom_PaperSize _size):m_hPrinterMode(NULL), m_PrinterName(NULL), m_DriverName(NULL), m_PortName(NULL)
        {
                Attach(_size);
        }

        ~rom_Printer()
        {
                Detach();
        }

        bool Setup(HWND _owner = NULL) throw(...);

        void SetPaperSize(rom_PaperSize size) throw();

        rom_PaperSize                   GetPaperSize() const throw();

        void SetDuplexMode(rom_DuplexMode _mode) throw();

        rom_DuplexMode GetDuplexMode() const throw();


        const char* GetName() const throw();

        rom_PaperOrientation    GetPaperOrientation() const throw();

        void SetPaperOrientation(rom_PaperOrientation _orient) throw();


        static const char* GetPrinterName(rom_PaperSize _size, char* _name, size_t _cap);


        static void     SetPrinterName(rom_PaperSize _size, const char* _name);

        static bool SelectPrinters(HWND _owner = NULL);

        void Attach(rom_PaperSize _size);

};

class _EXTERN_ rom_DCPrinter:public rom_DCAuto
{
        void ThrowSpoolException(int _r) const;

public:

        rom_DCPrinter(HDC _dc):rom_DCAuto(_dc){}

        rom_DCPrinter(rom_Printer& _printer);

        void StartPage();

        void EndPage();

        void StartDoc(const char* _job_name);

        void EndDoc();

        void AbortDoc();

};

#endif

class rom_Printer;

#ifdef _ROMLIB_WX_
#else


#endif


class _EXTERN_ rom_RepDrawContext;

/******************************************************************************
        В рабочем каталоге находится настроечный файл ROM.INI. По умолчанию
        используется системный каталог Windows (см. ::GetWindowsDirectory).
        Процесс может изменит рабочий каталог с помощью romSetWorkingDirectory
        (это не влияет на системный каталог). Изменение действительно до завершения
        процесса.
 ******************************************************************************/

_EXTERN_ char* rom_GetWorkingDirectory(char* _path);
/*
        Получение рабочего каталога (без завершающего слеш).

        _path[_MAX_PATH] -- возвращаемый путь.

        Возвращаемое значение:

        _path
*/

_EXTERN_ const char* rom_SetWorkingDirectory(const char* _path);
/*
        Изменение рабочего каталога.

        _path[_MAX_PATH] -- новый рабочий каталог (без завершающего слеш).

        Возвращаемое значение:

        _path

*/

_EXTERN_ char* rom_GetIniPath(char* _path);
/*
        Получение полного пути к настроечному файлу.

        _path[_MAX_PATH + _MAX_FNAME] -- возвращаемый путь к настроечному фалу
                                                (...\\ROM.INI)

        Возвращаемое значение:

        _path
*/

_EXTERN_ void rom_SetDefaultSxSy(const rom_DC& _dc) throw();
/*
   Функция устанавливает значения по умолчанию для
   вычислений с контекстом устройства
   MMHToPix, MMVToPix, PixToMMV, PixToMMH.
*/


class _EXTERN_ rom_InStream
/*
        Базовый абстрактный класс для потоков ввода отчета. Разбивает поток символов на лексемы.
*/
{
        void    EatWhite();
        /*
                Пропуск разделителей ('\t', ' ' и '\n'). Символ '\n' пропускается
                только в том случае, если m_KeepLineFeed == FALSE.
        */

protected:
        BOOL    m_Oem;                                  // признак перекодировки строковых лексем в 866
        char*   m_Token;                                // буфер накопление строковых лексем (AddToToken,ClearToken,DetachToken)
        int             m_TokenLen;                             // текущий размер строковой лексемы
        int             m_TokenSize;                    // размер буффера под строковую лексему

        /*
                Функции организации ввода символов.
                Должны быть переписаны конкретной реалиацией.
        */
        virtual int             GetC() = 0;
        virtual int             GetI() = 0;
        virtual long    Tell() = 0;
        virtual BOOL    Seek(long rbpos) = 0;
        virtual BOOL    UngetC(int ch) = 0;

        void    AddToToken(int _ch);
        /*
                Добавление символа в лексему (m_Token).
        */

        void    ClearToken();
        /*
                Удаление лексемы. Освобождение памяти и обнуление счетчиков.
        */

        char*   DetachToken();

        int GetCh();

public:
        BOOL    m_KeepLineFeed;
        /*
                Управляет поведением EatWhite.
        */

        rom_InStream(BOOL oem):m_Oem(oem), m_KeepLineFeed(TRUE), m_Token(NULL), m_TokenLen(0), m_TokenSize(0){}
        /*
                Конструирование потока с учетом перекодировки.
        */

        void    GetString(char** _s);
        /*
                Получение строковой лексемы.
                Строковая лексема, это любой поток символов, не пересекающий
                границу строк.

                *_s -- указатель на память, где находится лексема. Вызывающая программа должна
                освобождать эту память (free).
        */

        BOOL    GetQuotedString(char** _s);
        /*
                Получение лексемы "строка в кавычках".
                "Строка в кавычках" -- это любая последовательность символов, которая может пересекать
                границу строк. Кавычка внутри строки обозначается парой \".

                *_s -- указатель на память, где находится лексема. Вызывающая программа должна
                освобождать эту память (free).

                Возвращает FALSE, когда кавычки не закрыты.
        */

        int             GetInt();
        /*
                Получение лексемы для целого.

                Возвращает значение лексемы.
        */

        int             GetPrefix(long& rbpos);
        /*
                Возвращает символ префикса элемента отчета (фрейма, праямоугольника и проч.).
                Возвращает 0, если последовательность симполов не может быть префиксом
                ({{<символ>). При этом поток остается в том состоянии, в каком он был до
                чтения префикса.

                rbpos -- возвращаемая позиция в потоке непосредственно перед префиксом.
        */

        int             GetPostfix();
        /*
                Возвращает символ постфикса элемента отчета. Возвращает 0, если последовательность
                символов не может быть постфиксом (<символ>}}). Пои этом поток остается в состоянии,
                как он быть до чтения постфикса.
        */

        virtual BOOL    IsOpen() = 0;
        /*
                Возвращет признак, что поток открыт.
        */

        BOOL    RollBack(long rbpos);
        /*
                Откат на заданную позицию потока.
        */
};

class _EXTERN_ rom_InFileStream:public rom_InStream
/*
        Поток для ввода отчета из файла.
*/
{
        FILE*   m_Stream;
        BOOL    m_DoFreeStream;

        int             GetC();
        int             GetI();
        long    Tell();
        BOOL    Seek(long rbpos);
        BOOL    UngetC(int ch);

public:

        rom_InFileStream(const char* file, BOOL oem);

        rom_InFileStream(FILE *, BOOL oem);

        ~rom_InFileStream();

        BOOL IsOpen();
};

class _EXTERN_ rom_InMemoryStream:public rom_InStream
/*
        Поток для ввода отчета из блока памяти
*/
{
        HGLOBAL m_Stream;
        UCHAR*  m_Buffer;
        int             m_Pos;

        int             GetC();
        int             GetI();
        long    Tell();
        BOOL    Seek(long rbpos);
        BOOL    UngetC(int ch);

protected:

        rom_InMemoryStream(BOOL oem);

        void    SetStream(HGLOBAL stream);

public:

        rom_InMemoryStream(HGLOBAL stream, BOOL oem);

        ~rom_InMemoryStream();

        BOOL IsOpen();
};

class _EXTERN_ rom_InClipboardStream:public rom_InMemoryStream
/*
        Поток для ввода отчета из буфера обмена
*/
{
        HWND    m_Owner;

public:

        rom_InClipboardStream(HWND owner, UINT cf);

        ~rom_InClipboardStream();
};

class _EXTERN_ rom_OutStream
/*
        Базовый абстрактный класс для вывода отчета (см. производные классы).
*/
{
protected:
        BOOL    m_Oem;  // признак перекодирования в 866 при выводе

        rom_OutStream(BOOL oem):m_Oem(oem){}

        virtual BOOL PutC(int c) = 0;
        /*
                Абстрактная функция для вывода символа.
                Возвращает FALSE в случае ошибки.
        */

        BOOL PutW(const char* _s);
        /*
                Вывод слова _s (строки без разделителей).
                Возвращает FALSE, если один из вызовов PutC
                вернул FALSE.
        */

public:

        virtual BOOL IsOpen() = 0;
        /*
                Признак готовности потока для вывода.
        */

        BOOL PutChar(char ch);
        /*
                Вывод символа.
                Использует PutC для вывода одиночного символа.
                Возвращает FALSE, если PutC вернул FALSE.
        */

        BOOL PutString(const char* _s);
        /*
                Вывод строки символов (не содержащей кавычек и переносов строки).
                Возвращает FALSE, если один из вызовов PutC вернул
                FALSE.
        */

        BOOL PutQuotedString(const char* _s);
        BOOL PutQuotedString(const rom_String& _s);
        /*
                Вывод строки символов (может содержать кавычки и переносы).
                Внутренние кавычки заменяет парой \".
                Возвращает FALSE, если вызов PutC вернул FALSE.
        */


        BOOL PutInt(int v);
        /*
                Вывод целого числа.
                Возвращает FALSE, если PutW вернул FALSE.
        */

        BOOL PutPrefix(int prefix);
        /*
                Вывод префикса элемента отчета (фрейма, прямоугольника и проч).
                prefix -- код символа префикса.
                Возвращает FALSE, если PutW вернул FALSE.
        */

        BOOL PutPostfix(int postfix);
        /*
                Вывод постфикса элемента отчета.
                postfix -- код символа постфикса.
                Возвращает FALSE, если PutW вернул FALSE.
        */
};

class _EXTERN_ rom_OutFileStream:public rom_OutStream
{
        FILE*   m_Stream;               // файл вывода
        BOOL    m_DoFreeStream; // признак собственного файла вывода

        BOOL PutC(int _c);
        /*
                см. OutStream
        */

public:

        rom_OutFileStream(const char* _file, BOOL _oem);
        /*
                Открытие потока с собственным файлом вывода.
                _file -- путь к файлу;
                _oem -- признак перекодировки в 866.
                При удалении объекта файл вывода будет закрыт.
        */

        rom_OutFileStream(FILE *_file, BOOL _oem);
        /*
                Открытие потока с присоединенным файлом вывода.
                _file -- открытый на запись файл;
                _oem -- признак перекодировки в _oem.
                Удаление объекта не влияет на присоединенный файл.
        */

        ~rom_OutFileStream();

        BOOL    IsOpen();
        /*
                см. OutStream
        */
};

class _EXTERN_ rom_OutMemoryStream:public rom_OutStream
/*
        Поток для вывода отчета в память.    
*/
{
        enum {Released, Owned, Locked} m_State; // состояние блока памяти
        
        BOOL PutC(int c);                                               
        /*
                Вывод символа в блок и при необходимости расширение блока.
        */

        BOOL ExtentMemory();
        /*
                Расширение блока.
                Возвращает FALSE, если произошла ошибка выделения памяти.
        */

protected:
        HGLOBAL m_Stream;               // блок памяти для вывода
        char*   m_Buffer;               // указатель на блок памяти вывода (GlobalLock(m_Stream))
        int         m_Size;                     // размер m_Stream
        int             m_Pos;                  // текущая позиция вывода
        BOOL    m_CRLF;                 // признак разворачивания \n -> \r\n

        void    Release();
        /*
                Перевод памяти в состояние Release (GlobalUnlock(m_Stream)).
        */

        void    Close();
        /*
                Освобождение памяти.
        */

        void    Open();
        /*
                Начальное размещеие памяти.
        */

public:
        rom_OutMemoryStream(BOOL oem = FALSE, BOOL crlf = TRUE);
        /*
                Создание потока:
                oem -- признак перекодирования вывода в 866
                crlf -- признак замены \n -> \r\n
        */

        virtual ~rom_OutMemoryStream();

        virtual BOOL IsOpen();
        /*
                см. OutStream
        */

        int GetSize()
        /*
                Возвращает текущий размер выделенной памяти.
        */
        {
                return m_Size;
        }

        int GetPos() 
        /*
                Возвращает текущую позиций вывода.
        */
        {
                return m_Pos;
        }

        void Copy(LPSTR _dest)
        /*
                Копирует содержимое буфера вывода в строку. Размер строки должен соответствовать
                размеру выводимых данных и буфер вывода должен завершаться \0.
        */
        {
                strcpy(_dest, m_Buffer);
        }

        BOOL SetCRLF(BOOL crlf)
        /*
                Изменяет текущее состояние признака замены \n -> \r\n.
                Возвращает старое значение признака.
        */
        {
                BOOL ret = m_CRLF;
                m_CRLF = crlf;
                return ret;
        }

        HGLOBAL GetBuffer()
        /*
                Возвращает ссылку на блок памяти вывода.
                Поток переводится в состояние Release, в котором блок памяти отторгается
                от потока и должен освобождаться вызывающим окружением.
        */
        {
                Release();
                return m_Stream;
        }

};

class _EXTERN_ rom_OutClipboardStream:public rom_OutMemoryStream
/*
        Поток вывода в буфер обмена.
*/
{
        HWND    m_Owner;        // окно-владелец буфера обмена
        UINT    m_CF;           // формат вывода
        BOOL    m_IsOpen;       // признак доступности буфера

public:
        rom_OutClipboardStream(HWND owner, UINT cf);
        /*
                Открытие буфера обмена для заданного формата.
                owner -- окно-владалец
                cf -- формат вывода
        */

        ~rom_OutClipboardStream();

        BOOL IsOpen();
        /*      
                см. OutStream
        */

        void ChangeFormat(UINT cf);
        /*
                Смена формата вывода.
                cf -- новый формат.
        */

        static void DoEmptyClipboard();

        static void Empty(HWND owner);
};

_EXTERN_ UINT rom_GetRepCF();
/*
        Получение зарегистрированного формата буффера обмена
        отчета.
*/

_EXTERN_ UINT rom_GetRepFrameRectangleCF();
/*
        Получение зарегистрированного формата прямоугольника.
*/

class rom_Report;
class rom_RepPage;
class rom_RepFrame;
class rom_RepFrameItem;

class _EXTERN_ rom_RepItem
/*
        Базовый класс для всех элементов отчета.
        Представляет интерфейс для отрисовки и проч.
        Все элемента объединяются в двунаправленный список
        в рамках отчета.
*/
{
        friend class rom_Report;

        rom_RepItem     *Next, *Prev;
        /*
                Ссылки списка элементов отчета.
        */

        rom_RepItem()
        /*
                Только для использования в качестве головы списка элементов
                (Report::m_ItemList).
        */
        {
                m_Rep = NULL;
                Next = Prev = this;
        }

public:

        rom_Report      *m_Rep; // ссылка на отчет

        enum ItemType   // возможные типы элементов
        {
                Line,           // строка текста (программы)
                Frame,          // фрейм (графика отчета)
                PageBreak,      // принудительный разрыв страницы
                Dummy           // ничто
        };

        rom_RepItem(rom_Report* _rep, rom_RepItem* _before);
        /*
                Создание очередного элемента в отчете (_rep) и вставка его перед указанным элементом (_before).
                Если _before == NULL, то элемент вставляется в конец отчета.
        */

        virtual ~rom_RepItem();

        virtual ItemType Type() const
        /*
                Возвращает тип элемента
        */
        {
                return Dummy;
        }

        virtual bool In(rom_InStream& _in)
        /*
                Ввод элемента из потока
        */
        {
                return true;
        }

        virtual bool Out(rom_OutStream& _out)
        /*
                Вывод элемента в поток
        */
        {
                return true;
        }

        virtual rom_RepItem* Clone(rom_Report* _rep, rom_RepItem* _before)
        /*
                Дублирование элемента в отчете (_rep).
        */
        {
                return new rom_RepItem(_rep, _before);
        }

        virtual int Height() const
        {
                return 0;
        }

        virtual void Draw(rom_DC& _dc, word4 _flags, rom_RepDrawContext* _dx = NULL) const throw(){}

        virtual int     MinHeight() const
        {
                return 0;
        }

        virtual void Scale(unsigned int _a, unsigned int _b) throw(){}
        
};

struct _EXTERN_ rom_RepPageItem
/*
        Элемент постраничной разбивки отчета
*/
{
                rom_RepItem* m_Item;                    // элемент отчета
                int     m_Offset;                               // смещение от начала страницы
                rom_RepPage* m_Page;                    // страница
                rom_RepPageItem *Next, *Prev;   // двунаправленный список элементов разбивки
};

class _EXTERN_ rom_RepPage
/*
   Страница отчета в постраничной разбивке.
*/
{
   rom_Report* m_Rep;  // отчет
   int m_Number;       // номер страницы
   rom_RepPageItem m_ItemList; // список элементов на странице

public:

   rom_RepPage(rom_Report* rep);
   /*
       Добавление новой страницы в конец списка страниц.
   */

   ~rom_RepPage();

   rom_RepPageItem* GetFirstItem();
   /*
       Получние первого элемента на странице (NULL если страница пуста).
   */

   rom_RepPageItem* GetLastItem() const throw();
   /*
       Получение последнего элемента на странице (NULL если страница пуста).
   */

   rom_RepPageItem* GetNextItem(rom_RepPageItem* _item);
   /*
       Получение следующего элемента на странице (NULL для последнего элемента).
   */

   rom_RepPageItem* GetPrevItem(rom_RepPageItem* _item);
   /*
       Получение предыдущего элемента на странице (NULL для первого элемента).
   */

   BOOL IsEmpty();
   /*
       Признак пустой страницы
   */

   /*  \brief Проверяет наличие свободного пространства на странице для
                          размещение одного или нескольких элементов отчета. 
                          
           Список элементов задается начиная с параметра _item и должен завершаться NULL.
       Подстчет свободного пространства начинается с последнего размещенного
       на странице элемента.

           \param       _dc             Контекст устройства.
           \param       _item   Начало списка элементов.
   */
   BOOL HasSpaceFor(rom_DC& _dc, rom_RepItem* _item, ...);

   void Add(rom_RepItem* _item);
   /*
       Размещение элемента отчета _item на странице (элемент добавляется
       в конец страницы).
   */

   int GetTopMargin();
   /*
       Размер верхнего поля (1/100 мм).
   */

   int GetBottomMargin();
   /*
       Размер нижнего поля (1/100 мм).
   */

   int GetLeftMargin();
   /*
       Размер левого поля (1/100 мм).
   */

   int GetRightMargin();
   /*
       Размер правого поля (1/100 мм).
   */

   int GetLength();
   /*
       Высота страницы без учета полей (1/100 мм).
   */

   int GetWidth();
   /*
       Ширина страницы без учета полей (1/100 мм).
   */

   int GetFreeWorkspace(rom_DC& _dc) const throw();

   void DrawContents(rom_DC& _dc, rom_RepDrawContext* _dx = NULL);

   /*   \brief  Вывод страницы на печать.

                \param  _dc     Контекст устройства вывода.
   */
   void Print(rom_DCPrinter& _hdc, rom_RepDrawContext* _dx = NULL);

   int GetNumber() const
   /* 
        Получение номера страницы.
   */
   {
       return m_Number;
   }

};

class _EXTERN_ rom_RepLine:public rom_RepItem
/*
        Строка программного текста в отчете.
*/
{
        rom_String m_Line;      // содержимое строки

public:

        rom_RepLine(rom_Report* _rep, rom_RepItem* _before):rom_RepItem(_rep, _before)
        /*
                Конструктор пустой строки.
                При создании строка вставляется в отчет _rep перед элементом _before.
                (NULL -- конец отчета).
        */
        {
        }

        rom_RepLine(rom_Report* _rep, const char* _s, rom_RepItem* _before):rom_RepItem(_rep, _before), m_Line(_s)
        /*
                Контсруктор строки с заданным содержимым.
                При создании строка вставляется в отчет _rep перед заданной строкой _before
                (NULL -- конец отчета).
        */
        {
        }

        ~rom_RepLine()
        {
        }

   ItemType Type() const
   /*
      См. RepItem.
   */
   {
      return Line;
   }

        bool            In(rom_InStream& in);
        /*
                Ввод строки из потока (строк не должна быть заковычена).
        */

        bool            Out(rom_OutStream& out);
        /*
                Вывод строки в поток.
        */

        const char* CStr()
        /*
                Возвращает ссылку на буфер строки.
                Строка возвращается только на чтение.
        */
        {
                return m_Line.CStr();
        }

        rom_RepItem* Clone(rom_Report* _rep, rom_RepItem* _before);
        /*
                Создание копии строки в другом (или том же) отчете
                (см. RomItem::Clone).
        */

        /************************************************************/
        /* Эти функции -- рудимент, который в ближайшее время       */
        /* отпадет и на него лучше не расчитывать :)                            */

        void Insert(const char* _s, int p = -1);

        void Insert(int _c , int _p = -1)
        {
                char s[2];

                s[0] = _c;
                s[1] = '\0';
                Insert(s, _p);
        }

        void Remove(int p, int l = -1);

        rom_String Substr(int p, int l = -1);

        /* Конец рудимента                                          */
        /************************************************************/

        int GetLength() const
        /*
                Возвращает длину строки.
        */
        {
                return m_Line.GetLength();
        }

        int Height() const
        /*
                Высота завивт от шрифта, а мы его сейчас не знаем -- потому 0.
        */
        {
                return 0;
        }
};

class _EXTERN_ rom_RepFrameItem
{
        friend class rom_RepFrame;

        rom_RepFrameItem *Next, *Prev;  

        rom_RepFrameItem();

protected:

        rom_RepFrame*   m_Frame;                

public:

        rom_String              m_Name;         
        rom_Rect                m_Rc;           

        enum itemType
        {
                itemNone,                               
                itemRectangle,                  
                itemBitmap,                             
                itemCircle,                             
                itemDiagonal                    
        };

        virtual int Type()
        {
                return itemNone;
        }

        rom_RepFrameItem(rom_RepFrame* _frame, rom_RepFrameItem* _before = NULL);

        virtual ~rom_RepFrameItem();

        virtual bool In(rom_InStream& _in);

        virtual bool Out(rom_OutStream& _out);

        virtual rom_RepFrameItem* Clone(rom_RepFrame* _frame);

        virtual void Draw(rom_DC& _dc, word4 _flags, rom_RepDrawContext* _dx = NULL) const throw(){}

    void MoveBefore(rom_RepFrameItem* _before);

        virtual void Scale(unsigned int _a, unsigned int _b) throw();

};

class _EXTERN_ rom_RepFrameRectangle:public rom_RepFrameItem
{
        void DrawBorders(rom_DC& _dc, const rom_Rect& _rc) const throw();
        void FillRectangle(rom_DC& _dc, const rom_Rect& _rc) const throw();
        void DrawText(rom_DC& _hdc, const rom_Rect& _rc) const;

        unsigned char m_Border[4];

        int PackBorderWidths() const throw();

        int PackBorderStyles() const throw();

public:
        rom_String              m_Text;                 
        rom_TextHAlignment      m_HorzAlign;    
        rom_TextVAlignment      m_VertAlign;    
        rom_String              m_FontName;             
        rom_FontCharset m_CharSet;              
        int                             m_FontSize;             
        rom_FontWeight  m_FontWeight;   
        bool                    m_Italic;               
        bool                    m_StrikeOut;    
        bool                    m_Underline;    
        rom_Colour              m_TextColor;    
        rom_TextOrientation     m_Orient;               
//      int                             m_Borders;              //!< Обрамление: 0x1 - up, 0x2 - bot, 0x4 - left, 0x8 - right.
        int                             m_BordersStyle; 
        rom_Colour              m_TopColor;             
        rom_Colour              m_BotColor;             
        rom_Colour              m_LeftColor;    
        rom_Colour              m_RightColor;   
        rom_BrushStyle  m_FillStyle;    
        rom_Colour              m_FillColor;    

        void SetBorder(int _flags, int _widths);

        void SetBorder(int _styles) throw();

        void SetBorder(int _i, rom_PenStyle _s);

        rom_PenStyle GetBorder(int _i) const{return (rom_PenStyle)m_Border[_i];}

        int Type()
        {
                return itemRectangle;
        }
        
        rom_RepFrameRectangle(rom_RepFrame* _frame, rom_RepFrameItem* _before = NULL);

        bool In(rom_InStream& _in);

        bool Out(rom_OutStream& _out);

        rom_RepFrameItem* Clone(rom_RepFrame* _frame);

        void Draw(rom_DC& _dc, word4 _flags, rom_RepDrawContext* _dx) const throw();

        HBRUSH CreateBrush() const;


        int PackBorderFlags() const throw();

        void Scale(unsigned int _a, unsigned int _b) throw();

};

class _EXTERN_ rom_RepFrameBitmap:public rom_RepFrameItem
/*
        Графический примитив -- изображение
*/
{
public:

        rom_String      m_FileName;     // файл с изображением
        bool    m_Stretch;      // признак растяжения

        int Type()
        /*
                См. RepFrameItem
        */
        {
                return itemBitmap;
        }

        rom_RepFrameBitmap(rom_RepFrame* _frame, rom_RepFrameItem* _before = NULL):rom_RepFrameItem(_frame, _before){}
        /*
                Добавление изображения к фрейму
        */

        bool In(rom_InStream& _in);
        /*
                Ввод изображения из потока
        */

        bool Out(rom_OutStream &_out);
        /*
                Вывод изображения в поток
        */

        rom_RepFrameItem* Clone(rom_RepFrame* _frame);
        /*
                Копирование изображения
        */

        void Draw(rom_DC& _hdc, word4 _flags, rom_RepDrawContext* _dx = NULL) const;
        /*
                Отрисовка изображения
        */
};

class _EXTERN_ rom_RepFrameCircle:public rom_RepFrameItem
/*
        Графический примитив -- круг
*/
{
public:

        rom_Colour m_Color;             // цвет рисования
        rom_PenStyle m_LineStyle;       // 0 - сплошная линия, 1 - пунктир, 2 - точками

        int Type()
        /*
                См. RepFrameItem
        */
        {
                return itemCircle;
        }

        rom_RepFrameCircle(rom_RepFrame* _frame, rom_RepFrameItem* _before = NULL):rom_RepFrameItem(_frame, _before)
        /*
                Добавление круга к фрейму :)
        */
        {
        }

        bool In(rom_InStream & _in);
        /*
                Ввод из потока
        */

        bool Out(rom_OutStream &_out);
        /*
                Вывод в поток
        */

        rom_RepFrameItem* Clone(rom_RepFrame* _frame);
        /*
                Копирование
        */

        void Draw(rom_DC& _dc, word4 _flags, rom_RepDrawContext* _dx) const;
        /*
                Отрисовка
        */
};

class _EXTERN_ rom_RepFrameDiagonal:public rom_RepFrameItem
/*
        Графический примитив -- перечеркивание
*/
{
public:

        rom_Colour              m_Color;        // цвет
//      byte                    m_Width;        // толстота
//      rom_PenStyle    m_Style;        // стиль: 0 - сплошная линия, 1 - пунктир, 2 - точками
        byte                    m_Dir;          // 0 - (top_left, bottom_right), 1 - (bottom_left, top_right)
        rom_PenStyle    m_Style;

        int Type()
        /*
                См. RepFrameItem
        */
        {
                return itemDiagonal;
        }

        rom_RepFrameDiagonal(rom_RepFrame *_frame, rom_RepFrameItem* _before = NULL):rom_RepFrameItem(_frame, _before)
        /*
                Добавление к фрейму
        */
        {
        }

        bool In(rom_InStream &_in);
        /*
                См. RepFrameItem
        */

        bool Out(rom_OutStream &_out);
        /*
                См. RepFrameItem
        */

        rom_RepFrameItem* Clone(rom_RepFrame *_frame);
        /*
                См. RepFrameItem
        */

        void Draw(rom_DC& _dc, word4 _flags, rom_RepDrawContext* _dx) const;
        /*
                См. RepFrameItem
        */
};

class _EXTERN_ rom_RepFrame:public rom_RepItem
{
        friend class rom_RepFrameItem;

protected:

        rom_RepFrameItem m_ItemList;    

public:

        int     m_Height;       

        rom_RepFrame(rom_Report* _rep, rom_RepItem* _before) throw():rom_RepItem(_rep, _before){}

        ~rom_RepFrame();

        ItemType Type()const
        {
           return Frame;
        }

        bool In(rom_InStream& _in);

        bool Out(rom_OutStream& out);

        rom_RepFrameItem* GetFirstItem(rom_RepFrameItem::itemType _type = rom_RepFrameItem::itemNone) const;
        
        rom_RepFrameItem* GetLastItem(rom_RepFrameItem::itemType type = rom_RepFrameItem::itemNone) const;
        
        rom_RepFrameItem* GetNextItem(rom_RepFrameItem* _item, rom_RepFrameItem::itemType type = rom_RepFrameItem::itemNone) const;

        rom_RepFrameItem* GetPrevItem(rom_RepFrameItem* _item, rom_RepFrameItem::itemType type = rom_RepFrameItem::itemNone) const;

        rom_RepFrameItem* FindItem(const char* _name);

        int     GetItemsCount() const;

        rom_RepItem* Clone(rom_Report* _rep, rom_RepItem* _before);

        int     Height() const
        {
                return m_Height;
        }

        void Draw(rom_DC& _dc, word4 _flag, rom_RepDrawContext* _dx = NULL) const throw();

        rom_RepFrame* SubFrame(rom_Report* _rep, LPRECT _rc, rom_RepItem* _before);

        int     MinHeight() const;

        void Clear();

        void Scale(unsigned int _a, unsigned int _b) throw();

};

class _EXTERN_ rom_RepPageBreak:public rom_RepItem
/*
        Принудительный разрыв страницы
*/
{
        static int      m_Height;               // высота символа при выводе (некая константа)

public:

        rom_RepPageBreak(rom_Report* _rep, rom_RepItem* _before):rom_RepItem(_rep, _before){}
        /*
                Создание разрыва страницы в отчете _rep и добавление его перед указанным элементом
                _before.
        */

   ItemType Type() const
   /*
      См. RepItem
   */
   {
      return PageBreak;
   }

        bool In(rom_InStream& _in);
        /*
                См. RepItem
        */

        bool Out(rom_OutStream& _out);
        /*
                См. RepItem
        */

        rom_RepItem* Clone(rom_Report* _rep, rom_RepItem* _before);
        /*
                См. RepItem
        */
        
        int Height() const;
        /*
                См. RepItem
        */
};

class _EXTERN_ rom_Report
{
        friend class rom_RepItem;
        friend class rom_RepPage;

        rom_RepItem     m_ItemList;
        rom_RepPage** m_PageArray;
        int m_PageArrayLength;  
        int m_PageArraySize;

        void ExtendPageArray();
        int AppendPage(rom_RepPage* _page);
        void RemovePage(int _number);

public:

        rom_PaperOrientation    m_Orient;               
        rom_PaperSize                   m_PaperSize;    
        int             m_TopMargin;                                    
        int             m_LeftMargin;                                   
        int             m_BottomMargin;                                 
        int             m_RightMargin;                                  

        rom_Report();   

        ~rom_Report();  

        BOOL            Open(const char* _file, BOOL _oem = FALSE);

        BOOL            Save(const char* file, BOOL oem = FALSE);

        BOOL            Save(rom_OutStream& out);

        BOOL            SaveHeader(rom_OutStream &out);

        BOOL            Open(rom_InStream& _in);

        BOOL            SendToClipboard(HWND);

        BOOL            GetFromClipboard(HWND);

        void            Clear();        

        void            ClearPages();   

        rom_RepItem* GetFirstItem();

        rom_RepItem* GetNextItem(rom_RepItem* _item);

        int                     GetItemsCount();

        rom_RepPage* GetPage(int i);    

        int                     GetTotalPages();        

        int                     GetWorkspaceLength(rom_DC& _dc);

        int                     GetPageWidth();

        int                     GetPageLength();

        BOOL            SetupPageProperties(HWND _pParent);

        void            Make(ole_excel::data *_cells);

   void Paginate(rom_DC& _hdc);
 
   void Print
           (
                        rom_DCPrinter& _dc, 
                        const char* _job_name, 
                        int (*_monit)(rom_RepPage* _page, void* _ptr) = NULL, 
                        void* _ptr = NULL,
                        rom_RepDrawContext* _dx = NULL
                );

#ifdef _ROMLIB_XML_

        rom_XMLElement* ConvertToXML
                (
                        rom_XMLDocument* _parent,
                        bool _comment_rep_line = true
                ) throw(...);

#endif

        void Scale(unsigned int _a, unsigned int _b) throw();

        void Scale(rom_PaperSize _size, rom_PaperOrientation _orient) throw();

};

class _EXTERN_ rom_RepDrawContext
{
public:

        bool            m_PageContentsBorderFlag;               

        rom_Colour      m_PageContentsBorderColor;              

        rom_RepDrawContext();

        virtual void DrawPageContents(rom_DC& _dc, rom_RepPage* _page);

        virtual void DrawPageItem(rom_DC& _dc, rom_RepPageItem* _item);

        virtual void OnDrawFrameRectangle(rom_DC& _hdc, const rom_RepFrameRectangle* _item, const rom_Rect& _rc){};
};

#endif