Base classes

Classes
class	owl::TEventHandler
class	owl::TResponseTableEntry< T >
class	owl::TGdiBase
class	owl::TStreamableBase
class	owl::TStreamable
class	owl::TStreamer
	Provides a base class for all streamable objects. More...
class	owl::TOldStreamer
	Provides a base class for all streamable objects. More...
class	owl::TNewStreamer
class	owl::TPWrittenObjects
class	owl::TPReadObjects
class	owl::pstream
class	owl::ipstream
class	owl::opstream
class	owl::fpbase
class	owl::ifpstream
class	owl::ofpstream
Defines
#define	WM_OWLLAST   0x7FFF
#define	WM_OWLFIRST   (WM_OWLLAST - 0x03FF)
#define	WM_COMMAND_ENABLE   (WM_OWLLAST - 0)
#define	WM_CHILDINVALID   (WM_OWLLAST - 1)
#define	WM_OWLDOCUMENT   (WM_OWLLAST - 2)
#define	WM_OWLVIEW   (WM_OWLLAST - 3)
#define	WM_OWLNOTIFY   (WM_OWLLAST - 4)
#define	WM_OWLPREPROCMENU   (WM_OWLLAST - 5)
#define	WM_OWLCANCLOSE   (WM_OWLLAST - 6)
#define	WM_VBXINITFORM   (WM_OWLLAST - 7)
#define	WM_VBXNAME   (WM_OWLLAST - 8)
#define	WM_VBXBASE   (WM_OWLLAST - 8 - 256)
#define	WM_OWLWAKEUP   (WM_VBXBASE - 1)
#define	WM_OWLFRAMESIZE   (WM_VBXBASE - 2)
#define	WM_OWLSLIPDBLCLK   (WM_VBXBASE - 3)
#define	WM_OWLWINDOWDOCKED   (WM_VBXBASE - 4)
#define	WM_OWLCREATETTIP   (WM_VBXBASE - 5)
#define	WM_OWLHELPHIT   (WM_VBXBASE - 6)
#define	_OBJ_FULLTYPENAME(obj)   typeid(*obj).name()
#define	_OBJ_TYPENAME(obj)   typeid(*obj).name()
#define	DECLARE_STREAMERS(cls, ver)
#define	DECLARE_STREAMER(exp, cls, ver)
#define	DECLARE_STREAMER_FROM_BASES(cls, base)
#define	DECLARE_STREAMER_FROM_BASE(exp, cls, base)
#define	DECLARE_ABSTRACT_STREAMERS(cls, ver)
#define	DECLARE_ABSTRACT_STREAMER(exp, cls, ver)
#define	DECLARE_STREAMABLE_OPS(cls)
#define	DECLARE_STREAMABLE_INLINES_I(cls)
#define	DECLARE_STREAMABLE_CTOR(cls)
#define	DECLARE_CASTABLE   friend class std::type_info
#define	DECLARE_STREAMABLE(exp, cls, ver)
#define	DECLARE_STREAMABLES(cls, ver)
#define	DECLARE_STREAMABLE_FROM_BASE(exp, cls, base)
#define	DECLARE_STREAMABLE_FROM_BASES(cls, base)
#define	DECLARE_ABSTRACT_STREAMABLE(exp, cls, ver)
#define	DECLARE_ABSTRACT_STREAMABLES(cls, ver)
#define	DECLARE_STREAMABLE_OWL(cls, ver)   DECLARE_STREAMABLES( cls, ver )
#define	DECLARE_STREAMABLE_FROM_BASE_OWL(cls, base)   DECLARE_STREAMABLE_FROM_BASES(cls, base )
#define	DECLARE_ABSTRACT_STREAMABLE_OWL(cls, ver)   DECLARE_ABSTRACT_STREAMABLES(cls, ver )
#define	DECLARE_STREAMABLE_INLINES(cls)   DECLARE_STREAMABLE_INLINES_I( cls )
#define	IMPLEMENT_CASTABLE(cls)
#define	IMPLEMENT_CASTABLE1(cls, base1)
#define	IMPLEMENT_CASTABLE2(cls, base1, base2)
#define	IMPLEMENT_CASTABLE3(cls, base1, base2, base3)
#define	IMPLEMENT_CASTABLE4(cls, base1, base2, base3, base4)
#define	IMPLEMENT_CASTABLE5(cls, base1, base2, base3, base4, base5)
#define	IMPLEMENT_STREAMABLE_CLASS(cls)   ::owl::TStreamableClass r ## cls( typeid(cls).name(), &cls::Streamer::Build )
#define	IMPLEMENT_STREAMABLE_POINTER_IMPL(template_prefix, cls)
#define	IMPLEMENT_STREAMABLE_POINTER(cls)   IMPLEMENT_STREAMABLE_POINTER_IMPL(, cls)
#define	IMPLEMENT_STREAMER(cls)
#define	IMPLEMENT_STREAMABLE_CTOR(cls)   cls::cls ( ::owl::StreamableInit ) {}
#define	IMPLEMENT_STREAMABLE_CTOR1_IMPL(template_prefix, cls, constructor, base1)   template_prefix cls::constructor(::owl::StreamableInit) : base1(::owl::streamableInit) {}
#define	IMPLEMENT_STREAMABLE_CTOR1(cls, base1)   IMPLEMENT_STREAMABLE_CTOR1_IMPL(, cls, cls, base1)
#define	IMPLEMENT_STREAMABLE_CTOR2(cls, base1, base2)
#define	IMPLEMENT_STREAMABLE_CTOR3(cls, base1, base2, base3)
#define	IMPLEMENT_STREAMABLE_CTOR4(cls, base1, base2, base3, base4)
#define	IMPLEMENT_STREAMABLE_CTOR5(cls, base1, base2, base3, base4, base5)
#define	IMPLEMENT_ABSTRACT_STREAMABLE(cls)
#define	IMPLEMENT_ABSTRACT_STREAMABLE1(cls, base1)
#define	IMPLEMENT_ABSTRACT_STREAMABLE2(cls, base1, base2)
#define	IMPLEMENT_ABSTRACT_STREAMABLE3(cls, base1, base2, base3)
#define	IMPLEMENT_ABSTRACT_STREAMABLE4(cls, base1, base2, base3, base4)
#define	IMPLEMENT_ABSTRACT_STREAMABLE5(cls, base1, base2, base3, base4, base5)
#define	IMPLEMENT_STREAMABLE(cls)
#define	IMPLEMENT_STREAMABLE1(cls, base1)
#define	IMPLEMENT_STREAMABLE2(cls, base1, base2)
#define	IMPLEMENT_STREAMABLE3(cls, base1, base2, base3)
#define	IMPLEMENT_STREAMABLE4(cls, base1, base2, base3, base4)
#define	IMPLEMENT_STREAMABLE5(cls, base1, base2, base3, base4, base5)
#define	IMPLEMENT_STREAMABLE_FROM_BASE(cls, base1)
Typedefs
typedef LRESULT	owl::TResult
typedef uint	owl::TMsgId
typedef WPARAM	owl::TParam1
typedef LPARAM	owl::TParam2
typedef TResponseTableEntry < TGeneric >	owl::TGenericTableEntry
typedef unsigned	owl::P_id_type
Enumerations
enum	owl::TAutoDelete { NoAutoDelete, AutoDelete }
enum	owl::StreamableInit { streamableInit }
Functions
template<class T1 , class T2 >
TParam2	owl::MkParam2 (const T1 &lo, const T2 &hi)
TParam1	owl::MkParam1 (uint lo, uint hi)
ipstream &	owl::operator>> (ipstream &is, tstring &str)
opstream &	owl::operator<< (opstream &os, const tstring &str)
ipstream &	owl::operator>> (ipstream &, int8 &)
ipstream &	owl::operator>> (ipstream &, uint8 &)
ipstream &	owl::operator>> (ipstream &, char &)
ipstream &	owl::operator>> (ipstream &, signed short &)
ipstream &	owl::operator>> (ipstream &, unsigned short &)
ipstream &	owl::operator>> (ipstream &, signed int &)
ipstream &	owl::operator>> (ipstream &, unsigned int &)
ipstream &	owl::operator>> (ipstream &, bool &)
ipstream &	owl::operator>> (ipstream &, signed long &)
ipstream &	owl::operator>> (ipstream &, unsigned long &)
ipstream &	owl::operator>> (ipstream &, int64 &)
ipstream &	owl::operator>> (ipstream &, uint64 &)
ipstream &	owl::operator>> (ipstream &, float &)
ipstream &	owl::operator>> (ipstream &, double &)
ipstream &	owl::operator>> (ipstream &, long double &)
opstream &	owl::operator<< (opstream &, int8)
opstream &	owl::operator<< (opstream &, uint8)
opstream &	owl::operator<< (opstream &, char)
opstream &	owl::operator<< (opstream &, signed short)
opstream &	owl::operator<< (opstream &, unsigned short)
opstream &	owl::operator<< (opstream &, bool)
opstream &	owl::operator<< (opstream &, int64)
opstream &	owl::operator<< (opstream &, uint64)
opstream &	owl::operator<< (opstream &, float)
opstream &	owl::operator<< (opstream &, double)
opstream &	owl::operator<< (opstream &, long double)
opstream &	owl::operator<< (opstream &ps, signed int i)
opstream &	owl::operator<< (opstream &ps, unsigned int i)
opstream &	owl::operator<< (opstream &ps, signed long l)
opstream &	owl::operator<< (opstream &ps, unsigned long l)
template<class Base >
void	owl::WriteBaseObject (Base *base, opstream &out)
template<class Base >
void	owl::ReadBaseObject (Base *base, ipstream &in)
template<class Base >
void	owl::WriteVirtualBase (Base *base, opstream &out)
template<class Base >
void	owl::ReadVirtualBase (Base *base, ipstream &in)
_OWLCTOR	owl::pstream::pstream (std::streambuf *)
int	owl::pstream::rdstate () const
int	owl::pstream::eof () const
int	owl::pstream::fail () const
int	owl::pstream::bad () const
int	owl::pstream::good () const
void	owl::pstream::clear (int=0)
	owl::pstream::operator void * () const
