MFXBaseObject.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2004-2024 German Aerospace Center (DLR) and others.
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0/
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License 2.0 are satisfied: GNU General Public License, version 2
// or later which is available at
// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
/****************************************************************************/
//
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <FXHash.h>
using namespace FX;
 
namespace FXEX {
 
#define FXMAPALL(func) {MKUINT(MINKEY,MINTYPE),MKUINT(MAXKEY,MAXTYPE),&func}
 
#define FXMAPKEY(key,func)  {MKUINT(key,MINTYPE),MKUINT(key,MAXTYPE),&func}
 
 
class /* FXAPI // patch by Daniel Krajzewicz 24.02.2004 */
    MFXBaseObject : public FXObject {
    FXDECLARE(MFXBaseObject)
 
protected:
    enum {
        FLAG_ENABLED  = 0x00000002,   // enabled
        FLAG_UPDATE   = 0x00000004,   // needs update
        FLAG_FOCUSED  = 0x00000010,   // has focus
        FLAG_DIRTY    = 0x00000020,   // dirty
        FLAG_RECALC   = 0x00000040,   // needs recalculation
        FLAG_DEFAULT  = 0x00000200,   // set to default
        FLAG_INITIAL  = 0x00000400,   // set to initial value
        FLAG_ACTIVE   = 0x00001000,   // active
        FLAG_CHANGED  = 0x00010000,   // changed
        FLAG_READONLY = 0x10000000    // read only
    };
 
private:
    FXApp*        app;             // application pointer
 
protected:
    FXObject*     target;          // application target
    FXSelector    message;         // application message
    void*         data;            // user data
    FXuint        datalen;         // length of user data
    FXuint        flags;           // state flags
    FXuint        options;         // option flags
 
public:
    enum {
        ID_NONE = 0,
        ID_DELETE = 6,
        ID_DISABLE,
        ID_ENABLE,
        ID_SETVALUE = 17,
        ID_SETINTVALUE,
        ID_SETREALVALUE,
        ID_SETSTRINGVALUE,
        ID_SETINTRANGE,
        ID_SETREALRANGE,
        ID_GETINTVALUE,
        ID_GETREALVALUE,
        ID_GETSTRINGVALUE,
        ID_XML,
        ID_META,
        ID_COMMENT,
        ID_DOCUMENT,
        ID_TAG,
        ID_CONTENT,
        ID_LAST
    };
 
public:
    long onCmdEnable(FXObject*, FXSelector, void*);
    long onCmdDisable(FXObject*, FXSelector, void*);
    long onUpdate(FXObject*, FXSelector, void*);
 
public:
    MFXBaseObject(FXObject* tgt = NULL, FXSelector sel = 0);
 
    MFXBaseObject(FXApp* a, FXObject* tgt = NULL, FXSelector sel = 0);
 
    FXApp* getApp();
 
    FXObject* getTarget() {
        return target;
    }
 
    void setTarget(FXObject* tgt) {
        target = tgt;
    }
 
    FXSelector getSelector() {
        return message;
    }
 
    void setSelector(FXSelector sel) {
        message = sel;
    }
 
    void* getUserData() {
        return data;
    }
 
    void setUserData(void* d) {
        data = d;
    }
 
    FXuint getUserDataLen() {
        return datalen;
    }
 
    void setUserDataLen(FXuint len) {
        datalen = len;
    }
 
    FXbool isEnabled() {
        return (flags & FLAG_ENABLED) != 0;
    }
 
    virtual void enable() {
        flags |= FLAG_ENABLED;
    }
 
    virtual void disable() {
        flags &= ~FLAG_ENABLED;
    }
 
    virtual FXbool isReadonly() {
        return (flags & FLAG_READONLY) != 0;
    }
 
    virtual void setReadonly(FXbool mode = TRUE);
 
    virtual void create() {}
 
    virtual void detach() {}
 
    virtual void destroy() {}
 
    virtual void save(FXStream& store) const;
 
    virtual void load(FXStream& store);
 
    virtual ~MFXBaseObject();
};
 
} // namespace FXEX