Ticket #2173: beautiful_text.patch

modules/org.sophie2.base.model.text/src/main/java/org/sophie2/base/model/text/smart/layout/HotSegmentLayout.java

@@ -2 +2 @@
 
 import java.awt.Color;
 import java.awt.Graphics2D;
+import java.awt.RenderingHints;
 import java.awt.Shape;
 import java.awt.font.LineBreakMeasurer;
 import java.awt.font.TextHitInfo;
 import java.awt.font.TextLayout;
+import java.awt.geom.Rectangle2D;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
 import java.util.Comparator;
 import java.util.Iterator;
 
@@ -93 +98 @@
 
                 Graphics2D graphics = (Graphics2D) g2d.create();
                 graphics.translate(x, y);
-                awtLayout.draw(graphics, 0f, 0f);
+                
+                graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+                
                 boolean caretHandled = false;
                 for (Iterator<HotHighlight> iter = highlights.getIterator(); iter.hasNext();) {
                         HotHighlight highlight = iter.next();
@@ -101 +108 @@
                         caretHandled = true;
                 }
                 
+                drawLayout(graphics, 0f, 0f);
+                
                 graphics.dispose();
         }
 
@@ -170 +179 @@
                 return this.awtLayoutCache;
         }
         
+        private Object textLineCache = null;
+        private Object getTextLine() {
+
+                if (this.textLineCache == null) {
+                        TextLayout awtLayout = toAwtLayout();
+                        Field textLineField;
+                        try {
+                                textLineField = awtLayout.getClass().getDeclaredField("textLine");
+                                textLineField.setAccessible(true);
+                                this.textLineCache = textLineField.get(awtLayout);
+                        } catch (SecurityException e) {
+                                throw new RuntimeException(e);
+                        } catch (NoSuchFieldException e) {
+                                throw new RuntimeException(e);
+                        } catch (IllegalArgumentException e) {
+                                throw new RuntimeException(e);
+                        } catch (IllegalAccessException e) {
+                                throw new RuntimeException(e);
+                        }
+                }
+
+                return this.textLineCache;
+        }
+        
+        private Object[] componentsCache = null;
+        private Object[] getComponents() {
+
+                if (this.componentsCache == null) {
+                        try {
+                                Object textLine = getTextLine();
+                                Field fComponentsField = textLine.getClass().getDeclaredField("fComponents");
+                                fComponentsField.setAccessible(true);
+                                this.componentsCache = (Object[]) fComponentsField.get(textLine);
+                        } catch (SecurityException e) {
+                                throw new RuntimeException(e);
+                        } catch (NoSuchFieldException e) {
+                                throw new RuntimeException(e);
+                        } catch (IllegalArgumentException e) {
+                                throw new RuntimeException(e);
+                        } catch (IllegalAccessException e) {
+                                throw new RuntimeException(e);
+                        }
+                }
+                return this.componentsCache;
+        }
+
+        private int[] componentsVisualOrderCache = null;
+        private int[] getComponentsVisualOrder() {
+                
+                if (this.componentsVisualOrderCache == null) {
+                        try {
+                        Object textLine = getTextLine();
+                        Field fComponentVisualOrderField = textLine.getClass().getDeclaredField("fComponentVisualOrder");
+                        fComponentVisualOrderField.setAccessible(true);
+                        this.componentsVisualOrderCache = (int[])fComponentVisualOrderField.get(textLine);
+                        } catch (IllegalAccessException e) {
+                                throw new RuntimeException(e);
+                        } catch (NoSuchFieldException e) {
+                                throw new RuntimeException(e);
+                        }
+                }
+                
+                return this.componentsVisualOrderCache;
+        }
+        
+        private float[] locsCache = null;
+        private float[] getLocs() {
+                if (this.locsCache == null) {
+                        try {
+                        Object textLine = getTextLine();
+                        
+                        Field locsField = textLine.getClass().getDeclaredField("locs");
+                        locsField.setAccessible(true);
+                        this.locsCache = (float[])locsField.get(textLine);
+                        } catch (IllegalAccessException e) {
+                                throw new RuntimeException(e);
+                        } catch (NoSuchFieldException e) {
+                                throw new RuntimeException(e);
+                        }
+                }
+                
+                return this.locsCache;
+        }
+        
+        private void drawLayout(Graphics2D g2, float x, float y) {
+
+                
+                try {
+                        Object[] components = getComponents();
+                        int length = components.length;
+                        
+                        int[] componentVisualOrder = getComponentsVisualOrder();
+                        float[] locs = getLocs();
+                        
+                        for (int i = 0, n = 0; i < length; i++, n += 2) {
+                            int vi = componentVisualOrder==null? i : (Integer)componentVisualOrder[i];
+
+                            Method getOutlineMethod 
+                                = components[vi].getClass().getDeclaredMethod("getOutline", float.class, float.class);
+                            getOutlineMethod.setAccessible(true);
+
+                            Object outlineArgs[] = new Object[2];
+                            outlineArgs[0] = new Float(locs[n] + x);
+                            outlineArgs[1] = new Float(locs[n+1] + y);
+
+                            Shape outlineShape = (Shape)getOutlineMethod.invoke(components[vi], outlineArgs);
+                            
+                            Field decoratorField = components[vi].getClass().getDeclaredField("decorator");
+                            decoratorField.setAccessible(true);
+                                        Object decorator = decoratorField.get(components[vi]);
+                            
+                                        Field fgPaintField = decorator.getClass().getDeclaredField("fgPaint");
+                                        fgPaintField.setAccessible(true);
+                                        Color fgColor = (Color)fgPaintField.get(decorator);
+                                
+                                        Field bgPaintField = decorator.getClass().getDeclaredField("bgPaint");
+                                        bgPaintField.setAccessible(true);
+                                        
+                                        Color bgColor = (Color)bgPaintField.get(decorator);
+                                        
+                                        if (bgColor.getAlpha() != 0) {
+                                                
+                                                 Method getLogicalBoundsMethod = 
+                                                components[vi].getClass().getDeclaredMethod("getLogicalBounds", float.class, float.class);
+                                            getLogicalBoundsMethod.setAccessible(true);
+                                            Rectangle2D background = (Rectangle2D) getLogicalBoundsMethod.invoke(components[vi], outlineArgs); 
+                                            
+                                            background = new Rectangle2D.Float(x + (float)background.getX(),
+                                                        y + (float)background.getY(),
+                                                        (float)background.getWidth(),
+                                                        (float)background.getHeight());
+                                                
+                                                g2.setColor(bgColor);
+                                                g2.fill(background);
+                                        }
+                                        
+                                        g2.setColor(fgColor);
+                            g2.fill(outlineShape);
+                    }
+                } catch (NoSuchFieldException e) {
+                        throw new RuntimeException(e);
+                } catch (IllegalAccessException e) {
+                        throw new RuntimeException(e);
+                } catch (NoSuchMethodException e) {
+                        throw new RuntimeException(e);
+                } catch (InvocationTargetException e) {
+                        throw new RuntimeException(e);
+                }
+        }       
+        
         public ImmHotText getConsumedText() {
                 return this.text;
         }