int	owl::pstream::operator! () const
std::streambuf *	owl::pstream::rdbuf () const
_OWLCTOR	owl::pstream::pstream ()
void	owl::pstream::init (std::streambuf *)
void	owl::pstream::setstate (int)
_OWLCTOR	owl::ipstream::ipstream (std::streambuf *)
_OWLCTOR	owl::ipstream::ipstream ()
TStreamableBase *	owl::ipstream::find (P_id_type)
void	owl::ipstream::registerObject (TStreamableBase *adr)
uint32	owl::ipstream::getVersion () const
void	owl::opstream::writeWord (uint32)
void	owl::opstream::writeSuffix (const TStreamableBase *)
P_id_type	owl::opstream::findObject (TStreamableBase *adr)
void	owl::opstream::registerObject (TStreamableBase *adr)
P_id_type	owl::opstream::findVB (TStreamableBase *adr)
void	owl::opstream::registerVB (TStreamableBase *adr)
_OWLCTOR	owl::fpbase::fpbase ()
_OWLCTOR	owl::fpbase::fpbase (LPCSTR, int, int=openprot)
std::filebuf *	owl::fpbase::rdbuf ()
_OWLCTOR	owl::ifpstream::ifpstream ()
_OWLCTOR	owl::ifpstream::ifpstream (LPCSTR, int=std::ios::in, int=fpbase::openprot)
std::filebuf *	owl::ifpstream::rdbuf ()
void	owl::ifpstream::open (LPCSTR, int=std::ios::in, int=fpbase::openprot)
_OWLCTOR	owl::ofpstream::ofpstream ()
_OWLCTOR	owl::ofpstream::ofpstream (LPCSTR, int=std::ios::out, int=fpbase::openprot)
std::filebuf *	owl::ofpstream::rdbuf ()
void	owl::ofpstream::open (LPCSTR, int=std::ios::out, int=fpbase::openprot)
Variables
class _RTTI	owl::TStreamable

