AddVertices::AddVertices(MultipointObjectImp* pObject, const vector<LocationType>& oldVertices, const vector<LocationType>& oldGeoVertices, const vector<LocationType>& newVertices, const vector<LocationType>& newGeoVertices) : UndoAction(dynamic_cast<SessionItem*>(pObject)), mOldVertices(oldVertices), mOldGeoVertices(oldGeoVertices), mNewVertices(newVertices), mNewGeoVertices(newGeoVertices) { if (pObject != NULL) { GraphicLayer* pLayer = pObject->getLayer(); if (pLayer != NULL) { View* pView = pLayer->getView(); if (pView != NULL) { mViewId = pView->getId(); } mLayerId = pLayer->getId(); } } setText("Add Vertices"); }
void ScaleBarObjectImp::updateAttachments() { if (mpGeoreference.get() == NULL) { const RasterElement* pGeoreference = getGeoreferenceElement(); if (pGeoreference != NULL) { mpGeoreference.reset(const_cast<RasterElement*>(pGeoreference)); mXgsd = GeoAlgorithms::getXaxisGSD(pGeoreference); mNeedsLayout = true; } } if (mpView.get() == NULL) { GraphicLayer* pLayer = getLayer(); if (pLayer != NULL) { PerspectiveView* pPerspectiveView = dynamic_cast<PerspectiveView*>(pLayer->getView()); if (pPerspectiveView != NULL) { mpView.reset(pPerspectiveView); mNeedsLayout = true; } } } }
void MeasurementObjectImp::updateGeoreferenceAttachment() { if (mpGeoreference.get() != NULL) { return; } RasterElement* pGeoreference = NULL; // Must find Georeference through the view, since the GraphicElement is a root element. GraphicLayer* pLayer = getLayer(); if (pLayer != NULL) { SpatialDataView* pView = dynamic_cast<SpatialDataView*>(pLayer->getView()); if (pView != NULL) { LayerList* pLayerList = pView->getLayerList(); VERIFYNRV(pLayerList != NULL); pGeoreference = pLayerList->getPrimaryRasterElement(); } } if (pGeoreference != NULL && pGeoreference->isGeoreferenced()) { mpGeoreference.reset(pGeoreference); enableGeo(); generateGeoStrings(); } }
void FrameLabelObjectImp::updateAnimationList(bool force) { if (getAutoMode() == false) { return; } const bool wasLocked = getLocked(); if (force == true) { setLocked(false); } if (getLocked() == false) { View* pView = NULL; GraphicLayer* pLayer = getLayer(); if (pLayer != NULL) { pView = pLayer->getView(); } setAnimations(pView); } if (force == true) { setLocked(wasLocked); } }
void linkInputLabels() { GraphicLayer* layer = GraphicLayer::sharedLayer(); CCArray* children = layer->getChildren(); if(children != NULL) { for(int i = 0 ; i < children->count(); i++) { RawObject* child = (RawObject*)children->objectAtIndex(i); //Force actualization of content size and fontSize after everything is loaded because the nodeToWorldTransform is only right after if(isKindOfClass(child, InputLabel)) { InputLabel* input = (InputLabel*)child; child->getNode()->setContentSize(child->getNode()->getContentSize()); if(input->getOriginalInfos() != NULL) { ((ui::EditBox*)child->getNode())->setFontSize(input->getOriginalInfos()->getFontSize()); } } if((isKindOfClass(child, InputLabel)) && child->getEventInfos()->objectForKey("LinkTo") != NULL && isKindOfClass(child->getEventInfos()->objectForKey("LinkTo"), CCString)) { InputLabel* input = (InputLabel*)child; if(input->getLinkTo() == NULL) { CCString* linkTo = (CCString*)child->getEventInfos()->objectForKey("LinkTo"); CCArray* matchs = layer->allObjectsWithName(linkTo); for(long j = 0; j < matchs->count(); j++) { RawObject* match = (RawObject*)matchs->objectAtIndex(j); if(isKindOfClass(match, LabelTTF)) { input->setLinkTo((LabelTTF*)match); j = matchs->count(); } } } } else if((isKindOfClass(child, DropDownList)) && child->getEventInfos()->objectForKey("LinkTo") != NULL && isKindOfClass(child->getEventInfos()->objectForKey("LinkTo"), CCString)) { DropDownList* dropDownList = (DropDownList*)child; if(dropDownList->getLinkTo() == NULL) { CCString* linkTo = (CCString*)child->getEventInfos()->objectForKey("LinkTo"); CCArray* matchs = layer->allObjectsWithName(linkTo); for(long j = 0; j < matchs->count(); j++) { RawObject* match = (RawObject*)matchs->objectAtIndex(j); if(isKindOfClass(match, LabelTTF)) { dropDownList->setLinkTo((LabelTTF*)match); j = matchs->count(); } } } } } } }
void GroupUngroupGraphicObjects::group() { GraphicLayer* pLayer = dynamic_cast<GraphicLayer*>(getSessionItem()); if (pLayer != NULL) { list<GraphicObject*> selectedObjects; pLayer->getSelectedObjects(selectedObjects); pLayer->deselectAllObjects(); for (list<string>::const_iterator iter = mObjectIds.begin(); iter != mObjectIds.end(); ++iter) { string objectId = *iter; if (objectId.empty() == false) { string viewId; View* pView = pLayer->getView(); if (pView != NULL) { viewId = pView->getId(); } GraphicObject* pObject = GraphicUndoUtilities::getObject(viewId, pLayer->getId(), objectId); if (pObject != NULL) { pLayer->selectObject(pObject); } } } pLayer->groupSelection(); list<GraphicObject*> newSelectedObjects; pLayer->getSelectedObjects(newSelectedObjects); VERIFYNRV(newSelectedObjects.size() == 1); GraphicGroup* pGroup = dynamic_cast<GraphicGroup*>(newSelectedObjects.front()); VERIFYNRV(pGroup != NULL); for (list<GraphicObject*>::iterator iter = selectedObjects.begin(); iter != selectedObjects.end(); ++iter) { GraphicObject* pObject = *iter; if ((pObject != NULL) && (pGroup->hasObject(pObject) == false)) { pLayer->selectObject(pObject); } } string oldGroupId = mGroupId; mGroupId = pGroup->getId(); emit sessionItemChanged(oldGroupId, mGroupId); } }
void reorderZindex() { GraphicLayer* layer = GraphicLayer::sharedLayer(); CCArray* children = layer->getChildren(); if(children != NULL) { for(int i = 0 ; i < children->count(); i++) { RawObject* child = (RawObject*)children->objectAtIndex(i); if(child->getZOrder() != 0) { layer->reorderChild(child, child->getZOrder()); } } } }
void GraphicLayerMemento::toLayer(Layer* pLayer) const { GraphicLayer* pGraphicLayer = dynamic_cast<GraphicLayer*>(pLayer); if (pGraphicLayer != NULL) { GraphicElement* pElement = dynamic_cast<GraphicElement*>(pGraphicLayer->getDataElement()); if (pElement != NULL) { GraphicGroupImp* pGroup = dynamic_cast<GraphicGroupImp*>(pElement->getGroup()); if (pGroup != NULL) { pGroup->setLayer(pGraphicLayer); } } } }
void GroupUngroupGraphicObjects::ungroup() { GraphicLayer* pLayer = dynamic_cast<GraphicLayer*>(getSessionItem()); if ((pLayer != NULL) && (mGroupId.empty() == false)) { string viewId; View* pView = pLayer->getView(); if (pView != NULL) { viewId = pView->getId(); } GraphicGroup* pGroup = dynamic_cast<GraphicGroup*>(GraphicUndoUtilities::getObject(viewId, pLayer->getId(), mGroupId)); if (pGroup != NULL) { list<GraphicObject*> selectedObjects; pLayer->getSelectedObjects(selectedObjects); pLayer->deselectAllObjects(); pLayer->selectObject(pGroup); pLayer->ungroupSelection(); list<GraphicObject*> objects; pLayer->getSelectedObjects(objects); mObjectIds.clear(); for (list<GraphicObject*>::iterator iter = objects.begin(); iter != objects.end(); ++iter) { GraphicObject* pObject = *iter; if (pObject != NULL) { string objectId = pObject->getId(); if (objectId.empty() == false) { mObjectIds.push_back(objectId); } } } for (list<GraphicObject*>::iterator iter = selectedObjects.begin(); iter != selectedObjects.end(); ++iter) { GraphicObject* pObject = *iter; if ((pObject != NULL) && (pObject != pGroup)) { pLayer->selectObject(pObject); } } } } }
QFont TextObjectImp::getScaledFont(double minSize, double maxSize) { QFont scaledFont = getFont(); GraphicLayer* pLayer = getLayer(); if (pLayer != NULL) { // Scale the point size double pointSize = scaledFont.pointSizeF(); PerspectiveView* pPerspectiveView = dynamic_cast<PerspectiveView*>(pLayer->getView()); if (pPerspectiveView != NULL) { // Zoom percentage double zoomPercent = pPerspectiveView->getZoomPercentage(); pointSize *= zoomPercent / 100.0; // Product DPI ProductView* pProductView = dynamic_cast<ProductView*>(pPerspectiveView); if (pProductView != NULL) { int dpi = pProductView->getDpi(); pointSize *= dpi / 72.0; } } // Restrict to the minimum size if (minSize > 0.0) { pointSize = max(pointSize, minSize); } // Restrict to the maximum size if (maxSize > 0.0) { pointSize = min(pointSize, maxSize); } // Set the scaled point size in the font scaledFont.setPointSizeF(pointSize); } return scaledFont; }
NewPath::NewPath(PolylineObjectImp* pObject, unsigned int path) : UndoAction(dynamic_cast<SessionItem*>(pObject)), mPath(path) { if (pObject != NULL) { GraphicLayer* pLayer = pObject->getLayer(); if (pLayer != NULL) { View* pView = pLayer->getView(); if (pView != NULL) { mViewId = pView->getId(); } mLayerId = pLayer->getId(); } } setText("New Path"); }
void Scene::onTouchMoved(Touch *touch, Event *pEvent) { //CCLOG("onTouchMoved started..."); if(linker->linkedObjectOf(touch) != NULL && isKindOfClass(linker->linkedObjectOf(touch), const Image)) { Image* toggle = (Image*)linker->linkedObjectOf(touch); GraphicLayer* layer = GraphicLayer::sharedLayer(); char *end = strrchr(toggle->getImageFile().c_str(), '-'); if(end && strcmp(end, "-on") == 0 && !layer->allObjectsAtPosition(Scene::touchPosition(touch))->containsObject(toggle)) { this->switchButton(toggle, false); } } for(GenericRecognizer* receiver : touchReceiversList) { receiver->onTouchMoved(touch, pEvent); } //CCLOG("onTouchMoved ended"); }
SetGraphicObjectName::SetGraphicObjectName(GraphicObject *pObject, const string &oldName, const string &newName) : UndoAction(pObject), mOldName(oldName), mNewName(newName) { GraphicObjectImp* pObjectImp = dynamic_cast<GraphicObjectImp*>(pObject); if (pObjectImp != NULL) { GraphicLayer* pLayer = pObjectImp->getLayer(); if (pLayer != NULL) { View* pView = pLayer->getView(); if (pView != NULL) { mViewId = pView->getId(); } mLayerId = pLayer->getId(); } } setText("Rename Graphic Object"); }
SetGraphicObjectProperty::SetGraphicObjectProperty(GraphicObject* pObject, const GraphicProperty* pOldProperty, const GraphicProperty* pNewProperty) : UndoAction(pObject), mpOldProperty(NULL), mpNewProperty(NULL) { GraphicObjectImp* pObjectImp = dynamic_cast<GraphicObjectImp*>(pObject); if (pObjectImp != NULL) { GraphicLayer* pLayer = pObjectImp->getLayer(); if (pLayer != NULL) { View* pView = pLayer->getView(); if (pView != NULL) { mViewId = pView->getId(); } mLayerId = pLayer->getId(); } } QString actionText = "Set Object Property"; if ((pOldProperty != NULL) && (pNewProperty != NULL)) { string oldName = pOldProperty->getName(); string newName = pNewProperty->getName(); if (oldName == newName) { actionText = "Set Object " + QString::fromStdString(oldName); mpOldProperty = pOldProperty->copy(); mpNewProperty = pNewProperty->copy(); } } setText(actionText); }
void TextObjectImp::updateBoundingBox() { // Get the width and height of the bounding box in screen pixels based on the scaled text image size int iWidth = 0; int iHeight = 0; string text = getSubstitutedText(); if (text.empty() == false) { QString strMessage = QString::fromStdString(text); QFont scaledFont = getScaledFont(); int iMaxSize = 0; glGetIntegerv(GL_MAX_TEXTURE_SIZE, &iMaxSize); int iAlignment = getTextAlignment(); QFontMetrics ftMetrics(scaledFont); QRect boundingBox = ftMetrics.boundingRect(0, 0, iMaxSize, iMaxSize, iAlignment | Qt::TextWordWrap, strMessage); iWidth = boundingBox.width(); iHeight = boundingBox.height(); } // Get the current bounding box LocationType llCorner = getLlCorner(); LocationType urCorner = getUrCorner(); // Use the lower left corner as the anchor and compute the data coordinate of the upper right corner GraphicLayer* pLayer = getLayer(); if (pLayer != NULL) { // Compute the upper right coordinate PerspectiveView* pView = dynamic_cast<PerspectiveView*>(pLayer->getView()); if (pView != NULL) { double zoomFactor = 100.0 / pView->getZoomPercentage(); double xScale = zoomFactor / pLayer->getXScaleFactor(); double yScale = zoomFactor / pLayer->getYScaleFactor(); urCorner.mX = llCorner.mX + (iWidth * xScale); urCorner.mY = llCorner.mY + (iHeight * yScale); } if (dynamic_cast<OrthographicView*>(pLayer->getView()) != NULL) { double dScreenX = 0.0; double dScreenY = 0.0; pLayer->translateDataToScreen(llCorner.mX, llCorner.mY, dScreenX, dScreenY); pLayer->translateScreenToData(dScreenX + iWidth, dScreenY + iHeight, urCorner.mX, urCorner.mY); } } else { urCorner.mX = llCorner.mX + iWidth; urCorner.mY = llCorner.mY + iHeight; } // Update the bounding box and selection handles setBoundingBox(llCorner, urCorner); updateHandles(); mUpdateBoundingBox = false; }
bool ChangeUpDirection::execute(PlugInArgList* pInArgList, PlugInArgList* pOutArgList) { if (pInArgList == NULL || pOutArgList == NULL) { return false; } ProgressTracker progress(pInArgList->getPlugInArgValue<Progress>(Executable::ProgressArg()), "Rotating data.", "app", "{11adadb9-c133-49de-8cf5-a16372da2578}"); RasterElement* pData = pInArgList->getPlugInArgValue<RasterElement>(Executable::DataElementArg()); if (pData == NULL) { progress.report("No data element specified.", 0, ERRORS, true); return false; } bool display = false; if (!pInArgList->getPlugInArgValue("Display Results", display)) { progress.report("Unsure if results should be displayed. Invalid argument.", 0, ERRORS, true); return false; } double rotation = 0.0; SpatialDataView* pOrigView = NULL; if (isBatch()) { if (!pInArgList->getPlugInArgValue("Rotation", rotation)) { progress.report("No rotation specified.", 0, ERRORS, true); return false; } } else { pOrigView = pInArgList->getPlugInArgValue<SpatialDataView>(Executable::ViewArg()); if (pOrigView == NULL) { progress.report("No view specified.", 0, ERRORS, true); return false; } GraphicLayer* pLayer = dynamic_cast<GraphicLayer*>(pOrigView->getActiveLayer()); if (pLayer == NULL) { pLayer = dynamic_cast<GraphicLayer*>(pOrigView->getTopMostLayer(ANNOTATION)); } GraphicObject* pArrow = NULL; if (pLayer != NULL) { std::list<GraphicObject*> objects; pLayer->getObjects(ARROW_OBJECT, objects); if (!objects.empty()) { pArrow = objects.back(); } if (objects.size() > 1) { progress.report("Multiple arrow objects found. Using the most recently added one.", 0, WARNING, true); } } if (pArrow == NULL) { progress.report("Unable to locate up direction. Add an arrow annotation and re-run this plugin.", 0, ERRORS, true); return false; } LocationType ur = pArrow->getUrCorner(); LocationType ll = pArrow->getLlCorner(); double xlen = ur.mX - ll.mX; double ylen = ur.mY - ll.mY; // Initial rotatation value. The 90 degrees is due to the difference // in the "0 point" (right vs. up). Also account for explicit rotation // of the annotation object. Convert this to radians. rotation = GeoConversions::convertDegToRad(90 + pArrow->getRotation()); // Determine a rotation adjustment based on the bounding box rotation += atan2(ylen, xlen); } progress.report("Rotating data.", 10, NORMAL); ModelResource<RasterElement> pRotated(pData->copyShallow(pData->getName() + "_rotated", pData->getParent())); if (pRotated.get() == NULL) { progress.report("Unable to create destination raster element.", 0, ERRORS, true); return false; } int defaultBadValue(0); // the rotate method will handle setting the default bad values into the rotated raster if (!RasterUtilities::rotate(pRotated.get(), pData, rotation, defaultBadValue, INTERP_NEAREST_NEIGHBOR, progress.getCurrentProgress(), &mAbort)) { // error message already reported by rotate() return false; } pOutArgList->setPlugInArgValue("Rotated Element", pRotated.get()); if (display) { SpatialDataWindow* pWindow = static_cast<SpatialDataWindow*>( Service<DesktopServices>()->createWindow(pRotated->getName(), SPATIAL_DATA_WINDOW)); SpatialDataView* pView = (pWindow == NULL) ? NULL : pWindow->getSpatialDataView(); if (pView == NULL) { Service<DesktopServices>()->deleteWindow(pWindow); progress.report("Unable to create view.", 0, ERRORS, true); return false; } pView->setPrimaryRasterElement(pRotated.get()); RasterLayer* pLayer = NULL; { // scope UndoLock lock(pView); pLayer = static_cast<RasterLayer*>(pView->createLayer(RASTER, pRotated.get())); } if (pLayer == NULL) { //#pragma message(__FILE__ "(" STRING(__LINE__) ") : warning : This would be cleaner with a WindowResource. If one " \ // "becomes available, use it instead. (tclarke)") Service<DesktopServices>()->deleteWindow(pWindow); progress.report("Unable to create layer.", 0, ERRORS, true); return false; } pOutArgList->setPlugInArgValue("View", pView); } pRotated.release(); progress.report("Rotation complete.", 100, NORMAL); progress.upALevel(); return true; }
string MeasurementObjectImp::generateGeoStrings() const { LocationType llCorner = getLlCorner(); LocationType urCorner = getUrCorner(); LocationType llCornerLatLon; LocationType urCornerLatLon; bool unitsValid = false; // Get lat lon coordinates and terrain raster const RasterElement* pTerrain = NULL; bool geoValid(false); if (mpGeoreference.get() != NULL) { GraphicLayer* pLayer = getLayer(); if (pLayer != NULL) { SpatialDataView* pView = dynamic_cast<SpatialDataView*>(pLayer->getView()); if (pView != NULL) { LayerList* pLayerList = pView->getLayerList(); VERIFYRV(pLayerList != NULL, ""); VERIFYRV(pLayerList->getPrimaryRasterElement() == mpGeoreference.get(), ""); pTerrain = mpGeoreference->getTerrain(); Layer* pPrimaryRasterLayer = pLayerList->getLayer(RASTER, mpGeoreference.get()); if (pPrimaryRasterLayer != NULL) { pPrimaryRasterLayer->translateWorldToData(llCorner.mX, llCorner.mY, llCorner.mX, llCorner.mY); pPrimaryRasterLayer->translateWorldToData(urCorner.mX, urCorner.mY, urCorner.mX, urCorner.mY); } } } if (mpGeoreference->isGeoreferenced()) { bool llValid(false); bool urValid(false); llCornerLatLon = mpGeoreference->convertPixelToGeocoord(llCorner, false, &llValid); urCornerLatLon = mpGeoreference->convertPixelToGeocoord(urCorner, false, &urValid); geoValid = llValid && urValid; } } mUsingInaccurateGeocoords = !geoValid; unitsValid = geoValid; //String Variables string startLoc = ""; string endLoc = ""; string distance = ""; string bearing = ""; string distanceUnit = ""; GeoAlgorithms algs; double distanceVal = 0; double azimuthVal = 0; // Create GeoPoint objects LatLonPoint startLlPoint = llCornerLatLon; LatLonPoint endLlPoint = urCornerLatLon; UtmPoint startUtmPoint = startLlPoint; UtmPoint endUtmPoint = endLlPoint; MgrsPoint startMgrsPoint = startLlPoint; MgrsPoint endMgrsPoint = endLlPoint; // find elevations double elevation1(0.0); double elevation2(0.0); if (pTerrain != NULL) { const RasterDataDescriptor* pDescriptor = dynamic_cast<const RasterDataDescriptor*>(pTerrain->getDataDescriptor()); if (pDescriptor != NULL) { const vector<DimensionDescriptor>& activeRows = pDescriptor->getRows(); const vector<DimensionDescriptor>& activeColumns = pDescriptor->getColumns(); if ( llCorner.mY >= 0 && llCorner.mY < activeRows.size() && llCorner.mX >= 0 && llCorner.mX < activeColumns.size() && urCorner.mY >= 0 && urCorner.mY < activeRows.size() && urCorner.mX >= 0 && urCorner.mX < activeColumns.size() ) { DimensionDescriptor llRowDim(activeRows[llCorner.mY]); DimensionDescriptor llColumnDim(activeColumns[llCorner.mX]); DimensionDescriptor urRowDim(activeRows[urCorner.mY]); DimensionDescriptor urColumnDim(activeColumns[urCorner.mX]); elevation1 = pTerrain->getPixelValue(llColumnDim, llRowDim, DimensionDescriptor(), COMPLEX_MAGNITUDE); elevation2 = pTerrain->getPixelValue(urColumnDim, urRowDim, DimensionDescriptor(), COMPLEX_MAGNITUDE); const Units* pElevationUnits = pDescriptor->getUnits(); if (pElevationUnits != NULL) { double scale = pElevationUnits->getScaleFromStandard(); elevation1 *= scale; elevation2 *= scale; } } } } if (unitsValid == true) { // Calculate bearing and distance distanceVal = algs.getPythagoreanOrVincentyDistance(startLlPoint.getLatitude().getValue(), startLlPoint.getLongitude().getValue(), endLlPoint.getLatitude().getValue(), endLlPoint.getLongitude().getValue(), elevation1, elevation2); azimuthVal = algs.getVincentyAzimuth(startLlPoint.getLatitude().getValue(), startLlPoint.getLongitude().getValue(), endLlPoint.getLatitude().getValue(), endLlPoint.getLongitude().getValue()); azimuthVal = GeoConversions::convertRadToDeg(azimuthVal); // Set distance text if (mDrawnDistanceUnit == KILOMETER) { distanceUnit = "km"; distanceVal = distanceVal/1000; } else if (mDrawnDistanceUnit == MILE) { distanceUnit = "mi"; distanceVal = GeoConversions::convertMetersToMiles(distanceVal); } else if (mDrawnDistanceUnit == NAUTICAL_MILE) { distanceUnit = "Nm"; distanceVal = GeoConversions::convertMetersToNm(distanceVal); } else if (mDrawnDistanceUnit == METER) { distanceUnit = "m"; } else if (mDrawnDistanceUnit == YARD) { distanceUnit = "yd"; distanceVal = GeoConversions::convertMetersToFeet(distanceVal)/3; } else if (mDrawnDistanceUnit == FOOT) { distanceUnit = "ft"; distanceVal = GeoConversions::convertMetersToFeet(distanceVal); } // set location text switch (mDrawnGeocoord) { case GEOCOORD_LATLON: startLoc = startLlPoint.getText(mDrawnDmsFormat, mEndPointsPrecision); endLoc = endLlPoint.getText(mDrawnDmsFormat, mEndPointsPrecision); break; case GEOCOORD_UTM: startLoc = startUtmPoint.getText(); endLoc = endUtmPoint.getText(); break; case GEOCOORD_MGRS: startLoc = startMgrsPoint.getText(); endLoc = endMgrsPoint.getText(); break; default: startLoc = "(" + QString::number(llCorner.mX, 'f', mEndPointsPrecision).toStdString() + ", " + QString::number(llCorner.mY, 'f', mEndPointsPrecision).toStdString() + ")"; endLoc = "(" + QString::number(urCorner.mX, 'f', mEndPointsPrecision).toStdString() + ", " + QString::number(urCorner.mY, 'f', mEndPointsPrecision).toStdString() + ")"; break; } } else { startLoc = "(" + QString::number(llCorner.mX, 'f', mEndPointsPrecision).toStdString() + ", " + QString::number(llCorner.mY, 'f', mEndPointsPrecision).toStdString() + ")"; endLoc = "(" + QString::number(urCorner.mX, 'f', mEndPointsPrecision).toStdString() + ", " + QString::number(urCorner.mY, 'f', mEndPointsPrecision).toStdString() + ")"; azimuthVal = algs.getPythagoreanAzimuth(llCorner.mX, llCorner.mY, urCorner.mX, urCorner.mY); azimuthVal = GeoConversions::convertRadToDeg(azimuthVal); distanceVal = algs.getPythagoreanDistance(urCorner.mX, urCorner.mY, llCorner.mX, llCorner.mY); distanceUnit = "pix"; } bearing = QString::number(azimuthVal, 'f', mBearingPrecision).toStdString(); distance = QString::number(distanceVal, 'f', mDistancePrecision).toStdString(); QString bearingText = QString::fromStdString(bearing) + " deg"; QString distanceText = QString::fromStdString(distance) + " " + QString::fromStdString(distanceUnit); QString startLocText = QString::fromStdString(startLoc); QString endLocText = QString::fromStdString(endLoc); // Final strings if (bearingText != mBearingText) { mBearingText = bearingText; mBearingTextTexture.invalidate(); } if (distanceText != mDistanceText) { mDistanceText = distanceText; mDistanceTextTexture.invalidate(); } if (startLocText != mStartLocText) { mStartLocText = startLocText; mStartLocTextTexture.invalidate(); } if (endLocText != mEndLocText) { mEndLocText = endLocText; mEndLocTextTexture.invalidate(); } string rtnVal = "DISTANCE: " + distanceText.toStdString() + " : LOCATION: " + startLoc + " to " + endLoc + " at " + bearingText.toStdString(); return rtnVal; }
bool ArcObjectImp::hit(LocationType pixelCoord) const { int iStart = static_cast<int>(getStartAngle()); if (iStart < 0) { iStart--; } int iStop = static_cast<int>(getStopAngle()); if (iStop < 0) { iStop--; } if (iStart == iStop) { iStart = 0; iStop = 360; } ArcRegion eArcRegion = getArcRegion(); DrawUtil::initializeCircle(); LocationType center = getCenter(); bool bHit = false; // Filled area FillStyle eFillStyle = getFillStyle(); if (eFillStyle != EMPTY_FILL) { int iSize = abs(iStop - iStart) + 1; if (eArcRegion == ARC_CENTER) { iSize += 2; } else if (eArcRegion == ARC_CHORD) { iSize += 1; } double* pXVertices = new double[iSize]; double* pYVertices = new double[iSize]; int i = 0; int iIndex = 0; for (i = iStart, iIndex = 0; i <= iStop; i++, iIndex++) { LocationType arcPoint = getLocation(static_cast<double>(i)); pXVertices[iIndex] = arcPoint.mX; pYVertices[iIndex] = arcPoint.mY; } if ((eArcRegion == ARC_CENTER) || (eArcRegion == ARC_CHORD)) { if (eArcRegion == ARC_CENTER) { pXVertices[iSize - 2] = center.mX; pYVertices[iSize - 2] = center.mY; } pXVertices[iSize - 1] = pXVertices[0]; pYVertices[iSize - 1] = pYVertices[0]; } bHit = DrawUtil::isWithin(pixelCoord.mX, pixelCoord.mY, pXVertices, pYVertices, iSize); delete [] pXVertices; delete [] pYVertices; } // Line if (bHit == false) { bool bLine = false; bLine = getLineState(); if (bLine == true) { // Check the arc line double size = 1.0; GraphicLayer* pLayer = NULL; pLayer = getLayer(); if (pLayer != NULL) { View* pView = pLayer->getView(); if (pView != NULL) { size = pView->getPixelSize(center, center); } size *= min(pLayer->getXScaleFactor(), pLayer->getYScaleFactor()); } LocationType basePoint; for (int i = iStart; i <= iStop; i++) { LocationType currentPoint = getLocation(static_cast<double>(i)); if (i != iStart) { bHit = DrawUtil::lineHit(currentPoint, basePoint, pixelCoord, 2.0/size); if (bHit == true) { break; } } basePoint.mX = currentPoint.mX; basePoint.mY = currentPoint.mY; } // Check the arc region lines if (bHit == false) { LocationType startPoint = getLocation(static_cast<double>(iStart)); LocationType stopPoint = getLocation(static_cast<double>(iStop)); if (eArcRegion == ARC_CENTER) { bHit = DrawUtil::lineHit(startPoint, center, pixelCoord, 2.0/size); if (bHit == false) { bHit = DrawUtil::lineHit(stopPoint, center, pixelCoord, 2.0/size); } } else if (eArcRegion == ARC_CHORD) { bHit = DrawUtil::lineHit(startPoint, stopPoint, pixelCoord, 2.0/size); } } } } return bHit; }
void loadNodeToFenneX(Node* baseNode, Panel* parent) { GraphicLayer* layer = GraphicLayer::sharedLayer(); if(parent == NULL) { layer->useBaseLayer((Layer*)baseNode); #if VERBOSE_LOAD_CCB CCLOG("replaced base layer by CCB node : position : %f, %f, scale : %f", baseNode->getPosition().x, baseNode->getPosition().y, baseNode->getScale()); #endif } //Use an index because InputLabel modify the array, so you need to rewind a bit at some point for(int i = 0; i < baseNode->getChildren().size(); i++) { Node* node = baseNode->getChildren().at(i); #if VERBOSE_LOAD_CCB CCLOG("doing child %d from parent %s ...", i, parent != NULL ? parent->getName() != "" ? parent->getName().c_str() : "Panel" : "base layer"); #endif RawObject* result = NULL; if(isKindOfClass(node, Label)) { Label* label = (Label*)node; #if VERBOSE_LOAD_CCB CCLOG("label, font : %s", label->getSystemFontName().c_str()); #endif CCString* translationKey = isKindOfClass(label, CustomBaseNode) ? (CCString*)dynamic_cast<CustomBaseNode*>(label)->getParameters()->objectForKey("translationKey") : NULL; const std::string translated = Localization::getLocalizedString(translationKey != NULL ? translationKey->getCString() : label->getString()); if(translationKey == NULL || translationKey->compare(translated.c_str()) != 0) { //Don't replace the string if it's the same, as it may only be a key, not a real label label->setString(translated); } result = layer->createLabelTTFromLabel(label, parent); } else if(isKindOfClass(node, CustomDropDownList)) { #if VERBOSE_LOAD_CCB CCLOG("DropDownList"); #endif Sprite* sprite = (Sprite*)node; result = layer->createDropDownListFromSprite(sprite, parent); } else if(isKindOfClass(node, Sprite)) { #if VERBOSE_LOAD_CCB CCLOG("image"); #endif Sprite* sprite = (Sprite*)node; result = layer->createImageFromSprite(sprite, parent); } else if(isKindOfClass(node, CustomInput)) { #if VERBOSE_LOAD_CCB CCLOG("input label"); #endif ui::Scale9Sprite* sprite = (ui::Scale9Sprite*)node; CCString* translationKey = isKindOfClass(sprite, CustomBaseNode) ? (CCString*)dynamic_cast<CustomBaseNode*>(sprite)->getParameters()->objectForKey("translationKey") : NULL; std::string placeHolder = isKindOfClass(sprite, CustomInput) ? ((CustomInput*) sprite)->getPlaceHolder()->getCString() : ""; result = layer->createInputLabelFromScale9Sprite(sprite, parent); const std::string text = Localization::getLocalizedString(translationKey != NULL ? translationKey->getCString() : placeHolder.c_str()); if(translationKey == NULL || translationKey->compare(text.c_str()) != 0) { ((InputLabel*) result)->setInitialText(text); } i--; } else if(isKindOfClass(node, ui::Scale9Sprite)) { #if VERBOSE_LOAD_CCB CCLOG("scale sprite"); #endif ui::Scale9Sprite* sprite = (ui::Scale9Sprite*)node; result = layer->createCustomObjectFromNode(sprite, parent); } else if(!isKindOfClass(node, ui::EditBox)) { #if VERBOSE_LOAD_CCB CCLOG("Edit Box"); #endif result = layer->createPanelFromNode(node, parent); } #if VERBOSE_LOAD_CCB if(result != NULL) { CCLOG("Child %d loaded : position : %f, %f, scale : %f", i, result->getPosition().x, result->getPosition().y, result->getScale()); } else { CCLOG("Problem loading child %d !", i); } #endif } }
void TextObjectImp::draw(double zoomFactor) const { RectangleObjectImp::draw(zoomFactor); if (QGLContext::currentContext() != mpDrawContext || mUpdateTexture == true) { (const_cast<TextObjectImp*> (this))->updateTexture(); } if (mpDrawContext == NULL) { return; } LocationType llCorner = getLlCorner(); LocationType urCorner = getUrCorner(); glEnable(GL_TEXTURE_2D); // switch to using this tile's texture GLuint textureId = mTextureResource; if (mpDrawContext == mTempTextureResource.getContext()) { textureId = mTempTextureResource; } glBindTexture(GL_TEXTURE_2D, textureId); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); double maxS = mDataWidth / static_cast<double>(mTextureWidth); double maxT = mDataHeight / static_cast<double>(mTextureHeight); ColorType color = getTextColor(); glBegin(GL_QUADS); glColor4ub(color.mRed, color.mGreen, color.mBlue, 255); // Determine if the bounding box is flipped based on its screen locations bool bHorizontalFlip = false; bool bVerticalFlip = false; GraphicLayer* pLayer = getLayer(); if (pLayer != NULL) { pLayer->isFlipped(llCorner, urCorner, bHorizontalFlip, bVerticalFlip); // Account for the difference between screen origin (upper left) and OpenGL origin (lower left) bVerticalFlip = !bVerticalFlip; } // Draw the text left to right and right side up if ((bHorizontalFlip == false) && (bVerticalFlip == false)) { glTexCoord2f(0.0, 0.0); glVertex3f(llCorner.mX, llCorner.mY, 0.0); glTexCoord2f(maxS, 0.0); glVertex3f(urCorner.mX, llCorner.mY, 0.0); glTexCoord2f(maxS, maxT); glVertex3f(urCorner.mX, urCorner.mY, 0.0); glTexCoord2f(0.0, maxT); glVertex3f(llCorner.mX, urCorner.mY, 0.0); } else if ((bHorizontalFlip == true) && (bVerticalFlip == false)) { glTexCoord2f(maxS, 0.0); glVertex3f(llCorner.mX, llCorner.mY, 0.0); glTexCoord2f(0.0, 0.0); glVertex3f(urCorner.mX, llCorner.mY, 0.0); glTexCoord2f(0.0, maxT); glVertex3f(urCorner.mX, urCorner.mY, 0.0); glTexCoord2f(maxS, maxT); glVertex3f(llCorner.mX, urCorner.mY, 0.0); } else if ((bHorizontalFlip == true) && (bVerticalFlip == true)) { glTexCoord2f(maxS, maxT); glVertex3f(llCorner.mX, llCorner.mY, 0.0); glTexCoord2f(0.0, maxT); glVertex3f(urCorner.mX, llCorner.mY, 0.0); glTexCoord2f(0.0, 0.0); glVertex3f(urCorner.mX, urCorner.mY, 0.0); glTexCoord2f(maxS, 0.0); glVertex3f(llCorner.mX, urCorner.mY, 0.0); } else if ((bHorizontalFlip == false) && (bVerticalFlip == true)) { glTexCoord2f(0.0, maxT); glVertex3f(llCorner.mX, llCorner.mY, 0.0); glTexCoord2f(maxS, maxT); glVertex3f(urCorner.mX, llCorner.mY, 0.0); glTexCoord2f(maxS, 0.0); glVertex3f(urCorner.mX, urCorner.mY, 0.0); glTexCoord2f(0.0, 0.0); glVertex3f(llCorner.mX, urCorner.mY, 0.0); } glEnd(); glDisable(GL_BLEND); glDisable(GL_ALPHA_TEST); glDisable(GL_TEXTURE_2D); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); // mTempTextureResource is allocated by the updateTexture method when the gl context has changed // Free the texture here; more importantly set mpDrawContext to mTextureResource so that the next // draw operation completes successfully without the need to recreate the texture. if (mTempTextureResource.get() != NULL) { TextObjectImp* pNonConst = const_cast<TextObjectImp*>(this); pNonConst->mTempTextureResource = GlTextureResource(0); pNonConst->mpDrawContext = mTextureResource.getContext(); } }
bool EllipseObjectImp::hit(LocationType pixelCoord) const { LocationType llCorner = getLlCorner(); LocationType urCorner = getUrCorner(); double xVertices[DrawUtil::VERTEX_COUNT + 1]; double yVertices[DrawUtil::VERTEX_COUNT + 1]; DrawUtil::initializeCircle(); LocationType center; center.mX = (llCorner.mX + urCorner.mX) / 2.0; center.mY = (llCorner.mY + urCorner.mY) / 2.0; LocationType radii; radii.mX = fabs (llCorner.mX - urCorner.mX) / 2.0; radii.mY = fabs (llCorner.mY - urCorner.mY) / 2.0; int i = 0; for (i = 0; i < DrawUtil::VERTEX_COUNT; i++) { xVertices[i] = center.mX + radii.mX * DrawUtil::sCirclePoints[i].mX; yVertices[i] = center.mY + radii.mY * DrawUtil::sCirclePoints[i].mY; } xVertices[DrawUtil::VERTEX_COUNT] = xVertices[0]; yVertices[DrawUtil::VERTEX_COUNT] = yVertices[0]; bool bHit = false; // Filled area FillStyle eFillStyle = getFillStyle(); if (eFillStyle != EMPTY_FILL) { bHit = DrawUtil::isWithin(pixelCoord.mX, pixelCoord.mY, xVertices, yVertices, DrawUtil::VERTEX_COUNT+1); } // Line if (bHit == false) { bool bLine = false; bLine = getLineState(); if (bLine == true) { double size = 1.0; GraphicLayer* pLayer = NULL; pLayer = getLayer(); if (pLayer != NULL) { View* pView = pLayer->getView(); if (pView != NULL) { size = pView->getPixelSize(llCorner, urCorner); } size *= min(pLayer->getXScaleFactor(), pLayer->getYScaleFactor()); } LocationType basePoint; for (i = 0; i < DrawUtil::VERTEX_COUNT; i++) { LocationType currentPoint(xVertices[i], yVertices[i]); if (i != 0) { bHit = DrawUtil::lineHit(currentPoint, basePoint, pixelCoord, 2.0/size); if (bHit == true) { break; } } basePoint = currentPoint; } } } return bHit; }
void EastArrowObjectImp::orient() { if (isOriented() == true) { return; } GraphicLayer* pLayer = NULL; pLayer = getLayer(); if (pLayer == NULL) { return; } View* pView = NULL; pView = pLayer->getView(); if (pView == NULL) { return; } SpatialDataView* pSpatialDataView = NULL; if (pView->isKindOf("SpatialDataView") == true) { pSpatialDataView = static_cast<SpatialDataView*> (pView); } else if (pView->isKindOf("ProductView") == true) { ProductView* pProductView = static_cast<ProductView*> (pView); GraphicLayer* pLayoutLayer = NULL; pLayoutLayer = pProductView->getLayoutLayer(); if (pLayoutLayer == pLayer) { list<GraphicObject*> viewObjects; pLayoutLayer->getObjects(VIEW_OBJECT, viewObjects); list<GraphicObject*>::iterator iter = viewObjects.begin(); while (iter != viewObjects.end()) { GraphicObject* pObject = *iter; if (pObject != NULL) { View* pObjectView = pObject->getObjectView(); if (pObjectView != NULL) { if (pObjectView->isKindOf("SpatialDataView") == true) { pSpatialDataView = static_cast<SpatialDataView*> (pObjectView); } } } ++iter; } } } if (pSpatialDataView == NULL) { return; } LayerList* pLayerList = pSpatialDataView->getLayerList(); VERIFYNRV(pLayerList != NULL); RasterElement* pRaster = pLayerList->getPrimaryRasterElement(); VERIFYNRV(pRaster != NULL); if (!pRaster->isGeoreferenced()) { return; } // Calculate the angle of the object relative to the pixel coordinates updateHandles(); LocationType pixelStart = mHandles[7]; ProductView* pProductView = dynamic_cast<ProductView*> (pView); if (pProductView != NULL) { // Convert to the screen coordinate system double dScreenX = 0; double dScreenY = 0; pLayer->translateDataToWorld(pixelStart.mX, pixelStart.mY, pixelStart.mX, pixelStart.mY); pProductView->translateWorldToScreen(pixelStart.mX, pixelStart.mY, dScreenX, dScreenY); // Convert to the spatial data view coordinate system pSpatialDataView->translateScreenToWorld(dScreenX, dScreenY, pixelStart.mX, pixelStart.mY); pLayer->translateWorldToData(pixelStart.mX, pixelStart.mY, pixelStart.mX, pixelStart.mY); } double dAngle; if (GeoAlgorithms::getAngleToNorth(pRaster, dAngle, pixelStart) == false) { return; } // Update the angle if the object is in the layout layer if (pProductView != NULL) { // Rotation dAngle -= pSpatialDataView->getRotation(); // Pitch double dPitch = pSpatialDataView->getPitch(); if (dPitch > 0.0) { dAngle *= -1.0; } } // Rotate the object setRotation(dAngle); // Update the orientation flag DirectionalArrowObjectImp::orient(); }
void ScaleBarObjectImp::updateLayout() { if (mNeedsLayout == false) { return; } LocationType llCorner = getLlCorner(); LocationType urCorner = getUrCorner(); bool bHorizontalFlip = false; bool bVerticalFlip = false; GraphicLayer* pLayer = getLayer(); if (pLayer != NULL) { pLayer->isFlipped(llCorner, urCorner, bHorizontalFlip, bVerticalFlip); } if (bHorizontalFlip == true) { double temp = llCorner.mX; llCorner.mX = urCorner.mX; urCorner.mX = temp; } if (bVerticalFlip == true) { double temp = llCorner.mY; llCorner.mY = urCorner.mY; urCorner.mY = temp; } double barHeight = urCorner.mY - llCorner.mY; double spacingScale = 1.0; string unitsText = "pix"; double unitScale = 1.0; //mXgsd is calculated in meters if (mpGeoreference.get() != NULL) { if (getUnitSystem() == UNIT_KFT) { unitsText = "ft"; } else if (getUnitSystem() == UNIT_KM) { unitsText = "m"; } else if (getUnitSystem() == UNIT_MI) { unitsText = "mi"; } // if the scalebar is an object in the layout layer, we need to scale the // scalebar length to scene pixels from page coordinates if (getUnitSystem() == UNIT_KFT) { unitScale = GeoConversions::convertMetersToFeet(1); } else if (getUnitSystem() == UNIT_MI) { unitScale = GeoConversions::convertMetersToMiles(1); } } else { mXgsd = 1.0; } double deltaX = urCorner.mX - llCorner.mX; double lengthBar = fabs(deltaX * mXgsd * unitScale); double totalLengthPixels = fabs(deltaX); double ticksize = 0.0; //ticksize in pixels double ticksizeDistance = pow(10.0, floor(log10(lengthBar / 5.0))); //ticksize in specific units (feet or meters) if (ticksizeDistance * 5.0 * 5.0 > lengthBar) { if (ticksizeDistance * 2.0 * 5.0 > lengthBar) { // times 1.0; } else { ticksizeDistance *= 2.0; } } else { ticksizeDistance *= 5.0; } if (mpGeoreference.get() == NULL || getUnitSystem() == UNIT_KM || getUnitSystem() == UNIT_KFT) { if (ticksizeDistance >= (1000 / 5.0)) // 5 ticks >= 1000 base units (either meters or feet) { spacingScale /= 1000.0; //meters to kilometers, feet to kilofeet unitsText = "k" + unitsText; } } else if (getUnitSystem() == UNIT_MI) { if (ticksizeDistance < (0.25 / 5.0)) //5 ticks is less than 1/4 mile, convert to feet. { spacingScale = GeoConversions::convertMilesToFeet(spacingScale); unitsText = "ft"; } } // need to divide ticksize by gsd here if (lengthBar != 0.0) { ticksize = DrawUtil::sign(deltaX) * ticksizeDistance * totalLengthPixels / lengthBar; // ticksize in pixels } ostringstream center; center << (ticksizeDistance * 5.0) * spacingScale << unitsText; TextStringProperty centerText(center.str()); ostringstream right; right << lengthBar * spacingScale << unitsText; string newRightVal = right.str(); TextStringProperty rightText(right.str()); TextStringProperty leftText("0" + unitsText); double width = 0.0; double height = 0.0; int i = 0; list<GraphicObject*> objects = mpGroup->getObjects(); list<GraphicObject*>::iterator it = objects.begin(); for (i = 0; it != objects.end(); ++it, ++i) { GraphicObjectImp* pObj = dynamic_cast<GraphicObjectImp*>(*it); TextObjectImp* pText = NULL; if (pObj == NULL) { continue; } LocationType llObjCorner = pObj->getLlCorner(); LocationType urObjCorner = pObj->getUrCorner(); switch (i) { case 0: // big, stretchy rectangle llObjCorner.mX = llCorner.mX; urObjCorner.mX = urCorner.mX; llObjCorner.mY = llCorner.mY + barHeight * (1.0-BOX_HEIGHT); urObjCorner.mY = llObjCorner.mY + barHeight * BOX_HEIGHT; pObj->setBoundingBox(llObjCorner, urObjCorner); pObj->updateHandles(); break; case 1: case 2: case 3: case 4: case 5: // 5 rectangles llObjCorner.mX = ((i-1) * ticksize) + llCorner.mX; urObjCorner.mX = (i * ticksize) + llCorner.mX; llObjCorner.mY = llCorner.mY + barHeight * (1.0-BOX_HEIGHT); urObjCorner.mY = llObjCorner.mY + barHeight * BOX_HEIGHT; pObj->setBoundingBox(llObjCorner, urObjCorner); pObj->updateHandles(); break; case 6: //center line llObjCorner.mX = (5.0 * ticksize) + llCorner.mX; urObjCorner.mX = llObjCorner.mX; llObjCorner.mY = llCorner.mY + barHeight * (1.0-BOX_HEIGHT - CENTER_LINE_HEIGHT); urObjCorner.mY = llObjCorner.mY + barHeight * CENTER_LINE_HEIGHT; pObj->setBoundingBox(llObjCorner, urObjCorner); pObj->updateHandles(); break; case 7: // left line llObjCorner.mX = llCorner.mX; urObjCorner.mX = llCorner.mX; llObjCorner.mY = llCorner.mY + barHeight * TEXT_HEIGHT; urObjCorner.mY = llObjCorner.mY + barHeight * LINE_HEIGHT; pObj->setBoundingBox(llObjCorner, urObjCorner); pObj->updateHandles(); break; case 8: //right line llObjCorner.mX = urCorner.mX; urObjCorner.mX = llObjCorner.mX; llObjCorner.mY = llCorner.mY + barHeight * TEXT_HEIGHT; urObjCorner.mY = llObjCorner.mY + barHeight * LINE_HEIGHT; pObj->setBoundingBox(llObjCorner, urObjCorner); pObj->updateHandles(); break; case 9: { //left text pText = dynamic_cast<TextObjectImp*>(pObj); VERIFYNRV(pText != NULL); if (pObj->getText() != leftText.getString()) { pText->setProperty(&leftText); pText->updateTexture(); } else { pText->updateBoundingBox(); } LocationType textLlCorner = pText->getLlCorner(); LocationType textUrCorner = pText->getUrCorner(); width = textUrCorner.mX - textLlCorner.mX; height = textUrCorner.mY - textLlCorner.mY; llObjCorner.mX = llCorner.mX; llObjCorner.mY = llCorner.mY; if (height != 0.0) { urObjCorner.mX = llObjCorner.mX + width * barHeight * TEXT_HEIGHT / height; } else { urObjCorner.mX = llObjCorner.mX + width; } urObjCorner.mY = llObjCorner.mY + barHeight * TEXT_HEIGHT; pObj->setBoundingBox(llObjCorner, urObjCorner); break; } case 10: { //center text pText = dynamic_cast<TextObjectImp*>(pObj); VERIFYNRV(pText != NULL); if (pObj->getText() != centerText.getString()) { pText->setProperty(¢erText); pText->updateTexture(); } else { pText->updateBoundingBox(); } LocationType textLlCorner = pText->getLlCorner(); LocationType textUrCorner = pText->getUrCorner(); width = textUrCorner.mX - textLlCorner.mX; height = textUrCorner.mY - textLlCorner.mY; if (height != 0.0) { llObjCorner.mX = llCorner.mX + (5.0 * ticksize) - (width / 2.0) * barHeight * TEXT_HEIGHT / height; urObjCorner.mX = llObjCorner.mX + width * barHeight * TEXT_HEIGHT / height; } else { llObjCorner.mX = llCorner.mX + (5.0 * ticksize); urObjCorner.mX = llObjCorner.mX + width; } llObjCorner.mY = llCorner.mY + (1.0-BOX_HEIGHT-TEXT_HEIGHT-CENTER_LINE_HEIGHT)*barHeight; urObjCorner.mY = llObjCorner.mY + barHeight*TEXT_HEIGHT; pObj->setBoundingBox(llObjCorner, urObjCorner); break; } case 11: { //right text pText = dynamic_cast<TextObjectImp*>(pObj); VERIFYNRV(pText != NULL); if (pObj->getText() != rightText.getString()) { pText->setProperty(&rightText); pText->updateTexture(); } else { pText->updateBoundingBox(); } LocationType textLlCorner = pText->getLlCorner(); LocationType textUrCorner = pText->getUrCorner(); width = textUrCorner.mX - textLlCorner.mX; height = textUrCorner.mY - textLlCorner.mY; if (height != 0.0) { llObjCorner.mX = urCorner.mX - width * barHeight * TEXT_HEIGHT / height; urObjCorner.mX = llObjCorner.mX + width * barHeight * TEXT_HEIGHT / height; } else { llObjCorner.mX = urCorner.mX; urObjCorner.mX = llObjCorner.mX + width; } llObjCorner.mY = llCorner.mY; urObjCorner.mY = llObjCorner.mY + barHeight*TEXT_HEIGHT; pObj->setBoundingBox(llObjCorner, urObjCorner); break; } default: break; } } mpGroup->updateBoundingBox(); mNeedsLayout = false; }