Box.H

Go to the documentation of this file.

/* Copyright 2000-2018 Matt Flax <flatmax@flatmax.org>
   This file is part of GTK+ IOStream class set

   GTK+ IOStream is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   GTK+ IOStream 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 General Public License for more details.

   You have received a copy of the GNU General Public License
   along with GTK+ IOStream
 */
#ifndef BOX_H_
#define BOX_H_

#include <iostream>
using namespace std;
#include <gtk/gtk.h>

#include <mffm/LinkList.H>
#include "Container.H"

#ifndef uint
typedef unsigned int uint;
#endif

class BoxIS {
    //bool defaultVal=false;
    //#define defaultVal false ///< The default value
    bool expandDefault;
    bool fillDefault;
    bool startDefault;

    void setDefaults(void){
        expandDefault=fillDefault=false; //defaultVal; // setup the default behaviour
        startDefault=true;

        expand = expandDefault;
        fill = fillDefault;
        start = startDefault;
    }
public:
    bool expand;
    bool fill;
    bool start;

    BoxIS(void) {
        setDefaults(); // load up the default values
    }

    BoxIS(bool expandIn, bool fillIn) {
        setDefaults(); // load up the default values
        expand=expandIn;
        fill=fillIn;
   }

    BoxIS(bool expandIn, bool fillIn, bool startIn) {
        setDefaults(); // load up the default values
        expand=expandIn;
        fill=fillIn;
        start=startIn;
    }

    void reset(void) {
        expand=expandDefault;
        fill=fillDefault;
        start=startDefault;
    }

    void setDefaultStart(bool startIn){
        startDefault=startIn;
        start=startDefault;
    }

    void setDefaultExpand(bool expandIn){
        expandDefault=expandIn;
        expand=expandDefault;
    }

    void setDefaultFill(bool fillIn){
        fillDefault=fillIn;
        fill=fillDefault;
    }

    BoxIS& operator=(BoxIS& bis) {
        expand=bis.expand;
        fill=bis.fill;
        start=bis.start;
        return *this;
    }

    BoxIS& operator=(const BoxIS bis) {
        expand=bis.expand;
        fill=bis.fill;
        start=bis.start;
        return *this;
    }

    void dump(void){
        cout<<"BoxIS::expand="<<expand<<", fill="<<fill<<", start="<<start<<endl;
    }
};

/*/// The default values of expand and fill
bool BoxIS::defaultVal=false;
*/

class Box : public BoxIS, public Container {
protected:

    virtual void pack(GtkWidget *obj) {
        if (start)
            gtk_box_pack_start (GTK_BOX (widget), obj, expand, fill, 0);
        else
            gtk_box_pack_end (GTK_BOX (widget), obj, expand, fill, 0);
        //BoxIS::reset(); // reset the starting values
    }
public:

    enum {EXPAND=1, FILL=2, START=4, RESET=8, END=16, NOFILL=32, NOEXPAND=64}; 

    Box(void) : BoxIS() {
    }

//    /** \brief destructor destroys the widget to neatly cleanup.
//    */
//    virtual ~Box(void){
//    }

    Box& operator<<(BoxIS bis) {
        this->BoxIS::operator=((const BoxIS)bis);
        return *this;
    }

//    /* Align the box : this is a bad idea, as it requires
//    \param a The alignment class
//    \return Returns a Box reference for further processing.
//    */
//    Box& operator<<(Alignment &a) {
//        Box *b=static_cast<Box*>(&a);
//        return *this<<BoxIS(true,true,true)<<b->getWidget();
//    }

    Box& operator <<(Box& b) {
        return Box::operator<<(b.getWidget());
    }

    Box& operator <<(int val) {
        if (val&RESET)
            BoxIS::reset();
        else {
            if (val&FILL)
                fill=true;
            if (val&EXPAND)
                expand=true;
            if (val&START)
                start=true;
            if (val&NOFILL)
                fill=false;
            if (val&NOEXPAND)
                expand=false;
            if (val&END)
                start=false;
        }
        return *this;
    }

    Box& operator <<(Box * b) {
        return Box::operator<<(b->getWidget());
    }

    Box& operator <<(Container& b) {
        return Box::operator<<(b.getWidget());
    }

    Box& operator <<(Container * b) {
        return Box::operator<<(b->getWidget());
    }

    Box& operator <<(GtkWidget * b) {
        Container::operator <<(b);
        return *this;
    }

    Box& operator <<(Widget *w) {
        Container::operator <<(w->getWidget());
        return *this;
    }

    Box& operator <<(Widget &w) {
        Container::operator <<(w.getWidget());
        return *this;
    }

    Box& operator <<(LinkList<GtkWidget *> &ll) {
        Container::operator <<(ll);
        return *this;
    }

    Box& operator >>(GtkWidget * b) {
        Container::operator>>(b);
        return *this;
    }

    Box& operator >>(Container * b) {
        Container::operator>>(b);
        return *this;
    }

    Box& operator >>(Container &b) {
        Container::operator>>(b);
        return *this;
    }

//    /*! Unpack an unknown widget from the box.
//        Note that removal of the widget can destroy it if the only reference is the box.
//    \return Returns the widget removed from the box
//    */
//    GtkWidget* removeUnknownWidget() {
//    GtkWidget* wdgt=gtk_container_get_focus_child((GtkContainer *)this->getWidget());
//    *this>>wdgt;
//    return wdgt;
//    }

    Box& operator=(const Box b){
        //widget=b.getWidget();
        Container::operator=(b);
        BoxIS::operator=(b);
        return *this;
    }

};

class VBox : public Box {
public:
    VBox() {
#if GTK_MAJOR_VERSION==2
        widget = gtk_vbox_new (FALSE, 0);
#else
        widget = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
#endif
    }
};

class HBox  : public Box {
public:
    HBox() {
#if GTK_MAJOR_VERSION==2
        widget = gtk_hbox_new (FALSE, 0);
#else
        widget = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
#endif
    }
};

class HBBox : public HBox {
public:
    HBBox() {
#if GTK_MAJOR_VERSION==2
        widget = gtk_hbutton_box_new ();
#else
        widget = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
#endif
    }
};

class VBBox : public VBox {
public:
    VBBox() {
#if GTK_MAJOR_VERSION==2
        widget = gtk_vbutton_box_new ();
#else
        widget = gtk_button_box_new(GTK_ORIENTATION_VERTICAL);
#endif
    }
};
#endif //BOX_H_