Screenshot of the Week: C++ Refactoring

by waynebeaton at April 28, 2015 03:08 PM

My son has just finished up his first year of software development at college. In a demonstration of what I consider cruel and unusual punishment, his first programming language is C++ and his first development environment is Visual C++. I have to assume that the version of Visual C++ that the college unleashed on these unsuspecting students is some sort of reduced-functionality version, because it seems to lack certain functionality that I consider pretty basic, like refactoring.

I learned C years ago, and did some honest-to-goodness work using it, but never did take the time to learn C++, so I used this as an opportunity to close that gap. Naturally, I decided to learn C++ using the Eclipse C/C++ Development Tools (CDT).

The CDT provides some excellent refactoring support.

Renaming a C++ method

Renaming a C++ method

Keep the just-sorting-this-stuff-out nature of the work when considering the code in the screenshot.

This screenshot shows the first stage of the Rename refactoring. As expected, this changes the name of the method (function), the declaration in the header file, and any code that calls it. There are many other refactorings available, including ones that extract constants, fields, and functions. Note the Call Hierarchy view on the bottom view stack: use this view to find out how your function interacts with the world (calls and callers). There’s all sorts of cool stuff available.

The Eclipse CDT project has participated in every simultaneous release we’ve done and so it’s no surprise that they’re an important part of the Eclipse Mars Release. Help us test Eclipse Mars by downloading and testing a milestone build.

Epilogue: To my son’s instructors’ credit, they did avoid complex memory management issues, and did get the students to produce some pretty cool and very playable games featuring two-dimensional graphics. Those students that survive the programme are probably going to do well…

Caveat: I never really took the time necessary to properly research the functionalities provided by Visual C++ or spend any significant time using it. I have to assume that it’s very functional once you get comfortable with it.



by waynebeaton at April 28, 2015 03:08 PM

@ApacheParquet Graduating and Mesos with Siri

by Chris Aniszczyk at April 28, 2015 02:52 PM

The last week for me has been fun in open source land outside of me getting two of my wisdom teeth pulled out of my face. On the bright side, I have some pain killers now and also, two notable things happened. First it was nice to finally graduate Parquet out of the Apache Incubator:

It’s been a little over two years since we (Twitter) announced the open source columnar storage project with Cloudera. It’s a great feeling to see a plan come together and see this project grow over the years with 60+ contributors while hitting the notable achievement of graduating out of the Apache incubator gauntlet. If there’s any lesson here for me, it’s much easier to build an open source community when you do it an independent fashion with at least someone else in the beginning (thanks Cloudera).

Another notable thing that happened was that Apple finally announced that they are using Mesos to power Siri’s massive infrastructure.

In my experience of building open source communities, there are usually your public adopters and private adopters. There are companies that wish to remain private about the software they use at times and that’s fine, it’s understandable when it can be viewed as a competitive advantage. The challenge is how you work with these private adopters when they use an open source project of yours while wanting to collaborate behind the scenes.

Anyways, it’s a great feeling to see Apple opening up a bit about their infrastructure and open source usage after working with them for awhile. Hopefully this is a sign of things to come from them. Also, it would be nice if Apple just updated Siri so when you ask what Mesos is, it replies with a funny response and proclaims her love of open source infrastructure technology.

Overall, it’s been a great last week.


by Chris Aniszczyk at April 28, 2015 02:52 PM

JBoss Tools Alpha2 for Eclipse Mars

by maxandersen at April 28, 2015 10:55 AM

Alpha 2 build for Eclipse Mars M6 is now available at Alpha2 download.

Installation

This version of JBoss Tools targets Eclipse Mars 4.5 (M6).

We recommend using the Eclipse 4.5 JEE Bundle since then you get most of the dependencies preinstalled.

Once you have installed Eclipse, you use our update site directly:

http://download.jboss.org/jbosstools/mars/development/updates/core/

Note: Marketplace entry and Integration Stack tooling will become available from JBoss Central at a later date.

What is new ?

Easy Import/Open of projects

