vos/metaobjects/image2D/image2D.cc

Go to the documentation of this file.

/* $Id: image2D.cc,v 1.1 2002/08/25 16:38:06 reed Exp $ */


/*
    Image2D metaobject implementation
    Reed Hedges <reed@interreality.org> August 2002

    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

*/

/** @file image2D.cc Code: a MetaObject for Image2D object types. */

#include "vos/vos.hh"
#include "property/property.hh"
#include "image2D.hh"

/* Constructor */
Image2D::Image2D(MetaObject* s) : MetaObject(s) {
    accessControl = &NoPropertyAccessControl::static_;
}

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

LocalImage2D::LocalImage2D(MetaObject* s) : Image2D(s), MetaObject(s)
{
}

LocalImage2D::~LocalImage2D() {
}

/* Initialize required subobjects: */
void LocalImage2D::initialize() {

    pREF(LocalSite*, localsite, Site::getDefaultPeer(),
    try {
        rREF(Vobject&, v, findObject("image2D:position"), );
    } catch(NoSuchObjectError) {
        setPosition(0, 0);
    }
    try {
        rREF(Vobject&, v, findObject("image2D:orientation"), );
    } catch(NoSuchObjectError) {
        setOrientation(0.0);
    }
    try {
        rREF(Vobject&, v, findObject("image2D:scaling"), );
    } catch(NoSuchObjectError) {
        setScaling(100, 100);
    }
    try {
        rREF(Vobject&, v, findObject("image2D:image"), );
    } catch(NoSuchObjectError) {
        setImage("undefined", "?");
    }
    );
}

void LocalImage2D::initialize(PropertyAccessControl* ac) {
    accessControl = ac;
    initialize();
}
    

RemoteImage2D::RemoteImage2D(MetaObject* s) : Image2D(s), MetaObject(s)
{
}

RemoteImage2D::~RemoteImage2D() {
}

/* Return type string ("2D:image2D") */

const string Image2D::getType() {
    return string("image2D:image2D");
}

/* Register extenders with libvos MetaFactory */
void Image2D::registerExtenders() {
    LocalSite::addLocalObjectExtension(typeid(LocalImage2D).name(), &LocalImage2D::new_LocalImage2D);
    LocalSite::addLocalObjectExtension(typeid(Image2D).name(), &LocalImage2D::new_LocalImage2D);
    LocalSite::addLocalObjectExtension("image2D:image2D", &LocalImage2D::new_LocalImage2D);
    RemoteSite::addRemoteObjectExtension(typeid(RemoteImage2D).name(), &RemoteImage2D::new_RemoteImage2D);
    RemoteSite::addRemoteObjectExtension(typeid(Image2D).name(), &RemoteImage2D::new_RemoteImage2D); 
    RemoteSite::addRemoteObjectExtension("image2D:image2D", &RemoteImage2D::new_RemoteImage2D);     
}

/* Get and set Subproperties and other Subobjects */

void Image2D::getPosition(double& x, double& y) {
    rREF(Vobject&, v, findObject("image2D:position"), 
        string s;
        meta_cast<Property&>(v).read(s); 
        sscanf(s.c_str(), "%lf %lf", &x, &y);
    );
}


void Image2D::setPosition(double x, double y, PropertyAccessControl* ac) {
    if(ac == NULL)
        ac = accessControl;
    char s[20];
    snprintf(s, sizeof(s), "%f %f", x, y);
    Property::setProperty(*this, "image2D:position", s, "text/x-vector-float", ac);
}

double Image2D::getOrientation() {
    double o = 0;
    rREF(Vobject&, v, findObject("image2D:orientation"), 
        string s;
        meta_cast<Property&>(v).read(s);
        sscanf(s.c_str(), "%lf", &o);
     );
    return o;
}


void Image2D::setOrientation(double o, PropertyAccessControl* ac) {
    if(ac == NULL)
        ac = accessControl;
    char s[40];
    snprintf(s, sizeof(s), "%f", o);
    Property::setProperty(*this, "image2D:orientation", s, "text/x-vector-float", ac);
}

void Image2D::getScaling(double& x, double& y) {
    string s;
    rREF(Vobject&, v, findObject("image2D:scaling"), s = meta_cast<Property&>(v).read(); 
        sscanf(s.c_str(), "%lf %lf", &x, &y);
    );
}


void Image2D::setScaling(double x, double y, PropertyAccessControl* ac) {
    if(ac == NULL)
        ac = accessControl;
    char s[40];
    snprintf(s, sizeof(s), "%f %f", x, y); 
    Property::setProperty(*this, "image2D:scaling", s, "text/x-vector-float", ac);
}

string Image2D::getImage() {
    string s;
    rREF(Vobject&, v, findObject("image2D:image"), 
        meta_cast<Property&>(v).read(s); 
    );
    return s;
}

void Image2D::getImage(string& s) {
    rREF(Vobject&, v, findObject("image2D:image"), 
        meta_cast<Property&>(v).read(s); 
    );
}


string Image2D::getImageDatatype() {
    string s;
    rREF(Vobject&, v, findObject("image2D:image"), s = meta_cast<Property&>(v).getDataType(); );
    return s;
}

void Image2D::setImage(const string& value, const string& datatype,
PropertyAccessControl* ac) {
    if(ac == NULL)
        ac = accessControl;
    Property::setProperty(*this, "image2D:image", value, datatype, ac);
}

void Image2D::setImageFromFile(const string& filename, const string& datatype, PropertyAccessControl* ac) {
    cerr << "setimagefromfile: ";
    cerr << "reading from " << filename << endl;

    // not the best way: use c++ stream classes or buffered input?
    FILE* F = fopen(filename.c_str(), "r");
    string data = "";
    char c;
    while( (c = fgetc(F)) != EOF) {
        data += c;
    }
    fclose(F);
    setImage(data, datatype, ac);
}

int Image2D::getImageLength() {
    int l; 
    rREF(Vobject&, v, findObject("image2D:image"), l = meta_cast<Property&>(v).getLength(); );
    return l;
}

/* Process local object messages */
void LocalImage2D::sendMessage(Message* m) {


    /* Let superclass have message */
    Image2D::sendMessage(m);
}





/* Process remote update messages */
void RemoteImage2D::sendUpdateMessage(Message* m) {


    /* branch to update message handlers specific to RemoteImage2D */

    /* let superclass have message... */
    Image2D::sendUpdateMessage(m);
}


/* Generators for factory */


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

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

---