DbField.h

Go to the documentation of this file.

// Copyright (C) 2002-2024, 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 Open Design Alliance software pursuant to a license 
//   agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2024 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 OD_DBFIELD_H
#define OD_DBFIELD_H
 
#include "TD_PackPush.h"
 
#include "DbObject.h"
#include "DbFieldValue.h"
#include "OdValue.h"
 
class OdDbField;
typedef OdSmartPtr<OdDbField> OdDbFieldPtr;

typedef OdArray<OdDbFieldPtr> OdDbFieldArray;
 

      typedef struct OdFd
{
  enum EvalFields
  {
    kEvalRecursive = 1
  };
  
} OdFd;
 
class OdDbField;

typedef OdSmartPtr<OdDbField> OdDbFieldPtr;
 
//*************************************************************************
// OdDbField
//*************************************************************************

class DBENT_EXPORT OdDbField : public OdDbObject
{
public:
  enum State
  {
    kInitialized        = 0x01,       // Field was initialized by the evaluator.
    kCompiled           = 0x02,       // Field was compiled.
    kModified           = 0x04,       // Field was modified, but not evaluated.
    kEvaluated          = 0x08,       // Field was evaluated.
    kHasCache           = 0x10,       // Field has evaluated cache.
    kHasFormattedString = 0x20        // Internal use only. 
  };
  
  enum EvalOption
  {
    kDisable            = 0,          // Do not evaluate field.
    kOnOpen             = 0x01,       // Evaluate field when a drawing is opened.
    kOnSave             = 0x02,       // Evaluate field when a drawing is saved.
    kOnPlot             = 0x04,       // Evaluate field when a drawing is printed.
    kOnEtransmit        = 0x08,       // Evaluate field when a drawing is etransmitted.
    kOnRegen            = 0x10,       // Evaluate field when a drawing is regenerated.
    kOnDemand           = 0x20,       // Evaluate field when demanded.
    kAutomatic          = (kOnOpen | kOnSave | kOnPlot |  kOnEtransmit | kOnRegen | kOnDemand) // Evaluate automatically.
  };
  
  enum EvalContext
  {
    kOpen               = 0x01,       // Field is being evaluated when a drawing is opened.
    kSave               = 0x02,       // Field is being evaluated when a drawing is saved.
    kPlot               = 0x04,       // Field is being evaluated when a drawing is printed.
    kEtransmit          = 0x08,       // Field is being evaluated when a drawing is etransmitted.
    kRegen              = 0x10,       // Field is being evaluated when a drawing is regenerated.
    kDemand             = 0x20,       // Field is being evaluated when demanded.
    kPreview            = 0x40        // Field is being evaluated when a drawing is previewed.
  };
  
  enum EvalStatus
  {
    kNotYetEvaluated    = 0x01,       // Evaluation not performed.
    kSuccess            = 0x02,       // Evaluation complete: Successful.
    kEvaluatorNotFound  = 0x04,       // Evaluator for the field not found.
    kSyntaxError        = 0x08,       // Evaluation complete: Syntax error in field code.
    kInvalidCode        = 0x10,       // Evaluation complete: Invalid field code.
    kInvalidContext     = 0x20,       // Evaluation complete: Invalid context to evaluate field.
    kOtherError         = 0x40        // Evaluation complete: Other evaluation error.
  };
  
  enum FieldCodeFlag
  {
    kRawCode            = 0x00,       // Returns the raw main field code. Ignored by setFieldCode().
    kFieldCode          = 0x01,       // Returns the raw field code with child codes substituted. Ignored by setFieldCode().
    kEvaluatedText      = 0x02,       // Returns the evaluated text. Ignored by setFieldCode().
    kEvaluatedChildren  = 0x04,       // Returns the field code with evaluated text for child fields. Ignored by setFieldCode().
    kObjectReference    = 0x08,       // Returns embedded text as references to child fields. Ignored by setFieldCode().
    kAddMarkers         = 0x10,       // Returns embedded text as field codes enclosed in field markers. Ignored by setFieldCode().
    kEscapeBackslash    = 0x20,       // Converts single backslashes to double backslashes. Ignored by setFieldCode().
    kStripOptions       = 0x40,       // Strips the standard options from the field code. Ignored by setFieldCode().
    kPreserveFields     = 0x80,       // Internal use only. Ignored by getFieldCode().
    kTextField          = 0x100,      // Treats the field as text with embedded fields. Ignored by getFieldCode().
    kPreserveOptions    = 0x200,      // Ignored by getFieldCode(). For internal use.
    kDetachChildren     = 0x400,      // Ignored by getFieldCode(). For internal use.
    kChildObjectReference = 0x800,    // Get child fields as object references. For internal use. 
    kForExpression      = 0x1000      // Get the value in a format used in arithmatic expressions (e.g. vector child values are put in square brackets). For internal use. Ignored by setFieldCode().
  };
  
