---

base_control.cpp

Go to the documentation of this file.

#include "base_control.h"
#include "cursive.h"
#include "curses.h"

namespace crs {

  void base_control::init() {
    updateParentCoord();
    if( mParent ) {
      parentHandle = mParent->registerControl( this );
    }
    resize();
  }

  base_control::base_control( base_control *Parent, window_events *Events, 
      const unsigned int Left, const unsigned int Top, const unsigned int Width, const unsigned int Height ): 
    name(""),
  mCursorpos(0,0),
  events(Events),
  mParent(Parent),
  buffer( ' ', Width, Height ),
  mLeft(Left),
  mTop(Top),
  mWidth(Width),
  mHeight(Height),
  mVisible(false),
  top      ( this, &base_control::getTop,     &base_control::setTop     ),
  left     ( this, &base_control::getLeft,    &base_control::setLeft    ),
  width    ( this, &base_control::getWidth,   &base_control::setWidth   ),
  height   ( this, &base_control::getHeight,  &base_control::setHeight  ),
  parent   ( this, &base_control::getParent,  &base_control::setParent  ),
  visible  ( this, &base_control::getVisible, &base_control::setVisible ),
  curpos   ( this, &base_control::getCurPos,  &base_control::setCurPos  ),
  controls ( this, &base_control::getControls ) {
    init();
  }

  base_control::~base_control() {
    if( mParent )
      for( controllist::iterator i = mControls.begin(); i != mControls.end(); i++ ){
        (*i)->freeRegistration();
      }
    if( mParent ) {
      mParent->deregisterControl( parentHandle );
    }
  }

  base_control::controllist::iterator base_control::registerControl( base_control *control ) {
    return mControls.insert( mControls.end(), control );
  }

  void base_control::deregisterControl( controllist::iterator &i ) {
    mControls.erase( i );
  }

  void base_control::freeRegistration() {
    mParent = 0;
  }

  void base_control::resize() {
    buffer.resize( mWidth, mHeight );
    draw();
  }

  void base_control::draw_on_screen() {
    draw();
    for( unsigned int x = 0; x < mWidth; x++ )
      for( unsigned int y = 0; y < mHeight; y++ ) {
        mvaddch( y + mTop + parentTop, x + mLeft + parentLeft, buffer[ x + y * mWidth ] );
      }
  }

  void base_control::draw() {
    buffer.fill( ' ' );
    for( controllist::iterator i = mControls.begin(); i != mControls.end(); i++ ) {
      (*i)->draw();
    }
  }

  void base_control::flush( chtype *parentWin, const unsigned int parentWidth, const unsigned int parentHeight ) {
    if( mVisible ) {
      for( controllist::iterator i = mControls.begin(); i != mControls.end(); i++ ) {
          (*i)->flush( &buffer[0], mWidth, mHeight );
      }
      for( unsigned int y = 0; y < mHeight && y + mTop < parentHeight; y++ ) {
        std::memcpy( 
            &parentWin[ ( y + mTop ) * parentWidth + mLeft ], 
            &buffer[ y * mWidth ], 
            mWidth * sizeof( chtype ) );
      }
    }
  }

  const base_control::controllist &base_control::getControls() {
    return mControls;
  }

  void base_control::updateParentCoord() {
    if( mParent ) {
      parentTop = mParent->top;
      parentLeft = mParent->left;
      parentWidth = mParent->width;
      parentHeight = mParent->height;
    } else {
      parentWidth = parentHeight = parentTop = parentLeft = 0;
    }
  }

  const bool &base_control::getVisible() {
    return mVisible;
  }

  void base_control::setVisible( const bool &is ) {
    if( is != mVisible ) {
      if( is ) {
        doShow();
      } else {
        doHide();
      }
      mVisible = is;
    }
  }

  void base_control::doHide() {
    if( events )
      events->onHide( *this );
  }

