<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="de" lang="de"><head>
	<title>Apache OpenOffice: Ben&ouml;tigen Sie Hilfe?</title>

<!-- Start de-header -->
	<link rel="stylesheet" href="styles/de.css" media="screen" type="text/css" />
	<link rel="stylesheet" href="styles/de_print.css" media="print" type="text/css" />
	<link rel="alternate stylesheet" title="ohne Navbar" media="screen" href="styles/de_nonavbar.css" type="text/css" />
	<meta http-equiv="Content-Style-Type" content="text/css" />
	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
	<style type="text/css">
        	/*<![CDATA[*/
        	<!--
        	@import url("styles/de_navbar6.css");
        	-->
        	/*]]>*/
        </style>

<!-- End de-header -->

<!-- >
Kommentare zur Seite
$Id: probleme.html,v 1.22 2008/09/27 22:30:35 mbayer Exp $
< -->
</head>

<body dir="ltr">
<!-- Start Navbar -->
	<!-- >
	Kommentare zur Navbar Wo Hilfe nahe ist
	Makemapversion:
	$Id: makemap.pl,v 1.8 2006/08/15 06:52:27 markomlm Exp :
	navbar_Support ,V 0.5.6 Dienstag, 03. April 2007 23:14:37 _mlm
	< -->
<ul id="navbar_de">
    <li><div >de-links</div></li>
    <li> <a href="index.html" title=" "> Hauptseite </a></li>
    <li> <a href="map_all.html" title=" "> Sitemap </a></li>
    <li> <a href="neuhier.html" title="Informationen zu OpenOffice, dem Softwareprodukt"> Produkt-Info </a></li>
    <li> <a href="kontakt.html" title="Informationen zu OpenOffice, der Community"> Projekt-Info </a></li>
    <li> <a href="downloads/quick.html" title="Software und mehr"> Download </a></li>
    <li> <a href="doc/index.html" title="Installationsbeschreibungen und mehr Schriftliches"> Dokumentationen </a></li>
    <li> <a href="doc/faq/index.html" title="FAQ- H&auml;ufig gestellte Fragen"> FAQ </a></li>
    <li>Support
      <ul>
      <li> Probleme? </li>
      <li> <a href="about-ooo/about-users-mailinglist.html" title="Auf den Mailinglisten von OpenOffice.org kann jede Frage eine Antwort finden."> Mailingliste </a></li>
      <li> <a href="foren.html" title="Deutsch- und englischsprachige Hilfe im WWW und USENET"> Foren und Newsgroups </a></li>
      <li> <a href="about-ooo/about-support.html" title="In der Regel kostenpflichtiger, umfassender Support"> Professioneller Support </a></li>
      <li> <a href="bildung/index.html" title="Bildungsportal Infos f&uuml;r Schulen, Volkshochschulen und zum ECDL"> Bildungsportal </a></li>
      </ul>
    </li>
    <li> <a href="doc/howto/index.html" title="Knappe Anleitungen f&uuml;r die erste Benutzung"> Erste Schritte </a></li>
    <li> <a href="marketing/index.html" title="Materialien und mehr"> Marketing </a></li>
    <li> <a href="presse/about-presskit.html" title="Pressemitteilungen, Interviews und andere Informationen"> Presse </a></li>
    <li> <a href="dev/index.html" title="Informationen f&uuml;r Mitglieder im de.OpenOffice.org Projekt"> Mithelfen </a></li>
</ul>
<!-- End Navbar -->

<div id="body_de">
<h2>Ben&ouml;tigen Sie Hilfe oder haben Sie ein Problem?</h2>

<h3>Fragen zur Anwendung des Programms</h3>

<p>Sie haben eine Frage oder wissen <abbr title="zum Beispiel">z. B.</abbr> nicht, wie Sie eine Funktion in einer Komponente von OpenOffice aufrufen k&ouml;nnen? Oder Sie haben ein Verhalten festgestellt, das Sie sich nicht erkl&auml;ren k&ouml;nnen? </p>
<p>Antworten finden Sie möglicherweise in den Handbüchern, die wir im <a href="./doc/">Dokumentationsportal</a> für Sie bereithalten. Eine Reihe häufig auftretender Fragen und Probleme haben wir außerdem in den entsprechenden <a href="https://wiki.openoffice.org/wiki/DE/FAQ"><acronym xml:lang="en" lang="en" title="Frequently Asked Questions">FAQs</acronym></a> beantwortet. Eine weitere informative Quelle ist das <a href="http://www.ooowiki.de/">OpenOffice.org-Wiki</a>, auch hier finden Sie eine Fülle von Material.
</p>
<p>Ließ sich Ihr Problem mit diesen Hilfen nicht lösen, dann stellen Sie Ihre Frage am besten auf der Anwender-Mailingliste. Auf dieser Liste helfen Anwender anderen Anwendern <em>auf freiwilliger Basis</em>, denn OpenOffice ist keine kommerzielle Software und bietet damit keinen eigenen kommerziellen Support.
</p>
<p>
Sie sollten sich anmelden, bevor Sie Ihre Frage stellen, damit Sie auch über alle eingehenden Antworten informiert werden:
</p>
<ul>
	<li>Senden Sie bitte eine E-Mail an <a href="mailto:users-de-subscribe@openoffice.apache.org">users-de-subscribe@openoffice.apache.org</a>.</li>
	<li>Sie erhalten daraufhin eine Bestätigungsmail (auf Englisch), die Sie einfach mit der Antwort-Funktion Ihres E-Mail-Programms beantworten, um die Anmeldung abzuschließen (<abbr title="so genanntes">sog.</abbr> <i xml:lang="en" lang="en">Double Opt-In</i>).</li>
