graphics.h

// ==========================================================================
//
// file: bmptk/graphics/bmptk-graphics.h
//
// ==========================================================================

#ifndef BMPTK_GRAPHICS_H
#define BMPTK_GRAPHICS_H

#include <iostream>
#include <limits>

namespace bmptk { 

namespace graphics {

// ==========================================================================
//
// class vector
//
//
//

class vector {
private:   
     
   static int sign( short int x ){ 
      return ( x > 0 ) - (x < 0); }  
      
   static bool is_within( short int x, short int m ){
      return (( x >= 0 ) && ( x < m )) || (( x <= 0 ) && ( x > m )); }

   short int x;
  
   short int y;

public:      

   vector(): x( 0 ), y( 0 ) {}   
     
   vector( short int x, short int y ): x( x ), y( y ) {}   
     
   short int x_get() const { return x; }
   
   short int y_get() const { return y; }
   
   vector operator + ( const vector p ) const {
      return vector( x + p.x, y + p.y ); }          
      
   vector operator += ( const vector p ){
      return vector( x += p.x, y += p.y ); }          
      
   vector operator + ( void ) const {
      return vector( x, y ); }
   
   vector operator - ( const vector p ) const {
      return vector( x - p.x, y - p.y ); }          
      
   vector operator -= ( const vector p ){
      return vector( x -= p.x, y -= p.y ); }          
      
   vector operator - ( void ) const {
      return vector( - x, - y ); }
   
   vector operator / ( int n ) const {
      return vector( x / n, y / n ); }          
      
   vector & operator /= ( int n ){
      x /= n; 
          y /= n;
          return *this;
   }      
      
   vector operator * ( int n ) const {
      return vector( x * n, y * n ); }         
      
   vector & operator *= ( int n ){
      x *= n;
          y *= n;
      return *this;
   }         
      
   vector operator * ( const vector rhs ) const {
      return vector( x * rhs.x, y * rhs.y ); }         
      
   bool operator == ( const vector p ) const {
      return ( x == p.x ) && ( y == p.y );  }          

   bool operator != ( const vector p ) const {
      return ! ( *this == p );  }     
      
   //
   vector direction( void ) const {
      return vector( sign( x ), sign( y )); }           
           
   // 
   vector abs( void ) const {
      // std::abs is not present in DevKitPro??
      return vector( 
         ( x >= 0 ) ? x : -x,
         ( y >= 0 ) ? y : -y  ); 
   }  
      
   //
   vector x_projection( void ) const {
      return vector( x, 0 ); }        
      
   //
   vector y_projection( void ) const {
      return vector( 0, y ); }        
      
   //
   vector mirrored( void ) const {
      return vector( y, x ); }        
      
   //   
   bool is_within( const vector p ) const {
      return is_within( x, p.x ) && is_within( y, p.y ); }
      
   static vector origin(){ return vector( 0, 0 ); }
   
   static vector zero(){ return vector( 0, 0 ); }
   
   static vector one(){ return vector( 1, 1 ); }
};

//
vector max( 
   vector a, 
   vector b, 
   vector c = vector::origin(), 
   vector d = vector::origin() 
);

vector operator * ( int n, const vector v ); 

//
std::ostream & operator<< ( std::ostream &s, const vector p );


// ==========================================================================
//
// class color
//
//
//

class color {  
private:    
              
   static int clip( int x ){
      return ( x < 0 ) ? 0 : ( x > 0xFF ? 0xFF : x ); }        

   bool transp;
   unsigned char r; 
   unsigned char g;
   unsigned char b; 
   
public:      
   
   //
   color( int r, int g, int b, bool t = 0 ):
      transp( t ), r( clip( r )), g( clip( g )), b( clip( b ))
   {
      if( t ){ r = g = b = 0; }
   }
      
   //
   color( unsigned int rgb = 0 ):
      transp( 0 ),  
      r( clip( ( rgb & 0xFF0000 ) >> 16 )), 
      g( clip( ( rgb & 0x00FF00 ) >>  8 )), 
      b( clip( ( rgb & 0x0000FF ) >>  0 )){}
      
