A brief list of features already implemented in the new EAP includes:

• Continued work on UI changes (Project View, run/debug toolwindows UI redesigned);

• Subversion 1.7 support (work in progress);
• Performance improvements in Git and Perforce integration;
• New Coverage view;
• New tree-based File Structure Popup;
• Improved popup for controlling Git branches (checkout, compare, delete, multi-root support);
• Highlighting of unused public members in Groovy code;
• Extract Closure refactoring for Groovy;
• New Flex project structure UI (work in progress);
• Spring support improvements;
• Gradle project synchronization support (work in progress);
• Android lint tool integration;
• Magic Constant inspection and code completion;
• Possibility to run JUnit or TestNG tests for any selection of classes or methods

In the coming weeks we plan to publish blog posts describing each of the new features in more detail. And for the time being, you can download IntelliJ IDEA 11.1 EAP try them out for yourself.

As always, your feedback is welcome in the issue tracker.

Note that this EAP cycle does not include 30-day time-limited licenses in each build. In order to use these builds, you need to have a valid license for IntelliJ IDEA 11.

This update fixes some most annoying bugs and performance problems found. Check out the full release notes for the list of resolved issues and download the update. If you’re already running version 11 (or 11.0.1) use the “Check for Update” action from the IDE and install the patch.

Develop with pleasure and stay tuned for exciting news coming soon.
-The IntelliJ IDEA Team

You can download IntelliJ IDEA 11.0.2 Release Candidate from the EAP page.

• Perforce integration uses ‘p4 move’ command for moves and renames when available;
• Spring integration performance improvements;
• Other bugfixes listed in the release notes.

You can download the new build from the EAP page.

Do you know that when you search for file or class you can preview an image (Ctrl-Shift-I) or see a quick doc (Ctrl-Q)?

It is also possible to open multiple items in the editor (multiselect with Ctrl or Shift) or run multiple selected tests right from the search (Ctrl-Shift-F10).

And you can open all search results in the ‘Find’ tool-window to process them one by one later.

Did I mention your favorite feature? No? Please, share it with everyone!

Generally speaking there’s nothing special about Move refactoring, but in complex multi-module projects choosing a right folder may turn out harder than it seems to be. Well, not anymore it isn’t, and here’s the proof.

We’ll start with, invoking Move action by pressing F6 in editor, Project view or UML diagram (don’t forget to select your class/top-level function/whatever else first):

Here we specify the target package (thinking in terms of packages instead of directories is a lot more natural, isn’t it?). As we type, IntelliJ IDEA assists us with completion and highlights packages that don’t exist with red, which means they will be created on-the-fly, which is good, because we can start coding right away without preparing package structure in advance.

We can opt to searching for out-of-the-code usages (e.g. comments, string constants and properties files), and finally, if we need to move a class to a different source folder (e.g. to another module), all we need to to is to select an appropriate option! This way, after pressing Refactor or Preview we’ll be able to choose which module and source root to move to (current source root will be preselected):

And that’s it! No need to bother with directories anymore!

Of course, all changes can be previewed first, so that we can see the entire picture without making any actual changes, which is cool, because not all changes are safe. Press Preview and here we go:

All the usages of moved element grouped by type and location, plus we can easily exclude usages we don’t want modified.

Another interesting case is to move inner class to the top-level. This may be useful when some utility class has grown enough to deserve a separate file. Here’s an example:

Just as before, place the caret at the class and press F6:

Now accept the name and package of a new top-level class, and IntelliJ IDEA will take care about the rest.

We wish you safe refactoring, and keep watching this blog for the latest news!

Start it from “Tools” menu, complete Play! commands, use command history, analyze output.
Play! with pleasure!

Let us give you a brief overview of what you can do with it.

Sure, the first thing to start with is installation. Nothing complex here—go to File menu, open Settings, then click Plugins and Browse repositories (if you’re on Mac OS, the path is slightly different—you should look in IntelliJ IDEA, then Preferences, Plugins, and then Browse repositories). After you’re there, find ActionScript Profiler and install it.

Let’s play with this extremely simple Flex component to set an example.

As you can see, it’s a rather heavy computation implemented in Task.calculateResult() method that is invoked 1000 times in a cycle from clickHandler() function that handles the mouse click.

To start the profiling we open context menu for the main class and click Profile:

Once the application is built and started, an empty Profiling window opens. Let’s tell profiler to start collecting CPU usage data by clicking Start CPU Profiling.

Now switch to our application, click Calculate and wait for resulting popup to appear. Then, we need to go back to IDE and click Stop CPU Profiling to compute the results—and here they are!

Invoked functions table shows the list of called functions, with child nodes representing points from which parent node was called:

We can easily compare timings by sorting the table by self time or cumulative time (just click column header for that).

Note: Edit source action is available for every item either via context menu or with F4 keyboard shortcut, so you can go to source code directly from profiling results.

Merged callees table at the bottom shows all the functions that were called (directly or indirectly) from the function selected in the upper table. You can sort this table as well to compare every detail and expand items to drill down through the call chains.

This concludes today’s post about CPU profiling. We hope you enjoyed it. In the next posts we are going to take a look at memory profiling capabilities and memory leaks hunting techniques. Please report any problems to the bug tracker. Stay tuned!

Plugin is compatible with IntelliJ IDEA 11.0 and 10.5. It was tested with 32-bit Flash Player 9, 10 and 11 on Windows (32- and 64-bit), Mac OS (32-bit and 64-bit) and Linux (32-bit).

Profile with pleasure!

To upgrade to the new version, simply use the “Check for Update” action if you’re already running version 11, or grab the complete installer from the download page. And of course, the release notes for the new build are also available.

Happy New Year, and see you again in 2012!

IntelliJ IDEA helps you collecting all these items in one place — ‘Favorites’. It’s easy to add a file, a class or a method to the Favorites by simply pressing Alt+Shift+F. You can also drag and drop items to the Favorites.

And now with ‘Favorites’ being a separate tool-window, just press Alt+2 (or Cmd+2) whenever you need to access one of your precious items again.