vos/gui/gui/select_value.cc

Go to the documentation of this file.

/* $Id: select_value.cc,v 1.5 2003/07/23 00:17:21 reed Exp $ */

/** @file select_value.cc Code: a MetaObject for widget.select.value object types. 

    Copyright (C) 2002 Reed Hedges

    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 "select_value.hh"

using namespace std;
using namespace VOSGUI;

/* Constructor */
SelectValue::SelectValue(MetaObject* s) : MetaObject(s), Select(s), Widget(s),
    choices(0), selected(0)
{
}

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


LocalSelectValue::LocalSelectValue(MetaObject* s) : SelectValue(s), MetaObject(s), Select(s), LocalSelect(s), Widget(s), LocalWidget(s)
{
}

LocalSelectValue::~LocalSelectValue() {
}



RemoteSelectValue::RemoteSelectValue(MetaObject* s) : SelectValue(s), MetaObject(s), Select(s), RemoteSelect(s), Widget(s), RemoteWidget(s)
{
}

RemoteSelectValue::~RemoteSelectValue() {
}

/* Return type string ("gui:widget.select.value") */
const string SelectValue::getType() {
    return string("gui:widget.select.value");
}

/* Register extenders with libvos MetaFactory */
void SelectValue::registerExtenders() {
    LocalSite::addLocalObjectExtension(typeid(LocalSelectValue).name(), &LocalSelectValue::new_LocalSelectValue);
    LocalSite::addLocalObjectExtension(typeid(SelectValue).name(), &LocalSelectValue::new_LocalSelectValue);
    LocalSite::addLocalObjectExtension("gui:widget.select.value", &LocalSelectValue::new_LocalSelectValue);
    RemoteSite::addRemoteObjectExtension(typeid(RemoteSelectValue).name(), &RemoteSelectValue::new_RemoteSelectValue);
    RemoteSite::addRemoteObjectExtension(typeid(SelectValue).name(), &RemoteSelectValue::new_RemoteSelectValue);
    RemoteSite::addRemoteObjectExtension("gui:widget.select.value", &RemoteSelectValue::new_RemoteSelectValue);
}

string SelectValue::getValue() {
    return selected->read();
}

void SelectValue::getValue(string& v) {
    selected->read(v);
}

void SelectValue::setValue(const string& v) {
    selected->replace(v);
}


void SelectValue::add(const string& label, Property* p) {
    choices->insertChild(-1, label, p);
}

void SelectValue::add(Property* p) {
    add(p->read(), p);
}

void SelectValue::add(const string& label, const string& value, PropertyAccessControl* pac) {
    vRef<Site> site = getSite();
    vRef<LocalProperty> p = meta_cast<LocalProperty*>(site->createMetaObject("", typeid(LocalProperty).name(), 0));
    p->insertPropertyAccessControl(0, pac);
    p->replace(value);
    add(label, &p);
}

void SelectValue::add(const string& val, PropertyAccessControl* pac) {
    add(val, val, pac);
}

void SelectValue::remove(const string& v) throw(NoSuchObjectError) {

    ///@bug only removes the first occurance of the object.

    const ChildList& cl = choices->getChildren();
    int pos = -1;
    for(ChildList::const_iterator i = cl.begin(); i != cl.end(); i++) {
        vRef<Property> p = meta_cast<Property*>((*i)->child);
        if(&p) {
            if(p->read() == v) {
                pos = (*i)->position;
                break;
            }
        }
    }
    if(pos == -1)
       throw NoSuchObjectError("No such object in the selection's choices-object value");
    else
           choices->removeChild(pos); 
}


Property* SelectValue::getSelectedObj() {
    return &selected;
}

Property* SelectValue::getStyleObj() {
    vRef<Property> p = meta_cast<Property*>(&findObject("gui:style"));
    if(!&p) throw bad_cast();
    return &p;
}

void SelectValue::setSelectedObj(Property* obj) {
    selected = obj;
    // TODO: remove existing "gui:selected" ?
    insertChild(-1, "gui:selected", &selected);
}


Vobject* SelectValue::getChoicesObj() {
    return &choices;
}


void SelectValue::setChoicesObj(Vobject* obj) {
    choices = obj;
    // TODO: remove existing "gui:choices" ?
    insertChild(-1, "gui:choices", &choices);
}

void SelectValue::setStyle(const string& style, PropertyAccessControl* pac) {
    if(!pac) pac = accessControl;
    Property::setProperty(*this, "gui:style", style, "text/plain", pac);
}
    
void SelectValue::setPopup(PropertyAccessControl* pac) {
    setStyle("popup", pac);
}

void SelectValue::setRadio(PropertyAccessControl* pac) {
    setStyle("radio", pac);
}

string SelectValue::getStyle() {
    return Property::getProperty(*this, "gui:style", "popup");
}

void SelectValue::setRadioOrientation(const string& ori, PropertyAccessControl* ac) {
    if(ac == 0) 
        ac = accessControl;
    Property::setProperty(*this, "gui:radio-orientation", ori, "text/plain", ac);
}

string SelectValue::getRadioOrientation() {
    return Property::getProperty(*this, "gui:radio-orientation", "horizontal");
}

void SelectValue::setRadioSize(int n, PropertyAccessControl* ac) {
    if(ac == 0)
        ac = accessControl;
    Property::setIntProperty(*this, "gui:radio-size", n, ac);
}

int SelectValue::getRadioSize() {
    return Property::getIntProperty(*this, "gui:radio-size");
}

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

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

void LocalSelectValue::initialize() {
    vRef<Site> site = getSite();
    try {
        choices = findObject("gui:choices");
    } catch(NoSuchObjectError) {
        choices = site->createMetaObject("gui:choices", 0);
        insertChild(-1, "gui:choices", &choices);
        choices->addChildListener(&DoNothingListener::static_);
    }
    try {
        selected = meta_cast<Property*>(&findObject("gui:selected"));
        assert(&selected);
    } catch(NoSuchObjectError) {
        selected = meta_cast<Property*>(site->createMetaObject("gui:selected", typeid(Property).name(), 0));
        insertChild(-1, "gui:selected", &selected);
    } 
    setPopup();
    SelectValue::initialize();
}

void SelectValue::initialize() {
    try {
        choices = findObject("gui:choices");
    } catch(NoSuchObjectError) {
        LOG("GUI::SelectValue", 2, "initialize(): Warning: no \"gui:choices\" object found.");
    }
    try {
        selected = meta_cast<Property*>(&findObject("gui:selected"));
        assert(&selected);
    } catch(NoSuchObjectError) {
        LOG("GUI::SelectValue", 2, "initialize(): Warning: no \"gui:selected\" object found.");
    }
}

---