   unsigned int rgb15_get( void ) const {
      return (
           ((unsigned int)( r & 0xF8 ) >>  3 )
         | ((unsigned int)( g & 0xF8 ) <<  2 )
         | ((unsigned int)( b & 0xF8 ) <<  7 ) 
      );
   }      
   
   //
   bool is_transparent() const { return transp; }
   
   //
   unsigned char red_get() const { return r; } 
   
   //
   unsigned char green_get() const { return g; }
   
   //
   unsigned char blue_get() const { return b; }    

   color operator + ( const color c ) const {
      return color( 
         r + (int)c.r, 
         g + (int)c.g, 
         b + (int)c.b, 
         transp && c.transp ); }
      
   const color & operator += ( const color c ){
      r = clip( r + (int)c.r ); 
      g = clip( g + (int)c.g ); 
      b = clip( b + (int)c.b ); 
      transp = transp && c.transp; 
      return *this;
   }
      
   color operator + ( void ) const {
      return color( r, g, b, transp ); }          
      
   color operator - ( const color c ) const {
      return color( 
         r - (int)c.r, 
         g - (int)c.g, 
         b - (int)c.b, 
         transp && c.transp ); }
      
   color & operator -= ( const color c ){
      r = clip( r - (int)c.r ); 
      g = clip( g - (int)c.g );
      b = clip( b - (int)c.b );
      transp = transp && c.transp; 
      return *this;
   }          
      
   color operator - ( void ) const {
      return color( 
         0xFF - (int)r, 
         0xFF - (int)g, 
         0xFF - (int)b, 
         transp ); }
      
   color operator / ( unsigned int n ) const {
      return color( r / n, g / n, b / n, transp ); }
      
   color & operator /= ( unsigned int n ){
      r = clip( r / n ); 
      g = clip( g / n ); 
      b = clip( b / n ); 
      return *this;
   }
      
   color operator * ( unsigned int n ) const {
      return color( r * n, g * n, b * n, transp ); }
   
   color & operator *= ( unsigned int n ){
      r = clip( r * n ); 
      g = clip( g * n ); 
      b = clip( b * n ); 
      return *this;
   }
      
   bool operator == ( const color c ) const {
      return transp ? c.transp : 
         ( ! c.transp ) && ( r == c.r ) && ( g == c.g ) && ( b == c.b ); }

   bool operator != ( const color c ) const {
      return ! ( *this == c );  }   
   
   color mixed_with( const color c ) const {
      return color( 
         ( r + c.r ) / 2, 
         ( g + c.g ) / 2, 
         ( b + c.b ) / 2,
         transp && c.transp ); }          

   //

   // these 'constants' are delibreately NOT Doxygen-documented     
   static color black()       { return color( 0,       0,    0 ); }   
   static color white()       { return color( 0xFF, 0xFF, 0xFF ); }   
   static color red()         { return color( 0xFF,    0,    0 ); }   
   static color green()       { return color( 0,    0xFF,    0 ); }   
   static color blue()        { return color( 0,       0, 0xFF ); }   
   static color gray()        { return color( 0x80, 0x80, 0x80 ); }   
   static color yellow()      { return color( 0xFF, 0xFF,    0 ); }   
   static color cyan()        { return color(    0, 0xFF, 0xFF ); }   
   static color magenta()     { return color( 0xFF,    0, 0xFF ); }   
   static color transparent() { return color( 0, 0, 0, 1 );       }   
   static color violet()      { return color( 0xEE82EE );         }   
   static color sienna()      { return color( 0xA0522D );         }   
   static color purple()      { return color( 0x800080 );         }   
   static color pink()        { return color( 0xFFC8CB );         }   
   static color silver()      { return color( 0xC0C0C0 );         }   
   static color brown()       { return color( 0xA52A2A );         }   
   static color salmon()      { return color( 0xFA8072 );         }   

};

//
std::ostream & operator << ( std::ostream &s, const color c );


// ==========================================================================
//
// class event
//

//
//
enum event_type { 