We have included our incubation project at Eclipse that makes importing and opening of projects much easier than default Eclipse. No longer do you need to know or guess at which of many import wizards are the right one. With this you just use menu:File[Import Project from Folder], point it to a folder and it will auto-detect the type of project, imports ann configure it as best as it can.

easyimport filemenu

Once started it will recursively scan the selected folder and report which directories it found.

easyimport wizard

We included this incubation feature to get early feedback - please do give it a try and let us know if it works great or if we detected some projects "badly".

OpenShft v3

Our OpenShift integration now allow you to connect to OpenShift 3 in addition to the existing OpenShift 2 support.

connection wizard server type

Once connected you can browse the OpenShift/Kubernetes data for your application/projects.

validation

Note: OpenShift v3 is not available from openshift.com to try at this point in time. If you want to try use it you can follow the instructions at OpenShift Origin sample app.

Java EE 7 Batch wizards, content assist, validation and refactoring

In Alpha 1 we introduced support for Java EE 7 batch specification and now extending this support with a wizard, content assist, linked navigation, searching and refactoring of Batch elements.

validation

WildFly 9

We’ve added native WildFly 9 runtime detection and server support. You no longer need to use the WildFly 8 adapter and detection will work correctly now.

Content assist for AngularJS Expressions

When editing AngularJS single-page html (not templates) the html editor now communicates with the preview to provide content assist for angularjs expressions.

angular

Custom HTML Tag validation

There is now a quickfix for marking custom HTML5 elements to be ignored in validation.

validation

Note: this is not specific to JBoss Tools, it is built into Eclipse M6

Next steps

With Alpha2 out we are heading towards a Beta1.

In Beta1 we are targeting including:

  1. OpenShift v3 support for templates

  2. Docker Tooling

  3. Better JavaScript content assist

  4. Making project imports in Eclipse even simpler

  5. And more…​

As always, ask/suggest away and we’ll keep you posted!

Have fun!

Max Rydahl Andersen
@maxandersen


by maxandersen at April 28, 2015 10:55 AM

Kudos to Tony McCrary for his Eclipse JDT icon work

by Lars Vogel at April 28, 2015 07:50 AM

Tony McCrary continues his awesome icon contributions.

This time he managed to re-create the JDT icon set so that the JDT icon look good on a dark background. This work started in January 2014 (!!!) and as the JDT developer are under a high pressure, Tony even generated a gallery to compare the old gif and the new png icons to make the review easier for them.

On the left you see the old gif icons, the right are the new png icons.

JDT icons

JDT icons

See JDT icon work Bug for details.

Many thanks from me personally and the platform.ui team to Tony.


by Lars Vogel at April 28, 2015 07:50 AM

Call 4 papers - where is an open source app?

by Krzysztof (Chris) Daniel (noreply@blogger.com) at April 27, 2015 03:45 PM

I was recently submitting a number of conference proposal related to my current area of interest, and one thing that struck me was the lack of a rock-solid, easy to use call-4-paper application.

Each time I wanted to propose a talk to a conference I had to create a profile, confirm e-mail address, provide a lot of details and only then I was allowed to fill actual talk details.

"Don't reinvent the wheel!" they say.

So, why, WHY each conference organizers decide to write their OWN c4p application? That makes no sense.

The internet proposal submission is no longer a feature that will distinguish your conference.

That's why I am starting my new, open source application for accepting conference talks. It will not be fancy, but it will work.

Clone it, run it, modify it, USE it.

Contribute if you wish.







by Krzysztof (Chris) Daniel (noreply@blogger.com) at April 27, 2015 03:45 PM

Using the Xtend language for M2M transformation

by Andreas Graf at April 26, 2015 02:34 PM

In the last few month, we have been developing a customer project that centers around model-to-model transformation with the target model being AUTOSAR.

In the initial concept phase, we had two major candidates for the M2M-transformation language: Xtend and QVTO. After doing some evaluations, we decided that for the specific use case, Xtend was the technology of choice.

 