  enum FilingOption
  {
    kSkipFilingResult   = 0x01        // Don't file field value.
  };
  
public:
  ODDB_DECLARE_MEMBERS(OdDbField);
  
  OdDbField();
 
  // OdDbField(const OdString& fieldCode, bool bTextField = false);
  // ~OdDbField(void);
  
  OdResult setInObject(
    OdDbObject* pOwner, 
    const OdString& propertyName);
  
  virtual OdResult postInDatabase(
    OdDbDatabase* pDb);
  
  OdDbField::State state() const;
  
  OdDbField::EvalStatus evaluationStatus() const; 
                                          // OdUInt32* errCode = 0, 
                                         // OdString* errMsg = 0) const;

  OdDbField::EvalOption evaluationOption() const;
  
  OdResult setEvaluationOption(
    OdDbField::EvalOption evaluationOption);
    
  OdDbField::FilingOption filingOption() const;
  
  OdResult setFilingOption(
    OdDbField::FilingOption filingOption);
  
  OdString evaluatorId() const;

  OdResult setEvaluatorId(
    const OdString& evaluatorId);
  
  bool isTextField() const;
 
  // OdResult convertToTextField (void);
 
  // OdString getFieldCode     (OdDbField::FieldCodeFlag nFlag, OdArray<OdDbField*>* pChildFields = 0, 
  //                           OdDb::OpenMode mode = OdDb::kForRead) const;
  
  OdString getFieldCode(
    OdDbField::FieldCodeFlag flags);
 
  //                      OdArray<OdDbField*>* pChildFields = 0, 
  //                      OdDb::OpenMode mode = OdDb::kForRead) const;
 

  OdResult setFieldCode(
    const OdString& fieldCode, 
    OdDbField::FieldCodeFlag flags = (OdDbField::FieldCodeFlag) 0,
    OdDbFieldArray* pChildFields = 0);

  OdResult setFieldCodeWithParse(const OdString& fieldCode,
    OdDbField::FieldCodeFlag flags = (OdDbField::FieldCodeFlag) 0);

  OdUInt32  childCount() const;
  
  OdDbFieldPtr getChild(
    OdUInt32 childIndex, 
    OdDb::OpenMode openMode);

  OdString getFormat() const;

  OdResult setFormat(
    const OdString& format);
          

  OdResult evaluate(
    int nContext, 
    OdDbDatabase* pDb = 0, 
    int* pNumFound = 0, 
    int* pNumEvaluated = 0);
  
  
  OdValue::DataType dataType() const;

  OdString getValue() const;
  
  OdResult getValue(
    OdFieldValue& pValue) const;
            
  bool  hasHyperlink() const;
 
  OdResult getHyperlink(OdString& psName,
                        OdString& psDescription, 
                        OdString& psSubLocation,
                        OdString& psDisplayString) const;
 
  OdResult setHyperlink(const OdString& psName, 
                        const OdString& psDescription, 
                        const OdString& psSubLocation = OdString::kEmpty);
 
  OdResult removeHyperlink();
  
  OdFieldValue getData(
    const OdString& key) const;
  
  OdResult setData(
    const OdString& key, 
    const OdFieldValue& pData);

  virtual OdDbObjectId setField(const OdString& propName, OdDbField* pField) ODRX_OVERRIDE;

  OdResult removeField(OdDbObjectId fieldId);
public:
  // Base class overrides
 
  virtual OdResult dwgInFields(
    OdDbDwgFiler* pFiler);
  virtual void dwgOutFields(
    OdDbDwgFiler* pFiler) const;
  virtual OdResult dxfInFields(
    OdDbDxfFiler* pFiler);
  virtual void dxfOutFields(
    OdDbDxfFiler* pFiler) const;
  
  virtual void subClose();
};
 
#define TEXT_FIELD_NAME OD_T("TEXT")
 
DBENT_EXPORT OdDbFieldPtr copyTextFieldToObject(OdDbFieldPtr srcField, OdDbObject* pObj);
DBENT_EXPORT OdDbFieldPtr copyFieldWithChild(OdDbFieldPtr srcField, bool addToDb = true);
 
#include "TD_PackPop.h"
#endif // OD_DBFIELD_H