We've got a rendering that needs to inherit it's rendering parameters from an ancestor item. Knowing the ID of the item I'm trying to inherit from, how do I get that item's rendering parameters with Glass?
Related
So recently I started a project where I want to display a graph showing relations between different datasets.
The graph consists of Edges and Nodes, while both of these classes inherit QQuickPaintedItem and override the paint(QPainter* painter) method. I have another class which stores all Nodes and Edges in two QLists. When I want to display the Graph, the paint method for every Node and Edge is called and is being painted into a QQuickView. I do this by setting a Qml File for the QQuickView (important: The loaded qml File has nothing to do with the actual Graph, everything is painted with the paint-method from QQuickPaintedItem and i haven't exposed anything related to the Graph to Qml.
The Qml File is being used to display some controls for the graph) and getting the content item (QQuickItem* from method contentItem()) of the QQuickView and setting it as a parent for every Node and Edge. All of this works fine for me.
Now to my problem: Some of the graphs I wanna display are bigger than my actual view i want to display them in, so to solve this i want to implement horizontal and vertical Scrolling for my View. However I haven't found anything that seems to solve my problem due to the fact that i can't use predefined Qml-Layouts like ListView aso. for my Graph.
Does anyone have an idea how I could implement Scrolling? Is there a way to implement this for my QQuickView or is there are way to expose my two Lists of Nodes and Edges to Qml and implement Scrolling in there?
(If you need some code, feel free to ask. I don't think it makes sense to share some code right now since I'm searching for an idea what to do about this topic in the first place).
Thank you!
If you don't mind rendering everything, what you need is Flickable.
Set the viewable width and height of your Flickable (explicitely, with anchors, or with layouts) and nest your custom item in it and set the contentWidth and contentHeight of the flickable depending on the total size or your custom item.
I'm quite new to QML and I'm struggling to find any information how to render a tree model in a simple way (although horizontally, rather than vertically):
Seems like QML only supports list data structures from models. Is there any way to do it?
Figured it out on my own. The trick is to use DelegateModel, Repeater and Row/Column layouts, not TreeView.
Create a component which will show your current node using DelegateModel.
Use a Repeater to create children - let the component dynamically create another instance of itself, assign the current node as the rootIndex of newly constructed DelegateModel, and set it as the model for the Repeater.
By properly using layouts, you can position your nodes exactly as in the attached image.
I am trying to use Ember to render a directed acyclic graph. In Backbone, I was able to render the child component views (the nodes), to the DOM, get their dimensions (.height(), .width()) and then use that information in a graph layout algorithm, then re-render the parent component in such a way that all child components would get their new (x, y) positions and transition into place. Getting the height/width into the layout algorithm is important because without that information, it can't provide adequate space for the nodes to not overlap. Letting the DOM provide that information is nice, because it allows the graph nodes to be formatted by the browser itself, using good ol' HTML layout.
Ember seems like a natural fit for doing something like this, but here's my problem. I have the following:
{{parent-component nodes=nodes}}
{{node-layer nodes=nodes }}
...
{{#each nodes as |node|}}
{{node-view height=node.height width=node.width position=node.position}}
{{/each}}
...
{{/node-layer}}
{{/parent-component}}
The only time I can get the leaf component's (the node's) height/width is on a didInsertElement or didRender call in the node component. That works fine. There are a variety of ways I can pass this information back up to the parent component and into my layout algorithm. The problem is that any method of re-rendering the parent component, such that the new positions will trickle down to the child components, will happen as part of the call stack stemming from the child's didInsertElement render hook cycle, and Ember will complain and/or I will completely freeze the browser in and endless render loop.
Can anyone think of a pattern using Ember to do what I'm trying to do? One that doesn't involve fighting the framework or some hack?
I am stuck on OpenGL 1.1 for a particular game-modding project, and I am using a display list as a sort of snapshot of part of the game, where I begin the display list, direct those parts to render, and close the display list. This correctly results in a display list I can then transform and render at will.
However, while I am transforming and rendering that display list, the part of the game that was snapshotted ceases to exist, and it destroys any display lists that it had been using, meaning when I render my snapshot, those parts that were display lists then fail to render.
What I would like to be able to do is somehow direct OpenGL to copy the contents of nested display lists into the top-level one instead of just embedding the call to the nested display list. I haven't been able to find any function that would do what I want. Does one exist?
(No, the parts of the game I am snapshotting are not predictable, and are likely to be wildly different every single time.)
I think your best bet would be to hook into all relevant OpenGL calls, by injecting a "opengl32.dll" hooking DLL with entry points identical to the OpenGL ones, but each one making a copy of the relevant data.
I am troubled by the following:
I am working with an interactive QGraphicsScene that needs to render the graphical representation of an SQL query, based on the users' operations, such as: add something to the query (a table, a new column, something else) or remove something from the query (a keyword, a table, a column ...). The changes of the scene must be displayed after the operation, and also the "logic layer" of the application needs to track the operations the user did, since the "rendering" of the query is done by the "logic" layer (ie: the "logic layer" creates all the QGraphicsItemGroup derived objects which at a later stage, after all the logic layer components were built, are being added to the graphics scene of the query and put on the window).
The problem that occurs is the following: right now I did not manage to find any usable solution to present a query after a change in the smoothest possible way.
Allow me to link in a screenshot for further explanation:
Let's suppose the user wants to remove the PERSON.NAME column from the query. What happens in the application:
the user clicks on the "remove" (small red X after the column name) button of the PERSON.NAME columns' graphic item
the Graphics View senses this operation, sends the REMOVE column from the graphic system to the "logic layer" (the "model")
the logic layer on its turn removes the corresponding "logic layer" object representing the PERSON.NAME column,
And here the trouble starts:
the entire graphic (yes, everything) is re-rendered by the logic layer creating the graphic items for the same query, without PERSON.NAME
then I have to create a new window which has a new QGraphicsScene object together with a QGraphicsView
insert the re-rendered objects' graphic items representing the query, (but now without the PERSON.NAME column) into the new QGraphicsScene with addItem()
and now replace the central widget of the application with the new window.
and now you can see, that indeed, in the query the PERSON.NAME is not there anymore and all the graphic elements that were below PERSON.NAME were moved up on the screen.
Obviously this is not a good solution, there is an ugly flickering when I change the window, but I simply did not find a better solution to this problem till now.
So I am asking for your help in order to identify what improvements can be done to this methodology of updating the screen upon removal (addition) of a new element knowing the background information above, without a new window. Obviously other, mroe generic graphic related comments are welcome too.
Thanks,f
Based on the information from the question and the comments, a couple of things you could consider:
First thing is that you need to get rid of creating a new Window and a new QGraphicsView when refreshing.
I suppose this is the main reason for flickering. Keep your UI structure unmodified and only modify the scene.
You could use one of these approaches:
Either create a new QGraphicsScene and set it as the view's scene, or call clear() on
the existing scene. Then recreate your QGraphicsItems from your native model and make sure that all your pointers and references are updated.
Another approach would be to have the QGraphicsScene update your native model when something changes, to avoid the need to recreate the whole scene from scratch. For example, let the QGraphicsScene handle the deletion of the QGraphicsItem when the user clicks the delete icon, and then let the scene update your native model to reflect this change.
Yet another approach would be to discard your native model, and use the QGraphicsScene with its QGraphicsItems as your model. Implement serialization etc. in the scene class. This avoids the need to synchronize the two models. The drawback is that your graphics independant logic is then much tighter coupled to the QGraphicsScene, which you might not want. Depending on your code size, this might also be a lot of work.
I would start with 1., since it seems to be the easiest way to go based on your existing approach. If you still come across weird issues with pointers and object ownership, try to isolate them and ask on SO :)