TopicExplanation
ComfortXtend has a number of features that make writing model-to-model-transformations very concise and comfortable. The most important is the concise syntax to navigate over models. This helps to avoid loops that would be required when implementing in Java


val r = eAllContents.filter(EcucChoiceReferenceDef).findFirst[
shortName == "DemMemoryDestinationRef"]
}
Traceability / One-Pass TransformationXtend provides so-called "create" methods for creating new target model elements in your transformation. The main usage is to be able to write efficient code without having to implement a multi-pass transformation. This is solved by using an internal cache to return the same target object if the method is invoked for the same input objects more than one time


However, the internally used caches can also be used to generate tracing information about the relationship from source to target model. We use that both for

  • Writing out trace information in a log file

  • Adding trace information about the source elements to the target elements


Both features have been added to the "plain" Xtend, because we can use standard Java mechanisms to access them.


In addition, we can also run a static analysis to see what sourcetarget metaclass combinations exist in our codebase.
PerformanceXtend compiles to plain Java. This gives higher performance than many interpreted transformation languages. In addition, you can use any Java profiler (such as Yourkit, JProfiler) to find bottlenecks in your transformations.
Long-Term-SupportXtend compiles to plain Java. You can just keep the compiled java code for safety and be totally independent about the Xtend project itself.
Test-SupportXtend compiles to plain Java. You can just use any testing tools (such as JUnit integration in Eclipse or mvn/surefire). We have extensive test cases for the transformation that are documented in nice reports that are generated with standard Java tooling.
Code CoverageXtend compiles to plain Java. You can just use any code coverage tools (such as Jacoco)
DebuggingDebugger integration is fully supported to step through your code.
ExtensibilityXtend is fully integrated with Java. It does not matter if you write your code in Java or Xtend.
DocumentationYou can use standard Javadocs in your Xtend transformations and use the standard tooling to get reports.
ModularityXtend integrates with Dependency Injection. Systems like Google Guice can be used to configure combinations of model transformation.
Active AnnotationsXtend supports the customization of its mapping to Java with active annotations. That makes it possible to adapt and extend the transformation system to custom requirements.
Full EMF supportThe Xtend transformations operate on the generated EMF classes. That makes it easy to work with unsettable attributes etc.
IDE IntegrationThe Xtend editors support essential operations such as "Find References", "Go To declaration" etc.

The Xtend syntax on the other hand is not a language based on any standard. But it’s performance, modularity and maintenance features are a strong argument for adding it as a candidate for model transformations.


by Andreas Graf at April 26, 2015 02:34 PM

Eclipse Hackathon Hamburg – Greetings

by eselmeister at April 25, 2015 10:35 AM

Yesterday, we had our second Eclipse Hackathon in Hamburg, Germany. It was a great meeting :-).

Hackathon-2015-Q2

Stay tuned, the next Hackathon will be in approx. three month.


by eselmeister at April 25, 2015 10:35 AM

Save the date: Eclipse DemoCamp Mars June 23rd 2015

by Maximilian Koegel and Jonas Helming at April 24, 2015 10:09 AM

We are pleased to announce the Eclipse DemoCamp Munich 2015 on June 23rd.
The DemoCamp Munich is one of the biggest DemoCamps worldwide and, therefore, an excellent opportunity to showcase all the cool, new, and interesting technology being built by the Eclipse community. This event is open to Eclipse enthusiasts who want to demonstrate what they are doing with Eclipse. The aim is to create an opportunity for you to meet other Eclipse fans in Munich in an informal setting.

We are offering 110 seats, however we usually receive around 200 registrations. Pre-registration is mandatory, please be sure to do so as soon as possible. To give everyone the same chance, registration for the event will start in one week, on May 4th at exactly 2pm. There you’ll also find detailed information on the location, time and more.
https://wiki.eclipse.org/Eclipse_DemoCamps_Mars_2015/Munich

We are looking forward to your registration and seeing you in June!

