// ----------------------------------------------------------------------------- // 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