1:
98:
99: package ;
100:
101: import ;
102: import ;
103: import ;
104: import ;
105: import ;
106: import ;
107: import ;
108: import ;
109: import ;
110: import ;
111: import ;
112: import ;
113:
114: import ;
115: import ;
116: import ;
117: import ;
118: import ;
119: import ;
120: import ;
121: import ;
122: import ;
123: import ;
124: import ;
125: import ;
126: import ;
127: import ;
128: import ;
129: import ;
130: import ;
131: import ;
132: import ;
133: import ;
134: import ;
135: import ;
136: import ;
137: import ;
138: import ;
139: import ;
140: import ;
141: import ;
142: import ;
143: import ;
144: import ;
145: import ;
146: import ;
147:
148:
154: public abstract class AbstractCategoryItemRenderer extends AbstractRenderer
155: implements CategoryItemRenderer, Cloneable, PublicCloneable, Serializable {
156:
157:
158: private static final long serialVersionUID = 1247553218442497391L;
159:
160:
161: private CategoryPlot plot;
162:
163:
168: private CategoryItemLabelGenerator itemLabelGenerator;
169:
170:
171: private ObjectList itemLabelGeneratorList;
172:
173:
174: private CategoryItemLabelGenerator baseItemLabelGenerator;
175:
176:
181: private CategoryToolTipGenerator toolTipGenerator;
182:
183:
184: private ObjectList toolTipGeneratorList;
185:
186:
187: private CategoryToolTipGenerator baseToolTipGenerator;
188:
189:
194: private CategoryURLGenerator itemURLGenerator;
195:
196:
197: private ObjectList itemURLGeneratorList;
198:
199:
200: private CategoryURLGenerator baseItemURLGenerator;
201:
202:
203: private CategorySeriesLabelGenerator legendItemLabelGenerator;
204:
205:
206: private CategorySeriesLabelGenerator legendItemToolTipGenerator;
207:
208:
209: private CategorySeriesLabelGenerator legendItemURLGenerator;
210:
211:
212: private transient int rowCount;
213:
214:
215: private transient int columnCount;
216:
217:
224: protected AbstractCategoryItemRenderer() {
225: this.itemLabelGenerator = null;
226: this.itemLabelGeneratorList = new ObjectList();
227: this.toolTipGenerator = null;
228: this.toolTipGeneratorList = new ObjectList();
229: this.itemURLGenerator = null;
230: this.itemURLGeneratorList = new ObjectList();
231: this.legendItemLabelGenerator
232: = new StandardCategorySeriesLabelGenerator();
233: }
234:
235:
242: public int getPassCount() {
243: return 1;
244: }
245:
246:
255: public CategoryPlot getPlot() {
256: return this.plot;
257: }
258:
259:
268: public void setPlot(CategoryPlot plot) {
269: if (plot == null) {
270: throw new IllegalArgumentException("Null 'plot' argument.");
271: }
272: this.plot = plot;
273: }
274:
275:
276:
277:
288: public CategoryItemLabelGenerator getItemLabelGenerator(int row,
289: int column) {
290: return getSeriesItemLabelGenerator(row);
291: }
292:
293:
302: public CategoryItemLabelGenerator getSeriesItemLabelGenerator(int series) {
303:
304:
305: if (this.itemLabelGenerator != null) {
306: return this.itemLabelGenerator;
307: }
308:
309:
310: CategoryItemLabelGenerator generator = (CategoryItemLabelGenerator)
311: this.itemLabelGeneratorList.get(series);
312: if (generator == null) {
313: generator = this.baseItemLabelGenerator;
314: }
315: return generator;
316:
317: }
318:
319:
330: public void setItemLabelGenerator(CategoryItemLabelGenerator generator) {
331: this.itemLabelGenerator = generator;
332: fireChangeEvent();
333: }
334:
335:
344: public void setSeriesItemLabelGenerator(int series,
345: CategoryItemLabelGenerator generator) {
346: this.itemLabelGeneratorList.set(series, generator);
347: fireChangeEvent();
348: }
349:
350:
357: public CategoryItemLabelGenerator getBaseItemLabelGenerator() {
358: return this.baseItemLabelGenerator;
359: }
360:
361:
369: public void setBaseItemLabelGenerator(
370: CategoryItemLabelGenerator generator) {
371: this.baseItemLabelGenerator = generator;
372: fireChangeEvent();
373: }
374:
375:
376:
377:
389: public CategoryToolTipGenerator getToolTipGenerator(int row, int column) {
390:
391: CategoryToolTipGenerator result = null;
392: if (this.toolTipGenerator != null) {
393: result = this.toolTipGenerator;
394: }
395: else {
396: result = getSeriesToolTipGenerator(row);
397: if (result == null) {
398: result = this.baseToolTipGenerator;
399: }
400: }
401: return result;
402: }
403:
404:
416: public CategoryToolTipGenerator getToolTipGenerator() {
417: return this.toolTipGenerator;
418: }
419:
420:
434: public void setToolTipGenerator(CategoryToolTipGenerator generator) {
435: this.toolTipGenerator = generator;
436: fireChangeEvent();
437: }
438:
439:
449: public CategoryToolTipGenerator getSeriesToolTipGenerator(int series) {
450: return (CategoryToolTipGenerator) this.toolTipGeneratorList.get(series);
451: }
452:
453:
462: public void setSeriesToolTipGenerator(int series,
463: CategoryToolTipGenerator generator) {
464: this.toolTipGeneratorList.set(series, generator);
465: fireChangeEvent();
466: }
467:
468:
475: public CategoryToolTipGenerator getBaseToolTipGenerator() {
476: return this.baseToolTipGenerator;
477: }
478:
479:
487: public void setBaseToolTipGenerator(CategoryToolTipGenerator generator) {
488: this.baseToolTipGenerator = generator;
489: fireChangeEvent();
490: }
491:
492:
493:
494:
504: public CategoryURLGenerator getItemURLGenerator(int row, int column) {
505: return getSeriesItemURLGenerator(row);
506: }
507:
508:
517: public CategoryURLGenerator getSeriesItemURLGenerator(int series) {
518:
519:
520: if (this.itemURLGenerator != null) {
521: return this.itemURLGenerator;
522: }
523:
524:
525: CategoryURLGenerator generator
526: = (CategoryURLGenerator) this.itemURLGeneratorList.get(series);
527: if (generator == null) {
528: generator = this.baseItemURLGenerator;
529: }
530: return generator;
531:
532: }
533:
534:
545: public void setItemURLGenerator(CategoryURLGenerator generator) {
546: this.itemURLGenerator = generator;
547: fireChangeEvent();
548: }
549:
550:
559: public void setSeriesItemURLGenerator(int series,
560: CategoryURLGenerator generator) {
561: this.itemURLGeneratorList.set(series, generator);
562: fireChangeEvent();
563: }
564:
565:
572: public CategoryURLGenerator getBaseItemURLGenerator() {
573: return this.baseItemURLGenerator;
574: }
575:
576:
584: public void setBaseItemURLGenerator(CategoryURLGenerator generator) {
585: this.baseItemURLGenerator = generator;
586: fireChangeEvent();
587: }
588:
589:
595: public int getRowCount() {
596: return this.rowCount;
597: }
598:
599:
605: public int getColumnCount() {
606: return this.columnCount;
607: }
608:
609:
621: protected CategoryItemRendererState createState(PlotRenderingInfo info) {
622: return new CategoryItemRendererState(info);
623: }
624:
625:
640: public CategoryItemRendererState initialise(Graphics2D g2,
641: Rectangle2D dataArea,
642: CategoryPlot plot,
643: int rendererIndex,
644: PlotRenderingInfo info) {
645:
646: setPlot(plot);
647: CategoryDataset data = plot.getDataset(rendererIndex);
648: if (data != null) {
649: this.rowCount = data.getRowCount();
650: this.columnCount = data.getColumnCount();
651: }
652: else {
653: this.rowCount = 0;
654: this.columnCount = 0;
655: }
656: return createState(info);
657:
658: }
659:
660:
669: public Range findRangeBounds(CategoryDataset dataset) {
670: return DatasetUtilities.findRangeBounds(dataset);
671: }
672:
673:
682: public void drawBackground(Graphics2D g2,
683: CategoryPlot plot,
684: Rectangle2D dataArea) {
685:
686: plot.drawBackground(g2, dataArea);
687:
688: }
689:
690:
699: public void drawOutline(Graphics2D g2,
700: CategoryPlot plot,
701: Rectangle2D dataArea) {
702:
703: plot.drawOutline(g2, dataArea);
704:
705: }
706:
707:
723: public void drawDomainGridline(Graphics2D g2,
724: CategoryPlot plot,
725: Rectangle2D dataArea,
726: double value) {
727:
728: Line2D line = null;
729: PlotOrientation orientation = plot.getOrientation();
730:
731: if (orientation == PlotOrientation.HORIZONTAL) {
732: line = new Line2D.Double(dataArea.getMinX(), value,
733: dataArea.getMaxX(), value);
734: }
735: else if (orientation == PlotOrientation.VERTICAL) {
736: line = new Line2D.Double(value, dataArea.getMinY(), value,
737: dataArea.getMaxY());
738: }
739:
740: Paint paint = plot.getDomainGridlinePaint();
741: if (paint == null) {
742: paint = CategoryPlot.DEFAULT_GRIDLINE_PAINT;
743: }
744: g2.setPaint(paint);
745:
746: Stroke stroke = plot.getDomainGridlineStroke();
747: if (stroke == null) {
748: stroke = CategoryPlot.DEFAULT_GRIDLINE_STROKE;
749: }
750: g2.setStroke(stroke);
751:
752: g2.draw(line);
753:
754: }
755:
756:
769: public void drawRangeGridline(Graphics2D g2,
770: CategoryPlot plot,
771: ValueAxis axis,
772: Rectangle2D dataArea,
773: double value) {
774:
775: Range range = axis.getRange();
776: if (!range.contains(value)) {
777: return;
778: }
779:
780: PlotOrientation orientation = plot.getOrientation();
781: double v = axis.valueToJava2D(value, dataArea, plot.getRangeAxisEdge());
782: Line2D line = null;
783: if (orientation == PlotOrientation.HORIZONTAL) {
784: line = new Line2D.Double(v, dataArea.getMinY(), v,
785: dataArea.getMaxY());
786: }
787: else if (orientation == PlotOrientation.VERTICAL) {
788: line = new Line2D.Double(dataArea.getMinX(), v,
789: dataArea.getMaxX(), v);
790: }
791:
792: Paint paint = plot.getRangeGridlinePaint();
793: if (paint == null) {
794: paint = CategoryPlot.DEFAULT_GRIDLINE_PAINT;
795: }
796: g2.setPaint(paint);
797:
798: Stroke stroke = plot.getRangeGridlineStroke();
799: if (stroke == null) {
800: stroke = CategoryPlot.DEFAULT_GRIDLINE_STROKE;
801: }
802: g2.setStroke(stroke);
803:
804: g2.draw(line);
805:
806: }
807:
808:
820: public void drawDomainMarker(Graphics2D g2,
821: CategoryPlot plot,
822: CategoryAxis axis,
823: CategoryMarker marker,
824: Rectangle2D dataArea) {
825:
826: Comparable category = marker.getKey();
827: CategoryDataset dataset = plot.getDataset(plot.getIndexOf(this));
828: int columnIndex = dataset.getColumnIndex(category);
829: if (columnIndex < 0) {
830: return;
831: }
832:
833: final Composite savedComposite = g2.getComposite();
834: g2.setComposite(AlphaComposite.getInstance(
835: AlphaComposite.SRC_OVER, marker.getAlpha()));
836:
837: PlotOrientation orientation = plot.getOrientation();
838: Rectangle2D bounds = null;
839: if (marker.getDrawAsLine()) {
840: double v = axis.getCategoryMiddle(columnIndex,
841: dataset.getColumnCount(), dataArea,
842: plot.getDomainAxisEdge());
843: Line2D line = null;
844: if (orientation == PlotOrientation.HORIZONTAL) {
845: line = new Line2D.Double(dataArea.getMinX(), v,
846: dataArea.getMaxX(), v);
847: }
848: else if (orientation == PlotOrientation.VERTICAL) {
849: line = new Line2D.Double(v, dataArea.getMinY(), v,
850: dataArea.getMaxY());
851: }
852: g2.setPaint(marker.getPaint());
853: g2.setStroke(marker.getStroke());
854: g2.draw(line);
855: bounds = line.getBounds2D();
856: }
857: else {
858: double v0 = axis.getCategoryStart(columnIndex,
859: dataset.getColumnCount(), dataArea,
860: plot.getDomainAxisEdge());
861: double v1 = axis.getCategoryEnd(columnIndex,
862: dataset.getColumnCount(), dataArea,
863: plot.getDomainAxisEdge());
864: Rectangle2D area = null;
865: if (orientation == PlotOrientation.HORIZONTAL) {
866: area = new Rectangle2D.Double(dataArea.getMinX(), v0,
867: dataArea.getWidth(), (v1 - v0));
868: }
869: else if (orientation == PlotOrientation.VERTICAL) {
870: area = new Rectangle2D.Double(v0, dataArea.getMinY(),
871: (v1 - v0), dataArea.getHeight());
872: }
873: g2.setPaint(marker.getPaint());
874: g2.fill(area);
875: bounds = area;
876: }
877:
878: String label = marker.getLabel();
879: RectangleAnchor anchor = marker.getLabelAnchor();
880: if (label != null) {
881: Font labelFont = marker.getLabelFont();
882: g2.setFont(labelFont);
883: g2.setPaint(marker.getLabelPaint());
884: Point2D coordinates = calculateDomainMarkerTextAnchorPoint(
885: g2, orientation, dataArea, bounds, marker.getLabelOffset(),
886: marker.getLabelOffsetType(), anchor);
887: TextUtilities.drawAlignedString(label, g2,
888: (float) coordinates.getX(), (float) coordinates.getY(),
889: marker.getLabelTextAnchor());
890: }
891: g2.setComposite(savedComposite);
892: }
893:
894:
906: public void drawRangeMarker(Graphics2D g2,
907: CategoryPlot plot,
908: ValueAxis axis,
909: Marker marker,
910: Rectangle2D dataArea) {
911:
912: if (marker instanceof ValueMarker) {
913: ValueMarker vm = (ValueMarker) marker;
914: double value = vm.getValue();
915: Range range = axis.getRange();
916:
917: if (!range.contains(value)) {
918: return;
919: }
920:
921: final Composite savedComposite = g2.getComposite();
922: g2.setComposite(AlphaComposite.getInstance(
923: AlphaComposite.SRC_OVER, marker.getAlpha()));
924:
925: PlotOrientation orientation = plot.getOrientation();
926: double v = axis.valueToJava2D(value, dataArea,
927: plot.getRangeAxisEdge());
928: Line2D line = null;
929: if (orientation == PlotOrientation.HORIZONTAL) {
930: line = new Line2D.Double(v, dataArea.getMinY(), v,
931: dataArea.getMaxY());
932: }
933: else if (orientation == PlotOrientation.VERTICAL) {
934: line = new Line2D.Double(dataArea.getMinX(), v,
935: dataArea.getMaxX(), v);
936: }
937:
938: g2.setPaint(marker.getPaint());
939: g2.setStroke(marker.getStroke());
940: g2.draw(line);
941:
942: String label = marker.getLabel();
943: RectangleAnchor anchor = marker.getLabelAnchor();
944: if (label != null) {
945: Font labelFont = marker.getLabelFont();
946: g2.setFont(labelFont);
947: g2.setPaint(marker.getLabelPaint());
948: Point2D coordinates = calculateRangeMarkerTextAnchorPoint(
949: g2, orientation, dataArea, line.getBounds2D(),
950: marker.getLabelOffset(), LengthAdjustmentType.EXPAND,
951: anchor);
952: TextUtilities.drawAlignedString(label, g2,
953: (float) coordinates.getX(), (float) coordinates.getY(),
954: marker.getLabelTextAnchor());
955: }
956: g2.setComposite(savedComposite);
957: }
958: else if (marker instanceof IntervalMarker) {
959: IntervalMarker im = (IntervalMarker) marker;
960: double start = im.getStartValue();
961: double end = im.getEndValue();
962: Range range = axis.getRange();
963: if (!(range.intersects(start, end))) {
964: return;
965: }
966:
967: final Composite savedComposite = g2.getComposite();
968: g2.setComposite(AlphaComposite.getInstance(
969: AlphaComposite.SRC_OVER, marker.getAlpha()));
970:
971: double start2d = axis.valueToJava2D(start, dataArea,
972: plot.getRangeAxisEdge());
973: double end2d = axis.valueToJava2D(end, dataArea,
974: plot.getRangeAxisEdge());
975: double low = Math.min(start2d, end2d);
976: double high = Math.max(start2d, end2d);
977:
978: PlotOrientation orientation = plot.getOrientation();
979: Rectangle2D rect = null;
980: if (orientation == PlotOrientation.HORIZONTAL) {
981:
982: low = Math.max(low, dataArea.getMinX());
983: high = Math.min(high, dataArea.getMaxX());
984: rect = new Rectangle2D.Double(low,
985: dataArea.getMinY(), high - low,
986: dataArea.getHeight());
987: }
988: else if (orientation == PlotOrientation.VERTICAL) {
989:
990: low = Math.max(low, dataArea.getMinY());
991: high = Math.min(high, dataArea.getMaxY());
992: rect = new Rectangle2D.Double(dataArea.getMinX(),
993: low, dataArea.getWidth(),
994: high - low);
995: }
996: Paint p = marker.getPaint();
997: if (p instanceof GradientPaint) {
998: GradientPaint gp = (GradientPaint) p;
999: GradientPaintTransformer t = im.getGradientPaintTransformer();
1000: if (t != null) {
1001: gp = t.transform(gp, rect);
1002: }
1003: g2.setPaint(gp);
1004: }
1005: else {
1006: g2.setPaint(p);
1007: }
1008: g2.fill(rect);
1009:
1010:
1011: if (im.getOutlinePaint() != null && im.getOutlineStroke() != null) {
1012: if (orientation == PlotOrientation.VERTICAL) {
1013: Line2D line = new Line2D.Double();
1014: double x0 = dataArea.getMinX();
1015: double x1 = dataArea.getMaxX();
1016: g2.setPaint(im.getOutlinePaint());
1017: g2.setStroke(im.getOutlineStroke());
1018: if (range.contains(start)) {
1019: line.setLine(x0, start2d, x1, start2d);
1020: g2.draw(line);
1021: }
1022: if (range.contains(end)) {
1023: line.setLine(x0, end2d, x1, end2d);
1024: g2.draw(line);
1025: }
1026: }
1027: else {
1028: Line2D line = new Line2D.Double();
1029: double y0 = dataArea.getMinY();
1030: double y1 = dataArea.getMaxY();
1031: g2.setPaint(im.getOutlinePaint());
1032: g2.setStroke(im.getOutlineStroke());
1033: if (range.contains(start)) {
1034: line.setLine(start2d, y0, start2d, y1);
1035: g2.draw(line);
1036: }
1037: if (range.contains(end)) {
1038: line.setLine(end2d, y0, end2d, y1);
1039: g2.draw(line);
1040: }
1041: }
1042: }
1043:
1044: String label = marker.getLabel();
1045: RectangleAnchor anchor = marker.getLabelAnchor();
1046: if (label != null) {
1047: Font labelFont = marker.getLabelFont();
1048: g2.setFont(labelFont);
1049: g2.setPaint(marker.getLabelPaint());
1050: Point2D coordinates = calculateRangeMarkerTextAnchorPoint(
1051: g2, orientation, dataArea, rect,
1052: marker.getLabelOffset(), marker.getLabelOffsetType(),
1053: anchor);
1054: TextUtilities.drawAlignedString(label, g2,
1055: (float) coordinates.getX(), (float) coordinates.getY(),
1056: marker.getLabelTextAnchor());
1057: }
1058: g2.setComposite(savedComposite);
1059: }
1060: }
1061:
1062:
1076: protected Point2D calculateDomainMarkerTextAnchorPoint(Graphics2D g2,
1077: PlotOrientation orientation,
1078: Rectangle2D dataArea,
1079: Rectangle2D markerArea,
1080: RectangleInsets markerOffset,
1081: LengthAdjustmentType labelOffsetType,
1082: RectangleAnchor anchor) {
1083:
1084: Rectangle2D anchorRect = null;
1085: if (orientation == PlotOrientation.HORIZONTAL) {
1086: anchorRect = markerOffset.createAdjustedRectangle(markerArea,
1087: LengthAdjustmentType.CONTRACT, labelOffsetType);
1088: }
1089: else if (orientation == PlotOrientation.VERTICAL) {
1090: anchorRect = markerOffset.createAdjustedRectangle(markerArea,
1091: labelOffsetType, LengthAdjustmentType.CONTRACT);
1092: }
1093: return RectangleAnchor.coordinates(anchorRect, anchor);
1094:
1095: }
1096:
1097:
1110: protected Point2D calculateRangeMarkerTextAnchorPoint(Graphics2D g2,
1111: PlotOrientation orientation,
1112: Rectangle2D dataArea,
1113: Rectangle2D markerArea,
1114: RectangleInsets markerOffset,
1115: LengthAdjustmentType labelOffsetType,
1116: RectangleAnchor anchor) {
1117:
1118: Rectangle2D anchorRect = null;
1119: if (orientation == PlotOrientation.HORIZONTAL) {
1120: anchorRect = markerOffset.createAdjustedRectangle(markerArea,
1121: labelOffsetType, LengthAdjustmentType.CONTRACT);
1122: }
1123: else if (orientation == PlotOrientation.VERTICAL) {
1124: anchorRect = markerOffset.createAdjustedRectangle(markerArea,
1125: LengthAdjustmentType.CONTRACT, labelOffsetType);
1126: }
1127: return RectangleAnchor.coordinates(anchorRect, anchor);
1128:
1129: }
1130:
1131:
1143: public LegendItem getLegendItem(int datasetIndex, int series) {
1144:
1145: CategoryPlot p = getPlot();
1146: if (p == null) {
1147: return null;
1148: }
1149:
1150:
1151: if (!isSeriesVisible(series) || !isSeriesVisibleInLegend(series)) {
1152: return null;
1153: }
1154:
1155: CategoryDataset dataset = p.getDataset(datasetIndex);
1156: String label = this.legendItemLabelGenerator.generateLabel(dataset,
1157: series);
1158: String description = label;
1159: String toolTipText = null;
1160: if (this.legendItemToolTipGenerator != null) {
1161: toolTipText = this.legendItemToolTipGenerator.generateLabel(
1162: dataset, series);
1163: }
1164: String urlText = null;
1165: if (this.legendItemURLGenerator != null) {
1166: urlText = this.legendItemURLGenerator.generateLabel(dataset,
1167: series);
1168: }
1169: Shape shape = lookupSeriesShape(series);
1170: Paint paint = lookupSeriesPaint(series);
1171: Paint outlinePaint = lookupSeriesOutlinePaint(series);
1172: Stroke outlineStroke = lookupSeriesOutlineStroke(series);
1173:
1174: LegendItem item = new LegendItem(label, description, toolTipText,
1175: urlText, shape, paint, outlineStroke, outlinePaint);
1176: item.setSeriesKey(dataset.getRowKey(series));
1177: item.setSeriesIndex(series);
1178: item.setDataset(dataset);
1179: item.setDatasetIndex(datasetIndex);
1180: return item;
1181: }
1182:
1183:
1190: public boolean equals(Object obj) {
1191:
1192: if (obj == this) {
1193: return true;
1194: }
1195: if (!(obj instanceof AbstractCategoryItemRenderer)) {
1196: return false;
1197: }
1198: AbstractCategoryItemRenderer that = (AbstractCategoryItemRenderer) obj;
1199:
1200: if (!ObjectUtilities.equal(this.itemLabelGenerator,
1201: that.itemLabelGenerator)) {
1202: return false;
1203: }
1204: if (!ObjectUtilities.equal(this.itemLabelGeneratorList,
1205: that.itemLabelGeneratorList)) {
1206: return false;
1207: }
1208: if (!ObjectUtilities.equal(this.baseItemLabelGenerator,
1209: that.baseItemLabelGenerator)) {
1210: return false;
1211: }
1212: if (!ObjectUtilities.equal(this.toolTipGenerator,
1213: that.toolTipGenerator)) {
1214: return false;
1215: }
1216: if (!ObjectUtilities.equal(this.toolTipGeneratorList,
1217: that.toolTipGeneratorList)) {
1218: return false;
1219: }
1220: if (!ObjectUtilities.equal(this.baseToolTipGenerator,
1221: that.baseToolTipGenerator)) {
1222: return false;
1223: }
1224: if (!ObjectUtilities.equal(this.itemURLGenerator,
1225: that.itemURLGenerator)) {
1226: return false;
1227: }
1228: if (!ObjectUtilities.equal(this.itemURLGeneratorList,
1229: that.itemURLGeneratorList)) {
1230: return false;
1231: }
1232: if (!ObjectUtilities.equal(this.baseItemURLGenerator,
1233: that.baseItemURLGenerator)) {
1234: return false;
1235: }
1236: if (!ObjectUtilities.equal(this.legendItemLabelGenerator,
1237: that.legendItemLabelGenerator)) {
1238: return false;
1239: }
1240: if (!ObjectUtilities.equal(this.legendItemToolTipGenerator,
1241: that.legendItemToolTipGenerator)) {
1242: return false;
1243: }
1244: if (!ObjectUtilities.equal(this.legendItemURLGenerator,
1245: that.legendItemURLGenerator)) {
1246: return false;
1247: }
1248: return super.equals(obj);
1249: }
1250:
1251:
1256: public int hashCode() {
1257: int result = super.hashCode();
1258: return result;
1259: }
1260:
1261:
1266: public DrawingSupplier getDrawingSupplier() {
1267: DrawingSupplier result = null;
1268: CategoryPlot cp = getPlot();
1269: if (cp != null) {
1270: result = cp.getDrawingSupplier();
1271: }
1272: return result;
1273: }
1274:
1275:
1288: protected void drawItemLabel(Graphics2D g2,
1289: PlotOrientation orientation,
1290: CategoryDataset dataset,
1291: int row, int column,
1292: double x, double y,
1293: boolean negative) {
1294:
1295: CategoryItemLabelGenerator generator
1296: = getItemLabelGenerator(row, column);
1297: if (generator != null) {
1298: Font labelFont = getItemLabelFont(row, column);
1299: Paint paint = getItemLabelPaint(row, column);
1300: g2.setFont(labelFont);
1301: g2.setPaint(paint);
1302: String label = generator.generateLabel(dataset, row, column);
1303: ItemLabelPosition position = null;
1304: if (!negative) {
1305: position = getPositiveItemLabelPosition(row, column);
1306: }
1307: else {
1308: position = getNegativeItemLabelPosition(row, column);
1309: }
1310: Point2D anchorPoint = calculateLabelAnchorPoint(
1311: position.getItemLabelAnchor(), x, y, orientation);
1312: TextUtilities.drawRotatedString(label, g2,
1313: (float) anchorPoint.getX(), (float) anchorPoint.getY(),
1314: position.getTextAnchor(),
1315: position.getAngle(), position.getRotationAnchor());
1316: }
1317:
1318: }
1319:
1320:
1330: public Object clone() throws CloneNotSupportedException {
1331:
1332: AbstractCategoryItemRenderer clone
1333: = (AbstractCategoryItemRenderer) super.clone();
1334:
1335: if (this.itemLabelGenerator != null) {
1336: if (this.itemLabelGenerator instanceof PublicCloneable) {
1337: PublicCloneable pc = (PublicCloneable) this.itemLabelGenerator;
1338: clone.itemLabelGenerator
1339: = (CategoryItemLabelGenerator) pc.clone();
1340: }
1341: else {
1342: throw new CloneNotSupportedException(
1343: "ItemLabelGenerator not cloneable.");
1344: }
1345: }
1346:
1347: if (this.itemLabelGeneratorList != null) {
1348: clone.itemLabelGeneratorList
1349: = (ObjectList) this.itemLabelGeneratorList.clone();
1350: }
1351:
1352: if (this.baseItemLabelGenerator != null) {
1353: if (this.baseItemLabelGenerator instanceof PublicCloneable) {
1354: PublicCloneable pc
1355: = (PublicCloneable) this.baseItemLabelGenerator;
1356: clone.baseItemLabelGenerator
1357: = (CategoryItemLabelGenerator) pc.clone();
1358: }
1359: else {
1360: throw new CloneNotSupportedException(
1361: "ItemLabelGenerator not cloneable.");
1362: }
1363: }
1364:
1365: if (this.toolTipGenerator != null) {
1366: if (this.toolTipGenerator instanceof PublicCloneable) {
1367: PublicCloneable pc = (PublicCloneable) this.toolTipGenerator;
1368: clone.toolTipGenerator = (CategoryToolTipGenerator) pc.clone();
1369: }
1370: else {
1371: throw new CloneNotSupportedException(
1372: "Tool tip generator not cloneable.");
1373: }
1374: }
1375:
1376: if (this.toolTipGeneratorList != null) {
1377: clone.toolTipGeneratorList
1378: = (ObjectList) this.toolTipGeneratorList.clone();
1379: }
1380:
1381: if (this.baseToolTipGenerator != null) {
1382: if (this.baseToolTipGenerator instanceof PublicCloneable) {
1383: PublicCloneable pc
1384: = (PublicCloneable) this.baseToolTipGenerator;
1385: clone.baseToolTipGenerator
1386: = (CategoryToolTipGenerator) pc.clone();
1387: }
1388: else {
1389: throw new CloneNotSupportedException(
1390: "Base tool tip generator not cloneable.");
1391: }
1392: }
1393:
1394: if (this.itemURLGenerator != null) {
1395: if (this.itemURLGenerator instanceof PublicCloneable) {
1396: PublicCloneable pc = (PublicCloneable) this.itemURLGenerator;
1397: clone.itemURLGenerator = (CategoryURLGenerator) pc.clone();
1398: }
1399: else {
1400: throw new CloneNotSupportedException(
1401: "Item URL generator not cloneable.");
1402: }
1403: }
1404:
1405: if (this.itemURLGeneratorList != null) {
1406: clone.itemURLGeneratorList
1407: = (ObjectList) this.itemURLGeneratorList.clone();
1408: }
1409:
1410: if (this.baseItemURLGenerator != null) {
1411: if (this.baseItemURLGenerator instanceof PublicCloneable) {
1412: PublicCloneable pc
1413: = (PublicCloneable) this.baseItemURLGenerator;
1414: clone.baseItemURLGenerator = (CategoryURLGenerator) pc.clone();
1415: }
1416: else {
1417: throw new CloneNotSupportedException(
1418: "Base item URL generator not cloneable.");
1419: }
1420: }
1421:
1422: if (this.legendItemLabelGenerator instanceof PublicCloneable) {
1423: clone.legendItemLabelGenerator = (CategorySeriesLabelGenerator)
1424: ObjectUtilities.clone(this.legendItemLabelGenerator);
1425: }
1426: if (this.legendItemToolTipGenerator instanceof PublicCloneable) {
1427: clone.legendItemToolTipGenerator = (CategorySeriesLabelGenerator)
1428: ObjectUtilities.clone(this.legendItemToolTipGenerator);
1429: }
1430: if (this.legendItemURLGenerator instanceof PublicCloneable) {
1431: clone.legendItemURLGenerator = (CategorySeriesLabelGenerator)
1432: ObjectUtilities.clone(this.legendItemURLGenerator);
1433: }
1434: return clone;
1435: }
1436:
1437:
1445: protected CategoryAxis getDomainAxis(CategoryPlot plot, int index) {
1446: CategoryAxis result = plot.getDomainAxis(index);
1447: if (result == null) {
1448: result = plot.getDomainAxis();
1449: }
1450: return result;
1451: }
1452:
1453:
1461: protected ValueAxis getRangeAxis(CategoryPlot plot, int index) {
1462: ValueAxis result = plot.getRangeAxis(index);
1463: if (result == null) {
1464: result = plot.getRangeAxis();
1465: }
1466: return result;
1467: }
1468:
1469:
1477: public LegendItemCollection getLegendItems() {
1478: if (this.plot == null) {
1479: return new LegendItemCollection();
1480: }
1481: LegendItemCollection result = new LegendItemCollection();
1482: int index = this.plot.getIndexOf(this);
1483: CategoryDataset dataset = this.plot.getDataset(index);
1484: if (dataset != null) {
1485: int seriesCount = dataset.getRowCount();
1486: for (int i = 0; i < seriesCount; i++) {
1487: if (isSeriesVisibleInLegend(i)) {
1488: LegendItem item = getLegendItem(index, i);
1489: if (item != null) {
1490: result.add(item);
1491: }
1492: }
1493: }
1494:
1495: }
1496: return result;
1497: }
1498:
1499:
1506: public CategorySeriesLabelGenerator getLegendItemLabelGenerator() {
1507: return this.legendItemLabelGenerator;
1508: }
1509:
1510:
1518: public void setLegendItemLabelGenerator(
1519: CategorySeriesLabelGenerator generator) {
1520: if (generator == null) {
1521: throw new IllegalArgumentException("Null 'generator' argument.");
1522: }
1523: this.legendItemLabelGenerator = generator;
1524: fireChangeEvent();
1525: }
1526:
1527:
1534: public CategorySeriesLabelGenerator getLegendItemToolTipGenerator() {
1535: return this.legendItemToolTipGenerator;
1536: }
1537:
1538:
1546: public void setLegendItemToolTipGenerator(
1547: CategorySeriesLabelGenerator generator) {
1548: this.legendItemToolTipGenerator = generator;
1549: fireChangeEvent();
1550: }
1551:
1552:
1559: public CategorySeriesLabelGenerator getLegendItemURLGenerator() {
1560: return this.legendItemURLGenerator;
1561: }
1562:
1563:
1571: public void setLegendItemURLGenerator(
1572: CategorySeriesLabelGenerator generator) {
1573: this.legendItemURLGenerator = generator;
1574: fireChangeEvent();
1575: }
1576:
1577:
1586: protected void addItemEntity(EntityCollection entities,
1587: CategoryDataset dataset, int row, int column,
1588: Shape hotspot) {
1589:
1590: String tip = null;
1591: CategoryToolTipGenerator tipster = getToolTipGenerator(row, column);
1592: if (tipster != null) {
1593: tip = tipster.generateToolTip(dataset, row, column);
1594: }
1595: String url = null;
1596: CategoryURLGenerator urlster = getItemURLGenerator(row, column);
1597: if (urlster != null) {
1598: url = urlster.generateURL(dataset, row, column);
1599: }
1600: CategoryItemEntity entity = new CategoryItemEntity(hotspot, tip, url,
1601: dataset, dataset.getRowKey(row), dataset.getColumnKey(column));
1602: entities.add(entity);
1603:
1604: }
1605:
1606:
1607: }