shared_ptr<IfcPlateTypeEnum> IfcPlateTypeEnum::createObjectFromSTEP( const std::wstring& arg )
{
// read TYPE
if( arg.compare( L"$" ) == 0 ) { return shared_ptr<IfcPlateTypeEnum>(); }
else if( arg.compare( L"*" ) == 0 ) { return shared_ptr<IfcPlateTypeEnum>(); }
shared_ptr<IfcPlateTypeEnum> type_object( new IfcPlateTypeEnum() );
if( boost::iequals( arg, L".CURTAIN_PANEL." ) )
{
type_object->m_enum = IfcPlateTypeEnum::ENUM_CURTAIN_PANEL;
}
else if( boost::iequals( arg, L".SHEET." ) )
{
type_object->m_enum = IfcPlateTypeEnum::ENUM_SHEET;
}
else if( boost::iequals( arg, L".USERDEFINED." ) )
{
type_object->m_enum = IfcPlateTypeEnum::ENUM_USERDEFINED;
}
else if( boost::iequals( arg, L".NOTDEFINED." ) )
{
type_object->m_enum = IfcPlateTypeEnum::ENUM_NOTDEFINED;
}
return type_object;
}
shared_ptr<IfcTimeSeriesDataTypeEnum> IfcTimeSeriesDataTypeEnum::createObjectFromSTEP( const std::wstring& arg )
{
// read TYPE
if( arg.compare( L"$" ) == 0 ) { return shared_ptr<IfcTimeSeriesDataTypeEnum>(); }
else if( arg.compare( L"*" ) == 0 ) { return shared_ptr<IfcTimeSeriesDataTypeEnum>(); }
shared_ptr<IfcTimeSeriesDataTypeEnum> type_object( new IfcTimeSeriesDataTypeEnum() );
if( boost::iequals( arg, L".CONTINUOUS." ) )
{
type_object->m_enum = IfcTimeSeriesDataTypeEnum::ENUM_CONTINUOUS;
}
else if( boost::iequals( arg, L".DISCRETE." ) )
{
type_object->m_enum = IfcTimeSeriesDataTypeEnum::ENUM_DISCRETE;
}
else if( boost::iequals( arg, L".DISCRETEBINARY." ) )
{
type_object->m_enum = IfcTimeSeriesDataTypeEnum::ENUM_DISCRETEBINARY;
}
else if( boost::iequals( arg, L".PIECEWISEBINARY." ) )
{
type_object->m_enum = IfcTimeSeriesDataTypeEnum::ENUM_PIECEWISEBINARY;
}
else if( boost::iequals( arg, L".PIECEWISECONSTANT." ) )
{
type_object->m_enum = IfcTimeSeriesDataTypeEnum::ENUM_PIECEWISECONSTANT;
}
else if( boost::iequals( arg, L".PIECEWISECONTINUOUS." ) )
{
type_object->m_enum = IfcTimeSeriesDataTypeEnum::ENUM_PIECEWISECONTINUOUS;
}
else if( boost::iequals( arg, L".NOTDEFINED." ) )
{
type_object->m_enum = IfcTimeSeriesDataTypeEnum::ENUM_NOTDEFINED;
}
return type_object;
}
shared_ptr<IfcElectricFlowStorageDeviceTypeEnum> IfcElectricFlowStorageDeviceTypeEnum::createObjectFromSTEP( const std::wstring& arg )
{
// read TYPE
if( arg.compare( L"$" ) == 0 ) { return shared_ptr<IfcElectricFlowStorageDeviceTypeEnum>(); }
else if( arg.compare( L"*" ) == 0 ) { return shared_ptr<IfcElectricFlowStorageDeviceTypeEnum>(); }
shared_ptr<IfcElectricFlowStorageDeviceTypeEnum> type_object( new IfcElectricFlowStorageDeviceTypeEnum() );
if( boost::iequals( arg, L".BATTERY." ) )
{
type_object->m_enum = IfcElectricFlowStorageDeviceTypeEnum::ENUM_BATTERY;
}
else if( boost::iequals( arg, L".CAPACITORBANK." ) )
{
type_object->m_enum = IfcElectricFlowStorageDeviceTypeEnum::ENUM_CAPACITORBANK;
}
else if( boost::iequals( arg, L".HARMONICFILTER." ) )
{
type_object->m_enum = IfcElectricFlowStorageDeviceTypeEnum::ENUM_HARMONICFILTER;
}
else if( boost::iequals( arg, L".INDUCTORBANK." ) )
{
type_object->m_enum = IfcElectricFlowStorageDeviceTypeEnum::ENUM_INDUCTORBANK;
}
else if( boost::iequals( arg, L".UPS." ) )
{
type_object->m_enum = IfcElectricFlowStorageDeviceTypeEnum::ENUM_UPS;
}
else if( boost::iequals( arg, L".USERDEFINED." ) )
{
type_object->m_enum = IfcElectricFlowStorageDeviceTypeEnum::ENUM_USERDEFINED;
}
else if( boost::iequals( arg, L".NOTDEFINED." ) )
{
type_object->m_enum = IfcElectricFlowStorageDeviceTypeEnum::ENUM_NOTDEFINED;
}
return type_object;
}
shared_ptr<IfcElectricMotorTypeEnum> IfcElectricMotorTypeEnum::createObjectFromSTEP( const std::wstring& arg )
{
// read TYPE
if( arg.compare( L"$" ) == 0 ) { return shared_ptr<IfcElectricMotorTypeEnum>(); }
else if( arg.compare( L"*" ) == 0 ) { return shared_ptr<IfcElectricMotorTypeEnum>(); }
shared_ptr<IfcElectricMotorTypeEnum> type_object( new IfcElectricMotorTypeEnum() );
if( boost::iequals( arg, L".DC." ) )
{
type_object->m_enum = IfcElectricMotorTypeEnum::ENUM_DC;
}
else if( boost::iequals( arg, L".INDUCTION." ) )
{
type_object->m_enum = IfcElectricMotorTypeEnum::ENUM_INDUCTION;
}
else if( boost::iequals( arg, L".POLYPHASE." ) )
{
type_object->m_enum = IfcElectricMotorTypeEnum::ENUM_POLYPHASE;
}
else if( boost::iequals( arg, L".RELUCTANCESYNCHRONOUS." ) )
{
type_object->m_enum = IfcElectricMotorTypeEnum::ENUM_RELUCTANCESYNCHRONOUS;
}
else if( boost::iequals( arg, L".SYNCHRONOUS." ) )
{
type_object->m_enum = IfcElectricMotorTypeEnum::ENUM_SYNCHRONOUS;
}
else if( boost::iequals( arg, L".USERDEFINED." ) )
{
type_object->m_enum = IfcElectricMotorTypeEnum::ENUM_USERDEFINED;
}
else if( boost::iequals( arg, L".NOTDEFINED." ) )
{
type_object->m_enum = IfcElectricMotorTypeEnum::ENUM_NOTDEFINED;
}
return type_object;
}
shared_ptr<IfcTransformerTypeEnum> IfcTransformerTypeEnum::createObjectFromSTEP( const std::wstring& arg )
{
// read TYPE
if( arg.compare( L"$" ) == 0 ) { return shared_ptr<IfcTransformerTypeEnum>(); }
else if( arg.compare( L"*" ) == 0 ) { return shared_ptr<IfcTransformerTypeEnum>(); }
shared_ptr<IfcTransformerTypeEnum> type_object( new IfcTransformerTypeEnum() );
if( boost::iequals( arg, L".CURRENT." ) )
{
type_object->m_enum = IfcTransformerTypeEnum::ENUM_CURRENT;
}
else if( boost::iequals( arg, L".FREQUENCY." ) )
{
type_object->m_enum = IfcTransformerTypeEnum::ENUM_FREQUENCY;
}
else if( boost::iequals( arg, L".INVERTER." ) )
{
type_object->m_enum = IfcTransformerTypeEnum::ENUM_INVERTER;
}
else if( boost::iequals( arg, L".RECTIFIER." ) )
{
type_object->m_enum = IfcTransformerTypeEnum::ENUM_RECTIFIER;
}
else if( boost::iequals( arg, L".VOLTAGE." ) )
{
type_object->m_enum = IfcTransformerTypeEnum::ENUM_VOLTAGE;
}
else if( boost::iequals( arg, L".USERDEFINED." ) )
{
type_object->m_enum = IfcTransformerTypeEnum::ENUM_USERDEFINED;
}
else if( boost::iequals( arg, L".NOTDEFINED." ) )
{
type_object->m_enum = IfcTransformerTypeEnum::ENUM_NOTDEFINED;
}
return type_object;
}
shared_ptr<IfcUnitaryEquipmentTypeEnum> IfcUnitaryEquipmentTypeEnum::createObjectFromSTEP( const std::wstring& arg )
{
// read TYPE
if( arg.compare( L"$" ) == 0 ) { return shared_ptr<IfcUnitaryEquipmentTypeEnum>(); }
else if( arg.compare( L"*" ) == 0 ) { return shared_ptr<IfcUnitaryEquipmentTypeEnum>(); }
shared_ptr<IfcUnitaryEquipmentTypeEnum> type_object( new IfcUnitaryEquipmentTypeEnum() );
if( boost::iequals( arg, L".AIRHANDLER." ) )
{
type_object->m_enum = IfcUnitaryEquipmentTypeEnum::ENUM_AIRHANDLER;
}
else if( boost::iequals( arg, L".AIRCONDITIONINGUNIT." ) )
{
type_object->m_enum = IfcUnitaryEquipmentTypeEnum::ENUM_AIRCONDITIONINGUNIT;
}
else if( boost::iequals( arg, L".DEHUMIDIFIER." ) )
{
type_object->m_enum = IfcUnitaryEquipmentTypeEnum::ENUM_DEHUMIDIFIER;
}
else if( boost::iequals( arg, L".SPLITSYSTEM." ) )
{
type_object->m_enum = IfcUnitaryEquipmentTypeEnum::ENUM_SPLITSYSTEM;
}
else if( boost::iequals( arg, L".ROOFTOPUNIT." ) )
{
type_object->m_enum = IfcUnitaryEquipmentTypeEnum::ENUM_ROOFTOPUNIT;
}
else if( boost::iequals( arg, L".USERDEFINED." ) )
{
type_object->m_enum = IfcUnitaryEquipmentTypeEnum::ENUM_USERDEFINED;
}
else if( boost::iequals( arg, L".NOTDEFINED." ) )
{
type_object->m_enum = IfcUnitaryEquipmentTypeEnum::ENUM_NOTDEFINED;
}
return type_object;
}
TUint32 IdentifyUCKeyword (const SKeyword aKeyword [], std::wstring aIdentifier, const std::wstring& aContext)
{
for (std::wstring::size_type letter = 0; letter < aIdentifier.size (); letter++)
{
aIdentifier [letter] = toupper (aIdentifier [letter]);
}
for (const SKeyword* index = &aKeyword [0]; index -> iName != NULL; index++)
{
if (aIdentifier.compare (index -> iName) == 0)
{
return index -> iId;
}
}
throw CSISException (CSISException::ESyntax, aContext + aIdentifier);
}
shared_ptr<IfcConstructionProductResourceTypeEnum> IfcConstructionProductResourceTypeEnum::createObjectFromSTEP( const std::wstring& arg )
{
// read TYPE
if( arg.compare( L"$" ) == 0 ) { return shared_ptr<IfcConstructionProductResourceTypeEnum>(); }
else if( arg.compare( L"*" ) == 0 ) { return shared_ptr<IfcConstructionProductResourceTypeEnum>(); }
shared_ptr<IfcConstructionProductResourceTypeEnum> type_object( new IfcConstructionProductResourceTypeEnum() );
if( boost::iequals( arg, L".ASSEMBLY." ) )
{
type_object->m_enum = IfcConstructionProductResourceTypeEnum::ENUM_ASSEMBLY;
}
else if( boost::iequals( arg, L".FORMWORK." ) )
{
type_object->m_enum = IfcConstructionProductResourceTypeEnum::ENUM_FORMWORK;
}
else if( boost::iequals( arg, L".USERDEFINED." ) )
{
type_object->m_enum = IfcConstructionProductResourceTypeEnum::ENUM_USERDEFINED;
}
else if( boost::iequals( arg, L".NOTDEFINED." ) )
{
type_object->m_enum = IfcConstructionProductResourceTypeEnum::ENUM_NOTDEFINED;
}
return type_object;
}
shared_ptr<IfcTransportElementTypeEnum> IfcTransportElementTypeEnum::createObjectFromSTEP( const std::wstring& arg )
{
// read TYPE
if( arg.compare( L"$" ) == 0 ) { return shared_ptr<IfcTransportElementTypeEnum>(); }
else if( arg.compare( L"*" ) == 0 ) { return shared_ptr<IfcTransportElementTypeEnum>(); }
shared_ptr<IfcTransportElementTypeEnum> type_object( new IfcTransportElementTypeEnum() );
if( boost::iequals( arg, L".ELEVATOR." ) )
{
type_object->m_enum = IfcTransportElementTypeEnum::ENUM_ELEVATOR;
}
else if( boost::iequals( arg, L".ESCALATOR." ) )
{
type_object->m_enum = IfcTransportElementTypeEnum::ENUM_ESCALATOR;
}
else if( boost::iequals( arg, L".MOVINGWALKWAY." ) )
{
type_object->m_enum = IfcTransportElementTypeEnum::ENUM_MOVINGWALKWAY;
}
else if( boost::iequals( arg, L".CRANEWAY." ) )
{
type_object->m_enum = IfcTransportElementTypeEnum::ENUM_CRANEWAY;
}
else if( boost::iequals( arg, L".LIFTINGGEAR." ) )
{
type_object->m_enum = IfcTransportElementTypeEnum::ENUM_LIFTINGGEAR;
}
else if( boost::iequals( arg, L".USERDEFINED." ) )
{
type_object->m_enum = IfcTransportElementTypeEnum::ENUM_USERDEFINED;
}
else if( boost::iequals( arg, L".NOTDEFINED." ) )
{
type_object->m_enum = IfcTransportElementTypeEnum::ENUM_NOTDEFINED;
}
return type_object;
}
shared_ptr<IfcKnotType> IfcKnotType::createObjectFromSTEP( const std::wstring& arg )
{
// read TYPE
if( arg.compare( L"$" ) == 0 ) { return shared_ptr<IfcKnotType>(); }
else if( arg.compare( L"*" ) == 0 ) { return shared_ptr<IfcKnotType>(); }
shared_ptr<IfcKnotType> type_object( new IfcKnotType() );
if( boost::iequals( arg, L".UNIFORM_KNOTS." ) )
{
type_object->m_enum = IfcKnotType::ENUM_UNIFORM_KNOTS;
}
else if( boost::iequals( arg, L".QUASI_UNIFORM_KNOTS." ) )
{
type_object->m_enum = IfcKnotType::ENUM_QUASI_UNIFORM_KNOTS;
}
else if( boost::iequals( arg, L".PIECEWISE_BEZIER_KNOTS." ) )
{
type_object->m_enum = IfcKnotType::ENUM_PIECEWISE_BEZIER_KNOTS;
}
else if( boost::iequals( arg, L".UNSPECIFIED." ) )
{
type_object->m_enum = IfcKnotType::ENUM_UNSPECIFIED;
}
return type_object;
}
shared_ptr<IfcColumnTypeEnum> IfcColumnTypeEnum::createObjectFromSTEP( const std::wstring& arg )
{
// read TYPE
if( arg.compare( L"$" ) == 0 ) { return shared_ptr<IfcColumnTypeEnum>(); }
else if( arg.compare( L"*" ) == 0 ) { return shared_ptr<IfcColumnTypeEnum>(); }
shared_ptr<IfcColumnTypeEnum> type_object( new IfcColumnTypeEnum() );
if( boost::iequals( arg, L".COLUMN." ) )
{
type_object->m_enum = IfcColumnTypeEnum::ENUM_COLUMN;
}
else if( boost::iequals( arg, L".PILASTER." ) )
{
type_object->m_enum = IfcColumnTypeEnum::ENUM_PILASTER;
}
else if( boost::iequals( arg, L".USERDEFINED." ) )
{
type_object->m_enum = IfcColumnTypeEnum::ENUM_USERDEFINED;
}
else if( boost::iequals( arg, L".NOTDEFINED." ) )
{
type_object->m_enum = IfcColumnTypeEnum::ENUM_NOTDEFINED;
}
return type_object;
}
shared_ptr<IfcCooledBeamTypeEnum> IfcCooledBeamTypeEnum::createObjectFromSTEP( const std::wstring& arg )
{
// read TYPE
if( arg.compare( L"$" ) == 0 ) { return shared_ptr<IfcCooledBeamTypeEnum>(); }
else if( arg.compare( L"*" ) == 0 ) { return shared_ptr<IfcCooledBeamTypeEnum>(); }
shared_ptr<IfcCooledBeamTypeEnum> type_object( new IfcCooledBeamTypeEnum() );
if( boost::iequals( arg, L".ACTIVE." ) )
{
type_object->m_enum = IfcCooledBeamTypeEnum::ENUM_ACTIVE;
}
else if( boost::iequals( arg, L".PASSIVE." ) )
{
type_object->m_enum = IfcCooledBeamTypeEnum::ENUM_PASSIVE;
}
else if( boost::iequals( arg, L".USERDEFINED." ) )
{
type_object->m_enum = IfcCooledBeamTypeEnum::ENUM_USERDEFINED;
}
else if( boost::iequals( arg, L".NOTDEFINED." ) )
{
type_object->m_enum = IfcCooledBeamTypeEnum::ENUM_NOTDEFINED;
}
return type_object;
}
shared_ptr<IfcDuctSegmentTypeEnum> IfcDuctSegmentTypeEnum::createObjectFromSTEP( const std::wstring& arg )
{
// read TYPE
if( arg.compare( L"$" ) == 0 ) { return shared_ptr<IfcDuctSegmentTypeEnum>(); }
else if( arg.compare( L"*" ) == 0 ) { return shared_ptr<IfcDuctSegmentTypeEnum>(); }
shared_ptr<IfcDuctSegmentTypeEnum> type_object( new IfcDuctSegmentTypeEnum() );
if( boost::iequals( arg, L".RIGIDSEGMENT." ) )
{
type_object->m_enum = IfcDuctSegmentTypeEnum::ENUM_RIGIDSEGMENT;
}
else if( boost::iequals( arg, L".FLEXIBLESEGMENT." ) )
{
type_object->m_enum = IfcDuctSegmentTypeEnum::ENUM_FLEXIBLESEGMENT;
}
else if( boost::iequals( arg, L".USERDEFINED." ) )
{
type_object->m_enum = IfcDuctSegmentTypeEnum::ENUM_USERDEFINED;
}
else if( boost::iequals( arg, L".NOTDEFINED." ) )
{
type_object->m_enum = IfcDuctSegmentTypeEnum::ENUM_NOTDEFINED;
}
return type_object;
}
shared_ptr<IfcStructuralCurveMemberTypeEnum> IfcStructuralCurveMemberTypeEnum::createObjectFromSTEP( const std::wstring& arg )
{
// read TYPE
if( arg.compare( L"$" ) == 0 ) { return shared_ptr<IfcStructuralCurveMemberTypeEnum>(); }
else if( arg.compare( L"*" ) == 0 ) { return shared_ptr<IfcStructuralCurveMemberTypeEnum>(); }
shared_ptr<IfcStructuralCurveMemberTypeEnum> type_object( new IfcStructuralCurveMemberTypeEnum() );
if( boost::iequals( arg, L".RIGID_JOINED_MEMBER." ) )
{
type_object->m_enum = IfcStructuralCurveMemberTypeEnum::ENUM_RIGID_JOINED_MEMBER;
}
else if( boost::iequals( arg, L".PIN_JOINED_MEMBER." ) )
{
type_object->m_enum = IfcStructuralCurveMemberTypeEnum::ENUM_PIN_JOINED_MEMBER;
}
else if( boost::iequals( arg, L".CABLE." ) )
{
type_object->m_enum = IfcStructuralCurveMemberTypeEnum::ENUM_CABLE;
}
else if( boost::iequals( arg, L".TENSION_MEMBER." ) )
{
type_object->m_enum = IfcStructuralCurveMemberTypeEnum::ENUM_TENSION_MEMBER;
}
else if( boost::iequals( arg, L".COMPRESSION_MEMBER." ) )
{
type_object->m_enum = IfcStructuralCurveMemberTypeEnum::ENUM_COMPRESSION_MEMBER;
}
else if( boost::iequals( arg, L".USERDEFINED." ) )
{
type_object->m_enum = IfcStructuralCurveMemberTypeEnum::ENUM_USERDEFINED;
}
else if( boost::iequals( arg, L".NOTDEFINED." ) )
{
type_object->m_enum = IfcStructuralCurveMemberTypeEnum::ENUM_NOTDEFINED;
}
return type_object;
}
shared_ptr<IfcFootingTypeEnum> IfcFootingTypeEnum::createObjectFromSTEP( const std::wstring& arg )
{
// read TYPE
if( arg.compare( L"$" ) == 0 ) { return shared_ptr<IfcFootingTypeEnum>(); }
else if( arg.compare( L"*" ) == 0 ) { return shared_ptr<IfcFootingTypeEnum>(); }
shared_ptr<IfcFootingTypeEnum> type_object( new IfcFootingTypeEnum() );
if( boost::iequals( arg, L".CAISSON_FOUNDATION." ) )
{
type_object->m_enum = IfcFootingTypeEnum::ENUM_CAISSON_FOUNDATION;
}
else if( boost::iequals( arg, L".FOOTING_BEAM." ) )
{
type_object->m_enum = IfcFootingTypeEnum::ENUM_FOOTING_BEAM;
}
else if( boost::iequals( arg, L".PAD_FOOTING." ) )
{
type_object->m_enum = IfcFootingTypeEnum::ENUM_PAD_FOOTING;
}
else if( boost::iequals( arg, L".PILE_CAP." ) )
{
type_object->m_enum = IfcFootingTypeEnum::ENUM_PILE_CAP;
}
else if( boost::iequals( arg, L".STRIP_FOOTING." ) )
{
type_object->m_enum = IfcFootingTypeEnum::ENUM_STRIP_FOOTING;
}
else if( boost::iequals( arg, L".USERDEFINED." ) )
{
type_object->m_enum = IfcFootingTypeEnum::ENUM_USERDEFINED;
}
else if( boost::iequals( arg, L".NOTDEFINED." ) )
{
type_object->m_enum = IfcFootingTypeEnum::ENUM_NOTDEFINED;
}
return type_object;
}
void CEmissary::setMenuItemState(std::wstring itemString, std::wstring state)
{
HWND hwnd;
if ((hwnd = FindWindow(DIMDIM_PUBLISHER_TRAY_CLASS_NAME, NULL)) == NULL)
return;
if (itemString.compare(_T("screencaster")) == 0)
{
if (state.compare(_T("enable")) == 0)
PostMessage(hwnd, WM_DIMDIM_SCREENCASTER_PROGRESS, 0, 0);
else if (state.compare(_T("warning")) == 0)
PostMessage(hwnd, WM_DIMDIM_SCREENCASER_FORCELOW, 0, 0);
else
PostMessage(hwnd, WM_DIMDIM_IDLE, 0, 0);
}
else
{
if (state.compare(_T("enable")) == 0)
PostMessage(hwnd, WM_DIMDIM_CONVERTER_PROGRESS, 0, 0);
else
PostMessage(hwnd, WM_DIMDIM_IDLE, 0, 0);
}
}
shared_ptr<IfcProjectOrderTypeEnum> IfcProjectOrderTypeEnum::createObjectFromSTEP( const std::wstring& arg )
{
// read TYPE
if( arg.compare( L"$" ) == 0 ) { return shared_ptr<IfcProjectOrderTypeEnum>(); }
else if( arg.compare( L"*" ) == 0 ) { return shared_ptr<IfcProjectOrderTypeEnum>(); }
shared_ptr<IfcProjectOrderTypeEnum> type_object( new IfcProjectOrderTypeEnum() );
if( boost::iequals( arg, L".CHANGEORDER." ) )
{
type_object->m_enum = IfcProjectOrderTypeEnum::ENUM_CHANGEORDER;
}
else if( boost::iequals( arg, L".MAINTENANCEWORKORDER." ) )
{
type_object->m_enum = IfcProjectOrderTypeEnum::ENUM_MAINTENANCEWORKORDER;
}
else if( boost::iequals( arg, L".MOVEORDER." ) )
{
type_object->m_enum = IfcProjectOrderTypeEnum::ENUM_MOVEORDER;
}
else if( boost::iequals( arg, L".PURCHASEORDER." ) )
{
type_object->m_enum = IfcProjectOrderTypeEnum::ENUM_PURCHASEORDER;
}
else if( boost::iequals( arg, L".WORKORDER." ) )
{
type_object->m_enum = IfcProjectOrderTypeEnum::ENUM_WORKORDER;
}
else if( boost::iequals( arg, L".USERDEFINED." ) )
{
type_object->m_enum = IfcProjectOrderTypeEnum::ENUM_USERDEFINED;
}
else if( boost::iequals( arg, L".NOTDEFINED." ) )
{
type_object->m_enum = IfcProjectOrderTypeEnum::ENUM_NOTDEFINED;
}
return type_object;
}
shared_ptr<IfcOpeningElementTypeEnum> IfcOpeningElementTypeEnum::createObjectFromSTEP( const std::wstring& arg )
{
// read TYPE
if( arg.compare( L"$" ) == 0 ) { return shared_ptr<IfcOpeningElementTypeEnum>(); }
else if( arg.compare( L"*" ) == 0 ) { return shared_ptr<IfcOpeningElementTypeEnum>(); }
shared_ptr<IfcOpeningElementTypeEnum> type_object( new IfcOpeningElementTypeEnum() );
if( boost::iequals( arg, L".OPENING." ) )
{
type_object->m_enum = IfcOpeningElementTypeEnum::ENUM_OPENING;
}
else if( boost::iequals( arg, L".RECESS." ) )
{
type_object->m_enum = IfcOpeningElementTypeEnum::ENUM_RECESS;
}
else if( boost::iequals( arg, L".USERDEFINED." ) )
{
type_object->m_enum = IfcOpeningElementTypeEnum::ENUM_USERDEFINED;
}
else if( boost::iequals( arg, L".NOTDEFINED." ) )
{
type_object->m_enum = IfcOpeningElementTypeEnum::ENUM_NOTDEFINED;
}
return type_object;
}
shared_ptr<IfcTextPath> IfcTextPath::createObjectFromSTEP( const std::wstring& arg )
{
// read TYPE
if( arg.compare( L"$" ) == 0 ) { return shared_ptr<IfcTextPath>(); }
else if( arg.compare( L"*" ) == 0 ) { return shared_ptr<IfcTextPath>(); }
shared_ptr<IfcTextPath> type_object( new IfcTextPath() );
if( boost::iequals( arg, L".LEFT." ) )
{
type_object->m_enum = IfcTextPath::ENUM_LEFT;
}
else if( boost::iequals( arg, L".RIGHT." ) )
{
type_object->m_enum = IfcTextPath::ENUM_RIGHT;
}
else if( boost::iequals( arg, L".UP." ) )
{
type_object->m_enum = IfcTextPath::ENUM_UP;
}
else if( boost::iequals( arg, L".DOWN." ) )
{
type_object->m_enum = IfcTextPath::ENUM_DOWN;
}
return type_object;
}
shared_ptr<IfcOutletTypeEnum> IfcOutletTypeEnum::createObjectFromSTEP( const std::wstring& arg )
{
// read TYPE
if( arg.compare( L"$" ) == 0 ) { return shared_ptr<IfcOutletTypeEnum>(); }
else if( arg.compare( L"*" ) == 0 ) { return shared_ptr<IfcOutletTypeEnum>(); }
shared_ptr<IfcOutletTypeEnum> type_object( new IfcOutletTypeEnum() );
if( boost::iequals( arg, L".AUDIOVISUALOUTLET." ) )
{
type_object->m_enum = IfcOutletTypeEnum::ENUM_AUDIOVISUALOUTLET;
}
else if( boost::iequals( arg, L".COMMUNICATIONSOUTLET." ) )
{
type_object->m_enum = IfcOutletTypeEnum::ENUM_COMMUNICATIONSOUTLET;
}
else if( boost::iequals( arg, L".POWEROUTLET." ) )
{
type_object->m_enum = IfcOutletTypeEnum::ENUM_POWEROUTLET;
}
else if( boost::iequals( arg, L".DATAOUTLET." ) )
{
type_object->m_enum = IfcOutletTypeEnum::ENUM_DATAOUTLET;
}
else if( boost::iequals( arg, L".TELEPHONEOUTLET." ) )
{
type_object->m_enum = IfcOutletTypeEnum::ENUM_TELEPHONEOUTLET;
}
else if( boost::iequals( arg, L".USERDEFINED." ) )
{
type_object->m_enum = IfcOutletTypeEnum::ENUM_USERDEFINED;
}
else if( boost::iequals( arg, L".NOTDEFINED." ) )
{
type_object->m_enum = IfcOutletTypeEnum::ENUM_NOTDEFINED;
}
return type_object;
}
HRESULT STDMETHODCALLTYPE OnDefaultDeviceChanged( EDataFlow flow, ERole role, LPCWSTR pwstrDeviceId )
{
if ( flow == eRender && last_device.compare( pwstrDeviceId ) != 0 )
{
last_device = pwstrDeviceId;
EnterCriticalSection( &lock );
for ( std::vector<XAudio2_Output*>::iterator it = instances.begin(); it < instances.end(); ++it )
{
xaudio2_device_changed( *it );
}
LeaveCriticalSection( &lock );
}
return S_OK;
}
Dictionary::Dictionary(const std::wstring& locale)
{
std::wstring basePath = GetDllDir() + L"locales\\";
// Always load base locale first - that's our fallback
ReadDictionary(basePath, baseLocale);
// Now try to load by full locale code
if (locale != baseLocale && !ReadDictionary(basePath, locale))
{
// Fall back to short locale name
size_t pos = locale.find(L'-');
if (pos != std::wstring::npos && locale.compare(0, pos, baseLocale) != 0)
ReadDictionary(basePath, locale.substr(0, pos));
}
}
int SearchSortedUCTable (const SIdentifierTable aTable [], const std::wstring& aIdentifier)
{
for (int index = 0; aTable [index].iName; index++)
{
int comparision = aIdentifier.compare (aTable [index].iName);
if (comparision == 0)
{
return index;
}
if (comparision < 0)
{
break;
}
}
return -1;
}
shared_ptr<IfcUnitaryControlElementTypeEnum> IfcUnitaryControlElementTypeEnum::createObjectFromSTEP( const std::wstring& arg, const std::map<int,shared_ptr<BuildingEntity> >& map )
{
if( arg.compare( L"$" ) == 0 ) { return shared_ptr<IfcUnitaryControlElementTypeEnum>(); }
if( arg.compare( L"*" ) == 0 ) { return shared_ptr<IfcUnitaryControlElementTypeEnum>(); }
shared_ptr<IfcUnitaryControlElementTypeEnum> type_object( new IfcUnitaryControlElementTypeEnum() );
if( boost::iequals( arg, L".ALARMPANEL." ) )
{
type_object->m_enum = IfcUnitaryControlElementTypeEnum::ENUM_ALARMPANEL;
}
else if( boost::iequals( arg, L".CONTROLPANEL." ) )
{
type_object->m_enum = IfcUnitaryControlElementTypeEnum::ENUM_CONTROLPANEL;
}
else if( boost::iequals( arg, L".GASDETECTIONPANEL." ) )
{
type_object->m_enum = IfcUnitaryControlElementTypeEnum::ENUM_GASDETECTIONPANEL;
}
else if( boost::iequals( arg, L".INDICATORPANEL." ) )
{
type_object->m_enum = IfcUnitaryControlElementTypeEnum::ENUM_INDICATORPANEL;
}
else if( boost::iequals( arg, L".MIMICPANEL." ) )
{
type_object->m_enum = IfcUnitaryControlElementTypeEnum::ENUM_MIMICPANEL;
}
else if( boost::iequals( arg, L".HUMIDISTAT." ) )
{
type_object->m_enum = IfcUnitaryControlElementTypeEnum::ENUM_HUMIDISTAT;
}
else if( boost::iequals( arg, L".THERMOSTAT." ) )
{
type_object->m_enum = IfcUnitaryControlElementTypeEnum::ENUM_THERMOSTAT;
}
else if( boost::iequals( arg, L".WEATHERSTATION." ) )
{
type_object->m_enum = IfcUnitaryControlElementTypeEnum::ENUM_WEATHERSTATION;
}
else if( boost::iequals( arg, L".USERDEFINED." ) )
{
type_object->m_enum = IfcUnitaryControlElementTypeEnum::ENUM_USERDEFINED;
}
else if( boost::iequals( arg, L".NOTDEFINED." ) )
{
type_object->m_enum = IfcUnitaryControlElementTypeEnum::ENUM_NOTDEFINED;
}
return type_object;
}
shared_ptr<IfcConstructionEquipmentResourceTypeEnum> IfcConstructionEquipmentResourceTypeEnum::createObjectFromSTEP( const std::wstring& arg, const std::map<int,shared_ptr<BuildingEntity> >& map )
{
if( arg.compare( L"$" ) == 0 ) { return shared_ptr<IfcConstructionEquipmentResourceTypeEnum>(); }
if( arg.compare( L"*" ) == 0 ) { return shared_ptr<IfcConstructionEquipmentResourceTypeEnum>(); }
shared_ptr<IfcConstructionEquipmentResourceTypeEnum> type_object( new IfcConstructionEquipmentResourceTypeEnum() );
if( boost::iequals( arg, L".DEMOLISHING." ) )
{
type_object->m_enum = IfcConstructionEquipmentResourceTypeEnum::ENUM_DEMOLISHING;
}
else if( boost::iequals( arg, L".EARTHMOVING." ) )
{
type_object->m_enum = IfcConstructionEquipmentResourceTypeEnum::ENUM_EARTHMOVING;
}
else if( boost::iequals( arg, L".ERECTING." ) )
{
type_object->m_enum = IfcConstructionEquipmentResourceTypeEnum::ENUM_ERECTING;
}
else if( boost::iequals( arg, L".HEATING." ) )
{
type_object->m_enum = IfcConstructionEquipmentResourceTypeEnum::ENUM_HEATING;
}
else if( boost::iequals( arg, L".LIGHTING." ) )
{
type_object->m_enum = IfcConstructionEquipmentResourceTypeEnum::ENUM_LIGHTING;
}
else if( boost::iequals( arg, L".PAVING." ) )
{
type_object->m_enum = IfcConstructionEquipmentResourceTypeEnum::ENUM_PAVING;
}
else if( boost::iequals( arg, L".PUMPING." ) )
{
type_object->m_enum = IfcConstructionEquipmentResourceTypeEnum::ENUM_PUMPING;
}
else if( boost::iequals( arg, L".TRANSPORTING." ) )
{
type_object->m_enum = IfcConstructionEquipmentResourceTypeEnum::ENUM_TRANSPORTING;
}
else if( boost::iequals( arg, L".USERDEFINED." ) )
{
type_object->m_enum = IfcConstructionEquipmentResourceTypeEnum::ENUM_USERDEFINED;
}
else if( boost::iequals( arg, L".NOTDEFINED." ) )
{
type_object->m_enum = IfcConstructionEquipmentResourceTypeEnum::ENUM_NOTDEFINED;
}
return type_object;
}
//指定されたフォーマットに対応するEncoderのCLSIDを取得する
bool GetEncoderClassID(const std::wstring& MimeType,CLSID* ClassID)
{
typedef Gdiplus::ImageCodecInfo CodecInfo;
unsigned EncoderCount,Size;
Gdiplus::GetImageEncodersSize(&EncoderCount,&Size);
if(!Size) return false;
std::vector<unsigned char> Codecs(Size,0);
Gdiplus::GetImageEncoders(EncoderCount,Size,(CodecInfo*)Codecs.data());
auto Codec=std::find_if((CodecInfo*)Codecs.data(),(CodecInfo*)Codecs.data()+EncoderCount,
[&](CodecInfo& Codec){return !MimeType.compare(Codec.MimeType);});
std::memcpy(ClassID,&(*Codec).Clsid,sizeof(CLSID));
return true;
}
shared_ptr<IfcCondenserTypeEnum> IfcCondenserTypeEnum::createObjectFromSTEP( const std::wstring& arg, const std::map<int,shared_ptr<BuildingEntity> >& map )
{
if( arg.compare( L"$" ) == 0 ) { return shared_ptr<IfcCondenserTypeEnum>(); }
if( arg.compare( L"*" ) == 0 ) { return shared_ptr<IfcCondenserTypeEnum>(); }
shared_ptr<IfcCondenserTypeEnum> type_object( new IfcCondenserTypeEnum() );
if( boost::iequals( arg, L".AIRCOOLED." ) )
{
type_object->m_enum = IfcCondenserTypeEnum::ENUM_AIRCOOLED;
}
else if( boost::iequals( arg, L".EVAPORATIVECOOLED." ) )
{
type_object->m_enum = IfcCondenserTypeEnum::ENUM_EVAPORATIVECOOLED;
}
else if( boost::iequals( arg, L".WATERCOOLED." ) )
{
type_object->m_enum = IfcCondenserTypeEnum::ENUM_WATERCOOLED;
}
else if( boost::iequals( arg, L".WATERCOOLEDBRAZEDPLATE." ) )
{
type_object->m_enum = IfcCondenserTypeEnum::ENUM_WATERCOOLEDBRAZEDPLATE;
}
else if( boost::iequals( arg, L".WATERCOOLEDSHELLCOIL." ) )
{
type_object->m_enum = IfcCondenserTypeEnum::ENUM_WATERCOOLEDSHELLCOIL;
}
else if( boost::iequals( arg, L".WATERCOOLEDSHELLTUBE." ) )
{
type_object->m_enum = IfcCondenserTypeEnum::ENUM_WATERCOOLEDSHELLTUBE;
}
else if( boost::iequals( arg, L".WATERCOOLEDTUBEINTUBE." ) )
{
type_object->m_enum = IfcCondenserTypeEnum::ENUM_WATERCOOLEDTUBEINTUBE;
}
else if( boost::iequals( arg, L".USERDEFINED." ) )
{
type_object->m_enum = IfcCondenserTypeEnum::ENUM_USERDEFINED;
}
else if( boost::iequals( arg, L".NOTDEFINED." ) )
{
type_object->m_enum = IfcCondenserTypeEnum::ENUM_NOTDEFINED;
}
return type_object;
}
shared_ptr<IfcPipeFittingTypeEnum> IfcPipeFittingTypeEnum::createObjectFromSTEP( const std::wstring& arg, const std::map<int,shared_ptr<BuildingEntity> >& map )
{
if( arg.compare( L"$" ) == 0 ) { return shared_ptr<IfcPipeFittingTypeEnum>(); }
if( arg.compare( L"*" ) == 0 ) { return shared_ptr<IfcPipeFittingTypeEnum>(); }
shared_ptr<IfcPipeFittingTypeEnum> type_object( new IfcPipeFittingTypeEnum() );
if( boost::iequals( arg, L".BEND." ) )
{
type_object->m_enum = IfcPipeFittingTypeEnum::ENUM_BEND;
}
else if( boost::iequals( arg, L".CONNECTOR." ) )
{
type_object->m_enum = IfcPipeFittingTypeEnum::ENUM_CONNECTOR;
}
else if( boost::iequals( arg, L".ENTRY." ) )
{
type_object->m_enum = IfcPipeFittingTypeEnum::ENUM_ENTRY;
}
else if( boost::iequals( arg, L".EXIT." ) )
{
type_object->m_enum = IfcPipeFittingTypeEnum::ENUM_EXIT;
}
else if( boost::iequals( arg, L".JUNCTION." ) )
{
type_object->m_enum = IfcPipeFittingTypeEnum::ENUM_JUNCTION;
}
else if( boost::iequals( arg, L".OBSTRUCTION." ) )
{
type_object->m_enum = IfcPipeFittingTypeEnum::ENUM_OBSTRUCTION;
}
else if( boost::iequals( arg, L".TRANSITION." ) )
{
type_object->m_enum = IfcPipeFittingTypeEnum::ENUM_TRANSITION;
}
else if( boost::iequals( arg, L".USERDEFINED." ) )
{
type_object->m_enum = IfcPipeFittingTypeEnum::ENUM_USERDEFINED;
}
else if( boost::iequals( arg, L".NOTDEFINED." ) )
{
type_object->m_enum = IfcPipeFittingTypeEnum::ENUM_NOTDEFINED;
}
return type_object;
}
shared_ptr<IfcStructuralCurveActivityTypeEnum> IfcStructuralCurveActivityTypeEnum::createObjectFromSTEP( const std::wstring& arg, const std::map<int,shared_ptr<BuildingEntity> >& map )
{
if( arg.compare( L"$" ) == 0 ) { return shared_ptr<IfcStructuralCurveActivityTypeEnum>(); }
if( arg.compare( L"*" ) == 0 ) { return shared_ptr<IfcStructuralCurveActivityTypeEnum>(); }
shared_ptr<IfcStructuralCurveActivityTypeEnum> type_object( new IfcStructuralCurveActivityTypeEnum() );
if( boost::iequals( arg, L".CONST." ) )
{
type_object->m_enum = IfcStructuralCurveActivityTypeEnum::ENUM_CONST;
}
else if( boost::iequals( arg, L".LINEAR." ) )
{
type_object->m_enum = IfcStructuralCurveActivityTypeEnum::ENUM_LINEAR;
}
else if( boost::iequals( arg, L".POLYGONAL." ) )
{
type_object->m_enum = IfcStructuralCurveActivityTypeEnum::ENUM_POLYGONAL;
}
else if( boost::iequals( arg, L".EQUIDISTANT." ) )
{
type_object->m_enum = IfcStructuralCurveActivityTypeEnum::ENUM_EQUIDISTANT;
}
else if( boost::iequals( arg, L".SINUS." ) )
{
type_object->m_enum = IfcStructuralCurveActivityTypeEnum::ENUM_SINUS;
}
else if( boost::iequals( arg, L".PARABOLA." ) )
{
type_object->m_enum = IfcStructuralCurveActivityTypeEnum::ENUM_PARABOLA;
}
else if( boost::iequals( arg, L".DISCRETE." ) )
{
type_object->m_enum = IfcStructuralCurveActivityTypeEnum::ENUM_DISCRETE;
}
else if( boost::iequals( arg, L".USERDEFINED." ) )
{
type_object->m_enum = IfcStructuralCurveActivityTypeEnum::ENUM_USERDEFINED;
}
else if( boost::iequals( arg, L".NOTDEFINED." ) )
{
type_object->m_enum = IfcStructuralCurveActivityTypeEnum::ENUM_NOTDEFINED;
}
return type_object;
}
shared_ptr<IfcObjectTypeEnum> IfcObjectTypeEnum::createObjectFromSTEP( const std::wstring& arg, const std::map<int,shared_ptr<BuildingEntity> >& map )
{
if( arg.compare( L"$" ) == 0 ) { return shared_ptr<IfcObjectTypeEnum>(); }
if( arg.compare( L"*" ) == 0 ) { return shared_ptr<IfcObjectTypeEnum>(); }
shared_ptr<IfcObjectTypeEnum> type_object( new IfcObjectTypeEnum() );
if( boost::iequals( arg, L".PRODUCT." ) )
{
type_object->m_enum = IfcObjectTypeEnum::ENUM_PRODUCT;
}
else if( boost::iequals( arg, L".PROCESS." ) )
{
type_object->m_enum = IfcObjectTypeEnum::ENUM_PROCESS;
}
else if( boost::iequals( arg, L".CONTROL." ) )
{
type_object->m_enum = IfcObjectTypeEnum::ENUM_CONTROL;
}
else if( boost::iequals( arg, L".RESOURCE." ) )
{
type_object->m_enum = IfcObjectTypeEnum::ENUM_RESOURCE;
}
else if( boost::iequals( arg, L".ACTOR." ) )
{
type_object->m_enum = IfcObjectTypeEnum::ENUM_ACTOR;
}
else if( boost::iequals( arg, L".GROUP." ) )
{
type_object->m_enum = IfcObjectTypeEnum::ENUM_GROUP;
}
else if( boost::iequals( arg, L".PROJECT." ) )
{
type_object->m_enum = IfcObjectTypeEnum::ENUM_PROJECT;
}
else if( boost::iequals( arg, L".NOTDEFINED." ) )
{
type_object->m_enum = IfcObjectTypeEnum::ENUM_NOTDEFINED;
}
return type_object;
}