---

Detailed Description

TEventHandler, TStreamableBase, and TGdiBase are important base classes. All ObjectWindows classes are derived from one or more of these classes. Classes that inherit from TEventHandler are able to respond to window messages. Classes that inherit from TStreamableBase support streaming; that is, their objects can write to and read from streams. Almost all of the ObjectWindows classes are derived from TStreamableBase. You can use multiple inheritance to derive a class from both TEventHandler and TStreamableBase. Classes that inherit from TGDIBase, a private base class, support GDI drawing objects such as pens, brushes, fonts, and bitmaps.

• TEventHandler sends messages to the appropriate message handler.
• TStreamableBase provides support for C++ streaming and persistence.
• TGdiBase is the root class for all derived GDI classes that support Windows' GDI library.

---

Define Documentation

#define DECLARE_ABSTRACT_STREAMABLE	(		exp,
			cls,
			ver
	)

Value:

DECLARE_CASTABLE;                                               \
    DECLARE_ABSTRACT_STREAMER( exp, cls, ver );                     \
    DECLARE_STREAMABLE_OPS( cls );                                  \
    DECLARE_STREAMABLE_CTOR( cls )

#define DECLARE_ABSTRACT_STREAMABLES	(		cls,
			ver
	)

Value:

DECLARE_CASTABLE;                                               \
    DECLARE_ABSTRACT_STREAMERS(cls, ver );                          \
    DECLARE_STREAMABLE_OPS( cls );                                  \
    DECLARE_STREAMABLE_CTOR( cls )

#define DECLARE_ABSTRACT_STREAMER	(		exp,
			cls,
			ver
	)

Value:

public:                                                             \
    class exp Streamer : public ::owl::TNewStreamer                        \
        {                                                           \
        public:                                                     \
                                                                    \
        Streamer( ::owl::TStreamableBase *obj );                           \
                                                                    \
        virtual ::owl::uint32 ClassVersion() const                         \
            { return ver; }                                         \
                                                                    \
        virtual void Write( ::owl::opstream& ) const;                      \
        virtual void *Read( ::owl::ipstream&, ::owl::uint32 ) const;              \
                                                                    \
        cls *GetObject() const                                      \
            {                                                       \
            return object;                                          \
            }                                                       \
                                                                    \
        private:                                                    \
            cls *object;                                            \
                                                                    \
        };                                                          \
    friend class exp Streamer;

#define DECLARE_ABSTRACT_STREAMERS	(		cls,
			ver
	)

Value:

public:                                                             \
    class Streamer : public ::owl::TNewStreamer                            \
        {                                                           \
        public:                                                     \
                                                                    \
        Streamer( ::owl::TStreamableBase *obj );                           \
                                                                    \
        virtual ::owl::uint32 ClassVersion() const                         \
            { return ver; }                                         \
                                                                    \
        virtual void Write( ::owl::opstream& ) const;                      \
        virtual void *Read( ::owl::ipstream&, ::owl::uint32 ) const;              \
                                                                    \
        cls *GetObject() const                                      \
            {                                                       \
            return object;                                          \
            }                                                       \
                                                                    \
        private:                                                    \
            cls *object;                                            \
                                                                    \
        };                                                          \
    friend class Streamer;

#define DECLARE_STREAMABLE	(		exp,
			cls,
			ver
	)

Value:

DECLARE_CASTABLE ;                                              \
    DECLARE_STREAMER( exp, cls, ver );                              \
    DECLARE_STREAMABLE_OPS( cls );                                  \
    DECLARE_STREAMABLE_CTOR( cls )

#define DECLARE_STREAMABLE_CTOR

(

cls

)

Value:

public:                                                             \
    cls ( ::owl::StreamableInit )

#define DECLARE_STREAMABLE_FROM_BASE	(		exp,
			cls,
			base
	)

Value:

DECLARE_CASTABLE;                                               \
    DECLARE_STREAMER_FROM_BASE( exp, cls, base );                   \
    DECLARE_STREAMABLE_OPS( cls );                                  \
    DECLARE_STREAMABLE_CTOR( cls )

#define DECLARE_STREAMABLE_FROM_BASES	(		cls,
			base
	)

Value:

DECLARE_CASTABLE;                                               \
    DECLARE_STREAMER_FROM_BASES(cls, base );                        \
    DECLARE_STREAMABLE_OPS( cls );                                  \
    DECLARE_STREAMABLE_CTOR( cls )

#define DECLARE_STREAMABLE_INLINES_I

(

cls

)

Value:

inline ::owl::ipstream& operator >> ( ::owl::ipstream& is, cls& cl )              \
    { return cls::readRef( is, cl ); }                              \
