juanotto commented on code in PR #23: URL: https://github.com/apache/netbeans-antora-tutorials/pull/23#discussion_r2479285716
########## modules/ROOT/pages/tutorials/nbm-selection-1.adoc: ########## @@ -503,146 +503,160 @@ import org.openide.util.NbBundle; import org.openide.util.lookup.Lookups; import org.openide.windows.TopComponent; ---- - -The line `associateLookup(Lookups.singleton(obj));` will create a `Lookup` that contains only one object - the new instance of `Event` - and assign that `Lookup` to be what is returned by `MyEditor.getLookup()`. While this is an artificial example, you can imagine how `Event` might represent a file, an entity in a database, or anything else you might want to edit or view. Probably you can also imagine one component that allows you to select or edit multiple unique instances of `Event`, which will be the subject of the next tutorial. - -To make your editor component at least somewhat interesting (though it doesn't actually edit anything), you set the text fields' values to values from the `Event`, so you have something to display. ++ +The line `associateLookup(Lookups.singleton(obj));` creates a `Lookup` containing one object - the new `Event` instance. +This becomes what `MyEditor.getLookup()` returns. While this is a simple example, you can imagine `Event` representing a +file, database entity, or anything else you want to edit or view. You could also have a component that lets you select +or edit multiple `Event` instances, which is covered in the next tutorial. ++ +To make the editor component interesting (though it doesn't actually edit anything), you set the text fields to display +values from the `Event`. == Running the Code -Now you're ready to run the tutorial. Simply right click `EventManager`, the application which contains your three modules, and choose Run from the popup menu. When the IDE opens, simply choose Window > Open Editor to invoke your action. Do this a couple of times, so that there are several of your editor components open. Your singleton `MyViewer` window should also be open. Notice how the `MyViewer` window's contents change as you click different tabs, as shown here: - -image::tutorials/selection-1_result1.png[] +Now you're ready to run the tutorial. Right click `EventManager` and choose Run. When the IDE opens, choose +Window > Open Editor to invoke your action. Do this a few times to open several editor components. Your `MyViewer` +window should also be open. Notice how the `MyViewer` window content changes as you click different tabs: -If you click in the Viewer window, or close all of the editor windows, note that the text changes to "[no selection]", as shown below: +image::tutorials/selection-1_nb27_result1.png[] -image::tutorials/selection-1_result2.png[] +If you click in the Viewer window or close all editor windows, the text changes to "[no selection]". -NOTE: If you do not see the `MyViewer` window, you probably did not check the checkbox in the wizard to open it on system start - simply go to the Window menu and choose MyViewer to display it. +NOTE: If you don't see the `MyViewer` window, you probably didn't check the "open on system start" checkbox in the +wizard. Go to the Window menu and choose MyViewer to display it. == So, What's the Point? -So the key point of this tutorial is the way the code is split into three modules: the My Viewer module knows nothing about the My Editor module, and either one can run by itself. They only share a common dependency on My API. That means two things: 1. My Viewer and My Editor can be developed and shipped independently, and 2. Any module that wants to provide a different sort of editor than My Editor can do so, and the viewer component will work perfectly with it, as long as the replacement editor offers an instance of `Event` from its Lookup. - -To really picture the value of this, imagine `Event` were something much more complex; imagine that `MyEditor` is an image editor, and ` Event` represents an image being edited. The thing that's powerful here is that you could replace `MyEditor` with, say, an SVG vector-based editor, and the viewer component (presumably showing attributes of the currently edited image) will work transparently with that new editor. It is this model of doing things that is the reason you can add new tools into the NetBeans IDE that work against Java files, and they will work in different versions of NetBeans, and that you can have an alternate editor (such as the form editor) for Java files and all the components and actions that work against Java files still work when the form editor is used. +The key point is how the code is split into three modules: My Viewer knows nothing about My Editor, and either can run +independently. They only share a dependency on My API. This means: -This is very much the way NetBeans works with Java and other source files-in their case, the thing that is available from the editor's Lookup is a ` xref:wiki::wiki/DevFaqDataObject.adoc[DataObject]`, and components like Navigator and the Property Sheet are simply watching what object is being made available by the focused `TopComponent`. +1. My Viewer and My Editor can be developed and shipped independently +2. Any module can provide a different editor and the viewer will work with it, as long as the new editor offers an +`Event` from its Lookup -Another valuable thing about this approach is that often people are migrating existing applications to the NetBeans Platform. The object that is part of the data model, in that case, is probably existing, working code that should not be changed in order to integrate it into NetBeans. By keeping the data model's API in a separate module, the NetBeans integration can be kept separate from the core business logic. +To understand the value, imagine `Event` is something complex - say `MyEditor` is an image editor and `Event` represents +an image being edited. You could replace `MyEditor` with an SVG vector editor, and the viewer (showing image attributes) +would work transparently with the new editor. This is why you can add new tools to NetBeans IDE that work with Java +files - they work across different NetBeans versions, and alternative editors (like the form editor) still work with all +components and actions that work with Java files. +This is how NetBeans IDE works with Java and other source files. The thing available from the editor's Lookup is Review Comment: I'll go with just Netbeans, more concise -- This is an automated message from the Apache Git Service. To respond to the message, please log on to GitHub and use the URL above to go to the specific comment. To unsubscribe, e-mail: [email protected] For queries about this service, please contact Infrastructure at: [email protected] --------------------------------------------------------------------- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected] For further information about the NetBeans mailing lists, visit: https://cwiki.apache.org/confluence/display/NETBEANS/Mailing+lists
