The single available option was to show/hide the Menu Bar, which is useful for RCP apps. But for IDE usage the status line MUST show up (it’s impossible to debug a stacktrace without knowing which line you are, for instance). My buddy Robson is a packager of ArchLinux and they were facing this issue with Eclipse, so he asked me to fix it.

Get the plugin

You might get the .jar here and drop it on your plugins/ folder. If you are an Eclipse plugin developer, you might also want to check it out on my github.

Toggle Fullscreen

You might use Ctrl+Alt+Z to toggle fullscreen, or at Window->Fullscreen

Configure

You can choose to hide or show Menu Bar and Status Bar in Window -> Preferences -> General -> Full Screen

Enjoy!

]]> http://ugosan.org/lot-of-space-with-eclipse-fullscreen/feed/ 4 http://ugosan.org/first-steps-of-eclipse-sketch/ http://ugosan.org/first-steps-of-eclipse-sketch/#comments Sat, 08 May 2010 07:00:21 +0000 Ugo http://ugosan.org/?p=124

What do you think of this logo? (Click on it.)

Good news, the Sketch project was finally created! You may find it at http://www.eclipse.org/sketch

Although some improvements and refactoring are taking place right now, the API is already usable if you would like to pre-alpha-test it.

Me, Chris and Mariot have decided to go for Git as the version control. We are a fresh new project, so there were no reason not to: http://git.eclipse.org/c/sketch/org.eclipse.sketch.git/

Be aware that we are still re-organizing everything, and the code will be probably changed a lot, but if you see something really ugly, please file a bug.

The future of Sketch, as I envision it, includes users drawing their own graphical representations for models, being able to make suggestions to existing models using their own vocabulary and ultimately writing their own models. There is a very interesting discussion on this regard at the forum. If you are interested, please join it.

As for the present, I’ve prepared two videos for FlexiTools’2010, showing the features already available in Sketch.

1. VIDEO Creating a Use Case Diagram

Here I extend the Shapes editor (which is only able to model Squares and Triangles) to build such diagram.

2. VIDEO Creating an Activity Diagram and Making Annotations

Here is a slightly more complex example, plus annotations, which is the most immediate outcome of Sketch, since no recognition is needed.

What is the Delta Pack?

It’s a zipped Eclipse package with all the needed plugins to export your RCP product to many platforms (Windows, Linux, Mac, and so on) without having to do that on a platform’s native Eclipse installation. The archive contains all the platform specific fragments from the Eclipse SDK.

Situation

You have either

• a .product of an already existing project (I will use Sketch product for Shapes Application as the example here)
• you have your .product with your native installation dependencies and want to export to multiple platforms

First, check your version

First of all, check your Eclipse version, the delta pack you will download must have the exact same version, which means (yes) you will need to download another delta pack in case you update your Eclipse. But fortunately the steps are really easy to follow.

In my case, the version is Galileo 3.5.2 and the build is M20100211-1343, so look for that delta pack. Googling “delta pack <build name>” should give you the link, the file is usually like eclipse-M20100211-1343-delta-pack.zip

Unpack it into any folder. I usually place inside my own eclipse directory, inside a folder called delta.

Adding the delta pack to your Running Platform

Go to Window -> Preferences -> Plug-in Development -> Target Platform and Edit your current Running Platform.

Click Add..

Select Installation

