std::string ToolchainItem::colorStr(std::string const& _var) const
{
if (!library()) return std::string();
if (!valid())
{
std::string _path(std::string("invalid_") + _var);
if (!pathExists(_path))
{
return (_var != "light") ? "#e74c3c" : "#6b2018";
} else
{
return library()->config().get<std::string>(tbd::ConfigPath("colorset") / tbd::ConfigPath(_path));
}
}
auto& _cfg = library()->config();
tbd::ConfigPath _toolsetId(elementId().toolset().str());
tbd::ConfigPath _typeId(elementId().typeId().str());
tbd::ConfigPath _path = _toolsetId / _typeId / tbd::ConfigPath(_var);
std::cout << _path.dump() << std::endl;
if (pathExists(_path.dump()))
{
return _cfg.get<std::string>(ConfigPath("colorset") /_path);
}
_path = _toolsetId / tbd::ConfigPath(_var);
if (pathExists(_path.dump()))
{
return _cfg.get<std::string>(ConfigPath("colorset") /_path);
}
return (_var != "light") ? "#405959" : "#9ed8db";
}
void GraphicsSvgItem::paint(QPainter *painter, const QStyleOptionGraphicsItem */*option*/, QWidget */*widget*/)
{
if(!renderer()->isValid())
return;
QRectF rect=boundingRect();
rect.setSize(QSizeF(GraphicsDomain::IconSize,GraphicsDomain::IconSize));
if (elementId().isEmpty())
renderer()->render(painter, rect);
else
renderer()->render(painter, elementId(), rect);
}
static JSValueRef elementDoesAutoCompleteForElementWithIdCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
{
LayoutTestController* controller = reinterpret_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));
JSRetainPtr<JSStringRef> elementId(Adopt, JSValueToStringCopy(context, arguments[0], exception));
ASSERT(!*exception);
bool autoCompletes = controller->elementDoesAutoCompleteForElementWithId(elementId.get());
return JSValueMakeBoolean(context, autoCompletes);
}
bool ToDraw::contains(const QPointF &point) const
{
bool result = QGraphicsSvgItem::contains(point);
if (result)
{
QRectF bounds = transform().mapRect(unclippedRect());
const QImage &img = toImage(elementId(), qRound(bounds.width()), qRound(bounds.height()), renderer());
QPointF transformedPoint = transform().map(point);
result = qAlpha(img.pixel(transformedPoint.toPoint())) != 0;
}
return result;
}
inline void element(base::Element const* _element)
{
if (element_)
{
if (element_->elementId() != elementId())
{
element_ = nullptr;
return;
}
}
element_ = _element;
}
static JSValueRef pauseTransitionAtTimeOnElementWithIdCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
{
if (argumentCount != 3)
return JSValueMakeUndefined(context);
JSRetainPtr<JSStringRef> propertyName(Adopt, JSValueToStringCopy(context, arguments[0], exception));
ASSERT(!*exception);
double time = JSValueToNumber(context, arguments[1], exception);
ASSERT(!*exception);
JSRetainPtr<JSStringRef> elementId(Adopt, JSValueToStringCopy(context, arguments[2], exception));
ASSERT(!*exception);
LayoutTestController* controller = reinterpret_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));
return JSValueMakeBoolean(context, controller->pauseTransitionAtTimeOnElementWithId(propertyName.get(), time, elementId.get()));
}
//-----------------------------------------------------------------------------
// RCmDestinationExt::ElementId()
//-----------------------------------------------------------------------------
//
EXPORT_C TUint32 RCmDestinationExt::ElementId()
{
OstTraceFunctionEntry0( RCMDESTINATIONEXT_ELEMENTID_ENTRY );
__ASSERT_ALWAYS( iCmDestinationWrapper && iCmDestinationWrapper->SessionConnected(),
User::Panic( KCmmPanicCategoryApi, EDestNotConnectedToServer ) );
TUint32 elementId( 0 );
TInt err = iCmDestinationWrapper->GetElementId( elementId );
if ( err )
{
elementId = 0;
}
OstTraceFunctionExit0( RCMDESTINATIONEXT_ELEMENTID_EXIT );
return elementId;
}
int QGraphicsSvgItem::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QGraphicsObject::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: d_func()->_q_repaintItem(); break;
default: ;
}
_id -= 1;
}
#ifndef QT_NO_PROPERTIES
else if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast< QString*>(_v) = elementId(); break;
case 1: *reinterpret_cast< QSize*>(_v) = maximumCacheSize(); break;
}
_id -= 2;
} else if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: setElementId(*reinterpret_cast< QString*>(_v)); break;
case 1: setMaximumCacheSize(*reinterpret_cast< QSize*>(_v)); break;
}
_id -= 2;
} else if (_c == QMetaObject::ResetProperty) {
_id -= 2;
} else if (_c == QMetaObject::QueryPropertyDesignable) {
_id -= 2;
} else if (_c == QMetaObject::QueryPropertyScriptable) {
_id -= 2;
} else if (_c == QMetaObject::QueryPropertyStored) {
_id -= 2;
} else if (_c == QMetaObject::QueryPropertyEditable) {
_id -= 2;
} else if (_c == QMetaObject::QueryPropertyUser) {
_id -= 2;
}
#endif // QT_NO_PROPERTIES
return _id;
}
QString KBBThemeManager::value(const KBBScalableGraphicWidget::itemType itemType, const QString &styleElement)
{
const QString id = elementId(itemType);
QString style;
QString v;
QDomNode node = m_root.firstChild();
while(!node.isNull()) {
if (node.toElement().attribute(QLatin1Literal("id")) == id)
style = node.toElement().attribute(QLatin1Literal("style"));
node = node.nextSibling();
}
QStringList styleList = style.split(QLatin1Char(';'));
for (int i = 0; i < styleList.size(); i++) {
styleList.replace(i, styleList.at(i).trimmed());
if (styleList.at(i).startsWith(styleElement + QLatin1Char(':'))) {
QString s = styleList.at(i);
v = s.right(s.length()-styleElement.length()-1);
}
}
return v;
}
RcppExport SEXP xbrlProcessFacts(SEXP epaDoc) {
xmlDocPtr doc = (xmlDocPtr) R_ExternalPtrAddr(epaDoc);
xmlXPathContextPtr context = xmlXPathNewContext(doc);
xmlXPathObjectPtr fact_res = xmlXPathEvalExpression((xmlChar*) "//*[@*[local-name()='contextRef']]", context);
xmlNodeSetPtr fact_nodeset = fact_res->nodesetval;
xmlXPathFreeContext(context);
int fact_nodeset_ln = fact_nodeset->nodeNr;
CharacterVector elementId(fact_nodeset_ln);
CharacterVector contextId(fact_nodeset_ln);
CharacterVector unitId(fact_nodeset_ln);
CharacterVector fact(fact_nodeset_ln);
CharacterVector decimals(fact_nodeset_ln);
CharacterVector sign(fact_nodeset_ln);
CharacterVector scale(fact_nodeset_ln);
CharacterVector tupleRef(fact_nodeset_ln);
CharacterVector order(fact_nodeset_ln);
CharacterVector factId(fact_nodeset_ln);
CharacterVector ns(fact_nodeset_ln);
for (int i=0; i < fact_nodeset_ln; i++) {
xmlNodePtr fact_node = fact_nodeset->nodeTab[i];
if (fact_node->ns->prefix)
elementId[i] = (char *) ((string) (char *) fact_node->ns->prefix + "_" + (string) (char *) fact_node->name).data();
else
elementId[i] = (char *) fact_node->name;
xmlChar *tmp_str;
if ((tmp_str = xmlGetProp(fact_node, (xmlChar*) "contextRef"))) {
contextId[i] = (char *) tmp_str;
xmlFree(tmp_str);
} else {
contextId[i] = NA_STRING;
}
if ((tmp_str = xmlGetProp(fact_node, (xmlChar*) "unitRef"))) {
unitId[i] = (char *) tmp_str;
xmlFree(tmp_str);
} else {
unitId[i] = NA_STRING;
}
if ((tmp_str = xmlNodeListGetString(doc, fact_node->xmlChildrenNode, 1))) {
fact[i] = (char *) tmp_str;
xmlFree(tmp_str);
} else {
fact[i] = NA_STRING;
}
if ((tmp_str = xmlGetProp(fact_node, (xmlChar*) "decimals"))) {
decimals[i] = (char *) tmp_str;
xmlFree(tmp_str);
} else {
decimals[i] = NA_STRING;
}
if ((tmp_str = xmlGetProp(fact_node, (xmlChar*) "scale"))) {
scale[i] = (char *) tmp_str;
xmlFree(tmp_str);
} else {
scale[i] = NA_STRING;
}
if ((tmp_str = xmlGetProp(fact_node, (xmlChar*) "sign"))) {
sign[i] = (char *) tmp_str;
xmlFree(tmp_str);
} else {
sign[i] = NA_STRING;
}
if ((tmp_str = xmlGetProp(fact_node, (xmlChar*) "tupleRef"))) {
sign[i] = (char *) tmp_str;
xmlFree(tmp_str);
} else {
sign[i] = NA_STRING;
}
if ((tmp_str = xmlGetProp(fact_node, (xmlChar*) "order"))) {
sign[i] = (char *) tmp_str;
xmlFree(tmp_str);
} else {
sign[i] = NA_STRING;
}
if ((tmp_str = xmlGetProp(fact_node, (xmlChar*) "id"))) {
factId[i] = (char *) tmp_str;
xmlFree(tmp_str);
} else if ((tmp_str = xmlGetProp(fact_node, (xmlChar*) "name"))) {
factId[i] = (char *) tmp_str;
xmlFree(tmp_str);
} else {
factId[i] = NA_STRING;
}
ns[i] = (char *) fact_node->ns->href;
}
xmlXPathFreeObject(fact_res);
return DataFrame::create(Named("elementId")=elementId,
Named("contextId")=contextId,
Named("unitId")=unitId,
Named("fact")=fact,
Named("factId")=factId,
Named("decimals")=decimals,
Named("scale")=scale,
Named("sign")=sign,
Named("tupleRef")=tupleRef,
Named("order")=order,
Named("ns")=ns);
}
bool
HdxIntersector::Query(HdxIntersector::Params const& params,
HdRprimCollection const& col,
HdEngine* engine,
HdxIntersector::Result* result)
{
TRACE_FUNCTION();
// Make sure we're in a sane GL state before attempting anything.
if (GlfHasLegacyGraphics()) {
TF_RUNTIME_ERROR("framebuffer object not supported");
return false;
}
GlfGLContextSharedPtr context = GlfGLContext::GetCurrentGLContext();
if (!TF_VERIFY(context)) {
TF_RUNTIME_ERROR("Invalid GL context");
return false;
}
if (!_drawTarget) {
// Initialize the shared draw target late to ensure there is a valid GL
// context, which may not be the case at constructon time.
_Init(GfVec2i(128,128));
}
GfVec2i size(_drawTarget->GetSize());
GfVec4i viewport(0, 0, size[0], size[1]);
if (!TF_VERIFY(_renderPass)) {
return false;
}
_renderPass->SetRprimCollection(col);
// Setup state based on incoming params.
_renderPassState->SetAlphaThreshold(params.alphaThreshold);
_renderPassState->SetClipPlanes(params.clipPlanes);
_renderPassState->SetCullStyle(params.cullStyle);
_renderPassState->SetCamera(params.viewMatrix, params.projectionMatrix, viewport);
_renderPassState->SetLightingEnabled(false);
// Use a separate drawTarget (framebuffer object) for each GL context
// that uses this renderer, but the drawTargets share attachments/textures.
GlfDrawTargetRefPtr drawTarget = GlfDrawTarget::New(size);
// Clone attachments into this context. Note that this will do a
// light-weight copy of the textures, it does not produce a full copy of the
// underlying images.
drawTarget->Bind();
drawTarget->CloneAttachments(_drawTarget);
//
// Setup GL raster state
//
GLenum drawBuffers[3] = { GL_COLOR_ATTACHMENT0,
GL_COLOR_ATTACHMENT1,
GL_COLOR_ATTACHMENT2 };
glDrawBuffers(3, drawBuffers);
glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE);
glDisable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
glDepthFunc(GL_LEQUAL);
glClearColor(0,0,0,0);
glClearStencil(0);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT);
glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
GLF_POST_PENDING_GL_ERRORS();
//
// Execute the picking pass
//
{
GLuint vao;
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
// Setup stencil state and prevent writes to color buffer.
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
glEnable(GL_STENCIL_TEST);
glStencilFunc(GL_ALWAYS, 1, 1);
glStencilOp(GL_KEEP, // stencil failed
GL_KEEP, // stencil passed, depth failed
GL_REPLACE); // stencil passed, depth passed
//
// Condition the stencil buffer.
//
params.depthMaskCallback();
// we expect any GL state changes are restored.
// Disable stencil updates and setup the stencil test.
glStencilFunc(GL_LESS, 0, 1);
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
// Clear depth incase the depthMaskCallback pollutes the depth buffer.
glClear(GL_DEPTH_BUFFER_BIT);
// Restore color outputs & setup state for rendering
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
glDisable(GL_CULL_FACE);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glFrontFace(GL_CCW);
//
// Enable conservative rasterization, if available.
//
// XXX: This wont work until it's in the Glew build.
bool convRstr = glewIsSupported("GL_NV_conservative_raster");
if (convRstr) {
// XXX: this should come from Glew
#define GL_CONSERVATIVE_RASTERIZATION_NV 0x9346
glEnable(GL_CONSERVATIVE_RASTERIZATION_NV);
}
//
// Execute
//
// XXX: make intersector a Task
HdTaskSharedPtrVector tasks;
tasks.push_back(boost::make_shared<HdxIntersector_DrawTask>(_renderPass,
_renderPassState,
params.renderTags));
engine->Execute(*_index, tasks);
glDisable(GL_STENCIL_TEST);
if (convRstr) {
// XXX: this should come from Glew
#define GL_CONSERVATIVE_RASTERIZATION_NV 0x9346
glDisable(GL_CONSERVATIVE_RASTERIZATION_NV);
}
// Restore
glBindVertexArray(0);
glDeleteVertexArrays(1, &vao);
}
GLF_POST_PENDING_GL_ERRORS();
//
// Capture the result buffers to be resolved later.
//
size_t len = size[0] * size[1];
std::unique_ptr<unsigned char[]> primId(new unsigned char[len*4]);
std::unique_ptr<unsigned char[]> instanceId(new unsigned char[len*4]);
std::unique_ptr<unsigned char[]> elementId(new unsigned char[len*4]);
std::unique_ptr<float[]> depths(new float[len]);
glBindTexture(GL_TEXTURE_2D,
drawTarget->GetAttachments().at("primId")->GetGlTextureName());
glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, &primId[0]);
glBindTexture(GL_TEXTURE_2D,
drawTarget->GetAttachments().at("instanceId")->GetGlTextureName());
glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, &instanceId[0]);
glBindTexture(GL_TEXTURE_2D,
drawTarget->GetAttachments().at("elementId")->GetGlTextureName());
glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, &elementId[0]);
glBindTexture(GL_TEXTURE_2D,
drawTarget->GetAttachments().at("depth")->GetGlTextureName());
glGetTexImage(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, GL_FLOAT,
&depths[0]);
glBindTexture(GL_TEXTURE_2D, 0);
GLF_POST_PENDING_GL_ERRORS();
if (result) {
*result = HdxIntersector::Result(
std::move(primId), std::move(instanceId), std::move(elementId),
std::move(depths), _index, params, viewport);
}
drawTarget->Unbind();
GLF_POST_PENDING_GL_ERRORS();
return true;
}
// Save an object to a file
void ToDraw::save(QDataStream &stream) const
{
stream << pos();
stream << elementId();
stream << zValue();
}
void SvgCard::paint(QPainter* painter, const QStyleOptionGraphicsItem* , QWidget* )
{
//QGraphicsSvgItem::paint(painter, option, widget);
renderer()->render(painter, elementId(), boundingRect());
}