inline ::owl::ipstream& operator >> ( ::owl::ipstream& is, cls*& cl )             \
    { return cls::readPtr( is, cl ); }                              \
inline ::owl::opstream& operator << ( ::owl::opstream& os, const cls& cl )        \
    { return cls::writeRef( os, cl ); }                             \
inline ::owl::opstream& operator << ( ::owl::opstream& os, const cls* cl )        \
    { return cls::writePtr( os, cl ); }

#define DECLARE_STREAMABLE_OPS

(

cls

)

Value:

static ::owl::ipstream& readRef( ::owl::ipstream& is, cls& cl );                  \
friend inline ::owl::ipstream& operator >> ( ::owl::ipstream& is, cls& cl );      \
static ::owl::ipstream& readPtr( ::owl::ipstream& is, cls*& cl );                 \
friend inline ::owl::ipstream& operator >> ( ::owl::ipstream& is, cls*& cl );     \
static ::owl::opstream& writeRef( ::owl::opstream& is, const cls& cl );           \
friend inline ::owl::opstream& operator << ( ::owl::opstream& os, const cls& cl );\
static ::owl::opstream& writePtr( ::owl::opstream& is, const cls* cl );           \
friend inline ::owl::opstream& operator << ( ::owl::opstream& os, const cls* cl );

#define DECLARE_STREAMABLES	(		cls,
			ver
	)

Value:

DECLARE_CASTABLE ;                                              \
    DECLARE_STREAMERS(cls, ver );                                   \
    DECLARE_STREAMABLE_OPS( cls );                                  \
    DECLARE_STREAMABLE_CTOR( cls )

#define DECLARE_STREAMER	(		exp,
			cls,
			ver
	)

Value:

public:                                                             \
    class exp Streamer : public ::owl::TNewStreamer                \
        {                                                           \
        public:                                                     \
                                                                    \
        Streamer( ::owl::TStreamableBase *obj );                   \
                                                                    \
        virtual ::owl::uint32 ClassVersion() const                         \
            { return ver; }                                         \
                                                                    \
        virtual void Write( ::owl::opstream& ) const;              \
        virtual void *Read( ::owl::ipstream&, ::owl::uint32 ) const;      \
                                                                    \
        cls *GetObject() const                                      \
            {                                                       \
            return object;                                          \
            }                                                       \
                                                                    \
        static ::owl::TStreamer *Build( ::owl::TStreamableBase *obj ) \
            {                                                       \
            return new Streamer( obj ? obj : new cls(::owl::streamableInit) ); \
            }                                                       \
                                                                    \
        private:                                                    \
            cls *object;                                            \
                                                                    \
        };                                                          \
    friend class exp Streamer;

#define DECLARE_STREAMER_FROM_BASE	(		exp,
			cls,
			base
	)

Value:

public:                                                             \
    class exp Streamer : public base::Streamer                      \
        {                                                           \
        public:                                                     \
                                                                    \
        Streamer( ::owl::TStreamableBase *obj ) : base::Streamer(obj){}    \
                                                                    \
        cls *GetObject() const                                      \
            {                                                       \
            return object;                                          \
            }                                                       \
                                                                    \
        static ::owl::TStreamer *Build( ::owl::TStreamableBase *obj )             \
            {                                                       \
            return new Streamer( obj ? obj : new cls(::owl::streamableInit) ); \
            }                                                       \
                                                                    \
        private:                                                    \
            cls *object;                                            \
                                                                    \
        };                                                          \
    friend class exp Streamer;

#define DECLARE_STREAMER_FROM_BASES	(		cls,
			base
	)

Value:

public:                                                             \
    class Streamer : public base::Streamer                          \
        {                                                           \
        public:                                                     \
                                                                    \
        Streamer( ::owl::TStreamableBase *obj ) : base::Streamer(obj){} \
                                                                    \
        cls *GetObject() const                                      \
            {                                                       \
            return object;                                          \
            }                                                       \
                                                                    \
        static ::owl::TStreamer *Build( ::owl::TStreamableBase *obj ) \
            {                                                       \
            return new Streamer( obj ? obj : new cls(::owl::streamableInit) ); \
            }                                                       \
                                                                    \
        private:                                                    \
            cls *object;                                            \
                                                                    \
        };                                                          \
    friend class Streamer;

#define DECLARE_STREAMERS	(		cls,
			ver
	)

Value:

public:                                                             \
    class Streamer : public ::owl::TNewStreamer                    \
        {                                                           \
        public:                                                     \
                                                                    \
        Streamer( ::owl::TStreamableBase *obj );                   \
                                                                    \
        virtual ::owl::uint32 ClassVersion() const                         \
            { return ver; }                                         \
                                                                    \
        virtual void Write( ::owl::opstream& ) const;              \
        virtual void *Read( ::owl::ipstream&, ::owl::uint32 ) const;      \
                                                                    \
        cls *GetObject() const                                      \
            {                                                       \
            return object;                                          \
            }                                                       \
                                                                    \
        static ::owl::TStreamer *Build( ::owl::TStreamableBase *obj ) \
            {                                                       \
            return new Streamer( obj ? obj : new cls(::owl::streamableInit) ); \
            }                                                       \
                                                                    \
        private:                                                    \
            cls *object;                                            \
                                                                    \
        };                                                          \
    friend class Streamer;

#define IMPLEMENT_ABSTRACT_STREAMABLE

(

cls

)

Value:

IMPLEMENT_STREAMER( cls );                                          \
IMPLEMENT_STREAMABLE_CTOR( cls );                                   \
IMPLEMENT_STREAMABLE_POINTER( cls )