   //
   event_none, 
   
   //
   event_exit, 
   
   //
   event_down, 
  
   //
   event_touch, 
  
   //
   event_up, 
  
   //
   event_click 
};

//
const char * event_type_name( const event_type e );

//
std::ostream & operator<<( std::ostream &s, const event_type &e );

//
//
class event {

   const vector location;
   
   const event_type e;
   
public:

   event( const vector p, const event_type e ):
      location( p ), e( e ) {}   
      
   vector location_get() const { return location; }

   event_type event_type_get() const { return e; }
   
};

//
std::ostream & operator<<( std::ostream &s, const event &e );


// forward declaration needed because drawable
// must know its frame
class frame;


// ==========================================================================
//
// class drawable
//
//
//1 frame where it can draw itself, and
//
class drawable {
private:

   drawable( const drawable &rhs );
   
   drawable & operator=( const drawable &rhs );

protected:

   frame &fr;
   
   vector position;

   color fg;
   
   color bg;
   
   unsigned int width;
   
   //
   void drawable_draw_pixel( 
      const vector address, 
      const color c 
   ) const;
         
   //
   drawable( 
      frame &fr,
      const vector position = vector::origin(),
      const color fg = color::black(), 
      const color bg = color::transparent(),
      unsigned int width = 1
   ): fr( fr ), position( position ), fg( fg ), bg( bg ), width( width ) {}
   
public:    

   frame &frame_get() const { return fr; }
   
   const vector position_get() const { return position; }
     
   color fg_get() const { return fg; }
      
   color bg_get() const { return bg; }
      
   unsigned int width_get() const { return width; }
   
   void position_set( const vector pos ){ position = pos; }
      
   void fg_set( const color c ){ fg = c; }
      
   void bg_set( const color c ){ bg = c; }
      
   void width_set( unsigned int w ){ width = w; }
   
   virtual void draw() const = 0;
      
};


// ==========================================================================
//
// class frame
//
//
//

class frame {
private:

   frame( const frame &rhs );
   
   frame & operator=( const frame &rhs );
   

protected:
    
   const vector size;
   
   color bg;
   
   //
   virtual void checked_write( const vector p, const color c ) = 0;  
   
public:          

   frame( const vector size ): size( size ), bg( color::white()) {}
   
   vector size_get() const { return size; }
            
   virtual vector translate_outfrom( const vector p ) const {
      return p; }   
   
   virtual vector translate_into( const vector p ) const {
      return p; }   
   
   bool is_valid( vector p ){
      return p.is_within( size ); }   
      
   //
   color bg_get(){ return bg; }      
   
   //
   void write( const vector p, const color c ){
      if( is_valid( p ) ){ checked_write( p, c ); }}        
   
   //
   virtual void clear( const color c = color::white() );
   
   //
   virtual void flush(){}
};


// ==========================================================================
//
// class frame_dummy
//
//

class frame_dummy : public frame {
public:

   //
   frame_dummy( const vector size = vector::origin() ): frame( size ){}
   
protected:

   //
   void checked_write( const vector p, const color c ){}
};


// ==========================================================================
//
// class frame_buffer
//
//

class frame_buffer : public frame {
private:
   frame &f;
   
   color *pixels;
   
   //
   color & pixel( vector p ){
      return pixels[ p.x_get() + f.size_get().x_get() * p.y_get() ];
   }
   
   color pixel( vector p ) const {
      return pixels[ p.x_get() + f.size_get().x_get() * p.y_get() ]; 
   }
      
   frame_buffer( const frame_buffer &rhs );
   
   void operator=( const frame_buffer &rhs );
   
public:   

