 Thank you so much for coming here. I would be in a lot of time. I'm Kade and I'm going to be working for Collabra. And I will be working on asynchronous data to see what it is and why it is needed. So, maybe lots of you know that me and Collabra are working on the LibreOffice Online. And LibreOffice Online has very many of the specific needs and it's structured so that there's a website email which is responsible for the extra communication that the term has to provide. It connects to the LibreOffice and manages also the instances of LibreOffice so that it is possible to have one LibreOffice instance actually for each and every document. But that's it in a way so that it is not too resource intensive. So we do it so that there's like one process that actually has lots of LibreOffice kit pre-initialized so that the fonts are loaded and initialized and lots of other things are there and initialized as well. And from there we actually, by default, every time a new document is needed to be rendered. It also is server-bound which is the user's interaction on the document. So whenever the user presses a key in the jump-stick part it is sent by the web-socket, the web-socket server and then from the door like this it is actually like a pass to the right instance of LibreOffice that manages the editing of the document inside. This is all written in C++. Then a profile like this has a client path. So this is what actually the user sees is that it is for a browser and it's taking care of the interaction with the user. The thing that you can see on the screen is actually like the jump-stick for the menus so that the user interactions are open but like when there is something that is executed it is sent by the web-socket server and then it is handled the way how it is needed. It is a very useful tool to tell here what the document actually is. So the document itself is not text. What the user sees is actually a series of paths so there are pixels that are 256 to 256 pixels and this is right there on the server. Whenever there is a change in the document I don't trigger the user's change here in the client or triggered internally from the LibreOffice board for example like there is an animated GIF or something like that. There is an update sent to the server of the area that needs to be rendered and the user sees a new GIF. Why it doesn't feel like a series of GIFs? It is because the actual cursor is a separate layer that is painted in the jump-stick and so that is why is it easy to update it can be a blinking cursor because it will be very unfortunate to send a new GIF for a blink of the cursor. So that is a separate layer and when you move inside the GIF it moves exactly as if the user if it was composed from the real address because in this LibreOffice GIF that actually sends the positions from the cursor and it sends it as if it was rendered on the normal screen The same thing is true for the forward selections so still it feels like normal in the normal document. So JavaScript is used for the sliders or managed to empower status bar but it seems impractical to do everything in the JavaScript or many things are not impractical to do in the core. The balance we are searching here comes from the history of this document as a prototype when we render just everything everything in the LibreOffice and then slowly we are finding what is the right balance between server-side rendering and what is supposed to be in JavaScript and it seems that the right balance is when you can send a task for all the users what is the function here that we can send to all the users that's the correct thing to render on the server but when there is something specific for just one user when there are more people connected to the document that is exactly the thing that should be handled in the JavaScript bar So then we started with this cursor just as I've said but later it went on to data validation how commands in the documents so the normal commanding thing was first implemented as a renderer to the task as you see it normally in your business but then it was transferred into JavaScript commands which added lots of nice things here because the commands can float re-organizing the tasks very nice but what about dials? are something that we start the first implement in JavaScript itself because it sounds like it is specifically to do it on the user as well but it quickly turned out that the implement in the dials in JavaScript is extremely like a process that takes too long time so we had to find a special printer but then it turned out that it is much better to take the dials as they are in the office and handle that handle that to the JavaScript bar so yeah we started working on this thing nearly one year later and finally we had some root of the fruit filters out and most of the root was done which would be a big fan here unfortunately we had to stop it so now it is working the features are exposed there are lots of things here like the advanced character page for cookies we can see some dials that are here but of course it is not finished yet so now this is a bit easy exposing the dials but still you have to do some changes in the core for which of the dials I'll go on later like why it is necessary because like I wrote about some of the details here but like the first to actually see the dials it is now very easy to expose but then you have to check if it works for the cooperation or not so from the point of view it works so that the build on the dials is a feature that was done I think I said for the TDF vendor but then like we started to extend it so that it is more interactive it is not only like that you initialize the dial and the essential of that to be able to to notify actually the client the diagnostic client one of the dials is locked up because it is not necessary it is not always that the dial would be triggered by the user very directly it is sometimes that you already have a dial off that has a button to actually like it is hidden on the dial so it is something that you do not become controlled by the gem itself part because like when you already have our programming, one of the dials is running in the developer's game and you cannot catch the event of actually like running the dial you have to do the infrastructure in a way that like you met the past that sounds about a small part of course in validation of the parts when something changes into the dial because there is a small sort of like when you for example change state of the radio button or something like that you have to do the past and send it like the update of the area that is being made and things like that so for this work we have added a concept of the graphics game notify which is some general structure like when when you provide this to a dial like each of the dials can have a restore notify so when a dial has this notify it sends some of these events like we have found it like directly to the code like where it is necessary it causes a graphics game notify and then this is the graphics game notify takes care of actually like doing all that to the to the javascript to the javascript file this is just a summary of the things that have to be that have to be done in the notify because it is kind of bending down posting stuff about the new events about most events and stuff like that and on the end of the event these callbacks that that democratize that something has changed so windows indicating the actions that we must create that something has changed, size changed that was a or a cursor to because of course obviously the dials have their own cursor as well and what is quite challenging here is that the the dials have to be localized so so actually using that so we have to hack the javascript to be able to actually like force the language for the actual dial this is again in order to be able to have multiple users in one document but each of them would have their own language settings so like that would be one user that checks the other language and it is built for when we are making an hour for one user like directly for the painting which is for the other there are also lots of stuff with resources to do that to accumulate like these days it is much more generic and easier to do so how the conversion of the dials so the same and what is it actually the same so so change the volume of the smartphone the dials it is so that like normally in mobile dials the user would put for everything else so like when you put up a mobile dial you can be sure that no actions in actual in actual document are being placed so with that mobile dials like it is not possible for the other users to actually do something but we in the cooperative anything we actually need to do something else we don't need to do enable the other users to be actually that they still could edit the document and anything luckily lots of this stuff were written before we started this this passing written it is because of the geographies so that you have a manual until you actually execute some mobile dial so in this manual the events are coming in and it will seal so that like and other things that are going on can take place so even when the mobile dial was executed it still was possible to pick it in the way that you could have seen that it was still possible to type behind the scenes so this was possible like the next year if you have seen the dialogue the editing from the other users where the problem was like when two users actually open the same dial so like factory properties something that lots of users or the color of the phone or stuff like that and when these two actually open at the same time it means that there was this manual from manual there was an execute and from this execute it called heal and this heal again triggered another dial so it was manual execute, execute so in order to now close the dial both these executes had to finish so the events just worked like you were able to close the dial in a way that it was hidden but before both these executes actually were closed you didn't return to the manual so it means that the actual change of the executes was not applied which was the main problem here so we started to think like what's the change here so that like for example the user and luckily there was something that that already was implemented in the real face and it was started with mobile which means that it was functionally that allow you to dial return the control back to the manual so there was no execute that would be calling heal but when you actually started to dial instead of like getting this stack of like main look, execute main look did something to show the dial return back to the manual and the other the sense of the dial again just show the dial and return to the manual but it turned out that using the this was very practical it was like for each like when the execution actually ended you have to comply with the antiques so when you click OK you have to you have to code that that applies this and for this it was like for this exact model it was for us this is very new new slope for this move the code actually out of the procedure very rare to somewhere else so instead it thought it would be better to load the moves around use around them so you can see easy cases it needs to be very small very small change so either add it it's the original code the scope VCL pointer the original VCL pointer it is so that the lifetime lifetime of the dial doesn't end with going out of scope the scope VCL pointer means that the dial is distracted when the control goes out of the control instead of the VCL pointer just keeps it alive until after the dial is actually triggered to be closed the other thing that's changed here is the execute is changed to start to execute the same then you get the sound down for like actually taking the property that the started to get it it's called the result is what is then called when the dial is actually closed is the result and then you have the code that was previously here in many cases because it wasn't in the case like if the result of the execute was okay was something that was okay and why not to do it so in many cases it's just like this while you are using directly the code that is there so like there are more more advanced cases then it needs more thinking cases like this so using all those features here same style, same testing for this small cases as well then you just click through the dial and see that it is there for not mobile dialogues which was of course much easier because he inspired not using any type as a execute then you have that using the as a execute substructure for as a register the child window and then the code when you actually want to show the dial there is a little child window which brings that different space in the manual so it's not much right now there and it's very far from the box for the car so usually in the convenience sometimes it happens that you expose the dial in the online and it doesn't appear so very usually the dial doesn't have an error because it is not necessary for BCL and we needed the model to be able to set up the local power here so you just need to assign a view shell you need all that information so the right to call and press you actually have a campaign how to get the view shell so you just assign it there it breaks it again, under half you want to get the water but you have to do this it's one version of the same now it has this language for users luckily these days it's not a big issue still there could be some cases like where some way to cash so you have to check before it's suspected but these days this is usually without a bridge because in case you would like to you would like to expose the dial in the online and it doesn't work for you it's just for me for me yeah thank you well, I think the biggest problem is when you expect this in an hour but you usually just start with that so it's fun and here you can also sort it out in this infrastructure that's an hour thank you so much thank you I wanted to start a little bit but this problem is screaming again screaming again for example so basically it's still a change because we are creating new styles so we have so far bigger problems for string readers than just the dials it's not something that it's impossible to sort out but for users it doesn't it's very well it's like yes so we have some proof of concept thanks to thanks to Ash yeah thanks to Ash we have a proof of concept code for the sidebar and we will use these languages for the sidebar like the entire sidebar it is logically it is all behind the scenes logically it is detached from the window and then send as a window to the application and then of course like this it looks like like the sidebar online behind the scenes or that it's located in the window so we do not have to convert it in any way to the same but like it is necessary to have it as a detection window so that the resizing actually looks like the version for resizing is not that important but very important is that you can change the person and then you would be using that to function yeah very good