161 lines
9.6 KiB
C++
161 lines
9.6 KiB
C++
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright 2016 Autodesk, Inc. All rights reserved.
|
|
//
|
|
// Use of this software is subject to the terms of the Autodesk license
|
|
// agreement provided at the time of installation or download, or which
|
|
// otherwise accompanies this software.
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
#pragma once
|
|
#include "../../Core/Base.h"
|
|
#include "../FusionTypeDefs.h"
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
// THIS CLASS WILL BE VISIBLE TO AN API CLIENT.
|
|
// THIS HEADER FILE WILL BE GENERATED FROM NIDL.
|
|
#include "../../Core/OSMacros.h"
|
|
|
|
#ifdef FUSIONXINTERFACE_EXPORTS
|
|
# ifdef __COMPILING_ADSK_FUSION_CUSTOMFEATUREINPUT_CPP__
|
|
# define ADSK_FUSION_CUSTOMFEATUREINPUT_API XI_EXPORT
|
|
# else
|
|
# define ADSK_FUSION_CUSTOMFEATUREINPUT_API
|
|
# endif
|
|
#else
|
|
# define ADSK_FUSION_CUSTOMFEATUREINPUT_API XI_IMPORT
|
|
#endif
|
|
|
|
namespace adsk { namespace core {
|
|
class ValueInput;
|
|
}}
|
|
|
|
namespace adsk { namespace fusion {
|
|
|
|
/// This class defines the methods and properties that pertain to the definition of a Ruled Surface feature.
|
|
class CustomFeatureInput : public core::Base {
|
|
public:
|
|
|
|
/// Adds an entity or parameter this feature is dependent on. This is used by Fusion to know
|
|
/// when to recompute this feature and to control the behavior of the feature's node in the timeline.
|
|
/// id : An ID for this dependency. This is used to allow you to identify which dependency is which in the future.
|
|
/// The ID must be unique with respect to the other dependencies of this custom feature.
|
|
/// entity : The entity or parameter you want to add as a dependency. This can be a BRepBody, BRepFace, BrepEdge,
|
|
/// BRepVertex, a sketch, any sketch entities, a profile, any construction geometry, or any parameter.
|
|
/// Returns true if the dependency was successfully added.
|
|
bool addDependency(const std::string& id, const core::Ptr<core::Base>& entity);
|
|
|
|
/// Defines the information needed to create a new custom parameter that will be associated with
|
|
/// this feature. A custom parameter appears as a model parameter and will be listed as a child of the
|
|
/// custom feature in the parameter dialog. The custom feature will automatically have a dependency
|
|
/// on this parameter.
|
|
/// id : An id for this parameter. This is used to allow you to identify the parameter in the future. This
|
|
/// must be unique with respect to all other parameters associated with this custom feature. It's needed
|
|
/// because the label does not need to be unique and the Fusion auto-generated name can be edited by
|
|
/// the user.
|
|
/// label : The label for this parameter as seen in the parameters dialog. This identifies to the user the purpose
|
|
/// of this parameter. For example, when you create an extrusion with a specific distance, there are two
|
|
/// parameters displayed in the parameters dialog with the labels "AlongDistance" and "TaperAngle". This does
|
|
/// not have to be unique because in the case of a fillet feature there can be multiple parameters all labeled "Radius".
|
|
/// value : ValueInput object that specifies the value of the parameter. If the ValueInput was created using a real,
|
|
/// the value will be interpreted using the internal unit for the unit type specified by the "units" argument.
|
|
/// For example, if the ValueInput was created using the real value 5 and the input to the "units" argument is
|
|
/// any valid length unit, the value will be interpreted as 5 centimeters since centimeters is the internal unit
|
|
/// for lengths. If the "units" argument is a valid angle unit the value will be interpreted as 5 radians.
|
|
/// If the ValueInput was created using a string, the string is used as-is for the expression of the parameter.
|
|
/// This means if there are units as part of the string it must evaluate to the same unit type as that specified
|
|
/// by the "units" argument and if no units are specified it will use the current default units specified for
|
|
/// the current document. For example, if the ValueInput was created with the string "5 in", then the "units"
|
|
/// argument must define any valid length so it is compatible. If the ValueInput was created with the string "5",
|
|
/// any unit type can be used and the result will be 5 of that unit.
|
|
/// When using a ValueInput created using a string, it's the same as creating a parameter in the user-interface.
|
|
/// You can specify any valid expression, i.e. "5", "5 in", "5 in / 2", "5 + Length", etc. and you can choose
|
|
/// from many different types of units. The only requirement is that the units must match in type. For example,
|
|
/// they must both be lengths, or they must both be angles.
|
|
/// units : The units to use for the value of the parameter. Units specified must match the units specified (if any)
|
|
/// in the ValueInput object.
|
|
/// To create a parameter with no units (unitless) you can specify either an empty string.
|
|
/// isVisible : Optional argument that specifies if the parameter will be visible in the parameters dialog or not. By
|
|
/// default the parameter will be visible.
|
|
/// This can be useful in cases where the feature can be edited to be in different states where a parameter
|
|
/// is only valid in a certain state. You can change the visibility based on the current state of the feature
|
|
/// and if that parameter should be available for edit. This implies that you create all the parameters that
|
|
/// might be needed and then change their visibility based on the current state of the feature. The parameters
|
|
/// that are not visible will not be returned by the ModelParameters collection and are only available through
|
|
/// the custom feature they're associated with.
|
|
/// Returns true if the definition of the model parameter was successfully added.
|
|
bool addCustomParameter(const std::string& id, const std::string& label, const core::Ptr<core::ValueInput>& value, const std::string& units, bool isVisible = true);
|
|
|
|
/// Sets the start and end features that the custom feature will group. A "feature" in this
|
|
/// case is an object that is visible in the timeline, such as modeling features, sketches,
|
|
/// and construction geometry. The custom feature will group the input start and end features
|
|
/// and all features between them in the timeline.
|
|
/// You can determine the current start and end features using the features property and use
|
|
/// the first and last features returned. If the custom feature contains a single feature,
|
|
/// you can use the same feature for both the start and end feature arguments. You can also
|
|
/// use null for both arguments to remove all features from a custom feature. The custom feature
|
|
/// still exists but will be empty, and the features will be displayed individually within the timeline.
|
|
/// startFeature : The first feature in the timeline that the custom feature will group.
|
|
/// endFeature : The last feature in the timeline that the custom feature will group. When creating a custom feature
|
|
/// that contains a single feature, this can be the same feature as the startFeature argument.
|
|
/// Returns true if setting the start and end features was successful.
|
|
bool setStartAndEndFeatures(const core::Ptr<core::Base>& startFeature, const core::Ptr<core::Base>& endFeature);
|
|
|
|
/// Returns the features that are grouped by this custom feature. The start and end features and all of
|
|
/// the features between them in the timeline are returned. This includes all entities represented in
|
|
/// the timeline including modeling features, construction geometry, sketches, etc.
|
|
std::vector<core::Ptr<core::Base>> features() const;
|
|
|
|
ADSK_FUSION_CUSTOMFEATUREINPUT_API static const char* classType();
|
|
ADSK_FUSION_CUSTOMFEATUREINPUT_API const char* objectType() const override;
|
|
ADSK_FUSION_CUSTOMFEATUREINPUT_API void* queryInterface(const char* id) const override;
|
|
ADSK_FUSION_CUSTOMFEATUREINPUT_API static const char* interfaceId() { return classType(); }
|
|
|
|
private:
|
|
|
|
// Raw interface
|
|
virtual bool addDependency_raw(const char * id, core::Base* entity) = 0;
|
|
virtual bool addCustomParameter_raw(const char * id, const char * label, core::ValueInput* value, const char * units, bool isVisible) = 0;
|
|
virtual bool setStartAndEndFeatures_raw(core::Base* startFeature, core::Base* endFeature) = 0;
|
|
virtual core::Base** features_raw(size_t& return_size) const = 0;
|
|
};
|
|
|
|
// Inline wrappers
|
|
|
|
inline bool CustomFeatureInput::addDependency(const std::string& id, const core::Ptr<core::Base>& entity)
|
|
{
|
|
bool res = addDependency_raw(id.c_str(), entity.get());
|
|
return res;
|
|
}
|
|
|
|
inline bool CustomFeatureInput::addCustomParameter(const std::string& id, const std::string& label, const core::Ptr<core::ValueInput>& value, const std::string& units, bool isVisible)
|
|
{
|
|
bool res = addCustomParameter_raw(id.c_str(), label.c_str(), value.get(), units.c_str(), isVisible);
|
|
return res;
|
|
}
|
|
|
|
inline bool CustomFeatureInput::setStartAndEndFeatures(const core::Ptr<core::Base>& startFeature, const core::Ptr<core::Base>& endFeature)
|
|
{
|
|
bool res = setStartAndEndFeatures_raw(startFeature.get(), endFeature.get());
|
|
return res;
|
|
}
|
|
|
|
inline std::vector<core::Ptr<core::Base>> CustomFeatureInput::features() const
|
|
{
|
|
std::vector<core::Ptr<core::Base>> res;
|
|
size_t s;
|
|
|
|
core::Base** p= features_raw(s);
|
|
if(p)
|
|
{
|
|
res.assign(p, p+s);
|
|
core::DeallocateArray(p);
|
|
}
|
|
return res;
|
|
}
|
|
}// namespace fusion
|
|
}// namespace adsk
|
|
|
|
#undef ADSK_FUSION_CUSTOMFEATUREINPUT_API |