278 lines
11 KiB
C++
278 lines
11 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/Application/Events.h"
|
|
#include "../../Core/Application/EventHandler.h"
|
|
#include <vector>
|
|
|
|
// THIS CLASS WILL BE VISIBLE TO AN API CLIENT.
|
|
// THIS HEADER FILE WILL BE GENERATED FROM NIDL.
|
|
#include "../../Core/OSMacros.h"
|
|
|
|
#ifdef CAMXINTERFACE_EXPORTS
|
|
# ifdef __COMPILING_NETWORKMACHINEEVENTS_CPP__
|
|
# define NETWORKMACHINEEVENTS_API XI_EXPORT
|
|
# else
|
|
# define NETWORKMACHINEEVENTS_API
|
|
# endif
|
|
#else
|
|
# define NETWORKMACHINEEVENTS_API XI_IMPORT
|
|
#endif
|
|
|
|
namespace adsk { namespace cam {
|
|
class CreateMachineConfigurationsEvent;
|
|
class CreateMachineConfigurationsEventArgs;
|
|
class CreateMachineConfigurationsEventHandler;
|
|
class Machine;
|
|
class MachineDescription;
|
|
class SearchNetworkMachinesEventArgs;
|
|
class SearchNetworkMachinesEventHandler;
|
|
}}
|
|
|
|
namespace adsk { namespace cam {
|
|
|
|
/// This event is fired from the 'Find network machines' dialog when the corresponding
|
|
/// addin is selected from the vendor dropdown, or when 'search all vendors' is
|
|
/// selected. This event will allow the addin to initiate an enumeration of machines on
|
|
/// the network. MachineDescription objects should be created for each machine found, and
|
|
/// an list of those MachineDescription objects should be set on the 'machineDescriptions'
|
|
/// property of the SearchNetworkMachinesEventArgs. Nothing should be set to signify no
|
|
/// machines found. See SearchNetworkMachinesEventArgs and MachineDescription for details.
|
|
/// Note that this event is raised on a background thread.
|
|
class SearchNetworkMachinesEvent : public core::Event {
|
|
public:
|
|
|
|
/// Add a handler to be notified when the SearchNetworkMachinesEvent occurs.
|
|
/// handler : The handler object to be called when this event is fired.
|
|
/// Returns true if the addition of the handler was successful.
|
|
bool add(SearchNetworkMachinesEventHandler* handler);
|
|
|
|
/// Removes a handler from the SearchNetworkMachinesEvent.
|
|
/// handler : The handler object to be removed from the event.
|
|
/// Returns true if removal of the handler was successful.
|
|
bool remove(SearchNetworkMachinesEventHandler* handler);
|
|
|
|
NETWORKMACHINEEVENTS_API static const char* classType();
|
|
NETWORKMACHINEEVENTS_API const char* objectType() const override;
|
|
NETWORKMACHINEEVENTS_API void* queryInterface(const char* id) const override;
|
|
NETWORKMACHINEEVENTS_API static const char* interfaceId() { return classType(); }
|
|
|
|
private:
|
|
|
|
// Raw interface
|
|
virtual bool add_raw(SearchNetworkMachinesEventHandler* handler) = 0;
|
|
virtual bool remove_raw(SearchNetworkMachinesEventHandler* handler) = 0;
|
|
};
|
|
|
|
// Inline wrappers
|
|
|
|
inline bool SearchNetworkMachinesEvent::add(SearchNetworkMachinesEventHandler* handler)
|
|
{
|
|
bool res = add_raw(handler);
|
|
return res;
|
|
}
|
|
|
|
inline bool SearchNetworkMachinesEvent::remove(SearchNetworkMachinesEventHandler* handler)
|
|
{
|
|
bool res = remove_raw(handler);
|
|
return res;
|
|
}
|
|
|
|
/// This event is fired from the 'Find network machines' dialog when MachineDescription(s)
|
|
/// previously provided during the handling of the SearchNetworkMachines event are selected
|
|
/// to add to the user's Machine Library. This event will allow the addins to create
|
|
/// machine configurations corresponding to the selected MachineDescription objects.
|
|
/// Handlers of this event should create machine configurations corresponding to each
|
|
/// MachineDescription present in the 'machineDescriptions' property in the
|
|
/// CreateMachineConfigurationsEventArgs and set them on the 'machines' property of the
|
|
/// event args. See CreateMachineConfigurationsEventArgs for details. Note that this event is
|
|
/// raised on a background thread.
|
|
class CreateMachineConfigurationsEvent : public core::Event {
|
|
public:
|
|
|
|
/// Add a handler to be notified when the CreateMachineConfigurationsEvent occurs.
|
|
/// handler : The handler object to be called when this event is fired.
|
|
/// Returns true if the addition of the handler was successful.
|
|
bool add(CreateMachineConfigurationsEventHandler* handler);
|
|
|
|
/// Removes a handler from the CreateMachineConfigurationsEvent.
|
|
/// handler : The handler object to be removed from the event.
|
|
/// Returns true if removal of the handler was successful.
|
|
bool remove(CreateMachineConfigurationsEventHandler* handler);
|
|
|
|
NETWORKMACHINEEVENTS_API static const char* classType();
|
|
NETWORKMACHINEEVENTS_API const char* objectType() const override;
|
|
NETWORKMACHINEEVENTS_API void* queryInterface(const char* id) const override;
|
|
NETWORKMACHINEEVENTS_API static const char* interfaceId() { return classType(); }
|
|
|
|
private:
|
|
|
|
// Raw interface
|
|
virtual bool add_raw(CreateMachineConfigurationsEventHandler* handler) = 0;
|
|
virtual bool remove_raw(CreateMachineConfigurationsEventHandler* handler) = 0;
|
|
};
|
|
|
|
// Inline wrappers
|
|
|
|
inline bool CreateMachineConfigurationsEvent::add(CreateMachineConfigurationsEventHandler* handler)
|
|
{
|
|
bool res = add_raw(handler);
|
|
return res;
|
|
}
|
|
|
|
inline bool CreateMachineConfigurationsEvent::remove(CreateMachineConfigurationsEventHandler* handler)
|
|
{
|
|
bool res = remove_raw(handler);
|
|
return res;
|
|
}
|
|
|
|
/// Event handler for the SearchNetworkMachinesEvent event.
|
|
class SearchNetworkMachinesEventHandler : public core::EventHandler {
|
|
public:
|
|
|
|
/// The function called by Fusion 360 when the associated event is fired.
|
|
/// eventArgs : An object that provides access to additional information associated with the event.
|
|
NETWORKMACHINEEVENTS_API virtual void notify(const core::Ptr<SearchNetworkMachinesEventArgs>& eventArgs) = 0;
|
|
};
|
|
|
|
/// This EventArgs object will be sent with the SearchNetworkMachinesEvent.
|
|
class SearchNetworkMachinesEventArgs : public core::EventArgs {
|
|
public:
|
|
|
|
/// Gets and sets a list of MachineDescription objects representing machines found on the
|
|
/// network. Do not set anything to signify no machine found.
|
|
std::vector<core::Ptr<MachineDescription>> machineDescriptions() const;
|
|
bool machineDescriptions(const std::vector<core::Ptr<MachineDescription>>& value);
|
|
|
|
NETWORKMACHINEEVENTS_API static const char* classType();
|
|
NETWORKMACHINEEVENTS_API const char* objectType() const override;
|
|
NETWORKMACHINEEVENTS_API void* queryInterface(const char* id) const override;
|
|
NETWORKMACHINEEVENTS_API static const char* interfaceId() { return classType(); }
|
|
|
|
private:
|
|
|
|
// Raw interface
|
|
virtual MachineDescription** machineDescriptions_raw(size_t& return_size) const = 0;
|
|
virtual bool machineDescriptions_raw(MachineDescription** value, size_t value_size) = 0;
|
|
};
|
|
|
|
// Inline wrappers
|
|
|
|
inline std::vector<core::Ptr<MachineDescription>> SearchNetworkMachinesEventArgs::machineDescriptions() const
|
|
{
|
|
std::vector<core::Ptr<MachineDescription>> res;
|
|
size_t s;
|
|
|
|
MachineDescription** p= machineDescriptions_raw(s);
|
|
if(p)
|
|
{
|
|
res.assign(p, p+s);
|
|
core::DeallocateArray(p);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
inline bool SearchNetworkMachinesEventArgs::machineDescriptions(const std::vector<core::Ptr<MachineDescription>>& value)
|
|
{
|
|
MachineDescription** value_ = new MachineDescription*[value.size()];
|
|
for(size_t i=0; i<value.size(); ++i)
|
|
value_[i] = value[i].get();
|
|
|
|
bool res = machineDescriptions_raw(value_, value.size());
|
|
delete[] value_;
|
|
return res;
|
|
}
|
|
|
|
/// Event handler for the CreateMachineConfigurationsEvent.
|
|
class CreateMachineConfigurationsEventHandler : public core::EventHandler {
|
|
public:
|
|
|
|
/// The function called by Fusion 360 when the associated event is fired.
|
|
/// eventArgs : Returns an object that provides access to additional information associated with the event.
|
|
NETWORKMACHINEEVENTS_API virtual void notify(const core::Ptr<CreateMachineConfigurationsEventArgs>& eventArgs) = 0;
|
|
};
|
|
|
|
/// This EventArgs object will be sent with the CreateMachineConfigurationsEvent.
|
|
class CreateMachineConfigurationsEventArgs : public core::EventArgs {
|
|
public:
|
|
|
|
/// Gets the collection of MachineDescription objects for which machine configurations
|
|
/// must be created. These MachineDescription(s) will be a subset of those previously
|
|
/// provided by the addin's SearchNetworkMachinesEventHandler.
|
|
/// Returns a list of MachineDescription objects which is a subset of the list that was
|
|
/// previously set by this addin on the 'machineDescriptions' property of the
|
|
/// SearchNetworkMachinesEventArgs.
|
|
std::vector<core::Ptr<MachineDescription>> machineDescriptions() const;
|
|
|
|
/// Gets and sets the list of Machine objects. Machines should be created corresponding to
|
|
/// each of the MachineDescription objects provided in the machineDescriptions property.
|
|
/// Machines can be created using adsk.cam.Machine.createFromTemplate or
|
|
/// adsk.cam.Machine.createFromFile.
|
|
std::vector<core::Ptr<Machine>> machines() const;
|
|
bool machines(const std::vector<core::Ptr<Machine>>& value);
|
|
|
|
NETWORKMACHINEEVENTS_API static const char* classType();
|
|
NETWORKMACHINEEVENTS_API const char* objectType() const override;
|
|
NETWORKMACHINEEVENTS_API void* queryInterface(const char* id) const override;
|
|
NETWORKMACHINEEVENTS_API static const char* interfaceId() { return classType(); }
|
|
|
|
private:
|
|
|
|
// Raw interface
|
|
virtual MachineDescription** machineDescriptions_raw(size_t& return_size) const = 0;
|
|
virtual Machine** machines_raw(size_t& return_size) const = 0;
|
|
virtual bool machines_raw(Machine** value, size_t value_size) = 0;
|
|
};
|
|
|
|
// Inline wrappers
|
|
|
|
inline std::vector<core::Ptr<MachineDescription>> CreateMachineConfigurationsEventArgs::machineDescriptions() const
|
|
{
|
|
std::vector<core::Ptr<MachineDescription>> res;
|
|
size_t s;
|
|
|
|
MachineDescription** p= machineDescriptions_raw(s);
|
|
if(p)
|
|
{
|
|
res.assign(p, p+s);
|
|
core::DeallocateArray(p);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
inline std::vector<core::Ptr<Machine>> CreateMachineConfigurationsEventArgs::machines() const
|
|
{
|
|
std::vector<core::Ptr<Machine>> res;
|
|
size_t s;
|
|
|
|
Machine** p= machines_raw(s);
|
|
if(p)
|
|
{
|
|
res.assign(p, p+s);
|
|
core::DeallocateArray(p);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
inline bool CreateMachineConfigurationsEventArgs::machines(const std::vector<core::Ptr<Machine>>& value)
|
|
{
|
|
Machine** value_ = new Machine*[value.size()];
|
|
for(size_t i=0; i<value.size(); ++i)
|
|
value_[i] = value[i].get();
|
|
|
|
bool res = machines_raw(value_, value.size());
|
|
delete[] value_;
|
|
return res;
|
|
}
|
|
}// namespace cam
|
|
}// namespace adsk
|
|
|
|
#undef NETWORKMACHINEEVENTS_API |