// This is -*- C++ -*-

/* 
 * types.h
 *
 * Copyright 1998 Karl E. Nelson
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 */
#ifndef _GDKMM_TYPES_H_
#define _GDKMM_TYPES_H_

#include <gdk/gdk.h>
#include <gdk--config.h>

#include <string>

// we need memset, memcpy
#include <string.h>

/*********************************************************************
***** Version macros
*********************************************************************/
/* we need features to get the gdk version numbers. */
#include <gtk/gtkfeatures.h>

/* macro for controlling version numbers */
#ifndef _GDK_VERSION
// this one is old.  Will be replaced with more flexable below.
#define _GDK_VERSION(major,minor) ((GTK_MAJOR_VERSION==major)&&(GTK_MINOR_VERSION==minor))

#define GDK_VERSION_GT(major,minor) ((GTK_MAJOR_VERSION>major)||(GTK_MAJOR_VERSION==major)&&(GTK_MINOR_VERSION>minor))
#define GDK_VERSION_GE(major,minor) ((GTK_MAJOR_VERSION>major)||(GTK_MAJOR_VERSION==major)&&(GTK_MINOR_VERSION>=minor))
#define GDK_VERSION_EQ(major,minor) ((GTK_MAJOR_VERSION==major)&&(GTK_MINOR_VERSION==minor))
#define GDK_VERSION_NE(major,minor) ((GTK_MAJOR_VERSION!=major)||(GTK_MINOR_VERSION!=minor))
#define GDK_VERSION_LE(major,minor) ((GTK_MAJOR_VERSION<major)||(GTK_MAJOR_VERSION==major)&&(GTK_MINOR_VERSION<=minor))
#define GDK_VERSION_LT(major,minor) ((GTK_MAJOR_VERSION<major)||(GTK_MAJOR_VERSION==major)&&(GTK_MINOR_VERSION<minor))

#define GDK_VERSION_GT_MICRO(major,minor,micro) \
  ((GTK_MAJOR_VERSION>major)|| \
  (GTK_MAJOR_VERSION==major)&&(GTK_MINOR_VERSION>minor)||\
  (GTK_MAJOR_VERSION==major)&&(GTK_MINOR_VERSION==minor)&&(GTK_MICRO_VERSION>micro))

#endif

/*********************************************************************
***** Forward declarations
*********************************************************************/

/* Handles */
class Gdk_Drawable;
class Gdk_Bitmap;
class Gdk_Colormap;
class Gdk_Image;
class Gdk_Pixmap;
class Gdk_Window;
class Gdk_Font;
class Gdk_GC;
class Gdk_Visual; 
class Gdk_Cursor;


/* types */
typedef GdkAtom 		Gdk_Atom;
#if GDK_VERSION_GT(1,0)
typedef GdkWChar 		Gdk_WChar;
#endif


/* Stucts */
class Gdk_Color;
class Gdk_ColorContextDither;
class Gdk_ColorContext;
class Gdk_GCValues;
#if GDK_VERSION_GT(1,0)
class Gdk_Geometry;
class Gdk_ICAttr;
#endif
class Gdk_Image; 
class Gdk_Point;
class Gdk_Points;
class Gdk_Rectangle;
class Gdk_Segment;
class Gdk_Segments;
class Gdk_WindowAttr;

class Gdk_DeviceKey;
class Gdk_DeviceInfo;
class Gdk_TimeCoord;
class Gdk_Region;

// OBSOLETE - name consistancy
typedef Gdk_ColorContextDither 	Gdk_Color_Context_Dither;
typedef Gdk_ColorContext 	Gdk_Color_Context;
typedef Gdk_TimeCoord 		Gdk_Time_Coord;
typedef Gdk_WindowAttr 		Gdk_Window_Attr;
typedef Gdk_DeviceKey 		Gdk_Device_Key;
typedef Gdk_GCValues 		Gdk_GC_Values;
typedef Gdk_DeviceInfo 		Gdk_Device_Info;
#if GDK_VERSION_GT(1,0)
typedef GdkWChar 		Gdk_W_Char;
#endif


