// -----------------------------------------------------------------------------
// 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 */
API_ElemTypeID Neig_To_ElemID (API_NeigID neigID)
{
API_ElemTypeID typeID;
GSErrCode err;
err = ACAPI_Goodies (APIAny_NeigIDToElemTypeID, &neigID, &typeID);
if (err != NoError)
typeID = API_ZombieElemID;
return typeID;
} // Neig_To_ElemID
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
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);
}
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);
}
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
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