#define IMPLEMENT_ABSTRACT_STREAMABLE1	(		cls,
			base1
	)

Value:

IMPLEMENT_STREAMER( cls );                                          \
IMPLEMENT_STREAMABLE_CTOR1( cls, base1 );                           \
IMPLEMENT_STREAMABLE_POINTER( cls )

#define IMPLEMENT_ABSTRACT_STREAMABLE2	(		cls,
			base1,
			base2
	)

Value:

IMPLEMENT_STREAMER( cls );                                          \
IMPLEMENT_STREAMABLE_CTOR2( cls, base1, base2 );                    \
IMPLEMENT_STREAMABLE_POINTER( cls )

#define IMPLEMENT_ABSTRACT_STREAMABLE3	(		cls,
			base1,
			base2,
			base3
	)

Value:

IMPLEMENT_STREAMER( cls );                                          \
IMPLEMENT_STREAMABLE_CTOR3( cls, base1, base2, base3 );             \
IMPLEMENT_STREAMABLE_POINTER( cls )

#define IMPLEMENT_ABSTRACT_STREAMABLE4	(		cls,
			base1,
			base2,
			base3,
			base4
	)

Value:

IMPLEMENT_STREAMER( cls );                                          \
IMPLEMENT_STREAMABLE_CTOR4( cls, base1, base2, base3, base4 );      \
IMPLEMENT_STREAMABLE_POINTER( cls )

#define IMPLEMENT_ABSTRACT_STREAMABLE5	(		cls,
			base1,
			base2,
			base3,
			base4,
			base5
	)

Value:

IMPLEMENT_STREAMER( cls );                                          \
IMPLEMENT_STREAMABLE_CTOR5( cls, base1, base2, base3, base4, base5 );\
IMPLEMENT_STREAMABLE_POINTER( cls )

#define IMPLEMENT_STREAMABLE

(

cls

)

Value:

IMPLEMENT_STREAMABLE_CLASS( cls );                                  \
IMPLEMENT_ABSTRACT_STREAMABLE( cls )

#define IMPLEMENT_STREAMABLE1	(		cls,
			base1
	)

Value:

IMPLEMENT_STREAMABLE_CLASS( cls );                                  \
IMPLEMENT_ABSTRACT_STREAMABLE1( cls, base1 )

#define IMPLEMENT_STREAMABLE2	(		cls,
			base1,
			base2
	)

Value:

IMPLEMENT_STREAMABLE_CLASS( cls );                                  \
IMPLEMENT_ABSTRACT_STREAMABLE2( cls, base1, base2 )

#define IMPLEMENT_STREAMABLE3	(		cls,
			base1,
			base2,
			base3
	)

Value:

IMPLEMENT_STREAMABLE_CLASS( cls );                                  \
IMPLEMENT_ABSTRACT_STREAMABLE3( cls, base1, base2, base3 )

#define IMPLEMENT_STREAMABLE4	(		cls,
			base1,
			base2,
			base3,
			base4
	)

Value:

IMPLEMENT_STREAMABLE_CLASS( cls );                                  \
IMPLEMENT_ABSTRACT_STREAMABLE4( cls, base1, base2, base3, base4 )

#define IMPLEMENT_STREAMABLE5	(		cls,
			base1,
			base2,
			base3,
			base4,
			base5
	)

Value:

IMPLEMENT_STREAMABLE_CLASS( cls );                                  \
IMPLEMENT_ABSTRACT_STREAMABLE5( cls, base1, base2, base3, base4, base5 )

#define IMPLEMENT_STREAMABLE_CTOR2	(		cls,
			base1,
			base2
	)

Value:

cls::cls ( ::owl::StreamableInit ) :                                       \
    base1 ( ::owl::streamableInit ),                                       \
    base2 ( ::owl::streamableInit ) {}

#define IMPLEMENT_STREAMABLE_CTOR3	(		cls,
			base1,
			base2,
			base3
	)

Value:

cls::cls ( ::owl::StreamableInit ) :                                       \
    base1 ( ::owl::streamableInit ),                                       \
    base2 ( ::owl::streamableInit ),                                       \
    base3 ( ::owl::streamableInit ) {}

#define IMPLEMENT_STREAMABLE_CTOR4	(		cls,
			base1,
			base2,
			base3,
			base4
	)

Value:

cls::cls ( ::owl::StreamableInit ) :                                       \
    base1 ( ::owl::streamableInit ),                                       \
    base2 ( ::owl::streamableInit ),                                       \
    base3 ( ::owl::streamableInit ),                                       \
    base4 ( ::owl::streamableInit ) {}

#define IMPLEMENT_STREAMABLE_CTOR5	(		cls,
			base1,
			base2,
			base3,
			base4,
			base5
	)

Value:

cls::cls ( ::owl::StreamableInit ) :                                       \
    base1 ( ::owl::streamableInit ),                                       \
    base2 ( ::owl::streamableInit ),                                       \
    base3 ( ::owl::streamableInit ),                                       \
    base4 ( ::owl::streamableInit ),                                       \
    base5 ( ::owl::streamableInit ) {}

#define IMPLEMENT_STREAMABLE_FROM_BASE	(		cls,
			base1
	)

Value:

IMPLEMENT_STREAMABLE_CLASS( cls );                                  \
IMPLEMENT_STREAMABLE_CTOR1( cls, base1 );                           \
IMPLEMENT_STREAMABLE_POINTER( cls )

#define IMPLEMENT_STREAMABLE_POINTER_IMPL	(		template_prefix,
			cls
	)

Value:

