<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!--
  Licensed to the Apache Software Foundation (ASF) under one or more
  contributor license agreements.  See the NOTICE file distributed with
  this work for additional information regarding copyright ownership.
  The ASF licenses this file to You under the Apache License, Version 2.0
  (the "License"); you may not use this file except in compliance with
  the License.  You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
-->
<!-- $Id$ -->
<!DOCTYPE document PUBLIC "-//APACHE//DTD Documentation V1.3//EN" "http://forrest.apache.org/dtd/document-v13.dtd">
<document>
  <header>
    <title>Apache™ FOP: Mailing List Resources</title>
    <version>$Revision$</version>
  </header>
  <body>
    <section id="general">
      <title>General Information</title>
      <p>Before posting questions to any list:</p>
      <ul>
        <li>Review the <jump href="http://jakarta.apache.org/site/mail.html">Jakarta Mailing Lists - Guidelines</jump> for general principles about mailing lists.</li>
        <li>Review "<jump href="http://www.catb.org/~esr/faqs/smart-questions.html">How To Ask Questions The Smart Way</jump>".</li>
        <li>Send only <em>plain text</em> email messages to any mailing lists.
Please do <em>not</em> send html or rtf email, as they do not work well with the archive engines.
If you are using Microsoft Outlook, this setting can be found at the "Mail Format" tab of the Tools/Options menu.</li>
        <li>Use a mail client that respects the <em>References</em> and/or <em>In-Reply-To</em> mail header entries. This is important for mail clients that can display threads as trees. <strong>Compliant mail clients</strong> include Microsoft Outlook, Becky!, KMail, Apple Mail, Ximian Evolution, Mozilla (version 1.2 or greater). Non-compliant mail clients include Microsoft Exchange, Lotus Notes, Internet Mail Service (MUA or MTA), and dtmail.</li>
      </ul>
      <p>For help in understanding email acronyms, see the <jump href="http://www.lingo2word.com/lists/acronym_listA.html">Lingo2Word Acronym List</jump>, or the <jump href="http://www.keno.org/web_design/acronyms.htm">Keno Internet Services Internet Glossary</jump>.</p>
    </section>
    <section id="fop-user">
      <title>Apache™ FOP Users Mailing List</title>
      <p>Use this forum to discuss topics of interest to FOP users.</p>
      <section id="fop-user-archive">
        <title>Archives</title>
        <p>To review the archives, you have several options:</p>
        <ul>

          <li>The <link href="http://mail-archives.apache.org/mod_mbox/xmlgraphics-fop-users/">Apache Mailing List archive</link> (mod_mbox archive, no full-text search, yet).</li>
          <li>The <link href="http://xmlgraphics.apache.org/mail/fop-users/">Apache Mailing List archive</link> (gzipped mbox files).</li>
          <li>The <jump href="http://marc.theaimsgroup.com/?l=fop-user&amp;r=1&amp;w=2">Mailing list ARChives </jump> (MARC) at the AIMS group.</li>
          <li><jump href="http://www.mail-archive.com/fop-users%40xmlgraphics.apache.org/">The Mail Archive</jump>.</li>
          <li>The <jump href="http://dir.gmane.org/gmane.text.xml.fop.user">GMANE archive</jump>.</li>
          <li>The <jump href="http://apache-fop.1065347.n5.nabble.com/FOP-Users-f3.html">Nabble archive</jump> (only posts after May 2005).</li>
          <li>The <jump href="http://fop-users.markmail.org/">MarkMail archive</jump>.</li>
        </ul>
        <note>
          If you don't like mailing lists and prefer a forum-like system, have a look at
          <jump href="http://dir.gmane.org/gmane.text.xml.fop.user">GMANE</jump> or
          <jump href="http://www.nabble.com/FOP---Users-f353.html">Nabble</jump>. They
          allow you to post to the mailing list without having to subscribe.
        </note>
      </section>
      <section id="fop-user-subscribe">
        <title>Subscription Information</title>
        <ul>
          <li>See <link href="http://xmlgraphics.apache.org/mail.html">Apache XML Graphics Mailing Lists</link> for detailed subscription information.</li>
          <li>To subscribe (digest only): Send email to <link href="mailto:fop-users-digest-subscribe@xmlgraphics.apache.org">fop-users-digest-subscribe@xmlgraphics.apache.org</link>.</li>
          <li>To <strong>subscribe</strong> fully: Send email to <link href="mailto:fop-users-subscribe@xmlgraphics.apache.org">fop-users-subscribe@xmlgraphics.apache.org</link>.</li>
          <li>To receive information about the mailing list: Send email to <link href="mailto:fop-users-help@xmlgraphics.apache.org">fop-users-help@xmlgraphics.apache.org</link>.</li>
          <li>To <strong>unsubscribe</strong>: Send email to <link href="mailto:fop-users-unsubscribe@xmlgraphics.apache.org">fop-users-unsubscribe@xmlgraphics.apache.org</link>.</li>
        </ul>
      </section>
      <note>You can find the developer mailing list on the <link href="dev/index.html#mail-fop-dev">Development pages</link>.</note>
      <section id="fop-user-policy">
        <title>Submitting a Question</title>
        <p>FOP support is primarily <em>self-service</em>. The FOP User Mailing List serves as a backup to the self-service documentation for cases where either the documentation is deficient or where users have unusual circumstances. FOP developers and users are happy to help answer questions that are <em>appropriate to the forum</em> (i.e. FOP-specific), and that are <em>submitted after appropriate preparation</em>. To ensure that your question is not <strong>abusive</strong> of this policy, please use the following checklist:</p>
        <ul>
          <li>Have you followed the <link href="gethelp.html">Getting Help</link> checklist? If not, please do so before submitting your question.</li>
          <li>Is your question appropriate to the forum? If it is really an XSL-FO question, XSLT question, or PDF question, please see the other resources on this page that are intended to help you get those questions answered.</li>
          <li>Have you read <link href="#general">Mailing List General Information</link>? If not please do so before proceeding.</li>
          <li>Have you stated the version of FOP you are using? Please do so. Usually, it's a good idea to state the JDK/JRE version and the operating system you're using, too.</li>
          <li>Have you included any detailed error messages? Please do so.</li>
          <li>Does a proper understanding of your question require inclusion of XSLT code, DocBook
            source, or other semantic XML? If so, the question is <em>almost certainly not
              appropriate to this list</em>. In general, the only input documents that are
            appropriate on this list are XSL-FO snippets. See <link
              href="1.1rc1/running.html#check-input">Running Xalan</link> for instructions about capturing the XSL-FO document that is actually submitted to FOP. If you haven't examined the XSL-FO document yourself, then you are not yet prepared to formulate a FOP-specific question.</li>
          <li>If you are providing one or more XSL-FO snippets:
            <ul>
              <li>Have you reduced them to the shortest possible complete, <strong>self-contained</strong> document that demonstrates the problem? Please do so.</li>
              <li>Have you removed images that are not an integral part of the question? Please do so.</li>
              <li>Have you filtered out confidential material? Please do so.</li>
            </ul>
          </li>
          <li>If you are including a stack trace:
            <ul>
              <li>Is it helpful in finding the problem? If not, please do not submit it.</li>
              <li>Have you included only those portions that are relevant to the question? If not, please do so.</li>
            </ul>
          </li>
          <li>Are you attaching large PDF files or screen shots to your message? If so, please consider attaching a minimal, appropriate B&amp;W GIF, JPG or PNG that conveys the necessary information instead. A good alternative is to put the files on a web server.</li>
        </ul>
      </section>
    </section>
    <section id="w3c-xslfo">
      <title>XSL-FO Mailing List (at W3C)</title>
      <p>Use this forum to ask general XSL-FO questions.</p>
      <ul>
        <li>To review the archive: <jump href="http://lists.w3.org/Archives/Public/www-xsl-fo/">W3C XSL-FO Archives</jump>.</li>
        <li>Before posting questions to any list, see "<link href="#general">General Information</link>".</li>
        <li>Subscription administration information can be found at <jump href="http://www.w3.org/Mail/Request">W3C Mailing List Administrativia</jump>.
After reviewing the instructions there, send your subscribe or unsubscribe request to <link href="mailto:www-xsl-fo-request@w3.org">www-xsl-fo-request@w3.org</link>.</li>
      </ul>
    </section>
    <section id="yahoogroups-xslfo">
      <title>XSL-FO Mailing List (at YahooGroups)</title>
      <p>Use this forum to ask general XSL-FO questions.</p>
      <ul>
        <li>Before posting questions to any list, see "<link href="#general">General Information</link>".</li>
        <li>The home page for this groups is <jump href="http://groups.yahoo.com/group/XSL-FO">XSL-FO - discussion of XSL Formatting Objects</jump>.</li>
      </ul>
    </section>
    <section id="xslt-mulberry">
      <title>XSLT List (Mulberry Tech)</title>
      <ul>
        <li>Before posting questions to any list, see "<link href="#general">General Information</link>".</li>
        <li>Information for using and subscribing can be found at <jump href="http://www.mulberrytech.com/xsl/xsl-list">XSL-List -- Open Forum on XSL</jump>.</li>
      </ul>
    </section>
  </body>
</document>