   //
   frame_buffer( frame &fr ):
      frame( fr.size_get()),
          f( fr )
   {
      pixels = new color[ f.size_get().x_get() * f.size_get().y_get() ];
      for( int x = 0; x < f.size_get().x_get(); x++ ){
         for( int y = 0; y < f.size_get().y_get(); y++ ){
                        pixel( vector( x, y )) = color::transparent();
         }
      }   
   }
   
   virtual ~frame_buffer(){
      delete[] pixels;
   }
   
   void checked_write( const vector p, const color c ){
      pixel( p ) = c;
   }
  
   //
   void flush(){
      for( int x = 0; x < f.size_get().x_get(); x++ ){
         for( int y = 0; y < f.size_get().y_get(); y++ ){
            vector p( x, y );
                        if( ! pixel( p ).is_transparent() ){
               f.write( p, pixel( p ));
                           pixel( p ) = color::transparent();
                        }   
         }
      }                       
          f.flush();
   }
   
   void clear( const color c = color::white() ){
      bg = c;
      frame::clear( c );
   }   
   
};


// ==========================================================================
//
// class frame_snapshot
//
//

class frame_snapshot : public frame {
private:
   frame &f;
   
   color *pixels;
   
   //
   color & pixel( vector p ){
      return pixels[ p.x_get() + f.size_get().x_get() * p.y_get() ];
   }
   
   color pixel( vector p ) const {
      return pixels[ p.x_get() + f.size_get().x_get() * p.y_get() ]; 
   }
      
   frame_snapshot( const frame_snapshot &rhs );
   
   void operator=( const frame_snapshot &rhs );
   
public:   

   //
   frame_snapshot( frame &fr ):
      frame( fr.size_get()),
          f( fr )
   {
      pixels = new color[ f.size_get().x_get() * f.size_get().y_get() ];
      for( int x = 0; x < f.size_get().x_get(); x++ ){
         for( int y = 0; y < f.size_get().y_get(); y++ ){
                        pixel( vector( x, y )) = color::transparent();
         }
      }   
   }
   
   virtual ~frame_snapshot(){
      delete[] pixels;
   }
   
   void checked_write( const vector p, const color c ){
      if( ! c.is_transparent() ){
         pixel( p ) = c;
      }          
          f.write( p, c );
   }
  
   void flush(){              
          f.flush();
   }
   
   void clear( const color c = color::white() ){
      bg = c;
      frame::clear( c );
   }   
   
   //
   void write_to_bmp_file( const char *file_name );

};


// ==========================================================================
//
// class frame_tee
//
//

class frame_tee : public frame {
private:
   frame &f1, &f2, &f3, &f4;
   
   static frame & frame_dummy_ref(){
      static frame_dummy dummy;
      return dummy;
   }
   
public:
          
   frame_tee( 
      frame &f1, 
          frame &f2,
      frame &f3 = frame_dummy_ref(), 
          frame &f4 = frame_dummy_ref() 
   ): 
      frame( max( 
             f1.size_get(), 
                 f2.size_get(),
             f3.size_get(), 
                 f4.size_get() )),
          f1( f1 ), 
          f2( f2 ),
          f3( f3 ),
          f4( f4 ){}
          
   void checked_write( const vector p, const color c ){
      f1.write( p, c );
          f2.write( p, c );
      f3.write( p, c );
          f4.write( p, c );
   }
   
   void flush(){
      f1.flush();
          f2.flush();
      f3.flush();
          f4.flush();
   }   
   
   void clear( const color c = color::white() ){
      bg = c;
      f1.clear( c ); 
      f2.clear( c ); 
      f3.clear( c ); 
      f4.clear( c ); 
   }   
};


// ==========================================================================
//
// class frame_filter
//
//

class frame_filter : public frame {
private:
   frame &f;
   color (&filter)(color);
   void (&writer)(frame &f, vector p, color c, color bg );
   
   static color default_filter( color c ){ return c; }
   static void default_writer( frame &f, vector p, color c, color bg ){ 
      f.write( p, c ); }
   
public:

   frame_filter( frame &f, color (&filter)(color) ): 
      frame( f.size_get()),
      f( f ),
          filter( filter ),
          writer( frame_filter::default_writer ){}
          