template_prefix owl::ipstream& cls::readPtr(::owl::ipstream& is, cls*& cl)\
  {::owl::TStreamableBase *t = 0; cl = dynamic_cast<cls*>(is.readObjectPointer(t)); return is;}\
  \
  template_prefix owl::ipstream& cls::readRef(::owl::ipstream& is, cls& cl)\
  {::owl::TStreamableBase* p = &cl; is.readObject(p); return is;}\
  \
  template_prefix owl::opstream& cls::writeRef(::owl::opstream& os, const cls& cl)\
  {os.writeObject(&cl); return os;}\
  \
  template_prefix owl::opstream& cls::writePtr(::owl::opstream& os, const cls* cl)\
  {os.writeObjectPointer(cl); return os;}

#define IMPLEMENT_STREAMER

(

cls

)

Value:

cls::Streamer::Streamer( ::owl::TStreamableBase *obj ) :                   \
    ::owl::TNewStreamer(obj), object(TYPESAFE_DOWNCAST(obj,cls)){}

#define WM_OWLCREATETTIP   (WM_VBXBASE - 5)

Notify gadget window to create tooltips.

#define WM_OWLFRAMESIZE   (WM_VBXBASE - 2)

Notify children of frame resizing.

#define WM_OWLHELPHIT   (WM_VBXBASE - 6)

Notify Help manager with hit point.

#define WM_OWLSLIPDBLCLK   (WM_VBXBASE - 3)

Notify parent of user dblclick of edge slip.

#define WM_OWLWINDOWDOCKED   (WM_VBXBASE - 4)

Notify window it was [un]docked/reparented.

---

Typedef Documentation

typedef uint owl::TMsgId

Message ID type.

typedef WPARAM owl::TParam1

Type of first message parameter (uint)

typedef LPARAM owl::TParam2

Type of second message parameter (uint32)

typedef LRESULT owl::TResult

Returned result of a message.

---

Enumeration Type Documentation

enum owl::StreamableInit

\ class TStreamable

This is the base class from which all streamable objects must be

derived.

enum owl::TAutoDelete

Flag for Handle ctors to control Handle deletion in dtor.

---

Function Documentation

_OWLCTOR owl::fpbase::fpbase

(

)

[inline]

Creates a buffered fpbase object.

References owl::pstream::init().

_OWLCTOR owl::fpbase::fpbase	(	LPCSTR	name,
		int	omode,
		int	prot = openprot
	)		[inline]

Creates a buffered fpbase object. It opens the file specified by name, using the mode omode and protection prot; and attaches this file to the stream.

References owl::pstream::init(), and owl::fpbase::open().

_OWLCTOR owl::ifpstream::ifpstream

(

)

[inline]

Creates a buffered ifpstream object using a default buffer.

_OWLCTOR owl::ifpstream::ifpstream	(	LPCSTR	name,
		int	omode = std::ios::in,
		int	prot = fpbase::openprot
	)		[inline]

Creates a buffered ifpstream object. It opens the file specified by name using the mode mode and protection prot; and attaches this file to the stream.

_OWLCTOR owl::ipstream::ipstream

(

std::streambuf *

sb

)

[inline]

Creates a buffered ipstream with the given buffer. The state is set to 0.

References owl::pstream::init(), and owl::ipstream::readVersion().

_OWLCTOR owl::ipstream::ipstream

(

)

[inline, protected]

Creates a buffered ipstream without initializing the buffer pointer, bp. Use psteam::init to set the buffer and state.

References owl::ipstream::readVersion().

_OWLCTOR owl::ofpstream::ofpstream

(

)

[inline]

Creates a buffered ofpstream object using a default buffer.

_OWLCTOR owl::ofpstream::ofpstream	(	LPCSTR	name,
		int	omode = std::ios::out,
		int	prot = fpbase::openprot
	)		[inline]

Creates a buffered ofpstream object. It opens the file specified by name, using the mode mode, and protection prot; and attaches this file to the stream

_OWLCTOR owl::pstream::pstream

(

std::streambuf *

sb

)

[inline]

Creates a buffered pstream with the given buffer. The state is set to 0.

References owl::pstream::init().

_OWLCTOR owl::pstream::pstream

(

)

[inline, protected]

Creates a pstream without initializing the buffer pointer bp or state. Use init to set the buffer and setstate to set the state.

int owl::pstream::bad

(

)

const [inline]

Returns nonzero if an error occurs.

void owl::pstream::clear

(

int

i = 0

)

[inline]

Sets the stream state to the given value (defaults to 0).

int owl::pstream::eof

(

)

const [inline]

Returns nonzero on end of stream.

int owl::pstream::fail

(

)

const [inline]

Returns nonzero if a previous stream operation failed.

TStreamableBase * owl::ipstream::find

(

P_id_type

id

)

[inline]

Returns a pointer to the object corresponding to Id.

P_id_type owl::opstream::findObject

(

TStreamableBase *

adr

)

[inline]

Returns the type ID for the object pointed to by adr.

P_id_type owl::opstream::findVB

(

TStreamableBase *

adr

)

[inline]

Returns a pointer to the virtual base.

uint32 owl::ipstream::getVersion

(

)

const [inline]

Returns the object version number.

int owl::pstream::good

(

)

const [inline]

Returns nonzero if no error states have been recorded for the stream (that is, no errors have occurred).

void owl::pstream::init

(

std::streambuf *

sbp

)

[inline, protected]

The init member function initializes the stream and sets state to 0 and bp to sbp.

void owl::ifpstream::open	(	LPCSTR	name,
		int	omode = std::ios::in,
		int	prot = fpbase::openprot
	)		[inline]

