Size ParagraphShadowNode::measure(LayoutConstraints layoutConstraints) const {
return textLayoutManager_->measure(
getTag(),
getAttributedString(),
getProps()->paragraphAttributes,
layoutConstraints);
}
AttributedString ParagraphShadowNode::getAttributedString() const {
if (!cachedAttributedString_.has_value()) {
cachedAttributedString_ =
BaseTextShadowNode::getAttributedString(getProps()->textAttributes, getChildren());
}
return cachedAttributedString_.value();
}
// *********************************************************************************************************
void CDisplayerVisual::updateLocalPos()
{
//H_AUTO(R2_CDisplayerVisual_updateLocalPos)
if (getProps().findAttr("Position"))
{
_Pos = getVector(getObject(&getProps(), "Position"));
static volatile bool wantAssert = true;
if (!isValidDouble(_Pos.x) || !isValidDouble(_Pos.y) ||!isValidDouble(_Pos.z))
{
// nlassert(!wantAssert);
BOMB_IF(wantAssert,"'wantAssert' was triggered",_Pos.set(0, 0, 0));
}
}
else
{
_Pos.set(0, 0, 0);
}
}
bool FileLoader::getProps(const NODE node, PropStream& props)
{
size_t size;
if (const uint8_t* a = getProps(node, size)) {
props.init(reinterpret_cast<const char*>(a), size); // does not break strict aliasing
return true;
}
props.init(nullptr, 0);
return false;
}
AttributedString ParagraphShadowNode::getAttributedString() const {
if (!cachedAttributedString_.has_value()) {
auto textAttributes = TextAttributes::defaultTextAttributes();
textAttributes.apply(getProps()->textAttributes);
cachedAttributedString_ = BaseTextShadowNode::getAttributedString(
textAttributes, shared_from_this());
}
return cachedAttributedString_.value();
}
bool FileLoader::getProps(const NODE node, PropStream& props)
{
size_t size;
if (const uint8_t* a = getProps(node, size)) {
props.init((char*)a, size);
return true;
}
props.init(nullptr, 0);
return false;
}
bool FileLoader::getProps(const NODE node, PropStream &props)
{
unsigned long size;
const unsigned char* a = getProps(node, size);
if(!a){
props.init(NULL, 0);
return false;
}
else{
props.init((char*)a, size);
return true;
}
}
AttributedString BaseTextShadowNode::getAttributedString(
const TextAttributes &textAttributes,
const SharedShadowNode &parentNode) const {
auto attributedString = AttributedString{};
for (const auto &childNode : parentNode->getChildren()) {
// RawShadowNode
auto rawTextShadowNode =
std::dynamic_pointer_cast<const RawTextShadowNode>(childNode);
if (rawTextShadowNode) {
auto fragment = AttributedString::Fragment{};
fragment.string = rawTextShadowNode->getProps()->text;
fragment.textAttributes = textAttributes;
fragment.parentShadowNode = parentNode;
attributedString.appendFragment(fragment);
continue;
}
// TextShadowNode
auto textShadowNode =
std::dynamic_pointer_cast<const TextShadowNode>(childNode);
if (textShadowNode) {
auto localTextAttributes = textAttributes;
localTextAttributes.apply(textShadowNode->getProps()->textAttributes);
attributedString.appendAttributedString(
textShadowNode->getAttributedString(
localTextAttributes, textShadowNode));
continue;
}
// Any other kind of ShadowNode
auto fragment = AttributedString::Fragment{};
fragment.shadowNode = childNode;
fragment.textAttributes = textAttributes;
attributedString.appendFragment(fragment);
}
return attributedString;
}
int main(int argc, char *argv[])
{
if (argc!=2) {
usage();
return EXIT_FAILURE;
} else if (strcmp(argv[1],"-v")==0) {
std::cout << "ghsom: Version " << VERSION << std::endl;
} else {
getProps(argv[1]);
startIt();
}
return EXIT_SUCCESS;
}
void IAdaptor::getAllSubProps(vtkPropCollection* propc, int depth)
{
vtkProp* prop;
m_propCollection->InitTraversal();
while ( (prop = m_propCollection->GetNextProp()) )
{
getProps(propc, prop);
}
if(depth != 0)
{
auto subServices = this->getRegisteredServices();
for( const auto& service : subServices)
{
auto adaptor = ::fwRenderVTK::IAdaptor::dynamicCast(service.lock());
if(adaptor)
{
adaptor->getAllSubProps( propc, depth - 1 );
}
}
}
}
ImageSource ImageShadowNode::getImageSource() const {
auto sources = getProps()->sources;
if (sources.size() == 0) {
return {
/* .type = */ ImageSource::Type::Invalid,
};
}
if (sources.size() == 1) {
return sources[0];
}
auto layoutMetrics = getLayoutMetrics();
auto size = layoutMetrics.getContentFrame().size;
auto scale = layoutMetrics.pointScaleFactor;
auto targetImageArea = size.width * size.height * scale * scale;
auto bestFit = kFloatMax;
auto bestSource = ImageSource{};
for (const auto &source : sources) {
auto sourceSize = source.size;
auto sourceScale = source.scale == 0 ? scale : source.scale;
auto sourceArea =
sourceSize.width * sourceSize.height * sourceScale * sourceScale;
auto fit = std::abs(1 - (sourceArea / targetImageArea));
if (fit < bestFit) {
bestFit = fit;
bestSource = source;
}
}
return bestSource;
}
//*********************************************************************************************************
void CDisplayerVisualActivitySequence::onPostRender()
{
//H_AUTO(R2_CDisplayerVisualActivitySequence_onPostRender)
CDisplayerVisual *entityDV = getParentDV();
CDisplayerVisual *groupDV = getPossibleGroupDV(entityDV);
if (!isVisible(groupDV, entityDV))
{
removeFromWorldMap();
return;
}
//
TSequenceState state = Hidden;
// if this activity sequence is not the selected one in its parent then it is hidden
updateState(state, groupDV);
// if current selection is a son of the group...
static std::vector<CDisplayerVisual *> groupSons;
groupDV->getSons(groupSons);
for(uint k = 0; k < groupSons.size(); ++k)
{
nlassert(groupSons[k]);
updateState(state, groupSons[k]);
}
// if one of the route is selected or highlighted
CObjectTable *activities = getProps().toTable("Components");
if (!activities)
{
removeFromWorldMap();
return;
}
// get first world object parent to get start position
for(uint k = 0; k < activities->getSize(); ++k)
{
// search next zone of activity
CObjectTable *activity = activities->getValue(k)->toTable();
if (!activity) continue;
std::string zoneId = getString(activity, "ActivityZoneId");
if (zoneId.empty()) continue;
std::string activityStr = getString(activity, "Activity");
if (activityStr == "Stand Still" || activityStr == "Inactive") continue;
CInstance *zone = getEditor().getInstanceFromId(zoneId);
if (!zone) continue;
CDisplayerVisual *dv = zone->getDisplayerVisual();
if (!dv) continue;
updateState(state, dv);
static std::vector<CDisplayerVisual *> vertices;
dv->getSons(vertices);
for (uint l = 0; l < vertices.size(); ++l)
{
nlassert(vertices[l]);
updateState(state, vertices[l]);
}
}
//
if (state != Hidden && entityDV)
{
// see if this sequence is the selected one
sint index = entityDV->getDisplayedInstance()->getSelectedSequence();
CObject *sequences = getProps().getParent(); // see what is my index in the sequences list of my parent
if (sequences)
{
clamp(index, (sint) 0, (sint) sequences->getSize() - 1);
if (index != sequences->findIndex(&getProps()))
{
state = Hidden; // not the current selected sequence
}
}
}
//
_DecalColor = CV_FootStepDecalSelectedColor.get();
CRGBA mapColor = CV_FootStepMapSelectedColor.get();
switch(state)
{
case Hidden:
_DecalColor = CV_FootStepDecalHiddenColor.get();
mapColor = CV_FootStepMapHiddenColor.get();
break;
case HasFocus:
_DecalColor = CV_FootStepDecalFocusedColor.get();
mapColor = CV_FootStepMapFocusedColor.get();
break;
}
for(uint k = 0; k < _WPCache.size(); ++k)
{
if (_WPCache[k].DV)
{
if (_WPCache[k].DV->getWorldPos2f() != _WPCache[k].WorldPos2f)
{
touch();
break;
}
}
}
update();
if (_AddedToWorldMap)
{
setWorldMapColor(mapColor);
}
}
void IAdaptor::registerProp(vtkProp* prop)
{
getProps(m_propCollection, prop);
}
//*********************************************************************************************************
void CDisplayerVisualActivitySequence::update()
{
//H_AUTO(R2_CDisplayerVisualActivitySequence_update)
if (!_Active) return;
if (!_Touched) return;
_Touched = false;
CObjectTable *activities = getProps().toTable("Components");
if (!activities)
{
clear();
return;
}
// get first world object parent to get start position
nlassert(getDisplayedInstance());
CInstance *prevZone = NULL;
CDisplayerVisual *prevDV = getParentDV();
if (!prevDV)
{
clear();
return;
}
//
clear(false);
//
for(uint k = 0; k < activities->getSize(); ++k)
{
// search next zone of activity
CObjectTable *activity = activities->getValue(k)->toTable();
if (!activity) continue;
std::string activityStr = getString(activity, "Activity");
if (activityStr == "Stand Still" || activityStr == "Inactive") continue;
//
CInstance *nextZone = NULL;
std::string zoneId = getString(activity, "ActivityZoneId");
//
if (!zoneId.empty())
{
_ObserverHandles.push_back(getEditor().addInstanceObserver(zoneId, this));
nextZone = getEditor().getInstanceFromId(zoneId);
}
if (!nextZone) break;
CDisplayerVisual *nextDV = nextZone->getDisplayerVisual();
if (!nextDV) break;
_TraversedPrimInfos.push_back(CTraversedPrimInfo());
_TraversedPrimInfos.back().PrimDisplay = nextDV;
_TraversedPrimInfos.back().Visible = nextDV->getActualDisplayMode() != DisplayModeHidden;
CWorldPosCache wpc;
wpc.DV = nextDV;
wpc.WorldPos2f = nextDV->getWorldPos2f();
_WPCache.push_back(wpc);
if (nextDV->getActualDisplayMode() != DisplayModeHidden
&& prevDV->getActualDisplayMode() != DisplayModeHidden)
{
// special case for regions
if (nextZone->isKindOf("Region"))
{
// first case : previous zone is not a region
if (!prevZone || !prevZone->isKindOf("Region"))
{
// search shortest distance bewteen last pos and the region
CVector entryPos;
if (nextDV->evalEnterPoint(prevDV->evalExitPoint(), entryPos))
{
addFootSteps(CLine(prevDV->evalExitPoint(), entryPos));
}
else
{
addWanderSteps(prevDV->evalExitPoint());
}
}
else
{
// region-region footsteps
// just use the couple of vertices for which the distance is the smallest
static std::vector<CVector2f> r0;
static std::vector<CVector2f> r1;
prevDV->getSonsWorldPos2f(r0);
nextDV->getSonsWorldPos2f(r1);
if (!r0.empty() && !r1.empty())
{
CVector2f p0, p1;
float bestDist = FLT_MAX;
for(uint k = 0; k < r0.size(); ++k)
{
for(uint l = 0; l < r0.size(); ++l)
{
float dist = (r0[k] - r1[l]).norm();
if (dist <bestDist)
{
bestDist = dist;
p0 = r0[k];
p1 = r1[l];
}
}
}
nlassert(bestDist != FLT_MAX);
addFootSteps(CLine(p0.asVector(), p1.asVector()));
}
}
}
else
{
// special case if prev zone is a region
if (prevZone && prevZone->isKindOf("Region"))
{
// search shortest distance bewteen last pos and the region
CVector entryPos;
if (prevDV->evalEnterPoint(nextDV->evalLinkPoint(), entryPos))
{
addFootSteps(CLine(entryPos, nextDV->evalLinkPoint()));
}
else
{
addWanderSteps(nextDV->evalLinkPoint());
}
}
else
{
// simple footsteps between last & new pos
addFootSteps(CLine(prevDV->evalExitPoint(), nextDV->evalLinkPoint()));
}
}
}
prevDV = nextDV;
prevZone = nextZone;
}
//
CGroupMap *gm = CTool::getWorldMap();
if (!_AddedToWorldMap && gm)
{
gm->addDeco(this);
}
if (_AddedToWorldMap)
{
setWorldMapNumEdges((uint)_FootSteps.size());
nlassert(gm);
onUpdate(*gm);
}
}
int
main (int ac, char *av[])
{
FILE *fp;
/* save our name for usage() */
me = av[0];
/* crack args */
while (--ac && **++av == '-') {
char *s = *av;
while (*++s) {
switch (*s) {
case 'b': /* beep when true */
bflag++;
break;
case 'd':
if (ac < 2) {
fprintf (stderr, "-d requires open fileno\n");
usage();
}
directfd = atoi(*++av);
ac--;
break;
case 'e': /* print each updated expression value */
eflag++;
break;
case 'f': /* print final expression value */
fflag++;
break;
case 'h':
if (directfd >= 0) {
fprintf (stderr, "Can not combine -d and -h\n");
usage();
}
if (ac < 2) {
fprintf (stderr, "-h requires host name\n");
usage();
}
host = *++av;
ac--;
break;
case 'i': /* read expression from stdin */
iflag++;
break;
case 'o': /* print operands as they change */
oflag++;
break;
case 'p':
if (directfd >= 0) {
fprintf (stderr, "Can not combine -d and -p\n");
usage();
}
if (ac < 2) {
fprintf (stderr, "-p requires tcp port number\n");
usage();
}
port = atoi(*++av);
ac--;
break;
case 't':
if (ac < 2) {
fprintf (stderr, "-t requires timeout\n");
usage();
}
timeout = atoi(*++av);
ac--;
break;
case 'v': /* verbose */
verbose++;
break;
case 'w': /* wait for expression to be true */
wflag++;
break;
default:
fprintf (stderr, "Unknown flag: %c\n", *s);
usage();
}
}
}
/* now there are ac args starting with av[0] */
/* compile expression from av[0] or stdin */
if (ac == 0)
compile (NULL);
else if (ac == 1)
compile (av[0]);
else
usage();
/* open connection */
if (directfd >= 0) {
fp = fdopen (directfd, "r+");
setbuf (fp, NULL); /* don't absorb next guy's stuff */
if (!fp) {
fprintf (stderr, "Direct fd %d: %s\n",directfd,strerror(errno));
exit(1);
}
if (verbose)
fprintf (stderr, "Using direct fd %d\n", directfd);
} else {
fp = openINDIServer();
if (verbose)
fprintf (stderr, "Connected to %s on port %d\n", host, port);
}
/* build a parser context for cracking XML responses */
lillp = newLilXML();
/* set up to catch an io timeout function */
signal (SIGALRM, onAlarm);
/* send getProperties */
getProps(fp);
/* initialize all properties */
initProps(fp);
/* evaluate expression, return depending on flags */
return (runEval(fp));
}
// *********************************************************************************************************
bool CDisplayerVisual::inheritPos() const
{
//H_AUTO(R2_CDisplayerVisual_inheritPos)
return getNumber(&getProps(), "InheritPos") != 0;
}
static void U_CALLCONV
numericLineFn(void *context,
char *fields[][2], int32_t fieldCount,
UErrorCode *pErrorCode) {
Props newProps={ 0 };
char *s, *numberLimit;
uint32_t start, end, value, oldProps32;
char c;
UBool isFraction;
/* get the code point range */
u_parseCodePointRange(fields[0][0], &start, &end, pErrorCode);
if(U_FAILURE(*pErrorCode)) {
fprintf(stderr, "genprops: syntax error in DerivedNumericValues.txt field 0 at %s\n", fields[0][0]);
exit(*pErrorCode);
}
/*
* Ignore the
* # @missing: 0000..10FFFF; NaN
* line from Unicode 5.1's DerivedNumericValues.txt:
* The following code cannot parse "NaN", and we don't want to overwrite
* the numeric values for all characters after reading most
* from UnicodeData.txt already.
*/
if(start==0 && end==0x10ffff) {
return;
}
/* check if the numeric value is a fraction (this code does not handle any) */
isFraction=FALSE;
s=uprv_strchr(fields[1][0], '.');
if(s!=NULL) {
numberLimit=s+1;
while('0'<=(c=*numberLimit++) && c<='9') {
if(c!='0') {
isFraction=TRUE;
break;
}
}
}
if(isFraction) {
value=0;
} else {
/* parse numeric value */
s=(char *)u_skipWhitespace(fields[1][0]);
/* try large, single-significant-digit numbers, may otherwise overflow strtoul() */
if('1'<=s[0] && s[0]<='9' && s[1]=='0' && s[2]=='0') {
/* large integers are encoded in a special way, see store.c */
uint8_t exp=0;
value=s[0]-'0';
numberLimit=s;
while(*(++numberLimit)=='0') {
++exp;
}
newProps.exponent=exp;
} else {
/* normal number parsing */
value=(uint32_t)uprv_strtoul(s, &numberLimit, 10);
}
if(numberLimit<=s || (*numberLimit!='.' && u_skipWhitespace(numberLimit)!=fields[1][1]) || value>=0x80000000) {
fprintf(stderr, "genprops: syntax error in DerivedNumericValues.txt field 1 at %s\n", fields[0][0]);
exit(U_PARSE_ERROR);
}
}
/*
* Unicode 4.0.1 removes the third column that used to list the numeric type.
* Assume that either the data is the same as in UnicodeData.txt,
* or else that the numeric type is "numeric".
* This should work because we only expect to add numeric values for
* Han characters; for those, UnicodeData.txt lists only ranges without
* specific properties for single characters.
*/
/* set the new numeric value */
newProps.code=start;
newProps.numericValue=(int32_t)value; /* newly parsed numeric value */
/* the exponent may have been set above */
for(; start<=end; ++start) {
uint32_t newProps32;
int32_t oldNtv;
oldProps32=getProps(start);
oldNtv=(int32_t)GET_NUMERIC_TYPE_VALUE(oldProps32);
if(isFraction) {
if(UPROPS_NTV_FRACTION_START<=oldNtv && oldNtv<UPROPS_NTV_LARGE_START) {
/* this code point was already listed with its numeric value in UnicodeData.txt */
continue;
} else {
fprintf(stderr, "genprops: not prepared for new fractions in DerivedNumericValues.txt field 1 at %s\n", fields[1][0]);
exit(U_PARSE_ERROR);
}
}
/*
* For simplicity, and because we only expect to set numeric values for Han characters,
* for now we only allow to set these values for Lo characters.
*/
if(oldNtv==UPROPS_NTV_NONE && GET_CATEGORY(oldProps32)!=U_OTHER_LETTER) {
fprintf(stderr, "genprops error: new numeric value for a character other than Lo in DerivedNumericValues.txt at %s\n", fields[0][0]);
exit(U_PARSE_ERROR);
}
/* verify that we do not change an existing value (fractions were excluded above) */
if(oldNtv!=UPROPS_NTV_NONE) {
/* the code point already has a value stored */
newProps.numericType=UPROPS_NTV_GET_TYPE(oldNtv);
newProps32=makeProps(&newProps);
if(oldNtv!=GET_NUMERIC_TYPE_VALUE(newProps32)) {
fprintf(stderr, "genprops error: new numeric value differs from old one for U+%04lx\n", (long)start);
exit(U_PARSE_ERROR);
}
/* same value, continue */
} else {
/* the code point is getting a new numeric value */
newProps.numericType=(uint8_t)U_NT_NUMERIC; /* assumed numeric type, see Unicode 4.0.1 comment */
newProps32=makeProps(&newProps);
if(beVerbose) {
printf("adding U+%04x numeric type %d encoded-numeric-type-value 0x%03x from %s\n",
(int)start, U_NT_NUMERIC, (int)GET_NUMERIC_TYPE_VALUE(newProps32), fields[0][0]);
}
addProps(start, newProps32|GET_CATEGORY(oldProps32));
}
}
}
