import java.util.*;
import java.util.zip.*;
import java.util.List;
import java.util.regex.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.text.*;
import javax.swing.table.*;
import java.io.*;
import java.net.*;
import java.lang.reflect.*;
import java.lang.ref.*;
import java.lang.management.*;
import java.security.*;
import java.security.spec.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import javax.imageio.*;
import java.math.*;
import javax.swing.event.AncestorListener;
import javax.swing.event.AncestorEvent;
import javax.swing.Timer;
import javax.swing.Timer;
import java.awt.datatransfer.StringSelection;
public class main {
// A concept should be an object, not just a string.
static int concepts_internStringsLongerThan = 10;
static ThreadLocal<Boolean> concepts_unlisted = new ThreadLocal<Boolean>();
static interface Derefable {
Concept get();
}
static class Concepts {
Map<Long, Concept> concepts = synchroTreeMap();
HashMap<Class, Object> perClassData = new HashMap<Class, Object>();
String programID;
long idCounter;
volatile long changes = 1, changesWritten;
volatile java.util.Timer autoSaver;
volatile boolean savingConcepts;
int autoSaveInterval = 1000;
boolean useGZIP = true;
Concepts() {}
Concepts(String programID) {
this.programID = programID;}
synchronized long newID() {
do {
++idCounter;
} while (hasConcept(idCounter));
return idCounter;
}
void initProgramID() {
if (programID == null)
programID = programID();
}
Concepts load() {
initProgramID();
clearConcepts();
DynamicObject_loading = true;
try {
long time = now();
readLocally2(this, programID, "concepts");
assignConceptsToUs();
done("Loading concepts", time);
readLocally2(this, programID, "idCounter");
} finally {
DynamicObject_loading = false;
}
return this;
}
Concepts loadConcepts() { return load(); }
void assignConceptsToUs() {
for (Concept c : values(concepts)) {
c._concepts = this;
callOpt_noArgs(c, "_doneLoading2");
}
}
String progID() {
return programID == null ? programID() : programID;
}
Concept getConcept(String id) {
return empty(id) ? null : getConcept(parseLong(id));
}
Concept getConcept(long id) {
return (Concept) concepts.get((long) id);
}
Concept getConcept(PassRef ref) {
return ref == null ? null : getConcept(ref.longID());
}
boolean hasConcept(long id) {
return concepts.containsKey((long) id);
}
void deleteConcept(long id) {
Concept c = getConcept(id);
if (c == null)
print("Concept " + id + " not found");
else
c.delete();
}
// call in only one thread
void saveConceptsIfDirty() {
initProgramID();
savingConcepts = true;
long start = now();
try {
String s;
//synchronized(main.class) {
long _changes = changes;
if (_changes == changesWritten) return;
saveLocally2(this, programID, "idCounter");
s = structure(cloneMap(concepts));
changesWritten = _changes; // only update when structure didn't fail (e.g. because of ConcurrentModificationException)
//}
s = javaTokWordWrap(s);
long time = now()-start;
print("Saving " + l(s) + " chars (" /*+ changesWritten + ", "*/ + time + " ms)");
start = now();
File f = getProgramFile(useGZIP ? "concepts.structure.gz" : "concepts.structure");
if (useGZIP) {
saveGZTextFile(f, s);
getProgramFile("concepts.structure").delete();
} else {
saveTextFile(f, s);
getProgramFile("concepts.structure.gz").delete();
}
copyFile(f, getProgramFile("concepts.structure" + (useGZIP ? ".gz" : "") + ".backup" + ymd() + "-" + formatInt(hours(), 2)));
time = now()-start;
print("Saved " + toK(f.length()) + " K (" + time + " ms)");
} finally {
savingConcepts = false;
}
}
void saveConcepts() {
saveConceptsIfDirty();
}
void clearConcepts() {
concepts.clear();
change();
}
synchronized void change() {
++changes;
}
// auto-save every second if dirty
synchronized void autoSaveConcepts() {
if (autoSaver == null) {
autoSaver = doEvery(autoSaveInterval, new Runnable() { public void run() { try { saveConcepts();
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } });
print("Installed auto-saver (" + autoSaveInterval + " ms, " + progID() + ")");
}
}
void cleanMeUp() {
if (autoSaver != null) {
autoSaver.cancel();
autoSaver = null;
}
while (savingConcepts) sleep(10);
saveConceptsIfDirty();
}
Map<Long, String> getIDsAndNames() {
Map<Long, String> map = new HashMap<Long, String>();
Map<Long, Concept> cloned = cloneMap(concepts);
for (long id : keys(cloned))
map.put(id, cloned.get(id).className);
return map;
}
void deleteConcepts(List l) {
for (Object o : l)
if (o instanceof Long)
concepts.remove((Long) o);
else if (o instanceof Concept)
((Concept) o).delete();
else
warn("Can't delete " + getClassName(o));
}
<A extends Concept> A conceptOfType(Class<A> type) {
return firstOfType(allConcepts(), type);
}
<A extends Concept> List<A> conceptsOfType(Class<A> type) {
return filterByType(allConcepts(), type);
}
<A extends Concept> List<A> listConcepts(Class<A> type) {
return conceptsOfType(type);
}
<A extends Concept> List<A> list(Class<A> type) {
return conceptsOfType(type);
}
List<Concept> list(String type) {
return conceptsOfType(type);
}
List<Concept> conceptsOfType(String type) {
return filterByDynamicType(allConcepts(), "main$" + type);
}
boolean hasConceptOfType(Class<? extends Concept> type) {
return hasType(allConcepts(), type);
}
void persistConcepts() {
loadConcepts();
autoSaveConcepts();
}
// We love synonyms
void conceptPersistence() {
persistConcepts();
}
void persist() { persistConcepts(); }
void persist(int interval) { autoSaveInterval = interval; persist(); }
// Runs r if there is no concept of that type
<A extends Concept> A ensureHas(Class<A> c, Runnable r) {
A a = conceptOfType(c);
if (a == null) {
r.run();
a = conceptOfType(c);
if (a == null)
throw fail("Concept not made by " + r + ": " + shortClassName(c));
}
return a;
}
// Ensures that every concept of type c1 is ref'd by a concept of
// type c2.
// Type of func: voidfunc(concept)
void ensureHas(Class<? extends Concept> c1, Class<? extends Concept> c2, Object func) {
for (Concept a : conceptsOfType(c1)) {
Concept b = findBackRef(a, c2);
if (b == null) {
callF(func, a);
b = findBackRef(a, c2);
if (b == null)
throw fail("Concept not made by " + func + ": " + shortClassName(c2));
}
}
}
// Type of func: voidfunc(concept)
void forEvery(Class<? extends Concept> type, Object func) {
for (Concept c : conceptsOfType(type))
callF(func, c);
}
int deleteAll(Class<? extends Concept> type) {
List<Concept> l = (List) conceptsOfType(type);
for (Concept c : l) c.delete();
return l(l);
}
Collection<Concept> allConcepts() {
synchronized(concepts) {
return new ArrayList(values(concepts));
}
}
PassRef toPassRef(Concept c) {
return new PassRef(c);
}
<A extends Concept> int countConcepts(Class<A> c, Object... params) {
int n = 0;
for (A x : list(c))
if (checkConceptFields(x, params))
++n;
return n;
}
int countConcepts() {
return l(concepts);
}
// inter-process methods
PassRef xnew(String name, Object... values) {
return new PassRef(cnew(name, values));
}
void xset(long id, String field, Object value) {
xset(new PassRef(id), field, value);
}
void xset(PassRef c, String field, Object value) {
if (value instanceof PassRef)
value = getConcept((PassRef) value);
cset(getConcept(c), field, value);
}
Object xget(long id, String field) {
return xget(new PassRef(id), field);
}
Object xget(PassRef c, String field) {
return cget(getConcept(c), field);
}
void xdelete(long id) {
xdelete(new PassRef(id));
}
void xdelete(PassRef c) {
getConcept(c).delete();
}
List<PassRef> xlist() {
return map("toPassRef", allConcepts());
}
List<PassRef> xlist(String className) {
return map("toPassRef", conceptsOfType(className));
}
}
static volatile Concepts mainConcepts = new Concepts(); // Where we create new concepts
static class Concept extends DynamicObject {
transient Concepts _concepts; // Where we belong
long id;
Object madeBy;
//double energy;
//bool defunct;
long created;
// used only internally (cnew)
Concept(String className) {
super(className);
_created();
}
Concept() {
if (!DynamicObject_loading) {
className = shortClassName(this);
//print("New concept of type " + className);
_created();
}
}
List<Ref> refs = new ArrayList<Ref>();
List<Ref> backRefs = new ArrayList<Ref>();
void _created() {
_concepts = mainConcepts;
id = _concepts.newID();
created = now();
_concepts.concepts.put((long) id, this);
_concepts.change();
}
void put(String field, Object value) {
fieldValues.put(field, value);
_concepts.change();
}
Object get(String field) {
return fieldValues.get(field);
}
class Ref<A extends Concept> {
A value;
Ref() {
if (!DynamicObject_loading) refs.add(this);
}
Ref(A value) {
this.value = value;
refs.add(this);
index();
}
// get owning concept (source)
Concept concept() {
return Concept.this;
}
// get target
A get() {
return value;
}
void set(A a) {
if (a == value) return;
unindex();
value = a;
index();
}
void set(Ref<A> ref) {
set(ref.get());
}
void index() {
if (value != null)
value.backRefs.add(this);
change();
}
void unindex() {
if (value != null)
value.backRefs.remove(this);
}
void change() {
Concept.this.change();
}
}
class RefL<A extends Concept> extends AbstractList<Concept> {
List<Ref<A>> l = new ArrayList<Ref<A>>();
public A set(int i, A o) {
A prev = l.get(i).get();
l.get(i).set(o);
return prev;
}
public void add(int i, A o) {
l.add(i, new Ref(o));
}
public A get(int i) {
return l.get(i).get();
}
public A remove(int i) {
return l.remove(i).get();
}
public int size() {
return l.size();
}
}
void delete() {
//name = "[defunct " + name + "]";
//defunct = true;
//energy = 0;
for (Ref r : refs)
r.unindex();
refs.clear();
for (Ref r : cloneList(backRefs))
r.set((Concept) null);
backRefs.clear(); // Should be clear at this point anyway
if (_concepts != null) {
_concepts.concepts.remove((long) id);
change();
_concepts = null;
}
id = 0;
}
BaseXRef export() {
return new BaseXRef(_concepts.progID(), id);
}
// notice system of a change in this object
void change() {
if (_concepts != null) _concepts.change();
}
String _programID() {
return _concepts == null ? programID() : _concepts.progID();
}
} // class Concept
// for inter-process communication
// prepared for string ids if we do them later
static class PassRef {
String id;
PassRef() {} // make serialisation happy
PassRef(long id) { this.id = str(id); }
PassRef(Concept c) { this(c.id); }
long longID() { return parseLong(id); }
public String toString() {
return id;
}
}
static class Event extends Concept {}
// Reference to a concept in another program
static class BaseXRef {
String programID;
long id;
BaseXRef() {}
BaseXRef(String programID, long id) {
this.id = id;
this.programID = programID;}
public boolean equals(Object o) {
if (!(o instanceof BaseXRef)) return false;
BaseXRef r = (BaseXRef) ( o);
return eq(programID, r.programID) && eq(id, r.id);
}
public int hashCode() {
return programID.hashCode() + (int) id;
}
}
// BaseXRef as a concept
static class XRef extends Concept {
BaseXRef ref;
XRef() {}
XRef(BaseXRef ref) {
this.ref = ref; _doneLoading2(); }
// after we have been added to concepts
void _doneLoading2() {
getIndex().put(ref, this);
}
HashMap<BaseXRef, XRef> getIndex() {
return getXRefIndex(_concepts);
}
}
static synchronized HashMap<BaseXRef, XRef> getXRefIndex(Concepts concepts) {
HashMap cache = (HashMap) concepts.perClassData.get(XRef.class);
if (cache == null)
concepts.perClassData.put(XRef.class, cache = new HashMap());
return cache;
}
// uses mainConcepts
static XRef lookupOrCreateXRef(BaseXRef ref) {
XRef xref = getXRefIndex(mainConcepts).get(ref);
if (xref == null)
xref = new XRef(ref);
return xref;
}
// define standard concept functions to use main concepts
static <A extends Concept> List<A> list(Class<A> type) {
return mainConcepts.list(type);
}
static List<Concept> list(String type) {
return mainConcepts.list(type);
}
static Concept cnew(String name, Object... values) {
Class<? extends Concept> cc = findClass(name);
Concept c = cc != null ? nuObject(cc) : new Concept(name);
csetAll(c, values);
return c;
}
static <A extends Concept> A cnew(Class<A> cc, Object... values) {
A c = nuObject(cc);
csetAll(c, values);
return c;
}
static Object cget(Concept c, String field) {
Object o = getOpt(c, field);
if (o instanceof Concept.Ref) return ((Concept.Ref) o).get();
return o;
}
static void csetAll(Concept c, Object... values) {
cset(c, values);
}
static void cset(Concept c, Object... values) { try {
values = expandParams(c.getClass(), values);
warnIfOddCount(values);
for (int i = 0; i+1 < l(values); i += 2) {
String field = (String) values[i];
Object value = values[i+1];
Field f = setOpt_findField(c.getClass(), field);
//print("cset: " + c.id + " " + field + " " + struct(value) + " " + f);
if (value instanceof PassRef) value = c._concepts.getConcept((PassRef) value);
value = deref(value);
if (value instanceof String && l((String) value) >= concepts_internStringsLongerThan) value = ((String) value).intern();
if (f == null)
c.fieldValues.put(field, value instanceof Concept ? c.new Ref((Concept) value) : value);
else if (isSubtypeOf(f.getType(), Concept.Ref.class))
((Concept.Ref) f.get(c)).set((Concept) value);
else
f.set(c, value);
}
c.change();
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static <A extends Concept> int countConcepts(Class<A> c, Object... params) {
return mainConcepts.countConcepts(c, params);
}
static int countConcepts() {
return mainConcepts.countConcepts();
}
static <A extends Concept> A findBackRef(Concept c, Class<A> type) {
for (Concept.Ref r : c.backRefs)
if (instanceOf(r.concept(), type))
return (A) r.concept(); return null;
}
static <A extends Concept> List<A> findBackRefs(Collection<? extends Concept> concepts, Class<A> type) {
IdentityHashMap<A, Boolean> l = new IdentityHashMap<A, Boolean>();
for (Concept c : concepts)
for (Concept.Ref r : c.backRefs)
if (instanceOf(r.concept(), type))
l.put((A) r.concept(), true);
return asList(keys(l));
}
// TODO: sort by ID?
static <A extends Concept> List<A> findBackRefs(Concept c, Class<A> type) {
IdentityHashMap<A, Boolean> l = new IdentityHashMap<A, Boolean>();
for (Concept.Ref r : c.backRefs)
if (instanceOf(r.concept(), type))
l.put((A) r.concept(), true);
return asList(keys(l));
}
static <A extends Concept> List<A> findBackRefs(Class<A> type, Concept c) {
return findBackRefs(c, type);
}
static void cleanMeUp() {
mainConcepts.cleanMeUp();
}
static Concept getConcept(long id) {
return mainConcepts.getConcept(id);
}
static void loadAndAutoSaveConcepts() {
mainConcepts.persist();
}
static void loadConceptsFrom(String progID) {
mainConcepts.programID = progID;
mainConcepts.load();
}
static List<Concept> conceptsOfType(String type) {
return mainConcepts.conceptsOfType(type);
}
static Collection<Concept> allConcepts() {
return mainConcepts.allConcepts();
}
static long changeCount() {
return mainConcepts.changes;
}
// make concept instance that is not connected to DB
static <A extends Concept> A unlisted(Class<A> c, Object... args) {
concepts_unlisted.set(true);
try {
return nuObject(c, args);
} finally {
concepts_unlisted.set(null);
}
}
static void deleteConcepts(List l) {
mainConcepts.deleteConcepts(l);
} // Dynamic Concepts
static class Screenshot extends Concept {
String pngPath; // optional, relative (program ID + "/" + file name)
Rect r; // optional, rectangle that was shot
Screenshot() {} // for persistance
Screenshot(BufferedImage img) {
savePNG(pngFile(), img);
}
File pngFile() {
if (pngPath != null)
return prepareFile(new File(javaxDataDir(), pngPath));
return prepareProgramFile(_programID(), "screenshot" + id + ".png");
}
BufferedImage loadImage() {
return loadImage2(pngFile());
}
boolean hasImage() {
return pngFile().exists();
}
}
static class TransientScreenshot extends Screenshot {
transient BufferedImage img;
TransientScreenshot() {} // for persistance
TransientScreenshot(BufferedImage img) {
this.img = img;}
boolean hasImage() { return img != null; }
BufferedImage loadImage() { return img; }
void disposeImage() { img = null; }
}
static class MarkedClip extends Clip {
static String _fieldOrder = "screenshot positionInScreenshot";
Ref<Screenshot> screenshot = new Ref<Screenshot>();
Rect positionInScreenshot;
}
static class Clip extends Concept {
static String _fieldOrder = "originalID img description";
long originalID; // ID in #1005389
BWImage img;
String description;
}
static class Found extends Concept {
static String _fieldOrder = "screenshot clip fi";
Ref<Screenshot> screenshot = new Ref<Screenshot>();
Ref<Clip> clip = new Ref<Clip>();
FoundImg fi; // contains Rect r
}
static class FullySearched extends Concept {
static String _fieldOrder = "screenshot clip";
Ref<Screenshot> screenshot = new Ref<Screenshot>();
Ref<Clip> clip = new Ref<Clip>();
} // PIF Classes v2
// please include #1005686 [PIF Classes v2]
static class SingleObjectFinder {
String obj = "start button";
SingleObjectFinder() {}
SingleObjectFinder(String obj) {
this.obj = obj;}
int maxTotal = 10;
JComponent form;
JLabel lFound, lSearchTime, lScreenshots;
volatile List<Found> found;
void showGUI() {
form = showForm(
("Number of " + (obj) + " pictures stored:"), jConceptCountLabel(Clip.class),
"Number of screenshots stored:", lScreenshots = jConceptDependentLabel(new Object() { Object get() {
int n = countConcepts(Screenshot.class);
int t = countConcepts(TransientScreenshot.class);
return n + " (" + (n-t) + " with image)";
}
public String toString() { return "int n = countConcepts(Screenshot);\n int t = countConcepts(TransientScreenshot);\n ret n + \" (\" + (n-t) + \" with image)\";"; }}),
"Currently found:", lFound = jlabel(),
"Search time:", lSearchTime = jlabel(),
"", jbutton("Show pictures", new Runnable() { public void run() { try { showClips() ;
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } }),
"", jbutton(("Grab picture of " + (obj)), new Runnable() { public void run() { try { addClip(false) ;
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } }),
"", jbutton("Grab picture with delay", new Runnable() { public void run() { try { addClip(true) ;
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } })
);
onDoubleClick(lFound, new Runnable() { public void run() { try {
Found f = first(found);
if (f == null) return;
moveMouseTo(centerOfRect(f.fi.r));
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } });
componentPopupMenu(lFound, new Object() { void get(JPopupMenu menu) {
menu.add(jmenuItem("Show all", new Runnable() { public void run() { try {
for (Found f: unnull(found))
pointArrowsToArea(f.fi.r);
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } }));
}
public String toString() { return "menu.add(jmenuItem(\"Show all\", r {\n for (Found f: unnull(found))\n pointArrowsToArea(f.fi.r);\n }));"; }});
componentPopupMenu(lScreenshots, new Object() { void get(JPopupMenu menu) {
menu.add(jmenuItem("Delete older screenshots", new Runnable() { public void run() { try {
deleteOlderScreenshots()
;
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } }));
}
public String toString() { return "menu.add(jmenuItem(\"Delete older screenshots\", r {\n deleteOlderScreenshots()\n }));"; }});
final MonoThread thread = new MonoThread();
installTimer(form, 5000, 0, new Runnable() { public void run() { try {
thread.runIfNotRunning(new Runnable() { public void run() { try {
BufferedImage img = shootScreen2();
long start = now();
found = continuousFind_step(goodClips(), img, maxTotal);
final long time = now()-start;
swingLater(new Runnable() { public void run() { try {
lSearchTime.setText(time + " ms");
String s = "no";
if (nempty(found))
s = "at " + first(found).fi.r + " [clip " + first(found).clip.get().id + "]";
if (l(found) > 1)
s += " +" + (l(found)-1);
lFound.setText(s);
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } });
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } });
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } });
}
void addClip(boolean delay) {
letUserMarkScreenArea(delay ? null : shootScreen2(), new Object() { void get(final Rectangle r, BufferedImage img) {
if (r == null) print("Cancelled!");
else {
Screenshot screenshot = new Screenshot(img);
showAnimation("#1005611", "You marked " + r, 3);
uniq(MarkedClip.class, "screenshot", screenshot, "positionInScreenshot" , new Rect(r),
"description" , obj,
"img" , new BWImage(img).clip(r));
darkenScreenArea(r, 5);
swingLater(250, new Runnable() { public void run() { try {
pointArrowsToArea(r, 5-0.25);
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } });
}
}
public String toString() { return "if (r == null) print(\"Cancelled!\");\n else {\n Screenshot screenshot = new Screenshot(img);\n \n showAnimation(\"#1005611\", \"You marked \" + r, 3);\n uniq(MarkedClip, +screenshot, \"positionInScreenshot\" , new Rect(r), \n \"description\" , obj,\n \"img\" , new BWImage(img).clip(r));\n darkenScreenArea(r, 5);\n swingLater(250, r {\n pointArrowsToArea(r, 5-0.25);\n });\n }"; }});
}
void showClips() {
List<List> data = new ArrayList<List>();
for (MarkedClip clip : list(MarkedClip.class)) try { /* pcall 1*/
data.add(ll(clip.id, clip.img == null ? null : clip.img.getBufferedImage(), clip.description));
/* pcall 2 */ } catch (Throwable __e) { printStackTrace(__e); }
final JTable table = showTableWithImages("Clips", splitAtSpace("ID Picture Description"), data);
tablePopupMenu(table, new Object() { void get(JPopupMenu menu, int row) {
List line = getTableLine(table, row);
long id = parseLong(line.get(0));
final Clip clip = (Clip) ( getConcept(id));
if (neq(clip.description, "bad"))
menu.add(jmenuItem("Mark bad", new Runnable() { public void run() { try {
cset(clip, "description" , "bad");
disposeFrame(table);
showClips();
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } }));
}
public String toString() { return "L line = getTableLine(table, row);\n long id = parseLong(line.get(0));\n final Clip clip = (Clip) ( getConcept(id));\n if (neq(clip.description, \"bad\"))\n menu.add(jmenuItem(\"Mark bad\", r {\n cset(clip, \"description\" , \"bad\");\n disposeFrame(table);\n showClips();\n }));"; }});
}
List<Clip> goodClips() {
return filter(list(Clip.class) , new Object() { Object get(Clip c) { return swic(c.description, obj) ; }
public String toString() { return "swic(c.description, obj)"; }});
}
void deleteOlderScreenshots() {
for (Screenshot s : dropLast(list(Screenshot.class))) {
if (hasBackRef(s, Clip.class)) continue;
print("Backrefs to screenshot:");
List<Concept> backRefs = findBackRefs(s, Concept.class);
printIndent(renderConcepts(backRefs));
deleteConcepts(backRefs);
s.delete();
}
}
} // SingleObjectFinder
static SingleObjectFinder finder;
public static void main(String[] args) throws Exception { swingLater(new Runnable() { public void run() { try { substance();
concepts();
finder = new SingleObjectFinder("JavaX console duplicate button");
finder.showGUI();
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } });}
static void moveMouseTo(int newx, int newy) {
moveMouse(newx, newy);
}
static void moveMouseTo(Pt pt) {
moveMouse(pt.x, pt.y);
}
static List<String> splitAtSpace(String s) {
return asList(s.split("\\s+"));
}
static Object callF(Object f, Object... args) {
return callFunction(f, args);
}
// firstDelay = delay
static java.util.Timer doEvery(int delay, Runnable r) {
java.util.Timer timer = new java.util.Timer();
timer.scheduleAtFixedRate(timerTask(r), delay, delay);
return timer;
}
static <A> ArrayList<A> asList(A[] a) {
return new ArrayList<A>(Arrays.asList(a));
}
static ArrayList<Integer> asList(int[] a) {
ArrayList<Integer> l = new ArrayList();
for (int i : a) l.add(i);
return l;
}
static <A> ArrayList<A> asList(Iterable<A> s) {
if (s instanceof ArrayList) return (ArrayList) s;
ArrayList l = new ArrayList();
if (s != null)
for (A a : s)
l.add(a);
return l;
}
static void printIndent(Object o) {
print(indentx(str(o)));
}
static void printIndent(String indent, Object o) {
print(indentx(indent, str(o)));
}
static void printIndent(int indent, Object o) {
print(indentx(indent, str(o)));
}
static String[] dropLast(String[] a, int n) {
n = Math.min(n, a.length);
String[] b = new String[a.length-n];
System.arraycopy(a, 0, b, 0, b.length);
return b;
}
static <A> List<A> dropLast(List<A> l) {
return subList(l, 0, l(l)-1);
}
static String dropLast(String s) {
return substring(s, 0, l(s)-1);
}
// makeText : func() -> S
static JLabel jConceptDependentLabel(final Object makeText) {
final JLabel l = jlabel();
awtOnConceptChanges(l, 1000, 0, new Runnable() { public void run() { try {
l.setText(str(callF(makeText)));
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } });
return l;
}
static BufferedImage loadImage2(String snippetIDOrURL) {
return loadBufferedImage(snippetIDOrURL);
}
static BufferedImage loadImage2(File file) {
return loadBufferedImage(file);
}
static void disposeFrame(final Component c) {
swingNowOrLater(new Runnable() { public void run() { try {
Frame f = getFrame(c);
if (f != null)
f.dispose();
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } });
}
static void swingLater(long delay, final Runnable r) {
javax.swing.Timer timer = new javax.swing.Timer(toInt(delay), new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent _evt) {
r.run();
}});
timer.setRepeats(false);
timer.start();
}
static void swingLater(Runnable r) {
SwingUtilities.invokeLater(r);
}
static <A> List<A> filterByDynamicType(Collection<A> c, String type) {
List<A> l = new ArrayList<A>();
for (A x : c)
if (eq(dynamicClassName(x), type))
l.add(x);
return l;
}
static JMenuItem jmenuItem(String text, final Runnable r) {
JMenuItem mi = new JMenuItem(text);
mi.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent _evt) { r.run(); }});
return mi;
}
static <A> List<A> cloneList(Collection<A> l) {
//O mutex = getOpt(l, "mutex");
/*if (mutex != null)
synchronized(mutex) {
ret new ArrayList<A>(l);
}
else
ret new ArrayList<A>(l);*/
// assume mutex is equal to collection, which will be true unless you explicitly pass a mutex to synchronizedList() which no one ever does.
synchronized(l) {
return new ArrayList<A>(l);
}
}
static JButton jbutton(String text, Object action) {
return newButton(text, action);
}
// button without action
static JButton jbutton(String text) {
return newButton(text, null);
}
static HashMap<String, Class> findClass_cache = new HashMap<String, Class>();
// currently finds only inner classes of class "main"
// returns null on not found
// this is the simple version that is not case-tolerant
static Class findClass(String name) {
synchronized(findClass_cache) {
if (findClass_cache.containsKey(name))
return findClass_cache.get(name);
if (!isJavaIdentifier(name)) return null;
Class c;
try {
c = Class.forName("main$" + name);
} catch (ClassNotFoundException e) {
c = null;
}
findClass_cache.put(name, c);
return c;
}
}
static Field setOpt_findField(Class c, String field) {
HashMap<String, Field> map;
synchronized(getOpt_cache) {
map = getOpt_cache.get(c);
if (map == null)
map = getOpt_makeCache(c);
}
return map.get(field);
}
static void setOpt(Object o, String field, Object value) { try {
if (o == null) return;
Class c = o.getClass();
HashMap<String, Field> map;
synchronized(getOpt_cache) {
map = getOpt_cache.get(c);
if (map == null)
map = getOpt_makeCache(c);
}
if (map == getOpt_special) {
if (o instanceof Class) {
setOpt((Class) o, field, value);
return;
}
return;
}
Field f = map.get(field);
if (f != null)
smartSet(f, o, value); // possible improvement: skip setAccessible
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static void setOpt(Class c, String field, Object value) {
if (c == null) return;
try {
Field f = setOpt_findStaticField(c, field);
if (f != null)
smartSet(f, null, value);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
static Field setOpt_findStaticField(Class<?> c, String field) {
Class _c = c;
do {
for (Field f : _c.getDeclaredFields())
if (f.getName().equals(field) && (f.getModifiers() & Modifier.STATIC) != 0)
return f;
_c = _c.getSuperclass();
} while (_c != null);
return null;
}
static String str(Object o) {
return String.valueOf(o);
}
static boolean isSubtypeOf(Class a, Class b) {
return b.isAssignableFrom(a); // << always hated that method, let's replace it!
}
static long toK(long l) {
return (l+1023)/1024;
}
static RuntimeException fail() {
throw new RuntimeException("fail");
}
static RuntimeException fail(Object msg) {
throw new RuntimeException(String.valueOf(msg));
}
static RuntimeException fail(String msg) {
throw new RuntimeException(unnull(msg));
}
// disabled for now to shorten some programs
/*static RuntimeException fail(S msg, O... args) {
throw new RuntimeException(format(msg, args));
}*/
static void concepts() {
loadAndAutoSaveConcepts();
}
public static void copyFile(File src, File dest) { try {
mkdirsForFile(dest);
FileInputStream inputStream = new FileInputStream(src.getPath());
FileOutputStream outputStream = newFileOutputStream(dest.getPath());
try {
copyStream(inputStream, outputStream);
inputStream.close();
} finally {
outputStream.close();
}
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static boolean hasBackRef(Class<? extends Concept> type, Concept c) {
return hasBackRef(c, type);
}
static boolean hasBackRef(Concept c, Class<? extends Concept> type) {
return findBackRef(c, type) != null;
}
// requires #1005686 (PIF Classes v2)
static List<Found> continuousFind_step(List<Clip> clips) {
return continuousFind_step(clips, shootScreen2());
}
// creates TransientScreenshot and Found objects
static List<Found> continuousFind_step(List<Clip> clips, BufferedImage screenshot) {
return continuousFind_step(clips, screenshot, 1);
}
static List<Found> continuousFind_step(List<Clip> clips, BufferedImage screenshot, int maxTotal) {
TransientScreenshot t = //unlisted(TransientScreenshot, screenshot);
new TransientScreenshot(screenshot);
try {
ImageFinder finder = new ImageFinder(ll(((Screenshot) t)), clips);
finder.maxTotal = maxTotal;
finder.run();
} finally {
t.disposeImage();
}
print("#found = " + countConcepts(Found.class));
return findBackRefs(Found.class, t);
}
static <A> A firstOfType(Collection c, Class<A> type) {
for (Object x : c)
if (isInstanceX(type, x))
return (A) x;
return null;
}
static String unnull(String s) {
return s == null ? "" : s;
}
static <A> List<A> unnull(List<A> l) {
return l == null ? emptyList() : l;
}
static <A> Iterable<A> unnull(Iterable<A> i) {
return i == null ? emptyList() : i;
}
static Object[] unnull(Object[] a) {
return a == null ? new Object[0] : a;
}
static BitSet unnull(BitSet b) {
return b == null ? new BitSet() : b;
}
static boolean swic(String a, String b) {
return startsWithIgnoreCase(a, b);
}
static void saveGZTextFile(File file, String contents) { try {
File parentFile = file.getParentFile();
if (parentFile != null)
parentFile.mkdirs();
String tempFileName = file.getPath() + "_temp";
File tempFile = new File(tempFileName);
if (contents != null) {
if (tempFile.exists()) try {
String saveName = tempFileName + ".saved." + now();
copyFile(tempFile, new File(saveName));
} catch (Throwable e) { printStackTrace(e); }
FileOutputStream fileOutputStream = newFileOutputStream(tempFile.getPath());
GZIPOutputStream gos = new GZIPOutputStream(fileOutputStream);
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(gos, "UTF-8");
PrintWriter printWriter = new PrintWriter(outputStreamWriter);
printWriter.print(contents);
printWriter.close();
gos.close();
fileOutputStream.close();
}
if (file.exists() && !file.delete())
throw new IOException("Can't delete " + file.getPath());
if (contents != null)
if (!tempFile.renameTo(file))
throw new IOException("Can't rename " + tempFile + " to " + file);
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
// runnable can be a func(O o) {} receving the selected item
static void onDoubleClick(final JList list, final Object runnable) {
list.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent evt) {
if (evt.getClickCount() == 2) {
int idx = list.locationToIndex(evt.getPoint());
Object item = list.getModel().getElementAt(idx);
list.setSelectedIndex(idx);
callF(runnable, item);
}
}
});
}
// runnable can be a func(O o) {} receving the selected row index
static void onDoubleClick(final JTable table, final Object runnable) {
table.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent evt) {
if (evt.getClickCount() == 2) {
int idx = table.rowAtPoint(evt.getPoint());
table.setRowSelectionInterval(idx, idx);
callF(runnable, idx);
}
}
});
}
// other components get the pointer position
// only reacts on left button
static void onDoubleClick(JComponent c, final Object runnable) {
c.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent evt) {
if (evt.getButton() == 1 && evt.getClickCount() == 2)
callF(runnable, evt.getPoint());
}
});
}
static Map synchroTreeMap() {
return Collections.synchronizedMap(new TreeMap());
}
static void sleep(long ms) {
ping();
try {
Thread.sleep(ms);
} catch (Exception e) { throw new RuntimeException(e); }
}
static void sleep() { try {
print("Sleeping.");
synchronized(main.class) { main.class.wait(); }
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static class componentPopupMenu_Maker {
List menuMakers = new ArrayList();
}
static Map<JComponent, componentPopupMenu_Maker> componentPopupMenu_map = new WeakHashMap();
static ThreadLocal<MouseEvent> componentPopupMenu_mouseEvent = new ThreadLocal<MouseEvent>();
// menuMaker = voidfunc(JPopupMenu)
static void componentPopupMenu(final JComponent component, final Object menuMaker) {
swingNowOrLater(new Runnable() { public void run() { try {
componentPopupMenu_Maker maker = componentPopupMenu_map.get(component);
if (maker == null) {
componentPopupMenu_map.put(component, maker = new componentPopupMenu_Maker());
final componentPopupMenu_Maker _maker = maker;
component.addMouseListener(new MouseAdapter() {
public void mousePressed(MouseEvent e) { displayMenu(e); }
public void mouseReleased(MouseEvent e) { displayMenu(e); }
void displayMenu(MouseEvent e) {
if (e.isPopupTrigger()) {
JPopupMenu menu = new JPopupMenu();
int emptyCount = menu.getComponentCount();
componentPopupMenu_mouseEvent.set(e);
for (Object menuMaker : _maker.menuMakers)
pcallF(menuMaker, menu);
// show menu if any items in it
if (menu.getComponentCount() != emptyCount)
menu.show(e.getComponent(), e.getX(), e.getY());
}
}
});
}
maker.menuMakers.add(menuMaker);
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } });
}
// get purpose 1: access a list/array (safer version of x.get(y))
static <A> A get(List<A> l, int idx) {
return idx >= 0 && idx < l(l) ? l.get(idx) : null;
}
static <A> A get(A[] l, int idx) {
return idx >= 0 && idx < l(l) ? l[idx] : null;
}
// default to false
static boolean get(boolean[] l, int idx) {
return idx >= 0 && idx < l(l) ? l[idx] : false;
}
static Class get_dynamicObject = DynamicObject.class;
// get purpose 2: access a field by reflection or a map
static Object get(Object o, String field) {
try {
if (o instanceof Class) return get((Class) o, field);
if (o instanceof Map)
return ((Map) o).get(field);
Field f = getOpt_findField(o.getClass(), field);
if (f != null) {
f.setAccessible(true);
return f.get(o);
}
if (get_dynamicObject != null && get_dynamicObject.isInstance(o))
return call(get_raw(o, "fieldValues"), "get", field);
} catch (Exception e) {
throw asRuntimeException(e);
}
throw new RuntimeException("Field '" + field + "' not found in " + o.getClass().getName());
}
static Object get_raw(Object o, String field) {
try {
Field f = get_findField(o.getClass(), field);
f.setAccessible(true);
return f.get(o);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
static Object get(Class c, String field) {
try {
Field f = get_findStaticField(c, field);
f.setAccessible(true);
return f.get(null);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
static Field get_findStaticField(Class<?> c, String field) {
Class _c = c;
do {
for (Field f : _c.getDeclaredFields())
if (f.getName().equals(field) && (f.getModifiers() & Modifier.STATIC) != 0)
return f;
_c = _c.getSuperclass();
} while (_c != null);
throw new RuntimeException("Static field '" + field + "' not found in " + c.getName());
}
static Field get_findField(Class<?> c, String field) {
Class _c = c;
do {
for (Field f : _c.getDeclaredFields())
if (f.getName().equals(field))
return f;
_c = _c.getSuperclass();
} while (_c != null);
throw new RuntimeException("Field '" + field + "' not found in " + c.getName());
}
static List map(Iterable l, Object f) {
return map(f, l);
}
static List map(Object f, Iterable l) {
List x = new ArrayList();
Object mc = mc();
for (Object o : unnull(l))
x.add(callFunction(f, o));
return x;
}
static List map(Object f, Object[] l) {
return map(f, asList(l));
}
static List map(Map map, Object f) {
List x = new ArrayList();
for (Object _e : map.entrySet()) {
Map.Entry e = (Map.Entry) _e;
x.add(callFunction(f, e.getKey(), e.getValue()));
}
return x;
}
static JLabel jConceptCountLabel(final Class<? extends Concept> c) {
return jConceptDependentLabel(new Object() { Object get() { return countConcepts(c) ; }
public String toString() { return "countConcepts(c)"; }});
}
static int letUserMarkScreenArea_shootAfterClickDelay = 1000;
static void letUserMarkScreenArea(final Object f) {
letUserMarkScreenArea(shootScreen2(), f);
}
// f: voidfunc(Rectangle r, BufferedImage screenshot) - gets called with null values on abort
static void letUserMarkScreenArea(final BufferedImage screenshot, final Object f) {
final JWindow window = showAnimationInTopRightCorner("#1005611", "Please click roughly in the area you would like to select");
trackOneClick(new Object() { void get(final Point p) {
final Flag done = new Flag();
window.dispose();
{ /*nt*/ Thread _t_0 = new Thread("Shooting Screen") {
public void run() { /* in run */ try { /* pcall 1*/ /* in thread */
sleep(screenshot == null ? letUserMarkScreenArea_shootAfterClickDelay : 0);
swingLater(new Runnable() { public void run() { try {
final BufferedImage screenshot2 = screenshot == null ? shootScreen2() : screenshot;
final ImageSurface is = imageSurface(screenshot2);
is.setZoom(4);
JFrame frame = showCenterFrame("Please select exact area and click OK", jScrollPane(is));
setFrameBounds(frame, centerScreenPart(0.75));
addToWindow(frame, withInset(imageSelectionDepend(is, jbutton("OK", new Runnable() { public void run() { try {
Rectangle r = is.selection;
if (r != null) {
disposeWindow(is);
done.raise();
callF(f, r, screenshot2);
}
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } }))));
is.centerPoint(p);
onFrameClose(frame, new Runnable() { public void run() { try {
if (!done.isUp()) {
done.raise();
callF(f, null, null);
}
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } });
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } });
/* in thread */ /* pcall 2 */ } catch (Throwable __e) { printStackTrace(__e); } /* in run */ }
};
_t_0.start(); }
}
public String toString() { return "final Flag done = new Flag();\n window.dispose();\n \n thread \"Shooting Screen\" {\n sleep(screenshot == null ? letUserMarkScreenArea_shootAfterClickDelay : 0);\n awt {\n final BufferedImage screenshot2 = screenshot == null ? shootScreen2() : screenshot;\n \n final ImageSurface is = imageSurface(screenshot2);\n is.setZoom(4);\n JFrame frame = showCenterFrame(\"Please select exact area and click OK\", jScrollPane(is));\n setFrameBounds(frame, centerScreenPart(0.75));\n addToWindow(frame, withInset(imageSelectionDepend(is, jbutton(\"OK\", r {\n Rectangle r = is.selection;\n if (r != null) {\n disposeWindow(is);\n done.raise();\n callF(f, r, screenshot2);\n }\n }))));\n is.centerPoint(p);\n onFrameClose(frame, r {\n if (!done.isUp()) {\n done.raise();\n callF(f, null, null);\n }\n });\n }\n }"; }});
}
static <A, B> Map<A, B> cloneMap(Map<A, B> map) {
if (map == null) return litmap();
// assume mutex is equal to collection, which will be true unless you explicitly pass a mutex to synchronizedList() which no one ever does.
synchronized(map) {
return new HashMap(map);
}
}
static void set(Object o, String field, Object value) {
if (o instanceof Class) set((Class) o, field, value);
else try {
Field f = set_findField(o.getClass(), field);
smartSet(f, o, value);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
static void set(Class c, String field, Object value) {
try {
Field f = set_findStaticField(c, field);
smartSet(f, null, value);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
static Field set_findStaticField(Class<?> c, String field) {
Class _c = c;
do {
for (Field f : _c.getDeclaredFields())
if (f.getName().equals(field) && (f.getModifiers() & Modifier.STATIC) != 0)
return f;
_c = _c.getSuperclass();
} while (_c != null);
throw new RuntimeException("Static field '" + field + "' not found in " + c.getName());
}
static Field set_findField(Class<?> c, String field) {
Class _c = c;
do {
for (Field f : _c.getDeclaredFields())
if (f.getName().equals(field))
return f;
_c = _c.getSuperclass();
} while (_c != null);
throw new RuntimeException("Field '" + field + "' not found in " + c.getName());
}
static BufferedImage shootScreen2() {
return shootScreen2(screenRectangle());
}
static BufferedImage shootScreen2(Rectangle area) { try {
return new Robot().createScreenCapture(area);
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static int l(Object[] a) { return a == null ? 0 : a.length; }
static int l(boolean[] a) { return a == null ? 0 : a.length; }
static int l(byte[] a) { return a == null ? 0 : a.length; }
static int l(int[] a) { return a == null ? 0 : a.length; }
static int l(float[] a) { return a == null ? 0 : a.length; }
static int l(char[] a) { return a == null ? 0 : a.length; }
static int l(Collection c) { return c == null ? 0 : c.size(); }
static int l(Map m) { return m == null ? 0 : m.size(); }
static int l(CharSequence s) { return s == null ? 0 : s.length(); }
static int l(Object o) {
return l((List) o); // incomplete
}
static String renderConcepts(List<? extends Concept> l) {
return fromLines(map(l, new Object() { Object get(Concept c) { return renderConcept(c) ; }
public String toString() { return "renderConcept(c)"; }}));
}
static long parseLong(String s) {
if (s == null) return 0;
return Long.parseLong(dropSuffix("L", s));
}
static long parseLong(Object s) {
return Long.parseLong((String) s);
}
static JWindow showAnimation(String imageID, double seconds) {
return showAnimationInTopRightCorner(imageID, seconds);
}
static JWindow showAnimation(String imageID) {
return showAnimationInTopRightCorner(imageID);
}
static JWindow showAnimation(String imageID, String text, double seconds) {
return showAnimationInTopRightCorner(imageID, text, seconds);
}
static boolean equals(Object a, Object b) {
return a == null ? b == null : a.equals(b);
}
static JTable showTableWithImages(final String title, final List<String> cols, final List<List> data) {
return (JTable) swingAndWait(new Object() { Object get() {
JTable table = sexyTable();
fillTableWithData(table, data, cols);
table.setRowHeight(100);
showFrame(title, table);
return table;
}
public String toString() { return "JTable table = sexyTable();\n fillTableWithData(table, data, cols);\n table.setRowHeight(100);\n showFrame(title, table);\n ret table;"; }});
}
static boolean hasType(Collection c, Class type) {
for (Object x : c)
if (isInstanceX(type, x))
return true;
return false;
}
static Object first(Object list) {
return ((List) list).isEmpty() ? null : ((List) list).get(0);
}
static <A> A first(List<A> list) {
return list.isEmpty() ? null : list.get(0);
}
static <A> A first(A[] bla) {
return bla == null || bla.length == 0 ? null : bla[0];
}
static <A> A first(Iterable<A> i) {
if (i == null) return null;
Iterator<A> it = i.iterator();
return it.hasNext() ? it.next() : null;
}
static Pt centerOfRect(Rect r) {
return new Pt(r.x+r.w/2, r.y+r.h/2);
}
static <A> List<A> ll(A... a) {
return litlist(a);
}
static String formatInt(int i, int digits) {
return padLeft(str(i), '0', digits);
}
static File prepareProgramFile(String name) {
return mkdirsForFile(getProgramFile(name));
}
static File prepareProgramFile(String progID, String name) {
return mkdirsForFile(getProgramFile(progID, name));
}
static boolean empty(Collection c) {
return isEmpty(c);
}
static boolean empty(String s) {
return isEmpty(s);
}
static boolean empty(Map map) {
return map == null || map.isEmpty();
}
static boolean empty(Object[] o) {
return o == null || o.length == 0;
}
static boolean empty(Object o) {
if (o instanceof Collection) return empty((Collection) o);
if (o instanceof String) return empty((String) o);
if (o instanceof Map) return empty((Map) o);
if (o instanceof Object[]) return empty((Object[]) o);
throw fail("unknown type for 'empty': " + getType(o));
}
static boolean instanceOf(Object o, String className) {
if (o == null) return false;
String c = o.getClass().getName();
return eq(c, className) || eq(c, "main$" + className);
}
static boolean instanceOf(Object o, Class c) {
if (c == null) return false;
return c.isInstance(o);
}
static RGBImage loadImage(String snippetIDOrURL) {
return new RGBImage(loadBufferedImage(snippetIDOrURL));
}
static WeakHashMap<Class, HashMap<String, Method>> callOpt_noArgs_cache = new WeakHashMap();
static Object callOpt_noArgs(Object o, String method) { try {
if (o == null) return null;
if (o instanceof Class)
return callOpt(o, method); // not optimized
Class c = o.getClass();
HashMap<String, Method> map;
synchronized(callOpt_noArgs_cache) {
map = callOpt_noArgs_cache.get(c);
if (map == null)
map = callOpt_noArgs_makeCache(c);
}
Method m = map.get(method);
return m != null ? m.invoke(o) : null;
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
// used internally - we are in synchronized block
static HashMap<String, Method> callOpt_noArgs_makeCache(Class c) {
HashMap<String, Method> map = new HashMap<String, Method>();
Class _c = c;
do {
for (Method m : c.getDeclaredMethods())
if (m.getParameterTypes().length == 0) {
m.setAccessible(true);
String name = m.getName();
if (!map.containsKey(name))
map.put(name, m);
}
_c = _c.getSuperclass();
} while (_c != null);
callOpt_noArgs_cache.put(c, map);
return map;
}
static File prepareFile(File file) {
return mkdirsForFile(file);
}
static boolean neq(Object a, Object b) {
return !eq(a, b);
}
static JComponent showForm(Object... parts) {
return showFormTitled(autoFrameTitle(), parts);
}
static <A> List<A> filterByType(Collection c, Class<A> type) {
List<A> l = new ArrayList<A>();
for (Object x : c)
if (isInstanceX(type, x))
l.add((A) x);
return l;
}
static boolean eq(Object a, Object b) {
if (a == null) return b == null;
if (a.equals(b)) return true;
if (a instanceof BigInteger) {
if (b instanceof Integer) return a.equals(BigInteger.valueOf((Integer) b));
if (b instanceof Long) return a.equals(BigInteger.valueOf((Long) b));
}
return false;
}
static int done_minPrint = 10;
static long done(long startTime, String desc) {
long time = now()-startTime;
if (time >= done_minPrint)
print(desc + " [" + time + " ms]");
return time;
}
static long done(String desc, long startTime) {
return done(startTime, desc);
}
static long done(long startTime) {
return done(startTime, "");
}
static class tablePopupMenu_Maker {
List menuMakers = new ArrayList();
}
static Map<JTable, tablePopupMenu_Maker> tablePopupMenu_map = new WeakHashMap();
static ThreadLocal<MouseEvent> tablePopupMenu_mouseEvent = new ThreadLocal<MouseEvent>();
// menuMaker = voidfunc(JPopupMenu, int row)
static void tablePopupMenu(final JTable table, final Object menuMaker) {
swingNowOrLater(new Runnable() { public void run() { try {
tablePopupMenu_Maker maker = tablePopupMenu_map.get(table);
if (maker == null) {
tablePopupMenu_map.put(table, maker = new tablePopupMenu_Maker());
final tablePopupMenu_Maker _maker = maker;
table.addMouseListener(new MouseAdapter() {
public void mousePressed(MouseEvent e) { displayMenu(e); }
public void mouseReleased(MouseEvent e) { displayMenu(e); }
void displayMenu(MouseEvent e) {
if (e.isPopupTrigger()) {
JPopupMenu menu = new JPopupMenu();
int row = table.rowAtPoint(e.getPoint());
table.setRowSelectionInterval(row, row);
int emptyCount = menu.getComponentCount();
tablePopupMenu_mouseEvent.set(e);
for (Object menuMaker : _maker.menuMakers)
pcallF(menuMaker, menu, row);
// show menu if any items in it
if (menu.getComponentCount() != emptyCount)
menu.show(e.getComponent(), e.getX(), e.getY());
}
}
});
}
maker.menuMakers.add(menuMaker);
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } });
}
static boolean warn_on = true;
static void warn(String s) {
if (warn_on)
print("Warning: " + s);
}
static void warn(String s, List<String> warnings) {
warn(s);
if (warnings != null)
warnings.add(s);
}
/** writes safely (to temp file, then rename) */
public static void saveTextFile(String fileName, String contents) throws IOException {
File file = new File(fileName);
File parentFile = file.getParentFile();
if (parentFile != null)
parentFile.mkdirs();
String tempFileName = fileName + "_temp";
File tempFile = new File(tempFileName);
if (contents != null) {
if (tempFile.exists()) try {
String saveName = tempFileName + ".saved." + now();
copyFile(tempFile, new File(saveName));
} catch (Throwable e) { printStackTrace(e); }
FileOutputStream fileOutputStream = newFileOutputStream(tempFile.getPath());
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream, "UTF-8");
PrintWriter printWriter = new PrintWriter(outputStreamWriter);
printWriter.print(contents);
printWriter.close();
}
if (file.exists() && !file.delete())
throw new IOException("Can't delete " + fileName);
if (contents != null)
if (!tempFile.renameTo(file))
throw new IOException("Can't rename " + tempFile + " to " + file);
}
public static void saveTextFile(File fileName, String contents) {
try {
saveTextFile(fileName.getPath(), contents);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
static <A extends Concept> A uniq(Class<A> c, Object... params) {
return uniqueConcept(c, params);
}
static Object nuObject(String className, Object... args) { try {
return nuObject(Class.forName(className), args);
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
// too ambiguous - maybe need to fix some callers
/*static O nuObject(O realm, S className, O... args) {
ret nuObject(_getClass(realm, className), args);
}*/
static <A> A nuObject(Class<A> c, Object... args) { try {
Constructor m = nuObject_findConstructor(c, args);
m.setAccessible(true);
return (A) m.newInstance(args);
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static Constructor nuObject_findConstructor(Class c, Object... args) {
for (Constructor m : c.getDeclaredConstructors()) {
if (!nuObject_checkArgs(m.getParameterTypes(), args, false))
continue;
return m;
}
throw new RuntimeException("Constructor with " + args.length + " matching parameter(s) not found in " + c.getName());
}
static boolean nuObject_checkArgs(Class[] types, Object[] args, boolean debug) {
if (types.length != args.length) {
if (debug)
System.out.println("Bad parameter length: " + args.length + " vs " + types.length);
return false;
}
for (int i = 0; i < types.length; i++)
if (!(args[i] == null || isInstanceX(types[i], args[i]))) {
if (debug)
System.out.println("Bad parameter " + i + ": " + args[i] + " vs " + types[i]);
return false;
}
return true;
}
static int pointArrowsToArea_inset = 20;
static double pointArrowsToArea_defaultSeconds = 5;
static List<JWindow> pointArrowsToArea(Rect r) {
return pointArrowsToArea(r.getRectangle());
}
static List<JWindow> pointArrowsToArea(Rectangle r) {
return pointArrowsToArea(r, pointArrowsToArea_defaultSeconds);
}
static List<JWindow> pointArrowsToArea(Rectangle r, double seconds) {
int midX = r.x+r.width/2, midY = r.y+r.height/2;
int inset = pointArrowsToArea_inset;
String iLeft = "#1005637", iDown = "#1005636", iRight = "#1005634", iUp = "#1005635";
int rInset = -16;
List<JWindow> windows = new ArrayList<JWindow>();
BufferedImage img = loadImage2(iLeft);
addIfNotNull(windows, freeFloatingAnimation(iLeft, r.x+r.width+inset+rInset, midY-img.getHeight()/2));
img = loadImage2(iDown);
addIfNotNull(windows, freeFloatingAnimation(iDown, midX, r.y-inset-img.getHeight()));
img = loadImage2(iRight);
addIfNotNull(windows, freeFloatingAnimation(iRight, r.x-inset-img.getWidth(), midY-img.getHeight()/2));
img = loadImage2(iUp);
addIfNotNull(windows, freeFloatingAnimation(iUp, midX, r.y+r.height+inset));
return disposeWindowsAfter(secondsToMS(seconds), windows);
}
static void readLocally(String progID, String varNames) {
readLocally2(mc(), progID, varNames);
}
static void readLocally(String varNames) {
readLocally2(mc(), programID(), varNames);
}
static void readLocally2(Object obj, String varNames) {
readLocally2(obj, programID(), varNames);
}
// read a string variable from standard storage
// does not overwrite variable contents if there is no file
static synchronized void readLocally2(Object obj, String progID, String varNames) {
for (String variableName : codeTokensOnly(javaTok(varNames))) {
File textFile = new File(programDir(progID), variableName + ".text");
String value = loadTextFile(textFile);
if (value != null)
set(main.class, variableName, value);
else {
File structureFile = new File(programDir(progID), variableName + ".structure");
value = loadTextFile(structureFile);
if (value == null) {
File structureGZFile = new File(programDir(progID), variableName + ".structure.gz");
value = loadGZTextFile(structureGZFile);
}
if (value != null)
readLocally_set(obj, variableName, unstructure(value));
}
}
}
static void readLocally_set(Object c, String varName, Object value) {
Object oldValue = get(c, varName);
if (oldValue instanceof List && !(oldValue instanceof ArrayList) && value != null) {
// Assume it's a synchroList.
value = synchroList((List) value);
}
set(c, varName, value);
}
static String getClassName(Object o) {
return o == null ? "null" : o.getClass().getName();
}
static String javaTokWordWrap(String s) {
int cols = 120, col = 0;
List<String> tok = javaTok(s);
for (int i = 0; i < l(tok); i++) {
String t = tok.get(i);
if (odd(i) && col >= cols && !containsNewLine(t))
tok.set(i, t += "\n");
int idx = t.lastIndexOf('\n');
if (idx >= 0) col = l(t)-(idx+1);
else col += l(t);
}
return join(tok);
}
static Object deref(Object o) {
if (o instanceof Derefable) o = ((Derefable) o).get();
return o;
}
static File javaxDataDir_dir; // can be set to work on different base dir
static File javaxDataDir() {
return javaxDataDir_dir != null ? javaxDataDir_dir : new File(userHome(), "JavaX-Data");
}
static <A, B> Set<A> keys(Map<A, B> map) {
return map.keySet();
}
static Set keys(Object map) {
return keys((Map) map);
}
static <A, B> Collection<B> values(Map<A, B> map) {
return map == null ? emptyList() : map.values();
}
static Str concept(String name) {
for (Str s : list(Str.class))
if (eqic(s.name, name) || containsIgnoreCase(s.otherNames, name))
return s;
return new Str(name);
}
static void warnIfOddCount(Object... list) {
if (odd(l(list)))
warn("Odd list size: " + struct(list));
}
static JLabel jlabel(String text) {
return new JLabel(text);
}
static JLabel jlabel() {
return jlabel(" ");
}
static void savePNG(BufferedImage img, File file) { try {
ImageIO.write(img, "png", mkdirsFor(file));
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
// gotta love convenience & program-smartness
static void savePNG(File file, BufferedImage img) {
savePNG(img, file);
}
static List<String> getTableLine(JTable tbl, int row) {
if (row >= 0 && row < tbl.getModel().getRowCount()) {
List<String> l = new ArrayList<String>();
for (int i = 0; i < tbl.getModel().getColumnCount(); i++)
l.add(String.valueOf(tbl.getModel().getValueAt(row, i)));
return l;
}
return null;
}
static String ymd() {
return year() + formatInt(month(), 2) + formatInt(dayOfMonth(), 2);
}
static void load(String varName) {
readLocally(varName);
}
static void load(String progID, String varName) {
readLocally(progID, varName);
}
static long now_virtualTime;
static long now() {
return now_virtualTime != 0 ? now_virtualTime : System.currentTimeMillis();
}
static <A extends Concept> Object[] expandParams(Class<A> c, Object[] params) {
if (l(params) == 1)
params = new Object[] { singleFieldName(c), params[0] };
else
warnIfOddCount(params);
return params;
}
static String shortClassName(Object o) {
if (o == null) return null;
Class c = o instanceof Class ? (Class) o : o.getClass();
String name = c.getName();
return shortenClassName(name);
}
// first delay = delay
static void installTimer(JComponent component, Runnable r, long delay) {
installTimer(component, r, delay, delay);
}
// first delay = delay
static void installTimer(RootPaneContainer frame, long delay, Runnable r) {
installTimer(frame.getRootPane(), r, delay, delay);
}
// first delay = delay
static void installTimer(JComponent component, long delay, Runnable r) {
installTimer(component, r, delay, delay);
}
static void installTimer(JComponent component, long delay, long firstDelay, Runnable r) {
installTimer(component, r, delay, firstDelay);
}
static void installTimer(final JComponent component, final Runnable r, final long delay, final long firstDelay) {
installTimer(component, r, delay, firstDelay, true);
}
static void installTimer(final JComponent component, final Runnable r, final long delay, final long firstDelay, final boolean repeats) {
swingLater(new Runnable() { public void run() { try {
final Timer timer = new Timer(toInt(delay), new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent _evt) {
try { /* pcall 1*/
if (!allPaused())
r.run();
/* pcall 2 */ } catch (Throwable __e) { printStackTrace(__e); }
}});
timer.setInitialDelay(toInt(firstDelay));
timer.setRepeats(repeats);
bindTimerToComponent(timer, component);
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } });
}
static void installTimer(JFrame frame, long delay, long firstDelay, Runnable r) {
installTimer(frame.getRootPane(), r, delay, firstDelay);
}
static boolean checkConceptFields(Concept x, Object... data) {
for (int i = 0; i < l(data); i += 2)
if (neq(cget(x, (String) data[i]), deref(data[i+1])))
return false;
return true;
}
static String programID() {
return getProgramID();
}
static File getProgramFile(String progID, String fileName) {
if (new File(fileName).isAbsolute())
return new File(fileName);
return new File(getProgramDir(progID), fileName);
}
static File getProgramFile(String fileName) {
return getProgramFile(getProgramID(), fileName);
}
static void saveLocally(String variableName) {
saveLocally(programID(), variableName);
}
static void saveLocally(String progID, String variableName) {
saveLocally2(mc(), progID, variableName);
}
static void saveLocally2(Object obj, String variableName) {
saveLocally2(obj, programID(), variableName);
}
static synchronized void saveLocally2(Object obj, String progID, String variableName) {
File textFile = new File(programDir(progID), variableName + ".text");
File structureFile = new File(programDir(progID), variableName + ".structure");
Object x = get(obj, variableName);
if (x == null) {
textFile.delete();
structureFile.delete();
} else if (x instanceof String) {
saveTextFile(textFile, (String) x);
structureFile.delete();
} else {
saveTextFile(structureFile, structure(x));
textFile.delete();
}
}
static int hours() {
return Calendar.getInstance().get(Calendar.HOUR_OF_DAY);
}
static boolean nempty(Collection c) {
return !isEmpty(c);
}
static boolean nempty(CharSequence s) {
return !isEmpty(s);
}
static boolean nempty(Object[] o) {
return !isEmpty(o);
}
static boolean nempty(Map m) {
return !isEmpty(m);
}
static boolean nempty(Iterator i) {
return i != null && i.hasNext();
}
static boolean structure_showTiming, structure_checkTokenCount;
static String structure(Object o) {
structure_Data d = new structure_Data();
structure_1(o, d);
while (nempty(d.stack))
popLast(d.stack).run();
String s = str(d.out);
if (structure_checkTokenCount) {
print("token count=" + d.n);
assertEquals("token count", l(javaTokC(s)), d.n);
}
return s;
}
// leave to false, unless unstructure() breaks
static boolean structure_allowShortening = false;
static int structure_shareStringsLongerThan = 20;
static class structure_Data {
StringBuilder out = new StringBuilder();
int stringSizeLimit;
IdentityHashMap<Object, Integer> seen = new IdentityHashMap<Object, Integer>();
BitSet refd = new BitSet();
HashMap<String, Integer> strings = new HashMap<String, Integer>();
HashSet<String> concepts = new HashSet<String>();
HashMap<Class, List<Field>> fieldsByClass = new HashMap();
Class conceptClass = findClass("Concept");
int n; // token count
List<Runnable> stack = new ArrayList<Runnable>();
// append single token
structure_Data append(String token) { out.append(token); ++n; return this; }
structure_Data append(int i) { out.append(i); ++n; return this; }
// append multiple tokens
structure_Data append(String token, int tokCount) { out.append(token); n += tokCount; return this; }
// extend last token
structure_Data app(String token) { out.append(token); return this; }
structure_Data app(int i) { out.append(i); return this; }
}
static void structure_1(Object o, final structure_Data d) {
final StringBuilder out = d.out;
if (o == null) { d.append("null"); return; }
Class c = o.getClass();
String name = c.getName();
String dynName = shortDynamicClassName(o);
boolean concept = d.conceptClass != null && d.conceptClass.isInstance(o);
List<Field> lFields = d.fieldsByClass.get(c);
if (lFields == null) {
// these are never back-referenced (for readability)
if (o instanceof Number) {
if (o instanceof Integer) { out.append(((Integer) o).intValue()); d.n++; return; }
if (o instanceof Long) { out.append(((Long) o).longValue()).append("L"); d.n++; return; }
if (o instanceof Float) { d.append("fl ", 2); quote_impl(str(o), out); return; }
if (o instanceof Double) { d.append("d(", 3); quote_impl(str(o), out); d.append(")"); return; }
if (o instanceof BigInteger) { out.append("bigint(").append(o).append(")"); d.n += 4; return; }
}
if (o instanceof Boolean) {
d.append(((Boolean) o).booleanValue() ? "t" : "f"); return;
}
if (o instanceof Character) {
d.append(quoteCharacter((Character) o)); return;
}
if (o instanceof File) {
d.append("File ").append(quote(((File) o).getPath())); return;
}
// referencable objects follow
Integer ref = d.seen.get(o);
if (o instanceof String && ref == null)
ref = d.strings.get((String) o);
if (ref != null) {
d.refd.set(ref);
d.append("t").app(ref); return;
}
ref = d.n; //d.seen.size()+1;
d.seen.put(o, ref);
//d.append("m").app(ref).app(" "); // marker
if (o instanceof String) {
String s = d.stringSizeLimit != 0 ? shorten((String) o, d.stringSizeLimit) : (String) o;
if (l(s) >= structure_shareStringsLongerThan)
d.strings.put(s, ref);
quote_impl(s, out); d.n++; return;
}
if (o instanceof HashSet) {
d.append("hashset ");
structure_1(new ArrayList((Set) o), d);
return;
}
if (o instanceof TreeSet) {
d.append("treeset ");
structure_1(new ArrayList((Set) o), d);
return;
}
if (o instanceof Collection && neq(name, "main$Concept$RefL")) {
d.append("[");
final int l = out.length();
final Iterator it = ((Collection) o).iterator();
d.stack.add(new Runnable() { public void run() { try {
if (!it.hasNext())
d.append("]");
else {
d.stack.add(this);
if (out.length() != l) d.append(", ");
structure_1(it.next(), d);
}
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } });
return;
}
if (o instanceof Map) {
if (o instanceof HashMap) d.append("hm");
d.append("{");
final int l = out.length();
final Iterator it = ((Map) o).entrySet().iterator();
d.stack.add(new Runnable() {
boolean v;
Map.Entry e;
public void run() {
if (v) {
d.append("=");
v = false;
d.stack.add(this);
structure_1(e.getValue(), d);
} else {
if (!it.hasNext())
d.append("}");
else {
e = (Map.Entry) it.next();
v = true;
d.stack.add(this);
if (out.length() != l) d.append(", ");
structure_1(e.getKey(), d);
}
}
}
});
return;
}
if (c.isArray()) {
if (o instanceof byte[]) {
d.append("ba ").append(quote(bytesToHex((byte[]) o))); return;
}
int n = Array.getLength(o);
if (o instanceof boolean[]) {
String hex = boolArrayToHex((boolean[]) o);
int i = l(hex);
while (i > 0 && hex.charAt(i-1) == '0' && hex.charAt(i-2) == '0') i -= 2;
d.append("boolarray ").append(n).app(" ").append(quote(substring(hex, 0, i))); return;
}
String atype = "array", sep = ", ";
if (o instanceof int[]) {
//ret "intarray " + quote(intArrayToHex((int[]) o));
atype = "intarray";
sep = " ";
}
d.append(atype).append("{");
for (int i = 0; i < n; i++) {
if (i != 0) d.append(sep);
structure_1(Array.get(o, i), d);
}
d.append("}"); return;
}
if (o instanceof Class) {
d.append("class(", 2).append(quote(((Class) o).getName())).append(")"); return;
}
if (o instanceof Throwable) {
d.append("exception(", 2).append(quote(((Throwable) o).getMessage())).append(")"); return;
}
if (o instanceof BitSet) {
BitSet bs = (BitSet) o;
d.append("bitset{", 2);
int l = out.length();
for (int i = bs.nextSetBit(0); i >= 0; i = bs.nextSetBit(i+1)) {
if (out.length() != l) d.append(", ");
d.append(i);
}
d.append("}"); return;
}
// Need more cases? This should cover all library classes...
if (name.startsWith("java.") || name.startsWith("javax.")) {
d.append("j ").append(quote(str(o))); return; // Hm. this is not unstructure-able
}
/*if (name.equals("main$Lisp")) {
fail("lisp not supported right now");
}*/
if (concept && !d.concepts.contains(dynName)) {
d.concepts.add(dynName);
d.append("c ");
}
// serialize an object with fields.
// first, collect all fields and values in fv.
TreeSet<Field> fields = new TreeSet<Field>(new Comparator<Field>() {
public int compare(Field a, Field b) {
return stdcompare(a.getName(), b.getName());
}
});
while (c != Object.class) {
for (Field field : getDeclaredFields_cached(c)) {
if ((field.getModifiers() & (Modifier.STATIC | Modifier.TRANSIENT)) != 0)
continue;
String fieldName = field.getName();
fields.add(field);
// put special cases here...
}
c = c.getSuperclass();
}
lFields = asList(fields);
// Render this$1 first because unstructure needs it for constructor call.
for (int i = 0; i < l(lFields); i++) {
Field f = lFields.get(i);
if (f.getName().equals("this$1")) {
lFields.remove(i);
lFields.add(0, f);
break;
}
}
d.fieldsByClass.put(c, lFields);
}
LinkedHashMap<String, Object> fv = new LinkedHashMap<String, Object>();
for (Field f : lFields) {
Object value;
try {
value = f.get(o);
} catch (Exception e) {
value = "?";
}
if (value != null)
fv.put(f.getName(), value);
}
String shortName = dropPrefix("main$", name);
// Now we have fields & values. Process fieldValues if it's a DynamicObject.
// omit field "className" if equal to class's name
if (concept && eq(fv.get("className"), shortName))
fv.remove("className");
if (o instanceof DynamicObject) {
fv.putAll((Map) fv.get("fieldValues"));
fv.remove("fieldValues");
shortName = dynName;
fv.remove("className");
}
String singleField = fv.size() == 1 ? first(fv.keySet()) : null;
d.append(shortName);
final int l = out.length();
final Iterator it = fv.entrySet().iterator();
d.stack.add(new Runnable() { public void run() { try {
if (!it.hasNext()) {
if (out.length() != l)
d.append(")");
} else {
Map.Entry e = (Map.Entry) it.next();
d.append(out.length() == l ? "(" : ", ");
d.append((String) e.getKey()).append("=");
d.stack.add(this);
structure_1(e.getValue(), d);
}
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } });
}
static float darkenScreenArea_factor = 0.5f;
static JWindow darkenScreenArea(Rectangle r, double seconds) {
return disposeWindowAfter(iround(seconds*1000),
darkenScreenArea(r));
}
static JWindow darkenScreenArea(final Rectangle r) {
return (JWindow) swingAndWait(new Object() { Object get() {
Rectangle r2 = maxWindowBounds().intersection(r);
if (neq(r, r2)) warn("darkenScreenArea: Rectangle cropped");
if (r2.isEmpty()) return null;
BufferedImage img = shootScreen2(r2);
RescaleOp op = new RescaleOp(darkenScreenArea_factor, 0, null);
img = op.filter(img, null);
JLabel label = new JLabel(imageIcon(img));
JWindow w = new JWindow();
w.setBounds(r2);
w.add(label);
w.setAlwaysOnTop(true);
w.setVisible(true);
return w;
}
public String toString() { return "Rectangle r2 = maxWindowBounds().intersection(r);\n if (neq(r, r2)) warn(\"darkenScreenArea: Rectangle cropped\");\n if (r2.isEmpty()) null;\n \n BufferedImage img = shootScreen2(r2);\n RescaleOp op = new RescaleOp(darkenScreenArea_factor, 0, null);\n img = op.filter(img, null);\n \n JLabel label = new JLabel(imageIcon(img));\n JWindow w = new JWindow();\n w.setBounds(r2);\n w.add(label);\n w.setAlwaysOnTop(true);\n w.setVisible(true);\n ret w;"; }});
}
static volatile StringBuffer local_log = new StringBuffer(); // not redirected
static volatile StringBuffer print_log = local_log; // might be redirected, e.g. to main bot
// in bytes - will cut to half that
static volatile int print_log_max = 1024*1024;
static volatile int local_log_max = 100*1024;
//static int print_maxLineLength = 0; // 0 = unset
static boolean print_silent; // total mute if set
static void print() {
print("");
}
// slightly overblown signature to return original object...
static <A> A print(A o) {
ping();
if (print_silent) return o;
String s = String.valueOf(o) + "\n";
print_noNewLine(s);
return o;
}
static void print_noNewLine(String s) {
// TODO if (print_maxLineLength != 0)
StringBuffer loc = local_log;
StringBuffer buf = print_log;
int loc_max = print_log_max;
if (buf != loc && buf != null) {
print_append(buf, s, print_log_max);
loc_max = local_log_max;
}
if (loc != null)
print_append(loc, s, loc_max);
System.out.print(s);
}
static void print(long l) {
print(String.valueOf(l));
}
static void print(char c) {
print(String.valueOf(c));
}
static void print_append(StringBuffer buf, String s, int max) {
synchronized(buf) {
buf.append(s);
max /= 2;
if (buf.length() > max) try {
int newLength = max/2;
int ofs = buf.length()-newLength;
String newString = buf.substring(ofs);
buf.setLength(0);
buf.append("[...] ").append(newString);
} catch (Exception e) {
buf.setLength(0);
}
}
}
static Object getOpt(Object o, String field) {
return getOpt_cached(o, field);
}
static Object getOpt_raw(Object o, String field) {
try {
Field f = getOpt_findField(o.getClass(), field);
if (f == null) return null;
f.setAccessible(true);
return f.get(o);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
static Object getOpt(Class c, String field) {
try {
if (c == null) return null;
Field f = getOpt_findStaticField(c, field);
if (f == null) return null;
f.setAccessible(true);
return f.get(null);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
static Field getOpt_findStaticField(Class<?> c, String field) {
Class _c = c;
do {
for (Field f : _c.getDeclaredFields())
if (f.getName().equals(field) && (f.getModifiers() & Modifier.STATIC) != 0)
return f;
_c = _c.getSuperclass();
} while (_c != null);
return null;
}
static Field getOpt_findField(Class<?> c, String field) {
Class _c = c;
do {
for (Field f : _c.getDeclaredFields())
if (f.getName().equals(field))
return f;
_c = _c.getSuperclass();
} while (_c != null);
return null;
}
static int year() {
return Calendar.getInstance().get(Calendar.YEAR);
}
static Object callFunction(Object f, Object... args) {
if (f == null) return null;
if (f instanceof Runnable) {
((Runnable) f).run();
return null;
} else if (f instanceof String)
return call(mc(), (String) f, args);
else
return call(f, "get", args);
//else throw fail("Can't call a " + getClassName(f));
}
static <A extends Window> A disposeWindowAfter(int delay, final A w) {
if (w != null)
swingLater(delay, new Runnable() { public void run() { try {
w.dispose();
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } });
return w;
}
// Note: Doesn't show anything if are is not completely in allowed bounds
static JWindow freeFloatingAnimation(String imageID, int x, int y, double seconds) {
return disposeWindowAfter(iround(seconds*1000),
freeFloatingAnimation(imageID, x, y));
}
static JWindow freeFloatingAnimation(final String imageID, final int x, final int y) {
return (JWindow) swingAndWait(new Object() { Object get() {
JLabel label = new JLabel(imageIcon(imageID));
label.setOpaque(false);
JWindow w = new JWindow();
w.setLocation(x, y);
w.add(label); // add it to get appropriate size through pack()
w.pack();
Rectangle maxBounds = maxWindowBounds();
Rectangle r = w.getBounds();
if (!maxBounds.contains(r)) return null;
/*w.setLocation(
max(0, min(x, maxBounds.x+maxBounds.width-w.getWidth())),
max(0, min(y, maxBounds.y+maxBounds.height-w.getHeight())));*/
Rectangle r2 = intersectWithScreen(r);
BufferedImage background = shootScreen2(r2);
//w.setLayout(null);
w.remove(label);
JLayeredPane layeredPane = new JLayeredPane();
Rectangle bounds = new Rectangle(0, 0, w.getContentPane().getWidth(), w.getContentPane().getHeight());
w.add(layeredPane);
JLabel lBackground = new JLabel(imageIcon(background));
lBackground.setBounds(0, 0, r2.width, r2.height);
layeredPane.add(lBackground, new Integer(1));
label.setBounds(bounds);
layeredPane.add(label, new Integer(2));
revalidate(w);
w.setAlwaysOnTop(true);
w.setVisible(true);
return w;
}
public String toString() { return "JLabel label = new JLabel(imageIcon(imageID));\n label.setOpaque(false);\n JWindow w = new JWindow();\n w.setLocation(x, y);\n w.add(label); // add it to get appropriate size through pack()\n w.pack();\n Rectangle maxBounds = maxWindowBounds();\n Rectangle r = w.getBounds();\n if (!maxBounds.contains(r)) null;\n /*w.setLocation(\n max(0, min(x, maxBounds.x+maxBounds.width-w.getWidth())),\n max(0, min(y, maxBounds.y+maxBounds.height-w.getHeight())));*/\n \n Rectangle r2 = intersectWithScreen(r);\n BufferedImage background = shootScreen2(r2);\n //w.setLayout(null);\n w.remove(label);\n JLayeredPane layeredPane = new JLayeredPane();\n Rectangle bounds = new Rectangle(0, 0, w.getContentPane().getWidth(), w.getContentPane().getHeight());\n w.add(layeredPane);\n JLabel lBackground = new JLabel(imageIcon(background));\n lBackground.setBounds(0, 0, r2.width, r2.height);\n layeredPane.add(lBackground, new Integer(1));\n label.setBounds(bounds);\n layeredPane.add(label, new Integer(2));\n revalidate(w);\n \n w.setAlwaysOnTop(true);\n w.setVisible(true);\n ret w;"; }});
}
static String quote(Object o) {
if (o == null) return "null";
return quote(str(o));
}
static String quote(String s) {
if (s == null) return "null";
StringBuilder out = new StringBuilder();
quote_impl(s, out);
return out.toString();
}
static void quote_impl(String s, StringBuilder out) {
out.append('"');
int l = s.length();
for (int i = 0; i < l; i++) {
char c = s.charAt(i);
if (c == '\\' || c == '"')
out.append('\\').append(c);
else if (c == '\r')
out.append("\\r");
else if (c == '\n')
out.append("\\n");
else
out.append(c);
}
out.append('"');
}
static String quoteCharacter(char c) {
if (c == '\'') return "'\\''";
if (c == '\\') return "'\\\\'";
return "'" + c + "'";
}
static String shortDynamicClassName(Object o) {
if (o instanceof DynamicObject && ((DynamicObject) o).className != null)
return ((DynamicObject) o).className;
return shortClassName(o);
}
static <A extends Concept> A uniqueConcept(Class<A> c, Object... params) {
params = expandParams(c, params);
A x = findConceptWhere(c, params);
if (x == null) {
x = nuObject(c);
for (int i = 0; i+1 < l(params); i += 2)
cset(x, (String) params[i], params[i+1]);
}
return x;
}
static void printStackTrace(Throwable e) {
// we go to system.out now - system.err is nonsense
print(getStackTrace(e));
}
static void printStackTrace() {
printStackTrace(new Throwable());
}
static void printStackTrace(String indent, Throwable e) {
if (endsWithLetter(indent)) indent += " ";
printIndent(indent, getStackTrace(e));
}
static boolean allPaused() {
return ping_pauseAll;
}
static String getType(Object o) {
return getClassName(o);
}
static int dayOfMonth() {
return days();
}
// factor = 0.75 or something
static Rectangle centerScreenPart(double factor) {
int x = screenWidth(), y = screenHeight();
int w = iround(x*factor), h = iround(y*factor);
return new Rectangle((x-w)/2, (y-h)/2, w, h);
}
static void addToWindow(Component c, Component toAdd) {
JFrame frame = getFrame(c);
Container cp = frame.getContentPane();
JPanel newCP = new JPanel();
newCP.setLayout(new BorderLayout());
newCP.add(BorderLayout.CENTER, cp);
newCP.add(BorderLayout.SOUTH, toAdd);
frame.setContentPane(newCP);
// magic combo to actually relayout and repaint
frame.revalidate();
frame.repaint();
}
static String programID;
static String getProgramID() {
return nempty(programID) ? formatSnippetID(programID) : "?";
}
// TODO: ask JavaX instead
static String getProgramID(Class c) {
String id = (String) getOpt(c, "programID");
if (nempty(id))
return formatSnippetID(id);
return "?";
}
static String getProgramID(Object o) {
return getProgramID(getMainClass(o));
}
// replacement for class JavaTok
// maybe incomplete, might want to add floating point numbers
// todo also: extended multi-line strings
static int javaTok_n, javaTok_elements;
static boolean javaTok_opt;
static List<String> javaTok(String s) {
return javaTok(s, null);
}
static List<String> javaTok(String s, List<String> existing) {
++javaTok_n;
int nExisting = javaTok_opt && existing != null ? existing.size() : 0;
ArrayList<String> tok = existing != null ? new ArrayList(nExisting) : new ArrayList();
int l = s.length();
int i = 0, n = 0;
while (i < l) {
int j = i;
char c, d;
// scan for whitespace
while (j < l) {
c = s.charAt(j);
d = j+1 >= l ? '\0' : s.charAt(j+1);
if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
++j;
else if (c == '/' && d == '*') {
do ++j; while (j < l && !s.substring(j, Math.min(j+2, l)).equals("*/"));
j = Math.min(j+2, l);
} else if (c == '/' && d == '/') {
do ++j; while (j < l && "\r\n".indexOf(s.charAt(j)) < 0);
} else
break;
}
if (n < nExisting && javaTok_isCopyable(existing.get(n), s, i, j))
tok.add(existing.get(n));
else
tok.add(quickSubstring(s, i, j));
++n;
i = j;
if (i >= l) break;
c = s.charAt(i);
d = i+1 >= l ? '\0' : s.charAt(i+1);
// scan for non-whitespace
if (c == '\'' || c == '"') {
char opener = c;
++j;
while (j < l) {
if (s.charAt(j) == opener || s.charAt(j) == '\n') { // end at \n to not propagate unclosed string literal errors
++j;
break;
} else if (s.charAt(j) == '\\' && j+1 < l)
j += 2;
else
++j;
}
} else if (Character.isJavaIdentifierStart(c))
do ++j; while (j < l && (Character.isJavaIdentifierPart(s.charAt(j)) || "'".indexOf(s.charAt(j)) >= 0)); // for stuff like "don't"
else if (Character.isDigit(c)) {
do ++j; while (j < l && Character.isDigit(s.charAt(j)));
if (j < l && s.charAt(j) == 'L') ++j; // Long constants like 1L
} else if (c == '[' && d == '[') {
do ++j; while (j+1 < l && !s.substring(j, j+2).equals("]]"));
j = Math.min(j+2, l);
} else if (c == '[' && d == '=' && i+2 < l && s.charAt(i+2) == '[') {
do ++j; while (j+2 < l && !s.substring(j, j+3).equals("]=]"));
j = Math.min(j+3, l);
} else
++j;
if (n < nExisting && javaTok_isCopyable(existing.get(n), s, i, j))
tok.add(existing.get(n));
else
tok.add(quickSubstring(s, i, j));
++n;
i = j;
}
if ((tok.size() % 2) == 0) tok.add("");
javaTok_elements += tok.size();
return tok;
}
static List<String> javaTok(List<String> tok) {
return javaTok(join(tok), tok);
}
static boolean javaTok_isCopyable(String t, String s, int i, int j) {
return t.length() == j-i
&& s.regionMatches(i, t, 0, j-i); // << could be left out, but that's brave
}
static Object unstructure(String text) {
return unstructure(text, false);
}
static Object unstructure(String text, final boolean allDynamic) {
return unstructure(text, allDynamic, null);
}
static int structure_internStringsLongerThan = 50;
// classFinder: func(name) -> class (optional)
static Object unstructure(String text, final boolean allDynamic,
final Object classFinder) {
if (text == null) return null;
final List<String> tok = javaTokC(text);
final boolean debug = unstructure_debug;
class X {
int i = 0;
HashMap<Integer, Object> refs = new HashMap<Integer, Object>();
HashMap<Integer, Object> tokrefs = new HashMap<Integer, Object>();
HashSet<String> concepts = new HashSet<String>();
HashMap<String, Class> classesMap = new HashMap<String, Class>();
Object parse() {
String t = tok.get(i);
int refID = 0;
if (structure_isMarker(t, 0, l(t))) {
refID = parseInt(t.substring(1));
i++;
}
// if (debug) print("parse: " + quote(t));
int tokIndex = i;
Object o = parse_inner(refID, tokIndex);
if (refID != 0)
refs.put(refID, o);
if (o != null)
tokrefs.put(tokIndex, o);
return o;
}
Object parse_inner(int refID, int tokIndex) {
String t = tok.get(i);
// if (debug) print("parse_inner: " + quote(t));
Class c = classesMap.get(t);
if (c == null) {
if (t.startsWith("\"")) {
String s = internIfLongerThan(unquote(tok.get(i)), structure_internStringsLongerThan);
i++;
return s;
}
if (t.startsWith("'"))
return unquoteCharacter(tok.get(i++));
if (t.equals("bigint"))
return parseBigInt();
if (t.equals("d"))
return parseDouble();
if (t.equals("fl"))
return parseFloat();
if (t.equals("false") || t.equals("f")) {
i++; return false;
}
if (t.equals("true") || t.equals("t")) {
i++; return true;
}
if (t.equals("-")) {
t = tok.get(i+1);
i += 2;
return isLongConstant(t) ? (Object) (-parseLong(t)) : (Object) (-parseInt(t));
}
if (isInteger(t) || isLongConstant(t)) {
i++;
//if (debug) print("isLongConstant " + quote(t) + " => " + isLongConstant(t));
if (isLongConstant(t)) return parseLong(t);
long l = parseLong(t);
boolean isInt = l == (int) l;
if (debug)
print("l=" + l + ", isInt: " + isInt);
return isInt ? (Object) new Integer((int) l) : (Object) new Long(l);
}
if (t.equals("File")) {
File f = new File(unquote(tok.get(i+1)));
i += 2;
return f;
}
if (t.startsWith("r") && isInteger(t.substring(1))) {
i++;
int ref = Integer.parseInt(t.substring(1));
Object o = refs.get(ref);
if (o == null)
print("Warning: unsatisfied back reference " + ref);
return o;
}
if (t.startsWith("t") && isInteger(t.substring(1))) {
i++;
int ref = Integer.parseInt(t.substring(1));
Object o = tokrefs.get(ref);
if (o == null)
print("Warning: unsatisfied token reference " + ref);
return o;
}
if (t.equals("hashset"))
return parseHashSet();
if (t.equals("treeset"))
return parseTreeSet();
if (eqOneOf(t, "hashmap", "hm"))
return parseHashMap();
if (t.equals("{"))
return parseMap();
if (t.equals("["))
return parseList();
if (t.equals("bitset"))
return parseBitSet();
if (t.equals("array") || t.equals("intarray"))
return parseArray();
if (t.equals("ba")) {
String hex = unquote(tok.get(i+1));
i += 2;
return hexToBytes(hex);
}
if (t.equals("boolarray")) {
int n = parseInt(tok.get(i+1));
String hex = unquote(tok.get(i+2));
i += 6;
return boolArrayFromBytes(hexToBytes(hex), n);
}
if (t.equals("class"))
return parseClass();
if (t.equals("l"))
return parseLisp();
if (t.equals("null")) {
i++; return null;
}
/* in dev.
if (!allDynamic && t.equals("run")) {
S snippetID = unquote(t.get(i+1));
i += 2;
run(
}
*/
if (eq(t, "c")) {
consume("c");
t = tok.get(i);
assertTrue(isJavaIdentifier(t));
concepts.add(t);
}
}
if (c == null && !isJavaIdentifier(t))
throw new RuntimeException("Unknown token " + (i+1) + ": " + t);
// any other class name
if (c == null) {
// First, find class
if (allDynamic) c = null;
else if (classFinder != null)
c = (Class) callF(classFinder, t);
else
c = findClass(t);
if (c != null)
classesMap.put(t, c);
}
// Check if it has an outer reference
i++;
boolean hasOuter = eq(get(tok, i), "(") && eq(get(tok, i+1), "this$1");
DynamicObject dO = null;
Object o = null;
if (c != null)
o = hasOuter ? nuStubInnerObject(c) : nuEmptyObject(c);
else {
if (concepts.contains(t) && (c = findClass("Concept")) != null)
o = dO = (DynamicObject) nuEmptyObject(c);
else
dO = new DynamicObject();
dO.className = t;
if (debug) print("Made dynamic object " + t + " " + shortClassName(dO));
}
// Save in references list early because contents of object
// might link back to main object
if (refID != 0)
refs.put(refID, o != null ? o : dO);
tokrefs.put(tokIndex, o != null ? o : dO);
// NOW parse the fields!
Map<String, Object> fields = new TreeMap<String, Object>();
if (i < tok.size() && tok.get(i).equals("(")) {
consume("(");
while (!tok.get(i).equals(")")) {
String key = unquote(tok.get(i));
i++;
consume("=");
Object value = parse();
fields.put(key, value);
if (tok.get(i).equals(",")) i++;
}
consume(")");
}
if (o != null)
if (dO != null) {
if (debug)
printStructure("setOptAllDyn", fields);
setOptAllDyn(dO, fields);
} else
setOptAll(o, fields);
else for (String field : keys(fields))
dO.fieldValues.put(field.intern(), fields.get(field));
if (o != null)
pcallOpt_noArgs(o, "_doneLoading");
return o != null ? o : dO;
}
Object parseSet(Set set) {
set.addAll((List) parseList());
return set;
}
Object parseLisp() {
consume("l");
consume("(");
ArrayList list = new ArrayList();
while (!tok.get(i).equals(")")) {
list.add(parse());
if (tok.get(i).equals(",")) i++;
}
consume(")");
return newObject("main$Lisp", (String) list.get(0), subList(list, 1));
}
Object parseBitSet() {
consume("bitset");
consume("{");
BitSet bs = new BitSet();
while (!tok.get(i).equals("}")) {
bs.set((Integer) parse());
if (tok.get(i).equals(",")) i++;
}
consume("}");
return bs;
}
Object parseList() {
consume("[");
ArrayList list = new ArrayList();
while (!tok.get(i).equals("]")) {
Object o = parse();
//if (debug) print("List element type: " + getClassName(o));
list.add(o);
if (tok.get(i).equals(",")) i++;
}
consume("]");
return list;
}
Object parseArray() {
String type = tok.get(i);
i++;
consume("{");
List list = new ArrayList();
while (!tok.get(i).equals("}")) {
list.add(parse());
if (tok.get(i).equals(",")) i++;
}
consume("}");
if (type.equals("intarray"))
return toIntArray(list);
return list.toArray();
}
Object parseClass() {
consume("class");
consume("(");
String name = tok.get(i);
i++;
consume(")");
Class c = allDynamic ? null : findClass(name);
if (c != null) return c;
DynamicObject dO = new DynamicObject();
dO.className = "java.lang.Class";
dO.fieldValues.put("name", name);
return dO;
}
Object parseBigInt() {
consume("bigint");
consume("(");
String val = tok.get(i);
i++;
if (eq(val, "-")) {
val = "-" + tok.get(i);
i++;
}
consume(")");
return new BigInteger(val);
}
Object parseDouble() {
consume("d");
consume("(");
String val = unquote(tok.get(i));
i++;
consume(")");
return Double.parseDouble(val);
}
Object parseFloat() {
consume("fl");
String val;
if (eq(tok.get(i), "(")) {
consume("(");
val = unquote(tok.get(i));
i++;
consume(")");
} else {
val = unquote(tok.get(i));
i++;
}
return Float.parseFloat(val);
}
Object parseHashMap() {
i++;
return parseMap(new HashMap());
}
Object parseHashSet() {
consume("hashset");
return parseSet(new HashSet());
}
Object parseTreeSet() {
consume("treeset");
return parseSet(new TreeSet());
}
Object parseMap() {
return parseMap(new TreeMap());
}
Object parseMap(Map map) {
consume("{");
while (!tok.get(i).equals("}")) {
Object key = parse();
consume("=");
Object value = parse();
map.put(key, value);
if (tok.get(i).equals(",")) i++;
}
consume("}");
return map;
}
void consume(String s) {
if (!tok.get(i).equals(s)) {
String prevToken = i-1 >= 0 ? tok.get(i-1) : "";
String nextTokens = join(tok.subList(i, Math.min(i+2, tok.size())));
throw fail(quote(s) + " expected: " + prevToken + " " + nextTokens + " (" + i + "/" + tok.size() + ")");
}
i++;
}
}
return new X().parse();
}
static boolean unstructure_debug;
//please include function withMargin.
static int showForm_defaultGap = 4;
static JComponent showFormTitled(String title, Object... _parts) {
List<List> l = new ArrayList<List>();
final Var<JFrame> frame = new Var<JFrame>();
List parts = asList(_parts);
Runnable submit = null;
for (int i = 0; i < l(parts); i++) {
final Object o = parts.get(i), next = get(parts, i+1);
if (o instanceof Runnable)
l.add(ll(null, jbutton("Submit", submit = new Runnable() { public void run() { try {
Object result = call(o);
if (neq(Boolean.FALSE, result))
disposeFrame(frame.get());
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } })));
else if (o instanceof Component || o instanceof String || next instanceof Component) { // smartAdd accepts strings
l.add(ll(o == null ? new JPanel(): o, next));
i++;
}
else print("showForm: Unknown element type: " + getClassName(o));
}
List<JTextField> textFields = collectInstances(flattenList(l), JTextField.class);
if (l(textFields) == 1)
onEnter(first(textFields), submit);
JPanel panel = hvgrid(l, showForm_defaultGap);
frame.set(minFrameWidth(showPackedFrame(title, withMargin(panel)), 400));
return panel;
}
static long secondsToMS(double seconds) {
return toMS(seconds);
}
static <A> List<A> subList(List<A> l, int startIndex) {
return subList(l, startIndex, l(l));
}
static <A> List<A> subList(List<A> l, int startIndex, int endIndex) {
startIndex = max(0, min(l(l), startIndex));
endIndex = max(0, min(l(l), endIndex));
if (startIndex > endIndex) return litlist();
return l.subList(startIndex, endIndex);
}
static String renderConcept(Concept.Ref ref) {
return renderConcept(ref.get());
}
static String renderConcept(Concept c) {
if (c == null) return "null";
StringBuilder buf = new StringBuilder();
buf.append(c.id + " " + shortDynamicClassName(c));
for (String field : conceptFields(c)) {
Object val = cget(c, field);
if (val != null) {
if (eq(val, Boolean.FALSE) && isPrimitiveBoolField(c, field)) continue;
buf.append(" " + field + "=");
buf.append(renderConcept_short(val));
}
}
return str(buf);
}
static String renderConcept_short(Object val) {
if (val instanceof Concept)
return shortDynamicClassName(val) + ((Concept) val).id;
else if (val instanceof Concept.RefL)
return "[" + join(", ", map((List) val, "renderConcept_short")) + "]";
else
return struct(val);
}
static void setFrameBounds(Component c, Rectangle bounds) {
JFrame f = getFrame(c);
if (f != null) {
f.setBounds(bounds);
revalidate(f);
}
}
static Object call(Object o) {
return callFunction(o);
}
// varargs assignment fixer for a single string array argument
static Object call(Object o, String method, String[] arg) {
return call(o, method, new Object[] {arg});
}
static Object call(Object o, String method, Object... args) {
try {
if (o instanceof Class) {
Method m = call_findStaticMethod((Class) o, method, args, false);
m.setAccessible(true);
return m.invoke(null, args);
} else {
Method m = call_findMethod(o, method, args, false);
m.setAccessible(true);
return m.invoke(o, args);
}
} catch (Exception e) {
throw e instanceof RuntimeException ? (RuntimeException) e : new RuntimeException(e);
}
}
static Method call_findStaticMethod(Class c, String method, Object[] args, boolean debug) {
Class _c = c;
while (c != null) {
for (Method m : c.getDeclaredMethods()) {
if (debug)
System.out.println("Checking method " + m.getName() + " with " + m.getParameterTypes().length + " parameters");;
if (!m.getName().equals(method)) {
if (debug) System.out.println("Method name mismatch: " + method);
continue;
}
if ((m.getModifiers() & Modifier.STATIC) == 0 || !call_checkArgs(m, args, debug))
continue;
return m;
}
c = c.getSuperclass();
}
throw new RuntimeException("Method '" + method + "' (static) with " + args.length + " parameter(s) not found in " + _c.getName());
}
static Method call_findMethod(Object o, String method, Object[] args, boolean debug) {
Class c = o.getClass();
while (c != null) {
for (Method m : c.getDeclaredMethods()) {
if (debug)
System.out.println("Checking method " + m.getName() + " with " + m.getParameterTypes().length + " parameters");;
if (m.getName().equals(method) && call_checkArgs(m, args, debug))
return m;
}
c = c.getSuperclass();
}
throw new RuntimeException("Method '" + method + "' (non-static) with " + args.length + " parameter(s) not found in " + o.getClass().getName());
}
private static boolean call_checkArgs(Method m, Object[] args, boolean debug) {
Class<?>[] types = m.getParameterTypes();
if (types.length != args.length) {
if (debug)
System.out.println("Bad parameter length: " + args.length + " vs " + types.length);
return false;
}
for (int i = 0; i < types.length; i++)
if (!(args[i] == null || isInstanceX(types[i], args[i]))) {
if (debug)
System.out.println("Bad parameter " + i + ": " + args[i] + " vs " + types[i]);
return false;
}
return true;
}
static HashMap<Class, Field[]> getDeclaredFields_cache = new HashMap();
static Field[] getDeclaredFields_cached(Class c) {
Field[] fields;
synchronized(getDeclaredFields_cache) {
fields = getDeclaredFields_cache.get(c);
if (fields == null) {
getDeclaredFields_cache.put(c, fields = c.getDeclaredFields());
for (Field f : fields)
f.setAccessible(true);
}
}
return fields;
}
static boolean loadBufferedImage_useImageCache = true;
static BufferedImage loadBufferedImage(String snippetIDOrURL) { try {
if (snippetIDOrURL == null) return null;
if (isURL(snippetIDOrURL))
return ImageIO.read(new URL(snippetIDOrURL));
if (!isSnippetID(snippetIDOrURL)) throw fail("Not a URL or snippet ID: " + snippetIDOrURL);
String snippetID = "" + parseSnippetID(snippetIDOrURL);
try {
File dir = getCacheProgramDir("Image-Snippets");
if (loadBufferedImage_useImageCache) {
dir.mkdirs();
File file = new File(dir, snippetID + ".png");
if (file.exists() && file.length() != 0)
try {
return ImageIO.read(file);
} catch (Throwable e) {
e.printStackTrace();
// fall back to loading from sourceforge
}
}
String imageURL = snippetImageURL(snippetID);
System.err.println("Loading image: " + imageURL);
BufferedImage image = ImageIO.read(new URL(imageURL));
if (loadBufferedImage_useImageCache) {
File tempFile = new File(dir, snippetID + ".tmp." + System.currentTimeMillis());
ImageIO.write(image, "png", tempFile);
tempFile.renameTo(new File(dir, snippetID + ".png"));
//Log.info("Cached image.");
}
//Log.info("Loaded image.");
return image;
} catch (IOException e) {
throw new RuntimeException(e);
}
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static BufferedImage loadBufferedImage(File file) { try {
return file.isFile() ? ImageIO.read(file) : null;
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static String boolArrayToHex(boolean[] a) {
return bytesToHex(boolArrayToBytes(a));
}
static boolean startsWithIgnoreCase(String a, String b) {
return a != null && a.regionMatches(true, 0, b, 0, b.length());
}
static boolean showAnimationInTopRightCorner_alwaysOnTop = true;
// automatically switches to AWT thread for you
// text is optional text below image
static JWindow showAnimationInTopRightCorner(final String imageID, final String text) {
if (isHeadless()) return null;
return (JWindow) swingAndWait(new Object() { Object get() {
JLabel label = new JLabel(imageIcon(imageID));
if (nempty(text)) {
label.setText(text);
label.setVerticalTextPosition(SwingConstants.BOTTOM);
label.setHorizontalTextPosition(SwingConstants.CENTER);
}
final JWindow window = showInTopRightCorner(label);
onClick(label, new Runnable() { public void run() { try { window.dispose() ;
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } });
if (showAnimationInTopRightCorner_alwaysOnTop)
window.setAlwaysOnTop(true);
return window;
}
public String toString() { return "JLabel label = new JLabel(imageIcon(imageID));\n if (nempty(text)) {\n label.setText(text);\n label.setVerticalTextPosition(SwingConstants.BOTTOM);\n label.setHorizontalTextPosition(SwingConstants.CENTER);\n }\n final JWindow window = showInTopRightCorner(label);\n onClick(label, r { window.dispose() });\n if (showAnimationInTopRightCorner_alwaysOnTop)\n window.setAlwaysOnTop(true);\n ret window;"; }});
}
static JWindow showAnimationInTopRightCorner(final String imageID) {
return showAnimationInTopRightCorner(imageID, "");
}
static JWindow showAnimationInTopRightCorner(String imageID, double seconds) {
return showAnimationInTopRightCorner(imageID, "", seconds);
}
static JWindow showAnimationInTopRightCorner(String imageID, String text, double seconds) {
if (isHeadless()) return null;
return disposeWindowAfter(iround(seconds*1000),
showAnimationInTopRightCorner(imageID, text));
}
public static String bytesToHex(byte[] bytes) {
return bytesToHex(bytes, 0, bytes.length);
}
public static String bytesToHex(byte[] bytes, int ofs, int len) {
StringBuilder stringBuilder = new StringBuilder(len*2);
for (int i = 0; i < len; i++) {
String s = "0" + Integer.toHexString(bytes[ofs+i]);
stringBuilder.append(s.substring(s.length()-2, s.length()));
}
return stringBuilder.toString();
}
static String indentx(String s) {
return indentx(indent_default, s);
}
static String indentx(int n, String s) {
return dropSuffix(repeat(' ', n), indent(n, s));
}
static String indentx(String indent, String s) {
return dropSuffix(indent, indent(indent, s));
}
static File programDir_mine; // set this to relocate program's data
static File programDir() {
return programDir(getProgramID());
}
static File programDir(String snippetID) {
if (programDir_mine != null && sameSnippetID(snippetID, programID()))
return programDir_mine;
return new File(javaxDataDir(), formatSnippetID(snippetID));
}
static void onFrameClose(JFrame frame, final Runnable r) {
frame.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
r.run();
}
});
}
static JScrollPane jScrollPane(Component c) {
return new JScrollPane(c);
}
static int month() {
return Calendar.getInstance().get(Calendar.MONTH)+1;
}
static Rectangle maxWindowBounds() {
return GraphicsEnvironment.getLocalGraphicsEnvironment().getMaximumWindowBounds();
}
static <A extends Window> List<A> disposeWindowsAfter(long delay, final List<A> l) {
swingLater(delay, new Runnable() { public void run() { try { for (Window w : unnull(l)) w.dispose() ;
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } });
return l;
}
public static File mkdirsForFile(File file) {
File dir = file.getParentFile();
if (dir != null) // is null if file is in current dir
dir.mkdirs();
return file;
}
static String fromLines(List<String> lines) {
StringBuilder buf = new StringBuilder();
if (lines != null)
for (String line : lines)
buf.append(line).append('\n');
return buf.toString();
}
static String fromLines(String... lines) {
return fromLines(asList(lines));
}
static List emptyList() {
return new ArrayList();
//ret Collections.emptyList();
}
static <A> void addIfNotNull(Collection<A> l, A a) {
if (a != null)
l.add(a);
}
static <A> List<A> synchroList() {
return Collections.synchronizedList(new ArrayList<A>());
}
static <A> List<A> synchroList(List<A> l) {
return Collections.synchronizedList(l);
}
static FileOutputStream newFileOutputStream(File path) throws IOException {
return newFileOutputStream(path.getPath());
}
static FileOutputStream newFileOutputStream(String path) throws IOException {
return newFileOutputStream(path, false);
}
static FileOutputStream newFileOutputStream(String path, boolean append) throws IOException {
FileOutputStream f = new // Line break for ancient translator
FileOutputStream(path, append);
callJavaX("registerIO", f, path, true);
return f;
}
static JPanel withInset(Component c) {
return withMargin(c);
}
static String padLeft(String s, char c, int n) {
return rep(c, n-l(s)) + s;
}
// onClick: voidfunc(Point, int) - 2nd parameter is button (1 to 3)
// or voidfunc(Point)
static void trackOneClick(final Object onClick) {
forwardOneClick(new Object() { Object get(final Point p, final int button) {
swingLater(new Runnable() { public void run() { try { // Let the window go away first
callFOpt(onClick, p, button);
callFOpt(onClick, p);
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } }); return false; // don't forward click
}
public String toString() { return "awt { // Let the window go away first\n callFOpt(onClick, p, button);\n callFOpt(onClick, p);\n }\n false; // don't forward click"; }});
}
static boolean isEmpty(Collection c) {
return c == null || c.isEmpty();
}
static boolean isEmpty(CharSequence s) {
return s == null || s.length() == 0;
}
static boolean isEmpty(Object[] a) {
return a == null || a.length == 0;
}
static boolean isEmpty(Map map) {
return map == null || map.isEmpty();
}
static boolean eqic(String a, String b) {
if ((a == null) != (b == null)) return false;
if (a == null) return true;
return a.equalsIgnoreCase(b);
}
static boolean containsIgnoreCase(List<String> l, String s) {
for (String x : l)
if (eqic(x, s))
return true;
return false;
}
static boolean containsIgnoreCase(String[] l, String s) {
for (String x : l)
if (eqic(x, s))
return true;
return false;
}
static boolean containsIgnoreCase(String s, char c) {
return indexOfIgnoreCase(s, String.valueOf(c)) >= 0;
}
static boolean containsIgnoreCase(String a, String b) {
return indexOfIgnoreCase(a, b) >= 0;
}
static String dynamicClassName(Object o) {
if (o instanceof DynamicObject && ((DynamicObject) o).className != null)
return "main$" + ((DynamicObject) o).className;
return className(o);
}
static <A> A popLast(List<A> l) {
return liftLast(l);
}
static void copyStream(InputStream in, OutputStream out) { try {
byte[] buf = new byte[65536];
while (true) {
int n = in.read(buf);
if (n <= 0) return;
out.write(buf, 0, n);
}
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static String struct(Object o) {
return structure(o);
}
static String shorten(String s, int max) {
if (s == null) return "";
if (max < 0) return s;
return s.length() <= max ? s : s.substring(0, Math.min(s.length(), max)) + "...";
}
static JFrame showCenterFrame(String title, int w, int h) {
return showCenterFrame(title, w, h, null);
}
static JFrame showCenterFrame(String title, int w, int h, Component content) {
JFrame frame = makeFrame(title, content);
frame.setSize(w, h);
return centerFrame(frame);
}
static JFrame showCenterFrame(String title, Component content) {
return centerFrame(makeFrame(title, content));
}
public static String join(String glue, Iterable<String> strings) {
StringBuilder buf = new StringBuilder();
Iterator<String> i = strings.iterator();
if (i.hasNext()) {
buf.append(i.next());
while (i.hasNext())
buf.append(glue).append(i.next());
}
return buf.toString();
}
public static String join(String glue, String[] strings) {
return join(glue, Arrays.asList(strings));
}
public static String join(Iterable<String> strings) {
return join("", strings);
}
public static String join(String[] strings) {
return join("", strings);
}
static void swingAndWait(Runnable r) { try {
if (isAWTThread())
r.run();
else
EventQueue.invokeAndWait(r);
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static Object swingAndWait(final Object f) {
if (isAWTThread())
return callF(f);
else {
final Var result = new Var();
swingAndWait(new Runnable() { public void run() { try {
result.set(callF(f));
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } });
return result.get();
}
}
static String dropPrefix(String prefix, String s) {
return s.startsWith(prefix) ? s.substring(l(prefix)) : s;
}
static List<String> codeTokensOnly(List<String> tok) {
List<String> l = new ArrayList<String>();
for (int i = 1; i < tok.size(); i += 2)
l.add(tok.get(i));
return l;
}
static Map litmap(Object... x) {
TreeMap map = new TreeMap();
litmap_impl(map, x);
return map;
}
static void litmap_impl(Map map, Object... x) {
for (int i = 0; i < x.length-1; i += 2)
if (x[i+1] != null)
map.put(x[i], x[i+1]);
}
static boolean odd(int i) {
return (i & 1) != 0;
}
static String shortenClassName(String name) {
return name == null ? null : substring(name, xIndexOf(name, '$')+1);
}
static boolean isJavaIdentifier(String s) {
if (s.length() == 0 || !Character.isJavaIdentifierStart(s.charAt(0)))
return false;
for (int i = 1; i < s.length(); i++)
if (!Character.isJavaIdentifierPart(s.charAt(i)))
return false;
return true;
}
static void bindTimerToComponent(final Timer timer, JFrame f) {
bindTimerToComponent(timer, f.getRootPane());
}
static void bindTimerToComponent(final Timer timer, JComponent c) {
if (c.isShowing())
timer.start();
c.addAncestorListener(new AncestorListener() {
public void ancestorAdded(AncestorEvent event) {
timer.start();
}
public void ancestorRemoved(AncestorEvent event) {
timer.stop();
}
public void ancestorMoved(AncestorEvent event) {
}
});
}
static TimerTask timerTask(final Runnable r) {
return new TimerTask() {
public void run() {
try { /* pcall 1*/
r.run();
/* pcall 2 */ } catch (Throwable __e) { printStackTrace(__e); }
}
};
}
static volatile boolean ping_pauseAll;
static int ping_sleep = 100; // poll pauseAll flag every 100
static volatile boolean ping_anyActions;
static Map<Thread, Object> ping_actions = synchroMap(new WeakHashMap());
// returns true if it did anything
static boolean ping() { try {
if (ping_pauseAll && !isAWTThread()) {
do
Thread.sleep(ping_sleep);
while (ping_pauseAll);
return true;
}
if (ping_anyActions) {
Object action;
synchronized(mc()) {
action = ping_actions.get(currentThread());
if (action instanceof Runnable)
ping_actions.remove(currentThread());
if (ping_actions.isEmpty()) ping_anyActions = false;
}
if (action instanceof Runnable)
((Runnable) action).run();
else if (eq(action, "cancelled"))
throw fail("Thread cancelled.");
}
return false;
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static String _userHome;
static String userHome() {
if (_userHome == null) {
if (isAndroid())
_userHome = "/storage/sdcard0/";
else
_userHome = System.getProperty("user.home");
//System.out.println("userHome: " + _userHome);
}
return _userHome;
}
static File userHome(String path) {
return new File(userDir(), path);
}
static <A> ArrayList<A> litlist(A... a) {
return new ArrayList<A>(Arrays.asList(a));
}
static JFrame showFrame() {
return makeFrame();
}
static JFrame showFrame(Object content) {
return makeFrame(content);
}
static JFrame showFrame(String title) {
return makeFrame(title);
}
static JFrame showFrame(String title, Object content) {
return makeFrame(title, content);
}
static JFrame showFrame(JFrame frame) {
if (frameTooSmall(frame)) frameStandardSize(frame);
frame.setVisible(true);
return frame;
}
// make or update frame
static JFrame showFrame(String title, Object content, JFrame frame) {
if (frame == null)
return showFrame(title, content);
else {
frame.setTitle(title);
setFrameContents(frame, content);
return frame;
}
}
static String autoFrameTitle() {
return getProgramTitle();
}
static int iround(double d) {
return (int) Math.round(d);
}
static void awtOnConceptChanges(JComponent component, int delay, final Object runnable) {
awtOnConceptChanges(component, delay, delay, runnable);
}
static void awtOnConceptChanges(JComponent component, int delay, int firstDelay,
final Object runnable) {
installTimer(component, delay, firstDelay, new Runnable() {
long c;
public void run() {
long _c = changeCount();
if (_c != c) {
c = _c;
call(runnable);
}
}
});
}
static List<String> javaTokC(String s) {
int l = s.length();
ArrayList<String> tok = new ArrayList<String>();
int i = 0;
while (i < l) {
int j = i;
char c, d;
// scan for whitespace
while (j < l) {
c = s.charAt(j);
d = j+1 >= l ? '\0' : s.charAt(j+1);
if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
++j;
else if (c == '/' && d == '*') {
do ++j; while (j < l && !s.substring(j, Math.min(j+2, l)).equals("*/"));
j = Math.min(j+2, l);
} else if (c == '/' && d == '/') {
do ++j; while (j < l && "\r\n".indexOf(s.charAt(j)) < 0);
} else
break;
}
i = j;
if (i >= l) break;
c = s.charAt(i);
d = i+1 >= l ? '\0' : s.charAt(i+1);
// scan for non-whitespace
if (c == '\'' || c == '"') {
char opener = c;
++j;
while (j < l) {
if (s.charAt(j) == opener || s.charAt(j) == '\n') { // end at \n to not propagate unclosed string literal errors
++j;
break;
} else if (s.charAt(j) == '\\' && j+1 < l)
j += 2;
else
++j;
}
} else if (Character.isJavaIdentifierStart(c))
do ++j; while (j < l && (Character.isJavaIdentifierPart(s.charAt(j)) || "'".indexOf(s.charAt(j)) >= 0)); // for stuff like "don't"
else if (Character.isDigit(c)) {
do ++j; while (j < l && Character.isDigit(s.charAt(j)));
if (j < l && s.charAt(j) == 'L') ++j; // Long constants like 1L
} else if (c == '[' && d == '[') {
do ++j; while (j+1 < l && !s.substring(j, j+2).equals("]]"));
j = Math.min(j+2, l);
} else if (c == '[' && d == '=' && i+2 < l && s.charAt(i+2) == '[') {
do ++j; while (j+2 < l && !s.substring(j, j+3).equals("]=]"));
j = Math.min(j+3, l);
} else
++j;
tok.add(quickSubstring(s, i, j));
i = j;
}
return tok;
}
static <A> A assertEquals(Object x, A y) {
return assertEquals(null, x, y);
}
static <A> A assertEquals(String msg, Object x, A y) {
if (!(x == null ? y == null : x.equals(y)))
throw fail((msg != null ? msg + ": " : "") + x + " != " + y);
return y;
}
static File getProgramDir() {
return programDir();
}
static File getProgramDir(String snippetID) {
return programDir(snippetID);
}
static JTable sexyTable() {
final JTable table = tableWithToolTips();
tablePopupMenu(table, new Object() { void get(JPopupMenu menu, final int row) {
final String item = first(getTableLine(table, row));
MouseEvent e = tablePopupMenu_mouseEvent.get();
final int col = table.columnAtPoint(e.getPoint());
menu.add(jmenuItem("Copy text to clipboard", new Runnable() { public void run() { try {
String text = str(table.getModel().getValueAt(row, col));
copyTextToClipboard(text);
print("Copied text to clipboard: " + quote(text));
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } }));
menu.add(jmenuItem("Copy text to clipboard quoted", new Runnable() { public void run() { try {
String text = str(table.getModel().getValueAt(row, col));
copyTextToClipboard(quote(text));
print("Copied text to clipboard (quoted): " + quote(text));
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } }));
}
public String toString() { return "final S item = first(getTableLine(table, row));\n MouseEvent e = tablePopupMenu_mouseEvent.get();\n final int col = table.columnAtPoint(e.getPoint());\n\n menu.add(jmenuItem(\"Copy text to clipboard\", r {\n S text = str(table.getModel().getValueAt(row, col));\n copyTextToClipboard(text);\n print(\"Copied text to clipboard: \" + quote(text));\n }));\n \n menu.add(jmenuItem(\"Copy text to clipboard quoted\", r {\n S text = str(table.getModel().getValueAt(row, col));\n copyTextToClipboard(quote(text));\n print(\"Copied text to clipboard (quoted): \" + quote(text));\n }));"; }});
// Disable Ctrl+PageUp and Ctrl+PageDown
table.getInputMap().put(KeyStroke.getKeyStroke(KeyEvent.VK_PAGE_UP, InputEvent.CTRL_MASK), "none");
//table.getInputMap().put(KeyStroke.getKeyStroke(KeyEvent.VK_PAGE_DOWN, InputEvent.CTRL_MASK), "none");
/*table.registerKeyboardAction(
null,
KeyStroke.getKeyStroke(KeyEvent.VK_PAGE_UP, InputEvent.CTRL_MASK),
JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT
);*/
table.getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT)
.put(KeyStroke.getKeyStroke(KeyEvent.VK_PAGE_UP, InputEvent.CTRL_MASK), "none");
table.getInputMap(JComponent.WHEN_FOCUSED)
.put(KeyStroke.getKeyStroke(KeyEvent.VK_PAGE_UP, InputEvent.CTRL_MASK), "none");
table.getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT)
.put(KeyStroke.getKeyStroke(KeyEvent.VK_PAGE_UP, InputEvent.CTRL_MASK), "none");
table.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW)
.put(KeyStroke.getKeyStroke(KeyEvent.VK_PAGE_UP, InputEvent.CTRL_MASK), "none");
((InputMap) UIManager.get("Table.ancestorInputMap")).put(KeyStroke.getKeyStroke(KeyEvent.VK_PAGE_UP, InputEvent.CTRL_MASK), "none");
return table;
}
// action can be Runnable or a function name
static JButton newButton(String text, final Object action) {
JButton btn = new JButton(text);
if (action != null)
btn.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent _evt) {
callFunction(action);
}});
return btn;
}
static JButton imageSelectionDepend(final ImageSurface is, final JButton b) {
final Runnable prev = is.onSelectionChange;
is.onSelectionChange = new Runnable() { public void run() { try {
b.setEnabled(is.selection != null);
pcallF(prev);
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } };
b.setEnabled(is.selection != null);
return b;
}
static void fillTableWithData(final JTable table, List<List> rows, List<String> colNames) {
fillTableWithData(table, rows, toStringArray(colNames));
}
// thread-safe
static void fillTableWithData(final JTable table, List<List> rows, String... colNames) {
final DefaultTableModel model = fillTableWithData_makeModel(rows, colNames);
swingNowOrLater(new Runnable() { public void run() { try {
setTableModel(table, model);
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } });
}
static DefaultTableModel fillTableWithData_makeModel(List<List> rows, String... colNames) {
Object[][] data = new Object[rows.size()][];
int w = 0;
for (int i = 0; i < rows.size(); i++) {
List l = rows.get(i);
Object[] r = new Object[l.size()];
for (int j = 0; j < l.size(); j++) {
Object o = l.get(j);
if (o instanceof BufferedImage) o = imageIcon((BufferedImage) o);
r[j] = o;
}
data[i] = r;
w = Math.max(w, l.size());
}
Object[] columnNames = new Object[w];
for (int i = 0; i < w; i++)
columnNames[i] = i < l(colNames) ? colNames[i] : "?";
return new DefaultTableModel(data, columnNames) {
public Class getColumnClass(int column) {
return or(getValueAt(0, column).getClass(), String.class);
}
};
}
static Object pcallF(Object f, Object... args) {
return pcallFunction(f, args);
}
static RuntimeException asRuntimeException(Throwable t) {
return t instanceof RuntimeException ? (RuntimeException) t : new RuntimeException(t);
}
static Object mc() {
return getMainClass();
}
// extended over Class.isInstance() to handle primitive types
static boolean isInstanceX(Class type, Object arg) {
if (type == boolean.class) return arg instanceof Boolean;
if (type == int.class) return arg instanceof Integer;
if (type == long.class) return arg instanceof Long;
if (type == float.class) return arg instanceof Float;
if (type == short.class) return arg instanceof Short;
if (type == char.class) return arg instanceof Character;
if (type == byte.class) return arg instanceof Byte;
if (type == double.class) return arg instanceof Double;
return type.isInstance(arg);
}
static String singleFieldName(Class c) {
Set<String> l = listFields(c);
if (l(l) != 1)
throw fail("No single field found in " + c + " (have " + n(l(l), "fields") + ")");
return first(l);
}
static Rectangle screenRectangle() {
return new Rectangle(Toolkit.getDefaultToolkit().getScreenSize());
}
static String loadGZTextFile(File file) { try {
if (!file.isFile()) return null;
ByteArrayOutputStream fos = new ByteArrayOutputStream();
InputStream fis = new FileInputStream(file);
GZIPInputStream gis = new GZIPInputStream(fis);
try {
byte[] buffer = new byte[1024];
int len;
while((len = gis.read(buffer)) != -1){
fos.write(buffer, 0, len);
}
} finally {
fis.close();
}
fos.close();
return fromUtf8(fos.toByteArray()); // TODO: use a Reader
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static boolean containsNewLine(String s) {
return contains(s, '\n'); // screw \r, nobody needs it
}
static Object callOpt(Object o) {
if (o == null) return null;
return callF(o);
}
static Object callOpt(Object o, String method, Object... args) {
try {
if (o == null) return null;
if (o instanceof Class) {
Method m = callOpt_findStaticMethod((Class) o, method, args, false);
if (m == null) return null;
m.setAccessible(true);
return m.invoke(null, args);
} else {
Method m = callOpt_findMethod(o, method, args, false);
if (m == null) return null;
m.setAccessible(true);
return m.invoke(o, args);
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
static Method callOpt_findStaticMethod(Class c, String method, Object[] args, boolean debug) {
Class _c = c;
while (c != null) {
for (Method m : c.getDeclaredMethods()) {
if (debug)
System.out.println("Checking method " + m.getName() + " with " + m.getParameterTypes().length + " parameters");;
if (!m.getName().equals(method)) {
if (debug) System.out.println("Method name mismatch: " + method);
continue;
}
if ((m.getModifiers() & Modifier.STATIC) == 0 || !callOpt_checkArgs(m, args, debug))
continue;
return m;
}
c = c.getSuperclass();
}
return null;
}
static Method callOpt_findMethod(Object o, String method, Object[] args, boolean debug) {
Class c = o.getClass();
while (c != null) {
for (Method m : c.getDeclaredMethods()) {
if (debug)
System.out.println("Checking method " + m.getName() + " with " + m.getParameterTypes().length + " parameters");;
if (m.getName().equals(method) && callOpt_checkArgs(m, args, debug))
return m;
}
c = c.getSuperclass();
}
return null;
}
private static boolean callOpt_checkArgs(Method m, Object[] args, boolean debug) {
Class<?>[] types = m.getParameterTypes();
if (types.length != args.length) {
if (debug)
System.out.println("Bad parameter length: " + args.length + " vs " + types.length);
return false;
}
for (int i = 0; i < types.length; i++)
if (!(args[i] == null || isInstanceX(types[i], args[i]))) {
if (debug)
System.out.println("Bad parameter " + i + ": " + args[i] + " vs " + types[i]);
return false;
}
return true;
}
static JFrame getFrame(Object o) {
if (!(o instanceof Component)) return null;
Component c = (Component) o;
while (c != null) {
if (c instanceof JFrame) return (JFrame) c;
c = c.getParent();
}
return null;
}
static String substring(String s, int x) {
return safeSubstring(s, x);
}
static String substring(String s, int x, int y) {
return safeSubstring(s, x, y);
}
static final WeakHashMap<Class, HashMap<String, Field>> getOpt_cache = new WeakHashMap();
static final HashMap getOpt_special = new HashMap(); // just a marker
static {
getOpt_cache.put(Class.class, getOpt_special);
getOpt_cache.put(String.class, getOpt_special);
}
static Object getOpt_cached(Object o, String field) { try {
if (o == null) return null;
Class c = o.getClass();
HashMap<String, Field> map;
synchronized(getOpt_cache) {
map = getOpt_cache.get(c);
if (map == null)
map = getOpt_makeCache(c);
}
if (map == getOpt_special) {
if (o instanceof Class)
return getOpt((Class) o, field);
if (o instanceof String)
return getOpt(getBot((String) o), field);
if (o instanceof Map)
return ((Map) o).get(field);
}
Field f = map.get(field);
if (f != null) return f.get(o);
if (o instanceof DynamicObject)
return ((DynamicObject) o).fieldValues.get(field);
return null;
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
// used internally - we are in synchronized block
static HashMap<String, Field> getOpt_makeCache(Class c) {
HashMap<String, Field> map;
if (isSubtypeOf(c, Map.class))
map = getOpt_special;
else {
map = new HashMap();
Class _c = c;
do {
for (Field f : _c.getDeclaredFields()) {
f.setAccessible(true);
String name = f.getName();
if (!map.containsKey(name))
map.put(name, f);
}
_c = _c.getSuperclass();
} while (_c != null);
}
getOpt_cache.put(c, map);
return map;
}
static ImageIcon imageIcon(String imageID) { try {
return new ImageIcon(loadBinarySnippet(imageID).toURI().toURL());
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static ImageIcon imageIcon(BufferedImage img) {
return new ImageIcon(img);
}
public static File mkdirsFor(File file) {
return mkdirsForFile(file);
}
static ImageSurface imageSurface(BufferedImage img) {
return new ImageSurface(img);
}
static int toInt(Object o) {
if (o == null) return 0;
if (o instanceof Number)
return ((Number) o).intValue();
if (o instanceof String)
return parseInt((String) o);
throw fail("woot not int: " + getClassName(o));
}
static int toInt(long l) {
if (l != (int) l) throw fail("Too large for int: " + l);
return (int) l;
}
public static String loadTextFile(String fileName) {
try {
return loadTextFile(fileName, null);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public static String loadTextFile(String fileName, String defaultContents) throws IOException {
if (!new File(fileName).exists())
return defaultContents;
FileInputStream fileInputStream = new FileInputStream(fileName);
InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream, "UTF-8");
return loadTextFile(inputStreamReader);
}
public static String loadTextFile(File fileName) {
try {
return loadTextFile(fileName, null);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public static String loadTextFile(File fileName, String defaultContents) throws IOException {
try {
return loadTextFile(fileName.getPath(), defaultContents);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public static String loadTextFile(Reader reader) throws IOException {
StringBuilder builder = new StringBuilder();
try {
char[] buffer = new char[1024];
int n;
while (-1 != (n = reader.read(buffer)))
builder.append(buffer, 0, n);
} finally {
reader.close();
}
return builder.toString();
}
static String dropSuffix(String suffix, String s) {
return s.endsWith(suffix) ? s.substring(0, l(s)-l(suffix)) : s;
}
static void smartSet(Field f, Object o, Object value) throws Exception {
f.setAccessible(true);
// take care of common case (long to int)
if (f.getType() == int.class && value instanceof Long)
value = ((Long) value).intValue();
f.set(o, value);
}
// can probably be merged with next variant
static void disposeWindow(final Window window) {
if (window != null) swingNowOrLater(new Runnable() { public void run() { try {
window.dispose();
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } });
}
static void disposeWindow(final Component c) {
disposeWindow(getWindow(c));
}
static void moveMouse(int newx, int newy) { try {
Point p = getMouseLocation();
//int steps = 20, delay = 40; // slow
//int steps = 20, delay = 20; // fast
int steps = 20, delay = 30; // medium
Robot robot = new Robot();
for (int i = 1; i <= steps; i++) {
Point p2 = blendPoints(p, new Point(newx, newy), ((double) i) / steps);
robot.mouseMove(p2.x, p2.y);
if (i != steps)
sleep(delay);
}
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static int stdcompare(String a, String b) {
return a == null ? b == null ? 0 : -1 : a.compareTo(b);
}
static int stdcompare(long a, long b) {
return a < b ? -1 : a > b ? 1 : 0;
}
static JFrame makeFrame() {
return makeFrame((Component) null);
}
static JFrame makeFrame(Object content) {
return makeFrame(programTitle(), content);
}
static JFrame makeFrame(String title) {
return makeFrame(title, null);
}
static JFrame makeFrame(String title, Object content) {
return makeFrame(title, content, true);
}
static JFrame makeFrame(String title, Object content, boolean showIt) {
JFrame frame = new JFrame(title);
if (content != null)
frame.getContentPane().add(wrap(content));
frame.setBounds(300, 100, 500, 400);
if (showIt)
frame.setVisible(true);
//callOpt(content, "requestFocus");
//exitOnFrameClose(frame);
// standard right-click behavior on titles
if (isSubstanceLAF())
onTitleRightClick(frame,
//r { showConsole(); }
new Object() { void get(MouseEvent e) {
if (!e.isPopupTrigger()) return;
JPopupMenu menu = new JPopupMenu();
menu.add(jmenuItem("Restart Program", new Runnable() { public void run() { try { restart() ;
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } }));
menu.add(jmenuItem("Show Console", new Runnable() { public void run() { try { showConsole() ;
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } }));
menu.show(e.getComponent(), e.getX(), e.getY());
}
public String toString() { return "if (!e.isPopupTrigger()) ret;\n JPopupMenu menu = new JPopupMenu();\n\n menu.add(jmenuItem(\"Restart Program\", r { restart() }));\n menu.add(jmenuItem(\"Show Console\", r { showConsole() }));\n\n menu.show(e.getComponent(), e.getX(), e.getY());"; }});
return frame;
}
// This is for main classes that are all static.
// (We don't go to base classes.)
static Set<String> listFields(Object c) {
TreeSet<String> fields = new TreeSet<String>();
for (Field f : _getClass(c).getDeclaredFields())
fields.add(f.getName());
return fields;
}
static List collectInstances(Iterable i, Class c) {
List l = new ArrayList();
for (Object o : i)
if (isInstanceX(c, o))
l.add(o);
return l;
}
static boolean isURL(String s) {
return s.startsWith("http://") || s.startsWith("https://");
}
static void setFrameContents(JFrame frame, Object contents) {
frame.getContentPane().removeAll();
frame.getContentPane().add(wrap(contents));
revalidate(frame);
}
static boolean isAWTThread() {
return isTrue(callOpt(getClass("javax.swing.SwingUtilities"), "isEventDispatchThread"));
}
static Thread currentThread() {
return Thread.currentThread();
}
static byte[] hexToBytes(String s) {
int n = l(s) / 2;
byte[] bytes = new byte[n];
for (int i = 0; i < n; i++) {
String hex = substring(s, i*2, i*2+2);
try {
bytes[i] = (byte) parseHexByte(hex);
} catch (Throwable _e) {
throw fail("Bad hex byte: " + quote(hex) + " at " + i*2 + "/" + l(s));
}
}
return bytes;
}
// returns l(s) if not found
static int xIndexOf(String s, String sub, int i) {
if (s == null) return 0;
i = s.indexOf(sub, min(i, l(s)));
return i >= 0 ? i : l(s);
}
static int xIndexOf(String s, String sub) {
return xIndexOf(s, sub, 0);
}
static int xIndexOf(String s, char c) {
if (s == null) return 0;
int i = s.indexOf(c);
return i >= 0 ? i : l(s);
}
static List flattenList(List a) {
List l = new ArrayList();
for (Object x : a)
if (x instanceof List)
l.addAll(flattenList((List) x));
else
l.add(x);
return l;
}
static HashMap<Class, Constructor> nuEmptyObject_cache = new HashMap<Class, Constructor>();
static <A> A nuEmptyObject(Class<A> c) { try {
Constructor ctr;
synchronized(nuEmptyObject_cache) {
ctr = nuEmptyObject_cache.get(c);
if (ctr == null) {
nuEmptyObject_cache.put(c, ctr = nuEmptyObject_findConstructor(c));
ctr.setAccessible(true);
}
}
return (A) ctr.newInstance();
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static Constructor nuEmptyObject_findConstructor(Class c) {
for (Constructor m : c.getDeclaredConstructors())
if (m.getParameterTypes().length == 0)
return m;
throw fail("No default constructor declared in " + c.getName());
}
static boolean contains(Collection c, Object o) {
return c != null && c.contains(o);
}
static boolean contains(Object[] x, Object o) {
if (x != null)
for (Object a : x)
if (eq(a, o))
return true;
return false;
}
static boolean contains(String s, char c) {
return s != null && s.indexOf(c) >= 0;
}
static boolean contains(String s, String b) {
return s != null && s.indexOf(b) >= 0;
}
static JWindow showInTopRightCorner(Component c) {
JWindow w = new JWindow();
w.add(c);
w.pack();
moveToTopRightCorner(w);
w.setVisible(true);
return w;
}
static boolean setOptAllDyn_debug;
static void setOptAllDyn(DynamicObject o, Map<String, Object> fields) {
if (fields == null) return;
for (String field : keys(fields)) {
Object val = fields.get(field);
boolean has = hasField(o, field);
if (has)
setOpt(o, field, val);
else {
o.fieldValues.put(field.intern(), val);
if (setOptAllDyn_debug) print("setOptAllDyn added dyn " + field + " to " + o + " [value: " + val + ", fieldValues = " + systemHashCode(o.fieldValues) + ", " + struct(keys(o.fieldValues)) + "]");
}
}
}
static File loadBinarySnippet(String snippetID) { try {
long id = parseSnippetID(snippetID);
File f = DiskSnippetCache_getLibrary(id);
if (f == null) {
byte[] data = loadDataSnippetImpl(snippetID);
DiskSnippetCache_putLibrary(id, data);
f = DiskSnippetCache_getLibrary(id);
}
return f;
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static String quickSubstring(String s, int i, int j) {
if (i == j) return "";
return s.substring(i, j);
}
static int screenWidth() {
return getScreenWidth();
}
static <A> A liftLast(List<A> l) {
if (l.isEmpty()) return null;
int i = l(l)-1;
A a = l.get(i);
l.remove(i);
return a;
}
static Object callFOpt(Object f, Object... args) {
if (f == null) return null;
if (f instanceof Runnable) {
((Runnable) f).run();
return null;
} else if (f instanceof String)
return callOpt(mc(), (String) f, args);
else
return callOpt(f, "get", args);
}
static void setTableModel(JTable table, TableModel model) {
int i = table.getSelectedRow();
table.setModel(model);
if (i >= 0 && i < model.getRowCount())
table.setRowSelectionInterval(i, i);
}
static JFrame centerFrame(JFrame frame) {
frame.setLocationRelativeTo(null); // magic trick
return frame;
}
static boolean structure_isMarker(String s, int i, int j) {
if (i >= j) return false;
if (s.charAt(i) != 'm') return false;
++i;
while (i < j) {
char c = s.charAt(i);
if (c < '0' || c > '9') return false;
++i;
}
return true;
}
static int min(int a, int b) {
return Math.min(a, b);
}
static long min(long a, long b) {
return Math.min(a, b);
}
static double min(double a, double b) {
return Math.min(a, b);
}
static double min(double[] c) {
double x = Double.MAX_VALUE;
for (double d : c) x = Math.min(x, d);
return x;
}
static byte min(byte[] c) {
byte x = 127;
for (byte d : c) if (d < x) x = d;
return x;
}
static Object newObject(Class c, Object... args) {
return nuObject(c, args);
}
static Object newObject(String className, Object... args) {
return nuObject(className, args);
}
static Class getMainClass() {
return main.class;
}
static Class getMainClass(Object o) { try {
return (o instanceof Class ? (Class) o : o.getClass()).getClassLoader().loadClass("main");
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static JFrame minFrameWidth(JFrame frame, int w) {
if (frame.getWidth() < w)
frame.setSize(w, frame.getHeight());
return frame;
}
static String[] toStringArray(Collection<String> c) {
String[] a = new String[l(c)];
Iterator<String> it = c.iterator();
for (int i = 0; i < l(a); i++)
a[i] = it.next();
return a;
}
static String[] toStringArray(Object o) {
if (o instanceof String[])
return (String[]) o;
else if (o instanceof Collection)
return toStringArray((Collection<String>) o);
else
throw fail("Not a collection or array: " + structure(o));
}
static String n(long l, String name) {
return l + " " + (l == 1 ? singular(name) : getPlural(name));
}
static void copyTextToClipboard(String text) {
StringSelection selection = new StringSelection(text);
Toolkit.getDefaultToolkit().getSystemClipboard().setContents(selection, selection);
}
static int days() {
return Calendar.getInstance().get(Calendar.DAY_OF_MONTH);
}
static <A extends Concept> A findConceptWhere(Class<A> c, Object... params) {
params = expandParams(c, params);
for (A x : list(c))
if (checkConceptFields(x, params))
return x;
return null;
}
static boolean frameTooSmall(JFrame frame) {
return frame.getWidth() < 100 || frame.getHeight() < 50;
}
static Boolean isHeadless_cache;
static boolean isHeadless() {
if (isHeadless_cache != null) return isHeadless_cache;
if (GraphicsEnvironment.isHeadless()) return isHeadless_cache = true;
// Also check if AWT actually works.
// If DISPLAY variable is set but no X server up, this will notice.
try {
isAWTThread();
return isHeadless_cache = false;
} catch (Throwable _e) { return isHeadless_cache = true; }
}
static boolean isInteger(String s) {
if (s == null) return false;
int n = l(s);
if (n == 0) return false;
int i = 0;
if (s.charAt(0) == '-')
if (++i >= n) return false;
while (i < n) {
char c = s.charAt(i);
if (c < '0' || c > '9') return false;
++i;
}
return true;
}
static String getStackTrace(Throwable throwable) {
StringWriter writer = new StringWriter();
throwable.printStackTrace(new PrintWriter(writer));
return writer.toString();
}
static String formatSnippetID(String id) {
return "#" + parseSnippetID(id);
}
static String formatSnippetID(long id) {
return "#" + id;
}
static String rep(int n, char c) {
return repeat(c, n);
}
static String rep(char c, int n) {
return repeat(c, n);
}
static <A> List<A> rep(A a, int n) {
return repeat(a, n);
}
static String getProgramTitle() {
return getProgramName();
}
static int withMargin_defaultWidth = 6;
static JPanel withMargin(Component c) {
JPanel p = new JPanel(new BorderLayout());
int w = withMargin_defaultWidth;
p.setBorder(BorderFactory.createEmptyBorder(w, w, w, w));
p.add(c);
return p;
}
static String snippetImageURL(String snippetID) {
long id = parseSnippetID(snippetID);
String url;
if (id == 1000010 || id == 1000012)
url = "http://tinybrain.de:8080/tb/show-blobimage.php?id=" + id;
else
url = "http://eyeocr.sourceforge.net/filestore/filestore.php?cmd=serve&file=blob_" + id
+ "&contentType=image/png";
return url;
}
static void revalidate(Component c) {
if (c == null || !c.isShowing()) return;
// magic combo to actually relayout and repaint
c.revalidate();
c.repaint();
}
static boolean isPrimitiveBoolField(Object o, String field) {
Field f = findField2(o, field);
return f != null && eq(f.getType(), boolean.class);
}
static Window getWindow(Object o) {
if (!(o instanceof Component)) return null;
Component c = (Component) o;
while (c != null) {
if (c instanceof Window) return (Window) c;
c = c.getParent();
}
return null;
}
static Object callJavaX(String method, Object... args) {
return callOpt(getJavaX(), method, args);
}
static void frameStandardSize(JFrame frame) {
frame.setBounds(300, 100, 500, 400);
}
public static String unquote(String s) {
if (s == null) return null;
if (s.startsWith("[")) {
int i = 1;
while (i < s.length() && s.charAt(i) == '=') ++i;
if (i < s.length() && s.charAt(i) == '[') {
String m = s.substring(1, i);
if (s.endsWith("]" + m + "]"))
return s.substring(i+1, s.length()-i-1);
}
}
if (s.startsWith("\"") /*&& s.endsWith("\"")*/ && s.length() > 1) {
int l = s.endsWith("\"") ? s.length()-1 : s.length();
StringBuilder sb = new StringBuilder(l-1);
for (int i = 1; i < l; i++) {
char ch = s.charAt(i);
if (ch == '\\') {
char nextChar = (i == l - 1) ? '\\' : s.charAt(i + 1);
// Octal escape?
if (nextChar >= '0' && nextChar <= '7') {
String code = "" + nextChar;
i++;
if ((i < l - 1) && s.charAt(i + 1) >= '0'
&& s.charAt(i + 1) <= '7') {
code += s.charAt(i + 1);
i++;
if ((i < l - 1) && s.charAt(i + 1) >= '0'
&& s.charAt(i + 1) <= '7') {
code += s.charAt(i + 1);
i++;
}
}
sb.append((char) Integer.parseInt(code, 8));
continue;
}
switch (nextChar) {
case '\\':
ch = '\\';
break;
case 'b':
ch = '\b';
break;
case 'f':
ch = '\f';
break;
case 'n':
ch = '\n';
break;
case 'r':
ch = '\r';
break;
case 't':
ch = '\t';
break;
case '\"':
ch = '\"';
break;
case '\'':
ch = '\'';
break;
// Hex Unicode: u????
case 'u':
if (i >= l - 5) {
ch = 'u';
break;
}
int code = Integer.parseInt(
"" + s.charAt(i + 2) + s.charAt(i + 3)
+ s.charAt(i + 4) + s.charAt(i + 5), 16);
sb.append(Character.toChars(code));
i += 5;
continue;
default:
ch = nextChar; // added by Stefan
}
i++;
}
sb.append(ch);
}
return sb.toString();
}
return s; // not quoted - return original
}
static JFrame showPackedFrame(String title, Component contents) {
return packFrame(showFrame(title, contents));
}
static JFrame showPackedFrame(Component contents) {
return packFrame(showFrame(contents));
}
static void setOptAll(Object o, Map<String, Object> fields) {
if (fields == null) return;
for (String field : keys(fields))
setOpt(o, field, fields.get(field));
}
static void setOptAll(Object o, Object... values) {
//values = expandParams(c.getClass(), values);
warnIfOddCount(values);
for (int i = 0; i+1 < l(values); i += 2) {
String field = (String) values[i];
Object value = values[i+1];
setOpt(o, field, value);
}
}
static int forwardOneClick_windowSize = 11; // odd should look nice. Set to 1 for an invisible window
static int forwardOneClick_clickDelay = 0; // Delay in ms between closing window and forwarding click. 0 seems to work fine.
static int forwardOneClick_trackingSpeed = 10; // How often to move the window (ms)
// onClick: voidfunc(Point, int) - 2nd parameter is button (1 to 3)
// if you make it a func and return false, click is not forwarded
static void forwardOneClick(final Object onClick) {
swingNowOrLater(new Runnable() { public void run() { try {
final JWindow window = new JWindow();
final int windowSize = forwardOneClick_windowSize;
window.setSize(windowSize, windowSize);
window.setVisible(true);
window.setAlwaysOnTop(true);
JPanel panel = singleColorPanel(Color.red);
window.setContentPane(panel);
revalidate(window);
final Robot robot = new Robot();
panel.addMouseListener(new MouseAdapter() {
public void mouseReleased(final MouseEvent e) {
window.setVisible(false);
final int b = e.getButton();
final int mod =
b == 1 ? InputEvent.BUTTON1_DOWN_MASK
: b == 2 ? InputEvent.BUTTON2_DOWN_MASK
: InputEvent.BUTTON3_DOWN_MASK;
final Point point = getMouseLocation();
swingLater(forwardOneClick_clickDelay, new Runnable() { public void run() { try {
if (isFalse(callF(onClick, point, b))) return;
robot.mousePress(mod);
robot.mouseRelease(mod);
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } });
}
});
swingEvery(window, forwardOneClick_trackingSpeed, new Runnable() { public void run() { try {
Point p = getMouseLocation();
window.setLocation(p.x-windowSize/2, p.y-windowSize/2);
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } });
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } });
}
static int screenHeight() {
return getScreenHeight();
}
static char unquoteCharacter(String s) {
assertTrue(s.startsWith("'") && s.length() > 1);
return unquote("\"" + s.substring(1, s.endsWith("'") ? s.length()-1 : s.length()) + "\"").charAt(0);
}
static int parseInt(String s) {
return empty(s) ? 0 : Integer.parseInt(s);
}
static <A> A nuStubInnerObject(Class<A> c) { try {
Class outerType = getOuterClass(c);
Constructor m = c.getDeclaredConstructor(outerType);
m.setAccessible(true);
return (A) m.newInstance(new Object[] {null});
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static Rectangle intersectWithScreen(Rectangle r) {
return r.intersection(screenRectangle());
}
static boolean[] boolArrayFromBytes(byte[] a, int n) {
boolean[] b = new boolean[n];
int m = min(n, l(a)*8);
for (int i = 0; i < m; i++)
b[i] = (a[i/8] & 1 << (i & 7)) != 0;
return b;
}
// hopefully covers all cases :)
static String safeSubstring(String s, int x, int y) {
if (s == null) return null;
if (x < 0) x = 0;
if (x > s.length()) return "";
if (y < x) y = x;
if (y > s.length()) y = s.length();
return s.substring(x, y);
}
static String safeSubstring(String s, int x) {
return safeSubstring(s, x, l(s));
}
static Object getBot(String botID) {
return callOpt(getMainBot(), "getBot", botID);
}
static Point getMouseLocation() {
return MouseInfo.getPointerInfo().getLocation();
}
static byte[] boolArrayToBytes(boolean[] a) {
byte[] b = new byte[(l(a)+7)/8];
for (int i = 0; i < l(a); i++)
if (a[i])
b[i/8] |= 1 << (i & 7);
return b;
}
static TableWithTooltips tableWithToolTips() {
return tableWithTooltips();
}
static String className(Object o) {
return getClassName(o);
}
static File getCacheProgramDir() {
return getCacheProgramDir(getProgramID());
}
static File getCacheProgramDir(String snippetID) {
return new File(userHome(), "JavaX-Caches/" + formatSnippetIDOpt(snippetID));
}
public static boolean isSnippetID(String s) {
try {
parseSnippetID(s);
return true;
} catch (RuntimeException e) {
return false;
}
}
static void assertTrue(Object o) {
assertEquals(true, o);
}
static boolean assertTrue(String msg, boolean b) {
if (!b)
throw fail(msg);
return b;
}
static boolean assertTrue(boolean b) {
if (!b)
throw fail("oops");
return b;
}
static long toMS(double seconds) {
return (long) (seconds*1000);
}
static boolean isLongConstant(String s) {
if (!s.endsWith("L")) return false;
s = s.substring(0, l(s)-1);
return isInteger(s);
}
static boolean endsWithLetter(String s) {
return nempty(s) && isLetter(last(s));
}
static String internIfLongerThan(String s, int l) {
return s == null ? null : l(s) >= l ? s.intern() : s;
}
static void pcallOpt_noArgs(Object o, String method) {
try { /* pcall 1*/ callOpt_noArgs(o, method); /* pcall 2 */ } catch (Throwable __e) { printStackTrace(__e); }
}
static int max(int a, int b) {
return Math.max(a, b);
}
static int max(int a, int b, int c) {
return max(max(a, b), c);
}
static long max(int a, long b) {
return Math.max((long) a, b);
}
static long max(long a, long b) {
return Math.max(a, b);
}
static double max(int a, double b) {
return Math.max((double) a, b);
}
static float max(float a, float b) {
return Math.max(a, b);
}
static int max(Collection<Integer> c) {
int x = Integer.MIN_VALUE;
for (int i : c) x = max(x, i);
return x;
}
static double max(double[] c) {
if (c.length == 0) return Double.MIN_VALUE;
double x = c[0];
for (int i = 1; i < c.length; i++) x = Math.max(x, c[i]);
return x;
}
static byte max(byte[] c) {
byte x = -128;
for (byte d : c) if (d > x) x = d;
return x;
}
static boolean sameSnippetID(String a, String b) {
return a != null && b != null && parseSnippetID(a) == parseSnippetID(b);
}
// TODO: all the fringe cases (?)
static JPanel hvgrid(List<List> components) {
if (empty(components)) return new JPanel();
int h = l(components), w = l(first(components));
JPanel panel = new JPanel();
panel.setLayout(new GridLayout(h, w));
for (List<Component> row : components)
smartAdd(panel, row);
return panel;
}
static JPanel hvgrid(List<List> components, int gap) {
JPanel panel = hvgrid(components);
GridLayout g = (GridLayout) ( panel.getLayout());
g.setHgap(gap);
g.setVgap(gap);
return panel;
}
static Object pcallFunction(Object f, Object... args) {
try { /* pcall 1*/ return callFunction(f, args); /* pcall 2 */ } catch (Throwable __e) { printStackTrace(__e); } return null;
}
// works on lists and strings and null
static int indexOfIgnoreCase(Object a, Object b) {
if (a == null) return -1;
if (a instanceof String) {
Matcher m = Pattern.compile((String) b, Pattern.CASE_INSENSITIVE + Pattern.LITERAL).matcher((String) a);
if (m.find()) return m.start(); else return -1;
}
if (a instanceof List) {
for (int i = 0; i < ((List) a).size(); i++) {
Object o = ((List) a).get(i);
if (o != null && ((String) o).equalsIgnoreCase((String) b))
return i;
}
return -1;
}
throw fail("Unknown type: " + a);
}
static void onClick(JComponent c, final Object runnable) {
c.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
callF(runnable, e);
}
});
}
static int[] toIntArray(List<Integer> l) {
int[] a = new int[l(l)];
for (int i = 0; i < a.length; i++)
a[i] = l.get(i);
return a;
}
static Point blendPoints(Point x, Point y, double yish) {
double xish = 1-yish;
return new Point((int) (x.x*xish+y.x*yish), (int) (x.y*xish+y.y*yish));
}
static void printStructure(String prefix, Object o) {
if (endsWithLetter(prefix)) prefix += ": ";
print(prefix + structure(o));
}
static void printStructure(Object o) {
print(structure(o));
}
static boolean eqOneOf(Object o, Object... l) {
for (Object x : l) if (eq(o, x)) return true; return false;
}
static JTextField onEnter(JTextField tf, final Object action) {
if (action == null || tf == null) return tf;
tf.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent evt) {
pcallF(action);
}
});
return tf;
}
static Map synchroMap() {
return synchroHashMap();
}
static <A, B> Map<A, B> synchroMap(Map<A, B> map) {
return Collections.synchronizedMap(map);
}
static int indent_default = 2;
static String indent(int indent) {
return repeat(' ', indent);
}
static String indent(int indent, String s) {
return indent(repeat(' ', indent), s);
}
static String indent(String indent, String s) {
return indent + s.replace("\n", "\n" + indent);
}
static String indent(String s) {
return indent(indent_default, s);
}
static List<String> indent(String indent, List<String> lines) {
List<String> l = new ArrayList<String>();
for (String s : lines)
l.add(indent + s);
return l;
}
static double parseDouble(String s) {
return Double.parseDouble(s);
}
public static long parseSnippetID(String snippetID) {
long id = Long.parseLong(shortenSnippetID(snippetID));
if (id == 0) throw fail("0 is not a snippet ID");
return id;
}
static String repeat(char c, int n) {
n = max(n, 0);
char[] chars = new char[n];
for (int i = 0; i < n; i++)
chars[i] = c;
return new String(chars);
}
static <A> List<A> repeat(A a, int n) {
List<A> l = new ArrayList<A>();
for (int i = 0; i < n; i++)
l.add(a);
return l;
}
static Set<String> conceptFields(Concept c) {
return setMinus(mergeSets(allNonStaticFields(c), keys(c.fieldValues)),
"className", "fieldValues", "id", "created", "refs", "backRefs",
"_concepts");
}
static <A> A or(A a, A b) {
return a != null ? a : b;
}
static String fromUtf8(byte[] bytes) { try {
return new String(bytes, "UTF-8");
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static File userDir() {
return new File(userHome());
}
static File userDir(String path) {
return new File(userHome(), path);
}
static boolean isAndroid() { return System.getProperty("java.vendor").toLowerCase().indexOf("android") >= 0; }
// runnable = Runnable or voidfunc(MouseEvent)
static void onTitleRightClick(final JFrame frame, final Object runnable) {
swingLater(new Runnable() { public void run() { try {
if (!isSubstanceLAF())
print("Can't add title right click!");
else {
JComponent titleBar = getTitlePaneComponent(frame);
titleBar.addMouseListener(new MouseAdapter() {
public void mousePressed(MouseEvent e) {
if (e.isPopupTrigger())
callF(runnable, e);
}
});
}
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } });
}
static String shortenSnippetID(String snippetID) {
if (snippetID.startsWith("#"))
snippetID = snippetID.substring(1);
String httpBlaBla = "http://tinybrain.de/";
if (snippetID.startsWith(httpBlaBla))
snippetID = snippetID.substring(httpBlaBla.length());
return "" + parseLong(snippetID);
}
static List<String> getPlural_specials = ll("sheep", "fish");
static String getPlural(String s) {
if (containsIgnoreCase(getPlural_specials, s)) return s;
if (ewic(s, "y")) return dropSuffixIgnoreCase("y", s) + "ies";
if (ewic(s, "ss")) return s + "es";
if (ewic(s, "s")) return s;
return s + "s";
}
static JPanel smartAdd(JPanel panel, List parts) {
for (Object o : parts) {
Component c;
if (o == null)
c = new JPanel();
else if (o instanceof String)
c = jlabel((String) o);
else
c = wrap(o);
panel.add(c);
}
return panel;
}
static JPanel smartAdd(JPanel panel, Object... parts) {
return smartAdd(panel, asList(parts));
}
static Map<String, String> singular_specials = litmap(
"children", "child", "images", "image", "chess", "chess");
static Set<String> singular_specials2 = litset("time");
static String singular(String s) {
if (s == null) return null;
s = toLower(s);
{ String _a_1 = singular_specials.get(s); if (!empty(_a_1)) return _a_1; }
if (singular_specials2.contains(dropSuffix("s", s)))
return dropSuffix("s", s);
if (s.endsWith("ness")) return s;
if (s.endsWith("ges")) return dropSuffix("s", s);
s = dropSuffix("es", s);
s = dropSuffix("s", s);
return s;
}
static void showConsole() {
JFrame frame = consoleFrame();
if (frame != null)
frame.setVisible(true);
}
static Object mainBot;
static Object getMainBot() {
return mainBot;
}
// Data files are immutable, use centralized cache
public static File DiskSnippetCache_getLibrary(long snippetID) throws IOException {
File file = new File(getGlobalCache(), "data_" + snippetID + ".jar");
return file.exists() ? file : null;
}
public static void DiskSnippetCache_putLibrary(long snippetID, byte[] data) throws IOException {
saveBinaryFile(new File(getGlobalCache(), "data_" + snippetID).getPath() + ".jar", data);
}
static byte[] loadDataSnippetImpl(String snippetID) throws IOException {
byte[] data;
try {
URL url = new URL("http://eyeocr.sourceforge.net/filestore/filestore.php?cmd=serve&file=blob_"
+ parseSnippetID(snippetID) + "&contentType=application/binary");
System.err.println("Loading library: " + url);
try {
data = loadBinaryPage(url.openConnection());
} catch (RuntimeException e) {
data = null;
}
if (data == null || data.length == 0) {
url = new URL("http://data.tinybrain.de/blobs/"
+ parseSnippetID(snippetID));
System.err.println("Loading library: " + url);
data = loadBinaryPage(url.openConnection());
}
System.err.println("Bytes loaded: " + data.length);
} catch (FileNotFoundException e) {
throw new IOException("Binary snippet #" + snippetID + " not found or not public");
}
return data;
}
static <A> Set<A> mergeSets(Set<A>... l) {
return joinSets(l);
}
static Class __javax;
static Class getJavaX() {
return __javax;
}
static void swingEvery(JComponent component, long delay, Runnable r) {
installTimer(component, delay, r);
}
static void swingEvery(JComponent component, long delay, long firstDelay, Runnable r) {
installTimer(component, r, delay, firstDelay);
}
static void swingEvery(RootPaneContainer frame, long delay, Runnable r) {
installTimer(frame, delay, r);
}
static int getScreenHeight() {
return getScreenSize().height;
}
// hmm, this shouldn't call functions really. That was just
// for coroutines.
static boolean isTrue(Object o) {
if (o instanceof Boolean)
return ((Boolean) o).booleanValue();
if (o == null) return false;
return ((Boolean) callF(o)).booleanValue();
}
static boolean isTrue(Object pred, Object arg) {
return booleanValue(callF(pred, arg));
}
static <A> Set<A> setMinus(Set<A> set, Object... stuff) {
Set s2 = cloneSet(set);
for (Object o : stuff)
s2.remove(o);
return s2;
}
// c = Component or something implementing swing()
static Component wrap(Object swingable) {
Component c = (Component) ( swingable instanceof Component ? swingable : call(swingable, "swing"));
if (c instanceof JTable || c instanceof JList
|| c instanceof JTextArea || c instanceof JEditorPane
|| c instanceof JTextPane)
return new JScrollPane(c);
return c;
}
static boolean hasField(Object o, String field) {
return findField2(o, field) != null;
}
static Class<?> _getClass(String name) {
try {
return Class.forName(name);
} catch (ClassNotFoundException e) {
return null;
}
}
static Class _getClass(Object o) {
return o instanceof Class ? (Class) o : o.getClass();
}
static Class _getClass(Object realm, String name) { try {
return getClass(realm).getClassLoader().loadClass(classNameToVM(name));
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static <A> A last(List<A> l) {
return l.isEmpty() ? null : l.get(l.size()-1);
}
static char last(String s) {
return empty(s) ? '#' : s.charAt(l(s)-1);
}
static int systemHashCode(Object o) {
return identityHashCode(o);
}
static boolean isFalse(Object o) {
return eq(false, o);
}
static TableWithTooltips tableWithTooltips() {
return new TableWithTooltips();
}
static class TableWithTooltips extends JTable {
public String getToolTipText(MouseEvent e) {
String tip = null;
Point p = e.getPoint();
int rowIndex = rowAtPoint(p);
int colIndex = columnAtPoint(p);
try {
return str(getValueAt(rowIndex, colIndex));
} catch (Throwable _e) { return null;
}
}
}
static Map synchroHashMap() {
return Collections.synchronizedMap(new HashMap());
}
static Field findField2(Object o, String field) {
if (o instanceof Class) return findField2_findStaticField((Class) o, field);
return findField2_findField(o.getClass(), field);
}
static Field findField2_findStaticField(Class<?> c, String field) {
Class _c = c;
do {
for (Field f : _c.getDeclaredFields())
if (f.getName().equals(field) && (f.getModifiers() & Modifier.STATIC) != 0)
return f;
_c = _c.getSuperclass();
} while (_c != null);
return null;
}
static Field findField2_findField(Class<?> c, String field) {
Class _c = c;
do {
for (Field f : _c.getDeclaredFields())
if (f.getName().equals(field))
return f;
_c = _c.getSuperclass();
} while (_c != null);
return null;
}
static Class getOuterClass(Class c) { try {
String s = c.getName();
int i = s.lastIndexOf('$');
return Class.forName(substring(s, 0, i));
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static boolean isSubstanceLAF() {
return substanceLookAndFeelEnabled();
}
static int packFrame_minw = 150, packFrame_minh = 50;
static JFrame packFrame(Component c) {
JFrame frame = getFrame(c);
if (frame == null) return null;
frame.pack();
int maxW = getScreenWidth()-50, maxH = getScreenHeight()-50;
frame.setSize(
min(maxW, max(frame.getWidth(), packFrame_minw)),
min(maxH, max(frame.getHeight(), packFrame_minh)));
return frame;
}
static JPanel singleColorPanel(Color color) {
JPanel p = new JPanel();
p.setOpaque(true);
p.setBackground(color);
return p;
}
static int getScreenWidth() {
return getScreenSize().width;
}
static void restart() {
Object j = getJavaX();
call(j, "cleanRestart", get(j, "fullArgs"));
}
static String programTitle() {
return getProgramName();
}
static Class<?> getClass(String name) {
try {
return Class.forName(name);
} catch (ClassNotFoundException e) {
return null;
}
}
static Class getClass(Object o) {
return o instanceof Class ? (Class) o : o.getClass();
}
static Class getClass(Object realm, String name) { try {
try {
return getClass(realm).getClassLoader().loadClass(classNameToVM(name));
} catch (ClassNotFoundException e) {
return null;
}
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static boolean isLetter(char c) {
return Character.isLetter(c);
}
static String formatSnippetIDOpt(String s) {
return isSnippetID(s) ? formatSnippetID(s) : s;
}
static int parseHexByte(String s) {
return Integer.parseInt(s, 16);
}
static String getProgramName_cache;
static synchronized String getProgramName() {
if (getProgramName_cache == null)
getProgramName_cache = getSnippetTitle(getProgramID());
return getProgramName_cache;
}
static Set<String> allNonStaticFields(Object o) {
TreeSet<String> fields = new TreeSet<String>();
Class _c = _getClass(o);
do {
for (Field f : _c.getDeclaredFields())
if ((f.getModifiers() & Modifier.STATIC) == 0)
fields.add(f.getName());
_c = _c.getSuperclass();
} while (_c != null);
return fields;
}
static int moveToTopRightCorner_inset = 20;
static void moveToTopRightCorner(Window w) {
w.setLocation(getScreenSize().width-w.getWidth()-moveToTopRightCorner_inset, moveToTopRightCorner_inset);
}
static <A> HashSet<A> litset(A... items) {
return lithashset(items);
}
static JComponent getTitlePaneComponent(Window window) {
if (!substanceLookAndFeelEnabled()) return null;
JRootPane rootPane = null;
if (window instanceof JFrame) {
JFrame f = (JFrame) window;
rootPane = f.getRootPane();
}
if (window instanceof JDialog) {
JDialog d = (JDialog) window;
rootPane = d.getRootPane();
}
if (rootPane != null) {
Object /*SubstanceRootPaneUI*/ ui = rootPane.getUI();
return (JComponent) call(ui, "getTitlePane");
}
return null;
}
static String dropSuffixIgnoreCase(String suffix, String s) {
return ewic(s, suffix) ? s.substring(0, l(s)-l(suffix)) : s;
}
static File getGlobalCache() {
File file = new File(userHome(), ".tinybrain/snippet-cache");
file.mkdirs();
return file;
}
static String classNameToVM(String name) {
return name.replace(".", "$");
}
/** writes safely (to temp file, then rename) */
public static void saveBinaryFile(String fileName, byte[] contents) throws IOException {
File file = new File(fileName);
File parentFile = file.getParentFile();
if (parentFile != null)
parentFile.mkdirs();
String tempFileName = fileName + "_temp";
FileOutputStream fileOutputStream = newFileOutputStream(tempFileName);
fileOutputStream.write(contents);
fileOutputStream.close();
if (file.exists() && !file.delete())
throw new IOException("Can't delete " + fileName);
if (!new File(tempFileName).renameTo(file))
throw new IOException("Can't rename " + tempFileName + " to " + fileName);
}
static void saveBinaryFile(File fileName, byte[] contents) {
try {
saveBinaryFile(fileName.getPath(), contents);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
static <A> Set<A> joinSets(Set<A>... l) {
TreeSet set = new TreeSet();
for (Set o : l)
if (o != null)
set.addAll(o);
return set;
}
static JFrame consoleFrame() {
return (JFrame) getOpt(get(getJavaX(), "console"), "frame");
}
static int identityHashCode(Object o) {
return System.identityHashCode(o);
}
// TODO: does not detect set type (hash/tree) when it's synchronized
static <A> Set<A> cloneSet(Set<A> set) {
// assume mutex is equal to collection, which will be true unless you explicitly pass a mutex to synchronizedList() which no one ever does.
synchronized(set) {
return set instanceof TreeSet ? new TreeSet(set) : new HashSet(set);
}
}
static boolean substanceLookAndFeelEnabled() {
return startsWith(getLookAndFeel(), "org.pushingpixels.");
}
static boolean ewic(String a, String b) {
return endsWithIgnoreCase(a, b);
}
static String toLower(String s) {
return s == null ? null : s.toLowerCase();
}
static char toLower(char c) {
return Character.toLowerCase(c);
}
static String getSnippetTitle(String id) { try {
if (!isSnippetID(id)) return "?";
return trim(loadPageSilently(new URL("http://tinybrain.de:8080/tb-int/getfield.php?id=" + parseSnippetID(id) + "&field=title" + standardCredentials())));
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static boolean booleanValue(Object o) {
return eq(true, o);
}
static Dimension getScreenSize() {
return Toolkit.getDefaultToolkit().getScreenSize();
}
static byte[] loadBinaryPage(String url) { try {
return loadBinaryPage(new URL(url).openConnection());
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
public static byte[] loadBinaryPage(URLConnection con) { try {
//setHeaders(con);
ByteArrayOutputStream buf = new ByteArrayOutputStream();
InputStream inputStream = con.getInputStream();
int n = 0;
while (true) {
int ch = inputStream.read();
if (ch < 0)
break;
buf.write(ch);
if (++n % 100000 == 0)
System.err.println(" " + n + " bytes loaded.");
}
inputStream.close();
return buf.toByteArray();
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static String trim(String s) { return s == null ? null : s.trim(); }
static String trim(StringBuilder buf) { return buf.toString().trim(); }
static String trim(StringBuffer buf) { return buf.toString().trim(); }
static String standardCredentials() {
String user = standardCredentialsUser();
String pass = trim(loadTextFile(new File(userHome(), ".tinybrain/userpass")));
if (nempty(user) && nempty(pass))
return "&_user=" + urlencode(user) + "&_pass=" + urlencode(pass);
return "";
}
static <A> HashSet<A> lithashset(A... items) {
HashSet<A> set = new HashSet<A>();
for (A a : items) set.add(a);
return set;
}
static boolean endsWithIgnoreCase(String a, String b) {
return a != null && l(a) >= l(b) && a.regionMatches(true, l(a)-l(b), b, 0, l(b));
}
static ThreadLocal<String> loadPage_charset = new ThreadLocal<String>();
static boolean loadPage_allowGzip = true, loadPage_debug;
static boolean loadPage_anonymous; // don't send computer ID
static int loadPage_verboseness = 100000;
static int loadPage_retries = 60; // seconds
public static String loadPageSilently(String url) {
try {
return loadPageSilently(new URL(loadPage_preprocess(url)));
} catch (IOException e) { throw new RuntimeException(e); }
}
public static String loadPageSilently(URL url) {
try {
IOException e = null;
for (int tries = 0; tries < loadPage_retries; tries++)
try {
URLConnection con = openConnection(url);
return loadPage(con, url);
} catch (IOException _e) {
e = _e;
if (loadPageThroughProxy_enabled) {
print("Trying proxy because of: " + e);
try {
return loadPageThroughProxy(str(url));
} catch (Throwable e2) {
print(" " + exceptionToStringShort(e2));
}
}
sleepSeconds(1);
}
throw e;
} catch (IOException e) { throw new RuntimeException(e); }
}
static String loadPage_preprocess(String url) {
if (url.startsWith("tb/"))
url = "tinybrain.de:8080/" + url;
if (url.indexOf("://") < 0)
url = "http://" + url;
return url;
}
public static String loadPage(String url) {
try {
url = loadPage_preprocess(url);
print("Loading: " + hideCredentials(url));
return loadPageSilently(new URL(url));
} catch (IOException e) { throw new RuntimeException(e); }
}
public static String loadPage(URL url) {
print("Loading: " + hideCredentials(url.toExternalForm()));
return loadPageSilently(url);
}
public static String loadPage(URLConnection con, URL url) throws IOException {
try {
if (!loadPage_anonymous) {
String computerID = getComputerID();
if (computerID != null)
con.setRequestProperty("X-ComputerID", computerID);
}
if (loadPage_allowGzip)
con.setRequestProperty("Accept-Encoding", "gzip");
} catch (Throwable e) {} // fails if within doPost
String contentType = con.getContentType();
if (contentType == null)
throw new IOException("Page could not be read: " + url);
//print("Content-Type: " + contentType);
String charset = loadPage_charset == null ? null : loadPage_charset.get();
if (charset == null) charset = loadPage_guessCharset(contentType);
InputStream in = con.getInputStream();
if ("gzip".equals(con.getContentEncoding())) {
if (loadPage_debug)
print("loadPage: Using gzip.");
in = new GZIPInputStream(in);
}
Reader r = new InputStreamReader(in, charset);
StringBuilder buf = new StringBuilder();
int n = 0;
while (true) {
int ch = r.read();
if (ch < 0)
break;
buf.append((char) ch);
++n;
if ((n % loadPage_verboseness) == 0) print(" " + n + " chars read");
}
return buf.toString();
}
static String loadPage_guessCharset(String contentType) {
Pattern p = Pattern.compile("text/[a-z]+;\\s+charset=([^\\s]+)\\s*");
Matcher m = p.matcher(contentType);
String match = m.matches() ? m.group(1) : null;
if (loadPage_debug)
print("loadPage: contentType=" + contentType + ", match: " + match);
/* If Content-Type doesn't match this pre-conception, choose default and hope for the best. */
return or(match, "ISO-8859-1");
}
static String getLookAndFeel() {
return getClassName(UIManager.getLookAndFeel());
}
static boolean startsWith(String a, String b) {
return a != null && a.startsWith(b);
}
static boolean startsWith(List a, List b) {
if (a == null || l(b) > l(a)) return false;
for (int i = 0; i < l(b); i++)
if (neq(a.get(i), b.get(i)))
return false;
return true;
}
static String hideCredentials(String url) {
return url.replaceAll("&_pass=[^&]*", "&_pass=<hidden>");
}
static String exceptionToStringShort(Throwable e) {
e = getInnerException(e);
String msg = unnull(e.getMessage());
if (msg.indexOf("Error") < 0 && msg.indexOf("Exception") < 0)
return baseClassName(e) + ": " + msg;
else
return msg;
}
static URLConnection openConnection(URL url) { try {
ping();
return url.openConnection();
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static String urlencode(String x) {
try {
return URLEncoder.encode(unnull(x), "UTF-8");
} catch (UnsupportedEncodingException e) { throw new RuntimeException(e); }
}
static String standardCredentialsUser() {
return trim(loadTextFile(new File(userHome(), ".tinybrain/username")));
}
static String getComputerID() { try {
return computerID();
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static final boolean loadPageThroughProxy_enabled = false;
static String loadPageThroughProxy(String url) {
return null;
}
static void sleepSeconds(double s) {
if (s > 0) sleep(round(s*1000));
}
static Throwable getInnerException(Throwable e) {
while (e.getCause() != null)
e = e.getCause();
return e;
}
static String _computerID;
public static String computerID() { try {
if (_computerID == null) {
File file = new File(userHome(), ".tinybrain/computer-id");
_computerID = loadTextFile(file.getPath(), null);
if (_computerID == null) {
_computerID = makeRandomID(12);
saveTextFile(file.getPath(), _computerID);
}
}
return _computerID;
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static String baseClassName(String className) {
return substring(className, className.lastIndexOf('.'));
}
static String baseClassName(Object o) {
return baseClassName(getClassName(o));
}
static long round(double d) {
return Math.round(d);
}
static String makeRandomID(int length) {
Random random = new Random();
char[] id = new char[length];
for (int i = 0; i < id.length; i++)
id[i] = (char) ((int) 'a' + random.nextInt(26));
return new String(id);
}
static class Pt {
int x, y;
Pt() {}
Pt(Point p) {
x = p.x;
y = p.y;
}
Pt(int x, int y) {
this.y = y;
this.x = x;}
Point getPoint() {
return new Point(x, y);
}
public boolean equals(Object o) { return stdEq2(this, o); }
public int hashCode() { return stdHash2(this); }
public String toString() {
return x + ", " + y;
}
}
// Note: requires e.g. #1005530 - PIF Classes (Clip, Found, FullySearched, Screenshot)
static class ImageFinder {
List<Screenshot> screenshots = synchroList();
List<Clip> clips = synchroList();
float similarity = 0.999f;
int maxCopiesPerClip = 100;
Integer maxTotal; // max total clips found per screenshot
//LinkedBlockingDeque queue = new LinkedBlockingDeque();
boolean quickSearch_clipBufferedImage = true;
ImageFinder() {}
ImageFinder(List<Screenshot> screenshots, List<Clip> clips) {
this.clips = clips;
this.screenshots = screenshots;}
ImageFinder(Screenshot screenshot, List<Clip> clips) { this(ll(screenshot), clips); }
void run() {
for (Screenshot s : cloneList(screenshots))
searchScreenshot(s);
}
void searchScreenshot(Screenshot screenshot) {
print("Searching screenshot " + screenshot.id);
Var<BWImage> screen = new Var<BWImage>();
// Order clips by last found
/*LinkedHashSet<Clip> clips = new LinkedHashSet<Clip>();
for (Found found : reversed(list(Found)))
addIfNotNull(clips, found.clip!);
addAll(clips, reversed(list(Clip)));*/
quickSearch(screenshot, screen);
if (!foundEnough(screenshot))
it: for (Clip clip : clips) {
if (findConcept(FullySearched.class, "screenshot", screenshot, "clip", clip) != null) continue;
print(" Searching " + clip.description);
if (!screenshot.hasImage()) continue;
if (!screen.has())
screen.set(new BWImage(screenshot.loadImage()));
bwRawImageSearch_verbose = true;
bwRawImageSearch_maxEntries = maxCopiesPerClip;
for (FoundImg fi : bwRawImageSearch(screen.v, clip.img, similarity)) {
uniq(Found.class, "screenshot", screenshot, "clip", clip, "fi", fi);
if (foundEnough(screenshot)) break it;
}
uniq(FullySearched.class, "screenshot", screenshot, "clip", clip);
}
print("Done searching screenshot");
}
void quickSearch(Screenshot screenshot, Var<BWImage> screen) {
HashMap<Clip, Rect> lastPosition = new HashMap<Clip, Rect>();
for (Found found : reversed(list(Found.class)))
if (!lastPosition.containsKey(found.clip.get()))
lastPosition.put(found.clip.get(), found.fi.r);
for (Clip clip : keys(lastPosition)) try { /* pcall 1*/
if (!clips.contains(clip)) continue;
if (findConcept(FullySearched.class, "screenshot", screenshot, "clip", clip) != null) continue;
Rect pos = lastPosition.get(clip);
print(" Quick-Searching " + clip.description + " at " + struct(pos));
BWImage pat = clip.img;
int wp = pat.getWidth(), hp = pat.getHeight();
float maxError = (1f-similarity)*wp*hp;
float diff;
if (quickSearch_clipBufferedImage) {
// TODO: cache image
BWImage big = new BWImage(clipBufferedImage(screenshot.loadImage(), new Rectangle(pos.x, pos.y, wp, hp)));
diff = bwImageSectionsSimilarity(big, pat, 0, 0, maxError);
} else {
if (!screen.has())
screen.set(new BWImage(screenshot.loadImage()));
diff = bwImageSectionsSimilarity(screen.v, pat, pos.x, pos.y, maxError);
}
if (diff <= maxError) {
float sim = 1-diff/(wp*hp);
FoundImg fi = new FoundImg(pos, sim);
print(" Found!");
uniq(Found.class, "screenshot", screenshot, "clip", clip, "fi", fi);
if (foundEnough(screenshot)) break;
}
/* pcall 2 */ } catch (Throwable __e) { printStackTrace(__e); }
}
boolean foundEnough(Screenshot screenshot) {
return maxTotal != null && l(findBackRefs(screenshot, Found.class)) >= maxTotal;
}
}
static class MonoThread {
Thread t;
boolean runIfNotRunning(final Runnable r) {
return run(r);
}
synchronized boolean run(final Runnable r) {
if (t == null) {
t = new Thread() {
public void run() {
try {
r.run();
} catch (Throwable e) {
e.printStackTrace();
} finally {
synchronized(MonoThread.this) {
t = null;
}
}
}
};
t.start();
return true;
} else
return false;
}
}
static class Str extends Concept {
String name;
List<String> otherNames = new ArrayList<String>();
Str() {}
Str(String name) {
this.name = name;}
public String toString() { return name; }
}
static class FoundImg {
Rect r;
float sim; // similarity in 0 to 1
FoundImg() {}
FoundImg(Rect r, float sim) {
this.sim = sim;
this.r = r;}
public boolean equals(Object o) { return stdEq2(this, o); }
public int hashCode() { return stdHash2(this); }
}
static class Rect {
int x, y, w, h;
Rect() {}
Rect(Rectangle r) {
x = r.x;
y = r.y;
w = r.width;
h = r.height;
}
Rect(int x, int y, int w, int h) {
this.h = h;
this.w = w;
this.y = y;
this.x = x;}
Rectangle getRectangle() {
return new Rectangle(x, y, w, h);
}
public boolean equals(Object o) { return stdEq2(this, o); }
public int hashCode() { return stdHash2(this); }
public String toString() {
return x + "," + y + " / " + w + "," + h;
}
int x2() { return x + w; }
int y2() { return y + h; }
}
static class ImageSurface extends Surface {
private BufferedImage image;
private double zoomX = 1, zoomY = 1;
private Rectangle selection;
List tools = new ArrayList();
Object overlay; // voidfunc(Graphics2D)
Runnable onSelectionChange;
public ImageSurface() {
this(new RGBImage(1, 1, new int[] { 0xFFFFFF }));
}
public ImageSurface(RGBImage image) {
this(image.getBufferedImage());
}
public ImageSurface(BufferedImage image) {
clearSurface = false;
this.image = image;
new PopupMenuHelper() {
@Override
public void fillMenu() {
Point p = new Point((int) (point.x/getZoomX()), (int) (point.y/getZoomY()));
fillPopupMenu(menu, p);
}
}.install(this);
new ImageSurfaceSelector(this);
}
public ImageSurface(RGBImage image, double zoom) {
this(image);
setZoom(zoom);
}
// point is already in image coordinates
protected void fillPopupMenu(JPopupMenu menu, final Point point) {
JMenuItem miZoomReset = new JMenuItem("Zoom 100%");
miZoomReset.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent evt) {
setZoom(1.0);
centerPoint(point);
}
});
menu.add(miZoomReset);
JMenuItem miZoomIn = new JMenuItem("Zoom in");
miZoomIn.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent evt) {
setZoom(getZoomX()*2.0, getZoomY()*2.0);
centerPoint(point);
}
});
menu.add(miZoomIn);
JMenuItem miZoomOut = new JMenuItem("Zoom out");
miZoomOut.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent evt) {
setZoom(getZoomX()*0.5, getZoomY()*0.5);
centerPoint(point);
}
});
menu.add(miZoomOut);
JMenuItem miZoomToWindow = new JMenuItem("Zoom to window");
miZoomToWindow.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent evt) {
zoomToDisplaySize();
}
});
menu.add(miZoomToWindow);
menu.addSeparator();
/*JMenuItem miSelect = new JMenuItem("Select rectangle");
miSelect.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent actionEvent) {
setTool(new ImageSurfaceSelector(ImageSurface.this));
}
});
menu.add(miSelect);
menu.add(magicWandMenuItem(2));
menu.add(magicWandMenuItem(4));
menu.add(magicWandMenuItem(8));
menu.addSeparator();*/
JMenuItem miSave = new JMenuItem("Save image...");
miSave.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent evt) {
saveImage();
}
});
menu.add(miSave);
/*JMenuItem miUpload = new JMenuItem("Upload image...");
miUpload.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent evt) {
uploadImage();
}
});
menu.add(miUpload);*/
}
public void saveImage() {
RGBImage image = new RGBImage(getImage(), null);
JFileChooser fileChooser = new JFileChooser(getProgramDir());
if (fileChooser.showSaveDialog(this) == JFileChooser.APPROVE_OPTION) {
try {
image.save(fileChooser.getSelectedFile());
} catch (IOException e) {
popup(e);
}
}
}
public void render(int w, int h, Graphics2D g) {
g.setColor(Color.white);
g.fillRect(0, 0, w, h);
if (image != null)
g.drawImage(image, 0, 0, getZoomedWidth(), getZoomedHeight(), null);
if (overlay != null) pcallF(overlay, g);
if (selection != null) {
// drawRect is inclusive, selection is exclusive, so... whatever, tests show it's cool.
drawSelectionRect(g, selection, Color.green, Color.white);
}
}
public void drawSelectionRect(Graphics2D g, Rectangle selection, Color green, Color white) {
g.setColor(green);
int top = (int) (selection.y * zoomY);
int bottom = (int) ((selection.y+selection.height) * zoomY);
int left = (int) (selection.x * zoomX);
int right = (int) ((selection.x+selection.width) * zoomX);
g.drawRect(left-1, top-1, right-left+1, bottom-top+1);
g.setColor(white);
g.drawRect(left - 2, top - 2, right - left + 3, bottom - top + 3);
}
public void setZoom(double zoom) {
setZoom(zoom, zoom);
}
public void setZoom(double zoomX, double zoomY) {
this.zoomX = zoomX;
this.zoomY = zoomY;
revalidate();
repaint();
}
public Dimension getMinimumSize() {
int w = getZoomedWidth();
int h = getZoomedHeight();
Dimension min = super.getMinimumSize();
return new Dimension(Math.max(w, min.width), Math.max(h, min.height));
}
private int getZoomedHeight() {
return (int) (image.getHeight() * zoomY);
}
private int getZoomedWidth() {
return (int) (image.getWidth() * zoomX);
}
public void setImage(RGBImage image) {
setImage(image.getBufferedImage());
}
public void setImage(BufferedImage image) {
this.image = image;
revalidate();
repaint();
}
public BufferedImage getImage() {
return image;
}
public double getZoomX() {
return zoomX;
}
public double getZoomY() {
return zoomY;
}
public Dimension getPreferredSize() {
return new Dimension(getZoomedWidth(), getZoomedHeight());
}
/** returns a scrollpane with the scroll-mode prevent-garbage-drawing fix applied */
public JScrollPane makeScrollPane() {
JScrollPane scrollPane = new JScrollPane(this);
scrollPane.getViewport().setScrollMode(JViewport.BACKINGSTORE_SCROLL_MODE);
return scrollPane;
}
public void zoomToDisplaySize() {
if (image == null) return;
Dimension display = getDisplaySize();
double xRatio = display.width/(double) image.getWidth();
double yRatio = display.height/(double) image.getHeight();
setZoom(Math.min(xRatio, yRatio));
revalidate();
}
/** tricky magic to get parent scroll pane */
private Dimension getDisplaySize() {
Container c = getParent();
while (c != null) {
if (c instanceof JScrollPane)
return c.getSize();
c = c.getParent();
}
return getSize();
}
public void setSelection(Rectangle r) {
if (neq(selection, r)) {
selection = r;
pcallF(onSelectionChange);
repaint();
}
}
public Rectangle getSelection() {
return selection;
}
public RGBImage getRGBImage() {
return new RGBImage(getImage());
}
// p is in image coordinates
void centerPoint(Point p) {
//_print("centerPoint " + p);
if (!(getParent() instanceof JViewport))
return;
p = new Point((int) (p.x*getZoomX()), (int) (p.y*getZoomY()));
final JViewport viewport = (JViewport) ( getParent());
Dimension viewSize = viewport.getExtentSize();
//_print("centerPoint " + p);
int x = max(0, p.x-viewSize.width/2);
int y = max(0, p.y-viewSize.height/2);
p = new Point(x,y);
//_print("centerPoint " + p);
final Point _p = p;
awtLater(new Runnable() { public void run() { try {
viewport.setViewPosition(_p);
} catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); } } });
}
}
abstract static class Surface extends JPanel {
public Object AntiAlias = RenderingHints.VALUE_ANTIALIAS_ON;
public Object Rendering = RenderingHints.VALUE_RENDER_SPEED;
public AlphaComposite composite;
public Paint texture;
public BufferedImage bimg;
public int imageType;
public String name;
public boolean clearSurface = true;
// Demos using animated gif's that implement ImageObserver set dontThread.
public boolean dontThread;
protected long sleepAmount = 50; // max20 fps
private long orig, start, frame;
private Toolkit toolkit;
private boolean perfMonitor, outputPerf;
private int biw, bih;
private boolean clearOnce;
private boolean toBeInitialized = true;
public Surface() {
setDoubleBuffered(false);
toolkit = getToolkit();
name = this.getClass().getName();
name = name.substring(name.indexOf(".", 7)+1);
setImageType(0);
// To launch an individual demo with the performance str output :
// java -Djava2demo.perf= -cp Java2Demo.jar demos.Clipping.ClipAnim
try {
if (System.getProperty("java2demo.perf") != null) {
perfMonitor = outputPerf = true;
}
} catch (Exception ex) { }
}
/*protected Image getImage(String name) {
return DemoImages.getImage(name, this);
}
protected Font getFont(String name) {
return DemoFonts.getFont(name);
}*/
public int getImageType() {
return imageType;
}
public void setImageType(int imgType) {
if (imgType == 0) {
imageType = 1;
} else {
imageType = imgType;
}
bimg = null;
}
public void setAntiAlias(boolean aa) {
AntiAlias = aa
? RenderingHints.VALUE_ANTIALIAS_ON
: RenderingHints.VALUE_ANTIALIAS_OFF;
}
public void setRendering(boolean rd) {
Rendering = rd
? RenderingHints.VALUE_RENDER_QUALITY
: RenderingHints.VALUE_RENDER_SPEED;
}
public void setTexture(Object obj) {
if (obj instanceof GradientPaint) {
texture = new GradientPaint(0, 0, Color.white,
getSize().width*2, 0, Color.green);
} else {
texture = (Paint) obj;
}
}
public void setComposite(boolean cp) {
composite = cp
? AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.5f)
: null;
}
public void setMonitor(boolean pm) {
perfMonitor = pm;
}
public void setSleepAmount(long amount) {
sleepAmount = amount;
}
public long getSleepAmount() {
return sleepAmount;
}
public BufferedImage createBufferedImage(Graphics2D g2,
int w,
int h,
int imgType) {
BufferedImage bi = null;
if (imgType == 0) {
bi = (BufferedImage) g2.getDeviceConfiguration().
createCompatibleImage(w, h);
} else if (imgType > 0 && imgType < 14) {
bi = new BufferedImage(w, h, imgType);
} else if (imgType == 14) {
bi = createBinaryImage(w, h, 2);
} else if (imgType == 15) {
bi = createBinaryImage(w, h, 4);
} else if (imgType == 16) {
bi = createSGISurface(w, h, 32);
} else if (imgType == 17) {
bi = createSGISurface(w, h, 16);
}
biw = w;
bih = h;
return bi;
}
// Lookup tables for BYTE_BINARY 1, 2 and 4 bits.
static byte[] lut1Arr = new byte[] {0, (byte)255 };
static byte[] lut2Arr = new byte[] {0, (byte)85, (byte)170, (byte)255};
static byte[] lut4Arr = new byte[] {0, (byte)17, (byte)34, (byte)51,
(byte)68, (byte)85,(byte) 102, (byte)119,
(byte)136, (byte)153, (byte)170, (byte)187,
(byte)204, (byte)221, (byte)238, (byte)255};
private BufferedImage createBinaryImage(int w, int h, int pixelBits) {
int bytesPerRow = w * pixelBits / 8;
if (w * pixelBits % 8 != 0) {
bytesPerRow++;
}
byte[] imageData = new byte[h * bytesPerRow];
IndexColorModel cm = null;
switch (pixelBits) {
case 1:
cm = new IndexColorModel(pixelBits, lut1Arr.length,
lut1Arr, lut1Arr, lut1Arr);
break;
case 2:
cm = new IndexColorModel(pixelBits, lut2Arr.length,
lut2Arr, lut2Arr, lut2Arr);
break;
case 4:
cm = new IndexColorModel(pixelBits, lut4Arr.length,
lut4Arr, lut4Arr, lut4Arr);
break;
default:
{new Exception("Invalid # of bit per pixel").printStackTrace();}
}
DataBuffer db = new DataBufferByte(imageData, imageData.length);
WritableRaster r = Raster.createPackedRaster(db, w, h, pixelBits, null);
return new BufferedImage(cm, r, false, null);
}
private BufferedImage createSGISurface(int w, int h, int pixelBits) {
int rMask32 = 0xFF000000;
int rMask16 = 0xF800;
int gMask32 = 0x00FF0000;
int gMask16 = 0x07C0;
int bMask32 = 0x0000FF00;
int bMask16 = 0x003E;
DirectColorModel dcm = null;
DataBuffer db = null;
WritableRaster wr = null;
switch (pixelBits) {
case 16:
short[] imageDataUShort = new short[w * h];
dcm = new DirectColorModel(16, rMask16, gMask16, bMask16);
db = new DataBufferUShort(imageDataUShort, imageDataUShort.length);
wr = Raster.createPackedRaster(db, w, h, w,
new int[] {rMask16, gMask16, bMask16},
null);
break;
case 32:
int[] imageDataInt = new int[w * h];
dcm = new DirectColorModel(32, rMask32, gMask32, bMask32);
db = new DataBufferInt(imageDataInt, imageDataInt.length);
wr = Raster.createPackedRaster(db, w, h, w,
new int[] {rMask32, gMask32, bMask32},
null);
break;
default:
{new Exception("Invalid # of bit per pixel").printStackTrace();}
}
return new BufferedImage(dcm, wr, false, null);
}
public Graphics2D createGraphics2D(int width,
int height,
BufferedImage bi,
Graphics g) {
Graphics2D g2 = null;
if (bi != null) {
g2 = bi.createGraphics();
} else {
g2 = (Graphics2D) g;
}
g2.setBackground(getBackground());
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, AntiAlias);
g2.setRenderingHint(RenderingHints.KEY_RENDERING, Rendering);
if (clearSurface || clearOnce) {
g2.clearRect(0, 0, width, height);
clearOnce = false;
}
if (texture != null) {
// set composite to opaque for texture fills
g2.setComposite(AlphaComposite.SrcOver);
g2.setPaint(texture);
g2.fillRect(0, 0, width, height);
}
if (composite != null) {
g2.setComposite(composite);
}
return g2;
}
public abstract void render(int w, int h, Graphics2D g);
/**
* It's possible to turn off double-buffering for just the repaint
* calls invoked directly on the non double buffered component.
* This can be done by overriding paintImmediately() (which is called
* as a result of repaint) and getting the current RepaintManager and
* turning off double buffering in the RepaintManager before calling
* super.paintImmediately(g).
*/
public void paintImmediately(int x,int y,int w, int h) {
RepaintManager repaintManager = null;
boolean save = true;
if (!isDoubleBuffered()) {
repaintManager = RepaintManager.currentManager(this);
save = repaintManager.isDoubleBufferingEnabled();
repaintManager.setDoubleBufferingEnabled(false);
}
super.paintImmediately(x, y, w, h);
if (repaintManager != null) {
repaintManager.setDoubleBufferingEnabled(save);
}
}
public void paint(Graphics g) {
Dimension d = getSize();
if (imageType == 1)
bimg = null;
else if (bimg == null || biw != d.width || bih != d.height) {
bimg = createBufferedImage((Graphics2D)g,
d.width, d.height, imageType-2);
clearOnce = true;
toBeInitialized = true;
}
if (toBeInitialized) {
toBeInitialized = false;
startClock();
}
Graphics2D g2 = createGraphics2D(d.width, d.height, bimg, g);
render(d.width, d.height, g2);
g2.dispose();
if (bimg != null) {
g.drawImage(bimg, 0, 0, null);
toolkit.sync();
}
}
public void startClock() {
orig = System.currentTimeMillis();
start = orig;
frame = 0;
}
private static final int REPORTFRAMES = 30;
public static void setAlpha(Graphics2D g, float alpha) {
g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha));
}
}
static boolean DynamicObject_loading;
static class DynamicObject {
String className; // just the name, without the "main$"
Map<String, Object> fieldValues = new TreeMap<String, Object>();
DynamicObject() {}
// className = just the name, without the "main$"
DynamicObject(String className) {
this.className = className;}
}
/** this class is fully thread-safe */
static class Flag {
private boolean up;
/** returns true if flag was down before */
public synchronized boolean raise() {
return doRaise();
}
private synchronized boolean doRaise() {
if (!up) {
up = true;
notifyAll();
return true;
} else
return false;
}
public synchronized void waitUntilUp() {
if (!up) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public synchronized void waitUntilUp(long timeout) {
if (!up) {
try {
wait(timeout);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public synchronized boolean isUp() {
return up;
}
public String toString() {
return isUp() ? "up" : "down";
}
// currently does a semi-active wait with latency = 50 ms
public void waitForThisOr(Flag otherFlag) { try {
while (!isUp() && !otherFlag.isUp())
Thread.sleep(50);
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
}
static class BWImage {
private int width, height;
private BWImageSimpleStorage storage;
// color returned when getPixel is called with a position outside the actual image
private float borderColor = 0.0f;
// for unstructure()
BWImage() {}
// BLACK! [Inefficient...]
public BWImage(int width, int height) {
this.width = width;
this.height = height;
byte[] bytePixels = new byte[width*height];
storage = makeStorage(width, height, bytePixels);
}
public BWImage(int width, int height, float[] pixels) {
this.width = width;
this.height = height;
byte[] bytePixels = new byte[pixels.length];
for (int i = 0; i < pixels.length; i++)
bytePixels[i] = toByte(pixels[i]);
storage = makeStorage(width, height, bytePixels);
}
private BWImageSimpleStorage makeStorage(int width, int height, byte[] bytePixels) {
return new BWImageSimpleStorage(width, height, bytePixels);
}
public BWImage(int width, int height, byte[] pixels) {
this.height = height;
this.width = width;
storage = makeStorage(width, height, pixels);
}
public BWImage(BWImage image) {
width = image.getWidth();
height = image.getHeight();
byte[] bytePixels = new byte[width*height];
for (int y = 0; y < height; y++)
for (int x = 0; x < width; x++)
bytePixels[y*width+x] = image.getByte(x, y);
storage = makeStorage(width, height, bytePixels);
}
public BWImage(RGBImage image) {
width = image.getWidth();
height = image.getHeight();
byte[] result = new byte[height*width];
for (int y = 0; y < height; y++)
for (int x = 0; x < width; x++) {
RGB rgb = image.getRGB(x, y);
result[y*width+x] = BWImage.toByte(rgb.getBrightness());
}
storage = makeStorage(width, height, result);
}
/*public BWImage(BufferedImage image) {
this(new RGBImage(image));
}*/
BWImage(BufferedImage image) { try {
width = image.getWidth();
height = image.getHeight();
int[] pixels = new int[width*height];
byte[] bytePixels = new byte[width*height];
PixelGrabber pixelGrabber = new PixelGrabber(image, 0, 0, width, height, pixels, 0, width);
if (!pixelGrabber.grabPixels())
throw fail("Could not grab pixels");
int n = width*height;
for (int i = 0; i < n; i++) {
//bytePixels[i] = pixelToByte(pixels[i]);
int packed = pixels[i];
float r = ((packed >> 16) & 0xFF)/255f;
float g = ((packed >> 8) & 0xFF)/255f;
float b = (packed & 0xFF)/255f;
bytePixels[i] = (byte) ((r+g+b)/3.0f*255f);
}
storage = makeStorage(width, height, bytePixels);
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
// TODO: does it exactly match the other method? (asRGB+getBrightness+toByte)
static byte pixelToByte(int packed) {
/*int r = (packed >> 16) & 0xFF;
int g = (packed >> 8) & 0xFF;
int b = packed & 0xFF;
ret (byte) ((r+g+b)/3.0f);*/
float r = ((packed >> 16) & 0xFF)/255f;
float g = ((packed >> 8) & 0xFF)/255f;
float b = (packed & 0xFF)/255f;
return (byte) ((r+g+b)/3.0f*255f);
}
public byte getByte(int x, int y) {
return inRange(x, y) ? storage.getByte(x,y ) : toByte(borderColor);
}
public BWImage(int width, int height, float brightness) {
this.width = width;
this.height = height;
byte[] pixels = new byte[width*height];
for (int i = 0; i < pixels.length; i++)
pixels[i] = toByte(brightness);
storage = makeStorage(width, height, pixels);
}
public double averageBrightness() {
double sum = 0;
for (int y = 0; y < height; y++)
for (int x = 0; x < width; x++)
sum += getPixel(x, y);
return (sum/(double) (height*width));
}
public float minimumBrightness() {
float min = 1;
for (int y = 0; y < height; y++)
for (int x = 0; x < width; x++)
min = Math.min(min, getPixel(x, y));
return min;
}
public float getPixel(int x, int y) {
return inRange(x, y) ? toFloat(storage.getByte(x,y )) : borderColor;
}
public static byte toByte(float pixel) {
return (byte) (pixel*255f);
}
public static float toFloat(byte pixel) {
return (((int) pixel) & 255)/255f;
}
private boolean inRange(int x, int y) {
return x >= 0 && x < width && y >= 0 && y < height;
}
public int getWidth() {
return width;
}
public int getHeight() {
return height;
}
public RGBImage toRGB() {
RGB[] rgbs = new RGB[width*height];
for (int y = 0; y < height; y++)
for (int x = 0; x < width; x++) {
float p = getPixel(x, y);
rgbs[y*width+x] = new RGB(p, p, p);
}
return new RGBImage(width, height, rgbs);
}
public BWImage clip(int x, int y, int w, int h) {
return clip(new Rectangle(x, y, w, h));
}
private Rectangle fixClipRect(Rectangle r) {
return r.intersection(new Rectangle(0, 0, width, height));
}
/** this should be multithread-safe */
public BWImage clip(Rectangle r) {
r = fixClipRect(r);
byte[] newPixels = new byte[r.height*r.width];
for (int y = 0; y < r.height; y++)
for (int x = 0; x < r.width; x++)
newPixels[y*r.width+x] = getByte(r.x+x, r.y+y);
return new BWImage(r.width, r.height, newPixels);
}
public void setPixel(int x, int y, float brightness) {
storage.setByte(x, y, toByte(fixPixel(brightness)));
}
public void setByte(int x, int y, byte brightness) {
storage.setByte(x, y, brightness);
}
private float fixPixel(float pixel) {
return Math.max(0, Math.min(1, pixel));
}
public float getBorderColor() {
return borderColor;
}
public void setBorderColor(float borderColor) {
this.borderColor = borderColor;
}
public boolean anyPixelBrighterThan(double threshold) {
for (int y = 0; y < height; y++)
for (int x = 0; x < width; x++)
if (getPixel(x, y) > threshold)
return true;
return false;
}
BufferedImage getBufferedImage() {
//ret toRGB().getBufferedImage();
BufferedImage bufferedImage = new BufferedImage(width, height, BufferedImage.TYPE_BYTE_GRAY);
for (int y = 0; y < height; y++)
for (int x = 0; x < width; x++) {
int b = ((int) getByte(x, y) & 0xFF);
bufferedImage.setRGB(x, y, b*0x010101);
}
return bufferedImage;
}
byte[] getBytes() {
return storage.pixels;
}
}
static class BWImageSimpleStorage {
int width, height;
byte[] pixels;
// for unstructure()
BWImageSimpleStorage() {}
public BWImageSimpleStorage(int width, int height, byte[] pixels) {
this.width = width;
this.height = height;
this.pixels = pixels;
}
public void setByte(int x, int y, byte b) {
pixels[y*width+x] = b;
}
public byte getByte(int x, int y) {
return pixels[y*width+x];
}
}
static class Var<A> {
A v; // you can access this directly if you use one thread
Var() {}
Var(A v) {
this.v = v;}
synchronized void set(A a) { v = a; }
synchronized A get() { return v; }
synchronized boolean has() { return v != null; }
}
static class RGB {
public final float r, g, b;
public RGB(float r, float g, float b) {
this.r = r;
this.g = g;
this.b = b;
}
public RGB(double r, double g, double b) {
this.r = (float) r;
this.g = (float) g;
this.b = (float) b;
}
public RGB(double brightness) {
this.r = this.g = this.b = (float) brightness;
}
public RGB(Color color) {
this.r = color.getRed()/255f;
this.g = color.getGreen()/255f;
this.b = color.getBlue()/255f;
}
public RGB(String hex) {
r = Integer.parseInt(hex.substring(0, 2), 16)/255f;
g = Integer.parseInt(hex.substring(2, 4), 16)/255f;
b = Integer.parseInt(hex.substring(4, 6), 16)/255f;
}
public float getComponent(int i) {
return i == 0 ? r : i == 1 ? g : b;
}
public Color getColor() {
return new Color(r, g, b);
}
public static RGB newSafe(float r, float g, float b) {
return new RGB(Math.max(0, Math.min(1, r)), Math.max(0, Math.min(1, g)), Math.max(0, Math.min(1, b)));
}
public int asInt() {
return getColor().getRGB() & 0xFFFFFF;
}
public float getBrightness() {
return (r+g+b)/3.0f;
}
public String getHexString() {
return Integer.toHexString(asInt() | 0xFF000000).substring(2).toUpperCase();
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof RGB)) return false;
RGB rgb = (RGB) o;
if (Float.compare(rgb.b, b) != 0) return false;
if (Float.compare(rgb.g, g) != 0) return false;
if (Float.compare(rgb.r, r) != 0) return false;
return true;
}
@Override
public int hashCode() {
int result = (r != +0.0f ? Float.floatToIntBits(r) : 0);
result = 31 * result + (g != +0.0f ? Float.floatToIntBits(g) : 0);
result = 31 * result + (b != +0.0f ? Float.floatToIntBits(b) : 0);
return result;
}
public boolean isBlack() {
return r == 0f && g == 0f && b == 0f;
}
public boolean isWhite() {
return r == 1f && g == 1f && b == 1f;
}
public String toString() {
return getHexString();
}
}
static class RGBImage {
transient BufferedImage bufferedImage;
File file;
int width, height;
int[] pixels;
// color returned when getPixel is called with out-of-bounds position
int background = 0xFFFFFF;
RGBImage() {}
RGBImage(BufferedImage image) {
this(image, null);
}
RGBImage(BufferedImage image, File file) {
this.file = file;
bufferedImage = image;
width = image.getWidth();
height = image.getHeight();
pixels = new int[width*height];
PixelGrabber pixelGrabber = new PixelGrabber(image, 0, 0, width, height, pixels, 0, width);
try {
if (!pixelGrabber.grabPixels())
throw new RuntimeException("Could not grab pixels");
cleanPixels(); // set upper byte to 0
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
/** We assume it's a file name to load from */
RGBImage(String file) throws IOException {
this(new File(file));
}
RGBImage(Dimension size, Color color) {
this(size.width, size.height, color);
}
RGBImage(Dimension size, RGB color) {
this(size.width, size.height, color);
}
private void cleanPixels() {
for (int i = 0; i < pixels.length; i++)
pixels[i] &= 0xFFFFFF;
}
RGBImage(int width, int height, int[] pixels) {
this.width = width;
this.height = height;
this.pixels = pixels;
}
RGBImage(int w, int h, RGB[] pixels) {
this.width = w;
this.height = h;
this.pixels = asInts(pixels);
}
public static int[] asInts(RGB[] pixels) {
int[] ints = new int[pixels.length];
for (int i = 0; i < pixels.length; i++)
ints[i] = pixels[i] == null ? 0 : pixels[i].getColor().getRGB();
return ints;
}
public RGBImage(int w, int h) {
this(w, h, Color.black);
}
RGBImage(int w, int h, RGB rgb) {
this.width = w;
this.height = h;
this.pixels = new int[w*h];
int col = rgb.asInt();
if (col != 0)
for (int i = 0; i < pixels.length; i++)
pixels[i] = col;
}
RGBImage(RGBImage image) {
this(image.width, image.height, copyPixels(image.pixels));
}
RGBImage(int width, int height, Color color) {
this(width, height, new RGB(color));
}
RGBImage(File file) throws IOException {
this(javax.imageio.ImageIO.read(file));
}
private static int[] copyPixels(int[] pixels) {
int[] copy = new int[pixels.length];
System.arraycopy(pixels, 0, copy, 0, pixels.length);
return copy;
}
public int getIntPixel(int x, int y) {
if (inRange(x, y))
return pixels[y * width + x];
else
return background;
}
public static RGB asRGB(int packed) {
int r = (packed >> 16) & 0xFF;
int g = (packed >> 8) & 0xFF;
int b = packed & 0xFF;
return new RGB(r / 255f, g / 255f, b / 255f);
}
public RGB getRGB(int x, int y) {
if (inRange(x, y))
return asRGB(pixels[y * width + x]);
else
return new RGB(background);
}
/** alias of getRGB - I kept typing getPixel instead of getRGB all the time, so I finally created it */
public RGB getPixel(int x, int y) {
return getRGB(x, y);
}
public int getWidth() {
return width;
}
public int getHeight() {
return height;
}
/** Attention: cached, i.e. does not change when image itself changes */
/** @NotNull */
public BufferedImage getBufferedImage() {
if (bufferedImage == null) {
bufferedImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
//bufferedImage.setData(Raster.createRaster(new SampleModel()));
for (int y = 0; y < height; y++)
for (int x = 0; x < width; x++)
bufferedImage.setRGB(x, y, pixels[y*width+x]);
}
return bufferedImage;
}
public RGBImage clip(Rectangle r) {
r = fixClipRect(r);
int[] newPixels;
try {
newPixels = new int[r.width*r.height];
} catch (RuntimeException e) {
System.out.println(r);
throw e;
}
for (int y = 0; y < r.height; y++) {
System.arraycopy(pixels, (y+r.y)*width+r.x, newPixels, y*r.width, r.width);
}
return new RGBImage(r.width, r.height, newPixels);
}
private Rectangle fixClipRect(Rectangle r) {
r = r.intersection(new Rectangle(0, 0, width, height));
if (r.isEmpty())
r = new Rectangle(r.x, r.y, 0, 0);
return r;
}
public File getFile() {
return file;
}
/** can now also do GIF (not just JPEG) */
public static RGBImage load(String fileName) {
return load(new File(fileName));
}
/** can now also do GIF (not just JPEG) */
public static RGBImage load(File file) {
try {
BufferedImage bufferedImage = javax.imageio.ImageIO.read(file);
return new RGBImage(bufferedImage);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public int getInt(int x, int y) {
return pixels[y * width + x];
}
public void save(File file) throws IOException {
String name = file.getName().toLowerCase();
String type;
if (name.endsWith(".png")) type = "png";
else if (name.endsWith(".jpg") || name.endsWith(".jpeg")) type = "jpeg";
else throw new IOException("Unknown image extension: " + name);
javax.imageio.ImageIO.write(getBufferedImage(), type, file);
}
public static RGBImage dummyImage() {
return new RGBImage(1, 1, new int[] {0xFFFFFF});
}
public int[] getPixels() {
return pixels;
}
public void setPixel(int x, int y, RGB rgb) {
if (x >= 0 && y >= 0 && x < width && y < height)
pixels[y*width+x] = rgb.asInt();
}
public void setPixel(int x, int y, Color color) {
setPixel(x, y, new RGB(color));
}
public void setPixel(int x, int y, int rgb) {
if (x >= 0 && y >= 0 && x < width && y < height)
pixels[y*width+x] = rgb;
}
public RGBImage copy() {
return new RGBImage(this);
}
public boolean inRange(int x, int y) {
return x >= 0 && y >= 0 && x < width && y < height;
}
public int getBackground() {
return background;
}
public void setBackground(int background) {
this.background = background;
}
public Dimension getSize() {
return new Dimension(width, height);
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
RGBImage rgbImage = (RGBImage) o;
if (height != rgbImage.height) return false;
if (width != rgbImage.width) return false;
if (!Arrays.equals(pixels, rgbImage.pixels)) return false;
return true;
}
@Override
public int hashCode() {
int result = width;
result = 31 * result + height;
result = 31 * result + Arrays.hashCode(pixels);
return result;
}
public String getHex(int x, int y) {
return getPixel(x, y).getHexString();
}
public RGBImage clip(int x, int y, int width, int height) {
return clip(new Rectangle(x, y, width, height));
}
public RGBImage clipLine(int y) {
return clip(0, y, width, 1);
}
public int numPixels() {
return width*height;
}
}
static <A extends Concept> A findConcept(Class<A> c, Object... params) {
return findConceptWhere(c, params);
}
static void swingNowOrLater(Runnable r) {
if (isAWTThread())
r.run();
else
swingLater(r);
}
static boolean inRange(int x, int n) {
return x >= 0 && x < n;
}
static <A> List<A> reversed(Collection<A> l) {
return reversedList(l);
}
static boolean bwRawImageSearch_verbose;
static BWImageSectionComparator bwRawImageSearch_comparator;
static int bwRawImageSearch_maxEntries = 1000;
// similarity = e.g. 0.99f
static List<FoundImg> bwRawImageSearch(BWImage big, BWImage pat, float similarity) {
List<FoundImg> found = new ArrayList<FoundImg>();
int wp = pat.getWidth(), hp = pat.getHeight();
int w = big.getWidth(), h = big.getHeight();
float maxError = (1f-similarity)*wp*hp;
for (int y = 0; y < h-hp; y++)
for (int x = 0; x < w-wp; x++) {
float diff = bwRawImageSearch_comparator != null
? bwRawImageSearch_comparator.compare(big, pat, x, y, maxError)
: bwImageSectionsSimilarity(big, pat, x, y, maxError);
if (diff <= maxError) {
float sim = 1-diff/(wp*hp);
if (bwRawImageSearch_verbose)
print(" Image found at " + x + "/" + y + " [sim: " + formatDouble(sim, 4) + "]");
Rect r = new Rect(x, y, wp, hp);
found.add(new FoundImg(r, sim));
ping();
if (l(found) >= bwRawImageSearch_maxEntries) return found;
x += wp-1;
}
}
return found;
}
static Class run(String progID, String... args) {
Class main = hotwire(progID);
callMain(main, args);
return main;
}
static float bwImageSectionsSimilarity(BWImage big, BWImage pat, int x, int y, float max) {
int wp = pat.getWidth(), hp = pat.getHeight();
int w = big.getWidth(), h = big.getHeight();
float diff = 0;
for (int yy = 0; yy < hp; yy++)
for (int xx = 0; xx < wp; xx++) {
diff += abs(big.getPixel(x+xx, y+yy)-pat.getPixel(xx, yy));
if (diff > max) return max+1;
}
return diff;
}
static BufferedImage clipBufferedImage(BufferedImage src, Rectangle clip) {
return src.getSubimage(clip.x, clip.y, clip.width, clip.height);
}
static void substance() {
substanceLAF();
}
static void substance(String skinName) {
substanceLAF(skinName);
}
static void popup(final Throwable throwable) {
popupError(throwable);
}
static void popup(final String msg) {
print(msg);
SwingUtilities.invokeLater(new Runnable() {
public void run() {
JOptionPane.showMessageDialog(null, msg);
}
});
}
static List filter(Iterable c, Object pred) {
List x = new ArrayList();
for (Object o : c)
if (isTrue(callF(pred, o)))
x.add(o);
return x;
}
static List filter(Object pred, Iterable c) {
return filter(c, pred);
}
static void awtLater(int delay, final Runnable r) {
swingLater(delay, r);
}
static void awtLater(Runnable r) {
swingLater(r);
}
static int asInt(Object o) {
return toInt(o);
}
static void popupError(final Throwable throwable) {
throwable.printStackTrace(); // print stack trace to console for the experts
SwingUtilities.invokeLater(new Runnable() {
public void run() {
String text = throwable.toString();
//text = cutPrefix(text, "java.lang.RuntimeException: ");
JOptionPane.showMessageDialog(null, text);
}
});
}
static float abs(float f) {
return Math.abs(f);
}
static void callMain(Object c, String... args) {
callOpt(c, "main", new Object[] {args});
}
static void substanceLAF() {
substanceLAF(null);
}
static String substanceLAF_version = "#1003448";
static void substanceLAF(String skinName) {
try { /* pcall 1*/
if (!substanceLookAndFeelEnabled()) {
Object x = hotwire_overInternalBot(substanceLAF_version);
if (skinName != null)
set(x, "skinName", skinName);
runMain(x);
JFrame.setDefaultLookAndFeelDecorated(substanceLookAndFeelEnabled());
}
/* pcall 2 */ } catch (Throwable __e) { printStackTrace(__e); }
}
static <A> List<A> reversedList(Collection<A> l) {
List<A> x = cloneList(l);
Collections.reverse(x);
return x;
}
public static String formatDouble(double d, int digits) {
String format = "0.";
for (int i = 0; i < digits; i++) format += "#";
return new java.text.DecimalFormat(format, new java.text.DecimalFormatSymbols(Locale.ENGLISH)).format(d);
}
// compile JavaX source, load classes & return main class
// src can be a snippet ID or path to sources dir
// TODO: record injection?
static Class<?> hotwire(String src) {
try {
Class j = getJavaX();
synchronized(j) { // hopefully this goes well...
List<File> libraries = new ArrayList<File>();
File srcDir = (File) call(j, "transpileMain", src, libraries);
if (srcDir == null)
throw fail("transpileMain returned null (src=" + quote(src) + ")");
Object androidContext = get(j, "androidContext");
if (androidContext != null)
return (Class) call(j, "loadx2android", srcDir, src);
File classesDir = (File) call(j, "TempDirMaker_make");
String javacOutput = (String) call(j, "compileJava", srcDir, libraries, classesDir);
System.out.println(javacOutput);
URL[] urls = new URL[libraries.size()+1];
urls[0] = classesDir.toURI().toURL();
for (int i = 0; i < libraries.size(); i++)
urls[i+1] = libraries.get(i).toURI().toURL();
// make class loader
URLClassLoader classLoader = new URLClassLoader(urls);
// load & return main class
Class<?> theClass = classLoader.loadClass("main");
callOpt(j, "registerSourceCode", theClass, loadTextFile(new File(srcDir, "main.java")));
call(j, "setVars", theClass, isSnippetID(src) ? src : null);
if (isSnippetID(src))
callOpt(j, "addInstance", src, theClass);
if (!_inCore())
hotwire_copyOver(theClass);
return theClass;
}
} catch (Exception e) {
throw e instanceof RuntimeException ? (RuntimeException) e : new RuntimeException(e);
}
}
static boolean _inCore() {
return false;
}
static Class<?> hotwire_overInternalBot(String progID) { try {
File jar = CompilerBot.compileSnippet(progID);
assertTrue(jar.getAbsolutePath(), jar.isFile());
// collect urls (program + libraries)
List<URL> urls = litlist(jar.toURI().toURL());
String dehlibs = unnull(loadTextFileFromZip(jar, "libraries"));
Matcher matcher = Pattern.compile("\\d+").matcher(dehlibs);
while (matcher.find()) {
String libID = matcher.group();
urls.add(loadLibrary(libID).toURI().toURL());
}
// make class loader
URLClassLoader classLoader = new URLClassLoader(urls.toArray(new URL[l(urls)]));
// load & return main class
Class<?> theClass = classLoader.loadClass("main");
Class j = getJavaX();
String src = loadTextFileFromZip(jar, "main.java");
call(j, "registerSourceCode", theClass, src);
synchronized(j) { // hopefully this goes well...
call(j, "setVars", theClass, progID);
callOpt(j, "addInstance", progID, theClass);
}
hotwire_copyOver(theClass);
return theClass;
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static void runMain(Object c, String... args) {
callMain(c, args);
}
static void hotwire_copyOver(Class c) {
synchronized(StringBuffer.class) {
for (String field : litlist("print_log", "print_silent", "androidContext")) {
Object o = getOpt(mc(), field);
if (o != null)
setOpt(c, field, o);
}
Object mainBot = getMainBot();
if (mainBot != null)
setOpt(c, "mainBot", mainBot);
setOpt(c, "creator_class", new WeakReference(mc()));
}
}
static String loadTextFileFromZip(File inZip, String fileName) {
return loadTextFileFromZipFile(inZip, fileName);
}
static File loadLibrary(String snippetID) {
return loadBinarySnippet(snippetID);
}
static String loadTextFileFromZipFile(File inZip, String fileName) { try {
ZipFile zip = new ZipFile(inZip);
try {
ZipEntry entry = zip.getEntry(fileName);
if (entry == null)
//fail("Entry " + fileName + " not found in zip file: " + inZip.getAbsolutePath());
return null;
InputStream fin = zip.getInputStream(entry);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
copyStream(fin, baos);
fin.close();
return fromUTF8(baos.toByteArray());
} finally {
zip.close();
}
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static String fromUTF8(byte[] bytes) {
return fromUtf8(bytes);
}
static class CompilerBot {
static boolean verbose;
// returns jar path
static File compileSnippet(String snippetID) {
String transpiledSrc = getServerTranspiled2(snippetID);
int i = transpiledSrc.indexOf('\n');
String libs = transpiledSrc.substring(0, Math.max(0, i));
if (verbose)
print("Compiling snippet: " + snippetID + ". Libs: " + libs);
transpiledSrc = transpiledSrc.substring(i+1);
return compile(transpiledSrc, libs);
}
static File compile(String src) {
return compile(src, "");
}
static File compile(String src, String libs) {
return compile(src, libs, null);
}
static File compile(String src, String dehlibs, String javaTarget) {
if (verbose)
print("Compiling " + l(src) + " chars");
String md5 = md5(src);
File jar = getJarFile(md5);
if (jar == null || jar.length() <= 22) {
// have to compile
javaCompileToJar(src, dehlibs, jar);
} else {
if (verbose)
print("Getting classes from cache (" + jar.getAbsolutePath() + ", " + jar.length() + " bytes)");
touchFile(jar); // so we can find the unused ones easier
}
return jar;
}
static File getJarFile(String md5) {
assertTrue(isMD5(md5));
return new File(getCacheProgramDir("#1002203"), md5 + ".jar");
}
}
static class ImageSurfaceSelector extends MouseAdapter {
ImageSurface is;
Point startingPoint;
boolean enabled = true;
ImageSurfaceSelector(ImageSurface is) {
this.is = is;
if (containsInstance(is.tools, ImageSurfaceSelector.class)) return;
print("New selector");
is.tools.add(this);
is.addMouseListener(this);
is.addMouseMotionListener(this);
}
public void mousePressed(MouseEvent evt) {
if (evt.getButton() != MouseEvent.BUTTON1) return;
if (enabled)
startingPoint = getPoint(evt);
}
public void mouseDragged(MouseEvent e) {
if (startingPoint != null) {
Point endPoint = getPoint(e);
Rectangle r = new Rectangle(startingPoint, new Dimension(endPoint.x-startingPoint.x+1, endPoint.y-startingPoint.y+1));
normalize(r);
is.setSelection(r);
}
}
public static void normalize(Rectangle r) {
if (r.width < 0) {
r.x += r.width;
r.width = -r.width;
}
if (r.height < 0) {
r.y += r.height;
r.height = -r.height;
}
}
public void mouseReleased(MouseEvent e) {
mouseDragged(e);
if (getPoint(e).equals(startingPoint))
is.setSelection(null);
startingPoint = null;
}
Point getPoint(MouseEvent e) {
return new Point((int) (e.getX()/is.getZoomX()), (int) (e.getY()/is.getZoomY()));
}
}
static interface BWImageSectionComparator {
float compare(BWImage big, BWImage pat, int x, int y, float max);
}
static class PopupMenuHelper extends MouseAdapter {
JPopupMenu menu;
Point point;
/** override me */
void fillMenu() {
}
public void mousePressed(MouseEvent e) {
displayMenu(e);
}
public void mouseReleased(MouseEvent e) {
displayMenu(e);
}
private void displayMenu(MouseEvent e) {
boolean popupTrigger = e.isPopupTrigger();
if (popupTrigger) {
JPopupMenu menu = new JPopupMenu();
int count = menu.getComponentCount();
this.menu = menu;
this.point = e.getPoint();
fillMenu();
this.menu = null;
if (menu.getComponentCount() != count)
menu.show(e.getComponent(), e.getX(), e.getY());
}
}
public void install(JComponent component) {
component.addMouseListener(this);
}
}
static String getServerTranspiled2(String id) {
String transpiled = loadCachedTranspilation(id);
String md5 = null;
try { /* pcall 1*/
if (transpiled != null)
md5 = md5(transpiled);
/* pcall 2 */ } catch (Throwable __e) { printStackTrace(__e); }
String transpiledSrc = getServerTranspiled(formatSnippetID(id), md5);
if (eq(transpiledSrc, "SAME")) {
print("SAME");
transpiledSrc = loadCachedTranspilation(formatSnippetID(id));
}
return transpiledSrc;
}
// will create the file or update its last modified timestamp
static void touchFile(File file) { try {
closeRandomAccessFile(newRandomAccessFile(mkdirsForFile(file), "rw"));
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static boolean stdEq2(Object a, Object b) {
if (a == null) return b == null;
if (b == null) return false;
if (a.getClass() != b.getClass()) return false;
for (String field : allFields(a))
if (neq(getOpt(a, field), getOpt(b, field)))
return false;
return true;
}
static String md5(String text) { try {
if (text == null) return "-";
return bytesToHex(md5_impl(text.getBytes("UTF-8"))); // maybe different than the way PHP does it...
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static String md5(byte[] data) {
if (data == null) return "-";
return bytesToHex(md5_impl(data));
}
static MessageDigest md5_md;
/*static byte[] md5_impl(byte[] data) { try {
if (md5_md == null)
md5_md = MessageDigest.getInstance("MD5");
return ((MessageDigest) md5_md.clone()).digest(data);
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}*/
static byte[] md5_impl(byte[] data) { try {
return MessageDigest.getInstance("MD5").digest(data);
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static String md5(File file) { try {
return md5(loadBinaryFile(file));
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static File javaCompileToJar(String src, File destJar) {
return javaCompileToJar(src, "", destJar);
}
// returns path to jar
static synchronized File javaCompileToJar(String src, String dehlibs, File destJar) {
String javaTarget = null; // use default target
print("Compiling " + l(src) + " chars");
String md5 = md5(src);
File jar = destJar;
Class j = getJavaX();
if (javaTarget != null)
setOpt(j, "javaTarget", javaTarget);
//setOpt(j, "verbose", true);
File srcDir = (File) ( call(j, "TempDirMaker_make"));
String className = getNameOfPublicClass(javaTok(src));
String fileName = className + ".java";
File mainJava = new File(srcDir, fileName);
//print("main java: " + mainJava.getAbsolutePath());
saveTextFile(mainJava, src);
File classesDir = (File) call(j, "TempDirMaker_make");
List<File> libraries = new ArrayList<File>();
Matcher m = Pattern.compile("\\d+").matcher(dehlibs);
while (m.find()) {
String libID = m.group();
//print("libID=" + quote(libID));
assertTrue(isSnippetID(libID));
libraries.add(loadLibrary(libID));
}
try {
String compilerOutput = (String) ( call(j, "compileJava", srcDir, libraries, classesDir));
if (nempty(compilerOutput))
print("Compiler said: " + compilerOutput);
// sanity test
if (!new File(classesDir, className + ".class").exists())
throw fail("No class generated (" + className + ")");
} catch (Exception e) {
//e.printStackTrace();
throw fail("Compile Error. " + getOpt(j, "javaCompilerOutput"));
}
// add sources to .jar
saveTextFile(new File(classesDir, "main.java"), src);
// add information about libraries to jar
if (nempty(dehlibs))
saveTextFile(new File(classesDir, "libraries"), dehlibs);
//print("Zipping: " + classesDir.getAbsolutePath() + " to " + jar.getAbsolutePath());
dir2zip_recurse_verbose = false;
int n = dir2zip_recurse(classesDir, jar); // cache on success only
//print("Files zipped: " + n);
return jar;
}
static int stdHash2(Object a) {
if (a == null) return 0;
return stdHash(a, toStringArray(allFields(a)));
}
static boolean isMD5(String s) {
return l(s) == 32 && isLowerHexString(s);
}
static boolean containsInstance(Iterable i, Class c) {
if (i != null) for (Object o : i)
if (isInstanceX(c, o)) return true; return false;
}
static boolean isLowerHexString(String s) {
for (int i = 0; i < l(s); i++) {
char c = s.charAt(i);
if (c >= '0' && c <= '9' || c >= 'a' && c <= 'f') {
// ok
} else
return false;
}
return true;
}
static void closeRandomAccessFile(RandomAccessFile f) {
if (f != null) try { /* pcall 1*/
f.close();
callJavaX("dropIO", f);
/* pcall 2 */ } catch (Throwable __e) { printStackTrace(__e); }
}
static String getNameOfPublicClass(List<String> tok) {
for (List<String> c : allClasses(tok))
if (hasModifier(c, "public"))
return getClassDeclarationName(c);
return null;
}
static Set<String> allFields(Object o) {
TreeSet<String> fields = new TreeSet<String>();
Class _c = _getClass(o);
do {
for (Field f : _c.getDeclaredFields())
fields.add(f.getName());
_c = _c.getSuperclass();
} while (_c != null);
return fields;
}
static String loadCachedTranspilation(String id) {
return loadTextFile(new File(getCodeProgramDir(id), "Transpilation"));
}
static RandomAccessFile newRandomAccessFile(File path, String mode) throws IOException {
RandomAccessFile f = new RandomAccessFile(path, mode);
callJavaX("registerIO", f, path, mode.indexOf('w') >= 0);
return f;
}
public static byte[] loadBinaryFile(String fileName) {
try {
if (!new File(fileName).exists())
return null;
FileInputStream in = new FileInputStream(fileName);
byte buf[] = new byte[1024];
ByteArrayOutputStream out = new ByteArrayOutputStream();
int l;
while (true) {
l = in.read(buf);
if (l <= 0) break;
out.write(buf, 0, l);
}
in.close();
return out.toByteArray();
} catch (IOException e) { throw new RuntimeException(e); }
}
public static byte[] loadBinaryFile(File file) {
return loadBinaryFile(file.getPath());
}
static boolean dir2zip_recurse_verbose;
static int dir2zip_recurse(File inDir, File zip) {
return dir2zip_recurse(inDir, zip, "");
}
// TODO: the zero files case?
static int dir2zip_recurse(File inDir, File zip, String outPrefix) { try {
mkdirsForFile(zip);
FileOutputStream fout = newFileOutputStream(zip);
ZipOutputStream outZip = new ZipOutputStream(fout);
try {
return dir2zip_recurse(inDir, outZip, outPrefix, 0);
} finally {
outZip.close();
}
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static int dir2zip_recurse(File inDir, ZipOutputStream outZip, String outPrefix, int level) { try {
if (++level >= 20) throw fail("woot? 20 levels in zip?");
List<File> files = new ArrayList<File>();
for (File f : inDir.listFiles())
files.add(f);
int n = 0;
sortFilesByName(files);
for (File f : files) {
if (f.isDirectory()) {
print("dir2zip_recurse: Scanning " + f.getAbsolutePath());
n += dir2zip_recurse(f, outZip, outPrefix + f.getName() + "/", level);
} else {
if (dir2zip_recurse_verbose) print("Copying " + f.getName());
outZip.putNextEntry(new ZipEntry(outPrefix + f.getName()));
InputStream fin = new FileInputStream(f);
copyStream(fin, outZip);
fin.close();
++n;
}
}
return n;
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static String getServerTranspiled(String snippetID) {
return getServerTranspiled(snippetID, null);
}
// returns "SAME" if md5 matches
static String getServerTranspiled(String snippetID, String expectedMD5) { try {
long id = parseSnippetID(snippetID);
/*S t = getTranspilationFromBossBot(id);
if (t != null) return t;*/
String text = loadPage_utf8("http://tinybrain.de:8080/tb-int/get-transpiled.php?raw=1&withlibs=1&id=" + id + "&utf8=1"
+ (l(expectedMD5) > 1 ? "&md5=" + urlencode(expectedMD5) : "")
+ standardCredentials());
if (nempty(text) && neq(text, "SAME"))
saveTranspiledCode(snippetID, text);
return text;
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
static int stdHash(Object a, String... fields) {
if (a == null) return 0;
int hash = getClassName(a).hashCode();
for (String field : fields)
hash = hash*2+hashCode(getOpt(a, field));
return hash;
}
static String loadPage_utf8(URL url) {
return loadPage_utf8(url.toString());
}
static String loadPage_utf8(String url) {
loadPage_charset.set("UTF-8");
try {
return loadPage(url);
} finally {
loadPage_charset.set(null);
}
}
static void saveTranspiledCode(String progID, String code) {
saveTextFile(new File(getCodeProgramDir(progID), "Transpilation"), code);
}
static File getCodeProgramDir() {
return getCodeProgramDir(getProgramID());
}
static File getCodeProgramDir(String snippetID) {
return new File(javaxCodeDir(), formatSnippetID(snippetID));
}
static File getCodeProgramDir(long snippetID) {
return getCodeProgramDir(formatSnippetID(snippetID));
}
static int hashCode(Object a) {
return a == null ? 0 : a.hashCode();
}
// scans a Java construct (class, method) and checks its modifiers
static boolean hasModifier(List<String> tok, String modifier) {
for (int i = 1; i < tok.size() && getJavaModifiers().contains(tok.get(i)); i += 2)
if (tok.get(i).equals(modifier))
return true;
return false;
}
static String getClassDeclarationName(List<String> c) {
for (int i = 1; i+2 < c.size(); i += 2)
if (eqOneOf(c.get(i), "class", "interface", "enum"))
return c.get(i+2);
return null;
}
// lists returned are actual CNC (N/C/N/.../C/N) - and connected to
// original list
// only returns the top level classes
static List<List<String>> allClasses(List<String> tok) {
List<List<String>> l = new ArrayList();
for (int i = 1; i < tok.size(); i += 2) {
if (eqOneOf(tok.get(i), "class", "interface", "enum") && (i == 1 || !tok.get(i-2).equals("."))) {
int j = i;
while (j < tok.size() && !tok.get(j).equals("{"))
j += 2;
j = findEndOfBlock(tok, j)+1;
i = leftScanModifiers(tok, i);
l.add(tok.subList(i-1, Math.min(tok.size(), j)));
i = j-2;
}
}
return l;
}
static List<List<String>> allClasses(String text) {
return allClasses(javaTok(text));
}
static void sortFilesByName(List<File> l) {
sort(l, new Comparator<File>() {
public int compare(File a, File b) {
return stdcompare(a.getName(), b.getName());
}
});
}
static File javaxCodeDir_dir; // can be set to work on different base dir
static File javaxCodeDir() {
return javaxCodeDir_dir != null ? javaxCodeDir_dir : new File(userHome(), "JavaX-Code");
}
static List<String> getJavaModifiers_list = litlist("static", "abstract", "public", "private", "protected", "final", "native", "volatile", "synchronized", "transient");
static List<String> getJavaModifiers() {
return getJavaModifiers_list;
}
static <T> void sort(T[] a, Comparator<? super T> c) {
Arrays.sort(a, c);
}
static <T> void sort(T[] a) {
Arrays.sort(a);
}
static <T> void sort(List<T> a, Comparator<? super T> c) {
Collections.sort(a, c);
}
static void sort(List a) {
Collections.sort(a);
}
// i must point at the opening bracket ("{")
// index returned is index of closing bracket + 1
static int findEndOfBlock(List<String> cnc, int i) {
int j = i+2, level = 1;
while (j < cnc.size()) {
if (cnc.get(j).equals("{")) ++level;
else if (cnc.get(j).equals("}")) --level;
if (level == 0)
return j+1;
++j;
}
return cnc.size();
}
static int leftScanModifiers(List<String> tok, int i) {
List<String> mod = getJavaModifiers();
while (i > 1 && mod.contains(tok.get(i-2)))
i -= 2;
return i;
}
}