196 lines
8.1 KiB
C++
196 lines
8.1 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>
|
|
|
|
// 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_CUSTOMFEATUREDEFINITION_CPP__
|
|
# define ADSK_FUSION_CUSTOMFEATUREDEFINITION_API XI_EXPORT
|
|
# else
|
|
# define ADSK_FUSION_CUSTOMFEATUREDEFINITION_API
|
|
# endif
|
|
#else
|
|
# define ADSK_FUSION_CUSTOMFEATUREDEFINITION_API XI_IMPORT
|
|
#endif
|
|
|
|
namespace adsk { namespace fusion {
|
|
class CustomFeatureEvent;
|
|
}}
|
|
|
|
namespace adsk { namespace fusion {
|
|
|
|
/// The CustomFeatureDefinition object defines a specific type of custom feature. It contains
|
|
/// the settings that apply to all custom features of that type and is used when creating new
|
|
/// custom features of that type. It also supports the events used to handle changes to custom
|
|
/// features of that type.
|
|
class CustomFeatureDefinition : public core::Base {
|
|
public:
|
|
|
|
/// A static function that creates a new CustomFeatureDefinition object. The creation of a
|
|
/// CustomFeatureDefinition object is required to be able to create new custom features and
|
|
/// for existing custom features to behave correctly. The CustomFeatureDefinition object defines
|
|
/// all of the information that is common for all custom features of a particular type. For example,
|
|
/// it defines the icon and the default name. The CustomFeatureDefinition object also supports the
|
|
/// events that used to react to an existing feature being edited or re-computed.
|
|
/// The custom feature definition should be created when your add-in is initially loaded to notify
|
|
/// Fusion that the add-in that supports that custom feature type is available.
|
|
/// id : The unique ID for custom features of a particular type. Care must be taken to ensure that this
|
|
/// is unique and you must be consistent in its use once you've chosen an ID. A good practice to
|
|
/// help ensure unique naming is to use the name of your company in combination with the name of
|
|
/// the feature, such as "CompanyName.FeatureName". For example, "WoodTools4U.Dovetail".
|
|
/// defaultName : The default name of the feature. Fusion will use this name and append a number to each feature
|
|
/// instance as it's created. For example, if this is "Dovetail" the first custom feature created
|
|
/// will be named "Dovetail1" and the second will be "Dovetail2".
|
|
/// If you want to localize this name you can use the Application.Preferences.generalPreferences.userLanguage
|
|
/// property to determine what language the user has chosen and use the corresponding name for that language.
|
|
/// iconFolder : The folder that contains the image files that will be used for the icon for this feature in
|
|
/// the timeline. This can be a full path or a relative path where it will be relative to the add-in
|
|
/// file. The folder should contain the image files named 16x16.png and 32x32.png which should be
|
|
/// images that are 16 and 32 pixels square.
|
|
/// Returns the newly created CustomFeatureDefinition or null in the case of failure.
|
|
static core::Ptr<CustomFeatureDefinition> create(const std::string& id, const std::string& defaultName, const std::string& iconFolder);
|
|
|
|
/// Gets the unique ID used for this type of custom feature.
|
|
std::string id() const;
|
|
|
|
/// Gets and sets the folder that contains the images that are used for the icon in the timeline for
|
|
/// this custom feature. The folder should contain the image files named 16x16.png and 32x32.png
|
|
/// which should be images that are 16 and 32 pixels square.
|
|
std::string iconFolder() const;
|
|
bool iconFolder(const std::string& value);
|
|
|
|
/// Gets and sets the default name of the feature. Fusion will use this name and append a number
|
|
/// to each feature instance as it's created. For example, if this is "Dovetail" the first
|
|
/// custom feature created will be named "Dovetail1" and the second will be "Dovetail2".
|
|
/// If you want to localize this name you can use the Application.Preferences.generalPreferences.userLanguage
|
|
/// property to determine what language the user has chosen and use the corresponding name for that language.
|
|
std::string defaultName() const;
|
|
bool defaultName(const std::string& value);
|
|
|
|
/// Gets and sets which command will be invoked when the feature is edited. This is the id of the
|
|
/// CommandDefinition object that you have created to do the edit of the feature.
|
|
std::string editCommandId() const;
|
|
bool editCommandId(const std::string& value);
|
|
|
|
/// The customFeatureCompute event fires when Fusion is computing the timeline and reaches
|
|
/// the custom feature. The event is fired if any of the dependencies of the custom feature
|
|
/// have changed. You can modify the results of your custom feature based on the dependencies.
|
|
core::Ptr<CustomFeatureEvent> customFeatureCompute() const;
|
|
|
|
ADSK_FUSION_CUSTOMFEATUREDEFINITION_API static const char* classType();
|
|
ADSK_FUSION_CUSTOMFEATUREDEFINITION_API const char* objectType() const override;
|
|
ADSK_FUSION_CUSTOMFEATUREDEFINITION_API void* queryInterface(const char* id) const override;
|
|
ADSK_FUSION_CUSTOMFEATUREDEFINITION_API static const char* interfaceId() { return classType(); }
|
|
|
|
private:
|
|
|
|
// Raw interface
|
|
ADSK_FUSION_CUSTOMFEATUREDEFINITION_API static CustomFeatureDefinition* create_raw(const char * id, const char * defaultName, const char * iconFolder);
|
|
virtual char* id_raw() const = 0;
|
|
virtual char* iconFolder_raw() const = 0;
|
|
virtual bool iconFolder_raw(const char * value) = 0;
|
|
virtual char* defaultName_raw() const = 0;
|
|
virtual bool defaultName_raw(const char * value) = 0;
|
|
virtual char* editCommandId_raw() const = 0;
|
|
virtual bool editCommandId_raw(const char * value) = 0;
|
|
virtual CustomFeatureEvent* customFeatureCompute_raw() const = 0;
|
|
};
|
|
|
|
// Inline wrappers
|
|
|
|
inline core::Ptr<CustomFeatureDefinition> CustomFeatureDefinition::create(const std::string& id, const std::string& defaultName, const std::string& iconFolder)
|
|
{
|
|
core::Ptr<CustomFeatureDefinition> res = create_raw(id.c_str(), defaultName.c_str(), iconFolder.c_str());
|
|
return res;
|
|
}
|
|
|
|
inline std::string CustomFeatureDefinition::id() const
|
|
{
|
|
std::string res;
|
|
|
|
char* p= id_raw();
|
|
if (p)
|
|
{
|
|
res = p;
|
|
core::DeallocateArray(p);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
inline std::string CustomFeatureDefinition::iconFolder() const
|
|
{
|
|
std::string res;
|
|
|
|
char* p= iconFolder_raw();
|
|
if (p)
|
|
{
|
|
res = p;
|
|
core::DeallocateArray(p);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
inline bool CustomFeatureDefinition::iconFolder(const std::string& value)
|
|
{
|
|
return iconFolder_raw(value.c_str());
|
|
}
|
|
|
|
inline std::string CustomFeatureDefinition::defaultName() const
|
|
{
|
|
std::string res;
|
|
|
|
char* p= defaultName_raw();
|
|
if (p)
|
|
{
|
|
res = p;
|
|
core::DeallocateArray(p);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
inline bool CustomFeatureDefinition::defaultName(const std::string& value)
|
|
{
|
|
return defaultName_raw(value.c_str());
|
|
}
|
|
|
|
inline std::string CustomFeatureDefinition::editCommandId() const
|
|
{
|
|
std::string res;
|
|
|
|
char* p= editCommandId_raw();
|
|
if (p)
|
|
{
|
|
res = p;
|
|
core::DeallocateArray(p);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
inline bool CustomFeatureDefinition::editCommandId(const std::string& value)
|
|
{
|
|
return editCommandId_raw(value.c_str());
|
|
}
|
|
|
|
inline core::Ptr<CustomFeatureEvent> CustomFeatureDefinition::customFeatureCompute() const
|
|
{
|
|
core::Ptr<CustomFeatureEvent> res = customFeatureCompute_raw();
|
|
return res;
|
|
}
|
|
}// namespace fusion
|
|
}// namespace adsk
|
|
|
|
#undef ADSK_FUSION_CUSTOMFEATUREDEFINITION_API |