Browse for the folder where you extracted the delta pack (mine is inside my eclipse folder, inside a folder called delta.

It will show all the packages for all platforms. See the swt for win32 64 bits, linux and everything. Click Finish and it will reload your platform (it might take a while).

If you open up your .product definition, and click Add Required Plugins, you shall see all the plugins.

If you go at the Overview tab of your product, click Export Product export wizard, and there it is, Export to multiple platforms.

Now you are able to generate your RCP product for any platform Eclipse is built for. Enjoy!

This might improve quite a bit your Eclipse’s performance, it improved mine. So try it out and share what did worked for you.

Warning: do NOT turn those flags on at your production environments.

Just add to your -vmargs launching arguments:

eclipse -vmargs

-XX:+UnlockExperimentalVMOptions

-XX:+UseG1GC

-XX:+UseFastAccessorMethods

Some people reported a great improvement in performance, not only in Eclipse, but also in other Java apps. For me it improved a little.

Some people also used other parameters (which didnt worked for my environment).

A complete list of jvm options may be found here, some are interesting like:

-XX:+AggressiveHeap
-XX:+AggressiveOpts
-XX:ParallelGCThreads=2
-XX:ThreadPriorityPolicy=1

Does it works for you? Please comment.

Here we talk about creating an intermediate element which holds a flexible graphic representation, in opposition to it’s canonical one (which in GMF is defined at .gmfgraph model). The users would be able to draw the elements as they wish, and as well be able to create new ones, something like this:

Here is a video explaining how it works, please watch and comment (go to Sketch Forum):

The main idea is the approach of the modeling task as a twofold process — one of freely sketching models with little interruption from the system; and another more formal, “classic modeling”, recognizing the elements drawn by the user right away, having as output a model in its canonical representation.

By letting users draw the model using their own graphic representation, we are allowing the GEF/GMF editor to be more flexible regarding its visual notation. For instance, assuming a simple model with the elements named flower, sun and cloud – they might be connected and generate an output or might serve as input for other models. A user might draw the flower element, for instance, in infinite ways, having any number of petals, with or without stem, and so on.

This allows the creation of a “graphicless model”, without predefined visual counterparts to the model elements, just elements and relations — the user would choose how elements will look like. That means the .gmfgraph would just hold the canonical representation, but the real one will be the user’s.

 So, on Eclipse GEF/GMF frameworks side, some minor modifications will need to take place:

• The underlying model (Ecore?) will need a generic element to serve as an ‘unrecognized’ element, to be created at the model while the user does not signifies it as anything
• make the editor flexible enough to hold any graphic representation for it’s elements, representing it using an SVG with the sketch. Also, this approach can also be used to make annotations on existing models, since the user might be able to create an “annotation” element.

Those are all feasible, so little adaptation would be needed to plug sketch onto GEF/GMF editors

Don’t you think?

This project is intended to be applied to any GEF editor, and since that there are so many GEF-based graphical editors out there, our goal now is to try to define a common set of functionalities between them.

We will start to discuss some of the ideas using the Sketch Forum/Newsgroup, please join the discussion and create topics if you are interested on this project or if you know a GEF editor that this project could benefit.

So far, what we have in mind is:

• Gesture (not only shape) recognition – the API would be able to provide a set of configurable gestures, that would translate into commands for moving, resizing, and so on. This feature would massively benefit GEF3D.
• Sketched vs. ‘Beautified’ look – There would be two ways of presenting the diagrams: the Sketched would show the recognized element as the user sketched it (using an SVG Figure created from it); The ‘beautified’ look would be the EditPart’s normal representation.
• Postponed recognition – Maybe to have an Action to trigger the recognition would be better for some domains, instead of always asking the user what he meant to represent like on this demo.

Imagine to have a mockup/wireframe editor built on top of Visual Editor. A prototype builder might be coded using the user’s own drawings. And the prototype might be constructed without a ‘done look’.

Any more ideas?

We are also editing the Sketch proposal’s Wiki so the modifications would be merged onto the official one later. If you are an interested party, please add yourself there.

I think so, I’ve been working on sketch recognition for GEF/GMF editors while creating the MoLIC editor, take a look:

Sketch API (former OmniModeling) on MoLIC Editor from Ugo Sangiorgi on Vimeo.

There are other posts on this blog reporting the evolution until this point — the API is able to recognize shapes the way you draw, learning withing the process if it cant recognize it upfront. It can recognize any shape, really, you will ‘teach’ it how.

Omnimodeling: Multi-Agent Recognition from Ugo Sangiorgi on Vimeo.

So it’s on! I decided to contribute to Eclipse by proposing a Sketch API for GEF/GMF using the former OmniModeling project base, take a look at the proposal we are working on. Mariot Chauvin and Chris Aniszczyk are helping me through, thank you so much guys!

Comments and contributions are welcome

I should acknowledge Simone D.J. Barbosa for the kind support during the OmniModeling project, as well as my colleagues at the Semiotic Engineering Group of PUCRio.

Omnimodeling: Multi-Agent Recognition from Ugo Sangiorgi on Vimeo.

HAL and Dr. David Bowman discussing a GMF model
HAL sees Java Perspective:

This is a normal GMF generated GEF editor with Square, Triangle and Connection tools.
I’d added another tool called Sketch on the palette, so at this point I’m able to feedback to the user the sketch being performed, and detect what is meant by comparing the sketch with a using the Levenshtein algorithm for string distance. I’m also working on a Multi-agent approach for both recognition and learning of sketches.

Omnimodeling for GMF (in progress…) from Ugo Sangiorgi on Vimeo.

So in a rough way, GMF provides the ability for a user to create/edit/view a XML model containing Squares and Triangles (in this case) but in a graphic way. What OmniModeling tries to accomplish is to add another layer on top of this funcionality and let the user draw the model freely, by hand.

The next step is not only to recognize the shape, but grasp the size of the element being added (by comparing distance between corners maybe) and set it automatically.

.

Instead of clicking on the palette, the user just select the Free Drawing Tool and sketch freely on the editor. A given layer could recognize the points and add the relative element to the diagram.
Also, if the recognizer didnt get the sketch upfront, there could be a mechanism that let the user tell the program what he/she meant with that sketch, lets say a popup menu that let the user choose what element is meant by the sketch.

This could be a nice feature to have on GMF. You model your domain, works the Graphical model, the Tooling model, and there could be also a Sketch model for you to create, binding gestures to elements.

I’m starting a prototype. I tought it might be called OmniModeling. The modeller of everything