A big thanks to our sponsors: BSI Business Systems Integration AG, EclipseSource München GmbH, Eclipse Foundation and Capgemini Deutschland GmbH


TwitterGoogle+LinkedInFacebook

Leave a Comment. Tagged with democamp, eclipse, democamp, eclipse


by Maximilian Koegel and Jonas Helming at April 24, 2015 10:09 AM

Lightweight Dialogs in e4 & JavaFX

by Tom Schindl at April 23, 2015 02:25 PM

I’ve just checked in the initial bits to use lightweight dialogs in your e4 + JavaFX applications. You can see it in action in the short video from below

Useage is fairly simple. First you need to have dialog implementation like this:

static class OpenProjectDialogImpl extends TitleAreaDialog {
  private ListView<Project> list;
  private final CommandService cmdService;

  @Inject
  public OpenProjectDialogImpl(Workbench workbench, 
    CommandService cmdService, @Service List<ProjectService> projectServiceList) {

    super("Open project", 
      "Open project", "Open an existing project");
    this.cmdService = cmdService;
    addDefaultButtons();
    setMaxWidth(500);
    setMaxHeight(500);
    setId("open-project-dialog");
		
    list = new ListView<>();
    list.setMinWidth(600);
    list.setCellFactory(v -> 
      new SimpleListCell<Project>( 
        p -> labelExtractor(p, projectServiceList), 
        p -> cssProvider(p,projectServiceList)));
    list.setItems(FXCollections.observableArrayList(
      workbench.getProjectList()));
    setClientArea(list);
  }
	
  @Override
  protected void handleOk() {
    if( list.getSelectionModel().getSelectedItem() != null ) {
      cmdService.execute("org.eclipse.fx.code.compensator.app.command.openproject", Collections.singletonMap("projectId", list.getSelectionModel().getSelectedItem().getProjectId()));
      super.handleOk();	
    }
  }
}

and displaying it is nothing more than:

public class OpenProjectDialog {
  @Execute
  public void open(LightWeightDialogService dialogService) {
    dialogService.openDialog(OpenProjectDialogImpl.class, ModalityScope.WINDOW);
  }
}

As you can see in the video you can choose how the dialog is opened & closed. This is done through an OSGi-Service of type LightweightDialogTransitionService:

@Component
public class FadeDialogTranstionServiceImpl extends FadeDialogTranstionService implements LightweightDialogTransitionService {
  @Override
  protected void configureFadeIn(FadeTransition transition) {
    super.configureFadeIn(transition);
    transition.setInterpolator(Interpolator.EASE_OUT);
  }
	
  @Override
  protected void configureFadeOut(FadeTransition transition) {
    super.configureFadeOut(transition);
    transition.setInterpolator(Interpolator.EASE_OUT);
  }
}


by Tom Schindl at April 23, 2015 02:25 PM

Developing for Cloud Foundry

April 23, 2015 02:07 PM

We are pleased to have a series of articles describing how developers can use Eclipse and Orion for developing Cloud Foundry applications.

April 23, 2015 02:07 PM

Font Icons for Eclipse Scout

by Matthias Zimmermann at April 23, 2015 09:08 AM

Today, web pages and web applications start to rely more and more on font icons. As clean and modern icons can help an application to get a professional look and feel we went through the little exercise to demonstrate how to use font icons in Eclipse Scout applications.

One of the most prominently used icon font on many web pages is Font Awesome. As the font contains hundreds of icons that are free to use even in commercial applications, it is ideally suited for demonstration purposes as well as productive use.

font_awesome_homepage

The reminder of the article describes the usage of such fonts for icons with Eclipse Scout.

To demonstrate the usage we added an icons and font icons form to the Scout Widget Application.

demoapp_fonticon

In the text below we will first talk about the general usage of icons in Scout application, and discuss how icons are provided to the application through icon provider services. Then the font icon provider services is introduced that allows to create Scout icons for individual characters from any true type font files.

How To Use Icons in Scout

