vos/gui/gui/input_numeric.cc

Go to the documentation of this file.

/* $Id: input_numeric.cc,v 1.6 2003/07/23 00:17:20 reed Exp $ */

/*  Copyright (C) 2003 Reed Hedges <reed@interreality.org>

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser 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
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser 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

*/



#include <vos/corelibs/vos/vos.hh>
#include <vos/metaobjects/property/property.hh>
#include "input_numeric.hh"

using namespace VOSGUI;

/* Constructor */
NumericInput::NumericInput(MetaObject* s) : MetaObject(s), Widget(s), Input(s)
{
}

/* Destructor */
NumericInput::~NumericInput() {
}


LocalNumericInput::LocalNumericInput(MetaObject* s) : NumericInput(s), MetaObject(s), LocalWidget(s), Widget(s), Input(s), LocalInput(s)
{
}

LocalNumericInput::~LocalNumericInput() {
}

/* Initialize required subobjects: */




RemoteNumericInput::RemoteNumericInput(MetaObject* s) : NumericInput(s), MetaObject(s), Widget(s), RemoteWidget(s), Input(s), RemoteInput(s)
{

}

RemoteNumericInput::~RemoteNumericInput() {
}

/* Return type string ("gui:widget.input.numeric") */

const string NumericInput::getType() {
    return string("gui:widget.input.numeric");
}

/* Register extenders with libvos MetaFactory */
void NumericInput::registerExtenders() {
    LocalSite::addLocalObjectExtension(typeid(LocalNumericInput).name(), &LocalNumericInput::new_LocalNumericInput);
    LocalSite::addLocalObjectExtension(typeid(NumericInput).name(), &LocalNumericInput::new_LocalNumericInput);
    LocalSite::addLocalObjectExtension("gui:widget.input.numeric", &LocalNumericInput::new_LocalNumericInput);
    RemoteSite::addRemoteObjectExtension(typeid(RemoteNumericInput).name(), &RemoteNumericInput::new_RemoteNumericInput);
    RemoteSite::addRemoteObjectExtension(typeid(NumericInput).name(), &RemoteNumericInput::new_RemoteNumericInput);
    RemoteSite::addRemoteObjectExtension("gui:widget.input.numeric", &RemoteNumericInput::new_RemoteNumericInput);
}

/* Get and set Subproperties and other Subobjects */

void NumericInput::setValue(double v) {
    char p[32];
    snprintf(p, sizeof(p), "%lg", v);
    setTarget(p);
}

double NumericInput::getValue() {
    return Property::getFloatProperty(*this, "gui:target");
}
 
double NumericInput::getMaximum() {
    string s;
    double m;
    try {
        vRef<Vobject> v = findObject("gui:maximum");
        Property* p = meta_cast<Property*>(&v);
        if(!p)
            throw bad_cast();
        p->read(s);
        string mdt = p->getDataType();
        if(mdt == "text/x-float") {
            sscanf(s.c_str(), "%lg", &m);
        } else {
            LOG("VOSGUI::NumericInput", 0, "Sorry, the datatype \"" << mdt << " has not been implemented yet!");
            return 1.0;
        }
        return m;
    } catch(exception& e) {
        LOG("VOSGUI::NumericInput", 1, "Got exception in getMaximum: " << e.what());
        return 1.0;
    }
}

string NumericInput::getMaximumDatatype() {
    vRef<Vobject> v = findObject("gui:maximum");
    Property* p  = meta_cast<Property*>(&v);
    if(!p) throw bad_cast();
    return p->getDataType();
}

void NumericInput::setMaximum(const double value, PropertyAccessControl* ac) {
    if(ac == NULL)
        ac = accessControl;
    char s[32];
    snprintf(s, sizeof(s), "%.15g", value);
    Property::setProperty(*this, "gui:maximum", s, "text/x-float", ac);
}

void NumericInput::setRange(double min, double max, PropertyAccessControl* ac) {
    setMinimum(min, ac);
    setMaximum(max, ac);
}