   frame_filter( 
      frame &f, 
          void (&writer)(frame &f, vector p, color c, color bg ) 
   ): 
      frame( f.size_get()),
      f( f ),
          filter( frame_filter::default_filter ),
          writer( writer ){}
          
   void checked_write( const vector p, const color c ){
      writer( f, p, filter( c ), bg );
   }
   
   void flush(){
      f.flush();
   }   
   
   void clear( const color c = color::white() ){
      bg = filter( c );
      f.clear( bg ); 
   }   
};


// ==========================================================================
//
// class subframe
//
//
#ifdef notyet















#endif
//

class subframe : public frame {
public:

   frame & master;              
   
   const vector top_left;
   
   const vector bottom_right;
   
#ifdef notyet   

   const unsigned int scale;
#endif
   
   const bool swapped;
   
   vector translate_outfrom( const vector p ) const {
      vector x( 
         top_left.x_get() < bottom_right.x_get()
            ? top_left.x_get() + p.x_get() 
            : top_left.x_get() - p.x_get(),
         top_left.y_get() < bottom_right.y_get()  
            ? top_left.y_get() + p.y_get()
            : top_left.y_get() - p.y_get()
       );
           if( swapped ){
          x = x.mirrored();
           }       
           return x;
        }   
      
   vector translate_into( const vector p ) const {
      vector x( 
         top_left.x_get() < bottom_right.x_get()
            ? p.x_get() - top_left.x_get()
            :  ( - p.x_get()) - top_left.x_get(),
         top_left.y_get() < bottom_right.y_get()  
            ? + p.y_get()- top_left.y_get() 
            : ( - p.y_get()) - top_left.y_get()
       );
           if( swapped ){
          x = x.mirrored();
           }       
           return x;
        }   
      
   subframe( 
      frame &f, 
      vector top_left, 
      vector direction,
#ifdef notyet  
      unsigned int scale = 1,
#endif    
          bool swapped = false
   ):
      frame( direction.abs() ),
      master( f ), 
      top_left( top_left ), 
      bottom_right( top_left + direction - direction.direction() ),
#ifdef notyet     
      scale( scale ),
#endif    
          swapped( swapped ){}
  
protected:

   //
   void checked_write( const vector p, const color c ){
      if( is_valid( p )){
         vector q = swapped ?  p.mirrored() : p;
#ifdef notyet            
         for( unsigned int x = 0; x < scale; x++ ){
            for( unsigned int y = 0; y < scale; y++ ){       
               master.write( translate( q * scale + vector( x, y )), c ); 
            }}}}
#else
         master.write( translate_outfrom( q ), c ); 
      }          
   }              
#endif                  
                   
};


// ==========================================================================
//
// class line
//
//
//

class line : public drawable {
public:    

   //
   vector size;
   
   line( 
      frame &frame,
      const vector position,
      const vector size, 
      const color fg = color::black(), 
      int width = 1 
   ):
      drawable( 
             frame, 
                 position, 
                 fg, 
                 color::transparent(), 
                 width 
          ), size( size ){}
      
        
   void draw() const;
};    


// ==========================================================================
//
// class rectangle

enum relief {  

   relief_flat,
 
   relief_raised, 
   
   relief_sunken
}; 
   
relief flip( const relief r );   

std::ostream & operator<<( std::ostream &s, const relief &r );

//
//
//

class rectangle : public drawable {
private:
   rectangle( const rectangle & );
   
   void operator=( const rectangle & rhs );
   
public:

   //
   color bright;
   
   //
   color dark;
   
   //
   relief border;
   
   //
   vector size;
   
   rectangle(
      frame &frame,
      const vector position,
      const vector size, 
      const color fg     = color::black(),
      const color bg     = color::transparent(),
      int width          = 1,
      relief rel         = relief_flat
   ):
      drawable( frame, position, fg, bg, width ), 
      bright( fg ), 
      dark( fg / 4 ), 
      border( rel ),
      size( size ){}       