modules/org.sophie2.dev/src/main/java/org/sophie2/dev/author/FakeAuthorMain.java

@@ -95 +95 @@
         public static void main(String[] args) {
                 //Profiler.start();
                 SophieLog.info("Starting fake...");
-                SophieLog.setMinLevel("", LogLevel.INFO);
+                SophieLog.setMinLevel("", LogLevel.WARN);
                 //SophieLog.setMinLevel("org.sophie2.core.mvc", LogLevel.DEBUG);
                 //SophieLog.setMinLevel("org.sophie2.core.modularity.FileEntryManager.fillFakeModulePaths", LogLevel.ERROR);
                 //SophieLog.setMinLevel("org.sophie2.base.layout", LogLevel.DEBUG);
                 //SophieLog.setMinLevel("org.sophie2.base.model.resources.r4", LogLevel.DEBUG);
                 //SophieLog.setMinLevel("org.sophie2.base.model.resources.r4.access", LogLevel.INFO);
-                SophieLog.setMinLevel("org.sophie2.main.media", LogLevel.ALL);
+                SophieLog.setMinLevel("org.sophie2.main.media", LogLevel.NONE);
+                
                 SophieLog.setMinLevel("org.sophie2.main.media.natlib.output", LogLevel.NONE);
+                SophieLog.setMinLevel("org.sophie2.main.func.servers.view", LogLevel.NONE);
+                
                 //SophieLog.setMinLevel("org.sophie2.main.func.timelines", LogLevel.DEBUG);
                 //SophieLog.setMinLevel("org.sophie2.main.media.natlib.output.JavaSoundOutputBridge", LogLevel.TRACE);
                 //SophieLog.setMinLevel("org.sophie2.main.media.natlib.input.JavaSoundInputBridge", LogLevel.TRACE);