void Message::addTraceId(const std::string& id)
{
std::string trace = getEncoding().getAnnotationAsString(X_QPID_TRACE);
if (trace.empty()) {
addAnnotation(X_QPID_TRACE, id);
} else if (trace.find(id) == std::string::npos) {
trace += ",";
trace += id;
addAnnotation(X_QPID_TRACE, trace);
}
}
void AnnotationState::handleAnnotationCommand(protocol::MessagePtr msg)
{
switch(msg->type()) {
case protocol::MSG_ANNOTATION_CREATE: {
const auto &cmd = msg.cast<const protocol::AnnotationCreate>();
addAnnotation(Annotation { cmd.id(), QString(), QRect(cmd.x(), cmd.y(), cmd.w(), cmd.h()), QColor(Qt::transparent) });
break;
}
case protocol::MSG_ANNOTATION_RESHAPE: {
const auto &cmd = msg.cast<const protocol::AnnotationReshape>();
reshapeAnnotation(cmd.id(), QRect(cmd.x(), cmd.y(), cmd.w(), cmd.h()));
break;
}
case protocol::MSG_ANNOTATION_EDIT: {
const auto &cmd = msg.cast<const protocol::AnnotationEdit>();
changeAnnotation(cmd.id(), cmd.text(), QColor::fromRgba(cmd.bg()));
break;
}
case protocol::MSG_ANNOTATION_DELETE: {
const auto &cmd = msg.cast<const protocol::AnnotationDelete>();
deleteAnnotation(cmd.id());
break;
}
default: qFatal("unhandled annotation command: %d", msg->type());
}
}
XSDOper *XSDOperationFactory::getSimpleContent()
{
XSDOper *complexContent = new XSDOper();
complexContent->name = IO_XSD_SIMPLECONTENT;
complexContent->add = true ;
addAnnotation(complexContent);
return complexContent;
}
XSDOper *XSDOperationFactory::getBaseSimpleTypeNoRef()
{
XSDOper *oper = new XSDOper();
addAnnotation(oper);
QPair<QString, QString> attrName(IO_ELEMENT_ATTR_NAME, XSDOperationParameters::TokenName);
oper->attributesToAdd << attrName;
oper->attributesToRemove << IO_ELEMENT_ATTR_REF;
oper->attributesToRemove << IO_ELEMENT_ATTR_TYPE;
return oper;
}
void FarEditor::addFARColor(int lno, int s, int e, color col)
{
if (TrueMod){
AnnotationInfo ai;
ai.fg_color = ((col.fg>>16)&0xFF) + (col.fg&0x00FF00) + ((col.fg&0xFF)<<16);
ai.bk_color = ((col.bk>>16)&0xFF) + (col.bk&0x00FF00) + ((col.bk&0xFF)<<16);
ai.bk_valid = ai.fg_valid = 1;
ai.style = col.style;
addAnnotation(lno, s, e, ai);
}else{
XSDOper *XSDOperationFactory::getComplexTypeReferenceElement()
{
XSDOper *oper = new XSDOper();
addAnnotation(oper);
QPair<QString, QString> attrName(IO_ELEMENT_ATTR_NAME, XSDOperationParameters::TokenName);
oper->attributesToAdd << attrName;
QPair<QString, QString> attrRef(IO_ELEMENT_ATTR_TYPE, XSDOperationParameters::TokenType);
oper->attributesToAdd << attrRef;
oper->attributesToRemove << IO_ELEMENT_ATTR_REF;
return oper;
}
XSDOper *XSDOperationFactory::createSimpleType(const QString &typeName)
{
XSDOper *oper = new XSDOper();
oper->name = IO_XSD_SIMPLETYPE;
oper->add = true ;
if(!typeName.isEmpty()) {
QPair<QString, QString> attrName(IO_ELEMENT_ATTR_NAME, typeName);
oper->attributesToAdd << attrName;
}
addAnnotation(oper);
return oper;
}
XSDOper *XSDOperationFactory::addAdd(XSDOper *parent, const QString &name, const bool isAnnotation)
{
XSDOper *child = new XSDOper();
parent->children.append(child);
child ->name = name;
child ->add = true ;
if(isAnnotation) {
addAnnotation(child);
}
return child;
}
void QRenderPass::copy(const QNode *ref)
{
QNode::copy(ref);
const QRenderPass *other = static_cast<const QRenderPass*>(ref);
d_func()->m_shader = qobject_cast<QShaderProgram *>(QNode::clone(other->d_func()->m_shader));
Q_FOREACH (QAnnotation *crit, other->d_func()->m_annotationList)
addAnnotation(qobject_cast<QAnnotation *>(QNode::clone(crit)));
Q_FOREACH (QParameterMapping *binding, other->d_func()->m_bindings)
addBinding(qobject_cast<QParameterMapping *>(QNode::clone(binding)));
Q_FOREACH (QRenderState *renderState, other->d_func()->m_renderStates)
addRenderState(qobject_cast<QRenderState *>(QNode::clone(renderState)));
}
void QTechnique::copy(const QNode *ref)
{
QNode::copy(ref);
const QTechnique *tech = static_cast<const QTechnique*>(ref);
d_func()->m_openGLFilter.copy(tech->d_func()->m_openGLFilter);
Q_FOREACH (QAnnotation *annotation, tech->d_func()->m_annotationList)
addAnnotation(qobject_cast<QAnnotation *>(QNode::clone(annotation)));
Q_FOREACH (QRenderPass *pass, tech->d_func()->m_renderPasses)
addPass(qobject_cast<QRenderPass *>(QNode::clone(pass)));
Q_FOREACH (QParameter *p, tech->d_func()->m_parameters)
addParameter(qobject_cast<QParameter *>(QNode::clone(p)));
}
QMaterial *RayCloudPlot::makeMaterial()
{
auto mat = new QMaterial();
auto eff = new QEffect(mat);
mat->addParameter(m_linewidthParam);
mat->addParameter(m_pixelSize);
mat->addParameter(m_colorParam);
// Set up the shader
auto gl3tech = new QTechnique();
auto api = gl3tech->graphicsApiFilter();
api->setApi(QGraphicsApiFilter::OpenGL);
// api->setMajorVersion(3);
// api->setMinorVersion(1);
// api->setProfile(QGraphicsApiFilter::CoreProfile);
api->setMajorVersion(2);
api->setMinorVersion(0);
api->setProfile(QGraphicsApiFilter::NoProfile);
// Forward render
auto ann = new QAnnotation();
ann->setName("renderingStyle");
ann->setValue("forward");
// Shader render pass
auto gl3program = new QShaderProgram();
gl3program->setVertexShaderCode(QShaderProgram::loadSource(QUrl("qrc:/shaders/ray.vert")));
gl3program->setFragmentShaderCode(QShaderProgram::loadSource(QUrl("qrc:/shaders/ray.frag")));
auto gl3pass = new QRenderPass();
gl3pass->setShaderProgram(gl3program);
// auto pointsize = new QPointSize();
// pointsize->setEnabled(true);
// gl3pass->addRenderState(pointsize);
// auto cullface = new QCullFace();
// cullface->setMode(QCullFace::Front);
// cullface->setEnabled(true);
// gl3pass->addRenderState(cullface);
gl3tech->addAnnotation(ann);
gl3tech->addPass(gl3pass);
// Push it all in
eff->addTechnique(gl3tech);
mat->setEffect(eff);
return mat;
}
void Cluster::dropEvent(QDropEvent *event)
{
if (event->source() == 0) {
event->setDropAction(Qt::IgnoreAction);
}
else if (event->source() == this) {
event->setDropAction(Qt::IgnoreAction);
}
else if (event->mimeData()->hasFormat("Annotation")) {
QByteArray ba = event->mimeData()->data("Annotation");
Annotation ann(ba);
addAnnotation(ann);
event->acceptProposedAction();
}
}
bool Object::addAnnotation(weak_ptr<Annotation> annotation) {
if (!isActive()) return false;
if (annotation.expired()) return false;
return addAnnotation(annotation.lock());
}
void Message::clearTrace()
{
addAnnotation(X_QPID_TRACE, std::string());
}
/// Set the name for this instruction.
void Instruction::setInstrName(CFGBuilder &Builder, StringRef Name) {
addAnnotation(Builder.newAnnotationT<InstrNameAnnot>(Name));
}
