001: /*
002: * Copyright 2006-2007 Pentaho Corporation. All rights reserved.
003: * This software was developed by Pentaho Corporation and is provided under the terms
004: * of the Mozilla Public License, Version 1.1, or any later version. You may not use
005: * this file except in compliance with the license. If you need a copy of the license,
006: * please go to http://www.mozilla.org/MPL/MPL-1.1.txt.
007: *
008: * Software distributed under the Mozilla Public License is distributed on an "AS IS"
009: * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. Please refer to
010: * the license for the specific language governing your rights and limitations.
011: *
012: * Additional Contributor(s): Martin Schmid gridvision engineering GmbH
013: */
014: package org.pentaho.reportdesigner.crm.report.model.functions;
015:
016: import org.jetbrains.annotations.NonNls;
017: import org.jetbrains.annotations.NotNull;
018: import org.jetbrains.annotations.Nullable;
019: import org.jfree.report.function.Expression;
020: import org.pentaho.reportdesigner.crm.report.PropertyKeys;
021: import org.pentaho.reportdesigner.crm.report.model.ReportFunctionElement;
022: import org.pentaho.reportdesigner.crm.report.reportexporter.ReportCreationException;
023: import org.pentaho.reportdesigner.lib.client.i18n.TranslationManager;
024: import org.pentaho.reportdesigner.lib.client.util.IOUtil;
025:
026: import java.beans.BeanInfo;
027: import java.beans.IntrospectionException;
028: import java.beans.Introspector;
029: import java.beans.PropertyDescriptor;
030: import java.io.FileInputStream;
031: import java.lang.reflect.InvocationTargetException;
032: import java.lang.reflect.Method;
033: import java.lang.reflect.Modifier;
034: import java.util.Arrays;
035: import java.util.Comparator;
036: import java.util.HashMap;
037: import java.util.HashSet;
038: import java.util.LinkedList;
039: import java.util.List;
040: import java.util.StringTokenizer;
041: import java.util.logging.Level;
042: import java.util.logging.Logger;
043:
044: /**
045: * User: Martin
046: * Date: 27.07.2006
047: * Time: 09:56:42
048: */
049: public class ExpressionRegistry {
050: @NonNls
051: @NotNull
052: private static final Logger LOG = Logger
053: .getLogger(ExpressionRegistry.class.getName());
054: @NotNull
055: private static final String FUNCTIONS_FILENAME = "./resources/functions.txt";
056:
057: public static void main(@NotNull
058: String[] args) {
059: ExpressionRegistry instance = ExpressionRegistry.getInstance();
060: for (Class<?> jFreeReportExpressionClass : instance
061: .getJFreeReportExpressionToWrapperClassesMap().keySet()) {
062: Class<?> wrapperClass = instance
063: .getJFreeReportExpressionToWrapperClassesMap().get(
064: jFreeReportExpressionClass);
065: //noinspection UseOfSystemOutOrSystemErr
066: System.out.println(jFreeReportExpressionClass.getName()
067: + " <---> " + wrapperClass.getName());
068: }
069: }
070:
071: @NotNull
072: private static final HashSet<String> exludedExpressionProperties;
073:
074: static {
075: exludedExpressionProperties = new HashSet<String>();
076: exludedExpressionProperties.add("value");//NON-NLS
077: exludedExpressionProperties.add("active");//NON-NLS
078: exludedExpressionProperties.add("dataRow");//NON-NLS
079: exludedExpressionProperties.add("instance");//NON-NLS
080: exludedExpressionProperties.add("cacheKey");//NON-NLS
081: exludedExpressionProperties.add("runtime");//NON-NLS
082: }
083:
084: @NotNull
085: private static final ExpressionRegistry registry = new ExpressionRegistry();
086:
087: @NotNull
088: public static ExpressionRegistry getInstance() {
089: return registry;
090: }
091:
092: @NotNull
093: private HashMap<String, String> jFreeReportExpressionToTreePathMap;
094: @NotNull
095: private HashMap<Class<?>, Class<?>> jFreeReportExpressionToWrapperClassesMap;
096: @NotNull
097: private HashMap<Class<?>, Class<?>> wrapperToJFreeReportExpressionClassesMap;
098: @NotNull
099: private HashMap<String, Class<?>> simpleNameToWrapperClassesMap;
100:
101: @NotNull
102: private HashMap<String, PropertyInfo> propertyInfos;
103:
104: private ExpressionRegistry() {
105: //MARKED we should directly access JFreeReports function registry as soon as available
106:
107: jFreeReportExpressionToTreePathMap = new HashMap<String, String>();
108: jFreeReportExpressionToWrapperClassesMap = new HashMap<Class<?>, Class<?>>();
109: simpleNameToWrapperClassesMap = new HashMap<String, Class<?>>();
110:
111: propertyInfos = new HashMap<String, PropertyInfo>();
112: AdditionalPropertyInfos
113: .initExternalPropertyInfos(propertyInfos);
114: AdditionalPropertyInfos
115: .initTreePathInfos(jFreeReportExpressionToTreePathMap);
116:
117: generateAndAddClassIfPossible("org.jfree.report.function.AverageExpression");
118: generateAndAddClassIfPossible("org.jfree.report.function.ColumnAverageExpression");
119: generateAndAddClassIfPossible("org.jfree.report.function.ColumnDifferenceExpression");
120: generateAndAddClassIfPossible("org.jfree.report.function.ColumnDivisionExpression");
121: generateAndAddClassIfPossible("org.jfree.report.function.ColumnMaximumExpression");
122: generateAndAddClassIfPossible("org.jfree.report.function.ColumnMinimumExpression");
123: generateAndAddClassIfPossible("org.jfree.report.function.ColumnMultiplyExpression");
124: generateAndAddClassIfPossible("org.jfree.report.function.ColumnSumExpression");
125: generateAndAddClassIfPossible("org.jfree.report.function.CompareFieldsExpression");
126: generateAndAddClassIfPossible("org.jfree.report.function.ConvertToDateExpression");
127: generateAndAddClassIfPossible("org.jfree.report.function.ConvertToNumberExpression");
128: generateAndAddClassIfPossible("org.jfree.report.function.CountDistinctFunction");
129: generateAndAddClassIfPossible("org.jfree.report.function.CreateGroupAnchorsFunction");
130: generateAndAddClassIfPossible("org.jfree.report.function.CreateHyperLinksFunction");
131: generateAndAddClassIfPossible("org.jfree.report.function.DateCutExpression");
132: generateAndAddClassIfPossible("org.jfree.report.function.ElementColorFunction");
133: generateAndAddClassIfPossible("org.jfree.report.function.ElementTrafficLightFunction");
134: generateAndAddClassIfPossible("org.jfree.report.function.ElementVisibilityFunction");
135: generateAndAddClassIfPossible("org.jfree.report.function.ElementVisibilitySwitchFunction");
136: generateAndAddClassIfPossible("org.jfree.report.function.EventMonitorFunction");
137: generateAndAddClassIfPossible("org.jfree.report.function.GroupCountFunction");
138: generateAndAddClassIfPossible("org.jfree.report.function.HideElementByNameFunction");
139: generateAndAddClassIfPossible("org.jfree.report.function.HideElementIfDataAvailableExpression");
140: generateAndAddClassIfPossible("org.jfree.report.function.HideNullValuesFunction");
141: generateAndAddClassIfPossible("org.jfree.report.function.HidePageBandForTableExportFunction");
142: generateAndAddClassIfPossible("org.jfree.report.function.IsEmptyExpression");
143: generateAndAddClassIfPossible("org.jfree.report.function.IsNullExpression");
144: generateAndAddClassIfPossible("org.jfree.report.function.ItemAvgFunction");
145: generateAndAddClassIfPossible("org.jfree.report.function.ItemColumnQuotientExpression");
146: generateAndAddClassIfPossible("org.jfree.report.function.ItemCountFunction");
147: generateAndAddClassIfPossible("org.jfree.report.function.ItemHideFunction");
148: generateAndAddClassIfPossible("org.jfree.report.function.ItemMaxFunction");
149: generateAndAddClassIfPossible("org.jfree.report.function.ItemMinFunction");
150: generateAndAddClassIfPossible("org.jfree.report.function.ItemPercentageFunction");
151: generateAndAddClassIfPossible("org.jfree.report.function.ItemSumFunction");
152: generateAndAddClassIfPossible("org.jfree.report.function.NegativeNumberPaintChangeFunction");
153: generateAndAddClassIfPossible("org.jfree.report.function.PageFunction");
154: generateAndAddClassIfPossible("org.jfree.report.function.PageItemCountFunction");
155: generateAndAddClassIfPossible("org.jfree.report.function.PageItemSumFunction");
156: generateAndAddClassIfPossible("org.jfree.report.function.PageOfPagesFunction");
157: generateAndAddClassIfPossible("org.jfree.report.function.PageTotalFunction");
158: generateAndAddClassIfPossible("org.jfree.report.function.PaintComponentFunction");
159: generateAndAddClassIfPossible("org.jfree.report.function.PaintDynamicComponentFunction");
160: generateAndAddClassIfPossible("org.jfree.report.function.PercentageExpression");
161: generateAndAddClassIfPossible("org.jfree.report.function.ShowElementByNameFunction");
162: generateAndAddClassIfPossible("org.jfree.report.function.ShowElementIfDataAvailableExpression");
163: generateAndAddClassIfPossible("org.jfree.report.function.TextFormatExpression");
164: generateAndAddClassIfPossible("org.jfree.report.function.TotalCalculationFunction");
165: generateAndAddClassIfPossible("org.jfree.report.function.TotalGroupCountFunction");
166: generateAndAddClassIfPossible("org.jfree.report.function.TotalGroupSumFunction");
167: generateAndAddClassIfPossible("org.jfree.report.function.TotalGroupSumQuotientFunction");
168: generateAndAddClassIfPossible("org.jfree.report.function.TotalGroupSumQuotientPercentFunction");
169: generateAndAddClassIfPossible("org.jfree.report.function.TotalItemCountFunction");
170: generateAndAddClassIfPossible("org.jfree.report.function.TriggerPageFooterFunction");
171: generateAndAddClassIfPossible("org.jfree.report.function.bool.AndExpression");
172: generateAndAddClassIfPossible("org.jfree.report.function.bool.IsEmptyDataExpression");
173: generateAndAddClassIfPossible("org.jfree.report.function.bool.OrExpression");
174: generateAndAddClassIfPossible("org.jfree.report.function.date.CompareDateExpression");
175: generateAndAddClassIfPossible("org.jfree.report.function.date.DateExpression");
176: generateAndAddClassIfPossible("org.jfree.report.function.date.DateSpanExpression");
177: generateAndAddClassIfPossible("org.jfree.report.function.date.VariableDateExpression");
178: generateAndAddClassIfPossible("org.jfree.report.function.numeric.CompareNumberExpression");
179: generateAndAddClassIfPossible("org.jfree.report.function.numeric.IsNegativeExpression");
180: generateAndAddClassIfPossible("org.jfree.report.function.numeric.IsPositiveExpression");
181: generateAndAddClassIfPossible("org.jfree.report.function.strings.CapitalizeStringExpression");
182: generateAndAddClassIfPossible("org.jfree.report.function.strings.CompareStringExpression");
183: generateAndAddClassIfPossible("org.jfree.report.function.strings.MapIndirectExpression");
184: generateAndAddClassIfPossible("org.jfree.report.function.strings.MapStringExpression");
185: generateAndAddClassIfPossible("org.jfree.report.function.strings.ResourceBundleLookupExpression");
186: generateAndAddClassIfPossible("org.jfree.report.function.strings.ResourceMesssageFormatExpression");
187: generateAndAddClassIfPossible("org.jfree.report.function.strings.SubStringExpression");
188: generateAndAddClassIfPossible("org.jfree.report.function.strings.ToLowerCaseStringExpression");
189: generateAndAddClassIfPossible("org.jfree.report.function.strings.ToUpperCaseStringExpression");
190: generateAndAddClassIfPossible("org.jfree.report.function.strings.TokenizeStringExpression");
191: generateAndAddClassIfPossible("org.jfree.report.function.strings.URLEncodeExpression");
192: generateAndAddClassIfPossible("org.jfree.report.function.sys.IsExportTypeExpression");
193: generateAndAddClassIfPossible("org.jfree.report.modules.misc.beanshell.BSHExpression");
194: //generateAndAddClassIfPossible("org.jfree.report.modules.misc.bsf.BSFExpression");
195: generateAndAddClassIfPossible("org.jfree.report.modules.misc.survey.SurveyScaleExpression");
196:
197: generateAndAddClassIfPossible("org.pentaho.plugin.jfreereport.reportcharts.AreaChartExpression");
198: generateAndAddClassIfPossible("org.pentaho.plugin.jfreereport.reportcharts.BarChartExpression");
199: generateAndAddClassIfPossible("org.pentaho.plugin.jfreereport.reportcharts.BarLineChartExpression");
200: generateAndAddClassIfPossible("org.pentaho.plugin.jfreereport.reportcharts.BubbleChartExpression");
201: generateAndAddClassIfPossible("org.pentaho.plugin.jfreereport.reportcharts.ExtendedXYLineChartExpression");
202: generateAndAddClassIfPossible("org.pentaho.plugin.jfreereport.reportcharts.LineChartExpression");
203: generateAndAddClassIfPossible("org.pentaho.plugin.jfreereport.reportcharts.MultiPieChartExpression");
204: generateAndAddClassIfPossible("org.pentaho.plugin.jfreereport.reportcharts.PieChartExpression");
205: generateAndAddClassIfPossible("org.pentaho.plugin.jfreereport.reportcharts.RingChartExpression");
206: generateAndAddClassIfPossible("org.pentaho.plugin.jfreereport.reportcharts.ScatterPlotChartExpression");
207: generateAndAddClassIfPossible("org.pentaho.plugin.jfreereport.reportcharts.WaterfallChartExpressions");
208: generateAndAddClassIfPossible("org.pentaho.plugin.jfreereport.reportcharts.XYAreaChartExpression");
209: generateAndAddClassIfPossible("org.pentaho.plugin.jfreereport.reportcharts.XYBarChartExpression");
210: generateAndAddClassIfPossible("org.pentaho.plugin.jfreereport.reportcharts.XYLineChartExpression");
211:
212: generateAndAddClassIfPossible("org.pentaho.plugin.jfreereport.reportcharts.PieSetCollectorFunction");
213: generateAndAddClassIfPossible("org.pentaho.plugin.jfreereport.reportcharts.CategorySetCollectorFunction");
214: generateAndAddClassIfPossible("org.pentaho.plugin.jfreereport.reportcharts.XYSeriesCollectorFunction");
215: generateAndAddClassIfPossible("org.pentaho.plugin.jfreereport.reportcharts.XYZSeriesCollectorFunction");
216: generateAndAddClassIfPossible("org.pentaho.plugin.jfreereport.reportcharts.TimeSeriesCollectorFunction");
217:
218: generateAndAddClassIfPossible("org.jfree.report.function.FormulaExpression");
219: generateAndAddClassIfPossible("org.jfree.report.function.FormulaFunction");
220:
221: List<String> functionList = readFunctions();
222: for (String function : functionList) {
223: generateAndAddClassIfPossible(function.trim());
224: }
225:
226: wrapperToJFreeReportExpressionClassesMap = new HashMap<Class<?>, Class<?>>();
227: for (Class<?> jFreeClass : jFreeReportExpressionToWrapperClassesMap
228: .keySet()) {
229: @Nullable
230: Class<?> wrapperClass = jFreeReportExpressionToWrapperClassesMap
231: .get(jFreeClass);
232: wrapperToJFreeReportExpressionClassesMap.put(wrapperClass,
233: jFreeClass);
234: }
235: }
236:
237: @NotNull
238: private List<String> readFunctions() {
239: List<String> functionList = new LinkedList<String>();
240:
241: FileInputStream fis = null;
242: try {
243: //noinspection IOResourceOpenedButNotSafelyClosed
244: fis = new FileInputStream(FUNCTIONS_FILENAME);
245: StringBuilder sb = new StringBuilder(1000);
246: byte[] bytes = new byte[1024];
247: int numRead;
248: while ((numRead = fis.read(bytes)) != -1) {
249: sb.append(new String(bytes, 0, numRead));
250: }
251:
252: StringTokenizer st = new StringTokenizer(sb.toString(),
253: ", ");
254: while (st.hasMoreTokens()) {
255: String function = st.nextToken();
256: functionList.add(function);
257: }
258: } catch (Exception e) {
259: if (LOG.isLoggable(Level.FINE))
260: LOG.log(Level.FINE,
261: "ExpressionRegistry.readFunctions ", e);
262: } finally {
263: IOUtil.closeStream(fis);
264: }
265:
266: return functionList;
267: }
268:
269: private void generateAndAddClassIfPossible(@NotNull
270: String jFreeReportClassName) {
271: try {
272: Class<?> jFreeReportClass = Class
273: .forName(jFreeReportClassName);
274: if (!Expression.class.isAssignableFrom(jFreeReportClass)) {
275: return;
276: }
277: if (Modifier.isAbstract(jFreeReportClass.getModifiers())) {
278: return;
279: }
280: if (!Modifier.isPublic(jFreeReportClass.getModifiers())) {
281: return;
282: }
283:
284: BeanInfo beanInfo = Introspector
285: .getBeanInfo(jFreeReportClass);
286: PropertyDescriptor[] propertyDescriptors = beanInfo
287: .getPropertyDescriptors();
288:
289: //sort alphabetically, the file name (from superclass) will be the first.
290: Arrays.sort(propertyDescriptors,
291: new Comparator<PropertyDescriptor>() {
292: public int compare(@NotNull
293: PropertyDescriptor o1, @NotNull
294: PropertyDescriptor o2) {
295: return o1.getName().compareTo(o2.getName());
296: }
297: });
298:
299: FunctionGenerator functionGenerator = new FunctionGenerator(
300: FunctionGenerator.PACKAGE_PREFIX
301: + jFreeReportClassName + "_DesignerWrapper");//NON-NLS
302: for (PropertyDescriptor propertyDescriptor : propertyDescriptors) {
303: if (propertyDescriptor.getReadMethod() != null
304: && propertyDescriptor.getWriteMethod() != null
305: && !exludedExpressionProperties
306: .contains(propertyDescriptor.getName())) {
307: functionGenerator.addProperty(createProperty(
308: jFreeReportClassName, propertyDescriptor));
309: }
310: }
311: Class<ReportFunctionElement> wrapperClass = FunctionGenerator
312: .defineClass(functionGenerator);
313: jFreeReportExpressionToWrapperClassesMap.put(
314: jFreeReportClass, wrapperClass);
315:
316: simpleNameToWrapperClassesMap.put(jFreeReportClass
317: .getSimpleName(), wrapperClass);
318: } catch (Throwable e) {
319: if (LOG.isLoggable(Level.FINE))
320: LOG.log(Level.FINE,
321: "ExpressionRegistry.generateAndAddClassIfPossible jFreeReportClassName = "
322: + jFreeReportClassName + " is missing");
323: if (LOG.isLoggable(Level.FINE))
324: LOG
325: .log(
326: Level.FINE,
327: "ExpressionRegistry.generateAndAddClassIfPossible ",
328: e);
329: }
330: }
331:
332: @NotNull
333: public HashMap<Class<?>, Class<?>> getJFreeReportExpressionToWrapperClassesMap() {
334: return jFreeReportExpressionToWrapperClassesMap;
335: }
336:
337: @NotNull
338: public String getTreePath(@NotNull
339: Class<?> jFreeClass) {
340: String path = jFreeReportExpressionToTreePathMap.get(jFreeClass
341: .getName());
342: if (path != null) {
343: return path;
344: } else {
345: return "";
346: }
347: }
348:
349: @NotNull
350: public HashMap<Class<?>, Class<?>> getWrapperToJFreeReportExpressionClassesMap() {
351: return wrapperToJFreeReportExpressionClassesMap;
352: }
353:
354: @Nullable
355: public ReportFunctionElement createWrapperInstance(@NotNull
356: String className) {
357: try {
358: Class<?> wrapperClass = Class.forName(className);
359: @Nullable
360: Class<?> jFreeClass = wrapperToJFreeReportExpressionClassesMap
361: .get(wrapperClass);
362:
363: ReportFunctionElement wrapperInstance = (ReportFunctionElement) wrapperClass
364: .newInstance();
365: if (jFreeClass == null) {
366: return null;
367: }
368: Expression jFreeExpression = (Expression) jFreeClass
369: .newInstance();
370:
371: fillWrapper(wrapperInstance, jFreeExpression);
372:
373: return wrapperInstance;
374: } catch (Throwable e) {
375: if (LOG.isLoggable(Level.FINE))
376: LOG.log(Level.FINE,
377: "ExpressionRegistry.createWrapperInstance ", e);
378: return null;
379: }
380: }
381:
382: @NotNull
383: public ReportFunctionElement createWrapperInstance(@NotNull
384: Expression jFreeExpression) {
385:
386: Class<?> jFreeClass = jFreeExpression.getClass();
387: @Nullable
388: Class<?> wrapperClass = jFreeReportExpressionToWrapperClassesMap
389: .get(jFreeClass);
390:
391: if (wrapperClass == null) {
392: wrapperClass = getWrapperClassForOldFunction(jFreeClass
393: .getSimpleName());
394:
395: if (wrapperClass == null) {
396: throw new RuntimeException(
397: "Could not create expression instance for class "
398: + jFreeExpression.getClass().getName());
399: }
400: }
401: try {
402: ReportFunctionElement wrapperInstance = (ReportFunctionElement) wrapperClass
403: .newInstance();
404:
405: fillWrapper(wrapperInstance, jFreeExpression);
406:
407: return wrapperInstance;
408: } catch (Exception e) {
409: throw new RuntimeException(
410: "Could not create expression instance for class "
411: + jFreeExpression.getClass().getName(), e);
412: }
413: }
414:
415: public void fillWrapper(@NotNull
416: ReportFunctionElement wrapperInstance, @NotNull
417: Expression jFreeExpression) throws IntrospectionException,
418: IllegalAccessException, InvocationTargetException {
419: //copy values from jFreeExpression to wrapper (to not loose initialisations)
420: BeanInfo beanInfo = Introspector.getBeanInfo(jFreeExpression
421: .getClass());
422: PropertyDescriptor[] propertyDescriptors = beanInfo
423: .getPropertyDescriptors();
424: for (PropertyDescriptor propertyDescriptor : propertyDescriptors) {
425: if (propertyDescriptor.getReadMethod() != null
426: && propertyDescriptor.getWriteMethod() != null
427: && !"active".equals(propertyDescriptor.getName()))//NON-NLS
428: {
429: try {
430: Method method = wrapperInstance.getClass()
431: .getMethod(
432: propertyDescriptor.getWriteMethod()
433: .getName(),
434: propertyDescriptor.getWriteMethod()
435: .getParameterTypes()[0]);
436: Object args = propertyDescriptor.getReadMethod()
437: .invoke(jFreeExpression);
438: method.invoke(wrapperInstance, args);
439: } catch (NoSuchMethodException e) {
440: if (LOG.isLoggable(Level.FINE))
441: LOG
442: .log(
443: Level.FINE,
444: "ExpressionCreator.createReportFunctionElement ",
445: e);
446: //shit happens
447: }
448: }
449: }
450: }
451:
452: @NotNull
453: public Expression createJFreeReportExpressionInstance(@NotNull
454: ReportFunctionElement reportFunctionElement)
455: throws ReportCreationException {
456: try {
457: @Nullable
458: Class<?> freeClass = wrapperToJFreeReportExpressionClassesMap
459: .get(reportFunctionElement.getClass());
460:
461: if (freeClass != null) {
462: Expression obj = (Expression) freeClass.newInstance();
463: BeanInfo beanInfo = Introspector
464: .getBeanInfo(reportFunctionElement.getClass());
465: PropertyDescriptor[] propertyDescriptors = beanInfo
466: .getPropertyDescriptors();
467: for (PropertyDescriptor propertyDescriptor : propertyDescriptors) {
468: if (propertyDescriptor.getReadMethod() != null
469: && propertyDescriptor.getWriteMethod() != null) {
470: Class<?> parameterTypes = propertyDescriptor
471: .getWriteMethod().getParameterTypes()[0];
472: Method method = obj.getClass().getMethod(
473: propertyDescriptor.getWriteMethod()
474: .getName(), parameterTypes);
475: method.invoke(obj, propertyDescriptor
476: .getReadMethod().invoke(
477: reportFunctionElement));
478: }
479: }
480:
481: return obj;
482: }
483: } catch (Exception e) {
484: throw new ReportCreationException(
485: "Could not create expression",
486: reportFunctionElement, e);
487: }
488: throw new ReportCreationException(
489: "Could not create expression freeClass not found",
490: reportFunctionElement);
491: }
492:
493: @NotNull
494: public String getLocalizedExpressionName(@NotNull
495: Class<?> clazz) {
496: String key1 = "Expressions." + clazz.getSimpleName() + ".Name";//NON-NLS
497: String functionName1 = TranslationManager.getInstance()
498: .getTranslation("R", key1);
499: if (key1.equals(functionName1)) {
500: functionName1 = clazz.getSimpleName();
501: }
502: return functionName1;
503: }
504:
505: @NotNull
506: public String getLocalizedDescription(@NotNull
507: Class<?> clazz) {
508: String key1 = "Expressions." + clazz.getSimpleName()
509: + ".Description";//NON-NLS
510: String functionName1 = TranslationManager.getInstance()
511: .getTranslation("R", key1);
512: if (key1.equals(functionName1)) {
513: return "";
514: }
515: return functionName1;
516: }
517:
518: @Nullable
519: public Class<?> getWrapperClassForOldFunction(@NotNull
520: String simpleClassName) {
521: return simpleNameToWrapperClassesMap.get(simpleClassName);
522: }
523:
524: @NotNull
525: private Property createProperty(@NotNull
526: String jFreeReportClassName, @NotNull
527: PropertyDescriptor propertyDescriptor) {
528: PropertyInfo propertyInfo = propertyInfos
529: .get(jFreeReportClassName + "."
530: + propertyDescriptor.getName());
531: if (propertyInfo != null) {
532: return new Property(propertyDescriptor.getPropertyType(),
533: propertyDescriptor.getName(), propertyInfo
534: .getGroup(), propertyInfo.getSortingID());
535: }
536: //prints the name of the properties. useful when adding new functions.
537: //System.out.println("propertyInfos.put(\""+jFreeReportClassName+"."+propertyDescriptor.getName()+"\", new PropertyInfo(PropertyKeys.GROUP_OPTIONAL, -1));//NON-NLS");
538:
539: return new Property(propertyDescriptor.getPropertyType(),
540: propertyDescriptor.getName(),
541: PropertyKeys.GROUP_UNKNOWN, -1);
542: }
543: }
|