It opens the named file in the given mode (app, ate, in, out, binary, trunc, nocreate, or noreplace) and protection. The default mode for ifpstream is ios::in (input) with openprot protection. The opened file is attached to this stream.

Reimplemented from owl::fpbase.

References owl::ipstream::readVersion().

void owl::ofpstream::open	(	LPCSTR	name,
		int	omode = std::ios::out,
		int	prot = fpbase::openprot
	)		[inline]

Opens the named file in the given mode (app, ate, in, out, binary, trunc, nocreate, or noreplace) and protection. The default mode for ofpstream is ios::out (output) with openprot protection. The opened file is attached to this stream.

Reimplemented from owl::fpbase.

owl::pstream::operator void *

(

)

const [inline]

Converts to a void pointer.

References owl::pstream::fail().

int owl::pstream::operator!

(

)

const [inline]

Overloads the NOT operator. Returns 0 if the operation has failed (that is, if pstream::fail returned nonzero); otherwise, returns nonzero.

References owl::pstream::fail().

opstream & owl::operator<<	(	opstream &	ps,
		unsigned int	i
	)		[inline]

This friend operator of opstream inserts (writes) the given argument to the given ipstream object. The data type of the argument determines the form of write operation employed.

References owl::opstream::writeWord32().

opstream & owl::operator<<	(	opstream &	ps,
		signed long	l
	)		[inline]

This friend operator of opstream inserts (writes) the given argument to the given ipstream object. The data type of the argument determines the form of write operation employed.

References owl::opstream::writeBytes().

opstream & owl::operator<<	(	opstream &	ps,
		unsigned long	l
	)		[inline]

This friend operator of opstream inserts (writes) the given argument to the given ipstream object. The data type of the argument determines the form of write operation employed.

References owl::opstream::writeBytes().

opstream & owl::operator<<	(	opstream &	ps,
		uint8	ch
	)		[inline]

This friend operator of opstream inserts (writes) the given argument to the given ipstream object. The data type of the argument determines the form of write operation employed.

References owl::opstream::writeByte().

opstream & owl::operator<<	(	opstream &	ps,
		int8	ch
	)		[inline]

opstream, a specialized derivative of pstream, is the base class for writing (inserting) streamable objects.

This friend operator of opstream inserts (writes) the given argument to the given ipstream object. The data type of the argument determines the form of write operation employed.

References owl::opstream::writeByte().

opstream & owl::operator<<	(	opstream &	ps,
		char	ch
	)		[inline]

This friend operator of opstream inserts (writes) the given argument to the given ipstream object. The data type of the argument determines the form of write operation employed.

References owl::opstream::writeByte().

opstream & owl::operator<<	(	opstream &	ps,
		signed short	sh
	)		[inline]

This friend operator of opstream inserts (writes) the given argument to the given ipstream object. The data type of the argument determines the form of write operation employed.

References owl::opstream::writeWord16().

opstream & owl::operator<<	(	opstream &	ps,
		unsigned short	sh
	)		[inline]

This friend operator of opstream inserts (writes) the given argument to the given ipstream object. The data type of the argument determines the form of write operation employed.

References owl::opstream::writeWord16().

opstream & owl::operator<<	(	opstream &	ps,
		bool	b
	)		[inline]

This friend operator of opstream inserts (writes) the given argument to the given ipstream object. The data type of the argument determines the form of write operation employed.

References owl::opstream::writeWord32().

opstream & owl::operator<<	(	opstream &	ps,
		float	f
	)		[inline]

This friend operator of opstream inserts (writes) the given argument to the given ipstream object. The data type of the argument determines the form of write operation employed.

References owl::opstream::writeBytes().

opstream & owl::operator<<	(	opstream &	ps,
		double	d
	)		[inline]

This friend operator of opstream inserts (writes) the given argument to the given ipstream object. The data type of the argument determines the form of write operation employed.

References owl::opstream::writeBytes().

opstream & owl::operator<<	(	opstream &	ps,
		long double	l
	)		[inline]

This friend operator of opstream inserts (writes) the given argument to the given ipstream object. The data type of the argument determines the form of write operation employed.

References owl::opstream::writeBytes().

opstream & owl::operator<<	(	opstream &	ps,
		signed int	i
	)		[inline]

This friend operator of opstream inserts (writes) the given argument to the given ipstream object. The data type of the argument determines the form of write operation employed.

References owl::opstream::writeWord32().

ipstream & owl::operator>>	(	ipstream &	ps,
		signed short &	sh
	)		[inline]

This friend operator of ipstream extracts (reads) from the ipstream ps, to the given argument. It returns a reference to the stream that lets you chain >> operations in the usual way. The data type of the argument determines how the read is performed. For example, reading a signed char is implemented using readByte.

References owl::ipstream::readWord16().

ipstream & owl::operator>>	(	ipstream &	ps,
		float &	f
	)		[inline]

This friend operator of ipstream extracts (reads) from the ipstream ps, to the given argument. It returns a reference to the stream that lets you chain >> operations in the usual way. The data type of the argument determines how the read is performed. For example, reading a signed char is implemented using readByte.

References owl::ipstream::readBytes().

ipstream & owl::operator>>	(	ipstream &	ps,
		double &	d
	)		[inline]

This friend operator of ipstream extracts (reads) from the ipstream ps, to the given argument. It returns a reference to the stream that lets you chain >> operations in the usual way. The data type of the argument determines how the read is performed. For example, reading a signed char is implemented using readByte.

References owl::ipstream::readBytes().

ipstream & owl::operator>>	(	ipstream &	ps,
		unsigned short &	sh
	)		[inline]