  void base_control::doShow() {
    if( events )
      events->onShow( *this );
  }

  const position &base_control::getCurPos() {
    return mCursorpos;
  }

  void base_control::setCurPos( const position &new_pos ) {
    if( new_pos.x < mWidth && new_pos.y < mHeight ) {
      mCursorpos.x = new_pos.x;
      mCursorpos.y  = new_pos.y;
    }
  }

  int base_control::getAbsTop() const {
    return mParent ? mParent->getAbsTop() + mTop : mTop;
  }

  int base_control::getAbsLeft() const {
    return mParent ? mParent->getAbsLeft() + mLeft : mLeft;
  }

  const int &base_control::getTop() {
    return mTop;
  }

  void base_control::setTop( const int &val ) {
    if( val >= 0 && val + mHeight <= parentHeight) {
      doMove( position( mLeft, mTop ), position( mLeft, val ) );
      mTop = val;
    }
  }

  const int &base_control::getLeft() {
    return mLeft;
  }

  void base_control::setLeft( const int &val ) {
    if( val >= 0 && val + mWidth <= parentWidth ) {
      doMove( position( mLeft, mTop ), position( val, mTop ) );
      mLeft = val;
    }
  }

  const base_control &base_control::getParent() {
    return *mParent;
  }

  void base_control::setParent( const base_control &win ) {
    mParent = const_cast<base_control*>(&win);
  }

  const unsigned int &base_control::getWidth() {
    return mWidth;
  }

  void base_control::setWidth( const unsigned int &val ) {
    doResize( getBounds(), bounds( mLeft, mTop, val, mHeight ) );
    mWidth = val;
    resize();
  }

  const unsigned int &base_control::getHeight() {
    return mHeight;
  }

  void base_control::setHeight( const unsigned int &val ) {
    doResize( getBounds(), bounds( mLeft, mTop, mWidth, val ) );
    mHeight = val;
    resize();
  }

  const bounds &base_control::getBounds() {
    return *std::auto_ptr<bounds>( new bounds( mLeft, mTop, mWidth, mHeight ) );
  }

  void base_control::doMove( const position &old_pos, const position &new_pos ){
    if( events )
      events->onMove( *this, old_pos, new_pos );
  }

  void base_control::doResize( const bounds &old_bounds, const bounds &new_bounds ){
    if( events )
      events->onResize( *this, old_bounds, new_bounds );
  }

  void base_control::putPixel( const char ch, const unsigned int x, const unsigned int y ) {
    if( x <= mWidth && y <= mHeight ) {
      buffer[ x * y ] = ch;
    }
  }

  void base_control::fill( const char ch ) {
    for( unsigned int x = 0; x < mWidth; x++ ){
      for( unsigned int y = 0; y < mHeight; y++ ) {
        mvaddch( parentLeft + mLeft + x, parentTop + mTop + y, ch );
      }
    }
  }

  void base_control::setText( const std::string &text, const unsigned int x, const unsigned int y ) {
    buffer.setText( text, x, y );
  }

  focused_ctrl::focused_ctrl(base_control *Parent, window_events *Events, 
      const unsigned int Left, const unsigned int Top, const unsigned int Width, const unsigned int Height ):
    base_control( Parent, Events, Left, Top, Width, Height ) {
      focusHandle = crsv.registerFocusable( this );
    }

  focused_ctrl::~focused_ctrl() {
    crsv.deregisterFocusable( focusHandle );
  }

  const style::styles &styled_ctrl::getStyle() {
    return mStyle;
  }

  void styled_ctrl::setStyle( const style::styles &Style ) {
    mStyle = Style;
  }

  styled_ctrl::styled_ctrl( style::styles Style, chtype clb, chtype crb ):
    mStyle(Style), custom_left_border(clb), custom_right_border(crb),
  style( this, &styled_ctrl::getStyle, &styled_ctrl::setStyle ) {
  }

}

---