/* Events - We need a better (light) wrapper, so unwrapped for now */
//typedef GdkEventAny		Gdk_EventAny;
//typedef GdkEventExpose 	Gdk_EventExpose;
//typedef GdkEventNoExpose	Gdk_EventNoExpose;
//typedef GdkEventVisibility	Gdk_EventVisibility;
//typedef GdkEventMotion	Gdk_EventMotion;
//typedef GdkEventButton	Gdk_EventButton;
//typedef GdkEventKey		Gdk_EventKey;
//typedef GdkEventFocus		Gdk_EventFocus;
//typedef GdkEventCrossing	Gdk_EventCrossing;
//typedef GdkEventConfigure	Gdk_EventConfigure;
//typedef GdkEventProperty	Gdk_EventProperty;
//typedef GdkEventSelection	Gdk_EventSelection;
//typedef GdkEventProximity	Gdk_EventProximity;
//#if GDK_VERSION_LE(1,0)
//typedef GdkEventOther		Gdk_EventOther;
//typedef GdkEventDragBegin	Gdk_EventDragBegin;
//typedef GdkEventDragRequest	Gdk_EventDragRequest;
//typedef GdkEventDropEnter	Gdk_EventDropEnter;
//typedef GdkEventDropDataAvailable Gdk_EventDropDataAvailable;
//typedef GdkEventDropLeave	Gdk_EventDropLeave;
//#else
//typedef GdkEventDND           Gdk_EventDND;
//#endif
//typedef GdkEventClient	Gdk_EventClient;
//typedef GdkEvent 		Gdk_Event;


/* DND */
#if GDK_VERSION_GT(1,0)
/* enum */
//typedef GdkDragAction		Gdk_DragAction;
//typedef GdkDragProtocol 	Gdk_DragProtocol;
/* struct */
class Gdk_DragContext;
// Obsolete
typedef Gdk_DragContext         Gdk_Drag_Context;
#endif


/* Enums - We need a better encapsulation for Enums*/
//typedef GdkWindowType			Gdk_WindowType;
//typedef GdkWindowClass		Gdk_WindowClass;
//typedef GdkImageType			Gdk_ImageType;
//typedef GdkVisualType			Gdk_VisualType;
//typedef GdkFontType			Gdk_FontType;
//typedef GdkWindowAttributesType	Gdk_WindowAttributesType;
//typedef GdkWindowHints		Gdk_WindowHints;
//typedef GdkFunction			Gdk_Function;
//typedef GdkFill			Gdk_Fill;
//typedef GdkFillRule			Gdk_FillRule;
//typedef GdkLineStyle			Gdk_LineStyle;
//typedef GdkCapStyle			Gdk_CapStyle;
//typedef GdkJoinStyle			Gdk_JoinStyle;
//typedef GdkCursorType			Gdk_CursorType;
//typedef GdkFilterReturn		Gdk_FilterReturn;
//typedef GdkVisibilityState		Gdk_VisibilityState;
//typedef GdkEventType			Gdk_EventType;
//typedef GdkEventMask			Gdk_EventMask;
//typedef GdkNotifyType			Gdk_NotifyType;
//typedef GdkModifierType		Gdk_ModifierType;
//typedef GdkSubwindowMode		Gdk_SubwindowMode;
//typedef GdkInputCondition		Gdk_InputCondition;
//typedef GdkStatus			Gdk_Status;
//typedef GdkByteOrder			Gdk_ByteOrder;
//typedef GdkGCValuesMask		Gdk_GCValuesMask;
//typedef GdkSelection			Gdk_Selection;
//typedef GdkPropertyState		Gdk_PropertyState;
//typedef GdkPropMode			Gdk_PropMode;
//#if GDK_VERSION_LE(1,0)
//typedef GdkDndType			Gdk_DndType;
//#endif
//typedef GdkInputSource		Gdk_InputSource;
//typedef GdkInputMode			Gdk_InputMode;
//typedef GdkAxisUse			Gdk_AxisUse;
//typedef GdkTarget			Gdk_Target;
//typedef GdkSelectionType		Gdk_SelectionType;
//typedef GdkExtensionMode		Gdk_ExtensionMode;
//typedef GdkIMStyle			Gdk_IMStyle;
//typedef GdkWMDecoration		Gdk_WMDecoration;
//typedef GdkWMFunction			Gdk_WM_Function;
//typedef GdkColorContextMode		Gdk_ColorContextMode;
//typedef GdkOverlapType		Gdk_OverlapType;


/*********************************************************************
***** Implementations 
*********************************************************************/
/* Templates */

