FdField.h

Go to the documentation of this file.

// Copyright (C) 2002-2017, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Teigha(R) software pursuant to a license 
//   agreement with Open Design Alliance.
//   Teigha(R) Copyright (C) 2002-2017 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
 
 
#ifndef _FdField_h_Included_
#define _FdField_h_Included_
 
#include "RxObject.h"
#include "RxDictionary.h"
#include "DbField.h"
 
class OdDbField;
class OdDbEvalVariant;
class OdFieldValue;
class OdFdFieldEngineImpl;
class OdFdFieldResult;
class OdDbDatabase;
 
#include "TD_PackPush.h"
 
class TOOLKIT_EXPORT OdFdFieldEvaluator : public OdRxObject
{
public:
  ODRX_DECLARE_MEMBERS(OdFdFieldEvaluator);
 
  virtual const OdString evaluatorId() const = 0;
  virtual const OdString evaluatorId(OdDbField* pField) const = 0;
  virtual OdResult initialize(OdDbField* pField) const = 0; 
 
//    The field framework calls this method to compile a field when the field code is changed.   
  
  virtual OdResult compile(OdDbField* pField, 
    OdDbDatabase* pDb,
    OdFdFieldResult* pResult) const = 0;
 
//  The field framework calls this method to evaluate a field whenever the field needs 
//    to be evaluated.
 
  virtual OdResult evaluate(OdDbField* pField, 
    int nContext, 
    OdDbDatabase* pDb, 
    OdFdFieldResult* pResult) const = 0;
 
//      The field framework calls this method when a field is queried 
//      to get the evaluated field value as a string. The evaluator can 
 
  virtual OdResult format(OdDbField* pField, OdString& pszValue) const = 0;
};
 
typedef OdSmartPtr<OdFdFieldEvaluator> OdFdFieldEvaluatorPtr;
 
class TOOLKIT_EXPORT OdFdFieldEvaluatorLoader : public OdRxObject
{
public:
  ODRX_DECLARE_MEMBERS(OdFdFieldEvaluatorLoader);
 
  virtual OdFdFieldEvaluator* getEvaluator(
    const OdString& pszEvalId) = 0;
 
  virtual OdFdFieldEvaluator * findEvaluator(
    OdDbField* pField, 
    OdString& pszEvalId) = 0;
};
 
class TOOLKIT_EXPORT OdFdFieldReactor : public OdRxObject
{
public:
  ODRX_DECLARE_MEMBERS(OdFdFieldReactor);
 
  virtual void beginEvaluateFields(
    int nContext, 
    OdDbDatabase* pDb);
  
  virtual void endEvaluateFields(
    int nContext, 
    OdDbDatabase* pDb);
};
 
typedef OdArray<OdFdFieldReactor*> FieldReactors;
 
class TOOLKIT_EXPORT OdFdFieldEngine : public OdRxObject
{
public:
  ODRX_DECLARE_MEMBERS(OdFdFieldEngine);
  virtual ~OdFdFieldEngine(){}
  virtual void registerEvaluatorLoader(OdFdFieldEvaluatorLoader* pLoader) = 0;
 
  virtual void unregisterEvaluatorLoader(OdFdFieldEvaluatorLoader* pLoader) = 0;
 
  virtual int evaluatorLoaderCount() const = 0;
 
  virtual OdFdFieldEvaluatorLoader * getEvaluatorLoader(int inputIndex) = 0;
 
  virtual OdFdFieldEvaluator * getEvaluator (
    const OdString& pszEvalId) = 0;
 
  virtual OdFdFieldEvaluator * findEvaluator(
    OdDbField* pField,
    OdString& pszEvalId) = 0;
 
  virtual void addFieldReactor(OdFdFieldReactor* pReactor) = 0;
  
  virtual void removeFieldReactor(OdFdFieldReactor* pReactor) = 0;
};
 
typedef OdSmartPtr<OdFdFieldEngine> OdFdFieldEnginePtr;
#define ODFD_FIELD_ENGINE             OD_T("FieldEngine")
 
TOOLKIT_EXPORT OdFdFieldEnginePtr oddbGetFieldEngine();
 
TOOLKIT_EXPORT OdString oddbGetFieldEngineValueByError(const OdString& sPrevValue);
TOOLKIT_EXPORT OdString oddbSetFieldEngineValueFormatByError(
                          const OdString& sValue = L"%ls"); // value to keep result of previous evaluation
 
class TOOLKIT_EXPORT OdFdFieldResult : public OdRxObject
{
public:
  ODRX_DECLARE_MEMBERS(OdFdFieldResult);
  OdFdFieldResult();
  
  virtual void setFieldValue(const OdFieldValue* pValue) = 0;
  
  virtual void setEvaluationStatus(OdDbField::EvalStatus errorStatus, int errorCode = 0, const OdString& errorMessage = OdString()) = 0;
};
 
class TOOLKIT_EXPORT OdFdFieldEnginePE : public OdRxObject
{
public:
  ODRX_DECLARE_MEMBERS(OdFdFieldEnginePE);
  virtual bool getSheetSetProperty(OdString& propValue, const OdString& compName, const OdString& propName, OdDbDatabase* pDb) = 0;
 
  virtual bool parseObjProp(const OdString& prop, OdDbDatabase* pDb, OdDbObjectId& objId, OdString& propName) = 0;
 
  virtual bool getObjPropValue(const OdString& propName, const OdDbObjectId& objId, OdFdFieldResult& result) = 0;
 
  virtual OdDbDatabase* getCurrentDb() = 0;
 
  virtual OdString getFileName(OdDbDatabase* pDb) = 0;
 
  virtual void getLispVariable(const OdString& lispVar, OdFieldValue& fValue) = 0;
 
  virtual OdDbObjectId getOwnerTable(const OdDbField* field) = 0;
};
 
typedef OdSmartPtr<OdFdFieldEnginePE> OdFdFieldEnginePEPtr;
 
TOOLKIT_EXPORT OdResult oddbEvaluateFields( 
  OdDbDatabase* pDb,
  int nContext,
  const OdDbObjectIdArray* objIds = 0, 
  const OdDbObjectIdArray* pFieldsToEvaluate = 0,
  const OdString& pszEvaluatorId = OdString(),
  OdFd::EvalFields nEvalFlag = OdFd::kEvalRecursive,
  int* pNumFound = 0,
  int* pNumEvaluated = 0);
 
 
#include "TD_PackPop.h"
 
#endif //_FdField_h_Included_