Icons can be used for a number of UI components in Scout applications. They may be used for buttons, image fields, for smart fields entries, tree nodes and for table rows. To identify individual icons, its icon name/id can be used. The simplest way to figure out how to use icons in Scout applications is to follow the code of the Scout widget application.

For a concrete example we will look at the implementation for the button with the white arrow pointing to the right that is implemented in the icons form of the Scout widget application.

button_with_arrow

 

To find the corresponding code in the widget application, open the IconsForm and drill down to the ExamplesBox group box and locate the IconButton class. In method getConfiguredIconId the desired icon is specified as shown below. 

  @Order(4000.0)
  public class IconButton extends AbstractButton {
    ...

    @Override
    protected String getConfiguredIconId() {
      return AbstractIcons.WizardNextButton;
    }

    ....
  }

From this example we can see that a few icons come out of the box with the Scout framework. As every application has its own special needs, additional application specific icons may be located in the client plugin of the application. In the default case the corresponding image files may be placed in folder resources/icons of the client plugin. In the example of the Scout widget application the icon “star_yellow” is backed by image file star_yellow.png in the icon resource folder. This represents the simplest way to add your own icons to your application. Just put your icon image files into the folder resources/icons of the client plugin as in the case of the yellow_star icon.

However, designing good looking icons is time consuming and to get started quickly having a large amount of icons out of the box would be helpful. To take advantage of the fact that with the Font Awesome toolkit such a collection of high quality icons is available in the public domain, we can also write a specific icon provider that consumes the available icons from the Fontawesome true type font file at runtime.

The Font Icon Provider Service

Before we discuss the font icon provider service let us look at the general concept of icon provider service of the Scout framework. In Scout, icons are provided to the application through icon provider services. When a UI component needs to display an icon specified by its name, the Scout framework checks with the registered icon provider services to access the necessary image content.

At runtime, the icon name is fed into method getIconSpec of the first available service that implements the IIconProviderService interface. If the method returns null, the framework consults the next icon provider. This mechanism allows for the implementation of application specific icon provider services. There is one additional thing. To avoid the repeated generation of the image content, generated Icons are cached by the Scout framework. Instead of asking the icon provider services to create the content every time an icon is used, the framework first checks its cache, if an icon is already available from the cache, it will directly use this cached icon.

By writing a specific FontIconProviderService that converts characters from a true type font to Scout icons on the fly, font icons can be used along the traditional icons. To use font icons in the demo application only a few things are needed:

  • The font’s true type file (e.g. fontawesome-webfont.ttf) is located in folder resources/fonts of the client plugin
  • The alias information for the needed icons is specified in the icons.properties file (in folder resources/fonts)
  • The FontIconProvierService itself and its registration in the client’s plugin.xml

At startup of the FontIconProviderService, method initializeFonts is called through method initializeService that then loads the available true type fonts and properties file mentioned above. Using this information the icon provider service then returns the created font icons in method getIconSpec. The icon alias (IconId in the screenshot above) defined in the icons.properties file can either be used on its own or amended with various additional attributes:

  • Color (icon color, or icon background color if a background type is selected)
  • Size (true type font characters may be scaled to arbitrary sizes)
  • Background (to create inverted icons with a square or round background image)

In the example shown in the screenshot above, the icon specification is encoded into the string font:plane!#FAA635!128;fontawesome-webfont. This results in the search of alias “plane;fontawesome-webfont” in the properties file leading to the font’s character f072 that is then scaled to 128 pixels and colored using #FAA635.

To play around with the available options click on button “Sample Content” in the icons form of the widget demo application. There, you can change the icon id, the color, size and the background shape. When you switch the font from “fontawesome-webfont” to “cour”, you can also try to create an icon from a single letter (e.g. with the icon name “font:X!128;cour”).

Conclusion

In this post we have provided a quick introduction to the usage of icons in Scout applications and demonstrated how to use font icons in your own Scout applications. Using the provided FontIconProviderService you can now either use the discussed Fontawesome or use your own true type font files to extract font icons for your applications.

Project HomeForumWikiTwitter


