// -----------------------------------------------------------------------------
// GetTeamworkMembers
//
// collect information of joined Teamwork members
// -----------------------------------------------------------------------------
static GSErrCode GetTeamworkMembers (GS::HashTable<short, API_UserInfo>& userInfoTable, short& myUserId)
{
API_ProjectInfo projectInfo;
BNZeroMemory (&projectInfo, sizeof (API_ProjectInfo));
GSErrCode err = ACAPI_Environment (APIEnv_ProjectID, &projectInfo);
if (projectInfo.location != NULL)
delete projectInfo.location;
if (projectInfo.location_team != NULL)
delete projectInfo.location_team;
if (err != NoError)
return err;
myUserId = projectInfo.userId;
API_SharingInfo sharingInfo;
BNZeroMemory (&sharingInfo, sizeof (API_SharingInfo));
err = ACAPI_Environment (APIEnv_ProjectSharingID, &sharingInfo);
if (err == NoError && sharingInfo.users != NULL) {
for (Int32 i = 0; i < sharingInfo.nUsers; i++)
userInfoTable.Add (((*sharingInfo.users)[i]).userId, (*sharingInfo.users)[i]);
}
if (sharingInfo.users != NULL)
BMhKill (reinterpret_cast<GSHandle*>(&sharingInfo.users));
return err;
} /* GetTeamworkMembers */
static GSErrCode CreateAText (const TextParams *textPars)
{
API_Element element;
API_ElementMemo memo;
Int32 len;
API_Coord c;
GSErrCode err;
if (!ClickAPoint ("Click the top/left corner of the text box", &c))
return APIERR_CANCEL;
BNZeroMemory (&element, sizeof (element));
BNZeroMemory (&memo, sizeof (memo));
element.header.typeID = API_TextID;
err = ACAPI_Element_GetDefaults (&element, NULL);
if (err != NoError) {
ErrorBeep ("ACAPI_Element_GetDefaults (text)", err);
return err;
}
element.text.pen = textPars->pen;
element.text.size = textPars->size;
element.text.anchor = APIAnc_LT;
element.text.just = APIJust_Left;
element.text.loc = c;
element.text.nonBreaking = true;
element.text.nLine = 1;
len = Strlen32 (textPars->content);
memo.textContent = BMAllocateHandle (len + 1, ALLOCATE_CLEAR, 0);
err = BMError ();
if (err != NoError)
return err;
strcpy (*memo.textContent, textPars->content);
err = ACAPI_CallUndoableCommand ("Create text",
[&] () -> GSErrCode {
return ACAPI_Element_Create (&element, &memo);
});
if (err != NoError)
ErrorBeep ("ACAPI_Element_Create (text)", err);
ACAPI_DisposeElemMemoHdls (&memo);
return err;
} // CreateAText
bool GetAnArc (const char* prompt,
API_Coord* origin,
API_Coord* startPos,
API_Coord* endPos,
bool* isArcNegative /*= NULL*/)
{
API_GetPointType pointInfo;
API_GetLineType lineInfo;
API_GetArcType arcInfo;
GSErrCode err;
BNZeroMemory (&pointInfo, sizeof (API_GetPointType));
BNZeroMemory (&lineInfo, sizeof (API_GetLineType));
BNZeroMemory (&arcInfo, sizeof (API_GetArcType));
CHTruncate (prompt, pointInfo.prompt, sizeof (pointInfo.prompt));
err = ACAPI_Interface (APIIo_GetPointID, &pointInfo, NULL);
if (err == NoError) {
CHTruncate (prompt, lineInfo.prompt, sizeof (lineInfo.prompt));
lineInfo.startCoord = pointInfo.pos; // line starts with the clicked point
lineInfo.disableDefaultFeedback = false; // draw the default thick rubber line
err = ACAPI_Interface (APIIo_GetLineID, &lineInfo, NULL);
}
if (err == NoError) {
CHTruncate (prompt, arcInfo.prompt, sizeof (arcInfo.prompt));
arcInfo.origo = lineInfo.startCoord; // set arc origo
arcInfo.startCoord = lineInfo.pos; // arc starts with the second clicked point
arcInfo.startCoordGiven = true;
arcInfo.disableDefaultFeedback = false; // draw the default thick rubber line
err = ACAPI_Interface (APIIo_GetArcID, &arcInfo, NULL);
}
if (err == NoError) {
if (origin != NULL)
*origin = ToCoord (arcInfo.origo);
if (startPos != NULL)
*startPos = ToCoord (arcInfo.startCoord);
if (endPos != NULL)
*endPos = ToCoord (arcInfo.pos);
if (isArcNegative != NULL)
*isArcNegative = arcInfo.negArc ? true : false;
}
return (err == NoError);
} // GetAnArc
void deleteElements(){
API_Element element;
elementidlist elementsToDelete;
GSErr err;
char buffer[256];
readDelimitedFrom(getClientSocket(), &elementsToDelete);
BNZeroMemory(&element, sizeof(API_Element));
API_Elem_Head* test;
for (int i = 0; i < elementsToDelete.guid_size(); i++){
element.header.guid = APIGuidFromString(elementsToDelete.guid(i).c_str());
if (ACAPI_Element_Get(&element) == NoError){
layermsg layerMsg;
layerMsg.set_name(searchLayers(element.header.layer));
bool hidden = hiddenLayer(layerMsg);
if (hidden){
controlLayer(layerMsg, true);
}
test = &element.header;
err = ACAPI_Element_Delete(&test, 1);
if (hidden){
controlLayer(layerMsg, false);
}
if (hasError(err)){
quit();
return;
}
}
}
}
void selectElement(){
API_ElemTypeID typeID;
API_Guid guid;
API_Element element;
API_ElementMemo memo;
API_Coord3D c3;
GSErrCode err = NoError;
elementid eleMsg;
char buffer[256];
while (!ClickAnElem("Click an element", API_ZombieElemID, NULL, &typeID, &guid, &c3)){
}
/*
if (!ClickAnElem("Click an element", API_ZombieElemID, NULL, &typeID, &guid, &c3)) {
WriteReport_Alert("Please click an element");
return;
}
*/
BNZeroMemory(&element, sizeof(API_Element));
element.header.typeID = typeID;
element.header.guid = guid;
err = ACAPI_Element_Get(&element);
if (err != NoError) {
sprintf(buffer, ErrID_To_Name(err));
ACAPI_WriteReport(buffer, true);
return;
}
sendElementID(getClientSocket(), element);
}
static void Do_CreateAText ()
{
bool okHit;
TextParams textPars;
Int32 version = 0;
GSSize nBytes = 0;
unsigned short platformSign = GS::Act_Platform_Sign;
BNZeroMemory (&textPars, sizeof (TextParams));
ACAPI_GetPreferences_Platform (&version, &nBytes, NULL, NULL);
if (version == 1 && nBytes == sizeof (TextParams)) {
ACAPI_GetPreferences_Platform (&version, &nBytes, &textPars, &platformSign);
if (platformSign != GS::Act_Platform_Sign) {
GS::PlatformSign inplatform = (GS::PlatformSign) platformSign;
IVShort (inplatform, &textPars.pen);
IVShort (inplatform, &textPars.filler_1);
IVLong (inplatform, &textPars.filler_2);
IVDouble (inplatform, &textPars.size);
// char content [256];
}
} else
DefaultParams (&textPars);
okHit = InputParams (&textPars, NULL);
if (okHit) {
ACAPI_SetPreferences (1, sizeof (TextParams), &textPars);
CreateAText (&textPars);
}
return;
} // Do_CreateAText
// -----------------------------------------------------------------------------
// PrintElementInfo
//
// print reservation information of a given element
// -----------------------------------------------------------------------------
static void PrintElementInfo (const GS::HashTable<short, API_UserInfo>& userInfoTable,
short myUserId,
const char* actionStr,
const API_Guid& guid,
short elementOwnerId = 0)
{
API_Elem_Head elemHead;
BNZeroMemory (&elemHead, sizeof (API_Elem_Head));
elemHead.guid = guid;
if (ACAPI_Element_GetHeader (&elemHead) == NoError) {
GS::UniString elemTypeName;
ACAPI_Goodies (APIAny_GetElemTypeNameID, (void*) elemHead.typeID, &elemTypeName);
GS::UniString actionByUserStr (actionStr);
if (userInfoTable.ContainsKey (elementOwnerId)) {
if (elementOwnerId == myUserId) {
actionByUserStr.Append (" by me (");
actionByUserStr.Append (userInfoTable[elementOwnerId].fullName);
actionByUserStr.Append (")");
} else {
actionByUserStr.Append (" by ");
actionByUserStr.Append (userInfoTable[elementOwnerId].fullName);
}
}
const GS::UniString reportString = GS::UniString::Printf ("= %T {%T} is %T", elemTypeName.ToPrintf (), APIGuidToString (guid).ToPrintf (), actionByUserStr.ToPrintf ());
ACAPI_WriteReport (reportString.ToCStr ().Get (), false);
}
} /* PrintElementInfo */
void getColumns(){
API_Element element;
GSErrCode err;
char buffer[256];
columnrepeated columnMsg;
API_StoryInfo storyInfo;
storyinfo* storyInfoMsg;
err = ACAPI_Environment(APIEnv_GetStorySettingsID, &storyInfo, NULL);
if (err != NoError) {
ErrorBeep("APIEnv_GetStorySettingsID", err);
return;
}
GS::Array<API_Guid> elemList;
ACAPI_Element_GetElemList(API_ColumnID, &elemList);
for (GS::Array<API_Guid>::ConstIterator it = elemList.Enumerate(); it != NULL; ++it) {
BNZeroMemory(&element, sizeof(API_Element));
element.header.guid = *it;
err = ACAPI_Element_Get(&element);
if (err == NoError) {
columnMsg.add_px(element.column.origoPos.x);
columnMsg.add_py(element.column.origoPos.y);
storyInfoMsg = columnMsg.add_bottomlevel();
storyInfoMsg->set_exists(true);
storyInfoMsg->set_index(element.header.floorInd);
storyInfoMsg->set_level((*storyInfo.data)[element.header.floorInd - storyInfo.firstStory].level);
storyInfoMsg->set_name((*storyInfo.data)[element.header.floorInd - storyInfo.firstStory].name);
storyInfoMsg = columnMsg.add_toplevel();
storyInfoMsg->set_exists(true);
storyInfoMsg->set_index(element.header.floorInd + 1);
storyInfoMsg->set_level((*storyInfo.data)[element.header.floorInd + 1 - storyInfo.firstStory].level);
storyInfoMsg->set_name((*storyInfo.data)[element.header.floorInd + 1 - storyInfo.firstStory].name);
columnMsg.add_circular(element.column.circleBased);
columnMsg.add_angle(element.column.angle);
columnMsg.add_depth(element.column.coreDepth);
columnMsg.add_width(element.column.coreWidth);
columnMsg.add_slantangle(element.column.slantAngle);
columnMsg.add_slantdirection(element.column.slantDirectionAngle);
char s[64];
APIGuid2GSGuid(element.header.guid).ConvertToString(s);
columnMsg.add_guid(s);
}
else{
sprintf(buffer, ErrID_To_Name(err));
ACAPI_WriteReport(buffer, true);
}
}
//writeDelimitedTo(wallInfo, raw_out);
writeDelimitedTo(getClientSocket(), columnMsg);
BMKillHandle(reinterpret_cast<GSHandle *> (&storyInfo.data));
}
static void DefaultParams (TextParams *textPars)
{
BNZeroMemory (textPars, sizeof (TextParams));
textPars->pen = 65;
textPars->size = 4.0;
strcpy (textPars->content, "This is the default text");
return;
} // DefaultParams
// -----------------------------------------------------------------------------
// Do_ElementEdit
// edit the linked elements
// -----------------------------------------------------------------------------
static GSErrCode Do_ElementEdit (API_Elem_Head *header)
{
API_Guid elemGuid = APINULLGuid;
Int32 nLinks = 0;
API_Guid** linkToList = NULL;
API_ActTranPars actTranPars;
API_EditPars editPars;
GSErrCode err;
BNZeroMemory (&actTranPars, sizeof (API_ActTranPars));
BNZeroMemory (&editPars, sizeof (API_EditPars));
ACAPI_Notify_GetTranParams (&actTranPars);
ActTranPars_To_EditPars (&actTranPars, &editPars);
elemGuid = header->guid;
err = ACAPI_Element_GetLinks (elemGuid, &linkToList, &nLinks);
if (linkToList == NULL || nLinks == 0)
return NoError;
if (err == NoError) {
if (err == NoError) {
API_Neig** neigHdl = reinterpret_cast<API_Neig**> (BMAllocateHandle (nLinks * sizeof (API_Neig), ALLOCATE_CLEAR, 0));
if (neigHdl == NULL)
return APIERR_MEMFULL;
for (GSIndex index = 0; index < nLinks; index++) {
API_Elem_Head elemHead;
BNZeroMemory (&elemHead, sizeof (API_Elem_Head));
elemHead.guid = (*linkToList)[index];
ACAPI_Element_GetHeader (&elemHead);
ElemHead_To_Neig (&(*neigHdl)[index], &elemHead);
}
err = ACAPI_Element_Edit (neigHdl, nLinks, &editPars);
BMKillHandle (reinterpret_cast<GSHandle*> (&neigHdl));
}
}
BMKillHandle (reinterpret_cast<GSHandle*> (&linkToList));
return err;
} // Do_ElementEdit
GSErrCode Attribute_Get (API_Attribute* attr, const API_AttrTypeID& typeID, const short index)
{
GSErrCode err = NoError;
BNZeroMemory (attr, sizeof (API_Attribute));
attr->header.typeID = typeID;
attr->header.index = index;
// search by type and index
err = ACAPI_Attribute_Get (attr);
if (err != NoError)
ACAPI_WriteReport ("ACAPI_Attribute_Get failed", true);
return err;
}
void Do_ElemSet_Create (void)
{
GS::Array<API_Guid> guids;
// get the guids of a Wall, Column, Beam and Window
GS::Array<API_Guid> wallList;
ACAPI_Element_GetElemList (API_WallID, &wallList);
if (!wallList.IsEmpty ())
guids.Push (wallList[0]);
else
guids.Push (APINULLGuid);
GS::Array<API_Guid> columnList;
ACAPI_Element_GetElemList (API_ColumnID, &columnList);
if (!columnList.IsEmpty ())
guids.Push (columnList[0]);
else
guids.Push (APINULLGuid);
GS::Array<API_Guid> beamList;
ACAPI_Element_GetElemList (API_BeamID, &beamList);
if (!beamList.IsEmpty ())
guids.Push (beamList[0]);
else
guids.Push (APINULLGuid);
GS::Array<API_Guid> windowList;
ACAPI_Element_GetElemList (API_WindowID, &windowList);
if (!windowList.IsEmpty ())
guids.Push (windowList[0]);
else
guids.Push (APINULLGuid);
// write a note into the user data
API_UserData userData;
BNZeroMemory (&userData, sizeof (userData));
userData.dataVersion = 4;
userData.platformSign = GS::Act_Platform_Sign;
userData.dataHdl = BMAllocateHandle (1024, ALLOCATE_CLEAR, 0);
if (userData.dataHdl != NULL)
sprintf (*userData.dataHdl, "Original element count: 4, guids [%s,%s,%s,%s]", APIGuidToString (guids[0]).ToCStr ().Get (), APIGuidToString (guids[1]).ToCStr ().Get (), APIGuidToString (guids[2]).ToCStr ().Get (), APIGuidToString (guids[3]).ToCStr ().Get ());
API_Guid setGuid;
GSErrCode err = ACAPI_ElementSet_Create (&guids, &userData, &setGuid);
if (err != NoError) {
DBPrintf ("Create Element Set error: %d\n", err);
} else {
DBPrintf ("Created Element Set (%s)\n", APIGuidToString (setGuid).ToCStr ().Get ());
}
BMKillHandle (&userData.dataHdl);
} /* ElemSet_Create */
bool GetMenuItemMark (short menuResID, short itemIndex)
{
API_MenuItemRef itemRef;
GSFlags itemFlags;
BNZeroMemory (&itemRef, sizeof (API_MenuItemRef));
itemRef.menuResID = menuResID;
itemRef.itemIndex = itemIndex;
itemFlags = 0;
ACAPI_Interface (APIIo_GetMenuItemFlagsID, &itemRef, &itemFlags);
return (bool) ((itemFlags & API_MenuItemChecked) != 0);
} // GetMenuItemMark
// -----------------------------------------------------------------------------
// Start the binary link
// -----------------------------------------------------------------------------
GSErrCode __ACENV_CALL BeginLinkCommandHandler (GSHandle params, GSPtr resultData, bool silentMode)
{
UNUSED_PARAMETER (params);
UNUSED_PARAMETER (silentMode);
CallBackTbl_Client *myResultData;
myResultData = (CallBackTbl_Client *) resultData;
BNZeroMemory (myResultData, sizeof (CallBackTbl_Client));
myResultData->counterProc = ShowCounter;
ACAPI_KeepInMemory (true);
return NoError;
} // BeginLinkCommandHandler
static void ModifyParams (const TextParams *textPars,
const TextParamsInd *parHdlInd,
GSHandle parHdl)
{
API_MDCLParameter par;
GSErrCode err = NoError;
if (parHdlInd->penInd != 0) {
BNZeroMemory (&par, sizeof (API_MDCLParameter));
par.index = parHdlInd->penInd;
par.type = MDCLPar_int;
par.int_par = textPars->pen;
err = ACAPI_Goodies (APIAny_ChangeMDCLParameterID, parHdl, &par);
}
if (err == NoError && parHdlInd->sizeInd != 0) {
BNZeroMemory (&par, sizeof (API_MDCLParameter));
par.index = parHdlInd->sizeInd;
par.type = MDCLPar_float;
par.float_par = textPars->size;
err = ACAPI_Goodies (APIAny_ChangeMDCLParameterID, parHdl, &par);
}
if (err == NoError && parHdlInd->contentInd != 0) {
BNZeroMemory (&par, sizeof (API_MDCLParameter));
par.index = parHdlInd->contentInd;
par.type = MDCLPar_string;
par.string_par = textPars->content;
err = ACAPI_Goodies (APIAny_ChangeMDCLParameterID, parHdl, &par);
}
if (err != NoError)
ErrorBeep ("APIAny_ChangeMDCLParameterID", err);
return;
} // ModifyParams
//TODO: See more file type that are define in API_FileOpenPars, fileTypeID
void openFile(){
GSErrCode err;
char buffer[256];
API_FileOpenPars openPars;
openmessage pathMsg;
readDelimitedFrom(getClientSocket(), &pathMsg);
BNZeroMemory(&openPars, sizeof(API_FileOpenPars));
std::string extension = pathMsg.extension();
if (extension == "pln"){
openPars.fileTypeID = APIFType_PlanFile;
}
else if (extension == "pdf") {
openPars.fileTypeID = APIFType_PdfFile;
}
else if (extension == "ifc"
|| extension == "ifcxml"
|| extension == "ifczip") {
openPars.fileTypeID = APIFType_IfcFile;
}
else {
openPars.fileTypeID = APIFType_None;
}
openPars.useStoredLib = true;
IO::Location* folderLoc = new IO::Location(pathMsg.path().c_str());
openPars.file = folderLoc;
err = ACAPI_Automate(APIDo_OpenID, &openPars, NULL);
delete openPars.file;
if (err != NoError){
sprintf(buffer, ErrID_To_Name(err));
ACAPI_WriteReport(buffer, true);
return;
}
}
void DisableEnableMenuItem (short menuResID, short itemIndex, bool disable)
{
API_MenuItemRef itemRef;
GSFlags itemFlags;
BNZeroMemory (&itemRef, sizeof (API_MenuItemRef));
itemRef.menuResID = menuResID;
itemRef.itemIndex = itemIndex;
itemFlags = 0;
ACAPI_Interface (APIIo_GetMenuItemFlagsID, &itemRef, &itemFlags);
if (disable)
itemFlags |= API_MenuItemDisabled;
else
itemFlags &= ~API_MenuItemDisabled;
ACAPI_Interface (APIIo_SetMenuItemFlagsID, &itemRef, &itemFlags);
return;
} // DisEnableMenuItem
void getLines(){
API_Element element;
GSErrCode err;
char buffer[256];
getlinesmsg msg;
linemsg* lineMsg;
pointsmessage* pts;
GS::Array<API_Guid> elemList;
ACAPI_Element_GetElemList(API_LineID, &elemList);
for (GS::Array<API_Guid>::ConstIterator it = elemList.Enumerate(); it != NULL; ++it) {
BNZeroMemory(&element, sizeof(API_Element));
element.header.guid = *it;
err = ACAPI_Element_Get(&element);
if (hasError(err)){
quit();
return;
}
char s[64];
APIGuid2GSGuid(element.header.guid).ConvertToString(s);
msg.add_guids(s);
lineMsg = msg.add_lines();
pts = new pointsmessage();
pts->add_px(element.line.begC.x);
pts->add_py(element.line.begC.y);
pts->add_pz(0);
pts->add_px(element.line.endC.x);
pts->add_py(element.line.endC.y);
pts->add_pz(0);
lineMsg->set_allocated_pts(pts);
}
writeDelimitedTo(getClientSocket(), msg);
}
bool ClickAPoint (const char *prompt,
API_Coord *c)
{
API_GetPointType pointInfo;
GSErrCode err;
BNZeroMemory (&pointInfo, sizeof (API_GetPointType));
CHTruncate (prompt, pointInfo.prompt, sizeof (pointInfo.prompt));
pointInfo.changeFilter = false;
pointInfo.changePlane = false;
err = ACAPI_Interface (APIIo_GetPointID, &pointInfo, NULL);
if (err != NoError) {
if (err != APIERR_CANCEL)
WriteReport_Alert ("Error in APICmd_GetPointID: %d", err);
return false;
}
c->x = pointInfo.pos.x;
c->y = pointInfo.pos.y;
return true;
} // ClickAPoint
// ============================================================================
// Do_ClickedElementMonitor
//
// observe clicked element
// ============================================================================
void Do_ClickedElementMonitor (bool switchOn)
{
API_Elem_Head elemHead;
GSErrCode err = NoError;
BNZeroMemory (&elemHead, sizeof (API_Elem_Head));
if (!ClickAnElem ("Click an element", API_ZombieElemID, NULL, &elemHead.typeID, &elemHead.guid)) {
WriteReport_Alert ("No element was clicked");
return;
}
if (switchOn) {
ACAPI_Notify_InstallElementObserver (ElementEventHandlerProc);
err = ACAPI_Element_AttachObserver (&elemHead, 0);
if (err == APIERR_LINKEXIST)
err = NoError;
} else {
err = ACAPI_Element_DetachObserver (&elemHead);
}
return;
} // Do_ClickedElementMonitor
void getObjects(){
API_Element element;
GSErrCode err;
char buffer[256];
objectrepeated objectMsg;
API_StoryInfo storyInfo;
storyinfo* storyInfoMsg;
err = ACAPI_Environment(APIEnv_GetStorySettingsID, &storyInfo, NULL);
if (err != NoError) {
ErrorBeep("APIEnv_GetStorySettingsID", err);
return;
}
GS::Array<API_Guid> elemList;
ACAPI_Element_GetElemList(API_ObjectID, &elemList);
for (GS::Array<API_Guid>::ConstIterator it = elemList.Enumerate(); it != NULL; ++it) {
BNZeroMemory(&element, sizeof(API_Element));
element.header.guid = *it;
err = ACAPI_Element_Get(&element);
if (err == NoError) {
std::string objectName = searchObjectsValue(element.object.libInd);
if (objectName == "Not Found"){
sprintf(buffer, "Found no material");
ACAPI_WriteReport(buffer, true);
}
else{
objectMsg.add_name(objectName);
}
objectMsg.add_px(element.object.pos.x);
objectMsg.add_py(element.object.pos.y);
storyInfoMsg = objectMsg.add_bottomlevel();
storyInfoMsg->set_exists(true);
storyInfoMsg->set_index(element.header.floorInd);
storyInfoMsg->set_level((*storyInfo.data)[element.header.floorInd - storyInfo.firstStory].level);
storyInfoMsg->set_name((*storyInfo.data)[element.header.floorInd - storyInfo.firstStory].name);
objectMsg.add_angle(element.object.angle);
objectMsg.add_xratio(element.object.xRatio);
objectMsg.add_yratio(element.object.yRatio);
objectMsg.add_bottomoffset(element.object.level);
if (element.header.variationID == APIVarId_SymbStair){
objectMsg.add_stairs(true);
}
else{
objectMsg.add_stairs(false);
}
objectMsg.add_usexyfixsize(element.object.useXYFixSize);
char s[64];
APIGuid2GSGuid(element.header.guid).ConvertToString(s);
objectMsg.add_guid(s);
}
else{
sprintf(buffer, ErrID_To_Name(err));
ACAPI_WriteReport(buffer, true);
}
}
writeDelimitedTo(getClientSocket(), objectMsg);
BMKillHandle(reinterpret_cast<GSHandle *> (&storyInfo.data));
}
void highlightElementByID(){
GSErrCode err;
API_NeigID neigID;
API_Element element;
elementidlist eleMsg;
API_StoryCmdType storyCmd;
char buffer[256];
readDelimitedFrom(getClientSocket(), &eleMsg);
Int32 nItem = eleMsg.guid_size();
bool add = true;
//Clear all selected elements
err = ACAPI_Element_Select(NULL, 0, add);
API_Neig** neigHdl = reinterpret_cast<API_Neig**> (BMAllocateHandle(nItem * sizeof(API_Neig), ALLOCATE_CLEAR, 0));
API_Neig neig;
for (int i = 0; i < nItem; i++){
BNZeroMemory(&element, sizeof(API_Element));
element.header.guid = APIGuidFromString(eleMsg.guid(i).c_str());
err = ACAPI_Element_Get(&element);
if (err != NoError) {
sprintf(buffer, ErrID_To_Name(err));
ACAPI_WriteReport(buffer, true);
return;
}
err = ACAPI_Goodies(APIAny_ElemTypeToNeigID, (void*)element.header.typeID, &neigID);
(*neigHdl)[i].neigID = neigID;
(*neigHdl)[i].guid = element.header.guid;
(*neigHdl)[i].flags = API_NeigFlg_Normal;
(*neigHdl)[i].elemPartType = APINeigElemPart_None;
}
//Add the current element to the selection
err = ACAPI_Element_Select(neigHdl, nItem, add);
if (err != NoError) {
sprintf(buffer, ErrID_To_Name(err));
ACAPI_WriteReport(buffer, true);
return;
}
BMhKill((GSHandle*)&neigHdl);
/*
* In order for the GUI update, we need to create an element, and then
* delete it.
* By doing this we can have the selected element highlighted
*/
API_Element wallElement;
API_ElementMemo memo;
BNZeroMemory(&memo, sizeof(API_ElementMemo));
BNZeroMemory(&wallElement, sizeof(API_Element));
wallElement.header.typeID = API_WallID;
wallElement.header.layer = 1;
err = ACAPI_Element_GetDefaults(&wallElement, &memo);
if (err != NoError) {
ErrorBeep("ACAPI_Element_GetMemo", err);
return;
}
err = ACAPI_Element_Create(&wallElement, &memo);
if (err != NoError){
ErrorBeep("ACAPI_Element_Create", err);
sprintf(buffer, ErrID_To_Name(err));
ACAPI_WriteReport(buffer, true);
}
ACAPI_DisposeElemMemoHdls(&memo);
API_Elem_Head* test;
test = &wallElement.header;
ACAPI_Element_Delete(&test, 1);
}
// -----------------------------------------------------------------------------
// ElementEventHandlerProc
//
// -----------------------------------------------------------------------------
GSErrCode __ACENV_CALL ElementEventHandlerProc (const API_NotifyElementType *elemType)
{
GSErrCode err = NoError;
char msgStr[256];
char elemStr[32];
if (elemType->notifID == APINotifyElement_BeginEvents || elemType->notifID == APINotifyElement_EndEvents) {
API_DatabaseInfo api_dbPars;
BNZeroMemory (&api_dbPars, sizeof (API_DatabaseInfo));
api_dbPars.databaseUnId = elemType->databaseId;
ACAPI_Database (APIDb_GetDatabaseInfoID, &api_dbPars, NULL);
sprintf (msgStr, "### Element_Manager: %s notification on database \"%s\"",
(elemType->notifID == APINotifyElement_BeginEvents) ? "Begin Events" : "End Events",
(const char *) GS::UniString (api_dbPars.title).ToCStr ());
} else if (GetElementTypeString (elemType->elemHead.typeID, elemStr)) {
char elemGuidStr[64];
char parentElemGuidStr[64];
API_Element parentElement;
API_ElementUserData parentUserData;
BNZeroMemory (&parentElement, sizeof (API_Element));
BNZeroMemory (&parentUserData, sizeof (API_ElementUserData));
ACAPI_Notify_GetParentElement (&parentElement, NULL, 0, &parentUserData);
BMKillHandle (&parentUserData.dataHdl);
CHTruncate (APIGuid2GSGuid (elemType->elemHead.guid).ToUniString ().ToCStr (), elemGuidStr, sizeof (elemGuidStr));
CHTruncate (APIGuid2GSGuid (parentElement.header.guid).ToUniString ().ToCStr (), parentElemGuidStr, sizeof (parentElemGuidStr));
switch (elemType->notifID) {
case APINotifyElement_New:
if (!allNewElements)
break;
if (parentElement.header.guid != APINULLGuid)
sprintf (msgStr, "### Element_Manager: <%s> created {%s} as a copy of {%s}", elemStr, elemGuidStr, parentElemGuidStr);
else
sprintf (msgStr, "### Element_Manager: <%s> created {%s}", elemStr, elemGuidStr);
err = ACAPI_Element_AttachObserver (const_cast<API_Elem_Head*> (&elemType->elemHead), 0);
if (err == APIERR_LINKEXIST)
err = NoError;
break;
case APINotifyElement_Copy:
if (!allNewElements)
break;
if (parentElement.header.guid != APINULLGuid) {
sprintf (msgStr, "### Element_Manager: <%s> copied {%s} from {%s}", elemStr, elemGuidStr, parentElemGuidStr);
err = ACAPI_Element_AttachObserver (const_cast<API_Elem_Head*> (&elemType->elemHead), 0);
if (err == APIERR_LINKEXIST)
err = NoError;
}
break;
case APINotifyElement_Change:
if (parentElement.header.guid != APINULLGuid)
sprintf (msgStr, "### Element_Manager: <%s> changed {%s} -> {%s}", elemStr, parentElemGuidStr, elemGuidStr);
else
sprintf (msgStr, "### Element_Manager: <%s> window/door changed {%s}", elemStr, elemGuidStr);
break;
case APINotifyElement_Edit:
if (parentElement.header.guid != APINULLGuid)
sprintf (msgStr, "### Element_Manager: <%s> edited {%s} -> {%s}", elemStr, parentElemGuidStr, elemGuidStr);
else
sprintf (msgStr, "### Element_Manager: <%s> edited in place {%s}", elemStr, elemGuidStr);
err = Do_ElementEdit (&parentElement.header);
break;
case APINotifyElement_Delete:
sprintf (msgStr, "### Element_Manager: <%s> deleted {%s}", elemStr, elemGuidStr);
break;
case APINotifyElement_Undo_Created:
sprintf (msgStr, "### Element_Manager: undone <%s> created {%s} ", elemStr, elemGuidStr);
break;
case APINotifyElement_Undo_Modified:
sprintf (msgStr, "### Element_Manager: undone <%s> modified {%s}", elemStr, elemGuidStr);
break;
case APINotifyElement_Undo_Deleted:
sprintf (msgStr, "### Element_Manager: undone <%s> deleted {%s}", elemStr, elemGuidStr);
break;
case APINotifyElement_Redo_Created:
sprintf (msgStr, "### Element_Manager: redone <%s> created {%s}", elemStr, elemGuidStr);
break;
case APINotifyElement_Redo_Modified:
sprintf (msgStr, "### Element_Manager: redone <%s> modified {%s}", elemStr, elemGuidStr);
break;
case APINotifyElement_Redo_Deleted:
sprintf (msgStr, "### Element_Manager: redone <%s> deleted {%s}", elemStr, elemGuidStr);
break;
default:
break;
}
}
ACAPI_WriteReport (msgStr, false);
return err;
} // ElementEventHandlerProc
void getWalls(){
API_Element element;
GSErrCode err;
char buffer[256];
getwallmsg msg;
wallmsg* aux;
pointsmessage* pts;
polyarcsmessage* arcs;
GS::Array<API_Guid> elemList;
ACAPI_Element_GetElemList(API_WallID, &elemList);
for (GS::Array<API_Guid>::ConstIterator it = elemList.Enumerate(); it != NULL; ++it) {
BNZeroMemory(&element, sizeof(API_Element));
element.header.guid = *it;
err = ACAPI_Element_Get(&element);
if (err == NoError) {
double x0 = element.wall.begC.x;
double y0 = element.wall.begC.y;
double x1 = element.wall.endC.x;
double y1 = element.wall.endC.y;
char s[256];
APIGuid2GSGuid(element.header.guid).ConvertToString(s);
msg.add_guid(s);
aux = msg.add_walls();
aux->set_bottomindex(element.header.floorInd);
aux->set_thickness(element.wall.thickness);
aux->set_upperindex(element.header.floorInd + 1);
std::string materialName;
if (element.wall.modelElemStructureType == API_BasicStructure){
materialName = searchBuildingMaterialsValue(element.wall.buildingMaterial);
aux->set_type("Basic");
}
else{
materialName = searchCompositeMaterialsValue(element.wall.composite);
aux->set_type("Composite");
}
if (materialName == "Not Found"){
sprintf(buffer, "Found no material %d", element.wall.buildingMaterial);
ACAPI_WriteReport(buffer, true);
}
else{
aux->set_material(materialName);
}
if (element.wall.referenceLineLocation == APIWallRefLine_Center ||
element.wall.referenceLineLocation == APIWallRefLine_CoreCenter){
aux->set_referenceline("Center");
}
else if (element.wall.referenceLineLocation == APIWallRefLine_Outside ||
element.wall.referenceLineLocation == APIWallRefLine_CoreOutside){
aux->set_referenceline("Outside");
}
else if (element.wall.referenceLineLocation == APIWallRefLine_Inside ||
element.wall.referenceLineLocation == APIWallRefLine_CoreInside){
aux->set_referenceline("Inside");
}
else{
sprintf(buffer, "Found no referenceLine %d", element.wall.buildingMaterial);
ACAPI_WriteReport(buffer, true);
}
aux->set_alphaangle(element.wall.slantAlpha);
aux->set_betaangle(element.wall.slantBeta);
aux->set_profilename("");
if (element.wall.profileType == APISect_Normal){
aux->set_typeprofile("Normal");
}
else if (element.wall.profileType == APISect_Slanted){
aux->set_typeprofile("Slanted");
}
else if (element.wall.profileType == APISect_Trapez){
aux->set_typeprofile("DoubleSlanted");
}
else if (element.wall.profileType == APISect_Poly){
aux->set_typeprofile("Poly");
aux->set_profilename(searchProfileName(element.wall.profileAttr));
}
aux->set_height(element.wall.height);
pts = new pointsmessage();
pts->add_px(x0);
pts->add_py(y0);
pts->add_pz(0);
pts->add_px(x1);
pts->add_py(y1);
pts->add_pz(0);
aux->set_allocated_pts(pts);
arcs = new polyarcsmessage();
arcs->add_arcangle(element.wall.angle);
arcs->add_begindex(0);
arcs->add_endindex(1);
aux->set_allocated_arcs(arcs);
aux->set_flipped(!element.wall.flipped);
aux->set_bottomoffset(element.wall.bottomOffset);
aux->set_refoffset(element.wall.offset);
if (element.wall.oppMat.overrideMaterial){
aux->set_oppmat(searchOverrideMaterialsValue(element.wall.oppMat.material));
}
else{
aux->set_oppmat("");
}
if (element.wall.refMat.overrideMaterial){
aux->set_refmat(searchOverrideMaterialsValue(element.wall.refMat.material));
}
else{
aux->set_refmat("");
}
if (element.wall.sidMat.overrideMaterial){
aux->set_sidmat(searchOverrideMaterialsValue(element.wall.sidMat.material));
}
else{
aux->set_sidmat("");
}
/*
API_Attribute attr;
attr.header.typeID = API_LayerID;
attr.header.index = 1;
err = ACAPI_Attribute_Get(&attr);
if (hasError(err)){
quit();
return;
}
msgArchiCAD(attr.layer.head.name);
aux->set_layer(attr.header.name);
*/
aux->set_layer(searchLayers(element.header.layer));
GS::Array<API_Guid> windowList;
ACAPI_Element_GetElemList(API_WindowID, &windowList);
API_Element wElement;
for (GS::Array<API_Guid>::ConstIterator it2 = windowList.Enumerate(); it2 != NULL; ++it2) {
BNZeroMemory(&wElement, sizeof(API_Element));
wElement.header.guid = *it2;
err = ACAPI_Element_Get(&wElement);
if (hasError(err)){
quit();
return;
}
if (wElement.window.owner == element.header.guid){
windowmessage* wmsg = aux->add_windows();
wmsg->set_height(wElement.window.openingBase.height);
wmsg->set_width(wElement.window.openingBase.width);
wmsg->set_objloc(wElement.window.objLoc);
wmsg->set_zpos(wElement.window.lower);
wmsg->set_guid(s);
wmsg->set_name(searchObjectsValue(wElement.window.openingBase.libInd));
wmsg->set_depthoffset(wElement.window.revealDepthOffset);
wmsg->set_flipx(wElement.window.openingBase.oSide);
wmsg->set_flipy(wElement.window.openingBase.reflected);
aux->add_windoworder(0);
API_ParamOwnerType paramOwner;
API_GetParamsType getParams;
BNZeroMemory(¶mOwner, sizeof(API_ParamOwnerType));
paramOwner.guid = wElement.header.guid;
paramOwner.libInd = 0;
paramOwner.typeID = wElement.header.typeID;
BNZeroMemory(&getParams, sizeof(API_GetParamsType));
err = ACAPI_Goodies(APIAny_OpenParametersID, ¶mOwner, NULL);
if (err == NoError) {
err = ACAPI_Goodies(APIAny_GetActParametersID, &getParams, NULL);
if (err == NoError) {
additionalparams* wparams = new additionalparams();
prepareParams(wparams, ¶mOwner, &getParams);
wmsg->set_allocated_params(wparams);
}
}
}
}
}
else{
sprintf(buffer, ErrID_To_Name(err));
ACAPI_WriteReport(buffer, true);
}
}
writeDelimitedTo(getClientSocket(), msg);
}
void getPolyLines(){
API_Element element;
API_ElementMemo memo;
API_StoryInfo storyInfo;
GSErrCode err;
char buffer[256];
getpolylinesmsg msg;
polylinemsg* polylineMsg;
pointsmessage* pts;
polyarcsmessage* arcs;
err = ACAPI_Environment(APIEnv_GetStorySettingsID, &storyInfo, NULL);
if (err != NoError) {
ErrorBeep("APIEnv_GetStorySettingsID", err);
return;
}
GS::Array<API_Guid> elemList;
ACAPI_Element_GetElemList(API_PolyLineID, &elemList);
for (GS::Array<API_Guid>::ConstIterator it = elemList.Enumerate(); it != NULL; ++it) {
BNZeroMemory(&element, sizeof(API_Element));
element.header.guid = *it;
err = ACAPI_Element_Get(&element);
if (hasError(err)){
quit();
return;
}
err = ACAPI_Element_GetMemo(element.header.guid, &memo);
if (hasError(err)){
quit();
return;
}
char s[64];
APIGuid2GSGuid(element.header.guid).ConvertToString(s);
msg.add_guids(s);
polylineMsg = msg.add_polylines();
pts = new pointsmessage();
for (int i = 1; i <= element.polyLine.poly.nCoords; i++){
pts->add_px((*memo.coords)[i].x);
pts->add_py((*memo.coords)[i].y);
pts->add_pz((*storyInfo.data)[element.header.floorInd - storyInfo.firstStory].level);
}
polylineMsg->set_allocated_pts(pts);
arcs = new polyarcsmessage();
int arcscounter = 1;
for (int i = 0; i < element.polyLine.poly.nArcs; i++){
for (; arcscounter < (*memo.parcs)[i].begIndex; arcscounter++){
arcs->add_arcangle(0);
arcs->add_begindex(arcscounter);
arcs->add_endindex(arcscounter + 1);
}
arcs->add_arcangle((*memo.parcs)[i].arcAngle);
arcs->add_begindex((*memo.parcs)[i].begIndex);
arcs->add_endindex((*memo.parcs)[i].endIndex);
arcscounter++;
}
polylineMsg->set_allocated_arcs(arcs);
}
writeDelimitedTo(getClientSocket(), msg);
BMKillHandle(reinterpret_cast<GSHandle *> (&storyInfo.data));
}
// -----------------------------------------------------------------------------
// Convert API_ActTranPars to API_EditPars
// -----------------------------------------------------------------------------
static bool ActTranPars_To_EditPars (const API_ActTranPars *actTranPars, API_EditPars *editPars)
{
BNZeroMemory (editPars, sizeof (API_EditPars));
editPars->withDelete = true;
editPars->typeID = (API_EditCmdID) 0;
switch (actTranPars->typeID) {
case APIEdit_Drag:
editPars->typeID = APIEdit_Drag;
editPars->endC.x = actTranPars->theDisp.x;
editPars->endC.y = actTranPars->theDisp.y;
editPars->endC.z = actTranPars->theDispZ;
break;
case APIEdit_Rotate:
editPars->typeID = APIEdit_Rotate;
editPars->origC = actTranPars->theOrigo;
editPars->begC.x = editPars->origC.x + 1.0;
editPars->begC.y = editPars->origC.y;
editPars->endC.x = editPars->origC.x + actTranPars->theCosA;
editPars->endC.y = editPars->origC.y + actTranPars->theSinA;
break;
case APIEdit_Mirror:
editPars->typeID = APIEdit_Mirror;
editPars->begC.x = actTranPars->theOrigo.x;
editPars->begC.y = actTranPars->theOrigo.y;
editPars->endC.x = actTranPars->theOrigo.x + actTranPars->theAxeVect.x;
editPars->endC.y = actTranPars->theOrigo.y + actTranPars->theAxeVect.y;
break;
case APIEdit_Stretch:
editPars->typeID = APIEdit_Stretch;
editPars->begC.x = actTranPars->theOrigo.x;
editPars->begC.y = actTranPars->theOrigo.y;
editPars->endC.x = actTranPars->theOrigo.x + actTranPars->theDisp.x;
editPars->endC.y = actTranPars->theOrigo.y + actTranPars->theDisp.y;
break;
case APIEdit_PDirStretch:
editPars->typeID = APIEdit_PDirStretch;
editPars->begC.x = actTranPars->theOrigo.x;
editPars->begC.y = actTranPars->theOrigo.y;
editPars->endC.x = actTranPars->theOrigo.x + actTranPars->theDisp.x;
editPars->endC.y = actTranPars->theOrigo.y + actTranPars->theDisp.y;
break;
case APIEdit_PHeightStretch:
editPars->typeID = APIEdit_PHeightStretch;
editPars->begC.x = actTranPars->theOrigo.x;
editPars->begC.y = actTranPars->theOrigo.y;
editPars->endC.x = actTranPars->theOrigo.x + actTranPars->theDisp.x;
editPars->endC.y = actTranPars->theOrigo.y + actTranPars->theDisp.y;
break;
case APIEdit_Resize:
editPars->typeID = APIEdit_Resize;
editPars->begC.x = actTranPars->theOrigo.x;
editPars->begC.y = actTranPars->theOrigo.y;
editPars->endC.x = actTranPars->theOrigo.x + 1;
editPars->endC.y = actTranPars->theOrigo.y;
editPars->endC2.x = actTranPars->theOrigo.x + actTranPars->theRatio;
editPars->endC2.y = actTranPars->theOrigo.y;
break;
case APIEdit_Elevate:
editPars->typeID = APIEdit_Elevate;
editPars->endC.z = actTranPars->theDispZ;
break;
case APIEdit_VertStretch:
editPars->typeID = APIEdit_VertStretch;
editPars->endC.z = actTranPars->theDispZ;
break;
case APIEdit_General:
break;
}
return editPars->typeID != (API_EditCmdID) 0;
} // ActTranPars_To_EditPars
static void ProcessParams (TextParams *textPars,
TextParamsInd *parHdlInd,
GSHandle parHdl)
{
API_MDCLParameter par;
Int32 n, i;
bool unknown, badValue, badType;
GSErrCode err;
WriteReport ("Passed parameters");
if (parHdl == NULL) {
WriteReport (" [no params]");
return;
}
err = ACAPI_Goodies (APIAny_GetMDCLParameterNumID, parHdl, &n);
WriteReport (" num: %d", n);
for (i = 1; i <= n; i++) {
BNZeroMemory (&par, sizeof (API_MDCLParameter));
par.index = i;
err = ACAPI_Goodies (APIAny_GetMDCLParameterID, parHdl, &par);
if (err == NoError) {
switch (par.type) {
case MDCLPar_int:
WriteReport (" [%d] (%s) \"%s\" %d", i, " int", par.name, par.int_par);
break;
case MDCLPar_pointer:
WriteReport (" [%d] (%s) \"%s\" %p", i, " ptr", par.name, par.ptr_par);
break;
case MDCLPar_float:
WriteReport (" [%d] (%s) \"%s\" %lf", i, "float", par.name, par.float_par);
break;
case MDCLPar_string:
WriteReport (" [%d] (%s) \"%s\" \"%s\"", i, " str", par.name, par.string_par);
break;
}
unknown = false;
badValue = false;
badType = false;
if (CHEqualCStrings (par.name, "pen")) {
if (par.type == MDCLPar_int) {
if (par.int_par > 1 && par.int_par < 256)
textPars->pen = (short) par.int_par;
else
badValue = true;
parHdlInd->penInd = (short) i;
} else
badType = true;
} else if (CHEqualCStrings (par.name, "size")) {
if (par.type == MDCLPar_float) {
if (par.float_par > 0.0001)
textPars->size = par.float_par;
else
badValue = true;
parHdlInd->sizeInd = (short) i;
} else
badType = true;
} else if (CHEqualCStrings (par.name, "content")) {
if (par.type == MDCLPar_string) {
strncpy (textPars->content, par.string_par, 255);
textPars->content [255] = '\0';
parHdlInd->contentInd = (short) i;
} else
badType = true;
} else
unknown = true;
if (unknown)
WriteReport (" ## unknown parameter ##");
if (badValue)
WriteReport (" ## bad value ##");
if (badType)
WriteReport (" ## bad type ##");
} else
ErrorBeep ("APIAny_GetMDCLParameterID", err);
}
return;
} // ProcessParams
bool ClickAnElem (const char *prompt,
API_ElemTypeID needTypeID,
API_Neig *neig /*= NULL*/,
API_ElemTypeID *typeID /*= NULL*/,
API_Guid *guid /*= NULL*/,
API_Coord3D *c /*= NULL*/,
bool ignorePartialSelection /*= true*/)
{
API_GetPointType pointInfo;
API_ElemTypeID clickedID;
GSErrCode err;
BNZeroMemory (&pointInfo, sizeof (API_GetPointType));
CHTruncate (prompt, pointInfo.prompt, sizeof (pointInfo.prompt));
pointInfo.changeFilter = false;
pointInfo.changePlane = false;
err = ACAPI_Interface (APIIo_GetPointID, &pointInfo, NULL);
if (err != NoError) {
if (err != APIERR_CANCEL)
WriteReport_Alert ("Error in APIIo_GetPointID: %d", err);
return false;
}
if (pointInfo.neig.neigID == APINeig_None) { // try to find polygonal element clicked inside the polygon area
API_Elem_Head elemHead;
BNZeroMemory (&elemHead, sizeof (API_Elem_Head));
API_ElemSearchPars pars;
BNZeroMemory (&pars, sizeof (API_ElemSearchPars));
pars.typeID = needTypeID;
pars.loc.x = pointInfo.pos.x;
pars.loc.y = pointInfo.pos.y;
pars.z = 1.00E6;
pars.filterBits = APIFilt_OnVisLayer | APIFilt_OnActFloor;
err = ACAPI_Goodies (APIAny_SearchElementByCoordID, &pars, &elemHead.guid);
if (err == NoError) {
elemHead.typeID = pars.typeID;
ElemHead_To_Neig (&pointInfo.neig, &elemHead);
}
}
if (pointInfo.neig.elemPartType != APINeigElemPart_None && ignorePartialSelection) {
pointInfo.neig.elemPartType = APINeigElemPart_None;
pointInfo.neig.elemPartIndex = 0;
}
clickedID = Neig_To_ElemID (pointInfo.neig.neigID);
if (neig != NULL)
*neig = pointInfo.neig;
if (typeID != NULL)
*typeID = clickedID;
if (guid != NULL)
*guid = pointInfo.neig.guid;
if (c != NULL)
*c = pointInfo.pos;
if (clickedID == API_ZombieElemID)
return false;
bool good = (needTypeID == API_ZombieElemID || needTypeID == clickedID);
if (!good && clickedID == API_SectElemID) {
API_Element element;
BNZeroMemory (&element, sizeof (API_Element));
element.header.guid = pointInfo.neig.guid;
if (ACAPI_Element_Get (&element) == NoError)
good = (needTypeID == element.sectElem.parentID);
}
return good;
} // ClickAnElem
void getRoofs(){
API_Element element;
API_ElementMemo memo;
GSErrCode err;
char buffer[256];
roofrepeated roofMsg;
API_StoryInfo storyInfo;
storyinfo* storyInfoMsg;
pointsmessage* points;
intlistmsg* subpolygons;
err = ACAPI_Environment(APIEnv_GetStorySettingsID, &storyInfo, NULL);
if (err != NoError) {
ErrorBeep("APIEnv_GetStorySettingsID", err);
return;
}
GS::Array<API_Guid> elemList;
ACAPI_Element_GetElemList(API_RoofID, &elemList);
for (GS::Array<API_Guid>::ConstIterator it = elemList.Enumerate(); it != NULL; ++it) {
BNZeroMemory(&element, sizeof(API_Element));
element.header.guid = *it;
err = ACAPI_Element_Get(&element);
if (err == NoError) {
err = ACAPI_Element_GetMemo(element.header.guid, &memo);
if (err == NoError){
points = roofMsg.add_points();
subpolygons = roofMsg.add_subpolygons();
for (int i = 1; i <= element.roof.u.planeRoof.poly.nCoords; i++){
points->add_px((*memo.coords)[i].x);
points->add_py((*memo.coords)[i].y);
points->add_pz((*storyInfo.data)[element.header.floorInd - storyInfo.firstStory].level);
}
for (int i = 1; i <= element.roof.u.planeRoof.poly.nSubPolys; i++){
subpolygons->add_ilist((*memo.pends)[i]);
}
storyInfoMsg = roofMsg.add_bottomlevel();
storyInfoMsg->set_exists(true);
storyInfoMsg->set_index(element.header.floorInd);
storyInfoMsg->set_level((*storyInfo.data)[element.header.floorInd - storyInfo.firstStory].level);
storyInfoMsg->set_name((*storyInfo.data)[element.header.floorInd - storyInfo.firstStory].name);
roofMsg.add_height(element.roof.shellBase.level);
roofMsg.add_thickness(element.slab.thickness);
std::string materialName;
if (element.roof.shellBase.modelElemStructureType == API_BasicStructure){
materialName = searchBuildingMaterialsValue(element.roof.shellBase.buildingMaterial);
roofMsg.add_type("Basic");
}
else{
materialName = searchCompositeMaterialsValue(element.roof.shellBase.composite);
roofMsg.add_type("Composite");
}
if (materialName == "Not Found"){
sprintf(buffer, "Found no material");
ACAPI_WriteReport(buffer, true);
}
else{
roofMsg.add_material(materialName);
}
char s[64];
APIGuid2GSGuid(element.header.guid).ConvertToString(s);
roofMsg.add_guid(s);
}
}
else{
sprintf(buffer, ErrID_To_Name(err));
ACAPI_WriteReport(buffer, true);
}
}
writeDelimitedTo(getClientSocket(), roofMsg);
BMKillHandle(reinterpret_cast<GSHandle *> (&storyInfo.data));
}
bool ElemHead_To_Neig (API_Neig *neig,
const API_Elem_Head *elemHead)
{
BNZeroMemory (neig, sizeof (API_Neig));
API_Elem_Head* elemHeadNonConst = const_cast<API_Elem_Head*>(elemHead);
neig->guid = elemHead->guid;
if (elemHeadNonConst->typeID == API_ZombieElemID && neig->guid != APINULLGuid) {
BNZeroMemory (elemHeadNonConst, sizeof (API_Elem_Head));
elemHeadNonConst->guid = neig->guid;
ACAPI_Element_GetHeader (elemHeadNonConst);
}
switch (elemHeadNonConst->typeID) {
case API_WallID: neig->neigID = APINeig_Wall; neig->inIndex = 1; break;
case API_ColumnID: neig->neigID = APINeig_Colu; neig->inIndex = 0; break;
case API_BeamID: neig->neigID = APINeig_Beam; neig->inIndex = 1; break;
case API_WindowID: neig->neigID = APINeig_WindHole; neig->inIndex = 0; break;
case API_DoorID: neig->neigID = APINeig_DoorHole; neig->inIndex = 0; break;
case API_ObjectID: neig->neigID = APINeig_Symb; neig->inIndex = 1; break;
case API_LampID: neig->neigID = APINeig_Light; neig->inIndex = 1; break;
case API_SlabID: neig->neigID = APINeig_Ceil; neig->inIndex = 1; break;
case API_RoofID: neig->neigID = APINeig_Roof; neig->inIndex = 1; break;
case API_MeshID: neig->neigID = APINeig_Mesh; neig->inIndex = 1; break;
case API_DimensionID: neig->neigID = APINeig_DimOn; neig->inIndex = 1; break;
case API_RadialDimensionID: neig->neigID = APINeig_RadDim; neig->inIndex = 1; break;
case API_LevelDimensionID: neig->neigID = APINeig_LevDim; neig->inIndex = 1; break;
case API_AngleDimensionID: neig->neigID = APINeig_AngDimOn; neig->inIndex = 1; break;
case API_TextID: neig->neigID = APINeig_Word; neig->inIndex = 1; break;
case API_LabelID: neig->neigID = APINeig_Label; neig->inIndex = 1; break;
case API_ZoneID: neig->neigID = APINeig_Room; neig->inIndex = 1; break;
case API_HatchID: neig->neigID = APINeig_Hatch; neig->inIndex = 1; break;
case API_LineID: neig->neigID = APINeig_Line; neig->inIndex = 1; break;
case API_PolyLineID: neig->neigID = APINeig_PolyLine; neig->inIndex = 1; break;
case API_ArcID: neig->neigID = APINeig_Arc; neig->inIndex = 1; break;
case API_CircleID: neig->neigID = APINeig_Circ; neig->inIndex = 1; break;
case API_SplineID: neig->neigID = APINeig_Spline; neig->inIndex = 1; break;
case API_HotspotID: neig->neigID = APINeig_Hot; neig->inIndex = 1; break;
case API_CutPlaneID: neig->neigID = APINeig_CutPlane; neig->inIndex = 1; break;
case API_ElevationID: neig->neigID = APINeig_Elevation; neig->inIndex = 1; break;
case API_InteriorElevationID: neig->neigID = APINeig_InteriorElevation; neig->inIndex = 1; break;
case API_CameraID: neig->neigID = APINeig_Camera; neig->inIndex = 1; break;
case API_CamSetID: return false;
case API_PictureID: neig->neigID = APINeig_PictObj; neig->inIndex = 1; break;
case API_DetailID: neig->neigID = APINeig_Detail; neig->inIndex = 1; break;
case API_WorksheetID: neig->neigID = APINeig_Worksheet; neig->inIndex = 1; break;
case API_SectElemID: neig->neigID = APINeig_VirtSy; neig->inIndex = 1; break;
case API_DrawingID: neig->neigID = APINeig_DrawingCenter; neig->inIndex = 1; break;
case API_CurtainWallID: neig->neigID = APINeig_CurtainWall; neig->inIndex = 1; break;
case API_CurtainWallSegmentID: neig->neigID = APINeig_CWSegment; neig->inIndex = 1; break;
case API_CurtainWallFrameID: neig->neigID = APINeig_CWFrame; neig->inIndex = 1; break;
case API_CurtainWallPanelID: neig->neigID = APINeig_CWPanel; neig->inIndex = 1; break;
case API_CurtainWallJunctionID: neig->neigID = APINeig_CWJunction; neig->inIndex = 1; break;
case API_CurtainWallAccessoryID: neig->neigID = APINeig_CWAccessory; neig->inIndex = 1; break;
case API_ShellID: neig->neigID = APINeig_Shell; neig->inIndex = 1; break;
case API_SkylightID: neig->neigID = APINeig_SkylightHole; neig->inIndex = 0; break;
case API_MorphID: neig->neigID = APINeig_Morph; neig->inIndex = 1; break;
case API_ChangeMarkerID: neig->neigID = APINeig_ChangeMarker; neig->inIndex = 1; break;
case API_GroupID:
case API_HotlinkID:
default:
return false;
}
return true;
} // ElemHead_To_Neig