   void draw() const;
};  
    
    
// ==========================================================================
//
// class circle
//
//
//

class circle : public drawable {
private:

   void circle_draw(
      const color c,
      bool fill
   ) const;
   
   void circle_draw_pixel(  
      const vector v,
      const color c
   ) const;

public:    

   unsigned int radius; 
   
   circle( 
      frame &frame,
      const vector position,
      unsigned int radius,
      const color fg = color::black(),
      const color bg = color::transparent(),
      unsigned int width = 1
   ):
      drawable( frame, position, fg, bg, width ), radius( radius ){}        
      
   void draw() const; 
};    


// ==========================================================================
//
// class image
//
//
//
class image {
private:

   image( const image &rhs );
   
   image & operator=( const image &rhs );
   
public:

   image(){}
           
   virtual void draw( 
      frame &frame, 
      const vector position = vector::origin() ) const = 0;      
};


// ==========================================================================
//
// class image_pixels
//
//
//
class image_pixels : public image {
protected:      

   vector size;
        
   //
   virtual color checked_read( const vector p ) const = 0;

public:

   image_pixels( vector size ): size( size ){}  
              
   vector size_get() const { return size; }     
   
   bool is_valid( const vector p ) const {
      return p.is_within( size ); }  
   
   virtual void draw( 
      frame &frame, 
      const vector position = vector::origin() ) const;
      
   //
   color read( const vector p ) const {
      if( is_valid( p )){
         return checked_read( p );
      } else {
         return color::transparent();
      }               
   }       
};


// ==========================================================================
//
// class inline_rgb_photo
//
//
//

class inline_rgb_photo : public image_pixels {
private:

   const unsigned char *data;  
   
   color checked_read( const vector p ) const;
     
public:     
   
   inline_rgb_photo( vector size, const unsigned char *data ):
      image_pixels( size ), data( data ){}        

};

// ==========================================================================
//
// class inline_bw_photo
//
//
//

class inline_bw_photo : public image_pixels {
private:

   const unsigned char *data;  

   color fg, bg;

public:        
    
   bool bool_read( const vector p ) const; 
   
   inline_bw_photo( 
   
      const vector size,   
      
      //
      const unsigned char *data 
   ):
      image_pixels( size ), 
          data( data )
   { 
      fg = color::black(); 
      bg = color::white(); 
   }        
      
private:
        
   color checked_read( const vector p ) const {
      return bool_read( p ) ? fg : bg; }                    
};


// ==========================================================================
//
// class font
//
//
//

class font {
public:    
    
   bool const fixed;
   
   bool const proportional;
   
   const vector font_char_size;
   
   font( bool fixed, const vector char_size ):
      fixed( fixed ), proportional( ! fixed ), font_char_size( char_size ){}     
    
   //
   virtual bool has( char c ) const = 0;
       
   virtual bool read( char c, const vector p ) const = 0;
   
   //
   virtual vector char_size( char c ) const = 0;
    
};


// ==========================================================================
//
// class char_photo
//
//
//

class char_photo : public image_pixels {   
public:    
       
   const font &f;  
    
   const char c;
   
   const color fg;
   
   const color bg;

   char_photo( 
      const font &f,
      char c, 
      const color fg = color::black(), 
      const color bg = color::transparent()
   ):
      image_pixels( f.char_size( c )),
      f( f ),
      c( c ), 
      fg( fg ), 
      bg( bg )
   {}
   
   color checked_read( const vector p ) const {
      return f.read( c, p ) ? fg : bg; }      
         
};


// ==========================================================================
//
// class inline_font
//
//
//

         // font type
         // picture is a picture of the characters in the font, 
         //    stored as one long line
         // when list is NULL the characters 0x20 .. 0x7F are supported,
         //    otherwise it is a (0-terminated) list of characters
         // for a fixed-width font x_size is the width of a char,
         //    and start is NULL
         // for a proportional font x_size is 0, and
         //    start points to an array with the x-offsets of each
         //    character. The first offset is of course 0, but
         //    still stored, and there are 0x61 offsets (not 0x60!)