by Matthias Zimmermann at April 23, 2015 09:08 AM

J2V8 2.2 New and Noteworthy

by Ian Bull at April 22, 2015 10:26 PM

I’m happy to announce the availability of J2V8 2.2 (2.2.1 actually). This release adds two important features: 1) Typed Arrays and 2) 64 Bit Windows support.

Typed Arrays

In Javascript, most arrays are untyped. That is, you can create an array and add anything to it.

var myStuff = [];
myStuff[0] = 42;
myStuff[1] = true;
myStuff[2] = "Strings";

A  few years ago, the Javascript community realized the need for a more efficient mechanism for working with binary data in WebGL. The result of this work were Typed Arrays. Typed Arrays are a continuous chunk of memory with a typed view onto it. The memory is managed by the underlying engine and they perform a lot better than regular Javascript arrays.

var buffer = new ArrayBuffer(256);
var i32 = new Int32Array(buffer);
i32[0] = 1;
i32[1] = 3;
i32[2] = i32[0] + i32[1];

In this example, an array buffer of 256 bytes is allocated. A view, rendering the data as an array of 32bit integers, is then projected onto that buffer. Because the memory is continuous and the types are known, the operations (such as add in this case) perform much faster.

J2V8 2.2 supports the creation of Typed Arrays. You can even access the contents of the arrays, in bulk, from Java using the getIntsMethod (getDoubles and getBoolean for doubles and booleans).

V8 v8 = V8.createV8Runtime();
V8Array result = v8.executeArrayScript("var buffer = new ArrayBuffer(256);\n"
 + "var i32 = new Int32Array(buffer);\n"
 + "i32[0] = 1;\n"
 + "i32[1] = 3;\n"
 + "i32[2] = i32[0] + i32[1];\n"
 + "i32;");
int[] ints = result.getInts(0, 3);
System.out.println("Result: " + ints[0] + ", " + ints[1] + ", " + ints[2]);
result.release();
v8.release();

64 Bit Windows Support

J2V8 now supports 64 bit Windows. The binaries have pushed to Maven Central and can be consumed using the following dependency.

<dependency>
  <groupId>com.eclipsesource.j2v8</groupId>
  <artifactId>j2v8_win32_x86_64</artifactId>
  <version>2.2.1</version>
  <scope>compile</scope>
</dependency>

For more news about J2V8, follow me on Twitter.


TwitterGoogle+LinkedInFacebook

Leave a Comment. Tagged with j2v8, j2v8


by Ian Bull at April 22, 2015 10:26 PM

Screenshot of the Week: Git Repositories View

by waynebeaton at April 22, 2015 02:40 PM

The Git Repositories view (which I tend to add to whatever perspective I’m working in) provides pretty much one-stop-shopping for most of my repository activity needs.

The Git Repositories View in Eclipse Mars

The Git Repositories View in Eclipse Mars

In this screenshot, you can see a handful of local branches that I obviously need to spend a few minutes cleaning up, and some stashed commits. Direct access to tags, references, and remotes is also provided. You can also work directly with files in the working directory if you opt to not create a project in the workspace.

I generally don’t tweak the default configuration of any software (I’m lazy that way), but I find that in Eclipse I’m starting to move the perspective launcher down to the bottom left of the window, turn the tool bar off (though not in this screenshot), and clear out views from the right side of the window (to make more room for the editor). What are your favourite tweaks?



by waynebeaton at April 22, 2015 02:40 PM

Setting profiles in the preferences dialog

by eselmeister at April 22, 2015 08:45 AM

I wondered if it’s possible to allow users to work with different profile settings. That would be beneficial, cause users then don’t have to remember different plug-in settings for various analytical scenarios. Eclipse offers to export/import *.epf files, hence there should be a way to automate this. Here’s the solution:

Profiles

The preference service allows to export the currently used preferences:

