static final java.awt.Toolkit awtToolkit =

java.awt.Toolkit.getDefaultToolkit();

/** Command on Mac OS X, Ctrl on Windows and Linux */

static final int SHORTCUT_KEY_MASK =

awtToolkit.getMenuShortcutKeyMaskEx();

/** Command-Option on Mac OS X, Ctrl-Alt on Windows and Linux */

static final int SHORTCUT_ALT_KEY_MASK =

ActionEvent.ALT_MASK | SHORTCUT_KEY_MASK;

/** Command-Shift on Mac OS X, Ctrl-Shift on Windows and Linux */

static final int SHORTCUT_SHIFT_KEY_MASK =

ActionEvent.SHIFT_MASK | SHORTCUT_KEY_MASK;

/** Command-W on Mac OS X, Ctrl-W on Windows and Linux */

static public final KeyStroke WINDOW_CLOSE_KEYSTROKE =

KeyStroke.getKeyStroke('W', SHORTCUT_KEY_MASK);

static final String BAD_KEYSTROKE =

"'%s' is not understood, please re-read the Java reference for KeyStroke";

/**

static public int getButtonWidth() {

// Made into a method so that calling Toolkit methods doesn't require

// the languages to be loaded, and with that, Base initialized completely

return zoom(Integer.parseInt(Language.text("preferences.button.width")));

}

/**

static public KeyStroke getKeyStrokeExt(String base) {

String key = base + ".keystroke";

// see if there's an override in preferences.txt

String sequence = Preferences.get(key);

if (sequence != null) {

KeyStroke ks = KeyStroke.getKeyStroke(sequence);

if (ks != null) {

return ks; // user did good, we're all set

} else {

System.err.format(BAD_KEYSTROKE, sequence);

}

}

sequence = Language.text(key + "." + Platform.getName());

KeyStroke ks = KeyStroke.getKeyStroke(sequence);

if (ks == null) {

// this can only happen if user has screwed up their language files

System.err.format(BAD_KEYSTROKE, sequence);

//return KeyStroke.getKeyStroke(0, 0); // badness

}

return ks;

}

/**

static public JMenuItem newJMenuItemExt(String base) {

JMenuItem menuItem = new JMenuItem(Language.text(base));

KeyStroke ks = getKeyStrokeExt(base); // will print error if necessary

if (ks != null) {

menuItem.setAccelerator(ks);

}

return menuItem;

}

/**

static public JMenuItem newJMenuItem(String title, int what) {

JMenuItem menuItem = new JMenuItem(title);

menuItem.setAccelerator(KeyStroke.getKeyStroke(what, SHORTCUT_KEY_MASK));

return menuItem;

}

/**

static public JMenuItem newJMenuItem(Action action, int what) {

JMenuItem menuItem = new JMenuItem(action);

// Use putValue() instead of setAccelerator() to work with applyAction()

action.putValue(Action.ACCELERATOR_KEY,

KeyStroke.getKeyStroke(what, SHORTCUT_KEY_MASK));

return menuItem;

}

/**

static public JMenuItem newJMenuItemShift(String title, int what) {

JMenuItem menuItem = new JMenuItem(title);

menuItem.setAccelerator(KeyStroke.getKeyStroke(what, SHORTCUT_SHIFT_KEY_MASK));

return menuItem;

}

/**

static public JMenuItem newJMenuItemShift(Action action, int what) {

JMenuItem menuItem = new JMenuItem(action);

// Use putValue() instead of setAccelerator() to work with applyAction()

action.putValue(Action.ACCELERATOR_KEY,

KeyStroke.getKeyStroke(what, SHORTCUT_SHIFT_KEY_MASK));

return menuItem;

}

/**

static public JMenuItem newJMenuItemAlt(String title, int what) {

JMenuItem menuItem = new JMenuItem(title);

menuItem.setAccelerator(KeyStroke.getKeyStroke(what, SHORTCUT_ALT_KEY_MASK));

return menuItem;

}

static public JCheckBoxMenuItem newJCheckBoxMenuItem(String title, int what) {

JCheckBoxMenuItem menuItem = new JCheckBoxMenuItem(title);

menuItem.setAccelerator(KeyStroke.getKeyStroke(what, SHORTCUT_KEY_MASK));

return menuItem;

}

static public void addDisabledItem(JMenu menu, String title) {

JMenuItem item = new JMenuItem(title);

item.setEnabled(false);

menu.add(item);

}

/**

static public void applyAction(Action action, JButton button) {

button.setAction(action);

// use an arbitrary but unique name

String name = String.valueOf(action.hashCode());

button.getActionMap().put(name, action);

button.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW)

.put((KeyStroke) action.getValue(Action.ACCELERATOR_KEY), name);

}

/**

static public void setMenuMnemonics(JMenuItem... menu) {

if (Platform.isMacOS()) return;

if (menu.length == 0) return;

// The English is http://techbase.kde.org/Projects/Usability/HIG/Keyboard_Accelerators,

// made lowercase.

// Nothing but [a-z] except for '&' before mnemonics and regexes for changeable text.

final String[] kdePreDefStrs = {

"&file", "&new", "&open", "open&recent",

"&save", "save&as", "saveacop&y", "saveas&template", "savea&ll", "reloa&d",

"&print", "printpre&view", "&import", "e&xport", "&closefile",

"clos&eallfiles", "&quit", "&edit", "&undo", "re&do", "cu&t", "&copy",

"&paste", "&delete", "select&all", "dese&lect", "&find", "find&next",

"findpre&vious", "&replace", "&gotoline", "&view", "&newview",

"close&allviews", "&splitview", "&removeview", "splitter&orientation",

"&horizontal", "&vertical", "view&mode", "&fullscreenmode", "&zoom",

"zoom&in", "zoom&out", "zoomtopage&width", "zoomwhole&page", "zoom&factor",

"&insert", "&format", "&go", "&up", "&back", "&forward", "&home", "&go",

"&previouspage", "&nextpage", "&firstpage", "&lastpage", "read&updocument",

"read&downdocument", "&back", "&forward", "&gotopage", "&bookmarks",

"&addbookmark", "bookmark&tabsasfolder", "&editbookmarks",

"&newbookmarksfolder", "&tools", "&settings", "&toolbars",

"configure&shortcuts", "configuretool&bars", "&configure.*", "&help",

".+&handbook", "&whatsthis", "report&bug", "&aboutprocessing", "about&kde",

"&beenden", "&suchen", // de

"&preferncias", "&sair", // Preferências; pt

"&rechercher" // fr

};

Pattern[] kdePreDefPats = new Pattern[kdePreDefStrs.length];

for (int i = 0; i < kdePreDefStrs.length; i++) {

kdePreDefPats[i] = Pattern.compile(kdePreDefStrs[i].replace("&",""));

}

final Pattern nonAAlpha = Pattern.compile("[^A-Za-z]");

FontMetrics fmTmp = null;

for (JMenuItem m : menu) {

if (m != null) {

fmTmp = m.getFontMetrics(m.getFont());

break;

}

}

if (fmTmp == null) return; // All null menuitems; would fail.

final FontMetrics fm = fmTmp; // Hack for accessing variable in comparator.

final Comparator<Character> charComparator = new Comparator<>() {

final char[] baddies = "qypgjaeiouQAEIOU".toCharArray();

public int compare(Character ch1, Character ch2) {

// Discriminates against descenders for readability, per MS

// Human Interface Guide, and vowels per MS and Gnome.

float w1 = fm.charWidth(ch1), w2 = fm.charWidth(ch2);

for (char bad : baddies) {

if (bad == ch1) w1 *= 0.66f;

if (bad == ch2) w2 *= 0.66f;

}

return (int)Math.signum(w2 - w1);

}

};

// Holds only [0-9a-z], not uppercase.

// Prevents X != x, so "Save" and "Save As" aren't both given 'a'.

final List<Character> taken = new ArrayList<>(menu.length);

char firstChar;

char[] cleanChars;

Character[] cleanCharas;

// METHOD 1: attempt to assign KDE defaults.

for (JMenuItem jmi : menu) {

if (jmi == null) continue;

if (jmi.getText() == null) continue;

jmi.setMnemonic(0); // Reset all mnemonics.

String asciiName = nonAAlpha.matcher(jmi.getText()).replaceAll("");

String lAsciiName = asciiName.toLowerCase();

for (int i = 0; i < kdePreDefStrs.length; i++) {

if (kdePreDefPats[i].matcher(lAsciiName).matches()) {

char mnem = asciiName.charAt(kdePreDefStrs[i].indexOf("&"));

jmi.setMnemonic(mnem);

jmi.setDisplayedMnemonicIndex(jmi.getText().indexOf(mnem));

taken.add((char)(mnem | 32)); // to lowercase

break;

}

}

}

// Where KDE defaults fail, use an algorithm.

algorithmicAssignment:

for (JMenuItem jmi : menu) {

if (jmi == null) continue;

if (jmi.getText() == null) continue;

if (jmi.getMnemonic() != 0) continue; // Already assigned.

// The string can't be made lower-case as that would spoil

// the width comparison.

String cleanString = jmi.getText();

if (cleanString.startsWith("sketchbook → "))

cleanString = cleanString.substring(13);

if (cleanString.length() == 0) continue;

// First, ban letters by underscores.

final List<Character> banned = new ArrayList<>();

for (int i = 0; i < cleanString.length(); i++) {

if (cleanString.charAt(i) == '_') {

if (i > 0)

banned.add(Character.toLowerCase(cleanString.charAt(i - 1)));

if (i + 1 < cleanString.length())

banned.add(Character.toLowerCase(cleanString.charAt(i + 1)));

}

}

// METHOD 2: Uppercase starts of words.

// Splitting into blocks of ASCII letters wouldn't work

// because there could be non-ASCII letters in a word.

for (String wd : cleanString.split("[^\\p{IsAlphabetic}]")) {

if (wd.length() == 0) continue;

firstChar = wd.charAt(0);

if (taken.contains(Character.toLowerCase(firstChar))) continue;

if (banned.contains(Character.toLowerCase(firstChar))) continue;

if ('A' <= firstChar && firstChar <= 'Z') {

jmi.setMnemonic(firstChar);

jmi.setDisplayedMnemonicIndex(jmi.getText().indexOf(firstChar));

taken.add((char)(firstChar | 32)); // tolowercase

continue algorithmicAssignment;

}

}

// METHOD 3: Lowercase starts of words.

for (String wd : cleanString.split("[^\\p{IsAlphabetic}]")) {

if (wd.length() == 0) continue;

firstChar = wd.charAt(0);

if (taken.contains(Character.toLowerCase(firstChar))) continue;

if (banned.contains(Character.toLowerCase(firstChar))) continue;

if ('a' <= firstChar && firstChar <= 'z') {

jmi.setMnemonic(firstChar);

jmi.setDisplayedMnemonicIndex(jmi.getText().indexOf(firstChar));

taken.add(firstChar); // is lowercase

continue algorithmicAssignment;

}

}

// METHOD 4: Second wide-enough ASCII letter.

cleanString = nonAAlpha.matcher(jmi.getText()).replaceAll("");

if (cleanString.length() >= 2) {

char ascii2nd = cleanString.charAt(1);

if (!taken.contains((char)(ascii2nd|32)) &&

!banned.contains((char)(ascii2nd|32)) &&

fm.charWidth('A') <= 2*fm.charWidth(ascii2nd)) {

jmi.setMnemonic(ascii2nd);

jmi.setDisplayedMnemonicIndex(jmi.getText().indexOf(ascii2nd));

taken.add((char)(ascii2nd|32));

continue algorithmicAssignment;

}

}

// METHOD 5: charComparator over all ASCII letters.

cleanChars = cleanString.toCharArray();

cleanCharas = new Character[cleanChars.length];

for (int i = 0; i < cleanChars.length; i++) {

cleanCharas[i] = cleanChars[i];

}

Arrays.sort(cleanCharas, charComparator); // sorts in increasing order

for (char mnem : cleanCharas) {

if (taken.contains(Character.toLowerCase(mnem))) continue;

if (banned.contains(Character.toLowerCase(mnem))) continue;

// NB: setMnemonic(char) doesn't want [^A-Za-z]

jmi.setMnemonic(mnem);

jmi.setDisplayedMnemonicIndex(jmi.getText().indexOf(mnem));

taken.add(Character.toLowerCase(mnem));

continue algorithmicAssignment;

}

// METHOD 6: Digits as last resort.

for (char digit : jmi.getText().replaceAll("[^0-9]", "").toCharArray()) {

if (taken.contains(digit)) continue;

if (banned.contains(digit)) continue;

jmi.setMnemonic(KeyEvent.VK_0 + digit - '0');

// setDisplayedMnemonicIndex() unneeded: no case issues.

taken.add(digit);

continue algorithmicAssignment;

}

}

// Finally, RECURSION.

for (JMenuItem jmi : menu) {

if (jmi instanceof JMenu) setMenuMnemsInside((JMenu) jmi);

}

}

/**

static public void setMenuMnemonics(JMenuBar menubar) {

JMenuItem[] items = new JMenuItem[menubar.getMenuCount()];

for (int i = 0; i < items.length; i++) {

items[i] = menubar.getMenu(i);

}

setMenuMnemonics(items);

}

/**

static public void setMenuMnemonics(JPopupMenu menu) {

ArrayList<JMenuItem> items = new ArrayList<>();

for (Component c : menu.getComponents()) {

if (c instanceof JMenuItem) items.add((JMenuItem)c);

}

setMenuMnemonics(items.toArray(new JMenuItem[0]));

}

/**

static public void setMenuMnemsInside(JMenu menu) {

JMenuItem[] items = new JMenuItem[menu.getItemCount()];

for (int i = 0; i < items.length; i++) {

items[i] = menu.getItem(i);

}

setMenuMnemonics(items);

}

static public int getMenuItemIndex(JMenu menu, JMenuItem item) {

int index = 0;

for (Component comp : menu.getMenuComponents()) {

if (comp == item) {

return index;

}

index++;

}

return -1;

}

// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

static public Dimension getScreenSize() {

return awtToolkit.getScreenSize();

}

/**

static public Image getLibImage(String filename) {

ImageIcon icon = getLibIcon(filename);

return (icon == null) ? null : icon.getImage();

}

/**

static public ImageIcon getLibIcon(String filename) {

File file = Platform.getContentFile("lib/" + filename);

if (file == null || !file.exists()) {

Messages.err("does not exist: " + file);

return null;

}

return new ImageIcon(file.getAbsolutePath());

}

static public ImageIcon getIconX(File dir, String base) {

return getIconX(dir, base, 0);

}

/*

/**

static public ImageIcon getIconX(File dir, String base, int size) {

final int scale = Toolkit.highResImages() ? 2 : 1;

String filename = (size == 0) ?

(base + "-" + scale + "x.png") :

(base + "-" + (size*scale) + ".png");

File file = new File(dir, filename);

if (!file.exists()) {

return null;

}

// Not broken into separate class because it requires (and is

// optimized for) an image file, and the SVG version does not.

// Also moving away from images from files anyway. [fry 220501]

return new ImageIcon(file.getAbsolutePath()) {

@Override

public int getIconWidth() {

return Toolkit.zoom(super.getIconWidth()) / scale;

}

@Override

public int getIconHeight() {

return Toolkit.zoom(super.getIconHeight()) / scale;

}

@Override

public synchronized void paintIcon(Component c, Graphics g, int x, int y) {

ImageObserver imageObserver = getImageObserver();

if (imageObserver == null) {

imageObserver = c;

}

g.drawImage(getImage(), x, y, getIconWidth(), getIconHeight(), imageObserver);

}

};

}

/**

static public ImageIcon getLibIconX(String base) {

return getLibIconX(base, 0);

}

static public ImageIcon getLibIconX(String base, int size) {

return getIconX(Platform.getContentFile("lib"), base, size);

}

// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

static List<Image> iconImages;

/**

static public void setIcon(Frame frame) {

setIcon((Window) frame);

}

/**

static public void setIcon(Window window) {

if (!Platform.isMacOS()) {

if (iconImages == null) {

iconImages = new ArrayList<>();

final int[] sizes = { 16, 32, 48, 64, 128, 256, 512 };

for (int sz : sizes) {

iconImages.add(Toolkit.getLibImage("icons/app-" + sz + ".png"));

}

}

window.setIconImages(iconImages);

}

}

// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/**

static public ImageIcon renderIcon(String name, String color, int size) {

return renderIcon(Platform.getContentFile("lib/" + name + ".svg"), color, size);

}

/**

static public ImageIcon renderIcon(File file, String color, int size) {

Image image = renderMonoImage(file, color, size);

return (image != null) ? wrapIcon(image) : null;

}

static public ImageIcon wrapIcon(Image image) {

final int scale = Toolkit.highResImages() ? 2 : 1;

return new ImageIcon(image) {

@Override

public int getIconWidth() {

return Toolkit.zoom(super.getIconWidth()) / scale;

}

@Override

public int getIconHeight() {

return Toolkit.zoom(super.getIconHeight()) / scale;

}

@Override

public synchronized void paintIcon(Component c, Graphics g, int x, int y) {

ImageObserver imageObserver = getImageObserver();

if (imageObserver == null) {

imageObserver = c;

}

g.drawImage(getImage(), x, y, getIconWidth(), getIconHeight(), imageObserver);

}

};

}

static protected Image renderMonoImage(File file, String color, int size) {

String xmlOrig = Util.loadFile(file);

if (xmlOrig != null) {

StringDict replace = new StringDict(new String[][] {

{ "#9B9B9B", color }

});

return Toolkit.svgToImageMult(xmlOrig, size, size, replace);

}

return null;

}

/*

static public Image svgToImageMult(String xmlStr, int wide, int high, StringDict replacements) {

/*

// 2-pass version to avoid re-assigning identical colors

// (Otherwise, if a color is set to #666666 before #666666 is

// re-assigned to its new color, the swap will happen twice.)

for (StringDict.Entry entry : replacements.entries()) {

xmlStr = xmlStr.replace(entry.key, "$" + entry.key.hashCode() + "$");

}

for (StringDict.Entry entry : replacements.entries()) {

xmlStr = xmlStr.replace("$" + entry.key.hashCode() + "$", entry.value);

}

return svgToImage(xmlStr, highResMultiply(wide), highResMultiply(high));

}

/**

static private Image svgToImage(String xmlStr, int wide, int high) {

PGraphicsJava2D pg = new PGraphicsJava2D();

pg.setPrimary(false);

pg.setSize(wide, high);

pg.smooth();

pg.beginDraw();

try {

XML xml = XML.parse(xmlStr);

PShape shape = new PShapeJava2D(xml);

pg.shape(shape, 0, 0, wide, high);

} catch (Exception e) {

e.printStackTrace();

}

pg.endDraw();

return pg.image;

}

// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

static public Shape createRoundRect(float x1, float y1, float x2, float y2,

float tl, float tr, float br, float bl) {

GeneralPath path = new GeneralPath();

if (tr != 0) {

path.moveTo(x2-tr, y1);

path.quadTo(x2, y1, x2, y1+tr);

} else {

path.moveTo(x2, y1);

}

if (br != 0) {

path.lineTo(x2, y2-br);

path.quadTo(x2, y2, x2-br, y2);

} else {

path.lineTo(x2, y2);

}

if (bl != 0) {

path.lineTo(x1+bl, y2);

path.quadTo(x1, y2, x1, y2-bl);

} else {

path.lineTo(x1, y2);

}

if (tl != 0) {

path.lineTo(x1, y1+tl);

path.quadTo(x1, y1, x1+tl, y1);

} else {

path.lineTo(x1, y1);

}

path.closePath();

return path;

}

/**

static public void registerWindowCloseKeys(JRootPane root,

ActionListener disposer) {

KeyStroke stroke = KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0);

root.registerKeyboardAction(disposer, stroke,

JComponent.WHEN_IN_FOCUSED_WINDOW);

stroke = KeyStroke.getKeyStroke('W', SHORTCUT_KEY_MASK);

root.registerKeyboardAction(disposer, stroke,

JComponent.WHEN_IN_FOCUSED_WINDOW);

}

// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

static public void beep() {

awtToolkit.beep();

}

static public Clipboard getSystemClipboard() {

return awtToolkit.getSystemClipboard();

}

// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/*

static public Graphics2D prepareGraphics(Image image) {

return prepareGraphics(image.getGraphics(), true);

}

static public Graphics2D prepareGraphics(Graphics g) {

return prepareGraphics(g, false);

}

/**

static public Graphics2D prepareGraphics(Graphics g, boolean scale) {

Graphics2D g2 = (Graphics2D) g;

if (scale && Toolkit.isRetina()) {

// scale everything 2x, will be scaled down when drawn to the screen

g2.scale(2, 2);

}

g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,

RenderingHints.VALUE_ANTIALIAS_ON);

g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,

RenderingHints.VALUE_TEXT_ANTIALIAS_ON);

g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION,

RenderingHints.VALUE_INTERPOLATION_BICUBIC);

if (Toolkit.isRetina()) {

// Looks great on retina, not so great (with our font) on 1x

g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,

RenderingHints.VALUE_TEXT_ANTIALIAS_GASP);

}

if (scale) {

zoomStroke(g2);

}

return g2;

}