 Okay, I'm Tomasz from Collabora and I'll talk about the building X-ray like an object inspector. So this is mainly a continuation from a FOSDM talk. At that time, when FOSDM was held, I was in the middle of the implementation of the new object inspector. So finally now I can talk about how it actually looks as a whole. So first, I will just quickly go through the introduction and why we need this, why we need the object inspector and why we had to implement it. So the object inspector was a tender from the Document Foundation. The tender was for implementing support for a dedicated built-in UNO object inspector tour in the liberal office. And thanks to the Document Foundation to make this work possible so that we have now this awesome tour. So the development tools like this UNO object inspector is now called, it was released with a liberal office 7.2 and this is the latest release and can be freely used. So, development tools about it. So first let's talk about like UNO object inspector, what is an UNO object inspector at least. So it's a tool like X-ray tool or EMR, which was an extension for liberal office. The main purpose of these tools were to inspect the UNO objects, like what the properties are, the types and values, which methods it has, what interfaces, objects, UNO objects implemented, which types are supported. So in addition to this, they also allow you to traverse the UNO object tree. So you can go from one object, see what properties are and for the properties you can then again see what object, what UNO object it contains. So you can go like recursively through the document object model. It's very good for developers or for just users that aren't very familiar how the document object model is constructed. They can use this tool and just see, inspect everything and maybe they can use this when writing their extensions or macros. So what is the idea actually? The idea of the development tool is that it has to be a tool that is built inside liberal office, so no extension again. The problem with this was of course always that extension has to be downloaded and a lot of users don't really know that they exist. So if we have this available inside liberal office, out of the box, this is more available to the users. Then there should be a dockable window on the bottom of the screen, like very similar to how the development tools are in the popular browsers. So you would have like two, three left hand side and right hand side where on left hand side it should be just a subset of the document object model where we can go to the current document object, inspect current document object model, but not everything inside the document object model, just what was predefined. Just for example inside writer, for example there would be properties for paragraphs and each paragraph that should have like each section of the paragraph. And for example what is on the left hand side also is the styles. We can expect all the styles that are currently available. On the right hand side then there should be the actual object inspector where we see a lot of properties and information about the objects. It should also have a point and click functionality. This is more like whatever you have currently selected, we should be able to inspect it. So you select an object like for example a shape and if you enable this functionality you select a shape and you can inspect it inside the object inspector. So as I said this is already what I generally described. For the left hand side again the document review, this should be easier for the new users to understand the document object model and how to navigate it. So on the right hand side the idea on the right hand side is that there should be the object inspector. So it should be similar to the watch window that already exists inside macro editor. Unfortunately we weren't able to share the code but they are very similar how they are constructed. And this watch window shows like properties, methods, interfaces of an object and you can see all the types and current values. And yes as I said it should be it's possible to inspect the objects recursively, properties and objects recursively. And it supports also looking into the various collections and arrays. More on this later, also what is good to have special handling of certain types. So point and click as I already said you click inside the document and you can show an object inside the object inspector. So what's the state of the development tools? Like it was released inside LibreOffice. I will talk about how the object inspector or development tools are currently inside LibreOffice 7.2. So first one where is the location where we can enable the development tools? Previously this was in help development tools but this was not a very good place for the development tools. So I moved this to tools development tools as you can see on the screen. It's like very down where the extension manager custom objects I think this is and macros. This is a very good place where we can find the development tools. So the structure. Okay on the left side as I said there is the document object model tree view. There is a button current selection which is the point and click functionality. And on the right side we have the document inspector. On the top on the right side we have an additional menu for the object inspector. And on the tops you have interfaces, services, properties and methods. So using the tops we are changing what we want to see for the current object. So one object to inspect are on the left-hand side. For writer there is like paragraph shape, tables, frames and so on and so on. And for the car sheets, shapes, charts, pivot tables and so on. And also of course for drawing, impress there are pages or slides and shapes and so on. This is what you can generally select inside the document object model tree view. And then on the right-hand side you can select it. Here you can see the location of the point and click. So this current selection is the point and click functionality. It listens to all the changes. Selection changes and then after you select an object you can inspect it in object inspector. If you disable this then you can normally just work with the document tree view as before. So if this is enabled you cannot, if you select anything inside the document object model tree view it will have no effect because the current selection, this button has precedence. And when it is disabled then the control goes back to the document object model tree view. So on the right-hand side the object inspector. So on the top there is a menu. We have like back inspect and refresh buttons. Back and inspect I will introduce later. And refresh button just refreshes the car and object. So if the object changes in the between we have to refresh it. This doesn't happen automatically because if we cannot, we don't actually check when the object changes. Maybe this is possible but we didn't implement. This is not necessary. So we have to take in account that the object can't change and it could also be deleted when you are still inspecting it. So refresh, refreshes the current object. Then on the right-hand side of the toolbar we have like current shows the class name or the current implementation name. So we know which object we are inspecting. And then on the lower side we have like this tab view where we have interfaces, services, properties and methods. So the most interfaces and services are generally not so interesting. We just list what interfaces the current object supports and in which services current object supports. So what's more interesting is properties tab. So I will explain a little bit more in detail what you can find in property tab. It shows all the properties of the current object. So properties that implement X property set. And this is not the only thing. It also shows the properties that are attributes. So they are marked as attribute inside the object interface definition language. And they are also shown through the properties. Through the properties are any properties or any methods that are set and or set methods. So if something starts like get string it will be shown as a string property. But of course if get string has no parameters. Only if it has no parameters it will be shown as a property here. Any other like even if it has get something else get string and it has an input parameter it will be showing the methods. There are special cases here. And this is that we also if the object implements X index container or X name container or X enumeration we also want to show what are the content of this. So X index it will show all indices of the current object. So we can nicely traverse the documentary. Similar if it implements the X name container it will show all the key or name value, name property pairs of the current object inside here. This is generally because otherwise it would be very hard to get to these values if it's not available. These special cases not available here. So we are nesting is possible. This means like recursion is possible. So it shows properties in properties. And not only that it shows also special types like of course value types like strings are shown as values. But you can also have structs and arrays. So struct you can see struct and you can go and inspect the properties or the members of a struct. And arrays similar like this you can see what all the indices are of the array and inspect their values as well. The columns here as you can see is like this the columns are like name, value type and info. So name is just property name value is the value of the property. If this is possible to if it is a value type it is we can we can show the value otherwise not. And we show something that is probably helpful helpful. Like for example sequence for sequence we show also the size of the sequence or array. And if there is nothing useful to show then we just don't show anything. So the third column is the type. Here we showed the type of the column other is a string byte array or some property some or interface or whatever it is the type of this current property. And then last column is like info column and this shows additional info. Additional info in many cases like access restrictions like either for example if the property is absolute property it shows if it is a getter or it also has a setter or it has both. And if the property is just for reading or it can be also for reading and writing. So on the bottom we have like this properties like edit text field and this is needed because if you have like value which is very big one for example a very very long string. We cannot show this inside the inside the tree view because it will be just too long. So we always limit this to a certain value certain size of the string or and just show this limited string inside the tree view. But the whole string will be shown then in the lower part of the inside this edit text field. As you can see on the right side there is a very very long string and we can see. Another good thing is that if we want to copy something from this string we can do this inside here we cannot do this inside tree view. And of course if it's inside the tree view we can just show one row not multiple rows this will be very very annoying. So there's always one row and if there are multiple rows of text it will be shown here inside the edit text field. So there's also a stack because if you right click on or just in the tool select this looking glass icon it will be it will inspect the current properties. And what this means is that this selected property will now go will be now the route the inspected object. And when we do this we put the previous object inside stack so inside the stack. So we also have this back button enabled when we can go just back to the previous selected previous inspected object. So we can just form this like chain of inspected objects so it's easier for the user to like if there is a lot of properties that he's not interested in he can just inspect the current one and it will be on the top. And if he needs to go back he can still go back with the back button. If on the DOM tree anything is selected the stack is cleared so it's not like that you can always go back it will be cleared only if you are inspecting inside the current object. This is working but if you go to the another object or if you use point and click and select the selected object and change the selected object on the GUI the stack will be clear. So this is about the properties next is then what is still interesting are the methods. So this show now shows all the supported methods of the current objects. The method has like this methods have has like one to three four columns and first column is just method is just the name of the method then the return type is the type will be returned. And I don't think this is always very exact currently if the return type is more complicated it will be shown like any not exactly the type that we are interested in. This is just to make the GUI more easier to handle. And the third column is like parameters which just shows what are the input parameters the name of the parameter and the type not to just input also if it's an output or if it's an input output parameter. And the last column is implementation class. The implementation class is the class where the method is implemented. So this can if the current object is derived from some implementation or some interface then the interface where this method is defined is written here. This is all what is currently supported. So there are some more ideas and to do for the object inspector. For example, it will be very good inside methods that we have the possibility to execute a method. This is currently not implemented but it will be good just if you say okay I want to execute this method and then you would set the parameters and execute it. I think this can be very good for users that want to modify some things quickly. Another thing is also to inspect an object in an independent dialogue. So currently we are always inside these development tools but sometimes we want to just extract some, inspect an object separately and just always have it on the screen. So it's easier for us to look at multiple objects at the same time. So I think that if you have a possibility to open an independent dialogue and inspect the object there it will be very useful. So the demo, for the demo I have like this one document open and I'll just show a little bit how to work inside this development tools and object inspector. So first we can just select current selection and this we select this shape and now we can go to the properties and as you can see this is now SVX shape collection. So just because you can select multiple shapes it always has a shape collection and the first shape inside the collection is the shape we are inspecting. So we can now go inside and for example we are interested in to get the shape text where this is located. So first we can just go and see here there is a property string that has shape text as the value. So we can easily inspect and see where this is found. So there are also other things that we can inspect here and for example if we are not interested in the other shapes we can just say here inspect right click inspect or this. And now the top level it will be just text context of this shape. So for example if now we write some paragraph one and again we are selecting this so we have like this as we extract range. And now we have to go inside this because this is again a collection of the ranges we will just inspect. So now we are in one of exactly this text range and we can go again see the string and string is paragraph one like we are selected here. And if we are interested in other properties we can see here whatever other properties we are interested in and if we go to methods we can see all the methods that are. So as I say these pseudo properties you can see that there is a get string method and because this is get string method it's recognized as a property which is also available here as just string. Let's just look inside the document object model here. We have like we unselect this and then we can we see that we have one paragraph and one text portion and this should be exactly this one here. And if we look at it string is paragraph one. Okay this is all for me thanks for listening and this is all.