RangeControl.h

Go to the documentation of this file.

#ifndef RANGECONTROL_H
#define RANGECONTROL_H


#include <Midad/Util/Undoable.h>
#include <Midad/Util/Range.h>
#include <Midad/Util/Signals.h>

template<class TYPE>
class RangeControl : public Undoable, public SigC::Object
{

public:

    RangeControl(UndoHistory* history = 0, Range<TYPE>* range = 0)
        : fHistory(history), fRange(range), fBlockHistory(false) { 
        if (!fHistory) fHistory = SigC::manage(new UndoHistory);
        if (!fRange) fRange = SigC::manage(new Range<TYPE>); 
    }

#if 0
    // copy constructor, assignment:
    RangeControl(const RangeControl<TYPE>& rhs) 
        : fHistory(rhs.fHistory), fRange(rhs.fRange){ }
    RangeControl& operator=(const RangeControl<TYPE>& that) {
        if (this == &that) return *this;
        this->fRange = that.fRange;
        this->fHistory = that.fHistory;
        return *this;
    }
#endif

    virtual ~RangeControl() {}

    // Access current ranges values, setters add to the history
    void Set(TYPE min, TYPE max) {
        if (!fBlockHistory) fHistory->Store(*this);
        fRange->Set(min,max);
    }
    void SetMin(TYPE min) {
        if (!fBlockHistory) fHistory->Store(*this);
        fRange->SetMin(min);
    }
    void SetMax(TYPE max) {
        if (!fBlockHistory) fHistory->Store(*this);
        fRange->SetMax(max);
    }
    void Apply(Range<TYPE>* r) {
        if (!fBlockHistory) fHistory->Store(*this);
        fRange->Set(r->Min(),r->Max());
    }

//    void Get(TYPE& min, TYPE& max) const { fRange->Get(min,max); }
//    TYPE Min(void) const { return fRange->Min(); }
//    TYPE Max(void) const { return fRange->Max(); }

    // Change which Range is used.  Nothing is known here about what
    // Range signals may be connected, nor is any signal emitted to
    // announce this change.  The old range is held in the history and
    // will be restored if an Undo() is called.  The range passed in
    // is held in a SigC::Ptr<> so understands manage().
    void UseRange(Range<TYPE>* range) {
        using namespace SigC;
        UndoItem ui(*this, 
                    SigC::bind(SigC::slot(*this,&RangeControl::UseRange),
                               fRange));
        fHistory->Store(ui);
        fRange = range;
    }
        

    Range<TYPE>& GetRange() { return *fRange; }

    // Undoable implementation
    UndoMemento GetMemento() {
        using namespace SigC;
        return bind(slot(*fRange,&Range<TYPE>::SetState),fRange->GetState());
    }

    void StartCompound() { 
        fHistory->Store(*this);
        fBlockHistory = true;
    }
    void StopCompound() {
        fBlockHistory = false;
    }
        

private:
    SigC::Ptr<UndoHistory> fHistory;
    SigC::Ptr<Range<TYPE> > fRange;
    bool fBlockHistory;
};                              // end of class RangeControl



#endif  // RANGECONTROL_H

---