</ul>
<p>Fragen k&ouml;nnen Sie nun an die Mitglieder der Mailingliste richten, indem Sie eine E-Mail mit einem m&ouml;glichst aussagekr&auml;ftigen Betreff an <a href="mailto:users-de@openoffice.apache.org">users-de@openoffice.apache.org</a> senden.
</p>
<p>Um sich wieder von der Mailingliste abzumelden, gehen Sie bitte wie folgt vor:
</p>
<ul>
	<li>Senden Sie eine Mail an <a href="mailto:users-de-unsubscribe@openoffice.apache.org">users-de-unsubscribe@openoffice.apache.org</a> (mit der selben E-Mail-Adresse, die Sie für die Anmeldung verwendet hatten).</li>
	<li>Sie erhalten daraufhin eine Bestätigungsmail (auf Englisch), die Sie einfach mit der Antwort-Funktion Ihres E-Mail-Programms beantworten, um die Abmeldung abzuschließen (<abbr title="so genanntes">sog.</abbr> <i xml:lang="en" lang="en">Double Opt-Out</i>).</li>
</ul>
<p>Weitere Hinweise zur Anwender-Mailingliste finden Sie auf der Seite <a href="./about-ooo/about-users-mailinglist.html">Hilfe per Mail</a>.
</p>
<p>
<strong>Wichtige Hinweise für die Benutzung von Mailinglisten auf OpenOffice.org:</strong>
<br />Sie erhalten nach der Anmeldung <em>alle an die Liste geschickten Beiträge</em> aller Benutzer. Wenn Sie diese Mitteilungen nicht mehr erhalten möchten, melden Sie sich bitte selbst wieder von der Liste ab (<abbr title="siehe oben">s.o.</abbr>).
<br/><em>Die Mailinglisten sind öffentlich.</em> Eine an die Liste gerichtete E-Mail wird automatisch im Internet veröffentlicht und archiviert, ohne dass das Projekt dies steuern oder beeinflussen könnte. Wenn Sie eine Nachricht an die Liste senden, stimmen Sie damit deren Ver&ouml;ffentlichung zu! Vermeiden Sie deshalb bitte die Angabe persönlicher Daten wie Telefonnummer oder Adresse im Text <abbr title="beziehungsweise">bzw.</abbr> in der Signatur der Nachricht, wenn Sie nicht wollen, dass diese Angaben mitveröffentlicht werden und damit auch von Internetsuchmaschinen gefunden werden können.
</p>

<h3>Fragen zur Entwicklung und zur Mitarbeit</h3>

<p>Sie haben eine Frage, die nicht die Anwendung des Programms betrifft, sondern eher in den Bereich Entwicklung zielt? Oder Sie sind an einer aktiven Mitarbeit interessiert? Dann melden Sie sich bitte auf der Entwickler-Mailingliste; über diese Liste werden die Tätigkeiten des deutschsprachigen Projektes von OpenOffice koordiniert.
</p>
<ul>
	<li>Melden Sie sich an, indem Sie eine E-Mail an <a href="mailto:dev-de-subscribe@openoffice.apache.org">dev-de-subscribe@openoffice.apache.org</a> senden und die Bestätigungsmail beantworten (<i xml:lang="en" lang="en">Double Opt-In</i>).</li>
	<li>Senden Sie Ihre Fragen oder Anregungen an <a href="mailto:dev-de@openoffice.apache.org">dev-de@openoffice.apache.org</a>.</li>
	<li>Zum Abmelden senden Sie eine Mail an <a href="mailto:dev-de-unsubscribe@openoffice.apache.org">dev-de-unsubscribe@openoffice.apache.org</a> und beantworten Sie die Bestätigungsmail.</li>
</ul>

<p>Weitere Informationen für Interessenten haben wir auf der Seite <a href="./dev/">Informationen für Mitwirkende</a> zusammengestellt.</p>

<h3>Bücher</h3>

<p>Wenn Sie sich lieber aus Gedrucktem informieren, haben wir auf der Seite <a href="./about-ooo/about-literatur.html">Literatur</a> eine Liste von Publikationen zusammengestellt, die sich mit OpenOffice beschäftigen.
</p>

<h3>Weitere Informationsquellen</h3>

<ul>
	<li>Eine Liste mit Webforen zum Thema OpenOffice haben wir auf der Seite <a href="./foren.html">Foren und Newsgroups</a> zusammengestellt.</li>
	<li>Eine Liste mit kommerziellen Anbietern von Support-Dienstleistungen erreichen Sie über die Seite <a href="./about-ooo/about-support.html">Professioneller Support</a> (die Liste beruht auf Selbsteintrag).</li>
	<li>Englischsprachige Dokumentationen hält das <a  xml:lang="en" lang="en" href="https://documentation.openoffice.org/" hreflang="en">Documentation Project</a> bereit.</li>
</ul>
<p>Bitte beachten Sie auch die Links in der rechten Navigationsleiste („de-Links“).
</p>

</div>

<p><a href="https://validator.w3.org/check?uri=referer"><img src="https://www.w3.org/Icons/valid-xhtml10-blue" alt="Valid XHTML 1.0 Transitional" /></a></p>

</body>
</html>
