EdUserIO.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 _ODEDUSERIO_H_INCLUDED_
#define _ODEDUSERIO_H_INCLUDED_
 
#include "OdPlatform.h"
#include "Gi/GiDrawable.h"
#include "OdString.h"
#include "SharedPtr.h"
#include "RxObject.h"
 
#include "../FxClangExceptionRTTIWorkaround.h"
 
class OdGePoint3d;
 
#include "TD_PackPush.h"

namespace OdEd
{
  enum CommonInputOptions
  {
    kInpDefault       = 0x00000000,
    kInpDisallowEmpty = kInpDefault,
    kInpDisallowOther = kInpDisallowEmpty,
    kInpThrowEmpty    = (long)0x80000000,
    kInpThrowOther    = 0x40000000,
    kInpNonZero       = 0x20000000, // Disallow zero input 
    kInpNonNeg        = 0x10000000, // Disallow negative input 
    kInpThrowEmptyInQuotes = 0x02000000
  };
 
  enum GetFilePathFlags
  {
    kGfpForOpen         = 0, // For Open.
    kGfpForSave         = 1, // For Save.
    kGfpOverwritePrompt = 2  // Enable overwrite prompt displaying when exist file selected for saving.
  };
 
  enum GetStringOptions
  {
    kGstDefault      = 0, // Spaces disallowed, no KeywordExceptions
    kGstNoSpaces     = 0, // Spaces disallowed
    kGstAllowSpaces  = 1, // The first space character will not terminate the input.
    kGstNoEmpty      = 2  // The first space character will not terminate the input.
  };
 
  enum OdDbInputOptions
  {
    kGptDefault         = 0x00000000,
    kGdsDefault         = kGptDefault,
    kGinDefault         = kGptDefault,
    kGrlDefault         = kGptDefault,
    kGanDefault         = kGptDefault,
    kGptNoLimCheck      = 0x00000001, // Ignore the LIMMIN and LIMMAX system variables
    kGptNoUCS           = 0x00000002, // Do not project result point onto UCS plane (input point in eye plane)
    kGptRubberBand      = 0x00000004,
    kGptRectFrame       = 0x00000008,
    kGptBeginDrag       = 0x00000010,
    kGptEndDrag         = 0x00000020,
    kGptNoOSnap         = 0x00000040, // Disables object snaps
    kGanFromLastPoint   = 0x00000080,
    kGdsFromLastPoint   = kGanFromLastPoint,
    kGanNoAngBase       = 0x00000100,
    kGds2d              = 0x00000200, // Restrict (getDistance) to 2D
    kGdsSignedDist      = 0x00000400,
    kGdsPerpDist        = 0x00000800, // is in perpendicular plane to UCS plane
    kGdsNoZero          = 0x00001000,
    kGinNoZero          = kGdsNoZero,
    kGrlNoZero          = kGdsNoZero,
    kGanNoZero          = kGdsNoZero,
    kGdsNoNeg           = 0x00002000,
    kGinNoNeg           = kGdsNoNeg,
    kGrlNoNeg           = kGdsNoNeg
  };
 
  enum SelectOptions
  {
    kSelDefault         = 0x00000000,
    kSelPickLastPoint   = 0x00000001,  // Use last entered point as first corner of selection box
    kSelSingleEntity    = 0x00000002,  // Select single entity
    kSelIgnorePickFirst = 0x00000004,  // Clear previous contents of selection set
    kSelSinglePass      = 0x00000008,  // Use single pass for selection
                                       // (no pressing Enter is required to finish selection)
    kSelAllowEmpty      = 0x00000010,  // Empty selection set is allowed
    kSelRemove          = 0x00000020,  // Remove selected entities from current selection set
    kSelLeaveHighlighted= 0x00000040,  // Leave entities highlighted after operation
    kSelAllowInactSpaces= 0x00000080,  // Allow selection of all entities not only in active layout
    
    kSelAllowObjects    = 0x00000100,  // Allow non-entity objects selection
    kSelAllowPSVP       = 0x00000200,  // Allow overall Paper Space viewport selection
    kSelAllowSubents    = 0x00000400,  // Allow subentities selection
    kSelAllowLocked     = 0x00000800,   // Allow selection of entities on locked layers
 
    kSelAllowSubentsAlways    = 0x00001000,  // Allow subentities selection independent on press CTRL
  };
}
 
class OdGsView;
class OdGsModel;
 
class OdCmColorBase;
 
//
// OdEd_Classes
//

class ODRX_ABSTRACT FIRSTDLL_EXPORT OdEdInputTracker : public OdRxObject
{
public:
  ODRX_DECLARE_MEMBERS(OdEdInputTracker);
 
  virtual int addDrawables(OdGsView* pView);
  virtual void removeDrawables(OdGsView* pView);
};

typedef OdSmartPtr<OdEdInputTracker> OdEdInputTrackerPtr;
 

class ODRX_ABSTRACT FIRSTDLL_EXPORT OdEdIntegerTracker : public OdEdInputTracker
{
public:
  ODRX_DECLARE_MEMBERS(OdEdIntegerTracker);

  using argument_type = int;
 
  virtual void setValue(argument_type value) = 0;
};

typedef OdSmartPtr<OdEdIntegerTracker> OdEdIntegerTrackerPtr;
 

class ODRX_ABSTRACT FIRSTDLL_EXPORT OdEdRealTracker : public OdEdInputTracker
{
public:
  ODRX_DECLARE_MEMBERS(OdEdRealTracker);

  using argument_type = double;
 
  virtual void setValue(argument_type value) = 0;
};

typedef OdSmartPtr<OdEdRealTracker> OdEdRealTrackerPtr;
 

