001package org.apache.maven.doxia.module.docbook; 002 003/* 004 * Licensed to the Apache Software Foundation (ASF) under one 005 * or more contributor license agreements. See the NOTICE file 006 * distributed with this work for additional information 007 * regarding copyright ownership. The ASF licenses this file 008 * to you under the Apache License, Version 2.0 (the 009 * "License"); you may not use this file except in compliance 010 * with the License. You may obtain a copy of the License at 011 * 012 * http://www.apache.org/licenses/LICENSE-2.0 013 * 014 * Unless required by applicable law or agreed to in writing, 015 * software distributed under the License is distributed on an 016 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 017 * KIND, either express or implied. See the License for the 018 * specific language governing permissions and limitations 019 * under the License. 020 */ 021 022import java.io.PrintWriter; 023import java.io.StringWriter; 024import java.io.Writer; 025import java.util.ArrayList; 026import java.util.HashMap; 027import java.util.List; 028import java.util.Locale; 029import java.util.Map; 030import java.util.Set; 031import java.util.Stack; 032import java.util.StringTokenizer; 033import java.util.TreeSet; 034 035import javax.swing.text.MutableAttributeSet; 036import javax.swing.text.SimpleAttributeSet; 037 038import org.apache.maven.doxia.sink.Sink; 039import org.apache.maven.doxia.sink.SinkEventAttributes; 040import org.apache.maven.doxia.sink.impl.AbstractXmlSink; 041import org.apache.maven.doxia.sink.impl.SinkEventAttributeSet; 042import org.apache.maven.doxia.util.DoxiaUtils; 043import org.codehaus.plexus.util.FileUtils; 044 045import static org.apache.maven.doxia.util.HtmlTools.escapeHTML; 046 047/** 048 * <a href="http://www.oasis-open.org/docbook">Docbook</a> Sink implementation. 049 * <br> 050 * It uses the Docbook v4.4 DTD <a href="http://www.oasis-open.org/docbook/sgml/4.4/docbookx.dtd"> 051 * http://www.oasis-open.org/docbook/sgml/4.4/docbookx.dtd</a>. 052 * 053 * @since 1.0 054 */ 055public class DocBookSink 056 extends AbstractXmlSink 057 implements DocbookMarkup, SimplifiedDocbookMarkup 058{ 059 /** DocBook V4.4 SGML public id: "-//OASIS//DTD DocBook V4.4//EN" 060 * @deprecated since 1.1, use {@link DocbookMarkup#DEFAULT_SGML_PUBLIC_ID} instead of. */ 061 public static final String DEFAULT_SGML_PUBLIC_ID = DocbookMarkup.DEFAULT_SGML_PUBLIC_ID; 062 063 /** DocBook XML V4.4 XML public id: "-//OASIS//DTD DocBook XML V4.4//EN" 064 * @deprecated since 1.1, use {@link DocbookMarkup#DEFAULT_XML_PUBLIC_ID} instead of. */ 065 public static final String DEFAULT_XML_PUBLIC_ID = DocbookMarkup.DEFAULT_XML_PUBLIC_ID; 066 067 /** DocBook XML V4.4 XML system id: "http://www.oasis-open.org/docbook/xml/4.4/docbookx.dtd" 068 * @deprecated since 1.1, use {@link DocbookMarkup#DEFAULT_XML_SYSTEM_ID} instead of. */ 069 public static final String DEFAULT_XML_SYSTEM_ID = DocbookMarkup.DEFAULT_XML_SYSTEM_ID; 070 071 /** DocBook XML V4.4 SGML system id: "http://www.oasis-open.org/docbook/xml/4.4/docbookx.dtd" 072 * @deprecated since 1.1, use {@link DocbookMarkup#DEFAULT_SGML_SYSTEM_ID} instead of. */ 073 public static final String DEFAULT_SGML_SYSTEM_ID = DocbookMarkup.DEFAULT_SGML_SYSTEM_ID; 074 075 /** The output writer. */ 076 private PrintWriter out; 077 078 /** xmlMode. */ 079 private boolean xmlMode = false; 080 081 /** styleSheet. */ 082 private String styleSheet = null; 083 084 /** language. */ 085 private String lang = null; 086 087 /** publicId. */ 088 private String publicId = null; 089 090 /** systemId. */ 091 private String systemId = null; 092 093 /** italicBegin. */ 094 private String italicBeginTag; 095 096 /** italicEnd. */ 097 private String italicEndTag; 098 099 /** boldBegin. */ 100 private String boldBeginTag; 101 102 /** boldEnd. */ 103 private String boldEndTag; 104 105 /** monospacedBegin. */ 106 private String monospacedBeginTag; 107 108 /** monospacedEnd. */ 109 private String monospacedEndTag; 110 111 /** horizontalRule. */ 112 private String horizontalRuleElement; 113 114 /** pageBreak. */ 115 private String pageBreakElement; 116 117 /** lineBreak. */ 118 private String lineBreakElement; 119 120 /** An image source file. */ 121 private String graphicsFileName; 122 123 /** hasTitle. */ 124 private boolean hasTitle; 125 126 /** authorDate. */ 127 private boolean authorDateFlag; 128 129 /** verbatim. */ 130 private boolean verbatimFlag; 131 132 /** externalLink. */ 133 private boolean externalLinkFlag; 134 135 /** tableHasCaption. */ 136 private boolean tableHasCaption; 137 138 /** Used for table rows. */ 139 private PrintWriter savedOut; 140 141 /** tableRows. */ 142 private String tableRows; 143 144 /** tableRows writer. */ 145 private StringWriter tableRowsWriter; 146 147 /** tableHasGrid. */ 148 private boolean tableHasGrid; 149 150 private boolean skip; 151 152 private boolean paragraph; 153 154 private String encoding; 155 156 /** Keep track of the closing tags for inline events. */ 157 protected Stack<List<String>> inlineStack = new Stack<>(); 158 159 /** Map of warn messages with a String as key to describe the error type and a Set as value. 160 * Using to reduce warn messages. */ 161 private Map<String, Set<String>> warnMessages; 162 163 /** 164 * Constructor, initialize the Writer. 165 * 166 * @param writer not null writer to write the result. <b>Should</b> be an UTF-8 Writer. 167 * You could use <code>newXmlWriter</code> methods from {@link org.codehaus.plexus.util.WriterFactory}. 168 */ 169 protected DocBookSink( Writer writer ) 170 { 171 this( writer, null ); 172 } 173 174 /** 175 * Constructor, initialize the Writer and tells which encoding is used. 176 * 177 * @param writer not null writer to write the result. 178 * @param encoding the encoding used, that should be written to the generated HTML content 179 * if not <code>null</code>. 180 */ 181 protected DocBookSink( Writer writer, String encoding ) 182 { 183 this.out = new PrintWriter( writer ); 184 this.encoding = encoding; 185 186 setItalicElement( "<emphasis>" ); 187 setBoldElement( "<emphasis role=\"bold\">" ); 188 setMonospacedElement( "<literal>" ); 189 setHorizontalRuleElement( "<!-- HR -->" ); 190 setPageBreakElement( "<!-- PB -->" ); 191 setLineBreakElement( "<!-- LB -->" ); 192 } 193 194 /** 195 * Constructor, initialize the Writer and tells which encoding and languageId are used. 196 * 197 * @param writer not null writer to write the result. 198 * @param encoding the encoding used, that should be written to the generated HTML content 199 * if not <code>null</code>. 200 * @param languageId language identifier for the root element as defined by 201 * <a href="ftp://ftp.isi.edu/in-notes/bcp/bcp47.txt">IETF BCP 47</a>, Tags for the Identification of Languages; 202 * in addition, the empty string may be specified. 203 * @since 1.1 204 */ 205 protected DocBookSink( Writer writer, String encoding, String languageId ) 206 { 207 this( writer, encoding ); 208 209 this.lang = languageId; 210 } 211 212 /** 213 * <p>escapeSGML</p> 214 * 215 * @param text The text to escape. 216 * @param xmlMode xmlMode. 217 * @return The escaped text. 218 * @deprecated Use HtmlTools#escapeHTML(String,boolean). 219 */ 220 public static String escapeSGML( String text, boolean xmlMode ) 221 { 222 return escapeHTML( text, xmlMode ); 223 } 224 225 /** 226 * Sets the xml mode. 227 * 228 * @param mode the mode to set. 229 * @deprecated xml mode is not used. 230 */ 231 public void setXMLMode( boolean mode ) 232 { 233 this.xmlMode = mode; 234 } 235 236 /** 237 * Returns the current xmlMode. 238 * 239 * @return the current xmlMode. 240 * @deprecated xml mode is not used. 241 */ 242 public boolean isXMLMode() 243 { 244 return xmlMode; 245 } 246 247 /** 248 * Sets the encoding. The encoding specified here must be consistent with then encoding 249 * used in the Writer used by this DocBookSink instance. 250 * 251 * @param enc the encoding to set. 252 */ 253 public void setEncoding( String enc ) 254 { 255 encoding = enc; 256 } 257 258 /** 259 * Returns the encoding. 260 * 261 * @return the encoding set (can be <code>null</code>). 262 */ 263 public String getEncoding() 264 { 265 return encoding; 266 } 267 268 /** 269 * Sets the styleSheet. 270 * 271 * @param sheet the styleSheet to set. 272 */ 273 public void setStyleSheet( String sheet ) 274 { 275 this.styleSheet = sheet; 276 } 277 278 /** 279 * Returns the current styleSheet. 280 * 281 * @return the current styleSheet. 282 */ 283 public String getStyleSheet() 284 { 285 return styleSheet; 286 } 287 288 /** 289 * Sets the publicId. 290 * 291 * @param id the publicId to set. 292 */ 293 public void setPublicId( String id ) 294 { 295 this.publicId = id; 296 } 297 298 /** 299 * Returns the current publicId. 300 * 301 * @return the current publicId. 302 */ 303 public String getPublicId() 304 { 305 return publicId; 306 } 307 308 /** 309 * Sets the systemId. 310 * 311 * @param id the systemId to set. 312 */ 313 public void setSystemId( String id ) 314 { 315 this.systemId = id; 316 } 317 318 /** 319 * Returns the current systemId. 320 * 321 * @return the current systemId. 322 */ 323 public String getSystemId() 324 { 325 return systemId; 326 } 327 328 /** 329 * Sets the language. 330 * 331 * @param language the language to set. 332 */ 333 public void setLanguage( String language ) 334 { 335 this.lang = language; 336 } 337 338 /** 339 * Returns the current language. 340 * 341 * @return the current language. 342 */ 343 public String getLanguage() 344 { 345 return lang; 346 } 347 348 /** 349 * Sets the current italicBeginTag and constructs the corresponding end tag from it. 350 * 351 * @param tag the tag to set. If tag is null, the empty string is used. 352 */ 353 public void setItalicElement( String tag ) 354 { 355 if ( tag == null ) 356 { 357 tag = ""; 358 } 359 this.italicBeginTag = tag; 360 italicEndTag = makeEndTag( italicBeginTag ); 361 } 362 363 /** 364 * Constructs the corresponding end tag from the given begin tag. 365 * 366 * @param beginTag the begin tag to set. If null, the empty string is returned. 367 * @return the corresponding end tag. 368 */ 369 private String makeEndTag( String beginTag ) 370 { 371 int length = beginTag.length(); 372 if ( length == 0 ) 373 { 374 return ""; 375 } 376 377 if ( beginTag.charAt( 0 ) != '<' || beginTag.charAt( length - 1 ) != '>' ) 378 { 379 throw new IllegalArgumentException( "'" + beginTag + "', not a tag" ); 380 } 381 382 StringTokenizer tokens = new StringTokenizer( beginTag, "<> \t\n\r\f" ); 383 if ( !tokens.hasMoreTokens() ) 384 { 385 throw new IllegalArgumentException( "'" + beginTag + "', invalid tag" ); 386 } 387 388 return "</" + tokens.nextToken() + ">"; 389 } 390 391 /** 392 * Returns the current italicBeginTag. 393 * 394 * @return the current italicBeginTag. Defaults to {@code <emphasis>}. 395 */ 396 public String getItalicElement() 397 { 398 return italicBeginTag; 399 } 400 401 /** 402 * Sets the current boldBeginTag and constructs the corresponding end tag from it. 403 * 404 * @param tag the tag to set. If tag is null, the empty string is used. 405 */ 406 public void setBoldElement( String tag ) 407 { 408 if ( tag == null ) 409 { 410 tag = ""; 411 } 412 this.boldBeginTag = tag; 413 boldEndTag = makeEndTag( boldBeginTag ); 414 } 415 416 /** 417 * Returns the current boldBeginTag. 418 * 419 * @return the current boldBeginTag. Defaults to {@code <emphasis role=\"bold\">}. 420 */ 421 public String getBoldElement() 422 { 423 return boldBeginTag; 424 } 425 426 /** 427 * Sets the current monospacedBeginTag and constructs the corresponding end tag from it. 428 * 429 * @param tag the tag to set. If tag is null, the empty string is used. 430 */ 431 public void setMonospacedElement( String tag ) 432 { 433 if ( tag == null ) 434 { 435 tag = ""; 436 } 437 this.monospacedBeginTag = tag; 438 monospacedEndTag = makeEndTag( monospacedBeginTag ); 439 } 440 441 /** 442 * Returns the current monospacedBeginTag. 443 * 444 * @return the current monospacedBeginTag. Defaults to {@code <literal>}. 445 */ 446 public String getMonospacedElement() 447 { 448 return monospacedBeginTag; 449 } 450 451 /** 452 * Sets the current horizontalRuleElement. 453 * 454 * @param element the element to set. 455 */ 456 public void setHorizontalRuleElement( String element ) 457 { 458 this.horizontalRuleElement = element; 459 } 460 461 /** 462 * Returns the current horizontalRuleElement. 463 * 464 * @return the current horizontalRuleElement. Defaults to "<!-- HR -->". 465 */ 466 public String getHorizontalRuleElement() 467 { 468 return horizontalRuleElement; 469 } 470 471 /** 472 * Sets the current pageBreakElement. 473 * 474 * @param element the element to set. 475 */ 476 public void setPageBreakElement( String element ) 477 { 478 this.pageBreakElement = element; 479 } 480 481 /** 482 * Returns the current pageBreakElement. 483 * 484 * @return the current pageBreakElement. Defaults to "<!-- PB -->". 485 */ 486 public String getPageBreakElement() 487 { 488 return pageBreakElement; 489 } 490 491 /** 492 * Sets the current lineBreakElement. 493 * 494 * @param element the element to set. 495 */ 496 public void setLineBreakElement( String element ) 497 { 498 this.lineBreakElement = element; 499 } 500 501 /** 502 * Returns the current lineBreakElement. 503 * 504 * @return the current lineBreakElement. Defaults to "<!-- LB -->". 505 */ 506 public String getLineBreakElement() 507 { 508 return lineBreakElement; 509 } 510 511 /** 512 * Reset all variables. 513 * 514 * @deprecated since 1.1.2, use {@link #init()} instead of. 515 */ 516 protected void resetState() 517 { 518 init(); 519 } 520 521 /** 522 * {@inheritDoc} 523 */ 524 protected void init() 525 { 526 hasTitle = false; 527 authorDateFlag = false; 528 verbatimFlag = false; 529 externalLinkFlag = false; 530 graphicsFileName = null; 531 tableHasCaption = false; 532 savedOut = null; 533 tableRows = null; 534 tableHasGrid = false; 535 } 536 537 // ---------------------------------------------------------------------- 538 // 539 // ---------------------------------------------------------------------- 540 541 /** 542 * {@inheritDoc} 543 * 544 * @see SimplifiedDocbookMarkup#DEFAULT_XML_PUBLIC_ID 545 * @see SimplifiedDocbookMarkup#DEFAULT_XML_SYSTEM_ID 546 * @see SimplifiedDocbookMarkup#ARTICLE_TAG 547 */ 548 public void head() 549 { 550 init(); 551 552 MutableAttributeSet att = writeXmlHeader( "article" ); 553 554 writeStartTag( SimplifiedDocbookMarkup.ARTICLE_TAG, att ); 555 } 556 557 /** 558 * writeXmlHeader. 559 * 560 * @param root not null. 561 * @return an attribute set. 562 * @see SimplifiedDocbookMarkup#DEFAULT_XML_PUBLIC_ID 563 * @see SimplifiedDocbookMarkup#DEFAULT_XML_SYSTEM_ID 564 * @see SimplifiedDocbookMarkup#ARTICLE_TAG 565 * @since 1.1 566 */ 567 protected MutableAttributeSet writeXmlHeader( String root ) 568 { 569 markup( "<?xml version=\"1.0\"" ); 570 if ( encoding != null ) 571 { 572 markup( " encoding=\"" + encoding + "\"" ); 573 } 574 markup( "?>" ); 575 576 if ( styleSheet != null ) 577 { 578 markup( "<?xml-stylesheet type=\"text/css\" href=\"" + styleSheet + "\" ?>" ); 579 } 580 581 String pubId; 582 markup( "<!DOCTYPE " + root + " PUBLIC" ); 583 584 if ( publicId == null ) 585 { 586 pubId = SimplifiedDocbookMarkup.DEFAULT_XML_PUBLIC_ID; 587 } 588 else 589 { 590 pubId = publicId; 591 } 592 markup( " \"" + pubId + "\"" ); 593 String sysId = systemId; 594 if ( sysId == null ) 595 { 596 sysId = SimplifiedDocbookMarkup.DEFAULT_XML_SYSTEM_ID; 597 } 598 markup( " \"" + sysId + "\">" ); 599 600 MutableAttributeSet att = new SimpleAttributeSet(); 601 if ( lang != null ) 602 { 603 att.addAttribute( LANG_ATTRIBUTE, lang ); 604 } 605 return att; 606 } 607 608 /** 609 * {@inheritDoc} 610 * 611 * @see SimplifiedDocbookMarkup#ARTICLEINFO_TAG 612 */ 613 public void head_() 614 { 615 if ( hasTitle ) 616 { 617 writeEndTag( SimplifiedDocbookMarkup.ARTICLEINFO_TAG ); 618 hasTitle = false; 619 } 620 } 621 622 /** 623 * {@inheritDoc} 624 * 625 * @see SimplifiedDocbookMarkup#ARTICLEINFO_TAG 626 * @see SimplifiedDocbookMarkup#TITLE_TAG 627 */ 628 public void title() 629 { 630 writeStartTag( SimplifiedDocbookMarkup.ARTICLEINFO_TAG ); 631 writeStartTag( SimplifiedDocbookMarkup.TITLE_TAG ); 632 hasTitle = true; 633 } 634 635 /** 636 * {@inheritDoc} 637 * 638 * @see SimplifiedDocbookMarkup#TITLE_TAG 639 */ 640 public void title_() 641 { 642 writeEndTag( SimplifiedDocbookMarkup.TITLE_TAG ); 643 } 644 645 /** 646 * {@inheritDoc} 647 * 648 * @see SimplifiedDocbookMarkup#CORPAUTHOR_TAG 649 */ 650 public void author() 651 { 652 authorDateFlag = true; 653 writeStartTag( SimplifiedDocbookMarkup.CORPAUTHOR_TAG ); 654 } 655 656 /** 657 * {@inheritDoc} 658 * 659 * @see SimplifiedDocbookMarkup#CORPAUTHOR_TAG 660 */ 661 public void author_() 662 { 663 writeEndTag( SimplifiedDocbookMarkup.CORPAUTHOR_TAG ); 664 authorDateFlag = false; 665 } 666 667 /** 668 * {@inheritDoc} 669 * 670 * @see SimplifiedDocbookMarkup#DATE_TAG 671 */ 672 public void date() 673 { 674 authorDateFlag = true; 675 writeStartTag( SimplifiedDocbookMarkup.DATE_TAG ); 676 } 677 678 /** 679 * {@inheritDoc} 680 * 681 * @see SimplifiedDocbookMarkup#DATE_TAG 682 */ 683 public void date_() 684 { 685 writeEndTag( SimplifiedDocbookMarkup.DATE_TAG ); 686 authorDateFlag = false; 687 } 688 689 /** 690 * {@inheritDoc} 691 * 692 * @see SimplifiedDocbookMarkup#ARTICLE_TAG 693 */ 694 public void body_() 695 { 696 writeEndTag( SimplifiedDocbookMarkup.ARTICLE_TAG ); 697 out.flush(); 698 init(); 699 } 700 701 /** 702 * {@inheritDoc} 703 * 704 * @see SimplifiedDocbookMarkup#SIDEBAR_TAG 705 */ 706 public void sidebar() 707 { 708 writeStartTag( SimplifiedDocbookMarkup.SIDEBAR_TAG ); 709 } 710 711 /** 712 * {@inheritDoc} 713 * 714 * @see SimplifiedDocbookMarkup#SIDEBAR_TAG 715 */ 716 public void sidebar_() 717 { 718 writeEndTag( SimplifiedDocbookMarkup.SIDEBAR_TAG ); 719 } 720 721 /** 722 * {@inheritDoc} 723 * 724 * @see SimplifiedDocbookMarkup#SECTION_TAG 725 */ 726 public void section1() 727 { 728 writeStartTag( SimplifiedDocbookMarkup.SECTION_TAG ); 729 } 730 731 /** 732 * {@inheritDoc} 733 * 734 * @see SimplifiedDocbookMarkup#SECTION_TAG 735 */ 736 public void section1_() 737 { 738 writeEndTag( SimplifiedDocbookMarkup.SECTION_TAG ); 739 } 740 741 /** 742 * {@inheritDoc} 743 * 744 * @see SimplifiedDocbookMarkup#SECTION_TAG 745 */ 746 public void section2() 747 { 748 writeStartTag( SimplifiedDocbookMarkup.SECTION_TAG ); 749 } 750 751 /** 752 * {@inheritDoc} 753 * 754 * @see SimplifiedDocbookMarkup#SECTION_TAG 755 */ 756 public void section2_() 757 { 758 writeEndTag( SimplifiedDocbookMarkup.SECTION_TAG ); 759 } 760 761 /** 762 * {@inheritDoc} 763 * 764 * @see SimplifiedDocbookMarkup#SECTION_TAG 765 */ 766 public void section3() 767 { 768 writeStartTag( SimplifiedDocbookMarkup.SECTION_TAG ); 769 } 770 771 /** 772 * {@inheritDoc} 773 * 774 * @see SimplifiedDocbookMarkup#SECTION_TAG 775 */ 776 public void section3_() 777 { 778 writeEndTag( SimplifiedDocbookMarkup.SECTION_TAG ); 779 } 780 781 /** 782 * {@inheritDoc} 783 * 784 * @see SimplifiedDocbookMarkup#SECTION_TAG 785 */ 786 public void section4() 787 { 788 writeStartTag( SimplifiedDocbookMarkup.SECTION_TAG ); 789 } 790 791 /** 792 * {@inheritDoc} 793 * 794 * @see SimplifiedDocbookMarkup#SECTION_TAG 795 */ 796 public void section4_() 797 { 798 writeEndTag( SimplifiedDocbookMarkup.SECTION_TAG ); 799 } 800 801 /** 802 * {@inheritDoc} 803 * 804 * @see SimplifiedDocbookMarkup#SECTION_TAG 805 */ 806 public void section5() 807 { 808 writeStartTag( SimplifiedDocbookMarkup.SECTION_TAG ); 809 } 810 811 /** 812 * {@inheritDoc} 813 * 814 * @see SimplifiedDocbookMarkup#SECTION_TAG 815 */ 816 public void section5_() 817 { 818 writeEndTag( SimplifiedDocbookMarkup.SECTION_TAG ); 819 } 820 821 /** 822 * {@inheritDoc} 823 * 824 * @see SimplifiedDocbookMarkup#TITLE_TAG 825 */ 826 public void sectionTitle() 827 { 828 writeStartTag( SimplifiedDocbookMarkup.TITLE_TAG ); 829 } 830 831 /** 832 * {@inheritDoc} 833 * 834 * @see SimplifiedDocbookMarkup#TITLE_TAG 835 */ 836 public void sectionTitle_() 837 { 838 writeEndTag( SimplifiedDocbookMarkup.TITLE_TAG ); 839 } 840 841 /** 842 * {@inheritDoc} 843 * 844 * @see SimplifiedDocbookMarkup#TITLE_TAG 845 */ 846 public void sectionTitle1() 847 { 848 writeStartTag( SimplifiedDocbookMarkup.TITLE_TAG ); 849 } 850 851 /** 852 * {@inheritDoc} 853 * 854 * @see SimplifiedDocbookMarkup#TITLE_TAG 855 */ 856 public void sectionTitle1_() 857 { 858 writeEndTag( SimplifiedDocbookMarkup.TITLE_TAG ); 859 } 860 861 /** 862 * {@inheritDoc} 863 * 864 * @see SimplifiedDocbookMarkup#TITLE_TAG 865 */ 866 public void sectionTitle2() 867 { 868 writeStartTag( SimplifiedDocbookMarkup.TITLE_TAG ); 869 } 870 871 /** 872 * {@inheritDoc} 873 * 874 * @see SimplifiedDocbookMarkup#TITLE_TAG 875 */ 876 public void sectionTitle2_() 877 { 878 writeEndTag( SimplifiedDocbookMarkup.TITLE_TAG ); 879 } 880 881 /** 882 * {@inheritDoc} 883 * 884 * @see SimplifiedDocbookMarkup#TITLE_TAG 885 */ 886 public void sectionTitle3() 887 { 888 writeStartTag( SimplifiedDocbookMarkup.TITLE_TAG ); 889 } 890 891 /** 892 * {@inheritDoc} 893 * 894 * @see SimplifiedDocbookMarkup#TITLE_TAG 895 */ 896 public void sectionTitle3_() 897 { 898 writeEndTag( SimplifiedDocbookMarkup.TITLE_TAG ); 899 } 900 901 /** 902 * {@inheritDoc} 903 * 904 * @see SimplifiedDocbookMarkup#TITLE_TAG 905 */ 906 public void sectionTitle4() 907 { 908 writeStartTag( SimplifiedDocbookMarkup.TITLE_TAG ); 909 } 910 911 /** 912 * {@inheritDoc} 913 * 914 * @see SimplifiedDocbookMarkup#TITLE_TAG 915 */ 916 public void sectionTitle4_() 917 { 918 writeEndTag( SimplifiedDocbookMarkup.TITLE_TAG ); 919 } 920 921 /** 922 * {@inheritDoc} 923 * 924 * @see SimplifiedDocbookMarkup#TITLE_TAG 925 */ 926 public void sectionTitle5() 927 { 928 writeStartTag( SimplifiedDocbookMarkup.TITLE_TAG ); 929 } 930 931 /** 932 * {@inheritDoc} 933 * 934 * @see SimplifiedDocbookMarkup#TITLE_TAG 935 */ 936 public void sectionTitle5_() 937 { 938 writeEndTag( SimplifiedDocbookMarkup.TITLE_TAG ); 939 } 940 941 /** 942 * {@inheritDoc} 943 * 944 * @see SimplifiedDocbookMarkup#SECTIONINFO_TAG 945 */ 946 public void header() 947 { 948 writeStartTag( SimplifiedDocbookMarkup.SECTIONINFO_TAG ); 949 } 950 951 /** 952 * {@inheritDoc} 953 * 954 * @see SimplifiedDocbookMarkup#SECTIONINFO_TAG 955 */ 956 public void header_() 957 { 958 writeEndTag( SimplifiedDocbookMarkup.SECTIONINFO_TAG ); 959 } 960 961 /** 962 * {@inheritDoc} 963 * 964 * @see SimplifiedDocbookMarkup#ITEMIZEDLIST_TAG 965 */ 966 public void list() 967 { 968 paragraph_(); 969 writeStartTag( SimplifiedDocbookMarkup.ITEMIZEDLIST_TAG ); 970 } 971 972 /** 973 * {@inheritDoc} 974 * 975 * @see SimplifiedDocbookMarkup#ITEMIZEDLIST_TAG 976 */ 977 public void list_() 978 { 979 writeEndTag( SimplifiedDocbookMarkup.ITEMIZEDLIST_TAG ); 980 } 981 982 /** 983 * {@inheritDoc} 984 * 985 * @see SimplifiedDocbookMarkup#LISTITEM_TAG 986 */ 987 public void listItem() 988 { 989 writeStartTag( SimplifiedDocbookMarkup.LISTITEM_TAG ); 990 paragraph(); 991 } 992 993 /** 994 * {@inheritDoc} 995 * 996 * @see SimplifiedDocbookMarkup#LISTITEM_TAG 997 */ 998 public void listItem_() 999 { 1000 paragraph_(); 1001 writeEndTag( SimplifiedDocbookMarkup.LISTITEM_TAG ); 1002 } 1003 1004 /** 1005 * {@inheritDoc} 1006 * @see SimplifiedDocbookMarkup#ORDEREDLIST_TAG 1007 * @see SimplifiedDocbookMarkup#NUMERATION_ATTRIBUTE 1008 */ 1009 public void numberedList( int numbering ) 1010 { 1011 String numeration = DocbookUtils.docbookListNumbering( numbering ); 1012 1013 paragraph_(); 1014 1015 MutableAttributeSet att = new SimpleAttributeSet(); 1016 att.addAttribute( SimplifiedDocbookMarkup.NUMERATION_ATTRIBUTE, numeration ); 1017 1018 writeStartTag( SimplifiedDocbookMarkup.ORDEREDLIST_TAG, att ); 1019 } 1020 1021 /** 1022 * {@inheritDoc} 1023 * 1024 * @see SimplifiedDocbookMarkup#ORDEREDLIST_TAG 1025 */ 1026 public void numberedList_() 1027 { 1028 writeEndTag( SimplifiedDocbookMarkup.ORDEREDLIST_TAG ); 1029 } 1030 1031 /** 1032 * {@inheritDoc} 1033 * 1034 * @see SimplifiedDocbookMarkup#LISTITEM_TAG 1035 */ 1036 public void numberedListItem() 1037 { 1038 writeStartTag( SimplifiedDocbookMarkup.LISTITEM_TAG ); 1039 paragraph(); 1040 } 1041 1042 /** 1043 * {@inheritDoc} 1044 * 1045 * @see SimplifiedDocbookMarkup#LISTITEM_TAG 1046 */ 1047 public void numberedListItem_() 1048 { 1049 paragraph_(); 1050 writeEndTag( SimplifiedDocbookMarkup.LISTITEM_TAG ); 1051 } 1052 1053 /** 1054 * {@inheritDoc} 1055 * 1056 * @see SimplifiedDocbookMarkup#VARIABLELIST_TAG 1057 */ 1058 public void definitionList() 1059 { 1060 paragraph_(); 1061 writeStartTag( SimplifiedDocbookMarkup.VARIABLELIST_TAG ); 1062 } 1063 1064 /** 1065 * {@inheritDoc} 1066 * 1067 * @see SimplifiedDocbookMarkup#VARIABLELIST_TAG 1068 */ 1069 public void definitionList_() 1070 { 1071 writeEndTag( SimplifiedDocbookMarkup.VARIABLELIST_TAG ); 1072 } 1073 1074 /** 1075 * {@inheritDoc} 1076 * 1077 * @see SimplifiedDocbookMarkup#VARLISTENTRY_TAG 1078 */ 1079 public void definitionListItem() 1080 { 1081 writeStartTag( SimplifiedDocbookMarkup.VARLISTENTRY_TAG ); 1082 } 1083 1084 /** 1085 * {@inheritDoc} 1086 * 1087 * @see SimplifiedDocbookMarkup#VARLISTENTRY_TAG 1088 */ 1089 public void definitionListItem_() 1090 { 1091 writeEndTag( SimplifiedDocbookMarkup.VARLISTENTRY_TAG ); 1092 } 1093 1094 /** 1095 * {@inheritDoc} 1096 * 1097 * @see SimplifiedDocbookMarkup#TERM_TAG 1098 */ 1099 public void definedTerm() 1100 { 1101 writeStartTag( SimplifiedDocbookMarkup.TERM_TAG ); 1102 } 1103 1104 /** 1105 * {@inheritDoc} 1106 * 1107 * @see SimplifiedDocbookMarkup#TERM_TAG 1108 */ 1109 public void definedTerm_() 1110 { 1111 writeEndTag( SimplifiedDocbookMarkup.TERM_TAG ); 1112 } 1113 1114 /** 1115 * {@inheritDoc} 1116 * 1117 * @see SimplifiedDocbookMarkup#LISTITEM_TAG 1118 */ 1119 public void definition() 1120 { 1121 writeStartTag( SimplifiedDocbookMarkup.LISTITEM_TAG ); 1122 paragraph(); 1123 } 1124 1125 /** 1126 * {@inheritDoc} 1127 * 1128 * @see SimplifiedDocbookMarkup#LISTITEM_TAG 1129 */ 1130 public void definition_() 1131 { 1132 paragraph_(); 1133 writeEndTag( SimplifiedDocbookMarkup.LISTITEM_TAG ); 1134 } 1135 1136 /** 1137 * {@inheritDoc} 1138 * 1139 * @see SimplifiedDocbookMarkup#PARA_TAG 1140 */ 1141 public void paragraph() 1142 { 1143 if ( !paragraph ) 1144 { 1145 writeStartTag( SimplifiedDocbookMarkup.PARA_TAG ); 1146 paragraph = true; 1147 } 1148 } 1149 1150 /** 1151 * {@inheritDoc} 1152 * 1153 * @see SimplifiedDocbookMarkup#PARA_TAG 1154 */ 1155 public void paragraph_() 1156 { 1157 if ( paragraph ) 1158 { 1159 writeEndTag( SimplifiedDocbookMarkup.PARA_TAG ); 1160 paragraph = false; 1161 } 1162 } 1163 1164 /** 1165 * {@inheritDoc} 1166 * @see SimplifiedDocbookMarkup#PROGRAMLISTING_TAG 1167 */ 1168 public void verbatim( boolean boxed ) 1169 { 1170 verbatimFlag = true; 1171 paragraph_(); 1172 writeStartTag( SimplifiedDocbookMarkup.PROGRAMLISTING_TAG ); 1173 } 1174 1175 /** 1176 * {@inheritDoc} 1177 * 1178 * @see SimplifiedDocbookMarkup#PROGRAMLISTING_TAG 1179 */ 1180 public void verbatim_() 1181 { 1182 writeEndTag( SimplifiedDocbookMarkup.PROGRAMLISTING_TAG ); 1183 verbatimFlag = false; 1184 } 1185 1186 /** 1187 * {@inheritDoc} 1188 */ 1189 public void horizontalRule() 1190 { 1191 markup( horizontalRuleElement ); 1192 } 1193 1194 /** 1195 * {@inheritDoc} 1196 */ 1197 public void pageBreak() 1198 { 1199 markup( pageBreakElement ); 1200 } 1201 1202 /** 1203 * {@inheritDoc} 1204 */ 1205 public void figure() 1206 { 1207 writeStartTag( SimplifiedDocbookMarkup.MEDIAOBJECT_TAG ); 1208 } 1209 1210 /** 1211 * {@inheritDoc} 1212 */ 1213 public void figure_() 1214 { 1215 writeEndTag( SimplifiedDocbookMarkup.MEDIAOBJECT_TAG ); 1216 } 1217 1218 /** 1219 * <p>graphicElement</p> 1220 * 1221 * @see SimplifiedDocbookMarkup#MEDIAOBJECT_TAG 1222 * @see SimplifiedDocbookMarkup#IMAGEOBJECT_TAG 1223 * @see SimplifiedDocbookMarkup#IMAGEDATA_TAG 1224 * @see SimplifiedDocbookMarkup#FORMAT_ATTRIBUTE 1225 * @see SimplifiedDocbookMarkup#FILEREF_ATTRIBUTE 1226 * @deprecated do not use! 1227 */ 1228 protected void graphicElement() 1229 { 1230 if ( graphicsFileName != null ) 1231 { 1232 String format = FileUtils.extension( graphicsFileName ).toUpperCase( Locale.ENGLISH ); 1233 if ( format.length() == 0 ) 1234 { 1235 format = "JPEG"; 1236 } 1237 1238 writeStartTag( SimplifiedDocbookMarkup.MEDIAOBJECT_TAG ); 1239 writeStartTag( SimplifiedDocbookMarkup.IMAGEOBJECT_TAG ); 1240 1241 MutableAttributeSet att = new SimpleAttributeSet(); 1242 att.addAttribute( SimplifiedDocbookMarkup.FORMAT_ATTRIBUTE, escapeHTML( format, true ) ); 1243 att.addAttribute( SimplifiedDocbookMarkup.FILEREF_ATTRIBUTE, escapeHTML( graphicsFileName, true ) ); 1244 1245 writeSimpleTag( SimplifiedDocbookMarkup.IMAGEDATA_TAG, att ); 1246 1247 writeEndTag( SimplifiedDocbookMarkup.IMAGEOBJECT_TAG ); 1248 writeEndTag( SimplifiedDocbookMarkup.MEDIAOBJECT_TAG ); 1249 graphicsFileName = null; 1250 } 1251 } 1252 1253 /** {@inheritDoc} */ 1254 public void figureGraphics( String name ) 1255 { 1256 String format = FileUtils.extension( name ).toUpperCase( Locale.ENGLISH ); 1257 1258 writeStartTag( SimplifiedDocbookMarkup.IMAGEOBJECT_TAG ); 1259 1260 MutableAttributeSet att = new SimpleAttributeSet(); 1261 att.addAttribute( SimplifiedDocbookMarkup.FORMAT_ATTRIBUTE, escapeHTML( format, true ) ); 1262 att.addAttribute( SimplifiedDocbookMarkup.FILEREF_ATTRIBUTE, escapeHTML( name, true ) ); 1263 1264 writeSimpleTag( SimplifiedDocbookMarkup.IMAGEDATA_TAG, att ); 1265 1266 writeEndTag( SimplifiedDocbookMarkup.IMAGEOBJECT_TAG ); 1267 } 1268 1269 /** 1270 * {@inheritDoc} 1271 * 1272 * @see SimplifiedDocbookMarkup#FIGURE_TAG 1273 * @see SimplifiedDocbookMarkup#TITLE_TAG 1274 */ 1275 public void figureCaption() 1276 { 1277 writeStartTag( SimplifiedDocbookMarkup.CAPTION_TAG ); 1278 writeStartTag( SimplifiedDocbookMarkup.PARA_TAG ); 1279 } 1280 1281 /** 1282 * {@inheritDoc} 1283 * 1284 * @see SimplifiedDocbookMarkup#FIGURE_TAG 1285 * @see SimplifiedDocbookMarkup#TITLE_TAG 1286 */ 1287 public void figureCaption_() 1288 { 1289 writeEndTag( SimplifiedDocbookMarkup.PARA_TAG ); 1290 writeEndTag( SimplifiedDocbookMarkup.CAPTION_TAG ); 1291 } 1292 1293 /** 1294 * {@inheritDoc} 1295 */ 1296 public void table() 1297 { 1298 tableHasCaption = false; 1299 } 1300 1301 /** 1302 * {@inheritDoc} 1303 * 1304 * @see SimplifiedDocbookMarkup#INFORMALTABLE_TAG 1305 * @see SimplifiedDocbookMarkup#FRAME_ATTRIBUTE 1306 * @see SimplifiedDocbookMarkup#ROWSEP_ATTRIBUTE 1307 * @see SimplifiedDocbookMarkup#COLSEP_ATTRIBUTE 1308 * @see SimplifiedDocbookMarkup#TABLE_TAG 1309 */ 1310 public void table_() 1311 { 1312 if ( tableHasCaption ) 1313 { 1314 tableHasCaption = false; 1315 // Formal table+title already written to original destination --- 1316 1317 out.write( tableRows ); 1318 writeEndTag( TABLE_TAG ); 1319 } 1320 else 1321 { 1322 String frame = "none"; 1323 String sep = "0"; 1324 if ( tableHasGrid ) 1325 { 1326 frame = "all"; 1327 sep = "1"; 1328 } 1329 1330 MutableAttributeSet att = new SimpleAttributeSet(); 1331 att.addAttribute( SimplifiedDocbookMarkup.FRAME_ATTRIBUTE, frame ); 1332 att.addAttribute( SimplifiedDocbookMarkup.ROWSEP_ATTRIBUTE, sep ); 1333 att.addAttribute( SimplifiedDocbookMarkup.COLSEP_ATTRIBUTE, sep ); 1334 1335 writeStartTag( SimplifiedDocbookMarkup.INFORMALTABLE_TAG, att ); 1336 1337 out.write( tableRows ); 1338 1339 writeEndTag( SimplifiedDocbookMarkup.INFORMALTABLE_TAG ); 1340 } 1341 1342 tableRows = null; 1343 tableHasGrid = false; 1344 } 1345 1346 /** 1347 * {@inheritDoc} 1348 * @see SimplifiedDocbookMarkup#TGROUP_TAG 1349 * @see SimplifiedDocbookMarkup#COLS_ATTRIBUTE 1350 * @see SimplifiedDocbookMarkup#COLSPEC_TAG 1351 */ 1352 public void tableRows( int[] justification, boolean grid ) 1353 { 1354 tableHasGrid = grid; 1355 1356 // Divert output to a string --- 1357 out.flush(); 1358 savedOut = out; 1359 tableRowsWriter = new StringWriter(); 1360 out = new PrintWriter( tableRowsWriter ); 1361 1362 MutableAttributeSet att = new SimpleAttributeSet(); 1363 att.addAttribute( SimplifiedDocbookMarkup.COLS_ATTRIBUTE, String.valueOf( justification.length ) ); 1364 1365 writeStartTag( SimplifiedDocbookMarkup.TGROUP_TAG, att ); 1366 1367 for ( int i1 : justification ) 1368 { 1369 String justif; 1370 switch ( i1 ) 1371 { 1372 case Sink.JUSTIFY_LEFT: 1373 justif = "left"; 1374 break; 1375 case Sink.JUSTIFY_RIGHT: 1376 justif = "right"; 1377 break; 1378 case Sink.JUSTIFY_CENTER: 1379 default: 1380 justif = "center"; 1381 break; 1382 } 1383 1384 att = new SimpleAttributeSet(); 1385 att.addAttribute( "align", justif ); 1386 1387 writeSimpleTag( SimplifiedDocbookMarkup.COLSPEC_TAG, att ); 1388 } 1389 1390 writeStartTag( SimplifiedDocbookMarkup.TBODY_TAG ); 1391 } 1392 1393 /** 1394 * {@inheritDoc} 1395 * 1396 * @see SimplifiedDocbookMarkup#TGROUP_TAG 1397 * @see SimplifiedDocbookMarkup#TBODY_TAG 1398 */ 1399 public void tableRows_() 1400 { 1401 writeEndTag( SimplifiedDocbookMarkup.TBODY_TAG ); 1402 writeEndTag( SimplifiedDocbookMarkup.TGROUP_TAG ); 1403 1404 // Remember diverted output and restore original destination --- 1405 out.flush(); 1406 if ( tableRowsWriter == null ) 1407 { 1408 throw new IllegalArgumentException( "tableRows( int[] justification, boolean grid )" 1409 + " was not called before." ); 1410 } 1411 1412 tableRows = tableRowsWriter.toString(); 1413 tableRowsWriter = null; 1414 out = savedOut; 1415 } 1416 1417 /** 1418 * {@inheritDoc} 1419 * 1420 * @see SimplifiedDocbookMarkup#ROW_TAG 1421 */ 1422 public void tableRow() 1423 { 1424 writeStartTag( SimplifiedDocbookMarkup.ROW_TAG ); 1425 } 1426 1427 /** 1428 * {@inheritDoc} 1429 * 1430 * @see SimplifiedDocbookMarkup#ROW_TAG 1431 */ 1432 public void tableRow_() 1433 { 1434 writeEndTag( SimplifiedDocbookMarkup.ROW_TAG ); 1435 } 1436 1437 /** 1438 * {@inheritDoc} 1439 * 1440 * @see SimplifiedDocbookMarkup#ENTRY_TAG 1441 */ 1442 public void tableCell() 1443 { 1444 writeStartTag( SimplifiedDocbookMarkup.ENTRY_TAG ); 1445 } 1446 1447 /** 1448 * {@inheritDoc} 1449 * 1450 * @see SimplifiedDocbookMarkup#ENTRY_TAG 1451 */ 1452 public void tableCell_() 1453 { 1454 writeEndTag( SimplifiedDocbookMarkup.ENTRY_TAG ); 1455 } 1456 1457 /** 1458 * {@inheritDoc} 1459 * 1460 * @see SimplifiedDocbookMarkup#ENTRY_TAG 1461 */ 1462 public void tableHeaderCell() 1463 { 1464 writeStartTag( SimplifiedDocbookMarkup.ENTRY_TAG ); 1465 } 1466 1467 /** 1468 * {@inheritDoc} 1469 * 1470 * @see SimplifiedDocbookMarkup#ENTRY_TAG 1471 */ 1472 public void tableHeaderCell_() 1473 { 1474 writeEndTag( SimplifiedDocbookMarkup.ENTRY_TAG ); 1475 } 1476 1477 /** 1478 * {@inheritDoc} 1479 * 1480 * @see SimplifiedDocbookMarkup#TABLE_TAG 1481 * @see SimplifiedDocbookMarkup#FRAME_ATTRIBUTE 1482 * @see SimplifiedDocbookMarkup#ROWSEP_ATTRIBUTE 1483 * @see SimplifiedDocbookMarkup#COLSEP_ATTRIBUTE 1484 * @see SimplifiedDocbookMarkup#TITLE_TAG 1485 */ 1486 public void tableCaption() 1487 { 1488 tableHasCaption = true; 1489 1490 String frame; 1491 int sep; 1492 if ( tableHasGrid ) 1493 { 1494 frame = "all"; 1495 sep = 1; 1496 } 1497 else 1498 { 1499 frame = "none"; 1500 sep = 0; 1501 } 1502 1503 MutableAttributeSet att = new SimpleAttributeSet(); 1504 att.addAttribute( SimplifiedDocbookMarkup.FRAME_ATTRIBUTE, frame ); 1505 att.addAttribute( SimplifiedDocbookMarkup.ROWSEP_ATTRIBUTE, String.valueOf( sep ) ); 1506 att.addAttribute( SimplifiedDocbookMarkup.COLSEP_ATTRIBUTE, String.valueOf( sep ) ); 1507 1508 writeStartTag( TABLE_TAG, att ); 1509 1510 writeStartTag( SimplifiedDocbookMarkup.TITLE_TAG ); 1511 } 1512 1513 /** 1514 * {@inheritDoc} 1515 * 1516 * @see SimplifiedDocbookMarkup#TITLE_TAG 1517 */ 1518 public void tableCaption_() 1519 { 1520 writeEndTag( SimplifiedDocbookMarkup.TITLE_TAG ); 1521 } 1522 1523 /** 1524 * {@inheritDoc} 1525 * @see SimplifiedDocbookMarkup#ANCHOR_TAG 1526 */ 1527 public void anchor( String name ) 1528 { 1529 if ( name == null ) 1530 { 1531 throw new NullPointerException( "Anchor name cannot be null!" ); 1532 } 1533 1534 if ( authorDateFlag ) 1535 { 1536 return; 1537 } 1538 1539 String id = name; 1540 1541 if ( !DoxiaUtils.isValidId( id ) ) 1542 { 1543 id = DoxiaUtils.encodeId( name, true ); 1544 1545 String msg = "Modified invalid anchor name: '" + name + "' to '" + id + "'"; 1546 logMessage( "modifiedLink", msg ); 1547 } 1548 1549 MutableAttributeSet att = new SimpleAttributeSet(); 1550 att.addAttribute( ID_ATTRIBUTE, id ); 1551 1552 writeSimpleTag( SimplifiedDocbookMarkup.ANCHOR_TAG, att ); 1553 } 1554 1555 /** 1556 * {@inheritDoc} 1557 * 1558 * @see SimplifiedDocbookMarkup#ANCHOR_TAG 1559 */ 1560 public void anchor_() 1561 { 1562 comment( " anchor_end " ); 1563 } 1564 1565 /** 1566 * {@inheritDoc} 1567 * @see SimplifiedDocbookMarkup#ULINK_TAG 1568 * @see SimplifiedDocbookMarkup#URL_ATTRIBUTE 1569 * @see SimplifiedDocbookMarkup#LINK_TAG 1570 * @see SimplifiedDocbookMarkup#LINKEND_ATTRIBUTE 1571 */ 1572 public void link( String name ) 1573 { 1574 if ( name == null ) 1575 { 1576 throw new NullPointerException( "Link name cannot be null!" ); 1577 } 1578 1579 if ( DoxiaUtils.isInternalLink( name ) ) 1580 { 1581 String linkend = name.substring( 1 ); 1582 MutableAttributeSet att = new SimpleAttributeSet(); 1583 att.addAttribute( SimplifiedDocbookMarkup.LINKEND_ATTRIBUTE, escapeHTML( linkend ) ); 1584 1585 writeStartTag( SimplifiedDocbookMarkup.LINK_TAG, att ); 1586 } 1587 else 1588 { 1589 externalLinkFlag = true; 1590 MutableAttributeSet att = new SimpleAttributeSet(); 1591 att.addAttribute( SimplifiedDocbookMarkup.URL_ATTRIBUTE, escapeHTML( name, true ) ); 1592 1593 writeStartTag( SimplifiedDocbookMarkup.ULINK_TAG, att ); 1594 } 1595 } 1596 1597 /** 1598 * {@inheritDoc} 1599 * 1600 * @see SimplifiedDocbookMarkup#ULINK_TAG 1601 * @see SimplifiedDocbookMarkup#LINK_TAG 1602 */ 1603 public void link_() 1604 { 1605 if ( externalLinkFlag ) 1606 { 1607 writeEndTag( SimplifiedDocbookMarkup.ULINK_TAG ); 1608 externalLinkFlag = false; 1609 } 1610 else 1611 { 1612 writeEndTag( SimplifiedDocbookMarkup.LINK_TAG ); 1613 } 1614 } 1615 1616 /** 1617 * {@inheritDoc} 1618 */ 1619 public void inline() 1620 { 1621 inline( null ); 1622 } 1623 1624 /** {@inheritDoc} */ 1625 public void inline( SinkEventAttributes attributes ) 1626 { 1627 List<String> tags = new ArrayList<>(); 1628 1629 if ( attributes != null ) 1630 { 1631 1632 if ( attributes.containsAttribute( SinkEventAttributes.SEMANTICS, "italic" ) ) 1633 { 1634 markup( italicBeginTag ); 1635 tags.add( 0, italicEndTag ); 1636 } 1637 1638 if ( attributes.containsAttribute( SinkEventAttributes.SEMANTICS, "bold" ) ) 1639 { 1640 write( boldBeginTag ); 1641 tags.add( 0, boldEndTag ); 1642 } 1643 1644 if ( attributes.containsAttribute( SinkEventAttributes.SEMANTICS, "code" ) ) 1645 { 1646 if ( !authorDateFlag ) 1647 { 1648 write( monospacedBeginTag ); 1649 tags.add( 0, monospacedEndTag ); 1650 } 1651 } 1652 1653 } 1654 1655 inlineStack.push( tags ); 1656 } 1657 1658 /** 1659 * {@inheritDoc} 1660 */ 1661 public void inline_() 1662 { 1663 for ( String tag: inlineStack.pop() ) 1664 { 1665 markup( tag ); 1666 } 1667 } 1668 1669 /** 1670 * {@inheritDoc} 1671 */ 1672 public void italic() 1673 { 1674 inline( SinkEventAttributeSet.Semantics.ITALIC ); 1675 } 1676 1677 /** 1678 * {@inheritDoc} 1679 */ 1680 public void italic_() 1681 { 1682 inline_(); 1683 } 1684 1685 /** 1686 * {@inheritDoc} 1687 */ 1688 public void bold() 1689 { 1690 inline( SinkEventAttributeSet.Semantics.BOLD ); 1691 } 1692 1693 /** 1694 * {@inheritDoc} 1695 */ 1696 public void bold_() 1697 { 1698 inline_(); 1699 } 1700 1701 /** 1702 * {@inheritDoc} 1703 */ 1704 public void monospaced() 1705 { 1706 inline( SinkEventAttributeSet.Semantics.CODE ); 1707 } 1708 1709 /** 1710 * {@inheritDoc} 1711 */ 1712 public void monospaced_() 1713 { 1714 inline_(); 1715 } 1716 1717 /** 1718 * {@inheritDoc} 1719 */ 1720 public void lineBreak() 1721 { 1722 markup( lineBreakElement ); 1723 } 1724 1725 /** 1726 * {@inheritDoc} 1727 */ 1728 public void nonBreakingSpace() 1729 { 1730 markup( " " ); 1731 //markup( " " ); 1732 } 1733 1734 /** {@inheritDoc} */ 1735 public void text( String text ) 1736 { 1737 if ( verbatimFlag ) 1738 { 1739 verbatimContent( text ); 1740 } 1741 else 1742 { 1743 content( text ); 1744 } 1745 } 1746 1747 /** {@inheritDoc} */ 1748 public void comment( String comment ) 1749 { 1750 if ( comment != null ) 1751 { 1752 String originalComment = comment; 1753 1754 // http://www.w3.org/TR/2000/REC-xml-20001006#sec-comments 1755 while ( comment.contains( "--" ) ) 1756 { 1757 comment = comment.replace( "--", "- -" ); 1758 } 1759 1760 if ( comment.endsWith( "-" ) ) 1761 { 1762 comment += " "; 1763 } 1764 1765 if ( !originalComment.equals( comment ) ) 1766 { 1767 String msg = "Modified invalid comment: '" + originalComment + "' to '" + comment + "'"; 1768 logMessage( "modifiedComment", msg ); 1769 } 1770 1771 StringBuilder buffer = new StringBuilder( comment.length() + 7 ); 1772 1773 buffer.append( LESS_THAN ).append( BANG ).append( MINUS ).append( MINUS ); 1774 buffer.append( comment ); 1775 buffer.append( MINUS ).append( MINUS ).append( GREATER_THAN ); 1776 1777 markup( buffer.toString() ); 1778 } 1779 } 1780 1781 /** 1782 * {@inheritDoc} 1783 * 1784 * Unknown events just log a warning message but are ignored otherwise. 1785 * @see org.apache.maven.doxia.sink.Sink#unknown(String,Object[],SinkEventAttributes) 1786 */ 1787 public void unknown( String name, Object[] requiredParams, SinkEventAttributes attributes ) 1788 { 1789 String msg = "Unknown Sink event: '" + name + "', ignoring!"; 1790 logMessage( "unknownEvent", msg ); 1791 } 1792 1793 // ----------------------------------------------------------------------- 1794 1795 /** 1796 * Write text to output, preserving white space. 1797 * 1798 * @param text The text to write. 1799 */ 1800 protected void markup( String text ) 1801 { 1802 if ( !skip ) 1803 { 1804 out.write( text ); 1805 } 1806 } 1807 1808 /** 1809 * Write SGML escaped text to output, not preserving white space. 1810 * 1811 * @param text The text to write. 1812 */ 1813 protected void content( String text ) 1814 { 1815 if ( !skip ) 1816 { 1817 out.write( escapeHTML( text, true ) ); 1818 } 1819 } 1820 1821 /** 1822 * Write SGML escaped text to output, preserving white space. 1823 * 1824 * @param text The text to write. 1825 */ 1826 protected void verbatimContent( String text ) 1827 { 1828 if ( !skip ) 1829 { 1830 out.write( escapeHTML( text, true ) ); 1831 } 1832 } 1833 1834 // ----------------------------------------------------------------------- 1835 1836 /** 1837 * {@inheritDoc} 1838 */ 1839 public void flush() 1840 { 1841 out.flush(); 1842 } 1843 1844 /** 1845 * {@inheritDoc} 1846 */ 1847 public void close() 1848 { 1849 out.close(); 1850 1851 if ( getLog().isWarnEnabled() && this.warnMessages != null ) 1852 { 1853 for ( Map.Entry<String, Set<String>> entry : this.warnMessages.entrySet() ) 1854 { 1855 for ( String msg : entry.getValue() ) 1856 { 1857 getLog().warn( msg ); 1858 } 1859 } 1860 1861 this.warnMessages = null; 1862 } 1863 } 1864 1865 /** {@inheritDoc} */ 1866 protected void write( String text ) 1867 { 1868 markup( unifyEOLs( text ) ); 1869 } 1870 1871 /** 1872 * <p>Setter for the field <code>skip</code>.</p> 1873 * 1874 * @param skip the skip to set. 1875 * @since 1.1 1876 */ 1877 public void setSkip( boolean skip ) 1878 { 1879 this.skip = skip; 1880 } 1881 1882 /** 1883 * If debug mode is enabled, log the <code>msg</code> as is, otherwise add unique msg in <code>warnMessages</code>. 1884 * 1885 * @param key not null 1886 * @param msg not null 1887 * @see #close() 1888 * @since 1.1.1 1889 */ 1890 private void logMessage( String key, String msg ) 1891 { 1892 msg = "[Docbook Sink] " + msg; 1893 if ( getLog().isDebugEnabled() ) 1894 { 1895 getLog().debug( msg ); 1896 1897 return; 1898 } 1899 1900 if ( warnMessages == null ) 1901 { 1902 warnMessages = new HashMap<>(); 1903 } 1904 1905 Set<String> set = warnMessages.get( key ); 1906 if ( set == null ) 1907 { 1908 set = new TreeSet<>(); 1909 } 1910 set.add( msg ); 1911 warnMessages.put( key, set ); 1912 } 1913}