This friend operator of ipstream extracts (reads) from the ipstream ps, to the given argument. It returns a reference to the stream that lets you chain >> operations in the usual way. The data type of the argument determines how the read is performed. For example, reading a signed char is implemented using readByte.

References owl::ipstream::readWord16().

ipstream & owl::operator>>	(	ipstream &	ps,
		signed int &	i
	)		[inline]

This friend operator of ipstream extracts (reads) from the ipstream ps, to the given argument. It returns a reference to the stream that lets you chain >> operations in the usual way. The data type of the argument determines how the read is performed. For example, reading a signed char is implemented using readByte.

References owl::ipstream::readWord().

ipstream & owl::operator>>	(	ipstream &	ps,
		signed long &	l
	)		[inline]

This friend operator of ipstream extracts (reads) from the ipstream ps, to the given argument. It returns a reference to the stream that lets you chain >> operations in the usual way. The data type of the argument determines how the read is performed. For example, reading a signed char is implemented using readByte.

References owl::ipstream::readBytes().

ipstream & owl::operator>>	(	ipstream &	ps,
		int8 &	ch
	)		[inline]

Base class for reading streamable objects

This friend operator of ipstream extracts (reads) from the ipstream ps, to the given argument. It returns a reference to the stream that lets you chain >> operations in the usual way. The data type of the argument determines how the read is performed. For example, reading a signed char is implemented using readByte.

References owl::ipstream::readByte().

ipstream & owl::operator>>	(	ipstream &	ps,
		unsigned int &	i
	)		[inline]

This friend operator of ipstream extracts (reads) from the ipstream ps, to the given argument. It returns a reference to the stream that lets you chain >> operations in the usual way. The data type of the argument determines how the read is performed. For example, reading a signed char is implemented using readByte.

References owl::ipstream::readWord().

ipstream & owl::operator>>	(	ipstream &	is,
		tstring &	str
	)

This operator of ipstream extracts (reads) from the ipstream is, to the string str. It returns a reference to the stream that lets you chain >> operations in the usual way.

References owl::pstream::good(), and owl::ipstream::readBytes().

ipstream & owl::operator>>	(	ipstream &	ps,
		bool &	b
	)		[inline]

This friend operator of ipstream extracts (reads) from the ipstream ps, to the given argument. It returns a reference to the stream that lets you chain >> operations in the usual way. The data type of the argument determines how the read is performed. For example, reading a signed char is implemented using readByte.

References owl::ipstream::readWord32().

ipstream & owl::operator>>	(	ipstream &	ps,
		uint8 &	ch
	)		[inline]

This friend operator of ipstream extracts (reads) from the ipstream ps, to the given argument. It returns a reference to the stream that lets you chain >> operations in the usual way. The data type of the argument determines how the read is performed. For example, reading a signed char is implemented using readByte.

References owl::ipstream::readByte().

ipstream & owl::operator>>	(	ipstream &	ps,
		long double &	l
	)		[inline]

This friend operator of ipstream extracts (reads) from the ipstream ps, to the given argument. It returns a reference to the stream that lets you chain >> operations in the usual way. The data type of the argument determines how the read is performed. For example, reading a signed char is implemented using readByte.

References owl::ipstream::readBytes().

ipstream & owl::operator>>	(	ipstream &	ps,
		unsigned long &	l
	)		[inline]

This friend operator of ipstream extracts (reads) from the ipstream ps, to the given argument. It returns a reference to the stream that lets you chain >> operations in the usual way. The data type of the argument determines how the read is performed. For example, reading a signed char is implemented using readByte.

References owl::ipstream::readBytes().

ipstream & owl::operator>>	(	ipstream &	ps,
		char &	ch
	)		[inline]

This friend operator of ipstream extracts (reads) from the ipstream ps, to the given argument. It returns a reference to the stream that lets you chain >> operations in the usual way. The data type of the argument determines how the read is performed. For example, reading a signed char is implemented using readByte.

References owl::ipstream::readByte().

std::streambuf * owl::pstream::rdbuf

(

)

const [inline]

Returns the pb pointer to the buffer assigned to the stream.

std::filebuf * owl::ifpstream::rdbuf

(

)

[inline]

Returns a pointer to the current file buffer.

Reimplemented from owl::fpbase.

std::filebuf * owl::ofpstream::rdbuf

(

)

[inline]

Returns a pointer to the current file buffer.

Reimplemented from owl::fpbase.

std::filebuf * owl::fpbase::rdbuf

(

)

[inline]

Returns a pointer to the current file buffer.

Reimplemented in owl::ifpstream, and owl::ofpstream.

int owl::pstream::rdstate

(

)

const [inline]

Returns the current state value.

void owl::opstream::registerObject

(

TStreamableBase *

adr

)

[inline]

Registers the class of the object pointed to by adr.

void owl::ipstream::registerObject

(

TStreamableBase *

adr

)

[inline]

Registers the object pointed to by adr.

void owl::opstream::registerVB

(

TStreamableBase *

adr

)

[inline]

Registers a virtual base class.

void owl::pstream::setstate

(

int

b

)

[inline, protected]

Updates the state data member with state |= (b & 0xFF).

void owl::opstream::writeSuffix

(

const TStreamableBase *

)

[inline, protected]

Writes the class name suffix to the stream. The << operator uses this function to write a prefix and suffix around the data written with writeData. The prefix/suffix is used to ensure type-safe stream I/O.

References owl::opstream::writeByte().

void owl::opstream::writeWord

(

uint32

word32

)

[inline]

Writes the 32-bit word us to the stream.

References owl::opstream::writeWord32().