Error enlarging buttons on eclipse - eclipse

Question

Hello im trying to enlarge my buttons on eclipse. I found this code on the web that suppose to fix it
but it keeps giving me the error
Error: Could not find or load main class testEclipse.FixIcons
Any idea what can i do?
Im pretty new at this .. thanks
package testEclipse;
import java.awt.Graphics2D;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipOutputStream;
import javax.imageio.ImageIO;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.GnuParser;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;
import org.apache.commons.io.IOUtils;
import org.apache.log4j.Logger;
import org.imgscalr.Scalr;
import com.mortennobel.imagescaling.AdvancedResizeOp;
import com.mortennobel.imagescaling.ResampleOp;
/**
* Small utility to double the size of eclipse icons for QHD monitors.
*
* #author David Levy
* #since 2014/04/10
*
*/
public class FixIcons {
private static final Logger logger = Logger.getLogger(FixIcons.class);
public static final void main(String[] args) {
try {
Options options = new Options();
options.addOption(new Option("b", "baseDir", true,
"This is the base directory where we'll parse jars/zips"));
options.addOption(new Option("o", "outputDir", true,
"This is the base directory where we'll place output"));
for (Option o : new ArrayList<Option>(options.getOptions())) {
o.setRequired(true);
}
GnuParser parser = new GnuParser();
CommandLine commandLine = parser.parse(options, args);
String baseDirArg = "D:\\things\\tools\\eclipse";
logger.info("Base directory: " + baseDirArg);
String outputDirArg = "D:\\things\\tools\\eclipsetmp";
logger.info("Output directory: " + outputDirArg);
File base = new File(baseDirArg);
if (!base.exists() || !base.canRead() || !base.isDirectory()) {
logger.error("Unable to read from base directory");
return;
}
File output = new File(outputDirArg);
if (!output.exists() || !output.canRead() || !output.canWrite()
|| !output.isDirectory()) {
logger.error("Unable to write to output director");
return;
}
if (base.list() == null || base.list().length == 0) {
logger.error("The base directory is empty");
return;
}
if (output.list() != null && output.list().length != 0) {
logger.error("The output directory is not empty");
return;
}
processDirectory(base, output);
} catch (ParseException e) {
logger.error("Unable to parse arguments: " + e.getMessage());
} catch (Exception e) {
logger.error("Unexpected error: " + e.getMessage(), e);
}
}
public static void processDirectory(File directory, File outputDirectory)
throws Exception {
logger.info("Processing directory [" + directory.getAbsolutePath()
+ "]");
for (File file : directory.listFiles()) {
if (file.isDirectory()) {
File targetDir = new File(outputDirectory.getAbsolutePath()
+ File.separator + file.getName());
logger.info("Creating directory: "
+ targetDir.getAbsolutePath());
targetDir.mkdir();
processDirectory(file, targetDir);
} else {
File targetFile = new File(outputDirectory.getAbsolutePath()
+ File.separator + file.getName());
if (file.getName().toLowerCase().endsWith(".zip")
|| file.getName().toLowerCase().endsWith(".jar")) {
logger.info("Processing archive file: "
+ file.getAbsolutePath());
ZipFile zipSrc = new ZipFile(file);
Enumeration<? extends ZipEntry> srcEntries = zipSrc.entries();
ZipOutputStream outStream = new ZipOutputStream(
new FileOutputStream(targetFile));
while (srcEntries.hasMoreElements()) {
ZipEntry entry = (ZipEntry) srcEntries.nextElement();
logger.info("Processing zip entry [" + entry.getName()
+ "]");
ZipEntry newEntry = new ZipEntry(entry.getName());
try {
outStream.putNextEntry(newEntry);
} catch (Exception e) {
if (!e.getMessage().startsWith("duplicate entry: ")) {
logger.error("error: ", e);
} else {
logger.info(e.getMessage(), e);
}
outStream.closeEntry();
continue;
}
BufferedInputStream bis = new BufferedInputStream(
zipSrc.getInputStream(entry));
if (ImageType.findType(entry.getName()) != null) {
processImage(zipSrc.getName() + "!/" + entry.getName(), bis, outStream);
} else {
IOUtils.copy(bis, outStream);
}
outStream.closeEntry();
bis.close();
}
zipSrc.close();
outStream.close();
} else if (ImageType.findType(file.getName()) != null) {
logger.info("Processing image: " + file.getAbsolutePath());
FileInputStream inStream = null;
FileOutputStream outStream = null;
try {
inStream = new FileInputStream(file);
outStream = new FileOutputStream(targetFile);
processImage(file.getName(), inStream, outStream);
} finally {
IOUtils.closeQuietly(inStream);
IOUtils.closeQuietly(outStream);
}
} else {
logger.info("Processing : " + file.getAbsolutePath());
FileInputStream inStream = null;
FileOutputStream outStream = null;
try {
inStream = new FileInputStream(file);
outStream = new FileOutputStream(targetFile);
IOUtils.copy(inStream, outStream);
} finally {
IOUtils.closeQuietly(inStream);
IOUtils.closeQuietly(outStream);
}
}
}
}
}
public static void processImage(String fileName, InputStream input,
OutputStream output) throws IOException {
logger.info("Scaling image: " + fileName);
boolean imageWriteStarted = false;
try {
BufferedImage out = ImageIO.read(input);
int outWidth = out.getWidth() * 2;
int outHeight = out.getHeight() * 2;
BufferedImage rescaledOut = createResizedCopy(out, outWidth, outHeight);
ImageIO.write(rescaledOut, ImageType.findType(fileName).name(),
output);
} catch (Exception e) {
if (imageWriteStarted) {
throw new RuntimeException("Failed to scale image [" + fileName
+ "]: " + e.getMessage(), e);
} else {
logger.error(
"Unable to scale [" + fileName + "]: " + e.getMessage(),
e);
IOUtils.copy(input, output);
}
}
}
private static BufferedImage createResizedCopy(BufferedImage originalImage, int scaledWidth, int scaledHeight) {
try {
// Resample failed - maybe the image was too small, try another way (Scalr)
BufferedImage scaledBI = Scalr.resize(originalImage, Scalr.Method.ULTRA_QUALITY, scaledWidth, scaledHeight);
return scaledBI;
} catch (RuntimeException e) {
return scale(originalImage, 2.0);
}
}
private static BufferedImage scale(BufferedImage source,double ratio) {
int w = (int) (source.getWidth() * ratio);
int h = (int) (source.getHeight() * ratio);
BufferedImage bi = getCompatibleImage(w, h);
Graphics2D g2d = bi.createGraphics();
double xScale = (double) w / source.getWidth();
double yScale = (double) h / source.getHeight();
AffineTransform at = AffineTransform.getScaleInstance(xScale,yScale);
g2d.drawRenderedImage(source, at);
g2d.dispose();
return bi;
}
private static BufferedImage getCompatibleImage(int w, int h) {
GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsDevice gd = ge.getDefaultScreenDevice();
GraphicsConfiguration gc = gd.getDefaultConfiguration();
BufferedImage image = gc.createCompatibleImage(w, h);
return image;
}
}