I could do this just when I modify a source file.
But I never think about checking it, and this is painful. The best solution is to update these mentions at the beginning of every year, in all the files, in a single row. And to perform this bulk task, I use my favorite IDE: Eclipse.

There are 2 kinds of mentions to update.
But the path is the same. It starts by checking out all the projects in the workspace, followed by Search > File…

Last Year Mentions

The first kind of mention is quite simple, as an example:

Copyright (c) 2012, Linagora

It means the file was created in 2012.
The search options are quite trivial here. Disable the Regular expression checkbox. Search any file (*, the star symbol). Type in the search text and click Replace… Once the search has been performed, type in the replacement text in the shown dialog.

Copyright (c) 2012-2013, Linagora

Multi-Year Mentions

The second kind of mention covers several years, e.g.

Copyright (c) 2009-2012, Linagora

We are going to replace all the occurrences once again. But the search box will rely on more advanced options. Make sure Regular expression is checked and search for…

Copyright \(c\) 20(\d\d)-2012, Linagora

Remember to click Replace… and not Search…

Then, add the following replacement text.

Copyright (c) 20$1-2013, Linagora

And voilà! All your copyright mentions have been updated. And you can save them in a single commit.
Coupled to build rules (e.g. with Sonar) and the right template files for your source code, you will not have to think about copyright mentions before next year.

SWT and JFace can also be used outside Eclipse.
However, they are not usable as libraries with Maven. Only as bundles with Tycho. This is because Eclipse releases are not hosted on Maven repositories but on p2 repositories. The Maven plugin called Tycho allows Maven, among other things, to rely on p2 repositories. But it is intended to build OSGi applications.

Hopefully, there is now a regular Maven repository that hosts SWT and JFace bundles as libraries.
Thus, they can be used with Maven, in non-Osgi projects. This repository is available at this address: http://swt-repo.googlecode.com/svn/repo/

To use these libraries in a non-Osgi project, add the repository to your POM.

<repositories>
   <repository>
      <id>swt-repo</id>
      <url>https://swt-repo.googlecode.com/svn/repo/</url>
   </repository>
</repositories>

If you only want to use SWT, add the SWT library that fits your operating system.
As an example, for Windows x64.

<dependencies>
   <!-- SWT -->
   <dependency>
      <groupId>org.eclipse.swt</groupId>
      <artifactId>org.eclipse.swt.win32.win32.x86_64</artifactId>
      <version>3.7.2</version>
   </dependency>
</dependencies>

If in addition you want to use JFace and Eclipse extensions for JFace (ListDialog, ListeSelectionDialog…), add the following dependency. This will add JFace by transitivity.

<dependencies>
   <!-- JFace + Eclipse's JFace extensions -->
   <dependency>
      <groupId>org.eclipse.ui</groupId>
      <artifactId>org.eclipse.ui.workbench</artifactId>
      <version>3.7.1.v20120104-1859</version>
   </dependency>
</dependencies>

If you need JFace but not its Eclipse extensions, add instead…

<dependencies>
   <!-- JFace dependencies -->
   <dependency>
      <groupId>org.eclipse.jface</groupId>
      <artifactId>org.eclipse.jface</artifactId>
      <version>3.7.0.v20110928-1505</version>
   </dependency>
</dependencies>

Other versions of SWT and JFace should be added to the repository.
Another solution could be based on Tycho. But so far, I have not found any solution. I started a thread about this on the Tycho-user mailing list.

Anyway, the solution described above will fit all the Maven versions.
A Tycho-based solution would only work with Maven3 (but would avoid duplicating the libraries).

I let some traces in this article (as an example and for me, for later).
Notice that the apply command did not work with EGit, I had to use the command line. I guess it will be fixed in a future version.

• First, we need a patch, given as a diff file, e.g. in a bug entry.
• As a committer, you should apply and check this patch. So, you first need to copy the patch in your (cloned) Git repository.
• Get some stats about the patch :

  git apply --stat myPatchFile

• Make sure the patch can be applied :

  git apply --check myPatchFile

• Apply the patch :

  git apply myPatchFile

• Delete the patch file.

Then, you can check that the patch works and then commit it, before pushing the modification.
One important thing is to keep the author’s name in the commit. The author and the committer are different. And both can be kept in the commit and in the history. Here is an example in the command line:

git commit -a --author="authorUsername <author.mail.address@sth.com>"

After the push, both the author and commiter names will appear in the repository.

I don’t know if everyone in Eclipse projects uses this feature, but from the community perspective, this is very interesting (IMO).