public static void exportProfile(File file, IPreferenceFilter[] preferenceFilters) throws FileNotFoundException, CoreException {

	FileOutputStream fileOutputStream = new FileOutputStream(file);
	IPreferencesService preferencesService = Platform.getPreferencesService();
	preferencesService.exportPreferences(preferencesService.getRootNode(), preferenceFilters, fileOutputStream);
}

Importing stored preferences works similarly:

public static IStatus importProfile(File file) throws FileNotFoundException, CoreException {

	FileInputStream fileInputStream = new FileInputStream(file);
	IPreferencesService preferencesService = Platform.getPreferencesService();
	return preferencesService.importPreferences(fileInputStream);
}

It depends on you where to store the preference profiles. There’s only a small drawback when loading a profile within the preferences dialog. All pages are displaying the old and not updated profile values. Hence, the dialog needs to be restarted. This can be automated too from within a page.

IPreferencePageContainer preferencePageContainer = getContainer();
if(preferencePageContainer instanceof PreferenceDialog) {
	PreferenceDialog preferenceDialog = (PreferenceDialog)preferencePageContainer;
	preferenceDialog.close();
	preferenceDialog = PreferencesUtil.createPreferenceDialogOn(null, null, null, null);
	preferenceDialog.open();
}

The more better it would be reload all page values without re-opening the preference dialog. But I didn’t find a way how to do it. Anyhow, it works so far.


by eselmeister at April 22, 2015 08:45 AM

Making the Text Editor to be the Default One for All Unknown Files in Eclipse

by Kaloyan Raev (noreply@blogger.com) at April 22, 2015 06:16 AM

Eclipse users usually work with many different file types. Some of the file types may be opened by default in an external editor instead of in the Eclipse workbench. This happens if Eclipse has no editor available to handle that particular file type, but there is one installed in the operating system. In such case Eclipse assumes that it is better for the user to have the file opened in the external system editor.

Lots of users are quite annoyed by this behavior, especially when it comes to text-based files. They would prefer to have the file opened in the plain text editor of Eclipse instead of switching the context to the external program. Unfortunately, there is no easy way to change this in the preference settings. It's possible to associate a specific file extension with the plain text editor, but this must be done separately for every file extensions. There is no way to say "all text files of unknown type should open in the text editor".

Here comes the Default Text Editor plugin. It takes advantage of the Editor Association Override extension point introduced in Eclipse 3.8. When the plugin is installed it will change the default behavior of Eclipse and will opened all text files of unknown type in the plain text editor. Binary files like images may still be opened in an external system editor. As simple as that.

The plugin is available on the Eclipse Marketplace. It can also be installed through an update site. More info is available on the GitHub project.

by Kaloyan Raev (noreply@blogger.com) at April 22, 2015 06:16 AM

$150 Bug Bounty for Fixing a Dark Theme Issue

by Kaloyan Raev (noreply@blogger.com) at April 21, 2015 06:54 PM

Zend Studio is an IDE based on the Eclipse Platform. The dark theme is an important feature and is very popular among PHP developers. The most annoying issue with the dark theme, we have at the moment, is that the expand/collapse toggle in trees is almost invisible on Windows, because it seems to be unaffected by the dark theme coloring. See Eclipse bug 434201 for details.



We decided to put some money on the table with the hope that someone will step in and fix this bug. This will benefit not only Zend Studio users, but all Windows users in the Eclipse ecosystem who want to use the dark theme.

We created a $150 bug bounty on the FreedomSponsors crowd-funding platform. Follow this link to open the sponsored issue. Since this is a crowd-funding platform, anyone else who is ready to give some money for resolving this issue is welcome to do it, so the offer becomes more attractive.

UPDATE. The bug has been fixed within days and it will be delivered with the Mars M7 milestone. Thanks to Fabio Zadrozny for his great work. Kudos to Lars Vogel for adding $100 more to the bounty.

by Kaloyan Raev (noreply@blogger.com) at April 21, 2015 06:54 PM

Gendoc v0.5 released

by Tristan FAURE (noreply@blogger.com) at April 21, 2015 11:24 AM

