001    package railo.commons.pdf;
002    
003    import java.awt.Dimension;
004    import java.awt.Insets;
005    import java.io.InputStream;
006    import java.io.InputStreamReader;
007    import java.io.OutputStream;
008    import java.io.StringReader;
009    import java.net.URL;
010    import java.net.URLClassLoader;
011    
012    import railo.Version;
013    import railo.commons.io.IOUtil;
014    import railo.commons.io.res.Resource;
015    import railo.commons.io.res.filter.ExtensionResourceFilter;
016    import railo.commons.io.res.util.FileWrapper;
017    import railo.commons.io.res.util.ResourceUtil;
018    import railo.commons.lang.ClassUtil;
019    import railo.commons.lang.Md5;
020    import railo.runtime.Info;
021    import railo.runtime.config.Config;
022    import railo.runtime.exp.PageException;
023    import railo.runtime.op.Caster;
024    
025    public class PDF {
026            
027            private final Object pd4ml;
028            private static Class pd4mlClass;
029            private static ClassLoader classLoader;
030            private static Class pd4mlMarkClass;
031            //private final boolean isEvaluation;
032    
033            public PDF(Config config) throws PageException {
034                    //this.isEvaluation=isEvaluation;
035                    try {
036                            //classLoader=new URLClassLoader(new URL[]{new File("/Users/mic/Downloads/java/pd4ml/fullversion/pd4ml.volume.310/lib/pd4ml.jar").toURL()},this.getClass().getClassLoader());
037                            if(classLoader==null) {
038                                    Resource temp = config.getConfigDir().getRealResource("temp");
039                                    Resource file=temp.getRealResource(Md5.getDigestAsString(Info.getVersionAsString())+".lmdp");
040                            
041                                    if(!file.exists()){
042                                            ResourceUtil.removeChildrenEL(temp, new ExtensionResourceFilter(".lmdp"));
043                                            
044                                    file.createFile(true);
045                                    //print.out(new Info().getClass().getResource("/resource/lib/pd4ml.jar"));
046                                    InputStream jar = new Info().getClass().getResourceAsStream("/resource/lib/pd4ml.jar");
047                                    IOUtil.copy(jar, file,true);
048                            }
049                            ClassLoader parent = Version.class.getClassLoader();
050                            classLoader=new URLClassLoader(new URL[]{FileWrapper.toFile(file).toURL()},parent);
051                            
052                            //classLoader=new URLClassLoader(new URL[]{new Info().getClass().getResource("/resource/lib/pd4ml.jar")},this.getClass().getClassLoader());
053                            }
054                            if(pd4mlClass==null)pd4mlClass=ClassUtil.loadClass(classLoader,"org.zefer.pd4ml.PD4ML");
055                            pd4ml=ClassUtil.loadInstance(pd4mlClass);
056                            
057                    } catch (Exception e) {
058                            throw Caster.toPageException(e);
059                    }
060                    pd4mlClass=pd4ml.getClass();
061            }
062            
063            public void enableTableBreaks(boolean b) throws PageException {
064                    invoke(pd4ml,"enableTableBreaks",b);
065            }
066    
067            public void interpolateImages(boolean b) throws PageException {
068                    invoke(pd4ml,"interpolateImages",b);
069            }
070    
071            public void adjustHtmlWidth() throws PageException {
072                    invoke(pd4ml,"adjustHtmlWidth");
073            }
074    
075            public void setPageInsets(Insets insets) throws PageException {
076                    invoke(pd4ml,"setPageInsets",insets);
077            }
078    
079            public void setPageSize(Dimension dimension) throws PageException {
080                    invoke(pd4ml,"setPageSize",dimension);
081            }
082    
083            public void setPageHeader(PDFPageMark header) throws PageException {
084                    invoke(pd4ml,"setPageHeader",toPD4PageMark(header));
085            }
086            
087            public void generateOutlines(boolean flag) throws PageException {
088                    invoke(pd4ml,"generateOutlines",
089                                    new Object[]{Caster.toBoolean(flag)},new Class[]{boolean.class});
090            }
091    
092            public void useTTF(String pathToFontDirs,boolean embed ) throws PageException {
093                    invoke(pd4ml,"useTTF",
094                                    new Object[]{pathToFontDirs,Caster.toBoolean(embed)},
095                                    new Class[]{String.class,boolean.class});
096            }
097    
098            public void setPageFooter(PDFPageMark footer) throws PageException {
099                    //if(isEvaluation) return;
100                    invoke(pd4ml,"setPageFooter",toPD4PageMark(footer));
101            }
102            
103            public void render(InputStreamReader reader, OutputStream os) throws PageException {
104                    //setEvaluationFooter();
105                    
106                    
107                    invoke(pd4ml, "render", 
108                                    new Object[]{reader,os}, 
109                                    new Class[]{reader.getClass(),OutputStream.class});
110                    
111                    //invoke(pd4ml,"render",reader,os,OutputStream.class);
112                    
113            }
114    
115            public void render(String str, OutputStream os,URL base) throws PageException {
116                    //setEvaluationFooter();
117                    
118                    StringReader sr = new StringReader(str);
119                    if(base==null) {
120                            invoke(pd4ml, "render", 
121                                    new Object[]{sr,os}, 
122                                    new Class[]{sr.getClass(),OutputStream.class});
123                    }
124                    else {
125                            invoke(pd4ml, "render", 
126                                    new Object[]{sr,os,base}, 
127                                    new Class[]{sr.getClass(),OutputStream.class,URL.class});
128                    }
129                    //invoke(pd4ml,"render",new StringReader(str),os,OutputStream.class);
130            }
131            
132            /*private void setEvaluationFooterX() throws PageException {
133                    if(isEvaluation) invoke(pd4ml,"setPageFooter",toPD4PageMark(new PDFPageMark(-1,EVAL_TEXT)));
134            }*/
135    
136    
137            private Object toPD4PageMark(PDFPageMark mark) throws PageException {
138                    Object pd4mlMark=null;
139                    try {
140                            if(pd4mlMarkClass==null)pd4mlMarkClass=ClassUtil.loadClass(classLoader,"org.zefer.pd4ml.PD4PageMark");
141                            pd4mlMark=ClassUtil.loadInstance(pd4mlMarkClass);
142                            
143                    } catch (Exception e) {
144                    }
145    
146                    invoke(pd4mlMark,"setAreaHeight",mark.getAreaHeight());
147                    invoke(pd4mlMark,"setHtmlTemplate",mark.getHtmlTemplate());
148                    return pd4mlMark;
149            }
150            
151            private void invoke(Object o,String methodName, Object[] args, Class[] argClasses) throws PageException {
152                    try {
153                            o.getClass().getMethod(methodName, argClasses).invoke(o, args);
154                    } 
155                    catch (Exception e) {
156                            throw Caster.toPageException(e);
157                    }
158            }
159            /*private void invoke(Object o,String methodName, Object argument1, Object argument2,Class clazz) throws PageException {
160                    try {
161                            o.getClass().getMethod(methodName, new Class[]{argument1.getClass(),clazz}).invoke(o, new Object[]{argument1,argument2});
162                    } 
163                    catch (Exception e) {
164                            throw Caster.toPageException(e);
165                    }
166            }*/
167            private void invoke(Object o,String methodName, Object argument) throws PageException {
168                    try {
169                            o.getClass().getMethod(methodName, new Class[]{argument.getClass()}).invoke(o, new Object[]{argument});
170                    } 
171                    catch (Exception e) {
172                            throw Caster.toPageException(e);
173                    }
174            }
175    
176            private void invoke(Object o,String methodName, boolean argument) throws PageException {
177                    try {
178                            o.getClass().getMethod(methodName, new Class[]{boolean.class}).invoke(o, new Object[]{Caster.toRef(argument)});
179                    } 
180                    catch (Exception e) {
181                            throw Caster.toPageException(e);
182                    }
183            }
184            private void invoke(Object o,String methodName, int argument) throws PageException {
185                    try {
186                            o.getClass().getMethod(methodName, new Class[]{int.class}).invoke(o, new Object[]{Caster.toRef(argument)});
187                    } 
188                    catch (Exception e) {
189                            throw Caster.toPageException(e);
190                    }
191            }
192            
193            private void invoke(Object o,String methodName) throws PageException {
194                    try {
195                            o.getClass().getMethod(methodName, new Class[]{}).invoke(o, new Object[]{});
196                    } 
197                    catch (Exception e) {
198                            throw Caster.toPageException(e);
199                    }
200            }
201    
202    }