class inline_font : public font, public inline_bw_photo {
public: 
    
   const int *start; 
   
   inline_font( 
   
      bool fixed,
      
      const vector char_size,
      
      const int *start,
      
      const vector size,
            
      const unsigned char *data
   ):         
      font( fixed, char_size ), 
      inline_bw_photo( size, data ),
      start( start )
   {}        
           
   bool has( char c ) const { 
      if( ( c < ' ' ) || ( c >= 127 ) ) return false;
      return start[ (int) c - 32 ] >= 0; 
   }
      
   vector char_size( char c ) const;
   
   bool read( char c, const vector p ) const;
};


// ==========================================================================
//
// class format

enum font_alignment { 
        
   align_near, 
   
   align_far, 
   
   align_centre, 
   
   align_fill 
};

std::ostream & operator<<( std::ostream &s, const font_alignment &a );

const inline_font & font_default();

//
//
//

class format {
public:
   const font &f;
   
   font_alignment h;
   
   font_alignment v;
   
   bool wrap;
   
   unsigned int scale;
   
   vector spacing;
   
   vector top_left_margin;
   
   vector bottom_right_margin;
   
   color fg;
   
   color bg;
   
   format( 
      const font &f = font_default(),
      font_alignment h = align_near, 
      font_alignment v = align_near, 
      bool wrap = 0,
      unsigned int scale = 1,
      vector spacing = vector::origin(),
      vector top_left_margin = vector( 2,2 ),
      vector bottom_right_margin = vector( 2,2 ),
      color fg = color::black(),
      color bg = color::transparent()
   ): 
      f( f ),         
      h( h ), 
      v( v ), 
      wrap( wrap ),
      scale( scale ),
      spacing( spacing ),
      top_left_margin( top_left_margin ),
      bottom_right_margin( bottom_right_margin ),
      fg( fg ),
      bg( bg )
   {}

   format( const format &fmt, const font &fr ):
      f( fr ),
      h( fmt.h ), 
      v( fmt.v ), 
      wrap( fmt.wrap ),
      scale( fmt.scale ),
      spacing( fmt.spacing ),
      top_left_margin( fmt.top_left_margin ),
      bottom_right_margin( fmt.bottom_right_margin ),
      fg( fmt.fg ),
      bg( fmt.bg )
   {}     
};    

std::ostream & operator<<( std::ostream &s, const format &f );


// ==========================================================================
//
// class text
//
//
//
class text : public image {
public:    
        
   const char *s;
     
   format f;    
   
   text( 
      //
      const char *s,
           
      //
      const format f = format()
   ): s( s ), f( f ){}        
      
   //
   void draw( frame &f, const vector position = vector::origin() ) const; 
};   


class frame_console_stringbuf : public std::streambuf {
private:
   frame &fr;
   vector cursor;
   format fm;
   
   void print( char c );
   std::streamsize xsputn ( const char * s, std::streamsize n );
   
public:

   frame_console_stringbuf( frame &fr, format fm ): 
      fr( fr ), 
      cursor(0,0),
      fm( fm )
   {}
   
};

// ==========================================================================
//
// class frame_console
//
//
//

class frame_console : public std::ostream {
private:
   frame_console_stringbuf buf;
public:
   //
   //
   frame_console( frame &f, format fo = format() ): 
      // std::ios(0),
      std::ostream(&buf),
      buf( f, fo )
    {}
};


// ==========================================================================
//
// A sheet is a graphical object, ultimately to be shown in a frame,
// that can show ASCII text
//

#ifdef nono
class sheet_base : public drawable {
protected:
   const char * buffer;
   unsigned int size;   
   sheet_base( ){}
   void add( char c );
   void clear(){}
   void draw(){}
} 

template< unsigned int charsize > class sheet : public sheet_base {
   char buffer[ charsize + 1 ];
public:
   sheet( ): sheet_base( , ){}
}