Gendoc is officially an eclipse project and first official release is now available.
Gendoc is a template based technology allowing generation of OpenXML (Word) and Open Document (OpenOffice, LibreOffice) documents from EMF Models/XML using Acceleo language. Gendoc is currently industrially used in several critical systems company (space, avionics).

To start working with Gendoc and Luna please find update site in downloads section : http://www.eclipse.org/gendoc/downloads/download.php

Documentation and tutorials are available here : http://www.eclipse.org/gendoc/documentation/documentation.php

For any information or questions feel free to use links referenced on community section.


by Tristan FAURE (noreply@blogger.com) at April 21, 2015 11:24 AM

SWT Development, a comprehensive guide. (SWT -> Gtk)

by Leo Ufimtsev at April 20, 2015 07:18 PM

I typed up a comprehensive guide on SWT Development (Gtk side).

img_2015_04_20__11_15_12

It covers:
– SWT Develeper Setup.

– Navigating SWT code base.

– Building SO images to run latest master.

– Adding functions to OS.java.

– Compining and testing various Gtk Versions.

– Diagrams for complex workflows and detailed explanations.

Link: http://leoufimtsev.github.io./org/swt-dev.html

Please feel free to post questions & feedback into comments.



by Leo Ufimtsev at April 20, 2015 07:18 PM

Shared blog for EclipseSource Munich

by Maximilian Koegel at April 20, 2015 04:39 PM

To make it simpler for you to follow our blog posts from EclipseSource Munich we will now use a joint blog for all topics related to our work in Munich. This means there will be less posts that appear on my blog since I will post many things on the new Blog. All posts on the new blog are announced on the Twitter Account and Google+ page, see details below:

New Blog: http://eclipsesource.com/blogs/author/helmingkoegel

Twitter: https://twitter.com/EclipseSourceM

Google+: https://plus.google.com/105940428433807258305/posts

See you on the new blog!

 Shared blog for EclipseSource Munich


TwitterGoogle+LinkedInFacebook

Leave a Comment. Tagged with emf, modeling, Munich, emf, modeling, Munich


by Maximilian Koegel at April 20, 2015 04:39 PM

Andmore 0.5-M1 Released

by kingargyle at April 20, 2015 02:05 PM

Screen Shot 2015-04-19 at 4.44.52 PM

Android development using eclipse has taken a step forward today.  The first stable milestone release is ready for you, the user community to kick the tires, and start to use for your development.  Full details can be found in the New and Noteworthy section for the release notes.

There is a p2 site for your installation needs, and it is recommended that you not install both Android Developer Tools and Andmore into the same IDE.

http://download.eclipse.org/andmore/milestone/0.5-M1/

Add the above url to your available software sites.

Andmore contains all the functionality and features of Android Developer Tools, plus a lot more.    Also, thanks to Ricardo Gladwell for updating the m2e-android plugin to support Andmore.  This means that if you are using maven already, you can continue to do so with Andmore to continue developing Android applications and manage your dependencies.  The p2 site for maven support is:

http://rgladwell.github.io/m2e-android/updates/master/

So what about Gradel support and the the android gradle plugin?  Right now this is targeted for 0.5-M2.   There is a lot of stuff that needs to occur in order for this to happen.  For one thing, AAR support is necessary.   We also need to look into what extension points that the Buildship project will offer.  Will Andmore need to provide any extension points to allow Maven and Gradel to have more control over the build process?

Limitations with the current Andmore release:

  • No AAR support
  • No Gradel support
  • Android API 22 has limited support.  The only piece that may give you an error message is the GUI Layout editor.  If this happens change the API level in the editor from 22 to 21 or lower.

There is plenty to do yet, and the project is very open to contributions from the community.  If you would like to help out with any of the remaining work, do not hesitate to fork the repo on Github, and submit a pull request.   Andmore will be what the community makes it.  Bugs and Feature requests can be opened at:

https://bugs.eclipse.org/bugs/enter_bug.cgi?product=andmore



by kingargyle at April 20, 2015 02:05 PM