Revision 43780 trunk/org.gvsig.desktop/org.gvsig.desktop.compat.cdc/org.gvsig.fmap.mapcontext/org.gvsig.fmap.mapcontext.api/src/main/java/org/gvsig/fmap/mapcontext/impl/DefaultMapContextManager.java
| DefaultMapContextManager.java | ||
|---|---|---|
| 35 | 35 |
import java.util.Collections; |
| 36 | 36 |
import java.util.HashMap; |
| 37 | 37 |
import java.util.Iterator; |
| 38 |
import java.util.LinkedHashMap; |
|
| 38 | 39 |
import java.util.List; |
| 39 | 40 |
import java.util.Map; |
| 40 | 41 |
import org.apache.commons.lang3.StringUtils; |
| ... | ... | |
| 96 | 97 |
|
| 97 | 98 |
private Class drawerClazz = DefaultMapContextDrawer.class; |
| 98 | 99 |
|
| 99 |
private Map legends = Collections.synchronizedMap(new HashMap());
|
|
| 100 |
private final Map legends = new HashMap();
|
|
| 100 | 101 |
|
| 101 |
private Map legendReaders = Collections.synchronizedMap(new HashMap());
|
|
| 102 |
private final Map<String, Class<ILegendReader>> legendReaders = new LinkedHashMap<>();
|
|
| 102 | 103 |
|
| 103 |
private Map legendWriters = Collections.synchronizedMap(new HashMap());
|
|
| 104 |
private final Map<String, Map<Class<ILegend>,Class<ILegendWriter>>> legendWriters = new LinkedHashMap<>();
|
|
| 104 | 105 |
|
| 105 | 106 |
private String defaultVectorLegend; |
| 106 | 107 |
|
| ... | ... | |
| 325 | 326 |
|
| 326 | 327 |
// ============================================================= |
| 327 | 328 |
// Legend reading/writing |
| 329 |
|
|
| 330 |
private Map<Class<ILegend>,Class<ILegendWriter>> getLegendWritersForFormat(String format) {
|
|
| 331 |
synchronized(legendWriters) {
|
|
| 332 |
return legendWriters.get(format); |
|
| 333 |
} |
|
| 334 |
} |
|
| 335 |
|
|
| 336 |
private Class<ILegendReader> getLegendReaderForFormat(String format) {
|
|
| 337 |
synchronized(legendReaders) {
|
|
| 338 |
return legendReaders.get(format); |
|
| 339 |
} |
|
| 340 |
} |
|
| 341 |
|
|
| 342 |
@Override |
|
| 343 |
public List<String> getLegendReadingFormats() {
|
|
| 344 |
synchronized(legendReaders) {
|
|
| 345 |
List<String> resp = new ArrayList(); |
|
| 346 |
resp.addAll(legendReaders.keySet()); |
|
| 347 |
return resp; |
|
| 348 |
} |
|
| 349 |
} |
|
| 350 |
|
|
| 351 |
@Override |
|
| 352 |
public List<String> getLegendWritingFormats() {
|
|
| 353 |
synchronized(legendWriters) {
|
|
| 354 |
List<String> resp = new ArrayList(); |
|
| 355 |
resp.addAll(legendWriters.keySet()); |
|
| 356 |
return resp; |
|
| 357 |
} |
|
| 358 |
} |
|
| 359 |
|
|
| 360 |
@Override |
|
| 328 | 361 |
public void registerLegendReader(String format, Class readerClass) |
| 329 | 362 |
throws MapContextRuntimeException {
|
| 330 | 363 |
if (readerClass == null |
| ... | ... | |
| 332 | 365 |
throw new InvalidRegisteredClassException(ILegendReader.class, |
| 333 | 366 |
readerClass, format); |
| 334 | 367 |
} |
| 335 |
|
|
| 336 |
legendReaders.put(format, readerClass); |
|
| 368 |
synchronized (legendReaders) {
|
|
| 369 |
legendReaders.put(format, readerClass); |
|
| 370 |
} |
|
| 337 | 371 |
notifyObservers(REGISTER_LEGEND_READER, format, readerClass); |
| 338 | 372 |
} |
| 339 | 373 |
|
| 340 |
public ILegendReader createLegendReader(String format) |
|
| 341 |
throws MapContextRuntimeException {
|
|
| 342 |
Class legendReaderClazz = (Class) legendReaders.get(format); |
|
| 343 |
|
|
| 344 |
if (legendReaderClazz != null) {
|
|
| 345 |
try {
|
|
| 346 |
ILegendReader reader = (ILegendReader) legendReaderClazz.newInstance(); |
|
| 347 |
return (ILegendReader) notifyObservers(CREATE_LEGEND_READER, reader).getValue(); |
|
| 348 |
} catch (InstantiationException e) {
|
|
| 349 |
throw new RegisteredClassInstantiationException( |
|
| 350 |
ILegendReader.class, legendReaderClazz, format, e); |
|
| 351 |
} catch (IllegalAccessException e) {
|
|
| 352 |
throw new RegisteredClassInstantiationException( |
|
| 353 |
ILegendReader.class, legendReaderClazz, format, e); |
|
| 354 |
} |
|
| 355 |
} |
|
| 356 |
return null; |
|
| 357 |
} |
|
| 358 |
|
|
| 374 |
@Override |
|
| 359 | 375 |
public void registerLegendWriter(Class legendClass, String format, |
| 360 | 376 |
Class writerClass) throws MapContextRuntimeException {
|
| 361 |
if (writerClass == null |
|
| 377 |
if (writerClass == null || legendClass == null
|
|
| 362 | 378 |
|| !ILegendWriter.class.isAssignableFrom(writerClass) |
| 363 |
|| legendClass == null |
|
| 364 | 379 |
|| !ILegend.class.isAssignableFrom(legendClass)) {
|
| 365 | 380 |
|
| 366 | 381 |
throw new InvalidRegisteredClassException(ILegendWriter.class, |
| ... | ... | |
| 368 | 383 |
legendClass == null ? "Null" : legendClass.getName())); |
| 369 | 384 |
} |
| 370 | 385 |
|
| 371 |
Map legendFormatWriters = (Map) legendWriters.get(format); |
|
| 372 |
|
|
| 373 | 386 |
synchronized (legendWriters) {
|
| 374 |
if (legendFormatWriters == null) {
|
|
| 375 |
legendFormatWriters = Collections.synchronizedMap(new HashMap()); |
|
| 376 |
legendWriters.put(format, legendFormatWriters); |
|
| 387 |
Map<Class<ILegend>, Class<ILegendWriter>> legendWriterOfFormat = legendWriters.get(format); |
|
| 388 |
if (legendWriterOfFormat == null) {
|
|
| 389 |
legendWriterOfFormat = new LinkedHashMap(); |
|
| 390 |
legendWriters.put(format, legendWriterOfFormat); |
|
| 377 | 391 |
} |
| 392 |
legendWriterOfFormat.put(legendClass, writerClass); |
|
| 378 | 393 |
} |
| 379 |
legendFormatWriters.put(legendClass, writerClass); |
|
| 380 | 394 |
notifyObservers(REGISTER_LEGEND_WRITER, format, writerClass); |
| 381 | 395 |
} |
| 382 | 396 |
|
| 397 |
@Override |
|
| 398 |
public ILegendReader createLegendReader(String format) |
|
| 399 |
throws MapContextRuntimeException {
|
|
| 400 |
Class<ILegendReader> legendReaderClazz = getLegendReaderForFormat(format); |
|
| 401 |
|
|
| 402 |
if (legendReaderClazz != null) {
|
|
| 403 |
try {
|
|
| 404 |
ILegendReader reader = (ILegendReader) legendReaderClazz.newInstance(); |
|
| 405 |
return (ILegendReader) notifyObservers(CREATE_LEGEND_READER, reader).getValue(); |
|
| 406 |
} catch (InstantiationException|IllegalAccessException e) {
|
|
| 407 |
throw new RegisteredClassInstantiationException( |
|
| 408 |
ILegendReader.class, legendReaderClazz, format, e); |
|
| 409 |
} |
|
| 410 |
} |
|
| 411 |
return null; |
|
| 412 |
} |
|
| 413 |
|
|
| 414 |
@Override |
|
| 383 | 415 |
public ILegendWriter createLegendWriter(Class legendClass, String format) |
| 384 | 416 |
throws MapContextRuntimeException {
|
| 385 | 417 |
|
| ... | ... | |
| 387 | 419 |
return null; |
| 388 | 420 |
} |
| 389 | 421 |
|
| 390 |
Map legendFormatWriters = getLegendWritersForFormat(format); |
|
| 422 |
Map<Class<ILegend>, Class<ILegendWriter>> legendFormatWriters = getLegendWritersForFormat(format);
|
|
| 391 | 423 |
|
| 392 | 424 |
if (legendFormatWriters != null) {
|
| 393 |
Class legendWriterClazz = (Class) legendFormatWriters |
|
| 394 |
.get(legendClass); |
|
| 395 |
|
|
| 425 |
Class<ILegendWriter> legendWriterClazz = legendFormatWriters.get(legendClass); |
|
| 396 | 426 |
if (legendWriterClazz != null) {
|
| 397 | 427 |
/* |
| 398 | 428 |
* Found exact match |
| ... | ... | |
| 400 | 430 |
try {
|
| 401 | 431 |
ILegendWriter writer = (ILegendWriter) legendWriterClazz.newInstance(); |
| 402 | 432 |
return (ILegendWriter) notifyObservers(CREATE_LEGEND_READER, writer).getValue(); |
| 403 |
} catch (InstantiationException e) {
|
|
| 433 |
} catch (InstantiationException|IllegalAccessException e) {
|
|
| 404 | 434 |
throw new RegisteredClassInstantiationException( |
| 405 |
ILegendWriter.class, legendWriterClazz, format |
|
| 406 |
.concat("-").concat(
|
|
| 407 |
legendClass == null ? "Null" : legendClass.getName()), e); |
|
| 408 |
} catch (IllegalAccessException e) {
|
|
| 409 |
throw new RegisteredClassInstantiationException( |
|
| 410 |
ILegendWriter.class, legendWriterClazz, format |
|
| 411 |
.concat("-").concat(
|
|
| 412 |
legendClass == null ? "Null" : legendClass.getName()), e); |
|
| 435 |
ILegendWriter.class, |
|
| 436 |
legendWriterClazz, |
|
| 437 |
format.concat("-").concat(legendClass.getName()),
|
|
| 438 |
e |
|
| 439 |
); |
|
| 413 | 440 |
} |
| 414 | 441 |
} else {
|
| 415 | 442 |
/* |
| ... | ... | |
| 425 | 452 |
return null; |
| 426 | 453 |
} |
| 427 | 454 |
|
| 428 |
private ILegendWriter getSuperClassLegendWriter(Map clsToWtr, Class legclass)
|
|
| 455 |
private ILegendWriter getSuperClassLegendWriter(Map<Class<ILegend>, Class<ILegendWriter>> clsToWtr, Class<ILegend> legclass)
|
|
| 429 | 456 |
throws Exception {
|
| 430 | 457 |
|
| 431 |
if (!ILegend.class.isAssignableFrom(legclass)) {
|
|
| 432 |
// Class is not a legend |
|
| 433 |
return null; |
|
| 434 |
} |
|
| 435 |
|
|
| 436 | 458 |
Iterator kiter = clsToWtr.keySet().iterator(); |
| 437 | 459 |
Object oitem = null; |
| 438 | 460 |
Class citem = null; |
| ... | ... | |
| 455 | 477 |
return null; |
| 456 | 478 |
} |
| 457 | 479 |
|
| 458 |
private Map getLegendWritersForFormat(String format) {
|
|
| 459 |
return (Map) legendWriters.get(format); |
|
| 460 |
} |
|
| 461 |
|
|
| 462 |
public List getLegendReadingFormats() {
|
|
| 463 |
List resp = new ArrayList(); |
|
| 464 |
Iterator iter = legendReaders.keySet().iterator(); |
|
| 465 |
while (iter.hasNext()) {
|
|
| 466 |
resp.add(iter.next()); |
|
| 467 |
} |
|
| 468 |
return resp; |
|
| 469 |
} |
|
| 470 |
|
|
| 471 |
public List getLegendWritingFormats() {
|
|
| 472 |
List resp = new ArrayList(); |
|
| 473 |
Iterator iter = legendWriters.keySet().iterator(); |
|
| 474 |
while (iter.hasNext()) {
|
|
| 475 |
resp.add(iter.next()); |
|
| 476 |
} |
|
| 477 |
return resp; |
|
| 478 |
} |
|
| 479 | 480 |
// ============================================================= |
| 480 | 481 |
|
| 481 | 482 |
public IMultiLayerSymbol createMultiLayerSymbol(int shapeType) |
Also available in: Unified diff