//: Object used as base to wrap all of the gdk structures
//- Gdk passes everything as pointers to structures.  To encapsulate
//- this and protect against bad pointers, we will wrap them to
//- a class with value semantics, but with a pointer access.
//- It can be directly changed back to the gdk equivent (a pointer).
//- It is considered a private template.
template <class GdkObj>
  class Gdk_Obj
    {
     public:
       typedef GdkObj BaseObjectType;
     protected:
       bool null_;
       GdkObj obj_;

       //: Initialize and zero memory
       Gdk_Obj():null_(0)
         {
         }

     public:
       Gdk_Obj(GdkObj *obj):null_(obj==NULL)
         {
          if (null_) 
            return;
          if (&obj_!=obj)
            memcpy(&obj_,obj,sizeof(GdkObj));
         }

       Gdk_Obj(const Gdk_Obj& obj):null_(0)
         {
          if (this!=&obj)
            memcpy(&obj_,&obj.obj_,sizeof(GdkObj));
         }

       ~Gdk_Obj() {};

       operator GdkObj* ()
         {
          if (null_) 
            return 0;
          return &obj_;
         }

       operator GdkObj* () const
         {
          if (null_) 
            return 0;
          return &obj_;
         }

       GdkObj* gdkobj()
         {return &obj_;}
       const GdkObj* gdkobj() const
         {return &obj_;}

       GdkObj* operator -> ()
         {return &obj_;}
       const GdkObj* operator -> () const
         {return &obj_;}
    
    }; 

template <class GdkObj>
  class Gdk_Handle
    {
     public:
       typedef GdkObj BaseObjectType;
     private:
       void *operator new(size_t);
     protected:
       GdkObj* obj_;

       //: Create an unconnect obj.
       Gdk_Handle():obj_(0) {}

       //: Initialize from gdk
       Gdk_Handle(GdkObj* obj):obj_(obj) {}

       //: Initialize from gdk--
       Gdk_Handle(const Gdk_Handle &obj):obj_(obj.obj_) {}

     public:
       void *operator new(size_t s,void* v) {return ::operator new(s,v);}

       ~Gdk_Handle() {}
       
       GdkObj* gdkobj() const
         {return obj_;}

       //: convert back to gdk object.
       operator GdkObj* () const
         {return obj_;}

       //: Is the handle connected?
       bool connected() const
         {return (obj_!=0);}

       //: Are these the same handle?
       bool operator == (const Gdk_Handle &obj) const
         {return (obj_==obj.obj_);}

       //: Are these different handles?
       bool operator != (const Gdk_Handle &obj) const
         {return (obj_!=obj.obj_);}

#if 0
       //: Copy a handle.
       virtual Gdk_Handle& operator= (const Gdk_Handle& obj)
         {if (*this!=obj)
            {
             unref();
             obj_=obj.obj_;
             ref();
            }
          return *this;
         }
  
      //: Free a handle. (this used to be free(), but changed 
      //: it because clash with malloc debuggers)
      virtual void release()
         {unref();}
#endif
    };

//: Remove a const and make gdk+.
//- C++ can't do a const_cast and use the converter to gdk
//- at the same time.  Therefore, we must show it the way.
template <class GdkObj>
  inline typename GdkObj::BaseObjectType* gdk_const_cast(const GdkObj& obj) 
    {return const_cast<typename GdkObj::BaseObjectType*>(obj.gdkobj());}

/* simple wrappers */

class Gdk_ColorContextDither	:public Gdk_Obj<GdkColorContextDither> {};
class Gdk_ColorContext		:public Gdk_Obj<GdkColorContext> {};
class Gdk_GCValues		:public Gdk_Obj<GdkGCValues> {};
#if GDK_VERSION_GT(1,0)
class Gdk_Geometry		:public Gdk_Obj<GdkGeometry> {};
class Gdk_ICAttr		:public Gdk_Obj<GdkICAttr> {};
class Gdk_DragContext		:public Gdk_Obj<GdkDragContext> 
{
public:
  Gdk_DragContext () {};
  Gdk_DragContext ( Gdk_DragContext &x ) : 
    Gdk_Obj<GdkDragContext> ( x ) {}
  Gdk_DragContext ( GdkDragContext *x ):
    Gdk_Obj<GdkDragContext> ( x ) {}
};
#endif
class Gdk_WindowAttr		:public Gdk_Obj<GdkWindowAttr> {};
class Gdk_DeviceKey		:public Gdk_Obj<GdkDeviceKey> {};
class Gdk_DeviceInfo		:public Gdk_Obj<GdkDeviceInfo> {};
class Gdk_TimeCoord		:public Gdk_Obj<GdkTimeCoord> {};
class Gdk_Region		:public Gdk_Obj<GdkRegion> {};