// ==========================================================================
//
// A widget is a graphical object, ultimately to be shown in a frame,
// that can handle events in some way, and can draw itself.
//

class widget {
protected:
   widget * children, * next_child;
public:   
   const widget *toplevel, *parent;
   frame *inner;
   bool changed;
   
   widget( widget * toplevel, widget * parent, frame *f ): 
      children( 0 ), next_child( 0 ), 
      toplevel( toplevel ), parent( parent ), 
      inner( f ), changed( 1 ) 
   {}
      
   widget( widget * parent, frame *f ): 
      children( 0 ), next_child( 0 ),
      toplevel( parent->toplevel ), parent( parent ), 
      inner( f ), changed( 1 )
   {
      parent->add( this ); }
      
   void add( widget * w ){
      w->next_child = children; 
      children = w; }           
         
   void redraw( bool forced = 0 ){
      if( forced ){
         changed = 1;
      }         
      if( changed ){   
         draw();
      }
      for( widget *w = children; w != 0; w = w->next_child ){    
         w->redraw( changed ); 
      }
      changed = 0;
   }         
         
   virtual void handle( const event &e ){
      for( widget *w = children; w != 0; w = w->next_child ){    
         event ew( w->inner->translate( 
            e.location_get() ), 
            e.event_type_get() );
         if( ew.location_get().is_within( w->inner->size_get() )){   
            w->handle( ew ); 
         }   
      }           
   };    
   
   virtual void draw( void ){};         
};


// ==========================================================================
//
// A wframe is a widget that has a border around its inner frame.
// This frame has a fixed width, but the colors and the relief can be
// changed.
//

class wframe : public widget {
private:
   subframe subf;
public:
   const vector size;
   vector origin;
   relief border;
   color bg;
   
   wframe( 
      widget &parent, 
      const vector size,
      const vector &origin = vector( 0, 0 ), 
      const color &bg = color::red(),
      const relief border = relief_raised
   ):
      widget( &parent, &subf ),
      subf( *parent.inner, origin, origin + size ),
      size( size ),
      origin( origin ),
      border( border ),
      bg( bg ) 
   {}
      
   void handle( const event &e ){
      //trace << e;  
      if( e.event_type_get() == event_down ){
         bg = color( bg.red_get(), bg.green_get(), bg.blue_get() ^ 0xFFFF );   
         border = flip( border );
         //trace << border;
         changed = 1;
      }                 
   };
   
   void draw( void ){
      subf.clear( bg );
   }
};


// ==========================================================================
//
// A wpaint is a widget that paints wherever a touch event occurs.
//

class wpaint : public widget {
private:
   subframe subf;
public:
   const vector size;
   vector origin;
   relief border;
   color bg, fg;
   
   wpaint( 
      widget &parent, 
      const vector size,
      const vector origin = vector( 0, 0 ), 
      const color &bg = color::red(),
      const color &fg = color::blue()
   ):
      widget( &parent, &subf ),
      subf( *parent.inner, origin, origin + size ),
      size( size ),
      origin( origin ),
      bg( bg ), fg( fg )
   {}
      
   void handle( const event &e ){
      if( e.event_type_get() == event_touch ){
        inner->write( e.location_get(), fg );      
      }                  
   };
   
   void draw( void ){
      subf.clear( bg );
   }
};


// ==========================================================================
//
// A wtoplevel is a widget that has an associated graphics frame
// and a way to get the events that occur within that frame.
//
// It has a run method that keeps getting and handling events
// (untill it gets an event_exit).
//

class wtoplevel : public widget {
public:
   color bg;
    
   wtoplevel( frame &f, const color &bg  ):
      widget( this, this, &f ), bg( bg ) {}
      
   virtual event event_get( void ) = 0;
   
   void draw( void ){
      inner->clear( bg ); }
   
   void run( void );
};
#endif

} // namespace graphics
} // namespace bmptk

#endif // #ifdef BMPTK_GRAPHICS_H