class ODRX_ABSTRACT FIRSTDLL_EXPORT OdEdStringTracker : public OdEdInputTracker
{
protected:
  bool bShowCursor = false;
public:
  ODRX_DECLARE_MEMBERS(OdEdStringTracker);

  using argument_type = const OdString&;
 
  virtual void setValue(argument_type value) = 0;
 
  virtual void setCursor(const bool& showCursor)
  {
    this->bShowCursor = showCursor;
  }
};

typedef OdSmartPtr<OdEdStringTracker> OdEdStringTrackerPtr;
 

class ODRX_ABSTRACT FIRSTDLL_EXPORT OdEdPointTracker : public OdEdInputTracker
{
public:
  ODRX_DECLARE_MEMBERS(OdEdPointTracker);

  using argument_type = const OdGePoint3d&;
 
  virtual void setValue(argument_type value) = 0;
};

typedef OdSmartPtr<OdEdPointTracker> OdEdPointTrackerPtr;
 

class ODRX_ABSTRACT FIRSTDLL_EXPORT OdEdPointDefTracker : public OdEdPointTracker
{
public:
  ODRX_DECLARE_MEMBERS(OdEdPointDefTracker);
 
  virtual OdGePoint3d basePoint() const = 0;
};

typedef OdSmartPtr<OdEdPointDefTracker> OdEdPointDefTrackerPtr;
 

class ODRX_ABSTRACT FIRSTDLL_EXPORT OdEdColorTracker : public OdEdInputTracker
{
public:
  ODRX_DECLARE_MEMBERS(OdEdColorTracker);

  using argument_type = const OdCmColorBase&;
 
  virtual void setValue(argument_type value) = 0;
};

typedef OdSmartPtr<OdEdColorTracker> OdEdColorTrackerPtr;
 
 
//
// OdEd_Exceptions
//
 
#define OdException OdError
 

class FIRSTDLL_EXPORT OdEdException : public OdException
{
protected:
  OdEdException();
  OdEdException(OdErrorContext* pErrCtx);
  
  FX_DECLARE_CLANG_RTTI_EXCEPTION_WORKAROUND(); // FELIX_CHANGE
};
 

class FIRSTDLL_EXPORT OdEdCancel : public OdEdException
{
public:

  OdEdCancel();
  
  OdEdCancel(OdErrorContext* pErrCtx);
 
  FX_DECLARE_CLANG_RTTI_EXCEPTION_WORKAROUND(); // FELIX_CHANGE
};
 

class FIRSTDLL_EXPORT OdEdKeyword : public OdEdException
{
public:
  
  OdEdKeyword(int nKeyword, const OdString& sKeyword);
 
  int keywordIndex() const;
  const OdString& keyword() const;
  
  FX_DECLARE_CLANG_RTTI_EXCEPTION_WORKAROUND(); // FELIX_CHANGE
};
 

class FIRSTDLL_EXPORT OdEdOtherInput : public OdEdCancel
{
public:
  
  OdEdOtherInput(const OdString& sInput);
  const OdString& string() const;
 
  FX_DECLARE_CLANG_RTTI_EXCEPTION_WORKAROUND(); // FELIX_CHANGE
};
 

class FIRSTDLL_EXPORT OdEdEmptyInput : public OdEdCancel
{
public:
  
  OdEdEmptyInput();
  
  FX_DECLARE_CLANG_RTTI_EXCEPTION_WORKAROUND(); // FELIX_CHANGE
};
 

class ODRX_ABSTRACT FIRSTDLL_EXPORT OdEdUserIO : public OdRxObject
{ 
public:
  ODRX_DECLARE_MEMBERS(OdEdUserIO);

  virtual bool interactive();

  virtual int getKeyword(
    const OdString& prompt,
    const OdString& keywords,
    int defVal = -1,
    int options = OdEd::kInpDefault,
    OdEdIntegerTracker* pTracker = 0) = 0;

  virtual int getInt(
    const OdString& prompt,
    int options = OdEd::kInpDefault,
    int defVal = 0,
    const OdString& keywords = OdString::kEmpty,
    OdEdIntegerTracker* pTracker = 0) = 0;

  virtual double getReal(
    const OdString& prompt, 
    int options = OdEd::kInpDefault,
    double defVal = 0.0,
    const OdString& keywords = OdString::kEmpty,
    OdEdRealTracker* pTracker = 0) = 0;

  virtual OdString getString(
    const OdString& prompt, 
    int options = OdEd::kInpDefault, 
    const OdString& defValue = OdString::kEmpty,
    const OdString& keywords = OdString::kEmpty,
    OdEdStringTracker* pTracker = 0) = 0;
                                 
  virtual void putString(const OdString& string) = 0;

  virtual OdSharedPtr<OdCmColorBase> getCmColor(
    const OdString& prompt,
    int options = OdEd::kInpDefault,
    const OdCmColorBase* pDefaultValue = 0,
    const OdString& keywords = OdString::kEmpty,
    OdEdColorTracker* pTracker = 0) = 0;

  virtual OdString getFilePath(
      const OdString& prompt, 
      int options = OdEd::kGfpForOpen,
      const OdString& dialogCaption = OdString::kEmpty, 
      const OdString& defExt = OdString::kEmpty,
      const OdString& fileName = OdString::kEmpty,
      const OdString& filter = OdString::kEmpty,
      const OdString& keywords = OdString::kEmpty,
      OdEdStringTracker*  pTracker = 0);

  virtual void putError(const OdString& errmsg) { putString(errmsg); }
};
 
#include "TD_PackPop.h"
 
#endif //#ifndef _ODEDUSERIO_H_INCLUDED_