Property* NumericInput::getMaximumObject() {
    return meta_cast<Property*>(&findObject("gui:maximum"));
}

void NumericInput::setMaximumObject(Property* newobj) {
    try {
        vRef<ParentChildRelation> pcr = findChild("gui:maximum");
        setChild(pcr->position, "gui:maximum", newobj);
    } catch (NoSuchObjectError) {
        insertChild(-1, "gui:maximum", newobj);
    }
}



double NumericInput::getMinimum() {
    string s;
    double m;
    try {
        vRef<Vobject> v = findObject("gui:minimum");
        Property* p = meta_cast<Property*>(&v);
        if(!p) {
            throw bad_cast();
        }
        p->read(s);
        string mdt = p->getDataType();
        if(mdt == "text/x-float") {
            sscanf(s.c_str(), "%lg", &m);
        } else {
            LOG("VOSGUI::NumericInput", 0, "Sorry, the datatype \"" << mdt << " has not been implemented yet!");
            return 0.0;
        }
        return m;
    } catch(exception& e) {
        LOG("VOSGUI::NumericInput", 2, "Warning: Got exception in getMinimum: " << e.what());
        return 0.0;
    }
}

string NumericInput::getMinimumDatatype() {
    vRef<Vobject> v = findObject("gui:minimum");
    Property* p = meta_cast<Property*>(&v);
    if(!p) throw bad_cast();
    return p->getDataType();
}

void NumericInput::setMinimum(const double value, PropertyAccessControl* ac) {
    if(ac == NULL)
        ac = accessControl;
    char s[32];
    snprintf(s, sizeof(s), "%.15g", value);
    Property::setProperty(*this, "gui:minimum", s, "text/x-float", ac);
}

Property* NumericInput::getMinimumObject() {
    return meta_cast<Property*>(&findObject("gui:minimum"));
}

void NumericInput::setMinimumObject(Property* newobj) {
    try {
        vRef<ParentChildRelation> pcr = findChild("gui:minimum");
        setChild(pcr->position, "gui:minimum", newobj);
    } catch (NoSuchObjectError) {
        insertChild(-1, "gui:minimum", newobj);
    }
}


double NumericInput::getIncrement() {
    string s;
    double i;
    try {
        vRef<Property> p = meta_cast<Property*>(&findObject("gui:increment"));
        if(!&p) throw bad_cast();
        p->read(s);
        string idt = p->getDataType();
        if(idt == "text/x-float") {
            sscanf(s.c_str(), "%lg", &i);
        } else {
            LOG("VOSGUI::NumericInput", 0, "Sorry, the datatype \"" << idt << " has not been implemented yet!");
            return 0.1;
        }
        return i;
    } catch(...) {
        return 0.1;
    }
}

string NumericInput::getIncrementDatatype() {
    vRef<Vobject> v = findObject("gui:increment");
    Property* p = meta_cast<Property*>(&v);
    if(!p) throw bad_cast();
    return p->getDataType();
}

void NumericInput::setIncrement(const double value, PropertyAccessControl* ac) {
    if(ac == NULL)
        ac = accessControl;
    char s[32];
    snprintf(s, sizeof(s), "%.15g", value);
    Property::setProperty(*this, "gui:increment", s, "text/x-float", ac);
}

Property* NumericInput::getIncrementObject() {
    return meta_cast<Property*>(&findObject("gui:increment"));
}

void NumericInput::setIncrementObject(Property* newobj) {
    try {
        vRef<ParentChildRelation> pcr = findChild("gui:increment");
        setChild(pcr->position, "gui:increment", newobj);
    } catch (NoSuchObjectError) {
        insertChild(-1, "gui:increment", newobj);
    }
}
/* Generators for factory */

MetaObject* LocalNumericInput::new_LocalNumericInput(MetaObject *s, const string& type) {
    LocalNumericInput* o = new LocalNumericInput(s);
    return o;
}

MetaObject* RemoteNumericInput::new_RemoteNumericInput(MetaObject *s, const string& type) {
    return new RemoteNumericInput(s);
}

---