/* Color */
#include <gdk--/color.h>

class Gdk_Point: public Gdk_Obj<GdkPoint>
  {
   public:
       // for convenience
       operator GdkPoint () const {
	   return obj_;
       }

     Gdk_Point()
       :Gdk_Obj<GdkPoint>() {}
     Gdk_Point(GdkPoint *pt)
       :Gdk_Obj<GdkPoint>(pt) {}
     Gdk_Point(const Gdk_Point& pt)
       :Gdk_Obj<GdkPoint>(pt) {}
     Gdk_Point(gint x,gint y)
       {obj_.x=x;
        obj_.y=y;
       }
     ~Gdk_Point();
  };

class Gdk_Points 
  {
    protected:
      GdkPoint *points_;
      int       size_;
      bool      owned_;

      // block assignment
      Gdk_Points& operator= (const Gdk_Points&);

      void a_alloc(size_t size);
      template <class Iterator>
      void a_dup(Iterator b, Iterator e) ;

    public:
      operator GdkPoint *() const { return points_; }
      int size() const            { return size_; }

      Gdk_Points(GdkPoint * points, int size);
      Gdk_Points(Gdk_Point * points, int size);
      ~Gdk_Points();

#ifndef GTKMM_CXX_AMBIGUOUS_TEMPLATES
      template <class Container>
      Gdk_Points(const Container & c) 
        {
          a_dup(c.begin(), c.end());
        }
#else
      Gdk_Points(const vector<Gdk_Point> & c) { a_dup(c.begin(), c.end()); }
      Gdk_Points(const list<Gdk_Point> & c) { a_dup(c.begin(), c.end()); }
      Gdk_Points(const vector<GdkPoint> & c) { a_dup(c.begin(), c.end()); }
      Gdk_Points(const list<GdkPoint> & c) { a_dup(c.begin(), c.end()); }
#endif
      template <class Iterator>
      Gdk_Points(Iterator b,Iterator e) { a_dup(b, e); }
  };

template <class Iterator>
void Gdk_Points::a_dup(Iterator b,Iterator e)
  {
    Iterator iter;

    for(iter = b, size_ = 0; iter != e; ++iter, ++size_);

    a_alloc(size_);

    unsigned int i;
    for(iter = b, i = 0; iter != e; ++iter, ++i)
        points_[i] = *iter;
  }


class Gdk_Rectangle:public Gdk_Obj<GdkRectangle>
  {
   public:
     Gdk_Rectangle()
       :Gdk_Obj<GdkRectangle>() {}
     Gdk_Rectangle(GdkRectangle* rect)
       :Gdk_Obj<GdkRectangle>(rect) {}
     Gdk_Rectangle(const Gdk_Rectangle& rect)
       :Gdk_Obj<GdkRectangle>(rect) {}
     Gdk_Rectangle(gint x, gint y, gint w, gint h)
       :Gdk_Obj<GdkRectangle>()
       {obj_.x=x;
        obj_.y=y;
        obj_.width=w;
        obj_.height=h;
       }
     ~Gdk_Rectangle();

#if GDK_VERSION_GT(1,0)
     GdkRectangle join(Gdk_Rectangle &src2)
       {GdkRectangle rec;
        gdk_rectangle_union(&obj_,&(src2.obj_),&rec);
        return rec;
       }
#endif
  };

#if GDK_VERSION_GT(1,0)
inline GdkRectangle join(Gdk_Rectangle &src1,Gdk_Rectangle &src2)
   {return src1.join(src2);
   }
#endif

class Gdk_Segment: public Gdk_Obj<GdkSegment>
  {
   public:
     Gdk_Segment()
       :Gdk_Obj<GdkSegment>() {}
     Gdk_Segment(GdkSegment* seg)
       :Gdk_Obj<GdkSegment>(seg) {}
     Gdk_Segment(const Gdk_Segment& seg)
       :Gdk_Obj<GdkSegment>(seg) {}
     Gdk_Segment(gint x1, gint y1, gint x2, gint y2)
       :Gdk_Obj<GdkSegment>()
       {obj_.x1=x1;
        obj_.y1=y1;
        obj_.x2=x2;
        obj_.y2=y2;
       }
     ~Gdk_Segment();
  };   

#endif // _GDKMM_TYPES_H_