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